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 <asm/arch/clock.h> 16 #include <asm/arch/sys_proto.h> 17 #include <asm/arch/mux.h> 18 #include <asm/arch/ddr_defs.h> 19 #include <asm/arch/gpio.h> 20 #include <asm/emif.h> 21 #include "board.h" 22 #include <miiphy.h> 23 #include <cpsw.h> 24 25 DECLARE_GLOBAL_DATA_PTR; 26 27 static struct ctrl_dev *cdev = (struct ctrl_dev *)CTRL_DEVICE_BASE; 28 29 /* 30 * Read header information from EEPROM into global structure. 31 */ 32 static int read_eeprom(struct am43xx_board_id *header) 33 { 34 /* Check if baseboard eeprom is available */ 35 if (i2c_probe(CONFIG_SYS_I2C_EEPROM_ADDR)) { 36 printf("Could not probe the EEPROM at 0x%x\n", 37 CONFIG_SYS_I2C_EEPROM_ADDR); 38 return -ENODEV; 39 } 40 41 /* read the eeprom using i2c */ 42 if (i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, 2, (uchar *)header, 43 sizeof(struct am43xx_board_id))) { 44 printf("Could not read the EEPROM\n"); 45 return -EIO; 46 } 47 48 if (header->magic != 0xEE3355AA) { 49 /* 50 * read the eeprom using i2c again, 51 * but use only a 1 byte address 52 */ 53 if (i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, 1, (uchar *)header, 54 sizeof(struct am43xx_board_id))) { 55 printf("Could not read the EEPROM at 0x%x\n", 56 CONFIG_SYS_I2C_EEPROM_ADDR); 57 return -EIO; 58 } 59 60 if (header->magic != 0xEE3355AA) { 61 printf("Incorrect magic number (0x%x) in EEPROM\n", 62 header->magic); 63 return -EINVAL; 64 } 65 } 66 67 strncpy(am43xx_board_name, (char *)header->name, sizeof(header->name)); 68 am43xx_board_name[sizeof(header->name)] = 0; 69 70 return 0; 71 } 72 73 #ifndef CONFIG_SKIP_LOWLEVEL_INIT 74 75 #define NUM_OPPS 6 76 77 const struct dpll_params dpll_mpu[NUM_CRYSTAL_FREQ][NUM_OPPS] = { 78 { /* 19.2 MHz */ 79 {-1, -1, -1, -1, -1, -1, -1}, /* OPP 50 */ 80 {-1, -1, -1, -1, -1, -1, -1}, /* OPP RESERVED */ 81 {-1, -1, -1, -1, -1, -1, -1}, /* OPP 100 */ 82 {-1, -1, -1, -1, -1, -1, -1}, /* OPP 120 */ 83 {-1, -1, -1, -1, -1, -1, -1}, /* OPP TB */ 84 {-1, -1, -1, -1, -1, -1, -1} /* OPP NT */ 85 }, 86 { /* 24 MHz */ 87 {300, 23, 1, -1, -1, -1, -1}, /* OPP 50 */ 88 {-1, -1, -1, -1, -1, -1, -1}, /* OPP RESERVED */ 89 {600, 23, 1, -1, -1, -1, -1}, /* OPP 100 */ 90 {720, 23, 1, -1, -1, -1, -1}, /* OPP 120 */ 91 {800, 23, 1, -1, -1, -1, -1}, /* OPP TB */ 92 {1000, 23, 1, -1, -1, -1, -1} /* OPP NT */ 93 }, 94 { /* 25 MHz */ 95 {300, 24, 1, -1, -1, -1, -1}, /* OPP 50 */ 96 {-1, -1, -1, -1, -1, -1, -1}, /* OPP RESERVED */ 97 {600, 24, 1, -1, -1, -1, -1}, /* OPP 100 */ 98 {720, 24, 1, -1, -1, -1, -1}, /* OPP 120 */ 99 {800, 24, 1, -1, -1, -1, -1}, /* OPP TB */ 100 {1000, 24, 1, -1, -1, -1, -1} /* OPP NT */ 101 }, 102 { /* 26 MHz */ 103 {300, 25, 1, -1, -1, -1, -1}, /* OPP 50 */ 104 {-1, -1, -1, -1, -1, -1, -1}, /* OPP RESERVED */ 105 {600, 25, 1, -1, -1, -1, -1}, /* OPP 100 */ 106 {720, 25, 1, -1, -1, -1, -1}, /* OPP 120 */ 107 {800, 25, 1, -1, -1, -1, -1}, /* OPP TB */ 108 {1000, 25, 1, -1, -1, -1, -1} /* OPP NT */ 109 }, 110 }; 111 112 const struct dpll_params dpll_core[NUM_CRYSTAL_FREQ] = { 113 {-1, -1, -1, -1, -1, -1, -1}, /* 19.2 MHz */ 114 {1000, 23, -1, -1, 10, 8, 4}, /* 24 MHz */ 115 {1000, 24, -1, -1, 10, 8, 4}, /* 25 MHz */ 116 {1000, 25, -1, -1, 10, 8, 4} /* 26 MHz */ 117 }; 118 119 const struct dpll_params dpll_per[NUM_CRYSTAL_FREQ] = { 120 {-1, -1, -1, -1, -1, -1, -1}, /* 19.2 MHz */ 121 {960, 23, 5, -1, -1, -1, -1}, /* 24 MHz */ 122 {960, 24, 5, -1, -1, -1, -1}, /* 25 MHz */ 123 {960, 25, 5, -1, -1, -1, -1} /* 26 MHz */ 124 }; 125 126 const struct dpll_params epos_evm_dpll_ddr = { 127 266, 24, 1, -1, 1, -1, -1}; 128 129 const struct dpll_params gp_evm_dpll_ddr = { 130 400, 23, 1, -1, 1, -1, -1}; 131 132 const struct ctrl_ioregs ioregs_lpddr2 = { 133 .cm0ioctl = LPDDR2_ADDRCTRL_IOCTRL_VALUE, 134 .cm1ioctl = LPDDR2_ADDRCTRL_WD0_IOCTRL_VALUE, 135 .cm2ioctl = LPDDR2_ADDRCTRL_WD1_IOCTRL_VALUE, 136 .dt0ioctl = LPDDR2_DATA0_IOCTRL_VALUE, 137 .dt1ioctl = LPDDR2_DATA0_IOCTRL_VALUE, 138 .dt2ioctrl = LPDDR2_DATA0_IOCTRL_VALUE, 139 .dt3ioctrl = LPDDR2_DATA0_IOCTRL_VALUE, 140 .emif_sdram_config_ext = 0x1, 141 }; 142 143 const struct emif_regs emif_regs_lpddr2 = { 144 .sdram_config = 0x808012BA, 145 .ref_ctrl = 0x0000040D, 146 .sdram_tim1 = 0xEA86B411, 147 .sdram_tim2 = 0x103A094A, 148 .sdram_tim3 = 0x0F6BA37F, 149 .read_idle_ctrl = 0x00050000, 150 .zq_config = 0x50074BE4, 151 .temp_alert_config = 0x0, 152 .emif_rd_wr_lvl_rmp_win = 0x0, 153 .emif_rd_wr_lvl_rmp_ctl = 0x0, 154 .emif_rd_wr_lvl_ctl = 0x0, 155 .emif_ddr_phy_ctlr_1 = 0x0E084006, 156 .emif_rd_wr_exec_thresh = 0x00000405, 157 .emif_ddr_ext_phy_ctrl_1 = 0x04010040, 158 .emif_ddr_ext_phy_ctrl_2 = 0x00500050, 159 .emif_ddr_ext_phy_ctrl_3 = 0x00500050, 160 .emif_ddr_ext_phy_ctrl_4 = 0x00500050, 161 .emif_ddr_ext_phy_ctrl_5 = 0x00500050 162 }; 163 164 const u32 ext_phy_ctrl_const_base_lpddr2[] = { 165 0x00500050, 166 0x00350035, 167 0x00350035, 168 0x00350035, 169 0x00350035, 170 0x00350035, 171 0x00000000, 172 0x00000000, 173 0x00000000, 174 0x00000000, 175 0x00000000, 176 0x00000000, 177 0x00000000, 178 0x00000000, 179 0x00000000, 180 0x00000000, 181 0x00000000, 182 0x00000000, 183 0x40001000, 184 0x08102040 185 }; 186 187 const struct ctrl_ioregs ioregs_ddr3 = { 188 .cm0ioctl = DDR3_ADDRCTRL_IOCTRL_VALUE, 189 .cm1ioctl = DDR3_ADDRCTRL_WD0_IOCTRL_VALUE, 190 .cm2ioctl = DDR3_ADDRCTRL_WD1_IOCTRL_VALUE, 191 .dt0ioctl = DDR3_DATA0_IOCTRL_VALUE, 192 .dt1ioctl = DDR3_DATA0_IOCTRL_VALUE, 193 .dt2ioctrl = DDR3_DATA0_IOCTRL_VALUE, 194 .dt3ioctrl = DDR3_DATA0_IOCTRL_VALUE, 195 .emif_sdram_config_ext = 0x0143, 196 }; 197 198 const struct emif_regs ddr3_emif_regs_400Mhz = { 199 .sdram_config = 0x638413B2, 200 .ref_ctrl = 0x00000C30, 201 .sdram_tim1 = 0xEAAAD4DB, 202 .sdram_tim2 = 0x266B7FDA, 203 .sdram_tim3 = 0x107F8678, 204 .read_idle_ctrl = 0x00050000, 205 .zq_config = 0x50074BE4, 206 .temp_alert_config = 0x0, 207 .emif_ddr_phy_ctlr_1 = 0x0E004008, 208 .emif_ddr_ext_phy_ctrl_1 = 0x08020080, 209 .emif_ddr_ext_phy_ctrl_2 = 0x00400040, 210 .emif_ddr_ext_phy_ctrl_3 = 0x00400040, 211 .emif_ddr_ext_phy_ctrl_4 = 0x00400040, 212 .emif_ddr_ext_phy_ctrl_5 = 0x00400040, 213 .emif_rd_wr_lvl_rmp_win = 0x0, 214 .emif_rd_wr_lvl_rmp_ctl = 0x0, 215 .emif_rd_wr_lvl_ctl = 0x0, 216 .emif_rd_wr_exec_thresh = 0x00000405 217 }; 218 219 const u32 ext_phy_ctrl_const_base_ddr3[] = { 220 0x00400040, 221 0x00350035, 222 0x00350035, 223 0x00350035, 224 0x00350035, 225 0x00350035, 226 0x00000000, 227 0x00000000, 228 0x00000000, 229 0x00000000, 230 0x00000000, 231 0x00340034, 232 0x00340034, 233 0x00340034, 234 0x00340034, 235 0x00340034, 236 0x0, 237 0x0, 238 0x40000000, 239 0x08102040 240 }; 241 242 void emif_get_ext_phy_ctrl_const_regs(const u32 **regs, u32 *size) 243 { 244 if (board_is_eposevm()) { 245 *regs = ext_phy_ctrl_const_base_lpddr2; 246 *size = ARRAY_SIZE(ext_phy_ctrl_const_base_lpddr2); 247 } else if (board_is_gpevm()) { 248 *regs = ext_phy_ctrl_const_base_ddr3; 249 *size = ARRAY_SIZE(ext_phy_ctrl_const_base_ddr3); 250 } 251 252 return; 253 } 254 255 const struct dpll_params *get_dpll_ddr_params(void) 256 { 257 struct am43xx_board_id header; 258 259 enable_i2c0_pin_mux(); 260 i2c_init(CONFIG_SYS_OMAP24_I2C_SPEED, CONFIG_SYS_OMAP24_I2C_SLAVE); 261 if (read_eeprom(&header) < 0) 262 puts("Could not get board ID.\n"); 263 264 if (board_is_eposevm()) 265 return &epos_evm_dpll_ddr; 266 else if (board_is_gpevm()) 267 return &gp_evm_dpll_ddr; 268 269 puts(" Board not supported\n"); 270 return NULL; 271 } 272 273 /* 274 * get_sys_clk_index : returns the index of the sys_clk read from 275 * ctrl status register. This value is either 276 * read from efuse or sysboot pins. 277 */ 278 static u32 get_sys_clk_index(void) 279 { 280 struct ctrl_stat *ctrl = (struct ctrl_stat *)CTRL_BASE; 281 u32 ind = readl(&ctrl->statusreg), src; 282 283 src = (ind & CTRL_CRYSTAL_FREQ_SRC_MASK) >> CTRL_CRYSTAL_FREQ_SRC_SHIFT; 284 if (src == CTRL_CRYSTAL_FREQ_SRC_EFUSE) /* Value read from EFUSE */ 285 return ((ind & CTRL_CRYSTAL_FREQ_SELECTION_MASK) >> 286 CTRL_CRYSTAL_FREQ_SELECTION_SHIFT); 287 else /* Value read from SYS BOOT pins */ 288 return ((ind & CTRL_SYSBOOT_15_14_MASK) >> 289 CTRL_SYSBOOT_15_14_SHIFT); 290 } 291 292 /* 293 * get_opp_offset: 294 * Returns the index for safest OPP of the device to boot. 295 * max_off: Index of the MAX OPP in DEV ATTRIBUTE register. 296 * min_off: Index of the MIN OPP in DEV ATTRIBUTE register. 297 * This data is read from dev_attribute register which is e-fused. 298 * A'1' in bit indicates OPP disabled and not available, a '0' indicates 299 * OPP available. Lowest OPP starts with min_off. So returning the 300 * bit with rightmost '0'. 301 */ 302 static int get_opp_offset(int max_off, int min_off) 303 { 304 struct ctrl_stat *ctrl = (struct ctrl_stat *)CTRL_BASE; 305 int opp, offset, i; 306 307 /* Bits 0:11 are defined to be the MPU_MAX_FREQ */ 308 opp = readl(&ctrl->dev_attr) & ~0xFFFFF000; 309 310 for (i = max_off; i >= min_off; i--) { 311 offset = opp & (1 << i); 312 if (!offset) 313 return i; 314 } 315 316 return min_off; 317 } 318 319 const struct dpll_params *get_dpll_mpu_params(void) 320 { 321 int opp = get_opp_offset(DEV_ATTR_MAX_OFFSET, DEV_ATTR_MIN_OFFSET); 322 u32 ind = get_sys_clk_index(); 323 324 return &dpll_mpu[ind][opp]; 325 } 326 327 const struct dpll_params *get_dpll_core_params(void) 328 { 329 int ind = get_sys_clk_index(); 330 331 return &dpll_core[ind]; 332 } 333 334 const struct dpll_params *get_dpll_per_params(void) 335 { 336 int ind = get_sys_clk_index(); 337 338 return &dpll_per[ind]; 339 } 340 341 void set_uart_mux_conf(void) 342 { 343 enable_uart0_pin_mux(); 344 } 345 346 void set_mux_conf_regs(void) 347 { 348 enable_board_pin_mux(); 349 } 350 351 static void enable_vtt_regulator(void) 352 { 353 u32 temp; 354 355 /* enable module */ 356 writel(GPIO_CTRL_ENABLEMODULE, AM33XX_GPIO5_BASE + OMAP_GPIO_CTRL); 357 358 /* enable output for GPIO5_7 */ 359 writel(GPIO_SETDATAOUT(7), 360 AM33XX_GPIO5_BASE + OMAP_GPIO_SETDATAOUT); 361 temp = readl(AM33XX_GPIO5_BASE + OMAP_GPIO_OE); 362 temp = temp & ~(GPIO_OE_ENABLE(7)); 363 writel(temp, AM33XX_GPIO5_BASE + OMAP_GPIO_OE); 364 } 365 366 void sdram_init(void) 367 { 368 /* 369 * EPOS EVM has 1GB LPDDR2 connected to EMIF. 370 * GP EMV has 1GB DDR3 connected to EMIF 371 * along with VTT regulator. 372 */ 373 if (board_is_eposevm()) { 374 config_ddr(0, &ioregs_lpddr2, NULL, NULL, &emif_regs_lpddr2, 0); 375 } else if (board_is_gpevm()) { 376 enable_vtt_regulator(); 377 config_ddr(0, &ioregs_ddr3, NULL, NULL, 378 &ddr3_emif_regs_400Mhz, 0); 379 } 380 } 381 #endif 382 383 int board_init(void) 384 { 385 gd->bd->bi_boot_params = CONFIG_SYS_SDRAM_BASE + 0x100; 386 387 return 0; 388 } 389 390 #ifdef CONFIG_BOARD_LATE_INIT 391 int board_late_init(void) 392 { 393 #ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG 394 char safe_string[HDR_NAME_LEN + 1]; 395 struct am43xx_board_id header; 396 397 if (read_eeprom(&header) < 0) 398 puts("Could not get board ID.\n"); 399 400 /* Now set variables based on the header. */ 401 strncpy(safe_string, (char *)header.name, sizeof(header.name)); 402 safe_string[sizeof(header.name)] = 0; 403 setenv("board_name", safe_string); 404 405 strncpy(safe_string, (char *)header.version, sizeof(header.version)); 406 safe_string[sizeof(header.version)] = 0; 407 setenv("board_rev", safe_string); 408 #endif 409 return 0; 410 } 411 #endif 412 413 #ifdef CONFIG_DRIVER_TI_CPSW 414 415 static void cpsw_control(int enabled) 416 { 417 /* Additional controls can be added here */ 418 return; 419 } 420 421 static struct cpsw_slave_data cpsw_slaves[] = { 422 { 423 .slave_reg_ofs = 0x208, 424 .sliver_reg_ofs = 0xd80, 425 .phy_addr = 16, 426 }, 427 { 428 .slave_reg_ofs = 0x308, 429 .sliver_reg_ofs = 0xdc0, 430 .phy_addr = 1, 431 }, 432 }; 433 434 static struct cpsw_platform_data cpsw_data = { 435 .mdio_base = CPSW_MDIO_BASE, 436 .cpsw_base = CPSW_BASE, 437 .mdio_div = 0xff, 438 .channels = 8, 439 .cpdma_reg_ofs = 0x800, 440 .slaves = 1, 441 .slave_data = cpsw_slaves, 442 .ale_reg_ofs = 0xd00, 443 .ale_entries = 1024, 444 .host_port_reg_ofs = 0x108, 445 .hw_stats_reg_ofs = 0x900, 446 .bd_ram_ofs = 0x2000, 447 .mac_control = (1 << 5), 448 .control = cpsw_control, 449 .host_port_num = 0, 450 .version = CPSW_CTRL_VERSION_2, 451 }; 452 453 int board_eth_init(bd_t *bis) 454 { 455 int rv; 456 uint8_t mac_addr[6]; 457 uint32_t mac_hi, mac_lo; 458 459 /* try reading mac address from efuse */ 460 mac_lo = readl(&cdev->macid0l); 461 mac_hi = readl(&cdev->macid0h); 462 mac_addr[0] = mac_hi & 0xFF; 463 mac_addr[1] = (mac_hi & 0xFF00) >> 8; 464 mac_addr[2] = (mac_hi & 0xFF0000) >> 16; 465 mac_addr[3] = (mac_hi & 0xFF000000) >> 24; 466 mac_addr[4] = mac_lo & 0xFF; 467 mac_addr[5] = (mac_lo & 0xFF00) >> 8; 468 469 if (!getenv("ethaddr")) { 470 puts("<ethaddr> not set. Validating first E-fuse MAC\n"); 471 if (is_valid_ether_addr(mac_addr)) 472 eth_setenv_enetaddr("ethaddr", mac_addr); 473 } 474 475 mac_lo = readl(&cdev->macid1l); 476 mac_hi = readl(&cdev->macid1h); 477 mac_addr[0] = mac_hi & 0xFF; 478 mac_addr[1] = (mac_hi & 0xFF00) >> 8; 479 mac_addr[2] = (mac_hi & 0xFF0000) >> 16; 480 mac_addr[3] = (mac_hi & 0xFF000000) >> 24; 481 mac_addr[4] = mac_lo & 0xFF; 482 mac_addr[5] = (mac_lo & 0xFF00) >> 8; 483 484 if (!getenv("eth1addr")) { 485 if (is_valid_ether_addr(mac_addr)) 486 eth_setenv_enetaddr("eth1addr", mac_addr); 487 } 488 489 if (board_is_eposevm()) { 490 writel(RMII_MODE_ENABLE | RMII_CHIPCKL_ENABLE, &cdev->miisel); 491 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RMII; 492 cpsw_slaves[0].phy_addr = 16; 493 } else { 494 writel(RGMII_MODE_ENABLE, &cdev->miisel); 495 cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII; 496 cpsw_slaves[0].phy_addr = 0; 497 } 498 499 rv = cpsw_register(&cpsw_data); 500 if (rv < 0) 501 printf("Error %d registering CPSW switch\n", rv); 502 503 return rv; 504 } 505 #endif 506