1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32
33#define DRV_NAME "fmvj18x_cs"
34#define DRV_VERSION "2.9"
35
36#include <linux/module.h>
37#include <linux/kernel.h>
38#include <linux/init.h>
39#include <linux/ptrace.h>
40#include <linux/slab.h>
41#include <linux/string.h>
42#include <linux/timer.h>
43#include <linux/interrupt.h>
44#include <linux/in.h>
45#include <linux/delay.h>
46#include <linux/ethtool.h>
47#include <linux/netdevice.h>
48#include <linux/etherdevice.h>
49#include <linux/skbuff.h>
50#include <linux/if_arp.h>
51#include <linux/ioport.h>
52#include <linux/crc32.h>
53
54#include <pcmcia/cistpl.h>
55#include <pcmcia/ciscode.h>
56#include <pcmcia/ds.h>
57
58#include <asm/uaccess.h>
59#include <asm/io.h>
60
61
62
63
64
65MODULE_DESCRIPTION("fmvj18x and compatible PCMCIA ethernet driver");
66MODULE_LICENSE("GPL");
67
68#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
69
70
71
72INT_MODULE_PARM(sram_config, 0);
73
74
75
76
77
78
79static int fmvj18x_config(struct pcmcia_device *link);
80static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id);
81static int fmvj18x_setup_mfc(struct pcmcia_device *link);
82static void fmvj18x_release(struct pcmcia_device *link);
83static void fmvj18x_detach(struct pcmcia_device *p_dev);
84
85
86
87
88static int fjn_config(struct net_device *dev, struct ifmap *map);
89static int fjn_open(struct net_device *dev);
90static int fjn_close(struct net_device *dev);
91static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
92 struct net_device *dev);
93static irqreturn_t fjn_interrupt(int irq, void *dev_id);
94static void fjn_rx(struct net_device *dev);
95static void fjn_reset(struct net_device *dev);
96static void set_rx_mode(struct net_device *dev);
97static void fjn_tx_timeout(struct net_device *dev);
98static const struct ethtool_ops netdev_ethtool_ops;
99
100
101
102
103typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
104 XXX10304, NEC, KME
105} cardtype_t;
106
107
108
109
110typedef struct local_info_t {
111 struct pcmcia_device *p_dev;
112 long open_time;
113 uint tx_started:1;
114 uint tx_queue;
115 u_short tx_queue_len;
116 cardtype_t cardtype;
117 u_short sent;
118 u_char __iomem *base;
119} local_info_t;
120
121#define MC_FILTERBREAK 64
122
123
124
125
126
127#define TX_STATUS 0
128#define RX_STATUS 1
129#define TX_INTR 2
130#define RX_INTR 3
131#define TX_MODE 4
132#define RX_MODE 5
133#define CONFIG_0 6
134#define CONFIG_1 7
135
136#define NODE_ID 8
137#define MAR_ADR 8
138
139#define DATAPORT 8
140#define TX_START 10
141#define COL_CTRL 11
142#define BMPR12 12
143#define BMPR13 13
144#define RX_SKIP 14
145
146#define LAN_CTRL 16
147
148#define MAC_ID 0x1a
149#define UNGERMANN_MAC_ID 0x18
150
151
152
153
154#define ENA_TMT_OK 0x80
155#define ENA_TMT_REC 0x20
156#define ENA_COL 0x04
157#define ENA_16_COL 0x02
158#define ENA_TBUS_ERR 0x01
159
160#define ENA_PKT_RDY 0x80
161#define ENA_BUS_ERR 0x40
162#define ENA_LEN_ERR 0x08
163#define ENA_ALG_ERR 0x04
164#define ENA_CRC_ERR 0x02
165#define ENA_OVR_FLO 0x01
166
167
168#define F_TMT_RDY 0x80
169#define F_NET_BSY 0x40
170#define F_TMT_OK 0x20
171#define F_SRT_PKT 0x10
172#define F_COL_ERR 0x04
173#define F_16_COL 0x02
174#define F_TBUS_ERR 0x01
175
176#define F_PKT_RDY 0x80
177#define F_BUS_ERR 0x40
178#define F_LEN_ERR 0x08
179#define F_ALG_ERR 0x04
180#define F_CRC_ERR 0x02
181#define F_OVR_FLO 0x01
182
183#define F_BUF_EMP 0x40
184
185#define F_SKP_PKT 0x05
186
187
188#define D_TX_INTR ( ENA_TMT_OK )
189#define D_RX_INTR ( ENA_PKT_RDY | ENA_LEN_ERR \
190 | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
191#define TX_STAT_M ( F_TMT_RDY )
192#define RX_STAT_M ( F_PKT_RDY | F_LEN_ERR \
193 | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
194
195
196#define D_TX_MODE 0x06
197#define ID_MATCHED 0x02
198#define RECV_ALL 0x03
199#define CONFIG0_DFL 0x5a
200#define CONFIG0_DFL_1 0x5e
201#define CONFIG0_RST 0xda
202#define CONFIG0_RST_1 0xde
203#define BANK_0 0xa0
204#define BANK_1 0xa4
205#define BANK_2 0xa8
206#define CHIP_OFF 0x80
207#define DO_TX 0x80
208#define SEND_PKT 0x81
209#define AUTO_MODE 0x07
210#define MANU_MODE 0x03
211#define TDK_AUTO_MODE 0x47
212#define TDK_MANU_MODE 0x43
213#define INTR_OFF 0x0d
214#define INTR_ON 0x1d
215
216#define TX_TIMEOUT ((400*HZ)/1000)
217
218#define BANK_0U 0x20
219#define BANK_1U 0x24
220#define BANK_2U 0x28
221
222static const struct net_device_ops fjn_netdev_ops = {
223 .ndo_open = fjn_open,
224 .ndo_stop = fjn_close,
225 .ndo_start_xmit = fjn_start_xmit,
226 .ndo_tx_timeout = fjn_tx_timeout,
227 .ndo_set_config = fjn_config,
228 .ndo_set_rx_mode = set_rx_mode,
229 .ndo_change_mtu = eth_change_mtu,
230 .ndo_set_mac_address = eth_mac_addr,
231 .ndo_validate_addr = eth_validate_addr,
232};
233
234static int fmvj18x_probe(struct pcmcia_device *link)
235{
236 local_info_t *lp;
237 struct net_device *dev;
238
239 dev_dbg(&link->dev, "fmvj18x_attach()\n");
240
241
242 dev = alloc_etherdev(sizeof(local_info_t));
243 if (!dev)
244 return -ENOMEM;
245 lp = netdev_priv(dev);
246 link->priv = dev;
247 lp->p_dev = link;
248 lp->base = NULL;
249
250
251 link->resource[0]->end = 32;
252 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
253
254
255 link->config_flags |= CONF_ENABLE_IRQ;
256
257 dev->netdev_ops = &fjn_netdev_ops;
258 dev->watchdog_timeo = TX_TIMEOUT;
259
260 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
261
262 return fmvj18x_config(link);
263}
264
265
266
267static void fmvj18x_detach(struct pcmcia_device *link)
268{
269 struct net_device *dev = link->priv;
270
271 dev_dbg(&link->dev, "fmvj18x_detach\n");
272
273 unregister_netdev(dev);
274
275 fmvj18x_release(link);
276
277 free_netdev(dev);
278}
279
280
281
282static int mfc_try_io_port(struct pcmcia_device *link)
283{
284 int i, ret;
285 static const unsigned int serial_base[5] =
286 { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
287
288 for (i = 0; i < 5; i++) {
289 link->resource[1]->start = serial_base[i];
290 link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
291 if (link->resource[1]->start == 0) {
292 link->resource[1]->end = 0;
293 pr_notice("out of resource for serial\n");
294 }
295 ret = pcmcia_request_io(link);
296 if (ret == 0)
297 return ret;
298 }
299 return ret;
300}
301
302static int ungermann_try_io_port(struct pcmcia_device *link)
303{
304 int ret;
305 unsigned int ioaddr;
306
307
308
309
310 for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
311 link->resource[0]->start = ioaddr;
312 ret = pcmcia_request_io(link);
313 if (ret == 0) {
314
315 link->config_index =
316 ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
317 return ret;
318 }
319 }
320 return ret;
321}
322
323static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
324{
325 return 0;
326}
327
328static int fmvj18x_config(struct pcmcia_device *link)
329{
330 struct net_device *dev = link->priv;
331 local_info_t *lp = netdev_priv(dev);
332 int i, ret;
333 unsigned int ioaddr;
334 cardtype_t cardtype;
335 char *card_name = "unknown";
336 u8 *buf;
337 size_t len;
338 u_char buggybuf[32];
339
340 dev_dbg(&link->dev, "fmvj18x_config\n");
341
342 link->io_lines = 5;
343
344 len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
345 kfree(buf);
346
347 if (len) {
348
349 ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
350 if (ret != 0)
351 goto failed;
352
353 switch (link->manf_id) {
354 case MANFID_TDK:
355 cardtype = TDK;
356 if (link->card_id == PRODID_TDK_GN3410 ||
357 link->card_id == PRODID_TDK_NP9610 ||
358 link->card_id == PRODID_TDK_MN3200) {
359
360 link->config_base = 0x800;
361 link->config_index = 0x47;
362 link->resource[1]->end = 8;
363 }
364 break;
365 case MANFID_NEC:
366 cardtype = NEC;
367 link->config_base = 0x800;
368 link->config_index = 0x47;
369 link->resource[1]->end = 8;
370 break;
371 case MANFID_KME:
372 cardtype = KME;
373 link->config_base = 0x800;
374 link->config_index = 0x47;
375 link->resource[1]->end = 8;
376 break;
377 case MANFID_CONTEC:
378 cardtype = CONTEC;
379 break;
380 case MANFID_FUJITSU:
381 if (link->config_base == 0x0fe0)
382 cardtype = MBH10302;
383 else if (link->card_id == PRODID_FUJITSU_MBH10302)
384
385
386 cardtype = MBH10304;
387 else if (link->card_id == PRODID_FUJITSU_MBH10304)
388 cardtype = MBH10304;
389 else
390 cardtype = LA501;
391 break;
392 default:
393 cardtype = MBH10304;
394 }
395 } else {
396
397 switch (link->manf_id) {
398 case MANFID_FUJITSU:
399 if (link->card_id == PRODID_FUJITSU_MBH10304) {
400 cardtype = XXX10304;
401 link->config_index = 0x20;
402 } else {
403 cardtype = MBH10302;
404 link->config_index = 1;
405 }
406 break;
407 case MANFID_UNGERMANN:
408 cardtype = UNGERMANN;
409 break;
410 default:
411 cardtype = MBH10302;
412 link->config_index = 1;
413 }
414 }
415
416 if (link->resource[1]->end != 0) {
417 ret = mfc_try_io_port(link);
418 if (ret != 0) goto failed;
419 } else if (cardtype == UNGERMANN) {
420 ret = ungermann_try_io_port(link);
421 if (ret != 0) goto failed;
422 } else {
423 ret = pcmcia_request_io(link);
424 if (ret)
425 goto failed;
426 }
427 ret = pcmcia_request_irq(link, fjn_interrupt);
428 if (ret)
429 goto failed;
430 ret = pcmcia_enable_device(link);
431 if (ret)
432 goto failed;
433
434 dev->irq = link->irq;
435 dev->base_addr = link->resource[0]->start;
436
437 if (resource_size(link->resource[1]) != 0) {
438 ret = fmvj18x_setup_mfc(link);
439 if (ret != 0) goto failed;
440 }
441
442 ioaddr = dev->base_addr;
443
444
445 if (sram_config == 0)
446 outb(CONFIG0_RST, ioaddr + CONFIG_0);
447 else
448 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
449
450
451 if (cardtype == MBH10302)
452 outb(BANK_0, ioaddr + CONFIG_1);
453 else
454 outb(BANK_0U, ioaddr + CONFIG_1);
455
456
457 switch (cardtype) {
458 case MBH10304:
459 case TDK:
460 case LA501:
461 case CONTEC:
462 case NEC:
463 case KME:
464 if (cardtype == MBH10304) {
465 card_name = "FMV-J182";
466
467 len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
468 if (len < 11) {
469 kfree(buf);
470 goto failed;
471 }
472
473 for (i = 5; i < 11; i++)
474 dev->dev_addr[i] = buf[i];
475 kfree(buf);
476 } else {
477 if (pcmcia_get_mac_from_cis(link, dev))
478 goto failed;
479 if( cardtype == TDK ) {
480 card_name = "TDK LAK-CD021";
481 } else if( cardtype == LA501 ) {
482 card_name = "LA501";
483 } else if( cardtype == NEC ) {
484 card_name = "PK-UG-J001";
485 } else if( cardtype == KME ) {
486 card_name = "Panasonic";
487 } else {
488 card_name = "C-NET(PC)C";
489 }
490 }
491 break;
492 case UNGERMANN:
493
494 for (i = 0; i < 6; i++)
495 dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
496 card_name = "Access/CARD";
497 break;
498 case XXX10304:
499
500 if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
501 pr_notice("unable to read hardware net address\n");
502 goto failed;
503 }
504 for (i = 0 ; i < 6; i++) {
505 dev->dev_addr[i] = buggybuf[i];
506 }
507 card_name = "FMV-J182";
508 break;
509 case MBH10302:
510 default:
511
512 for (i = 0; i < 6; i++)
513 dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
514 card_name = "FMV-J181";
515 break;
516 }
517
518 lp->cardtype = cardtype;
519 SET_NETDEV_DEV(dev, &link->dev);
520
521 if (register_netdev(dev) != 0) {
522 pr_notice("register_netdev() failed\n");
523 goto failed;
524 }
525
526
527 netdev_info(dev, "%s, sram %s, port %#3lx, irq %d, hw_addr %pM\n",
528 card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
529 dev->base_addr, dev->irq, dev->dev_addr);
530
531 return 0;
532
533failed:
534 fmvj18x_release(link);
535 return -ENODEV;
536}
537
538
539static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
540{
541 u_char __iomem *base;
542 int i, j;
543
544
545 link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
546 link->resource[2]->start = 0; link->resource[2]->end = 0;
547 i = pcmcia_request_window(link, link->resource[2], 0);
548 if (i != 0)
549 return -1;
550
551 base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
552 pcmcia_map_mem_page(link, link->resource[2], 0);
553
554
555
556
557
558
559
560 for (i = 0; i < 0x200; i++) {
561 if (readb(base+i*2) == 0x22) {
562 if (readb(base+(i-1)*2) == 0xff &&
563 readb(base+(i+5)*2) == 0x04 &&
564 readb(base+(i+6)*2) == 0x06 &&
565 readb(base+(i+13)*2) == 0xff)
566 break;
567 }
568 }
569
570 if (i != 0x200) {
571 for (j = 0 ; j < 6; j++,i++) {
572 node_id[j] = readb(base+(i+7)*2);
573 }
574 }
575
576 iounmap(base);
577 j = pcmcia_release_window(link, link->resource[2]);
578 return (i != 0x200) ? 0 : -1;
579
580}
581
582
583static int fmvj18x_setup_mfc(struct pcmcia_device *link)
584{
585 int i;
586 struct net_device *dev = link->priv;
587 unsigned int ioaddr;
588 local_info_t *lp = netdev_priv(dev);
589
590
591 link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
592 link->resource[3]->start = link->resource[3]->end = 0;
593 i = pcmcia_request_window(link, link->resource[3], 0);
594 if (i != 0)
595 return -1;
596
597 lp->base = ioremap(link->resource[3]->start,
598 resource_size(link->resource[3]));
599 if (lp->base == NULL) {
600 netdev_notice(dev, "ioremap failed\n");
601 return -1;
602 }
603
604 i = pcmcia_map_mem_page(link, link->resource[3], 0);
605 if (i != 0) {
606 iounmap(lp->base);
607 lp->base = NULL;
608 return -1;
609 }
610
611 ioaddr = dev->base_addr;
612 writeb(0x47, lp->base+0x800);
613 writeb(0x0, lp->base+0x802);
614
615 writeb(ioaddr & 0xff, lp->base+0x80a);
616 writeb((ioaddr >> 8) & 0xff, lp->base+0x80c);
617
618 writeb(0x45, lp->base+0x820);
619 writeb(0x8, lp->base+0x822);
620
621 return 0;
622
623}
624
625
626static void fmvj18x_release(struct pcmcia_device *link)
627{
628
629 struct net_device *dev = link->priv;
630 local_info_t *lp = netdev_priv(dev);
631 u_char __iomem *tmp;
632
633 dev_dbg(&link->dev, "fmvj18x_release\n");
634
635 if (lp->base != NULL) {
636 tmp = lp->base;
637 lp->base = NULL;
638 iounmap(tmp);
639 }
640
641 pcmcia_disable_device(link);
642
643}
644
645static int fmvj18x_suspend(struct pcmcia_device *link)
646{
647 struct net_device *dev = link->priv;
648
649 if (link->open)
650 netif_device_detach(dev);
651
652 return 0;
653}
654
655static int fmvj18x_resume(struct pcmcia_device *link)
656{
657 struct net_device *dev = link->priv;
658
659 if (link->open) {
660 fjn_reset(dev);
661 netif_device_attach(dev);
662 }
663
664 return 0;
665}
666
667
668
669static const struct pcmcia_device_id fmvj18x_ids[] = {
670 PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
671 PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
672 PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
673 PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
674 PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
675 PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
676 PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
677 PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
678 PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0 ", 0x8cef4d3a, 0x075fc7b6),
679 PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0 ", 0x8cef4d3a, 0xbccf43e6),
680 PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
681 PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
682 PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
683 PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
684 PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304 ES", 0x2599f454),
685 PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
686 PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
687 PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
688 PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
689 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
690 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
691 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
692 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
693 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0b05),
694 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
695 PCMCIA_DEVICE_NULL,
696};
697MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
698
699static struct pcmcia_driver fmvj18x_cs_driver = {
700 .owner = THIS_MODULE,
701 .name = "fmvj18x_cs",
702 .probe = fmvj18x_probe,
703 .remove = fmvj18x_detach,
704 .id_table = fmvj18x_ids,
705 .suspend = fmvj18x_suspend,
706 .resume = fmvj18x_resume,
707};
708module_pcmcia_driver(fmvj18x_cs_driver);
709
710
711
712static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
713{
714 struct net_device *dev = dev_id;
715 local_info_t *lp = netdev_priv(dev);
716 unsigned int ioaddr;
717 unsigned short tx_stat, rx_stat;
718
719 ioaddr = dev->base_addr;
720
721
722 outw(0x0000, ioaddr + TX_INTR);
723
724
725 udelay(1);
726
727
728 tx_stat = inb(ioaddr + TX_STATUS);
729 rx_stat = inb(ioaddr + RX_STATUS);
730
731
732 outb(tx_stat, ioaddr + TX_STATUS);
733 outb(rx_stat, ioaddr + RX_STATUS);
734
735 pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
736 pr_debug(" tx_status %02x.\n", tx_stat);
737
738 if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
739
740 fjn_rx(dev);
741 }
742 if (tx_stat & F_TMT_RDY) {
743 dev->stats.tx_packets += lp->sent ;
744 lp->sent = 0 ;
745 if (lp->tx_queue) {
746 outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
747 lp->sent = lp->tx_queue ;
748 lp->tx_queue = 0;
749 lp->tx_queue_len = 0;
750 dev->trans_start = jiffies;
751 } else {
752 lp->tx_started = 0;
753 }
754 netif_wake_queue(dev);
755 }
756 pr_debug("%s: exiting interrupt,\n", dev->name);
757 pr_debug(" tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
758
759 outb(D_TX_INTR, ioaddr + TX_INTR);
760 outb(D_RX_INTR, ioaddr + RX_INTR);
761
762 if (lp->base != NULL) {
763
764 writeb(0x01, lp->base+0x802);
765 writeb(0x09, lp->base+0x822);
766 }
767
768 return IRQ_HANDLED;
769
770}
771
772
773
774static void fjn_tx_timeout(struct net_device *dev)
775{
776 struct local_info_t *lp = netdev_priv(dev);
777 unsigned int ioaddr = dev->base_addr;
778
779 netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
780 htons(inw(ioaddr + TX_STATUS)),
781 inb(ioaddr + TX_STATUS) & F_TMT_RDY
782 ? "IRQ conflict" : "network cable problem");
783 netdev_notice(dev, "timeout registers: %04x %04x %04x "
784 "%04x %04x %04x %04x %04x.\n",
785 htons(inw(ioaddr + 0)), htons(inw(ioaddr + 2)),
786 htons(inw(ioaddr + 4)), htons(inw(ioaddr + 6)),
787 htons(inw(ioaddr + 8)), htons(inw(ioaddr + 10)),
788 htons(inw(ioaddr + 12)), htons(inw(ioaddr + 14)));
789 dev->stats.tx_errors++;
790
791 local_irq_disable();
792 fjn_reset(dev);
793
794 lp->tx_started = 0;
795 lp->tx_queue = 0;
796 lp->tx_queue_len = 0;
797 lp->sent = 0;
798 lp->open_time = jiffies;
799 local_irq_enable();
800 netif_wake_queue(dev);
801}
802
803static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
804 struct net_device *dev)
805{
806 struct local_info_t *lp = netdev_priv(dev);
807 unsigned int ioaddr = dev->base_addr;
808 short length = skb->len;
809
810 if (length < ETH_ZLEN)
811 {
812 if (skb_padto(skb, ETH_ZLEN))
813 return NETDEV_TX_OK;
814 length = ETH_ZLEN;
815 }
816
817 netif_stop_queue(dev);
818
819 {
820 unsigned char *buf = skb->data;
821
822 if (length > ETH_FRAME_LEN) {
823 netdev_notice(dev, "Attempting to send a large packet (%d bytes)\n",
824 length);
825 return NETDEV_TX_BUSY;
826 }
827
828 netdev_dbg(dev, "Transmitting a packet of length %lu\n",
829 (unsigned long)skb->len);
830 dev->stats.tx_bytes += skb->len;
831
832
833 outw(0x0000, ioaddr + TX_INTR);
834
835
836 udelay(1);
837
838 outw(length, ioaddr + DATAPORT);
839 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
840
841 lp->tx_queue++;
842 lp->tx_queue_len += ((length+3) & ~1);
843
844 if (lp->tx_started == 0) {
845
846 outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
847 lp->sent = lp->tx_queue ;
848 lp->tx_queue = 0;
849 lp->tx_queue_len = 0;
850 lp->tx_started = 1;
851 netif_start_queue(dev);
852 } else {
853 if( sram_config == 0 ) {
854 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
855
856 netif_start_queue(dev);
857 } else {
858 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
859 lp->tx_queue < 127 )
860
861 netif_start_queue(dev);
862 }
863 }
864
865
866 outb(D_TX_INTR, ioaddr + TX_INTR);
867 outb(D_RX_INTR, ioaddr + RX_INTR);
868 }
869 dev_kfree_skb (skb);
870
871 return NETDEV_TX_OK;
872}
873
874
875
876static void fjn_reset(struct net_device *dev)
877{
878 struct local_info_t *lp = netdev_priv(dev);
879 unsigned int ioaddr = dev->base_addr;
880 int i;
881
882 netdev_dbg(dev, "fjn_reset() called\n");
883
884
885 if( sram_config == 0 )
886 outb(CONFIG0_RST, ioaddr + CONFIG_0);
887 else
888 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
889
890
891 if (lp->cardtype == MBH10302)
892 outb(BANK_0, ioaddr + CONFIG_1);
893 else
894 outb(BANK_0U, ioaddr + CONFIG_1);
895
896
897 outb(D_TX_MODE, ioaddr + TX_MODE);
898
899 outb(ID_MATCHED, ioaddr + RX_MODE);
900
901
902 for (i = 0; i < 6; i++)
903 outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
904
905
906 set_rx_mode(dev);
907
908
909 if (lp->cardtype == MBH10302)
910 outb(BANK_2, ioaddr + CONFIG_1);
911 else
912 outb(BANK_2U, ioaddr + CONFIG_1);
913
914
915 if( lp->cardtype == TDK || lp->cardtype == CONTEC)
916 outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
917 else
918 outb(AUTO_MODE, ioaddr + COL_CTRL);
919
920
921 outb(0x00, ioaddr + BMPR12);
922 outb(0x00, ioaddr + BMPR13);
923
924
925 outb(0x01, ioaddr + RX_SKIP);
926
927
928 if( sram_config == 0 )
929 outb(CONFIG0_DFL, ioaddr + CONFIG_0);
930 else
931 outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
932
933
934 inw(ioaddr + DATAPORT);
935 inw(ioaddr + DATAPORT);
936
937
938 outb(0xff, ioaddr + TX_STATUS);
939 outb(0xff, ioaddr + RX_STATUS);
940
941 if (lp->cardtype == MBH10302)
942 outb(INTR_OFF, ioaddr + LAN_CTRL);
943
944
945 outb(D_TX_INTR, ioaddr + TX_INTR);
946 outb(D_RX_INTR, ioaddr + RX_INTR);
947
948
949 if (lp->cardtype == MBH10302)
950 outb(INTR_ON, ioaddr + LAN_CTRL);
951}
952
953
954
955static void fjn_rx(struct net_device *dev)
956{
957 unsigned int ioaddr = dev->base_addr;
958 int boguscount = 10;
959
960 pr_debug("%s: in rx_packet(), rx_status %02x.\n",
961 dev->name, inb(ioaddr + RX_STATUS));
962
963 while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
964 u_short status = inw(ioaddr + DATAPORT);
965
966 netdev_dbg(dev, "Rxing packet mode %02x status %04x.\n",
967 inb(ioaddr + RX_MODE), status);
968#ifndef final_version
969 if (status == 0) {
970 outb(F_SKP_PKT, ioaddr + RX_SKIP);
971 break;
972 }
973#endif
974 if ((status & 0xF0) != 0x20) {
975 dev->stats.rx_errors++;
976 if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
977 if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
978 if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
979 if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
980 } else {
981 u_short pkt_len = inw(ioaddr + DATAPORT);
982
983 struct sk_buff *skb;
984
985 if (pkt_len > 1550) {
986 netdev_notice(dev, "The FMV-18x claimed a very large packet, size %d\n",
987 pkt_len);
988 outb(F_SKP_PKT, ioaddr + RX_SKIP);
989 dev->stats.rx_errors++;
990 break;
991 }
992 skb = netdev_alloc_skb(dev, pkt_len + 2);
993 if (skb == NULL) {
994 outb(F_SKP_PKT, ioaddr + RX_SKIP);
995 dev->stats.rx_dropped++;
996 break;
997 }
998
999 skb_reserve(skb, 2);
1000 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1001 (pkt_len + 1) >> 1);
1002 skb->protocol = eth_type_trans(skb, dev);
1003
1004 {
1005 int i;
1006 pr_debug("%s: Rxed packet of length %d: ",
1007 dev->name, pkt_len);
1008 for (i = 0; i < 14; i++)
1009 pr_debug(" %02x", skb->data[i]);
1010 pr_debug(".\n");
1011 }
1012
1013 netif_rx(skb);
1014 dev->stats.rx_packets++;
1015 dev->stats.rx_bytes += pkt_len;
1016 }
1017 if (--boguscount <= 0)
1018 break;
1019 }
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039}
1040
1041
1042
1043static void netdev_get_drvinfo(struct net_device *dev,
1044 struct ethtool_drvinfo *info)
1045{
1046 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1047 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1048 snprintf(info->bus_info, sizeof(info->bus_info),
1049 "PCMCIA 0x%lx", dev->base_addr);
1050}
1051
1052static const struct ethtool_ops netdev_ethtool_ops = {
1053 .get_drvinfo = netdev_get_drvinfo,
1054};
1055
1056static int fjn_config(struct net_device *dev, struct ifmap *map){
1057 return 0;
1058}
1059
1060static int fjn_open(struct net_device *dev)
1061{
1062 struct local_info_t *lp = netdev_priv(dev);
1063 struct pcmcia_device *link = lp->p_dev;
1064
1065 pr_debug("fjn_open('%s').\n", dev->name);
1066
1067 if (!pcmcia_dev_present(link))
1068 return -ENODEV;
1069
1070 link->open++;
1071
1072 fjn_reset(dev);
1073
1074 lp->tx_started = 0;
1075 lp->tx_queue = 0;
1076 lp->tx_queue_len = 0;
1077 lp->open_time = jiffies;
1078 netif_start_queue(dev);
1079
1080 return 0;
1081}
1082
1083
1084
1085static int fjn_close(struct net_device *dev)
1086{
1087 struct local_info_t *lp = netdev_priv(dev);
1088 struct pcmcia_device *link = lp->p_dev;
1089 unsigned int ioaddr = dev->base_addr;
1090
1091 pr_debug("fjn_close('%s').\n", dev->name);
1092
1093 lp->open_time = 0;
1094 netif_stop_queue(dev);
1095
1096
1097 if( sram_config == 0 )
1098 outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1099 else
1100 outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1101
1102
1103
1104
1105 outb(CHIP_OFF ,ioaddr + CONFIG_1);
1106
1107
1108 if (lp->cardtype == MBH10302)
1109 outb(INTR_OFF, ioaddr + LAN_CTRL);
1110
1111 link->open--;
1112
1113 return 0;
1114}
1115
1116
1117
1118
1119
1120
1121
1122static void set_rx_mode(struct net_device *dev)
1123{
1124 unsigned int ioaddr = dev->base_addr;
1125 u_char mc_filter[8];
1126 u_long flags;
1127 int i;
1128
1129 int saved_bank;
1130 int saved_config_0 = inb(ioaddr + CONFIG_0);
1131
1132 local_irq_save(flags);
1133
1134
1135 if (sram_config == 0)
1136 outb(CONFIG0_RST, ioaddr + CONFIG_0);
1137 else
1138 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1139
1140 if (dev->flags & IFF_PROMISC) {
1141 memset(mc_filter, 0xff, sizeof(mc_filter));
1142 outb(3, ioaddr + RX_MODE);
1143 } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1144 (dev->flags & IFF_ALLMULTI)) {
1145
1146 memset(mc_filter, 0xff, sizeof(mc_filter));
1147 outb(2, ioaddr + RX_MODE);
1148 } else if (netdev_mc_empty(dev)) {
1149 memset(mc_filter, 0x00, sizeof(mc_filter));
1150 outb(1, ioaddr + RX_MODE);
1151 } else {
1152 struct netdev_hw_addr *ha;
1153
1154 memset(mc_filter, 0, sizeof(mc_filter));
1155 netdev_for_each_mc_addr(ha, dev) {
1156 unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1157 mc_filter[bit >> 3] |= (1 << (bit & 7));
1158 }
1159 outb(2, ioaddr + RX_MODE);
1160 }
1161
1162
1163 saved_bank = inb(ioaddr + CONFIG_1);
1164 outb(0xe4, ioaddr + CONFIG_1);
1165
1166 for (i = 0; i < 8; i++)
1167 outb(mc_filter[i], ioaddr + MAR_ADR + i);
1168 outb(saved_bank, ioaddr + CONFIG_1);
1169
1170 outb(saved_config_0, ioaddr + CONFIG_0);
1171
1172 local_irq_restore(flags);
1173}
1174