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