?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6/kvm.git] / drivers / net / pcmcia / smc91c92_cs.c
blobd652e1eddb4588c0b6f1322457debaa62e28cef2
1 /*======================================================================
2
3 A PCMCIA ethernet driver for SMC91c92-based cards.
4
5 This driver supports Megahertz PCMCIA ethernet cards; and
6 Megahertz, Motorola, Ositech, and Psion Dacom ethernet/modem
7 multifunction cards.
8
9 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
10
11 smc91c92_cs.c 1.122 2002/10/25 06:26:39
12
13 This driver contains code written by Donald Becker
14 (becker@scyld.com), Rowan Hughes (x-csrdh@jcu.edu.au),
15 David Hinds (dahinds@users.sourceforge.net), and Erik Stahlman
16 (erik@vt.edu). Donald wrote the SMC 91c92 code using parts of
17 Erik's SMC 91c94 driver. Rowan wrote a similar driver, and I've
18 incorporated some parts of his driver here. I (Dave) wrote most
19 of the PCMCIA glue code, and the Ositech support code. Kelly
20 Stephens (kstephen@holli.com) added support for the Motorola
21 Mariner, with help from Allen Brost.
22
23 This software may be used and distributed according to the terms of
24 the GNU General Public License, incorporated herein by reference.
25
26 ======================================================================*/
27
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/crc32.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/skbuff.h>
40 #include <linux/if_arp.h>
41 #include <linux/ioport.h>
42 #include <linux/ethtool.h>
43 #include <linux/mii.h>
44 #include <linux/jiffies.h>
45
46 #include <pcmcia/cs_types.h>
47 #include <pcmcia/cs.h>
48 #include <pcmcia/cistpl.h>
49 #include <pcmcia/cisreg.h>
50 #include <pcmcia/ciscode.h>
51 #include <pcmcia/ds.h>
52
53 #include <asm/io.h>
54 #include <asm/system.h>
55 #include <asm/uaccess.h>
56
57 /* Ositech Seven of Diamonds firmware */
58 #include "ositech.h"
59
60 /*====================================================================*/
61
62 static char *if_names[] = { "auto", "10baseT", "10base2"};
63
64 /* Module parameters */
65
66 MODULE_DESCRIPTION("SMC 91c92 series 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 /*
72 Transceiver/media type.
73 0 = auto
74 1 = 10baseT (and autoselect if #define AUTOSELECT),
75 2 = AUI/10base2,
76 */
77 INT_MODULE_PARM(if_port, 0);
78
79 #ifdef PCMCIA_DEBUG
80 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
81 static const char *version =
82 "smc91c92_cs.c 0.09 1996/8/4 Donald Becker, becker@scyld.com.\n";
83 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
84 #else
85 #define DEBUG(n, args...)
86 #endif
87
88 #define DRV_NAME "smc91c92_cs"
89 #define DRV_VERSION "1.122"
90
91 /*====================================================================*/
92
93 /* Operational parameter that usually are not changed. */
94
95 /* Time in jiffies before concluding Tx hung */
96 #define TX_TIMEOUT ((400*HZ)/1000)
97
98 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
99 #define INTR_WORK 4
100
101 /* Times to check the check the chip before concluding that it doesn't
102 currently have room for another Tx packet. */
103 #define MEMORY_WAIT_TIME 8
104
105 static dev_info_t dev_info = "smc91c92_cs";
106
107 static dev_link_t *dev_list;
108
109 struct smc_private {
110 dev_link_t link;
111 spinlock_t lock;
112 u_short manfid;
113 u_short cardid;
114 struct net_device_stats stats;
115 dev_node_t node;
116 struct sk_buff *saved_skb;
117 int packets_waiting;
118 void __iomem *base;
119 u_short cfg;
120 struct timer_list media;
121 int watchdog, tx_err;
122 u_short media_status;
123 u_short fast_poll;
124 u_short link_status;
125 struct mii_if_info mii_if;
126 int duplex;
127 int rx_ovrn;
128 };
129
130 struct smc_cfg_mem {
131 tuple_t tuple;
132 cisparse_t parse;
133 u_char buf[255];
134 };
135
136 /* Special definitions for Megahertz multifunction cards */
137 #define MEGAHERTZ_ISR 0x0380
138
139 /* Special function registers for Motorola Mariner */
140 #define MOT_LAN 0x0000
141 #define MOT_UART 0x0020
142 #define MOT_EEPROM 0x20
143
144 #define MOT_NORMAL \
145 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
146
147 /* Special function registers for Ositech cards */
148 #define OSITECH_AUI_CTL 0x0c
149 #define OSITECH_PWRDOWN 0x0d
150 #define OSITECH_RESET 0x0e
151 #define OSITECH_ISR 0x0f
152 #define OSITECH_AUI_PWR 0x0c
153 #define OSITECH_RESET_ISR 0x0e
154
155 #define OSI_AUI_PWR 0x40
156 #define OSI_LAN_PWRDOWN 0x02
157 #define OSI_MODEM_PWRDOWN 0x01
158 #define OSI_LAN_RESET 0x02
159 #define OSI_MODEM_RESET 0x01
160
161 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
162 #define BANK_SELECT 14 /* Window select register. */
163 #define SMC_SELECT_BANK(x) { outw(x, ioaddr + BANK_SELECT); }
164
165 /* Bank 0 registers. */
166 #define TCR 0 /* transmit control register */
167 #define TCR_CLEAR 0 /* do NOTHING */
168 #define TCR_ENABLE 0x0001 /* if this is 1, we can transmit */
169 #define TCR_PAD_EN 0x0080 /* pads short packets to 64 bytes */
170 #define TCR_MONCSN 0x0400 /* Monitor Carrier. */
171 #define TCR_FDUPLX 0x0800 /* Full duplex mode. */
172 #define TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
173
174 #define EPH 2 /* Ethernet Protocol Handler report. */
175 #define EPH_TX_SUC 0x0001
176 #define EPH_SNGLCOL 0x0002
177 #define EPH_MULCOL 0x0004
178 #define EPH_LTX_MULT 0x0008
179 #define EPH_16COL 0x0010
180 #define EPH_SQET 0x0020
181 #define EPH_LTX_BRD 0x0040
182 #define EPH_TX_DEFR 0x0080
183 #define EPH_LAT_COL 0x0200
184 #define EPH_LOST_CAR 0x0400
185 #define EPH_EXC_DEF 0x0800
186 #define EPH_CTR_ROL 0x1000
187 #define EPH_RX_OVRN 0x2000
188 #define EPH_LINK_OK 0x4000
189 #define EPH_TX_UNRN 0x8000
190 #define MEMINFO 8 /* Memory Information Register */
191 #define MEMCFG 10 /* Memory Configuration Register */
192
193 /* Bank 1 registers. */
194 #define CONFIG 0
195 #define CFG_MII_SELECT 0x8000 /* 91C100 only */
196 #define CFG_NO_WAIT 0x1000
197 #define CFG_FULL_STEP 0x0400
198 #define CFG_SET_SQLCH 0x0200
199 #define CFG_AUI_SELECT 0x0100
200 #define CFG_16BIT 0x0080
201 #define CFG_DIS_LINK 0x0040
202 #define CFG_STATIC 0x0030
203 #define CFG_IRQ_SEL_1 0x0004
204 #define CFG_IRQ_SEL_0 0x0002
205 #define BASE_ADDR 2
206 #define ADDR0 4
207 #define GENERAL 10
208 #define CONTROL 12
209 #define CTL_STORE 0x0001
210 #define CTL_RELOAD 0x0002
211 #define CTL_EE_SELECT 0x0004
212 #define CTL_TE_ENABLE 0x0020
213 #define CTL_CR_ENABLE 0x0040
214 #define CTL_LE_ENABLE 0x0080
215 #define CTL_AUTO_RELEASE 0x0800
216 #define CTL_POWERDOWN 0x2000
217
218 /* Bank 2 registers. */
219 #define MMU_CMD 0
220 #define MC_ALLOC 0x20 /* or with number of 256 byte packets */
221 #define MC_RESET 0x40
222 #define MC_RELEASE 0x80 /* remove and release the current rx packet */
223 #define MC_FREEPKT 0xA0 /* Release packet in PNR register */
224 #define MC_ENQUEUE 0xC0 /* Enqueue the packet for transmit */
225 #define PNR_ARR 2
226 #define FIFO_PORTS 4
227 #define FP_RXEMPTY 0x8000
228 #define POINTER 6
229 #define PTR_AUTO_INC 0x0040
230 #define PTR_READ 0x2000
231 #define PTR_AUTOINC 0x4000
232 #define PTR_RCV 0x8000
233 #define DATA_1 8
234 #define INTERRUPT 12
235 #define IM_RCV_INT 0x1
236 #define IM_TX_INT 0x2
237 #define IM_TX_EMPTY_INT 0x4
238 #define IM_ALLOC_INT 0x8
239 #define IM_RX_OVRN_INT 0x10
240 #define IM_EPH_INT 0x20
241
242 #define RCR 4
243 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
244 RxEnable = 0x0100, RxStripCRC = 0x0200};
245 #define RCR_SOFTRESET 0x8000 /* resets the chip */
246 #define RCR_STRIP_CRC 0x200 /* strips CRC */
247 #define RCR_ENABLE 0x100 /* IFF this is set, we can receive packets */
248 #define RCR_ALMUL 0x4 /* receive all multicast packets */
249 #define RCR_PROMISC 0x2 /* enable promiscuous mode */
250
251 /* the normal settings for the RCR register : */
252 #define RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
253 #define RCR_CLEAR 0x0 /* set it to a base state */
254 #define COUNTER 6
255
256 /* BANK 3 -- not the same values as in smc9194! */
257 #define MULTICAST0 0
258 #define MULTICAST2 2
259 #define MULTICAST4 4
260 #define MULTICAST6 6
261 #define MGMT 8
262 #define REVISION 0x0a
263
264 /* Transmit status bits. */
265 #define TS_SUCCESS 0x0001
266 #define TS_16COL 0x0010
267 #define TS_LATCOL 0x0200
268 #define TS_LOSTCAR 0x0400
269
270 /* Receive status bits. */
271 #define RS_ALGNERR 0x8000
272 #define RS_BADCRC 0x2000
273 #define RS_ODDFRAME 0x1000
274 #define RS_TOOLONG 0x0800
275 #define RS_TOOSHORT 0x0400
276 #define RS_MULTICAST 0x0001
277 #define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
278
279 #define set_bits(v, p) outw(inw(p)|(v), (p))
280 #define mask_bits(v, p) outw(inw(p)&(v), (p))
281
282 /*====================================================================*/
283
284 static dev_link_t *smc91c92_attach(void);
285 static void smc91c92_detach(dev_link_t *);
286 static void smc91c92_config(dev_link_t *link);
287 static void smc91c92_release(dev_link_t *link);
288 static int smc91c92_event(event_t event, int priority,
289 event_callback_args_t *args);
290
291 static int smc_open(struct net_device *dev);
292 static int smc_close(struct net_device *dev);
293 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
294 static void smc_tx_timeout(struct net_device *dev);
295 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
296 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
297 static void smc_rx(struct net_device *dev);
298 static struct net_device_stats *smc_get_stats(struct net_device *dev);
299 static void set_rx_mode(struct net_device *dev);
300 static int s9k_config(struct net_device *dev, struct ifmap *map);
301 static void smc_set_xcvr(struct net_device *dev, int if_port);
302 static void smc_reset(struct net_device *dev);
303 static void media_check(u_long arg);
304 static void mdio_sync(kio_addr_t addr);
305 static int mdio_read(struct net_device *dev, int phy_id, int loc);
306 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
307 static int smc_link_ok(struct net_device *dev);
308 static struct ethtool_ops ethtool_ops;
309
310 /*======================================================================
311
312 smc91c92_attach() creates an "instance" of the driver, allocating
313 local data structures for one device. The device is registered
314 with Card Services.
315
316 ======================================================================*/
317
318 static dev_link_t *smc91c92_attach(void)
319 {
320 client_reg_t client_reg;
321 struct smc_private *smc;
322 dev_link_t *link;
323 struct net_device *dev;
324 int ret;
325
326 DEBUG(0, "smc91c92_attach()\n");
327
328 /* Create new ethernet device */
329 dev = alloc_etherdev(sizeof(struct smc_private));
330 if (!dev)
331 return NULL;
332 smc = netdev_priv(dev);
333 link = &smc->link;
334 link->priv = dev;
335
336 spin_lock_init(&smc->lock);
337 link->io.NumPorts1 = 16;
338 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
339 link->io.IOAddrLines = 4;
340 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
341 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
342 link->irq.Handler = &smc_interrupt;
343 link->irq.Instance = dev;
344 link->conf.Attributes = CONF_ENABLE_IRQ;
345 link->conf.Vcc = 50;
346 link->conf.IntType = INT_MEMORY_AND_IO;
347
348 /* The SMC91c92-specific entries in the device structure. */
349 SET_MODULE_OWNER(dev);
350 dev->hard_start_xmit = &smc_start_xmit;
351 dev->get_stats = &smc_get_stats;
352 dev->set_config = &s9k_config;
353 dev->set_multicast_list = &set_rx_mode;
354 dev->open = &smc_open;
355 dev->stop = &smc_close;
356 dev->do_ioctl = &smc_ioctl;
357 SET_ETHTOOL_OPS(dev, &ethtool_ops);
358 #ifdef HAVE_TX_TIMEOUT
359 dev->tx_timeout = smc_tx_timeout;
360 dev->watchdog_timeo = TX_TIMEOUT;
361 #endif
362
363 smc->mii_if.dev = dev;
364 smc->mii_if.mdio_read = mdio_read;
365 smc->mii_if.mdio_write = mdio_write;
366 smc->mii_if.phy_id_mask = 0x1f;
367 smc->mii_if.reg_num_mask = 0x1f;
368
369 /* Register with Card Services */
370 link->next = dev_list;
371 dev_list = link;
372 client_reg.dev_info = &dev_info;
373 client_reg.Version = 0x0210;
374 client_reg.event_callback_args.client_data = link;
375 ret = pcmcia_register_client(&link->handle, &client_reg);
376 if (ret != 0) {
377 cs_error(link->handle, RegisterClient, ret);
378 smc91c92_detach(link);
379 return NULL;
380 }
381
382 return link;
383 } /* smc91c92_attach */
384
385 /*======================================================================
386
387 This deletes a driver "instance". The device is de-registered
388 with Card Services. If it has been released, all local data
389 structures are freed. Otherwise, the structures will be freed
390 when the device is released.
391
392 ======================================================================*/
393
394 static void smc91c92_detach(dev_link_t *link)
395 {
396 struct net_device *dev = link->priv;
397 dev_link_t **linkp;
398
399 DEBUG(0, "smc91c92_detach(0x%p)\n", link);
400
401 /* Locate device structure */
402 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
403 if (*linkp == link) break;
404 if (*linkp == NULL)
405 return;
406
407 if (link->dev)
408 unregister_netdev(dev);
409
410 if (link->state & DEV_CONFIG)
411 smc91c92_release(link);
412
413 if (link->handle)
414 pcmcia_deregister_client(link->handle);
415
416 /* Unlink device structure, free bits */
417 *linkp = link->next;
418 free_netdev(dev);
419 } /* smc91c92_detach */
420
421 /*====================================================================*/
422
423 static int cvt_ascii_address(struct net_device *dev, char *s)
424 {
425 int i, j, da, c;
426
427 if (strlen(s) != 12)
428 return -1;
429 for (i = 0; i < 6; i++) {
430 da = 0;
431 for (j = 0; j < 2; j++) {
432 c = *s++;
433 da <<= 4;
434 da += ((c >= '0') && (c <= '9')) ?
435 (c - '0') : ((c & 0x0f) + 9);
436 }
437 dev->dev_addr[i] = da;
438 }
439 return 0;
440 }
441
442 /*====================================================================*/
443
444 static int first_tuple(client_handle_t handle, tuple_t *tuple,
445 cisparse_t *parse)
446 {
447 int i;
448
449 if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
450 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
451 return i;
452 return pcmcia_parse_tuple(handle, tuple, parse);
453 }
454
455 static int next_tuple(client_handle_t handle, tuple_t *tuple,
456 cisparse_t *parse)
457 {
458 int i;
459
460 if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
461 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
462 return i;
463 return pcmcia_parse_tuple(handle, tuple, parse);
464 }
465
466 /*======================================================================
467
468 Configuration stuff for Megahertz cards
469
470 mhz_3288_power() is used to power up a 3288's ethernet chip.
471 mhz_mfc_config() handles socket setup for multifunction (1144
472 and 3288) cards. mhz_setup() gets a card's hardware ethernet
473 address.
474
475 ======================================================================*/
476
477 static int mhz_3288_power(dev_link_t *link)
478 {
479 struct net_device *dev = link->priv;
480 struct smc_private *smc = netdev_priv(dev);
481 u_char tmp;
482
483 /* Read the ISR twice... */
484 readb(smc->base+MEGAHERTZ_ISR);
485 udelay(5);
486 readb(smc->base+MEGAHERTZ_ISR);
487
488 /* Pause 200ms... */
489 mdelay(200);
490
491 /* Now read and write the COR... */
492 tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
493 udelay(5);
494 writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
495
496 return 0;
497 }
498
499 static int mhz_mfc_config(dev_link_t *link)
500 {
501 struct net_device *dev = link->priv;
502 struct smc_private *smc = netdev_priv(dev);
503 struct smc_cfg_mem *cfg_mem;
504 tuple_t *tuple;
505 cisparse_t *parse;
506 cistpl_cftable_entry_t *cf;
507 u_char *buf;
508 win_req_t req;
509 memreq_t mem;
510 int i, k;
511
512 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
513 if (!cfg_mem)
514 return CS_OUT_OF_RESOURCE;
515
516 tuple = &cfg_mem->tuple;
517 parse = &cfg_mem->parse;
518 cf = &parse->cftable_entry;
519 buf = cfg_mem->buf;
520
521 link->conf.Attributes |= CONF_ENABLE_SPKR;
522 link->conf.Status = CCSR_AUDIO_ENA;
523 link->irq.Attributes =
524 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
525 link->io.IOAddrLines = 16;
526 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
527 link->io.NumPorts2 = 8;
528
529 tuple->Attributes = tuple->TupleOffset = 0;
530 tuple->TupleData = (cisdata_t *)buf;
531 tuple->TupleDataMax = 255;
532 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
533
534 i = first_tuple(link->handle, tuple, parse);
535 /* The Megahertz combo cards have modem-like CIS entries, so
536 we have to explicitly try a bunch of port combinations. */
537 while (i == CS_SUCCESS) {
538 link->conf.ConfigIndex = cf->index;
539 link->io.BasePort2 = cf->io.win[0].base;
540 for (k = 0; k < 0x400; k += 0x10) {
541 if (k & 0x80) continue;
542 link->io.BasePort1 = k ^ 0x300;
543 i = pcmcia_request_io(link->handle, &link->io);
544 if (i == CS_SUCCESS) break;
545 }
546 if (i == CS_SUCCESS) break;
547 i = next_tuple(link->handle, tuple, parse);
548 }
549 if (i != CS_SUCCESS)
550 goto free_cfg_mem;
551 dev->base_addr = link->io.BasePort1;
552
553 /* Allocate a memory window, for accessing the ISR */
554 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
555 req.Base = req.Size = 0;
556 req.AccessSpeed = 0;
557 i = pcmcia_request_window(&link->handle, &req, &link->win);
558 if (i != CS_SUCCESS)
559 goto free_cfg_mem;
560 smc->base = ioremap(req.Base, req.Size);
561 mem.CardOffset = mem.Page = 0;
562 if (smc->manfid == MANFID_MOTOROLA)
563 mem.CardOffset = link->conf.ConfigBase;
564 i = pcmcia_map_mem_page(link->win, &mem);
565
566 if ((i == CS_SUCCESS)
567 && (smc->manfid == MANFID_MEGAHERTZ)
568 && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
569 mhz_3288_power(link);
570
571 free_cfg_mem:
572 kfree(cfg_mem);
573 return i;
574 }
575
576 static int mhz_setup(dev_link_t *link)
577 {
578 client_handle_t handle = link->handle;
579 struct net_device *dev = link->priv;
580 struct smc_cfg_mem *cfg_mem;
581 tuple_t *tuple;
582 cisparse_t *parse;
583 u_char *buf, *station_addr;
584 int rc;
585
586 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
587 if (!cfg_mem)
588 return -1;
589
590 tuple = &cfg_mem->tuple;
591 parse = &cfg_mem->parse;
592 buf = cfg_mem->buf;
593
594 tuple->Attributes = tuple->TupleOffset = 0;
595 tuple->TupleData = (cisdata_t *)buf;
596 tuple->TupleDataMax = 255;
597
598 /* Read the station address from the CIS. It is stored as the last
599 (fourth) string in the Version 1 Version/ID tuple. */
600 tuple->DesiredTuple = CISTPL_VERS_1;
601 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
602 rc = -1;
603 goto free_cfg_mem;
604 }
605 /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
606 if (next_tuple(handle, tuple, parse) != CS_SUCCESS)
607 first_tuple(handle, tuple, parse);
608 if (parse->version_1.ns > 3) {
609 station_addr = parse->version_1.str + parse->version_1.ofs[3];
610 if (cvt_ascii_address(dev, station_addr) == 0) {
611 rc = 0;
612 goto free_cfg_mem;
613 }
614 }
615
616 /* Another possibility: for the EM3288, in a special tuple */
617 tuple->DesiredTuple = 0x81;
618 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) {
619 rc = -1;
620 goto free_cfg_mem;
621 }
622 if (pcmcia_get_tuple_data(handle, tuple) != CS_SUCCESS) {
623 rc = -1;
624 goto free_cfg_mem;
625 }
626 buf[12] = '\0';
627 if (cvt_ascii_address(dev, buf) == 0) {
628 rc = 0;
629 goto free_cfg_mem;
630 }
631 rc = -1;
632 free_cfg_mem:
633 kfree(cfg_mem);
634 return rc;
635 }
636
637 /*======================================================================
638
639 Configuration stuff for the Motorola Mariner
640
641 mot_config() writes directly to the Mariner configuration
642 registers because the CIS is just bogus.
643
644 ======================================================================*/
645
646 static void mot_config(dev_link_t *link)
647 {
648 struct net_device *dev = link->priv;
649 struct smc_private *smc = netdev_priv(dev);
650 kio_addr_t ioaddr = dev->base_addr;
651 kio_addr_t iouart = link->io.BasePort2;
652
653 /* Set UART base address and force map with COR bit 1 */
654 writeb(iouart & 0xff, smc->base + MOT_UART + CISREG_IOBASE_0);
655 writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
656 writeb(MOT_NORMAL, smc->base + MOT_UART + CISREG_COR);
657
658 /* Set SMC base address and force map with COR bit 1 */
659 writeb(ioaddr & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_0);
660 writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
661 writeb(MOT_NORMAL, smc->base + MOT_LAN + CISREG_COR);
662
663 /* Wait for things to settle down */
664 mdelay(100);
665 }
666
667 static int mot_setup(dev_link_t *link)
668 {
669 struct net_device *dev = link->priv;
670 kio_addr_t ioaddr = dev->base_addr;
671 int i, wait, loop;
672 u_int addr;
673
674 /* Read Ethernet address from Serial EEPROM */
675
676 for (i = 0; i < 3; i++) {
677 SMC_SELECT_BANK(2);
678 outw(MOT_EEPROM + i, ioaddr + POINTER);
679 SMC_SELECT_BANK(1);
680 outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
681
682 for (loop = wait = 0; loop < 200; loop++) {
683 udelay(10);
684 wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
685 if (wait == 0) break;
686 }
687
688 if (wait)
689 return -1;
690
691 addr = inw(ioaddr + GENERAL);
692 dev->dev_addr[2*i] = addr & 0xff;
693 dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
694 }
695
696 return 0;
697 }
698
699 /*====================================================================*/
700
701 static int smc_config(dev_link_t *link)
702 {
703 struct net_device *dev = link->priv;
704 struct smc_cfg_mem *cfg_mem;
705 tuple_t *tuple;
706 cisparse_t *parse;
707 cistpl_cftable_entry_t *cf;
708 u_char *buf;
709 int i;
710
711 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
712 if (!cfg_mem)
713 return CS_OUT_OF_RESOURCE;
714
715 tuple = &cfg_mem->tuple;
716 parse = &cfg_mem->parse;
717 cf = &parse->cftable_entry;
718 buf = cfg_mem->buf;
719
720 tuple->Attributes = tuple->TupleOffset = 0;
721 tuple->TupleData = (cisdata_t *)buf;
722 tuple->TupleDataMax = 255;
723 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
724
725 link->io.NumPorts1 = 16;
726 i = first_tuple(link->handle, tuple, parse);
727 while (i != CS_NO_MORE_ITEMS) {
728 if (i == CS_SUCCESS) {
729 link->conf.ConfigIndex = cf->index;
730 link->io.BasePort1 = cf->io.win[0].base;
731 link->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
732 i = pcmcia_request_io(link->handle, &link->io);
733 if (i == CS_SUCCESS) break;
734 }
735 i = next_tuple(link->handle, tuple, parse);
736 }
737 if (i == CS_SUCCESS)
738 dev->base_addr = link->io.BasePort1;
739
740 kfree(cfg_mem);
741 return i;
742 }
743
744 static int smc_setup(dev_link_t *link)
745 {
746 client_handle_t handle = link->handle;
747 struct net_device *dev = link->priv;
748 struct smc_cfg_mem *cfg_mem;
749 tuple_t *tuple;
750 cisparse_t *parse;
751 cistpl_lan_node_id_t *node_id;
752 u_char *buf, *station_addr;
753 int i, rc;
754
755 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
756 if (!cfg_mem)
757 return CS_OUT_OF_RESOURCE;
758
759 tuple = &cfg_mem->tuple;
760 parse = &cfg_mem->parse;
761 buf = cfg_mem->buf;
762
763 tuple->Attributes = tuple->TupleOffset = 0;
764 tuple->TupleData = (cisdata_t *)buf;
765 tuple->TupleDataMax = 255;
766
767 /* Check for a LAN function extension tuple */
768 tuple->DesiredTuple = CISTPL_FUNCE;
769 i = first_tuple(handle, tuple, parse);
770 while (i == CS_SUCCESS) {
771 if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
772 break;
773 i = next_tuple(handle, tuple, parse);
774 }
775 if (i == CS_SUCCESS) {
776 node_id = (cistpl_lan_node_id_t *)parse->funce.data;
777 if (node_id->nb == 6) {
778 for (i = 0; i < 6; i++)
779 dev->dev_addr[i] = node_id->id[i];
780 rc = 0;
781 goto free_cfg_mem;
782 }
783 }
784 /* Try the third string in the Version 1 Version/ID tuple. */
785 tuple->DesiredTuple = CISTPL_VERS_1;
786 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
787 rc = -1;
788 goto free_cfg_mem;
789 }
790 station_addr = parse->version_1.str + parse->version_1.ofs[2];
791 if (cvt_ascii_address(dev, station_addr) == 0) {
792 rc = 0;
793 goto free_cfg_mem;
794 }
795
796 rc = -1;
797 free_cfg_mem:
798 kfree(cfg_mem);
799 return rc;
800 }
801
802 /*====================================================================*/
803
804 static int osi_config(dev_link_t *link)
805 {
806 struct net_device *dev = link->priv;
807 static kio_addr_t com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
808 int i, j;
809
810 link->conf.Attributes |= CONF_ENABLE_SPKR;
811 link->conf.Status = CCSR_AUDIO_ENA;
812 link->irq.Attributes =
813 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
814 link->io.NumPorts1 = 64;
815 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
816 link->io.NumPorts2 = 8;
817 link->io.IOAddrLines = 16;
818
819 /* Enable Hard Decode, LAN, Modem */
820 link->conf.ConfigIndex = 0x23;
821
822 for (i = j = 0; j < 4; j++) {
823 link->io.BasePort2 = com[j];
824 i = pcmcia_request_io(link->handle, &link->io);
825 if (i == CS_SUCCESS) break;
826 }
827 if (i != CS_SUCCESS) {
828 /* Fallback: turn off hard decode */
829 link->conf.ConfigIndex = 0x03;
830 link->io.NumPorts2 = 0;
831 i = pcmcia_request_io(link->handle, &link->io);
832 }
833 dev->base_addr = link->io.BasePort1 + 0x10;
834 return i;
835 }
836
837 static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid)
838 {
839 client_handle_t handle = link->handle;
840 struct net_device *dev = link->priv;
841 struct smc_cfg_mem *cfg_mem;
842 tuple_t *tuple;
843 u_char *buf;
844 int i, rc;
845
846 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
847 if (!cfg_mem)
848 return -1;
849
850 tuple = &cfg_mem->tuple;
851 buf = cfg_mem->buf;
852
853 tuple->Attributes = TUPLE_RETURN_COMMON;
854 tuple->TupleData = (cisdata_t *)buf;
855 tuple->TupleDataMax = 255;
856 tuple->TupleOffset = 0;
857
858 /* Read the station address from tuple 0x90, subtuple 0x04 */
859 tuple->DesiredTuple = 0x90;
860 i = pcmcia_get_first_tuple(handle, tuple);
861 while (i == CS_SUCCESS) {
862 i = pcmcia_get_tuple_data(handle, tuple);
863 if ((i != CS_SUCCESS) || (buf[0] == 0x04))
864 break;
865 i = pcmcia_get_next_tuple(handle, tuple);
866 }
867 if (i != CS_SUCCESS) {
868 rc = -1;
869 goto free_cfg_mem;
870 }
871 for (i = 0; i < 6; i++)
872 dev->dev_addr[i] = buf[i+2];
873
874 if (((manfid == MANFID_OSITECH) &&
875 (cardid == PRODID_OSITECH_SEVEN)) ||
876 ((manfid == MANFID_PSION) &&
877 (cardid == PRODID_PSION_NET100))) {
878 /* Download the Seven of Diamonds firmware */
879 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
880 outb(__Xilinx7OD[i], link->io.BasePort1+2);
881 udelay(50);
882 }
883 } else if (manfid == MANFID_OSITECH) {
884 /* Make sure both functions are powered up */
885 set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
886 /* Now, turn on the interrupt for both card functions */
887 set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
888 DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
889 inw(link->io.BasePort1 + OSITECH_AUI_PWR),
890 inw(link->io.BasePort1 + OSITECH_RESET_ISR));
891 }
892 rc = 0;
893 free_cfg_mem:
894 kfree(cfg_mem);
895 return rc;
896 }
897
898 /*======================================================================
899
900 This verifies that the chip is some SMC91cXX variant, and returns
901 the revision code if successful. Otherwise, it returns -ENODEV.
902
903 ======================================================================*/
904
905 static int check_sig(dev_link_t *link)
906 {
907 struct net_device *dev = link->priv;
908 kio_addr_t ioaddr = dev->base_addr;
909 int width;
910 u_short s;
911
912 SMC_SELECT_BANK(1);
913 if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
914 /* Try powering up the chip */
915 outw(0, ioaddr + CONTROL);
916 mdelay(55);
917 }
918
919 /* Try setting bus width */
920 width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
921 s = inb(ioaddr + CONFIG);
922 if (width)
923 s |= CFG_16BIT;
924 else
925 s &= ~CFG_16BIT;
926 outb(s, ioaddr + CONFIG);
927
928 /* Check Base Address Register to make sure bus width is OK */
929 s = inw(ioaddr + BASE_ADDR);
930 if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
931 ((s >> 8) != (s & 0xff))) {
932 SMC_SELECT_BANK(3);
933 s = inw(ioaddr + REVISION);
934 return (s & 0xff);
935 }
936
937 if (width) {
938 event_callback_args_t args;
939 printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
940 args.client_data = link;
941 smc91c92_event(CS_EVENT_RESET_PHYSICAL, 0, &args);
942 pcmcia_release_io(link->handle, &link->io);
943 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
944 pcmcia_request_io(link->handle, &link->io);
945 smc91c92_event(CS_EVENT_CARD_RESET, 0, &args);
946 return check_sig(link);
947 }
948 return -ENODEV;
949 }
950
951 /*======================================================================
952
953 smc91c92_config() is scheduled to run after a CARD_INSERTION event
954 is received, to configure the PCMCIA socket, and to make the
955 ethernet device available to the system.
956
957 ======================================================================*/
958
959 #define CS_EXIT_TEST(ret, svc, label) \
960 if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
961
962 static void smc91c92_config(dev_link_t *link)
963 {
964 client_handle_t handle = link->handle;
965 struct net_device *dev = link->priv;
966 struct smc_private *smc = netdev_priv(dev);
967 struct smc_cfg_mem *cfg_mem;
968 tuple_t *tuple;
969 cisparse_t *parse;
970 u_char *buf;
971 char *name;
972 int i, j, rev;
973 kio_addr_t ioaddr;
974 u_long mir;
975
976 DEBUG(0, "smc91c92_config(0x%p)\n", link);
977
978 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
979 if (!cfg_mem)
980 goto config_failed;
981
982 tuple = &cfg_mem->tuple;
983 parse = &cfg_mem->parse;
984 buf = cfg_mem->buf;
985
986 tuple->Attributes = tuple->TupleOffset = 0;
987 tuple->TupleData = (cisdata_t *)buf;
988 tuple->TupleDataMax = 64;
989
990 tuple->DesiredTuple = CISTPL_CONFIG;
991 i = first_tuple(handle, tuple, parse);
992 CS_EXIT_TEST(i, ParseTuple, config_failed);
993 link->conf.ConfigBase = parse->config.base;
994 link->conf.Present = parse->config.rmask[0];
995
996 tuple->DesiredTuple = CISTPL_MANFID;
997 tuple->Attributes = TUPLE_RETURN_COMMON;
998 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
999 smc->manfid = parse->manfid.manf;
1000 smc->cardid = parse->manfid.card;
1001 }
1002
1003 /* Configure card */
1004 link->state |= DEV_CONFIG;
1005
1006 if ((smc->manfid == MANFID_OSITECH) &&
1007 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1008 i = osi_config(link);
1009 } else if ((smc->manfid == MANFID_MOTOROLA) ||
1010 ((smc->manfid == MANFID_MEGAHERTZ) &&
1011 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
1012 (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
1013 i = mhz_mfc_config(link);
1014 } else {
1015 i = smc_config(link);
1016 }
1017 CS_EXIT_TEST(i, RequestIO, config_failed);
1018
1019 i = pcmcia_request_irq(link->handle, &link->irq);
1020 CS_EXIT_TEST(i, RequestIRQ, config_failed);
1021 i = pcmcia_request_configuration(link->handle, &link->conf);
1022 CS_EXIT_TEST(i, RequestConfiguration, config_failed);
1023
1024 if (smc->manfid == MANFID_MOTOROLA)
1025 mot_config(link);
1026
1027 dev->irq = link->irq.AssignedIRQ;
1028
1029 if ((if_port >= 0) && (if_port <= 2))
1030 dev->if_port = if_port;
1031 else
1032 printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
1033
1034 switch (smc->manfid) {
1035 case MANFID_OSITECH:
1036 case MANFID_PSION:
1037 i = osi_setup(link, smc->manfid, smc->cardid); break;
1038 case MANFID_SMC:
1039 case MANFID_NEW_MEDIA:
1040 i = smc_setup(link); break;
1041 case 0x128: /* For broken Megahertz cards */
1042 case MANFID_MEGAHERTZ:
1043 i = mhz_setup(link); break;
1044 case MANFID_MOTOROLA:
1045 default: /* get the hw address from EEPROM */
1046 i = mot_setup(link); break;
1047 }
1048
1049 if (i != 0) {
1050 printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1051 goto config_undo;
1052 }
1053
1054 smc->duplex = 0;
1055 smc->rx_ovrn = 0;
1056
1057 rev = check_sig(link);
1058 name = "???";
1059 if (rev > 0)
1060 switch (rev >> 4) {
1061 case 3: name = "92"; break;
1062 case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1063 case 5: name = "95"; break;
1064 case 7: name = "100"; break;
1065 case 8: name = "100-FD"; break;
1066 case 9: name = "110"; break;
1067 }
1068
1069 ioaddr = dev->base_addr;
1070 if (rev > 0) {
1071 u_long mcr;
1072 SMC_SELECT_BANK(0);
1073 mir = inw(ioaddr + MEMINFO) & 0xff;
1074 if (mir == 0xff) mir++;
1075 /* Get scale factor for memory size */
1076 mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1077 mir *= 128 * (1<<((mcr >> 9) & 7));
1078 SMC_SELECT_BANK(1);
1079 smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1080 smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1081 if (smc->manfid == MANFID_OSITECH)
1082 smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1083 if ((rev >> 4) >= 7)
1084 smc->cfg |= CFG_MII_SELECT;
1085 } else
1086 mir = 0;
1087
1088 if (smc->cfg & CFG_MII_SELECT) {
1089 SMC_SELECT_BANK(3);
1090
1091 for (i = 0; i < 32; i++) {
1092 j = mdio_read(dev, i, 1);
1093 if ((j != 0) && (j != 0xffff)) break;
1094 }
1095 smc->mii_if.phy_id = (i < 32) ? i : -1;
1096
1097 SMC_SELECT_BANK(0);
1098 }
1099
1100 link->dev = &smc->node;
1101 link->state &= ~DEV_CONFIG_PENDING;
1102 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
1103
1104 if (register_netdev(dev) != 0) {
1105 printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1106 link->dev = NULL;
1107 goto config_undo;
1108 }
1109
1110 strcpy(smc->node.dev_name, dev->name);
1111
1112 printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1113 "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
1114 dev->irq);
1115 for (i = 0; i < 6; i++)
1116 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
1117
1118 if (rev > 0) {
1119 if (mir & 0x3ff)
1120 printk(KERN_INFO " %lu byte", mir);
1121 else
1122 printk(KERN_INFO " %lu kb", mir>>10);
1123 printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1124 "MII" : if_names[dev->if_port]);
1125 }
1126
1127 if (smc->cfg & CFG_MII_SELECT) {
1128 if (smc->mii_if.phy_id != -1) {
1129 DEBUG(0, " MII transceiver at index %d, status %x.\n",
1130 smc->mii_if.phy_id, j);
1131 } else {
1132 printk(KERN_NOTICE " No MII transceivers found!\n");
1133 }
1134 }
1135 kfree(cfg_mem);
1136 return;
1137
1138 config_undo:
1139 unregister_netdev(dev);
1140 config_failed: /* CS_EXIT_TEST() calls jump to here... */
1141 smc91c92_release(link);
1142 link->state &= ~DEV_CONFIG_PENDING;
1143 kfree(cfg_mem);
1144
1145 } /* smc91c92_config */
1146
1147 /*======================================================================
1148
1149 After a card is removed, smc91c92_release() will unregister the net
1150 device, and release the PCMCIA configuration. If the device is
1151 still open, this will be postponed until it is closed.
1152
1153 ======================================================================*/
1154
1155 static void smc91c92_release(dev_link_t *link)
1156 {
1157
1158 DEBUG(0, "smc91c92_release(0x%p)\n", link);
1159
1160 pcmcia_release_configuration(link->handle);
1161 pcmcia_release_io(link->handle, &link->io);
1162 pcmcia_release_irq(link->handle, &link->irq);
1163 if (link->win) {
1164 struct net_device *dev = link->priv;
1165 struct smc_private *smc = netdev_priv(dev);
1166 iounmap(smc->base);
1167 pcmcia_release_window(link->win);
1168 }
1169
1170 link->state &= ~DEV_CONFIG;
1171 }
1172
1173 /*======================================================================
1174
1175 The card status event handler. Mostly, this schedules other
1176 stuff to run after an event is received. A CARD_REMOVAL event
1177 also sets some flags to discourage the net drivers from trying
1178 to talk to the card any more.
1179
1180 ======================================================================*/
1181
1182 static int smc91c92_event(event_t event, int priority,
1183 event_callback_args_t *args)
1184 {
1185 dev_link_t *link = args->client_data;
1186 struct net_device *dev = link->priv;
1187 struct smc_private *smc = netdev_priv(dev);
1188 int i;
1189
1190 DEBUG(1, "smc91c92_event(0x%06x)\n", event);
1191
1192 switch (event) {
1193 case CS_EVENT_CARD_REMOVAL:
1194 link->state &= ~DEV_PRESENT;
1195 if (link->state & DEV_CONFIG)
1196 netif_device_detach(dev);
1197 break;
1198 case CS_EVENT_CARD_INSERTION:
1199 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1200 smc91c92_config(link);
1201 break;
1202 case CS_EVENT_PM_SUSPEND:
1203 link->state |= DEV_SUSPEND;
1204 /* Fall through... */
1205 case CS_EVENT_RESET_PHYSICAL:
1206 if (link->state & DEV_CONFIG) {
1207 if (link->open)
1208 netif_device_detach(dev);
1209 pcmcia_release_configuration(link->handle);
1210 }
1211 break;
1212 case CS_EVENT_PM_RESUME:
1213 link->state &= ~DEV_SUSPEND;
1214 /* Fall through... */
1215 case CS_EVENT_CARD_RESET:
1216 if (link->state & DEV_CONFIG) {
1217 if ((smc->manfid == MANFID_MEGAHERTZ) &&
1218 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
1219 mhz_3288_power(link);
1220 pcmcia_request_configuration(link->handle, &link->conf);
1221 if (smc->manfid == MANFID_MOTOROLA)
1222 mot_config(link);
1223 if ((smc->manfid == MANFID_OSITECH) &&
1224 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1225 /* Power up the card and enable interrupts */
1226 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
1227 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
1228 }
1229 if (((smc->manfid == MANFID_OSITECH) &&
1230 (smc->cardid == PRODID_OSITECH_SEVEN)) ||
1231 ((smc->manfid == MANFID_PSION) &&
1232 (smc->cardid == PRODID_PSION_NET100))) {
1233 /* Download the Seven of Diamonds firmware */
1234 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
1235 outb(__Xilinx7OD[i], link->io.BasePort1+2);
1236 udelay(50);
1237 }
1238 }
1239 if (link->open) {
1240 smc_reset(dev);
1241 netif_device_attach(dev);
1242 }
1243 }
1244 break;
1245 }
1246 return 0;
1247 } /* smc91c92_event */
1248
1249 /*======================================================================
1250
1251 MII interface support for SMC91cXX based cards
1252 ======================================================================*/
1253
1254 #define MDIO_SHIFT_CLK 0x04
1255 #define MDIO_DATA_OUT 0x01
1256 #define MDIO_DIR_WRITE 0x08
1257 #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
1258 #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1259 #define MDIO_DATA_READ 0x02
1260
1261 static void mdio_sync(kio_addr_t addr)
1262 {
1263 int bits;
1264 for (bits = 0; bits < 32; bits++) {
1265 outb(MDIO_DATA_WRITE1, addr);
1266 outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1267 }
1268 }
1269
1270 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1271 {
1272 kio_addr_t addr = dev->base_addr + MGMT;
1273 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1274 int i, retval = 0;
1275
1276 mdio_sync(addr);
1277 for (i = 13; i >= 0; i--) {
1278 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1279 outb(dat, addr);
1280 outb(dat | MDIO_SHIFT_CLK, addr);
1281 }
1282 for (i = 19; i > 0; i--) {
1283 outb(0, addr);
1284 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1285 outb(MDIO_SHIFT_CLK, addr);
1286 }
1287 return (retval>>1) & 0xffff;
1288 }
1289
1290 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1291 {
1292 kio_addr_t addr = dev->base_addr + MGMT;
1293 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1294 int i;
1295
1296 mdio_sync(addr);
1297 for (i = 31; i >= 0; i--) {
1298 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1299 outb(dat, addr);
1300 outb(dat | MDIO_SHIFT_CLK, addr);
1301 }
1302 for (i = 1; i >= 0; i--) {
1303 outb(0, addr);
1304 outb(MDIO_SHIFT_CLK, addr);
1305 }
1306 }
1307
1308 /*======================================================================
1309
1310 The driver core code, most of which should be common with a
1311 non-PCMCIA implementation.
1312
1313 ======================================================================*/
1314
1315 #ifdef PCMCIA_DEBUG
1316 static void smc_dump(struct net_device *dev)
1317 {
1318 kio_addr_t ioaddr = dev->base_addr;
1319 u_short i, w, save;
1320 save = inw(ioaddr + BANK_SELECT);
1321 for (w = 0; w < 4; w++) {
1322 SMC_SELECT_BANK(w);
1323 printk(KERN_DEBUG "bank %d: ", w);
1324 for (i = 0; i < 14; i += 2)
1325 printk(" %04x", inw(ioaddr + i));
1326 printk("\n");
1327 }
1328 outw(save, ioaddr + BANK_SELECT);
1329 }
1330 #endif
1331
1332 static int smc_open(struct net_device *dev)
1333 {
1334 struct smc_private *smc = netdev_priv(dev);
1335 dev_link_t *link = &smc->link;
1336
1337 #ifdef PCMCIA_DEBUG
1338 DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1339 dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1340 if (pc_debug > 1) smc_dump(dev);
1341 #endif
1342
1343 /* Check that the PCMCIA card is still here. */
1344 if (!DEV_OK(link))
1345 return -ENODEV;
1346 /* Physical device present signature. */
1347 if (check_sig(link) < 0) {
1348 printk("smc91c92_cs: Yikes! Bad chip signature!\n");
1349 return -ENODEV;
1350 }
1351 link->open++;
1352
1353 netif_start_queue(dev);
1354 smc->saved_skb = NULL;
1355 smc->packets_waiting = 0;
1356
1357 smc_reset(dev);
1358 init_timer(&smc->media);
1359 smc->media.function = &media_check;
1360 smc->media.data = (u_long) dev;
1361 smc->media.expires = jiffies + HZ;
1362 add_timer(&smc->media);
1363
1364 return 0;
1365 } /* smc_open */
1366
1367 /*====================================================================*/
1368
1369 static int smc_close(struct net_device *dev)
1370 {
1371 struct smc_private *smc = netdev_priv(dev);
1372 dev_link_t *link = &smc->link;
1373 kio_addr_t ioaddr = dev->base_addr;
1374
1375 DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1376 dev->name, inw(ioaddr + BANK_SELECT));
1377
1378 netif_stop_queue(dev);
1379
1380 /* Shut off all interrupts, and turn off the Tx and Rx sections.
1381 Don't bother to check for chip present. */
1382 SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1383 outw(0, ioaddr + INTERRUPT);
1384 SMC_SELECT_BANK(0);
1385 mask_bits(0xff00, ioaddr + RCR);
1386 mask_bits(0xff00, ioaddr + TCR);
1387
1388 /* Put the chip into power-down mode. */
1389 SMC_SELECT_BANK(1);
1390 outw(CTL_POWERDOWN, ioaddr + CONTROL );
1391
1392 link->open--;
1393 del_timer_sync(&smc->media);
1394
1395 return 0;
1396 } /* smc_close */
1397
1398 /*======================================================================
1399
1400 Transfer a packet to the hardware and trigger the packet send.
1401 This may be called at either from either the Tx queue code
1402 or the interrupt handler.
1403
1404 ======================================================================*/
1405
1406 static void smc_hardware_send_packet(struct net_device * dev)
1407 {
1408 struct smc_private *smc = netdev_priv(dev);
1409 struct sk_buff *skb = smc->saved_skb;
1410 kio_addr_t ioaddr = dev->base_addr;
1411 u_char packet_no;
1412
1413 if (!skb) {
1414 printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1415 return;
1416 }
1417
1418 /* There should be a packet slot waiting. */
1419 packet_no = inw(ioaddr + PNR_ARR) >> 8;
1420 if (packet_no & 0x80) {
1421 /* If not, there is a hardware problem! Likely an ejected card. */
1422 printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1423 " failed, status %#2.2x.\n", dev->name, packet_no);
1424 dev_kfree_skb_irq(skb);
1425 smc->saved_skb = NULL;
1426 netif_start_queue(dev);
1427 return;
1428 }
1429
1430 smc->stats.tx_bytes += skb->len;
1431 /* The card should use the just-allocated buffer. */
1432 outw(packet_no, ioaddr + PNR_ARR);
1433 /* point to the beginning of the packet */
1434 outw(PTR_AUTOINC , ioaddr + POINTER);
1435
1436 /* Send the packet length (+6 for status, length and ctl byte)
1437 and the status word (set to zeros). */
1438 {
1439 u_char *buf = skb->data;
1440 u_int length = skb->len; /* The chip will pad to ethernet min. */
1441
1442 DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1443 dev->name, length);
1444
1445 /* send the packet length: +6 for status word, length, and ctl */
1446 outw(0, ioaddr + DATA_1);
1447 outw(length + 6, ioaddr + DATA_1);
1448 outsw(ioaddr + DATA_1, buf, length >> 1);
1449
1450 /* The odd last byte, if there is one, goes in the control word. */
1451 outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1452 }
1453
1454 /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1455 outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1456 (inw(ioaddr + INTERRUPT) & 0xff00),
1457 ioaddr + INTERRUPT);
1458
1459 /* The chip does the rest of the work. */
1460 outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1461
1462 smc->saved_skb = NULL;
1463 dev_kfree_skb_irq(skb);
1464 dev->trans_start = jiffies;
1465 netif_start_queue(dev);
1466 return;
1467 }
1468
1469 /*====================================================================*/
1470
1471 static void smc_tx_timeout(struct net_device *dev)
1472 {
1473 struct smc_private *smc = netdev_priv(dev);
1474 kio_addr_t ioaddr = dev->base_addr;
1475
1476 printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1477 "Tx_status %2.2x status %4.4x.\n",
1478 dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1479 smc->stats.tx_errors++;
1480 smc_reset(dev);
1481 dev->trans_start = jiffies;
1482 smc->saved_skb = NULL;
1483 netif_wake_queue(dev);
1484 }
1485
1486 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1487 {
1488 struct smc_private *smc = netdev_priv(dev);
1489 kio_addr_t ioaddr = dev->base_addr;
1490 u_short num_pages;
1491 short time_out, ir;
1492
1493 netif_stop_queue(dev);
1494
1495 DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1496 " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1497
1498 if (smc->saved_skb) {
1499 /* THIS SHOULD NEVER HAPPEN. */
1500 smc->stats.tx_aborted_errors++;
1501 printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1502 dev->name);
1503 return 1;
1504 }
1505 smc->saved_skb = skb;
1506
1507 num_pages = skb->len >> 8;
1508
1509 if (num_pages > 7) {
1510 printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1511 dev_kfree_skb (skb);
1512 smc->saved_skb = NULL;
1513 smc->stats.tx_dropped++;
1514 return 0; /* Do not re-queue this packet. */
1515 }
1516 /* A packet is now waiting. */
1517 smc->packets_waiting++;
1518
1519 SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1520
1521 /* need MC_RESET to keep the memory consistent. errata? */
1522 if (smc->rx_ovrn) {
1523 outw(MC_RESET, ioaddr + MMU_CMD);
1524 smc->rx_ovrn = 0;
1525 }
1526
1527 /* Allocate the memory; send the packet now if we win. */
1528 outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1529 for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1530 ir = inw(ioaddr+INTERRUPT);
1531 if (ir & IM_ALLOC_INT) {
1532 /* Acknowledge the interrupt, send the packet. */
1533 outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1534 smc_hardware_send_packet(dev); /* Send the packet now.. */
1535 return 0;
1536 }
1537 }
1538
1539 /* Otherwise defer until the Tx-space-allocated interrupt. */
1540 DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1541 outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1542
1543 return 0;
1544 }
1545
1546 /*======================================================================
1547
1548 Handle a Tx anomolous event. Entered while in Window 2.
1549
1550 ======================================================================*/
1551
1552 static void smc_tx_err(struct net_device * dev)
1553 {
1554 struct smc_private *smc = netdev_priv(dev);
1555 kio_addr_t ioaddr = dev->base_addr;
1556 int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1557 int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1558 int tx_status;
1559
1560 /* select this as the packet to read from */
1561 outw(packet_no, ioaddr + PNR_ARR);
1562
1563 /* read the first word from this packet */
1564 outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1565
1566 tx_status = inw(ioaddr + DATA_1);
1567
1568 smc->stats.tx_errors++;
1569 if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1570 if (tx_status & TS_LATCOL) smc->stats.tx_window_errors++;
1571 if (tx_status & TS_16COL) {
1572 smc->stats.tx_aborted_errors++;
1573 smc->tx_err++;
1574 }
1575
1576 if (tx_status & TS_SUCCESS) {
1577 printk(KERN_NOTICE "%s: Successful packet caused error "
1578 "interrupt?\n", dev->name);
1579 }
1580 /* re-enable transmit */
1581 SMC_SELECT_BANK(0);
1582 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1583 SMC_SELECT_BANK(2);
1584
1585 outw(MC_FREEPKT, ioaddr + MMU_CMD); /* Free the packet memory. */
1586
1587 /* one less packet waiting for me */
1588 smc->packets_waiting--;
1589
1590 outw(saved_packet, ioaddr + PNR_ARR);
1591 return;
1592 }
1593
1594 /*====================================================================*/
1595
1596 static void smc_eph_irq(struct net_device *dev)
1597 {
1598 struct smc_private *smc = netdev_priv(dev);
1599 kio_addr_t ioaddr = dev->base_addr;
1600 u_short card_stats, ephs;
1601
1602 SMC_SELECT_BANK(0);
1603 ephs = inw(ioaddr + EPH);
1604 DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1605 " %4.4x.\n", dev->name, ephs);
1606 /* Could be a counter roll-over warning: update stats. */
1607 card_stats = inw(ioaddr + COUNTER);
1608 /* single collisions */
1609 smc->stats.collisions += card_stats & 0xF;
1610 card_stats >>= 4;
1611 /* multiple collisions */
1612 smc->stats.collisions += card_stats & 0xF;
1613 #if 0 /* These are for when linux supports these statistics */
1614 card_stats >>= 4; /* deferred */
1615 card_stats >>= 4; /* excess deferred */
1616 #endif
1617 /* If we had a transmit error we must re-enable the transmitter. */
1618 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1619
1620 /* Clear a link error interrupt. */
1621 SMC_SELECT_BANK(1);
1622 outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1623 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1624 ioaddr + CONTROL);
1625 SMC_SELECT_BANK(2);
1626 }
1627
1628 /*====================================================================*/
1629
1630 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1631 {
1632 struct net_device *dev = dev_id;
1633 struct smc_private *smc = netdev_priv(dev);
1634 kio_addr_t ioaddr;
1635 u_short saved_bank, saved_pointer, mask, status;
1636 unsigned int handled = 1;
1637 char bogus_cnt = INTR_WORK; /* Work we are willing to do. */
1638
1639 if (!netif_device_present(dev))
1640 return IRQ_NONE;
1641
1642 ioaddr = dev->base_addr;
1643
1644 DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1645 irq, ioaddr);
1646
1647 smc->watchdog = 0;
1648 saved_bank = inw(ioaddr + BANK_SELECT);
1649 if ((saved_bank & 0xff00) != 0x3300) {
1650 /* The device does not exist -- the card could be off-line, or
1651 maybe it has been ejected. */
1652 DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1653 "/ejected device.\n", dev->name, irq);
1654 handled = 0;
1655 goto irq_done;
1656 }
1657
1658 SMC_SELECT_BANK(2);
1659 saved_pointer = inw(ioaddr + POINTER);
1660 mask = inw(ioaddr + INTERRUPT) >> 8;
1661 /* clear all interrupts */
1662 outw(0, ioaddr + INTERRUPT);
1663
1664 do { /* read the status flag, and mask it */
1665 status = inw(ioaddr + INTERRUPT) & 0xff;
1666 DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1667 status, mask);
1668 if ((status & mask) == 0) {
1669 if (bogus_cnt == INTR_WORK)
1670 handled = 0;
1671 break;
1672 }
1673 if (status & IM_RCV_INT) {
1674 /* Got a packet(s). */
1675 smc_rx(dev);
1676 }
1677 if (status & IM_TX_INT) {
1678 smc_tx_err(dev);
1679 outw(IM_TX_INT, ioaddr + INTERRUPT);
1680 }
1681 status &= mask;
1682 if (status & IM_TX_EMPTY_INT) {
1683 outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1684 mask &= ~IM_TX_EMPTY_INT;
1685 smc->stats.tx_packets += smc->packets_waiting;
1686 smc->packets_waiting = 0;
1687 }
1688 if (status & IM_ALLOC_INT) {
1689 /* Clear this interrupt so it doesn't happen again */
1690 mask &= ~IM_ALLOC_INT;
1691
1692 smc_hardware_send_packet(dev);
1693
1694 /* enable xmit interrupts based on this */
1695 mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1696
1697 /* and let the card send more packets to me */
1698 netif_wake_queue(dev);
1699 }
1700 if (status & IM_RX_OVRN_INT) {
1701 smc->stats.rx_errors++;
1702 smc->stats.rx_fifo_errors++;
1703 if (smc->duplex)
1704 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1705 outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1706 }
1707 if (status & IM_EPH_INT)
1708 smc_eph_irq(dev);
1709 } while (--bogus_cnt);
1710
1711 DEBUG(3, " Restoring saved registers mask %2.2x bank %4.4x"
1712 " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1713
1714 /* restore state register */
1715 outw((mask<<8), ioaddr + INTERRUPT);
1716 outw(saved_pointer, ioaddr + POINTER);
1717 SMC_SELECT_BANK(saved_bank);
1718
1719 DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1720
1721 irq_done:
1722
1723 if ((smc->manfid == MANFID_OSITECH) &&
1724 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1725 /* Retrigger interrupt if needed */
1726 mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1727 set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1728 }
1729 if (smc->manfid == MANFID_MOTOROLA) {
1730 u_char cor;
1731 cor = readb(smc->base + MOT_UART + CISREG_COR);
1732 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1733 writeb(cor, smc->base + MOT_UART + CISREG_COR);
1734 cor = readb(smc->base + MOT_LAN + CISREG_COR);
1735 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1736 writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1737 }
1738 #ifdef DOES_NOT_WORK
1739 if (smc->base != NULL) { /* Megahertz MFC's */
1740 readb(smc->base+MEGAHERTZ_ISR);
1741 readb(smc->base+MEGAHERTZ_ISR);
1742 }
1743 #endif
1744 return IRQ_RETVAL(handled);
1745 }
1746
1747 /*====================================================================*/
1748
1749 static void smc_rx(struct net_device *dev)
1750 {
1751 struct smc_private *smc = netdev_priv(dev);
1752 kio_addr_t ioaddr = dev->base_addr;
1753 int rx_status;
1754 int packet_length; /* Caution: not frame length, rather words
1755 to transfer from the chip. */
1756
1757 /* Assertion: we are in Window 2. */
1758
1759 if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1760 printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1761 dev->name);
1762 return;
1763 }
1764
1765 /* Reset the read pointer, and read the status and packet length. */
1766 outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1767 rx_status = inw(ioaddr + DATA_1);
1768 packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1769
1770 DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1771 dev->name, rx_status, packet_length);
1772
1773 if (!(rx_status & RS_ERRORS)) {
1774 /* do stuff to make a new packet */
1775 struct sk_buff *skb;
1776
1777 /* Note: packet_length adds 5 or 6 extra bytes here! */
1778 skb = dev_alloc_skb(packet_length+2);
1779
1780 if (skb == NULL) {
1781 DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1782 smc->stats.rx_dropped++;
1783 outw(MC_RELEASE, ioaddr + MMU_CMD);
1784 return;
1785 }
1786
1787 packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1788 skb_reserve(skb, 2);
1789 insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1790 (packet_length+1)>>1);
1791 skb->protocol = eth_type_trans(skb, dev);
1792
1793 skb->dev = dev;
1794 netif_rx(skb);
1795 dev->last_rx = jiffies;
1796 smc->stats.rx_packets++;
1797 smc->stats.rx_bytes += packet_length;
1798 if (rx_status & RS_MULTICAST)
1799 smc->stats.multicast++;
1800 } else {
1801 /* error ... */
1802 smc->stats.rx_errors++;
1803
1804 if (rx_status & RS_ALGNERR) smc->stats.rx_frame_errors++;
1805 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1806 smc->stats.rx_length_errors++;
1807 if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
1808 }
1809 /* Let the MMU free the memory of this packet. */
1810 outw(MC_RELEASE, ioaddr + MMU_CMD);
1811
1812 return;
1813 }
1814
1815 /*====================================================================*/
1816
1817 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1818 {
1819 struct smc_private *smc = netdev_priv(dev);
1820 /* Nothing to update - the 91c92 is a pretty primative chip. */
1821 return &smc->stats;
1822 }
1823
1824 /*======================================================================
1825
1826 Calculate values for the hardware multicast filter hash table.
1827
1828 ======================================================================*/
1829
1830 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1831 u_char *multicast_table)
1832 {
1833 struct dev_mc_list *mc_addr;
1834
1835 for (mc_addr = addrs; mc_addr && --count > 0; mc_addr = mc_addr->next) {
1836 u_int position = ether_crc(6, mc_addr->dmi_addr);
1837 #ifndef final_version /* Verify multicast address. */
1838 if ((mc_addr->dmi_addr[0] & 1) == 0)
1839 continue;
1840 #endif
1841 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1842 }
1843 }
1844
1845 /*======================================================================
1846
1847 Set the receive mode.
1848
1849 This routine is used by both the protocol level to notify us of
1850 promiscuous/multicast mode changes, and by the open/reset code to
1851 initialize the Rx registers. We always set the multicast list and
1852 leave the receiver running.
1853
1854 ======================================================================*/
1855
1856 static void set_rx_mode(struct net_device *dev)
1857 {
1858 kio_addr_t ioaddr = dev->base_addr;
1859 struct smc_private *smc = netdev_priv(dev);
1860 u_int multicast_table[ 2 ] = { 0, };
1861 unsigned long flags;
1862 u_short rx_cfg_setting;
1863
1864 if (dev->flags & IFF_PROMISC) {
1865 printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.\n", dev->name);
1866 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1867 } else if (dev->flags & IFF_ALLMULTI)
1868 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1869 else {
1870 if (dev->mc_count) {
1871 fill_multicast_tbl(dev->mc_count, dev->mc_list,
1872 (u_char *)multicast_table);
1873 }
1874 rx_cfg_setting = RxStripCRC | RxEnable;
1875 }
1876
1877 /* Load MC table and Rx setting into the chip without interrupts. */
1878 spin_lock_irqsave(&smc->lock, flags);
1879 SMC_SELECT_BANK(3);
1880 outl(multicast_table[0], ioaddr + MULTICAST0);
1881 outl(multicast_table[1], ioaddr + MULTICAST4);
1882 SMC_SELECT_BANK(0);
1883 outw(rx_cfg_setting, ioaddr + RCR);
1884 SMC_SELECT_BANK(2);
1885 spin_unlock_irqrestore(&smc->lock, flags);
1886
1887 return;
1888 }
1889
1890 /*======================================================================
1891
1892 Senses when a card's config changes. Here, it's coax or TP.
1893
1894 ======================================================================*/
1895
1896 static int s9k_config(struct net_device *dev, struct ifmap *map)
1897 {
1898 struct smc_private *smc = netdev_priv(dev);
1899 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1900 if (smc->cfg & CFG_MII_SELECT)
1901 return -EOPNOTSUPP;
1902 else if (map->port > 2)
1903 return -EINVAL;
1904 dev->if_port = map->port;
1905 printk(KERN_INFO "%s: switched to %s port\n",
1906 dev->name, if_names[dev->if_port]);
1907 smc_reset(dev);
1908 }
1909 return 0;
1910 }
1911
1912 /*======================================================================
1913
1914 Reset the chip, reloading every register that might be corrupted.
1915
1916 ======================================================================*/
1917
1918 /*
1919 Set transceiver type, perhaps to something other than what the user
1920 specified in dev->if_port.
1921 */
1922 static void smc_set_xcvr(struct net_device *dev, int if_port)
1923 {
1924 struct smc_private *smc = netdev_priv(dev);
1925 kio_addr_t ioaddr = dev->base_addr;
1926 u_short saved_bank;
1927
1928 saved_bank = inw(ioaddr + BANK_SELECT);
1929 SMC_SELECT_BANK(1);
1930 if (if_port == 2) {
1931 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1932 if ((smc->manfid == MANFID_OSITECH) &&
1933 (smc->cardid != PRODID_OSITECH_SEVEN))
1934 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1935 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1936 } else {
1937 outw(smc->cfg, ioaddr + CONFIG);
1938 if ((smc->manfid == MANFID_OSITECH) &&
1939 (smc->cardid != PRODID_OSITECH_SEVEN))
1940 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1941 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1942 }
1943 SMC_SELECT_BANK(saved_bank);
1944 }
1945
1946 static void smc_reset(struct net_device *dev)
1947 {
1948 kio_addr_t ioaddr = dev->base_addr;
1949 struct smc_private *smc = netdev_priv(dev);
1950 int i;
1951
1952 DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1953
1954 /* The first interaction must be a write to bring the chip out
1955 of sleep mode. */
1956 SMC_SELECT_BANK(0);
1957 /* Reset the chip. */
1958 outw(RCR_SOFTRESET, ioaddr + RCR);
1959 udelay(10);
1960
1961 /* Clear the transmit and receive configuration registers. */
1962 outw(RCR_CLEAR, ioaddr + RCR);
1963 outw(TCR_CLEAR, ioaddr + TCR);
1964
1965 /* Set the Window 1 control, configuration and station addr registers.
1966 No point in writing the I/O base register ;-> */
1967 SMC_SELECT_BANK(1);
1968 /* Automatically release succesfully transmitted packets,
1969 Accept link errors, counter and Tx error interrupts. */
1970 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1971 ioaddr + CONTROL);
1972 smc_set_xcvr(dev, dev->if_port);
1973 if ((smc->manfid == MANFID_OSITECH) &&
1974 (smc->cardid != PRODID_OSITECH_SEVEN))
1975 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1976 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1977 ioaddr - 0x10 + OSITECH_AUI_PWR);
1978
1979 /* Fill in the physical address. The databook is wrong about the order! */
1980 for (i = 0; i < 6; i += 2)
1981 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1982 ioaddr + ADDR0 + i);
1983
1984 /* Reset the MMU */
1985 SMC_SELECT_BANK(2);
1986 outw(MC_RESET, ioaddr + MMU_CMD);
1987 outw(0, ioaddr + INTERRUPT);
1988
1989 /* Re-enable the chip. */
1990 SMC_SELECT_BANK(0);
1991 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1992 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1993 set_rx_mode(dev);
1994
1995 if (smc->cfg & CFG_MII_SELECT) {
1996 SMC_SELECT_BANK(3);
1997
1998 /* Reset MII */
1999 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
2000
2001 /* Advertise 100F, 100H, 10F, 10H */
2002 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
2003
2004 /* Restart MII autonegotiation */
2005 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
2006 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
2007 }
2008
2009 /* Enable interrupts. */
2010 SMC_SELECT_BANK(2);
2011 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
2012 ioaddr + INTERRUPT);
2013 }
2014
2015 /*======================================================================
2016
2017 Media selection timer routine
2018
2019 ======================================================================*/
2020
2021 static void media_check(u_long arg)
2022 {
2023 struct net_device *dev = (struct net_device *) arg;
2024 struct smc_private *smc = netdev_priv(dev);
2025 kio_addr_t ioaddr = dev->base_addr;
2026 u_short i, media, saved_bank;
2027 u_short link;
2028
2029 saved_bank = inw(ioaddr + BANK_SELECT);
2030
2031 if (!netif_device_present(dev))
2032 goto reschedule;
2033
2034 SMC_SELECT_BANK(2);
2035
2036 /* need MC_RESET to keep the memory consistent. errata? */
2037 if (smc->rx_ovrn) {
2038 outw(MC_RESET, ioaddr + MMU_CMD);
2039 smc->rx_ovrn = 0;
2040 }
2041 i = inw(ioaddr + INTERRUPT);
2042 SMC_SELECT_BANK(0);
2043 media = inw(ioaddr + EPH) & EPH_LINK_OK;
2044 SMC_SELECT_BANK(1);
2045 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
2046
2047 /* Check for pending interrupt with watchdog flag set: with
2048 this, we can limp along even if the interrupt is blocked */
2049 if (smc->watchdog++ && ((i>>8) & i)) {
2050 if (!smc->fast_poll)
2051 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
2052 smc_interrupt(dev->irq, smc, NULL);
2053 smc->fast_poll = HZ;
2054 }
2055 if (smc->fast_poll) {
2056 smc->fast_poll--;
2057 smc->media.expires = jiffies + HZ/100;
2058 add_timer(&smc->media);
2059 SMC_SELECT_BANK(saved_bank);
2060 return;
2061 }
2062
2063 if (smc->cfg & CFG_MII_SELECT) {
2064 if (smc->mii_if.phy_id < 0)
2065 goto reschedule;
2066
2067 SMC_SELECT_BANK(3);
2068 link = mdio_read(dev, smc->mii_if.phy_id, 1);
2069 if (!link || (link == 0xffff)) {
2070 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
2071 smc->mii_if.phy_id = -1;
2072 goto reschedule;
2073 }
2074
2075 link &= 0x0004;
2076 if (link != smc->link_status) {
2077 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
2078 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2079 (link) ? "found" : "lost");
2080 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
2081 ? TCR_FDUPLX : 0);
2082 if (link) {
2083 printk(KERN_INFO "%s: autonegotiation complete: "
2084 "%sbaseT-%cD selected\n", dev->name,
2085 ((p & 0x0180) ? "100" : "10"),
2086 (smc->duplex ? 'F' : 'H'));
2087 }
2088 SMC_SELECT_BANK(0);
2089 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
2090 smc->link_status = link;
2091 }
2092 goto reschedule;
2093 }
2094
2095 /* Ignore collisions unless we've had no rx's recently */
2096 if (time_after(jiffies, dev->last_rx + HZ)) {
2097 if (smc->tx_err || (smc->media_status & EPH_16COL))
2098 media |= EPH_16COL;
2099 }
2100 smc->tx_err = 0;
2101
2102 if (media != smc->media_status) {
2103 if ((media & smc->media_status & 1) &&
2104 ((smc->media_status ^ media) & EPH_LINK_OK))
2105 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2106 (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
2107 else if ((media & smc->media_status & 2) &&
2108 ((smc->media_status ^ media) & EPH_16COL))
2109 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
2110 (media & EPH_16COL ? "problem" : "ok"));
2111 if (dev->if_port == 0) {
2112 if (media & 1) {
2113 if (media & EPH_LINK_OK)
2114 printk(KERN_INFO "%s: flipped to 10baseT\n",
2115 dev->name);
2116 else
2117 smc_set_xcvr(dev, 2);
2118 } else {
2119 if (media & EPH_16COL)
2120 smc_set_xcvr(dev, 1);
2121 else
2122 printk(KERN_INFO "%s: flipped to 10base2\n",
2123 dev->name);
2124 }
2125 }
2126 smc->media_status = media;
2127 }
2128
2129 reschedule:
2130 smc->media.expires = jiffies + HZ;
2131 add_timer(&smc->media);
2132 SMC_SELECT_BANK(saved_bank);
2133 }
2134
2135 static int smc_link_ok(struct net_device *dev)
2136 {
2137 kio_addr_t ioaddr = dev->base_addr;
2138 struct smc_private *smc = netdev_priv(dev);
2139
2140 if (smc->cfg & CFG_MII_SELECT) {
2141 return mii_link_ok(&smc->mii_if);
2142 } else {
2143 SMC_SELECT_BANK(0);
2144 return inw(ioaddr + EPH) & EPH_LINK_OK;
2145 }
2146 }
2147
2148 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2149 {
2150 u16 tmp;
2151 kio_addr_t ioaddr = dev->base_addr;
2152
2153 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2154 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2155
2156 SMC_SELECT_BANK(1);
2157 tmp = inw(ioaddr + CONFIG);
2158 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2159 ecmd->transceiver = XCVR_INTERNAL;
2160 ecmd->speed = SPEED_10;
2161 ecmd->phy_address = ioaddr + MGMT;
2162
2163 SMC_SELECT_BANK(0);
2164 tmp = inw(ioaddr + TCR);
2165 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2166
2167 return 0;
2168 }
2169
2170 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2171 {
2172 u16 tmp;
2173 kio_addr_t ioaddr = dev->base_addr;
2174
2175 if (ecmd->speed != SPEED_10)
2176 return -EINVAL;
2177 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2178 return -EINVAL;
2179 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2180 return -EINVAL;
2181 if (ecmd->transceiver != XCVR_INTERNAL)
2182 return -EINVAL;
2183
2184 if (ecmd->port == PORT_AUI)
2185 smc_set_xcvr(dev, 1);
2186 else
2187 smc_set_xcvr(dev, 0);
2188
2189 SMC_SELECT_BANK(0);
2190 tmp = inw(ioaddr + TCR);
2191 if (ecmd->duplex == DUPLEX_FULL)
2192 tmp |= TCR_FDUPLX;
2193 else
2194 tmp &= ~TCR_FDUPLX;
2195 outw(tmp, ioaddr + TCR);
2196
2197 return 0;
2198 }
2199
2200 static int check_if_running(struct net_device *dev)
2201 {
2202 if (!netif_running(dev))
2203 return -EINVAL;
2204 return 0;
2205 }
2206
2207 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2208 {
2209 strcpy(info->driver, DRV_NAME);
2210 strcpy(info->version, DRV_VERSION);
2211 }
2212
2213 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2214 {
2215 struct smc_private *smc = netdev_priv(dev);
2216 kio_addr_t ioaddr = dev->base_addr;
2217 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2218 int ret;
2219
2220 SMC_SELECT_BANK(3);
2221 spin_lock_irq(&smc->lock);
2222 if (smc->cfg & CFG_MII_SELECT)
2223 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2224 else
2225 ret = smc_netdev_get_ecmd(dev, ecmd);
2226 spin_unlock_irq(&smc->lock);
2227 SMC_SELECT_BANK(saved_bank);
2228 return ret;
2229 }
2230
2231 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2232 {
2233 struct smc_private *smc = netdev_priv(dev);
2234 kio_addr_t ioaddr = dev->base_addr;
2235 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2236 int ret;
2237
2238 SMC_SELECT_BANK(3);
2239 spin_lock_irq(&smc->lock);
2240 if (smc->cfg & CFG_MII_SELECT)
2241 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2242 else
2243 ret = smc_netdev_set_ecmd(dev, ecmd);
2244 spin_unlock_irq(&smc->lock);
2245 SMC_SELECT_BANK(saved_bank);
2246 return ret;
2247 }
2248
2249 static u32 smc_get_link(struct net_device *dev)
2250 {
2251 struct smc_private *smc = netdev_priv(dev);
2252 kio_addr_t ioaddr = dev->base_addr;
2253 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2254 u32 ret;
2255
2256 SMC_SELECT_BANK(3);
2257 spin_lock_irq(&smc->lock);
2258 ret = smc_link_ok(dev);
2259 spin_unlock_irq(&smc->lock);
2260 SMC_SELECT_BANK(saved_bank);
2261 return ret;
2262 }
2263
2264 #ifdef PCMCIA_DEBUG
2265 static u32 smc_get_msglevel(struct net_device *dev)
2266 {
2267 return pc_debug;
2268 }
2269
2270 static void smc_set_msglevel(struct net_device *dev, u32 val)
2271 {
2272 pc_debug = val;
2273 }
2274 #endif
2275
2276 static int smc_nway_reset(struct net_device *dev)
2277 {
2278 struct smc_private *smc = netdev_priv(dev);
2279 if (smc->cfg & CFG_MII_SELECT) {
2280 kio_addr_t ioaddr = dev->base_addr;
2281 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2282 int res;
2283
2284 SMC_SELECT_BANK(3);
2285 res = mii_nway_restart(&smc->mii_if);
2286 SMC_SELECT_BANK(saved_bank);
2287
2288 return res;
2289 } else
2290 return -EOPNOTSUPP;
2291 }
2292
2293 static struct ethtool_ops ethtool_ops = {
2294 .begin = check_if_running,
2295 .get_drvinfo = smc_get_drvinfo,
2296 .get_settings = smc_get_settings,
2297 .set_settings = smc_set_settings,
2298 .get_link = smc_get_link,
2299 #ifdef PCMCIA_DEBUG
2300 .get_msglevel = smc_get_msglevel,
2301 .set_msglevel = smc_set_msglevel,
2302 #endif
2303 .nway_reset = smc_nway_reset,
2304 };
2305
2306 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2307 {
2308 struct smc_private *smc = netdev_priv(dev);
2309 struct mii_ioctl_data *mii = if_mii(rq);
2310 int rc = 0;
2311 u16 saved_bank;
2312 kio_addr_t ioaddr = dev->base_addr;
2313
2314 if (!netif_running(dev))
2315 return -EINVAL;
2316
2317 spin_lock_irq(&smc->lock);
2318 saved_bank = inw(ioaddr + BANK_SELECT);
2319 SMC_SELECT_BANK(3);
2320 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2321 SMC_SELECT_BANK(saved_bank);
2322 spin_unlock_irq(&smc->lock);
2323 return rc;
2324 }
2325
2326 static struct pcmcia_device_id smc91c92_ids[] = {
2327 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2328 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2329 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2330 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2331 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2332 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2333 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2334 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2335 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2336 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2337 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2338 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2339 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2340 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2341 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2342 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2343 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2344 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2345 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2346 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2347 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2348 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2349 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2350 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2351 /* These conflict with other cards! */
2352 /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2353 /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2354 PCMCIA_DEVICE_NULL,
2355 };
2356 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2357
2358 static struct pcmcia_driver smc91c92_cs_driver = {
2359 .owner = THIS_MODULE,
2360 .drv = {
2361 .name = "smc91c92_cs",
2362 },
2363 .attach = smc91c92_attach,
2364 .event = smc91c92_event,
2365 .detach = smc91c92_detach,
2366 .id_table = smc91c92_ids,
2367 };
2368
2369 static int __init init_smc91c92_cs(void)
2370 {
2371 return pcmcia_register_driver(&smc91c92_cs_driver);
2372 }
2373
2374 static void __exit exit_smc91c92_cs(void)
2375 {
2376 pcmcia_unregister_driver(&smc91c92_cs_driver);
2377 BUG_ON(dev_list != NULL);
2378 }
2379
2380 module_init(init_smc91c92_cs);
2381 module_exit(exit_smc91c92_cs);
kernel-based virtual machine