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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
smc91c92_cs.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：66k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

smc91c92_cs.c：源码内容
  1. /*======================================================================
  3.     A PCMCIA ethernet driver for SMC91c92-based cards.
  5.     This driver supports Megahertz PCMCIA ethernet cards; and
  6.     Megahertz, Motorola, Ositech, and Psion Dacom ethernet/modem
  7.     multifunction cards.
  9.     Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
  11.     smc91c92_cs.c 1.2 2002/09/28 15:00:00
  12.     
  13.     This driver contains code written by Donald Becker
  14.     (becker@scyld.com), Rowan Hughes (x-csrdh@jcu.edu.au),
  15.     David Hinds (dahinds@users.sourceforge.net), and Erik Stahlman
  16.     (erik@vt.edu).  Donald wrote the SMC 91c92 code using parts of
  17.     Erik's SMC 91c94 driver.  Rowan wrote a similar driver, and I've
  18.     incorporated some parts of his driver here.  I (Dave) wrote most
  19.     of the PCMCIA glue code, and the Ositech support code.  Kelly
  20.     Stephens (kstephen@holli.com) added support for the Motorola
  21.     Mariner, with help from Allen Brost. 
  23.     This software may be used and distributed according to the terms of
  24.     the GNU General Public License, incorporated herein by reference.
  26. ======================================================================*/
  28. #include <linux/module.h>
  29. #include <linux/kernel.h>
  30. #include <linux/init.h>
  31. #include <linux/sched.h>
  32. #include <linux/slab.h>
  33. #include <linux/string.h>
  34. #include <linux/timer.h>
  35. #include <linux/interrupt.h>
  36. #include <linux/delay.h>
  37. #include <linux/crc32.h>
  38. #include <asm/io.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>
  42. #include <linux/netdevice.h>
  43. #include <linux/etherdevice.h>
  44. #include <linux/skbuff.h>
  45. #include <linux/if_arp.h>
  46. #include <linux/ioport.h>
  47. #include <linux/ethtool.h>
  48. #include <linux/mii.h>
  50. #include <pcmcia/version.h>
  51. #include <pcmcia/cs_types.h>
  52. #include <pcmcia/cs.h>
  53. #include <pcmcia/cistpl.h>
  54. #include <pcmcia/cisreg.h>
  55. #include <pcmcia/ciscode.h>
  56. #include <pcmcia/ds.h>
  58. /* Ositech Seven of Diamonds firmware */
  59. #include "ositech.h"
  61. /*====================================================================*/
  63. static char *if_names[] = { "auto", "10baseT", "10base2"};
  65. /* Module parameters */
  67. MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
  68. MODULE_LICENSE("GPL");
  70. #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
  72. /*
  73.   Transceiver/media type.
  74.    0 = auto
  75.    1 = 10baseT (and autoselect if #define AUTOSELECT),
  76.    2 = AUI/10base2,
  77. */
  78. INT_MODULE_PARM(if_port, 0);
  80. /* Bit map of interrupts to choose from. */
  81. INT_MODULE_PARM(irq_mask, 0xdeb8);
  82. static int irq_list[4] = { -1 };
  83. MODULE_PARM(irq_list, "1-4i");
  85. #ifdef PCMCIA_DEBUG
  86. INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  87. static const char *version =
  88. "smc91c92_cs.c 0.09 1996/8/4 Donald Becker, becker@scyld.com.n";
  89. #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  90. #else
  91. #define DEBUG(n, args...)
  92. #endif
  94. #define DRV_NAME "smc91c92_cs"
  95. #define DRV_VERSION "1.2"
  97. /*====================================================================*/
  99. /* Operational parameter that usually are not changed. */
  101. /* Time in jiffies before concluding Tx hung */
  102. #define TX_TIMEOUT ((400*HZ)/1000)
  104. /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  105. #define INTR_WORK 4
  107. /* Times to check the check the chip before concluding that it doesn't
  108.    currently have room for another Tx packet. */
  109. #define MEMORY_WAIT_TIME        8
  111. static dev_info_t dev_info = "smc91c92_cs";
  113. static dev_link_t *dev_list;
  115. struct smc_private {
  116.     dev_link_t link;
  117.     struct net_device dev;
  118.     spinlock_t lock;
  119.     u_short manfid;
  120.     u_short cardid;
  121.     struct net_device_stats stats;
  122.     dev_node_t node;
  123.     struct sk_buff *saved_skb;
  124.     int packets_waiting;
  125.     caddr_t base;
  126.     u_short cfg;
  127.     struct timer_list media;
  128.     int watchdog, tx_err;
  129.     u_short media_status;
  130.     u_short fast_poll;
  131.     u_short link_status;
  132.     struct mii_if_info mii_if;
  133. };
  135. /* Special definitions for Megahertz multifunction cards */
  136. #define MEGAHERTZ_ISR 0x0380
  138. /* Special function registers for Motorola Mariner */
  139. #define MOT_LAN 0x0000
  140. #define MOT_UART 0x0020
  141. #define MOT_EEPROM 0x20
  143. #define MOT_NORMAL 
  144. (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
  146. /* Special function registers for Ositech cards */
  147. #define OSITECH_AUI_CTL 0x0c
  148. #define OSITECH_PWRDOWN 0x0d
  149. #define OSITECH_RESET 0x0e
  150. #define OSITECH_ISR 0x0f
  151. #define OSITECH_AUI_PWR 0x0c
  152. #define OSITECH_RESET_ISR 0x0e
  154. #define OSI_AUI_PWR 0x40
  155. #define OSI_LAN_PWRDOWN 0x02
  156. #define OSI_MODEM_PWRDOWN 0x01
  157. #define OSI_LAN_RESET 0x02
  158. #define OSI_MODEM_RESET 0x01
  160. /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
  161. #define BANK_SELECT 14 /* Window select register. */
  162. #define SMC_SELECT_BANK(x)  { outw(x, ioaddr + BANK_SELECT); }
  164. /* Bank 0 registers. */
  165. #define TCR  0 /* transmit control register */
  166. #define  TCR_CLEAR 0 /* do NOTHING */
  167. #define  TCR_ENABLE 0x0001 /* if this is 1, we can transmit */
  168. #define  TCR_PAD_EN 0x0080 /* pads short packets to 64 bytes */
  169. #define  TCR_MONCSN 0x0400  /* Monitor Carrier. */
  170. #define  TCR_FDUPLX 0x0800  /* Full duplex mode. */
  171. #define  TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
  173. #define EPH 2 /* Ethernet Protocol Handler report. */
  174. #define  EPH_TX_SUC 0x0001
  175. #define  EPH_SNGLCOL 0x0002
  176. #define  EPH_MULCOL 0x0004
  177. #define  EPH_LTX_MULT 0x0008
  178. #define  EPH_16COL 0x0010
  179. #define  EPH_SQET 0x0020
  180. #define  EPH_LTX_BRD 0x0040
  181. #define  EPH_TX_DEFR 0x0080
  182. #define  EPH_LAT_COL 0x0200
  183. #define  EPH_LOST_CAR 0x0400
  184. #define  EPH_EXC_DEF 0x0800
  185. #define  EPH_CTR_ROL 0x1000
  186. #define  EPH_RX_OVRN 0x2000
  187. #define  EPH_LINK_OK 0x4000
  188. #define  EPH_TX_UNRN 0x8000
  189. #define MEMINFO 8 /* Memory Information Register */
  190. #define MEMCFG 10 /* Memory Configuration Register */
  192. /* Bank 1 registers. */
  193. #define CONFIG 0
  194. #define  CFG_MII_SELECT 0x8000 /* 91C100 only */
  195. #define  CFG_NO_WAIT 0x1000
  196. #define  CFG_FULL_STEP 0x0400
  197. #define  CFG_SET_SQLCH 0x0200
  198. #define  CFG_AUI_SELECT   0x0100
  199. #define  CFG_16BIT 0x0080
  200. #define  CFG_DIS_LINK 0x0040
  201. #define  CFG_STATIC 0x0030
  202. #define  CFG_IRQ_SEL_1 0x0004
  203. #define  CFG_IRQ_SEL_0 0x0002
  204. #define BASE_ADDR 2
  205. #define ADDR0 4
  206. #define GENERAL 10
  207. #define CONTROL 12
  208. #define  CTL_STORE 0x0001
  209. #define  CTL_RELOAD 0x0002
  210. #define  CTL_EE_SELECT 0x0004
  211. #define  CTL_TE_ENABLE 0x0020
  212. #define  CTL_CR_ENABLE 0x0040
  213. #define  CTL_LE_ENABLE 0x0080
  214. #define  CTL_AUTO_RELEASE 0x0800
  215. #define  CTL_POWERDOWN 0x2000
  217. /* Bank 2 registers. */
  218. #define MMU_CMD 0
  219. #define  MC_ALLOC 0x20   /* or with number of 256 byte packets */
  220. #define  MC_RESET 0x40
  221. #define  MC_RELEASE   0x80   /* remove and release the current rx packet */
  222. #define  MC_FREEPKT   0xA0   /* Release packet in PNR register */
  223. #define  MC_ENQUEUE 0xC0  /* Enqueue the packet for transmit */
  224. #define PNR_ARR 2
  225. #define FIFO_PORTS 4
  226. #define  FP_RXEMPTY 0x8000
  227. #define POINTER 6
  228. #define  PTR_AUTO_INC 0x0040
  229. #define  PTR_READ 0x2000
  230. #define  PTR_AUTOINC  0x4000
  231. #define  PTR_RCV 0x8000
  232. #define DATA_1 8
  233. #define INTERRUPT 12
  234. #define  IM_RCV_INT 0x1
  235. #define  IM_TX_INT 0x2
  236. #define  IM_TX_EMPTY_INT 0x4
  237. #define  IM_ALLOC_INT 0x8
  238. #define  IM_RX_OVRN_INT 0x10
  239. #define  IM_EPH_INT 0x20
  241. #define RCR 4
  242. enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
  243.      RxEnable = 0x0100, RxStripCRC = 0x0200};
  244. #define  RCR_SOFTRESET 0x8000  /* resets the chip */
  245. #define  RCR_STRIP_CRC 0x200 /* strips CRC */
  246. #define  RCR_ENABLE 0x100 /* IFF this is set, we can receive packets */
  247. #define  RCR_ALMUL 0x4  /* receive all multicast packets */
  248. #define  RCR_PROMISC 0x2 /* enable promiscuous mode */
  250. /* the normal settings for the RCR register : */
  251. #define  RCR_NORMAL (RCR_STRIP_CRC | RCR_ENABLE)
  252. #define  RCR_CLEAR 0x0 /* set it to a base state */
  253. #define COUNTER 6
  255. /* BANK 3 -- not the same values as in smc9194! */
  256. #define MULTICAST0 0
  257. #define MULTICAST2 2
  258. #define MULTICAST4 4
  259. #define MULTICAST6 6
  260. #define MGMT     8 
  261. #define REVISION 0x0a
  263. /* Transmit status bits. */
  264. #define TS_SUCCESS 0x0001
  265. #define TS_16COL   0x0010
  266. #define TS_LATCOL  0x0200
  267. #define TS_LOSTCAR 0x0400
  269. /* Receive status bits. */
  270. #define RS_ALGNERR 0x8000
  271. #define RS_BADCRC 0x2000
  272. #define RS_ODDFRAME 0x1000
  273. #define RS_TOOLONG 0x0800
  274. #define RS_TOOSHORT 0x0400
  275. #define RS_MULTICAST 0x0001
  276. #define RS_ERRORS (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
  278. #define set_bits(v, p) outw(inw(p)|(v), (p))
  279. #define mask_bits(v, p) outw(inw(p)&(v), (p))
  281. /*====================================================================*/
  283. static dev_link_t *smc91c92_attach(void);
  284. static void smc91c92_detach(dev_link_t *);
  285. static void smc91c92_config(dev_link_t *link);
  286. static void smc91c92_release(u_long arg);
  287. static int smc91c92_event(event_t event, int priority,
  288.   event_callback_args_t *args);
  290. static int smc91c92_open(struct net_device *dev);
  291. static int smc91c92_close(struct net_device *dev);
  292. static void smc_tx_timeout(struct net_device *dev);
  293. static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
  294. static void smc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  295. static void smc_rx(struct net_device *dev);
  296. static struct net_device_stats *smc91c92_get_stats(struct net_device *dev);
  297. static void set_rx_mode(struct net_device *dev);
  298. static int s9k_config(struct net_device *dev, struct ifmap *map);
  299. static void smc_set_xcvr(struct net_device *dev, int if_port);
  300. static void smc_reset(struct net_device *dev);
  301. static void media_check(u_long arg);
  302. static void smc_mdio_sync(ioaddr_t addr);
  303. static int smc_mdio_read(struct net_device *dev, int phy_id, int loc);
  304. static void smc_mdio_write(struct net_device *dev, int phy_id, int loc, int value);
  305. static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  306. static int smc_link_ok(struct net_device *dev);
  308. /*======================================================================
  310.     This bit of code is used to avoid unregistering network devices
  311.     at inappropriate times.  2.2 and later kernels are fairly picky
  312.     about when this can happen.
  313.     
  314. ======================================================================*/
  316. static void flush_stale_links(void)
  317. {
  318.     dev_link_t *link, *next;
  319.     for (link = dev_list; link; link = next) {
  320. next = link->next;
  321. if (link->state & DEV_STALE_LINK)
  322.     smc91c92_detach(link);
  323.     }
  324. }
  326. /*====================================================================*/
  328. static void cs_error(client_handle_t handle, int func, int ret)
  329. {
  330.     error_info_t err = { func, ret };
  331.     CardServices(ReportError, handle, &err);
  332. }
  334. /*======================================================================
  336.   smc91c92_attach() creates an "instance" of the driver, allocating
  337.   local data structures for one device.  The device is registered
  338.   with Card Services.
  340. ======================================================================*/
  342. static dev_link_t *smc91c92_attach(void)
  343. {
  344.     client_reg_t client_reg;
  345.     struct smc_private *smc;
  346.     dev_link_t *link;
  347.     struct net_device *dev;
  348.     int i, ret;
  350.     DEBUG(0, "smc91c92_attach()n");
  351.     flush_stale_links();
  352.     
  353.     /* Create new ethernet device */
  354.     smc = kmalloc(sizeof(struct smc_private), GFP_KERNEL);
  355.     if (!smc) return NULL;
  356.     memset(smc, 0, sizeof(struct smc_private));
  357.     link = &smc->link; dev = &smc->dev;
  358.     spin_lock_init(&smc->lock);
  359.     link->release.function = &smc91c92_release;
  360.     link->release.data = (u_long)link;
  361.     link->io.NumPorts1 = 16;
  362.     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
  363.     link->io.IOAddrLines = 4;
  364.     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
  365.     link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
  366.     if (irq_list[0] == -1)
  367. link->irq.IRQInfo2 = irq_mask;
  368.     else
  369. for (i = 0; i < 4; i++)
  370.     link->irq.IRQInfo2 |= 1 << irq_list[i];
  371.     link->irq.Handler = &smc_interrupt;
  372.     link->conf.Attributes = CONF_ENABLE_IRQ;
  373.     link->conf.Vcc = 50;
  374.     link->conf.IntType = INT_MEMORY_AND_IO;
  376.     /* The SMC91c92-specific entries in the device structure. */
  377.     dev->hard_start_xmit = &smc_start_xmit;
  378.     dev->get_stats = &smc91c92_get_stats;
  379.     dev->set_config = &s9k_config;
  380.     dev->set_multicast_list = &set_rx_mode;
  381.     dev->do_ioctl = &smc_ioctl;
  382.     ether_setup(dev);
  383.     dev->open = &smc91c92_open;
  384.     dev->stop = &smc91c92_close;
  385. #ifdef HAVE_TX_TIMEOUT
  386.     dev->tx_timeout = smc_tx_timeout;
  387.     dev->watchdog_timeo = TX_TIMEOUT;
  388. #endif
  389.     dev->priv = link->priv = link->irq.Instance = smc;
  390.    
  391.     smc->mii_if.dev = dev;
  392.     smc->mii_if.mdio_read = smc_mdio_read;
  393.     smc->mii_if.mdio_write = smc_mdio_write;
  394.     smc->mii_if.phy_id_mask = 0x1f;
  395.     smc->mii_if.reg_num_mask = 0x1f;
  396.     
  397.     /* Register with Card Services */
  398.     link->next = dev_list;
  399.     dev_list = link;
  400.     client_reg.dev_info = &dev_info;
  401.     client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
  402.     client_reg.EventMask = CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
  403. CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
  404. CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
  405.     client_reg.event_handler = &smc91c92_event;
  406.     client_reg.Version = 0x0210;
  407.     client_reg.event_callback_args.client_data = link;
  408.     ret = CardServices(RegisterClient, &link->handle, &client_reg);
  409.     if (ret != 0) {
  410. cs_error(link->handle, RegisterClient, ret);
  411. smc91c92_detach(link);
  412. return NULL;
  413.     }
  414.     
  415.     return link;
  416. } /* smc91c92_attach */
  418. /*======================================================================
  420.     This deletes a driver "instance".  The device is de-registered
  421.     with Card Services.  If it has been released, all local data
  422.     structures are freed.  Otherwise, the structures will be freed
  423.     when the device is released.
  425. ======================================================================*/
  427. static void smc91c92_detach(dev_link_t *link)
  428. {
  429.     struct smc_private *smc = link->priv;
  430.     dev_link_t **linkp;
  432.     DEBUG(0, "smc91c92_detach(0x%p)n", link);
  433.     
  434.     /* Locate device structure */
  435.     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
  436. if (*linkp == link) break;
  437.     if (*linkp == NULL)
  438. return;
  439.     
  440.     del_timer(&link->release);
  441.     if (link->state & DEV_CONFIG) {
  442. smc91c92_release((u_long)link);
  443. if (link->state & DEV_STALE_CONFIG) {
  444.     link->state |= DEV_STALE_LINK;
  445.     return;
  446. }
  447.     }
  448.     
  449.     if (link->handle)
  450. CardServices(DeregisterClient, link->handle);
  451.     
  452.     /* Unlink device structure, free bits */
  453.     *linkp = link->next;
  454.     if (link->dev)
  455. unregister_netdev(&smc->dev);
  456.     kfree(smc);
  457.     
  458. } /* smc91c92_detach */
  460. /*====================================================================*/
  462. static int cvt_ascii_address(struct net_device *dev, char *s)
  463. {
  464.     int i, j, da, c;
  466.     if (strlen(s) != 12)
  467. return -1;
  468.     for (i = 0; i < 6; i++) {
  469. da = 0;
  470. for (j = 0; j < 2; j++) {
  471.     c = *s++;
  472.     da <<= 4;
  473.     da += ((c >= '0') && (c <= '9')) ?
  474. (c - '0') : ((c & 0x0f) + 9);
  475. }
  476. dev->dev_addr[i] = da;
  477.     }
  478.     return 0;
  479. }
  481. /*====================================================================*/
  483. static int get_tuple(int fn, client_handle_t handle, tuple_t *tuple,
  484.      cisparse_t *parse)
  485. {
  486.     int i;
  487.     i = CardServices(fn, handle, tuple);
  488.     if (i != CS_SUCCESS) return i;
  489.     i = CardServices(GetTupleData, handle, tuple);
  490.     if (i != CS_SUCCESS) return i;
  491.     return CardServices(ParseTuple, handle, tuple, parse);
  492. }
  494. #define first_tuple(a, b, c) get_tuple(GetFirstTuple, a, b, c)
  495. #define next_tuple(a, b, c) get_tuple(GetNextTuple, a, b, c)
  497. /*======================================================================
  499.     Configuration stuff for Megahertz cards
  501.     mhz_3288_power() is used to power up a 3288's ethernet chip.
  502.     mhz_mfc_config() handles socket setup for multifunction (1144
  503.     and 3288) cards.  mhz_setup() gets a card's hardware ethernet
  504.     address.
  505.     
  506. ======================================================================*/
  508. static int mhz_3288_power(dev_link_t *link)
  509. {
  510.     struct smc_private *smc = link->priv;
  511.     u_char tmp;
  512.     
  513.     /* Read the ISR twice... */
  514.     readb(smc->base+MEGAHERTZ_ISR);
  515.     udelay(5);
  516.     readb(smc->base+MEGAHERTZ_ISR);
  518.     /* Pause 200ms... */
  519.     mdelay(200);
  520.     
  521.     /* Now read and write the COR... */
  522.     tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
  523.     udelay(5);
  524.     writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
  526.     return 0;
  527. }
  529. static int mhz_mfc_config(dev_link_t *link)
  530. {
  531.     struct smc_private *smc = link->priv;
  532.     struct net_device *dev = &smc->dev;
  533.     tuple_t tuple;
  534.     cisparse_t parse;
  535.     u_char buf[255];
  536.     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
  537.     win_req_t req;
  538.     memreq_t mem;
  539.     int i, k;
  541.     link->conf.Attributes |= CONF_ENABLE_SPKR;
  542.     link->conf.Status = CCSR_AUDIO_ENA;
  543.     link->irq.Attributes =
  544. IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
  545.     link->io.IOAddrLines = 16;
  546.     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
  547.     link->io.NumPorts2 = 8;
  549.     tuple.Attributes = tuple.TupleOffset = 0;
  550.     tuple.TupleData = (cisdata_t *)buf;
  551.     tuple.TupleDataMax = sizeof(buf);
  552.     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
  554.     i = first_tuple(link->handle, &tuple, &parse);
  555.     /* The Megahertz combo cards have modem-like CIS entries, so
  556.        we have to explicitly try a bunch of port combinations. */
  557.     while (i == CS_SUCCESS) {
  558. link->conf.ConfigIndex = cf->index;
  559. link->io.BasePort2 = cf->io.win[0].base;
  560. for (k = 0; k < 0x400; k += 0x10) {
  561.     if (k & 0x80) continue;
  562.     link->io.BasePort1 = k ^ 0x300;
  563.     i = CardServices(RequestIO, link->handle, &link->io);
  564.     if (i == CS_SUCCESS) break;
  565. }
  566. if (i == CS_SUCCESS) break;
  567. i = next_tuple(link->handle, &tuple, &parse);
  568.     }
  569.     if (i != CS_SUCCESS)
  570. return i;
  571.     dev->base_addr = link->io.BasePort1;
  572.     
  573.     /* Allocate a memory window, for accessing the ISR */
  574.     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
  575.     req.Base = req.Size = 0;
  576.     req.AccessSpeed = 0;
  577.     link->win = (window_handle_t)link->handle;
  578.     i = CardServices(RequestWindow, &link->win, &req);
  579.     if (i != CS_SUCCESS)
  580. return i;
  581.     smc->base = ioremap(req.Base, req.Size);
  582.     mem.CardOffset = mem.Page = 0;
  583.     if (smc->manfid == MANFID_MOTOROLA)
  584. mem.CardOffset = link->conf.ConfigBase;
  585.     i = CardServices(MapMemPage, link->win, &mem);
  586.     
  587.     if ((i == CS_SUCCESS)
  588. && (smc->manfid == MANFID_MEGAHERTZ)
  589. && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
  590. mhz_3288_power(link);
  591.     
  592.     return i;
  593. }
  595. static int mhz_setup(dev_link_t *link)
  596. {
  597.     client_handle_t handle = link->handle;
  598.     struct smc_private *smc = link->priv;
  599.     struct net_device *dev = &smc->dev;
  600.     tuple_t tuple;
  601.     cisparse_t parse;
  602.     u_char buf[255], *station_addr;
  604.     tuple.Attributes = tuple.TupleOffset = 0;
  605.     tuple.TupleData = buf;
  606.     tuple.TupleDataMax = sizeof(buf);
  608.     /* Read the station address from the CIS.  It is stored as the last
  609.        (fourth) string in the Version 1 Version/ID tuple. */
  610.     tuple.DesiredTuple = CISTPL_VERS_1;
  611.     if (first_tuple(handle, &tuple, &parse) != CS_SUCCESS)
  612. return -1;
  613.     /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
  614.     if (next_tuple(handle, &tuple, &parse) != CS_SUCCESS)
  615. first_tuple(handle, &tuple, &parse);
  616.     if (parse.version_1.ns > 3) {
  617. station_addr = parse.version_1.str + parse.version_1.ofs[3];
  618. if (cvt_ascii_address(dev, station_addr) == 0)
  619.     return 0;
  620.     }
  622.     /* Another possibility: for the EM3288, in a special tuple */
  623.     tuple.DesiredTuple = 0x81;
  624.     if (CardServices(GetFirstTuple, handle, &tuple) != CS_SUCCESS)
  625. return -1;
  626.     if (CardServices(GetTupleData, handle, &tuple) != CS_SUCCESS)
  627. return -1;
  628.     buf[12] = '';
  629.     if (cvt_ascii_address(dev, buf) == 0)
  630. return 0;
  631.     
  632.     return -1;
  633. }
  635. /*======================================================================
  637.     Configuration stuff for the Motorola Mariner
  639.     mot_config() writes directly to the Mariner configuration
  640.     registers because the CIS is just bogus.
  641.     
  642. ======================================================================*/
  644. static void mot_config(dev_link_t *link)
  645. {
  646.     struct smc_private *smc = link->priv;
  647.     struct net_device *dev = &smc->dev;
  648.     ioaddr_t ioaddr = dev->base_addr;
  649.     ioaddr_t iouart = link->io.BasePort2;
  650.     
  651.     /* Set UART base address and force map with COR bit 1 */
  652.     writeb(iouart & 0xff,        smc->base + MOT_UART + CISREG_IOBASE_0);
  653.     writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
  654.     writeb(MOT_NORMAL,           smc->base + MOT_UART + CISREG_COR);
  655.     
  656.     /* Set SMC base address and force map with COR bit 1 */
  657.     writeb(ioaddr & 0xff,        smc->base + MOT_LAN + CISREG_IOBASE_0);
  658.     writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
  659.     writeb(MOT_NORMAL,           smc->base + MOT_LAN + CISREG_COR);
  661.     /* Wait for things to settle down */
  662.     mdelay(100);
  663. }
  665. static int mot_setup(dev_link_t *link)
  666. {
  667.     struct smc_private *smc = link->priv;
  668.     struct net_device *dev = &smc->dev;
  669.     ioaddr_t ioaddr = dev->base_addr;
  670.     int i, wait, loop;
  671.     u_int addr;
  673.     /* Read Ethernet address from Serial EEPROM */
  674.     
  675.     for (i = 0; i < 3; i++) {
  676. SMC_SELECT_BANK(2);
  677. outw(MOT_EEPROM + i, ioaddr + POINTER);
  678. SMC_SELECT_BANK(1);
  679. outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
  681. for (loop = wait = 0; loop < 200; loop++) {
  682.     udelay(10);
  683.     wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
  684.     if (wait == 0) break;
  685. }
  687. if (wait)
  688.     return -1;
  690. addr = inw(ioaddr + GENERAL);
  691. dev->dev_addr[2*i]   = addr & 0xff;
  692. dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
  693.     }
  694.     
  695.     return 0;
  696. }
  698. /*====================================================================*/
  700. static int smc_config(dev_link_t *link)
  701. {
  702.     struct smc_private *smc = link->priv;
  703.     struct net_device *dev = &smc->dev;
  704.     tuple_t tuple;
  705.     cisparse_t parse;
  706.     u_char buf[255];
  707.     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
  708.     int i;
  710.     tuple.Attributes = tuple.TupleOffset = 0;
  711.     tuple.TupleData = (cisdata_t *)buf;
  712.     tuple.TupleDataMax = sizeof(buf);
  713.     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
  715.     link->io.NumPorts1 = 16;
  716.     i = first_tuple(link->handle, &tuple, &parse);
  717.     while (i != CS_NO_MORE_ITEMS) {
  718. if (i == CS_SUCCESS) {
  719.     link->conf.ConfigIndex = cf->index;
  720.     link->io.BasePort1 = cf->io.win[0].base;
  721.     link->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
  722.     i = CardServices(RequestIO, link->handle, &link->io);
  723.     if (i == CS_SUCCESS) break;
  724. }
  725. i = next_tuple(link->handle, &tuple, &parse);
  726.     }
  727.     if (i == CS_SUCCESS)
  728. dev->base_addr = link->io.BasePort1;
  729.     return i;
  730. }
  732. static int smc_setup(dev_link_t *link)
  733. {
  734.     client_handle_t handle = link->handle;
  735.     struct smc_private *smc = link->priv;
  736.     struct net_device *dev = &smc->dev;
  737.     tuple_t tuple;
  738.     cisparse_t parse;
  739.     cistpl_lan_node_id_t *node_id;
  740.     u_char buf[255], *station_addr;
  741.     int i;
  743.     tuple.Attributes = tuple.TupleOffset = 0;
  744.     tuple.TupleData = buf;
  745.     tuple.TupleDataMax = sizeof(buf);
  746.     
  747.     /* Check for a LAN function extension tuple */
  748.     tuple.DesiredTuple = CISTPL_FUNCE;
  749.     i = first_tuple(handle, &tuple, &parse);
  750.     while (i == CS_SUCCESS) {
  751. if (parse.funce.type == CISTPL_FUNCE_LAN_NODE_ID)
  752.     break;
  753. i = next_tuple(handle, &tuple, &parse);
  754.     }
  755.     if (i == CS_SUCCESS) {
  756. node_id = (cistpl_lan_node_id_t *)parse.funce.data;
  757. if (node_id->nb == 6) {
  758.     for (i = 0; i < 6; i++)
  759. dev->dev_addr[i] = node_id->id[i];
  760.     return 0;
  761. }
  762.     }
  763.     
  764.     /* Try the third string in the Version 1 Version/ID tuple. */
  765.     tuple.DesiredTuple = CISTPL_VERS_1;
  766.     if (first_tuple(handle, &tuple, &parse) != CS_SUCCESS)
  767. return -1;
  768.     station_addr = parse.version_1.str + parse.version_1.ofs[2];
  769.     if (cvt_ascii_address(dev, station_addr) == 0)
  770. return 0;
  772.     return -1;
  773. }
  775. /*====================================================================*/
  777. static int osi_config(dev_link_t *link)
  778. {
  779.     struct smc_private *smc = link->priv;
  780.     struct net_device *dev = &smc->dev;
  781.     static ioaddr_t com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
  782.     int i, j;
  783.     
  784.     link->conf.Attributes |= CONF_ENABLE_SPKR;
  785.     link->conf.Status = CCSR_AUDIO_ENA;
  786.     link->irq.Attributes =
  787. IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
  788.     link->io.NumPorts1 = 64;
  789.     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
  790.     link->io.NumPorts2 = 8;
  791.     link->io.IOAddrLines = 16;
  792.     
  793.     /* Enable Hard Decode, LAN, Modem */
  794.     link->conf.ConfigIndex = 0x23;
  795.     
  796.     for (i = j = 0; j < 4; j++) {
  797. link->io.BasePort2 = com[j];
  798. i = CardServices(RequestIO, link->handle, &link->io);
  799. if (i == CS_SUCCESS) break;
  800.     }
  801.     if (i != CS_SUCCESS) {
  802. /* Fallback: turn off hard decode */
  803. link->conf.ConfigIndex = 0x03;
  804. link->io.NumPorts2 = 0;
  805. i = CardServices(RequestIO, link->handle, &link->io);
  806.     }
  807.     dev->base_addr = link->io.BasePort1 + 0x10;
  808.     return i;
  809. }
  811. static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid)
  812. {
  813.     client_handle_t handle = link->handle;
  814.     struct smc_private *smc = link->priv;
  815.     struct net_device *dev = &smc->dev;
  816.     tuple_t tuple;
  817.     u_char buf[255];
  818.     int i;
  819.     
  820.     tuple.Attributes = TUPLE_RETURN_COMMON;
  821.     tuple.TupleData = buf;
  822.     tuple.TupleDataMax = sizeof(buf);
  823.     tuple.TupleOffset = 0;
  824.     
  825.     /* Read the station address from tuple 0x90, subtuple 0x04 */
  826.     tuple.DesiredTuple = 0x90;
  827.     i = CardServices(GetFirstTuple, handle, &tuple);
  828.     while (i == CS_SUCCESS) {
  829. i = CardServices(GetTupleData, handle, &tuple);
  830. if ((i != CS_SUCCESS) || (buf[0] == 0x04))
  831.     break;
  832. i = CardServices(GetNextTuple, handle, &tuple);
  833.     }
  834.     if (i != CS_SUCCESS)
  835. return -1;
  836.     for (i = 0; i < 6; i++)
  837. dev->dev_addr[i] = buf[i+2];
  839.     if (((manfid == MANFID_OSITECH) &&
  840.  (cardid == PRODID_OSITECH_SEVEN)) ||
  841. ((manfid == MANFID_PSION) &&
  842.  (cardid == PRODID_PSION_NET100))) {
  843. /* Download the Seven of Diamonds firmware */
  844. for (i = 0; i < sizeof(__Xilinx7OD); i++) {
  845.     outb(__Xilinx7OD[i], link->io.BasePort1+2);
  846.     udelay(50);
  847. }
  848.     } else if (manfid == MANFID_OSITECH) {
  849. /* Make sure both functions are powered up */
  850. set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
  851. /* Now, turn on the interrupt for both card functions */
  852. set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
  853. DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4xn",
  854.       inw(link->io.BasePort1 + OSITECH_AUI_PWR),
  855.       inw(link->io.BasePort1 + OSITECH_RESET_ISR));
  856.     }
  858.     return 0;
  859. }
  861. /*======================================================================
  863.     This verifies that the chip is some SMC91cXX variant, and returns
  864.     the revision code if successful.  Otherwise, it returns -ENODEV.
  865.     
  866. ======================================================================*/
  868. static int check_sig(dev_link_t *link)
  869. {
  870.     struct smc_private *smc = link->priv;
  871.     struct net_device *dev = &smc->dev;
  872.     ioaddr_t ioaddr = dev->base_addr;
  873.     int width;
  874.     u_short s;
  876.     SMC_SELECT_BANK(1);
  877.     if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
  878. /* Try powering up the chip */
  879. outw(0, ioaddr + CONTROL);
  880. mdelay(55);
  881.     }
  883.     /* Try setting bus width */
  884.     width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
  885.     s = inb(ioaddr + CONFIG);
  886.     if (width)
  887. s |= CFG_16BIT;
  888.     else
  889. s &= ~CFG_16BIT;
  890.     outb(s, ioaddr + CONFIG);
  891.     
  892.     /* Check Base Address Register to make sure bus width is OK */
  893.     s = inw(ioaddr + BASE_ADDR);
  894.     if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
  895. ((s >> 8) != (s & 0xff))) {
  896. SMC_SELECT_BANK(3);
  897. s = inw(ioaddr + REVISION);
  898. return (s & 0xff);
  899.     }
  901.     if (width) {
  902. event_callback_args_t args;
  903. printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.n");
  904. args.client_data = link;
  905. smc91c92_event(CS_EVENT_RESET_PHYSICAL, 0, &args);
  906. CardServices(ReleaseIO, link->handle, &link->io);
  907. link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
  908. CardServices(RequestIO, link->handle, &link->io);
  909. smc91c92_event(CS_EVENT_CARD_RESET, 0, &args);
  910. return check_sig(link);
  911.     }
  912.     return -ENODEV;
  913. }
  915. /*======================================================================
  917.     smc91c92_config() is scheduled to run after a CARD_INSERTION event
  918.     is received, to configure the PCMCIA socket, and to make the
  919.     ethernet device available to the system.
  921. ======================================================================*/
  923. #define CS_EXIT_TEST(ret, svc, label) 
  924. if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
  926. static void smc91c92_config(dev_link_t *link)
  927. {
  928.     client_handle_t handle = link->handle;
  929.     struct smc_private *smc = link->priv;
  930.     struct net_device *dev = &smc->dev;
  931.     tuple_t tuple;
  932.     cisparse_t parse;
  933.     u_short buf[32];
  934.     char *name;
  935.     int i, j, rev;
  936.     ioaddr_t ioaddr;
  938.     DEBUG(0, "smc91c92_config(0x%p)n", link);
  939.     
  940.     tuple.Attributes = tuple.TupleOffset = 0;
  941.     tuple.TupleData = (cisdata_t *)buf;
  942.     tuple.TupleDataMax = sizeof(buf);
  944.     tuple.DesiredTuple = CISTPL_CONFIG;
  945.     i = first_tuple(handle, &tuple, &parse);
  946.     CS_EXIT_TEST(i, ParseTuple, config_failed);
  947.     link->conf.ConfigBase = parse.config.base;
  948.     link->conf.Present = parse.config.rmask[0];
  949.     
  950.     tuple.DesiredTuple = CISTPL_MANFID;
  951.     tuple.Attributes = TUPLE_RETURN_COMMON;
  952.     if (first_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
  953. smc->manfid = parse.manfid.manf;
  954. smc->cardid = parse.manfid.card;
  955.     }
  956.     
  957.     /* Configure card */
  958.     link->state |= DEV_CONFIG;
  960.     if ((smc->manfid == MANFID_OSITECH) &&
  961. (smc->cardid != PRODID_OSITECH_SEVEN)) {
  962. i = osi_config(link);
  963.     } else if ((smc->manfid == MANFID_MOTOROLA) ||
  964.        ((smc->manfid == MANFID_MEGAHERTZ) &&
  965. ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
  966.  (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
  967. i = mhz_mfc_config(link);
  968.     } else {
  969. i = smc_config(link);
  970.     }
  971.     CS_EXIT_TEST(i, RequestIO, config_failed);
  972.     
  973.     i = CardServices(RequestIRQ, link->handle, &link->irq);
  974.     CS_EXIT_TEST(i, RequestIRQ, config_failed);
  975.     i = CardServices(RequestConfiguration, link->handle, &link->conf);
  976.     CS_EXIT_TEST(i, RequestConfiguration, config_failed);
  977.     
  978.     if (smc->manfid == MANFID_MOTOROLA)
  979. mot_config(link);
  981.     dev->irq = link->irq.AssignedIRQ;
  983.     if ((if_port >= 0) && (if_port <= 2))
  984. dev->if_port = if_port;
  985.     else
  986. printk(KERN_NOTICE "smc91c92_cs: invalid if_port requestedn");
  987.     
  988.     if (register_netdev(dev) != 0) {
  989. printk(KERN_ERR "smc91c92_cs: register_netdev() failedn");
  990. goto config_undo;
  991.     }
  993.     switch (smc->manfid) {
  994.     case MANFID_OSITECH:
  995.     case MANFID_PSION:
  996. i = osi_setup(link, smc->manfid, smc->cardid); break;
  997.     case MANFID_SMC:
  998.     case MANFID_NEW_MEDIA:
  999. i = smc_setup(link); break;
  1000.     case 0x128: /* For broken Megahertz cards */
  1001.     case MANFID_MEGAHERTZ:
  1002. i = mhz_setup(link); break;
  1003.     case MANFID_MOTOROLA:
  1004.     default: /* get the hw address from EEPROM */
  1005. i = mot_setup(link); break;
  1006.     }
  1007.     
  1008.     if (i != 0) {
  1009. printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.n");
  1010. link->state &= ~DEV_CONFIG_PENDING;
  1011. goto config_undo;
  1012.     }
  1014.     strcpy(smc->node.dev_name, dev->name);
  1015.     link->dev = &smc->node;
  1016.     link->state &= ~DEV_CONFIG_PENDING;
  1018.     rev = check_sig(link);
  1019.     name = "???";
  1020.     if (rev > 0)
  1021. switch (rev >> 4) {
  1022. case 3: name = "92"; break;
  1023. case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
  1024. case 5: name = "95"; break;
  1025. case 7: name = "100"; break;
  1026. case 8: name = "100-FD"; break;
  1027. case 9: name = "110"; break;
  1028. }
  1029.     printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
  1030.    "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
  1031.    dev->irq);
  1032.     for (i = 0; i < 6; i++)
  1033. printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "n"));
  1035.     ioaddr = dev->base_addr;
  1036.     if (rev > 0) {
  1037. u_long mir, mcr;
  1038. SMC_SELECT_BANK(0);
  1039. mir = inw(ioaddr + MEMINFO) & 0xff;
  1040. if (mir == 0xff) mir++;
  1041. /* Get scale factor for memory size */
  1042. mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
  1043. mir *= 128 * (1<<((mcr >> 9) & 7));
  1044. if (mir & 0x3ff)
  1045.     printk(KERN_INFO "  %lu byte", mir);
  1046. else
  1047.     printk(KERN_INFO "  %lu kb", mir>>10);
  1048. SMC_SELECT_BANK(1);
  1049. smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
  1050. smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
  1051. if (smc->manfid == MANFID_OSITECH)
  1052.     smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
  1053. if ((rev >> 4) >= 7)
  1054.     smc->cfg |= CFG_MII_SELECT;
  1055. printk(" buffer, %s xcvrn", (smc->cfg & CFG_MII_SELECT) ?
  1056.        "MII" : if_names[dev->if_port]);
  1057.     }
  1058.     
  1059.     if (smc->cfg & CFG_MII_SELECT) {
  1060. SMC_SELECT_BANK(3);
  1062. for (i = 0; i < 32; i++) {
  1063.     j = smc_mdio_read(dev, i, 1);
  1064.     if ((j != 0) && (j != 0xffff)) break;
  1065. }
  1066. smc->mii_if.phy_id = (i < 32) ? i : -1;
  1067. if (i < 32) {
  1068.     DEBUG(0, "  MII transceiver at index %d, status %x.n", i, j);
  1069. } else {
  1070.          printk(KERN_NOTICE "  No MII transceivers found!n");
  1071. }
  1073. SMC_SELECT_BANK(0);
  1074.     }
  1076.     return;
  1077.     
  1078. config_undo:
  1079.     unregister_netdev(dev);
  1080. config_failed: /* CS_EXIT_TEST() calls jump to here... */
  1081.     smc91c92_release((u_long)link);
  1082.     
  1083. } /* smc91c92_config */
  1085. /*======================================================================
  1087.     After a card is removed, smc91c92_release() will unregister the net
  1088.     device, and release the PCMCIA configuration.  If the device is
  1089.     still open, this will be postponed until it is closed.
  1091. ======================================================================*/
  1093. static void smc91c92_release(u_long arg)
  1094. {
  1095.     dev_link_t *link = (dev_link_t *)arg;
  1096.     struct smc_private *smc = link->priv;
  1098.     DEBUG(0, "smc91c92_release(0x%p)n", link);
  1099.     
  1100.     if (link->open) {
  1101. DEBUG(1, "smc91c92_cs: release postponed, '%s' still openn",
  1102.       link->dev->dev_name);
  1103. link->state |= DEV_STALE_CONFIG;
  1104. return;
  1105.     }
  1106.     
  1107.     CardServices(ReleaseConfiguration, link->handle);
  1108.     CardServices(ReleaseIO, link->handle, &link->io);
  1109.     CardServices(ReleaseIRQ, link->handle, &link->irq);
  1110.     if (link->win) {
  1111. iounmap(smc->base);
  1112. CardServices(ReleaseWindow, link->win);
  1113.     }
  1114.     
  1115.     link->state &= ~DEV_CONFIG;
  1117. } /* smc91c92_release */
  1119. /*======================================================================
  1121.     The card status event handler.  Mostly, this schedules other
  1122.     stuff to run after an event is received.  A CARD_REMOVAL event
  1123.     also sets some flags to discourage the net drivers from trying
  1124.     to talk to the card any more.
  1126. ======================================================================*/
  1128. static int smc91c92_event(event_t event, int priority,
  1129.   event_callback_args_t *args)
  1130. {
  1131.     dev_link_t *link = args->client_data;
  1132.     struct smc_private *smc = link->priv;
  1133.     struct net_device *dev = &smc->dev;
  1134.     int i;   
  1135.  
  1136.     DEBUG(1, "smc91c92_event(0x%06x)n", event);
  1138.     switch (event) {
  1139.     case CS_EVENT_CARD_REMOVAL:
  1140. link->state &= ~DEV_PRESENT;
  1141. if (link->state & DEV_CONFIG) {
  1142.     netif_device_detach(dev);
  1143.     mod_timer(&link->release, jiffies + HZ/20);
  1144. }
  1145. break;
  1146.     case CS_EVENT_CARD_INSERTION:
  1147. link->state |= DEV_PRESENT;
  1148. smc91c92_config(link);
  1149. break;
  1150.     case CS_EVENT_PM_SUSPEND:
  1151. link->state |= DEV_SUSPEND;
  1152. /* Fall through... */
  1153.     case CS_EVENT_RESET_PHYSICAL:
  1154. if (link->state & DEV_CONFIG) {
  1155.     if (link->open)
  1156. netif_device_detach(dev);
  1157.     CardServices(ReleaseConfiguration, link->handle);
  1158. }
  1159. break;
  1160.     case CS_EVENT_PM_RESUME:
  1161. link->state &= ~DEV_SUSPEND;
  1162. /* Fall through... */
  1163.     case CS_EVENT_CARD_RESET:
  1164. if (link->state & DEV_CONFIG) {
  1165.     if ((smc->manfid == MANFID_MEGAHERTZ) &&
  1166. (smc->cardid == PRODID_MEGAHERTZ_EM3288))
  1167. mhz_3288_power(link);
  1168.     CardServices(RequestConfiguration, link->handle, &link->conf);
  1169.     if (smc->manfid == MANFID_MOTOROLA)
  1170. mot_config(link);
  1171.     if ((smc->manfid == MANFID_OSITECH) &&
  1172. (smc->cardid != PRODID_OSITECH_SEVEN)) {
  1173. /* Power up the card and enable interrupts */
  1174. set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
  1175. set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
  1176.     }
  1177.     if (((smc->manfid == MANFID_OSITECH) &&
  1178.   (smc->cardid == PRODID_OSITECH_SEVEN)) ||
  1179. ((smc->manfid == MANFID_PSION) &&
  1180.   (smc->cardid == PRODID_PSION_NET100))) {
  1181. /* Download the Seven of Diamonds firmware */
  1182. for (i = 0; i < sizeof(__Xilinx7OD); i++) {
  1183.          outb(__Xilinx7OD[i], link->io.BasePort1+2);
  1184.         udelay(50);
  1185. }
  1186.     }
  1187.     if (link->open) {
  1188. smc_reset(dev);
  1189. netif_device_attach(dev);
  1190.     }
  1191. }
  1192. break;
  1193.     }
  1194.     return 0;
  1195. } /* smc91c92_event */
  1197. /*======================================================================
  1199.     MII interface support for SMC91cXX based cards
  1200. ======================================================================*/
  1202. #define MDIO_SHIFT_CLK 0x04
  1203. #define MDIO_DATA_OUT 0x01
  1204. #define MDIO_DIR_WRITE 0x08
  1205. #define MDIO_DATA_WRITE0 (MDIO_DIR_WRITE)
  1206. #define MDIO_DATA_WRITE1 (MDIO_DIR_WRITE | MDIO_DATA_OUT)
  1207. #define MDIO_DATA_READ 0x02
  1209. static void smc_mdio_sync(ioaddr_t addr)
  1210. {
  1211.     int bits;
  1212.     for (bits = 0; bits < 32; bits++) {
  1213. outb(MDIO_DATA_WRITE1, addr);
  1214. outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
  1215.     }
  1216. }
  1218. static int smc_mdio_read(struct net_device *dev, int phy_id, int loc)
  1219. {
  1220.     ioaddr_t addr = dev->base_addr + MGMT;
  1221.     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
  1222.     int i, retval = 0;
  1224.     smc_mdio_sync(addr);
  1225.     for (i = 13; i >= 0; i--) {
  1226. int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
  1227. outb(dat, addr);
  1228. outb(dat | MDIO_SHIFT_CLK, addr);
  1229.     }
  1230.     for (i = 19; i > 0; i--) {
  1231. outb(0, addr);
  1232. retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
  1233. outb(MDIO_SHIFT_CLK, addr);
  1234.     }
  1235.     return (retval>>1) & 0xffff;
  1236. }
  1238. static void smc_mdio_write(struct net_device *dev, int phy_id, int loc, int value)
  1239. {
  1240.     ioaddr_t addr = dev->base_addr + MGMT;
  1241.     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
  1242.     int i;
  1244.     smc_mdio_sync(addr);
  1245.     for (i = 31; i >= 0; i--) {
  1246. int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
  1247. outb(dat, addr);
  1248. outb(dat | MDIO_SHIFT_CLK, addr);
  1249.     }
  1250.     for (i = 1; i >= 0; i--) {
  1251. outb(0, addr);
  1252. outb(MDIO_SHIFT_CLK, addr);
  1253.     }
  1254. }
  1256. /*======================================================================
  1257.   
  1258.     The driver core code, most of which should be common with a
  1259.     non-PCMCIA implementation.
  1260.     
  1261. ======================================================================*/
  1263. #ifdef PCMCIA_DEBUG
  1264. static void smc_dump(struct net_device *dev)
  1265. {
  1266.     ioaddr_t ioaddr = dev->base_addr;
  1267.     u_short i, w, save;
  1268.     save = inw(ioaddr + BANK_SELECT);
  1269.     for (w = 0; w < 4; w++) {
  1270. SMC_SELECT_BANK(w);
  1271. printk(KERN_DEBUG "bank %d: ", w);
  1272. for (i = 0; i < 14; i += 2)
  1273.     printk(" %04x", inw(ioaddr + i));
  1274. printk("n");
  1275.     }
  1276.     outw(save, ioaddr + BANK_SELECT);
  1277. }
  1278. #endif
  1280. static int smc91c92_open(struct net_device *dev)
  1281. {
  1282.     struct smc_private *smc = dev->priv;
  1283.     dev_link_t *link = &smc->link;
  1285. #ifdef PCMCIA_DEBUG
  1286.     DEBUG(0, "%s: smc91c92_open(%p), ID/Window %4.4x.n",
  1287.   dev->name, dev, inw(dev->base_addr + BANK_SELECT));
  1288.     if (pc_debug > 1) smc_dump(dev);
  1289. #endif
  1290.     
  1291.     /* Check that the PCMCIA card is still here. */
  1292.     if (!DEV_OK(link))
  1293. return -ENODEV;
  1294.     /* Physical device present signature. */
  1295.     if (check_sig(link) < 0) {
  1296. printk("smc91c92_cs: Yikes!  Bad chip signature!n");
  1297. return -ENODEV;
  1298.     }
  1299.     link->open++;
  1300.     MOD_INC_USE_COUNT;
  1302.     netif_start_queue(dev);
  1303.     smc->saved_skb = 0;
  1304.     smc->packets_waiting = 0;
  1305.     
  1306.     smc_reset(dev);
  1307.     smc->media.function = &media_check;
  1308.     smc->media.data = (u_long)smc;
  1309.     smc->media.expires = jiffies + HZ;
  1310.     add_timer(&smc->media);
  1311.     
  1312.     return 0;
  1313. } /* smc91c92_open */
  1315. /*====================================================================*/
  1317. static int smc91c92_close(struct net_device *dev)
  1318. {
  1319.     struct smc_private *smc = dev->priv;
  1320.     dev_link_t *link = &smc->link;
  1321.     ioaddr_t ioaddr = dev->base_addr;
  1323.     DEBUG(0, "%s: smc91c92_close(), status %4.4x.n",
  1324.   dev->name, inw(ioaddr + BANK_SELECT));
  1326.     netif_stop_queue(dev);
  1328.     /* Shut off all interrupts, and turn off the Tx and Rx sections.
  1329.        Don't bother to check for chip present. */
  1330.     SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
  1331.     outw(0, ioaddr + INTERRUPT);
  1332.     SMC_SELECT_BANK(0);
  1333.     mask_bits(0xff00, ioaddr + RCR);
  1334.     mask_bits(0xff00, ioaddr + TCR);
  1335.     
  1336.     /* Put the chip into power-down mode. */
  1337.     SMC_SELECT_BANK(1);
  1338.     outw(CTL_POWERDOWN, ioaddr + CONTROL );
  1339.     
  1340.     link->open--;
  1341.     del_timer(&smc->media);
  1342.     if (link->state & DEV_STALE_CONFIG)
  1343. mod_timer(&link->release, jiffies + HZ/20);
  1344.     
  1345.     MOD_DEC_USE_COUNT;
  1346.     
  1347.     return 0;
  1348. } /* smc91c92_close */
  1350. /*======================================================================
  1352.    Transfer a packet to the hardware and trigger the packet send.
  1353.    This may be called at either from either the Tx queue code
  1354.    or the interrupt handler.
  1355.    
  1356. ======================================================================*/
  1358. static void smc_hardware_send_packet(struct net_device * dev)
  1359. {
  1360.     struct smc_private *smc = dev->priv;
  1361.     struct sk_buff *skb = smc->saved_skb;
  1362.     ioaddr_t ioaddr = dev->base_addr;
  1363.     u_char packet_no;
  1364.     
  1365.     if (!skb) {
  1366. printk(KERN_ERR "%s: In XMIT with no packet to send.n", dev->name);
  1367. return;
  1368.     }
  1369.     
  1370.     /* There should be a packet slot waiting. */
  1371.     packet_no = inw(ioaddr + PNR_ARR) >> 8;
  1372.     if (packet_no & 0x80) {
  1373. /* If not, there is a hardware problem!  Likely an ejected card. */
  1374. printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
  1375.        " failed, status %#2.2x.n", dev->name, packet_no);
  1376. dev_kfree_skb_irq(skb);
  1377. smc->saved_skb = NULL;
  1378. netif_start_queue(dev);
  1379. return;
  1380.     }
  1382.     smc->stats.tx_bytes += skb->len;
  1383.     /* The card should use the just-allocated buffer. */
  1384.     outw(packet_no, ioaddr + PNR_ARR);
  1385.     /* point to the beginning of the packet */
  1386.     outw(PTR_AUTOINC , ioaddr + POINTER);
  1387.     
  1388.     /* Send the packet length (+6 for status, length and ctl byte)
  1389.        and the status word (set to zeros). */
  1390.     {
  1391. u_char *buf = skb->data;
  1392. u_int length = skb->len; /* The chip will pad to ethernet min. */
  1394. DEBUG(2, "%s: Trying to xmit packet of length %d.n",
  1395.       dev->name, length);
  1397. /* send the packet length: +6 for status word, length, and ctl */
  1398. outw(0, ioaddr + DATA_1);
  1399. outw(length + 6, ioaddr + DATA_1);
  1400. outsw(ioaddr + DATA_1, buf, length >> 1);
  1402. /* The odd last byte, if there is one, goes in the control word. */
  1403. outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
  1404.     }
  1405.     
  1406.     /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
  1407.     outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
  1408.  (inw(ioaddr + INTERRUPT) & 0xff00),
  1409.  ioaddr + INTERRUPT);
  1410.     
  1411.     /* The chip does the rest of the work. */
  1412.     outw(MC_ENQUEUE , ioaddr + MMU_CMD);
  1413.     
  1414.     smc->saved_skb = NULL;
  1415.     dev_kfree_skb_irq(skb);
  1416.     dev->trans_start = jiffies;
  1417.     netif_start_queue(dev);
  1418.     return;
  1419. }
  1421. /*====================================================================*/
  1423. static void smc_tx_timeout(struct net_device *dev)
  1424. {
  1425.     struct smc_private *smc = dev->priv;
  1426.     ioaddr_t ioaddr = dev->base_addr;
  1428.     printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
  1429.    "Tx_status %2.2x status %4.4x.n",
  1430.    dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
  1431.     smc->stats.tx_errors++;
  1432.     smc_reset(dev);
  1433.     dev->trans_start = jiffies;
  1434.     smc->saved_skb = NULL;
  1435.     netif_wake_queue(dev);
  1436. }
  1438. static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1439. {
  1440.     struct smc_private *smc = dev->priv;
  1441.     ioaddr_t ioaddr = dev->base_addr;
  1442.     u_short num_pages;
  1443.     short time_out, ir;
  1445.     netif_stop_queue(dev);
  1447.     DEBUG(2, "%s: smc91c92_start_xmit(length = %d) called,"
  1448.   " status %4.4x.n", dev->name, skb->len, inw(ioaddr + 2));
  1449.     
  1450.     if (smc->saved_skb) {
  1451. /* THIS SHOULD NEVER HAPPEN. */
  1452. smc->stats.tx_aborted_errors++;
  1453. printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.n",
  1454.        dev->name);
  1455. return 1;
  1456.     }
  1457.     smc->saved_skb = skb;
  1458.     
  1459.     num_pages = skb->len >> 8;
  1460.     
  1461.     if (num_pages > 7) {
  1462. printk(KERN_ERR "%s: Far too big packet error.n", dev->name);
  1463. dev_kfree_skb (skb);
  1464. smc->saved_skb = NULL;
  1465. smc->stats.tx_dropped++;
  1466. return 0; /* Do not re-queue this packet. */
  1467.     }
  1468.     /* A packet is now waiting. */
  1469.     smc->packets_waiting++;
  1470.     
  1471.     SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
  1472.     
  1473.     /* Allocate the memory; send the packet now if we win. */
  1474.     outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
  1475.     for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
  1476. ir = inw(ioaddr+INTERRUPT);
  1477. if (ir & IM_ALLOC_INT) {
  1478.     /* Acknowledge the interrupt, send the packet. */
  1479.     outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
  1480.     smc_hardware_send_packet(dev); /* Send the packet now.. */
  1481.     return 0;
  1482. }
  1483.     }
  1484.     
  1485.     /* Otherwise defer until the Tx-space-allocated interrupt. */
  1486.     DEBUG(2, "%s: memory allocation deferred.n", dev->name);
  1487.     outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
  1488.     
  1489.     return 0;
  1490. }
  1492. /*======================================================================
  1494.     Handle a Tx anomolous event.  Entered while in Window 2.
  1495.     
  1496. ======================================================================*/
  1498. static void smc_tx_err(struct net_device * dev)
  1499. {
  1500.     struct smc_private *smc = (struct smc_private *)dev->priv;
  1501.     ioaddr_t ioaddr = dev->base_addr;
  1502.     int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
  1503.     int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
  1504.     int tx_status;
  1505.     
  1506.     /* select this as the packet to read from */
  1507.     outw(packet_no, ioaddr + PNR_ARR);
  1508.     
  1509.     /* read the first word from this packet */
  1510.     outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
  1511.     
  1512.     tx_status = inw(ioaddr + DATA_1);
  1514.     smc->stats.tx_errors++;
  1515.     if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
  1516.     if (tx_status & TS_LATCOL)  smc->stats.tx_window_errors++;
  1517.     if (tx_status & TS_16COL) {
  1518. smc->stats.tx_aborted_errors++;
  1519. smc->tx_err++;
  1520.     }
  1521.     
  1522.     if (tx_status & TS_SUCCESS) {
  1523. printk(KERN_NOTICE "%s: Successful packet caused error "
  1524.        "interrupt?n", dev->name);
  1525.     }
  1526.     /* re-enable transmit */
  1527.     SMC_SELECT_BANK(0);
  1528.     outw(inw(ioaddr + TCR) | TCR_ENABLE, ioaddr + TCR);
  1529.     SMC_SELECT_BANK(2);
  1530.     
  1531.     outw(MC_FREEPKT, ioaddr + MMU_CMD);  /* Free the packet memory. */
  1532.     
  1533.     /* one less packet waiting for me */
  1534.     smc->packets_waiting--;
  1535.     
  1536.     outw(saved_packet, ioaddr + PNR_ARR);
  1537.     return;
  1538. }
  1540. /*====================================================================*/
  1542. static void smc_eph_irq(struct net_device *dev)
  1543. {
  1544.     struct smc_private *smc = dev->priv;
  1545.     ioaddr_t ioaddr = dev->base_addr;
  1546.     u_short card_stats, ephs;
  1547.     
  1548.     SMC_SELECT_BANK(0);
  1549.     ephs = inw(ioaddr + EPH);
  1550.     DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
  1551.   " %4.4x.n", dev->name, ephs);
  1552.     /* Could be a counter roll-over warning: update stats. */
  1553.     card_stats = inw(ioaddr + COUNTER);
  1554.     /* single collisions */
  1555.     smc->stats.collisions += card_stats & 0xF;
  1556.     card_stats >>= 4;
  1557.     /* multiple collisions */
  1558.     smc->stats.collisions += card_stats & 0xF;
  1559. #if 0  /* These are for when linux supports these statistics */
  1560.     card_stats >>= 4; /* deferred */
  1561.     card_stats >>= 4; /* excess deferred */
  1562. #endif
  1563.     /* If we had a transmit error we must re-enable the transmitter. */
  1564.     outw(inw(ioaddr + TCR) | TCR_ENABLE, ioaddr + TCR);
  1566.     /* Clear a link error interrupt. */
  1567.     SMC_SELECT_BANK(1);
  1568.     outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
  1569.     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
  1570.  ioaddr + CONTROL);
  1571.     SMC_SELECT_BANK(2);
  1572. }
  1574. /*====================================================================*/
  1575.     
  1576. static void smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1577. {
  1578.     struct smc_private *smc = dev_id;
  1579.     struct net_device *dev = &smc->dev;
  1580.     ioaddr_t ioaddr;
  1581.     u_short saved_bank, saved_pointer, mask, status;
  1582.     char bogus_cnt = INTR_WORK; /* Work we are willing to do. */
  1584.     if (!netif_device_present(dev))
  1585. return;
  1586.     ioaddr = dev->base_addr;
  1587.     
  1588.     DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.n", dev->name,
  1589.   irq, ioaddr);
  1590.     
  1591.     smc->watchdog = 0;
  1592.     saved_bank = inw(ioaddr + BANK_SELECT);
  1593.     if ((saved_bank & 0xff00) != 0x3300) {
  1594. /* The device does not exist -- the card could be off-line, or
  1595.    maybe it has been ejected. */
  1596. DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
  1597.       "/ejected device.n", dev->name, irq);
  1598. goto irq_done;
  1599.     }
  1600.     
  1601.     SMC_SELECT_BANK(2);
  1602.     saved_pointer = inw(ioaddr + POINTER);
  1603.     mask = inw(ioaddr + INTERRUPT) >> 8;
  1604.     /* clear all interrupts */
  1605.     outw(0, ioaddr + INTERRUPT);
  1606.     
  1607.     do { /* read the status flag, and mask it */
  1608. status = inw(ioaddr + INTERRUPT) & 0xff;
  1609. DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).n", dev->name,
  1610.       status, mask);
  1611. if ((status & mask) == 0)
  1612.     break;
  1614. if (status & IM_RCV_INT) {
  1615.     /* Got a packet(s). */
  1616.     smc_rx(dev);
  1617. }
  1618. if (status & IM_TX_INT) {
  1619.     smc_tx_err(dev);
  1620.     outw(IM_TX_INT, ioaddr + INTERRUPT);
  1621. }
  1622. status &= mask;
  1623. if (status & IM_TX_EMPTY_INT) {
  1624.     outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
  1625.     mask &= ~IM_TX_EMPTY_INT;
  1626.     smc->stats.tx_packets += smc->packets_waiting;
  1627.     smc->packets_waiting = 0;
  1628. }
  1629. if (status & IM_ALLOC_INT) {
  1630.     /* Clear this interrupt so it doesn't happen again */
  1631.     mask &= ~IM_ALLOC_INT;
  1632.     
  1633.     smc_hardware_send_packet(dev);
  1634.     
  1635.     /* enable xmit interrupts based on this */
  1636.     mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
  1637.     
  1638.     /* and let the card send more packets to me */
  1639.     netif_wake_queue(dev);
  1640. }
  1641. if (status & IM_RX_OVRN_INT) {
  1642.     smc->stats.rx_errors++;
  1643.     smc->stats.rx_fifo_errors++;
  1644.     outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
  1645. }
  1646. if (status & IM_EPH_INT)
  1647.     smc_eph_irq(dev);
  1648.     } while (--bogus_cnt);
  1650.     DEBUG(3, "  Restoring saved registers mask %2.2x bank %4.4x"
  1651.   " pointer %4.4x.n", mask, saved_bank, saved_pointer);
  1652.     
  1653.     /* restore state register */
  1654.     outw((mask<<8), ioaddr + INTERRUPT);
  1655.     outw(saved_pointer, ioaddr + POINTER);
  1656.     SMC_SELECT_BANK(saved_bank);
  1658.     DEBUG(3, "%s: Exiting interrupt IRQ%d.n", dev->name, irq);
  1660. irq_done:
  1661.     
  1662.     if ((smc->manfid == MANFID_OSITECH) &&
  1663. (smc->cardid != PRODID_OSITECH_SEVEN)) {
  1664. /* Retrigger interrupt if needed */
  1665. mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
  1666. set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
  1667.     }
  1668.     if (smc->manfid == MANFID_MOTOROLA) {
  1669. u_char cor;
  1670. cor = readb(smc->base + MOT_UART + CISREG_COR);
  1671. writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
  1672. writeb(cor, smc->base + MOT_UART + CISREG_COR);
  1673. cor = readb(smc->base + MOT_LAN + CISREG_COR);
  1674. writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
  1675. writeb(cor, smc->base + MOT_LAN + CISREG_COR);
  1676.     }
  1677. #ifdef DOES_NOT_WORK
  1678.     if (smc->base != NULL) { /* Megahertz MFC's */
  1679. readb(smc->base+MEGAHERTZ_ISR);
  1680. readb(smc->base+MEGAHERTZ_ISR);
  1681.     }
  1682. #endif
  1683. }
  1685. /*====================================================================*/
  1687. static void smc_rx(struct net_device *dev)
  1688. {
  1689.     struct smc_private *smc = (struct smc_private *)dev->priv;
  1690.     ioaddr_t ioaddr = dev->base_addr;
  1691.     int rx_status;
  1692.     int packet_length; /* Caution: not frame length, rather words
  1693.    to transfer from the chip. */
  1694.     
  1695.     /* Assertion: we are in Window 2. */
  1696.     
  1697.     if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
  1698. printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.n",
  1699.        dev->name);
  1700. return;
  1701.     }
  1702.     
  1703.     /*  Reset the read pointer, and read the status and packet length. */
  1704.     outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
  1705.     rx_status = inw(ioaddr + DATA_1);
  1706.     packet_length = inw(ioaddr + DATA_1) & 0x07ff;
  1708.     DEBUG(2, "%s: Receive status %4.4x length %d.n",
  1709.   dev->name, rx_status, packet_length);
  1710.     
  1711.     if (!(rx_status & RS_ERRORS)) {
  1712. /* do stuff to make a new packet */
  1713. struct sk_buff *skb;
  1715. /* Note: packet_length adds 5 or 6 extra bytes here! */
  1716. skb = dev_alloc_skb(packet_length+2);
  1718. if (skb == NULL) {
  1719.     DEBUG(1, "%s: Low memory, packet dropped.n", dev->name);
  1720.     smc->stats.rx_dropped++;
  1721.     outw(MC_RELEASE, ioaddr + MMU_CMD);
  1722.     return;
  1723. }
  1725. packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
  1726. skb_reserve(skb, 2);
  1727. insw(ioaddr+DATA_1, skb_put(skb, packet_length),
  1728. (packet_length+1)>>1);
  1729. skb->protocol = eth_type_trans(skb, dev);
  1731. skb->dev = dev;
  1732. netif_rx(skb);
  1733. dev->last_rx = jiffies;
  1734. smc->stats.rx_packets++;
  1735. smc->stats.rx_bytes += packet_length;
  1736. if (rx_status & RS_MULTICAST)
  1737.     smc->stats.multicast++;
  1738.     } else {
  1739. /* error ... */
  1740. smc->stats.rx_errors++;
  1742. if (rx_status & RS_ALGNERR)  smc->stats.rx_frame_errors++;
  1743. if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
  1744.     smc->stats.rx_length_errors++;
  1745. if (rx_status & RS_BADCRC) smc->stats.rx_crc_errors++;
  1746.     }
  1747.     /* Let the MMU free the memory of this packet. */
  1748.     outw(MC_RELEASE, ioaddr + MMU_CMD);
  1749.     
  1750.     return;
  1751. }
  1753. /*====================================================================*/
  1755. static struct net_device_stats *smc91c92_get_stats(struct net_device *dev)
  1756. {
  1757.     struct smc_private *smc = (struct smc_private *)dev->priv;
  1758.     /* Nothing to update - the 91c92 is a pretty primative chip. */
  1759.     return &smc->stats;
  1760. }
  1763. /*======================================================================
  1764.   
  1765.     Calculate values for the hardware multicast filter hash table.
  1766.     
  1767. ======================================================================*/
  1769. static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
  1770.        u_char *multicast_table)
  1771. {
  1772.     struct dev_mc_list *mc_addr;
  1773.     
  1774.     for (mc_addr = addrs;  mc_addr && --count > 0;  mc_addr = mc_addr->next) {
  1775. u_int position = ether_crc(6, mc_addr->dmi_addr);
  1776. #ifndef final_version /* Verify multicast address. */
  1777. if ((mc_addr->dmi_addr[0] & 1) == 0)
  1778.     continue;
  1779. #endif
  1780. multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
  1781.     }
  1782. }
  1784. /*======================================================================
  1785.   
  1786.     Set the receive mode.
  1787.     
  1788.     This routine is used by both the protocol level to notify us of
  1789.     promiscuous/multicast mode changes, and by the open/reset code to
  1790.     initialize the Rx registers.  We always set the multicast list and
  1791.     leave the receiver running.
  1792.     
  1793. ======================================================================*/
  1795. static void set_rx_mode(struct net_device *dev)
  1796. {
  1797.     ioaddr_t ioaddr = dev->base_addr;
  1798.     struct smc_private *smc = dev->priv;
  1799.     u_int multicast_table[ 2 ] = { 0, };
  1800.     unsigned long flags;
  1801.     u_short rx_cfg_setting;
  1802.     
  1803.     if (dev->flags & IFF_PROMISC) {
  1804. printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.n", dev->name);
  1805. rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
  1806.     } else if (dev->flags & IFF_ALLMULTI)
  1807. rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
  1808.     else {
  1809. if (dev->mc_count)  {
  1810.     fill_multicast_tbl(dev->mc_count, dev->mc_list,
  1811.        (u_char *)multicast_table);
  1812. }
  1813. rx_cfg_setting = RxStripCRC | RxEnable;
  1814.     }
  1815.     
  1816.     /* Load MC table and Rx setting into the chip without interrupts. */
  1817.     spin_lock_irqsave(&smc->lock, flags);
  1818.     SMC_SELECT_BANK(3);
  1819.     outl(multicast_table[0], ioaddr + MULTICAST0);
  1820.     outl(multicast_table[1], ioaddr + MULTICAST4);
  1821.     SMC_SELECT_BANK(0);
  1822.     outw(rx_cfg_setting, ioaddr + RCR);
  1823.     SMC_SELECT_BANK(2);
  1824.     spin_unlock_irqrestore(&smc->lock, flags);
  1825.  
  1826.     return;
  1827. }
  1829. /*======================================================================
  1831.     Senses when a card's config changes. Here, it's coax or TP.
  1832.  
  1833. ======================================================================*/
  1835. static int s9k_config(struct net_device *dev, struct ifmap *map)
  1836. {
  1837.     struct smc_private *smc = dev->priv;
  1838.     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
  1839. if (smc->cfg & CFG_MII_SELECT)
  1840.     return -EOPNOTSUPP;
  1841. else if (map->port > 2)
  1842.     return -EINVAL;
  1843. dev->if_port = map->port;
  1844. printk(KERN_INFO "%s: switched to %s portn",
  1845.        dev->name, if_names[dev->if_port]);
  1846. smc_reset(dev);
  1847.     }
  1848.     return 0;
  1849. }
  1851. /*======================================================================
  1853.     Reset the chip, reloading every register that might be corrupted.
  1855. ======================================================================*/
  1857. /*
  1858.   Set transceiver type, perhaps to something other than what the user
  1859.   specified in dev->if_port.
  1860. */
  1861. static void smc_set_xcvr(struct net_device *dev, int if_port)
  1862. {
  1863.     struct smc_private *smc = (struct smc_private *)dev->priv;
  1864.     ioaddr_t ioaddr = dev->base_addr;
  1865.     u_short saved_bank;
  1867.     saved_bank = inw(ioaddr + BANK_SELECT);
  1868.     SMC_SELECT_BANK(1);
  1869.     if (if_port == 2) {
  1870. outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
  1871. if ((smc->manfid == MANFID_OSITECH) &&
  1872.     (smc->cardid != PRODID_OSITECH_SEVEN))
  1873.     set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
  1874. smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
  1875.     } else {
  1876. outw(smc->cfg, ioaddr + CONFIG);
  1877. if ((smc->manfid == MANFID_OSITECH) &&
  1878.     (smc->cardid != PRODID_OSITECH_SEVEN))
  1879.     mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
  1880. smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
  1881.     }
  1882.     SMC_SELECT_BANK(saved_bank);
  1883. }
  1885. static void smc_reset(struct net_device *dev)
  1886. {
  1887.     ioaddr_t ioaddr = dev->base_addr;
  1888.     struct smc_private *smc = dev->priv;
  1889.     int i;
  1891.     DEBUG(0, "%s: smc91c92 reset called.n", dev->name);
  1892.     
  1893.     /* The first interaction must be a write to bring the chip out
  1894.        of sleep mode. */
  1895.     SMC_SELECT_BANK(0);
  1896.     /* Reset the chip. */
  1897.     outw(RCR_SOFTRESET, ioaddr + RCR);
  1898.     udelay(10);
  1899.     
  1900.     /* Clear the transmit and receive configuration registers. */
  1901.     outw(RCR_CLEAR, ioaddr + RCR);
  1902.     outw(TCR_CLEAR, ioaddr + TCR);
  1903.     
  1904.     /* Set the Window 1 control, configuration and station addr registers.
  1905.        No point in writing the I/O base register ;-> */
  1906.     SMC_SELECT_BANK(1);
  1907.     /* Automatically release succesfully transmitted packets,
  1908.        Accept link errors, counter and Tx error interrupts. */
  1909.     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
  1910.  ioaddr + CONTROL);
  1911.     smc_set_xcvr(dev, dev->if_port);
  1912.     if ((smc->manfid == MANFID_OSITECH) &&
  1913. (smc->cardid != PRODID_OSITECH_SEVEN))
  1914. outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
  1915.      (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
  1916.      ioaddr - 0x10 + OSITECH_AUI_PWR);
  1917.     
  1918.     /* Fill in the physical address.  The databook is wrong about the order! */
  1919.     for (i = 0; i < 6; i += 2)
  1920. outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
  1921.      ioaddr + ADDR0 + i);
  1922.     
  1923.     /* Reset the MMU */
  1924.     SMC_SELECT_BANK(2);
  1925.     outw(MC_RESET, ioaddr + MMU_CMD);
  1926.     outw(0, ioaddr + INTERRUPT);
  1927.     
  1928.     /* Re-enable the chip. */
  1929.     SMC_SELECT_BANK(0);
  1930.     outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
  1931.  TCR_ENABLE | TCR_PAD_EN, ioaddr + TCR);
  1932.     set_rx_mode(dev);
  1934.     if (smc->cfg & CFG_MII_SELECT) {
  1935. SMC_SELECT_BANK(3);
  1937. /* Reset MII */
  1938. smc_mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
  1940. /* Restart MII autonegotiation */
  1941. smc_mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
  1942. smc_mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
  1943.     }
  1945.     /* Enable interrupts. */
  1946.     SMC_SELECT_BANK(2);
  1947.     outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
  1948.  ioaddr + INTERRUPT);
  1949. }
  1951. /*======================================================================
  1953.     Media selection timer routine
  1954.     
  1955. ======================================================================*/
  1957. static void media_check(u_long arg)
  1958. {
  1959.     struct smc_private *smc = (struct smc_private *)(arg);
  1960.     struct net_device *dev = &smc->dev;
  1961.     ioaddr_t ioaddr = dev->base_addr;
  1962.     u_short i, media, saved_bank;
  1963.     u_short link;
  1965.     saved_bank = inw(ioaddr + BANK_SELECT);
  1967.     if (!netif_device_present(dev))
  1968. goto reschedule;
  1970.     SMC_SELECT_BANK(2);
  1971.     i = inw(ioaddr + INTERRUPT);
  1972.     SMC_SELECT_BANK(0);
  1973.     media = inw(ioaddr + EPH) & EPH_LINK_OK;
  1974.     SMC_SELECT_BANK(1);
  1975.     media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
  1976.     
  1977.     /* Check for pending interrupt with watchdog flag set: with
  1978.        this, we can limp along even if the interrupt is blocked */
  1979.     if (smc->watchdog++ && ((i>>8) & i)) {
  1980. if (!smc->fast_poll)
  1981.     printk(KERN_INFO "%s: interrupt(s) dropped!n", dev->name);
  1982. smc_interrupt(dev->irq, smc, NULL);
  1983. smc->fast_poll = HZ;
  1984.     }
  1985.     if (smc->fast_poll) {
  1986. smc->fast_poll--;
  1987. smc->media.expires = jiffies + 1;
  1988. add_timer(&smc->media);
  1989. SMC_SELECT_BANK(saved_bank);
  1990. return;
  1991.     }
  1993.     if (smc->cfg & CFG_MII_SELECT) {
  1994. if (smc->mii_if.phy_id < 0)
  1995.     goto reschedule;
  1997. SMC_SELECT_BANK(3);
  1998. link = smc_mdio_read(dev, smc->mii_if.phy_id, 1);
  1999. if (!link || (link == 0xffff)) {
  2000.        printk(KERN_INFO "%s: MII is missing!n", dev->name);
  2001.     smc->mii_if.phy_id = -1;
  2002.     goto reschedule;
  2003. }
  2005. link &= 0x0004;
  2006. if (link != smc->link_status) {
  2007.     u_short p = smc_mdio_read(dev, smc->mii_if.phy_id, 5);
  2008.     printk(KERN_INFO "%s: %s link beatn", dev->name,
  2009. (link) ? "found" : "lost");
  2010.     if (link) {
  2011.         printk(KERN_INFO "%s: autonegotiation complete: "
  2012.         "%sbaseT-%cD selectedn", dev->name,
  2013.     ((p & 0x0180) ? "100" : "10"),
  2014.     (((p & 0x0100) || ((p & 0x1c0) == 0x40)) ? 'F' : 'H'));
  2015.     }
  2016.     smc->link_status = link;
  2017. }
  2018.     }
  2020.     if (smc->cfg & CFG_MII_SELECT)
  2021. goto reschedule;
  2023.     /* Ignore collisions unless we've had no rx's recently */
  2024.     if (jiffies - dev->last_rx > HZ) {
  2025. if (smc->tx_err || (smc->media_status & EPH_16COL))
  2026.     media |= EPH_16COL;
  2027.     }
  2028.     smc->tx_err = 0;
  2030.     if (media != smc->media_status) {
  2031. if ((media & smc->media_status & 1) &&
  2032.     ((smc->media_status ^ media) & EPH_LINK_OK))
  2033.     printk(KERN_INFO "%s: %s link beatn", dev->name,
  2034.    (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
  2035. else if ((media & smc->media_status & 2) &&
  2036.  ((smc->media_status ^ media) & EPH_16COL))
  2037.     printk(KERN_INFO "%s: coax cable %sn", dev->name,
  2038.    (media & EPH_16COL ? "problem" : "ok"));
  2039. if (dev->if_port == 0) {
  2040.     if (media & 1) {
  2041. if (media & EPH_LINK_OK)
  2042.     printk(KERN_INFO "%s: flipped to 10baseTn",
  2043.    dev->name);
  2044. else
  2045.     smc_set_xcvr(dev, 2);
  2046.     } else {
  2047. if (media & EPH_16COL)
  2048.     smc_set_xcvr(dev, 1);
  2049. else
  2050.     printk(KERN_INFO "%s: flipped to 10base2n",
  2051.    dev->name);
  2052.     }
  2053. }
  2054. smc->media_status = media;
  2055.     }
  2056.     
  2057. reschedule:
  2058.     smc->media.expires = jiffies + HZ;
  2059.     add_timer(&smc->media);
  2060.     SMC_SELECT_BANK(saved_bank);
  2061. }
  2063. static int smc_link_ok(struct net_device *dev)
  2064. {
  2065.     ioaddr_t ioaddr = dev->base_addr;
  2066.     struct smc_private *smc = dev->priv;
  2068.     if (smc->cfg & CFG_MII_SELECT) {
  2069. return mii_link_ok(&smc->mii_if);
  2070.     } else {
  2071.         SMC_SELECT_BANK(0);
  2072. return inw(ioaddr + EPH) & EPH_LINK_OK;
  2073.     }
  2074. }
  2076. static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
  2077. {
  2078.     u16 tmp;
  2079.     ioaddr_t ioaddr = dev->base_addr;
  2081.     ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
  2082. SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
  2084.     SMC_SELECT_BANK(1);
  2085.     tmp = inw(ioaddr + CONFIG);
  2086.     ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
  2087.     ecmd->transceiver = XCVR_INTERNAL;
  2088.     ecmd->speed = SPEED_10;
  2089.     ecmd->phy_address = ioaddr + MGMT;
  2091.     SMC_SELECT_BANK(0);
  2092.     tmp = inw(ioaddr + TCR);
  2093.     ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
  2095.     return 0;
  2096. }
  2098. static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
  2099. {
  2100.     u16 tmp;
  2101.     ioaddr_t ioaddr = dev->base_addr;
  2103.     if (ecmd->speed != SPEED_10)
  2104.      return -EINVAL;
  2105.     if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
  2106.      return -EINVAL;
  2107.     if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
  2108. return -EINVAL;
  2109.     if (ecmd->transceiver != XCVR_INTERNAL)
  2110.      return -EINVAL;
  2112.     if (ecmd->port == PORT_AUI)
  2113. smc_set_xcvr(dev, 1);
  2114.     else
  2115. smc_set_xcvr(dev, 0);
  2117.     SMC_SELECT_BANK(0);
  2118.     tmp = inw(ioaddr + TCR);
  2119.     if (ecmd->duplex == DUPLEX_FULL)
  2120. tmp |= TCR_FDUPLX;
  2121.     else
  2122. tmp &= ~TCR_FDUPLX;
  2123.     outw(ioaddr + TCR, tmp);
  2125.     return 0;
  2126. }
  2128. static int smc_ethtool_ioctl (struct net_device *dev, void *useraddr)
  2129. {
  2130.     u32 ethcmd;
  2131.     struct smc_private *smc = dev->priv;
  2133.     if (get_user(ethcmd, (u32 *)useraddr))
  2134. return -EFAULT;
  2136.     switch (ethcmd) {
  2138.     case ETHTOOL_GDRVINFO: {
  2139. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  2140. strcpy(info.driver, DRV_NAME);
  2141. strcpy(info.version, DRV_VERSION);
  2142. if (copy_to_user(useraddr, &info, sizeof(info)))
  2143.     return -EFAULT;
  2144. return 0;
  2145.     }
  2147.     /* get settings */
  2148.     case ETHTOOL_GSET: {
  2149. int ret;
  2150. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  2151. spin_lock_irq(&smc->lock);
  2152. if (smc->cfg & CFG_MII_SELECT)
  2153.     ret = mii_ethtool_gset(&smc->mii_if, &ecmd);
  2154. else
  2155.     ret = smc_netdev_get_ecmd(dev, &ecmd);
  2156. spin_unlock_irq(&smc->lock);
  2157. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  2158.     return -EFAULT;
  2159. return ret;
  2160.     }
  2162.     /* set settings */
  2163.     case ETHTOOL_SSET: {
  2164. int ret;
  2165. struct ethtool_cmd ecmd;
  2166. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  2167.     return -EFAULT;
  2168. spin_lock_irq(&smc->lock);
  2169. if (smc->cfg & CFG_MII_SELECT)
  2170.     ret = mii_ethtool_sset(&smc->mii_if, &ecmd);    
  2171. else
  2172.     ret = smc_netdev_set_ecmd(dev, &ecmd);
  2173. spin_unlock_irq(&smc->lock);
  2174. return ret;
  2175.     }
  2177.     /* get link status */
  2178.     case ETHTOOL_GLINK: {
  2179. struct ethtool_value edata = { ETHTOOL_GLINK };
  2180. spin_lock_irq(&smc->lock);
  2181. edata.data = smc_link_ok(dev);
  2182. spin_unlock_irq(&smc->lock);
  2183. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  2184.     return -EFAULT;
  2185. return 0;
  2186.     }
  2188. #ifdef PCMCIA_DEBUG
  2189.     /* get message-level */
  2190.     case ETHTOOL_GMSGLVL: {
  2191. struct ethtool_value edata = { ETHTOOL_GMSGLVL };
  2192. edata.data = pc_debug;
  2193. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  2194.     return -EFAULT;
  2195. return 0;
  2196.     }
  2197.     
  2198.     /* set message-level */
  2199.     case ETHTOOL_SMSGLVL: {
  2200. struct ethtool_value edata;
  2201. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  2202.     return -EFAULT;
  2203. pc_debug = edata.data;
  2204. return 0;
  2205.     }
  2206. #endif
  2207.     /* restart autonegotiation */
  2208.     case ETHTOOL_NWAY_RST: {
  2209. if (smc->cfg & CFG_MII_SELECT)
  2210.     return mii_nway_restart(&smc->mii_if);
  2211. else
  2212.     return -EOPNOTSUPP;
  2213.     }
  2214.     
  2215.     default:
  2216. break;
  2217.     }
  2219.     return -EOPNOTSUPP;
  2220. }
  2222. static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
  2223. {
  2224.     struct smc_private *smc = dev->priv;
  2225.     struct mii_ioctl_data *mii;
  2226.     int rc = 0;
  2228.     mii = (struct mii_ioctl_data *) &rq->ifr_data;
  2229.     if (!netif_running(dev))
  2230.      return -EINVAL;
  2232.     switch (cmd) {
  2233.     case SIOCETHTOOL:
  2234. rc = smc_ethtool_ioctl(dev, (void *) rq->ifr_data);
  2235. break;
  2236.     
  2237.     default:
  2238. spin_lock_irq(&smc->lock);
  2239. rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
  2240. spin_unlock_irq(&smc->lock);
  2241. break;
  2242.     }
  2244.     return rc;
  2245. }
  2248. /*====================================================================*/
  2250. static int __init init_smc91c92_cs(void)
  2251. {
  2252.     servinfo_t serv;
  2253.     DEBUG(0, "%sn", version);
  2254.     CardServices(GetCardServicesInfo, &serv);
  2255.     if (serv.Revision != CS_RELEASE_CODE) {
  2256. printk(KERN_ERR
  2257.        "smc91c92_cs: Card Services release does not match!n");
  2258. return -1;
  2259.     }
  2260.     register_pccard_driver(&dev_info, &smc91c92_attach, &smc91c92_detach);
  2261.     return 0;
  2262. }
  2264. static void __exit exit_smc91c92_cs(void)
  2265. {
  2266.     DEBUG(0, "smc91c92_cs: unloadingn");
  2267.     unregister_pccard_driver(&dev_info);
  2268.     while (dev_list != NULL)
  2269. smc91c92_detach(dev_list);
  2270. }
  2272. module_init(init_smc91c92_cs);
  2273. module_exit(exit_smc91c92_cs);