board/ti/am43xx/board.c

   1 /*
   2  * board.c
   3  *
   4  * Board functions for TI AM43XX based boards
   5  *
   6  * Copyright (C) 2013, Texas Instruments, Incorporated - http://www.ti.com/
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <i2c.h>
  13 #include <asm/errno.h>
  14 #include <spl.h>
  15 #include <usb.h>
  16 #include <asm/arch/clock.h>
  17 #include <asm/arch/sys_proto.h>
  18 #include <asm/arch/mux.h>
  19 #include <asm/arch/ddr_defs.h>
  20 #include <asm/arch/gpio.h>
  21 #include <asm/emif.h>
  22 #include "board.h"
  23 #include <power/pmic.h>
  24 #include <power/tps65218.h>
  25 #include <power/tps62362.h>
  26 #include <miiphy.h>
  27 #include <cpsw.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 DECLARE_GLOBAL_DATA_PTR;
  34
  35 static struct ctrl_dev *cdev = (struct ctrl_dev *)CTRL_DEVICE_BASE;
  36
  37 /*
  38  * Read header information from EEPROM into global structure.
  39  */
  40 static int read_eeprom(struct am43xx_board_id *header)
  41 {
  42         /* Check if baseboard eeprom is available */
  43         if (i2c_probe(CONFIG_SYS_I2C_EEPROM_ADDR)) {
  44                 printf("Could not probe the EEPROM at 0x%x\n",
  45                        CONFIG_SYS_I2C_EEPROM_ADDR);
  46                 return -ENODEV;
  47         }
  48
  49         /* read the eeprom using i2c */
  50         if (i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, 2, (uchar *)header,
  51                      sizeof(struct am43xx_board_id))) {
  52                 printf("Could not read the EEPROM\n");
  53                 return -EIO;
  54         }
  55
  56         if (header->magic != 0xEE3355AA) {
  57                 /*
  58                  * read the eeprom using i2c again,
  59                  * but use only a 1 byte address
  60                  */
  61                 if (i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, 1, (uchar *)header,
  62                              sizeof(struct am43xx_board_id))) {
  63                         printf("Could not read the EEPROM at 0x%x\n",
  64                                CONFIG_SYS_I2C_EEPROM_ADDR);
  65                         return -EIO;
  66                 }
  67
  68                 if (header->magic != 0xEE3355AA) {
  69                         printf("Incorrect magic number (0x%x) in EEPROM\n",
  70                                header->magic);
  71                         return -EINVAL;
  72                 }
  73         }
  74
  75         strncpy(am43xx_board_name, (char *)header->name, sizeof(header->name));
  76         am43xx_board_name[sizeof(header->name)] = 0;
  77
  78         strncpy(am43xx_board_rev, (char *)header->version, sizeof(header->version));
  79         am43xx_board_rev[sizeof(header->version)] = 0;
  80
  81         return 0;
  82 }
  83
  84 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
  85
  86 #define NUM_OPPS        6
  87
  88 const struct dpll_params dpll_mpu[NUM_CRYSTAL_FREQ][NUM_OPPS] = {
  89         {       /* 19.2 MHz */
  90                 {125, 3, 2, -1, -1, -1, -1},    /* OPP 50 */
  91                 {-1, -1, -1, -1, -1, -1, -1},   /* OPP RESERVED */
  92                 {125, 3, 1, -1, -1, -1, -1},    /* OPP 100 */
  93                 {150, 3, 1, -1, -1, -1, -1},    /* OPP 120 */
  94                 {125, 2, 1, -1, -1, -1, -1},    /* OPP TB */
  95                 {625, 11, 1, -1, -1, -1, -1}    /* OPP NT */
  96         },
  97         {       /* 24 MHz */
  98                 {300, 23, 1, -1, -1, -1, -1},   /* OPP 50 */
  99                 {-1, -1, -1, -1, -1, -1, -1},   /* OPP RESERVED */
 100                 {600, 23, 1, -1, -1, -1, -1},   /* OPP 100 */
 101                 {720, 23, 1, -1, -1, -1, -1},   /* OPP 120 */
 102                 {800, 23, 1, -1, -1, -1, -1},   /* OPP TB */
 103                 {1000, 23, 1, -1, -1, -1, -1}   /* OPP NT */
 104         },
 105         {       /* 25 MHz */
 106                 {300, 24, 1, -1, -1, -1, -1},   /* OPP 50 */
 107                 {-1, -1, -1, -1, -1, -1, -1},   /* OPP RESERVED */
 108                 {600, 24, 1, -1, -1, -1, -1},   /* OPP 100 */
 109                 {720, 24, 1, -1, -1, -1, -1},   /* OPP 120 */
 110                 {800, 24, 1, -1, -1, -1, -1},   /* OPP TB */
 111                 {1000, 24, 1, -1, -1, -1, -1}   /* OPP NT */
 112         },
 113         {       /* 26 MHz */
 114                 {300, 25, 1, -1, -1, -1, -1},   /* OPP 50 */
 115                 {-1, -1, -1, -1, -1, -1, -1},   /* OPP RESERVED */
 116                 {600, 25, 1, -1, -1, -1, -1},   /* OPP 100 */
 117                 {720, 25, 1, -1, -1, -1, -1},   /* OPP 120 */
 118                 {800, 25, 1, -1, -1, -1, -1},   /* OPP TB */
 119                 {1000, 25, 1, -1, -1, -1, -1}   /* OPP NT */
 120         },
 121 };
 122
 123 const struct dpll_params dpll_core[NUM_CRYSTAL_FREQ] = {
 124                 {625, 11, -1, -1, 10, 8, 4},    /* 19.2 MHz */
 125                 {1000, 23, -1, -1, 10, 8, 4},   /* 24 MHz */
 126                 {1000, 24, -1, -1, 10, 8, 4},   /* 25 MHz */
 127                 {1000, 25, -1, -1, 10, 8, 4}    /* 26 MHz */
 128 };
 129
 130 const struct dpll_params dpll_per[NUM_CRYSTAL_FREQ] = {
 131                 {400, 7, 5, -1, -1, -1, -1},    /* 19.2 MHz */
 132                 {400, 9, 5, -1, -1, -1, -1},    /* 24 MHz */
 133                 {384, 9, 5, -1, -1, -1, -1},    /* 25 MHz */
 134                 {480, 12, 5, -1, -1, -1, -1}    /* 26 MHz */
 135 };
 136
 137 const struct dpll_params epos_evm_dpll_ddr[NUM_CRYSTAL_FREQ] = {
 138                 {665, 47, 1, -1, 4, -1, -1}, /*19.2*/
 139                 {133, 11, 1, -1, 4, -1, -1}, /* 24 MHz */
 140                 {266, 24, 1, -1, 4, -1, -1}, /* 25 MHz */
 141                 {133, 12, 1, -1, 4, -1, -1}  /* 26 MHz */
 142 };
 143
 144 const struct dpll_params gp_evm_dpll_ddr = {
 145                 50, 2, 1, -1, 2, -1, -1};
 146
 147 static const struct dpll_params idk_dpll_ddr = {
 148         400, 23, 1, -1, 2, -1, -1
 149 };
 150
 151 static const u32 ext_phy_ctrl_const_base_lpddr2[] = {
 152         0x00500050,
 153         0x00350035,
 154         0x00350035,
 155         0x00350035,
 156         0x00350035,
 157         0x00350035,
 158         0x00000000,
 159         0x00000000,
 160         0x00000000,
 161         0x00000000,
 162         0x00000000,
 163         0x00000000,
 164         0x00000000,
 165         0x00000000,
 166         0x00000000,
 167         0x00000000,
 168         0x00000000,
 169         0x00000000,
 170         0x40001000,
 171         0x08102040
 172 };
 173
 174 const struct ctrl_ioregs ioregs_lpddr2 = {
 175         .cm0ioctl               = LPDDR2_ADDRCTRL_IOCTRL_VALUE,
 176         .cm1ioctl               = LPDDR2_ADDRCTRL_WD0_IOCTRL_VALUE,
 177         .cm2ioctl               = LPDDR2_ADDRCTRL_WD1_IOCTRL_VALUE,
 178         .dt0ioctl               = LPDDR2_DATA0_IOCTRL_VALUE,
 179         .dt1ioctl               = LPDDR2_DATA0_IOCTRL_VALUE,
 180         .dt2ioctrl              = LPDDR2_DATA0_IOCTRL_VALUE,
 181         .dt3ioctrl              = LPDDR2_DATA0_IOCTRL_VALUE,
 182         .emif_sdram_config_ext  = 0x1,
 183 };
 184
 185 const struct emif_regs emif_regs_lpddr2 = {
 186         .sdram_config                   = 0x808012BA,
 187         .ref_ctrl                       = 0x0000040D,
 188         .sdram_tim1                     = 0xEA86B411,
 189         .sdram_tim2                     = 0x103A094A,
 190         .sdram_tim3                     = 0x0F6BA37F,
 191         .read_idle_ctrl                 = 0x00050000,
 192         .zq_config                      = 0x50074BE4,
 193         .temp_alert_config              = 0x0,
 194         .emif_rd_wr_lvl_rmp_win         = 0x0,
 195         .emif_rd_wr_lvl_rmp_ctl         = 0x0,
 196         .emif_rd_wr_lvl_ctl             = 0x0,
 197         .emif_ddr_phy_ctlr_1            = 0x0E284006,
 198         .emif_rd_wr_exec_thresh         = 0x80000405,
 199         .emif_ddr_ext_phy_ctrl_1        = 0x04010040,
 200         .emif_ddr_ext_phy_ctrl_2        = 0x00500050,
 201         .emif_ddr_ext_phy_ctrl_3        = 0x00500050,
 202         .emif_ddr_ext_phy_ctrl_4        = 0x00500050,
 203         .emif_ddr_ext_phy_ctrl_5        = 0x00500050,
 204         .emif_prio_class_serv_map       = 0x80000001,
 205         .emif_connect_id_serv_1_map     = 0x80000094,
 206         .emif_connect_id_serv_2_map     = 0x00000000,
 207         .emif_cos_config                        = 0x000FFFFF
 208 };
 209
 210 const struct ctrl_ioregs ioregs_ddr3 = {
 211         .cm0ioctl               = DDR3_ADDRCTRL_IOCTRL_VALUE,
 212         .cm1ioctl               = DDR3_ADDRCTRL_WD0_IOCTRL_VALUE,
 213         .cm2ioctl               = DDR3_ADDRCTRL_WD1_IOCTRL_VALUE,
 214         .dt0ioctl               = DDR3_DATA0_IOCTRL_VALUE,
 215         .dt1ioctl               = DDR3_DATA0_IOCTRL_VALUE,
 216         .dt2ioctrl              = DDR3_DATA0_IOCTRL_VALUE,
 217         .dt3ioctrl              = DDR3_DATA0_IOCTRL_VALUE,
 218         .emif_sdram_config_ext  = 0xc163,
 219 };
 220
 221 const struct emif_regs ddr3_emif_regs_400Mhz = {
 222         .sdram_config                   = 0x638413B2,
 223         .ref_ctrl                       = 0x00000C30,
 224         .sdram_tim1                     = 0xEAAAD4DB,
 225         .sdram_tim2                     = 0x266B7FDA,
 226         .sdram_tim3                     = 0x107F8678,
 227         .read_idle_ctrl                 = 0x00050000,
 228         .zq_config                      = 0x50074BE4,
 229         .temp_alert_config              = 0x0,
 230         .emif_ddr_phy_ctlr_1            = 0x0E004008,
 231         .emif_ddr_ext_phy_ctrl_1        = 0x08020080,
 232         .emif_ddr_ext_phy_ctrl_2        = 0x00400040,
 233         .emif_ddr_ext_phy_ctrl_3        = 0x00400040,
 234         .emif_ddr_ext_phy_ctrl_4        = 0x00400040,
 235         .emif_ddr_ext_phy_ctrl_5        = 0x00400040,
 236         .emif_rd_wr_lvl_rmp_win         = 0x0,
 237         .emif_rd_wr_lvl_rmp_ctl         = 0x0,
 238         .emif_rd_wr_lvl_ctl             = 0x0,
 239         .emif_rd_wr_exec_thresh         = 0x80000405,
 240         .emif_prio_class_serv_map       = 0x80000001,
 241         .emif_connect_id_serv_1_map     = 0x80000094,
 242         .emif_connect_id_serv_2_map     = 0x00000000,
 243         .emif_cos_config                = 0x000FFFFF
 244 };
 245
 246 /* EMIF DDR3 Configurations are different for beta AM43X GP EVMs */
 247 const struct emif_regs ddr3_emif_regs_400Mhz_beta = {
 248         .sdram_config                   = 0x638413B2,
 249         .ref_ctrl                       = 0x00000C30,
 250         .sdram_tim1                     = 0xEAAAD4DB,
 251         .sdram_tim2                     = 0x266B7FDA,
 252         .sdram_tim3                     = 0x107F8678,
 253         .read_idle_ctrl                 = 0x00050000,
 254         .zq_config                      = 0x50074BE4,
 255         .temp_alert_config              = 0x0,
 256         .emif_ddr_phy_ctlr_1            = 0x0E004008,
 257         .emif_ddr_ext_phy_ctrl_1        = 0x08020080,
 258         .emif_ddr_ext_phy_ctrl_2        = 0x00000065,
 259         .emif_ddr_ext_phy_ctrl_3        = 0x00000091,
 260         .emif_ddr_ext_phy_ctrl_4        = 0x000000B5,
 261         .emif_ddr_ext_phy_ctrl_5        = 0x000000E5,
 262         .emif_rd_wr_exec_thresh         = 0x80000405,
 263         .emif_prio_class_serv_map       = 0x80000001,
 264         .emif_connect_id_serv_1_map     = 0x80000094,
 265         .emif_connect_id_serv_2_map     = 0x00000000,
 266         .emif_cos_config                = 0x000FFFFF
 267 };
 268
 269 /* EMIF DDR3 Configurations are different for production AM43X GP EVMs */
 270 const struct emif_regs ddr3_emif_regs_400Mhz_production = {
 271         .sdram_config                   = 0x638413B2,
 272         .ref_ctrl                       = 0x00000C30,
 273         .sdram_tim1                     = 0xEAAAD4DB,
 274         .sdram_tim2                     = 0x266B7FDA,
 275         .sdram_tim3                     = 0x107F8678,
 276         .read_idle_ctrl                 = 0x00050000,
 277         .zq_config                      = 0x50074BE4,
 278         .temp_alert_config              = 0x0,
 279         .emif_ddr_phy_ctlr_1            = 0x0E004008,
 280         .emif_ddr_ext_phy_ctrl_1        = 0x08020080,
 281         .emif_ddr_ext_phy_ctrl_2        = 0x00000066,
 282         .emif_ddr_ext_phy_ctrl_3        = 0x00000091,
 283         .emif_ddr_ext_phy_ctrl_4        = 0x000000B9,
 284         .emif_ddr_ext_phy_ctrl_5        = 0x000000E6,
 285         .emif_rd_wr_exec_thresh         = 0x80000405,
 286         .emif_prio_class_serv_map       = 0x80000001,
 287         .emif_connect_id_serv_1_map     = 0x80000094,
 288         .emif_connect_id_serv_2_map     = 0x00000000,
 289         .emif_cos_config                = 0x000FFFFF
 290 };
 291
 292 static const struct emif_regs ddr3_sk_emif_regs_400Mhz = {
 293         .sdram_config                   = 0x638413b2,
 294         .sdram_config2                  = 0x00000000,
 295         .ref_ctrl                       = 0x00000c30,
 296         .sdram_tim1                     = 0xeaaad4db,
 297         .sdram_tim2                     = 0x266b7fda,
 298         .sdram_tim3                     = 0x107f8678,
 299         .read_idle_ctrl                 = 0x00050000,
 300         .zq_config                      = 0x50074be4,
 301         .temp_alert_config              = 0x0,
 302         .emif_ddr_phy_ctlr_1            = 0x0e084008,
 303         .emif_ddr_ext_phy_ctrl_1        = 0x08020080,
 304         .emif_ddr_ext_phy_ctrl_2        = 0x89,
 305         .emif_ddr_ext_phy_ctrl_3        = 0x90,
 306         .emif_ddr_ext_phy_ctrl_4        = 0x8e,
 307         .emif_ddr_ext_phy_ctrl_5        = 0x8d,
 308         .emif_rd_wr_lvl_rmp_win         = 0x0,
 309         .emif_rd_wr_lvl_rmp_ctl         = 0x00000000,
 310         .emif_rd_wr_lvl_ctl             = 0x00000000,
 311         .emif_rd_wr_exec_thresh         = 0x80000000,
 312         .emif_prio_class_serv_map       = 0x80000001,
 313         .emif_connect_id_serv_1_map     = 0x80000094,
 314         .emif_connect_id_serv_2_map     = 0x00000000,
 315         .emif_cos_config                = 0x000FFFFF
 316 };
 317
 318 static const struct emif_regs ddr3_idk_emif_regs_400Mhz = {
 319         .sdram_config                   = 0x61a11b32,
 320         .sdram_config2                  = 0x00000000,
 321         .ref_ctrl                       = 0x00000c30,
 322         .sdram_tim1                     = 0xeaaad4db,
 323         .sdram_tim2                     = 0x266b7fda,
 324         .sdram_tim3                     = 0x107f8678,
 325         .read_idle_ctrl                 = 0x00050000,
 326         .zq_config                      = 0x50074be4,
 327         .temp_alert_config              = 0x00000000,
 328         .emif_ddr_phy_ctlr_1            = 0x00008009,
 329         .emif_ddr_ext_phy_ctrl_1        = 0x08020080,
 330         .emif_ddr_ext_phy_ctrl_2        = 0x00000040,
 331         .emif_ddr_ext_phy_ctrl_3        = 0x0000003e,
 332         .emif_ddr_ext_phy_ctrl_4        = 0x00000051,
 333         .emif_ddr_ext_phy_ctrl_5        = 0x00000051,
 334         .emif_rd_wr_lvl_rmp_win         = 0x00000000,
 335         .emif_rd_wr_lvl_rmp_ctl         = 0x00000000,
 336         .emif_rd_wr_lvl_ctl             = 0x00000000,
 337         .emif_rd_wr_exec_thresh         = 0x00000405,
 338         .emif_prio_class_serv_map       = 0x00000000,
 339         .emif_connect_id_serv_1_map     = 0x00000000,
 340         .emif_connect_id_serv_2_map     = 0x00000000,
 341         .emif_cos_config                = 0x00ffffff
 342 };
 343
 344 void emif_get_ext_phy_ctrl_const_regs(const u32 **regs, u32 *size)
 345 {
 346         if (board_is_eposevm()) {
 347                 *regs = ext_phy_ctrl_const_base_lpddr2;
 348                 *size = ARRAY_SIZE(ext_phy_ctrl_const_base_lpddr2);
 349         }
 350
 351         return;
 352 }
 353
 354 /*
 355  * get_sys_clk_index : returns the index of the sys_clk read from
 356  *                      ctrl status register. This value is either
 357  *                      read from efuse or sysboot pins.
 358  */
 359 static u32 get_sys_clk_index(void)
 360 {
 361         struct ctrl_stat *ctrl = (struct ctrl_stat *)CTRL_BASE;
 362         u32 ind = readl(&ctrl->statusreg), src;
 363
 364         src = (ind & CTRL_CRYSTAL_FREQ_SRC_MASK) >> CTRL_CRYSTAL_FREQ_SRC_SHIFT;
 365         if (src == CTRL_CRYSTAL_FREQ_SRC_EFUSE) /* Value read from EFUSE */
 366                 return ((ind & CTRL_CRYSTAL_FREQ_SELECTION_MASK) >>
 367                         CTRL_CRYSTAL_FREQ_SELECTION_SHIFT);
 368         else /* Value read from SYS BOOT pins */
 369                 return ((ind & CTRL_SYSBOOT_15_14_MASK) >>
 370                         CTRL_SYSBOOT_15_14_SHIFT);
 371 }
 372
 373 const struct dpll_params *get_dpll_ddr_params(void)
 374 {
 375         int ind = get_sys_clk_index();
 376
 377         if (board_is_eposevm())
 378                 return &epos_evm_dpll_ddr[ind];
 379         else if (board_is_gpevm() || board_is_sk())
 380                 return &gp_evm_dpll_ddr;
 381         else if (board_is_idk())
 382                 return &idk_dpll_ddr;
 383
 384         printf(" Board '%s' not supported\n", am43xx_board_name);
 385         return NULL;
 386 }
 387
 388
 389 /*
 390  * get_opp_offset:
 391  * Returns the index for safest OPP of the device to boot.
 392  * max_off:     Index of the MAX OPP in DEV ATTRIBUTE register.
 393  * min_off:     Index of the MIN OPP in DEV ATTRIBUTE register.
 394  * This data is read from dev_attribute register which is e-fused.
 395  * A'1' in bit indicates OPP disabled and not available, a '0' indicates
 396  * OPP available. Lowest OPP starts with min_off. So returning the
 397  * bit with rightmost '0'.
 398  */
 399 static int get_opp_offset(int max_off, int min_off)
 400 {
 401         struct ctrl_stat *ctrl = (struct ctrl_stat *)CTRL_BASE;
 402         int opp, offset, i;
 403
 404         /* Bits 0:11 are defined to be the MPU_MAX_FREQ */
 405         opp = readl(&ctrl->dev_attr) & ~0xFFFFF000;
 406
 407         for (i = max_off; i >= min_off; i--) {
 408                 offset = opp & (1 << i);
 409                 if (!offset)
 410                         return i;
 411         }
 412
 413         return min_off;
 414 }
 415
 416 const struct dpll_params *get_dpll_mpu_params(void)
 417 {
 418         int opp = get_opp_offset(DEV_ATTR_MAX_OFFSET, DEV_ATTR_MIN_OFFSET);
 419         u32 ind = get_sys_clk_index();
 420
 421         return &dpll_mpu[ind][opp];
 422 }
 423
 424 const struct dpll_params *get_dpll_core_params(void)
 425 {
 426         int ind = get_sys_clk_index();
 427
 428         return &dpll_core[ind];
 429 }
 430
 431 const struct dpll_params *get_dpll_per_params(void)
 432 {
 433         int ind = get_sys_clk_index();
 434
 435         return &dpll_per[ind];
 436 }
 437
 438 void scale_vcores_generic(u32 m)
 439 {
 440         int mpu_vdd;
 441
 442         if (i2c_probe(TPS65218_CHIP_PM))
 443                 return;
 444
 445         switch (m) {
 446         case 1000:
 447                 mpu_vdd = TPS65218_DCDC_VOLT_SEL_1330MV;
 448                 break;
 449         case 800:
 450                 mpu_vdd = TPS65218_DCDC_VOLT_SEL_1260MV;
 451                 break;
 452         case 720:
 453                 mpu_vdd = TPS65218_DCDC_VOLT_SEL_1200MV;
 454                 break;
 455         case 600:
 456                 mpu_vdd = TPS65218_DCDC_VOLT_SEL_1100MV;
 457                 break;
 458         case 300:
 459                 mpu_vdd = TPS65218_DCDC_VOLT_SEL_0950MV;
 460                 break;
 461         default:
 462                 puts("Unknown MPU clock, not scaling\n");
 463                 return;
 464         }
 465
 466         /* Set DCDC1 (CORE) voltage to 1.1V */
 467         if (tps65218_voltage_update(TPS65218_DCDC1,
 468                                     TPS65218_DCDC_VOLT_SEL_1100MV)) {
 469                 printf("%s failure\n", __func__);
 470                 return;
 471         }
 472
 473         /* Set DCDC2 (MPU) voltage */
 474         if (tps65218_voltage_update(TPS65218_DCDC2, mpu_vdd)) {
 475                 printf("%s failure\n", __func__);
 476                 return;
 477         }
 478 }
 479
 480 void scale_vcores_idk(u32 m)
 481 {
 482         int mpu_vdd;
 483
 484         if (i2c_probe(TPS62362_I2C_ADDR))
 485                 return;
 486
 487         switch (m) {
 488         case 1000:
 489                 mpu_vdd = TPS62362_DCDC_VOLT_SEL_1330MV;
 490                 break;
 491         case 800:
 492                 mpu_vdd = TPS62362_DCDC_VOLT_SEL_1260MV;
 493                 break;
 494         case 720:
 495                 mpu_vdd = TPS62362_DCDC_VOLT_SEL_1200MV;
 496                 break;
 497         case 600:
 498                 mpu_vdd = TPS62362_DCDC_VOLT_SEL_1100MV;
 499                 break;
 500         case 300:
 501                 mpu_vdd = TPS62362_DCDC_VOLT_SEL_1330MV;
 502                 break;
 503         default:
 504                 puts("Unknown MPU clock, not scaling\n");
 505                 return;
 506         }
 507
 508         /* Set VDD_MPU voltage */
 509         if (tps62362_voltage_update(TPS62362_SET3, mpu_vdd)) {
 510                 printf("%s failure\n", __func__);
 511                 return;
 512         }
 513 }
 514
 515 void scale_vcores(void)
 516 {
 517         const struct dpll_params *mpu_params;
 518         struct am43xx_board_id header;
 519
 520         enable_i2c0_pin_mux();
 521         i2c_init(CONFIG_SYS_OMAP24_I2C_SPEED, CONFIG_SYS_OMAP24_I2C_SLAVE);
 522         if (read_eeprom(&header) < 0)
 523                 puts("Could not get board ID.\n");
 524
 525         /* Get the frequency */
 526         mpu_params = get_dpll_mpu_params();
 527
 528         if (board_is_idk())
 529                 scale_vcores_idk(mpu_params->m);
 530         else
 531                 scale_vcores_generic(mpu_params->m);
 532 }
 533
 534 void set_uart_mux_conf(void)
 535 {
 536         enable_uart0_pin_mux();
 537 }
 538
 539 void set_mux_conf_regs(void)
 540 {
 541         enable_board_pin_mux();
 542 }
 543
 544 static void enable_vtt_regulator(void)
 545 {
 546         u32 temp;
 547
 548         /* enable module */
 549         writel(GPIO_CTRL_ENABLEMODULE, AM33XX_GPIO5_BASE + OMAP_GPIO_CTRL);
 550
 551         /* enable output for GPIO5_7 */
 552         writel(GPIO_SETDATAOUT(7),
 553                AM33XX_GPIO5_BASE + OMAP_GPIO_SETDATAOUT);
 554         temp = readl(AM33XX_GPIO5_BASE + OMAP_GPIO_OE);
 555         temp = temp & ~(GPIO_OE_ENABLE(7));
 556         writel(temp, AM33XX_GPIO5_BASE + OMAP_GPIO_OE);
 557 }
 558
 559 void sdram_init(void)
 560 {
 561         /*
 562          * EPOS EVM has 1GB LPDDR2 connected to EMIF.
 563          * GP EMV has 1GB DDR3 connected to EMIF
 564          * along with VTT regulator.
 565          */
 566         if (board_is_eposevm()) {
 567                 config_ddr(0, &ioregs_lpddr2, NULL, NULL, &emif_regs_lpddr2, 0);
 568         } else if (board_is_evm_14_or_later()) {
 569                 enable_vtt_regulator();
 570                 config_ddr(0, &ioregs_ddr3, NULL, NULL,
 571                            &ddr3_emif_regs_400Mhz_production, 0);
 572         } else if (board_is_evm_12_or_later()) {
 573                 enable_vtt_regulator();
 574                 config_ddr(0, &ioregs_ddr3, NULL, NULL,
 575                            &ddr3_emif_regs_400Mhz_beta, 0);
 576         } else if (board_is_gpevm()) {
 577                 enable_vtt_regulator();
 578                 config_ddr(0, &ioregs_ddr3, NULL, NULL,
 579                            &ddr3_emif_regs_400Mhz, 0);
 580         } else if (board_is_sk()) {
 581                 config_ddr(400, &ioregs_ddr3, NULL, NULL,
 582                            &ddr3_sk_emif_regs_400Mhz, 0);
 583         } else if (board_is_idk()) {
 584                 config_ddr(400, &ioregs_ddr3, NULL, NULL,
 585                            &ddr3_idk_emif_regs_400Mhz, 0);
 586         }
 587 }
 588 #endif
 589
 590 /* setup board specific PMIC */
 591 int power_init_board(void)
 592 {
 593         struct pmic *p;
 594
 595         if (board_is_idk()) {
 596                 power_tps62362_init(I2C_PMIC);
 597                 p = pmic_get("TPS62362");
 598                 if (p && !pmic_probe(p))
 599                         puts("PMIC:  TPS62362\n");
 600         } else {
 601                 power_tps65218_init(I2C_PMIC);
 602                 p = pmic_get("TPS65218_PMIC");
 603                 if (p && !pmic_probe(p))
 604                         puts("PMIC:  TPS65218\n");
 605         }
 606
 607         return 0;
 608 }
 609
 610 int board_init(void)
 611 {
 612         struct l3f_cfg_bwlimiter *bwlimiter = (struct l3f_cfg_bwlimiter *)L3F_CFG_BWLIMITER;
 613         u32 mreqprio_0, mreqprio_1, modena_init0_bw_fractional,
 614             modena_init0_bw_integer, modena_init0_watermark_0;
 615
 616         gd->bd->bi_boot_params = CONFIG_SYS_SDRAM_BASE + 0x100;
 617         gpmc_init();
 618
 619         /* Clear all important bits for DSS errata that may need to be tweaked*/
 620         mreqprio_0 = readl(&cdev->mreqprio_0) & MREQPRIO_0_SAB_INIT1_MASK &
 621                            MREQPRIO_0_SAB_INIT0_MASK;
 622
 623         mreqprio_1 = readl(&cdev->mreqprio_1) & MREQPRIO_1_DSS_MASK;
 624
 625         modena_init0_bw_fractional = readl(&bwlimiter->modena_init0_bw_fractional) &
 626                                            BW_LIMITER_BW_FRAC_MASK;
 627
 628         modena_init0_bw_integer = readl(&bwlimiter->modena_init0_bw_integer) &
 629                                         BW_LIMITER_BW_INT_MASK;
 630
 631         modena_init0_watermark_0 = readl(&bwlimiter->modena_init0_watermark_0) &
 632                                          BW_LIMITER_BW_WATERMARK_MASK;
 633
 634         /* Setting MReq Priority of the DSS*/
 635         mreqprio_0 |= 0x77;
 636
 637         /*
 638          * Set L3 Fast Configuration Register
 639          * Limiting bandwith for ARM core to 700 MBPS
 640          */
 641         modena_init0_bw_fractional |= 0x10;
 642         modena_init0_bw_integer |= 0x3;
 643
 644         writel(mreqprio_0, &cdev->mreqprio_0);
 645         writel(mreqprio_1, &cdev->mreqprio_1);
 646
 647         writel(modena_init0_bw_fractional, &bwlimiter->modena_init0_bw_fractional);
 648         writel(modena_init0_bw_integer, &bwlimiter->modena_init0_bw_integer);
 649         writel(modena_init0_watermark_0, &bwlimiter->modena_init0_watermark_0);
 650
 651         return 0;
 652 }
 653
 654 #ifdef CONFIG_BOARD_LATE_INIT
 655 int board_late_init(void)
 656 {
 657 #ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG
 658         char safe_string[HDR_NAME_LEN + 1];
 659         struct am43xx_board_id header;
 660
 661         if (read_eeprom(&header) < 0)
 662                 puts("Could not get board ID.\n");
 663
 664         /* Now set variables based on the header. */
 665         strncpy(safe_string, (char *)header.name, sizeof(header.name));
 666         safe_string[sizeof(header.name)] = 0;
 667         setenv("board_name", safe_string);
 668
 669         strncpy(safe_string, (char *)header.version, sizeof(header.version));
 670         safe_string[sizeof(header.version)] = 0;
 671         setenv("board_rev", safe_string);
 672 #endif
 673         return 0;
 674 }
 675 #endif
 676
 677 #ifdef CONFIG_USB_DWC3
 678 static struct dwc3_device usb_otg_ss1 = {
 679         .maximum_speed = USB_SPEED_HIGH,
 680         .base = USB_OTG_SS1_BASE,
 681         .tx_fifo_resize = false,
 682         .index = 0,
 683 };
 684
 685 static struct dwc3_omap_device usb_otg_ss1_glue = {
 686         .base = (void *)USB_OTG_SS1_GLUE_BASE,
 687         .utmi_mode = DWC3_OMAP_UTMI_MODE_SW,
 688         .index = 0,
 689 };
 690
 691 static struct ti_usb_phy_device usb_phy1_device = {
 692         .usb2_phy_power = (void *)USB2_PHY1_POWER,
 693         .index = 0,
 694 };
 695
 696 static struct dwc3_device usb_otg_ss2 = {
 697         .maximum_speed = USB_SPEED_HIGH,
 698         .base = USB_OTG_SS2_BASE,
 699         .tx_fifo_resize = false,
 700         .index = 1,
 701 };
 702
 703 static struct dwc3_omap_device usb_otg_ss2_glue = {
 704         .base = (void *)USB_OTG_SS2_GLUE_BASE,
 705         .utmi_mode = DWC3_OMAP_UTMI_MODE_SW,
 706         .index = 1,
 707 };
 708
 709 static struct ti_usb_phy_device usb_phy2_device = {
 710         .usb2_phy_power = (void *)USB2_PHY2_POWER,
 711         .index = 1,
 712 };
 713
 714 int board_usb_init(int index, enum usb_init_type init)
 715 {
 716         enable_usb_clocks(index);
 717         switch (index) {
 718         case 0:
 719                 if (init == USB_INIT_DEVICE) {
 720                         usb_otg_ss1.dr_mode = USB_DR_MODE_PERIPHERAL;
 721                         usb_otg_ss1_glue.vbus_id_status = OMAP_DWC3_VBUS_VALID;
 722                 } else {
 723                         usb_otg_ss1.dr_mode = USB_DR_MODE_HOST;
 724                         usb_otg_ss1_glue.vbus_id_status = OMAP_DWC3_ID_GROUND;
 725                 }
 726
 727                 dwc3_omap_uboot_init(&usb_otg_ss1_glue);
 728                 ti_usb_phy_uboot_init(&usb_phy1_device);
 729                 dwc3_uboot_init(&usb_otg_ss1);
 730                 break;
 731         case 1:
 732                 if (init == USB_INIT_DEVICE) {
 733                         usb_otg_ss2.dr_mode = USB_DR_MODE_PERIPHERAL;
 734                         usb_otg_ss2_glue.vbus_id_status = OMAP_DWC3_VBUS_VALID;
 735                 } else {
 736                         usb_otg_ss2.dr_mode = USB_DR_MODE_HOST;
 737                         usb_otg_ss2_glue.vbus_id_status = OMAP_DWC3_ID_GROUND;
 738                 }
 739
 740                 ti_usb_phy_uboot_init(&usb_phy2_device);
 741                 dwc3_omap_uboot_init(&usb_otg_ss2_glue);
 742                 dwc3_uboot_init(&usb_otg_ss2);
 743                 break;
 744         default:
 745                 printf("Invalid Controller Index\n");
 746         }
 747
 748         return 0;
 749 }
 750
 751 int board_usb_cleanup(int index, enum usb_init_type init)
 752 {
 753         switch (index) {
 754         case 0:
 755         case 1:
 756                 ti_usb_phy_uboot_exit(index);
 757                 dwc3_uboot_exit(index);
 758                 dwc3_omap_uboot_exit(index);
 759                 break;
 760         default:
 761                 printf("Invalid Controller Index\n");
 762         }
 763         disable_usb_clocks(index);
 764
 765         return 0;
 766 }
 767
 768 int usb_gadget_handle_interrupts(int index)
 769 {
 770         u32 status;
 771
 772         status = dwc3_omap_uboot_interrupt_status(index);
 773         if (status)
 774                 dwc3_uboot_handle_interrupt(index);
 775
 776         return 0;
 777 }
 778 #endif
 779
 780 #ifdef CONFIG_DRIVER_TI_CPSW
 781
 782 static void cpsw_control(int enabled)
 783 {
 784         /* Additional controls can be added here */
 785         return;
 786 }
 787
 788 static struct cpsw_slave_data cpsw_slaves[] = {
 789         {
 790                 .slave_reg_ofs  = 0x208,
 791                 .sliver_reg_ofs = 0xd80,
 792                 .phy_addr       = 16,
 793         },
 794         {
 795                 .slave_reg_ofs  = 0x308,
 796                 .sliver_reg_ofs = 0xdc0,
 797                 .phy_addr       = 1,
 798         },
 799 };
 800
 801 static struct cpsw_platform_data cpsw_data = {
 802         .mdio_base              = CPSW_MDIO_BASE,
 803         .cpsw_base              = CPSW_BASE,
 804         .mdio_div               = 0xff,
 805         .channels               = 8,
 806         .cpdma_reg_ofs          = 0x800,
 807         .slaves                 = 1,
 808         .slave_data             = cpsw_slaves,
 809         .ale_reg_ofs            = 0xd00,
 810         .ale_entries            = 1024,
 811         .host_port_reg_ofs      = 0x108,
 812         .hw_stats_reg_ofs       = 0x900,
 813         .bd_ram_ofs             = 0x2000,
 814         .mac_control            = (1 << 5),
 815         .control                = cpsw_control,
 816         .host_port_num          = 0,
 817         .version                = CPSW_CTRL_VERSION_2,
 818 };
 819
 820 int board_eth_init(bd_t *bis)
 821 {
 822         int rv;
 823         uint8_t mac_addr[6];
 824         uint32_t mac_hi, mac_lo;
 825
 826         /* try reading mac address from efuse */
 827         mac_lo = readl(&cdev->macid0l);
 828         mac_hi = readl(&cdev->macid0h);
 829         mac_addr[0] = mac_hi & 0xFF;
 830         mac_addr[1] = (mac_hi & 0xFF00) >> 8;
 831         mac_addr[2] = (mac_hi & 0xFF0000) >> 16;
 832         mac_addr[3] = (mac_hi & 0xFF000000) >> 24;
 833         mac_addr[4] = mac_lo & 0xFF;
 834         mac_addr[5] = (mac_lo & 0xFF00) >> 8;
 835
 836         if (!getenv("ethaddr")) {
 837                 puts("<ethaddr> not set. Validating first E-fuse MAC\n");
 838                 if (is_valid_ethaddr(mac_addr))
 839                         eth_setenv_enetaddr("ethaddr", mac_addr);
 840         }
 841
 842         mac_lo = readl(&cdev->macid1l);
 843         mac_hi = readl(&cdev->macid1h);
 844         mac_addr[0] = mac_hi & 0xFF;
 845         mac_addr[1] = (mac_hi & 0xFF00) >> 8;
 846         mac_addr[2] = (mac_hi & 0xFF0000) >> 16;
 847         mac_addr[3] = (mac_hi & 0xFF000000) >> 24;
 848         mac_addr[4] = mac_lo & 0xFF;
 849         mac_addr[5] = (mac_lo & 0xFF00) >> 8;
 850
 851         if (!getenv("eth1addr")) {
 852                 if (is_valid_ethaddr(mac_addr))
 853                         eth_setenv_enetaddr("eth1addr", mac_addr);
 854         }
 855
 856         if (board_is_eposevm()) {
 857                 writel(RMII_MODE_ENABLE | RMII_CHIPCKL_ENABLE, &cdev->miisel);
 858                 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RMII;
 859                 cpsw_slaves[0].phy_addr = 16;
 860         } else if (board_is_sk()) {
 861                 writel(RGMII_MODE_ENABLE, &cdev->miisel);
 862                 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII;
 863                 cpsw_slaves[0].phy_addr = 4;
 864                 cpsw_slaves[1].phy_addr = 5;
 865         } else if (board_is_idk()) {
 866                 writel(RGMII_MODE_ENABLE, &cdev->miisel);
 867                 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII;
 868                 cpsw_slaves[0].phy_addr = 0;
 869         } else {
 870                 writel(RGMII_MODE_ENABLE, &cdev->miisel);
 871                 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII;
 872                 cpsw_slaves[0].phy_addr = 0;
 873         }
 874
 875         rv = cpsw_register(&cpsw_data);
 876         if (rv < 0)
 877                 printf("Error %d registering CPSW switch\n", rv);
 878
 879         return rv;
 880 }
 881 #endif