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