1/* 2 * linux/arch/arm/mach-omap2/board-omap3beagle.c 3 * 4 * Copyright (C) 2008 Texas Instruments 5 * 6 * Modified from mach-omap2/board-3430sdp.c 7 * 8 * Initial code: Syed Mohammed Khasim 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 15#include <linux/kernel.h> 16#include <linux/init.h> 17#include <linux/platform_device.h> 18#include <linux/delay.h> 19#include <linux/err.h> 20#include <linux/clk.h> 21#include <linux/io.h> 22#include <linux/leds.h> 23#include <linux/gpio.h> 24#include <linux/input.h> 25#include <linux/gpio_keys.h> 26 27#include <linux/mtd/mtd.h> 28#include <linux/mtd/partitions.h> 29#include <linux/mtd/nand.h> 30 31#include <linux/regulator/machine.h> 32#include <linux/i2c/twl.h> 33 34#include <mach/hardware.h> 35#include <asm/mach-types.h> 36#include <asm/mach/arch.h> 37#include <asm/mach/map.h> 38#include <asm/mach/flash.h> 39 40#include <plat/board.h> 41#include <plat/common.h> 42#include <plat/display.h> 43#include <plat/gpmc.h> 44#include <plat/nand.h> 45#include <plat/usb.h> 46#include <plat/timer-gp.h> 47 48#include "mux.h" 49#include "hsmmc.h" 50 51#define NAND_BLOCK_SIZE SZ_128K 52 53static struct mtd_partition omap3beagle_nand_partitions[] = { 54 /* All the partition sizes are listed in terms of NAND block size */ 55 { 56 .name = "X-Loader", 57 .offset = 0, 58 .size = 4 * NAND_BLOCK_SIZE, 59 .mask_flags = MTD_WRITEABLE, /* force read-only */ 60 }, 61 { 62 .name = "U-Boot", 63 .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */ 64 .size = 15 * NAND_BLOCK_SIZE, 65 .mask_flags = MTD_WRITEABLE, /* force read-only */ 66 }, 67 { 68 .name = "U-Boot Env", 69 .offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */ 70 .size = 1 * NAND_BLOCK_SIZE, 71 }, 72 { 73 .name = "Kernel", 74 .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */ 75 .size = 32 * NAND_BLOCK_SIZE, 76 }, 77 { 78 .name = "File System", 79 .offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */ 80 .size = MTDPART_SIZ_FULL, 81 }, 82}; 83 84static struct omap_nand_platform_data omap3beagle_nand_data = { 85 .options = NAND_BUSWIDTH_16, 86 .parts = omap3beagle_nand_partitions, 87 .nr_parts = ARRAY_SIZE(omap3beagle_nand_partitions), 88 .dma_channel = -1, /* disable DMA in OMAP NAND driver */ 89 .nand_setup = NULL, 90 .dev_ready = NULL, 91}; 92 93/* DSS */ 94 95static int beagle_enable_dvi(struct omap_dss_device *dssdev) 96{ 97 if (gpio_is_valid(dssdev->reset_gpio)) 98 gpio_set_value(dssdev->reset_gpio, 1); 99 100 return 0; 101} 102 103static void beagle_disable_dvi(struct omap_dss_device *dssdev) 104{ 105 if (gpio_is_valid(dssdev->reset_gpio)) 106 gpio_set_value(dssdev->reset_gpio, 0); 107} 108 109static struct omap_dss_device beagle_dvi_device = { 110 .type = OMAP_DISPLAY_TYPE_DPI, 111 .name = "dvi", 112 .driver_name = "generic_panel", 113 .phy.dpi.data_lines = 24, 114 .reset_gpio = 170, 115 .platform_enable = beagle_enable_dvi, 116 .platform_disable = beagle_disable_dvi, 117}; 118 119static struct omap_dss_device beagle_tv_device = { 120 .name = "tv", 121 .driver_name = "venc", 122 .type = OMAP_DISPLAY_TYPE_VENC, 123 .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO, 124}; 125 126static struct omap_dss_device *beagle_dss_devices[] = { 127 &beagle_dvi_device, 128 &beagle_tv_device, 129}; 130 131static struct omap_dss_board_info beagle_dss_data = { 132 .num_devices = ARRAY_SIZE(beagle_dss_devices), 133 .devices = beagle_dss_devices, 134 .default_device = &beagle_dvi_device, 135}; 136 137static struct platform_device beagle_dss_device = { 138 .name = "omapdss", 139 .id = -1, 140 .dev = { 141 .platform_data = &beagle_dss_data, 142 }, 143}; 144 145static struct regulator_consumer_supply beagle_vdac_supply = 146 REGULATOR_SUPPLY("vdda_dac", "omapdss"); 147 148static struct regulator_consumer_supply beagle_vdvi_supply = 149 REGULATOR_SUPPLY("vdds_dsi", "omapdss"); 150 151static void __init beagle_display_init(void) 152{ 153 int r; 154 155 r = gpio_request(beagle_dvi_device.reset_gpio, "DVI reset"); 156 if (r < 0) { 157 printk(KERN_ERR "Unable to get DVI reset GPIO\n"); 158 return; 159 } 160 161 gpio_direction_output(beagle_dvi_device.reset_gpio, 0); 162} 163 164#include "sdram-micron-mt46h32m32lf-6.h" 165 166static struct omap2_hsmmc_info mmc[] = { 167 { 168 .mmc = 1, 169 .wires = 8, 170 .gpio_wp = 29, 171 }, 172 {} /* Terminator */ 173}; 174 175static struct regulator_consumer_supply beagle_vmmc1_supply = { 176 .supply = "vmmc", 177}; 178 179static struct regulator_consumer_supply beagle_vsim_supply = { 180 .supply = "vmmc_aux", 181}; 182 183static struct gpio_led gpio_leds[]; 184 185static int beagle_twl_gpio_setup(struct device *dev, 186 unsigned gpio, unsigned ngpio) 187{ 188 if (system_rev >= 0x20 && system_rev <= 0x34301000) { 189 omap_mux_init_gpio(23, OMAP_PIN_INPUT); 190 mmc[0].gpio_wp = 23; 191 } else { 192 omap_mux_init_gpio(29, OMAP_PIN_INPUT); 193 } 194 /* gpio + 0 is "mmc0_cd" (input/IRQ) */ 195 mmc[0].gpio_cd = gpio + 0; 196 omap2_hsmmc_init(mmc); 197 198 /* link regulators to MMC adapters */ 199 beagle_vmmc1_supply.dev = mmc[0].dev; 200 beagle_vsim_supply.dev = mmc[0].dev; 201 202 /* REVISIT: need ehci-omap hooks for external VBUS 203 * power switch and overcurrent detect 204 */ 205 206 gpio_request(gpio + 1, "EHCI_nOC"); 207 gpio_direction_input(gpio + 1); 208 209 /* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, active low) */ 210 gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR"); 211 gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0); 212 213 /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */ 214 gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1; 215 216 return 0; 217} 218 219static struct twl4030_gpio_platform_data beagle_gpio_data = { 220 .gpio_base = OMAP_MAX_GPIO_LINES, 221 .irq_base = TWL4030_GPIO_IRQ_BASE, 222 .irq_end = TWL4030_GPIO_IRQ_END, 223 .use_leds = true, 224 .pullups = BIT(1), 225 .pulldowns = BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13) 226 | BIT(15) | BIT(16) | BIT(17), 227 .setup = beagle_twl_gpio_setup, 228}; 229 230/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */ 231static struct regulator_init_data beagle_vmmc1 = { 232 .constraints = { 233 .min_uV = 1850000, 234 .max_uV = 3150000, 235 .valid_modes_mask = REGULATOR_MODE_NORMAL 236 | REGULATOR_MODE_STANDBY, 237 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE 238 | REGULATOR_CHANGE_MODE 239 | REGULATOR_CHANGE_STATUS, 240 }, 241 .num_consumer_supplies = 1, 242 .consumer_supplies = &beagle_vmmc1_supply, 243}; 244 245/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */ 246static struct regulator_init_data beagle_vsim = { 247 .constraints = { 248 .min_uV = 1800000, 249 .max_uV = 3000000, 250 .valid_modes_mask = REGULATOR_MODE_NORMAL 251 | REGULATOR_MODE_STANDBY, 252 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE 253 | REGULATOR_CHANGE_MODE 254 | REGULATOR_CHANGE_STATUS, 255 }, 256 .num_consumer_supplies = 1, 257 .consumer_supplies = &beagle_vsim_supply, 258}; 259 260/* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */ 261static struct regulator_init_data beagle_vdac = { 262 .constraints = { 263 .min_uV = 1800000, 264 .max_uV = 1800000, 265 .valid_modes_mask = REGULATOR_MODE_NORMAL 266 | REGULATOR_MODE_STANDBY, 267 .valid_ops_mask = REGULATOR_CHANGE_MODE 268 | REGULATOR_CHANGE_STATUS, 269 }, 270 .num_consumer_supplies = 1, 271 .consumer_supplies = &beagle_vdac_supply, 272}; 273 274/* VPLL2 for digital video outputs */ 275static struct regulator_init_data beagle_vpll2 = { 276 .constraints = { 277 .name = "VDVI", 278 .min_uV = 1800000, 279 .max_uV = 1800000, 280 .valid_modes_mask = REGULATOR_MODE_NORMAL 281 | REGULATOR_MODE_STANDBY, 282 .valid_ops_mask = REGULATOR_CHANGE_MODE 283 | REGULATOR_CHANGE_STATUS, 284 }, 285 .num_consumer_supplies = 1, 286 .consumer_supplies = &beagle_vdvi_supply, 287}; 288 289static struct twl4030_usb_data beagle_usb_data = { 290 .usb_mode = T2_USB_MODE_ULPI, 291}; 292 293static struct twl4030_codec_audio_data beagle_audio_data = { 294 .audio_mclk = 26000000, 295}; 296 297static struct twl4030_codec_data beagle_codec_data = { 298 .audio_mclk = 26000000, 299 .audio = &beagle_audio_data, 300}; 301 302static struct twl4030_platform_data beagle_twldata = { 303 .irq_base = TWL4030_IRQ_BASE, 304 .irq_end = TWL4030_IRQ_END, 305 306 /* platform_data for children goes here */ 307 .usb = &beagle_usb_data, 308 .gpio = &beagle_gpio_data, 309 .codec = &beagle_codec_data, 310 .vmmc1 = &beagle_vmmc1, 311 .vsim = &beagle_vsim, 312 .vdac = &beagle_vdac, 313 .vpll2 = &beagle_vpll2, 314}; 315 316static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = { 317 { 318 I2C_BOARD_INFO("twl4030", 0x48), 319 .flags = I2C_CLIENT_WAKE, 320 .irq = INT_34XX_SYS_NIRQ, 321 .platform_data = &beagle_twldata, 322 }, 323}; 324 325static int __init omap3_beagle_i2c_init(void) 326{ 327 omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo, 328 ARRAY_SIZE(beagle_i2c_boardinfo)); 329 /* Bus 3 is attached to the DVI port where devices like the pico DLP 330 * projector don't work reliably with 400kHz */ 331 omap_register_i2c_bus(3, 100, NULL, 0); 332 return 0; 333} 334 335static struct gpio_led gpio_leds[] = { 336 { 337 .name = "beagleboard::usr0", 338 .default_trigger = "heartbeat", 339 .gpio = 150, 340 }, 341 { 342 .name = "beagleboard::usr1", 343 .default_trigger = "mmc0", 344 .gpio = 149, 345 }, 346 { 347 .name = "beagleboard::pmu_stat", 348 .gpio = -EINVAL, /* gets replaced */ 349 .active_low = true, 350 }, 351}; 352 353static struct gpio_led_platform_data gpio_led_info = { 354 .leds = gpio_leds, 355 .num_leds = ARRAY_SIZE(gpio_leds), 356}; 357 358static struct platform_device leds_gpio = { 359 .name = "leds-gpio", 360 .id = -1, 361 .dev = { 362 .platform_data = &gpio_led_info, 363 }, 364}; 365 366static struct gpio_keys_button gpio_buttons[] = { 367 { 368 .code = BTN_EXTRA, 369 .gpio = 7, 370 .desc = "user", 371 .wakeup = 1, 372 }, 373}; 374 375static struct gpio_keys_platform_data gpio_key_info = { 376 .buttons = gpio_buttons, 377 .nbuttons = ARRAY_SIZE(gpio_buttons), 378}; 379 380static struct platform_device keys_gpio = { 381 .name = "gpio-keys", 382 .id = -1, 383 .dev = { 384 .platform_data = &gpio_key_info, 385 }, 386}; 387 388static void __init omap3_beagle_init_irq(void) 389{ 390 omap2_init_common_hw(mt46h32m32lf6_sdrc_params, 391 mt46h32m32lf6_sdrc_params); 392 omap_init_irq(); 393#ifdef CONFIG_OMAP_32K_TIMER 394 omap2_gp_clockevent_set_gptimer(12); 395#endif 396 omap_gpio_init(); 397} 398 399static struct platform_device *omap3_beagle_devices[] __initdata = { 400 &leds_gpio, 401 &keys_gpio, 402 &beagle_dss_device, 403}; 404 405static void __init omap3beagle_flash_init(void) 406{ 407 u8 cs = 0; 408 u8 nandcs = GPMC_CS_NUM + 1; 409 410 /* find out the chip-select on which NAND exists */ 411 while (cs < GPMC_CS_NUM) { 412 u32 ret = 0; 413 ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1); 414 415 if ((ret & 0xC00) == 0x800) { 416 printk(KERN_INFO "Found NAND on CS%d\n", cs); 417 if (nandcs > GPMC_CS_NUM) 418 nandcs = cs; 419 } 420 cs++; 421 } 422 423 if (nandcs > GPMC_CS_NUM) { 424 printk(KERN_INFO "NAND: Unable to find configuration " 425 "in GPMC\n "); 426 return; 427 } 428 429 if (nandcs < GPMC_CS_NUM) { 430 omap3beagle_nand_data.cs = nandcs; 431 432 printk(KERN_INFO "Registering NAND on CS%d\n", nandcs); 433 if (gpmc_nand_init(&omap3beagle_nand_data) < 0) 434 printk(KERN_ERR "Unable to register NAND device\n"); 435 } 436} 437 438static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = { 439 440 .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY, 441 .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY, 442 .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN, 443 444 .phy_reset = true, 445 .reset_gpio_port[0] = -EINVAL, 446 .reset_gpio_port[1] = 147, 447 .reset_gpio_port[2] = -EINVAL 448}; 449 450#ifdef CONFIG_OMAP_MUX 451static struct omap_board_mux board_mux[] __initdata = { 452 { .reg_offset = OMAP_MUX_TERMINATOR }, 453}; 454#else 455#define board_mux NULL 456#endif 457 458static struct omap_musb_board_data musb_board_data = { 459 .interface_type = MUSB_INTERFACE_ULPI, 460 .mode = MUSB_OTG, 461 .power = 100, 462}; 463 464static void __init omap3_beagle_init(void) 465{ 466 omap3_mux_init(board_mux, OMAP_PACKAGE_CBB); 467 omap3_beagle_i2c_init(); 468 platform_add_devices(omap3_beagle_devices, 469 ARRAY_SIZE(omap3_beagle_devices)); 470 omap_serial_init(); 471 472 omap_mux_init_gpio(170, OMAP_PIN_INPUT); 473 gpio_request(170, "DVI_nPD"); 474 /* REVISIT leave DVI powered down until it's needed ... */ 475 gpio_direction_output(170, true); 476 477 usb_musb_init(&musb_board_data); 478 usb_ehci_init(&ehci_pdata); 479 omap3beagle_flash_init(); 480 481 /* Ensure SDRC pins are mux'd for self-refresh */ 482 omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT); 483 omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT); 484 485 beagle_display_init(); 486} 487 488MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board") 489 /* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */ 490 .phys_io = 0x48000000, 491 .io_pg_offst = ((0xfa000000) >> 18) & 0xfffc, 492 .boot_params = 0x80000100, 493 .map_io = omap3_map_io, 494 .reserve = omap_reserve, 495 .init_irq = omap3_beagle_init_irq, 496 .init_machine = omap3_beagle_init, 497 .timer = &omap_timer, 498MACHINE_END 499