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 *next_dev;        /* next 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 struct ethtool_ops netdev_ethtool_ops;
 302 static u16 read_srom_word(long ,int);
 303 static irqreturn_t dmfe_interrupt(int , void *, struct pt_regs *);
 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         /* Allocate Tx/Rx descriptor memory */
 403         db->desc_pool_ptr = pci_alloc_consistent(pdev, sizeof(struct tx_desc) * DESC_ALL_CNT + 0x20, &db->desc_pool_dma_ptr);
 404         db->buf_pool_ptr = pci_alloc_consistent(pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4, &db->buf_pool_dma_ptr);
 405
 406         db->first_tx_desc = (struct tx_desc *) db->desc_pool_ptr;
 407         db->first_tx_desc_dma = db->desc_pool_dma_ptr;
 408         db->buf_pool_start = db->buf_pool_ptr;
 409         db->buf_pool_dma_start = db->buf_pool_dma_ptr;
 410
 411         db->chip_id = ent->driver_data;
 412         db->ioaddr = pci_resource_start(pdev, 0);
 413         db->chip_revision = dev_rev;
 414
 415         db->pdev = pdev;
 416
 417         dev->base_addr = db->ioaddr;
 418         dev->irq = pdev->irq;
 419         pci_set_drvdata(pdev, dev);
 420         dev->open = &dmfe_open;
 421         dev->hard_start_xmit = &dmfe_start_xmit;
 422         dev->stop = &dmfe_stop;
 423         dev->get_stats = &dmfe_get_stats;
 424         dev->set_multicast_list = &dmfe_set_filter_mode;
 425 #ifdef CONFIG_NET_POLL_CONTROLLER
 426         dev->poll_controller = &poll_dmfe;
 427 #endif
 428         dev->ethtool_ops = &netdev_ethtool_ops;
 429         spin_lock_init(&db->lock);
 430
 431         pci_read_config_dword(pdev, 0x50, &pci_pmr);
 432         pci_pmr &= 0x70000;
 433         if ( (pci_pmr == 0x10000) && (dev_rev == 0x02000031) )
 434                 db->chip_type = 1;      /* DM9102A E3 */
 435         else
 436                 db->chip_type = 0;
 437
 438         /* read 64 word srom data */
 439         for (i = 0; i < 64; i++)
 440                 ((u16 *) db->srom)[i] = cpu_to_le16(read_srom_word(db->ioaddr, i));
 441
 442         /* Set Node address */
 443         for (i = 0; i < 6; i++)
 444                 dev->dev_addr[i] = db->srom[20 + i];
 445
 446         err = register_netdev (dev);
 447         if (err)
 448                 goto err_out_res;
 449
 450         printk(KERN_INFO "%s: Davicom DM%04lx at pci%s,",
 451                 dev->name,
 452                 ent->driver_data >> 16,
 453                 pci_name(pdev));
 454         for (i = 0; i < 6; i++)
 455                 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
 456         printk(", irq %d.\n", dev->irq);
 457
 458         pci_set_master(pdev);
 459
 460         return 0;
 461
 462 err_out_res:
 463         pci_release_regions(pdev);
 464 err_out_disable:
 465         pci_disable_device(pdev);
 466 err_out_free:
 467         pci_set_drvdata(pdev, NULL);
 468         free_netdev(dev);
 469
 470         return err;
 471 }
 472
 473
 474 static void __devexit dmfe_remove_one (struct pci_dev *pdev)
 475 {
 476         struct net_device *dev = pci_get_drvdata(pdev);
 477         struct dmfe_board_info *db = netdev_priv(dev);
 478
 479         DMFE_DBUG(0, "dmfe_remove_one()", 0);
 480
 481         if (dev) {
 482                 pci_free_consistent(db->pdev, sizeof(struct tx_desc) *
 483                                         DESC_ALL_CNT + 0x20, db->desc_pool_ptr,
 484                                         db->desc_pool_dma_ptr);
 485                 pci_free_consistent(db->pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
 486                                         db->buf_pool_ptr, db->buf_pool_dma_ptr);
 487                 unregister_netdev(dev);
 488                 pci_release_regions(pdev);
 489                 free_netdev(dev);       /* free board information */
 490                 pci_set_drvdata(pdev, NULL);
 491         }
 492
 493         DMFE_DBUG(0, "dmfe_remove_one() exit", 0);
 494 }
 495
 496
 497 /*
 498  *      Open the interface.
 499  *      The interface is opened whenever "ifconfig" actives it.
 500  */
 501
 502 static int dmfe_open(struct DEVICE *dev)
 503 {
 504         int ret;
 505         struct dmfe_board_info *db = netdev_priv(dev);
 506
 507         DMFE_DBUG(0, "dmfe_open", 0);
 508
 509         ret = request_irq(dev->irq, &dmfe_interrupt, SA_SHIRQ, dev->name, dev);
 510         if (ret)
 511                 return ret;
 512
 513         /* system variable init */
 514         db->cr6_data = CR6_DEFAULT | dmfe_cr6_user_set;
 515         db->tx_packet_cnt = 0;
 516         db->tx_queue_cnt = 0;
 517         db->rx_avail_cnt = 0;
 518         db->link_failed = 1;
 519         db->wait_reset = 0;
 520
 521         db->first_in_callback = 0;
 522         db->NIC_capability = 0xf;       /* All capability*/
 523         db->PHY_reg4 = 0x1e0;
 524
 525         /* CR6 operation mode decision */
 526         if ( !chkmode || (db->chip_id == PCI_DM9132_ID) ||
 527                 (db->chip_revision >= 0x02000030) ) {
 528                 db->cr6_data |= DMFE_TXTH_256;
 529                 db->cr0_data = CR0_DEFAULT;
 530                 db->dm910x_chk_mode=4;          /* Enter the normal mode */
 531         } else {
 532                 db->cr6_data |= CR6_SFT;        /* Store & Forward mode */
 533                 db->cr0_data = 0;
 534                 db->dm910x_chk_mode = 1;        /* Enter the check mode */
 535         }
 536
 537         /* Initilize DM910X board */
 538         dmfe_init_dm910x(dev);
 539
 540         /* Active System Interface */
 541         netif_wake_queue(dev);
 542
 543         /* set and active a timer process */
 544         init_timer(&db->timer);
 545         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
 546         db->timer.data = (unsigned long)dev;
 547         db->timer.function = &dmfe_timer;
 548         add_timer(&db->timer);
 549
 550         return 0;
 551 }
 552
 553
 554 /*      Initilize DM910X board
 555  *      Reset DM910X board
 556  *      Initilize TX/Rx descriptor chain structure
 557  *      Send the set-up frame
 558  *      Enable Tx/Rx machine
 559  */
 560
 561 static void dmfe_init_dm910x(struct DEVICE *dev)
 562 {
 563         struct dmfe_board_info *db = netdev_priv(dev);
 564         unsigned long ioaddr = db->ioaddr;
 565
 566         DMFE_DBUG(0, "dmfe_init_dm910x()", 0);
 567
 568         /* Reset DM910x MAC controller */
 569         outl(DM910X_RESET, ioaddr + DCR0);      /* RESET MAC */
 570         udelay(100);
 571         outl(db->cr0_data, ioaddr + DCR0);
 572         udelay(5);
 573
 574         /* Phy addr : DM910(A)2/DM9132/9801, phy address = 1 */
 575         db->phy_addr = 1;
 576
 577         /* Parser SROM and media mode */
 578         dmfe_parse_srom(db);
 579         db->media_mode = dmfe_media_mode;
 580
 581         /* RESET Phyxcer Chip by GPR port bit 7 */
 582         outl(0x180, ioaddr + DCR12);            /* Let bit 7 output port */
 583         if (db->chip_id == PCI_DM9009_ID) {
 584                 outl(0x80, ioaddr + DCR12);     /* Issue RESET signal */
 585                 mdelay(300);                    /* Delay 300 ms */
 586         }
 587         outl(0x0, ioaddr + DCR12);      /* Clear RESET signal */
 588
 589         /* Process Phyxcer Media Mode */
 590         if ( !(db->media_mode & 0x10) ) /* Force 1M mode */
 591                 dmfe_set_phyxcer(db);
 592
 593         /* Media Mode Process */
 594         if ( !(db->media_mode & DMFE_AUTO) )
 595                 db->op_mode = db->media_mode;   /* Force Mode */
 596
 597         /* Initiliaze Transmit/Receive decriptor and CR3/4 */
 598         dmfe_descriptor_init(db, ioaddr);
 599
 600         /* Init CR6 to program DM910x operation */
 601         update_cr6(db->cr6_data, ioaddr);
 602
 603         /* Send setup frame */
 604         if (db->chip_id == PCI_DM9132_ID)
 605                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
 606         else
 607                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
 608
 609         /* Init CR7, interrupt active bit */
 610         db->cr7_data = CR7_DEFAULT;
 611         outl(db->cr7_data, ioaddr + DCR7);
 612
 613         /* Init CR15, Tx jabber and Rx watchdog timer */
 614         outl(db->cr15_data, ioaddr + DCR15);
 615
 616         /* Enable DM910X Tx/Rx function */
 617         db->cr6_data |= CR6_RXSC | CR6_TXSC | 0x40000;
 618         update_cr6(db->cr6_data, ioaddr);
 619 }
 620
 621
 622 /*
 623  *      Hardware start transmission.
 624  *      Send a packet to media from the upper layer.
 625  */
 626
 627 static int dmfe_start_xmit(struct sk_buff *skb, struct DEVICE *dev)
 628 {
 629         struct dmfe_board_info *db = netdev_priv(dev);
 630         struct tx_desc *txptr;
 631         unsigned long flags;
 632
 633         DMFE_DBUG(0, "dmfe_start_xmit", 0);
 634
 635         /* Resource flag check */
 636         netif_stop_queue(dev);
 637
 638         /* Too large packet check */
 639         if (skb->len > MAX_PACKET_SIZE) {
 640                 printk(KERN_ERR DRV_NAME ": big packet = %d\n", (u16)skb->len);
 641                 dev_kfree_skb(skb);
 642                 return 0;
 643         }
 644
 645         spin_lock_irqsave(&db->lock, flags);
 646
 647         /* No Tx resource check, it never happen nromally */
 648         if (db->tx_queue_cnt >= TX_FREE_DESC_CNT) {
 649                 spin_unlock_irqrestore(&db->lock, flags);
 650                 printk(KERN_ERR DRV_NAME ": No Tx resource %ld\n", db->tx_queue_cnt);
 651                 return 1;
 652         }
 653
 654         /* Disable NIC interrupt */
 655         outl(0, dev->base_addr + DCR7);
 656
 657         /* transmit this packet */
 658         txptr = db->tx_insert_ptr;
 659         memcpy(txptr->tx_buf_ptr, skb->data, skb->len);
 660         txptr->tdes1 = cpu_to_le32(0xe1000000 | skb->len);
 661
 662         /* Point to next transmit free descriptor */
 663         db->tx_insert_ptr = txptr->next_tx_desc;
 664
 665         /* Transmit Packet Process */
 666         if ( (!db->tx_queue_cnt) && (db->tx_packet_cnt < TX_MAX_SEND_CNT) ) {
 667                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 668                 db->tx_packet_cnt++;                    /* Ready to send */
 669                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 670                 dev->trans_start = jiffies;             /* saved time stamp */
 671         } else {
 672                 db->tx_queue_cnt++;                     /* queue TX packet */
 673                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 674         }
 675
 676         /* Tx resource check */
 677         if ( db->tx_queue_cnt < TX_FREE_DESC_CNT )
 678                 netif_wake_queue(dev);
 679
 680         /* Restore CR7 to enable interrupt */
 681         spin_unlock_irqrestore(&db->lock, flags);
 682         outl(db->cr7_data, dev->base_addr + DCR7);
 683
 684         /* free this SKB */
 685         dev_kfree_skb(skb);
 686
 687         return 0;
 688 }
 689
 690
 691 /*
 692  *      Stop the interface.
 693  *      The interface is stopped when it is brought.
 694  */
 695
 696 static int dmfe_stop(struct DEVICE *dev)
 697 {
 698         struct dmfe_board_info *db = netdev_priv(dev);
 699         unsigned long ioaddr = dev->base_addr;
 700
 701         DMFE_DBUG(0, "dmfe_stop", 0);
 702
 703         /* disable system */
 704         netif_stop_queue(dev);
 705
 706         /* deleted timer */
 707         del_timer_sync(&db->timer);
 708
 709         /* Reset & stop DM910X board */
 710         outl(DM910X_RESET, ioaddr + DCR0);
 711         udelay(5);
 712         phy_write(db->ioaddr, db->phy_addr, 0, 0x8000, db->chip_id);
 713
 714         /* free interrupt */
 715         free_irq(dev->irq, dev);
 716
 717         /* free allocated rx buffer */
 718         dmfe_free_rxbuffer(db);
 719
 720 #if 0
 721         /* show statistic counter */
 722         printk(DRV_NAME ": FU:%lx EC:%lx LC:%lx NC:%lx LOC:%lx TXJT:%lx RESET:%lx RCR8:%lx FAL:%lx TT:%lx\n",
 723                 db->tx_fifo_underrun, db->tx_excessive_collision,
 724                 db->tx_late_collision, db->tx_no_carrier, db->tx_loss_carrier,
 725                 db->tx_jabber_timeout, db->reset_count, db->reset_cr8,
 726                 db->reset_fatal, db->reset_TXtimeout);
 727 #endif
 728
 729         return 0;
 730 }
 731
 732
 733 /*
 734  *      DM9102 insterrupt handler
 735  *      receive the packet to upper layer, free the transmitted packet
 736  */
 737
 738 static irqreturn_t dmfe_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 739 {
 740         struct DEVICE *dev = dev_id;
 741         struct dmfe_board_info *db = netdev_priv(dev);
 742         unsigned long ioaddr = dev->base_addr;
 743         unsigned long flags;
 744
 745         DMFE_DBUG(0, "dmfe_interrupt()", 0);
 746
 747         if (!dev) {
 748                 DMFE_DBUG(1, "dmfe_interrupt() without DEVICE arg", 0);
 749                 return IRQ_NONE;
 750         }
 751
 752         spin_lock_irqsave(&db->lock, flags);
 753
 754         /* Got DM910X status */
 755         db->cr5_data = inl(ioaddr + DCR5);
 756         outl(db->cr5_data, ioaddr + DCR5);
 757         if ( !(db->cr5_data & 0xc1) ) {
 758                 spin_unlock_irqrestore(&db->lock, flags);
 759                 return IRQ_HANDLED;
 760         }
 761
 762         /* Disable all interrupt in CR7 to solve the interrupt edge problem */
 763         outl(0, ioaddr + DCR7);
 764
 765         /* Check system status */
 766         if (db->cr5_data & 0x2000) {
 767                 /* system bus error happen */
 768                 DMFE_DBUG(1, "System bus error happen. CR5=", db->cr5_data);
 769                 db->reset_fatal++;
 770                 db->wait_reset = 1;     /* Need to RESET */
 771                 spin_unlock_irqrestore(&db->lock, flags);
 772                 return IRQ_HANDLED;
 773         }
 774
 775          /* Received the coming packet */
 776         if ( (db->cr5_data & 0x40) && db->rx_avail_cnt )
 777                 dmfe_rx_packet(dev, db);
 778
 779         /* reallocate rx descriptor buffer */
 780         if (db->rx_avail_cnt<RX_DESC_CNT)
 781                 allocate_rx_buffer(db);
 782
 783         /* Free the transmitted descriptor */
 784         if ( db->cr5_data & 0x01)
 785                 dmfe_free_tx_pkt(dev, db);
 786
 787         /* Mode Check */
 788         if (db->dm910x_chk_mode & 0x2) {
 789                 db->dm910x_chk_mode = 0x4;
 790                 db->cr6_data |= 0x100;
 791                 update_cr6(db->cr6_data, db->ioaddr);
 792         }
 793
 794         /* Restore CR7 to enable interrupt mask */
 795         outl(db->cr7_data, ioaddr + DCR7);
 796
 797         spin_unlock_irqrestore(&db->lock, flags);
 798         return IRQ_HANDLED;
 799 }
 800
 801
 802 #ifdef CONFIG_NET_POLL_CONTROLLER
 803 /*
 804  * Polling 'interrupt' - used by things like netconsole to send skbs
 805  * without having to re-enable interrupts. It's not called while
 806  * the interrupt routine is executing.
 807  */
 808
 809 static void poll_dmfe (struct net_device *dev)
 810 {
 811         /* disable_irq here is not very nice, but with the lockless
 812            interrupt handler we have no other choice. */
 813         disable_irq(dev->irq);
 814         dmfe_interrupt (dev->irq, dev, NULL);
 815         enable_irq(dev->irq);
 816 }
 817 #endif
 818
 819 /*
 820  *      Free TX resource after TX complete
 821  */
 822
 823 static void dmfe_free_tx_pkt(struct DEVICE *dev, struct dmfe_board_info * db)
 824 {
 825         struct tx_desc *txptr;
 826         unsigned long ioaddr = dev->base_addr;
 827         u32 tdes0;
 828
 829         txptr = db->tx_remove_ptr;
 830         while(db->tx_packet_cnt) {
 831                 tdes0 = le32_to_cpu(txptr->tdes0);
 832                 /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 833                 if (tdes0 & 0x80000000)
 834                         break;
 835
 836                 /* A packet sent completed */
 837                 db->tx_packet_cnt--;
 838                 db->stats.tx_packets++;
 839
 840                 /* Transmit statistic counter */
 841                 if ( tdes0 != 0x7fffffff ) {
 842                         /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 843                         db->stats.collisions += (tdes0 >> 3) & 0xf;
 844                         db->stats.tx_bytes += le32_to_cpu(txptr->tdes1) & 0x7ff;
 845                         if (tdes0 & TDES0_ERR_MASK) {
 846                                 db->stats.tx_errors++;
 847
 848                                 if (tdes0 & 0x0002) {   /* UnderRun */
 849                                         db->tx_fifo_underrun++;
 850                                         if ( !(db->cr6_data & CR6_SFT) ) {
 851                                                 db->cr6_data = db->cr6_data | CR6_SFT;
 852                                                 update_cr6(db->cr6_data, db->ioaddr);
 853                                         }
 854                                 }
 855                                 if (tdes0 & 0x0100)
 856                                         db->tx_excessive_collision++;
 857                                 if (tdes0 & 0x0200)
 858                                         db->tx_late_collision++;
 859                                 if (tdes0 & 0x0400)
 860                                         db->tx_no_carrier++;
 861                                 if (tdes0 & 0x0800)
 862                                         db->tx_loss_carrier++;
 863                                 if (tdes0 & 0x4000)
 864                                         db->tx_jabber_timeout++;
 865                         }
 866                 }
 867
 868                 txptr = txptr->next_tx_desc;
 869         }/* End of while */
 870
 871         /* Update TX remove pointer to next */
 872         db->tx_remove_ptr = txptr;
 873
 874         /* Send the Tx packet in queue */
 875         if ( (db->tx_packet_cnt < TX_MAX_SEND_CNT) && db->tx_queue_cnt ) {
 876                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 877                 db->tx_packet_cnt++;                    /* Ready to send */
 878                 db->tx_queue_cnt--;
 879                 outl(0x1, ioaddr + DCR1);               /* Issue Tx polling */
 880                 dev->trans_start = jiffies;             /* saved time stamp */
 881         }
 882
 883         /* Resource available check */
 884         if ( db->tx_queue_cnt < TX_WAKE_DESC_CNT )
 885                 netif_wake_queue(dev);  /* Active upper layer, send again */
 886 }
 887
 888
 889 /*
 890  *      Calculate the CRC valude of the Rx packet
 891  *      flag =  1 : return the reverse CRC (for the received packet CRC)
 892  *              0 : return the normal CRC (for Hash Table index)
 893  */
 894
 895 static inline u32 cal_CRC(unsigned char * Data, unsigned int Len, u8 flag)
 896 {
 897         u32 crc = crc32(~0, Data, Len);
 898         if (flag) crc = ~crc;
 899         return crc;
 900 }
 901
 902
 903 /*
 904  *      Receive the come packet and pass to upper layer
 905  */
 906
 907 static void dmfe_rx_packet(struct DEVICE *dev, struct dmfe_board_info * db)
 908 {
 909         struct rx_desc *rxptr;
 910         struct sk_buff *skb;
 911         int rxlen;
 912         u32 rdes0;
 913
 914         rxptr = db->rx_ready_ptr;
 915
 916         while(db->rx_avail_cnt) {
 917                 rdes0 = le32_to_cpu(rxptr->rdes0);
 918                 if (rdes0 & 0x80000000) /* packet owner check */
 919                         break;
 920
 921                 db->rx_avail_cnt--;
 922                 db->interval_rx_cnt++;
 923
 924                 pci_unmap_single(db->pdev, le32_to_cpu(rxptr->rdes2), RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE);
 925                 if ( (rdes0 & 0x300) != 0x300) {
 926                         /* A packet without First/Last flag */
 927                         /* reuse this SKB */
 928                         DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
 929                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 930                 } else {
 931                         /* A packet with First/Last flag */
 932                         rxlen = ( (rdes0 >> 16) & 0x3fff) - 4;
 933
 934                         /* error summary bit check */
 935                         if (rdes0 & 0x8000) {
 936                                 /* This is a error packet */
 937                                 //printk(DRV_NAME ": rdes0: %lx\n", rdes0);
 938                                 db->stats.rx_errors++;
 939                                 if (rdes0 & 1)
 940                                         db->stats.rx_fifo_errors++;
 941                                 if (rdes0 & 2)
 942                                         db->stats.rx_crc_errors++;
 943                                 if (rdes0 & 0x80)
 944                                         db->stats.rx_length_errors++;
 945                         }
 946
 947                         if ( !(rdes0 & 0x8000) ||
 948                                 ((db->cr6_data & CR6_PM) && (rxlen>6)) ) {
 949                                 skb = rxptr->rx_skb_ptr;
 950
 951                                 /* Received Packet CRC check need or not */
 952                                 if ( (db->dm910x_chk_mode & 1) &&
 953                                         (cal_CRC(skb->tail, rxlen, 1) !=
 954                                         (*(u32 *) (skb->tail+rxlen) ))) { /* FIXME (?) */
 955                                         /* Found a error received packet */
 956                                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 957                                         db->dm910x_chk_mode = 3;
 958                                 } else {
 959                                         /* Good packet, send to upper layer */
 960                                         /* Shorst packet used new SKB */
 961                                         if ( (rxlen < RX_COPY_SIZE) &&
 962                                                 ( (skb = dev_alloc_skb(rxlen + 2) )
 963                                                 != NULL) ) {
 964                                                 /* size less than COPY_SIZE, allocate a rxlen SKB */
 965                                                 skb->dev = dev;
 966                                                 skb_reserve(skb, 2); /* 16byte align */
 967                                                 memcpy(skb_put(skb, rxlen), rxptr->rx_skb_ptr->tail, rxlen);
 968                                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 969                                         } else {
 970                                                 skb->dev = dev;
 971                                                 skb_put(skb, rxlen);
 972                                         }
 973                                         skb->protocol = eth_type_trans(skb, dev);
 974                                         netif_rx(skb);
 975                                         dev->last_rx = jiffies;
 976                                         db->stats.rx_packets++;
 977                                         db->stats.rx_bytes += rxlen;
 978                                 }
 979                         } else {
 980                                 /* Reuse SKB buffer when the packet is error */
 981                                 DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
 982                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 983                         }
 984                 }
 985
 986                 rxptr = rxptr->next_rx_desc;
 987         }
 988
 989         db->rx_ready_ptr = rxptr;
 990 }
 991
 992
 993 /*
 994  *      Get statistics from driver.
 995  */
 996
 997 static struct net_device_stats * dmfe_get_stats(struct DEVICE *dev)
 998 {
 999         struct dmfe_board_info *db = netdev_priv(dev);
1000
1001         DMFE_DBUG(0, "dmfe_get_stats", 0);
1002         return &db->stats;
1003 }
1004
1005
1006 /*
1007  * Set DM910X multicast address
1008  */
1009
1010 static void dmfe_set_filter_mode(struct DEVICE * dev)
1011 {
1012         struct dmfe_board_info *db = netdev_priv(dev);
1013         unsigned long flags;
1014
1015         DMFE_DBUG(0, "dmfe_set_filter_mode()", 0);
1016         spin_lock_irqsave(&db->lock, flags);
1017
1018         if (dev->flags & IFF_PROMISC) {
1019                 DMFE_DBUG(0, "Enable PROM Mode", 0);
1020                 db->cr6_data |= CR6_PM | CR6_PBF;
1021                 update_cr6(db->cr6_data, db->ioaddr);
1022                 spin_unlock_irqrestore(&db->lock, flags);
1023                 return;
1024         }
1025
1026         if (dev->flags & IFF_ALLMULTI || dev->mc_count > DMFE_MAX_MULTICAST) {
1027                 DMFE_DBUG(0, "Pass all multicast address", dev->mc_count);
1028                 db->cr6_data &= ~(CR6_PM | CR6_PBF);
1029                 db->cr6_data |= CR6_PAM;
1030                 spin_unlock_irqrestore(&db->lock, flags);
1031                 return;
1032         }
1033
1034         DMFE_DBUG(0, "Set multicast address", dev->mc_count);
1035         if (db->chip_id == PCI_DM9132_ID)
1036                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
1037         else
1038                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
1039         spin_unlock_irqrestore(&db->lock, flags);
1040 }
1041
1042 static void netdev_get_drvinfo(struct net_device *dev,
1043                                struct ethtool_drvinfo *info)
1044 {
1045         struct dmfe_board_info *np = netdev_priv(dev);
1046
1047         strcpy(info->driver, DRV_NAME);
1048         strcpy(info->version, DRV_VERSION);
1049         if (np->pdev)
1050                 strcpy(info->bus_info, pci_name(np->pdev));
1051         else
1052                 sprintf(info->bus_info, "EISA 0x%lx %d",
1053                         dev->base_addr, dev->irq);
1054 }
1055
1056 static struct ethtool_ops netdev_ethtool_ops = {
1057         .get_drvinfo            = netdev_get_drvinfo,
1058 };
1059
1060 /*
1061  *      A periodic timer routine
1062  *      Dynamic media sense, allocate Rx buffer...
1063  */
1064
1065 static void dmfe_timer(unsigned long data)
1066 {
1067         u32 tmp_cr8;
1068         unsigned char tmp_cr12;
1069         struct DEVICE *dev = (struct DEVICE *) data;
1070         struct dmfe_board_info *db = netdev_priv(dev);
1071         unsigned long flags;
1072
1073         DMFE_DBUG(0, "dmfe_timer()", 0);
1074         spin_lock_irqsave(&db->lock, flags);
1075
1076         /* Media mode process when Link OK before enter this route */
1077         if (db->first_in_callback == 0) {
1078                 db->first_in_callback = 1;
1079                 if (db->chip_type && (db->chip_id==PCI_DM9102_ID)) {
1080                         db->cr6_data &= ~0x40000;
1081                         update_cr6(db->cr6_data, db->ioaddr);
1082                         phy_write(db->ioaddr, db->phy_addr, 0, 0x1000, db->chip_id);
1083                         db->cr6_data |= 0x40000;
1084                         update_cr6(db->cr6_data, db->ioaddr);
1085                         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
1086                         add_timer(&db->timer);
1087                         spin_unlock_irqrestore(&db->lock, flags);
1088                         return;
1089                 }
1090         }
1091
1092
1093         /* Operating Mode Check */
1094         if ( (db->dm910x_chk_mode & 0x1) &&
1095                 (db->stats.rx_packets > MAX_CHECK_PACKET) )
1096                 db->dm910x_chk_mode = 0x4;
1097
1098         /* Dynamic reset DM910X : system error or transmit time-out */
1099         tmp_cr8 = inl(db->ioaddr + DCR8);
1100         if ( (db->interval_rx_cnt==0) && (tmp_cr8) ) {
1101                 db->reset_cr8++;
1102                 db->wait_reset = 1;
1103         }
1104         db->interval_rx_cnt = 0;
1105
1106         /* TX polling kick monitor */
1107         if ( db->tx_packet_cnt &&
1108              time_after(jiffies, dev->trans_start + DMFE_TX_KICK) ) {
1109                 outl(0x1, dev->base_addr + DCR1);   /* Tx polling again */
1110
1111                 /* TX Timeout */
1112                 if ( time_after(jiffies, dev->trans_start + DMFE_TX_TIMEOUT) ) {
1113                         db->reset_TXtimeout++;
1114                         db->wait_reset = 1;
1115                         printk(KERN_WARNING "%s: Tx timeout - resetting\n",
1116                                dev->name);
1117                 }
1118         }
1119
1120         if (db->wait_reset) {
1121                 DMFE_DBUG(0, "Dynamic Reset device", db->tx_packet_cnt);
1122                 db->reset_count++;
1123                 dmfe_dynamic_reset(dev);
1124                 db->first_in_callback = 0;
1125                 db->timer.expires = DMFE_TIMER_WUT;
1126                 add_timer(&db->timer);
1127                 spin_unlock_irqrestore(&db->lock, flags);
1128                 return;
1129         }
1130
1131         /* Link status check, Dynamic media type change */
1132         if (db->chip_id == PCI_DM9132_ID)
1133                 tmp_cr12 = inb(db->ioaddr + DCR9 + 3);  /* DM9132 */
1134         else
1135                 tmp_cr12 = inb(db->ioaddr + DCR12);     /* DM9102/DM9102A */
1136
1137         if ( ((db->chip_id == PCI_DM9102_ID) &&
1138                 (db->chip_revision == 0x02000030)) ||
1139                 ((db->chip_id == PCI_DM9132_ID) &&
1140                 (db->chip_revision == 0x02000010)) ) {
1141                 /* DM9102A Chip */
1142                 if (tmp_cr12 & 2)
1143                         tmp_cr12 = 0x0;         /* Link failed */
1144                 else
1145                         tmp_cr12 = 0x3; /* Link OK */
1146         }
1147
1148         if ( !(tmp_cr12 & 0x3) && !db->link_failed ) {
1149                 /* Link Failed */
1150                 DMFE_DBUG(0, "Link Failed", tmp_cr12);
1151                 db->link_failed = 1;
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                         dmfe_process_mode(db);
1175                         /* SHOW_MEDIA_TYPE(db->op_mode); */
1176                 }
1177
1178         /* HPNA remote command check */
1179         if (db->HPNA_command & 0xf00) {
1180                 db->HPNA_timer--;
1181                 if (!db->HPNA_timer)
1182                         dmfe_HPNA_remote_cmd_chk(db);
1183         }
1184
1185         /* Timer active again */
1186         db->timer.expires = DMFE_TIMER_WUT;
1187         add_timer(&db->timer);
1188         spin_unlock_irqrestore(&db->lock, flags);
1189 }
1190
1191
1192 /*
1193  *      Dynamic reset the DM910X board
1194  *      Stop DM910X board
1195  *      Free Tx/Rx allocated memory
1196  *      Reset DM910X board
1197  *      Re-initilize DM910X board
1198  */
1199
1200 static void dmfe_dynamic_reset(struct DEVICE *dev)
1201 {
1202         struct dmfe_board_info *db = netdev_priv(dev);
1203
1204         DMFE_DBUG(0, "dmfe_dynamic_reset()", 0);
1205
1206         /* Sopt MAC controller */
1207         db->cr6_data &= ~(CR6_RXSC | CR6_TXSC); /* Disable Tx/Rx */
1208         update_cr6(db->cr6_data, dev->base_addr);
1209         outl(0, dev->base_addr + DCR7);         /* Disable Interrupt */
1210         outl(inl(dev->base_addr + DCR5), dev->base_addr + DCR5);
1211
1212         /* Disable upper layer interface */
1213         netif_stop_queue(dev);
1214
1215         /* Free Rx Allocate buffer */
1216         dmfe_free_rxbuffer(db);
1217
1218         /* system variable init */
1219         db->tx_packet_cnt = 0;
1220         db->tx_queue_cnt = 0;
1221         db->rx_avail_cnt = 0;
1222         db->link_failed = 1;
1223         db->wait_reset = 0;
1224
1225         /* Re-initilize DM910X board */
1226         dmfe_init_dm910x(dev);
1227
1228         /* Restart upper layer interface */
1229         netif_wake_queue(dev);
1230 }
1231
1232
1233 /*
1234  *      free all allocated rx buffer
1235  */
1236
1237 static void dmfe_free_rxbuffer(struct dmfe_board_info * db)
1238 {
1239         DMFE_DBUG(0, "dmfe_free_rxbuffer()", 0);
1240
1241         /* free allocated rx buffer */
1242         while (db->rx_avail_cnt) {
1243                 dev_kfree_skb(db->rx_ready_ptr->rx_skb_ptr);
1244                 db->rx_ready_ptr = db->rx_ready_ptr->next_rx_desc;
1245                 db->rx_avail_cnt--;
1246         }
1247 }
1248
1249
1250 /*
1251  *      Reuse the SK buffer
1252  */
1253
1254 static void dmfe_reuse_skb(struct dmfe_board_info *db, struct sk_buff * skb)
1255 {
1256         struct rx_desc *rxptr = db->rx_insert_ptr;
1257
1258         if (!(rxptr->rdes0 & cpu_to_le32(0x80000000))) {
1259                 rxptr->rx_skb_ptr = skb;
1260                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1261                 wmb();
1262                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1263                 db->rx_avail_cnt++;
1264                 db->rx_insert_ptr = rxptr->next_rx_desc;
1265         } else
1266                 DMFE_DBUG(0, "SK Buffer reuse method error", db->rx_avail_cnt);
1267 }
1268
1269
1270 /*
1271  *      Initialize transmit/Receive descriptor
1272  *      Using Chain structure, and allocate Tx/Rx buffer
1273  */
1274
1275 static void dmfe_descriptor_init(struct dmfe_board_info *db, unsigned long ioaddr)
1276 {
1277         struct tx_desc *tmp_tx;
1278         struct rx_desc *tmp_rx;
1279         unsigned char *tmp_buf;
1280         dma_addr_t tmp_tx_dma, tmp_rx_dma;
1281         dma_addr_t tmp_buf_dma;
1282         int i;
1283
1284         DMFE_DBUG(0, "dmfe_descriptor_init()", 0);
1285
1286         /* tx descriptor start pointer */
1287         db->tx_insert_ptr = db->first_tx_desc;
1288         db->tx_remove_ptr = db->first_tx_desc;
1289         outl(db->first_tx_desc_dma, ioaddr + DCR4);     /* TX DESC address */
1290
1291         /* rx descriptor start pointer */
1292         db->first_rx_desc = (void *)db->first_tx_desc + sizeof(struct tx_desc) * TX_DESC_CNT;
1293         db->first_rx_desc_dma =  db->first_tx_desc_dma + sizeof(struct tx_desc) * TX_DESC_CNT;
1294         db->rx_insert_ptr = db->first_rx_desc;
1295         db->rx_ready_ptr = db->first_rx_desc;
1296         outl(db->first_rx_desc_dma, ioaddr + DCR3);     /* RX DESC address */
1297
1298         /* Init Transmit chain */
1299         tmp_buf = db->buf_pool_start;
1300         tmp_buf_dma = db->buf_pool_dma_start;
1301         tmp_tx_dma = db->first_tx_desc_dma;
1302         for (tmp_tx = db->first_tx_desc, i = 0; i < TX_DESC_CNT; i++, tmp_tx++) {
1303                 tmp_tx->tx_buf_ptr = tmp_buf;
1304                 tmp_tx->tdes0 = cpu_to_le32(0);
1305                 tmp_tx->tdes1 = cpu_to_le32(0x81000000);        /* IC, chain */
1306                 tmp_tx->tdes2 = cpu_to_le32(tmp_buf_dma);
1307                 tmp_tx_dma += sizeof(struct tx_desc);
1308                 tmp_tx->tdes3 = cpu_to_le32(tmp_tx_dma);
1309                 tmp_tx->next_tx_desc = tmp_tx + 1;
1310                 tmp_buf = tmp_buf + TX_BUF_ALLOC;
1311                 tmp_buf_dma = tmp_buf_dma + TX_BUF_ALLOC;
1312         }
1313         (--tmp_tx)->tdes3 = cpu_to_le32(db->first_tx_desc_dma);
1314         tmp_tx->next_tx_desc = db->first_tx_desc;
1315
1316          /* Init Receive descriptor chain */
1317         tmp_rx_dma=db->first_rx_desc_dma;
1318         for (tmp_rx = db->first_rx_desc, i = 0; i < RX_DESC_CNT; i++, tmp_rx++) {
1319                 tmp_rx->rdes0 = cpu_to_le32(0);
1320                 tmp_rx->rdes1 = cpu_to_le32(0x01000600);
1321                 tmp_rx_dma += sizeof(struct rx_desc);
1322                 tmp_rx->rdes3 = cpu_to_le32(tmp_rx_dma);
1323                 tmp_rx->next_rx_desc = tmp_rx + 1;
1324         }
1325         (--tmp_rx)->rdes3 = cpu_to_le32(db->first_rx_desc_dma);
1326         tmp_rx->next_rx_desc = db->first_rx_desc;
1327
1328         /* pre-allocate Rx buffer */
1329         allocate_rx_buffer(db);
1330 }
1331
1332
1333 /*
1334  *      Update CR6 value
1335  *      Firstly stop DM910X , then written value and start
1336  */
1337
1338 static void update_cr6(u32 cr6_data, unsigned long ioaddr)
1339 {
1340         u32 cr6_tmp;
1341
1342         cr6_tmp = cr6_data & ~0x2002;           /* stop Tx/Rx */
1343         outl(cr6_tmp, ioaddr + DCR6);
1344         udelay(5);
1345         outl(cr6_data, ioaddr + DCR6);
1346         udelay(5);
1347 }
1348
1349
1350 /*
1351  *      Send a setup frame for DM9132
1352  *      This setup frame initilize DM910X address filter mode
1353 */
1354
1355 static void dm9132_id_table(struct DEVICE *dev, int mc_cnt)
1356 {
1357         struct dev_mc_list *mcptr;
1358         u16 * addrptr;
1359         unsigned long ioaddr = dev->base_addr+0xc0;             /* ID Table */
1360         u32 hash_val;
1361         u16 i, hash_table[4];
1362
1363         DMFE_DBUG(0, "dm9132_id_table()", 0);
1364
1365         /* Node address */
1366         addrptr = (u16 *) dev->dev_addr;
1367         outw(addrptr[0], ioaddr);
1368         ioaddr += 4;
1369         outw(addrptr[1], ioaddr);
1370         ioaddr += 4;
1371         outw(addrptr[2], ioaddr);
1372         ioaddr += 4;
1373
1374         /* Clear Hash Table */
1375         for (i = 0; i < 4; i++)
1376                 hash_table[i] = 0x0;
1377
1378         /* broadcast address */
1379         hash_table[3] = 0x8000;
1380
1381         /* the multicast address in Hash Table : 64 bits */
1382         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1383                 hash_val = cal_CRC( (char *) mcptr->dmi_addr, 6, 0) & 0x3f;
1384                 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
1385         }
1386
1387         /* Write the hash table to MAC MD table */
1388         for (i = 0; i < 4; i++, ioaddr += 4)
1389                 outw(hash_table[i], ioaddr);
1390 }
1391
1392
1393 /*
1394  *      Send a setup frame for DM9102/DM9102A
1395  *      This setup frame initilize DM910X address filter mode
1396  */
1397
1398 static void send_filter_frame(struct DEVICE *dev, int mc_cnt)
1399 {
1400         struct dmfe_board_info *db = netdev_priv(dev);
1401         struct dev_mc_list *mcptr;
1402         struct tx_desc *txptr;
1403         u16 * addrptr;
1404         u32 * suptr;
1405         int i;
1406
1407         DMFE_DBUG(0, "send_filter_frame()", 0);
1408
1409         txptr = db->tx_insert_ptr;
1410         suptr = (u32 *) txptr->tx_buf_ptr;
1411
1412         /* Node address */
1413         addrptr = (u16 *) dev->dev_addr;
1414         *suptr++ = addrptr[0];
1415         *suptr++ = addrptr[1];
1416         *suptr++ = addrptr[2];
1417
1418         /* broadcast address */
1419         *suptr++ = 0xffff;
1420         *suptr++ = 0xffff;
1421         *suptr++ = 0xffff;
1422
1423         /* fit the multicast address */
1424         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1425                 addrptr = (u16 *) mcptr->dmi_addr;
1426                 *suptr++ = addrptr[0];
1427                 *suptr++ = addrptr[1];
1428                 *suptr++ = addrptr[2];
1429         }
1430
1431         for (; i<14; i++) {
1432                 *suptr++ = 0xffff;
1433                 *suptr++ = 0xffff;
1434                 *suptr++ = 0xffff;
1435         }
1436
1437         /* prepare the setup frame */
1438         db->tx_insert_ptr = txptr->next_tx_desc;
1439         txptr->tdes1 = cpu_to_le32(0x890000c0);
1440
1441         /* Resource Check and Send the setup packet */
1442         if (!db->tx_packet_cnt) {
1443                 /* Resource Empty */
1444                 db->tx_packet_cnt++;
1445                 txptr->tdes0 = cpu_to_le32(0x80000000);
1446                 update_cr6(db->cr6_data | 0x2000, dev->base_addr);
1447                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
1448                 update_cr6(db->cr6_data, dev->base_addr);
1449                 dev->trans_start = jiffies;
1450         } else
1451                 db->tx_queue_cnt++;     /* Put in TX queue */
1452 }
1453
1454
1455 /*
1456  *      Allocate rx buffer,
1457  *      As possible as allocate maxiumn Rx buffer
1458  */
1459
1460 static void allocate_rx_buffer(struct dmfe_board_info *db)
1461 {
1462         struct rx_desc *rxptr;
1463         struct sk_buff *skb;
1464
1465         rxptr = db->rx_insert_ptr;
1466
1467         while(db->rx_avail_cnt < RX_DESC_CNT) {
1468                 if ( ( skb = dev_alloc_skb(RX_ALLOC_SIZE) ) == NULL )
1469                         break;
1470                 rxptr->rx_skb_ptr = skb; /* FIXME (?) */
1471                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1472                 wmb();
1473                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1474                 rxptr = rxptr->next_rx_desc;
1475                 db->rx_avail_cnt++;
1476         }
1477
1478         db->rx_insert_ptr = rxptr;
1479 }
1480
1481
1482 /*
1483  *      Read one word data from the serial ROM
1484  */
1485
1486 static u16 read_srom_word(long ioaddr, int offset)
1487 {
1488         int i;
1489         u16 srom_data = 0;
1490         long cr9_ioaddr = ioaddr + DCR9;
1491
1492         outl(CR9_SROM_READ, cr9_ioaddr);
1493         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1494
1495         /* Send the Read Command 110b */
1496         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1497         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1498         SROM_CLK_WRITE(SROM_DATA_0, cr9_ioaddr);
1499
1500         /* Send the offset */
1501         for (i = 5; i >= 0; i--) {
1502                 srom_data = (offset & (1 << i)) ? SROM_DATA_1 : SROM_DATA_0;
1503                 SROM_CLK_WRITE(srom_data, cr9_ioaddr);
1504         }
1505
1506         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1507
1508         for (i = 16; i > 0; i--) {
1509                 outl(CR9_SROM_READ | CR9_SRCS | CR9_SRCLK, cr9_ioaddr);
1510                 udelay(5);
1511                 srom_data = (srom_data << 1) | ((inl(cr9_ioaddr) & CR9_CRDOUT) ? 1 : 0);
1512                 outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1513                 udelay(5);
1514         }
1515
1516         outl(CR9_SROM_READ, cr9_ioaddr);
1517         return srom_data;
1518 }
1519
1520
1521 /*
1522  *      Auto sense the media mode
1523  */
1524
1525 static u8 dmfe_sense_speed(struct dmfe_board_info * db)
1526 {
1527         u8 ErrFlag = 0;
1528         u16 phy_mode;
1529
1530         /* CR6 bit18=0, select 10/100M */
1531         update_cr6( (db->cr6_data & ~0x40000), db->ioaddr);
1532
1533         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1534         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1535
1536         if ( (phy_mode & 0x24) == 0x24 ) {
1537                 if (db->chip_id == PCI_DM9132_ID)       /* DM9132 */
1538                         phy_mode = phy_read(db->ioaddr, db->phy_addr, 7, db->chip_id) & 0xf000;
1539                 else                            /* DM9102/DM9102A */
1540                         phy_mode = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0xf000;
1541                 /* printk(DRV_NAME ": Phy_mode %x ",phy_mode); */
1542                 switch (phy_mode) {
1543                 case 0x1000: db->op_mode = DMFE_10MHF; break;
1544                 case 0x2000: db->op_mode = DMFE_10MFD; break;
1545                 case 0x4000: db->op_mode = DMFE_100MHF; break;
1546                 case 0x8000: db->op_mode = DMFE_100MFD; break;
1547                 default: db->op_mode = DMFE_10MHF;
1548                         ErrFlag = 1;
1549                         break;
1550                 }
1551         } else {
1552                 db->op_mode = DMFE_10MHF;
1553                 DMFE_DBUG(0, "Link Failed :", phy_mode);
1554                 ErrFlag = 1;
1555         }
1556
1557         return ErrFlag;
1558 }
1559
1560
1561 /*
1562  *      Set 10/100 phyxcer capability
1563  *      AUTO mode : phyxcer register4 is NIC capability
1564  *      Force mode: phyxcer register4 is the force media
1565  */
1566
1567 static void dmfe_set_phyxcer(struct dmfe_board_info *db)
1568 {
1569         u16 phy_reg;
1570
1571         /* Select 10/100M phyxcer */
1572         db->cr6_data &= ~0x40000;
1573         update_cr6(db->cr6_data, db->ioaddr);
1574
1575         /* DM9009 Chip: Phyxcer reg18 bit12=0 */
1576         if (db->chip_id == PCI_DM9009_ID) {
1577                 phy_reg = phy_read(db->ioaddr, db->phy_addr, 18, db->chip_id) & ~0x1000;
1578                 phy_write(db->ioaddr, db->phy_addr, 18, phy_reg, db->chip_id);
1579         }
1580
1581         /* Phyxcer capability setting */
1582         phy_reg = phy_read(db->ioaddr, db->phy_addr, 4, db->chip_id) & ~0x01e0;
1583
1584         if (db->media_mode & DMFE_AUTO) {
1585                 /* AUTO Mode */
1586                 phy_reg |= db->PHY_reg4;
1587         } else {
1588                 /* Force Mode */
1589                 switch(db->media_mode) {
1590                 case DMFE_10MHF: phy_reg |= 0x20; break;
1591                 case DMFE_10MFD: phy_reg |= 0x40; break;
1592                 case DMFE_100MHF: phy_reg |= 0x80; break;
1593                 case DMFE_100MFD: phy_reg |= 0x100; break;
1594                 }
1595                 if (db->chip_id == PCI_DM9009_ID) phy_reg &= 0x61;
1596         }
1597
1598         /* Write new capability to Phyxcer Reg4 */
1599         if ( !(phy_reg & 0x01e0)) {
1600                 phy_reg|=db->PHY_reg4;
1601                 db->media_mode|=DMFE_AUTO;
1602         }
1603         phy_write(db->ioaddr, db->phy_addr, 4, phy_reg, db->chip_id);
1604
1605         /* Restart Auto-Negotiation */
1606         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1607                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1800, db->chip_id);
1608         if ( !db->chip_type )
1609                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1200, db->chip_id);
1610 }
1611
1612
1613 /*
1614  *      Process op-mode
1615  *      AUTO mode : PHY controller in Auto-negotiation Mode
1616  *      Force mode: PHY controller in force mode with HUB
1617  *                      N-way force capability with SWITCH
1618  */
1619
1620 static void dmfe_process_mode(struct dmfe_board_info *db)
1621 {
1622         u16 phy_reg;
1623
1624         /* Full Duplex Mode Check */
1625         if (db->op_mode & 0x4)
1626                 db->cr6_data |= CR6_FDM;        /* Set Full Duplex Bit */
1627         else
1628                 db->cr6_data &= ~CR6_FDM;       /* Clear Full Duplex Bit */
1629
1630         /* Transciver Selection */
1631         if (db->op_mode & 0x10)         /* 1M HomePNA */
1632                 db->cr6_data |= 0x40000;/* External MII select */
1633         else
1634                 db->cr6_data &= ~0x40000;/* Internal 10/100 transciver */
1635
1636         update_cr6(db->cr6_data, db->ioaddr);
1637
1638         /* 10/100M phyxcer force mode need */
1639         if ( !(db->media_mode & 0x18)) {
1640                 /* Forece Mode */
1641                 phy_reg = phy_read(db->ioaddr, db->phy_addr, 6, db->chip_id);
1642                 if ( !(phy_reg & 0x1) ) {
1643                         /* parter without N-Way capability */
1644                         phy_reg = 0x0;
1645                         switch(db->op_mode) {
1646                         case DMFE_10MHF: phy_reg = 0x0; break;
1647                         case DMFE_10MFD: phy_reg = 0x100; break;
1648                         case DMFE_100MHF: phy_reg = 0x2000; break;
1649                         case DMFE_100MFD: phy_reg = 0x2100; break;
1650                         }
1651                         phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
1652                         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1653                                 mdelay(20);
1654                         phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
1655                 }
1656         }
1657 }
1658
1659
1660 /*
1661  *      Write a word to Phy register
1662  */
1663
1664 static void phy_write(unsigned long iobase, u8 phy_addr, u8 offset, u16 phy_data, u32 chip_id)
1665 {
1666         u16 i;
1667         unsigned long ioaddr;
1668
1669         if (chip_id == PCI_DM9132_ID) {
1670                 ioaddr = iobase + 0x80 + offset * 4;
1671                 outw(phy_data, ioaddr);
1672         } else {
1673                 /* DM9102/DM9102A Chip */
1674                 ioaddr = iobase + DCR9;
1675
1676                 /* Send 33 synchronization clock to Phy controller */
1677                 for (i = 0; i < 35; i++)
1678                         phy_write_1bit(ioaddr, PHY_DATA_1);
1679
1680                 /* Send start command(01) to Phy */
1681                 phy_write_1bit(ioaddr, PHY_DATA_0);
1682                 phy_write_1bit(ioaddr, PHY_DATA_1);
1683
1684                 /* Send write command(01) to Phy */
1685                 phy_write_1bit(ioaddr, PHY_DATA_0);
1686                 phy_write_1bit(ioaddr, PHY_DATA_1);
1687
1688                 /* Send Phy address */
1689                 for (i = 0x10; i > 0; i = i >> 1)
1690                         phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1691
1692                 /* Send register address */
1693                 for (i = 0x10; i > 0; i = i >> 1)
1694                         phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
1695
1696                 /* written trasnition */
1697                 phy_write_1bit(ioaddr, PHY_DATA_1);
1698                 phy_write_1bit(ioaddr, PHY_DATA_0);
1699
1700                 /* Write a word data to PHY controller */
1701                 for ( i = 0x8000; i > 0; i >>= 1)
1702                         phy_write_1bit(ioaddr, phy_data & i ? PHY_DATA_1 : PHY_DATA_0);
1703         }
1704 }
1705
1706
1707 /*
1708  *      Read a word data from phy register
1709  */
1710
1711 static u16 phy_read(unsigned long iobase, u8 phy_addr, u8 offset, u32 chip_id)
1712 {
1713         int i;
1714         u16 phy_data;
1715         unsigned long ioaddr;
1716
1717         if (chip_id == PCI_DM9132_ID) {
1718                 /* DM9132 Chip */
1719                 ioaddr = iobase + 0x80 + offset * 4;
1720                 phy_data = inw(ioaddr);
1721         } else {
1722                 /* DM9102/DM9102A Chip */
1723                 ioaddr = iobase + DCR9;
1724
1725                 /* Send 33 synchronization clock to Phy controller */
1726                 for (i = 0; i < 35; i++)
1727                         phy_write_1bit(ioaddr, PHY_DATA_1);
1728
1729                 /* Send start command(01) to Phy */
1730                 phy_write_1bit(ioaddr, PHY_DATA_0);
1731                 phy_write_1bit(ioaddr, PHY_DATA_1);
1732
1733                 /* Send read command(10) to Phy */
1734                 phy_write_1bit(ioaddr, PHY_DATA_1);
1735                 phy_write_1bit(ioaddr, PHY_DATA_0);
1736
1737                 /* Send Phy address */
1738                 for (i = 0x10; i > 0; i = i >> 1)
1739                         phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1740
1741                 /* Send register address */
1742                 for (i = 0x10; i > 0; i = i >> 1)
1743                         phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
1744
1745                 /* Skip transition state */
1746                 phy_read_1bit(ioaddr);
1747
1748                 /* read 16bit data */
1749                 for (phy_data = 0, i = 0; i < 16; i++) {
1750                         phy_data <<= 1;
1751                         phy_data |= phy_read_1bit(ioaddr);
1752                 }
1753         }
1754
1755         return phy_data;
1756 }
1757
1758
1759 /*
1760  *      Write one bit data to Phy Controller
1761  */
1762
1763 static void phy_write_1bit(unsigned long ioaddr, u32 phy_data)
1764 {
1765         outl(phy_data, ioaddr);                 /* MII Clock Low */
1766         udelay(1);
1767         outl(phy_data | MDCLKH, ioaddr);        /* MII Clock High */
1768         udelay(1);
1769         outl(phy_data, ioaddr);                 /* MII Clock Low */
1770         udelay(1);
1771 }
1772
1773
1774 /*
1775  *      Read one bit phy data from PHY controller
1776  */
1777
1778 static u16 phy_read_1bit(unsigned long ioaddr)
1779 {
1780         u16 phy_data;
1781
1782         outl(0x50000, ioaddr);
1783         udelay(1);
1784         phy_data = ( inl(ioaddr) >> 19 ) & 0x1;
1785         outl(0x40000, ioaddr);
1786         udelay(1);
1787
1788         return phy_data;
1789 }
1790
1791
1792 /*
1793  *      Parser SROM and media mode
1794  */
1795
1796 static void dmfe_parse_srom(struct dmfe_board_info * db)
1797 {
1798         char * srom = db->srom;
1799         int dmfe_mode, tmp_reg;
1800
1801         DMFE_DBUG(0, "dmfe_parse_srom() ", 0);
1802
1803         /* Init CR15 */
1804         db->cr15_data = CR15_DEFAULT;
1805
1806         /* Check SROM Version */
1807         if ( ( (int) srom[18] & 0xff) == SROM_V41_CODE) {
1808                 /* SROM V4.01 */
1809                 /* Get NIC support media mode */
1810                 db->NIC_capability = le16_to_cpup(srom + 34);
1811                 db->PHY_reg4 = 0;
1812                 for (tmp_reg = 1; tmp_reg < 0x10; tmp_reg <<= 1) {
1813                         switch( db->NIC_capability & tmp_reg ) {
1814                         case 0x1: db->PHY_reg4 |= 0x0020; break;
1815                         case 0x2: db->PHY_reg4 |= 0x0040; break;
1816                         case 0x4: db->PHY_reg4 |= 0x0080; break;
1817                         case 0x8: db->PHY_reg4 |= 0x0100; break;
1818                         }
1819                 }
1820
1821                 /* Media Mode Force or not check */
1822                 dmfe_mode = le32_to_cpup(srom + 34) & le32_to_cpup(srom + 36);
1823                 switch(dmfe_mode) {
1824                 case 0x4: dmfe_media_mode = DMFE_100MHF; break; /* 100MHF */
1825                 case 0x2: dmfe_media_mode = DMFE_10MFD; break;  /* 10MFD */
1826                 case 0x8: dmfe_media_mode = DMFE_100MFD; break; /* 100MFD */
1827                 case 0x100:
1828                 case 0x200: dmfe_media_mode = DMFE_1M_HPNA; break;/* HomePNA */
1829                 }
1830
1831                 /* Special Function setting */
1832                 /* VLAN function */
1833                 if ( (SF_mode & 0x1) || (srom[43] & 0x80) )
1834                         db->cr15_data |= 0x40;
1835
1836                 /* Flow Control */
1837                 if ( (SF_mode & 0x2) || (srom[40] & 0x1) )
1838                         db->cr15_data |= 0x400;
1839
1840                 /* TX pause packet */
1841                 if ( (SF_mode & 0x4) || (srom[40] & 0xe) )
1842                         db->cr15_data |= 0x9800;
1843         }
1844
1845         /* Parse HPNA parameter */
1846         db->HPNA_command = 1;
1847
1848         /* Accept remote command or not */
1849         if (HPNA_rx_cmd == 0)
1850                 db->HPNA_command |= 0x8000;
1851
1852          /* Issue remote command & operation mode */
1853         if (HPNA_tx_cmd == 1)
1854                 switch(HPNA_mode) {     /* Issue Remote Command */
1855                 case 0: db->HPNA_command |= 0x0904; break;
1856                 case 1: db->HPNA_command |= 0x0a00; break;
1857                 case 2: db->HPNA_command |= 0x0506; break;
1858                 case 3: db->HPNA_command |= 0x0602; break;
1859                 }
1860         else
1861                 switch(HPNA_mode) {     /* Don't Issue */
1862                 case 0: db->HPNA_command |= 0x0004; break;
1863                 case 1: db->HPNA_command |= 0x0000; break;
1864                 case 2: db->HPNA_command |= 0x0006; break;
1865                 case 3: db->HPNA_command |= 0x0002; break;
1866                 }
1867
1868         /* Check DM9801 or DM9802 present or not */
1869         db->HPNA_present = 0;
1870         update_cr6(db->cr6_data|0x40000, db->ioaddr);
1871         tmp_reg = phy_read(db->ioaddr, db->phy_addr, 3, db->chip_id);
1872         if ( ( tmp_reg & 0xfff0 ) == 0xb900 ) {
1873                 /* DM9801 or DM9802 present */
1874                 db->HPNA_timer = 8;
1875                 if ( phy_read(db->ioaddr, db->phy_addr, 31, db->chip_id) == 0x4404) {
1876                         /* DM9801 HomeRun */
1877                         db->HPNA_present = 1;
1878                         dmfe_program_DM9801(db, tmp_reg);
1879                 } else {
1880                         /* DM9802 LongRun */
1881                         db->HPNA_present = 2;
1882                         dmfe_program_DM9802(db);
1883                 }
1884         }
1885
1886 }
1887
1888
1889 /*
1890  *      Init HomeRun DM9801
1891  */
1892
1893 static void dmfe_program_DM9801(struct dmfe_board_info * db, int HPNA_rev)
1894 {
1895         uint reg17, reg25;
1896
1897         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9801_NOISE_FLOOR;
1898         switch(HPNA_rev) {
1899         case 0xb900: /* DM9801 E3 */
1900                 db->HPNA_command |= 0x1000;
1901                 reg25 = phy_read(db->ioaddr, db->phy_addr, 24, db->chip_id);
1902                 reg25 = ( (reg25 + HPNA_NoiseFloor) & 0xff) | 0xf000;
1903                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1904                 break;
1905         case 0xb901: /* DM9801 E4 */
1906                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1907                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor;
1908                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1909                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor + 3;
1910                 break;
1911         case 0xb902: /* DM9801 E5 */
1912         case 0xb903: /* DM9801 E6 */
1913         default:
1914                 db->HPNA_command |= 0x1000;
1915                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1916                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor - 5;
1917                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
1918                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor;
1919                 break;
1920         }
1921         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1922         phy_write(db->ioaddr, db->phy_addr, 17, reg17, db->chip_id);
1923         phy_write(db->ioaddr, db->phy_addr, 25, reg25, db->chip_id);
1924 }
1925
1926
1927 /*
1928  *      Init HomeRun DM9802
1929  */
1930
1931 static void dmfe_program_DM9802(struct dmfe_board_info * db)
1932 {
1933         uint phy_reg;
1934
1935         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9802_NOISE_FLOOR;
1936         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1937         phy_reg = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
1938         phy_reg = ( phy_reg & 0xff00) + HPNA_NoiseFloor;
1939         phy_write(db->ioaddr, db->phy_addr, 25, phy_reg, db->chip_id);
1940 }
1941
1942
1943 /*
1944  *      Check remote HPNA power and speed status. If not correct,
1945  *      issue command again.
1946 */
1947
1948 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
1949 {
1950         uint phy_reg;
1951
1952         /* Got remote device status */
1953         phy_reg = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0x60;
1954         switch(phy_reg) {
1955         case 0x00: phy_reg = 0x0a00;break; /* LP/LS */
1956         case 0x20: phy_reg = 0x0900;break; /* LP/HS */
1957         case 0x40: phy_reg = 0x0600;break; /* HP/LS */
1958         case 0x60: phy_reg = 0x0500;break; /* HP/HS */
1959         }
1960
1961         /* Check remote device status match our setting ot not */
1962         if ( phy_reg != (db->HPNA_command & 0x0f00) ) {
1963                 phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
1964                 db->HPNA_timer=8;
1965         } else
1966                 db->HPNA_timer=600;     /* Match, every 10 minutes, check */
1967 }
1968
1969
1970
1971 static struct pci_device_id dmfe_pci_tbl[] = {
1972         { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
1973         { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
1974         { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
1975         { 0x1282, 0x9009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9009_ID },
1976         { 0, }
1977 };
1978 MODULE_DEVICE_TABLE(pci, dmfe_pci_tbl);
1979
1980
1981 static struct pci_driver dmfe_driver = {
1982         .name           = "dmfe",
1983         .id_table       = dmfe_pci_tbl,
1984         .probe          = dmfe_init_one,
1985         .remove         = __devexit_p(dmfe_remove_one),
1986 };
1987
1988 MODULE_AUTHOR("Sten Wang, sten_wang@davicom.com.tw");
1989 MODULE_DESCRIPTION("Davicom DM910X fast ethernet driver");
1990 MODULE_LICENSE("GPL");
1991 MODULE_VERSION(DRV_VERSION);
1992
1993 module_param(debug, int, 0);
1994 module_param(mode, byte, 0);
1995 module_param(cr6set, int, 0);
1996 module_param(chkmode, byte, 0);
1997 module_param(HPNA_mode, byte, 0);
1998 module_param(HPNA_rx_cmd, byte, 0);
1999 module_param(HPNA_tx_cmd, byte, 0);
2000 module_param(HPNA_NoiseFloor, byte, 0);
2001 module_param(SF_mode, byte, 0);
2002 MODULE_PARM_DESC(debug, "Davicom DM9xxx enable debugging (0-1)");
2003 MODULE_PARM_DESC(mode, "Davicom DM9xxx: Bit 0: 10/100Mbps, bit 2: duplex, bit 8: HomePNA");
2004 MODULE_PARM_DESC(SF_mode, "Davicom DM9xxx special function (bit 0: VLAN, bit 1 Flow Control, bit 2: TX pause packet)");
2005
2006 /*      Description:
2007  *      when user used insmod to add module, system invoked init_module()
2008  *      to initilize and register.
2009  */
2010
2011 static int __init dmfe_init_module(void)
2012 {
2013         int rc;
2014
2015         printk(version);
2016         printed_version = 1;
2017
2018         DMFE_DBUG(0, "init_module() ", debug);
2019
2020         if (debug)
2021                 dmfe_debug = debug;     /* set debug flag */
2022         if (cr6set)
2023                 dmfe_cr6_user_set = cr6set;
2024
2025         switch(mode) {
2026         case DMFE_10MHF:
2027         case DMFE_100MHF:
2028         case DMFE_10MFD:
2029         case DMFE_100MFD:
2030         case DMFE_1M_HPNA:
2031                 dmfe_media_mode = mode;
2032                 break;
2033         default:dmfe_media_mode = DMFE_AUTO;
2034                 break;
2035         }
2036
2037         if (HPNA_mode > 4)
2038                 HPNA_mode = 0;          /* Default: LP/HS */
2039         if (HPNA_rx_cmd > 1)
2040                 HPNA_rx_cmd = 0;        /* Default: Ignored remote cmd */
2041         if (HPNA_tx_cmd > 1)
2042                 HPNA_tx_cmd = 0;        /* Default: Don't issue remote cmd */
2043         if (HPNA_NoiseFloor > 15)
2044                 HPNA_NoiseFloor = 0;
2045
2046         rc = pci_module_init(&dmfe_driver);
2047         if (rc < 0)
2048                 return rc;
2049
2050         return 0;
2051 }
2052
2053
2054 /*
2055  *      Description:
2056  *      when user used rmmod to delete module, system invoked clean_module()
2057  *      to un-register all registered services.
2058  */
2059
2060 static void __exit dmfe_cleanup_module(void)
2061 {
2062         DMFE_DBUG(0, "dmfe_clean_module() ", debug);
2063         pci_unregister_driver(&dmfe_driver);
2064 }
2065
2066 module_init(dmfe_init_module);
2067 module_exit(dmfe_cleanup_module);