drivers/net/tulip/dmfe.c

   1 /*
   2     A Davicom DM9102/DM9102A/DM9102A+DM9801/DM9102A+DM9802 NIC fast
   3     ethernet driver for Linux.
   4     Copyright (C) 1997  Sten Wang
   5
   6     This program is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU General Public License
   8     as published by the Free Software Foundation; either version 2
   9     of the License, or (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     DAVICOM Web-Site: www.davicom.com.tw
  17
  18     Author: Sten Wang, 886-3-5798797-8517, E-mail: sten_wang@davicom.com.tw
  19     Maintainer: Tobias Ringstrom <tori@unhappy.mine.nu>
  20
  21     (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
  22
  23     Marcelo Tosatti <marcelo@conectiva.com.br> :
  24     Made it compile in 2.3 (device to net_device)
  25
  26     Alan Cox <alan@redhat.com> :
  27     Cleaned up for kernel merge.
  28     Removed the back compatibility support
  29     Reformatted, fixing spelling etc as I went
  30     Removed IRQ 0-15 assumption
  31
  32     Jeff Garzik <jgarzik@pobox.com> :
  33     Updated to use new PCI driver API.
  34     Resource usage cleanups.
  35     Report driver version to user.
  36
  37     Tobias Ringstrom <tori@unhappy.mine.nu> :
  38     Cleaned up and added SMP safety.  Thanks go to Jeff Garzik,
  39     Andrew Morton and Frank Davis for the SMP safety fixes.
  40
  41     Vojtech Pavlik <vojtech@suse.cz> :
  42     Cleaned up pointer arithmetics.
  43     Fixed a lot of 64bit issues.
  44     Cleaned up printk()s a bit.
  45     Fixed some obvious big endian problems.
  46
  47     Tobias Ringstrom <tori@unhappy.mine.nu> :
  48     Use time_after for jiffies calculation.  Added ethtool
  49     support.  Updated PCI resource allocation.  Do not
  50     forget to unmap PCI mapped skbs.
  51
  52     Alan Cox <alan@redhat.com>
  53     Added new PCI identifiers provided by Clear Zhang at ALi
  54     for their 1563 ethernet device.
  55
  56     TODO
  57
  58     Implement pci_driver::suspend() and pci_driver::resume()
  59     power management methods.
  60
  61     Check on 64 bit boxes.
  62     Check and fix on big endian boxes.
  63
  64     Test and make sure PCI latency is now correct for all cases.
  65 */
  66
  67 #define DRV_NAME        "dmfe"
  68 #define DRV_VERSION     "1.36.4"
  69 #define DRV_RELDATE     "2002-01-17"
  70
  71 #include <linux/module.h>
  72 #include <linux/kernel.h>
  73 #include <linux/string.h>
  74 #include <linux/timer.h>
  75 #include <linux/ptrace.h>
  76 #include <linux/errno.h>
  77 #include <linux/ioport.h>
  78 #include <linux/slab.h>
  79 #include <linux/interrupt.h>
  80 #include <linux/pci.h>
  81 #include <linux/dma-mapping.h>
  82 #include <linux/init.h>
  83 #include <linux/netdevice.h>
  84 #include <linux/etherdevice.h>
  85 #include <linux/ethtool.h>
  86 #include <linux/skbuff.h>
  87 #include <linux/delay.h>
  88 #include <linux/spinlock.h>
  89 #include <linux/crc32.h>
  90 #include <linux/bitops.h>
  91
  92 #include <asm/processor.h>
  93 #include <asm/io.h>
  94 #include <asm/dma.h>
  95 #include <asm/uaccess.h>
  96 #include <asm/irq.h>
  97
  98
  99 /* Board/System/Debug information/definition ---------------- */
 100 #define PCI_DM9132_ID   0x91321282      /* Davicom DM9132 ID */
 101 #define PCI_DM9102_ID   0x91021282      /* Davicom DM9102 ID */
 102 #define PCI_DM9100_ID   0x91001282      /* Davicom DM9100 ID */
 103 #define PCI_DM9009_ID   0x90091282      /* Davicom DM9009 ID */
 104
 105 #define DM9102_IO_SIZE  0x80
 106 #define DM9102A_IO_SIZE 0x100
 107 #define TX_MAX_SEND_CNT 0x1             /* Maximum tx packet per time */
 108 #define TX_DESC_CNT     0x10            /* Allocated Tx descriptors */
 109 #define RX_DESC_CNT     0x20            /* Allocated Rx descriptors */
 110 #define TX_FREE_DESC_CNT (TX_DESC_CNT - 2)      /* Max TX packet count */
 111 #define TX_WAKE_DESC_CNT (TX_DESC_CNT - 3)      /* TX wakeup count */
 112 #define DESC_ALL_CNT    (TX_DESC_CNT + RX_DESC_CNT)
 113 #define TX_BUF_ALLOC    0x600
 114 #define RX_ALLOC_SIZE   0x620
 115 #define DM910X_RESET    1
 116 #define CR0_DEFAULT     0x00E00000      /* TX & RX burst mode */
 117 #define CR6_DEFAULT     0x00080000      /* HD */
 118 #define CR7_DEFAULT     0x180c1
 119 #define CR15_DEFAULT    0x06            /* TxJabber RxWatchdog */
 120 #define TDES0_ERR_MASK  0x4302          /* TXJT, LC, EC, FUE */
 121 #define MAX_PACKET_SIZE 1514
 122 #define DMFE_MAX_MULTICAST 14
 123 #define RX_COPY_SIZE    100
 124 #define MAX_CHECK_PACKET 0x8000
 125 #define DM9801_NOISE_FLOOR 8
 126 #define DM9802_NOISE_FLOOR 5
 127
 128 #define DMFE_10MHF      0
 129 #define DMFE_100MHF     1
 130 #define DMFE_10MFD      4
 131 #define DMFE_100MFD     5
 132 #define DMFE_AUTO       8
 133 #define DMFE_1M_HPNA    0x10
 134
 135 #define DMFE_TXTH_72    0x400000        /* TX TH 72 byte */
 136 #define DMFE_TXTH_96    0x404000        /* TX TH 96 byte */
 137 #define DMFE_TXTH_128   0x0000          /* TX TH 128 byte */
 138 #define DMFE_TXTH_256   0x4000          /* TX TH 256 byte */
 139 #define DMFE_TXTH_512   0x8000          /* TX TH 512 byte */
 140 #define DMFE_TXTH_1K    0xC000          /* TX TH 1K  byte */
 141
 142 #define DMFE_TIMER_WUT  (jiffies + HZ * 1)/* timer wakeup time : 1 second */
 143 #define DMFE_TX_TIMEOUT ((3*HZ)/2)      /* tx packet time-out time 1.5 s" */
 144 #define DMFE_TX_KICK    (HZ/2)  /* tx packet Kick-out time 0.5 s" */
 145
 146 #define DMFE_DBUG(dbug_now, msg, value) if (dmfe_debug || (dbug_now)) printk(KERN_ERR DRV_NAME ": %s %lx\n", (msg), (long) (value))
 147
 148 #define SHOW_MEDIA_TYPE(mode) printk(KERN_ERR DRV_NAME ": Change Speed to %sMhz %s duplex\n",mode & 1 ?"100":"10", mode & 4 ? "full":"half");
 149
 150
 151 /* CR9 definition: SROM/MII */
 152 #define CR9_SROM_READ   0x4800
 153 #define CR9_SRCS        0x1
 154 #define CR9_SRCLK       0x2
 155 #define CR9_CRDOUT      0x8
 156 #define SROM_DATA_0     0x0
 157 #define SROM_DATA_1     0x4
 158 #define PHY_DATA_1      0x20000
 159 #define PHY_DATA_0      0x00000
 160 #define MDCLKH          0x10000
 161
 162 #define PHY_POWER_DOWN  0x800
 163
 164 #define SROM_V41_CODE   0x14
 165
 166 #define SROM_CLK_WRITE(data, ioaddr) outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr);udelay(5);outl(data|CR9_SROM_READ|CR9_SRCS|CR9_SRCLK,ioaddr);udelay(5);outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr);udelay(5);
 167
 168 #define __CHK_IO_SIZE(pci_id, dev_rev) ( ((pci_id)==PCI_DM9132_ID) || ((dev_rev) >= 0x02000030) ) ? DM9102A_IO_SIZE: DM9102_IO_SIZE
 169 #define CHK_IO_SIZE(pci_dev, dev_rev) __CHK_IO_SIZE(((pci_dev)->device << 16) | (pci_dev)->vendor, dev_rev)
 170
 171 /* Sten Check */
 172 #define DEVICE net_device
 173
 174 /* Structure/enum declaration ------------------------------- */
 175 struct tx_desc {
 176         u32 tdes0, tdes1, tdes2, tdes3; /* Data for the card */
 177         char *tx_buf_ptr;               /* Data for us */
 178         struct tx_desc *next_tx_desc;
 179 } __attribute__(( aligned(32) ));
 180
 181 struct rx_desc {
 182         u32 rdes0, rdes1, rdes2, rdes3; /* Data for the card */
 183         struct sk_buff *rx_skb_ptr;     /* Data for us */
 184         struct rx_desc *next_rx_desc;
 185 } __attribute__(( aligned(32) ));
 186
 187 struct dmfe_board_info {
 188         u32 chip_id;                    /* Chip vendor/Device ID */
 189         u32 chip_revision;              /* Chip revision */
 190         struct DEVICE *dev;             /* net device */
 191         struct pci_dev *pdev;           /* PCI device */
 192         spinlock_t lock;
 193
 194         long ioaddr;                    /* I/O base address */
 195         u32 cr0_data;
 196         u32 cr5_data;
 197         u32 cr6_data;
 198         u32 cr7_data;
 199         u32 cr15_data;
 200
 201         /* pointer for memory physical address */
 202         dma_addr_t buf_pool_dma_ptr;    /* Tx buffer pool memory */
 203         dma_addr_t buf_pool_dma_start;  /* Tx buffer pool align dword */
 204         dma_addr_t desc_pool_dma_ptr;   /* descriptor pool memory */
 205         dma_addr_t first_tx_desc_dma;
 206         dma_addr_t first_rx_desc_dma;
 207
 208         /* descriptor pointer */
 209         unsigned char *buf_pool_ptr;    /* Tx buffer pool memory */
 210         unsigned char *buf_pool_start;  /* Tx buffer pool align dword */
 211         unsigned char *desc_pool_ptr;   /* descriptor pool memory */
 212         struct tx_desc *first_tx_desc;
 213         struct tx_desc *tx_insert_ptr;
 214         struct tx_desc *tx_remove_ptr;
 215         struct rx_desc *first_rx_desc;
 216         struct rx_desc *rx_insert_ptr;
 217         struct rx_desc *rx_ready_ptr;   /* packet come pointer */
 218         unsigned long tx_packet_cnt;    /* transmitted packet count */
 219         unsigned long tx_queue_cnt;     /* wait to send packet count */
 220         unsigned long rx_avail_cnt;     /* available rx descriptor count */
 221         unsigned long interval_rx_cnt;  /* rx packet count a callback time */
 222
 223         u16 HPNA_command;               /* For HPNA register 16 */
 224         u16 HPNA_timer;                 /* For HPNA remote device check */
 225         u16 dbug_cnt;
 226         u16 NIC_capability;             /* NIC media capability */
 227         u16 PHY_reg4;                   /* Saved Phyxcer register 4 value */
 228
 229         u8 HPNA_present;                /* 0:none, 1:DM9801, 2:DM9802 */
 230         u8 chip_type;                   /* Keep DM9102A chip type */
 231         u8 media_mode;                  /* user specify media mode */
 232         u8 op_mode;                     /* real work media mode */
 233         u8 phy_addr;
 234         u8 link_failed;                 /* Ever link failed */
 235         u8 wait_reset;                  /* Hardware failed, need to reset */
 236         u8 dm910x_chk_mode;             /* Operating mode check */
 237         u8 first_in_callback;           /* Flag to record state */
 238         struct timer_list timer;
 239
 240         /* System defined statistic counter */
 241         struct net_device_stats stats;
 242
 243         /* Driver defined statistic counter */
 244         unsigned long tx_fifo_underrun;
 245         unsigned long tx_loss_carrier;
 246         unsigned long tx_no_carrier;
 247         unsigned long tx_late_collision;
 248         unsigned long tx_excessive_collision;
 249         unsigned long tx_jabber_timeout;
 250         unsigned long reset_count;
 251         unsigned long reset_cr8;
 252         unsigned long reset_fatal;
 253         unsigned long reset_TXtimeout;
 254
 255         /* NIC SROM data */
 256         unsigned char srom[128];
 257 };
 258
 259 enum dmfe_offsets {
 260         DCR0 = 0x00, DCR1 = 0x08, DCR2 = 0x10, DCR3 = 0x18, DCR4 = 0x20,
 261         DCR5 = 0x28, DCR6 = 0x30, DCR7 = 0x38, DCR8 = 0x40, DCR9 = 0x48,
 262         DCR10 = 0x50, DCR11 = 0x58, DCR12 = 0x60, DCR13 = 0x68, DCR14 = 0x70,
 263         DCR15 = 0x78
 264 };
 265
 266 enum dmfe_CR6_bits {
 267         CR6_RXSC = 0x2, CR6_PBF = 0x8, CR6_PM = 0x40, CR6_PAM = 0x80,
 268         CR6_FDM = 0x200, CR6_TXSC = 0x2000, CR6_STI = 0x100000,
 269         CR6_SFT = 0x200000, CR6_RXA = 0x40000000, CR6_NO_PURGE = 0x20000000
 270 };
 271
 272 /* Global variable declaration ----------------------------- */
 273 static int __devinitdata printed_version;
 274 static char version[] __devinitdata =
 275         KERN_INFO DRV_NAME ": Davicom DM9xxx net driver, version "
 276         DRV_VERSION " (" DRV_RELDATE ")\n";
 277
 278 static int dmfe_debug;
 279 static unsigned char dmfe_media_mode = DMFE_AUTO;
 280 static u32 dmfe_cr6_user_set;
 281
 282 /* For module input parameter */
 283 static int debug;
 284 static u32 cr6set;
 285 static unsigned char mode = 8;
 286 static u8 chkmode = 1;
 287 static u8 HPNA_mode;            /* Default: Low Power/High Speed */
 288 static u8 HPNA_rx_cmd;          /* Default: Disable Rx remote command */
 289 static u8 HPNA_tx_cmd;          /* Default: Don't issue remote command */
 290 static u8 HPNA_NoiseFloor;      /* Default: HPNA NoiseFloor */
 291 static u8 SF_mode;              /* Special Function: 1:VLAN, 2:RX Flow Control
 292                                    4: TX pause packet */
 293
 294
 295 /* function declaration ------------------------------------- */
 296 static int dmfe_open(struct DEVICE *);
 297 static int dmfe_start_xmit(struct sk_buff *, struct DEVICE *);
 298 static int dmfe_stop(struct DEVICE *);
 299 static struct net_device_stats * dmfe_get_stats(struct DEVICE *);
 300 static void dmfe_set_filter_mode(struct DEVICE *);
 301 static const struct ethtool_ops netdev_ethtool_ops;
 302 static u16 read_srom_word(long ,int);
 303 static irqreturn_t dmfe_interrupt(int , void *);
 304 #ifdef CONFIG_NET_POLL_CONTROLLER
 305 static void poll_dmfe (struct net_device *dev);
 306 #endif
 307 static void dmfe_descriptor_init(struct dmfe_board_info *, unsigned long);
 308 static void allocate_rx_buffer(struct dmfe_board_info *);
 309 static void update_cr6(u32, unsigned long);
 310 static void send_filter_frame(struct DEVICE * ,int);
 311 static void dm9132_id_table(struct DEVICE * ,int);
 312 static u16 phy_read(unsigned long, u8, u8, u32);
 313 static void phy_write(unsigned long, u8, u8, u16, u32);
 314 static void phy_write_1bit(unsigned long, u32);
 315 static u16 phy_read_1bit(unsigned long);
 316 static u8 dmfe_sense_speed(struct dmfe_board_info *);
 317 static void dmfe_process_mode(struct dmfe_board_info *);
 318 static void dmfe_timer(unsigned long);
 319 static inline u32 cal_CRC(unsigned char *, unsigned int, u8);
 320 static void dmfe_rx_packet(struct DEVICE *, struct dmfe_board_info *);
 321 static void dmfe_free_tx_pkt(struct DEVICE *, struct dmfe_board_info *);
 322 static void dmfe_reuse_skb(struct dmfe_board_info *, struct sk_buff *);
 323 static void dmfe_dynamic_reset(struct DEVICE *);
 324 static void dmfe_free_rxbuffer(struct dmfe_board_info *);
 325 static void dmfe_init_dm910x(struct DEVICE *);
 326 static void dmfe_parse_srom(struct dmfe_board_info *);
 327 static void dmfe_program_DM9801(struct dmfe_board_info *, int);
 328 static void dmfe_program_DM9802(struct dmfe_board_info *);
 329 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * );
 330 static void dmfe_set_phyxcer(struct dmfe_board_info *);
 331
 332 /* DM910X network baord routine ---------------------------- */
 333
 334 /*
 335  *      Search DM910X board ,allocate space and register it
 336  */
 337
 338 static int __devinit dmfe_init_one (struct pci_dev *pdev,
 339                                     const struct pci_device_id *ent)
 340 {
 341         struct dmfe_board_info *db;     /* board information structure */
 342         struct net_device *dev;
 343         u32 dev_rev, pci_pmr;
 344         int i, err;
 345
 346         DMFE_DBUG(0, "dmfe_init_one()", 0);
 347
 348         if (!printed_version++)
 349                 printk(version);
 350
 351         /* Init network device */
 352         dev = alloc_etherdev(sizeof(*db));
 353         if (dev == NULL)
 354                 return -ENOMEM;
 355         SET_MODULE_OWNER(dev);
 356         SET_NETDEV_DEV(dev, &pdev->dev);
 357
 358         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
 359                 printk(KERN_WARNING DRV_NAME ": 32-bit PCI DMA not available.\n");
 360                 err = -ENODEV;
 361                 goto err_out_free;
 362         }
 363
 364         /* Enable Master/IO access, Disable memory access */
 365         err = pci_enable_device(pdev);
 366         if (err)
 367                 goto err_out_free;
 368
 369         if (!pci_resource_start(pdev, 0)) {
 370                 printk(KERN_ERR DRV_NAME ": I/O base is zero\n");
 371                 err = -ENODEV;
 372                 goto err_out_disable;
 373         }
 374
 375         /* Read Chip revision */
 376         pci_read_config_dword(pdev, PCI_REVISION_ID, &dev_rev);
 377
 378         if (pci_resource_len(pdev, 0) < (CHK_IO_SIZE(pdev, dev_rev)) ) {
 379                 printk(KERN_ERR DRV_NAME ": Allocated I/O size too small\n");
 380                 err = -ENODEV;
 381                 goto err_out_disable;
 382         }
 383
 384 #if 0   /* pci_{enable_device,set_master} sets minimum latency for us now */
 385
 386         /* Set Latency Timer 80h */
 387         /* FIXME: setting values > 32 breaks some SiS 559x stuff.
 388            Need a PCI quirk.. */
 389
 390         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
 391 #endif
 392
 393         if (pci_request_regions(pdev, DRV_NAME)) {
 394                 printk(KERN_ERR DRV_NAME ": Failed to request PCI regions\n");
 395                 err = -ENODEV;
 396                 goto err_out_disable;
 397         }
 398
 399         /* Init system & device */
 400         db = netdev_priv(dev);
 401
 402         db->dev = dev;
 403
 404         /* Allocate Tx/Rx descriptor memory */
 405         db->desc_pool_ptr = pci_alloc_consistent(pdev, sizeof(struct tx_desc) * DESC_ALL_CNT + 0x20, &db->desc_pool_dma_ptr);
 406         db->buf_pool_ptr = pci_alloc_consistent(pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4, &db->buf_pool_dma_ptr);
 407
 408         db->first_tx_desc = (struct tx_desc *) db->desc_pool_ptr;
 409         db->first_tx_desc_dma = db->desc_pool_dma_ptr;
 410         db->buf_pool_start = db->buf_pool_ptr;
 411         db->buf_pool_dma_start = db->buf_pool_dma_ptr;
 412
 413         db->chip_id = ent->driver_data;
 414         db->ioaddr = pci_resource_start(pdev, 0);
 415         db->chip_revision = dev_rev;
 416
 417         db->pdev = pdev;
 418
 419         dev->base_addr = db->ioaddr;
 420         dev->irq = pdev->irq;
 421         pci_set_drvdata(pdev, dev);
 422         dev->open = &dmfe_open;
 423         dev->hard_start_xmit = &dmfe_start_xmit;
 424         dev->stop = &dmfe_stop;
 425         dev->get_stats = &dmfe_get_stats;
 426         dev->set_multicast_list = &dmfe_set_filter_mode;
 427 #ifdef CONFIG_NET_POLL_CONTROLLER
 428         dev->poll_controller = &poll_dmfe;
 429 #endif
 430         dev->ethtool_ops = &netdev_ethtool_ops;
 431         netif_carrier_off(db->dev);
 432         spin_lock_init(&db->lock);
 433
 434         pci_read_config_dword(pdev, 0x50, &pci_pmr);
 435         pci_pmr &= 0x70000;
 436         if ( (pci_pmr == 0x10000) && (dev_rev == 0x02000031) )
 437                 db->chip_type = 1;      /* DM9102A E3 */
 438         else
 439                 db->chip_type = 0;
 440
 441         /* read 64 word srom data */
 442         for (i = 0; i < 64; i++)
 443                 ((u16 *) db->srom)[i] = cpu_to_le16(read_srom_word(db->ioaddr, i));
 444
 445         /* Set Node address */
 446         for (i = 0; i < 6; i++)
 447                 dev->dev_addr[i] = db->srom[20 + i];
 448
 449         err = register_netdev (dev);
 450         if (err)
 451                 goto err_out_res;
 452
 453         printk(KERN_INFO "%s: Davicom DM%04lx at pci%s,",
 454                 dev->name,
 455                 ent->driver_data >> 16,
 456                 pci_name(pdev));
 457         for (i = 0; i < 6; i++)
 458                 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
 459         printk(", irq %d.\n", dev->irq);
 460
 461         pci_set_master(pdev);
 462
 463         return 0;
 464
 465 err_out_res:
 466         pci_release_regions(pdev);
 467 err_out_disable:
 468         pci_disable_device(pdev);
 469 err_out_free:
 470         pci_set_drvdata(pdev, NULL);
 471         free_netdev(dev);
 472
 473         return err;
 474 }
 475
 476
 477 static void __devexit dmfe_remove_one (struct pci_dev *pdev)
 478 {
 479         struct net_device *dev = pci_get_drvdata(pdev);
 480         struct dmfe_board_info *db = netdev_priv(dev);
 481
 482         DMFE_DBUG(0, "dmfe_remove_one()", 0);
 483
 484         if (dev) {
 485                 pci_free_consistent(db->pdev, sizeof(struct tx_desc) *
 486                                         DESC_ALL_CNT + 0x20, db->desc_pool_ptr,
 487                                         db->desc_pool_dma_ptr);
 488                 pci_free_consistent(db->pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
 489                                         db->buf_pool_ptr, db->buf_pool_dma_ptr);
 490                 unregister_netdev(dev);
 491                 pci_release_regions(pdev);
 492                 free_netdev(dev);       /* free board information */
 493                 pci_set_drvdata(pdev, NULL);
 494         }
 495
 496         DMFE_DBUG(0, "dmfe_remove_one() exit", 0);
 497 }
 498
 499
 500 /*
 501  *      Open the interface.
 502  *      The interface is opened whenever "ifconfig" actives it.
 503  */
 504
 505 static int dmfe_open(struct DEVICE *dev)
 506 {
 507         int ret;
 508         struct dmfe_board_info *db = netdev_priv(dev);
 509
 510         DMFE_DBUG(0, "dmfe_open", 0);
 511
 512         ret = request_irq(dev->irq, &dmfe_interrupt, IRQF_SHARED, dev->name, dev);
 513         if (ret)
 514                 return ret;
 515
 516         /* system variable init */
 517         db->cr6_data = CR6_DEFAULT | dmfe_cr6_user_set;
 518         db->tx_packet_cnt = 0;
 519         db->tx_queue_cnt = 0;
 520         db->rx_avail_cnt = 0;
 521         db->link_failed = 1;
 522         db->wait_reset = 0;
 523
 524         db->first_in_callback = 0;
 525         db->NIC_capability = 0xf;       /* All capability*/
 526         db->PHY_reg4 = 0x1e0;
 527
 528         /* CR6 operation mode decision */
 529         if ( !chkmode || (db->chip_id == PCI_DM9132_ID) ||
 530                 (db->chip_revision >= 0x02000030) ) {
 531                 db->cr6_data |= DMFE_TXTH_256;
 532                 db->cr0_data = CR0_DEFAULT;
 533                 db->dm910x_chk_mode=4;          /* Enter the normal mode */
 534         } else {
 535                 db->cr6_data |= CR6_SFT;        /* Store & Forward mode */
 536                 db->cr0_data = 0;
 537                 db->dm910x_chk_mode = 1;        /* Enter the check mode */
 538         }
 539
 540         /* Initilize DM910X board */
 541         dmfe_init_dm910x(dev);
 542
 543         /* Active System Interface */
 544         netif_wake_queue(dev);
 545
 546         /* set and active a timer process */
 547         init_timer(&db->timer);
 548         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
 549         db->timer.data = (unsigned long)dev;
 550         db->timer.function = &dmfe_timer;
 551         add_timer(&db->timer);
 552
 553         return 0;
 554 }
 555
 556
 557 /*      Initilize DM910X board
 558  *      Reset DM910X board
 559  *      Initilize TX/Rx descriptor chain structure
 560  *      Send the set-up frame
 561  *      Enable Tx/Rx machine
 562  */
 563
 564 static void dmfe_init_dm910x(struct DEVICE *dev)
 565 {
 566         struct dmfe_board_info *db = netdev_priv(dev);
 567         unsigned long ioaddr = db->ioaddr;
 568
 569         DMFE_DBUG(0, "dmfe_init_dm910x()", 0);
 570
 571         /* Reset DM910x MAC controller */
 572         outl(DM910X_RESET, ioaddr + DCR0);      /* RESET MAC */
 573         udelay(100);
 574         outl(db->cr0_data, ioaddr + DCR0);
 575         udelay(5);
 576
 577         /* Phy addr : DM910(A)2/DM9132/9801, phy address = 1 */
 578         db->phy_addr = 1;
 579
 580         /* Parser SROM and media mode */
 581         dmfe_parse_srom(db);
 582         db->media_mode = dmfe_media_mode;
 583
 584         /* RESET Phyxcer Chip by GPR port bit 7 */
 585         outl(0x180, ioaddr + DCR12);            /* Let bit 7 output port */
 586         if (db->chip_id == PCI_DM9009_ID) {
 587                 outl(0x80, ioaddr + DCR12);     /* Issue RESET signal */
 588                 mdelay(300);                    /* Delay 300 ms */
 589         }
 590         outl(0x0, ioaddr + DCR12);      /* Clear RESET signal */
 591
 592         /* Process Phyxcer Media Mode */
 593         if ( !(db->media_mode & 0x10) ) /* Force 1M mode */
 594                 dmfe_set_phyxcer(db);
 595
 596         /* Media Mode Process */
 597         if ( !(db->media_mode & DMFE_AUTO) )
 598                 db->op_mode = db->media_mode;   /* Force Mode */
 599
 600         /* Initiliaze Transmit/Receive decriptor and CR3/4 */
 601         dmfe_descriptor_init(db, ioaddr);
 602
 603         /* Init CR6 to program DM910x operation */
 604         update_cr6(db->cr6_data, ioaddr);
 605
 606         /* Send setup frame */
 607         if (db->chip_id == PCI_DM9132_ID)
 608                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
 609         else
 610                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
 611
 612         /* Init CR7, interrupt active bit */
 613         db->cr7_data = CR7_DEFAULT;
 614         outl(db->cr7_data, ioaddr + DCR7);
 615
 616         /* Init CR15, Tx jabber and Rx watchdog timer */
 617         outl(db->cr15_data, ioaddr + DCR15);
 618
 619         /* Enable DM910X Tx/Rx function */
 620         db->cr6_data |= CR6_RXSC | CR6_TXSC | 0x40000;
 621         update_cr6(db->cr6_data, ioaddr);
 622 }
 623
 624
 625 /*
 626  *      Hardware start transmission.
 627  *      Send a packet to media from the upper layer.
 628  */
 629
 630 static int dmfe_start_xmit(struct sk_buff *skb, struct DEVICE *dev)
 631 {
 632         struct dmfe_board_info *db = netdev_priv(dev);
 633         struct tx_desc *txptr;
 634         unsigned long flags;
 635
 636         DMFE_DBUG(0, "dmfe_start_xmit", 0);
 637
 638         /* Resource flag check */
 639         netif_stop_queue(dev);
 640
 641         /* Too large packet check */
 642         if (skb->len > MAX_PACKET_SIZE) {
 643                 printk(KERN_ERR DRV_NAME ": big packet = %d\n", (u16)skb->len);
 644                 dev_kfree_skb(skb);
 645                 return 0;
 646         }
 647
 648         spin_lock_irqsave(&db->lock, flags);
 649
 650         /* No Tx resource check, it never happen nromally */
 651         if (db->tx_queue_cnt >= TX_FREE_DESC_CNT) {
 652                 spin_unlock_irqrestore(&db->lock, flags);
 653                 printk(KERN_ERR DRV_NAME ": No Tx resource %ld\n", db->tx_queue_cnt);
 654                 return 1;
 655         }
 656
 657         /* Disable NIC interrupt */
 658         outl(0, dev->base_addr + DCR7);
 659
 660         /* transmit this packet */
 661         txptr = db->tx_insert_ptr;
 662         memcpy(txptr->tx_buf_ptr, skb->data, skb->len);
 663         txptr->tdes1 = cpu_to_le32(0xe1000000 | skb->len);
 664
 665         /* Point to next transmit free descriptor */
 666         db->tx_insert_ptr = txptr->next_tx_desc;
 667
 668         /* Transmit Packet Process */
 669         if ( (!db->tx_queue_cnt) && (db->tx_packet_cnt < TX_MAX_SEND_CNT) ) {
 670                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 671                 db->tx_packet_cnt++;                    /* Ready to send */
 672                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 673                 dev->trans_start = jiffies;             /* saved time stamp */
 674         } else {
 675                 db->tx_queue_cnt++;                     /* queue TX packet */
 676                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 677         }
 678
 679         /* Tx resource check */
 680         if ( db->tx_queue_cnt < TX_FREE_DESC_CNT )
 681                 netif_wake_queue(dev);
 682
 683         /* Restore CR7 to enable interrupt */
 684         spin_unlock_irqrestore(&db->lock, flags);
 685         outl(db->cr7_data, dev->base_addr + DCR7);
 686
 687         /* free this SKB */
 688         dev_kfree_skb(skb);
 689
 690         return 0;
 691 }
 692
 693
 694 /*
 695  *      Stop the interface.
 696  *      The interface is stopped when it is brought.
 697  */
 698
 699 static int dmfe_stop(struct DEVICE *dev)
 700 {
 701         struct dmfe_board_info *db = netdev_priv(dev);
 702         unsigned long ioaddr = dev->base_addr;
 703
 704         DMFE_DBUG(0, "dmfe_stop", 0);
 705
 706         /* disable system */
 707         netif_stop_queue(dev);
 708
 709         /* deleted timer */
 710         del_timer_sync(&db->timer);
 711
 712         /* Reset & stop DM910X board */
 713         outl(DM910X_RESET, ioaddr + DCR0);
 714         udelay(5);
 715         phy_write(db->ioaddr, db->phy_addr, 0, 0x8000, db->chip_id);
 716
 717         /* free interrupt */
 718         free_irq(dev->irq, dev);
 719
 720         /* free allocated rx buffer */
 721         dmfe_free_rxbuffer(db);
 722
 723 #if 0
 724         /* show statistic counter */
 725         printk(DRV_NAME ": FU:%lx EC:%lx LC:%lx NC:%lx LOC:%lx TXJT:%lx RESET:%lx RCR8:%lx FAL:%lx TT:%lx\n",
 726                 db->tx_fifo_underrun, db->tx_excessive_collision,
 727                 db->tx_late_collision, db->tx_no_carrier, db->tx_loss_carrier,
 728                 db->tx_jabber_timeout, db->reset_count, db->reset_cr8,
 729                 db->reset_fatal, db->reset_TXtimeout);
 730 #endif
 731
 732         return 0;
 733 }
 734
 735
 736 /*
 737  *      DM9102 insterrupt handler
 738  *      receive the packet to upper layer, free the transmitted packet
 739  */
 740
 741 static irqreturn_t dmfe_interrupt(int irq, void *dev_id)
 742 {
 743         struct DEVICE *dev = dev_id;
 744         struct dmfe_board_info *db = netdev_priv(dev);
 745         unsigned long ioaddr = dev->base_addr;
 746         unsigned long flags;
 747
 748         DMFE_DBUG(0, "dmfe_interrupt()", 0);
 749
 750         spin_lock_irqsave(&db->lock, flags);
 751
 752         /* Got DM910X status */
 753         db->cr5_data = inl(ioaddr + DCR5);
 754         outl(db->cr5_data, ioaddr + DCR5);
 755         if ( !(db->cr5_data & 0xc1) ) {
 756                 spin_unlock_irqrestore(&db->lock, flags);
 757                 return IRQ_HANDLED;
 758         }
 759
 760         /* Disable all interrupt in CR7 to solve the interrupt edge problem */
 761         outl(0, ioaddr + DCR7);
 762
 763         /* Check system status */
 764         if (db->cr5_data & 0x2000) {
 765                 /* system bus error happen */
 766                 DMFE_DBUG(1, "System bus error happen. CR5=", db->cr5_data);
 767                 db->reset_fatal++;
 768                 db->wait_reset = 1;     /* Need to RESET */
 769                 spin_unlock_irqrestore(&db->lock, flags);
 770                 return IRQ_HANDLED;
 771         }
 772
 773          /* Received the coming packet */
 774         if ( (db->cr5_data & 0x40) && db->rx_avail_cnt )
 775                 dmfe_rx_packet(dev, db);
 776
 777         /* reallocate rx descriptor buffer */
 778         if (db->rx_avail_cnt<RX_DESC_CNT)
 779                 allocate_rx_buffer(db);
 780
 781         /* Free the transmitted descriptor */
 782         if ( db->cr5_data & 0x01)
 783                 dmfe_free_tx_pkt(dev, db);
 784
 785         /* Mode Check */
 786         if (db->dm910x_chk_mode & 0x2) {
 787                 db->dm910x_chk_mode = 0x4;
 788                 db->cr6_data |= 0x100;
 789                 update_cr6(db->cr6_data, db->ioaddr);
 790         }
 791
 792         /* Restore CR7 to enable interrupt mask */
 793         outl(db->cr7_data, ioaddr + DCR7);
 794
 795         spin_unlock_irqrestore(&db->lock, flags);
 796         return IRQ_HANDLED;
 797 }
 798
 799
 800 #ifdef CONFIG_NET_POLL_CONTROLLER
 801 /*
 802  * Polling 'interrupt' - used by things like netconsole to send skbs
 803  * without having to re-enable interrupts. It's not called while
 804  * the interrupt routine is executing.
 805  */
 806
 807 static void poll_dmfe (struct net_device *dev)
 808 {
 809         /* disable_irq here is not very nice, but with the lockless
 810            interrupt handler we have no other choice. */
 811         disable_irq(dev->irq);
 812         dmfe_interrupt (dev->irq, dev);
 813         enable_irq(dev->irq);
 814 }
 815 #endif
 816
 817 /*
 818  *      Free TX resource after TX complete
 819  */
 820
 821 static void dmfe_free_tx_pkt(struct DEVICE *dev, struct dmfe_board_info * db)
 822 {
 823         struct tx_desc *txptr;
 824         unsigned long ioaddr = dev->base_addr;
 825         u32 tdes0;
 826
 827         txptr = db->tx_remove_ptr;
 828         while(db->tx_packet_cnt) {
 829                 tdes0 = le32_to_cpu(txptr->tdes0);
 830                 /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 831                 if (tdes0 & 0x80000000)
 832                         break;
 833
 834                 /* A packet sent completed */
 835                 db->tx_packet_cnt--;
 836                 db->stats.tx_packets++;
 837
 838                 /* Transmit statistic counter */
 839                 if ( tdes0 != 0x7fffffff ) {
 840                         /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 841                         db->stats.collisions += (tdes0 >> 3) & 0xf;
 842                         db->stats.tx_bytes += le32_to_cpu(txptr->tdes1) & 0x7ff;
 843                         if (tdes0 & TDES0_ERR_MASK) {
 844                                 db->stats.tx_errors++;
 845
 846                                 if (tdes0 & 0x0002) {   /* UnderRun */
 847                                         db->tx_fifo_underrun++;
 848                                         if ( !(db->cr6_data & CR6_SFT) ) {
 849                                                 db->cr6_data = db->cr6_data | CR6_SFT;
 850                                                 update_cr6(db->cr6_data, db->ioaddr);
 851                                         }
 852                                 }
 853                                 if (tdes0 & 0x0100)
 854                                         db->tx_excessive_collision++;
 855                                 if (tdes0 & 0x0200)
 856                                         db->tx_late_collision++;
 857                                 if (tdes0 & 0x0400)
 858                                         db->tx_no_carrier++;
 859                                 if (tdes0 & 0x0800)
 860                                         db->tx_loss_carrier++;
 861                                 if (tdes0 & 0x4000)
 862                                         db->tx_jabber_timeout++;
 863                         }
 864                 }
 865
 866                 txptr = txptr->next_tx_desc;
 867         }/* End of while */
 868
 869         /* Update TX remove pointer to next */
 870         db->tx_remove_ptr = txptr;
 871
 872         /* Send the Tx packet in queue */
 873         if ( (db->tx_packet_cnt < TX_MAX_SEND_CNT) && db->tx_queue_cnt ) {
 874                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 875                 db->tx_packet_cnt++;                    /* Ready to send */
 876                 db->tx_queue_cnt--;
 877                 outl(0x1, ioaddr + DCR1);               /* Issue Tx polling */
 878                 dev->trans_start = jiffies;             /* saved time stamp */
 879         }
 880
 881         /* Resource available check */
 882         if ( db->tx_queue_cnt < TX_WAKE_DESC_CNT )
 883                 netif_wake_queue(dev);  /* Active upper layer, send again */
 884 }
 885
 886
 887 /*
 888  *      Calculate the CRC valude of the Rx packet
 889  *      flag =  1 : return the reverse CRC (for the received packet CRC)
 890  *              0 : return the normal CRC (for Hash Table index)
 891  */
 892
 893 static inline u32 cal_CRC(unsigned char * Data, unsigned int Len, u8 flag)
 894 {
 895         u32 crc = crc32(~0, Data, Len);
 896         if (flag) crc = ~crc;
 897         return crc;
 898 }
 899
 900
 901 /*
 902  *      Receive the come packet and pass to upper layer
 903  */
 904
 905 static void dmfe_rx_packet(struct DEVICE *dev, struct dmfe_board_info * db)
 906 {
 907         struct rx_desc *rxptr;
 908         struct sk_buff *skb;
 909         int rxlen;
 910         u32 rdes0;
 911
 912         rxptr = db->rx_ready_ptr;
 913
 914         while(db->rx_avail_cnt) {
 915                 rdes0 = le32_to_cpu(rxptr->rdes0);
 916                 if (rdes0 & 0x80000000) /* packet owner check */
 917                         break;
 918
 919                 db->rx_avail_cnt--;
 920                 db->interval_rx_cnt++;
 921
 922                 pci_unmap_single(db->pdev, le32_to_cpu(rxptr->rdes2), RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE);
 923                 if ( (rdes0 & 0x300) != 0x300) {
 924                         /* A packet without First/Last flag */
 925                         /* reuse this SKB */
 926                         DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
 927                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 928                 } else {
 929                         /* A packet with First/Last flag */
 930                         rxlen = ( (rdes0 >> 16) & 0x3fff) - 4;
 931
 932                         /* error summary bit check */
 933                         if (rdes0 & 0x8000) {
 934                                 /* This is a error packet */
 935                                 //printk(DRV_NAME ": rdes0: %lx\n", rdes0);
 936                                 db->stats.rx_errors++;
 937                                 if (rdes0 & 1)
 938                                         db->stats.rx_fifo_errors++;
 939                                 if (rdes0 & 2)
 940                                         db->stats.rx_crc_errors++;
 941                                 if (rdes0 & 0x80)
 942                                         db->stats.rx_length_errors++;
 943                         }
 944
 945                         if ( !(rdes0 & 0x8000) ||
 946                                 ((db->cr6_data & CR6_PM) && (rxlen>6)) ) {
 947                                 skb = rxptr->rx_skb_ptr;
 948
 949                                 /* Received Packet CRC check need or not */
 950                                 if ( (db->dm910x_chk_mode & 1) &&
 951                                         (cal_CRC(skb->data, rxlen, 1) !=
 952                                         (*(u32 *) (skb->data+rxlen) ))) { /* FIXME (?) */
 953                                         /* Found a error received packet */
 954                                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 955                                         db->dm910x_chk_mode = 3;
 956                                 } else {
 957                                         /* Good packet, send to upper layer */
 958                                         /* Shorst packet used new SKB */
 959                                         if ( (rxlen < RX_COPY_SIZE) &&
 960                                                 ( (skb = dev_alloc_skb(rxlen + 2) )
 961                                                 != NULL) ) {
 962                                                 /* size less than COPY_SIZE, allocate a rxlen SKB */
 963                                                 skb->dev = dev;
 964                                                 skb_reserve(skb, 2); /* 16byte align */
 965                                                 memcpy(skb_put(skb, rxlen), rxptr->rx_skb_ptr->data, rxlen);
 966                                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 967                                         } else {
 968                                                 skb->dev = dev;
 969                                                 skb_put(skb, rxlen);
 970                                         }
 971                                         skb->protocol = eth_type_trans(skb, dev);
 972                                         netif_rx(skb);
 973                                         dev->last_rx = jiffies;
 974                                         db->stats.rx_packets++;
 975                                         db->stats.rx_bytes += rxlen;
 976                                 }
 977                         } else {
 978                                 /* Reuse SKB buffer when the packet is error */
 979                                 DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
 980                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 981                         }
 982                 }
 983
 984                 rxptr = rxptr->next_rx_desc;
 985         }
 986
 987         db->rx_ready_ptr = rxptr;
 988 }
 989
 990
 991 /*
 992  *      Get statistics from driver.
 993  */
 994
 995 static struct net_device_stats * dmfe_get_stats(struct DEVICE *dev)
 996 {
 997         struct dmfe_board_info *db = netdev_priv(dev);
 998
 999         DMFE_DBUG(0, "dmfe_get_stats", 0);
1000         return &db->stats;
1001 }
1002
1003
1004 /*
1005  * Set DM910X multicast address
1006  */
1007
1008 static void dmfe_set_filter_mode(struct DEVICE * dev)
1009 {
1010         struct dmfe_board_info *db = netdev_priv(dev);
1011         unsigned long flags;
1012
1013         DMFE_DBUG(0, "dmfe_set_filter_mode()", 0);
1014         spin_lock_irqsave(&db->lock, flags);
1015
1016         if (dev->flags & IFF_PROMISC) {
1017                 DMFE_DBUG(0, "Enable PROM Mode", 0);
1018                 db->cr6_data |= CR6_PM | CR6_PBF;
1019                 update_cr6(db->cr6_data, db->ioaddr);
1020                 spin_unlock_irqrestore(&db->lock, flags);
1021                 return;
1022         }
1023
1024         if (dev->flags & IFF_ALLMULTI || dev->mc_count > DMFE_MAX_MULTICAST) {
1025                 DMFE_DBUG(0, "Pass all multicast address", dev->mc_count);
1026                 db->cr6_data &= ~(CR6_PM | CR6_PBF);
1027                 db->cr6_data |= CR6_PAM;
1028                 spin_unlock_irqrestore(&db->lock, flags);
1029                 return;
1030         }
1031
1032         DMFE_DBUG(0, "Set multicast address", dev->mc_count);
1033         if (db->chip_id == PCI_DM9132_ID)
1034                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
1035         else
1036                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
1037         spin_unlock_irqrestore(&db->lock, flags);
1038 }
1039
1040 static void netdev_get_drvinfo(struct net_device *dev,
1041                                struct ethtool_drvinfo *info)
1042 {
1043         struct dmfe_board_info *np = netdev_priv(dev);
1044
1045         strcpy(info->driver, DRV_NAME);
1046         strcpy(info->version, DRV_VERSION);
1047         if (np->pdev)
1048                 strcpy(info->bus_info, pci_name(np->pdev));
1049         else
1050                 sprintf(info->bus_info, "EISA 0x%lx %d",
1051                         dev->base_addr, dev->irq);
1052 }
1053
1054 static const struct ethtool_ops netdev_ethtool_ops = {
1055         .get_drvinfo            = netdev_get_drvinfo,
1056         .get_link               = ethtool_op_get_link,
1057 };
1058
1059 /*
1060  *      A periodic timer routine
1061  *      Dynamic media sense, allocate Rx buffer...
1062  */
1063
1064 static void dmfe_timer(unsigned long data)
1065 {
1066         u32 tmp_cr8;
1067         unsigned char tmp_cr12;
1068         struct DEVICE *dev = (struct DEVICE *) data;
1069         struct dmfe_board_info *db = netdev_priv(dev);
1070         unsigned long flags;
1071
1072         DMFE_DBUG(0, "dmfe_timer()", 0);
1073         spin_lock_irqsave(&db->lock, flags);
1074
1075         /* Media mode process when Link OK before enter this route */
1076         if (db->first_in_callback == 0) {
1077                 db->first_in_callback = 1;
1078                 if (db->chip_type && (db->chip_id==PCI_DM9102_ID)) {
1079                         db->cr6_data &= ~0x40000;
1080                         update_cr6(db->cr6_data, db->ioaddr);
1081                         phy_write(db->ioaddr, db->phy_addr, 0, 0x1000, db->chip_id);
1082                         db->cr6_data |= 0x40000;
1083                         update_cr6(db->cr6_data, db->ioaddr);
1084                         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
1085                         add_timer(&db->timer);
1086                         spin_unlock_irqrestore(&db->lock, flags);
1087                         return;
1088                 }
1089         }
1090
1091
1092         /* Operating Mode Check */
1093         if ( (db->dm910x_chk_mode & 0x1) &&
1094                 (db->stats.rx_packets > MAX_CHECK_PACKET) )
1095                 db->dm910x_chk_mode = 0x4;
1096
1097         /* Dynamic reset DM910X : system error or transmit time-out */
1098         tmp_cr8 = inl(db->ioaddr + DCR8);
1099         if ( (db->interval_rx_cnt==0) && (tmp_cr8) ) {
1100                 db->reset_cr8++;
1101                 db->wait_reset = 1;
1102         }
1103         db->interval_rx_cnt = 0;
1104
1105         /* TX polling kick monitor */
1106         if ( db->tx_packet_cnt &&
1107              time_after(jiffies, dev->trans_start + DMFE_TX_KICK) ) {
1108                 outl(0x1, dev->base_addr + DCR1);   /* Tx polling again */
1109
1110                 /* TX Timeout */
1111                 if ( time_after(jiffies, dev->trans_start + DMFE_TX_TIMEOUT) ) {
1112                         db->reset_TXtimeout++;
1113                         db->wait_reset = 1;
1114                         printk(KERN_WARNING "%s: Tx timeout - resetting\n",
1115                                dev->name);
1116                 }
1117         }
1118
1119         if (db->wait_reset) {
1120                 DMFE_DBUG(0, "Dynamic Reset device", db->tx_packet_cnt);
1121                 db->reset_count++;
1122                 dmfe_dynamic_reset(dev);
1123                 db->first_in_callback = 0;
1124                 db->timer.expires = DMFE_TIMER_WUT;
1125                 add_timer(&db->timer);
1126                 spin_unlock_irqrestore(&db->lock, flags);
1127                 return;
1128         }
1129
1130         /* Link status check, Dynamic media type change */
1131         if (db->chip_id == PCI_DM9132_ID)
1132                 tmp_cr12 = inb(db->ioaddr + DCR9 + 3);  /* DM9132 */
1133         else
1134                 tmp_cr12 = inb(db->ioaddr + DCR12);     /* DM9102/DM9102A */
1135
1136         if ( ((db->chip_id == PCI_DM9102_ID) &&
1137                 (db->chip_revision == 0x02000030)) ||
1138                 ((db->chip_id == PCI_DM9132_ID) &&
1139                 (db->chip_revision == 0x02000010)) ) {
1140                 /* DM9102A Chip */
1141                 if (tmp_cr12 & 2)
1142                         tmp_cr12 = 0x0;         /* Link failed */
1143                 else
1144                         tmp_cr12 = 0x3; /* Link OK */
1145         }
1146
1147         if ( !(tmp_cr12 & 0x3) && !db->link_failed ) {
1148                 /* Link Failed */
1149                 DMFE_DBUG(0, "Link Failed", tmp_cr12);
1150                 db->link_failed = 1;
1151                 netif_carrier_off(db->dev);
1152
1153                 /* For Force 10/100M Half/Full mode: Enable Auto-Nego mode */
1154                 /* AUTO or force 1M Homerun/Longrun don't need */
1155                 if ( !(db->media_mode & 0x38) )
1156                         phy_write(db->ioaddr, db->phy_addr, 0, 0x1000, db->chip_id);
1157
1158                 /* AUTO mode, if INT phyxcer link failed, select EXT device */
1159                 if (db->media_mode & DMFE_AUTO) {
1160                         /* 10/100M link failed, used 1M Home-Net */
1161                         db->cr6_data|=0x00040000;       /* bit18=1, MII */
1162                         db->cr6_data&=~0x00000200;      /* bit9=0, HD mode */
1163                         update_cr6(db->cr6_data, db->ioaddr);
1164                 }
1165         } else
1166                 if ((tmp_cr12 & 0x3) && db->link_failed) {
1167                         DMFE_DBUG(0, "Link link OK", tmp_cr12);
1168                         db->link_failed = 0;
1169
1170                         /* Auto Sense Speed */
1171                         if ( (db->media_mode & DMFE_AUTO) &&
1172                                 dmfe_sense_speed(db) )
1173                                 db->link_failed = 1;
1174                         else
1175                                 netif_carrier_on(db->dev);
1176                         dmfe_process_mode(db);
1177                         /* SHOW_MEDIA_TYPE(db->op_mode); */
1178                 }
1179
1180         /* HPNA remote command check */
1181         if (db->HPNA_command & 0xf00) {
1182                 db->HPNA_timer--;
1183                 if (!db->HPNA_timer)
1184                         dmfe_HPNA_remote_cmd_chk(db);
1185         }
1186
1187         /* Timer active again */
1188         db->timer.expires = DMFE_TIMER_WUT;
1189         add_timer(&db->timer);
1190         spin_unlock_irqrestore(&db->lock, flags);
1191 }
1192
1193
1194 /*
1195  *      Dynamic reset the DM910X board
1196  *      Stop DM910X board
1197  *      Free Tx/Rx allocated memory
1198  *      Reset DM910X board
1199  *      Re-initilize DM910X board
1200  */
1201
1202 static void dmfe_dynamic_reset(struct DEVICE *dev)
1203 {
1204         struct dmfe_board_info *db = netdev_priv(dev);
1205
1206         DMFE_DBUG(0, "dmfe_dynamic_reset()", 0);
1207
1208         /* Sopt MAC controller */
1209         db->cr6_data &= ~(CR6_RXSC | CR6_TXSC); /* Disable Tx/Rx */
1210         update_cr6(db->cr6_data, dev->base_addr);
1211         outl(0, dev->base_addr + DCR7);         /* Disable Interrupt */
1212         outl(inl(dev->base_addr + DCR5), dev->base_addr + DCR5);
1213
1214         /* Disable upper layer interface */
1215         netif_stop_queue(dev);
1216
1217         /* Free Rx Allocate buffer */
1218         dmfe_free_rxbuffer(db);
1219
1220         /* system variable init */
1221         db->tx_packet_cnt = 0;
1222         db->tx_queue_cnt = 0;
1223         db->rx_avail_cnt = 0;
1224         db->link_failed = 1;
1225         db->wait_reset = 0;
1226
1227         /* Re-initilize DM910X board */
1228         dmfe_init_dm910x(dev);
1229
1230         /* Restart upper layer interface */
1231         netif_wake_queue(dev);
1232 }
1233
1234
1235 /*
1236  *      free all allocated rx buffer
1237  */
1238
1239 static void dmfe_free_rxbuffer(struct dmfe_board_info * db)
1240 {
1241         DMFE_DBUG(0, "dmfe_free_rxbuffer()", 0);
1242
1243         /* free allocated rx buffer */
1244         while (db->rx_avail_cnt) {
1245                 dev_kfree_skb(db->rx_ready_ptr->rx_skb_ptr);
1246                 db->rx_ready_ptr = db->rx_ready_ptr->next_rx_desc;
1247                 db->rx_avail_cnt--;
1248         }
1249 }
1250
1251
1252 /*
1253  *      Reuse the SK buffer
1254  */
1255
1256 static void dmfe_reuse_skb(struct dmfe_board_info *db, struct sk_buff * skb)
1257 {
1258         struct rx_desc *rxptr = db->rx_insert_ptr;
1259
1260         if (!(rxptr->rdes0 & cpu_to_le32(0x80000000))) {
1261                 rxptr->rx_skb_ptr = skb;
1262                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->data, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1263                 wmb();
1264                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1265                 db->rx_avail_cnt++;
1266                 db->rx_insert_ptr = rxptr->next_rx_desc;
1267         } else
1268                 DMFE_DBUG(0, "SK Buffer reuse method error", db->rx_avail_cnt);
1269 }
1270
1271
1272 /*
1273  *      Initialize transmit/Receive descriptor
1274  *      Using Chain structure, and allocate Tx/Rx buffer
1275  */
1276
1277 static void dmfe_descriptor_init(struct dmfe_board_info *db, unsigned long ioaddr)
1278 {
1279         struct tx_desc *tmp_tx;
1280         struct rx_desc *tmp_rx;
1281         unsigned char *tmp_buf;
1282         dma_addr_t tmp_tx_dma, tmp_rx_dma;
1283         dma_addr_t tmp_buf_dma;
1284         int i;
1285
1286         DMFE_DBUG(0, "dmfe_descriptor_init()", 0);
1287
1288         /* tx descriptor start pointer */
1289         db->tx_insert_ptr = db->first_tx_desc;
1290         db->tx_remove_ptr = db->first_tx_desc;
1291         outl(db->first_tx_desc_dma, ioaddr + DCR4);     /* TX DESC address */
1292
1293         /* rx descriptor start pointer */
1294         db->first_rx_desc = (void *)db->first_tx_desc + sizeof(struct tx_desc) * TX_DESC_CNT;
1295         db->first_rx_desc_dma =  db->first_tx_desc_dma + sizeof(struct tx_desc) * TX_DESC_CNT;
1296         db->rx_insert_ptr = db->first_rx_desc;
1297         db->rx_ready_ptr = db->first_rx_desc;
1298         outl(db->first_rx_desc_dma, ioaddr + DCR3);     /* RX DESC address */
1299
1300         /* Init Transmit chain */
1301         tmp_buf = db->buf_pool_start;
1302         tmp_buf_dma = db->buf_pool_dma_start;
1303         tmp_tx_dma = db->first_tx_desc_dma;
1304         for (tmp_tx = db->first_tx_desc, i = 0; i < TX_DESC_CNT; i++, tmp_tx++) {
1305                 tmp_tx->tx_buf_ptr = tmp_buf;
1306                 tmp_tx->tdes0 = cpu_to_le32(0);
1307                 tmp_tx->tdes1 = cpu_to_le32(0x81000000);        /* IC, chain */
1308                 tmp_tx->tdes2 = cpu_to_le32(tmp_buf_dma);
1309                 tmp_tx_dma += sizeof(struct tx_desc);
1310                 tmp_tx->tdes3 = cpu_to_le32(tmp_tx_dma);
1311                 tmp_tx->next_tx_desc = tmp_tx + 1;
1312                 tmp_buf = tmp_buf + TX_BUF_ALLOC;
1313                 tmp_buf_dma = tmp_buf_dma + TX_BUF_ALLOC;
1314         }
1315         (--tmp_tx)->tdes3 = cpu_to_le32(db->first_tx_desc_dma);
1316         tmp_tx->next_tx_desc = db->first_tx_desc;
1317
1318          /* Init Receive descriptor chain */
1319         tmp_rx_dma=db->first_rx_desc_dma;
1320         for (tmp_rx = db->first_rx_desc, i = 0; i < RX_DESC_CNT; i++, tmp_rx++) {
1321                 tmp_rx->rdes0 = cpu_to_le32(0);
1322                 tmp_rx->rdes1 = cpu_to_le32(0x01000600);
1323                 tmp_rx_dma += sizeof(struct rx_desc);
1324                 tmp_rx->rdes3 = cpu_to_le32(tmp_rx_dma);
1325                 tmp_rx->next_rx_desc = tmp_rx + 1;
1326         }
1327         (--tmp_rx)->rdes3 = cpu_to_le32(db->first_rx_desc_dma);
1328         tmp_rx->next_rx_desc = db->first_rx_desc;
1329
1330         /* pre-allocate Rx buffer */
1331         allocate_rx_buffer(db);
1332 }
1333
1334
1335 /*
1336  *      Update CR6 value
1337  *      Firstly stop DM910X , then written value and start
1338  */
1339
1340 static void update_cr6(u32 cr6_data, unsigned long ioaddr)
1341 {
1342         u32 cr6_tmp;
1343
1344         cr6_tmp = cr6_data & ~0x2002;           /* stop Tx/Rx */
1345         outl(cr6_tmp, ioaddr + DCR6);
1346         udelay(5);
1347         outl(cr6_data, ioaddr + DCR6);
1348         udelay(5);
1349 }
1350
1351
1352 /*
1353  *      Send a setup frame for DM9132
1354  *      This setup frame initilize DM910X address filter mode
1355 */
1356
1357 static void dm9132_id_table(struct DEVICE *dev, int mc_cnt)
1358 {
1359         struct dev_mc_list *mcptr;
1360         u16 * addrptr;
1361         unsigned long ioaddr = dev->base_addr+0xc0;             /* ID Table */
1362         u32 hash_val;
1363         u16 i, hash_table[4];
1364
1365         DMFE_DBUG(0, "dm9132_id_table()", 0);
1366
1367         /* Node address */
1368         addrptr = (u16 *) dev->dev_addr;
1369         outw(addrptr[0], ioaddr);
1370         ioaddr += 4;
1371         outw(addrptr[1], ioaddr);
1372         ioaddr += 4;
1373         outw(addrptr[2], ioaddr);
1374         ioaddr += 4;
1375
1376         /* Clear Hash Table */
1377         for (i = 0; i < 4; i++)
1378                 hash_table[i] = 0x0;
1379
1380         /* broadcast address */
1381         hash_table[3] = 0x8000;
1382
1383         /* the multicast address in Hash Table : 64 bits */
1384         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1385                 hash_val = cal_CRC( (char *) mcptr->dmi_addr, 6, 0) & 0x3f;
1386                 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
1387         }
1388
1389         /* Write the hash table to MAC MD table */
1390         for (i = 0; i < 4; i++, ioaddr += 4)
1391                 outw(hash_table[i], ioaddr);
1392 }
1393
1394
1395 /*
1396  *      Send a setup frame for DM9102/DM9102A
1397  *      This setup frame initilize DM910X address filter mode
1398  */
1399
1400 static void send_filter_frame(struct DEVICE *dev, int mc_cnt)
1401 {
1402         struct dmfe_board_info *db = netdev_priv(dev);
1403         struct dev_mc_list *mcptr;
1404         struct tx_desc *txptr;
1405         u16 * addrptr;
1406         u32 * suptr;
1407         int i;
1408
1409         DMFE_DBUG(0, "send_filter_frame()", 0);
1410
1411         txptr = db->tx_insert_ptr;
1412         suptr = (u32 *) txptr->tx_buf_ptr;
1413
1414         /* Node address */
1415         addrptr = (u16 *) dev->dev_addr;
1416         *suptr++ = addrptr[0];
1417         *suptr++ = addrptr[1];
1418         *suptr++ = addrptr[2];
1419
1420         /* broadcast address */
1421         *suptr++ = 0xffff;
1422         *suptr++ = 0xffff;
1423         *suptr++ = 0xffff;
1424
1425         /* fit the multicast address */
1426         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1427                 addrptr = (u16 *) mcptr->dmi_addr;
1428                 *suptr++ = addrptr[0];
1429                 *suptr++ = addrptr[1];
1430                 *suptr++ = addrptr[2];
1431         }
1432
1433         for (; i<14; i++) {
1434                 *suptr++ = 0xffff;
1435                 *suptr++ = 0xffff;
1436                 *suptr++ = 0xffff;
1437         }
1438
1439         /* prepare the setup frame */
1440         db->tx_insert_ptr = txptr->next_tx_desc;
1441         txptr->tdes1 = cpu_to_le32(0x890000c0);
1442
1443         /* Resource Check and Send the setup packet */
1444         if (!db->tx_packet_cnt) {
1445                 /* Resource Empty */
1446                 db->tx_packet_cnt++;
1447                 txptr->tdes0 = cpu_to_le32(0x80000000);
1448                 update_cr6(db->cr6_data | 0x2000, dev->base_addr);
1449                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
1450                 update_cr6(db->cr6_data, dev->base_addr);
1451                 dev->trans_start = jiffies;
1452         } else
1453                 db->tx_queue_cnt++;     /* Put in TX queue */
1454 }
1455
1456
1457 /*
1458  *      Allocate rx buffer,
1459  *      As possible as allocate maxiumn Rx buffer
1460  */
1461
1462 static void allocate_rx_buffer(struct dmfe_board_info *db)
1463 {
1464         struct rx_desc *rxptr;
1465         struct sk_buff *skb;
1466
1467         rxptr = db->rx_insert_ptr;
1468
1469         while(db->rx_avail_cnt < RX_DESC_CNT) {
1470                 if ( ( skb = dev_alloc_skb(RX_ALLOC_SIZE) ) == NULL )
1471                         break;
1472                 rxptr->rx_skb_ptr = skb; /* FIXME (?) */
1473                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->data, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1474                 wmb();
1475                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1476                 rxptr = rxptr->next_rx_desc;
1477                 db->rx_avail_cnt++;
1478         }
1479
1480         db->rx_insert_ptr = rxptr;
1481 }
1482
1483
1484 /*
1485  *      Read one word data from the serial ROM
1486  */
1487
1488 static u16 read_srom_word(long ioaddr, int offset)
1489 {
1490         int i;
1491         u16 srom_data = 0;
1492         long cr9_ioaddr = ioaddr + DCR9;
1493
1494         outl(CR9_SROM_READ, cr9_ioaddr);
1495         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1496
1497         /* Send the Read Command 110b */
1498         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1499         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1500         SROM_CLK_WRITE(SROM_DATA_0, cr9_ioaddr);
1501
1502         /* Send the offset */
1503         for (i = 5; i >= 0; i--) {
1504                 srom_data = (offset & (1 << i)) ? SROM_DATA_1 : SROM_DATA_0;
1505                 SROM_CLK_WRITE(srom_data, cr9_ioaddr);
1506         }
1507
1508         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1509
1510         for (i = 16; i > 0; i--) {
1511                 outl(CR9_SROM_READ | CR9_SRCS | CR9_SRCLK, cr9_ioaddr);
1512                 udelay(5);
1513                 srom_data = (srom_data << 1) | ((inl(cr9_ioaddr) & CR9_CRDOUT) ? 1 : 0);
1514                 outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1515                 udelay(5);
1516         }
1517
1518         outl(CR9_SROM_READ, cr9_ioaddr);
1519         return srom_data;
1520 }
1521
1522
1523 /*
1524  *      Auto sense the media mode
1525  */
1526
1527 static u8 dmfe_sense_speed(struct dmfe_board_info * db)
1528 {
1529         u8 ErrFlag = 0;
1530         u16 phy_mode;
1531
1532         /* CR6 bit18=0, select 10/100M */
1533         update_cr6( (db->cr6_data & ~0x40000), db->ioaddr);
1534
1535         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1536         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1537
1538         if ( (phy_mode & 0x24) == 0x24 ) {
1539                 if (db->chip_id == PCI_DM9132_ID)       /* DM9132 */
1540                         phy_mode = phy_read(db->ioaddr, db->phy_addr, 7, db->chip_id) & 0xf000;
1541                 else                            /* DM9102/DM9102A */
1542                         phy_mode = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0xf000;
1543                 /* printk(DRV_NAME ": Phy_mode %x ",phy_mode); */
1544                 switch (phy_mode) {
1545                 case 0x1000: db->op_mode = DMFE_10MHF; break;
1546                 case 0x2000: db->op_mode = DMFE_10MFD; break;
1547                 case 0x4000: db->op_mode = DMFE_100MHF; break;
1548                 case 0x8000: db->op_mode = DMFE_100MFD; break;
1549                 default: db->op_mode = DMFE_10MHF;
1550                         ErrFlag = 1;
1551                         break;
1552                 }
1553         } else {
1554                 db->op_mode = DMFE_10MHF;
1555                 DMFE_DBUG(0, "Link Failed :", phy_mode);
1556                 ErrFlag = 1;
1557         }
1558
1559         return ErrFlag;
1560 }
1561
1562
1563 /*
1564  *      Set 10/100 phyxcer capability
1565  *      AUTO mode : phyxcer register4 is NIC capability
1566  *      Force mode: phyxcer register4 is the force media
1567  */
1568
1569 static void dmfe_set_phyxcer(struct dmfe_board_info *db)
1570 {
1571         u16 phy_reg;
1572
1573         /* Select 10/100M phyxcer */
1574         db->cr6_data &= ~0x40000;
1575         update_cr6(db->cr6_data, db->ioaddr);
1576
1577         /* DM9009 Chip: Phyxcer reg18 bit12=0 */
1578         if (db->chip_id == PCI_DM9009_ID) {
1579                 phy_reg = phy_read(db->ioaddr, db->phy_addr, 18, db->chip_id) & ~0x1000;
1580                 phy_write(db->ioaddr, db->phy_addr, 18, phy_reg, db->chip_id);
1581         }
1582
1583         /* Phyxcer capability setting */
1584         phy_reg = phy_read(db->ioaddr, db->phy_addr, 4, db->chip_id) & ~0x01e0;
1585
1586         if (db->media_mode & DMFE_AUTO) {
1587                 /* AUTO Mode */
1588                 phy_reg |= db->PHY_reg4;
1589         } else {
1590                 /* Force Mode */
1591                 switch(db->media_mode) {
1592                 case DMFE_10MHF: phy_reg |= 0x20; break;
1593                 case DMFE_10MFD: phy_reg |= 0x40; break;
1594                 case DMFE_100MHF: phy_reg |= 0x80; break;
1595                 case DMFE_100MFD: phy_reg |= 0x100; break;
1596                 }
1597                 if (db->chip_id == PCI_DM9009_ID) phy_reg &= 0x61;
1598         }
1599
1600         /* Write new capability to Phyxcer Reg4 */
1601         if ( !(phy_reg & 0x01e0)) {
1602                 phy_reg|=db->PHY_reg4;
1603                 db->media_mode|=DMFE_AUTO;
1604         }
1605         phy_write(db->ioaddr, db->phy_addr, 4, phy_reg, db->chip_id);
1606
1607         /* Restart Auto-Negotiation */
1608         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1609                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1800, db->chip_id);
1610         if ( !db->chip_type )
1611                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1200, db->chip_id);
1612 }
1613
1614
1615 /*
1616  *      Process op-mode
1617  *      AUTO mode : PHY controller in Auto-negotiation Mode
1618  *      Force mode: PHY controller in force mode with HUB
1619  *                      N-way force capability with SWITCH
1620  */
1621
1622 static void dmfe_process_mode(struct dmfe_board_info *db)
1623 {
1624         u16 phy_reg;
1625
1626         /* Full Duplex Mode Check */
1627         if (db->op_mode & 0x4)
1628                 db->cr6_data |= CR6_FDM;        /* Set Full Duplex Bit */
1629         else
1630                 db->cr6_data &= ~CR6_FDM;       /* Clear Full Duplex Bit */
1631
1632         /* Transciver Selection */
1633         if (db->op_mode & 0x10)         /* 1M HomePNA */
1634                 db->cr6_data |= 0x40000;/* External MII select */
1635         else
1636                 db->cr6_data &= ~0x40000;/* Internal 10/100 transciver */
1637
1638         update_cr6(db->cr6_data, db->ioaddr);
1639
1640         /* 10/100M phyxcer force mode need */
1641         if ( !(db->media_mode & 0x18)) {
1642                 /* Forece Mode */
1643                 phy_reg = phy_read(db->ioaddr, db->phy_addr, 6, db->chip_id);
1644                 if ( !(phy_reg & 0x1) ) {
1645                         /* parter without N-Way capability */
1646                         phy_reg = 0x0;
1647                         switch(db->op_mode) {
1648                         case DMFE_10MHF: phy_reg = 0x0; break;
1649                         case DMFE_10MFD: phy_reg = 0x100; break;
1650                         case DMFE_100MHF: phy_reg = 0x2000; break;
1651                         case DMFE_100MFD: phy_reg = 0x2100; break;
1652                         }
1653                         phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
1654                         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1655                                 mdelay(20);
1656                         phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
1657                 }
1658         }
1659 }
1660
1661
1662 /*
1663  *      Write a word to Phy register
1664  */
1665
1666 static void phy_write(unsigned long iobase, u8 phy_addr, u8 offset, u16 phy_data, u32 chip_id)
1667 {
1668         u16 i;
1669         unsigned long ioaddr;
1670
1671         if (chip_id == PCI_DM9132_ID) {
1672                 ioaddr = iobase + 0x80 + offset * 4;
1673                 outw(phy_data, ioaddr);
1674         } else {
1675                 /* DM9102/DM9102A Chip */
1676                 ioaddr = iobase + DCR9;
1677
1678                 /* Send 33 synchronization clock to Phy controller */
1679                 for (i = 0; i < 35; i++)
1680                         phy_write_1bit(ioaddr, PHY_DATA_1);
1681
1682                 /* Send start command(01) to Phy */
1683                 phy_write_1bit(ioaddr, PHY_DATA_0);
1684                 phy_write_1bit(ioaddr, PHY_DATA_1);
1685
1686                 /* Send write command(01) to Phy */
1687                 phy_write_1bit(ioaddr, PHY_DATA_0);
1688                 phy_write_1bit(ioaddr, PHY_DATA_1);
1689
1690                 /* Send Phy address */
1691                 for (i = 0x10; i > 0; i = i >> 1)
1692                         phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1693
1694                 /* Send register address */
1695                 for (i = 0x10; i > 0; i = i >> 1)
1696                         phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
1697
1698                 /* written trasnition */
1699                 phy_write_1bit(ioaddr, PHY_DATA_1);
1700                 phy_write_1bit(ioaddr, PHY_DATA_0);
1701
1702                 /* Write a word data to PHY controller */
1703                 for ( i = 0x8000; i > 0; i >>= 1)
1704                         phy_write_1bit(ioaddr, phy_data & i ? PHY_DATA_1 : PHY_DATA_0);
1705         }
1706 }
1707
1708
1709 /*
1710  *      Read a word data from phy register
1711  */
1712
1713 static u16 phy_read(unsigned long iobase, u8 phy_addr, u8 offset, u32 chip_id)
1714 {
1715         int i;
1716         u16 phy_data;
1717         unsigned long ioaddr;
1718
1719         if (chip_id == PCI_DM9132_ID) {
1720                 /* DM9132 Chip */
1721                 ioaddr = iobase + 0x80 + offset * 4;
1722                 phy_data = inw(ioaddr);
1723         } else {
1724                 /* DM9102/DM9102A Chip */
1725                 ioaddr = iobase + DCR9;
1726
1727                 /* Send 33 synchronization clock to Phy controller */
1728                 for (i = 0; i < 35; i++)
1729                         phy_write_1bit(ioaddr, PHY_DATA_1);
1730
1731                 /* Send start command(01) to Phy */
1732                 phy_write_1bit(ioaddr, PHY_DATA_0);
1733                 phy_write_1bit(ioaddr, PHY_DATA_1);
1734
1735                 /* Send read command(10) to Phy */
1736                 phy_write_1bit(ioaddr, PHY_DATA_1);
1737                 phy_write_1bit(ioaddr, PHY_DATA_0);
1738
1739                 /* Send Phy address */
1740                 for (i = 0x10; i > 0; i = i >> 1)
1741                         phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1742
1743                 /* Send register address */
1744                 for (i = 0x10; i > 0; i = i >> 1)
1745                         phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
1746
1747                 /* Skip transition state */
1748                 phy_read_1bit(ioaddr);
1749
1750                 /* read 16bit data */
1751                 for (phy_data = 0, i = 0; i < 16; i++) {
1752                         phy_data <<= 1;
1753                         phy_data |= phy_read_1bit(ioaddr);
1754                 }
1755         }
1756
1757         return phy_data;
1758 }
1759
1760
1761 /*
1762  *      Write one bit data to Phy Controller
1763  */
1764
1765 static void phy_write_1bit(unsigned long ioaddr, u32 phy_data)
1766 {
1767         outl(phy_data, ioaddr);                 /* MII Clock Low */
1768         udelay(1);
1769         outl(phy_data | MDCLKH, ioaddr);        /* MII Clock High */
1770         udelay(1);
1771         outl(phy_data, ioaddr);                 /* MII Clock Low */
1772         udelay(1);
1773 }
1774
1775
1776 /*
1777  *      Read one bit phy data from PHY controller
1778  */
1779
1780 static u16 phy_read_1bit(unsigned long ioaddr)
1781 {
1782         u16 phy_data;
1783
1784         outl(0x50000, ioaddr);
1785         udelay(1);
1786         phy_data = ( inl(ioaddr) >> 19 ) & 0x1;
1787         outl(0x40000, ioaddr);
1788         udelay(1);
1789
1790         return phy_data;
1791 }
1792
1793
1794 /*
1795  *      Parser SROM and media mode
1796  */
1797
1798 static void dmfe_parse_srom(struct dmfe_board_info * db)
1799 {
1800         char * srom = db->srom;
1801         int dmfe_mode, tmp_reg;
1802
1803         DMFE_DBUG(0, "dmfe_parse_srom() ", 0);
1804
1805         /* Init CR15 */
1806         db->cr15_data = CR15_DEFAULT;
1807
1808         /* Check SROM Version */
1809         if ( ( (int) srom[18] & 0xff) == SROM_V41_CODE) {
1810                 /* SROM V4.01 */
1811                 /* Get NIC support media mode */
1812                 db->NIC_capability = le16_to_cpup((__le16 *)srom + 34/2);
1813                 db->PHY_reg4 = 0;
1814                 for (tmp_reg = 1; tmp_reg < 0x10; tmp_reg <<= 1) {
1815                         switch( db->NIC_capability & tmp_reg ) {
1816                         case 0x1: db->PHY_reg4 |= 0x0020; break;
1817                         case 0x2: db->PHY_reg4 |= 0x0040; break;
1818                         case 0x4: db->PHY_reg4 |= 0x0080; break;
1819                         case 0x8: db->PHY_reg4 |= 0x0100; break;
1820                         }
1821                 }
1822
1823                 /* Media Mode Force or not check */
1824                 dmfe_mode = le32_to_cpup((__le32 *)srom + 34/4) &
1825                                 le32_to_cpup((__le32 *)srom + 36/4);
1826                 switch(dmfe_mode) {
1827                 case 0x4: dmfe_media_mode = DMFE_100MHF; break; /* 100MHF */
1828                 case 0x2: dmfe_media_mode = DMFE_10MFD; break;  /* 10MFD */
1829                 case 0x8: dmfe_media_mode = DMFE_100MFD; break; /* 100MFD */
1830                 case 0x100:
1831                 case 0x200: dmfe_media_mode = DMFE_1M_HPNA; break;/* HomePNA */
1832                 }
1833
1834                 /* Special Function setting */
1835                 /* VLAN function */
1836                 if ( (SF_mode & 0x1) || (srom[43] & 0x80) )
1837                         db->cr15_data |= 0x40;
1838
1839                 /* Flow Control */
1840                 if ( (SF_mode & 0x2) || (srom[40] & 0x1) )
1841                         db->cr15_data |= 0x400;
1842
1843                 /* TX pause packet */
1844                 if ( (SF_mode & 0x4) || (srom[40] & 0xe) )
1845                         db->cr15_data |= 0x9800;
1846         }
1847
1848         /* Parse HPNA parameter */
1849         db->HPNA_command = 1;
1850
1851         /* Accept remote command or not */
1852         if (HPNA_rx_cmd == 0)
1853                 db->HPNA_command |= 0x8000;
1854
1855          /* Issue remote command & operation mode */
1856         if (HPNA_tx_cmd == 1)
1857                 switch(HPNA_mode) {     /* Issue Remote Command */
1858                 case 0: db->HPNA_command |= 0x0904; break;
1859                 case 1: db->HPNA_command |= 0x0a00; break;
1860                 case 2: db->HPNA_command |= 0x0506; break;
1861                 case 3: db->HPNA_command |= 0x0602; break;
1862                 }
1863         else
1864                 switch(HPNA_mode) {     /* Don't Issue */
1865                 case 0: db->HPNA_command |= 0x0004; break;
1866                 case 1: db->HPNA_command |= 0x0000; break;
1867                 case 2: db->HPNA_command |= 0x0006; break;
1868                 case 3: db->HPNA_command |= 0x0002; break;
1869                 }
1870
1871         /* Check DM9801 or DM9802 present or not */
1872         db->HPNA_present = 0;
1873         update_cr6(db->cr6_data|0x40000, db->ioaddr);
1874         tmp_reg = phy_read(db->ioaddr, db->phy_addr, 3, db->chip_id);
1875         if ( ( tmp_reg & 0xfff0 ) == 0xb900 ) {
1876                 /* DM9801 or DM9802 present */
1877                 db->HPNA_timer = 8;
1878                 if ( phy_read(db->ioaddr, db->phy_addr, 31, db->chip_id) == 0x4404) {
1879                         /* DM9801 HomeRun */
1880                         db->HPNA_present = 1;
1881                         dmfe_program_DM9801(db, tmp_reg);
1882                 } else {
1883                         /* DM9802 LongRun */
1884                         db->HPNA_present = 2;
1885                         dmfe_program_DM9802(db);
1886                 }
1887         }
1888
1889 }
1890
1891
1892 /*
1893  *      Init HomeRun DM9801
1894  */
1895
1896 static void dmfe_program_DM9801(struct dmfe_board_info * db, int HPNA_rev)
1897 {
1898         uint reg17, reg25;
1899
1900         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9801_NOISE_FLOOR;
1901         switch(HPNA_rev) {
1902         case 0xb900: /* DM9801 E3 */
1903                 db->HPNA_command |= 0x1000;
1904                 reg25 = phy_read(db->ioaddr, db->phy_addr, 24, db->chip_id);
1905                 reg25 = ( (reg25 + HPNA_NoiseFloor) & 0xff) | 0xf000;
1906                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1907                 break;
1908         case 0xb901: /* DM9801 E4 */
1909                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1910                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor;
1911                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1912                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor + 3;
1913                 break;
1914         case 0xb902: /* DM9801 E5 */
1915         case 0xb903: /* DM9801 E6 */
1916         default:
1917                 db->HPNA_command |= 0x1000;
1918                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1919                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor - 5;
1920                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1921                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor;
1922                 break;
1923         }
1924         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1925         phy_write(db->ioaddr, db->phy_addr, 17, reg17, db->chip_id);
1926         phy_write(db->ioaddr, db->phy_addr, 25, reg25, db->chip_id);
1927 }
1928
1929
1930 /*
1931  *      Init HomeRun DM9802
1932  */
1933
1934 static void dmfe_program_DM9802(struct dmfe_board_info * db)
1935 {
1936         uint phy_reg;
1937
1938         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9802_NOISE_FLOOR;
1939         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1940         phy_reg = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1941         phy_reg = ( phy_reg & 0xff00) + HPNA_NoiseFloor;
1942         phy_write(db->ioaddr, db->phy_addr, 25, phy_reg, db->chip_id);
1943 }
1944
1945
1946 /*
1947  *      Check remote HPNA power and speed status. If not correct,
1948  *      issue command again.
1949 */
1950
1951 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
1952 {
1953         uint phy_reg;
1954
1955         /* Got remote device status */
1956         phy_reg = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0x60;
1957         switch(phy_reg) {
1958         case 0x00: phy_reg = 0x0a00;break; /* LP/LS */
1959         case 0x20: phy_reg = 0x0900;break; /* LP/HS */
1960         case 0x40: phy_reg = 0x0600;break; /* HP/LS */
1961         case 0x60: phy_reg = 0x0500;break; /* HP/HS */
1962         }
1963
1964         /* Check remote device status match our setting ot not */
1965         if ( phy_reg != (db->HPNA_command & 0x0f00) ) {
1966                 phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1967                 db->HPNA_timer=8;
1968         } else
1969                 db->HPNA_timer=600;     /* Match, every 10 minutes, check */
1970 }
1971
1972
1973
1974 static struct pci_device_id dmfe_pci_tbl[] = {
1975         { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
1976         { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
1977         { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
1978         { 0x1282, 0x9009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9009_ID },
1979         { 0, }
1980 };
1981 MODULE_DEVICE_TABLE(pci, dmfe_pci_tbl);
1982
1983
1984 static struct pci_driver dmfe_driver = {
1985         .name           = "dmfe",
1986         .id_table       = dmfe_pci_tbl,
1987         .probe          = dmfe_init_one,
1988         .remove         = __devexit_p(dmfe_remove_one),
1989 };
1990
1991 MODULE_AUTHOR("Sten Wang, sten_wang@davicom.com.tw");
1992 MODULE_DESCRIPTION("Davicom DM910X fast ethernet driver");
1993 MODULE_LICENSE("GPL");
1994 MODULE_VERSION(DRV_VERSION);
1995
1996 module_param(debug, int, 0);
1997 module_param(mode, byte, 0);
1998 module_param(cr6set, int, 0);
1999 module_param(chkmode, byte, 0);
2000 module_param(HPNA_mode, byte, 0);
2001 module_param(HPNA_rx_cmd, byte, 0);
2002 module_param(HPNA_tx_cmd, byte, 0);
2003 module_param(HPNA_NoiseFloor, byte, 0);
2004 module_param(SF_mode, byte, 0);
2005 MODULE_PARM_DESC(debug, "Davicom DM9xxx enable debugging (0-1)");
2006 MODULE_PARM_DESC(mode, "Davicom DM9xxx: Bit 0: 10/100Mbps, bit 2: duplex, bit 8: HomePNA");
2007 MODULE_PARM_DESC(SF_mode, "Davicom DM9xxx special function (bit 0: VLAN, bit 1 Flow Control, bit 2: TX pause packet)");
2008
2009 /*      Description:
2010  *      when user used insmod to add module, system invoked init_module()
2011  *      to initilize and register.
2012  */
2013
2014 static int __init dmfe_init_module(void)
2015 {
2016         int rc;
2017
2018         printk(version);
2019         printed_version = 1;
2020
2021         DMFE_DBUG(0, "init_module() ", debug);
2022
2023         if (debug)
2024                 dmfe_debug = debug;     /* set debug flag */
2025         if (cr6set)
2026                 dmfe_cr6_user_set = cr6set;
2027
2028         switch(mode) {
2029         case DMFE_10MHF:
2030         case DMFE_100MHF:
2031         case DMFE_10MFD:
2032         case DMFE_100MFD:
2033         case DMFE_1M_HPNA:
2034                 dmfe_media_mode = mode;
2035                 break;
2036         default:dmfe_media_mode = DMFE_AUTO;
2037                 break;
2038         }
2039
2040         if (HPNA_mode > 4)
2041                 HPNA_mode = 0;          /* Default: LP/HS */
2042         if (HPNA_rx_cmd > 1)
2043                 HPNA_rx_cmd = 0;        /* Default: Ignored remote cmd */
2044         if (HPNA_tx_cmd > 1)
2045                 HPNA_tx_cmd = 0;        /* Default: Don't issue remote cmd */
2046         if (HPNA_NoiseFloor > 15)
2047                 HPNA_NoiseFloor = 0;
2048
2049         rc = pci_register_driver(&dmfe_driver);
2050         if (rc < 0)
2051                 return rc;
2052
2053         return 0;
2054 }
2055
2056
2057 /*
2058  *      Description:
2059  *      when user used rmmod to delete module, system invoked clean_module()
2060  *      to un-register all registered services.
2061  */
2062
2063 static void __exit dmfe_cleanup_module(void)
2064 {
2065         DMFE_DBUG(0, "dmfe_clean_module() ", debug);
2066         pci_unregister_driver(&dmfe_driver);
2067 }
2068
2069 module_init(dmfe_init_module);
2070 module_exit(dmfe_cleanup_module);