phys_size_t initdram(int board_type) { phys_size_t dram_size; int use_spd = 0; puts("Initializing...."); #ifdef CONFIG_DDR_SPD /* if hwconfig is not enabled, or "sdram" is not defined, use spd */ if (hwconfig_sub("fsl_ddr", "sdram")) { if (hwconfig_subarg_cmp("fsl_ddr", "sdram", "spd")) use_spd = 1; else if (hwconfig_subarg_cmp("fsl_ddr", "sdram", "fixed")) use_spd = 0; else use_spd = 1; } else use_spd = 1; #endif if (use_spd) { puts("using SPD\n"); dram_size = fsl_ddr_sdram(); } else { puts("using fixed parameters\n"); dram_size = fixed_sdram(); } dram_size = setup_ddr_tlbs(dram_size / 0x100000); dram_size *= 0x100000; puts(" DDR: "); return dram_size; }
int misc_init_r(void) { struct cpld_data *cpld_data = (void *)(CONFIG_SYS_CPLD_BASE); ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); if (hwconfig_subarg_cmp("fsl_p1010mux", "tdm_can", "can")) { clrbits_be32(&gur->pmuxcr, MPC85xx_PMUXCR_CAN1_TDM | MPC85xx_PMUXCR_CAN1_UART | MPC85xx_PMUXCR_CAN2_TDM | MPC85xx_PMUXCR_CAN2_UART); out_8(&cpld_data->tdm_can_sel, MUX_CPLD_CAN_UART); } else if (hwconfig_subarg_cmp("fsl_p1010mux", "tdm_can", "tdm")) { clrbits_be32(&gur->pmuxcr, MPC85xx_PMUXCR_CAN2_UART | MPC85xx_PMUXCR_CAN1_UART); setbits_be32(&gur->pmuxcr, MPC85xx_PMUXCR_CAN2_TDM | MPC85xx_PMUXCR_CAN1_TDM); clrbits_be32(&gur->pmuxcr2, MPC85xx_PMUXCR2_UART_GPIO); setbits_be32(&gur->pmuxcr2, MPC85xx_PMUXCR2_UART_TDM); out_8(&cpld_data->tdm_can_sel, MUX_CPLD_TDM); out_8(&cpld_data->spi_cs0_sel, MUX_CPLD_SPICS0_SLIC); } else { /* defaultly spi_cs_sel to flash */ out_8(&cpld_data->spi_cs0_sel, MUX_CPLD_SPICS0_FLASH); } return 0; }
/* * Initializes on-board ethernet controllers. */ int board_eth_init(bd_t *bis) { #ifdef CONFIG_DRIVER_TI_EMAC davinci_emac_mii_mode_sel(0); #endif /* CONFIG_DRIVER_TI_EMAC */ if (!davinci_emac_initialize()) { printf("Error: Ethernet init failed!\n"); return -1; } if (hwconfig_subarg_cmp("switch", "lan", "on")) /* Switch port lan on */ enbw_cmc_switch(1, 1); else enbw_cmc_switch(1, 0); if (hwconfig_subarg_cmp("switch", "pwl", "on")) /* Switch port pwl on */ enbw_cmc_switch(2, 1); else enbw_cmc_switch(2, 0); return 0; }
/* * Initializes on-board ethernet controllers. */ int board_eth_init(bd_t *bis) { struct spi_slave *spi; const char *s; size_t len = 0; int config = 1; davinci_emac_mii_mode_sel(0); /* send a config file to the switch */ s = hwconfig_subarg("switch", "config", &len); if (len) { unsigned long addr = simple_strtoul(s, NULL, 16); config = enbw_cmc_config_switch(addr); } if (config) { /* * no valid config file -> do we have some args in * hwconfig ? */ if ((hwconfig_subarg("switch", "lan", &len)) || (hwconfig_subarg("switch", "lmn", &len))) { /* If so start switch */ spi = enbw_cmc_init_spi(); if (spi) { if (enbw_cmc_switch_write(spi, 1, 0)) config = 0; udelay(10000); if (enbw_cmc_switch_write(spi, 1, 1)) config = 0; spi_release_bus(spi); spi_free_slave(spi); } } else { config = 0; } } if (!davinci_emac_initialize()) { printf("Error: Ethernet init failed!\n"); return -1; } if (config) { if (hwconfig_subarg_cmp("switch", "lan", "on")) /* Switch port lan on */ enbw_cmc_switch(1, 1); else enbw_cmc_switch(1, 0); if (hwconfig_subarg_cmp("switch", "lmn", "on")) /* Switch port pwl on */ enbw_cmc_switch(2, 1); else enbw_cmc_switch(2, 0); } return 0; }
void fdt_fixup_dr_usb(void *blob, bd_t *bd) { const char *modes[] = { "host", "peripheral", "otg" }; const char *phys[] = { "ulpi", "utmi" }; const char *dr_mode_type = NULL; const char *dr_phy_type = NULL; int usb_mode_off = -1; int usb_phy_off = -1; char str[5]; int i, j; for (i = 1; i <= CONFIG_USB_MAX_CONTROLLER_COUNT; i++) { int mode_idx = -1, phy_idx = -1; snprintf(str, 5, "%s%d", "usb", i); if (hwconfig(str)) { for (j = 0; j < ARRAY_SIZE(modes); j++) { if (hwconfig_subarg_cmp(str, "dr_mode", modes[j])) { mode_idx = j; break; } } for (j = 0; j < ARRAY_SIZE(phys); j++) { if (hwconfig_subarg_cmp(str, "phy_type", phys[j])) { phy_idx = j; break; } } if (mode_idx < 0 || phy_idx < 0) { puts("ERROR: wrong usb mode/phy defined!!\n"); return; } dr_mode_type = modes[mode_idx]; dr_phy_type = phys[phy_idx]; if (mode_idx < 0 && phy_idx < 0) { printf("WARNING: invalid phy or mode\n"); return; } } usb_mode_off = fdt_fixup_usb_mode_phy_type(blob, dr_mode_type, NULL, usb_mode_off); if (usb_mode_off < 0) return; usb_phy_off = fdt_fixup_usb_mode_phy_type(blob, NULL, dr_phy_type, usb_phy_off); if (usb_phy_off < 0) return; } }
void fdt_fixup_dr_usb(void *blob, bd_t *bd) { const char *modes[] = { "host", "peripheral", "otg" }; const char *phys[] = { "ulpi", "utmi" }; const char *mode = NULL; const char *phy_type = NULL; char usb1_defined = 0; int usb_mode_off = -1; int usb_phy_off = -1; char str[5]; int i, j; for (i = 1; i <= FSL_MAX_NUM_USB_CTRLS; i++) { int mode_idx = -1, phy_idx = -1; snprintf(str, 5, "%s%d", "usb", i); if (hwconfig(str)) { for (j = 0; j < ARRAY_SIZE(modes); j++) { if (hwconfig_subarg_cmp(str, "dr_mode", modes[j])) { mode_idx = j; break; } } for (j = 0; j < ARRAY_SIZE(phys); j++) { if (hwconfig_subarg_cmp(str, "phy_type", phys[j])) { phy_idx = j; break; } } if (mode_idx >= 0) { usb_mode_off = fdt_fixup_usb_mode_phy_type(blob, modes[mode_idx], NULL, usb_mode_off); if (usb_mode_off < 0) return; } if (phy_idx >= 0) { usb_phy_off = fdt_fixup_usb_mode_phy_type(blob, NULL, phys[phy_idx], usb_phy_off); if (usb_phy_off < 0) return; } if (!strcmp(str, "usb1")) usb1_defined = 1; if (mode_idx < 0 && phy_idx < 0) printf("WARNING: invalid phy or mode\n"); } } if (!usb1_defined) { int usb_off = -1; mode = getenv("usb_dr_mode"); phy_type = getenv("usb_phy_type"); if (!mode && !phy_type) return; fdt_fixup_usb_mode_phy_type(blob, mode, phy_type, usb_off); } }
void ft_board_setup(void *blob, bd_t *bd) { phys_addr_t base; phys_size_t size; struct cpu_type *cpu; cpu = gd->arch.cpu; ft_cpu_setup(blob, bd); base = getenv_bootm_low(); size = getenv_bootm_size(); #if defined(CONFIG_PCI) FT_FSL_PCI_SETUP; #endif fdt_fixup_memory(blob, (u64)base, (u64)size); #if defined(CONFIG_HAS_FSL_DR_USB) fdt_fixup_dr_usb(blob, bd); #endif /* P1014 and it's derivatives don't support CAN and eTSEC3 */ if (cpu->soc_ver == SVR_P1014) { fdt_del_flexcan(blob); fdt_del_node_and_alias(blob, "ethernet2"); } #ifndef CONFIG_SDCARD /* disable sdhc due to sdhc bug */ fdt_del_sdhc(blob); if (hwconfig_subarg_cmp("fsl_p1010mux", "tdm_can", "can")) { fdt_del_tdm(blob); fdt_del_spi_slic(blob); } else if (hwconfig_subarg_cmp("fsl_p1010mux", "tdm_can", "tdm")) { fdt_del_flexcan(blob); fdt_del_spi_flash(blob); fdt_disable_uart1(blob); } else { /* * If we don't set fsl_p1010mux:tdm_can to "can" or "tdm" * explicitly, defaultly spi_cs_sel to spi-flash instead of * to tdm/slic. */ fdt_del_tdm(blob); fdt_del_flexcan(blob); fdt_disable_uart1(blob); } #endif }
int main() { const char *ret; size_t len; setenv("hwconfig", "key1:subkey1=value1,subkey2=value2;key2:value3;;;;" "key3;:,:=;key4", 1); ret = hwconfig_arg("key1", &len); printf("%zd %.*s\n", len, (int)len, ret); assert(len == 29); assert(hwconfig_arg_cmp("key1", "subkey1=value1,subkey2=value2")); assert(!strncmp(ret, "subkey1=value1,subkey2=value2", len)); ret = hwconfig_subarg("key1", "subkey1", &len); printf("%zd %.*s\n", len, (int)len, ret); assert(len == 6); assert(hwconfig_subarg_cmp("key1", "subkey1", "value1")); assert(!strncmp(ret, "value1", len)); ret = hwconfig_subarg("key1", "subkey2", &len); printf("%zd %.*s\n", len, (int)len, ret); assert(len == 6); assert(hwconfig_subarg_cmp("key1", "subkey2", "value2")); assert(!strncmp(ret, "value2", len)); ret = hwconfig_arg("key2", &len); printf("%zd %.*s\n", len, (int)len, ret); assert(len == 6); assert(hwconfig_arg_cmp("key2", "value3")); assert(!strncmp(ret, "value3", len)); assert(hwconfig("key3")); assert(hwconfig_arg("key4", &len) == NULL); assert(hwconfig_arg("bogus", &len) == NULL); unsetenv("hwconfig"); assert(hwconfig(NULL) == 0); assert(hwconfig("") == 0); assert(hwconfig("key3") == 0); return 0; }
static void fdt_board_fixup_qe_usb(void *blob, bd_t *bd) { u8 *bcsr = (u8 *)CONFIG_SYS_BCSR_BASE; if (hwconfig_subarg_cmp("qe_usb", "speed", "low")) clrbits_8(&bcsr[17], BCSR17_nUSBLOWSPD); else setbits_8(&bcsr[17], BCSR17_nUSBLOWSPD); if (hwconfig_subarg_cmp("qe_usb", "mode", "peripheral")) { clrbits_8(&bcsr[17], BCSR17_USBVCC); clrbits_8(&bcsr[17], BCSR17_USBMODE); do_fixup_by_compat(blob, "fsl,mpc8569-qe-usb", "mode", "peripheral", sizeof("peripheral"), 1); } else { setbits_8(&bcsr[17], BCSR17_USBVCC); setbits_8(&bcsr[17], BCSR17_USBMODE); } clrbits_8(&bcsr[17], BCSR17_nUSBEN); }
int board_pci_host_broken(void) { struct immap __iomem *im = (struct immap __iomem *)CONFIG_SYS_IMMR; const u32 rcw_mask = HRCWH_PCI1_ARBITER_ENABLE | HRCWH_PCI_HOST; /* It's always OK in case of external arbiter. */ if (hwconfig_subarg_cmp("pci", "arbiter", "external")) return 0; if ((in_be32(&im->reset.rcwh) & rcw_mask) != rcw_mask) return 1; return 0; }
static void fdt_board_fixup_esdhc(void *blob, bd_t *bd) { const char *status = "disabled"; int off = -1; if (!hwconfig("esdhc")) return; if (esdhc_disables_uart0()) fdt_board_disable_serial(blob, bd, "serial0"); while (1) { const u32 *idx; int len; off = fdt_node_offset_by_compatible(blob, off, "fsl-i2c"); if (off < 0) break; idx = fdt_getprop(blob, off, "cell-index", &len); if (!idx || len != sizeof(*idx)) continue; if (*idx == 1) { fdt_setprop(blob, off, "status", status, strlen(status) + 1); break; } } if (hwconfig_subarg_cmp("esdhc", "mode", "4-bits")) { off = fdt_node_offset_by_compatible(blob, -1, "fsl,esdhc"); if (off < 0) { printf("WARNING: could not find esdhc node\n"); return; } fdt_delprop(blob, off, "sdhci,1-bit-only"); } }
void fdt_fixup_dr_usb(void *blob, bd_t *bd) { const char *modes[] = { "host", "peripheral", "otg" }; const char *phys[] = { "ulpi", "utmi" }; const char *mode = NULL; const char *phy_type = NULL; const char *dr_mode_type = NULL; const char *dr_phy_type = NULL; char usb1_defined = 0; int usb_mode_off = -1; int usb_phy_off = -1; char str[5]; int i, j; for (i = 1; i <= FSL_MAX_NUM_USB_CTRLS; i++) { int mode_idx = -1, phy_idx = -1; snprintf(str, 5, "%s%d", "usb", i); if (hwconfig(str)) { for (j = 0; j < ARRAY_SIZE(modes); j++) { if (hwconfig_subarg_cmp(str, "dr_mode", modes[j])) { mode_idx = j; break; } } for (j = 0; j < ARRAY_SIZE(phys); j++) { if (hwconfig_subarg_cmp(str, "phy_type", phys[j])) { phy_idx = j; break; } } dr_mode_type = modes[mode_idx]; dr_phy_type = phys[phy_idx]; /* use usb_dr_mode and usb_phy_type if usb1_defined = 0; these variables are to be deprecated */ if (!strcmp(str, "usb1")) usb1_defined = 1; if (mode_idx < 0 && phy_idx < 0) { printf("WARNING: invalid phy or mode\n"); return; } } usb_mode_off = fdt_fixup_usb_mode_phy_type(blob, dr_mode_type, NULL, usb_mode_off); if (usb_mode_off < 0) return; usb_phy_off = fdt_fixup_usb_mode_phy_type(blob, NULL, dr_phy_type, usb_phy_off); if (usb_phy_off < 0) return; } if (!usb1_defined) { int usb_off = -1; mode = getenv("usb_dr_mode"); phy_type = getenv("usb_phy_type"); if (mode || phy_type) { printf("WARNING: usb_dr_mode and usb_phy_type " "are to be deprecated soon. Use " "hwconfig to set these values instead!!\n"); fdt_fixup_usb_mode_phy_type(blob, mode, phy_type, usb_off); } } }
static int esdhc_disables_uart0(void) { return prototype_board() || hwconfig_subarg_cmp("esdhc", "mode", "4-bits"); }
static int prototype_board(void) { if (hwconfig_subarg("board", "rev", NULL)) return hwconfig_subarg_cmp("board", "rev", "prototype"); return 1; }
/* setup GPIO pinmux and default configuration per baseboard and env */ void setup_board_gpio(int board, struct ventana_board_info *info) { const char *s; char arg[10]; size_t len; int i; int quiet = simple_strtol(getenv("quiet"), NULL, 10); if (board >= GW_UNKNOWN) return; /* RS232_EN# */ if (gpio_cfg[board].rs232_en) { gpio_direction_output(gpio_cfg[board].rs232_en, (hwconfig("rs232")) ? 0 : 1); } /* MSATA Enable */ if (gpio_cfg[board].msata_en && is_cpu_type(MXC_CPU_MX6Q)) { gpio_direction_output(GP_MSATA_SEL, (hwconfig("msata")) ? 1 : 0); } /* USBOTG Select (PCISKT or FrontPanel) */ if (gpio_cfg[board].usb_sel) { gpio_direction_output(gpio_cfg[board].usb_sel, (hwconfig("usb_pcisel")) ? 1 : 0); } /* * Configure DIO pinmux/padctl registers * see IMX6DQRM/IMX6SDLRM IOMUXC_SW_PAD_CTL_PAD_* register definitions */ for (i = 0; i < gpio_cfg[board].dio_num; i++) { struct dio_cfg *cfg = &gpio_cfg[board].dio_cfg[i]; iomux_v3_cfg_t ctrl = DIO_PAD_CFG; unsigned cputype = is_cpu_type(MXC_CPU_MX6Q) ? 0 : 1; if (!cfg->gpio_padmux[0] && !cfg->gpio_padmux[1]) continue; sprintf(arg, "dio%d", i); if (!hwconfig(arg)) continue; s = hwconfig_subarg(arg, "padctrl", &len); if (s) { ctrl = MUX_PAD_CTRL(simple_strtoul(s, NULL, 16) & 0x1ffff) | MUX_MODE_SION; } if (hwconfig_subarg_cmp(arg, "mode", "gpio")) { if (!quiet) { printf("DIO%d: GPIO%d_IO%02d (gpio-%d)\n", i, (cfg->gpio_param/32)+1, cfg->gpio_param%32, cfg->gpio_param); } imx_iomux_v3_setup_pad(cfg->gpio_padmux[cputype] | ctrl); gpio_requestf(cfg->gpio_param, "dio%d", i); gpio_direction_input(cfg->gpio_param); } else if (hwconfig_subarg_cmp(arg, "mode", "pwm") && cfg->pwm_padmux) { if (!cfg->pwm_param) { printf("DIO%d: Error: pwm config invalid\n", i); continue; } if (!quiet) printf("DIO%d: pwm%d\n", i, cfg->pwm_param); imx_iomux_v3_setup_pad(cfg->pwm_padmux[cputype] | MUX_PAD_CTRL(ctrl)); } } if (!quiet) { if (gpio_cfg[board].msata_en && is_cpu_type(MXC_CPU_MX6Q)) { printf("MSATA: %s\n", (hwconfig("msata") ? "enabled" : "disabled")); } if (gpio_cfg[board].rs232_en) { printf("RS232: %s\n", (hwconfig("rs232")) ? "enabled" : "disabled"); } } }