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