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