From eb7a1a15b23341693864c6fc13ac5eab5c1d6122 Mon Sep 17 00:00:00 2001
From: gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4>
Date: Sat, 10 Aug 2013 14:50:32 +0000
Subject: Removed 2nd parameter to assertion and check macros.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/branches/kernel_3_dev@6122 35acf78f-673a-0410-8e92-d51de3d6d3f4
---
 os/hal/osal/chibios/osal.c                         |  7 ++--
 os/hal/osal/chibios/osal.h                         |  9 +++--
 os/hal/platforms/STM32/SPIv2/spi_lld.c             | 12 +++----
 os/hal/platforms/STM32/can_lld.c                   | 12 +++----
 os/hal/platforms/STM32/icu_lld.c                   |  4 +--
 os/hal/platforms/STM32/pwm_lld.c                   |  6 ++--
 os/hal/platforms/STM32F30x/adc_lld.c               | 11 +++---
 os/hal/platforms/STM32F30x/stm32_dma.c             |  2 +-
 os/hal/src/adc.c                                   | 15 ++++----
 os/hal/src/can.c                                   | 12 +++----
 os/hal/src/icu.c                                   |  8 ++---
 os/hal/src/pwm.c                                   | 13 +++----
 os/hal/src/serial.c                                |  4 +--
 os/hal/src/spi.c                                   | 41 +++++++++-------------
 os/kernel/include/chdebug.h                        | 22 +++++-------
 os/kernel/ports/ARMCMx/devices/STM32F30x/systick.h | 16 +++------
 os/kernel/src/chcond.c                             | 20 +++++------
 os/kernel/src/chdynamic.c                          |  6 ++--
 os/kernel/src/chevents.c                           | 16 ++++-----
 os/kernel/src/chheap.c                             |  8 ++---
 os/kernel/src/chmboxes.c                           | 16 ++++-----
 os/kernel/src/chmempools.c                         |  8 ++---
 os/kernel/src/chmsg.c                              |  5 ++-
 os/kernel/src/chmtx.c                              | 26 +++++---------
 os/kernel/src/chqueues.c                           |  4 +--
 os/kernel/src/chregistry.c                         |  3 +-
 os/kernel/src/chschd.c                             |  1 -
 os/kernel/src/chsem.c                              | 24 +++++--------
 os/kernel/src/chthreads.c                          | 16 ++++-----
 os/kernel/src/chvt.c                               |  9 ++---
 30 files changed, 144 insertions(+), 212 deletions(-)

diff --git a/os/hal/osal/chibios/osal.c b/os/hal/osal/chibios/osal.c
index 8b0398538..65912ce7e 100644
--- a/os/hal/osal/chibios/osal.c
+++ b/os/hal/osal/chibios/osal.c
@@ -96,7 +96,7 @@ void osalSysHalt(const char *reason) {
  */
 msg_t osalThreadSuspendS(thread_reference_t *trp) {
 
-  chDbgAssert(*trp == NULL, "osalThreadSuspendS(), #1", "not NULL");
+  chDbgAssert(*trp == NULL, "not NULL");
 
   *trp = (thread_reference_t)chThdSelf();
   chSchGoSleepS(CH_STATE_SUSPENDED);
@@ -118,7 +118,7 @@ void osalThreadResumeI(thread_reference_t *trp, msg_t msg) {
   if (*trp != NULL) {
 
     chDbgAssert((*trp)->p_state == CH_STATE_SUSPENDED,
-                "osalThreadResumeI(), #1", "not THD_STATE_SUSPENDED");
+                "not THD_STATE_SUSPENDED");
 
     (*trp)->p_u.rdymsg = msg;
     chSchReadyI((thread_t *)*trp);
@@ -141,8 +141,7 @@ void osalThreadResumeS(thread_reference_t *trp, msg_t msg) {
   if (*trp != NULL) {
     thread_t *tp = (thread_t *)*trp;
 
-    chDbgAssert(tp->p_state == CH_STATE_SUSPENDED,
-                "osalThreadResumeS(), #1", "not THD_STATE_SUSPENDED");
+    chDbgAssert(tp->p_state == CH_STATE_SUSPENDED, "not THD_STATE_SUSPENDED");
 
     *trp = NULL;
     chSchWakeupS(tp, msg);
diff --git a/os/hal/osal/chibios/osal.h b/os/hal/osal/chibios/osal.h
index 726782d8b..fa48f3aa6 100644
--- a/os/hal/osal/chibios/osal.h
+++ b/os/hal/osal/chibios/osal.h
@@ -188,8 +188,8 @@ typedef struct {
 
 /**
  * @brief   Condition assertion.
- * @details If the condition check fails then the OSAL panics with the
- *          specified message and halts.
+ * @details If the condition check fails then the OSAL panics with a
+ *          message and halts.
  * @note    The condition is tested only if the @p OSAL_ENABLE_ASSERTIONS
  *          switch is enabled.
  * @note    The convention for the message is the following:<br>
@@ -198,12 +198,11 @@ typedef struct {
  *          comment in the code about the assertion.
  *
  * @param[in] c         the condition to be verified to be true
- * @param[in] msg       the text message
  * @param[in] remark    a remark string
  *
  * @api
  */
-#define osalDbgAssert(c, msg, remark) chDbgAssert(c, msg, remark)
+#define osalDbgAssert(c, remark) chDbgAssert(c, remark)
 
 /**
  * @brief   Function parameters check.
@@ -215,7 +214,7 @@ typedef struct {
  *
  * @api
  */
-#define osalDbgCheck(c) chDbgCheck(c, __FUNCTION__)
+#define osalDbgCheck(c) chDbgCheck(c)
 
 /**
  * @brief   I-Class state check.
diff --git a/os/hal/platforms/STM32/SPIv2/spi_lld.c b/os/hal/platforms/STM32/SPIv2/spi_lld.c
index 712d824f6..3cbcc0fc0 100644
--- a/os/hal/platforms/STM32/SPIv2/spi_lld.c
+++ b/os/hal/platforms/STM32/SPIv2/spi_lld.c
@@ -221,12 +221,12 @@ void spi_lld_start(SPIDriver *spip) {
                             STM32_SPI_SPI1_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_rx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #1", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       b = dmaStreamAllocate(spip->dmatx,
                             STM32_SPI_SPI1_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_tx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #2", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       rccEnableSPI1(FALSE);
     }
 #endif
@@ -237,12 +237,12 @@ void spi_lld_start(SPIDriver *spip) {
                             STM32_SPI_SPI2_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_rx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #3", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       b = dmaStreamAllocate(spip->dmatx,
                             STM32_SPI_SPI2_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_tx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #4", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       rccEnableSPI2(FALSE);
     }
 #endif
@@ -253,12 +253,12 @@ void spi_lld_start(SPIDriver *spip) {
                             STM32_SPI_SPI3_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_rx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #5", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       b = dmaStreamAllocate(spip->dmatx,
                             STM32_SPI_SPI3_IRQ_PRIORITY,
                             (stm32_dmaisr_t)spi_lld_serve_tx_interrupt,
                             (void *)spip);
-      osalDbgAssert(!b, "spi_lld_start(), #6", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       rccEnableSPI3(FALSE);
     }
 #endif
diff --git a/os/hal/platforms/STM32/can_lld.c b/os/hal/platforms/STM32/can_lld.c
index 2febf5bc9..a53a8fe27 100644
--- a/os/hal/platforms/STM32/can_lld.c
+++ b/os/hal/platforms/STM32/can_lld.c
@@ -404,8 +404,7 @@ void can_lld_start(CANDriver *canp) {
 #if STM32_CAN_USE_CAN2
   if (&CAND2 == canp) {
 
-    osalDbgAssert(CAND1.state != CAN_STOP,
-                  "can_lld_start(), #1", "CAN1 must be started");
+    osalDbgAssert(CAND1.state != CAN_STOP, "CAN1 must be started");
 
     nvicEnableVector(STM32_CAN2_TX_NUMBER, STM32_CAN_CAN2_IRQ_PRIORITY);
     nvicEnableVector(STM32_CAN2_RX0_NUMBER, STM32_CAN_CAN2_IRQ_PRIORITY);
@@ -447,8 +446,7 @@ void can_lld_stop(CANDriver *canp) {
     if (&CAND1 == canp) {
 
 #if STM32_CAN_USE_CAN2
-      osalDbgAssert(CAND2.state == CAN_STOP,
-                    "can_lld_stop(), #1", "CAN2 must be stopped");
+      osalDbgAssert(CAND2.state == CAN_STOP, "CAN2 must be stopped");
 #endif
 
       CAN1->MCR = 0x00010002;                   /* Register reset value.    */
@@ -690,12 +688,10 @@ void canSTM32SetFilters(uint32_t can2sb, uint32_t num, const CANFilter *cfp) {
                (num < STM32_CAN_MAX_FILTERS));
 
 #if STM32_CAN_USE_CAN1
-  osalDbgAssert(CAND1.state == CAN_STOP,
-                "canSTM32SetFilters(), #1", "invalid state");
+  osalDbgAssert(CAND1.state == CAN_STOP, "invalid state");
 #endif
 #if STM32_CAN_USE_CAN2
-  osalDbgAssert(CAND2.state == CAN_STOP,
-                "canSTM32SetFilters(), #2", "invalid state");
+  osalDbgAssert(CAND2.state == CAN_STOP, "invalid state");
 #endif
 
   can_lld_set_filters(can2sb, num, cfp);
diff --git a/os/hal/platforms/STM32/icu_lld.c b/os/hal/platforms/STM32/icu_lld.c
index 149231aa3..73699c637 100644
--- a/os/hal/platforms/STM32/icu_lld.c
+++ b/os/hal/platforms/STM32/icu_lld.c
@@ -392,7 +392,7 @@ void icu_lld_start(ICUDriver *icup) {
 
   osalDbgAssert((icup->config->channel == ICU_CHANNEL_1) ||
                 (icup->config->channel == ICU_CHANNEL_2),
-                "icu_lld_start(), #1", "invalid input");
+                "invalid input");
 
   if (icup->state == ICU_STOP) {
     /* Clock activation and timer reset.*/
@@ -469,7 +469,7 @@ void icu_lld_start(ICUDriver *icup) {
   psc = (icup->clock / icup->config->frequency) - 1;
   osalDbgAssert((psc <= 0xFFFF) &&
                 ((psc + 1) * icup->config->frequency) == icup->clock,
-                "icu_lld_start(), #1", "invalid frequency");
+                "invalid frequency");
   icup->tim->PSC  = (uint16_t)psc;
   icup->tim->ARR   = 0xFFFF;
 
diff --git a/os/hal/platforms/STM32/pwm_lld.c b/os/hal/platforms/STM32/pwm_lld.c
index a8850924f..c3109beee 100644
--- a/os/hal/platforms/STM32/pwm_lld.c
+++ b/os/hal/platforms/STM32/pwm_lld.c
@@ -488,9 +488,9 @@ void pwm_lld_start(PWMDriver *pwmp) {
 
   /* Timer configuration.*/
   psc = (pwmp->clock / pwmp->config->frequency) - 1;
-  chDbgAssert((psc <= 0xFFFF) &&
-              ((psc + 1) * pwmp->config->frequency) == pwmp->clock,
-              "pwm_lld_start(), #1", "invalid frequency");
+  osalDbgAssert((psc <= 0xFFFF) &&
+                ((psc + 1) * pwmp->config->frequency) == pwmp->clock,
+                "invalid frequency");
   pwmp->tim->PSC  = (uint16_t)psc;
   pwmp->tim->ARR  = (uint16_t)(pwmp->period - 1);
   pwmp->tim->CR2  = pwmp->config->cr2;
diff --git a/os/hal/platforms/STM32F30x/adc_lld.c b/os/hal/platforms/STM32F30x/adc_lld.c
index 768420c52..d516cf21b 100644
--- a/os/hal/platforms/STM32F30x/adc_lld.c
+++ b/os/hal/platforms/STM32F30x/adc_lld.c
@@ -147,14 +147,12 @@ static void adc_lld_analog_off(ADCDriver *adcp) {
  */
 static void adc_lld_calibrate(ADCDriver *adcp) {
 
-  osalDbgAssert(adcp->adcm->CR == ADC_CR_ADVREGEN_0, "adc_lld_calibrate(), #1",
-                                                     "invalid register state");
+  osalDbgAssert(adcp->adcm->CR == ADC_CR_ADVREGEN_0, "invalid register state");
   adcp->adcm->CR |= ADC_CR_ADCAL;
   while ((adcp->adcm->CR & ADC_CR_ADCAL) != 0)
     ;
 #if STM32_ADC_DUAL_MODE
-  osalDbgAssert(adcp->adcs->CR == ADC_CR_ADVREGEN_0, "adc_lld_calibrate(), #2",
-                                                     "invalid register state");
+  osalDbgAssert(adcp->adcs->CR == ADC_CR_ADVREGEN_0, "invalid register state");
   adcp->adcs->CR |= ADC_CR_ADCAL;
   while ((adcp->adcs->CR & ADC_CR_ADCAL) != 0)
     ;
@@ -377,7 +375,7 @@ void adc_lld_start(ADCDriver *adcp) {
                             STM32_ADC_ADC12_DMA_IRQ_PRIORITY,
                             (stm32_dmaisr_t)adc_lld_serve_dma_interrupt,
                             (void *)adcp);
-      osalDbgAssert(!b, "adc_lld_start(), #1", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       rccEnableADC12(FALSE);
     }
 #endif /* STM32_ADC_USE_ADC1 */
@@ -389,7 +387,7 @@ void adc_lld_start(ADCDriver *adcp) {
                             STM32_ADC_ADC34_DMA_IRQ_PRIORITY,
                             (stm32_dmaisr_t)adc_lld_serve_dma_interrupt,
                             (void *)adcp);
-      osalDbgAssert(!b, "adc_lld_start(), #2", "stream already allocated");
+      osalDbgAssert(!b, "stream already allocated");
       rccEnableADC34(FALSE);
     }
 #endif /* STM32_ADC_USE_ADC2 */
@@ -459,7 +457,6 @@ void adc_lld_start_conversion(ADCDriver *adcp) {
   const ADCConversionGroup *grpp = adcp->grpp;
 
   osalDbgAssert(!STM32_ADC_DUAL_MODE || ((grpp->num_channels & 1) == 0),
-                "adc_lld_start_conversion(), #1",
                 "odd number of channels in dual mode");
 
   /* Calculating control registers values.*/
diff --git a/os/hal/platforms/STM32F30x/stm32_dma.c b/os/hal/platforms/STM32F30x/stm32_dma.c
index 430a9f667..eb73f1b37 100644
--- a/os/hal/platforms/STM32F30x/stm32_dma.c
+++ b/os/hal/platforms/STM32F30x/stm32_dma.c
@@ -427,7 +427,7 @@ void dmaStreamRelease(const stm32_dma_stream_t *dmastp) {
 
   /* Check if the streams is not taken.*/
   osalDbgAssert((dma_streams_mask & (1 << dmastp->selfindex)) != 0,
-                "dmaStreamRelease(), #1", "not allocated");
+                "not allocated");
 
   /* Disables the associated IRQ vector.*/
   nvicDisableVector(dmastp->vector);
diff --git a/os/hal/src/adc.c b/os/hal/src/adc.c
index ccc11574a..e6d8d8075 100644
--- a/os/hal/src/adc.c
+++ b/os/hal/src/adc.c
@@ -102,7 +102,7 @@ void adcStart(ADCDriver *adcp, const ADCConfig *config) {
 
   osalSysLock();
   osalDbgAssert((adcp->state == ADC_STOP) || (adcp->state == ADC_READY),
-                "adcStart(), #1", "invalid state");
+                "invalid state");
   adcp->config = config;
   adc_lld_start(adcp);
   adcp->state = ADC_READY;
@@ -122,7 +122,7 @@ void adcStop(ADCDriver *adcp) {
 
   osalSysLock();
   osalDbgAssert((adcp->state == ADC_STOP) || (adcp->state == ADC_READY),
-                "adcStop(), #1", "invalid state");
+                "invalid state");
   adc_lld_stop(adcp);
   adcp->state = ADC_STOP;
   osalSysUnlock();
@@ -183,7 +183,7 @@ void adcStartConversionI(ADCDriver *adcp,
   osalDbgAssert((adcp->state == ADC_READY) ||
                 (adcp->state == ADC_COMPLETE) ||
                 (adcp->state == ADC_ERROR),
-                "adcStartConversionI(), #1", "not ready");
+                "not ready");
 
   adcp->samples  = samples;
   adcp->depth    = depth;
@@ -207,9 +207,8 @@ void adcStopConversion(ADCDriver *adcp) {
   osalDbgCheck(adcp != NULL);
 
   osalSysLock();
-  osalDbgAssert((adcp->state == ADC_READY) ||
-                (adcp->state == ADC_ACTIVE),
-                "adcStopConversion(), #1", "invalid state");
+  osalDbgAssert((adcp->state == ADC_READY) || (adcp->state == ADC_ACTIVE),
+                "invalid state");
   if (adcp->state != ADC_READY) {
     adc_lld_stop_conversion(adcp);
     adcp->grpp  = NULL;
@@ -236,7 +235,7 @@ void adcStopConversionI(ADCDriver *adcp) {
   osalDbgAssert((adcp->state == ADC_READY) ||
                 (adcp->state == ADC_ACTIVE) ||
                 (adcp->state == ADC_COMPLETE),
-                "adcStopConversionI(), #1", "invalid state");
+                "invalid state");
 
   if (adcp->state != ADC_READY) {
     adc_lld_stop_conversion(adcp);
@@ -277,7 +276,7 @@ msg_t adcConvert(ADCDriver *adcp,
   msg_t msg;
 
   osalSysLock();
-  osalDbgAssert(adcp->thread == NULL, "adcConvert(), #1", "already waiting");
+  osalDbgAssert(adcp->thread == NULL, "already waiting");
   adcStartConversionI(adcp, grpp, samples, depth);
   msg = osalThreadSuspendS(&adcp->thread);
   osalSysUnlock();
diff --git a/os/hal/src/can.c b/os/hal/src/can.c
index 9a352ddd1..ed5c43f87 100644
--- a/os/hal/src/can.c
+++ b/os/hal/src/can.c
@@ -104,7 +104,7 @@ void canStart(CANDriver *canp, const CANConfig *config) {
   osalDbgAssert((canp->state == CAN_STOP) ||
                 (canp->state == CAN_STARTING) ||
                 (canp->state == CAN_READY),
-                "canStart(), #1", "invalid state");
+                "invalid state");
   while (canp->state == CAN_STARTING)
     osalThreadSleepS(1);
   if (canp->state == CAN_STOP) {
@@ -128,7 +128,7 @@ void canStop(CANDriver *canp) {
 
   osalSysLock();
   osalDbgAssert((canp->state == CAN_STOP) || (canp->state == CAN_READY),
-                "canStop(), #1", "invalid state");
+                "invalid state");
   can_lld_stop(canp);
   canp->state  = CAN_STOP;
   osalQueueWakeupAllI(&canp->rxqueue, MSG_RESET);
@@ -168,7 +168,7 @@ msg_t canTransmit(CANDriver *canp,
 
   osalSysLock();
   osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
-                "canTransmit(), #1", "invalid state");
+                "invalid state");
   while ((canp->state == CAN_SLEEP) || !can_lld_is_tx_empty(canp, mailbox)) {
     msg_t msg = osalQueueGoSleepTimeoutS(&canp->txqueue, timeout);
     if (msg != MSG_OK) {
@@ -213,7 +213,7 @@ msg_t canReceive(CANDriver *canp,
 
   osalSysLock();
   osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
-                "canReceive(), #1", "invalid state");
+                "invalid state");
   while ((canp->state == CAN_SLEEP) || !can_lld_is_rx_nonempty(canp, mailbox)) {
     msg_t msg = osalQueueGoSleepTimeoutS(&canp->rxqueue, timeout);
     if (msg != MSG_OK) {
@@ -245,7 +245,7 @@ void canSleep(CANDriver *canp) {
 
   osalSysLock();
   osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
-                "canSleep(), #1", "invalid state");
+                "invalid state");
   if (canp->state == CAN_READY) {
     can_lld_sleep(canp);
     canp->state = CAN_SLEEP;
@@ -268,7 +268,7 @@ void canWakeup(CANDriver *canp) {
 
   osalSysLock();
   osalDbgAssert((canp->state == CAN_READY) || (canp->state == CAN_SLEEP),
-                "canWakeup(), #1", "invalid state");
+                "invalid state");
   if (canp->state == CAN_SLEEP) {
     can_lld_wakeup(canp);
     canp->state = CAN_READY;
diff --git a/os/hal/src/icu.c b/os/hal/src/icu.c
index 401c0e04c..291b6df9a 100644
--- a/os/hal/src/icu.c
+++ b/os/hal/src/icu.c
@@ -89,7 +89,7 @@ void icuStart(ICUDriver *icup, const ICUConfig *config) {
 
   osalSysLock();
   osalDbgAssert((icup->state == ICU_STOP) || (icup->state == ICU_READY),
-                "icuStart(), #1", "invalid state");
+                "invalid state");
   icup->config = config;
   icu_lld_start(icup);
   icup->state = ICU_READY;
@@ -109,7 +109,7 @@ void icuStop(ICUDriver *icup) {
 
   osalSysLock();
   osalDbgAssert((icup->state == ICU_STOP) || (icup->state == ICU_READY),
-                "icuStop(), #1", "invalid state");
+                "invalid state");
   icu_lld_stop(icup);
   icup->state = ICU_STOP;
   osalSysUnlock();
@@ -127,7 +127,7 @@ void icuEnable(ICUDriver *icup) {
   osalDbgCheck(icup != NULL);
 
   osalSysLock();
-  osalDbgAssert(icup->state == ICU_READY, "icuEnable(), #1", "invalid state");
+  osalDbgAssert(icup->state == ICU_READY, "invalid state");
   icu_lld_enable(icup);
   icup->state = ICU_WAITING;
   osalSysUnlock();
@@ -147,7 +147,7 @@ void icuDisable(ICUDriver *icup) {
   osalSysLock();
   osalDbgAssert((icup->state == ICU_READY) || (icup->state == ICU_WAITING) ||
                 (icup->state == ICU_ACTIVE) || (icup->state == ICU_IDLE),
-                "icuDisable(), #1", "invalid state");
+                "invalid state");
   icu_lld_disable(icup);
   icup->state = ICU_READY;
   osalSysUnlock();
diff --git a/os/hal/src/pwm.c b/os/hal/src/pwm.c
index bde512176..dfbe32df3 100644
--- a/os/hal/src/pwm.c
+++ b/os/hal/src/pwm.c
@@ -94,7 +94,7 @@ void pwmStart(PWMDriver *pwmp, const PWMConfig *config) {
 
   osalSysLock();
   osalDbgAssert((pwmp->state == PWM_STOP) || (pwmp->state == PWM_READY),
-                "pwmStart(), #1", "invalid state");
+                "invalid state");
   pwmp->config = config;
   pwmp->period = config->period;
   pwm_lld_start(pwmp);
@@ -115,7 +115,7 @@ void pwmStop(PWMDriver *pwmp) {
 
   osalSysLock();
   osalDbgAssert((pwmp->state == PWM_STOP) || (pwmp->state == PWM_READY),
-                "pwmStop(), #1", "invalid state");
+                "invalid state");
   pwm_lld_stop(pwmp);
   pwmp->state = PWM_STOP;
   osalSysUnlock();
@@ -141,8 +141,7 @@ void pwmChangePeriod(PWMDriver *pwmp, pwmcnt_t period) {
   osalDbgCheck(pwmp != NULL);
 
   osalSysLock();
-  osalDbgAssert(pwmp->state == PWM_READY,
-                "pwmChangePeriod(), #1", "invalid state");
+  osalDbgAssert(pwmp->state == PWM_READY, "invalid state");
   pwmChangePeriodI(pwmp, period);
   osalSysUnlock();
 }
@@ -168,8 +167,7 @@ void pwmEnableChannel(PWMDriver *pwmp,
   osalDbgCheck((pwmp != NULL) && (channel < PWM_CHANNELS));
 
   osalSysLock();
-  osalDbgAssert(pwmp->state == PWM_READY,
-                "pwmEnableChannel(), #1", "not ready");
+  osalDbgAssert(pwmp->state == PWM_READY, "not ready");
   pwm_lld_enable_channel(pwmp, channel, width);
   osalSysUnlock();
 }
@@ -193,8 +191,7 @@ void pwmDisableChannel(PWMDriver *pwmp, pwmchannel_t channel) {
   osalDbgCheck((pwmp != NULL) && (channel < PWM_CHANNELS));
 
   osalSysLock();
-  osalDbgAssert(pwmp->state == PWM_READY,
-                "pwmDisableChannel(), #1", "not ready");
+  osalDbgAssert(pwmp->state == PWM_READY, "not ready");
   pwm_lld_disable_channel(pwmp, channel);
   osalSysUnlock();
 }
diff --git a/os/hal/src/serial.c b/os/hal/src/serial.c
index 0b9d5b41d..4b1fd17d5 100644
--- a/os/hal/src/serial.c
+++ b/os/hal/src/serial.c
@@ -154,7 +154,7 @@ void sdStart(SerialDriver *sdp, const SerialConfig *config) {
 
   osalSysLock();
   osalDbgAssert((sdp->state == SD_STOP) || (sdp->state == SD_READY),
-                "sdStart(), #1", "invalid state");
+                "invalid state");
   sd_lld_start(sdp, config);
   sdp->state = SD_READY;
   osalSysUnlock();
@@ -175,7 +175,7 @@ void sdStop(SerialDriver *sdp) {
 
   osalSysLock();
   osalDbgAssert((sdp->state == SD_STOP) || (sdp->state == SD_READY),
-              "sdStop(), #1", "invalid state");
+                "invalid state");
   sd_lld_stop(sdp);
   sdp->state = SD_STOP;
   oqResetI(&sdp->oqueue);
diff --git a/os/hal/src/spi.c b/os/hal/src/spi.c
index cd7124bd3..f47ed0527 100644
--- a/os/hal/src/spi.c
+++ b/os/hal/src/spi.c
@@ -98,7 +98,7 @@ void spiStart(SPIDriver *spip, const SPIConfig *config) {
 
   osalSysLock();
   osalDbgAssert((spip->state == SPI_STOP) || (spip->state == SPI_READY),
-                "spiStart(), #1", "invalid state");
+                "invalid state");
   spip->config = config;
   spi_lld_start(spip);
   spip->state = SPI_READY;
@@ -120,7 +120,7 @@ void spiStop(SPIDriver *spip) {
 
   osalSysLock();
   osalDbgAssert((spip->state == SPI_STOP) || (spip->state == SPI_READY),
-                "spiStop(), #1", "invalid state");
+                "invalid state");
   spi_lld_stop(spip);
   spip->state = SPI_STOP;
   osalSysUnlock();
@@ -138,7 +138,7 @@ void spiSelect(SPIDriver *spip) {
   osalDbgCheck(spip != NULL);
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY, "spiSelect(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiSelectI(spip);
   osalSysUnlock();
 }
@@ -156,7 +156,7 @@ void spiUnselect(SPIDriver *spip) {
   osalDbgCheck(spip != NULL);
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY, "spiUnselect(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiUnselectI(spip);
   osalSysUnlock();
 }
@@ -179,7 +179,7 @@ void spiStartIgnore(SPIDriver *spip, size_t n) {
   osalDbgCheck((spip != NULL) && (n > 0));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY, "spiStartIgnore(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiStartIgnoreI(spip, n);
   osalSysUnlock();
 }
@@ -207,8 +207,7 @@ void spiStartExchange(SPIDriver *spip, size_t n,
   osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL) && (txbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY,
-                "spiStartExchange(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiStartExchangeI(spip, n, txbuf, rxbuf);
   osalSysUnlock();
 }
@@ -233,7 +232,7 @@ void spiStartSend(SPIDriver *spip, size_t n, const void *txbuf) {
   osalDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY, "spiStartSend(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiStartSendI(spip, n, txbuf);
   osalSysUnlock();
 }
@@ -258,8 +257,7 @@ void spiStartReceive(SPIDriver *spip, size_t n, void *rxbuf) {
   osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY,
-                "spiStartReceive(), #1", "not ready");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
   spiStartReceiveI(spip, n, rxbuf);
   osalSysUnlock();
 }
@@ -284,10 +282,8 @@ void spiIgnore(SPIDriver *spip, size_t n) {
   osalDbgCheck((spip != NULL) && (n > 0));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY,
-                "spiIgnore(), #1", "not ready");
-  osalDbgAssert(spip->config->end_cb == NULL,
-                "spiIgnore(), #2", "has callback");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
+  osalDbgAssert(spip->config->end_cb == NULL, "has callback");
   spiStartIgnoreI(spip, n);
   _spi_wait_s(spip);
   osalSysUnlock();
@@ -318,9 +314,8 @@ void spiExchange(SPIDriver *spip, size_t n,
                (rxbuf != NULL) && (txbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY, "spiExchange(), #1", "not ready");
-  osalDbgAssert(spip->config->end_cb == NULL,
-              "spiExchange(), #2", "has callback");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
+  osalDbgAssert(spip->config->end_cb == NULL, "has callback");
   spiStartExchangeI(spip, n, txbuf, rxbuf);
   _spi_wait_s(spip);
   osalSysUnlock();
@@ -347,10 +342,8 @@ void spiSend(SPIDriver *spip, size_t n, const void *txbuf) {
   osalDbgCheck((spip != NULL) && (n > 0) && (txbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY,
-                "spiSend(), #1", "not ready");
-  osalDbgAssert(spip->config->end_cb == NULL,
-                "spiSend(), #2", "has callback");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
+  osalDbgAssert(spip->config->end_cb == NULL, "has callback");
   spiStartSendI(spip, n, txbuf);
   _spi_wait_s(spip);
   osalSysUnlock();
@@ -377,10 +370,8 @@ void spiReceive(SPIDriver *spip, size_t n, void *rxbuf) {
   osalDbgCheck((spip != NULL) && (n > 0) && (rxbuf != NULL));
 
   osalSysLock();
-  osalDbgAssert(spip->state == SPI_READY,
-                "spiReceive(), #1", "not ready");
-  osalDbgAssert(spip->config->end_cb == NULL,
-                "spiReceive(), #2", "has callback");
+  osalDbgAssert(spip->state == SPI_READY, "not ready");
+  osalDbgAssert(spip->config->end_cb == NULL, "has callback");
   spiStartReceiveI(spip, n, rxbuf);
   _spi_wait_s(spip);
   osalSysUnlock();
diff --git a/os/kernel/include/chdebug.h b/os/kernel/include/chdebug.h
index 0f4083c84..836645f07 100644
--- a/os/kernel/include/chdebug.h
+++ b/os/kernel/include/chdebug.h
@@ -177,49 +177,43 @@ typedef struct {
  *          is specified in @p chconf.h else the macro does nothing.
  *
  * @param[in] c         the condition to be verified to be true
- * @param[in] func      the undecorated function name
  *
  * @api
  */
 #if !defined(chDbgCheck)
-#define chDbgCheck(c, func) {                                               \
+#define chDbgCheck(c) {                                                     \
   if (!(c))                                                                 \
-    chDbgPanic(__QUOTE_THIS(func)"()");                                     \
+    chDbgPanic("C:"__QUOTE_THIS(__FUNCTION__)":"__QUOTE_THIS(__LINE__));    \
 }
 #endif /* !defined(chDbgCheck) */
 
 #else /* !CH_DBG_ENABLE_CHECKS */
-#define chDbgCheck(c, func) {                                               \
-  (void)(c), (void)__QUOTE_THIS(func)"()";                                  \
-}
+#define chDbgCheck(c) {(void)(c);}
 #endif /* !CH_DBG_ENABLE_CHECKS */
 
 #if CH_DBG_ENABLE_ASSERTS || defined(__DOXYGEN__)
 /**
  * @brief   Condition assertion.
- * @details If the condition check fails then the kernel panics with the
- *          specified message and halts.
+ * @details If the condition check fails then the kernel panics with a
+ *          message and halts.
  * @note    The condition is tested only if the @p CH_DBG_ENABLE_ASSERTS switch
  *          is specified in @p chconf.h else the macro does nothing.
- * @note    The convention for the message is the following:<br>
- *          @<function_name@>(), #@<assert_number@>
  * @note    The remark string is not currently used except for putting a
  *          comment in the code about the assertion.
  *
  * @param[in] c         the condition to be verified to be true
- * @param[in] m         the text message
  * @param[in] r         a remark string
  *
  * @api
  */
 #if !defined(chDbgAssert)
-#define chDbgAssert(c, m, r) {                                              \
+#define chDbgAssert(c, r) {                                                 \
   if (!(c))                                                                 \
-    chDbgPanic(m);                                                          \
+    chDbgPanic("A:"__QUOTE_THIS(__FUNCTION__)":"__QUOTE_THIS(__LINE__));    \
 }
 #endif /* !defined(chDbgAssert) */
 #else /* !CH_DBG_ENABLE_ASSERTS */
-#define chDbgAssert(c, m, r) {(void)(c);}
+#define chDbgAssert(c, r) {(void)(c);}
 #endif /* !CH_DBG_ENABLE_ASSERTS */
 /** @} */
 
diff --git a/os/kernel/ports/ARMCMx/devices/STM32F30x/systick.h b/os/kernel/ports/ARMCMx/devices/STM32F30x/systick.h
index 3b143780d..bf73c1a37 100644
--- a/os/kernel/ports/ARMCMx/devices/STM32F30x/systick.h
+++ b/os/kernel/ports/ARMCMx/devices/STM32F30x/systick.h
@@ -80,9 +80,7 @@ static inline systime_t port_timer_get_time(void) {
  */
 static inline void port_timer_start_alarm(systime_t time) {
 
-  chDbgAssert((TIM2->DIER & 2) == 0,
-              "port_timer_start_alarm(), #1",
-              "already started");
+  chDbgAssert((TIM2->DIER & 2) == 0, "already started");
 
   TIM2->CCR1  = time;
   TIM2->SR      = 0;
@@ -96,9 +94,7 @@ static inline void port_timer_start_alarm(systime_t time) {
  */
 static inline void port_timer_stop_alarm(void) {
 
-  chDbgAssert((TIM2->DIER & 2) != 0,
-              "port_timer_stop_alarm(), #1",
-              "not started");
+  chDbgAssert((TIM2->DIER & 2) != 0, "not started");
 
   TIM2->DIER    = 0;
 }
@@ -112,9 +108,7 @@ static inline void port_timer_stop_alarm(void) {
  */
 static inline void port_timer_set_alarm(systime_t time) {
 
-  chDbgAssert((TIM2->DIER & 2) != 0,
-              "port_timer_set_alarm(), #1",
-              "not started");
+  chDbgAssert((TIM2->DIER & 2) != 0, "not started");
 
   TIM2->CCR1  = time;
 }
@@ -128,9 +122,7 @@ static inline void port_timer_set_alarm(systime_t time) {
  */
 static inline systime_t port_timer_get_alarm(void) {
 
-  chDbgAssert((TIM2->DIER & 2) != 0,
-              "port_timer_get_alarm(), #1",
-              "not started");
+  chDbgAssert((TIM2->DIER & 2) != 0, "not started");
 
   return TIM2->CCR1;
 }
diff --git a/os/kernel/src/chcond.c b/os/kernel/src/chcond.c
index 49e1f891e..94fd8e81c 100644
--- a/os/kernel/src/chcond.c
+++ b/os/kernel/src/chcond.c
@@ -75,7 +75,7 @@
  */
 void chCondObjectInit(condition_variable_t *cp) {
 
-  chDbgCheck(cp != NULL, "chCondInit");
+  chDbgCheck(cp != NULL);
 
   queue_init(&cp->c_queue);
 }
@@ -89,7 +89,7 @@ void chCondObjectInit(condition_variable_t *cp) {
  */
 void chCondSignal(condition_variable_t *cp) {
 
-  chDbgCheck(cp != NULL, "chCondSignal");
+  chDbgCheck(cp != NULL);
 
   chSysLock();
   if (queue_notempty(&cp->c_queue))
@@ -111,7 +111,7 @@ void chCondSignal(condition_variable_t *cp) {
 void chCondSignalI(condition_variable_t *cp) {
 
   chDbgCheckClassI();
-  chDbgCheck(cp != NULL, "chCondSignalI");
+  chDbgCheck(cp != NULL);
 
   if (queue_notempty(&cp->c_queue))
     chSchReadyI(queue_fifo_remove(&cp->c_queue))->p_u.rdymsg = RDY_OK;
@@ -146,7 +146,7 @@ void chCondBroadcast(condition_variable_t *cp) {
 void chCondBroadcastI(condition_variable_t *cp) {
 
   chDbgCheckClassI();
-  chDbgCheck(cp != NULL, "chCondBroadcastI");
+  chDbgCheck(cp != NULL);
 
   /* Empties the condition variable queue and inserts all the threads into the
      ready list in FIFO order. The wakeup message is set to @p RDY_RESET in
@@ -204,10 +204,8 @@ msg_t chCondWaitS(condition_variable_t *cp) {
   msg_t msg;
 
   chDbgCheckClassS();
-  chDbgCheck(cp != NULL, "chCondWaitS");
-  chDbgAssert(ctp->p_mtxlist != NULL,
-              "chCondWaitS(), #1",
-              "not owning a mutex");
+  chDbgCheck(cp != NULL);
+  chDbgAssert(ctp->p_mtxlist != NULL, "not owning a mutex");
 
   mp = chMtxUnlockS();
   ctp->p_u.wtobjp = cp;
@@ -289,10 +287,8 @@ msg_t chCondWaitTimeoutS(condition_variable_t *cp, systime_t time) {
   msg_t msg;
 
   chDbgCheckClassS();
-  chDbgCheck((cp != NULL) && (time != TIME_IMMEDIATE), "chCondWaitTimeoutS");
-  chDbgAssert(currp->p_mtxlist != NULL,
-              "chCondWaitTimeoutS(), #1",
-              "not owning a mutex");
+  chDbgCheck((cp != NULL) && (time != TIME_IMMEDIATE));
+  chDbgAssert(currp->p_mtxlist != NULL, "not owning a mutex");
 
   mp = chMtxUnlockS();
   currp->p_u.wtobjp = cp;
diff --git a/os/kernel/src/chdynamic.c b/os/kernel/src/chdynamic.c
index 86e37df14..5f174eda7 100644
--- a/os/kernel/src/chdynamic.c
+++ b/os/kernel/src/chdynamic.c
@@ -69,7 +69,7 @@
 thread_t *chThdAddRef(thread_t *tp) {
 
   chSysLock();
-  chDbgAssert(tp->p_refs < 255, "chThdAddRef(), #1", "too many references");
+  chDbgAssert(tp->p_refs < 255, "too many references");
   tp->p_refs++;
   chSysUnlock();
   return tp;
@@ -92,7 +92,7 @@ void chThdRelease(thread_t *tp) {
   trefs_t refs;
 
   chSysLock();
-  chDbgAssert(tp->p_refs > 0, "chThdRelease(), #1", "not referenced");
+  chDbgAssert(tp->p_refs > 0, "not referenced");
   refs = --tp->p_refs;
   chSysUnlock();
 
@@ -198,7 +198,7 @@ thread_t *chThdCreateFromMemoryPool(memory_pool_t *mp, tprio_t prio,
   void *wsp;
   thread_t *tp;
 
-  chDbgCheck(mp != NULL, "chThdCreateFromMemoryPool");
+  chDbgCheck(mp != NULL);
 
   wsp = chPoolAlloc(mp);
   if (wsp == NULL)
diff --git a/os/kernel/src/chevents.c b/os/kernel/src/chevents.c
index d95730f7c..04b0e6fb8 100644
--- a/os/kernel/src/chevents.c
+++ b/os/kernel/src/chevents.c
@@ -104,7 +104,7 @@ void chEvtRegisterMask(event_source_t *esp,
                        event_listener_t *elp,
                        eventmask_t mask) {
 
-  chDbgCheck((esp != NULL) && (elp != NULL), "chEvtRegisterMask");
+  chDbgCheck((esp != NULL) && (elp != NULL));
 
   chSysLock();
   elp->el_next     = esp->es_next;
@@ -131,7 +131,7 @@ void chEvtRegisterMask(event_source_t *esp,
 void chEvtUnregister(event_source_t *esp, event_listener_t *elp) {
   event_listener_t *p;
 
-  chDbgCheck((esp != NULL) && (elp != NULL), "chEvtUnregister");
+  chDbgCheck((esp != NULL) && (elp != NULL));
 
   p = (event_listener_t *)esp;
   chSysLock();
@@ -205,7 +205,7 @@ void chEvtBroadcastFlagsI(event_source_t *esp, eventflags_t flags) {
   event_listener_t *elp;
 
   chDbgCheckClassI();
-  chDbgCheck(esp != NULL, "chEvtBroadcastMaskI");
+  chDbgCheck(esp != NULL);
 
   elp = esp->es_next;
   while (elp != (event_listener_t *)esp) {
@@ -248,7 +248,7 @@ eventflags_t chEvtGetAndClearFlags(event_listener_t *elp) {
  */
 void chEvtSignal(thread_t *tp, eventmask_t mask) {
 
-  chDbgCheck(tp != NULL, "chEvtSignal");
+  chDbgCheck(tp != NULL);
 
   chSysLock();
   chEvtSignalI(tp, mask);
@@ -271,7 +271,7 @@ void chEvtSignal(thread_t *tp, eventmask_t mask) {
 void chEvtSignalI(thread_t *tp, eventmask_t mask) {
 
   chDbgCheckClassI();
-  chDbgCheck(tp != NULL, "chEvtSignalI");
+  chDbgCheck(tp != NULL);
 
   tp->p_epending |= mask;
   /* Test on the AND/OR conditions wait states.*/
@@ -335,14 +335,12 @@ eventflags_t chEvtGetAndClearFlagsI(event_listener_t *elp) {
 void chEvtDispatch(const evhandler_t *handlers, eventmask_t mask) {
   eventid_t eid;
 
-  chDbgCheck(handlers != NULL, "chEvtDispatch");
+  chDbgCheck(handlers != NULL);
 
   eid = 0;
   while (mask) {
     if (mask & EVENT_MASK(eid)) {
-      chDbgAssert(handlers[eid] != NULL,
-                  "chEvtDispatch(), #1",
-                  "null handler");
+      chDbgAssert(handlers[eid] != NULL, "null handler");
       mask &= ~EVENT_MASK(eid);
       handlers[eid](eid);
     }
diff --git a/os/kernel/src/chheap.c b/os/kernel/src/chheap.c
index c2732376e..abda4ff10 100644
--- a/os/kernel/src/chheap.c
+++ b/os/kernel/src/chheap.c
@@ -108,7 +108,7 @@ void _heap_init(void) {
 void chHeapObjectInit(memory_heap_t *heapp, void *buf, size_t size) {
   union heap_header *hp;
 
-  chDbgCheck(MEM_IS_ALIGNED(buf) && MEM_IS_ALIGNED(size), "chHeapInit");
+  chDbgCheck(MEM_IS_ALIGNED(buf) && MEM_IS_ALIGNED(size));
 
   heapp->h_provider = (memgetfunc_t)NULL;
   heapp->h_free.h.u.next = hp = buf;
@@ -204,7 +204,7 @@ void chHeapFree(void *p) {
   union heap_header *qp, *hp;
   memory_heap_t *heapp;
 
-  chDbgCheck(p != NULL, "chHeapFree");
+  chDbgCheck(p != NULL);
 
   hp = (union heap_header *)p - 1;
   heapp = hp->h.u.heap;
@@ -212,9 +212,7 @@ void chHeapFree(void *p) {
   H_LOCK(heapp);
 
   while (true) {
-    chDbgAssert((hp < qp) || (hp >= LIMIT(qp)),
-                "chHeapFree(), #1",
-                "within free block");
+    chDbgAssert((hp < qp) || (hp >= LIMIT(qp)), "within free block");
 
     if (((qp == &heapp->h_free) || (hp > qp)) &&
         ((qp->h.u.next == NULL) || (hp < qp->h.u.next))) {
diff --git a/os/kernel/src/chmboxes.c b/os/kernel/src/chmboxes.c
index 2a6e6fae8..003c779ec 100644
--- a/os/kernel/src/chmboxes.c
+++ b/os/kernel/src/chmboxes.c
@@ -86,7 +86,7 @@
  */
 void chMBObjectInit(mailbox_t *mbp, msg_t *buf, cnt_t n) {
 
-  chDbgCheck((mbp != NULL) && (buf != NULL) && (n > 0), "chMBInit");
+  chDbgCheck((mbp != NULL) && (buf != NULL) && (n > 0));
 
   mbp->mb_buffer = mbp->mb_wrptr = mbp->mb_rdptr = buf;
   mbp->mb_top = &buf[n];
@@ -105,7 +105,7 @@ void chMBObjectInit(mailbox_t *mbp, msg_t *buf, cnt_t n) {
  */
 void chMBReset(mailbox_t *mbp) {
 
-  chDbgCheck(mbp != NULL, "chMBReset");
+  chDbgCheck(mbp != NULL);
 
   chSysLock();
   mbp->mb_wrptr = mbp->mb_rdptr = mbp->mb_buffer;
@@ -166,7 +166,7 @@ msg_t chMBPostS(mailbox_t *mbp, msg_t msg, systime_t time) {
   msg_t rdymsg;
 
   chDbgCheckClassS();
-  chDbgCheck(mbp != NULL, "chMBPostS");
+  chDbgCheck(mbp != NULL);
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
   if (rdymsg == RDY_OK) {
@@ -196,7 +196,7 @@ msg_t chMBPostS(mailbox_t *mbp, msg_t msg, systime_t time) {
 msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
 
   chDbgCheckClassI();
-  chDbgCheck(mbp != NULL, "chMBPostI");
+  chDbgCheck(mbp != NULL);
 
   if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
     return RDY_TIMEOUT;
@@ -259,7 +259,7 @@ msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t time) {
   msg_t rdymsg;
 
   chDbgCheckClassS();
-  chDbgCheck(mbp != NULL, "chMBPostAheadS");
+  chDbgCheck(mbp != NULL);
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);
   if (rdymsg == RDY_OK) {
@@ -289,7 +289,7 @@ msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t time) {
 msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
 
   chDbgCheckClassI();
-  chDbgCheck(mbp != NULL, "chMBPostAheadI");
+  chDbgCheck(mbp != NULL);
 
   if (chSemGetCounterI(&mbp->mb_emptysem) <= 0)
     return RDY_TIMEOUT;
@@ -352,7 +352,7 @@ msg_t chMBFetchS(mailbox_t *mbp, msg_t *msgp, systime_t time) {
   msg_t rdymsg;
 
   chDbgCheckClassS();
-  chDbgCheck((mbp != NULL) && (msgp != NULL), "chMBFetchS");
+  chDbgCheck((mbp != NULL) && (msgp != NULL));
 
   rdymsg = chSemWaitTimeoutS(&mbp->mb_fullsem, time);
   if (rdymsg == RDY_OK) {
@@ -382,7 +382,7 @@ msg_t chMBFetchS(mailbox_t *mbp, msg_t *msgp, systime_t time) {
 msg_t chMBFetchI(mailbox_t *mbp, msg_t *msgp) {
 
   chDbgCheckClassI();
-  chDbgCheck((mbp != NULL) && (msgp != NULL), "chMBFetchI");
+  chDbgCheck((mbp != NULL) && (msgp != NULL));
 
   if (chSemGetCounterI(&mbp->mb_fullsem) <= 0)
     return RDY_TIMEOUT;
diff --git a/os/kernel/src/chmempools.c b/os/kernel/src/chmempools.c
index 6d84b557e..d92ea7517 100644
--- a/os/kernel/src/chmempools.c
+++ b/os/kernel/src/chmempools.c
@@ -75,7 +75,7 @@
  */
 void chPoolObjectInit(memory_pool_t *mp, size_t size, memgetfunc_t provider) {
 
-  chDbgCheck((mp != NULL) && (size >= sizeof(void *)), "chPoolInit");
+  chDbgCheck((mp != NULL) && (size >= sizeof(void *)));
 
   mp->mp_next = NULL;
   mp->mp_object_size = size;
@@ -97,7 +97,7 @@ void chPoolObjectInit(memory_pool_t *mp, size_t size, memgetfunc_t provider) {
  */
 void chPoolLoadArray(memory_pool_t *mp, void *p, size_t n) {
 
-  chDbgCheck((mp != NULL) && (n != 0), "chPoolLoadArray");
+  chDbgCheck((mp != NULL) && (n != 0));
 
   while (n) {
     chPoolAdd(mp, p);
@@ -120,7 +120,7 @@ void *chPoolAllocI(memory_pool_t *mp) {
   void *objp;
 
   chDbgCheckClassI();
-  chDbgCheck(mp != NULL, "chPoolAllocI");
+  chDbgCheck(mp != NULL);
 
   if ((objp = mp->mp_next) != NULL)
     mp->mp_next = mp->mp_next->ph_next;
@@ -164,7 +164,7 @@ void chPoolFreeI(memory_pool_t *mp, void *objp) {
   struct pool_header *php = objp;
 
   chDbgCheckClassI();
-  chDbgCheck((mp != NULL) && (objp != NULL), "chPoolFreeI");
+  chDbgCheck((mp != NULL) && (objp != NULL));
 
   php->ph_next = mp->mp_next;
   mp->mp_next = php;
diff --git a/os/kernel/src/chmsg.c b/os/kernel/src/chmsg.c
index 1e99cce3f..335b46c61 100644
--- a/os/kernel/src/chmsg.c
+++ b/os/kernel/src/chmsg.c
@@ -88,7 +88,7 @@
 msg_t chMsgSend(thread_t *tp, msg_t msg) {
   thread_t *ctp = currp;
 
-  chDbgCheck(tp != NULL, "chMsgSend");
+  chDbgCheck(tp != NULL);
 
   chSysLock();
   ctp->p_msg = msg;
@@ -141,8 +141,7 @@ thread_t *chMsgWait(void) {
 void chMsgRelease(thread_t *tp, msg_t msg) {
 
   chSysLock();
-  chDbgAssert(tp->p_state == CH_STATE_SNDMSG,
-              "chMsgRelease(), #1", "invalid state");
+  chDbgAssert(tp->p_state == CH_STATE_SNDMSG, "invalid state");
   chMsgReleaseS(tp, msg);
   chSysUnlock();
 }
diff --git a/os/kernel/src/chmtx.c b/os/kernel/src/chmtx.c
index 5f7bdfb8d..0eb02e2b5 100644
--- a/os/kernel/src/chmtx.c
+++ b/os/kernel/src/chmtx.c
@@ -98,7 +98,7 @@
  */
 void chMtxObjectInit(mutex_t *mp) {
 
-  chDbgCheck(mp != NULL, "chMtxInit");
+  chDbgCheck(mp != NULL);
 
   queue_init(&mp->m_queue);
   mp->m_owner = NULL;
@@ -135,7 +135,7 @@ void chMtxLockS(mutex_t *mp) {
   thread_t *ctp = currp;
 
   chDbgCheckClassS();
-  chDbgCheck(mp != NULL, "chMtxLockS");
+  chDbgCheck(mp != NULL);
 
   /* Is the mutex already locked? */
   if (mp->m_owner != NULL) {
@@ -194,8 +194,8 @@ void chMtxLockS(mutex_t *mp) {
 
     /* It is assumed that the thread performing the unlock operation assigns
        the mutex to this thread.*/
-    chDbgAssert(mp->m_owner == ctp, "chMtxLockS(), #1", "not owner");
-    chDbgAssert(ctp->p_mtxlist == mp, "chMtxLockS(), #2", "not owned");
+    chDbgAssert(mp->m_owner == ctp, "not owner");
+    chDbgAssert(ctp->p_mtxlist == mp, "not owned");
   }
   else {
     /* It was not owned, inserted in the owned mutexes list.*/
@@ -253,7 +253,7 @@ bool chMtxTryLock(mutex_t *mp) {
 bool chMtxTryLockS(mutex_t *mp) {
 
   chDbgCheckClassS();
-  chDbgCheck(mp != NULL, "chMtxTryLockS");
+  chDbgCheck(mp != NULL);
 
   if (mp->m_owner != NULL)
     return false;
@@ -280,12 +280,8 @@ mutex_t *chMtxUnlock(void) {
 
   chSysLock();
 
-  chDbgAssert(ctp->p_mtxlist != NULL,
-              "chMtxUnlock(), #1",
-              "owned mutexes list empty");
-  chDbgAssert(ctp->p_mtxlist->m_owner == ctp,
-              "chMtxUnlock(), #2",
-              "ownership failure");
+  chDbgAssert(ctp->p_mtxlist != NULL, "owned mutexes list empty");
+  chDbgAssert(ctp->p_mtxlist->m_owner == ctp, "ownership failure");
 
   /* Removes the top mutex from the thread's owned mutexes list and marks it
      as not owned.*/
@@ -344,12 +340,8 @@ mutex_t *chMtxUnlockS(void) {
   mutex_t *ump, *mp;
 
   chDbgCheckClassS();
-  chDbgAssert(ctp->p_mtxlist != NULL,
-              "chMtxUnlockS(), #1",
-              "owned mutexes list empty");
-  chDbgAssert(ctp->p_mtxlist->m_owner == ctp,
-              "chMtxUnlockS(), #2",
-              "ownership failure");
+  chDbgAssert(ctp->p_mtxlist != NULL, "owned mutexes list empty");
+  chDbgAssert(ctp->p_mtxlist->m_owner == ctp, "ownership failure");
 
   /* Removes the top mutex from the owned mutexes list and marks it as not
      owned.*/
diff --git a/os/kernel/src/chqueues.c b/os/kernel/src/chqueues.c
index 7cbc63f50..679d69337 100644
--- a/os/kernel/src/chqueues.c
+++ b/os/kernel/src/chqueues.c
@@ -245,7 +245,7 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
   qnotify_t nfy = iqp->q_notify;
   size_t r = 0;
 
-  chDbgCheck(n > 0, "chIQReadTimeout");
+  chDbgCheck(n > 0);
 
   chSysLock();
   while (true) {
@@ -425,7 +425,7 @@ size_t chOQWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
   qnotify_t nfy = oqp->q_notify;
   size_t w = 0;
 
-  chDbgCheck(n > 0, "chOQWriteTimeout");
+  chDbgCheck(n > 0);
 
   chSysLock();
   while (true) {
diff --git a/os/kernel/src/chregistry.c b/os/kernel/src/chregistry.c
index b0d241fee..685d0c109 100644
--- a/os/kernel/src/chregistry.c
+++ b/os/kernel/src/chregistry.c
@@ -159,8 +159,7 @@ thread_t *chRegNextThread(thread_t *tp) {
     ntp = NULL;
 #if CH_CFG_USE_DYNAMIC
   else {
-    chDbgAssert(ntp->p_refs < 255, "chRegNextThread(), #1",
-                "too many references");
+    chDbgAssert(ntp->p_refs < 255, "too many references");
     ntp->p_refs++;
   }
 #endif
diff --git a/os/kernel/src/chschd.c b/os/kernel/src/chschd.c
index 53a14dac7..615008589 100644
--- a/os/kernel/src/chschd.c
+++ b/os/kernel/src/chschd.c
@@ -91,7 +91,6 @@ thread_t *chSchReadyI(thread_t *tp) {
   /* Integrity checks.*/
   chDbgAssert((tp->p_state != CH_STATE_READY) &&
               (tp->p_state != CH_STATE_FINAL),
-              "chSchReadyI(), #1",
               "invalid state");
 
   tp->p_state = CH_STATE_READY;
diff --git a/os/kernel/src/chsem.c b/os/kernel/src/chsem.c
index d25b93822..388e50bc6 100644
--- a/os/kernel/src/chsem.c
+++ b/os/kernel/src/chsem.c
@@ -98,7 +98,7 @@
  */
 void chSemObjectInit(semaphore_t *sp, cnt_t n) {
 
-  chDbgCheck((sp != NULL) && (n >= 0), "chSemInit");
+  chDbgCheck((sp != NULL) && (n >= 0));
 
   queue_init(&sp->s_queue);
   sp->s_cnt = n;
@@ -150,10 +150,9 @@ void chSemResetI(semaphore_t *sp, cnt_t n) {
   cnt_t cnt;
 
   chDbgCheckClassI();
-  chDbgCheck((sp != NULL) && (n >= 0), "chSemResetI");
+  chDbgCheck((sp != NULL) && (n >= 0));
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemResetI(), #1",
               "inconsistent semaphore");
 
   cnt = sp->s_cnt;
@@ -198,10 +197,9 @@ msg_t chSemWait(semaphore_t *sp) {
 msg_t chSemWaitS(semaphore_t *sp) {
 
   chDbgCheckClassS();
-  chDbgCheck(sp != NULL, "chSemWaitS");
+  chDbgCheck(sp != NULL);
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemWaitS(), #1",
               "inconsistent semaphore");
 
   if (--sp->s_cnt < 0) {
@@ -263,10 +261,9 @@ msg_t chSemWaitTimeout(semaphore_t *sp, systime_t time) {
 msg_t chSemWaitTimeoutS(semaphore_t *sp, systime_t time) {
 
   chDbgCheckClassS();
-  chDbgCheck(sp != NULL, "chSemWaitTimeoutS");
+  chDbgCheck(sp != NULL);
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemWaitTimeoutS(), #1",
               "inconsistent semaphore");
 
   if (--sp->s_cnt < 0) {
@@ -290,10 +287,9 @@ msg_t chSemWaitTimeoutS(semaphore_t *sp, systime_t time) {
  */
 void chSemSignal(semaphore_t *sp) {
 
-  chDbgCheck(sp != NULL, "chSemSignal");
+  chDbgCheck(sp != NULL);
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemSignal(), #1",
               "inconsistent semaphore");
 
   chSysLock();
@@ -316,10 +312,9 @@ void chSemSignal(semaphore_t *sp) {
 void chSemSignalI(semaphore_t *sp) {
 
   chDbgCheckClassI();
-  chDbgCheck(sp != NULL, "chSemSignalI");
+  chDbgCheck(sp != NULL);
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemSignalI(), #1",
               "inconsistent semaphore");
 
   if (++sp->s_cnt <= 0) {
@@ -347,10 +342,9 @@ void chSemSignalI(semaphore_t *sp) {
 void chSemAddCounterI(semaphore_t *sp, cnt_t n) {
 
   chDbgCheckClassI();
-  chDbgCheck((sp != NULL) && (n > 0), "chSemAddCounterI");
+  chDbgCheck((sp != NULL) && (n > 0));
   chDbgAssert(((sp->s_cnt >= 0) && queue_isempty(&sp->s_queue)) ||
               ((sp->s_cnt < 0) && queue_notempty(&sp->s_queue)),
-              "chSemAddCounterI(), #1",
               "inconsistent semaphore");
 
   while (n > 0) {
@@ -376,14 +370,12 @@ void chSemAddCounterI(semaphore_t *sp, cnt_t n) {
 msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) {
   msg_t msg;
 
-  chDbgCheck((sps != NULL) && (spw != NULL), "chSemSignalWait");
+  chDbgCheck((sps != NULL) && (spw != NULL));
   chDbgAssert(((sps->s_cnt >= 0) && queue_isempty(&sps->s_queue)) ||
               ((sps->s_cnt < 0) && queue_notempty(&sps->s_queue)),
-              "chSemSignalWait(), #1",
               "inconsistent semaphore");
   chDbgAssert(((spw->s_cnt >= 0) && queue_isempty(&spw->s_queue)) ||
               ((spw->s_cnt < 0) && queue_notempty(&spw->s_queue)),
-              "chSemSignalWait(), #2",
               "inconsistent semaphore");
 
   chSysLock();
diff --git a/os/kernel/src/chthreads.c b/os/kernel/src/chthreads.c
index a18e82005..073b6eed7 100644
--- a/os/kernel/src/chthreads.c
+++ b/os/kernel/src/chthreads.c
@@ -183,8 +183,7 @@ thread_t *chThdCreateI(void *wsp, size_t size,
   chDbgCheckClassI();
 
   chDbgCheck((wsp != NULL) && (size >= THD_WA_SIZE(0)) &&
-             (prio <= HIGHPRIO) && (pf != NULL),
-             "chThdCreateI");
+             (prio <= HIGHPRIO) && (pf != NULL));
   SETUP_CONTEXT(wsp, size, pf, arg);
   return _thread_init(tp, prio);
 }
@@ -238,7 +237,7 @@ thread_t *chThdCreateStatic(void *wsp, size_t size,
 tprio_t chThdSetPriority(tprio_t newprio) {
   tprio_t oldprio;
 
-  chDbgCheck(newprio <= HIGHPRIO, "chThdSetPriority");
+  chDbgCheck(newprio <= HIGHPRIO);
 
   chSysLock();
 #if CH_CFG_USE_MUTEXES
@@ -272,7 +271,6 @@ thread_t *chThdResume(thread_t *tp) {
 
   chSysLock();
   chDbgAssert(tp->p_state == CH_STATE_SUSPENDED,
-              "chThdResume(), #1",
               "thread not in CH_STATE_SUSPENDED state");
   chSchWakeupS(tp, RDY_OK);
   chSysUnlock();
@@ -312,7 +310,7 @@ void chThdTerminate(thread_t *tp) {
  */
 void chThdSleep(systime_t time) {
 
-  chDbgCheck(time != TIME_IMMEDIATE, "chThdSleep");
+  chDbgCheck(time != TIME_IMMEDIATE);
 
   chSysLock();
   chThdSleepS(time);
@@ -403,7 +401,7 @@ void chThdExitS(msg_t msg) {
 #endif
   chSchGoSleepS(CH_STATE_FINAL);
   /* The thread never returns here.*/
-  chDbgAssert(false, "chThdExitS(), #1", "zombies apocalypse");
+  chDbgAssert(false, "zombies apocalypse");
 }
 
 #if CH_CFG_USE_WAITEXIT || defined(__DOXYGEN__)
@@ -441,12 +439,12 @@ void chThdExitS(msg_t msg) {
 msg_t chThdWait(thread_t *tp) {
   msg_t msg;
 
-  chDbgCheck(tp != NULL, "chThdWait");
+  chDbgCheck(tp != NULL);
 
   chSysLock();
-  chDbgAssert(tp != currp, "chThdWait(), #1", "waiting self");
+  chDbgAssert(tp != currp, "waiting self");
 #if CH_CFG_USE_DYNAMIC
-  chDbgAssert(tp->p_refs > 0, "chThdWait(), #2", "not referenced");
+  chDbgAssert(tp->p_refs > 0, "not referenced");
 #endif
   if (tp->p_state != CH_STATE_FINAL) {
     list_insert(currp, &tp->p_waiting);
diff --git a/os/kernel/src/chvt.c b/os/kernel/src/chvt.c
index 6fa4dd582..3f1559ac4 100644
--- a/os/kernel/src/chvt.c
+++ b/os/kernel/src/chvt.c
@@ -118,8 +118,7 @@ void chVTDoSetI(virtual_timer_t *vtp, systime_t delay,
   virtual_timer_t *p;
 
   chDbgCheckClassI();
-  chDbgCheck((vtp != NULL) && (vtfunc != NULL) && (delay != TIME_IMMEDIATE),
-             "chVTDoSetI");
+  chDbgCheck((vtp != NULL) && (vtfunc != NULL) && (delay != TIME_IMMEDIATE));
 
   vtp->vt_par = par;
   vtp->vt_func = vtfunc;
@@ -181,10 +180,8 @@ void chVTDoSetI(virtual_timer_t *vtp, systime_t delay,
 void chVTDoResetI(virtual_timer_t *vtp) {
 
   chDbgCheckClassI();
-  chDbgCheck(vtp != NULL, "chVTDoResetI");
-  chDbgAssert(vtp->vt_func != NULL,
-              "chVTDoResetI(), #1",
-              "timer not set or already triggered");
+  chDbgCheck(vtp != NULL);
+  chDbgAssert(vtp->vt_func != NULL, "timer not set or already triggered");
 
   /* Removing the element from the delta list.*/
   vtp->vt_next->vt_delta += vtp->vt_delta;
-- 
cgit v1.2.3