![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smc91c92_cs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients|
Return to smc91c92_cs.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients |
1.1 root 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);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.