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