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