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