drivers/net/tlan.c

   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  *  (C) 1999-2001 Torben Mathiasen
  11  *  (C) 2002 Samuel Chessman
  12  *
  13  *  This software may be used and distributed according to the terms
  14  *  of the GNU General Public License, incorporated herein by reference.
  15  *
  16  ** This file is best viewed/edited with columns>=132.
  17  *
  18  ** Useful (if not required) reading:
  19  *
  20  *              Texas Instruments, ThunderLAN Programmer's Guide,
  21  *                      TI Literature Number SPWU013A
  22  *                      available in PDF format from www.ti.com
  23  *              Level One, LXT901 and LXT970 Data Sheets
  24  *                      available in PDF format from www.level1.com
  25  *              National Semiconductor, DP83840A Data Sheet
  26  *                      available in PDF format from www.national.com
  27  *              Microchip Technology, 24C01A/02A/04A Data Sheet
  28  *                      available in PDF format from www.microchip.com
  29  *
  30  * Change History
  31  *
  32  *      Tigran Aivazian <tigran@sco.com>:       TLan_PciProbe() now uses
  33  *                                              new PCI BIOS interface.
  34  *      Alan Cox        <alan@redhat.com>:      Fixed the out of memory
  35  *                                              handling.
  36  *
  37  *      Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
  38  *
  39  *      v1.1 Dec 20, 1999    - Removed linux version checking
  40  *                             Patch from Tigran Aivazian.
  41  *                           - v1.1 includes Alan's SMP updates.
  42  *                           - We still have problems on SMP though,
  43  *                             but I'm looking into that.
  44  *
  45  *      v1.2 Jan 02, 2000    - Hopefully fixed the SMP deadlock.
  46  *                           - Removed dependency of HZ being 100.
  47  *                           - We now allow higher priority timers to
  48  *                             overwrite timers like TLAN_TIMER_ACTIVITY
  49  *                             Patch from John Cagle <john.cagle@compaq.com>.
  50  *                           - Fixed a few compiler warnings.
  51  *
  52  *      v1.3 Feb 04, 2000    - Fixed the remaining HZ issues.
  53  *                           - Removed call to pci_present().
  54  *                           - Removed SA_INTERRUPT flag from irq handler.
  55  *                           - Added __init and __initdata to reduce resisdent
  56  *                             code size.
  57  *                           - Driver now uses module_init/module_exit.
  58  *                           - Rewrote init_module and tlan_probe to
  59  *                             share a lot more code. We now use tlan_probe
  60  *                             with builtin and module driver.
  61  *                           - Driver ported to new net API.
  62  *                           - tlan.txt has been reworked to reflect current
  63  *                             driver (almost)
  64  *                           - Other minor stuff
  65  *
  66  *      v1.4 Feb 10, 2000    - Updated with more changes required after Dave's
  67  *                             network cleanup in 2.3.43pre7 (Tigran & myself)
  68  *                           - Minor stuff.
  69  *
  70  *      v1.5 March 22, 2000  - Fixed another timer bug that would hang the driver
  71  *                             if no cable/link were present.
  72  *                           - Cosmetic changes.
  73  *                           - TODO: Port completely to new PCI/DMA API
  74  *                                   Auto-Neg fallback.
  75  *
  76  *      v1.6 April 04, 2000  - Fixed driver support for kernel-parameters. Haven't
  77  *                             tested it though, as the kernel support is currently
  78  *                             broken (2.3.99p4p3).
  79  *                           - Updated tlan.txt accordingly.
  80  *                           - Adjusted minimum/maximum frame length.
  81  *                           - There is now a TLAN website up at
  82  *                             http://tlan.kernel.dk
  83  *
  84  *      v1.7 April 07, 2000  - Started to implement custom ioctls. Driver now
  85  *                             reports PHY information when used with Donald
  86  *                             Beckers userspace MII diagnostics utility.
  87  *
  88  *      v1.8 April 23, 2000  - Fixed support for forced speed/duplex settings.
  89  *                           - Added link information to Auto-Neg and forced
  90  *                             modes. When NIC operates with auto-neg the driver
  91  *                             will report Link speed & duplex modes as well as
  92  *                             link partner abilities. When forced link is used,
  93  *                             the driver will report status of the established
  94  *                             link.
  95  *                             Please read tlan.txt for additional information.
  96  *                           - Removed call to check_region(), and used
  97  *                             return value of request_region() instead.
  98  *
  99  *      v1.8a May 28, 2000   - Minor updates.
 100  *
 101  *      v1.9 July 25, 2000   - Fixed a few remaining Full-Duplex issues.
 102  *                           - Updated with timer fixes from Andrew Morton.
 103  *                           - Fixed module race in TLan_Open.
 104  *                           - Added routine to monitor PHY status.
 105  *                           - Added activity led support for Proliant devices.
 106  *
 107  *      v1.10 Aug 30, 2000   - Added support for EISA based tlan controllers
 108  *                             like the Compaq NetFlex3/E.
 109  *                           - Rewrote tlan_probe to better handle multiple
 110  *                             bus probes. Probing and device setup is now
 111  *                             done through TLan_Probe and TLan_init_one. Actual
 112  *                             hardware probe is done with kernel API and
 113  *                             TLan_EisaProbe.
 114  *                           - Adjusted debug information for probing.
 115  *                           - Fixed bug that would cause general debug information
 116  *                             to be printed after driver removal.
 117  *                           - Added transmit timeout handling.
 118  *                           - Fixed OOM return values in tlan_probe.
 119  *                           - Fixed possible mem leak in tlan_exit
 120  *                             (now tlan_remove_one).
 121  *                           - Fixed timer bug in TLan_phyMonitor.
 122  *                           - This driver version is alpha quality, please
 123  *                             send me any bug issues you may encounter.
 124  *
 125  *      v1.11 Aug 31, 2000   - Do not try to register irq 0 if no irq line was
 126  *                             set for EISA cards.
 127  *                           - Added support for NetFlex3/E with nibble-rate
 128  *                             10Base-T PHY. This is untestet as I haven't got
 129  *                             one of these cards.
 130  *                           - Fixed timer being added twice.
 131  *                           - Disabled PhyMonitoring by default as this is
 132  *                             work in progress. Define MONITOR to enable it.
 133  *                           - Now we don't display link info with PHYs that
 134  *                             doesn't support it (level1).
 135  *                           - Incresed tx_timeout beacuse of auto-neg.
 136  *                           - Adjusted timers for forced speeds.
 137  *
 138  *      v1.12 Oct 12, 2000   - Minor fixes (memleak, init, etc.)
 139  *
 140  *      v1.13 Nov 28, 2000   - Stop flooding console with auto-neg issues
 141  *                             when link can't be established.
 142  *                           - Added the bbuf option as a kernel parameter.
 143  *                           - Fixed ioaddr probe bug.
 144  *                           - Fixed stupid deadlock with MII interrupts.
 145  *                           - Added support for speed/duplex selection with
 146  *                             multiple nics.
 147  *                           - Added partly fix for TX Channel lockup with
 148  *                             TLAN v1.0 silicon. This needs to be investigated
 149  *                             further.
 150  *
 151  *      v1.14 Dec 16, 2000   - Added support for servicing multiple frames per.
 152  *                             interrupt. Thanks goes to
 153  *                             Adam Keys <adam@ti.com>
 154  *                             Denis Beaudoin <dbeaudoin@ti.com>
 155  *                             for providing the patch.
 156  *                           - Fixed auto-neg output when using multiple
 157  *                             adapters.
 158  *                           - Converted to use new taskq interface.
 159  *
 160  *      v1.14a Jan 6, 2001   - Minor adjustments (spinlocks, etc.)
 161  *
 162  *      Samuel Chessman <chessman@tux.org> New Maintainer!
 163  *
 164  *      v1.15 Apr 4, 2002    - Correct operation when aui=1 to be
 165  *                             10T half duplex no loopback
 166  *                             Thanks to Gunnar Eikman
 167  *******************************************************************************/
 168
 169 #include <linux/module.h>
 170 #include <linux/init.h>
 171 #include <linux/ioport.h>
 172 #include <linux/eisa.h>
 173 #include <linux/pci.h>
 174 #include <linux/netdevice.h>
 175 #include <linux/etherdevice.h>
 176 #include <linux/delay.h>
 177 #include <linux/spinlock.h>
 178 #include <linux/workqueue.h>
 179 #include <linux/mii.h>
 180
 181 #include "tlan.h"
 182
 183 typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
 184
 185
 186 /* For removing EISA devices */
 187 static  struct net_device       *TLan_Eisa_Devices;
 188
 189 static  int             TLanDevicesInstalled;
 190
 191 /* Set speed, duplex and aui settings */
 192 static  int aui[MAX_TLAN_BOARDS];
 193 static  int duplex[MAX_TLAN_BOARDS];
 194 static  int speed[MAX_TLAN_BOARDS];
 195 static  int boards_found;
 196
 197 MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
 198 MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
 199 MODULE_LICENSE("GPL");
 200
 201
 202 /* Define this to enable Link beat monitoring */
 203 #undef MONITOR
 204
 205 /* Turn on debugging. See Documentation/networking/tlan.txt for details */
 206 static  int             debug;
 207
 208 static  int             bbuf;
 209 static  u8              *TLanPadBuffer;
 210 static  dma_addr_t      TLanPadBufferDMA;
 211 static  char            TLanSignature[] = "TLAN";
 212 static  const char tlan_banner[] = "ThunderLAN driver v1.15\n";
 213 static  int tlan_have_pci;
 214 static  int tlan_have_eisa;
 215
 216 static const char *media[] = {
 217         "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ",
 218         "100baseTx-FD", "100baseT4", NULL
 219 };
 220
 221 static struct board {
 222         const char      *deviceLabel;
 223         u32             flags;
 224         u16             addrOfs;
 225 } board_info[] = {
 226         { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
 227         { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
 228         { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
 229         { "Compaq NetFlex-3/P", TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
 230         { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
 231         { "Compaq Netelligent Integrated 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
 232         { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
 233         { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
 234         { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
 235         { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 },
 236         { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
 237         { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
 238         { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
 239         { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED |     /* EISA card */
 240                                 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
 241         { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
 242 };
 243
 244 static struct pci_device_id tlan_pci_tbl[] = {
 245         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
 246                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 247         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
 248                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
 249         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
 250                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
 251         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
 252                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
 253         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
 254                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
 255         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
 256                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
 257         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
 258                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
 259         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
 260                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
 261         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
 262                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
 263         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
 264                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
 265         { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
 266                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
 267         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
 268                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
 269         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
 270                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
 271         { 0,}
 272 };
 273 MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
 274
 275 static void     TLan_EisaProbe( void );
 276 static void     TLan_Eisa_Cleanup( void );
 277 static int      TLan_Init( struct net_device * );
 278 static int      TLan_Open( struct net_device *dev );
 279 static int      TLan_StartTx( struct sk_buff *, struct net_device *);
 280 static irqreturn_t TLan_HandleInterrupt( int, void *, struct pt_regs *);
 281 static int      TLan_Close( struct net_device *);
 282 static struct   net_device_stats *TLan_GetStats( struct net_device *);
 283 static void     TLan_SetMulticastList( struct net_device *);
 284 static int      TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd);
 285 static int      TLan_probe1( struct pci_dev *pdev, long ioaddr, int irq, int rev, const struct pci_device_id *ent);
 286 static void     TLan_tx_timeout( struct net_device *dev);
 287 static int      tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
 288
 289 static u32      TLan_HandleInvalid( struct net_device *, u16 );
 290 static u32      TLan_HandleTxEOF( struct net_device *, u16 );
 291 static u32      TLan_HandleStatOverflow( struct net_device *, u16 );
 292 static u32      TLan_HandleRxEOF( struct net_device *, u16 );
 293 static u32      TLan_HandleDummy( struct net_device *, u16 );
 294 static u32      TLan_HandleTxEOC( struct net_device *, u16 );
 295 static u32      TLan_HandleStatusCheck( struct net_device *, u16 );
 296 static u32      TLan_HandleRxEOC( struct net_device *, u16 );
 297
 298 static void     TLan_Timer( unsigned long );
 299
 300 static void     TLan_ResetLists( struct net_device * );
 301 static void     TLan_FreeLists( struct net_device * );
 302 static void     TLan_PrintDio( u16 );
 303 static void     TLan_PrintList( TLanList *, char *, int );
 304 static void     TLan_ReadAndClearStats( struct net_device *, int );
 305 static void     TLan_ResetAdapter( struct net_device * );
 306 static void     TLan_FinishReset( struct net_device * );
 307 static void     TLan_SetMac( struct net_device *, int areg, char *mac );
 308
 309 static void     TLan_PhyPrint( struct net_device * );
 310 static void     TLan_PhyDetect( struct net_device * );
 311 static void     TLan_PhyPowerDown( struct net_device * );
 312 static void     TLan_PhyPowerUp( struct net_device * );
 313 static void     TLan_PhyReset( struct net_device * );
 314 static void     TLan_PhyStartLink( struct net_device * );
 315 static void     TLan_PhyFinishAutoNeg( struct net_device * );
 316 #ifdef MONITOR
 317 static void     TLan_PhyMonitor( struct net_device * );
 318 #endif
 319
 320 /*
 321 static int      TLan_PhyNop( struct net_device * );
 322 static int      TLan_PhyInternalCheck( struct net_device * );
 323 static int      TLan_PhyInternalService( struct net_device * );
 324 static int      TLan_PhyDp83840aCheck( struct net_device * );
 325 */
 326
 327 static int      TLan_MiiReadReg( struct net_device *, u16, u16, u16 * );
 328 static void     TLan_MiiSendData( u16, u32, unsigned );
 329 static void     TLan_MiiSync( u16 );
 330 static void     TLan_MiiWriteReg( struct net_device *, u16, u16, u16 );
 331
 332 static void     TLan_EeSendStart( u16 );
 333 static int      TLan_EeSendByte( u16, u8, int );
 334 static void     TLan_EeReceiveByte( u16, u8 *, int );
 335 static int      TLan_EeReadByte( struct net_device *, u8, u8 * );
 336
 337
 338 static void
 339 TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
 340 {
 341         unsigned long addr = (unsigned long)skb;
 342         tag->buffer[9].address = (u32)addr;
 343         addr >>= 31;    /* >>= 32 is undefined for 32bit arch, stupid C */
 344         addr >>= 1;
 345         tag->buffer[8].address = (u32)addr;
 346 }
 347
 348 static struct sk_buff *
 349 TLan_GetSKB( struct tlan_list_tag *tag)
 350 {
 351         unsigned long addr = tag->buffer[8].address;
 352         addr <<= 31;
 353         addr <<= 1;
 354         addr |= tag->buffer[9].address;
 355         return (struct sk_buff *) addr;
 356 }
 357
 358
 359 static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = {
 360         TLan_HandleInvalid,
 361         TLan_HandleTxEOF,
 362         TLan_HandleStatOverflow,
 363         TLan_HandleRxEOF,
 364         TLan_HandleDummy,
 365         TLan_HandleTxEOC,
 366         TLan_HandleStatusCheck,
 367         TLan_HandleRxEOC
 368 };
 369
 370 static inline void
 371 TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
 372 {
 373         TLanPrivateInfo *priv = netdev_priv(dev);
 374         unsigned long flags = 0;
 375
 376         if (!in_irq())
 377                 spin_lock_irqsave(&priv->lock, flags);
 378         if ( priv->timer.function != NULL &&
 379                 priv->timerType != TLAN_TIMER_ACTIVITY ) {
 380                 if (!in_irq())
 381                         spin_unlock_irqrestore(&priv->lock, flags);
 382                 return;
 383         }
 384         priv->timer.function = &TLan_Timer;
 385         if (!in_irq())
 386                 spin_unlock_irqrestore(&priv->lock, flags);
 387
 388         priv->timer.data = (unsigned long) dev;
 389         priv->timerSetAt = jiffies;
 390         priv->timerType = type;
 391         mod_timer(&priv->timer, jiffies + ticks);
 392
 393 } /* TLan_SetTimer */
 394
 395
 396 /*****************************************************************************
 397 ******************************************************************************
 398
 399         ThunderLAN Driver Primary Functions
 400
 401         These functions are more or less common to all Linux network drivers.
 402
 403 ******************************************************************************
 404 *****************************************************************************/
 405
 406
 407
 408
 409
 410         /***************************************************************
 411          *      tlan_remove_one
 412          *
 413          *      Returns:
 414          *              Nothing
 415          *      Parms:
 416          *              None
 417          *
 418          *      Goes through the TLanDevices list and frees the device
 419          *      structs and memory associated with each device (lists
 420          *      and buffers).  It also ureserves the IO port regions
 421          *      associated with this device.
 422          *
 423          **************************************************************/
 424
 425
 426 static void __devexit tlan_remove_one( struct pci_dev *pdev)
 427 {
 428         struct net_device *dev = pci_get_drvdata( pdev );
 429         TLanPrivateInfo *priv = netdev_priv(dev);
 430
 431         unregister_netdev( dev );
 432
 433         if ( priv->dmaStorage ) {
 434                 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
 435         }
 436
 437 #ifdef CONFIG_PCI
 438         pci_release_regions(pdev);
 439 #endif
 440
 441         free_netdev( dev );
 442
 443         pci_set_drvdata( pdev, NULL );
 444 }
 445
 446 static struct pci_driver tlan_driver = {
 447         .name           = "tlan",
 448         .id_table       = tlan_pci_tbl,
 449         .probe          = tlan_init_one,
 450         .remove         = __devexit_p(tlan_remove_one),
 451 };
 452
 453 static int __init tlan_probe(void)
 454 {
 455         static int      pad_allocated;
 456
 457         printk(KERN_INFO "%s", tlan_banner);
 458
 459         TLanPadBuffer = (u8 *) pci_alloc_consistent(NULL, TLAN_MIN_FRAME_SIZE, &TLanPadBufferDMA);
 460
 461         if (TLanPadBuffer == NULL) {
 462                 printk(KERN_ERR "TLAN: Could not allocate memory for pad buffer.\n");
 463                 return -ENOMEM;
 464         }
 465
 466         memset(TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE);
 467         pad_allocated = 1;
 468
 469         TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
 470
 471         /* Use new style PCI probing. Now the kernel will
 472            do most of this for us */
 473         pci_register_driver(&tlan_driver);
 474
 475         TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
 476         TLan_EisaProbe();
 477
 478         printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d  EISA: %d\n",
 479                  TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
 480                  tlan_have_pci, tlan_have_eisa);
 481
 482         if (TLanDevicesInstalled == 0) {
 483                 pci_unregister_driver(&tlan_driver);
 484                 pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
 485                 return -ENODEV;
 486         }
 487         return 0;
 488 }
 489
 490
 491 static int __devinit tlan_init_one( struct pci_dev *pdev,
 492                                     const struct pci_device_id *ent)
 493 {
 494         return TLan_probe1( pdev, -1, -1, 0, ent);
 495 }
 496
 497
 498 /*
 499         ***************************************************************
 500          *      tlan_probe1
 501          *
 502          *      Returns:
 503          *              0 on success, error code on error
 504          *      Parms:
 505          *              none
 506          *
 507          *      The name is lower case to fit in with all the rest of
 508          *      the netcard_probe names.  This function looks for
 509          *      another TLan based adapter, setting it up with the
 510          *      allocated device struct if one is found.
 511          *      tlan_probe has been ported to the new net API and
 512          *      now allocates its own device structure. This function
 513          *      is also used by modules.
 514          *
 515          **************************************************************/
 516
 517 static int __devinit TLan_probe1(struct pci_dev *pdev,
 518                                 long ioaddr, int irq, int rev, const struct pci_device_id *ent )
 519 {
 520
 521         struct net_device  *dev;
 522         TLanPrivateInfo    *priv;
 523         u8                 pci_rev;
 524         u16                device_id;
 525         int                reg, rc = -ENODEV;
 526
 527         if (pdev) {
 528                 rc = pci_enable_device(pdev);
 529                 if (rc)
 530                         return rc;
 531
 532                 rc = pci_request_regions(pdev, TLanSignature);
 533                 if (rc) {
 534                         printk(KERN_ERR "TLAN: Could not reserve IO regions\n");
 535                         goto err_out;
 536                 }
 537         }
 538
 539         dev = alloc_etherdev(sizeof(TLanPrivateInfo));
 540         if (dev == NULL) {
 541                 printk(KERN_ERR "TLAN: Could not allocate memory for device.\n");
 542                 rc = -ENOMEM;
 543                 goto err_out_regions;
 544         }
 545         SET_MODULE_OWNER(dev);
 546         SET_NETDEV_DEV(dev, &pdev->dev);
 547
 548         priv = netdev_priv(dev);
 549
 550         priv->pciDev = pdev;
 551
 552         /* Is this a PCI device? */
 553         if (pdev) {
 554                 u32                pci_io_base = 0;
 555
 556                 priv->adapter = &board_info[ent->driver_data];
 557
 558                 rc = pci_set_dma_mask(pdev, 0xFFFFFFFF);
 559                 if (rc) {
 560                         printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
 561                         goto err_out_free_dev;
 562                 }
 563
 564                 pci_read_config_byte ( pdev, PCI_REVISION_ID, &pci_rev);
 565
 566                 for ( reg= 0; reg <= 5; reg ++ ) {
 567                         if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
 568                                 pci_io_base = pci_resource_start(pdev, reg);
 569                                 TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.\n",
 570                                                 pci_io_base);
 571                                 break;
 572                         }
 573                 }
 574                 if (!pci_io_base) {
 575                         printk(KERN_ERR "TLAN: No IO mappings available\n");
 576                         rc = -EIO;
 577                         goto err_out_free_dev;
 578                 }
 579
 580                 dev->base_addr = pci_io_base;
 581                 dev->irq = pdev->irq;
 582                 priv->adapterRev = pci_rev;
 583                 pci_set_master(pdev);
 584                 pci_set_drvdata(pdev, dev);
 585
 586         } else  {     /* EISA card */
 587                 /* This is a hack. We need to know which board structure
 588                  * is suited for this adapter */
 589                 device_id = inw(ioaddr + EISA_ID2);
 590                 priv->is_eisa = 1;
 591                 if (device_id == 0x20F1) {
 592                         priv->adapter = &board_info[13];        /* NetFlex-3/E */
 593                         priv->adapterRev = 23;                  /* TLAN 2.3 */
 594                 } else {
 595                         priv->adapter = &board_info[14];
 596                         priv->adapterRev = 10;                  /* TLAN 1.0 */
 597                 }
 598                 dev->base_addr = ioaddr;
 599                 dev->irq = irq;
 600         }
 601
 602         /* Kernel parameters */
 603         if (dev->mem_start) {
 604                 priv->aui    = dev->mem_start & 0x01;
 605                 priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0 : (dev->mem_start & 0x06) >> 1;
 606                 priv->speed  = ((dev->mem_start & 0x18) == 0x18) ? 0 : (dev->mem_start & 0x18) >> 3;
 607
 608                 if (priv->speed == 0x1) {
 609                         priv->speed = TLAN_SPEED_10;
 610                 } else if (priv->speed == 0x2) {
 611                         priv->speed = TLAN_SPEED_100;
 612                 }
 613                 debug = priv->debug = dev->mem_end;
 614         } else {
 615                 priv->aui    = aui[boards_found];
 616                 priv->speed  = speed[boards_found];
 617                 priv->duplex = duplex[boards_found];
 618                 priv->debug = debug;
 619         }
 620
 621         /* This will be used when we get an adapter error from
 622          * within our irq handler */
 623         INIT_WORK(&priv->tlan_tqueue, (void *)(void*)TLan_tx_timeout, dev);
 624
 625         spin_lock_init(&priv->lock);
 626
 627         rc = TLan_Init(dev);
 628         if (rc) {
 629                 printk(KERN_ERR "TLAN: Could not set up device.\n");
 630                 goto err_out_free_dev;
 631         }
 632
 633         rc = register_netdev(dev);
 634         if (rc) {
 635                 printk(KERN_ERR "TLAN: Could not register device.\n");
 636                 goto err_out_uninit;
 637         }
 638
 639
 640         TLanDevicesInstalled++;
 641         boards_found++;
 642
 643         /* pdev is NULL if this is an EISA device */
 644         if (pdev)
 645                 tlan_have_pci++;
 646         else {
 647                 priv->nextDevice = TLan_Eisa_Devices;
 648                 TLan_Eisa_Devices = dev;
 649                 tlan_have_eisa++;
 650         }
 651
 652         printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n",
 653                         dev->name,
 654                         (int) dev->irq,
 655                         (int) dev->base_addr,
 656                         priv->adapter->deviceLabel,
 657                         priv->adapterRev);
 658         return 0;
 659
 660 err_out_uninit:
 661         pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage,
 662                             priv->dmaStorageDMA );
 663 err_out_free_dev:
 664         free_netdev(dev);
 665 err_out_regions:
 666 #ifdef CONFIG_PCI
 667         if (pdev)
 668                 pci_release_regions(pdev);
 669 #endif
 670 err_out:
 671         if (pdev)
 672                 pci_disable_device(pdev);
 673         return rc;
 674 }
 675
 676
 677 static void TLan_Eisa_Cleanup(void)
 678 {
 679         struct net_device *dev;
 680         TLanPrivateInfo *priv;
 681
 682         while( tlan_have_eisa ) {
 683                 dev = TLan_Eisa_Devices;
 684                 priv = netdev_priv(dev);
 685                 if (priv->dmaStorage) {
 686                         pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
 687                 }
 688                 release_region( dev->base_addr, 0x10);
 689                 unregister_netdev( dev );
 690                 TLan_Eisa_Devices = priv->nextDevice;
 691                 free_netdev( dev );
 692                 tlan_have_eisa--;
 693         }
 694 }
 695
 696
 697 static void __exit tlan_exit(void)
 698 {
 699         pci_unregister_driver(&tlan_driver);
 700
 701         if (tlan_have_eisa)
 702                 TLan_Eisa_Cleanup();
 703
 704         pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
 705
 706 }
 707
 708
 709 /* Module loading/unloading */
 710 module_init(tlan_probe);
 711 module_exit(tlan_exit);
 712
 713
 714
 715         /**************************************************************
 716          *      TLan_EisaProbe
 717          *
 718          *      Returns: 0 on success, 1 otherwise
 719          *
 720          *      Parms:   None
 721          *
 722          *
 723          *      This functions probes for EISA devices and calls
 724          *      TLan_probe1 when one is found.
 725          *
 726          *************************************************************/
 727
 728 static void  __init TLan_EisaProbe (void)
 729 {
 730         long    ioaddr;
 731         int     rc = -ENODEV;
 732         int     irq;
 733         u16     device_id;
 734
 735         if (!EISA_bus) {
 736                 TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus present\n");
 737                 return;
 738         }
 739
 740         /* Loop through all slots of the EISA bus */
 741         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
 742
 743         TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
 744         TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
 745
 746
 747                 TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
 748                                         (int) ioaddr);
 749                 if (request_region(ioaddr, 0x10, TLanSignature) == NULL)
 750                         goto out;
 751
 752                 if (inw(ioaddr + EISA_ID) != 0x110E) {
 753                         release_region(ioaddr, 0x10);
 754                         goto out;
 755                 }
 756
 757                 device_id = inw(ioaddr + EISA_ID2);
 758                 if (device_id !=  0x20F1 && device_id != 0x40F1) {
 759                         release_region (ioaddr, 0x10);
 760                         goto out;
 761                 }
 762
 763                 if (inb(ioaddr + EISA_CR) != 0x1) {     /* Check if adapter is enabled */
 764                         release_region (ioaddr, 0x10);
 765                         goto out2;
 766                 }
 767
 768                 if (debug == 0x10)
 769                         printk("Found one\n");
 770
 771
 772                 /* Get irq from board */
 773                 switch (inb(ioaddr + 0xCC0)) {
 774                         case(0x10):
 775                                 irq=5;
 776                                 break;
 777                         case(0x20):
 778                                 irq=9;
 779                                 break;
 780                         case(0x40):
 781                                 irq=10;
 782                                 break;
 783                         case(0x80):
 784                                 irq=11;
 785                                 break;
 786                         default:
 787                                 goto out;
 788                 }
 789
 790
 791                 /* Setup the newly found eisa adapter */
 792                 rc = TLan_probe1( NULL, ioaddr, irq,
 793                                         12, NULL);
 794                 continue;
 795
 796                 out:
 797                         if (debug == 0x10)
 798                                 printk("None found\n");
 799                         continue;
 800
 801                 out2:   if (debug == 0x10)
 802                                 printk("Card found but it is not enabled, skipping\n");
 803                         continue;
 804
 805         }
 806
 807 } /* TLan_EisaProbe */
 808
 809 #ifdef CONFIG_NET_POLL_CONTROLLER
 810 static void TLan_Poll(struct net_device *dev)
 811 {
 812         disable_irq(dev->irq);
 813         TLan_HandleInterrupt(dev->irq, dev, NULL);
 814         enable_irq(dev->irq);
 815 }
 816 #endif
 817
 818
 819
 820
 821         /***************************************************************
 822          *      TLan_Init
 823          *
 824          *      Returns:
 825          *              0 on success, error code otherwise.
 826          *      Parms:
 827          *              dev     The structure of the device to be
 828          *                      init'ed.
 829          *
 830          *      This function completes the initialization of the
 831          *      device structure and driver.  It reserves the IO
 832          *      addresses, allocates memory for the lists and bounce
 833          *      buffers, retrieves the MAC address from the eeprom
 834          *      and assignes the device's methods.
 835          *
 836          **************************************************************/
 837
 838 static int TLan_Init( struct net_device *dev )
 839 {
 840         int             dma_size;
 841         int             err;
 842         int             i;
 843         TLanPrivateInfo *priv;
 844
 845         priv = netdev_priv(dev);
 846
 847         if ( bbuf ) {
 848                 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
 849                    * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
 850         } else {
 851                 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
 852                    * ( sizeof(TLanList) );
 853         }
 854         priv->dmaStorage = pci_alloc_consistent(priv->pciDev, dma_size, &priv->dmaStorageDMA);
 855         priv->dmaSize = dma_size;
 856
 857         if ( priv->dmaStorage == NULL ) {
 858                 printk(KERN_ERR "TLAN:  Could not allocate lists and buffers for %s.\n",
 859                         dev->name );
 860                 return -ENOMEM;
 861         }
 862         memset( priv->dmaStorage, 0, dma_size );
 863         priv->rxList = (TLanList *)
 864                        ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 );
 865         priv->rxListDMA = ( ( ( (u32) priv->dmaStorageDMA ) + 7 ) & 0xFFFFFFF8 );
 866         priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
 867         priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS;
 868         if ( bbuf ) {
 869                 priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
 870                 priv->rxBufferDMA =priv->txListDMA + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
 871                 priv->txBuffer = priv->rxBuffer + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
 872                 priv->txBufferDMA = priv->rxBufferDMA + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
 873         }
 874
 875         err = 0;
 876         for ( i = 0;  i < 6 ; i++ )
 877                 err |= TLan_EeReadByte( dev,
 878                                         (u8) priv->adapter->addrOfs + i,
 879                                         (u8 *) &dev->dev_addr[i] );
 880         if ( err ) {
 881                 printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %d\n",
 882                         dev->name,
 883                         err );
 884         }
 885         dev->addr_len = 6;
 886
 887         netif_carrier_off(dev);
 888
 889         /* Device methods */
 890         dev->open = &TLan_Open;
 891         dev->hard_start_xmit = &TLan_StartTx;
 892         dev->stop = &TLan_Close;
 893         dev->get_stats = &TLan_GetStats;
 894         dev->set_multicast_list = &TLan_SetMulticastList;
 895         dev->do_ioctl = &TLan_ioctl;
 896 #ifdef CONFIG_NET_POLL_CONTROLLER
 897         dev->poll_controller = &TLan_Poll;
 898 #endif
 899         dev->tx_timeout = &TLan_tx_timeout;
 900         dev->watchdog_timeo = TX_TIMEOUT;
 901
 902         return 0;
 903
 904 } /* TLan_Init */
 905
 906
 907
 908
 909         /***************************************************************
 910          *      TLan_Open
 911          *
 912          *      Returns:
 913          *              0 on success, error code otherwise.
 914          *      Parms:
 915          *              dev     Structure of device to be opened.
 916          *
 917          *      This routine puts the driver and TLAN adapter in a
 918          *      state where it is ready to send and receive packets.
 919          *      It allocates the IRQ, resets and brings the adapter
 920          *      out of reset, and allows interrupts.  It also delays
 921          *      the startup for autonegotiation or sends a Rx GO
 922          *      command to the adapter, as appropriate.
 923          *
 924          **************************************************************/
 925
 926 static int TLan_Open( struct net_device *dev )
 927 {
 928         TLanPrivateInfo *priv = netdev_priv(dev);
 929         int             err;
 930
 931         priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
 932         err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, TLanSignature, dev );
 933
 934         if ( err ) {
 935                 printk(KERN_ERR "TLAN:  Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq );
 936                 return err;
 937         }
 938
 939         init_timer(&priv->timer);
 940         netif_start_queue(dev);
 941
 942         /* NOTE: It might not be necessary to read the stats before a
 943                          reset if you don't care what the values are.
 944         */
 945         TLan_ResetLists( dev );
 946         TLan_ReadAndClearStats( dev, TLAN_IGNORE );
 947         TLan_ResetAdapter( dev );
 948
 949         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %x\n", dev->name, priv->tlanRev );
 950
 951         return 0;
 952
 953 } /* TLan_Open */
 954
 955
 956
 957         /**************************************************************
 958          *      TLan_ioctl
 959          *
 960          *      Returns:
 961          *              0 on success, error code otherwise
 962          *      Params:
 963          *              dev     structure of device to receive ioctl.
 964          *
 965          *              rq      ifreq structure to hold userspace data.
 966          *
 967          *              cmd     ioctl command.
 968          *
 969          *
 970          *************************************************************/
 971
 972 static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 973 {
 974         TLanPrivateInfo *priv = netdev_priv(dev);
 975         struct mii_ioctl_data *data = if_mii(rq);
 976         u32 phy   = priv->phy[priv->phyNum];
 977
 978         if (!priv->phyOnline)
 979                 return -EAGAIN;
 980
 981         switch(cmd) {
 982         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
 983                         data->phy_id = phy;
 984
 985
 986         case SIOCGMIIREG:               /* Read MII PHY register. */
 987                         TLan_MiiReadReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, &data->val_out);
 988                         return 0;
 989
 990
 991         case SIOCSMIIREG:               /* Write MII PHY register. */
 992                         if (!capable(CAP_NET_ADMIN))
 993                                 return -EPERM;
 994                         TLan_MiiWriteReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
 995                         return 0;
 996                 default:
 997                         return -EOPNOTSUPP;
 998         }
 999 } /* tlan_ioctl */
1000
1001
1002         /***************************************************************
1003          *      TLan_tx_timeout
1004          *
1005          *      Returns: nothing
1006          *
1007          *      Params:
1008          *              dev     structure of device which timed out
1009          *                      during transmit.
1010          *
1011          **************************************************************/
1012
1013 static void TLan_tx_timeout(struct net_device *dev)
1014 {
1015
1016         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
1017
1018         /* Ok so we timed out, lets see what we can do about it...*/
1019         TLan_FreeLists( dev );
1020         TLan_ResetLists( dev );
1021         TLan_ReadAndClearStats( dev, TLAN_IGNORE );
1022         TLan_ResetAdapter( dev );
1023         dev->trans_start = jiffies;
1024         netif_wake_queue( dev );
1025
1026 }
1027
1028
1029
1030         /***************************************************************
1031          *      TLan_StartTx
1032          *
1033          *      Returns:
1034          *              0 on success, non-zero on failure.
1035          *      Parms:
1036          *              skb     A pointer to the sk_buff containing the
1037          *                      frame to be sent.
1038          *              dev     The device to send the data on.
1039          *
1040          *      This function adds a frame to the Tx list to be sent
1041          *      ASAP.  First it verifies that the adapter is ready and
1042          *      there is room in the queue.  Then it sets up the next
1043          *      available list, copies the frame to the corresponding
1044          *      buffer.  If the adapter Tx channel is idle, it gives
1045          *      the adapter a Tx Go command on the list, otherwise it
1046          *      sets the forward address of the previous list to point
1047          *      to this one.  Then it frees the sk_buff.
1048          *
1049          **************************************************************/
1050
1051 static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
1052 {
1053         TLanPrivateInfo *priv = netdev_priv(dev);
1054         TLanList        *tail_list;
1055         dma_addr_t      tail_list_phys;
1056         u8              *tail_buffer;
1057         int             pad;
1058         unsigned long   flags;
1059
1060         if ( ! priv->phyOnline ) {
1061                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n", dev->name );
1062                 dev_kfree_skb_any(skb);
1063                 return 0;
1064         }
1065
1066         tail_list = priv->txList + priv->txTail;
1067         tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
1068
1069         if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
1070                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s is busy (Head=%d Tail=%d)\n", dev->name, priv->txHead, priv->txTail );
1071                 netif_stop_queue(dev);
1072                 priv->txBusyCount++;
1073                 return 1;
1074         }
1075
1076         tail_list->forward = 0;
1077
1078         if ( bbuf ) {
1079                 tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
1080                 memcpy( tail_buffer, skb->data, skb->len );
1081         } else {
1082                 tail_list->buffer[0].address = pci_map_single(priv->pciDev, skb->data, skb->len, PCI_DMA_TODEVICE);
1083                 TLan_StoreSKB(tail_list, skb);
1084         }
1085
1086         pad = TLAN_MIN_FRAME_SIZE - skb->len;
1087
1088         if ( pad > 0 ) {
1089                 tail_list->frameSize = (u16) skb->len + pad;
1090                 tail_list->buffer[0].count = (u32) skb->len;
1091                 tail_list->buffer[1].count = TLAN_LAST_BUFFER | (u32) pad;
1092                 tail_list->buffer[1].address = TLanPadBufferDMA;
1093         } else {
1094                 tail_list->frameSize = (u16) skb->len;
1095                 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
1096                 tail_list->buffer[1].count = 0;
1097                 tail_list->buffer[1].address = 0;
1098         }
1099
1100         spin_lock_irqsave(&priv->lock, flags);
1101         tail_list->cStat = TLAN_CSTAT_READY;
1102         if ( ! priv->txInProgress ) {
1103                 priv->txInProgress = 1;
1104                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Starting TX on buffer %d\n", priv->txTail );
1105                 outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM );
1106                 outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
1107         } else {
1108                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Adding buffer %d to TX channel\n", priv->txTail );
1109                 if ( priv->txTail == 0 ) {
1110                         ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = tail_list_phys;
1111                 } else {
1112                         ( priv->txList + ( priv->txTail - 1 ) )->forward = tail_list_phys;
1113                 }
1114         }
1115         spin_unlock_irqrestore(&priv->lock, flags);
1116
1117         CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS );
1118
1119         if ( bbuf )
1120                 dev_kfree_skb_any(skb);
1121
1122         dev->trans_start = jiffies;
1123         return 0;
1124
1125 } /* TLan_StartTx */
1126
1127
1128
1129
1130         /***************************************************************
1131          *      TLan_HandleInterrupt
1132          *
1133          *      Returns:
1134          *              Nothing
1135          *      Parms:
1136          *              irq     The line on which the interrupt
1137          *                      occurred.
1138          *              dev_id  A pointer to the device assigned to
1139          *                      this irq line.
1140          *              regs    ???
1141          *
1142          *      This function handles an interrupt generated by its
1143          *      assigned TLAN adapter.  The function deactivates
1144          *      interrupts on its adapter, records the type of
1145          *      interrupt, executes the appropriate subhandler, and
1146          *      acknowdges the interrupt to the adapter (thus
1147          *      re-enabling adapter interrupts.
1148          *
1149          **************************************************************/
1150
1151 static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *regs)
1152 {
1153         u32             ack;
1154         struct net_device       *dev;
1155         u32             host_cmd;
1156         u16             host_int;
1157         int             type;
1158         TLanPrivateInfo *priv;
1159
1160         dev = dev_id;
1161         priv = netdev_priv(dev);
1162
1163         spin_lock(&priv->lock);
1164
1165         host_int = inw( dev->base_addr + TLAN_HOST_INT );
1166         outw( host_int, dev->base_addr + TLAN_HOST_INT );
1167
1168         type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
1169
1170         ack = TLanIntVector[type]( dev, host_int );
1171
1172         if ( ack ) {
1173                 host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
1174                 outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
1175         }
1176
1177         spin_unlock(&priv->lock);
1178
1179         return IRQ_HANDLED;
1180 } /* TLan_HandleInterrupts */
1181
1182
1183
1184
1185         /***************************************************************
1186          *      TLan_Close
1187          *
1188          *      Returns:
1189          *              An error code.
1190          *      Parms:
1191          *              dev     The device structure of the device to
1192          *                      close.
1193          *
1194          *      This function shuts down the adapter.  It records any
1195          *      stats, puts the adapter into reset state, deactivates
1196          *      its time as needed, and frees the irq it is using.
1197          *
1198          **************************************************************/
1199
1200 static int TLan_Close(struct net_device *dev)
1201 {
1202         TLanPrivateInfo *priv = netdev_priv(dev);
1203
1204         netif_stop_queue(dev);
1205         priv->neg_be_verbose = 0;
1206
1207         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1208         outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1209         if ( priv->timer.function != NULL ) {
1210                 del_timer_sync( &priv->timer );
1211                 priv->timer.function = NULL;
1212         }
1213
1214         free_irq( dev->irq, dev );
1215         TLan_FreeLists( dev );
1216         TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
1217
1218         return 0;
1219
1220 } /* TLan_Close */
1221
1222
1223
1224
1225         /***************************************************************
1226          *      TLan_GetStats
1227          *
1228          *      Returns:
1229          *              A pointer to the device's statistics structure.
1230          *      Parms:
1231          *              dev     The device structure to return the
1232          *                      stats for.
1233          *
1234          *      This function updates the devices statistics by reading
1235          *      the TLAN chip's onboard registers.  Then it returns the
1236          *      address of the statistics structure.
1237          *
1238          **************************************************************/
1239
1240 static struct net_device_stats *TLan_GetStats( struct net_device *dev )
1241 {
1242         TLanPrivateInfo *priv = netdev_priv(dev);
1243         int i;
1244
1245         /* Should only read stats if open ? */
1246         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1247
1248         TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %d\n", dev->name, priv->rxEocCount );
1249         TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %d\n", dev->name, priv->txBusyCount );
1250         if ( debug & TLAN_DEBUG_GNRL ) {
1251                 TLan_PrintDio( dev->base_addr );
1252                 TLan_PhyPrint( dev );
1253         }
1254         if ( debug & TLAN_DEBUG_LIST ) {
1255                 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
1256                         TLan_PrintList( priv->rxList + i, "RX", i );
1257                 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
1258                         TLan_PrintList( priv->txList + i, "TX", i );
1259         }
1260
1261         return ( &( (TLanPrivateInfo *) netdev_priv(dev) )->stats );
1262
1263 } /* TLan_GetStats */
1264
1265
1266
1267
1268         /***************************************************************
1269          *      TLan_SetMulticastList
1270          *
1271          *      Returns:
1272          *              Nothing
1273          *      Parms:
1274          *              dev     The device structure to set the
1275          *                      multicast list for.
1276          *
1277          *      This function sets the TLAN adaptor to various receive
1278          *      modes.  If the IFF_PROMISC flag is set, promiscuous
1279          *      mode is acitviated.  Otherwise, promiscuous mode is
1280          *      turned off.  If the IFF_ALLMULTI flag is set, then
1281          *      the hash table is set to receive all group addresses.
1282          *      Otherwise, the first three multicast addresses are
1283          *      stored in AREG_1-3, and the rest are selected via the
1284          *      hash table, as necessary.
1285          *
1286          **************************************************************/
1287
1288 static void TLan_SetMulticastList( struct net_device *dev )
1289 {
1290         struct dev_mc_list      *dmi = dev->mc_list;
1291         u32                     hash1 = 0;
1292         u32                     hash2 = 0;
1293         int                     i;
1294         u32                     offset;
1295         u8                      tmp;
1296
1297         if ( dev->flags & IFF_PROMISC ) {
1298                 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1299                 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
1300         } else {
1301                 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
1302                 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
1303                 if ( dev->flags & IFF_ALLMULTI ) {
1304                         for ( i = 0; i < 3; i++ )
1305                                 TLan_SetMac( dev, i + 1, NULL );
1306                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
1307                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
1308                 } else {
1309                         for ( i = 0; i < dev->mc_count; i++ ) {
1310                                 if ( i < 3 ) {
1311                                         TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr );
1312                                 } else {
1313                                         offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
1314                                         if ( offset < 32 )
1315                                                 hash1 |= ( 1 << offset );
1316                                         else
1317                                                 hash2 |= ( 1 << ( offset - 32 ) );
1318                                 }
1319                                 dmi = dmi->next;
1320                         }
1321                         for ( ; i < 3; i++ )
1322                                 TLan_SetMac( dev, i + 1, NULL );
1323                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
1324                         TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
1325                 }
1326         }
1327
1328 } /* TLan_SetMulticastList */
1329
1330
1331
1332 /*****************************************************************************
1333 ******************************************************************************
1334
1335         ThunderLAN Driver Interrupt Vectors and Table
1336
1337         Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
1338         Programmer's Guide" for more informations on handling interrupts
1339         generated by TLAN based adapters.
1340
1341 ******************************************************************************
1342 *****************************************************************************/
1343
1344
1345         /***************************************************************
1346          *      TLan_HandleInvalid
1347          *
1348          *      Returns:
1349          *              0
1350          *      Parms:
1351          *              dev             Device assigned the IRQ that was
1352          *                              raised.
1353          *              host_int        The contents of the HOST_INT
1354          *                              port.
1355          *
1356          *      This function handles invalid interrupts.  This should
1357          *      never happen unless some other adapter is trying to use
1358          *      the IRQ line assigned to the device.
1359          *
1360          **************************************************************/
1361
1362 u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
1363 {
1364         /* printk( "TLAN:  Invalid interrupt on %s.\n", dev->name ); */
1365         return 0;
1366
1367 } /* TLan_HandleInvalid */
1368
1369
1370
1371
1372         /***************************************************************
1373          *      TLan_HandleTxEOF
1374          *
1375          *      Returns:
1376          *              1
1377          *      Parms:
1378          *              dev             Device assigned the IRQ that was
1379          *                              raised.
1380          *              host_int        The contents of the HOST_INT
1381          *                              port.
1382          *
1383          *      This function handles Tx EOF interrupts which are raised
1384          *      by the adapter when it has completed sending the
1385          *      contents of a buffer.  If detemines which list/buffer
1386          *      was completed and resets it.  If the buffer was the last
1387          *      in the channel (EOC), then the function checks to see if
1388          *      another buffer is ready to send, and if so, sends a Tx
1389          *      Go command.  Finally, the driver activates/continues the
1390          *      activity LED.
1391          *
1392          **************************************************************/
1393
1394 u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
1395 {
1396         TLanPrivateInfo *priv = netdev_priv(dev);
1397         int             eoc = 0;
1398         TLanList        *head_list;
1399         dma_addr_t      head_list_phys;
1400         u32             ack = 0;
1401         u16             tmpCStat;
1402
1403         TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1404         head_list = priv->txList + priv->txHead;
1405
1406         while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1407                 ack++;
1408                 if ( ! bbuf ) {
1409                         struct sk_buff *skb = TLan_GetSKB(head_list);
1410                         pci_unmap_single(priv->pciDev, head_list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
1411                         dev_kfree_skb_any(skb);
1412                         head_list->buffer[8].address = 0;
1413                         head_list->buffer[9].address = 0;
1414                 }
1415
1416                 if ( tmpCStat & TLAN_CSTAT_EOC )
1417                         eoc = 1;
1418
1419                 priv->stats.tx_bytes += head_list->frameSize;
1420
1421                 head_list->cStat = TLAN_CSTAT_UNUSED;
1422                 netif_start_queue(dev);
1423                 CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS );
1424                 head_list = priv->txList + priv->txHead;
1425         }
1426
1427         if (!ack)
1428                 printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n");
1429
1430         if ( eoc ) {
1431                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
1432                 head_list = priv->txList + priv->txHead;
1433                 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1434                 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1435                         outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1436                         ack |= TLAN_HC_GO;
1437                 } else {
1438                         priv->txInProgress = 0;
1439                 }
1440         }
1441
1442         if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1443                 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1444                 if ( priv->timer.function == NULL ) {
1445                          priv->timer.function = &TLan_Timer;
1446                          priv->timer.data = (unsigned long) dev;
1447                          priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1448                          priv->timerSetAt = jiffies;
1449                          priv->timerType = TLAN_TIMER_ACTIVITY;
1450                          add_timer(&priv->timer);
1451                 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1452                         priv->timerSetAt = jiffies;
1453                 }
1454         }
1455
1456         return ack;
1457
1458 } /* TLan_HandleTxEOF */
1459
1460
1461
1462
1463         /***************************************************************
1464          *      TLan_HandleStatOverflow
1465          *
1466          *      Returns:
1467          *              1
1468          *      Parms:
1469          *              dev             Device assigned the IRQ that was
1470          *                              raised.
1471          *              host_int        The contents of the HOST_INT
1472          *                              port.
1473          *
1474          *      This function handles the Statistics Overflow interrupt
1475          *      which means that one or more of the TLAN statistics
1476          *      registers has reached 1/2 capacity and needs to be read.
1477          *
1478          **************************************************************/
1479
1480 u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
1481 {
1482         TLan_ReadAndClearStats( dev, TLAN_RECORD );
1483
1484         return 1;
1485
1486 } /* TLan_HandleStatOverflow */
1487
1488
1489
1490
1491         /***************************************************************
1492          *      TLan_HandleRxEOF
1493          *
1494          *      Returns:
1495          *              1
1496          *      Parms:
1497          *              dev             Device assigned the IRQ that was
1498          *                              raised.
1499          *              host_int        The contents of the HOST_INT
1500          *                              port.
1501          *
1502          *      This function handles the Rx EOF interrupt which
1503          *      indicates a frame has been received by the adapter from
1504          *      the net and the frame has been transferred to memory.
1505          *      The function determines the bounce buffer the frame has
1506          *      been loaded into, creates a new sk_buff big enough to
1507          *      hold the frame, and sends it to protocol stack.  It
1508          *      then resets the used buffer and appends it to the end
1509          *      of the list.  If the frame was the last in the Rx
1510          *      channel (EOC), the function restarts the receive channel
1511          *      by sending an Rx Go command to the adapter.  Then it
1512          *      activates/continues the activity LED.
1513          *
1514          **************************************************************/
1515
1516 u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
1517 {
1518         TLanPrivateInfo *priv = netdev_priv(dev);
1519         u32             ack = 0;
1520         int             eoc = 0;
1521         u8              *head_buffer;
1522         TLanList        *head_list;
1523         struct sk_buff  *skb;
1524         TLanList        *tail_list;
1525         void            *t;
1526         u32             frameSize;
1527         u16             tmpCStat;
1528         dma_addr_t      head_list_phys;
1529
1530         TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOF (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1531         head_list = priv->rxList + priv->rxHead;
1532         head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1533
1534         while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
1535                 frameSize = head_list->frameSize;
1536                 ack++;
1537                 if (tmpCStat & TLAN_CSTAT_EOC)
1538                         eoc = 1;
1539
1540                 if (bbuf) {
1541                         skb = dev_alloc_skb(frameSize + 7);
1542                         if (skb == NULL)
1543                                 printk(KERN_INFO "TLAN: Couldn't allocate memory for received data.\n");
1544                         else {
1545                                 head_buffer = priv->rxBuffer + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
1546                                 skb->dev = dev;
1547                                 skb_reserve(skb, 2);
1548                                 t = (void *) skb_put(skb, frameSize);
1549
1550                                 priv->stats.rx_bytes += head_list->frameSize;
1551
1552                                 memcpy( t, head_buffer, frameSize );
1553                                 skb->protocol = eth_type_trans( skb, dev );
1554                                 netif_rx( skb );
1555                         }
1556                 } else {
1557                         struct sk_buff *new_skb;
1558
1559                         /*
1560                          *      I changed the algorithm here. What we now do
1561                          *      is allocate the new frame. If this fails we
1562                          *      simply recycle the frame.
1563                          */
1564
1565                         new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1566
1567                         if ( new_skb != NULL ) {
1568                                 skb = TLan_GetSKB(head_list);
1569                                 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1570                                 skb_trim( skb, frameSize );
1571
1572                                 priv->stats.rx_bytes += frameSize;
1573
1574                                 skb->protocol = eth_type_trans( skb, dev );
1575                                 netif_rx( skb );
1576
1577                                 new_skb->dev = dev;
1578                                 skb_reserve( new_skb, 2 );
1579                                 t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
1580                                 head_list->buffer[0].address = pci_map_single(priv->pciDev, new_skb->data, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1581                                 head_list->buffer[8].address = (u32) t;
1582                                 TLan_StoreSKB(head_list, new_skb);
1583                         } else
1584                                 printk(KERN_WARNING "TLAN:  Couldn't allocate memory for received data.\n" );
1585                 }
1586
1587                 head_list->forward = 0;
1588                 head_list->cStat = 0;
1589                 tail_list = priv->rxList + priv->rxTail;
1590                 tail_list->forward = head_list_phys;
1591
1592                 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
1593                 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
1594                 head_list = priv->rxList + priv->rxHead;
1595                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1596         }
1597
1598         if (!ack)
1599                 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
1600
1601
1602
1603
1604         if ( eoc ) {
1605                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1606                 head_list = priv->rxList + priv->rxHead;
1607                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1608                 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1609                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1610                 priv->rxEocCount++;
1611         }
1612
1613         if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1614                 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1615                 if ( priv->timer.function == NULL )  {
1616                         priv->timer.function = &TLan_Timer;
1617                         priv->timer.data = (unsigned long) dev;
1618                         priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1619                         priv->timerSetAt = jiffies;
1620                         priv->timerType = TLAN_TIMER_ACTIVITY;
1621                         add_timer(&priv->timer);
1622                 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1623                         priv->timerSetAt = jiffies;
1624                 }
1625         }
1626
1627         dev->last_rx = jiffies;
1628
1629         return ack;
1630
1631 } /* TLan_HandleRxEOF */
1632
1633
1634
1635
1636         /***************************************************************
1637          *      TLan_HandleDummy
1638          *
1639          *      Returns:
1640          *              1
1641          *      Parms:
1642          *              dev             Device assigned the IRQ that was
1643          *                              raised.
1644          *              host_int        The contents of the HOST_INT
1645          *                              port.
1646          *
1647          *      This function handles the Dummy interrupt, which is
1648          *      raised whenever a test interrupt is generated by setting
1649          *      the Req_Int bit of HOST_CMD to 1.
1650          *
1651          **************************************************************/
1652
1653 u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
1654 {
1655         printk( "TLAN:  Test interrupt on %s.\n", dev->name );
1656         return 1;
1657
1658 } /* TLan_HandleDummy */
1659
1660
1661
1662
1663         /***************************************************************
1664          *      TLan_HandleTxEOC
1665          *
1666          *      Returns:
1667          *              1
1668          *      Parms:
1669          *              dev             Device assigned the IRQ that was
1670          *                              raised.
1671          *              host_int        The contents of the HOST_INT
1672          *                              port.
1673          *
1674          *      This driver is structured to determine EOC occurrences by
1675          *      reading the CSTAT member of the list structure.  Tx EOC
1676          *      interrupts are disabled via the DIO INTDIS register.
1677          *      However, TLAN chips before revision 3.0 didn't have this
1678          *      functionality, so process EOC events if this is the
1679          *      case.
1680          *
1681          **************************************************************/
1682
1683 u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
1684 {
1685         TLanPrivateInfo *priv = netdev_priv(dev);
1686         TLanList                *head_list;
1687         dma_addr_t              head_list_phys;
1688         u32                     ack = 1;
1689
1690         host_int = 0;
1691         if ( priv->tlanRev < 0x30 ) {
1692                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail );
1693                 head_list = priv->txList + priv->txHead;
1694                 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1695                 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1696                         netif_stop_queue(dev);
1697                         outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1698                         ack |= TLAN_HC_GO;
1699                 } else {
1700                         priv->txInProgress = 0;
1701                 }
1702         }
1703
1704         return ack;
1705
1706 } /* TLan_HandleTxEOC */
1707
1708
1709
1710
1711         /***************************************************************
1712          *      TLan_HandleStatusCheck
1713          *
1714          *      Returns:
1715          *              0 if Adapter check, 1 if Network Status check.
1716          *      Parms:
1717          *              dev             Device assigned the IRQ that was
1718          *                              raised.
1719          *              host_int        The contents of the HOST_INT
1720          *                              port.
1721          *
1722          *      This function handles Adapter Check/Network Status
1723          *      interrupts generated by the adapter.  It checks the
1724          *      vector in the HOST_INT register to determine if it is
1725          *      an Adapter Check interrupt.  If so, it resets the
1726          *      adapter.  Otherwise it clears the status registers
1727          *      and services the PHY.
1728          *
1729          **************************************************************/
1730
1731 u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1732 {
1733         TLanPrivateInfo *priv = netdev_priv(dev);
1734         u32             ack;
1735         u32             error;
1736         u8              net_sts;
1737         u32             phy;
1738         u16             tlphy_ctl;
1739         u16             tlphy_sts;
1740
1741         ack = 1;
1742         if ( host_int & TLAN_HI_IV_MASK ) {
1743                 netif_stop_queue( dev );
1744                 error = inl( dev->base_addr + TLAN_CH_PARM );
1745                 printk( "TLAN:  %s: Adaptor Error = 0x%x\n", dev->name, error );
1746                 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1747                 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1748
1749                 schedule_work(&priv->tlan_tqueue);
1750
1751                 netif_wake_queue(dev);
1752                 ack = 0;
1753         } else {
1754                 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name );
1755                 phy = priv->phy[priv->phyNum];
1756
1757                 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
1758                 if ( net_sts ) {
1759                         TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
1760                         TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %x\n", dev->name, (unsigned) net_sts );
1761                 }
1762                 if ( ( net_sts & TLAN_NET_STS_MIRQ ) &&  ( priv->phyNum == 0 ) ) {
1763                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
1764                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
1765                         if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1766                                 tlphy_ctl |= TLAN_TC_SWAPOL;
1767                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1768                         } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1769                                 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1770                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1771                         }
1772
1773                         if (debug) {
1774                                 TLan_PhyPrint( dev );
1775                         }
1776                 }
1777         }
1778
1779         return ack;
1780
1781 } /* TLan_HandleStatusCheck */
1782
1783
1784
1785
1786         /***************************************************************
1787          *      TLan_HandleRxEOC
1788          *
1789          *      Returns:
1790          *              1
1791          *      Parms:
1792          *              dev             Device assigned the IRQ that was
1793          *                              raised.
1794          *              host_int        The contents of the HOST_INT
1795          *                              port.
1796          *
1797          *      This driver is structured to determine EOC occurrences by
1798          *      reading the CSTAT member of the list structure.  Rx EOC
1799          *      interrupts are disabled via the DIO INTDIS register.
1800          *      However, TLAN chips before revision 3.0 didn't have this
1801          *      CSTAT member or a INTDIS register, so if this chip is
1802          *      pre-3.0, process EOC interrupts normally.
1803          *
1804          **************************************************************/
1805
1806 u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1807 {
1808         TLanPrivateInfo *priv = netdev_priv(dev);
1809         dma_addr_t      head_list_phys;
1810         u32             ack = 1;
1811
1812         if (  priv->tlanRev < 0x30 ) {
1813                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail );
1814                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1815                 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1816                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1817                 priv->rxEocCount++;
1818         }
1819
1820         return ack;
1821
1822 } /* TLan_HandleRxEOC */
1823
1824
1825
1826
1827 /*****************************************************************************
1828 ******************************************************************************
1829
1830         ThunderLAN Driver Timer Function
1831
1832 ******************************************************************************
1833 *****************************************************************************/
1834
1835
1836         /***************************************************************
1837          *      TLan_Timer
1838          *
1839          *      Returns:
1840          *              Nothing
1841          *      Parms:
1842          *              data    A value given to add timer when
1843          *                      add_timer was called.
1844          *
1845          *      This function handles timed functionality for the
1846          *      TLAN driver.  The two current timer uses are for
1847          *      delaying for autonegotionation and driving the ACT LED.
1848          *      -       Autonegotiation requires being allowed about
1849          *              2 1/2 seconds before attempting to transmit a
1850          *              packet.  It would be a very bad thing to hang
1851          *              the kernel this long, so the driver doesn't
1852          *              allow transmission 'til after this time, for
1853          *              certain PHYs.  It would be much nicer if all
1854          *              PHYs were interrupt-capable like the internal
1855          *              PHY.
1856          *      -       The ACT LED, which shows adapter activity, is
1857          *              driven by the driver, and so must be left on
1858          *              for a short period to power up the LED so it
1859          *              can be seen.  This delay can be changed by
1860          *              changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1861          *              if desired.  100 ms  produces a slightly
1862          *              sluggish response.
1863          *
1864          **************************************************************/
1865
1866 void TLan_Timer( unsigned long data )
1867 {
1868         struct net_device       *dev = (struct net_device *) data;
1869         TLanPrivateInfo *priv = netdev_priv(dev);
1870         u32             elapsed;
1871         unsigned long   flags = 0;
1872
1873         priv->timer.function = NULL;
1874
1875         switch ( priv->timerType ) {
1876 #ifdef MONITOR
1877                 case TLAN_TIMER_LINK_BEAT:
1878                         TLan_PhyMonitor( dev );
1879                         break;
1880 #endif
1881                 case TLAN_TIMER_PHY_PDOWN:
1882                         TLan_PhyPowerDown( dev );
1883                         break;
1884                 case TLAN_TIMER_PHY_PUP:
1885                         TLan_PhyPowerUp( dev );
1886                         break;
1887                 case TLAN_TIMER_PHY_RESET:
1888                         TLan_PhyReset( dev );
1889                         break;
1890                 case TLAN_TIMER_PHY_START_LINK:
1891                         TLan_PhyStartLink( dev );
1892                         break;
1893                 case TLAN_TIMER_PHY_FINISH_AN:
1894                         TLan_PhyFinishAutoNeg( dev );
1895                         break;
1896                 case TLAN_TIMER_FINISH_RESET:
1897                         TLan_FinishReset( dev );
1898                         break;
1899                 case TLAN_TIMER_ACTIVITY:
1900                         spin_lock_irqsave(&priv->lock, flags);
1901                         if ( priv->timer.function == NULL ) {
1902                                 elapsed = jiffies - priv->timerSetAt;
1903                                 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
1904                                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
1905                                 } else  {
1906                                         priv->timer.function = &TLan_Timer;
1907                                         priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
1908                                         spin_unlock_irqrestore(&priv->lock, flags);
1909                                         add_timer( &priv->timer );
1910                                         break;
1911                                 }
1912                         }
1913                         spin_unlock_irqrestore(&priv->lock, flags);
1914                         break;
1915                 default:
1916                         break;
1917         }
1918
1919 } /* TLan_Timer */
1920
1921
1922
1923
1924 /*****************************************************************************
1925 ******************************************************************************
1926
1927         ThunderLAN Driver Adapter Related Routines
1928
1929 ******************************************************************************
1930 *****************************************************************************/
1931
1932
1933         /***************************************************************
1934          *      TLan_ResetLists
1935          *
1936          *      Returns:
1937          *              Nothing
1938          *      Parms:
1939          *              dev     The device structure with the list
1940          *                      stuctures to be reset.
1941          *
1942          *      This routine sets the variables associated with managing
1943          *      the TLAN lists to their initial values.
1944          *
1945          **************************************************************/
1946
1947 void TLan_ResetLists( struct net_device *dev )
1948 {
1949         TLanPrivateInfo *priv = netdev_priv(dev);
1950         int             i;
1951         TLanList        *list;
1952         dma_addr_t      list_phys;
1953         struct sk_buff  *skb;
1954         void            *t = NULL;
1955
1956         priv->txHead = 0;
1957         priv->txTail = 0;
1958         for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
1959                 list = priv->txList + i;
1960                 list->cStat = TLAN_CSTAT_UNUSED;
1961                 if ( bbuf ) {
1962                         list->buffer[0].address = priv->txBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1963                 } else {
1964                         list->buffer[0].address = 0;
1965                 }
1966                 list->buffer[2].count = 0;
1967                 list->buffer[2].address = 0;
1968                 list->buffer[8].address = 0;
1969                 list->buffer[9].address = 0;
1970         }
1971
1972         priv->rxHead = 0;
1973         priv->rxTail = TLAN_NUM_RX_LISTS - 1;
1974         for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
1975                 list = priv->rxList + i;
1976                 list_phys = priv->rxListDMA + sizeof(TLanList) * i;
1977                 list->cStat = TLAN_CSTAT_READY;
1978                 list->frameSize = TLAN_MAX_FRAME_SIZE;
1979                 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
1980                 if ( bbuf ) {
1981                         list->buffer[0].address = priv->rxBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1982                 } else {
1983                         skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1984                         if ( skb == NULL ) {
1985                                 printk( "TLAN:  Couldn't allocate memory for received data.\n" );
1986                                 /* If this ever happened it would be a problem */
1987                         } else {
1988                                 skb->dev = dev;
1989                                 skb_reserve( skb, 2 );
1990                                 t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
1991                         }
1992                         list->buffer[0].address = pci_map_single(priv->pciDev, t, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1993                         list->buffer[8].address = (u32) t;
1994                         TLan_StoreSKB(list, skb);
1995                 }
1996                 list->buffer[1].count = 0;
1997                 list->buffer[1].address = 0;
1998                 if ( i < TLAN_NUM_RX_LISTS - 1 )
1999                         list->forward = list_phys + sizeof(TLanList);
2000                 else
2001                         list->forward = 0;
2002         }
2003
2004 } /* TLan_ResetLists */
2005
2006
2007 void TLan_FreeLists( struct net_device *dev )
2008 {
2009         TLanPrivateInfo *priv = netdev_priv(dev);
2010         int             i;
2011         TLanList        *list;
2012         struct sk_buff  *skb;
2013
2014         if ( ! bbuf ) {
2015                 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
2016                         list = priv->txList + i;
2017                         skb = TLan_GetSKB(list);
2018                         if ( skb ) {
2019                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
2020                                 dev_kfree_skb_any( skb );
2021                                 list->buffer[8].address = 0;
2022                                 list->buffer[9].address = 0;
2023                         }
2024                 }
2025
2026                 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2027                         list = priv->rxList + i;
2028                         skb = TLan_GetSKB(list);
2029                         if ( skb ) {
2030                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2031                                 dev_kfree_skb_any( skb );
2032                                 list->buffer[8].address = 0;
2033                                 list->buffer[9].address = 0;
2034                         }
2035                 }
2036         }
2037 } /* TLan_FreeLists */
2038
2039
2040
2041
2042         /***************************************************************
2043          *      TLan_PrintDio
2044          *
2045          *      Returns:
2046          *              Nothing
2047          *      Parms:
2048          *              io_base         Base IO port of the device of
2049          *                              which to print DIO registers.
2050          *
2051          *      This function prints out all the internal (DIO)
2052          *      registers of a TLAN chip.
2053          *
2054          **************************************************************/
2055
2056 void TLan_PrintDio( u16 io_base )
2057 {
2058         u32 data0, data1;
2059         int     i;
2060
2061         printk( "TLAN:   Contents of internal registers for io base 0x%04hx.\n", io_base );
2062         printk( "TLAN:      Off.  +0         +4\n" );
2063         for ( i = 0; i < 0x4C; i+= 8 ) {
2064                 data0 = TLan_DioRead32( io_base, i );
2065                 data1 = TLan_DioRead32( io_base, i + 0x4 );
2066                 printk( "TLAN:      0x%02x  0x%08x 0x%08x\n", i, data0, data1 );
2067         }
2068
2069 } /* TLan_PrintDio */
2070
2071
2072
2073
2074         /***************************************************************
2075          *      TLan_PrintList
2076          *
2077          *      Returns:
2078          *              Nothing
2079          *      Parms:
2080          *              list    A pointer to the TLanList structure to
2081          *                      be printed.
2082          *              type    A string to designate type of list,
2083          *                      "Rx" or "Tx".
2084          *              num     The index of the list.
2085          *
2086          *      This function prints out the contents of the list
2087          *      pointed to by the list parameter.
2088          *
2089          **************************************************************/
2090
2091 void TLan_PrintList( TLanList *list, char *type, int num)
2092 {
2093         int i;
2094
2095         printk( "TLAN:   %s List %d at 0x%08x\n", type, num, (u32) list );
2096         printk( "TLAN:      Forward    = 0x%08x\n",  list->forward );
2097         printk( "TLAN:      CSTAT      = 0x%04hx\n", list->cStat );
2098         printk( "TLAN:      Frame Size = 0x%04hx\n", list->frameSize );
2099         /* for ( i = 0; i < 10; i++ ) { */
2100         for ( i = 0; i < 2; i++ ) {
2101                 printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address );
2102         }
2103
2104 } /* TLan_PrintList */
2105
2106
2107
2108
2109         /***************************************************************
2110          *      TLan_ReadAndClearStats
2111          *
2112          *      Returns:
2113          *              Nothing
2114          *      Parms:
2115          *              dev     Pointer to device structure of adapter
2116          *                      to which to read stats.
2117          *              record  Flag indicating whether to add
2118          *
2119          *      This functions reads all the internal status registers
2120          *      of the TLAN chip, which clears them as a side effect.
2121          *      It then either adds the values to the device's status
2122          *      struct, or discards them, depending on whether record
2123          *      is TLAN_RECORD (!=0)  or TLAN_IGNORE (==0).
2124          *
2125          **************************************************************/
2126
2127 void TLan_ReadAndClearStats( struct net_device *dev, int record )
2128 {
2129         TLanPrivateInfo *priv = netdev_priv(dev);
2130         u32             tx_good, tx_under;
2131         u32             rx_good, rx_over;
2132         u32             def_tx, crc, code;
2133         u32             multi_col, single_col;
2134         u32             excess_col, late_col, loss;
2135
2136         outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2137         tx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2138         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2139         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2140         tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2141
2142         outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2143         rx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2144         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2145         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2146         rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2147
2148         outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2149         def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
2150         def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2151         crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2152         code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2153
2154         outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2155         multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
2156         multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2157         single_col  = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2158         single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2159
2160         outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2161         excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2162         late_col   = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2163         loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2164
2165         if ( record ) {
2166                 priv->stats.rx_packets += rx_good;
2167                 priv->stats.rx_errors  += rx_over + crc + code;
2168                 priv->stats.tx_packets += tx_good;
2169                 priv->stats.tx_errors  += tx_under + loss;
2170                 priv->stats.collisions += multi_col + single_col + excess_col + late_col;
2171
2172                 priv->stats.rx_over_errors    += rx_over;
2173                 priv->stats.rx_crc_errors     += crc;
2174                 priv->stats.rx_frame_errors   += code;
2175
2176                 priv->stats.tx_aborted_errors += tx_under;
2177                 priv->stats.tx_carrier_errors += loss;
2178         }
2179
2180 } /* TLan_ReadAndClearStats */
2181
2182
2183
2184
2185         /***************************************************************
2186          *      TLan_Reset
2187          *
2188          *      Returns:
2189          *              0
2190          *      Parms:
2191          *              dev     Pointer to device structure of adapter
2192          *                      to be reset.
2193          *
2194          *      This function resets the adapter and it's physical
2195          *      device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
2196          *      Programmer's Guide" for details.  The routine tries to
2197          *      implement what is detailed there, though adjustments
2198          *      have been made.
2199          *
2200          **************************************************************/
2201
2202 void
2203 TLan_ResetAdapter( struct net_device *dev )
2204 {
2205         TLanPrivateInfo *priv = netdev_priv(dev);
2206         int             i;
2207         u32             addr;
2208         u32             data;
2209         u8              data8;
2210
2211         priv->tlanFullDuplex = FALSE;
2212         priv->phyOnline=0;
2213         netif_carrier_off(dev);
2214
2215 /*  1.  Assert reset bit. */
2216
2217         data = inl(dev->base_addr + TLAN_HOST_CMD);
2218         data |= TLAN_HC_AD_RST;
2219         outl(data, dev->base_addr + TLAN_HOST_CMD);
2220
2221         udelay(1000);
2222
2223 /*  2.  Turn off interrupts. ( Probably isn't necessary ) */
2224
2225         data = inl(dev->base_addr + TLAN_HOST_CMD);
2226         data |= TLAN_HC_INT_OFF;
2227         outl(data, dev->base_addr + TLAN_HOST_CMD);
2228
2229 /*  3.  Clear AREGs and HASHs. */
2230
2231         for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2232                 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2233         }
2234
2235 /*  4.  Setup NetConfig register. */
2236
2237         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2238         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2239
2240 /*  5.  Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2241
2242         outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2243         outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2244
2245 /*  6.  Unreset the MII by setting NMRST (in NetSio) to 1. */
2246
2247         outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2248         addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2249         TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2250
2251 /*  7.  Setup the remaining registers. */
2252
2253         if ( priv->tlanRev >= 0x30 ) {
2254                 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2255                 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2256         }
2257         TLan_PhyDetect( dev );
2258         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2259
2260         if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2261                 data |= TLAN_NET_CFG_BIT;
2262                 if ( priv->aui == 1 ) {
2263                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2264                 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2265                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2266                         priv->tlanFullDuplex = TRUE;
2267                 } else {
2268                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2269                 }
2270         }
2271
2272         if ( priv->phyNum == 0 ) {
2273                 data |= TLAN_NET_CFG_PHY_EN;
2274         }
2275         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2276
2277         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2278                 TLan_FinishReset( dev );
2279         } else {
2280                 TLan_PhyPowerDown( dev );
2281         }
2282
2283 } /* TLan_ResetAdapter */
2284
2285
2286
2287
2288 void
2289 TLan_FinishReset( struct net_device *dev )
2290 {
2291         TLanPrivateInfo *priv = netdev_priv(dev);
2292         u8              data;
2293         u32             phy;
2294         u8              sio;
2295         u16             status;
2296         u16             partner;
2297         u16             tlphy_ctl;
2298         u16             tlphy_par;
2299         u16             tlphy_id1, tlphy_id2;
2300         int             i;
2301
2302         phy = priv->phy[priv->phyNum];
2303
2304         data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2305         if ( priv->tlanFullDuplex ) {
2306                 data |= TLAN_NET_CMD_DUPLEX;
2307         }
2308         TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2309         data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2310         if ( priv->phyNum == 0 ) {
2311                 data |= TLAN_NET_MASK_MASK7;
2312         }
2313         TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2314         TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2315         TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2316         TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2317
2318         if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
2319                 status = MII_GS_LINK;
2320                 printk( "TLAN:  %s: Link forced.\n", dev->name );
2321         } else {
2322                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2323                 udelay( 1000 );
2324                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2325                 if ( (status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */
2326                         (tlphy_id1 == NAT_SEM_ID1) &&
2327                         (tlphy_id2 == NAT_SEM_ID2) ) {
2328                         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2329                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2330
2331                         printk( "TLAN: %s: Link active with ", dev->name );
2332                         if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2333                                  printk( "forced 10%sMbps %s-Duplex\n",
2334                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2335                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2336                         } else {
2337                                 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2338                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2339                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2340                                 printk("TLAN: Partner capability: ");
2341                                         for (i = 5; i <= 10; i++)
2342                                                 if (partner & (1<<i))
2343                                                         printk("%s",media[i-5]);
2344                                 printk("\n");
2345                         }
2346
2347                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2348 #ifdef MONITOR
2349                         /* We have link beat..for now anyway */
2350                         priv->link = 1;
2351                         /*Enabling link beat monitoring */
2352                         TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2353 #endif
2354                 } else if (status & MII_GS_LINK)  {
2355                         printk( "TLAN: %s: Link active\n", dev->name );
2356                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2357                 }
2358         }
2359
2360         if ( priv->phyNum == 0 ) {
2361                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2362                 tlphy_ctl |= TLAN_TC_INTEN;
2363                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2364                 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2365                 sio |= TLAN_NET_SIO_MINTEN;
2366                 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2367         }
2368
2369         if ( status & MII_GS_LINK ) {
2370                 TLan_SetMac( dev, 0, dev->dev_addr );
2371                 priv->phyOnline = 1;
2372                 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2373                 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2374                         outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2375                 }
2376                 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2377                 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2378                 netif_carrier_on(dev);
2379         } else {
2380                 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
2381                 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2382                 return;
2383         }
2384
2385 } /* TLan_FinishReset */
2386
2387
2388
2389
2390         /***************************************************************
2391          *      TLan_SetMac
2392          *
2393          *      Returns:
2394          *              Nothing
2395          *      Parms:
2396          *              dev     Pointer to device structure of adapter
2397          *                      on which to change the AREG.
2398          *              areg    The AREG to set the address in (0 - 3).
2399          *              mac     A pointer to an array of chars.  Each
2400          *                      element stores one byte of the address.
2401          *                      IE, it isn't in ascii.
2402          *
2403          *      This function transfers a MAC address to one of the
2404          *      TLAN AREGs (address registers).  The TLAN chip locks
2405          *      the register on writing to offset 0 and unlocks the
2406          *      register after writing to offset 5.  If NULL is passed
2407          *      in mac, then the AREG is filled with 0's.
2408          *
2409          **************************************************************/
2410
2411 void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2412 {
2413         int i;
2414
2415         areg *= 6;
2416
2417         if ( mac != NULL ) {
2418                 for ( i = 0; i < 6; i++ )
2419                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
2420         } else {
2421                 for ( i = 0; i < 6; i++ )
2422                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
2423         }
2424
2425 } /* TLan_SetMac */
2426
2427
2428
2429
2430 /*****************************************************************************
2431 ******************************************************************************
2432
2433         ThunderLAN Driver PHY Layer Routines
2434
2435 ******************************************************************************
2436 *****************************************************************************/
2437
2438
2439
2440         /*********************************************************************
2441          *      TLan_PhyPrint
2442          *
2443          *      Returns:
2444          *              Nothing
2445          *      Parms:
2446          *              dev     A pointer to the device structure of the
2447          *                      TLAN device having the PHYs to be detailed.
2448          *
2449          *      This function prints the registers a PHY (aka transceiver).
2450          *
2451          ********************************************************************/
2452
2453 void TLan_PhyPrint( struct net_device *dev )
2454 {
2455         TLanPrivateInfo *priv = netdev_priv(dev);
2456         u16 i, data0, data1, data2, data3, phy;
2457
2458         phy = priv->phy[priv->phyNum];
2459
2460         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2461                 printk( "TLAN:   Device %s, Unmanaged PHY.\n", dev->name );
2462         } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2463                 printk( "TLAN:   Device %s, PHY 0x%02x.\n", dev->name, phy );
2464                 printk( "TLAN:      Off.  +0     +1     +2     +3 \n" );
2465                 for ( i = 0; i < 0x20; i+= 4 ) {
2466                         printk( "TLAN:      0x%02x", i );
2467                         TLan_MiiReadReg( dev, phy, i, &data0 );
2468                         printk( " 0x%04hx", data0 );
2469                         TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2470                         printk( " 0x%04hx", data1 );
2471                         TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2472                         printk( " 0x%04hx", data2 );
2473                         TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2474                         printk( " 0x%04hx\n", data3 );
2475                 }
2476         } else {
2477                 printk( "TLAN:   Device %s, Invalid PHY.\n", dev->name );
2478         }
2479
2480 } /* TLan_PhyPrint */
2481
2482
2483
2484
2485         /*********************************************************************
2486          *      TLan_PhyDetect
2487          *
2488          *      Returns:
2489          *              Nothing
2490          *      Parms:
2491          *              dev     A pointer to the device structure of the adapter
2492          *                      for which the PHY needs determined.
2493          *
2494          *      So far I've found that adapters which have external PHYs
2495          *      may also use the internal PHY for part of the functionality.
2496          *      (eg, AUI/Thinnet).  This function finds out if this TLAN
2497          *      chip has an internal PHY, and then finds the first external
2498          *      PHY (starting from address 0) if it exists).
2499          *
2500          ********************************************************************/
2501
2502 void TLan_PhyDetect( struct net_device *dev )
2503 {
2504         TLanPrivateInfo *priv = netdev_priv(dev);
2505         u16             control;
2506         u16             hi;
2507         u16             lo;
2508         u32             phy;
2509
2510         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2511                 priv->phyNum = 0xFFFF;
2512                 return;
2513         }
2514
2515         TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2516
2517         if ( hi != 0xFFFF ) {
2518                 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2519         } else {
2520                 priv->phy[0] = TLAN_PHY_NONE;
2521         }
2522
2523         priv->phy[1] = TLAN_PHY_NONE;
2524         for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2525                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2526                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2527                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2528                 if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2529                         TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
2530                         if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
2531                                 priv->phy[1] = phy;
2532                         }
2533                 }
2534         }
2535
2536         if ( priv->phy[1] != TLAN_PHY_NONE ) {
2537                 priv->phyNum = 1;
2538         } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2539                 priv->phyNum = 0;
2540         } else {
2541                 printk( "TLAN:  Cannot initialize device, no PHY was found!\n" );
2542         }
2543
2544 } /* TLan_PhyDetect */
2545
2546
2547
2548
2549 void TLan_PhyPowerDown( struct net_device *dev )
2550 {
2551         TLanPrivateInfo *priv = netdev_priv(dev);
2552         u16             value;
2553
2554         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2555         value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2556         TLan_MiiSync( dev->base_addr );
2557         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2558         if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2559                 TLan_MiiSync( dev->base_addr );
2560                 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2561         }
2562
2563         /* Wait for 50 ms and powerup
2564          * This is abitrary.  It is intended to make sure the
2565          * transceiver settles.
2566          */
2567         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2568
2569 } /* TLan_PhyPowerDown */
2570
2571
2572
2573
2574 void TLan_PhyPowerUp( struct net_device *dev )
2575 {
2576         TLanPrivateInfo *priv = netdev_priv(dev);
2577         u16             value;
2578
2579         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2580         TLan_MiiSync( dev->base_addr );
2581         value = MII_GC_LOOPBK;
2582         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2583         TLan_MiiSync(dev->base_addr);
2584         /* Wait for 500 ms and reset the
2585          * transceiver.  The TLAN docs say both 50 ms and
2586          * 500 ms, so do the longer, just in case.
2587          */
2588         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2589
2590 } /* TLan_PhyPowerUp */
2591
2592
2593
2594
2595 void TLan_PhyReset( struct net_device *dev )
2596 {
2597         TLanPrivateInfo *priv = netdev_priv(dev);
2598         u16             phy;
2599         u16             value;
2600
2601         phy = priv->phy[priv->phyNum];
2602
2603         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2604         TLan_MiiSync( dev->base_addr );
2605         value = MII_GC_LOOPBK | MII_GC_RESET;
2606         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2607         TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2608         while ( value & MII_GC_RESET ) {
2609                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2610         }
2611
2612         /* Wait for 500 ms and initialize.
2613          * I don't remember why I wait this long.
2614          * I've changed this to 50ms, as it seems long enough.
2615          */
2616         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2617
2618 } /* TLan_PhyReset */
2619
2620
2621
2622
2623 void TLan_PhyStartLink( struct net_device *dev )
2624 {
2625         TLanPrivateInfo *priv = netdev_priv(dev);
2626         u16             ability;
2627         u16             control;
2628         u16             data;
2629         u16             phy;
2630         u16             status;
2631         u16             tctl;
2632
2633         phy = priv->phy[priv->phyNum];
2634         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2635         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2636         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2637
2638         if ( ( status & MII_GS_AUTONEG ) &&
2639              ( ! priv->aui ) ) {
2640                 ability = status >> 11;
2641                 if ( priv->speed  == TLAN_SPEED_10 &&
2642                      priv->duplex == TLAN_DUPLEX_HALF) {
2643                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2644                 } else if ( priv->speed == TLAN_SPEED_10 &&
2645                             priv->duplex == TLAN_DUPLEX_FULL) {
2646                         priv->tlanFullDuplex = TRUE;
2647                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2648                 } else if ( priv->speed == TLAN_SPEED_100 &&
2649                             priv->duplex == TLAN_DUPLEX_HALF) {
2650                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2651                 } else if ( priv->speed == TLAN_SPEED_100 &&
2652                             priv->duplex == TLAN_DUPLEX_FULL) {
2653                         priv->tlanFullDuplex = TRUE;
2654                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2655                 } else {
2656
2657                         /* Set Auto-Neg advertisement */
2658                         TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2659                         /* Enablee Auto-Neg */
2660                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2661                         /* Restart Auto-Neg */
2662                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2663                         /* Wait for 4 sec for autonegotiation
2664                         * to complete.  The max spec time is less than this
2665                         * but the card need additional time to start AN.
2666                         * .5 sec should be plenty extra.
2667                         */
2668                         printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2669                         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2670                         return;
2671                 }
2672
2673         }
2674
2675         if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2676                 priv->phyNum = 0;
2677                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2678                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2679                 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2680                 return;
2681         }  else if ( priv->phyNum == 0 ) {
2682                 control = 0;
2683                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2684                 if ( priv->aui ) {
2685                         tctl |= TLAN_TC_AUISEL;
2686                 } else {
2687                         tctl &= ~TLAN_TC_AUISEL;
2688                         if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2689                                 control |= MII_GC_DUPLEX;
2690                                 priv->tlanFullDuplex = TRUE;
2691                         }
2692                         if ( priv->speed == TLAN_SPEED_100 ) {
2693                                 control |= MII_GC_SPEEDSEL;
2694                         }
2695                 }
2696                 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2697                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2698         }
2699
2700         /* Wait for 2 sec to give the transceiver time
2701          * to establish link.
2702          */
2703         TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2704
2705 } /* TLan_PhyStartLink */
2706
2707
2708
2709
2710 void TLan_PhyFinishAutoNeg( struct net_device *dev )
2711 {
2712         TLanPrivateInfo *priv = netdev_priv(dev);
2713         u16             an_adv;
2714         u16             an_lpa;
2715         u16             data;
2716         u16             mode;
2717         u16             phy;
2718         u16             status;
2719
2720         phy = priv->phy[priv->phyNum];
2721
2722         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2723         udelay( 1000 );
2724         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2725
2726         if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2727                 /* Wait for 8 sec to give the process
2728                  * more time.  Perhaps we should fail after a while.
2729                  */
2730                  if (!priv->neg_be_verbose++) {
2731                          printk(KERN_INFO "TLAN:  Giving autonegotiation more time.\n");
2732                          printk(KERN_INFO "TLAN:  Please check that your adapter has\n");
2733                          printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.\n");
2734                          printk(KERN_INFO "TLAN:  Trying to establish link in the background...\n");
2735                  }
2736                 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2737                 return;
2738         }
2739
2740         printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2741         TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2742         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2743         mode = an_adv & an_lpa & 0x03E0;
2744         if ( mode & 0x0100 ) {
2745                 priv->tlanFullDuplex = TRUE;
2746         } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2747                 priv->tlanFullDuplex = TRUE;
2748         }
2749
2750         if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
2751                 priv->phyNum = 0;
2752                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2753                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2754                 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2755                 return;
2756         }
2757
2758         if ( priv->phyNum == 0 ) {
2759                 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
2760                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
2761                         printk( "TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
2762                 } else {
2763                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2764                         printk( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
2765                 }
2766         }
2767
2768         /* Wait for 100 ms.  No reason in partiticular.
2769          */
2770         TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2771
2772 } /* TLan_PhyFinishAutoNeg */
2773
2774 #ifdef MONITOR
2775
2776         /*********************************************************************
2777         *
2778         *      TLan_phyMonitor
2779         *
2780         *      Returns:
2781         *              None
2782         *
2783         *      Params:
2784         *              dev             The device structure of this device.
2785         *
2786         *
2787         *      This function monitors PHY condition by reading the status
2788         *      register via the MII bus. This can be used to give info
2789         *      about link changes (up/down), and possible switch to alternate
2790         *      media.
2791         *
2792         * ******************************************************************/
2793
2794 void TLan_PhyMonitor( struct net_device *dev )
2795 {
2796         TLanPrivateInfo *priv = netdev_priv(dev);
2797         u16     phy;
2798         u16     phy_status;
2799
2800         phy = priv->phy[priv->phyNum];
2801
2802         /* Get PHY status register */
2803         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2804
2805         /* Check if link has been lost */
2806         if (!(phy_status & MII_GS_LINK)) {
2807                if (priv->link) {
2808                       priv->link = 0;
2809                       printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2810                       dev->flags &= ~IFF_RUNNING;
2811                       TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2812                       return;
2813                 }
2814         }
2815
2816         /* Link restablished? */
2817         if ((phy_status & MII_GS_LINK) && !priv->link) {
2818                 priv->link = 1;
2819                 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2820                 dev->flags |= IFF_RUNNING;
2821         }
2822
2823         /* Setup a new monitor */
2824         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2825 }
2826
2827 #endif /* MONITOR */
2828
2829
2830 /*****************************************************************************
2831 ******************************************************************************
2832
2833         ThunderLAN Driver MII Routines
2834
2835         These routines are based on the information in Chap. 2 of the
2836         "ThunderLAN Programmer's Guide", pp. 15-24.
2837
2838 ******************************************************************************
2839 *****************************************************************************/
2840
2841
2842         /***************************************************************
2843          *      TLan_MiiReadReg
2844          *
2845          *      Returns:
2846          *              0       if ack received ok
2847          *              1       otherwise.
2848          *
2849          *      Parms:
2850          *              dev             The device structure containing
2851          *                              The io address and interrupt count
2852          *                              for this device.
2853          *              phy             The address of the PHY to be queried.
2854          *              reg             The register whose contents are to be
2855          *                              retreived.
2856          *              val             A pointer to a variable to store the
2857          *                              retrieved value.
2858          *
2859          *      This function uses the TLAN's MII bus to retreive the contents
2860          *      of a given register on a PHY.  It sends the appropriate info
2861          *      and then reads the 16-bit register value from the MII bus via
2862          *      the TLAN SIO register.
2863          *
2864          **************************************************************/
2865
2866 int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2867 {
2868         u8      nack;
2869         u16     sio, tmp;
2870         u32     i;
2871         int     err;
2872         int     minten;
2873         TLanPrivateInfo *priv = netdev_priv(dev);
2874         unsigned long flags = 0;
2875
2876         err = FALSE;
2877         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2878         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2879
2880         if (!in_irq())
2881                 spin_lock_irqsave(&priv->lock, flags);
2882
2883         TLan_MiiSync(dev->base_addr);
2884
2885         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2886         if ( minten )
2887                 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2888
2889         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
2890         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Read  ( 10b ) */
2891         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
2892         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
2893
2894
2895         TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio);         /* Change direction */
2896
2897         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Clock Idle bit */
2898         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2899         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Wait 300ns */
2900
2901         nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio);    /* Check for ACK */
2902         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);            /* Finish ACK */
2903         if (nack) {                                     /* No ACK, so fake it */
2904                 for (i = 0; i < 16; i++) {
2905                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2906                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2907                 }
2908                 tmp = 0xffff;
2909                 err = TRUE;
2910         } else {                                        /* ACK, so read data */
2911                 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2912                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2913                         if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2914                                 tmp |= i;
2915                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2916                 }
2917         }
2918
2919
2920         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Idle cycle */
2921         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2922
2923         if ( minten )
2924                 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2925
2926         *val = tmp;
2927
2928         if (!in_irq())
2929                 spin_unlock_irqrestore(&priv->lock, flags);
2930
2931         return err;
2932
2933 } /* TLan_MiiReadReg */
2934
2935
2936
2937
2938         /***************************************************************
2939          *      TLan_MiiSendData
2940          *
2941          *      Returns:
2942          *              Nothing
2943          *      Parms:
2944          *              base_port       The base IO port of the adapter in
2945          *                              question.
2946          *              dev             The address of the PHY to be queried.
2947          *              data            The value to be placed on the MII bus.
2948          *              num_bits        The number of bits in data that are to
2949          *                              be placed on the MII bus.
2950          *
2951          *      This function sends on sequence of bits on the MII
2952          *      configuration bus.
2953          *
2954          **************************************************************/
2955
2956 void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
2957 {
2958         u16 sio;
2959         u32 i;
2960
2961         if ( num_bits == 0 )
2962                 return;
2963
2964         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
2965         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2966         TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
2967
2968         for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
2969                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
2970                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2971                 if ( data & i )
2972                         TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
2973                 else
2974                         TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
2975                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
2976                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2977         }
2978
2979 } /* TLan_MiiSendData */
2980
2981
2982
2983
2984         /***************************************************************
2985          *      TLan_MiiSync
2986          *
2987          *      Returns:
2988          *              Nothing
2989          *      Parms:
2990          *              base_port       The base IO port of the adapter in
2991          *                              question.
2992          *
2993          *      This functions syncs all PHYs in terms of the MII configuration
2994          *      bus.
2995          *
2996          **************************************************************/
2997
2998 void TLan_MiiSync( u16 base_port )
2999 {
3000         int i;
3001         u16 sio;
3002
3003         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3004         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3005
3006         TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3007         for ( i = 0; i < 32; i++ ) {
3008                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3009                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3010         }
3011
3012 } /* TLan_MiiSync */
3013
3014
3015
3016
3017         /***************************************************************
3018          *      TLan_MiiWriteReg
3019          *
3020          *      Returns:
3021          *              Nothing
3022          *      Parms:
3023          *              dev             The device structure for the device
3024          *                              to write to.
3025          *              phy             The address of the PHY to be written to.
3026          *              reg             The register whose contents are to be
3027          *                              written.
3028          *              val             The value to be written to the register.
3029          *
3030          *      This function uses the TLAN's MII bus to write the contents of a
3031          *      given register on a PHY.  It sends the appropriate info and then
3032          *      writes the 16-bit register value from the MII configuration bus
3033          *      via the TLAN SIO register.
3034          *
3035          **************************************************************/
3036
3037 void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3038 {
3039         u16     sio;
3040         int     minten;
3041         unsigned long flags = 0;
3042         TLanPrivateInfo *priv = netdev_priv(dev);
3043
3044         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3045         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3046
3047         if (!in_irq())
3048                 spin_lock_irqsave(&priv->lock, flags);
3049
3050         TLan_MiiSync( dev->base_addr );
3051
3052         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3053         if ( minten )
3054                 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3055
3056         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
3057         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Write ( 01b ) */
3058         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
3059         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
3060
3061         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Send ACK */
3062         TLan_MiiSendData( dev->base_addr, val, 16 );    /* Send Data */
3063
3064         TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );        /* Idle cycle */
3065         TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3066
3067         if ( minten )
3068                 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3069
3070         if (!in_irq())
3071                 spin_unlock_irqrestore(&priv->lock, flags);
3072
3073 } /* TLan_MiiWriteReg */
3074
3075
3076
3077
3078 /*****************************************************************************
3079 ******************************************************************************
3080
3081         ThunderLAN Driver Eeprom routines
3082
3083         The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3084         EEPROM.  These functions are based on information in Microchip's
3085         data sheet.  I don't know how well this functions will work with
3086         other EEPROMs.
3087
3088 ******************************************************************************
3089 *****************************************************************************/
3090
3091
3092         /***************************************************************
3093          *      TLan_EeSendStart
3094          *
3095          *      Returns:
3096          *              Nothing
3097          *      Parms:
3098          *              io_base         The IO port base address for the
3099          *                              TLAN device with the EEPROM to
3100          *                              use.
3101          *
3102          *      This function sends a start cycle to an EEPROM attached
3103          *      to a TLAN chip.
3104          *
3105          **************************************************************/
3106
3107 void TLan_EeSendStart( u16 io_base )
3108 {
3109         u16     sio;
3110
3111         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3112         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3113
3114         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3115         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3116         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3117         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3118         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3119
3120 } /* TLan_EeSendStart */
3121
3122
3123
3124
3125         /***************************************************************
3126          *      TLan_EeSendByte
3127          *
3128          *      Returns:
3129          *              If the correct ack was received, 0, otherwise 1
3130          *      Parms:  io_base         The IO port base address for the
3131          *                              TLAN device with the EEPROM to
3132          *                              use.
3133          *              data            The 8 bits of information to
3134          *                              send to the EEPROM.
3135          *              stop            If TLAN_EEPROM_STOP is passed, a
3136          *                              stop cycle is sent after the
3137          *                              byte is sent after the ack is
3138          *                              read.
3139          *
3140          *      This function sends a byte on the serial EEPROM line,
3141          *      driving the clock to send each bit. The function then
3142          *      reverses transmission direction and reads an acknowledge
3143          *      bit.
3144          *
3145          **************************************************************/
3146
3147 int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3148 {
3149         int     err;
3150         u8      place;
3151         u16     sio;
3152
3153         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3154         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3155
3156         /* Assume clock is low, tx is enabled; */
3157         for ( place = 0x80; place != 0; place >>= 1 ) {
3158                 if ( place & data )
3159                         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3160                 else
3161                         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3162                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3163                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3164         }
3165         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3166         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3167         err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3168         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3169         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3170
3171         if ( ( ! err ) && stop ) {
3172                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3173                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3174                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3175         }
3176
3177         return ( err );
3178
3179 } /* TLan_EeSendByte */
3180
3181
3182
3183
3184         /***************************************************************
3185          *      TLan_EeReceiveByte
3186          *
3187          *      Returns:
3188          *              Nothing
3189          *      Parms:
3190          *              io_base         The IO port base address for the
3191          *                              TLAN device with the EEPROM to
3192          *                              use.
3193          *              data            An address to a char to hold the
3194          *                              data sent from the EEPROM.
3195          *              stop            If TLAN_EEPROM_STOP is passed, a
3196          *                              stop cycle is sent after the
3197          *                              byte is received, and no ack is
3198          *                              sent.
3199          *
3200          *      This function receives 8 bits of data from the EEPROM
3201          *      over the serial link.  It then sends and ack bit, or no
3202          *      ack and a stop bit.  This function is used to retrieve
3203          *      data after the address of a byte in the EEPROM has been
3204          *      sent.
3205          *
3206          **************************************************************/
3207
3208 void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3209 {
3210         u8  place;
3211         u16 sio;
3212
3213         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3214         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3215         *data = 0;
3216
3217         /* Assume clock is low, tx is enabled; */
3218         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3219         for ( place = 0x80; place; place >>= 1 ) {
3220                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3221                 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3222                         *data |= place;
3223                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3224         }
3225
3226         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3227         if ( ! stop ) {
3228                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* Ack = 0 */
3229                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3230                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3231         } else {
3232                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );         /* No ack = 1 (?) */
3233                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3234                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3235                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3236                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3237                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3238         }
3239
3240 } /* TLan_EeReceiveByte */
3241
3242
3243
3244
3245         /***************************************************************
3246          *      TLan_EeReadByte
3247          *
3248          *      Returns:
3249          *              No error = 0, else, the stage at which the error
3250          *              occurred.
3251          *      Parms:
3252          *              io_base         The IO port base address for the
3253          *                              TLAN device with the EEPROM to
3254          *                              use.
3255          *              ee_addr         The address of the byte in the
3256          *                              EEPROM whose contents are to be
3257          *                              retrieved.
3258          *              data            An address to a char to hold the
3259          *                              data obtained from the EEPROM.
3260          *
3261          *      This function reads a byte of information from an byte
3262          *      cell in the EEPROM.
3263          *
3264          **************************************************************/
3265
3266 int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3267 {
3268         int err;
3269         TLanPrivateInfo *priv = netdev_priv(dev);
3270         unsigned long flags = 0;
3271         int ret=0;
3272
3273         spin_lock_irqsave(&priv->lock, flags);
3274
3275         TLan_EeSendStart( dev->base_addr );
3276         err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3277         if (err)
3278         {
3279                 ret=1;
3280                 goto fail;
3281         }
3282         err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3283         if (err)
3284         {
3285                 ret=2;
3286                 goto fail;
3287         }
3288         TLan_EeSendStart( dev->base_addr );
3289         err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3290         if (err)
3291         {
3292                 ret=3;
3293                 goto fail;
3294         }
3295         TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3296 fail:
3297         spin_unlock_irqrestore(&priv->lock, flags);
3298
3299         return ret;
3300
3301 } /* TLan_EeReadByte */
3302
3303
3304