source: rtems/c/src/lib/libbsp/arm/lpc24xx/misc/io.c @ d267a8a0

4.115
Last change on this file since d267a8a0 was d267a8a0, checked in by Sebastian Huber <sebastian.huber@…>, on Oct 14, 2010 at 6:52:46 AM

2010-10-14 Sebastian Huber <sebastian.huber@…>

  • misc/system-clocks.c: Fixed lpc24xx_micro_seconds_delay().
  • Property mode set to 100644
File size: 12.2 KB
Line 
1/**
2 * @file
3 *
4 * @ingroup lpc24xx_io
5 *
6 * @brief Input and output module.
7 */
8
9/*
10 * Copyright (c) 2009, 2010
11 * embedded brains GmbH
12 * Obere Lagerstr. 30
13 * D-82178 Puchheim
14 * Germany
15 * <rtems@embedded-brains.de>
16 *
17 * The license and distribution terms for this file may be
18 * found in the file LICENSE in this distribution or at
19 * http://www.rtems.com/license/LICENSE.
20 */
21
22#include <bsp/io.h>
23#include <bsp/system-clocks.h>
24
25#define LPC24XX_IO_SELECT(pin) (pin >> 4U)
26
27#define LPC24XX_IO_SELECT_SHIFT(pin) ((pin & 0xfU) << 1U)
28
29#define LPC24XX_IO_SELECT_MASK 0x3U
30
31#define LPC24XX_IO_PRIMARY 0x0U
32
33#define LPC24XX_IO_ALTERNATE_0 0x1U
34
35#define LPC24XX_IO_ALTERNATE_1 0x2U
36
37#define LPC24XX_IO_ALTERNATE_2 0x3U
38
39#define LPC24XX_IO_ENTRY(mod, cfg, begin_port, begin_index, last_port, last_index, function) \
40  { \
41    .module = mod, \
42    .config = cfg, \
43    .pin_begin = LPC24XX_IO_INDEX_BY_PORT(begin_port, begin_index), \
44    .pin_last = LPC24XX_IO_INDEX_BY_PORT(last_port, last_index), \
45    .pin_function = function \
46  }
47
48typedef struct {
49  unsigned module : 6;
50  unsigned config : 4;
51  unsigned pin_begin : 8;
52  unsigned pin_last : 8;
53  unsigned pin_function : 3;
54} lpc24xx_io_entry;
55
56typedef void (*lpc24xx_io_iterate_routine)(unsigned /* pin */, unsigned /* function */);
57
58static const lpc24xx_io_entry lpc24xx_io_config_table [] = {
59  /* UART */
60  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_0, 0, 0, 2, 0, 3, LPC24XX_IO_ALTERNATE_0),
61  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_1, 0, 0, 15, 0, 16, LPC24XX_IO_ALTERNATE_0),
62  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_1, 1, 2, 0, 2, 1, LPC24XX_IO_ALTERNATE_1),
63  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_1, 2, 3, 16, 3, 17, LPC24XX_IO_ALTERNATE_2),
64  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_0),
65  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_2, 1, 2, 8, 2, 9, LPC24XX_IO_ALTERNATE_1),
66  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_2, 2, 4, 22, 4, 23, LPC24XX_IO_ALTERNATE_1),
67  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_3, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_1),
68  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_3, 1, 0, 25, 0, 26, LPC24XX_IO_ALTERNATE_2),
69  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART_3, 2, 4, 28, 4, 29, LPC24XX_IO_ALTERNATE_2),
70
71  /* Ethernet */
72  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 0, 1, 17, LPC24XX_IO_ALTERNATE_0),
73  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 1, 1, 0, 1, 1, LPC24XX_IO_ALTERNATE_0),
74  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 1, 1, 4, 1, 4, LPC24XX_IO_ALTERNATE_0),
75  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 1, 1, 8, 1, 10, LPC24XX_IO_ALTERNATE_0),
76  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 1, 1, 14, 1, 17, LPC24XX_IO_ALTERNATE_0),
77
78  /* ADC */
79  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ADC, 0, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_2),
80  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ADC, 1, 0, 23, 0, 25, LPC24XX_IO_ALTERNATE_0),
81
82  /* I2C */
83  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_0, 0, 0, 27, 0, 28, LPC24XX_IO_ALTERNATE_0),
84  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_1, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_2),
85  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_1, 1, 0, 19, 0, 20, LPC24XX_IO_ALTERNATE_2),
86  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_1, 2, 2, 14, 2, 15, LPC24XX_IO_ALTERNATE_2),
87  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_1),
88  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_2, 1, 2, 30, 2, 31, LPC24XX_IO_ALTERNATE_2),
89  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C_2, 2, 4, 20, 4, 21, LPC24XX_IO_ALTERNATE_1),
90
91  /* SSP */
92  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_0, 0, 0, 15, 0, 18, LPC24XX_IO_ALTERNATE_1),
93  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_0, 1, 1, 20, 0, 21, LPC24XX_IO_ALTERNATE_2),
94  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_0, 1, 1, 23, 0, 24, LPC24XX_IO_ALTERNATE_2),
95  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_0, 2, 2, 22, 2, 23, LPC24XX_IO_ALTERNATE_2),
96  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_0, 2, 2, 26, 2, 27, LPC24XX_IO_ALTERNATE_2),
97  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_1, 0, 0, 6, 0, 9, LPC24XX_IO_ALTERNATE_1),
98  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_1, 1, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_1),
99  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_1, 1, 0, 14, 0, 14, LPC24XX_IO_ALTERNATE_2),
100  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_1, 1, 1, 31, 1, 31, LPC24XX_IO_ALTERNATE_1),
101  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP_1, 2, 4, 20, 4, 23, LPC24XX_IO_ALTERNATE_2),
102
103  /* USB */
104  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 0, 29, 0, 30, LPC24XX_IO_ALTERNATE_0),
105  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 1, 19, 1, 19, LPC24XX_IO_ALTERNATE_1),
106
107  /* SPI */
108  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SPI, 0, 0, 15, 0, 18, LPC24XX_IO_ALTERNATE_2),
109
110  /* PWM */
111  LPC24XX_IO_ENTRY(LPC24XX_MODULE_PWM_1, 0, 2, 0, 2, 0, LPC24XX_IO_ALTERNATE_0),
112
113  /* LCD */
114  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 0, 4, 0, 9, LPC24XX_IO_ALTERNATE_0),
115  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 1, 20, 1, 29, LPC24XX_IO_ALTERNATE_0),
116  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 2, 0, 2, 3, LPC24XX_IO_ALTERNATE_2),
117  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 2, 5, 2, 9, LPC24XX_IO_ALTERNATE_2),
118  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 2, 12, 2, 13, LPC24XX_IO_ALTERNATE_0),
119  LPC24XX_IO_ENTRY(LPC24XX_MODULE_LCD, 0, 4, 28, 4, 29, LPC24XX_IO_ALTERNATE_1),
120
121  /* Terminate */
122  LPC24XX_IO_ENTRY(LPC24XX_MODULE_COUNT, 0, 0, 0, 0, 0, 0)
123};
124
125static rtems_status_code lpc24xx_io_iterate(
126  lpc24xx_module module,
127  unsigned config,
128  lpc24xx_io_iterate_routine routine
129)
130{
131  rtems_status_code sc = RTEMS_INVALID_ID;
132  const lpc24xx_io_entry *e = &lpc24xx_io_config_table [0];
133
134  while (e->module != LPC24XX_MODULE_COUNT) {
135    if (e->module == module && e->config == config) {
136      unsigned pin = e->pin_begin;
137      unsigned last = e->pin_last;
138      unsigned function = e->pin_function;
139
140      while (pin <= last) {
141        (*routine)(pin, function);
142
143        ++pin;
144      }
145
146      sc = RTEMS_SUCCESSFUL;
147    }
148    ++e;
149  }
150
151  return sc;
152}
153
154static void lpc24xx_io_do_config(unsigned pin, unsigned function)
155{
156  rtems_interrupt_level level;
157  unsigned select = LPC24XX_IO_SELECT(pin);
158  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
159
160  rtems_interrupt_disable(level);
161
162  LPC24XX_PINSEL [select] =
163    (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
164      | ((function & LPC24XX_IO_SELECT_MASK) << shift);
165
166  rtems_interrupt_flash(level);
167
168  LPC24XX_PINMODE [select] &= ~(LPC24XX_IO_SELECT_MASK << shift);
169
170  rtems_interrupt_enable(level);
171}
172
173static void lpc24xx_io_do_release(unsigned pin, unsigned function)
174{
175  rtems_interrupt_level level;
176  unsigned select = LPC24XX_IO_SELECT(pin);
177  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
178
179  rtems_interrupt_disable(level);
180  LPC24XX_PINSEL [select] =
181    (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift));
182  rtems_interrupt_enable(level);
183}
184
185rtems_status_code lpc24xx_io_config(
186  lpc24xx_module module,
187  unsigned config
188)
189{
190  return lpc24xx_io_iterate(module, config, lpc24xx_io_do_config);
191}
192
193rtems_status_code lpc24xx_io_release(
194  lpc24xx_module module,
195  unsigned config
196)
197{
198  return lpc24xx_io_iterate(module, config, lpc24xx_io_do_release);
199}
200
201rtems_status_code lpc24xx_gpio_config(
202  unsigned pin,
203  lpc24xx_gpio_settings settings
204)
205{
206  if (pin <= LPC24XX_IO_INDEX_MAX) {
207    rtems_interrupt_level level;
208    unsigned port = LPC24XX_IO_PORT(pin);
209    unsigned bit = LPC24XX_IO_PORT_BIT(pin);
210    unsigned select = LPC24XX_IO_SELECT(pin);
211    unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
212    unsigned resistor = settings & LPC24XX_GPIO_RESISTOR_MASK;
213    unsigned output = (settings & LPC24XX_GPIO_OUTPUT) != 0 ? 1U : 0U;
214
215    /* Get resistor flags */
216    switch (resistor) {
217      case LPC24XX_GPIO_RESISTOR_PULL_UP:
218      case LPC24XX_GPIO_RESISTOR_DEFAULT:
219        resistor = 0x0U;
220        break;
221      case LPC24XX_GPIO_RESISTOR_NONE:
222        resistor = 0x2U;
223        break;
224      case LPC24XX_GPIO_RESISTOR_PULL_DOWN:
225        resistor = 0x3U;
226        break;
227      default:
228        return RTEMS_INVALID_NUMBER;
229    }
230
231    rtems_interrupt_disable(level);
232
233    /* Resistor */
234    LPC24XX_PINMODE [select] =
235      (LPC24XX_PINMODE [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
236        | ((resistor & LPC24XX_IO_SELECT_MASK) << shift);
237
238    rtems_interrupt_flash(level);
239
240    /* Input or output */
241    LPC24XX_FIO [port].dir =
242      (LPC24XX_FIO [port].dir & ~(1U << bit)) | (output << bit);
243
244    rtems_interrupt_enable(level);
245  } else {
246    return RTEMS_INVALID_ID;
247  }
248
249  return RTEMS_SUCCESSFUL;
250}
251
252#define LPC24XX_MODULE_ENTRY(mod, pwr, clk, idx) \
253  [mod] = { \
254    .power = pwr, \
255    .clock = clk, \
256    .index = idx \
257  }
258
259typedef struct {
260  unsigned char power : 1;
261  unsigned char clock : 1;
262  unsigned char index : 6;
263} lpc24xx_module_entry;
264
265static const lpc24xx_module_entry lpc24xx_module_table [] = {
266  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_ACF, 0, 1, 15),
267  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_ADC, 1, 1, 12),
268  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_BAT_RAM, 0, 1, 16),
269  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_CAN_0, 1, 1, 13),
270  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_CAN_1, 1, 1, 14),
271  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_DAC, 0, 1, 11),
272  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_EMC, 1, 0, 11),
273  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_ETHERNET, 1, 0, 30),
274  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_GPDMA, 1, 1, 29),
275  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_GPIO, 0, 1, 17),
276  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_I2C_0, 1, 1, 7),
277  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_I2C_1, 1, 1, 19),
278  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_I2C_2, 1, 1, 26),
279  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_I2S, 1, 1, 27),
280  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_LCD, 1, 1, 20),
281  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_MCI, 1, 1, 28),
282  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_PCB, 0, 1, 18),
283  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_PWM_0, 1, 1, 5),
284  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_PWM_1, 1, 1, 6),
285  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_RTC, 1, 1, 9),
286  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_SPI, 1, 1, 8),
287  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_SSP_0, 1, 1, 21),
288  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_SSP_1, 1, 1, 10),
289  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_SYSCON, 0, 1, 30),
290  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_TIMER_0, 1, 1, 1),
291  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_TIMER_1, 1, 1, 2),
292  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_TIMER_2, 1, 1, 22),
293  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_TIMER_3, 1, 1, 23),
294  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_UART_0, 1, 1, 3),
295  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_UART_1, 1, 1, 4),
296  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_UART_2, 1, 1, 24),
297  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_UART_3, 1, 1, 25),
298  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_USB, 1, 0, 31),
299  LPC24XX_MODULE_ENTRY(LPC24XX_MODULE_WDT, 0, 1, 0)
300};
301
302static rtems_status_code lpc24xx_module_do_enable(
303  lpc24xx_module module,
304  lpc24xx_module_clock clock,
305  bool enable
306)
307{
308  rtems_interrupt_level level;
309  bool has_power = false;
310  bool has_clock = false;
311  unsigned index = 0;
312
313  if ((unsigned) module >= LPC24XX_MODULE_COUNT) {
314      return RTEMS_INVALID_ID;
315  }
316
317  if ((clock & ~LPC24XX_MODULE_CLOCK_MASK) != 0U) {
318    return RTEMS_INVALID_NUMBER;
319  }
320
321  has_power = lpc24xx_module_table [module].power;
322  has_clock = lpc24xx_module_table [module].clock;
323  index = lpc24xx_module_table [module].index;
324
325  /* Enable or disable module */
326  if (enable) {
327    if (has_power) {
328      rtems_interrupt_disable(level);
329      PCONP |= 1U << index;
330      rtems_interrupt_enable(level);
331    }
332
333    if (module != LPC24XX_MODULE_USB) {
334      if (has_clock) {
335        unsigned clock_shift = 2U * index;
336
337        rtems_interrupt_disable(level);
338        if (clock_shift < 32U) {
339          PCLKSEL0 = (PCLKSEL0 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
340              | (clock << clock_shift);
341        } else {
342          clock_shift -= 32U;
343          PCLKSEL1 = (PCLKSEL1 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
344              | (clock << clock_shift);
345        }
346        rtems_interrupt_enable(level);
347      }
348    } else {
349      unsigned pllclk = lpc24xx_pllclk();
350      unsigned usbsel = pllclk / 48000000U - 1U;
351
352      if (usbsel > 15U || (usbsel % 2U != 1U) || (pllclk % 48000000U) != 0U) {
353        return RTEMS_INCORRECT_STATE;
354      }
355
356      USBCLKCFG = usbsel;
357    }
358  } else {
359    if (has_power) {
360      rtems_interrupt_disable(level);
361      PCONP &= ~(1U << index);
362      rtems_interrupt_enable(level);
363    }
364  }
365
366  return RTEMS_SUCCESSFUL;
367}
368
369rtems_status_code lpc24xx_module_enable(
370  lpc24xx_module module,
371  lpc24xx_module_clock clock
372)
373{
374  return lpc24xx_module_do_enable(module, clock, true);
375}
376
377rtems_status_code lpc24xx_module_disable(
378  lpc24xx_module module
379)
380{
381  return lpc24xx_module_do_enable(module, 0U, false);
382}
Note: See TracBrowser for help on using the repository browser.