a891ad4048f1594275855bcfcfa4ec80253621a8
[people/xl0/gpxe.git] / src / drivers / net / sis900.c
1 /* -*- Mode:C; c-basic-offset:4; -*- */
2
3 /* 
4    sis900.c: An SiS 900/7016 PCI Fast Ethernet driver for Etherboot
5    Copyright (C) 2001 Entity Cyber, Inc.
6
7    Revision:    1.0     March 1, 2001
8    
9    Author: Marty Connor (mdc@etherboot.org)
10
11    Adapted from a Linux driver which was written by Donald Becker
12    and modified by Ollie Lho and Chin-Shan Li of SiS Corporation.
13    Rewritten for Etherboot by Marty Connor.
14    
15    This software may be used and distributed according to the terms
16    of the GNU Public License (GPL), incorporated herein by reference.
17    
18    References:
19    SiS 7016 Fast Ethernet PCI Bus 10/100 Mbps LAN Controller with OnNow Support,
20    preliminary Rev. 1.0 Jan. 14, 1998
21    SiS 900 Fast Ethernet PCI Bus 10/100 Mbps LAN Single Chip with OnNow Support,
22    preliminary Rev. 1.0 Nov. 10, 1998
23    SiS 7014 Single Chip 100BASE-TX/10BASE-T Physical Layer Solution,
24    preliminary Rev. 1.0 Jan. 18, 1998
25    http://www.sis.com.tw/support/databook.htm */
26
27 /* Revision History */
28
29 /*
30   07 Dec 2003  timlegge - Enabled Multicast Support
31   06 Dec 2003  timlegge - Fixed relocation issue in 5.2
32   04 Jan 2002  Chien-Yu Chen, Doug Ambrisko, Marty Connor  Patch to Etherboot 5.0.5
33      Added support for the SiS 630ET plus various bug fixes from linux kernel
34      source 2.4.17.
35   01 March 2001  mdc     1.0
36      Initial Release.  Tested with PCI based sis900 card and ThinkNIC
37      computer.
38   20 March 2001 P.Koegel
39      added support for sis630e and PHY ICS1893 and RTL8201
40      Testet with SIS730S chipset + ICS1893
41 */
42
43 \f
44 /* Includes */
45
46 #include "etherboot.h"
47 #include "dev.h"
48 #include <gpxe/pci.h>
49 #include "nic.h"
50 #include "timer.h"
51
52 #include "sis900.h"
53
54 /* Globals */
55
56 static struct nic_operations sis900_operations;
57
58 static int sis900_debug = 0;
59
60 static unsigned short vendor, dev_id;
61 static unsigned long ioaddr;
62 static u8 pci_revision;
63
64 static unsigned int cur_phy;
65
66 static unsigned int cur_rx;
67
68 struct {
69     BufferDesc txd;
70     BufferDesc rxd[NUM_RX_DESC];
71     unsigned char txb[TX_BUF_SIZE];
72     unsigned char rxb[NUM_RX_DESC * RX_BUF_SIZE];
73 } sis900_bufs __shared;
74 #define txd sis900_bufs.txd
75 #define rxd sis900_bufs.rxd
76 #define txb sis900_bufs.txb
77 #define rxb sis900_bufs.rxb
78
79 #if 0
80 static struct mac_chip_info {
81     const char *name;
82     u16 vendor_id, device_id, flags;
83     int io_size;
84 } mac_chip_table[] = {
85     { "SiS 900 PCI Fast Ethernet", PCI_VENDOR_ID_SIS, PCI_DEVICE_ID_SIS900,
86       PCI_COMMAND_IO|PCI_COMMAND_MASTER, SIS900_TOTAL_SIZE},
87     { "SiS 7016 PCI Fast Ethernet",PCI_VENDOR_ID_SIS, PCI_DEVICE_ID_SIS7016,
88       PCI_COMMAND_IO|PCI_COMMAND_MASTER, SIS900_TOTAL_SIZE},
89     {0,0,0,0,0} /* 0 terminated list. */
90 };
91 #endif
92
93 static void sis900_read_mode(struct nic *nic, int phy_addr, int *speed, int *duplex);
94 static void amd79c901_read_mode(struct nic *nic, int phy_addr, int *speed, int *duplex);
95 static void ics1893_read_mode(struct nic *nic, int phy_addr, int *speed, int *duplex);
96 static void rtl8201_read_mode(struct nic *nic, int phy_addr, int *speed, int *duplex);
97 static void vt6103_read_mode(struct nic *nic, int phy_addr, int *speed, int *duplex);
98
99 static struct mii_chip_info {
100     const char * name;
101     u16 phy_id0;
102     u16 phy_id1;
103     void (*read_mode) (struct nic *nic, int phy_addr, int *speed, int *duplex);
104 } mii_chip_table[] = {
105     {"SiS 900 Internal MII PHY", 0x001d, 0x8000, sis900_read_mode},
106     {"SiS 7014 Physical Layer Solution", 0x0016, 0xf830,sis900_read_mode},
107     {"AMD 79C901 10BASE-T PHY",  0x0000, 0x6B70, amd79c901_read_mode},
108     {"AMD 79C901 HomePNA PHY",   0x0000, 0x6B90, amd79c901_read_mode},
109     {"ICS 1893 Integrated PHYceiver"   , 0x0015, 0xf440,ics1893_read_mode},
110 //  {"NS 83851 PHY",0x2000, 0x5C20, MIX },
111     {"RTL 8201 10/100Mbps Phyceiver"   , 0x0000, 0x8200,rtl8201_read_mode},
112     {"VIA 6103 10/100Mbps Phyceiver", 0x0101, 0x8f20,vt6103_read_mode},
113     {0,0,0,0}
114 };
115
116 static struct mii_phy {
117     struct mii_phy * next;
118     struct mii_chip_info * chip_info;
119     int phy_addr;
120     u16 status;
121 } mii;
122
123 \f
124
125 #if 0
126 // PCI to ISA bridge for SIS640E access
127 static struct pci_device_id pci_isa_bridge_list[] = {
128         { .vendor = 0x1039, .device = 0x0008,
129                 .name = "SIS 85C503/5513 PCI to ISA bridge"},
130 };
131
132 PCI_DRIVER( sis_bridge_pci_driver, pci_isa_bridge_list, PCI_NO_CLASS );
133
134 static struct device_driver sis_bridge_driver = {
135     .name = "SIS ISA bridge",
136     .bus_driver = &pci_driver,
137     .bus_driver_info = ( struct bus_driver_info * ) &sis_bridge_pci_driver,
138 };
139 #endif
140
141 /* Function Prototypes */
142
143 static int sis900_probe(struct nic *nic,struct pci_device *pci);
144
145 static u16  sis900_read_eeprom(int location);
146 static void sis900_mdio_reset(long mdio_addr);
147 static void sis900_mdio_idle(long mdio_addr);
148 static u16  sis900_mdio_read(int phy_id, int location);
149 #if 0
150 static void sis900_mdio_write(int phy_id, int location, int val);
151 #endif
152 static void sis900_init(struct nic *nic);
153
154 static void sis900_reset(struct nic *nic);
155
156 static void sis900_init_rxfilter(struct nic *nic);
157 static void sis900_init_txd(struct nic *nic);
158 static void sis900_init_rxd(struct nic *nic);
159 static void sis900_set_rx_mode(struct nic *nic);
160 static void sis900_check_mode(struct nic *nic);
161
162 static void sis900_transmit(struct nic *nic, const char *d, 
163                             unsigned int t, unsigned int s, const char *p);
164 static int  sis900_poll(struct nic *nic, int retrieve);
165
166 static void sis900_disable(struct nic *nic);
167
168 static void sis900_irq(struct nic *nic, irq_action_t action);
169
170 /**
171  *      sis900_get_mac_addr: - Get MAC address for stand alone SiS900 model
172  *      @pci_dev: the sis900 pci device
173  *      @net_dev: the net device to get address for
174  *
175  *      Older SiS900 and friends, use EEPROM to store MAC address.
176  *      MAC address is read from read_eeprom() into @net_dev->dev_addr.
177  */
178
179 static int sis900_get_mac_addr(struct pci_device * pci_dev __unused, struct nic *nic)
180 {
181         u16 signature;
182         int i;
183
184         /* check to see if we have sane EEPROM */
185         signature = (u16) sis900_read_eeprom( EEPROMSignature);
186         if (signature == 0xffff || signature == 0x0000) {
187                 printf ("sis900_probe: Error EERPOM read %hX\n", signature);
188                 return 0;
189         }
190
191         /* get MAC address from EEPROM */
192         for (i = 0; i < 3; i++)
193                         ((u16 *)(nic->node_addr))[i] = sis900_read_eeprom(i+EEPROMMACAddr);
194         return 1;
195 }
196
197 /**
198  *      sis96x_get_mac_addr: - Get MAC address for SiS962 or SiS963 model
199  *      @pci_dev: the sis900 pci device
200  *      @net_dev: the net device to get address for 
201  *
202  *      SiS962 or SiS963 model, use EEPROM to store MAC address. And EEPROM 
203  *      is shared by
204  *      LAN and 1394. When access EEPROM, send EEREQ signal to hardware first 
205  *      and wait for EEGNT. If EEGNT is ON, EEPROM is permitted to be access 
206  *      by LAN, otherwise is not. After MAC address is read from EEPROM, send
207  *      EEDONE signal to refuse EEPROM access by LAN. 
208  *      The EEPROM map of SiS962 or SiS963 is different to SiS900. 
209  *      The signature field in SiS962 or SiS963 spec is meaningless. 
210  *      MAC address is read into @net_dev->dev_addr.
211  */
212
213 static int sis96x_get_mac_addr(struct pci_device * pci_dev __unused, struct nic *nic)
214 {
215 /*      long ioaddr = net_dev->base_addr; */
216         long ee_addr = ioaddr + mear;
217         u32 waittime = 0;
218         int i;
219         
220         printf("Alternate function\n");
221
222         outl(EEREQ, ee_addr);
223         while(waittime < 2000) {
224                 if(inl(ee_addr) & EEGNT) {
225
226                         /* get MAC address from EEPROM */
227                         for (i = 0; i < 3; i++)
228                                 ((u16 *)(nic->node_addr))[i] = sis900_read_eeprom(i+EEPROMMACAddr);
229
230                         outl(EEDONE, ee_addr);
231                         return 1;
232                 } else {
233                         udelay(1);      
234                         waittime ++;
235                 }
236         }
237         outl(EEDONE, ee_addr);
238         return 0;
239 }
240
241 /**
242  *      sis630e_get_mac_addr: - Get MAC address for SiS630E model
243  *      @pci_dev: the sis900 pci device
244  *      @net_dev: the net device to get address for
245  *
246  *      SiS630E model, use APC CMOS RAM to store MAC address.
247  *      APC CMOS RAM is accessed through ISA bridge.
248  *      MAC address is read into @net_dev->dev_addr.
249  */
250
251 static int sis630e_get_mac_addr(struct pci_device * pci_dev __unused, struct nic *nic)
252 {
253         u8 reg;
254         int i;
255 #if 0
256         struct bus_loc bus_loc;
257 #endif
258         union {
259             struct bus_dev bus_dev;
260             struct pci_device isa_bridge;
261         } u;
262
263 #if 0
264         /* find PCI to ISA bridge */
265         memset(&bus_loc, 0, sizeof(bus_loc));
266         if ( ! find_by_driver ( &bus_loc, &u.bus_dev, &sis_bridge_driver, 0 ) )
267             return 0;
268 #endif
269
270         pci_read_config_byte(&u.isa_bridge, 0x48, &reg);
271         pci_write_config_byte(&u.isa_bridge, 0x48, reg | 0x40);
272
273         for (i = 0; i < ETH_ALEN; i++)
274         {
275                 outb(0x09 + i, 0x70);
276                 ((u8 *)(nic->node_addr))[i] = inb(0x71);
277         }
278         pci_write_config_byte(&u.isa_bridge, 0x48, reg & ~0x40);
279
280         return 1;
281 }
282
283 /**
284  *      sis630e_get_mac_addr: - Get MAC address for SiS630E model
285  *      @pci_dev: the sis900 pci device
286  *      @net_dev: the net device to get address for
287  *
288  *      SiS630E model, use APC CMOS RAM to store MAC address.
289  *      APC CMOS RAM is accessed through ISA bridge.
290  *      MAC address is read into @net_dev->dev_addr.
291  */
292
293 static int sis635_get_mac_addr(struct pci_device * pci_dev __unused, struct nic *nic)
294 {
295         u32 rfcrSave;
296         u32 i;
297         
298         
299         rfcrSave = inl(rfcr + ioaddr);
300
301         outl(rfcrSave | RELOAD, ioaddr + cr);
302         outl(0, ioaddr + cr);
303
304         /* disable packet filtering before setting filter */
305         outl(rfcrSave & ~RFEN, rfcr + ioaddr);
306
307         /* load MAC addr to filter data register */
308         for (i = 0 ; i < 3 ; i++) {
309                 outl((i << RFADDR_shift), ioaddr + rfcr);
310                 *( ((u16 *)nic->node_addr) + i) = inw(ioaddr + rfdr);
311         }
312
313         /* enable packet filitering */
314         outl(rfcrSave | RFEN, rfcr + ioaddr);
315
316         return 1;
317 }
318 \f
319 /* 
320  * Function: sis900_probe
321  *
322  * Description: initializes initializes the NIC, retrieves the
323  *    MAC address of the card, and sets up some globals required by 
324  *    other routines.
325  *
326  * Side effects:
327  *            leaves the ioaddress of the sis900 chip in the variable ioaddr.
328  *            leaves the sis900 initialized, and ready to recieve packets.
329  *
330  * Returns:   struct nic *:          pointer to NIC data structure
331  */
332
333 static int sis900_probe ( struct nic *nic, struct pci_device *pci ) {
334
335     int i;
336     int found=0;
337     int phy_addr;
338     u8 revision;
339     int ret;
340
341     if (pci->ioaddr == 0)
342         return 0;
343
344     nic->irqno  = 0;
345     pci_fill_nic ( nic, pci );
346     nic->ioaddr = pci->ioaddr;
347     ioaddr  = pci->ioaddr;
348     vendor  = pci->vendor;
349     dev_id  = pci->device;
350
351     /* wakeup chip */
352     pci_write_config_dword(pci, 0x40, 0x00000000);
353
354     adjust_pci_device(pci);
355
356     /* get MAC address */
357     ret = 0;
358     pci_read_config_byte(pci, PCI_REVISION, &revision);
359     
360     /* save for use later in sis900_reset() */
361     pci_revision = revision; 
362
363     if (revision == SIS630E_900_REV)
364         ret = sis630e_get_mac_addr(pci, nic);
365     else if ((revision > 0x81) && (revision <= 0x90))
366         ret = sis635_get_mac_addr(pci, nic);
367     else if (revision == SIS96x_900_REV)
368         ret = sis96x_get_mac_addr(pci, nic);
369     else
370         ret = sis900_get_mac_addr(pci, nic);
371
372     if (ret == 0)
373     {
374         printf ("sis900_probe: Error MAC address not found\n");
375         return 0;
376     }
377
378     /* 630ET : set the mii access mode as software-mode */
379     if (revision == SIS630ET_900_REV)
380         outl(ACCESSMODE | inl(ioaddr + cr), ioaddr + cr);
381
382     DBG( "sis900_probe: Vendor:%#hX Device:%#hX\n", vendor, dev_id );
383
384     /* probe for mii transceiver */
385     /* search for total of 32 possible mii phy addresses */
386
387     found = 0;
388     for (phy_addr = 0; phy_addr < 32; phy_addr++) {
389         u16 mii_status;
390         u16 phy_id0, phy_id1;
391
392         mii_status = sis900_mdio_read(phy_addr, MII_STATUS);
393         if (mii_status == 0xffff || mii_status == 0x0000)
394             /* the mii is not accessable, try next one */
395             continue;
396                 
397         phy_id0 = sis900_mdio_read(phy_addr, MII_PHY_ID0);
398         phy_id1 = sis900_mdio_read(phy_addr, MII_PHY_ID1);
399
400         /* search our mii table for the current mii */ 
401         for (i = 0; mii_chip_table[i].phy_id1; i++) {
402
403             if ((phy_id0 == mii_chip_table[i].phy_id0) &&
404                 ((phy_id1 & 0xFFF0) == mii_chip_table[i].phy_id1)){
405
406                 printf("sis900_probe: %s transceiver found at address %d.\n",
407                        mii_chip_table[i].name, phy_addr);
408
409                 mii.chip_info = &mii_chip_table[i];
410                 mii.phy_addr  = phy_addr;
411                 mii.status    = sis900_mdio_read(phy_addr, MII_STATUS);
412                 mii.next      = NULL;
413
414                 found=1;
415                 break;
416             }
417         }
418     }
419         
420     if (found == 0) {
421         printf("sis900_probe: No MII transceivers found!\n");
422         return 0;
423     }
424
425     /* Arbitrarily select the last PHY found as current PHY */
426     cur_phy = mii.phy_addr;
427     printf("sis900_probe: Using %s as default\n",  mii.chip_info->name);
428
429     /* initialize device */
430     sis900_init(nic);
431     nic->nic_op = &sis900_operations;
432
433     return 1;
434 }
435
436
437
438 \f
439 /* 
440  * EEPROM Routines:  These functions read and write to EEPROM for 
441  *    retrieving the MAC address and other configuration information about 
442  *    the card.
443  */
444
445 /* Delay between EEPROM clock transitions. */
446 #define eeprom_delay()  inl(ee_addr)
447
448 \f
449 /* Function: sis900_read_eeprom
450  *
451  * Description: reads and returns a given location from EEPROM
452  *
453  * Arguments: int location:       requested EEPROM location
454  *
455  * Returns:   u16:                contents of requested EEPROM location
456  *
457  */
458
459 /* Read Serial EEPROM through EEPROM Access Register, Note that location is 
460    in word (16 bits) unit */
461 static u16 sis900_read_eeprom(int location)
462 {
463     int i;
464     u16 retval = 0;
465     long ee_addr = ioaddr + mear;
466     u32 read_cmd = location | EEread;
467
468     outl(0, ee_addr);
469     eeprom_delay();
470     outl(EECS, ee_addr);
471     eeprom_delay();
472
473     /* Shift the read command (9) bits out. */
474     for (i = 8; i >= 0; i--) {
475         u32 dataval = (read_cmd & (1 << i)) ? EEDI | EECS : EECS;
476         outl(dataval, ee_addr);
477         eeprom_delay();
478         outl(dataval | EECLK, ee_addr);
479         eeprom_delay();
480     }
481     outl(EECS, ee_addr);
482     eeprom_delay();
483
484     /* read the 16-bits data in */
485     for (i = 16; i > 0; i--) {
486         outl(EECS, ee_addr);
487         eeprom_delay();
488         outl(EECS | EECLK, ee_addr);
489         eeprom_delay();
490         retval = (retval << 1) | ((inl(ee_addr) & EEDO) ? 1 : 0);
491         eeprom_delay();
492     }
493                 
494     /* Terminate the EEPROM access. */
495     outl(0, ee_addr);
496     eeprom_delay();
497 //  outl(EECLK, ee_addr);
498
499     return (retval);
500 }
501
502 #define sis900_mdio_delay()    inl(mdio_addr)
503
504 \f
505 /* 
506    Read and write the MII management registers using software-generated
507    serial MDIO protocol. Note that the command bits and data bits are
508    send out seperately 
509 */
510
511 static void sis900_mdio_idle(long mdio_addr)
512 {
513     outl(MDIO | MDDIR, mdio_addr);
514     sis900_mdio_delay();
515     outl(MDIO | MDDIR | MDC, mdio_addr);
516 }
517
518 /* Syncronize the MII management interface by shifting 32 one bits out. */
519 static void sis900_mdio_reset(long mdio_addr)
520 {
521     int i;
522
523     for (i = 31; i >= 0; i--) {
524         outl(MDDIR | MDIO, mdio_addr);
525         sis900_mdio_delay();
526         outl(MDDIR | MDIO | MDC, mdio_addr);
527         sis900_mdio_delay();
528     }
529     return;
530 }
531
532 static u16 sis900_mdio_read(int phy_id, int location)
533 {
534     long mdio_addr = ioaddr + mear;
535     int mii_cmd = MIIread|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
536     u16 retval = 0;
537     int i;
538
539     sis900_mdio_reset(mdio_addr);
540     sis900_mdio_idle(mdio_addr);
541
542     for (i = 15; i >= 0; i--) {
543         int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
544         outl(dataval, mdio_addr);
545         sis900_mdio_delay();
546         outl(dataval | MDC, mdio_addr);
547         sis900_mdio_delay();
548     }
549
550     /* Read the 16 data bits. */
551     for (i = 16; i > 0; i--) {
552         outl(0, mdio_addr);
553         sis900_mdio_delay();
554         retval = (retval << 1) | ((inl(mdio_addr) & MDIO) ? 1 : 0);
555         outl(MDC, mdio_addr);
556         sis900_mdio_delay();
557     }
558     outl(0x00, mdio_addr);
559     return retval;
560 }
561
562 #if 0
563 static void sis900_mdio_write(int phy_id, int location, int value)
564 {
565     long mdio_addr = ioaddr + mear;
566     int mii_cmd = MIIwrite|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
567     int i;
568
569     sis900_mdio_reset(mdio_addr);
570     sis900_mdio_idle(mdio_addr);
571
572     /* Shift the command bits out. */
573     for (i = 15; i >= 0; i--) {
574         int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
575         outb(dataval, mdio_addr);
576         sis900_mdio_delay();
577         outb(dataval | MDC, mdio_addr);
578         sis900_mdio_delay();
579     }
580     sis900_mdio_delay();
581
582     /* Shift the value bits out. */
583     for (i = 15; i >= 0; i--) {
584         int dataval = (value & (1 << i)) ? MDDIR | MDIO : MDDIR;
585         outl(dataval, mdio_addr);
586         sis900_mdio_delay();
587         outl(dataval | MDC, mdio_addr);
588         sis900_mdio_delay();
589     }
590     sis900_mdio_delay();
591         
592     /* Clear out extra bits. */
593     for (i = 2; i > 0; i--) {
594         outb(0, mdio_addr);
595         sis900_mdio_delay();
596         outb(MDC, mdio_addr);
597         sis900_mdio_delay();
598     }
599     outl(0x00, mdio_addr);
600     return;
601 }
602 #endif
603
604 \f
605 /* Function: sis900_init
606  *
607  * Description: resets the ethernet controller chip and various
608  *    data structures required for sending and receiving packets.
609  *    
610  * Arguments: struct nic *nic:          NIC data structure
611  *
612  * returns:   void.
613  */
614
615 static void
616 sis900_init(struct nic *nic)
617 {
618     /* Soft reset the chip. */
619     sis900_reset(nic);
620
621     sis900_init_rxfilter(nic);
622
623     sis900_init_txd(nic);
624     sis900_init_rxd(nic);
625
626     sis900_set_rx_mode(nic);
627
628     sis900_check_mode(nic);
629
630     outl(RxENA| inl(ioaddr + cr), ioaddr + cr);
631 }
632
633 \f
634 /* 
635  * Function: sis900_reset
636  *
637  * Description: disables interrupts and soft resets the controller chip
638  *
639  * Arguments: struct nic *nic:          NIC data structure
640  *
641  * Returns:   void.
642  */
643
644 static void 
645 sis900_reset(struct nic *nic __unused)
646 {
647     int i = 0;
648     u32 status = TxRCMP | RxRCMP;
649
650     outl(0, ioaddr + ier);
651     outl(0, ioaddr + imr);
652     outl(0, ioaddr + rfcr);
653
654     outl(RxRESET | TxRESET | RESET | inl(ioaddr + cr), ioaddr + cr);
655
656     /* Check that the chip has finished the reset. */
657     while (status && (i++ < 1000)) {
658         status ^= (inl(isr + ioaddr) & status);
659     }
660
661     if( (pci_revision >= SIS635A_900_REV) || (pci_revision == SIS900B_900_REV) )
662             outl(PESEL | RND_CNT, ioaddr + cfg);
663     else
664             outl(PESEL, ioaddr + cfg);
665 }
666
667 \f
668 /* Function: sis_init_rxfilter
669  *
670  * Description: sets receive filter address to our MAC address
671  *
672  * Arguments: struct nic *nic:          NIC data structure
673  *
674  * returns:   void.
675  */
676
677 static void
678 sis900_init_rxfilter(struct nic *nic)
679 {
680     u32 rfcrSave;
681     int i;
682         
683     rfcrSave = inl(rfcr + ioaddr);
684
685     /* disable packet filtering before setting filter */
686     outl(rfcrSave & ~RFEN, rfcr + ioaddr);
687
688     /* load MAC addr to filter data register */
689     for (i = 0 ; i < 3 ; i++) {
690         u32 w;
691
692         w = (u32) *((u16 *)(nic->node_addr)+i);
693         outl((i << RFADDR_shift), ioaddr + rfcr);
694         outl(w, ioaddr + rfdr);
695
696         if (sis900_debug > 0)
697             printf("sis900_init_rxfilter: Receive Filter Addrss[%d]=%lX\n",
698                    i, inl(ioaddr + rfdr));
699     }
700
701     /* enable packet filitering */
702     outl(rfcrSave | RFEN, rfcr + ioaddr);
703 }
704
705 \f
706 /* 
707  * Function: sis_init_txd
708  *
709  * Description: initializes the Tx descriptor
710  *
711  * Arguments: struct nic *nic:          NIC data structure
712  *
713  * returns:   void.
714  */
715
716 static void
717 sis900_init_txd(struct nic *nic __unused)
718 {
719     txd.link   = (u32) 0;
720     txd.cmdsts = (u32) 0;
721     txd.bufptr = virt_to_bus(&txb[0]);
722
723     /* load Transmit Descriptor Register */
724     outl(virt_to_bus(&txd), ioaddr + txdp); 
725     if (sis900_debug > 0)
726         printf("sis900_init_txd: TX descriptor register loaded with: %lX\n", 
727                inl(ioaddr + txdp));
728 }
729
730 \f
731 /* Function: sis_init_rxd
732  *
733  * Description: initializes the Rx descriptor ring
734  *    
735  * Arguments: struct nic *nic:          NIC data structure
736  *
737  * Returns:   void.
738  */
739
740 static void 
741 sis900_init_rxd(struct nic *nic __unused) 
742
743     int i;
744
745     cur_rx = 0; 
746
747     /* init RX descriptor */
748     for (i = 0; i < NUM_RX_DESC; i++) {
749         rxd[i].link   = virt_to_bus((i+1 < NUM_RX_DESC) ? &rxd[i+1] : &rxd[0]);
750         rxd[i].cmdsts = (u32) RX_BUF_SIZE;
751         rxd[i].bufptr = virt_to_bus(&rxb[i*RX_BUF_SIZE]);
752         if (sis900_debug > 0)
753             printf("sis900_init_rxd: rxd[%d]=%p link=%X cmdsts=%X bufptr=%X\n", 
754                    i, &rxd[i], rxd[i].link, rxd[i].cmdsts, rxd[i].bufptr);
755     }
756
757     /* load Receive Descriptor Register */
758     outl(virt_to_bus(&rxd[0]), ioaddr + rxdp);
759
760     if (sis900_debug > 0)
761         printf("sis900_init_rxd: RX descriptor register loaded with: %lX\n", 
762                inl(ioaddr + rxdp));
763
764 }
765
766 \f
767 /* Function: sis_init_rxd
768  *
769  * Description: 
770  *    sets the receive mode to accept all broadcast packets and packets
771  *    with our MAC address, and reject all multicast packets.      
772  *    
773  * Arguments: struct nic *nic:          NIC data structure
774  *
775  * Returns:   void.
776  */
777
778 static void sis900_set_rx_mode(struct nic *nic __unused)
779 {
780     int i, table_entries;
781     u32 rx_mode; 
782     u16 mc_filter[16] = {0};    /* 256/128 bits multicast hash table */
783         
784     if((pci_revision == SIS635A_900_REV) || (pci_revision == SIS900B_900_REV))
785         table_entries = 16;
786     else
787         table_entries = 8;
788
789     /* accept all multicast packet */
790     rx_mode = RFAAB | RFAAM;
791     for (i = 0; i < table_entries; i++)
792                 mc_filter[i] = 0xffff;
793                                         
794     /* update Multicast Hash Table in Receive Filter */
795     for (i = 0; i < table_entries; i++) {
796         /* why plus 0x04? That makes the correct value for hash table. */
797         outl((u32)(0x00000004+i) << RFADDR_shift, ioaddr + rfcr);
798         outl(mc_filter[i], ioaddr + rfdr);
799     }
800
801     /* Accept Broadcast and multicast packets, destination addresses that match 
802        our MAC address */
803     outl(RFEN | rx_mode, ioaddr + rfcr);
804
805     return;
806 }
807
808 \f
809 /* Function: sis900_check_mode
810  *
811  * Description: checks the state of transmit and receive
812  *    parameters on the NIC, and updates NIC registers to match
813  *    
814  * Arguments: struct nic *nic:          NIC data structure
815  *
816  * Returns:   void.
817  */
818
819 static void
820 sis900_check_mode(struct nic *nic)
821 {
822     int speed, duplex;
823     u32 tx_flags = 0, rx_flags = 0;
824
825     mii.chip_info->read_mode(nic, cur_phy, &speed, &duplex);
826
827     if( inl(ioaddr + cfg) & EDB_MASTER_EN ) {
828         tx_flags = TxATP | (DMA_BURST_64 << TxMXDMA_shift) | (TX_FILL_THRESH << TxFILLT_shift);
829         rx_flags = DMA_BURST_64 << RxMXDMA_shift;
830     }
831     else {
832             tx_flags = TxATP | (DMA_BURST_512 << TxMXDMA_shift) | (TX_FILL_THRESH << TxFILLT_shift);
833             rx_flags = DMA_BURST_512 << RxMXDMA_shift;
834     }
835
836     if (speed == HW_SPEED_HOME || speed == HW_SPEED_10_MBPS) {
837         rx_flags |= (RxDRNT_10 << RxDRNT_shift);
838         tx_flags |= (TxDRNT_10 << TxDRNT_shift);
839     }
840     else {
841         rx_flags |= (RxDRNT_100 << RxDRNT_shift);
842         tx_flags |= (TxDRNT_100 << TxDRNT_shift);
843     }
844
845     if (duplex == FDX_CAPABLE_FULL_SELECTED) {
846         tx_flags |= (TxCSI | TxHBI);
847         rx_flags |= RxATX;
848     }
849
850     outl (tx_flags, ioaddr + txcfg);
851     outl (rx_flags, ioaddr + rxcfg);
852 }
853
854 \f
855 /* Function: sis900_read_mode
856  *
857  * Description: retrieves and displays speed and duplex
858  *    parameters from the NIC
859  *    
860  * Arguments: struct nic *nic:          NIC data structure
861  *
862  * Returns:   void.
863  */
864
865 static void
866 sis900_read_mode(struct nic *nic __unused, int phy_addr, int *speed, int *duplex)
867 {
868     int i = 0;
869     u32 status;
870     u16 phy_id0, phy_id1;
871         
872     /* STSOUT register is Latched on Transition, read operation updates it */
873     while (i++ < 2)
874         status = sis900_mdio_read(phy_addr, MII_STSOUT);
875
876     *speed = HW_SPEED_10_MBPS;
877     *duplex = FDX_CAPABLE_HALF_SELECTED;
878     
879     if (status & (MII_NWAY_TX | MII_NWAY_TX_FDX))
880         *speed = HW_SPEED_100_MBPS;
881     if (status & ( MII_NWAY_TX_FDX | MII_NWAY_T_FDX))
882         *duplex = FDX_CAPABLE_FULL_SELECTED;
883         
884     /* Workaround for Realtek RTL8201 PHY issue */
885     phy_id0 = sis900_mdio_read(phy_addr, MII_PHY_ID0);
886     phy_id1 = sis900_mdio_read(phy_addr, MII_PHY_ID1);
887     if((phy_id0 == 0x0000) && ((phy_id1 & 0xFFF0) == 0x8200)){
888         if(sis900_mdio_read(phy_addr, MII_CONTROL) & MII_CNTL_FDX)
889             *duplex = FDX_CAPABLE_FULL_SELECTED;
890         if(sis900_mdio_read(phy_addr, 0x0019) & 0x01)
891             *speed = HW_SPEED_100_MBPS;
892     }
893
894     if (status & MII_STSOUT_LINK_FAIL)
895         printf("sis900_read_mode: Media Link Off\n");
896     else
897         printf("sis900_read_mode: Media Link On %s %s-duplex \n", 
898                *speed == HW_SPEED_100_MBPS ? 
899                "100mbps" : "10mbps",
900                *duplex == FDX_CAPABLE_FULL_SELECTED ?
901                "full" : "half");
902 }
903
904 \f
905 /* Function: amd79c901_read_mode
906  *
907  * Description: retrieves and displays speed and duplex
908  *    parameters from the NIC
909  *    
910  * Arguments: struct nic *nic:          NIC data structure
911  *
912  * Returns:   void.
913  */
914
915 static void
916 amd79c901_read_mode(struct nic *nic __unused, int phy_addr, int *speed, int *duplex)
917 {
918     int i;
919     u16 status;
920         
921     for (i = 0; i < 2; i++)
922         status = sis900_mdio_read(phy_addr, MII_STATUS);
923
924     if (status & MII_STAT_CAN_AUTO) {
925         /* 10BASE-T PHY */
926         for (i = 0; i < 2; i++)
927             status = sis900_mdio_read(phy_addr, MII_STATUS_SUMMARY);
928         if (status & MII_STSSUM_SPD)
929             *speed = HW_SPEED_100_MBPS;
930         else
931             *speed = HW_SPEED_10_MBPS;
932         if (status & MII_STSSUM_DPLX)
933             *duplex = FDX_CAPABLE_FULL_SELECTED;
934         else
935             *duplex = FDX_CAPABLE_HALF_SELECTED;
936
937         if (status & MII_STSSUM_LINK)
938             printf("amd79c901_read_mode: Media Link On %s %s-duplex \n", 
939                    *speed == HW_SPEED_100_MBPS ? 
940                    "100mbps" : "10mbps",
941                    *duplex == FDX_CAPABLE_FULL_SELECTED ?
942                    "full" : "half");
943         else
944             printf("amd79c901_read_mode: Media Link Off\n");
945     }
946     else {
947         /* HomePNA */
948         *speed = HW_SPEED_HOME;
949         *duplex = FDX_CAPABLE_HALF_SELECTED;
950         if (status & MII_STAT_LINK)
951             printf("amd79c901_read_mode:Media Link On 1mbps half-duplex \n");
952         else
953             printf("amd79c901_read_mode: Media Link Off\n");
954     }
955 }
956
957 \f
958 /**
959  *      ics1893_read_mode: - read media mode for ICS1893 PHY
960  *      @net_dev: the net device to read mode for
961  *      @phy_addr: mii phy address
962  *      @speed: the transmit speed to be determined
963  *      @duplex: the duplex mode to be determined
964  *
965  *      ICS1893 PHY use Quick Poll Detailed Status register
966  *      to determine the speed and duplex mode for sis900
967  */
968
969 static void ics1893_read_mode(struct nic *nic __unused, int phy_addr, int *speed, int *duplex)
970 {
971         int i = 0;
972         u32 status;
973
974         /* MII_QPDSTS is Latched, read twice in succession will reflect the current state */
975         for (i = 0; i < 2; i++)
976                 status = sis900_mdio_read(phy_addr, MII_QPDSTS);
977
978         if (status & MII_STSICS_SPD)
979                 *speed = HW_SPEED_100_MBPS;
980         else
981                 *speed = HW_SPEED_10_MBPS;
982
983         if (status & MII_STSICS_DPLX)
984                 *duplex = FDX_CAPABLE_FULL_SELECTED;
985         else
986                 *duplex = FDX_CAPABLE_HALF_SELECTED;
987
988         if (status & MII_STSICS_LINKSTS)
989                 printf("ics1893_read_mode: Media Link On %s %s-duplex \n",
990                        *speed == HW_SPEED_100_MBPS ?
991                        "100mbps" : "10mbps",
992                        *duplex == FDX_CAPABLE_FULL_SELECTED ?
993                        "full" : "half");
994         else
995                 printf("ics1893_read_mode: Media Link Off\n");
996 }
997
998 /**
999  *      rtl8201_read_mode: - read media mode for rtl8201 phy
1000  *      @nic: the net device to read mode for
1001  *      @phy_addr: mii phy address
1002  *      @speed: the transmit speed to be determined
1003  *      @duplex: the duplex mode to be determined
1004  *
1005  *      read MII_STATUS register from rtl8201 phy
1006  *      to determine the speed and duplex mode for sis900
1007  */
1008
1009 static void rtl8201_read_mode(struct nic *nic __unused, int phy_addr, int *speed, int *duplex)
1010 {
1011         u32 status;
1012
1013         status = sis900_mdio_read(phy_addr, MII_STATUS);
1014
1015         if (status & MII_STAT_CAN_TX_FDX) {
1016                 *speed = HW_SPEED_100_MBPS;
1017                 *duplex = FDX_CAPABLE_FULL_SELECTED;
1018         }
1019         else if (status & MII_STAT_CAN_TX) {
1020                 *speed = HW_SPEED_100_MBPS;
1021                 *duplex = FDX_CAPABLE_HALF_SELECTED;
1022         }
1023         else if (status & MII_STAT_CAN_T_FDX) {
1024                 *speed = HW_SPEED_10_MBPS;
1025                 *duplex = FDX_CAPABLE_FULL_SELECTED;
1026         }
1027         else if (status & MII_STAT_CAN_T) {
1028                 *speed = HW_SPEED_10_MBPS;
1029                 *duplex = FDX_CAPABLE_HALF_SELECTED;
1030         }
1031
1032         if (status & MII_STAT_LINK)
1033                 printf("rtl8201_read_mode: Media Link On %s %s-duplex \n",
1034                        *speed == HW_SPEED_100_MBPS ?
1035                        "100mbps" : "10mbps",
1036                        *duplex == FDX_CAPABLE_FULL_SELECTED ?
1037                        "full" : "half");
1038         else
1039                 printf("rtl8201_read_config_mode: Media Link Off\n");
1040 }
1041
1042 /**
1043  *      vt6103_read_mode: - read media mode for vt6103 phy
1044  *      @nic: the net device to read mode for
1045  *      @phy_addr: mii phy address
1046  *      @speed: the transmit speed to be determined
1047  *      @duplex: the duplex mode to be determined
1048  *
1049  *      read MII_STATUS register from rtl8201 phy
1050  *      to determine the speed and duplex mode for sis900
1051  */
1052
1053 static void vt6103_read_mode(struct nic *nic __unused, int phy_addr, int *speed, int *duplex)
1054 {
1055         u32 status;
1056
1057         status = sis900_mdio_read(phy_addr, MII_STATUS);
1058
1059         if (status & MII_STAT_CAN_TX_FDX) {
1060                 *speed = HW_SPEED_100_MBPS;
1061                 *duplex = FDX_CAPABLE_FULL_SELECTED;
1062         }
1063         else if (status & MII_STAT_CAN_TX) {
1064                 *speed = HW_SPEED_100_MBPS;
1065                 *duplex = FDX_CAPABLE_HALF_SELECTED;
1066         }
1067         else if (status & MII_STAT_CAN_T_FDX) {
1068                 *speed = HW_SPEED_10_MBPS;
1069                 *duplex = FDX_CAPABLE_FULL_SELECTED;
1070         }
1071         else if (status & MII_STAT_CAN_T) {
1072                 *speed = HW_SPEED_10_MBPS;
1073                 *duplex = FDX_CAPABLE_HALF_SELECTED;
1074         }
1075
1076         if (status & MII_STAT_LINK)
1077                 printf("vt6103_read_mode: Media Link On %s %s-duplex \n",
1078                        *speed == HW_SPEED_100_MBPS ?
1079                        "100mbps" : "10mbps",
1080                        *duplex == FDX_CAPABLE_FULL_SELECTED ?
1081                        "full" : "half");
1082         else
1083                 printf("vt6103_read_config_mode: Media Link Off\n");
1084 }
1085
1086 /* Function: sis900_transmit
1087  *
1088  * Description: transmits a packet and waits for completion or timeout.
1089  *
1090  * Arguments: char d[6]:          destination ethernet address.
1091  *            unsigned short t:   ethernet protocol type.
1092  *            unsigned short s:   size of the data-part of the packet.
1093  *            char *p:            the data for the packet.
1094  *    
1095  * Returns:   void.
1096  */
1097
1098 static void
1099 sis900_transmit(struct nic  *nic,
1100                 const char  *d,     /* Destination */
1101                 unsigned int t,     /* Type */
1102                 unsigned int s,     /* size */
1103                 const char  *p)     /* Packet */
1104 {
1105     u32 to, nstype;
1106     volatile u32 tx_status;
1107     
1108     /* Stop the transmitter */
1109     outl(TxDIS | inl(ioaddr + cr), ioaddr + cr);
1110
1111     /* load Transmit Descriptor Register */
1112     outl(virt_to_bus(&txd), ioaddr + txdp); 
1113     if (sis900_debug > 1)
1114         printf("sis900_transmit: TX descriptor register loaded with: %lX\n", 
1115                inl(ioaddr + txdp));
1116
1117     memcpy(txb, d, ETH_ALEN);
1118     memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
1119     nstype = htons(t);
1120     memcpy(txb + 2 * ETH_ALEN, (char*)&nstype, 2);
1121     memcpy(txb + ETH_HLEN, p, s);
1122
1123     s += ETH_HLEN;
1124     s &= DSIZE;
1125
1126     if (sis900_debug > 1)
1127         printf("sis900_transmit: sending %d bytes ethtype %hX\n", (int) s, t);
1128
1129     /* pad to minimum packet size */
1130     while (s < ETH_ZLEN)  
1131         txb[s++] = '\0';
1132
1133     /* set the transmit buffer descriptor and enable Transmit State Machine */
1134     txd.bufptr = virt_to_bus(&txb[0]);
1135     txd.cmdsts = (u32) OWN | s;
1136
1137     /* restart the transmitter */
1138     outl(TxENA | inl(ioaddr + cr), ioaddr + cr);
1139
1140     if (sis900_debug > 1)
1141         printf("sis900_transmit: Queued Tx packet size %d.\n", (int) s);
1142
1143     to = currticks() + TX_TIMEOUT;
1144
1145     while (((tx_status=txd.cmdsts) & OWN) && (currticks() < to))
1146         /* wait */ ;
1147
1148     if (currticks() >= to) {
1149         printf("sis900_transmit: TX Timeout! Tx status %X.\n", tx_status);
1150     }
1151     
1152     if (tx_status & (ABORT | UNDERRUN | OWCOLL)) {
1153         /* packet unsuccessfully transmited */
1154         printf("sis900_transmit: Transmit error, Tx status %X.\n", tx_status);
1155     }
1156     /* Disable interrupts by clearing the interrupt mask. */
1157     outl(0, ioaddr + imr);
1158 }
1159
1160 \f
1161 /* Function: sis900_poll
1162  *
1163  * Description: checks for a received packet and returns it if found.
1164  *
1165  * Arguments: struct nic *nic:          NIC data structure
1166  *
1167  * Returns:   1 if a packet was recieved.
1168  *            0 if no pacet was recieved.
1169  *
1170  * Side effects:
1171  *            Returns (copies) the packet to the array nic->packet.
1172  *            Returns the length of the packet in nic->packetlen.
1173  */
1174
1175 static int
1176 sis900_poll(struct nic *nic, int retrieve)
1177 {
1178     u32 rx_status = rxd[cur_rx].cmdsts;
1179     int retstat = 0;
1180
1181     if (sis900_debug > 2)
1182         printf("sis900_poll: cur_rx:%d, status:%X\n", cur_rx, rx_status);
1183
1184     if (!(rx_status & OWN))
1185         return retstat;
1186
1187     if (sis900_debug > 1)
1188         printf("sis900_poll: got a packet: cur_rx:%d, status:%X\n",
1189                cur_rx, rx_status);
1190
1191     if ( ! retrieve ) return 1;
1192     
1193     nic->packetlen = (rx_status & DSIZE) - CRC_SIZE;
1194
1195     if (rx_status & (ABORT|OVERRUN|TOOLONG|RUNT|RXISERR|CRCERR|FAERR)) {
1196         /* corrupted packet received */
1197         printf("sis900_poll: Corrupted packet received, buffer status = %X\n",
1198                rx_status);
1199         retstat = 0;
1200     } else {
1201         /* give packet to higher level routine */
1202         memcpy(nic->packet, (rxb + cur_rx*RX_BUF_SIZE), nic->packetlen);
1203         retstat = 1;
1204     }
1205
1206     /* return the descriptor and buffer to receive ring */
1207     rxd[cur_rx].cmdsts = RX_BUF_SIZE;
1208     rxd[cur_rx].bufptr = virt_to_bus(&rxb[cur_rx*RX_BUF_SIZE]);
1209         
1210     if (++cur_rx == NUM_RX_DESC)
1211         cur_rx = 0;
1212
1213     /* re-enable the potentially idle receive state machine */
1214     outl(RxENA | inl(ioaddr + cr), ioaddr + cr);
1215
1216     return retstat;
1217
1218 }
1219
1220 \f
1221 /* Function: sis900_disable
1222  *
1223  * Description: Turns off interrupts and stops Tx and Rx engines
1224  *    
1225  * Arguments: struct nic *nic:          NIC data structure
1226  *
1227  * Returns:   void.
1228  */
1229
1230 static void
1231 sis900_disable ( struct nic *nic ) {
1232
1233     sis900_init(nic);
1234
1235     /* Disable interrupts by clearing the interrupt mask. */
1236     outl(0, ioaddr + imr);
1237     outl(0, ioaddr + ier);
1238     
1239     /* Stop the chip's Tx and Rx Status Machine */
1240     outl(RxDIS | TxDIS | inl(ioaddr + cr), ioaddr + cr);
1241 }
1242
1243 \f
1244 /* Function: sis900_irq
1245  *
1246  * Description: Enable, Disable, or Force, interrupts
1247  *    
1248  * Arguments: struct nic *nic:          NIC data structure
1249  *            irq_action_t action:      Requested action       
1250  *
1251  * Returns:   void.
1252  */
1253
1254 static void
1255 sis900_irq(struct nic *nic __unused, irq_action_t action __unused)
1256 {
1257   switch ( action ) {
1258   case DISABLE :
1259     break;
1260   case ENABLE :
1261     break;
1262   case FORCE :
1263     break;
1264   }
1265 }
1266
1267 static struct nic_operations sis900_operations = {
1268         .connect        = dummy_connect,
1269         .poll           = sis900_poll,
1270         .transmit       = sis900_transmit,
1271         .irq            = sis900_irq,
1272 };
1273
1274 static struct pci_device_id sis900_nics[] = {
1275 PCI_ROM(0x1039, 0x0900, "sis900",  "SIS900"),
1276 PCI_ROM(0x1039, 0x7016, "sis7016", "SIS7016"),
1277 };
1278
1279 PCI_DRIVER ( sis900_driver, sis900_nics, PCI_NO_CLASS );
1280
1281 DRIVER ( "SIS900", nic_driver, pci_driver, sis900_driver,
1282          sis900_probe, sis900_disable );