git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@2808 35acf78f-673a-0410-8e92-d51de3d6d3f4

1 files changed, 40 insertions, 40 deletions

diff --git a/os/hal/src/can.c b/os/hal/src/can.c
index d63cbfd8a..c240c9e44 100644
--- a/os/hal/src/can.c
+++ b/os/hal/src/can.c
@@ -67,17 +67,17 @@ void canInit(void) {
  */

 void canObjectInit(CANDriver *canp) {

 

-  canp->cd_state    = CAN_STOP;

-  canp->cd_config   = NULL;

-  chSemInit(&canp->cd_txsem, 0);

-  chSemInit(&canp->cd_rxsem, 0);

-  chEvtInit(&canp->cd_rxfull_event);

-  chEvtInit(&canp->cd_txempty_event);

-  chEvtInit(&canp->cd_error_event);

-  canp->cd_status = 0;

+  canp->state    = CAN_STOP;

+  canp->config   = NULL;

+  chSemInit(&canp->txsem, 0);

+  chSemInit(&canp->rxsem, 0);

+  chEvtInit(&canp->rxfull_event);

+  chEvtInit(&canp->txempty_event);

+  chEvtInit(&canp->error_event);

+  canp->status = 0;

 #if CAN_USE_SLEEP_MODE

-  chEvtInit(&canp->cd_sleep_event);

-  chEvtInit(&canp->cd_wakeup_event);

+  chEvtInit(&canp->sleep_event);

+  chEvtInit(&canp->wakeup_event);

 #endif /* CAN_USE_SLEEP_MODE */

 }

 

@@ -98,16 +98,16 @@ void canStart(CANDriver *canp, const CANConfig *config) {
   chDbgCheck(canp != NULL, "canStart");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_STOP) ||

-              (canp->cd_state == CAN_STARTING) ||

-              (canp->cd_state == CAN_READY),

+  chDbgAssert((canp->state == CAN_STOP) ||

+              (canp->state == CAN_STARTING) ||

+              (canp->state == CAN_READY),

               "canStart(), #1", "invalid state");

-  while (canp->cd_state == CAN_STARTING)

+  while (canp->state == CAN_STARTING)

     chThdSleepS(1);

-  if (canp->cd_state == CAN_STOP) {

-    canp->cd_config = config;

+  if (canp->state == CAN_STOP) {

+    canp->config = config;

     can_lld_start(canp);

-    canp->cd_state = CAN_READY;

+    canp->state = CAN_READY;

   }

   chSysUnlock();

 }

@@ -124,14 +124,14 @@ void canStop(CANDriver *canp) {
   chDbgCheck(canp != NULL, "canStop");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_STOP) || (canp->cd_state == CAN_READY),

+  chDbgAssert((canp->state == CAN_STOP) || (canp->state == CAN_READY),

               "canStop(), #1", "invalid state");

   can_lld_stop(canp);

-  chSemResetI(&canp->cd_rxsem, 0);

-  chSemResetI(&canp->cd_txsem, 0);

+  chSemResetI(&canp->rxsem, 0);

+  chSemResetI(&canp->txsem, 0);

   chSchRescheduleS();

-  canp->cd_state  = CAN_STOP;

-  canp->cd_status = 0;

+  canp->state  = CAN_STOP;

+  canp->status = 0;

   chSysUnlock();

 }

 

@@ -142,7 +142,7 @@ void canStop(CANDriver *canp) {
  * @note    Trying to transmit while in sleep mode simply enqueues the thread.

  *

  * @param[in] canp      pointer to the @p CANDriver object

- * @param[in] ctfp       pointer to the CAN frame to be transmitted

+ * @param[in] ctfp      pointer to the CAN frame to be transmitted

  * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

@@ -160,10 +160,10 @@ msg_t canTransmit(CANDriver *canp, const CANTxFrame *ctfp, systime_t timeout) {
   chDbgCheck((canp != NULL) && (ctfp != NULL), "canTransmit");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_READY) || (canp->cd_state == CAN_SLEEP),

+  chDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),

               "canTransmit(), #1", "invalid state");

-  while ((canp->cd_state == CAN_SLEEP) || !can_lld_can_transmit(canp)) {

-    msg_t msg = chSemWaitTimeoutS(&canp->cd_txsem, timeout);

+  while ((canp->state == CAN_SLEEP) || !can_lld_can_transmit(canp)) {

+    msg_t msg = chSemWaitTimeoutS(&canp->txsem, timeout);

     if (msg != RDY_OK) {

       chSysUnlock();

       return msg;

@@ -200,10 +200,10 @@ msg_t canReceive(CANDriver *canp, CANRxFrame *crfp, systime_t timeout) {
   chDbgCheck((canp != NULL) && (crfp != NULL), "canReceive");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_READY) || (canp->cd_state == CAN_SLEEP),

+  chDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),

               "canReceive(), #1", "invalid state");

-  while ((canp->cd_state == CAN_SLEEP) || !can_lld_can_receive(canp)) {

-    msg_t msg = chSemWaitTimeoutS(&canp->cd_rxsem, timeout);

+  while ((canp->state == CAN_SLEEP) || !can_lld_can_receive(canp)) {

+    msg_t msg = chSemWaitTimeoutS(&canp->rxsem, timeout);

     if (msg != RDY_OK) {

       chSysUnlock();

       return msg;

@@ -226,8 +226,8 @@ canstatus_t canGetAndClearFlags(CANDriver *canp) {
   canstatus_t status;

 

   chSysLock();

-  status = canp->cd_status;

-  canp->cd_status = 0;

+  status = canp->status;

+  canp->status = 0;

   chSysUnlock();

   return status;

 }

@@ -236,7 +236,7 @@ canstatus_t canGetAndClearFlags(CANDriver *canp) {
 /**

  * @brief   Enters the sleep mode.

  * @details This function puts the CAN driver in sleep mode and broadcasts

- *          the @p cd_sleep_event event source.

+ *          the @p sleep_event event source.

  * @pre     In order to use this function the option @p CAN_USE_SLEEP_MODE must

  *          be enabled and the @p CAN_SUPPORTS_SLEEP mode must be supported

  *          by the low level driver.

@@ -250,12 +250,12 @@ void canSleep(CANDriver *canp) {
   chDbgCheck(canp != NULL, "canSleep");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_READY) || (canp->cd_state == CAN_SLEEP),

+  chDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),

               "canSleep(), #1", "invalid state");

-  if (canp->cd_state == CAN_READY) {

+  if (canp->state == CAN_READY) {

     can_lld_sleep(canp);

-    canp->cd_state = CAN_SLEEP;

-    chEvtBroadcastI(&canp->cd_sleep_event);

+    canp->state = CAN_SLEEP;

+    chEvtBroadcastI(&canp->sleep_event);

     chSchRescheduleS();

   }

   chSysUnlock();

@@ -273,12 +273,12 @@ void canWakeup(CANDriver *canp) {
   chDbgCheck(canp != NULL, "canWakeup");

 

   chSysLock();

-  chDbgAssert((canp->cd_state == CAN_READY) || (canp->cd_state == CAN_SLEEP),

+  chDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),

               "canWakeup(), #1", "invalid state");

-  if (canp->cd_state == CAN_SLEEP) {

+  if (canp->state == CAN_SLEEP) {

     can_lld_wakeup(canp);

-    canp->cd_state = CAN_READY;

-    chEvtBroadcastI(&canp->cd_wakeup_event);

+    canp->state = CAN_READY;

+    chEvtBroadcastI(&canp->wakeup_event);

     chSchRescheduleS();

   }

   chSysUnlock();