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 ( &( (TLanPrivateInfo *) netdev_priv(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                 priv->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                                 priv->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                                 priv->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         TLanPrivateInfo *priv = netdev_priv(dev);
2146         u32             tx_good, tx_under;
2147         u32             rx_good, rx_over;
2148         u32             def_tx, crc, code;
2149         u32             multi_col, single_col;
2150         u32             excess_col, late_col, loss;
2151
2152         outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2153         tx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2154         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2155         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2156         tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2157
2158         outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2159         rx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2160         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2161         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2162         rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2163
2164         outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2165         def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
2166         def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2167         crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2168         code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2169
2170         outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2171         multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
2172         multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2173         single_col  = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2174         single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2175
2176         outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2177         excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2178         late_col   = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2179         loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2180
2181         if ( record ) {
2182                 priv->stats.rx_packets += rx_good;
2183                 priv->stats.rx_errors  += rx_over + crc + code;
2184                 priv->stats.tx_packets += tx_good;
2185                 priv->stats.tx_errors  += tx_under + loss;
2186                 priv->stats.collisions += multi_col + single_col + excess_col + late_col;
2187
2188                 priv->stats.rx_over_errors    += rx_over;
2189                 priv->stats.rx_crc_errors     += crc;
2190                 priv->stats.rx_frame_errors   += code;
2191
2192                 priv->stats.tx_aborted_errors += tx_under;
2193                 priv->stats.tx_carrier_errors += loss;
2194         }
2195
2196 } /* TLan_ReadAndClearStats */
2197
2198
2199
2200
2201         /***************************************************************
2202          *      TLan_Reset
2203          *
2204          *      Returns:
2205          *              0
2206          *      Parms:
2207          *              dev     Pointer to device structure of adapter
2208          *                      to be reset.
2209          *
2210          *      This function resets the adapter and it's physical
2211          *      device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
2212          *      Programmer's Guide" for details.  The routine tries to
2213          *      implement what is detailed there, though adjustments
2214          *      have been made.
2215          *
2216          **************************************************************/
2217
2218 static void
2219 TLan_ResetAdapter( struct net_device *dev )
2220 {
2221         TLanPrivateInfo *priv = netdev_priv(dev);
2222         int             i;
2223         u32             addr;
2224         u32             data;
2225         u8              data8;
2226
2227         priv->tlanFullDuplex = FALSE;
2228         priv->phyOnline=0;
2229         netif_carrier_off(dev);
2230
2231 /*  1.  Assert reset bit. */
2232
2233         data = inl(dev->base_addr + TLAN_HOST_CMD);
2234         data |= TLAN_HC_AD_RST;
2235         outl(data, dev->base_addr + TLAN_HOST_CMD);
2236
2237         udelay(1000);
2238
2239 /*  2.  Turn off interrupts. ( Probably isn't necessary ) */
2240
2241         data = inl(dev->base_addr + TLAN_HOST_CMD);
2242         data |= TLAN_HC_INT_OFF;
2243         outl(data, dev->base_addr + TLAN_HOST_CMD);
2244
2245 /*  3.  Clear AREGs and HASHs. */
2246
2247         for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2248                 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2249         }
2250
2251 /*  4.  Setup NetConfig register. */
2252
2253         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2254         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2255
2256 /*  5.  Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2257
2258         outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2259         outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2260
2261 /*  6.  Unreset the MII by setting NMRST (in NetSio) to 1. */
2262
2263         outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2264         addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2265         TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2266
2267 /*  7.  Setup the remaining registers. */
2268
2269         if ( priv->tlanRev >= 0x30 ) {
2270                 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2271                 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2272         }
2273         TLan_PhyDetect( dev );
2274         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2275
2276         if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2277                 data |= TLAN_NET_CFG_BIT;
2278                 if ( priv->aui == 1 ) {
2279                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2280                 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2281                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2282                         priv->tlanFullDuplex = TRUE;
2283                 } else {
2284                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2285                 }
2286         }
2287
2288         if ( priv->phyNum == 0 ) {
2289                 data |= TLAN_NET_CFG_PHY_EN;
2290         }
2291         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2292
2293         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2294                 TLan_FinishReset( dev );
2295         } else {
2296                 TLan_PhyPowerDown( dev );
2297         }
2298
2299 } /* TLan_ResetAdapter */
2300
2301
2302
2303
2304 static void
2305 TLan_FinishReset( struct net_device *dev )
2306 {
2307         TLanPrivateInfo *priv = netdev_priv(dev);
2308         u8              data;
2309         u32             phy;
2310         u8              sio;
2311         u16             status;
2312         u16             partner;
2313         u16             tlphy_ctl;
2314         u16             tlphy_par;
2315         u16             tlphy_id1, tlphy_id2;
2316         int             i;
2317
2318         phy = priv->phy[priv->phyNum];
2319
2320         data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2321         if ( priv->tlanFullDuplex ) {
2322                 data |= TLAN_NET_CMD_DUPLEX;
2323         }
2324         TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2325         data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2326         if ( priv->phyNum == 0 ) {
2327                 data |= TLAN_NET_MASK_MASK7;
2328         }
2329         TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2330         TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2331         TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2332         TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2333
2334         if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
2335                 status = MII_GS_LINK;
2336                 printk( "TLAN:  %s: Link forced.\n", dev->name );
2337         } else {
2338                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2339                 udelay( 1000 );
2340                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2341                 if ( (status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */
2342                         (tlphy_id1 == NAT_SEM_ID1) &&
2343                         (tlphy_id2 == NAT_SEM_ID2) ) {
2344                         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2345                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2346
2347                         printk( "TLAN: %s: Link active with ", dev->name );
2348                         if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2349                                  printk( "forced 10%sMbps %s-Duplex\n",
2350                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2351                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2352                         } else {
2353                                 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2354                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2355                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2356                                 printk("TLAN: Partner capability: ");
2357                                         for (i = 5; i <= 10; i++)
2358                                                 if (partner & (1<<i))
2359                                                         printk("%s",media[i-5]);
2360                                 printk("\n");
2361                         }
2362
2363                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2364 #ifdef MONITOR
2365                         /* We have link beat..for now anyway */
2366                         priv->link = 1;
2367                         /*Enabling link beat monitoring */
2368                         TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2369 #endif
2370                 } else if (status & MII_GS_LINK)  {
2371                         printk( "TLAN: %s: Link active\n", dev->name );
2372                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2373                 }
2374         }
2375
2376         if ( priv->phyNum == 0 ) {
2377                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2378                 tlphy_ctl |= TLAN_TC_INTEN;
2379                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2380                 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2381                 sio |= TLAN_NET_SIO_MINTEN;
2382                 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2383         }
2384
2385         if ( status & MII_GS_LINK ) {
2386                 TLan_SetMac( dev, 0, dev->dev_addr );
2387                 priv->phyOnline = 1;
2388                 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2389                 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2390                         outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2391                 }
2392                 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2393                 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2394                 netif_carrier_on(dev);
2395         } else {
2396                 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
2397                 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2398                 return;
2399         }
2400         TLan_SetMulticastList(dev);
2401
2402 } /* TLan_FinishReset */
2403
2404
2405
2406
2407         /***************************************************************
2408          *      TLan_SetMac
2409          *
2410          *      Returns:
2411          *              Nothing
2412          *      Parms:
2413          *              dev     Pointer to device structure of adapter
2414          *                      on which to change the AREG.
2415          *              areg    The AREG to set the address in (0 - 3).
2416          *              mac     A pointer to an array of chars.  Each
2417          *                      element stores one byte of the address.
2418          *                      IE, it isn't in ascii.
2419          *
2420          *      This function transfers a MAC address to one of the
2421          *      TLAN AREGs (address registers).  The TLAN chip locks
2422          *      the register on writing to offset 0 and unlocks the
2423          *      register after writing to offset 5.  If NULL is passed
2424          *      in mac, then the AREG is filled with 0's.
2425          *
2426          **************************************************************/
2427
2428 static void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2429 {
2430         int i;
2431
2432         areg *= 6;
2433
2434         if ( mac != NULL ) {
2435                 for ( i = 0; i < 6; i++ )
2436                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
2437         } else {
2438                 for ( i = 0; i < 6; i++ )
2439                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
2440         }
2441
2442 } /* TLan_SetMac */
2443
2444
2445
2446
2447 /*****************************************************************************
2448 ******************************************************************************
2449
2450         ThunderLAN Driver PHY Layer Routines
2451
2452 ******************************************************************************
2453 *****************************************************************************/
2454
2455
2456
2457         /*********************************************************************
2458          *      TLan_PhyPrint
2459          *
2460          *      Returns:
2461          *              Nothing
2462          *      Parms:
2463          *              dev     A pointer to the device structure of the
2464          *                      TLAN device having the PHYs to be detailed.
2465          *
2466          *      This function prints the registers a PHY (aka transceiver).
2467          *
2468          ********************************************************************/
2469
2470 static void TLan_PhyPrint( struct net_device *dev )
2471 {
2472         TLanPrivateInfo *priv = netdev_priv(dev);
2473         u16 i, data0, data1, data2, data3, phy;
2474
2475         phy = priv->phy[priv->phyNum];
2476
2477         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2478                 printk( "TLAN:   Device %s, Unmanaged PHY.\n", dev->name );
2479         } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2480                 printk( "TLAN:   Device %s, PHY 0x%02x.\n", dev->name, phy );
2481                 printk( "TLAN:      Off.  +0     +1     +2     +3 \n" );
2482                 for ( i = 0; i < 0x20; i+= 4 ) {
2483                         printk( "TLAN:      0x%02x", i );
2484                         TLan_MiiReadReg( dev, phy, i, &data0 );
2485                         printk( " 0x%04hx", data0 );
2486                         TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2487                         printk( " 0x%04hx", data1 );
2488                         TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2489                         printk( " 0x%04hx", data2 );
2490                         TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2491                         printk( " 0x%04hx\n", data3 );
2492                 }
2493         } else {
2494                 printk( "TLAN:   Device %s, Invalid PHY.\n", dev->name );
2495         }
2496
2497 } /* TLan_PhyPrint */
2498
2499
2500
2501
2502         /*********************************************************************
2503          *      TLan_PhyDetect
2504          *
2505          *      Returns:
2506          *              Nothing
2507          *      Parms:
2508          *              dev     A pointer to the device structure of the adapter
2509          *                      for which the PHY needs determined.
2510          *
2511          *      So far I've found that adapters which have external PHYs
2512          *      may also use the internal PHY for part of the functionality.
2513          *      (eg, AUI/Thinnet).  This function finds out if this TLAN
2514          *      chip has an internal PHY, and then finds the first external
2515          *      PHY (starting from address 0) if it exists).
2516          *
2517          ********************************************************************/
2518
2519 static void TLan_PhyDetect( struct net_device *dev )
2520 {
2521         TLanPrivateInfo *priv = netdev_priv(dev);
2522         u16             control;
2523         u16             hi;
2524         u16             lo;
2525         u32             phy;
2526
2527         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2528                 priv->phyNum = 0xFFFF;
2529                 return;
2530         }
2531
2532         TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2533
2534         if ( hi != 0xFFFF ) {
2535                 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2536         } else {
2537                 priv->phy[0] = TLAN_PHY_NONE;
2538         }
2539
2540         priv->phy[1] = TLAN_PHY_NONE;
2541         for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2542                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2543                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2544                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2545                 if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2546                         TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
2547                         if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
2548                                 priv->phy[1] = phy;
2549                         }
2550                 }
2551         }
2552
2553         if ( priv->phy[1] != TLAN_PHY_NONE ) {
2554                 priv->phyNum = 1;
2555         } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2556                 priv->phyNum = 0;
2557         } else {
2558                 printk( "TLAN:  Cannot initialize device, no PHY was found!\n" );
2559         }
2560
2561 } /* TLan_PhyDetect */
2562
2563
2564
2565
2566 static void TLan_PhyPowerDown( struct net_device *dev )
2567 {
2568         TLanPrivateInfo *priv = netdev_priv(dev);
2569         u16             value;
2570
2571         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2572         value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2573         TLan_MiiSync( dev->base_addr );
2574         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2575         if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2576                 TLan_MiiSync( dev->base_addr );
2577                 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2578         }
2579
2580         /* Wait for 50 ms and powerup
2581          * This is abitrary.  It is intended to make sure the
2582          * transceiver settles.
2583          */
2584         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2585
2586 } /* TLan_PhyPowerDown */
2587
2588
2589
2590
2591 static void TLan_PhyPowerUp( struct net_device *dev )
2592 {
2593         TLanPrivateInfo *priv = netdev_priv(dev);
2594         u16             value;
2595
2596         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2597         TLan_MiiSync( dev->base_addr );
2598         value = MII_GC_LOOPBK;
2599         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2600         TLan_MiiSync(dev->base_addr);
2601         /* Wait for 500 ms and reset the
2602          * transceiver.  The TLAN docs say both 50 ms and
2603          * 500 ms, so do the longer, just in case.
2604          */
2605         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2606
2607 } /* TLan_PhyPowerUp */
2608
2609
2610
2611
2612 static void TLan_PhyReset( struct net_device *dev )
2613 {
2614         TLanPrivateInfo *priv = netdev_priv(dev);
2615         u16             phy;
2616         u16             value;
2617
2618         phy = priv->phy[priv->phyNum];
2619
2620         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2621         TLan_MiiSync( dev->base_addr );
2622         value = MII_GC_LOOPBK | MII_GC_RESET;
2623         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2624         TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2625         while ( value & MII_GC_RESET ) {
2626                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2627         }
2628
2629         /* Wait for 500 ms and initialize.
2630          * I don't remember why I wait this long.
2631          * I've changed this to 50ms, as it seems long enough.
2632          */
2633         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2634
2635 } /* TLan_PhyReset */
2636
2637
2638
2639
2640 static void TLan_PhyStartLink( struct net_device *dev )
2641 {
2642         TLanPrivateInfo *priv = netdev_priv(dev);
2643         u16             ability;
2644         u16             control;
2645         u16             data;
2646         u16             phy;
2647         u16             status;
2648         u16             tctl;
2649
2650         phy = priv->phy[priv->phyNum];
2651         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2652         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2653         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2654
2655         if ( ( status & MII_GS_AUTONEG ) &&
2656              ( ! priv->aui ) ) {
2657                 ability = status >> 11;
2658                 if ( priv->speed  == TLAN_SPEED_10 &&
2659                      priv->duplex == TLAN_DUPLEX_HALF) {
2660                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2661                 } else if ( priv->speed == TLAN_SPEED_10 &&
2662                             priv->duplex == TLAN_DUPLEX_FULL) {
2663                         priv->tlanFullDuplex = TRUE;
2664                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2665                 } else if ( priv->speed == TLAN_SPEED_100 &&
2666                             priv->duplex == TLAN_DUPLEX_HALF) {
2667                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2668                 } else if ( priv->speed == TLAN_SPEED_100 &&
2669                             priv->duplex == TLAN_DUPLEX_FULL) {
2670                         priv->tlanFullDuplex = TRUE;
2671                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2672                 } else {
2673
2674                         /* Set Auto-Neg advertisement */
2675                         TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2676                         /* Enablee Auto-Neg */
2677                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2678                         /* Restart Auto-Neg */
2679                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2680                         /* Wait for 4 sec for autonegotiation
2681                         * to complete.  The max spec time is less than this
2682                         * but the card need additional time to start AN.
2683                         * .5 sec should be plenty extra.
2684                         */
2685                         printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2686                         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2687                         return;
2688                 }
2689
2690         }
2691
2692         if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2693                 priv->phyNum = 0;
2694                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2695                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2696                 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2697                 return;
2698         }  else if ( priv->phyNum == 0 ) {
2699                 control = 0;
2700                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2701                 if ( priv->aui ) {
2702                         tctl |= TLAN_TC_AUISEL;
2703                 } else {
2704                         tctl &= ~TLAN_TC_AUISEL;
2705                         if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2706                                 control |= MII_GC_DUPLEX;
2707                                 priv->tlanFullDuplex = TRUE;
2708                         }
2709                         if ( priv->speed == TLAN_SPEED_100 ) {
2710                                 control |= MII_GC_SPEEDSEL;
2711                         }
2712                 }
2713                 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2714                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2715         }
2716
2717         /* Wait for 2 sec to give the transceiver time
2718          * to establish link.
2719          */
2720         TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2721
2722 } /* TLan_PhyStartLink */
2723
2724
2725
2726
2727 static void TLan_PhyFinishAutoNeg( struct net_device *dev )
2728 {
2729         TLanPrivateInfo *priv = netdev_priv(dev);
2730         u16             an_adv;
2731         u16             an_lpa;
2732         u16             data;
2733         u16             mode;
2734         u16             phy;
2735         u16             status;
2736
2737         phy = priv->phy[priv->phyNum];
2738
2739         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2740         udelay( 1000 );
2741         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2742
2743         if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2744                 /* Wait for 8 sec to give the process
2745                  * more time.  Perhaps we should fail after a while.
2746                  */
2747                  if (!priv->neg_be_verbose++) {
2748                          printk(KERN_INFO "TLAN:  Giving autonegotiation more time.\n");
2749                          printk(KERN_INFO "TLAN:  Please check that your adapter has\n");
2750                          printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.\n");
2751                          printk(KERN_INFO "TLAN:  Trying to establish link in the background...\n");
2752                  }
2753                 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2754                 return;
2755         }
2756
2757         printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2758         TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2759         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2760         mode = an_adv & an_lpa & 0x03E0;
2761         if ( mode & 0x0100 ) {
2762                 priv->tlanFullDuplex = TRUE;
2763         } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2764                 priv->tlanFullDuplex = TRUE;
2765         }
2766
2767         if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
2768                 priv->phyNum = 0;
2769                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2770                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2771                 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2772                 return;
2773         }
2774
2775         if ( priv->phyNum == 0 ) {
2776                 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
2777                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
2778                         printk( "TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
2779                 } else {
2780                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2781                         printk( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
2782                 }
2783         }
2784
2785         /* Wait for 100 ms.  No reason in partiticular.
2786          */
2787         TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2788
2789 } /* TLan_PhyFinishAutoNeg */
2790
2791 #ifdef MONITOR
2792
2793         /*********************************************************************
2794         *
2795         *      TLan_phyMonitor
2796         *
2797         *      Returns:
2798         *              None
2799         *
2800         *      Params:
2801         *              dev             The device structure of this device.
2802         *
2803         *
2804         *      This function monitors PHY condition by reading the status
2805         *      register via the MII bus. This can be used to give info
2806         *      about link changes (up/down), and possible switch to alternate
2807         *      media.
2808         *
2809         * ******************************************************************/
2810
2811 void TLan_PhyMonitor( struct net_device *dev )
2812 {
2813         TLanPrivateInfo *priv = netdev_priv(dev);
2814         u16     phy;
2815         u16     phy_status;
2816
2817         phy = priv->phy[priv->phyNum];
2818
2819         /* Get PHY status register */
2820         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2821
2822         /* Check if link has been lost */
2823         if (!(phy_status & MII_GS_LINK)) {
2824                if (priv->link) {
2825                       priv->link = 0;
2826                       printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2827                       netif_carrier_off(dev);
2828                       TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2829                       return;
2830                 }
2831         }
2832
2833         /* Link restablished? */
2834         if ((phy_status & MII_GS_LINK) && !priv->link) {
2835                 priv->link = 1;
2836                 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2837                 netif_carrier_on(dev);
2838         }
2839
2840         /* Setup a new monitor */
2841         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2842 }
2843
2844 #endif /* MONITOR */
2845
2846
2847 /*****************************************************************************
2848 ******************************************************************************
2849
2850         ThunderLAN Driver MII Routines
2851
2852         These routines are based on the information in Chap. 2 of the
2853         "ThunderLAN Programmer's Guide", pp. 15-24.
2854
2855 ******************************************************************************
2856 *****************************************************************************/
2857
2858
2859         /***************************************************************
2860          *      TLan_MiiReadReg
2861          *
2862          *      Returns:
2863          *              0       if ack received ok
2864          *              1       otherwise.
2865          *
2866          *      Parms:
2867          *              dev             The device structure containing
2868          *                              The io address and interrupt count
2869          *                              for this device.
2870          *              phy             The address of the PHY to be queried.
2871          *              reg             The register whose contents are to be
2872          *                              retrieved.
2873          *              val             A pointer to a variable to store the
2874          *                              retrieved value.
2875          *
2876          *      This function uses the TLAN's MII bus to retrieve the contents
2877          *      of a given register on a PHY.  It sends the appropriate info
2878          *      and then reads the 16-bit register value from the MII bus via
2879          *      the TLAN SIO register.
2880          *
2881          **************************************************************/
2882
2883 static int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2884 {
2885         u8      nack;
2886         u16     sio, tmp;
2887         u32     i;
2888         int     err;
2889         int     minten;
2890         TLanPrivateInfo *priv = netdev_priv(dev);
2891         unsigned long flags = 0;
2892
2893         err = FALSE;
2894         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2895         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2896
2897         if (!in_irq())
2898                 spin_lock_irqsave(&priv->lock, flags);
2899
2900         TLan_MiiSync(dev->base_addr);
2901
2902         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2903         if ( minten )
2904                 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2905
2906         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
2907         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Read  ( 10b ) */
2908         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
2909         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
2910
2911
2912         TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio);         /* Change direction */
2913
2914         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Clock Idle bit */
2915         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2916         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Wait 300ns */
2917
2918         nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio);    /* Check for ACK */
2919         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);            /* Finish ACK */
2920         if (nack) {                                     /* No ACK, so fake it */
2921                 for (i = 0; i < 16; i++) {
2922                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2923                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2924                 }
2925                 tmp = 0xffff;
2926                 err = TRUE;
2927         } else {                                        /* ACK, so read data */
2928                 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2929                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2930                         if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2931                                 tmp |= i;
2932                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2933                 }
2934         }
2935
2936
2937         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Idle cycle */
2938         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2939
2940         if ( minten )
2941                 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2942
2943         *val = tmp;
2944
2945         if (!in_irq())
2946                 spin_unlock_irqrestore(&priv->lock, flags);
2947
2948         return err;
2949
2950 } /* TLan_MiiReadReg */
2951
2952
2953
2954
2955         /***************************************************************
2956          *      TLan_MiiSendData
2957          *
2958          *      Returns:
2959          *              Nothing
2960          *      Parms:
2961          *              base_port       The base IO port of the adapter in
2962          *                              question.
2963          *              dev             The address of the PHY to be queried.
2964          *              data            The value to be placed on the MII bus.
2965          *              num_bits        The number of bits in data that are to
2966          *                              be placed on the MII bus.
2967          *
2968          *      This function sends on sequence of bits on the MII
2969          *      configuration bus.
2970          *
2971          **************************************************************/
2972
2973 static void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
2974 {
2975         u16 sio;
2976         u32 i;
2977
2978         if ( num_bits == 0 )
2979                 return;
2980
2981         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
2982         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2983         TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
2984
2985         for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
2986                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
2987                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2988                 if ( data & i )
2989                         TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
2990                 else
2991                         TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
2992                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
2993                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
2994         }
2995
2996 } /* TLan_MiiSendData */
2997
2998
2999
3000
3001         /***************************************************************
3002          *      TLan_MiiSync
3003          *
3004          *      Returns:
3005          *              Nothing
3006          *      Parms:
3007          *              base_port       The base IO port of the adapter in
3008          *                              question.
3009          *
3010          *      This functions syncs all PHYs in terms of the MII configuration
3011          *      bus.
3012          *
3013          **************************************************************/
3014
3015 static void TLan_MiiSync( u16 base_port )
3016 {
3017         int i;
3018         u16 sio;
3019
3020         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3021         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3022
3023         TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3024         for ( i = 0; i < 32; i++ ) {
3025                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3026                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3027         }
3028
3029 } /* TLan_MiiSync */
3030
3031
3032
3033
3034         /***************************************************************
3035          *      TLan_MiiWriteReg
3036          *
3037          *      Returns:
3038          *              Nothing
3039          *      Parms:
3040          *              dev             The device structure for the device
3041          *                              to write to.
3042          *              phy             The address of the PHY to be written to.
3043          *              reg             The register whose contents are to be
3044          *                              written.
3045          *              val             The value to be written to the register.
3046          *
3047          *      This function uses the TLAN's MII bus to write the contents of a
3048          *      given register on a PHY.  It sends the appropriate info and then
3049          *      writes the 16-bit register value from the MII configuration bus
3050          *      via the TLAN SIO register.
3051          *
3052          **************************************************************/
3053
3054 static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3055 {
3056         u16     sio;
3057         int     minten;
3058         unsigned long flags = 0;
3059         TLanPrivateInfo *priv = netdev_priv(dev);
3060
3061         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3062         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3063
3064         if (!in_irq())
3065                 spin_lock_irqsave(&priv->lock, flags);
3066
3067         TLan_MiiSync( dev->base_addr );
3068
3069         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3070         if ( minten )
3071                 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3072
3073         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
3074         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Write ( 01b ) */
3075         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
3076         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
3077
3078         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Send ACK */
3079         TLan_MiiSendData( dev->base_addr, val, 16 );    /* Send Data */
3080
3081         TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );        /* Idle cycle */
3082         TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3083
3084         if ( minten )
3085                 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3086
3087         if (!in_irq())
3088                 spin_unlock_irqrestore(&priv->lock, flags);
3089
3090 } /* TLan_MiiWriteReg */
3091
3092
3093
3094
3095 /*****************************************************************************
3096 ******************************************************************************
3097
3098         ThunderLAN Driver Eeprom routines
3099
3100         The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3101         EEPROM.  These functions are based on information in Microchip's
3102         data sheet.  I don't know how well this functions will work with
3103         other EEPROMs.
3104
3105 ******************************************************************************
3106 *****************************************************************************/
3107
3108
3109         /***************************************************************
3110          *      TLan_EeSendStart
3111          *
3112          *      Returns:
3113          *              Nothing
3114          *      Parms:
3115          *              io_base         The IO port base address for the
3116          *                              TLAN device with the EEPROM to
3117          *                              use.
3118          *
3119          *      This function sends a start cycle to an EEPROM attached
3120          *      to a TLAN chip.
3121          *
3122          **************************************************************/
3123
3124 static void TLan_EeSendStart( u16 io_base )
3125 {
3126         u16     sio;
3127
3128         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3129         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3130
3131         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3132         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3133         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3134         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3135         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3136
3137 } /* TLan_EeSendStart */
3138
3139
3140
3141
3142         /***************************************************************
3143          *      TLan_EeSendByte
3144          *
3145          *      Returns:
3146          *              If the correct ack was received, 0, otherwise 1
3147          *      Parms:  io_base         The IO port base address for the
3148          *                              TLAN device with the EEPROM to
3149          *                              use.
3150          *              data            The 8 bits of information to
3151          *                              send to the EEPROM.
3152          *              stop            If TLAN_EEPROM_STOP is passed, a
3153          *                              stop cycle is sent after the
3154          *                              byte is sent after the ack is
3155          *                              read.
3156          *
3157          *      This function sends a byte on the serial EEPROM line,
3158          *      driving the clock to send each bit. The function then
3159          *      reverses transmission direction and reads an acknowledge
3160          *      bit.
3161          *
3162          **************************************************************/
3163
3164 static int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3165 {
3166         int     err;
3167         u8      place;
3168         u16     sio;
3169
3170         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3171         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3172
3173         /* Assume clock is low, tx is enabled; */
3174         for ( place = 0x80; place != 0; place >>= 1 ) {
3175                 if ( place & data )
3176                         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3177                 else
3178                         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3179                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3180                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3181         }
3182         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3183         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3184         err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3185         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3186         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3187
3188         if ( ( ! err ) && stop ) {
3189                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3190                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3191                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3192         }
3193
3194         return ( err );
3195
3196 } /* TLan_EeSendByte */
3197
3198
3199
3200
3201         /***************************************************************
3202          *      TLan_EeReceiveByte
3203          *
3204          *      Returns:
3205          *              Nothing
3206          *      Parms:
3207          *              io_base         The IO port base address for the
3208          *                              TLAN device with the EEPROM to
3209          *                              use.
3210          *              data            An address to a char to hold the
3211          *                              data sent from the EEPROM.
3212          *              stop            If TLAN_EEPROM_STOP is passed, a
3213          *                              stop cycle is sent after the
3214          *                              byte is received, and no ack is
3215          *                              sent.
3216          *
3217          *      This function receives 8 bits of data from the EEPROM
3218          *      over the serial link.  It then sends and ack bit, or no
3219          *      ack and a stop bit.  This function is used to retrieve
3220          *      data after the address of a byte in the EEPROM has been
3221          *      sent.
3222          *
3223          **************************************************************/
3224
3225 static void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3226 {
3227         u8  place;
3228         u16 sio;
3229
3230         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3231         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3232         *data = 0;
3233
3234         /* Assume clock is low, tx is enabled; */
3235         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3236         for ( place = 0x80; place; place >>= 1 ) {
3237                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3238                 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3239                         *data |= place;
3240                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3241         }
3242
3243         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3244         if ( ! stop ) {
3245                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* Ack = 0 */
3246                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3247                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3248         } else {
3249                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );         /* No ack = 1 (?) */
3250                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3251                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3252                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3253                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3254                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3255         }
3256
3257 } /* TLan_EeReceiveByte */
3258
3259
3260
3261
3262         /***************************************************************
3263          *      TLan_EeReadByte
3264          *
3265          *      Returns:
3266          *              No error = 0, else, the stage at which the error
3267          *              occurred.
3268          *      Parms:
3269          *              io_base         The IO port base address for the
3270          *                              TLAN device with the EEPROM to
3271          *                              use.
3272          *              ee_addr         The address of the byte in the
3273          *                              EEPROM whose contents are to be
3274          *                              retrieved.
3275          *              data            An address to a char to hold the
3276          *                              data obtained from the EEPROM.
3277          *
3278          *      This function reads a byte of information from an byte
3279          *      cell in the EEPROM.
3280          *
3281          **************************************************************/
3282
3283 static int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3284 {
3285         int err;
3286         TLanPrivateInfo *priv = netdev_priv(dev);
3287         unsigned long flags = 0;
3288         int ret=0;
3289
3290         spin_lock_irqsave(&priv->lock, flags);
3291
3292         TLan_EeSendStart( dev->base_addr );
3293         err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3294         if (err)
3295         {
3296                 ret=1;
3297                 goto fail;
3298         }
3299         err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3300         if (err)
3301         {
3302                 ret=2;
3303                 goto fail;
3304         }
3305         TLan_EeSendStart( dev->base_addr );
3306         err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3307         if (err)
3308         {
3309                 ret=3;
3310                 goto fail;
3311         }
3312         TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3313 fail:
3314         spin_unlock_irqrestore(&priv->lock, flags);
3315
3316         return ret;
3317
3318 } /* TLan_EeReadByte */
3319
3320
3321