Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2025-02-26 12:27:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

net: e1000: Remove non-DM_ETH code

Browse source 
As DM_ETH is required for all network drivers, it's now safe to remove
the non-DM_ETH support code.

Signed-off-by: Tom Rini <trini@konsulko.com>
This commit is contained in:
Tom Rini 2022-11-27 10:25:09 -05:00
parent 9f2d365ed3
commit 53fa409f59
2 changed files with 1 additions and 226 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

216
drivers/net/e1000.c
View file

@ -65,9 +65,7 @@ DEFINE_ALIGN_BUFFER(unsigned char, packet, 4096, E1000_BUFFER_ALIGN);
static int tx_tail; static int tx_tail;
static int rx_tail, rx_last; static int rx_tail, rx_last;
#ifdef CONFIG_DM_ETH
static int num_cards; /* Number of E1000 devices seen so far */ static int num_cards; /* Number of E1000 devices seen so far */
#endif
static struct pci_device_id e1000_supported[] = { static struct pci_device_id e1000_supported[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82542) }, { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82542) },
@ -1611,13 +1609,8 @@ e1000_reset_hw(struct e1000_hw *hw)
/* For 82542 (rev 2.0), disable MWI before issuing a device reset */ /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
if (hw->mac_type == e1000_82542_rev2_0) { if (hw->mac_type == e1000_82542_rev2_0) {
DEBUGOUT("Disabling MWI on 82542 rev 2.0\n"); DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
#ifdef CONFIG_DM_ETH
dm_pci_write_config16(hw->pdev, PCI_COMMAND, dm_pci_write_config16(hw->pdev, PCI_COMMAND,
hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE); hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE);
#else
pci_write_config_word(hw->pdev, PCI_COMMAND,
hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE);
#endif
} }
/* Clear interrupt mask to stop board from generating interrupts */ /* Clear interrupt mask to stop board from generating interrupts */
@ -1695,11 +1688,7 @@ e1000_reset_hw(struct e1000_hw *hw)
/* If MWI was previously enabled, reenable it. */ /* If MWI was previously enabled, reenable it. */
if (hw->mac_type == e1000_82542_rev2_0) { if (hw->mac_type == e1000_82542_rev2_0) {
#ifdef CONFIG_DM_ETH
dm_pci_write_config16(hw->pdev, PCI_COMMAND, hw->pci_cmd_word); dm_pci_write_config16(hw->pdev, PCI_COMMAND, hw->pci_cmd_word);
#else
pci_write_config_word(hw->pdev, PCI_COMMAND, hw->pci_cmd_word);
#endif
} }
if (hw->mac_type != e1000_igb) if (hw->mac_type != e1000_igb)
E1000_WRITE_REG(hw, PBA, pba); E1000_WRITE_REG(hw, PBA, pba);
@ -1884,15 +1873,9 @@ e1000_init_hw(struct e1000_hw *hw, unsigned char enetaddr[6])
/* For 82542 (rev 2.0), disable MWI and put the receiver into reset */ /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
if (hw->mac_type == e1000_82542_rev2_0) { if (hw->mac_type == e1000_82542_rev2_0) {
DEBUGOUT("Disabling MWI on 82542 rev 2.0\n"); DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
#ifdef CONFIG_DM_ETH
dm_pci_write_config16(hw->pdev, PCI_COMMAND, dm_pci_write_config16(hw->pdev, PCI_COMMAND,
hw-> hw->
pci_cmd_word & ~PCI_COMMAND_INVALIDATE); pci_cmd_word & ~PCI_COMMAND_INVALIDATE);
#else
pci_write_config_word(hw->pdev, PCI_COMMAND,
hw->
pci_cmd_word & ~PCI_COMMAND_INVALIDATE);
#endif
E1000_WRITE_REG(hw, RCTL, E1000_RCTL_RST); E1000_WRITE_REG(hw, RCTL, E1000_RCTL_RST);
E1000_WRITE_FLUSH(hw); E1000_WRITE_FLUSH(hw);
mdelay(5); mdelay(5);
@ -1908,11 +1891,7 @@ e1000_init_hw(struct e1000_hw *hw, unsigned char enetaddr[6])
E1000_WRITE_REG(hw, RCTL, 0); E1000_WRITE_REG(hw, RCTL, 0);
E1000_WRITE_FLUSH(hw); E1000_WRITE_FLUSH(hw);
mdelay(1); mdelay(1);
#ifdef CONFIG_DM_ETH
dm_pci_write_config16(hw->pdev, PCI_COMMAND, hw->pci_cmd_word); dm_pci_write_config16(hw->pdev, PCI_COMMAND, hw->pci_cmd_word);
#else
pci_write_config_word(hw->pdev, PCI_COMMAND, hw->pci_cmd_word);
#endif
} }
/* Zero out the Multicast HASH table */ /* Zero out the Multicast HASH table */
@ -1935,17 +1914,10 @@ e1000_init_hw(struct e1000_hw *hw, unsigned char enetaddr[6])
default: default:
/* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */ /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
if (hw->bus_type == e1000_bus_type_pcix) { if (hw->bus_type == e1000_bus_type_pcix) {
#ifdef CONFIG_DM_ETH
dm_pci_read_config16(hw->pdev, PCIX_COMMAND_REGISTER, dm_pci_read_config16(hw->pdev, PCIX_COMMAND_REGISTER,
&pcix_cmd_word); &pcix_cmd_word);
dm_pci_read_config16(hw->pdev, PCIX_STATUS_REGISTER_HI, dm_pci_read_config16(hw->pdev, PCIX_STATUS_REGISTER_HI,
&pcix_stat_hi_word); &pcix_stat_hi_word);
#else
pci_read_config_word(hw->pdev, PCIX_COMMAND_REGISTER,
&pcix_cmd_word);
pci_read_config_word(hw->pdev, PCIX_STATUS_REGISTER_HI,
&pcix_stat_hi_word);
#endif
cmd_mmrbc = cmd_mmrbc =
(pcix_cmd_word & PCIX_COMMAND_MMRBC_MASK) >> (pcix_cmd_word & PCIX_COMMAND_MMRBC_MASK) >>
PCIX_COMMAND_MMRBC_SHIFT; PCIX_COMMAND_MMRBC_SHIFT;
@ -1957,13 +1929,8 @@ e1000_init_hw(struct e1000_hw *hw, unsigned char enetaddr[6])
if (cmd_mmrbc > stat_mmrbc) { if (cmd_mmrbc > stat_mmrbc) {
pcix_cmd_word &= ~PCIX_COMMAND_MMRBC_MASK; pcix_cmd_word &= ~PCIX_COMMAND_MMRBC_MASK;
pcix_cmd_word |= stat_mmrbc << PCIX_COMMAND_MMRBC_SHIFT; pcix_cmd_word |= stat_mmrbc << PCIX_COMMAND_MMRBC_SHIFT;
#ifdef CONFIG_DM_ETH
dm_pci_write_config16(hw->pdev, PCIX_COMMAND_REGISTER, dm_pci_write_config16(hw->pdev, PCIX_COMMAND_REGISTER,
pcix_cmd_word); pcix_cmd_word);
#else
pci_write_config_word(hw->pdev, PCIX_COMMAND_REGISTER,
pcix_cmd_word);
#endif
} }
} }
break; break;
@ -5060,7 +5027,6 @@ e1000_sw_init(struct e1000_hw *hw)
int result; int result;
/* PCI config space info */ /* PCI config space info */
#ifdef CONFIG_DM_ETH
dm_pci_read_config16(hw->pdev, PCI_VENDOR_ID, &hw->vendor_id); dm_pci_read_config16(hw->pdev, PCI_VENDOR_ID, &hw->vendor_id);
dm_pci_read_config16(hw->pdev, PCI_DEVICE_ID, &hw->device_id); dm_pci_read_config16(hw->pdev, PCI_DEVICE_ID, &hw->device_id);
dm_pci_read_config16(hw->pdev, PCI_SUBSYSTEM_VENDOR_ID, dm_pci_read_config16(hw->pdev, PCI_SUBSYSTEM_VENDOR_ID,
@ -5069,16 +5035,6 @@ e1000_sw_init(struct e1000_hw *hw)
dm_pci_read_config8(hw->pdev, PCI_REVISION_ID, &hw->revision_id); dm_pci_read_config8(hw->pdev, PCI_REVISION_ID, &hw->revision_id);
dm_pci_read_config16(hw->pdev, PCI_COMMAND, &hw->pci_cmd_word); dm_pci_read_config16(hw->pdev, PCI_COMMAND, &hw->pci_cmd_word);
#else
pci_read_config_word(hw->pdev, PCI_VENDOR_ID, &hw->vendor_id);
pci_read_config_word(hw->pdev, PCI_DEVICE_ID, &hw->device_id);
pci_read_config_word(hw->pdev, PCI_SUBSYSTEM_VENDOR_ID,
&hw->subsystem_vendor_id);
pci_read_config_word(hw->pdev, PCI_SUBSYSTEM_ID, &hw->subsystem_id);
pci_read_config_byte(hw->pdev, PCI_REVISION_ID, &hw->revision_id);
pci_read_config_word(hw->pdev, PCI_COMMAND, &hw->pci_cmd_word);
#endif
/* identify the MAC */ /* identify the MAC */
result = e1000_set_mac_type(hw); result = e1000_set_mac_type(hw);
@ -5485,51 +5441,25 @@ void e1000_get_bus_type(struct e1000_hw *hw)
} }
} }
#ifndef CONFIG_DM_ETH
/* A list of all registered e1000 devices */
static LIST_HEAD(e1000_hw_list);
#endif
#ifdef CONFIG_DM_ETH
static int e1000_init_one(struct e1000_hw *hw, int cardnum, static int e1000_init_one(struct e1000_hw *hw, int cardnum,
struct udevice *devno, unsigned char enetaddr[6]) struct udevice *devno, unsigned char enetaddr[6])
#else
static int e1000_init_one(struct e1000_hw *hw, int cardnum, pci_dev_t devno,
unsigned char enetaddr[6])
#endif
{ {
u32 val; u32 val;
/* Assign the passed-in values */ /* Assign the passed-in values */
#ifdef CONFIG_DM_ETH
hw->pdev = devno; hw->pdev = devno;
#else
hw->pdev = devno;
#endif
hw->cardnum = cardnum; hw->cardnum = cardnum;
/* Print a debug message with the IO base address */ /* Print a debug message with the IO base address */
#ifdef CONFIG_DM_ETH
dm_pci_read_config32(devno, PCI_BASE_ADDRESS_0, &val); dm_pci_read_config32(devno, PCI_BASE_ADDRESS_0, &val);
#else
pci_read_config_dword(devno, PCI_BASE_ADDRESS_0, &val);
#endif
E1000_DBG(hw, "iobase 0x%08x\n", val & 0xfffffff0); E1000_DBG(hw, "iobase 0x%08x\n", val & 0xfffffff0);
/* Try to enable I/O accesses and bus-mastering */ /* Try to enable I/O accesses and bus-mastering */
val = PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; val = PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
#ifdef CONFIG_DM_ETH
dm_pci_write_config32(devno, PCI_COMMAND, val); dm_pci_write_config32(devno, PCI_COMMAND, val);
#else
pci_write_config_dword(devno, PCI_COMMAND, val);
#endif
/* Make sure it worked */ /* Make sure it worked */
#ifdef CONFIG_DM_ETH
dm_pci_read_config32(devno, PCI_COMMAND, &val); dm_pci_read_config32(devno, PCI_COMMAND, &val);
#else
pci_read_config_dword(devno, PCI_COMMAND, &val);
#endif
if (!(val & PCI_COMMAND_MEMORY)) { if (!(val & PCI_COMMAND_MEMORY)) {
E1000_ERR(hw, "Can't enable I/O memory\n"); E1000_ERR(hw, "Can't enable I/O memory\n");
return -ENOSPC; return -ENOSPC;
@ -5548,13 +5478,8 @@ static int e1000_init_one(struct e1000_hw *hw, int cardnum, pci_dev_t devno,
#ifndef CONFIG_E1000_NO_NVM #ifndef CONFIG_E1000_NO_NVM
hw->eeprom_semaphore_present = true; hw->eeprom_semaphore_present = true;
#endif #endif
#ifdef CONFIG_DM_ETH
hw->hw_addr = dm_pci_map_bar(devno, PCI_BASE_ADDRESS_0, 0, 0, hw->hw_addr = dm_pci_map_bar(devno, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_TYPE, PCI_REGION_MEM); PCI_REGION_TYPE, PCI_REGION_MEM);
#else
hw->hw_addr = pci_map_bar(devno, PCI_BASE_ADDRESS_0,
PCI_REGION_MEM);
#endif
hw->mac_type = e1000_undefined; hw->mac_type = e1000_undefined;
/* MAC and Phy settings */ /* MAC and Phy settings */
@ -5599,71 +5524,13 @@ static void e1000_name(char *str, int cardnum)
sprintf(str, "e1000#%u", cardnum); sprintf(str, "e1000#%u", cardnum);
} }
#ifndef CONFIG_DM_ETH
/**************************************************************************
TRANSMIT - Transmit a frame
***************************************************************************/
static int e1000_transmit(struct eth_device *nic, void *txpacket, int length)
{
struct e1000_hw *hw = nic->priv;
return _e1000_transmit(hw, txpacket, length);
}
/**************************************************************************
DISABLE - Turn off ethernet interface
***************************************************************************/
static void
e1000_disable(struct eth_device *nic)
{
struct e1000_hw *hw = nic->priv;
_e1000_disable(hw);
}
/**************************************************************************
INIT - set up ethernet interface(s)
***************************************************************************/
static int
e1000_init(struct eth_device *nic, struct bd_info *bis)
{
struct e1000_hw *hw = nic->priv;
return _e1000_init(hw, nic->enetaddr);
}
static int
e1000_poll(struct eth_device *nic)
{
struct e1000_hw *hw = nic->priv;
int len;
len = _e1000_poll(hw);
if (len) {
net_process_received_packet((uchar *)packet, len);
fill_rx(hw);
}
return len ? 1 : 0;
}
#endif /* !CONFIG_DM_ETH */
#ifdef CONFIG_DM_ETH
static int e1000_write_hwaddr(struct udevice *dev) static int e1000_write_hwaddr(struct udevice *dev)
#else
static int e1000_write_hwaddr(struct eth_device *dev)
#endif
{ {
#ifndef CONFIG_E1000_NO_NVM #ifndef CONFIG_E1000_NO_NVM
unsigned char current_mac[6]; unsigned char current_mac[6];
#ifdef CONFIG_DM_ETH
struct eth_pdata *plat = dev_get_plat(dev); struct eth_pdata *plat = dev_get_plat(dev);
struct e1000_hw *hw = dev_get_priv(dev); struct e1000_hw *hw = dev_get_priv(dev);
u8 *mac = plat->enetaddr; u8 *mac = plat->enetaddr;
#else
struct e1000_hw *hw = dev->priv;
u8 *mac = dev->enetaddr;
#endif
uint16_t data[3]; uint16_t data[3];
int ret_val, i; int ret_val, i;
@ -5701,87 +5568,16 @@ static int e1000_write_hwaddr(struct eth_device *dev)
#endif #endif
} }
#ifndef CONFIG_DM_ETH
/**************************************************************************
PROBE - Look for an adapter, this routine's visible to the outside
You should omit the last argument struct pci_device * for a non-PCI NIC
***************************************************************************/
int
e1000_initialize(struct bd_info * bis)
{
unsigned int i;
pci_dev_t devno;
int ret;
DEBUGFUNC();
/* Find and probe all the matching PCI devices */
for (i = 0; (devno = pci_find_devices(e1000_supported, i)) >= 0; i++) {
/*
* These will never get freed due to errors, this allows us to
* perform SPI EEPROM programming from U-Boot, for example.
*/
struct eth_device *nic = malloc(sizeof(*nic));
struct e1000_hw *hw = malloc(sizeof(*hw));
if (!nic || !hw) {
printf("e1000#%u: Out of Memory!\n", i);
free(nic);
free(hw);
continue;
}
/* Make sure all of the fields are initially zeroed */
memset(nic, 0, sizeof(*nic));
memset(hw, 0, sizeof(*hw));
nic->priv = hw;
/* Generate a card name */
e1000_name(nic->name, i);
hw->name = nic->name;
ret = e1000_init_one(hw, i, devno, nic->enetaddr);
if (ret)
continue;
list_add_tail(&hw->list_node, &e1000_hw_list);
hw->nic = nic;
/* Set up the function pointers and register the device */
nic->init = e1000_init;
nic->recv = e1000_poll;
nic->send = e1000_transmit;
nic->halt = e1000_disable;
nic->write_hwaddr = e1000_write_hwaddr;
eth_register(nic);
}
return i;
}
struct e1000_hw *e1000_find_card(unsigned int cardnum)
{
struct e1000_hw *hw;
list_for_each_entry(hw, &e1000_hw_list, list_node)
if (hw->cardnum == cardnum)
return hw;
return NULL;
}
#endif /* !CONFIG_DM_ETH */
#ifdef CONFIG_CMD_E1000 #ifdef CONFIG_CMD_E1000
static int do_e1000(struct cmd_tbl *cmdtp, int flag, int argc, static int do_e1000(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[]) char *const argv[])
{ {
unsigned char *mac = NULL; unsigned char *mac = NULL;
#ifdef CONFIG_DM_ETH
struct eth_pdata *plat; struct eth_pdata *plat;
struct udevice *dev; struct udevice *dev;
char name[30]; char name[30];
int ret; int ret;
#endif #if defined(CONFIG_E1000_SPI)
#if !defined(CONFIG_DM_ETH) || defined(CONFIG_E1000_SPI)
struct e1000_hw *hw; struct e1000_hw *hw;
#endif #endif
int cardnum; int cardnum;
@ -5793,18 +5589,12 @@ static int do_e1000(struct cmd_tbl *cmdtp, int flag, int argc,
/* Make sure we can find the requested e1000 card */ /* Make sure we can find the requested e1000 card */
cardnum = dectoul(argv[1], NULL); cardnum = dectoul(argv[1], NULL);
#ifdef CONFIG_DM_ETH
e1000_name(name, cardnum); e1000_name(name, cardnum);
ret = uclass_get_device_by_name(UCLASS_ETH, name, &dev); ret = uclass_get_device_by_name(UCLASS_ETH, name, &dev);
if (!ret) { if (!ret) {
plat = dev_get_plat(dev); plat = dev_get_plat(dev);
mac = plat->enetaddr; mac = plat->enetaddr;
} }
#else
hw = e1000_find_card(cardnum);
if (hw)
mac = hw->nic->enetaddr;
#endif
if (!mac) { if (!mac) {
printf("e1000: ERROR: No such device: e1000#%s\n", argv[1]); printf("e1000: ERROR: No such device: e1000#%s\n", argv[1]);
return 1; return 1;
@ -5817,9 +5607,7 @@ static int do_e1000(struct cmd_tbl *cmdtp, int flag, int argc,
} }
#ifdef CONFIG_E1000_SPI #ifdef CONFIG_E1000_SPI
#ifdef CONFIG_DM_ETH
hw = dev_get_priv(dev); hw = dev_get_priv(dev);
#endif
/* Handle the "SPI" subcommand */ /* Handle the "SPI" subcommand */
if (!strcmp(argv[2], "spi")) if (!strcmp(argv[2], "spi"))
return do_e1000_spi(cmdtp, hw, argc - 3, argv + 3); return do_e1000_spi(cmdtp, hw, argc - 3, argv + 3);
@ -5843,7 +5631,6 @@ U_BOOT_CMD(
); );
#endif /* not CONFIG_CMD_E1000 */ #endif /* not CONFIG_CMD_E1000 */
#ifdef CONFIG_DM_ETH
static int e1000_eth_start(struct udevice *dev) static int e1000_eth_start(struct udevice *dev)
{ {
struct eth_pdata *plat = dev_get_plat(dev); struct eth_pdata *plat = dev_get_plat(dev);
@ -5948,4 +5735,3 @@ U_BOOT_DRIVER(eth_e1000) = {
}; };
U_BOOT_PCI_DEVICE(eth_e1000, e1000_supported); U_BOOT_PCI_DEVICE(eth_e1000, e1000_supported);
#endif

11
drivers/net/e1000.h
View file

@ -21,10 +21,6 @@
#include <linux/list.h> #include <linux/list.h>
#include <malloc.h> #include <malloc.h>
#include <net.h> #include <net.h>
/* Avoids a compile error since struct eth_device is not defined */
#ifndef CONFIG_DM_ETH
#include <netdev.h>
#endif
#include <asm/io.h> #include <asm/io.h>
#include <pci.h> #include <pci.h>
@ -1077,19 +1073,12 @@ typedef enum {
struct e1000_hw { struct e1000_hw {
const char *name; const char *name;
struct list_head list_node; struct list_head list_node;
#ifndef CONFIG_DM_ETH
struct eth_device *nic;
#endif
#ifdef CONFIG_E1000_SPI #ifdef CONFIG_E1000_SPI
struct spi_slave spi; struct spi_slave spi;
#endif #endif
unsigned int cardnum; unsigned int cardnum;
#ifdef CONFIG_DM_ETH
struct udevice *pdev; struct udevice *pdev;
#else
pci_dev_t pdev;
#endif
uint8_t *hw_addr; uint8_t *hw_addr;
e1000_mac_type mac_type; e1000_mac_type mac_type;
e1000_phy_type phy_type; e1000_phy_type phy_type;