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