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