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

4.104.115
Last change on this file since ba938b8 was ba938b8, checked in by Thomas Doerfler <Thomas.Doerfler@…>, on Sep 18, 2009 at 8:05:40 AM

Changes throughout.

  • Property mode set to 100644
File size: 12.4 KB
Line 
1/**
2 * @file
3 *
4 * @ingroup lpc24xx_io
5 *
6 * @brief Input and output module.
7 */
8
9/*
10 * Copyright (c) 2009
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, idx, cfg, begin_port, begin_index, last_port, last_index, function) \
40  { \
41    .module = mod, \
42    .index = idx, \
43    .config = cfg, \
44    .pin_begin = LPC24XX_IO_INDEX_BY_PORT(begin_port, begin_index), \
45    .pin_last = LPC24XX_IO_INDEX_BY_PORT(last_port, last_index), \
46    .pin_function = function \
47  }
48
49typedef struct {
50  unsigned module : 5;
51  unsigned index : 4;
52  unsigned config : 4;
53  unsigned pin_begin : 8;
54  unsigned pin_last : 8;
55  unsigned pin_function : 3;
56} lpc24xx_io_entry;
57
58typedef void (*lpc24xx_io_iterate_routine)(unsigned /* pin */, unsigned /* function */);
59
60static const lpc24xx_io_entry lpc24xx_io_config_table [] = {
61  /* UART */
62  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 0, 0, 0, 2, 0, 3, LPC24XX_IO_ALTERNATE_0),
63  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 0, 0, 15, 0, 16, LPC24XX_IO_ALTERNATE_1),
64  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 1, 2, 0, 2, 1, LPC24XX_IO_ALTERNATE_2),
65  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 1, 2, 3, 16, 3, 17, LPC24XX_IO_ALTERNATE_1),
66  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_1),
67  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 1, 2, 8, 2, 9, LPC24XX_IO_ALTERNATE_1),
68  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 2, 2, 4, 22, 4, 23, LPC24XX_IO_ALTERNATE_1),
69  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_2),
70  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 1, 0, 25, 0, 26, LPC24XX_IO_ALTERNATE_2),
71  LPC24XX_IO_ENTRY(LPC24XX_MODULE_UART, 3, 2, 4, 28, 4, 29, LPC24XX_IO_ALTERNATE_2),
72
73  /* Ethernet */
74  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 0, 1, 0, 1, 17, LPC24XX_IO_ALTERNATE_0),
75  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 0, 1, 1, LPC24XX_IO_ALTERNATE_0),
76  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 4, 1, 4, LPC24XX_IO_ALTERNATE_0),
77  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 8, 1, 10, LPC24XX_IO_ALTERNATE_0),
78  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ETHERNET, 0, 1, 1, 14, 1, 17, LPC24XX_IO_ALTERNATE_0),
79
80  /* ADC */
81  LPC24XX_IO_ENTRY(LPC24XX_MODULE_ADC, 0, 0, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_2),
82
83  /* I2C */
84  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 0, 0, 0, 27, 0, 28, LPC24XX_IO_ALTERNATE_0),
85  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 0, 0, 0, 0, 1, LPC24XX_IO_ALTERNATE_2),
86  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 1, 0, 19, 0, 20, LPC24XX_IO_ALTERNATE_2),
87  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 1, 2, 2, 14, 2, 15, LPC24XX_IO_ALTERNATE_2),
88  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 0, 0, 10, 0, 11, LPC24XX_IO_ALTERNATE_1),
89  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 1, 2, 30, 2, 31, LPC24XX_IO_ALTERNATE_2),
90  LPC24XX_IO_ENTRY(LPC24XX_MODULE_I2C, 2, 2, 4, 20, 4, 21, LPC24XX_IO_ALTERNATE_1),
91
92  /* SSP */
93  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 0, 0, 15, 0, 18, LPC24XX_IO_ALTERNATE_1),
94  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 1, 1, 20, 0, 21, LPC24XX_IO_ALTERNATE_2),
95  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 1, 1, 23, 0, 24, LPC24XX_IO_ALTERNATE_2),
96  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 2, 2, 22, 2, 23, LPC24XX_IO_ALTERNATE_2),
97  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 0, 2, 2, 26, 2, 27, LPC24XX_IO_ALTERNATE_2),
98  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 0, 0, 6, 0, 9, LPC24XX_IO_ALTERNATE_1),
99  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 0, 12, 0, 13, LPC24XX_IO_ALTERNATE_1),
100  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 0, 14, 0, 14, LPC24XX_IO_ALTERNATE_2),
101  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 1, 1, 31, 1, 31, LPC24XX_IO_ALTERNATE_1),
102  LPC24XX_IO_ENTRY(LPC24XX_MODULE_SSP, 1, 2, 4, 20, 4, 23, LPC24XX_IO_ALTERNATE_2),
103
104  /* USB */
105  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 0, 0, 29, 0, 30, LPC24XX_IO_ALTERNATE_0),
106  LPC24XX_IO_ENTRY(LPC24XX_MODULE_USB, 0, 0, 1, 19, 1, 19, LPC24XX_IO_ALTERNATE_1),
107
108  /* Terminate */
109  LPC24XX_IO_ENTRY(LPC24XX_MODULE_COUNT, 0, 0, 0, 0, 0, 0, 0),
110};
111
112static rtems_status_code lpc24xx_io_iterate(
113  lpc24xx_module module,
114  unsigned index,
115  unsigned config,
116  lpc24xx_io_iterate_routine routine
117)
118{
119  rtems_status_code sc = RTEMS_INVALID_ID;
120  const lpc24xx_io_entry *e = &lpc24xx_io_config_table [0];
121
122  while (e->module != LPC24XX_MODULE_COUNT) {
123    if (e->module == module && e->index == index && e->config == config) {
124      unsigned pin = e->pin_begin;
125      unsigned last = e->pin_last;
126      unsigned function = e->pin_function;
127
128      while (pin <= last) {
129        (*routine)(pin, function);
130
131        ++pin;
132      }
133
134      sc = RTEMS_SUCCESSFUL;
135    }
136    ++e;
137  }
138
139  return sc;
140}
141
142static void lpc24xx_io_do_config(unsigned pin, unsigned function)
143{
144  rtems_interrupt_level level;
145  unsigned select = LPC24XX_IO_SELECT(pin);
146  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
147
148  rtems_interrupt_disable(level);
149
150  LPC24XX_PINSEL [select] =
151    (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
152      | ((function & LPC24XX_IO_SELECT_MASK) << shift);
153
154  rtems_interrupt_flash(level);
155
156  LPC24XX_PINMODE [select] &= ~(LPC24XX_IO_SELECT_MASK << shift);
157
158  rtems_interrupt_enable(level);
159}
160
161static void lpc24xx_io_do_release(unsigned pin, unsigned function)
162{
163  rtems_interrupt_level level;
164  unsigned select = LPC24XX_IO_SELECT(pin);
165  unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
166
167  rtems_interrupt_disable(level);
168  LPC24XX_PINSEL [select] =
169    (LPC24XX_PINSEL [select] & ~(LPC24XX_IO_SELECT_MASK << shift));
170  rtems_interrupt_enable(level);
171}
172
173rtems_status_code lpc24xx_io_config(
174  lpc24xx_module module,
175  unsigned index,
176  unsigned config
177)
178{
179  return lpc24xx_io_iterate(module, index, config, lpc24xx_io_do_config);
180}
181
182rtems_status_code lpc24xx_io_release(
183  lpc24xx_module module,
184  unsigned index,
185  unsigned config
186)
187{
188  return lpc24xx_io_iterate(module, index, config, lpc24xx_io_do_release);
189}
190
191rtems_status_code lpc24xx_gpio_config(
192  unsigned pin,
193  lpc24xx_gpio_settings settings
194)
195{
196  if (pin <= LPC24XX_IO_INDEX_MAX) {
197    rtems_interrupt_level level;
198    unsigned port = LPC24XX_IO_PORT(pin);
199    unsigned bit = LPC24XX_IO_PORT_BIT(pin);
200    unsigned select = LPC24XX_IO_SELECT(pin);
201    unsigned shift = LPC24XX_IO_SELECT_SHIFT(pin);
202    unsigned resistor = settings & LPC24XX_GPIO_RESISTOR_MASK;
203    unsigned output = (settings & LPC24XX_GPIO_OUTPUT) != 0 ? 1U : 0U;
204
205    /* Get resistor flags */
206    switch (resistor) {
207      case LPC24XX_GPIO_RESISTOR_PULL_UP:
208      case LPC24XX_GPIO_RESISTOR_DEFAULT:
209        resistor = 0x0U;
210        break;
211      case LPC24XX_GPIO_RESISTOR_NONE:
212        resistor = 0x2U;
213        break;
214      case LPC24XX_GPIO_RESISTOR_PULL_DOWN:
215        resistor = 0x3U;
216        break;
217      default:
218        return RTEMS_INVALID_NUMBER;
219    }
220
221    rtems_interrupt_disable(level);
222
223    /* Resistor */
224    LPC24XX_PINMODE [select] =
225      (LPC24XX_PINMODE [select] & ~(LPC24XX_IO_SELECT_MASK << shift))
226        | ((resistor & LPC24XX_IO_SELECT_MASK) << shift); 
227
228    rtems_interrupt_flash(level);
229
230    /* Input or output */
231    LPC24XX_FIO [port].dir =
232      (LPC24XX_FIO [port].dir & ~(1U << bit)) | (output << bit);
233
234    rtems_interrupt_enable(level);
235  } else {
236    return RTEMS_INVALID_ID;
237  }
238
239  return RTEMS_SUCCESSFUL;
240}
241
242static rtems_status_code lpc24xx_module_do_enable(
243  lpc24xx_module module,
244  unsigned index,
245  lpc24xx_module_clock clock,
246  bool enable
247)
248{
249  const unsigned NO_POWER = 32U;
250  const unsigned INVALID = 33U;
251  unsigned power_bit = INVALID;
252  unsigned clock_shift = INVALID;
253
254  /* Check clock value */
255  if ((clock & ~LPC24XX_MODULE_CLOCK_MASK) != 0U) {
256    return RTEMS_INVALID_NUMBER;
257  }
258
259  /* Get power bit */
260  switch (module) {
261    case LPC24XX_MODULE_ACF:
262      if (index == 0) {
263        power_bit = NO_POWER;
264        clock_shift = 30U;
265      }
266      break;
267    case LPC24XX_MODULE_ADC:
268      if (index == 0) {
269        power_bit = 12U;
270      }
271      break;
272    case LPC24XX_MODULE_BAT_RAM:
273      if (index == 0) {
274        power_bit = NO_POWER;
275        clock_shift = 32U;
276      }
277      break;
278    case LPC24XX_MODULE_CAN:
279      if (index < 2) {
280        power_bit = 13U + index;
281      }
282      break;
283    case LPC24XX_MODULE_DAC:
284      if (index == 0) {
285        power_bit = NO_POWER;
286        clock_shift = 22U;
287      }
288      break;
289    case LPC24XX_MODULE_EMC:
290      if (index == 0) {
291        power_bit = 11U;
292      }
293      break;
294    case LPC24XX_MODULE_ETHERNET:
295      if (index == 0) {
296        power_bit = 30U;
297      }
298      break;
299    case LPC24XX_MODULE_GPDMA:
300      if (index == 0) {
301        power_bit = 29U;
302      }
303      break;
304    case LPC24XX_MODULE_GPIO:
305      if (index == 0) {
306        power_bit = NO_POWER;
307        clock_shift = 34U;
308      }
309      break;
310    case LPC24XX_MODULE_I2C:
311      switch (index) {
312        case 0U:
313          power_bit = 7U;
314          break;
315        case 1U:
316          power_bit = 19U;
317          break;
318        case 2U:
319          power_bit = 26U;
320          break;
321      }
322      break;
323    case LPC24XX_MODULE_I2S:
324      if (index == 0) {
325        power_bit = 27U;
326      }
327      break;
328    case LPC24XX_MODULE_LCD:
329      if (index == 0) {
330        power_bit = 20U;
331      }
332      break;
333    case LPC24XX_MODULE_MCI:
334      if (index == 0) {
335        power_bit = 28U;
336      }
337      break;
338    case LPC24XX_MODULE_PCB:
339      if (index == 0) {
340        power_bit = NO_POWER;
341        clock_shift = 36U;
342      }
343      break;
344    case LPC24XX_MODULE_PWM:
345      if (index < 2) {
346        power_bit = 5U + index;
347      }
348      break;
349    case LPC24XX_MODULE_RTC:
350      if (index == 0) {
351        power_bit = 9U;
352      }
353      break;
354    case LPC24XX_MODULE_SPI:
355      if (index == 0) {
356        power_bit = 8U;
357      }
358      break;
359    case LPC24XX_MODULE_SSP:
360      switch (index) {
361        case 0U:
362          power_bit = 21U;
363          break;
364        case 1U:
365          power_bit = 10U;
366          break;
367      }
368      break;
369    case LPC24XX_MODULE_SYSCON:
370      if (index == 0) {
371        power_bit = NO_POWER;
372        clock_shift = 60U;
373      }
374      break;
375    case LPC24XX_MODULE_TIMER:
376      if (index < 2) {
377        power_bit = 1U + index;
378      } else if (index < 4) {
379        power_bit = 20U + index;
380      }
381      break;
382    case LPC24XX_MODULE_UART:
383      if (index < 2) {
384        power_bit = 3U + index;
385      } else if (index < 4) {
386        power_bit = 22U + index;
387      }
388      break;
389    case LPC24XX_MODULE_USB:
390      if (index == 0) {
391        power_bit = 31U;
392      }
393      break;
394    case LPC24XX_MODULE_WDT:
395      if (index == 0) {
396        power_bit = NO_POWER;
397        clock_shift = 0U;
398      }
399      break;
400    default:
401      return RTEMS_INVALID_ID;
402  }
403
404  /* Check power bit */
405  if (power_bit == INVALID) {
406    return RTEMS_INVALID_ID;
407  }
408
409  /* Get clock shift */
410  if (clock_shift == INVALID) {
411    clock_shift = power_bit << 1U;
412  }
413
414  /* Enable or disable module */
415  if (enable) {
416    rtems_interrupt_level level;
417
418    rtems_interrupt_disable(level);
419    PCONP |= 1U << power_bit;
420    rtems_interrupt_enable(level);
421
422    if (module != LPC24XX_MODULE_USB) {
423      rtems_interrupt_disable(level);
424      if (clock_shift < 32U) {
425        PCLKSEL0 = (PCLKSEL0 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
426            | (clock << clock_shift);
427      } else {
428        clock_shift -= 32U;
429        PCLKSEL1 = (PCLKSEL1 & ~(LPC24XX_MODULE_CLOCK_MASK << clock_shift))
430            | (clock << clock_shift);
431      }
432      rtems_interrupt_enable(level);
433    } else {
434      unsigned pllclk = lpc24xx_pllclk();
435      unsigned usbsel = pllclk / 48000000U - 1U;
436
437      if (usbsel > 15U || (usbsel % 2U != 1U) || (pllclk % 48000000U) != 0U) {
438        return RTEMS_INCORRECT_STATE;
439      }
440
441      USBCLKCFG = usbsel;
442    }
443  } else {
444    rtems_interrupt_level level;
445
446    rtems_interrupt_disable(level);
447    PCONP &= ~(1U << power_bit);
448    rtems_interrupt_enable(level);
449  }
450
451  return RTEMS_SUCCESSFUL;
452}
453
454rtems_status_code lpc24xx_module_enable(
455  lpc24xx_module module,
456  unsigned index,
457  lpc24xx_module_clock clock
458)
459{
460  return lpc24xx_module_do_enable(module, index, clock, true);
461}
462
463rtems_status_code lpc24xx_module_disable(
464  lpc24xx_module module,
465  unsigned index
466)
467{
468  return lpc24xx_module_do_enable(module, index, 0U, false);
469}
Note: See TracBrowser for help on using the repository browser.