Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/net/ethernet/fujitsu/fmvj18x_cs.c

  1 /*======================================================================
  2     fmvj18x_cs.c 2.8 2002/03/23
  3 
  4     A fmvj18x (and its compatibles) PCMCIA client driver
  5 
  6     Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
  7 
  8     TDK LAK-CD021 and CONTEC C-NET(PC)C support added by 
  9     Nobuhiro Katayama, kata-n@po.iijnet.or.jp
 10 
 11     The PCMCIA client code is based on code written by David Hinds.
 12     Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
 13     but is actually largely Donald Becker's AT1700 driver, which
 14     carries the following attribution:
 15 
 16     Written 1993-94 by Donald Becker.
 17 
 18     Copyright 1993 United States Government as represented by the
 19     Director, National Security Agency.
 20     
 21     This software may be used and distributed according to the terms
 22     of the GNU General Public License, incorporated herein by reference.
 23     
 24     The author may be reached as becker@scyld.com, or C/O
 25     Scyld Computing Corporation
 26     410 Severn Ave., Suite 210
 27     Annapolis MD 21403
 28    
 29 ======================================================================*/
 30 
 31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 32 
 33 #define DRV_NAME        "fmvj18x_cs"
 34 #define DRV_VERSION     "2.9"
 35 
 36 #include <linux/module.h>
 37 #include <linux/kernel.h>
 38 #include <linux/ptrace.h>
 39 #include <linux/slab.h>
 40 #include <linux/string.h>
 41 #include <linux/timer.h>
 42 #include <linux/interrupt.h>
 43 #include <linux/in.h>
 44 #include <linux/delay.h>
 45 #include <linux/ethtool.h>
 46 #include <linux/netdevice.h>
 47 #include <linux/etherdevice.h>
 48 #include <linux/skbuff.h>
 49 #include <linux/if_arp.h>
 50 #include <linux/ioport.h>
 51 #include <linux/crc32.h>
 52 
 53 #include <pcmcia/cistpl.h>
 54 #include <pcmcia/ciscode.h>
 55 #include <pcmcia/ds.h>
 56 
 57 #include <linux/uaccess.h>
 58 #include <asm/io.h>
 59 
 60 /*====================================================================*/
 61 
 62 /* Module parameters */
 63 
 64 MODULE_DESCRIPTION("fmvj18x and compatible PCMCIA ethernet driver");
 65 MODULE_LICENSE("GPL");
 66 
 67 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
 68 
 69 /* SRAM configuration */
 70 /* 0:4KB*2 TX buffer   else:8KB*2 TX buffer */
 71 INT_MODULE_PARM(sram_config, 0);
 72 
 73 
 74 /*====================================================================*/
 75 /*
 76     PCMCIA event handlers
 77  */
 78 static int fmvj18x_config(struct pcmcia_device *link);
 79 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id);
 80 static int fmvj18x_setup_mfc(struct pcmcia_device *link);
 81 static void fmvj18x_release(struct pcmcia_device *link);
 82 static void fmvj18x_detach(struct pcmcia_device *p_dev);
 83 
 84 /*
 85     LAN controller(MBH86960A) specific routines
 86  */
 87 static int fjn_config(struct net_device *dev, struct ifmap *map);
 88 static int fjn_open(struct net_device *dev);
 89 static int fjn_close(struct net_device *dev);
 90 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
 91                                         struct net_device *dev);
 92 static irqreturn_t fjn_interrupt(int irq, void *dev_id);
 93 static void fjn_rx(struct net_device *dev);
 94 static void fjn_reset(struct net_device *dev);
 95 static void set_rx_mode(struct net_device *dev);
 96 static void fjn_tx_timeout(struct net_device *dev);
 97 static const struct ethtool_ops netdev_ethtool_ops;
 98 
 99 /*
100     card type
101  */
102 enum cardtype { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
103                XXX10304, NEC, KME
104 };
105 
106 /*
107     driver specific data structure
108 */
109 struct local_info {
110         struct pcmcia_device    *p_dev;
111     long open_time;
112     uint tx_started:1;
113     uint tx_queue;
114     u_short tx_queue_len;
115     enum cardtype cardtype;
116     u_short sent;
117     u_char __iomem *base;
118 };
119 
120 #define MC_FILTERBREAK 64
121 
122 /*====================================================================*/
123 /* 
124     ioport offset from the base address 
125  */
126 #define TX_STATUS               0 /* transmit status register */
127 #define RX_STATUS               1 /* receive status register */
128 #define TX_INTR                 2 /* transmit interrupt mask register */
129 #define RX_INTR                 3 /* receive interrupt mask register */
130 #define TX_MODE                 4 /* transmit mode register */
131 #define RX_MODE                 5 /* receive mode register */
132 #define CONFIG_0                6 /* configuration register 0 */
133 #define CONFIG_1                7 /* configuration register 1 */
134 
135 #define NODE_ID                 8 /* node ID register            (bank 0) */
136 #define MAR_ADR                 8 /* multicast address registers (bank 1) */
137 
138 #define DATAPORT                8 /* buffer mem port registers   (bank 2) */
139 #define TX_START               10 /* transmit start register */
140 #define COL_CTRL               11 /* 16 collision control register */
141 #define BMPR12                 12 /* reserved */
142 #define BMPR13                 13 /* reserved */
143 #define RX_SKIP                14 /* skip received packet register */
144 
145 #define LAN_CTRL               16 /* LAN card control register */
146 
147 #define MAC_ID               0x1a /* hardware address */
148 #define UNGERMANN_MAC_ID     0x18 /* UNGERMANN-BASS hardware address */
149 
150 /* 
151     control bits 
152  */
153 #define ENA_TMT_OK           0x80
154 #define ENA_TMT_REC          0x20
155 #define ENA_COL              0x04
156 #define ENA_16_COL           0x02
157 #define ENA_TBUS_ERR         0x01
158 
159 #define ENA_PKT_RDY          0x80
160 #define ENA_BUS_ERR          0x40
161 #define ENA_LEN_ERR          0x08
162 #define ENA_ALG_ERR          0x04
163 #define ENA_CRC_ERR          0x02
164 #define ENA_OVR_FLO          0x01
165 
166 /* flags */
167 #define F_TMT_RDY            0x80 /* can accept new packet */
168 #define F_NET_BSY            0x40 /* carrier is detected */
169 #define F_TMT_OK             0x20 /* send packet successfully */
170 #define F_SRT_PKT            0x10 /* short packet error */
171 #define F_COL_ERR            0x04 /* collision error */
172 #define F_16_COL             0x02 /* 16 collision error */
173 #define F_TBUS_ERR           0x01 /* bus read error */
174 
175 #define F_PKT_RDY            0x80 /* packet(s) in buffer */
176 #define F_BUS_ERR            0x40 /* bus read error */
177 #define F_LEN_ERR            0x08 /* short packet */
178 #define F_ALG_ERR            0x04 /* frame error */
179 #define F_CRC_ERR            0x02 /* CRC error */
180 #define F_OVR_FLO            0x01 /* overflow error */
181 
182 #define F_BUF_EMP            0x40 /* receive buffer is empty */
183 
184 #define F_SKP_PKT            0x05 /* drop packet in buffer */
185 
186 /* default bitmaps */
187 #define D_TX_INTR  ( ENA_TMT_OK )
188 #define D_RX_INTR  ( ENA_PKT_RDY | ENA_LEN_ERR \
189                    | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
190 #define TX_STAT_M  ( F_TMT_RDY )
191 #define RX_STAT_M  ( F_PKT_RDY | F_LEN_ERR \
192                    | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
193 
194 /* commands */
195 #define D_TX_MODE            0x06 /* no tests, detect carrier */
196 #define ID_MATCHED           0x02 /* (RX_MODE) */
197 #define RECV_ALL             0x03 /* (RX_MODE) */
198 #define CONFIG0_DFL          0x5a /* 16bit bus, 4K x 2 Tx queues */
199 #define CONFIG0_DFL_1        0x5e /* 16bit bus, 8K x 2 Tx queues */
200 #define CONFIG0_RST          0xda /* Data Link Controller off (CONFIG_0) */
201 #define CONFIG0_RST_1        0xde /* Data Link Controller off (CONFIG_0) */
202 #define BANK_0               0xa0 /* bank 0 (CONFIG_1) */
203 #define BANK_1               0xa4 /* bank 1 (CONFIG_1) */
204 #define BANK_2               0xa8 /* bank 2 (CONFIG_1) */
205 #define CHIP_OFF             0x80 /* contrl chip power off (CONFIG_1) */
206 #define DO_TX                0x80 /* do transmit packet */
207 #define SEND_PKT             0x81 /* send a packet */
208 #define AUTO_MODE            0x07 /* Auto skip packet on 16 col detected */
209 #define MANU_MODE            0x03 /* Stop and skip packet on 16 col */
210 #define TDK_AUTO_MODE        0x47 /* Auto skip packet on 16 col detected */
211 #define TDK_MANU_MODE        0x43 /* Stop and skip packet on 16 col */
212 #define INTR_OFF             0x0d /* LAN controller ignores interrupts */
213 #define INTR_ON              0x1d /* LAN controller will catch interrupts */
214 
215 #define TX_TIMEOUT              ((400*HZ)/1000)
216 
217 #define BANK_0U              0x20 /* bank 0 (CONFIG_1) */
218 #define BANK_1U              0x24 /* bank 1 (CONFIG_1) */
219 #define BANK_2U              0x28 /* bank 2 (CONFIG_1) */
220 
221 static const struct net_device_ops fjn_netdev_ops = {
222         .ndo_open               = fjn_open,
223         .ndo_stop               = fjn_close,
224         .ndo_start_xmit         = fjn_start_xmit,
225         .ndo_tx_timeout         = fjn_tx_timeout,
226         .ndo_set_config         = fjn_config,
227         .ndo_set_rx_mode        = set_rx_mode,
228         .ndo_set_mac_address    = eth_mac_addr,
229         .ndo_validate_addr      = eth_validate_addr,
230 };
231 
232 static int fmvj18x_probe(struct pcmcia_device *link)
233 {
234     struct local_info *lp;
235     struct net_device *dev;
236 
237     dev_dbg(&link->dev, "fmvj18x_attach()\n");
238 
239     /* Make up a FMVJ18x specific data structure */
240     dev = alloc_etherdev(sizeof(struct local_info));
241     if (!dev)
242         return -ENOMEM;
243     lp = netdev_priv(dev);
244     link->priv = dev;
245     lp->p_dev = link;
246     lp->base = NULL;
247 
248     /* The io structure describes IO port mapping */
249     link->resource[0]->end = 32;
250     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
251 
252     /* General socket configuration */
253     link->config_flags |= CONF_ENABLE_IRQ;
254 
255     dev->netdev_ops = &fjn_netdev_ops;
256     dev->watchdog_timeo = TX_TIMEOUT;
257 
258     dev->ethtool_ops = &netdev_ethtool_ops;
259 
260     return fmvj18x_config(link);
261 } /* fmvj18x_attach */
262 
263 /*====================================================================*/
264 
265 static void fmvj18x_detach(struct pcmcia_device *link)
266 {
267     struct net_device *dev = link->priv;
268 
269     dev_dbg(&link->dev, "fmvj18x_detach\n");
270 
271     unregister_netdev(dev);
272 
273     fmvj18x_release(link);
274 
275     free_netdev(dev);
276 } /* fmvj18x_detach */
277 
278 /*====================================================================*/
279 
280 static int mfc_try_io_port(struct pcmcia_device *link)
281 {
282     int i, ret;
283     static const unsigned int serial_base[5] =
284         { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
285 
286     for (i = 0; i < 5; i++) {
287         link->resource[1]->start = serial_base[i];
288         link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
289         if (link->resource[1]->start == 0) {
290             link->resource[1]->end = 0;
291             pr_notice("out of resource for serial\n");
292         }
293         ret = pcmcia_request_io(link);
294         if (ret == 0)
295                 return ret;
296     }
297     return ret;
298 }
299 
300 static int ungermann_try_io_port(struct pcmcia_device *link)
301 {
302     int ret;
303     unsigned int ioaddr;
304     /*
305         Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
306         0x380,0x3c0 only for ioport.
307     */
308     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
309         link->resource[0]->start = ioaddr;
310         ret = pcmcia_request_io(link);
311         if (ret == 0) {
312             /* calculate ConfigIndex value */
313             link->config_index =
314                 ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
315             return ret;
316         }
317     }
318     return ret; /* RequestIO failed */
319 }
320 
321 static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
322 {
323         return 0; /* strange, but that's what the code did already before... */
324 }
325 
326 static int fmvj18x_config(struct pcmcia_device *link)
327 {
328     struct net_device *dev = link->priv;
329     struct local_info *lp = netdev_priv(dev);
330     int i, ret;
331     unsigned int ioaddr;
332     enum cardtype cardtype;
333     char *card_name = "unknown";
334     u8 *buf;
335     size_t len;
336     u_char buggybuf[32];
337 
338     dev_dbg(&link->dev, "fmvj18x_config\n");
339 
340     link->io_lines = 5;
341 
342     len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
343     kfree(buf);
344 
345     if (len) {
346         /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
347         ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
348         if (ret != 0)
349                 goto failed;
350 
351         switch (link->manf_id) {
352         case MANFID_TDK:
353             cardtype = TDK;
354             if (link->card_id == PRODID_TDK_GN3410 ||
355                 link->card_id == PRODID_TDK_NP9610 ||
356                 link->card_id == PRODID_TDK_MN3200) {
357                 /* MultiFunction Card */
358                 link->config_base = 0x800;
359                 link->config_index = 0x47;
360                 link->resource[1]->end = 8;
361             }
362             break;
363         case MANFID_NEC:
364             cardtype = NEC; /* MultiFunction Card */
365             link->config_base = 0x800;
366             link->config_index = 0x47;
367             link->resource[1]->end = 8;
368             break;
369         case MANFID_KME:
370             cardtype = KME; /* MultiFunction Card */
371             link->config_base = 0x800;
372             link->config_index = 0x47;
373             link->resource[1]->end = 8;
374             break;
375         case MANFID_CONTEC:
376             cardtype = CONTEC;
377             break;
378         case MANFID_FUJITSU:
379             if (link->config_base == 0x0fe0)
380                 cardtype = MBH10302;
381             else if (link->card_id == PRODID_FUJITSU_MBH10302) 
382                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
383                    but these are MBH10304 based card. */ 
384                 cardtype = MBH10304;
385             else if (link->card_id == PRODID_FUJITSU_MBH10304)
386                 cardtype = MBH10304;
387             else
388                 cardtype = LA501;
389             break;
390         default:
391             cardtype = MBH10304;
392         }
393     } else {
394         /* old type card */
395         switch (link->manf_id) {
396         case MANFID_FUJITSU:
397             if (link->card_id == PRODID_FUJITSU_MBH10304) {
398                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
399                 link->config_index = 0x20;
400             } else {
401                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
402                 link->config_index = 1;
403             }
404             break;
405         case MANFID_UNGERMANN:
406             cardtype = UNGERMANN;
407             break;
408         default:
409             cardtype = MBH10302;
410             link->config_index = 1;
411         }
412     }
413 
414     if (link->resource[1]->end != 0) {
415         ret = mfc_try_io_port(link);
416         if (ret != 0) goto failed;
417     } else if (cardtype == UNGERMANN) {
418         ret = ungermann_try_io_port(link);
419         if (ret != 0) goto failed;
420     } else { 
421             ret = pcmcia_request_io(link);
422             if (ret)
423                     goto failed;
424     }
425     ret = pcmcia_request_irq(link, fjn_interrupt);
426     if (ret)
427             goto failed;
428     ret = pcmcia_enable_device(link);
429     if (ret)
430             goto failed;
431 
432     dev->irq = link->irq;
433     dev->base_addr = link->resource[0]->start;
434 
435     if (resource_size(link->resource[1]) != 0) {
436         ret = fmvj18x_setup_mfc(link);
437         if (ret != 0) goto failed;
438     }
439 
440     ioaddr = dev->base_addr;
441 
442     /* Reset controller */
443     if (sram_config == 0) 
444         outb(CONFIG0_RST, ioaddr + CONFIG_0);
445     else
446         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
447 
448     /* Power On chip and select bank 0 */
449     if (cardtype == MBH10302)
450         outb(BANK_0, ioaddr + CONFIG_1);
451     else
452         outb(BANK_0U, ioaddr + CONFIG_1);
453     
454     /* Set hardware address */
455     switch (cardtype) {
456     case MBH10304:
457     case TDK:
458     case LA501:
459     case CONTEC:
460     case NEC:
461     case KME:
462         if (cardtype == MBH10304) {
463             card_name = "FMV-J182";
464 
465             len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
466             if (len < 11) {
467                     kfree(buf);
468                     goto failed;
469             }
470             /* Read MACID from CIS */
471             for (i = 0; i < 6; i++)
472                     dev->dev_addr[i] = buf[i + 5];
473             kfree(buf);
474         } else {
475             if (pcmcia_get_mac_from_cis(link, dev))
476                 goto failed;
477             if( cardtype == TDK ) {
478                 card_name = "TDK LAK-CD021";
479             } else if( cardtype == LA501 ) {
480                 card_name = "LA501";
481             } else if( cardtype == NEC ) {
482                 card_name = "PK-UG-J001";
483             } else if( cardtype == KME ) {
484                 card_name = "Panasonic";
485             } else {
486                 card_name = "C-NET(PC)C";
487             }
488         }
489         break;
490     case UNGERMANN:
491         /* Read MACID from register */
492         for (i = 0; i < 6; i++) 
493             dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
494         card_name = "Access/CARD";
495         break;
496     case XXX10304:
497         /* Read MACID from Buggy CIS */
498         if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
499             pr_notice("unable to read hardware net address\n");
500             goto failed;
501         }
502         for (i = 0 ; i < 6; i++) {
503             dev->dev_addr[i] = buggybuf[i];
504         }
505         card_name = "FMV-J182";
506         break;
507     case MBH10302:
508     default:
509         /* Read MACID from register */
510         for (i = 0; i < 6; i++) 
511             dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
512         card_name = "FMV-J181";
513         break;
514     }
515 
516     lp->cardtype = cardtype;
517     SET_NETDEV_DEV(dev, &link->dev);
518 
519     if (register_netdev(dev) != 0) {
520         pr_notice("register_netdev() failed\n");
521         goto failed;
522     }
523 
524     /* print current configuration */
525     netdev_info(dev, "%s, sram %s, port %#3lx, irq %d, hw_addr %pM\n",
526                 card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
527                 dev->base_addr, dev->irq, dev->dev_addr);
528 
529     return 0;
530     
531 failed:
532     fmvj18x_release(link);
533     return -ENODEV;
534 } /* fmvj18x_config */
535 /*====================================================================*/
536 
537 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
538 {
539     u_char __iomem *base;
540     int i, j;
541 
542     /* Allocate a small memory window */
543     link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
544     link->resource[2]->start = 0; link->resource[2]->end = 0;
545     i = pcmcia_request_window(link, link->resource[2], 0);
546     if (i != 0)
547         return -1;
548 
549     base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
550     pcmcia_map_mem_page(link, link->resource[2], 0);
551 
552     /*
553      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
554      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
555      *  'xx' is garbage.
556      *  'yy' is MAC address.
557     */ 
558     for (i = 0; i < 0x200; i++) {
559         if (readb(base+i*2) == 0x22) {  
560                 if (readb(base+(i-1)*2) == 0xff &&
561                     readb(base+(i+5)*2) == 0x04 &&
562                     readb(base+(i+6)*2) == 0x06 &&
563                     readb(base+(i+13)*2) == 0xff)
564                         break;
565         }
566     }
567 
568     if (i != 0x200) {
569         for (j = 0 ; j < 6; j++,i++) {
570             node_id[j] = readb(base+(i+7)*2);
571         }
572     }
573 
574     iounmap(base);
575     j = pcmcia_release_window(link, link->resource[2]);
576     return (i != 0x200) ? 0 : -1;
577 
578 } /* fmvj18x_get_hwinfo */
579 /*====================================================================*/
580 
581 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
582 {
583     int i;
584     struct net_device *dev = link->priv;
585     unsigned int ioaddr;
586     struct local_info *lp = netdev_priv(dev);
587 
588     /* Allocate a small memory window */
589     link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
590     link->resource[3]->start = link->resource[3]->end = 0;
591     i = pcmcia_request_window(link, link->resource[3], 0);
592     if (i != 0)
593         return -1;
594 
595     lp->base = ioremap(link->resource[3]->start,
596                        resource_size(link->resource[3]));
597     if (lp->base == NULL) {
598         netdev_notice(dev, "ioremap failed\n");
599         return -1;
600     }
601 
602     i = pcmcia_map_mem_page(link, link->resource[3], 0);
603     if (i != 0) {
604         iounmap(lp->base);
605         lp->base = NULL;
606         return -1;
607     }
608     
609     ioaddr = dev->base_addr;
610     writeb(0x47, lp->base+0x800);       /* Config Option Register of LAN */
611     writeb(0x0,  lp->base+0x802);       /* Config and Status Register */
612 
613     writeb(ioaddr & 0xff, lp->base+0x80a);        /* I/O Base(Low) of LAN */
614     writeb((ioaddr >> 8) & 0xff, lp->base+0x80c); /* I/O Base(High) of LAN */
615    
616     writeb(0x45, lp->base+0x820);       /* Config Option Register of Modem */
617     writeb(0x8,  lp->base+0x822);       /* Config and Status Register */
618 
619     return 0;
620 
621 }
622 /*====================================================================*/
623 
624 static void fmvj18x_release(struct pcmcia_device *link)
625 {
626 
627     struct net_device *dev = link->priv;
628     struct local_info *lp = netdev_priv(dev);
629     u_char __iomem *tmp;
630 
631     dev_dbg(&link->dev, "fmvj18x_release\n");
632 
633     if (lp->base != NULL) {
634         tmp = lp->base;
635         lp->base = NULL;    /* set NULL before iounmap */
636         iounmap(tmp);
637     }
638 
639     pcmcia_disable_device(link);
640 
641 }
642 
643 static int fmvj18x_suspend(struct pcmcia_device *link)
644 {
645         struct net_device *dev = link->priv;
646 
647         if (link->open)
648                 netif_device_detach(dev);
649 
650         return 0;
651 }
652 
653 static int fmvj18x_resume(struct pcmcia_device *link)
654 {
655         struct net_device *dev = link->priv;
656 
657         if (link->open) {
658                 fjn_reset(dev);
659                 netif_device_attach(dev);
660         }
661 
662         return 0;
663 }
664 
665 /*====================================================================*/
666 
667 static const struct pcmcia_device_id fmvj18x_ids[] = {
668         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
669         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
670         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
671         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
672         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
673         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
674         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
675         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
676         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
677         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
678         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
679         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
680         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
681         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
682         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
683         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
684         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
685         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
686         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
687         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
688         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
689         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
690         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
691         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0b05),
692         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
693         PCMCIA_DEVICE_NULL,
694 };
695 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
696 
697 static struct pcmcia_driver fmvj18x_cs_driver = {
698         .owner          = THIS_MODULE,
699         .name           = "fmvj18x_cs",
700         .probe          = fmvj18x_probe,
701         .remove         = fmvj18x_detach,
702         .id_table       = fmvj18x_ids,
703         .suspend        = fmvj18x_suspend,
704         .resume         = fmvj18x_resume,
705 };
706 module_pcmcia_driver(fmvj18x_cs_driver);
707 
708 /*====================================================================*/
709 
710 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
711 {
712     struct net_device *dev = dev_id;
713     struct local_info *lp = netdev_priv(dev);
714     unsigned int ioaddr;
715     unsigned short tx_stat, rx_stat;
716 
717     ioaddr = dev->base_addr;
718 
719     /* avoid multiple interrupts */
720     outw(0x0000, ioaddr + TX_INTR);
721 
722     /* wait for a while */
723     udelay(1);
724 
725     /* get status */
726     tx_stat = inb(ioaddr + TX_STATUS);
727     rx_stat = inb(ioaddr + RX_STATUS);
728 
729     /* clear status */
730     outb(tx_stat, ioaddr + TX_STATUS);
731     outb(rx_stat, ioaddr + RX_STATUS);
732     
733     pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
734     pr_debug("               tx_status %02x.\n", tx_stat);
735     
736     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
737         /* there is packet(s) in rx buffer */
738         fjn_rx(dev);
739     }
740     if (tx_stat & F_TMT_RDY) {
741         dev->stats.tx_packets += lp->sent ;
742         lp->sent = 0 ;
743         if (lp->tx_queue) {
744             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
745             lp->sent = lp->tx_queue ;
746             lp->tx_queue = 0;
747             lp->tx_queue_len = 0;
748             netif_trans_update(dev);
749         } else {
750             lp->tx_started = 0;
751         }
752         netif_wake_queue(dev);
753     }
754     pr_debug("%s: exiting interrupt,\n", dev->name);
755     pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
756 
757     outb(D_TX_INTR, ioaddr + TX_INTR);
758     outb(D_RX_INTR, ioaddr + RX_INTR);
759 
760     if (lp->base != NULL) {
761         /* Ack interrupt for multifunction card */
762         writeb(0x01, lp->base+0x802);
763         writeb(0x09, lp->base+0x822);
764     }
765 
766     return IRQ_HANDLED;
767 
768 } /* fjn_interrupt */
769 
770 /*====================================================================*/
771 
772 static void fjn_tx_timeout(struct net_device *dev)
773 {
774     struct local_info *lp = netdev_priv(dev);
775     unsigned int ioaddr = dev->base_addr;
776 
777     netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
778                   htons(inw(ioaddr + TX_STATUS)),
779                   inb(ioaddr + TX_STATUS) & F_TMT_RDY
780                   ? "IRQ conflict" : "network cable problem");
781     netdev_notice(dev, "timeout registers: %04x %04x %04x "
782                   "%04x %04x %04x %04x %04x.\n",
783                   htons(inw(ioaddr + 0)), htons(inw(ioaddr + 2)),
784                   htons(inw(ioaddr + 4)), htons(inw(ioaddr + 6)),
785                   htons(inw(ioaddr + 8)), htons(inw(ioaddr + 10)),
786                   htons(inw(ioaddr + 12)), htons(inw(ioaddr + 14)));
787     dev->stats.tx_errors++;
788     /* ToDo: We should try to restart the adaptor... */
789     local_irq_disable();
790     fjn_reset(dev);
791 
792     lp->tx_started = 0;
793     lp->tx_queue = 0;
794     lp->tx_queue_len = 0;
795     lp->sent = 0;
796     lp->open_time = jiffies;
797     local_irq_enable();
798     netif_wake_queue(dev);
799 }
800 
801 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
802                                         struct net_device *dev)
803 {
804     struct local_info *lp = netdev_priv(dev);
805     unsigned int ioaddr = dev->base_addr;
806     short length = skb->len;
807     
808     if (length < ETH_ZLEN)
809     {
810         if (skb_padto(skb, ETH_ZLEN))
811                 return NETDEV_TX_OK;
812         length = ETH_ZLEN;
813     }
814 
815     netif_stop_queue(dev);
816 
817     {
818         unsigned char *buf = skb->data;
819 
820         if (length > ETH_FRAME_LEN) {
821             netdev_notice(dev, "Attempting to send a large packet (%d bytes)\n",
822                           length);
823             return NETDEV_TX_BUSY;
824         }
825 
826         netdev_dbg(dev, "Transmitting a packet of length %lu\n",
827                    (unsigned long)skb->len);
828         dev->stats.tx_bytes += skb->len;
829 
830         /* Disable both interrupts. */
831         outw(0x0000, ioaddr + TX_INTR);
832 
833         /* wait for a while */
834         udelay(1);
835 
836         outw(length, ioaddr + DATAPORT);
837         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
838 
839         lp->tx_queue++;
840         lp->tx_queue_len += ((length+3) & ~1);
841 
842         if (lp->tx_started == 0) {
843             /* If the Tx is idle, always trigger a transmit. */
844             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
845             lp->sent = lp->tx_queue ;
846             lp->tx_queue = 0;
847             lp->tx_queue_len = 0;
848             lp->tx_started = 1;
849             netif_start_queue(dev);
850         } else {
851             if( sram_config == 0 ) {
852                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
853                     /* Yes, there is room for one more packet. */
854                     netif_start_queue(dev);
855             } else {
856                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) && 
857                                                 lp->tx_queue < 127 )
858                     /* Yes, there is room for one more packet. */
859                     netif_start_queue(dev);
860             }
861         }
862 
863         /* Re-enable interrupts */
864         outb(D_TX_INTR, ioaddr + TX_INTR);
865         outb(D_RX_INTR, ioaddr + RX_INTR);
866     }
867     dev_kfree_skb (skb);
868 
869     return NETDEV_TX_OK;
870 } /* fjn_start_xmit */
871 
872 /*====================================================================*/
873 
874 static void fjn_reset(struct net_device *dev)
875 {
876     struct local_info *lp = netdev_priv(dev);
877     unsigned int ioaddr = dev->base_addr;
878     int i;
879 
880     netdev_dbg(dev, "fjn_reset() called\n");
881 
882     /* Reset controller */
883     if( sram_config == 0 ) 
884         outb(CONFIG0_RST, ioaddr + CONFIG_0);
885     else
886         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
887 
888     /* Power On chip and select bank 0 */
889     if (lp->cardtype == MBH10302)
890         outb(BANK_0, ioaddr + CONFIG_1);
891     else
892         outb(BANK_0U, ioaddr + CONFIG_1);
893 
894     /* Set Tx modes */
895     outb(D_TX_MODE, ioaddr + TX_MODE);
896     /* set Rx modes */
897     outb(ID_MATCHED, ioaddr + RX_MODE);
898 
899     /* Set hardware address */
900     for (i = 0; i < 6; i++) 
901         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
902 
903     /* (re)initialize the multicast table */
904     set_rx_mode(dev);
905 
906     /* Switch to bank 2 (runtime mode) */
907     if (lp->cardtype == MBH10302)
908         outb(BANK_2, ioaddr + CONFIG_1);
909     else
910         outb(BANK_2U, ioaddr + CONFIG_1);
911 
912     /* set 16col ctrl bits */
913     if( lp->cardtype == TDK || lp->cardtype == CONTEC) 
914         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
915     else
916         outb(AUTO_MODE, ioaddr + COL_CTRL);
917 
918     /* clear Reserved Regs */
919     outb(0x00, ioaddr + BMPR12);
920     outb(0x00, ioaddr + BMPR13);
921 
922     /* reset Skip packet reg. */
923     outb(0x01, ioaddr + RX_SKIP);
924 
925     /* Enable Tx and Rx */
926     if( sram_config == 0 )
927         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
928     else
929         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
930 
931     /* Init receive pointer ? */
932     inw(ioaddr + DATAPORT);
933     inw(ioaddr + DATAPORT);
934 
935     /* Clear all status */
936     outb(0xff, ioaddr + TX_STATUS);
937     outb(0xff, ioaddr + RX_STATUS);
938 
939     if (lp->cardtype == MBH10302)
940         outb(INTR_OFF, ioaddr + LAN_CTRL);
941 
942     /* Turn on Rx interrupts */
943     outb(D_TX_INTR, ioaddr + TX_INTR);
944     outb(D_RX_INTR, ioaddr + RX_INTR);
945 
946     /* Turn on interrupts from LAN card controller */
947     if (lp->cardtype == MBH10302)
948         outb(INTR_ON, ioaddr + LAN_CTRL);
949 } /* fjn_reset */
950 
951 /*====================================================================*/
952 
953 static void fjn_rx(struct net_device *dev)
954 {
955     unsigned int ioaddr = dev->base_addr;
956     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
957 
958     pr_debug("%s: in rx_packet(), rx_status %02x.\n",
959           dev->name, inb(ioaddr + RX_STATUS));
960 
961     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
962         u_short status = inw(ioaddr + DATAPORT);
963 
964         netdev_dbg(dev, "Rxing packet mode %02x status %04x.\n",
965                    inb(ioaddr + RX_MODE), status);
966 #ifndef final_version
967         if (status == 0) {
968             outb(F_SKP_PKT, ioaddr + RX_SKIP);
969             break;
970         }
971 #endif
972         if ((status & 0xF0) != 0x20) {  /* There was an error. */
973             dev->stats.rx_errors++;
974             if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
975             if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
976             if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
977             if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
978         } else {
979             u_short pkt_len = inw(ioaddr + DATAPORT);
980             /* Malloc up new buffer. */
981             struct sk_buff *skb;
982 
983             if (pkt_len > 1550) {
984                 netdev_notice(dev, "The FMV-18x claimed a very large packet, size %d\n",
985                               pkt_len);
986                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
987                 dev->stats.rx_errors++;
988                 break;
989             }
990             skb = netdev_alloc_skb(dev, pkt_len + 2);
991             if (skb == NULL) {
992                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
993                 dev->stats.rx_dropped++;
994                 break;
995             }
996 
997             skb_reserve(skb, 2);
998             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
999                  (pkt_len + 1) >> 1);
1000             skb->protocol = eth_type_trans(skb, dev);
1001 
1002             {
1003                 int i;
1004                 pr_debug("%s: Rxed packet of length %d: ",
1005                         dev->name, pkt_len);
1006                 for (i = 0; i < 14; i++)
1007                         pr_debug(" %02x", skb->data[i]);
1008                 pr_debug(".\n");
1009             }
1010 
1011             netif_rx(skb);
1012             dev->stats.rx_packets++;
1013             dev->stats.rx_bytes += pkt_len;
1014         }
1015         if (--boguscount <= 0)
1016             break;
1017     }
1018 
1019     /* If any worth-while packets have been received, dev_rint()
1020            has done a netif_wake_queue() for us and will work on them
1021            when we get to the bottom-half routine. */
1022 /*
1023     if (lp->cardtype != TDK) {
1024         int i;
1025         for (i = 0; i < 20; i++) {
1026             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1027                 break;
1028             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1029             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1030         }
1031 
1032         if (i > 0)
1033             pr_debug("%s: Exint Rx packet with mode %02x after "
1034                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1035     }
1036 */
1037 } /* fjn_rx */
1038 
1039 /*====================================================================*/
1040 
1041 static void netdev_get_drvinfo(struct net_device *dev,
1042                                struct ethtool_drvinfo *info)
1043 {
1044         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1045         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1046         snprintf(info->bus_info, sizeof(info->bus_info),
1047                 "PCMCIA 0x%lx", dev->base_addr);
1048 }
1049 
1050 static const struct ethtool_ops netdev_ethtool_ops = {
1051         .get_drvinfo            = netdev_get_drvinfo,
1052 };
1053 
1054 static int fjn_config(struct net_device *dev, struct ifmap *map){
1055     return 0;
1056 }
1057 
1058 static int fjn_open(struct net_device *dev)
1059 {
1060     struct local_info *lp = netdev_priv(dev);
1061     struct pcmcia_device *link = lp->p_dev;
1062 
1063     pr_debug("fjn_open('%s').\n", dev->name);
1064 
1065     if (!pcmcia_dev_present(link))
1066         return -ENODEV;
1067     
1068     link->open++;
1069     
1070     fjn_reset(dev);
1071     
1072     lp->tx_started = 0;
1073     lp->tx_queue = 0;
1074     lp->tx_queue_len = 0;
1075     lp->open_time = jiffies;
1076     netif_start_queue(dev);
1077     
1078     return 0;
1079 } /* fjn_open */
1080 
1081 /*====================================================================*/
1082 
1083 static int fjn_close(struct net_device *dev)
1084 {
1085     struct local_info *lp = netdev_priv(dev);
1086     struct pcmcia_device *link = lp->p_dev;
1087     unsigned int ioaddr = dev->base_addr;
1088 
1089     pr_debug("fjn_close('%s').\n", dev->name);
1090 
1091     lp->open_time = 0;
1092     netif_stop_queue(dev);
1093 
1094     /* Set configuration register 0 to disable Tx and Rx. */
1095     if( sram_config == 0 ) 
1096         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1097     else
1098         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1099 
1100     /* Update the statistics -- ToDo. */
1101 
1102     /* Power-down the chip.  Green, green, green! */
1103     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1104 
1105     /* Set the ethernet adaptor disable IRQ */
1106     if (lp->cardtype == MBH10302)
1107         outb(INTR_OFF, ioaddr + LAN_CTRL);
1108 
1109     link->open--;
1110 
1111     return 0;
1112 } /* fjn_close */
1113 
1114 /*====================================================================*/
1115 
1116 /*
1117   Set the multicast/promiscuous mode for this adaptor.
1118 */
1119 
1120 static void set_rx_mode(struct net_device *dev)
1121 {
1122     unsigned int ioaddr = dev->base_addr;
1123     u_char mc_filter[8];                 /* Multicast hash filter */
1124     u_long flags;
1125     int i;
1126     
1127     int saved_bank;
1128     int saved_config_0 = inb(ioaddr + CONFIG_0);
1129      
1130     local_irq_save(flags); 
1131 
1132     /* Disable Tx and Rx */
1133     if (sram_config == 0) 
1134         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1135     else
1136         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1137 
1138     if (dev->flags & IFF_PROMISC) {
1139         memset(mc_filter, 0xff, sizeof(mc_filter));
1140         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1141     } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1142                (dev->flags & IFF_ALLMULTI)) {
1143         /* Too many to filter perfectly -- accept all multicasts. */
1144         memset(mc_filter, 0xff, sizeof(mc_filter));
1145         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1146     } else if (netdev_mc_empty(dev)) {
1147         memset(mc_filter, 0x00, sizeof(mc_filter));
1148         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1149     } else {
1150         struct netdev_hw_addr *ha;
1151 
1152         memset(mc_filter, 0, sizeof(mc_filter));
1153         netdev_for_each_mc_addr(ha, dev) {
1154             unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1155             mc_filter[bit >> 3] |= (1 << (bit & 7));
1156         }
1157         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1158     }
1159 
1160     /* Switch to bank 1 and set the multicast table. */
1161     saved_bank = inb(ioaddr + CONFIG_1);
1162     outb(0xe4, ioaddr + CONFIG_1);
1163 
1164     for (i = 0; i < 8; i++)
1165         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1166     outb(saved_bank, ioaddr + CONFIG_1);
1167 
1168     outb(saved_config_0, ioaddr + CONFIG_0);
1169 
1170     local_irq_restore(flags);
1171 }
1172 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us