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