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