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