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