Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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 <asm/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_change_mtu         = eth_change_mtu,
229         .ndo_set_mac_address    = eth_mac_addr,
230         .ndo_validate_addr      = eth_validate_addr,
231 };
232 
233 static int fmvj18x_probe(struct pcmcia_device *link)
234 {
235     struct local_info *lp;
236     struct net_device *dev;
237 
238     dev_dbg(&link->dev, "fmvj18x_attach()\n");
239 
240     /* Make up a FMVJ18x specific data structure */
241     dev = alloc_etherdev(sizeof(struct local_info));
242     if (!dev)
243         return -ENOMEM;
244     lp = netdev_priv(dev);
245     link->priv = dev;
246     lp->p_dev = link;
247     lp->base = NULL;
248 
249     /* The io structure describes IO port mapping */
250     link->resource[0]->end = 32;
251     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
252 
253     /* General socket configuration */
254     link->config_flags |= CONF_ENABLE_IRQ;
255 
256     dev->netdev_ops = &fjn_netdev_ops;
257     dev->watchdog_timeo = TX_TIMEOUT;
258 
259     dev->ethtool_ops = &netdev_ethtool_ops;
260 
261     return fmvj18x_config(link);
262 } /* fmvj18x_attach */
263 
264 /*====================================================================*/
265 
266 static void fmvj18x_detach(struct pcmcia_device *link)
267 {
268     struct net_device *dev = link->priv;
269 
270     dev_dbg(&link->dev, "fmvj18x_detach\n");
271 
272     unregister_netdev(dev);
273 
274     fmvj18x_release(link);
275 
276     free_netdev(dev);
277 } /* fmvj18x_detach */
278 
279 /*====================================================================*/
280 
281 static int mfc_try_io_port(struct pcmcia_device *link)
282 {
283     int i, ret;
284     static const unsigned int serial_base[5] =
285         { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
286 
287     for (i = 0; i < 5; i++) {
288         link->resource[1]->start = serial_base[i];
289         link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
290         if (link->resource[1]->start == 0) {
291             link->resource[1]->end = 0;
292             pr_notice("out of resource for serial\n");
293         }
294         ret = pcmcia_request_io(link);
295         if (ret == 0)
296                 return ret;
297     }
298     return ret;
299 }
300 
301 static int ungermann_try_io_port(struct pcmcia_device *link)
302 {
303     int ret;
304     unsigned int ioaddr;
305     /*
306         Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
307         0x380,0x3c0 only for ioport.
308     */
309     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
310         link->resource[0]->start = ioaddr;
311         ret = pcmcia_request_io(link);
312         if (ret == 0) {
313             /* calculate ConfigIndex value */
314             link->config_index =
315                 ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
316             return ret;
317         }
318     }
319     return ret; /* RequestIO failed */
320 }
321 
322 static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
323 {
324         return 0; /* strange, but that's what the code did already before... */
325 }
326 
327 static int fmvj18x_config(struct pcmcia_device *link)
328 {
329     struct net_device *dev = link->priv;
330     struct local_info *lp = netdev_priv(dev);
331     int i, ret;
332     unsigned int ioaddr;
333     enum cardtype cardtype;
334     char *card_name = "unknown";
335     u8 *buf;
336     size_t len;
337     u_char buggybuf[32];
338 
339     dev_dbg(&link->dev, "fmvj18x_config\n");
340 
341     link->io_lines = 5;
342 
343     len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
344     kfree(buf);
345 
346     if (len) {
347         /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
348         ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
349         if (ret != 0)
350                 goto failed;
351 
352         switch (link->manf_id) {
353         case MANFID_TDK:
354             cardtype = TDK;
355             if (link->card_id == PRODID_TDK_GN3410 ||
356                 link->card_id == PRODID_TDK_NP9610 ||
357                 link->card_id == PRODID_TDK_MN3200) {
358                 /* MultiFunction Card */
359                 link->config_base = 0x800;
360                 link->config_index = 0x47;
361                 link->resource[1]->end = 8;
362             }
363             break;
364         case MANFID_NEC:
365             cardtype = NEC; /* MultiFunction Card */
366             link->config_base = 0x800;
367             link->config_index = 0x47;
368             link->resource[1]->end = 8;
369             break;
370         case MANFID_KME:
371             cardtype = KME; /* MultiFunction Card */
372             link->config_base = 0x800;
373             link->config_index = 0x47;
374             link->resource[1]->end = 8;
375             break;
376         case MANFID_CONTEC:
377             cardtype = CONTEC;
378             break;
379         case MANFID_FUJITSU:
380             if (link->config_base == 0x0fe0)
381                 cardtype = MBH10302;
382             else if (link->card_id == PRODID_FUJITSU_MBH10302) 
383                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
384                    but these are MBH10304 based card. */ 
385                 cardtype = MBH10304;
386             else if (link->card_id == PRODID_FUJITSU_MBH10304)
387                 cardtype = MBH10304;
388             else
389                 cardtype = LA501;
390             break;
391         default:
392             cardtype = MBH10304;
393         }
394     } else {
395         /* old type card */
396         switch (link->manf_id) {
397         case MANFID_FUJITSU:
398             if (link->card_id == PRODID_FUJITSU_MBH10304) {
399                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
400                 link->config_index = 0x20;
401             } else {
402                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
403                 link->config_index = 1;
404             }
405             break;
406         case MANFID_UNGERMANN:
407             cardtype = UNGERMANN;
408             break;
409         default:
410             cardtype = MBH10302;
411             link->config_index = 1;
412         }
413     }
414 
415     if (link->resource[1]->end != 0) {
416         ret = mfc_try_io_port(link);
417         if (ret != 0) goto failed;
418     } else if (cardtype == UNGERMANN) {
419         ret = ungermann_try_io_port(link);
420         if (ret != 0) goto failed;
421     } else { 
422             ret = pcmcia_request_io(link);
423             if (ret)
424                     goto failed;
425     }
426     ret = pcmcia_request_irq(link, fjn_interrupt);
427     if (ret)
428             goto failed;
429     ret = pcmcia_enable_device(link);
430     if (ret)
431             goto failed;
432 
433     dev->irq = link->irq;
434     dev->base_addr = link->resource[0]->start;
435 
436     if (resource_size(link->resource[1]) != 0) {
437         ret = fmvj18x_setup_mfc(link);
438         if (ret != 0) goto failed;
439     }
440 
441     ioaddr = dev->base_addr;
442 
443     /* Reset controller */
444     if (sram_config == 0) 
445         outb(CONFIG0_RST, ioaddr + CONFIG_0);
446     else
447         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
448 
449     /* Power On chip and select bank 0 */
450     if (cardtype == MBH10302)
451         outb(BANK_0, ioaddr + CONFIG_1);
452     else
453         outb(BANK_0U, ioaddr + CONFIG_1);
454     
455     /* Set hardware address */
456     switch (cardtype) {
457     case MBH10304:
458     case TDK:
459     case LA501:
460     case CONTEC:
461     case NEC:
462     case KME:
463         if (cardtype == MBH10304) {
464             card_name = "FMV-J182";
465 
466             len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
467             if (len < 11) {
468                     kfree(buf);
469                     goto failed;
470             }
471             /* Read MACID from CIS */
472             for (i = 5; i < 11; i++)
473                     dev->dev_addr[i] = buf[i];
474             kfree(buf);
475         } else {
476             if (pcmcia_get_mac_from_cis(link, dev))
477                 goto failed;
478             if( cardtype == TDK ) {
479                 card_name = "TDK LAK-CD021";
480             } else if( cardtype == LA501 ) {
481                 card_name = "LA501";
482             } else if( cardtype == NEC ) {
483                 card_name = "PK-UG-J001";
484             } else if( cardtype == KME ) {
485                 card_name = "Panasonic";
486             } else {
487                 card_name = "C-NET(PC)C";
488             }
489         }
490         break;
491     case UNGERMANN:
492         /* Read MACID from register */
493         for (i = 0; i < 6; i++) 
494             dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
495         card_name = "Access/CARD";
496         break;
497     case XXX10304:
498         /* Read MACID from Buggy CIS */
499         if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
500             pr_notice("unable to read hardware net address\n");
501             goto failed;
502         }
503         for (i = 0 ; i < 6; i++) {
504             dev->dev_addr[i] = buggybuf[i];
505         }
506         card_name = "FMV-J182";
507         break;
508     case MBH10302:
509     default:
510         /* Read MACID from register */
511         for (i = 0; i < 6; i++) 
512             dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
513         card_name = "FMV-J181";
514         break;
515     }
516 
517     lp->cardtype = cardtype;
518     SET_NETDEV_DEV(dev, &link->dev);
519 
520     if (register_netdev(dev) != 0) {
521         pr_notice("register_netdev() failed\n");
522         goto failed;
523     }
524 
525     /* print current configuration */
526     netdev_info(dev, "%s, sram %s, port %#3lx, irq %d, hw_addr %pM\n",
527                 card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
528                 dev->base_addr, dev->irq, dev->dev_addr);
529 
530     return 0;
531     
532 failed:
533     fmvj18x_release(link);
534     return -ENODEV;
535 } /* fmvj18x_config */
536 /*====================================================================*/
537 
538 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
539 {
540     u_char __iomem *base;
541     int i, j;
542 
543     /* Allocate a small memory window */
544     link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
545     link->resource[2]->start = 0; link->resource[2]->end = 0;
546     i = pcmcia_request_window(link, link->resource[2], 0);
547     if (i != 0)
548         return -1;
549 
550     base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
551     pcmcia_map_mem_page(link, link->resource[2], 0);
552 
553     /*
554      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
555      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
556      *  'xx' is garbage.
557      *  'yy' is MAC address.
558     */ 
559     for (i = 0; i < 0x200; i++) {
560         if (readb(base+i*2) == 0x22) {  
561                 if (readb(base+(i-1)*2) == 0xff &&
562                     readb(base+(i+5)*2) == 0x04 &&
563                     readb(base+(i+6)*2) == 0x06 &&
564                     readb(base+(i+13)*2) == 0xff)
565                         break;
566         }
567     }
568 
569     if (i != 0x200) {
570         for (j = 0 ; j < 6; j++,i++) {
571             node_id[j] = readb(base+(i+7)*2);
572         }
573     }
574 
575     iounmap(base);
576     j = pcmcia_release_window(link, link->resource[2]);
577     return (i != 0x200) ? 0 : -1;
578 
579 } /* fmvj18x_get_hwinfo */
580 /*====================================================================*/
581 
582 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
583 {
584     int i;
585     struct net_device *dev = link->priv;
586     unsigned int ioaddr;
587     struct local_info *lp = netdev_priv(dev);
588 
589     /* Allocate a small memory window */
590     link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
591     link->resource[3]->start = link->resource[3]->end = 0;
592     i = pcmcia_request_window(link, link->resource[3], 0);
593     if (i != 0)
594         return -1;
595 
596     lp->base = ioremap(link->resource[3]->start,
597                        resource_size(link->resource[3]));
598     if (lp->base == NULL) {
599         netdev_notice(dev, "ioremap failed\n");
600         return -1;
601     }
602 
603     i = pcmcia_map_mem_page(link, link->resource[3], 0);
604     if (i != 0) {
605         iounmap(lp->base);
606         lp->base = NULL;
607         return -1;
608     }
609     
610     ioaddr = dev->base_addr;
611     writeb(0x47, lp->base+0x800);       /* Config Option Register of LAN */
612     writeb(0x0,  lp->base+0x802);       /* Config and Status Register */
613 
614     writeb(ioaddr & 0xff, lp->base+0x80a);        /* I/O Base(Low) of LAN */
615     writeb((ioaddr >> 8) & 0xff, lp->base+0x80c); /* I/O Base(High) of LAN */
616    
617     writeb(0x45, lp->base+0x820);       /* Config Option Register of Modem */
618     writeb(0x8,  lp->base+0x822);       /* Config and Status Register */
619 
620     return 0;
621 
622 }
623 /*====================================================================*/
624 
625 static void fmvj18x_release(struct pcmcia_device *link)
626 {
627 
628     struct net_device *dev = link->priv;
629     struct local_info *lp = netdev_priv(dev);
630     u_char __iomem *tmp;
631 
632     dev_dbg(&link->dev, "fmvj18x_release\n");
633 
634     if (lp->base != NULL) {
635         tmp = lp->base;
636         lp->base = NULL;    /* set NULL before iounmap */
637         iounmap(tmp);
638     }
639 
640     pcmcia_disable_device(link);
641 
642 }
643 
644 static int fmvj18x_suspend(struct pcmcia_device *link)
645 {
646         struct net_device *dev = link->priv;
647 
648         if (link->open)
649                 netif_device_detach(dev);
650 
651         return 0;
652 }
653 
654 static int fmvj18x_resume(struct pcmcia_device *link)
655 {
656         struct net_device *dev = link->priv;
657 
658         if (link->open) {
659                 fjn_reset(dev);
660                 netif_device_attach(dev);
661         }
662 
663         return 0;
664 }
665 
666 /*====================================================================*/
667 
668 static const struct pcmcia_device_id fmvj18x_ids[] = {
669         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
670         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
671         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
672         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
673         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
674         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
675         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
676         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
677         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
678         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
679         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
680         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
681         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
682         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
683         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
684         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
685         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
686         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
687         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
688         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
689         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
690         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
691         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
692         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0b05),
693         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
694         PCMCIA_DEVICE_NULL,
695 };
696 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
697 
698 static struct pcmcia_driver fmvj18x_cs_driver = {
699         .owner          = THIS_MODULE,
700         .name           = "fmvj18x_cs",
701         .probe          = fmvj18x_probe,
702         .remove         = fmvj18x_detach,
703         .id_table       = fmvj18x_ids,
704         .suspend        = fmvj18x_suspend,
705         .resume         = fmvj18x_resume,
706 };
707 module_pcmcia_driver(fmvj18x_cs_driver);
708 
709 /*====================================================================*/
710 
711 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
712 {
713     struct net_device *dev = dev_id;
714     struct local_info *lp = netdev_priv(dev);
715     unsigned int ioaddr;
716     unsigned short tx_stat, rx_stat;
717 
718     ioaddr = dev->base_addr;
719 
720     /* avoid multiple interrupts */
721     outw(0x0000, ioaddr + TX_INTR);
722 
723     /* wait for a while */
724     udelay(1);
725 
726     /* get status */
727     tx_stat = inb(ioaddr + TX_STATUS);
728     rx_stat = inb(ioaddr + RX_STATUS);
729 
730     /* clear status */
731     outb(tx_stat, ioaddr + TX_STATUS);
732     outb(rx_stat, ioaddr + RX_STATUS);
733     
734     pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
735     pr_debug("               tx_status %02x.\n", tx_stat);
736     
737     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
738         /* there is packet(s) in rx buffer */
739         fjn_rx(dev);
740     }
741     if (tx_stat & F_TMT_RDY) {
742         dev->stats.tx_packets += lp->sent ;
743         lp->sent = 0 ;
744         if (lp->tx_queue) {
745             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
746             lp->sent = lp->tx_queue ;
747             lp->tx_queue = 0;
748             lp->tx_queue_len = 0;
749             dev->trans_start = jiffies;
750         } else {
751             lp->tx_started = 0;
752         }
753         netif_wake_queue(dev);
754     }
755     pr_debug("%s: exiting interrupt,\n", dev->name);
756     pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
757 
758     outb(D_TX_INTR, ioaddr + TX_INTR);
759     outb(D_RX_INTR, ioaddr + RX_INTR);
760 
761     if (lp->base != NULL) {
762         /* Ack interrupt for multifunction card */
763         writeb(0x01, lp->base+0x802);
764         writeb(0x09, lp->base+0x822);
765     }
766 
767     return IRQ_HANDLED;
768 
769 } /* fjn_interrupt */
770 
771 /*====================================================================*/
772 
773 static void fjn_tx_timeout(struct net_device *dev)
774 {
775     struct local_info *lp = netdev_priv(dev);
776     unsigned int ioaddr = dev->base_addr;
777 
778     netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
779                   htons(inw(ioaddr + TX_STATUS)),
780                   inb(ioaddr + TX_STATUS) & F_TMT_RDY
781                   ? "IRQ conflict" : "network cable problem");
782     netdev_notice(dev, "timeout registers: %04x %04x %04x "
783                   "%04x %04x %04x %04x %04x.\n",
784                   htons(inw(ioaddr + 0)), htons(inw(ioaddr + 2)),
785                   htons(inw(ioaddr + 4)), htons(inw(ioaddr + 6)),
786                   htons(inw(ioaddr + 8)), htons(inw(ioaddr + 10)),
787                   htons(inw(ioaddr + 12)), htons(inw(ioaddr + 14)));
788     dev->stats.tx_errors++;
789     /* ToDo: We should try to restart the adaptor... */
790     local_irq_disable();
791     fjn_reset(dev);
792 
793     lp->tx_started = 0;
794     lp->tx_queue = 0;
795     lp->tx_queue_len = 0;
796     lp->sent = 0;
797     lp->open_time = jiffies;
798     local_irq_enable();
799     netif_wake_queue(dev);
800 }
801 
802 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
803                                         struct net_device *dev)
804 {
805     struct local_info *lp = netdev_priv(dev);
806     unsigned int ioaddr = dev->base_addr;
807     short length = skb->len;
808     
809     if (length < ETH_ZLEN)
810     {
811         if (skb_padto(skb, ETH_ZLEN))
812                 return NETDEV_TX_OK;
813         length = ETH_ZLEN;
814     }
815 
816     netif_stop_queue(dev);
817 
818     {
819         unsigned char *buf = skb->data;
820 
821         if (length > ETH_FRAME_LEN) {
822             netdev_notice(dev, "Attempting to send a large packet (%d bytes)\n",
823                           length);
824             return NETDEV_TX_BUSY;
825         }
826 
827         netdev_dbg(dev, "Transmitting a packet of length %lu\n",
828                    (unsigned long)skb->len);
829         dev->stats.tx_bytes += skb->len;
830 
831         /* Disable both interrupts. */
832         outw(0x0000, ioaddr + TX_INTR);
833 
834         /* wait for a while */
835         udelay(1);
836 
837         outw(length, ioaddr + DATAPORT);
838         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
839 
840         lp->tx_queue++;
841         lp->tx_queue_len += ((length+3) & ~1);
842 
843         if (lp->tx_started == 0) {
844             /* If the Tx is idle, always trigger a transmit. */
845             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
846             lp->sent = lp->tx_queue ;
847             lp->tx_queue = 0;
848             lp->tx_queue_len = 0;
849             lp->tx_started = 1;
850             netif_start_queue(dev);
851         } else {
852             if( sram_config == 0 ) {
853                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
854                     /* Yes, there is room for one more packet. */
855                     netif_start_queue(dev);
856             } else {
857                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) && 
858                                                 lp->tx_queue < 127 )
859                     /* Yes, there is room for one more packet. */
860                     netif_start_queue(dev);
861             }
862         }
863 
864         /* Re-enable interrupts */
865         outb(D_TX_INTR, ioaddr + TX_INTR);
866         outb(D_RX_INTR, ioaddr + RX_INTR);
867     }
868     dev_kfree_skb (skb);
869 
870     return NETDEV_TX_OK;
871 } /* fjn_start_xmit */
872 
873 /*====================================================================*/
874 
875 static void fjn_reset(struct net_device *dev)
876 {
877     struct local_info *lp = netdev_priv(dev);
878     unsigned int ioaddr = dev->base_addr;
879     int i;
880 
881     netdev_dbg(dev, "fjn_reset() called\n");
882 
883     /* Reset controller */
884     if( sram_config == 0 ) 
885         outb(CONFIG0_RST, ioaddr + CONFIG_0);
886     else
887         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
888 
889     /* Power On chip and select bank 0 */
890     if (lp->cardtype == MBH10302)
891         outb(BANK_0, ioaddr + CONFIG_1);
892     else
893         outb(BANK_0U, ioaddr + CONFIG_1);
894 
895     /* Set Tx modes */
896     outb(D_TX_MODE, ioaddr + TX_MODE);
897     /* set Rx modes */
898     outb(ID_MATCHED, ioaddr + RX_MODE);
899 
900     /* Set hardware address */
901     for (i = 0; i < 6; i++) 
902         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
903 
904     /* (re)initialize the multicast table */
905     set_rx_mode(dev);
906 
907     /* Switch to bank 2 (runtime mode) */
908     if (lp->cardtype == MBH10302)
909         outb(BANK_2, ioaddr + CONFIG_1);
910     else
911         outb(BANK_2U, ioaddr + CONFIG_1);
912 
913     /* set 16col ctrl bits */
914     if( lp->cardtype == TDK || lp->cardtype == CONTEC) 
915         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
916     else
917         outb(AUTO_MODE, ioaddr + COL_CTRL);
918 
919     /* clear Reserved Regs */
920     outb(0x00, ioaddr + BMPR12);
921     outb(0x00, ioaddr + BMPR13);
922 
923     /* reset Skip packet reg. */
924     outb(0x01, ioaddr + RX_SKIP);
925 
926     /* Enable Tx and Rx */
927     if( sram_config == 0 )
928         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
929     else
930         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
931 
932     /* Init receive pointer ? */
933     inw(ioaddr + DATAPORT);
934     inw(ioaddr + DATAPORT);
935 
936     /* Clear all status */
937     outb(0xff, ioaddr + TX_STATUS);
938     outb(0xff, ioaddr + RX_STATUS);
939 
940     if (lp->cardtype == MBH10302)
941         outb(INTR_OFF, ioaddr + LAN_CTRL);
942 
943     /* Turn on Rx interrupts */
944     outb(D_TX_INTR, ioaddr + TX_INTR);
945     outb(D_RX_INTR, ioaddr + RX_INTR);
946 
947     /* Turn on interrupts from LAN card controller */
948     if (lp->cardtype == MBH10302)
949         outb(INTR_ON, ioaddr + LAN_CTRL);
950 } /* fjn_reset */
951 
952 /*====================================================================*/
953 
954 static void fjn_rx(struct net_device *dev)
955 {
956     unsigned int ioaddr = dev->base_addr;
957     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
958 
959     pr_debug("%s: in rx_packet(), rx_status %02x.\n",
960           dev->name, inb(ioaddr + RX_STATUS));
961 
962     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
963         u_short status = inw(ioaddr + DATAPORT);
964 
965         netdev_dbg(dev, "Rxing packet mode %02x status %04x.\n",
966                    inb(ioaddr + RX_MODE), status);
967 #ifndef final_version
968         if (status == 0) {
969             outb(F_SKP_PKT, ioaddr + RX_SKIP);
970             break;
971         }
972 #endif
973         if ((status & 0xF0) != 0x20) {  /* There was an error. */
974             dev->stats.rx_errors++;
975             if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
976             if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
977             if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
978             if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
979         } else {
980             u_short pkt_len = inw(ioaddr + DATAPORT);
981             /* Malloc up new buffer. */
982             struct sk_buff *skb;
983 
984             if (pkt_len > 1550) {
985                 netdev_notice(dev, "The FMV-18x claimed a very large packet, size %d\n",
986                               pkt_len);
987                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
988                 dev->stats.rx_errors++;
989                 break;
990             }
991             skb = netdev_alloc_skb(dev, pkt_len + 2);
992             if (skb == NULL) {
993                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
994                 dev->stats.rx_dropped++;
995                 break;
996             }
997 
998             skb_reserve(skb, 2);
999             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1000                  (pkt_len + 1) >> 1);
1001             skb->protocol = eth_type_trans(skb, dev);
1002 
1003             {
1004                 int i;
1005                 pr_debug("%s: Rxed packet of length %d: ",
1006                         dev->name, pkt_len);
1007                 for (i = 0; i < 14; i++)
1008                         pr_debug(" %02x", skb->data[i]);
1009                 pr_debug(".\n");
1010             }
1011 
1012             netif_rx(skb);
1013             dev->stats.rx_packets++;
1014             dev->stats.rx_bytes += pkt_len;
1015         }
1016         if (--boguscount <= 0)
1017             break;
1018     }
1019 
1020     /* If any worth-while packets have been received, dev_rint()
1021            has done a netif_wake_queue() for us and will work on them
1022            when we get to the bottom-half routine. */
1023 /*
1024     if (lp->cardtype != TDK) {
1025         int i;
1026         for (i = 0; i < 20; i++) {
1027             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1028                 break;
1029             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1030             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1031         }
1032 
1033         if (i > 0)
1034             pr_debug("%s: Exint Rx packet with mode %02x after "
1035                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1036     }
1037 */
1038 } /* fjn_rx */
1039 
1040 /*====================================================================*/
1041 
1042 static void netdev_get_drvinfo(struct net_device *dev,
1043                                struct ethtool_drvinfo *info)
1044 {
1045         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1046         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1047         snprintf(info->bus_info, sizeof(info->bus_info),
1048                 "PCMCIA 0x%lx", dev->base_addr);
1049 }
1050 
1051 static const struct ethtool_ops netdev_ethtool_ops = {
1052         .get_drvinfo            = netdev_get_drvinfo,
1053 };
1054 
1055 static int fjn_config(struct net_device *dev, struct ifmap *map){
1056     return 0;
1057 }
1058 
1059 static int fjn_open(struct net_device *dev)
1060 {
1061     struct local_info *lp = netdev_priv(dev);
1062     struct pcmcia_device *link = lp->p_dev;
1063 
1064     pr_debug("fjn_open('%s').\n", dev->name);
1065 
1066     if (!pcmcia_dev_present(link))
1067         return -ENODEV;
1068     
1069     link->open++;
1070     
1071     fjn_reset(dev);
1072     
1073     lp->tx_started = 0;
1074     lp->tx_queue = 0;
1075     lp->tx_queue_len = 0;
1076     lp->open_time = jiffies;
1077     netif_start_queue(dev);
1078     
1079     return 0;
1080 } /* fjn_open */
1081 
1082 /*====================================================================*/
1083 
1084 static int fjn_close(struct net_device *dev)
1085 {
1086     struct local_info *lp = netdev_priv(dev);
1087     struct pcmcia_device *link = lp->p_dev;
1088     unsigned int ioaddr = dev->base_addr;
1089 
1090     pr_debug("fjn_close('%s').\n", dev->name);
1091 
1092     lp->open_time = 0;
1093     netif_stop_queue(dev);
1094 
1095     /* Set configuration register 0 to disable Tx and Rx. */
1096     if( sram_config == 0 ) 
1097         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1098     else
1099         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1100 
1101     /* Update the statistics -- ToDo. */
1102 
1103     /* Power-down the chip.  Green, green, green! */
1104     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1105 
1106     /* Set the ethernet adaptor disable IRQ */
1107     if (lp->cardtype == MBH10302)
1108         outb(INTR_OFF, ioaddr + LAN_CTRL);
1109 
1110     link->open--;
1111 
1112     return 0;
1113 } /* fjn_close */
1114 
1115 /*====================================================================*/
1116 
1117 /*
1118   Set the multicast/promiscuous mode for this adaptor.
1119 */
1120 
1121 static void set_rx_mode(struct net_device *dev)
1122 {
1123     unsigned int ioaddr = dev->base_addr;
1124     u_char mc_filter[8];                 /* Multicast hash filter */
1125     u_long flags;
1126     int i;
1127     
1128     int saved_bank;
1129     int saved_config_0 = inb(ioaddr + CONFIG_0);
1130      
1131     local_irq_save(flags); 
1132 
1133     /* Disable Tx and Rx */
1134     if (sram_config == 0) 
1135         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1136     else
1137         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1138 
1139     if (dev->flags & IFF_PROMISC) {
1140         memset(mc_filter, 0xff, sizeof(mc_filter));
1141         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1142     } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1143                (dev->flags & IFF_ALLMULTI)) {
1144         /* Too many to filter perfectly -- accept all multicasts. */
1145         memset(mc_filter, 0xff, sizeof(mc_filter));
1146         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1147     } else if (netdev_mc_empty(dev)) {
1148         memset(mc_filter, 0x00, sizeof(mc_filter));
1149         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1150     } else {
1151         struct netdev_hw_addr *ha;
1152 
1153         memset(mc_filter, 0, sizeof(mc_filter));
1154         netdev_for_each_mc_addr(ha, dev) {
1155             unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1156             mc_filter[bit >> 3] |= (1 << (bit & 7));
1157         }
1158         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1159     }
1160 
1161     /* Switch to bank 1 and set the multicast table. */
1162     saved_bank = inb(ioaddr + CONFIG_1);
1163     outb(0xe4, ioaddr + CONFIG_1);
1164 
1165     for (i = 0; i < 8; i++)
1166         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1167     outb(saved_bank, ioaddr + CONFIG_1);
1168 
1169     outb(saved_config_0, ioaddr + CONFIG_0);
1170 
1171     local_irq_restore(flags);
1172 }
1173 

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