Moved definition of __shared into compiler.h
[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 /* Define the RX Descriptor */
252 static struct netdev_desc rx_ring[RX_RING_SIZE];
253
254 /* Create a static buffer of size PKT_BUF_SZ for each RX and TX descriptor.
255    All descriptors point to a part of this buffer */
256 struct {
257         unsigned char txb[PKT_BUF_SZ * TX_RING_SIZE];
258         unsigned char rxb[RX_RING_SIZE * PKT_BUF_SZ];
259 } rx_tx_buf __shared;
260 #define rxb rx_tx_buf.rxb
261 #define txb rx_tx_buf.txb
262
263 /* FIXME: Move BASE to the private structure */
264 static u32 BASE;
265 #define EEPROM_SIZE     128
266
267 enum pci_id_flags_bits {
268         PCI_USES_IO = 1, PCI_USES_MEM = 2, PCI_USES_MASTER = 4,
269         PCI_ADDR0 = 0 << 4, PCI_ADDR1 = 1 << 4, PCI_ADDR2 =
270             2 << 4, PCI_ADDR3 = 3 << 4,
271 };
272
273 enum chip_capability_flags { CanHaveMII = 1, KendinPktDropBug = 2, };
274 #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO  | PCI_ADDR0)
275
276 #define MII_CNT         4
277 static struct sundance_private {
278         const char *nic_name;
279         /* Frequently used values */
280
281         unsigned int cur_rx;    /* Producer/consumer ring indicies */
282         unsigned int mtu;
283
284         /* These values keep track of the tranceiver/media in use */
285         unsigned int flowctrl:1;
286         unsigned int an_enable:1;
287
288         unsigned int speed;
289
290         /* MII tranceiver section */
291         struct mii_if_info mii_if;
292         int mii_preamble_required;
293         unsigned char phys[MII_CNT];
294         unsigned char pci_rev_id;
295 } sdx;
296
297 static struct sundance_private *sdc;
298
299 /* Station Address location within the EEPROM */
300 #define EEPROM_SA_OFFSET        0x10
301 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
302                         IntrDrvRqst | IntrTxDone | StatsMax | \
303                         LinkChange)
304
305 static int eeprom_read(long ioaddr, int location);
306 static int mdio_read(struct nic *nic, int phy_id, unsigned int location);
307 static void mdio_write(struct nic *nic, int phy_id, unsigned int location,
308                        int value);
309 static void set_rx_mode(struct nic *nic);
310
311 static void check_duplex(struct nic *nic)
312 {
313         int mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
314         int negotiated = mii_lpa & sdc->mii_if.advertising;
315         int duplex;
316
317         /* Force media */
318         if (!sdc->an_enable || mii_lpa == 0xffff) {
319                 if (sdc->mii_if.full_duplex)
320                         outw(inw(BASE + MACCtrl0) | EnbFullDuplex,
321                              BASE + MACCtrl0);
322                 return;
323         }
324
325         /* Autonegotiation */
326         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
327         if (sdc->mii_if.full_duplex != duplex) {
328                 sdc->mii_if.full_duplex = duplex;
329                 dprintf(("%s: Setting %s-duplex based on MII #%d "
330                          "negotiated capability %4.4x.\n", sdc->nic_name,
331                          duplex ? "full" : "half", sdc->phys[0],
332                          negotiated));
333                 outw(inw(BASE + MACCtrl0) | duplex ? 0x20 : 0,
334                      BASE + MACCtrl0);
335         }
336 }
337
338
339 /**************************************************************************
340  *  init_ring - setup the tx and rx descriptors
341  *************************************************************************/
342 static void init_ring(struct nic *nic __unused)
343 {
344         int i;
345
346         sdc->cur_rx = 0;
347
348         /* Initialize all the Rx descriptors */
349         for (i = 0; i < RX_RING_SIZE; i++) {
350                 rx_ring[i].next_desc = virt_to_le32desc(&rx_ring[i + 1]);
351                 rx_ring[i].status = 0;
352                 rx_ring[i].length = 0;
353                 rx_ring[i].addr = 0;
354         }
355
356         /* Mark the last entry as wrapping the ring */
357         rx_ring[i - 1].next_desc = virt_to_le32desc(&rx_ring[0]);
358
359         for (i = 0; i < RX_RING_SIZE; i++) {
360                 rx_ring[i].addr = virt_to_le32desc(&rxb[i * PKT_BUF_SZ]);
361                 rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
362         }
363
364         /* We only use one transmit buffer, but two
365          * descriptors so transmit engines have somewhere
366          * to point should they feel the need */
367         tx_ring[0].status = 0x00000000;
368         tx_ring[0].addr = virt_to_bus(&txb[0]);
369         tx_ring[0].next_desc = 0;       /* virt_to_bus(&tx_ring[1]); */
370
371         /* This descriptor is never used */
372         tx_ring[1].status = 0x00000000;
373         tx_ring[1].addr = 0;    /*virt_to_bus(&txb[0]); */
374         tx_ring[1].next_desc = 0;
375
376         /* Mark the last entry as wrapping the ring,
377          * though this should never happen */
378         tx_ring[1].length = cpu_to_le32(LastFrag | PKT_BUF_SZ);
379 }
380
381 /**************************************************************************
382  *  RESET - Reset Adapter
383  * ***********************************************************************/
384 static void sundance_reset(struct nic *nic)
385 {
386         int i;
387
388         init_ring(nic);
389
390         outl(virt_to_le32desc(&rx_ring[0]), BASE + RxListPtr);
391         /* The Tx List Pointer is written as packets are queued */
392
393         /* Initialize other registers. */
394         /* __set_mac_addr(dev); */
395         {
396                 u16 addr16;
397
398                 addr16 = (nic->node_addr[0] | (nic->node_addr[1] << 8));
399                 outw(addr16, BASE + StationAddr);
400                 addr16 = (nic->node_addr[2] | (nic->node_addr[3] << 8));
401                 outw(addr16, BASE + StationAddr + 2);
402                 addr16 = (nic->node_addr[4] | (nic->node_addr[5] << 8));
403                 outw(addr16, BASE + StationAddr + 4);
404         }
405
406         outw(sdc->mtu + 14, BASE + MaxFrameSize);
407         if (sdc->mtu > 2047)    /* this will never happen with default options */
408                 outl(inl(BASE + ASICCtrl) | 0x0c, BASE + ASICCtrl);
409
410         set_rx_mode(nic);
411
412         outw(0, BASE + DownCounter);
413         /* Set the chip to poll every N*30nsec */
414         outb(100, BASE + RxDMAPollPeriod);
415
416         /* Fix DFE-580TX packet drop issue */
417         if (sdc->pci_rev_id >= 0x14)
418                 writeb(0x01, BASE + DebugCtrl1);
419
420         outw(RxEnable | TxEnable, BASE + MACCtrl1);
421
422         /* Construct a perfect filter frame with the mac address as first match
423          * and broadcast for all others */
424         for (i = 0; i < 192; i++)
425                 txb[i] = 0xFF;
426
427         txb[0] = nic->node_addr[0];
428         txb[1] = nic->node_addr[1];
429         txb[2] = nic->node_addr[2];
430         txb[3] = nic->node_addr[3];
431         txb[4] = nic->node_addr[4];
432         txb[5] = nic->node_addr[5];
433
434         dprintf(("%s: Done sundance_reset, status: Rx %hX Tx %hX "
435                  "MAC Control %hX, %hX %hX\n",
436                  sdc->nic_name, (int) inl(BASE + RxStatus),
437                  (int) inw(BASE + TxStatus), (int) inl(BASE + MACCtrl0),
438                  (int) inw(BASE + MACCtrl1), (int) inw(BASE + MACCtrl0)));
439 }
440
441 /**************************************************************************
442 IRQ - Wait for a frame
443 ***************************************************************************/
444 static void sundance_irq ( struct nic *nic, irq_action_t action ) {
445         unsigned int intr_status;
446
447         switch ( action ) {
448         case DISABLE :
449         case ENABLE :
450                 intr_status = inw(nic->ioaddr + IntrStatus);
451                 intr_status = intr_status & ~DEFAULT_INTR;
452                 if ( action == ENABLE ) 
453                         intr_status = intr_status | DEFAULT_INTR;
454                 outw(intr_status, nic->ioaddr + IntrEnable);
455                 break;
456         case FORCE :
457                 outw(0x0200, BASE + ASICCtrl);
458                 break;
459         }
460 }
461 /**************************************************************************
462 POLL - Wait for a frame
463 ***************************************************************************/
464 static int sundance_poll(struct nic *nic, int retreive)
465 {
466         /* return true if there's an ethernet packet ready to read */
467         /* nic->packet should contain data on return */
468         /* nic->packetlen should contain length of data */
469         int entry = sdc->cur_rx % RX_RING_SIZE;
470         u32 frame_status = le32_to_cpu(rx_ring[entry].status);
471         int intr_status;
472         int pkt_len = 0;
473
474         if (!(frame_status & DescOwn))
475                 return 0;
476
477         /* There is a packet ready */
478         if(!retreive)
479                 return 1;
480
481         intr_status = inw(nic->ioaddr + IntrStatus);
482         outw(intr_status, nic->ioaddr + IntrStatus);
483
484         pkt_len = frame_status & 0x1fff;
485
486         if (frame_status & 0x001f4000) {
487                 dprintf(("Polling frame_status error\n"));      /* Do we really care about this */
488         } else {
489                 if (pkt_len < rx_copybreak) {
490                         /* FIXME: What should happen Will this ever occur */
491                         printf("Poll Error: pkt_len < rx_copybreak");
492                 } else {
493                         nic->packetlen = pkt_len;
494                         memcpy(nic->packet, rxb +
495                                (sdc->cur_rx * PKT_BUF_SZ), nic->packetlen);
496
497                 }
498         }
499         rx_ring[entry].length = cpu_to_le32(PKT_BUF_SZ | LastFrag);
500         rx_ring[entry].status = 0;
501         entry++;
502         sdc->cur_rx = entry % RX_RING_SIZE;
503         outw(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone), 
504                 nic->ioaddr + IntrStatus);
505         return 1;
506 }
507
508 /**************************************************************************
509 TRANSMIT - Transmit a frame
510 ***************************************************************************/
511 static void sundance_transmit(struct nic *nic, const char *d,   /* Destination */
512                               unsigned int t,   /* Type */
513                               unsigned int s,   /* size */
514                               const char *p)
515 {                               /* Packet */
516         u16 nstype;
517         u32 to;
518
519         /* Disable the Tx */
520         outw(TxDisable, BASE + MACCtrl1);
521
522         memcpy(txb, d, ETH_ALEN);
523         memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
524         nstype = htons((u16) t);
525         memcpy(txb + 2 * ETH_ALEN, (u8 *) & nstype, 2);
526         memcpy(txb + ETH_HLEN, p, s);
527
528         s += ETH_HLEN;
529         s &= 0x0FFF;
530         while (s < ETH_ZLEN)
531                 txb[s++] = '\0';
532
533         /* Setup the transmit descriptor */
534         tx_ring[0].length = cpu_to_le32(s | LastFrag);
535         tx_ring[0].status = cpu_to_le32(0x00000001);
536
537         /* Point to transmit descriptor */
538         outl(virt_to_le32desc(&tx_ring[0]), BASE + TxListPtr);
539
540         /* Enable Tx */
541         outw(TxEnable, BASE + MACCtrl1);
542         /* Trigger an immediate send */
543         outw(0, BASE + TxStatus);
544
545         to = currticks() + TX_TIME_OUT;
546         while (!(tx_ring[0].status & 0x00010000) && (currticks() < to));        /* wait */
547
548         if (currticks() >= to) {
549                 printf("TX Time Out");
550         }
551         /* Disable Tx */
552         outw(TxDisable, BASE + MACCtrl1);
553
554 }
555
556 /**************************************************************************
557 DISABLE - Turn off ethernet interface
558 ***************************************************************************/
559 static void sundance_disable ( struct nic *nic __unused ) {
560         /* put the card in its initial state */
561         /* This function serves 3 purposes.
562          * This disables DMA and interrupts so we don't receive
563          *  unexpected packets or interrupts from the card after
564          *  etherboot has finished.
565          * This frees resources so etherboot may use
566          *  this driver on another interface
567          * This allows etherboot to reinitialize the interface
568          *  if something is something goes wrong.
569          */
570         outw(0x0000, BASE + IntrEnable);
571         /* Stop the Chipchips Tx and Rx Status */
572         outw(TxDisable | RxDisable | StatsDisable, BASE + MACCtrl1);
573 }
574
575 static struct nic_operations sundance_operations = {
576         .connect        = dummy_connect,
577         .poll           = sundance_poll,
578         .transmit       = sundance_transmit,
579         .irq            = sundance_irq,
580
581 };
582 static struct pci_driver sundance_driver;
583
584 /**************************************************************************
585 PROBE - Look for an adapter, this routine's visible to the outside
586 ***************************************************************************/
587 static int sundance_probe ( struct nic *nic, struct pci_device *pci ) {
588
589         u8 ee_data[EEPROM_SIZE];
590         u16 mii_ctl;
591         int i;
592         int speed;
593
594         if (pci->ioaddr == 0)
595                 return 0;
596
597         /* BASE is used throughout to address the card */
598         BASE = pci->ioaddr;
599         printf(" sundance.c: Found %s Vendor=0x%hX Device=0x%hX\n",
600                pci->name, pci->vendor_id, pci->device_id);
601
602         /* Get the MAC Address by reading the EEPROM */
603         for (i = 0; i < 3; i++) {
604                 ((u16 *) ee_data)[i] =
605                     le16_to_cpu(eeprom_read(BASE, i + EEPROM_SA_OFFSET));
606         }
607         /* Update the nic structure with the MAC Address */
608         for (i = 0; i < ETH_ALEN; i++) {
609                 nic->node_addr[i] = ee_data[i];
610         }
611
612         /* Set the card as PCI Bus Master */
613         adjust_pci_device(pci);
614
615 //      sdc->mii_if.dev = pci;
616 //      sdc->mii_if.phy_id_mask = 0x1f;
617 //      sdc->mii_if.reg_num_mask = 0x1f;
618
619         /* point to private storage */
620         sdc = &sdx;
621
622         sdc->nic_name = pci->name;
623         sdc->mtu = mtu;
624
625         pci_read_config_byte(pci, PCI_REVISION_ID, &sdc->pci_rev_id);
626         dprintf(("Device revision id: %hx\n", sdc->pci_rev_id));
627         /* Print out some hardware info */
628         printf("%s: %! at ioaddr %hX, ", pci->name, nic->node_addr, BASE);
629         sdc->mii_preamble_required = 0;
630         if (1) {
631                 int phy, phy_idx = 0;
632                 sdc->phys[0] = 1;       /* Default Setting */
633                 sdc->mii_preamble_required++;
634                 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
635                         int mii_status = mdio_read(nic, phy, MII_BMSR);
636                         if (mii_status != 0xffff && mii_status != 0x0000) {
637                                 sdc->phys[phy_idx++] = phy;
638                                 sdc->mii_if.advertising =
639                                     mdio_read(nic, phy, MII_ADVERTISE);
640                                 if ((mii_status & 0x0040) == 0)
641                                         sdc->mii_preamble_required++;
642                                 dprintf
643                                     (("%s: MII PHY found at address %d, status " "%hX advertising %hX\n", sdc->nic_name, phy, mii_status, sdc->mii_if.advertising));
644                         }
645                 }
646                 sdc->mii_preamble_required--;
647                 if (phy_idx == 0)
648                         printf("%s: No MII transceiver found!\n",
649                                sdc->nic_name);
650                 sdc->mii_if.phy_id = sdc->phys[0];
651         }
652
653         /* Parse override configuration */
654         sdc->an_enable = 1;
655         if (strcasecmp(media, "autosense") != 0) {
656                 sdc->an_enable = 0;
657                 if (strcasecmp(media, "100mbps_fd") == 0 ||
658                     strcasecmp(media, "4") == 0) {
659                         sdc->speed = 100;
660                         sdc->mii_if.full_duplex = 1;
661                 } else if (strcasecmp(media, "100mbps_hd") == 0
662                            || strcasecmp(media, "3") == 0) {
663                         sdc->speed = 100;
664                         sdc->mii_if.full_duplex = 0;
665                 } else if (strcasecmp(media, "10mbps_fd") == 0 ||
666                            strcasecmp(media, "2") == 0) {
667                         sdc->speed = 10;
668                         sdc->mii_if.full_duplex = 1;
669                 } else if (strcasecmp(media, "10mbps_hd") == 0 ||
670                            strcasecmp(media, "1") == 0) {
671                         sdc->speed = 10;
672                         sdc->mii_if.full_duplex = 0;
673                 } else {
674                         sdc->an_enable = 1;
675                 }
676         }
677         if (flowctrl == 1)
678                 sdc->flowctrl = 1;
679
680         /* Fibre PHY? */
681         if (inl(BASE + ASICCtrl) & 0x80) {
682                 /* Default 100Mbps Full */
683                 if (sdc->an_enable) {
684                         sdc->speed = 100;
685                         sdc->mii_if.full_duplex = 1;
686                         sdc->an_enable = 0;
687                 }
688         }
689
690         /* The Linux driver uses flow control and resets the link here.  This means the
691            mii section from above would need to be re done I believe.  Since it serves
692            no real purpose leave it out. */
693
694         /* Force media type */
695         if (!sdc->an_enable) {
696                 mii_ctl = 0;
697                 mii_ctl |= (sdc->speed == 100) ? BMCR_SPEED100 : 0;
698                 mii_ctl |= (sdc->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
699                 mdio_write(nic, sdc->phys[0], MII_BMCR, mii_ctl);
700                 printf("Override speed=%d, %s duplex\n",
701                        sdc->speed,
702                        sdc->mii_if.full_duplex ? "Full" : "Half");
703         }
704
705         /* Reset the chip to erase previous misconfiguration */
706         dprintf(("ASIC Control is %x.\n", inl(BASE + ASICCtrl)));
707         outw(0x007f, BASE + ASICCtrl + 2);
708         dprintf(("ASIC Control is now %x.\n", inl(BASE + ASICCtrl)));
709
710         sundance_reset(nic);
711         if (sdc->an_enable) {
712                 u16 mii_advertise, mii_lpa;
713                 mii_advertise =
714                     mdio_read(nic, sdc->phys[0], MII_ADVERTISE);
715                 mii_lpa = mdio_read(nic, sdc->phys[0], MII_LPA);
716                 mii_advertise &= mii_lpa;
717                 if (mii_advertise & ADVERTISE_100FULL)
718                         sdc->speed = 100;
719                 else if (mii_advertise & ADVERTISE_100HALF)
720                         sdc->speed = 100;
721                 else if (mii_advertise & ADVERTISE_10FULL)
722                         sdc->speed = 10;
723                 else if (mii_advertise & ADVERTISE_10HALF)
724                         sdc->speed = 10;
725         } else {
726                 mii_ctl = mdio_read(nic, sdc->phys[0], MII_BMCR);
727                 speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
728                 sdc->speed = speed;
729                 printf("%s: Link changed: %dMbps ,", sdc->nic_name, speed);
730                 printf("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
731                        "full" : "half");
732         }
733         check_duplex(nic);
734         if (sdc->flowctrl && sdc->mii_if.full_duplex) {
735                 outw(inw(BASE + MulticastFilter1 + 2) | 0x0200,
736                      BASE + MulticastFilter1 + 2);
737                 outw(inw(BASE + MACCtrl0) | EnbFlowCtrl, BASE + MACCtrl0);
738         }
739         printf("%dMbps, %s-Duplex\n", sdc->speed,
740                sdc->mii_if.full_duplex ? "Full" : "Half");
741
742         /* point to NIC specific routines */
743         nic->nic_op     = &sundance_operations;
744         pci_fill_nic ( nic, pci );
745         nic->irqno = pci->irq;
746         nic->ioaddr = BASE;
747
748         return 1;
749 }
750
751
752 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
753 static int eeprom_read(long ioaddr, int location)
754 {
755         int boguscnt = 10000;   /* Typical 1900 ticks */
756         outw(0x0200 | (location & 0xff), ioaddr + EECtrl);
757         do {
758                 if (!(inw(ioaddr + EECtrl) & 0x8000)) {
759                         return inw(ioaddr + EEData);
760                 }
761         }
762         while (--boguscnt > 0);
763         return 0;
764 }
765
766 /*  MII transceiver control section.
767         Read and write the MII registers using software-generated serial
768         MDIO protocol.  See the MII specifications or DP83840A data sheet
769         for details.
770
771         The maximum data clock rate is 2.5 Mhz.
772         The timing is decoupled from the processor clock by flushing the write
773         from the CPU write buffer with a following read, and using PCI
774         transaction time. */
775
776 #define mdio_in(mdio_addr) inb(mdio_addr)
777 #define mdio_out(value, mdio_addr) outb(value, mdio_addr)
778 #define mdio_delay(mdio_addr) inb(mdio_addr)
779
780 enum mii_reg_bits {
781         MDIO_ShiftClk = 0x0001, MDIO_Data = 0x0002, MDIO_EnbOutput =
782             0x0004,
783 };
784 #define MDIO_EnbIn  (0)
785 #define MDIO_WRITE0 (MDIO_EnbOutput)
786 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
787
788 /* Generate the preamble required for initial synchronization and
789    a few older transceivers. */
790 static void mdio_sync(long mdio_addr)
791 {
792         int bits = 32;
793
794         /* Establish sync by sending at least 32 logic ones. */
795         while (--bits >= 0) {
796                 mdio_out(MDIO_WRITE1, mdio_addr);
797                 mdio_delay(mdio_addr);
798                 mdio_out(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
799                 mdio_delay(mdio_addr);
800         }
801 }
802
803 static int
804 mdio_read(struct nic *nic __unused, int phy_id, unsigned int location)
805 {
806         long mdio_addr = BASE + MIICtrl;
807         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
808         int i, retval = 0;
809
810         if (sdc->mii_preamble_required)
811                 mdio_sync(mdio_addr);
812
813         /* Shift the read command bits out. */
814         for (i = 15; i >= 0; i--) {
815                 int dataval =
816                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
817
818                 mdio_out(dataval, mdio_addr);
819                 mdio_delay(mdio_addr);
820                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
821                 mdio_delay(mdio_addr);
822         }
823         /* Read the two transition, 16 data, and wire-idle bits. */
824         for (i = 19; i > 0; i--) {
825                 mdio_out(MDIO_EnbIn, mdio_addr);
826                 mdio_delay(mdio_addr);
827                 retval = (retval << 1) | ((mdio_in(mdio_addr) & MDIO_Data)
828                                           ? 1 : 0);
829                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
830                 mdio_delay(mdio_addr);
831         }
832         return (retval >> 1) & 0xffff;
833 }
834
835 static void
836 mdio_write(struct nic *nic __unused, int phy_id,
837            unsigned int location, int value)
838 {
839         long mdio_addr = BASE + MIICtrl;
840         int mii_cmd =
841             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
842         int i;
843
844         if (sdc->mii_preamble_required)
845                 mdio_sync(mdio_addr);
846
847         /* Shift the command bits out. */
848         for (i = 31; i >= 0; i--) {
849                 int dataval =
850                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
851                 mdio_out(dataval, mdio_addr);
852                 mdio_delay(mdio_addr);
853                 mdio_out(dataval | MDIO_ShiftClk, mdio_addr);
854                 mdio_delay(mdio_addr);
855         }
856         /* Clear out extra bits. */
857         for (i = 2; i > 0; i--) {
858                 mdio_out(MDIO_EnbIn, mdio_addr);
859                 mdio_delay(mdio_addr);
860                 mdio_out(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
861                 mdio_delay(mdio_addr);
862         }
863         return;
864 }
865
866 static void set_rx_mode(struct nic *nic __unused)
867 {
868         int i;
869         u16 mc_filter[4];       /* Multicast hash filter */
870         u32 rx_mode;
871
872         memset(mc_filter, 0xff, sizeof(mc_filter));
873         rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
874
875         if (sdc->mii_if.full_duplex && sdc->flowctrl)
876                 mc_filter[3] |= 0x0200;
877         for (i = 0; i < 4; i++)
878                 outw(mc_filter[i], BASE + MulticastFilter0 + i * 2);
879         outb(rx_mode, BASE + RxMode);
880         return;
881 }
882
883 static struct pci_id sundance_nics[] = {
884         PCI_ROM(0x13f0, 0x0201, "sundance", "ST201 Sundance 'Alta' based Adaptor"),
885         PCI_ROM(0x1186, 0x1002, "dfe530txs", "D-Link DFE530TXS (Sundance ST201 Alta)"),
886 };
887
888 PCI_DRIVER ( sundance_driver, sundance_nics, PCI_NO_CLASS );
889
890 DRIVER ( "SUNDANCE/PCI", nic_driver, pci_driver, sundance_driver,
891          sundance_probe, sundance_disable );