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