int board_eth_init(bd_t *bis) { int ret; uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; uint32_t ctrl_val; /* try reading mac address from efuse */ mac_lo = readl((*ctrl)->control_core_mac_id_0_lo); mac_hi = readl((*ctrl)->control_core_mac_id_0_hi); mac_addr[0] = (mac_hi & 0xFF0000) >> 16; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = mac_hi & 0xFF; mac_addr[3] = (mac_lo & 0xFF0000) >> 16; mac_addr[4] = (mac_lo & 0xFF00) >> 8; mac_addr[5] = mac_lo & 0xFF; if (!getenv("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("ethaddr", mac_addr); } mac_lo = readl((*ctrl)->control_core_mac_id_1_lo); mac_hi = readl((*ctrl)->control_core_mac_id_1_hi); mac_addr[0] = (mac_hi & 0xFF0000) >> 16; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = mac_hi & 0xFF; mac_addr[3] = (mac_lo & 0xFF0000) >> 16; mac_addr[4] = (mac_lo & 0xFF00) >> 8; mac_addr[5] = mac_lo & 0xFF; if (!getenv("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("eth1addr", mac_addr); } ctrl_val = readl((*ctrl)->control_core_control_io1) & (~0x33); ctrl_val |= 0x22; writel(ctrl_val, (*ctrl)->control_core_control_io1); if (*omap_si_rev == DRA722_ES1_0) cpsw_data.active_slave = 1; if (board_is_dra72x_revc_or_later()) { cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII_ID; cpsw_slaves[1].phy_if = PHY_INTERFACE_MODE_RGMII_ID; } ret = cpsw_register(&cpsw_data); if (ret < 0) printf("Error %d registering CPSW switch\n", ret); return ret; }
int board_eth_init(bd_t *bis) { int ret; uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; uint32_t ctrl_val; /* try reading mac address from efuse */ mac_lo = readl((*ctrl)->control_core_mac_id_0_lo); mac_hi = readl((*ctrl)->control_core_mac_id_0_hi); mac_addr[0] = (mac_hi & 0xFF0000) >> 16; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = mac_hi & 0xFF; mac_addr[3] = (mac_lo & 0xFF0000) >> 16; mac_addr[4] = (mac_lo & 0xFF00) >> 8; mac_addr[5] = mac_lo & 0xFF; if (!getenv("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("ethaddr", mac_addr); } mac_lo = readl((*ctrl)->control_core_mac_id_1_lo); mac_hi = readl((*ctrl)->control_core_mac_id_1_hi); mac_addr[0] = (mac_hi & 0xFF0000) >> 16; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = mac_hi & 0xFF; mac_addr[3] = (mac_lo & 0xFF0000) >> 16; mac_addr[4] = (mac_lo & 0xFF00) >> 8; mac_addr[5] = mac_lo & 0xFF; if (!getenv("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("eth1addr", mac_addr); } ctrl_val = readl((*ctrl)->control_core_control_io1) & (~0x33); ctrl_val |= 0x22; writel(ctrl_val, (*ctrl)->control_core_control_io1); /* The phy address for the AM57xx IDK are different than x15 */ if (board_is_am572x_idk() || board_is_am571x_idk()) { cpsw_data.slave_data[0].phy_addr = 0; cpsw_data.slave_data[1].phy_addr = 1; } ret = cpsw_register(&cpsw_data); if (ret < 0) printf("Error %d registering CPSW switch\n", ret); return ret; }
/* * Routine: misc_init_r * Description: Configure board specific parts */ int misc_init_r(void) { struct ctrl_id *id_base = (struct ctrl_id *)OMAP34XX_ID_L4_IO_BASE; #ifdef CONFIG_DRIVER_DM9000 uchar enetaddr[6]; u32 die_id_0; #endif twl4030_power_init(); #ifdef CONFIG_TWL4030_LED twl4030_led_init(TWL4030_LED_LEDEN_LEDAON | TWL4030_LED_LEDEN_LEDBON); #endif #ifdef CONFIG_DRIVER_DM9000 /* Configure GPMC registers for DM9000 */ enable_gpmc_cs_config(gpmc_net_config, &gpmc_cfg->cs[6], CONFIG_DM9000_BASE, GPMC_SIZE_16M); /* Use OMAP DIE_ID as MAC address */ if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { printf("ethaddr not set, using Die ID\n"); die_id_0 = readl(&id_base->die_id_0); enetaddr[0] = 0x02; /* locally administered */ enetaddr[1] = readl(&id_base->die_id_1) & 0xff; enetaddr[2] = (die_id_0 & 0xff000000) >> 24; enetaddr[3] = (die_id_0 & 0x00ff0000) >> 16; enetaddr[4] = (die_id_0 & 0x0000ff00) >> 8; enetaddr[5] = (die_id_0 & 0x000000ff); eth_setenv_enetaddr("ethaddr", enetaddr); }
static int set_ethaddr_from_eeprom(void) { const int ETH_ADDR_LEN = 6; unsigned char ethaddr[ETH_ADDR_LEN]; const char * ETHADDR_NAME = "ethaddr"; if (getenv(ETHADDR_NAME)) return 0; if (i2c_set_bus_num(0)) { printf("i2c bus 0 is not valid\n"); return -1; } if (i2c_read(CONFIG_AT24MAC_ADDR, CONFIG_AT24MAC_REG, 1, ethaddr, ETH_ADDR_LEN)) { printf("Failed to read ethernet address from EEPROM\n"); return -1; } if (!is_valid_ethaddr(ethaddr)) { printf("The ethernet address read from EEPROM is not valid!\n"); return -1; } return eth_setenv_enetaddr(ETHADDR_NAME, ethaddr); }
int mac_read_from_eeprom(void) { const u8 *mac; if (read_eeprom()) { printf("I2C EEPROM read failed.\n"); return -1; } if (!eeprom_is_valid) { printf("I2C EEPROM content not valid\n"); return -1; } mac = NULL; switch (eeprom_version) { case 1: case 2: mac = (const u8 *)&eeprom_content.macaddress; break; } if (mac && is_valid_ether_addr(mac)) { eth_setenv_enetaddr("ethaddr", mac); printf("DIAG: %s() MAC value [%s]\n", __func__, getenv("ethaddr")); } return 0; }
static inline int eth_setenv_enetaddr_by_index(const char *base_name, int index, uchar *enetaddr) { char enetvar[32]; sprintf(enetvar, index ? "%s%daddr" : "%saddr", base_name, index); return eth_setenv_enetaddr(enetvar, enetaddr); }
/* Set MAC address which is read from EEPROM */ int set_mac_addr_from_eeprom(int eeprom_addr, int reg) { const int MAC_ADDR_LEN = 6; unsigned char mac_addr[MAC_ADDR_LEN]; const char * ETHADDR_NAME = "ethaddr"; if (getenv(ETHADDR_NAME)) return 0; /* No need to set mac address */ /* Set I2C bus to 0 */ if (i2c_set_bus_num(0)) { printf("i2c bus 0 is not valid\n"); return -1; } if (i2c_read(eeprom_addr, reg, 1, mac_addr, MAC_ADDR_LEN)) { printf("MAC address read failed from i2c addr: 0x%02x, reg: 0x%02x\n", eeprom_addr, reg); return -1; } if (!is_valid_ether_addr(mac_addr)) { printf("MAC address read from EEPROM is not valid!\n"); return -1; } return eth_setenv_enetaddr(ETHADDR_NAME, mac_addr); }
static void board_init_enetaddr(uchar *mac_addr) { #ifdef CONFIG_SYS_NO_FLASH # define USE_MAC_IN_FLASH 0 #else # define USE_MAC_IN_FLASH 1 #endif bool valid_mac = false; if (USE_MAC_IN_FLASH) { /* we cram the MAC in the last flash sector */ uchar *board_mac_addr = (uchar *)0x203F0096; if (is_valid_ether_addr(board_mac_addr)) { memcpy(mac_addr, board_mac_addr, 6); valid_mac = true; } } if (!valid_mac) { puts("Warning: Generating 'random' MAC address\n"); eth_random_addr(mac_addr); } eth_setenv_enetaddr("ethaddr", mac_addr); }
/* * Routine: misc_init_r * Description: Configure board specific parts */ int misc_init_r(void) { struct ctrl_id *id_base = (struct ctrl_id *)OMAP34XX_ID_L4_IO_BASE; #ifdef CONFIG_DRIVER_DM9000 uchar enetaddr[6]; u32 die_id_0; #endif twl4030_power_init(); #ifdef CONFIG_TWL4030_LED twl4030_led_init(); #endif #ifdef CONFIG_DRIVER_DM9000 /* Configure GPMC registers for DM9000 */ writel(NET_GPMC_CONFIG1, &gpmc_cfg->cs[6].config1); writel(NET_GPMC_CONFIG2, &gpmc_cfg->cs[6].config2); writel(NET_GPMC_CONFIG3, &gpmc_cfg->cs[6].config3); writel(NET_GPMC_CONFIG4, &gpmc_cfg->cs[6].config4); writel(NET_GPMC_CONFIG5, &gpmc_cfg->cs[6].config5); writel(NET_GPMC_CONFIG6, &gpmc_cfg->cs[6].config6); writel(NET_GPMC_CONFIG7, &gpmc_cfg->cs[6].config7); /* Use OMAP DIE_ID as MAC address */ if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { printf("ethaddr not set, using Die ID\n"); die_id_0 = readl(&id_base->die_id_0); enetaddr[0] = 0x02; /* locally administered */ enetaddr[1] = readl(&id_base->die_id_1) & 0xff; enetaddr[2] = (die_id_0 & 0xff000000) >> 24; enetaddr[3] = (die_id_0 & 0x00ff0000) >> 16; enetaddr[4] = (die_id_0 & 0x0000ff00) >> 8; enetaddr[5] = (die_id_0 & 0x000000ff); eth_setenv_enetaddr("ethaddr", enetaddr); }
void cs8900_get_enetaddr (void) { int i; uchar enetaddr[6]; /* if the env is setup, then bail */ if (eth_getenv_enetaddr("ethaddr", enetaddr)) return; /* verify chip id */ if (get_reg_init_bus (PP_ChipID) != 0x630e) return; eth_reset (); if ((get_reg (PP_SelfSTAT) & (PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) == (PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) { /* Load the MAC from EEPROM */ for (i = 0; i < 6 / 2; i++) { unsigned int Addr; Addr = get_reg (PP_IA + i * 2); enetaddr[i * 2] = Addr & 0xFF; enetaddr[i * 2 + 1] = Addr >> 8; } eth_setenv_enetaddr("ethaddr", enetaddr); debug("### Set environment from HW MAC addr = \"%pM\"\n", enetaddr); } }
static void board_init_enetaddr(uchar *mac_addr) { bool valid_mac = false; /* the MAC is stored in OTP memory page 0xDF */ uint32_t ret; uint64_t otp_mac; ret = bfrom_OtpRead(0xDF, OTP_LOWER_HALF, &otp_mac); if (!(ret & OTP_MASTER_ERROR)) { uchar *otp_mac_p = (uchar *)&otp_mac; for (ret = 0; ret < 6; ++ret) mac_addr[ret] = otp_mac_p[5 - ret]; if (is_valid_ether_addr(mac_addr)) valid_mac = true; } if (!valid_mac) { puts("Warning: Generating 'random' MAC address\n"); bfin_gen_rand_mac(mac_addr); } eth_setenv_enetaddr("ethaddr", mac_addr); }
static int set_ethaddr_from_at24mac(void) { const int ETH_ADDR_LEN = 6; unsigned char ethaddr[ETH_ADDR_LEN]; const char *ETHADDR_NAME = "ethaddr"; struct udevice *bus, *dev; if (getenv(ETHADDR_NAME)) return 0; if (uclass_get_device_by_seq(UCLASS_I2C, AT24MAC_ON_I2C_BUS, &bus)) { printf("Cannot find I2C bus\n"); return -1; } if (dm_i2c_probe(bus, AT24MAC_ADDR, 0, &dev)) { printf("Failed to probe I2C device chip\n"); return -1; } if (dm_i2c_read(dev, AT24MAC_REG, ethaddr, ETH_ADDR_LEN)) { printf("Failed to read ethernet address from AT24MAC\n"); return -1; } if (!is_valid_ethaddr(ethaddr)) { printf("The ethernet address read from AT24MAC is not valid\n"); return -1; } return eth_setenv_enetaddr(ETHADDR_NAME, ethaddr); }
int board_eth_init(bd_t *bis) { int n = 0; #if (defined(CONFIG_DRIVER_TI_CPSW) && !defined(CONFIG_SPL_BUILD)) || \ (defined(CONFIG_SPL_ETH_SUPPORT) && defined(CONFIG_SPL_BUILD)) struct ctrl_dev *cdev = (struct ctrl_dev *)CTRL_DEVICE_BASE; #ifdef CONFIG_FACTORYSET int rv; if (!is_valid_ether_addr(factory_dat.mac)) printf("Error: no valid mac address\n"); else eth_setenv_enetaddr("ethaddr", factory_dat.mac); #endif /* #ifdef CONFIG_FACTORYSET */ /* Set rgmii mode and enable rmii clock to be sourced from chip */ writel(RGMII_MODE_ENABLE , &cdev->miisel); rv = cpsw_register(&cpsw_data); if (rv < 0) printf("Error %d registering CPSW switch\n", rv); else n += rv; #endif return n; }
int misc_init_r(void) { #if 0 /* TO DO */ uint8_t mac[6] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc }; /* set MAC address */ eth_setenv_enetaddr("ethaddr", mac); #endif #ifdef CONFIG_BOOT_ANDROID boot_mode_select(); #endif #if defined(CONFIG_CMD_BATTERYDET) && defined(CONFIG_BATTERY_INIT_GPIO) battery_init_gpio(); #endif #ifdef CONFIG_TESTARGS if(gpio_get_value(GPIO_PA(3)) == 0) //HOME key is PA03, press HOME key for more than 2 seconds to enter rootfs for factory test { int second = 2; while(second > 0 && gpio_get_value(GPIO_PA(3)) == 0) { mdelay(1000); second --; } if(second == 0) setenv("bootargs", CONFIG_TESTARGS); } #endif return 0; }
int misc_init_r(void) { uchar enetaddr[6]; if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { puts("Warning: Generating 'random' MAC address\n"); net_random_ethaddr(enetaddr); eth_setenv_enetaddr("ethaddr", enetaddr); } return 0; }
int misc_init_r(void) { uchar enetaddr[6]; if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { board_get_enetaddr(enetaddr); eth_setenv_enetaddr("ethaddr", enetaddr); } return 0; }
static void board_init_enetaddr(char *var) { uchar enetaddr[6]; if (eth_getenv_enetaddr(var, enetaddr)) return; printf("Warning: %s: generating 'random' MAC address\n", var); bfin_gen_rand_mac(enetaddr); eth_setenv_enetaddr(var, enetaddr); }
int misc_init_r(void) { #if defined(CONFIG_CMD_I2C) && defined(CONFIG_SYS_I2C_EEPROM_ADDR) if (!getenv("ethaddr")) { uchar mac[6]; if (lacie_read_mac_address(mac) == 0) eth_setenv_enetaddr("ethaddr", mac); } #endif return 0; }
static void board_init_enetaddr(uchar *mac_addr) { #ifndef CONFIG_SYS_NO_FLASH /* we cram the MAC in the last flash sector */ uchar *board_mac_addr = (uchar *)0x203F0096; if (is_valid_ethaddr(board_mac_addr)) { memcpy(mac_addr, board_mac_addr, 6); eth_setenv_enetaddr("ethaddr", mac_addr); } #endif }
int misc_init_r(void) { uint8_t macaddr[6]; uint8_t enetaddr[6]; debug("Testing mac addresses\n"); memcpy(macaddr, (uint8_t *) CONFIG_ETHADDR_ADDR, 6); if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { debug("Setting eth0 mac addr to %pM\n", macaddr); eth_setenv_enetaddr("ethaddr", macaddr); } if (!eth_getenv_enetaddr("eth1addr", enetaddr)) { macaddr[5] += 1; debug("Setting eth1 mac addr to %pM\n", macaddr); eth_setenv_enetaddr("eth1addr", macaddr); } return 0; }
int board_late_init(void) { #if !defined(CONFIG_SPL_BUILD) uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; /* try reading mac address from efuse */ mac_lo = readl(&cdev->macid0l); mac_hi = readl(&cdev->macid0h); mac_addr[0] = mac_hi & 0xFF; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = (mac_hi & 0xFF0000) >> 16; mac_addr[3] = (mac_hi & 0xFF000000) >> 24; mac_addr[4] = mac_lo & 0xFF; mac_addr[5] = (mac_lo & 0xFF00) >> 8; if (!getenv("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("ethaddr", mac_addr); } mac_lo = readl(&cdev->macid1l); mac_hi = readl(&cdev->macid1h); mac_addr[0] = mac_hi & 0xFF; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = (mac_hi & 0xFF0000) >> 16; mac_addr[3] = (mac_hi & 0xFF000000) >> 24; mac_addr[4] = mac_lo & 0xFF; mac_addr[5] = (mac_lo & 0xFF00) >> 8; if (!getenv("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_setenv_enetaddr("eth1addr", mac_addr); } #endif return 0; }
int misc_init_r(void) { uchar data[128]; char str[32]; u32 serial; int ret; /* EEPROM is at bus 0. */ ret = i2c_set_bus_num(0); if (ret) { puts("Cannot select EEPROM I2C bus.\n"); return 0; } /* EEPROM is at address 0x50. */ ret = eeprom_read(0x50, 0, data, sizeof(data)); if (ret) { puts("Cannot read I2C EEPROM.\n"); return 0; } /* Check EEPROM signature. */ if (!(data[0] == 0xa5 && data[1] == 0x5a)) { puts("Invalid I2C EEPROM signature.\n"); setenv("unit_serial", "invalid"); setenv("unit_ident", "VINing-xxxx-STD"); setenv("hostname", "vining-invalid"); return 0; } /* If 'unit_serial' is already set, do nothing. */ if (!getenv("unit_serial")) { /* This field is Big Endian ! */ serial = (data[0x54] << 24) | (data[0x55] << 16) | (data[0x56] << 8) | (data[0x57] << 0); memset(str, 0, sizeof(str)); sprintf(str, "%07i", serial); setenv("unit_serial", str); } if (!getenv("unit_ident")) { memset(str, 0, sizeof(str)); memcpy(str, &data[0x2e], 18); setenv("unit_ident", str); } /* Set ethernet address from EEPROM. */ if (!getenv("ethaddr") && is_valid_ethaddr(&data[0x62])) eth_setenv_enetaddr("ethaddr", &data[0x62]); return 0; }
/* * If there is no MAC address in the environment, then it will be initialized * (silently) from the value in the EEPROM. */ void davinci_sync_env_enetaddr(uint8_t *rom_enetaddr) { uint8_t env_enetaddr[6]; eth_getenv_enetaddr_by_index(0, env_enetaddr); if (!memcmp(env_enetaddr, "\0\0\0\0\0\0", 6)) { /* There is no MAC address in the environment, so we initialize * it from the value in the EEPROM. */ debug("### Setting environment from EEPROM MAC address = " "\"%pM\"\n", env_enetaddr); eth_setenv_enetaddr("ethaddr", rom_enetaddr); } }
int board_late_init(void) { u8 mac[6]; /* Read Mac Address and set*/ i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE); i2c_set_bus_num(CONFIG_SYS_I2C_MODULE); /* Read MAC address */ i2c_read(0x50, 0x0, 0, mac, 6); if (is_valid_ethaddr(mac)) eth_setenv_enetaddr("ethaddr", mac); return 0; }
/** * Setup the driver and init MAC address according to doc/README.enetaddr * Called by ne2k_register() before registering the driver @eth layer * * @param struct ethdevice of this instance of the driver for dev->enetaddr * @return 0 on success, -1 on error (causing caller to print error msg) */ static int ne2k_setup_driver(struct eth_device *dev) { PRINTK("### ne2k_setup_driver\n"); if (!pbuf) { pbuf = malloc(2000); if (!pbuf) { printf("Cannot allocate rx buffer\n"); return -1; } } #ifdef CONFIG_DRIVER_NE2000_CCR { vu_char *p = (vu_char *) CONFIG_DRIVER_NE2000_CCR; PRINTK("CCR before is %x\n", *p); *p = CONFIG_DRIVER_NE2000_VAL; PRINTK("CCR after is %x\n", *p); } #endif nic.base = (u8 *) CONFIG_DRIVER_NE2000_BASE; nic.data = nic.base + DP_DATA; nic.tx_buf1 = START_PG; nic.tx_buf2 = START_PG2; nic.rx_buf_start = RX_START; nic.rx_buf_end = RX_END; /* * According to doc/README.enetaddr, drivers shall give priority * to the MAC address value in the environment, so we do not read * it from the prom or eeprom if it is specified in the environment. */ if (!eth_getenv_enetaddr("ethaddr", dev->enetaddr)) { /* If the MAC address is not in the environment, get it: */ if (!get_prom(dev->enetaddr, nic.base)) /* get MAC from prom */ dp83902a_init(dev->enetaddr); /* fallback: seeprom */ /* And write it into the environment otherwise eth_write_hwaddr * returns -1 due to eth_getenv_enetaddr_by_index() failing, * and this causes "Warning: failed to set MAC address", and * cmd_bdinfo has no ethaddr value which it can show: */ eth_setenv_enetaddr("ethaddr", dev->enetaddr); } return 0; }
static void rescue_mode(void) { uchar enetaddr[6]; printf("Entering rescue mode..\n"); #ifdef CONFIG_RANDOM_MACADDR if (!eth_getenv_enetaddr("ethaddr", enetaddr)) { eth_random_enetaddr(enetaddr); if (eth_setenv_enetaddr("ethaddr", enetaddr)) { printf("Failed to set ethernet address\n"); set_led(LED_ALARM_BLINKING); return; } } #endif setenv("bootsource", "rescue"); }
int misc_init_r(void) { #if defined(CONFIG_CMD_NET) uchar mac_id[6]; if (!eth_getenv_enetaddr("ethaddr", mac_id) && !i2c_read_mac(mac_id)) eth_setenv_enetaddr("ethaddr", mac_id); #endif setenv("verify", "n"); #if defined(CONFIG_SPEAR_USBTTY) setenv("stdin", "usbtty"); setenv("stdout", "usbtty"); setenv("stderr", "usbtty"); #endif return 0; }
int misc_init_r(void) { #if 0 /* TO DO */ uint8_t mac[6] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc }; /* set MAC address */ eth_setenv_enetaddr("ethaddr", mac); #endif #ifdef CONFIG_BOOT_ANDROID boot_mode_select(); #endif #if defined(CONFIG_CMD_BATTERYDET) && defined(CONFIG_BATTERY_INIT_GPIO) battery_init_gpio(); #endif return 0; }
int board_late_init(void) { unsigned char mac[8]; int cpurev = get_cpu_rev(); setenv("cpu", get_imx_type((cpurev & 0xFF000) >> 12)); if (!getenv("board")) setenv("board", "insp"); if (!getenv("uboot_defconfig")) setenv("uboot_defconfig", CONFIG_DEFCONFIG); imx_get_mac_from_fuse(0, mac); if (is_valid_ethaddr(mac)) { if (!getenv("ethaddr")) eth_setenv_enetaddr("ethaddr", mac); } return 0; }
int board_eth_init(bd_t *bis) { int rv = 0; char mac_addr[6]; const char *mac = 0; uint32_t mac_hi, mac_lo; /* try reading mac address from efuse */ mac_lo = readl(&cdev->macid0l); mac_hi = readl(&cdev->macid0h); mac_addr[0] = mac_hi & 0xFF; mac_addr[1] = (mac_hi & 0xFF00) >> 8; mac_addr[2] = (mac_hi & 0xFF0000) >> 16; mac_addr[3] = (mac_hi & 0xFF000000) >> 24; mac_addr[4] = mac_lo & 0xFF; mac_addr[5] = (mac_lo & 0xFF00) >> 8; #if (defined(CONFIG_DRIVER_TI_CPSW) && !defined(CONFIG_SPL_BUILD)) || \ (defined(CONFIG_SPL_ETH_SUPPORT) && defined(CONFIG_SPL_BUILD)) if (!getenv("ethaddr")) { #if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_USE_FDT) printf("<ethaddr> not set. trying DTB ... "); mac = dtbmacaddr(0); #endif if (!mac) { printf("<ethaddr> not set. validating E-fuse MAC ... "); if (is_valid_ether_addr((const u8 *)mac_addr)) mac = (const char *)mac_addr; } if (mac) { printf("using: %pM on ", mac); eth_setenv_enetaddr("ethaddr", (const u8 *)mac); } } writel(MII_MODE_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_MII; cpsw_slaves[1].phy_if = PHY_INTERFACE_MODE_MII; rv = cpsw_register(&cpsw_data); if (rv < 0) { printf("Error %d registering CPSW switch\n", rv); return 0; } #endif /* CONFIG_DRIVER_TI_CPSW, ... */ return rv; }