Debian Codegraph @

linux/pcmcia-cs/clients/smc91c92_cs.c

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