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