board-h4.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390
  1. /*
  2. * linux/arch/arm/mach-omap2/board-h4.c
  3. *
  4. * Copyright (C) 2005 Nokia Corporation
  5. * Author: Paul Mundt <paul.mundt@nokia.com>
  6. *
  7. * Modified from mach-omap/omap1/board-generic.c
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. */
  13. #include <linux/gpio.h>
  14. #include <linux/kernel.h>
  15. #include <linux/init.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/mtd/mtd.h>
  18. #include <linux/mtd/partitions.h>
  19. #include <linux/mtd/physmap.h>
  20. #include <linux/delay.h>
  21. #include <linux/workqueue.h>
  22. #include <linux/i2c.h>
  23. #include <linux/i2c/at24.h>
  24. #include <linux/input.h>
  25. #include <linux/err.h>
  26. #include <linux/clk.h>
  27. #include <linux/io.h>
  28. #include <linux/input/matrix_keypad.h>
  29. #include <asm/mach-types.h>
  30. #include <asm/mach/arch.h>
  31. #include <asm/mach/map.h>
  32. #include <plat/menelaus.h>
  33. #include <plat/dma.h>
  34. #include <plat/gpmc.h>
  35. #include "debug-devices.h"
  36. #include <video/omapdss.h>
  37. #include <video/omap-panel-generic-dpi.h>
  38. #include "common.h"
  39. #include "mux.h"
  40. #include "control.h"
  41. #define H4_FLASH_CS 0
  42. #define H4_SMC91X_CS 1
  43. #define H4_ETHR_GPIO_IRQ 92
  44. #if defined(CONFIG_KEYBOARD_MATRIX) || defined(CONFIG_KEYBOARD_MATRIX_MODULE)
  45. static const uint32_t board_matrix_keys[] = {
  46. KEY(0, 0, KEY_LEFT),
  47. KEY(1, 0, KEY_RIGHT),
  48. KEY(2, 0, KEY_A),
  49. KEY(3, 0, KEY_B),
  50. KEY(4, 0, KEY_C),
  51. KEY(0, 1, KEY_DOWN),
  52. KEY(1, 1, KEY_UP),
  53. KEY(2, 1, KEY_E),
  54. KEY(3, 1, KEY_F),
  55. KEY(4, 1, KEY_G),
  56. KEY(0, 2, KEY_ENTER),
  57. KEY(1, 2, KEY_I),
  58. KEY(2, 2, KEY_J),
  59. KEY(3, 2, KEY_K),
  60. KEY(4, 2, KEY_3),
  61. KEY(0, 3, KEY_M),
  62. KEY(1, 3, KEY_N),
  63. KEY(2, 3, KEY_O),
  64. KEY(3, 3, KEY_P),
  65. KEY(4, 3, KEY_Q),
  66. KEY(0, 4, KEY_R),
  67. KEY(1, 4, KEY_4),
  68. KEY(2, 4, KEY_T),
  69. KEY(3, 4, KEY_U),
  70. KEY(4, 4, KEY_ENTER),
  71. KEY(0, 5, KEY_V),
  72. KEY(1, 5, KEY_W),
  73. KEY(2, 5, KEY_L),
  74. KEY(3, 5, KEY_S),
  75. KEY(4, 5, KEY_ENTER),
  76. };
  77. static const struct matrix_keymap_data board_keymap_data = {
  78. .keymap = board_matrix_keys,
  79. .keymap_size = ARRAY_SIZE(board_matrix_keys),
  80. };
  81. static unsigned int board_keypad_row_gpios[] = {
  82. 88, 89, 124, 11, 6, 96
  83. };
  84. static unsigned int board_keypad_col_gpios[] = {
  85. 90, 91, 100, 36, 12, 97, 98
  86. };
  87. static struct matrix_keypad_platform_data board_keypad_platform_data = {
  88. .keymap_data = &board_keymap_data,
  89. .row_gpios = board_keypad_row_gpios,
  90. .num_row_gpios = ARRAY_SIZE(board_keypad_row_gpios),
  91. .col_gpios = board_keypad_col_gpios,
  92. .num_col_gpios = ARRAY_SIZE(board_keypad_col_gpios),
  93. .active_low = 1,
  94. .debounce_ms = 20,
  95. .col_scan_delay_us = 5,
  96. };
  97. static struct platform_device board_keyboard = {
  98. .name = "matrix-keypad",
  99. .id = -1,
  100. .dev = {
  101. .platform_data = &board_keypad_platform_data,
  102. },
  103. };
  104. static void __init board_mkp_init(void)
  105. {
  106. omap_mux_init_gpio(88, OMAP_PULL_ENA | OMAP_PULL_UP);
  107. omap_mux_init_gpio(89, OMAP_PULL_ENA | OMAP_PULL_UP);
  108. omap_mux_init_gpio(124, OMAP_PULL_ENA | OMAP_PULL_UP);
  109. omap_mux_init_signal("mcbsp2_dr.gpio_11", OMAP_PULL_ENA | OMAP_PULL_UP);
  110. if (omap_has_menelaus()) {
  111. omap_mux_init_signal("sdrc_a14.gpio0",
  112. OMAP_PULL_ENA | OMAP_PULL_UP);
  113. omap_mux_init_signal("vlynq_rx0.gpio_15", 0);
  114. omap_mux_init_signal("gpio_98", 0);
  115. board_keypad_row_gpios[5] = 0;
  116. board_keypad_col_gpios[2] = 15;
  117. board_keypad_col_gpios[6] = 18;
  118. } else {
  119. omap_mux_init_signal("gpio_96", OMAP_PULL_ENA | OMAP_PULL_UP);
  120. omap_mux_init_signal("gpio_100", 0);
  121. omap_mux_init_signal("gpio_98", 0);
  122. }
  123. omap_mux_init_signal("gpio_90", 0);
  124. omap_mux_init_signal("gpio_91", 0);
  125. omap_mux_init_signal("gpio_36", 0);
  126. omap_mux_init_signal("mcbsp2_clkx.gpio_12", 0);
  127. omap_mux_init_signal("gpio_97", 0);
  128. platform_device_register(&board_keyboard);
  129. }
  130. #else
  131. static inline void board_mkp_init(void)
  132. {
  133. }
  134. #endif
  135. static struct mtd_partition h4_partitions[] = {
  136. /* bootloader (U-Boot, etc) in first sector */
  137. {
  138. .name = "bootloader",
  139. .offset = 0,
  140. .size = SZ_128K,
  141. .mask_flags = MTD_WRITEABLE, /* force read-only */
  142. },
  143. /* bootloader params in the next sector */
  144. {
  145. .name = "params",
  146. .offset = MTDPART_OFS_APPEND,
  147. .size = SZ_128K,
  148. .mask_flags = 0,
  149. },
  150. /* kernel */
  151. {
  152. .name = "kernel",
  153. .offset = MTDPART_OFS_APPEND,
  154. .size = SZ_2M,
  155. .mask_flags = 0
  156. },
  157. /* file system */
  158. {
  159. .name = "filesystem",
  160. .offset = MTDPART_OFS_APPEND,
  161. .size = MTDPART_SIZ_FULL,
  162. .mask_flags = 0
  163. }
  164. };
  165. static struct physmap_flash_data h4_flash_data = {
  166. .width = 2,
  167. .parts = h4_partitions,
  168. .nr_parts = ARRAY_SIZE(h4_partitions),
  169. };
  170. static struct resource h4_flash_resource = {
  171. .flags = IORESOURCE_MEM,
  172. };
  173. static struct platform_device h4_flash_device = {
  174. .name = "physmap-flash",
  175. .id = 0,
  176. .dev = {
  177. .platform_data = &h4_flash_data,
  178. },
  179. .num_resources = 1,
  180. .resource = &h4_flash_resource,
  181. };
  182. static struct platform_device *h4_devices[] __initdata = {
  183. &h4_flash_device,
  184. };
  185. static struct panel_generic_dpi_data h4_panel_data = {
  186. .name = "h4",
  187. };
  188. static struct omap_dss_device h4_lcd_device = {
  189. .name = "lcd",
  190. .driver_name = "generic_dpi_panel",
  191. .type = OMAP_DISPLAY_TYPE_DPI,
  192. .phy.dpi.data_lines = 16,
  193. .data = &h4_panel_data,
  194. };
  195. static struct omap_dss_device *h4_dss_devices[] = {
  196. &h4_lcd_device,
  197. };
  198. static struct omap_dss_board_info h4_dss_data = {
  199. .num_devices = ARRAY_SIZE(h4_dss_devices),
  200. .devices = h4_dss_devices,
  201. .default_device = &h4_lcd_device,
  202. };
  203. /* 2420 Sysboot setup (2430 is different) */
  204. static u32 get_sysboot_value(void)
  205. {
  206. return (omap_ctrl_readl(OMAP24XX_CONTROL_STATUS) &
  207. (OMAP2_SYSBOOT_5_MASK | OMAP2_SYSBOOT_4_MASK |
  208. OMAP2_SYSBOOT_3_MASK | OMAP2_SYSBOOT_2_MASK |
  209. OMAP2_SYSBOOT_1_MASK | OMAP2_SYSBOOT_0_MASK));
  210. }
  211. /* H4-2420's always used muxed mode, H4-2422's always use non-muxed
  212. *
  213. * Note: OMAP-GIT doesn't correctly do is_cpu_omap2422 and is_cpu_omap2423
  214. * correctly. The macro needs to look at production_id not just hawkeye.
  215. */
  216. static u32 is_gpmc_muxed(void)
  217. {
  218. u32 mux;
  219. mux = get_sysboot_value();
  220. if ((mux & 0xF) == 0xd)
  221. return 1; /* NAND config (could be either) */
  222. if (mux & 0x2) /* if mux'ed */
  223. return 1;
  224. else
  225. return 0;
  226. }
  227. static inline void __init h4_init_debug(void)
  228. {
  229. int eth_cs;
  230. unsigned long cs_mem_base;
  231. unsigned int muxed, rate;
  232. struct clk *gpmc_fck;
  233. eth_cs = H4_SMC91X_CS;
  234. gpmc_fck = clk_get(NULL, "gpmc_fck"); /* Always on ENABLE_ON_INIT */
  235. if (IS_ERR(gpmc_fck)) {
  236. WARN_ON(1);
  237. return;
  238. }
  239. clk_prepare_enable(gpmc_fck);
  240. rate = clk_get_rate(gpmc_fck);
  241. clk_disable_unprepare(gpmc_fck);
  242. clk_put(gpmc_fck);
  243. if (is_gpmc_muxed())
  244. muxed = 0x200;
  245. else
  246. muxed = 0;
  247. /* Make sure CS1 timings are correct */
  248. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG1,
  249. 0x00011000 | muxed);
  250. if (rate >= 160000000) {
  251. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f01);
  252. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080803);
  253. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1c0b1c0a);
  254. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x041f1F1F);
  255. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000004C4);
  256. } else if (rate >= 130000000) {
  257. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f00);
  258. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080802);
  259. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1C091C09);
  260. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x041f1F1F);
  261. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000004C4);
  262. } else {/* rate = 100000000 */
  263. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f00);
  264. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080802);
  265. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1C091C09);
  266. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x031A1F1F);
  267. gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000003C2);
  268. }
  269. if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
  270. printk(KERN_ERR "Failed to request GPMC mem for smc91x\n");
  271. goto out;
  272. }
  273. udelay(100);
  274. omap_mux_init_gpio(92, 0);
  275. if (debug_card_init(cs_mem_base, H4_ETHR_GPIO_IRQ) < 0)
  276. gpmc_cs_free(eth_cs);
  277. out:
  278. clk_disable_unprepare(gpmc_fck);
  279. clk_put(gpmc_fck);
  280. }
  281. static void __init h4_init_flash(void)
  282. {
  283. unsigned long base;
  284. if (gpmc_cs_request(H4_FLASH_CS, SZ_64M, &base) < 0) {
  285. printk("Can't request GPMC CS for flash\n");
  286. return;
  287. }
  288. h4_flash_resource.start = base;
  289. h4_flash_resource.end = base + SZ_64M - 1;
  290. }
  291. static struct at24_platform_data m24c01 = {
  292. .byte_len = SZ_1K / 8,
  293. .page_size = 16,
  294. };
  295. static struct i2c_board_info __initdata h4_i2c_board_info[] = {
  296. {
  297. I2C_BOARD_INFO("isp1301_omap", 0x2d),
  298. },
  299. { /* EEPROM on mainboard */
  300. I2C_BOARD_INFO("24c01", 0x52),
  301. .platform_data = &m24c01,
  302. },
  303. { /* EEPROM on cpu card */
  304. I2C_BOARD_INFO("24c01", 0x57),
  305. .platform_data = &m24c01,
  306. },
  307. };
  308. #ifdef CONFIG_OMAP_MUX
  309. static struct omap_board_mux board_mux[] __initdata = {
  310. { .reg_offset = OMAP_MUX_TERMINATOR },
  311. };
  312. #endif
  313. static void __init omap_h4_init(void)
  314. {
  315. omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAF);
  316. /*
  317. * Make sure the serial ports are muxed on at this point.
  318. * You have to mux them off in device drivers later on
  319. * if not needed.
  320. */
  321. board_mkp_init();
  322. h4_i2c_board_info[0].irq = gpio_to_irq(125);
  323. i2c_register_board_info(1, h4_i2c_board_info,
  324. ARRAY_SIZE(h4_i2c_board_info));
  325. platform_add_devices(h4_devices, ARRAY_SIZE(h4_devices));
  326. omap_serial_init();
  327. omap_sdrc_init(NULL, NULL);
  328. h4_init_flash();
  329. omap_display_init(&h4_dss_data);
  330. }
  331. MACHINE_START(OMAP_H4, "OMAP2420 H4 board")
  332. /* Maintainer: Paul Mundt <paul.mundt@nokia.com> */
  333. .atag_offset = 0x100,
  334. .reserve = omap_reserve,
  335. .map_io = omap242x_map_io,
  336. .init_early = omap2420_init_early,
  337. .init_irq = omap2_init_irq,
  338. .handle_irq = omap2_intc_handle_irq,
  339. .init_machine = omap_h4_init,
  340. .init_late = omap2420_init_late,
  341. .timer = &omap2_timer,
  342. .restart = omap_prcm_restart,
  343. MACHINE_END