1 /*======================================================================
3 A PCMCIA ethernet driver for SMC91c92-based cards.
5 This driver supports Megahertz PCMCIA ethernet cards; and
6 Megahertz, Motorola, Ositech, and Psion Dacom ethernet/modem
9 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
11 smc91c92_cs.c 1.122 2002/10/25 06:26:39
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.
23 This software may be used and distributed according to the terms of
24 the GNU General Public License, incorporated herein by reference.
26 ======================================================================*/
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>
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 #include <pcmcia/ss.h>
55 #include <asm/system.h>
56 #include <asm/uaccess.h>
58 /* Ositech Seven of Diamonds firmware */
61 /*====================================================================*/
63 static const char *if_names[] = { "auto", "10baseT", "10base2"};
65 /* Module parameters */
67 MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
68 MODULE_LICENSE("GPL");
70 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
73 Transceiver/media type.
75 1 = 10baseT (and autoselect if #define AUTOSELECT),
78 INT_MODULE_PARM(if_port, 0);
81 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
82 static const char *version =
83 "smc91c92_cs.c 1.123 2006/11/09 Donald Becker, becker@scyld.com.\n";
84 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
86 #define DEBUG(n, args...)
89 #define DRV_NAME "smc91c92_cs"
90 #define DRV_VERSION "1.123"
92 /*====================================================================*/
94 /* Operational parameter that usually are not changed. */
96 /* Time in jiffies before concluding Tx hung */
97 #define TX_TIMEOUT ((400*HZ)/1000)
99 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
102 /* Times to check the check the chip before concluding that it doesn't
103 currently have room for another Tx packet. */
104 #define MEMORY_WAIT_TIME 8
107 struct pcmcia_device *p_dev;
111 struct net_device_stats stats;
113 struct sk_buff *saved_skb;
117 struct timer_list media;
118 int watchdog, tx_err;
119 u_short media_status;
122 struct mii_if_info mii_if;
133 /* Special definitions for Megahertz multifunction cards */
134 #define MEGAHERTZ_ISR 0x0380
136 /* Special function registers for Motorola Mariner */
137 #define MOT_LAN 0x0000
138 #define MOT_UART 0x0020
139 #define MOT_EEPROM 0x20
142 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
144 /* Special function registers for Ositech cards */
145 #define OSITECH_AUI_CTL 0x0c
146 #define OSITECH_PWRDOWN 0x0d
147 #define OSITECH_RESET 0x0e
148 #define OSITECH_ISR 0x0f
149 #define OSITECH_AUI_PWR 0x0c
150 #define OSITECH_RESET_ISR 0x0e
152 #define OSI_AUI_PWR 0x40
153 #define OSI_LAN_PWRDOWN 0x02
154 #define OSI_MODEM_PWRDOWN 0x01
155 #define OSI_LAN_RESET 0x02
156 #define OSI_MODEM_RESET 0x01
158 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
159 #define BANK_SELECT 14 /* Window select register. */
160 #define SMC_SELECT_BANK(x) { outw(x, ioaddr + BANK_SELECT); }
162 /* Bank 0 registers. */
163 #define TCR 0 /* transmit control register */
164 #define TCR_CLEAR 0 /* do NOTHING */
165 #define TCR_ENABLE 0x0001 /* if this is 1, we can transmit */
166 #define TCR_PAD_EN 0x0080 /* pads short packets to 64 bytes */
167 #define TCR_MONCSN 0x0400 /* Monitor Carrier. */
168 #define TCR_FDUPLX 0x0800 /* Full duplex mode. */
169 #define TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
171 #define EPH 2 /* Ethernet Protocol Handler report. */
172 #define EPH_TX_SUC 0x0001
173 #define EPH_SNGLCOL 0x0002
174 #define EPH_MULCOL 0x0004
175 #define EPH_LTX_MULT 0x0008
176 #define EPH_16COL 0x0010
177 #define EPH_SQET 0x0020
178 #define EPH_LTX_BRD 0x0040
179 #define EPH_TX_DEFR 0x0080
180 #define EPH_LAT_COL 0x0200
181 #define EPH_LOST_CAR 0x0400
182 #define EPH_EXC_DEF 0x0800
183 #define EPH_CTR_ROL 0x1000
184 #define EPH_RX_OVRN 0x2000
185 #define EPH_LINK_OK 0x4000
186 #define EPH_TX_UNRN 0x8000
187 #define MEMINFO 8 /* Memory Information Register */
188 #define MEMCFG 10 /* Memory Configuration Register */
190 /* Bank 1 registers. */
192 #define CFG_MII_SELECT 0x8000 /* 91C100 only */
193 #define CFG_NO_WAIT 0x1000
194 #define CFG_FULL_STEP 0x0400
195 #define CFG_SET_SQLCH 0x0200
196 #define CFG_AUI_SELECT 0x0100
197 #define CFG_16BIT 0x0080
198 #define CFG_DIS_LINK 0x0040
199 #define CFG_STATIC 0x0030
200 #define CFG_IRQ_SEL_1 0x0004
201 #define CFG_IRQ_SEL_0 0x0002
206 #define CTL_STORE 0x0001
207 #define CTL_RELOAD 0x0002
208 #define CTL_EE_SELECT 0x0004
209 #define CTL_TE_ENABLE 0x0020
210 #define CTL_CR_ENABLE 0x0040
211 #define CTL_LE_ENABLE 0x0080
212 #define CTL_AUTO_RELEASE 0x0800
213 #define CTL_POWERDOWN 0x2000
215 /* Bank 2 registers. */
217 #define MC_ALLOC 0x20 /* or with number of 256 byte packets */
218 #define MC_RESET 0x40
219 #define MC_RELEASE 0x80 /* remove and release the current rx packet */
220 #define MC_FREEPKT 0xA0 /* Release packet in PNR register */
221 #define MC_ENQUEUE 0xC0 /* Enqueue the packet for transmit */
224 #define FP_RXEMPTY 0x8000
226 #define PTR_AUTO_INC 0x0040
227 #define PTR_READ 0x2000
228 #define PTR_AUTOINC 0x4000
229 #define PTR_RCV 0x8000
232 #define IM_RCV_INT 0x1
233 #define IM_TX_INT 0x2
234 #define IM_TX_EMPTY_INT 0x4
235 #define IM_ALLOC_INT 0x8
236 #define IM_RX_OVRN_INT 0x10
237 #define IM_EPH_INT 0x20
240 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
241 RxEnable = 0x0100, RxStripCRC = 0x0200};
242 #define RCR_SOFTRESET 0x8000 /* resets the chip */
243 #define RCR_STRIP_CRC 0x200 /* strips CRC */
244 #define RCR_ENABLE 0x100 /* IFF this is set, we can receive packets */
245 #define RCR_ALMUL 0x4 /* receive all multicast packets */
246 #define RCR_PROMISC 0x2 /* enable promiscuous mode */
248 /* the normal settings for the RCR register : */
249 #define RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
250 #define RCR_CLEAR 0x0 /* set it to a base state */
253 /* BANK 3 -- not the same values as in smc9194! */
259 #define REVISION 0x0a
261 /* Transmit status bits. */
262 #define TS_SUCCESS 0x0001
263 #define TS_16COL 0x0010
264 #define TS_LATCOL 0x0200
265 #define TS_LOSTCAR 0x0400
267 /* Receive status bits. */
268 #define RS_ALGNERR 0x8000
269 #define RS_BADCRC 0x2000
270 #define RS_ODDFRAME 0x1000
271 #define RS_TOOLONG 0x0800
272 #define RS_TOOSHORT 0x0400
273 #define RS_MULTICAST 0x0001
274 #define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
276 #define set_bits(v, p) outw(inw(p)|(v), (p))
277 #define mask_bits(v, p) outw(inw(p)&(v), (p))
279 /*====================================================================*/
281 static void smc91c92_detach(struct pcmcia_device *p_dev);
282 static int smc91c92_config(struct pcmcia_device *link);
283 static void smc91c92_release(struct pcmcia_device *link);
285 static int smc_open(struct net_device *dev);
286 static int smc_close(struct net_device *dev);
287 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
288 static void smc_tx_timeout(struct net_device *dev);
289 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
290 static irqreturn_t smc_interrupt(int irq, void *dev_id);
291 static void smc_rx(struct net_device *dev);
292 static struct net_device_stats *smc_get_stats(struct net_device *dev);
293 static void set_rx_mode(struct net_device *dev);
294 static int s9k_config(struct net_device *dev, struct ifmap *map);
295 static void smc_set_xcvr(struct net_device *dev, int if_port);
296 static void smc_reset(struct net_device *dev);
297 static void media_check(u_long arg);
298 static void mdio_sync(unsigned int addr);
299 static int mdio_read(struct net_device *dev, int phy_id, int loc);
300 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
301 static int smc_link_ok(struct net_device *dev);
302 static const struct ethtool_ops ethtool_ops;
304 /*======================================================================
306 smc91c92_attach() creates an "instance" of the driver, allocating
307 local data structures for one device. The device is registered
310 ======================================================================*/
312 static int smc91c92_probe(struct pcmcia_device *link)
314 struct smc_private *smc;
315 struct net_device *dev;
317 DEBUG(0, "smc91c92_attach()\n");
319 /* Create new ethernet device */
320 dev = alloc_etherdev(sizeof(struct smc_private));
323 smc = netdev_priv(dev);
327 spin_lock_init(&smc->lock);
328 link->io.NumPorts1 = 16;
329 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
330 link->io.IOAddrLines = 4;
331 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
332 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
333 link->irq.Handler = &smc_interrupt;
334 link->irq.Instance = dev;
335 link->conf.Attributes = CONF_ENABLE_IRQ;
336 link->conf.IntType = INT_MEMORY_AND_IO;
338 /* The SMC91c92-specific entries in the device structure. */
339 dev->hard_start_xmit = &smc_start_xmit;
340 dev->get_stats = &smc_get_stats;
341 dev->set_config = &s9k_config;
342 dev->set_multicast_list = &set_rx_mode;
343 dev->open = &smc_open;
344 dev->stop = &smc_close;
345 dev->do_ioctl = &smc_ioctl;
346 SET_ETHTOOL_OPS(dev, ðtool_ops);
347 #ifdef HAVE_TX_TIMEOUT
348 dev->tx_timeout = smc_tx_timeout;
349 dev->watchdog_timeo = TX_TIMEOUT;
352 smc->mii_if.dev = dev;
353 smc->mii_if.mdio_read = mdio_read;
354 smc->mii_if.mdio_write = mdio_write;
355 smc->mii_if.phy_id_mask = 0x1f;
356 smc->mii_if.reg_num_mask = 0x1f;
358 return smc91c92_config(link);
359 } /* smc91c92_attach */
361 /*======================================================================
363 This deletes a driver "instance". The device is de-registered
364 with Card Services. If it has been released, all local data
365 structures are freed. Otherwise, the structures will be freed
366 when the device is released.
368 ======================================================================*/
370 static void smc91c92_detach(struct pcmcia_device *link)
372 struct net_device *dev = link->priv;
374 DEBUG(0, "smc91c92_detach(0x%p)\n", link);
377 unregister_netdev(dev);
379 smc91c92_release(link);
382 } /* smc91c92_detach */
384 /*====================================================================*/
386 static int cvt_ascii_address(struct net_device *dev, char *s)
392 for (i = 0; i < 6; i++) {
394 for (j = 0; j < 2; j++) {
397 da += ((c >= '0') && (c <= '9')) ?
398 (c - '0') : ((c & 0x0f) + 9);
400 dev->dev_addr[i] = da;
405 /*====================================================================*/
407 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple,
412 if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
413 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
415 return pcmcia_parse_tuple(handle, tuple, parse);
418 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple,
423 if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
424 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
426 return pcmcia_parse_tuple(handle, tuple, parse);
429 /*======================================================================
431 Configuration stuff for Megahertz cards
433 mhz_3288_power() is used to power up a 3288's ethernet chip.
434 mhz_mfc_config() handles socket setup for multifunction (1144
435 and 3288) cards. mhz_setup() gets a card's hardware ethernet
438 ======================================================================*/
440 static int mhz_3288_power(struct pcmcia_device *link)
442 struct net_device *dev = link->priv;
443 struct smc_private *smc = netdev_priv(dev);
446 /* Read the ISR twice... */
447 readb(smc->base+MEGAHERTZ_ISR);
449 readb(smc->base+MEGAHERTZ_ISR);
454 /* Now read and write the COR... */
455 tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
457 writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
462 static int mhz_mfc_config_check(struct pcmcia_device *p_dev,
463 cistpl_cftable_entry_t *cf,
467 p_dev->conf.ConfigIndex = cf->index;
468 p_dev->io.BasePort2 = cf->io.win[0].base;
469 for (k = 0; k < 0x400; k += 0x10) {
472 p_dev->io.BasePort1 = k ^ 0x300;
473 if (!pcmcia_request_io(p_dev, &p_dev->io))
479 static int mhz_mfc_config(struct pcmcia_device *link)
481 struct net_device *dev = link->priv;
482 struct smc_private *smc = netdev_priv(dev);
483 struct smc_cfg_mem *cfg_mem;
488 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
490 return CS_OUT_OF_RESOURCE;
492 link->conf.Attributes |= CONF_ENABLE_SPKR;
493 link->conf.Status = CCSR_AUDIO_ENA;
494 link->irq.Attributes =
495 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
496 link->io.IOAddrLines = 16;
497 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
498 link->io.NumPorts2 = 8;
500 /* The Megahertz combo cards have modem-like CIS entries, so
501 we have to explicitly try a bunch of port combinations. */
502 if (pcmcia_loop_config(link, mhz_mfc_config_check, NULL))
504 dev->base_addr = link->io.BasePort1;
506 /* Allocate a memory window, for accessing the ISR */
507 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
508 req.Base = req.Size = 0;
510 i = pcmcia_request_window(&link, &req, &link->win);
513 smc->base = ioremap(req.Base, req.Size);
514 mem.CardOffset = mem.Page = 0;
515 if (smc->manfid == MANFID_MOTOROLA)
516 mem.CardOffset = link->conf.ConfigBase;
517 i = pcmcia_map_mem_page(link->win, &mem);
519 if ((i == CS_SUCCESS)
520 && (smc->manfid == MANFID_MEGAHERTZ)
521 && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
522 mhz_3288_power(link);
529 static int mhz_setup(struct pcmcia_device *link)
531 struct net_device *dev = link->priv;
532 struct smc_cfg_mem *cfg_mem;
535 u_char *buf, *station_addr;
538 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
542 tuple = &cfg_mem->tuple;
543 parse = &cfg_mem->parse;
546 tuple->Attributes = tuple->TupleOffset = 0;
547 tuple->TupleData = (cisdata_t *)buf;
548 tuple->TupleDataMax = 255;
550 /* Read the station address from the CIS. It is stored as the last
551 (fourth) string in the Version 1 Version/ID tuple. */
552 tuple->DesiredTuple = CISTPL_VERS_1;
553 if (first_tuple(link, tuple, parse) != CS_SUCCESS) {
557 /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
558 if (next_tuple(link, tuple, parse) != CS_SUCCESS)
559 first_tuple(link, tuple, parse);
560 if (parse->version_1.ns > 3) {
561 station_addr = parse->version_1.str + parse->version_1.ofs[3];
562 if (cvt_ascii_address(dev, station_addr) == 0) {
568 /* Another possibility: for the EM3288, in a special tuple */
569 tuple->DesiredTuple = 0x81;
570 if (pcmcia_get_first_tuple(link, tuple) != CS_SUCCESS) {
574 if (pcmcia_get_tuple_data(link, tuple) != CS_SUCCESS) {
579 if (cvt_ascii_address(dev, buf) == 0) {
589 /*======================================================================
591 Configuration stuff for the Motorola Mariner
593 mot_config() writes directly to the Mariner configuration
594 registers because the CIS is just bogus.
596 ======================================================================*/
598 static void mot_config(struct pcmcia_device *link)
600 struct net_device *dev = link->priv;
601 struct smc_private *smc = netdev_priv(dev);
602 unsigned int ioaddr = dev->base_addr;
603 unsigned int iouart = link->io.BasePort2;
605 /* Set UART base address and force map with COR bit 1 */
606 writeb(iouart & 0xff, smc->base + MOT_UART + CISREG_IOBASE_0);
607 writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
608 writeb(MOT_NORMAL, smc->base + MOT_UART + CISREG_COR);
610 /* Set SMC base address and force map with COR bit 1 */
611 writeb(ioaddr & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_0);
612 writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
613 writeb(MOT_NORMAL, smc->base + MOT_LAN + CISREG_COR);
615 /* Wait for things to settle down */
619 static int mot_setup(struct pcmcia_device *link)
621 struct net_device *dev = link->priv;
622 unsigned int ioaddr = dev->base_addr;
626 /* Read Ethernet address from Serial EEPROM */
628 for (i = 0; i < 3; i++) {
630 outw(MOT_EEPROM + i, ioaddr + POINTER);
632 outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
634 for (loop = wait = 0; loop < 200; loop++) {
636 wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
637 if (wait == 0) break;
643 addr = inw(ioaddr + GENERAL);
644 dev->dev_addr[2*i] = addr & 0xff;
645 dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
651 /*====================================================================*/
653 static int smc_configcheck(struct pcmcia_device *p_dev,
654 cistpl_cftable_entry_t *cf,
657 p_dev->conf.ConfigIndex = cf->index;
658 p_dev->io.BasePort1 = cf->io.win[0].base;
659 p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
660 return pcmcia_request_io(p_dev, &p_dev->io);
663 static int smc_config(struct pcmcia_device *link)
665 struct net_device *dev = link->priv;
668 link->io.NumPorts1 = 16;
669 i = pcmcia_loop_config(link, smc_configcheck, NULL);
671 dev->base_addr = link->io.BasePort1;
676 static int smc_setup(struct pcmcia_device *link)
678 struct net_device *dev = link->priv;
679 struct smc_cfg_mem *cfg_mem;
682 cistpl_lan_node_id_t *node_id;
683 u_char *buf, *station_addr;
686 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
688 return CS_OUT_OF_RESOURCE;
690 tuple = &cfg_mem->tuple;
691 parse = &cfg_mem->parse;
694 tuple->Attributes = tuple->TupleOffset = 0;
695 tuple->TupleData = (cisdata_t *)buf;
696 tuple->TupleDataMax = 255;
698 /* Check for a LAN function extension tuple */
699 tuple->DesiredTuple = CISTPL_FUNCE;
700 i = first_tuple(link, tuple, parse);
701 while (i == CS_SUCCESS) {
702 if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
704 i = next_tuple(link, tuple, parse);
706 if (i == CS_SUCCESS) {
707 node_id = (cistpl_lan_node_id_t *)parse->funce.data;
708 if (node_id->nb == 6) {
709 for (i = 0; i < 6; i++)
710 dev->dev_addr[i] = node_id->id[i];
715 /* Try the third string in the Version 1 Version/ID tuple. */
716 if (link->prod_id[2]) {
717 station_addr = link->prod_id[2];
718 if (cvt_ascii_address(dev, station_addr) == 0) {
730 /*====================================================================*/
732 static int osi_config(struct pcmcia_device *link)
734 struct net_device *dev = link->priv;
735 static const unsigned int com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
738 link->conf.Attributes |= CONF_ENABLE_SPKR;
739 link->conf.Status = CCSR_AUDIO_ENA;
740 link->irq.Attributes =
741 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
742 link->io.NumPorts1 = 64;
743 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
744 link->io.NumPorts2 = 8;
745 link->io.IOAddrLines = 16;
747 /* Enable Hard Decode, LAN, Modem */
748 link->conf.ConfigIndex = 0x23;
750 for (i = j = 0; j < 4; j++) {
751 link->io.BasePort2 = com[j];
752 i = pcmcia_request_io(link, &link->io);
753 if (i == CS_SUCCESS) break;
755 if (i != CS_SUCCESS) {
756 /* Fallback: turn off hard decode */
757 link->conf.ConfigIndex = 0x03;
758 link->io.NumPorts2 = 0;
759 i = pcmcia_request_io(link, &link->io);
761 dev->base_addr = link->io.BasePort1 + 0x10;
765 static int osi_setup(struct pcmcia_device *link, u_short manfid, u_short cardid)
767 struct net_device *dev = link->priv;
768 struct smc_cfg_mem *cfg_mem;
773 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
777 tuple = &cfg_mem->tuple;
780 tuple->Attributes = TUPLE_RETURN_COMMON;
781 tuple->TupleData = (cisdata_t *)buf;
782 tuple->TupleDataMax = 255;
783 tuple->TupleOffset = 0;
785 /* Read the station address from tuple 0x90, subtuple 0x04 */
786 tuple->DesiredTuple = 0x90;
787 i = pcmcia_get_first_tuple(link, tuple);
788 while (i == CS_SUCCESS) {
789 i = pcmcia_get_tuple_data(link, tuple);
790 if ((i != CS_SUCCESS) || (buf[0] == 0x04))
792 i = pcmcia_get_next_tuple(link, tuple);
794 if (i != CS_SUCCESS) {
798 for (i = 0; i < 6; i++)
799 dev->dev_addr[i] = buf[i+2];
801 if (((manfid == MANFID_OSITECH) &&
802 (cardid == PRODID_OSITECH_SEVEN)) ||
803 ((manfid == MANFID_PSION) &&
804 (cardid == PRODID_PSION_NET100))) {
805 /* Download the Seven of Diamonds firmware */
806 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
807 outb(__Xilinx7OD[i], link->io.BasePort1+2);
810 } else if (manfid == MANFID_OSITECH) {
811 /* Make sure both functions are powered up */
812 set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
813 /* Now, turn on the interrupt for both card functions */
814 set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
815 DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
816 inw(link->io.BasePort1 + OSITECH_AUI_PWR),
817 inw(link->io.BasePort1 + OSITECH_RESET_ISR));
825 static int smc91c92_suspend(struct pcmcia_device *link)
827 struct net_device *dev = link->priv;
830 netif_device_detach(dev);
835 static int smc91c92_resume(struct pcmcia_device *link)
837 struct net_device *dev = link->priv;
838 struct smc_private *smc = netdev_priv(dev);
841 if ((smc->manfid == MANFID_MEGAHERTZ) &&
842 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
843 mhz_3288_power(link);
844 if (smc->manfid == MANFID_MOTOROLA)
846 if ((smc->manfid == MANFID_OSITECH) &&
847 (smc->cardid != PRODID_OSITECH_SEVEN)) {
848 /* Power up the card and enable interrupts */
849 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
850 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
852 if (((smc->manfid == MANFID_OSITECH) &&
853 (smc->cardid == PRODID_OSITECH_SEVEN)) ||
854 ((smc->manfid == MANFID_PSION) &&
855 (smc->cardid == PRODID_PSION_NET100))) {
856 /* Download the Seven of Diamonds firmware */
857 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
858 outb(__Xilinx7OD[i], link->io.BasePort1+2);
864 netif_device_attach(dev);
871 /*======================================================================
873 This verifies that the chip is some SMC91cXX variant, and returns
874 the revision code if successful. Otherwise, it returns -ENODEV.
876 ======================================================================*/
878 static int check_sig(struct pcmcia_device *link)
880 struct net_device *dev = link->priv;
881 unsigned int ioaddr = dev->base_addr;
886 if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
887 /* Try powering up the chip */
888 outw(0, ioaddr + CONTROL);
892 /* Try setting bus width */
893 width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
894 s = inb(ioaddr + CONFIG);
899 outb(s, ioaddr + CONFIG);
901 /* Check Base Address Register to make sure bus width is OK */
902 s = inw(ioaddr + BASE_ADDR);
903 if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
904 ((s >> 8) != (s & 0xff))) {
906 s = inw(ioaddr + REVISION);
912 .Attributes = CONF_IO_CHANGE_WIDTH,
914 printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
916 smc91c92_suspend(link);
917 pcmcia_modify_configuration(link, &mod);
918 smc91c92_resume(link);
919 return check_sig(link);
924 /*======================================================================
926 smc91c92_config() is scheduled to run after a CARD_INSERTION event
927 is received, to configure the PCMCIA socket, and to make the
928 ethernet device available to the system.
930 ======================================================================*/
932 #define CS_EXIT_TEST(ret, svc, label) \
933 if (ret != CS_SUCCESS) { cs_error(link, svc, ret); goto label; }
935 static int smc91c92_config(struct pcmcia_device *link)
937 struct net_device *dev = link->priv;
938 struct smc_private *smc = netdev_priv(dev);
943 DECLARE_MAC_BUF(mac);
945 DEBUG(0, "smc91c92_config(0x%p)\n", link);
947 smc->manfid = link->manf_id;
948 smc->cardid = link->card_id;
950 if ((smc->manfid == MANFID_OSITECH) &&
951 (smc->cardid != PRODID_OSITECH_SEVEN)) {
952 i = osi_config(link);
953 } else if ((smc->manfid == MANFID_MOTOROLA) ||
954 ((smc->manfid == MANFID_MEGAHERTZ) &&
955 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
956 (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
957 i = mhz_mfc_config(link);
959 i = smc_config(link);
961 CS_EXIT_TEST(i, RequestIO, config_failed);
963 i = pcmcia_request_irq(link, &link->irq);
964 CS_EXIT_TEST(i, RequestIRQ, config_failed);
965 i = pcmcia_request_configuration(link, &link->conf);
966 CS_EXIT_TEST(i, RequestConfiguration, config_failed);
968 if (smc->manfid == MANFID_MOTOROLA)
971 dev->irq = link->irq.AssignedIRQ;
973 if ((if_port >= 0) && (if_port <= 2))
974 dev->if_port = if_port;
976 printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
978 switch (smc->manfid) {
981 i = osi_setup(link, smc->manfid, smc->cardid); break;
983 case MANFID_NEW_MEDIA:
984 i = smc_setup(link); break;
985 case 0x128: /* For broken Megahertz cards */
986 case MANFID_MEGAHERTZ:
987 i = mhz_setup(link); break;
988 case MANFID_MOTOROLA:
989 default: /* get the hw address from EEPROM */
990 i = mot_setup(link); break;
994 printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1001 rev = check_sig(link);
1005 case 3: name = "92"; break;
1006 case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1007 case 5: name = "95"; break;
1008 case 7: name = "100"; break;
1009 case 8: name = "100-FD"; break;
1010 case 9: name = "110"; break;
1013 ioaddr = dev->base_addr;
1017 mir = inw(ioaddr + MEMINFO) & 0xff;
1018 if (mir == 0xff) mir++;
1019 /* Get scale factor for memory size */
1020 mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1021 mir *= 128 * (1<<((mcr >> 9) & 7));
1023 smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1024 smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1025 if (smc->manfid == MANFID_OSITECH)
1026 smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1027 if ((rev >> 4) >= 7)
1028 smc->cfg |= CFG_MII_SELECT;
1032 if (smc->cfg & CFG_MII_SELECT) {
1035 for (i = 0; i < 32; i++) {
1036 j = mdio_read(dev, i, 1);
1037 if ((j != 0) && (j != 0xffff)) break;
1039 smc->mii_if.phy_id = (i < 32) ? i : -1;
1044 link->dev_node = &smc->node;
1045 SET_NETDEV_DEV(dev, &handle_to_dev(link));
1047 if (register_netdev(dev) != 0) {
1048 printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1049 link->dev_node = NULL;
1053 strcpy(smc->node.dev_name, dev->name);
1055 printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1057 dev->name, name, (rev & 0x0f), dev->base_addr, dev->irq,
1058 print_mac(mac, dev->dev_addr));
1062 printk(KERN_INFO " %lu byte", mir);
1064 printk(KERN_INFO " %lu kb", mir>>10);
1065 printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1066 "MII" : if_names[dev->if_port]);
1069 if (smc->cfg & CFG_MII_SELECT) {
1070 if (smc->mii_if.phy_id != -1) {
1071 DEBUG(0, " MII transceiver at index %d, status %x.\n",
1072 smc->mii_if.phy_id, j);
1074 printk(KERN_NOTICE " No MII transceivers found!\n");
1080 unregister_netdev(dev);
1081 config_failed: /* CS_EXIT_TEST() calls jump to here... */
1082 smc91c92_release(link);
1084 } /* smc91c92_config */
1086 /*======================================================================
1088 After a card is removed, smc91c92_release() will unregister the net
1089 device, and release the PCMCIA configuration. If the device is
1090 still open, this will be postponed until it is closed.
1092 ======================================================================*/
1094 static void smc91c92_release(struct pcmcia_device *link)
1096 DEBUG(0, "smc91c92_release(0x%p)\n", link);
1098 struct net_device *dev = link->priv;
1099 struct smc_private *smc = netdev_priv(dev);
1102 pcmcia_disable_device(link);
1105 /*======================================================================
1107 MII interface support for SMC91cXX based cards
1108 ======================================================================*/
1110 #define MDIO_SHIFT_CLK 0x04
1111 #define MDIO_DATA_OUT 0x01
1112 #define MDIO_DIR_WRITE 0x08
1113 #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
1114 #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1115 #define MDIO_DATA_READ 0x02
1117 static void mdio_sync(unsigned int addr)
1120 for (bits = 0; bits < 32; bits++) {
1121 outb(MDIO_DATA_WRITE1, addr);
1122 outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1126 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1128 unsigned int addr = dev->base_addr + MGMT;
1129 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1133 for (i = 13; i >= 0; i--) {
1134 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1136 outb(dat | MDIO_SHIFT_CLK, addr);
1138 for (i = 19; i > 0; i--) {
1140 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1141 outb(MDIO_SHIFT_CLK, addr);
1143 return (retval>>1) & 0xffff;
1146 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1148 unsigned int addr = dev->base_addr + MGMT;
1149 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1153 for (i = 31; i >= 0; i--) {
1154 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1156 outb(dat | MDIO_SHIFT_CLK, addr);
1158 for (i = 1; i >= 0; i--) {
1160 outb(MDIO_SHIFT_CLK, addr);
1164 /*======================================================================
1166 The driver core code, most of which should be common with a
1167 non-PCMCIA implementation.
1169 ======================================================================*/
1172 static void smc_dump(struct net_device *dev)
1174 unsigned int ioaddr = dev->base_addr;
1176 save = inw(ioaddr + BANK_SELECT);
1177 for (w = 0; w < 4; w++) {
1179 printk(KERN_DEBUG "bank %d: ", w);
1180 for (i = 0; i < 14; i += 2)
1181 printk(" %04x", inw(ioaddr + i));
1184 outw(save, ioaddr + BANK_SELECT);
1188 static int smc_open(struct net_device *dev)
1190 struct smc_private *smc = netdev_priv(dev);
1191 struct pcmcia_device *link = smc->p_dev;
1194 DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1195 dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1196 if (pc_debug > 1) smc_dump(dev);
1199 /* Check that the PCMCIA card is still here. */
1200 if (!pcmcia_dev_present(link))
1202 /* Physical device present signature. */
1203 if (check_sig(link) < 0) {
1204 printk("smc91c92_cs: Yikes! Bad chip signature!\n");
1209 netif_start_queue(dev);
1210 smc->saved_skb = NULL;
1211 smc->packets_waiting = 0;
1214 init_timer(&smc->media);
1215 smc->media.function = &media_check;
1216 smc->media.data = (u_long) dev;
1217 smc->media.expires = jiffies + HZ;
1218 add_timer(&smc->media);
1223 /*====================================================================*/
1225 static int smc_close(struct net_device *dev)
1227 struct smc_private *smc = netdev_priv(dev);
1228 struct pcmcia_device *link = smc->p_dev;
1229 unsigned int ioaddr = dev->base_addr;
1231 DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1232 dev->name, inw(ioaddr + BANK_SELECT));
1234 netif_stop_queue(dev);
1236 /* Shut off all interrupts, and turn off the Tx and Rx sections.
1237 Don't bother to check for chip present. */
1238 SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1239 outw(0, ioaddr + INTERRUPT);
1241 mask_bits(0xff00, ioaddr + RCR);
1242 mask_bits(0xff00, ioaddr + TCR);
1244 /* Put the chip into power-down mode. */
1246 outw(CTL_POWERDOWN, ioaddr + CONTROL );
1249 del_timer_sync(&smc->media);
1254 /*======================================================================
1256 Transfer a packet to the hardware and trigger the packet send.
1257 This may be called at either from either the Tx queue code
1258 or the interrupt handler.
1260 ======================================================================*/
1262 static void smc_hardware_send_packet(struct net_device * dev)
1264 struct smc_private *smc = netdev_priv(dev);
1265 struct sk_buff *skb = smc->saved_skb;
1266 unsigned int ioaddr = dev->base_addr;
1270 printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1274 /* There should be a packet slot waiting. */
1275 packet_no = inw(ioaddr + PNR_ARR) >> 8;
1276 if (packet_no & 0x80) {
1277 /* If not, there is a hardware problem! Likely an ejected card. */
1278 printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1279 " failed, status %#2.2x.\n", dev->name, packet_no);
1280 dev_kfree_skb_irq(skb);
1281 smc->saved_skb = NULL;
1282 netif_start_queue(dev);
1286 smc->stats.tx_bytes += skb->len;
1287 /* The card should use the just-allocated buffer. */
1288 outw(packet_no, ioaddr + PNR_ARR);
1289 /* point to the beginning of the packet */
1290 outw(PTR_AUTOINC , ioaddr + POINTER);
1292 /* Send the packet length (+6 for status, length and ctl byte)
1293 and the status word (set to zeros). */
1295 u_char *buf = skb->data;
1296 u_int length = skb->len; /* The chip will pad to ethernet min. */
1298 DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1301 /* send the packet length: +6 for status word, length, and ctl */
1302 outw(0, ioaddr + DATA_1);
1303 outw(length + 6, ioaddr + DATA_1);
1304 outsw(ioaddr + DATA_1, buf, length >> 1);
1306 /* The odd last byte, if there is one, goes in the control word. */
1307 outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1310 /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1311 outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1312 (inw(ioaddr + INTERRUPT) & 0xff00),
1313 ioaddr + INTERRUPT);
1315 /* The chip does the rest of the work. */
1316 outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1318 smc->saved_skb = NULL;
1319 dev_kfree_skb_irq(skb);
1320 dev->trans_start = jiffies;
1321 netif_start_queue(dev);
1325 /*====================================================================*/
1327 static void smc_tx_timeout(struct net_device *dev)
1329 struct smc_private *smc = netdev_priv(dev);
1330 unsigned int ioaddr = dev->base_addr;
1332 printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1333 "Tx_status %2.2x status %4.4x.\n",
1334 dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1335 smc->stats.tx_errors++;
1337 dev->trans_start = jiffies;
1338 smc->saved_skb = NULL;
1339 netif_wake_queue(dev);
1342 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1344 struct smc_private *smc = netdev_priv(dev);
1345 unsigned int ioaddr = dev->base_addr;
1348 unsigned long flags;
1350 netif_stop_queue(dev);
1352 DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1353 " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1355 if (smc->saved_skb) {
1356 /* THIS SHOULD NEVER HAPPEN. */
1357 smc->stats.tx_aborted_errors++;
1358 printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1362 smc->saved_skb = skb;
1364 num_pages = skb->len >> 8;
1366 if (num_pages > 7) {
1367 printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1368 dev_kfree_skb (skb);
1369 smc->saved_skb = NULL;
1370 smc->stats.tx_dropped++;
1371 return 0; /* Do not re-queue this packet. */
1373 /* A packet is now waiting. */
1374 smc->packets_waiting++;
1376 spin_lock_irqsave(&smc->lock, flags);
1377 SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1379 /* need MC_RESET to keep the memory consistent. errata? */
1381 outw(MC_RESET, ioaddr + MMU_CMD);
1385 /* Allocate the memory; send the packet now if we win. */
1386 outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1387 for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1388 ir = inw(ioaddr+INTERRUPT);
1389 if (ir & IM_ALLOC_INT) {
1390 /* Acknowledge the interrupt, send the packet. */
1391 outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1392 smc_hardware_send_packet(dev); /* Send the packet now.. */
1393 spin_unlock_irqrestore(&smc->lock, flags);
1398 /* Otherwise defer until the Tx-space-allocated interrupt. */
1399 DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1400 outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1401 spin_unlock_irqrestore(&smc->lock, flags);
1406 /*======================================================================
1408 Handle a Tx anomolous event. Entered while in Window 2.
1410 ======================================================================*/
1412 static void smc_tx_err(struct net_device * dev)
1414 struct smc_private *smc = netdev_priv(dev);
1415 unsigned int ioaddr = dev->base_addr;
1416 int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1417 int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1420 /* select this as the packet to read from */
1421 outw(packet_no, ioaddr + PNR_ARR);
1423 /* read the first word from this packet */
1424 outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1426 tx_status = inw(ioaddr + DATA_1);
1428 smc->stats.tx_errors++;
1429 if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1430 if (tx_status & TS_LATCOL) smc->stats.tx_window_errors++;
1431 if (tx_status & TS_16COL) {
1432 smc->stats.tx_aborted_errors++;
1436 if (tx_status & TS_SUCCESS) {
1437 printk(KERN_NOTICE "%s: Successful packet caused error "
1438 "interrupt?\n", dev->name);
1440 /* re-enable transmit */
1442 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1445 outw(MC_FREEPKT, ioaddr + MMU_CMD); /* Free the packet memory. */
1447 /* one less packet waiting for me */
1448 smc->packets_waiting--;
1450 outw(saved_packet, ioaddr + PNR_ARR);
1454 /*====================================================================*/
1456 static void smc_eph_irq(struct net_device *dev)
1458 struct smc_private *smc = netdev_priv(dev);
1459 unsigned int ioaddr = dev->base_addr;
1460 u_short card_stats, ephs;
1463 ephs = inw(ioaddr + EPH);
1464 DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1465 " %4.4x.\n", dev->name, ephs);
1466 /* Could be a counter roll-over warning: update stats. */
1467 card_stats = inw(ioaddr + COUNTER);
1468 /* single collisions */
1469 smc->stats.collisions += card_stats & 0xF;
1471 /* multiple collisions */
1472 smc->stats.collisions += card_stats & 0xF;
1473 #if 0 /* These are for when linux supports these statistics */
1474 card_stats >>= 4; /* deferred */
1475 card_stats >>= 4; /* excess deferred */
1477 /* If we had a transmit error we must re-enable the transmitter. */
1478 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1480 /* Clear a link error interrupt. */
1482 outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1483 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1488 /*====================================================================*/
1490 static irqreturn_t smc_interrupt(int irq, void *dev_id)
1492 struct net_device *dev = dev_id;
1493 struct smc_private *smc = netdev_priv(dev);
1494 unsigned int ioaddr;
1495 u_short saved_bank, saved_pointer, mask, status;
1496 unsigned int handled = 1;
1497 char bogus_cnt = INTR_WORK; /* Work we are willing to do. */
1499 if (!netif_device_present(dev))
1502 ioaddr = dev->base_addr;
1504 DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1507 spin_lock(&smc->lock);
1509 saved_bank = inw(ioaddr + BANK_SELECT);
1510 if ((saved_bank & 0xff00) != 0x3300) {
1511 /* The device does not exist -- the card could be off-line, or
1512 maybe it has been ejected. */
1513 DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1514 "/ejected device.\n", dev->name, irq);
1520 saved_pointer = inw(ioaddr + POINTER);
1521 mask = inw(ioaddr + INTERRUPT) >> 8;
1522 /* clear all interrupts */
1523 outw(0, ioaddr + INTERRUPT);
1525 do { /* read the status flag, and mask it */
1526 status = inw(ioaddr + INTERRUPT) & 0xff;
1527 DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1529 if ((status & mask) == 0) {
1530 if (bogus_cnt == INTR_WORK)
1534 if (status & IM_RCV_INT) {
1535 /* Got a packet(s). */
1538 if (status & IM_TX_INT) {
1540 outw(IM_TX_INT, ioaddr + INTERRUPT);
1543 if (status & IM_TX_EMPTY_INT) {
1544 outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1545 mask &= ~IM_TX_EMPTY_INT;
1546 smc->stats.tx_packets += smc->packets_waiting;
1547 smc->packets_waiting = 0;
1549 if (status & IM_ALLOC_INT) {
1550 /* Clear this interrupt so it doesn't happen again */
1551 mask &= ~IM_ALLOC_INT;
1553 smc_hardware_send_packet(dev);
1555 /* enable xmit interrupts based on this */
1556 mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1558 /* and let the card send more packets to me */
1559 netif_wake_queue(dev);
1561 if (status & IM_RX_OVRN_INT) {
1562 smc->stats.rx_errors++;
1563 smc->stats.rx_fifo_errors++;
1565 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1566 outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1568 if (status & IM_EPH_INT)
1570 } while (--bogus_cnt);
1572 DEBUG(3, " Restoring saved registers mask %2.2x bank %4.4x"
1573 " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1575 /* restore state register */
1576 outw((mask<<8), ioaddr + INTERRUPT);
1577 outw(saved_pointer, ioaddr + POINTER);
1578 SMC_SELECT_BANK(saved_bank);
1580 DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1584 if ((smc->manfid == MANFID_OSITECH) &&
1585 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1586 /* Retrigger interrupt if needed */
1587 mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1588 set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1590 if (smc->manfid == MANFID_MOTOROLA) {
1592 cor = readb(smc->base + MOT_UART + CISREG_COR);
1593 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1594 writeb(cor, smc->base + MOT_UART + CISREG_COR);
1595 cor = readb(smc->base + MOT_LAN + CISREG_COR);
1596 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1597 writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1599 #ifdef DOES_NOT_WORK
1600 if (smc->base != NULL) { /* Megahertz MFC's */
1601 readb(smc->base+MEGAHERTZ_ISR);
1602 readb(smc->base+MEGAHERTZ_ISR);
1605 spin_unlock(&smc->lock);
1606 return IRQ_RETVAL(handled);
1609 /*====================================================================*/
1611 static void smc_rx(struct net_device *dev)
1613 struct smc_private *smc = netdev_priv(dev);
1614 unsigned int ioaddr = dev->base_addr;
1616 int packet_length; /* Caution: not frame length, rather words
1617 to transfer from the chip. */
1619 /* Assertion: we are in Window 2. */
1621 if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1622 printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1627 /* Reset the read pointer, and read the status and packet length. */
1628 outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1629 rx_status = inw(ioaddr + DATA_1);
1630 packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1632 DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1633 dev->name, rx_status, packet_length);
1635 if (!(rx_status & RS_ERRORS)) {
1636 /* do stuff to make a new packet */
1637 struct sk_buff *skb;
1639 /* Note: packet_length adds 5 or 6 extra bytes here! */
1640 skb = dev_alloc_skb(packet_length+2);
1643 DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1644 smc->stats.rx_dropped++;
1645 outw(MC_RELEASE, ioaddr + MMU_CMD);
1649 packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1650 skb_reserve(skb, 2);
1651 insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1652 (packet_length+1)>>1);
1653 skb->protocol = eth_type_trans(skb, dev);
1656 dev->last_rx = jiffies;
1657 smc->stats.rx_packets++;
1658 smc->stats.rx_bytes += packet_length;
1659 if (rx_status & RS_MULTICAST)
1660 smc->stats.multicast++;
1663 smc->stats.rx_errors++;
1665 if (rx_status & RS_ALGNERR) smc->stats.rx_frame_errors++;
1666 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1667 smc->stats.rx_length_errors++;
1668 if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
1670 /* Let the MMU free the memory of this packet. */
1671 outw(MC_RELEASE, ioaddr + MMU_CMD);
1676 /*====================================================================*/
1678 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1680 struct smc_private *smc = netdev_priv(dev);
1681 /* Nothing to update - the 91c92 is a pretty primative chip. */
1685 /*======================================================================
1687 Calculate values for the hardware multicast filter hash table.
1689 ======================================================================*/
1691 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1692 u_char *multicast_table)
1694 struct dev_mc_list *mc_addr;
1696 for (mc_addr = addrs; mc_addr && count-- > 0; mc_addr = mc_addr->next) {
1697 u_int position = ether_crc(6, mc_addr->dmi_addr);
1698 #ifndef final_version /* Verify multicast address. */
1699 if ((mc_addr->dmi_addr[0] & 1) == 0)
1702 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1706 /*======================================================================
1708 Set the receive mode.
1710 This routine is used by both the protocol level to notify us of
1711 promiscuous/multicast mode changes, and by the open/reset code to
1712 initialize the Rx registers. We always set the multicast list and
1713 leave the receiver running.
1715 ======================================================================*/
1717 static void set_rx_mode(struct net_device *dev)
1719 unsigned int ioaddr = dev->base_addr;
1720 struct smc_private *smc = netdev_priv(dev);
1721 u_int multicast_table[ 2 ] = { 0, };
1722 unsigned long flags;
1723 u_short rx_cfg_setting;
1725 if (dev->flags & IFF_PROMISC) {
1726 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1727 } else if (dev->flags & IFF_ALLMULTI)
1728 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1730 if (dev->mc_count) {
1731 fill_multicast_tbl(dev->mc_count, dev->mc_list,
1732 (u_char *)multicast_table);
1734 rx_cfg_setting = RxStripCRC | RxEnable;
1737 /* Load MC table and Rx setting into the chip without interrupts. */
1738 spin_lock_irqsave(&smc->lock, flags);
1740 outl(multicast_table[0], ioaddr + MULTICAST0);
1741 outl(multicast_table[1], ioaddr + MULTICAST4);
1743 outw(rx_cfg_setting, ioaddr + RCR);
1745 spin_unlock_irqrestore(&smc->lock, flags);
1750 /*======================================================================
1752 Senses when a card's config changes. Here, it's coax or TP.
1754 ======================================================================*/
1756 static int s9k_config(struct net_device *dev, struct ifmap *map)
1758 struct smc_private *smc = netdev_priv(dev);
1759 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1760 if (smc->cfg & CFG_MII_SELECT)
1762 else if (map->port > 2)
1764 dev->if_port = map->port;
1765 printk(KERN_INFO "%s: switched to %s port\n",
1766 dev->name, if_names[dev->if_port]);
1772 /*======================================================================
1774 Reset the chip, reloading every register that might be corrupted.
1776 ======================================================================*/
1779 Set transceiver type, perhaps to something other than what the user
1780 specified in dev->if_port.
1782 static void smc_set_xcvr(struct net_device *dev, int if_port)
1784 struct smc_private *smc = netdev_priv(dev);
1785 unsigned int ioaddr = dev->base_addr;
1788 saved_bank = inw(ioaddr + BANK_SELECT);
1791 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1792 if ((smc->manfid == MANFID_OSITECH) &&
1793 (smc->cardid != PRODID_OSITECH_SEVEN))
1794 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1795 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1797 outw(smc->cfg, ioaddr + CONFIG);
1798 if ((smc->manfid == MANFID_OSITECH) &&
1799 (smc->cardid != PRODID_OSITECH_SEVEN))
1800 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1801 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1803 SMC_SELECT_BANK(saved_bank);
1806 static void smc_reset(struct net_device *dev)
1808 unsigned int ioaddr = dev->base_addr;
1809 struct smc_private *smc = netdev_priv(dev);
1812 DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1814 /* The first interaction must be a write to bring the chip out
1817 /* Reset the chip. */
1818 outw(RCR_SOFTRESET, ioaddr + RCR);
1821 /* Clear the transmit and receive configuration registers. */
1822 outw(RCR_CLEAR, ioaddr + RCR);
1823 outw(TCR_CLEAR, ioaddr + TCR);
1825 /* Set the Window 1 control, configuration and station addr registers.
1826 No point in writing the I/O base register ;-> */
1828 /* Automatically release successfully transmitted packets,
1829 Accept link errors, counter and Tx error interrupts. */
1830 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1832 smc_set_xcvr(dev, dev->if_port);
1833 if ((smc->manfid == MANFID_OSITECH) &&
1834 (smc->cardid != PRODID_OSITECH_SEVEN))
1835 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1836 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1837 ioaddr - 0x10 + OSITECH_AUI_PWR);
1839 /* Fill in the physical address. The databook is wrong about the order! */
1840 for (i = 0; i < 6; i += 2)
1841 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1842 ioaddr + ADDR0 + i);
1846 outw(MC_RESET, ioaddr + MMU_CMD);
1847 outw(0, ioaddr + INTERRUPT);
1849 /* Re-enable the chip. */
1851 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1852 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1855 if (smc->cfg & CFG_MII_SELECT) {
1859 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1861 /* Advertise 100F, 100H, 10F, 10H */
1862 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1864 /* Restart MII autonegotiation */
1865 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1866 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1869 /* Enable interrupts. */
1871 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
1872 ioaddr + INTERRUPT);
1875 /*======================================================================
1877 Media selection timer routine
1879 ======================================================================*/
1881 static void media_check(u_long arg)
1883 struct net_device *dev = (struct net_device *) arg;
1884 struct smc_private *smc = netdev_priv(dev);
1885 unsigned int ioaddr = dev->base_addr;
1886 u_short i, media, saved_bank;
1888 unsigned long flags;
1890 spin_lock_irqsave(&smc->lock, flags);
1892 saved_bank = inw(ioaddr + BANK_SELECT);
1894 if (!netif_device_present(dev))
1899 /* need MC_RESET to keep the memory consistent. errata? */
1901 outw(MC_RESET, ioaddr + MMU_CMD);
1904 i = inw(ioaddr + INTERRUPT);
1906 media = inw(ioaddr + EPH) & EPH_LINK_OK;
1908 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
1910 /* Check for pending interrupt with watchdog flag set: with
1911 this, we can limp along even if the interrupt is blocked */
1912 if (smc->watchdog++ && ((i>>8) & i)) {
1913 if (!smc->fast_poll)
1914 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1915 smc_interrupt(dev->irq, dev);
1916 smc->fast_poll = HZ;
1918 if (smc->fast_poll) {
1920 smc->media.expires = jiffies + HZ/100;
1921 add_timer(&smc->media);
1922 SMC_SELECT_BANK(saved_bank);
1923 spin_unlock_irqrestore(&smc->lock, flags);
1927 if (smc->cfg & CFG_MII_SELECT) {
1928 if (smc->mii_if.phy_id < 0)
1932 link = mdio_read(dev, smc->mii_if.phy_id, 1);
1933 if (!link || (link == 0xffff)) {
1934 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
1935 smc->mii_if.phy_id = -1;
1940 if (link != smc->link_status) {
1941 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
1942 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1943 (link) ? "found" : "lost");
1944 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
1947 printk(KERN_INFO "%s: autonegotiation complete: "
1948 "%sbaseT-%cD selected\n", dev->name,
1949 ((p & 0x0180) ? "100" : "10"),
1950 (smc->duplex ? 'F' : 'H'));
1953 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
1954 smc->link_status = link;
1959 /* Ignore collisions unless we've had no rx's recently */
1960 if (time_after(jiffies, dev->last_rx + HZ)) {
1961 if (smc->tx_err || (smc->media_status & EPH_16COL))
1966 if (media != smc->media_status) {
1967 if ((media & smc->media_status & 1) &&
1968 ((smc->media_status ^ media) & EPH_LINK_OK))
1969 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1970 (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
1971 else if ((media & smc->media_status & 2) &&
1972 ((smc->media_status ^ media) & EPH_16COL))
1973 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
1974 (media & EPH_16COL ? "problem" : "ok"));
1975 if (dev->if_port == 0) {
1977 if (media & EPH_LINK_OK)
1978 printk(KERN_INFO "%s: flipped to 10baseT\n",
1981 smc_set_xcvr(dev, 2);
1983 if (media & EPH_16COL)
1984 smc_set_xcvr(dev, 1);
1986 printk(KERN_INFO "%s: flipped to 10base2\n",
1990 smc->media_status = media;
1994 smc->media.expires = jiffies + HZ;
1995 add_timer(&smc->media);
1996 SMC_SELECT_BANK(saved_bank);
1997 spin_unlock_irqrestore(&smc->lock, flags);
2000 static int smc_link_ok(struct net_device *dev)
2002 unsigned int ioaddr = dev->base_addr;
2003 struct smc_private *smc = netdev_priv(dev);
2005 if (smc->cfg & CFG_MII_SELECT) {
2006 return mii_link_ok(&smc->mii_if);
2009 return inw(ioaddr + EPH) & EPH_LINK_OK;
2013 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2016 unsigned int ioaddr = dev->base_addr;
2018 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2019 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2022 tmp = inw(ioaddr + CONFIG);
2023 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2024 ecmd->transceiver = XCVR_INTERNAL;
2025 ecmd->speed = SPEED_10;
2026 ecmd->phy_address = ioaddr + MGMT;
2029 tmp = inw(ioaddr + TCR);
2030 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2035 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2038 unsigned int ioaddr = dev->base_addr;
2040 if (ecmd->speed != SPEED_10)
2042 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2044 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2046 if (ecmd->transceiver != XCVR_INTERNAL)
2049 if (ecmd->port == PORT_AUI)
2050 smc_set_xcvr(dev, 1);
2052 smc_set_xcvr(dev, 0);
2055 tmp = inw(ioaddr + TCR);
2056 if (ecmd->duplex == DUPLEX_FULL)
2060 outw(tmp, ioaddr + TCR);
2065 static int check_if_running(struct net_device *dev)
2067 if (!netif_running(dev))
2072 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2074 strcpy(info->driver, DRV_NAME);
2075 strcpy(info->version, DRV_VERSION);
2078 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2080 struct smc_private *smc = netdev_priv(dev);
2081 unsigned int ioaddr = dev->base_addr;
2082 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2085 spin_lock_irq(&smc->lock);
2087 if (smc->cfg & CFG_MII_SELECT)
2088 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2090 ret = smc_netdev_get_ecmd(dev, ecmd);
2091 SMC_SELECT_BANK(saved_bank);
2092 spin_unlock_irq(&smc->lock);
2096 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2098 struct smc_private *smc = netdev_priv(dev);
2099 unsigned int ioaddr = dev->base_addr;
2100 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2103 spin_lock_irq(&smc->lock);
2105 if (smc->cfg & CFG_MII_SELECT)
2106 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2108 ret = smc_netdev_set_ecmd(dev, ecmd);
2109 SMC_SELECT_BANK(saved_bank);
2110 spin_unlock_irq(&smc->lock);
2114 static u32 smc_get_link(struct net_device *dev)
2116 struct smc_private *smc = netdev_priv(dev);
2117 unsigned int ioaddr = dev->base_addr;
2118 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2121 spin_lock_irq(&smc->lock);
2123 ret = smc_link_ok(dev);
2124 SMC_SELECT_BANK(saved_bank);
2125 spin_unlock_irq(&smc->lock);
2130 static u32 smc_get_msglevel(struct net_device *dev)
2135 static void smc_set_msglevel(struct net_device *dev, u32 val)
2141 static int smc_nway_reset(struct net_device *dev)
2143 struct smc_private *smc = netdev_priv(dev);
2144 if (smc->cfg & CFG_MII_SELECT) {
2145 unsigned int ioaddr = dev->base_addr;
2146 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2150 res = mii_nway_restart(&smc->mii_if);
2151 SMC_SELECT_BANK(saved_bank);
2158 static const struct ethtool_ops ethtool_ops = {
2159 .begin = check_if_running,
2160 .get_drvinfo = smc_get_drvinfo,
2161 .get_settings = smc_get_settings,
2162 .set_settings = smc_set_settings,
2163 .get_link = smc_get_link,
2165 .get_msglevel = smc_get_msglevel,
2166 .set_msglevel = smc_set_msglevel,
2168 .nway_reset = smc_nway_reset,
2171 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2173 struct smc_private *smc = netdev_priv(dev);
2174 struct mii_ioctl_data *mii = if_mii(rq);
2177 unsigned int ioaddr = dev->base_addr;
2179 if (!netif_running(dev))
2182 spin_lock_irq(&smc->lock);
2183 saved_bank = inw(ioaddr + BANK_SELECT);
2185 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2186 SMC_SELECT_BANK(saved_bank);
2187 spin_unlock_irq(&smc->lock);
2191 static struct pcmcia_device_id smc91c92_ids[] = {
2192 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2193 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2194 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2195 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2196 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2197 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2198 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2199 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2200 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2201 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2202 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2203 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2204 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2205 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2206 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2207 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2208 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2209 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2210 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2211 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2212 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2213 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2214 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2215 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2216 /* These conflict with other cards! */
2217 /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2218 /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2221 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2223 static struct pcmcia_driver smc91c92_cs_driver = {
2224 .owner = THIS_MODULE,
2226 .name = "smc91c92_cs",
2228 .probe = smc91c92_probe,
2229 .remove = smc91c92_detach,
2230 .id_table = smc91c92_ids,
2231 .suspend = smc91c92_suspend,
2232 .resume = smc91c92_resume,
2235 static int __init init_smc91c92_cs(void)
2237 return pcmcia_register_driver(&smc91c92_cs_driver);
2240 static void __exit exit_smc91c92_cs(void)
2242 pcmcia_unregister_driver(&smc91c92_cs_driver);
2245 module_init(init_smc91c92_cs);
2246 module_exit(exit_smc91c92_cs);