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