?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC66 3.0.0.4.374.130 core
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / net / pcmcia / smc91c92_cs.c
blob7912dbd14251d515712205e00891a3e9b703437b
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 netif_rx(skb);
1673 dev->last_rx = jiffies;
1674 smc->stats.rx_packets++;
1675 smc->stats.rx_bytes += packet_length;
1676 if (rx_status & RS_MULTICAST)
1677 smc->stats.multicast++;
1678 } else {
1679 /* error ... */
1680 smc->stats.rx_errors++;
1681
1682 if (rx_status & RS_ALGNERR) smc->stats.rx_frame_errors++;
1683 if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1684 smc->stats.rx_length_errors++;
1685 if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
1686 }
1687 /* Let the MMU free the memory of this packet. */
1688 outw(MC_RELEASE, ioaddr + MMU_CMD);
1689
1690 return;
1691 }
1692
1693 /*====================================================================*/
1694
1695 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1696 {
1697 struct smc_private *smc = netdev_priv(dev);
1698 /* Nothing to update - the 91c92 is a pretty primative chip. */
1699 return &smc->stats;
1700 }
1701
1702 /*======================================================================
1703
1704 Calculate values for the hardware multicast filter hash table.
1705
1706 ======================================================================*/
1707
1708 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1709 u_char *multicast_table)
1710 {
1711 struct dev_mc_list *mc_addr;
1712
1713 for (mc_addr = addrs; mc_addr && count-- > 0; mc_addr = mc_addr->next) {
1714 u_int position = ether_crc(6, mc_addr->dmi_addr);
1715 #ifndef final_version /* Verify multicast address. */
1716 if ((mc_addr->dmi_addr[0] & 1) == 0)
1717 continue;
1718 #endif
1719 multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1720 }
1721 }
1722
1723 /*======================================================================
1724
1725 Set the receive mode.
1726
1727 This routine is used by both the protocol level to notify us of
1728 promiscuous/multicast mode changes, and by the open/reset code to
1729 initialize the Rx registers. We always set the multicast list and
1730 leave the receiver running.
1731
1732 ======================================================================*/
1733
1734 static void set_rx_mode(struct net_device *dev)
1735 {
1736 kio_addr_t ioaddr = dev->base_addr;
1737 struct smc_private *smc = netdev_priv(dev);
1738 u_int multicast_table[ 2 ] = { 0, };
1739 unsigned long flags;
1740 u_short rx_cfg_setting;
1741
1742 if (dev->flags & IFF_PROMISC) {
1743 rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1744 } else if (dev->flags & IFF_ALLMULTI)
1745 rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1746 else {
1747 if (dev->mc_count) {
1748 fill_multicast_tbl(dev->mc_count, dev->mc_list,
1749 (u_char *)multicast_table);
1750 }
1751 rx_cfg_setting = RxStripCRC | RxEnable;
1752 }
1753
1754 /* Load MC table and Rx setting into the chip without interrupts. */
1755 spin_lock_irqsave(&smc->lock, flags);
1756 SMC_SELECT_BANK(3);
1757 outl(multicast_table[0], ioaddr + MULTICAST0);
1758 outl(multicast_table[1], ioaddr + MULTICAST4);
1759 SMC_SELECT_BANK(0);
1760 outw(rx_cfg_setting, ioaddr + RCR);
1761 SMC_SELECT_BANK(2);
1762 spin_unlock_irqrestore(&smc->lock, flags);
1763
1764 return;
1765 }
1766
1767 /*======================================================================
1768
1769 Senses when a card's config changes. Here, it's coax or TP.
1770
1771 ======================================================================*/
1772
1773 static int s9k_config(struct net_device *dev, struct ifmap *map)
1774 {
1775 struct smc_private *smc = netdev_priv(dev);
1776 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1777 if (smc->cfg & CFG_MII_SELECT)
1778 return -EOPNOTSUPP;
1779 else if (map->port > 2)
1780 return -EINVAL;
1781 dev->if_port = map->port;
1782 printk(KERN_INFO "%s: switched to %s port\n",
1783 dev->name, if_names[dev->if_port]);
1784 smc_reset(dev);
1785 }
1786 return 0;
1787 }
1788
1789 /*======================================================================
1790
1791 Reset the chip, reloading every register that might be corrupted.
1792
1793 ======================================================================*/
1794
1795 /*
1796 Set transceiver type, perhaps to something other than what the user
1797 specified in dev->if_port.
1798 */
1799 static void smc_set_xcvr(struct net_device *dev, int if_port)
1800 {
1801 struct smc_private *smc = netdev_priv(dev);
1802 kio_addr_t ioaddr = dev->base_addr;
1803 u_short saved_bank;
1804
1805 saved_bank = inw(ioaddr + BANK_SELECT);
1806 SMC_SELECT_BANK(1);
1807 if (if_port == 2) {
1808 outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1809 if ((smc->manfid == MANFID_OSITECH) &&
1810 (smc->cardid != PRODID_OSITECH_SEVEN))
1811 set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1812 smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1813 } else {
1814 outw(smc->cfg, ioaddr + CONFIG);
1815 if ((smc->manfid == MANFID_OSITECH) &&
1816 (smc->cardid != PRODID_OSITECH_SEVEN))
1817 mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1818 smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1819 }
1820 SMC_SELECT_BANK(saved_bank);
1821 }
1822
1823 static void smc_reset(struct net_device *dev)
1824 {
1825 kio_addr_t ioaddr = dev->base_addr;
1826 struct smc_private *smc = netdev_priv(dev);
1827 int i;
1828
1829 DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1830
1831 /* The first interaction must be a write to bring the chip out
1832 of sleep mode. */
1833 SMC_SELECT_BANK(0);
1834 /* Reset the chip. */
1835 outw(RCR_SOFTRESET, ioaddr + RCR);
1836 udelay(10);
1837
1838 /* Clear the transmit and receive configuration registers. */
1839 outw(RCR_CLEAR, ioaddr + RCR);
1840 outw(TCR_CLEAR, ioaddr + TCR);
1841
1842 /* Set the Window 1 control, configuration and station addr registers.
1843 No point in writing the I/O base register ;-> */
1844 SMC_SELECT_BANK(1);
1845 /* Automatically release successfully transmitted packets,
1846 Accept link errors, counter and Tx error interrupts. */
1847 outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1848 ioaddr + CONTROL);
1849 smc_set_xcvr(dev, dev->if_port);
1850 if ((smc->manfid == MANFID_OSITECH) &&
1851 (smc->cardid != PRODID_OSITECH_SEVEN))
1852 outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1853 (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1854 ioaddr - 0x10 + OSITECH_AUI_PWR);
1855
1856 /* Fill in the physical address. The databook is wrong about the order! */
1857 for (i = 0; i < 6; i += 2)
1858 outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1859 ioaddr + ADDR0 + i);
1860
1861 /* Reset the MMU */
1862 SMC_SELECT_BANK(2);
1863 outw(MC_RESET, ioaddr + MMU_CMD);
1864 outw(0, ioaddr + INTERRUPT);
1865
1866 /* Re-enable the chip. */
1867 SMC_SELECT_BANK(0);
1868 outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1869 TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1870 set_rx_mode(dev);
1871
1872 if (smc->cfg & CFG_MII_SELECT) {
1873 SMC_SELECT_BANK(3);
1874
1875 /* Reset MII */
1876 mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1877
1878 /* Advertise 100F, 100H, 10F, 10H */
1879 mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1880
1881 /* Restart MII autonegotiation */
1882 mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1883 mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1884 }
1885
1886 /* Enable interrupts. */
1887 SMC_SELECT_BANK(2);
1888 outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
1889 ioaddr + INTERRUPT);
1890 }
1891
1892 /*======================================================================
1893
1894 Media selection timer routine
1895
1896 ======================================================================*/
1897
1898 static void media_check(u_long arg)
1899 {
1900 struct net_device *dev = (struct net_device *) arg;
1901 struct smc_private *smc = netdev_priv(dev);
1902 kio_addr_t ioaddr = dev->base_addr;
1903 u_short i, media, saved_bank;
1904 u_short link;
1905
1906 saved_bank = inw(ioaddr + BANK_SELECT);
1907
1908 if (!netif_device_present(dev))
1909 goto reschedule;
1910
1911 SMC_SELECT_BANK(2);
1912
1913 /* need MC_RESET to keep the memory consistent. errata? */
1914 if (smc->rx_ovrn) {
1915 outw(MC_RESET, ioaddr + MMU_CMD);
1916 smc->rx_ovrn = 0;
1917 }
1918 i = inw(ioaddr + INTERRUPT);
1919 SMC_SELECT_BANK(0);
1920 media = inw(ioaddr + EPH) & EPH_LINK_OK;
1921 SMC_SELECT_BANK(1);
1922 media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
1923
1924 /* Check for pending interrupt with watchdog flag set: with
1925 this, we can limp along even if the interrupt is blocked */
1926 if (smc->watchdog++ && ((i>>8) & i)) {
1927 if (!smc->fast_poll)
1928 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1929 smc_interrupt(dev->irq, dev);
1930 smc->fast_poll = HZ;
1931 }
1932 if (smc->fast_poll) {
1933 smc->fast_poll--;
1934 smc->media.expires = jiffies + HZ/100;
1935 add_timer(&smc->media);
1936 SMC_SELECT_BANK(saved_bank);
1937 return;
1938 }
1939
1940 if (smc->cfg & CFG_MII_SELECT) {
1941 if (smc->mii_if.phy_id < 0)
1942 goto reschedule;
1943
1944 SMC_SELECT_BANK(3);
1945 link = mdio_read(dev, smc->mii_if.phy_id, 1);
1946 if (!link || (link == 0xffff)) {
1947 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
1948 smc->mii_if.phy_id = -1;
1949 goto reschedule;
1950 }
1951
1952 link &= 0x0004;
1953 if (link != smc->link_status) {
1954 u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
1955 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1956 (link) ? "found" : "lost");
1957 smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
1958 ? TCR_FDUPLX : 0);
1959 if (link) {
1960 printk(KERN_INFO "%s: autonegotiation complete: "
1961 "%sbaseT-%cD selected\n", dev->name,
1962 ((p & 0x0180) ? "100" : "10"),
1963 (smc->duplex ? 'F' : 'H'));
1964 }
1965 SMC_SELECT_BANK(0);
1966 outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
1967 smc->link_status = link;
1968 }
1969 goto reschedule;
1970 }
1971
1972 /* Ignore collisions unless we've had no rx's recently */
1973 if (time_after(jiffies, dev->last_rx + HZ)) {
1974 if (smc->tx_err || (smc->media_status & EPH_16COL))
1975 media |= EPH_16COL;
1976 }
1977 smc->tx_err = 0;
1978
1979 if (media != smc->media_status) {
1980 if ((media & smc->media_status & 1) &&
1981 ((smc->media_status ^ media) & EPH_LINK_OK))
1982 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1983 (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
1984 else if ((media & smc->media_status & 2) &&
1985 ((smc->media_status ^ media) & EPH_16COL))
1986 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
1987 (media & EPH_16COL ? "problem" : "ok"));
1988 if (dev->if_port == 0) {
1989 if (media & 1) {
1990 if (media & EPH_LINK_OK)
1991 printk(KERN_INFO "%s: flipped to 10baseT\n",
1992 dev->name);
1993 else
1994 smc_set_xcvr(dev, 2);
1995 } else {
1996 if (media & EPH_16COL)
1997 smc_set_xcvr(dev, 1);
1998 else
1999 printk(KERN_INFO "%s: flipped to 10base2\n",
2000 dev->name);
2001 }
2002 }
2003 smc->media_status = media;
2004 }
2005
2006 reschedule:
2007 smc->media.expires = jiffies + HZ;
2008 add_timer(&smc->media);
2009 SMC_SELECT_BANK(saved_bank);
2010 }
2011
2012 static int smc_link_ok(struct net_device *dev)
2013 {
2014 kio_addr_t ioaddr = dev->base_addr;
2015 struct smc_private *smc = netdev_priv(dev);
2016
2017 if (smc->cfg & CFG_MII_SELECT) {
2018 return mii_link_ok(&smc->mii_if);
2019 } else {
2020 SMC_SELECT_BANK(0);
2021 return inw(ioaddr + EPH) & EPH_LINK_OK;
2022 }
2023 }
2024
2025 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2026 {
2027 u16 tmp;
2028 kio_addr_t ioaddr = dev->base_addr;
2029
2030 ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2031 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2032
2033 SMC_SELECT_BANK(1);
2034 tmp = inw(ioaddr + CONFIG);
2035 ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2036 ecmd->transceiver = XCVR_INTERNAL;
2037 ecmd->speed = SPEED_10;
2038 ecmd->phy_address = ioaddr + MGMT;
2039
2040 SMC_SELECT_BANK(0);
2041 tmp = inw(ioaddr + TCR);
2042 ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2043
2044 return 0;
2045 }
2046
2047 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2048 {
2049 u16 tmp;
2050 kio_addr_t ioaddr = dev->base_addr;
2051
2052 if (ecmd->speed != SPEED_10)
2053 return -EINVAL;
2054 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2055 return -EINVAL;
2056 if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2057 return -EINVAL;
2058 if (ecmd->transceiver != XCVR_INTERNAL)
2059 return -EINVAL;
2060
2061 if (ecmd->port == PORT_AUI)
2062 smc_set_xcvr(dev, 1);
2063 else
2064 smc_set_xcvr(dev, 0);
2065
2066 SMC_SELECT_BANK(0);
2067 tmp = inw(ioaddr + TCR);
2068 if (ecmd->duplex == DUPLEX_FULL)
2069 tmp |= TCR_FDUPLX;
2070 else
2071 tmp &= ~TCR_FDUPLX;
2072 outw(tmp, ioaddr + TCR);
2073
2074 return 0;
2075 }
2076
2077 static int check_if_running(struct net_device *dev)
2078 {
2079 if (!netif_running(dev))
2080 return -EINVAL;
2081 return 0;
2082 }
2083
2084 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2085 {
2086 strcpy(info->driver, DRV_NAME);
2087 strcpy(info->version, DRV_VERSION);
2088 }
2089
2090 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2091 {
2092 struct smc_private *smc = netdev_priv(dev);
2093 kio_addr_t ioaddr = dev->base_addr;
2094 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2095 int ret;
2096
2097 SMC_SELECT_BANK(3);
2098 spin_lock_irq(&smc->lock);
2099 if (smc->cfg & CFG_MII_SELECT)
2100 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2101 else
2102 ret = smc_netdev_get_ecmd(dev, ecmd);
2103 spin_unlock_irq(&smc->lock);
2104 SMC_SELECT_BANK(saved_bank);
2105 return ret;
2106 }
2107
2108 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2109 {
2110 struct smc_private *smc = netdev_priv(dev);
2111 kio_addr_t ioaddr = dev->base_addr;
2112 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2113 int ret;
2114
2115 SMC_SELECT_BANK(3);
2116 spin_lock_irq(&smc->lock);
2117 if (smc->cfg & CFG_MII_SELECT)
2118 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2119 else
2120 ret = smc_netdev_set_ecmd(dev, ecmd);
2121 spin_unlock_irq(&smc->lock);
2122 SMC_SELECT_BANK(saved_bank);
2123 return ret;
2124 }
2125
2126 static u32 smc_get_link(struct net_device *dev)
2127 {
2128 struct smc_private *smc = netdev_priv(dev);
2129 kio_addr_t ioaddr = dev->base_addr;
2130 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2131 u32 ret;
2132
2133 SMC_SELECT_BANK(3);
2134 spin_lock_irq(&smc->lock);
2135 ret = smc_link_ok(dev);
2136 spin_unlock_irq(&smc->lock);
2137 SMC_SELECT_BANK(saved_bank);
2138 return ret;
2139 }
2140
2141 #ifdef PCMCIA_DEBUG
2142 static u32 smc_get_msglevel(struct net_device *dev)
2143 {
2144 return pc_debug;
2145 }
2146
2147 static void smc_set_msglevel(struct net_device *dev, u32 val)
2148 {
2149 pc_debug = val;
2150 }
2151 #endif
2152
2153 static int smc_nway_reset(struct net_device *dev)
2154 {
2155 struct smc_private *smc = netdev_priv(dev);
2156 if (smc->cfg & CFG_MII_SELECT) {
2157 kio_addr_t ioaddr = dev->base_addr;
2158 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2159 int res;
2160
2161 SMC_SELECT_BANK(3);
2162 res = mii_nway_restart(&smc->mii_if);
2163 SMC_SELECT_BANK(saved_bank);
2164
2165 return res;
2166 } else
2167 return -EOPNOTSUPP;
2168 }
2169
2170 static const struct ethtool_ops ethtool_ops = {
2171 .begin = check_if_running,
2172 .get_drvinfo = smc_get_drvinfo,
2173 .get_settings = smc_get_settings,
2174 .set_settings = smc_set_settings,
2175 .get_link = smc_get_link,
2176 #ifdef PCMCIA_DEBUG
2177 .get_msglevel = smc_get_msglevel,
2178 .set_msglevel = smc_set_msglevel,
2179 #endif
2180 .nway_reset = smc_nway_reset,
2181 };
2182
2183 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2184 {
2185 struct smc_private *smc = netdev_priv(dev);
2186 struct mii_ioctl_data *mii = if_mii(rq);
2187 int rc = 0;
2188 u16 saved_bank;
2189 kio_addr_t ioaddr = dev->base_addr;
2190
2191 if (!netif_running(dev))
2192 return -EINVAL;
2193
2194 spin_lock_irq(&smc->lock);
2195 saved_bank = inw(ioaddr + BANK_SELECT);
2196 SMC_SELECT_BANK(3);
2197 rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2198 SMC_SELECT_BANK(saved_bank);
2199 spin_unlock_irq(&smc->lock);
2200 return rc;
2201 }
2202
2203 static struct pcmcia_device_id smc91c92_ids[] = {
2204 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2205 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2206 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2207 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2208 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2209 PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2210 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2211 PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2212 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2213 PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2214 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2215 PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2216 PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2217 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2218 PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2219 PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2220 PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2221 PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2222 PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2223 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2224 PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2225 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2226 PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2227 PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2228 /* These conflict with other cards! */
2229 /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2230 /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2231 PCMCIA_DEVICE_NULL,
2232 };
2233 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2234
2235 static struct pcmcia_driver smc91c92_cs_driver = {
2236 .owner = THIS_MODULE,
2237 .drv = {
2238 .name = "smc91c92_cs",
2239 },
2240 .probe = smc91c92_probe,
2241 .remove = smc91c92_detach,
2242 .id_table = smc91c92_ids,
2243 .suspend = smc91c92_suspend,
2244 .resume = smc91c92_resume,
2245 };
2246
2247 static int __init init_smc91c92_cs(void)
2248 {
2249 return pcmcia_register_driver(&smc91c92_cs_driver);
2250 }
2251
2252 static void __exit exit_smc91c92_cs(void)
2253 {
2254 pcmcia_unregister_driver(&smc91c92_cs_driver);
2255 }
2256
2257 module_init(init_smc91c92_cs);
2258 module_exit(exit_smc91c92_cs);
Tomato firmware and modifications.