arch/arm/mach-omap2/board-omap3beagle.c

   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 #include <linux/opp.h>
  27
  28 #include <linux/mtd/mtd.h>
  29 #include <linux/mtd/partitions.h>
  30 #include <linux/mtd/nand.h>
  31 #include <linux/mmc/host.h>
  32
  33 #include <linux/regulator/machine.h>
  34 #include <linux/i2c/twl.h>
  35
  36 #include <mach/hardware.h>
  37 #include <asm/mach-types.h>
  38 #include <asm/mach/arch.h>
  39 #include <asm/mach/map.h>
  40 #include <asm/mach/flash.h>
  41
  42 #include <plat/board.h>
  43 #include <plat/common.h>
  44 #include <plat/display.h>
  45 #include <plat/panel-generic-dpi.h>
  46 #include <plat/gpmc.h>
  47 #include <plat/nand.h>
  48 #include <plat/usb.h>
  49 #include <plat/omap_device.h>
  50
  51 #include "mux.h"
  52 #include "hsmmc.h"
  53 #include "timer-gp.h"
  54 #include "pm.h"
  55 #include "common-board-devices.h"
  56
  57 #define NAND_BLOCK_SIZE         SZ_128K
  58
  59 /*
  60  * OMAP3 Beagle revision
  61  * Run time detection of Beagle revision is done by reading GPIO.
  62  * GPIO ID -
  63  *      AXBX    = GPIO173, GPIO172, GPIO171: 1 1 1
  64  *      C1_3    = GPIO173, GPIO172, GPIO171: 1 1 0
  65  *      C4      = GPIO173, GPIO172, GPIO171: 1 0 1
  66  *      XM      = GPIO173, GPIO172, GPIO171: 0 0 0
  67  */
  68 enum {
  69         OMAP3BEAGLE_BOARD_UNKN = 0,
  70         OMAP3BEAGLE_BOARD_AXBX,
  71         OMAP3BEAGLE_BOARD_C1_3,
  72         OMAP3BEAGLE_BOARD_C4,
  73         OMAP3BEAGLE_BOARD_XM,
  74 };
  75
  76 static u8 omap3_beagle_version;
  77
  78 static u8 omap3_beagle_get_rev(void)
  79 {
  80         return omap3_beagle_version;
  81 }
  82
  83 static void __init omap3_beagle_init_rev(void)
  84 {
  85         int ret;
  86         u16 beagle_rev = 0;
  87
  88         omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP);
  89         omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
  90         omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);
  91
  92         ret = gpio_request(171, "rev_id_0");
  93         if (ret < 0)
  94                 goto fail0;
  95
  96         ret = gpio_request(172, "rev_id_1");
  97         if (ret < 0)
  98                 goto fail1;
  99
 100         ret = gpio_request(173, "rev_id_2");
 101         if (ret < 0)
 102                 goto fail2;
 103
 104         gpio_direction_input(171);
 105         gpio_direction_input(172);
 106         gpio_direction_input(173);
 107
 108         beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
 109                         | (gpio_get_value(173) << 2);
 110
 111         switch (beagle_rev) {
 112         case 7:
 113                 printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n");
 114                 omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX;
 115                 break;
 116         case 6:
 117                 printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n");
 118                 omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3;
 119                 break;
 120         case 5:
 121                 printk(KERN_INFO "OMAP3 Beagle Rev: C4\n");
 122                 omap3_beagle_version = OMAP3BEAGLE_BOARD_C4;
 123                 break;
 124         case 0:
 125                 printk(KERN_INFO "OMAP3 Beagle Rev: xM\n");
 126                 omap3_beagle_version = OMAP3BEAGLE_BOARD_XM;
 127                 break;
 128         default:
 129                 printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
 130                 omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
 131         }
 132
 133         return;
 134
 135 fail2:
 136         gpio_free(172);
 137 fail1:
 138         gpio_free(171);
 139 fail0:
 140         printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
 141         omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
 142
 143         return;
 144 }
 145
 146 static struct mtd_partition omap3beagle_nand_partitions[] = {
 147         /* All the partition sizes are listed in terms of NAND block size */
 148         {
 149                 .name           = "X-Loader",
 150                 .offset         = 0,
 151                 .size           = 4 * NAND_BLOCK_SIZE,
 152                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 153         },
 154         {
 155                 .name           = "U-Boot",
 156                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
 157                 .size           = 15 * NAND_BLOCK_SIZE,
 158                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 159         },
 160         {
 161                 .name           = "U-Boot Env",
 162                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x260000 */
 163                 .size           = 1 * NAND_BLOCK_SIZE,
 164         },
 165         {
 166                 .name           = "Kernel",
 167                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
 168                 .size           = 32 * NAND_BLOCK_SIZE,
 169         },
 170         {
 171                 .name           = "File System",
 172                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x680000 */
 173                 .size           = MTDPART_SIZ_FULL,
 174         },
 175 };
 176
 177 /* DSS */
 178
 179 static int beagle_enable_dvi(struct omap_dss_device *dssdev)
 180 {
 181         if (gpio_is_valid(dssdev->reset_gpio))
 182                 gpio_set_value(dssdev->reset_gpio, 1);
 183
 184         return 0;
 185 }
 186
 187 static void beagle_disable_dvi(struct omap_dss_device *dssdev)
 188 {
 189         if (gpio_is_valid(dssdev->reset_gpio))
 190                 gpio_set_value(dssdev->reset_gpio, 0);
 191 }
 192
 193 static struct panel_generic_dpi_data dvi_panel = {
 194         .name = "generic",
 195         .platform_enable = beagle_enable_dvi,
 196         .platform_disable = beagle_disable_dvi,
 197 };
 198
 199 static struct omap_dss_device beagle_dvi_device = {
 200         .type = OMAP_DISPLAY_TYPE_DPI,
 201         .name = "dvi",
 202         .driver_name = "generic_dpi_panel",
 203         .data = &dvi_panel,
 204         .phy.dpi.data_lines = 24,
 205         .reset_gpio = -EINVAL,
 206 };
 207
 208 static struct omap_dss_device beagle_tv_device = {
 209         .name = "tv",
 210         .driver_name = "venc",
 211         .type = OMAP_DISPLAY_TYPE_VENC,
 212         .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
 213 };
 214
 215 static struct omap_dss_device *beagle_dss_devices[] = {
 216         &beagle_dvi_device,
 217         &beagle_tv_device,
 218 };
 219
 220 static struct omap_dss_board_info beagle_dss_data = {
 221         .num_devices = ARRAY_SIZE(beagle_dss_devices),
 222         .devices = beagle_dss_devices,
 223         .default_device = &beagle_dvi_device,
 224 };
 225
 226 static struct regulator_consumer_supply beagle_vdac_supply =
 227         REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
 228
 229 static struct regulator_consumer_supply beagle_vdvi_supplies[] = {
 230         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 231         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 232 };
 233
 234 static void __init beagle_display_init(void)
 235 {
 236         int r;
 237
 238         r = gpio_request(beagle_dvi_device.reset_gpio, "DVI reset");
 239         if (r < 0) {
 240                 printk(KERN_ERR "Unable to get DVI reset GPIO\n");
 241                 return;
 242         }
 243
 244         gpio_direction_output(beagle_dvi_device.reset_gpio, 0);
 245 }
 246
 247 #include "sdram-micron-mt46h32m32lf-6.h"
 248
 249 static struct omap2_hsmmc_info mmc[] = {
 250         {
 251                 .mmc            = 1,
 252                 .caps           = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
 253                 .gpio_wp        = 29,
 254         },
 255         {}      /* Terminator */
 256 };
 257
 258 static struct regulator_consumer_supply beagle_vmmc1_supply = {
 259         .supply                 = "vmmc",
 260 };
 261
 262 static struct regulator_consumer_supply beagle_vsim_supply = {
 263         .supply                 = "vmmc_aux",
 264 };
 265
 266 static struct gpio_led gpio_leds[];
 267
 268 static int beagle_twl_gpio_setup(struct device *dev,
 269                 unsigned gpio, unsigned ngpio)
 270 {
 271         int r;
 272
 273         if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
 274                 mmc[0].gpio_wp = -EINVAL;
 275         } else if ((omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C1_3) ||
 276                 (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C4)) {
 277                 omap_mux_init_gpio(23, OMAP_PIN_INPUT);
 278                 mmc[0].gpio_wp = 23;
 279         } else {
 280                 omap_mux_init_gpio(29, OMAP_PIN_INPUT);
 281         }
 282         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
 283         mmc[0].gpio_cd = gpio + 0;
 284         omap2_hsmmc_init(mmc);
 285
 286         /* link regulators to MMC adapters */
 287         beagle_vmmc1_supply.dev = mmc[0].dev;
 288         beagle_vsim_supply.dev = mmc[0].dev;
 289
 290         /* REVISIT: need ehci-omap hooks for external VBUS
 291          * power switch and overcurrent detect
 292          */
 293         if (omap3_beagle_get_rev() != OMAP3BEAGLE_BOARD_XM) {
 294                 r = gpio_request(gpio + 1, "EHCI_nOC");
 295                 if (!r) {
 296                         r = gpio_direction_input(gpio + 1);
 297                         if (r)
 298                                 gpio_free(gpio + 1);
 299                 }
 300                 if (r)
 301                         pr_err("%s: unable to configure EHCI_nOC\n", __func__);
 302         }
 303
 304         /*
 305          * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
 306          * high / others active low)
 307          */
 308         gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
 309         if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
 310                 gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1);
 311         else
 312                 gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
 313
 314         /* DVI reset GPIO is different between beagle revisions */
 315         if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
 316                 beagle_dvi_device.reset_gpio = 129;
 317         else
 318                 beagle_dvi_device.reset_gpio = 170;
 319
 320         /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
 321         gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
 322
 323         /*
 324          * gpio + 1 on Xm controls the TFP410's enable line (active low)
 325          * gpio + 2 control varies depending on the board rev as follows:
 326          * P7/P8 revisions(prototype): Camera EN
 327          * A2+ revisions (production): LDO (supplies DVI, serial, led blocks)
 328          */
 329         if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
 330                 r = gpio_request(gpio + 1, "nDVI_PWR_EN");
 331                 if (!r) {
 332                         r = gpio_direction_output(gpio + 1, 0);
 333                         if (r)
 334                                 gpio_free(gpio + 1);
 335                 }
 336                 if (r)
 337                         pr_err("%s: unable to configure nDVI_PWR_EN\n",
 338                                 __func__);
 339                 r = gpio_request(gpio + 2, "DVI_LDO_EN");
 340                 if (!r) {
 341                         r = gpio_direction_output(gpio + 2, 1);
 342                         if (r)
 343                                 gpio_free(gpio + 2);
 344                 }
 345                 if (r)
 346                         pr_err("%s: unable to configure DVI_LDO_EN\n",
 347                                 __func__);
 348         }
 349
 350         return 0;
 351 }
 352
 353 static struct twl4030_gpio_platform_data beagle_gpio_data = {
 354         .gpio_base      = OMAP_MAX_GPIO_LINES,
 355         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 356         .irq_end        = TWL4030_GPIO_IRQ_END,
 357         .use_leds       = true,
 358         .pullups        = BIT(1),
 359         .pulldowns      = BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13)
 360                                 | BIT(15) | BIT(16) | BIT(17),
 361         .setup          = beagle_twl_gpio_setup,
 362 };
 363
 364 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
 365 static struct regulator_init_data beagle_vmmc1 = {
 366         .constraints = {
 367                 .min_uV                 = 1850000,
 368                 .max_uV                 = 3150000,
 369                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 370                                         | REGULATOR_MODE_STANDBY,
 371                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 372                                         | REGULATOR_CHANGE_MODE
 373                                         | REGULATOR_CHANGE_STATUS,
 374         },
 375         .num_consumer_supplies  = 1,
 376         .consumer_supplies      = &beagle_vmmc1_supply,
 377 };
 378
 379 /* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
 380 static struct regulator_init_data beagle_vsim = {
 381         .constraints = {
 382                 .min_uV                 = 1800000,
 383                 .max_uV                 = 3000000,
 384                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 385                                         | REGULATOR_MODE_STANDBY,
 386                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 387                                         | REGULATOR_CHANGE_MODE
 388                                         | REGULATOR_CHANGE_STATUS,
 389         },
 390         .num_consumer_supplies  = 1,
 391         .consumer_supplies      = &beagle_vsim_supply,
 392 };
 393
 394 /* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
 395 static struct regulator_init_data beagle_vdac = {
 396         .constraints = {
 397                 .min_uV                 = 1800000,
 398                 .max_uV                 = 1800000,
 399                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 400                                         | REGULATOR_MODE_STANDBY,
 401                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 402                                         | REGULATOR_CHANGE_STATUS,
 403         },
 404         .num_consumer_supplies  = 1,
 405         .consumer_supplies      = &beagle_vdac_supply,
 406 };
 407
 408 /* VPLL2 for digital video outputs */
 409 static struct regulator_init_data beagle_vpll2 = {
 410         .constraints = {
 411                 .name                   = "VDVI",
 412                 .min_uV                 = 1800000,
 413                 .max_uV                 = 1800000,
 414                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 415                                         | REGULATOR_MODE_STANDBY,
 416                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 417                                         | REGULATOR_CHANGE_STATUS,
 418         },
 419         .num_consumer_supplies  = ARRAY_SIZE(beagle_vdvi_supplies),
 420         .consumer_supplies      = beagle_vdvi_supplies,
 421 };
 422
 423 static struct twl4030_usb_data beagle_usb_data = {
 424         .usb_mode       = T2_USB_MODE_ULPI,
 425 };
 426
 427 static struct twl4030_codec_audio_data beagle_audio_data;
 428
 429 static struct twl4030_codec_data beagle_codec_data = {
 430         .audio_mclk = 26000000,
 431         .audio = &beagle_audio_data,
 432 };
 433
 434 static struct twl4030_platform_data beagle_twldata = {
 435         .irq_base       = TWL4030_IRQ_BASE,
 436         .irq_end        = TWL4030_IRQ_END,
 437
 438         /* platform_data for children goes here */
 439         .usb            = &beagle_usb_data,
 440         .gpio           = &beagle_gpio_data,
 441         .codec          = &beagle_codec_data,
 442         .vmmc1          = &beagle_vmmc1,
 443         .vsim           = &beagle_vsim,
 444         .vdac           = &beagle_vdac,
 445         .vpll2          = &beagle_vpll2,
 446 };
 447
 448 static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
 449        {
 450                I2C_BOARD_INFO("eeprom", 0x50),
 451        },
 452 };
 453
 454 static int __init omap3_beagle_i2c_init(void)
 455 {
 456         omap3_pmic_init("twl4030", &beagle_twldata);
 457         /* Bus 3 is attached to the DVI port where devices like the pico DLP
 458          * projector don't work reliably with 400kHz */
 459         omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
 460         return 0;
 461 }
 462
 463 static struct gpio_led gpio_leds[] = {
 464         {
 465                 .name                   = "beagleboard::usr0",
 466                 .default_trigger        = "heartbeat",
 467                 .gpio                   = 150,
 468         },
 469         {
 470                 .name                   = "beagleboard::usr1",
 471                 .default_trigger        = "mmc0",
 472                 .gpio                   = 149,
 473         },
 474         {
 475                 .name                   = "beagleboard::pmu_stat",
 476                 .gpio                   = -EINVAL,      /* gets replaced */
 477                 .active_low             = true,
 478         },
 479 };
 480
 481 static struct gpio_led_platform_data gpio_led_info = {
 482         .leds           = gpio_leds,
 483         .num_leds       = ARRAY_SIZE(gpio_leds),
 484 };
 485
 486 static struct platform_device leds_gpio = {
 487         .name   = "leds-gpio",
 488         .id     = -1,
 489         .dev    = {
 490                 .platform_data  = &gpio_led_info,
 491         },
 492 };
 493
 494 static struct gpio_keys_button gpio_buttons[] = {
 495         {
 496                 .code                   = BTN_EXTRA,
 497                 .gpio                   = 7,
 498                 .desc                   = "user",
 499                 .wakeup                 = 1,
 500         },
 501 };
 502
 503 static struct gpio_keys_platform_data gpio_key_info = {
 504         .buttons        = gpio_buttons,
 505         .nbuttons       = ARRAY_SIZE(gpio_buttons),
 506 };
 507
 508 static struct platform_device keys_gpio = {
 509         .name   = "gpio-keys",
 510         .id     = -1,
 511         .dev    = {
 512                 .platform_data  = &gpio_key_info,
 513         },
 514 };
 515
 516 static void __init omap3_beagle_init_early(void)
 517 {
 518         omap2_init_common_infrastructure();
 519         omap2_init_common_devices(mt46h32m32lf6_sdrc_params,
 520                                   mt46h32m32lf6_sdrc_params);
 521 }
 522
 523 static void __init omap3_beagle_init_irq(void)
 524 {
 525         omap_init_irq();
 526 #ifdef CONFIG_OMAP_32K_TIMER
 527         omap2_gp_clockevent_set_gptimer(12);
 528 #endif
 529 }
 530
 531 static struct platform_device *omap3_beagle_devices[] __initdata = {
 532         &leds_gpio,
 533         &keys_gpio,
 534 };
 535
 536 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 537
 538         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
 539         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 540         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 541
 542         .phy_reset  = true,
 543         .reset_gpio_port[0]  = -EINVAL,
 544         .reset_gpio_port[1]  = 147,
 545         .reset_gpio_port[2]  = -EINVAL
 546 };
 547
 548 #ifdef CONFIG_OMAP_MUX
 549 static struct omap_board_mux board_mux[] __initdata = {
 550         { .reg_offset = OMAP_MUX_TERMINATOR },
 551 };
 552 #endif
 553
 554 static struct omap_musb_board_data musb_board_data = {
 555         .interface_type         = MUSB_INTERFACE_ULPI,
 556         .mode                   = MUSB_OTG,
 557         .power                  = 100,
 558 };
 559
 560 static void __init beagle_opp_init(void)
 561 {
 562         int r = 0;
 563
 564         /* Initialize the omap3 opp table */
 565         if (omap3_opp_init()) {
 566                 pr_err("%s: opp default init failed\n", __func__);
 567                 return;
 568         }
 569
 570         /* Custom OPP enabled for XM */
 571         if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
 572                 struct omap_hwmod *mh = omap_hwmod_lookup("mpu");
 573                 struct omap_hwmod *dh = omap_hwmod_lookup("iva");
 574                 struct device *dev;
 575
 576                 if (!mh || !dh) {
 577                         pr_err("%s: Aiee.. no mpu/dsp devices? %p %p\n",
 578                                 __func__, mh, dh);
 579                         return;
 580                 }
 581                 /* Enable MPU 1GHz and lower opps */
 582                 dev = &mh->od->pdev.dev;
 583                 r = opp_enable(dev, 800000000);
 584                 /* TODO: MPU 1GHz needs SR and ABB */
 585
 586                 /* Enable IVA 800MHz and lower opps */
 587                 dev = &dh->od->pdev.dev;
 588                 r |= opp_enable(dev, 660000000);
 589                 /* TODO: DSP 800MHz needs SR and ABB */
 590                 if (r) {
 591                         pr_err("%s: failed to enable higher opp %d\n",
 592                                 __func__, r);
 593                         /*
 594                          * Cleanup - disable the higher freqs - we dont care
 595                          * about the results
 596                          */
 597                         dev = &mh->od->pdev.dev;
 598                         opp_disable(dev, 800000000);
 599                         dev = &dh->od->pdev.dev;
 600                         opp_disable(dev, 660000000);
 601                 }
 602         }
 603         return;
 604 }
 605
 606 static void __init omap3_beagle_init(void)
 607 {
 608         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 609         omap3_beagle_init_rev();
 610         omap3_beagle_i2c_init();
 611         platform_add_devices(omap3_beagle_devices,
 612                         ARRAY_SIZE(omap3_beagle_devices));
 613         omap_display_init(&beagle_dss_data);
 614         omap_serial_init();
 615
 616         omap_mux_init_gpio(170, OMAP_PIN_INPUT);
 617         gpio_request(170, "DVI_nPD");
 618         /* REVISIT leave DVI powered down until it's needed ... */
 619         gpio_direction_output(170, true);
 620
 621         usb_musb_init(&musb_board_data);
 622         usbhs_init(&usbhs_bdata);
 623         omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
 624                              ARRAY_SIZE(omap3beagle_nand_partitions));
 625
 626         /* Ensure SDRC pins are mux'd for self-refresh */
 627         omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
 628         omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
 629
 630         beagle_display_init();
 631         beagle_opp_init();
 632 }
 633
 634 MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board")
 635         /* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */
 636         .boot_params    = 0x80000100,
 637         .reserve        = omap_reserve,
 638         .map_io         = omap3_map_io,
 639         .init_early     = omap3_beagle_init_early,
 640         .init_irq       = omap3_beagle_init_irq,
 641         .init_machine   = omap3_beagle_init,
 642         .timer          = &omap_timer,
 643 MACHINE_END