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