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

26 files changed, 274 insertions, 274 deletions

diff --git a/src/chcond.c b/src/chcond.c
index 229de3222..7d90c3ffb 100644
--- a/src/chcond.c
+++ b/src/chcond.c
@@ -31,8 +31,8 @@
 #if defined(CH_USE_CONDVARS) && defined(CH_USE_MUTEXES)

 

 /**

- * Initializes s \p CondVar structure.

- * @param cp pointer to a \p CondVar structure

+ * Initializes s @p CondVar structure.

+ * @param cp pointer to a @p CondVar structure

  */

 void chCondInit(CondVar *cp) {

 

@@ -42,7 +42,7 @@ void chCondInit(CondVar *cp) {
 /**

  * Signals one thread that is waiting on the condition variable.

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  */

 void chCondSignal(CondVar *cp) {

 

@@ -57,8 +57,8 @@ void chCondSignal(CondVar *cp) {
 /**

  * Signals one thread that is waiting on the condition variable.

  *

- * @param cp pointer to the \p CondVar structure

- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()

+ * @param cp pointer to the @p CondVar structure

+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()

  *       block.

  */

 void chCondSignalI(CondVar *cp) {

@@ -70,7 +70,7 @@ void chCondSignalI(CondVar *cp) {
 /**

  * Signals all threads that are waiting on the condition variable.

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  */

 void chCondBroadcast(CondVar *cp) {

 

@@ -85,13 +85,13 @@ void chCondBroadcast(CondVar *cp) {
 /**

  * Signals all threads that are waiting on the condition variable.

  *

- * @param cp pointer to the \p CondVar structure

- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()

+ * @param cp pointer to the @p CondVar structure

+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()

  */

 void chCondBroadcastI(CondVar *cp) {

 

   /* 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

+   * ready list in FIFO order. The wakeup message is set to @p RDY_RESET in

    * order to make a chCondBroadcast() detectable from a chCondSignal(). */

   while (cp->c_queue.p_next != (void *)&cp->c_queue)

     chSchReadyI(fifo_remove(&cp->c_queue))->p_rdymsg = RDY_RESET;

@@ -105,7 +105,7 @@ void chCondBroadcastI(CondVar *cp) {
  *

  * The thread MUST already have locked the mutex when calling chCondWait().

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  * @return The wakep mode.

  * @retval RDY_OK if the condvar was signaled using chCondSignal().

  * @retval RDY_RESET if the condvar was signaled using chCondBroadcast().

@@ -129,11 +129,11 @@ msg_t chCondWait(CondVar *cp) {
  *

  * The thread MUST already have locked the mutex when calling chCondWait().

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  * @return The wakep mode.

  * @retval RDY_OK if the condvar was signaled using chCondSignal().

  * @retval RDY_RESET if the condvar was signaled using chCondBroadcast().

- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()

+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()

  */

 msg_t chCondWaitS(CondVar *cp) {

   Mutex *mp;

@@ -159,7 +159,7 @@ msg_t chCondWaitS(CondVar *cp) {
  *

  * The thread MUST already have locked the mutex when calling chCondWait().

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  * @param time the number of ticks before the operation fails

  * @return The wakep mode.

  * @retval RDY_OK if the condvar was signaled using chCondSignal().

@@ -186,14 +186,14 @@ msg_t chCondWaitTimeout(CondVar *cp, systime_t time) {
  *

  * The thread MUST already have locked the mutex when calling chCondWait().

  *

- * @param cp pointer to the \p CondVar structure

+ * @param cp pointer to the @p CondVar structure

  * @param time the number of ticks before the operation fails

  * @return The wakep mode.

  * @retval RDY_OK if the condvar was signaled using chCondSignal().

  * @retval RDY_RESET if the condvar was signaled using chCondBroadcast().

  * @retval RDY_TIMEOUT if the condvar was not signaled within the specified

  *         timeout.

- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()

+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()

  */

 msg_t chCondWaitTimeoutS(CondVar *cp, systime_t time) {

   Mutex *mp;

diff --git a/src/chevents.c b/src/chevents.c
index af42a36b3..cddc2215a 100644
--- a/src/chevents.c
+++ b/src/chevents.c
@@ -26,8 +26,8 @@
 #ifdef CH_USE_EVENTS

 /**

  * Registers an Event Listener on an Event Source.

- * @param esp pointer to the  \p EventSource structure

- * @param elp pointer to the \p EventListener structure

+ * @param esp pointer to the  @p EventSource structure

+ * @param elp pointer to the @p EventListener structure

  * @param emask the mask of event flags to be pended to the thread when the

  *              event source is broadcasted

  * @note Multiple Event Listeners can specify the same bits to be pended.

@@ -46,8 +46,8 @@ void chEvtRegisterMask(EventSource *esp, EventListener *elp, eventmask_t emask)
 

 /**

  * Unregisters an Event Listener from its Event Source.

- * @param esp pointer to the  \p EventSource structure

- * @param elp pointer to the \p EventListener structure

+ * @param esp pointer to the  @p EventSource structure

+ * @param elp pointer to the @p EventListener structure

  * @note If the event listener is not registered on the specified event source

  *       then the function does nothing.

  * @note For optimal performance it is better to perform the unregister

@@ -89,7 +89,7 @@ eventmask_t chEvtClear(eventmask_t mask) {
 

 /**

  * Makes an events mask pending in the current thread, this is \b much faster than

- * using \p chEvtBroadcast().

+ * using @p chEvtBroadcast().

  * @param mask the events to be pended

  * @return The current pending events mask.

  */

@@ -105,7 +105,7 @@ eventmask_t chEvtPend(eventmask_t mask) {
 

 /**

  * Signals all the Event Listeners registered on the specified Event Source.

- * @param esp pointer to the \p EventSource structure

+ * @param esp pointer to the @p EventSource structure

  */

 void chEvtBroadcast(EventSource *esp) {

 

@@ -119,7 +119,7 @@ void chEvtBroadcast(EventSource *esp) {
 

 /**

  * Signals all the Event Listeners registered on the specified Event Source.

- * @param esp pointer to the \p EventSource structure

+ * @param esp pointer to the @p EventSource structure

  * @note This function does not reschedule.

  */

 void chEvtBroadcastI(EventSource *esp) {

@@ -143,7 +143,7 @@ void chEvtBroadcastI(EventSource *esp) {
 /**

  * Invokes the event handlers associated with a mask.

  * @param mask mask of the events to be dispatched

- * @param handlers an array of \p evhandler_t. The array must be

+ * @param handlers an array of @p evhandler_t. The array must be

  *                 have indexes from zero up the higher registered event

  *                 identifier.

  */

@@ -163,10 +163,10 @@ void chEvtDispatch(const evhandler_t handlers[], eventmask_t mask) {
 #if defined(CH_OPTIMIZE_SPEED) || !defined(CH_USE_EVENTS_TIMEOUT) || \

     defined(__DOXIGEN__)

 /**

- * A pending event among those specified in \p ewmask is selected, cleared and

+ * A pending event among those specified in @p ewmask is selected, cleared and

  * its mask returned.

  * @param ewmask mask of the events that the function should wait for,

- *               \p ALL_EVENTS enables all the events

+ *               @p ALL_EVENTS enables all the events

  * @return The mask of the lowest id served and cleared event.

  * @note One and only one event is served in the function, the one with the

  *       lowest event id. The function is meant to be invoked into a loop in

@@ -193,10 +193,10 @@ eventmask_t chEvtWaitOne(eventmask_t ewmask) {
 

 /**

  * Waits for any of the specified events.

- * The function waits for any event among those specified in \p ewmask to

+ * The function waits for any event among those specified in @p ewmask to

  * become pending then the events are cleared and returned.

  * @param ewmask mask of the events that the function should wait for,

- *               \p ALL_EVENTS enables all the events

+ *               @p ALL_EVENTS enables all the events

  * @return The mask of the served and cleared events.

  */

 eventmask_t chEvtWaitAny(eventmask_t ewmask) {

@@ -217,7 +217,7 @@ eventmask_t chEvtWaitAny(eventmask_t ewmask) {
 

 /**

  * Waits for all the specified event flags then clears them.

- * The function waits for all the events specified in \p ewmask to become

+ * The function waits for all the events specified in @p ewmask to become

  * pending then the events are cleared and returned.

  * @param ewmask mask of the event ids that the function should wait for

  * @return The mask of the served and cleared events.

@@ -240,10 +240,10 @@ eventmask_t chEvtWaitAll(eventmask_t ewmask) {
 #ifdef CH_USE_EVENTS_TIMEOUT

 /**

  * Waits for a single event.

- * A pending event among those specified in \p ewmask is selected, cleared and

+ * A pending event among those specified in @p ewmask is selected, cleared and

  * its mask returned.

  * @param ewmask mask of the events that the function should wait for,

- *               \p ALL_EVENTS enables all the events

+ *               @p ALL_EVENTS enables all the events

  * @param time the number of ticks before the operation timouts

  * @return The mask of the lowest id served and cleared event.

  * @retval 0 if the specified timeout expired.

@@ -273,10 +273,10 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t ewmask, systime_t time) {
 

 /**

  * Waits for any of the specified events.

- * The function waits for any event among those specified in \p ewmask to

+ * The function waits for any event among those specified in @p ewmask to

  * become pending then the events are cleared and returned.

  * @param ewmask mask of the events that the function should wait for,

- *               \p ALL_EVENTS enables all the events

+ *               @p ALL_EVENTS enables all the events

  * @param time the number of ticks before the operation timouts

  * @return The mask of the served and cleared events.

  * @retval 0 if the specified timeout expired.

@@ -300,7 +300,7 @@ eventmask_t chEvtWaitAnyTimeout(eventmask_t ewmask, systime_t time) {
 

 /**

  * Waits for all the specified event flags then clears them.

- * The function waits for all the events specified in \p ewmask to become

+ * The function waits for all the events specified in @p ewmask to become

  * pending then the events are cleared and returned.

  * @param ewmask mask of the event ids that the function should wait for

  * @param time the number of ticks before the operation timouts

diff --git a/src/chheap.c b/src/chheap.c
index 08ead3411..98bff9c43 100644
--- a/src/chheap.c
+++ b/src/chheap.c
@@ -190,7 +190,7 @@ void chHeapFree(void *p) {
  * @return The number of fragments in the heap.

  * @note This function is meant to be used in the test suite, it should not be

  *       really useful for the application code.

- * @note This function is not implemented when the \p CH_USE_MALLOC_HEAP

+ * @note This function is not implemented when the @p CH_USE_MALLOC_HEAP

  *       configuration option is used (it always returns zero).

  */

 size_t chHeapStatus(size_t *sizep) {

diff --git a/src/chmempools.c b/src/chmempools.c
index dad37aeb4..fac9db851 100644
--- a/src/chmempools.c
+++ b/src/chmempools.c
@@ -28,7 +28,7 @@
 

 /**

  * Initializes an empty memory pool.

- * @param mp pointer to a \p MemoryPool structure

+ * @param mp pointer to a @p MemoryPool structure

  * @param size the size of the objects contained in this memory pool

  */

 void chPoolInit(MemoryPool *mp, size_t size) {

@@ -42,7 +42,7 @@ void chPoolInit(MemoryPool *mp, size_t size) {
 

 /**

  * Allocates an object from a memory pool.

- * @param mp pointer to a \p MemoryPool structure

+ * @param mp pointer to a @p MemoryPool structure

  * @return The pointer to the allocated object.

  * @retval NULL if pool is empty.

  */

@@ -59,7 +59,7 @@ void *chPoolAllocI(MemoryPool *mp) {
 

 /**

  * Allocates an object from a memory pool.

- * @param mp pointer to a \p MemoryPool structure

+ * @param mp pointer to a @p MemoryPool structure

  * @return The pointer to the allocated object.

  * @retval NULL if pool is empty.

  */

@@ -74,7 +74,7 @@ void *chPoolAlloc(MemoryPool *mp) {
 

 /**

  * Releases (or adds) an object into (to) a memory pool.

- * @param mp pointer to a \p MemoryPool structure

+ * @param mp pointer to a @p MemoryPool structure

  * @param objp the pointer to the object to be released or added

  * @note the object is assumed to be of the right size for the specified

  *       memory pool.

@@ -91,7 +91,7 @@ void chPoolFreeI(MemoryPool *mp, void *objp) {
 

 /**

  * Releases (or adds) an object into (to) a memory pool.

- * @param mp pointer to a \p MemoryPool structure

+ * @param mp pointer to a @p MemoryPool structure

  * @param objp the pointer to the object to be released or added

  * @note the object is assumed to be of the right size for the specified

  *       memory pool.

diff --git a/src/chmsg.c b/src/chmsg.c
index d960f44e8..f53e84030 100644
--- a/src/chmsg.c
+++ b/src/chmsg.c
@@ -26,11 +26,11 @@
 #ifdef CH_USE_MESSAGES

 /**

  * Sends a message to the specified thread. The client is stopped until the

- * server executes a \p chMsgRelease() after receiving the message.

+ * server executes a @p chMsgRelease() after receiving the message.

  *

  * @param tp the pointer to the thread

  * @param msg the message, it can be a pointer to a complex structure

- * @return The return message from \p chMsgRelease().

+ * @return The return message from @p chMsgRelease().

  */

 msg_t chMsgSend(Thread *tp, msg_t msg) {

 

@@ -55,16 +55,16 @@ msg_t chMsgSend(Thread *tp, msg_t msg) {
 #ifdef CH_USE_MESSAGES_EVENT

 /**

  * Sends a message to the specified thread and atomically triggers an event.

- * The client is stopped until the server executes a \p chMsgRelease()

+ * The client is stopped until the server executes a @p chMsgRelease()

  * after receiving the message.

  *

  * @param tp the pointer to the thread

  * @param msg the message, it can be a pointer to a complex structure

  * @param esp the event source to pulse while sending the message

- * @return The return message from \p chMsgRelease().

+ * @return The return message from @p chMsgRelease().

  * @note This function assumes that the receiving thread is not sleeping into

- *       a \p chMsgWait(). The use case is that the server thread is waiting

- *       for both messages AND events while waiting into \p chEvtWaitXXX().

+ *       a @p chMsgWait(). The use case is that the server thread is waiting

+ *       for both messages AND events while waiting into @p chEvtWaitXXX().

  */

 msg_t chMsgSendWithEvent(Thread *tp, msg_t msg, EventSource *esp) {

 

@@ -93,7 +93,7 @@ msg_t chMsgSendWithEvent(Thread *tp, msg_t msg, EventSource *esp) {
  * @return The pointer to the message structure. Note, it is always the

  *         message associated to the thread on the top of the messages queue.

  * @note You can assume that the data contained in the message is stable until

- *       you invoke \p chMsgRelease() because the sending thread is

+ *       you invoke @p chMsgRelease() because the sending thread is

  *       suspended until then.

  */

 msg_t chMsgWait(void) {

@@ -114,9 +114,9 @@ msg_t chMsgWait(void) {
  *

  * @return The pointer to the message structure. Note, it is always the

  *         message associated to the thread on the top of the messages queue.

- *         If the queue is empty then \p NULL is returned.

+ *         If the queue is empty then @p NULL is returned.

  * @note You can assume that the data pointed by the message is stable until

- *       you invoke \p chMsgRelease() because the sending thread is

+ *       you invoke @p chMsgRelease() because the sending thread is

  *       suspended until then. Always remember that the message data is not

  *       copied between the sender and the receiver, just a pointer is passed.

  */

@@ -137,7 +137,7 @@ msg_t chMsgGet(void) {
  * @param msg the message returned to the message sender

  * @note You can call this function only if there is a message already in the

  *       queue else the result will be unpredictable (a crash most likely).

- *       Exiting from the \p chMsgWait() ensures you have at least one

+ *       Exiting from the @p chMsgWait() ensures you have at least one

  *       message in the queue so it is not a big deal.<br>

  *       The condition is only tested in debug mode in order to make this code

  *       as fast as possible.

diff --git a/src/chmtx.c b/src/chmtx.c
index 25a490b98..8288cfe89 100644
--- a/src/chmtx.c
+++ b/src/chmtx.c
@@ -27,8 +27,8 @@
 #ifdef CH_USE_MUTEXES
 
 /**
- * Initializes s \p Mutex structure.
- * @param mp pointer to a \p Mutex structure
+ * Initializes s @p Mutex structure.
+ * @param mp pointer to a @p Mutex structure
  */
 void chMtxInit(Mutex *mp) {
 
@@ -38,7 +38,7 @@ void chMtxInit(Mutex *mp) {
 
 /**
  * Locks the specified mutex.
- * @param mp pointer to the \p Mutex structure
+ * @param mp pointer to the @p Mutex structure
  */
 void chMtxLock(Mutex *mp) {
 
@@ -52,8 +52,8 @@ void chMtxLock(Mutex *mp) {
 /**
  * Locks the specified mutex.
  *
- * @param mp pointer to the \p Mutex structure
- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()
+ * @param mp pointer to the @p Mutex structure
+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()
  *       block.
  */
 void chMtxLockS(Mutex *mp) {
@@ -113,7 +113,7 @@ void chMtxLockS(Mutex *mp) {
  * Tries to lock a mutex. This function does not have any overhead related to
  * the priority inheritance mechanism because it does not try to enter a sleep
  * state on the mutex.
- * @param mp pointer to the \p Mutex structure
+ * @param mp pointer to the @p Mutex structure
  * @retval TRUE if the mutex was successfully acquired
  * @retval FALSE if the lock attempt failed.
  */
@@ -132,10 +132,10 @@ bool_t chMtxTryLock(Mutex *mp) {
  * Tries to lock a mutex. This function does not have any overhead related to
  * the priority inheritance mechanism because it does not try to enter a sleep
  * state on the mutex.
- * @param mp pointer to the \p Mutex structure
+ * @param mp pointer to the @p Mutex structure
  * @retval TRUE if the mutex was successfully acquired
  * @retval FALSE if the lock attempt failed.
- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()
+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()
  *       block.
  */
 bool_t chMtxTryLockS(Mutex *mp) {
@@ -196,7 +196,7 @@ Mutex *chMtxUnlock(void) {
 /**
  * Unlocks the next owned mutex in reverse lock order.
  * @return The pointer to the unlocked mutex.
- * @note This function must be called within a \p chSysLock() / \p chSysUnlock()
+ * @note This function must be called within a @p chSysLock() / @p chSysUnlock()
  *       block.
  * @note This function does not reschedule internally.
  */
diff --git a/src/chqueues.c b/src/chqueues.c
index 30e71a055..f7cc10f42 100644
--- a/src/chqueues.c
+++ b/src/chqueues.c
@@ -29,11 +29,11 @@
 /**

  * Initializes an input queue. A Semaphore is internally initialized

  * and works as a counter of the bytes contained in the queue.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param buffer pointer to a memory area allocated as queue buffer

  * @param size size of the queue buffer

  * @param inotify pointer to a callback function that is invoked when

- *        some data is read from the Queue. The value can be \p NULL.

+ *        some data is read from the Queue. The value can be @p NULL.

  */

 void chIQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t inotify) {

 

@@ -46,7 +46,7 @@ void chIQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t inotify) {
 /**

  * Resets an input queue. All the data is lost and the waiting threads

  * resumed.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  */

 void chIQReset(Queue *qp) {

 

@@ -60,7 +60,7 @@ void chIQReset(Queue *qp) {
 

 /**

  * Inserts a byte into an input queue.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param b the byte value to be written

  * @retval Q_OK if the operation is successful.

  * @retval Q_FULL if the queue is full.

@@ -83,7 +83,7 @@ msg_t chIQPutI(Queue *qp, uint8_t b) {
 /**

  * Gets a byte from the input queue, if the queue is empty then the

  * calling thread is suspended until a byte arrives in the queue.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @return A byte value from the queue.

  * @retval Q_RESET if the queue was reset.

  */

@@ -113,13 +113,13 @@ msg_t chIQGet(Queue *qp) {
  * Gets a byte from the input queue, if the queue is empty then the

  * calling thread is suspended until a byte arrives in the queue or the

  * specified time expires.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param time the number of ticks before the operation timouts

  * @return A byte value from the queue.

  * @retval Q_TIMEOUT if the specified time expired.

  * @retval Q_RESET if the queue was reset.

- * @note The function is available only if the \p CH_USE_QUEUES_TIMEOUT and

- *       \p CH_USE_SEMAPHORES_TIMEOUT options are enabled in \p chconf.h.

+ * @note The function is available only if the @p CH_USE_QUEUES_TIMEOUT and

+ *       @p CH_USE_SEMAPHORES_TIMEOUT options are enabled in @p chconf.h.

  */

 msg_t chIQGetTimeout(Queue *qp, systime_t time) {

   uint8_t b;

@@ -147,7 +147,7 @@ msg_t chIQGetTimeout(Queue *qp, systime_t time) {
 /**

  * Reads some data from the input queue into the specified buffer. The function

  * is non-blocking and can return zero if the queue is empty.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param buffer the data buffer

  * @param n the maximum amount of data to be read

  * @return The number of bytes read.

@@ -189,11 +189,11 @@ size_t chIQRead(Queue *qp, uint8_t *buffer, size_t n) {
 /**

  * Initializes an output queue. A Semaphore is internally initialized

  * and works as a counter of the free bytes in the queue.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param buffer pointer to a memory area allocated as queue buffer

  * @param size size of the queue buffer

  * @param onotify pointer to a callback function that is invoked when

- *        some data is written in the Queue. The value can be \p NULL.

+ *        some data is written in the Queue. The value can be @p NULL.

  */

 void chOQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t onotify) {

 

@@ -206,7 +206,7 @@ void chOQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t onotify) {
 /**

  * Resets an Output Queue. All the data is lost and the waiting threads

  * resumed.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  */

 void chOQReset(Queue *qp) {

 

@@ -221,7 +221,7 @@ void chOQReset(Queue *qp) {
 /**

  * Inserts a byte in the output queue, if the queue is full then the thread

  * is suspended until the queue has free space available.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param b the byte value to be written

  */

 void chOQPut(Queue *qp, uint8_t b) {

@@ -241,7 +241,7 @@ void chOQPut(Queue *qp, uint8_t b) {
 

 /**

  * Gets a byte from an output queue.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @return The byte value from the queue.

  * @retval Q_EMPTY if the queue is empty.

  * @note This function is the lower side endpoint of the output queue.

@@ -264,7 +264,7 @@ msg_t chOQGetI(Queue *qp) {
 /**

  * Writes some data from the specified buffer into the queue. The function

  * is non-blocking and can return zero if the queue is full.

- * @param qp pointer to a \p Queue structure

+ * @param qp pointer to a @p Queue structure

  * @param buffer the data buffer

  * @param n the maximum amount of data to be written

  * @return The number of written bytes.

@@ -307,13 +307,13 @@ size_t chOQWrite(Queue *qp, uint8_t *buffer, size_t n) {
 #ifdef CH_USE_QUEUES_HALFDUPLEX

  /**

  * Initializes an half duplex queue.

- * @param qp pointer to the \p HalfDuplexQueue structure

+ * @param qp pointer to the @p HalfDuplexQueue structure

  * @param buffer pointer to a memory area allocated as buffer for the queue

  * @param size the size of the queue buffer

  * @param inotify pointer to a callback function that is invoked when

- *        some data is read from the queue. The value can be \p NULL.

+ *        some data is read from the queue. The value can be @p NULL.

  * @param onotify pointer to a callback function that is invoked when

- *        some data is written to the queue. The value can be \p NULL.

+ *        some data is written to the queue. The value can be @p NULL.

  */

 void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, size_t size,

                qnotify_t inotify, qnotify_t onotify) {

@@ -329,7 +329,7 @@ void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, size_t size,
 /**

  * Reads a byte from the receive queue, if the queue is empty or is in

  * transmission mode then the invoking thread is suspended.

- * @param qp pointer to a \p HalfDuplexQueue structure

+ * @param qp pointer to a @p HalfDuplexQueue structure

  * @return The byte value.

  * @retval Q_RESET if the queue was reset.

  */

@@ -362,12 +362,12 @@ msg_t chHDQGetReceive(HalfDuplexQueue *qp) {
 /**

  * Reads a byte from the receive queue, if the queue is empty or is in

  * transmission mode then the invoking thread is suspended.

- * @param qp pointer to a \p HalfDuplexQueue structure

+ * @param qp pointer to a @p HalfDuplexQueue structure

  * @param time the number of ticks before the operation timouts

  * @return The byte value.

  * @retval Q_TIMEOUT if a timeout occurs.

- * @note The function is available only if the \p CH_USE_QUEUES_TIMEOUT and

- *       \p CH_USE_SEMAPHORES_TIMEOUT options are enabled in \p chconf.h.

+ * @note The function is available only if the @p CH_USE_QUEUES_TIMEOUT and

+ *       @p CH_USE_SEMAPHORES_TIMEOUT options are enabled in @p chconf.h.

  */

 msg_t chHDQGetReceiveTimeout(HalfDuplexQueue *qp, systime_t time) {

   uint8_t b;

@@ -400,7 +400,7 @@ msg_t chHDQGetReceiveTimeout(HalfDuplexQueue *qp, systime_t time) {
  * Writes a byte into the transmit queue. If the buffer contains unread

  * input data then the the buffer is cleared and the queue goes in

  * transmission mode.

- * @param qp pointer to a \p HalfDuplexQueue structure

+ * @param qp pointer to a @p HalfDuplexQueue structure

  * @param b the byte value to be written

  */

 void chHDQPutTransmit(HalfDuplexQueue *qp, uint8_t b) {

@@ -431,7 +431,7 @@ void chHDQPutTransmit(HalfDuplexQueue *qp, uint8_t b) {
 

 /**

  * Gets a byte from the transmit queue.

- * @param qp pointer to a \p HalfDuplexQueue structure

+ * @param qp pointer to a @p HalfDuplexQueue structure

  * @return The byte value.

  * @retval Q_EMPTY if the transmit queue is empty (not in transmission mode).

  * @note This function must be called with interrupts disabled or from an

@@ -453,7 +453,7 @@ msg_t chHDQGetTransmitI(HalfDuplexQueue *qp) {
 /**

  * Writes a byte into the receive queue. If the queue is in transmission mode

  * then the byte is lost.

- * @param qp pointer to a \p HalfDuplexQueue structure

+ * @param qp pointer to a @p HalfDuplexQueue structure

  * @param b the byte value to be written

  * @retval Q_OK if the operation is successful.

  * @retval Q_FULL if the driver is in transmit mode or the receive queue is full.

diff --git a/src/chschd.c b/src/chschd.c
index 1f8b2413d..91a9ea0b0 100644
--- a/src/chschd.c
+++ b/src/chschd.c
@@ -30,7 +30,7 @@ ReadyList rlist;
 
 /**
  * Scheduler initialization.
- * @note Internally invoked by the \p chSysInit().
+ * @note Internally invoked by the @p chSysInit().
  */
 void chSchInit(void) {
 
@@ -47,7 +47,7 @@ void chSchInit(void) {
  * @param tp the Thread to be made ready
  * @return The Thread pointer.
  * @note The function must be called in the system mutex zone.
- * @note The function does not reschedule, the \p chSchRescheduleS() should
+ * @note The function does not reschedule, the @p chSchRescheduleS() should
  *       be called soon after.
  * @note The function is not meant to be used in the user code directly.
  */
@@ -72,7 +72,7 @@ Thread *chSchReadyI(Thread *tp) {
 /**
  * Puts the current thread to sleep into the specified state, the next highest
  * priority thread becomes running. The threads states are described into
- * \p threads.h
+ * @p threads.h
  * @param newstate the new thread state
  * @note The function must be called in the system mutex zone.
  * @note The function is not meant to be used in the user code directly.
@@ -112,7 +112,7 @@ static void wakeup(void *p) {
  *
  * @param newstate the new thread state
  * @param time the number of ticks before the operation timeouts. the value
- *             zero (\p TIME_INFINITE) is allowed.
+ *             zero (@p TIME_INFINITE) is allowed.
  * @return The wakeup message.
  * @retval RDY_TIMEOUT if a timeout occurs.
  * @note The function must be called in the system mutex zone.
@@ -142,8 +142,8 @@ msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
  * @param msg message to the awakened thread
  * @note The function must be called in the system mutex zone.
  * @note The function is not meant to be used in the user code directly.
- * @note It is equivalent to a \p chSchReadyI() followed by a
- *       \p chSchRescheduleS() but much more efficient.
+ * @note It is equivalent to a @p chSchReadyI() followed by a
+ *       @p chSchRescheduleS() but much more efficient.
  */
 void chSchWakeupS(Thread *ntp, msg_t msg) {
   ntp->p_rdymsg = msg;
@@ -172,7 +172,7 @@ void chSchWakeupS(Thread *ntp, msg_t msg) {
 /**
  * Switch to the first thread on the runnable queue.
  *
- * @note It is intended to be called if \p chSchRescRequiredI() evaluates to \p TRUE.
+ * @note It is intended to be called if @p chSchRescRequiredI() evaluates to @p TRUE.
  */
 void chSchDoRescheduleI(void) {
 
diff --git a/src/chsem.c b/src/chsem.c
index d29e97268..094a30d4e 100644
--- a/src/chsem.c
+++ b/src/chsem.c
@@ -27,7 +27,7 @@
 #ifdef CH_USE_SEMAPHORES

 /**

  * Initializes a semaphore with the specified counter value.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @param n initial value of the semaphore counter. Must be non-negative.

  * @note Can be called with interrupts disabled or enabled.

  */

@@ -40,11 +40,11 @@ void chSemInit(Semaphore *sp, cnt_t n) {
 

 /**

  * Performs a reset operation on the semaphore.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @param n the new value of the semaphore counter. The value must be non-negative.

  * @note The released threads can recognize they were waked up by a reset

- *       instead than a signal because the \p chSemWait() will return

- *       \p RDY_RESET instead of \p RDY_OK.

+ *       instead than a signal because the @p chSemWait() will return

+ *       @p RDY_RESET instead of @p RDY_OK.

  */

 void chSemReset(Semaphore *sp, cnt_t n) {

 

@@ -58,11 +58,11 @@ void chSemReset(Semaphore *sp, cnt_t n) {
 

 /**

  * Performs a reset operation on the semaphore.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @param n the new value of the semaphore counter. The value must be non-negative.

  * @note The released threads can recognize they were waked up by a reset

- *       instead than a signal because the \p chSemWait() will return

- *       \p RDY_RESET instead of \p RDY_OK.

+ *       instead than a signal because the @p chSemWait() will return

+ *       @p RDY_RESET instead of @p RDY_OK.

  * @note This function does not reschedule.

  */

 void chSemResetI(Semaphore *sp, cnt_t n) {

@@ -77,9 +77,9 @@ void chSemResetI(Semaphore *sp, cnt_t n) {
 

 /**

  * Performs a wait operation on a semaphore.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @retval RDY_OK if the semaphore was signaled or not taken.

- * @retval RDY_RESET if the semaphore was reset using \p chSemReset().

+ * @retval RDY_RESET if the semaphore was reset using @p chSemReset().

  */

 msg_t chSemWait(Semaphore *sp) {

   msg_t msg;

@@ -94,9 +94,9 @@ msg_t chSemWait(Semaphore *sp) {
 

 /**

  * Performs a wait operation on a semaphore.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @retval RDY_OK if the semaphore was signaled or not taken.

- * @retval RDY_RESET if the semaphore was reset using \p chSemReset().

+ * @retval RDY_RESET if the semaphore was reset using @p chSemReset().

  * @note This function must be called with interrupts disabled.

  * @note This function cannot be called by an interrupt handler.

  */

@@ -114,14 +114,14 @@ msg_t chSemWaitS(Semaphore *sp) {
 #ifdef CH_USE_SEMAPHORES_TIMEOUT

 /**

  * Performs a wait operation on a semaphore with timeout specification.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @param time the number of ticks before the operation fails

  * @retval RDY_OK if the semaphore was signaled or not taken.

- * @retval RDY_RESET if the semaphore was reset using \p chSemReset().

+ * @retval RDY_RESET if the semaphore was reset using @p chSemReset().

  * @retval RDY_TIMEOUT if the semaphore was not signaled or reset within the

  *         specified timeout.

- * @note The function is available only if the \p CH_USE_SEMAPHORES_TIMEOUT

- *       option is enabled in \p chconf.h.

+ * @note The function is available only if the @p CH_USE_SEMAPHORES_TIMEOUT

+ *       option is enabled in @p chconf.h.

  */

 msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {

   msg_t msg;

@@ -136,14 +136,14 @@ msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {
 

 /**

  * Performs a wait operation on a semaphore with timeout specification.

- * @param sp pointer to a \p Semaphore structure

+ * @param sp pointer to a @p Semaphore structure

  * @param time the number of ticks before the operation fails

  * @retval RDY_OK if the semaphore was signaled or not taken.

- * @retval RDY_RESET if the semaphore was reset using \p chSemReset().

+ * @retval RDY_RESET if the semaphore was reset using @p chSemReset().

  * @retval RDY_TIMEOUT if the semaphore was not signaled or reset within the specified

  *         timeout.

- * @note The function is available only if the \p CH_USE_SEMAPHORES_TIMEOUT

- *       option is enabled in \p chconf.h.

+ * @note The function is available only if the @p CH_USE_SEMAPHORES_TIMEOUT

+ *       option is enabled in @p chconf.h.

  */

 msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {

 

@@ -158,9 +158,9 @@ msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
 

 /**

  * Performs a signal operation on a semaphore.

- * @param sp pointer to a \p Semaphore structure

- * @note The function is available only if the \p CH_USE_SEMAPHORES

- *       option is enabled in \p chconf.h.

+ * @param sp pointer to a @p Semaphore structure

+ * @note The function is available only if the @p CH_USE_SEMAPHORES

+ *       option is enabled in @p chconf.h.

  */

 void chSemSignal(Semaphore *sp) {

 

@@ -174,9 +174,9 @@ void chSemSignal(Semaphore *sp) {
 

 /**

  * Performs a signal operation on a semaphore.

- * @param sp pointer to a \p Semaphore structure

- * @note The function is available only if the \p CH_USE_SEMAPHORES

- *       option is enabled in \p chconf.h.

+ * @param sp pointer to a @p Semaphore structure

+ * @note The function is available only if the @p CH_USE_SEMAPHORES

+ *       option is enabled in @p chconf.h.

  * @note This function does not reschedule.

  */

 void chSemSignalI(Semaphore *sp) {

@@ -193,12 +193,12 @@ void chSemSignalI(Semaphore *sp) {
 #ifdef CH_USE_SEMSW

 /**

  * Performs atomic signal and wait operations on two semaphores.

- * @param sps pointer to a \p Semaphore structure to be signaled

- * @param spw pointer to a \p Semaphore structure to be wait on

+ * @param sps pointer to a @p Semaphore structure to be signaled

+ * @param spw pointer to a @p Semaphore structure to be wait on

  * @retval RDY_OK if the semaphore was signaled or not taken.

- * @retval RDY_RESET if the semaphore was reset using \p chSemReset().

- * @note The function is available only if the \p CH_USE_SEMSW

- *       option is enabled in \p chconf.h.

+ * @retval RDY_RESET if the semaphore was reset using @p chSemReset().

+ * @note The function is available only if the @p CH_USE_SEMSW

+ *       option is enabled in @p chconf.h.

  */

 msg_t chSemSignalWait(Semaphore *sps, Semaphore *spw) {

   msg_t msg;

diff --git a/src/chserial.c b/src/chserial.c
index 4ab65e140..c41bc2c4a 100644
--- a/src/chserial.c
+++ b/src/chserial.c
@@ -29,15 +29,15 @@
  * Initializes a generic full duplex driver. The HW dependent part of the

  * initialization has to be performed outside, usually in the hardware

  * initialization code.

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @param ib pointer to a memory area allocated for the Input Queue buffer

  * @param isize size of the Input Queue buffer

  * @param inotify pointer to a callback function that is invoked when

- *        some data is read from the Queue. The value can be \p NULL.

+ *        some data is read from the Queue. The value can be @p NULL.

  * @param ob pointer to a memory area allocated for the Output Queue buffer

  * @param osize size of the Output Queue buffer

  * @param onotify pointer to a callback function that is invoked when

- *        some data is written in the Queue. The value can be \p NULL.

+ *        some data is written in the Queue. The value can be @p NULL.

  */

 void chFDDInit(FullDuplexDriver *sd,

                uint8_t *ib, size_t isize, qnotify_t inotify,

@@ -54,7 +54,7 @@ void chFDDInit(FullDuplexDriver *sd,
 /**

  * This function must be called from the input interrupt service routine in

  * order to enqueue incoming data and generate the related events.

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @param b the byte to be written in the driver's Input Queue

  */

 void chFDDIncomingDataI(FullDuplexDriver *sd, uint8_t b) {

@@ -69,7 +69,7 @@ void chFDDIncomingDataI(FullDuplexDriver *sd, uint8_t b) {
  * Must be called from the output interrupt service routine in order to get

  * the next byte to be transmitted.

  *

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @return The byte value read from the driver's output queue.

  * @retval Q_EMPTY if the queue is empty (the lower driver usually disables

  *         the interrupt source when this happens).

@@ -85,7 +85,7 @@ msg_t chFDDRequestDataI(FullDuplexDriver *sd) {
 /**

  * Must be called from the I/O interrupt service routine in order to

  * notify I/O conditions as errors, signals change etc.

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @param mask condition flags to be added to the mask

  */

 void chFDDAddFlagsI(FullDuplexDriver *sd, dflags_t mask) {

@@ -96,7 +96,7 @@ void chFDDAddFlagsI(FullDuplexDriver *sd, dflags_t mask) {
 

 /**

  * This function returns and clears the errors mask associated to the driver.

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @return The condition flags modified since last time this function was

  *         invoked.

  */

@@ -114,13 +114,13 @@ dflags_t chFDDGetAndClearFlags(FullDuplexDriver *sd) {
  * Initializes a generic half duplex driver. The HW dependent part of the

  * initialization has to be performed outside, usually in the hardware

  * initialization code.

- * @param sd pointer to a \p HalfDuplexDriver structure

+ * @param sd pointer to a @p HalfDuplexDriver structure

  * @param b pointer to a memory area allocated for the queue buffer

  * @param size the buffer size

  * @param inotify pointer to a callback function that is invoked when

- *        some data is read from the queue. The value can be \p NULL.

+ *        some data is read from the queue. The value can be @p NULL.

  * @param onotify pointer to a callback function that is invoked when

- *        some data is written in the queue. The value can be \p NULL.

+ *        some data is written in the queue. The value can be @p NULL.

  */

 void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, size_t size,

                qnotify_t inotify, qnotify_t onotify) {

@@ -135,7 +135,7 @@ void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, size_t size,
 /**

  * This function must be called from the input interrupt service routine in

  * order to enqueue incoming data and generate the related events.

- * @param sd pointer to a \p FullDuplexDriver structure

+ * @param sd pointer to a @p FullDuplexDriver structure

  * @param b the byte to be written in the driver's input queue

  */

 void chHDDIncomingDataI(HalfDuplexDriver *sd, uint8_t b) {

@@ -150,7 +150,7 @@ void chHDDIncomingDataI(HalfDuplexDriver *sd, uint8_t b) {
  * Must be called from the output interrupt service routine in order to get

  * the next byte to be transmitted.

  *

- * @param sd pointer to a \p HalfDuplexDriver structure

+ * @param sd pointer to a @p HalfDuplexDriver structure

  * @return The byte value read from the driver's output queue.

  * @retval Q_EMPTY if the queue is empty (the lower driver usually disables

  *         the interrupt source when this happens).

@@ -166,7 +166,7 @@ msg_t chHDDRequestDataI(HalfDuplexDriver *sd) {
 /**

  * Must be called from the I/O interrupt service routine in order to

  * notify I/O conditions as errors, signals change etc.

- * @param sd pointer to a \p HalfDuplexDriver structure

+ * @param sd pointer to a @p HalfDuplexDriver structure

  * @param mask condition flags to be added to the mask

  */

 void chHDDAddFlagsI(HalfDuplexDriver *sd, dflags_t mask) {

@@ -177,7 +177,7 @@ void chHDDAddFlagsI(HalfDuplexDriver *sd, dflags_t mask) {
 

 /**

  * This function returns and clears the errors mask associated to the driver.

- * @param sd pointer to a \p HalfDuplexDriver structure

+ * @param sd pointer to a @p HalfDuplexDriver structure

  * @return The condition flags modified since last time this function was

  *         invoked.

  */

diff --git a/src/chsys.c b/src/chsys.c
index c1666095e..45ce8b0f8 100644
--- a/src/chsys.c
+++ b/src/chsys.c
@@ -45,9 +45,9 @@ static void idle_thread(void *p) {
 /**
  * ChibiOS/RT initialization. After executing this function the current
  * instructions stream becomes the main thread.
- * @note Interrupts should be still disabled when \p chSysInit() is invoked
+ * @note Interrupts should be still disabled when @p chSysInit() is invoked
  *       and are internally enabled.
- * @note The main thread is created with priority \p NORMALPRIO.
+ * @note The main thread is created with priority @p NORMALPRIO.
  */
 void chSysInit(void) {
   static Thread mainthread;
@@ -81,7 +81,7 @@ void chSysInit(void) {
  * it when the quantum is used up. Increments system time and manages the
  * timers.
  * @note The frequency of the timer determines the system tick granularity and,
- * together with the \p CH_TIME_QUANTUM macro, the round robin interval.
+ * together with the @p CH_TIME_QUANTUM macro, the round robin interval.
  */
 void chSysTimerHandlerI(void) {
 
diff --git a/src/chthreads.c b/src/chthreads.c
index c41e3af6b..dfa413641 100644
--- a/src/chthreads.c
+++ b/src/chthreads.c
@@ -66,17 +66,17 @@ static void memfill(uint8_t *p, uint32_t n, uint8_t v) {
 /**
  * Initializes a new thread.
  * The new thread is initialized but not inserted in the ready list, the
- * initial state is \p PRSUSPENDED.
+ * initial state is @p PRSUSPENDED.
  * @param prio the priority level for the new thread. Usually the threads are
- *             created with priority \p NORMALPRIO, priorities
- *             can range from \p LOWPRIO to \p HIGHPRIO.
+ *             created with priority @p NORMALPRIO, priorities
+ *             can range from @p LOWPRIO to @p HIGHPRIO.
  * @param workspace pointer to a working area dedicated to the thread stack
  * @param wsize size of the working area.
  * @param pf the thread function
- * @param arg an argument passed to the thread function. It can be \p NULL.
- * @return The pointer to the \p Thread structure allocated for the
+ * @param arg an argument passed to the thread function. It can be @p NULL.
+ * @return The pointer to the @p Thread structure allocated for the
  *         thread into the working space area.
- * @note A thread can terminate by calling \p chThdExit() or by simply
+ * @note A thread can terminate by calling @p chThdExit() or by simply
  *       returning from its main function.
  * @note This function can be invoked from within an interrupt handler.
  */
@@ -100,13 +100,13 @@ Thread *chThdInit(void *workspace, size_t wsize,
  * @param workspace pointer to a working area dedicated to the thread stack
  * @param wsize size of the working area.
  * @param prio the priority level for the new thread. Usually the threads are
- *             created with priority \p NORMALPRIO, priorities
- *             can range from \p LOWPRIO to \p HIGHPRIO.
+ *             created with priority @p NORMALPRIO, priorities
+ *             can range from @p LOWPRIO to @p HIGHPRIO.
  * @param pf the thread function
- * @param arg an argument passed to the thread function. It can be \p NULL.
- * @return The pointer to the \p Thread structure allocated for the
+ * @param arg an argument passed to the thread function. It can be @p NULL.
+ * @return The pointer to the @p Thread structure allocated for the
  *         thread into the working space area.
- * @note A thread can terminate by calling \p chThdExit() or by simply
+ * @note A thread can terminate by calling @p chThdExit() or by simply
  *       returning from its main function.
  */
 Thread *chThdCreateStatic(void *workspace, size_t wsize,
@@ -120,20 +120,20 @@ Thread *chThdCreateStatic(void *workspace, size_t wsize,
  * Creates a new thread allocating the memory from the heap.
  * @param wsize size of the working area to be allocated
  * @param prio the priority level for the new thread. Usually the threads are
- *             created with priority \p NORMALPRIO, priorities
- *             can range from \p LOWPRIO to \p HIGHPRIO.
+ *             created with priority @p NORMALPRIO, priorities
+ *             can range from @p LOWPRIO to @p HIGHPRIO.
  * @param pf the thread function
- * @param arg an argument passed to the thread function. It can be \p NULL.
- * @return The pointer to the \p Thread structure allocated for the
+ * @param arg an argument passed to the thread function. It can be @p NULL.
+ * @return The pointer to the @p Thread structure allocated for the
  *         thread into the working space area.
  * @retval NULL if the memory cannot be allocated.
- * @note A thread can terminate by calling \p chThdExit() or by simply
+ * @note A thread can terminate by calling @p chThdExit() or by simply
  *       returning from its main function.
  * @note The memory allocated for the thread is not released when the thread
- *       terminates but when a \p chThdWait() is performed.
- * @note The function is available only if the \p CH_USE_DYNAMIC,
- *       \p CH_USE_HEAP and \p CH_USE_WAITEXIT options are enabled
- *       in \p chconf.h.
+ *       terminates but when a @p chThdWait() is performed.
+ * @note The function is available only if the @p CH_USE_DYNAMIC,
+ *       @p CH_USE_HEAP and @p CH_USE_WAITEXIT options are enabled
+ *       in @p chconf.h.
  */
 Thread *chThdCreateFromHeap(size_t wsize, tprio_t prio,
                             tfunc_t pf, void *arg) {
@@ -152,21 +152,21 @@ Thread *chThdCreateFromHeap(size_t wsize, tprio_t prio,
  * Creates a new thread allocating the memory from the specified Memory Pool.
  * @param mp the memory pool
  * @param prio the priority level for the new thread. Usually the threads are
- *             created with priority \p NORMALPRIO, priorities
- *             can range from \p LOWPRIO to \p HIGHPRIO.
+ *             created with priority @p NORMALPRIO, priorities
+ *             can range from @p LOWPRIO to @p HIGHPRIO.
  * @param pf the thread function
- * @param arg an argument passed to the thread function. It can be \p NULL.
- * @return The pointer to the \p Thread structure allocated for the
- *         thread into the working space area or \p NULL if the memory cannot
+ * @param arg an argument passed to the thread function. It can be @p NULL.
+ * @return The pointer to the @p Thread structure allocated for the
+ *         thread into the working space area or @p NULL if the memory cannot
  *         be allocated.
  * @retval NULL if the memory pool is empty.
- * @note A thread can terminate by calling \p chThdExit() or by simply
+ * @note A thread can terminate by calling @p chThdExit() or by simply
  *       returning from its main function.
  * @note The memory allocated for the thread is not released when the thread
- *       terminates but when a \p chThdWait() is performed.
- * @note The function is available only if the \p CH_USE_DYNAMIC,
- *       \p CH_USE_MEMPOOLS and \p CH_USE_WAITEXIT options are enabled
- *       in \p chconf.h.
+ *       terminates but when a @p chThdWait() is performed.
+ * @note The function is available only if the @p CH_USE_DYNAMIC,
+ *       @p CH_USE_MEMPOOLS and @p CH_USE_WAITEXIT options are enabled
+ *       in @p chconf.h.
  */
 Thread *chThdCreateFromMemoryPool(MemoryPool *mp, tprio_t prio,
                                   tfunc_t pf, void *arg) {
@@ -210,9 +210,9 @@ void chThdSetPriority(tprio_t newprio) {
 /**
  * Suspends the invoking thread.
  *
- * @param tpp pointer to a \p Thread pointer, the \p Thread pointer is set
+ * @param tpp pointer to a @p Thread pointer, the @p Thread pointer is set
  *            to point to the suspended process before it enters the
- *            \p PRSUSPENDED state, it is set to \p NULL after it is resumed.
+ *            @p PRSUSPENDED state, it is set to @p NULL after it is resumed.
  *            This allows to implement a "test and resume" on the variable
  *            into interrupt handlers.
  */
@@ -244,8 +244,8 @@ Thread *chThdResume(Thread *tp) {
  * Requests a thread termination.
  * @param tp the pointer to the thread
  * @note The thread is not termitated but a termination request is added to
- *       its \p p_flags field. The thread can read this status by
- *       invoking \p chThdShouldTerminate() and then terminate cleanly.
+ *       its @p p_flags field. The thread can read this status by
+ *       invoking @p chThdShouldTerminate() and then terminate cleanly.
  */
 void chThdTerminate(Thread *tp) {
 
@@ -282,7 +282,7 @@ void chThdSleepUntil(systime_t time) {
  * Terminates the current thread by specifying an exit status code.
  *
  * @param msg the thread exit code. The code can be retrieved by using
- *            \p chThdWait().
+ *            @p chThdWait().
  */
 void chThdExit(msg_t msg) {
   Thread *tp = currp;
@@ -304,20 +304,20 @@ void chThdExit(msg_t msg) {
  * The memory used by the exited thread is handled in different ways depending
  * on the API that spawned the thread:
  * <ul>
- * <li>If the thread was spawned by \p chThdCreateStatic() or by \p chThdInit()
+ * <li>If the thread was spawned by @p chThdCreateStatic() or by @p chThdInit()
  *     then nothing happens and the thread working area is not released or
  *     modified in any way. This is the default, totally static, behavior.</li>
- * <li>If the thread was spawned by \p chThdCreateFromHeap() then the working
+ * <li>If the thread was spawned by @p chThdCreateFromHeap() then the working
  *     area is returned to the system heap.</li>
- * <li>If the thread was spawned by \p chThdCreateFromMemoryPool() then the
+ * <li>If the thread was spawned by @p chThdCreateFromMemoryPool() then the
  *     working area is returned to the owning memory pool.</li>
  * </ul>
  * @param tp the thread pointer
  * @return The exit code from the terminated thread
- * @note After invoking \p chThdWait() the thread pointer becomes invalid and
+ * @note After invoking @p chThdWait() the thread pointer becomes invalid and
  *       must not be used as parameter for further system calls.
- * @note The function is available only if the \p CH_USE_WAITEXIT
- *       option is enabled in \p chconf.h.
+ * @note The function is available only if the @p CH_USE_WAITEXIT
+ *       option is enabled in @p chconf.h.
  * @note Only one thread can be waiting for another thread at any time. You
  *       should imagine the threads as having a reference counter that is set
  *       to one when the thread is created, chThdWait() decreases the reference
diff --git a/src/chvt.c b/src/chvt.c
index 0d3106a1c..0071b1733 100644
--- a/src/chvt.c
+++ b/src/chvt.c
@@ -39,7 +39,7 @@ void chVTInit(void) {
 

 /**

  * Enables a virtual timer.

- * @param vtp the \p VirtualTimer structure pointer

+ * @param vtp the @p VirtualTimer structure pointer

  * @param time the number of time ticks, the value zero is not allowed

  * @param vtfunc the timer callback function. After invoking the callback

  *               the timer is disabled and the structure can be disposed or

@@ -70,7 +70,7 @@ void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
 

 /**

  * Disables a Virtual Timer.

- * @param vtp the \p VirtualTimer structure pointer

+ * @param vtp the @p VirtualTimer structure pointer

  * @note It must be called with the interrupts disabled.

  * @note The timer MUST be active when this function is invoked.

  */

diff --git a/src/include/debug.h b/src/include/debug.h
index 6bd3845b4..52c15cf08 100644
--- a/src/include/debug.h
+++ b/src/include/debug.h
@@ -67,8 +67,8 @@ extern "C" {
  * with the specified message.

  * @param c the condition to be verified to be true

  * @param m the text message

- * @note The condition is tested only if the \p CH_USE_DEBUG switch is

- *       specified in \p chconf.h else the macro does nothing.

+ * @note The condition is tested only if the @p CH_USE_DEBUG switch is

+ *       specified in @p chconf.h else the macro does nothing.

  */

 #define chDbgAssert(c, m) {                                             \

   if (!(c))                                                             \

diff --git a/src/include/events.h b/src/include/events.h
index 49b551f45..1f2e2a15a 100644
--- a/src/include/events.h
+++ b/src/include/events.h
@@ -57,16 +57,16 @@ typedef struct EventSource {
 

 /**

  * Initializes an Event Source.

- * @param esp pointer to the \p EventSource structure

+ * @param esp pointer to the @p EventSource structure

  * @note Can be called with interrupts disabled or enabled.

  */

 #define chEvtInit(esp) \

         ((esp)->es_next = (EventListener *)(void *)(esp))

 

 /**

- * Verifies if there is at least one \p EventListener registered on the

- * \p EventSource.

- * @param esp pointer to the \p EventSource structure

+ * Verifies if there is at least one @p EventListener registered on the

+ * @p EventSource.

+ * @param esp pointer to the @p EventSource structure

  * @note Can be called with interrupts disabled or enabled.

  */

 #define chEvtIsListening(esp) \

@@ -101,12 +101,12 @@ extern "C" {
 

 /**

  * Registers an Event Listener on an Event Source.

- * @param esp pointer to the  \p EventSource structure

- * @param elp pointer to the \p EventListener structure

+ * @param esp pointer to the  @p EventSource structure

+ * @param elp pointer to the @p EventListener structure

  * @param eid numeric identifier assigned to the Event Listener. The identifier

  *            is used as index for the event callback function.

  *            The value must range between zero and the size, in bit, of the

- *            \p eventid_t type minus one.

+ *            @p eventid_t type minus one.

  * @note Multiple Event Listeners can use the same event identifier, the

  *       listener will share the callback function.

  */

diff --git a/src/include/lists.h b/src/include/lists.h
index 5f4a73d67..10b5d7823 100644
--- a/src/include/lists.h
+++ b/src/include/lists.h
@@ -36,9 +36,9 @@ typedef struct Thread Thread;
  * @extends ThreadsList

  */

 typedef struct {

-  /** First \p Thread in the queue, or \p ThreadQueue when empty. */

+  /** First @p Thread in the queue, or @p ThreadQueue when empty. */

   Thread                *p_next;

-  /** Last \p Thread in the queue, or \p ThreadQueue when empty. */

+  /** Last @p Thread in the queue, or @p ThreadQueue when empty. */

   Thread                *p_prev;

 } ThreadsQueue;

 

@@ -46,7 +46,7 @@ typedef struct {
  * Generic threads single link list, it works like a stack.

  */

 typedef struct {

-  /** Last pushed \p Thread on the stack list, or \p ThreadList when empty. */

+  /** Last pushed @p Thread on the stack list, or @p ThreadList when empty. */

   Thread                *p_next;

 } ThreadsList;

 

diff --git a/src/include/mutexes.h b/src/include/mutexes.h
index e4ddcfb43..247b5ad7c 100644
--- a/src/include/mutexes.h
+++ b/src/include/mutexes.h
@@ -33,9 +33,9 @@
 typedef struct Mutex {

   /** Queue of the threads sleeping on this Mutex.*/

   ThreadsQueue          m_queue;

-  /** Owner \p Thread pointer or \p NULL.*/

+  /** Owner @p Thread pointer or @p NULL.*/

   Thread                *m_owner;

-  /** Next \p Mutex into an owner-list, \p NULL if none.*/

+  /** Next @p Mutex into an owner-list, @p NULL if none.*/

   struct Mutex          *m_next;

 } Mutex;

 

@@ -55,7 +55,7 @@ extern "C" {
 #endif

 

 /**

- * Returns \p TRUE if the mutex queue contains at least a waiting thread.

+ * Returns @p TRUE if the mutex queue contains at least a waiting thread.

  */

 #define chMtxQueueNotEmptyS(mp) notempty(&(mp)->m_queue)

 

diff --git a/src/include/scheduler.h b/src/include/scheduler.h
index f4dac7d16..7d2f95beb 100644
--- a/src/include/scheduler.h
+++ b/src/include/scheduler.h
@@ -25,7 +25,7 @@
 #ifndef _SCHEDULER_H_
 #define _SCHEDULER_H_
 
-/** Normal \p chSchReadyI() message. */
+/** Normal @p chSchReadyI() message. */
 #define RDY_OK          0
 /** Returned when the thread was made ready because of a timeout. */
 #define RDY_TIMEOUT     -1
@@ -57,9 +57,9 @@
  * @extends ThreadsQueue
  */
 typedef struct {
-  /** Next \p Thread in the ready list.*/
+  /** Next @p Thread in the ready list.*/
   Thread                *p_next;
-  /** Previous \p Thread in the ready list.*/
+  /** Previous @p Thread in the ready list.*/
   Thread                *p_prev;
   /* End of the fields shared with the ThreadsQueue structure. */
   /** The thread priority.*/
diff --git a/src/include/serial.h b/src/include/serial.h
index 25dcfa9ec..0dfd02c56 100644
--- a/src/include/serial.h
+++ b/src/include/serial.h
@@ -53,21 +53,21 @@ typedef struct {
   /** Input queue. Incoming data can be read from this queue by using the

    *  queues APIs.*/

   Queue                 sd_iqueue;

-  /** Data Available \p EventSource. This event is generated when some incoming

-   *  data is inserted in the Input \p Queue.*/

+  /** Data Available @p EventSource. This event is generated when some incoming

+   *  data is inserted in the Input @p Queue.*/

   EventSource           sd_ievent;

 

-  /** Output queue. Outgoing data can be written to this Output \p Queue by

+  /** Output queue. Outgoing data can be written to this Output @p Queue by

    *   using the queues APIs.*/

   Queue                 sd_oqueue;

-  /** Data Transmitted \p EventSource. This event is generated when the

-   *  Output \p Queue is empty.*/

+  /** Data Transmitted @p EventSource. This event is generated when the

+   *  Output @p Queue is empty.*/

   EventSource           sd_oevent;

 

   /** I/O driver status flags. This field should not be read directly but

-   *  the \p chFDDGetAndClearFlags() funtion should be used instead.*/

+   *  the @p chFDDGetAndClearFlags() funtion should be used instead.*/

   dflags_t              sd_flags;

-  /** Status Change \p EventSource. This event is generated when a

+  /** Status Change @p EventSource. This event is generated when a

    *  condition flag was changed.*/

   EventSource           sd_sevent;

 } FullDuplexDriver;

@@ -115,17 +115,17 @@ extern "C" {
  */

 typedef struct {

 

-  /** Data queue. Transmit/receive \p HalfDuplexQueue.*/

+  /** Data queue. Transmit/receive @p HalfDuplexQueue.*/

   HalfDuplexQueue       sd_queue;

-  /** Data Available \p EventSource. This event is generated when some

+  /** Data Available @p EventSource. This event is generated when some

    *  incoming data is inserted in the receive queue.*/

   EventSource           sd_ievent;

-  /** Data Transmitted \p EventSource. This event is generated when the

+  /** Data Transmitted @p EventSource. This event is generated when the

    *  transmission queue is empty and the driver can either transmit more

    *  data or enter receive mode.*/

   EventSource           sd_oevent;

   /** I/O driver status flags. This field should not be read directly but

-   *  the \p chHDDGetAndClearFlags() funtion should be used

+   *  the @p chHDDGetAndClearFlags() funtion should be used

    *  instead.*/

   dflags_t              sd_flags;

   /** Status Change Event Source. This event is generated when a condition

diff --git a/src/include/sys.h b/src/include/sys.h
index ae6a8dd2a..5acc863f2 100644
--- a/src/include/sys.h
+++ b/src/include/sys.h
@@ -154,7 +154,7 @@
  * IRQ handler exit code.

  * @note Usually IRQ handlers function are also declared naked.

  * @note This macro usually performs the final reschedulation by using

- *       \p chSchRescRequiredI() and \p chSchDoRescheduleI().

+ *       @p chSchRescRequiredI() and @p chSchDoRescheduleI().

  */

 #define CH_IRQ_EPILOGUE() SYS_IRQ_EPILOGUE()

 

diff --git a/src/include/threads.h b/src/include/threads.h
index 771fabb83..cd3856b34 100644
--- a/src/include/threads.h
+++ b/src/include/threads.h
@@ -30,13 +30,13 @@
  * @extends ThreadsQueue
  * @note Not all the listed fields are always needed, by switching off some
  *       not needed ChibiOS/RT subsystems it is possible to save RAM space by
- *       shrinking the \p Thread structure.
+ *       shrinking the @p Thread structure.
  */
 struct Thread {
-  /** Next \p Thread in the threads list.*/
+  /** Next @p Thread in the threads list.*/
   Thread                *p_next;
   /* End of the fields shared with the ThreadsList structure. */
-  /** Previous \p Thread in the threads list.*/
+  /** Previous @p Thread in the threads list.*/
   Thread                *p_prev;
   /* End of the fields shared with the ThreadsQueue structure. */
   /** The thread priority.*/
@@ -59,28 +59,28 @@ struct Thread {
    * thread in the system.
    */
   union {
-    /** Thread wakeup code (only valid when exiting the \p PRREADY state).*/
+    /** Thread wakeup code (only valid when exiting the @p PRREADY state).*/
     msg_t               p_rdymsg;
-    /** The thread exit code (only while in \p PREXIT state).*/
+    /** The thread exit code (only while in @p PREXIT state).*/
     msg_t               p_exitcode;
 #ifdef CH_USE_SEMAPHORES
-    /** Semaphore where the thread is waiting on (only in \p PRWTSEM state).*/
+    /** Semaphore where the thread is waiting on (only in @p PRWTSEM state).*/
     Semaphore           *p_wtsemp;
 #endif
 #ifdef CH_USE_MUTEXES
-    /** Mutex where the thread is waiting on (only in \p PRWTMTX state).*/
+    /** Mutex where the thread is waiting on (only in @p PRWTMTX state).*/
     Mutex               *p_wtmtxp;
 #endif
 #ifdef CH_USE_CONDVARS
-    /** CondVar where the thread is waiting on (only in \p PRWTCOND state).*/
+    /** CondVar where the thread is waiting on (only in @p PRWTCOND state).*/
     CondVar             *p_wtcondp;
 #endif
 #ifdef CH_USE_MESSAGES
-    /** Destination thread for message send (only in \p PRSNDMSG state).*/
+    /** Destination thread for message send (only in @p PRSNDMSG state).*/
     Thread              *p_wtthdp;
 #endif
 #ifdef CH_USE_EVENTS
-    /** Enabled events mask (only while in \p PRWTOREVT or \p PRWTANDEVT
+    /** Enabled events mask (only while in @p PRWTOREVT or @p PRWTANDEVT
         states). */
     eventmask_t         p_ewmask;
 #endif
@@ -106,7 +106,7 @@ struct Thread {
   eventmask_t           p_epending;
 #endif
 #ifdef CH_USE_MUTEXES
-  /** List of mutexes owned by this thread, \p NULL terminated. */
+  /** List of mutexes owned by this thread, @p NULL terminated. */
   Mutex                 *p_mtxlist;
   /** Thread's own, non-inherited, priority. */
   tprio_t               p_realprio;
@@ -129,20 +129,20 @@ struct Thread {
 #define PRWTSEM         3
 /** Thread state: Waiting on a mutex. */
 #define PRWTMTX         4
-/** Thread state: Waiting in \p chThdSleep() or \p chThdSleepUntil(). */
+/** Thread state: Waiting in @p chThdSleep() or @p chThdSleepUntil(). */
 #define PRWTCOND        5
-/** Thread state: Waiting in \p chCondWait(). */
+/** Thread state: Waiting in @p chCondWait(). */
 #define PRSLEEP         6
-/** Thread state: Waiting in \p chThdWait(). */
+/** Thread state: Waiting in @p chThdWait(). */
 #define PRWAIT          7
-/** Thread state: Waiting in \p chEvtWaitOneTimeout() or
-    \p chEvtWaitAnyTimeout(). */
+/** Thread state: Waiting in @p chEvtWaitOneTimeout() or
+    @p chEvtWaitAnyTimeout(). */
 #define PRWTOREVT       8
-/** Thread state: Waiting in \p chEvtWaitAllTimeout(). */
+/** Thread state: Waiting in @p chEvtWaitAllTimeout(). */
 #define PRWTANDEVT      9
-/** Thread state: Waiting in \p chMsgSend(). */
+/** Thread state: Waiting in @p chMsgSend(). */
 #define PRSNDMSG        10
-/** Thread state: Waiting in \p chMsgWait(). */
+/** Thread state: Waiting in @p chMsgWait(). */
 #define PRWTMSG         11
 /** Thread state: After termination.*/
 #define PREXIT          12
@@ -195,16 +195,16 @@ extern "C" {
 }
 #endif
 
-/** Returns the pointer to the \p Thread currently in execution.*/
+/** Returns the pointer to the @p Thread currently in execution.*/
 #define chThdSelf() currp
 
 /** Returns the thread priority.*/
 #define chThdGetPriority() (currp->p_prio)
 
-/** Returns the pointer to the \p Thread local storage area, if any.*/
+/** Returns the pointer to the @p Thread local storage area, if any.*/
 #define chThdLS() (void *)(currp + 1)
 
-/** Verifies if the specified thread is in the \p PREXIT state.*/
+/** Verifies if the specified thread is in the @p PREXIT state.*/
 #define chThdTerminated(tp) ((tp)->p_state == PREXIT)
 
 /**
@@ -213,8 +213,8 @@ extern "C" {
 #define chThdShouldTerminate() (currp->p_flags & P_TERMINATE)
 
 /**
- * Resumes a thread created with the \p P_SUSPENDED option or suspended with
- * \p chThdSuspend().
+ * Resumes a thread created with the @p P_SUSPENDED option or suspended with
+ * @p chThdSuspend().
  * @param tp the pointer to the thread
  */
 #define chThdResumeI(tp) chSchReadyI(tp)
diff --git a/src/include/vt.h b/src/include/vt.h
index 72385715b..04af725c9 100644
--- a/src/include/vt.h
+++ b/src/include/vt.h
@@ -117,10 +117,10 @@ extern "C" {
 #define chVTIsArmedI(vtp) ((vtp)->vt_func != NULL)

 

 /**

- * Returns the number of system ticks since the \p chSysInit() invocation.

+ * Returns the number of system ticks since the @p chSysInit() invocation.

  * @return the system ticks number

  * @note The counter can reach its maximum and then returns to zero.

- * @note This function is designed to work with the \p chThdSleepUntil().

+ * @note This function is designed to work with the @p chThdSleepUntil().

  */

 #define chSysGetTime() (vtlist.vt_systime)

 

diff --git a/src/lib/ch.hpp b/src/lib/ch.hpp
index fd016f210..2d34a0563 100644
--- a/src/lib/ch.hpp
+++ b/src/lib/ch.hpp
@@ -99,7 +99,7 @@ namespace chibios_rt {
 

   /**

    * Base class for a ChibiOS/RT thread, the thread body is the virtual

-   * function \p Main().

+   * function @p Main().

    */

   class BaseThread {

   public:

@@ -185,7 +185,7 @@ namespace chibios_rt {
     static msg_t WaitMessage(void);

 

     /**

-     * Returns an enqueued message or \p NULL.

+     * Returns an enqueued message or @p NULL.

      * @return The incoming message.

      * @retval NULL No incoming message.

      */

@@ -242,7 +242,7 @@ namespace chibios_rt {
 

     /**

      * Simplified constructor, it allows to create a thread by simply

-     * specifying a name. In is assumed \p NORMALPRIO as initial priority

+     * specifying a name. In is assumed @p NORMALPRIO as initial priority

      * and no special option flags.

      * @param tname the name to be assigned to the thread

      */

@@ -255,7 +255,7 @@ namespace chibios_rt {
 

 #ifdef CH_USE_SEMAPHORES

   /**

-   * Class encapsulating a \p Semaphore.

+   * Class encapsulating a @p Semaphore.

    */

   class Semaphore {

   public:

@@ -305,8 +305,8 @@ namespace chibios_rt {
 #ifdef CH_USE_SEMSW

     /**

      * Atomic signal and wait operations.

-     * @param ssem pointer to a \p Semaphore to be signaled

-     * @param wsem pointer to a \p Semaphore to be wait on

+     * @param ssem pointer to a @p Semaphore to be signaled

+     * @param wsem pointer to a @p Semaphore to be wait on

      * @retval RDY_OK if the semaphore was signaled or not taken.

      * @retval RDY_RESET if the semaphore was reset.

      */

@@ -317,7 +317,7 @@ namespace chibios_rt {
 

 #ifdef CH_USE_MUTEXES

   /**

-   * Class encapsulating a \p Mutex.

+   * Class encapsulating a @p Mutex.

    */

   class Mutex {

   public:

@@ -364,7 +364,7 @@ namespace chibios_rt {
 

 #ifdef CH_USE_CONDVARS

   /**

-   * Class encapsulating a \p CondVar.

+   * Class encapsulating a @p CondVar.

    */

   class CondVar {

   public:

@@ -417,7 +417,7 @@ namespace chibios_rt {
 

 #ifdef CH_USE_EVENTS

   /**

-   * Class encapsulating an \p EventSource.

+   * Class encapsulating an @p EventSource.

    */

   class Event {

   public:

@@ -434,14 +434,14 @@ namespace chibios_rt {
 

     /**

      * Registers a listener on the event source.

-     * @param elp pointer to the \p EventListener structure

+     * @param elp pointer to the @p EventListener structure

      * @param eid numeric identifier assigned to the Event Listener

      */

     void Register(EventListener *elp, eventid_t eid);

 

     /**

      * Registers an Event Listener on an Event Source.

-     * @param elp pointer to the \p EventListener structure

+     * @param elp pointer to the @p EventListener structure

      * @param emask the mask of event flags to be pended to the thread when the

      *              event source is broadcasted

      * @note Multiple Event Listeners can specify the same bits to be pended.

@@ -470,7 +470,7 @@ namespace chibios_rt {
 

     /**

      * Makes an events mask pending in the current thread, this is \b much

-     * faster than using \p Broadcast().

+     * faster than using @p Broadcast().

      * @param mask the events to be pended

      * @return The current pending events mask.

      */

@@ -479,7 +479,7 @@ namespace chibios_rt {
     /**

      * Invokes the event handlers associated with a mask.

      * @param mask mask of the events to be dispatched

-     * @param handlers an array of \p evhandler_t. The array must be

+     * @param handlers an array of @p evhandler_t. The array must be

      *                 have indexes from zero up the higher registered event

      *                 identifier.

      */

diff --git a/src/lib/evtimer.c b/src/lib/evtimer.c
index f9bd7449b..786a25c7f 100644
--- a/src/lib/evtimer.c
+++ b/src/lib/evtimer.c
@@ -39,7 +39,7 @@ static void tmrcb(void *p) {
 /**

  * Starts the timer, if the timer was already running then the function has

  * no effect.

- * @param etp pointer to an initialized \p EvTimer structure.

+ * @param etp pointer to an initialized @p EvTimer structure.

  */

 void evtStart(EvTimer *etp) {

 

@@ -54,7 +54,7 @@ void evtStart(EvTimer *etp) {
 /**

  * Stops the timer, if the timer was already stopped then the function has

  * no effect.

- * @param etp pointer to an initialized \p EvTimer structure.

+ * @param etp pointer to an initialized @p EvTimer structure.

  */

 void evtStop(EvTimer *etp) {

 

diff --git a/src/lib/evtimer.h b/src/lib/evtimer.h
index 661b29cd4..d0ff5f7c7 100644
--- a/src/lib/evtimer.h
+++ b/src/lib/evtimer.h
@@ -46,7 +46,7 @@ extern "C" {
 #endif

 

 /**

- * Initializes an \p EvTimer structure.

+ * Initializes an @p EvTimer structure.

  * @param etp the EvTimer structure to be initialized

  * @param time the interval in system ticks

  */

diff --git a/src/templates/chconf.h b/src/templates/chconf.h
index 7ce208aa0..c97c00a86 100644
--- a/src/templates/chconf.h
+++ b/src/templates/chconf.h
@@ -48,7 +48,7 @@
  *  robin scheduling algorithm on threads of equal priority.*/

 #define CH_USE_ROUNDROBIN

 

-/** Configuration option: if specified then the \p chThdWait() function

+/** Configuration option: if specified then the @p chThdWait() function

  *  is included in the kernel.*/

 #define CH_USE_WAITEXIT

 

@@ -62,7 +62,7 @@
 

 /** Configuration option: if specified then the Semaphores with timeout APIs

  *  are included in the kernel.

- * @note requires \p CH_USE_SEMAPHORES.*/

+ * @note requires @p CH_USE_SEMAPHORES.*/

 #define CH_USE_SEMAPHORES_TIMEOUT

 

 /** Configuration option: if specified then the Mutexes APIs are included in

@@ -71,21 +71,21 @@
 

 /** Configuration option: if specified then the Conditional Variables APIs are

  *  included in the kernel.

- * @note requires \p CH_USE_MUTEXES.*/

+ * @note requires @p CH_USE_MUTEXES.*/

 #define CH_USE_CONDVARS

 

 /** Configuration option: if specified then the Conditional Variables APIs are

  *  included in the kernel.

- * @note requires \p CH_USE_CONDVARS and \p CH_USE_MUTEXES.*/

+ * @note requires @p CH_USE_CONDVARS and @p CH_USE_MUTEXES.*/

 #define CH_USE_CONDVARS_TIMEOUT

 

 /** Configuration option: if specified then the Events APIs are included in

  *  the kernel.*/

 #define CH_USE_EVENTS

 

-/** Configuration option: if specified then the \p chEvtWaitXXXTimeout()

+/** Configuration option: if specified then the @p chEvtWaitXXXTimeout()

  * functions are included in the kernel.

- * @note requires \p CH_USE_EVENTS.

+ * @note requires @p CH_USE_EVENTS.

  */

 #define CH_USE_EVENTS_TIMEOUT

 

@@ -93,14 +93,14 @@
  *  included in the kernel.*/

 #define CH_USE_MESSAGES

 

-/** Configuration option: if specified then the \p chMsgSendWithEvent()

+/** Configuration option: if specified then the @p chMsgSendWithEvent()

  *  function is included in the kernel.

- * @note requires \p CH_USE_MESSAGES.*/

+ * @note requires @p CH_USE_MESSAGES.*/

 #define CH_USE_MESSAGES_EVENT

 

 /** Configuration option: If enabled then the threads serve messages by

  *  priority instead of FIFO order.

- * @note requires \p CH_USE_MESSAGES.*/

+ * @note requires @p CH_USE_MESSAGES.*/

 #define CH_USE_MESSAGES_PRIORITY

 

 /** Configuration option: if specified then the I/O queues APIs are included

@@ -113,7 +113,7 @@
 

 /** Configuration option: if specified then the I/O queues with timeout

  *  APIs are included in the kernel.

- * @note requires \p CH_USE_SEMAPHORES_TIMEOUT.*/

+ * @note requires @p CH_USE_SEMAPHORES_TIMEOUT.*/

 #define CH_USE_QUEUES_TIMEOUT

 

 /** Configuration option: if specified then the full duplex serial driver APIs

@@ -131,13 +131,13 @@
 /** Configuration option: Number of RAM bytes to use as system heap. If set to

  *  zero then the whole available RAM is used as system heap.

  * @note In order to use the whole RAM as system heap the linker script must

- *       provide the \p __heap_base__ and \p __heap_end__ symbols.

- * @note requires \p CH_USE_HEAP.

+ *       provide the @p __heap_base__ and @p __heap_end__ symbols.

+ * @note requires @p CH_USE_HEAP.

  */

 #define CH_HEAP_SIZE 0

 

-/** Configuration option: enforces the use of the C-runtime \p malloc() and

- *  \p free() functions as backend for the system heap allocator.*/

+/** Configuration option: enforces the use of the C-runtime @p malloc() and

+ *  @p free() functions as backend for the system heap allocator.*/

 #define CH_USE_MALLOC_HEAP

 

 /** Configuration option: if specified then the memory pools allocator APIs

@@ -146,7 +146,7 @@
 

 /** Configuration option: if specified then the dynamic objects creation APIs

  *  are included in the kernel.

- * @note requires \p CH_USE_WAITEXIT.

+ * @note requires @p CH_USE_WAITEXIT.

  */

 #define CH_USE_DYNAMIC

 

@@ -156,18 +156,18 @@
 

 /** Configuration option: This constant is the number of ticks allowed for the

  *  threads before preemption occurs. This option is only meaningful if the

- *  option \p CH_USE_ROUNDROBIN is also active.*/

+ *  option @p CH_USE_ROUNDROBIN is also active.*/

 #define CH_TIME_QUANTUM 20

 

 /** Configuration option: Defines a CPU register to be used as storage for the

- *  global \p currp variable. Caching this variable in a register can greatly

+ *  global @p currp variable. Caching this variable in a register can greatly

  *  improve both space and time efficiency of the generated code. Another side

  *  effect is that one less register has to be saved during the context switch

  *  resulting in lower RAM usage and faster code.

  *  @note This option is only useable with the GCC compiler and is only useful

  *        on processors with many registers like ARM cores.

  *  @note If this option is enabled then ALL the libraries linked to the

- *        ChibiOS/RT code <b>must</b> be recompiled with the GCC option \p

+ *        ChibiOS/RT code <b>must</b> be recompiled with the GCC option @p

  *        -ffixed-\<reg\>.

  */

 //#define CH_CURRP_REGISTER_CACHE "reg"

@@ -182,19 +182,19 @@
  */

 #define CH_USE_TRACE

 

-/** User fields added to the end of the \p Thread structure. */

+/** User fields added to the end of the @p Thread structure. */

 #define THREAD_EXT_FIELDS                                               \

 struct {                                                                \

   /* Add thread custom fields here.*/                                   \

 };

 

-/** User initialization code added to the \p chThdInit() API.

- *  @note It is invoked from within \p chThdInit(). */

+/** User initialization code added to the @p chThdInit() API.

+ *  @note It is invoked from within @p chThdInit(). */

 #define THREAD_EXT_INIT(tp) {                                           \

   /* Add thread initialization code here.*/                             \

 }

 

-/** User finalization code added to the \p chThdExit() API.

+/** User finalization code added to the @p chThdExit() API.

  *  @note It is inserted into lock zone. */

 #define THREAD_EXT_EXIT(tp) {                                           \

   /* Add thread finalization code here.*/                               \