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