Changes throughout.

4 files changed, 168 insertions, 290 deletions

diff --git a/c/src/lib/libbsp/arm/lpc24xx/misc/bspidle.c b/c/src/lib/libbsp/arm/lpc24xx/misc/bspidle.c
index 44ec76bb5c..a923397f10 100644
--- a/c/src/lib/libbsp/arm/lpc24xx/misc/bspidle.c
+++ b/c/src/lib/libbsp/arm/lpc24xx/misc/bspidle.c
@@ -24,7 +24,7 @@
 #include <bsp.h>
 #include <bsp/lpc24xx.h>
 
-void *bsp_idle_thread(uint32_t ignored)
+void *bsp_idle_thread(uintptr_t ignored)
 {
   while (true) {
     /*
diff --git a/c/src/lib/libbsp/arm/lpc24xx/misc/dma.c b/c/src/lib/libbsp/arm/lpc24xx/misc/dma.c
index 5b3ba6fa0b..96b04d761c 100644
--- a/c/src/lib/libbsp/arm/lpc24xx/misc/dma.c
+++ b/c/src/lib/libbsp/arm/lpc24xx/misc/dma.c
@@ -1,9 +1,9 @@
 /**
  * @file
  *
- * @ingroup lpc24xx
+ * @ingroup lpc24xx_dma
  *
- * @brief DMA support.
+ * @brief Direct memory access (DMA) support.
  */
 
 /*
@@ -12,10 +12,11 @@
  * Obere Lagerstr. 30
  * D-82178 Puchheim
  * Germany
- * rtems@embedded-brains.de
+ * <rtems@embedded-brains.de>
  *
- * The license and distribution terms for this file may be found in the file
- * LICENSE in this distribution or at http://www.rtems.com/license/LICENSE.
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.com/license/LICENSE.
  */
 
 #include <rtems/endian.h>
@@ -29,9 +30,6 @@
  */
 static bool lpc24xx_dma_channel_occupation [GPDMA_CH_NUMBER];
 
-/**
- * @brief Initializes the general purpose DMA.
- */
 void lpc24xx_dma_initialize(void)
 {
   rtems_interrupt_level level;
@@ -57,13 +55,6 @@ void lpc24xx_dma_initialize(void)
   GPDMA_SYNC = 0;
 }
 
-/**
- * @brief Tries to obtain the channel @a channel.
- *
- * @retval RTEMS_SUCCESSFUL Successful operation.
- * @retval RTEMS_INVALID_ID Invalid channel number.
- * @retval RTEMS_RESOURCE_IN_USE Channel already occupied.
- */
 rtems_status_code lpc24xx_dma_channel_obtain(unsigned channel)
 {
   if (channel < GPDMA_CH_NUMBER) {
@@ -81,14 +72,6 @@ rtems_status_code lpc24xx_dma_channel_obtain(unsigned channel)
   }
 }
 
-/**
- * @brief Releases the channel @a channel.
- *
- * You must have obtained this channel with lpc24xx_dma_channel_obtain()
- * previously.
- *
- * If the channel number @a channel is out of range nothing will happen.
- */
 void lpc24xx_dma_channel_release(unsigned channel)
 {
   if (channel < GPDMA_CH_NUMBER) {
@@ -96,29 +79,23 @@ void lpc24xx_dma_channel_release(unsigned channel)
   }
 }
 
-/**
- * @brief Disables the channel @a channel.
- *
- * If @a force is false the channel will be halted and disabled when the
- * channel is inactive.
- *
- * If the channel number @a channel is out of range the behaviour is undefined.
- */
 void lpc24xx_dma_channel_disable(unsigned channel, bool force)
 {
-  volatile lpc24xx_dma_channel *ch = GPDMA_CH_BASE_ADDR(channel);
-  uint32_t cfg = ch->cfg;
-
-  if (!force) {
-    /* Halt */
-    ch->cfg = SET_FLAG(cfg, GPDMA_CH_CFG_HALT);
-
-    /* Wait for inactive */
-    do {
-      cfg = ch->cfg;
-    } while (IS_FLAG_SET(cfg, GPDMA_CH_CFG_ACTIVE));
+  if (channel < GPDMA_CH_NUMBER) {
+    volatile lpc24xx_dma_channel *ch = GPDMA_CH_BASE_ADDR(channel);
+    uint32_t cfg = ch->cfg;
+ 
+    if (!force) {
+      /* Halt */
+      ch->cfg = SET_FLAG(cfg, GPDMA_CH_CFG_HALT);
+ 
+      /* Wait for inactive */
+      do {
+        cfg = ch->cfg;
+      } while (IS_FLAG_SET(cfg, GPDMA_CH_CFG_ACTIVE));
+    }
+ 
+    /* Disable */
+    ch->cfg = CLEAR_FLAG(cfg, GPDMA_CH_CFG_EN);
   }
-
-  /* Disable */
-  ch->cfg = CLEAR_FLAG(cfg, GPDMA_CH_CFG_EN);
 }
diff --git a/c/src/lib/libbsp/arm/lpc24xx/misc/io.c b/c/src/lib/libbsp/arm/lpc24xx/misc/io.c
index d1b46b7289..85ea380bcc 100644
--- a/c/src/lib/libbsp/arm/lpc24xx/misc/io.c
+++ b/c/src/lib/libbsp/arm/lpc24xx/misc/io.c
@@ -1,9 +1,9 @@
 /**
  * @file
  *
- * @ingroup lpc24xx
+ * @ingroup lpc24xx_io
  *
- * Input and output module.
+ * @brief Input and output module.
  */
 
 /*
@@ -20,10 +20,11 @@
  */
 
 #include <bsp/io.h>
+#include <bsp/system-clocks.h>
 
-#define LPC24XX_IO_SELECT( index) (index >> 4U)
+#define LPC24XX_IO_SELECT(pin) (pin >> 4U)
 
-#define LPC24XX_IO_SELECT_SHIFT( index) ((index & 0xfU) << 1U)
+#define LPC24XX_IO_SELECT_SHIFT(pin) ((pin & 0xfU) << 1U)
 
 #define LPC24XX_IO_SELECT_MASK 0x3U
 
@@ -35,169 +36,138 @@
 
 #define LPC24XX_IO_ALTERNATE_2 0x3U
 
-#define LPC24XX_IO_HEADER_FLAG 0x80U
-
-#define LPC24XX_IO_ENTRY( b, e, f) \
-  { .function = f, .begin = b, .end = e }
-
-#define LPC24XX_IO_HEADER( module, index, config) \
-  { .function = config | LPC24XX_IO_HEADER_FLAG, .begin = module, .end = index }
+#define LPC24XX_IO_ENTRY(mod, idx, cfg, begin_port, begin_index, last_port, last_index, function) \
+  { \
+    .module = mod, \
+    .index = idx, \
+    .config = cfg, \
+    .pin_begin = LPC24XX_IO_INDEX_BY_PORT(begin_port, begin_index), \
+    .pin_last = LPC24XX_IO_INDEX_BY_PORT(last_port, last_index), \
+    .pin_function = function \
+  }
 
-typedef struct  __attribute__ ((__packed__)) {
-  unsigned char function;
-  unsigned char begin;
-  unsigned char end;
+typedef struct {
+  unsigned module : 5;
+  unsigned index : 4;
+  unsigned config : 4;
+  unsigned pin_begin : 8;
+  unsigned pin_last : 8;
+  unsigned pin_function : 3;
 } lpc24xx_io_entry;
 
-typedef void (*lpc24xx_io_iterate_routine)( unsigned /* index */, unsigned /* function */);
+typedef void (*lpc24xx_io_iterate_routine)(unsigned /* pin */, unsigned /* function */);
 
 static const lpc24xx_io_entry lpc24xx_io_config_table [] = {
-  /* EMC */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_EMC, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 16), LPC24XX_IO_INDEX_BY_PORT( 2, 22), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 24), LPC24XX_IO_INDEX_BY_PORT( 2, 26), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 26), LPC24XX_IO_INDEX_BY_PORT( 2, 30), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 3, 0), LPC24XX_IO_INDEX_BY_PORT( 3, 16), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 4, 0), LPC24XX_IO_INDEX_BY_PORT( 4, 28), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 4, 30), LPC24XX_IO_INDEX_BY_PORT( 5, 0), LPC24XX_IO_ALTERNATE_0),
-
   /* UART */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 2), LPC24XX_IO_INDEX_BY_PORT( 0, 4), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 1, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 15), LPC24XX_IO_INDEX_BY_PORT( 0, 17), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 1, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 0), LPC24XX_IO_INDEX_BY_PORT( 2, 2), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 1, 2),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 3, 16), LPC24XX_IO_INDEX_BY_PORT( 3, 18), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 2, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 10), LPC24XX_IO_INDEX_BY_PORT( 0, 12), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 2, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 8), LPC24XX_IO_INDEX_BY_PORT( 2, 10), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 2, 2),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 4, 22), LPC24XX_IO_INDEX_BY_PORT( 4, 24), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 3, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 0), LPC24XX_IO_INDEX_BY_PORT( 0, 2), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 3, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 25), LPC24XX_IO_INDEX_BY_PORT( 0, 27), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_UART, 3, 2),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 4, 28), LPC24XX_IO_INDEX_BY_PORT( 4, 30), LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 0, 0, 0, 2, 0, 3, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 0, 0, 15, 0, 16, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 1, 2, 0, 2, 1, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 2, 3, 16, 3, 17, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 1, 2, 8, 2, 9, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 2, 4, 22, 4, 23, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 1, 0, 25, 0, 26, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 2, 4, 28, 4, 29, LPC24XX_IO_ALTERNATE_2),
 
   /* Ethernet */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_ETHERNET, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 0), LPC24XX_IO_INDEX_BY_PORT( 1, 18), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_ETHERNET, 0, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 0), LPC24XX_IO_INDEX_BY_PORT( 1, 2), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 4), LPC24XX_IO_INDEX_BY_PORT( 1, 5), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 8), LPC24XX_IO_INDEX_BY_PORT( 1, 11), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 14), LPC24XX_IO_INDEX_BY_PORT( 1, 18), LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 0, 1, 0, 1, 17, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 0, 1, 1, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 4, 1, 4, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 8, 1, 10, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 14, 1, 17, LPC24XX_IO_ALTERNATE_0),
 
   /* ADC */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_ADC, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 12), LPC24XX_IO_INDEX_BY_PORT( 0, 14), LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ADC, 0, 0, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_2),
 
   /* I2C */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 27), LPC24XX_IO_INDEX_BY_PORT( 0, 29), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 1, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 0), LPC24XX_IO_INDEX_BY_PORT( 0, 2), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 1, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 19), LPC24XX_IO_INDEX_BY_PORT( 0, 21), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 1, 2),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 14), LPC24XX_IO_INDEX_BY_PORT( 2, 16), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 2, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 10), LPC24XX_IO_INDEX_BY_PORT( 0, 12), LPC24XX_IO_ALTERNATE_1),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 2, 1),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 2, 30), LPC24XX_IO_INDEX_BY_PORT( 3, 0), LPC24XX_IO_ALTERNATE_2),
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_I2C, 2, 2),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 4, 20), LPC24XX_IO_INDEX_BY_PORT( 4, 22), LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 0, 0, 0, 27, 0, 28, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 1, 0, 19, 0, 20, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 2, 2, 14, 2, 15, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 1, 2, 30, 2, 31, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 2, 4, 20, 4, 21, LPC24XX_IO_ALTERNATE_1),
+
+  /* SSP */
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 0, 0, 15, 0, 18, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 1, 1, 20, 0, 21, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 1, 1, 23, 0, 24, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 2, 2, 22, 2, 23, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 2, 2, 26, 2, 27, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 0, 0, 6, 0, 9, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 0, 14, 0, 14, LPC24XX_IO_ALTERNATE_2),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 1, 31, 1, 31, LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 2, 4, 20, 4, 23, LPC24XX_IO_ALTERNATE_2),
 
   /* USB */
-  LPC24XX_IO_HEADER( LPC24XX_MODULE_USB, 0, 0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 0, 29), LPC24XX_IO_INDEX_BY_PORT( 0, 31), LPC24XX_IO_ALTERNATE_0),
-  LPC24XX_IO_ENTRY( LPC24XX_IO_INDEX_BY_PORT( 1, 19), LPC24XX_IO_INDEX_BY_PORT( 1, 20), LPC24XX_IO_ALTERNATE_1),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 0, 0, 29, 0, 30, LPC24XX_IO_ALTERNATE_0),
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 0, 1, 19, 1, 19, LPC24XX_IO_ALTERNATE_1),
+
+  /* Terminate */
+  LPC24XX_IO_ENTRY(LPC24XX_MODULE_COUNT, 0, 0, 0, 0, 0, 0, 0),
 };
 
-static size_t lpc24xx_io_get_entry_index( lpc24xx_module module, unsigned index, unsigned config)
+static rtems_status_code lpc24xx_io_iterate(
+  lpc24xx_module module,
+  unsigned index,
+  unsigned config,
+  lpc24xx_io_iterate_routine routine
+)
 {
-  size_t i = 0;
+  rtems_status_code sc = RTEMS_INVALID_ID;
+  const lpc24xx_io_entry *e = &lpc24xx_io_config_table [0];
 
-  config |= LPC24XX_IO_HEADER_FLAG;
+  while (e->module != LPC24XX_MODULE_COUNT) {
+    if (e->module == module && e->index == index && e->config == config) {
+      unsigned pin = e->pin_begin;
+      unsigned last = e->pin_last;
+      unsigned function = e->pin_function;
 
-  for (i = 0; i < sizeof( lpc24xx_io_config_table); ++i) {
-    const lpc24xx_io_entry *e = lpc24xx_io_config_table + i;
+      while (pin <= last) {
+        (*routine)(pin, function);
 
-    if (e->function == config && e->begin == module && e->end == index) {
-      return i + 1;
+        ++pin;
+      }
+
+      sc = RTEMS_SUCCESSFUL;
     }
+    ++e;
   }
 
-  return (size_t) -1;
+  return sc;
 }
 
-static void lpc24xx_io_do_config( unsigned index, unsigned function)
+static void lpc24xx_io_do_config(unsigned pin, unsigned function)
 {
   rtems_interrupt_level level;
-  unsigned select = LPC24XX_IO_SELECT( index);
-  unsigned shift = LPC24XX_IO_SELECT_SHIFT( index);
+  unsigned select = LPC24XX_IO_SELECT(pin);
+  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
 
-  rtems_interrupt_disable( level);
+  rtems_interrupt_disable(level);
 
   LPC24XX_PINSEL [select] =
     (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
       | ((function & LPC24XX_IO_SELECT_MASK) << shift);
 
-  rtems_interrupt_flash( level);
+  rtems_interrupt_flash(level);
 
   LPC24XX_PINMODE [select] &= ~(LPC24XX_IO_SELECT_MASK << shift);
 
-  rtems_interrupt_enable( level);
+  rtems_interrupt_enable(level);
 }
 
-static void lpc24xx_io_do_release( unsigned index, unsigned function)
+static void lpc24xx_io_do_release(unsigned pin, unsigned function)
 {
   rtems_interrupt_level level;
-  unsigned select = LPC24XX_IO_SELECT( index);
-  unsigned shift = LPC24XX_IO_SELECT_SHIFT( index);
+  unsigned select = LPC24XX_IO_SELECT(pin);
+  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
 
-  rtems_interrupt_disable( level);
+  rtems_interrupt_disable(level);
   LPC24XX_PINSEL [select] =
     (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift));
-  rtems_interrupt_enable( level);
-}
-
-static rtems_status_code lpc24xx_io_iterate(
-  lpc24xx_module module,
-  unsigned index,
-  unsigned config,
-  lpc24xx_io_iterate_routine routine
-)
-{
-  size_t i = lpc24xx_io_get_entry_index( module, index, config);
-
-  if (i != (size_t) -1) {
-    const lpc24xx_io_entry * const table_end = lpc24xx_io_config_table
-      + sizeof( lpc24xx_io_config_table) / sizeof( lpc24xx_io_config_table [0]);
-    const lpc24xx_io_entry *e = lpc24xx_io_config_table + i;
-
-    while (e != table_end && (e->function & LPC24XX_IO_HEADER_FLAG) == 0) {
-      unsigned j = e->begin;
-      unsigned end = e->end;
-      unsigned function = e->function;
-
-      while (j < end) {
-        routine( j, function);
-
-        ++j;
-      }
-
-      ++e;
-    }
-  } else {
-    return RTEMS_INVALID_ID;
-  }
-
-  return RTEMS_SUCCESSFUL;
+  rtems_interrupt_enable(level);
 }
 
 rtems_status_code lpc24xx_io_config(
@@ -206,7 +176,7 @@ rtems_status_code lpc24xx_io_config(
   unsigned config
 )
 {
-  return lpc24xx_io_iterate( module, index, config, lpc24xx_io_do_config);
+  return lpc24xx_io_iterate(module, index, config, lpc24xx_io_do_config);
 }
 
 rtems_status_code lpc24xx_io_release(
@@ -215,20 +185,20 @@ rtems_status_code lpc24xx_io_release(
   unsigned config
 )
 {
-  return lpc24xx_io_iterate( module, index, config, lpc24xx_io_do_release);
+  return lpc24xx_io_iterate(module, index, config, lpc24xx_io_do_release);
 }
 
 rtems_status_code lpc24xx_gpio_config(
-  unsigned index,
+  unsigned pin,
   lpc24xx_gpio_settings settings
 )
 {
-  if (index <= LPC24XX_IO_INDEX_MAX) {
+  if (pin <= LPC24XX_IO_INDEX_MAX) {
     rtems_interrupt_level level;
-    unsigned port = LPC24XX_IO_PORT( index);
-    unsigned bit = LPC24XX_IO_PORT_BIT( index);
-    unsigned select = LPC24XX_IO_SELECT( index);
-    unsigned shift = LPC24XX_IO_SELECT_SHIFT( index);
+    unsigned port = LPC24XX_IO_PORT(pin);
+    unsigned bit = LPC24XX_IO_PORT_BIT(pin);
+    unsigned select = LPC24XX_IO_SELECT(pin);
+    unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
     unsigned resistor = settings & LPC24XX_GPIO_RESISTOR_MASK;
     unsigned output = (settings & LPC24XX_GPIO_OUTPUT) != 0 ? 1U : 0U;
 
@@ -248,20 +218,20 @@ rtems_status_code lpc24xx_gpio_config(
         return RTEMS_INVALID_NUMBER;
     }
 
-    rtems_interrupt_disable( level);
+    rtems_interrupt_disable(level);
 
     /* Resistor */
     LPC24XX_PINMODE [select] =
       (LPC24XX_PINMODE [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
         | ((resistor & LPC24XX_IO_SELECT_MASK) << shift); 
 
-    rtems_interrupt_flash( level);
+    rtems_interrupt_flash(level);
 
     /* Input or output */
     LPC24XX_FIO [port].dir =
       (LPC24XX_FIO [port].dir & ~(1U << bit)) | (output << bit);
 
-    rtems_interrupt_enable( level);
+    rtems_interrupt_enable(level);
   } else {
     return RTEMS_INVALID_ID;
   }
@@ -445,12 +415,12 @@ static rtems_status_code lpc24xx_module_do_enable(
   if (enable) {
     rtems_interrupt_level level;
 
-    rtems_interrupt_disable( level);
+    rtems_interrupt_disable(level);
     PCONP |= 1U << power_bit;
-    rtems_interrupt_enable( level);
+    rtems_interrupt_enable(level);
 
     if (module != LPC24XX_MODULE_USB) {
-      rtems_interrupt_disable( level);
+      rtems_interrupt_disable(level);
       if (clock_shift < 32U) {
         PCLKSEL0 = (PCLKSEL0 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
             | (clock << clock_shift);
@@ -459,7 +429,7 @@ static rtems_status_code lpc24xx_module_do_enable(
         PCLKSEL1 = (PCLKSEL1 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
             | (clock << clock_shift);
       }
-      rtems_interrupt_enable( level);
+      rtems_interrupt_enable(level);
     } else {
       unsigned pllclk = lpc24xx_pllclk();
       unsigned usbsel = pllclk / 48000000U - 1U;
@@ -473,9 +443,9 @@ static rtems_status_code lpc24xx_module_do_enable(
   } else {
     rtems_interrupt_level level;
 
-    rtems_interrupt_disable( level);
+    rtems_interrupt_disable(level);
     PCONP &= ~(1U << power_bit);
-    rtems_interrupt_enable( level);
+    rtems_interrupt_enable(level);
   }
 
   return RTEMS_SUCCESSFUL;
@@ -487,7 +457,7 @@ rtems_status_code lpc24xx_module_enable(
   lpc24xx_module_clock clock
 )
 {
-  return lpc24xx_module_do_enable( module, index, clock, true);
+  return lpc24xx_module_do_enable(module, index, clock, true);
 }
 
 rtems_status_code lpc24xx_module_disable(
@@ -495,5 +465,5 @@ rtems_status_code lpc24xx_module_disable(
   unsigned index
 )
 {
-  return lpc24xx_module_do_enable( module, index, 0U, false);
+  return lpc24xx_module_do_enable(module, index, 0U, false);
 }
diff --git a/c/src/lib/libbsp/arm/lpc24xx/misc/system-clocks.c b/c/src/lib/libbsp/arm/lpc24xx/misc/system-clocks.c
index d470295211..110e9aef15 100644
--- a/c/src/lib/libbsp/arm/lpc24xx/misc/system-clocks.c
+++ b/c/src/lib/libbsp/arm/lpc24xx/misc/system-clocks.c
@@ -1,7 +1,7 @@
 /**
  * @file
  *
- * @ingroup lpc24xx
+ * @ingroup lpc24xx_clocks
  *
  * @brief System clocks.
  */
@@ -36,45 +36,44 @@
   #error "unknown RTC oscillator frequency"
 #endif
 
-/**
- * @brief Delay for @a us micro seconds.
- *
- * @note Uses Timer 1.
- */
-void lpc24xx_micro_seconds_delay( unsigned us)
+void lpc24xx_timer_initialize(void)
 {
-  /* Stop and reset timer */
-  T1TCR = 0x02;
+  /* Reset timer */
+  T1TCR = TCR_RST;
+
+  /* Set timer mode */
+  T1CTCR = 0;
 
   /* Set prescaler to zero */
-  T1PR = 0x00;
-  
-  /* Set match value */
-  T1MR0 = (uint32_t) ((uint64_t) 4000000 * (uint64_t) us / (uint64_t) lpc24xx_cclk()) + 1;
+  T1PR = 0;
 
   /* Reset all interrupt flags */
   T1IR = 0xff;
 
-  /* Stop timer on match */
-  T1MCR = 0x04;
+  /* Do not stop on a match */
+  T1MCR = 0;
+
+  /* No captures */
+  T1CCR = 0;
 
   /* Start timer */
-  T1TCR = 0x01;
-  
-  /* Wait until delay time has elapsed */
-  while ((T1TCR & 0x01) != 0) {
-    /* Wait */
-  }
+  T1TCR = TCR_EN;
 }
 
-/**
- * @brief Returns the PLL output clock frequency in [Hz].
- *
- * Returns zero in case of an unexpected PLL input frequency.
- */
-unsigned lpc24xx_pllclk( void)
+void lpc24xx_micro_seconds_delay(unsigned us)
+{
+  unsigned start = lpc24xx_timer();
+  unsigned end = start + us * (lpc24xx_cclk() / 1000000);
+  unsigned now = 0;
+
+  do {
+    now = lpc24xx_timer();
+  } while (now < end);
+}
+
+unsigned lpc24xx_pllclk(void)
 {
-  unsigned clksrc = GET_CLKSRCSEL_CLKSRC( CLKSRCSEL);
+  unsigned clksrc = GET_CLKSRCSEL_CLKSRC(CLKSRCSEL);
   unsigned pllinclk = 0;
   unsigned pllclk = 0;
 
@@ -94,10 +93,10 @@ unsigned lpc24xx_pllclk( void)
   }
 
   /* Get PLL output frequency */
-  if (IS_FLAG_SET( PLLSTAT, PLLSTAT_PLLC)) {
+  if (IS_FLAG_SET(PLLSTAT, PLLSTAT_PLLC)) {
     uint32_t pllcfg = PLLCFG;
-    unsigned n = GET_PLLCFG_NSEL( pllcfg) + 1;
-    unsigned m = GET_PLLCFG_MSEL( pllcfg) + 1;
+    unsigned n = GET_PLLCFG_NSEL(pllcfg) + 1;
+    unsigned m = GET_PLLCFG_MSEL(pllcfg) + 1;
 
     pllclk = (pllinclk / n) * 2 * m;
   } else {
@@ -107,81 +106,13 @@ unsigned lpc24xx_pllclk( void)
   return pllclk;
 }
 
-/**
- * @brief Returns the CPU clock frequency in [Hz].
- *
- * Returns zero in case of an unexpected PLL input frequency.
- */
-unsigned lpc24xx_cclk( void)
+unsigned lpc24xx_cclk(void)
 {
   /* Get PLL output frequency */
   unsigned pllclk = lpc24xx_pllclk();
 
   /* Get CPU frequency */
-  unsigned cclk = pllclk / (GET_CCLKCFG_CCLKSEL( CCLKCFG) + 1);
+  unsigned cclk = pllclk / (GET_CCLKCFG_CCLKSEL(CCLKCFG) + 1);
 
   return cclk;
 }
-
-static void lpc24xx_pll_config( uint32_t val)
-{
-  PLLCON = val;
-  PLLFEED = 0xaa;
-  PLLFEED = 0x55;
-}
-
-/**
- * @brief Sets the Phase Locked Loop (PLL).
- *
- * @param clksrc Selects the clock source for the PLL.
- *
- * @param nsel Selects PLL pre-divider value (sometimes named psel).
- *
- * @param msel Selects PLL multiplier value.
- *
- * @param cclksel Selects the divide value for creating the CPU clock (CCLK)
- * from the PLL output.
- *
- * @note All parameter values are the actual register field values.
- */
-void lpc24xx_set_pll( unsigned clksrc, unsigned nsel, unsigned msel, unsigned cclksel)
-{
-  bool pll_enabled = IS_FLAG_SET( PLLSTAT, PLLSTAT_PLLE);
-
-  /* Disconnect PLL if necessary */
-  if (IS_FLAG_SET( PLLSTAT, PLLSTAT_PLLC)) {
-    if (pll_enabled) {
-      lpc24xx_pll_config( PLLCON_PLLE);
-    } else {
-      lpc24xx_pll_config( 0);
-    }
-  }
-
-  /* Set CPU clock divider to a reasonable save value */
-  CCLKCFG = 0;
-
-  /* Disable PLL if necessary */
-  if (pll_enabled) {
-    lpc24xx_pll_config( 0);
-  }
-
-  /* Select clock source */
-  CLKSRCSEL = SET_CLKSRCSEL_CLKSRC( 0, clksrc);
-
-  /* Set PLL Configuration Register */
-  PLLCFG = SET_PLLCFG_NSEL( 0, nsel) | SET_PLLCFG_MSEL( 0, msel);
-
-  /* Enable PLL */
-  lpc24xx_pll_config( PLLCON_PLLE);
-
-  /* Wait for lock */
-  while (IS_FLAG_CLEARED( PLLSTAT, PLLSTAT_PLOCK)) {
-    /* Wait */
-  }
-
-  /* Set CPU clock divider and ensure that we have an odd value */
-  CCLKCFG = SET_CCLKCFG_CCLKSEL( 0, cclksel | 1);
-
-  /* Connect PLL */
-  lpc24xx_pll_config( PLLCON_PLLE | PLLCON_PLLC);
-}