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>
54 #include <asm/system.h>
55 #include <asm/uaccess.h>
57 /* Ositech Seven of Diamonds firmware */
60 /*====================================================================*/
62 static char *if_names[] = { "auto", "10baseT", "10base2"};
64 /* Module parameters */
66 MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
67 MODULE_LICENSE("GPL");
69 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
72 Transceiver/media type.
74 1 = 10baseT (and autoselect if #define AUTOSELECT),
77 INT_MODULE_PARM(if_port, 0);
80 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
81 static const char *version =
82 "smc91c92_cs.c 0.09 1996/8/4 Donald Becker, becker@scyld.com.\n";
83 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
85 #define DEBUG(n, args...)
88 #define DRV_NAME "smc91c92_cs"
89 #define DRV_VERSION "1.122"
91 /*====================================================================*/
93 /* Operational parameter that usually are not changed. */
95 /* Time in jiffies before concluding Tx hung */
96 #define TX_TIMEOUT ((400*HZ)/1000)
98 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
101 /* Times to check the check the chip before concluding that it doesn't
102 currently have room for another Tx packet. */
103 #define MEMORY_WAIT_TIME 8
105 static dev_info_t dev_info = "smc91c92_cs";
112 struct net_device_stats stats;
114 struct sk_buff *saved_skb;
118 struct timer_list media;
119 int watchdog, tx_err;
120 u_short media_status;
123 struct mii_if_info mii_if;
134 /* Special definitions for Megahertz multifunction cards */
135 #define MEGAHERTZ_ISR 0x0380
137 /* Special function registers for Motorola Mariner */
138 #define MOT_LAN 0x0000
139 #define MOT_UART 0x0020
140 #define MOT_EEPROM 0x20
143 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
145 /* Special function registers for Ositech cards */
146 #define OSITECH_AUI_CTL 0x0c
147 #define OSITECH_PWRDOWN 0x0d
148 #define OSITECH_RESET 0x0e
149 #define OSITECH_ISR 0x0f
150 #define OSITECH_AUI_PWR 0x0c
151 #define OSITECH_RESET_ISR 0x0e
153 #define OSI_AUI_PWR 0x40
154 #define OSI_LAN_PWRDOWN 0x02
155 #define OSI_MODEM_PWRDOWN 0x01
156 #define OSI_LAN_RESET 0x02
157 #define OSI_MODEM_RESET 0x01
159 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
160 #define BANK_SELECT 14 /* Window select register. */
161 #define SMC_SELECT_BANK(x) { outw(x, ioaddr + BANK_SELECT); }
163 /* Bank 0 registers. */
164 #define TCR 0 /* transmit control register */
165 #define TCR_CLEAR 0 /* do NOTHING */
166 #define TCR_ENABLE 0x0001 /* if this is 1, we can transmit */
167 #define TCR_PAD_EN 0x0080 /* pads short packets to 64 bytes */
168 #define TCR_MONCSN 0x0400 /* Monitor Carrier. */
169 #define TCR_FDUPLX 0x0800 /* Full duplex mode. */
170 #define TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
172 #define EPH 2 /* Ethernet Protocol Handler report. */
173 #define EPH_TX_SUC 0x0001
174 #define EPH_SNGLCOL 0x0002
175 #define EPH_MULCOL 0x0004
176 #define EPH_LTX_MULT 0x0008
177 #define EPH_16COL 0x0010
178 #define EPH_SQET 0x0020
179 #define EPH_LTX_BRD 0x0040
180 #define EPH_TX_DEFR 0x0080
181 #define EPH_LAT_COL 0x0200
182 #define EPH_LOST_CAR 0x0400
183 #define EPH_EXC_DEF 0x0800
184 #define EPH_CTR_ROL 0x1000
185 #define EPH_RX_OVRN 0x2000
186 #define EPH_LINK_OK 0x4000
187 #define EPH_TX_UNRN 0x8000
188 #define MEMINFO 8 /* Memory Information Register */
189 #define MEMCFG 10 /* Memory Configuration Register */
191 /* Bank 1 registers. */
193 #define CFG_MII_SELECT 0x8000 /* 91C100 only */
194 #define CFG_NO_WAIT 0x1000
195 #define CFG_FULL_STEP 0x0400
196 #define CFG_SET_SQLCH 0x0200
197 #define CFG_AUI_SELECT 0x0100
198 #define CFG_16BIT 0x0080
199 #define CFG_DIS_LINK 0x0040
200 #define CFG_STATIC 0x0030
201 #define CFG_IRQ_SEL_1 0x0004
202 #define CFG_IRQ_SEL_0 0x0002
207 #define CTL_STORE 0x0001
208 #define CTL_RELOAD 0x0002
209 #define CTL_EE_SELECT 0x0004
210 #define CTL_TE_ENABLE 0x0020
211 #define CTL_CR_ENABLE 0x0040
212 #define CTL_LE_ENABLE 0x0080
213 #define CTL_AUTO_RELEASE 0x0800
214 #define CTL_POWERDOWN 0x2000
216 /* Bank 2 registers. */
218 #define MC_ALLOC 0x20 /* or with number of 256 byte packets */
219 #define MC_RESET 0x40
220 #define MC_RELEASE 0x80 /* remove and release the current rx packet */
221 #define MC_FREEPKT 0xA0 /* Release packet in PNR register */
222 #define MC_ENQUEUE 0xC0 /* Enqueue the packet for transmit */
225 #define FP_RXEMPTY 0x8000
227 #define PTR_AUTO_INC 0x0040
228 #define PTR_READ 0x2000
229 #define PTR_AUTOINC 0x4000
230 #define PTR_RCV 0x8000
233 #define IM_RCV_INT 0x1
234 #define IM_TX_INT 0x2
235 #define IM_TX_EMPTY_INT 0x4
236 #define IM_ALLOC_INT 0x8
237 #define IM_RX_OVRN_INT 0x10
238 #define IM_EPH_INT 0x20
241 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
242 RxEnable = 0x0100, RxStripCRC = 0x0200};
243 #define RCR_SOFTRESET 0x8000 /* resets the chip */
244 #define RCR_STRIP_CRC 0x200 /* strips CRC */
245 #define RCR_ENABLE 0x100 /* IFF this is set, we can receive packets */
246 #define RCR_ALMUL 0x4 /* receive all multicast packets */
247 #define RCR_PROMISC 0x2 /* enable promiscuous mode */
249 /* the normal settings for the RCR register : */
250 #define RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
251 #define RCR_CLEAR 0x0 /* set it to a base state */
254 /* BANK 3 -- not the same values as in smc9194! */
260 #define REVISION 0x0a
262 /* Transmit status bits. */
263 #define TS_SUCCESS 0x0001
264 #define TS_16COL 0x0010
265 #define TS_LATCOL 0x0200
266 #define TS_LOSTCAR 0x0400
268 /* Receive status bits. */
269 #define RS_ALGNERR 0x8000
270 #define RS_BADCRC 0x2000
271 #define RS_ODDFRAME 0x1000
272 #define RS_TOOLONG 0x0800
273 #define RS_TOOSHORT 0x0400
274 #define RS_MULTICAST 0x0001
275 #define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
277 #define set_bits(v, p) outw(inw(p)|(v), (p))
278 #define mask_bits(v, p) outw(inw(p)&(v), (p))
280 /*====================================================================*/
282 static dev_link_t *smc91c92_attach(void);
283 static void smc91c92_detach(struct pcmcia_device *p_dev);
284 static void smc91c92_config(dev_link_t *link);
285 static void smc91c92_release(dev_link_t *link);
286 static int smc91c92_event(event_t event, int priority,
287 event_callback_args_t *args);
289 static int smc_open(struct net_device *dev);
290 static int smc_close(struct net_device *dev);
291 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
292 static void smc_tx_timeout(struct net_device *dev);
293 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
294 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
295 static void smc_rx(struct net_device *dev);
296 static struct net_device_stats *smc_get_stats(struct net_device *dev);
297 static void set_rx_mode(struct net_device *dev);
298 static int s9k_config(struct net_device *dev, struct ifmap *map);
299 static void smc_set_xcvr(struct net_device *dev, int if_port);
300 static void smc_reset(struct net_device *dev);
301 static void media_check(u_long arg);
302 static void mdio_sync(kio_addr_t addr);
303 static int mdio_read(struct net_device *dev, int phy_id, int loc);
304 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
305 static int smc_link_ok(struct net_device *dev);
306 static struct ethtool_ops ethtool_ops;
308 /*======================================================================
310 smc91c92_attach() creates an "instance" of the driver, allocating
311 local data structures for one device. The device is registered
314 ======================================================================*/
316 static dev_link_t *smc91c92_attach(void)
318 client_reg_t client_reg;
319 struct smc_private *smc;
321 struct net_device *dev;
324 DEBUG(0, "smc91c92_attach()\n");
326 /* Create new ethernet device */
327 dev = alloc_etherdev(sizeof(struct smc_private));
330 smc = netdev_priv(dev);
334 spin_lock_init(&smc->lock);
335 link->io.NumPorts1 = 16;
336 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
337 link->io.IOAddrLines = 4;
338 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
339 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
340 link->irq.Handler = &smc_interrupt;
341 link->irq.Instance = dev;
342 link->conf.Attributes = CONF_ENABLE_IRQ;
344 link->conf.IntType = INT_MEMORY_AND_IO;
346 /* The SMC91c92-specific entries in the device structure. */
347 SET_MODULE_OWNER(dev);
348 dev->hard_start_xmit = &smc_start_xmit;
349 dev->get_stats = &smc_get_stats;
350 dev->set_config = &s9k_config;
351 dev->set_multicast_list = &set_rx_mode;
352 dev->open = &smc_open;
353 dev->stop = &smc_close;
354 dev->do_ioctl = &smc_ioctl;
355 SET_ETHTOOL_OPS(dev, ðtool_ops);
356 #ifdef HAVE_TX_TIMEOUT
357 dev->tx_timeout = smc_tx_timeout;
358 dev->watchdog_timeo = TX_TIMEOUT;
361 smc->mii_if.dev = dev;
362 smc->mii_if.mdio_read = mdio_read;
363 smc->mii_if.mdio_write = mdio_write;
364 smc->mii_if.phy_id_mask = 0x1f;
365 smc->mii_if.reg_num_mask = 0x1f;
367 /* Register with Card Services */
369 client_reg.dev_info = &dev_info;
370 client_reg.Version = 0x0210;
371 client_reg.event_callback_args.client_data = link;
372 ret = pcmcia_register_client(&link->handle, &client_reg);
374 cs_error(link->handle, RegisterClient, ret);
375 smc91c92_detach(link->handle);
380 } /* smc91c92_attach */
382 /*======================================================================
384 This deletes a driver "instance". The device is de-registered
385 with Card Services. If it has been released, all local data
386 structures are freed. Otherwise, the structures will be freed
387 when the device is released.
389 ======================================================================*/
391 static void smc91c92_detach(struct pcmcia_device *p_dev)
393 dev_link_t *link = dev_to_instance(p_dev);
394 struct net_device *dev = link->priv;
396 DEBUG(0, "smc91c92_detach(0x%p)\n", link);
399 unregister_netdev(dev);
401 if (link->state & DEV_CONFIG)
402 smc91c92_release(link);
405 } /* smc91c92_detach */
407 /*====================================================================*/
409 static int cvt_ascii_address(struct net_device *dev, char *s)
415 for (i = 0; i < 6; i++) {
417 for (j = 0; j < 2; j++) {
420 da += ((c >= '0') && (c <= '9')) ?
421 (c - '0') : ((c & 0x0f) + 9);
423 dev->dev_addr[i] = da;
428 /*====================================================================*/
430 static int first_tuple(client_handle_t handle, tuple_t *tuple,
435 if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
436 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
438 return pcmcia_parse_tuple(handle, tuple, parse);
441 static int next_tuple(client_handle_t handle, tuple_t *tuple,
446 if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
447 (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
449 return pcmcia_parse_tuple(handle, tuple, parse);
452 /*======================================================================
454 Configuration stuff for Megahertz cards
456 mhz_3288_power() is used to power up a 3288's ethernet chip.
457 mhz_mfc_config() handles socket setup for multifunction (1144
458 and 3288) cards. mhz_setup() gets a card's hardware ethernet
461 ======================================================================*/
463 static int mhz_3288_power(dev_link_t *link)
465 struct net_device *dev = link->priv;
466 struct smc_private *smc = netdev_priv(dev);
469 /* Read the ISR twice... */
470 readb(smc->base+MEGAHERTZ_ISR);
472 readb(smc->base+MEGAHERTZ_ISR);
477 /* Now read and write the COR... */
478 tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
480 writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
485 static int mhz_mfc_config(dev_link_t *link)
487 struct net_device *dev = link->priv;
488 struct smc_private *smc = netdev_priv(dev);
489 struct smc_cfg_mem *cfg_mem;
492 cistpl_cftable_entry_t *cf;
498 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
500 return CS_OUT_OF_RESOURCE;
502 tuple = &cfg_mem->tuple;
503 parse = &cfg_mem->parse;
504 cf = &parse->cftable_entry;
507 link->conf.Attributes |= CONF_ENABLE_SPKR;
508 link->conf.Status = CCSR_AUDIO_ENA;
509 link->irq.Attributes =
510 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
511 link->io.IOAddrLines = 16;
512 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
513 link->io.NumPorts2 = 8;
515 tuple->Attributes = tuple->TupleOffset = 0;
516 tuple->TupleData = (cisdata_t *)buf;
517 tuple->TupleDataMax = 255;
518 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
520 i = first_tuple(link->handle, tuple, parse);
521 /* The Megahertz combo cards have modem-like CIS entries, so
522 we have to explicitly try a bunch of port combinations. */
523 while (i == CS_SUCCESS) {
524 link->conf.ConfigIndex = cf->index;
525 link->io.BasePort2 = cf->io.win[0].base;
526 for (k = 0; k < 0x400; k += 0x10) {
527 if (k & 0x80) continue;
528 link->io.BasePort1 = k ^ 0x300;
529 i = pcmcia_request_io(link->handle, &link->io);
530 if (i == CS_SUCCESS) break;
532 if (i == CS_SUCCESS) break;
533 i = next_tuple(link->handle, tuple, parse);
537 dev->base_addr = link->io.BasePort1;
539 /* Allocate a memory window, for accessing the ISR */
540 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
541 req.Base = req.Size = 0;
543 i = pcmcia_request_window(&link->handle, &req, &link->win);
546 smc->base = ioremap(req.Base, req.Size);
547 mem.CardOffset = mem.Page = 0;
548 if (smc->manfid == MANFID_MOTOROLA)
549 mem.CardOffset = link->conf.ConfigBase;
550 i = pcmcia_map_mem_page(link->win, &mem);
552 if ((i == CS_SUCCESS)
553 && (smc->manfid == MANFID_MEGAHERTZ)
554 && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
555 mhz_3288_power(link);
562 static int mhz_setup(dev_link_t *link)
564 client_handle_t handle = link->handle;
565 struct net_device *dev = link->priv;
566 struct smc_cfg_mem *cfg_mem;
569 u_char *buf, *station_addr;
572 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
576 tuple = &cfg_mem->tuple;
577 parse = &cfg_mem->parse;
580 tuple->Attributes = tuple->TupleOffset = 0;
581 tuple->TupleData = (cisdata_t *)buf;
582 tuple->TupleDataMax = 255;
584 /* Read the station address from the CIS. It is stored as the last
585 (fourth) string in the Version 1 Version/ID tuple. */
586 tuple->DesiredTuple = CISTPL_VERS_1;
587 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
591 /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
592 if (next_tuple(handle, tuple, parse) != CS_SUCCESS)
593 first_tuple(handle, tuple, parse);
594 if (parse->version_1.ns > 3) {
595 station_addr = parse->version_1.str + parse->version_1.ofs[3];
596 if (cvt_ascii_address(dev, station_addr) == 0) {
602 /* Another possibility: for the EM3288, in a special tuple */
603 tuple->DesiredTuple = 0x81;
604 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) {
608 if (pcmcia_get_tuple_data(handle, tuple) != CS_SUCCESS) {
613 if (cvt_ascii_address(dev, buf) == 0) {
623 /*======================================================================
625 Configuration stuff for the Motorola Mariner
627 mot_config() writes directly to the Mariner configuration
628 registers because the CIS is just bogus.
630 ======================================================================*/
632 static void mot_config(dev_link_t *link)
634 struct net_device *dev = link->priv;
635 struct smc_private *smc = netdev_priv(dev);
636 kio_addr_t ioaddr = dev->base_addr;
637 kio_addr_t iouart = link->io.BasePort2;
639 /* Set UART base address and force map with COR bit 1 */
640 writeb(iouart & 0xff, smc->base + MOT_UART + CISREG_IOBASE_0);
641 writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
642 writeb(MOT_NORMAL, smc->base + MOT_UART + CISREG_COR);
644 /* Set SMC base address and force map with COR bit 1 */
645 writeb(ioaddr & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_0);
646 writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
647 writeb(MOT_NORMAL, smc->base + MOT_LAN + CISREG_COR);
649 /* Wait for things to settle down */
653 static int mot_setup(dev_link_t *link)
655 struct net_device *dev = link->priv;
656 kio_addr_t ioaddr = dev->base_addr;
660 /* Read Ethernet address from Serial EEPROM */
662 for (i = 0; i < 3; i++) {
664 outw(MOT_EEPROM + i, ioaddr + POINTER);
666 outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
668 for (loop = wait = 0; loop < 200; loop++) {
670 wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
671 if (wait == 0) break;
677 addr = inw(ioaddr + GENERAL);
678 dev->dev_addr[2*i] = addr & 0xff;
679 dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
685 /*====================================================================*/
687 static int smc_config(dev_link_t *link)
689 struct net_device *dev = link->priv;
690 struct smc_cfg_mem *cfg_mem;
693 cistpl_cftable_entry_t *cf;
697 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
699 return CS_OUT_OF_RESOURCE;
701 tuple = &cfg_mem->tuple;
702 parse = &cfg_mem->parse;
703 cf = &parse->cftable_entry;
706 tuple->Attributes = tuple->TupleOffset = 0;
707 tuple->TupleData = (cisdata_t *)buf;
708 tuple->TupleDataMax = 255;
709 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
711 link->io.NumPorts1 = 16;
712 i = first_tuple(link->handle, tuple, parse);
713 while (i != CS_NO_MORE_ITEMS) {
714 if (i == CS_SUCCESS) {
715 link->conf.ConfigIndex = cf->index;
716 link->io.BasePort1 = cf->io.win[0].base;
717 link->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
718 i = pcmcia_request_io(link->handle, &link->io);
719 if (i == CS_SUCCESS) break;
721 i = next_tuple(link->handle, tuple, parse);
724 dev->base_addr = link->io.BasePort1;
730 static int smc_setup(dev_link_t *link)
732 client_handle_t handle = link->handle;
733 struct net_device *dev = link->priv;
734 struct smc_cfg_mem *cfg_mem;
737 cistpl_lan_node_id_t *node_id;
738 u_char *buf, *station_addr;
741 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
743 return CS_OUT_OF_RESOURCE;
745 tuple = &cfg_mem->tuple;
746 parse = &cfg_mem->parse;
749 tuple->Attributes = tuple->TupleOffset = 0;
750 tuple->TupleData = (cisdata_t *)buf;
751 tuple->TupleDataMax = 255;
753 /* Check for a LAN function extension tuple */
754 tuple->DesiredTuple = CISTPL_FUNCE;
755 i = first_tuple(handle, tuple, parse);
756 while (i == CS_SUCCESS) {
757 if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
759 i = next_tuple(handle, tuple, parse);
761 if (i == CS_SUCCESS) {
762 node_id = (cistpl_lan_node_id_t *)parse->funce.data;
763 if (node_id->nb == 6) {
764 for (i = 0; i < 6; i++)
765 dev->dev_addr[i] = node_id->id[i];
770 /* Try the third string in the Version 1 Version/ID tuple. */
771 tuple->DesiredTuple = CISTPL_VERS_1;
772 if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
776 station_addr = parse->version_1.str + parse->version_1.ofs[2];
777 if (cvt_ascii_address(dev, station_addr) == 0) {
788 /*====================================================================*/
790 static int osi_config(dev_link_t *link)
792 struct net_device *dev = link->priv;
793 static kio_addr_t com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
796 link->conf.Attributes |= CONF_ENABLE_SPKR;
797 link->conf.Status = CCSR_AUDIO_ENA;
798 link->irq.Attributes =
799 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
800 link->io.NumPorts1 = 64;
801 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
802 link->io.NumPorts2 = 8;
803 link->io.IOAddrLines = 16;
805 /* Enable Hard Decode, LAN, Modem */
806 link->conf.ConfigIndex = 0x23;
808 for (i = j = 0; j < 4; j++) {
809 link->io.BasePort2 = com[j];
810 i = pcmcia_request_io(link->handle, &link->io);
811 if (i == CS_SUCCESS) break;
813 if (i != CS_SUCCESS) {
814 /* Fallback: turn off hard decode */
815 link->conf.ConfigIndex = 0x03;
816 link->io.NumPorts2 = 0;
817 i = pcmcia_request_io(link->handle, &link->io);
819 dev->base_addr = link->io.BasePort1 + 0x10;
823 static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid)
825 client_handle_t handle = link->handle;
826 struct net_device *dev = link->priv;
827 struct smc_cfg_mem *cfg_mem;
832 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
836 tuple = &cfg_mem->tuple;
839 tuple->Attributes = TUPLE_RETURN_COMMON;
840 tuple->TupleData = (cisdata_t *)buf;
841 tuple->TupleDataMax = 255;
842 tuple->TupleOffset = 0;
844 /* Read the station address from tuple 0x90, subtuple 0x04 */
845 tuple->DesiredTuple = 0x90;
846 i = pcmcia_get_first_tuple(handle, tuple);
847 while (i == CS_SUCCESS) {
848 i = pcmcia_get_tuple_data(handle, tuple);
849 if ((i != CS_SUCCESS) || (buf[0] == 0x04))
851 i = pcmcia_get_next_tuple(handle, tuple);
853 if (i != CS_SUCCESS) {
857 for (i = 0; i < 6; i++)
858 dev->dev_addr[i] = buf[i+2];
860 if (((manfid == MANFID_OSITECH) &&
861 (cardid == PRODID_OSITECH_SEVEN)) ||
862 ((manfid == MANFID_PSION) &&
863 (cardid == PRODID_PSION_NET100))) {
864 /* Download the Seven of Diamonds firmware */
865 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
866 outb(__Xilinx7OD[i], link->io.BasePort1+2);
869 } else if (manfid == MANFID_OSITECH) {
870 /* Make sure both functions are powered up */
871 set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
872 /* Now, turn on the interrupt for both card functions */
873 set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
874 DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
875 inw(link->io.BasePort1 + OSITECH_AUI_PWR),
876 inw(link->io.BasePort1 + OSITECH_RESET_ISR));
884 static int smc91c92_suspend(struct pcmcia_device *p_dev)
886 dev_link_t *link = dev_to_instance(p_dev);
887 struct net_device *dev = link->priv;
889 link->state |= DEV_SUSPEND;
890 if (link->state & DEV_CONFIG) {
892 netif_device_detach(dev);
893 pcmcia_release_configuration(link->handle);
899 static int smc91c92_resume(struct pcmcia_device *p_dev)
901 dev_link_t *link = dev_to_instance(p_dev);
902 struct net_device *dev = link->priv;
903 struct smc_private *smc = netdev_priv(dev);
906 link->state &= ~DEV_SUSPEND;
907 if (link->state & DEV_CONFIG) {
908 if ((smc->manfid == MANFID_MEGAHERTZ) &&
909 (smc->cardid == PRODID_MEGAHERTZ_EM3288))
910 mhz_3288_power(link);
911 pcmcia_request_configuration(link->handle, &link->conf);
912 if (smc->manfid == MANFID_MOTOROLA)
914 if ((smc->manfid == MANFID_OSITECH) &&
915 (smc->cardid != PRODID_OSITECH_SEVEN)) {
916 /* Power up the card and enable interrupts */
917 set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
918 set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
920 if (((smc->manfid == MANFID_OSITECH) &&
921 (smc->cardid == PRODID_OSITECH_SEVEN)) ||
922 ((smc->manfid == MANFID_PSION) &&
923 (smc->cardid == PRODID_PSION_NET100))) {
924 /* Download the Seven of Diamonds firmware */
925 for (i = 0; i < sizeof(__Xilinx7OD); i++) {
926 outb(__Xilinx7OD[i], link->io.BasePort1+2);
932 netif_device_attach(dev);
940 /*======================================================================
942 This verifies that the chip is some SMC91cXX variant, and returns
943 the revision code if successful. Otherwise, it returns -ENODEV.
945 ======================================================================*/
947 static int check_sig(dev_link_t *link)
949 struct net_device *dev = link->priv;
950 kio_addr_t ioaddr = dev->base_addr;
955 if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
956 /* Try powering up the chip */
957 outw(0, ioaddr + CONTROL);
961 /* Try setting bus width */
962 width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
963 s = inb(ioaddr + CONFIG);
968 outb(s, ioaddr + CONFIG);
970 /* Check Base Address Register to make sure bus width is OK */
971 s = inw(ioaddr + BASE_ADDR);
972 if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
973 ((s >> 8) != (s & 0xff))) {
975 s = inw(ioaddr + REVISION);
980 printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
981 smc91c92_suspend(link->handle);
982 pcmcia_release_io(link->handle, &link->io);
983 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
984 pcmcia_request_io(link->handle, &link->io);
985 smc91c92_resume(link->handle);
986 return check_sig(link);
991 /*======================================================================
993 smc91c92_config() is scheduled to run after a CARD_INSERTION event
994 is received, to configure the PCMCIA socket, and to make the
995 ethernet device available to the system.
997 ======================================================================*/
999 #define CS_EXIT_TEST(ret, svc, label) \
1000 if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
1002 static void smc91c92_config(dev_link_t *link)
1004 client_handle_t handle = link->handle;
1005 struct net_device *dev = link->priv;
1006 struct smc_private *smc = netdev_priv(dev);
1007 struct smc_cfg_mem *cfg_mem;
1016 DEBUG(0, "smc91c92_config(0x%p)\n", link);
1018 cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
1022 tuple = &cfg_mem->tuple;
1023 parse = &cfg_mem->parse;
1026 tuple->Attributes = tuple->TupleOffset = 0;
1027 tuple->TupleData = (cisdata_t *)buf;
1028 tuple->TupleDataMax = 64;
1030 tuple->DesiredTuple = CISTPL_CONFIG;
1031 i = first_tuple(handle, tuple, parse);
1032 CS_EXIT_TEST(i, ParseTuple, config_failed);
1033 link->conf.ConfigBase = parse->config.base;
1034 link->conf.Present = parse->config.rmask[0];
1036 tuple->DesiredTuple = CISTPL_MANFID;
1037 tuple->Attributes = TUPLE_RETURN_COMMON;
1038 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
1039 smc->manfid = parse->manfid.manf;
1040 smc->cardid = parse->manfid.card;
1043 /* Configure card */
1044 link->state |= DEV_CONFIG;
1046 if ((smc->manfid == MANFID_OSITECH) &&
1047 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1048 i = osi_config(link);
1049 } else if ((smc->manfid == MANFID_MOTOROLA) ||
1050 ((smc->manfid == MANFID_MEGAHERTZ) &&
1051 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
1052 (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
1053 i = mhz_mfc_config(link);
1055 i = smc_config(link);
1057 CS_EXIT_TEST(i, RequestIO, config_failed);
1059 i = pcmcia_request_irq(link->handle, &link->irq);
1060 CS_EXIT_TEST(i, RequestIRQ, config_failed);
1061 i = pcmcia_request_configuration(link->handle, &link->conf);
1062 CS_EXIT_TEST(i, RequestConfiguration, config_failed);
1064 if (smc->manfid == MANFID_MOTOROLA)
1067 dev->irq = link->irq.AssignedIRQ;
1069 if ((if_port >= 0) && (if_port <= 2))
1070 dev->if_port = if_port;
1072 printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
1074 switch (smc->manfid) {
1075 case MANFID_OSITECH:
1077 i = osi_setup(link, smc->manfid, smc->cardid); break;
1079 case MANFID_NEW_MEDIA:
1080 i = smc_setup(link); break;
1081 case 0x128: /* For broken Megahertz cards */
1082 case MANFID_MEGAHERTZ:
1083 i = mhz_setup(link); break;
1084 case MANFID_MOTOROLA:
1085 default: /* get the hw address from EEPROM */
1086 i = mot_setup(link); break;
1090 printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1097 rev = check_sig(link);
1101 case 3: name = "92"; break;
1102 case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1103 case 5: name = "95"; break;
1104 case 7: name = "100"; break;
1105 case 8: name = "100-FD"; break;
1106 case 9: name = "110"; break;
1109 ioaddr = dev->base_addr;
1113 mir = inw(ioaddr + MEMINFO) & 0xff;
1114 if (mir == 0xff) mir++;
1115 /* Get scale factor for memory size */
1116 mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1117 mir *= 128 * (1<<((mcr >> 9) & 7));
1119 smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1120 smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1121 if (smc->manfid == MANFID_OSITECH)
1122 smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1123 if ((rev >> 4) >= 7)
1124 smc->cfg |= CFG_MII_SELECT;
1128 if (smc->cfg & CFG_MII_SELECT) {
1131 for (i = 0; i < 32; i++) {
1132 j = mdio_read(dev, i, 1);
1133 if ((j != 0) && (j != 0xffff)) break;
1135 smc->mii_if.phy_id = (i < 32) ? i : -1;
1140 link->dev = &smc->node;
1141 link->state &= ~DEV_CONFIG_PENDING;
1142 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
1144 if (register_netdev(dev) != 0) {
1145 printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1150 strcpy(smc->node.dev_name, dev->name);
1152 printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1153 "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
1155 for (i = 0; i < 6; i++)
1156 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
1160 printk(KERN_INFO " %lu byte", mir);
1162 printk(KERN_INFO " %lu kb", mir>>10);
1163 printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1164 "MII" : if_names[dev->if_port]);
1167 if (smc->cfg & CFG_MII_SELECT) {
1168 if (smc->mii_if.phy_id != -1) {
1169 DEBUG(0, " MII transceiver at index %d, status %x.\n",
1170 smc->mii_if.phy_id, j);
1172 printk(KERN_NOTICE " No MII transceivers found!\n");
1179 unregister_netdev(dev);
1180 config_failed: /* CS_EXIT_TEST() calls jump to here... */
1181 smc91c92_release(link);
1182 link->state &= ~DEV_CONFIG_PENDING;
1185 } /* smc91c92_config */
1187 /*======================================================================
1189 After a card is removed, smc91c92_release() will unregister the net
1190 device, and release the PCMCIA configuration. If the device is
1191 still open, this will be postponed until it is closed.
1193 ======================================================================*/
1195 static void smc91c92_release(dev_link_t *link)
1198 DEBUG(0, "smc91c92_release(0x%p)\n", link);
1200 pcmcia_release_configuration(link->handle);
1201 pcmcia_release_io(link->handle, &link->io);
1202 pcmcia_release_irq(link->handle, &link->irq);
1204 struct net_device *dev = link->priv;
1205 struct smc_private *smc = netdev_priv(dev);
1207 pcmcia_release_window(link->win);
1210 link->state &= ~DEV_CONFIG;
1213 /*======================================================================
1215 The card status event handler. Mostly, this schedules other
1216 stuff to run after an event is received. A CARD_REMOVAL event
1217 also sets some flags to discourage the net drivers from trying
1218 to talk to the card any more.
1220 ======================================================================*/
1222 static int smc91c92_event(event_t event, int priority,
1223 event_callback_args_t *args)
1225 dev_link_t *link = args->client_data;
1227 DEBUG(1, "smc91c92_event(0x%06x)\n", event);
1230 case CS_EVENT_CARD_INSERTION:
1231 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1232 smc91c92_config(link);
1236 } /* smc91c92_event */
1238 /*======================================================================
1240 MII interface support for SMC91cXX based cards
1241 ======================================================================*/
1243 #define MDIO_SHIFT_CLK 0x04
1244 #define MDIO_DATA_OUT 0x01
1245 #define MDIO_DIR_WRITE 0x08
1246 #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
1247 #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1248 #define MDIO_DATA_READ 0x02
1250 static void mdio_sync(kio_addr_t addr)
1253 for (bits = 0; bits < 32; bits++) {
1254 outb(MDIO_DATA_WRITE1, addr);
1255 outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1259 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1261 kio_addr_t addr = dev->base_addr + MGMT;
1262 u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1266 for (i = 13; i >= 0; i--) {
1267 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1269 outb(dat | MDIO_SHIFT_CLK, addr);
1271 for (i = 19; i > 0; i--) {
1273 retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1274 outb(MDIO_SHIFT_CLK, addr);
1276 return (retval>>1) & 0xffff;
1279 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1281 kio_addr_t addr = dev->base_addr + MGMT;
1282 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1286 for (i = 31; i >= 0; i--) {
1287 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1289 outb(dat | MDIO_SHIFT_CLK, addr);
1291 for (i = 1; i >= 0; i--) {
1293 outb(MDIO_SHIFT_CLK, addr);
1297 /*======================================================================
1299 The driver core code, most of which should be common with a
1300 non-PCMCIA implementation.
1302 ======================================================================*/
1305 static void smc_dump(struct net_device *dev)
1307 kio_addr_t ioaddr = dev->base_addr;
1309 save = inw(ioaddr + BANK_SELECT);
1310 for (w = 0; w < 4; w++) {
1312 printk(KERN_DEBUG "bank %d: ", w);
1313 for (i = 0; i < 14; i += 2)
1314 printk(" %04x", inw(ioaddr + i));
1317 outw(save, ioaddr + BANK_SELECT);
1321 static int smc_open(struct net_device *dev)
1323 struct smc_private *smc = netdev_priv(dev);
1324 dev_link_t *link = &smc->link;
1327 DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1328 dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1329 if (pc_debug > 1) smc_dump(dev);
1332 /* Check that the PCMCIA card is still here. */
1335 /* Physical device present signature. */
1336 if (check_sig(link) < 0) {
1337 printk("smc91c92_cs: Yikes! Bad chip signature!\n");
1342 netif_start_queue(dev);
1343 smc->saved_skb = NULL;
1344 smc->packets_waiting = 0;
1347 init_timer(&smc->media);
1348 smc->media.function = &media_check;
1349 smc->media.data = (u_long) dev;
1350 smc->media.expires = jiffies + HZ;
1351 add_timer(&smc->media);
1356 /*====================================================================*/
1358 static int smc_close(struct net_device *dev)
1360 struct smc_private *smc = netdev_priv(dev);
1361 dev_link_t *link = &smc->link;
1362 kio_addr_t ioaddr = dev->base_addr;
1364 DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1365 dev->name, inw(ioaddr + BANK_SELECT));
1367 netif_stop_queue(dev);
1369 /* Shut off all interrupts, and turn off the Tx and Rx sections.
1370 Don't bother to check for chip present. */
1371 SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1372 outw(0, ioaddr + INTERRUPT);
1374 mask_bits(0xff00, ioaddr + RCR);
1375 mask_bits(0xff00, ioaddr + TCR);
1377 /* Put the chip into power-down mode. */
1379 outw(CTL_POWERDOWN, ioaddr + CONTROL );
1382 del_timer_sync(&smc->media);
1387 /*======================================================================
1389 Transfer a packet to the hardware and trigger the packet send.
1390 This may be called at either from either the Tx queue code
1391 or the interrupt handler.
1393 ======================================================================*/
1395 static void smc_hardware_send_packet(struct net_device * dev)
1397 struct smc_private *smc = netdev_priv(dev);
1398 struct sk_buff *skb = smc->saved_skb;
1399 kio_addr_t ioaddr = dev->base_addr;
1403 printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1407 /* There should be a packet slot waiting. */
1408 packet_no = inw(ioaddr + PNR_ARR) >> 8;
1409 if (packet_no & 0x80) {
1410 /* If not, there is a hardware problem! Likely an ejected card. */
1411 printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1412 " failed, status %#2.2x.\n", dev->name, packet_no);
1413 dev_kfree_skb_irq(skb);
1414 smc->saved_skb = NULL;
1415 netif_start_queue(dev);
1419 smc->stats.tx_bytes += skb->len;
1420 /* The card should use the just-allocated buffer. */
1421 outw(packet_no, ioaddr + PNR_ARR);
1422 /* point to the beginning of the packet */
1423 outw(PTR_AUTOINC , ioaddr + POINTER);
1425 /* Send the packet length (+6 for status, length and ctl byte)
1426 and the status word (set to zeros). */
1428 u_char *buf = skb->data;
1429 u_int length = skb->len; /* The chip will pad to ethernet min. */
1431 DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1434 /* send the packet length: +6 for status word, length, and ctl */
1435 outw(0, ioaddr + DATA_1);
1436 outw(length + 6, ioaddr + DATA_1);
1437 outsw(ioaddr + DATA_1, buf, length >> 1);
1439 /* The odd last byte, if there is one, goes in the control word. */
1440 outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1443 /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1444 outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1445 (inw(ioaddr + INTERRUPT) & 0xff00),
1446 ioaddr + INTERRUPT);
1448 /* The chip does the rest of the work. */
1449 outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1451 smc->saved_skb = NULL;
1452 dev_kfree_skb_irq(skb);
1453 dev->trans_start = jiffies;
1454 netif_start_queue(dev);
1458 /*====================================================================*/
1460 static void smc_tx_timeout(struct net_device *dev)
1462 struct smc_private *smc = netdev_priv(dev);
1463 kio_addr_t ioaddr = dev->base_addr;
1465 printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1466 "Tx_status %2.2x status %4.4x.\n",
1467 dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1468 smc->stats.tx_errors++;
1470 dev->trans_start = jiffies;
1471 smc->saved_skb = NULL;
1472 netif_wake_queue(dev);
1475 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1477 struct smc_private *smc = netdev_priv(dev);
1478 kio_addr_t ioaddr = dev->base_addr;
1482 netif_stop_queue(dev);
1484 DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1485 " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1487 if (smc->saved_skb) {
1488 /* THIS SHOULD NEVER HAPPEN. */
1489 smc->stats.tx_aborted_errors++;
1490 printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1494 smc->saved_skb = skb;
1496 num_pages = skb->len >> 8;
1498 if (num_pages > 7) {
1499 printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1500 dev_kfree_skb (skb);
1501 smc->saved_skb = NULL;
1502 smc->stats.tx_dropped++;
1503 return 0; /* Do not re-queue this packet. */
1505 /* A packet is now waiting. */
1506 smc->packets_waiting++;
1508 SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1510 /* need MC_RESET to keep the memory consistent. errata? */
1512 outw(MC_RESET, ioaddr + MMU_CMD);
1516 /* Allocate the memory; send the packet now if we win. */
1517 outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1518 for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1519 ir = inw(ioaddr+INTERRUPT);
1520 if (ir & IM_ALLOC_INT) {
1521 /* Acknowledge the interrupt, send the packet. */
1522 outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1523 smc_hardware_send_packet(dev); /* Send the packet now.. */
1528 /* Otherwise defer until the Tx-space-allocated interrupt. */
1529 DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1530 outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1535 /*======================================================================
1537 Handle a Tx anomolous event. Entered while in Window 2.
1539 ======================================================================*/
1541 static void smc_tx_err(struct net_device * dev)
1543 struct smc_private *smc = netdev_priv(dev);
1544 kio_addr_t ioaddr = dev->base_addr;
1545 int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1546 int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1549 /* select this as the packet to read from */
1550 outw(packet_no, ioaddr + PNR_ARR);
1552 /* read the first word from this packet */
1553 outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1555 tx_status = inw(ioaddr + DATA_1);
1557 smc->stats.tx_errors++;
1558 if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1559 if (tx_status & TS_LATCOL) smc->stats.tx_window_errors++;
1560 if (tx_status & TS_16COL) {
1561 smc->stats.tx_aborted_errors++;
1565 if (tx_status & TS_SUCCESS) {
1566 printk(KERN_NOTICE "%s: Successful packet caused error "
1567 "interrupt?\n", dev->name);
1569 /* re-enable transmit */
1571 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1574 outw(MC_FREEPKT, ioaddr + MMU_CMD); /* Free the packet memory. */
1576 /* one less packet waiting for me */
1577 smc->packets_waiting--;
1579 outw(saved_packet, ioaddr + PNR_ARR);
1583 /*====================================================================*/
1585 static void smc_eph_irq(struct net_device *dev)
1587 struct smc_private *smc = netdev_priv(dev);
1588 kio_addr_t ioaddr = dev->base_addr;
1589 u_short card_stats, ephs;
1592 ephs = inw(ioaddr + EPH);
1593 DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1594 " %4.4x.\n", dev->name, ephs);
1595 /* Could be a counter roll-over warning: update stats. */
1596 card_stats = inw(ioaddr + COUNTER);
1597 /* single collisions */
1598 smc->stats.collisions += card_stats & 0xF;
1600 /* multiple collisions */
1601 smc->stats.collisions += card_stats & 0xF;
1602 #if 0 /* These are for when linux supports these statistics */
1603 card_stats >>= 4; /* deferred */
1604 card_stats >>= 4; /* excess deferred */
1606 /* If we had a transmit error we must re-enable the transmitter. */
1607 outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1609 /* Clear a link error interrupt. */
1611 outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1612 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1617 /*====================================================================*/
1619 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1621 struct net_device *dev = dev_id;
1622 struct smc_private *smc = netdev_priv(dev);
1624 u_short saved_bank, saved_pointer, mask, status;
1625 unsigned int handled = 1;
1626 char bogus_cnt = INTR_WORK; /* Work we are willing to do. */
1628 if (!netif_device_present(dev))
1631 ioaddr = dev->base_addr;
1633 DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1637 saved_bank = inw(ioaddr + BANK_SELECT);
1638 if ((saved_bank & 0xff00) != 0x3300) {
1639 /* The device does not exist -- the card could be off-line, or
1640 maybe it has been ejected. */
1641 DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1642 "/ejected device.\n", dev->name, irq);
1648 saved_pointer = inw(ioaddr + POINTER);
1649 mask = inw(ioaddr + INTERRUPT) >> 8;
1650 /* clear all interrupts */
1651 outw(0, ioaddr + INTERRUPT);
1653 do { /* read the status flag, and mask it */
1654 status = inw(ioaddr + INTERRUPT) & 0xff;
1655 DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1657 if ((status & mask) == 0) {
1658 if (bogus_cnt == INTR_WORK)
1662 if (status & IM_RCV_INT) {
1663 /* Got a packet(s). */
1666 if (status & IM_TX_INT) {
1668 outw(IM_TX_INT, ioaddr + INTERRUPT);
1671 if (status & IM_TX_EMPTY_INT) {
1672 outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1673 mask &= ~IM_TX_EMPTY_INT;
1674 smc->stats.tx_packets += smc->packets_waiting;
1675 smc->packets_waiting = 0;
1677 if (status & IM_ALLOC_INT) {
1678 /* Clear this interrupt so it doesn't happen again */
1679 mask &= ~IM_ALLOC_INT;
1681 smc_hardware_send_packet(dev);
1683 /* enable xmit interrupts based on this */
1684 mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1686 /* and let the card send more packets to me */
1687 netif_wake_queue(dev);
1689 if (status & IM_RX_OVRN_INT) {
1690 smc->stats.rx_errors++;
1691 smc->stats.rx_fifo_errors++;
1693 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1694 outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1696 if (status & IM_EPH_INT)
1698 } while (--bogus_cnt);
1700 DEBUG(3, " Restoring saved registers mask %2.2x bank %4.4x"
1701 " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1703 /* restore state register */
1704 outw((mask<<8), ioaddr + INTERRUPT);
1705 outw(saved_pointer, ioaddr + POINTER);
1706 SMC_SELECT_BANK(saved_bank);
1708 DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1712 if ((smc->manfid == MANFID_OSITECH) &&
1713 (smc->cardid != PRODID_OSITECH_SEVEN)) {
1714 /* Retrigger interrupt if needed */
1715 mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1716 set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1718 if (smc->manfid == MANFID_MOTOROLA) {
1720 cor = readb(smc->base + MOT_UART + CISREG_COR);
1721 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1722 writeb(cor, smc->base + MOT_UART + CISREG_COR);
1723 cor = readb(smc->base + MOT_LAN + CISREG_COR);
1724 writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1725 writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1727 #ifdef DOES_NOT_WORK
1728 if (smc->base != NULL) { /* Megahertz MFC's */
1729 readb(smc->base+MEGAHERTZ_ISR);
1730 readb(smc->base+MEGAHERTZ_ISR);
1733 return IRQ_RETVAL(handled);
1736 /*====================================================================*/
1738 static void smc_rx(struct net_device *dev)
1740 struct smc_private *smc = netdev_priv(dev);
1741 kio_addr_t ioaddr = dev->base_addr;
1743 int packet_length; /* Caution: not frame length, rather words
1744 to transfer from the chip. */
1746 /* Assertion: we are in Window 2. */
1748 if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1749 printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1754 /* Reset the read pointer, and read the status and packet length. */
1755 outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1756 rx_status = inw(ioaddr + DATA_1);
1757 packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1759 DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1760 dev->name, rx_status, packet_length);
1762 if (!(rx_status & RS_ERRORS)) {
1763 /* do stuff to make a new packet */
1764 struct sk_buff *skb;
1766 /* Note: packet_length adds 5 or 6 extra bytes here! */
1767 skb = dev_alloc_skb(packet_length+2);
1770 DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1771 smc->stats.rx_dropped++;
1772 outw(MC_RELEASE, ioaddr + MMU_CMD);
1776 packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1777 skb_reserve(skb, 2);
1778 insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1779 (packet_length+1)>>1);
1780 skb->protocol = eth_type_trans(skb, dev);
1784 dev->last_rx = jiffies;
1785 smc->stats.rx_packets++;
1786 smc->stats.rx_bytes += packet_length;
1787 if (rx_status & RS_MULTICAST)
1788 smc->stats.multicast++;
1791 smc->stats.rx_errors++;
1793 if (rx_status & RS_ALGNERR) smc->stats.rx_frame_errors++;
1794 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1795 smc->stats.rx_length_errors++;
1796 if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
1798 /* Let the MMU free the memory of this packet. */
1799 outw(MC_RELEASE, ioaddr + MMU_CMD);
1804 /*====================================================================*/
1806 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1808 struct smc_private *smc = netdev_priv(dev);
1809 /* Nothing to update - the 91c92 is a pretty primative chip. */
1813 /*======================================================================
1815 Calculate values for the hardware multicast filter hash table.
1817 ======================================================================*/
1819 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1820 u_char *multicast_table)
1822 struct dev_mc_list *mc_addr;
1824 for (mc_addr = addrs; mc_addr && count-- > 0; mc_addr = mc_addr->next) {
1825 u_int position = ether_crc(6, mc_addr->dmi_addr);
1826 #ifndef final_version /* Verify multicast address. */
1827 if ((mc_addr->dmi_addr[0] & 1) == 0)
1830 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1834 /*======================================================================
1836 Set the receive mode.
1838 This routine is used by both the protocol level to notify us of
1839 promiscuous/multicast mode changes, and by the open/reset code to
1840 initialize the Rx registers. We always set the multicast list and
1841 leave the receiver running.
1843 ======================================================================*/
1845 static void set_rx_mode(struct net_device *dev)
1847 kio_addr_t ioaddr = dev->base_addr;
1848 struct smc_private *smc = netdev_priv(dev);
1849 u_int multicast_table[ 2 ] = { 0, };
1850 unsigned long flags;
1851 u_short rx_cfg_setting;
1853 if (dev->flags & IFF_PROMISC) {
1854 printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.\n", dev->name);
1855 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1856 } else if (dev->flags & IFF_ALLMULTI)
1857 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1859 if (dev->mc_count) {
1860 fill_multicast_tbl(dev->mc_count, dev->mc_list,
1861 (u_char *)multicast_table);
1863 rx_cfg_setting = RxStripCRC | RxEnable;
1866 /* Load MC table and Rx setting into the chip without interrupts. */
1867 spin_lock_irqsave(&smc->lock, flags);
1869 outl(multicast_table[0], ioaddr + MULTICAST0);
1870 outl(multicast_table[1], ioaddr + MULTICAST4);
1872 outw(rx_cfg_setting, ioaddr + RCR);
1874 spin_unlock_irqrestore(&smc->lock, flags);
1879 /*======================================================================
1881 Senses when a card's config changes. Here, it's coax or TP.
1883 ======================================================================*/
1885 static int s9k_config(struct net_device *dev, struct ifmap *map)
1887 struct smc_private *smc = netdev_priv(dev);
1888 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1889 if (smc->cfg & CFG_MII_SELECT)
1891 else if (map->port > 2)
1893 dev->if_port = map->port;
1894 printk(KERN_INFO "%s: switched to %s port\n",
1895 dev->name, if_names[dev->if_port]);
1901 /*======================================================================
1903 Reset the chip, reloading every register that might be corrupted.
1905 ======================================================================*/
1908 Set transceiver type, perhaps to something other than what the user
1909 specified in dev->if_port.
1911 static void smc_set_xcvr(struct net_device *dev, int if_port)
1913 struct smc_private *smc = netdev_priv(dev);
1914 kio_addr_t ioaddr = dev->base_addr;
1917 saved_bank = inw(ioaddr + BANK_SELECT);
1920 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1921 if ((smc->manfid == MANFID_OSITECH) &&
1922 (smc->cardid != PRODID_OSITECH_SEVEN))
1923 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1924 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1926 outw(smc->cfg, ioaddr + CONFIG);
1927 if ((smc->manfid == MANFID_OSITECH) &&
1928 (smc->cardid != PRODID_OSITECH_SEVEN))
1929 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1930 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1932 SMC_SELECT_BANK(saved_bank);
1935 static void smc_reset(struct net_device *dev)
1937 kio_addr_t ioaddr = dev->base_addr;
1938 struct smc_private *smc = netdev_priv(dev);
1941 DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1943 /* The first interaction must be a write to bring the chip out
1946 /* Reset the chip. */
1947 outw(RCR_SOFTRESET, ioaddr + RCR);
1950 /* Clear the transmit and receive configuration registers. */
1951 outw(RCR_CLEAR, ioaddr + RCR);
1952 outw(TCR_CLEAR, ioaddr + TCR);
1954 /* Set the Window 1 control, configuration and station addr registers.
1955 No point in writing the I/O base register ;-> */
1957 /* Automatically release succesfully transmitted packets,
1958 Accept link errors, counter and Tx error interrupts. */
1959 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1961 smc_set_xcvr(dev, dev->if_port);
1962 if ((smc->manfid == MANFID_OSITECH) &&
1963 (smc->cardid != PRODID_OSITECH_SEVEN))
1964 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1965 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1966 ioaddr - 0x10 + OSITECH_AUI_PWR);
1968 /* Fill in the physical address. The databook is wrong about the order! */
1969 for (i = 0; i < 6; i += 2)
1970 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1971 ioaddr + ADDR0 + i);
1975 outw(MC_RESET, ioaddr + MMU_CMD);
1976 outw(0, ioaddr + INTERRUPT);
1978 /* Re-enable the chip. */
1980 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1981 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1984 if (smc->cfg & CFG_MII_SELECT) {
1988 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1990 /* Advertise 100F, 100H, 10F, 10H */
1991 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1993 /* Restart MII autonegotiation */
1994 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1995 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1998 /* Enable interrupts. */
2000 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
2001 ioaddr + INTERRUPT);
2004 /*======================================================================
2006 Media selection timer routine
2008 ======================================================================*/
2010 static void media_check(u_long arg)
2012 struct net_device *dev = (struct net_device *) arg;
2013 struct smc_private *smc = netdev_priv(dev);
2014 kio_addr_t ioaddr = dev->base_addr;
2015 u_short i, media, saved_bank;
2018 saved_bank = inw(ioaddr + BANK_SELECT);
2020 if (!netif_device_present(dev))
2025 /* need MC_RESET to keep the memory consistent. errata? */
2027 outw(MC_RESET, ioaddr + MMU_CMD);
2030 i = inw(ioaddr + INTERRUPT);
2032 media = inw(ioaddr + EPH) & EPH_LINK_OK;
2034 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
2036 /* Check for pending interrupt with watchdog flag set: with
2037 this, we can limp along even if the interrupt is blocked */
2038 if (smc->watchdog++ && ((i>>8) & i)) {
2039 if (!smc->fast_poll)
2040 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
2041 smc_interrupt(dev->irq, smc, NULL);
2042 smc->fast_poll = HZ;
2044 if (smc->fast_poll) {
2046 smc->media.expires = jiffies + HZ/100;
2047 add_timer(&smc->media);
2048 SMC_SELECT_BANK(saved_bank);
2052 if (smc->cfg & CFG_MII_SELECT) {
2053 if (smc->mii_if.phy_id < 0)
2057 link = mdio_read(dev, smc->mii_if.phy_id, 1);
2058 if (!link || (link == 0xffff)) {
2059 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
2060 smc->mii_if.phy_id = -1;
2065 if (link != smc->link_status) {
2066 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
2067 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2068 (link) ? "found" : "lost");
2069 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
2072 printk(KERN_INFO "%s: autonegotiation complete: "
2073 "%sbaseT-%cD selected\n", dev->name,
2074 ((p & 0x0180) ? "100" : "10"),
2075 (smc->duplex ? 'F' : 'H'));
2078 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
2079 smc->link_status = link;
2084 /* Ignore collisions unless we've had no rx's recently */
2085 if (time_after(jiffies, dev->last_rx + HZ)) {
2086 if (smc->tx_err || (smc->media_status & EPH_16COL))
2091 if (media != smc->media_status) {
2092 if ((media & smc->media_status & 1) &&
2093 ((smc->media_status ^ media) & EPH_LINK_OK))
2094 printk(KERN_INFO "%s: %s link beat\n", dev->name,
2095 (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
2096 else if ((media & smc->media_status & 2) &&
2097 ((smc->media_status ^ media) & EPH_16COL))
2098 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
2099 (media & EPH_16COL ? "problem" : "ok"));
2100 if (dev->if_port == 0) {
2102 if (media & EPH_LINK_OK)
2103 printk(KERN_INFO "%s: flipped to 10baseT\n",
2106 smc_set_xcvr(dev, 2);
2108 if (media & EPH_16COL)
2109 smc_set_xcvr(dev, 1);
2111 printk(KERN_INFO "%s: flipped to 10base2\n",
2115 smc->media_status = media;
2119 smc->media.expires = jiffies + HZ;
2120 add_timer(&smc->media);
2121 SMC_SELECT_BANK(saved_bank);
2124 static int smc_link_ok(struct net_device *dev)
2126 kio_addr_t ioaddr = dev->base_addr;
2127 struct smc_private *smc = netdev_priv(dev);
2129 if (smc->cfg & CFG_MII_SELECT) {
2130 return mii_link_ok(&smc->mii_if);
2133 return inw(ioaddr + EPH) & EPH_LINK_OK;
2137 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2140 kio_addr_t ioaddr = dev->base_addr;
2142 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2143 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2146 tmp = inw(ioaddr + CONFIG);
2147 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2148 ecmd->transceiver = XCVR_INTERNAL;
2149 ecmd->speed = SPEED_10;
2150 ecmd->phy_address = ioaddr + MGMT;
2153 tmp = inw(ioaddr + TCR);
2154 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2159 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2162 kio_addr_t ioaddr = dev->base_addr;
2164 if (ecmd->speed != SPEED_10)
2166 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2168 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2170 if (ecmd->transceiver != XCVR_INTERNAL)
2173 if (ecmd->port == PORT_AUI)
2174 smc_set_xcvr(dev, 1);
2176 smc_set_xcvr(dev, 0);
2179 tmp = inw(ioaddr + TCR);
2180 if (ecmd->duplex == DUPLEX_FULL)
2184 outw(tmp, ioaddr + TCR);
2189 static int check_if_running(struct net_device *dev)
2191 if (!netif_running(dev))
2196 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2198 strcpy(info->driver, DRV_NAME);
2199 strcpy(info->version, DRV_VERSION);
2202 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2204 struct smc_private *smc = netdev_priv(dev);
2205 kio_addr_t ioaddr = dev->base_addr;
2206 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2210 spin_lock_irq(&smc->lock);
2211 if (smc->cfg & CFG_MII_SELECT)
2212 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2214 ret = smc_netdev_get_ecmd(dev, ecmd);
2215 spin_unlock_irq(&smc->lock);
2216 SMC_SELECT_BANK(saved_bank);
2220 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2222 struct smc_private *smc = netdev_priv(dev);
2223 kio_addr_t ioaddr = dev->base_addr;
2224 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2228 spin_lock_irq(&smc->lock);
2229 if (smc->cfg & CFG_MII_SELECT)
2230 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2232 ret = smc_netdev_set_ecmd(dev, ecmd);
2233 spin_unlock_irq(&smc->lock);
2234 SMC_SELECT_BANK(saved_bank);
2238 static u32 smc_get_link(struct net_device *dev)
2240 struct smc_private *smc = netdev_priv(dev);
2241 kio_addr_t ioaddr = dev->base_addr;
2242 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2246 spin_lock_irq(&smc->lock);
2247 ret = smc_link_ok(dev);
2248 spin_unlock_irq(&smc->lock);
2249 SMC_SELECT_BANK(saved_bank);
2254 static u32 smc_get_msglevel(struct net_device *dev)
2259 static void smc_set_msglevel(struct net_device *dev, u32 val)
2265 static int smc_nway_reset(struct net_device *dev)
2267 struct smc_private *smc = netdev_priv(dev);
2268 if (smc->cfg & CFG_MII_SELECT) {
2269 kio_addr_t ioaddr = dev->base_addr;
2270 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2274 res = mii_nway_restart(&smc->mii_if);
2275 SMC_SELECT_BANK(saved_bank);
2282 static struct ethtool_ops ethtool_ops = {
2283 .begin = check_if_running,
2284 .get_drvinfo = smc_get_drvinfo,
2285 .get_settings = smc_get_settings,
2286 .set_settings = smc_set_settings,
2287 .get_link = smc_get_link,
2289 .get_msglevel = smc_get_msglevel,
2290 .set_msglevel = smc_set_msglevel,
2292 .nway_reset = smc_nway_reset,
2295 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2297 struct smc_private *smc = netdev_priv(dev);
2298 struct mii_ioctl_data *mii = if_mii(rq);
2301 kio_addr_t ioaddr = dev->base_addr;
2303 if (!netif_running(dev))
2306 spin_lock_irq(&smc->lock);
2307 saved_bank = inw(ioaddr + BANK_SELECT);
2309 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2310 SMC_SELECT_BANK(saved_bank);
2311 spin_unlock_irq(&smc->lock);
2315 static struct pcmcia_device_id smc91c92_ids[] = {
2316 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2317 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2318 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2319 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2320 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2321 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2322 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2323 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2324 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2325 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2326 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2327 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2328 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2329 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2330 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2331 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2332 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2333 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2334 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2335 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2336 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2337 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2338 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2339 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2340 /* These conflict with other cards! */
2341 /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2342 /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2345 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2347 static struct pcmcia_driver smc91c92_cs_driver = {
2348 .owner = THIS_MODULE,
2350 .name = "smc91c92_cs",
2352 .attach = smc91c92_attach,
2353 .event = smc91c92_event,
2354 .remove = smc91c92_detach,
2355 .id_table = smc91c92_ids,
2356 .suspend = smc91c92_suspend,
2357 .resume = smc91c92_resume,
2360 static int __init init_smc91c92_cs(void)
2362 return pcmcia_register_driver(&smc91c92_cs_driver);
2365 static void __exit exit_smc91c92_cs(void)
2367 pcmcia_unregister_driver(&smc91c92_cs_driver);
2370 module_init(init_smc91c92_cs);
2371 module_exit(exit_smc91c92_cs);