1
2
3
4
5
6
7#include <common.h>
8#include <asm/io.h>
9#include <cpu_func.h>
10#include <malloc.h>
11#include <miiphy.h>
12#include <net.h>
13#include <netdev.h>
14#include <pci.h>
15#include <linux/delay.h>
16
17
18#define SCB_STATUS 0
19#define SCB_INT_ACK_BYTE 1
20#define SCB_CMD 2
21#define SCB_INTR_CTL_BYTE 3
22#define SCB_POINTER 4
23#define SCB_PORT 8
24#define SCB_FLASH 12
25#define SCB_EEPROM 14
26#define SCB_CTRL_MDI 16
27#define SCB_EARLY_RX 20
28#define SCB_GEN_CONTROL 28
29#define SCB_GEN_STATUS 29
30
31
32#define SCB_STATUS_CX 0x8000
33#define SCB_STATUS_FR 0x4000
34#define SCB_STATUS_CNA 0x2000
35#define SCB_STATUS_RNR 0x1000
36#define SCB_STATUS_MDI 0x0800
37#define SCB_STATUS_SWI 0x0400
38#define SCB_STATUS_FCP 0x0100
39
40#define SCB_INTACK_MASK 0xFD00
41
42#define SCB_INTACK_TX (SCB_STATUS_CX | SCB_STATUS_CNA)
43#define SCB_INTACK_RX (SCB_STATUS_FR | SCB_STATUS_RNR)
44
45
46
47#define CU_NOP 0x0000
48#define CU_START 0x0010
49#define CU_RESUME 0x0020
50#define CU_STATSADDR 0x0040
51#define CU_SHOWSTATS 0x0050
52#define CU_ADDR_LOAD 0x0060
53#define CU_DUMPSTATS 0x0070
54
55
56#define RUC_NOP 0x0000
57#define RUC_START 0x0001
58#define RUC_RESUME 0x0002
59#define RUC_ABORT 0x0004
60#define RUC_ADDR_LOAD 0x0006
61#define RUC_RESUMENR 0x0007
62
63#define CU_CMD_MASK 0x00f0
64#define RU_CMD_MASK 0x0007
65
66#define SCB_M 0x0100
67#define SCB_SWI 0x0200
68
69#define CU_STATUS_MASK 0x00C0
70#define RU_STATUS_MASK 0x003C
71
72#define RU_STATUS_IDLE (0 << 2)
73#define RU_STATUS_SUS (1 << 2)
74#define RU_STATUS_NORES (2 << 2)
75#define RU_STATUS_READY (4 << 2)
76#define RU_STATUS_NO_RBDS_SUS ((1 << 2) | (8 << 2))
77#define RU_STATUS_NO_RBDS_NORES ((2 << 2) | (8 << 2))
78#define RU_STATUS_NO_RBDS_READY ((4 << 2) | (8 << 2))
79
80
81#define I82559_RESET 0x00000000
82#define I82559_SELFTEST 0x00000001
83#define I82559_SELECTIVE_RESET 0x00000002
84#define I82559_DUMP 0x00000003
85#define I82559_DUMP_WAKEUP 0x00000007
86
87
88#define EE_SHIFT_CLK 0x01
89#define EE_CS 0x02
90#define EE_DATA_WRITE 0x04
91#define EE_WRITE_0 0x01
92#define EE_WRITE_1 0x05
93#define EE_DATA_READ 0x08
94#define EE_ENB (0x4800 | EE_CS)
95#define EE_CMD_BITS 3
96#define EE_DATA_BITS 16
97
98
99#define EE_EWENB_CMD(addr_len) (4 << (addr_len))
100#define EE_WRITE_CMD(addr_len) (5 << (addr_len))
101#define EE_READ_CMD(addr_len) (6 << (addr_len))
102#define EE_ERASE_CMD(addr_len) (7 << (addr_len))
103
104
105struct eepro100_rxfd {
106 u16 status;
107 u16 control;
108 u32 link;
109 u32 rx_buf_addr;
110 u32 count;
111
112 u8 data[PKTSIZE_ALIGN];
113};
114
115#define RFD_STATUS_C 0x8000
116#define RFD_STATUS_OK 0x2000
117
118#define RFD_CONTROL_EL 0x8000
119#define RFD_CONTROL_S 0x4000
120#define RFD_CONTROL_H 0x0010
121#define RFD_CONTROL_SF 0x0008
122
123#define RFD_COUNT_MASK 0x3fff
124#define RFD_COUNT_F 0x4000
125#define RFD_COUNT_EOF 0x8000
126
127#define RFD_RX_CRC 0x0800
128#define RFD_RX_ALIGNMENT 0x0400
129#define RFD_RX_RESOURCE 0x0200
130#define RFD_RX_DMA_OVER 0x0100
131#define RFD_RX_SHORT 0x0080
132#define RFD_RX_LENGTH 0x0020
133#define RFD_RX_ERROR 0x0010
134#define RFD_RX_NO_ADR_MATCH 0x0004
135#define RFD_RX_IA_MATCH 0x0002
136#define RFD_RX_TCO 0x0001
137
138
139struct eepro100_txfd {
140 u16 status;
141 u16 command;
142 u32 link;
143 u32 tx_desc_addr;
144 s32 count;
145
146 u32 tx_buf_addr0;
147 s32 tx_buf_size0;
148 u32 tx_buf_addr1;
149 s32 tx_buf_size1;
150};
151
152#define TXCB_CMD_TRANSMIT 0x0004
153#define TXCB_CMD_SF 0x0008
154#define TXCB_CMD_NC 0x0010
155#define TXCB_CMD_I 0x2000
156#define TXCB_CMD_S 0x4000
157#define TXCB_CMD_EL 0x8000
158
159#define TXCB_COUNT_MASK 0x3fff
160#define TXCB_COUNT_EOF 0x8000
161
162
163struct descriptor {
164 u16 status;
165 u16 command;
166 u32 link;
167
168 unsigned char params[0];
169};
170
171#define CONFIG_SYS_CMD_EL 0x8000
172#define CONFIG_SYS_CMD_SUSPEND 0x4000
173#define CONFIG_SYS_CMD_INT 0x2000
174#define CONFIG_SYS_CMD_IAS 0x0001
175#define CONFIG_SYS_CMD_CONFIGURE 0x0002
176
177#define CONFIG_SYS_STATUS_C 0x8000
178#define CONFIG_SYS_STATUS_OK 0x2000
179
180
181#define NUM_RX_DESC PKTBUFSRX
182#define NUM_TX_DESC 1
183
184#define TOUT_LOOP 1000000
185
186
187
188
189
190
191static const char i82558_config_cmd[] = {
192 22, 0x08, 0, 1, 0, 0, 0x22, 0x03, 1,
193 0, 0x2E, 0, 0x60, 0x08, 0x88,
194 0x68, 0, 0x40, 0xf2, 0x84,
195 0x31, 0x05,
196};
197
198struct eepro100_priv {
199
200 struct eepro100_rxfd rx_ring[NUM_RX_DESC];
201
202 struct eepro100_txfd tx_ring[NUM_TX_DESC];
203
204 int rx_next;
205 u16 rx_stat;
206
207 int tx_next;
208 int tx_threshold;
209#ifdef CONFIG_DM_ETH
210 struct udevice *devno;
211#else
212 struct eth_device dev;
213 pci_dev_t devno;
214#endif
215 char *name;
216 void __iomem *iobase;
217 u8 *enetaddr;
218};
219
220#if defined(CONFIG_DM_ETH)
221#define bus_to_phys(dev, a) dm_pci_mem_to_phys((dev), (a))
222#define phys_to_bus(dev, a) dm_pci_phys_to_mem((dev), (a))
223#elif defined(CONFIG_E500)
224#define bus_to_phys(dev, a) (a)
225#define phys_to_bus(dev, a) (a)
226#else
227#define bus_to_phys(dev, a) pci_mem_to_phys((dev), (a))
228#define phys_to_bus(dev, a) pci_phys_to_mem((dev), (a))
229#endif
230
231static int INW(struct eepro100_priv *priv, u_long addr)
232{
233 return le16_to_cpu(readw(addr + priv->iobase));
234}
235
236static void OUTW(struct eepro100_priv *priv, int command, u_long addr)
237{
238 writew(cpu_to_le16(command), addr + priv->iobase);
239}
240
241static void OUTL(struct eepro100_priv *priv, int command, u_long addr)
242{
243 writel(cpu_to_le32(command), addr + priv->iobase);
244}
245
246#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
247static int INL(struct eepro100_priv *priv, u_long addr)
248{
249 return le32_to_cpu(readl(addr + priv->iobase));
250}
251
252static int get_phyreg(struct eepro100_priv *priv, unsigned char addr,
253 unsigned char reg, unsigned short *value)
254{
255 int timeout = 50;
256 int cmd;
257
258
259 cmd = (2 << 26) | ((addr & 0x1f) << 21) | ((reg & 0x1f) << 16);
260 OUTL(priv, cmd, SCB_CTRL_MDI);
261
262 do {
263 udelay(1000);
264 cmd = INL(priv, SCB_CTRL_MDI);
265 } while (!(cmd & (1 << 28)) && (--timeout));
266
267 if (timeout == 0)
268 return -1;
269
270 *value = (unsigned short)(cmd & 0xffff);
271
272 return 0;
273}
274
275static int set_phyreg(struct eepro100_priv *priv, unsigned char addr,
276 unsigned char reg, unsigned short value)
277{
278 int timeout = 50;
279 int cmd;
280
281
282 cmd = (1 << 26) | ((addr & 0x1f) << 21) | ((reg & 0x1f) << 16);
283 OUTL(priv, cmd | value, SCB_CTRL_MDI);
284
285 while (!(INL(priv, SCB_CTRL_MDI) & (1 << 28)) && (--timeout))
286 udelay(1000);
287
288 if (timeout == 0)
289 return -1;
290
291 return 0;
292}
293
294
295
296
297
298static int verify_phyaddr(struct eepro100_priv *priv, unsigned char addr)
299{
300 unsigned short value, model;
301 int ret;
302
303
304 ret = get_phyreg(priv, addr, MII_PHYSID2, &value);
305 if (ret) {
306 printf("%s: mii read timeout!\n", priv->name);
307 return ret;
308 }
309
310
311 model = (value >> 4) & 0x003f;
312 if (!model) {
313 printf("%s: no PHY at address %d\n", priv->name, addr);
314 return -EINVAL;
315 }
316
317 return 0;
318}
319
320static int eepro100_miiphy_read(struct mii_dev *bus, int addr, int devad,
321 int reg)
322{
323 struct eepro100_priv *priv = bus->priv;
324 unsigned short value = 0;
325 int ret;
326
327 ret = verify_phyaddr(priv, addr);
328 if (ret)
329 return ret;
330
331 ret = get_phyreg(priv, addr, reg, &value);
332 if (ret) {
333 printf("%s: mii read timeout!\n", bus->name);
334 return ret;
335 }
336
337 return value;
338}
339
340static int eepro100_miiphy_write(struct mii_dev *bus, int addr, int devad,
341 int reg, u16 value)
342{
343 struct eepro100_priv *priv = bus->priv;
344 int ret;
345
346 ret = verify_phyaddr(priv, addr);
347 if (ret)
348 return ret;
349
350 ret = set_phyreg(priv, addr, reg, value);
351 if (ret) {
352 printf("%s: mii write timeout!\n", bus->name);
353 return ret;
354 }
355
356 return 0;
357}
358#endif
359
360static void init_rx_ring(struct eepro100_priv *priv)
361{
362 struct eepro100_rxfd *rx_ring = priv->rx_ring;
363 int i;
364
365 for (i = 0; i < NUM_RX_DESC; i++) {
366 rx_ring[i].status = 0;
367 rx_ring[i].control = (i == NUM_RX_DESC - 1) ?
368 cpu_to_le16 (RFD_CONTROL_S) : 0;
369 rx_ring[i].link =
370 cpu_to_le32(phys_to_bus(priv->devno,
371 (u32)&rx_ring[(i + 1) %
372 NUM_RX_DESC]));
373 rx_ring[i].rx_buf_addr = 0xffffffff;
374 rx_ring[i].count = cpu_to_le32(PKTSIZE_ALIGN << 16);
375 }
376
377 flush_dcache_range((unsigned long)rx_ring,
378 (unsigned long)rx_ring +
379 (sizeof(*rx_ring) * NUM_RX_DESC));
380
381 priv->rx_next = 0;
382}
383
384static void purge_tx_ring(struct eepro100_priv *priv)
385{
386 struct eepro100_txfd *tx_ring = priv->tx_ring;
387
388 priv->tx_next = 0;
389 priv->tx_threshold = 0x01208000;
390 memset(tx_ring, 0, sizeof(*tx_ring) * NUM_TX_DESC);
391
392 flush_dcache_range((unsigned long)tx_ring,
393 (unsigned long)tx_ring +
394 (sizeof(*tx_ring) * NUM_TX_DESC));
395}
396
397
398static int wait_for_eepro100(struct eepro100_priv *priv)
399{
400 int i;
401
402 for (i = 0; INW(priv, SCB_CMD) & (CU_CMD_MASK | RU_CMD_MASK); i++) {
403 if (i >= TOUT_LOOP)
404 return 0;
405 }
406
407 return 1;
408}
409
410static int eepro100_txcmd_send(struct eepro100_priv *priv,
411 struct eepro100_txfd *desc)
412{
413 u16 rstat;
414 int i = 0;
415
416 flush_dcache_range((unsigned long)desc,
417 (unsigned long)desc + sizeof(*desc));
418
419 if (!wait_for_eepro100(priv))
420 return -ETIMEDOUT;
421
422 OUTL(priv, phys_to_bus(priv->devno, (u32)desc), SCB_POINTER);
423 OUTW(priv, SCB_M | CU_START, SCB_CMD);
424
425 while (true) {
426 invalidate_dcache_range((unsigned long)desc,
427 (unsigned long)desc + sizeof(*desc));
428 rstat = le16_to_cpu(desc->status);
429 if (rstat & CONFIG_SYS_STATUS_C)
430 break;
431
432 if (i++ >= TOUT_LOOP) {
433 printf("%s: Tx error buffer not ready\n", priv->name);
434 return -EINVAL;
435 }
436 }
437
438 invalidate_dcache_range((unsigned long)desc,
439 (unsigned long)desc + sizeof(*desc));
440 rstat = le16_to_cpu(desc->status);
441
442 if (!(rstat & CONFIG_SYS_STATUS_OK)) {
443 printf("TX error status = 0x%08X\n", rstat);
444 return -EIO;
445 }
446
447 return 0;
448}
449
450
451static int read_eeprom(struct eepro100_priv *priv, int location, int addr_len)
452{
453 unsigned short retval = 0;
454 int read_cmd = location | EE_READ_CMD(addr_len);
455 int i;
456
457 OUTW(priv, EE_ENB & ~EE_CS, SCB_EEPROM);
458 OUTW(priv, EE_ENB, SCB_EEPROM);
459
460
461 for (i = 12; i >= 0; i--) {
462 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
463
464 OUTW(priv, EE_ENB | dataval, SCB_EEPROM);
465 udelay(1);
466 OUTW(priv, EE_ENB | dataval | EE_SHIFT_CLK, SCB_EEPROM);
467 udelay(1);
468 }
469 OUTW(priv, EE_ENB, SCB_EEPROM);
470
471 for (i = 15; i >= 0; i--) {
472 OUTW(priv, EE_ENB | EE_SHIFT_CLK, SCB_EEPROM);
473 udelay(1);
474 retval = (retval << 1) |
475 !!(INW(priv, SCB_EEPROM) & EE_DATA_READ);
476 OUTW(priv, EE_ENB, SCB_EEPROM);
477 udelay(1);
478 }
479
480
481 OUTW(priv, EE_ENB & ~EE_CS, SCB_EEPROM);
482 return retval;
483}
484
485#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
486static int eepro100_initialize_mii(struct eepro100_priv *priv)
487{
488
489 struct mii_dev *mdiodev;
490 int ret;
491
492 mdiodev = mdio_alloc();
493 if (!mdiodev)
494 return -ENOMEM;
495
496 strlcpy(mdiodev->name, priv->name, MDIO_NAME_LEN);
497 mdiodev->read = eepro100_miiphy_read;
498 mdiodev->write = eepro100_miiphy_write;
499 mdiodev->priv = priv;
500
501 ret = mdio_register(mdiodev);
502 if (ret < 0) {
503 mdio_free(mdiodev);
504 return ret;
505 }
506
507 return 0;
508}
509#else
510static int eepro100_initialize_mii(struct eepro100_priv *priv)
511{
512 return 0;
513}
514#endif
515
516static struct pci_device_id supported[] = {
517 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82557) },
518 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82559) },
519 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82559ER) },
520 { }
521};
522
523static void eepro100_get_hwaddr(struct eepro100_priv *priv)
524{
525 u16 sum = 0;
526 int i, j;
527 int addr_len = read_eeprom(priv, 0, 6) == 0xffff ? 8 : 6;
528
529 for (j = 0, i = 0; i < 0x40; i++) {
530 u16 value = read_eeprom(priv, i, addr_len);
531
532 sum += value;
533 if (i < 3) {
534 priv->enetaddr[j++] = value;
535 priv->enetaddr[j++] = value >> 8;
536 }
537 }
538
539 if (sum != 0xBABA) {
540 memset(priv->enetaddr, 0, ETH_ALEN);
541 debug("%s: Invalid EEPROM checksum %#4.4x, check settings before activating this device!\n",
542 priv->name, sum);
543 }
544}
545
546static int eepro100_init_common(struct eepro100_priv *priv)
547{
548 struct eepro100_rxfd *rx_ring = priv->rx_ring;
549 struct eepro100_txfd *tx_ring = priv->tx_ring;
550 struct eepro100_txfd *ias_cmd, *cfg_cmd;
551 int ret, status = -1;
552 int tx_cur;
553
554
555 OUTL(priv, I82559_SELECTIVE_RESET, SCB_PORT);
556 udelay(20);
557
558 OUTL(priv, I82559_RESET, SCB_PORT);
559 udelay(20);
560
561 if (!wait_for_eepro100(priv)) {
562 printf("Error: Can not reset ethernet controller.\n");
563 goto done;
564 }
565 OUTL(priv, 0, SCB_POINTER);
566 OUTW(priv, SCB_M | RUC_ADDR_LOAD, SCB_CMD);
567
568 if (!wait_for_eepro100(priv)) {
569 printf("Error: Can not reset ethernet controller.\n");
570 goto done;
571 }
572 OUTL(priv, 0, SCB_POINTER);
573 OUTW(priv, SCB_M | CU_ADDR_LOAD, SCB_CMD);
574
575
576 init_rx_ring(priv);
577 purge_tx_ring(priv);
578
579
580 if (!wait_for_eepro100(priv)) {
581 printf("Error: Can not reset ethernet controller.\n");
582 goto done;
583 }
584
585
586 OUTL(priv, phys_to_bus(priv->devno, (u32)&rx_ring[priv->rx_next]),
587 SCB_POINTER);
588 OUTW(priv, SCB_M | RUC_START, SCB_CMD);
589
590
591 tx_cur = priv->tx_next;
592 priv->tx_next = ((priv->tx_next + 1) % NUM_TX_DESC);
593
594 cfg_cmd = &tx_ring[tx_cur];
595 cfg_cmd->command = cpu_to_le16(CONFIG_SYS_CMD_SUSPEND |
596 CONFIG_SYS_CMD_CONFIGURE);
597 cfg_cmd->status = 0;
598 cfg_cmd->link = cpu_to_le32(phys_to_bus(priv->devno,
599 (u32)&tx_ring[priv->tx_next]));
600
601 memcpy(((struct descriptor *)cfg_cmd)->params, i82558_config_cmd,
602 sizeof(i82558_config_cmd));
603
604 ret = eepro100_txcmd_send(priv, cfg_cmd);
605 if (ret) {
606 if (ret == -ETIMEDOUT)
607 printf("Error---CONFIG_SYS_CMD_CONFIGURE: Can not reset ethernet controller.\n");
608 goto done;
609 }
610
611
612 tx_cur = priv->tx_next;
613 priv->tx_next = ((priv->tx_next + 1) % NUM_TX_DESC);
614
615 ias_cmd = &tx_ring[tx_cur];
616 ias_cmd->command = cpu_to_le16(CONFIG_SYS_CMD_SUSPEND |
617 CONFIG_SYS_CMD_IAS);
618 ias_cmd->status = 0;
619 ias_cmd->link = cpu_to_le32(phys_to_bus(priv->devno,
620 (u32)&tx_ring[priv->tx_next]));
621
622 memcpy(((struct descriptor *)ias_cmd)->params, priv->enetaddr, 6);
623
624 ret = eepro100_txcmd_send(priv, ias_cmd);
625 if (ret) {
626 if (ret == -ETIMEDOUT)
627 printf("Error: Can not reset ethernet controller.\n");
628 goto done;
629 }
630
631 status = 0;
632
633done:
634 return status;
635}
636
637static int eepro100_send_common(struct eepro100_priv *priv,
638 void *packet, int length)
639{
640 struct eepro100_txfd *tx_ring = priv->tx_ring;
641 struct eepro100_txfd *desc;
642 int ret, status = -1;
643 int tx_cur;
644
645 if (length <= 0) {
646 printf("%s: bad packet size: %d\n", priv->name, length);
647 goto done;
648 }
649
650 tx_cur = priv->tx_next;
651 priv->tx_next = (priv->tx_next + 1) % NUM_TX_DESC;
652
653 desc = &tx_ring[tx_cur];
654 desc->command = cpu_to_le16(TXCB_CMD_TRANSMIT | TXCB_CMD_SF |
655 TXCB_CMD_S | TXCB_CMD_EL);
656 desc->status = 0;
657 desc->count = cpu_to_le32(priv->tx_threshold);
658 desc->link = cpu_to_le32(phys_to_bus(priv->devno,
659 (u32)&tx_ring[priv->tx_next]));
660 desc->tx_desc_addr = cpu_to_le32(phys_to_bus(priv->devno,
661 (u32)&desc->tx_buf_addr0));
662 desc->tx_buf_addr0 = cpu_to_le32(phys_to_bus(priv->devno,
663 (u_long)packet));
664 desc->tx_buf_size0 = cpu_to_le32(length);
665
666 ret = eepro100_txcmd_send(priv, &tx_ring[tx_cur]);
667 if (ret) {
668 if (ret == -ETIMEDOUT)
669 printf("%s: Tx error ethernet controller not ready.\n",
670 priv->name);
671 goto done;
672 }
673
674 status = length;
675
676done:
677 return status;
678}
679
680static int eepro100_recv_common(struct eepro100_priv *priv, uchar **packetp)
681{
682 struct eepro100_rxfd *rx_ring = priv->rx_ring;
683 struct eepro100_rxfd *desc;
684 int length;
685 u16 status;
686
687 priv->rx_stat = INW(priv, SCB_STATUS);
688 OUTW(priv, priv->rx_stat & SCB_STATUS_RNR, SCB_STATUS);
689
690 desc = &rx_ring[priv->rx_next];
691 invalidate_dcache_range((unsigned long)desc,
692 (unsigned long)desc + sizeof(*desc));
693 status = le16_to_cpu(desc->status);
694
695 if (!(status & RFD_STATUS_C))
696 return 0;
697
698
699 if (status & RFD_STATUS_OK) {
700
701 length = le32_to_cpu(desc->count) & 0x3fff;
702
703 *packetp = desc->data;
704 return length;
705 }
706
707
708 printf("RX error status = 0x%08X\n", status);
709 return -EINVAL;
710}
711
712static void eepro100_free_pkt_common(struct eepro100_priv *priv)
713{
714 struct eepro100_rxfd *rx_ring = priv->rx_ring;
715 struct eepro100_rxfd *desc;
716 int rx_prev;
717
718 desc = &rx_ring[priv->rx_next];
719
720 desc->control = cpu_to_le16(RFD_CONTROL_S);
721 desc->status = 0;
722 desc->count = cpu_to_le32(PKTSIZE_ALIGN << 16);
723 flush_dcache_range((unsigned long)desc,
724 (unsigned long)desc + sizeof(*desc));
725
726 rx_prev = (priv->rx_next + NUM_RX_DESC - 1) % NUM_RX_DESC;
727 desc = &rx_ring[rx_prev];
728 desc->control = 0;
729 flush_dcache_range((unsigned long)desc,
730 (unsigned long)desc + sizeof(*desc));
731
732
733 priv->rx_next = (priv->rx_next + 1) % NUM_RX_DESC;
734
735 if (!(priv->rx_stat & SCB_STATUS_RNR))
736 return;
737
738 printf("%s: Receiver is not ready, restart it !\n", priv->name);
739
740
741 init_rx_ring(priv);
742
743 if (!wait_for_eepro100(priv)) {
744 printf("Error: Can not restart ethernet controller.\n");
745 return;
746 }
747
748
749 OUTL(priv, phys_to_bus(priv->devno, (u32)&rx_ring[priv->rx_next]),
750 SCB_POINTER);
751 OUTW(priv, SCB_M | RUC_START, SCB_CMD);
752}
753
754static void eepro100_halt_common(struct eepro100_priv *priv)
755{
756
757 OUTL(priv, I82559_SELECTIVE_RESET, SCB_PORT);
758 udelay(20);
759
760 OUTL(priv, I82559_RESET, SCB_PORT);
761 udelay(20);
762
763 if (!wait_for_eepro100(priv)) {
764 printf("Error: Can not reset ethernet controller.\n");
765 goto done;
766 }
767 OUTL(priv, 0, SCB_POINTER);
768 OUTW(priv, SCB_M | RUC_ADDR_LOAD, SCB_CMD);
769
770 if (!wait_for_eepro100(priv)) {
771 printf("Error: Can not reset ethernet controller.\n");
772 goto done;
773 }
774 OUTL(priv, 0, SCB_POINTER);
775 OUTW(priv, SCB_M | CU_ADDR_LOAD, SCB_CMD);
776
777done:
778 return;
779}
780
781#ifndef CONFIG_DM_ETH
782static int eepro100_init(struct eth_device *dev, struct bd_info *bis)
783{
784 struct eepro100_priv *priv =
785 container_of(dev, struct eepro100_priv, dev);
786
787 return eepro100_init_common(priv);
788}
789
790static void eepro100_halt(struct eth_device *dev)
791{
792 struct eepro100_priv *priv =
793 container_of(dev, struct eepro100_priv, dev);
794
795 eepro100_halt_common(priv);
796}
797
798static int eepro100_send(struct eth_device *dev, void *packet, int length)
799{
800 struct eepro100_priv *priv =
801 container_of(dev, struct eepro100_priv, dev);
802
803 return eepro100_send_common(priv, packet, length);
804}
805
806static int eepro100_recv(struct eth_device *dev)
807{
808 struct eepro100_priv *priv =
809 container_of(dev, struct eepro100_priv, dev);
810 uchar *packet;
811 int ret;
812
813 ret = eepro100_recv_common(priv, &packet);
814 if (ret > 0)
815 net_process_received_packet(packet, ret);
816 if (ret)
817 eepro100_free_pkt_common(priv);
818
819 return ret;
820}
821
822int eepro100_initialize(struct bd_info *bis)
823{
824 struct eepro100_priv *priv;
825 struct eth_device *dev;
826 int card_number = 0;
827 u32 iobase, status;
828 pci_dev_t devno;
829 int idx = 0;
830 int ret;
831
832 while (1) {
833
834 devno = pci_find_devices(supported, idx++);
835 if (devno < 0)
836 break;
837
838 pci_read_config_dword(devno, PCI_BASE_ADDRESS_0, &iobase);
839 iobase &= ~0xf;
840
841 debug("eepro100: Intel i82559 PCI EtherExpressPro @0x%x\n",
842 iobase);
843
844 pci_write_config_dword(devno, PCI_COMMAND,
845 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
846
847
848 pci_read_config_dword(devno, PCI_COMMAND, &status);
849 if (!(status & PCI_COMMAND_MEMORY)) {
850 printf("Error: Can not enable MEM access.\n");
851 continue;
852 }
853
854 if (!(status & PCI_COMMAND_MASTER)) {
855 printf("Error: Can not enable Bus Mastering.\n");
856 continue;
857 }
858
859 priv = calloc(1, sizeof(*priv));
860 if (!priv) {
861 printf("eepro100: Can not allocate memory\n");
862 break;
863 }
864 dev = &priv->dev;
865
866 sprintf(dev->name, "i82559#%d", card_number);
867 priv->name = dev->name;
868
869 priv->devno = devno;
870 priv->iobase = (void __iomem *)bus_to_phys(devno, iobase);
871 priv->enetaddr = dev->enetaddr;
872
873 dev->init = eepro100_init;
874 dev->halt = eepro100_halt;
875 dev->send = eepro100_send;
876 dev->recv = eepro100_recv;
877
878 eth_register(dev);
879
880 ret = eepro100_initialize_mii(priv);
881 if (ret) {
882 eth_unregister(dev);
883 free(priv);
884 return ret;
885 }
886
887 card_number++;
888
889
890 pci_write_config_byte(devno, PCI_LATENCY_TIMER, 0x20);
891
892 udelay(10 * 1000);
893
894 eepro100_get_hwaddr(priv);
895 }
896
897 return card_number;
898}
899
900#else
901static int eepro100_start(struct udevice *dev)
902{
903 struct eth_pdata *plat = dev_get_plat(dev);
904 struct eepro100_priv *priv = dev_get_priv(dev);
905
906 memcpy(priv->enetaddr, plat->enetaddr, sizeof(plat->enetaddr));
907
908 return eepro100_init_common(priv);
909}
910
911static void eepro100_stop(struct udevice *dev)
912{
913 struct eepro100_priv *priv = dev_get_priv(dev);
914
915 eepro100_halt_common(priv);
916}
917
918static int eepro100_send(struct udevice *dev, void *packet, int length)
919{
920 struct eepro100_priv *priv = dev_get_priv(dev);
921 int ret;
922
923 ret = eepro100_send_common(priv, packet, length);
924
925 return ret ? 0 : -ETIMEDOUT;
926}
927
928static int eepro100_recv(struct udevice *dev, int flags, uchar **packetp)
929{
930 struct eepro100_priv *priv = dev_get_priv(dev);
931
932 return eepro100_recv_common(priv, packetp);
933}
934
935static int eepro100_free_pkt(struct udevice *dev, uchar *packet, int length)
936{
937 struct eepro100_priv *priv = dev_get_priv(dev);
938
939 eepro100_free_pkt_common(priv);
940
941 return 0;
942}
943
944static int eepro100_read_rom_hwaddr(struct udevice *dev)
945{
946 struct eepro100_priv *priv = dev_get_priv(dev);
947
948 eepro100_get_hwaddr(priv);
949
950 return 0;
951}
952
953static int eepro100_bind(struct udevice *dev)
954{
955 static int card_number;
956 char name[16];
957
958 sprintf(name, "eepro100#%u", card_number++);
959
960 return device_set_name(dev, name);
961}
962
963static int eepro100_probe(struct udevice *dev)
964{
965 struct eth_pdata *plat = dev_get_plat(dev);
966 struct eepro100_priv *priv = dev_get_priv(dev);
967 u16 command, status;
968 u32 iobase;
969 int ret;
970
971 dm_pci_read_config32(dev, PCI_BASE_ADDRESS_0, &iobase);
972 iobase &= ~0xf;
973
974 debug("eepro100: Intel i82559 PCI EtherExpressPro @0x%x\n", iobase);
975
976 priv->devno = dev;
977 priv->enetaddr = plat->enetaddr;
978 priv->iobase = (void __iomem *)bus_to_phys(dev, iobase);
979
980 command = PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
981 dm_pci_write_config16(dev, PCI_COMMAND, command);
982 dm_pci_read_config16(dev, PCI_COMMAND, &status);
983 if ((status & command) != command) {
984 printf("eepro100: Couldn't enable IO access or Bus Mastering\n");
985 return -EINVAL;
986 }
987
988 ret = eepro100_initialize_mii(priv);
989 if (ret)
990 return ret;
991
992 dm_pci_write_config8(dev, PCI_LATENCY_TIMER, 0x20);
993
994 return 0;
995}
996
997static const struct eth_ops eepro100_ops = {
998 .start = eepro100_start,
999 .send = eepro100_send,
1000 .recv = eepro100_recv,
1001 .stop = eepro100_stop,
1002 .free_pkt = eepro100_free_pkt,
1003 .read_rom_hwaddr = eepro100_read_rom_hwaddr,
1004};
1005
1006U_BOOT_DRIVER(eth_eepro100) = {
1007 .name = "eth_eepro100",
1008 .id = UCLASS_ETH,
1009 .bind = eepro100_bind,
1010 .probe = eepro100_probe,
1011 .ops = &eepro100_ops,
1012 .priv_auto = sizeof(struct eepro100_priv),
1013 .plat_auto = sizeof(struct eth_pdata),
1014};
1015
1016U_BOOT_PCI_DEVICE(eth_eepro100, supported);
1017#endif
1018