Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 2 | |
| 3 | #include <common.h> |
Simon Glass | 0af6e2d | 2019-08-01 09:46:52 -0600 | [diff] [blame] | 4 | #include <env.h> |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 5 | #include <malloc.h> |
| 6 | #include <net.h> |
Ben Warren | 840f8a5 | 2008-08-31 10:45:44 -0700 | [diff] [blame] | 7 | #include <netdev.h> |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 8 | #include <pci.h> |
| 9 | |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 10 | #undef DEBUG_SROM |
| 11 | #undef DEBUG_SROM2 |
| 12 | |
| 13 | #undef UPDATE_SROM |
| 14 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 15 | /* PCI Registers. */ |
| 16 | #define PCI_CFDA_PSM 0x43 |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 17 | |
| 18 | #define CFRV_RN 0x000000f0 /* Revision Number */ |
| 19 | |
| 20 | #define WAKEUP 0x00 /* Power Saving Wakeup */ |
| 21 | #define SLEEP 0x80 /* Power Saving Sleep Mode */ |
| 22 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 23 | #define DC2114x_BRK 0x0020 /* CFRV break between DC21142 & DC21143 */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 24 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 25 | /* Ethernet chip registers. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 26 | #define DE4X5_BMR 0x000 /* Bus Mode Register */ |
| 27 | #define DE4X5_TPD 0x008 /* Transmit Poll Demand Reg */ |
| 28 | #define DE4X5_RRBA 0x018 /* RX Ring Base Address Reg */ |
| 29 | #define DE4X5_TRBA 0x020 /* TX Ring Base Address Reg */ |
| 30 | #define DE4X5_STS 0x028 /* Status Register */ |
| 31 | #define DE4X5_OMR 0x030 /* Operation Mode Register */ |
| 32 | #define DE4X5_SICR 0x068 /* SIA Connectivity Register */ |
| 33 | #define DE4X5_APROM 0x048 /* Ethernet Address PROM */ |
| 34 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 35 | /* Register bits. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 36 | #define BMR_SWR 0x00000001 /* Software Reset */ |
| 37 | #define STS_TS 0x00700000 /* Transmit Process State */ |
| 38 | #define STS_RS 0x000e0000 /* Receive Process State */ |
| 39 | #define OMR_ST 0x00002000 /* Start/Stop Transmission Command */ |
| 40 | #define OMR_SR 0x00000002 /* Start/Stop Receive */ |
| 41 | #define OMR_PS 0x00040000 /* Port Select */ |
| 42 | #define OMR_SDP 0x02000000 /* SD Polarity - MUST BE ASSERTED */ |
| 43 | #define OMR_PM 0x00000080 /* Pass All Multicast */ |
| 44 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 45 | /* Descriptor bits. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 46 | #define R_OWN 0x80000000 /* Own Bit */ |
| 47 | #define RD_RER 0x02000000 /* Receive End Of Ring */ |
| 48 | #define RD_LS 0x00000100 /* Last Descriptor */ |
| 49 | #define RD_ES 0x00008000 /* Error Summary */ |
| 50 | #define TD_TER 0x02000000 /* Transmit End Of Ring */ |
| 51 | #define T_OWN 0x80000000 /* Own Bit */ |
| 52 | #define TD_LS 0x40000000 /* Last Segment */ |
| 53 | #define TD_FS 0x20000000 /* First Segment */ |
| 54 | #define TD_ES 0x00008000 /* Error Summary */ |
| 55 | #define TD_SET 0x08000000 /* Setup Packet */ |
| 56 | |
| 57 | /* The EEPROM commands include the alway-set leading bit. */ |
| 58 | #define SROM_WRITE_CMD 5 |
| 59 | #define SROM_READ_CMD 6 |
| 60 | #define SROM_ERASE_CMD 7 |
| 61 | |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 62 | #define SROM_HWADD 0x0014 /* Hardware Address offset in SROM */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 63 | #define SROM_RD 0x00004000 /* Read from Boot ROM */ |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 64 | #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */ |
| 65 | #define EE_WRITE_0 0x4801 |
| 66 | #define EE_WRITE_1 0x4805 |
| 67 | #define EE_DATA_READ 0x08 /* EEPROM chip data out. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 68 | #define SROM_SR 0x00000800 /* Select Serial ROM when set */ |
| 69 | |
| 70 | #define DT_IN 0x00000004 /* Serial Data In */ |
| 71 | #define DT_CLK 0x00000002 /* Serial ROM Clock */ |
| 72 | #define DT_CS 0x00000001 /* Serial ROM Chip Select */ |
| 73 | |
| 74 | #define POLL_DEMAND 1 |
| 75 | |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 76 | #if defined(CONFIG_E500) |
| 77 | #define phys_to_bus(a) (a) |
| 78 | #else |
| 79 | #define phys_to_bus(a) pci_phys_to_mem((pci_dev_t)dev->priv, a) |
| 80 | #endif |
| 81 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 82 | #define NUM_RX_DESC PKTBUFSRX |
| 83 | #define NUM_TX_DESC 1 /* Number of TX descriptors */ |
| 84 | #define RX_BUFF_SZ PKTSIZE_ALIGN |
| 85 | |
| 86 | #define TOUT_LOOP 1000000 |
| 87 | |
| 88 | #define SETUP_FRAME_LEN 192 |
| 89 | |
| 90 | struct de4x5_desc { |
| 91 | volatile s32 status; |
| 92 | u32 des1; |
| 93 | u32 buf; |
| 94 | u32 next; |
| 95 | }; |
| 96 | |
| 97 | /* RX and TX descriptor ring */ |
| 98 | static struct de4x5_desc rx_ring[NUM_RX_DESC] __aligned(32); |
| 99 | static struct de4x5_desc tx_ring[NUM_TX_DESC] __aligned(32); |
| 100 | static int rx_new; /* RX descriptor ring pointer */ |
| 101 | static int tx_new; /* TX descriptor ring pointer */ |
| 102 | |
| 103 | static char rx_ring_size; |
| 104 | static char tx_ring_size; |
| 105 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 106 | static u32 dc2114x_inl(struct eth_device *dev, u32 addr) |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 107 | { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 108 | return le32_to_cpu(*(volatile u32 *)(addr + dev->iobase)); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 109 | } |
| 110 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 111 | static void dc2114x_outl(struct eth_device *dev, u32 command, u32 addr) |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 112 | { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 113 | *(volatile u32 *)(addr + dev->iobase) = cpu_to_le32(command); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | static void reset_de4x5(struct eth_device *dev) |
| 117 | { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 118 | u32 i; |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 119 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 120 | i = dc2114x_inl(dev, DE4X5_BMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 121 | mdelay(1); |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 122 | dc2114x_outl(dev, i | BMR_SWR, DE4X5_BMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 123 | mdelay(1); |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 124 | dc2114x_outl(dev, i, DE4X5_BMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 125 | mdelay(1); |
| 126 | |
| 127 | for (i = 0; i < 5; i++) { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 128 | dc2114x_inl(dev, DE4X5_BMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 129 | mdelay(10); |
| 130 | } |
| 131 | |
| 132 | mdelay(1); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 133 | } |
| 134 | |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 135 | static void start_de4x5(struct eth_device *dev) |
| 136 | { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 137 | u32 omr; |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 138 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 139 | omr = dc2114x_inl(dev, DE4X5_OMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 140 | omr |= OMR_ST | OMR_SR; |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 141 | dc2114x_outl(dev, omr, DE4X5_OMR); /* Enable the TX and/or RX */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 142 | } |
| 143 | |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 144 | static void stop_de4x5(struct eth_device *dev) |
| 145 | { |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 146 | u32 omr; |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 147 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 148 | omr = dc2114x_inl(dev, DE4X5_OMR); |
Marek Vasut | 75244fb | 2020-04-19 03:36:46 +0200 | [diff] [blame] | 149 | omr &= ~(OMR_ST | OMR_SR); |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 150 | dc2114x_outl(dev, omr, DE4X5_OMR); /* Disable the TX and/or RX */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 153 | /* SROM Read and write routines. */ |
| 154 | static void sendto_srom(struct eth_device *dev, u_int command, u_long addr) |
| 155 | { |
| 156 | dc2114x_outl(dev, command, addr); |
| 157 | udelay(1); |
| 158 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 159 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 160 | static int getfrom_srom(struct eth_device *dev, u_long addr) |
| 161 | { |
| 162 | u32 tmp = dc2114x_inl(dev, addr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 163 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 164 | udelay(1); |
| 165 | return tmp; |
| 166 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 167 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 168 | /* Note: this routine returns extra data bits for size detection. */ |
| 169 | static int do_read_eeprom(struct eth_device *dev, u_long ioaddr, int location, |
| 170 | int addr_len) |
| 171 | { |
| 172 | int read_cmd = location | (SROM_READ_CMD << addr_len); |
| 173 | unsigned int retval = 0; |
| 174 | int i; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 175 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 176 | sendto_srom(dev, SROM_RD | SROM_SR, ioaddr); |
| 177 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 178 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 179 | #ifdef DEBUG_SROM |
| 180 | printf(" EEPROM read at %d ", location); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 181 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 182 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 183 | /* Shift the read command bits out. */ |
| 184 | for (i = 4 + addr_len; i >= 0; i--) { |
| 185 | short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 186 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 187 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS | dataval, |
| 188 | ioaddr); |
| 189 | udelay(10); |
| 190 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS | dataval | DT_CLK, |
| 191 | ioaddr); |
| 192 | udelay(10); |
| 193 | #ifdef DEBUG_SROM2 |
| 194 | printf("%X", getfrom_srom(dev, ioaddr) & 15); |
| 195 | #endif |
| 196 | retval = (retval << 1) | |
| 197 | !!(getfrom_srom(dev, ioaddr) & EE_DATA_READ); |
| 198 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 199 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 200 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 201 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 202 | #ifdef DEBUG_SROM2 |
| 203 | printf(" :%X:", getfrom_srom(dev, ioaddr) & 15); |
| 204 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 205 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 206 | for (i = 16; i > 0; i--) { |
| 207 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS | DT_CLK, ioaddr); |
| 208 | udelay(10); |
| 209 | #ifdef DEBUG_SROM2 |
| 210 | printf("%X", getfrom_srom(dev, ioaddr) & 15); |
| 211 | #endif |
| 212 | retval = (retval << 1) | |
| 213 | !!(getfrom_srom(dev, ioaddr) & EE_DATA_READ); |
| 214 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS, ioaddr); |
| 215 | udelay(10); |
| 216 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 217 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 218 | /* Terminate the EEPROM access. */ |
| 219 | sendto_srom(dev, SROM_RD | SROM_SR, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 220 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 221 | #ifdef DEBUG_SROM2 |
| 222 | printf(" EEPROM value at %d is %5.5x.\n", location, retval); |
| 223 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 224 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 225 | return retval; |
| 226 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 227 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 228 | /* |
| 229 | * This executes a generic EEPROM command, typically a write or write |
| 230 | * enable. It returns the data output from the EEPROM, and thus may |
| 231 | * also be used for reads. |
| 232 | */ |
| 233 | static int do_eeprom_cmd(struct eth_device *dev, u_long ioaddr, int cmd, |
| 234 | int cmd_len) |
| 235 | { |
| 236 | unsigned int retval = 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 237 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 238 | #ifdef DEBUG_SROM |
| 239 | printf(" EEPROM op 0x%x: ", cmd); |
| 240 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 241 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 242 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS | DT_CLK, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 243 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 244 | /* Shift the command bits out. */ |
| 245 | do { |
| 246 | short dataval = (cmd & BIT(cmd_len)) ? EE_WRITE_1 : EE_WRITE_0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 247 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 248 | sendto_srom(dev, dataval, ioaddr); |
| 249 | udelay(10); |
Marek Vasut | 268cc5b | 2020-04-19 03:09:47 +0200 | [diff] [blame] | 250 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 251 | #ifdef DEBUG_SROM2 |
| 252 | printf("%X", getfrom_srom(dev, ioaddr) & 15); |
| 253 | #endif |
Nobuhiro Iwamatsu | d45fa74 | 2010-10-19 14:03:40 +0900 | [diff] [blame] | 254 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 255 | sendto_srom(dev, dataval | DT_CLK, ioaddr); |
| 256 | udelay(10); |
| 257 | retval = (retval << 1) | |
| 258 | !!(getfrom_srom(dev, ioaddr) & EE_DATA_READ); |
| 259 | } while (--cmd_len >= 0); |
wdenk | 0260cd6 | 2004-01-02 15:01:32 +0000 | [diff] [blame] | 260 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 261 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 262 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 263 | /* Terminate the EEPROM access. */ |
| 264 | sendto_srom(dev, SROM_RD | SROM_SR, ioaddr); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 265 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 266 | #ifdef DEBUG_SROM |
| 267 | printf(" EEPROM result is 0x%5.5x.\n", retval); |
| 268 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 269 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 270 | return retval; |
| 271 | } |
Marek Vasut | 331e4ec | 2020-04-18 01:56:51 +0200 | [diff] [blame] | 272 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 273 | static int read_srom(struct eth_device *dev, u_long ioaddr, int index) |
| 274 | { |
| 275 | int ee_addr_size; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 276 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 277 | ee_addr_size = (do_read_eeprom(dev, ioaddr, 0xff, 8) & BIT(18)) ? 8 : 6; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 278 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 279 | return do_eeprom_cmd(dev, ioaddr, 0xffff | |
| 280 | (((SROM_READ_CMD << ee_addr_size) | index) << 16), |
| 281 | 3 + ee_addr_size + 16); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 282 | } |
| 283 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 284 | #ifdef UPDATE_SROM |
| 285 | static int write_srom(struct eth_device *dev, u_long ioaddr, int index, |
| 286 | int new_value) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 287 | { |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 288 | unsigned short newval; |
| 289 | int ee_addr_size; |
Marek Vasut | 268cc5b | 2020-04-19 03:09:47 +0200 | [diff] [blame] | 290 | int i; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 291 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 292 | ee_addr_size = (do_read_eeprom(dev, ioaddr, 0xff, 8) & BIT(18)) ? 8 : 6; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 293 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 294 | udelay(10 * 1000); /* test-only */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 295 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 296 | #ifdef DEBUG_SROM |
| 297 | printf("ee_addr_size=%d.\n", ee_addr_size); |
| 298 | printf("Writing new entry 0x%4.4x to offset %d.\n", new_value, index); |
| 299 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 300 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 301 | /* Enable programming modes. */ |
| 302 | do_eeprom_cmd(dev, ioaddr, 0x4f << (ee_addr_size - 4), |
| 303 | 3 + ee_addr_size); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 304 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 305 | /* Do the actual write. */ |
| 306 | do_eeprom_cmd(dev, ioaddr, new_value | |
| 307 | (((SROM_WRITE_CMD << ee_addr_size) | index) << 16), |
| 308 | 3 + ee_addr_size + 16); |
| 309 | |
| 310 | /* Poll for write finished. */ |
| 311 | sendto_srom(dev, SROM_RD | SROM_SR | DT_CS, ioaddr); |
| 312 | for (i = 0; i < 10000; i++) { /* Typical 2000 ticks */ |
| 313 | if (getfrom_srom(dev, ioaddr) & EE_DATA_READ) |
| 314 | break; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 315 | } |
| 316 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 317 | #ifdef DEBUG_SROM |
| 318 | printf(" Write finished after %d ticks.\n", i); |
| 319 | #endif |
| 320 | |
| 321 | /* Disable programming. */ |
| 322 | do_eeprom_cmd(dev, ioaddr, (0x40 << (ee_addr_size - 4)), |
| 323 | 3 + ee_addr_size); |
| 324 | |
| 325 | /* And read the result. */ |
| 326 | newval = do_eeprom_cmd(dev, ioaddr, |
| 327 | (((SROM_READ_CMD << ee_addr_size) | index) << 16) |
| 328 | | 0xffff, 3 + ee_addr_size + 16); |
| 329 | #ifdef DEBUG_SROM |
| 330 | printf(" New value at offset %d is %4.4x.\n", index, newval); |
| 331 | #endif |
| 332 | |
| 333 | return 1; |
| 334 | } |
| 335 | |
| 336 | static void update_srom(struct eth_device *dev, bd_t *bis) |
| 337 | { |
| 338 | static unsigned short eeprom[0x40] = { |
| 339 | 0x140b, 0x6610, 0x0000, 0x0000, /* 00 */ |
| 340 | 0x0000, 0x0000, 0x0000, 0x0000, /* 04 */ |
| 341 | 0x00a3, 0x0103, 0x0000, 0x0000, /* 08 */ |
| 342 | 0x0000, 0x1f00, 0x0000, 0x0000, /* 0c */ |
| 343 | 0x0108, 0x038d, 0x0000, 0x0000, /* 10 */ |
| 344 | 0xe078, 0x0001, 0x0040, 0x0018, /* 14 */ |
| 345 | 0x0000, 0x0000, 0x0000, 0x0000, /* 18 */ |
| 346 | 0x0000, 0x0000, 0x0000, 0x0000, /* 1c */ |
| 347 | 0x0000, 0x0000, 0x0000, 0x0000, /* 20 */ |
| 348 | 0x0000, 0x0000, 0x0000, 0x0000, /* 24 */ |
| 349 | 0x0000, 0x0000, 0x0000, 0x0000, /* 28 */ |
| 350 | 0x0000, 0x0000, 0x0000, 0x0000, /* 2c */ |
| 351 | 0x0000, 0x0000, 0x0000, 0x0000, /* 30 */ |
| 352 | 0x0000, 0x0000, 0x0000, 0x0000, /* 34 */ |
| 353 | 0x0000, 0x0000, 0x0000, 0x0000, /* 38 */ |
| 354 | 0x0000, 0x0000, 0x0000, 0x4e07, /* 3c */ |
| 355 | }; |
| 356 | uchar enetaddr[6]; |
| 357 | int i; |
| 358 | |
| 359 | /* Ethernet Addr... */ |
| 360 | if (!eth_env_get_enetaddr("ethaddr", enetaddr)) |
| 361 | return; |
| 362 | |
| 363 | eeprom[0x0a] = (enetaddr[1] << 8) | enetaddr[0]; |
| 364 | eeprom[0x0b] = (enetaddr[3] << 8) | enetaddr[2]; |
| 365 | eeprom[0x0c] = (enetaddr[5] << 8) | enetaddr[4]; |
| 366 | |
| 367 | for (i = 0; i < 0x40; i++) |
| 368 | write_srom(dev, DE4X5_APROM, i, eeprom[i]); |
| 369 | } |
| 370 | #endif /* UPDATE_SROM */ |
| 371 | |
| 372 | static void send_setup_frame(struct eth_device *dev, bd_t *bis) |
| 373 | { |
| 374 | char setup_frame[SETUP_FRAME_LEN]; |
| 375 | char *pa = &setup_frame[0]; |
| 376 | int i; |
| 377 | |
| 378 | memset(pa, 0xff, SETUP_FRAME_LEN); |
| 379 | |
| 380 | for (i = 0; i < ETH_ALEN; i++) { |
| 381 | *(pa + (i & 1)) = dev->enetaddr[i]; |
| 382 | if (i & 0x01) |
| 383 | pa += 4; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 384 | } |
| 385 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 386 | for (i = 0; tx_ring[tx_new].status & cpu_to_le32(T_OWN); i++) { |
| 387 | if (i < TOUT_LOOP) |
| 388 | continue; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 389 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 390 | printf("%s: tx error buffer not ready\n", dev->name); |
| 391 | return; |
| 392 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 393 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 394 | tx_ring[tx_new].buf = cpu_to_le32(phys_to_bus((u32)&setup_frame[0])); |
| 395 | tx_ring[tx_new].des1 = cpu_to_le32(TD_TER | TD_SET | SETUP_FRAME_LEN); |
| 396 | tx_ring[tx_new].status = cpu_to_le32(T_OWN); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 397 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 398 | dc2114x_outl(dev, POLL_DEMAND, DE4X5_TPD); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 399 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 400 | for (i = 0; tx_ring[tx_new].status & cpu_to_le32(T_OWN); i++) { |
| 401 | if (i < TOUT_LOOP) |
| 402 | continue; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 403 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 404 | printf("%s: tx buffer not ready\n", dev->name); |
| 405 | return; |
| 406 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 407 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 408 | if (le32_to_cpu(tx_ring[tx_new].status) != 0x7FFFFFFF) { |
| 409 | printf("TX error status2 = 0x%08X\n", |
| 410 | le32_to_cpu(tx_ring[tx_new].status)); |
| 411 | } |
| 412 | |
| 413 | tx_new = (tx_new + 1) % NUM_TX_DESC; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 414 | } |
| 415 | |
Joe Hershberger | cfb0cee | 2012-05-21 14:45:22 +0000 | [diff] [blame] | 416 | static int dc21x4x_send(struct eth_device *dev, void *packet, int length) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 417 | { |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 418 | int status = -1; |
| 419 | int i; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 420 | |
| 421 | if (length <= 0) { |
| 422 | printf("%s: bad packet size: %d\n", dev->name, length); |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 423 | goto done; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 424 | } |
| 425 | |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 426 | for (i = 0; tx_ring[tx_new].status & cpu_to_le32(T_OWN); i++) { |
| 427 | if (i < TOUT_LOOP) |
| 428 | continue; |
| 429 | |
| 430 | printf("%s: tx error buffer not ready\n", dev->name); |
| 431 | goto done; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 432 | } |
| 433 | |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 434 | tx_ring[tx_new].buf = cpu_to_le32(phys_to_bus((u32)packet)); |
| 435 | tx_ring[tx_new].des1 = cpu_to_le32(TD_TER | TD_LS | TD_FS | length); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 436 | tx_ring[tx_new].status = cpu_to_le32(T_OWN); |
| 437 | |
Marek Vasut | f02b701 | 2020-04-19 03:40:03 +0200 | [diff] [blame] | 438 | dc2114x_outl(dev, POLL_DEMAND, DE4X5_TPD); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 439 | |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 440 | for (i = 0; tx_ring[tx_new].status & cpu_to_le32(T_OWN); i++) { |
| 441 | if (i < TOUT_LOOP) |
| 442 | continue; |
| 443 | |
| 444 | printf(".%s: tx buffer not ready\n", dev->name); |
| 445 | goto done; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 446 | } |
| 447 | |
| 448 | if (le32_to_cpu(tx_ring[tx_new].status) & TD_ES) { |
wdenk | 0260cd6 | 2004-01-02 15:01:32 +0000 | [diff] [blame] | 449 | tx_ring[tx_new].status = 0x0; |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 450 | goto done; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 451 | } |
| 452 | |
| 453 | status = length; |
| 454 | |
Marek Vasut | e3ffef3 | 2020-04-19 03:10:14 +0200 | [diff] [blame] | 455 | done: |
| 456 | tx_new = (tx_new + 1) % NUM_TX_DESC; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 457 | return status; |
| 458 | } |
| 459 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 460 | static int dc21x4x_recv(struct eth_device *dev) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 461 | { |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 462 | int length = 0; |
| 463 | u32 status; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 464 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 465 | while (true) { |
| 466 | status = le32_to_cpu(rx_ring[rx_new].status); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 467 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 468 | if (status & R_OWN) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 469 | break; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 470 | |
| 471 | if (status & RD_LS) { |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 472 | /* Valid frame status. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 473 | if (status & RD_ES) { |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 474 | /* There was an error. */ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 475 | printf("RX error status = 0x%08X\n", status); |
| 476 | } else { |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 477 | /* A valid frame received. */ |
| 478 | length = (le32_to_cpu(rx_ring[rx_new].status) |
| 479 | >> 16); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 480 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 481 | /* Pass the packet up to the protocol layers */ |
| 482 | net_process_received_packet |
| 483 | (net_rx_packets[rx_new], length - 4); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 484 | } |
| 485 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 486 | /* |
| 487 | * Change buffer ownership for this frame, |
| 488 | * back to the adapter. |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 489 | */ |
| 490 | rx_ring[rx_new].status = cpu_to_le32(R_OWN); |
| 491 | } |
| 492 | |
Marek Vasut | f30abb7 | 2020-04-19 03:10:25 +0200 | [diff] [blame] | 493 | /* Update entry information. */ |
Marek Vasut | 81d10f7 | 2020-04-19 03:09:26 +0200 | [diff] [blame] | 494 | rx_new = (rx_new + 1) % rx_ring_size; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | return length; |
| 498 | } |
| 499 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 500 | static int dc21x4x_init(struct eth_device *dev, bd_t *bis) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 501 | { |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 502 | int i; |
Marek Vasut | 1f34678 | 2020-04-19 03:10:30 +0200 | [diff] [blame] | 503 | int devbusfn = (int)dev->priv; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 504 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 505 | /* Ensure we're not sleeping. */ |
| 506 | pci_write_config_byte(devbusfn, PCI_CFDA_PSM, WAKEUP); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 507 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 508 | reset_de4x5(dev); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 509 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 510 | if (dc2114x_inl(dev, DE4X5_STS) & (STS_TS | STS_RS)) { |
| 511 | printf("Error: Cannot reset ethernet controller.\n"); |
| 512 | return -1; |
| 513 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 514 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 515 | dc2114x_outl(dev, OMR_SDP | OMR_PS | OMR_PM, DE4X5_OMR); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 516 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 517 | for (i = 0; i < NUM_RX_DESC; i++) { |
| 518 | rx_ring[i].status = cpu_to_le32(R_OWN); |
| 519 | rx_ring[i].des1 = cpu_to_le32(RX_BUFF_SZ); |
| 520 | rx_ring[i].buf = |
| 521 | cpu_to_le32(phys_to_bus((u32)net_rx_packets[i])); |
| 522 | rx_ring[i].next = 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 523 | } |
| 524 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 525 | for (i = 0; i < NUM_TX_DESC; i++) { |
| 526 | tx_ring[i].status = 0; |
| 527 | tx_ring[i].des1 = 0; |
| 528 | tx_ring[i].buf = 0; |
| 529 | tx_ring[i].next = 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 530 | } |
| 531 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 532 | rx_ring_size = NUM_RX_DESC; |
| 533 | tx_ring_size = NUM_TX_DESC; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 534 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 535 | /* Write the end of list marker to the descriptor lists. */ |
| 536 | rx_ring[rx_ring_size - 1].des1 |= cpu_to_le32(RD_RER); |
| 537 | tx_ring[tx_ring_size - 1].des1 |= cpu_to_le32(TD_TER); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 538 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 539 | /* Tell the adapter where the TX/RX rings are located. */ |
| 540 | dc2114x_outl(dev, phys_to_bus((u32)&rx_ring), DE4X5_RRBA); |
| 541 | dc2114x_outl(dev, phys_to_bus((u32)&tx_ring), DE4X5_TRBA); |
Marek Vasut | e13635a | 2020-04-19 03:10:50 +0200 | [diff] [blame] | 542 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 543 | start_de4x5(dev); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 544 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 545 | tx_new = 0; |
| 546 | rx_new = 0; |
wdenk | 0260cd6 | 2004-01-02 15:01:32 +0000 | [diff] [blame] | 547 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 548 | send_setup_frame(dev, bis); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 549 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 550 | return 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 551 | } |
| 552 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 553 | static void dc21x4x_halt(struct eth_device *dev) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 554 | { |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 555 | int devbusfn = (int)dev->priv; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 556 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 557 | stop_de4x5(dev); |
| 558 | dc2114x_outl(dev, 0, DE4X5_SICR); |
| 559 | |
| 560 | pci_write_config_byte(devbusfn, PCI_CFDA_PSM, SLEEP); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 561 | } |
| 562 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 563 | static void read_hw_addr(struct eth_device *dev, bd_t *bis) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 564 | { |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 565 | u_short tmp, *p = (u_short *)(&dev->enetaddr[0]); |
| 566 | int i, j = 0; |
Marek Vasut | b46c7a0 | 2020-04-19 03:11:06 +0200 | [diff] [blame] | 567 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 568 | for (i = 0; i < (ETH_ALEN >> 1); i++) { |
| 569 | tmp = read_srom(dev, DE4X5_APROM, (SROM_HWADD >> 1) + i); |
| 570 | *p = le16_to_cpu(tmp); |
| 571 | j += *p++; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 572 | } |
| 573 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 574 | if (!j || j == 0x2fffd) { |
| 575 | memset(dev->enetaddr, 0, ETH_ALEN); |
| 576 | debug("Warning: can't read HW address from SROM.\n"); |
| 577 | #ifdef UPDATE_SROM |
| 578 | update_srom(dev, bis); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 579 | #endif |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 580 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 581 | } |
| 582 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 583 | static struct pci_device_id supported[] = { |
| 584 | { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_FAST }, |
| 585 | { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21142 }, |
| 586 | { } |
| 587 | }; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 588 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 589 | int dc21x4x_initialize(bd_t *bis) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 590 | { |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 591 | struct eth_device *dev; |
| 592 | unsigned short status; |
| 593 | unsigned char timer; |
| 594 | unsigned int iobase; |
| 595 | int card_number = 0; |
| 596 | pci_dev_t devbusfn; |
| 597 | unsigned int cfrv; |
| 598 | int idx = 0; |
Marek Vasut | b46c7a0 | 2020-04-19 03:11:06 +0200 | [diff] [blame] | 599 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 600 | while (1) { |
| 601 | devbusfn = pci_find_devices(supported, idx++); |
| 602 | if (devbusfn == -1) |
| 603 | break; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 604 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 605 | /* Get the chip configuration revision register. */ |
| 606 | pci_read_config_dword(devbusfn, PCI_REVISION_ID, &cfrv); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 607 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 608 | if ((cfrv & CFRV_RN) < DC2114x_BRK) { |
| 609 | printf("Error: The chip is not DC21143.\n"); |
| 610 | continue; |
| 611 | } |
Marek Vasut | b46c7a0 | 2020-04-19 03:11:06 +0200 | [diff] [blame] | 612 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 613 | pci_read_config_word(devbusfn, PCI_COMMAND, &status); |
| 614 | status |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; |
| 615 | pci_write_config_word(devbusfn, PCI_COMMAND, status); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 616 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 617 | pci_read_config_word(devbusfn, PCI_COMMAND, &status); |
| 618 | if (!(status & PCI_COMMAND_MEMORY)) { |
| 619 | printf("Error: Can not enable MEMORY access.\n"); |
| 620 | continue; |
| 621 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 622 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 623 | if (!(status & PCI_COMMAND_MASTER)) { |
| 624 | printf("Error: Can not enable Bus Mastering.\n"); |
| 625 | continue; |
| 626 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 627 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 628 | /* Check the latency timer for values >= 0x60. */ |
| 629 | pci_read_config_byte(devbusfn, PCI_LATENCY_TIMER, &timer); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 630 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 631 | if (timer < 0x60) { |
| 632 | pci_write_config_byte(devbusfn, PCI_LATENCY_TIMER, |
| 633 | 0x60); |
| 634 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 635 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 636 | /* read BAR for memory space access */ |
| 637 | pci_read_config_dword(devbusfn, PCI_BASE_ADDRESS_1, &iobase); |
| 638 | iobase &= PCI_BASE_ADDRESS_MEM_MASK; |
| 639 | debug("dc21x4x: DEC 21142 PCI Device @0x%x\n", iobase); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 640 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 641 | dev = (struct eth_device *)malloc(sizeof(*dev)); |
| 642 | if (!dev) { |
| 643 | printf("Can not allocalte memory of dc21x4x\n"); |
| 644 | break; |
| 645 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 646 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 647 | memset(dev, 0, sizeof(*dev)); |
Marek Vasut | b46c7a0 | 2020-04-19 03:11:06 +0200 | [diff] [blame] | 648 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 649 | sprintf(dev->name, "dc21x4x#%d", card_number); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 650 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 651 | dev->iobase = pci_mem_to_phys(devbusfn, iobase); |
| 652 | dev->priv = (void *)devbusfn; |
| 653 | dev->init = dc21x4x_init; |
| 654 | dev->halt = dc21x4x_halt; |
| 655 | dev->send = dc21x4x_send; |
| 656 | dev->recv = dc21x4x_recv; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 657 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 658 | /* Ensure we're not sleeping. */ |
| 659 | pci_write_config_byte(devbusfn, PCI_CFDA_PSM, WAKEUP); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 660 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 661 | udelay(10 * 1000); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 662 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 663 | read_hw_addr(dev, bis); |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 664 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 665 | eth_register(dev); |
Marek Vasut | b46c7a0 | 2020-04-19 03:11:06 +0200 | [diff] [blame] | 666 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 667 | card_number++; |
| 668 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 669 | |
Marek Vasut | 5e2ad05 | 2020-04-19 04:00:49 +0200 | [diff] [blame^] | 670 | return card_number; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 671 | } |