]> git.ipfire.org Git - people/ms/u-boot.git/blob - board/nokia/rx51/rx51.c
projects / people / ms / u-boot.git / blob
? search:


08fcaf21b3c6302a0ab425ee1537fee1537287ab
[people/ms/u-boot.git] / board / nokia / rx51 / rx51.c
1 /*
2 * (C) Copyright 2012
3 * Ивайло Димитров <freemangordon@abv.bg>
4 *
5 * (C) Copyright 2011-2012
6 * Pali Rohár <pali.rohar@gmail.com>
7 *
8 * (C) Copyright 2010
9 * Alistair Buxton <a.j.buxton@gmail.com>
10 *
11 * Derived from Beagle Board and 3430 SDP code:
12 * (C) Copyright 2004-2008
13 * Texas Instruments, <www.ti.com>
14 *
15 * Author :
16 * Sunil Kumar <sunilsaini05@gmail.com>
17 * Shashi Ranjan <shashiranjanmca05@gmail.com>
18 *
19 * Richard Woodruff <r-woodruff2@ti.com>
20 * Syed Mohammed Khasim <khasim@ti.com>
21 *
22 * SPDX-License-Identifier: GPL-2.0+
23 */
24
25 #include <common.h>
26 #include <watchdog.h>
27 #include <malloc.h>
28 #include <twl4030.h>
29 #include <i2c.h>
30 #include <video_fb.h>
31 #include <asm/io.h>
32 #include <asm/setup.h>
33 #include <asm/bitops.h>
34 #include <asm/mach-types.h>
35 #include <asm/arch/mux.h>
36 #include <asm/arch/sys_proto.h>
37 #include <asm/arch/mmc_host_def.h>
38
39 #include "rx51.h"
40 #include "tag_omap.h"
41
42 DECLARE_GLOBAL_DATA_PTR;
43
44 GraphicDevice gdev;
45
46 const omap3_sysinfo sysinfo = {
47 DDR_STACKED,
48 "Nokia RX-51",
49 "OneNAND"
50 };
51
52 /* This structure contains default omap tags needed for booting Maemo 5 */
53 static struct tag_omap omap[] = {
54 OMAP_TAG_UART_CONFIG(0x04),
55 OMAP_TAG_SERIAL_CONSOLE_CONFIG(0x03, 0x01C200),
56 OMAP_TAG_LCD_CONFIG("acx565akm", "internal", 90, 0x18),
57 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_focus", 0x44, 0x1, 0x2, 0x0),
58 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_launch", 0x45, 0x1, 0x2, 0x0),
59 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_shutter", 0x6e, 0x1, 0x0, 0x0),
60 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_apeslpx", 0x46, 0x2, 0x2, 0x0),
61 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_bsi", 0x9d, 0x2, 0x2, 0x0),
62 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_en", 0x4a, 0x2, 0x2, 0x0),
63 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_rst", 0x4b, 0x6, 0x2, 0x0),
64 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_rst_rq", 0x49, 0x6, 0x2, 0x0),
65 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_wddis", 0x0d, 0x2, 0x2, 0x0),
66 OMAP_TAG_GPIO_SWITCH_CONFIG("headphone", 0xb1, 0x1, 0x1, 0x0),
67 OMAP_TAG_GPIO_SWITCH_CONFIG("kb_lock", 0x71, 0x1, 0x0, 0x0),
68 OMAP_TAG_GPIO_SWITCH_CONFIG("proximity", 0x59, 0x0, 0x0, 0x0),
69 OMAP_TAG_GPIO_SWITCH_CONFIG("sleep_ind", 0xa2, 0x2, 0x2, 0x0),
70 OMAP_TAG_GPIO_SWITCH_CONFIG("slide", GPIO_SLIDE, 0x0, 0x0, 0x0),
71 OMAP_TAG_WLAN_CX3110X_CONFIG(0x25, 0xff, 87, 42, -1),
72 OMAP_TAG_PARTITION_CONFIG(PART1_NAME, PART1_SIZE * PART1_MULL,
73 PART1_OFFS, PART1_MASK),
74 OMAP_TAG_PARTITION_CONFIG(PART2_NAME, PART2_SIZE * PART2_MULL,
75 PART2_OFFS, PART2_MASK),
76 OMAP_TAG_PARTITION_CONFIG(PART3_NAME, PART3_SIZE * PART3_MULL,
77 PART3_OFFS, PART3_MASK),
78 OMAP_TAG_PARTITION_CONFIG(PART4_NAME, PART4_SIZE * PART4_MULL,
79 PART4_OFFS, PART4_MASK),
80 OMAP_TAG_PARTITION_CONFIG(PART5_NAME, PART5_SIZE * PART5_MULL,
81 PART5_OFFS, PART5_MASK),
82 OMAP_TAG_PARTITION_CONFIG(PART6_NAME, PART6_SIZE * PART6_MULL,
83 PART6_OFFS, PART6_MASK),
84 OMAP_TAG_BOOT_REASON_CONFIG("pwr_key"),
85 OMAP_TAG_VERSION_STR_CONFIG("product", "RX-51"),
86 OMAP_TAG_VERSION_STR_CONFIG("hw-build", "2101"),
87 OMAP_TAG_VERSION_STR_CONFIG("nolo", "1.4.14"),
88 OMAP_TAG_VERSION_STR_CONFIG("boot-mode", "normal"),
89 { }
90 };
91
92 static char *boot_reason_ptr;
93 static char *hw_build_ptr;
94 static char *nolo_version_ptr;
95 static char *boot_mode_ptr;
96
97 /*
98 * Routine: init_omap_tags
99 * Description: Initialize pointers to values in tag_omap
100 */
101 static void init_omap_tags(void)
102 {
103 char *component;
104 char *version;
105 int i = 0;
106 while (omap[i].hdr.tag) {
107 switch (omap[i].hdr.tag) {
108 case OMAP_TAG_BOOT_REASON:
109 boot_reason_ptr = omap[i].u.boot_reason.reason_str;
110 break;
111 case OMAP_TAG_VERSION_STR:
112 component = omap[i].u.version.component;
113 version = omap[i].u.version.version;
114 if (strcmp(component, "hw-build") == 0)
115 hw_build_ptr = version;
116 else if (strcmp(component, "nolo") == 0)
117 nolo_version_ptr = version;
118 else if (strcmp(component, "boot-mode") == 0)
119 boot_mode_ptr = version;
120 break;
121 default:
122 break;
123 }
124 i++;
125 }
126 }
127
128 static void reuse_omap_atags(struct tag_omap *t)
129 {
130 char *component;
131 char *version;
132 while (t->hdr.tag) {
133 switch (t->hdr.tag) {
134 case OMAP_TAG_BOOT_REASON:
135 memset(boot_reason_ptr, 0, 12);
136 strcpy(boot_reason_ptr, t->u.boot_reason.reason_str);
137 break;
138 case OMAP_TAG_VERSION_STR:
139 component = t->u.version.component;
140 version = t->u.version.version;
141 if (strcmp(component, "hw-build") == 0) {
142 memset(hw_build_ptr, 0, 12);
143 strcpy(hw_build_ptr, version);
144 } else if (strcmp(component, "nolo") == 0) {
145 memset(nolo_version_ptr, 0, 12);
146 strcpy(nolo_version_ptr, version);
147 } else if (strcmp(component, "boot-mode") == 0) {
148 memset(boot_mode_ptr, 0, 12);
149 strcpy(boot_mode_ptr, version);
150 }
151 break;
152 default:
153 break;
154 }
155 t = tag_omap_next(t);
156 }
157 }
158
159 /*
160 * Routine: reuse_atags
161 * Description: Reuse atags from previous bootloader.
162 * Reuse only only HW build, boot reason, boot mode and nolo
163 */
164 static void reuse_atags(void)
165 {
166 struct tag *t = (struct tag *)gd->bd->bi_boot_params;
167
168 /* First tag must be ATAG_CORE */
169 if (t->hdr.tag != ATAG_CORE)
170 return;
171
172 if (!boot_reason_ptr || !hw_build_ptr)
173 return;
174
175 /* Last tag must be ATAG_NONE */
176 while (t->hdr.tag != ATAG_NONE) {
177 switch (t->hdr.tag) {
178 case ATAG_REVISION:
179 memset(hw_build_ptr, 0, 12);
180 sprintf(hw_build_ptr, "%x", t->u.revision.rev);
181 break;
182 case ATAG_BOARD:
183 reuse_omap_atags((struct tag_omap *)&t->u);
184 break;
185 default:
186 break;
187 }
188 t = tag_next(t);
189 }
190 }
191
192 /*
193 * Routine: board_init
194 * Description: Early hardware init.
195 */
196 int board_init(void)
197 {
198 /* in SRAM or SDRAM, finish GPMC */
199 gpmc_init();
200 /* boot param addr */
201 gd->bd->bi_boot_params = OMAP34XX_SDRC_CS0 + 0x100;
202 return 0;
203 }
204
205 /*
206 * Routine: get_board_revision
207 * Description: Return board revision.
208 */
209 u32 get_board_rev(void)
210 {
211 return simple_strtol(hw_build_ptr, NULL, 16);
212 }
213
214 /*
215 * Routine: setup_board_tags
216 * Description: Append board specific boot tags.
217 */
218 void setup_board_tags(struct tag **in_params)
219 {
220 int setup_console_atag;
221 char *setup_boot_reason_atag;
222 char *setup_boot_mode_atag;
223 char *str;
224 int i;
225 int size;
226 int total_size;
227 struct tag *params;
228 struct tag_omap *t;
229
230 params = (struct tag *)gd->bd->bi_boot_params;
231
232 params->u.core.flags = 0x0;
233 params->u.core.pagesize = 0x1000;
234 params->u.core.rootdev = 0x0;
235
236 /* append omap atag only if env setup_omap_atag is set to 1 */
237 str = getenv("setup_omap_atag");
238 if (!str || str[0] != '1')
239 return;
240
241 str = getenv("setup_console_atag");
242 if (str && str[0] == '1')
243 setup_console_atag = 1;
244 else
245 setup_console_atag = 0;
246
247 setup_boot_reason_atag = getenv("setup_boot_reason_atag");
248 setup_boot_mode_atag = getenv("setup_boot_mode_atag");
249
250 params = *in_params;
251 t = (struct tag_omap *)&params->u;
252 total_size = sizeof(struct tag_header);
253
254 for (i = 0; omap[i].hdr.tag; i++) {
255
256 /* skip serial console tag */
257 if (!setup_console_atag &&
258 omap[i].hdr.tag == OMAP_TAG_SERIAL_CONSOLE)
259 continue;
260
261 size = omap[i].hdr.size + sizeof(struct tag_omap_header);
262 memcpy(t, &omap[i], size);
263
264 /* set uart tag to 0 - disable serial console */
265 if (!setup_console_atag && omap[i].hdr.tag == OMAP_TAG_UART)
266 t->u.uart.enabled_uarts = 0;
267
268 /* change boot reason */
269 if (setup_boot_reason_atag &&
270 omap[i].hdr.tag == OMAP_TAG_BOOT_REASON) {
271 memset(t->u.boot_reason.reason_str, 0, 12);
272 strcpy(t->u.boot_reason.reason_str,
273 setup_boot_reason_atag);
274 }
275
276 /* change boot mode */
277 if (setup_boot_mode_atag &&
278 omap[i].hdr.tag == OMAP_TAG_VERSION_STR &&
279 strcmp(omap[i].u.version.component, "boot-mode") == 0) {
280 memset(t->u.version.version, 0, 12);
281 strcpy(t->u.version.version, setup_boot_mode_atag);
282 }
283
284 total_size += size;
285 t = tag_omap_next(t);
286
287 }
288
289 params->hdr.tag = ATAG_BOARD;
290 params->hdr.size = total_size >> 2;
291 params = tag_next(params);
292
293 *in_params = params;
294 }
295
296 /*
297 * Routine: video_hw_init
298 * Description: Set up the GraphicDevice depending on sys_boot.
299 */
300 void *video_hw_init(void)
301 {
302 /* fill in Graphic Device */
303 gdev.frameAdrs = 0x8f9c0000;
304 gdev.winSizeX = 800;
305 gdev.winSizeY = 480;
306 gdev.gdfBytesPP = 2;
307 gdev.gdfIndex = GDF_16BIT_565RGB;
308 memset((void *)gdev.frameAdrs, 0, 0xbb800);
309 return (void *) &gdev;
310 }
311
312 /*
313 * Routine: twl4030_regulator_set_mode
314 * Description: Set twl4030 regulator mode over i2c powerbus.
315 */
316 static void twl4030_regulator_set_mode(u8 id, u8 mode)
317 {
318 u16 msg = MSG_SINGULAR(DEV_GRP_P1, id, mode);
319 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER,
320 TWL4030_PM_MASTER_PB_WORD_MSB, msg >> 8);
321 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER,
322 TWL4030_PM_MASTER_PB_WORD_LSB, msg & 0xff);
323 }
324
325 static void omap3_emu_romcode_call(u32 service_id, u32 *parameters)
326 {
327 u32 i, num_params = *parameters;
328 u32 *sram_scratch_space = (u32 *)OMAP3_PUBLIC_SRAM_SCRATCH_AREA;
329
330 /*
331 * copy the parameters to an un-cached area to avoid coherency
332 * issues
333 */
334 for (i = 0; i < num_params; i++) {
335 __raw_writel(*parameters, sram_scratch_space);
336 parameters++;
337 sram_scratch_space++;
338 }
339
340 /* Now make the PPA call */
341 do_omap3_emu_romcode_call(service_id, OMAP3_PUBLIC_SRAM_SCRATCH_AREA);
342 }
343
344 /*
345 * Routine: omap3_update_aux_cr_secure_rx51
346 * Description: Modify the contents Auxiliary Control Register.
347 * Parameters:
348 * set_bits - bits to set in ACR
349 * clr_bits - bits to clear in ACR
350 */
351 static void omap3_update_aux_cr_secure_rx51(u32 set_bits, u32 clear_bits)
352 {
353 struct emu_hal_params_rx51 emu_romcode_params = { 0, };
354 u32 acr;
355
356 /* Read ACR */
357 asm volatile ("mrc p15, 0, %0, c1, c0, 1" : "=r" (acr));
358 acr &= ~clear_bits;
359 acr |= set_bits;
360
361 emu_romcode_params.num_params = 2;
362 emu_romcode_params.param1 = acr;
363
364 omap3_emu_romcode_call(OMAP3_EMU_HAL_API_WRITE_ACR,
365 (u32 *)&emu_romcode_params);
366 }
367
368 /*
369 * Routine: misc_init_r
370 * Description: Configure board specific parts.
371 */
372 int misc_init_r(void)
373 {
374 char buf[12];
375 u8 state;
376
377 /* reset lp5523 led */
378 i2c_set_bus_num(1);
379 state = 0xff;
380 i2c_write(0x32, 0x3d, 1, &state, 1);
381 i2c_set_bus_num(0);
382
383 /* initialize twl4030 power managment */
384 twl4030_power_init();
385
386 /* set VSIM to 1.8V */
387 twl4030_pmrecv_vsel_cfg(TWL4030_PM_RECEIVER_VSIM_DEDICATED,
388 TWL4030_PM_RECEIVER_VSIM_VSEL_18,
389 TWL4030_PM_RECEIVER_VSIM_DEV_GRP,
390 TWL4030_PM_RECEIVER_DEV_GRP_P1);
391
392 /* store I2C access state */
393 twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG,
394 &state);
395
396 /* enable I2C access to powerbus (needed for twl4030 regulator) */
397 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG,
398 0x02);
399
400 /* set VAUX3, VSIM and VMMC1 state to active - enable eMMC memory */
401 twl4030_regulator_set_mode(RES_VAUX3, RES_STATE_ACTIVE);
402 twl4030_regulator_set_mode(RES_VSIM, RES_STATE_ACTIVE);
403 twl4030_regulator_set_mode(RES_VMMC1, RES_STATE_ACTIVE);
404
405 /* restore I2C access state */
406 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG,
407 state);
408
409 /* set env variable attkernaddr for relocated kernel */
410 sprintf(buf, "%#x", KERNEL_ADDRESS);
411 setenv("attkernaddr", buf);
412
413 /* initialize omap tags */
414 init_omap_tags();
415
416 /* reuse atags from previous bootloader */
417 reuse_atags();
418
419 dieid_num_r();
420 print_cpuinfo();
421
422 /*
423 * Cortex-A8(r1p0..r1p2) errata 430973 workaround
424 * Set IBE bit in Auxiliary Control Register
425 *
426 * Call this routine only on real secure device
427 * Qemu does not implement secure PPA and crash
428 */
429 if (get_device_type() == HS_DEVICE)
430 omap3_update_aux_cr_secure_rx51(1 << 6, 0);
431
432 return 0;
433 }
434
435 /*
436 * Routine: set_muxconf_regs
437 * Description: Setting up the configuration Mux registers specific to the
438 * hardware. Many pins need to be moved from protect to primary
439 * mode.
440 */
441 void set_muxconf_regs(void)
442 {
443 MUX_RX51();
444 }
445
446 static unsigned long int twl_wd_time; /* last time of watchdog reset */
447 static unsigned long int twl_i2c_lock;
448
449 /*
450 * Routine: hw_watchdog_reset
451 * Description: Reset timeout of twl4030 watchdog.
452 */
453 void hw_watchdog_reset(void)
454 {
455 u8 timeout = 0;
456
457 /* do not reset watchdog too often - max every 4s */
458 if (get_timer(twl_wd_time) < 4 * CONFIG_SYS_HZ)
459 return;
460
461 /* localy lock twl4030 i2c bus */
462 if (test_and_set_bit(0, &twl_i2c_lock))
463 return;
464
465 /* read actual watchdog timeout */
466 twl4030_i2c_read_u8(TWL4030_CHIP_PM_RECEIVER,
467 TWL4030_PM_RECEIVER_WATCHDOG_CFG, &timeout);
468
469 /* timeout 0 means watchdog is disabled */
470 /* reset watchdog timeout to 31s (maximum) */
471 if (timeout != 0)
472 twl4030_i2c_write_u8(TWL4030_CHIP_PM_RECEIVER,
473 TWL4030_PM_RECEIVER_WATCHDOG_CFG, 31);
474
475 /* store last watchdog reset time */
476 twl_wd_time = get_timer(0);
477
478 /* localy unlock twl4030 i2c bus */
479 test_and_clear_bit(0, &twl_i2c_lock);
480 }
481
482 /*
483 * TWL4030 keypad handler for cfb_console
484 */
485
486 static const char keymap[] = {
487 /* normal */
488 'q', 'o', 'p', ',', '\b', 0, 'a', 's',
489 'w', 'd', 'f', 'g', 'h', 'j', 'k', 'l',
490 'e', '.', 0, '\r', 0, 'z', 'x', 'c',
491 'r', 'v', 'b', 'n', 'm', ' ', ' ', 0,
492 't', 0, 0, 0, 0, 0, 0, 0,
493 'y', 0, 0, 0, 0, 0, 0, 0,
494 'u', 0, 0, 0, 0, 0, 0, 0,
495 'i', 5, 6, 0, 0, 0, 0, 0,
496 /* fn */
497 '1', '9', '0', '=', '\b', 0, '*', '+',
498 '2', '#', '-', '_', '(', ')', '&', '!',
499 '3', '?', '^', '\r', 0, 156, '$', 238,
500 '4', '/', '\\', '"', '\'', '@', 0, '<',
501 '5', '|', '>', 0, 0, 0, 0, 0,
502 '6', 0, 0, 0, 0, 0, 0, 0,
503 '7', 0, 0, 0, 0, 0, 0, 0,
504 '8', 16, 17, 0, 0, 0, 0, 0,
505 };
506
507 static u8 keys[8];
508 static u8 old_keys[8] = {0, 0, 0, 0, 0, 0, 0, 0};
509 #define KEYBUF_SIZE 32
510 static u8 keybuf[KEYBUF_SIZE];
511 static u8 keybuf_head;
512 static u8 keybuf_tail;
513
514 /*
515 * Routine: rx51_kp_init
516 * Description: Initialize HW keyboard.
517 */
518 int rx51_kp_init(void)
519 {
520 int ret = 0;
521 u8 ctrl;
522 ret = twl4030_i2c_read_u8(TWL4030_CHIP_KEYPAD,
523 TWL4030_KEYPAD_KEYP_CTRL_REG, &ctrl);
524
525 if (ret)
526 return ret;
527
528 /* turn on keyboard and use hardware scanning */
529 ctrl |= TWL4030_KEYPAD_CTRL_KBD_ON;
530 ctrl |= TWL4030_KEYPAD_CTRL_SOFT_NRST;
531 ctrl |= TWL4030_KEYPAD_CTRL_SOFTMODEN;
532 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD,
533 TWL4030_KEYPAD_KEYP_CTRL_REG, ctrl);
534 /* enable key event status */
535 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD,
536 TWL4030_KEYPAD_KEYP_IMR1, 0xfe);
537 /* enable interrupt generation on rising and falling */
538 /* this is a workaround for qemu twl4030 emulation */
539 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD,
540 TWL4030_KEYPAD_KEYP_EDR, 0x57);
541 /* enable ISR clear on read */
542 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD,
543 TWL4030_KEYPAD_KEYP_SIH_CTRL, 0x05);
544 return 0;
545 }
546
547 static void rx51_kp_fill(u8 k, u8 mods)
548 {
549 /* check if some cursor key without meta fn key was pressed */
550 if (!(mods & 2) && (k == 18 || k == 31 || k == 33 || k == 34)) {
551 keybuf[keybuf_tail++] = '\e';
552 keybuf_tail %= KEYBUF_SIZE;
553 keybuf[keybuf_tail++] = '[';
554 keybuf_tail %= KEYBUF_SIZE;
555 if (k == 18) /* up */
556 keybuf[keybuf_tail++] = 'A';
557 else if (k == 31) /* left */
558 keybuf[keybuf_tail++] = 'D';
559 else if (k == 33) /* down */
560 keybuf[keybuf_tail++] = 'B';
561 else if (k == 34) /* right */
562 keybuf[keybuf_tail++] = 'C';
563 keybuf_tail %= KEYBUF_SIZE;
564 return;
565 }
566
567 if (mods & 2) { /* fn meta key was pressed */
568 k = keymap[k+64];
569 } else {
570 k = keymap[k];
571 if (mods & 1) { /* ctrl key was pressed */
572 if (k >= 'a' && k <= 'z')
573 k -= 'a' - 1;
574 }
575 if (mods & 4) { /* shift key was pressed */
576 if (k >= 'a' && k <= 'z')
577 k += 'A' - 'a';
578 else if (k == '.')
579 k = ':';
580 else if (k == ',')
581 k = ';';
582 }
583 }
584 keybuf[keybuf_tail++] = k;
585 keybuf_tail %= KEYBUF_SIZE;
586 }
587
588 /*
589 * Routine: rx51_kp_tstc
590 * Description: Test if key was pressed (from buffer).
591 */
592 int rx51_kp_tstc(struct stdio_dev *sdev)
593 {
594 u8 c, r, dk, i;
595 u8 intr;
596 u8 mods;
597
598 /* localy lock twl4030 i2c bus */
599 if (test_and_set_bit(0, &twl_i2c_lock))
600 return 0;
601
602 /* twl4030 remembers up to 2 events */
603 for (i = 0; i < 2; i++) {
604
605 /* check interrupt register for events */
606 twl4030_i2c_read_u8(TWL4030_CHIP_KEYPAD,
607 TWL4030_KEYPAD_KEYP_ISR1 + (2 * i), &intr);
608
609 /* no event */
610 if (!(intr&1))
611 continue;
612
613 /* read the key state */
614 i2c_read(TWL4030_CHIP_KEYPAD,
615 TWL4030_KEYPAD_FULL_CODE_7_0, 1, keys, 8);
616
617 /* cut out modifier keys from the keystate */
618 mods = keys[4] >> 4;
619 keys[4] &= 0x0f;
620
621 for (c = 0; c < 8; c++) {
622
623 /* get newly pressed keys only */
624 dk = ((keys[c] ^ old_keys[c])&keys[c]);
625 old_keys[c] = keys[c];
626
627 /* fill the keybuf */
628 for (r = 0; r < 8; r++) {
629 if (dk&1)
630 rx51_kp_fill((c*8)+r, mods);
631 dk = dk >> 1;
632 }
633
634 }
635
636 }
637
638 /* localy unlock twl4030 i2c bus */
639 test_and_clear_bit(0, &twl_i2c_lock);
640
641 return (KEYBUF_SIZE + keybuf_tail - keybuf_head)%KEYBUF_SIZE;
642 }
643
644 /*
645 * Routine: rx51_kp_getc
646 * Description: Get last pressed key (from buffer).
647 */
648 int rx51_kp_getc(struct stdio_dev *sdev)
649 {
650 keybuf_head %= KEYBUF_SIZE;
651 while (!rx51_kp_tstc(sdev))
652 WATCHDOG_RESET();
653 return keybuf[keybuf_head++];
654 }
655
656 /*
657 * Routine: board_mmc_init
658 * Description: Initialize mmc devices.
659 */
660 int board_mmc_init(bd_t *bis)
661 {
662 omap_mmc_init(0, 0, 0, -1, -1);
663 omap_mmc_init(1, 0, 0, -1, -1);
664 return 0;
665 }
666
667 void board_mmc_power_init(void)
668 {
669 twl4030_power_mmc_init(0);
670 twl4030_power_mmc_init(1);
671 }
"Das U-Boot" Source Tree