diff options
Diffstat (limited to 'os/hal/src')
| -rw-r--r-- | os/hal/src/adc.c | 22 | ||||
| -rw-r--r-- | os/hal/src/can.c | 25 | ||||
| -rw-r--r-- | os/hal/src/dac.c | 16 | ||||
| -rw-r--r-- | os/hal/src/ext.c | 10 | ||||
| -rw-r--r-- | os/hal/src/gpt.c | 4 | ||||
| -rw-r--r-- | os/hal/src/hal.c | 43 | ||||
| -rw-r--r-- | os/hal/src/hal_mmcsd.c | 250 | ||||
| -rw-r--r-- | os/hal/src/hal_queues.c | 113 | ||||
| -rw-r--r-- | os/hal/src/i2c.c | 34 | ||||
| -rw-r--r-- | os/hal/src/i2s.c | 4 | ||||
| -rw-r--r-- | os/hal/src/icu.c | 4 | ||||
| -rw-r--r-- | os/hal/src/mac.c | 34 | ||||
| -rw-r--r-- | os/hal/src/mmc_spi.c | 202 | ||||
| -rw-r--r-- | os/hal/src/pal.c | 4 | ||||
| -rw-r--r-- | os/hal/src/pwm.c | 8 | ||||
| -rw-r--r-- | os/hal/src/rtc.c | 91 | ||||
| -rw-r--r-- | os/hal/src/sdc.c | 218 | ||||
| -rw-r--r-- | os/hal/src/serial.c | 12 | ||||
| -rw-r--r-- | os/hal/src/serial_usb.c | 97 | ||||
| -rw-r--r-- | os/hal/src/spi.c | 37 | ||||
| -rw-r--r-- | os/hal/src/st.c | 12 | ||||
| -rw-r--r-- | os/hal/src/uart.c | 20 | ||||
| -rw-r--r-- | os/hal/src/usb.c | 253 |
23 files changed, 865 insertions, 648 deletions
diff --git a/os/hal/src/adc.c b/os/hal/src/adc.c index 8edd93f90..2297f03fc 100644 --- a/os/hal/src/adc.c +++ b/os/hal/src/adc.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_ADC || defined(__DOXYGEN__)
+#if (HAL_USE_ADC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -75,12 +75,12 @@ void adcObjectInit(ADCDriver *adcp) { adcp->samples = NULL;
adcp->depth = 0;
adcp->grpp = NULL;
-#if ADC_USE_WAIT
+#if ADC_USE_WAIT == TRUE
adcp->thread = NULL;
-#endif /* ADC_USE_WAIT */
-#if ADC_USE_MUTUAL_EXCLUSION
+#endif
+#if ADC_USE_MUTUAL_EXCLUSION == TRUE
osalMutexObjectInit(&adcp->mutex);
-#endif /* ADC_USE_MUTUAL_EXCLUSION */
+#endif
#if defined(ADC_DRIVER_EXT_INIT_HOOK)
ADC_DRIVER_EXT_INIT_HOOK(adcp);
#endif
@@ -178,7 +178,7 @@ void adcStartConversionI(ADCDriver *adcp, osalDbgCheckClassI();
osalDbgCheck((adcp != NULL) && (grpp != NULL) && (samples != NULL) &&
- ((depth == 1) || ((depth & 1) == 0)));
+ ((depth == 1U) || ((depth & 1U) == 0U)));
osalDbgAssert((adcp->state == ADC_READY) ||
(adcp->state == ADC_COMPLETE) ||
(adcp->state == ADC_ERROR),
@@ -244,7 +244,7 @@ void adcStopConversionI(ADCDriver *adcp) { }
}
-#if ADC_USE_WAIT || defined(__DOXYGEN__)
+#if (ADC_USE_WAIT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Performs an ADC conversion.
* @details Performs a synchronous conversion operation.
@@ -281,9 +281,9 @@ msg_t adcConvert(ADCDriver *adcp, osalSysUnlock();
return msg;
}
-#endif /* ADC_USE_WAIT */
+#endif /* ADC_USE_WAIT == TRUE */
-#if ADC_USE_MUTUAL_EXCLUSION || defined(__DOXYGEN__)
+#if (ADC_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)
/**
* @brief Gains exclusive access to the ADC peripheral.
* @details This function tries to gain ownership to the ADC bus, if the bus
@@ -317,8 +317,8 @@ void adcReleaseBus(ADCDriver *adcp) { osalMutexUnlock(&adcp->mutex);
}
-#endif /* ADC_USE_MUTUAL_EXCLUSION */
+#endif /* ADC_USE_MUTUAL_EXCLUSION == TRUE */
-#endif /* HAL_USE_ADC */
+#endif /* HAL_USE_ADC == TRUE */
/** @} */
diff --git a/os/hal/src/can.c b/os/hal/src/can.c index 201828c98..094f9691f 100644 --- a/os/hal/src/can.c +++ b/os/hal/src/can.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_CAN || defined(__DOXYGEN__)
+#if (HAL_USE_CAN == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -77,10 +77,10 @@ void canObjectInit(CANDriver *canp) { osalEventObjectInit(&canp->rxfull_event);
osalEventObjectInit(&canp->txempty_event);
osalEventObjectInit(&canp->error_event);
-#if CAN_USE_SLEEP_MODE
+#if CAN_USE_SLEEP_MODE == TRUE
osalEventObjectInit(&canp->sleep_event);
osalEventObjectInit(&canp->wakeup_event);
-#endif /* CAN_USE_SLEEP_MODE */
+#endif
}
/**
@@ -104,8 +104,9 @@ void canStart(CANDriver *canp, const CANConfig *config) { (canp->state == CAN_STARTING) ||
(canp->state == CAN_READY),
"invalid state");
- while (canp->state == CAN_STARTING)
+ while (canp->state == CAN_STARTING) {
osalThreadSleepS(1);
+ }
if (canp->state == CAN_STOP) {
canp->config = config;
can_lld_start(canp);
@@ -163,13 +164,15 @@ msg_t canTransmit(CANDriver *canp, systime_t timeout) {
osalDbgCheck((canp != NULL) && (ctfp != NULL) &&
- (mailbox <= CAN_TX_MAILBOXES));
+ (mailbox <= (canmbx_t)CAN_TX_MAILBOXES));
osalSysLock();
osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
"invalid state");
+ /*lint -save -e9007 [13.5] Right side is supposed to be pure.*/
while ((canp->state == CAN_SLEEP) || !can_lld_is_tx_empty(canp, mailbox)) {
- msg_t msg = osalThreadEnqueueTimeoutS(&canp->txqueue, timeout);
+ /*lint -restore*/
+ msg_t msg = osalThreadEnqueueTimeoutS(&canp->txqueue, timeout);
if (msg != MSG_OK) {
osalSysUnlock();
return msg;
@@ -208,12 +211,14 @@ msg_t canReceive(CANDriver *canp, systime_t timeout) {
osalDbgCheck((canp != NULL) && (crfp != NULL) &&
- (mailbox < CAN_RX_MAILBOXES));
+ (mailbox < (canmbx_t)CAN_RX_MAILBOXES));
osalSysLock();
osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
"invalid state");
+ /*lint -save -e9007 [13.5] Right side is supposed to be pure.*/
while ((canp->state == CAN_SLEEP) || !can_lld_is_rx_nonempty(canp, mailbox)) {
+ /*lint -restore*/
msg_t msg = osalThreadEnqueueTimeoutS(&canp->rxqueue, timeout);
if (msg != MSG_OK) {
osalSysUnlock();
@@ -225,7 +230,7 @@ msg_t canReceive(CANDriver *canp, return MSG_OK;
}
-#if CAN_USE_SLEEP_MODE || defined(__DOXYGEN__)
+#if (CAN_USE_SLEEP_MODE == TRUE) || defined(__DOXYGEN__)
/**
* @brief Enters the sleep mode.
* @details This function puts the CAN driver in sleep mode and broadcasts
@@ -276,8 +281,8 @@ void canWakeup(CANDriver *canp) { }
osalSysUnlock();
}
-#endif /* CAN_USE_SLEEP_MODE */
+#endif /* CAN_USE_SLEEP_MODE == TRUE */
-#endif /* HAL_USE_CAN */
+#endif /* HAL_USE_CAN == TRUE */
/** @} */
diff --git a/os/hal/src/dac.c b/os/hal/src/dac.c index 47ec5b8f1..7ebbbc5c5 100644 --- a/os/hal/src/dac.c +++ b/os/hal/src/dac.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_DAC || defined(__DOXYGEN__)
+#if (HAL_USE_DAC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -74,10 +74,10 @@ void dacObjectInit(DACDriver *dacp) { dacp->config = NULL;
#if DAC_USE_WAIT
dacp->thread = NULL;
-#endif /* DAC_USE_WAIT */
+#endif
#if DAC_USE_MUTUAL_EXCLUSION
osalMutexObjectInit(&dacp->mutex);
-#endif /* DAC_USE_MUTUAL_EXCLUSION */
+#endif
#if defined(DAC_DRIVER_EXT_INIT_HOOK)
DAC_DRIVER_EXT_INIT_HOOK(dacp);
#endif
@@ -252,7 +252,7 @@ void dacStopConversionI(DACDriver *dacp) { }
}
-#if DAC_USE_WAIT || defined(__DOXYGEN__)
+#if (DAC_USE_WAIT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Performs a DAC conversion.
* @details Performs a synchronous conversion operation.
@@ -290,9 +290,9 @@ msg_t dacConvert(DACDriver *dacp, osalSysUnlock();
return msg;
}
-#endif /* DAC_USE_WAIT */
+#endif /* DAC_USE_WAIT == TRUE */
-#if DAC_USE_MUTUAL_EXCLUSION || defined(__DOXYGEN__)
+#if (DAC_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)
/**
* @brief Gains exclusive access to the DAC bus.
* @details This function tries to gain ownership to the DAC bus, if the bus
@@ -326,8 +326,8 @@ void dacReleaseBus(DACDriver *dacp) { osalMutexUnlock(&dacp->mutex);
}
-#endif /* DAC_USE_MUTUAL_EXCLUSION */
+#endif /* DAC_USE_MUTUAL_EXCLUSION == TRUE */
-#endif /* HAL_USE_DAC */
+#endif /* HAL_USE_DAC == TRUE */
/** @} */
diff --git a/os/hal/src/ext.c b/os/hal/src/ext.c index 6d67cb94e..feacdc0ef 100644 --- a/os/hal/src/ext.c +++ b/os/hal/src/ext.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_EXT || defined(__DOXYGEN__)
+#if (HAL_USE_EXT == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -127,7 +127,7 @@ void extStop(EXTDriver *extp) { */
void extChannelEnable(EXTDriver *extp, expchannel_t channel) {
- osalDbgCheck((extp != NULL) && (channel < EXT_MAX_CHANNELS));
+ osalDbgCheck((extp != NULL) && (channel < (expchannel_t)EXT_MAX_CHANNELS));
osalSysLock();
osalDbgAssert((extp->state == EXT_ACTIVE) &&
@@ -149,7 +149,7 @@ void extChannelEnable(EXTDriver *extp, expchannel_t channel) { */
void extChannelDisable(EXTDriver *extp, expchannel_t channel) {
- osalDbgCheck((extp != NULL) && (channel < EXT_MAX_CHANNELS));
+ osalDbgCheck((extp != NULL) && (channel < (expchannel_t)EXT_MAX_CHANNELS));
osalSysLock();
osalDbgAssert((extp->state == EXT_ACTIVE) &&
@@ -183,7 +183,7 @@ void extSetChannelModeI(EXTDriver *extp, EXTChannelConfig *oldcp;
osalDbgCheck((extp != NULL) &&
- (channel < EXT_MAX_CHANNELS) &&
+ (channel < (expchannel_t)EXT_MAX_CHANNELS) &&
(extcp != NULL));
osalDbgAssert(extp->state == EXT_ACTIVE, "invalid state");
@@ -198,6 +198,6 @@ void extSetChannelModeI(EXTDriver *extp, ext_lld_channel_enable(extp, channel);
}
-#endif /* HAL_USE_EXT */
+#endif /* HAL_USE_EXT == TRUE */
/** @} */
diff --git a/os/hal/src/gpt.c b/os/hal/src/gpt.c index c654b290e..2fa9718ec 100644 --- a/os/hal/src/gpt.c +++ b/os/hal/src/gpt.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_GPT || defined(__DOXYGEN__)
+#if (HAL_USE_GPT == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -260,6 +260,6 @@ void gptPolledDelay(GPTDriver *gptp, gptcnt_t interval) { gptp->state = GPT_READY;
}
-#endif /* HAL_USE_GPT */
+#endif /* HAL_USE_GPT == TRUE */
/** @} */
diff --git a/os/hal/src/hal.c b/os/hal/src/hal.c index 1ed95b835..4e9f9e26f 100644 --- a/os/hal/src/hal.c +++ b/os/hal/src/hal.c @@ -64,65 +64,70 @@ void halInit(void) { /* Platform low level initializations.*/
hal_lld_init();
-#if HAL_USE_PAL || defined(__DOXYGEN__)
+#if (HAL_USE_PAL == TRUE) || defined(__DOXYGEN__)
palInit(&pal_default_config);
#endif
-#if HAL_USE_ADC || defined(__DOXYGEN__)
+#if (HAL_USE_ADC == TRUE) || defined(__DOXYGEN__)
adcInit();
#endif
-#if HAL_USE_CAN || defined(__DOXYGEN__)
+#if (HAL_USE_CAN == TRUE) || defined(__DOXYGEN__)
canInit();
#endif
-#if HAL_USE_EXT || defined(__DOXYGEN__)
+#if (HAL_USE_DAC == TRUE) || defined(__DOXYGEN__)
+ dacInit();
+#endif
+#if (HAL_USE_EXT == TRUE) || defined(__DOXYGEN__)
extInit();
#endif
-#if HAL_USE_GPT || defined(__DOXYGEN__)
+#if (HAL_USE_GPT == TRUE) || defined(__DOXYGEN__)
gptInit();
#endif
-#if HAL_USE_I2C || defined(__DOXYGEN__)
+#if (HAL_USE_I2C == TRUE) || defined(__DOXYGEN__)
i2cInit();
#endif
-#if HAL_USE_I2S || defined(__DOXYGEN__)
+#if (HAL_USE_I2S == TRUE) || defined(__DOXYGEN__)
i2sInit();
#endif
-#if HAL_USE_ICU || defined(__DOXYGEN__)
+#if (HAL_USE_ICU == TRUE) || defined(__DOXYGEN__)
icuInit();
#endif
-#if HAL_USE_MAC || defined(__DOXYGEN__)
+#if (HAL_USE_MAC == TRUE) || defined(__DOXYGEN__)
macInit();
#endif
-#if HAL_USE_PWM || defined(__DOXYGEN__)
+#if (HAL_USE_PWM == TRUE) || defined(__DOXYGEN__)
pwmInit();
#endif
-#if HAL_USE_SERIAL || defined(__DOXYGEN__)
+#if (HAL_USE_SERIAL == TRUE) || defined(__DOXYGEN__)
sdInit();
#endif
-#if HAL_USE_SDC || defined(__DOXYGEN__)
+#if (HAL_USE_SDC == TRUE) || defined(__DOXYGEN__)
sdcInit();
#endif
-#if HAL_USE_SPI || defined(__DOXYGEN__)
+#if (HAL_USE_SPI == TRUE) || defined(__DOXYGEN__)
spiInit();
#endif
-#if HAL_USE_UART || defined(__DOXYGEN__)
+#if (HAL_USE_UART == TRUE) || defined(__DOXYGEN__)
uartInit();
#endif
-#if HAL_USE_USB || defined(__DOXYGEN__)
+#if (HAL_USE_USB == TRUE) || defined(__DOXYGEN__)
usbInit();
#endif
-#if HAL_USE_MMC_SPI || defined(__DOXYGEN__)
+#if (HAL_USE_MMC_SPI == TRUE) || defined(__DOXYGEN__)
mmcInit();
#endif
-#if HAL_USE_SERIAL_USB || defined(__DOXYGEN__)
+#if (HAL_USE_SERIAL_USB == TRUE) || defined(__DOXYGEN__)
sduInit();
#endif
-#if HAL_USE_RTC || defined(__DOXYGEN__)
+#if (HAL_USE_RTC == TRUE) || defined(__DOXYGEN__)
rtcInit();
#endif
/* Community driver overlay initialization.*/
-#if HAL_USE_COMMUNITY || defined(__DOXYGEN__)
+#if defined(HAL_USE_COMMUNITY) || defined(__DOXYGEN__)
+#if (HAL_USE_COMMUNITY == TRUE) || defined(__DOXYGEN__)
halCommunityInit();
#endif
+#endif
/* Board specific initialization.*/
boardInit();
diff --git a/os/hal/src/hal_mmcsd.c b/os/hal/src/hal_mmcsd.c index 887592cb6..41d03da39 100644 --- a/os/hal/src/hal_mmcsd.c +++ b/os/hal/src/hal_mmcsd.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_MMC_SPI || HAL_USE_SDC || defined(__DOXYGEN__)
+#if (HAL_USE_MMC_SPI == TRUE) || (HAL_USE_SDC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -67,17 +67,18 @@ uint32_t _mmcsd_get_slice(const uint32_t *data, unsigned startidx, endidx, startoff;
uint32_t endmask;
- osalDbgCheck((end >= start) && ((end - start) < 32));
+ osalDbgCheck((end >= start) && ((end - start) < 32U));
- startidx = start / 32;
- startoff = start % 32;
- endidx = end / 32;
- endmask = (1 << ((end % 32) + 1)) - 1;
+ startidx = start / 32U;
+ startoff = start % 32U;
+ endidx = end / 32U;
+ endmask = ((uint32_t)1U << ((end % 32U) + 1U)) - 1U;
/* One or two pieces?*/
- if (startidx < endidx)
+ if (startidx < endidx) {
return (data[startidx] >> startoff) | /* Two pieces case. */
- ((data[endidx] & endmask) << (32 - startoff));
+ ((data[endidx] & endmask) << (32U - startoff));
+ }
return (data[startidx] & endmask) >> startoff; /* One piece case. */
}
@@ -103,14 +104,15 @@ uint32_t _mmcsd_get_capacity(const uint32_t *csd) { a = _mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_SLICE);
b = _mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);
c = _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);
- return (a + 1) << (b + 2) << (c - 9); /* 2^9 == MMCSD_BLOCK_SIZE. */
+ return ((a + 1U) << (b + 2U)) << (c - 9U); /* 2^9 == MMCSD_BLOCK_SIZE. */
case 1:
/* CSD version 2.0.*/
- return 1024 * (_mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE) + 1);
+ return 1024U * (_mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE) + 1U);
default:
/* Reserved value detected.*/
- return 0;
+ break;
}
+ return 0U;
}
/**
@@ -127,10 +129,10 @@ uint32_t _mmcsd_get_capacity_ext(const uint8_t *ext_csd) { osalDbgCheck(NULL != ext_csd);
- return (ext_csd[215] << 24) +
- (ext_csd[214] << 16) +
- (ext_csd[213] << 8) +
- ext_csd[212];
+ return ((uint32_t)ext_csd[215] << 24U) +
+ ((uint32_t)ext_csd[214] << 16U) +
+ ((uint32_t)ext_csd[213] << 8U) +
+ (uint32_t)ext_csd[212];
}
/**
@@ -148,19 +150,20 @@ void _mmcsd_unpack_sdc_cid(const MMCSDBlockDevice *sdcp, osalDbgCheck((NULL != sdcp) && (NULL != cidsdc));
cid = sdcp->cid;
- cidsdc->crc = _mmcsd_get_slice(cid, MMCSD_CID_SDC_CRC_SLICE);
- cidsdc->mdt_y = _mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_Y_SLICE) + 2000;
- cidsdc->mdt_m = _mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_M_SLICE);
- cidsdc->mid = _mmcsd_get_slice(cid, MMCSD_CID_SDC_MID_SLICE);
- cidsdc->oid = _mmcsd_get_slice(cid, MMCSD_CID_SDC_OID_SLICE);
- cidsdc->pnm[4] = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM0_SLICE);
- cidsdc->pnm[3] = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM1_SLICE);
- cidsdc->pnm[2] = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM2_SLICE);
- cidsdc->pnm[1] = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM3_SLICE);
- cidsdc->pnm[0] = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM4_SLICE);
- cidsdc->prv_n = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_N_SLICE);
- cidsdc->prv_m = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_M_SLICE);
- cidsdc->psn = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PSN_SLICE);
+ cidsdc->crc = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_SDC_CRC_SLICE);
+ cidsdc->mdt_y = (uint16_t)_mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_Y_SLICE) +
+ 2000U;
+ cidsdc->mdt_m = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_SDC_MDT_M_SLICE);
+ cidsdc->mid = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_SDC_MID_SLICE);
+ cidsdc->oid = (uint16_t)_mmcsd_get_slice(cid, MMCSD_CID_SDC_OID_SLICE);
+ cidsdc->pnm[4] = (char) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM0_SLICE);
+ cidsdc->pnm[3] = (char) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM1_SLICE);
+ cidsdc->pnm[2] = (char) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM2_SLICE);
+ cidsdc->pnm[1] = (char) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM3_SLICE);
+ cidsdc->pnm[0] = (char) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PNM4_SLICE);
+ cidsdc->prv_n = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_N_SLICE);
+ cidsdc->prv_m = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_SDC_PRV_M_SLICE);
+ cidsdc->psn = _mmcsd_get_slice(cid, MMCSD_CID_SDC_PSN_SLICE);
}
/**
@@ -178,20 +181,21 @@ void _mmcsd_unpack_mmc_cid(const MMCSDBlockDevice *sdcp, osalDbgCheck((NULL != sdcp) && (NULL != cidmmc));
cid = sdcp->cid;
- cidmmc->crc = _mmcsd_get_slice(cid, MMCSD_CID_MMC_CRC_SLICE);
- cidmmc->mdt_y = _mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_Y_SLICE) + 1997;
- cidmmc->mdt_m = _mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_M_SLICE);
- cidmmc->mid = _mmcsd_get_slice(cid, MMCSD_CID_MMC_MID_SLICE);
- cidmmc->oid = _mmcsd_get_slice(cid, MMCSD_CID_MMC_OID_SLICE);
- cidmmc->pnm[5] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM0_SLICE);
- cidmmc->pnm[4] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM1_SLICE);
- cidmmc->pnm[3] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM2_SLICE);
- cidmmc->pnm[2] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM3_SLICE);
- cidmmc->pnm[1] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM4_SLICE);
- cidmmc->pnm[0] = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM5_SLICE);
- cidmmc->prv_n = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_N_SLICE);
- cidmmc->prv_m = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_M_SLICE);
- cidmmc->psn = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PSN_SLICE);
+ cidmmc->crc = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_MMC_CRC_SLICE);
+ cidmmc->mdt_y = (uint16_t)_mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_Y_SLICE) +
+ 1997U;
+ cidmmc->mdt_m = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_MMC_MDT_M_SLICE);
+ cidmmc->mid = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_MMC_MID_SLICE);
+ cidmmc->oid = (uint16_t)_mmcsd_get_slice(cid, MMCSD_CID_MMC_OID_SLICE);
+ cidmmc->pnm[5] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM0_SLICE);
+ cidmmc->pnm[4] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM1_SLICE);
+ cidmmc->pnm[3] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM2_SLICE);
+ cidmmc->pnm[2] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM3_SLICE);
+ cidmmc->pnm[1] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM4_SLICE);
+ cidmmc->pnm[0] = (char) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PNM5_SLICE);
+ cidmmc->prv_n = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_N_SLICE);
+ cidmmc->prv_m = (uint8_t) _mmcsd_get_slice(cid, MMCSD_CID_MMC_PRV_M_SLICE);
+ cidmmc->psn = _mmcsd_get_slice(cid, MMCSD_CID_MMC_PSN_SLICE);
}
/**
@@ -209,37 +213,37 @@ void _mmcsd_unpack_csd_mmc(const MMCSDBlockDevice *sdcp, osalDbgCheck((NULL != sdcp) && (NULL != csdmmc));
csd = sdcp->csd;
- csdmmc->c_size = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);
- csdmmc->c_size_mult = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);
- csdmmc->ccc = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_CCC_SLICE);
- csdmmc->copy = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_COPY_SLICE);
- csdmmc->crc = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_CRC_SLICE);
- csdmmc->csd_structure = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE);
- csdmmc->dsr_imp = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_DSR_IMP_SLICE);
- csdmmc->ecc = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ECC_SLICE);
- csdmmc->erase_grp_mult = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_MULT_SLICE);
- csdmmc->erase_grp_size = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_SIZE_SLICE);
- csdmmc->file_format = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_SLICE);
- csdmmc->file_format_grp = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_GRP_SLICE);
- csdmmc->nsac = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_NSAC_SLICE);
- csdmmc->perm_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_PERM_WRITE_PROTECT_SLICE);
- csdmmc->r2w_factor = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_R2W_FACTOR_SLICE);
- csdmmc->read_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);
- csdmmc->read_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_PARTIAL_SLICE);
- csdmmc->read_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BLK_MISALIGN_SLICE);
- csdmmc->spec_vers = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_SPEC_VERS_SLICE);
- csdmmc->taac = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TAAC_SLICE);
- csdmmc->tmp_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TMP_WRITE_PROTECT_SLICE);
- csdmmc->tran_speed = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TRAN_SPEED_SLICE);
- csdmmc->vdd_r_curr_max = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MAX_SLICE);
- csdmmc->vdd_r_curr_min = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MIN_SLICE);
- csdmmc->vdd_w_curr_max = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MAX_SLICE);
- csdmmc->vdd_w_curr_min = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MIN_SLICE);
- csdmmc->wp_grp_enable = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_ENABLE_SLICE);
- csdmmc->wp_grp_size = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_SIZE_SLICE);
- csdmmc->write_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_LEN_SLICE);
- csdmmc->write_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_PARTIAL_SLICE);
- csdmmc->write_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BLK_MISALIGN_SLICE);
+ csdmmc->c_size = (uint16_t)_mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_SLICE);
+ csdmmc->c_size_mult = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_C_SIZE_MULT_SLICE);
+ csdmmc->ccc = (uint16_t)_mmcsd_get_slice(csd, MMCSD_CSD_MMC_CCC_SLICE);
+ csdmmc->copy = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_COPY_SLICE);
+ csdmmc->crc = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_CRC_SLICE);
+ csdmmc->csd_structure = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE);
+ csdmmc->dsr_imp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_DSR_IMP_SLICE);
+ csdmmc->ecc = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ECC_SLICE);
+ csdmmc->erase_grp_mult = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_MULT_SLICE);
+ csdmmc->erase_grp_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_ERASE_GRP_SIZE_SLICE);
+ csdmmc->file_format = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_SLICE);
+ csdmmc->file_format_grp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_FILE_FORMAT_GRP_SLICE);
+ csdmmc->nsac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_NSAC_SLICE);
+ csdmmc->perm_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_PERM_WRITE_PROTECT_SLICE);
+ csdmmc->r2w_factor = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_R2W_FACTOR_SLICE);
+ csdmmc->read_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_LEN_SLICE);
+ csdmmc->read_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BL_PARTIAL_SLICE);
+ csdmmc->read_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_READ_BLK_MISALIGN_SLICE);
+ csdmmc->spec_vers = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_SPEC_VERS_SLICE);
+ csdmmc->taac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TAAC_SLICE);
+ csdmmc->tmp_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TMP_WRITE_PROTECT_SLICE);
+ csdmmc->tran_speed = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_TRAN_SPEED_SLICE);
+ csdmmc->vdd_r_curr_max = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MAX_SLICE);
+ csdmmc->vdd_r_curr_min = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_R_CURR_MIN_SLICE);
+ csdmmc->vdd_w_curr_max = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MAX_SLICE);
+ csdmmc->vdd_w_curr_min = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_VDD_W_CURR_MIN_SLICE);
+ csdmmc->wp_grp_enable = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_ENABLE_SLICE);
+ csdmmc->wp_grp_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WP_GRP_SIZE_SLICE);
+ csdmmc->write_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_LEN_SLICE);
+ csdmmc->write_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BL_PARTIAL_SLICE);
+ csdmmc->write_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_MMC_WRITE_BLK_MISALIGN_SLICE);
}
/**
@@ -257,31 +261,31 @@ void _mmcsd_unpack_csd_v10(const MMCSDBlockDevice *sdcp, osalDbgCheck(NULL != sdcp);
csd = sdcp->csd;
- csd10->c_size = _mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_SLICE);
- csd10->c_size_mult = _mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);
- csd10->ccc = _mmcsd_get_slice(csd, MMCSD_CSD_10_CCC_SLICE);
- csd10->copy = _mmcsd_get_slice(csd, MMCSD_CSD_10_COPY_SLICE);
- csd10->crc = _mmcsd_get_slice(csd, MMCSD_CSD_10_CRC_SLICE);
- csd10->csd_structure = _mmcsd_get_slice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE);
- csd10->dsr_imp = _mmcsd_get_slice(csd, MMCSD_CSD_10_DSR_IMP_SLICE);
- csd10->erase_blk_en = _mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_BLK_EN_SLICE);
- csd10->erase_sector_size = _mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_SECTOR_SIZE_SLICE);
- csd10->file_format = _mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_SLICE);
- csd10->file_format_grp = _mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_GRP_SLICE);
- csd10->nsac = _mmcsd_get_slice(csd, MMCSD_CSD_10_NSAC_SLICE);
- csd10->perm_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_10_PERM_WRITE_PROTECT_SLICE);
- csd10->r2w_factor = _mmcsd_get_slice(csd, MMCSD_CSD_10_R2W_FACTOR_SLICE);
- csd10->read_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);
- csd10->read_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_PARTIAL_SLICE);
- csd10->read_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BLK_MISALIGN_SLICE);
- csd10->taac = _mmcsd_get_slice(csd, MMCSD_CSD_10_TAAC_SLICE);
- csd10->tmp_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_10_TMP_WRITE_PROTECT_SLICE);
- csd10->tran_speed = _mmcsd_get_slice(csd, MMCSD_CSD_10_TRANS_SPEED_SLICE);
- csd10->wp_grp_enable = _mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_ENABLE_SLICE);
- csd10->wp_grp_size = _mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_SIZE_SLICE);
- csd10->write_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_LEN_SLICE);
- csd10->write_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_PARTIAL_SLICE);
- csd10->write_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BLK_MISALIGN_SLICE);
+ csd10->c_size = (uint16_t)_mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_SLICE);
+ csd10->c_size_mult = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_C_SIZE_MULT_SLICE);
+ csd10->ccc = (uint16_t)_mmcsd_get_slice(csd, MMCSD_CSD_10_CCC_SLICE);
+ csd10->copy = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_COPY_SLICE);
+ csd10->crc = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_CRC_SLICE);
+ csd10->csd_structure = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_CSD_STRUCTURE_SLICE);
+ csd10->dsr_imp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_DSR_IMP_SLICE);
+ csd10->erase_blk_en = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_BLK_EN_SLICE);
+ csd10->erase_sector_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_ERASE_SECTOR_SIZE_SLICE);
+ csd10->file_format = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_SLICE);
+ csd10->file_format_grp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_FILE_FORMAT_GRP_SLICE);
+ csd10->nsac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_NSAC_SLICE);
+ csd10->perm_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_PERM_WRITE_PROTECT_SLICE);
+ csd10->r2w_factor = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_R2W_FACTOR_SLICE);
+ csd10->read_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_LEN_SLICE);
+ csd10->read_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BL_PARTIAL_SLICE);
+ csd10->read_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_READ_BLK_MISALIGN_SLICE);
+ csd10->taac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_TAAC_SLICE);
+ csd10->tmp_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_TMP_WRITE_PROTECT_SLICE);
+ csd10->tran_speed = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_TRANS_SPEED_SLICE);
+ csd10->wp_grp_enable = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_ENABLE_SLICE);
+ csd10->wp_grp_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_WP_GRP_SIZE_SLICE);
+ csd10->write_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_LEN_SLICE);
+ csd10->write_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BL_PARTIAL_SLICE);
+ csd10->write_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_10_WRITE_BLK_MISALIGN_SLICE);
}
/**
@@ -299,32 +303,32 @@ void _mmcsd_unpack_csd_v20(const MMCSDBlockDevice *sdcp, osalDbgCheck(NULL != sdcp);
csd = sdcp->csd;
- csd20->c_size = _mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE);
- csd20->crc = _mmcsd_get_slice(csd, MMCSD_CSD_20_CRC_SLICE);
- csd20->ccc = _mmcsd_get_slice(csd, MMCSD_CSD_20_CCC_SLICE);
- csd20->copy = _mmcsd_get_slice(csd, MMCSD_CSD_20_COPY_SLICE);
- csd20->csd_structure = _mmcsd_get_slice(csd, MMCSD_CSD_20_CSD_STRUCTURE_SLICE);
- csd20->dsr_imp = _mmcsd_get_slice(csd, MMCSD_CSD_20_DSR_IMP_SLICE);
- csd20->erase_blk_en = _mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_BLK_EN_SLICE);
- csd20->file_format = _mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_SLICE);
- csd20->file_format_grp = _mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_GRP_SLICE);
- csd20->nsac = _mmcsd_get_slice(csd, MMCSD_CSD_20_NSAC_SLICE);
- csd20->perm_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_20_PERM_WRITE_PROTECT_SLICE);
- csd20->r2w_factor = _mmcsd_get_slice(csd, MMCSD_CSD_20_R2W_FACTOR_SLICE);
- csd20->read_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_LEN_SLICE);
- csd20->read_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_PARTIAL_SLICE);
- csd20->read_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BLK_MISALIGN_SLICE);
- csd20->erase_sector_size = _mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_SECTOR_SIZE_SLICE);
- csd20->taac = _mmcsd_get_slice(csd, MMCSD_CSD_20_TAAC_SLICE);
- csd20->tmp_write_protect = _mmcsd_get_slice(csd, MMCSD_CSD_20_TMP_WRITE_PROTECT_SLICE);
- csd20->tran_speed = _mmcsd_get_slice(csd, MMCSD_CSD_20_TRANS_SPEED_SLICE);
- csd20->wp_grp_enable = _mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_ENABLE_SLICE);
- csd20->wp_grp_size = _mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_SIZE_SLICE);
- csd20->write_bl_len = _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_LEN_SLICE);
- csd20->write_bl_partial = _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_PARTIAL_SLICE);
- csd20->write_blk_misalign = _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BLK_MISALIGN_SLICE);
+ csd20->c_size = _mmcsd_get_slice(csd, MMCSD_CSD_20_C_SIZE_SLICE);
+ csd20->crc = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_CRC_SLICE);
+ csd20->ccc = (uint16_t)_mmcsd_get_slice(csd, MMCSD_CSD_20_CCC_SLICE);
+ csd20->copy = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_COPY_SLICE);
+ csd20->csd_structure = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_CSD_STRUCTURE_SLICE);
+ csd20->dsr_imp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_DSR_IMP_SLICE);
+ csd20->erase_blk_en = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_BLK_EN_SLICE);
+ csd20->file_format = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_SLICE);
+ csd20->file_format_grp = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_FILE_FORMAT_GRP_SLICE);
+ csd20->nsac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_NSAC_SLICE);
+ csd20->perm_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_PERM_WRITE_PROTECT_SLICE);
+ csd20->r2w_factor = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_R2W_FACTOR_SLICE);
+ csd20->read_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_LEN_SLICE);
+ csd20->read_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BL_PARTIAL_SLICE);
+ csd20->read_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_READ_BLK_MISALIGN_SLICE);
+ csd20->erase_sector_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_ERASE_SECTOR_SIZE_SLICE);
+ csd20->taac = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_TAAC_SLICE);
+ csd20->tmp_write_protect = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_TMP_WRITE_PROTECT_SLICE);
+ csd20->tran_speed = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_TRANS_SPEED_SLICE);
+ csd20->wp_grp_enable = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_ENABLE_SLICE);
+ csd20->wp_grp_size = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_WP_GRP_SIZE_SLICE);
+ csd20->write_bl_len = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_LEN_SLICE);
+ csd20->write_bl_partial = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BL_PARTIAL_SLICE);
+ csd20->write_blk_misalign = (uint8_t) _mmcsd_get_slice(csd, MMCSD_CSD_20_WRITE_BLK_MISALIGN_SLICE);
}
-#endif /* HAL_USE_MMC_SPI || HAL_USE_SDC */
+#endif /* (HAL_USE_MMC_SPI == TRUE) || (HAL_USE_SDC == TRUE) */
/** @} */
diff --git a/os/hal/src/hal_queues.c b/os/hal/src/hal_queues.c index 9d4c6d330..d825674ec 100644 --- a/os/hal/src/hal_queues.c +++ b/os/hal/src/hal_queues.c @@ -40,7 +40,8 @@ #include "hal.h"
-#if !defined(_CHIBIOS_RT_) || !CH_CFG_USE_QUEUES || defined(__DOXYGEN__)
+#if !defined(_CHIBIOS_RT_) || (CH_CFG_USE_QUEUES == FALSE) || \
+ defined(__DOXYGEN__)
/**
* @brief Initializes an input queue.
@@ -62,7 +63,9 @@ void iqObjectInit(input_queue_t *iqp, uint8_t *bp, size_t size, osalThreadQueueObjectInit(&iqp->q_waiting);
iqp->q_counter = 0;
- iqp->q_buffer = iqp->q_rdptr = iqp->q_wrptr = bp;
+ iqp->q_buffer = bp;
+ iqp->q_rdptr = bp;
+ iqp->q_wrptr = bp;
iqp->q_top = bp + size;
iqp->q_notify = infy;
iqp->q_link = link;
@@ -83,7 +86,8 @@ void iqResetI(input_queue_t *iqp) { osalDbgCheckClassI();
- iqp->q_rdptr = iqp->q_wrptr = iqp->q_buffer;
+ iqp->q_rdptr = iqp->q_buffer;
+ iqp->q_wrptr = iqp->q_buffer;
iqp->q_counter = 0;
osalThreadDequeueAllI(&iqp->q_waiting, Q_RESET);
}
@@ -105,13 +109,15 @@ msg_t iqPutI(input_queue_t *iqp, uint8_t b) { osalDbgCheckClassI();
- if (iqIsFullI(iqp))
+ if (iqIsFullI(iqp)) {
return Q_FULL;
+ }
iqp->q_counter++;
*iqp->q_wrptr++ = b;
- if (iqp->q_wrptr >= iqp->q_top)
+ if (iqp->q_wrptr >= iqp->q_top) {
iqp->q_wrptr = iqp->q_buffer;
+ }
osalThreadDequeueNextI(&iqp->q_waiting, Q_OK);
@@ -127,7 +133,7 @@ msg_t iqPutI(input_queue_t *iqp, uint8_t b) { * buffer or before entering the state @p THD_STATE_WTQUEUE.
*
* @param[in] iqp pointer to an @p input_queue_t structure
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -138,16 +144,17 @@ msg_t iqPutI(input_queue_t *iqp, uint8_t b) { *
* @api
*/
-msg_t iqGetTimeout(input_queue_t *iqp, systime_t time) {
+msg_t iqGetTimeout(input_queue_t *iqp, systime_t timeout) {
uint8_t b;
osalSysLock();
- if (iqp->q_notify)
+ if (iqp->q_notify != NULL) {
iqp->q_notify(iqp);
+ }
while (iqIsEmptyI(iqp)) {
- msg_t msg;
- if ((msg = osalThreadEnqueueTimeoutS(&iqp->q_waiting, time)) < Q_OK) {
+ msg_t msg = osalThreadEnqueueTimeoutS(&iqp->q_waiting, timeout);
+ if (msg < Q_OK) {
osalSysUnlock();
return msg;
}
@@ -155,11 +162,12 @@ msg_t iqGetTimeout(input_queue_t *iqp, systime_t time) { iqp->q_counter--;
b = *iqp->q_rdptr++;
- if (iqp->q_rdptr >= iqp->q_top)
+ if (iqp->q_rdptr >= iqp->q_top) {
iqp->q_rdptr = iqp->q_buffer;
-
+ }
osalSysUnlock();
- return b;
+
+ return (msg_t)b;
}
/**
@@ -177,7 +185,7 @@ msg_t iqGetTimeout(input_queue_t *iqp, systime_t time) { * @param[out] bp pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred, the
* value 0 is reserved
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -187,19 +195,20 @@ msg_t iqGetTimeout(input_queue_t *iqp, systime_t time) { * @api
*/
size_t iqReadTimeout(input_queue_t *iqp, uint8_t *bp,
- size_t n, systime_t time) {
+ size_t n, systime_t timeout) {
qnotify_t nfy = iqp->q_notify;
size_t r = 0;
- osalDbgCheck(n > 0);
+ osalDbgCheck(n > 0U);
osalSysLock();
- while (TRUE) {
- if (nfy)
+ while (true) {
+ if (nfy != NULL) {
nfy(iqp);
+ }
while (iqIsEmptyI(iqp)) {
- if (osalThreadEnqueueTimeoutS(&iqp->q_waiting, time) != Q_OK) {
+ if (osalThreadEnqueueTimeoutS(&iqp->q_waiting, timeout) != Q_OK) {
osalSysUnlock();
return r;
}
@@ -207,13 +216,15 @@ size_t iqReadTimeout(input_queue_t *iqp, uint8_t *bp, iqp->q_counter--;
*bp++ = *iqp->q_rdptr++;
- if (iqp->q_rdptr >= iqp->q_top)
+ if (iqp->q_rdptr >= iqp->q_top) {
iqp->q_rdptr = iqp->q_buffer;
-
+ }
osalSysUnlock(); /* Gives a preemption chance in a controlled point.*/
+
r++;
- if (--n == 0)
+ if (--n == 0U) {
return r;
+ }
osalSysLock();
}
@@ -239,7 +250,9 @@ void oqObjectInit(output_queue_t *oqp, uint8_t *bp, size_t size, osalThreadQueueObjectInit(&oqp->q_waiting);
oqp->q_counter = size;
- oqp->q_buffer = oqp->q_rdptr = oqp->q_wrptr = bp;
+ oqp->q_buffer = bp;
+ oqp->q_rdptr = bp;
+ oqp->q_wrptr = bp;
oqp->q_top = bp + size;
oqp->q_notify = onfy;
oqp->q_link = link;
@@ -260,8 +273,9 @@ void oqResetI(output_queue_t *oqp) { osalDbgCheckClassI();
- oqp->q_rdptr = oqp->q_wrptr = oqp->q_buffer;
- oqp->q_counter = qSizeI(oqp);
+ oqp->q_rdptr = oqp->q_buffer;
+ oqp->q_wrptr = oqp->q_buffer;
+ oqp->q_counter = qSizeX(oqp);
osalThreadDequeueAllI(&oqp->q_waiting, Q_RESET);
}
@@ -275,7 +289,7 @@ void oqResetI(output_queue_t *oqp) { *
* @param[in] oqp pointer to an @p output_queue_t structure
* @param[in] b the byte value to be written in the queue
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -287,13 +301,12 @@ void oqResetI(output_queue_t *oqp) { *
* @api
*/
-msg_t oqPutTimeout(output_queue_t *oqp, uint8_t b, systime_t time) {
+msg_t oqPutTimeout(output_queue_t *oqp, uint8_t b, systime_t timeout) {
osalSysLock();
while (oqIsFullI(oqp)) {
- msg_t msg;
-
- if ((msg = osalThreadEnqueueTimeoutS(&oqp->q_waiting, time)) < Q_OK) {
+ msg_t msg = osalThreadEnqueueTimeoutS(&oqp->q_waiting, timeout);
+ if (msg < Q_OK) {
osalSysUnlock();
return msg;
}
@@ -301,13 +314,15 @@ msg_t oqPutTimeout(output_queue_t *oqp, uint8_t b, systime_t time) { oqp->q_counter--;
*oqp->q_wrptr++ = b;
- if (oqp->q_wrptr >= oqp->q_top)
+ if (oqp->q_wrptr >= oqp->q_top) {
oqp->q_wrptr = oqp->q_buffer;
+ }
- if (oqp->q_notify)
+ if (oqp->q_notify != NULL) {
oqp->q_notify(oqp);
-
+ }
osalSysUnlock();
+
return Q_OK;
}
@@ -326,17 +341,19 @@ msg_t oqGetI(output_queue_t *oqp) { osalDbgCheckClassI();
- if (oqIsEmptyI(oqp))
+ if (oqIsEmptyI(oqp)) {
return Q_EMPTY;
+ }
oqp->q_counter++;
b = *oqp->q_rdptr++;
- if (oqp->q_rdptr >= oqp->q_top)
+ if (oqp->q_rdptr >= oqp->q_top) {
oqp->q_rdptr = oqp->q_buffer;
+ }
osalThreadDequeueNextI(&oqp->q_waiting, Q_OK);
- return b;
+ return (msg_t)b;
}
/**
@@ -354,7 +371,7 @@ msg_t oqGetI(output_queue_t *oqp) { * @param[out] bp pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred, the
* value 0 is reserved
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -364,36 +381,40 @@ msg_t oqGetI(output_queue_t *oqp) { * @api
*/
size_t oqWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
- size_t n, systime_t time) {
+ size_t n, systime_t timeout) {
qnotify_t nfy = oqp->q_notify;
size_t w = 0;
- osalDbgCheck(n > 0);
+ osalDbgCheck(n > 0U);
osalSysLock();
- while (TRUE) {
+ while (true) {
while (oqIsFullI(oqp)) {
- if (osalThreadEnqueueTimeoutS(&oqp->q_waiting, time) != Q_OK) {
+ if (osalThreadEnqueueTimeoutS(&oqp->q_waiting, timeout) != Q_OK) {
osalSysUnlock();
return w;
}
}
oqp->q_counter--;
*oqp->q_wrptr++ = *bp++;
- if (oqp->q_wrptr >= oqp->q_top)
+ if (oqp->q_wrptr >= oqp->q_top) {
oqp->q_wrptr = oqp->q_buffer;
+ }
- if (nfy)
+ if (nfy != NULL) {
nfy(oqp);
-
+ }
osalSysUnlock(); /* Gives a preemption chance in a controlled point.*/
+
w++;
- if (--n == 0)
+ if (--n == 0U) {
return w;
+ }
+
osalSysLock();
}
}
-#endif /* !defined(_CHIBIOS_RT_) || !CH_USE_QUEUES */
+#endif /* !defined(_CHIBIOS_RT_) || (CH_USE_QUEUES == FALSE) */
/** @} */
diff --git a/os/hal/src/i2c.c b/os/hal/src/i2c.c index c463c3b08..0583833aa 100644 --- a/os/hal/src/i2c.c +++ b/os/hal/src/i2c.c @@ -30,7 +30,7 @@ */
#include "hal.h"
-#if HAL_USE_I2C || defined(__DOXYGEN__)
+#if (HAL_USE_I2C == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -76,9 +76,9 @@ void i2cObjectInit(I2CDriver *i2cp) { i2cp->state = I2C_STOP;
i2cp->config = NULL;
-#if I2C_USE_MUTUAL_EXCLUSION
+#if I2C_USE_MUTUAL_EXCLUSION == TRUE
osalMutexObjectInit(&i2cp->mutex);
-#endif /* I2C_USE_MUTUAL_EXCLUSION */
+#endif
#if defined(I2C_DRIVER_EXT_INIT_HOOK)
I2C_DRIVER_EXT_INIT_HOOK(i2cp);
@@ -175,9 +175,9 @@ msg_t i2cMasterTransmitTimeout(I2CDriver *i2cp, systime_t timeout) {
msg_t rdymsg;
- osalDbgCheck((i2cp != NULL) && (addr != 0) &&
- (txbytes > 0) && (txbuf != NULL) &&
- ((rxbytes == 0) || ((rxbytes > 0) && (rxbuf != NULL))) &&
+ osalDbgCheck((i2cp != NULL) && (addr != 0U) &&
+ (txbytes > 0U) && (txbuf != NULL) &&
+ ((rxbytes == 0U) || ((rxbytes > 0U) && (rxbuf != NULL))) &&
(timeout != TIME_IMMEDIATE));
osalDbgAssert(i2cp->state == I2C_READY, "not ready");
@@ -187,10 +187,12 @@ msg_t i2cMasterTransmitTimeout(I2CDriver *i2cp, i2cp->state = I2C_ACTIVE_TX;
rdymsg = i2c_lld_master_transmit_timeout(i2cp, addr, txbuf, txbytes,
rxbuf, rxbytes, timeout);
- if (rdymsg == MSG_TIMEOUT)
+ if (rdymsg == MSG_TIMEOUT) {
i2cp->state = I2C_LOCKED;
- else
+ }
+ else {
i2cp->state = I2C_READY;
+ }
osalSysUnlock();
return rdymsg;
}
@@ -223,8 +225,8 @@ msg_t i2cMasterReceiveTimeout(I2CDriver *i2cp, msg_t rdymsg;
- osalDbgCheck((i2cp != NULL) && (addr != 0) &&
- (rxbytes > 0) && (rxbuf != NULL) &&
+ osalDbgCheck((i2cp != NULL) && (addr != 0U) &&
+ (rxbytes > 0U) && (rxbuf != NULL) &&
(timeout != TIME_IMMEDIATE));
osalDbgAssert(i2cp->state == I2C_READY, "not ready");
@@ -233,15 +235,17 @@ msg_t i2cMasterReceiveTimeout(I2CDriver *i2cp, i2cp->errors = I2C_NO_ERROR;
i2cp->state = I2C_ACTIVE_RX;
rdymsg = i2c_lld_master_receive_timeout(i2cp, addr, rxbuf, rxbytes, timeout);
- if (rdymsg == MSG_TIMEOUT)
+ if (rdymsg == MSG_TIMEOUT) {
i2cp->state = I2C_LOCKED;
- else
+ }
+ else {
i2cp->state = I2C_READY;
+ }
osalSysUnlock();
return rdymsg;
}
-#if I2C_USE_MUTUAL_EXCLUSION || defined(__DOXYGEN__)
+#if (I2C_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)
/**
* @brief Gains exclusive access to the I2C bus.
* @details This function tries to gain ownership to the I2C bus, if the bus
@@ -275,8 +279,8 @@ void i2cReleaseBus(I2CDriver *i2cp) { osalMutexUnlock(&i2cp->mutex);
}
-#endif /* I2C_USE_MUTUAL_EXCLUSION */
+#endif /* I2C_USE_MUTUAL_EXCLUSION == TRUE */
-#endif /* HAL_USE_I2C */
+#endif /* HAL_USE_I2C == TRUE */
/** @} */
diff --git a/os/hal/src/i2s.c b/os/hal/src/i2s.c index 0e0349a6d..b40881339 100644 --- a/os/hal/src/i2s.c +++ b/os/hal/src/i2s.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_I2S || defined(__DOXYGEN__)
+#if (HAL_USE_I2S == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -153,6 +153,6 @@ void i2sStopExchange(I2SDriver *i2sp) { osalSysUnlock();
}
-#endif /* HAL_USE_I2S */
+#endif /* HAL_USE_I2S == TRUE */
/** @} */
diff --git a/os/hal/src/icu.c b/os/hal/src/icu.c index 02a777de0..995155df0 100644 --- a/os/hal/src/icu.c +++ b/os/hal/src/icu.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_ICU || defined(__DOXYGEN__)
+#if (HAL_USE_ICU == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -223,6 +223,6 @@ void icuDisableNotifications(ICUDriver *icup) { osalSysUnlock();
}
-#endif /* HAL_USE_ICU */
+#endif /* HAL_USE_ICU == TRUE */
/** @} */
diff --git a/os/hal/src/mac.c b/os/hal/src/mac.c index 90fa71a2d..88c32f3cc 100644 --- a/os/hal/src/mac.c +++ b/os/hal/src/mac.c @@ -27,13 +27,13 @@ #include "hal.h"
-#if HAL_USE_MAC || defined(__DOXYGEN__)
+#if (HAL_USE_MAC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
-#if MAC_USE_ZERO_COPY && !MAC_SUPPORTS_ZERO_COPY
+#if (MAC_USE_ZERO_COPY == TRUE) && (MAC_SUPPORTS_ZERO_COPY == FALSE)
#error "MAC_USE_ZERO_COPY not supported by this implementation"
#endif
@@ -82,7 +82,7 @@ void macObjectInit(MACDriver *macp) { macp->config = NULL;
osalThreadQueueObjectInit(&macp->tdqueue);
osalThreadQueueObjectInit(&macp->rdqueue);
-#if MAC_USE_EVENTS
+#if MAC_USE_EVENTS == TRUE
osalEventObjectInit(&macp->rdevent);
#endif
}
@@ -135,7 +135,7 @@ void macStop(MACDriver *macp) { *
* @param[in] macp pointer to the @p MACDriver object
* @param[out] tdp pointer to a @p MACTransmitDescriptor structure
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -148,7 +148,7 @@ void macStop(MACDriver *macp) { */
msg_t macWaitTransmitDescriptor(MACDriver *macp,
MACTransmitDescriptor *tdp,
- systime_t time) {
+ systime_t timeout) {
msg_t msg;
systime_t now;
@@ -156,16 +156,17 @@ msg_t macWaitTransmitDescriptor(MACDriver *macp, osalDbgAssert(macp->state == MAC_ACTIVE, "not active");
while (((msg = mac_lld_get_transmit_descriptor(macp, tdp)) != MSG_OK) &&
- (time > 0)) {
+ (timeout > 0U)) {
osalSysLock();
now = osalOsGetSystemTimeX();
- msg = osalThreadEnqueueTimeoutS(&macp->tdqueue, time);
+ msg = osalThreadEnqueueTimeoutS(&macp->tdqueue, timeout);
if (msg == MSG_TIMEOUT) {
osalSysUnlock();
break;
}
- if (time != TIME_INFINITE)
- time -= (osalOsGetSystemTimeX() - now);
+ if (timeout != TIME_INFINITE) {
+ timeout -= (osalOsGetSystemTimeX() - now);
+ }
osalSysUnlock();
}
return msg;
@@ -194,7 +195,7 @@ void macReleaseTransmitDescriptor(MACTransmitDescriptor *tdp) { *
* @param[in] macp pointer to the @p MACDriver object
* @param[out] rdp pointer to a @p MACReceiveDescriptor structure
- * @param[in] time the number of ticks before the operation timeouts,
+ * @param[in] timeout the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
@@ -207,7 +208,7 @@ void macReleaseTransmitDescriptor(MACTransmitDescriptor *tdp) { */
msg_t macWaitReceiveDescriptor(MACDriver *macp,
MACReceiveDescriptor *rdp,
- systime_t time) {
+ systime_t timeout) {
msg_t msg;
systime_t now;
@@ -215,16 +216,17 @@ msg_t macWaitReceiveDescriptor(MACDriver *macp, osalDbgAssert(macp->state == MAC_ACTIVE, "not active");
while (((msg = mac_lld_get_receive_descriptor(macp, rdp)) != MSG_OK) &&
- (time > 0)) {
+ (timeout > 0U)) {
osalSysLock();
now = osalOsGetSystemTimeX();
- msg = osalThreadEnqueueTimeoutS(&macp->rdqueue, time);
+ msg = osalThreadEnqueueTimeoutS(&macp->rdqueue, timeout);
if (msg == MSG_TIMEOUT) {
osalSysUnlock();
break;
}
- if (time != TIME_INFINITE)
- time -= (osalOsGetSystemTimeX() - now);
+ if (timeout != TIME_INFINITE) {
+ timeout -= (osalOsGetSystemTimeX() - now);
+ }
osalSysUnlock();
}
return msg;
@@ -264,6 +266,6 @@ bool macPollLinkStatus(MACDriver *macp) { return mac_lld_poll_link_status(macp);
}
-#endif /* HAL_USE_MAC */
+#endif /* HAL_USE_MAC == TRUE */
/** @} */
diff --git a/os/hal/src/mmc_spi.c b/os/hal/src/mmc_spi.c index 4382005be..87c4df3af 100644 --- a/os/hal/src/mmc_spi.c +++ b/os/hal/src/mmc_spi.c @@ -32,7 +32,7 @@ #include "hal.h"
-#if HAL_USE_MMC_SPI || defined(__DOXYGEN__)
+#if (HAL_USE_MMC_SPI == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -101,32 +101,42 @@ static const uint8_t crc7_lookup_table[256] = { static bool mmc_read(void *instance, uint32_t startblk,
uint8_t *buffer, uint32_t n) {
- if (mmcStartSequentialRead((MMCDriver *)instance, startblk))
+ if (mmcStartSequentialRead((MMCDriver *)instance, startblk)) {
return HAL_FAILED;
- while (n > 0) {
- if (mmcSequentialRead((MMCDriver *)instance, buffer))
+ }
+
+ while (n > 0U) {
+ if (mmcSequentialRead((MMCDriver *)instance, buffer)) {
return HAL_FAILED;
+ }
buffer += MMCSD_BLOCK_SIZE;
n--;
}
- if (mmcStopSequentialRead((MMCDriver *)instance))
- return HAL_FAILED;
+
+ if (mmcStopSequentialRead((MMCDriver *)instance)) {
+ return HAL_FAILED;
+ }
return HAL_SUCCESS;
}
static bool mmc_write(void *instance, uint32_t startblk,
const uint8_t *buffer, uint32_t n) {
- if (mmcStartSequentialWrite((MMCDriver *)instance, startblk))
- return HAL_FAILED;
- while (n > 0) {
- if (mmcSequentialWrite((MMCDriver *)instance, buffer))
- return HAL_FAILED;
- buffer += MMCSD_BLOCK_SIZE;
- n--;
+ if (mmcStartSequentialWrite((MMCDriver *)instance, startblk)) {
+ return HAL_FAILED;
}
- if (mmcStopSequentialWrite((MMCDriver *)instance))
+
+ while (n > 0U) {
+ if (mmcSequentialWrite((MMCDriver *)instance, buffer)) {
return HAL_FAILED;
+ }
+ buffer += MMCSD_BLOCK_SIZE;
+ n--;
+ }
+
+ if (mmcStopSequentialWrite((MMCDriver *)instance)) {
+ return HAL_FAILED;
+ }
return HAL_SUCCESS;
}
@@ -140,8 +150,10 @@ static bool mmc_write(void *instance, uint32_t startblk, */
static uint8_t crc7(uint8_t crc, const uint8_t *buffer, size_t len) {
- while (len--)
+ while (len > 0U) {
crc = crc7_lookup_table[(crc << 1) ^ (*buffer++)];
+ len--;
+ }
return crc;
}
@@ -158,15 +170,17 @@ static void wait(MMCDriver *mmcp) { for (i = 0; i < 16; i++) {
spiReceive(mmcp->config->spip, 1, buf);
- if (buf[0] == 0xFF)
+ if (buf[0] == 0xFFU) {
return;
+ }
}
/* Looks like it is a long wait.*/
- while (TRUE) {
+ while (true) {
spiReceive(mmcp->config->spip, 1, buf);
- if (buf[0] == 0xFF)
+ if (buf[0] == 0xFFU) {
break;
-#ifdef MMC_NICE_WAITING
+ }
+#if MMC_NICE_WAITING == TRUE
/* Trying to be nice with the other threads.*/
osalThreadSleep(1);
#endif
@@ -188,13 +202,13 @@ static void send_hdr(MMCDriver *mmcp, uint8_t cmd, uint32_t arg) { /* Wait for the bus to become idle if a write operation was in progress.*/
wait(mmcp);
- buf[0] = 0x40 | cmd;
- buf[1] = arg >> 24;
- buf[2] = arg >> 16;
- buf[3] = arg >> 8;
- buf[4] = arg;
+ buf[0] = (uint8_t)0x40U | cmd;
+ buf[1] = (uint8_t)(arg >> 24U);
+ buf[2] = (uint8_t)(arg >> 16U);
+ buf[3] = (uint8_t)(arg >> 8U);
+ buf[4] = (uint8_t)arg;
/* Calculate CRC for command header, shift to right position, add stop bit.*/
- buf[5] = ((crc7(0, buf, 5) & 0x7F) << 1) | 0x01;
+ buf[5] = ((crc7(0, buf, 5U) & 0x7FU) << 1U) | 0x01U;
spiSend(mmcp->config->spip, 6, buf);
}
@@ -214,10 +228,11 @@ static uint8_t recvr1(MMCDriver *mmcp) { for (i = 0; i < 9; i++) {
spiReceive(mmcp->config->spip, 1, r1);
- if (r1[0] != 0xFF)
+ if (r1[0] != 0xFFU) {
return r1[0];
+ }
}
- return 0xFF;
+ return 0xFFU;
}
/**
@@ -303,22 +318,22 @@ static bool read_CxD(MMCDriver *mmcp, uint8_t cmd, uint32_t cxd[4]) { spiSelect(mmcp->config->spip);
send_hdr(mmcp, cmd, 0);
- if (recvr1(mmcp) != 0x00) {
+ if (recvr1(mmcp) != 0x00U) {
spiUnselect(mmcp->config->spip);
return HAL_FAILED;
}
/* Wait for data availability.*/
- for (i = 0; i < MMC_WAIT_DATA; i++) {
+ for (i = 0U; i < MMC_WAIT_DATA; i++) {
spiReceive(mmcp->config->spip, 1, buf);
- if (buf[0] == 0xFE) {
+ if (buf[0] == 0xFEU) {
uint32_t *wp;
spiReceive(mmcp->config->spip, 16, buf);
bp = buf;
for (wp = &cxd[3]; wp >= cxd; wp--) {
- *wp = ((uint32_t)bp[0] << 24) | ((uint32_t)bp[1] << 16) |
- ((uint32_t)bp[2] << 8) | (uint32_t)bp[3];
+ *wp = ((uint32_t)bp[0] << 24U) | ((uint32_t)bp[1] << 16U) |
+ ((uint32_t)bp[2] << 8U) | (uint32_t)bp[3];
bp += 4;
}
@@ -343,11 +358,12 @@ static void sync(MMCDriver *mmcp) { uint8_t buf[1];
spiSelect(mmcp->config->spip);
- while (TRUE) {
+ while (true) {
spiReceive(mmcp->config->spip, 1, buf);
- if (buf[0] == 0xFF)
+ if (buf[0] == 0xFFU) {
break;
-#ifdef MMC_NICE_WAITING
+ }
+#if MMC_NICE_WAITING == TRUE
/* Trying to be nice with the other threads.*/
osalThreadSleep(1);
#endif
@@ -382,7 +398,7 @@ void mmcObjectInit(MMCDriver *mmcp) { mmcp->vmt = &mmc_vmt;
mmcp->state = BLK_STOP;
mmcp->config = NULL;
- mmcp->block_addresses = FALSE;
+ mmcp->block_addresses = false;
}
/**
@@ -448,7 +464,7 @@ bool mmcConnect(MMCDriver *mmcp) { /* Connection procedure in progress.*/
mmcp->state = BLK_CONNECTING;
- mmcp->block_addresses = FALSE;
+ mmcp->block_addresses = false;
/* Slow clock mode and 128 clock pulses.*/
spiStart(mmcp->config->spip, mmcp->config->lscfg);
@@ -456,11 +472,13 @@ bool mmcConnect(MMCDriver *mmcp) { /* SPI mode selection.*/
i = 0;
- while (TRUE) {
- if (send_command_R1(mmcp, MMCSD_CMD_GO_IDLE_STATE, 0) == 0x01)
+ while (true) {
+ if (send_command_R1(mmcp, MMCSD_CMD_GO_IDLE_STATE, 0) == 0x01U) {
break;
- if (++i >= MMC_CMD0_RETRY)
+ }
+ if (++i >= MMC_CMD0_RETRY) {
goto failed;
+ }
osalThreadSleepMilliseconds(10);
}
@@ -469,39 +487,46 @@ bool mmcConnect(MMCDriver *mmcp) { This method is based on "How to support SDC Ver2 and high capacity cards"
by ElmChan.*/
if (send_command_R3(mmcp, MMCSD_CMD_SEND_IF_COND,
- MMCSD_CMD8_PATTERN, r3) != 0x05) {
+ MMCSD_CMD8_PATTERN, r3) != 0x05U) {
/* Switch to SDHC mode.*/
i = 0;
- while (TRUE) {
- if ((send_command_R1(mmcp, MMCSD_CMD_APP_CMD, 0) == 0x01) &&
- (send_command_R3(mmcp, MMCSD_CMD_APP_OP_COND,
- 0x400001aa, r3) == 0x00))
+ while (true) {
+ /*lint -save -e9007 [13.5] Side effect unimportant.*/
+ if ((send_command_R1(mmcp, MMCSD_CMD_APP_CMD, 0) == 0x01U) &&
+ (send_command_R3(mmcp, MMCSD_CMD_APP_OP_COND, 0x400001AAU, r3) == 0x00U)) {
+ /*lint -restore*/
break;
+ }
- if (++i >= MMC_ACMD41_RETRY)
+ if (++i >= MMC_ACMD41_RETRY) {
goto failed;
+ }
osalThreadSleepMilliseconds(10);
}
/* Execute dedicated read on OCR register */
- send_command_R3(mmcp, MMCSD_CMD_READ_OCR, 0, r3);
+ (void) send_command_R3(mmcp, MMCSD_CMD_READ_OCR, 0, r3);
/* Check if CCS is set in response. Card operates in block mode if set.*/
- if (r3[0] & 0x40)
- mmcp->block_addresses = TRUE;
+ if ((r3[0] & 0x40U) != 0U) {
+ mmcp->block_addresses = true;
+ }
}
/* Initialization.*/
i = 0;
- while (TRUE) {
+ while (true) {
uint8_t b = send_command_R1(mmcp, MMCSD_CMD_INIT, 0);
- if (b == 0x00)
+ if (b == 0x00U) {
break;
- if (b != 0x01)
+ }
+ if (b != 0x01U) {
goto failed;
- if (++i >= MMC_CMD1_RETRY)
+ }
+ if (++i >= MMC_CMD1_RETRY) {
goto failed;
+ }
osalThreadSleepMilliseconds(10);
}
@@ -510,18 +535,23 @@ bool mmcConnect(MMCDriver *mmcp) { /* Setting block size.*/
if (send_command_R1(mmcp, MMCSD_CMD_SET_BLOCKLEN,
- MMCSD_BLOCK_SIZE) != 0x00)
+ MMCSD_BLOCK_SIZE) != 0x00U) {
goto failed;
+ }
/* Determine capacity.*/
- if (read_CxD(mmcp, MMCSD_CMD_SEND_CSD, mmcp->csd))
+ if (read_CxD(mmcp, MMCSD_CMD_SEND_CSD, mmcp->csd)) {
goto failed;
+ }
+
mmcp->capacity = _mmcsd_get_capacity(mmcp->csd);
- if (mmcp->capacity == 0)
+ if (mmcp->capacity == 0U) {
goto failed;
+ }
- if (read_CxD(mmcp, MMCSD_CMD_SEND_CID, mmcp->cid))
+ if (read_CxD(mmcp, MMCSD_CMD_SEND_CID, mmcp->cid)) {
goto failed;
+ }
mmcp->state = BLK_READY;
return HAL_SUCCESS;
@@ -593,12 +623,14 @@ bool mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) { spiStart(mmcp->config->spip, mmcp->config->hscfg);
spiSelect(mmcp->config->spip);
- if (mmcp->block_addresses)
+ if (mmcp->block_addresses) {
send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk);
- else
+ }
+ else {
send_hdr(mmcp, MMCSD_CMD_READ_MULTIPLE_BLOCK, startblk * MMCSD_BLOCK_SIZE);
+ }
- if (recvr1(mmcp) != 0x00) {
+ if (recvr1(mmcp) != 0x00U) {
spiStop(mmcp->config->spip);
mmcp->state = BLK_READY;
return HAL_FAILED;
@@ -619,16 +651,17 @@ bool mmcStartSequentialRead(MMCDriver *mmcp, uint32_t startblk) { * @api
*/
bool mmcSequentialRead(MMCDriver *mmcp, uint8_t *buffer) {
- int i;
+ unsigned i;
osalDbgCheck((mmcp != NULL) && (buffer != NULL));
- if (mmcp->state != BLK_READING)
+ if (mmcp->state != BLK_READING) {
return HAL_FAILED;
+ }
for (i = 0; i < MMC_WAIT_DATA; i++) {
spiReceive(mmcp->config->spip, 1, buffer);
- if (buffer[0] == 0xFE) {
+ if (buffer[0] == 0xFEU) {
spiReceive(mmcp->config->spip, MMCSD_BLOCK_SIZE, buffer);
/* CRC ignored. */
spiIgnore(mmcp->config->spip, 2);
@@ -654,16 +687,18 @@ bool mmcSequentialRead(MMCDriver *mmcp, uint8_t *buffer) { * @api
*/
bool mmcStopSequentialRead(MMCDriver *mmcp) {
- static const uint8_t stopcmd[] = {0x40 | MMCSD_CMD_STOP_TRANSMISSION,
- 0, 0, 0, 0, 1, 0xFF};
+ static const uint8_t stopcmd[] = {
+ (uint8_t)(0x40U | MMCSD_CMD_STOP_TRANSMISSION), 0, 0, 0, 0, 1, 0xFF
+ };
osalDbgCheck(mmcp != NULL);
- if (mmcp->state != BLK_READING)
+ if (mmcp->state != BLK_READING) {
return HAL_FAILED;
+ }
spiSend(mmcp->config->spip, sizeof(stopcmd), stopcmd);
-/* result = recvr1(mmcp) != 0x00;*/
+/* result = recvr1(mmcp) != 0x00U;*/
/* Note, ignored r1 response, it can be not zero, unknown issue.*/
(void) recvr1(mmcp);
@@ -695,13 +730,15 @@ bool mmcStartSequentialWrite(MMCDriver *mmcp, uint32_t startblk) { spiStart(mmcp->config->spip, mmcp->config->hscfg);
spiSelect(mmcp->config->spip);
- if (mmcp->block_addresses)
+ if (mmcp->block_addresses) {
send_hdr(mmcp, MMCSD_CMD_WRITE_MULTIPLE_BLOCK, startblk);
- else
+ }
+ else {
send_hdr(mmcp, MMCSD_CMD_WRITE_MULTIPLE_BLOCK,
startblk * MMCSD_BLOCK_SIZE);
+ }
- if (recvr1(mmcp) != 0x00) {
+ if (recvr1(mmcp) != 0x00U) {
spiStop(mmcp->config->spip);
mmcp->state = BLK_READY;
return HAL_FAILED;
@@ -727,14 +764,15 @@ bool mmcSequentialWrite(MMCDriver *mmcp, const uint8_t *buffer) { osalDbgCheck((mmcp != NULL) && (buffer != NULL));
- if (mmcp->state != BLK_WRITING)
+ if (mmcp->state != BLK_WRITING) {
return HAL_FAILED;
+ }
spiSend(mmcp->config->spip, sizeof(start), start); /* Data prologue. */
spiSend(mmcp->config->spip, MMCSD_BLOCK_SIZE, buffer);/* Data. */
spiIgnore(mmcp->config->spip, 2); /* CRC ignored. */
spiReceive(mmcp->config->spip, 1, b);
- if ((b[0] & 0x1F) == 0x05) {
+ if ((b[0] & 0x1FU) == 0x05U) {
wait(mmcp);
return HAL_SUCCESS;
}
@@ -762,8 +800,9 @@ bool mmcStopSequentialWrite(MMCDriver *mmcp) { osalDbgCheck(mmcp != NULL);
- if (mmcp->state != BLK_WRITING)
+ if (mmcp->state != BLK_WRITING) {
return HAL_FAILED;
+ }
spiSend(mmcp->config->spip, sizeof(stop), stop);
spiUnselect(mmcp->config->spip);
@@ -788,8 +827,9 @@ bool mmcSync(MMCDriver *mmcp) { osalDbgCheck(mmcp != NULL);
- if (mmcp->state != BLK_READY)
+ if (mmcp->state != BLK_READY) {
return HAL_FAILED;
+ }
/* Synchronization operation in progress.*/
mmcp->state = BLK_SYNCING;
@@ -818,8 +858,9 @@ bool mmcGetInfo(MMCDriver *mmcp, BlockDeviceInfo *bdip) { osalDbgCheck((mmcp != NULL) && (bdip != NULL));
- if (mmcp->state != BLK_READY)
+ if (mmcp->state != BLK_READY) {
return HAL_FAILED;
+ }
bdip->blk_num = mmcp->capacity;
bdip->blk_size = MMCSD_BLOCK_SIZE;
@@ -853,14 +894,17 @@ bool mmcErase(MMCDriver *mmcp, uint32_t startblk, uint32_t endblk) { endblk *= MMCSD_BLOCK_SIZE;
}
- if (send_command_R1(mmcp, MMCSD_CMD_ERASE_RW_BLK_START, startblk))
+ if (send_command_R1(mmcp, MMCSD_CMD_ERASE_RW_BLK_START, startblk) != 0x00U) {
goto failed;
+ }
- if (send_command_R1(mmcp, MMCSD_CMD_ERASE_RW_BLK_END, endblk))
+ if (send_command_R1(mmcp, MMCSD_CMD_ERASE_RW_BLK_END, endblk) != 0x00U) {
goto failed;
+ }
- if (send_command_R1(mmcp, MMCSD_CMD_ERASE, 0))
+ if (send_command_R1(mmcp, MMCSD_CMD_ERASE, 0) != 0x00U) {
goto failed;
+ }
mmcp->state = BLK_READY;
return HAL_SUCCESS;
@@ -872,6 +916,6 @@ failed: return HAL_FAILED;
}
-#endif /* HAL_USE_MMC_SPI */
+#endif /* HAL_USE_MMC_SPI == TRUE */
/** @} */
diff --git a/os/hal/src/pal.c b/os/hal/src/pal.c index b76093168..81b497fd6 100644 --- a/os/hal/src/pal.c +++ b/os/hal/src/pal.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_PAL || defined(__DOXYGEN__)
+#if (HAL_USE_PAL == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -120,6 +120,6 @@ void palSetBusMode(IOBus *bus, iomode_t mode) { palSetGroupMode(bus->portid, bus->mask, bus->offset, mode);
}
-#endif /* HAL_USE_PAL */
+#endif /* HAL_USE_PAL == TRUE */
/** @} */
diff --git a/os/hal/src/pwm.c b/os/hal/src/pwm.c index e569fa671..7d4beb3ff 100644 --- a/os/hal/src/pwm.c +++ b/os/hal/src/pwm.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_PWM || defined(__DOXYGEN__)
+#if (HAL_USE_PWM == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -269,7 +269,7 @@ void pwmEnableChannelNotification(PWMDriver *pwmp, pwmchannel_t channel) { osalSysLock();
osalDbgAssert(pwmp->state == PWM_READY, "not ready");
- osalDbgAssert((pwmp->enabled & (1 << channel)) != 0,
+ osalDbgAssert((pwmp->enabled & ((pwmchnmsk_t)1U << (pwmchnmsk_t)channel)) != 0U,
"channel not enabled");
osalDbgAssert(pwmp->config->channels[channel].callback != NULL,
"undefined channel callback");
@@ -297,7 +297,7 @@ void pwmDisableChannelNotification(PWMDriver *pwmp, pwmchannel_t channel) { osalSysLock();
osalDbgAssert(pwmp->state == PWM_READY, "not ready");
- osalDbgAssert((pwmp->enabled & (1 << channel)) != 0,
+ osalDbgAssert((pwmp->enabled & ((pwmchnmsk_t)1U << (pwmchnmsk_t)channel)) != 0U,
"channel not enabled");
osalDbgAssert(pwmp->config->channels[channel].callback != NULL,
"undefined channel callback");
@@ -307,6 +307,6 @@ void pwmDisableChannelNotification(PWMDriver *pwmp, pwmchannel_t channel) { osalSysUnlock();
}
-#endif /* HAL_USE_PWM */
+#endif /* HAL_USE_PWM == TRUE */
/** @} */
diff --git a/os/hal/src/rtc.c b/os/hal/src/rtc.c index d1d450505..653f6590b 100644 --- a/os/hal/src/rtc.c +++ b/os/hal/src/rtc.c @@ -31,7 +31,7 @@ #include "hal.h"
-#if HAL_USE_RTC || defined(__DOXYGEN__)
+#if (HAL_USE_RTC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -83,7 +83,7 @@ void rtcInit(void) { */
void rtcObjectInit(RTCDriver *rtcp) {
-#if RTC_HAS_STORAGE
+#if RTC_HAS_STORAGE == TRUE
rtcp->vmt = &_rtc_lld_vmt;
#else
(void)rtcp;
@@ -152,7 +152,7 @@ void rtcSetAlarm(RTCDriver *rtcp, rtcalarm_t alarm,
const RTCAlarm *alarmspec) {
- osalDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS));
+ osalDbgCheck((rtcp != NULL) && (alarm < (rtcalarm_t)RTC_ALARMS));
rtc_lld_set_alarm(rtcp, alarm, alarmspec);
}
@@ -178,13 +178,15 @@ void rtcGetAlarm(RTCDriver *rtcp, rtcalarm_t alarm,
RTCAlarm *alarmspec) {
- osalDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS) && (alarmspec != NULL));
+ osalDbgCheck((rtcp != NULL) &&
+ (alarm < (rtcalarm_t)RTC_ALARMS) &&
+ (alarmspec != NULL));
rtc_lld_get_alarm(rtcp, alarm, alarmspec);
}
#endif /* RTC_ALARMS > 0 */
-#if RTC_SUPPORTS_CALLBACKS || defined(__DOXYGEN__)
+#if (RTC_SUPPORTS_CALLBACKS == TRUE) || defined(__DOXYGEN__)
/**
* @brief Enables or disables RTC callbacks.
* @details This function enables or disables the callback, use a @p NULL
@@ -207,7 +209,7 @@ void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback) { rtc_lld_set_callback(rtcp, callback);
}
-#endif /* RTC_SUPPORTS_CALLBACKS */
+#endif /* RTC_SUPPORTS_CALLBACKS == TRUE */
/**
* @brief Convert @p RTCDateTime to broken-down time structure.
@@ -219,14 +221,14 @@ void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback) { */
void rtcConvertDateTimeToStructTm(const RTCDateTime *timespec,
struct tm *timp) {
- uint32_t tmp;
+ int tmp;
- timp->tm_year = timespec->year + (1980 - 1900);
- timp->tm_mon = timespec->month - 1;
- timp->tm_mday = timespec->day;
- timp->tm_isdst = timespec->dstflag;
+ timp->tm_year = (int)timespec->year + (1980 - 1900);
+ timp->tm_mon = (int)timespec->month - 1;
+ timp->tm_mday = (int)timespec->day;
+ timp->tm_isdst = (int)timespec->dstflag;
- tmp = timespec->millisecond / 1000;
+ tmp = (int)timespec->millisecond / 1000;
timp->tm_sec = tmp % 60;
tmp -= timp->tm_sec;
timp->tm_min = (tmp % 3600) / 60;
@@ -247,16 +249,23 @@ void rtcConvertStructTmToDateTime(const struct tm *timp, uint32_t tv_msec,
RTCDateTime *timespec) {
- timespec->year = timp->tm_year - (1980 - 1900);
- timespec->month = timp->tm_mon + 1;
- timespec->day = timp->tm_mday;
- timespec->dayofweek = timp->tm_wday + 1;
- if (-1 == timp->tm_isdst)
- timespec->dstflag = 0; /* set zero if dst is unknown */
- else
- timespec->dstflag = timp->tm_isdst;
- timespec->millisecond = tv_msec +
- (timp->tm_hour * 3600 + timp->tm_min * 60 + timp->tm_sec) * 1000;
+ /*lint -save -e9034 [10.4] Verified assignments to bit fields.*/
+ timespec->year = (uint32_t)timp->tm_year - (1980U - 1900U);
+ timespec->month = (uint32_t)timp->tm_mon + 1U;
+ timespec->day = (uint32_t)timp->tm_mday;
+ timespec->dayofweek = (uint32_t)timp->tm_wday + 1U;
+ if (-1 == timp->tm_isdst) {
+ timespec->dstflag = 0U; /* set zero if dst is unknown */
+ }
+ else {
+ timespec->dstflag = (uint32_t)timp->tm_isdst;
+ }
+ /*lint -restore*/
+ /*lint -save -e9033 [10.8] Verified assignments to bit fields.*/
+ timespec->millisecond = tv_msec + (uint32_t)((timp->tm_hour * 3600) +
+ (timp->tm_min * 60) +
+ (timp->tm_sec * 1000));
+ /*lint -restore*/
}
/**
@@ -273,36 +282,36 @@ uint32_t rtcConvertDateTimeToFAT(const RTCDateTime *timespec) { uint32_t fattime;
uint32_t sec, min, hour, day, month, tmp;
- tmp = timespec->millisecond / 1000;
- sec = tmp % 60;
- min = (tmp - sec) % 3600;
- hour = (tmp - sec - min * 60) / 3600;
+ tmp = timespec->millisecond / 1000U;
+ sec = tmp % 60U;
+ min = (tmp - sec) % 3600U;
+ hour = ((tmp - sec) - (min * 60U)) / 3600U;
day = timespec->day;
month = timespec->month;
/* handle DST flag */
- if (1 == timespec->dstflag) {
- hour += 1;
- if (hour == 24) {
- hour = 0;
- day += 1;
- if (day > month_len[month - 1]) {
- day = 1;
- month += 1;
+ if (1U == timespec->dstflag) {
+ hour += 1U;
+ if (hour == 24U) {
+ hour = 0U;
+ day += 1U;
+ if (day > month_len[month - 1U]) {
+ day = 1U;
+ month += 1U;
}
}
}
- fattime = sec >> 1;
- fattime |= min << 5;
- fattime |= hour << 11;
- fattime |= day << 16;
- fattime |= month << 21;
- fattime |= timespec->year << 25;
+ fattime = sec >> 1U;
+ fattime |= min << 5U;
+ fattime |= hour << 11U;
+ fattime |= day << 16U;
+ fattime |= month << 21U;
+ fattime |= (uint32_t)timespec->year << 25U;
return fattime;
}
-#endif /* HAL_USE_RTC */
+#endif /* HAL_USE_RTC == TRUE */
/** @} */
diff --git a/os/hal/src/sdc.c b/os/hal/src/sdc.c index 11fcfa51a..45c6604ac 100644 --- a/os/hal/src/sdc.c +++ b/os/hal/src/sdc.c @@ -25,15 +25,16 @@ * @{
*/
-#include "hal.h"
+#include <string.h>
-#include "string.h" /* for memset() */
+#include "hal.h"
-#if HAL_USE_SDC || defined(__DOXYGEN__)
+#if (HAL_USE_SDC == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
+
/**
* @brief MMC switch mode.
*/
@@ -41,7 +42,7 @@ typedef enum { MMC_SWITCH_COMMAND_SET = 0,
MMC_SWITCH_SET_BITS = 1,
MMC_SWITCH_CLEAR_BITS = 2,
- MMC_SWITCH_WRITE_BYTE = 3,
+ MMC_SWITCH_WRITE_BYTE = 3
} mmc_switch_t;
/**
@@ -49,7 +50,7 @@ typedef enum { */
typedef enum {
SD_SWITCH_CHECK = 0,
- SD_SWITCH_SET = 1,
+ SD_SWITCH_SET = 1
} sd_switch_t;
/**
@@ -59,7 +60,7 @@ typedef enum { SD_SWITCH_FUNCTION_SPEED = 0,
SD_SWITCH_FUNCTION_CMD_SYSTEM = 1,
SD_SWITCH_FUNCTION_DRIVER_STRENGTH = 2,
- SD_SWITCH_FUNCTION_CURRENT_LIMIT = 3,
+ SD_SWITCH_FUNCTION_CURRENT_LIMIT = 3
} sd_switch_function_t;
/*===========================================================================*/
@@ -106,17 +107,20 @@ static bool mode_detect(SDCDriver *sdcp) { MMCSD_CMD8_PATTERN, resp)) {
sdcp->cardmode = SDC_MODE_CARDTYPE_SDV20;
/* Voltage verification.*/
- if (((resp[0] >> 8) & 0xF) != 1)
+ if (((resp[0] >> 8U) & 0xFU) != 1U) {
return HAL_FAILED;
+ }
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_APP_CMD, 0, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
return HAL_FAILED;
+ }
}
else {
/* MMC or SD V1.1 detection.*/
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_APP_CMD, 0, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
sdcp->cardmode = SDC_MODE_CARDTYPE_MMC;
+ }
else {
sdcp->cardmode = SDC_MODE_CARDTYPE_SDV11;
@@ -144,19 +148,22 @@ static bool mmc_init(SDCDriver *sdcp) { unsigned i;
uint32_t resp[1];
- ocr = 0xC0FF8000;
+ ocr = 0xC0FF8000U;
i = 0;
while (true) {
- if (sdc_lld_send_cmd_short(sdcp, MMCSD_CMD_INIT, ocr, resp))
+ if (sdc_lld_send_cmd_short(sdcp, MMCSD_CMD_INIT, ocr, resp)) {
return HAL_FAILED;
- if ((resp[0] & 0x80000000) != 0) {
- if (resp[0] & 0x40000000)
+ }
+ if ((resp[0] & 0x80000000U) != 0U) {
+ if ((resp[0] & 0x40000000U) != 0U) {
sdcp->cardmode |= SDC_MODE_HIGH_CAPACITY;
+ }
break;
}
- if (++i >= SDC_INIT_RETRY)
+ if (++i >= (unsigned)SDC_INIT_RETRY) {
return HAL_FAILED;
- osalThreadSleep(OSAL_MS2ST(10));
+ }
+ osalThreadSleepMilliseconds(10);
}
return HAL_SUCCESS;
@@ -178,26 +185,32 @@ static bool sdc_init(SDCDriver *sdcp) { uint32_t ocr;
uint32_t resp[1];
- if ((sdcp->cardmode & SDC_MODE_CARDTYPE_MASK) == SDC_MODE_CARDTYPE_SDV20)
- ocr = 0xC0100000;
- else
- ocr = 0x80100000;
+ if ((sdcp->cardmode & SDC_MODE_CARDTYPE_MASK) == SDC_MODE_CARDTYPE_SDV20) {
+ ocr = 0xC0100000U;
+ }
+ else {
+ ocr = 0x80100000U;
+ }
i = 0;
while (true) {
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_APP_CMD, 0, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
return HAL_FAILED;
- if (sdc_lld_send_cmd_short(sdcp, MMCSD_CMD_APP_OP_COND, ocr, resp))
+ }
+ if (sdc_lld_send_cmd_short(sdcp, MMCSD_CMD_APP_OP_COND, ocr, resp)) {
return HAL_FAILED;
- if ((resp[0] & 0x80000000) != 0) {
- if (resp[0] & 0x40000000)
+ }
+ if ((resp[0] & 0x80000000U) != 0U) {
+ if ((resp[0] & 0x40000000U) != 0U) {
sdcp->cardmode |= SDC_MODE_HIGH_CAPACITY;
+ }
break;
}
- if (++i >= SDC_INIT_RETRY)
+ if (++i >= (unsigned)SDC_INIT_RETRY) {
return HAL_FAILED;
- osalThreadSleep(OSAL_MS2ST(10));
+ }
+ osalThreadSleepMilliseconds(10);
}
return HAL_SUCCESS;
@@ -207,7 +220,7 @@ static bool sdc_init(SDCDriver *sdcp) { * @brief Constructs CMD6 argument for MMC.
*
* @param[in] access EXT_CSD access mode
- * @param[in] index EXT_CSD byte number
+ * @param[in] idx EXT_CSD byte number
* @param[in] value value to be written in target field
* @param[in] cmd_set switch current command set
*
@@ -215,13 +228,13 @@ static bool sdc_init(SDCDriver *sdcp) { *
* @notapi
*/
-static uint32_t mmc_cmd6_construct(mmc_switch_t access, uint8_t index,
- uint8_t value, uint8_t cmd_set) {
+static uint32_t mmc_cmd6_construct(mmc_switch_t access, uint32_t idx,
+ uint32_t value, uint32_t cmd_set) {
- osalDbgAssert((index <= 191), "This field is not writable");
- osalDbgAssert((cmd_set < 8), "This field has only 3 bits");
+ osalDbgAssert(idx <= 191U, "This field is not writable");
+ osalDbgAssert(cmd_set < 8U, "This field has only 3 bits");
- return (access << 24) | (index << 16) | (value << 8) | cmd_set;
+ return ((uint32_t)access << 24U) | (idx << 16U) | (value << 8U) | cmd_set;
}
/**
@@ -235,15 +248,16 @@ static uint32_t mmc_cmd6_construct(mmc_switch_t access, uint8_t index, *
* @notapi
*/
-uint32_t sdc_cmd6_construct(sd_switch_t mode, sd_switch_function_t function,
- uint8_t value) {
+static uint32_t sdc_cmd6_construct(sd_switch_t mode,
+ sd_switch_function_t function,
+ uint32_t value) {
uint32_t ret = 0xFFFFFF;
- osalDbgAssert((value < 16), "This field has only 4 bits");
+ osalDbgAssert((value < 16U), "This field has only 4 bits");
- ret &= ~(0xF << (function * 4));
- ret |= value << (function * 4);
- return ret | (mode << 31);
+ ret &= ~((uint32_t)0xFU << ((uint32_t)function * 4U));
+ ret |= value << ((uint32_t)function * 4U);
+ return ret | ((uint32_t)mode << 31U);
}
/**
@@ -257,11 +271,11 @@ uint32_t sdc_cmd6_construct(sd_switch_t mode, sd_switch_function_t function, * @notapi
*/
static uint16_t sdc_cmd6_extract_info(sd_switch_function_t function,
- const uint8_t *buf) {
+ const uint8_t *buf) {
- size_t start = 12 - function * 2;
+ unsigned start = 12U - ((unsigned)function * 2U);
- return (buf[start] << 8) | buf[start+1];
+ return ((uint16_t)buf[start] << 8U) | (uint16_t)buf[start + 1U];
}
/**
@@ -280,14 +294,16 @@ static bool sdc_cmd6_check_status(sd_switch_function_t function, const uint8_t *buf) {
uint32_t tmp;
- uint8_t status;
+ uint32_t status;
- tmp = (buf[14] << 16) | (buf[15] << 8) | buf[16];
- status = (tmp >> (function * 4)) & 0xF;
- if (0xF != status)
+ tmp = ((uint32_t)buf[14] << 16U) |
+ ((uint32_t)buf[15] << 8U) |
+ (uint32_t)buf[16];
+ status = (tmp >> ((uint32_t)function * 4U)) & 0xFU;
+ if (0xFU != status) {
return HAL_SUCCESS;
- else
- return HAL_FAILED;
+ }
+ return HAL_FAILED;
}
/**
@@ -311,19 +327,24 @@ static bool sdc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) { *clk = SDC_CLK_25MHz;
/* Read switch functions' register.*/
- if (sdc_lld_read_special(sdcp, tmp, N, MMCSD_CMD_SWITCH, 0))
+ if (sdc_lld_read_special(sdcp, tmp, N, MMCSD_CMD_SWITCH, 0)) {
return HAL_FAILED;
+ }
/* Check card capabilities parsing acquired data.*/
- if ((sdc_cmd6_extract_info(SD_SWITCH_FUNCTION_SPEED, tmp) & 2) == 2) {
+ if ((sdc_cmd6_extract_info(SD_SWITCH_FUNCTION_SPEED, tmp) & 2U) == 2U) {
/* Construct command to set the bus speed.*/
cmdarg = sdc_cmd6_construct(SD_SWITCH_SET, SD_SWITCH_FUNCTION_SPEED, 1);
+
/* Write constructed command and read operation status in single call.*/
- if (sdc_lld_read_special(sdcp, tmp, N, MMCSD_CMD_SWITCH, cmdarg))
+ if (sdc_lld_read_special(sdcp, tmp, N, MMCSD_CMD_SWITCH, cmdarg)) {
return HAL_FAILED;
+ }
+
/* Check card answer for success status bits.*/
- if (HAL_SUCCESS == sdc_cmd6_check_status(SD_SWITCH_FUNCTION_SPEED, tmp))
+ if (HAL_SUCCESS == sdc_cmd6_check_status(SD_SWITCH_FUNCTION_SPEED, tmp)) {
*clk = SDC_CLK_50MHz;
+ }
}
return HAL_SUCCESS;
@@ -341,7 +362,7 @@ static bool sdc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) { *
* @notapi
*/
-static sdcbusclk_t mmc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) {
+static bool mmc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) {
uint32_t cmdarg;
uint32_t resp[1];
uint8_t *scratchpad = sdcp->config->scratchpad;
@@ -350,13 +371,15 @@ static sdcbusclk_t mmc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) { *clk = SDC_CLK_25MHz;
/* Use safe default when there is no space for data.*/
- if (NULL == scratchpad)
+ if (NULL == scratchpad) {
return HAL_SUCCESS;
+ }
cmdarg = mmc_cmd6_construct(MMC_SWITCH_WRITE_BYTE, 185, 1, 0);
if (!(sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SWITCH, cmdarg, resp) ||
- MMCSD_R1_ERROR(resp[0])))
+ MMCSD_R1_ERROR(resp[0]))) {
*clk = SDC_CLK_50MHz;
+ }
return HAL_SUCCESS;
}
@@ -375,10 +398,10 @@ static sdcbusclk_t mmc_detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) { */
static bool detect_bus_clk(SDCDriver *sdcp, sdcbusclk_t *clk) {
- if (SDC_MODE_CARDTYPE_MMC == (sdcp->cardmode & SDC_MODE_CARDTYPE_MASK))
+ if (SDC_MODE_CARDTYPE_MMC == (sdcp->cardmode & SDC_MODE_CARDTYPE_MASK)) {
return mmc_detect_bus_clk(sdcp, clk);
- else
- return sdc_detect_bus_clk(sdcp, clk);
+ }
+ return sdc_detect_bus_clk(sdcp, clk);
}
/**
@@ -402,11 +425,14 @@ static bool sdc_set_bus_width(SDCDriver *sdcp) { else if (SDC_MODE_4BIT == sdcp->config->bus_width) {
sdc_lld_set_bus_mode(sdcp, SDC_MODE_4BIT);
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_APP_CMD, sdcp->rca, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
return HAL_FAILED;
+ }
+
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SET_BUS_WIDTH, 2, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
return HAL_FAILED;
+ }
}
else {
/* SD card does not support 8bit bus.*/
@@ -435,13 +461,15 @@ static bool mmc_set_bus_width(SDCDriver *sdcp) { case SDC_MODE_1BIT:
/* Nothing to do. Bus is already in 1bit mode.*/
return HAL_SUCCESS;
- break;
case SDC_MODE_4BIT:
cmdarg = mmc_cmd6_construct(MMC_SWITCH_WRITE_BYTE, 183, 1, 0);
break;
case SDC_MODE_8BIT:
cmdarg = mmc_cmd6_construct(MMC_SWITCH_WRITE_BYTE, 183, 2, 0);
break;
+ default:
+ osalDbgAssert(false, "unexpected case");
+ break;
}
sdc_lld_set_bus_mode(sdcp, sdcp->config->bus_width);
@@ -467,19 +495,21 @@ static bool mmc_set_bus_width(SDCDriver *sdcp) { bool _sdc_wait_for_transfer_state(SDCDriver *sdcp) {
uint32_t resp[1];
- while (TRUE) {
+ while (true) {
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SEND_STATUS,
sdcp->rca, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
return HAL_FAILED;
+ }
+
switch (MMCSD_R1_STS(resp[0])) {
case MMCSD_STS_TRAN:
return HAL_SUCCESS;
case MMCSD_STS_DATA:
case MMCSD_STS_RCV:
case MMCSD_STS_PRG:
-#if SDC_NICE_WAITING
- osalThreadSleep(OSAL_MS2ST(1));
+#if SDC_NICE_WAITING == TRUE
+ osalThreadSleepMilliseconds(1);
#endif
continue;
default:
@@ -488,8 +518,6 @@ bool _sdc_wait_for_transfer_state(SDCDriver *sdcp) { return HAL_FAILED;
}
}
- /* If something going too wrong.*/
- return HAL_FAILED;
}
/*===========================================================================*/
@@ -598,56 +626,66 @@ bool sdcConnect(SDCDriver *sdcp) { sdc_lld_send_cmd_none(sdcp, MMCSD_CMD_GO_IDLE_STATE, 0);
/* Detect card type.*/
- if (HAL_FAILED == mode_detect(sdcp))
+ if (HAL_FAILED == mode_detect(sdcp)) {
goto failed;
+ }
/* Perform specific initialization procedure.*/
if ((sdcp->cardmode & SDC_MODE_CARDTYPE_MASK) == SDC_MODE_CARDTYPE_MMC) {
- if (HAL_FAILED == mmc_init(sdcp))
+ if (HAL_FAILED == mmc_init(sdcp)) {
goto failed;
+ }
}
else {
- if (HAL_FAILED == sdc_init(sdcp))
+ if (HAL_FAILED == sdc_init(sdcp)) {
goto failed;
+ }
}
/* Reads CID.*/
- if (sdc_lld_send_cmd_long_crc(sdcp, MMCSD_CMD_ALL_SEND_CID, 0, sdcp->cid))
+ if (sdc_lld_send_cmd_long_crc(sdcp, MMCSD_CMD_ALL_SEND_CID, 0, sdcp->cid)) {
goto failed;
+ }
/* Asks for the RCA.*/
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SEND_RELATIVE_ADDR,
- 0, &sdcp->rca))
+ 0, &sdcp->rca)) {
goto failed;
+ }
/* Reads CSD.*/
if (sdc_lld_send_cmd_long_crc(sdcp, MMCSD_CMD_SEND_CSD,
- sdcp->rca, sdcp->csd))
+ sdcp->rca, sdcp->csd)) {
goto failed;
+ }
/* Selects the card for operations.*/
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SEL_DESEL_CARD,
- sdcp->rca, resp))
+ sdcp->rca, resp)) {
goto failed;
+ }
/* Switches to high speed.*/
- if (HAL_SUCCESS != detect_bus_clk(sdcp, &clk))
+ if (HAL_SUCCESS != detect_bus_clk(sdcp, &clk)) {
goto failed;
+ }
sdc_lld_set_data_clk(sdcp, clk);
/* Reads extended CSD if needed and possible.*/
if (SDC_MODE_CARDTYPE_MMC == (sdcp->cardmode & SDC_MODE_CARDTYPE_MASK)) {
/* The card is a MMC, checking if it is a large device.*/
- if (_mmcsd_get_slice(sdcp->csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE) > 1) {
+ if (_mmcsd_get_slice(sdcp->csd, MMCSD_CSD_MMC_CSD_STRUCTURE_SLICE) > 1U) {
uint8_t *ext_csd = sdcp->config->scratchpad;
/* Size detection requires the buffer.*/
- if (NULL == ext_csd)
+ if (NULL == ext_csd) {
goto failed;
+ }
- if(sdc_lld_read_special(sdcp, ext_csd, 512, MMCSD_CMD_SEND_EXT_CSD, 0))
+ if(sdc_lld_read_special(sdcp, ext_csd, 512, MMCSD_CMD_SEND_EXT_CSD, 0)) {
goto failed;
+ }
/* Capacity from the EXT_CSD.*/
sdcp->capacity = _mmcsd_get_capacity_ext(ext_csd);
@@ -665,20 +703,26 @@ bool sdcConnect(SDCDriver *sdcp) { /* Block length fixed at 512 bytes.*/
if (sdc_lld_send_cmd_short_crc(sdcp, MMCSD_CMD_SET_BLOCKLEN,
MMCSD_BLOCK_SIZE, resp) ||
- MMCSD_R1_ERROR(resp[0]))
+ MMCSD_R1_ERROR(resp[0])) {
goto failed;
+ }
/* Switches to wide bus mode.*/
switch (sdcp->cardmode & SDC_MODE_CARDTYPE_MASK) {
case SDC_MODE_CARDTYPE_SDV11:
case SDC_MODE_CARDTYPE_SDV20:
- if (HAL_FAILED == sdc_set_bus_width(sdcp))
+ if (HAL_FAILED == sdc_set_bus_width(sdcp)) {
goto failed;
+ }
break;
case SDC_MODE_CARDTYPE_MMC:
- if (HAL_FAILED == mmc_set_bus_width(sdcp))
+ if (HAL_FAILED == mmc_set_bus_width(sdcp)) {
goto failed;
+ }
break;
+ default:
+ /* Unknown type.*/
+ goto failed;
}
/* Initialization complete.*/
@@ -749,10 +793,10 @@ bool sdcDisconnect(SDCDriver *sdcp) { bool sdcRead(SDCDriver *sdcp, uint32_t startblk, uint8_t *buf, uint32_t n) {
bool status;
- osalDbgCheck((sdcp != NULL) && (buf != NULL) && (n > 0));
+ osalDbgCheck((sdcp != NULL) && (buf != NULL) && (n > 0U));
osalDbgAssert(sdcp->state == BLK_READY, "invalid state");
- if ((startblk + n - 1) > sdcp->capacity){
+ if ((startblk + n - 1U) > sdcp->capacity){
sdcp->errors |= SDC_OVERFLOW_ERROR;
return HAL_FAILED;
}
@@ -787,10 +831,10 @@ bool sdcWrite(SDCDriver *sdcp, uint32_t startblk, const uint8_t *buf, uint32_t n) {
bool status;
- osalDbgCheck((sdcp != NULL) && (buf != NULL) && (n > 0));
+ osalDbgCheck((sdcp != NULL) && (buf != NULL) && (n > 0U));
osalDbgAssert(sdcp->state == BLK_READY, "invalid state");
- if ((startblk + n - 1) > sdcp->capacity){
+ if ((startblk + n - 1U) > sdcp->capacity){
sdcp->errors |= SDC_OVERFLOW_ERROR;
return HAL_FAILED;
}
@@ -842,8 +886,9 @@ bool sdcSync(SDCDriver *sdcp) { osalDbgCheck(sdcp != NULL);
- if (sdcp->state != BLK_READY)
+ if (sdcp->state != BLK_READY) {
return HAL_FAILED;
+ }
/* Synchronization operation in progress.*/
sdcp->state = BLK_SYNCING;
@@ -871,8 +916,9 @@ bool sdcGetInfo(SDCDriver *sdcp, BlockDeviceInfo *bdip) { osalDbgCheck((sdcp != NULL) && (bdip != NULL));
- if (sdcp->state != BLK_READY)
+ if (sdcp->state != BLK_READY) {
return HAL_FAILED;
+ }
bdip->blk_num = sdcp->capacity;
bdip->blk_size = MMCSD_BLOCK_SIZE;
@@ -880,7 +926,7 @@ bool sdcGetInfo(SDCDriver *sdcp, BlockDeviceInfo *bdip) { return HAL_SUCCESS;
}
-#endif /* HAL_USE_SDC */
+#endif /* HAL_USE_SDC == TRUE */
/** @} */
diff --git a/os/hal/src/serial.c b/os/hal/src/serial.c index 3b354f90f..9a4e80760 100644 --- a/os/hal/src/serial.c +++ b/os/hal/src/serial.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_SERIAL || defined(__DOXYGEN__)
+#if (HAL_USE_SERIAL == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -82,14 +82,14 @@ static msg_t gett(void *ip, systime_t timeout) { return iqGetTimeout(&((SerialDriver *)ip)->iqueue, timeout);
}
-static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t time) {
+static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t timeout) {
- return oqWriteTimeout(&((SerialDriver *)ip)->oqueue, bp, n, time);
+ return oqWriteTimeout(&((SerialDriver *)ip)->oqueue, bp, n, timeout);
}
-static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t time) {
+static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t timeout) {
- return iqReadTimeout(&((SerialDriver *)ip)->iqueue, bp, n, time);
+ return iqReadTimeout(&((SerialDriver *)ip)->iqueue, bp, n, timeout);
}
static const struct SerialDriverVMT vmt = {
@@ -237,6 +237,6 @@ msg_t sdRequestDataI(SerialDriver *sdp) { return b;
}
-#endif /* HAL_USE_SERIAL */
+#endif /* HAL_USE_SERIAL == TRUE */
/** @} */
diff --git a/os/hal/src/serial_usb.c b/os/hal/src/serial_usb.c index 7f837d37d..8fa6dc319 100644 --- a/os/hal/src/serial_usb.c +++ b/os/hal/src/serial_usb.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_SERIAL_USB || defined(__DOXYGEN__)
+#if (HAL_USE_SERIAL_USB == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -89,14 +89,14 @@ static msg_t gett(void *ip, systime_t timeout) { return iqGetTimeout(&((SerialUSBDriver *)ip)->iqueue, timeout);
}
-static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t time) {
+static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t timeout) {
- return oqWriteTimeout(&((SerialUSBDriver *)ip)->oqueue, bp, n, time);
+ return oqWriteTimeout(&((SerialUSBDriver *)ip)->oqueue, bp, n, timeout);
}
-static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t time) {
+static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t timeout) {
- return iqReadTimeout(&((SerialUSBDriver *)ip)->iqueue, bp, n, time);
+ return iqReadTimeout(&((SerialUSBDriver *)ip)->iqueue, bp, n, timeout);
}
static const struct SerialUSBDriverVMT vmt = {
@@ -116,24 +116,26 @@ static void inotify(io_queue_t *qp) { /* If the USB driver is not in the appropriate state then transactions
must not be started.*/
if ((usbGetDriverStateI(sdup->config->usbp) != USB_ACTIVE) ||
- (sdup->state != SDU_READY))
+ (sdup->state != SDU_READY)) {
return;
+ }
/* If there is in the queue enough space to hold at least one packet and
a transaction is not yet started then a new transaction is started for
the available space.*/
maxsize = sdup->config->usbp->epc[sdup->config->bulk_out]->out_maxsize;
- if (!usbGetReceiveStatusI(sdup->config->usbp, sdup->config->bulk_out) &&
- ((n = iqGetEmptyI(&sdup->iqueue)) >= maxsize)) {
- osalSysUnlock();
+ if (!usbGetReceiveStatusI(sdup->config->usbp, sdup->config->bulk_out)) {
+ if ((n = iqGetEmptyI(&sdup->iqueue)) >= maxsize) {
+ osalSysUnlock();
- n = (n / maxsize) * maxsize;
- usbPrepareQueuedReceive(sdup->config->usbp,
- sdup->config->bulk_out,
- &sdup->iqueue, n);
+ n = (n / maxsize) * maxsize;
+ usbPrepareQueuedReceive(sdup->config->usbp,
+ sdup->config->bulk_out,
+ &sdup->iqueue, n);
- osalSysLock();
- usbStartReceiveI(sdup->config->usbp, sdup->config->bulk_out);
+ osalSysLock();
+ (void) usbStartReceiveI(sdup->config->usbp, sdup->config->bulk_out);
+ }
}
}
@@ -149,21 +151,23 @@ static void onotify(io_queue_t *qp) { /* If the USB driver is not in the appropriate state then transactions
must not be started.*/
if ((usbGetDriverStateI(sdup->config->usbp) != USB_ACTIVE) ||
- (sdup->state != SDU_READY))
+ (sdup->state != SDU_READY)) {
return;
+ }
/* If there is not an ongoing transaction and the output queue contains
data then a new transaction is started.*/
- if (!usbGetTransmitStatusI(sdup->config->usbp, sdup->config->bulk_in) &&
- ((n = oqGetFullI(&sdup->oqueue)) > 0)) {
- osalSysUnlock();
+ if (!usbGetTransmitStatusI(sdup->config->usbp, sdup->config->bulk_in)) {
+ if ((n = oqGetFullI(&sdup->oqueue)) > 0U) {
+ osalSysUnlock();
- usbPrepareQueuedTransmit(sdup->config->usbp,
- sdup->config->bulk_in,
- &sdup->oqueue, n);
+ usbPrepareQueuedTransmit(sdup->config->usbp,
+ sdup->config->bulk_in,
+ &sdup->oqueue, n);
- osalSysLock();
- usbStartTransmitI(sdup->config->usbp, sdup->config->bulk_in);
+ osalSysLock();
+ (void) usbStartTransmitI(sdup->config->usbp, sdup->config->bulk_in);
+ }
}
}
@@ -215,9 +219,9 @@ void sduStart(SerialUSBDriver *sdup, const SerialUSBConfig *config) { osalSysLock();
osalDbgAssert((sdup->state == SDU_STOP) || (sdup->state == SDU_READY),
"invalid state");
- usbp->in_params[config->bulk_in - 1] = sdup;
- usbp->out_params[config->bulk_out - 1] = sdup;
- usbp->in_params[config->int_in - 1] = sdup;
+ usbp->in_params[config->bulk_in - 1U] = sdup;
+ usbp->out_params[config->bulk_out - 1U] = sdup;
+ usbp->in_params[config->int_in - 1U] = sdup;
sdup->config = config;
sdup->state = SDU_READY;
osalSysUnlock();
@@ -238,14 +242,13 @@ void sduStop(SerialUSBDriver *sdup) { osalDbgCheck(sdup != NULL);
osalSysLock();
-
osalDbgAssert((sdup->state == SDU_STOP) || (sdup->state == SDU_READY),
"invalid state");
/* Driver in stopped state.*/
- usbp->in_params[sdup->config->bulk_in - 1] = NULL;
- usbp->out_params[sdup->config->bulk_out - 1] = NULL;
- usbp->in_params[sdup->config->int_in - 1] = NULL;
+ usbp->in_params[sdup->config->bulk_in - 1U] = NULL;
+ usbp->out_params[sdup->config->bulk_out - 1U] = NULL;
+ usbp->in_params[sdup->config->int_in - 1U] = NULL;
sdup->state = SDU_STOP;
/* Queues reset in order to signal the driver stop to the application.*/
@@ -253,7 +256,6 @@ void sduStop(SerialUSBDriver *sdup) { iqResetI(&sdup->iqueue);
iqResetI(&sdup->oqueue);
osalOsRescheduleS();
-
osalSysUnlock();
}
@@ -274,7 +276,7 @@ void sduConfigureHookI(SerialUSBDriver *sdup) { /* Starts the first OUT transaction immediately.*/
usbPrepareQueuedReceive(usbp, sdup->config->bulk_out, &sdup->iqueue,
usbp->epc[sdup->config->bulk_out]->out_maxsize);
- usbStartReceiveI(usbp, sdup->config->bulk_out);
+ (void) usbStartReceiveI(usbp, sdup->config->bulk_out);
}
/**
@@ -323,15 +325,17 @@ bool sduRequestsHook(USBDriver *usbp) { */
void sduDataTransmitted(USBDriver *usbp, usbep_t ep) {
size_t n;
- SerialUSBDriver *sdup = usbp->in_params[ep - 1];
+ SerialUSBDriver *sdup = usbp->in_params[ep - 1U];
- if (sdup == NULL)
+ if (sdup == NULL) {
return;
+ }
osalSysLockFromISR();
chnAddFlagsI(sdup, CHN_OUTPUT_EMPTY);
- if ((n = oqGetFullI(&sdup->oqueue)) > 0) {
+ /*lint -save -e9013 [15.7] There is no else because it is not needed.*/
+ if ((n = oqGetFullI(&sdup->oqueue)) > 0U) {
/* The endpoint cannot be busy, we are in the context of the callback,
so it is safe to transmit without a check.*/
osalSysUnlockFromISR();
@@ -339,11 +343,11 @@ void sduDataTransmitted(USBDriver *usbp, usbep_t ep) { usbPrepareQueuedTransmit(usbp, ep, &sdup->oqueue, n);
osalSysLockFromISR();
- usbStartTransmitI(usbp, ep);
+ (void) usbStartTransmitI(usbp, ep);
}
- else if ((usbp->epc[ep]->in_state->txsize > 0) &&
- !(usbp->epc[ep]->in_state->txsize &
- (usbp->epc[ep]->in_maxsize - 1))) {
+ else if ((usbp->epc[ep]->in_state->txsize > 0U) &&
+ ((usbp->epc[ep]->in_state->txsize &
+ ((size_t)usbp->epc[ep]->in_maxsize - 1U)) == 0U)) {
/* Transmit zero sized packet in case the last one has maximum allowed
size. Otherwise the recipient may expect more data coming soon and
not return buffered data to app. See section 5.8.3 Bulk Transfer
@@ -353,8 +357,9 @@ void sduDataTransmitted(USBDriver *usbp, usbep_t ep) { usbPrepareQueuedTransmit(usbp, ep, &sdup->oqueue, 0);
osalSysLockFromISR();
- usbStartTransmitI(usbp, ep);
+ (void) usbStartTransmitI(usbp, ep);
}
+ /*lint -restore*/
osalSysUnlockFromISR();
}
@@ -369,10 +374,11 @@ void sduDataTransmitted(USBDriver *usbp, usbep_t ep) { */
void sduDataReceived(USBDriver *usbp, usbep_t ep) {
size_t n, maxsize;
- SerialUSBDriver *sdup = usbp->out_params[ep - 1];
+ SerialUSBDriver *sdup = usbp->out_params[ep - 1U];
- if (sdup == NULL)
+ if (sdup == NULL) {
return;
+ }
osalSysLockFromISR();
chnAddFlagsI(sdup, CHN_INPUT_AVAILABLE);
@@ -389,9 +395,8 @@ void sduDataReceived(USBDriver *usbp, usbep_t ep) { usbPrepareQueuedReceive(usbp, ep, &sdup->iqueue, n);
osalSysLockFromISR();
- usbStartReceiveI(usbp, ep);
+ (void) usbStartReceiveI(usbp, ep);
}
-
osalSysUnlockFromISR();
}
@@ -409,6 +414,6 @@ void sduInterruptTransmitted(USBDriver *usbp, usbep_t ep) { (void)ep;
}
-#endif /* HAL_USE_SERIAL */
+#endif /* HAL_USE_SERIAL_USB == TRUE */
/** @} */
diff --git a/os/hal/src/spi.c b/os/hal/src/spi.c index 7f7a9f021..2bbdc0ea7 100644 --- a/os/hal/src/spi.c +++ b/os/hal/src/spi.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_SPI || defined(__DOXYGEN__)
+#if (HAL_USE_SPI == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -72,12 +72,12 @@ void spiObjectInit(SPIDriver *spip) { spip->state = SPI_STOP;
spip->config = NULL;
-#if SPI_USE_WAIT
+#if SPI_USE_WAIT == TRUE
spip->thread = NULL;
-#endif /* SPI_USE_WAIT */
-#if SPI_USE_MUTUAL_EXCLUSION
+#endif
+#if SPI_USE_MUTUAL_EXCLUSION == TRUE
osalMutexObjectInit(&spip->mutex);
-#endif /* SPI_USE_MUTUAL_EXCLUSION */
+#endif
#if defined(SPI_DRIVER_EXT_INIT_HOOK)
SPI_DRIVER_EXT_INIT_HOOK(spip);
#endif
@@ -175,7 +175,7 @@ void spiUnselect(SPIDriver *spip) { */
void spiStartIgnore(SPIDriver *spip, size_t n) {
- osalDbgCheck((spip != NULL) && (n > 0));
+ osalDbgCheck((spip != NULL) && (n > 0U));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -203,7 +203,8 @@ void spiStartIgnore(SPIDriver *spip, size_t n) { void spiStartExchange(SPIDriver *spip, size_t n,
const void *txbuf, void *rxbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL) && (txbuf != NULL));
+ osalDbgCheck((spip != NULL) && (n > 0U) &&
+ (rxbuf != NULL) && (txbuf != NULL));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -228,7 +229,7 @@ void spiStartExchange(SPIDriver *spip, size_t n, */
void spiStartSend(SPIDriver *spip, size_t n, const void *txbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL));
+ osalDbgCheck((spip != NULL) && (n > 0U) && (txbuf != NULL));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -253,7 +254,7 @@ void spiStartSend(SPIDriver *spip, size_t n, const void *txbuf) { */
void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL));
+ osalDbgCheck((spip != NULL) && (n > 0U) && (rxbuf != NULL));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -261,7 +262,7 @@ void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) { osalSysUnlock();
}
-#if SPI_USE_WAIT || defined(__DOXYGEN__)
+#if (SPI_USE_WAIT == TRUE) || defined(__DOXYGEN__)
/**
* @brief Ignores data on the SPI bus.
* @details This synchronous function performs the transmission of a series of
@@ -278,7 +279,7 @@ void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) { */
void spiIgnore(SPIDriver *spip, size_t n) {
- osalDbgCheck((spip != NULL) && (n > 0));
+ osalDbgCheck((spip != NULL) && (n > 0U));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -309,7 +310,7 @@ void spiIgnore(SPIDriver *spip, size_t n) { void spiExchange(SPIDriver *spip, size_t n,
const void *txbuf, void *rxbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) &&
+ osalDbgCheck((spip != NULL) && (n > 0U) &&
(rxbuf != NULL) && (txbuf != NULL));
osalSysLock();
@@ -338,7 +339,7 @@ void spiExchange(SPIDriver *spip, size_t n, */
void spiSend(SPIDriver *spip, size_t n, const void *txbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL));
+ osalDbgCheck((spip != NULL) && (n > 0U) && (txbuf != NULL));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -366,7 +367,7 @@ void spiSend(SPIDriver *spip, size_t n, const void *txbuf) { */
void spiReceive(SPIDriver *spip, size_t n, void *rxbuf) {
- osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL));
+ osalDbgCheck((spip != NULL) && (n > 0U) && (rxbuf != NULL));
osalSysLock();
osalDbgAssert(spip->state == SPI_READY, "not ready");
@@ -375,9 +376,9 @@ void spiReceive(SPIDriver *spip, size_t n, void *rxbuf) { _spi_wait_s(spip);
osalSysUnlock();
}
-#endif /* SPI_USE_WAIT */
+#endif /* SPI_USE_WAIT == TRUE */
-#if SPI_USE_MUTUAL_EXCLUSION || defined(__DOXYGEN__)
+#if (SPI_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)
/**
* @brief Gains exclusive access to the SPI bus.
* @details This function tries to gain ownership to the SPI bus, if the bus
@@ -411,8 +412,8 @@ void spiReleaseBus(SPIDriver *spip) { osalMutexUnlock(&spip->mutex);
}
-#endif /* SPI_USE_MUTUAL_EXCLUSION */
+#endif /* SPI_USE_MUTUAL_EXCLUSION == TRUE */
-#endif /* HAL_USE_SPI */
+#endif /* HAL_USE_SPI == TRUE */
/** @} */
diff --git a/os/hal/src/st.c b/os/hal/src/st.c index 02bae928f..f44e8d093 100644 --- a/os/hal/src/st.c +++ b/os/hal/src/st.c @@ -73,15 +73,15 @@ void stInit(void) { * @note This functionality is only available in free running mode, the
* behavior in periodic mode is undefined.
*
- * @param[in] time the time to be set for the first alarm
+ * @param[in] abstime the time to be set for the first alarm
*
* @api
*/
-void stStartAlarm(systime_t time) {
+void stStartAlarm(systime_t abstime) {
osalDbgAssert(stIsAlarmActive() == false, "already active");
- st_lld_start_alarm(time);
+ st_lld_start_alarm(abstime);
}
/**
@@ -101,15 +101,15 @@ void stStopAlarm(void) { * @note This functionality is only available in free running mode, the
* behavior in periodic mode is undefined.
*
- * @param[in] time the time to be set for the next alarm
+ * @param[in] abstime the time to be set for the next alarm
*
* @api
*/
-void stSetAlarm(systime_t time) {
+void stSetAlarm(systime_t abstime) {
osalDbgAssert(stIsAlarmActive() != false, "not active");
- st_lld_set_alarm(time);
+ st_lld_set_alarm(abstime);
}
/**
diff --git a/os/hal/src/uart.c b/os/hal/src/uart.c index d8ef3511b..07d0b276d 100644 --- a/os/hal/src/uart.c +++ b/os/hal/src/uart.c @@ -27,7 +27,7 @@ #include "hal.h"
-#if HAL_USE_UART || defined(__DOXYGEN__)
+#if (HAL_USE_UART == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -137,7 +137,7 @@ void uartStop(UARTDriver *uartp) { */
void uartStartSend(UARTDriver *uartp, size_t n, const void *txbuf) {
- osalDbgCheck((uartp != NULL) && (n > 0) && (txbuf != NULL));
+ osalDbgCheck((uartp != NULL) && (n > 0U) && (txbuf != NULL));
osalSysLock();
osalDbgAssert(uartp->state == UART_READY, "is active");
@@ -163,7 +163,7 @@ void uartStartSend(UARTDriver *uartp, size_t n, const void *txbuf) { void uartStartSendI(UARTDriver *uartp, size_t n, const void *txbuf) {
osalDbgCheckClassI();
- osalDbgCheck((uartp != NULL) && (n > 0) && (txbuf != NULL));
+ osalDbgCheck((uartp != NULL) && (n > 0U) && (txbuf != NULL));
osalDbgAssert(uartp->state == UART_READY, "is active");
osalDbgAssert(uartp->txstate != UART_TX_ACTIVE, "tx active");
@@ -195,9 +195,11 @@ size_t uartStopSend(UARTDriver *uartp) { n = uart_lld_stop_send(uartp);
uartp->txstate = UART_TX_IDLE;
}
- else
+ else {
n = 0;
+ }
osalSysUnlock();
+
return n;
}
@@ -241,7 +243,7 @@ size_t uartStopSendI(UARTDriver *uartp) { */
void uartStartReceive(UARTDriver *uartp, size_t n, void *rxbuf) {
- osalDbgCheck((uartp != NULL) && (n > 0) && (rxbuf != NULL));
+ osalDbgCheck((uartp != NULL) && (n > 0U) && (rxbuf != NULL));
osalSysLock();
osalDbgAssert(uartp->state == UART_READY, "is active");
@@ -267,7 +269,7 @@ void uartStartReceive(UARTDriver *uartp, size_t n, void *rxbuf) { void uartStartReceiveI(UARTDriver *uartp, size_t n, void *rxbuf) {
osalDbgCheckClassI();
- osalDbgCheck((uartp != NULL) && (n > 0) && (rxbuf != NULL));
+ osalDbgCheck((uartp != NULL) && (n > 0U) && (rxbuf != NULL));
osalDbgAssert(uartp->state == UART_READY, "is active");
osalDbgAssert(uartp->rxstate != UART_RX_ACTIVE, "rx active");
@@ -299,9 +301,11 @@ size_t uartStopReceive(UARTDriver *uartp) { n = uart_lld_stop_receive(uartp);
uartp->rxstate = UART_RX_IDLE;
}
- else
+ else {
n = 0;
+ }
osalSysUnlock();
+
return n;
}
@@ -332,6 +336,6 @@ size_t uartStopReceiveI(UARTDriver *uartp) { return 0;
}
-#endif /* HAL_USE_UART */
+#endif /* HAL_USE_UART == TRUE */
/** @} */
diff --git a/os/hal/src/usb.c b/os/hal/src/usb.c index 602115fbd..ceb561957 100644 --- a/os/hal/src/usb.c +++ b/os/hal/src/usb.c @@ -29,7 +29,7 @@ #include "hal.h"
-#if HAL_USE_USB || defined(__DOXYGEN__)
+#if (HAL_USE_USB == TRUE) || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver local definitions. */
@@ -51,6 +51,14 @@ static const uint8_t halted_status[] = {0x01, 0x00}; /* Driver local functions. */
/*===========================================================================*/
+static uint16_t get_hword(uint8_t *p) {
+ uint16_t hw;
+
+ hw = (uint16_t)*p++;
+ hw |= (uint16_t)*p << 8U;
+ return hw;
+}
+
/**
* @brief SET ADDRESS transaction callback.
*
@@ -80,130 +88,154 @@ static bool default_handler(USBDriver *usbp) { const USBDescriptor *dp;
/* Decoding the request.*/
- switch (((usbp->setup[0] & (USB_RTYPE_RECIPIENT_MASK |
- USB_RTYPE_TYPE_MASK)) |
- (usbp->setup[1] << 8))) {
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_STATUS << 8):
+ switch ((((uint32_t)usbp->setup[0] & (USB_RTYPE_RECIPIENT_MASK |
+ USB_RTYPE_TYPE_MASK)) |
+ ((uint32_t)usbp->setup[1] << 8U))) {
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_GET_STATUS << 8):
/* Just returns the current status word.*/
usbSetupTransfer(usbp, (uint8_t *)&usbp->status, 2, NULL);
return true;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_CLEAR_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_CLEAR_FEATURE << 8):
/* Only the DEVICE_REMOTE_WAKEUP is handled here, any other feature
number is handled as an error.*/
if (usbp->setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) {
- usbp->status &= ~2;
+ usbp->status &= ~2U;
usbSetupTransfer(usbp, NULL, 0, NULL);
return true;
}
return false;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_SET_FEATURE << 8):
/* Only the DEVICE_REMOTE_WAKEUP is handled here, any other feature
number is handled as an error.*/
if (usbp->setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) {
- usbp->status |= 2;
+ usbp->status |= 2U;
usbSetupTransfer(usbp, NULL, 0, NULL);
return true;
}
return false;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_ADDRESS << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_SET_ADDRESS << 8):
/* The SET_ADDRESS handling can be performed here or postponed after
the status packed depending on the USB_SET_ADDRESS_MODE low
driver setting.*/
#if USB_SET_ADDRESS_MODE == USB_EARLY_SET_ADDRESS
if ((usbp->setup[0] == USB_RTYPE_RECIPIENT_DEVICE) &&
- (usbp->setup[1] == USB_REQ_SET_ADDRESS))
+ (usbp->setup[1] == USB_REQ_SET_ADDRESS)) {
set_address(usbp);
+ }
usbSetupTransfer(usbp, NULL, 0, NULL);
#else
usbSetupTransfer(usbp, NULL, 0, set_address);
#endif
return true;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_DESCRIPTOR << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_GET_DESCRIPTOR << 8):
/* Handling descriptor requests from the host.*/
- dp = usbp->config->get_descriptor_cb(
- usbp, usbp->setup[3], usbp->setup[2],
- usbFetchWord(&usbp->setup[4]));
- if (dp == NULL)
+ dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3],
+ usbp->setup[2],
+ get_hword(&usbp->setup[4]));
+ if (dp == NULL) {
return false;
+ }
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL);
+ /*lint -restore*/
return true;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_CONFIGURATION << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_GET_CONFIGURATION << 8):
/* Returning the last selected configuration.*/
usbSetupTransfer(usbp, &usbp->configuration, 1, NULL);
return true;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_CONFIGURATION << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_SET_CONFIGURATION << 8):
/* Handling configuration selection from the host.*/
usbp->configuration = usbp->setup[2];
- if (usbp->configuration == 0)
+ if (usbp->configuration == 0U) {
usbp->state = USB_SELECTED;
- else
+ }
+ else {
usbp->state = USB_ACTIVE;
+ }
_usb_isr_invoke_event_cb(usbp, USB_EVENT_CONFIGURED);
usbSetupTransfer(usbp, NULL, 0, NULL);
return true;
- case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_GET_STATUS << 8):
- case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_SYNCH_FRAME << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_INTERFACE | ((uint32_t)USB_REQ_GET_STATUS << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_ENDPOINT | ((uint32_t)USB_REQ_SYNCH_FRAME << 8):
/* Just sending two zero bytes, the application can change the behavior
using a hook..*/
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)zero_status, 2, NULL);
+ /*lint -restore*/
return true;
- case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_GET_STATUS << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_ENDPOINT | ((uint32_t)USB_REQ_GET_STATUS << 8):
/* Sending the EP status.*/
- if (usbp->setup[4] & 0x80) {
- switch (usb_lld_get_status_in(usbp, usbp->setup[4] & 0x0F)) {
+ if ((usbp->setup[4] & 0x80U) != 0U) {
+ switch (usb_lld_get_status_in(usbp, usbp->setup[4] & 0x0FU)) {
case EP_STATUS_STALLED:
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)halted_status, 2, NULL);
+ /*lint -restore*/
return true;
case EP_STATUS_ACTIVE:
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)active_status, 2, NULL);
+ /*lint -restore*/
return true;
+ case EP_STATUS_DISABLED:
default:
return false;
}
}
else {
- switch (usb_lld_get_status_out(usbp, usbp->setup[4] & 0x0F)) {
+ switch (usb_lld_get_status_out(usbp, usbp->setup[4] & 0x0FU)) {
case EP_STATUS_STALLED:
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)halted_status, 2, NULL);
+ /*lint -restore*/
return true;
case EP_STATUS_ACTIVE:
+ /*lint -save -e9005 [11.8] Removing const is fine.*/
usbSetupTransfer(usbp, (uint8_t *)active_status, 2, NULL);
+ /*lint -restore*/
return true;
+ case EP_STATUS_DISABLED:
default:
return false;
}
}
- case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_CLEAR_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_ENDPOINT | ((uint32_t)USB_REQ_CLEAR_FEATURE << 8):
/* Only ENDPOINT_HALT is handled as feature.*/
- if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT)
+ if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT) {
return false;
+ }
/* Clearing the EP status, not valid for EP0, it is ignored in that case.*/
- if ((usbp->setup[4] & 0x0F) > 0) {
- if (usbp->setup[4] & 0x80)
- usb_lld_clear_in(usbp, usbp->setup[4] & 0x0F);
- else
- usb_lld_clear_out(usbp, usbp->setup[4] & 0x0F);
+ if ((usbp->setup[4] & 0x0FU) != 0U) {
+ if ((usbp->setup[4] & 0x80U) != 0U) {
+ usb_lld_clear_in(usbp, usbp->setup[4] & 0x0FU);
+ }
+ else {
+ usb_lld_clear_out(usbp, usbp->setup[4] & 0x0FU);
+ }
}
usbSetupTransfer(usbp, NULL, 0, NULL);
return true;
- case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_SET_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_ENDPOINT | ((uint32_t)USB_REQ_SET_FEATURE << 8):
/* Only ENDPOINT_HALT is handled as feature.*/
- if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT)
+ if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT) {
return false;
+ }
/* Stalling the EP, not valid for EP0, it is ignored in that case.*/
- if ((usbp->setup[4] & 0x0F) > 0) {
- if (usbp->setup[4] & 0x80)
- usb_lld_stall_in(usbp, usbp->setup[4] & 0x0F);
- else
- usb_lld_stall_out(usbp, usbp->setup[4] & 0x0F);
+ if ((usbp->setup[4] & 0x0FU) != 0U) {
+ if ((usbp->setup[4] & 0x80U) != 0U) {
+ usb_lld_stall_in(usbp, usbp->setup[4] & 0x0FU);
+ }
+ else {
+ usb_lld_stall_out(usbp, usbp->setup[4] & 0x0FU);
+ }
}
usbSetupTransfer(usbp, NULL, 0, NULL);
return true;
- case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_DESCRIPTOR << 8):
- case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_CLEAR_FEATURE << 8):
- case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_SET_FEATURE << 8):
- case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_GET_INTERFACE << 8):
- case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_SET_INTERFACE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_DEVICE | ((uint32_t)USB_REQ_SET_DESCRIPTOR << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_INTERFACE | ((uint32_t)USB_REQ_CLEAR_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_INTERFACE | ((uint32_t)USB_REQ_SET_FEATURE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_INTERFACE | ((uint32_t)USB_REQ_GET_INTERFACE << 8):
+ case (uint32_t)USB_RTYPE_RECIPIENT_INTERFACE | ((uint32_t)USB_REQ_SET_INTERFACE << 8):
/* All the above requests are not handled here, if you need them then
use the hook mechanism and provide handling.*/
default:
@@ -239,7 +271,7 @@ void usbObjectInit(USBDriver *usbp) { usbp->state = USB_STOP;
usbp->config = NULL;
- for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
+ for (i = 0; i < (unsigned)USB_MAX_ENDPOINTS; i++) {
usbp->in_params[i] = NULL;
usbp->out_params[i] = NULL;
}
@@ -264,8 +296,9 @@ void usbStart(USBDriver *usbp, const USBConfig *config) { osalDbgAssert((usbp->state == USB_STOP) || (usbp->state == USB_READY),
"invalid state");
usbp->config = config;
- for (i = 0; i <= USB_MAX_ENDPOINTS; i++)
+ for (i = 0; i <= (unsigned)USB_MAX_ENDPOINTS; i++) {
usbp->epc[i] = NULL;
+ }
usb_lld_start(usbp);
usbp->state = USB_READY;
osalSysUnlock();
@@ -314,10 +347,12 @@ void usbInitEndpointI(USBDriver *usbp, usbep_t ep, osalDbgAssert(usbp->epc[ep] == NULL, "already initialized");
/* Logically enabling the endpoint in the USBDriver structure.*/
- if (epcp->in_state != NULL)
+ if (epcp->in_state != NULL) {
memset(epcp->in_state, 0, sizeof(USBInEndpointState));
- if (epcp->out_state != NULL)
+ }
+ if (epcp->out_state != NULL) {
memset(epcp->out_state, 0, sizeof(USBOutEndpointState));
+ }
usbp->epc[ep] = epcp;
@@ -343,10 +378,11 @@ void usbDisableEndpointsI(USBDriver *usbp) { osalDbgCheck(usbp != NULL);
osalDbgAssert(usbp->state == USB_SELECTED, "invalid state");
- usbp->transmitting &= ~1;
- usbp->receiving &= ~1;
- for (i = 1; i <= USB_MAX_ENDPOINTS; i++)
+ usbp->transmitting &= ~1U;
+ usbp->receiving &= ~1U;
+ for (i = 1; i <= (unsigned)USB_MAX_ENDPOINTS; i++) {
usbp->epc[i] = NULL;
+ }
/* Low level endpoints deactivation.*/
usb_lld_disable_endpoints(usbp);
@@ -475,10 +511,11 @@ bool usbStartReceiveI(USBDriver *usbp, usbep_t ep) { osalDbgCheckClassI();
osalDbgCheck(usbp != NULL);
- if (usbGetReceiveStatusI(usbp, ep))
+ if (usbGetReceiveStatusI(usbp, ep)) {
return true;
+ }
- usbp->receiving |= (1 << ep);
+ usbp->receiving |= (uint16_t)((unsigned)1U << (unsigned)ep);
usb_lld_start_out(usbp, ep);
return false;
}
@@ -502,10 +539,11 @@ bool usbStartTransmitI(USBDriver *usbp, usbep_t ep) { osalDbgCheckClassI();
osalDbgCheck(usbp != NULL);
- if (usbGetTransmitStatusI(usbp, ep))
+ if (usbGetTransmitStatusI(usbp, ep)) {
return true;
+ }
- usbp->transmitting |= (1 << ep);
+ usbp->transmitting |= (uint16_t)((unsigned)1U << (unsigned)ep);
usb_lld_start_in(usbp, ep);
return false;
}
@@ -527,8 +565,9 @@ bool usbStallReceiveI(USBDriver *usbp, usbep_t ep) { osalDbgCheckClassI();
osalDbgCheck(usbp != NULL);
- if (usbGetReceiveStatusI(usbp, ep))
+ if (usbGetReceiveStatusI(usbp, ep)) {
return true;
+ }
usb_lld_stall_out(usbp, ep);
return false;
@@ -551,8 +590,9 @@ bool usbStallTransmitI(USBDriver *usbp, usbep_t ep) { osalDbgCheckClassI();
osalDbgCheck(usbp != NULL);
- if (usbGetTransmitStatusI(usbp, ep))
+ if (usbGetTransmitStatusI(usbp, ep)) {
return true;
+ }
usb_lld_stall_in(usbp, ep);
return false;
@@ -578,8 +618,9 @@ void _usb_reset(USBDriver *usbp) { usbp->receiving = 0;
/* Invalidates all endpoints into the USBDriver structure.*/
- for (i = 0; i <= USB_MAX_ENDPOINTS; i++)
+ for (i = 0; i <= (unsigned)USB_MAX_ENDPOINTS; i++) {
usbp->epc[i] = NULL;
+ }
/* EP0 state machine initialization.*/
usbp->ep0state = USB_EP0_WAITING_SETUP;
@@ -606,12 +647,16 @@ void _usb_ep0setup(USBDriver *usbp, usbep_t ep) { /* First verify if the application has an handler installed for this
request.*/
- if (!(usbp->config->requests_hook_cb) ||
+ /*lint -save -e9007 [13.5] No side effects, it is intentional.*/
+ if ((usbp->config->requests_hook_cb == NULL) ||
!(usbp->config->requests_hook_cb(usbp))) {
+ /*lint -restore*/
/* Invoking the default handler, if this fails then stalls the
endpoint zero as error.*/
+ /*lint -save -e9007 [13.5] No side effects, it is intentional.*/
if (((usbp->setup[0] & USB_RTYPE_TYPE_MASK) != USB_RTYPE_TYPE_STD) ||
!default_handler(usbp)) {
+ /*lint -restore*/
/* Error response, the state machine goes into an error state, the low
level layer will have to reset it to USB_EP0_WAITING_SETUP after
receiving a SETUP packet.*/
@@ -631,18 +676,19 @@ void _usb_ep0setup(USBDriver *usbp, usbep_t ep) { /* Transfer preparation. The request handler must have populated
correctly the fields ep0next, ep0n and ep0endcb using the macro
usbSetupTransfer().*/
- max = usbFetchWord(&usbp->setup[6]);
+ max = (size_t)get_hword(&usbp->setup[6]);
/* The transfer size cannot exceed the specified amount.*/
- if (usbp->ep0n > max)
+ if (usbp->ep0n > max) {
usbp->ep0n = max;
+ }
if ((usbp->setup[0] & USB_RTYPE_DIR_MASK) == USB_RTYPE_DIR_DEV2HOST) {
/* IN phase.*/
- if (usbp->ep0n > 0) {
+ if (usbp->ep0n != 0U) {
/* Starts the transmit phase.*/
usbp->ep0state = USB_EP0_TX;
usbPrepareTransmit(usbp, 0, usbp->ep0next, usbp->ep0n);
osalSysLockFromISR();
- usbStartTransmitI(usbp, 0);
+ (void) usbStartTransmitI(usbp, 0);
osalSysUnlockFromISR();
}
else {
@@ -652,7 +698,7 @@ void _usb_ep0setup(USBDriver *usbp, usbep_t ep) { #if (USB_EP0_STATUS_STAGE == USB_EP0_STATUS_STAGE_SW)
usbPrepareReceive(usbp, 0, NULL, 0);
osalSysLockFromISR();
- usbStartReceiveI(usbp, 0);
+ (void) usbStartReceiveI(usbp, 0);
osalSysUnlockFromISR();
#else
usb_lld_end_setup(usbp, ep);
@@ -661,12 +707,12 @@ void _usb_ep0setup(USBDriver *usbp, usbep_t ep) { }
else {
/* OUT phase.*/
- if (usbp->ep0n > 0) {
+ if (usbp->ep0n != 0U) {
/* Starts the receive phase.*/
usbp->ep0state = USB_EP0_RX;
usbPrepareReceive(usbp, 0, usbp->ep0next, usbp->ep0n);
osalSysLockFromISR();
- usbStartReceiveI(usbp, 0);
+ (void) usbStartReceiveI(usbp, 0);
osalSysUnlockFromISR();
}
else {
@@ -676,7 +722,7 @@ void _usb_ep0setup(USBDriver *usbp, usbep_t ep) { #if (USB_EP0_STATUS_STAGE == USB_EP0_STATUS_STAGE_SW)
usbPrepareTransmit(usbp, 0, NULL, 0);
osalSysLockFromISR();
- usbStartTransmitI(usbp, 0);
+ (void) usbStartTransmitI(usbp, 0);
osalSysUnlockFromISR();
#else
usb_lld_end_setup(usbp, ep);
@@ -701,14 +747,15 @@ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { (void)ep;
switch (usbp->ep0state) {
case USB_EP0_TX:
- max = usbFetchWord(&usbp->setup[6]);
+ max = (size_t)get_hword(&usbp->setup[6]);
/* If the transmitted size is less than the requested size and it is a
multiple of the maximum packet size then a zero size packet must be
transmitted.*/
- if ((usbp->ep0n < max) && ((usbp->ep0n % usbp->epc[0]->in_maxsize) == 0)) {
+ if ((usbp->ep0n < max) &&
+ ((usbp->ep0n % usbp->epc[0]->in_maxsize) == 0U)) {
usbPrepareTransmit(usbp, 0, NULL, 0);
osalSysLockFromISR();
- usbStartTransmitI(usbp, 0);
+ (void) usbStartTransmitI(usbp, 0);
osalSysUnlockFromISR();
usbp->ep0state = USB_EP0_WAITING_TX0;
return;
@@ -720,7 +767,7 @@ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { #if (USB_EP0_STATUS_STAGE == USB_EP0_STATUS_STAGE_SW)
usbPrepareReceive(usbp, 0, NULL, 0);
osalSysLockFromISR();
- usbStartReceiveI(usbp, 0);
+ (void) usbStartReceiveI(usbp, 0);
osalSysUnlockFromISR();
#else
usb_lld_end_setup(usbp, ep);
@@ -728,20 +775,29 @@ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { return;
case USB_EP0_SENDING_STS:
/* Status packet sent, invoking the callback if defined.*/
- if (usbp->ep0endcb != NULL)
+ if (usbp->ep0endcb != NULL) {
usbp->ep0endcb(usbp);
+ }
usbp->ep0state = USB_EP0_WAITING_SETUP;
return;
+ case USB_EP0_WAITING_SETUP:
+ case USB_EP0_WAITING_STS:
+ case USB_EP0_RX:
+ /* All the above are invalid states in the IN phase.*/
+ osalDbgAssert(false, "EP0 state machine error");
+ /* Falling through is intentional.*/
+ case USB_EP0_ERROR:
+ /* Error response, the state machine goes into an error state, the low
+ level layer will have to reset it to USB_EP0_WAITING_SETUP after
+ receiving a SETUP packet.*/
+ usb_lld_stall_in(usbp, 0);
+ usb_lld_stall_out(usbp, 0);
+ _usb_isr_invoke_event_cb(usbp, USB_EVENT_STALLED);
+ usbp->ep0state = USB_EP0_ERROR;
+ return;
default:
- ;
+ osalDbgAssert(false, "EP0 state machine invalid state");
}
- /* Error response, the state machine goes into an error state, the low
- level layer will have to reset it to USB_EP0_WAITING_SETUP after
- receiving a SETUP packet.*/
- usb_lld_stall_in(usbp, 0);
- usb_lld_stall_out(usbp, 0);
- _usb_isr_invoke_event_cb(usbp, USB_EVENT_STALLED);
- usbp->ep0state = USB_EP0_ERROR;
}
/**
@@ -764,7 +820,7 @@ void _usb_ep0out(USBDriver *usbp, usbep_t ep) { #if (USB_EP0_STATUS_STAGE == USB_EP0_STATUS_STAGE_SW)
usbPrepareTransmit(usbp, 0, NULL, 0);
osalSysLockFromISR();
- usbStartTransmitI(usbp, 0);
+ (void) usbStartTransmitI(usbp, 0);
osalSysUnlockFromISR();
#else
usb_lld_end_setup(usbp, ep);
@@ -774,25 +830,36 @@ void _usb_ep0out(USBDriver *usbp, usbep_t ep) { /* Status packet received, it must be zero sized, invoking the callback
if defined.*/
#if (USB_EP0_STATUS_STAGE == USB_EP0_STATUS_STAGE_SW)
- if (usbGetReceiveTransactionSizeI(usbp, 0) != 0)
+ if (usbGetReceiveTransactionSizeI(usbp, 0) != 0U) {
break;
+ }
#endif
- if (usbp->ep0endcb != NULL)
+ if (usbp->ep0endcb != NULL) {
usbp->ep0endcb(usbp);
+ }
usbp->ep0state = USB_EP0_WAITING_SETUP;
return;
+ case USB_EP0_WAITING_SETUP:
+ case USB_EP0_TX:
+ case USB_EP0_WAITING_TX0:
+ case USB_EP0_SENDING_STS:
+ /* All the above are invalid states in the IN phase.*/
+ osalDbgAssert(false, "EP0 state machine error");
+ /* Falling through is intentional.*/
+ case USB_EP0_ERROR:
+ /* Error response, the state machine goes into an error state, the low
+ level layer will have to reset it to USB_EP0_WAITING_SETUP after
+ receiving a SETUP packet.*/
+ usb_lld_stall_in(usbp, 0);
+ usb_lld_stall_out(usbp, 0);
+ _usb_isr_invoke_event_cb(usbp, USB_EVENT_STALLED);
+ usbp->ep0state = USB_EP0_ERROR;
+ return;
default:
- ;
+ osalDbgAssert(false, "EP0 state machine invalid state");
}
- /* Error response, the state machine goes into an error state, the low
- level layer will have to reset it to USB_EP0_WAITING_SETUP after
- receiving a SETUP packet.*/
- usb_lld_stall_in(usbp, 0);
- usb_lld_stall_out(usbp, 0);
- _usb_isr_invoke_event_cb(usbp, USB_EVENT_STALLED);
- usbp->ep0state = USB_EP0_ERROR;
}
-#endif /* HAL_USE_USB */
+#endif /* HAL_USE_USB == TRUE */
/** @} */
|