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