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