drivers/net/tlan.c

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