board/ti/am57xx/board.c

   1 /*
   2  * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
   3  *
   4  * Author: Felipe Balbi <balbi@ti.com>
   5  *
   6  * Based on board/ti/dra7xx/evm.c
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <palmas.h>
  13 #include <sata.h>
  14 #include <usb.h>
  15 #include <asm/omap_common.h>
  16 #include <asm/emif.h>
  17 #include <asm/gpio.h>
  18 #include <asm/arch/gpio.h>
  19 #include <asm/arch/clock.h>
  20 #include <asm/arch/dra7xx_iodelay.h>
  21 #include <asm/arch/sys_proto.h>
  22 #include <asm/arch/mmc_host_def.h>
  23 #include <asm/arch/sata.h>
  24 #include <asm/arch/gpio.h>
  25 #include <asm/arch/omap.h>
  26 #include <environment.h>
  27 #include <usb.h>
  28 #include <linux/usb/gadget.h>
  29 #include <dwc3-uboot.h>
  30 #include <dwc3-omap-uboot.h>
  31 #include <ti-usb-phy-uboot.h>
  32
  33 #include "../common/board_detect.h"
  34 #include "mux_data.h"
  35
  36 #define board_is_x15()          board_ti_is("BBRDX15_")
  37 #define board_is_am572x_evm()   board_ti_is("AM572PM_")
  38
  39 #ifdef CONFIG_DRIVER_TI_CPSW
  40 #include <cpsw.h>
  41 #endif
  42
  43 DECLARE_GLOBAL_DATA_PTR;
  44
  45 /* GPIO 7_11 */
  46 #define GPIO_DDR_VTT_EN 203
  47
  48 #define SYSINFO_BOARD_NAME_MAX_LEN      45
  49
  50 const struct omap_sysinfo sysinfo = {
  51         "Board: UNKNOWN(BeagleBoard X15?) REV UNKNOWN\n"
  52 };
  53
  54 static const struct dmm_lisa_map_regs beagle_x15_lisa_regs = {
  55         .dmm_lisa_map_3 = 0x80740300,
  56         .is_ma_present  = 0x1
  57 };
  58
  59 void emif_get_dmm_regs(const struct dmm_lisa_map_regs **dmm_lisa_regs)
  60 {
  61         *dmm_lisa_regs = &beagle_x15_lisa_regs;
  62 }
  63
  64 static const struct emif_regs beagle_x15_emif1_ddr3_532mhz_emif_regs = {
  65         .sdram_config_init      = 0x61851b32,
  66         .sdram_config           = 0x61851b32,
  67         .sdram_config2          = 0x08000000,
  68         .ref_ctrl               = 0x000040F1,
  69         .ref_ctrl_final         = 0x00001035,
  70         .sdram_tim1             = 0xcccf36ab,
  71         .sdram_tim2             = 0x308f7fda,
  72         .sdram_tim3             = 0x409f88a8,
  73         .read_idle_ctrl         = 0x00050000,
  74         .zq_config              = 0x5007190b,
  75         .temp_alert_config      = 0x00000000,
  76         .emif_ddr_phy_ctlr_1_init = 0x0024400b,
  77         .emif_ddr_phy_ctlr_1    = 0x0e24400b,
  78         .emif_ddr_ext_phy_ctrl_1 = 0x10040100,
  79         .emif_ddr_ext_phy_ctrl_2 = 0x00910091,
  80         .emif_ddr_ext_phy_ctrl_3 = 0x00950095,
  81         .emif_ddr_ext_phy_ctrl_4 = 0x009b009b,
  82         .emif_ddr_ext_phy_ctrl_5 = 0x009e009e,
  83         .emif_rd_wr_lvl_rmp_win = 0x00000000,
  84         .emif_rd_wr_lvl_rmp_ctl = 0x80000000,
  85         .emif_rd_wr_lvl_ctl     = 0x00000000,
  86         .emif_rd_wr_exec_thresh = 0x00000305
  87 };
  88
  89 /* Ext phy ctrl regs 1-35 */
  90 static const u32 beagle_x15_emif1_ddr3_ext_phy_ctrl_const_regs[] = {
  91         0x10040100,
  92         0x00910091,
  93         0x00950095,
  94         0x009B009B,
  95         0x009E009E,
  96         0x00980098,
  97         0x00340034,
  98         0x00350035,
  99         0x00340034,
 100         0x00310031,
 101         0x00340034,
 102         0x007F007F,
 103         0x007F007F,
 104         0x007F007F,
 105         0x007F007F,
 106         0x007F007F,
 107         0x00480048,
 108         0x004A004A,
 109         0x00520052,
 110         0x00550055,
 111         0x00500050,
 112         0x00000000,
 113         0x00600020,
 114         0x40011080,
 115         0x08102040,
 116         0x0,
 117         0x0,
 118         0x0,
 119         0x0,
 120         0x0,
 121         0x0,
 122         0x0,
 123         0x0,
 124         0x0,
 125         0x0
 126 };
 127
 128 static const struct emif_regs beagle_x15_emif2_ddr3_532mhz_emif_regs = {
 129         .sdram_config_init      = 0x61851b32,
 130         .sdram_config           = 0x61851b32,
 131         .sdram_config2          = 0x08000000,
 132         .ref_ctrl               = 0x000040F1,
 133         .ref_ctrl_final         = 0x00001035,
 134         .sdram_tim1             = 0xcccf36ab,
 135         .sdram_tim2             = 0x308f7fda,
 136         .sdram_tim3             = 0x409f88a8,
 137         .read_idle_ctrl         = 0x00050000,
 138         .zq_config              = 0x5007190b,
 139         .temp_alert_config      = 0x00000000,
 140         .emif_ddr_phy_ctlr_1_init = 0x0024400b,
 141         .emif_ddr_phy_ctlr_1    = 0x0e24400b,
 142         .emif_ddr_ext_phy_ctrl_1 = 0x10040100,
 143         .emif_ddr_ext_phy_ctrl_2 = 0x00910091,
 144         .emif_ddr_ext_phy_ctrl_3 = 0x00950095,
 145         .emif_ddr_ext_phy_ctrl_4 = 0x009b009b,
 146         .emif_ddr_ext_phy_ctrl_5 = 0x009e009e,
 147         .emif_rd_wr_lvl_rmp_win = 0x00000000,
 148         .emif_rd_wr_lvl_rmp_ctl = 0x80000000,
 149         .emif_rd_wr_lvl_ctl     = 0x00000000,
 150         .emif_rd_wr_exec_thresh = 0x00000305
 151 };
 152
 153 static const u32 beagle_x15_emif2_ddr3_ext_phy_ctrl_const_regs[] = {
 154         0x10040100,
 155         0x00910091,
 156         0x00950095,
 157         0x009B009B,
 158         0x009E009E,
 159         0x00980098,
 160         0x00340034,
 161         0x00350035,
 162         0x00340034,
 163         0x00310031,
 164         0x00340034,
 165         0x007F007F,
 166         0x007F007F,
 167         0x007F007F,
 168         0x007F007F,
 169         0x007F007F,
 170         0x00480048,
 171         0x004A004A,
 172         0x00520052,
 173         0x00550055,
 174         0x00500050,
 175         0x00000000,
 176         0x00600020,
 177         0x40011080,
 178         0x08102040,
 179         0x0,
 180         0x0,
 181         0x0,
 182         0x0,
 183         0x0,
 184         0x0,
 185         0x0,
 186         0x0,
 187         0x0,
 188         0x0
 189 };
 190
 191 void emif_get_reg_dump(u32 emif_nr, const struct emif_regs **regs)
 192 {
 193         switch (emif_nr) {
 194         case 1:
 195                 *regs = &beagle_x15_emif1_ddr3_532mhz_emif_regs;
 196                 break;
 197         case 2:
 198                 *regs = &beagle_x15_emif2_ddr3_532mhz_emif_regs;
 199                 break;
 200         }
 201 }
 202
 203 void emif_get_ext_phy_ctrl_const_regs(u32 emif_nr, const u32 **regs, u32 *size)
 204 {
 205         switch (emif_nr) {
 206         case 1:
 207                 *regs = beagle_x15_emif1_ddr3_ext_phy_ctrl_const_regs;
 208                 *size = ARRAY_SIZE(beagle_x15_emif1_ddr3_ext_phy_ctrl_const_regs);
 209                 break;
 210         case 2:
 211                 *regs = beagle_x15_emif2_ddr3_ext_phy_ctrl_const_regs;
 212                 *size = ARRAY_SIZE(beagle_x15_emif2_ddr3_ext_phy_ctrl_const_regs);
 213                 break;
 214         }
 215 }
 216
 217 struct vcores_data beagle_x15_volts = {
 218         .mpu.value              = VDD_MPU_DRA752,
 219         .mpu.efuse.reg          = STD_FUSE_OPP_VMIN_MPU_NOM,
 220         .mpu.efuse.reg_bits     = DRA752_EFUSE_REGBITS,
 221         .mpu.addr               = TPS659038_REG_ADDR_SMPS12,
 222         .mpu.pmic               = &tps659038,
 223
 224         .eve.value              = VDD_EVE_DRA752,
 225         .eve.efuse.reg          = STD_FUSE_OPP_VMIN_DSPEVE_NOM,
 226         .eve.efuse.reg_bits     = DRA752_EFUSE_REGBITS,
 227         .eve.addr               = TPS659038_REG_ADDR_SMPS45,
 228         .eve.pmic               = &tps659038,
 229
 230         .gpu.value              = VDD_GPU_DRA752,
 231         .gpu.efuse.reg          = STD_FUSE_OPP_VMIN_GPU_NOM,
 232         .gpu.efuse.reg_bits     = DRA752_EFUSE_REGBITS,
 233         .gpu.addr               = TPS659038_REG_ADDR_SMPS45,
 234         .gpu.pmic               = &tps659038,
 235
 236         .core.value             = VDD_CORE_DRA752,
 237         .core.efuse.reg         = STD_FUSE_OPP_VMIN_CORE_NOM,
 238         .core.efuse.reg_bits    = DRA752_EFUSE_REGBITS,
 239         .core.addr              = TPS659038_REG_ADDR_SMPS6,
 240         .core.pmic              = &tps659038,
 241
 242         .iva.value              = VDD_IVA_DRA752,
 243         .iva.efuse.reg          = STD_FUSE_OPP_VMIN_IVA_NOM,
 244         .iva.efuse.reg_bits     = DRA752_EFUSE_REGBITS,
 245         .iva.addr               = TPS659038_REG_ADDR_SMPS45,
 246         .iva.pmic               = &tps659038,
 247 };
 248
 249 #ifdef CONFIG_SPL_BUILD
 250 /* No env to setup for SPL */
 251 static inline void setup_board_eeprom_env(void) { }
 252
 253 /* Override function to read eeprom information */
 254 void do_board_detect(void)
 255 {
 256         int rc;
 257
 258         rc = ti_i2c_eeprom_am_get(CONFIG_EEPROM_BUS_ADDRESS,
 259                                   CONFIG_EEPROM_CHIP_ADDRESS);
 260         if (rc)
 261                 printf("ti_i2c_eeprom_init failed %d\n", rc);
 262 }
 263
 264 #else   /* CONFIG_SPL_BUILD */
 265
 266 /* Override function to read eeprom information: actual i2c read done by SPL*/
 267 void do_board_detect(void)
 268 {
 269         char *bname = NULL;
 270         int rc;
 271
 272         rc = ti_i2c_eeprom_am_get(CONFIG_EEPROM_BUS_ADDRESS,
 273                                   CONFIG_EEPROM_CHIP_ADDRESS);
 274         if (rc)
 275                 printf("ti_i2c_eeprom_init failed %d\n", rc);
 276
 277         if (board_is_x15())
 278                 bname = "BeagleBoard X15";
 279         else if (board_is_am572x_evm())
 280                 bname = "AM572x EVM";
 281
 282         if (bname)
 283                 snprintf(sysinfo.board_string, SYSINFO_BOARD_NAME_MAX_LEN,
 284                          "Board: %s REV %s\n", bname, board_ti_get_rev());
 285 }
 286
 287 static void setup_board_eeprom_env(void)
 288 {
 289         char *name = "beagle_x15";
 290         int rc;
 291
 292         rc = ti_i2c_eeprom_am_get(CONFIG_EEPROM_BUS_ADDRESS,
 293                                   CONFIG_EEPROM_CHIP_ADDRESS);
 294         if (rc)
 295                 goto invalid_eeprom;
 296
 297         if (board_is_am572x_evm())
 298                 name = "am57xx_evm";
 299         else
 300                 printf("Unidentified board claims %s in eeprom header\n",
 301                        board_ti_get_name());
 302
 303 invalid_eeprom:
 304         set_board_info_env(name);
 305 }
 306
 307 #endif  /* CONFIG_SPL_BUILD */
 308
 309 void hw_data_init(void)
 310 {
 311         *prcm = &dra7xx_prcm;
 312         *dplls_data = &dra7xx_dplls;
 313         *omap_vcores = &beagle_x15_volts;
 314         *ctrl = &dra7xx_ctrl;
 315 }
 316
 317 int board_init(void)
 318 {
 319         gpmc_init();
 320         gd->bd->bi_boot_params = (CONFIG_SYS_SDRAM_BASE + 0x100);
 321
 322         return 0;
 323 }
 324
 325 int board_late_init(void)
 326 {
 327         init_sata(0);
 328         setup_board_eeprom_env();
 329
 330         /*
 331          * DEV_CTRL.DEV_ON = 1 please - else palmas switches off in 8 seconds
 332          * This is the POWERHOLD-in-Low behavior.
 333          */
 334         palmas_i2c_write_u8(TPS65903X_CHIP_P1, 0xA0, 0x1);
 335         return 0;
 336 }
 337
 338 void set_muxconf_regs(void)
 339 {
 340         do_set_mux32((*ctrl)->control_padconf_core_base,
 341                      early_padconf, ARRAY_SIZE(early_padconf));
 342 }
 343
 344 #ifdef CONFIG_IODELAY_RECALIBRATION
 345 void recalibrate_iodelay(void)
 346 {
 347         __recalibrate_iodelay(core_padconf_array_essential,
 348                               ARRAY_SIZE(core_padconf_array_essential),
 349                               iodelay_cfg_array, ARRAY_SIZE(iodelay_cfg_array));
 350 }
 351 #endif
 352
 353 #if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_GENERIC_MMC)
 354 int board_mmc_init(bd_t *bis)
 355 {
 356         omap_mmc_init(0, 0, 0, -1, -1);
 357         omap_mmc_init(1, 0, 0, -1, -1);
 358         return 0;
 359 }
 360 #endif
 361
 362 #if defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_OS_BOOT)
 363 int spl_start_uboot(void)
 364 {
 365         /* break into full u-boot on 'c' */
 366         if (serial_tstc() && serial_getc() == 'c')
 367                 return 1;
 368
 369 #ifdef CONFIG_SPL_ENV_SUPPORT
 370         env_init();
 371         env_relocate_spec();
 372         if (getenv_yesno("boot_os") != 1)
 373                 return 1;
 374 #endif
 375
 376         return 0;
 377 }
 378 #endif
 379
 380 #ifdef CONFIG_USB_DWC3
 381 static struct dwc3_device usb_otg_ss1 = {
 382         .maximum_speed = USB_SPEED_SUPER,
 383         .base = DRA7_USB_OTG_SS1_BASE,
 384         .tx_fifo_resize = false,
 385         .index = 0,
 386 };
 387
 388 static struct dwc3_omap_device usb_otg_ss1_glue = {
 389         .base = (void *)DRA7_USB_OTG_SS1_GLUE_BASE,
 390         .utmi_mode = DWC3_OMAP_UTMI_MODE_SW,
 391         .index = 0,
 392 };
 393
 394 static struct ti_usb_phy_device usb_phy1_device = {
 395         .pll_ctrl_base = (void *)DRA7_USB3_PHY1_PLL_CTRL,
 396         .usb2_phy_power = (void *)DRA7_USB2_PHY1_POWER,
 397         .usb3_phy_power = (void *)DRA7_USB3_PHY1_POWER,
 398         .index = 0,
 399 };
 400
 401 static struct dwc3_device usb_otg_ss2 = {
 402         .maximum_speed = USB_SPEED_HIGH,
 403         .base = DRA7_USB_OTG_SS2_BASE,
 404         .tx_fifo_resize = false,
 405         .index = 1,
 406 };
 407
 408 static struct dwc3_omap_device usb_otg_ss2_glue = {
 409         .base = (void *)DRA7_USB_OTG_SS2_GLUE_BASE,
 410         .utmi_mode = DWC3_OMAP_UTMI_MODE_SW,
 411         .index = 1,
 412 };
 413
 414 static struct ti_usb_phy_device usb_phy2_device = {
 415         .usb2_phy_power = (void *)DRA7_USB2_PHY2_POWER,
 416         .index = 1,
 417 };
 418
 419 int board_usb_init(int index, enum usb_init_type init)
 420 {
 421         enable_usb_clocks(index);
 422         switch (index) {
 423         case 0:
 424                 if (init == USB_INIT_DEVICE) {
 425                         printf("port %d can't be used as device\n", index);
 426                         disable_usb_clocks(index);
 427                         return -EINVAL;
 428                 } else {
 429                         usb_otg_ss1.dr_mode = USB_DR_MODE_HOST;
 430                         usb_otg_ss1_glue.vbus_id_status = OMAP_DWC3_ID_GROUND;
 431                         setbits_le32((*prcm)->cm_l3init_usb_otg_ss1_clkctrl,
 432                                      OTG_SS_CLKCTRL_MODULEMODE_HW |
 433                                      OPTFCLKEN_REFCLK960M);
 434                 }
 435
 436                 ti_usb_phy_uboot_init(&usb_phy1_device);
 437                 dwc3_omap_uboot_init(&usb_otg_ss1_glue);
 438                 dwc3_uboot_init(&usb_otg_ss1);
 439                 break;
 440         case 1:
 441                 if (init == USB_INIT_DEVICE) {
 442                         usb_otg_ss2.dr_mode = USB_DR_MODE_PERIPHERAL;
 443                         usb_otg_ss2_glue.vbus_id_status = OMAP_DWC3_VBUS_VALID;
 444                 } else {
 445                         printf("port %d can't be used as host\n", index);
 446                         disable_usb_clocks(index);
 447                         return -EINVAL;
 448                 }
 449
 450                 ti_usb_phy_uboot_init(&usb_phy2_device);
 451                 dwc3_omap_uboot_init(&usb_otg_ss2_glue);
 452                 dwc3_uboot_init(&usb_otg_ss2);
 453                 break;
 454         default:
 455                 printf("Invalid Controller Index\n");
 456         }
 457
 458         return 0;
 459 }
 460
 461 int board_usb_cleanup(int index, enum usb_init_type init)
 462 {
 463         switch (index) {
 464         case 0:
 465         case 1:
 466                 ti_usb_phy_uboot_exit(index);
 467                 dwc3_uboot_exit(index);
 468                 dwc3_omap_uboot_exit(index);
 469                 break;
 470         default:
 471                 printf("Invalid Controller Index\n");
 472         }
 473         disable_usb_clocks(index);
 474         return 0;
 475 }
 476
 477 int usb_gadget_handle_interrupts(int index)
 478 {
 479         u32 status;
 480
 481         status = dwc3_omap_uboot_interrupt_status(index);
 482         if (status)
 483                 dwc3_uboot_handle_interrupt(index);
 484
 485         return 0;
 486 }
 487 #endif
 488
 489 #ifdef CONFIG_DRIVER_TI_CPSW
 490
 491 /* Delay value to add to calibrated value */
 492 #define RGMII0_TXCTL_DLY_VAL            ((0x3 << 5) + 0x8)
 493 #define RGMII0_TXD0_DLY_VAL             ((0x3 << 5) + 0x8)
 494 #define RGMII0_TXD1_DLY_VAL             ((0x3 << 5) + 0x2)
 495 #define RGMII0_TXD2_DLY_VAL             ((0x4 << 5) + 0x0)
 496 #define RGMII0_TXD3_DLY_VAL             ((0x4 << 5) + 0x0)
 497 #define VIN2A_D13_DLY_VAL               ((0x3 << 5) + 0x8)
 498 #define VIN2A_D17_DLY_VAL               ((0x3 << 5) + 0x8)
 499 #define VIN2A_D16_DLY_VAL               ((0x3 << 5) + 0x2)
 500 #define VIN2A_D15_DLY_VAL               ((0x4 << 5) + 0x0)
 501 #define VIN2A_D14_DLY_VAL               ((0x4 << 5) + 0x0)
 502
 503 static void cpsw_control(int enabled)
 504 {
 505         /* VTP can be added here */
 506 }
 507
 508 static struct cpsw_slave_data cpsw_slaves[] = {
 509         {
 510                 .slave_reg_ofs  = 0x208,
 511                 .sliver_reg_ofs = 0xd80,
 512                 .phy_addr       = 1,
 513         },
 514         {
 515                 .slave_reg_ofs  = 0x308,
 516                 .sliver_reg_ofs = 0xdc0,
 517                 .phy_addr       = 2,
 518         },
 519 };
 520
 521 static struct cpsw_platform_data cpsw_data = {
 522         .mdio_base              = CPSW_MDIO_BASE,
 523         .cpsw_base              = CPSW_BASE,
 524         .mdio_div               = 0xff,
 525         .channels               = 8,
 526         .cpdma_reg_ofs          = 0x800,
 527         .slaves                 = 1,
 528         .slave_data             = cpsw_slaves,
 529         .ale_reg_ofs            = 0xd00,
 530         .ale_entries            = 1024,
 531         .host_port_reg_ofs      = 0x108,
 532         .hw_stats_reg_ofs       = 0x900,
 533         .bd_ram_ofs             = 0x2000,
 534         .mac_control            = (1 << 5),
 535         .control                = cpsw_control,
 536         .host_port_num          = 0,
 537         .version                = CPSW_CTRL_VERSION_2,
 538 };
 539
 540 static u64 mac_to_u64(u8 mac[6])
 541 {
 542         int i;
 543         u64 addr = 0;
 544
 545         for (i = 0; i < 6; i++) {
 546                 addr <<= 8;
 547                 addr |= mac[i];
 548         }
 549
 550         return addr;
 551 }
 552
 553 static void u64_to_mac(u64 addr, u8 mac[6])
 554 {
 555         mac[5] = addr;
 556         mac[4] = addr >> 8;
 557         mac[3] = addr >> 16;
 558         mac[2] = addr >> 24;
 559         mac[1] = addr >> 32;
 560         mac[0] = addr >> 40;
 561 }
 562
 563 int board_eth_init(bd_t *bis)
 564 {
 565         int ret;
 566         uint8_t mac_addr[6];
 567         uint32_t mac_hi, mac_lo;
 568         uint32_t ctrl_val;
 569         int i;
 570         u64 mac1, mac2;
 571         u8 mac_addr1[6], mac_addr2[6];
 572         int num_macs;
 573
 574         /* try reading mac address from efuse */
 575         mac_lo = readl((*ctrl)->control_core_mac_id_0_lo);
 576         mac_hi = readl((*ctrl)->control_core_mac_id_0_hi);
 577         mac_addr[0] = (mac_hi & 0xFF0000) >> 16;
 578         mac_addr[1] = (mac_hi & 0xFF00) >> 8;
 579         mac_addr[2] = mac_hi & 0xFF;
 580         mac_addr[3] = (mac_lo & 0xFF0000) >> 16;
 581         mac_addr[4] = (mac_lo & 0xFF00) >> 8;
 582         mac_addr[5] = mac_lo & 0xFF;
 583
 584         if (!getenv("ethaddr")) {
 585                 printf("<ethaddr> not set. Validating first E-fuse MAC\n");
 586
 587                 if (is_valid_ethaddr(mac_addr))
 588                         eth_setenv_enetaddr("ethaddr", mac_addr);
 589         }
 590
 591         mac_lo = readl((*ctrl)->control_core_mac_id_1_lo);
 592         mac_hi = readl((*ctrl)->control_core_mac_id_1_hi);
 593         mac_addr[0] = (mac_hi & 0xFF0000) >> 16;
 594         mac_addr[1] = (mac_hi & 0xFF00) >> 8;
 595         mac_addr[2] = mac_hi & 0xFF;
 596         mac_addr[3] = (mac_lo & 0xFF0000) >> 16;
 597         mac_addr[4] = (mac_lo & 0xFF00) >> 8;
 598         mac_addr[5] = mac_lo & 0xFF;
 599
 600         if (!getenv("eth1addr")) {
 601                 if (is_valid_ethaddr(mac_addr))
 602                         eth_setenv_enetaddr("eth1addr", mac_addr);
 603         }
 604
 605         ctrl_val = readl((*ctrl)->control_core_control_io1) & (~0x33);
 606         ctrl_val |= 0x22;
 607         writel(ctrl_val, (*ctrl)->control_core_control_io1);
 608
 609         ret = cpsw_register(&cpsw_data);
 610         if (ret < 0)
 611                 printf("Error %d registering CPSW switch\n", ret);
 612
 613         /*
 614          * Export any Ethernet MAC addresses from EEPROM.
 615          * On AM57xx the 2 MAC addresses define the address range
 616          */
 617         board_ti_get_eth_mac_addr(0, mac_addr1);
 618         board_ti_get_eth_mac_addr(1, mac_addr2);
 619
 620         if (is_valid_ethaddr(mac_addr1) && is_valid_ethaddr(mac_addr2)) {
 621                 mac1 = mac_to_u64(mac_addr1);
 622                 mac2 = mac_to_u64(mac_addr2);
 623
 624                 /* must contain an address range */
 625                 num_macs = mac2 - mac1 + 1;
 626                 /* <= 50 to protect against user programming error */
 627                 if (num_macs > 0 && num_macs <= 50) {
 628                         for (i = 0; i < num_macs; i++) {
 629                                 u64_to_mac(mac1 + i, mac_addr);
 630                                 if (is_valid_ethaddr(mac_addr)) {
 631                                         eth_setenv_enetaddr_by_index("eth",
 632                                                                      i + 2,
 633                                                                      mac_addr);
 634                                 }
 635                         }
 636                 }
 637         }
 638
 639         return ret;
 640 }
 641 #endif
 642
 643 #ifdef CONFIG_BOARD_EARLY_INIT_F
 644 /* VTT regulator enable */
 645 static inline void vtt_regulator_enable(void)
 646 {
 647         if (omap_hw_init_context() == OMAP_INIT_CONTEXT_UBOOT_AFTER_SPL)
 648                 return;
 649
 650         gpio_request(GPIO_DDR_VTT_EN, "ddr_vtt_en");
 651         gpio_direction_output(GPIO_DDR_VTT_EN, 1);
 652 }
 653
 654 int board_early_init_f(void)
 655 {
 656         vtt_regulator_enable();
 657         return 0;
 658 }
 659 #endif