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>
45 #include <pcmcia/cs_types.h>
46 #include <pcmcia/cs.h>
47 #include <pcmcia/cistpl.h>
48 #include <pcmcia/cisreg.h>
49 #include <pcmcia/ciscode.h>
50 #include <pcmcia/ds.h>
53 #include <asm/system.h>
54 #include <asm/uaccess.h>
56 /* Ositech Seven of Diamonds firmware */
59 /*====================================================================*/
61 static char *if_names[] = { "auto", "10baseT", "10base2"};
63 /* Module parameters */
65 MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
66 MODULE_LICENSE("GPL");
68 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
71 Transceiver/media type.
73 1 = 10baseT (and autoselect if #define AUTOSELECT),
76 INT_MODULE_PARM(if_port, 0);
79 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
80 static const char *version =
81 "smc91c92_cs.c 0.09 1996/8/4 Donald Becker, becker@scyld.com.\n";
82 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
84 #define DEBUG(n, args...)
87 #define DRV_NAME "smc91c92_cs"
88 #define DRV_VERSION "1.122"
90 /*====================================================================*/
92 /* Operational parameter that usually are not changed. */
94 /* Time in jiffies before concluding Tx hung */
95 #define TX_TIMEOUT ((400*HZ)/1000)
97 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
100 /* Times to check the check the chip before concluding that it doesn't
101 currently have room for another Tx packet. */
102 #define MEMORY_WAIT_TIME 8
104 static dev_info_t dev_info = "smc91c92_cs";
106 static dev_link_t *dev_list;
113 struct net_device_stats stats;
115 struct sk_buff *saved_skb;
119 struct timer_list media;
120 int watchdog, tx_err;
121 u_short media_status;
124 struct mii_if_info mii_if;
135 /* Special definitions for Megahertz multifunction cards */
136 #define MEGAHERTZ_ISR 0x0380
138 /* Special function registers for Motorola Mariner */
139 #define MOT_LAN 0x0000
140 #define MOT_UART 0x0020
141 #define MOT_EEPROM 0x20
144 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
146 /* Special function registers for Ositech cards */
147 #define OSITECH_AUI_CTL 0x0c
148 #define OSITECH_PWRDOWN 0x0d
149 #define OSITECH_RESET 0x0e
150 #define OSITECH_ISR 0x0f
151 #define OSITECH_AUI_PWR 0x0c
152 #define OSITECH_RESET_ISR 0x0e
154 #define OSI_AUI_PWR 0x40
155 #define OSI_LAN_PWRDOWN 0x02
156 #define OSI_MODEM_PWRDOWN 0x01
157 #define OSI_LAN_RESET 0x02
158 #define OSI_MODEM_RESET 0x01
160 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
161 #define BANK_SELECT 14 /* Window select register. */
162 #define SMC_SELECT_BANK(x) { outw(x, ioaddr + BANK_SELECT); }
164 /* Bank 0 registers. */
165 #define TCR 0 /* transmit control register */
166 #define TCR_CLEAR 0 /* do NOTHING */
167 #define TCR_ENABLE 0x0001 /* if this is 1, we can transmit */
168 #define TCR_PAD_EN 0x0080 /* pads short packets to 64 bytes */
169 #define TCR_MONCSN 0x0400 /* Monitor Carrier. */
170 #define TCR_FDUPLX 0x0800 /* Full duplex mode. */
171 #define TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
173 #define EPH 2 /* Ethernet Protocol Handler report. */
174 #define EPH_TX_SUC 0x0001
175 #define EPH_SNGLCOL 0x0002
176 #define EPH_MULCOL 0x0004
177 #define EPH_LTX_MULT 0x0008
178 #define EPH_16COL 0x0010
179 #define EPH_SQET 0x0020
180 #define EPH_LTX_BRD 0x0040
181 #define EPH_TX_DEFR 0x0080
182 #define EPH_LAT_COL 0x0200
183 #define EPH_LOST_CAR 0x0400
184 #define EPH_EXC_DEF 0x0800
185 #define EPH_CTR_ROL 0x1000
186 #define EPH_RX_OVRN 0x2000
187 #define EPH_LINK_OK 0x4000
188 #define EPH_TX_UNRN 0x8000
189 #define MEMINFO 8 /* Memory Information Register */
190 #define MEMCFG 10 /* Memory Configuration Register */
192 /* Bank 1 registers. */
194 #define CFG_MII_SELECT 0x8000 /* 91C100 only */
195 #define CFG_NO_WAIT 0x1000
196 #define CFG_FULL_STEP 0x0400
197 #define CFG_SET_SQLCH 0x0200
198 #define CFG_AUI_SELECT 0x0100
199 #define CFG_16BIT 0x0080
200 #define CFG_DIS_LINK 0x0040
201 #define CFG_STATIC 0x0030
202 #define CFG_IRQ_SEL_1 0x0004
203 #define CFG_IRQ_SEL_0 0x0002
208 #define CTL_STORE 0x0001
209 #define CTL_RELOAD 0x0002
210 #define CTL_EE_SELECT 0x0004
211 #define CTL_TE_ENABLE 0x0020
212 #define CTL_CR_ENABLE 0x0040
213 #define CTL_LE_ENABLE 0x0080
214 #define CTL_AUTO_RELEASE 0x0800
215 #define CTL_POWERDOWN 0x2000
217 /* Bank 2 registers. */
219 #define MC_ALLOC 0x20 /* or with number of 256 byte packets */
220 #define MC_RESET 0x40
221 #define MC_RELEASE 0x80 /* remove and release the current rx packet */
222 #define MC_FREEPKT 0xA0 /* Release packet in PNR register */
223 #define MC_ENQUEUE 0xC0 /* Enqueue the packet for transmit */
226 #define FP_RXEMPTY 0x8000
228 #define PTR_AUTO_INC 0x0040
229 #define PTR_READ 0x2000
230 #define PTR_AUTOINC 0x4000
231 #define PTR_RCV 0x8000
234 #define IM_RCV_INT 0x1
235 #define IM_TX_INT 0x2
236 #define IM_TX_EMPTY_INT 0x4
237 #define IM_ALLOC_INT 0x8
238 #define IM_RX_OVRN_INT 0x10
239 #define IM_EPH_INT 0x20
242 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
243 RxEnable = 0x0100, RxStripCRC = 0x0200};
244 #define RCR_SOFTRESET 0x8000 /* resets the chip */
245 #define RCR_STRIP_CRC 0x200 /* strips CRC */
246 #define RCR_ENABLE 0x100 /* IFF this is set, we can receive packets */
247 #define RCR_ALMUL 0x4 /* receive all multicast packets */
248 #define RCR_PROMISC 0x2 /* enable promiscuous mode */
250 /* the normal settings for the RCR register : */
251 #define RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
252 #define RCR_CLEAR 0x0 /* set it to a base state */
255 /* BANK 3 -- not the same values as in smc9194! */
261 #define REVISION 0x0a
263 /* Transmit status bits. */
264 #define TS_SUCCESS 0x0001
265 #define TS_16COL 0x0010
266 #define TS_LATCOL 0x0200
267 #define TS_LOSTCAR 0x0400
269 /* Receive status bits. */
270 #define RS_ALGNERR 0x8000
271 #define RS_BADCRC 0x2000
272 #define RS_ODDFRAME 0x1000
273 #define RS_TOOLONG 0x0800
274 #define RS_TOOSHORT 0x0400
275 #define RS_MULTICAST 0x0001
276 #define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
278 #define set_bits(v, p) outw(inw(p)|(v), (p))
279 #define mask_bits(v, p) outw(inw(p)&(v), (p))
281 /*====================================================================*/
283 static dev_link_t *smc91c92_attach(void);
284 static void smc91c92_detach(dev_link_t *);
285 static void smc91c92_config(dev_link_t *link);
286 static void smc91c92_release(dev_link_t *link);
287 static int smc91c92_event(event_t event, int priority,
288 event_callback_args_t *args);
290 static int smc_open(struct net_device *dev);
291 static int smc_close(struct net_device *dev);
292 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
293 static void smc_tx_timeout(struct net_device *dev);
294 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
295 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
296 static void smc_rx(struct net_device *dev);
297 static struct net_device_stats *smc_get_stats(struct net_device *dev);
298 static void set_rx_mode(struct net_device *dev);
299 static int s9k_config(struct net_device *dev, struct ifmap *map);
300 static void smc_set_xcvr(struct net_device *dev, int if_port);
301 static void smc_reset(struct net_device *dev);
302 static void media_check(u_long arg);
303 static void mdio_sync(kio_addr_t addr);
304 static int mdio_read(struct net_device *dev, int phy_id, int loc);
305 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
306 static int smc_link_ok(struct net_device *dev);
307 static struct ethtool_ops ethtool_ops;
309 /*======================================================================
311 smc91c92_attach() creates an "instance" of the driver, allocating
312 local data structures for one device. The device is registered
315 ======================================================================*/
317 static dev_link_t *smc91c92_attach(void)
319 client_reg_t client_reg;
320 struct smc_private *smc;
322 struct net_device *dev;
325 DEBUG(0, "smc91c92_attach()\n");
327 /* Create new ethernet device */
328 dev = alloc_etherdev(sizeof(struct smc_private));
331 smc = netdev_priv(dev);
335 spin_lock_init(&smc->lock);
336 link->io.NumPorts1 = 16;
337 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
338 link->io.IOAddrLines = 4;
339 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
340 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
341 link->irq.Handler = &smc_interrupt;
342 link->irq.Instance = dev;
343 link->conf.Attributes = CONF_ENABLE_IRQ;
345 link->conf.IntType = INT_MEMORY_AND_IO;
347 /* The SMC91c92-specific entries in the device structure. */
348 SET_MODULE_OWNER(dev);
349 dev->hard_start_xmit = &smc_start_xmit;
350 dev->get_stats = &smc_get_stats;
351 dev->set_config = &s9k_config;
352 dev->set_multicast_list = &set_rx_mode;
353 dev->open = &smc_open;
354 dev->stop = &smc_close;
355 dev->do_ioctl = &smc_ioctl;
356 SET_ETHTOOL_OPS(dev, ðtool_ops);
357 #ifdef HAVE_TX_TIMEOUT
358 dev->tx_timeout = smc_tx_timeout;
359 dev->watchdog_timeo = TX_TIMEOUT;
362 smc->mii_if.dev = dev;
363 smc->mii_if.mdio_read = mdio_read;
364 smc->mii_if.mdio_write = mdio_write;
365 smc->mii_if.phy_id_mask = 0x1f;
366 smc->mii_if.reg_num_mask = 0x1f;
368 /* Register with Card Services */
369 link->next = dev_list;
371 client_reg.dev_info = &dev_info;
372 client_reg.Version = 0x0210;
373 client_reg.event_callback_args.client_data = link;
374 ret = pcmcia_register_client(&link->handle, &client_reg);
376 cs_error(link->handle, RegisterClient, ret);
377 smc91c92_detach(link);
382 } /* smc91c92_attach */
384 /*======================================================================
386 This deletes a driver "instance". The device is de-registered
387 with Card Services. If it has been released, all local data
388 structures are freed. Otherwise, the structures will be freed
389 when the device is released.
391 ======================================================================*/
393 static void smc91c92_detach(dev_link_t *link)
395 struct net_device *dev = link->priv;
398 DEBUG(0, "smc91c92_detach(0x%p)\n", link);
400 /* Locate device structure */
401 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
402 if (*linkp == link) break;
407 unregister_netdev(dev);
409 if (link->state & DEV_CONFIG)
410 smc91c92_release(link);
413 pcmcia_deregister_client(link->handle);
415 /* Unlink device structure, free bits */
418 } /* smc91c92_detach */
420 /*====================================================================*/
422 static int cvt_ascii_address(struct net_device *dev, char *s)
428 for (i = 0; i < 6; i++) {
430 for (j = 0; j < 2; j++) {
433 da += ((c >= '0') && (c <= '9')) ?
434 (c - '0') : ((c & 0x0f) + 9);
436 dev->dev_addr[i] = da;
441 /*====================================================================*/
443 static int first_tuple(client_handle_t handle, tuple_t *tuple,
448 if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
449 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
451 return pcmcia_parse_tuple(handle, tuple, parse);
454 static int next_tuple(client_handle_t handle, tuple_t *tuple,
459 if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
460 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
462 return pcmcia_parse_tuple(handle, tuple, parse);
465 /*======================================================================
467 Configuration stuff for Megahertz cards
469 mhz_3288_power() is used to power up a 3288's ethernet chip.
470 mhz_mfc_config() handles socket setup for multifunction (1144
471 and 3288) cards. mhz_setup() gets a card's hardware ethernet
474 ======================================================================*/
476 static int mhz_3288_power(dev_link_t *link)
478 struct net_device *dev = link->priv;
479 struct smc_private *smc = netdev_priv(dev);
482 /* Read the ISR twice... */
483 readb(smc->base+MEGAHERTZ_ISR);
485 readb(smc->base+MEGAHERTZ_ISR);
490 /* Now read and write the COR... */
491 tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
493 writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
498 static int mhz_mfc_config(dev_link_t *link)
500 struct net_device *dev = link->priv;
501 struct smc_private *smc = netdev_priv(dev);
502 struct smc_cfg_mem *cfg_mem;
505 cistpl_cftable_entry_t *cf;
511 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
513 return CS_OUT_OF_RESOURCE;
515 tuple = &cfg_mem->tuple;
516 parse = &cfg_mem->parse;
517 cf = &parse->cftable_entry;
520 link->conf.Attributes |= CONF_ENABLE_SPKR;
521 link->conf.Status = CCSR_AUDIO_ENA;
522 link->irq.Attributes =
523 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
524 link->io.IOAddrLines = 16;
525 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
526 link->io.NumPorts2 = 8;
528 tuple->Attributes = tuple->TupleOffset = 0;
529 tuple->TupleData = (cisdata_t *)buf;
530 tuple->TupleDataMax = 255;
531 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
533 i = first_tuple(link->handle, tuple, parse);
534 /* The Megahertz combo cards have modem-like CIS entries, so
535 we have to explicitly try a bunch of port combinations. */
536 while (i == CS_SUCCESS) {
537 link->conf.ConfigIndex = cf->index;
538 link->io.BasePort2 = cf->io.win[0].base;
539 for (k = 0; k < 0x400; k += 0x10) {
540 if (k & 0x80) continue;
541 link->io.BasePort1 = k ^ 0x300;
542 i = pcmcia_request_io(link->handle, &link->io);
543 if (i == CS_SUCCESS) break;
545 if (i == CS_SUCCESS) break;
546 i = next_tuple(link->handle, tuple, parse);
550 dev->base_addr = link->io.BasePort1;
552 /* Allocate a memory window, for accessing the ISR */
553 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
554 req.Base = req.Size = 0;
556 i = pcmcia_request_window(&link->handle, &req, &link->win);
559 smc->base = ioremap(req.Base, req.Size);
560 mem.CardOffset = mem.Page = 0;
561 if (smc->manfid == MANFID_MOTOROLA)
562 mem.CardOffset = link->conf.ConfigBase;
563 i = pcmcia_map_mem_page(link->win, &mem);
565 if ((i == CS_SUCCESS)
566 && (smc->manfid == MANFID_MEGAHERTZ)
567 && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
568 mhz_3288_power(link);
575 static int mhz_setup(dev_link_t *link)
577 client_handle_t handle = link->handle;
578 struct net_device *dev = link->priv;
579 struct smc_cfg_mem *cfg_mem;
582 u_char *buf, *station_addr;
585 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
589 tuple = &cfg_mem->tuple;
590 parse = &cfg_mem->parse;
593 tuple->Attributes = tuple->TupleOffset = 0;
594 tuple->TupleData = (cisdata_t *)buf;
595 tuple->TupleDataMax = 255;
597 /* Read the station address from the CIS. It is stored as the last
598 (fourth) string in the Version 1 Version/ID tuple. */
599 tuple->DesiredTuple = CISTPL_VERS_1;
600 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
604 /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
605 if (next_tuple(handle, tuple, parse) != CS_SUCCESS)
606 first_tuple(handle, tuple, parse);
607 if (parse->version_1.ns > 3) {
608 station_addr = parse->version_1.str + parse->version_1.ofs[3];
609 if (cvt_ascii_address(dev, station_addr) == 0) {
615 /* Another possibility: for the EM3288, in a special tuple */
616 tuple->DesiredTuple = 0x81;
617 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) {
621 if (pcmcia_get_tuple_data(handle, tuple) != CS_SUCCESS) {
626 if (cvt_ascii_address(dev, buf) == 0) {
636 /*======================================================================
638 Configuration stuff for the Motorola Mariner
640 mot_config() writes directly to the Mariner configuration
641 registers because the CIS is just bogus.
643 ======================================================================*/
645 static void mot_config(dev_link_t *link)
647 struct net_device *dev = link->priv;
648 struct smc_private *smc = netdev_priv(dev);
649 kio_addr_t ioaddr = dev->base_addr;
650 kio_addr_t iouart = link->io.BasePort2;
652 /* Set UART base address and force map with COR bit 1 */
653 writeb(iouart & 0xff, smc->base + MOT_UART + CISREG_IOBASE_0);
654 writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
655 writeb(MOT_NORMAL, smc->base + MOT_UART + CISREG_COR);
657 /* Set SMC base address and force map with COR bit 1 */
658 writeb(ioaddr & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_0);
659 writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
660 writeb(MOT_NORMAL, smc->base + MOT_LAN + CISREG_COR);
662 /* Wait for things to settle down */
666 static int mot_setup(dev_link_t *link)
668 struct net_device *dev = link->priv;
669 kio_addr_t ioaddr = dev->base_addr;
673 /* Read Ethernet address from Serial EEPROM */
675 for (i = 0; i < 3; i++) {
677 outw(MOT_EEPROM + i, ioaddr + POINTER);
679 outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
681 for (loop = wait = 0; loop < 200; loop++) {
683 wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
684 if (wait == 0) break;
690 addr = inw(ioaddr + GENERAL);
691 dev->dev_addr[2*i] = addr & 0xff;
692 dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
698 /*====================================================================*/
700 static int smc_config(dev_link_t *link)
702 struct net_device *dev = link->priv;
703 struct smc_cfg_mem *cfg_mem;
706 cistpl_cftable_entry_t *cf;
710 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
712 return CS_OUT_OF_RESOURCE;
714 tuple = &cfg_mem->tuple;
715 parse = &cfg_mem->parse;
716 cf = &parse->cftable_entry;
719 tuple->Attributes = tuple->TupleOffset = 0;
720 tuple->TupleData = (cisdata_t *)buf;
721 tuple->TupleDataMax = 255;
722 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
724 link->io.NumPorts1 = 16;
725 i = first_tuple(link->handle, tuple, parse);
726 while (i != CS_NO_MORE_ITEMS) {
727 if (i == CS_SUCCESS) {
728 link->conf.ConfigIndex = cf->index;
729 link->io.BasePort1 = cf->io.win[0].base;
730 link->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
731 i = pcmcia_request_io(link->handle, &link->io);
732 if (i == CS_SUCCESS) break;
734 i = next_tuple(link->handle, tuple, parse);
737 dev->base_addr = link->io.BasePort1;
743 static int smc_setup(dev_link_t *link)
745 client_handle_t handle = link->handle;
746 struct net_device *dev = link->priv;
747 struct smc_cfg_mem *cfg_mem;
750 cistpl_lan_node_id_t *node_id;
751 u_char *buf, *station_addr;
754 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
756 return CS_OUT_OF_RESOURCE;
758 tuple = &cfg_mem->tuple;
759 parse = &cfg_mem->parse;
762 tuple->Attributes = tuple->TupleOffset = 0;
763 tuple->TupleData = (cisdata_t *)buf;
764 tuple->TupleDataMax = 255;
766 /* Check for a LAN function extension tuple */
767 tuple->DesiredTuple = CISTPL_FUNCE;
768 i = first_tuple(handle, tuple, parse);
769 while (i == CS_SUCCESS) {
770 if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
772 i = next_tuple(handle, tuple, parse);
774 if (i == CS_SUCCESS) {
775 node_id = (cistpl_lan_node_id_t *)parse->funce.data;
776 if (node_id->nb == 6) {
777 for (i = 0; i < 6; i++)
778 dev->dev_addr[i] = node_id->id[i];
783 /* Try the third string in the Version 1 Version/ID tuple. */
784 tuple->DesiredTuple = CISTPL_VERS_1;
785 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
789 station_addr = parse->version_1.str + parse->version_1.ofs[2];
790 if (cvt_ascii_address(dev, station_addr) == 0) {
801 /*====================================================================*/
803 static int osi_config(dev_link_t *link)
805 struct net_device *dev = link->priv;
806 static kio_addr_t com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
809 link->conf.Attributes |= CONF_ENABLE_SPKR;
810 link->conf.Status = CCSR_AUDIO_ENA;
811 link->irq.Attributes =
812 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
813 link->io.NumPorts1 = 64;
814 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
815 link->io.NumPorts2 = 8;
816 link->io.IOAddrLines = 16;
818 /* Enable Hard Decode, LAN, Modem */
819 link->conf.ConfigIndex = 0x23;
821 for (i = j = 0; j < 4; j++) {
822 link->io.BasePort2 = com[j];
823 i = pcmcia_request_io(link->handle, &link->io);
824 if (i == CS_SUCCESS) break;
826 if (i != CS_SUCCESS) {
827 /* Fallback: turn off hard decode */
828 link->conf.ConfigIndex = 0x03;
829 link->io.NumPorts2 = 0;
830 i = pcmcia_request_io(link->handle, &link->io);
832 dev->base_addr = link->io.BasePort1 + 0x10;
836 static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid)
838 client_handle_t handle = link->handle;
839 struct net_device *dev = link->priv;
840 struct smc_cfg_mem *cfg_mem;
845 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
849 tuple = &cfg_mem->tuple;
852 tuple->Attributes = TUPLE_RETURN_COMMON;
853 tuple->TupleData = (cisdata_t *)buf;
854 tuple->TupleDataMax = 255;
855 tuple->TupleOffset = 0;
857 /* Read the station address from tuple 0x90, subtuple 0x04 */
858 tuple->DesiredTuple = 0x90;
859 i = pcmcia_get_first_tuple(handle, tuple);
860 while (i == CS_SUCCESS) {
861 i = pcmcia_get_tuple_data(handle, tuple);
862 if ((i != CS_SUCCESS) || (buf[0] == 0x04))
864 i = pcmcia_get_next_tuple(handle, tuple);
866 if (i != CS_SUCCESS) {
870 for (i = 0; i < 6; i++)
871 dev->dev_addr[i] = buf[i+2];
873 if (((manfid == MANFID_OSITECH) &&
874 (cardid == PRODID_OSITECH_SEVEN)) ||
875 ((manfid == MANFID_PSION) &&
876 (cardid == PRODID_PSION_NET100))) {
877 /* Download the Seven of Diamonds firmware */
878 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
879 outb(__Xilinx7OD[i], link->io.BasePort1+2);
882 } else if (manfid == MANFID_OSITECH) {
883 /* Make sure both functions are powered up */
884 set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
885 /* Now, turn on the interrupt for both card functions */
886 set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
887 DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
888 inw(link->io.BasePort1 + OSITECH_AUI_PWR),
889 inw(link->io.BasePort1 + OSITECH_RESET_ISR));
897 /*======================================================================
899 This verifies that the chip is some SMC91cXX variant, and returns
900 the revision code if successful. Otherwise, it returns -ENODEV.
902 ======================================================================*/
904 static int check_sig(dev_link_t *link)
906 struct net_device *dev = link->priv;
907 kio_addr_t ioaddr = dev->base_addr;
912 if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
913 /* Try powering up the chip */
914 outw(0, ioaddr + CONTROL);
918 /* Try setting bus width */
919 width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
920 s = inb(ioaddr + CONFIG);
925 outb(s, ioaddr + CONFIG);
927 /* Check Base Address Register to make sure bus width is OK */
928 s = inw(ioaddr + BASE_ADDR);
929 if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
930 ((s >> 8) != (s & 0xff))) {
932 s = inw(ioaddr + REVISION);
937 event_callback_args_t args;
938 printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
939 args.client_data = link;
940 smc91c92_event(CS_EVENT_RESET_PHYSICAL, 0, &args);
941 pcmcia_release_io(link->handle, &link->io);
942 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
943 pcmcia_request_io(link->handle, &link->io);
944 smc91c92_event(CS_EVENT_CARD_RESET, 0, &args);
945 return check_sig(link);
950 /*======================================================================
952 smc91c92_config() is scheduled to run after a CARD_INSERTION event
953 is received, to configure the PCMCIA socket, and to make the
954 ethernet device available to the system.
956 ======================================================================*/
958 #define CS_EXIT_TEST(ret, svc, label) \
959 if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
961 static void smc91c92_config(dev_link_t *link)
963 client_handle_t handle = link->handle;
964 struct net_device *dev = link->priv;
965 struct smc_private *smc = netdev_priv(dev);
966 struct smc_cfg_mem *cfg_mem;
975 DEBUG(0, "smc91c92_config(0x%p)\n", link);
977 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
981 tuple = &cfg_mem->tuple;
982 parse = &cfg_mem->parse;
985 tuple->Attributes = tuple->TupleOffset = 0;
986 tuple->TupleData = (cisdata_t *)buf;
987 tuple->TupleDataMax = 64;
989 tuple->DesiredTuple = CISTPL_CONFIG;
990 i = first_tuple(handle, tuple, parse);
991 CS_EXIT_TEST(i, ParseTuple, config_failed);
992 link->conf.ConfigBase = parse->config.base;
993 link->conf.Present = parse->config.rmask[0];
995 tuple->DesiredTuple = CISTPL_MANFID;
996 tuple->Attributes = TUPLE_RETURN_COMMON;
997 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
998 smc->manfid = parse->manfid.manf;
999 smc->cardid = parse->manfid.card;
1002 /* Configure card */
1003 link->state |= DEV_CONFIG;
1005 if ((smc->manfid == MANFID_OSITECH) &&
1006 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1007 i = osi_config(link);
1008 } else if ((smc->manfid == MANFID_MOTOROLA) ||
1009 ((smc->manfid == MANFID_MEGAHERTZ) &&
1010 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
1011 (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
1012 i = mhz_mfc_config(link);
1014 i = smc_config(link);
1016 CS_EXIT_TEST(i, RequestIO, config_failed);
1018 i = pcmcia_request_irq(link->handle, &link->irq);
1019 CS_EXIT_TEST(i, RequestIRQ, config_failed);
1020 i = pcmcia_request_configuration(link->handle, &link->conf);
1021 CS_EXIT_TEST(i, RequestConfiguration, config_failed);
1023 if (smc->manfid == MANFID_MOTOROLA)
1026 dev->irq = link->irq.AssignedIRQ;
1028 if ((if_port >= 0) && (if_port <= 2))
1029 dev->if_port = if_port;
1031 printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
1033 switch (smc->manfid) {
1034 case MANFID_OSITECH:
1036 i = osi_setup(link, smc->manfid, smc->cardid); break;
1038 case MANFID_NEW_MEDIA:
1039 i = smc_setup(link); break;
1040 case 0x128: /* For broken Megahertz cards */
1041 case MANFID_MEGAHERTZ:
1042 i = mhz_setup(link); break;
1043 case MANFID_MOTOROLA:
1044 default: /* get the hw address from EEPROM */
1045 i = mot_setup(link); break;
1049 printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1056 rev = check_sig(link);
1060 case 3: name = "92"; break;
1061 case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1062 case 5: name = "95"; break;
1063 case 7: name = "100"; break;
1064 case 8: name = "100-FD"; break;
1065 case 9: name = "110"; break;
1068 ioaddr = dev->base_addr;
1072 mir = inw(ioaddr + MEMINFO) & 0xff;
1073 if (mir == 0xff) mir++;
1074 /* Get scale factor for memory size */
1075 mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1076 mir *= 128 * (1<<((mcr >> 9) & 7));
1078 smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1079 smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1080 if (smc->manfid == MANFID_OSITECH)
1081 smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1082 if ((rev >> 4) >= 7)
1083 smc->cfg |= CFG_MII_SELECT;
1087 if (smc->cfg & CFG_MII_SELECT) {
1090 for (i = 0; i < 32; i++) {
1091 j = mdio_read(dev, i, 1);
1092 if ((j != 0) && (j != 0xffff)) break;
1094 smc->mii_if.phy_id = (i < 32) ? i : -1;
1099 link->dev = &smc->node;
1100 link->state &= ~DEV_CONFIG_PENDING;
1101 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
1103 if (register_netdev(dev) != 0) {
1104 printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1109 strcpy(smc->node.dev_name, dev->name);
1111 printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1112 "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
1114 for (i = 0; i < 6; i++)
1115 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
1119 printk(KERN_INFO " %lu byte", mir);
1121 printk(KERN_INFO " %lu kb", mir>>10);
1122 printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1123 "MII" : if_names[dev->if_port]);
1126 if (smc->cfg & CFG_MII_SELECT) {
1127 if (smc->mii_if.phy_id != -1) {
1128 DEBUG(0, " MII transceiver at index %d, status %x.\n",
1129 smc->mii_if.phy_id, j);
1131 printk(KERN_NOTICE " No MII transceivers found!\n");
1138 unregister_netdev(dev);
1139 config_failed: /* CS_EXIT_TEST() calls jump to here... */
1140 smc91c92_release(link);
1141 link->state &= ~DEV_CONFIG_PENDING;
1144 } /* smc91c92_config */
1146 /*======================================================================
1148 After a card is removed, smc91c92_release() will unregister the net
1149 device, and release the PCMCIA configuration. If the device is
1150 still open, this will be postponed until it is closed.
1152 ======================================================================*/
1154 static void smc91c92_release(dev_link_t *link)
1157 DEBUG(0, "smc91c92_release(0x%p)\n", link);
1159 pcmcia_release_configuration(link->handle);
1160 pcmcia_release_io(link->handle, &link->io);
1161 pcmcia_release_irq(link->handle, &link->irq);
1163 struct net_device *dev = link->priv;
1164 struct smc_private *smc = netdev_priv(dev);
1166 pcmcia_release_window(link->win);
1169 link->state &= ~DEV_CONFIG;
1172 /*======================================================================
1174 The card status event handler. Mostly, this schedules other
1175 stuff to run after an event is received. A CARD_REMOVAL event
1176 also sets some flags to discourage the net drivers from trying
1177 to talk to the card any more.
1179 ======================================================================*/
1181 static int smc91c92_event(event_t event, int priority,
1182 event_callback_args_t *args)
1184 dev_link_t *link = args->client_data;
1185 struct net_device *dev = link->priv;
1186 struct smc_private *smc = netdev_priv(dev);
1189 DEBUG(1, "smc91c92_event(0x%06x)\n", event);
1192 case CS_EVENT_CARD_REMOVAL:
1193 link->state &= ~DEV_PRESENT;
1194 if (link->state & DEV_CONFIG)
1195 netif_device_detach(dev);
1197 case CS_EVENT_CARD_INSERTION:
1198 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1199 smc91c92_config(link);
1201 case CS_EVENT_PM_SUSPEND:
1202 link->state |= DEV_SUSPEND;
1203 /* Fall through... */
1204 case CS_EVENT_RESET_PHYSICAL:
1205 if (link->state & DEV_CONFIG) {
1207 netif_device_detach(dev);
1208 pcmcia_release_configuration(link->handle);
1211 case CS_EVENT_PM_RESUME:
1212 link->state &= ~DEV_SUSPEND;
1213 /* Fall through... */
1214 case CS_EVENT_CARD_RESET:
1215 if (link->state & DEV_CONFIG) {
1216 if ((smc->manfid == MANFID_MEGAHERTZ) &&
1217 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
1218 mhz_3288_power(link);
1219 pcmcia_request_configuration(link->handle, &link->conf);
1220 if (smc->manfid == MANFID_MOTOROLA)
1222 if ((smc->manfid == MANFID_OSITECH) &&
1223 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1224 /* Power up the card and enable interrupts */
1225 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
1226 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
1228 if (((smc->manfid == MANFID_OSITECH) &&
1229 (smc->cardid == PRODID_OSITECH_SEVEN)) ||
1230 ((smc->manfid == MANFID_PSION) &&
1231 (smc->cardid == PRODID_PSION_NET100))) {
1232 /* Download the Seven of Diamonds firmware */
1233 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
1234 outb(__Xilinx7OD[i], link->io.BasePort1+2);
1240 netif_device_attach(dev);
1246 } /* smc91c92_event */
1248 /*======================================================================
1250 MII interface support for SMC91cXX based cards
1251 ======================================================================*/
1253 #define MDIO_SHIFT_CLK 0x04
1254 #define MDIO_DATA_OUT 0x01
1255 #define MDIO_DIR_WRITE 0x08
1256 #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
1257 #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1258 #define MDIO_DATA_READ 0x02
1260 static void mdio_sync(kio_addr_t addr)
1263 for (bits = 0; bits < 32; bits++) {
1264 outb(MDIO_DATA_WRITE1, addr);
1265 outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1269 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1271 kio_addr_t addr = dev->base_addr + MGMT;
1272 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1276 for (i = 13; i >= 0; i--) {
1277 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1279 outb(dat | MDIO_SHIFT_CLK, addr);
1281 for (i = 19; i > 0; i--) {
1283 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1284 outb(MDIO_SHIFT_CLK, addr);
1286 return (retval>>1) & 0xffff;
1289 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1291 kio_addr_t addr = dev->base_addr + MGMT;
1292 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1296 for (i = 31; i >= 0; i--) {
1297 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1299 outb(dat | MDIO_SHIFT_CLK, addr);
1301 for (i = 1; i >= 0; i--) {
1303 outb(MDIO_SHIFT_CLK, addr);
1307 /*======================================================================
1309 The driver core code, most of which should be common with a
1310 non-PCMCIA implementation.
1312 ======================================================================*/
1315 static void smc_dump(struct net_device *dev)
1317 kio_addr_t ioaddr = dev->base_addr;
1319 save = inw(ioaddr + BANK_SELECT);
1320 for (w = 0; w < 4; w++) {
1322 printk(KERN_DEBUG "bank %d: ", w);
1323 for (i = 0; i < 14; i += 2)
1324 printk(" %04x", inw(ioaddr + i));
1327 outw(save, ioaddr + BANK_SELECT);
1331 static int smc_open(struct net_device *dev)
1333 struct smc_private *smc = netdev_priv(dev);
1334 dev_link_t *link = &smc->link;
1337 DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1338 dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1339 if (pc_debug > 1) smc_dump(dev);
1342 /* Check that the PCMCIA card is still here. */
1345 /* Physical device present signature. */
1346 if (check_sig(link) < 0) {
1347 printk("smc91c92_cs: Yikes! Bad chip signature!\n");
1352 netif_start_queue(dev);
1353 smc->saved_skb = NULL;
1354 smc->packets_waiting = 0;
1357 init_timer(&smc->media);
1358 smc->media.function = &media_check;
1359 smc->media.data = (u_long) dev;
1360 smc->media.expires = jiffies + HZ;
1361 add_timer(&smc->media);
1366 /*====================================================================*/
1368 static int smc_close(struct net_device *dev)
1370 struct smc_private *smc = netdev_priv(dev);
1371 dev_link_t *link = &smc->link;
1372 kio_addr_t ioaddr = dev->base_addr;
1374 DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1375 dev->name, inw(ioaddr + BANK_SELECT));
1377 netif_stop_queue(dev);
1379 /* Shut off all interrupts, and turn off the Tx and Rx sections.
1380 Don't bother to check for chip present. */
1381 SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1382 outw(0, ioaddr + INTERRUPT);
1384 mask_bits(0xff00, ioaddr + RCR);
1385 mask_bits(0xff00, ioaddr + TCR);
1387 /* Put the chip into power-down mode. */
1389 outw(CTL_POWERDOWN, ioaddr + CONTROL );
1392 del_timer_sync(&smc->media);
1397 /*======================================================================
1399 Transfer a packet to the hardware and trigger the packet send.
1400 This may be called at either from either the Tx queue code
1401 or the interrupt handler.
1403 ======================================================================*/
1405 static void smc_hardware_send_packet(struct net_device * dev)
1407 struct smc_private *smc = netdev_priv(dev);
1408 struct sk_buff *skb = smc->saved_skb;
1409 kio_addr_t ioaddr = dev->base_addr;
1413 printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1417 /* There should be a packet slot waiting. */
1418 packet_no = inw(ioaddr + PNR_ARR) >> 8;
1419 if (packet_no & 0x80) {
1420 /* If not, there is a hardware problem! Likely an ejected card. */
1421 printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1422 " failed, status %#2.2x.\n", dev->name, packet_no);
1423 dev_kfree_skb_irq(skb);
1424 smc->saved_skb = NULL;
1425 netif_start_queue(dev);
1429 smc->stats.tx_bytes += skb->len;
1430 /* The card should use the just-allocated buffer. */
1431 outw(packet_no, ioaddr + PNR_ARR);
1432 /* point to the beginning of the packet */
1433 outw(PTR_AUTOINC , ioaddr + POINTER);
1435 /* Send the packet length (+6 for status, length and ctl byte)
1436 and the status word (set to zeros). */
1438 u_char *buf = skb->data;
1439 u_int length = skb->len; /* The chip will pad to ethernet min. */
1441 DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1444 /* send the packet length: +6 for status word, length, and ctl */
1445 outw(0, ioaddr + DATA_1);
1446 outw(length + 6, ioaddr + DATA_1);
1447 outsw(ioaddr + DATA_1, buf, length >> 1);
1449 /* The odd last byte, if there is one, goes in the control word. */
1450 outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1453 /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1454 outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1455 (inw(ioaddr + INTERRUPT) & 0xff00),
1456 ioaddr + INTERRUPT);
1458 /* The chip does the rest of the work. */
1459 outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1461 smc->saved_skb = NULL;
1462 dev_kfree_skb_irq(skb);
1463 dev->trans_start = jiffies;
1464 netif_start_queue(dev);
1468 /*====================================================================*/
1470 static void smc_tx_timeout(struct net_device *dev)
1472 struct smc_private *smc = netdev_priv(dev);
1473 kio_addr_t ioaddr = dev->base_addr;
1475 printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1476 "Tx_status %2.2x status %4.4x.\n",
1477 dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1478 smc->stats.tx_errors++;
1480 dev->trans_start = jiffies;
1481 smc->saved_skb = NULL;
1482 netif_wake_queue(dev);
1485 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1487 struct smc_private *smc = netdev_priv(dev);
1488 kio_addr_t ioaddr = dev->base_addr;
1492 netif_stop_queue(dev);
1494 DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1495 " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1497 if (smc->saved_skb) {
1498 /* THIS SHOULD NEVER HAPPEN. */
1499 smc->stats.tx_aborted_errors++;
1500 printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1504 smc->saved_skb = skb;
1506 num_pages = skb->len >> 8;
1508 if (num_pages > 7) {
1509 printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1510 dev_kfree_skb (skb);
1511 smc->saved_skb = NULL;
1512 smc->stats.tx_dropped++;
1513 return 0; /* Do not re-queue this packet. */
1515 /* A packet is now waiting. */
1516 smc->packets_waiting++;
1518 SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1520 /* need MC_RESET to keep the memory consistent. errata? */
1522 outw(MC_RESET, ioaddr + MMU_CMD);
1526 /* Allocate the memory; send the packet now if we win. */
1527 outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1528 for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1529 ir = inw(ioaddr+INTERRUPT);
1530 if (ir & IM_ALLOC_INT) {
1531 /* Acknowledge the interrupt, send the packet. */
1532 outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1533 smc_hardware_send_packet(dev); /* Send the packet now.. */
1538 /* Otherwise defer until the Tx-space-allocated interrupt. */
1539 DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1540 outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1545 /*======================================================================
1547 Handle a Tx anomolous event. Entered while in Window 2.
1549 ======================================================================*/
1551 static void smc_tx_err(struct net_device * dev)
1553 struct smc_private *smc = netdev_priv(dev);
1554 kio_addr_t ioaddr = dev->base_addr;
1555 int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1556 int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1559 /* select this as the packet to read from */
1560 outw(packet_no, ioaddr + PNR_ARR);
1562 /* read the first word from this packet */
1563 outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1565 tx_status = inw(ioaddr + DATA_1);
1567 smc->stats.tx_errors++;
1568 if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1569 if (tx_status & TS_LATCOL) smc->stats.tx_window_errors++;
1570 if (tx_status & TS_16COL) {
1571 smc->stats.tx_aborted_errors++;
1575 if (tx_status & TS_SUCCESS) {
1576 printk(KERN_NOTICE "%s: Successful packet caused error "
1577 "interrupt?\n", dev->name);
1579 /* re-enable transmit */
1581 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1584 outw(MC_FREEPKT, ioaddr + MMU_CMD); /* Free the packet memory. */
1586 /* one less packet waiting for me */
1587 smc->packets_waiting--;
1589 outw(saved_packet, ioaddr + PNR_ARR);
1593 /*====================================================================*/
1595 static void smc_eph_irq(struct net_device *dev)
1597 struct smc_private *smc = netdev_priv(dev);
1598 kio_addr_t ioaddr = dev->base_addr;
1599 u_short card_stats, ephs;
1602 ephs = inw(ioaddr + EPH);
1603 DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1604 " %4.4x.\n", dev->name, ephs);
1605 /* Could be a counter roll-over warning: update stats. */
1606 card_stats = inw(ioaddr + COUNTER);
1607 /* single collisions */
1608 smc->stats.collisions += card_stats & 0xF;
1610 /* multiple collisions */
1611 smc->stats.collisions += card_stats & 0xF;
1612 #if 0 /* These are for when linux supports these statistics */
1613 card_stats >>= 4; /* deferred */
1614 card_stats >>= 4; /* excess deferred */
1616 /* If we had a transmit error we must re-enable the transmitter. */
1617 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1619 /* Clear a link error interrupt. */
1621 outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1622 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1627 /*====================================================================*/
1629 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1631 struct net_device *dev = dev_id;
1632 struct smc_private *smc = netdev_priv(dev);
1634 u_short saved_bank, saved_pointer, mask, status;
1635 unsigned int handled = 1;
1636 char bogus_cnt = INTR_WORK; /* Work we are willing to do. */
1638 if (!netif_device_present(dev))
1641 ioaddr = dev->base_addr;
1643 DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1647 saved_bank = inw(ioaddr + BANK_SELECT);
1648 if ((saved_bank & 0xff00) != 0x3300) {
1649 /* The device does not exist -- the card could be off-line, or
1650 maybe it has been ejected. */
1651 DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1652 "/ejected device.\n", dev->name, irq);
1658 saved_pointer = inw(ioaddr + POINTER);
1659 mask = inw(ioaddr + INTERRUPT) >> 8;
1660 /* clear all interrupts */
1661 outw(0, ioaddr + INTERRUPT);
1663 do { /* read the status flag, and mask it */
1664 status = inw(ioaddr + INTERRUPT) & 0xff;
1665 DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1667 if ((status & mask) == 0) {
1668 if (bogus_cnt == INTR_WORK)
1672 if (status & IM_RCV_INT) {
1673 /* Got a packet(s). */
1676 if (status & IM_TX_INT) {
1678 outw(IM_TX_INT, ioaddr + INTERRUPT);
1681 if (status & IM_TX_EMPTY_INT) {
1682 outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1683 mask &= ~IM_TX_EMPTY_INT;
1684 smc->stats.tx_packets += smc->packets_waiting;
1685 smc->packets_waiting = 0;
1687 if (status & IM_ALLOC_INT) {
1688 /* Clear this interrupt so it doesn't happen again */
1689 mask &= ~IM_ALLOC_INT;
1691 smc_hardware_send_packet(dev);
1693 /* enable xmit interrupts based on this */
1694 mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1696 /* and let the card send more packets to me */
1697 netif_wake_queue(dev);
1699 if (status & IM_RX_OVRN_INT) {
1700 smc->stats.rx_errors++;
1701 smc->stats.rx_fifo_errors++;
1703 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1704 outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1706 if (status & IM_EPH_INT)
1708 } while (--bogus_cnt);
1710 DEBUG(3, " Restoring saved registers mask %2.2x bank %4.4x"
1711 " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1713 /* restore state register */
1714 outw((mask<<8), ioaddr + INTERRUPT);
1715 outw(saved_pointer, ioaddr + POINTER);
1716 SMC_SELECT_BANK(saved_bank);
1718 DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1722 if ((smc->manfid == MANFID_OSITECH) &&
1723 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1724 /* Retrigger interrupt if needed */
1725 mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1726 set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1728 if (smc->manfid == MANFID_MOTOROLA) {
1730 cor = readb(smc->base + MOT_UART + CISREG_COR);
1731 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1732 writeb(cor, smc->base + MOT_UART + CISREG_COR);
1733 cor = readb(smc->base + MOT_LAN + CISREG_COR);
1734 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1735 writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1737 #ifdef DOES_NOT_WORK
1738 if (smc->base != NULL) { /* Megahertz MFC's */
1739 readb(smc->base+MEGAHERTZ_ISR);
1740 readb(smc->base+MEGAHERTZ_ISR);
1743 return IRQ_RETVAL(handled);
1746 /*====================================================================*/
1748 static void smc_rx(struct net_device *dev)
1750 struct smc_private *smc = netdev_priv(dev);
1751 kio_addr_t ioaddr = dev->base_addr;
1753 int packet_length; /* Caution: not frame length, rather words
1754 to transfer from the chip. */
1756 /* Assertion: we are in Window 2. */
1758 if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1759 printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1764 /* Reset the read pointer, and read the status and packet length. */
1765 outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1766 rx_status = inw(ioaddr + DATA_1);
1767 packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1769 DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1770 dev->name, rx_status, packet_length);
1772 if (!(rx_status & RS_ERRORS)) {
1773 /* do stuff to make a new packet */
1774 struct sk_buff *skb;
1776 /* Note: packet_length adds 5 or 6 extra bytes here! */
1777 skb = dev_alloc_skb(packet_length+2);
1780 DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1781 smc->stats.rx_dropped++;
1782 outw(MC_RELEASE, ioaddr + MMU_CMD);
1786 packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1787 skb_reserve(skb, 2);
1788 insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1789 (packet_length+1)>>1);
1790 skb->protocol = eth_type_trans(skb, dev);
1794 dev->last_rx = jiffies;
1795 smc->stats.rx_packets++;
1796 smc->stats.rx_bytes += packet_length;
1797 if (rx_status & RS_MULTICAST)
1798 smc->stats.multicast++;
1801 smc->stats.rx_errors++;
1803 if (rx_status & RS_ALGNERR) smc->stats.rx_frame_errors++;
1804 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1805 smc->stats.rx_length_errors++;
1806 if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
1808 /* Let the MMU free the memory of this packet. */
1809 outw(MC_RELEASE, ioaddr + MMU_CMD);
1814 /*====================================================================*/
1816 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1818 struct smc_private *smc = netdev_priv(dev);
1819 /* Nothing to update - the 91c92 is a pretty primative chip. */
1823 /*======================================================================
1825 Calculate values for the hardware multicast filter hash table.
1827 ======================================================================*/
1829 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1830 u_char *multicast_table)
1832 struct dev_mc_list *mc_addr;
1834 for (mc_addr = addrs; mc_addr && --count > 0; mc_addr = mc_addr->next) {
1835 u_int position = ether_crc(6, mc_addr->dmi_addr);
1836 #ifndef final_version /* Verify multicast address. */
1837 if ((mc_addr->dmi_addr[0] & 1) == 0)
1840 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1844 /*======================================================================
1846 Set the receive mode.
1848 This routine is used by both the protocol level to notify us of
1849 promiscuous/multicast mode changes, and by the open/reset code to
1850 initialize the Rx registers. We always set the multicast list and
1851 leave the receiver running.
1853 ======================================================================*/
1855 static void set_rx_mode(struct net_device *dev)
1857 kio_addr_t ioaddr = dev->base_addr;
1858 struct smc_private *smc = netdev_priv(dev);
1859 u_int multicast_table[ 2 ] = { 0, };
1860 unsigned long flags;
1861 u_short rx_cfg_setting;
1863 if (dev->flags & IFF_PROMISC) {
1864 printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.\n", dev->name);
1865 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1866 } else if (dev->flags & IFF_ALLMULTI)
1867 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1869 if (dev->mc_count) {
1870 fill_multicast_tbl(dev->mc_count, dev->mc_list,
1871 (u_char *)multicast_table);
1873 rx_cfg_setting = RxStripCRC | RxEnable;
1876 /* Load MC table and Rx setting into the chip without interrupts. */
1877 spin_lock_irqsave(&smc->lock, flags);
1879 outl(multicast_table[0], ioaddr + MULTICAST0);
1880 outl(multicast_table[1], ioaddr + MULTICAST4);
1882 outw(rx_cfg_setting, ioaddr + RCR);
1884 spin_unlock_irqrestore(&smc->lock, flags);
1889 /*======================================================================
1891 Senses when a card's config changes. Here, it's coax or TP.
1893 ======================================================================*/
1895 static int s9k_config(struct net_device *dev, struct ifmap *map)
1897 struct smc_private *smc = netdev_priv(dev);
1898 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1899 if (smc->cfg & CFG_MII_SELECT)
1901 else if (map->port > 2)
1903 dev->if_port = map->port;
1904 printk(KERN_INFO "%s: switched to %s port\n",
1905 dev->name, if_names[dev->if_port]);
1911 /*======================================================================
1913 Reset the chip, reloading every register that might be corrupted.
1915 ======================================================================*/
1918 Set transceiver type, perhaps to something other than what the user
1919 specified in dev->if_port.
1921 static void smc_set_xcvr(struct net_device *dev, int if_port)
1923 struct smc_private *smc = netdev_priv(dev);
1924 kio_addr_t ioaddr = dev->base_addr;
1927 saved_bank = inw(ioaddr + BANK_SELECT);
1930 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1931 if ((smc->manfid == MANFID_OSITECH) &&
1932 (smc->cardid != PRODID_OSITECH_SEVEN))
1933 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1934 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1936 outw(smc->cfg, ioaddr + CONFIG);
1937 if ((smc->manfid == MANFID_OSITECH) &&
1938 (smc->cardid != PRODID_OSITECH_SEVEN))
1939 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1940 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1942 SMC_SELECT_BANK(saved_bank);
1945 static void smc_reset(struct net_device *dev)
1947 kio_addr_t ioaddr = dev->base_addr;
1948 struct smc_private *smc = netdev_priv(dev);
1951 DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1953 /* The first interaction must be a write to bring the chip out
1956 /* Reset the chip. */
1957 outw(RCR_SOFTRESET, ioaddr + RCR);
1960 /* Clear the transmit and receive configuration registers. */
1961 outw(RCR_CLEAR, ioaddr + RCR);
1962 outw(TCR_CLEAR, ioaddr + TCR);
1964 /* Set the Window 1 control, configuration and station addr registers.
1965 No point in writing the I/O base register ;-> */
1967 /* Automatically release succesfully transmitted packets,
1968 Accept link errors, counter and Tx error interrupts. */
1969 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1971 smc_set_xcvr(dev, dev->if_port);
1972 if ((smc->manfid == MANFID_OSITECH) &&
1973 (smc->cardid != PRODID_OSITECH_SEVEN))
1974 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1975 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1976 ioaddr - 0x10 + OSITECH_AUI_PWR);
1978 /* Fill in the physical address. The databook is wrong about the order! */
1979 for (i = 0; i < 6; i += 2)
1980 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1981 ioaddr + ADDR0 + i);
1985 outw(MC_RESET, ioaddr + MMU_CMD);
1986 outw(0, ioaddr + INTERRUPT);
1988 /* Re-enable the chip. */
1990 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1991 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1994 if (smc->cfg & CFG_MII_SELECT) {
1998 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
2000 /* Advertise 100F, 100H, 10F, 10H */
2001 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
2003 /* Restart MII autonegotiation */
2004 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
2005 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
2008 /* Enable interrupts. */
2010 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
2011 ioaddr + INTERRUPT);
2014 /*======================================================================
2016 Media selection timer routine
2018 ======================================================================*/
2020 static void media_check(u_long arg)
2022 struct net_device *dev = (struct net_device *) arg;
2023 struct smc_private *smc = netdev_priv(dev);
2024 kio_addr_t ioaddr = dev->base_addr;
2025 u_short i, media, saved_bank;
2028 saved_bank = inw(ioaddr + BANK_SELECT);
2030 if (!netif_device_present(dev))
2035 /* need MC_RESET to keep the memory consistent. errata? */
2037 outw(MC_RESET, ioaddr + MMU_CMD);
2040 i = inw(ioaddr + INTERRUPT);
2042 media = inw(ioaddr + EPH) & EPH_LINK_OK;
2044 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
2046 /* Check for pending interrupt with watchdog flag set: with
2047 this, we can limp along even if the interrupt is blocked */
2048 if (smc->watchdog++ && ((i>>8) & i)) {
2049 if (!smc->fast_poll)
2050 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
2051 smc_interrupt(dev->irq, smc, NULL);
2052 smc->fast_poll = HZ;
2054 if (smc->fast_poll) {
2056 smc->media.expires = jiffies + HZ/100;
2057 add_timer(&smc->media);
2058 SMC_SELECT_BANK(saved_bank);
2062 if (smc->cfg & CFG_MII_SELECT) {
2063 if (smc->mii_if.phy_id < 0)
2067 link = mdio_read(dev, smc->mii_if.phy_id, 1);
2068 if (!link || (link == 0xffff)) {
2069 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
2070 smc->mii_if.phy_id = -1;
2075 if (link != smc->link_status) {
2076 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
2077 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2078 (link) ? "found" : "lost");
2079 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
2082 printk(KERN_INFO "%s: autonegotiation complete: "
2083 "%sbaseT-%cD selected\n", dev->name,
2084 ((p & 0x0180) ? "100" : "10"),
2085 (smc->duplex ? 'F' : 'H'));
2088 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
2089 smc->link_status = link;
2094 /* Ignore collisions unless we've had no rx's recently */
2095 if (jiffies - dev->last_rx > HZ) {
2096 if (smc->tx_err || (smc->media_status & EPH_16COL))
2101 if (media != smc->media_status) {
2102 if ((media & smc->media_status & 1) &&
2103 ((smc->media_status ^ media) & EPH_LINK_OK))
2104 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2105 (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
2106 else if ((media & smc->media_status & 2) &&
2107 ((smc->media_status ^ media) & EPH_16COL))
2108 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
2109 (media & EPH_16COL ? "problem" : "ok"));
2110 if (dev->if_port == 0) {
2112 if (media & EPH_LINK_OK)
2113 printk(KERN_INFO "%s: flipped to 10baseT\n",
2116 smc_set_xcvr(dev, 2);
2118 if (media & EPH_16COL)
2119 smc_set_xcvr(dev, 1);
2121 printk(KERN_INFO "%s: flipped to 10base2\n",
2125 smc->media_status = media;
2129 smc->media.expires = jiffies + HZ;
2130 add_timer(&smc->media);
2131 SMC_SELECT_BANK(saved_bank);
2134 static int smc_link_ok(struct net_device *dev)
2136 kio_addr_t ioaddr = dev->base_addr;
2137 struct smc_private *smc = netdev_priv(dev);
2139 if (smc->cfg & CFG_MII_SELECT) {
2140 return mii_link_ok(&smc->mii_if);
2143 return inw(ioaddr + EPH) & EPH_LINK_OK;
2147 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2150 kio_addr_t ioaddr = dev->base_addr;
2152 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2153 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2156 tmp = inw(ioaddr + CONFIG);
2157 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2158 ecmd->transceiver = XCVR_INTERNAL;
2159 ecmd->speed = SPEED_10;
2160 ecmd->phy_address = ioaddr + MGMT;
2163 tmp = inw(ioaddr + TCR);
2164 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2169 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2172 kio_addr_t ioaddr = dev->base_addr;
2174 if (ecmd->speed != SPEED_10)
2176 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2178 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2180 if (ecmd->transceiver != XCVR_INTERNAL)
2183 if (ecmd->port == PORT_AUI)
2184 smc_set_xcvr(dev, 1);
2186 smc_set_xcvr(dev, 0);
2189 tmp = inw(ioaddr + TCR);
2190 if (ecmd->duplex == DUPLEX_FULL)
2194 outw(tmp, ioaddr + TCR);
2199 static int check_if_running(struct net_device *dev)
2201 if (!netif_running(dev))
2206 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2208 strcpy(info->driver, DRV_NAME);
2209 strcpy(info->version, DRV_VERSION);
2212 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2214 struct smc_private *smc = netdev_priv(dev);
2215 kio_addr_t ioaddr = dev->base_addr;
2216 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2220 spin_lock_irq(&smc->lock);
2221 if (smc->cfg & CFG_MII_SELECT)
2222 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2224 ret = smc_netdev_get_ecmd(dev, ecmd);
2225 spin_unlock_irq(&smc->lock);
2226 SMC_SELECT_BANK(saved_bank);
2230 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2232 struct smc_private *smc = netdev_priv(dev);
2233 kio_addr_t ioaddr = dev->base_addr;
2234 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2238 spin_lock_irq(&smc->lock);
2239 if (smc->cfg & CFG_MII_SELECT)
2240 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2242 ret = smc_netdev_set_ecmd(dev, ecmd);
2243 spin_unlock_irq(&smc->lock);
2244 SMC_SELECT_BANK(saved_bank);
2248 static u32 smc_get_link(struct net_device *dev)
2250 struct smc_private *smc = netdev_priv(dev);
2251 kio_addr_t ioaddr = dev->base_addr;
2252 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2256 spin_lock_irq(&smc->lock);
2257 ret = smc_link_ok(dev);
2258 spin_unlock_irq(&smc->lock);
2259 SMC_SELECT_BANK(saved_bank);
2264 static u32 smc_get_msglevel(struct net_device *dev)
2269 static void smc_set_msglevel(struct net_device *dev, u32 val)
2275 static int smc_nway_reset(struct net_device *dev)
2277 struct smc_private *smc = netdev_priv(dev);
2278 if (smc->cfg & CFG_MII_SELECT) {
2279 kio_addr_t ioaddr = dev->base_addr;
2280 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2284 res = mii_nway_restart(&smc->mii_if);
2285 SMC_SELECT_BANK(saved_bank);
2292 static struct ethtool_ops ethtool_ops = {
2293 .begin = check_if_running,
2294 .get_drvinfo = smc_get_drvinfo,
2295 .get_settings = smc_get_settings,
2296 .set_settings = smc_set_settings,
2297 .get_link = smc_get_link,
2299 .get_msglevel = smc_get_msglevel,
2300 .set_msglevel = smc_set_msglevel,
2302 .nway_reset = smc_nway_reset,
2305 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2307 struct smc_private *smc = netdev_priv(dev);
2308 struct mii_ioctl_data *mii = if_mii(rq);
2311 kio_addr_t ioaddr = dev->base_addr;
2313 if (!netif_running(dev))
2316 spin_lock_irq(&smc->lock);
2317 saved_bank = inw(ioaddr + BANK_SELECT);
2319 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2320 SMC_SELECT_BANK(saved_bank);
2321 spin_unlock_irq(&smc->lock);
2325 static struct pcmcia_device_id smc91c92_ids[] = {
2326 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2327 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2328 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2329 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2330 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2331 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2332 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2333 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2334 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
2335 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
2336 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2337 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2338 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2339 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2340 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2341 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2342 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2343 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2344 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2345 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
2346 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
2347 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2348 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2349 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2350 /* These conflict with other cards! */
2351 /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2352 /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2355 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2357 static struct pcmcia_driver smc91c92_cs_driver = {
2358 .owner = THIS_MODULE,
2360 .name = "smc91c92_cs",
2362 .attach = smc91c92_attach,
2363 .event = smc91c92_event,
2364 .detach = smc91c92_detach,
2365 .id_table = smc91c92_ids,
2368 static int __init init_smc91c92_cs(void)
2370 return pcmcia_register_driver(&smc91c92_cs_driver);
2373 static void __exit exit_smc91c92_cs(void)
2375 pcmcia_unregister_driver(&smc91c92_cs_driver);
2376 BUG_ON(dev_list != NULL);
2379 module_init(init_smc91c92_cs);
2380 module_exit(exit_smc91c92_cs);