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 (!env_get("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_env_set_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 (!env_get("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_env_set_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 misc_init_r(void) { #ifdef CONFIG_ATSHA204A int err; struct udevice *dev = get_atsha204a_dev(); u8 mac0[4], mac1[4], mac[6]; if (!dev) goto out; err = atsha204a_wakeup(dev); if (err) goto out; err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false, OMNIA_ATSHA204_OTP_MAC0, mac0); if (err) goto out; err = atsha204a_read(dev, ATSHA204A_ZONE_OTP, false, OMNIA_ATSHA204_OTP_MAC1, mac1); if (err) goto out; atsha204a_sleep(dev); mac[0] = mac0[1]; mac[1] = mac0[2]; mac[2] = mac0[3]; mac[3] = mac1[1]; mac[4] = mac1[2]; mac[5] = mac1[3]; if (is_valid_ethaddr(mac)) eth_env_set_enetaddr("ethaddr", mac); increment_mac(mac); if (is_valid_ethaddr(mac)) eth_env_set_enetaddr("eth1addr", mac); increment_mac(mac); if (is_valid_ethaddr(mac)) eth_env_set_enetaddr("eth2addr", mac); out: #endif return 0; }
int misc_init_r(void) { u8 mac_addr[EFUSE_MAC_SIZE]; char serial[EFUSE_SN_SIZE]; ssize_t len; meson_gx_eth_init(PHY_INTERFACE_MODE_RGMII, 0); /* Reset PHY on GPIOZ_14 */ clrbits_le32(GX_GPIO_EN(3), BIT(14)); clrbits_le32(GX_GPIO_OUT(3), BIT(14)); mdelay(10); setbits_le32(GX_GPIO_OUT(3), BIT(14)); if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { len = meson_sm_read_efuse(EFUSE_MAC_OFFSET, mac_addr, EFUSE_MAC_SIZE); if (len == EFUSE_MAC_SIZE && is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); } if (!env_get("serial#")) { len = meson_sm_read_efuse(EFUSE_SN_OFFSET, serial, EFUSE_SN_SIZE); if (len == EFUSE_SN_SIZE) env_set("serial#", serial); } return 0; }
int misc_init_r(void) { u8 mac_addr[EFUSE_MAC_SIZE]; char serial[EFUSE_SN_SIZE]; ssize_t len; /* Set RMII mode */ out_le32(GXBB_ETH_REG_0, GXBB_ETH_REG_0_INVERT_RMII_CLK | GXBB_ETH_REG_0_CLK_EN); /* Use Internal PHY */ out_le32(GXBB_ETH_REG_2, 0x10110181); out_le32(GXBB_ETH_REG_3, 0xe40908ff); /* Enable power and clock gate */ setbits_le32(GXBB_GCLK_MPEG_1, GXBB_GCLK_MPEG_1_ETH); clrbits_le32(GXBB_MEM_PD_REG_0, GXBB_MEM_PD_REG_0_ETH_MASK); if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { len = meson_sm_read_efuse(EFUSE_MAC_OFFSET, mac_addr, EFUSE_MAC_SIZE); if (len == EFUSE_MAC_SIZE && is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); } if (!env_get("serial#")) { len = meson_sm_read_efuse(EFUSE_SN_OFFSET, serial, EFUSE_SN_SIZE); if (len == EFUSE_SN_SIZE) env_set("serial#", serial); } return 0; }
int misc_init_r(void) { u8 mac_addr[EFUSE_MAC_SIZE]; char serial[EFUSE_SN_SIZE]; ssize_t len; meson_gx_eth_init(PHY_INTERFACE_MODE_RMII, MESON_GXL_USE_INTERNAL_RMII_PHY); /* Enable power and clock gate */ setbits_le32(GX_GCLK_MPEG_1, GX_GCLK_MPEG_1_ETH); clrbits_le32(GX_MEM_PD_REG_0, GX_MEM_PD_REG_0_ETH_MASK); if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { len = meson_sm_read_efuse(EFUSE_MAC_OFFSET, mac_addr, EFUSE_MAC_SIZE); if (len == EFUSE_MAC_SIZE && is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); } if (!env_get("serial#")) { len = meson_sm_read_efuse(EFUSE_SN_OFFSET, serial, EFUSE_SN_SIZE); if (len == EFUSE_SN_SIZE) env_set("serial#", serial); } return 0; }
static void setup_macaddr(void) { #if CONFIG_IS_ENABLED(CMD_NET) int ret; const char *cpuid = env_get("cpuid#"); u8 hash[SHA256_SUM_LEN]; int size = sizeof(hash); u8 mac_addr[6]; /* Only generate a MAC address, if none is set in the environment */ if (env_get("ethaddr")) return; if (!cpuid) { debug("%s: could not retrieve 'cpuid#'\n", __func__); return; } ret = hash_block("sha256", (void *)cpuid, strlen(cpuid), hash, &size); if (ret) { debug("%s: failed to calculate SHA256\n", __func__); return; } /* Copy 6 bytes of the hash to base the MAC address on */ memcpy(mac_addr, hash, 6); /* Make this a valid MAC address and set it */ mac_addr[0] &= 0xfe; /* clear multicast bit */ mac_addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ eth_env_set_enetaddr("ethaddr", mac_addr); #endif }
int show_board_info(void) { unsigned char ethaddr[6]; if (read_tdx_cfg_block()) { printf("Missing Toradex config block\n"); checkboard(); return 0; } /* board serial-number */ sprintf(tdx_serial_str, "%08u", tdx_serial); sprintf(tdx_board_rev_str, "V%1d.%1d%c", tdx_hw_tag.ver_major, tdx_hw_tag.ver_minor, (char)tdx_hw_tag.ver_assembly + 'A'); env_set("serial#", tdx_serial_str); /* * Check if environment contains a valid MAC address, * set the one from config block if not */ if (!eth_env_get_enetaddr("ethaddr", ethaddr)) eth_env_set_enetaddr("ethaddr", (u8 *)&tdx_eth_addr); #ifdef CONFIG_TDX_CFG_BLOCK_2ND_ETHADDR if (!eth_env_get_enetaddr("eth1addr", ethaddr)) { /* * Secondary MAC address is allocated from block * 0x100000 higher then the first MAC address */ memcpy(ethaddr, &tdx_eth_addr, 6); ethaddr[3] += 0x10; eth_env_set_enetaddr("eth1addr", ethaddr); } #endif printf("Model: Toradex %s %s, Serial# %s\n", toradex_modules[tdx_hw_tag.prodid], tdx_board_rev_str, tdx_serial_str); return 0; }
/* * Routine: handle_mac_address * Description: prepare MAC address for on-board Ethernet. */ static int handle_mac_address(void) { unsigned char enetaddr[6]; int rc; rc = eth_env_get_enetaddr("ethaddr", enetaddr); if (rc) return 0; rc = cl_eeprom_read_mac_addr(enetaddr, CONFIG_SYS_I2C_EEPROM_BUS); if (rc) return rc; if (!is_valid_ethaddr(enetaddr)) return -1; return eth_env_set_enetaddr("ethaddr", enetaddr); }
/* * Routine: handle_mac_address * Description: prepare MAC address for on-board Ethernet. */ static int handle_mac_address(void) { uchar enetaddr[6]; int rv; rv = eth_env_get_enetaddr("ethaddr", enetaddr); if (rv) return 0; rv = cl_eeprom_read_mac_addr(enetaddr, CONFIG_SYS_I2C_EEPROM_BUS); if (rv) get_efuse_mac_addr(enetaddr); if (!is_valid_ethaddr(enetaddr)) return -1; return eth_env_set_enetaddr("ethaddr", enetaddr); }
static int handle_mac_address(char *env_var, uint eeprom_bus) { unsigned char enetaddr[6]; int rc; rc = eth_env_get_enetaddr(env_var, enetaddr); if (rc) return 0; rc = cl_eeprom_read_mac_addr(enetaddr, eeprom_bus); if (rc) return rc; if (!is_valid_ethaddr(enetaddr)) return -1; return eth_env_set_enetaddr(env_var, enetaddr); }
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 (!env_get("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_ethaddr((const u8 *)mac_addr)) mac = (const char *)mac_addr; } if (mac) { printf("using: %pM on ", mac); eth_env_set_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; } return rv; }
/* * 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]; int ret; ret = eth_env_get_enetaddr_by_index("eth", 0, env_enetaddr); if (!ret) { /* * 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); ret = !eth_env_set_enetaddr("ethaddr", rom_enetaddr); } if (!ret) printf("Failed to set mac address from EEPROM: %d\n", ret); }
/* * cl_som_imx7_handle_mac_address() - set Ethernet MAC address environment. * * @env_var: MAC address environment variable * @eeprom_bus: I2C bus of the environment EEPROM * * @return: 0 on success, < 0 on failure */ static int cl_som_imx7_handle_mac_address(char *env_var, uint eeprom_bus) { int ret; unsigned char enetaddr[6]; ret = eth_env_get_enetaddr(env_var, enetaddr); if (ret) return 0; ret = cl_eeprom_read_mac_addr(enetaddr, eeprom_bus); if (ret) return ret; ret = is_valid_ethaddr(enetaddr); if (!ret) return -1; return eth_env_set_enetaddr(env_var, enetaddr); }
int board_eth_init(bd_t *bis) { int rv, n = 0; uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; const char *devname; if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { /* 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 (is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); }
int misc_init_r(void) { #if defined(CONFIG_CMD_NET) uchar mac_id[6]; if (!eth_env_get_enetaddr("ethaddr", mac_id) && !i2c_read_mac(mac_id)) eth_env_set_enetaddr("ethaddr", mac_id); #endif env_set("verify", "n"); #if defined(CONFIG_SPEAR_USBTTY) env_set("stdin", "usbtty"); env_set("stdout", "usbtty"); env_set("stderr", "usbtty"); #ifndef CONFIG_SYS_NO_DCACHE dcache_enable(); #endif #endif return 0; }
/* * Routine: handle_mac_address * Description: prepare MAC address for on-board Ethernet. */ static int cm_t3517_handle_mac_address(void) { unsigned char enetaddr[6]; int ret; ret = eth_env_get_enetaddr("ethaddr", enetaddr); if (ret) return 0; ret = cl_eeprom_read_mac_addr(enetaddr, CONFIG_SYS_I2C_EEPROM_BUS); if (ret) { ret = am3517_get_efuse_enetaddr(enetaddr); if (ret) return ret; } if (!is_valid_ethaddr(enetaddr)) return -1; return eth_env_set_enetaddr("ethaddr", enetaddr); }
int board_eth_init(bd_t *bis) { uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; struct ctrl_dev *cdev = (struct ctrl_dev *)CTRL_DEVICE_BASE; if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { printf("<ethaddr> not set. Reading from E-fuse\n"); /* 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 (is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); else printf("Unable to read MAC address. Set <ethaddr>\n"); }
int misc_init_r(void) { u8 mac_addr[EFUSE_MAC_SIZE]; char serial[EFUSE_SN_SIZE]; ssize_t len; meson_eth_init(PHY_INTERFACE_MODE_RMII, 0); if (!eth_env_get_enetaddr("ethaddr", mac_addr)) { len = meson_sm_read_efuse(EFUSE_MAC_OFFSET, mac_addr, EFUSE_MAC_SIZE); if (len == EFUSE_MAC_SIZE && is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); } if (!env_get("serial#")) { len = meson_sm_read_efuse(EFUSE_SN_OFFSET, serial, EFUSE_SN_SIZE); if (len == EFUSE_SN_SIZE) env_set("serial#", serial); } return 0; }
int misc_init_r(void) { struct novena_eeprom_data data; uchar *datap = (uchar *)&data; const char *signature = "Novena"; int ret; /* If 'ethaddr' is already set, do nothing. */ if (env_get("ethaddr")) return 0; /* EEPROM is at bus 2. */ ret = i2c_set_bus_num(2); if (ret) { puts("Cannot select EEPROM I2C bus.\n"); return 0; } /* EEPROM is at address 0x56. */ ret = eeprom_read(0x56, 0, datap, sizeof(data)); if (ret) { puts("Cannot read I2C EEPROM.\n"); return 0; } /* Check EEPROM signature. */ if (memcmp(data.signature, signature, 6)) { puts("Invalid I2C EEPROM signature.\n"); return 0; } /* Set ethernet address from EEPROM. */ eth_env_set_enetaddr("ethaddr", data.mac); return ret; }
int misc_init_r(void) { dspwake(); #if defined(CONFIG_MAC_ADDR_IN_SPIFLASH) || defined(CONFIG_MAC_ADDR_IN_EEPROM) uchar env_enetaddr[6]; int enetaddr_found; enetaddr_found = eth_env_get_enetaddr("ethaddr", env_enetaddr); #ifdef CONFIG_MAC_ADDR_IN_SPIFLASH int spi_mac_read; uchar buff[6]; spi_mac_read = get_mac_addr(buff); /* * MAC address not present in the environment * try and read the MAC address from SPI flash * and set it. */ if (!enetaddr_found) { if (!spi_mac_read) { if (is_valid_ethaddr(buff)) { if (eth_env_set_enetaddr("ethaddr", buff)) { printf("Warning: Failed to " "set MAC address from SPI flash\n"); } } else { printf("Warning: Invalid " "MAC address read from SPI flash\n"); } } } else { /* * MAC address present in environment compare it with * the MAC address in SPI flash and warn on mismatch */ if (!spi_mac_read && is_valid_ethaddr(buff) && memcmp(env_enetaddr, buff, 6)) printf("Warning: MAC address in SPI flash don't match " "with the MAC address in the environment\n"); printf("Default using MAC address from environment\n"); } #endif uint8_t enetaddr[8]; int eeprom_mac_read; /* Read Ethernet MAC address from EEPROM */ eeprom_mac_read = dvevm_read_mac_address(enetaddr); /* * MAC address not present in the environment * try and read the MAC address from EEPROM flash * and set it. */ if (!enetaddr_found) { if (eeprom_mac_read) /* Set Ethernet MAC address from EEPROM */ davinci_sync_env_enetaddr(enetaddr); } else { /* * MAC address present in environment compare it with * the MAC address in EEPROM and warn on mismatch */ if (eeprom_mac_read && memcmp(enetaddr, env_enetaddr, 6)) printf("Warning: MAC address in EEPROM don't match " "with the MAC address in the environment\n"); printf("Default using MAC address from environment\n"); } #endif return 0; }
int board_eth_init(bd_t *bis) { int ret; uint8_t mac_addr[6]; uint32_t mac_hi, mac_lo; uint32_t ctrl_val; int i; u64 mac1, mac2; u8 mac_addr1[6], mac_addr2[6]; int num_macs; /* 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 (!env_get("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_env_set_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 (!env_get("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_env_set_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() || board_is_am574x_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); /* * Export any Ethernet MAC addresses from EEPROM. * On AM57xx the 2 MAC addresses define the address range */ board_ti_get_eth_mac_addr(0, mac_addr1); board_ti_get_eth_mac_addr(1, mac_addr2); if (is_valid_ethaddr(mac_addr1) && is_valid_ethaddr(mac_addr2)) { mac1 = mac_to_u64(mac_addr1); mac2 = mac_to_u64(mac_addr2); /* must contain an address range */ num_macs = mac2 - mac1 + 1; /* <= 50 to protect against user programming error */ if (num_macs > 0 && num_macs <= 50) { for (i = 0; i < num_macs; i++) { u64_to_mac(mac1 + i, mac_addr); if (is_valid_ethaddr(mac_addr)) { eth_env_set_enetaddr_by_index("eth", i + 2, mac_addr); } } } } return ret; }
int board_eth_init(bd_t *bis) { int rv; 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 (!env_get("ethaddr")) { puts("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_env_set_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 (!env_get("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("eth1addr", mac_addr); } if (board_is_eposevm()) { writel(RMII_MODE_ENABLE | RMII_CHIPCKL_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RMII; cpsw_slaves[0].phy_addr = 16; } else if (board_is_sk()) { writel(RGMII_MODE_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII; cpsw_slaves[0].phy_addr = 4; cpsw_slaves[1].phy_addr = 5; } else if (board_is_idk()) { writel(RGMII_MODE_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII; cpsw_slaves[0].phy_addr = 0; } else { writel(RGMII_MODE_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = PHY_INTERFACE_MODE_RGMII; cpsw_slaves[0].phy_addr = 0; } rv = cpsw_register(&cpsw_data); if (rv < 0) printf("Error %d registering CPSW switch\n", rv); return rv; }
int board_eth_init(bd_t *bis) { int rv, n = 0; 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 (defined(CONFIG_DRIVER_TI_CPSW) && !defined(CONFIG_SPL_BUILD)) || \ (defined(CONFIG_SPL_ETH_SUPPORT) && defined(CONFIG_SPL_BUILD)) if (!env_get("ethaddr")) { printf("<ethaddr> not set. Validating first E-fuse MAC\n"); if (is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("ethaddr", mac_addr); } #ifdef CONFIG_DRIVER_TI_CPSW 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 (!env_get("eth1addr")) { if (is_valid_ethaddr(mac_addr)) eth_env_set_enetaddr("eth1addr", mac_addr); } writel(MII_MODE_ENABLE, &cdev->miisel); cpsw_slaves[0].phy_if = 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); else n += rv; #endif /* * * CPSW RGMII Internal Delay Mode is not supported in all PVT * operating points. So we must set the TX clock delay feature * in the AR8051 PHY. Since we only support a single ethernet * device in U-Boot, we only do this for the first instance. */ #define AR8051_PHY_DEBUG_ADDR_REG 0x1d #define AR8051_PHY_DEBUG_DATA_REG 0x1e #define AR8051_DEBUG_RGMII_CLK_DLY_REG 0x5 #define AR8051_RGMII_TX_CLK_DLY 0x100 #endif #if defined(CONFIG_USB_ETHER) && \ (!defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_USB_ETHER)) if (is_valid_ether_addr(mac_addr)) eth_env_set_enetaddr("usbnet_devaddr", mac_addr); rv = usb_eth_initialize(bis); if (rv < 0) printf("Error %d registering USB_ETHER\n", rv); else n += rv; #endif return n; }