1 // SPDX-License-Identifier: GPL-2.0+
5 * Board functions for TI AM335X based boards
7 * Copyright (C) 2011, Texas Instruments, Incorporated - http://www.ti.com/
17 #include <asm/arch/cpu.h>
18 #include <asm/arch/hardware.h>
19 #include <asm/arch/omap.h>
20 #include <asm/arch/ddr_defs.h>
21 #include <asm/arch/clock.h>
22 #include <asm/arch/clk_synthesizer.h>
23 #include <asm/arch/gpio.h>
24 #include <asm/arch/mmc_host_def.h>
25 #include <asm/arch/sys_proto.h>
26 #include <asm/arch/mem.h>
30 #include <asm/omap_common.h>
31 #include <asm/omap_sec_common.h>
32 #include <asm/omap_mmc.h>
36 #include <power/tps65217.h>
37 #include <power/tps65910.h>
38 #include <env_internal.h>
40 #include "../common/board_detect.h"
43 DECLARE_GLOBAL_DATA_PTR
;
45 /* GPIO that controls power to DDR on EVM-SK */
46 #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
47 #define GPIO_DDR_VTT_EN GPIO_TO_PIN(0, 7)
48 #define ICE_GPIO_DDR_VTT_EN GPIO_TO_PIN(0, 18)
49 #define GPIO_PR1_MII_CTRL GPIO_TO_PIN(3, 4)
50 #define GPIO_MUX_MII_CTRL GPIO_TO_PIN(3, 10)
51 #define GPIO_FET_SWITCH_CTRL GPIO_TO_PIN(0, 7)
52 #define GPIO_PHY_RESET GPIO_TO_PIN(2, 5)
53 #define GPIO_ETH0_MODE GPIO_TO_PIN(0, 11)
54 #define GPIO_ETH1_MODE GPIO_TO_PIN(1, 26)
56 static struct ctrl_dev
*cdev
= (struct ctrl_dev
*)CTRL_DEVICE_BASE
;
58 #define GPIO0_RISINGDETECT (AM33XX_GPIO0_BASE + OMAP_GPIO_RISINGDETECT)
59 #define GPIO1_RISINGDETECT (AM33XX_GPIO1_BASE + OMAP_GPIO_RISINGDETECT)
61 #define GPIO0_IRQSTATUS1 (AM33XX_GPIO0_BASE + OMAP_GPIO_IRQSTATUS1)
62 #define GPIO1_IRQSTATUS1 (AM33XX_GPIO1_BASE + OMAP_GPIO_IRQSTATUS1)
64 #define GPIO0_IRQSTATUSRAW (AM33XX_GPIO0_BASE + 0x024)
65 #define GPIO1_IRQSTATUSRAW (AM33XX_GPIO1_BASE + 0x024)
68 * Read header information from EEPROM into global structure.
70 #ifdef CONFIG_TI_I2C_BOARD_DETECT
71 void do_board_detect(void)
73 enable_i2c0_pin_mux();
75 i2c_init(CONFIG_SYS_OMAP24_I2C_SPEED
, CONFIG_SYS_OMAP24_I2C_SLAVE
);
77 if (ti_i2c_eeprom_am_get(CONFIG_EEPROM_BUS_ADDRESS
,
78 CONFIG_EEPROM_CHIP_ADDRESS
))
79 printf("ti_i2c_eeprom_init failed\n");
83 #ifndef CONFIG_DM_SERIAL
84 struct serial_device
*default_serial_console(void)
87 return &eserial4_device
;
89 return &eserial1_device
;
93 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
94 static const struct ddr_data ddr2_data
= {
95 .datardsratio0
= MT47H128M16RT25E_RD_DQS
,
96 .datafwsratio0
= MT47H128M16RT25E_PHY_FIFO_WE
,
97 .datawrsratio0
= MT47H128M16RT25E_PHY_WR_DATA
,
100 static const struct cmd_control ddr2_cmd_ctrl_data
= {
101 .cmd0csratio
= MT47H128M16RT25E_RATIO
,
103 .cmd1csratio
= MT47H128M16RT25E_RATIO
,
105 .cmd2csratio
= MT47H128M16RT25E_RATIO
,
108 static const struct emif_regs ddr2_emif_reg_data
= {
109 .sdram_config
= MT47H128M16RT25E_EMIF_SDCFG
,
110 .ref_ctrl
= MT47H128M16RT25E_EMIF_SDREF
,
111 .sdram_tim1
= MT47H128M16RT25E_EMIF_TIM1
,
112 .sdram_tim2
= MT47H128M16RT25E_EMIF_TIM2
,
113 .sdram_tim3
= MT47H128M16RT25E_EMIF_TIM3
,
114 .emif_ddr_phy_ctlr_1
= MT47H128M16RT25E_EMIF_READ_LATENCY
,
117 static const struct emif_regs ddr2_evm_emif_reg_data
= {
118 .sdram_config
= MT47H128M16RT25E_EMIF_SDCFG
,
119 .ref_ctrl
= MT47H128M16RT25E_EMIF_SDREF
,
120 .sdram_tim1
= MT47H128M16RT25E_EMIF_TIM1
,
121 .sdram_tim2
= MT47H128M16RT25E_EMIF_TIM2
,
122 .sdram_tim3
= MT47H128M16RT25E_EMIF_TIM3
,
123 .ocp_config
= EMIF_OCP_CONFIG_AM335X_EVM
,
124 .emif_ddr_phy_ctlr_1
= MT47H128M16RT25E_EMIF_READ_LATENCY
,
127 static const struct ddr_data ddr3_data
= {
128 .datardsratio0
= MT41J128MJT125_RD_DQS
,
129 .datawdsratio0
= MT41J128MJT125_WR_DQS
,
130 .datafwsratio0
= MT41J128MJT125_PHY_FIFO_WE
,
131 .datawrsratio0
= MT41J128MJT125_PHY_WR_DATA
,
134 static const struct ddr_data ddr3_beagleblack_data
= {
135 .datardsratio0
= MT41K256M16HA125E_RD_DQS
,
136 .datawdsratio0
= MT41K256M16HA125E_WR_DQS
,
137 .datafwsratio0
= MT41K256M16HA125E_PHY_FIFO_WE
,
138 .datawrsratio0
= MT41K256M16HA125E_PHY_WR_DATA
,
141 static const struct ddr_data ddr3_evm_data
= {
142 .datardsratio0
= MT41J512M8RH125_RD_DQS
,
143 .datawdsratio0
= MT41J512M8RH125_WR_DQS
,
144 .datafwsratio0
= MT41J512M8RH125_PHY_FIFO_WE
,
145 .datawrsratio0
= MT41J512M8RH125_PHY_WR_DATA
,
148 static const struct ddr_data ddr3_icev2_data
= {
149 .datardsratio0
= MT41J128MJT125_RD_DQS_400MHz
,
150 .datawdsratio0
= MT41J128MJT125_WR_DQS_400MHz
,
151 .datafwsratio0
= MT41J128MJT125_PHY_FIFO_WE_400MHz
,
152 .datawrsratio0
= MT41J128MJT125_PHY_WR_DATA_400MHz
,
155 static const struct cmd_control ddr3_cmd_ctrl_data
= {
156 .cmd0csratio
= MT41J128MJT125_RATIO
,
157 .cmd0iclkout
= MT41J128MJT125_INVERT_CLKOUT
,
159 .cmd1csratio
= MT41J128MJT125_RATIO
,
160 .cmd1iclkout
= MT41J128MJT125_INVERT_CLKOUT
,
162 .cmd2csratio
= MT41J128MJT125_RATIO
,
163 .cmd2iclkout
= MT41J128MJT125_INVERT_CLKOUT
,
166 static const struct cmd_control ddr3_beagleblack_cmd_ctrl_data
= {
167 .cmd0csratio
= MT41K256M16HA125E_RATIO
,
168 .cmd0iclkout
= MT41K256M16HA125E_INVERT_CLKOUT
,
170 .cmd1csratio
= MT41K256M16HA125E_RATIO
,
171 .cmd1iclkout
= MT41K256M16HA125E_INVERT_CLKOUT
,
173 .cmd2csratio
= MT41K256M16HA125E_RATIO
,
174 .cmd2iclkout
= MT41K256M16HA125E_INVERT_CLKOUT
,
177 static const struct cmd_control ddr3_evm_cmd_ctrl_data
= {
178 .cmd0csratio
= MT41J512M8RH125_RATIO
,
179 .cmd0iclkout
= MT41J512M8RH125_INVERT_CLKOUT
,
181 .cmd1csratio
= MT41J512M8RH125_RATIO
,
182 .cmd1iclkout
= MT41J512M8RH125_INVERT_CLKOUT
,
184 .cmd2csratio
= MT41J512M8RH125_RATIO
,
185 .cmd2iclkout
= MT41J512M8RH125_INVERT_CLKOUT
,
188 static const struct cmd_control ddr3_icev2_cmd_ctrl_data
= {
189 .cmd0csratio
= MT41J128MJT125_RATIO_400MHz
,
190 .cmd0iclkout
= MT41J128MJT125_INVERT_CLKOUT_400MHz
,
192 .cmd1csratio
= MT41J128MJT125_RATIO_400MHz
,
193 .cmd1iclkout
= MT41J128MJT125_INVERT_CLKOUT_400MHz
,
195 .cmd2csratio
= MT41J128MJT125_RATIO_400MHz
,
196 .cmd2iclkout
= MT41J128MJT125_INVERT_CLKOUT_400MHz
,
199 static struct emif_regs ddr3_emif_reg_data
= {
200 .sdram_config
= MT41J128MJT125_EMIF_SDCFG
,
201 .ref_ctrl
= MT41J128MJT125_EMIF_SDREF
,
202 .sdram_tim1
= MT41J128MJT125_EMIF_TIM1
,
203 .sdram_tim2
= MT41J128MJT125_EMIF_TIM2
,
204 .sdram_tim3
= MT41J128MJT125_EMIF_TIM3
,
205 .zq_config
= MT41J128MJT125_ZQ_CFG
,
206 .emif_ddr_phy_ctlr_1
= MT41J128MJT125_EMIF_READ_LATENCY
|
210 static struct emif_regs ddr3_beagleblack_emif_reg_data
= {
211 .sdram_config
= MT41K256M16HA125E_EMIF_SDCFG
,
212 .ref_ctrl
= MT41K256M16HA125E_EMIF_SDREF
,
213 .sdram_tim1
= MT41K256M16HA125E_EMIF_TIM1
,
214 .sdram_tim2
= MT41K256M16HA125E_EMIF_TIM2
,
215 .sdram_tim3
= MT41K256M16HA125E_EMIF_TIM3
,
216 .ocp_config
= EMIF_OCP_CONFIG_BEAGLEBONE_BLACK
,
217 .zq_config
= MT41K256M16HA125E_ZQ_CFG
,
218 .emif_ddr_phy_ctlr_1
= MT41K256M16HA125E_EMIF_READ_LATENCY
,
221 static struct emif_regs ddr3_evm_emif_reg_data
= {
222 .sdram_config
= MT41J512M8RH125_EMIF_SDCFG
,
223 .ref_ctrl
= MT41J512M8RH125_EMIF_SDREF
,
224 .sdram_tim1
= MT41J512M8RH125_EMIF_TIM1
,
225 .sdram_tim2
= MT41J512M8RH125_EMIF_TIM2
,
226 .sdram_tim3
= MT41J512M8RH125_EMIF_TIM3
,
227 .ocp_config
= EMIF_OCP_CONFIG_AM335X_EVM
,
228 .zq_config
= MT41J512M8RH125_ZQ_CFG
,
229 .emif_ddr_phy_ctlr_1
= MT41J512M8RH125_EMIF_READ_LATENCY
|
233 static struct emif_regs ddr3_icev2_emif_reg_data
= {
234 .sdram_config
= MT41J128MJT125_EMIF_SDCFG_400MHz
,
235 .ref_ctrl
= MT41J128MJT125_EMIF_SDREF_400MHz
,
236 .sdram_tim1
= MT41J128MJT125_EMIF_TIM1_400MHz
,
237 .sdram_tim2
= MT41J128MJT125_EMIF_TIM2_400MHz
,
238 .sdram_tim3
= MT41J128MJT125_EMIF_TIM3_400MHz
,
239 .zq_config
= MT41J128MJT125_ZQ_CFG_400MHz
,
240 .emif_ddr_phy_ctlr_1
= MT41J128MJT125_EMIF_READ_LATENCY_400MHz
|
244 #ifdef CONFIG_SPL_OS_BOOT
245 int spl_start_uboot(void)
247 #ifdef CONFIG_SPL_SERIAL_SUPPORT
248 /* break into full u-boot on 'c' */
249 if (serial_tstc() && serial_getc() == 'c')
253 #ifdef CONFIG_SPL_ENV_SUPPORT
256 if (env_get_yesno("boot_os") != 1)
264 const struct dpll_params
*get_dpll_ddr_params(void)
266 int ind
= get_sys_clk_index();
268 if (board_is_evm_sk())
269 return &dpll_ddr3_303MHz
[ind
];
270 else if (board_is_pb() || board_is_bone_lt() || board_is_icev2())
271 return &dpll_ddr3_400MHz
[ind
];
272 else if (board_is_evm_15_or_later())
273 return &dpll_ddr3_303MHz
[ind
];
275 return &dpll_ddr2_266MHz
[ind
];
278 static u8
bone_not_connected_to_ac_power(void)
280 if (board_is_bone()) {
281 uchar pmic_status_reg
;
282 if (tps65217_reg_read(TPS65217_STATUS
,
285 if (!(pmic_status_reg
& TPS65217_PWR_SRC_AC_BITMASK
)) {
286 puts("No AC power, switching to default OPP\n");
293 const struct dpll_params
*get_dpll_mpu_params(void)
295 int ind
= get_sys_clk_index();
296 int freq
= am335x_get_efuse_mpu_max_freq(cdev
);
298 if (bone_not_connected_to_ac_power())
301 if (board_is_pb() || board_is_bone_lt())
302 freq
= MPUPLL_M_1000
;
306 return &dpll_mpu_opp
[ind
][5];
308 return &dpll_mpu_opp
[ind
][4];
310 return &dpll_mpu_opp
[ind
][3];
312 return &dpll_mpu_opp
[ind
][2];
314 return &dpll_mpu_opp100
;
316 return &dpll_mpu_opp
[ind
][0];
319 return &dpll_mpu_opp
[ind
][0];
322 static void scale_vcores_bone(int freq
)
324 int usb_cur_lim
, mpu_vdd
;
327 * Only perform PMIC configurations if board rev > A1
328 * on Beaglebone White
330 if (board_is_bone() && !strncmp(board_ti_get_rev(), "00A1", 4))
333 #ifndef CONFIG_DM_I2C
334 if (i2c_probe(TPS65217_CHIP_PM
))
337 if (power_tps65217_init(0))
343 * On Beaglebone White we need to ensure we have AC power
344 * before increasing the frequency.
346 if (bone_not_connected_to_ac_power())
350 * Override what we have detected since we know if we have
351 * a Beaglebone Black it supports 1GHz.
353 if (board_is_pb() || board_is_bone_lt())
354 freq
= MPUPLL_M_1000
;
358 mpu_vdd
= TPS65217_DCDC_VOLT_SEL_1325MV
;
359 usb_cur_lim
= TPS65217_USB_INPUT_CUR_LIMIT_1800MA
;
362 mpu_vdd
= TPS65217_DCDC_VOLT_SEL_1275MV
;
363 usb_cur_lim
= TPS65217_USB_INPUT_CUR_LIMIT_1300MA
;
366 mpu_vdd
= TPS65217_DCDC_VOLT_SEL_1200MV
;
367 usb_cur_lim
= TPS65217_USB_INPUT_CUR_LIMIT_1300MA
;
373 mpu_vdd
= TPS65217_DCDC_VOLT_SEL_1100MV
;
374 usb_cur_lim
= TPS65217_USB_INPUT_CUR_LIMIT_1300MA
;
378 if (tps65217_reg_write(TPS65217_PROT_LEVEL_NONE
,
381 TPS65217_USB_INPUT_CUR_LIMIT_MASK
))
382 puts("tps65217_reg_write failure\n");
384 /* Set DCDC3 (CORE) voltage to 1.10V */
385 if (tps65217_voltage_update(TPS65217_DEFDCDC3
,
386 TPS65217_DCDC_VOLT_SEL_1100MV
)) {
387 puts("tps65217_voltage_update failure\n");
391 /* Set DCDC2 (MPU) voltage */
392 if (tps65217_voltage_update(TPS65217_DEFDCDC2
, mpu_vdd
)) {
393 puts("tps65217_voltage_update failure\n");
398 * Set LDO3, LDO4 output voltage to 3.3V for Beaglebone.
399 * Set LDO3 to 1.8V and LDO4 to 3.3V for Beaglebone Black.
401 if (board_is_bone()) {
402 if (tps65217_reg_write(TPS65217_PROT_LEVEL_2
,
404 TPS65217_LDO_VOLTAGE_OUT_3_3
,
406 puts("tps65217_reg_write failure\n");
408 if (tps65217_reg_write(TPS65217_PROT_LEVEL_2
,
410 TPS65217_LDO_VOLTAGE_OUT_1_8
,
412 puts("tps65217_reg_write failure\n");
415 if (tps65217_reg_write(TPS65217_PROT_LEVEL_2
,
417 TPS65217_LDO_VOLTAGE_OUT_3_3
,
419 puts("tps65217_reg_write failure\n");
422 void scale_vcores_generic(int freq
)
424 int sil_rev
, mpu_vdd
;
427 * The GP EVM, IDK and EVM SK use a TPS65910 PMIC. For all
428 * MPU frequencies we support we use a CORE voltage of
429 * 1.10V. For MPU voltage we need to switch based on
430 * the frequency we are running at.
432 #ifndef CONFIG_DM_I2C
433 if (i2c_probe(TPS65910_CTRL_I2C_ADDR
))
436 if (power_tps65910_init(0))
440 * Depending on MPU clock and PG we will need a different
441 * VDD to drive at that speed.
443 sil_rev
= readl(&cdev
->deviceid
) >> 28;
444 mpu_vdd
= am335x_get_tps65910_mpu_vdd(sil_rev
, freq
);
446 /* Tell the TPS65910 to use i2c */
447 tps65910_set_i2c_control();
449 /* First update MPU voltage. */
450 if (tps65910_voltage_update(MPU
, mpu_vdd
))
453 /* Second, update the CORE voltage. */
454 if (tps65910_voltage_update(CORE
, TPS65910_OP_REG_SEL_1_1_0
))
459 void gpi2c_init(void)
461 /* When needed to be invoked prior to BSS initialization */
462 static bool first_time
= true;
465 enable_i2c0_pin_mux();
466 #ifndef CONFIG_DM_I2C
467 i2c_init(CONFIG_SYS_OMAP24_I2C_SPEED
,
468 CONFIG_SYS_OMAP24_I2C_SLAVE
);
474 void scale_vcores(void)
479 freq
= am335x_get_efuse_mpu_max_freq(cdev
);
481 if (board_is_beaglebonex())
482 scale_vcores_bone(freq
);
484 scale_vcores_generic(freq
);
487 void set_uart_mux_conf(void)
489 #if CONFIG_CONS_INDEX == 1
490 enable_uart0_pin_mux();
491 #elif CONFIG_CONS_INDEX == 2
492 enable_uart1_pin_mux();
493 #elif CONFIG_CONS_INDEX == 3
494 enable_uart2_pin_mux();
495 #elif CONFIG_CONS_INDEX == 4
496 enable_uart3_pin_mux();
497 #elif CONFIG_CONS_INDEX == 5
498 enable_uart4_pin_mux();
499 #elif CONFIG_CONS_INDEX == 6
500 enable_uart5_pin_mux();
504 void set_mux_conf_regs(void)
506 enable_board_pin_mux();
509 const struct ctrl_ioregs ioregs_evmsk
= {
510 .cm0ioctl
= MT41J128MJT125_IOCTRL_VALUE
,
511 .cm1ioctl
= MT41J128MJT125_IOCTRL_VALUE
,
512 .cm2ioctl
= MT41J128MJT125_IOCTRL_VALUE
,
513 .dt0ioctl
= MT41J128MJT125_IOCTRL_VALUE
,
514 .dt1ioctl
= MT41J128MJT125_IOCTRL_VALUE
,
517 const struct ctrl_ioregs ioregs_bonelt
= {
518 .cm0ioctl
= MT41K256M16HA125E_IOCTRL_VALUE
,
519 .cm1ioctl
= MT41K256M16HA125E_IOCTRL_VALUE
,
520 .cm2ioctl
= MT41K256M16HA125E_IOCTRL_VALUE
,
521 .dt0ioctl
= MT41K256M16HA125E_IOCTRL_VALUE
,
522 .dt1ioctl
= MT41K256M16HA125E_IOCTRL_VALUE
,
525 const struct ctrl_ioregs ioregs_evm15
= {
526 .cm0ioctl
= MT41J512M8RH125_IOCTRL_VALUE
,
527 .cm1ioctl
= MT41J512M8RH125_IOCTRL_VALUE
,
528 .cm2ioctl
= MT41J512M8RH125_IOCTRL_VALUE
,
529 .dt0ioctl
= MT41J512M8RH125_IOCTRL_VALUE
,
530 .dt1ioctl
= MT41J512M8RH125_IOCTRL_VALUE
,
533 const struct ctrl_ioregs ioregs
= {
534 .cm0ioctl
= MT47H128M16RT25E_IOCTRL_VALUE
,
535 .cm1ioctl
= MT47H128M16RT25E_IOCTRL_VALUE
,
536 .cm2ioctl
= MT47H128M16RT25E_IOCTRL_VALUE
,
537 .dt0ioctl
= MT47H128M16RT25E_IOCTRL_VALUE
,
538 .dt1ioctl
= MT47H128M16RT25E_IOCTRL_VALUE
,
541 void sdram_init(void)
543 if (board_is_evm_sk()) {
545 * EVM SK 1.2A and later use gpio0_7 to enable DDR3.
546 * This is safe enough to do on older revs.
548 gpio_request(GPIO_DDR_VTT_EN
, "ddr_vtt_en");
549 gpio_direction_output(GPIO_DDR_VTT_EN
, 1);
552 if (board_is_icev2()) {
553 gpio_request(ICE_GPIO_DDR_VTT_EN
, "ddr_vtt_en");
554 gpio_direction_output(ICE_GPIO_DDR_VTT_EN
, 1);
557 if (board_is_evm_sk())
558 config_ddr(303, &ioregs_evmsk
, &ddr3_data
,
559 &ddr3_cmd_ctrl_data
, &ddr3_emif_reg_data
, 0);
560 else if (board_is_pb() || board_is_bone_lt())
561 config_ddr(400, &ioregs_bonelt
,
562 &ddr3_beagleblack_data
,
563 &ddr3_beagleblack_cmd_ctrl_data
,
564 &ddr3_beagleblack_emif_reg_data
, 0);
565 else if (board_is_evm_15_or_later())
566 config_ddr(303, &ioregs_evm15
, &ddr3_evm_data
,
567 &ddr3_evm_cmd_ctrl_data
, &ddr3_evm_emif_reg_data
, 0);
568 else if (board_is_icev2())
569 config_ddr(400, &ioregs_evmsk
, &ddr3_icev2_data
,
570 &ddr3_icev2_cmd_ctrl_data
, &ddr3_icev2_emif_reg_data
,
572 else if (board_is_gp_evm())
573 config_ddr(266, &ioregs
, &ddr2_data
,
574 &ddr2_cmd_ctrl_data
, &ddr2_evm_emif_reg_data
, 0);
576 config_ddr(266, &ioregs
, &ddr2_data
,
577 &ddr2_cmd_ctrl_data
, &ddr2_emif_reg_data
, 0);
581 #if defined(CONFIG_CLOCK_SYNTHESIZER) && (!defined(CONFIG_SPL_BUILD) || \
582 (defined(CONFIG_SPL_ETH_SUPPORT) && defined(CONFIG_SPL_BUILD)))
583 static void request_and_set_gpio(int gpio
, char *name
, int val
)
587 ret
= gpio_request(gpio
, name
);
589 printf("%s: Unable to request %s\n", __func__
, name
);
593 ret
= gpio_direction_output(gpio
, 0);
595 printf("%s: Unable to set %s as output\n", __func__
, name
);
599 gpio_set_value(gpio
, val
);
607 #define REQUEST_AND_SET_GPIO(N) request_and_set_gpio(N, #N, 1);
608 #define REQUEST_AND_CLR_GPIO(N) request_and_set_gpio(N, #N, 0);
611 * RMII mode on ICEv2 board needs 50MHz clock. Given the clock
612 * synthesizer With a capacitor of 18pF, and 25MHz input clock cycle
613 * PLL1 gives an output of 100MHz. So, configuring the div2/3 as 2 to
614 * give 50MHz output for Eth0 and 1.
616 static struct clk_synth cdce913_data
= {
625 #if defined(CONFIG_OF_BOARD_SETUP) && defined(CONFIG_OF_CONTROL) && \
626 defined(CONFIG_DM_ETH) && defined(CONFIG_DRIVER_TI_CPSW)
628 #define MAX_CPSW_SLAVES 2
630 /* At the moment, we do not want to stop booting for any failures here */
631 int ft_board_setup(void *fdt
, bd_t
*bd
)
633 const char *slave_path
, *enet_name
;
634 int enetnode
, slavenode
, phynode
;
635 struct udevice
*ethdev
;
641 /* phy address fixup needed only on beagle bone family */
642 if (!board_is_beaglebonex())
645 for (i
= 0; i
< MAX_CPSW_SLAVES
; i
++) {
646 sprintf(alias
, "ethernet%d", i
);
648 slave_path
= fdt_get_alias(fdt
, alias
);
652 slavenode
= fdt_path_offset(fdt
, slave_path
);
656 enetnode
= fdt_parent_offset(fdt
, slavenode
);
657 enet_name
= fdt_get_name(fdt
, enetnode
, NULL
);
659 ethdev
= eth_get_dev_by_name(enet_name
);
663 phy_addr
= cpsw_get_slave_phy_addr(ethdev
, i
);
665 /* check for phy_id as well as phy-handle properties */
666 ret
= fdtdec_get_int_array_count(fdt
, slavenode
, "phy_id",
669 if (phy_id
[1] != phy_addr
) {
670 printf("fixing up phy_id for %s, old: %d, new: %d\n",
671 alias
, phy_id
[1], phy_addr
);
673 phy_id
[0] = cpu_to_fdt32(phy_id
[0]);
674 phy_id
[1] = cpu_to_fdt32(phy_addr
);
675 do_fixup_by_path(fdt
, slave_path
, "phy_id",
676 phy_id
, sizeof(phy_id
), 0);
679 phynode
= fdtdec_lookup_phandle(fdt
, slavenode
,
684 ret
= fdtdec_get_int(fdt
, phynode
, "reg", -ENOENT
);
688 if (ret
!= phy_addr
) {
689 printf("fixing up phy-handle for %s, old: %d, new: %d\n",
690 alias
, ret
, phy_addr
);
692 fdt_setprop_u32(fdt
, phynode
, "reg",
693 cpu_to_fdt32(phy_addr
));
704 * Basic board specific setup. Pinmux has been handled already.
708 #if defined(CONFIG_HW_WATCHDOG)
712 gd
->bd
->bi_boot_params
= CONFIG_SYS_SDRAM_BASE
+ 0x100;
713 #if defined(CONFIG_NOR) || defined(CONFIG_NAND)
717 #if defined(CONFIG_CLOCK_SYNTHESIZER) && (!defined(CONFIG_SPL_BUILD) || \
718 (defined(CONFIG_SPL_ETH_SUPPORT) && defined(CONFIG_SPL_BUILD)))
719 if (board_is_icev2()) {
723 REQUEST_AND_SET_GPIO(GPIO_PR1_MII_CTRL
);
724 /* Make J19 status available on GPIO1_26 */
725 REQUEST_AND_CLR_GPIO(GPIO_MUX_MII_CTRL
);
727 REQUEST_AND_SET_GPIO(GPIO_FET_SWITCH_CTRL
);
729 * Both ports can be set as RMII-CPSW or MII-PRU-ETH using
730 * jumpers near the port. Read the jumper value and set
731 * the pinmux, external mux and PHY clock accordingly.
732 * As jumper line is overridden by PHY RX_DV pin immediately
733 * after bootstrap (power-up/reset), we need to sample
734 * it during PHY reset using GPIO rising edge detection.
736 REQUEST_AND_SET_GPIO(GPIO_PHY_RESET
);
737 /* Enable rising edge IRQ on GPIO0_11 and GPIO 1_26 */
738 reg
= readl(GPIO0_RISINGDETECT
) | BIT(11);
739 writel(reg
, GPIO0_RISINGDETECT
);
740 reg
= readl(GPIO1_RISINGDETECT
) | BIT(26);
741 writel(reg
, GPIO1_RISINGDETECT
);
742 /* Reset PHYs to capture the Jumper setting */
743 gpio_set_value(GPIO_PHY_RESET
, 0);
744 udelay(2); /* PHY datasheet states 1uS min. */
745 gpio_set_value(GPIO_PHY_RESET
, 1);
747 reg
= readl(GPIO0_IRQSTATUSRAW
) & BIT(11);
749 writel(reg
, GPIO0_IRQSTATUS1
); /* clear irq */
751 printf("ETH0, CPSW\n");
754 printf("ETH0, PRU\n");
755 cdce913_data
.pdiv3
= 4; /* 25MHz PHY clk */
758 reg
= readl(GPIO1_IRQSTATUSRAW
) & BIT(26);
760 writel(reg
, GPIO1_IRQSTATUS1
); /* clear irq */
762 printf("ETH1, CPSW\n");
763 gpio_set_value(GPIO_MUX_MII_CTRL
, 1);
766 printf("ETH1, PRU\n");
767 cdce913_data
.pdiv2
= 4; /* 25MHz PHY clk */
770 /* disable rising edge IRQs */
771 reg
= readl(GPIO0_RISINGDETECT
) & ~BIT(11);
772 writel(reg
, GPIO0_RISINGDETECT
);
773 reg
= readl(GPIO1_RISINGDETECT
) & ~BIT(26);
774 writel(reg
, GPIO1_RISINGDETECT
);
776 rv
= setup_clock_synthesizer(&cdce913_data
);
778 printf("Clock synthesizer setup failed %d\n", rv
);
783 gpio_set_value(GPIO_PHY_RESET
, 0);
784 udelay(2); /* PHY datasheet states 1uS min. */
785 gpio_set_value(GPIO_PHY_RESET
, 1);
792 #ifdef CONFIG_BOARD_LATE_INIT
793 int board_late_init(void)
796 #if !defined(CONFIG_SPL_BUILD)
798 uint32_t mac_hi
, mac_lo
;
801 #ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG
804 if (board_is_bone_lt()) {
805 /* BeagleBoard.org BeagleBone Black Wireless: */
806 if (!strncmp(board_ti_get_rev(), "BWA", 3)) {
809 /* SeeedStudio BeagleBone Green Wireless */
810 if (!strncmp(board_ti_get_rev(), "GW1", 3)) {
813 /* BeagleBoard.org BeagleBone Blue */
814 if (!strncmp(board_ti_get_rev(), "BLA", 3)) {
823 set_board_info_env(name
);
826 * Default FIT boot on HS devices. Non FIT images are not allowed
829 if (get_device_type() == HS_DEVICE
)
830 env_set("boot_fit", "1");
833 #if !defined(CONFIG_SPL_BUILD)
834 /* try reading mac address from efuse */
835 mac_lo
= readl(&cdev
->macid0l
);
836 mac_hi
= readl(&cdev
->macid0h
);
837 mac_addr
[0] = mac_hi
& 0xFF;
838 mac_addr
[1] = (mac_hi
& 0xFF00) >> 8;
839 mac_addr
[2] = (mac_hi
& 0xFF0000) >> 16;
840 mac_addr
[3] = (mac_hi
& 0xFF000000) >> 24;
841 mac_addr
[4] = mac_lo
& 0xFF;
842 mac_addr
[5] = (mac_lo
& 0xFF00) >> 8;
844 if (!env_get("ethaddr")) {
845 printf("<ethaddr> not set. Validating first E-fuse MAC\n");
847 if (is_valid_ethaddr(mac_addr
))
848 eth_env_set_enetaddr("ethaddr", mac_addr
);
851 mac_lo
= readl(&cdev
->macid1l
);
852 mac_hi
= readl(&cdev
->macid1h
);
853 mac_addr
[0] = mac_hi
& 0xFF;
854 mac_addr
[1] = (mac_hi
& 0xFF00) >> 8;
855 mac_addr
[2] = (mac_hi
& 0xFF0000) >> 16;
856 mac_addr
[3] = (mac_hi
& 0xFF000000) >> 24;
857 mac_addr
[4] = mac_lo
& 0xFF;
858 mac_addr
[5] = (mac_lo
& 0xFF00) >> 8;
860 if (!env_get("eth1addr")) {
861 if (is_valid_ethaddr(mac_addr
))
862 eth_env_set_enetaddr("eth1addr", mac_addr
);
866 if (!env_get("serial#")) {
867 char *board_serial
= env_get("board_serial");
868 char *ethaddr
= env_get("ethaddr");
870 if (!board_serial
|| !strncmp(board_serial
, "unknown", 7))
871 env_set("serial#", ethaddr
);
873 env_set("serial#", board_serial
);
876 /* Just probe the potentially supported cdce913 device */
877 uclass_get_device(UCLASS_CLK
, 0, &dev
);
884 #if !CONFIG_IS_ENABLED(OF_CONTROL)
885 struct cpsw_slave_data slave_data
[] = {
887 .slave_reg_ofs
= CPSW_SLAVE0_OFFSET
,
888 .sliver_reg_ofs
= CPSW_SLIVER0_OFFSET
,
892 .slave_reg_ofs
= CPSW_SLAVE1_OFFSET
,
893 .sliver_reg_ofs
= CPSW_SLIVER1_OFFSET
,
898 struct cpsw_platform_data am335_eth_data
= {
899 .cpsw_base
= CPSW_BASE
,
900 .version
= CPSW_CTRL_VERSION_2
,
901 .bd_ram_ofs
= CPSW_BD_OFFSET
,
902 .ale_reg_ofs
= CPSW_ALE_OFFSET
,
903 .cpdma_reg_ofs
= CPSW_CPDMA_OFFSET
,
904 .mdio_div
= CPSW_MDIO_DIV
,
905 .host_port_reg_ofs
= CPSW_HOST_PORT_OFFSET
,
908 .slave_data
= slave_data
,
910 .bd_ram_ofs
= 0x2000,
913 .mdio_base
= 0x4a101000,
914 .gmii_sel
= 0x44e10650,
915 .phy_sel_compat
= "ti,am3352-cpsw-phy-sel",
916 .syscon_addr
= 0x44e10630,
917 .macid_sel_compat
= "cpsw,am33xx",
920 struct eth_pdata cpsw_pdata
= {
921 .iobase
= 0x4a100000,
923 .priv_pdata
= &am335_eth_data
,
926 U_BOOT_DEVICE(am335x_eth
) = {
928 .platdata
= &cpsw_pdata
,
932 #ifdef CONFIG_SPL_LOAD_FIT
933 int board_fit_config_name_match(const char *name
)
935 if (board_is_gp_evm() && !strcmp(name
, "am335x-evm"))
937 else if (board_is_bone() && !strcmp(name
, "am335x-bone"))
939 else if (board_is_bone_lt() && !strcmp(name
, "am335x-boneblack"))
941 else if (board_is_pb() && !strcmp(name
, "am335x-pocketbeagle"))
943 else if (board_is_evm_sk() && !strcmp(name
, "am335x-evmsk"))
945 else if (board_is_bbg1() && !strcmp(name
, "am335x-bonegreen"))
947 else if (board_is_icev2() && !strcmp(name
, "am335x-icev2"))
954 #ifdef CONFIG_TI_SECURE_DEVICE
955 void board_fit_image_post_process(void **p_image
, size_t *p_size
)
957 secure_boot_verify_image(p_image
, p_size
);
961 #if !CONFIG_IS_ENABLED(OF_CONTROL)
962 static const struct omap_hsmmc_plat am335x_mmc0_platdata
= {
963 .base_addr
= (struct hsmmc
*)OMAP_HSMMC1_BASE
,
964 .cfg
.host_caps
= MMC_MODE_HS_52MHz
| MMC_MODE_HS
| MMC_MODE_4BIT
,
966 .cfg
.f_max
= 52000000,
967 .cfg
.voltages
= MMC_VDD_32_33
| MMC_VDD_33_34
| MMC_VDD_165_195
,
968 .cfg
.b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
,
971 U_BOOT_DEVICE(am335x_mmc0
) = {
972 .name
= "omap_hsmmc",
973 .platdata
= &am335x_mmc0_platdata
,
976 static const struct omap_hsmmc_plat am335x_mmc1_platdata
= {
977 .base_addr
= (struct hsmmc
*)OMAP_HSMMC2_BASE
,
978 .cfg
.host_caps
= MMC_MODE_HS_52MHz
| MMC_MODE_HS
| MMC_MODE_8BIT
,
980 .cfg
.f_max
= 52000000,
981 .cfg
.voltages
= MMC_VDD_32_33
| MMC_VDD_33_34
| MMC_VDD_165_195
,
982 .cfg
.b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
,
985 U_BOOT_DEVICE(am335x_mmc1
) = {
986 .name
= "omap_hsmmc",
987 .platdata
= &am335x_mmc1_platdata
,