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