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