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