01b27d36b24156e8f87c7ced74b80b446a7e3e39
[people/xl0/gpxe.git] / src / drivers / net / sundance.c
1 /**************************************************************************
2 *
3 *    sundance.c -- Etherboot device driver for the Sundance ST201 "Alta".
4 *    Written 2002-2002 by Timothy Legge <tlegge@rogers.com>
5 *
6 *    This program is free software; you can redistribute it and/or modify
7 *    it under the terms of the GNU General Public License as published by
8 *    the Free Software Foundation; either version 2 of the License, or
9 *    (at your option) any later version.
10 *
11 *    This program is distributed in the hope that it will be useful,
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *    GNU General Public License for more details.
15 *
16 *    You should have received a copy of the GNU General Public License
17 *    along with this program; if not, write to the Free Software
18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 *    Portions of this code based on:
21 *               sundance.c: A Linux device driver for the Sundance ST201 "Alta"
22 *               Written 1999-2002 by Donald Becker
23 *
24 *               tulip.c: Tulip and Clone Etherboot Driver
25 *               By Marty Conner
26 *               Copyright (C) 2001 Entity Cyber, Inc.
27 *
28 *    Linux Driver Version LK1.09a, 10-Jul-2003 (2.4.25)
29 *
30 *    REVISION HISTORY:
31 *    ================
32 *    v1.1       01-01-2003      timlegge        Initial implementation
33 *    v1.7       04-10-2003      timlegge        Transfers Linux Kernel (30 sec)
34 *    v1.8       04-13-2003      timlegge        Fix multiple transmission bug
35 *    v1.9       08-19-2003      timlegge        Support Multicast
36 *    v1.10      01-17-2004      timlegge        Initial driver output cleanup
37 *    v1.11      03-21-2004      timlegge        Remove unused variables
38 *    v1.12      03-21-2004      timlegge        Remove excess MII defines
39 *    v1.13      03-24-2004      timlegge        Update to Linux 2.4.25 driver
40 *
41 ****************************************************************************/
42
43 /* to get some global routines like printf */
44 #include "etherboot.h"
45 /* to get the interface to the body of the program */
46 #include "nic.h"
47 /* to get the PCI support functions, if this is a PCI NIC */
48 #include <gpxe/pci.h>
49 #include "timer.h"
50 #include "mii.h"
51
52 #define drv_version "v1.12"
53 #define drv_date "2004-03-21"
54
55 #define HZ 100
56
57 /* Condensed operations for readability. */
58 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
59 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
60
61 /* May need to be moved to mii.h */
62 struct mii_if_info {
63         int phy_id;
64         int advertising;
65         unsigned int full_duplex:1;     /* is full duplex? */
66 };
67
68 //#define EDEBUG
69 #ifdef EDEBUG
70 #define dprintf(x) printf x
71 #else
72 #define dprintf(x)
73 #endif
74
75
76 /* Set the mtu */
77 static int mtu = 1514;
78
79 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
80    The sundance uses a 64 element hash table based on the Ethernet CRC.  */
81 // static int multicast_filter_limit = 32;
82
83 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
84    Setting to > 1518 effectively disables this feature.
85    This chip can receive into any byte alignment buffers, so word-oriented
86    archs do not need a copy-align of the IP header. */
87 static int rx_copybreak = 0;
88 static int flowctrl = 1;
89
90 /* Allow forcing the media type */
91 /* media[] specifies the media type the NIC operates at.
92                  autosense      Autosensing active media.
93                  10mbps_hd      10Mbps half duplex.
94                  10mbps_fd      10Mbps full duplex.
95                  100mbps_hd     100Mbps half duplex.
96                  100mbps_fd     100Mbps full duplex.
97 */
98 static char media[] = "autosense";
99
100 /* Operational parameters that are set at compile time. */
101
102 /* As Etherboot uses a Polling driver  we can keep the number of rings
103 to the minimum number required.  In general that is 1 transmit and 4 receive receive rings.  However some cards require that
104 there be a minimum of 2 rings  */
105 #define TX_RING_SIZE    2
106 #define TX_QUEUE_LEN    10      /* Limit ring entries actually used.  */
107 #define RX_RING_SIZE    4
108
109
110 /* Operational parameters that usually are not changed. */
111 /* Time in jiffies before concluding the transmitter is hung. */
112 #define TX_TIME_OUT       (4*HZ)
113 #define PKT_BUF_SZ      1536
114
115 /* Offsets to the device registers.
116    Unlike software-only systems, device drivers interact with complex hardware.
117    It's not useful to define symbolic names for every register bit in the
118    device.  The name can only partially document the semantics and make
119    the driver longer and more difficult to read.
120    In general, only the important configuration values or bits changed
121    multiple times should be defined symbolically.
122 */
123 enum alta_offsets {
124         DMACtrl = 0x00,
125         TxListPtr = 0x04,
126         TxDMABurstThresh = 0x08,
127         TxDMAUrgentThresh = 0x09,
128         TxDMAPollPeriod = 0x0a,
129         RxDMAStatus = 0x0c,
130         RxListPtr = 0x10,
131         DebugCtrl0 = 0x1a,
132         DebugCtrl1 = 0x1c,
133         RxDMABurstThresh = 0x14,
134         RxDMAUrgentThresh = 0x15,
135         RxDMAPollPeriod = 0x16,
136         LEDCtrl = 0x1a,
137         ASICCtrl = 0x30,
138         EEData = 0x34,
139         EECtrl = 0x36,
140         TxStartThresh = 0x3c,
141         RxEarlyThresh = 0x3e,
142         FlashAddr = 0x40,
143         FlashData = 0x44,
144         TxStatus = 0x46,
145         TxFrameId = 0x47,
146         DownCounter = 0x18,
147         IntrClear = 0x4a,
148         IntrEnable = 0x4c,
149         IntrStatus = 0x4e,
150         MACCtrl0 = 0x50,
151         MACCtrl1 = 0x52,
152         StationAddr = 0x54,
153         MaxFrameSize = 0x5A,
154         RxMode = 0x5c,
155         MIICtrl = 0x5e,
156         MulticastFilter0 = 0x60,
157         MulticastFilter1 = 0x64,
158         RxOctetsLow = 0x68,
159         RxOctetsHigh = 0x6a,
160         TxOctetsLow = 0x6c,
161         TxOctetsHigh = 0x6e,
162         TxFramesOK = 0x70,
163         RxFramesOK = 0x72,
164         StatsCarrierError = 0x74,
165         StatsLateColl = 0x75,
166         StatsMultiColl = 0x76,
167         StatsOneColl = 0x77,
168         StatsTxDefer = 0x78,
169         RxMissed = 0x79,
170         StatsTxXSDefer = 0x7a,
171         StatsTxAbort = 0x7b,
172         StatsBcastTx = 0x7c,
173         StatsBcastRx = 0x7d,
174         StatsMcastTx = 0x7e,
175         StatsMcastRx = 0x7f,
176         /* Aliased and bogus values! */
177         RxStatus = 0x0c,
178 };
179 enum ASICCtrl_HiWord_bit {
180         GlobalReset = 0x0001,
181         RxReset = 0x0002,
182         TxReset = 0x0004,
183         DMAReset = 0x0008,
184         FIFOReset = 0x0010,
185         NetworkReset = 0x0020,
186         HostReset = 0x0040,
187         ResetBusy = 0x0400,
188 };
189
190 /* Bits in the interrupt status/mask registers. */
191 enum intr_status_bits {
192         IntrSummary = 0x0001, IntrPCIErr = 0x0002, IntrMACCtrl = 0x0008,
193         IntrTxDone = 0x0004, IntrRxDone = 0x0010, IntrRxStart = 0x0020,
194         IntrDrvRqst = 0x0040,
195         StatsMax = 0x0080, LinkChange = 0x0100,
196         IntrTxDMADone = 0x0200, IntrRxDMADone = 0x0400,
197 };
198
199 /* Bits in the RxMode register. */
200 enum rx_mode_bits {
201         AcceptAllIPMulti = 0x20, AcceptMultiHash = 0x10, AcceptAll = 0x08,
202         AcceptBroadcast = 0x04, AcceptMulticast = 0x02, AcceptMyPhys =
203             0x01,
204 };
205 /* Bits in MACCtrl. */
206 enum mac_ctrl0_bits {
207         EnbFullDuplex = 0x20, EnbRcvLargeFrame = 0x40,
208         EnbFlowCtrl = 0x100, EnbPassRxCRC = 0x200,
209 };
210 enum mac_ctrl1_bits {
211         StatsEnable = 0x0020, StatsDisable = 0x0040, StatsEnabled = 0x0080,
212         TxEnable = 0x0100, TxDisable = 0x0200, TxEnabled = 0x0400,
213         RxEnable = 0x0800, RxDisable = 0x1000, RxEnabled = 0x2000,
214 };
215
216 /* The Rx and Tx buffer descriptors.
217    Using only 32 bit fields simplifies software endian correction.
218    This structure must be aligned, and should avoid spanning cache lines.
219 */
220 struct netdev_desc {
221         u32 next_desc;
222         u32 status;
223         u32 addr;
224         u32 length;
225 };
226
227 /* Bits in netdev_desc.status */
228 enum desc_status_bits {
229         DescOwn = 0x8000,
230         DescEndPacket = 0x4000,
231         DescEndRing = 0x2000,
232         LastFrag = 0x80000000,
233         DescIntrOnTx = 0x8000,
234         DescIntrOnDMADone = 0x80000000,
235         DisableAlign = 0x00000001,
236 };
237
238 /**********************************************
239 * Descriptor Ring and Buffer defination
240 ***********************************************/
241 /* Define the TX Descriptor */
242 static struct netdev_desc tx_ring[TX_RING_SIZE];
243
244 /* Define the RX Descriptor */
245 static struct netdev_desc rx_ring[RX_RING_SIZE];
246
247 /* Create a static buffer of size PKT_BUF_SZ for each RX and TX descriptor.
248    All descriptors point to a part of this buffer */
249 struct {
250         unsigned char txb[PKT_BUF_SZ * TX_RING_SIZE];
251         unsigned char rxb[RX_RING_SIZE * PKT_BUF_SZ];
252 } rx_tx_buf __shared;
253 #define rxb rx_tx_buf.rxb
254 #define txb rx_tx_buf.txb
255
256 /* FIXME: Move BASE to the private structure */
257 static u32 BASE;
258 #define EEPROM_SIZE     128
259
260 enum pci_id_flags_bits {
261         PCI_USES_IO = 1, PCI_USES_MEM = 2, PCI_USES_MASTER = 4,
262         PCI_ADDR0 = 0 << 4, PCI_ADDR1 = 1 << 4, PCI_ADDR2 =
263             2 << 4, PCI_ADDR3 = 3 << 4,
264 };
265
266 enum chip_capability_flags { CanHaveMII = 1, KendinPktDropBug = 2, };
267 #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO  | PCI_ADDR0)
268
269 #define MII_CNT         4
270 static struct sundance_private {
271         const char *nic_name;
272         /* Frequently used values */
273
274         unsigned int cur_rx;    /* Producer/consumer ring indicies */
275         unsigned int mtu;
276
277         /* These values keep track of the tranceiver/media in use */
278         unsigned int flowctrl:1;
279         unsigned int an_enable:1;
280
281         unsigned int speed;
282
283         /* MII tranceiver section */
284         struct mii_if_info mii_if;
285         int mii_preamble_required;
286         unsigned char phys[MII_CNT];
287         unsigned char pci_rev_id;
288 } sdx;
289
290 static struct sundance_private *sdc;
291
292 /* Station Address location within the EEPROM */
293 #define EEPROM_SA_OFFSET        0x10
294 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
295                         IntrDrvRqst | IntrTxDone | StatsMax | \
296                         LinkChange)
297
298 static int eeprom_read(long ioaddr, int location);
299 static int mdio_read(struct nic *nic, int phy_id, unsigned int location);
300 static void mdio_write(struct nic *nic, int phy_id, unsigned int location,
301                        int value);
302 static void set_rx_mode(struct nic *nic);
303
304 static void check_duplex(struct nic *nic)
305 {
306         int mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
307         int negotiated = mii_lpa & sdc->mii_if.advertising;
308         int duplex;
309
310         /* Force media */
311         if (!sdc->an_enable || mii_lpa == 0xffff) {
312                 if (sdc->mii_if.full_duplex)
313                         outw(inw(BASE + MACCtrl0) | EnbFullDuplex,
314                              BASE + MACCtrl0);
315                 return;
316         }
317
318         /* Autonegotiation */
319         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
320         if (sdc->mii_if.full_duplex != duplex) {
321                 sdc->mii_if.full_duplex = duplex;
322                 dprintf(("%s: Setting %s-duplex based on MII #%d "
323                          "negotiated capability %4.4x.\n", sdc->nic_name,
324                          duplex ? "full" : "half", sdc->phys[0],
325                          negotiated));
326                 outw(inw(BASE + MACCtrl0) | duplex ? 0x20 : 0,
327                      BASE + MACCtrl0);
328         }
329 }
330
331
332 /**************************************************************************
333  *  init_ring - setup the tx and rx descriptors
334  *************************************************************************/
335 static void init_ring(struct nic *nic __unused)
336 {
337         int i;
338
339         sdc->cur_rx = 0;
340
341         /* Initialize all the Rx descriptors */
342         for (i = 0; i < RX_RING_SIZE; i++) {
343                 rx_ring[i].next_desc = virt_to_le32desc(&rx_ring[i + 1]);
344                 rx_ring[i].status = 0;
345                 rx_ring[i].length = 0;
346                 rx_ring[i].addr = 0;
347         }
348
349         /* Mark the last entry as wrapping the ring */
350         rx_ring[i - 1].next_desc = virt_to_le32desc(&rx_ring[0]);
351
352         for (i = 0; i < RX_RING_SIZE; i++) {
353                 rx_ring[i].addr = virt_to_le32desc(&rxb[i * PKT_BUF_SZ]);
354                 rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
355         }
356
357         /* We only use one transmit buffer, but two
358          * descriptors so transmit engines have somewhere
359          * to point should they feel the need */
360         tx_ring[0].status = 0x00000000;
361         tx_ring[0].addr = virt_to_bus(&txb[0]);
362         tx_ring[0].next_desc = 0;       /* virt_to_bus(&tx_ring[1]); */
363
364         /* This descriptor is never used */
365         tx_ring[1].status = 0x00000000;
366         tx_ring[1].addr = 0;    /*virt_to_bus(&txb[0]); */
367         tx_ring[1].next_desc = 0;
368
369         /* Mark the last entry as wrapping the ring,
370          * though this should never happen */
371         tx_ring[1].length = cpu_to_le32(LastFrag | PKT_BUF_SZ);
372 }
373
374 /**************************************************************************
375  *  RESET - Reset Adapter
376  * ***********************************************************************/
377 static void sundance_reset(struct nic *nic)
378 {
379         int i;
380
381         init_ring(nic);
382
383         outl(virt_to_le32desc(&rx_ring[0]), BASE + RxListPtr);
384         /* The Tx List Pointer is written as packets are queued */
385
386         /* Initialize other registers. */
387         /* __set_mac_addr(dev); */
388         {
389                 u16 addr16;
390
391                 addr16 = (nic->node_addr[0] | (nic->node_addr[1] << 8));
392                 outw(addr16, BASE + StationAddr);
393                 addr16 = (nic->node_addr[2] | (nic->node_addr[3] << 8));
394                 outw(addr16, BASE + StationAddr + 2);
395                 addr16 = (nic->node_addr[4] | (nic->node_addr[5] << 8));
396                 outw(addr16, BASE + StationAddr + 4);
397         }
398
399         outw(sdc->mtu + 14, BASE + MaxFrameSize);
400         if (sdc->mtu > 2047)    /* this will never happen with default options */
401                 outl(inl(BASE + ASICCtrl) | 0x0c, BASE + ASICCtrl);
402
403         set_rx_mode(nic);
404
405         outw(0, BASE + DownCounter);
406         /* Set the chip to poll every N*30nsec */
407         outb(100, BASE + RxDMAPollPeriod);
408
409         /* Fix DFE-580TX packet drop issue */
410         if (sdc->pci_rev_id >= 0x14)
411                 writeb(0x01, BASE + DebugCtrl1);
412
413         outw(RxEnable | TxEnable, BASE + MACCtrl1);
414
415         /* Construct a perfect filter frame with the mac address as first match
416          * and broadcast for all others */
417         for (i = 0; i < 192; i++)
418                 txb[i] = 0xFF;
419
420         txb[0] = nic->node_addr[0];
421         txb[1] = nic->node_addr[1];
422         txb[2] = nic->node_addr[2];
423         txb[3] = nic->node_addr[3];
424         txb[4] = nic->node_addr[4];
425         txb[5] = nic->node_addr[5];
426
427         dprintf(("%s: Done sundance_reset, status: Rx %hX Tx %hX "
428                  "MAC Control %hX, %hX %hX\n",
429                  sdc->nic_name, (int) inl(BASE + RxStatus),
430                  (int) inw(BASE + TxStatus), (int) inl(BASE + MACCtrl0),
431                  (int) inw(BASE + MACCtrl1), (int) inw(BASE + MACCtrl0)));
432 }
433
434 /**************************************************************************
435 IRQ - Wait for a frame
436 ***************************************************************************/
437 static void sundance_irq ( struct nic *nic, irq_action_t action ) {
438         unsigned int intr_status;
439
440         switch ( action ) {
441         case DISABLE :
442         case ENABLE :
443                 intr_status = inw(nic->ioaddr + IntrStatus);
444                 intr_status = intr_status & ~DEFAULT_INTR;
445                 if ( action == ENABLE ) 
446                         intr_status = intr_status | DEFAULT_INTR;
447                 outw(intr_status, nic->ioaddr + IntrEnable);
448                 break;
449         case FORCE :
450                 outw(0x0200, BASE + ASICCtrl);
451                 break;
452         }
453 }
454 /**************************************************************************
455 POLL - Wait for a frame
456 ***************************************************************************/
457 static int sundance_poll(struct nic *nic, int retreive)
458 {
459         /* return true if there's an ethernet packet ready to read */
460         /* nic->packet should contain data on return */
461         /* nic->packetlen should contain length of data */
462         int entry = sdc->cur_rx % RX_RING_SIZE;
463         u32 frame_status = le32_to_cpu(rx_ring[entry].status);
464         int intr_status;
465         int pkt_len = 0;
466
467         if (!(frame_status & DescOwn))
468                 return 0;
469
470         /* There is a packet ready */
471         if(!retreive)
472                 return 1;
473
474         intr_status = inw(nic->ioaddr + IntrStatus);
475         outw(intr_status, nic->ioaddr + IntrStatus);
476
477         pkt_len = frame_status & 0x1fff;
478
479         if (frame_status & 0x001f4000) {
480                 dprintf(("Polling frame_status error\n"));      /* Do we really care about this */
481         } else {
482                 if (pkt_len < rx_copybreak) {
483                         /* FIXME: What should happen Will this ever occur */
484                         printf("Poll Error: pkt_len < rx_copybreak");
485                 } else {
486                         nic->packetlen = pkt_len;
487                         memcpy(nic->packet, rxb +
488                                (sdc->cur_rx * PKT_BUF_SZ), nic->packetlen);
489
490                 }
491         }
492         rx_ring[entry].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
493         rx_ring[entry].status = 0;
494         entry++;
495         sdc->cur_rx = entry % RX_RING_SIZE;
496         outw(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone), 
497                 nic->ioaddr + IntrStatus);
498         return 1;
499 }
500
501 /**************************************************************************
502 TRANSMIT - Transmit a frame
503 ***************************************************************************/
504 static void sundance_transmit(struct nic *nic, const char *d,   /* Destination */
505                               unsigned int t,   /* Type */
506                               unsigned int s,   /* size */
507                               const char *p)
508 {                               /* Packet */
509         u16 nstype;
510         u32 to;
511
512         /* Disable the Tx */
513         outw(TxDisable, BASE + MACCtrl1);
514
515         memcpy(txb, d, ETH_ALEN);
516         memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
517         nstype = htons((u16) t);
518         memcpy(txb + 2 * ETH_ALEN, (u8 *) & nstype, 2);
519         memcpy(txb + ETH_HLEN, p, s);
520
521         s += ETH_HLEN;
522         s &= 0x0FFF;
523         while (s < ETH_ZLEN)
524                 txb[s++] = '\0';
525
526         /* Setup the transmit descriptor */
527         tx_ring[0].length = cpu_to_le32(s | LastFrag);
528         tx_ring[0].status = cpu_to_le32(0x00000001);
529
530         /* Point to transmit descriptor */
531         outl(virt_to_le32desc(&tx_ring[0]), BASE + TxListPtr);
532
533         /* Enable Tx */
534         outw(TxEnable, BASE + MACCtrl1);
535         /* Trigger an immediate send */
536         outw(0, BASE + TxStatus);
537
538         to = currticks() + TX_TIME_OUT;
539         while (!(tx_ring[0].status & 0x00010000) && (currticks() < to));        /* wait */
540
541         if (currticks() >= to) {
542                 printf("TX Time Out");
543         }
544         /* Disable Tx */
545         outw(TxDisable, BASE + MACCtrl1);
546
547 }
548
549 /**************************************************************************
550 DISABLE - Turn off ethernet interface
551 ***************************************************************************/
552 static void sundance_disable ( struct nic *nic __unused ) {
553         /* put the card in its initial state */
554         /* This function serves 3 purposes.
555          * This disables DMA and interrupts so we don't receive
556          *  unexpected packets or interrupts from the card after
557          *  etherboot has finished.
558          * This frees resources so etherboot may use
559          *  this driver on another interface
560          * This allows etherboot to reinitialize the interface
561          *  if something is something goes wrong.
562          */
563         outw(0x0000, BASE + IntrEnable);
564         /* Stop the Chipchips Tx and Rx Status */
565         outw(TxDisable | RxDisable | StatsDisable, BASE + MACCtrl1);
566 }
567
568 static struct nic_operations sundance_operations = {
569         .connect        = dummy_connect,
570         .poll           = sundance_poll,
571         .transmit       = sundance_transmit,
572         .irq            = sundance_irq,
573
574 };
575
576 /**************************************************************************
577 PROBE - Look for an adapter, this routine's visible to the outside
578 ***************************************************************************/
579 static int sundance_probe ( struct nic *nic, struct pci_device *pci ) {
580
581         u8 ee_data[EEPROM_SIZE];
582         u16 mii_ctl;
583         int i;
584         int speed;
585
586         if (pci->ioaddr == 0)
587                 return 0;
588
589         /* BASE is used throughout to address the card */
590         BASE = pci->ioaddr;
591         printf(" sundance.c: Found %s Vendor=0x%hX Device=0x%hX\n",
592                pci->name, pci->vendor, pci->device);
593
594         /* Get the MAC Address by reading the EEPROM */
595         for (i = 0; i < 3; i++) {
596                 ((u16 *) ee_data)[i] =
597                     le16_to_cpu(eeprom_read(BASE, i + EEPROM_SA_OFFSET));
598         }
599         /* Update the nic structure with the MAC Address */
600         for (i = 0; i < ETH_ALEN; i++) {
601                 nic->node_addr[i] = ee_data[i];
602         }
603
604         /* Set the card as PCI Bus Master */
605         adjust_pci_device(pci);
606
607 //      sdc->mii_if.dev = pci;
608 //      sdc->mii_if.phy_id_mask = 0x1f;
609 //      sdc->mii_if.reg_num_mask = 0x1f;
610
611         /* point to private storage */
612         sdc = &sdx;
613
614         sdc->nic_name = pci->name;
615         sdc->mtu = mtu;
616
617         pci_read_config_byte(pci, PCI_REVISION_ID, &sdc->pci_rev_id);
618         dprintf(("Device revision id: %hx\n", sdc->pci_rev_id));
619         /* Print out some hardware info */
620         printf("%s: %! at ioaddr %hX, ", pci->name, nic->node_addr, BASE);
621         sdc->mii_preamble_required = 0;
622         if (1) {
623                 int phy, phy_idx = 0;
624                 sdc->phys[0] = 1;       /* Default Setting */
625                 sdc->mii_preamble_required++;
626                 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
627                         int mii_status = mdio_read(nic, phy, MII_BMSR);
628                         if (mii_status != 0xffff && mii_status != 0x0000) {
629                                 sdc->phys[phy_idx++] = phy;
630                                 sdc->mii_if.advertising =
631                                     mdio_read(nic, phy, MII_ADVERTISE);
632                                 if ((mii_status & 0x0040) == 0)
633                                         sdc->mii_preamble_required++;
634                                 dprintf
635                                     (("%s: MII PHY found at address %d, status " "%hX advertising %hX\n", sdc->nic_name, phy, mii_status, sdc->mii_if.advertising));
636                         }
637                 }
638                 sdc->mii_preamble_required--;
639                 if (phy_idx == 0)
640                         printf("%s: No MII transceiver found!\n",
641                                sdc->nic_name);
642                 sdc->mii_if.phy_id = sdc->phys[0];
643         }
644
645         /* Parse override configuration */
646         sdc->an_enable = 1;
647         if (strcasecmp(media, "autosense") != 0) {
648                 sdc->an_enable = 0;
649                 if (strcasecmp(media, "100mbps_fd") == 0 ||
650                     strcasecmp(media, "4") == 0) {
651                         sdc->speed = 100;
652                         sdc->mii_if.full_duplex = 1;
653                 } else if (strcasecmp(media, "100mbps_hd") == 0
654                            || strcasecmp(media, "3") == 0) {
655                         sdc->speed = 100;
656                         sdc->mii_if.full_duplex = 0;
657                 } else if (strcasecmp(media, "10mbps_fd") == 0 ||
658                            strcasecmp(media, "2") == 0) {
659                         sdc->speed = 10;
660                         sdc->mii_if.full_duplex = 1;
661                 } else if (strcasecmp(media, "10mbps_hd") == 0 ||
662                            strcasecmp(media, "1") == 0) {
663                         sdc->speed = 10;
664                         sdc->mii_if.full_duplex = 0;
665                 } else {
666                         sdc->an_enable = 1;
667                 }
668         }
669         if (flowctrl == 1)
670                 sdc->flowctrl = 1;
671
672         /* Fibre PHY? */
673         if (inl(BASE + ASICCtrl) & 0x80) {
674                 /* Default 100Mbps Full */
675                 if (sdc->an_enable) {
676                         sdc->speed = 100;
677                         sdc->mii_if.full_duplex = 1;
678                         sdc->an_enable = 0;
679                 }
680         }
681
682         /* The Linux driver uses flow control and resets the link here.  This means the
683            mii section from above would need to be re done I believe.  Since it serves
684            no real purpose leave it out. */
685
686         /* Force media type */
687         if (!sdc->an_enable) {
688                 mii_ctl = 0;
689                 mii_ctl |= (sdc->speed == 100) ? BMCR_SPEED100 : 0;
690                 mii_ctl |= (sdc->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
691                 mdio_write(nic, sdc->phys[0], MII_BMCR, mii_ctl);
692                 printf("Override speed=%d, %s duplex\n",
693                        sdc->speed,
694                        sdc->mii_if.full_duplex ? "Full" : "Half");
695         }
696
697         /* Reset the chip to erase previous misconfiguration */
698         dprintf(("ASIC Control is %x.\n", inl(BASE + ASICCtrl)));
699         outw(0x007f, BASE + ASICCtrl + 2);
700         dprintf(("ASIC Control is now %x.\n", inl(BASE + ASICCtrl)));
701
702         sundance_reset(nic);
703         if (sdc->an_enable) {
704                 u16 mii_advertise, mii_lpa;
705                 mii_advertise =
706                     mdio_read(nic, sdc->phys[0], MII_ADVERTISE);
707                 mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
708                 mii_advertise &= mii_lpa;
709                 if (mii_advertise & ADVERTISE_100FULL)
710                         sdc->speed = 100;
711                 else if (mii_advertise & ADVERTISE_100HALF)
712                         sdc->speed = 100;
713                 else if (mii_advertise & ADVERTISE_10FULL)
714                         sdc->speed = 10;
715                 else if (mii_advertise & ADVERTISE_10HALF)
716                         sdc->speed = 10;
717         } else {
718                 mii_ctl = mdio_read(nic, sdc->phys[0], MII_BMCR);
719                 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
720                 sdc->speed = speed;
721                 printf("%s: Link changed: %dMbps ,", sdc->nic_name, speed);
722                 printf("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
723                        "full" : "half");
724         }
725         check_duplex(nic);
726         if (sdc->flowctrl && sdc->mii_if.full_duplex) {
727                 outw(inw(BASE + MulticastFilter1 + 2) | 0x0200,
728                      BASE + MulticastFilter1 + 2);
729                 outw(inw(BASE + MACCtrl0) | EnbFlowCtrl, BASE + MACCtrl0);
730         }
731         printf("%dMbps, %s-Duplex\n", sdc->speed,
732                sdc->mii_if.full_duplex ? "Full" : "Half");
733
734         /* point to NIC specific routines */
735         nic->nic_op     = &sundance_operations;
736         pci_fill_nic ( nic, pci );
737         nic->irqno = pci->irq;
738         nic->ioaddr = BASE;
739
740         return 1;
741 }
742
743
744 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
745 static int eeprom_read(long ioaddr, int location)
746 {
747         int boguscnt = 10000;   /* Typical 1900 ticks */
748         outw(0x0200 | (location & 0xff), ioaddr + EECtrl);
749         do {
750                 if (!(inw(ioaddr + EECtrl) & 0x8000)) {
751                         return inw(ioaddr + EEData);
752                 }
753         }
754         while (--boguscnt > 0);
755         return 0;
756 }
757
758 /*  MII transceiver control section.
759         Read and write the MII registers using software-generated serial
760         MDIO protocol.  See the MII specifications or DP83840A data sheet
761         for details.
762
763         The maximum data clock rate is 2.5 Mhz.
764         The timing is decoupled from the processor clock by flushing the write
765         from the CPU write buffer with a following read, and using PCI
766         transaction time. */
767
768 #define mdio_in(mdio_addr) inb(mdio_addr)
769 #define mdio_out(value, mdio_addr) outb(value, mdio_addr)
770 #define mdio_delay(mdio_addr) inb(mdio_addr)
771
772 enum mii_reg_bits {
773         MDIO_ShiftClk = 0x0001, MDIO_Data = 0x0002, MDIO_EnbOutput =
774             0x0004,
775 };
776 #define MDIO_EnbIn  (0)
777 #define MDIO_WRITE0 (MDIO_EnbOutput)
778 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
779
780 /* Generate the preamble required for initial synchronization and
781    a few older transceivers. */
782 static void mdio_sync(long mdio_addr)
783 {
784         int bits = 32;
785
786         /* Establish sync by sending at least 32 logic ones. */
787         while (--bits >= 0) {
788                 mdio_out(MDIO_WRITE1, mdio_addr);
789                 mdio_delay(mdio_addr);
790                 mdio_out(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
791                 mdio_delay(mdio_addr);
792         }
793 }
794
795 static int
796 mdio_read(struct nic *nic __unused, int phy_id, unsigned int location)
797 {
798         long mdio_addr = BASE + MIICtrl;
799         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
800         int i, retval = 0;
801
802         if (sdc->mii_preamble_required)
803                 mdio_sync(mdio_addr);
804
805         /* Shift the read command bits out. */
806         for (i = 15; i >= 0; i--) {
807                 int dataval =
808                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
809
810                 mdio_out(dataval, mdio_addr);
811                 mdio_delay(mdio_addr);
812                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
813                 mdio_delay(mdio_addr);
814         }
815         /* Read the two transition, 16 data, and wire-idle bits. */
816         for (i = 19; i > 0; i--) {
817                 mdio_out(MDIO_EnbIn, mdio_addr);
818                 mdio_delay(mdio_addr);
819                 retval = (retval << 1) | ((mdio_in(mdio_addr) & MDIO_Data)
820                                           ? 1 : 0);
821                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
822                 mdio_delay(mdio_addr);
823         }
824         return (retval >> 1) & 0xffff;
825 }
826
827 static void
828 mdio_write(struct nic *nic __unused, int phy_id,
829            unsigned int location, int value)
830 {
831         long mdio_addr = BASE + MIICtrl;
832         int mii_cmd =
833             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
834         int i;
835
836         if (sdc->mii_preamble_required)
837                 mdio_sync(mdio_addr);
838
839         /* Shift the command bits out. */
840         for (i = 31; i >= 0; i--) {
841                 int dataval =
842                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
843                 mdio_out(dataval, mdio_addr);
844                 mdio_delay(mdio_addr);
845                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
846                 mdio_delay(mdio_addr);
847         }
848         /* Clear out extra bits. */
849         for (i = 2; i > 0; i--) {
850                 mdio_out(MDIO_EnbIn, mdio_addr);
851                 mdio_delay(mdio_addr);
852                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
853                 mdio_delay(mdio_addr);
854         }
855         return;
856 }
857
858 static void set_rx_mode(struct nic *nic __unused)
859 {
860         int i;
861         u16 mc_filter[4];       /* Multicast hash filter */
862         u32 rx_mode;
863
864         memset(mc_filter, 0xff, sizeof(mc_filter));
865         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
866
867         if (sdc->mii_if.full_duplex && sdc->flowctrl)
868                 mc_filter[3] |= 0x0200;
869         for (i = 0; i < 4; i++)
870                 outw(mc_filter[i], BASE + MulticastFilter0 + i * 2);
871         outb(rx_mode, BASE + RxMode);
872         return;
873 }
874
875 static struct pci_device_id sundance_nics[] = {
876         PCI_ROM(0x13f0, 0x0201, "sundance", "ST201 Sundance 'Alta' based Adaptor"),
877         PCI_ROM(0x1186, 0x1002, "dfe530txs", "D-Link DFE530TXS (Sundance ST201 Alta)"),
878 };
879
880 PCI_DRIVER ( sundance_driver, sundance_nics, PCI_NO_CLASS );
881
882 DRIVER ( "SUNDANCE/PCI", nic_driver, pci_driver, sundance_driver,
883          sundance_probe, sundance_disable );