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