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 );