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