?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[netdrvr fmvj18x_cs] fix multicast bug
[firewire-audio.git] / drivers / net / pcmcia / fmvj18x_cs.c
blob356f509092221de4b610f5be6aaf52227df975a6
1 /*======================================================================
2 fmvj18x_cs.c 2.8 2002/03/23
3
4 A fmvj18x (and its compatibles) PCMCIA client driver
5
6 Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
7
8 TDK LAK-CD021 and CONTEC C-NET(PC)C support added by
9 Nobuhiro Katayama, kata-n@po.iijnet.or.jp
10
11 The PCMCIA client code is based on code written by David Hinds.
12 Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
13 but is actually largely Donald Becker's AT1700 driver, which
14 carries the following attribution:
15
16 Written 1993-94 by Donald Becker.
17
18 Copyright 1993 United States Government as represented by the
19 Director, National Security Agency.
20
21 This software may be used and distributed according to the terms
22 of the GNU General Public License, incorporated herein by reference.
23
24 The author may be reached as becker@scyld.com, or C/O
25 Scyld Computing Corporation
26 410 Severn Ave., Suite 210
27 Annapolis MD 21403
28
29 ======================================================================*/
30
31 #define DRV_NAME "fmvj18x_cs"
32 #define DRV_VERSION "2.8"
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 /* Module parameters */
65
66 MODULE_DESCRIPTION("fmvj18x and compatible PCMCIA ethernet driver");
67 MODULE_LICENSE("GPL");
68
69 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
70
71 /* SRAM configuration */
72 /* 0:4KB*2 TX buffer else:8KB*2 TX buffer */
73 INT_MODULE_PARM(sram_config, 0);
74
75 #ifdef PCMCIA_DEBUG
76 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
77 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
78 static char *version = DRV_NAME ".c " DRV_VERSION " 2002/03/23";
79 #else
80 #define DEBUG(n, args...)
81 #endif
82
83 /*====================================================================*/
84 /*
85 PCMCIA event handlers
86 */
87 static void fmvj18x_config(dev_link_t *link);
88 static int fmvj18x_get_hwinfo(dev_link_t *link, u_char *node_id);
89 static int fmvj18x_setup_mfc(dev_link_t *link);
90 static void fmvj18x_release(dev_link_t *link);
91 static int fmvj18x_event(event_t event, int priority,
92 event_callback_args_t *args);
93 static dev_link_t *fmvj18x_attach(void);
94 static void fmvj18x_detach(dev_link_t *);
95
96 /*
97 LAN controller(MBH86960A) specific routines
98 */
99 static int fjn_config(struct net_device *dev, struct ifmap *map);
100 static int fjn_open(struct net_device *dev);
101 static int fjn_close(struct net_device *dev);
102 static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev);
103 static irqreturn_t fjn_interrupt(int irq, void *dev_id, struct pt_regs *regs);
104 static void fjn_rx(struct net_device *dev);
105 static void fjn_reset(struct net_device *dev);
106 static struct net_device_stats *fjn_get_stats(struct net_device *dev);
107 static void set_rx_mode(struct net_device *dev);
108 static void fjn_tx_timeout(struct net_device *dev);
109 static struct ethtool_ops netdev_ethtool_ops;
110
111 static dev_info_t dev_info = "fmvj18x_cs";
112 static dev_link_t *dev_list;
113
114 /*
115 card type
116 */
117 typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
118 XXX10304
119 } cardtype_t;
120
121 /*
122 driver specific data structure
123 */
124 typedef struct local_info_t {
125 dev_link_t link;
126 dev_node_t node;
127 struct net_device_stats stats;
128 long open_time;
129 uint tx_started:1;
130 uint tx_queue;
131 u_short tx_queue_len;
132 cardtype_t cardtype;
133 u_short sent;
134 } local_info_t;
135
136 #define MC_FILTERBREAK 64
137
138 /*====================================================================*/
139 /*
140 ioport offset from the base address
141 */
142 #define TX_STATUS 0 /* transmit status register */
143 #define RX_STATUS 1 /* receive status register */
144 #define TX_INTR 2 /* transmit interrupt mask register */
145 #define RX_INTR 3 /* receive interrupt mask register */
146 #define TX_MODE 4 /* transmit mode register */
147 #define RX_MODE 5 /* receive mode register */
148 #define CONFIG_0 6 /* configuration register 0 */
149 #define CONFIG_1 7 /* configuration register 1 */
150
151 #define NODE_ID 8 /* node ID register (bank 0) */
152 #define MAR_ADR 8 /* multicast address registers (bank 1) */
153
154 #define DATAPORT 8 /* buffer mem port registers (bank 2) */
155 #define TX_START 10 /* transmit start register */
156 #define COL_CTRL 11 /* 16 collision control register */
157 #define BMPR12 12 /* reserved */
158 #define BMPR13 13 /* reserved */
159 #define RX_SKIP 14 /* skip received packet register */
160
161 #define LAN_CTRL 16 /* LAN card control register */
162
163 #define MAC_ID 0x1a /* hardware address */
164 #define UNGERMANN_MAC_ID 0x18 /* UNGERMANN-BASS hardware address */
165
166 /*
167 control bits
168 */
169 #define ENA_TMT_OK 0x80
170 #define ENA_TMT_REC 0x20
171 #define ENA_COL 0x04
172 #define ENA_16_COL 0x02
173 #define ENA_TBUS_ERR 0x01
174
175 #define ENA_PKT_RDY 0x80
176 #define ENA_BUS_ERR 0x40
177 #define ENA_LEN_ERR 0x08
178 #define ENA_ALG_ERR 0x04
179 #define ENA_CRC_ERR 0x02
180 #define ENA_OVR_FLO 0x01
181
182 /* flags */
183 #define F_TMT_RDY 0x80 /* can accept new packet */
184 #define F_NET_BSY 0x40 /* carrier is detected */
185 #define F_TMT_OK 0x20 /* send packet successfully */
186 #define F_SRT_PKT 0x10 /* short packet error */
187 #define F_COL_ERR 0x04 /* collision error */
188 #define F_16_COL 0x02 /* 16 collision error */
189 #define F_TBUS_ERR 0x01 /* bus read error */
190
191 #define F_PKT_RDY 0x80 /* packet(s) in buffer */
192 #define F_BUS_ERR 0x40 /* bus read error */
193 #define F_LEN_ERR 0x08 /* short packet */
194 #define F_ALG_ERR 0x04 /* frame error */
195 #define F_CRC_ERR 0x02 /* CRC error */
196 #define F_OVR_FLO 0x01 /* overflow error */
197
198 #define F_BUF_EMP 0x40 /* receive buffer is empty */
199
200 #define F_SKP_PKT 0x05 /* drop packet in buffer */
201
202 /* default bitmaps */
203 #define D_TX_INTR ( ENA_TMT_OK )
204 #define D_RX_INTR ( ENA_PKT_RDY | ENA_LEN_ERR \
205 | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
206 #define TX_STAT_M ( F_TMT_RDY )
207 #define RX_STAT_M ( F_PKT_RDY | F_LEN_ERR \
208 | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
209
210 /* commands */
211 #define D_TX_MODE 0x06 /* no tests, detect carrier */
212 #define ID_MATCHED 0x02 /* (RX_MODE) */
213 #define RECV_ALL 0x03 /* (RX_MODE) */
214 #define CONFIG0_DFL 0x5a /* 16bit bus, 4K x 2 Tx queues */
215 #define CONFIG0_DFL_1 0x5e /* 16bit bus, 8K x 2 Tx queues */
216 #define CONFIG0_RST 0xda /* Data Link Controller off (CONFIG_0) */
217 #define CONFIG0_RST_1 0xde /* Data Link Controller off (CONFIG_0) */
218 #define BANK_0 0xa0 /* bank 0 (CONFIG_1) */
219 #define BANK_1 0xa4 /* bank 1 (CONFIG_1) */
220 #define BANK_2 0xa8 /* bank 2 (CONFIG_1) */
221 #define CHIP_OFF 0x80 /* contrl chip power off (CONFIG_1) */
222 #define DO_TX 0x80 /* do transmit packet */
223 #define SEND_PKT 0x81 /* send a packet */
224 #define AUTO_MODE 0x07 /* Auto skip packet on 16 col detected */
225 #define MANU_MODE 0x03 /* Stop and skip packet on 16 col */
226 #define TDK_AUTO_MODE 0x47 /* Auto skip packet on 16 col detected */
227 #define TDK_MANU_MODE 0x43 /* Stop and skip packet on 16 col */
228 #define INTR_OFF 0x0d /* LAN controller ignores interrupts */
229 #define INTR_ON 0x1d /* LAN controller will catch interrupts */
230
231 #define TX_TIMEOUT ((400*HZ)/1000)
232
233 #define BANK_0U 0x20 /* bank 0 (CONFIG_1) */
234 #define BANK_1U 0x24 /* bank 1 (CONFIG_1) */
235 #define BANK_2U 0x28 /* bank 2 (CONFIG_1) */
236
237 static dev_link_t *fmvj18x_attach(void)
238 {
239 local_info_t *lp;
240 dev_link_t *link;
241 struct net_device *dev;
242 client_reg_t client_reg;
243 int ret;
244
245 DEBUG(0, "fmvj18x_attach()\n");
246
247 /* Make up a FMVJ18x specific data structure */
248 dev = alloc_etherdev(sizeof(local_info_t));
249 if (!dev)
250 return NULL;
251 lp = netdev_priv(dev);
252 link = &lp->link;
253 link->priv = dev;
254
255 /* The io structure describes IO port mapping */
256 link->io.NumPorts1 = 32;
257 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
258 link->io.IOAddrLines = 5;
259
260 /* Interrupt setup */
261 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
262 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
263 link->irq.Handler = &fjn_interrupt;
264 link->irq.Instance = dev;
265
266 /* General socket configuration */
267 link->conf.Attributes = CONF_ENABLE_IRQ;
268 link->conf.Vcc = 50;
269 link->conf.IntType = INT_MEMORY_AND_IO;
270
271 /* The FMVJ18x specific entries in the device structure. */
272 SET_MODULE_OWNER(dev);
273 dev->hard_start_xmit = &fjn_start_xmit;
274 dev->set_config = &fjn_config;
275 dev->get_stats = &fjn_get_stats;
276 dev->set_multicast_list = &set_rx_mode;
277 dev->open = &fjn_open;
278 dev->stop = &fjn_close;
279 #ifdef HAVE_TX_TIMEOUT
280 dev->tx_timeout = fjn_tx_timeout;
281 dev->watchdog_timeo = TX_TIMEOUT;
282 #endif
283 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
284
285 /* Register with Card Services */
286 link->next = dev_list;
287 dev_list = link;
288 client_reg.dev_info = &dev_info;
289 client_reg.Version = 0x0210;
290 client_reg.event_callback_args.client_data = link;
291 ret = pcmcia_register_client(&link->handle, &client_reg);
292 if (ret != 0) {
293 cs_error(link->handle, RegisterClient, ret);
294 fmvj18x_detach(link);
295 return NULL;
296 }
297
298 return link;
299 } /* fmvj18x_attach */
300
301 /*====================================================================*/
302
303 static void fmvj18x_detach(dev_link_t *link)
304 {
305 struct net_device *dev = link->priv;
306 dev_link_t **linkp;
307
308 DEBUG(0, "fmvj18x_detach(0x%p)\n", link);
309
310 /* Locate device structure */
311 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
312 if (*linkp == link) break;
313 if (*linkp == NULL)
314 return;
315
316 if (link->dev)
317 unregister_netdev(dev);
318
319 if (link->state & DEV_CONFIG)
320 fmvj18x_release(link);
321
322 /* Break the link with Card Services */
323 if (link->handle)
324 pcmcia_deregister_client(link->handle);
325
326 /* Unlink device structure, free pieces */
327 *linkp = link->next;
328 free_netdev(dev);
329 } /* fmvj18x_detach */
330
331 /*====================================================================*/
332
333 #define CS_CHECK(fn, ret) \
334 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
335
336 static int mfc_try_io_port(dev_link_t *link)
337 {
338 int i, ret;
339 static kio_addr_t serial_base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
340
341 for (i = 0; i < 5; i++) {
342 link->io.BasePort2 = serial_base[i];
343 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
344 if (link->io.BasePort2 == 0) {
345 link->io.NumPorts2 = 0;
346 printk(KERN_NOTICE "fmvj18x_cs: out of resource for serial\n");
347 }
348 ret = pcmcia_request_io(link->handle, &link->io);
349 if (ret == CS_SUCCESS) return ret;
350 }
351 return ret;
352 }
353
354 static int ungermann_try_io_port(dev_link_t *link)
355 {
356 int ret;
357 kio_addr_t ioaddr;
358 /*
359 Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
360 0x380,0x3c0 only for ioport.
361 */
362 for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
363 link->io.BasePort1 = ioaddr;
364 ret = pcmcia_request_io(link->handle, &link->io);
365 if (ret == CS_SUCCESS) {
366 /* calculate ConfigIndex value */
367 link->conf.ConfigIndex =
368 ((link->io.BasePort1 & 0x0f0) >> 3) | 0x22;
369 return ret;
370 }
371 }
372 return ret; /* RequestIO failed */
373 }
374
375 static void fmvj18x_config(dev_link_t *link)
376 {
377 client_handle_t handle = link->handle;
378 struct net_device *dev = link->priv;
379 local_info_t *lp = netdev_priv(dev);
380 tuple_t tuple;
381 cisparse_t parse;
382 u_short buf[32];
383 int i, last_fn, last_ret, ret;
384 kio_addr_t ioaddr;
385 cardtype_t cardtype;
386 char *card_name = "unknown";
387 u_char *node_id;
388
389 DEBUG(0, "fmvj18x_config(0x%p)\n", link);
390
391 /*
392 This reads the card's CONFIG tuple to find its configuration
393 registers.
394 */
395 tuple.DesiredTuple = CISTPL_CONFIG;
396 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
397 tuple.TupleData = (u_char *)buf;
398 tuple.TupleDataMax = 64;
399 tuple.TupleOffset = 0;
400 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
401 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
402
403 /* Configure card */
404 link->state |= DEV_CONFIG;
405
406 link->conf.ConfigBase = parse.config.base;
407 link->conf.Present = parse.config.rmask[0];
408
409 tuple.DesiredTuple = CISTPL_FUNCE;
410 tuple.TupleOffset = 0;
411 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
412 /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
413 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
414 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
415 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
416 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
417 link->conf.ConfigIndex = parse.cftable_entry.index;
418 tuple.DesiredTuple = CISTPL_MANFID;
419 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS)
420 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
421 else
422 buf[0] = 0xffff;
423 switch (le16_to_cpu(buf[0])) {
424 case MANFID_TDK:
425 cardtype = TDK;
426 if (le16_to_cpu(buf[1]) == PRODID_TDK_CF010) {
427 cs_status_t status;
428 pcmcia_get_status(handle, &status);
429 if (status.CardState & CS_EVENT_3VCARD)
430 link->conf.Vcc = 33; /* inserted in 3.3V slot */
431 } else if (le16_to_cpu(buf[1]) == PRODID_TDK_GN3410
432 || le16_to_cpu(buf[1]) == PRODID_TDK_NP9610
433 || le16_to_cpu(buf[1]) == PRODID_TDK_MN3200) {
434 /* MultiFunction Card */
435 link->conf.ConfigBase = 0x800;
436 link->conf.ConfigIndex = 0x47;
437 link->io.NumPorts2 = 8;
438 }
439 break;
440 case MANFID_CONTEC:
441 cardtype = CONTEC;
442 break;
443 case MANFID_FUJITSU:
444 if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10302)
445 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
446 but these are MBH10304 based card. */
447 cardtype = MBH10304;
448 else if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10304)
449 cardtype = MBH10304;
450 else
451 cardtype = LA501;
452 break;
453 default:
454 cardtype = MBH10304;
455 }
456 } else {
457 /* old type card */
458 tuple.DesiredTuple = CISTPL_MANFID;
459 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS)
460 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
461 else
462 buf[0] = 0xffff;
463 switch (le16_to_cpu(buf[0])) {
464 case MANFID_FUJITSU:
465 if (le16_to_cpu(buf[1]) == PRODID_FUJITSU_MBH10304) {
466 cardtype = XXX10304; /* MBH10304 with buggy CIS */
467 link->conf.ConfigIndex = 0x20;
468 } else {
469 cardtype = MBH10302; /* NextCom NC5310, etc. */
470 link->conf.ConfigIndex = 1;
471 }
472 break;
473 case MANFID_UNGERMANN:
474 cardtype = UNGERMANN;
475 break;
476 default:
477 cardtype = MBH10302;
478 link->conf.ConfigIndex = 1;
479 }
480 }
481
482 if (link->io.NumPorts2 != 0) {
483 link->irq.Attributes =
484 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
485 ret = mfc_try_io_port(link);
486 if (ret != CS_SUCCESS) goto cs_failed;
487 } else if (cardtype == UNGERMANN) {
488 ret = ungermann_try_io_port(link);
489 if (ret != CS_SUCCESS) goto cs_failed;
490 } else {
491 CS_CHECK(RequestIO, pcmcia_request_io(link->handle, &link->io));
492 }
493 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
494 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
495 dev->irq = link->irq.AssignedIRQ;
496 dev->base_addr = link->io.BasePort1;
497
498 if (link->io.BasePort2 != 0)
499 fmvj18x_setup_mfc(link);
500
501 ioaddr = dev->base_addr;
502
503 /* Reset controller */
504 if (sram_config == 0)
505 outb(CONFIG0_RST, ioaddr + CONFIG_0);
506 else
507 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
508
509 /* Power On chip and select bank 0 */
510 if (cardtype == MBH10302)
511 outb(BANK_0, ioaddr + CONFIG_1);
512 else
513 outb(BANK_0U, ioaddr + CONFIG_1);
514
515 /* Set hardware address */
516 switch (cardtype) {
517 case MBH10304:
518 case TDK:
519 case LA501:
520 case CONTEC:
521 tuple.DesiredTuple = CISTPL_FUNCE;
522 tuple.TupleOffset = 0;
523 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
524 tuple.TupleOffset = 0;
525 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
526 if (cardtype == MBH10304) {
527 /* MBH10304's CIS_FUNCE is corrupted */
528 node_id = &(tuple.TupleData[5]);
529 card_name = "FMV-J182";
530 } else {
531 while (tuple.TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID ) {
532 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
533 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
534 }
535 node_id = &(tuple.TupleData[2]);
536 if( cardtype == TDK ) {
537 card_name = "TDK LAK-CD021";
538 } else if( cardtype == LA501 ) {
539 card_name = "LA501";
540 } else {
541 card_name = "C-NET(PC)C";
542 }
543 }
544 /* Read MACID from CIS */
545 for (i = 0; i < 6; i++)
546 dev->dev_addr[i] = node_id[i];
547 break;
548 case UNGERMANN:
549 /* Read MACID from register */
550 for (i = 0; i < 6; i++)
551 dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
552 card_name = "Access/CARD";
553 break;
554 case XXX10304:
555 /* Read MACID from Buggy CIS */
556 if (fmvj18x_get_hwinfo(link, tuple.TupleData) == -1) {
557 printk(KERN_NOTICE "fmvj18x_cs: unable to read hardware net address.\n");
558 goto failed;
559 }
560 for (i = 0 ; i < 6; i++) {
561 dev->dev_addr[i] = tuple.TupleData[i];
562 }
563 card_name = "FMV-J182";
564 break;
565 case MBH10302:
566 default:
567 /* Read MACID from register */
568 for (i = 0; i < 6; i++)
569 dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
570 card_name = "FMV-J181";
571 break;
572 }
573
574 lp->cardtype = cardtype;
575 link->dev = &lp->node;
576 link->state &= ~DEV_CONFIG_PENDING;
577 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
578
579 if (register_netdev(dev) != 0) {
580 printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failed\n");
581 link->dev = NULL;
582 goto failed;
583 }
584
585 strcpy(lp->node.dev_name, dev->name);
586
587 /* print current configuration */
588 printk(KERN_INFO "%s: %s, sram %s, port %#3lx, irq %d, hw_addr ",
589 dev->name, card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
590 dev->base_addr, dev->irq);
591 for (i = 0; i < 6; i++)
592 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
593
594 return;
595
596 cs_failed:
597 /* All Card Services errors end up here */
598 cs_error(link->handle, last_fn, last_ret);
599 failed:
600 fmvj18x_release(link);
601 link->state &= ~DEV_CONFIG_PENDING;
602
603 } /* fmvj18x_config */
604 /*====================================================================*/
605
606 static int fmvj18x_get_hwinfo(dev_link_t *link, u_char *node_id)
607 {
608 win_req_t req;
609 memreq_t mem;
610 u_char __iomem *base;
611 int i, j;
612
613 /* Allocate a small memory window */
614 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
615 req.Base = 0; req.Size = 0;
616 req.AccessSpeed = 0;
617 i = pcmcia_request_window(&link->handle, &req, &link->win);
618 if (i != CS_SUCCESS) {
619 cs_error(link->handle, RequestWindow, i);
620 return -1;
621 }
622
623 base = ioremap(req.Base, req.Size);
624 mem.Page = 0;
625 mem.CardOffset = 0;
626 pcmcia_map_mem_page(link->win, &mem);
627
628 /*
629 * MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
630 * 22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
631 * 'xx' is garbage.
632 * 'yy' is MAC address.
633 */
634 for (i = 0; i < 0x200; i++) {
635 if (readb(base+i*2) == 0x22) {
636 if (readb(base+(i-1)*2) == 0xff
637 && readb(base+(i+5)*2) == 0x04
638 && readb(base+(i+6)*2) == 0x06
639 && readb(base+(i+13)*2) == 0xff)
640 break;
641 }
642 }
643
644 if (i != 0x200) {
645 for (j = 0 ; j < 6; j++,i++) {
646 node_id[j] = readb(base+(i+7)*2);
647 }
648 }
649
650 iounmap(base);
651 j = pcmcia_release_window(link->win);
652 if (j != CS_SUCCESS)
653 cs_error(link->handle, ReleaseWindow, j);
654 return (i != 0x200) ? 0 : -1;
655
656 } /* fmvj18x_get_hwinfo */
657 /*====================================================================*/
658
659 static int fmvj18x_setup_mfc(dev_link_t *link)
660 {
661 win_req_t req;
662 memreq_t mem;
663 u_char __iomem *base;
664 int i, j;
665 struct net_device *dev = link->priv;
666 kio_addr_t ioaddr;
667
668 /* Allocate a small memory window */
669 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
670 req.Base = 0; req.Size = 0;
671 req.AccessSpeed = 0;
672 i = pcmcia_request_window(&link->handle, &req, &link->win);
673 if (i != CS_SUCCESS) {
674 cs_error(link->handle, RequestWindow, i);
675 return -1;
676 }
677
678 base = ioremap(req.Base, req.Size);
679 mem.Page = 0;
680 mem.CardOffset = 0;
681 pcmcia_map_mem_page(link->win, &mem);
682
683 ioaddr = dev->base_addr;
684 writeb(0x47, base+0x800); /* Config Option Register of LAN */
685 writeb(0x0, base+0x802); /* Config and Status Register */
686
687 writeb(ioaddr & 0xff, base+0x80a); /* I/O Base(Low) of LAN */
688 writeb((ioaddr >> 8) & 0xff, base+0x80c); /* I/O Base(High) of LAN */
689
690 writeb(0x45, base+0x820); /* Config Option Register of Modem */
691 writeb(0x8, base+0x822); /* Config and Status Register */
692
693 iounmap(base);
694 j = pcmcia_release_window(link->win);
695 if (j != CS_SUCCESS)
696 cs_error(link->handle, ReleaseWindow, j);
697 return 0;
698
699 }
700 /*====================================================================*/
701
702 static void fmvj18x_release(dev_link_t *link)
703 {
704
705 DEBUG(0, "fmvj18x_release(0x%p)\n", link);
706
707 /* Don't bother checking to see if these succeed or not */
708 pcmcia_release_window(link->win);
709 pcmcia_release_configuration(link->handle);
710 pcmcia_release_io(link->handle, &link->io);
711 pcmcia_release_irq(link->handle, &link->irq);
712
713 link->state &= ~DEV_CONFIG;
714 }
715
716 /*====================================================================*/
717
718 static int fmvj18x_event(event_t event, int priority,
719 event_callback_args_t *args)
720 {
721 dev_link_t *link = args->client_data;
722 struct net_device *dev = link->priv;
723
724 DEBUG(1, "fmvj18x_event(0x%06x)\n", event);
725
726 switch (event) {
727 case CS_EVENT_CARD_REMOVAL:
728 link->state &= ~DEV_PRESENT;
729 if (link->state & DEV_CONFIG)
730 netif_device_detach(dev);
731 break;
732 case CS_EVENT_CARD_INSERTION:
733 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
734 fmvj18x_config(link);
735 break;
736 case CS_EVENT_PM_SUSPEND:
737 link->state |= DEV_SUSPEND;
738 /* Fall through... */
739 case CS_EVENT_RESET_PHYSICAL:
740 if (link->state & DEV_CONFIG) {
741 if (link->open)
742 netif_device_detach(dev);
743 pcmcia_release_configuration(link->handle);
744 }
745 break;
746 case CS_EVENT_PM_RESUME:
747 link->state &= ~DEV_SUSPEND;
748 /* Fall through... */
749 case CS_EVENT_CARD_RESET:
750 if (link->state & DEV_CONFIG) {
751 pcmcia_request_configuration(link->handle, &link->conf);
752 if (link->open) {
753 fjn_reset(dev);
754 netif_device_attach(dev);
755 }
756 }
757 break;
758 }
759 return 0;
760 } /* fmvj18x_event */
761
762 static struct pcmcia_device_id fmvj18x_ids[] = {
763 PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
764 PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
765 PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
766 PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
767 PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
768 PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
769 PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
770 PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
771 PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0 ", 0x8cef4d3a, 0x075fc7b6),
772 PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0 ", 0x8cef4d3a, 0xbccf43e6),
773 PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
774 PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
775 PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
776 PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
777 PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304 ES", 0x2599f454),
778 PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
779 PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
780 PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
781 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
782 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
783 PCMCIA_DEVICE_NULL,
784 };
785 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
786
787 static struct pcmcia_driver fmvj18x_cs_driver = {
788 .owner = THIS_MODULE,
789 .drv = {
790 .name = "fmvj18x_cs",
791 },
792 .attach = fmvj18x_attach,
793 .event = fmvj18x_event,
794 .detach = fmvj18x_detach,
795 .id_table = fmvj18x_ids,
796 };
797
798 static int __init init_fmvj18x_cs(void)
799 {
800 return pcmcia_register_driver(&fmvj18x_cs_driver);
801 }
802
803 static void __exit exit_fmvj18x_cs(void)
804 {
805 pcmcia_unregister_driver(&fmvj18x_cs_driver);
806 BUG_ON(dev_list != NULL);
807 }
808
809 module_init(init_fmvj18x_cs);
810 module_exit(exit_fmvj18x_cs);
811
812 /*====================================================================*/
813
814 static irqreturn_t fjn_interrupt(int irq, void *dev_id, struct pt_regs *regs)
815 {
816 struct net_device *dev = dev_id;
817 local_info_t *lp = netdev_priv(dev);
818 kio_addr_t ioaddr;
819 unsigned short tx_stat, rx_stat;
820
821 if (lp == NULL) {
822 printk(KERN_NOTICE "fjn_interrupt(): irq %d for "
823 "unknown device.\n", irq);
824 return IRQ_NONE;
825 }
826 ioaddr = dev->base_addr;
827
828 /* avoid multiple interrupts */
829 outw(0x0000, ioaddr + TX_INTR);
830
831 /* wait for a while */
832 udelay(1);
833
834 /* get status */
835 tx_stat = inb(ioaddr + TX_STATUS);
836 rx_stat = inb(ioaddr + RX_STATUS);
837
838 /* clear status */
839 outb(tx_stat, ioaddr + TX_STATUS);
840 outb(rx_stat, ioaddr + RX_STATUS);
841
842 DEBUG(4, "%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
843 DEBUG(4, " tx_status %02x.\n", tx_stat);
844
845 if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
846 /* there is packet(s) in rx buffer */
847 fjn_rx(dev);
848 }
849 if (tx_stat & F_TMT_RDY) {
850 lp->stats.tx_packets += lp->sent ;
851 lp->sent = 0 ;
852 if (lp->tx_queue) {
853 outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
854 lp->sent = lp->tx_queue ;
855 lp->tx_queue = 0;
856 lp->tx_queue_len = 0;
857 dev->trans_start = jiffies;
858 } else {
859 lp->tx_started = 0;
860 }
861 netif_wake_queue(dev);
862 }
863 DEBUG(4, "%s: exiting interrupt,\n", dev->name);
864 DEBUG(4, " tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
865
866 outb(D_TX_INTR, ioaddr + TX_INTR);
867 outb(D_RX_INTR, ioaddr + RX_INTR);
868 return IRQ_HANDLED;
869
870 } /* fjn_interrupt */
871
872 /*====================================================================*/
873
874 static void fjn_tx_timeout(struct net_device *dev)
875 {
876 struct local_info_t *lp = netdev_priv(dev);
877 kio_addr_t ioaddr = dev->base_addr;
878
879 printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?\n",
880 dev->name, htons(inw(ioaddr + TX_STATUS)),
881 inb(ioaddr + TX_STATUS) & F_TMT_RDY
882 ? "IRQ conflict" : "network cable problem");
883 printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
884 "%04x %04x %04x %04x %04x.\n",
885 dev->name, htons(inw(ioaddr + 0)),
886 htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
887 htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
888 htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
889 htons(inw(ioaddr +14)));
890 lp->stats.tx_errors++;
891 /* ToDo: We should try to restart the adaptor... */
892 local_irq_disable();
893 fjn_reset(dev);
894
895 lp->tx_started = 0;
896 lp->tx_queue = 0;
897 lp->tx_queue_len = 0;
898 lp->sent = 0;
899 lp->open_time = jiffies;
900 local_irq_enable();
901 netif_wake_queue(dev);
902 }
903
904 static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev)
905 {
906 struct local_info_t *lp = netdev_priv(dev);
907 kio_addr_t ioaddr = dev->base_addr;
908 short length = skb->len;
909
910 if (length < ETH_ZLEN)
911 {
912 skb = skb_padto(skb, ETH_ZLEN);
913 if (skb == NULL)
914 return 0;
915 length = ETH_ZLEN;
916 }
917
918 netif_stop_queue(dev);
919
920 {
921 unsigned char *buf = skb->data;
922
923 if (length > ETH_FRAME_LEN) {
924 printk(KERN_NOTICE "%s: Attempting to send a large packet"
925 " (%d bytes).\n", dev->name, length);
926 return 1;
927 }
928
929 DEBUG(4, "%s: Transmitting a packet of length %lu.\n",
930 dev->name, (unsigned long)skb->len);
931 lp->stats.tx_bytes += skb->len;
932
933 /* Disable both interrupts. */
934 outw(0x0000, ioaddr + TX_INTR);
935
936 /* wait for a while */
937 udelay(1);
938
939 outw(length, ioaddr + DATAPORT);
940 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
941
942 lp->tx_queue++;
943 lp->tx_queue_len += ((length+3) & ~1);
944
945 if (lp->tx_started == 0) {
946 /* If the Tx is idle, always trigger a transmit. */
947 outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
948 lp->sent = lp->tx_queue ;
949 lp->tx_queue = 0;
950 lp->tx_queue_len = 0;
951 dev->trans_start = jiffies;
952 lp->tx_started = 1;
953 netif_start_queue(dev);
954 } else {
955 if( sram_config == 0 ) {
956 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
957 /* Yes, there is room for one more packet. */
958 netif_start_queue(dev);
959 } else {
960 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
961 lp->tx_queue < 127 )
962 /* Yes, there is room for one more packet. */
963 netif_start_queue(dev);
964 }
965 }
966
967 /* Re-enable interrupts */
968 outb(D_TX_INTR, ioaddr + TX_INTR);
969 outb(D_RX_INTR, ioaddr + RX_INTR);
970 }
971 dev_kfree_skb (skb);
972
973 return 0;
974 } /* fjn_start_xmit */
975
976 /*====================================================================*/
977
978 static void fjn_reset(struct net_device *dev)
979 {
980 struct local_info_t *lp = netdev_priv(dev);
981 kio_addr_t ioaddr = dev->base_addr;
982 int i;
983
984 DEBUG(4, "fjn_reset(%s) called.\n",dev->name);
985
986 /* Reset controller */
987 if( sram_config == 0 )
988 outb(CONFIG0_RST, ioaddr + CONFIG_0);
989 else
990 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
991
992 /* Power On chip and select bank 0 */
993 if (lp->cardtype == MBH10302)
994 outb(BANK_0, ioaddr + CONFIG_1);
995 else
996 outb(BANK_0U, ioaddr + CONFIG_1);
997
998 /* Set Tx modes */
999 outb(D_TX_MODE, ioaddr + TX_MODE);
1000 /* set Rx modes */
1001 outb(ID_MATCHED, ioaddr + RX_MODE);
1002
1003 /* Set hardware address */
1004 for (i = 0; i < 6; i++)
1005 outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
1006
1007 /* (re)initialize the multicast table */
1008 set_rx_mode(dev);
1009
1010 /* Switch to bank 2 (runtime mode) */
1011 if (lp->cardtype == MBH10302)
1012 outb(BANK_2, ioaddr + CONFIG_1);
1013 else
1014 outb(BANK_2U, ioaddr + CONFIG_1);
1015
1016 /* set 16col ctrl bits */
1017 if( lp->cardtype == TDK || lp->cardtype == CONTEC)
1018 outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
1019 else
1020 outb(AUTO_MODE, ioaddr + COL_CTRL);
1021
1022 /* clear Reserved Regs */
1023 outb(0x00, ioaddr + BMPR12);
1024 outb(0x00, ioaddr + BMPR13);
1025
1026 /* reset Skip packet reg. */
1027 outb(0x01, ioaddr + RX_SKIP);
1028
1029 /* Enable Tx and Rx */
1030 if( sram_config == 0 )
1031 outb(CONFIG0_DFL, ioaddr + CONFIG_0);
1032 else
1033 outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
1034
1035 /* Init receive pointer ? */
1036 inw(ioaddr + DATAPORT);
1037 inw(ioaddr + DATAPORT);
1038
1039 /* Clear all status */
1040 outb(0xff, ioaddr + TX_STATUS);
1041 outb(0xff, ioaddr + RX_STATUS);
1042
1043 if (lp->cardtype == MBH10302)
1044 outb(INTR_OFF, ioaddr + LAN_CTRL);
1045
1046 /* Turn on Rx interrupts */
1047 outb(D_TX_INTR, ioaddr + TX_INTR);
1048 outb(D_RX_INTR, ioaddr + RX_INTR);
1049
1050 /* Turn on interrupts from LAN card controller */
1051 if (lp->cardtype == MBH10302)
1052 outb(INTR_ON, ioaddr + LAN_CTRL);
1053 } /* fjn_reset */
1054
1055 /*====================================================================*/
1056
1057 static void fjn_rx(struct net_device *dev)
1058 {
1059 struct local_info_t *lp = netdev_priv(dev);
1060 kio_addr_t ioaddr = dev->base_addr;
1061 int boguscount = 10; /* 5 -> 10: by agy 19940922 */
1062
1063 DEBUG(4, "%s: in rx_packet(), rx_status %02x.\n",
1064 dev->name, inb(ioaddr + RX_STATUS));
1065
1066 while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
1067 u_short status = inw(ioaddr + DATAPORT);
1068
1069 DEBUG(4, "%s: Rxing packet mode %02x status %04x.\n",
1070 dev->name, inb(ioaddr + RX_MODE), status);
1071 #ifndef final_version
1072 if (status == 0) {
1073 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1074 break;
1075 }
1076 #endif
1077 if ((status & 0xF0) != 0x20) { /* There was an error. */
1078 lp->stats.rx_errors++;
1079 if (status & F_LEN_ERR) lp->stats.rx_length_errors++;
1080 if (status & F_ALG_ERR) lp->stats.rx_frame_errors++;
1081 if (status & F_CRC_ERR) lp->stats.rx_crc_errors++;
1082 if (status & F_OVR_FLO) lp->stats.rx_over_errors++;
1083 } else {
1084 u_short pkt_len = inw(ioaddr + DATAPORT);
1085 /* Malloc up new buffer. */
1086 struct sk_buff *skb;
1087
1088 if (pkt_len > 1550) {
1089 printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
1090 "large packet, size %d.\n", dev->name, pkt_len);
1091 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1092 lp->stats.rx_errors++;
1093 break;
1094 }
1095 skb = dev_alloc_skb(pkt_len+2);
1096 if (skb == NULL) {
1097 printk(KERN_NOTICE "%s: Memory squeeze, dropping "
1098 "packet (len %d).\n", dev->name, pkt_len);
1099 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1100 lp->stats.rx_dropped++;
1101 break;
1102 }
1103 skb->dev = dev;
1104
1105 skb_reserve(skb, 2);
1106 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1107 (pkt_len + 1) >> 1);
1108 skb->protocol = eth_type_trans(skb, dev);
1109
1110 #ifdef PCMCIA_DEBUG
1111 if (pc_debug > 5) {
1112 int i;
1113 printk(KERN_DEBUG "%s: Rxed packet of length %d: ",
1114 dev->name, pkt_len);
1115 for (i = 0; i < 14; i++)
1116 printk(" %02x", skb->data[i]);
1117 printk(".\n");
1118 }
1119 #endif
1120
1121 netif_rx(skb);
1122 dev->last_rx = jiffies;
1123 lp->stats.rx_packets++;
1124 lp->stats.rx_bytes += pkt_len;
1125 }
1126 if (--boguscount <= 0)
1127 break;
1128 }
1129
1130 /* If any worth-while packets have been received, dev_rint()
1131 has done a netif_wake_queue() for us and will work on them
1132 when we get to the bottom-half routine. */
1133 /*
1134 if (lp->cardtype != TDK) {
1135 int i;
1136 for (i = 0; i < 20; i++) {
1137 if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1138 break;
1139 (void)inw(ioaddr + DATAPORT); /+ dummy status read +/
1140 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1141 }
1142
1143 if (i > 0)
1144 DEBUG(5, "%s: Exint Rx packet with mode %02x after "
1145 "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1146 }
1147 */
1148
1149 return;
1150 } /* fjn_rx */
1151
1152 /*====================================================================*/
1153
1154 static void netdev_get_drvinfo(struct net_device *dev,
1155 struct ethtool_drvinfo *info)
1156 {
1157 strcpy(info->driver, DRV_NAME);
1158 strcpy(info->version, DRV_VERSION);
1159 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1160 }
1161
1162 #ifdef PCMCIA_DEBUG
1163 static u32 netdev_get_msglevel(struct net_device *dev)
1164 {
1165 return pc_debug;
1166 }
1167
1168 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1169 {
1170 pc_debug = level;
1171 }
1172 #endif /* PCMCIA_DEBUG */
1173
1174 static struct ethtool_ops netdev_ethtool_ops = {
1175 .get_drvinfo = netdev_get_drvinfo,
1176 #ifdef PCMCIA_DEBUG
1177 .get_msglevel = netdev_get_msglevel,
1178 .set_msglevel = netdev_set_msglevel,
1179 #endif /* PCMCIA_DEBUG */
1180 };
1181
1182 static int fjn_config(struct net_device *dev, struct ifmap *map){
1183 return 0;
1184 }
1185
1186 static int fjn_open(struct net_device *dev)
1187 {
1188 struct local_info_t *lp = netdev_priv(dev);
1189 dev_link_t *link = &lp->link;
1190
1191 DEBUG(4, "fjn_open('%s').\n", dev->name);
1192
1193 if (!DEV_OK(link))
1194 return -ENODEV;
1195
1196 link->open++;
1197
1198 fjn_reset(dev);
1199
1200 lp->tx_started = 0;
1201 lp->tx_queue = 0;
1202 lp->tx_queue_len = 0;
1203 lp->open_time = jiffies;
1204 netif_start_queue(dev);
1205
1206 return 0;
1207 } /* fjn_open */
1208
1209 /*====================================================================*/
1210
1211 static int fjn_close(struct net_device *dev)
1212 {
1213 struct local_info_t *lp = netdev_priv(dev);
1214 dev_link_t *link = &lp->link;
1215 kio_addr_t ioaddr = dev->base_addr;
1216
1217 DEBUG(4, "fjn_close('%s').\n", dev->name);
1218
1219 lp->open_time = 0;
1220 netif_stop_queue(dev);
1221
1222 /* Set configuration register 0 to disable Tx and Rx. */
1223 if( sram_config == 0 )
1224 outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1225 else
1226 outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1227
1228 /* Update the statistics -- ToDo. */
1229
1230 /* Power-down the chip. Green, green, green! */
1231 outb(CHIP_OFF ,ioaddr + CONFIG_1);
1232
1233 /* Set the ethernet adaptor disable IRQ */
1234 if (lp->cardtype == MBH10302)
1235 outb(INTR_OFF, ioaddr + LAN_CTRL);
1236
1237 link->open--;
1238
1239 return 0;
1240 } /* fjn_close */
1241
1242 /*====================================================================*/
1243
1244 static struct net_device_stats *fjn_get_stats(struct net_device *dev)
1245 {
1246 local_info_t *lp = netdev_priv(dev);
1247 return &lp->stats;
1248 } /* fjn_get_stats */
1249
1250 /*====================================================================*/
1251
1252 /*
1253 Set the multicast/promiscuous mode for this adaptor.
1254 */
1255
1256 static void set_rx_mode(struct net_device *dev)
1257 {
1258 kio_addr_t ioaddr = dev->base_addr;
1259 u_char mc_filter[8]; /* Multicast hash filter */
1260 u_long flags;
1261 int i;
1262
1263 int saved_bank;
1264 int saved_config_0 = inb(ioaddr + CONFIG_0);
1265
1266 local_irq_save(flags);
1267
1268 /* Disable Tx and Rx */
1269 if (sram_config == 0)
1270 outb(CONFIG0_RST, ioaddr + CONFIG_0);
1271 else
1272 outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1273
1274 if (dev->flags & IFF_PROMISC) {
1275 /* Unconditionally log net taps. */
1276 printk("%s: Promiscuous mode enabled.\n", dev->name);
1277 memset(mc_filter, 0xff, sizeof(mc_filter));
1278 outb(3, ioaddr + RX_MODE); /* Enable promiscuous mode */
1279 } else if (dev->mc_count > MC_FILTERBREAK
1280 || (dev->flags & IFF_ALLMULTI)) {
1281 /* Too many to filter perfectly -- accept all multicasts. */
1282 memset(mc_filter, 0xff, sizeof(mc_filter));
1283 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
1284 } else if (dev->mc_count == 0) {
1285 memset(mc_filter, 0x00, sizeof(mc_filter));
1286 outb(1, ioaddr + RX_MODE); /* Ignore almost all multicasts. */
1287 } else {
1288 struct dev_mc_list *mclist;
1289 int i;
1290
1291 memset(mc_filter, 0, sizeof(mc_filter));
1292 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1293 i++, mclist = mclist->next) {
1294 unsigned int bit =
1295 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
1296 mc_filter[bit >> 3] |= (1 << (bit & 7));
1297 }
1298 outb(2, ioaddr + RX_MODE); /* Use normal mode. */
1299 }
1300
1301 /* Switch to bank 1 and set the multicast table. */
1302 saved_bank = inb(ioaddr + CONFIG_1);
1303 outb(0xe4, ioaddr + CONFIG_1);
1304
1305 for (i = 0; i < 8; i++)
1306 outb(mc_filter[i], ioaddr + MAR_ADR + i);
1307 outb(saved_bank, ioaddr + CONFIG_1);
1308
1309 outb(saved_config_0, ioaddr + CONFIG_0);
1310
1311 local_irq_restore(flags);
1312 }
AMDTP streaming driver for the Linux FireWire stack (Juju)