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

8 files changed, 268 insertions, 303 deletions

diff --git a/os/hal/src/adc.c b/os/hal/src/adc.c
index 25cbfe750..956c7837f 100644
--- a/os/hal/src/adc.c
+++ b/os/hal/src/adc.c
@@ -67,19 +67,19 @@ void adcInit(void) {
  */

 void adcObjectInit(ADCDriver *adcp) {

 

-  adcp->ad_state    = ADC_STOP;

-  adcp->ad_config   = NULL;

-  adcp->ad_samples  = NULL;

-  adcp->ad_depth    = 0;

-  adcp->ad_grpp     = NULL;

+  adcp->state    = ADC_STOP;

+  adcp->config   = NULL;

+  adcp->samples  = NULL;

+  adcp->depth    = 0;

+  adcp->grpp     = NULL;

 #if ADC_USE_WAIT

-  adcp->ad_thread   = NULL;

+  adcp->thread   = NULL;

 #endif /* ADC_USE_WAIT */

 #if ADC_USE_MUTUAL_EXCLUSION

 #if CH_USE_MUTEXES

-  chMtxInit(&adcp->ad_mutex);

+  chMtxInit(&adcp->mutex);

 #else

-  chSemInit(&adcp->ad_semaphore, 1);

+  chSemInit(&adcp->semaphore, 1);

 #endif

 #endif /* ADC_USE_MUTUAL_EXCLUSION */

 #if defined(ADC_DRIVER_EXT_INIT_HOOK)

@@ -101,11 +101,11 @@ void adcStart(ADCDriver *adcp, const ADCConfig *config) {
   chDbgCheck(adcp != NULL, "adcStart");

 

   chSysLock();

-  chDbgAssert((adcp->ad_state == ADC_STOP) || (adcp->ad_state == ADC_READY),

+  chDbgAssert((adcp->state == ADC_STOP) || (adcp->state == ADC_READY),

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

-  adcp->ad_config = config;

+  adcp->config = config;

   adc_lld_start(adcp);

-  adcp->ad_state = ADC_READY;

+  adcp->state = ADC_READY;

   chSysUnlock();

 }

 

@@ -121,10 +121,10 @@ void adcStop(ADCDriver *adcp) {
   chDbgCheck(adcp != NULL, "adcStop");

 

   chSysLock();

-  chDbgAssert((adcp->ad_state == ADC_STOP) || (adcp->ad_state == ADC_READY),

+  chDbgAssert((adcp->state == ADC_STOP) || (adcp->state == ADC_READY),

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

   adc_lld_stop(adcp);

-  adcp->ad_state = ADC_STOP;

+  adcp->state = ADC_STOP;

   chSysUnlock();

 }

 

@@ -179,13 +179,13 @@ void adcStartConversionI(ADCDriver *adcp,
              ((depth == 1) || ((depth & 1) == 0)),

              "adcStartConversionI");

 

-  chDbgAssert((adcp->ad_state == ADC_READY) ||

-              (adcp->ad_state == ADC_COMPLETE),

+  chDbgAssert((adcp->state == ADC_READY) ||

+              (adcp->state == ADC_COMPLETE),

               "adcStartConversionI(), #1", "not ready");

-  adcp->ad_samples  = samples;

-  adcp->ad_depth    = depth;

-  adcp->ad_grpp     = grpp;

-  adcp->ad_state    = ADC_ACTIVE;

+  adcp->samples  = samples;

+  adcp->depth    = depth;

+  adcp->grpp     = grpp;

+  adcp->state    = ADC_ACTIVE;

   adc_lld_start_conversion(adcp);

 }

 

@@ -204,13 +204,13 @@ void adcStopConversion(ADCDriver *adcp) {
   chDbgCheck(adcp != NULL, "adcStopConversion");

 

   chSysLock();

-  chDbgAssert((adcp->ad_state == ADC_READY) ||

-              (adcp->ad_state == ADC_ACTIVE),

+  chDbgAssert((adcp->state == ADC_READY) ||

+              (adcp->state == ADC_ACTIVE),

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

-  if (adcp->ad_state != ADC_READY) {

+  if (adcp->state != ADC_READY) {

     adc_lld_stop_conversion(adcp);

-    adcp->ad_grpp  = NULL;

-    adcp->ad_state = ADC_READY;

+    adcp->grpp  = NULL;

+    adcp->state = ADC_READY;

     _adc_reset_s(adcp);

   }

   chSysUnlock();

@@ -230,14 +230,14 @@ void adcStopConversionI(ADCDriver *adcp) {
 

   chDbgCheck(adcp != NULL, "adcStopConversionI");

 

-  chDbgAssert((adcp->ad_state == ADC_READY) ||

-              (adcp->ad_state == ADC_ACTIVE) ||

-              (adcp->ad_state == ADC_COMPLETE),

+  chDbgAssert((adcp->state == ADC_READY) ||

+              (adcp->state == ADC_ACTIVE) ||

+              (adcp->state == ADC_COMPLETE),

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

-  if (adcp->ad_state != ADC_READY) {

+  if (adcp->state != ADC_READY) {

     adc_lld_stop_conversion(adcp);

-    adcp->ad_grpp  = NULL;

-    adcp->ad_state = ADC_READY;

+    adcp->grpp  = NULL;

+    adcp->state = ADC_READY;

     _adc_reset_i(adcp);

   }

 }

@@ -271,9 +271,9 @@ msg_t adcConvert(ADCDriver *adcp,
   msg_t msg;

 

   chSysLock();

-  chDbgAssert(grpp->acg_endcb == NULL, "adcConvert(), #1", "has callback");

+  chDbgAssert(grpp->end_cb == NULL, "adcConvert(), #1", "has callback");

   adcStartConversionI(adcp, grpp, samples, depth);

-  (adcp)->ad_thread = chThdSelf();

+  (adcp)->thread = chThdSelf();

   chSchGoSleepS(THD_STATE_SUSPENDED);

   msg = chThdSelf()->p_u.rdymsg;

   chSysUnlock();

@@ -286,8 +286,8 @@ msg_t adcConvert(ADCDriver *adcp,
  * @brief   Gains exclusive access to the ADC peripheral.

  * @details This function tries to gain ownership to the ADC bus, if the bus

  *          is already being used then the invoking thread is queued.

- * @pre     In order to use this function the option @p ADC_USE_MUTUAL_EXCLUSION

- *          must be enabled.

+ * @pre     In order to use this function the option

+ *          @p ADC_USE_MUTUAL_EXCLUSION must be enabled.

  *

  * @param[in] adcp      pointer to the @p ADCDriver object

  *

@@ -298,16 +298,16 @@ void adcAcquireBus(ADCDriver *adcp) {
   chDbgCheck(adcp != NULL, "adcAcquireBus");

 

 #if CH_USE_MUTEXES

-  chMtxLock(&adcp->ad_mutex);

+  chMtxLock(&adcp->mutex);

 #elif CH_USE_SEMAPHORES

-  chSemWait(&adcp->ad_semaphore);

+  chSemWait(&adcp->semaphore);

 #endif

 }

 

 /**

  * @brief   Releases exclusive access to the ADC peripheral.

- * @pre     In order to use this function the option @p ADC_USE_MUTUAL_EXCLUSION

- *          must be enabled.

+ * @pre     In order to use this function the option

+ *          @p ADC_USE_MUTUAL_EXCLUSION must be enabled.

  *

  * @param[in] adcp      pointer to the @p ADCDriver object

  *

@@ -321,7 +321,7 @@ void adcReleaseBus(ADCDriver *adcp) {
   (void)adcp;

   chMtxUnlock();

 #elif CH_USE_SEMAPHORES

-  chSemSignal(&adcp->ad_semaphore);

+  chSemSignal(&adcp->semaphore);

 #endif

 }

 #endif /* ADC_USE_MUTUAL_EXCLUSION */

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();

diff --git a/os/hal/src/mac.c b/os/hal/src/mac.c
index 9d033fe33..0cf74a5c1 100644
--- a/os/hal/src/mac.c
+++ b/os/hal/src/mac.c
@@ -71,10 +71,10 @@ void macInit(void) {
  */

 void macObjectInit(MACDriver *macp) {

 

-  chSemInit(&macp->md_tdsem, 0);

-  chSemInit(&macp->md_rdsem, 0);

+  chSemInit(&macp->tdsem, 0);

+  chSemInit(&macp->rdsem, 0);

 #if CH_USE_EVENTS

-  chEvtInit(&macp->md_rdevent);

+  chEvtInit(&macp->rdevent);

 #endif

 }

 

@@ -123,7 +123,7 @@ msg_t macWaitTransmitDescriptor(MACDriver *macp,
          (time > 0)) {

     chSysLock();

     systime_t now = chTimeNow();

-    if ((msg = chSemWaitTimeoutS(&macp->md_tdsem, time)) == RDY_TIMEOUT) {

+    if ((msg = chSemWaitTimeoutS(&macp->tdsem, time)) == RDY_TIMEOUT) {

       chSysUnlock();

       break;

     }

@@ -175,7 +175,7 @@ msg_t macWaitReceiveDescriptor(MACDriver *macp,
          (time > 0)) {

     chSysLock();

     systime_t now = chTimeNow();

-    if ((msg = chSemWaitTimeoutS(&macp->md_rdsem, time)) == RDY_TIMEOUT) {

+    if ((msg = chSemWaitTimeoutS(&macp->rdsem, time)) == RDY_TIMEOUT) {

       chSysUnlock();

       break;

     }

diff --git a/os/hal/src/mmc_spi.c b/os/hal/src/mmc_spi.c
index 1b2d930c5..df429c8d3 100644
--- a/os/hal/src/mmc_spi.c
+++ b/os/hal/src/mmc_spi.c
@@ -18,7 +18,7 @@
 */

 

 /**

- * @file    mmc_spi.c

+ * @file    spi.c

  * @brief   MMC over SPI driver code.

  *

  * @addtogroup MMC_SPI

@@ -52,24 +52,24 @@
 static void tmrfunc(void *p) {

   MMCDriver *mmcp = p;

 

-  if (mmcp->mmc_cnt > 0) {

-    if (mmcp->mmc_is_inserted()) {

-      if (--mmcp->mmc_cnt == 0) {

-        mmcp->mmc_state = MMC_INSERTED;

-        chEvtBroadcastI(&mmcp->mmc_inserted_event);

+  if (mmcp->cnt > 0) {

+    if (mmcp->is_inserted()) {

+      if (--mmcp->cnt == 0) {

+        mmcp->state = MMC_INSERTED;

+        chEvtBroadcastI(&mmcp->inserted_event);

       }

     }

     else

-      mmcp->mmc_cnt = MMC_POLLING_INTERVAL;

+      mmcp->cnt = MMC_POLLING_INTERVAL;

   }

   else {

-    if (!mmcp->mmc_is_inserted()) {

-      mmcp->mmc_state = MMC_WAIT;

-      mmcp->mmc_cnt = MMC_POLLING_INTERVAL;

-      chEvtBroadcastI(&mmcp->mmc_removed_event);

+    if (!mmcp->is_inserted()) {

+      mmcp->state = MMC_WAIT;

+      mmcp->cnt = MMC_POLLING_INTERVAL;

+      chEvtBroadcastI(&mmcp->removed_event);

     }

   }

-  chVTSetI(&mmcp->mmc_vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);

+  chVTSetI(&mmcp->vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);

 }

 

 /**

@@ -84,13 +84,13 @@ static void wait(MMCDriver *mmcp) {
   uint8_t buf[4];

 

   for (i = 0; i < 16; i++) {

-    spiReceive(mmcp->mmc_spip, 1, buf);

+    spiReceive(mmcp->spip, 1, buf);

     if (buf[0] == 0xFF)

       break;

   }

   /* Looks like it is a long wait.*/

   while (TRUE) {

-    spiReceive(mmcp->mmc_spip, 1, buf);

+    spiReceive(mmcp->spip, 1, buf);

     if (buf[0] == 0xFF)

       break;

 #ifdef MMC_NICE_WAITING

@@ -121,7 +121,7 @@ static void send_hdr(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {
   buf[3] = arg >> 8;

   buf[4] = arg;

   buf[5] = 0x95;        /* Valid for CMD0 ignored by other commands. */

-  spiSend(mmcp->mmc_spip, 6, buf);

+  spiSend(mmcp->spip, 6, buf);

 }

 

 /**

@@ -138,7 +138,7 @@ static uint8_t recvr1(MMCDriver *mmcp) {
   uint8_t r1[1];

 

   for (i = 0; i < 9; i++) {

-    spiReceive(mmcp->mmc_spip, 1, r1);

+    spiReceive(mmcp->spip, 1, r1);

     if (r1[0] != 0xFF)

       return r1[0];

   }

@@ -159,10 +159,10 @@ static uint8_t recvr1(MMCDriver *mmcp) {
 static uint8_t send_command(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {

   uint8_t r1;

 

-  spiSelect(mmcp->mmc_spip);

+  spiSelect(mmcp->spip);

   send_hdr(mmcp, cmd, arg);

   r1 = recvr1(mmcp);

-  spiUnselect(mmcp->mmc_spip);

+  spiUnselect(mmcp->spip);

   return r1;

 }

 

@@ -176,16 +176,16 @@ static uint8_t send_command(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) {
 static void sync(MMCDriver *mmcp) {

   uint8_t buf[1];

 

-  spiSelect(mmcp->mmc_spip);

+  spiSelect(mmcp->spip);

   while (TRUE) {

-    spiReceive(mmcp->mmc_spip, 1, buf);

+    spiReceive(mmcp->spip, 1, buf);

     if (buf[0] == 0xFF)

       break;

 #ifdef MMC_NICE_WAITING

     chThdSleep(1);      /* Trying to be nice with the other threads.*/

 #endif

   }

-  spiUnselect(mmcp->mmc_spip);

+  spiUnselect(mmcp->spip);

 }

 

 /*===========================================================================*/

@@ -221,15 +221,15 @@ void mmcObjectInit(MMCDriver *mmcp, SPIDriver *spip,
                    const SPIConfig *lscfg, const SPIConfig *hscfg,

                    mmcquery_t is_protected, mmcquery_t is_inserted) {

 

-  mmcp->mmc_state = MMC_STOP;

-  mmcp->mmc_config = NULL;

-  mmcp->mmc_spip = spip;

-  mmcp->mmc_lscfg = lscfg;

-  mmcp->mmc_hscfg = hscfg;

-  mmcp->mmc_is_protected = is_protected;

-  mmcp->mmc_is_inserted = is_inserted;

-  chEvtInit(&mmcp->mmc_inserted_event);

-  chEvtInit(&mmcp->mmc_removed_event);

+  mmcp->state = MMC_STOP;

+  mmcp->config = NULL;

+  mmcp->spip = spip;

+  mmcp->lscfg = lscfg;

+  mmcp->hscfg = hscfg;

+  mmcp->is_protected = is_protected;

+  mmcp->is_inserted = is_inserted;

+  chEvtInit(&mmcp->inserted_event);

+  chEvtInit(&mmcp->removed_event);

 }

 

 /**

@@ -245,11 +245,11 @@ void mmcStart(MMCDriver *mmcp, const MMCConfig *config) {
   chDbgCheck((mmcp != NULL) && (config == NULL), "mmcStart");

 

   chSysLock();

-  chDbgAssert(mmcp->mmc_state == MMC_STOP, "mmcStart(), #1", "invalid state");

-  mmcp->mmc_config = config;

-  mmcp->mmc_state = MMC_WAIT;

-  mmcp->mmc_cnt = MMC_POLLING_INTERVAL;

-  chVTSetI(&mmcp->mmc_vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);

+  chDbgAssert(mmcp->state == MMC_STOP, "mmcStart(), #1", "invalid state");

+  mmcp->config = config;

+  mmcp->state = MMC_WAIT;

+  mmcp->cnt = MMC_POLLING_INTERVAL;

+  chVTSetI(&mmcp->vt, MS2ST(MMC_POLLING_DELAY), tmrfunc, mmcp);

   chSysUnlock();

 }

 

@@ -265,17 +265,16 @@ void mmcStop(MMCDriver *mmcp) {
   chDbgCheck(mmcp != NULL, "mmcStop");

 

   chSysLock();

-  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&

-              (mmcp->mmc_state != MMC_READING) &&

-              (mmcp->mmc_state != MMC_WRITING),

-              "mmcStop(), #1",

-              "invalid state");

-  if (mmcp->mmc_state != MMC_STOP) {

-    mmcp->mmc_state = MMC_STOP;

-    chVTResetI(&mmcp->mmc_vt);

+  chDbgAssert((mmcp->state != MMC_UNINIT) &&

+              (mmcp->state != MMC_READING) &&

+              (mmcp->state != MMC_WRITING),

+              "mmcStop(), #1", "invalid state");

+  if (mmcp->state != MMC_STOP) {

+    mmcp->state = MMC_STOP;

+    chVTResetI(&mmcp->vt);

   }

   chSysUnlock();

-  spiStop(mmcp->mmc_spip);

+  spiStop(mmcp->spip);

 }

 

 /**

@@ -300,15 +299,13 @@ bool_t mmcConnect(MMCDriver *mmcp) {
 

   chDbgCheck(mmcp != NULL, "mmcConnect");

 

-  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&

-              (mmcp->mmc_state != MMC_STOP),

-              "mmcConnect(), #1",

-              "invalid state");

+  chDbgAssert((mmcp->state != MMC_UNINIT) && (mmcp->state != MMC_STOP),

+              "mmcConnect(), #1", "invalid state");

 

-  if (mmcp->mmc_state == MMC_INSERTED) {

+  if (mmcp->state == MMC_INSERTED) {

     /* Slow clock mode and 128 clock pulses.*/

-    spiStart(mmcp->mmc_spip, mmcp->mmc_lscfg);

-    spiIgnore(mmcp->mmc_spip, 16);

+    spiStart(mmcp->spip, mmcp->lscfg);

+    spiIgnore(mmcp->spip, 16);

 

     /* SPI mode selection.*/

     i = 0;

@@ -334,7 +331,7 @@ bool_t mmcConnect(MMCDriver *mmcp) {
     }

 

     /* Initialization complete, full speed. */

-    spiStart(mmcp->mmc_spip, mmcp->mmc_hscfg);

+    spiStart(mmcp->spip, mmcp->hscfg);

 

     /* Setting block size.*/

     if (send_command(mmcp, MMC_CMDSETBLOCKLEN, MMC_SECTOR_SIZE) != 0x00)

@@ -342,8 +339,8 @@ bool_t mmcConnect(MMCDriver *mmcp) {
 

     /* Transition to MMC_READY state (if not extracted).*/

     chSysLock();

-    if (mmcp->mmc_state == MMC_INSERTED) {

-      mmcp->mmc_state = MMC_READY;

+    if (mmcp->state == MMC_INSERTED) {

+      mmcp->state = MMC_READY;

       result = FALSE;

     }

     else

@@ -351,7 +348,7 @@ bool_t mmcConnect(MMCDriver *mmcp) {
     chSysUnlock();

     return result;

   }

-  if (mmcp->mmc_state == MMC_READY)

+  if (mmcp->state == MMC_READY)

     return FALSE;

   /* Any other state is invalid.*/

   return TRUE;

@@ -373,24 +370,22 @@ bool_t mmcDisconnect(MMCDriver *mmcp) {
 

   chDbgCheck(mmcp != NULL, "mmcDisconnect");

 

-  chDbgAssert((mmcp->mmc_state != MMC_UNINIT) &&

-              (mmcp->mmc_state != MMC_STOP),

-              "mmcDisconnect(), #1",

-              "invalid state");

-  switch (mmcp->mmc_state) {

+  chDbgAssert((mmcp->state != MMC_UNINIT) && (mmcp->state != MMC_STOP),

+              "mmcDisconnect(), #1", "invalid state");

+  switch (mmcp->state) {

   case MMC_READY:

     /* Wait for the pending write operations to complete.*/

     sync(mmcp);

     chSysLock();

-    if (mmcp->mmc_state == MMC_READY)

-      mmcp->mmc_state = MMC_INSERTED;

+    if (mmcp->state == MMC_READY)

+      mmcp->state = MMC_INSERTED;

     chSysUnlock();

   case MMC_INSERTED:

     status = FALSE;

   default:

     status = TRUE;

   }

-  spiStop(mmcp->mmc_spip);

+  spiStop(mmcp->spip);

   return status;

 }

 

@@ -410,21 +405,21 @@ bool_t mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) {
   chDbgCheck(mmcp != NULL, "mmcStartSequentialRead");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_READY) {

+  if (mmcp->state != MMC_READY) {

     chSysUnlock();

     return TRUE;

   }

-  mmcp->mmc_state = MMC_READING;

+  mmcp->state = MMC_READING;

   chSysUnlock();

 

-  spiStart(mmcp->mmc_spip, mmcp->mmc_hscfg);

-  spiSelect(mmcp->mmc_spip);

+  spiStart(mmcp->spip, mmcp->hscfg);

+  spiSelect(mmcp->spip);

   send_hdr(mmcp, MMC_CMDREADMULTIPLE, startblk * MMC_SECTOR_SIZE);

   if (recvr1(mmcp) != 0x00) {

-    spiUnselect(mmcp->mmc_spip);

+    spiUnselect(mmcp->spip);

     chSysLock();

-    if (mmcp->mmc_state == MMC_READING)

-      mmcp->mmc_state = MMC_READY;

+    if (mmcp->state == MMC_READING)

+      mmcp->state = MMC_READY;

     chSysUnlock();

     return TRUE;

   }

@@ -448,26 +443,26 @@ bool_t mmcSequentialRead(MMCDriver *mmcp, uint8_t *buffer) {
   chDbgCheck((mmcp != NULL) && (buffer != NULL), "mmcSequentialRead");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_READING) {

+  if (mmcp->state != MMC_READING) {

     chSysUnlock();

     return TRUE;

   }

   chSysUnlock();

 

   for (i = 0; i < MMC_WAIT_DATA; i++) {

-    spiReceive(mmcp->mmc_spip, 1, buffer);

+    spiReceive(mmcp->spip, 1, buffer);

     if (buffer[0] == 0xFE) {

-      spiReceive(mmcp->mmc_spip, MMC_SECTOR_SIZE, buffer);

+      spiReceive(mmcp->spip, MMC_SECTOR_SIZE, buffer);

       /* CRC ignored. */

-      spiIgnore(mmcp->mmc_spip, 2);

+      spiIgnore(mmcp->spip, 2);

       return FALSE;

     }

   }

   /* Timeout.*/

-  spiUnselect(mmcp->mmc_spip);

+  spiUnselect(mmcp->spip);

   chSysLock();

-  if (mmcp->mmc_state == MMC_READING)

-    mmcp->mmc_state = MMC_READY;

+  if (mmcp->state == MMC_READING)

+    mmcp->state = MMC_READY;

   chSysUnlock();

   return TRUE;

 }

@@ -489,22 +484,22 @@ bool_t mmcStopSequentialRead(MMCDriver *mmcp) {
   chDbgCheck(mmcp != NULL, "mmcStopSequentialRead");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_READING) {

+  if (mmcp->state != MMC_READING) {

     chSysUnlock();

     return TRUE;

   }

   chSysUnlock();

 

-  spiSend(mmcp->mmc_spip, sizeof(stopcmd), stopcmd);

+  spiSend(mmcp->spip, sizeof(stopcmd), stopcmd);

 /*  result = recvr1(mmcp) != 0x00;*/

   /* Note, ignored r1 response, it can be not zero, unknown issue.*/

   recvr1(mmcp);

   result = FALSE;

-  spiUnselect(mmcp->mmc_spip);

+  spiUnselect(mmcp->spip);

 

   chSysLock();

-  if (mmcp->mmc_state == MMC_READING)

-    mmcp->mmc_state = MMC_READY;

+  if (mmcp->state == MMC_READING)

+    mmcp->state = MMC_READY;

   chSysUnlock();

   return result;

 }

@@ -525,21 +520,21 @@ bool_t mmcStartSequentialWrite(MMCDriver *mmcp, uint32_t startblk) {
   chDbgCheck(mmcp != NULL, "mmcStartSequentialWrite");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_READY) {

+  if (mmcp->state != MMC_READY) {

     chSysUnlock();

     return TRUE;

   }

-  mmcp->mmc_state = MMC_WRITING;

+  mmcp->state = MMC_WRITING;

   chSysUnlock();

 

-  spiStart(mmcp->mmc_spip, mmcp->mmc_hscfg);

-  spiSelect(mmcp->mmc_spip);

+  spiStart(mmcp->spip, mmcp->hscfg);

+  spiSelect(mmcp->spip);

   send_hdr(mmcp, MMC_CMDWRITEMULTIPLE, startblk * MMC_SECTOR_SIZE);

   if (recvr1(mmcp) != 0x00) {

-    spiUnselect(mmcp->mmc_spip);

+    spiUnselect(mmcp->spip);

     chSysLock();

-    if (mmcp->mmc_state == MMC_WRITING)

-      mmcp->mmc_state = MMC_READY;

+    if (mmcp->state == MMC_WRITING)

+      mmcp->state = MMC_READY;

     chSysUnlock();

     return TRUE;

   }

@@ -564,26 +559,26 @@ bool_t mmcSequentialWrite(MMCDriver *mmcp, const uint8_t *buffer) {
   chDbgCheck((mmcp != NULL) && (buffer != NULL), "mmcSequentialWrite");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_WRITING) {

+  if (mmcp->state != MMC_WRITING) {

     chSysUnlock();

     return TRUE;

   }

   chSysUnlock();

 

-  spiSend(mmcp->mmc_spip, sizeof(start), start);    /* Data prologue.       */

-  spiSend(mmcp->mmc_spip, MMC_SECTOR_SIZE, buffer); /* Data.                */

-  spiIgnore(mmcp->mmc_spip, 2);                     /* CRC ignored.         */

-  spiReceive(mmcp->mmc_spip, 1, b);

+  spiSend(mmcp->spip, sizeof(start), start);        /* Data prologue.       */

+  spiSend(mmcp->spip, MMC_SECTOR_SIZE, buffer);     /* Data.                */

+  spiIgnore(mmcp->spip, 2);                         /* CRC ignored.         */

+  spiReceive(mmcp->spip, 1, b);

   if ((b[0] & 0x1F) == 0x05) {

     wait(mmcp);

     return FALSE;

   }

 

   /* Error.*/

-  spiUnselect(mmcp->mmc_spip);

+  spiUnselect(mmcp->spip);

   chSysLock();

-  if (mmcp->mmc_state == MMC_WRITING)

-    mmcp->mmc_state = MMC_READY;

+  if (mmcp->state == MMC_WRITING)

+    mmcp->state = MMC_READY;

   chSysUnlock();

   return TRUE;

 }

@@ -604,18 +599,18 @@ bool_t mmcStopSequentialWrite(MMCDriver *mmcp) {
   chDbgCheck(mmcp != NULL, "mmcStopSequentialWrite");

 

   chSysLock();

-  if (mmcp->mmc_state != MMC_WRITING) {

+  if (mmcp->state != MMC_WRITING) {

     chSysUnlock();

     return TRUE;

   }

   chSysUnlock();

 

-  spiSend(mmcp->mmc_spip, sizeof(stop), stop);

-  spiUnselect(mmcp->mmc_spip);

+  spiSend(mmcp->spip, sizeof(stop), stop);

+  spiUnselect(mmcp->spip);

 

   chSysLock();

-  if (mmcp->mmc_state == MMC_WRITING) {

-    mmcp->mmc_state = MMC_READY;

+  if (mmcp->state == MMC_WRITING) {

+    mmcp->state = MMC_READY;

     chSysUnlock();

     return FALSE;

   }

diff --git a/os/hal/src/pal.c b/os/hal/src/pal.c
index ce7c226e9..de12baef6 100644
--- a/os/hal/src/pal.c
+++ b/os/hal/src/pal.c
@@ -64,9 +64,9 @@
 ioportmask_t palReadBus(IOBus *bus) {

 

   chDbgCheck((bus != NULL) &&

-             (bus->bus_offset > PAL_IOPORTS_WIDTH), "palReadBus");

+             (bus->offset > PAL_IOPORTS_WIDTH), "palReadBus");

 

-  return palReadGroup(bus->bus_portid, bus->bus_mask, bus->bus_offset);

+  return palReadGroup(bus->portid, bus->mask, bus->offset);

 }

 

 /**

@@ -89,9 +89,9 @@ ioportmask_t palReadBus(IOBus *bus) {
 void palWriteBus(IOBus *bus, ioportmask_t bits) {

 

   chDbgCheck((bus != NULL) &&

-             (bus->bus_offset > PAL_IOPORTS_WIDTH), "palWriteBus");

+             (bus->offset > PAL_IOPORTS_WIDTH), "palWriteBus");

 

-  palWriteGroup(bus->bus_portid, bus->bus_mask, bus->bus_offset, bits);

+  palWriteGroup(bus->portid, bus->mask, bus->offset, bits);

 }

 

 /**

@@ -112,9 +112,9 @@ void palWriteBus(IOBus *bus, ioportmask_t bits) {
 void palSetBusMode(IOBus *bus, uint_fast8_t mode) {

 

   chDbgCheck((bus != NULL) &&

-             (bus->bus_offset > PAL_IOPORTS_WIDTH), "palSetBusMode");

+             (bus->offset > PAL_IOPORTS_WIDTH), "palSetBusMode");

 

-  palSetGroupMode(bus->bus_portid, bus->bus_mask, mode);

+  palSetGroupMode(bus->portid, bus->mask, mode);

 }

 

 #endif /* HAL_USE_PAL */

diff --git a/os/hal/src/pwm.c b/os/hal/src/pwm.c
index cf619e508..40ad7428d 100644
--- a/os/hal/src/pwm.c
+++ b/os/hal/src/pwm.c
@@ -67,8 +67,8 @@ void pwmInit(void) {
  */

 void pwmObjectInit(PWMDriver *pwmp) {

 

-  pwmp->pd_state    = PWM_STOP;

-  pwmp->pd_config   = NULL;

+  pwmp->state    = PWM_STOP;

+  pwmp->config   = NULL;

 #if defined(PWM_DRIVER_EXT_INIT_HOOK)

   PWM_DRIVER_EXT_INIT_HOOK(pwmp);

 #endif

@@ -87,11 +87,11 @@ void pwmStart(PWMDriver *pwmp, const PWMConfig *config) {
   chDbgCheck((pwmp != NULL) && (config != NULL), "pwmStart");

 

   chSysLock();

-  chDbgAssert((pwmp->pd_state == PWM_STOP) || (pwmp->pd_state == PWM_READY),

+  chDbgAssert((pwmp->state == PWM_STOP) || (pwmp->state == PWM_READY),

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

-  pwmp->pd_config = config;

+  pwmp->config = config;

   pwm_lld_start(pwmp);

-  pwmp->pd_state = PWM_READY;

+  pwmp->state = PWM_READY;

   chSysUnlock();

 }

 

@@ -107,10 +107,10 @@ void pwmStop(PWMDriver *pwmp) {
   chDbgCheck(pwmp != NULL, "pwmStop");

 

   chSysLock();

-  chDbgAssert((pwmp->pd_state == PWM_STOP) || (pwmp->pd_state == PWM_READY),

+  chDbgAssert((pwmp->state == PWM_STOP) || (pwmp->state == PWM_READY),

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

   pwm_lld_stop(pwmp);

-  pwmp->pd_state = PWM_STOP;

+  pwmp->state = PWM_STOP;

   chSysUnlock();

 }

 

@@ -132,7 +132,7 @@ void pwmEnableChannel(PWMDriver *pwmp,
              "pwmEnableChannel");

 

   chSysLock();

-  chDbgAssert(pwmp->pd_state == PWM_READY,

+  chDbgAssert(pwmp->state == PWM_READY,

               "pwmEnableChannel(), #1", "not ready");

   pwm_lld_enable_channel(pwmp, channel, width);

   chSysUnlock();

@@ -154,7 +154,7 @@ void pwmDisableChannel(PWMDriver *pwmp, pwmchannel_t channel) {
              "pwmEnableChannel");

 

   chSysLock();

-  chDbgAssert(pwmp->pd_state == PWM_READY,

+  chDbgAssert(pwmp->state == PWM_READY,

               "pwmDisableChannel(), #1", "not ready");

   pwm_lld_disable_channel(pwmp, channel);

   chSysUnlock();

diff --git a/os/hal/src/spi.c b/os/hal/src/spi.c
index e99126b9e..686006e0d 100644
--- a/os/hal/src/spi.c
+++ b/os/hal/src/spi.c
@@ -67,16 +67,16 @@ void spiInit(void) {
  */

 void spiObjectInit(SPIDriver *spip) {

 

-  spip->spd_state = SPI_STOP;

-  spip->spd_config = NULL;

+  spip->state = SPI_STOP;

+  spip->config = NULL;

 #if SPI_USE_WAIT

-  spip->spd_thread = NULL;

+  spip->thread = NULL;

 #endif /* SPI_USE_WAIT */

 #if SPI_USE_MUTUAL_EXCLUSION

 #if CH_USE_MUTEXES

-  chMtxInit(&spip->spd_mutex);

+  chMtxInit(&spip->mutex);

 #else

-  chSemInit(&spip->spd_semaphore, 1);

+  chSemInit(&spip->semaphore, 1);

 #endif

 #endif /* SPI_USE_MUTUAL_EXCLUSION */

 #if defined(SPI_DRIVER_EXT_INIT_HOOK)

@@ -97,11 +97,11 @@ void spiStart(SPIDriver *spip, const SPIConfig *config) {
   chDbgCheck((spip != NULL) && (config != NULL), "spiStart");

 

   chSysLock();

-  chDbgAssert((spip->spd_state == SPI_STOP) || (spip->spd_state == SPI_READY),

+  chDbgAssert((spip->state == SPI_STOP) || (spip->state == SPI_READY),

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

-  spip->spd_config = config;

+  spip->config = config;

   spi_lld_start(spip);

-  spip->spd_state = SPI_READY;

+  spip->state = SPI_READY;

   chSysUnlock();

 }

 

@@ -119,11 +119,11 @@ void spiStop(SPIDriver *spip) {
   chDbgCheck(spip != NULL, "spiStop");

 

   chSysLock();

-  chDbgAssert((spip->spd_state == SPI_STOP) || (spip->spd_state == SPI_READY),

+  chDbgAssert((spip->state == SPI_STOP) || (spip->state == SPI_READY),

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

   spi_lld_unselect(spip);

   spi_lld_stop(spip);

-  spip->spd_state = SPI_STOP;

+  spip->state = SPI_STOP;

   chSysUnlock();

 }

 

@@ -139,8 +139,7 @@ void spiSelect(SPIDriver *spip) {
   chDbgCheck(spip != NULL, "spiSelect");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiSelect(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiSelect(), #1", "not ready");

   spiSelectI(spip);

   chSysUnlock();

 }

@@ -158,8 +157,7 @@ void spiUnselect(SPIDriver *spip) {
   chDbgCheck(spip != NULL, "spiUnselect");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiUnselect(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiUnselect(), #1", "not ready");

   spiUnselectI(spip);

   chSysUnlock();

 }

@@ -182,8 +180,7 @@ void spiStartIgnore(SPIDriver *spip, size_t n) {
   chDbgCheck((spip != NULL) && (n > 0), "spiStartIgnore");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiStartIgnore(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiStartIgnore(), #1", "not ready");

   spiStartIgnoreI(spip, n);

   chSysUnlock();

 }

@@ -212,8 +209,7 @@ void spiStartExchange(SPIDriver *spip, size_t n,
              "spiStartExchange");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiStartExchange(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiStartExchange(), #1", "not ready");

   spiStartExchangeI(spip, n, txbuf, rxbuf);

   chSysUnlock();

 }

@@ -239,8 +235,7 @@ void spiStartSend(SPIDriver *spip, size_t n, const void *txbuf) {
              "spiStartSend");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiStartSend(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiStartSend(), #1", "not ready");

   spiStartSendI(spip, n, txbuf);

   chSysUnlock();

 }

@@ -266,8 +261,7 @@ void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) {
              "spiStartReceive");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiStartReceive(), #1", "not ready");

+  chDbgAssert(spip->state == SPI_READY, "spiStartReceive(), #1", "not ready");

   spiStartReceiveI(spip, n, rxbuf);

   chSysUnlock();

 }

@@ -280,7 +274,7 @@ void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) {
  * @pre     In order to use this function the option @p SPI_USE_WAIT must be

  *          enabled.

  * @pre     In order to use this function the driver must have been configured

- *          without callbacks (@p spc_endcb = @p NULL).

+ *          without callbacks (@p end_cb = @p NULL).

  *

  * @param[in] spip      pointer to the @p SPIDriver object

  * @param[in] n         number of words to be ignored

@@ -292,10 +286,8 @@ void spiIgnore(SPIDriver *spip, size_t n) {
   chDbgCheck((spip != NULL) && (n > 0), "spiIgnoreWait");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiIgnore(), #1", "not ready");

-  chDbgAssert(spip->spd_config->spc_endcb == NULL,

-              "spiIgnore(), #2", "has callback");

+  chDbgAssert(spip->state == SPI_READY, "spiIgnore(), #1", "not ready");

+  chDbgAssert(spip->config->end_cb == NULL, "spiIgnore(), #2", "has callback");

   spiStartIgnoreI(spip, n);

   _spi_wait_s(spip);

   chSysUnlock();

@@ -308,7 +300,7 @@ void spiIgnore(SPIDriver *spip, size_t n) {
  * @pre     In order to use this function the option @p SPI_USE_WAIT must be

  *          enabled.

  * @pre     In order to use this function the driver must have been configured

- *          without callbacks (@p spc_endcb = @p NULL).

+ *          without callbacks (@p end_cb = @p NULL).

  * @note    The buffers are organized as uint8_t arrays for data sizes below

  *          or equal to 8 bits else it is organized as uint16_t arrays.

  *

@@ -326,9 +318,8 @@ void spiExchange(SPIDriver *spip, size_t n,
              "spiExchange");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiExchange(), #1", "not ready");

-  chDbgAssert(spip->spd_config->spc_endcb == NULL,

+  chDbgAssert(spip->state == SPI_READY, "spiExchange(), #1", "not ready");

+  chDbgAssert(spip->config->end_cb == NULL,

               "spiExchange(), #2", "has callback");

   spiStartExchangeI(spip, n, txbuf, rxbuf);

   _spi_wait_s(spip);

@@ -341,7 +332,7 @@ void spiExchange(SPIDriver *spip, size_t n,
  * @pre     In order to use this function the option @p SPI_USE_WAIT must be

  *          enabled.

  * @pre     In order to use this function the driver must have been configured

- *          without callbacks (@p spc_endcb = @p NULL).

+ *          without callbacks (@p end_cb = @p NULL).

  * @note    The buffers are organized as uint8_t arrays for data sizes below

  *          or equal to 8 bits else it is organized as uint16_t arrays.

  *

@@ -353,14 +344,11 @@ void spiExchange(SPIDriver *spip, size_t n,
  */

 void spiSend(SPIDriver *spip, size_t n, const void *txbuf) {

 

-  chDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL),

-             "spiSend");

+  chDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL), "spiSend");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiSend(), #1", "not ready");

-  chDbgAssert(spip->spd_config->spc_endcb == NULL,

-              "spiSend(), #2", "has callback");

+  chDbgAssert(spip->state == SPI_READY, "spiSend(), #1", "not ready");

+  chDbgAssert(spip->config->end_cb == NULL, "spiSend(), #2", "has callback");

   spiStartSendI(spip, n, txbuf);

   _spi_wait_s(spip);

   chSysUnlock();

@@ -372,7 +360,7 @@ void spiSend(SPIDriver *spip, size_t n, const void *txbuf) {
  * @pre     In order to use this function the option @p SPI_USE_WAIT must be

  *          enabled.

  * @pre     In order to use this function the driver must have been configured

- *          without callbacks (@p spc_endcb = @p NULL).

+ *          without callbacks (@p end_cb = @p NULL).

  * @note    The buffers are organized as uint8_t arrays for data sizes below

  *          or equal to 8 bits else it is organized as uint16_t arrays.

  *

@@ -388,9 +376,8 @@ void spiReceive(SPIDriver *spip, size_t n, void *rxbuf) {
              "spiReceive");

 

   chSysLock();

-  chDbgAssert(spip->spd_state == SPI_READY,

-              "spiReceive(), #1", "not ready");

-  chDbgAssert(spip->spd_config->spc_endcb == NULL,

+  chDbgAssert(spip->state == SPI_READY, "spiReceive(), #1", "not ready");

+  chDbgAssert(spip->config->end_cb == NULL,

               "spiReceive(), #2", "has callback");

   spiStartReceiveI(spip, n, rxbuf);

   _spi_wait_s(spip);

@@ -415,9 +402,9 @@ void spiAcquireBus(SPIDriver *spip) {
   chDbgCheck(spip != NULL, "spiAcquireBus");

 

 #if CH_USE_MUTEXES

-  chMtxLock(&spip->spd_mutex);

+  chMtxLock(&spip->mutex);

 #elif CH_USE_SEMAPHORES

-  chSemWait(&spip->spd_semaphore);

+  chSemWait(&spip->semaphore);

 #endif

 }

 

@@ -438,7 +425,7 @@ void spiReleaseBus(SPIDriver *spip) {
   (void)spip;

   chMtxUnlock();

 #elif CH_USE_SEMAPHORES

-  chSemSignal(&spip->spd_semaphore);

+  chSemSignal(&spip->semaphore);

 #endif

 }

 #endif /* SPI_USE_MUTUAL_EXCLUSION */

diff --git a/os/hal/src/uart.c b/os/hal/src/uart.c
index 4a21e907f..2a9c6ce6f 100644
--- a/os/hal/src/uart.c
+++ b/os/hal/src/uart.c
@@ -67,10 +67,10 @@ void uartInit(void) {
  */

 void uartObjectInit(UARTDriver *uartp) {

 

-  uartp->ud_state   = UART_STOP;

-  uartp->ud_txstate = UART_TX_IDLE;

-  uartp->ud_rxstate = UART_RX_IDLE;

-  uartp->ud_config  = NULL;

+  uartp->state   = UART_STOP;

+  uartp->txstate = UART_TX_IDLE;

+  uartp->rxstate = UART_RX_IDLE;

+  uartp->config  = NULL;

   /* Optional, user-defined initializer.*/

 #if defined(UART_DRIVER_EXT_INIT_HOOK)

   UART_DRIVER_EXT_INIT_HOOK(uartp);

@@ -90,14 +90,12 @@ void uartStart(UARTDriver *uartp, const UARTConfig *config) {
   chDbgCheck((uartp != NULL) && (config != NULL), "uartStart");

 

   chSysLock();

-  chDbgAssert((uartp->ud_state == UART_STOP) ||

-              (uartp->ud_state == UART_READY),

-              "uartStart(), #1",

-              "invalid state");

+  chDbgAssert((uartp->state == UART_STOP) || (uartp->state == UART_READY),

+              "uartStart(), #1", "invalid state");

 

-  uartp->ud_config = config;

+  uartp->config = config;

   uart_lld_start(uartp);

-  uartp->ud_state = UART_READY;

+  uartp->state = UART_READY;

   chSysUnlock();

 }

 

@@ -113,15 +111,13 @@ void uartStop(UARTDriver *uartp) {
   chDbgCheck(uartp != NULL, "uartStop");

 

   chSysLock();

-  chDbgAssert((uartp->ud_state == UART_STOP) ||

-              (uartp->ud_state == UART_READY),

-              "uartStop(), #1",

-              "invalid state");

+  chDbgAssert((uartp->state == UART_STOP) || (uartp->state == UART_READY),

+              "uartStop(), #1", "invalid state");

 

   uart_lld_stop(uartp);

-  uartp->ud_state = UART_STOP;

-  uartp->ud_txstate = UART_TX_IDLE;

-  uartp->ud_rxstate = UART_RX_IDLE;

+  uartp->state = UART_STOP;

+  uartp->txstate = UART_TX_IDLE;

+  uartp->rxstate = UART_RX_IDLE;

   chSysUnlock();

 }

 

@@ -142,13 +138,11 @@ void uartStartSend(UARTDriver *uartp, size_t n, const void *txbuf) {
              "uartStartSend");

              

   chSysLock();

-  chDbgAssert((uartp->ud_state == UART_READY) &&

-              (uartp->ud_txstate == UART_TX_IDLE),

-              "uartStartSend(), #1",

-              "not active");

+  chDbgAssert((uartp->state == UART_READY) && (uartp->txstate == UART_TX_IDLE),

+              "uartStartSend(), #1", "not active");

 

   uart_lld_start_send(uartp, n, txbuf);

-  uartp->ud_txstate = UART_TX_ACTIVE;

+  uartp->txstate = UART_TX_ACTIVE;

   chSysUnlock();

 }

 

@@ -169,12 +163,11 @@ void uartStartSendI(UARTDriver *uartp, size_t n, const void *txbuf) {
   chDbgCheck((uartp != NULL) && (n > 0) && (txbuf != NULL),

              "uartStartSendI");

 

-  chDbgAssert((uartp->ud_state == UART_READY) &&

-              (uartp->ud_txstate != UART_TX_ACTIVE),

-              "uartStartSendI(), #1",

-              "not active");

+  chDbgAssert((uartp->state == UART_READY) &&

+              (uartp->txstate != UART_TX_ACTIVE),

+              "uartStartSendI(), #1", "not active");

   uart_lld_start_send(uartp, n, txbuf);

-  uartp->ud_txstate = UART_TX_ACTIVE;

+  uartp->txstate = UART_TX_ACTIVE;

 }

 

 /**

@@ -195,13 +188,11 @@ size_t uartStopSend(UARTDriver *uartp) {
   chDbgCheck(uartp != NULL, "uartStopSend");

 

   chSysLock();

-  chDbgAssert(uartp->ud_state == UART_READY,

-              "uartStopSend(), #1",

-              "not active");

+  chDbgAssert(uartp->state == UART_READY, "uartStopSend(), #1", "not active");

 

-  if (uartp->ud_txstate == UART_TX_ACTIVE) {

+  if (uartp->txstate == UART_TX_ACTIVE) {

     n = uart_lld_stop_send(uartp);

-    uartp->ud_txstate = UART_TX_IDLE;

+    uartp->txstate = UART_TX_IDLE;

   }

   else

     n = 0;

@@ -226,13 +217,11 @@ size_t uartStopSendI(UARTDriver *uartp) {
 

   chDbgCheck(uartp != NULL, "uartStopSendI");

 

-  chDbgAssert(uartp->ud_state == UART_READY,

-              "uartStopSendI(), #1",

-              "not active");

+  chDbgAssert(uartp->state == UART_READY, "uartStopSendI(), #1", "not active");

 

-  if (uartp->ud_txstate == UART_TX_ACTIVE) {

+  if (uartp->txstate == UART_TX_ACTIVE) {

     size_t n = uart_lld_stop_send(uartp);

-    uartp->ud_txstate = UART_TX_IDLE;

+    uartp->txstate = UART_TX_IDLE;

     return n;

   }

   return 0;

@@ -255,13 +244,11 @@ void uartStartReceive(UARTDriver *uartp, size_t n, void *rxbuf) {
              "uartStartReceive");

 

   chSysLock();

-  chDbgAssert((uartp->ud_state == UART_READY) &&

-              (uartp->ud_rxstate == UART_RX_IDLE),

-              "uartStartReceive(), #1",

-              "not active");

+  chDbgAssert((uartp->state == UART_READY) && (uartp->rxstate == UART_RX_IDLE),

+              "uartStartReceive(), #1", "not active");

 

   uart_lld_start_receive(uartp, n, rxbuf);

-  uartp->ud_rxstate = UART_RX_ACTIVE;

+  uartp->rxstate = UART_RX_ACTIVE;

   chSysUnlock();

 }

 

@@ -282,13 +269,11 @@ void uartStartReceiveI(UARTDriver *uartp, size_t n, void *rxbuf) {
   chDbgCheck((uartp != NULL) && (n > 0) && (rxbuf != NULL),

              "uartStartReceiveI");

 

-  chDbgAssert((uartp->ud_state == UART_READY) &&

-              (uartp->ud_rxstate == UART_RX_IDLE),

-              "uartStartReceiveI(), #1",

-              "not active");

+  chDbgAssert((uartp->state == UART_READY) && (uartp->rxstate == UART_RX_IDLE),

+              "uartStartReceiveI(), #1", "not active");

 

   uart_lld_start_receive(uartp, n, rxbuf);

-  uartp->ud_rxstate = UART_RX_ACTIVE;

+  uartp->rxstate = UART_RX_ACTIVE;

 }

 

 /**

@@ -309,13 +294,12 @@ size_t uartStopReceive(UARTDriver *uartp) {
   chDbgCheck(uartp != NULL, "uartStopReceive");

 

   chSysLock();

-  chDbgAssert(uartp->ud_state == UART_READY,

-              "uartStopReceive(), #1",

-              "not active");

+  chDbgAssert(uartp->state == UART_READY,

+              "uartStopReceive(), #1", "not active");

 

-  if (uartp->ud_rxstate == UART_RX_ACTIVE) {

+  if (uartp->rxstate == UART_RX_ACTIVE) {

     n = uart_lld_stop_receive(uartp);

-    uartp->ud_rxstate = UART_RX_IDLE;

+    uartp->rxstate = UART_RX_IDLE;

   }

   else

     n = 0;

@@ -339,13 +323,12 @@ size_t uartStopReceive(UARTDriver *uartp) {
 size_t uartStopReceiveI(UARTDriver *uartp) {

   chDbgCheck(uartp != NULL, "uartStopReceiveI");

 

-  chDbgAssert(uartp->ud_state == UART_READY,

-              "uartStopReceiveI(), #1",

-              "not active");

+  chDbgAssert(uartp->state == UART_READY,

+              "uartStopReceiveI(), #1", "not active");

 

-  if (uartp->ud_rxstate == UART_RX_ACTIVE) {

+  if (uartp->rxstate == UART_RX_ACTIVE) {

     size_t n = uart_lld_stop_receive(uartp);

-    uartp->ud_rxstate = UART_RX_IDLE;

+    uartp->rxstate = UART_RX_IDLE;

     return n;

   }

   return 0;