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