git.oblomov.eu Git - linux-2.6/blob - 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                 skb_copy_from_linear_data(skb, tail_buffer, 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_reserve(skb, 2);
1581                                 t = (void *) skb_put(skb, frameSize);
1582
1583                                 priv->stats.rx_bytes += head_list->frameSize;
1584
1585                                 memcpy( t, head_buffer, frameSize );
1586                                 skb->protocol = eth_type_trans( skb, dev );
1587                                 netif_rx( skb );
1588                         }
1589                 } else {
1590                         struct sk_buff *new_skb;
1591
1592                         /*
1593                          *      I changed the algorithm here. What we now do
1594                          *      is allocate the new frame. If this fails we
1595                          *      simply recycle the frame.
1596                          */
1597
1598                         new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
1599
1600                         if ( new_skb != NULL ) {
1601                                 skb = TLan_GetSKB(head_list);
1602                                 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1603                                 skb_trim( skb, frameSize );
1604
1605                                 priv->stats.rx_bytes += frameSize;
1606
1607                                 skb->protocol = eth_type_trans( skb, dev );
1608                                 netif_rx( skb );
1609
1610                                 skb_reserve( new_skb, 2 );
1611                                 t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
1612                                 head_list->buffer[0].address = pci_map_single(priv->pciDev, new_skb->data, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1613                                 head_list->buffer[8].address = (u32) t;
1614                                 TLan_StoreSKB(head_list, new_skb);
1615                         } else
1616                                 printk(KERN_WARNING "TLAN:  Couldn't allocate memory for received data.\n" );
1617                 }
1618
1619                 head_list->forward = 0;
1620                 head_list->cStat = 0;
1621                 tail_list = priv->rxList + priv->rxTail;
1622                 tail_list->forward = head_list_phys;
1623
1624                 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
1625                 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
1626                 head_list = priv->rxList + priv->rxHead;
1627                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1628         }
1629
1630         if (!ack)
1631                 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
1632
1633
1634
1635
1636         if ( eoc ) {
1637                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
1638                 head_list = priv->rxList + priv->rxHead;
1639                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1640                 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
1641                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1642                 priv->rxEocCount++;
1643         }
1644
1645         if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
1646                 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
1647                 if ( priv->timer.function == NULL )  {
1648                         priv->timer.function = &TLan_Timer;
1649                         priv->timer.data = (unsigned long) dev;
1650                         priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1651                         priv->timerSetAt = jiffies;
1652                         priv->timerType = TLAN_TIMER_ACTIVITY;
1653                         add_timer(&priv->timer);
1654                 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
1655                         priv->timerSetAt = jiffies;
1656                 }
1657         }
1658
1659         dev->last_rx = jiffies;
1660
1661         return ack;
1662
1663 } /* TLan_HandleRxEOF */
1664
1665
1666
1667
1668         /***************************************************************
1669          *      TLan_HandleDummy
1670          *
1671          *      Returns:
1672          *              1
1673          *      Parms:
1674          *              dev             Device assigned the IRQ that was
1675          *                              raised.
1676          *              host_int        The contents of the HOST_INT
1677          *                              port.
1678          *
1679          *      This function handles the Dummy interrupt, which is
1680          *      raised whenever a test interrupt is generated by setting
1681          *      the Req_Int bit of HOST_CMD to 1.
1682          *
1683          **************************************************************/
1684
1685 u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
1686 {
1687         printk( "TLAN:  Test interrupt on %s.\n", dev->name );
1688         return 1;
1689
1690 } /* TLan_HandleDummy */
1691
1692
1693
1694
1695         /***************************************************************
1696          *      TLan_HandleTxEOC
1697          *
1698          *      Returns:
1699          *              1
1700          *      Parms:
1701          *              dev             Device assigned the IRQ that was
1702          *                              raised.
1703          *              host_int        The contents of the HOST_INT
1704          *                              port.
1705          *
1706          *      This driver is structured to determine EOC occurrences by
1707          *      reading the CSTAT member of the list structure.  Tx EOC
1708          *      interrupts are disabled via the DIO INTDIS register.
1709          *      However, TLAN chips before revision 3.0 didn't have this
1710          *      functionality, so process EOC events if this is the
1711          *      case.
1712          *
1713          **************************************************************/
1714
1715 u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
1716 {
1717         TLanPrivateInfo *priv = netdev_priv(dev);
1718         TLanList                *head_list;
1719         dma_addr_t              head_list_phys;
1720         u32                     ack = 1;
1721
1722         host_int = 0;
1723         if ( priv->tlanRev < 0x30 ) {
1724                 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail );
1725                 head_list = priv->txList + priv->txHead;
1726                 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
1727                 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
1728                         netif_stop_queue(dev);
1729                         outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1730                         ack |= TLAN_HC_GO;
1731                 } else {
1732                         priv->txInProgress = 0;
1733                 }
1734         }
1735
1736         return ack;
1737
1738 } /* TLan_HandleTxEOC */
1739
1740
1741
1742
1743         /***************************************************************
1744          *      TLan_HandleStatusCheck
1745          *
1746          *      Returns:
1747          *              0 if Adapter check, 1 if Network Status check.
1748          *      Parms:
1749          *              dev             Device assigned the IRQ that was
1750          *                              raised.
1751          *              host_int        The contents of the HOST_INT
1752          *                              port.
1753          *
1754          *      This function handles Adapter Check/Network Status
1755          *      interrupts generated by the adapter.  It checks the
1756          *      vector in the HOST_INT register to determine if it is
1757          *      an Adapter Check interrupt.  If so, it resets the
1758          *      adapter.  Otherwise it clears the status registers
1759          *      and services the PHY.
1760          *
1761          **************************************************************/
1762
1763 u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1764 {
1765         TLanPrivateInfo *priv = netdev_priv(dev);
1766         u32             ack;
1767         u32             error;
1768         u8              net_sts;
1769         u32             phy;
1770         u16             tlphy_ctl;
1771         u16             tlphy_sts;
1772
1773         ack = 1;
1774         if ( host_int & TLAN_HI_IV_MASK ) {
1775                 netif_stop_queue( dev );
1776                 error = inl( dev->base_addr + TLAN_CH_PARM );
1777                 printk( "TLAN:  %s: Adaptor Error = 0x%x\n", dev->name, error );
1778                 TLan_ReadAndClearStats( dev, TLAN_RECORD );
1779                 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
1780
1781                 schedule_work(&priv->tlan_tqueue);
1782
1783                 netif_wake_queue(dev);
1784                 ack = 0;
1785         } else {
1786                 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name );
1787                 phy = priv->phy[priv->phyNum];
1788
1789                 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
1790                 if ( net_sts ) {
1791                         TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
1792                         TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %x\n", dev->name, (unsigned) net_sts );
1793                 }
1794                 if ( ( net_sts & TLAN_NET_STS_MIRQ ) &&  ( priv->phyNum == 0 ) ) {
1795                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
1796                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
1797                         if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1798                                 tlphy_ctl |= TLAN_TC_SWAPOL;
1799                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1800                         } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
1801                                 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1802                                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
1803                         }
1804
1805                         if (debug) {
1806                                 TLan_PhyPrint( dev );
1807                         }
1808                 }
1809         }
1810
1811         return ack;
1812
1813 } /* TLan_HandleStatusCheck */
1814
1815
1816
1817
1818         /***************************************************************
1819          *      TLan_HandleRxEOC
1820          *
1821          *      Returns:
1822          *              1
1823          *      Parms:
1824          *              dev             Device assigned the IRQ that was
1825          *                              raised.
1826          *              host_int        The contents of the HOST_INT
1827          *                              port.
1828          *
1829          *      This driver is structured to determine EOC occurrences by
1830          *      reading the CSTAT member of the list structure.  Rx EOC
1831          *      interrupts are disabled via the DIO INTDIS register.
1832          *      However, TLAN chips before revision 3.0 didn't have this
1833          *      CSTAT member or a INTDIS register, so if this chip is
1834          *      pre-3.0, process EOC interrupts normally.
1835          *
1836          **************************************************************/
1837
1838 u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1839 {
1840         TLanPrivateInfo *priv = netdev_priv(dev);
1841         dma_addr_t      head_list_phys;
1842         u32             ack = 1;
1843
1844         if (  priv->tlanRev < 0x30 ) {
1845                 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail );
1846                 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
1847                 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
1848                 ack |= TLAN_HC_GO | TLAN_HC_RT;
1849                 priv->rxEocCount++;
1850         }
1851
1852         return ack;
1853
1854 } /* TLan_HandleRxEOC */
1855
1856
1857
1858
1859 /*****************************************************************************
1860 ******************************************************************************
1861
1862         ThunderLAN Driver Timer Function
1863
1864 ******************************************************************************
1865 *****************************************************************************/
1866
1867
1868         /***************************************************************
1869          *      TLan_Timer
1870          *
1871          *      Returns:
1872          *              Nothing
1873          *      Parms:
1874          *              data    A value given to add timer when
1875          *                      add_timer was called.
1876          *
1877          *      This function handles timed functionality for the
1878          *      TLAN driver.  The two current timer uses are for
1879          *      delaying for autonegotionation and driving the ACT LED.
1880          *      -       Autonegotiation requires being allowed about
1881          *              2 1/2 seconds before attempting to transmit a
1882          *              packet.  It would be a very bad thing to hang
1883          *              the kernel this long, so the driver doesn't
1884          *              allow transmission 'til after this time, for
1885          *              certain PHYs.  It would be much nicer if all
1886          *              PHYs were interrupt-capable like the internal
1887          *              PHY.
1888          *      -       The ACT LED, which shows adapter activity, is
1889          *              driven by the driver, and so must be left on
1890          *              for a short period to power up the LED so it
1891          *              can be seen.  This delay can be changed by
1892          *              changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1893          *              if desired.  100 ms  produces a slightly
1894          *              sluggish response.
1895          *
1896          **************************************************************/
1897
1898 void TLan_Timer( unsigned long data )
1899 {
1900         struct net_device       *dev = (struct net_device *) data;
1901         TLanPrivateInfo *priv = netdev_priv(dev);
1902         u32             elapsed;
1903         unsigned long   flags = 0;
1904
1905         priv->timer.function = NULL;
1906
1907         switch ( priv->timerType ) {
1908 #ifdef MONITOR
1909                 case TLAN_TIMER_LINK_BEAT:
1910                         TLan_PhyMonitor( dev );
1911                         break;
1912 #endif
1913                 case TLAN_TIMER_PHY_PDOWN:
1914                         TLan_PhyPowerDown( dev );
1915                         break;
1916                 case TLAN_TIMER_PHY_PUP:
1917                         TLan_PhyPowerUp( dev );
1918                         break;
1919                 case TLAN_TIMER_PHY_RESET:
1920                         TLan_PhyReset( dev );
1921                         break;
1922                 case TLAN_TIMER_PHY_START_LINK:
1923                         TLan_PhyStartLink( dev );
1924                         break;
1925                 case TLAN_TIMER_PHY_FINISH_AN:
1926                         TLan_PhyFinishAutoNeg( dev );
1927                         break;
1928                 case TLAN_TIMER_FINISH_RESET:
1929                         TLan_FinishReset( dev );
1930                         break;
1931                 case TLAN_TIMER_ACTIVITY:
1932                         spin_lock_irqsave(&priv->lock, flags);
1933                         if ( priv->timer.function == NULL ) {
1934                                 elapsed = jiffies - priv->timerSetAt;
1935                                 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
1936                                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
1937                                 } else  {
1938                                         priv->timer.function = &TLan_Timer;
1939                                         priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
1940                                         spin_unlock_irqrestore(&priv->lock, flags);
1941                                         add_timer( &priv->timer );
1942                                         break;
1943                                 }
1944                         }
1945                         spin_unlock_irqrestore(&priv->lock, flags);
1946                         break;
1947                 default:
1948                         break;
1949         }
1950
1951 } /* TLan_Timer */
1952
1953
1954
1955
1956 /*****************************************************************************
1957 ******************************************************************************
1958
1959         ThunderLAN Driver Adapter Related Routines
1960
1961 ******************************************************************************
1962 *****************************************************************************/
1963
1964
1965         /***************************************************************
1966          *      TLan_ResetLists
1967          *
1968          *      Returns:
1969          *              Nothing
1970          *      Parms:
1971          *              dev     The device structure with the list
1972          *                      stuctures to be reset.
1973          *
1974          *      This routine sets the variables associated with managing
1975          *      the TLAN lists to their initial values.
1976          *
1977          **************************************************************/
1978
1979 void TLan_ResetLists( struct net_device *dev )
1980 {
1981         TLanPrivateInfo *priv = netdev_priv(dev);
1982         int             i;
1983         TLanList        *list;
1984         dma_addr_t      list_phys;
1985         struct sk_buff  *skb;
1986         void            *t = NULL;
1987
1988         priv->txHead = 0;
1989         priv->txTail = 0;
1990         for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
1991                 list = priv->txList + i;
1992                 list->cStat = TLAN_CSTAT_UNUSED;
1993                 if ( bbuf ) {
1994                         list->buffer[0].address = priv->txBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
1995                 } else {
1996                         list->buffer[0].address = 0;
1997                 }
1998                 list->buffer[2].count = 0;
1999                 list->buffer[2].address = 0;
2000                 list->buffer[8].address = 0;
2001                 list->buffer[9].address = 0;
2002         }
2003
2004         priv->rxHead = 0;
2005         priv->rxTail = TLAN_NUM_RX_LISTS - 1;
2006         for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2007                 list = priv->rxList + i;
2008                 list_phys = priv->rxListDMA + sizeof(TLanList) * i;
2009                 list->cStat = TLAN_CSTAT_READY;
2010                 list->frameSize = TLAN_MAX_FRAME_SIZE;
2011                 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
2012                 if ( bbuf ) {
2013                         list->buffer[0].address = priv->rxBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
2014                 } else {
2015                         skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
2016                         if ( skb == NULL ) {
2017                                 printk( "TLAN:  Couldn't allocate memory for received data.\n" );
2018                                 /* If this ever happened it would be a problem */
2019                         } else {
2020                                 skb->dev = dev;
2021                                 skb_reserve( skb, 2 );
2022                                 t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
2023                         }
2024                         list->buffer[0].address = pci_map_single(priv->pciDev, t, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2025                         list->buffer[8].address = (u32) t;
2026                         TLan_StoreSKB(list, skb);
2027                 }
2028                 list->buffer[1].count = 0;
2029                 list->buffer[1].address = 0;
2030                 if ( i < TLAN_NUM_RX_LISTS - 1 )
2031                         list->forward = list_phys + sizeof(TLanList);
2032                 else
2033                         list->forward = 0;
2034         }
2035
2036 } /* TLan_ResetLists */
2037
2038
2039 void TLan_FreeLists( struct net_device *dev )
2040 {
2041         TLanPrivateInfo *priv = netdev_priv(dev);
2042         int             i;
2043         TLanList        *list;
2044         struct sk_buff  *skb;
2045
2046         if ( ! bbuf ) {
2047                 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
2048                         list = priv->txList + i;
2049                         skb = TLan_GetSKB(list);
2050                         if ( skb ) {
2051                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
2052                                 dev_kfree_skb_any( skb );
2053                                 list->buffer[8].address = 0;
2054                                 list->buffer[9].address = 0;
2055                         }
2056                 }
2057
2058                 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
2059                         list = priv->rxList + i;
2060                         skb = TLan_GetSKB(list);
2061                         if ( skb ) {
2062                                 pci_unmap_single(priv->pciDev, list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
2063                                 dev_kfree_skb_any( skb );
2064                                 list->buffer[8].address = 0;
2065                                 list->buffer[9].address = 0;
2066                         }
2067                 }
2068         }
2069 } /* TLan_FreeLists */
2070
2071
2072
2073
2074         /***************************************************************
2075          *      TLan_PrintDio
2076          *
2077          *      Returns:
2078          *              Nothing
2079          *      Parms:
2080          *              io_base         Base IO port of the device of
2081          *                              which to print DIO registers.
2082          *
2083          *      This function prints out all the internal (DIO)
2084          *      registers of a TLAN chip.
2085          *
2086          **************************************************************/
2087
2088 void TLan_PrintDio( u16 io_base )
2089 {
2090         u32 data0, data1;
2091         int     i;
2092
2093         printk( "TLAN:   Contents of internal registers for io base 0x%04hx.\n", io_base );
2094         printk( "TLAN:      Off.  +0         +4\n" );
2095         for ( i = 0; i < 0x4C; i+= 8 ) {
2096                 data0 = TLan_DioRead32( io_base, i );
2097                 data1 = TLan_DioRead32( io_base, i + 0x4 );
2098                 printk( "TLAN:      0x%02x  0x%08x 0x%08x\n", i, data0, data1 );
2099         }
2100
2101 } /* TLan_PrintDio */
2102
2103
2104
2105
2106         /***************************************************************
2107          *      TLan_PrintList
2108          *
2109          *      Returns:
2110          *              Nothing
2111          *      Parms:
2112          *              list    A pointer to the TLanList structure to
2113          *                      be printed.
2114          *              type    A string to designate type of list,
2115          *                      "Rx" or "Tx".
2116          *              num     The index of the list.
2117          *
2118          *      This function prints out the contents of the list
2119          *      pointed to by the list parameter.
2120          *
2121          **************************************************************/
2122
2123 void TLan_PrintList( TLanList *list, char *type, int num)
2124 {
2125         int i;
2126
2127         printk( "TLAN:   %s List %d at 0x%08x\n", type, num, (u32) list );
2128         printk( "TLAN:      Forward    = 0x%08x\n",  list->forward );
2129         printk( "TLAN:      CSTAT      = 0x%04hx\n", list->cStat );
2130         printk( "TLAN:      Frame Size = 0x%04hx\n", list->frameSize );
2131         /* for ( i = 0; i < 10; i++ ) { */
2132         for ( i = 0; i < 2; i++ ) {
2133                 printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address );
2134         }
2135
2136 } /* TLan_PrintList */
2137
2138
2139
2140
2141         /***************************************************************
2142          *      TLan_ReadAndClearStats
2143          *
2144          *      Returns:
2145          *              Nothing
2146          *      Parms:
2147          *              dev     Pointer to device structure of adapter
2148          *                      to which to read stats.
2149          *              record  Flag indicating whether to add
2150          *
2151          *      This functions reads all the internal status registers
2152          *      of the TLAN chip, which clears them as a side effect.
2153          *      It then either adds the values to the device's status
2154          *      struct, or discards them, depending on whether record
2155          *      is TLAN_RECORD (!=0)  or TLAN_IGNORE (==0).
2156          *
2157          **************************************************************/
2158
2159 void TLan_ReadAndClearStats( struct net_device *dev, int record )
2160 {
2161         TLanPrivateInfo *priv = netdev_priv(dev);
2162         u32             tx_good, tx_under;
2163         u32             rx_good, rx_over;
2164         u32             def_tx, crc, code;
2165         u32             multi_col, single_col;
2166         u32             excess_col, late_col, loss;
2167
2168         outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2169         tx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2170         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2171         tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2172         tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2173
2174         outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
2175         rx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
2176         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2177         rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
2178         rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2179
2180         outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
2181         def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
2182         def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2183         crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2184         code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
2185
2186         outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2187         multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
2188         multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
2189         single_col  = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2190         single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
2191
2192         outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
2193         excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
2194         late_col   = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
2195         loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
2196
2197         if ( record ) {
2198                 priv->stats.rx_packets += rx_good;
2199                 priv->stats.rx_errors  += rx_over + crc + code;
2200                 priv->stats.tx_packets += tx_good;
2201                 priv->stats.tx_errors  += tx_under + loss;
2202                 priv->stats.collisions += multi_col + single_col + excess_col + late_col;
2203
2204                 priv->stats.rx_over_errors    += rx_over;
2205                 priv->stats.rx_crc_errors     += crc;
2206                 priv->stats.rx_frame_errors   += code;
2207
2208                 priv->stats.tx_aborted_errors += tx_under;
2209                 priv->stats.tx_carrier_errors += loss;
2210         }
2211
2212 } /* TLan_ReadAndClearStats */
2213
2214
2215
2216
2217         /***************************************************************
2218          *      TLan_Reset
2219          *
2220          *      Returns:
2221          *              0
2222          *      Parms:
2223          *              dev     Pointer to device structure of adapter
2224          *                      to be reset.
2225          *
2226          *      This function resets the adapter and it's physical
2227          *      device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
2228          *      Programmer's Guide" for details.  The routine tries to
2229          *      implement what is detailed there, though adjustments
2230          *      have been made.
2231          *
2232          **************************************************************/
2233
2234 void
2235 TLan_ResetAdapter( struct net_device *dev )
2236 {
2237         TLanPrivateInfo *priv = netdev_priv(dev);
2238         int             i;
2239         u32             addr;
2240         u32             data;
2241         u8              data8;
2242
2243         priv->tlanFullDuplex = FALSE;
2244         priv->phyOnline=0;
2245         netif_carrier_off(dev);
2246
2247 /*  1.  Assert reset bit. */
2248
2249         data = inl(dev->base_addr + TLAN_HOST_CMD);
2250         data |= TLAN_HC_AD_RST;
2251         outl(data, dev->base_addr + TLAN_HOST_CMD);
2252
2253         udelay(1000);
2254
2255 /*  2.  Turn off interrupts. ( Probably isn't necessary ) */
2256
2257         data = inl(dev->base_addr + TLAN_HOST_CMD);
2258         data |= TLAN_HC_INT_OFF;
2259         outl(data, dev->base_addr + TLAN_HOST_CMD);
2260
2261 /*  3.  Clear AREGs and HASHs. */
2262
2263         for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
2264                 TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
2265         }
2266
2267 /*  4.  Setup NetConfig register. */
2268
2269         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2270         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2271
2272 /*  5.  Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2273
2274         outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
2275         outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
2276
2277 /*  6.  Unreset the MII by setting NMRST (in NetSio) to 1. */
2278
2279         outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
2280         addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2281         TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
2282
2283 /*  7.  Setup the remaining registers. */
2284
2285         if ( priv->tlanRev >= 0x30 ) {
2286                 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2287                 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
2288         }
2289         TLan_PhyDetect( dev );
2290         data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2291
2292         if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
2293                 data |= TLAN_NET_CFG_BIT;
2294                 if ( priv->aui == 1 ) {
2295                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
2296                 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2297                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
2298                         priv->tlanFullDuplex = TRUE;
2299                 } else {
2300                         TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
2301                 }
2302         }
2303
2304         if ( priv->phyNum == 0 ) {
2305                 data |= TLAN_NET_CFG_PHY_EN;
2306         }
2307         TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2308
2309         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2310                 TLan_FinishReset( dev );
2311         } else {
2312                 TLan_PhyPowerDown( dev );
2313         }
2314
2315 } /* TLan_ResetAdapter */
2316
2317
2318
2319
2320 void
2321 TLan_FinishReset( struct net_device *dev )
2322 {
2323         TLanPrivateInfo *priv = netdev_priv(dev);
2324         u8              data;
2325         u32             phy;
2326         u8              sio;
2327         u16             status;
2328         u16             partner;
2329         u16             tlphy_ctl;
2330         u16             tlphy_par;
2331         u16             tlphy_id1, tlphy_id2;
2332         int             i;
2333
2334         phy = priv->phy[priv->phyNum];
2335
2336         data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2337         if ( priv->tlanFullDuplex ) {
2338                 data |= TLAN_NET_CMD_DUPLEX;
2339         }
2340         TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2341         data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2342         if ( priv->phyNum == 0 ) {
2343                 data |= TLAN_NET_MASK_MASK7;
2344         }
2345         TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
2346         TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
2347         TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
2348         TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2349
2350         if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
2351                 status = MII_GS_LINK;
2352                 printk( "TLAN:  %s: Link forced.\n", dev->name );
2353         } else {
2354                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2355                 udelay( 1000 );
2356                 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2357                 if ( (status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */
2358                         (tlphy_id1 == NAT_SEM_ID1) &&
2359                         (tlphy_id2 == NAT_SEM_ID2) ) {
2360                         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
2361                         TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
2362
2363                         printk( "TLAN: %s: Link active with ", dev->name );
2364                         if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
2365                                  printk( "forced 10%sMbps %s-Duplex\n",
2366                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2367                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2368                         } else {
2369                                 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
2370                                                 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
2371                                                 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
2372                                 printk("TLAN: Partner capability: ");
2373                                         for (i = 5; i <= 10; i++)
2374                                                 if (partner & (1<<i))
2375                                                         printk("%s",media[i-5]);
2376                                 printk("\n");
2377                         }
2378
2379                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2380 #ifdef MONITOR
2381                         /* We have link beat..for now anyway */
2382                         priv->link = 1;
2383                         /*Enabling link beat monitoring */
2384                         TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
2385 #endif
2386                 } else if (status & MII_GS_LINK)  {
2387                         printk( "TLAN: %s: Link active\n", dev->name );
2388                         TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
2389                 }
2390         }
2391
2392         if ( priv->phyNum == 0 ) {
2393                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
2394                 tlphy_ctl |= TLAN_TC_INTEN;
2395                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
2396                 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
2397                 sio |= TLAN_NET_SIO_MINTEN;
2398                 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
2399         }
2400
2401         if ( status & MII_GS_LINK ) {
2402                 TLan_SetMac( dev, 0, dev->dev_addr );
2403                 priv->phyOnline = 1;
2404                 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2405                 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
2406                         outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
2407                 }
2408                 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM );
2409                 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
2410                 netif_carrier_on(dev);
2411         } else {
2412                 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
2413                 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2414                 return;
2415         }
2416         TLan_SetMulticastList(dev);
2417
2418 } /* TLan_FinishReset */
2419
2420
2421
2422
2423         /***************************************************************
2424          *      TLan_SetMac
2425          *
2426          *      Returns:
2427          *              Nothing
2428          *      Parms:
2429          *              dev     Pointer to device structure of adapter
2430          *                      on which to change the AREG.
2431          *              areg    The AREG to set the address in (0 - 3).
2432          *              mac     A pointer to an array of chars.  Each
2433          *                      element stores one byte of the address.
2434          *                      IE, it isn't in ascii.
2435          *
2436          *      This function transfers a MAC address to one of the
2437          *      TLAN AREGs (address registers).  The TLAN chip locks
2438          *      the register on writing to offset 0 and unlocks the
2439          *      register after writing to offset 5.  If NULL is passed
2440          *      in mac, then the AREG is filled with 0's.
2441          *
2442          **************************************************************/
2443
2444 void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2445 {
2446         int i;
2447
2448         areg *= 6;
2449
2450         if ( mac != NULL ) {
2451                 for ( i = 0; i < 6; i++ )
2452                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
2453         } else {
2454                 for ( i = 0; i < 6; i++ )
2455                         TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
2456         }
2457
2458 } /* TLan_SetMac */
2459
2460
2461
2462
2463 /*****************************************************************************
2464 ******************************************************************************
2465
2466         ThunderLAN Driver PHY Layer Routines
2467
2468 ******************************************************************************
2469 *****************************************************************************/
2470
2471
2472
2473         /*********************************************************************
2474          *      TLan_PhyPrint
2475          *
2476          *      Returns:
2477          *              Nothing
2478          *      Parms:
2479          *              dev     A pointer to the device structure of the
2480          *                      TLAN device having the PHYs to be detailed.
2481          *
2482          *      This function prints the registers a PHY (aka transceiver).
2483          *
2484          ********************************************************************/
2485
2486 void TLan_PhyPrint( struct net_device *dev )
2487 {
2488         TLanPrivateInfo *priv = netdev_priv(dev);
2489         u16 i, data0, data1, data2, data3, phy;
2490
2491         phy = priv->phy[priv->phyNum];
2492
2493         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2494                 printk( "TLAN:   Device %s, Unmanaged PHY.\n", dev->name );
2495         } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
2496                 printk( "TLAN:   Device %s, PHY 0x%02x.\n", dev->name, phy );
2497                 printk( "TLAN:      Off.  +0     +1     +2     +3 \n" );
2498                 for ( i = 0; i < 0x20; i+= 4 ) {
2499                         printk( "TLAN:      0x%02x", i );
2500                         TLan_MiiReadReg( dev, phy, i, &data0 );
2501                         printk( " 0x%04hx", data0 );
2502                         TLan_MiiReadReg( dev, phy, i + 1, &data1 );
2503                         printk( " 0x%04hx", data1 );
2504                         TLan_MiiReadReg( dev, phy, i + 2, &data2 );
2505                         printk( " 0x%04hx", data2 );
2506                         TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2507                         printk( " 0x%04hx\n", data3 );
2508                 }
2509         } else {
2510                 printk( "TLAN:   Device %s, Invalid PHY.\n", dev->name );
2511         }
2512
2513 } /* TLan_PhyPrint */
2514
2515
2516
2517
2518         /*********************************************************************
2519          *      TLan_PhyDetect
2520          *
2521          *      Returns:
2522          *              Nothing
2523          *      Parms:
2524          *              dev     A pointer to the device structure of the adapter
2525          *                      for which the PHY needs determined.
2526          *
2527          *      So far I've found that adapters which have external PHYs
2528          *      may also use the internal PHY for part of the functionality.
2529          *      (eg, AUI/Thinnet).  This function finds out if this TLAN
2530          *      chip has an internal PHY, and then finds the first external
2531          *      PHY (starting from address 0) if it exists).
2532          *
2533          ********************************************************************/
2534
2535 void TLan_PhyDetect( struct net_device *dev )
2536 {
2537         TLanPrivateInfo *priv = netdev_priv(dev);
2538         u16             control;
2539         u16             hi;
2540         u16             lo;
2541         u32             phy;
2542
2543         if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
2544                 priv->phyNum = 0xFFFF;
2545                 return;
2546         }
2547
2548         TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
2549
2550         if ( hi != 0xFFFF ) {
2551                 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2552         } else {
2553                 priv->phy[0] = TLAN_PHY_NONE;
2554         }
2555
2556         priv->phy[1] = TLAN_PHY_NONE;
2557         for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
2558                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
2559                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
2560                 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
2561                 if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
2562                         TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
2563                         if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
2564                                 priv->phy[1] = phy;
2565                         }
2566                 }
2567         }
2568
2569         if ( priv->phy[1] != TLAN_PHY_NONE ) {
2570                 priv->phyNum = 1;
2571         } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
2572                 priv->phyNum = 0;
2573         } else {
2574                 printk( "TLAN:  Cannot initialize device, no PHY was found!\n" );
2575         }
2576
2577 } /* TLan_PhyDetect */
2578
2579
2580
2581
2582 void TLan_PhyPowerDown( struct net_device *dev )
2583 {
2584         TLanPrivateInfo *priv = netdev_priv(dev);
2585         u16             value;
2586
2587         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name );
2588         value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2589         TLan_MiiSync( dev->base_addr );
2590         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2591         if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
2592                 TLan_MiiSync( dev->base_addr );
2593                 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
2594         }
2595
2596         /* Wait for 50 ms and powerup
2597          * This is abitrary.  It is intended to make sure the
2598          * transceiver settles.
2599          */
2600         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
2601
2602 } /* TLan_PhyPowerDown */
2603
2604
2605
2606
2607 void TLan_PhyPowerUp( struct net_device *dev )
2608 {
2609         TLanPrivateInfo *priv = netdev_priv(dev);
2610         u16             value;
2611
2612         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name );
2613         TLan_MiiSync( dev->base_addr );
2614         value = MII_GC_LOOPBK;
2615         TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
2616         TLan_MiiSync(dev->base_addr);
2617         /* Wait for 500 ms and reset the
2618          * transceiver.  The TLAN docs say both 50 ms and
2619          * 500 ms, so do the longer, just in case.
2620          */
2621         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
2622
2623 } /* TLan_PhyPowerUp */
2624
2625
2626
2627
2628 void TLan_PhyReset( struct net_device *dev )
2629 {
2630         TLanPrivateInfo *priv = netdev_priv(dev);
2631         u16             phy;
2632         u16             value;
2633
2634         phy = priv->phy[priv->phyNum];
2635
2636         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name );
2637         TLan_MiiSync( dev->base_addr );
2638         value = MII_GC_LOOPBK | MII_GC_RESET;
2639         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
2640         TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2641         while ( value & MII_GC_RESET ) {
2642                 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
2643         }
2644
2645         /* Wait for 500 ms and initialize.
2646          * I don't remember why I wait this long.
2647          * I've changed this to 50ms, as it seems long enough.
2648          */
2649         TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
2650
2651 } /* TLan_PhyReset */
2652
2653
2654
2655
2656 void TLan_PhyStartLink( struct net_device *dev )
2657 {
2658         TLanPrivateInfo *priv = netdev_priv(dev);
2659         u16             ability;
2660         u16             control;
2661         u16             data;
2662         u16             phy;
2663         u16             status;
2664         u16             tctl;
2665
2666         phy = priv->phy[priv->phyNum];
2667         TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name );
2668         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2669         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
2670
2671         if ( ( status & MII_GS_AUTONEG ) &&
2672              ( ! priv->aui ) ) {
2673                 ability = status >> 11;
2674                 if ( priv->speed  == TLAN_SPEED_10 &&
2675                      priv->duplex == TLAN_DUPLEX_HALF) {
2676                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
2677                 } else if ( priv->speed == TLAN_SPEED_10 &&
2678                             priv->duplex == TLAN_DUPLEX_FULL) {
2679                         priv->tlanFullDuplex = TRUE;
2680                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
2681                 } else if ( priv->speed == TLAN_SPEED_100 &&
2682                             priv->duplex == TLAN_DUPLEX_HALF) {
2683                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
2684                 } else if ( priv->speed == TLAN_SPEED_100 &&
2685                             priv->duplex == TLAN_DUPLEX_FULL) {
2686                         priv->tlanFullDuplex = TRUE;
2687                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
2688                 } else {
2689
2690                         /* Set Auto-Neg advertisement */
2691                         TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
2692                         /* Enablee Auto-Neg */
2693                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
2694                         /* Restart Auto-Neg */
2695                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
2696                         /* Wait for 4 sec for autonegotiation
2697                         * to complete.  The max spec time is less than this
2698                         * but the card need additional time to start AN.
2699                         * .5 sec should be plenty extra.
2700                         */
2701                         printk( "TLAN: %s: Starting autonegotiation.\n", dev->name );
2702                         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
2703                         return;
2704                 }
2705
2706         }
2707
2708         if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
2709                 priv->phyNum = 0;
2710                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2711                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2712                 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2713                 return;
2714         }  else if ( priv->phyNum == 0 ) {
2715                 control = 0;
2716                 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
2717                 if ( priv->aui ) {
2718                         tctl |= TLAN_TC_AUISEL;
2719                 } else {
2720                         tctl &= ~TLAN_TC_AUISEL;
2721                         if ( priv->duplex == TLAN_DUPLEX_FULL ) {
2722                                 control |= MII_GC_DUPLEX;
2723                                 priv->tlanFullDuplex = TRUE;
2724                         }
2725                         if ( priv->speed == TLAN_SPEED_100 ) {
2726                                 control |= MII_GC_SPEEDSEL;
2727                         }
2728                 }
2729                 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
2730                 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
2731         }
2732
2733         /* Wait for 2 sec to give the transceiver time
2734          * to establish link.
2735          */
2736         TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
2737
2738 } /* TLan_PhyStartLink */
2739
2740
2741
2742
2743 void TLan_PhyFinishAutoNeg( struct net_device *dev )
2744 {
2745         TLanPrivateInfo *priv = netdev_priv(dev);
2746         u16             an_adv;
2747         u16             an_lpa;
2748         u16             data;
2749         u16             mode;
2750         u16             phy;
2751         u16             status;
2752
2753         phy = priv->phy[priv->phyNum];
2754
2755         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2756         udelay( 1000 );
2757         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
2758
2759         if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
2760                 /* Wait for 8 sec to give the process
2761                  * more time.  Perhaps we should fail after a while.
2762                  */
2763                  if (!priv->neg_be_verbose++) {
2764                          printk(KERN_INFO "TLAN:  Giving autonegotiation more time.\n");
2765                          printk(KERN_INFO "TLAN:  Please check that your adapter has\n");
2766                          printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.\n");
2767                          printk(KERN_INFO "TLAN:  Trying to establish link in the background...\n");
2768                  }
2769                 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
2770                 return;
2771         }
2772
2773         printk( "TLAN: %s: Autonegotiation complete.\n", dev->name );
2774         TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
2775         TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
2776         mode = an_adv & an_lpa & 0x03E0;
2777         if ( mode & 0x0100 ) {
2778                 priv->tlanFullDuplex = TRUE;
2779         } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
2780                 priv->tlanFullDuplex = TRUE;
2781         }
2782
2783         if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
2784                 priv->phyNum = 0;
2785                 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2786                 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
2787                 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
2788                 return;
2789         }
2790
2791         if ( priv->phyNum == 0 ) {
2792                 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
2793                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
2794                         printk( "TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
2795                 } else {
2796                         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
2797                         printk( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
2798                 }
2799         }
2800
2801         /* Wait for 100 ms.  No reason in partiticular.
2802          */
2803         TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
2804
2805 } /* TLan_PhyFinishAutoNeg */
2806
2807 #ifdef MONITOR
2808
2809         /*********************************************************************
2810         *
2811         *      TLan_phyMonitor
2812         *
2813         *      Returns:
2814         *              None
2815         *
2816         *      Params:
2817         *              dev             The device structure of this device.
2818         *
2819         *
2820         *      This function monitors PHY condition by reading the status
2821         *      register via the MII bus. This can be used to give info
2822         *      about link changes (up/down), and possible switch to alternate
2823         *      media.
2824         *
2825         * ******************************************************************/
2826
2827 void TLan_PhyMonitor( struct net_device *dev )
2828 {
2829         TLanPrivateInfo *priv = netdev_priv(dev);
2830         u16     phy;
2831         u16     phy_status;
2832
2833         phy = priv->phy[priv->phyNum];
2834
2835         /* Get PHY status register */
2836         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
2837
2838         /* Check if link has been lost */
2839         if (!(phy_status & MII_GS_LINK)) {
2840                if (priv->link) {
2841                       priv->link = 0;
2842                       printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
2843                       netif_carrier_off(dev);
2844                       TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2845                       return;
2846                 }
2847         }
2848
2849         /* Link restablished? */
2850         if ((phy_status & MII_GS_LINK) && !priv->link) {
2851                 priv->link = 1;
2852                 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name);
2853                 netif_carrier_on(dev);
2854         }
2855
2856         /* Setup a new monitor */
2857         TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
2858 }
2859
2860 #endif /* MONITOR */
2861
2862
2863 /*****************************************************************************
2864 ******************************************************************************
2865
2866         ThunderLAN Driver MII Routines
2867
2868         These routines are based on the information in Chap. 2 of the
2869         "ThunderLAN Programmer's Guide", pp. 15-24.
2870
2871 ******************************************************************************
2872 *****************************************************************************/
2873
2874
2875         /***************************************************************
2876          *      TLan_MiiReadReg
2877          *
2878          *      Returns:
2879          *              0       if ack received ok
2880          *              1       otherwise.
2881          *
2882          *      Parms:
2883          *              dev             The device structure containing
2884          *                              The io address and interrupt count
2885          *                              for this device.
2886          *              phy             The address of the PHY to be queried.
2887          *              reg             The register whose contents are to be
2888          *                              retrieved.
2889          *              val             A pointer to a variable to store the
2890          *                              retrieved value.
2891          *
2892          *      This function uses the TLAN's MII bus to retrieve the contents
2893          *      of a given register on a PHY.  It sends the appropriate info
2894          *      and then reads the 16-bit register value from the MII bus via
2895          *      the TLAN SIO register.
2896          *
2897          **************************************************************/
2898
2899 int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
2900 {
2901         u8      nack;
2902         u16     sio, tmp;
2903         u32     i;
2904         int     err;
2905         int     minten;
2906         TLanPrivateInfo *priv = netdev_priv(dev);
2907         unsigned long flags = 0;
2908
2909         err = FALSE;
2910         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2911         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2912
2913         if (!in_irq())
2914                 spin_lock_irqsave(&priv->lock, flags);
2915
2916         TLan_MiiSync(dev->base_addr);
2917
2918         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
2919         if ( minten )
2920                 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
2921
2922         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
2923         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Read  ( 10b ) */
2924         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
2925         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
2926
2927
2928         TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio);         /* Change direction */
2929
2930         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Clock Idle bit */
2931         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2932         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Wait 300ns */
2933
2934         nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio);    /* Check for ACK */
2935         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);            /* Finish ACK */
2936         if (nack) {                                     /* No ACK, so fake it */
2937                 for (i = 0; i < 16; i++) {
2938                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2939                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2940                 }
2941                 tmp = 0xffff;
2942                 err = TRUE;
2943         } else {                                        /* ACK, so read data */
2944                 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2945                         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
2946                         if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
2947                                 tmp |= i;
2948                         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2949                 }
2950         }
2951
2952
2953         TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);          /* Idle cycle */
2954         TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
2955
2956         if ( minten )
2957                 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
2958
2959         *val = tmp;
2960
2961         if (!in_irq())
2962                 spin_unlock_irqrestore(&priv->lock, flags);
2963
2964         return err;
2965
2966 } /* TLan_MiiReadReg */
2967
2968
2969
2970
2971         /***************************************************************
2972          *      TLan_MiiSendData
2973          *
2974          *      Returns:
2975          *              Nothing
2976          *      Parms:
2977          *              base_port       The base IO port of the adapter in
2978          *                              question.
2979          *              dev             The address of the PHY to be queried.
2980          *              data            The value to be placed on the MII bus.
2981          *              num_bits        The number of bits in data that are to
2982          *                              be placed on the MII bus.
2983          *
2984          *      This function sends on sequence of bits on the MII
2985          *      configuration bus.
2986          *
2987          **************************************************************/
2988
2989 void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
2990 {
2991         u16 sio;
2992         u32 i;
2993
2994         if ( num_bits == 0 )
2995                 return;
2996
2997         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
2998         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2999         TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
3000
3001         for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
3002                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3003                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
3004                 if ( data & i )
3005                         TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
3006                 else
3007                         TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
3008                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3009                 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
3010         }
3011
3012 } /* TLan_MiiSendData */
3013
3014
3015
3016
3017         /***************************************************************
3018          *      TLan_MiiSync
3019          *
3020          *      Returns:
3021          *              Nothing
3022          *      Parms:
3023          *              base_port       The base IO port of the adapter in
3024          *                              question.
3025          *
3026          *      This functions syncs all PHYs in terms of the MII configuration
3027          *      bus.
3028          *
3029          **************************************************************/
3030
3031 void TLan_MiiSync( u16 base_port )
3032 {
3033         int i;
3034         u16 sio;
3035
3036         outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
3037         sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3038
3039         TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
3040         for ( i = 0; i < 32; i++ ) {
3041                 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
3042                 TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3043         }
3044
3045 } /* TLan_MiiSync */
3046
3047
3048
3049
3050         /***************************************************************
3051          *      TLan_MiiWriteReg
3052          *
3053          *      Returns:
3054          *              Nothing
3055          *      Parms:
3056          *              dev             The device structure for the device
3057          *                              to write to.
3058          *              phy             The address of the PHY to be written to.
3059          *              reg             The register whose contents are to be
3060          *                              written.
3061          *              val             The value to be written to the register.
3062          *
3063          *      This function uses the TLAN's MII bus to write the contents of a
3064          *      given register on a PHY.  It sends the appropriate info and then
3065          *      writes the 16-bit register value from the MII configuration bus
3066          *      via the TLAN SIO register.
3067          *
3068          **************************************************************/
3069
3070 void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
3071 {
3072         u16     sio;
3073         int     minten;
3074         unsigned long flags = 0;
3075         TLanPrivateInfo *priv = netdev_priv(dev);
3076
3077         outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3078         sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
3079
3080         if (!in_irq())
3081                 spin_lock_irqsave(&priv->lock, flags);
3082
3083         TLan_MiiSync( dev->base_addr );
3084
3085         minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
3086         if ( minten )
3087                 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
3088
3089         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Start ( 01b ) */
3090         TLan_MiiSendData( dev->base_addr, 0x1, 2 );     /* Write ( 01b ) */
3091         TLan_MiiSendData( dev->base_addr, phy, 5 );     /* Device #      */
3092         TLan_MiiSendData( dev->base_addr, reg, 5 );     /* Register #    */
3093
3094         TLan_MiiSendData( dev->base_addr, 0x2, 2 );     /* Send ACK */
3095         TLan_MiiSendData( dev->base_addr, val, 16 );    /* Send Data */
3096
3097         TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );        /* Idle cycle */
3098         TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
3099
3100         if ( minten )
3101                 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
3102
3103         if (!in_irq())
3104                 spin_unlock_irqrestore(&priv->lock, flags);
3105
3106 } /* TLan_MiiWriteReg */
3107
3108
3109
3110
3111 /*****************************************************************************
3112 ******************************************************************************
3113
3114         ThunderLAN Driver Eeprom routines
3115
3116         The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
3117         EEPROM.  These functions are based on information in Microchip's
3118         data sheet.  I don't know how well this functions will work with
3119         other EEPROMs.
3120
3121 ******************************************************************************
3122 *****************************************************************************/
3123
3124
3125         /***************************************************************
3126          *      TLan_EeSendStart
3127          *
3128          *      Returns:
3129          *              Nothing
3130          *      Parms:
3131          *              io_base         The IO port base address for the
3132          *                              TLAN device with the EEPROM to
3133          *                              use.
3134          *
3135          *      This function sends a start cycle to an EEPROM attached
3136          *      to a TLAN chip.
3137          *
3138          **************************************************************/
3139
3140 void TLan_EeSendStart( u16 io_base )
3141 {
3142         u16     sio;
3143
3144         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3145         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3146
3147         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3148         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3149         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3150         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3151         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3152
3153 } /* TLan_EeSendStart */
3154
3155
3156
3157
3158         /***************************************************************
3159          *      TLan_EeSendByte
3160          *
3161          *      Returns:
3162          *              If the correct ack was received, 0, otherwise 1
3163          *      Parms:  io_base         The IO port base address for the
3164          *                              TLAN device with the EEPROM to
3165          *                              use.
3166          *              data            The 8 bits of information to
3167          *                              send to the EEPROM.
3168          *              stop            If TLAN_EEPROM_STOP is passed, a
3169          *                              stop cycle is sent after the
3170          *                              byte is sent after the ack is
3171          *                              read.
3172          *
3173          *      This function sends a byte on the serial EEPROM line,
3174          *      driving the clock to send each bit. The function then
3175          *      reverses transmission direction and reads an acknowledge
3176          *      bit.
3177          *
3178          **************************************************************/
3179
3180 int TLan_EeSendByte( u16 io_base, u8 data, int stop )
3181 {
3182         int     err;
3183         u8      place;
3184         u16     sio;
3185
3186         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3187         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3188
3189         /* Assume clock is low, tx is enabled; */
3190         for ( place = 0x80; place != 0; place >>= 1 ) {
3191                 if ( place & data )
3192                         TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3193                 else
3194                         TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
3195                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3196                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3197         }
3198         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3199         TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3200         err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
3201         TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3202         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3203
3204         if ( ( ! err ) && stop ) {
3205                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3206                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3207                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3208         }
3209
3210         return ( err );
3211
3212 } /* TLan_EeSendByte */
3213
3214
3215
3216
3217         /***************************************************************
3218          *      TLan_EeReceiveByte
3219          *
3220          *      Returns:
3221          *              Nothing
3222          *      Parms:
3223          *              io_base         The IO port base address for the
3224          *                              TLAN device with the EEPROM to
3225          *                              use.
3226          *              data            An address to a char to hold the
3227          *                              data sent from the EEPROM.
3228          *              stop            If TLAN_EEPROM_STOP is passed, a
3229          *                              stop cycle is sent after the
3230          *                              byte is received, and no ack is
3231          *                              sent.
3232          *
3233          *      This function receives 8 bits of data from the EEPROM
3234          *      over the serial link.  It then sends and ack bit, or no
3235          *      ack and a stop bit.  This function is used to retrieve
3236          *      data after the address of a byte in the EEPROM has been
3237          *      sent.
3238          *
3239          **************************************************************/
3240
3241 void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
3242 {
3243         u8  place;
3244         u16 sio;
3245
3246         outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
3247         sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3248         *data = 0;
3249
3250         /* Assume clock is low, tx is enabled; */
3251         TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
3252         for ( place = 0x80; place; place >>= 1 ) {
3253                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3254                 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
3255                         *data |= place;
3256                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3257         }
3258
3259         TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
3260         if ( ! stop ) {
3261                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* Ack = 0 */
3262                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3263                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3264         } else {
3265                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );         /* No ack = 1 (?) */
3266                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3267                 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
3268                 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
3269                 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
3270                 TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
3271         }
3272
3273 } /* TLan_EeReceiveByte */
3274
3275
3276
3277
3278         /***************************************************************
3279          *      TLan_EeReadByte
3280          *
3281          *      Returns:
3282          *              No error = 0, else, the stage at which the error
3283          *              occurred.
3284          *      Parms:
3285          *              io_base         The IO port base address for the
3286          *                              TLAN device with the EEPROM to
3287          *                              use.
3288          *              ee_addr         The address of the byte in the
3289          *                              EEPROM whose contents are to be
3290          *                              retrieved.
3291          *              data            An address to a char to hold the
3292          *                              data obtained from the EEPROM.
3293          *
3294          *      This function reads a byte of information from an byte
3295          *      cell in the EEPROM.
3296          *
3297          **************************************************************/
3298
3299 int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
3300 {
3301         int err;
3302         TLanPrivateInfo *priv = netdev_priv(dev);
3303         unsigned long flags = 0;
3304         int ret=0;
3305
3306         spin_lock_irqsave(&priv->lock, flags);
3307
3308         TLan_EeSendStart( dev->base_addr );
3309         err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
3310         if (err)
3311         {
3312                 ret=1;
3313                 goto fail;
3314         }
3315         err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
3316         if (err)
3317         {
3318                 ret=2;
3319                 goto fail;
3320         }
3321         TLan_EeSendStart( dev->base_addr );
3322         err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
3323         if (err)
3324         {
3325                 ret=3;
3326                 goto fail;
3327         }
3328         TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
3329 fail:
3330         spin_unlock_irqrestore(&priv->lock, flags);
3331
3332         return ret;
3333
3334 } /* TLan_EeReadByte */
3335
3336
3337