update: remove ec_timestamp_get_time_us api, using ec_timestamp_get_time_ns for all

Signed-off-by: sakumisu <1203593632@qq.com>

include/ec_datagram.h

@@ -57,8 +57,8 @@ typedef struct {
     ec_datagram_state_t state;        /**< State. */
     uint32_t lrw_read_offset;         /**< Read Offset in LRW datagram. */
     uint32_t lrw_read_size;           /**< Read Size in LRW datagram. */
-    uint64_t jiffies_sent;            /**< Jiffies, when the datagram was sent. */
-    uint64_t jiffies_received;        /**< Jiffies, when the datagram was received. */
+    uint64_t jiffies_sent;            /**< Jiffies [ns], when the datagram was sent. */
+    uint64_t jiffies_received;        /**< Jiffies [ns], when the datagram was received. */
     char name[EC_DATAGRAM_NAME_SIZE]; /**< Description of the datagram. */
     bool waiter;                      /**< True, if someone is waiting for the datagram. */
     ec_osal_sem_t wait;               /**< Semaphore for waiting. */

include/ec_mailbox.h

@@ -17,12 +17,12 @@ int ec_mailbox_send(ec_master_t *master,
 int ec_mailbox_read_status(ec_master_t *master,
                            uint16_t slave_index,
                            ec_datagram_t *datagram,
-                           uint32_t timeout_us);
+                           uint64_t timeout_ns);
 int ec_mailbox_receive(ec_master_t *master,
                        uint16_t slave_index,
                        ec_datagram_t *datagram,
                        uint8_t *type,
                        uint32_t *size,
-                       uint32_t timeout_us);
+                       uint64_t timeout_ns);
 
 #endif

include/ec_netdev.h

@@ -28,7 +28,7 @@ typedef struct {
     int32_t tx_byte_rates[EC_RATE_COUNT];  /**< Transmit rates in byte/s for different statistics cycle periods. */
     int32_t rx_byte_rates[EC_RATE_COUNT];  /**< Receive rates in byte/s for different statistics cycle periods. */
     int32_t loss_rates[EC_RATE_COUNT];     /**< Frame loss rates for different statistics cycle periods. */
-    uint64_t last_jiffies;                 /**< Jiffies of last statistic cycle. */
+    uint64_t last_jiffies;                 /**< Jiffies of last statistic cycle [ns]. */
 } ec_netdev_stats_t;
 
 typedef struct ec_netdev {

include/ec_timestamp.h

@@ -8,8 +8,7 @@
 
 void ec_timestamp_init(void);
 uint64_t ec_timestamp_get_time_ns(void);
-uint64_t ec_timestamp_get_time_us(void);
 
-#define jiffies ec_timestamp_get_time_us()
+#define jiffies ec_timestamp_get_time_ns()
 
 #endif

port/netdev_renesas.c

@@ -457,9 +457,4 @@ EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_ns(void)
 {
     return (uint64_t)(gpt_get_count() * 5ULL);
 }
-
-EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_us(void)
-{
-    return ec_timestamp_get_time_ns() / 1000ULL;
-}
 #endif

src/ec_coe.c

@@ -41,7 +41,7 @@ typedef ec_coe_download_segment_header_t ec_coe_upload_segment_header_t;
  */
 #define EC_COE_DOWN_SEG_MIN_DATA_SIZE 7
 
-#define EC_COE_TIMEOUT_US (1000 * 1000) /* 1s */
+#define EC_COE_TIMEOUT_NS (1000 * 1000 * 1000ULL) /* 1s */
 
 static int ec_coe_download_expedited(ec_master_t *master,
                                      uint16_t slave_index,
@@ -80,7 +80,7 @@ static int ec_coe_download_expedited(ec_master_t *master,
         return ret;
     }
 
-    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_US);
+    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_NS);
     if (ret < 0) {
         return ret;
     }
@@ -148,7 +148,7 @@ static int ec_coe_download_common(ec_master_t *master,
         return ret;
     }
 
-    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_US);
+    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_NS);
     if (ret < 0) {
         return ret;
     }
@@ -224,7 +224,7 @@ static int ec_coe_download_segment(ec_master_t *master,
         return ret;
     }
 
-    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_US);
+    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_NS);
     if (ret < 0) {
         return ret;
     }
@@ -366,7 +366,7 @@ int ec_coe_upload(ec_master_t *master,
         return ret;
     }
 
-    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_US);
+    ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_NS);
     if (ret < 0) {
         return ret;
     }
@@ -461,7 +461,7 @@ int ec_coe_upload(ec_master_t *master,
                     return ret;
                 }
 
-                ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_US);
+                ret = ec_mailbox_receive(master, slave_index, datagram, &mbox_proto, &recv_size, EC_COE_TIMEOUT_NS);
                 if (ret < 0) {
                     return ret;
                 }

src/ec_mailbox.c

@@ -5,8 +5,6 @@
  */
 #include "ec_master.h"
 
-#define EC_MBOX_READ_TIMEOUT (100 * 1000)
-
 uint8_t *ec_mailbox_fill_send(ec_master_t *master,
                               uint16_t slave_index,
                               ec_datagram_t *datagram,
@@ -50,7 +48,7 @@ int ec_mailbox_send(ec_master_t *master,
 int ec_mailbox_read_status(ec_master_t *master,
                            uint16_t slave_index,
                            ec_datagram_t *datagram,
-                           uint32_t timeout_us)
+                           uint64_t timeout_ns)
 {
     ec_slave_t *slave;
     uint64_t start_time;
@@ -74,7 +72,7 @@ check_again:
     }
 
     if (!(EC_READ_U8(datagram->data + 5) & ESC_SYNCM_STATUS_MBX_MODE_MASK)) {
-        if ((jiffies - start_time) > timeout_us) {
+        if ((jiffies - start_time) > timeout_ns) {
             return -EC_ERR_MBOX_EMPTY;
         }
         goto check_again;
@@ -88,7 +86,7 @@ int ec_mailbox_receive(ec_master_t *master,
                        ec_datagram_t *datagram,
                        uint8_t *type,
                        uint32_t *size,
-                       uint32_t timeout_us)
+                       uint64_t timeout_ns)
 {
     ec_slave_t *slave;
     uint16_t code;
@@ -102,7 +100,7 @@ int ec_mailbox_receive(ec_master_t *master,
 
     slave = &master->slaves[slave_index];
 
-    ret = ec_mailbox_read_status(master, slave_index, datagram, timeout_us);
+    ret = ec_mailbox_read_status(master, slave_index, datagram, timeout_ns);
     if (ret < 0) {
         return ret;
     }

src/ec_master.c

@@ -5,7 +5,7 @@
  */
 #include "ec_master.h"
 
-#define EC_DATAGRAM_TIMEOUT_US (50 * 1000) // 50ms
+#define EC_DATAGRAM_TIMEOUT_NS (50 * 1000 * 1000ULL) // 50ms
 
 static void ec_master_period_process(void *arg);
 
@@ -146,6 +146,7 @@ EC_FAST_CODE_SECTION void ec_master_receive_datagrams(ec_master_t *master,
     uint8_t datagram_type, datagram_index;
     uint32_t cmd_follows, matched;
     const uint8_t *cur_data;
+    uint64_t jiffies_received;
     uint32_t datagram_count;
     ec_datagram_t *datagram;
 
@@ -156,6 +157,8 @@ EC_FAST_CODE_SECTION void ec_master_receive_datagrams(ec_master_t *master,
         return;
     }
 
+    jiffies_received = jiffies;
+
     cur_data = frame_data;
 
     // check length of entire frame
@@ -171,6 +174,7 @@ EC_FAST_CODE_SECTION void ec_master_receive_datagrams(ec_master_t *master,
 
     datagram_count = 0;
     cmd_follows = 1;
+
     while (cmd_follows) {
         // process datagram header
         datagram_type = EC_READ_U8(cur_data);
@@ -229,7 +233,7 @@ EC_FAST_CODE_SECTION void ec_master_receive_datagrams(ec_master_t *master,
 
         // dequeue the received datagram
         datagram->state = EC_DATAGRAM_RECEIVED;
-        datagram->jiffies_received = jiffies;
+        datagram->jiffies_received = jiffies_received;
         ec_master_unqueue_datagram(master, datagram);
 
         datagram_count++;
@@ -253,7 +257,7 @@ EC_FAST_CODE_SECTION static void ec_master_send(ec_master_t *master)
         if (datagram->state != EC_DATAGRAM_SENT)
             continue;
 
-        if ((jiffies - datagram->jiffies_sent) > EC_DATAGRAM_TIMEOUT_US) {
+        if ((jiffies - datagram->jiffies_sent) > EC_DATAGRAM_TIMEOUT_NS) {
             datagram->state = EC_DATAGRAM_TIMED_OUT;
             ec_master_unqueue_datagram(master, datagram);
             master->stats.timeouts++;

src/ec_netdev.c

@@ -20,7 +20,7 @@ EC_FAST_CODE_SECTION void ec_netdev_update_stats(ec_netdev_t *netdev)
 {
     unsigned int i;
 
-    if ((jiffies - netdev->stats.last_jiffies) < 1000000) {
+    if ((jiffies - netdev->stats.last_jiffies) < 1000000000ULL) {
         return;
     }
 

src/ec_sii.c

@@ -5,7 +5,7 @@
  */
 #include "ec_master.h"
 
-#define SII_TIMEOUT_US (200 * 1000) // 200ms
+#define SII_TIMEOUT_NS (200 * 1000 * 1000ULL) // 200ms
 
 static int ec_sii_assign_master(ec_slave_t *slave, ec_datagram_t *datagram)
 {
@@ -57,7 +57,7 @@ sii_check:
     }
 
     if (EC_READ_U16(datagram->data) & ESC_EEPROM_CTRL_STAT_BUSY_MASK) {
-        if ((jiffies - start_time) > SII_TIMEOUT_US) {
+        if ((jiffies - start_time) > SII_TIMEOUT_NS) {
             return -EC_ERR_TIMEOUT;
         }
         goto sii_check;
@@ -102,7 +102,7 @@ sii_check:
     }
 
     if (EC_READ_U16(datagram->data) & ESC_EEPROM_CTRL_STAT_BUSY_MASK) {
-        if ((jiffies - start_time) > SII_TIMEOUT_US) {
+        if ((jiffies - start_time) > SII_TIMEOUT_NS) {
             return -EC_ERR_TIMEOUT;
         }
         goto sii_check;

src/ec_slave.c

@@ -105,32 +105,32 @@ errorout1:
     return ret;
 }
 
-/** Get timeout in us.
+/** Get timeout in ns.
  *
  * For defaults see ETG2000_S_R_V1i0i15 section 5.3.6.2.
  */
-unsigned int ec_slave_state_change_timeout_us(ec_slave_state_t old_state, ec_slave_state_t requested_state)
+static uint64_t ec_slave_state_change_timeout_ns(ec_slave_state_t old_state, ec_slave_state_t requested_state)
 {
     ec_slave_state_t from = old_state;
     ec_slave_state_t to = requested_state;
 
     if (from == EC_SLAVE_STATE_INIT &&
         (to == EC_SLAVE_STATE_PREOP || to == EC_SLAVE_STATE_BOOT)) {
-        return (3000 * 1000); // PreopTimeout
+        return (3000 * 1000 * 1000ULL); // PreopTimeout
     }
     if ((from == EC_SLAVE_STATE_PREOP && to == EC_SLAVE_STATE_SAFEOP) ||
         (from == EC_SLAVE_STATE_SAFEOP && to == EC_SLAVE_STATE_OP)) {
-        return (10000 * 1000); // SafeopOpTimeout
+        return (10000 * 1000 * 1000ULL); // SafeopOpTimeout
     }
     if (to == EC_SLAVE_STATE_INIT ||
         ((from == EC_SLAVE_STATE_OP || from == EC_SLAVE_STATE_SAFEOP) && to == EC_SLAVE_STATE_PREOP)) {
-        return (5000 * 1000); // BackToInitTimeout
+        return (5000 * 1000 * 1000ULL); // BackToInitTimeout
     }
     if (from == EC_SLAVE_STATE_OP && to == EC_SLAVE_STATE_SAFEOP) {
-        return (200 * 1000); // BackToSafeopTimeout
+        return (200 * 1000 * 1000ULL); // BackToSafeopTimeout
     }
 
-    return (10000 * 1000); // default [us]
+    return (10000 * 1000 * 1000ULL); // default [ns]
 }
 
 static uint8_t ec_slave_get_previous_port(const ec_slave_t *slave, uint8_t port_index)
@@ -218,7 +218,7 @@ static ec_slave_t *ec_slave_find_next_dc_slave(ec_slave_t *slave)
     return dc_slave;
 }
 
-void ec_slave_calc_port_delays(ec_slave_t *slave)
+static void ec_slave_calc_port_delays(ec_slave_t *slave)
 {
     uint8_t port_index;
     ec_slave_t *next_slave, *next_dc;
@@ -330,7 +330,7 @@ repeat_check:
             return -EC_ERR_ALERR;
         }
     } else {
-        if ((jiffies - start_time) > ec_slave_state_change_timeout_us(slave->current_state, requested_state)) {
+        if ((jiffies - start_time) > ec_slave_state_change_timeout_ns(slave->current_state, requested_state)) {
             return -EC_ERR_TIMEOUT;
         }
         goto repeat_check;
@@ -387,7 +387,7 @@ repeat_check:
             return ec_slave_state_clear_ack_error(slave, requested_state);
         } else {
             old_state = slave->current_state;
-            if ((jiffies - start_time) > ec_slave_state_change_timeout_us(slave->current_state, requested_state)) {
+            if ((jiffies - start_time) > ec_slave_state_change_timeout_ns(slave->current_state, requested_state)) {
                 return -EC_ERR_TIMEOUT;
             }
             goto repeat_check;
@@ -395,7 +395,7 @@ repeat_check:
     }
 
     // still in old state
-    if ((jiffies - start_time) > ec_slave_state_change_timeout_us(slave->current_state, requested_state)) {
+    if ((jiffies - start_time) > ec_slave_state_change_timeout_ns(slave->current_state, requested_state)) {
         return -EC_ERR_TIMEOUT;
     }
     goto repeat_check;
@@ -1372,7 +1372,7 @@ void ec_slaves_scanning(ec_master_t *master)
             }
         }
 
-        EC_LOG_INFO("Bus scanning completed in %u ms\n", (unsigned int)((jiffies - scan_jiffies) / 1000));
+        EC_LOG_INFO("Bus scanning completed in %u ms\n", (unsigned int)((jiffies - scan_jiffies) / 1000000));
         master->scan_done = true;
 
         ec_master_calc_dc(master);

src/ec_timestamp.c

@@ -34,10 +34,10 @@ void ec_timestamp_init(void)
 {
     g_clock_time_div = ec_get_cpu_frequency() / 1000000;
 
-    uint64_t start_cycle = ec_timestamp_get_time_us();
+    uint64_t start_cycle = ec_timestamp_get_time_ns();
     ec_osal_msleep(10);
 
-    EC_ASSERT_MSG((ec_timestamp_get_time_us() - start_cycle) >= 9000, "Timestamp timer not running\n");
+    EC_ASSERT_MSG((ec_timestamp_get_time_ns() - start_cycle) >= 9000000, "Timestamp timer not running\n");
 }
 
 EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_ns(void)
@@ -45,10 +45,6 @@ EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_ns(void)
     return (riscv_csr_get_core_mcycle() * 1000) / g_clock_time_div;
 }
 
-EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_us(void)
-{
-    return riscv_csr_get_core_mcycle() / g_clock_time_div;
-}
 #elif defined(__arm__) || defined(__ICCARM__) || defined(__ARMCC_VERSION)
 
 #define DWT_CR     (*(volatile uint32_t *)0xE0001000)
@@ -87,22 +83,16 @@ void ec_timestamp_init(void)
 
     DWT_CR |= (uint32_t)DWT_CR_CYCCNTENA;
 
-    uint64_t start_cycle = ec_timestamp_get_time_us();
+    uint64_t start_cycle = ec_timestamp_get_time_ns();
     ec_osal_msleep(10);
 
-    EC_ASSERT_MSG((ec_timestamp_get_time_us() - start_cycle) >= 9000, "Timestamp timer not running\n");
+    EC_ASSERT_MSG((ec_timestamp_get_time_ns() - start_cycle) >= 9000000, "Timestamp timer not running\n");
 }
 
 EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_ns(void)
 {
     return (arm_dwt_get_cycle_count() * 1000) / g_clock_time_div;
 }
-
-EC_FAST_CODE_SECTION uint64_t ec_timestamp_get_time_us(void)
-{
-    return arm_dwt_get_cycle_count() / g_clock_time_div;
-}
-
 #else
 #error "Unsupported architecture"
 #endif