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