开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pcnet_cs.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：48k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pcnet_cs.c：源码内容
  1. /*======================================================================
  3.     A PCMCIA ethernet driver for NS8390-based cards
  5.     This driver supports the D-Link DE-650 and Linksys EthernetCard
  6.     cards, the newer D-Link and Linksys combo cards, Accton EN2212
  7.     cards, the RPTI EP400, and the PreMax PE-200 in non-shared-memory
  8.     mode, and the IBM Credit Card Adapter, the NE4100, the Thomas
  9.     Conrad ethernet card, and the Kingston KNE-PCM/x in shared-memory
  10.     mode.  It will also handle the Socket EA card in either mode.
  12.     Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
  14.     pcnet_cs.c 1.144 2001/11/07 04:06:56
  15.     
  16.     The network driver code is based on Donald Becker's NE2000 code:
  18.     Written 1992,1993 by Donald Becker.
  19.     Copyright 1993 United States Government as represented by the
  20.     Director, National Security Agency.  This software may be used and
  21.     distributed according to the terms of the GNU General Public License,
  22.     incorporated herein by reference.
  23.     Donald Becker may be reached at becker@scyld.com
  25.     Based also on Keith Moore's changes to Don Becker's code, for IBM
  26.     CCAE support.  Drivers merged back together, and shared-memory
  27.     Socket EA support added, by Ken Raeburn, September 1995.
  29. ======================================================================*/
  31. #include <linux/kernel.h>
  32. #include <linux/module.h>
  33. #include <linux/init.h>
  34. #include <linux/sched.h>
  35. #include <linux/ptrace.h>
  36. #include <linux/slab.h>
  37. #include <linux/string.h>
  38. #include <linux/timer.h>
  39. #include <linux/delay.h>
  40. #include <asm/io.h>
  41. #include <asm/system.h>
  42. #include <asm/byteorder.h>
  44. #include <linux/netdevice.h>
  45. #include <../drivers/net/8390.h>
  47. #include <pcmcia/version.h>
  48. #include <pcmcia/cs_types.h>
  49. #include <pcmcia/cs.h>
  50. #include <pcmcia/cistpl.h>
  51. #include <pcmcia/ciscode.h>
  52. #include <pcmcia/ds.h>
  53. #include <pcmcia/cisreg.h>
  55. #define PCNET_CMD 0x00
  56. #define PCNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */
  57. #define PCNET_RESET 0x1f /* Issue a read to reset, a write to clear. */
  58. #define PCNET_MISC 0x18 /* For IBM CCAE and Socket EA cards */
  60. #define PCNET_START_PG 0x40 /* First page of TX buffer */
  61. #define PCNET_STOP_PG 0x80 /* Last page +1 of RX ring */
  63. /* Socket EA cards have a larger packet buffer */
  64. #define SOCKET_START_PG 0x01
  65. #define SOCKET_STOP_PG 0xff
  67. #define PCNET_RDC_TIMEOUT 0x02 /* Max wait in jiffies for Tx RDC */
  69. static char *if_names[] = { "auto", "10baseT", "10base2"};
  71. #ifdef PCMCIA_DEBUG
  72. static int pc_debug = PCMCIA_DEBUG;
  73. MODULE_PARM(pc_debug, "i");
  74. #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  75. static char *version =
  76. "pcnet_cs.c 1.144 2001/11/07 04:06:56 (David Hinds)";
  77. #else
  78. #define DEBUG(n, args...)
  79. #endif
  81. /*====================================================================*/
  83. /* Module parameters */
  85. MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  86. MODULE_DESCRIPTION("NE2000 compatible PCMCIA ethernet driver");
  87. MODULE_LICENSE("GPL");
  89. #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
  91. /* Bit map of interrupts to choose from */
  92. INT_MODULE_PARM(irq_mask, 0xdeb8);
  93. static int irq_list[4] = { -1 };
  94. MODULE_PARM(irq_list, "1-4i");
  96. INT_MODULE_PARM(if_port, 1); /* Transceiver type */
  97. INT_MODULE_PARM(use_big_buf, 1); /* use 64K packet buffer? */
  98. INT_MODULE_PARM(mem_speed, 0); /* shared mem speed, in ns */
  99. INT_MODULE_PARM(delay_output, 0); /* pause after xmit? */
  100. INT_MODULE_PARM(delay_time, 4); /* in usec */
  101. INT_MODULE_PARM(use_shmem, -1); /* use shared memory? */
  102. INT_MODULE_PARM(full_duplex, 0); /* full duplex? */
  104. /* Ugh!  Let the user hardwire the hardware address for queer cards */
  105. static int hw_addr[6] = { 0, /* ... */ };
  106. MODULE_PARM(hw_addr, "6i");
  108. /*====================================================================*/
  110. static void mii_phy_probe(struct net_device *dev);
  111. static void pcnet_config(dev_link_t *link);
  112. static void pcnet_release(u_long arg);
  113. static int pcnet_event(event_t event, int priority,
  114.        event_callback_args_t *args);
  115. static int pcnet_open(struct net_device *dev);
  116. static int pcnet_close(struct net_device *dev);
  117. static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  118. static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs);
  119. static void ei_watchdog(u_long arg);
  120. static void pcnet_reset_8390(struct net_device *dev);
  121. static int set_config(struct net_device *dev, struct ifmap *map);
  122. static int setup_shmem_window(dev_link_t *link, int start_pg,
  123.       int stop_pg, int cm_offset);
  124. static int setup_dma_config(dev_link_t *link, int start_pg,
  125.     int stop_pg);
  127. static dev_link_t *pcnet_attach(void);
  128. static void pcnet_detach(dev_link_t *);
  130. static dev_info_t dev_info = "pcnet_cs";
  131. static dev_link_t *dev_list;
  133. /*====================================================================*/
  135. typedef struct hw_info_t {
  136.     u_int offset;
  137.     u_char a0, a1, a2;
  138.     u_int flags;
  139. } hw_info_t;
  141. #define DELAY_OUTPUT 0x01
  142. #define HAS_MISC_REG 0x02
  143. #define USE_BIG_BUF 0x04
  144. #define HAS_IBM_MISC 0x08
  145. #define IS_DL10019 0x10
  146. #define IS_DL10022 0x20
  147. #define HAS_MII 0x40
  148. #define USE_SHMEM 0x80 /* autodetected */
  150. #define AM79C9XX_HOME_PHY 0x00006B90  /* HomePNA PHY */
  151. #define AM79C9XX_ETH_PHY 0x00006B70  /* 10baseT PHY */
  152. #define MII_PHYID_REV_MASK 0xfffffff0
  153. #define MII_PHYID_REG1 0x02
  154. #define MII_PHYID_REG2 0x03
  156. static hw_info_t hw_info[] = {
  157.     { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT }, 
  158.     { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
  159.     { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
  160.     { /* ASANTE FriendlyNet */ 0x4910, 0x00, 0x00, 0x94,
  161.       DELAY_OUTPUT | HAS_IBM_MISC },
  162.     { /* Danpex EN-6200P2 */ 0x0110, 0x00, 0x40, 0xc7, 0 },
  163.     { /* DataTrek NetCard */ 0x0ff0, 0x00, 0x20, 0xe8, 0 },
  164.     { /* Dayna CommuniCard E */ 0x0110, 0x00, 0x80, 0x19, 0 },
  165.     { /* D-Link DE-650 */ 0x0040, 0x00, 0x80, 0xc8, 0 },
  166.     { /* EP-210 Ethernet */ 0x0110, 0x00, 0x40, 0x33, 0 },
  167.     { /* EP4000 Ethernet */ 0x01c0, 0x00, 0x00, 0xb4, 0 },
  168.     { /* Epson EEN10B */ 0x0ff0, 0x00, 0x00, 0x48,
  169.       HAS_MISC_REG | HAS_IBM_MISC },
  170.     { /* ELECOM Laneed LD-CDWA */ 0xb8, 0x08, 0x00, 0x42, 0 },
  171.     { /* Hypertec Ethernet */ 0x01c0, 0x00, 0x40, 0x4c, 0 },
  172.     { /* IBM CCAE */ 0x0ff0, 0x08, 0x00, 0x5a,
  173.       HAS_MISC_REG | HAS_IBM_MISC },
  174.     { /* IBM CCAE */ 0x0ff0, 0x00, 0x04, 0xac,
  175.       HAS_MISC_REG | HAS_IBM_MISC },
  176.     { /* IBM CCAE */ 0x0ff0, 0x00, 0x06, 0x29,
  177.       HAS_MISC_REG | HAS_IBM_MISC },
  178.     { /* IBM FME */ 0x0374, 0x08, 0x00, 0x5a,
  179.       HAS_MISC_REG | HAS_IBM_MISC },
  180.     { /* IBM FME */ 0x0374, 0x00, 0x04, 0xac,
  181.       HAS_MISC_REG | HAS_IBM_MISC },
  182.     { /* Kansai KLA-PCM/T */ 0x0ff0, 0x00, 0x60, 0x87,
  183.       HAS_MISC_REG | HAS_IBM_MISC },
  184.     { /* NSC DP83903 */ 0x0374, 0x08, 0x00, 0x17,
  185.       HAS_MISC_REG | HAS_IBM_MISC },
  186.     { /* NSC DP83903 */ 0x0374, 0x00, 0xc0, 0xa8,
  187.       HAS_MISC_REG | HAS_IBM_MISC },
  188.     { /* NSC DP83903 */ 0x0374, 0x00, 0xa0, 0xb0,
  189.       HAS_MISC_REG | HAS_IBM_MISC },
  190.     { /* NSC DP83903 */ 0x0198, 0x00, 0x20, 0xe0,
  191.       HAS_MISC_REG | HAS_IBM_MISC },
  192.     { /* I-O DATA PCLA/T */ 0x0ff0, 0x00, 0xa0, 0xb0, 0 },
  193.     { /* Katron PE-520 */ 0x0110, 0x00, 0x40, 0xf6, 0 },
  194.     { /* Kingston KNE-PCM/x */ 0x0ff0, 0x00, 0xc0, 0xf0,
  195.       HAS_MISC_REG | HAS_IBM_MISC },
  196.     { /* Kingston KNE-PCM/x */ 0x0ff0, 0xe2, 0x0c, 0x0f,
  197.       HAS_MISC_REG | HAS_IBM_MISC },
  198.     { /* Kingston KNE-PC2 */ 0x0180, 0x00, 0xc0, 0xf0, 0 },
  199.     { /* Maxtech PCN2000 */ 0x5000, 0x00, 0x00, 0xe8, 0 },
  200.     { /* NDC Instant-Link */ 0x003a, 0x00, 0x80, 0xc6, 0 },
  201.     { /* NE2000 Compatible */ 0x0ff0, 0x00, 0xa0, 0x0c, 0 },
  202.     { /* Network General Sniffer */ 0x0ff0, 0x00, 0x00, 0x65,
  203.       HAS_MISC_REG | HAS_IBM_MISC },
  204.     { /* Panasonic VEL211 */ 0x0ff0, 0x00, 0x80, 0x45, 
  205.       HAS_MISC_REG | HAS_IBM_MISC },
  206.     { /* PreMax PE-200 */ 0x07f0, 0x00, 0x20, 0xe0, 0 },
  207.     { /* RPTI EP400 */ 0x0110, 0x00, 0x40, 0x95, 0 },
  208.     { /* SCM Ethernet */ 0x0ff0, 0x00, 0x20, 0xcb, 0 },
  209.     { /* Socket EA */ 0x4000, 0x00, 0xc0, 0x1b,
  210.       DELAY_OUTPUT | HAS_MISC_REG | USE_BIG_BUF },
  211.     { /* Socket LP-E CF+ */ 0x01c0, 0x00, 0xc0, 0x1b, 0 },
  212.     { /* SuperSocket RE450T */ 0x0110, 0x00, 0xe0, 0x98, 0 },
  213.     { /* Volktek NPL-402CT */ 0x0060, 0x00, 0x40, 0x05, 0 },
  214.     { /* NEC PC-9801N-J12 */ 0x0ff0, 0x00, 0x00, 0x4c, 0 },
  215.     { /* PCMCIA Technology OEM */ 0x01c8, 0x00, 0xa0, 0x0c, 0 }
  216. };
  218. #define NR_INFO (sizeof(hw_info)/sizeof(hw_info_t))
  220. static hw_info_t default_info = { 0, 0, 0, 0, 0 };
  221. static hw_info_t dl10019_info = { 0, 0, 0, 0, IS_DL10019|HAS_MII };
  222. static hw_info_t dl10022_info = { 0, 0, 0, 0, IS_DL10022|HAS_MII };
  224. typedef struct pcnet_dev_t {
  225.     struct net_device dev; /* so &dev == &pcnet_dev_t */
  226.     dev_link_t link;
  227.     dev_node_t node;
  228.     u_int flags;
  229.     caddr_t base;
  230.     struct timer_list watchdog;
  231.     int stale, fast_poll;
  232.     u_char phy_id;
  233.     u_char eth_phy, pna_phy;
  234.     u_short link_status;
  235.     u_long mii_reset;
  236. } pcnet_dev_t;
  238. /*======================================================================
  240.     This bit of code is used to avoid unregistering network devices
  241.     at inappropriate times.  2.2 and later kernels are fairly picky
  242.     about when this can happen.
  243.     
  244. ======================================================================*/
  246. static void flush_stale_links(void)
  247. {
  248.     dev_link_t *link, *next;
  249.     for (link = dev_list; link; link = next) {
  250. next = link->next;
  251. if (link->state & DEV_STALE_LINK)
  252.     pcnet_detach(link);
  253.     }
  254. }
  256. /*====================================================================*/
  258. static void cs_error(client_handle_t handle, int func, int ret)
  259. {
  260.     error_info_t err = { func, ret };
  261.     CardServices(ReportError, handle, &err);
  262. }
  264. /*======================================================================
  266.     We never need to do anything when a pcnet device is "initialized"
  267.     by the net software, because we only register already-found cards.
  269. ======================================================================*/
  271. static int pcnet_init(struct net_device *dev)
  272. {
  273.     return 0;
  274. }
  276. /*======================================================================
  278.     pcnet_attach() creates an "instance" of the driver, allocating
  279.     local data structures for one device.  The device is registered
  280.     with Card Services.
  282. ======================================================================*/
  284. static dev_link_t *pcnet_attach(void)
  285. {
  286.     pcnet_dev_t *info;
  287.     dev_link_t *link;
  288.     struct net_device *dev;
  289.     client_reg_t client_reg;
  290.     int i, ret;
  292.     DEBUG(0, "pcnet_attach()n");
  293.     flush_stale_links();
  295.     /* Create new ethernet device */
  296.     info = kmalloc(sizeof(*info), GFP_KERNEL);
  297.     if (!info) return NULL;
  298.     memset(info, 0, sizeof(*info));
  299.     link = &info->link; dev = &info->dev;
  300.     link->priv = info;
  301.     
  302.     link->release.function = &pcnet_release;
  303.     link->release.data = (u_long)link;
  304.     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
  305.     link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
  306.     if (irq_list[0] == -1)
  307. link->irq.IRQInfo2 = irq_mask;
  308.     else
  309. for (i = 0; i < 4; i++)
  310.     link->irq.IRQInfo2 |= 1 << irq_list[i];
  311.     link->conf.Attributes = CONF_ENABLE_IRQ;
  312.     link->conf.IntType = INT_MEMORY_AND_IO;
  314.     ethdev_init(dev);
  315.     dev->init = &pcnet_init;
  316.     dev->open = &pcnet_open;
  317.     dev->stop = &pcnet_close;
  318.     dev->set_config = &set_config;
  320.     /* Register with Card Services */
  321.     link->next = dev_list;
  322.     dev_list = link;
  323.     client_reg.dev_info = &dev_info;
  324.     client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
  325.     client_reg.EventMask =
  326. CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
  327. CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
  328. CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
  329.     client_reg.event_handler = &pcnet_event;
  330.     client_reg.Version = 0x0210;
  331.     client_reg.event_callback_args.client_data = link;
  332.     ret = CardServices(RegisterClient, &link->handle, &client_reg);
  333.     if (ret != CS_SUCCESS) {
  334. cs_error(link->handle, RegisterClient, ret);
  335. pcnet_detach(link);
  336. return NULL;
  337.     }
  339.     return link;
  340. } /* pcnet_attach */
  342. /*======================================================================
  344.     This deletes a driver "instance".  The device is de-registered
  345.     with Card Services.  If it has been released, all local data
  346.     structures are freed.  Otherwise, the structures will be freed
  347.     when the device is released.
  349. ======================================================================*/
  351. static void pcnet_detach(dev_link_t *link)
  352. {
  353.     pcnet_dev_t *info = link->priv;
  354.     dev_link_t **linkp;
  356.     DEBUG(0, "pcnet_detach(0x%p)n", link);
  358.     /* Locate device structure */
  359.     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
  360. if (*linkp == link) break;
  361.     if (*linkp == NULL)
  362. return;
  364.     del_timer(&link->release);
  365.     if (link->state & DEV_CONFIG) {
  366. pcnet_release((u_long)link);
  367. if (link->state & DEV_STALE_CONFIG) {
  368.     link->state |= DEV_STALE_LINK;
  369.     return;
  370. }
  371.     }
  373.     if (link->handle)
  374. CardServices(DeregisterClient, link->handle);
  376.     /* Unlink device structure, free bits */
  377.     *linkp = link->next;
  378.     if (link->dev)
  379. unregister_netdev(&info->dev);
  380.     kfree(info);
  382. } /* pcnet_detach */
  384. /*======================================================================
  386.     This probes for a card's hardware address, for card types that
  387.     encode this information in their CIS.
  389. ======================================================================*/
  391. static hw_info_t *get_hwinfo(dev_link_t *link)
  392. {
  393.     struct net_device *dev = link->priv;
  394.     win_req_t req;
  395.     memreq_t mem;
  396.     u_char *base, *virt;
  397.     int i, j;
  399.     /* Allocate a small memory window */
  400.     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
  401.     req.Base = 0; req.Size = 0;
  402.     req.AccessSpeed = 0;
  403.     link->win = (window_handle_t)link->handle;
  404.     i = CardServices(RequestWindow, &link->win, &req);
  405.     if (i != CS_SUCCESS) {
  406. cs_error(link->handle, RequestWindow, i);
  407. return NULL;
  408.     }
  410.     virt = ioremap(req.Base, req.Size);
  411.     mem.Page = 0;
  412.     for (i = 0; i < NR_INFO; i++) {
  413. mem.CardOffset = hw_info[i].offset & ~(req.Size-1);
  414. CardServices(MapMemPage, link->win, &mem);
  415. base = &virt[hw_info[i].offset & (req.Size-1)];
  416. if ((readb(base+0) == hw_info[i].a0) &&
  417.     (readb(base+2) == hw_info[i].a1) &&
  418.     (readb(base+4) == hw_info[i].a2))
  419.     break;
  420.     }
  421.     if (i < NR_INFO) {
  422. for (j = 0; j < 6; j++)
  423.     dev->dev_addr[j] = readb(base + (j<<1));
  424.     }
  425.     
  426.     iounmap(virt);
  427.     j = CardServices(ReleaseWindow, link->win);
  428.     if (j != CS_SUCCESS)
  429. cs_error(link->handle, ReleaseWindow, j);
  430.     return (i < NR_INFO) ? hw_info+i : NULL;
  431. } /* get_hwinfo */
  433. /*======================================================================
  435.     This probes for a card's hardware address by reading the PROM.
  436.     It checks the address against a list of known types, then falls
  437.     back to a simple NE2000 clone signature check.
  439. ======================================================================*/
  441. static hw_info_t *get_prom(dev_link_t *link)
  442. {
  443.     struct net_device *dev = link->priv;
  444.     ioaddr_t ioaddr = dev->base_addr;
  445.     u_char prom[32];
  446.     int i, j;
  448.     /* This is lifted straight from drivers/net/ne.c */
  449.     struct {
  450. u_char value, offset;
  451.     } program_seq[] = {
  452. {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
  453. {0x48, EN0_DCFG}, /* Set byte-wide (0x48) access. */
  454. {0x00, EN0_RCNTLO}, /* Clear the count regs. */
  455. {0x00, EN0_RCNTHI},
  456. {0x00, EN0_IMR}, /* Mask completion irq. */
  457. {0xFF, EN0_ISR},
  458. {E8390_RXOFF, EN0_RXCR}, /* 0x20  Set to monitor */
  459. {E8390_TXOFF, EN0_TXCR}, /* 0x02  and loopback mode. */
  460. {32, EN0_RCNTLO},
  461. {0x00, EN0_RCNTHI},
  462. {0x00, EN0_RSARLO}, /* DMA starting at 0x0000. */
  463. {0x00, EN0_RSARHI},
  464. {E8390_RREAD+E8390_START, E8390_CMD},
  465.     };
  467.     pcnet_reset_8390(dev);
  468.     mdelay(10);
  470.     for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++)
  471. outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
  473.     for (i = 0; i < 32; i++)
  474. prom[i] = inb(ioaddr + PCNET_DATAPORT);
  475.     for (i = 0; i < NR_INFO; i++) {
  476. if ((prom[0] == hw_info[i].a0) &&
  477.     (prom[2] == hw_info[i].a1) &&
  478.     (prom[4] == hw_info[i].a2))
  479.     break;
  480.     }
  481.     if ((i < NR_INFO) || ((prom[28] == 0x57) && (prom[30] == 0x57))) {
  482. for (j = 0; j < 6; j++)
  483.     dev->dev_addr[j] = prom[j<<1];
  484. return (i < NR_INFO) ? hw_info+i : &default_info;
  485.     }
  486.     return NULL;
  487. } /* get_prom */
  489. /*======================================================================
  491.     For DL10019 based cards, like the Linksys EtherFast
  493. ======================================================================*/
  495. static hw_info_t *get_dl10019(dev_link_t *link)
  496. {
  497.     struct net_device *dev = link->priv;
  498.     int i;
  499.     u_char sum;
  501.     for (sum = 0, i = 0x14; i < 0x1c; i++)
  502. sum += inb_p(dev->base_addr + i);
  503.     if (sum != 0xff)
  504. return NULL;
  505.     for (i = 0; i < 6; i++)
  506. dev->dev_addr[i] = inb_p(dev->base_addr + 0x14 + i);
  507.     i = inb(dev->base_addr + 0x1f);
  508.     return ((i == 0x91)||(i == 0x99)) ? &dl10022_info : &dl10019_info;
  509. }
  511. /*======================================================================
  513.     For Asix AX88190 based cards
  515. ======================================================================*/
  517. static hw_info_t *get_ax88190(dev_link_t *link)
  518. {
  519.     struct net_device *dev = link->priv;
  520.     ioaddr_t ioaddr = dev->base_addr;
  521.     int i, j;
  523.     /* Not much of a test, but the alternatives are messy */
  524.     if (link->conf.ConfigBase != 0x03c0)
  525. return NULL;
  527.     outb_p(0x01, ioaddr + EN0_DCFG); /* Set word-wide access. */
  528.     outb_p(0x00, ioaddr + EN0_RSARLO); /* DMA starting at 0x0400. */
  529.     outb_p(0x04, ioaddr + EN0_RSARHI);
  530.     outb_p(E8390_RREAD+E8390_START, ioaddr + E8390_CMD);
  532.     for (i = 0; i < 6; i += 2) {
  533. j = inw(ioaddr + PCNET_DATAPORT);
  534. dev->dev_addr[i] = j & 0xff;
  535. dev->dev_addr[i+1] = j >> 8;
  536.     }
  537.     printk(KERN_NOTICE "pcnet_cs: this is an AX88190 card!n");
  538.     printk(KERN_NOTICE "pcnet_cs: use axnet_cs instead.n");
  539.     return NULL;
  540. }
  542. /*======================================================================
  544.     This should be totally unnecessary... but when we can't figure
  545.     out the hardware address any other way, we'll let the user hard
  546.     wire it when the module is initialized.
  548. ======================================================================*/
  550. static hw_info_t *get_hwired(dev_link_t *link)
  551. {
  552.     struct net_device *dev = link->priv;
  553.     int i;
  555.     for (i = 0; i < 6; i++)
  556. if (hw_addr[i] != 0) break;
  557.     if (i == 6)
  558. return NULL;
  560.     for (i = 0; i < 6; i++)
  561. dev->dev_addr[i] = hw_addr[i];
  563.     return &default_info;
  564. } /* get_hwired */
  566. /*======================================================================
  568.     pcnet_config() is scheduled to run after a CARD_INSERTION event
  569.     is received, to configure the PCMCIA socket, and to make the
  570.     ethernet device available to the system.
  572. ======================================================================*/
  574. #define CS_CHECK(fn, args...) 
  575. while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed
  577. #define CFG_CHECK(fn, args...) 
  578. if (CardServices(fn, args) != 0) goto next_entry
  580. static int try_io_port(dev_link_t *link)
  581. {
  582.     int j, ret;
  583.     if (link->io.NumPorts1 == 32) {
  584. link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
  585. if (link->io.NumPorts2 > 0) {
  586.     /* for master/slave multifunction cards */
  587.     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
  588.     link->irq.Attributes = 
  589. IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
  590. }
  591.     } else {
  592. /* This should be two 16-port windows */
  593. link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
  594. link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
  595.     }
  596.     if (link->io.BasePort1 == 0) {
  597. link->io.IOAddrLines = 16;
  598. for (j = 0; j < 0x400; j += 0x20) {
  599.     link->io.BasePort1 = j ^ 0x300;
  600.     link->io.BasePort2 = (j ^ 0x300) + 0x10;
  601.     ret = CardServices(RequestIO, link->handle, &link->io);
  602.     if (ret == CS_SUCCESS) return ret;
  603. }
  604. return ret;
  605.     } else {
  606. return CardServices(RequestIO, link->handle, &link->io);
  607.     }
  608. }
  610. static void pcnet_config(dev_link_t *link)
  611. {
  612.     client_handle_t handle = link->handle;
  613.     pcnet_dev_t *info = link->priv;
  614.     struct net_device *dev = &info->dev;
  615.     tuple_t tuple;
  616.     cisparse_t parse;
  617.     int i, last_ret, last_fn, start_pg, stop_pg, cm_offset;
  618.     int manfid = 0, prodid = 0, has_shmem = 0;
  619.     u_short buf[64];
  620.     config_info_t conf;
  621.     hw_info_t *hw_info;
  623.     DEBUG(0, "pcnet_config(0x%p)n", link);
  625.     tuple.Attributes = 0;
  626.     tuple.TupleData = (cisdata_t *)buf;
  627.     tuple.TupleDataMax = sizeof(buf);
  628.     tuple.TupleOffset = 0;
  629.     tuple.DesiredTuple = CISTPL_CONFIG;
  630.     CS_CHECK(GetFirstTuple, handle, &tuple);
  631.     CS_CHECK(GetTupleData, handle, &tuple);
  632.     CS_CHECK(ParseTuple, handle, &tuple, &parse);
  633.     link->conf.ConfigBase = parse.config.base;
  634.     link->conf.Present = parse.config.rmask[0];
  636.     /* Configure card */
  637.     link->state |= DEV_CONFIG;
  639.     /* Look up current Vcc */
  640.     CS_CHECK(GetConfigurationInfo, handle, &conf);
  641.     link->conf.Vcc = conf.Vcc;
  643.     tuple.DesiredTuple = CISTPL_MANFID;
  644.     tuple.Attributes = TUPLE_RETURN_COMMON;
  645.     if ((CardServices(GetFirstTuple, handle, &tuple) == CS_SUCCESS) &&
  646.   (CardServices(GetTupleData, handle, &tuple) == CS_SUCCESS)) {
  647. manfid = le16_to_cpu(buf[0]);
  648. prodid = le16_to_cpu(buf[1]);
  649.     }
  650.     
  651.     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
  652.     tuple.Attributes = 0;
  653.     CS_CHECK(GetFirstTuple, handle, &tuple);
  654.     while (last_ret == CS_SUCCESS) {
  655. cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
  656. cistpl_io_t *io = &(parse.cftable_entry.io);
  658. CFG_CHECK(GetTupleData, handle, &tuple);
  659. CFG_CHECK(ParseTuple, handle, &tuple, &parse);
  660. if ((cfg->index == 0) || (cfg->io.nwin == 0))
  661.     goto next_entry;
  663. link->conf.ConfigIndex = cfg->index;
  664. /* For multifunction cards, by convention, we configure the
  665.    network function with window 0, and serial with window 1 */
  666. if (io->nwin > 1) {
  667.     i = (io->win[1].len > io->win[0].len);
  668.     link->io.BasePort2 = io->win[1-i].base;
  669.     link->io.NumPorts2 = io->win[1-i].len;
  670. } else {
  671.     i = link->io.NumPorts2 = 0;
  672. }
  673. has_shmem = ((cfg->mem.nwin == 1) &&
  674.      (cfg->mem.win[0].len >= 0x4000));
  675. link->io.BasePort1 = io->win[i].base;
  676. link->io.NumPorts1 = io->win[i].len;
  677. link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
  678. if (link->io.NumPorts1 + link->io.NumPorts2 >= 32) {
  679.     last_ret = try_io_port(link);
  680.     if (last_ret == CS_SUCCESS) break;
  681. }
  682.     next_entry:
  683. last_ret = CardServices(GetNextTuple, handle, &tuple);
  684.     }
  685.     if (last_ret != CS_SUCCESS) {
  686. cs_error(handle, RequestIO, last_ret);
  687. goto failed;
  688.     }
  690.     CS_CHECK(RequestIRQ, handle, &link->irq);
  691.     
  692.     if (link->io.NumPorts2 == 8) {
  693. link->conf.Attributes |= CONF_ENABLE_SPKR;
  694. link->conf.Status = CCSR_AUDIO_ENA;
  695.     }
  696.     if ((manfid == MANFID_IBM) &&
  697. (prodid == PRODID_IBM_HOME_AND_AWAY))
  698. link->conf.ConfigIndex |= 0x10;
  699.     
  700.     CS_CHECK(RequestConfiguration, handle, &link->conf);
  701.     dev->irq = link->irq.AssignedIRQ;
  702.     dev->base_addr = link->io.BasePort1;
  703.     if (info->flags & HAS_MISC_REG) {
  704. if ((if_port == 1) || (if_port == 2))
  705.     dev->if_port = if_port;
  706. else
  707.     printk(KERN_NOTICE "pcnet_cs: invalid if_port requestedn");
  708.     } else {
  709. dev->if_port = 0;
  710.     }
  711.     if (register_netdev(dev) != 0) {
  712. printk(KERN_NOTICE "pcnet_cs: register_netdev() failedn");
  713. goto failed;
  714.     }
  716.     hw_info = get_hwinfo(link);
  717.     if (hw_info == NULL)
  718. hw_info = get_prom(link);
  719.     if (hw_info == NULL)
  720. hw_info = get_dl10019(link);
  721.     if (hw_info == NULL)
  722. hw_info = get_ax88190(link);
  723.     if (hw_info == NULL)
  724. hw_info = get_hwired(link);
  725.     
  726.     if (hw_info == NULL) {
  727. printk(KERN_NOTICE "pcnet_cs: unable to read hardware net"
  728.        " address for io base %#3lxn", dev->base_addr);
  729. unregister_netdev(dev);
  730. goto failed;
  731.     }
  733.     info->flags = hw_info->flags;
  734.     /* Check for user overrides */
  735.     info->flags |= (delay_output) ? DELAY_OUTPUT : 0;
  736.     if ((manfid == MANFID_SOCKET) &&
  737. ((prodid == PRODID_SOCKET_LPE) ||
  738.  (prodid == PRODID_SOCKET_LPE_CF) ||
  739.  (prodid == PRODID_SOCKET_EIO)))
  740. info->flags &= ~USE_BIG_BUF;
  741.     if (!use_big_buf)
  742. info->flags &= ~USE_BIG_BUF;
  743.     
  744.     if (info->flags & USE_BIG_BUF) {
  745. start_pg = SOCKET_START_PG;
  746. stop_pg = SOCKET_STOP_PG;
  747. cm_offset = 0x10000;
  748.     } else {
  749. start_pg = PCNET_START_PG;
  750. stop_pg = PCNET_STOP_PG;
  751. cm_offset = 0;
  752.     }
  754.     /* has_shmem is ignored if use_shmem != -1 */
  755.     if ((use_shmem == 0) || (!has_shmem && (use_shmem == -1)) ||
  756. (setup_shmem_window(link, start_pg, stop_pg, cm_offset) != 0))
  757. setup_dma_config(link, start_pg, stop_pg);
  759.     ei_status.name = "NE2000";
  760.     ei_status.word16 = 1;
  761.     ei_status.reset_8390 = &pcnet_reset_8390;
  763.     strcpy(info->node.dev_name, dev->name);
  764.     link->dev = &info->node;
  765.     link->state &= ~DEV_CONFIG_PENDING;
  767.     if (info->flags & (IS_DL10019|IS_DL10022)) {
  768. u_char id = inb(dev->base_addr + 0x1a);
  769. dev->do_ioctl = &ei_ioctl;
  770. mii_phy_probe(dev);
  771. printk(KERN_INFO "%s: NE2000 (DL100%d rev %02x): ",
  772.        dev->name, ((info->flags & IS_DL10022) ? 22 : 19), id);
  773. if (info->pna_phy)
  774.     printk("PNA, ");
  775.     } else
  776. printk(KERN_INFO "%s: NE2000 Compatible: ", dev->name);
  777.     printk("io %#3lx, irq %d,", dev->base_addr, dev->irq);
  778.     if (info->flags & USE_SHMEM)
  779. printk (" mem %#5lx,", dev->mem_start);
  780.     if (info->flags & HAS_MISC_REG)
  781. printk(" %s xcvr,", if_names[dev->if_port]);
  782.     printk(" hw_addr ");
  783.     for (i = 0; i < 6; i++)
  784. printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "n"));
  785.     return;
  787. cs_failed:
  788.     cs_error(link->handle, last_fn, last_ret);
  789. failed:
  790.     pcnet_release((u_long)link);
  791.     return;
  792. } /* pcnet_config */
  794. /*======================================================================
  796.     After a card is removed, pcnet_release() will unregister the net
  797.     device, and release the PCMCIA configuration.  If the device is
  798.     still open, this will be postponed until it is closed.
  800. ======================================================================*/
  802. static void pcnet_release(u_long arg)
  803. {
  804.     dev_link_t *link = (dev_link_t *)arg;
  805.     pcnet_dev_t *info = link->priv;
  807.     DEBUG(0, "pcnet_release(0x%p)n", link);
  809.     if (link->open) {
  810. DEBUG(1, "pcnet_cs: release postponed, '%s' still openn",
  811.       info->node.dev_name);
  812. link->state |= DEV_STALE_CONFIG;
  813. return;
  814.     }
  816.     if (info->flags & USE_SHMEM) {
  817. iounmap(info->base);
  818. CardServices(ReleaseWindow, link->win);
  819.     }
  820.     CardServices(ReleaseConfiguration, link->handle);
  821.     CardServices(ReleaseIO, link->handle, &link->io);
  822.     CardServices(ReleaseIRQ, link->handle, &link->irq);
  824.     link->state &= ~DEV_CONFIG;
  826. } /* pcnet_release */
  828. /*======================================================================
  830.     The card status event handler.  Mostly, this schedules other
  831.     stuff to run after an event is received.  A CARD_REMOVAL event
  832.     also sets some flags to discourage the net drivers from trying
  833.     to talk to the card any more.
  835. ======================================================================*/
  837. static int pcnet_event(event_t event, int priority,
  838.        event_callback_args_t *args)
  839. {
  840.     dev_link_t *link = args->client_data;
  841.     pcnet_dev_t *info = link->priv;
  843.     DEBUG(2, "pcnet_event(0x%06x)n", event);
  845.     switch (event) {
  846.     case CS_EVENT_CARD_REMOVAL:
  847. link->state &= ~DEV_PRESENT;
  848. if (link->state & DEV_CONFIG) {
  849.     netif_device_detach(&info->dev);
  850.     mod_timer(&link->release, jiffies + HZ/20);
  851. }
  852. break;
  853.     case CS_EVENT_CARD_INSERTION:
  854. link->state |= DEV_PRESENT;
  855. pcnet_config(link);
  856. break;
  857.     case CS_EVENT_PM_SUSPEND:
  858. link->state |= DEV_SUSPEND;
  859. /* Fall through... */
  860.     case CS_EVENT_RESET_PHYSICAL:
  861. if (link->state & DEV_CONFIG) {
  862.     if (link->open)
  863. netif_device_detach(&info->dev);
  864.     CardServices(ReleaseConfiguration, link->handle);
  865. }
  866. break;
  867.     case CS_EVENT_PM_RESUME:
  868. link->state &= ~DEV_SUSPEND;
  869. /* Fall through... */
  870.     case CS_EVENT_CARD_RESET:
  871. if (link->state & DEV_CONFIG) {
  872.     CardServices(RequestConfiguration, link->handle, &link->conf);
  873.     if (link->open) {
  874. pcnet_reset_8390(&info->dev);
  875. NS8390_init(&info->dev, 1);
  876. netif_device_attach(&info->dev);
  877.     }
  878. }
  879. break;
  880.     }
  881.     return 0;
  882. } /* pcnet_event */
  884. /*======================================================================
  886.     MII interface support for DL10019 and DL10022 based cards
  888.     On the DL10019, the MII IO direction bit is 0x10; on  the DL10022
  889.     it is 0x20.  Setting both bits seems to work on both card types.
  891. ======================================================================*/
  893. #define DLINK_GPIO 0x1c
  894. #define DLINK_DIAG 0x1d
  895. #define MDIO_SHIFT_CLK 0x80
  896. #define MDIO_DATA_OUT 0x40
  897. #define MDIO_DIR_WRITE 0x30
  898. #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
  899. #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
  900. #define MDIO_DATA_READ 0x10
  901. #define MDIO_MASK 0x0f
  903. static void mdio_sync(ioaddr_t addr)
  904. {
  905.     int bits, mask = inb(addr) & MDIO_MASK;
  906.     for (bits = 0; bits < 32; bits++) {
  907. outb(mask | MDIO_DATA_WRITE1, addr);
  908. outb(mask | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
  909.     }
  910. }
  912. static int mdio_read(ioaddr_t addr, int phy_id, int loc)
  913. {
  914.     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
  915.     int i, retval = 0, mask = inb(addr) & MDIO_MASK;
  917.     mdio_sync(addr);
  918.     for (i = 13; i >= 0; i--) {
  919. int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
  920. outb(mask | dat, addr);
  921. outb(mask | dat | MDIO_SHIFT_CLK, addr);
  922.     }
  923.     for (i = 19; i > 0; i--) {
  924. outb(mask, addr);
  925. retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
  926. outb(mask | MDIO_SHIFT_CLK, addr);
  927.     }
  928.     return (retval>>1) & 0xffff;
  929. }
  931. static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value)
  932. {
  933.     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
  934.     int i, mask = inb(addr) & MDIO_MASK;
  936.     mdio_sync(addr);
  937.     for (i = 31; i >= 0; i--) {
  938. int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
  939. outb(mask | dat, addr);
  940. outb(mask | dat | MDIO_SHIFT_CLK, addr);
  941.     }
  942.     for (i = 1; i >= 0; i--) {
  943. outb(mask, addr);
  944. outb(mask | MDIO_SHIFT_CLK, addr);
  945.     }
  946. }
  948. static void mdio_reset(ioaddr_t addr, int phy_id)
  949. {
  950.     outb_p(0x08, addr);
  951.     outb_p(0x0c, addr);
  952.     outb_p(0x08, addr);
  953.     outb_p(0x0c, addr);
  954.     outb_p(0x00, addr);
  955. }
  957. /*====================================================================*/
  959. static void set_misc_reg(struct net_device *dev)
  960. {
  961.     ioaddr_t nic_base = dev->base_addr;
  962.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  963.     u_char tmp;
  964.     
  965.     if (info->flags & HAS_MISC_REG) {
  966. tmp = inb_p(nic_base + PCNET_MISC) & ~3;
  967. if (dev->if_port == 2)
  968.     tmp |= 1;
  969. if (info->flags & USE_BIG_BUF)
  970.     tmp |= 2;
  971. if (info->flags & HAS_IBM_MISC)
  972.     tmp |= 8;
  973. outb_p(tmp, nic_base + PCNET_MISC);
  974.     }
  975.     if (info->flags & IS_DL10022) {
  976. if (info->flags & HAS_MII) {
  977.     mdio_reset(nic_base + DLINK_GPIO, info->eth_phy);
  978.     /* Restart MII autonegotiation */
  979.     mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x0000);
  980.     mdio_write(nic_base + DLINK_GPIO, info->eth_phy, 0, 0x1200);
  981.     info->mii_reset = jiffies;
  982. } else {
  983.     outb(full_duplex ? 4 : 0, nic_base + DLINK_DIAG);
  984. }
  985.     }
  986. }
  988. /*====================================================================*/
  990. static void mii_phy_probe(struct net_device *dev)
  991. {
  992.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  993.     ioaddr_t mii_addr = dev->base_addr + DLINK_GPIO;
  994.     int i;
  995.     u_int tmp, phyid;
  997.     for (i = 31; i >= 0; i--) {
  998. tmp = mdio_read(mii_addr, i, 1);
  999. if ((tmp == 0) || (tmp == 0xffff))
  1000.     continue;
  1001. tmp = mdio_read(mii_addr, i, MII_PHYID_REG1);
  1002. phyid = tmp << 16;
  1003. phyid |= mdio_read(mii_addr, i, MII_PHYID_REG2);
  1004. phyid &= MII_PHYID_REV_MASK;
  1005. DEBUG(0, "%s: MII at %d is 0x%08xn", dev->name, i, phyid);
  1006. if (phyid == AM79C9XX_HOME_PHY) {
  1007.     info->pna_phy = i;
  1008. } else if (phyid != AM79C9XX_ETH_PHY) {
  1009.     info->eth_phy = i;
  1010. }
  1011.     }
  1012. }
  1014. static int pcnet_open(struct net_device *dev)
  1015. {
  1016.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  1017.     dev_link_t *link = &info->link;
  1018.     
  1019.     DEBUG(2, "pcnet_open('%s')n", dev->name);
  1021.     if (!DEV_OK(link))
  1022. return -ENODEV;
  1024.     link->open++;
  1025.     MOD_INC_USE_COUNT;
  1027.     set_misc_reg(dev);
  1028.     request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
  1030.     info->phy_id = info->eth_phy;
  1031.     info->link_status = 0x00;
  1032.     info->watchdog.function = &ei_watchdog;
  1033.     info->watchdog.data = (u_long)info;
  1034.     info->watchdog.expires = jiffies + HZ;
  1035.     add_timer(&info->watchdog);
  1037.     return ei_open(dev);
  1038. } /* pcnet_open */
  1040. /*====================================================================*/
  1042. static int pcnet_close(struct net_device *dev)
  1043. {
  1044.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  1045.     dev_link_t *link = &info->link;
  1047.     DEBUG(2, "pcnet_close('%s')n", dev->name);
  1049.     free_irq(dev->irq, dev);
  1050.     
  1051.     link->open--;
  1052.     netif_stop_queue(dev);
  1053.     del_timer(&info->watchdog);
  1054.     if (link->state & DEV_STALE_CONFIG)
  1055. mod_timer(&link->release, jiffies + HZ/20);
  1057.     MOD_DEC_USE_COUNT;
  1059.     return 0;
  1060. } /* pcnet_close */
  1062. /*======================================================================
  1064.     Hard reset the card.  This used to pause for the same period that
  1065.     a 8390 reset command required, but that shouldn't be necessary.
  1067. ======================================================================*/
  1069. static void pcnet_reset_8390(struct net_device *dev)
  1070. {
  1071.     ioaddr_t nic_base = dev->base_addr;
  1072.     int i;
  1074.     ei_status.txing = ei_status.dmaing = 0;
  1076.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
  1078.     outb(inb(nic_base + PCNET_RESET), nic_base + PCNET_RESET);
  1080.     for (i = 0; i < 100; i++) {
  1081. if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
  1082.     break;
  1083. udelay(100);
  1084.     }
  1085.     outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
  1086.     
  1087.     if (i == 100)
  1088. printk(KERN_ERR "%s: pcnet_reset_8390() did not complete.n",
  1089.        dev->name);
  1090.     set_misc_reg(dev);
  1091.     
  1092. } /* pcnet_reset_8390 */
  1094. /*====================================================================*/
  1096. static int set_config(struct net_device *dev, struct ifmap *map)
  1097. {
  1098.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  1099.     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
  1100. if (!(info->flags & HAS_MISC_REG))
  1101.     return -EOPNOTSUPP;
  1102. else if ((map->port < 1) || (map->port > 2))
  1103.     return -EINVAL;
  1104. dev->if_port = map->port;
  1105. printk(KERN_INFO "%s: switched to %s portn",
  1106.        dev->name, if_names[dev->if_port]);
  1107. NS8390_init(dev, 1);
  1108.     }
  1109.     return 0;
  1110. }
  1112. /*====================================================================*/
  1114. static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs)
  1115. {
  1116.     pcnet_dev_t *info = dev_id;
  1117.     info->stale = 0;
  1118.     ei_interrupt(irq, dev_id, regs);
  1119. }
  1121. static void ei_watchdog(u_long arg)
  1122. {
  1123.     pcnet_dev_t *info = (pcnet_dev_t *)(arg);
  1124.     struct net_device *dev = &info->dev;
  1125.     ioaddr_t nic_base = dev->base_addr;
  1126.     ioaddr_t mii_addr = nic_base + DLINK_GPIO;
  1127.     u_short link;
  1129.     if (!netif_device_present(dev)) goto reschedule;
  1131.     /* Check for pending interrupt with expired latency timer: with
  1132.        this, we can limp along even if the interrupt is blocked */
  1133.     outb_p(E8390_NODMA+E8390_PAGE0, nic_base + E8390_CMD);
  1134.     if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
  1135. if (!info->fast_poll)
  1136.     printk(KERN_INFO "%s: interrupt(s) dropped!n", dev->name);
  1137. ei_irq_wrapper(dev->irq, dev, NULL);
  1138. info->fast_poll = HZ;
  1139.     }
  1140.     if (info->fast_poll) {
  1141. info->fast_poll--;
  1142. info->watchdog.expires = jiffies + 1;
  1143. add_timer(&info->watchdog);
  1144. return;
  1145.     }
  1147.     if (!(info->flags & HAS_MII))
  1148. goto reschedule;
  1150.     mdio_read(mii_addr, info->phy_id, 1);
  1151.     link = mdio_read(mii_addr, info->phy_id, 1);
  1152.     if (!link || (link == 0xffff)) {
  1153. if (info->eth_phy) {
  1154.     info->phy_id = info->eth_phy = 0;
  1155. } else {
  1156.     printk(KERN_INFO "%s: MII is missing!n", dev->name);
  1157.     info->flags &= ~HAS_MII;
  1158. }
  1159. goto reschedule;
  1160.     }
  1162.     link &= 0x0004;
  1163.     if (link != info->link_status) {
  1164. u_short p = mdio_read(mii_addr, info->phy_id, 5);
  1165. printk(KERN_INFO "%s: %s link beatn", dev->name,
  1166.        (link) ? "found" : "lost");
  1167. if (link && (info->flags & IS_DL10022)) {
  1168.     /* Disable collision detection on full duplex links */
  1169.     outb((p & 0x0140) ? 4 : 0, nic_base + DLINK_DIAG);
  1170. }
  1171. if (link) {
  1172.     if (info->phy_id == info->eth_phy) {
  1173. if (p)
  1174.     printk(KERN_INFO "%s: autonegotiation complete: "
  1175.    "%sbaseT-%cD selectedn", dev->name,
  1176.    ((p & 0x0180) ? "100" : "10"),
  1177.    ((p & 0x0140) ? 'F' : 'H'));
  1178. else
  1179.     printk(KERN_INFO "%s: link partner did not "
  1180.    "autonegotiaten", dev->name);
  1181.     }
  1182.     NS8390_init(dev, 1);
  1183. }
  1184. info->link_status = link;
  1185.     }
  1186.     if (info->pna_phy && (jiffies - info->mii_reset > 6*HZ)) {
  1187. link = mdio_read(mii_addr, info->eth_phy, 1) & 0x0004;
  1188. if (((info->phy_id == info->pna_phy) && link) ||
  1189.     ((info->phy_id != info->pna_phy) && !link)) {
  1190.     /* isolate this MII and try flipping to the other one */
  1191.     mdio_write(mii_addr, info->phy_id, 0, 0x0400);
  1192.     info->phy_id ^= info->pna_phy ^ info->eth_phy;
  1193.     printk(KERN_INFO "%s: switched to %s transceivern", dev->name,
  1194.    (info->phy_id == info->eth_phy) ? "ethernet" : "PNA");
  1195.     mdio_write(mii_addr, info->phy_id, 0,
  1196.        (info->phy_id == info->eth_phy) ? 0x1000 : 0);
  1197.     info->link_status = 0;
  1198.     info->mii_reset = jiffies;
  1199. }
  1200.     }
  1202. reschedule:
  1203.     info->watchdog.expires = jiffies + HZ;
  1204.     add_timer(&info->watchdog);
  1205. }
  1207. /*====================================================================*/
  1209. static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1210. {
  1211.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  1212.     u16 *data = (u16 *)&rq->ifr_data;
  1213.     ioaddr_t mii_addr = dev->base_addr + DLINK_GPIO;
  1214.     switch (cmd) {
  1215.     case SIOCDEVPRIVATE:
  1216. data[0] = info->phy_id;
  1217.     case SIOCDEVPRIVATE+1:
  1218. data[3] = mdio_read(mii_addr, data[0], data[1] & 0x1f);
  1219. return 0;
  1220.     case SIOCDEVPRIVATE+2:
  1221. if (!capable(CAP_NET_ADMIN))
  1222.     return -EPERM;
  1223. mdio_write(mii_addr, data[0], data[1] & 0x1f, data[2]);
  1224. return 0;
  1225.     }
  1226.     return -EOPNOTSUPP;
  1227. }
  1229. /*====================================================================*/
  1231. static void dma_get_8390_hdr(struct net_device *dev,
  1232.      struct e8390_pkt_hdr *hdr,
  1233.      int ring_page)
  1234. {
  1235.     ioaddr_t nic_base = dev->base_addr;
  1237.     if (ei_status.dmaing) {
  1238. printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
  1239.        "[DMAstat:%1x][irqlock:%1x]n",
  1240.        dev->name, ei_status.dmaing, ei_status.irqlock);
  1241. return;
  1242.     }
  1243.     
  1244.     ei_status.dmaing |= 0x01;
  1245.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
  1246.     outb_p(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
  1247.     outb_p(0, nic_base + EN0_RCNTHI);
  1248.     outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */
  1249.     outb_p(ring_page, nic_base + EN0_RSARHI);
  1250.     outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
  1252.     insw(nic_base + PCNET_DATAPORT, hdr,
  1253.     sizeof(struct e8390_pkt_hdr)>>1);
  1254.     /* Fix for big endian systems */
  1255.     hdr->count = le16_to_cpu(hdr->count);
  1257.     outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
  1258.     ei_status.dmaing &= ~0x01;
  1259. }
  1261. /*====================================================================*/
  1263. static void dma_block_input(struct net_device *dev, int count,
  1264.     struct sk_buff *skb, int ring_offset)
  1265. {
  1266.     ioaddr_t nic_base = dev->base_addr;
  1267.     int xfer_count = count;
  1268.     char *buf = skb->data;
  1270. #ifdef PCMCIA_DEBUG
  1271.     if ((ei_debug > 4) && (count != 4))
  1272. printk(KERN_DEBUG "%s: [bi=%d]n", dev->name, count+4);
  1273. #endif
  1274.     if (ei_status.dmaing) {
  1275. printk(KERN_NOTICE "%s: DMAing conflict in dma_block_input."
  1276.        "[DMAstat:%1x][irqlock:%1x]n",
  1277.        dev->name, ei_status.dmaing, ei_status.irqlock);
  1278. return;
  1279.     }
  1280.     ei_status.dmaing |= 0x01;
  1281.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base + PCNET_CMD);
  1282.     outb_p(count & 0xff, nic_base + EN0_RCNTLO);
  1283.     outb_p(count >> 8, nic_base + EN0_RCNTHI);
  1284.     outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
  1285.     outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
  1286.     outb_p(E8390_RREAD+E8390_START, nic_base + PCNET_CMD);
  1288.     insw(nic_base + PCNET_DATAPORT,buf,count>>1);
  1289.     if (count & 0x01)
  1290. buf[count-1] = inb(nic_base + PCNET_DATAPORT), xfer_count++;
  1292.     /* This was for the ALPHA version only, but enough people have
  1293.        encountering problems that it is still here. */
  1294. #ifdef PCMCIA_DEBUG
  1295.     if (ei_debug > 4) { /* DMA termination address check... */
  1296. int addr, tries = 20;
  1297. do {
  1298.     /* DON'T check for 'inb_p(EN0_ISR) & ENISR_RDC' here
  1299.        -- it's broken for Rx on some cards! */
  1300.     int high = inb_p(nic_base + EN0_RSARHI);
  1301.     int low = inb_p(nic_base + EN0_RSARLO);
  1302.     addr = (high << 8) + low;
  1303.     if (((ring_offset + xfer_count) & 0xff) == (addr & 0xff))
  1304. break;
  1305. } while (--tries > 0);
  1306. if (tries <= 0)
  1307.     printk(KERN_NOTICE "%s: RX transfer address mismatch,"
  1308.    "%#4.4x (expected) vs. %#4.4x (actual).n",
  1309.    dev->name, ring_offset + xfer_count, addr);
  1310.     }
  1311. #endif
  1312.     outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
  1313.     ei_status.dmaing &= ~0x01;
  1314. } /* dma_block_input */
  1316. /*====================================================================*/
  1318. static void dma_block_output(struct net_device *dev, int count,
  1319.      const u_char *buf, const int start_page)
  1320. {
  1321.     ioaddr_t nic_base = dev->base_addr;
  1322.     pcnet_dev_t *info = (pcnet_dev_t *)dev;
  1323. #ifdef PCMCIA_DEBUG
  1324.     int retries = 0;
  1325. #endif
  1326.     u_long dma_start;
  1328. #ifdef PCMCIA_DEBUG
  1329.     if (ei_debug > 4)
  1330. printk(KERN_DEBUG "%s: [bo=%d]n", dev->name, count);
  1331. #endif
  1333.     /* Round the count up for word writes.  Do we need to do this?
  1334.        What effect will an odd byte count have on the 8390?
  1335.        I should check someday. */
  1336.     if (count & 0x01)
  1337. count++;
  1338.     if (ei_status.dmaing) {
  1339. printk(KERN_NOTICE "%s: DMAing conflict in dma_block_output."
  1340.        "[DMAstat:%1x][irqlock:%1x]n",
  1341.        dev->name, ei_status.dmaing, ei_status.irqlock);
  1342. return;
  1343.     }
  1344.     ei_status.dmaing |= 0x01;
  1345.     /* We should already be in page 0, but to be safe... */
  1346.     outb_p(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base+PCNET_CMD);
  1348. #ifdef PCMCIA_DEBUG
  1349.   retry:
  1350. #endif
  1352.     outb_p(ENISR_RDC, nic_base + EN0_ISR);
  1354.     /* Now the normal output. */
  1355.     outb_p(count & 0xff, nic_base + EN0_RCNTLO);
  1356.     outb_p(count >> 8,   nic_base + EN0_RCNTHI);
  1357.     outb_p(0x00, nic_base + EN0_RSARLO);
  1358.     outb_p(start_page, nic_base + EN0_RSARHI);
  1360.     outb_p(E8390_RWRITE+E8390_START, nic_base + PCNET_CMD);
  1361.     outsw(nic_base + PCNET_DATAPORT, buf, count>>1);
  1363.     dma_start = jiffies;
  1365. #ifdef PCMCIA_DEBUG
  1366.     /* This was for the ALPHA version only, but enough people have
  1367.        encountering problems that it is still here. */
  1368.     if (ei_debug > 4) { /* DMA termination address check... */
  1369. int addr, tries = 20;
  1370. do {
  1371.     int high = inb_p(nic_base + EN0_RSARHI);
  1372.     int low = inb_p(nic_base + EN0_RSARLO);
  1373.     addr = (high << 8) + low;
  1374.     if ((start_page << 8) + count == addr)
  1375. break;
  1376. } while (--tries > 0);
  1377. if (tries <= 0) {
  1378.     printk(KERN_NOTICE "%s: Tx packet transfer address mismatch,"
  1379.    "%#4.4x (expected) vs. %#4.4x (actual).n",
  1380.    dev->name, (start_page << 8) + count, addr);
  1381.     if (retries++ == 0)
  1382. goto retry;
  1383. }
  1384.     }
  1385. #endif
  1387.     while ((inb_p(nic_base + EN0_ISR) & ENISR_RDC) == 0)
  1388. if (jiffies - dma_start > PCNET_RDC_TIMEOUT) {
  1389.     printk(KERN_NOTICE "%s: timeout waiting for Tx RDC.n",
  1390.    dev->name);
  1391.     pcnet_reset_8390(dev);
  1392.     NS8390_init(dev, 1);
  1393.     break;
  1394. }
  1396.     outb_p(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */
  1397.     if (info->flags & DELAY_OUTPUT)
  1398. udelay((long)delay_time);
  1399.     ei_status.dmaing &= ~0x01;
  1400. }
  1402. /*====================================================================*/
  1404. static int setup_dma_config(dev_link_t *link, int start_pg,
  1405.     int stop_pg)
  1406. {
  1407.     struct net_device *dev = link->priv;
  1409.     ei_status.tx_start_page = start_pg;
  1410.     ei_status.rx_start_page = start_pg + TX_PAGES;
  1411.     ei_status.stop_page = stop_pg;
  1413.     /* set up block i/o functions */
  1414.     ei_status.get_8390_hdr = &dma_get_8390_hdr;
  1415.     ei_status.block_input = &dma_block_input;
  1416.     ei_status.block_output = &dma_block_output;
  1418.     return 0;
  1419. }
  1421. /*====================================================================*/
  1423. static void copyin(u_char *dest, u_char *src, int c)
  1424. {
  1425.     u_short *d = (u_short *)dest, *s = (u_short *)src;
  1426.     int odd;
  1428.     if (c <= 0)
  1429. return;
  1430.     odd = (c & 1); c >>= 1;
  1432.     if (c) {
  1433. do { *d++ = __raw_readw(s++); } while (--c);
  1434.     }
  1435.     /* get last byte by fetching a word and masking */
  1436.     if (odd)
  1437. *((u_char *)d) = readw(s) & 0xff;
  1438. }
  1440. static void copyout(u_char *dest, const u_char *src, int c)
  1441. {
  1442.     u_short *d = (u_short *)dest, *s = (u_short *)src;
  1443.     int odd;
  1445.     if (c <= 0)
  1446. return;
  1447.     odd = (c & 1); c >>= 1;
  1449.     if (c) {
  1450. do { __raw_writew(*s++, d++); } while (--c);
  1451.     }
  1452.     /* copy last byte doing a read-modify-write */
  1453.     if (odd)
  1454. writew((readw(d) & 0xff00) | *(u_char *)s, d);
  1455. }
  1457. /*====================================================================*/
  1459. static void shmem_get_8390_hdr(struct net_device *dev,
  1460.        struct e8390_pkt_hdr *hdr,
  1461.        int ring_page)
  1462. {
  1463.     void *xfer_start = (void *)(dev->rmem_start + (ring_page << 8)
  1464. - (ei_status.rx_start_page << 8));
  1465.     
  1466.     copyin((void *)hdr, xfer_start, sizeof(struct e8390_pkt_hdr));
  1467.     /* Fix for big endian systems */
  1468.     hdr->count = le16_to_cpu(hdr->count);
  1469. }
  1471. /*====================================================================*/
  1473. static void shmem_block_input(struct net_device *dev, int count,
  1474.       struct sk_buff *skb, int ring_offset)
  1475. {
  1476.     void *xfer_start = (void *)(dev->rmem_start + ring_offset
  1477. - (ei_status.rx_start_page << 8));
  1478.     char *buf = skb->data;
  1479.     
  1480.     if (xfer_start + count > (void *)dev->rmem_end) {
  1481. /* We must wrap the input move. */
  1482. int semi_count = (void*)dev->rmem_end - xfer_start;
  1483. copyin(buf, xfer_start, semi_count);
  1484. buf += semi_count;
  1485. ring_offset = ei_status.rx_start_page << 8;
  1486. xfer_start = (void *)dev->rmem_start;
  1487. count -= semi_count;
  1488.     }
  1489.     copyin(buf, xfer_start, count);
  1490. }
  1492. /*====================================================================*/
  1494. static void shmem_block_output(struct net_device *dev, int count,
  1495.        const u_char *buf, const int start_page)
  1496. {
  1497.     void *shmem = (void *)dev->mem_start + (start_page << 8);
  1498.     shmem -= ei_status.tx_start_page << 8;
  1499.     copyout(shmem, buf, count);
  1500. }
  1502. /*====================================================================*/
  1504. static int setup_shmem_window(dev_link_t *link, int start_pg,
  1505.       int stop_pg, int cm_offset)
  1506. {
  1507.     struct net_device *dev = link->priv;
  1508.     pcnet_dev_t *info = link->priv;
  1509.     win_req_t req;
  1510.     memreq_t mem;
  1511.     int i, window_size, offset, last_ret, last_fn;
  1513.     window_size = (stop_pg - start_pg) << 8;
  1514.     if (window_size > 32 * 1024)
  1515. window_size = 32 * 1024;
  1517.     /* Make sure it's a power of two.  */
  1518.     while ((window_size & (window_size - 1)) != 0)
  1519. window_size += window_size & ~(window_size - 1);
  1521.     /* Allocate a memory window */
  1522.     req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
  1523.     req.Attributes |= WIN_USE_WAIT;
  1524.     req.Base = 0; req.Size = window_size;
  1525.     req.AccessSpeed = mem_speed;
  1526.     link->win = (window_handle_t)link->handle;
  1527.     CS_CHECK(RequestWindow, &link->win, &req);
  1529.     mem.CardOffset = (start_pg << 8) + cm_offset;
  1530.     offset = mem.CardOffset % window_size;
  1531.     mem.CardOffset -= offset;
  1532.     mem.Page = 0;
  1533.     CS_CHECK(MapMemPage, link->win, &mem);
  1535.     /* Try scribbling on the buffer */
  1536.     info->base = ioremap(req.Base, window_size);
  1537.     for (i = 0; i < (TX_PAGES<<8); i += 2)
  1538. __raw_writew((i>>1), info->base+offset+i);
  1539.     udelay(100);
  1540.     for (i = 0; i < (TX_PAGES<<8); i += 2)
  1541. if (__raw_readw(info->base+offset+i) != (i>>1)) break;
  1542.     pcnet_reset_8390(dev);
  1543.     if (i != (TX_PAGES<<8)) {
  1544. iounmap(info->base);
  1545. CardServices(ReleaseWindow, link->win);
  1546. info->base = NULL; link->win = NULL;
  1547. goto failed;
  1548.     }
  1549.     
  1550.     dev->mem_start = (u_long)info->base + offset;
  1551.     dev->rmem_start = dev->mem_start + (TX_PAGES<<8);
  1552.     dev->mem_end = dev->rmem_end = (u_long)info->base + req.Size;
  1554.     ei_status.tx_start_page = start_pg;
  1555.     ei_status.rx_start_page = start_pg + TX_PAGES;
  1556.     ei_status.stop_page = start_pg + ((req.Size - offset) >> 8);
  1558.     /* set up block i/o functions */
  1559.     ei_status.get_8390_hdr = &shmem_get_8390_hdr;
  1560.     ei_status.block_input = &shmem_block_input;
  1561.     ei_status.block_output = &shmem_block_output;
  1563.     info->flags |= USE_SHMEM;
  1564.     return 0;
  1566. cs_failed:
  1567.     cs_error(link->handle, last_fn, last_ret);
  1568. failed:
  1569.     return 1;
  1570. }
  1572. /*====================================================================*/
  1574. static int __init init_pcnet_cs(void)
  1575. {
  1576.     servinfo_t serv;
  1577.     DEBUG(0, "%sn", version);
  1578.     CardServices(GetCardServicesInfo, &serv);
  1579.     if (serv.Revision != CS_RELEASE_CODE) {
  1580. printk(KERN_NOTICE "pcnet_cs: Card Services release "
  1581.        "does not match!n");
  1582. return -1;
  1583.     }
  1584.     register_pccard_driver(&dev_info, &pcnet_attach, &pcnet_detach);
  1585.     return 0;
  1586. }
  1588. static void __exit exit_pcnet_cs(void)
  1589. {
  1590.     DEBUG(0, "pcnet_cs: unloadingn");
  1591.     unregister_pccard_driver(&dev_info);
  1592.     while (dev_list != NULL)
  1593. pcnet_detach(dev_list);
  1594. }
  1596. module_init(init_pcnet_cs);
  1597. module_exit(exit_pcnet_cs);