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