board-n8x0.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694
  1. /*
  2. * linux/arch/arm/mach-omap2/board-n8x0.c
  3. *
  4. * Copyright (C) 2005-2009 Nokia Corporation
  5. * Author: Juha Yrjola <juha.yrjola@nokia.com>
  6. *
  7. * Modified from mach-omap2/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/clk.h>
  14. #include <linux/delay.h>
  15. #include <linux/gpio.h>
  16. #include <linux/init.h>
  17. #include <linux/io.h>
  18. #include <linux/stddef.h>
  19. #include <linux/i2c.h>
  20. #include <linux/spi/spi.h>
  21. #include <linux/usb/musb.h>
  22. #include <sound/tlv320aic3x.h>
  23. #include <asm/mach/arch.h>
  24. #include <asm/mach-types.h>
  25. #include <plat/board.h>
  26. #include <plat/common.h>
  27. #include <plat/menelaus.h>
  28. #include <mach/irqs.h>
  29. #include <plat/mcspi.h>
  30. #include <plat/onenand.h>
  31. #include <plat/mmc.h>
  32. #include <plat/serial.h>
  33. #include "mux.h"
  34. static int slot1_cover_open;
  35. static int slot2_cover_open;
  36. static struct device *mmc_device;
  37. #define TUSB6010_ASYNC_CS 1
  38. #define TUSB6010_SYNC_CS 4
  39. #define TUSB6010_GPIO_INT 58
  40. #define TUSB6010_GPIO_ENABLE 0
  41. #define TUSB6010_DMACHAN 0x3f
  42. #if defined(CONFIG_USB_TUSB6010) || \
  43. defined(CONFIG_USB_TUSB6010_MODULE)
  44. /*
  45. * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and
  46. * 1.5 V voltage regulators of PM companion chip. Companion chip will then
  47. * provide then PGOOD signal to TUSB6010 which will release it from reset.
  48. */
  49. static int tusb_set_power(int state)
  50. {
  51. int i, retval = 0;
  52. if (state) {
  53. gpio_set_value(TUSB6010_GPIO_ENABLE, 1);
  54. msleep(1);
  55. /* Wait until TUSB6010 pulls INT pin down */
  56. i = 100;
  57. while (i && gpio_get_value(TUSB6010_GPIO_INT)) {
  58. msleep(1);
  59. i--;
  60. }
  61. if (!i) {
  62. printk(KERN_ERR "tusb: powerup failed\n");
  63. retval = -ENODEV;
  64. }
  65. } else {
  66. gpio_set_value(TUSB6010_GPIO_ENABLE, 0);
  67. msleep(10);
  68. }
  69. return retval;
  70. }
  71. static struct musb_hdrc_config musb_config = {
  72. .multipoint = 1,
  73. .dyn_fifo = 1,
  74. .num_eps = 16,
  75. .ram_bits = 12,
  76. };
  77. static struct musb_hdrc_platform_data tusb_data = {
  78. #if defined(CONFIG_USB_MUSB_OTG)
  79. .mode = MUSB_OTG,
  80. #elif defined(CONFIG_USB_MUSB_PERIPHERAL)
  81. .mode = MUSB_PERIPHERAL,
  82. #else /* defined(CONFIG_USB_MUSB_HOST) */
  83. .mode = MUSB_HOST,
  84. #endif
  85. .set_power = tusb_set_power,
  86. .min_power = 25, /* x2 = 50 mA drawn from VBUS as peripheral */
  87. .power = 100, /* Max 100 mA VBUS for host mode */
  88. .config = &musb_config,
  89. };
  90. static void __init n8x0_usb_init(void)
  91. {
  92. int ret = 0;
  93. static char announce[] __initdata = KERN_INFO "TUSB 6010\n";
  94. /* PM companion chip power control pin */
  95. ret = gpio_request(TUSB6010_GPIO_ENABLE, "TUSB6010 enable");
  96. if (ret != 0) {
  97. printk(KERN_ERR "Could not get TUSB power GPIO%i\n",
  98. TUSB6010_GPIO_ENABLE);
  99. return;
  100. }
  101. gpio_direction_output(TUSB6010_GPIO_ENABLE, 0);
  102. tusb_set_power(0);
  103. ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2,
  104. TUSB6010_ASYNC_CS, TUSB6010_SYNC_CS,
  105. TUSB6010_GPIO_INT, TUSB6010_DMACHAN);
  106. if (ret != 0)
  107. goto err;
  108. printk(announce);
  109. return;
  110. err:
  111. gpio_free(TUSB6010_GPIO_ENABLE);
  112. }
  113. #else
  114. static void __init n8x0_usb_init(void) {}
  115. #endif /*CONFIG_USB_TUSB6010 */
  116. static struct omap2_mcspi_device_config p54spi_mcspi_config = {
  117. .turbo_mode = 0,
  118. .single_channel = 1,
  119. };
  120. static struct spi_board_info n800_spi_board_info[] __initdata = {
  121. {
  122. .modalias = "p54spi",
  123. .bus_num = 2,
  124. .chip_select = 0,
  125. .max_speed_hz = 48000000,
  126. .controller_data = &p54spi_mcspi_config,
  127. },
  128. };
  129. #if defined(CONFIG_MTD_ONENAND_OMAP2) || \
  130. defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
  131. static struct mtd_partition onenand_partitions[] = {
  132. {
  133. .name = "bootloader",
  134. .offset = 0,
  135. .size = 0x20000,
  136. .mask_flags = MTD_WRITEABLE, /* Force read-only */
  137. },
  138. {
  139. .name = "config",
  140. .offset = MTDPART_OFS_APPEND,
  141. .size = 0x60000,
  142. },
  143. {
  144. .name = "kernel",
  145. .offset = MTDPART_OFS_APPEND,
  146. .size = 0x200000,
  147. },
  148. {
  149. .name = "initfs",
  150. .offset = MTDPART_OFS_APPEND,
  151. .size = 0x400000,
  152. },
  153. {
  154. .name = "rootfs",
  155. .offset = MTDPART_OFS_APPEND,
  156. .size = MTDPART_SIZ_FULL,
  157. },
  158. };
  159. static struct omap_onenand_platform_data board_onenand_data[] = {
  160. {
  161. .cs = 0,
  162. .gpio_irq = 26,
  163. .parts = onenand_partitions,
  164. .nr_parts = ARRAY_SIZE(onenand_partitions),
  165. .flags = ONENAND_SYNC_READ,
  166. }
  167. };
  168. #endif
  169. #if defined(CONFIG_MENELAUS) && \
  170. (defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE))
  171. /*
  172. * On both N800 and N810, only the first of the two MMC controllers is in use.
  173. * The two MMC slots are multiplexed via Menelaus companion chip over I2C.
  174. * On N800, both slots are powered via Menelaus. On N810, only one of the
  175. * slots is powered via Menelaus. The N810 EMMC is powered via GPIO.
  176. *
  177. * VMMC slot 1 on both N800 and N810
  178. * VDCDC3_APE and VMCS2_APE slot 2 on N800
  179. * GPIO23 and GPIO9 slot 2 EMMC on N810
  180. *
  181. */
  182. #define N8X0_SLOT_SWITCH_GPIO 96
  183. #define N810_EMMC_VSD_GPIO 23
  184. #define N810_EMMC_VIO_GPIO 9
  185. static int n8x0_mmc_switch_slot(struct device *dev, int slot)
  186. {
  187. #ifdef CONFIG_MMC_DEBUG
  188. dev_dbg(dev, "Choose slot %d\n", slot + 1);
  189. #endif
  190. gpio_set_value(N8X0_SLOT_SWITCH_GPIO, slot);
  191. return 0;
  192. }
  193. static int n8x0_mmc_set_power_menelaus(struct device *dev, int slot,
  194. int power_on, int vdd)
  195. {
  196. int mV;
  197. #ifdef CONFIG_MMC_DEBUG
  198. dev_dbg(dev, "Set slot %d power: %s (vdd %d)\n", slot + 1,
  199. power_on ? "on" : "off", vdd);
  200. #endif
  201. if (slot == 0) {
  202. if (!power_on)
  203. return menelaus_set_vmmc(0);
  204. switch (1 << vdd) {
  205. case MMC_VDD_33_34:
  206. case MMC_VDD_32_33:
  207. case MMC_VDD_31_32:
  208. mV = 3100;
  209. break;
  210. case MMC_VDD_30_31:
  211. mV = 3000;
  212. break;
  213. case MMC_VDD_28_29:
  214. mV = 2800;
  215. break;
  216. case MMC_VDD_165_195:
  217. mV = 1850;
  218. break;
  219. default:
  220. BUG();
  221. }
  222. return menelaus_set_vmmc(mV);
  223. } else {
  224. if (!power_on)
  225. return menelaus_set_vdcdc(3, 0);
  226. switch (1 << vdd) {
  227. case MMC_VDD_33_34:
  228. case MMC_VDD_32_33:
  229. mV = 3300;
  230. break;
  231. case MMC_VDD_30_31:
  232. case MMC_VDD_29_30:
  233. mV = 3000;
  234. break;
  235. case MMC_VDD_28_29:
  236. case MMC_VDD_27_28:
  237. mV = 2800;
  238. break;
  239. case MMC_VDD_24_25:
  240. case MMC_VDD_23_24:
  241. mV = 2400;
  242. break;
  243. case MMC_VDD_22_23:
  244. case MMC_VDD_21_22:
  245. mV = 2200;
  246. break;
  247. case MMC_VDD_20_21:
  248. mV = 2000;
  249. break;
  250. case MMC_VDD_165_195:
  251. mV = 1800;
  252. break;
  253. default:
  254. BUG();
  255. }
  256. return menelaus_set_vdcdc(3, mV);
  257. }
  258. return 0;
  259. }
  260. static void n810_set_power_emmc(struct device *dev,
  261. int power_on)
  262. {
  263. dev_dbg(dev, "Set EMMC power %s\n", power_on ? "on" : "off");
  264. if (power_on) {
  265. gpio_set_value(N810_EMMC_VSD_GPIO, 1);
  266. msleep(1);
  267. gpio_set_value(N810_EMMC_VIO_GPIO, 1);
  268. msleep(1);
  269. } else {
  270. gpio_set_value(N810_EMMC_VIO_GPIO, 0);
  271. msleep(50);
  272. gpio_set_value(N810_EMMC_VSD_GPIO, 0);
  273. msleep(50);
  274. }
  275. }
  276. static int n8x0_mmc_set_power(struct device *dev, int slot, int power_on,
  277. int vdd)
  278. {
  279. if (machine_is_nokia_n800() || slot == 0)
  280. return n8x0_mmc_set_power_menelaus(dev, slot, power_on, vdd);
  281. n810_set_power_emmc(dev, power_on);
  282. return 0;
  283. }
  284. static int n8x0_mmc_set_bus_mode(struct device *dev, int slot, int bus_mode)
  285. {
  286. int r;
  287. dev_dbg(dev, "Set slot %d bus mode %s\n", slot + 1,
  288. bus_mode == MMC_BUSMODE_OPENDRAIN ? "open-drain" : "push-pull");
  289. BUG_ON(slot != 0 && slot != 1);
  290. slot++;
  291. switch (bus_mode) {
  292. case MMC_BUSMODE_OPENDRAIN:
  293. r = menelaus_set_mmc_opendrain(slot, 1);
  294. break;
  295. case MMC_BUSMODE_PUSHPULL:
  296. r = menelaus_set_mmc_opendrain(slot, 0);
  297. break;
  298. default:
  299. BUG();
  300. }
  301. if (r != 0 && printk_ratelimit())
  302. dev_err(dev, "MMC: unable to set bus mode for slot %d\n",
  303. slot);
  304. return r;
  305. }
  306. static int n8x0_mmc_get_cover_state(struct device *dev, int slot)
  307. {
  308. slot++;
  309. BUG_ON(slot != 1 && slot != 2);
  310. if (slot == 1)
  311. return slot1_cover_open;
  312. else
  313. return slot2_cover_open;
  314. }
  315. static void n8x0_mmc_callback(void *data, u8 card_mask)
  316. {
  317. int bit, *openp, index;
  318. if (machine_is_nokia_n800()) {
  319. bit = 1 << 1;
  320. openp = &slot2_cover_open;
  321. index = 1;
  322. } else {
  323. bit = 1;
  324. openp = &slot1_cover_open;
  325. index = 0;
  326. }
  327. if (card_mask & bit)
  328. *openp = 1;
  329. else
  330. *openp = 0;
  331. omap_mmc_notify_cover_event(mmc_device, index, *openp);
  332. }
  333. static int n8x0_mmc_late_init(struct device *dev)
  334. {
  335. int r, bit, *openp;
  336. int vs2sel;
  337. mmc_device = dev;
  338. r = menelaus_set_slot_sel(1);
  339. if (r < 0)
  340. return r;
  341. if (machine_is_nokia_n800())
  342. vs2sel = 0;
  343. else
  344. vs2sel = 2;
  345. r = menelaus_set_mmc_slot(2, 0, vs2sel, 1);
  346. if (r < 0)
  347. return r;
  348. n8x0_mmc_set_power(dev, 0, MMC_POWER_ON, 16); /* MMC_VDD_28_29 */
  349. n8x0_mmc_set_power(dev, 1, MMC_POWER_ON, 16);
  350. r = menelaus_set_mmc_slot(1, 1, 0, 1);
  351. if (r < 0)
  352. return r;
  353. r = menelaus_set_mmc_slot(2, 1, vs2sel, 1);
  354. if (r < 0)
  355. return r;
  356. r = menelaus_get_slot_pin_states();
  357. if (r < 0)
  358. return r;
  359. if (machine_is_nokia_n800()) {
  360. bit = 1 << 1;
  361. openp = &slot2_cover_open;
  362. } else {
  363. bit = 1;
  364. openp = &slot1_cover_open;
  365. slot2_cover_open = 0;
  366. }
  367. /* All slot pin bits seem to be inversed until first switch change */
  368. if (r == 0xf || r == (0xf & ~bit))
  369. r = ~r;
  370. if (r & bit)
  371. *openp = 1;
  372. else
  373. *openp = 0;
  374. r = menelaus_register_mmc_callback(n8x0_mmc_callback, NULL);
  375. return r;
  376. }
  377. static void n8x0_mmc_shutdown(struct device *dev)
  378. {
  379. int vs2sel;
  380. if (machine_is_nokia_n800())
  381. vs2sel = 0;
  382. else
  383. vs2sel = 2;
  384. menelaus_set_mmc_slot(1, 0, 0, 0);
  385. menelaus_set_mmc_slot(2, 0, vs2sel, 0);
  386. }
  387. static void n8x0_mmc_cleanup(struct device *dev)
  388. {
  389. menelaus_unregister_mmc_callback();
  390. gpio_free(N8X0_SLOT_SWITCH_GPIO);
  391. if (machine_is_nokia_n810()) {
  392. gpio_free(N810_EMMC_VSD_GPIO);
  393. gpio_free(N810_EMMC_VIO_GPIO);
  394. }
  395. }
  396. /*
  397. * MMC controller1 has two slots that are multiplexed via I2C.
  398. * MMC controller2 is not in use.
  399. */
  400. static struct omap_mmc_platform_data mmc1_data = {
  401. .nr_slots = 2,
  402. .switch_slot = n8x0_mmc_switch_slot,
  403. .init = n8x0_mmc_late_init,
  404. .cleanup = n8x0_mmc_cleanup,
  405. .shutdown = n8x0_mmc_shutdown,
  406. .max_freq = 24000000,
  407. .dma_mask = 0xffffffff,
  408. .slots[0] = {
  409. .wires = 4,
  410. .set_power = n8x0_mmc_set_power,
  411. .set_bus_mode = n8x0_mmc_set_bus_mode,
  412. .get_cover_state = n8x0_mmc_get_cover_state,
  413. .ocr_mask = MMC_VDD_165_195 | MMC_VDD_30_31 |
  414. MMC_VDD_32_33 | MMC_VDD_33_34,
  415. .name = "internal",
  416. },
  417. .slots[1] = {
  418. .set_power = n8x0_mmc_set_power,
  419. .set_bus_mode = n8x0_mmc_set_bus_mode,
  420. .get_cover_state = n8x0_mmc_get_cover_state,
  421. .ocr_mask = MMC_VDD_165_195 | MMC_VDD_20_21 |
  422. MMC_VDD_21_22 | MMC_VDD_22_23 |
  423. MMC_VDD_23_24 | MMC_VDD_24_25 |
  424. MMC_VDD_27_28 | MMC_VDD_28_29 |
  425. MMC_VDD_29_30 | MMC_VDD_30_31 |
  426. MMC_VDD_32_33 | MMC_VDD_33_34,
  427. .name = "external",
  428. },
  429. };
  430. static struct omap_mmc_platform_data *mmc_data[OMAP24XX_NR_MMC];
  431. static void __init n8x0_mmc_init(void)
  432. {
  433. int err;
  434. if (machine_is_nokia_n810()) {
  435. mmc1_data.slots[0].name = "external";
  436. /*
  437. * Some Samsung Movinand chips do not like open-ended
  438. * multi-block reads and fall to braind-dead state
  439. * while doing so. Reducing the number of blocks in
  440. * the transfer or delays in clock disable do not help
  441. */
  442. mmc1_data.slots[1].name = "internal";
  443. mmc1_data.slots[1].ban_openended = 1;
  444. }
  445. err = gpio_request(N8X0_SLOT_SWITCH_GPIO, "MMC slot switch");
  446. if (err)
  447. return;
  448. gpio_direction_output(N8X0_SLOT_SWITCH_GPIO, 0);
  449. if (machine_is_nokia_n810()) {
  450. err = gpio_request(N810_EMMC_VSD_GPIO, "MMC slot 2 Vddf");
  451. if (err) {
  452. gpio_free(N8X0_SLOT_SWITCH_GPIO);
  453. return;
  454. }
  455. gpio_direction_output(N810_EMMC_VSD_GPIO, 0);
  456. err = gpio_request(N810_EMMC_VIO_GPIO, "MMC slot 2 Vdd");
  457. if (err) {
  458. gpio_free(N8X0_SLOT_SWITCH_GPIO);
  459. gpio_free(N810_EMMC_VSD_GPIO);
  460. return;
  461. }
  462. gpio_direction_output(N810_EMMC_VIO_GPIO, 0);
  463. }
  464. mmc_data[0] = &mmc1_data;
  465. omap2_init_mmc(mmc_data, OMAP24XX_NR_MMC);
  466. }
  467. #else
  468. void __init n8x0_mmc_init(void)
  469. {
  470. }
  471. #endif /* CONFIG_MMC_OMAP */
  472. #ifdef CONFIG_MENELAUS
  473. static int n8x0_auto_sleep_regulators(void)
  474. {
  475. u32 val;
  476. int ret;
  477. val = EN_VPLL_SLEEP | EN_VMMC_SLEEP \
  478. | EN_VAUX_SLEEP | EN_VIO_SLEEP \
  479. | EN_VMEM_SLEEP | EN_DC3_SLEEP \
  480. | EN_VC_SLEEP | EN_DC2_SLEEP;
  481. ret = menelaus_set_regulator_sleep(1, val);
  482. if (ret < 0) {
  483. printk(KERN_ERR "Could not set regulators to sleep on "
  484. "menelaus: %u\n", ret);
  485. return ret;
  486. }
  487. return 0;
  488. }
  489. static int n8x0_auto_voltage_scale(void)
  490. {
  491. int ret;
  492. ret = menelaus_set_vcore_hw(1400, 1050);
  493. if (ret < 0) {
  494. printk(KERN_ERR "Could not set VCORE voltage on "
  495. "menelaus: %u\n", ret);
  496. return ret;
  497. }
  498. return 0;
  499. }
  500. static int n8x0_menelaus_late_init(struct device *dev)
  501. {
  502. int ret;
  503. ret = n8x0_auto_voltage_scale();
  504. if (ret < 0)
  505. return ret;
  506. ret = n8x0_auto_sleep_regulators();
  507. if (ret < 0)
  508. return ret;
  509. return 0;
  510. }
  511. #else
  512. static int n8x0_menelaus_late_init(struct device *dev)
  513. {
  514. return 0;
  515. }
  516. #endif
  517. static struct menelaus_platform_data n8x0_menelaus_platform_data __initdata = {
  518. .late_init = n8x0_menelaus_late_init,
  519. };
  520. static struct i2c_board_info __initdata n8x0_i2c_board_info_1[] __initdata = {
  521. {
  522. I2C_BOARD_INFO("menelaus", 0x72),
  523. .irq = INT_24XX_SYS_NIRQ,
  524. .platform_data = &n8x0_menelaus_platform_data,
  525. },
  526. };
  527. static struct aic3x_pdata n810_aic33_data __initdata = {
  528. .gpio_reset = 118,
  529. };
  530. static struct i2c_board_info n810_i2c_board_info_2[] __initdata = {
  531. {
  532. I2C_BOARD_INFO("tlv320aic3x", 0x18),
  533. .platform_data = &n810_aic33_data,
  534. },
  535. };
  536. static void __init n8x0_map_io(void)
  537. {
  538. omap2_set_globals_242x();
  539. omap242x_map_common_io();
  540. }
  541. static void __init n8x0_init_irq(void)
  542. {
  543. omap2_init_common_infrastructure();
  544. omap2_init_common_devices(NULL, NULL);
  545. omap_init_irq();
  546. }
  547. #ifdef CONFIG_OMAP_MUX
  548. static struct omap_board_mux board_mux[] __initdata = {
  549. /* I2S codec port pins for McBSP block */
  550. OMAP2420_MUX(EAC_AC_SCLK, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
  551. OMAP2420_MUX(EAC_AC_FS, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
  552. OMAP2420_MUX(EAC_AC_DIN, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
  553. OMAP2420_MUX(EAC_AC_DOUT, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
  554. { .reg_offset = OMAP_MUX_TERMINATOR },
  555. };
  556. #endif
  557. static void __init n8x0_init_machine(void)
  558. {
  559. omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAC);
  560. /* FIXME: add n810 spi devices */
  561. spi_register_board_info(n800_spi_board_info,
  562. ARRAY_SIZE(n800_spi_board_info));
  563. omap_register_i2c_bus(1, 400, n8x0_i2c_board_info_1,
  564. ARRAY_SIZE(n8x0_i2c_board_info_1));
  565. omap_register_i2c_bus(2, 400, NULL, 0);
  566. if (machine_is_nokia_n810())
  567. i2c_register_board_info(2, n810_i2c_board_info_2,
  568. ARRAY_SIZE(n810_i2c_board_info_2));
  569. omap_serial_init();
  570. gpmc_onenand_init(board_onenand_data);
  571. n8x0_mmc_init();
  572. n8x0_usb_init();
  573. }
  574. MACHINE_START(NOKIA_N800, "Nokia N800")
  575. .boot_params = 0x80000100,
  576. .map_io = n8x0_map_io,
  577. .reserve = omap_reserve,
  578. .init_irq = n8x0_init_irq,
  579. .init_machine = n8x0_init_machine,
  580. .timer = &omap_timer,
  581. MACHINE_END
  582. MACHINE_START(NOKIA_N810, "Nokia N810")
  583. .boot_params = 0x80000100,
  584. .map_io = n8x0_map_io,
  585. .reserve = omap_reserve,
  586. .init_irq = n8x0_init_irq,
  587. .init_machine = n8x0_init_machine,
  588. .timer = &omap_timer,
  589. MACHINE_END
  590. MACHINE_START(NOKIA_N810_WIMAX, "Nokia N810 WiMAX")
  591. .boot_params = 0x80000100,
  592. .map_io = n8x0_map_io,
  593. .reserve = omap_reserve,
  594. .init_irq = n8x0_init_irq,
  595. .init_machine = n8x0_init_machine,
  596. .timer = &omap_timer,
  597. MACHINE_END