[sundance] Add reset completion check
[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
695         /*
696         * wait for reset to complete
697         * this is heavily inspired by the linux sundance driver
698         * according to the linux driver it can take up to 1ms for the reset
699         * to complete
700         */
701         i = 0;
702         while(inl(BASE + ASICCtrl) & (ResetBusy << 16)) {
703                 if(i++ >= 10) {
704                         DBG("sundance: NIC reset did not complete.\n");
705                         break;
706                 }
707                 udelay(100);
708         }
709
710         DBG ( "ASIC Control is now %#x.\n", inl(BASE + ASICCtrl) );
711
712         sundance_reset(nic);
713         if (sdc->an_enable) {
714                 u16 mii_advertise, mii_lpa;
715                 mii_advertise =
716                     mdio_read(nic, sdc->phys[0], MII_ADVERTISE);
717                 mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
718                 mii_advertise &= mii_lpa;
719                 if (mii_advertise & ADVERTISE_100FULL)
720                         sdc->speed = 100;
721                 else if (mii_advertise & ADVERTISE_100HALF)
722                         sdc->speed = 100;
723                 else if (mii_advertise & ADVERTISE_10FULL)
724                         sdc->speed = 10;
725                 else if (mii_advertise & ADVERTISE_10HALF)
726                         sdc->speed = 10;
727         } else {
728                 mii_ctl = mdio_read(nic, sdc->phys[0], MII_BMCR);
729                 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
730                 sdc->speed = speed;
731                 printf("%s: Link changed: %dMbps ,", sdc->nic_name, speed);
732                 printf("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
733                        "full" : "half");
734         }
735         check_duplex(nic);
736         if (sdc->flowctrl && sdc->mii_if.full_duplex) {
737                 outw(inw(BASE + MulticastFilter1 + 2) | 0x0200,
738                      BASE + MulticastFilter1 + 2);
739                 outw(inw(BASE + MACCtrl0) | EnbFlowCtrl, BASE + MACCtrl0);
740         }
741         printf("%dMbps, %s-Duplex\n", sdc->speed,
742                sdc->mii_if.full_duplex ? "Full" : "Half");
743
744         /* point to NIC specific routines */
745         nic->nic_op     = &sundance_operations;
746
747         nic->irqno  = pci->irq;
748         nic->ioaddr = BASE;
749
750         return 1;
751 }
752
753
754 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
755 static int eeprom_read(long ioaddr, int location)
756 {
757         int boguscnt = 10000;   /* Typical 1900 ticks */
758         outw(0x0200 | (location & 0xff), ioaddr + EECtrl);
759         do {
760                 if (!(inw(ioaddr + EECtrl) & 0x8000)) {
761                         return inw(ioaddr + EEData);
762                 }
763         }
764         while (--boguscnt > 0);
765         return 0;
766 }
767
768 /*  MII transceiver control section.
769         Read and write the MII registers using software-generated serial
770         MDIO protocol.  See the MII specifications or DP83840A data sheet
771         for details.
772
773         The maximum data clock rate is 2.5 Mhz.
774         The timing is decoupled from the processor clock by flushing the write
775         from the CPU write buffer with a following read, and using PCI
776         transaction time. */
777
778 #define mdio_in(mdio_addr) inb(mdio_addr)
779 #define mdio_out(value, mdio_addr) outb(value, mdio_addr)
780 #define mdio_delay(mdio_addr) inb(mdio_addr)
781
782 enum mii_reg_bits {
783         MDIO_ShiftClk = 0x0001, MDIO_Data = 0x0002, MDIO_EnbOutput =
784             0x0004,
785 };
786 #define MDIO_EnbIn  (0)
787 #define MDIO_WRITE0 (MDIO_EnbOutput)
788 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
789
790 /* Generate the preamble required for initial synchronization and
791    a few older transceivers. */
792 static void mdio_sync(long mdio_addr)
793 {
794         int bits = 32;
795
796         /* Establish sync by sending at least 32 logic ones. */
797         while (--bits >= 0) {
798                 mdio_out(MDIO_WRITE1, mdio_addr);
799                 mdio_delay(mdio_addr);
800                 mdio_out(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
801                 mdio_delay(mdio_addr);
802         }
803 }
804
805 static int
806 mdio_read(struct nic *nic __unused, int phy_id, unsigned int location)
807 {
808         long mdio_addr = BASE + MIICtrl;
809         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
810         int i, retval = 0;
811
812         if (sdc->mii_preamble_required)
813                 mdio_sync(mdio_addr);
814
815         /* Shift the read command bits out. */
816         for (i = 15; i >= 0; i--) {
817                 int dataval =
818                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
819
820                 mdio_out(dataval, mdio_addr);
821                 mdio_delay(mdio_addr);
822                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
823                 mdio_delay(mdio_addr);
824         }
825         /* Read the two transition, 16 data, and wire-idle bits. */
826         for (i = 19; i > 0; i--) {
827                 mdio_out(MDIO_EnbIn, mdio_addr);
828                 mdio_delay(mdio_addr);
829                 retval = (retval << 1) | ((mdio_in(mdio_addr) & MDIO_Data)
830                                           ? 1 : 0);
831                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
832                 mdio_delay(mdio_addr);
833         }
834         return (retval >> 1) & 0xffff;
835 }
836
837 static void
838 mdio_write(struct nic *nic __unused, int phy_id,
839            unsigned int location, int value)
840 {
841         long mdio_addr = BASE + MIICtrl;
842         int mii_cmd =
843             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
844         int i;
845
846         if (sdc->mii_preamble_required)
847                 mdio_sync(mdio_addr);
848
849         /* Shift the command bits out. */
850         for (i = 31; i >= 0; i--) {
851                 int dataval =
852                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
853                 mdio_out(dataval, mdio_addr);
854                 mdio_delay(mdio_addr);
855                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
856                 mdio_delay(mdio_addr);
857         }
858         /* Clear out extra bits. */
859         for (i = 2; i > 0; i--) {
860                 mdio_out(MDIO_EnbIn, mdio_addr);
861                 mdio_delay(mdio_addr);
862                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
863                 mdio_delay(mdio_addr);
864         }
865         return;
866 }
867
868 static void set_rx_mode(struct nic *nic __unused)
869 {
870         int i;
871         u16 mc_filter[4];       /* Multicast hash filter */
872         u32 rx_mode;
873
874         memset(mc_filter, 0xff, sizeof(mc_filter));
875         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
876
877         if (sdc->mii_if.full_duplex && sdc->flowctrl)
878                 mc_filter[3] |= 0x0200;
879         for (i = 0; i < 4; i++)
880                 outw(mc_filter[i], BASE + MulticastFilter0 + i * 2);
881         outb(rx_mode, BASE + RxMode);
882         return;
883 }
884
885 static struct pci_device_id sundance_nics[] = {
886         PCI_ROM(0x13f0, 0x0201, "sundance", "ST201 Sundance 'Alta' based Adaptor"),
887         PCI_ROM(0x1186, 0x1002, "dfe530txs", "D-Link DFE530TXS (Sundance ST201 Alta)"),
888         PCI_ROM(0x13f0, 0x0200, "ip100a", "IC+ IP100A"),
889 };
890
891 PCI_DRIVER ( sundance_driver, sundance_nics, PCI_NO_CLASS );
892
893 DRIVER ( "SUNDANCE/PCI", nic_driver, pci_driver, sundance_driver,
894          sundance_probe, sundance_disable );
895
896 /*
897  * Local variables:
898  *  c-basic-offset: 8
899  *  c-indent-level: 8
900  *  tab-width: 8
901  * End:
902  */