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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
rtl8139.c
资源名称：rtl8139.rar　[点击查看]
上传用户：zhouquan
上传日期：2009-12-05
资源大小：16k
文件大小：51k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

rtl8139.c：源码内容
  1. /* rtl8139.c: A RealTek RTL8129/8139 Fast Ethernet driver for Linux. */
  2. /*
  3. Written 1997-2001 by Donald Becker.
  4. This software may be used and distributed according to the terms of
  5. the GNU General Public License (GPL), incorporated herein by reference.
  6. Drivers based on or derived from this code fall under the GPL and must
  7. retain the authorship, copyright and license notice.  This file is not
  8. a complete program and may only be used when the entire operating
  9. system is licensed under the GPL.
  11. This driver is for boards based on the RTL8129 and RTL8139 PCI ethernet
  12. chips.
  14. The author may be reached as becker@scyld.com, or C/O
  15. Scyld Computing Corporation
  16. 410 Severn Ave., Suite 210
  17. Annapolis MD 21403
  19. Support and updates available at
  20. http://www.scyld.com/network/rtl8139.html
  22. Twister-tuning table provided by Kinston <shangh@realtek.com.tw>.
  23. */
  25. /* These identify the driver base version and may not be removed. */
  26. static const char versionA[] =
  27. "rtl8139.c:v1.16a 11/13/2001 Donald Becker, becker@scyld.com.n";
  28. static const char versionB[] =
  29. " http://www.scyld.com/network/rtl8139.htmln";
  31. #ifndef USE_MEM_OPS
  32. /* Note: Register access width and timing restrictions apply in MMIO mode.
  33.    This updated driver should nominally work, but I/O mode is better tested. */
  34. #define USE_IO_OPS
  35. #endif
  37. /* The user-configurable values.
  38.    These may be modified when a driver module is loaded.*/
  39. static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
  40. /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  41. static int max_interrupt_work = 20;
  43. /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
  44.    The RTL chips use a 64 element hash table based on the Ethernet CRC.  It
  45.    is efficient to update the hardware filter, but recalculating the table
  46.    for a long filter list is painful.  */
  47. static int multicast_filter_limit = 32;
  49. /* Used to pass the full-duplex flag, etc. */
  50. #define MAX_UNITS 8 /* More are supported, limit only on options */
  51. static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  52. static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  54. /* Operational parameters that are set at compile time. */
  56. /* Maximum size of the in-memory receive ring (smaller if no memory). */
  57. #define RX_BUF_LEN_IDX 2 /* 0==8K, 1==16K, 2==32K, 3==64K */
  58. /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
  59. #define TX_BUF_SIZE 1536
  61. /* PCI Tuning Parameters
  62.    Threshold is bytes transferred to chip before transmission starts. */
  63. #define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
  65. /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024. */
  66. #define RX_FIFO_THRESH 4 /* Rx buffer level before first PCI xfer.  */
  67. #define RX_DMA_BURST 4 /* Maximum PCI burst, '4' is 256 bytes */
  68. #define TX_DMA_BURST 4 /* Calculate as 16<<val. */
  70. /* Operational parameters that usually are not changed. */
  71. /* Time in jiffies before concluding the transmitter is hung. */
  72. #define TX_TIMEOUT  (6*HZ)
  74. #ifndef __KERNEL__
  75. #define __KERNEL__
  76. #endif
  77. #if !defined(__OPTIMIZE__)
  78. #warning  You must compile this file with the correct options!
  79. #warning  See the last lines of the source file.
  80. #error You must compile this driver with "-O".
  81. #endif
  83. #include <linux/config.h>
  84. #if defined(CONFIG_SMP) && ! defined(__SMP__)
  85. #define __SMP__
  86. #endif
  87. #if defined(MODULE) && defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS)
  88. #define MODVERSIONS
  89. #endif
  91. #include <linux/version.h>
  92. #include <linux/module.h>
  93. #if LINUX_VERSION_CODE < 0x20300  &&  defined(MODVERSIONS)
  94. #include <linux/modversions.h>
  95. #endif
  97. #include <linux/kernel.h>
  98. #include <linux/string.h>
  99. #include <linux/timer.h>
  100. #include <linux/errno.h>
  101. #include <linux/ioport.h>
  102. #include <linux/malloc.h>
  103. #include <linux/interrupt.h>
  104. #include <linux/pci.h>
  105. #include <linux/netdevice.h>
  106. #include <linux/etherdevice.h>
  107. #include <linux/skbuff.h>
  108. #include <asm/processor.h> /* Processor type for cache alignment. */
  109. #include <asm/bitops.h>
  110. #include <asm/io.h>
  112. #if LINUX_VERSION_CODE >= 0x20300
  113. #include <linux/spinlock.h>
  114. #elif LINUX_VERSION_CODE >= 0x20200
  115. #include <asm/spinlock.h>
  116. #endif
  118. #ifdef INLINE_PCISCAN
  119. #include "k_compat.h"
  120. #else
  121. #include "pci-scan.h"
  122. #include "kern_compat.h"
  123. #endif
  125. #ifdef CONFIG_LEDMAN
  126. #include <linux/ledman.h>
  127. #endif
  129. #if (LINUX_VERSION_CODE >= 0x20100)  &&  defined(MODULE)
  130. char kernel_version[] = UTS_RELEASE;
  131. #endif
  133. /*
  134. Theory of Operation
  136. I. Board Compatibility
  138. This device driver is designed for the RealTek RTL8129 series, the RealTek
  139. Fast Ethernet controllers for PCI and CardBus.  This chip is used on many
  140. low-end boards, sometimes with custom chip labels.
  143. II. Board-specific settings
  145. PCI bus devices are configured by the system at boot time, so no jumpers
  146. need to be set on the board.  The system BIOS will assign the
  147. PCI INTA signal to a (preferably otherwise unused) system IRQ line.
  148. Note: Kernel versions earlier than 1.3.73 do not support shared PCI
  149. interrupt lines.
  151. III. Driver operation
  153. IIIa. Rx Ring buffers
  155. The receive unit uses a single linear ring buffer rather than the more
  156. common (and more efficient) descriptor-based architecture.  Incoming frames
  157. are sequentially stored into the Rx region, and the host copies them into
  158. skbuffs.
  160. Comment: While it is theoretically possible to process many frames in place,
  161. any delay in Rx processing would block the Rx ring and cause us to drop
  162. frames.  It would be difficult to design a protocol stack where the data
  163. buffer could be recalled by the device driver.
  165. IIIb. Tx operation
  167. The RTL8129 uses a fixed set of four Tx descriptors in register space.  Tx
  168. frames must be 32 bit aligned.  Linux aligns the IP header on word
  169. boundaries, and 14 byte ethernet header means that almost all frames will
  170. need to be copied to an alignment buffer.  The driver statically allocates
  171. alignment the four alignment buffers at open() time.
  173. IVb. References
  175. http://www.realtek.com.tw/cn/cn.html
  176. http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
  178. IVc. Errata
  180. */
  183. static void *rtl8139_probe1(struct pci_dev *pdev, void *init_dev,
  184. long ioaddr, int irq, int chip_idx, int find_cnt);
  185. static int rtl_pwr_event(void *dev_instance, int event);
  187. enum chip_capability_flags {HAS_MII_XCVR=0x01, HAS_CHIP_XCVR=0x02,
  188. HAS_LNK_CHNG=0x04, HAS_DESC=0x08};
  189. #ifdef USE_IO_OPS
  190. #define RTL8139_IOTYPE  PCI_USES_MASTER|PCI_USES_IO |PCI_ADDR0
  191. #else
  192. #define RTL8139_IOTYPE  PCI_USES_MASTER|PCI_USES_MEM|PCI_ADDR1
  193. #endif
  194. #define RTL8129_CAPS  HAS_MII_XCVR
  195. #define RTL8139_CAPS  HAS_CHIP_XCVR|HAS_LNK_CHNG
  196. #define RTL8139D_CAPS  HAS_CHIP_XCVR|HAS_LNK_CHNG|HAS_DESC
  198. /* Note: Update the marked constant in _attach() if the RTL8139B entry moves.*/
  199. static struct pci_id_info pci_tbl[] = {
  200. {"RealTek RTL8139C+, 64 bit high performance",
  201.  { 0x813910ec, 0xffffffff, 0,0, 0x10, 0xff},
  202.  RTL8139_IOTYPE, 0x80, RTL8139D_CAPS, },
  203. #if 1
  204. /* Raw 8139 with no serial EEPRON will produce ID of 8129! */
  205. {"RealTek RTL8139 Fast Ethernet", { 0x812910ec, 0xffffffff,},
  206.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  207. #else
  208. {"RealTek RTL8129 Fast Ethernet", { 0x812910ec, 0xffffffff,},
  209.  RTL8139_IOTYPE, 0x80, RTL8129_CAPS, },
  210. #endif
  211. {"RealTek RTL8139 Fast Ethernet", { 0x813910ec, 0xffffffff,},
  212.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  213. {"RealTek RTL8139B PCI/CardBus",  { 0x813810ec, 0xffffffff,},
  214.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  215. {"SMC1211TX EZCard 10/100 (RealTek RTL8139)", { 0x12111113, 0xffffffff,},
  216.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  217. {"Accton MPX5030 (RealTek RTL8139)", { 0x12111113, 0xffffffff,},
  218.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  219. {"D-Link DFE-538TX (RealTek RTL8139)", { 0x13001186, 0xffffffff,},
  220.  RTL8139_IOTYPE, 0x80, RTL8139_CAPS, },
  221. {0,}, /* 0 terminated list. */
  222. };
  224. struct drv_id_info rtl8139_drv_id = {
  225. "realtek", PCI_HOTSWAP, PCI_CLASS_NETWORK_ETHERNET<<8, pci_tbl,
  226. rtl8139_probe1, rtl_pwr_event };
  228. #ifndef USE_IO_OPS
  229. #undef inb
  230. #undef inw
  231. #undef inl
  232. #undef outb
  233. #undef outw
  234. #undef outl
  235. #define inb readb
  236. #define inw readw
  237. #define inl readl
  238. #define outb writeb
  239. #define outw writew
  240. #define outl writel
  241. #endif
  243. /* The rest of these values should never change. */
  244. #define NUM_TX_DESC 4 /* Number of Tx descriptor registers. */
  246. /* Symbolic offsets to registers. */
  247. enum RTL8129_registers {
  248. MAC0=0, /* Ethernet hardware address. */
  249. MAR0=8, /* Multicast filter. */
  250. TxStatus0=0x10, /* Transmit status (Four 32bit registers). */
  251. TxAddr0=0x20, /* Tx descriptors (also four 32bit). */
  252. RxBuf=0x30, RxEarlyCnt=0x34, RxEarlyStatus=0x36,
  253. ChipCmd=0x37, RxBufPtr=0x38, RxBufAddr=0x3A,
  254. IntrMask=0x3C, IntrStatus=0x3E,
  255. TxConfig=0x40, RxConfig=0x44,
  256. Timer=0x48, /* A general-purpose counter. */
  257. RxMissed=0x4C, /* 24 bits valid, write clears. */
  258. Cfg9346=0x50, Config0=0x51, Config1=0x52,
  259. FlashReg=0x54, GPPinData=0x58, GPPinDir=0x59, MII_SMI=0x5A, HltClk=0x5B,
  260. MultiIntr=0x5C, TxSummary=0x60,
  261. MII_BMCR=0x62, MII_BMSR=0x64, NWayAdvert=0x66, NWayLPAR=0x68,
  262. NWayExpansion=0x6A,
  263. /* Undocumented registers, but required for proper operation. */
  264. FIFOTMS=0x70, /* FIFO Control and test. */
  265. CSCR=0x74, /* Chip Status and Configuration Register. */
  266. PARA78=0x78, PARA7c=0x7c, /* Magic transceiver parameter register. */
  267. };
  269. enum ChipCmdBits {
  270. CmdReset=0x10, CmdRxEnb=0x08, CmdTxEnb=0x04, RxBufEmpty=0x01, };
  272. /* Interrupt register bits, using my own meaningful names. */
  273. enum IntrStatusBits {
  274. PCIErr=0x8000, PCSTimeout=0x4000,
  275. RxFIFOOver=0x40, RxUnderrun=0x20, RxOverflow=0x10,
  276. TxErr=0x08, TxOK=0x04, RxErr=0x02, RxOK=0x01,
  277. };
  278. enum TxStatusBits {
  279. TxHostOwns=0x2000, TxUnderrun=0x4000, TxStatOK=0x8000,
  280. TxOutOfWindow=0x20000000, TxAborted=0x40000000, TxCarrierLost=0x80000000,
  281. };
  282. enum RxStatusBits {
  283. RxMulticast=0x8000, RxPhysical=0x4000, RxBroadcast=0x2000,
  284. RxBadSymbol=0x0020, RxRunt=0x0010, RxTooLong=0x0008, RxCRCErr=0x0004,
  285. RxBadAlign=0x0002, RxStatusOK=0x0001,
  286. };
  288. /* Twister tuning parameters from RealTek.
  289.    Completely undocumented, but required to tune bad links. */
  290. enum CSCRBits {
  291. CSCR_LinkOKBit=0x0400, CSCR_LinkChangeBit=0x0800,
  292. CSCR_LinkStatusBits=0x0f000, CSCR_LinkDownOffCmd=0x003c0,
  293. CSCR_LinkDownCmd=0x0f3c0,
  294. };
  295. #define PARA78_default 0x78fa8388
  296. #define PARA7c_default 0xcb38de43  /* param[0][3] */
  297. #define PARA7c_xxx 0xcb38de43
  298. unsigned long param[4][4]={
  299. {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
  300. {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
  301. {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
  302. {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
  303. };
  305. #define PRIV_ALIGN 15  /* Desired alignment mask */
  306. struct rtl8129_private {
  307. struct net_device *next_module;
  308. void *priv_addr; /* Unaligned address for kfree */
  309. int chip_id;
  310. int drv_flags;
  311. struct pci_dev *pci_dev;
  312. struct net_device_stats stats;
  313. struct timer_list timer; /* Media selection timer. */
  314. unsigned char *rx_ring;
  315. unsigned int cur_rx; /* Index into the Rx buffer of next Rx pkt. */
  316. unsigned int rx_buf_len; /* Size (8K 16K 32K or 64KB) of the Rx ring */
  317. unsigned int rx_config;
  318. unsigned int cur_tx, dirty_tx, tx_flag;
  319. unsigned long tx_full; /* The Tx queue is full. */
  320. /* The saved address of a sent-in-place packet/buffer, for skfree(). */
  321. struct sk_buff* tx_skbuff[NUM_TX_DESC];
  322. unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
  323. unsigned char *tx_bufs; /* Tx bounce buffer region. */
  324. char phys[4]; /* MII device addresses. */
  325. u16 advertising; /* NWay media advertisement */
  326. char twistie, twist_row, twist_col; /* Twister tune state. */
  327. unsigned int full_duplex:1; /* Full-duplex operation requested. */
  328. unsigned int duplex_lock:1;
  329. unsigned int default_port:4; /* Last dev->if_port value. */
  330. unsigned int media2:4; /* Secondary monitored media port. */
  331. unsigned int medialock:1; /* Don't sense media type. */
  332. unsigned int mediasense:1; /* Media sensing in progress. */
  333. };
  335. MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  336. MODULE_DESCRIPTION("RealTek RTL8129/8139 Fast Ethernet driver");
  337. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  338. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  339. MODULE_PARM(multicast_filter_limit, "i");
  340. MODULE_PARM(max_interrupt_work, "i");
  341. MODULE_PARM(debug, "i");
  343. static int rtl8129_open(struct net_device *dev);
  344. static void rtl_hw_start(struct net_device *dev);
  345. static int read_eeprom(long ioaddr, int location, int addr_len);
  346. static int mdio_read(struct net_device *dev, int phy_id, int location);
  347. static void mdio_write(struct net_device *dev, int phy_id, int location, int val);
  348. static void rtl8129_timer(unsigned long data);
  349. static void rtl8129_tx_timeout(struct net_device *dev);
  350. static void rtl8129_init_ring(struct net_device *dev);
  351. static int rtl8129_start_xmit(struct sk_buff *skb, struct net_device *dev);
  352. static int rtl8129_rx(struct net_device *dev);
  353. static void rtl8129_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
  354. static int rtl8129_close(struct net_device *dev);
  355. static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  356. static struct net_device_stats *rtl8129_get_stats(struct net_device *dev);
  357. static inline u32 ether_crc(int length, unsigned char *data);
  358. static void set_rx_mode(struct net_device *dev);
  361. /* A list of all installed RTL8129 devices, for removing the driver module. */
  362. static struct net_device *root_rtl8129_dev = NULL;
  364. #ifndef MODULE
  365. int rtl8139_probe(struct net_device *dev)
  366. {
  367. static int did_version = 0; /* Already printed version info. */
  369. if (debug > 0  &&  did_version++ == 0)
  370. printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
  371. return pci_drv_register(&rtl8139_drv_id, dev);
  372. }
  373. #endif
  375. static void *rtl8139_probe1(struct pci_dev *pdev, void *init_dev,
  376. long ioaddr, int irq, int chip_idx, int found_cnt)
  377. {
  378. struct net_device *dev;
  379. struct rtl8129_private *np;
  380. void *priv_mem;
  381. int i, option = found_cnt < MAX_UNITS ? options[found_cnt] : 0;
  383. dev = init_etherdev(init_dev, 0);
  385. printk(KERN_INFO "%s: %s at %#lx, IRQ %d, ",
  386.    dev->name, pci_tbl[chip_idx].name, ioaddr, irq);
  388. /* Bring the chip out of low-power mode. */
  389. outb(0x00, ioaddr + Config1);
  391. #if 1
  392. for (i = 0; i < 6; i++)
  393. dev->dev_addr[i] = inb(ioaddr + MAC0 + i);
  394. #else
  395. {
  396. int addr_len = read_eeprom(ioaddr, 0, 8) == 0x8129 ? 8 : 6;
  397. for (i = 0; i < 3; i++)
  398. ((u16 *)(dev->dev_addr))[i] =
  399. le16_to_cpu(read_eeprom(ioaddr, i+7, addr_len));
  400. }
  401. #endif
  403. for (i = 0; i < 5; i++)
  404. printk("%2.2x:", dev->dev_addr[i]);
  405. printk("%2.2x.n", dev->dev_addr[i]);
  407. /* Make certain elements e.g. descriptor lists are aligned. */
  408. priv_mem = kmalloc(sizeof(*np) + PRIV_ALIGN, GFP_KERNEL);
  409. /* Check for the very unlikely case of no memory. */
  410. if (priv_mem == NULL)
  411. return NULL;
  413. /* We do a request_region() to register /proc/ioports info. */
  414. request_region(ioaddr, pci_tbl[chip_idx].io_size, dev->name);
  416. dev->base_addr = ioaddr;
  417. dev->irq = irq;
  419. dev->priv = np = (void *)(((long)priv_mem + PRIV_ALIGN) & ~PRIV_ALIGN);
  420. memset(np, 0, sizeof(*np));
  421. np->priv_addr = priv_mem;
  423. np->next_module = root_rtl8129_dev;
  424. root_rtl8129_dev = dev;
  426. np->pci_dev = pdev;
  427. np->chip_id = chip_idx;
  428. np->drv_flags = pci_tbl[chip_idx].drv_flags;
  430. /* Find the connected MII xcvrs.
  431.    Doing this in open() would allow detecting external xcvrs later, but
  432.    takes too much time. */
  433. if (np->drv_flags & HAS_MII_XCVR) {
  434. int phy, phy_idx = 0;
  435. for (phy = 0; phy < 32 && phy_idx < sizeof(np->phys); phy++) {
  436. int mii_status = mdio_read(dev, phy, 1);
  437. if (mii_status != 0xffff  &&  mii_status != 0x0000) {
  438. np->phys[phy_idx++] = phy;
  439. np->advertising = mdio_read(dev, phy, 4);
  440. printk(KERN_INFO "%s: MII transceiver %d status 0x%4.4x "
  441.    "advertising %4.4x.n",
  442.    dev->name, phy, mii_status, np->advertising);
  443. }
  444. }
  445. if (phy_idx == 0) {
  446. printk(KERN_INFO "%s: No MII transceivers found!  Assuming SYM "
  447.    "transceiver.n",
  448.    dev->name);
  449. np->phys[0] = 32;
  450. }
  451. } else
  452. np->phys[0] = 32;
  454. /* Put the chip into low-power mode. */
  455. outb(0xC0, ioaddr + Cfg9346);
  456. outb(0x03, ioaddr + Config1);
  457. outb('H', ioaddr + HltClk); /* 'R' would leave the clock running. */
  459. /* The lower four bits are the media type. */
  460. if (option > 0) {
  461. np->full_duplex = (option & 0x210) ? 1 : 0;
  462. np->default_port = option & 0xff;
  463. if (np->default_port)
  464. np->medialock = 1;
  465. }
  467. if (found_cnt < MAX_UNITS  &&  full_duplex[found_cnt] > 0)
  468. np->full_duplex = full_duplex[found_cnt];
  470. if (np->full_duplex) {
  471. printk(KERN_INFO "%s: Media type forced to Full Duplex.n", dev->name);
  472. /* Changing the MII-advertised media because might prevent
  473.    re-connection. */
  474. np->duplex_lock = 1;
  475. }
  476. if (np->default_port) {
  477. printk(KERN_INFO "  Forcing %dMbs %s-duplex operation.n",
  478.    (option & 0x20 ? 100 : 10),
  479.    (option & 0x10 ? "full" : "half"));
  480. mdio_write(dev, np->phys[0], 0,
  481.    ((option & 0x20) ? 0x2000 : 0) |  /* 100mbps? */
  482.    ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
  483. }
  485. /* The Rtl8129-specific entries in the device structure. */
  486. dev->open = &rtl8129_open;
  487. dev->hard_start_xmit = &rtl8129_start_xmit;
  488. dev->stop = &rtl8129_close;
  489. dev->get_stats = &rtl8129_get_stats;
  490. dev->set_multicast_list = &set_rx_mode;
  491. dev->do_ioctl = &mii_ioctl;
  493. return dev;
  494. }
  496. /* Serial EEPROM section. */
  498. /*  EEPROM_Ctrl bits. */
  499. #define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
  500. #define EE_CS 0x08 /* EEPROM chip select. */
  501. #define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
  502. #define EE_WRITE_0 0x00
  503. #define EE_WRITE_1 0x02
  504. #define EE_DATA_READ 0x01 /* EEPROM chip data out. */
  505. #define EE_ENB (0x80 | EE_CS)
  507. /* Delay between EEPROM clock transitions.
  508.    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
  509.  */
  511. #define eeprom_delay() inl(ee_addr)
  513. /* The EEPROM commands include the alway-set leading bit. */
  514. #define EE_WRITE_CMD (5)
  515. #define EE_READ_CMD (6)
  516. #define EE_ERASE_CMD (7)
  518. static int read_eeprom(long ioaddr, int location, int addr_len)
  519. {
  520. int i;
  521. unsigned retval = 0;
  522. long ee_addr = ioaddr + Cfg9346;
  523. int read_cmd = location | (EE_READ_CMD << addr_len);
  525. outb(EE_ENB & ~EE_CS, ee_addr);
  526. outb(EE_ENB, ee_addr);
  528. /* Shift the read command bits out. */
  529. for (i = 4 + addr_len; i >= 0; i--) {
  530. int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
  531. outb(EE_ENB | dataval, ee_addr);
  532. eeprom_delay();
  533. outb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
  534. eeprom_delay();
  535. }
  536. outb(EE_ENB, ee_addr);
  537. eeprom_delay();
  539. for (i = 16; i > 0; i--) {
  540. outb(EE_ENB | EE_SHIFT_CLK, ee_addr);
  541. eeprom_delay();
  542. retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
  543. outb(EE_ENB, ee_addr);
  544. eeprom_delay();
  545. }
  547. /* Terminate the EEPROM access. */
  548. outb(~EE_CS, ee_addr);
  549. return retval;
  550. }
  552. /* MII serial management: mostly bogus for now. */
  553. /* Read and write the MII management registers using software-generated
  554.    serial MDIO protocol.
  555.    The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
  556.    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
  557.    "overclocking" issues. */
  558. #define MDIO_DIR 0x80
  559. #define MDIO_DATA_OUT 0x04
  560. #define MDIO_DATA_IN 0x02
  561. #define MDIO_CLK 0x01
  562. #define MDIO_WRITE0 (MDIO_DIR)
  563. #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
  565. #define mdio_delay(mdio_addr) inb(mdio_addr)
  567. static char mii_2_8139_map[8] = {MII_BMCR, MII_BMSR, 0, 0, NWayAdvert,
  568.  NWayLPAR, NWayExpansion, 0 };
  570. /* Syncronize the MII management interface by shifting 32 one bits out. */
  571. static void mdio_sync(long mdio_addr)
  572. {
  573. int i;
  575. for (i = 32; i >= 0; i--) {
  576. outb(MDIO_WRITE1, mdio_addr);
  577. mdio_delay(mdio_addr);
  578. outb(MDIO_WRITE1 | MDIO_CLK, mdio_addr);
  579. mdio_delay(mdio_addr);
  580. }
  581. return;
  582. }
  583. static int mdio_read(struct net_device *dev, int phy_id, int location)
  584. {
  585. long mdio_addr = dev->base_addr + MII_SMI;
  586. int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
  587. int retval = 0;
  588. int i;
  590. if (phy_id > 31) { /* Really a 8139.  Use internal registers. */
  591. return location < 8 && mii_2_8139_map[location] ?
  592. inw(dev->base_addr + mii_2_8139_map[location]) : 0;
  593. }
  594. mdio_sync(mdio_addr);
  595. /* Shift the read command bits out. */
  596. for (i = 15; i >= 0; i--) {
  597. int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
  599. outb(MDIO_DIR | dataval, mdio_addr);
  600. mdio_delay(mdio_addr);
  601. outb(MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
  602. mdio_delay(mdio_addr);
  603. }
  605. /* Read the two transition, 16 data, and wire-idle bits. */
  606. for (i = 19; i > 0; i--) {
  607. outb(0, mdio_addr);
  608. mdio_delay(mdio_addr);
  609. retval = (retval << 1) | ((inb(mdio_addr) & MDIO_DATA_IN) ? 1 : 0);
  610. outb(MDIO_CLK, mdio_addr);
  611. mdio_delay(mdio_addr);
  612. }
  613. return (retval>>1) & 0xffff;
  614. }
  616. static void mdio_write(struct net_device *dev, int phy_id, int location,
  617.    int value)
  618. {
  619. long mdio_addr = dev->base_addr + MII_SMI;
  620. int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
  621. int i;
  623. if (phy_id > 31) { /* Really a 8139.  Use internal registers. */
  624. long ioaddr = dev->base_addr;
  625. if (location == 0) {
  626. outb(0xC0, ioaddr + Cfg9346);
  627. outw(value, ioaddr + MII_BMCR);
  628. outb(0x00, ioaddr + Cfg9346);
  629. } else if (location < 8  &&  mii_2_8139_map[location])
  630. outw(value, ioaddr + mii_2_8139_map[location]);
  631. return;
  632. }
  633. mdio_sync(mdio_addr);
  635. /* Shift the command bits out. */
  636. for (i = 31; i >= 0; i--) {
  637. int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
  638. outb(dataval, mdio_addr);
  639. mdio_delay(mdio_addr);
  640. outb(dataval | MDIO_CLK, mdio_addr);
  641. mdio_delay(mdio_addr);
  642. }
  643. /* Clear out extra bits. */
  644. for (i = 2; i > 0; i--) {
  645. outb(0, mdio_addr);
  646. mdio_delay(mdio_addr);
  647. outb(MDIO_CLK, mdio_addr);
  648. mdio_delay(mdio_addr);
  649. }
  650. return;
  651. }
  654. static int rtl8129_open(struct net_device *dev)
  655. {
  656. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  657. long ioaddr = dev->base_addr;
  658. int rx_buf_len_idx;
  660. MOD_INC_USE_COUNT;
  661. if (request_irq(dev->irq, &rtl8129_interrupt, SA_SHIRQ, dev->name, dev)) {
  662. MOD_DEC_USE_COUNT;
  663. return -EAGAIN;
  664. }
  666. /* The Rx ring allocation size is 2^N + delta, which is worst-case for
  667.    the kernel binary-buddy allocation.  We allocate the Tx bounce buffers
  668.    at the same time to use some of the otherwise wasted space.
  669.    The delta of +16 is required for dribble-over because the receiver does
  670.    not wrap when the packet terminates just beyond the end of the ring. */
  671. rx_buf_len_idx = RX_BUF_LEN_IDX;
  672. do {
  673. tp->rx_buf_len = 8192 << rx_buf_len_idx;
  674. tp->rx_ring = kmalloc(tp->rx_buf_len + 16 +
  675.   (TX_BUF_SIZE * NUM_TX_DESC), GFP_KERNEL);
  676. } while (tp->rx_ring == NULL  &&  --rx_buf_len_idx >= 0);
  678. if (tp->rx_ring == NULL) {
  679. if (debug > 0)
  680. printk(KERN_ERR "%s: Couldn't allocate a %d byte receive ring.n",
  681.    dev->name, tp->rx_buf_len);
  682. MOD_DEC_USE_COUNT;
  683. return -ENOMEM;
  684. }
  685. tp->tx_bufs = tp->rx_ring + tp->rx_buf_len + 16;
  687. rtl8129_init_ring(dev);
  688. tp->full_duplex = tp->duplex_lock;
  689. tp->tx_flag = (TX_FIFO_THRESH<<11) & 0x003f0000;
  690. tp->rx_config =
  691. (RX_FIFO_THRESH << 13) | (rx_buf_len_idx << 11) | (RX_DMA_BURST<<8);
  693. rtl_hw_start(dev);
  694. netif_start_tx_queue(dev);
  696. if (debug > 1)
  697. printk(KERN_DEBUG"%s: rtl8129_open() ioaddr %#lx IRQ %d"
  698.    " GP Pins %2.2x %s-duplex.n",
  699.    dev->name, ioaddr, dev->irq, inb(ioaddr + GPPinData),
  700.    tp->full_duplex ? "full" : "half");
  702. /* Set the timer to switch to check for link beat and perhaps switch
  703.    to an alternate media type. */
  704. init_timer(&tp->timer);
  705. tp->timer.expires = jiffies + 3*HZ;
  706. tp->timer.data = (unsigned long)dev;
  707. tp->timer.function = &rtl8129_timer;
  708. add_timer(&tp->timer);
  710. return 0;
  711. }
  713. /* Start the hardware at open or resume. */
  714. static void rtl_hw_start(struct net_device *dev)
  715. {
  716. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  717. long ioaddr = dev->base_addr;
  718. int i;
  720. /* Soft reset the chip. */
  721. outb(CmdReset, ioaddr + ChipCmd);
  722. /* Check that the chip has finished the reset. */
  723. for (i = 1000; i > 0; i--)
  724. if ((inb(ioaddr + ChipCmd) & CmdReset) == 0)
  725. break;
  726. /* Restore our idea of the MAC address. */
  727. outb(0xC0, ioaddr + Cfg9346);
  728. outl(cpu_to_le32(*(u32*)(dev->dev_addr + 0)), ioaddr + MAC0 + 0);
  729. outl(cpu_to_le32(*(u32*)(dev->dev_addr + 4)), ioaddr + MAC0 + 4);
  731. /* Hmmm, do these belong here? */
  732. tp->cur_rx = 0;
  734. /* Must enable Tx/Rx before setting transfer thresholds! */
  735. outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd);
  736. outl(tp->rx_config, ioaddr + RxConfig);
  737. /* Check this value: the documentation contradicts ifself.  Is the
  738.    IFG correct with bit 28:27 zero, or with |0x03000000 ? */
  739. outl((TX_DMA_BURST<<8), ioaddr + TxConfig);
  741. /* This is check_duplex() */
  742. if (tp->phys[0] >= 0  ||  (tp->drv_flags & HAS_MII_XCVR)) {
  743. u16 mii_reg5 = mdio_read(dev, tp->phys[0], 5);
  744. if (mii_reg5 == 0xffff)
  745. ; /* Not there */
  746. else if ((mii_reg5 & 0x0100) == 0x0100
  747.  || (mii_reg5 & 0x00C0) == 0x0040)
  748. tp->full_duplex = 1;
  749. if (debug > 1)
  750. printk(KERN_INFO"%s: Setting %s%s-duplex based on"
  751.    " auto-negotiated partner ability %4.4x.n", dev->name,
  752.    mii_reg5 == 0 ? "" :
  753.    (mii_reg5 & 0x0180) ? "100mbps " : "10mbps ",
  754.    tp->full_duplex ? "full" : "half", mii_reg5);
  755. }
  757. outb(tp->full_duplex ? 0x60 : 0x20, ioaddr + Config1);
  758. outb(0x00, ioaddr + Cfg9346);
  760. outl(virt_to_bus(tp->rx_ring), ioaddr + RxBuf);
  761. /* Start the chip's Tx and Rx process. */
  762. outl(0, ioaddr + RxMissed);
  763. set_rx_mode(dev);
  764. outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd);
  765. /* Enable all known interrupts by setting the interrupt mask. */
  766. outw(PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver
  767.  | TxErr | TxOK | RxErr | RxOK, ioaddr + IntrMask);
  769. }
  771. static void rtl8129_timer(unsigned long data)
  772. {
  773. struct net_device *dev = (struct net_device *)data;
  774. struct rtl8129_private *np = (struct rtl8129_private *)dev->priv;
  775. long ioaddr = dev->base_addr;
  776. int next_tick = 60*HZ;
  777. int mii_reg5 = mdio_read(dev, np->phys[0], 5);
  779. if (! np->duplex_lock  &&  mii_reg5 != 0xffff) {
  780. int duplex = (mii_reg5&0x0100) || (mii_reg5 & 0x01C0) == 0x0040;
  781. if (np->full_duplex != duplex) {
  782. np->full_duplex = duplex;
  783. printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d link"
  784.    " partner ability of %4.4x.n", dev->name,
  785.    np->full_duplex ? "full" : "half", np->phys[0], mii_reg5);
  786. outb(0xC0, ioaddr + Cfg9346);
  787. outb(np->full_duplex ? 0x60 : 0x20, ioaddr + Config1);
  788. outb(0x00, ioaddr + Cfg9346);
  789. }
  790. }
  791. #if LINUX_VERSION_CODE < 0x20300
  792. /* Check for bogusness. */
  793. if (inw(ioaddr + IntrStatus) & (TxOK | RxOK)) {
  794. int status = inw(ioaddr + IntrStatus); /* Double check */
  795. if (status & (TxOK | RxOK)  &&  ! dev->interrupt) {
  796. printk(KERN_ERR "%s: RTL8139 Interrupt line blocked, status %x.n",
  797.    dev->name, status);
  798. rtl8129_interrupt(dev->irq, dev, 0);
  799. }
  800. }
  801. if (dev->tbusy  &&  jiffies - dev->trans_start >= 2*TX_TIMEOUT)
  802. rtl8129_tx_timeout(dev);
  803. #else
  804. if (netif_queue_paused(dev)  &&
  805. np->cur_tx - np->dirty_tx > 1  &&
  806. (jiffies - dev->trans_start) > TX_TIMEOUT) {
  807. rtl8129_tx_timeout(dev);
  808. }
  809. #endif
  811. #if defined(RTL_TUNE_TWISTER)
  812. /* This is a complicated state machine to configure the "twister" for
  813.    impedance/echos based on the cable length.
  814.    All of this is magic and undocumented.
  815.    */
  816. if (np->twistie) switch(np->twistie) {
  817. case 1: {
  818. if (inw(ioaddr + CSCR) & CSCR_LinkOKBit) {
  819. /* We have link beat, let us tune the twister. */
  820. outw(CSCR_LinkDownOffCmd, ioaddr + CSCR);
  821. np->twistie = 2; /* Change to state 2. */
  822. next_tick = HZ/10;
  823. } else {
  824. /* Just put in some reasonable defaults for when beat returns. */
  825. outw(CSCR_LinkDownCmd, ioaddr + CSCR);
  826. outl(0x20,ioaddr + FIFOTMS); /* Turn on cable test mode. */
  827. outl(PARA78_default ,ioaddr + PARA78);
  828. outl(PARA7c_default ,ioaddr + PARA7c);
  829. np->twistie = 0; /* Bail from future actions. */
  830. }
  831. } break;
  832. case 2: {
  833. /* Read how long it took to hear the echo. */
  834. int linkcase = inw(ioaddr + CSCR) & CSCR_LinkStatusBits;
  835. if (linkcase == 0x7000) np->twist_row = 3;
  836. else if (linkcase == 0x3000) np->twist_row = 2;
  837. else if (linkcase == 0x1000) np->twist_row = 1;
  838. else np->twist_row = 0;
  839. np->twist_col = 0;
  840. np->twistie = 3; /* Change to state 2. */
  841. next_tick = HZ/10;
  842. } break;
  843. case 3: {
  844. /* Put out four tuning parameters, one per 100msec. */
  845. if (np->twist_col == 0) outw(0, ioaddr + FIFOTMS);
  846. outl(param[(int)np->twist_row][(int)np->twist_col], ioaddr + PARA7c);
  847. next_tick = HZ/10;
  848. if (++np->twist_col >= 4) {
  849. /* For short cables we are done.
  850.    For long cables (row == 3) check for mistune. */
  851. np->twistie = (np->twist_row == 3) ? 4 : 0;
  852. }
  853. } break;
  854. case 4: {
  855. /* Special case for long cables: check for mistune. */
  856. if ((inw(ioaddr + CSCR) & CSCR_LinkStatusBits) == 0x7000) {
  857. np->twistie = 0;
  858. break;
  859. } else {
  860. outl(0xfb38de03, ioaddr + PARA7c);
  861. np->twistie = 5;
  862. next_tick = HZ/10;
  863. }
  864. } break;
  865. case 5: {
  866. /* Retune for shorter cable (column 2). */
  867. outl(0x20,ioaddr + FIFOTMS);
  868. outl(PARA78_default,  ioaddr + PARA78);
  869. outl(PARA7c_default,  ioaddr + PARA7c);
  870. outl(0x00,ioaddr + FIFOTMS);
  871. np->twist_row = 2;
  872. np->twist_col = 0;
  873. np->twistie = 3;
  874. next_tick = HZ/10;
  875. } break;
  876. }
  877. #endif
  879. if (debug > 2) {
  880. if (np->drv_flags & HAS_MII_XCVR)
  881. printk(KERN_DEBUG"%s: Media selection tick, GP pins %2.2x.n",
  882.    dev->name, inb(ioaddr + GPPinData));
  883. else
  884. printk(KERN_DEBUG"%s: Media selection tick, Link partner %4.4x.n",
  885.    dev->name, inw(ioaddr + NWayLPAR));
  886. printk(KERN_DEBUG"%s:  Other registers are IntMask %4.4x IntStatus %4.4x"
  887.    " RxStatus %4.4x.n",
  888.    dev->name, inw(ioaddr + IntrMask), inw(ioaddr + IntrStatus),
  889.    inl(ioaddr + RxEarlyStatus));
  890. printk(KERN_DEBUG"%s:  Chip config %2.2x %2.2x.n",
  891.    dev->name, inb(ioaddr + Config0), inb(ioaddr + Config1));
  892. }
  894. np->timer.expires = jiffies + next_tick;
  895. add_timer(&np->timer);
  896. }
  898. static void rtl8129_tx_timeout(struct net_device *dev)
  899. {
  900. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  901. long ioaddr = dev->base_addr;
  902. int mii_reg, i;
  904. if (debug > 0)
  905. printk(KERN_ERR "%s: Transmit timeout, status %2.2x %4.4x "
  906.    "media %2.2x.n",
  907.    dev->name, inb(ioaddr + ChipCmd), inw(ioaddr + IntrStatus),
  908.    inb(ioaddr + GPPinData));
  910. /* Disable interrupts by clearing the interrupt mask. */
  911. outw(0x0000, ioaddr + IntrMask);
  912. /* Emit info to figure out what went wrong. */
  913. printk(KERN_DEBUG "%s: Tx queue start entry %d  dirty entry %d%s.n",
  914.    dev->name, tp->cur_tx, tp->dirty_tx, tp->tx_full ? ", full" : "");
  915. for (i = 0; i < NUM_TX_DESC; i++)
  916. printk(KERN_DEBUG "%s:  Tx descriptor %d is %8.8x.%sn",
  917.    dev->name, i, inl(ioaddr + TxStatus0 + i*4),
  918.    i == tp->dirty_tx % NUM_TX_DESC ? " (queue head)" : "");
  919. printk(KERN_DEBUG "%s: MII #%d registers are:", dev->name, tp->phys[0]);
  920. for (mii_reg = 0; mii_reg < 8; mii_reg++)
  921. printk(" %4.4x", mdio_read(dev, tp->phys[0], mii_reg));
  922. printk(".n");
  924. /* Stop a shared interrupt from scavenging while we are. */
  925. tp->dirty_tx = tp->cur_tx = 0;
  926. /* Dump the unsent Tx packets. */
  927. for (i = 0; i < NUM_TX_DESC; i++) {
  928. if (tp->tx_skbuff[i]) {
  929. dev_free_skb(tp->tx_skbuff[i]);
  930. tp->tx_skbuff[i] = 0;
  931. tp->stats.tx_dropped++;
  932. }
  933. }
  934. rtl_hw_start(dev);
  935. netif_unpause_tx_queue(dev);
  936. tp->tx_full = 0;
  937. return;
  938. }
  941. /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
  942. static void
  943. rtl8129_init_ring(struct net_device *dev)
  944. {
  945. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  946. int i;
  948. tp->tx_full = 0;
  949. tp->dirty_tx = tp->cur_tx = 0;
  951. for (i = 0; i < NUM_TX_DESC; i++) {
  952. tp->tx_skbuff[i] = 0;
  953. tp->tx_buf[i] = &tp->tx_bufs[i*TX_BUF_SIZE];
  954. }
  955. }
  957. static int
  958. rtl8129_start_xmit(struct sk_buff *skb, struct net_device *dev)
  959. {
  960. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  961. long ioaddr = dev->base_addr;
  962. int entry;
  964. #ifdef CONFIG_LEDMAN
  965. ledman_cmd(LEDMAN_CMD_SET,
  966. (dev->name[3] == '0') ? LEDMAN_LAN1_TX : LEDMAN_LAN2_TX);
  967. #endif
  969. if (netif_pause_tx_queue(dev) != 0) {
  970. /* This watchdog code is redundant with the media monitor timer. */
  971. if (jiffies - dev->trans_start > TX_TIMEOUT)
  972. rtl8129_tx_timeout(dev);
  973. return 1;
  974. }
  976. /* Calculate the next Tx descriptor entry. */
  977. entry = tp->cur_tx % NUM_TX_DESC;
  979. tp->tx_skbuff[entry] = skb;
  980. if ((long)skb->data & 3) { /* Must use alignment buffer. */
  981. memcpy(tp->tx_buf[entry], skb->data, skb->len);
  982. outl(virt_to_bus(tp->tx_buf[entry]), ioaddr + TxAddr0 + entry*4);
  983. } else
  984. outl(virt_to_bus(skb->data), ioaddr + TxAddr0 + entry*4);
  985. /* Note: the chip doesn't have auto-pad! */
  986. outl(tp->tx_flag | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN),
  987.  ioaddr + TxStatus0 + entry*4);
  989. /* There is a race condition here -- we might read dirty_tx, take an
  990.    interrupt that clears the Tx queue, and only then set tx_full.
  991.    So we do this in two phases. */
  992. if (++tp->cur_tx - tp->dirty_tx >= NUM_TX_DESC) {
  993. set_bit(0, &tp->tx_full);
  994. if (tp->cur_tx - (volatile unsigned int)tp->dirty_tx < NUM_TX_DESC) {
  995. clear_bit(0, &tp->tx_full);
  996. netif_unpause_tx_queue(dev);
  997. } else
  998. netif_stop_tx_queue(dev);
  999. } else
  1000. netif_unpause_tx_queue(dev);
  1002. dev->trans_start = jiffies;
  1003. if (debug > 4)
  1004. printk(KERN_DEBUG"%s: Queued Tx packet at %p size %d to slot %d.n",
  1005.    dev->name, skb->data, (int)skb->len, entry);
  1007. return 0;
  1008. }
  1010. /* The interrupt handler does all of the Rx thread work and cleans up
  1011.    after the Tx thread. */
  1012. static void rtl8129_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
  1013. {
  1014. struct net_device *dev = (struct net_device *)dev_instance;
  1015. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  1016. int boguscnt = max_interrupt_work;
  1017. long ioaddr = dev->base_addr;
  1018. int link_changed = 0; /* Grrr, avoid bogus "uninitialized" warning */
  1020. #if defined(__i386__)  &&  LINUX_VERSION_CODE < 0x20123
  1021. /* A lock to prevent simultaneous entry bug on Intel SMP machines. */
  1022. if (test_and_set_bit(0, (void*)&dev->interrupt)) {
  1023. printk(KERN_ERR"%s: SMP simultaneous entry of an interrupt handler.n",
  1024.    dev->name);
  1025. dev->interrupt = 0; /* Avoid halting machine. */
  1026. return;
  1027. }
  1028. #endif
  1030. do {
  1031. int status = inw(ioaddr + IntrStatus);
  1032. /* Acknowledge all of the current interrupt sources ASAP, but
  1033.    an first get an additional status bit from CSCR. */
  1034. if (status & RxUnderrun)
  1035. link_changed = inw(ioaddr+CSCR) & CSCR_LinkChangeBit;
  1036. outw(status, ioaddr + IntrStatus);
  1038. if (debug > 4)
  1039. printk(KERN_DEBUG"%s: interrupt  status=%#4.4x new intstat=%#4.4x.n",
  1040.    dev->name, status, inw(ioaddr + IntrStatus));
  1042. if ((status & (PCIErr|PCSTimeout|RxUnderrun|RxOverflow|RxFIFOOver
  1043.    |TxErr|TxOK|RxErr|RxOK)) == 0)
  1044. break;
  1046. if (status & (RxOK|RxUnderrun|RxOverflow|RxFIFOOver))/* Rx interrupt */
  1047. rtl8129_rx(dev);
  1049. if (status & (TxOK | TxErr)) {
  1050. unsigned int dirty_tx = tp->dirty_tx;
  1052. while (tp->cur_tx - dirty_tx > 0) {
  1053. int entry = dirty_tx % NUM_TX_DESC;
  1054. int txstatus = inl(ioaddr + TxStatus0 + entry*4);
  1056. if ( ! (txstatus & (TxStatOK | TxUnderrun | TxAborted)))
  1057. break; /* It still hasn't been Txed */
  1059. /* Note: TxCarrierLost is always asserted at 100mbps. */
  1060. if (txstatus & (TxOutOfWindow | TxAborted)) {
  1061. /* There was an major error, log it. */
  1062. if (debug > 1)
  1063. printk(KERN_NOTICE"%s: Transmit error, Tx status %8.8x.n",
  1064.    dev->name, txstatus);
  1065. tp->stats.tx_errors++;
  1066. if (txstatus&TxAborted) {
  1067. tp->stats.tx_aborted_errors++;
  1068. outl(TX_DMA_BURST << 8, ioaddr + TxConfig);
  1069. }
  1070. if (txstatus&TxCarrierLost) tp->stats.tx_carrier_errors++;
  1071. if (txstatus&TxOutOfWindow) tp->stats.tx_window_errors++;
  1072. #ifdef ETHER_STATS
  1073. if ((txstatus & 0x0f000000) == 0x0f000000)
  1074. tp->stats.collisions16++;
  1075. #endif
  1076. } else {
  1077. if (txstatus & TxUnderrun) {
  1078. /* Add 64 to the Tx FIFO threshold. */
  1079. if (tp->tx_flag <  0x00300000)
  1080. tp->tx_flag += 0x00020000;
  1081. tp->stats.tx_fifo_errors++;
  1082. }
  1083. tp->stats.collisions += (txstatus >> 24) & 15;
  1084. #if LINUX_VERSION_CODE > 0x20119
  1085. tp->stats.tx_bytes += txstatus & 0x7ff;
  1086. #endif
  1087. tp->stats.tx_packets++;
  1088. }
  1090. /* Free the original skb. */
  1091. dev_free_skb_irq(tp->tx_skbuff[entry]);
  1092. tp->tx_skbuff[entry] = 0;
  1093. if (test_bit(0, &tp->tx_full)) {
  1094. /* The ring is no longer full, clear tbusy. */
  1095. clear_bit(0, &tp->tx_full);
  1096. netif_resume_tx_queue(dev);
  1097. }
  1098. dirty_tx++;
  1099. }
  1101. #ifndef final_version
  1102. if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
  1103. printk(KERN_ERR"%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.n",
  1104.    dev->name, dirty_tx, tp->cur_tx, (int)tp->tx_full);
  1105. dirty_tx += NUM_TX_DESC;
  1106. }
  1107. #endif
  1108. tp->dirty_tx = dirty_tx;
  1109. }
  1111. /* Check uncommon events with one test. */
  1112. if (status & (PCIErr|PCSTimeout |RxUnderrun|RxOverflow|RxFIFOOver
  1113.   |TxErr|RxErr)) {
  1114. if (debug > 2)
  1115. printk(KERN_NOTICE"%s: Abnormal interrupt, status %8.8x.n",
  1116.    dev->name, status);
  1118. if (status == 0xffff)
  1119. break;
  1120. /* Update the error count. */
  1121. tp->stats.rx_missed_errors += inl(ioaddr + RxMissed);
  1122. outl(0, ioaddr + RxMissed);
  1124. if ((status & RxUnderrun)  &&  link_changed  &&
  1125. (tp->drv_flags & HAS_LNK_CHNG)) {
  1126. /* Really link-change on new chips. */
  1127. int lpar = inw(ioaddr + NWayLPAR);
  1128. int duplex = (lpar&0x0100) || (lpar & 0x01C0) == 0x0040
  1129. || tp->duplex_lock;
  1130. if (debug > 1)
  1131. printk(KERN_DEBUG "%s: Link changed, link partner "
  1132.    "%4.4x new duplex %d.n",
  1133.    dev->name, lpar, duplex);
  1134. if (tp->full_duplex != duplex) {
  1135. tp->full_duplex = duplex;
  1136. outb(0xC0, ioaddr + Cfg9346);
  1137. outb(tp->full_duplex ? 0x60 : 0x20, ioaddr + Config1);
  1138. outb(0x00, ioaddr + Cfg9346);
  1139. }
  1140. status &= ~RxUnderrun;
  1141. }
  1142. if (status & (RxUnderrun | RxOverflow | RxErr | RxFIFOOver))
  1143. tp->stats.rx_errors++;
  1145. if (status & (PCSTimeout)) tp->stats.rx_length_errors++;
  1146. if (status & (RxUnderrun|RxFIFOOver)) tp->stats.rx_fifo_errors++;
  1147. if (status & RxOverflow) {
  1148. tp->stats.rx_over_errors++;
  1149. tp->cur_rx = inw(ioaddr + RxBufAddr) % tp->rx_buf_len;
  1150. outw(tp->cur_rx - 16, ioaddr + RxBufPtr);
  1151. }
  1152. if (status & PCIErr) {
  1153. u32 pci_cmd_status;
  1154. pci_read_config_dword(tp->pci_dev, PCI_COMMAND, &pci_cmd_status);
  1156. printk(KERN_ERR "%s: PCI Bus error %4.4x.n",
  1157.    dev->name, pci_cmd_status);
  1158. }
  1159. }
  1160. if (--boguscnt < 0) {
  1161. printk(KERN_WARNING"%s: Too much work at interrupt, "
  1162.    "IntrStatus=0x%4.4x.n",
  1163.    dev->name, status);
  1164. /* Clear all interrupt sources. */
  1165. outw(0xffff, ioaddr + IntrStatus);
  1166. break;
  1167. }
  1168. } while (1);
  1170. if (debug > 3)
  1171. printk(KERN_DEBUG"%s: exiting interrupt, intr_status=%#4.4x.n",
  1172.    dev->name, inw(ioaddr + IntrStatus));
  1174. #if defined(__i386__)  &&  LINUX_VERSION_CODE < 0x20123
  1175. clear_bit(0, (void*)&dev->interrupt);
  1176. #endif
  1177. return;
  1178. }
  1180. /* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
  1181.    field alignments and semantics. */
  1182. static int rtl8129_rx(struct net_device *dev)
  1183. {
  1184. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  1185. long ioaddr = dev->base_addr;
  1186. unsigned char *rx_ring = tp->rx_ring;
  1187. u16 cur_rx = tp->cur_rx;
  1189. if (debug > 4)
  1190. printk(KERN_DEBUG"%s: In rtl8129_rx(), current %4.4x BufAddr %4.4x,"
  1191.    " free to %4.4x, Cmd %2.2x.n",
  1192.    dev->name, cur_rx, inw(ioaddr + RxBufAddr),
  1193.    inw(ioaddr + RxBufPtr), inb(ioaddr + ChipCmd));
  1195. #ifdef CONFIG_LEDMAN
  1196. ledman_cmd(LEDMAN_CMD_SET,
  1197. (dev->name[3] == '0') ? LEDMAN_LAN1_RX : LEDMAN_LAN2_RX);
  1198. #endif
  1200. while ((inb(ioaddr + ChipCmd) & RxBufEmpty) == 0) {
  1201. int ring_offset = cur_rx % tp->rx_buf_len;
  1202. u32 rx_status = le32_to_cpu(*(u32*)(rx_ring + ring_offset));
  1203. int rx_size = rx_status >> 16;  /* Includes the CRC. */
  1205. if (debug > 4) {
  1206. int i;
  1207. printk(KERN_DEBUG"%s:  rtl8129_rx() status %4.4x, size %4.4x,"
  1208.    " cur %4.4x.n",
  1209.    dev->name, rx_status, rx_size, cur_rx);
  1210. printk(KERN_DEBUG"%s: Frame contents ", dev->name);
  1211. for (i = 0; i < 70; i++)
  1212. printk(" %2.2x", rx_ring[ring_offset + i]);
  1213. printk(".n");
  1214. }
  1215. if (rx_status & (RxBadSymbol|RxRunt|RxTooLong|RxCRCErr|RxBadAlign)) {
  1216. if (debug > 1)
  1217. printk(KERN_DEBUG"%s: Ethernet frame had errors,"
  1218.    " status %8.8x.n", dev->name, rx_status);
  1219. if (rx_status == 0xffffffff) {
  1220. if (debug > 0)
  1221. printk(KERN_NOTICE"%s: Invalid receive status at ring "
  1222.    "offset %4.4xn", dev->name, ring_offset);
  1223. rx_status = 0;
  1224. }
  1225. if (rx_status & RxTooLong) {
  1226. if (debug > 0)
  1227. printk(KERN_NOTICE"%s: Oversized Ethernet frame, status %4.4x!n",
  1228.    dev->name, rx_status);
  1229. /* A.C.: The chip hangs here. */
  1230. }
  1231. tp->stats.rx_errors++;
  1232. if (rx_status & (RxBadSymbol|RxBadAlign))
  1233. tp->stats.rx_frame_errors++;
  1234. if (rx_status & (RxRunt|RxTooLong)) tp->stats.rx_length_errors++;
  1235. if (rx_status & RxCRCErr) tp->stats.rx_crc_errors++;
  1236. /* Reset the receiver, based on RealTek recommendation. (Bug?) */
  1237. tp->cur_rx = 0;
  1238. outb(CmdTxEnb, ioaddr + ChipCmd);
  1239. /* A.C.: Reset the multicast list. */
  1240. set_rx_mode(dev);
  1241. outb(CmdRxEnb | CmdTxEnb, ioaddr + ChipCmd);
  1242. } else {
  1243. /* Malloc up new buffer, compatible with net-2e. */
  1244. /* Omit the four octet CRC from the length. */
  1245. struct sk_buff *skb;
  1246. int pkt_size = rx_size - 4;
  1248. skb = dev_alloc_skb(pkt_size + 2);
  1249. if (skb == NULL) {
  1250. printk(KERN_WARNING"%s: Memory squeeze, deferring packet.n",
  1251.    dev->name);
  1252. /* We should check that some rx space is free.
  1253.    If not, free one and mark stats->rx_dropped++. */
  1254. tp->stats.rx_dropped++;
  1255. break;
  1256. }
  1257. skb->dev = dev;
  1258. skb_reserve(skb, 2); /* 16 byte align the IP fields. */
  1259. if (ring_offset + rx_size > tp->rx_buf_len) {
  1260. int semi_count = tp->rx_buf_len - ring_offset - 4;
  1261. /* This could presumably use two calls to copy_and_sum()? */
  1262. memcpy(skb_put(skb, semi_count), &rx_ring[ring_offset + 4],
  1263.    semi_count);
  1264. memcpy(skb_put(skb, pkt_size-semi_count), rx_ring,
  1265.    pkt_size-semi_count);
  1266. if (debug > 4) {
  1267. int i;
  1268. printk(KERN_DEBUG"%s:  Frame wrap @%d",
  1269.    dev->name, semi_count);
  1270. for (i = 0; i < 16; i++)
  1271. printk(" %2.2x", rx_ring[i]);
  1272. printk(".n");
  1273. memset(rx_ring, 0xcc, 16);
  1274. }
  1275. } else {
  1276. eth_copy_and_sum(skb, &rx_ring[ring_offset + 4],
  1277.  pkt_size, 0);
  1278. skb_put(skb, pkt_size);
  1279. }
  1280. skb->protocol = eth_type_trans(skb, dev);
  1281. netif_rx(skb);
  1282. #if LINUX_VERSION_CODE > 0x20119
  1283. tp->stats.rx_bytes += pkt_size;
  1284. #endif
  1285. tp->stats.rx_packets++;
  1286. }
  1288. cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
  1289. outw(cur_rx - 16, ioaddr + RxBufPtr);
  1290. }
  1291. if (debug > 4)
  1292. printk(KERN_DEBUG"%s: Done rtl8129_rx(), current %4.4x BufAddr %4.4x,"
  1293.    " free to %4.4x, Cmd %2.2x.n",
  1294.    dev->name, cur_rx, inw(ioaddr + RxBufAddr),
  1295.    inw(ioaddr + RxBufPtr), inb(ioaddr + ChipCmd));
  1296. tp->cur_rx = cur_rx;
  1297. return 0;
  1298. }
  1300. static int
  1301. rtl8129_close(struct net_device *dev)
  1302. {
  1303. long ioaddr = dev->base_addr;
  1304. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  1305. int i;
  1307. netif_stop_tx_queue(dev);
  1309. if (debug > 1)
  1310. printk(KERN_DEBUG"%s: Shutting down ethercard, status was 0x%4.4x.n",
  1311.    dev->name, inw(ioaddr + IntrStatus));
  1313. /* Disable interrupts by clearing the interrupt mask. */
  1314. outw(0x0000, ioaddr + IntrMask);
  1316. /* Stop the chip's Tx and Rx DMA processes. */
  1317. outb(0x00, ioaddr + ChipCmd);
  1319. /* Update the error counts. */
  1320. tp->stats.rx_missed_errors += inl(ioaddr + RxMissed);
  1321. outl(0, ioaddr + RxMissed);
  1323. del_timer(&tp->timer);
  1325. free_irq(dev->irq, dev);
  1327. for (i = 0; i < NUM_TX_DESC; i++) {
  1328. if (tp->tx_skbuff[i])
  1329. dev_free_skb(tp->tx_skbuff[i]);
  1330. tp->tx_skbuff[i] = 0;
  1331. }
  1332. kfree(tp->rx_ring);
  1333. tp->rx_ring = 0;
  1335. /* Green! Put the chip in low-power mode. */
  1336. outb(0xC0, ioaddr + Cfg9346);
  1337. outb(0x03, ioaddr + Config1);
  1338. outb('H', ioaddr + HltClk); /* 'R' would leave the clock running. */
  1340. MOD_DEC_USE_COUNT;
  1342. return 0;
  1343. }
  1345. static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1346. {
  1347. struct rtl8129_private *np = (struct rtl8129_private *)dev->priv;
  1348. u16 *data = (u16 *)&rq->ifr_data;
  1350. switch(cmd) {
  1351. case SIOCGMIIPHY: /* Get the address of the PHY in use. */
  1352. data[0] = np->phys[0] & 0x3f;
  1353. /* Fall Through */
  1354. case SIOCGMIIREG: /* Read the specified MII register. */
  1355. data[3] = mdio_read(dev, data[0], data[1] & 0x1f);
  1356. return 0;
  1357. case SIOCSMIIREG: /* Write the specified MII register */
  1358. if (!capable(CAP_NET_ADMIN))
  1359. return -EPERM;
  1360. if (data[0] == np->phys[0]) {
  1361. u16 value = data[2];
  1362. switch (data[1]) {
  1363. case 0:
  1364. /* Check for autonegotiation on or reset. */
  1365. np->medialock = (value & 0x9000) ? 0 : 1;
  1366. if (np->medialock)
  1367. np->full_duplex = (value & 0x0100) ? 1 : 0;
  1368. break;
  1369. case 4: np->advertising = value; break;
  1370. }
  1371. }
  1372. mdio_write(dev, data[0], data[1] & 0x1f, data[2]);
  1373. return 0;
  1374. default:
  1375. return -EOPNOTSUPP;
  1376. }
  1377. }
  1379. static struct net_device_stats *
  1380. rtl8129_get_stats(struct net_device *dev)
  1381. {
  1382. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  1383. long ioaddr = dev->base_addr;
  1385. if (netif_running(dev)) {
  1386. tp->stats.rx_missed_errors += inl(ioaddr + RxMissed);
  1387. outl(0, ioaddr + RxMissed);
  1388. }
  1390. return &tp->stats;
  1391. }
  1393. /* Set or clear the multicast filter for this adaptor.
  1394.    This routine is not state sensitive and need not be SMP locked. */
  1396. static unsigned const ethernet_polynomial = 0x04c11db7U;
  1397. static inline u32 ether_crc(int length, unsigned char *data)
  1398. {
  1399. int crc = -1;
  1401. while (--length >= 0) {
  1402. unsigned char current_octet = *data++;
  1403. int bit;
  1404. for (bit = 0; bit < 8; bit++, current_octet >>= 1)
  1405. crc = (crc << 1) ^
  1406. ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
  1407. }
  1408. return crc;
  1409. }
  1411. /* Bits in RxConfig. */
  1412. enum rx_mode_bits {
  1413. AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
  1414. AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
  1415. };
  1417. static void set_rx_mode(struct net_device *dev)
  1418. {
  1419. struct rtl8129_private *tp = (struct rtl8129_private *)dev->priv;
  1420. long ioaddr = dev->base_addr;
  1421. u32 mc_filter[2];  /* Multicast hash filter */
  1422. int i, rx_mode;
  1424. if (debug > 3)
  1425. printk(KERN_DEBUG"%s:   set_rx_mode(%4.4x) done -- Rx config %8.8x.n",
  1426.    dev->name, dev->flags, inl(ioaddr + RxConfig));
  1428. /* Note: do not reorder, GCC is clever about common statements. */
  1429. if (dev->flags & IFF_PROMISC) {
  1430. /* Unconditionally log net taps. */
  1431. printk(KERN_NOTICE"%s: Promiscuous mode enabled.n", dev->name);
  1432. rx_mode = AcceptBroadcast|AcceptMulticast|AcceptMyPhys|AcceptAllPhys;
  1433. mc_filter[1] = mc_filter[0] = 0xffffffff;
  1434. } else if ((dev->mc_count > multicast_filter_limit)
  1435.    || (dev->flags & IFF_ALLMULTI)) {
  1436. /* Too many to filter perfectly -- accept all multicasts. */
  1437. rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
  1438. mc_filter[1] = mc_filter[0] = 0xffffffff;
  1439. } else {
  1440. struct dev_mc_list *mclist;
  1441. rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
  1442. mc_filter[1] = mc_filter[0] = 0;
  1443. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  1444.  i++, mclist = mclist->next)
  1445. set_bit(ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26, mc_filter);
  1446. }
  1447. /* We can safely update without stopping the chip. */
  1448. outl(tp->rx_config | rx_mode, ioaddr + RxConfig);
  1449. outl(mc_filter[0], ioaddr + MAR0 + 0);
  1450. outl(mc_filter[1], ioaddr + MAR0 + 4);
  1451. return;
  1452. }
  1455. static int rtl_pwr_event(void *dev_instance, int event)
  1456. {
  1457. struct net_device *dev = dev_instance;
  1458. struct rtl8129_private *np = (struct rtl8129_private *)dev->priv;
  1459. long ioaddr = dev->base_addr;
  1461. if (debug > 1)
  1462. printk("%s: Handling power event %d.n", dev->name, event);
  1463. switch(event) {
  1464. case DRV_ATTACH:
  1465. MOD_INC_USE_COUNT;
  1466. break;
  1467. case DRV_SUSPEND:
  1468. netif_device_detach(dev);
  1469. /* Disable interrupts, stop Tx and Rx. */
  1470. outw(0x0000, ioaddr + IntrMask);
  1471. outb(0x00, ioaddr + ChipCmd);
  1472. /* Update the error counts. */
  1473. np->stats.rx_missed_errors += inl(ioaddr + RxMissed);
  1474. outl(0, ioaddr + RxMissed);
  1475. break;
  1476. case DRV_RESUME:
  1477. netif_device_attach(dev);
  1478. rtl_hw_start(dev);
  1479. break;
  1480. case DRV_DETACH: {
  1481. struct net_device **devp, **next;
  1482. if (dev->flags & IFF_UP) {
  1483. dev_close(dev);
  1484. dev->flags &= ~(IFF_UP|IFF_RUNNING);
  1485. }
  1486. unregister_netdev(dev);
  1487. release_region(dev->base_addr, pci_tbl[np->chip_id].io_size);
  1488. #ifndef USE_IO_OPS
  1489. iounmap((char *)dev->base_addr);
  1490. #endif
  1491. for (devp = &root_rtl8129_dev; *devp; devp = next) {
  1492. next = &((struct rtl8129_private *)(*devp)->priv)->next_module;
  1493. if (*devp == dev) {
  1494. *devp = *next;
  1495. break;
  1496. }
  1497. }
  1498. if (np->priv_addr)
  1499. kfree(np->priv_addr);
  1500. kfree(dev);
  1501. MOD_DEC_USE_COUNT;
  1502. break;
  1503. }
  1504. }
  1506. return 0;
  1507. }
  1509. #ifdef CARDBUS
  1511. #include <pcmcia/driver_ops.h>
  1513. static dev_node_t *rtl8139_attach(dev_locator_t *loc)
  1514. {
  1515. struct net_device *dev;
  1516. u16 dev_id;
  1517. u32 pciaddr;
  1518. u8 bus, devfn, irq;
  1519. long hostaddr;
  1520. /* Note: the chip index should match the 8139B pci_tbl[] entry. */
  1521. int chip_idx = 2;
  1523. if (loc->bus != LOC_PCI) return NULL;
  1524. bus = loc->b.pci.bus; devfn = loc->b.pci.devfn;
  1525. printk(KERN_DEBUG "rtl8139_attach(bus %d, function %d)n", bus, devfn);
  1526. #ifdef USE_IO_OPS
  1527. pcibios_read_config_dword(bus, devfn, PCI_BASE_ADDRESS_0, &pciaddr);
  1528. hostaddr = pciaddr & PCI_BASE_ADDRESS_IO_MASK;
  1529. #else
  1530. pcibios_read_config_dword(bus, devfn, PCI_BASE_ADDRESS_1, &pciaddr);
  1531. hostaddr = (long)ioremap(pciaddr & PCI_BASE_ADDRESS_MEM_MASK,
  1532.  pci_tbl[chip_idx].io_size);
  1533. #endif
  1534. pcibios_read_config_byte(bus, devfn, PCI_INTERRUPT_LINE, &irq);
  1535. pcibios_read_config_word(bus, devfn, PCI_DEVICE_ID, &dev_id);
  1536. if (hostaddr == 0 || irq == 0) {
  1537. printk(KERN_ERR "The %s interface at %d/%d was not assigned an %s.n"
  1538.    KERN_ERR "  It will not be activated.n",
  1539.    pci_tbl[chip_idx].name, bus, devfn,
  1540.    hostaddr == 0 ? "address" : "IRQ");
  1541. return NULL;
  1542. }
  1543. dev = rtl8139_probe1(pci_find_slot(bus, devfn), NULL,
  1544.  hostaddr, irq, chip_idx, 0);
  1545. if (dev) {
  1546. dev_node_t *node = kmalloc(sizeof(dev_node_t), GFP_KERNEL);
  1547. strcpy(node->dev_name, dev->name);
  1548. node->major = node->minor = 0;
  1549. node->next = NULL;
  1550. MOD_INC_USE_COUNT;
  1551. return node;
  1552. }
  1553. return NULL;
  1554. }
  1556. static void rtl8139_detach(dev_node_t *node)
  1557. {
  1558. struct net_device **devp, **next;
  1559. printk(KERN_INFO "rtl8139_detach(%s)n", node->dev_name);
  1560. for (devp = &root_rtl8129_dev; *devp; devp = next) {
  1561. next = &((struct rtl8129_private *)(*devp)->priv)->next_module;
  1562. if (strcmp((*devp)->name, node->dev_name) == 0) break;
  1563. }
  1564. if (*devp) {
  1565. struct rtl8129_private *np =
  1566. (struct rtl8129_private *)(*devp)->priv;
  1567. unregister_netdev(*devp);
  1568. release_region((*devp)->base_addr, pci_tbl[np->chip_id].io_size);
  1569. #ifndef USE_IO_OPS
  1570. iounmap((char *)(*devp)->base_addr);
  1571. #endif
  1572. kfree(*devp);
  1573. if (np->priv_addr)
  1574. kfree(np->priv_addr);
  1575. *devp = *next;
  1576. kfree(node);
  1577. MOD_DEC_USE_COUNT;
  1578. }
  1579. }
  1581. struct driver_operations realtek_ops = {
  1582. "realtek_cb",
  1583. rtl8139_attach, /*rtl8139_suspend*/0, /*rtl8139_resume*/0, rtl8139_detach
  1584. };
  1586. #endif  /* Cardbus support */
  1588. int rtl8139_init_module(void)
  1589. {
  1590. if (debug) /* Emit version even if no cards detected. */
  1591. printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
  1592. #ifdef CARDBUS
  1593. register_driver(&realtek_ops);
  1594. return 0;
  1595. #else
  1596. return pci_drv_register(&rtl8139_drv_id, NULL);
  1597. #endif
  1598. }
  1600. void rtl8139_cleanup_module(void)
  1601. {
  1602. struct net_device *next_dev;
  1604. #ifdef CARDBUS
  1605. unregister_driver(&realtek_ops);
  1606. #else
  1607. pci_drv_unregister(&rtl8139_drv_id);
  1608. #endif
  1610. while (root_rtl8129_dev) {
  1611. struct rtl8129_private *np = (void *)(root_rtl8129_dev->priv);
  1612. unregister_netdev(root_rtl8129_dev);
  1613. release_region(root_rtl8129_dev->base_addr,
  1614.    pci_tbl[np->chip_id].io_size);
  1615. #ifndef USE_IO_OPS
  1616. iounmap((char *)(root_rtl8129_dev->base_addr));
  1617. #endif
  1618. next_dev = np->next_module;
  1619. if (np->priv_addr)
  1620. kfree(np->priv_addr);
  1621. kfree(root_rtl8129_dev);
  1622. root_rtl8129_dev = next_dev;
  1623. }
  1624. }
  1626. module_init(rtl8139_init_module);
  1627. module_exit(rtl8139_cleanup_module);
  1629. /*
  1630.  * Local variables:
  1631.  *  compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c rtl8139.c"
  1632.  *  cardbus-compile-command: "gcc -DCARDBUS -DMODULE -Wall -Wstrict-prototypes -O6 -c rtl8139.c -o realtek_cb.o -I/usr/src/pcmcia/include/"
  1633.  *  c-indent-level: 4
  1634.  *  c-basic-offset: 4
  1635.  *  tab-width: 4
  1636.  * End:
  1637.  */