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