![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tlan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to tlan.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /******************************************************************** ! 2: * ! 3: * Linux ThunderLAN Driver ! 4: * ! 5: * tlan.c ! 6: * by James Banks ! 7: * ! 8: * (C) 1997-1998 Caldera, Inc. ! 9: * (C) 1998 James Banks ! 10: * ! 11: * This software may be used and distributed according to the terms ! 12: * of the GNU Public License, incorporated herein by reference. ! 13: * ! 14: ** This file is best viewed/edited with columns>=132. ! 15: * ! 16: ** Useful (if not required) reading: ! 17: * ! 18: * Texas Instruments, ThunderLAN Programmer's Guide, ! 19: * TI Literature Number SPWU013A ! 20: * available in PDF format from www.ti.com ! 21: * Level One, LXT901 and LXT970 Data Sheets ! 22: * available in PDF format from www.level1.com ! 23: * National Semiconductor, DP83840A Data Sheet ! 24: * available in PDF format from www.national.com ! 25: * Microchip Technology, 24C01A/02A/04A Data Sheet ! 26: * available in PDF format from www.microchip.com ! 27: * ! 28: ********************************************************************/ ! 29: ! 30: ! 31: #include <linux/module.h> ! 32: ! 33: #include "tlan.h" ! 34: ! 35: #include <linux/bios32.h> ! 36: #include <linux/ioport.h> ! 37: #include <linux/pci.h> ! 38: #include <linux/etherdevice.h> ! 39: #include <linux/delay.h> ! 40: ! 41: ! 42: ! 43: typedef u32 (TLanIntVectorFunc)( struct device *, u16 ); ! 44: ! 45: ! 46: #ifdef MODULE ! 47: ! 48: static struct device *TLanDevices = NULL; ! 49: static int TLanDevicesInstalled = 0; ! 50: ! 51: #endif ! 52: ! 53: ! 54: static int debug = 0; ! 55: static int aui = 0; ! 56: static int sa_int = 0; ! 57: static int bbuf = 0; ! 58: static int duplex = 0; ! 59: static int speed = 0; ! 60: static u8 *TLanPadBuffer; ! 61: static char TLanSignature[] = "TLAN"; ! 62: static int TLanVersionMajor = 1; ! 63: static int TLanVersionMinor = 0; ! 64: ! 65: ! 66: static TLanAdapterEntry TLanAdapterList[] = { ! 67: { PCI_VENDOR_ID_COMPAQ, ! 68: PCI_DEVICE_ID_NETELLIGENT_10, ! 69: "Compaq Netelligent 10 T PCI UTP", ! 70: TLAN_ADAPTER_ACTIVITY_LED, ! 71: 0x83 ! 72: }, ! 73: { PCI_VENDOR_ID_COMPAQ, ! 74: PCI_DEVICE_ID_NETELLIGENT_10_100, ! 75: "Compaq Netelligent 10/100 TX PCI UTP", ! 76: TLAN_ADAPTER_ACTIVITY_LED, ! 77: 0x83 ! 78: }, ! 79: { PCI_VENDOR_ID_COMPAQ, ! 80: PCI_DEVICE_ID_NETFLEX_3P_INTEGRATED, ! 81: "Compaq Integrated NetFlex-3/P", ! 82: TLAN_ADAPTER_NONE, ! 83: 0x83 ! 84: }, ! 85: { PCI_VENDOR_ID_COMPAQ, ! 86: PCI_DEVICE_ID_NETFLEX_3P, ! 87: "Compaq NetFlex-3/P", ! 88: TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, ! 89: 0x83 ! 90: }, ! 91: { PCI_VENDOR_ID_COMPAQ, ! 92: PCI_DEVICE_ID_NETFLEX_3P_BNC, ! 93: "Compaq NetFlex-3/P", ! 94: TLAN_ADAPTER_NONE, ! 95: 0x83 ! 96: }, ! 97: { PCI_VENDOR_ID_COMPAQ, ! 98: PCI_DEVICE_ID_NETELLIGENT_10_100_PROLIANT, ! 99: "Compaq Netelligent Integrated 10/100 TX UTP", ! 100: TLAN_ADAPTER_NONE, ! 101: 0x83 ! 102: }, ! 103: { PCI_VENDOR_ID_COMPAQ, ! 104: PCI_DEVICE_ID_NETELLIGENT_10_100_DUAL, ! 105: "Compaq Netelligent Dual 10/100 TX PCI UTP", ! 106: TLAN_ADAPTER_NONE, ! 107: 0x83 ! 108: }, ! 109: { PCI_VENDOR_ID_COMPAQ, ! 110: PCI_DEVICE_ID_DESKPRO_4000_5233MMX, ! 111: "Compaq Netelligent 10/100 TX Embedded UTP", ! 112: TLAN_ADAPTER_NONE, ! 113: 0x83 ! 114: }, ! 115: { PCI_VENDOR_ID_OLICOM, ! 116: PCI_DEVICE_ID_OLICOM_OC2183, ! 117: "Olicom OC-2183/2185", ! 118: TLAN_ADAPTER_USE_INTERN_10, ! 119: 0xF8 ! 120: }, ! 121: { PCI_VENDOR_ID_OLICOM, ! 122: PCI_DEVICE_ID_OLICOM_OC2325, ! 123: "Olicom OC-2325", ! 124: TLAN_ADAPTER_UNMANAGED_PHY, ! 125: 0xF8 ! 126: }, ! 127: { PCI_VENDOR_ID_OLICOM, ! 128: PCI_DEVICE_ID_OLICOM_OC2326, ! 129: "Olicom OC-2326", ! 130: TLAN_ADAPTER_USE_INTERN_10, ! 131: 0xF8 ! 132: }, ! 133: { PCI_VENDOR_ID_COMPAQ, ! 134: PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100, ! 135: "Compaq Netelligent 10/100 TX UTP", ! 136: TLAN_ADAPTER_ACTIVITY_LED, ! 137: 0x83 ! 138: }, ! 139: { PCI_VENDOR_ID_COMPAQ, ! 140: PCI_DEVICE_ID_NETELLIGENT_10_T2, ! 141: "Compaq Netelligent 10 T/2 PCI UTP/Coax", ! 142: TLAN_ADAPTER_NONE, ! 143: 0x83 ! 144: }, ! 145: { 0, ! 146: 0, ! 147: NULL, ! 148: 0, ! 149: 0 ! 150: } /* End of List */ ! 151: }; ! 152: ! 153: ! 154: static int TLan_PciProbe( u8 *, u8 *, u8 *, u8 *, u32 *, u32 * ); ! 155: static int TLan_Init( struct device * ); ! 156: static int TLan_Open(struct device *dev); ! 157: static int TLan_StartTx(struct sk_buff *, struct device *); ! 158: static void TLan_HandleInterrupt(int, void *, struct pt_regs *); ! 159: static int TLan_Close(struct device *); ! 160: static struct net_device_stats *TLan_GetStats( struct device * ); ! 161: static void TLan_SetMulticastList( struct device * ); ! 162: ! 163: static u32 TLan_HandleInvalid( struct device *, u16 ); ! 164: static u32 TLan_HandleTxEOF( struct device *, u16 ); ! 165: static u32 TLan_HandleStatOverflow( struct device *, u16 ); ! 166: static u32 TLan_HandleRxEOF( struct device *, u16 ); ! 167: static u32 TLan_HandleDummy( struct device *, u16 ); ! 168: static u32 TLan_HandleTxEOC( struct device *, u16 ); ! 169: static u32 TLan_HandleStatusCheck( struct device *, u16 ); ! 170: static u32 TLan_HandleRxEOC( struct device *, u16 ); ! 171: ! 172: static void TLan_Timer( unsigned long ); ! 173: ! 174: static void TLan_ResetLists( struct device * ); ! 175: static void TLan_FreeLists( struct device * ); ! 176: static void TLan_PrintDio( u16 ); ! 177: static void TLan_PrintList( TLanList *, char *, int ); ! 178: static void TLan_ReadAndClearStats( struct device *, int ); ! 179: static void TLan_ResetAdapter( struct device * ); ! 180: static void TLan_FinishReset( struct device * ); ! 181: static void TLan_SetMac( struct device *, int areg, char *mac ); ! 182: ! 183: static void TLan_PhyPrint( struct device * ); ! 184: static void TLan_PhyDetect( struct device * ); ! 185: static void TLan_PhyPowerDown( struct device * ); ! 186: static void TLan_PhyPowerUp( struct device * ); ! 187: static void TLan_PhyReset( struct device * ); ! 188: static void TLan_PhyStartLink( struct device * ); ! 189: static void TLan_PhyFinishAutoNeg( struct device * ); ! 190: /* ! 191: static int TLan_PhyNop( struct device * ); ! 192: static int TLan_PhyInternalCheck( struct device * ); ! 193: static int TLan_PhyInternalService( struct device * ); ! 194: static int TLan_PhyDp83840aCheck( struct device * ); ! 195: */ ! 196: ! 197: static int TLan_MiiReadReg( struct device *, u16, u16, u16 * ); ! 198: static void TLan_MiiSendData( u16, u32, unsigned ); ! 199: static void TLan_MiiSync( u16 ); ! 200: static void TLan_MiiWriteReg( struct device *, u16, u16, u16 ); ! 201: ! 202: static void TLan_EeSendStart( u16 ); ! 203: static int TLan_EeSendByte( u16, u8, int ); ! 204: static void TLan_EeReceiveByte( u16, u8 *, int ); ! 205: static int TLan_EeReadByte( struct device *, u8, u8 * ); ! 206: ! 207: ! 208: static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = { ! 209: TLan_HandleInvalid, ! 210: TLan_HandleTxEOF, ! 211: TLan_HandleStatOverflow, ! 212: TLan_HandleRxEOF, ! 213: TLan_HandleDummy, ! 214: TLan_HandleTxEOC, ! 215: TLan_HandleStatusCheck, ! 216: TLan_HandleRxEOC ! 217: }; ! 218: ! 219: static inline void ! 220: TLan_SetTimer( struct device *dev, u32 ticks, u32 type ) ! 221: { ! 222: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 223: ! 224: cli(); ! 225: if ( priv->timer.function != NULL ) { ! 226: return; ! 227: } ! 228: priv->timer.function = &TLan_Timer; ! 229: sti(); ! 230: ! 231: priv->timer.data = (unsigned long) dev; ! 232: priv->timer.expires = jiffies + ticks; ! 233: priv->timerSetAt = jiffies; ! 234: priv->timerType = type; ! 235: add_timer( &priv->timer ); ! 236: ! 237: } /* TLan_SetTimer */ ! 238: ! 239: ! 240: /***************************************************************************** ! 241: ****************************************************************************** ! 242: ! 243: ThunderLAN Driver Primary Functions ! 244: ! 245: These functions are more or less common to all Linux network drivers. ! 246: ! 247: ****************************************************************************** ! 248: *****************************************************************************/ ! 249: ! 250: ! 251: #ifdef MODULE ! 252: ! 253: /*************************************************************** ! 254: * init_module ! 255: * ! 256: * Returns: ! 257: * 0 if module installed ok, non-zero if not. ! 258: * Parms: ! 259: * None ! 260: * ! 261: * This function begins the setup of the driver creating a ! 262: * pad buffer, finding all TLAN devices (matching ! 263: * TLanAdapterList entries), and creating and initializing a ! 264: * device structure for each adapter. ! 265: * ! 266: **************************************************************/ ! 267: ! 268: extern int init_module(void) ! 269: { ! 270: TLanPrivateInfo *priv; ! 271: u8 bus; ! 272: struct device *dev; ! 273: size_t dev_size; ! 274: u8 dfn; ! 275: u32 index; ! 276: int failed; ! 277: int found; ! 278: u32 io_base; ! 279: u8 irq; ! 280: u8 rev; ! 281: ! 282: printk( "TLAN driver, v%d.%d, (C) 1997-8 Caldera, Inc.\n", ! 283: TLanVersionMajor, ! 284: TLanVersionMinor ! 285: ); ! 286: TLanPadBuffer = (u8 *) kmalloc( TLAN_MIN_FRAME_SIZE, ! 287: ( GFP_KERNEL | GFP_DMA ) ! 288: ); ! 289: if ( TLanPadBuffer == NULL ) { ! 290: printk( "TLAN: Could not allocate memory for pad buffer.\n" ); ! 291: return -ENOMEM; ! 292: } ! 293: ! 294: memset( TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE ); ! 295: ! 296: dev_size = sizeof(struct device) + sizeof(TLanPrivateInfo); ! 297: ! 298: while ( ( found = TLan_PciProbe( &bus, &dfn, &irq, &rev, &io_base, &index ) ) ) { ! 299: dev = (struct device *) kmalloc( dev_size, GFP_KERNEL ); ! 300: if ( dev == NULL ) { ! 301: printk( "TLAN: Could not allocate memory for device.\n" ); ! 302: continue; ! 303: } ! 304: memset( dev, 0, dev_size ); ! 305: ! 306: dev->priv = priv = ( (void *) dev ) + sizeof(struct device); ! 307: dev->name = priv->devName; ! 308: strcpy( priv->devName, " " ); ! 309: dev->base_addr = io_base; ! 310: dev->irq = irq; ! 311: dev->init = TLan_Init; ! 312: ! 313: priv->adapter = &TLanAdapterList[index]; ! 314: priv->adapterRev = rev; ! 315: priv->aui = aui; ! 316: if ( ( duplex != 1 ) && ( duplex != 2 ) ) { ! 317: duplex = 0; ! 318: } ! 319: priv->duplex = duplex; ! 320: if ( ( speed != 10 ) && ( speed != 100 ) ) { ! 321: speed = 0; ! 322: } ! 323: priv->speed = speed; ! 324: priv->sa_int = sa_int; ! 325: priv->debug = debug; ! 326: ! 327: ether_setup( dev ); ! 328: ! 329: failed = register_netdev( dev ); ! 330: ! 331: if ( failed ) { ! 332: printk( "TLAN: Could not register device.\n" ); ! 333: kfree( dev ); ! 334: } else { ! 335: priv->nextDevice = TLanDevices; ! 336: TLanDevices = dev; ! 337: TLanDevicesInstalled++; ! 338: printk("TLAN: %s irq=%2d io=%04x, %s, Rev. %d\n", ! 339: dev->name, ! 340: (int) dev->irq, ! 341: (int) dev->base_addr, ! 342: priv->adapter->deviceLabel, ! 343: priv->adapterRev ); ! 344: } ! 345: } ! 346: ! 347: /* printk( "TLAN: Found %d device(s).\n", TLanDevicesInstalled ); */ ! 348: ! 349: return ( ( TLanDevicesInstalled >= 0 ) ? 0 : -ENODEV ); ! 350: ! 351: } /* init_module */ ! 352: ! 353: ! 354: ! 355: ! 356: /*************************************************************** ! 357: * cleanup_module ! 358: * ! 359: * Returns: ! 360: * Nothing ! 361: * Parms: ! 362: * None ! 363: * ! 364: * Goes through the TLanDevices list and frees the device ! 365: * structs and memory associated with each device (lists ! 366: * and buffers). It also ureserves the IO port regions ! 367: * associated with this device. ! 368: * ! 369: **************************************************************/ ! 370: ! 371: extern void cleanup_module(void) ! 372: { ! 373: struct device *dev; ! 374: TLanPrivateInfo *priv; ! 375: ! 376: while ( TLanDevicesInstalled ) { ! 377: dev = TLanDevices; ! 378: priv = (TLanPrivateInfo *) dev->priv; ! 379: if ( priv->dmaStorage ) { ! 380: kfree( priv->dmaStorage ); ! 381: } ! 382: release_region( dev->base_addr, 0x10 ); ! 383: unregister_netdev( dev ); ! 384: TLanDevices = priv->nextDevice; ! 385: kfree( dev ); ! 386: TLanDevicesInstalled--; ! 387: } ! 388: kfree( TLanPadBuffer ); ! 389: ! 390: } /* cleanup_module */ ! 391: ! 392: ! 393: #else /* MODULE */ ! 394: ! 395: ! 396: ! 397: ! 398: /*************************************************************** ! 399: * tlan_probe ! 400: * ! 401: * Returns: ! 402: * 0 on success, error code on error ! 403: * Parms: ! 404: * dev device struct to use if adapter is ! 405: * found. ! 406: * ! 407: * The name is lower case to fit in with all the rest of ! 408: * the netcard_probe names. This function looks for a/ ! 409: * another TLan based adapter, setting it up with the ! 410: * provided device struct if one is found. ! 411: * ! 412: **************************************************************/ ! 413: ! 414: extern int tlan_probe( struct device *dev ) ! 415: { ! 416: TLanPrivateInfo *priv; ! 417: static int pad_allocated = 0; ! 418: int found; ! 419: u8 bus, dfn, irq, rev; ! 420: u32 io_base, index; ! 421: ! 422: found = TLan_PciProbe( &bus, &dfn, &irq, &rev, &io_base, &index ); ! 423: ! 424: if ( ! found ) { ! 425: return -ENODEV; ! 426: } ! 427: ! 428: dev->priv = kmalloc( sizeof(TLanPrivateInfo), GFP_KERNEL ); ! 429: ! 430: if ( dev->priv == NULL ) { ! 431: printk( "TLAN: Could not allocate memory for device.\n" ); ! 432: return -ENOMEM; ! 433: } ! 434: ! 435: memset( dev->priv, 0, sizeof(TLanPrivateInfo) ); ! 436: ! 437: if ( ! pad_allocated ) { ! 438: TLanPadBuffer = (u8 *) kmalloc( TLAN_MIN_FRAME_SIZE, ! 439: // ( GFP_KERNEL | GFP_DMA ) ! 440: ( GFP_KERNEL ) ! 441: ); ! 442: if ( TLanPadBuffer == NULL ) { ! 443: printk( "TLAN: Could not allocate memory for padding.\n" ); ! 444: kfree( dev->priv ); ! 445: return -ENOMEM; ! 446: } else { ! 447: pad_allocated = 1; ! 448: memset( TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE ); ! 449: } ! 450: } ! 451: ! 452: priv = (TLanPrivateInfo *) dev->priv; ! 453: ! 454: dev->name = priv->devName; ! 455: strcpy( priv->devName, " " ); ! 456: ! 457: dev = init_etherdev( dev, sizeof(TLanPrivateInfo) ); ! 458: ! 459: dev->base_addr = io_base; ! 460: dev->irq = irq; ! 461: ! 462: ! 463: priv->adapter = &TLanAdapterList[index]; ! 464: priv->adapterRev = rev; ! 465: priv->aui = dev->mem_start & 0x01; ! 466: priv->duplex = ( ( dev->mem_start & 0x0C ) == 0x0C ) ? 0 : ( dev->mem_start & 0x0C ) >> 2; ! 467: priv->speed = ( ( dev->mem_start & 0x30 ) == 0x30 ) ? 0 : ( dev->mem_start & 0x30 ) >> 4; ! 468: if ( priv->speed == 0x1 ) { ! 469: priv->speed = TLAN_SPEED_10; ! 470: } else if ( priv->speed == 0x2 ) { ! 471: priv->speed = TLAN_SPEED_100; ! 472: } ! 473: priv->sa_int = dev->mem_start & 0x02; ! 474: priv->debug = dev->mem_end; ! 475: ! 476: ! 477: printk("TLAN %d.%d: %s irq=%2d io=%04x, %s, Rev. %d\n", ! 478: TLanVersionMajor, ! 479: TLanVersionMinor, ! 480: dev->name, ! 481: (int) irq, ! 482: io_base, ! 483: priv->adapter->deviceLabel, ! 484: priv->adapterRev ); ! 485: ! 486: TLan_Init( dev ); ! 487: ! 488: return 0; ! 489: ! 490: } /* tlan_probe */ ! 491: ! 492: ! 493: #endif /* MODULE */ ! 494: ! 495: ! 496: ! 497: ! 498: /*************************************************************** ! 499: * TLan_PciProbe ! 500: * ! 501: * Returns: ! 502: * 1 if another TLAN card was found, 0 if not. ! 503: * Parms: ! 504: * pci_bus The PCI bus the card was found ! 505: * on. ! 506: * pci_dfn The PCI whatever the card was ! 507: * found at. ! 508: * pci_irq The IRQ of the found adapter. ! 509: * pci_rev The revision of the adapter. ! 510: * pci_io_base The first IO port used by the ! 511: * adapter. ! 512: * dl_ix The index in the device list ! 513: * of the adapter. ! 514: * ! 515: * This function searches for an adapter with PCI vendor ! 516: * and device IDs matching those in the TLanAdapterList. ! 517: * The function 'remembers' the last device it found, ! 518: * and so finds a new device (if anymore are to be found) ! 519: * each time the function is called. It then looks up ! 520: * pertinent PCI info and returns it to the caller. ! 521: * ! 522: **************************************************************/ ! 523: ! 524: int TLan_PciProbe( u8 *pci_bus, u8 *pci_dfn, u8 *pci_irq, u8 *pci_rev, u32 *pci_io_base, u32 *dl_ix ) ! 525: { ! 526: static int dl_index = 0; ! 527: static int pci_index = 0; ! 528: ! 529: int not_found; ! 530: u8 pci_latency; ! 531: u16 pci_command; ! 532: int reg; ! 533: ! 534: ! 535: if ( ! pcibios_present() ) { ! 536: printk( "TLAN: PCI Bios not present.\n" ); ! 537: return 0; ! 538: } ! 539: ! 540: for (; TLanAdapterList[dl_index].vendorId != 0; dl_index++) { ! 541: ! 542: not_found = pcibios_find_device( ! 543: TLanAdapterList[dl_index].vendorId, ! 544: TLanAdapterList[dl_index].deviceId, ! 545: pci_index, ! 546: pci_bus, ! 547: pci_dfn ! 548: ); ! 549: ! 550: if ( ! not_found ) { ! 551: ! 552: TLAN_DBG( ! 553: TLAN_DEBUG_GNRL, ! 554: "TLAN: found: Vendor Id = 0x%hx, Device Id = 0x%hx\n", ! 555: TLanAdapterList[dl_index].vendorId, ! 556: TLanAdapterList[dl_index].deviceId ! 557: ); ! 558: ! 559: pcibios_read_config_byte ( *pci_bus, *pci_dfn, PCI_REVISION_ID, pci_rev); ! 560: pcibios_read_config_byte ( *pci_bus, *pci_dfn, PCI_INTERRUPT_LINE, pci_irq); ! 561: pcibios_read_config_word ( *pci_bus, *pci_dfn, PCI_COMMAND, &pci_command); ! 562: pcibios_read_config_dword( *pci_bus, *pci_dfn, PCI_BASE_ADDRESS_0, pci_io_base); ! 563: pcibios_read_config_byte ( *pci_bus, *pci_dfn, PCI_LATENCY_TIMER, &pci_latency); ! 564: ! 565: if (pci_latency < 0x10) { ! 566: pcibios_write_config_byte( *pci_bus, *pci_dfn, PCI_LATENCY_TIMER, 0xff); ! 567: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: Setting latency timer to max.\n"); ! 568: } ! 569: ! 570: for ( reg = PCI_BASE_ADDRESS_0; reg <= PCI_BASE_ADDRESS_5; reg +=4 ) { ! 571: pcibios_read_config_dword( *pci_bus, *pci_dfn, reg, pci_io_base); ! 572: if ((pci_command & PCI_COMMAND_IO) && (*pci_io_base & 0x3)) { ! 573: *pci_io_base &= PCI_BASE_ADDRESS_IO_MASK; ! 574: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: IO mapping is available at %x.\n", *pci_io_base); ! 575: break; ! 576: } else { ! 577: *pci_io_base = 0; ! 578: } ! 579: } ! 580: ! 581: if ( *pci_io_base == 0 ) ! 582: printk("TLAN: IO mapping not available, ignoring device.\n"); ! 583: ! 584: if ( ! ( pci_command & PCI_COMMAND_MASTER ) ) { ! 585: pcibios_write_config_word ( *pci_bus, *pci_dfn, PCI_COMMAND, pci_command | PCI_COMMAND_MASTER ); ! 586: printk( "TLAN: Activating PCI bus mastering for this device.\n" ); ! 587: } ! 588: ! 589: pci_index++; ! 590: ! 591: if ( *pci_io_base ) { ! 592: *dl_ix = dl_index; ! 593: return 1; ! 594: } ! 595: ! 596: } else { ! 597: pci_index = 0; ! 598: } ! 599: } ! 600: ! 601: return 0; ! 602: ! 603: } /* TLan_PciProbe */ ! 604: ! 605: ! 606: ! 607: ! 608: /*************************************************************** ! 609: * TLan_Init ! 610: * ! 611: * Returns: ! 612: * 0 on success, error code otherwise. ! 613: * Parms: ! 614: * dev The structure of the device to be ! 615: * init'ed. ! 616: * ! 617: * This function completes the initialization of the ! 618: * device structure and driver. It reserves the IO ! 619: * addresses, allocates memory for the lists and bounce ! 620: * buffers, retrieves the MAC address from the eeprom ! 621: * and assignes the device's methods. ! 622: * ! 623: **************************************************************/ ! 624: ! 625: int TLan_Init( struct device *dev ) ! 626: { ! 627: int dma_size; ! 628: int err; ! 629: int i; ! 630: TLanPrivateInfo *priv; ! 631: ! 632: priv = (TLanPrivateInfo *) dev->priv; ! 633: ! 634: err = check_region( dev->base_addr, 0x10 ); ! 635: if ( err ) { ! 636: printk( "TLAN: %s: Io port region 0x%lx size 0x%x in use.\n", ! 637: dev->name, ! 638: dev->base_addr, ! 639: 0x10 ); ! 640: return -EIO; ! 641: } ! 642: request_region( dev->base_addr, 0x10, TLanSignature ); ! 643: ! 644: if ( bbuf ) { ! 645: dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS ) ! 646: * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE ); ! 647: } else { ! 648: dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS ) ! 649: * ( sizeof(TLanList) ); ! 650: } ! 651: ! 652: priv->dmaStorage = kmalloc( dma_size, GFP_KERNEL | GFP_DMA ); ! 653: if ( priv->dmaStorage == NULL ) { ! 654: printk( "TLAN: Could not allocate lists and buffers for %s.\n", ! 655: dev->name ); ! 656: return -ENOMEM; ! 657: } ! 658: memset( priv->dmaStorage, 0, dma_size ); ! 659: priv->rxList = (TLanList *) ! 660: ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 ); ! 661: priv->txList = priv->rxList + TLAN_NUM_RX_LISTS; ! 662: ! 663: if ( bbuf ) { ! 664: priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS ); ! 665: priv->txBuffer = priv->rxBuffer ! 666: + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE ); ! 667: } ! 668: ! 669: err = 0; ! 670: for ( i = 0; i < 6 ; i++ ) ! 671: err |= TLan_EeReadByte( dev, ! 672: (u8) priv->adapter->addrOfs + i, ! 673: (u8 *) &dev->dev_addr[i] ); ! 674: if ( err ) { ! 675: printk( "TLAN: %s: Error reading MAC from eeprom: %d\n", ! 676: dev->name, ! 677: err ); ! 678: } ! 679: ! 680: dev->addr_len = 6; ! 681: ! 682: dev->open = &TLan_Open; ! 683: dev->hard_start_xmit = &TLan_StartTx; ! 684: dev->stop = &TLan_Close; ! 685: dev->get_stats = &TLan_GetStats; ! 686: dev->set_multicast_list = &TLan_SetMulticastList; ! 687: ! 688: ! 689: return 0; ! 690: ! 691: } /* TLan_Init */ ! 692: ! 693: ! 694: ! 695: ! 696: /*************************************************************** ! 697: * TLan_Open ! 698: * ! 699: * Returns: ! 700: * 0 on success, error code otherwise. ! 701: * Parms: ! 702: * dev Structure of device to be opened. ! 703: * ! 704: * This routine puts the driver and TLAN adapter in a ! 705: * state where it is ready to send and receive packets. ! 706: * It allocates the IRQ, resets and brings the adapter ! 707: * out of reset, and allows interrupts. It also delays ! 708: * the startup for autonegotiation or sends a Rx GO ! 709: * command to the adapter, as appropriate. ! 710: * ! 711: **************************************************************/ ! 712: ! 713: int TLan_Open( struct device *dev ) ! 714: { ! 715: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 716: int err; ! 717: ! 718: priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION ); ! 719: if ( priv->sa_int ) { ! 720: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: Using SA_INTERRUPT\n" ); ! 721: err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ | SA_INTERRUPT, TLanSignature, dev ); ! 722: } else { ! 723: err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, TLanSignature, dev ); ! 724: } ! 725: if ( err ) { ! 726: printk( "TLAN: Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq ); ! 727: return -EAGAIN; ! 728: } ! 729: ! 730: MOD_INC_USE_COUNT; ! 731: ! 732: dev->tbusy = 0; ! 733: dev->interrupt = 0; ! 734: dev->start = 1; ! 735: ! 736: /* NOTE: It might not be necessary to read the stats before a ! 737: reset if you don't care what the values are. ! 738: */ ! 739: TLan_ResetLists( dev ); ! 740: TLan_ReadAndClearStats( dev, TLAN_IGNORE ); ! 741: TLan_ResetAdapter( dev ); ! 742: ! 743: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Opened. TLAN Chip Rev: %x\n", dev->name, priv->tlanRev ); ! 744: ! 745: return 0; ! 746: ! 747: } /* TLan_Open */ ! 748: ! 749: ! 750: ! 751: ! 752: /*************************************************************** ! 753: * TLan_StartTx ! 754: * ! 755: * Returns: ! 756: * 0 on success, non-zero on failure. ! 757: * Parms: ! 758: * skb A pointer to the sk_buff containing the ! 759: * frame to be sent. ! 760: * dev The device to send the data on. ! 761: * ! 762: * This function adds a frame to the Tx list to be sent ! 763: * ASAP. First it verifies that the adapter is ready and ! 764: * there is room in the queue. Then it sets up the next ! 765: * available list, copies the frame to the corresponding ! 766: * buffer. If the adapter Tx channel is idle, it gives ! 767: * the adapter a Tx Go command on the list, otherwise it ! 768: * sets the forward address of the previous list to point ! 769: * to this one. Then it frees the sk_buff. ! 770: * ! 771: **************************************************************/ ! 772: ! 773: int TLan_StartTx( struct sk_buff *skb, struct device *dev ) ! 774: { ! 775: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 776: TLanList *tail_list; ! 777: u8 *tail_buffer; ! 778: int pad; ! 779: ! 780: if ( ! priv->phyOnline ) { ! 781: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: %s PHY is not ready\n", dev->name ); ! 782: dev_kfree_skb( skb, FREE_WRITE ); ! 783: return 0; ! 784: } ! 785: ! 786: tail_list = priv->txList + priv->txTail; ! 787: ! 788: if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) { ! 789: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: %s is busy (Head=%d Tail=%d)\n", dev->name, priv->txHead, priv->txTail ); ! 790: dev->tbusy = 1; ! 791: priv->txBusyCount++; ! 792: return 1; ! 793: } ! 794: ! 795: tail_list->forward = 0; ! 796: ! 797: if ( bbuf ) { ! 798: tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE ); ! 799: memcpy( tail_buffer, skb->data, skb->len ); ! 800: } else { ! 801: tail_list->buffer[0].address = virt_to_bus( skb->data ); ! 802: tail_list->buffer[9].address = (u32) skb; ! 803: } ! 804: ! 805: pad = TLAN_MIN_FRAME_SIZE - skb->len; ! 806: ! 807: if ( pad > 0 ) { ! 808: tail_list->frameSize = (u16) skb->len + pad; ! 809: tail_list->buffer[0].count = (u32) skb->len; ! 810: tail_list->buffer[1].count = TLAN_LAST_BUFFER | (u32) pad; ! 811: tail_list->buffer[1].address = virt_to_bus( TLanPadBuffer ); ! 812: } else { ! 813: tail_list->frameSize = (u16) skb->len; ! 814: tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len; ! 815: tail_list->buffer[1].count = 0; ! 816: tail_list->buffer[1].address = 0; ! 817: } ! 818: ! 819: cli(); ! 820: tail_list->cStat = TLAN_CSTAT_READY; ! 821: if ( ! priv->txInProgress ) { ! 822: priv->txInProgress = 1; ! 823: outw( 0x4, dev->base_addr + TLAN_HOST_INT ); ! 824: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: Starting TX on buffer %d\n", priv->txTail ); ! 825: outl( virt_to_bus( tail_list ), dev->base_addr + TLAN_CH_PARM ); ! 826: outl( TLAN_HC_GO | TLAN_HC_ACK, dev->base_addr + TLAN_HOST_CMD ); ! 827: } else { ! 828: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: Adding buffer %d to TX channel\n", priv->txTail ); ! 829: if ( priv->txTail == 0 ) { ! 830: ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = virt_to_bus( tail_list ); ! 831: } else { ! 832: ( priv->txList + ( priv->txTail - 1 ) )->forward = virt_to_bus( tail_list ); ! 833: } ! 834: } ! 835: sti(); ! 836: ! 837: CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS ); ! 838: ! 839: if ( bbuf ) { ! 840: dev_kfree_skb( skb, FREE_WRITE ); ! 841: } ! 842: ! 843: dev->trans_start = jiffies; ! 844: return 0; ! 845: ! 846: } /* TLan_StartTx */ ! 847: ! 848: ! 849: ! 850: ! 851: /*************************************************************** ! 852: * TLan_HandleInterrupt ! 853: * ! 854: * Returns: ! 855: * Nothing ! 856: * Parms: ! 857: * irq The line on which the interrupt ! 858: * occurred. ! 859: * dev_id A pointer to the device assigned to ! 860: * this irq line. ! 861: * regs ??? ! 862: * ! 863: * This function handles an interrupt generated by its ! 864: * assigned TLAN adapter. The function deactivates ! 865: * interrupts on its adapter, records the type of ! 866: * interrupt, executes the appropriate subhandler, and ! 867: * acknowdges the interrupt to the adapter (thus ! 868: * re-enabling adapter interrupts. ! 869: * ! 870: **************************************************************/ ! 871: ! 872: void TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *regs) ! 873: { ! 874: u32 ack; ! 875: struct device *dev; ! 876: u32 host_cmd; ! 877: u16 host_int; ! 878: int type; ! 879: ! 880: dev = (struct device *) dev_id; ! 881: ! 882: cli(); ! 883: if ( dev->interrupt ) { ! 884: printk( "TLAN: Re-entering interrupt handler for %s: %d.\n" , dev->name, dev->interrupt ); ! 885: } ! 886: dev->interrupt++; ! 887: ! 888: host_int = inw( dev->base_addr + TLAN_HOST_INT ); ! 889: outw( host_int, dev->base_addr + TLAN_HOST_INT ); ! 890: ! 891: type = ( host_int & TLAN_HI_IT_MASK ) >> 2; ! 892: ! 893: ack = TLanIntVector[type]( dev, host_int ); ! 894: ! 895: if ( ack ) { ! 896: host_cmd = TLAN_HC_ACK | ack | ( type << 18 ); ! 897: outl( host_cmd, dev->base_addr + TLAN_HOST_CMD ); ! 898: } ! 899: ! 900: dev->interrupt--; ! 901: sti(); ! 902: ! 903: } /* TLan_HandleInterrupts */ ! 904: ! 905: ! 906: ! 907: ! 908: /*************************************************************** ! 909: * TLan_Close ! 910: * ! 911: * Returns: ! 912: * An error code. ! 913: * Parms: ! 914: * dev The device structure of the device to ! 915: * close. ! 916: * ! 917: * This function shuts down the adapter. It records any ! 918: * stats, puts the adapter into reset state, deactivates ! 919: * its time as needed, and frees the irq it is using. ! 920: * ! 921: **************************************************************/ ! 922: ! 923: int TLan_Close(struct device *dev) ! 924: { ! 925: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 926: ! 927: dev->start = 0; ! 928: dev->tbusy = 1; ! 929: ! 930: TLan_ReadAndClearStats( dev, TLAN_RECORD ); ! 931: outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD ); ! 932: if ( priv->timer.function != NULL ) ! 933: del_timer( &priv->timer ); ! 934: free_irq( dev->irq, dev ); ! 935: TLan_FreeLists( dev ); ! 936: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: Device %s closed.\n", dev->name ); ! 937: ! 938: MOD_DEC_USE_COUNT; ! 939: ! 940: return 0; ! 941: ! 942: } /* TLan_Close */ ! 943: ! 944: ! 945: ! 946: ! 947: /*************************************************************** ! 948: * TLan_GetStats ! 949: * ! 950: * Returns: ! 951: * A pointer to the device's statistics structure. ! 952: * Parms: ! 953: * dev The device structure to return the ! 954: * stats for. ! 955: * ! 956: * This function updates the devices statistics by reading ! 957: * the TLAN chip's onboard registers. Then it returns the ! 958: * address of the statistics structure. ! 959: * ! 960: **************************************************************/ ! 961: ! 962: struct net_device_stats *TLan_GetStats( struct device *dev ) ! 963: { ! 964: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 965: int i; ! 966: ! 967: /* Should only read stats if open ? */ ! 968: TLan_ReadAndClearStats( dev, TLAN_RECORD ); ! 969: ! 970: TLAN_DBG( TLAN_DEBUG_RX, "TLAN RECEIVE: %s EOC count = %d\n", dev->name, priv->rxEocCount ); ! 971: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: %s Busy count = %d\n", dev->name, priv->txBusyCount ); ! 972: if ( debug & TLAN_DEBUG_GNRL ) { ! 973: TLan_PrintDio( dev->base_addr ); ! 974: TLan_PhyPrint( dev ); ! 975: } ! 976: if ( debug & TLAN_DEBUG_LIST ) { ! 977: for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) ! 978: TLan_PrintList( priv->rxList + i, "RX", i ); ! 979: for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) ! 980: TLan_PrintList( priv->txList + i, "TX", i ); ! 981: } ! 982: ! 983: return ( &( (TLanPrivateInfo *) dev->priv )->stats ); ! 984: ! 985: } /* TLan_GetStats */ ! 986: ! 987: ! 988: ! 989: ! 990: /*************************************************************** ! 991: * TLan_SetMulticastList ! 992: * ! 993: * Returns: ! 994: * Nothing ! 995: * Parms: ! 996: * dev The device structure to set the ! 997: * multicast list for. ! 998: * ! 999: * This function sets the TLAN adaptor to various receive ! 1000: * modes. If the IFF_PROMISC flag is set, promiscuous ! 1001: * mode is acitviated. Otherwise, promiscuous mode is ! 1002: * turned off. If the IFF_ALLMULTI flag is set, then ! 1003: * the hash table is set to receive all group addresses. ! 1004: * Otherwise, the first three multicast addresses are ! 1005: * stored in AREG_1-3, and the rest are selected via the ! 1006: * hash table, as necessary. ! 1007: * ! 1008: **************************************************************/ ! 1009: ! 1010: void TLan_SetMulticastList( struct device *dev ) ! 1011: { ! 1012: struct dev_mc_list *dmi = dev->mc_list; ! 1013: u32 hash1 = 0; ! 1014: u32 hash2 = 0; ! 1015: int i; ! 1016: u32 offset; ! 1017: u8 tmp; ! 1018: ! 1019: if ( dev->flags & IFF_PROMISC ) { ! 1020: tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD ); ! 1021: TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF ); ! 1022: } else { ! 1023: tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD ); ! 1024: TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF ); ! 1025: if ( dev->flags & IFF_ALLMULTI ) { ! 1026: for ( i = 0; i < 3; i++ ) ! 1027: TLan_SetMac( dev, i + 1, NULL ); ! 1028: TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF ); ! 1029: TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF ); ! 1030: } else { ! 1031: for ( i = 0; i < dev->mc_count; i++ ) { ! 1032: if ( i < 3 ) { ! 1033: TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr ); ! 1034: } else { ! 1035: offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr ); ! 1036: if ( offset < 32 ) ! 1037: hash1 |= ( 1 << offset ); ! 1038: else ! 1039: hash2 |= ( 1 << ( offset - 32 ) ); ! 1040: } ! 1041: dmi = dmi->next; ! 1042: } ! 1043: for ( ; i < 3; i++ ) ! 1044: TLan_SetMac( dev, i + 1, NULL ); ! 1045: TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 ); ! 1046: TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 ); ! 1047: } ! 1048: } ! 1049: ! 1050: } /* TLan_SetMulticastList */ ! 1051: ! 1052: ! 1053: ! 1054: /***************************************************************************** ! 1055: ****************************************************************************** ! 1056: ! 1057: ThunderLAN Driver Interrupt Vectors and Table ! 1058: ! 1059: Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN ! 1060: Programmer's Guide" for more informations on handling interrupts ! 1061: generated by TLAN based adapters. ! 1062: ! 1063: ****************************************************************************** ! 1064: *****************************************************************************/ ! 1065: ! 1066: ! 1067: /*************************************************************** ! 1068: * TLan_HandleInvalid ! 1069: * ! 1070: * Returns: ! 1071: * 0 ! 1072: * Parms: ! 1073: * dev Device assigned the IRQ that was ! 1074: * raised. ! 1075: * host_int The contents of the HOST_INT ! 1076: * port. ! 1077: * ! 1078: * This function handles invalid interrupts. This should ! 1079: * never happen unless some other adapter is trying to use ! 1080: * the IRQ line assigned to the device. ! 1081: * ! 1082: **************************************************************/ ! 1083: ! 1084: u32 TLan_HandleInvalid( struct device *dev, u16 host_int ) ! 1085: { ! 1086: host_int = 0; ! 1087: /* printk( "TLAN: Invalid interrupt on %s.\n", dev->name ); */ ! 1088: return 0; ! 1089: ! 1090: } /* TLan_HandleInvalid */ ! 1091: ! 1092: ! 1093: ! 1094: ! 1095: /*************************************************************** ! 1096: * TLan_HandleTxEOF ! 1097: * ! 1098: * Returns: ! 1099: * 1 ! 1100: * Parms: ! 1101: * dev Device assigned the IRQ that was ! 1102: * raised. ! 1103: * host_int The contents of the HOST_INT ! 1104: * port. ! 1105: * ! 1106: * This function handles Tx EOF interrupts which are raised ! 1107: * by the adapter when it has completed sending the ! 1108: * contents of a buffer. If detemines which list/buffer ! 1109: * was completed and resets it. If the buffer was the last ! 1110: * in the channel (EOC), then the function checks to see if ! 1111: * another buffer is ready to send, and if so, sends a Tx ! 1112: * Go command. Finally, the driver activates/continues the ! 1113: * activity LED. ! 1114: * ! 1115: **************************************************************/ ! 1116: ! 1117: u32 TLan_HandleTxEOF( struct device *dev, u16 host_int ) ! 1118: { ! 1119: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1120: int eoc = 0; ! 1121: TLanList *head_list; ! 1122: u32 ack = 1; ! 1123: ! 1124: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n", priv->txHead, priv->txTail ); ! 1125: host_int = 0; ! 1126: head_list = priv->txList + priv->txHead; ! 1127: ! 1128: if ( ! bbuf ) { ! 1129: dev_kfree_skb( (struct sk_buff *) head_list->buffer[9].address, FREE_WRITE ); ! 1130: head_list->buffer[9].address = 0; ! 1131: } ! 1132: ! 1133: if ( head_list->cStat & TLAN_CSTAT_EOC ) ! 1134: eoc = 1; ! 1135: if ( ! head_list->cStat & TLAN_CSTAT_FRM_CMP ) { ! 1136: printk( "TLAN: Received interrupt for uncompleted TX frame.\n" ); ! 1137: } ! 1138: ! 1139: #if LINUX_KERNEL_VERSION > 0x20100 ! 1140: priv->stats->tx_bytes += head_list->frameSize; ! 1141: #endif ! 1142: ! 1143: head_list->cStat = TLAN_CSTAT_UNUSED; ! 1144: dev->tbusy = 0; ! 1145: CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS ); ! 1146: if ( eoc ) { ! 1147: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: Handling TX EOC (Head=%d Tail=%d)\n", priv->txHead, priv->txTail ); ! 1148: head_list = priv->txList + priv->txHead; ! 1149: if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) { ! 1150: outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM ); ! 1151: ack |= TLAN_HC_GO; ! 1152: } else { ! 1153: priv->txInProgress = 0; ! 1154: } ! 1155: } ! 1156: ! 1157: if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) { ! 1158: TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT ); ! 1159: if ( priv->timer.function == NULL ) { ! 1160: TLan_SetTimer( dev, TLAN_TIMER_ACT_DELAY, TLAN_TIMER_ACTIVITY ); ! 1161: } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) { ! 1162: priv->timerSetAt = jiffies; ! 1163: } ! 1164: } ! 1165: ! 1166: return ack; ! 1167: ! 1168: } /* TLan_HandleTxEOF */ ! 1169: ! 1170: ! 1171: ! 1172: ! 1173: /*************************************************************** ! 1174: * TLan_HandleStatOverflow ! 1175: * ! 1176: * Returns: ! 1177: * 1 ! 1178: * Parms: ! 1179: * dev Device assigned the IRQ that was ! 1180: * raised. ! 1181: * host_int The contents of the HOST_INT ! 1182: * port. ! 1183: * ! 1184: * This function handles the Statistics Overflow interrupt ! 1185: * which means that one or more of the TLAN statistics ! 1186: * registers has reached 1/2 capacity and needs to be read. ! 1187: * ! 1188: **************************************************************/ ! 1189: ! 1190: u32 TLan_HandleStatOverflow( struct device *dev, u16 host_int ) ! 1191: { ! 1192: host_int = 0; ! 1193: TLan_ReadAndClearStats( dev, TLAN_RECORD ); ! 1194: ! 1195: return 1; ! 1196: ! 1197: } /* TLan_HandleStatOverflow */ ! 1198: ! 1199: ! 1200: ! 1201: ! 1202: /*************************************************************** ! 1203: * TLan_HandleRxEOF ! 1204: * ! 1205: * Returns: ! 1206: * 1 ! 1207: * Parms: ! 1208: * dev Device assigned the IRQ that was ! 1209: * raised. ! 1210: * host_int The contents of the HOST_INT ! 1211: * port. ! 1212: * ! 1213: * This function handles the Rx EOF interrupt which ! 1214: * indicates a frame has been received by the adapter from ! 1215: * the net and the frame has been transferred to memory. ! 1216: * The function determines the bounce buffer the frame has ! 1217: * been loaded into, creates a new sk_buff big enough to ! 1218: * hold the frame, and sends it to protocol stack. It ! 1219: * then resets the used buffer and appends it to the end ! 1220: * of the list. If the frame was the last in the Rx ! 1221: * channel (EOC), the function restarts the receive channel ! 1222: * by sending an Rx Go command to the adapter. Then it ! 1223: * activates/continues the activity LED. ! 1224: * ! 1225: **************************************************************/ ! 1226: ! 1227: u32 TLan_HandleRxEOF( struct device *dev, u16 host_int ) ! 1228: { ! 1229: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1230: u32 ack = 1; ! 1231: int eoc = 0; ! 1232: u8 *head_buffer; ! 1233: TLanList *head_list; ! 1234: struct sk_buff *skb; ! 1235: TLanList *tail_list; ! 1236: void *t; ! 1237: ! 1238: TLAN_DBG( TLAN_DEBUG_RX, "TLAN RECEIVE: Handling RX EOF (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail ); ! 1239: host_int = 0; ! 1240: head_list = priv->rxList + priv->rxHead; ! 1241: tail_list = priv->rxList + priv->rxTail; ! 1242: ! 1243: if ( head_list->cStat & TLAN_CSTAT_EOC ) { ! 1244: eoc = 1; ! 1245: } ! 1246: ! 1247: if ( ! head_list->cStat & TLAN_CSTAT_FRM_CMP ) { ! 1248: printk( "TLAN: Received interrupt for uncompleted RX frame.\n" ); ! 1249: } else if ( bbuf ) { ! 1250: skb = dev_alloc_skb( head_list->frameSize + 7 ); ! 1251: if ( skb == NULL ) { ! 1252: printk( "TLAN: Couldn't allocate memory for received data.\n" ); ! 1253: } else { ! 1254: head_buffer = priv->rxBuffer + ( priv->rxHead * TLAN_MAX_FRAME_SIZE ); ! 1255: skb->dev = dev; ! 1256: skb_reserve( skb, 2 ); ! 1257: t = (void *) skb_put( skb, head_list->frameSize ); ! 1258: ! 1259: #if LINUX_KERNEL_VERSION > 0x20100 ! 1260: priv->stats->rx_bytes += head_list->frameSize; ! 1261: #endif ! 1262: ! 1263: memcpy( t, head_buffer, head_list->frameSize ); ! 1264: skb->protocol = eth_type_trans( skb, dev ); ! 1265: netif_rx( skb ); ! 1266: } ! 1267: } else { ! 1268: skb = (struct sk_buff *) head_list->buffer[9].address; ! 1269: head_list->buffer[9].address = 0; ! 1270: skb_trim( skb, head_list->frameSize ); ! 1271: ! 1272: #if LINUX_KERNEL_VERSION > 0x20100 ! 1273: priv->stats->rx_bytes += head_list->frameSize; ! 1274: #endif ! 1275: ! 1276: skb->protocol = eth_type_trans( skb, dev ); ! 1277: netif_rx( skb ); ! 1278: ! 1279: skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 ); ! 1280: if ( skb == NULL ) { ! 1281: printk( "TLAN: Couldn't allocate memory for received data.\n" ); ! 1282: /* If this ever happened it would be a problem */ ! 1283: } else { ! 1284: skb->dev = dev; ! 1285: skb_reserve( skb, 2 ); ! 1286: t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE ); ! 1287: head_list->buffer[0].address = virt_to_bus( t ); ! 1288: head_list->buffer[9].address = (u32) skb; ! 1289: } ! 1290: } ! 1291: ! 1292: head_list->forward = 0; ! 1293: head_list->frameSize = TLAN_MAX_FRAME_SIZE; ! 1294: head_list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER; ! 1295: tail_list->forward = virt_to_bus( head_list ); ! 1296: ! 1297: CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS ); ! 1298: CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS ); ! 1299: ! 1300: if ( eoc ) { ! 1301: TLAN_DBG( TLAN_DEBUG_RX, "TLAN RECEIVE: Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail ); ! 1302: head_list = priv->rxList + priv->rxHead; ! 1303: outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM ); ! 1304: ack |= TLAN_HC_GO | TLAN_HC_RT; ! 1305: priv->rxEocCount++; ! 1306: } ! 1307: ! 1308: if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) { ! 1309: TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT ); ! 1310: if ( priv->timer.function == NULL ) { ! 1311: TLan_SetTimer( dev, TLAN_TIMER_ACT_DELAY, TLAN_TIMER_ACTIVITY ); ! 1312: } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) { ! 1313: priv->timerSetAt = jiffies; ! 1314: } ! 1315: } ! 1316: ! 1317: dev->last_rx = jiffies; ! 1318: ! 1319: return ack; ! 1320: ! 1321: } /* TLan_HandleRxEOF */ ! 1322: ! 1323: ! 1324: ! 1325: ! 1326: /*************************************************************** ! 1327: * TLan_HandleDummy ! 1328: * ! 1329: * Returns: ! 1330: * 1 ! 1331: * Parms: ! 1332: * dev Device assigned the IRQ that was ! 1333: * raised. ! 1334: * host_int The contents of the HOST_INT ! 1335: * port. ! 1336: * ! 1337: * This function handles the Dummy interrupt, which is ! 1338: * raised whenever a test interrupt is generated by setting ! 1339: * the Req_Int bit of HOST_CMD to 1. ! 1340: * ! 1341: **************************************************************/ ! 1342: ! 1343: u32 TLan_HandleDummy( struct device *dev, u16 host_int ) ! 1344: { ! 1345: host_int = 0; ! 1346: printk( "TLAN: Test interrupt on %s.\n", dev->name ); ! 1347: return 1; ! 1348: ! 1349: } /* TLan_HandleDummy */ ! 1350: ! 1351: ! 1352: ! 1353: ! 1354: /*************************************************************** ! 1355: * TLan_HandleTxEOC ! 1356: * ! 1357: * Returns: ! 1358: * 1 ! 1359: * Parms: ! 1360: * dev Device assigned the IRQ that was ! 1361: * raised. ! 1362: * host_int The contents of the HOST_INT ! 1363: * port. ! 1364: * ! 1365: * This driver is structured to determine EOC occurances by ! 1366: * reading the CSTAT member of the list structure. Tx EOC ! 1367: * interrupts are disabled via the DIO INTDIS register. ! 1368: * However, TLAN chips before revision 3.0 didn't have this ! 1369: * functionality, so process EOC events if this is the ! 1370: * case. ! 1371: * ! 1372: **************************************************************/ ! 1373: ! 1374: u32 TLan_HandleTxEOC( struct device *dev, u16 host_int ) ! 1375: { ! 1376: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1377: TLanList *head_list; ! 1378: u32 ack = 1; ! 1379: ! 1380: host_int = 0; ! 1381: if ( priv->tlanRev < 0x30 ) { ! 1382: TLAN_DBG( TLAN_DEBUG_TX, "TLAN TRANSMIT: Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail ); ! 1383: head_list = priv->txList + priv->txHead; ! 1384: if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) { ! 1385: outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM ); ! 1386: ack |= TLAN_HC_GO; ! 1387: } else { ! 1388: priv->txInProgress = 0; ! 1389: } ! 1390: } ! 1391: ! 1392: return ack; ! 1393: ! 1394: } /* TLan_HandleTxEOC */ ! 1395: ! 1396: ! 1397: ! 1398: ! 1399: /*************************************************************** ! 1400: * TLan_HandleStatusCheck ! 1401: * ! 1402: * Returns: ! 1403: * 0 if Adapter check, 1 if Network Status check. ! 1404: * Parms: ! 1405: * dev Device assigned the IRQ that was ! 1406: * raised. ! 1407: * host_int The contents of the HOST_INT ! 1408: * port. ! 1409: * ! 1410: * This function handles Adapter Check/Network Status ! 1411: * interrupts generated by the adapter. It checks the ! 1412: * vector in the HOST_INT register to determine if it is ! 1413: * an Adapter Check interrupt. If so, it resets the ! 1414: * adapter. Otherwise it clears the status registers ! 1415: * and services the PHY. ! 1416: * ! 1417: **************************************************************/ ! 1418: ! 1419: u32 TLan_HandleStatusCheck( struct device *dev, u16 host_int ) ! 1420: { ! 1421: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1422: u32 ack; ! 1423: u32 error; ! 1424: u8 net_sts; ! 1425: u32 phy; ! 1426: u16 tlphy_ctl; ! 1427: u16 tlphy_sts; ! 1428: ! 1429: ack = 1; ! 1430: if ( host_int & TLAN_HI_IV_MASK ) { ! 1431: error = inl( dev->base_addr + TLAN_CH_PARM ); ! 1432: printk( "TLAN: %s: Adaptor Error = 0x%x\n", dev->name, error ); ! 1433: TLan_ReadAndClearStats( dev, TLAN_RECORD ); ! 1434: outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD ); ! 1435: TLan_FreeLists( dev ); ! 1436: TLan_ResetLists( dev ); ! 1437: TLan_ResetAdapter( dev ); ! 1438: dev->tbusy = 0; ! 1439: ack = 0; ! 1440: } else { ! 1441: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Status Check\n", dev->name ); ! 1442: phy = priv->phy[priv->phyNum]; ! 1443: ! 1444: net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS ); ! 1445: if ( net_sts ) { ! 1446: TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts ); ! 1447: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Net_Sts = %x\n", dev->name, (unsigned) net_sts ); ! 1448: } ! 1449: if ( ( net_sts & TLAN_NET_STS_MIRQ ) && ( priv->phyNum == 0 ) ) { ! 1450: TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts ); ! 1451: TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl ); ! 1452: if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) { ! 1453: tlphy_ctl |= TLAN_TC_SWAPOL; ! 1454: TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl); ! 1455: } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) { ! 1456: tlphy_ctl &= ~TLAN_TC_SWAPOL; ! 1457: TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl); ! 1458: } ! 1459: ! 1460: if (debug) { ! 1461: TLan_PhyPrint( dev ); ! 1462: } ! 1463: } ! 1464: } ! 1465: ! 1466: return ack; ! 1467: ! 1468: } /* TLan_HandleStatusCheck */ ! 1469: ! 1470: ! 1471: ! 1472: ! 1473: /*************************************************************** ! 1474: * TLan_HandleRxEOC ! 1475: * ! 1476: * Returns: ! 1477: * 1 ! 1478: * Parms: ! 1479: * dev Device assigned the IRQ that was ! 1480: * raised. ! 1481: * host_int The contents of the HOST_INT ! 1482: * port. ! 1483: * ! 1484: * This driver is structured to determine EOC occurances by ! 1485: * reading the CSTAT member of the list structure. Rx EOC ! 1486: * interrupts are disabled via the DIO INTDIS register. ! 1487: * However, TLAN chips before revision 3.0 didn't have this ! 1488: * CSTAT member or a INTDIS register, so if this chip is ! 1489: * pre-3.0, process EOC interrupts normally. ! 1490: * ! 1491: **************************************************************/ ! 1492: ! 1493: u32 TLan_HandleRxEOC( struct device *dev, u16 host_int ) ! 1494: { ! 1495: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1496: TLanList *head_list; ! 1497: u32 ack = 1; ! 1498: ! 1499: host_int = 0; ! 1500: if ( priv->tlanRev < 0x30 ) { ! 1501: TLAN_DBG( TLAN_DEBUG_RX, "TLAN RECEIVE: Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail ); ! 1502: head_list = priv->rxList + priv->rxHead; ! 1503: outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM ); ! 1504: ack |= TLAN_HC_GO | TLAN_HC_RT; ! 1505: priv->rxEocCount++; ! 1506: } ! 1507: ! 1508: return ack; ! 1509: ! 1510: } /* TLan_HandleRxEOC */ ! 1511: ! 1512: ! 1513: ! 1514: ! 1515: /***************************************************************************** ! 1516: ****************************************************************************** ! 1517: ! 1518: ThunderLAN Driver Timer Function ! 1519: ! 1520: ****************************************************************************** ! 1521: *****************************************************************************/ ! 1522: ! 1523: ! 1524: /*************************************************************** ! 1525: * TLan_Timer ! 1526: * ! 1527: * Returns: ! 1528: * Nothing ! 1529: * Parms: ! 1530: * data A value given to add timer when ! 1531: * add_timer was called. ! 1532: * ! 1533: * This function handles timed functionality for the ! 1534: * TLAN driver. The two current timer uses are for ! 1535: * delaying for autonegotionation and driving the ACT LED. ! 1536: * - Autonegotiation requires being allowed about ! 1537: * 2 1/2 seconds before attempting to transmit a ! 1538: * packet. It would be a very bad thing to hang ! 1539: * the kernel this long, so the driver doesn't ! 1540: * allow transmission 'til after this time, for ! 1541: * certain PHYs. It would be much nicer if all ! 1542: * PHYs were interrupt-capable like the internal ! 1543: * PHY. ! 1544: * - The ACT LED, which shows adapter activity, is ! 1545: * driven by the driver, and so must be left on ! 1546: * for a short period to power up the LED so it ! 1547: * can be seen. This delay can be changed by ! 1548: * changing the TLAN_TIMER_ACT_DELAY in tlan.h, ! 1549: * if desired. 10 jiffies produces a slightly ! 1550: * sluggish response. ! 1551: * ! 1552: **************************************************************/ ! 1553: ! 1554: void TLan_Timer( unsigned long data ) ! 1555: { ! 1556: struct device *dev = (struct device *) data; ! 1557: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1558: u32 elapsed; ! 1559: ! 1560: priv->timer.function = NULL; ! 1561: ! 1562: switch ( priv->timerType ) { ! 1563: case TLAN_TIMER_PHY_PDOWN: ! 1564: TLan_PhyPowerDown( dev ); ! 1565: break; ! 1566: case TLAN_TIMER_PHY_PUP: ! 1567: TLan_PhyPowerUp( dev ); ! 1568: break; ! 1569: case TLAN_TIMER_PHY_RESET: ! 1570: TLan_PhyReset( dev ); ! 1571: break; ! 1572: case TLAN_TIMER_PHY_START_LINK: ! 1573: TLan_PhyStartLink( dev ); ! 1574: break; ! 1575: case TLAN_TIMER_PHY_FINISH_AN: ! 1576: TLan_PhyFinishAutoNeg( dev ); ! 1577: break; ! 1578: case TLAN_TIMER_FINISH_RESET: ! 1579: TLan_FinishReset( dev ); ! 1580: break; ! 1581: case TLAN_TIMER_ACTIVITY: ! 1582: cli(); ! 1583: if ( priv->timer.function == NULL ) { ! 1584: elapsed = jiffies - priv->timerSetAt; ! 1585: if ( elapsed >= TLAN_TIMER_ACT_DELAY ) { ! 1586: TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK ); ! 1587: } else { ! 1588: priv->timer.function = &TLan_Timer; ! 1589: priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY; ! 1590: sti(); ! 1591: add_timer( &priv->timer ); ! 1592: } ! 1593: } ! 1594: sti(); ! 1595: break; ! 1596: default: ! 1597: break; ! 1598: } ! 1599: ! 1600: } /* TLan_Timer */ ! 1601: ! 1602: ! 1603: ! 1604: ! 1605: /***************************************************************************** ! 1606: ****************************************************************************** ! 1607: ! 1608: ThunderLAN Driver Adapter Related Routines ! 1609: ! 1610: ****************************************************************************** ! 1611: *****************************************************************************/ ! 1612: ! 1613: ! 1614: /*************************************************************** ! 1615: * TLan_ResetLists ! 1616: * ! 1617: * Returns: ! 1618: * Nothing ! 1619: * Parms: ! 1620: * dev The device structure with the list ! 1621: * stuctures to be reset. ! 1622: * ! 1623: * This routine sets the variables associated with managing ! 1624: * the TLAN lists to their initial values. ! 1625: * ! 1626: **************************************************************/ ! 1627: ! 1628: void TLan_ResetLists( struct device *dev ) ! 1629: { ! 1630: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1631: int i; ! 1632: TLanList *list; ! 1633: struct sk_buff *skb; ! 1634: void *t = NULL; ! 1635: ! 1636: priv->txHead = 0; ! 1637: priv->txTail = 0; ! 1638: for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) { ! 1639: list = priv->txList + i; ! 1640: list->cStat = TLAN_CSTAT_UNUSED; ! 1641: if ( bbuf ) { ! 1642: list->buffer[0].address = virt_to_bus( priv->txBuffer + ( i * TLAN_MAX_FRAME_SIZE ) ); ! 1643: } else { ! 1644: list->buffer[0].address = 0; ! 1645: } ! 1646: list->buffer[2].count = 0; ! 1647: list->buffer[2].address = 0; ! 1648: } ! 1649: ! 1650: priv->rxHead = 0; ! 1651: priv->rxTail = TLAN_NUM_RX_LISTS - 1; ! 1652: for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) { ! 1653: list = priv->rxList + i; ! 1654: list->cStat = TLAN_CSTAT_READY; ! 1655: list->frameSize = TLAN_MAX_FRAME_SIZE; ! 1656: list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER; ! 1657: if ( bbuf ) { ! 1658: list->buffer[0].address = virt_to_bus( priv->rxBuffer + ( i * TLAN_MAX_FRAME_SIZE ) ); ! 1659: } else { ! 1660: skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 ); ! 1661: if ( skb == NULL ) { ! 1662: printk( "TLAN: Couldn't allocate memory for received data.\n" ); ! 1663: /* If this ever happened it would be a problem */ ! 1664: } else { ! 1665: skb->dev = dev; ! 1666: skb_reserve( skb, 2 ); ! 1667: t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE ); ! 1668: } ! 1669: list->buffer[0].address = virt_to_bus( t ); ! 1670: list->buffer[9].address = (u32) skb; ! 1671: } ! 1672: list->buffer[1].count = 0; ! 1673: list->buffer[1].address = 0; ! 1674: if ( i < TLAN_NUM_RX_LISTS - 1 ) ! 1675: list->forward = virt_to_bus( list + 1 ); ! 1676: else ! 1677: list->forward = 0; ! 1678: } ! 1679: ! 1680: } /* TLan_ResetLists */ ! 1681: ! 1682: ! 1683: void TLan_FreeLists( struct device *dev ) ! 1684: { ! 1685: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1686: int i; ! 1687: TLanList *list; ! 1688: struct sk_buff *skb; ! 1689: ! 1690: if ( ! bbuf ) { ! 1691: for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) { ! 1692: list = priv->txList + i; ! 1693: skb = (struct sk_buff *) list->buffer[9].address; ! 1694: if ( skb ) { ! 1695: dev_kfree_skb( skb, FREE_WRITE ); ! 1696: list->buffer[9].address = 0; ! 1697: } ! 1698: } ! 1699: ! 1700: for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) { ! 1701: list = priv->rxList + i; ! 1702: skb = (struct sk_buff *) list->buffer[9].address; ! 1703: if ( skb ) { ! 1704: dev_kfree_skb( skb, FREE_READ ); ! 1705: list->buffer[9].address = 0; ! 1706: } ! 1707: } ! 1708: } ! 1709: ! 1710: } /* TLan_FreeLists */ ! 1711: ! 1712: ! 1713: ! 1714: ! 1715: /*************************************************************** ! 1716: * TLan_PrintDio ! 1717: * ! 1718: * Returns: ! 1719: * Nothing ! 1720: * Parms: ! 1721: * io_base Base IO port of the device of ! 1722: * which to print DIO registers. ! 1723: * ! 1724: * This function prints out all the internal (DIO) ! 1725: * registers of a TLAN chip. ! 1726: * ! 1727: **************************************************************/ ! 1728: ! 1729: void TLan_PrintDio( u16 io_base ) ! 1730: { ! 1731: u32 data0, data1; ! 1732: int i; ! 1733: ! 1734: printk( "TLAN: Contents of internal registers for io base 0x%04hx.\n", io_base ); ! 1735: printk( "TLAN: Off. +0 +4\n" ); ! 1736: for ( i = 0; i < 0x4C; i+= 8 ) { ! 1737: data0 = TLan_DioRead32( io_base, i ); ! 1738: data1 = TLan_DioRead32( io_base, i + 0x4 ); ! 1739: printk( "TLAN: 0x%02x 0x%08x 0x%08x\n", i, data0, data1 ); ! 1740: } ! 1741: ! 1742: } /* TLan_PrintDio */ ! 1743: ! 1744: ! 1745: ! 1746: ! 1747: /*************************************************************** ! 1748: * TLan_PrintList ! 1749: * ! 1750: * Returns: ! 1751: * Nothing ! 1752: * Parms: ! 1753: * list A pointer to the TLanList structure to ! 1754: * be printed. ! 1755: * type A string to designate type of list, ! 1756: * "Rx" or "Tx". ! 1757: * num The index of the list. ! 1758: * ! 1759: * This function prints out the contents of the list ! 1760: * pointed to by the list parameter. ! 1761: * ! 1762: **************************************************************/ ! 1763: ! 1764: void TLan_PrintList( TLanList *list, char *type, int num) ! 1765: { ! 1766: int i; ! 1767: ! 1768: printk( "TLAN: %s List %d at 0x%08x\n", type, num, (u32) list ); ! 1769: printk( "TLAN: Forward = 0x%08x\n", list->forward ); ! 1770: printk( "TLAN: CSTAT = 0x%04hx\n", list->cStat ); ! 1771: printk( "TLAN: Frame Size = 0x%04hx\n", list->frameSize ); ! 1772: /* for ( i = 0; i < 10; i++ ) { */ ! 1773: for ( i = 0; i < 2; i++ ) { ! 1774: printk( "TLAN: Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address ); ! 1775: } ! 1776: ! 1777: } /* TLan_PrintList */ ! 1778: ! 1779: ! 1780: ! 1781: ! 1782: /*************************************************************** ! 1783: * TLan_ReadAndClearStats ! 1784: * ! 1785: * Returns: ! 1786: * Nothing ! 1787: * Parms: ! 1788: * dev Pointer to device structure of adapter ! 1789: * to which to read stats. ! 1790: * record Flag indicating whether to add ! 1791: * ! 1792: * This functions reads all the internal status registers ! 1793: * of the TLAN chip, which clears them as a side effect. ! 1794: * It then either adds the values to the device's status ! 1795: * struct, or discards them, depending on whether record ! 1796: * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0). ! 1797: * ! 1798: **************************************************************/ ! 1799: ! 1800: void TLan_ReadAndClearStats( struct device *dev, int record ) ! 1801: { ! 1802: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1803: u32 tx_good, tx_under; ! 1804: u32 rx_good, rx_over; ! 1805: u32 def_tx, crc, code; ! 1806: u32 multi_col, single_col; ! 1807: u32 excess_col, late_col, loss; ! 1808: ! 1809: outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR ); ! 1810: tx_good = inb( dev->base_addr + TLAN_DIO_DATA ); ! 1811: tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; ! 1812: tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16; ! 1813: tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); ! 1814: ! 1815: outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR ); ! 1816: rx_good = inb( dev->base_addr + TLAN_DIO_DATA ); ! 1817: rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; ! 1818: rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16; ! 1819: rx_over = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); ! 1820: ! 1821: outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR ); ! 1822: def_tx = inb( dev->base_addr + TLAN_DIO_DATA ); ! 1823: def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; ! 1824: crc = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); ! 1825: code = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); ! 1826: ! 1827: outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR ); ! 1828: multi_col = inb( dev->base_addr + TLAN_DIO_DATA ); ! 1829: multi_col += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; ! 1830: single_col = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); ! 1831: single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8; ! 1832: ! 1833: outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR ); ! 1834: excess_col = inb( dev->base_addr + TLAN_DIO_DATA ); ! 1835: late_col = inb( dev->base_addr + TLAN_DIO_DATA + 1 ); ! 1836: loss = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); ! 1837: ! 1838: if ( record ) { ! 1839: priv->stats.rx_packets += rx_good; ! 1840: priv->stats.rx_errors += rx_over + crc + code; ! 1841: priv->stats.tx_packets += tx_good; ! 1842: priv->stats.tx_errors += tx_under + loss; ! 1843: priv->stats.collisions += multi_col + single_col + excess_col + late_col; ! 1844: ! 1845: priv->stats.rx_over_errors += rx_over; ! 1846: priv->stats.rx_crc_errors += crc; ! 1847: priv->stats.rx_frame_errors += code; ! 1848: ! 1849: priv->stats.tx_aborted_errors += tx_under; ! 1850: priv->stats.tx_carrier_errors += loss; ! 1851: } ! 1852: ! 1853: } /* TLan_ReadAndClearStats */ ! 1854: ! 1855: ! 1856: ! 1857: ! 1858: /*************************************************************** ! 1859: * TLan_Reset ! 1860: * ! 1861: * Returns: ! 1862: * 0 ! 1863: * Parms: ! 1864: * dev Pointer to device structure of adapter ! 1865: * to be reset. ! 1866: * ! 1867: * This function resets the adapter and it's physical ! 1868: * device. See Chap. 3, pp. 9-10 of the "ThunderLAN ! 1869: * Programmer's Guide" for details. The routine tries to ! 1870: * implement what is detailed there, though adjustments ! 1871: * have been made. ! 1872: * ! 1873: **************************************************************/ ! 1874: ! 1875: void ! 1876: TLan_ResetAdapter( struct device *dev ) ! 1877: { ! 1878: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1879: int i; ! 1880: u32 addr; ! 1881: u32 data; ! 1882: u8 data8; ! 1883: ! 1884: priv->tlanFullDuplex = FALSE; ! 1885: /* 1. Assert reset bit. */ ! 1886: ! 1887: data = inl(dev->base_addr + TLAN_HOST_CMD); ! 1888: data |= TLAN_HC_AD_RST; ! 1889: outl(data, dev->base_addr + TLAN_HOST_CMD); ! 1890: ! 1891: udelay(1000); ! 1892: ! 1893: /* 2. Turn off interrupts. ( Probably isn't necessary ) */ ! 1894: ! 1895: data = inl(dev->base_addr + TLAN_HOST_CMD); ! 1896: data |= TLAN_HC_INT_OFF; ! 1897: outl(data, dev->base_addr + TLAN_HOST_CMD); ! 1898: ! 1899: /* 3. Clear AREGs and HASHs. */ ! 1900: ! 1901: for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) { ! 1902: TLan_DioWrite32( dev->base_addr, (u16) i, 0 ); ! 1903: } ! 1904: ! 1905: /* 4. Setup NetConfig register. */ ! 1906: ! 1907: data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; ! 1908: TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data ); ! 1909: ! 1910: /* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */ ! 1911: ! 1912: outl( TLAN_HC_LD_TMR | 0x0, dev->base_addr + TLAN_HOST_CMD ); ! 1913: outl( TLAN_HC_LD_THR | 0x1, dev->base_addr + TLAN_HOST_CMD ); ! 1914: ! 1915: /* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */ ! 1916: ! 1917: outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR ); ! 1918: addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO; ! 1919: TLan_SetBit( TLAN_NET_SIO_NMRST, addr ); ! 1920: ! 1921: /* 7. Setup the remaining registers. */ ! 1922: ! 1923: if ( priv->tlanRev >= 0x30 ) { ! 1924: data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC; ! 1925: TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 ); ! 1926: } ! 1927: TLan_PhyDetect( dev ); ! 1928: data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN; ! 1929: if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) { ! 1930: data |= TLAN_NET_CFG_BIT; ! 1931: if ( priv->aui == 1 ) { ! 1932: TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a ); ! 1933: } else if ( priv->duplex == TLAN_DUPLEX_FULL ) { ! 1934: TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 ); ! 1935: priv->tlanFullDuplex = TRUE; ! 1936: } else { ! 1937: TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 ); ! 1938: } ! 1939: } ! 1940: if ( priv->phyNum == 0 ) { ! 1941: data |= TLAN_NET_CFG_PHY_EN; ! 1942: } ! 1943: TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data ); ! 1944: ! 1945: if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { ! 1946: TLan_FinishReset( dev ); ! 1947: } else { ! 1948: TLan_PhyPowerDown( dev ); ! 1949: } ! 1950: ! 1951: } /* TLan_ResetAdapter */ ! 1952: ! 1953: ! 1954: ! 1955: ! 1956: void ! 1957: TLan_FinishReset( struct device *dev ) ! 1958: { ! 1959: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 1960: u8 data; ! 1961: u32 phy; ! 1962: u8 sio; ! 1963: u16 status; ! 1964: u16 tlphy_ctl; ! 1965: ! 1966: phy = priv->phy[priv->phyNum]; ! 1967: ! 1968: data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP; ! 1969: if ( priv->tlanFullDuplex ) { ! 1970: data |= TLAN_NET_CMD_DUPLEX; ! 1971: } ! 1972: TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data ); ! 1973: data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5; ! 1974: if ( priv->phyNum == 0 ) { ! 1975: data |= TLAN_NET_MASK_MASK7; ! 1976: } ! 1977: TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data ); ! 1978: TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, TLAN_MAX_FRAME_SIZE ); ! 1979: ! 1980: if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) { ! 1981: status = MII_GS_LINK; ! 1982: printk( "TLAN: %s: Link forced.\n", dev->name ); ! 1983: } else { ! 1984: TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); ! 1985: udelay( 1000 ); ! 1986: TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); ! 1987: if ( status & MII_GS_LINK ) { ! 1988: printk( "TLAN: %s: Link active.\n", dev->name ); ! 1989: TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK ); ! 1990: } ! 1991: } ! 1992: ! 1993: if ( priv->phyNum == 0 ) { ! 1994: TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl ); ! 1995: tlphy_ctl |= TLAN_TC_INTEN; ! 1996: TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl ); ! 1997: sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO ); ! 1998: sio |= TLAN_NET_SIO_MINTEN; ! 1999: TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio ); ! 2000: } ! 2001: ! 2002: if ( status & MII_GS_LINK ) { ! 2003: TLan_SetMac( dev, 0, dev->dev_addr ); ! 2004: priv->phyOnline = 1; ! 2005: outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 ); ! 2006: if ( debug >= 1 ) { ! 2007: outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 ); ! 2008: } ! 2009: outl( virt_to_bus( priv->rxList ), dev->base_addr + TLAN_CH_PARM ); ! 2010: outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD ); ! 2011: } else { ! 2012: printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name ); ! 2013: TLan_SetTimer( dev, 1000, TLAN_TIMER_FINISH_RESET ); ! 2014: return; ! 2015: } ! 2016: ! 2017: } /* TLan_FinishReset */ ! 2018: ! 2019: ! 2020: ! 2021: ! 2022: /*************************************************************** ! 2023: * TLan_SetMac ! 2024: * ! 2025: * Returns: ! 2026: * Nothing ! 2027: * Parms: ! 2028: * dev Pointer to device structure of adapter ! 2029: * on which to change the AREG. ! 2030: * areg The AREG to set the address in (0 - 3). ! 2031: * mac A pointer to an array of chars. Each ! 2032: * element stores one byte of the address. ! 2033: * IE, it isn't in ascii. ! 2034: * ! 2035: * This function transfers a MAC address to one of the ! 2036: * TLAN AREGs (address registers). The TLAN chip locks ! 2037: * the register on writing to offset 0 and unlocks the ! 2038: * register after writing to offset 5. If NULL is passed ! 2039: * in mac, then the AREG is filled with 0's. ! 2040: * ! 2041: **************************************************************/ ! 2042: ! 2043: void TLan_SetMac( struct device *dev, int areg, char *mac ) ! 2044: { ! 2045: int i; ! 2046: ! 2047: areg *= 6; ! 2048: ! 2049: if ( mac != NULL ) { ! 2050: for ( i = 0; i < 6; i++ ) ! 2051: TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] ); ! 2052: } else { ! 2053: for ( i = 0; i < 6; i++ ) ! 2054: TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 ); ! 2055: } ! 2056: ! 2057: } /* TLan_SetMac */ ! 2058: ! 2059: ! 2060: ! 2061: ! 2062: /***************************************************************************** ! 2063: ****************************************************************************** ! 2064: ! 2065: ThunderLAN Driver PHY Layer Routines ! 2066: ! 2067: ****************************************************************************** ! 2068: *****************************************************************************/ ! 2069: ! 2070: ! 2071: ! 2072: /********************************************************************* ! 2073: * TLan_PhyPrint ! 2074: * ! 2075: * Returns: ! 2076: * Nothing ! 2077: * Parms: ! 2078: * dev A pointer to the device structure of the ! 2079: * TLAN device having the PHYs to be detailed. ! 2080: * ! 2081: * This function prints the registers a PHY (aka tranceiver). ! 2082: * ! 2083: ********************************************************************/ ! 2084: ! 2085: void TLan_PhyPrint( struct device *dev ) ! 2086: { ! 2087: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2088: u16 i, data0, data1, data2, data3, phy; ! 2089: ! 2090: phy = priv->phy[priv->phyNum]; ! 2091: ! 2092: if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { ! 2093: printk( "TLAN: Device %s, Unmanaged PHY.\n", dev->name ); ! 2094: } else if ( phy <= TLAN_PHY_MAX_ADDR ) { ! 2095: printk( "TLAN: Device %s, PHY 0x%02x.\n", dev->name, phy ); ! 2096: printk( "TLAN: Off. +0 +1 +2 +3 \n" ); ! 2097: for ( i = 0; i < 0x20; i+= 4 ) { ! 2098: printk( "TLAN: 0x%02x", i ); ! 2099: TLan_MiiReadReg( dev, phy, i, &data0 ); ! 2100: printk( " 0x%04hx", data0 ); ! 2101: TLan_MiiReadReg( dev, phy, i + 1, &data1 ); ! 2102: printk( " 0x%04hx", data1 ); ! 2103: TLan_MiiReadReg( dev, phy, i + 2, &data2 ); ! 2104: printk( " 0x%04hx", data2 ); ! 2105: TLan_MiiReadReg( dev, phy, i + 3, &data3 ); ! 2106: printk( " 0x%04hx\n", data3 ); ! 2107: } ! 2108: } else { ! 2109: printk( "TLAN: Device %s, Invalid PHY.\n", dev->name ); ! 2110: } ! 2111: ! 2112: } /* TLan_PhyPrint */ ! 2113: ! 2114: ! 2115: ! 2116: ! 2117: /********************************************************************* ! 2118: * TLan_PhyDetect ! 2119: * ! 2120: * Returns: ! 2121: * Nothing ! 2122: * Parms: ! 2123: * dev A pointer to the device structure of the adapter ! 2124: * for which the PHY needs determined. ! 2125: * ! 2126: * So far I've found that adapters which have external PHYs ! 2127: * may also use the internal PHY for part of the functionality. ! 2128: * (eg, AUI/Thinnet). This function finds out if this TLAN ! 2129: * chip has an internal PHY, and then finds the first external ! 2130: * PHY (starting from address 0) if it exists). ! 2131: * ! 2132: ********************************************************************/ ! 2133: ! 2134: void TLan_PhyDetect( struct device *dev ) ! 2135: { ! 2136: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2137: u16 control; ! 2138: u16 hi; ! 2139: u16 lo; ! 2140: u32 phy; ! 2141: ! 2142: if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { ! 2143: priv->phyNum = 0xFFFF; ! 2144: return; ! 2145: } ! 2146: ! 2147: TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi ); ! 2148: ! 2149: if ( hi != 0xFFFF ) { ! 2150: priv->phy[0] = TLAN_PHY_MAX_ADDR; ! 2151: } else { ! 2152: priv->phy[0] = TLAN_PHY_NONE; ! 2153: } ! 2154: ! 2155: priv->phy[1] = TLAN_PHY_NONE; ! 2156: for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) { ! 2157: TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control ); ! 2158: TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi ); ! 2159: TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo ); ! 2160: if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) { ! 2161: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo ); ! 2162: if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) { ! 2163: priv->phy[1] = phy; ! 2164: } ! 2165: } ! 2166: } ! 2167: ! 2168: if ( priv->phy[1] != TLAN_PHY_NONE ) { ! 2169: priv->phyNum = 1; ! 2170: } else if ( priv->phy[0] != TLAN_PHY_NONE ) { ! 2171: priv->phyNum = 0; ! 2172: } else { ! 2173: printk( "TLAN: Cannot initialize device, no PHY was found!\n" ); ! 2174: } ! 2175: ! 2176: } /* TLan_PhyDetect */ ! 2177: ! 2178: ! 2179: ! 2180: ! 2181: void TLan_PhyPowerDown( struct device *dev ) ! 2182: { ! 2183: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2184: u16 value; ! 2185: ! 2186: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Powering down PHY(s).\n", dev->name ); ! 2187: value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE; ! 2188: TLan_MiiSync( dev->base_addr ); ! 2189: TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value ); ! 2190: if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) { ! 2191: TLan_MiiSync( dev->base_addr ); ! 2192: TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value ); ! 2193: } ! 2194: ! 2195: /* Wait for 5 jiffies (50 ms) and powerup ! 2196: * This is abitrary. It is intended to make sure the ! 2197: * tranceiver settles. ! 2198: */ ! 2199: TLan_SetTimer( dev, 5, TLAN_TIMER_PHY_PUP ); ! 2200: ! 2201: } /* TLan_PhyPowerDown */ ! 2202: ! 2203: ! 2204: ! 2205: ! 2206: void TLan_PhyPowerUp( struct device *dev ) ! 2207: { ! 2208: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2209: u16 value; ! 2210: ! 2211: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Powering up PHY.\n", dev->name ); ! 2212: TLan_MiiSync( dev->base_addr ); ! 2213: value = MII_GC_LOOPBK; ! 2214: TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value ); ! 2215: ! 2216: /* Wait for 50 jiffies (500 ms) and reset the ! 2217: * tranceiver. The TLAN docs say both 50 ms and ! 2218: * 500 ms, so do the longer, just in case ! 2219: */ ! 2220: TLan_SetTimer( dev, 50, TLAN_TIMER_PHY_RESET ); ! 2221: ! 2222: } /* TLan_PhyPowerUp */ ! 2223: ! 2224: ! 2225: ! 2226: ! 2227: void TLan_PhyReset( struct device *dev ) ! 2228: { ! 2229: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2230: u16 phy; ! 2231: u16 value; ! 2232: ! 2233: phy = priv->phy[priv->phyNum]; ! 2234: ! 2235: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Reseting PHY.\n", dev->name ); ! 2236: TLan_MiiSync( dev->base_addr ); ! 2237: value = MII_GC_LOOPBK | MII_GC_RESET; ! 2238: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value ); ! 2239: TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value ); ! 2240: while ( value & MII_GC_RESET ) { ! 2241: TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value ); ! 2242: } ! 2243: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0 ); ! 2244: ! 2245: /* Wait for 50 jiffies (500 ms) and initialize. ! 2246: * I don't remember why I wait this long. ! 2247: */ ! 2248: TLan_SetTimer( dev, 50, TLAN_TIMER_PHY_START_LINK ); ! 2249: ! 2250: } /* TLan_PhyReset */ ! 2251: ! 2252: ! 2253: ! 2254: ! 2255: void TLan_PhyStartLink( struct device *dev ) ! 2256: { ! 2257: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2258: u16 ability; ! 2259: u16 control; ! 2260: u16 data; ! 2261: u16 phy; ! 2262: u16 status; ! 2263: u16 tctl; ! 2264: ! 2265: phy = priv->phy[priv->phyNum]; ! 2266: ! 2267: TLAN_DBG( TLAN_DEBUG_GNRL, "TLAN: %s: Trying to activate link.\n", dev->name ); ! 2268: TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); ! 2269: if ( ( status & MII_GS_AUTONEG ) && ! 2270: ( priv->duplex == TLAN_DUPLEX_DEFAULT ) && ! 2271: ( priv->speed == TLAN_SPEED_DEFAULT ) && ! 2272: ( ! priv->aui ) ) { ! 2273: ability = status >> 11; ! 2274: ! 2275: if ( priv->speed == TLAN_SPEED_10 ) { ! 2276: ability &= 0x0003; ! 2277: } else if ( priv->speed == TLAN_SPEED_100 ) { ! 2278: ability &= 0x001C; ! 2279: } ! 2280: ! 2281: if ( priv->duplex == TLAN_DUPLEX_FULL ) { ! 2282: ability &= 0x000A; ! 2283: } else if ( priv->duplex == TLAN_DUPLEX_HALF ) { ! 2284: ability &= 0x0005; ! 2285: } ! 2286: ! 2287: TLan_MiiWriteReg( dev, phy, MII_AN_ADV, ( ability << 5 ) | 1 ); ! 2288: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 ); ! 2289: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 ); ! 2290: ! 2291: /* Wait for 400 jiffies (4 sec) for autonegotiation ! 2292: * to complete. The max spec time is less than this ! 2293: * but the card need additional time to start AN. ! 2294: * .5 sec should be plenty extra. ! 2295: */ ! 2296: printk( "TLAN: %s: Starting autonegotiation.\n", dev->name ); ! 2297: TLan_SetTimer( dev, 400, TLAN_TIMER_PHY_FINISH_AN ); ! 2298: return; ! 2299: } ! 2300: ! 2301: if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) { ! 2302: priv->phyNum = 0; ! 2303: data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; ! 2304: TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data ); ! 2305: TLan_SetTimer( dev, 4, TLAN_TIMER_PHY_PDOWN ); ! 2306: return; ! 2307: } else if ( priv->phyNum == 0 ) { ! 2308: TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl ); ! 2309: if ( priv->aui ) { ! 2310: tctl |= TLAN_TC_AUISEL; ! 2311: } else { ! 2312: tctl &= ~TLAN_TC_AUISEL; ! 2313: control = 0; ! 2314: if ( priv->duplex == TLAN_DUPLEX_FULL ) { ! 2315: control |= MII_GC_DUPLEX; ! 2316: priv->tlanFullDuplex = TRUE; ! 2317: } ! 2318: if ( priv->speed == TLAN_SPEED_100 ) { ! 2319: control |= MII_GC_SPEEDSEL; ! 2320: } ! 2321: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control ); ! 2322: } ! 2323: TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl ); ! 2324: } ! 2325: ! 2326: /* Wait for 100 jiffies (1 sec) to give the tranceiver time ! 2327: * to establish link. ! 2328: */ ! 2329: TLan_SetTimer( dev, 100, TLAN_TIMER_FINISH_RESET ); ! 2330: ! 2331: } /* TLan_PhyStartLink */ ! 2332: ! 2333: ! 2334: ! 2335: ! 2336: void TLan_PhyFinishAutoNeg( struct device *dev ) ! 2337: { ! 2338: TLanPrivateInfo *priv = (TLanPrivateInfo *) dev->priv; ! 2339: u16 an_adv; ! 2340: u16 an_lpa; ! 2341: u16 data; ! 2342: u16 mode; ! 2343: u16 phy; ! 2344: u16 status; ! 2345: ! 2346: phy = priv->phy[priv->phyNum]; ! 2347: ! 2348: TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); ! 2349: if ( ! ( status & MII_GS_AUTOCMPLT ) ) { ! 2350: /* Wait for 800 jiffies (8 sec) to give the process ! 2351: * more time. Perhaps we should fail after a while. ! 2352: */ ! 2353: printk( "TLAN: Giving autonegotiation more time.\n" ); ! 2354: TLan_SetTimer( dev, 800, TLAN_TIMER_PHY_FINISH_AN ); ! 2355: return; ! 2356: } ! 2357: ! 2358: printk( "TLAN: %s: Autonegotiation complete.\n", dev->name ); ! 2359: TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv ); ! 2360: TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa ); ! 2361: mode = an_adv & an_lpa & 0x03E0; ! 2362: if ( mode & 0x0100 ) { ! 2363: priv->tlanFullDuplex = TRUE; ! 2364: } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) { ! 2365: priv->tlanFullDuplex = TRUE; ! 2366: } ! 2367: ! 2368: if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) { ! 2369: priv->phyNum = 0; ! 2370: data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; ! 2371: TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data ); ! 2372: TLan_SetTimer( dev, 40, TLAN_TIMER_PHY_PDOWN ); ! 2373: return; ! 2374: } ! 2375: ! 2376: if ( priv->phyNum == 0 ) { ! 2377: if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) { ! 2378: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX ); ! 2379: printk( "TLAN: Starting internal PHY with DUPLEX\n" ); ! 2380: } else { ! 2381: TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB ); ! 2382: printk( "TLAN: Starting internal PHY with HALF-DUPLEX\n" ); ! 2383: } ! 2384: } ! 2385: ! 2386: /* Wait for 10 jiffies (100 ms). No reason in partiticular. ! 2387: */ ! 2388: TLan_SetTimer( dev, 10, TLAN_TIMER_FINISH_RESET ); ! 2389: ! 2390: } /* TLan_PhyFinishAutoNeg */ ! 2391: ! 2392: ! 2393: ! 2394: ! 2395: /***************************************************************************** ! 2396: ****************************************************************************** ! 2397: ! 2398: ThunderLAN Driver MII Routines ! 2399: ! 2400: These routines are based on the information in Chap. 2 of the ! 2401: "ThunderLAN Programmer's Guide", pp. 15-24. ! 2402: ! 2403: ****************************************************************************** ! 2404: *****************************************************************************/ ! 2405: ! 2406: ! 2407: /*************************************************************** ! 2408: * TLan_MiiReadReg ! 2409: * ! 2410: * Returns: ! 2411: * 0 if ack received ok ! 2412: * 1 otherwise. ! 2413: * ! 2414: * Parms: ! 2415: * dev The device structure containing ! 2416: * The io address and interrupt count ! 2417: * for this device. ! 2418: * phy The address of the PHY to be queried. ! 2419: * reg The register whose contents are to be ! 2420: * retreived. ! 2421: * val A pointer to a variable to store the ! 2422: * retrieved value. ! 2423: * ! 2424: * This function uses the TLAN's MII bus to retreive the contents ! 2425: * of a given register on a PHY. It sends the appropriate info ! 2426: * and then reads the 16-bit register value from the MII bus via ! 2427: * the TLAN SIO register. ! 2428: * ! 2429: **************************************************************/ ! 2430: ! 2431: int TLan_MiiReadReg( struct device *dev, u16 phy, u16 reg, u16 *val ) ! 2432: { ! 2433: u8 nack; ! 2434: u16 sio, tmp; ! 2435: u32 i; ! 2436: int err; ! 2437: int minten; ! 2438: ! 2439: err = FALSE; ! 2440: outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR); ! 2441: sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2442: ! 2443: if ( dev->interrupt == 0 ) ! 2444: cli(); ! 2445: dev->interrupt++; ! 2446: ! 2447: TLan_MiiSync(dev->base_addr); ! 2448: ! 2449: minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio ); ! 2450: if ( minten ) ! 2451: TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio); ! 2452: ! 2453: TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */ ! 2454: TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Read ( 10b ) */ ! 2455: TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */ ! 2456: TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */ ! 2457: ! 2458: ! 2459: TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */ ! 2460: ! 2461: TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Clock Idle bit */ ! 2462: TLan_SetBit(TLAN_NET_SIO_MCLK, sio); ! 2463: TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Wait 300ns */ ! 2464: ! 2465: nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio); /* Check for ACK */ ! 2466: TLan_SetBit(TLAN_NET_SIO_MCLK, sio); /* Finish ACK */ ! 2467: if (nack) { /* No ACK, so fake it */ ! 2468: for (i = 0; i < 16; i++) { ! 2469: TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); ! 2470: TLan_SetBit(TLAN_NET_SIO_MCLK, sio); ! 2471: } ! 2472: tmp = 0xffff; ! 2473: err = TRUE; ! 2474: } else { /* ACK, so read data */ ! 2475: for (tmp = 0, i = 0x8000; i; i >>= 1) { ! 2476: TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); ! 2477: if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio)) ! 2478: tmp |= i; ! 2479: TLan_SetBit(TLAN_NET_SIO_MCLK, sio); ! 2480: } ! 2481: } ! 2482: ! 2483: ! 2484: TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Idle cycle */ ! 2485: TLan_SetBit(TLAN_NET_SIO_MCLK, sio); ! 2486: ! 2487: if ( minten ) ! 2488: TLan_SetBit(TLAN_NET_SIO_MINTEN, sio); ! 2489: ! 2490: *val = tmp; ! 2491: ! 2492: dev->interrupt--; ! 2493: if ( dev->interrupt == 0 ) ! 2494: sti(); ! 2495: ! 2496: return err; ! 2497: ! 2498: } /* TLan_MiiReadReg */ ! 2499: ! 2500: ! 2501: ! 2502: ! 2503: /*************************************************************** ! 2504: * TLan_MiiSendData ! 2505: * ! 2506: * Returns: ! 2507: * Nothing ! 2508: * Parms: ! 2509: * base_port The base IO port of the adapter in ! 2510: * question. ! 2511: * dev The address of the PHY to be queried. ! 2512: * data The value to be placed on the MII bus. ! 2513: * num_bits The number of bits in data that are to ! 2514: * be placed on the MII bus. ! 2515: * ! 2516: * This function sends on sequence of bits on the MII ! 2517: * configuration bus. ! 2518: * ! 2519: **************************************************************/ ! 2520: ! 2521: void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits ) ! 2522: { ! 2523: u16 sio; ! 2524: u32 i; ! 2525: ! 2526: if ( num_bits == 0 ) ! 2527: return; ! 2528: ! 2529: outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR ); ! 2530: sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2531: TLan_SetBit( TLAN_NET_SIO_MTXEN, sio ); ! 2532: ! 2533: for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) { ! 2534: TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); ! 2535: TLan_GetBit( TLAN_NET_SIO_MCLK, sio ); ! 2536: if ( data & i ) ! 2537: TLan_SetBit( TLAN_NET_SIO_MDATA, sio ); ! 2538: else ! 2539: TLan_ClearBit( TLAN_NET_SIO_MDATA, sio ); ! 2540: TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); ! 2541: TLan_GetBit( TLAN_NET_SIO_MCLK, sio ); ! 2542: } ! 2543: ! 2544: } /* TLan_MiiSendData */ ! 2545: ! 2546: ! 2547: ! 2548: ! 2549: /*************************************************************** ! 2550: * TLan_MiiSync ! 2551: * ! 2552: * Returns: ! 2553: * Nothing ! 2554: * Parms: ! 2555: * base_port The base IO port of the adapter in ! 2556: * question. ! 2557: * ! 2558: * This functions syncs all PHYs in terms of the MII configuration ! 2559: * bus. ! 2560: * ! 2561: **************************************************************/ ! 2562: ! 2563: void TLan_MiiSync( u16 base_port ) ! 2564: { ! 2565: int i; ! 2566: u16 sio; ! 2567: ! 2568: outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR ); ! 2569: sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2570: ! 2571: TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio ); ! 2572: for ( i = 0; i < 32; i++ ) { ! 2573: TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); ! 2574: TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); ! 2575: } ! 2576: ! 2577: } /* TLan_MiiSync */ ! 2578: ! 2579: ! 2580: ! 2581: ! 2582: /*************************************************************** ! 2583: * TLan_MiiWriteReg ! 2584: * ! 2585: * Returns: ! 2586: * Nothing ! 2587: * Parms: ! 2588: * dev The device structure for the device ! 2589: * to write to. ! 2590: * phy The address of the PHY to be written to. ! 2591: * reg The register whose contents are to be ! 2592: * written. ! 2593: * val The value to be written to the register. ! 2594: * ! 2595: * This function uses the TLAN's MII bus to write the contents of a ! 2596: * given register on a PHY. It sends the appropriate info and then ! 2597: * writes the 16-bit register value from the MII configuration bus ! 2598: * via the TLAN SIO register. ! 2599: * ! 2600: **************************************************************/ ! 2601: ! 2602: void TLan_MiiWriteReg( struct device *dev, u16 phy, u16 reg, u16 val ) ! 2603: { ! 2604: u16 sio; ! 2605: int minten; ! 2606: ! 2607: outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR); ! 2608: sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2609: ! 2610: if ( dev->interrupt == 0 ) ! 2611: cli(); ! 2612: dev->interrupt++; ! 2613: ! 2614: TLan_MiiSync( dev->base_addr ); ! 2615: ! 2616: minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio ); ! 2617: if ( minten ) ! 2618: TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio ); ! 2619: ! 2620: TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */ ! 2621: TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Write ( 01b ) */ ! 2622: TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */ ! 2623: TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */ ! 2624: ! 2625: TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Send ACK */ ! 2626: TLan_MiiSendData( dev->base_addr, val, 16 ); /* Send Data */ ! 2627: ! 2628: TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); /* Idle cycle */ ! 2629: TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); ! 2630: ! 2631: if ( minten ) ! 2632: TLan_SetBit( TLAN_NET_SIO_MINTEN, sio ); ! 2633: ! 2634: dev->interrupt--; ! 2635: if ( dev->interrupt == 0 ) ! 2636: sti(); ! 2637: ! 2638: } /* TLan_MiiWriteReg */ ! 2639: ! 2640: ! 2641: ! 2642: ! 2643: /***************************************************************************** ! 2644: ****************************************************************************** ! 2645: ! 2646: ThunderLAN Driver Eeprom routines ! 2647: ! 2648: The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A ! 2649: EEPROM. These functions are based on information in Microchip's ! 2650: data sheet. I don't know how well this functions will work with ! 2651: other EEPROMs. ! 2652: ! 2653: ****************************************************************************** ! 2654: *****************************************************************************/ ! 2655: ! 2656: ! 2657: /*************************************************************** ! 2658: * TLan_EeSendStart ! 2659: * ! 2660: * Returns: ! 2661: * Nothing ! 2662: * Parms: ! 2663: * io_base The IO port base address for the ! 2664: * TLAN device with the EEPROM to ! 2665: * use. ! 2666: * ! 2667: * This function sends a start cycle to an EEPROM attached ! 2668: * to a TLAN chip. ! 2669: * ! 2670: **************************************************************/ ! 2671: ! 2672: void TLan_EeSendStart( u16 io_base ) ! 2673: { ! 2674: u16 sio; ! 2675: ! 2676: outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); ! 2677: sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2678: ! 2679: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2680: TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); ! 2681: TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); ! 2682: TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); ! 2683: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2684: ! 2685: } /* TLan_EeSendStart */ ! 2686: ! 2687: ! 2688: ! 2689: ! 2690: /*************************************************************** ! 2691: * TLan_EeSendByte ! 2692: * ! 2693: * Returns: ! 2694: * If the correct ack was received, 0, otherwise 1 ! 2695: * Parms: io_base The IO port base address for the ! 2696: * TLAN device with the EEPROM to ! 2697: * use. ! 2698: * data The 8 bits of information to ! 2699: * send to the EEPROM. ! 2700: * stop If TLAN_EEPROM_STOP is passed, a ! 2701: * stop cycle is sent after the ! 2702: * byte is sent after the ack is ! 2703: * read. ! 2704: * ! 2705: * This function sends a byte on the serial EEPROM line, ! 2706: * driving the clock to send each bit. The function then ! 2707: * reverses transmission direction and reads an acknowledge ! 2708: * bit. ! 2709: * ! 2710: **************************************************************/ ! 2711: ! 2712: int TLan_EeSendByte( u16 io_base, u8 data, int stop ) ! 2713: { ! 2714: int err; ! 2715: u8 place; ! 2716: u16 sio; ! 2717: ! 2718: outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); ! 2719: sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2720: ! 2721: /* Assume clock is low, tx is enabled; */ ! 2722: for ( place = 0x80; place != 0; place >>= 1 ) { ! 2723: if ( place & data ) ! 2724: TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); ! 2725: else ! 2726: TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); ! 2727: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2728: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2729: } ! 2730: TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio ); ! 2731: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2732: err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio ); ! 2733: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2734: TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); ! 2735: ! 2736: if ( ( ! err ) && stop ) { ! 2737: TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */ ! 2738: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2739: TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); ! 2740: } ! 2741: ! 2742: return ( err ); ! 2743: ! 2744: } /* TLan_EeSendByte */ ! 2745: ! 2746: ! 2747: ! 2748: ! 2749: /*************************************************************** ! 2750: * TLan_EeReceiveByte ! 2751: * ! 2752: * Returns: ! 2753: * Nothing ! 2754: * Parms: ! 2755: * io_base The IO port base address for the ! 2756: * TLAN device with the EEPROM to ! 2757: * use. ! 2758: * data An address to a char to hold the ! 2759: * data sent from the EEPROM. ! 2760: * stop If TLAN_EEPROM_STOP is passed, a ! 2761: * stop cycle is sent after the ! 2762: * byte is received, and no ack is ! 2763: * sent. ! 2764: * ! 2765: * This function receives 8 bits of data from the EEPROM ! 2766: * over the serial link. It then sends and ack bit, or no ! 2767: * ack and a stop bit. This function is used to retrieve ! 2768: * data after the address of a byte in the EEPROM has been ! 2769: * sent. ! 2770: * ! 2771: **************************************************************/ ! 2772: ! 2773: void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop ) ! 2774: { ! 2775: u8 place; ! 2776: u16 sio; ! 2777: ! 2778: outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); ! 2779: sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; ! 2780: *data = 0; ! 2781: ! 2782: /* Assume clock is low, tx is enabled; */ ! 2783: TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio ); ! 2784: for ( place = 0x80; place; place >>= 1 ) { ! 2785: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2786: if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) ) ! 2787: *data |= place; ! 2788: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2789: } ! 2790: ! 2791: TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); ! 2792: if ( ! stop ) { ! 2793: TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* Ack = 0 */ ! 2794: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2795: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2796: } else { ! 2797: TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); /* No ack = 1 (?) */ ! 2798: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2799: TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); ! 2800: TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */ ! 2801: TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); ! 2802: TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); ! 2803: } ! 2804: ! 2805: } /* TLan_EeReceiveByte */ ! 2806: ! 2807: ! 2808: ! 2809: ! 2810: /*************************************************************** ! 2811: * TLan_EeReadByte ! 2812: * ! 2813: * Returns: ! 2814: * No error = 0, else, the stage at which the error ! 2815: * occured. ! 2816: * Parms: ! 2817: * io_base The IO port base address for the ! 2818: * TLAN device with the EEPROM to ! 2819: * use. ! 2820: * ee_addr The address of the byte in the ! 2821: * EEPROM whose contents are to be ! 2822: * retrieved. ! 2823: * data An address to a char to hold the ! 2824: * data obtained from the EEPROM. ! 2825: * ! 2826: * This function reads a byte of information from an byte ! 2827: * cell in the EEPROM. ! 2828: * ! 2829: **************************************************************/ ! 2830: ! 2831: int TLan_EeReadByte( struct device *dev, u8 ee_addr, u8 *data ) ! 2832: { ! 2833: int err; ! 2834: ! 2835: if ( dev->interrupt == 0 ) ! 2836: cli(); ! 2837: dev->interrupt++; ! 2838: ! 2839: TLan_EeSendStart( dev->base_addr ); ! 2840: err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK ); ! 2841: if (err) ! 2842: return 1; ! 2843: err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK ); ! 2844: if (err) ! 2845: return 2; ! 2846: TLan_EeSendStart( dev->base_addr ); ! 2847: err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK ); ! 2848: if (err) ! 2849: return 3; ! 2850: TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP ); ! 2851: ! 2852: dev->interrupt--; ! 2853: if ( dev->interrupt == 0 ) ! 2854: sti(); ! 2855: ! 2856: return 0; ! 2857: ! 2858: } /* TLan_EeReadByte */ ! 2859: ! 2860: ! 2861: ! 2862: ! 2863:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.