1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/slab.h>
33#include <linux/string.h>
34#include <linux/timer.h>
35#include <linux/interrupt.h>
36#include <linux/delay.h>
37#include <linux/crc32.h>
38#include <linux/netdevice.h>
39#include <linux/etherdevice.h>
40#include <linux/skbuff.h>
41#include <linux/if_arp.h>
42#include <linux/ioport.h>
43#include <linux/ethtool.h>
44#include <linux/mii.h>
45#include <linux/jiffies.h>
46#include <linux/firmware.h>
47
48#include <pcmcia/cistpl.h>
49#include <pcmcia/cisreg.h>
50#include <pcmcia/ciscode.h>
51#include <pcmcia/ds.h>
52#include <pcmcia/ss.h>
53
54#include <asm/io.h>
55#include <asm/uaccess.h>
56
57
58
59static const char *if_names[] = { "auto", "10baseT", "10base2"};
60
61
62#define FIRMWARE_NAME "ositech/Xilinx7OD.bin"
63
64
65
66MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
67MODULE_LICENSE("GPL");
68MODULE_FIRMWARE(FIRMWARE_NAME);
69
70#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
71
72
73
74
75
76
77
78INT_MODULE_PARM(if_port, 0);
79
80
81#define DRV_NAME "smc91c92_cs"
82#define DRV_VERSION "1.123"
83
84
85
86
87
88
89#define TX_TIMEOUT ((400*HZ)/1000)
90
91
92#define INTR_WORK 4
93
94
95
96#define MEMORY_WAIT_TIME 8
97
98struct smc_private {
99 struct pcmcia_device *p_dev;
100 spinlock_t lock;
101 u_short manfid;
102 u_short cardid;
103
104 struct sk_buff *saved_skb;
105 int packets_waiting;
106 void __iomem *base;
107 u_short cfg;
108 struct timer_list media;
109 int watchdog, tx_err;
110 u_short media_status;
111 u_short fast_poll;
112 u_short link_status;
113 struct mii_if_info mii_if;
114 int duplex;
115 int rx_ovrn;
116};
117
118
119#define MEGAHERTZ_ISR 0x0380
120
121
122#define MOT_LAN 0x0000
123#define MOT_UART 0x0020
124#define MOT_EEPROM 0x20
125
126#define MOT_NORMAL \
127(COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
128
129
130#define OSITECH_AUI_CTL 0x0c
131#define OSITECH_PWRDOWN 0x0d
132#define OSITECH_RESET 0x0e
133#define OSITECH_ISR 0x0f
134#define OSITECH_AUI_PWR 0x0c
135#define OSITECH_RESET_ISR 0x0e
136
137#define OSI_AUI_PWR 0x40
138#define OSI_LAN_PWRDOWN 0x02
139#define OSI_MODEM_PWRDOWN 0x01
140#define OSI_LAN_RESET 0x02
141#define OSI_MODEM_RESET 0x01
142
143
144#define BANK_SELECT 14
145#define SMC_SELECT_BANK(x) { outw(x, ioaddr + BANK_SELECT); }
146
147
148#define TCR 0
149#define TCR_CLEAR 0
150#define TCR_ENABLE 0x0001
151#define TCR_PAD_EN 0x0080
152#define TCR_MONCSN 0x0400
153#define TCR_FDUPLX 0x0800
154#define TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
155
156#define EPH 2
157#define EPH_TX_SUC 0x0001
158#define EPH_SNGLCOL 0x0002
159#define EPH_MULCOL 0x0004
160#define EPH_LTX_MULT 0x0008
161#define EPH_16COL 0x0010
162#define EPH_SQET 0x0020
163#define EPH_LTX_BRD 0x0040
164#define EPH_TX_DEFR 0x0080
165#define EPH_LAT_COL 0x0200
166#define EPH_LOST_CAR 0x0400
167#define EPH_EXC_DEF 0x0800
168#define EPH_CTR_ROL 0x1000
169#define EPH_RX_OVRN 0x2000
170#define EPH_LINK_OK 0x4000
171#define EPH_TX_UNRN 0x8000
172#define MEMINFO 8
173#define MEMCFG 10
174
175
176#define CONFIG 0
177#define CFG_MII_SELECT 0x8000
178#define CFG_NO_WAIT 0x1000
179#define CFG_FULL_STEP 0x0400
180#define CFG_SET_SQLCH 0x0200
181#define CFG_AUI_SELECT 0x0100
182#define CFG_16BIT 0x0080
183#define CFG_DIS_LINK 0x0040
184#define CFG_STATIC 0x0030
185#define CFG_IRQ_SEL_1 0x0004
186#define CFG_IRQ_SEL_0 0x0002
187#define BASE_ADDR 2
188#define ADDR0 4
189#define GENERAL 10
190#define CONTROL 12
191#define CTL_STORE 0x0001
192#define CTL_RELOAD 0x0002
193#define CTL_EE_SELECT 0x0004
194#define CTL_TE_ENABLE 0x0020
195#define CTL_CR_ENABLE 0x0040
196#define CTL_LE_ENABLE 0x0080
197#define CTL_AUTO_RELEASE 0x0800
198#define CTL_POWERDOWN 0x2000
199
200
201#define MMU_CMD 0
202#define MC_ALLOC 0x20
203#define MC_RESET 0x40
204#define MC_RELEASE 0x80
205#define MC_FREEPKT 0xA0
206#define MC_ENQUEUE 0xC0
207#define PNR_ARR 2
208#define FIFO_PORTS 4
209#define FP_RXEMPTY 0x8000
210#define POINTER 6
211#define PTR_AUTO_INC 0x0040
212#define PTR_READ 0x2000
213#define PTR_AUTOINC 0x4000
214#define PTR_RCV 0x8000
215#define DATA_1 8
216#define INTERRUPT 12
217#define IM_RCV_INT 0x1
218#define IM_TX_INT 0x2
219#define IM_TX_EMPTY_INT 0x4
220#define IM_ALLOC_INT 0x8
221#define IM_RX_OVRN_INT 0x10
222#define IM_EPH_INT 0x20
223
224#define RCR 4
225enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
226 RxEnable = 0x0100, RxStripCRC = 0x0200};
227#define RCR_SOFTRESET 0x8000
228#define RCR_STRIP_CRC 0x200
229#define RCR_ENABLE 0x100
230#define RCR_ALMUL 0x4
231#define RCR_PROMISC 0x2
232
233
234#define RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
235#define RCR_CLEAR 0x0
236#define COUNTER 6
237
238
239#define MULTICAST0 0
240#define MULTICAST2 2
241#define MULTICAST4 4
242#define MULTICAST6 6
243#define MGMT 8
244#define REVISION 0x0a
245
246
247#define TS_SUCCESS 0x0001
248#define TS_16COL 0x0010
249#define TS_LATCOL 0x0200
250#define TS_LOSTCAR 0x0400
251
252
253#define RS_ALGNERR 0x8000
254#define RS_BADCRC 0x2000
255#define RS_ODDFRAME 0x1000
256#define RS_TOOLONG 0x0800
257#define RS_TOOSHORT 0x0400
258#define RS_MULTICAST 0x0001
259#define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
260
261#define set_bits(v, p) outw(inw(p)|(v), (p))
262#define mask_bits(v, p) outw(inw(p)&(v), (p))
263
264
265
266static void smc91c92_detach(struct pcmcia_device *p_dev);
267static int smc91c92_config(struct pcmcia_device *link);
268static void smc91c92_release(struct pcmcia_device *link);
269
270static int smc_open(struct net_device *dev);
271static int smc_close(struct net_device *dev);
272static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
273static void smc_tx_timeout(struct net_device *dev);
274static netdev_tx_t smc_start_xmit(struct sk_buff *skb,
275 struct net_device *dev);
276static irqreturn_t smc_interrupt(int irq, void *dev_id);
277static void smc_rx(struct net_device *dev);
278static void set_rx_mode(struct net_device *dev);
279static int s9k_config(struct net_device *dev, struct ifmap *map);
280static void smc_set_xcvr(struct net_device *dev, int if_port);
281static void smc_reset(struct net_device *dev);
282static void media_check(u_long arg);
283static void mdio_sync(unsigned int addr);
284static int mdio_read(struct net_device *dev, int phy_id, int loc);
285static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
286static int smc_link_ok(struct net_device *dev);
287static const struct ethtool_ops ethtool_ops;
288
289static const struct net_device_ops smc_netdev_ops = {
290 .ndo_open = smc_open,
291 .ndo_stop = smc_close,
292 .ndo_start_xmit = smc_start_xmit,
293 .ndo_tx_timeout = smc_tx_timeout,
294 .ndo_set_config = s9k_config,
295 .ndo_set_rx_mode = set_rx_mode,
296 .ndo_do_ioctl = smc_ioctl,
297 .ndo_change_mtu = eth_change_mtu,
298 .ndo_set_mac_address = eth_mac_addr,
299 .ndo_validate_addr = eth_validate_addr,
300};
301
302static int smc91c92_probe(struct pcmcia_device *link)
303{
304 struct smc_private *smc;
305 struct net_device *dev;
306
307 dev_dbg(&link->dev, "smc91c92_attach()\n");
308
309
310 dev = alloc_etherdev(sizeof(struct smc_private));
311 if (!dev)
312 return -ENOMEM;
313 smc = netdev_priv(dev);
314 smc->p_dev = link;
315 link->priv = dev;
316
317 spin_lock_init(&smc->lock);
318
319
320 dev->netdev_ops = &smc_netdev_ops;
321 dev->ethtool_ops = ðtool_ops;
322 dev->watchdog_timeo = TX_TIMEOUT;
323
324 smc->mii_if.dev = dev;
325 smc->mii_if.mdio_read = mdio_read;
326 smc->mii_if.mdio_write = mdio_write;
327 smc->mii_if.phy_id_mask = 0x1f;
328 smc->mii_if.reg_num_mask = 0x1f;
329
330 return smc91c92_config(link);
331}
332
333static void smc91c92_detach(struct pcmcia_device *link)
334{
335 struct net_device *dev = link->priv;
336
337 dev_dbg(&link->dev, "smc91c92_detach\n");
338
339 unregister_netdev(dev);
340
341 smc91c92_release(link);
342
343 free_netdev(dev);
344}
345
346
347
348static int cvt_ascii_address(struct net_device *dev, char *s)
349{
350 int i, j, da, c;
351
352 if (strlen(s) != 12)
353 return -1;
354 for (i = 0; i < 6; i++) {
355 da = 0;
356 for (j = 0; j < 2; j++) {
357 c = *s++;
358 da <<= 4;
359 da += ((c >= '0') && (c <= '9')) ?
360 (c - '0') : ((c & 0x0f) + 9);
361 }
362 dev->dev_addr[i] = da;
363 }
364 return 0;
365}
366
367
368
369
370
371
372
373
374
375
376
377
378static int mhz_3288_power(struct pcmcia_device *link)
379{
380 struct net_device *dev = link->priv;
381 struct smc_private *smc = netdev_priv(dev);
382 u_char tmp;
383
384
385 readb(smc->base+MEGAHERTZ_ISR);
386 udelay(5);
387 readb(smc->base+MEGAHERTZ_ISR);
388
389
390 mdelay(200);
391
392
393 tmp = readb(smc->base + link->config_base + CISREG_COR);
394 udelay(5);
395 writeb(tmp, smc->base + link->config_base + CISREG_COR);
396
397 return 0;
398}
399
400static int mhz_mfc_config_check(struct pcmcia_device *p_dev, void *priv_data)
401{
402 int k;
403 p_dev->io_lines = 16;
404 p_dev->resource[1]->start = p_dev->resource[0]->start;
405 p_dev->resource[1]->end = 8;
406 p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
407 p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
408 p_dev->resource[0]->end = 16;
409 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
410 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
411 for (k = 0; k < 0x400; k += 0x10) {
412 if (k & 0x80)
413 continue;
414 p_dev->resource[0]->start = k ^ 0x300;
415 if (!pcmcia_request_io(p_dev))
416 return 0;
417 }
418 return -ENODEV;
419}
420
421static int mhz_mfc_config(struct pcmcia_device *link)
422{
423 struct net_device *dev = link->priv;
424 struct smc_private *smc = netdev_priv(dev);
425 unsigned int offset;
426 int i;
427
428 link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ |
429 CONF_AUTO_SET_IO;
430
431
432
433 if (pcmcia_loop_config(link, mhz_mfc_config_check, NULL))
434 return -ENODEV;
435
436 dev->base_addr = link->resource[0]->start;
437
438
439 link->resource[2]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
440 link->resource[2]->start = link->resource[2]->end = 0;
441 i = pcmcia_request_window(link, link->resource[2], 0);
442 if (i != 0)
443 return -ENODEV;
444
445 smc->base = ioremap(link->resource[2]->start,
446 resource_size(link->resource[2]));
447 offset = (smc->manfid == MANFID_MOTOROLA) ? link->config_base : 0;
448 i = pcmcia_map_mem_page(link, link->resource[2], offset);
449 if ((i == 0) &&
450 (smc->manfid == MANFID_MEGAHERTZ) &&
451 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
452 mhz_3288_power(link);
453
454 return 0;
455}
456
457static int pcmcia_get_versmac(struct pcmcia_device *p_dev,
458 tuple_t *tuple,
459 void *priv)
460{
461 struct net_device *dev = priv;
462 cisparse_t parse;
463 u8 *buf;
464
465 if (pcmcia_parse_tuple(tuple, &parse))
466 return -EINVAL;
467
468 buf = parse.version_1.str + parse.version_1.ofs[3];
469
470 if ((parse.version_1.ns > 3) && (cvt_ascii_address(dev, buf) == 0))
471 return 0;
472
473 return -EINVAL;
474};
475
476static int mhz_setup(struct pcmcia_device *link)
477{
478 struct net_device *dev = link->priv;
479 size_t len;
480 u8 *buf;
481 int rc;
482
483
484
485 if ((link->prod_id[3]) &&
486 (cvt_ascii_address(dev, link->prod_id[3]) == 0))
487 return 0;
488
489
490
491 if (!pcmcia_loop_tuple(link, CISTPL_VERS_1, pcmcia_get_versmac, dev))
492 return 0;
493
494
495 rc = -1;
496 len = pcmcia_get_tuple(link, 0x81, &buf);
497 if (buf && len >= 13) {
498 buf[12] = '\0';
499 if (cvt_ascii_address(dev, buf) == 0)
500 rc = 0;
501 }
502 kfree(buf);
503
504 return rc;
505};
506
507
508
509
510
511
512
513
514
515
516static void mot_config(struct pcmcia_device *link)
517{
518 struct net_device *dev = link->priv;
519 struct smc_private *smc = netdev_priv(dev);
520 unsigned int ioaddr = dev->base_addr;
521 unsigned int iouart = link->resource[1]->start;
522
523
524 writeb(iouart & 0xff, smc->base + MOT_UART + CISREG_IOBASE_0);
525 writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
526 writeb(MOT_NORMAL, smc->base + MOT_UART + CISREG_COR);
527
528
529 writeb(ioaddr & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_0);
530 writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
531 writeb(MOT_NORMAL, smc->base + MOT_LAN + CISREG_COR);
532
533
534 mdelay(100);
535}
536
537static int mot_setup(struct pcmcia_device *link)
538{
539 struct net_device *dev = link->priv;
540 unsigned int ioaddr = dev->base_addr;
541 int i, wait, loop;
542 u_int addr;
543
544
545
546 for (i = 0; i < 3; i++) {
547 SMC_SELECT_BANK(2);
548 outw(MOT_EEPROM + i, ioaddr + POINTER);
549 SMC_SELECT_BANK(1);
550 outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
551
552 for (loop = wait = 0; loop < 200; loop++) {
553 udelay(10);
554 wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
555 if (wait == 0) break;
556 }
557
558 if (wait)
559 return -1;
560
561 addr = inw(ioaddr + GENERAL);
562 dev->dev_addr[2*i] = addr & 0xff;
563 dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
564 }
565
566 return 0;
567}
568
569
570
571static int smc_configcheck(struct pcmcia_device *p_dev, void *priv_data)
572{
573 p_dev->resource[0]->end = 16;
574 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
575 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
576
577 return pcmcia_request_io(p_dev);
578}
579
580static int smc_config(struct pcmcia_device *link)
581{
582 struct net_device *dev = link->priv;
583 int i;
584
585 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
586
587 i = pcmcia_loop_config(link, smc_configcheck, NULL);
588 if (!i)
589 dev->base_addr = link->resource[0]->start;
590
591 return i;
592}
593
594
595static int smc_setup(struct pcmcia_device *link)
596{
597 struct net_device *dev = link->priv;
598
599
600 if (!pcmcia_get_mac_from_cis(link, dev))
601 return 0;
602
603
604 if (link->prod_id[2]) {
605 if (cvt_ascii_address(dev, link->prod_id[2]) == 0)
606 return 0;
607 }
608 return -1;
609}
610
611
612
613static int osi_config(struct pcmcia_device *link)
614{
615 struct net_device *dev = link->priv;
616 static const unsigned int com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
617 int i, j;
618
619 link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ;
620 link->resource[0]->end = 64;
621 link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
622 link->resource[1]->end = 8;
623
624
625 link->io_lines = 16;
626 link->config_index = 0x23;
627
628 for (i = j = 0; j < 4; j++) {
629 link->resource[1]->start = com[j];
630 i = pcmcia_request_io(link);
631 if (i == 0)
632 break;
633 }
634 if (i != 0) {
635
636 link->config_index = 0x03;
637 link->resource[1]->end = 0;
638 i = pcmcia_request_io(link);
639 }
640 dev->base_addr = link->resource[0]->start + 0x10;
641 return i;
642}
643
644static int osi_load_firmware(struct pcmcia_device *link)
645{
646 const struct firmware *fw;
647 int i, err;
648
649 err = request_firmware(&fw, FIRMWARE_NAME, &link->dev);
650 if (err) {
651 pr_err("Failed to load firmware \"%s\"\n", FIRMWARE_NAME);
652 return err;
653 }
654
655
656 for (i = 0; i < fw->size; i++) {
657 outb(fw->data[i], link->resource[0]->start + 2);
658 udelay(50);
659 }
660 release_firmware(fw);
661 return err;
662}
663
664static int pcmcia_osi_mac(struct pcmcia_device *p_dev,
665 tuple_t *tuple,
666 void *priv)
667{
668 struct net_device *dev = priv;
669 int i;
670
671 if (tuple->TupleDataLen < 8)
672 return -EINVAL;
673 if (tuple->TupleData[0] != 0x04)
674 return -EINVAL;
675 for (i = 0; i < 6; i++)
676 dev->dev_addr[i] = tuple->TupleData[i+2];
677 return 0;
678};
679
680
681static int osi_setup(struct pcmcia_device *link, u_short manfid, u_short cardid)
682{
683 struct net_device *dev = link->priv;
684 int rc;
685
686
687 if (pcmcia_loop_tuple(link, 0x90, pcmcia_osi_mac, dev))
688 return -1;
689
690 if (((manfid == MANFID_OSITECH) &&
691 (cardid == PRODID_OSITECH_SEVEN)) ||
692 ((manfid == MANFID_PSION) &&
693 (cardid == PRODID_PSION_NET100))) {
694 rc = osi_load_firmware(link);
695 if (rc)
696 return rc;
697 } else if (manfid == MANFID_OSITECH) {
698
699 set_bits(0x300, link->resource[0]->start + OSITECH_AUI_PWR);
700
701 set_bits(0x300, link->resource[0]->start + OSITECH_RESET_ISR);
702 dev_dbg(&link->dev, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
703 inw(link->resource[0]->start + OSITECH_AUI_PWR),
704 inw(link->resource[0]->start + OSITECH_RESET_ISR));
705 }
706 return 0;
707}
708
709static int smc91c92_suspend(struct pcmcia_device *link)
710{
711 struct net_device *dev = link->priv;
712
713 if (link->open)
714 netif_device_detach(dev);
715
716 return 0;
717}
718
719static int smc91c92_resume(struct pcmcia_device *link)
720{
721 struct net_device *dev = link->priv;
722 struct smc_private *smc = netdev_priv(dev);
723 int i;
724
725 if ((smc->manfid == MANFID_MEGAHERTZ) &&
726 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
727 mhz_3288_power(link);
728 if (smc->manfid == MANFID_MOTOROLA)
729 mot_config(link);
730 if ((smc->manfid == MANFID_OSITECH) &&
731 (smc->cardid != PRODID_OSITECH_SEVEN)) {
732
733 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
734 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
735 }
736 if (((smc->manfid == MANFID_OSITECH) &&
737 (smc->cardid == PRODID_OSITECH_SEVEN)) ||
738 ((smc->manfid == MANFID_PSION) &&
739 (smc->cardid == PRODID_PSION_NET100))) {
740 i = osi_load_firmware(link);
741 if (i) {
742 netdev_err(dev, "Failed to load firmware\n");
743 return i;
744 }
745 }
746 if (link->open) {
747 smc_reset(dev);
748 netif_device_attach(dev);
749 }
750
751 return 0;
752}
753
754
755
756
757
758
759
760
761
762static int check_sig(struct pcmcia_device *link)
763{
764 struct net_device *dev = link->priv;
765 unsigned int ioaddr = dev->base_addr;
766 int width;
767 u_short s;
768
769 SMC_SELECT_BANK(1);
770 if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
771
772 outw(0, ioaddr + CONTROL);
773 mdelay(55);
774 }
775
776
777 width = (link->resource[0]->flags == IO_DATA_PATH_WIDTH_AUTO);
778 s = inb(ioaddr + CONFIG);
779 if (width)
780 s |= CFG_16BIT;
781 else
782 s &= ~CFG_16BIT;
783 outb(s, ioaddr + CONFIG);
784
785
786 s = inw(ioaddr + BASE_ADDR);
787 if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
788 ((s >> 8) != (s & 0xff))) {
789 SMC_SELECT_BANK(3);
790 s = inw(ioaddr + REVISION);
791 return s & 0xff;
792 }
793
794 if (width) {
795 netdev_info(dev, "using 8-bit IO window\n");
796
797 smc91c92_suspend(link);
798 pcmcia_fixup_iowidth(link);
799 smc91c92_resume(link);
800 return check_sig(link);
801 }
802 return -ENODEV;
803}
804
805static int smc91c92_config(struct pcmcia_device *link)
806{
807 struct net_device *dev = link->priv;
808 struct smc_private *smc = netdev_priv(dev);
809 char *name;
810 int i, rev, j = 0;
811 unsigned int ioaddr;
812 u_long mir;
813
814 dev_dbg(&link->dev, "smc91c92_config\n");
815
816 smc->manfid = link->manf_id;
817 smc->cardid = link->card_id;
818
819 if ((smc->manfid == MANFID_OSITECH) &&
820 (smc->cardid != PRODID_OSITECH_SEVEN)) {
821 i = osi_config(link);
822 } else if ((smc->manfid == MANFID_MOTOROLA) ||
823 ((smc->manfid == MANFID_MEGAHERTZ) &&
824 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
825 (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
826 i = mhz_mfc_config(link);
827 } else {
828 i = smc_config(link);
829 }
830 if (i)
831 goto config_failed;
832
833 i = pcmcia_request_irq(link, smc_interrupt);
834 if (i)
835 goto config_failed;
836 i = pcmcia_enable_device(link);
837 if (i)
838 goto config_failed;
839
840 if (smc->manfid == MANFID_MOTOROLA)
841 mot_config(link);
842
843 dev->irq = link->irq;
844
845 if ((if_port >= 0) && (if_port <= 2))
846 dev->if_port = if_port;
847 else
848 dev_notice(&link->dev, "invalid if_port requested\n");
849
850 switch (smc->manfid) {
851 case MANFID_OSITECH:
852 case MANFID_PSION:
853 i = osi_setup(link, smc->manfid, smc->cardid); break;
854 case MANFID_SMC:
855 case MANFID_NEW_MEDIA:
856 i = smc_setup(link); break;
857 case 0x128:
858 case MANFID_MEGAHERTZ:
859 i = mhz_setup(link); break;
860 case MANFID_MOTOROLA:
861 default:
862 i = mot_setup(link); break;
863 }
864
865 if (i != 0) {
866 dev_notice(&link->dev, "Unable to find hardware address.\n");
867 goto config_failed;
868 }
869
870 smc->duplex = 0;
871 smc->rx_ovrn = 0;
872
873 rev = check_sig(link);
874 name = "???";
875 if (rev > 0)
876 switch (rev >> 4) {
877 case 3: name = "92"; break;
878 case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
879 case 5: name = "95"; break;
880 case 7: name = "100"; break;
881 case 8: name = "100-FD"; break;
882 case 9: name = "110"; break;
883 }
884
885 ioaddr = dev->base_addr;
886 if (rev > 0) {
887 u_long mcr;
888 SMC_SELECT_BANK(0);
889 mir = inw(ioaddr + MEMINFO) & 0xff;
890 if (mir == 0xff) mir++;
891
892 mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
893 mir *= 128 * (1<<((mcr >> 9) & 7));
894 SMC_SELECT_BANK(1);
895 smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
896 smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
897 if (smc->manfid == MANFID_OSITECH)
898 smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
899 if ((rev >> 4) >= 7)
900 smc->cfg |= CFG_MII_SELECT;
901 } else
902 mir = 0;
903
904 if (smc->cfg & CFG_MII_SELECT) {
905 SMC_SELECT_BANK(3);
906
907 for (i = 0; i < 32; i++) {
908 j = mdio_read(dev, i, 1);
909 if ((j != 0) && (j != 0xffff)) break;
910 }
911 smc->mii_if.phy_id = (i < 32) ? i : -1;
912
913 SMC_SELECT_BANK(0);
914 }
915
916 SET_NETDEV_DEV(dev, &link->dev);
917
918 if (register_netdev(dev) != 0) {
919 dev_err(&link->dev, "register_netdev() failed\n");
920 goto config_undo;
921 }
922
923 netdev_info(dev, "smc91c%s rev %d: io %#3lx, irq %d, hw_addr %pM\n",
924 name, (rev & 0x0f), dev->base_addr, dev->irq, dev->dev_addr);
925
926 if (rev > 0) {
927 if (mir & 0x3ff)
928 netdev_info(dev, " %lu byte", mir);
929 else
930 netdev_info(dev, " %lu kb", mir>>10);
931 pr_cont(" buffer, %s xcvr\n",
932 (smc->cfg & CFG_MII_SELECT) ? "MII" : if_names[dev->if_port]);
933 }
934
935 if (smc->cfg & CFG_MII_SELECT) {
936 if (smc->mii_if.phy_id != -1) {
937 netdev_dbg(dev, " MII transceiver at index %d, status %x\n",
938 smc->mii_if.phy_id, j);
939 } else {
940 netdev_notice(dev, " No MII transceivers found!\n");
941 }
942 }
943 return 0;
944
945config_undo:
946 unregister_netdev(dev);
947config_failed:
948 smc91c92_release(link);
949 free_netdev(dev);
950 return -ENODEV;
951}
952
953static void smc91c92_release(struct pcmcia_device *link)
954{
955 dev_dbg(&link->dev, "smc91c92_release\n");
956 if (link->resource[2]->end) {
957 struct net_device *dev = link->priv;
958 struct smc_private *smc = netdev_priv(dev);
959 iounmap(smc->base);
960 }
961 pcmcia_disable_device(link);
962}
963
964
965
966
967
968
969#define MDIO_SHIFT_CLK 0x04
970#define MDIO_DATA_OUT 0x01
971#define MDIO_DIR_WRITE 0x08
972#define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
973#define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
974#define MDIO_DATA_READ 0x02
975
976static void mdio_sync(unsigned int addr)
977{
978 int bits;
979 for (bits = 0; bits < 32; bits++) {
980 outb(MDIO_DATA_WRITE1, addr);
981 outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
982 }
983}
984
985static int mdio_read(struct net_device *dev, int phy_id, int loc)
986{
987 unsigned int addr = dev->base_addr + MGMT;
988 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
989 int i, retval = 0;
990
991 mdio_sync(addr);
992 for (i = 13; i >= 0; i--) {
993 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
994 outb(dat, addr);
995 outb(dat | MDIO_SHIFT_CLK, addr);
996 }
997 for (i = 19; i > 0; i--) {
998 outb(0, addr);
999 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1000 outb(MDIO_SHIFT_CLK, addr);
1001 }
1002 return (retval>>1) & 0xffff;
1003}
1004
1005static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1006{
1007 unsigned int addr = dev->base_addr + MGMT;
1008 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1009 int i;
1010
1011 mdio_sync(addr);
1012 for (i = 31; i >= 0; i--) {
1013 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1014 outb(dat, addr);
1015 outb(dat | MDIO_SHIFT_CLK, addr);
1016 }
1017 for (i = 1; i >= 0; i--) {
1018 outb(0, addr);
1019 outb(MDIO_SHIFT_CLK, addr);
1020 }
1021}
1022
1023
1024
1025
1026
1027
1028
1029
1030#ifdef PCMCIA_DEBUG
1031static void smc_dump(struct net_device *dev)
1032{
1033 unsigned int ioaddr = dev->base_addr;
1034 u_short i, w, save;
1035 save = inw(ioaddr + BANK_SELECT);
1036 for (w = 0; w < 4; w++) {
1037 SMC_SELECT_BANK(w);
1038 netdev_dbg(dev, "bank %d: ", w);
1039 for (i = 0; i < 14; i += 2)
1040 pr_cont(" %04x", inw(ioaddr + i));
1041 pr_cont("\n");
1042 }
1043 outw(save, ioaddr + BANK_SELECT);
1044}
1045#endif
1046
1047static int smc_open(struct net_device *dev)
1048{
1049 struct smc_private *smc = netdev_priv(dev);
1050 struct pcmcia_device *link = smc->p_dev;
1051
1052 dev_dbg(&link->dev, "%s: smc_open(%p), ID/Window %4.4x.\n",
1053 dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1054#ifdef PCMCIA_DEBUG
1055 smc_dump(dev);
1056#endif
1057
1058
1059 if (!pcmcia_dev_present(link))
1060 return -ENODEV;
1061
1062 if (check_sig(link) < 0) {
1063 netdev_info(dev, "Yikes! Bad chip signature!\n");
1064 return -ENODEV;
1065 }
1066 link->open++;
1067
1068 netif_start_queue(dev);
1069 smc->saved_skb = NULL;
1070 smc->packets_waiting = 0;
1071
1072 smc_reset(dev);
1073 setup_timer(&smc->media, media_check, (u_long)dev);
1074 mod_timer(&smc->media, jiffies + HZ);
1075
1076 return 0;
1077}
1078
1079
1080
1081static int smc_close(struct net_device *dev)
1082{
1083 struct smc_private *smc = netdev_priv(dev);
1084 struct pcmcia_device *link = smc->p_dev;
1085 unsigned int ioaddr = dev->base_addr;
1086
1087 dev_dbg(&link->dev, "%s: smc_close(), status %4.4x.\n",
1088 dev->name, inw(ioaddr + BANK_SELECT));
1089
1090 netif_stop_queue(dev);
1091
1092
1093
1094 SMC_SELECT_BANK(2);
1095 outw(0, ioaddr + INTERRUPT);
1096 SMC_SELECT_BANK(0);
1097 mask_bits(0xff00, ioaddr + RCR);
1098 mask_bits(0xff00, ioaddr + TCR);
1099
1100
1101 SMC_SELECT_BANK(1);
1102 outw(CTL_POWERDOWN, ioaddr + CONTROL );
1103
1104 link->open--;
1105 del_timer_sync(&smc->media);
1106
1107 return 0;
1108}
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118static void smc_hardware_send_packet(struct net_device * dev)
1119{
1120 struct smc_private *smc = netdev_priv(dev);
1121 struct sk_buff *skb = smc->saved_skb;
1122 unsigned int ioaddr = dev->base_addr;
1123 u_char packet_no;
1124
1125 if (!skb) {
1126 netdev_err(dev, "In XMIT with no packet to send\n");
1127 return;
1128 }
1129
1130
1131 packet_no = inw(ioaddr + PNR_ARR) >> 8;
1132 if (packet_no & 0x80) {
1133
1134 netdev_warn(dev, "hardware Tx buffer allocation failed, status %#2.2x\n",
1135 packet_no);
1136 dev_kfree_skb_irq(skb);
1137 smc->saved_skb = NULL;
1138 netif_start_queue(dev);
1139 return;
1140 }
1141
1142 dev->stats.tx_bytes += skb->len;
1143
1144 outw(packet_no, ioaddr + PNR_ARR);
1145
1146 outw(PTR_AUTOINC , ioaddr + POINTER);
1147
1148
1149
1150 {
1151 u_char *buf = skb->data;
1152 u_int length = skb->len;
1153
1154 netdev_dbg(dev, "Trying to xmit packet of length %d\n", length);
1155
1156
1157 outw(0, ioaddr + DATA_1);
1158 outw(length + 6, ioaddr + DATA_1);
1159 outsw(ioaddr + DATA_1, buf, length >> 1);
1160
1161
1162 outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1163 }
1164
1165
1166 outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1167 (inw(ioaddr + INTERRUPT) & 0xff00),
1168 ioaddr + INTERRUPT);
1169
1170
1171 outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1172
1173 smc->saved_skb = NULL;
1174 dev_kfree_skb_irq(skb);
1175 dev->trans_start = jiffies;
1176 netif_start_queue(dev);
1177}
1178
1179
1180
1181static void smc_tx_timeout(struct net_device *dev)
1182{
1183 struct smc_private *smc = netdev_priv(dev);
1184 unsigned int ioaddr = dev->base_addr;
1185
1186 netdev_notice(dev, "transmit timed out, Tx_status %2.2x status %4.4x.\n",
1187 inw(ioaddr)&0xff, inw(ioaddr + 2));
1188 dev->stats.tx_errors++;
1189 smc_reset(dev);
1190 dev->trans_start = jiffies;
1191 smc->saved_skb = NULL;
1192 netif_wake_queue(dev);
1193}
1194
1195static netdev_tx_t smc_start_xmit(struct sk_buff *skb,
1196 struct net_device *dev)
1197{
1198 struct smc_private *smc = netdev_priv(dev);
1199 unsigned int ioaddr = dev->base_addr;
1200 u_short num_pages;
1201 short time_out, ir;
1202 unsigned long flags;
1203
1204 netif_stop_queue(dev);
1205
1206 netdev_dbg(dev, "smc_start_xmit(length = %d) called, status %04x\n",
1207 skb->len, inw(ioaddr + 2));
1208
1209 if (smc->saved_skb) {
1210
1211 dev->stats.tx_aborted_errors++;
1212 netdev_dbg(dev, "Internal error -- sent packet while busy\n");
1213 return NETDEV_TX_BUSY;
1214 }
1215 smc->saved_skb = skb;
1216
1217 num_pages = skb->len >> 8;
1218
1219 if (num_pages > 7) {
1220 netdev_err(dev, "Far too big packet error: %d pages\n", num_pages);
1221 dev_kfree_skb (skb);
1222 smc->saved_skb = NULL;
1223 dev->stats.tx_dropped++;
1224 return NETDEV_TX_OK;
1225 }
1226
1227 smc->packets_waiting++;
1228
1229 spin_lock_irqsave(&smc->lock, flags);
1230 SMC_SELECT_BANK(2);
1231
1232
1233 if (smc->rx_ovrn) {
1234 outw(MC_RESET, ioaddr + MMU_CMD);
1235 smc->rx_ovrn = 0;
1236 }
1237
1238
1239 outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1240 for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1241 ir = inw(ioaddr+INTERRUPT);
1242 if (ir & IM_ALLOC_INT) {
1243
1244 outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1245 smc_hardware_send_packet(dev);
1246 spin_unlock_irqrestore(&smc->lock, flags);
1247 return NETDEV_TX_OK;
1248 }
1249 }
1250
1251
1252 netdev_dbg(dev, "memory allocation deferred.\n");
1253 outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1254 spin_unlock_irqrestore(&smc->lock, flags);
1255
1256 return NETDEV_TX_OK;
1257}
1258
1259
1260
1261
1262
1263
1264
1265static void smc_tx_err(struct net_device * dev)
1266{
1267 struct smc_private *smc = netdev_priv(dev);
1268 unsigned int ioaddr = dev->base_addr;
1269 int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1270 int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1271 int tx_status;
1272
1273
1274 outw(packet_no, ioaddr + PNR_ARR);
1275
1276
1277 outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1278
1279 tx_status = inw(ioaddr + DATA_1);
1280
1281 dev->stats.tx_errors++;
1282 if (tx_status & TS_LOSTCAR) dev->stats.tx_carrier_errors++;
1283 if (tx_status & TS_LATCOL) dev->stats.tx_window_errors++;
1284 if (tx_status & TS_16COL) {
1285 dev->stats.tx_aborted_errors++;
1286 smc->tx_err++;
1287 }
1288
1289 if (tx_status & TS_SUCCESS) {
1290 netdev_notice(dev, "Successful packet caused error interrupt?\n");
1291 }
1292
1293 SMC_SELECT_BANK(0);
1294 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1295 SMC_SELECT_BANK(2);
1296
1297 outw(MC_FREEPKT, ioaddr + MMU_CMD);
1298
1299
1300 smc->packets_waiting--;
1301
1302 outw(saved_packet, ioaddr + PNR_ARR);
1303}
1304
1305
1306
1307static void smc_eph_irq(struct net_device *dev)
1308{
1309 struct smc_private *smc = netdev_priv(dev);
1310 unsigned int ioaddr = dev->base_addr;
1311 u_short card_stats, ephs;
1312
1313 SMC_SELECT_BANK(0);
1314 ephs = inw(ioaddr + EPH);
1315 netdev_dbg(dev, "Ethernet protocol handler interrupt, status %4.4x.\n",
1316 ephs);
1317
1318 card_stats = inw(ioaddr + COUNTER);
1319
1320 dev->stats.collisions += card_stats & 0xF;
1321 card_stats >>= 4;
1322
1323 dev->stats.collisions += card_stats & 0xF;
1324#if 0
1325 card_stats >>= 4;
1326 card_stats >>= 4;
1327#endif
1328
1329 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1330
1331
1332 SMC_SELECT_BANK(1);
1333 outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1334 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1335 ioaddr + CONTROL);
1336 SMC_SELECT_BANK(2);
1337}
1338
1339
1340
1341static irqreturn_t smc_interrupt(int irq, void *dev_id)
1342{
1343 struct net_device *dev = dev_id;
1344 struct smc_private *smc = netdev_priv(dev);
1345 unsigned int ioaddr;
1346 u_short saved_bank, saved_pointer, mask, status;
1347 unsigned int handled = 1;
1348 char bogus_cnt = INTR_WORK;
1349
1350 if (!netif_device_present(dev))
1351 return IRQ_NONE;
1352
1353 ioaddr = dev->base_addr;
1354
1355 netdev_dbg(dev, "SMC91c92 interrupt %d at %#x.\n",
1356 irq, ioaddr);
1357
1358 spin_lock(&smc->lock);
1359 smc->watchdog = 0;
1360 saved_bank = inw(ioaddr + BANK_SELECT);
1361 if ((saved_bank & 0xff00) != 0x3300) {
1362
1363
1364 netdev_dbg(dev, "SMC91c92 interrupt %d for non-existent/ejected device.\n",
1365 irq);
1366 handled = 0;
1367 goto irq_done;
1368 }
1369
1370 SMC_SELECT_BANK(2);
1371 saved_pointer = inw(ioaddr + POINTER);
1372 mask = inw(ioaddr + INTERRUPT) >> 8;
1373
1374 outw(0, ioaddr + INTERRUPT);
1375
1376 do {
1377 status = inw(ioaddr + INTERRUPT) & 0xff;
1378 netdev_dbg(dev, "Status is %#2.2x (mask %#2.2x).\n",
1379 status, mask);
1380 if ((status & mask) == 0) {
1381 if (bogus_cnt == INTR_WORK)
1382 handled = 0;
1383 break;
1384 }
1385 if (status & IM_RCV_INT) {
1386
1387 smc_rx(dev);
1388 }
1389 if (status & IM_TX_INT) {
1390 smc_tx_err(dev);
1391 outw(IM_TX_INT, ioaddr + INTERRUPT);
1392 }
1393 status &= mask;
1394 if (status & IM_TX_EMPTY_INT) {
1395 outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1396 mask &= ~IM_TX_EMPTY_INT;
1397 dev->stats.tx_packets += smc->packets_waiting;
1398 smc->packets_waiting = 0;
1399 }
1400 if (status & IM_ALLOC_INT) {
1401
1402 mask &= ~IM_ALLOC_INT;
1403
1404 smc_hardware_send_packet(dev);
1405
1406
1407 mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1408
1409
1410 netif_wake_queue(dev);
1411 }
1412 if (status & IM_RX_OVRN_INT) {
1413 dev->stats.rx_errors++;
1414 dev->stats.rx_fifo_errors++;
1415 if (smc->duplex)
1416 smc->rx_ovrn = 1;
1417 outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1418 }
1419 if (status & IM_EPH_INT)
1420 smc_eph_irq(dev);
1421 } while (--bogus_cnt);
1422
1423 netdev_dbg(dev, " Restoring saved registers mask %2.2x bank %4.4x pointer %4.4x.\n",
1424 mask, saved_bank, saved_pointer);
1425
1426
1427 outw((mask<<8), ioaddr + INTERRUPT);
1428 outw(saved_pointer, ioaddr + POINTER);
1429 SMC_SELECT_BANK(saved_bank);
1430
1431 netdev_dbg(dev, "Exiting interrupt IRQ%d.\n", irq);
1432
1433irq_done:
1434
1435 if ((smc->manfid == MANFID_OSITECH) &&
1436 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1437
1438 mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1439 set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1440 }
1441 if (smc->manfid == MANFID_MOTOROLA) {
1442 u_char cor;
1443 cor = readb(smc->base + MOT_UART + CISREG_COR);
1444 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1445 writeb(cor, smc->base + MOT_UART + CISREG_COR);
1446 cor = readb(smc->base + MOT_LAN + CISREG_COR);
1447 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1448 writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1449 }
1450
1451 if ((smc->base != NULL) &&
1452 (smc->manfid == MANFID_MEGAHERTZ) &&
1453 (smc->cardid == PRODID_MEGAHERTZ_EM3288)) {
1454
1455 u_char tmp;
1456 tmp = readb(smc->base+MEGAHERTZ_ISR);
1457 tmp = readb(smc->base+MEGAHERTZ_ISR);
1458
1459
1460 writeb(tmp, smc->base + MEGAHERTZ_ISR);
1461 writeb(tmp, smc->base + MEGAHERTZ_ISR);
1462 }
1463
1464 spin_unlock(&smc->lock);
1465 return IRQ_RETVAL(handled);
1466}
1467
1468
1469
1470static void smc_rx(struct net_device *dev)
1471{
1472 unsigned int ioaddr = dev->base_addr;
1473 int rx_status;
1474 int packet_length;
1475
1476
1477
1478
1479 if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1480 netdev_err(dev, "smc_rx() with nothing on Rx FIFO\n");
1481 return;
1482 }
1483
1484
1485 outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1486 rx_status = inw(ioaddr + DATA_1);
1487 packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1488
1489 netdev_dbg(dev, "Receive status %4.4x length %d.\n",
1490 rx_status, packet_length);
1491
1492 if (!(rx_status & RS_ERRORS)) {
1493
1494 struct sk_buff *skb;
1495
1496
1497 skb = netdev_alloc_skb(dev, packet_length+2);
1498
1499 if (skb == NULL) {
1500 netdev_dbg(dev, "Low memory, packet dropped.\n");
1501 dev->stats.rx_dropped++;
1502 outw(MC_RELEASE, ioaddr + MMU_CMD);
1503 return;
1504 }
1505
1506 packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1507 skb_reserve(skb, 2);
1508 insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1509 (packet_length+1)>>1);
1510 skb->protocol = eth_type_trans(skb, dev);
1511
1512 netif_rx(skb);
1513 dev->last_rx = jiffies;
1514 dev->stats.rx_packets++;
1515 dev->stats.rx_bytes += packet_length;
1516 if (rx_status & RS_MULTICAST)
1517 dev->stats.multicast++;
1518 } else {
1519
1520 dev->stats.rx_errors++;
1521
1522 if (rx_status & RS_ALGNERR) dev->stats.rx_frame_errors++;
1523 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1524 dev->stats.rx_length_errors++;
1525 if (rx_status & RS_BADCRC) dev->stats.rx_crc_errors++;
1526 }
1527
1528 outw(MC_RELEASE, ioaddr + MMU_CMD);
1529}
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542static void set_rx_mode(struct net_device *dev)
1543{
1544 unsigned int ioaddr = dev->base_addr;
1545 struct smc_private *smc = netdev_priv(dev);
1546 unsigned char multicast_table[8];
1547 unsigned long flags;
1548 u_short rx_cfg_setting;
1549 int i;
1550
1551 memset(multicast_table, 0, sizeof(multicast_table));
1552
1553 if (dev->flags & IFF_PROMISC) {
1554 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1555 } else if (dev->flags & IFF_ALLMULTI)
1556 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1557 else {
1558 if (!netdev_mc_empty(dev)) {
1559 struct netdev_hw_addr *ha;
1560
1561 netdev_for_each_mc_addr(ha, dev) {
1562 u_int position = ether_crc(6, ha->addr);
1563 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1564 }
1565 }
1566 rx_cfg_setting = RxStripCRC | RxEnable;
1567 }
1568
1569
1570 spin_lock_irqsave(&smc->lock, flags);
1571 SMC_SELECT_BANK(3);
1572 for (i = 0; i < 8; i++)
1573 outb(multicast_table[i], ioaddr + MULTICAST0 + i);
1574 SMC_SELECT_BANK(0);
1575 outw(rx_cfg_setting, ioaddr + RCR);
1576 SMC_SELECT_BANK(2);
1577 spin_unlock_irqrestore(&smc->lock, flags);
1578}
1579
1580
1581
1582
1583
1584
1585
1586static int s9k_config(struct net_device *dev, struct ifmap *map)
1587{
1588 struct smc_private *smc = netdev_priv(dev);
1589 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1590 if (smc->cfg & CFG_MII_SELECT)
1591 return -EOPNOTSUPP;
1592 else if (map->port > 2)
1593 return -EINVAL;
1594 dev->if_port = map->port;
1595 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
1596 smc_reset(dev);
1597 }
1598 return 0;
1599}
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611static void smc_set_xcvr(struct net_device *dev, int if_port)
1612{
1613 struct smc_private *smc = netdev_priv(dev);
1614 unsigned int ioaddr = dev->base_addr;
1615 u_short saved_bank;
1616
1617 saved_bank = inw(ioaddr + BANK_SELECT);
1618 SMC_SELECT_BANK(1);
1619 if (if_port == 2) {
1620 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1621 if ((smc->manfid == MANFID_OSITECH) &&
1622 (smc->cardid != PRODID_OSITECH_SEVEN))
1623 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1624 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1625 } else {
1626 outw(smc->cfg, ioaddr + CONFIG);
1627 if ((smc->manfid == MANFID_OSITECH) &&
1628 (smc->cardid != PRODID_OSITECH_SEVEN))
1629 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1630 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1631 }
1632 SMC_SELECT_BANK(saved_bank);
1633}
1634
1635static void smc_reset(struct net_device *dev)
1636{
1637 unsigned int ioaddr = dev->base_addr;
1638 struct smc_private *smc = netdev_priv(dev);
1639 int i;
1640
1641 netdev_dbg(dev, "smc91c92 reset called.\n");
1642
1643
1644
1645 SMC_SELECT_BANK(0);
1646
1647 outw(RCR_SOFTRESET, ioaddr + RCR);
1648 udelay(10);
1649
1650
1651 outw(RCR_CLEAR, ioaddr + RCR);
1652 outw(TCR_CLEAR, ioaddr + TCR);
1653
1654
1655
1656 SMC_SELECT_BANK(1);
1657
1658
1659 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1660 ioaddr + CONTROL);
1661 smc_set_xcvr(dev, dev->if_port);
1662 if ((smc->manfid == MANFID_OSITECH) &&
1663 (smc->cardid != PRODID_OSITECH_SEVEN))
1664 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1665 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1666 ioaddr - 0x10 + OSITECH_AUI_PWR);
1667
1668
1669 for (i = 0; i < 6; i += 2)
1670 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1671 ioaddr + ADDR0 + i);
1672
1673
1674 SMC_SELECT_BANK(2);
1675 outw(MC_RESET, ioaddr + MMU_CMD);
1676 outw(0, ioaddr + INTERRUPT);
1677
1678
1679 SMC_SELECT_BANK(0);
1680 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1681 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1682 set_rx_mode(dev);
1683
1684 if (smc->cfg & CFG_MII_SELECT) {
1685 SMC_SELECT_BANK(3);
1686
1687
1688 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1689
1690
1691 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1692
1693
1694 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1695 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1696 }
1697
1698
1699 SMC_SELECT_BANK(2);
1700 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
1701 ioaddr + INTERRUPT);
1702}
1703
1704
1705
1706
1707
1708
1709
1710static void media_check(u_long arg)
1711{
1712 struct net_device *dev = (struct net_device *) arg;
1713 struct smc_private *smc = netdev_priv(dev);
1714 unsigned int ioaddr = dev->base_addr;
1715 u_short i, media, saved_bank;
1716 u_short link;
1717 unsigned long flags;
1718
1719 spin_lock_irqsave(&smc->lock, flags);
1720
1721 saved_bank = inw(ioaddr + BANK_SELECT);
1722
1723 if (!netif_device_present(dev))
1724 goto reschedule;
1725
1726 SMC_SELECT_BANK(2);
1727
1728
1729 if (smc->rx_ovrn) {
1730 outw(MC_RESET, ioaddr + MMU_CMD);
1731 smc->rx_ovrn = 0;
1732 }
1733 i = inw(ioaddr + INTERRUPT);
1734 SMC_SELECT_BANK(0);
1735 media = inw(ioaddr + EPH) & EPH_LINK_OK;
1736 SMC_SELECT_BANK(1);
1737 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
1738
1739 SMC_SELECT_BANK(saved_bank);
1740 spin_unlock_irqrestore(&smc->lock, flags);
1741
1742
1743
1744 if (smc->watchdog++ && ((i>>8) & i)) {
1745 if (!smc->fast_poll)
1746 netdev_info(dev, "interrupt(s) dropped!\n");
1747 local_irq_save(flags);
1748 smc_interrupt(dev->irq, dev);
1749 local_irq_restore(flags);
1750 smc->fast_poll = HZ;
1751 }
1752 if (smc->fast_poll) {
1753 smc->fast_poll--;
1754 smc->media.expires = jiffies + HZ/100;
1755 add_timer(&smc->media);
1756 return;
1757 }
1758
1759 spin_lock_irqsave(&smc->lock, flags);
1760
1761 saved_bank = inw(ioaddr + BANK_SELECT);
1762
1763 if (smc->cfg & CFG_MII_SELECT) {
1764 if (smc->mii_if.phy_id < 0)
1765 goto reschedule;
1766
1767 SMC_SELECT_BANK(3);
1768 link = mdio_read(dev, smc->mii_if.phy_id, 1);
1769 if (!link || (link == 0xffff)) {
1770 netdev_info(dev, "MII is missing!\n");
1771 smc->mii_if.phy_id = -1;
1772 goto reschedule;
1773 }
1774
1775 link &= 0x0004;
1776 if (link != smc->link_status) {
1777 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
1778 netdev_info(dev, "%s link beat\n", link ? "found" : "lost");
1779 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
1780 ? TCR_FDUPLX : 0);
1781 if (link) {
1782 netdev_info(dev, "autonegotiation complete: "
1783 "%dbaseT-%cD selected\n",
1784 (p & 0x0180) ? 100 : 10, smc->duplex ? 'F' : 'H');
1785 }
1786 SMC_SELECT_BANK(0);
1787 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
1788 smc->link_status = link;
1789 }
1790 goto reschedule;
1791 }
1792
1793
1794 if (time_after(jiffies, dev->last_rx + HZ)) {
1795 if (smc->tx_err || (smc->media_status & EPH_16COL))
1796 media |= EPH_16COL;
1797 }
1798 smc->tx_err = 0;
1799
1800 if (media != smc->media_status) {
1801 if ((media & smc->media_status & 1) &&
1802 ((smc->media_status ^ media) & EPH_LINK_OK))
1803 netdev_info(dev, "%s link beat\n",
1804 smc->media_status & EPH_LINK_OK ? "lost" : "found");
1805 else if ((media & smc->media_status & 2) &&
1806 ((smc->media_status ^ media) & EPH_16COL))
1807 netdev_info(dev, "coax cable %s\n",
1808 media & EPH_16COL ? "problem" : "ok");
1809 if (dev->if_port == 0) {
1810 if (media & 1) {
1811 if (media & EPH_LINK_OK)
1812 netdev_info(dev, "flipped to 10baseT\n");
1813 else
1814 smc_set_xcvr(dev, 2);
1815 } else {
1816 if (media & EPH_16COL)
1817 smc_set_xcvr(dev, 1);
1818 else
1819 netdev_info(dev, "flipped to 10base2\n");
1820 }
1821 }
1822 smc->media_status = media;
1823 }
1824
1825reschedule:
1826 smc->media.expires = jiffies + HZ;
1827 add_timer(&smc->media);
1828 SMC_SELECT_BANK(saved_bank);
1829 spin_unlock_irqrestore(&smc->lock, flags);
1830}
1831
1832static int smc_link_ok(struct net_device *dev)
1833{
1834 unsigned int ioaddr = dev->base_addr;
1835 struct smc_private *smc = netdev_priv(dev);
1836
1837 if (smc->cfg & CFG_MII_SELECT) {
1838 return mii_link_ok(&smc->mii_if);
1839 } else {
1840 SMC_SELECT_BANK(0);
1841 return inw(ioaddr + EPH) & EPH_LINK_OK;
1842 }
1843}
1844
1845static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1846{
1847 u16 tmp;
1848 unsigned int ioaddr = dev->base_addr;
1849
1850 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
1851 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
1852
1853 SMC_SELECT_BANK(1);
1854 tmp = inw(ioaddr + CONFIG);
1855 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
1856 ecmd->transceiver = XCVR_INTERNAL;
1857 ethtool_cmd_speed_set(ecmd, SPEED_10);
1858 ecmd->phy_address = ioaddr + MGMT;
1859
1860 SMC_SELECT_BANK(0);
1861 tmp = inw(ioaddr + TCR);
1862 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
1863
1864 return 0;
1865}
1866
1867static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1868{
1869 u16 tmp;
1870 unsigned int ioaddr = dev->base_addr;
1871
1872 if (ethtool_cmd_speed(ecmd) != SPEED_10)
1873 return -EINVAL;
1874 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
1875 return -EINVAL;
1876 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
1877 return -EINVAL;
1878 if (ecmd->transceiver != XCVR_INTERNAL)
1879 return -EINVAL;
1880
1881 if (ecmd->port == PORT_AUI)
1882 smc_set_xcvr(dev, 1);
1883 else
1884 smc_set_xcvr(dev, 0);
1885
1886 SMC_SELECT_BANK(0);
1887 tmp = inw(ioaddr + TCR);
1888 if (ecmd->duplex == DUPLEX_FULL)
1889 tmp |= TCR_FDUPLX;
1890 else
1891 tmp &= ~TCR_FDUPLX;
1892 outw(tmp, ioaddr + TCR);
1893
1894 return 0;
1895}
1896
1897static int check_if_running(struct net_device *dev)
1898{
1899 if (!netif_running(dev))
1900 return -EINVAL;
1901 return 0;
1902}
1903
1904static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1905{
1906 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1907 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1908}
1909
1910static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1911{
1912 struct smc_private *smc = netdev_priv(dev);
1913 unsigned int ioaddr = dev->base_addr;
1914 u16 saved_bank = inw(ioaddr + BANK_SELECT);
1915 int ret;
1916 unsigned long flags;
1917
1918 spin_lock_irqsave(&smc->lock, flags);
1919 SMC_SELECT_BANK(3);
1920 if (smc->cfg & CFG_MII_SELECT)
1921 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
1922 else
1923 ret = smc_netdev_get_ecmd(dev, ecmd);
1924 SMC_SELECT_BANK(saved_bank);
1925 spin_unlock_irqrestore(&smc->lock, flags);
1926 return ret;
1927}
1928
1929static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1930{
1931 struct smc_private *smc = netdev_priv(dev);
1932 unsigned int ioaddr = dev->base_addr;
1933 u16 saved_bank = inw(ioaddr + BANK_SELECT);
1934 int ret;
1935 unsigned long flags;
1936
1937 spin_lock_irqsave(&smc->lock, flags);
1938 SMC_SELECT_BANK(3);
1939 if (smc->cfg & CFG_MII_SELECT)
1940 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
1941 else
1942 ret = smc_netdev_set_ecmd(dev, ecmd);
1943 SMC_SELECT_BANK(saved_bank);
1944 spin_unlock_irqrestore(&smc->lock, flags);
1945 return ret;
1946}
1947
1948static u32 smc_get_link(struct net_device *dev)
1949{
1950 struct smc_private *smc = netdev_priv(dev);
1951 unsigned int ioaddr = dev->base_addr;
1952 u16 saved_bank = inw(ioaddr + BANK_SELECT);
1953 u32 ret;
1954 unsigned long flags;
1955
1956 spin_lock_irqsave(&smc->lock, flags);
1957 SMC_SELECT_BANK(3);
1958 ret = smc_link_ok(dev);
1959 SMC_SELECT_BANK(saved_bank);
1960 spin_unlock_irqrestore(&smc->lock, flags);
1961 return ret;
1962}
1963
1964static int smc_nway_reset(struct net_device *dev)
1965{
1966 struct smc_private *smc = netdev_priv(dev);
1967 if (smc->cfg & CFG_MII_SELECT) {
1968 unsigned int ioaddr = dev->base_addr;
1969 u16 saved_bank = inw(ioaddr + BANK_SELECT);
1970 int res;
1971
1972 SMC_SELECT_BANK(3);
1973 res = mii_nway_restart(&smc->mii_if);
1974 SMC_SELECT_BANK(saved_bank);
1975
1976 return res;
1977 } else
1978 return -EOPNOTSUPP;
1979}
1980
1981static const struct ethtool_ops ethtool_ops = {
1982 .begin = check_if_running,
1983 .get_drvinfo = smc_get_drvinfo,
1984 .get_settings = smc_get_settings,
1985 .set_settings = smc_set_settings,
1986 .get_link = smc_get_link,
1987 .nway_reset = smc_nway_reset,
1988};
1989
1990static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1991{
1992 struct smc_private *smc = netdev_priv(dev);
1993 struct mii_ioctl_data *mii = if_mii(rq);
1994 int rc = 0;
1995 u16 saved_bank;
1996 unsigned int ioaddr = dev->base_addr;
1997 unsigned long flags;
1998
1999 if (!netif_running(dev))
2000 return -EINVAL;
2001
2002 spin_lock_irqsave(&smc->lock, flags);
2003 saved_bank = inw(ioaddr + BANK_SELECT);
2004 SMC_SELECT_BANK(3);
2005 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2006 SMC_SELECT_BANK(saved_bank);
2007 spin_unlock_irqrestore(&smc->lock, flags);
2008 return rc;
2009}
2010
2011static const struct pcmcia_device_id smc91c92_ids[] = {
2012 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2013 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2014 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2015 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2016 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2017 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2018 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2019 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2020 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2021 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2022 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2023 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2024 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2025 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2026 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2027 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2028 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2029 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2030 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2031 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2032 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2033 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2034 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2035 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2036
2037
2038
2039 PCMCIA_DEVICE_NULL,
2040};
2041MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2042
2043static struct pcmcia_driver smc91c92_cs_driver = {
2044 .owner = THIS_MODULE,
2045 .name = "smc91c92_cs",
2046 .probe = smc91c92_probe,
2047 .remove = smc91c92_detach,
2048 .id_table = smc91c92_ids,
2049 .suspend = smc91c92_suspend,
2050 .resume = smc91c92_resume,
2051};
2052module_pcmcia_driver(smc91c92_cs_driver);
2053