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