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