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