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