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