unsigned char *eth_get_ethaddr(void) { struct eth_pdata *pdata; if (eth_get_dev()) { pdata = eth_get_dev()->platdata; return pdata->enetaddr; } return NULL; }
static void net_init_loop(void) { if (eth_get_dev()) memcpy(net_ethaddr, eth_get_ethaddr(), 6); return; }
static int nc_stdio_tstc(struct stdio_dev *dev) { #ifdef CONFIG_DM_ETH struct udevice *eth; #else struct eth_device *eth; #endif if (input_recursion) return 0; if (input_size) return 1; eth = eth_get_dev(); if (eth_is_active(eth)) return 0; /* inside net loop */ input_recursion = 1; net_timeout = 1; net_loop(NETCONS); /* kind of poll */ input_recursion = 0; return input_size != 0; }
int eth_rx(void) { struct udevice *current; uchar *packet; int flags; int ret; int i; current = eth_get_dev(); if (!current) return -ENODEV; if (!device_active(current)) return -EINVAL; /* Process up to 32 packets at one time */ flags = ETH_RECV_CHECK_DEVICE; for (i = 0; i < 32; i++) { ret = eth_get_ops(current)->recv(current, flags, &packet); flags = 0; if (ret > 0) net_process_received_packet(packet, ret); if (ret >= 0 && eth_get_ops(current)->free_pkt) eth_get_ops(current)->free_pkt(current, packet, ret); if (ret <= 0) break; } if (ret == -EAGAIN) ret = 0; if (ret < 0) { /* We cannot completely return the error at present */ debug("%s: recv() returned error %d\n", __func__, ret); } return ret; }
/** * bootm_disable_interrupts() - Disable interrupts in preparation for load/boot * * @return interrupt flag (0 if interrupts were disabled, non-zero if they were * enabled) */ static ulong bootm_disable_interrupts(void) { ulong iflag; /* * We have reached the point of no return: we are going to * overwrite all exception vector code, so we cannot easily * recover from any failures any more... */ iflag = disable_interrupts(); #ifdef CONFIG_NETCONSOLE /* Stop the ethernet stack if NetConsole could have left it up */ eth_halt(); eth_unregister(eth_get_dev()); #endif #if defined(CONFIG_CMD_USB) /* * turn off USB to prevent the host controller from writing to the * SDRAM while Linux is booting. This could happen (at least for OHCI * controller), because the HCCA (Host Controller Communication Area) * lies within the SDRAM and the host controller writes continously to * this area (as busmaster!). The HccaFrameNumber is for example * updated every 1 ms within the HCCA structure in SDRAM! For more * details see the OpenHCI specification. */ usb_stop(); #endif return iflag; }
void __mii_init(void) { FEC_INFO_T *info; volatile FEC_T *fecp; struct eth_device *dev; int miispd = 0, i = 0; u16 status = 0; u16 linkgood = 0; /* retrieve from register structure */ dev = eth_get_dev(); info = dev->priv; fecp = (FEC_T *) info->miibase; fecpin_setclear(dev, 1); mii_reset(info); /* We use strictly polling mode only */ fecp->eimr = 0; /* Clear any pending interrupt */ fecp->eir = 0xffffffff; /* Set MII speed */ miispd = (gd->bus_clk / 1000000) / 5; fecp->mscr = miispd << 1; info->phy_addr = mii_discover_phy(dev); while (i < MCFFEC_TOUT_LOOP) { status = 0; i++; /* Read PHY control register */ miiphy_read(dev->name, info->phy_addr, MII_BMCR, &status); /* If phy set to autonegotiate, wait for autonegotiation done, * if phy is not autonegotiating, just wait for link up. */ if ((status & BMCR_ANENABLE) == BMCR_ANENABLE) { linkgood = (BMSR_ANEGCOMPLETE | BMSR_LSTATUS); } else { linkgood = BMSR_LSTATUS; } /* Read PHY status register */ miiphy_read(dev->name, info->phy_addr, MII_BMSR, &status); if ((status & linkgood) == linkgood) break; udelay(1); } if (i >= MCFFEC_TOUT_LOOP) { printf("Link UP timeout\n"); } /* adapt to the duplex and speed settings of the phy */ info->dup_spd = miiphy_duplex(dev->name, info->phy_addr) << 16; info->dup_spd |= miiphy_speed(dev->name, info->phy_addr); }
/* send command to phy using mii, wait for result */ uint mii_send(uint mii_cmd) { struct fec_info_s *info; struct eth_device *dev; volatile fec_t *ep; uint mii_reply; int j = 0; /* retrieve from register structure */ dev = eth_get_dev(); info = dev->priv; ep = (fec_t *) info->miibase; ep->mmfr = mii_cmd; /* command to phy */ /* wait for mii complete */ while (!(ep->eir & FEC_EIR_MII) && (j < MCFFEC_TOUT_LOOP)) { udelay(1); j++; } if (j >= MCFFEC_TOUT_LOOP) { printf("MII not complete\n"); return -1; } mii_reply = ep->mmfr; /* result from phy */ ep->eir = FEC_EIR_MII; /* clear MII complete */ #ifdef ET_DEBUG printf("%s[%d] %s: sent=0x%8.8x, reply=0x%8.8x\n", __FILE__, __LINE__, __FUNCTION__, mii_cmd, mii_reply); #endif return (mii_reply & 0xffff); /* data read from phy */ }
static int zynq_gem_miiphy_write(const char *devname, uchar addr, uchar reg, ushort val) { struct eth_device *dev = eth_get_dev(); debug("%s 0x%x, 0x%x, 0x%x\n", __func__, addr, reg, val); return phywrite(dev, addr, reg, val); }
static void NetInitLoop(void) { NetOurIP = string_to_ip("10.0.0.179"); NetOurGatewayIP = string_to_ip("10.0.0.254"); NetOurSubnetMask = string_to_ip("255.255.255.0"); NetServerIP = string_to_ip("10.0.0.128"); memcpy(NetOurEther, eth_get_dev()->enetaddr, 6); }
static int axiemac_miiphy_write(const char *devname, uchar addr, uchar reg, ushort val) { struct eth_device *dev = eth_get_dev(); debug("axiemac: Write MII 0x%x, 0x%x, 0x%x\n", addr, reg, val); return phywrite(dev, addr, reg, val); }
static int zynq_gem_miiphyread(const char *devname, uchar addr, uchar reg, ushort *val) { struct eth_device *dev = eth_get_dev(); int ret; ret = phyread(dev, addr, reg, val); debug("%s 0x%x, 0x%x, 0x%x\n", __func__, addr, reg, *val); return ret; }
static int axiemac_miiphy_read(const char *devname, uchar addr, uchar reg, ushort *val) { struct eth_device *dev = eth_get_dev(); u32 ret; ret = phyread(dev, addr, reg, val); debug("axiemac: Read MII 0x%x, 0x%x, 0x%x\n", addr, reg, *val); return ret; }
static void nc_send_packet(const char *buf, int len) { #ifdef CONFIG_DM_ETH struct udevice *eth; #else struct eth_device *eth; #endif int inited = 0; uchar *pkt; uchar *ether; struct in_addr ip; debug_cond(DEBUG_DEV_PKT, "output: \"%*.*s\"\n", len, len, buf); eth = eth_get_dev(); if (eth == NULL) return; if (!memcmp(nc_ether, net_null_ethaddr, 6)) { if (eth_is_active(eth)) return; /* inside net loop */ output_packet = buf; output_packet_len = len; input_recursion = 1; net_loop(NETCONS); /* wait for arp reply and send packet */ input_recursion = 0; output_packet_len = 0; return; } if (!eth_is_active(eth)) { if (eth_is_on_demand_init()) { if (eth_init() < 0) return; eth_set_last_protocol(NETCONS); } else { eth_init_state_only(); } inited = 1; } pkt = (uchar *)net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE; memcpy(pkt, buf, len); ether = nc_ether; ip = nc_ip; net_send_udp_packet(ether, ip, nc_out_port, nc_in_port, len); if (inited) { if (eth_is_on_demand_init()) eth_halt(); else eth_halt_state_only(); } }
/* Set passive state without calling stop on the driver */ void eth_halt_state_only(void) { struct udevice *current; struct eth_device_priv *priv; current = eth_get_dev(); if (!current || !device_active(current)) return; priv = current->uclass_priv; priv->state = ETH_STATE_PASSIVE; }
/* Set active state without calling start on the driver */ int eth_init_state_only(void) { struct udevice *current; struct eth_device_priv *priv; current = eth_get_dev(); if (!current || !device_active(current)) return -EINVAL; priv = current->uclass_priv; priv->state = ETH_STATE_ACTIVE; return 0; }
static void NetInitLoop(void) { static int env_changed_id; int env_id = get_env_id(); /* update only when the environment has changed */ if (env_changed_id != env_id) { NetOurIP = getenv_IPaddr("ipaddr"); NetOurGatewayIP = getenv_IPaddr("gatewayip"); NetOurSubnetMask = getenv_IPaddr("netmask"); NetServerIP = getenv_IPaddr("serverip"); NetOurNativeVLAN = getenv_VLAN("nvlan"); NetOurVLAN = getenv_VLAN("vlan"); #if defined(CONFIG_CMD_DNS) NetOurDNSIP = getenv_IPaddr("dnsip"); #endif env_changed_id = env_id; } if (eth_get_dev()) memcpy(NetOurEther, eth_get_dev()->enetaddr, 6); return; }
void __mii_init(void) { volatile fec_t *fecp; struct fec_info_s *info; struct eth_device *dev; int miispd = 0, i = 0; u16 autoneg = 0; /* retrieve from register structure */ dev = eth_get_dev(); info = dev->priv; fecp = (fec_t *) info->miibase; fecpin_setclear(dev, 1); mii_reset(info); /* We use strictly polling mode only */ fecp->eimr = 0; /* Clear any pending interrupt */ fecp->eir = 0xffffffff; /* Set MII speed */ miispd = (gd->bus_clk / 1000000) / 5; fecp->mscr = miispd << 1; info->phy_addr = mii_discover_phy(dev); #define AUTONEGLINK (PHY_BMSR_AUTN_COMP | PHY_BMSR_LS) while (i < MCFFEC_TOUT_LOOP) { autoneg = 0; miiphy_read(dev->name, info->phy_addr, PHY_BMSR, &autoneg); i++; if ((autoneg & AUTONEGLINK) == AUTONEGLINK) break; udelay(500); } if (i >= MCFFEC_TOUT_LOOP) { printf("Auto Negotiation not complete\n"); } /* adapt to the half/full speed settings */ info->dup_spd = miiphy_duplex(dev->name, info->phy_addr) << 16; info->dup_spd |= miiphy_speed(dev->name, info->phy_addr); }
/* * There can only be one active eth interface at a time - use what is * currently set to eth_current */ int dev_enum_net(struct device_info *di) { struct eth_device *eth_current = eth_get_dev(); di->type = DEV_TYP_NET; di->cookie = (void *)eth_current; if (di->cookie == NULL) return 0; memcpy(di->di_net.hwaddr, eth_current->enetaddr, 6); debugf("device found, returning cookie 0x%08x\n", (u_int32_t)di->cookie); return 1; }
int eth_send(void *packet, int length) { struct udevice *current; int ret; current = eth_get_dev(); if (!current) return -ENODEV; if (!device_active(current)) return -EINVAL; ret = eth_get_ops(current)->send(current, packet, length); if (ret < 0) { /* We cannot completely return the error at present */ debug("%s: send() returned error %d\n", __func__, ret); } return ret; }
/**************************************************************************** * mii_init -- Initialize the MII for MII command without ethernet * This function is a subset of eth_init **************************************************************************** */ void mii_reset(struct fec_info_s *info) { volatile fec_t *fecp = (fec_t *) (info->miibase); struct eth_device *dev; int i, miispd; u16 rst = 0; dev = eth_get_dev(); miispd = (gd->bus_clk / 1000000) / 5; fecp->mscr = miispd << 1; miiphy_write(dev->name, info->phy_addr, PHY_BMCR, PHY_BMCR_RESET); for (i = 0; i < FEC_RESET_DELAY; ++i) { udelay(500); miiphy_read(dev->name, info->phy_addr, PHY_BMCR, &rst); if ((rst & PHY_BMCR_RESET) == 0) break; } if (i == FEC_RESET_DELAY) printf("Mii reset timeout %d\n", i); }
static void nc_send_packet (const char *buf, int len) { DECLARE_GLOBAL_DATA_PTR; struct eth_device *eth; int inited = 0; uchar *pkt; uchar *ether; IPaddr_t ip; if ((eth = eth_get_dev ()) == NULL) { return; } if (!memcmp (nc_ether, NetEtherNullAddr, 6)) { if (eth->state == ETH_STATE_ACTIVE) return; /* inside net loop */ output_packet = buf; output_packet_len = len; NetLoop (NETCONS); /* wait for arp reply and send packet */ output_packet_len = 0; return; } if (eth->state != ETH_STATE_ACTIVE) { if (eth_init (gd->bd) < 0) return; inited = 1; } pkt = (uchar *) NetTxPacket + NetEthHdrSize () + IP_HDR_SIZE; memcpy (pkt, buf, len); ether = nc_ether; ip = nc_ip; NetSendUDPPacket (ether, ip, nc_port, nc_port, len); if (inited) eth_halt (); }
static int nc_tstc(void) { struct eth_device *eth; if (input_recursion) return 0; if (input_size) return 1; eth = eth_get_dev (); if (eth && eth->state == ETH_STATE_ACTIVE) return 0; /* inside net loop */ input_recursion = 1; net_timeout = 1; NetLoop (NETCONS); /* kind of poll */ input_recursion = 0; return input_size != 0; }
/* * Initializes on-board ethernet controllers. */ int board_eth_init(bd_t *bis) { u_int8_t mac_addr[6]; u_int8_t switch_start_cmd[2] = { 0x01, 0x23 }; struct eth_device *dev; /* Read Ethernet MAC address from EEPROM */ if (dvevm_read_mac_address(mac_addr)) /* set address env if not already set */ davinci_sync_env_enetaddr(mac_addr); /* read the address back from env */ if (!eth_getenv_enetaddr("ethaddr", mac_addr)) return -1; /* enable the Ethernet switch in the 3 port PHY */ if (i2c_write(PHY_SW_I2C_ADDR, 0, 0, switch_start_cmd, sizeof(switch_start_cmd))) { printf("Ethernet switch start failed!\n"); return -1; } /* finally, initialise the driver */ if (!davinci_emac_initialize()) { printf("Error: Ethernet init failed!\n"); return -1; } dev = eth_get_dev(); /* provide the resulting addr to the driver */ memcpy(dev->enetaddr, mac_addr, 6); dev->write_hwaddr(dev); return 0; }
int bootme_send_frame(const void *buf, size_t len) { int ret; struct eth_device *eth; int inited = 0; uchar *pkt; eth = eth_get_dev(); if (eth == NULL) return -EINVAL; if (bootme_state == BOOTME_INIT) check_net_config(); debug("%s: buf: %p len: %u from %pI4:%d to %pI4:%d\n", __func__, buf, len, &NetOurIP, bootme_src_port, &bootme_ip, bootme_dst_port); if (memcmp(bootme_ether, NetEtherNullAddr, ETH_ALEN) == 0) { if (eth->state == ETH_STATE_ACTIVE) return 0; /* inside net loop */ output_packet = buf; output_packet_len = len; /* wait for arp reply and send packet */ ret = NetLoop(BOOTME); if (ret < 0) { /* drop packet */ output_packet_len = 0; return ret; } if (bootme_timed_out) return -ETIMEDOUT; return 0; } if (eth->state != ETH_STATE_ACTIVE) { if (eth_is_on_demand_init()) { ret = eth_init(gd->bd); if (ret < 0) return ret; eth_set_last_protocol(BOOTME); } else { eth_init_state_only(gd->bd); } inited = 1; } assert(NetTxPacket != NULL); pkt = (uchar *)NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE; memcpy(pkt, buf, len); ret = NetSendUDPPacket(bootme_ether, bootme_ip, bootme_dst_port, bootme_src_port, len); if (inited) { debug("Stopping network\n"); if (eth_is_on_demand_init()) eth_halt(); else eth_halt_state_only(); } return ret; }
static int dev_valid_net(void *cookie) { return ((void *)eth_get_dev() == cookie) ? 1 : 0; }
void __mii_init(void) { FEC_INFO_T *info; volatile FEC_T *fecp; struct eth_device *dev; int miispd = 0, i = 0; u16 status = 0; u16 linkgood = 0; /* retrieve from register structure */ dev = eth_get_dev(); info = dev->priv; fecp = (FEC_T *) info->miibase; fecpin_setclear(dev, 1); mii_reset(info); /* We use strictly polling mode only */ fecp->eimr = 0; /* Clear any pending interrupt */ fecp->eir = 0xffffffff; /* Set MII speed */ #ifdef CONFIG_M68K miispd = (gd->bus_clk / 1000000) / 5; #else /* * The MSCR[MII_SPEED] bit field is minus 1 encoded. * * We round the value in MSCR[MII_SPEED] up, so that the MDC frequency * never exceeds CONFIG_MCFFEC_MII_SPEED_LIMIT. */ miispd = (CONFIG_MCFFEC_MAC_CLK - 1) / (2 * CONFIG_MCFFEC_MII_SPEED_LIMIT); #endif /* CONFIG_M68K */ if (miispd > MCFFEC_MII_SPEED_MAX) miispd = MCFFEC_MII_SPEED_MAX; fecp->mscr = miispd << 1; info->phy_addr = mii_discover_phy(dev); while (i < MCFFEC_TOUT_LOOP) { status = 0; i++; /* Read PHY control register */ miiphy_read(dev->name, info->phy_addr, PHY_BMCR, &status); /* If phy set to autonegotiate, wait for autonegotiation done, * if phy is not autonegotiating, just wait for link up. */ if ((status & PHY_BMCR_AUTON) == PHY_BMCR_AUTON) { linkgood = (PHY_BMSR_AUTN_COMP | PHY_BMSR_LS); } else { linkgood = PHY_BMSR_LS; } /* Read PHY status register */ miiphy_read(dev->name, info->phy_addr, PHY_BMSR, &status); if ((status & linkgood) == linkgood) break; udelay(1); } if (i >= MCFFEC_TOUT_LOOP) { printf("Link UP timeout\n"); } /* adapt to the duplex and speed settings of the phy */ info->dup_spd = miiphy_duplex(dev->name, info->phy_addr) << 16; info->dup_spd |= miiphy_speed(dev->name, info->phy_addr); }
static void TftpSend(void) { uchar *pkt; uchar *xp; int len = 0; ushort *s; #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP.. non-MasterClients do not ACK data. */ if (Multicast && (TftpState == STATE_DATA) && (MasterClient == 0)) return; #endif /* * We will always be sending some sort of packet, so * cobble together the packet headers now. */ pkt = NetTxPacket + NetEthHdrSize() + IP_UDP_HDR_SIZE; switch (TftpState) { case STATE_SEND_RRQ: case STATE_SEND_WRQ: xp = pkt; s = (ushort *)pkt; #ifdef CONFIG_CMD_TFTPPUT *s++ = htons(TftpState == STATE_SEND_RRQ ? TFTP_RRQ : TFTP_WRQ); #else *s++ = htons(TFTP_RRQ); #endif pkt = (uchar *)s; strcpy((char *)pkt, tftp_filename); pkt += strlen(tftp_filename) + 1; strcpy((char *)pkt, "octet"); pkt += 5 /*strlen("octet")*/ + 1; strcpy((char *)pkt, "timeout"); pkt += 7 /*strlen("timeout")*/ + 1; sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000); debug("send option \"timeout %s\"\n", (char *)pkt); pkt += strlen((char *)pkt) + 1; #ifdef CONFIG_TFTP_TSIZE pkt += sprintf((char *)pkt, "tsize%c%lu%c", 0, NetBootFileXferSize, 0); #endif /* try for more effic. blk size */ pkt += sprintf((char *)pkt, "blksize%c%d%c", 0, TftpBlkSizeOption, 0); #ifdef CONFIG_MCAST_TFTP /* Check all preconditions before even trying the option */ if (!ProhibitMcast) { Bitmap = malloc(Mapsize); if (Bitmap && eth_get_dev()->mcast) { free(Bitmap); Bitmap = NULL; pkt += sprintf((char *)pkt, "multicast%c%c", 0, 0); } } #endif /* CONFIG_MCAST_TFTP */ len = pkt - xp; break; case STATE_OACK: #ifdef CONFIG_MCAST_TFTP /* My turn! Start at where I need blocks I missed.*/ if (Multicast) TftpBlock = ext2_find_next_zero_bit(Bitmap, (Mapsize*8), 0); /*..falling..*/ #endif case STATE_RECV_WRQ: case STATE_DATA: xp = pkt; s = (ushort *)pkt; s[0] = htons(TFTP_ACK); s[1] = htons(TftpBlock); pkt = (uchar *)(s + 2); #ifdef CONFIG_CMD_TFTPPUT if (TftpWriting) { int toload = TftpBlkSize; int loaded = load_block(TftpBlock, pkt, toload); s[0] = htons(TFTP_DATA); pkt += loaded; TftpFinalBlock = (loaded < toload); } #endif len = pkt - xp; break; case STATE_TOO_LARGE: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_ERROR); *s++ = htons(3); pkt = (uchar *)s; strcpy((char *)pkt, "File too large"); pkt += 14 /*strlen("File too large")*/ + 1; len = pkt - xp; break; case STATE_BAD_MAGIC: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_ERROR); *s++ = htons(2); pkt = (uchar *)s; strcpy((char *)pkt, "File has bad magic"); pkt += 18 /*strlen("File has bad magic")*/ + 1; len = pkt - xp; break; } NetSendUDPPacket(NetServerEther, TftpRemoteIP, TftpRemotePort, TftpOurPort, len); }
int eth_get_dev_index(void) { if (eth_get_dev()) return eth_get_dev()->seq; return -1; }
static void TftpSend (void) { volatile uchar * pkt; volatile uchar * xp; int len = 0; volatile ushort *s; #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP.. non-MasterClients do not ACK data. */ if (Multicast && (TftpState == STATE_DATA) && (MasterClient == 0)) return; #endif /* * We will always be sending some sort of packet, so * cobble together the packet headers now. */ pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE; switch (TftpState) { case STATE_RRQ: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_RRQ); pkt = (uchar *)s; strcpy ((char *)pkt, tftp_filename); pkt += strlen(tftp_filename) + 1; strcpy ((char *)pkt, "octet"); pkt += 5 /*strlen("octet")*/ + 1; strcpy ((char *)pkt, "timeout"); pkt += 7 /*strlen("timeout")*/ + 1; sprintf((char *)pkt, "%lu", TIMEOUT / 1000); debug("send option \"timeout %s\"\n", (char *)pkt); pkt += strlen((char *)pkt) + 1; /* try for more effic. blk size */ pkt += sprintf((char *)pkt,"blksize%c%d%c", 0,TftpBlkSizeOption,0); #ifdef CONFIG_MCAST_TFTP /* Check all preconditions before even trying the option */ if (!ProhibitMcast && (Bitmap=malloc(Mapsize)) && eth_get_dev()->mcast) { free(Bitmap); Bitmap=NULL; pkt += sprintf((char *)pkt,"multicast%c%c",0,0); } #endif /* CONFIG_MCAST_TFTP */ len = pkt - xp; break; case STATE_OACK: #ifdef CONFIG_MCAST_TFTP /* My turn! Start at where I need blocks I missed.*/ if (Multicast) TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*8),0); /*..falling..*/ #endif case STATE_DATA: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_ACK); *s++ = htons(TftpBlock); pkt = (uchar *)s; len = pkt - xp; break; case STATE_TOO_LARGE: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_ERROR); *s++ = htons(3); pkt = (uchar *)s; strcpy ((char *)pkt, "File too large"); pkt += 14 /*strlen("File too large")*/ + 1; len = pkt - xp; break; case STATE_BAD_MAGIC: xp = pkt; s = (ushort *)pkt; *s++ = htons(TFTP_ERROR); *s++ = htons(2); pkt = (uchar *)s; strcpy ((char *)pkt, "File has bad magic"); pkt += 18 /*strlen("File has bad magic")*/ + 1; len = pkt - xp; break; } NetSendUDPPacket(NetServerEther, TftpServerIP, TftpServerPort, TftpOurPort, len); }
int eth_init(void) { char *ethact = getenv("ethact"); char *ethrotate = getenv("ethrotate"); struct udevice *current = NULL; struct udevice *old_current; int ret = -ENODEV; /* * When 'ethrotate' variable is set to 'no' and 'ethact' variable * is already set to an ethernet device, we should stick to 'ethact'. */ if ((ethrotate != NULL) && (strcmp(ethrotate, "no") == 0)) { if (ethact) { current = eth_get_dev_by_name(ethact); if (!current) return -EINVAL; } } if (!current) { current = eth_get_dev(); if (!current) { printf("No ethernet found.\n"); return -ENODEV; } } old_current = current; do { if (current) { debug("Trying %s\n", current->name); if (device_active(current)) { ret = eth_get_ops(current)->start(current); if (ret >= 0) { struct eth_device_priv *priv = current->uclass_priv; priv->state = ETH_STATE_ACTIVE; return 0; } } else { ret = eth_errno; } debug("FAIL\n"); } else { debug("PROBE FAIL\n"); } /* * If ethrotate is enabled, this will change "current", * otherwise we will drop out of this while loop immediately */ eth_try_another(0); /* This will ensure the new "current" attempted to probe */ current = eth_get_dev(); } while (old_current != current); return ret; }