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

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

Linux/Unix编程

开发平台：

Unix_Linux

dl2k.c：源码内容
  1. /*  D-Link DL2000-based Gigabit Ethernet Adapter Linux driver */
  2. /*
  3.     Copyright (c) 2001, 2002 by D-Link Corporation
  4.     Written by Edward Peng.<edward_peng@dlink.com.tw>
  5.     Created 03-May-2001, base on Linux' sundance.c.
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11. */
  12. /*
  13.     Rev Date Description
  14.     ==========================================================================
  15.     0.01 2001/05/03 Created DL2000-based linux driver
  16.     0.02 2001/05/21 Added VLAN and hardware checksum support.
  17.     1.00 2001/06/26 Added jumbo frame support.
  18.     1.01 2001/08/21 Added two parameters, rx_coalesce and rx_timeout.
  19.     1.02 2001/10/08 Supported fiber media.
  20.      Added flow control parameters.
  21.     1.03 2001/10/12 Changed the default media to 1000mbps_fd for 
  22.      the fiber devices.
  23.     1.04 2001/11/08 Fixed Tx stopped when tx very busy.
  24.     1.05 2001/11/22 Fixed Tx stopped when unidirectional tx busy.
  25.     1.06 2001/12/13 Fixed disconnect bug at 10Mbps mode.
  26.      Fixed tx_full flag incorrect.
  27. Added tx_coalesce paramter.
  28.     1.07 2002/01/03 Fixed miscount of RX frame error.
  29.     1.08 2002/01/17 Fixed the multicast bug.
  30.     1.09 2002/03/07 Move rx-poll-now to re-fill loop.
  31.      Added rio_timer() to watch rx buffers. 
  32.     1.10 2002/04/16 Fixed miscount of carrier error.
  33.     1.11 2002/05/23 Added ISR schedule scheme.
  34.      Fixed miscount of rx frame error for DGE-550SX.
  35.      Fixed VLAN bug.
  36.     1.12 2002/06/13 Lock tx_coalesce=1 on 10/100Mbps mode.
  37.  */
  39. #include "dl2k.h"
  41. static char version[] __devinitdata =
  42.     KERN_INFO "D-Link DL2000-based linux driver v1.12 2002/06/13n";
  44. #define MAX_UNITS 8
  45. static int mtu[MAX_UNITS];
  46. static int vlan[MAX_UNITS];
  47. static int jumbo[MAX_UNITS];
  48. static char *media[MAX_UNITS];
  49. static int tx_flow=-1;
  50. static int rx_flow=-1;
  51. static int copy_thresh;
  52. static int rx_coalesce=10; /* Rx frame count each interrupt */
  53. static int rx_timeout=200; /* Rx DMA wait time in 640ns increments */
  54. static int tx_coalesce=16; /* HW xmit count each TxDMAComplete */
  57. MODULE_AUTHOR ("Edward Peng");
  58. MODULE_DESCRIPTION ("D-Link DL2000-based Gigabit Ethernet Adapter");
  59. MODULE_LICENSE("GPL");
  60. MODULE_PARM (mtu, "1-" __MODULE_STRING (MAX_UNITS) "i");
  61. MODULE_PARM (media, "1-" __MODULE_STRING (MAX_UNITS) "s");
  62. MODULE_PARM (vlan, "1-" __MODULE_STRING (MAX_UNITS) "i");
  63. MODULE_PARM (jumbo, "1-" __MODULE_STRING (MAX_UNITS) "i");
  64. MODULE_PARM (tx_flow, "i");
  65. MODULE_PARM (rx_flow, "i");
  66. MODULE_PARM (copy_thresh, "i");
  67. MODULE_PARM (rx_coalesce, "i"); /* Rx frame count each interrupt */
  68. MODULE_PARM (rx_timeout, "i"); /* Rx DMA wait time in 64ns increments */
  69. MODULE_PARM (tx_coalesce, "i"); /* HW xmit count each TxDMAComplete */
  72. /* Enable the default interrupts */
  73. #define DEFAULT_INTR (RxDMAComplete | HostError | IntRequested | TxDMAComplete| 
  74.        UpdateStats | LinkEvent)
  75. #define EnableInt() 
  76. writew(DEFAULT_INTR, ioaddr + IntEnable)
  78. static int max_intrloop = 50;
  79. static int multicast_filter_limit = 0x40;
  81. static int rio_open (struct net_device *dev);
  82. static void rio_timer (unsigned long data);
  83. static void rio_tx_timeout (struct net_device *dev);
  84. static void alloc_list (struct net_device *dev);
  85. static int start_xmit (struct sk_buff *skb, struct net_device *dev);
  86. static void rio_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
  87. static void rio_free_tx (struct net_device *dev, int irq);
  88. static void tx_error (struct net_device *dev, int tx_status);
  89. static int receive_packet (struct net_device *dev);
  90. static void rio_error (struct net_device *dev, int int_status);
  91. static int change_mtu (struct net_device *dev, int new_mtu);
  92. static void set_multicast (struct net_device *dev);
  93. static struct net_device_stats *get_stats (struct net_device *dev);
  94. static int clear_stats (struct net_device *dev);
  95. static int rio_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
  96. static int rio_close (struct net_device *dev);
  97. static int find_miiphy (struct net_device *dev);
  98. static int parse_eeprom (struct net_device *dev);
  99. static int read_eeprom (long ioaddr, int eep_addr);
  100. static int mii_wait_link (struct net_device *dev, int wait);
  101. static int mii_set_media (struct net_device *dev);
  102. static int mii_get_media (struct net_device *dev);
  103. static int mii_set_media_pcs (struct net_device *dev);
  104. static int mii_get_media_pcs (struct net_device *dev);
  105. static int mii_read (struct net_device *dev, int phy_addr, int reg_num);
  106. static int mii_write (struct net_device *dev, int phy_addr, int reg_num,
  107.       u16 data);
  109. static int __devinit
  110. rio_probe1 (struct pci_dev *pdev, const struct pci_device_id *ent)
  111. {
  112. struct net_device *dev;
  113. struct netdev_private *np;
  114. static int card_idx;
  115. int chip_idx = ent->driver_data;
  116. int err, irq;
  117. long ioaddr;
  118. static int version_printed;
  119. void *ring_space;
  120. dma_addr_t ring_dma;
  122. if (!version_printed++)
  123. printk ("%s", version);
  125. err = pci_enable_device (pdev);
  126. if (err)
  127. return err;
  129. irq = pdev->irq;
  130. err = pci_request_regions (pdev, "dl2k");
  131. if (err)
  132. goto err_out_disable;
  134. pci_set_master (pdev);
  135. dev = alloc_etherdev (sizeof (*np));
  136. if (!dev) {
  137. err = -ENOMEM;
  138. goto err_out_res;
  139. }
  140. SET_MODULE_OWNER (dev);
  142. #ifdef MEM_MAPPING
  143. ioaddr = pci_resource_start (pdev, 1);
  144. ioaddr = (long) ioremap (ioaddr, RIO_IO_SIZE);
  145. if (!ioaddr) {
  146. err = -ENOMEM;
  147. goto err_out_dev;
  148. }
  149. #else
  150. ioaddr = pci_resource_start (pdev, 0);
  151. #endif
  152. dev->base_addr = ioaddr;
  153. dev->irq = irq;
  154. np = dev->priv;
  155. np->chip_id = chip_idx;
  156. np->pdev = pdev;
  157. spin_lock_init (&np->tx_lock);
  158. spin_lock_init (&np->rx_lock);
  160. /* Parse manual configuration */
  161. np->an_enable = 1;
  162. np->tx_coalesce = 1;
  163. if (card_idx < MAX_UNITS) {
  164. if (media[card_idx] != NULL) {
  165. np->an_enable = 0;
  166. if (strcmp (media[card_idx], "auto") == 0 ||
  167.     strcmp (media[card_idx], "autosense") == 0 || 
  168.     strcmp (media[card_idx], "0") == 0 ) {
  169. np->an_enable = 2; 
  170. } else if (strcmp (media[card_idx], "100mbps_fd") == 0 ||
  171.     strcmp (media[card_idx], "4") == 0) {
  172. np->speed = 100;
  173. np->full_duplex = 1;
  174. } else if (strcmp (media[card_idx], "100mbps_hd") == 0
  175.    || strcmp (media[card_idx], "3") == 0) {
  176. np->speed = 100;
  177. np->full_duplex = 0;
  178. } else if (strcmp (media[card_idx], "10mbps_fd") == 0 ||
  179.    strcmp (media[card_idx], "2") == 0) {
  180. np->speed = 10;
  181. np->full_duplex = 1;
  182. } else if (strcmp (media[card_idx], "10mbps_hd") == 0 ||
  183.    strcmp (media[card_idx], "1") == 0) {
  184. np->speed = 10;
  185. np->full_duplex = 0;
  186. } else if (strcmp (media[card_idx], "1000mbps_fd") == 0 ||
  187.  strcmp (media[card_idx], "6") == 0) {
  188. np->speed=1000;
  189. np->full_duplex=1;
  190. } else if (strcmp (media[card_idx], "1000mbps_hd") == 0 ||
  191.  strcmp (media[card_idx], "5") == 0) {
  192. np->speed = 1000;
  193. np->full_duplex = 0;
  194. } else {
  195. np->an_enable = 1;
  196. }
  197. }
  198. if (jumbo[card_idx] != 0) {
  199. np->jumbo = 1;
  200. dev->mtu = MAX_JUMBO;
  201. } else {
  202. np->jumbo = 0;
  203. if (mtu[card_idx] > 0 && mtu[card_idx] < PACKET_SIZE)
  204. dev->mtu = mtu[card_idx];
  205. }
  206. np->vlan = (vlan[card_idx] > 0 && vlan[card_idx] < 4096) ?
  207.     vlan[card_idx] : 0;
  208. if (rx_coalesce > 0 && rx_timeout > 0) {
  209. np->rx_coalesce = rx_coalesce;
  210. np->rx_timeout = rx_timeout;
  211. np->coalesce = 1;
  212. }
  213. np->tx_flow = (tx_flow == 0) ? 0 : 1;
  214. np->rx_flow = (rx_flow == 0) ? 0 : 1;
  216. if (tx_coalesce < 1)
  217. tx_coalesce = 1;
  218. else if (tx_coalesce > TX_RING_SIZE-1)
  219. tx_coalesce = TX_RING_SIZE - 1;
  220. }
  221. dev->open = &rio_open;
  222. dev->hard_start_xmit = &start_xmit;
  223. dev->stop = &rio_close;
  224. dev->get_stats = &get_stats;
  225. dev->set_multicast_list = &set_multicast;
  226. dev->do_ioctl = &rio_ioctl;
  227. dev->tx_timeout = &rio_tx_timeout;
  228. dev->watchdog_timeo = TX_TIMEOUT;
  229. dev->change_mtu = &change_mtu;
  230. #if 0
  231. dev->features = NETIF_F_IP_CSUM;
  232. #endif
  233. pci_set_drvdata (pdev, dev);
  235. ring_space = pci_alloc_consistent (pdev, TX_TOTAL_SIZE, &ring_dma);
  236. if (!ring_space)
  237. goto err_out_iounmap;
  238. np->tx_ring = (struct netdev_desc *) ring_space;
  239. np->tx_ring_dma = ring_dma;
  241. ring_space = pci_alloc_consistent (pdev, RX_TOTAL_SIZE, &ring_dma);
  242. if (!ring_space)
  243. goto err_out_unmap_tx;
  244. np->rx_ring = (struct netdev_desc *) ring_space;
  245. np->rx_ring_dma = ring_dma;
  247. /* Parse eeprom data */
  248. parse_eeprom (dev);
  250. /* Find PHY address */
  251. err = find_miiphy (dev);
  252. if (err)
  253. goto err_out_unmap_rx;
  255. /* Fiber device? */
  256. np->phy_media = (readw(ioaddr + ASICCtrl) & PhyMedia) ? 1 : 0;
  257. np->link_status = 0;
  258. /* Set media and reset PHY */
  259. if (np->phy_media) {
  260. /* default 1000mbps_fd for fiber deivices */
  261. if (np->an_enable == 1) {
  262. np->an_enable = 0;
  263. np->speed = 1000;
  264. np->full_duplex = 1;
  265. } else if (np->an_enable == 2) {
  266. np->an_enable = 1;
  267. }
  268. mii_set_media_pcs (dev);
  269. } else {
  270. /* Auto-Negotiation is mandatory for 1000BASE-T,
  271.    IEEE 802.3ab Annex 28D page 14 */
  272. if (np->speed == 1000)
  273. np->an_enable = 1;
  274. mii_set_media (dev);
  275. }
  276. pci_read_config_byte(pdev, PCI_REVISION_ID, &np->pci_rev_id);
  278. /* Reset all logic functions */
  279. writew (GlobalReset | DMAReset | FIFOReset | NetworkReset | HostReset,
  280. ioaddr + ASICCtrl + 2);
  282. err = register_netdev (dev);
  283. if (err)
  284. goto err_out_unmap_rx;
  286. card_idx++;
  288. printk (KERN_INFO "%s: %s, %02x:%02x:%02x:%02x:%02x:%02x, IRQ %dn",
  289. dev->name, np->name,
  290. dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
  291. dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5], irq);
  292. if (tx_coalesce > 1)
  293. printk(KERN_INFO "tx_coalesce:t%d packetsn", 
  294. tx_coalesce);
  295. if (np->coalesce)
  296. printk(KERN_INFO "rx_coalesce:t%d packetsn"
  297.        KERN_INFO "rx_timeout: t%d nsn", 
  298. np->rx_coalesce, np->rx_timeout*640);
  299. if (np->vlan)
  300. printk(KERN_INFO "vlan(id):t%dn", np->vlan);
  301. return 0;
  303.       err_out_unmap_rx:
  304. pci_free_consistent (pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
  305.       err_out_unmap_tx:
  306. pci_free_consistent (pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
  307.       err_out_iounmap:
  308. #ifdef MEM_MAPPING
  309. iounmap ((void *) ioaddr);
  311.       err_out_dev:
  312. #endif
  313. kfree (dev);
  315.       err_out_res:
  316. pci_release_regions (pdev);
  318.       err_out_disable:
  319. pci_disable_device (pdev);
  320. return err;
  321. }
  323. int
  324. find_miiphy (struct net_device *dev)
  325. {
  326. int i, phy_found = 0;
  327. struct netdev_private *np;
  328. long ioaddr;
  329. np = dev->priv;
  330. ioaddr = dev->base_addr;
  331. np->phy_addr = 1;
  333. for (i = 31; i >= 0; i--) {
  334. int mii_status = mii_read (dev, i, 1);
  335. if (mii_status != 0xffff && mii_status != 0x0000) {
  336. np->phy_addr = i;
  337. phy_found++;
  338. }
  339. }
  340. if (!phy_found) {
  341. printk (KERN_ERR "%s: No MII PHY found!n", dev->name);
  342. return -ENODEV;
  343. }
  344. return 0;
  345. }
  347. int
  348. parse_eeprom (struct net_device *dev)
  349. {
  350. int i, j;
  351. long ioaddr = dev->base_addr;
  352. u8 sromdata[256];
  353. u8 *psib;
  354. u32 crc;
  355. PSROM_t psrom = (PSROM_t) sromdata;
  356. struct netdev_private *np = dev->priv;
  358. int cid, next;
  360. /* Read eeprom */
  361. for (i = 0; i < 128; i++) {
  362. ((u16 *) sromdata)[i] = le16_to_cpu (read_eeprom (ioaddr, i));
  363. }
  365. /* Check CRC */
  366. crc = ~ether_crc_le (256 - 4, sromdata);
  367. if (psrom->crc != crc) {
  368. printk (KERN_ERR "%s: EEPROM data CRC error.n", dev->name);
  369. return -1;
  370. }
  372. /* Set MAC address */
  373. for (i = 0; i < 6; i++)
  374. dev->dev_addr[i] = psrom->mac_addr[i];
  376. /* Parse Software Infomation Block */
  377. i = 0x30;
  378. psib = (u8 *) sromdata;
  379. do {
  380. cid = psib[i++];
  381. next = psib[i++];
  382. if ((cid == 0 && next == 0) || (cid == 0xff && next == 0xff)) {
  383. printk (KERN_ERR "Cell data errorn");
  384. return -1;
  385. }
  386. switch (cid) {
  387. case 0: /* Format version */
  388. break;
  389. case 1: /* End of cell */
  390. return 0;
  391. case 2: /* Duplex Polarity */
  392. np->duplex_polarity = psib[i];
  393. writeb (readb (ioaddr + PhyCtrl) | psib[i],
  394. ioaddr + PhyCtrl);
  395. break;
  396. case 3: /* Wake Polarity */
  397. np->wake_polarity = psib[i];
  398. break;
  399. case 9: /* Adapter description */
  400. j = (next - i > 255) ? 255 : next - i;
  401. memcpy (np->name, &(psib[i]), j);
  402. break;
  403. case 4:
  404. case 5:
  405. case 6:
  406. case 7:
  407. case 8: /* Reversed */
  408. break;
  409. default: /* Unknown cell */
  410. return -1;
  411. }
  412. i = next;
  413. } while (1);
  415. return 0;
  416. }
  418. static int
  419. rio_open (struct net_device *dev)
  420. {
  421. struct netdev_private *np = dev->priv;
  422. long ioaddr = dev->base_addr;
  423. int i;
  425. i = request_irq (dev->irq, &rio_interrupt, SA_SHIRQ, dev->name, dev);
  426. if (i)
  427. return i;
  428. /* DebugCtrl bit 4, 5, 9 must set */
  429. writel (readl (ioaddr + DebugCtrl) | 0x0230, ioaddr + DebugCtrl);
  431. /* Jumbo frame */
  432. if (np->jumbo != 0)
  433. writew (MAX_JUMBO+14, ioaddr + MaxFrameSize);
  435. alloc_list (dev);
  437. /* Get station address */
  438. for (i = 0; i < 6; i++)
  439. writeb (dev->dev_addr[i], ioaddr + StationAddr0 + i);
  441. set_multicast (dev);
  442. if (np->coalesce) {
  443. writel (np->rx_coalesce | np->rx_timeout << 16,
  444. ioaddr + RxDMAIntCtrl);
  445. }
  446. /* Set RIO to poll every N*320nsec. */
  447. writeb (0x20, ioaddr + RxDMAPollPeriod);
  448. writeb (0xff, ioaddr + TxDMAPollPeriod);
  449. writeb (0x30, ioaddr + RxDMABurstThresh);
  450. writeb (0x30, ioaddr + RxDMAUrgentThresh);
  452. /* clear statistics */
  453. clear_stats (dev);
  455. /* VLAN supported */
  456. if (np->vlan) {
  457. /* priority field in RxDMAIntCtrl  */
  458. writel (readl(ioaddr + RxDMAIntCtrl) | 0x7 << 10, 
  459. ioaddr + RxDMAIntCtrl);
  460. /* VLANId */
  461. writew (np->vlan, ioaddr + VLANId);
  462. /* Length/Type should be 0x8100 */
  463. writel (0x8100 << 16 | np->vlan, ioaddr + VLANTag);
  464. /* Enable AutoVLANuntagging, but disable AutoVLANtagging.
  465.    VLAN information tagged by TFC' VID, CFI fields. */
  466. writel (readl (ioaddr + MACCtrl) | AutoVLANuntagging,
  467. ioaddr + MACCtrl);
  468. }
  470. /* Enable default interrupts */
  471. EnableInt ();
  473. init_timer (&np->timer);
  474. np->timer.expires = jiffies + 1*HZ;
  475. np->timer.data = (unsigned long) dev;
  476. np->timer.function = &rio_timer;
  477. add_timer (&np->timer);
  479. /* Start Tx/Rx */
  480. writel (readl (ioaddr + MACCtrl) | StatsEnable | RxEnable | TxEnable, 
  481. ioaddr + MACCtrl);
  483. netif_start_queue (dev);
  484. return 0;
  485. }
  487. static void 
  488. rio_timer (unsigned long data)
  489. {
  490. struct net_device *dev = (struct net_device *)data;
  491. struct netdev_private *np = dev->priv;
  492. unsigned int entry;
  493. int next_tick = 1*HZ;
  494. unsigned long flags;
  496. spin_lock_irqsave(&np->rx_lock, flags);
  497. /* Recover rx ring exhausted error */
  498. if (np->cur_rx - np->old_rx >= RX_RING_SIZE) {
  499. printk(KERN_INFO "Try to recover rx ring exhausted...n");
  500. /* Re-allocate skbuffs to fill the descriptor ring */
  501. for (; np->cur_rx - np->old_rx > 0; np->old_rx++) {
  502. struct sk_buff *skb;
  503. entry = np->old_rx % RX_RING_SIZE;
  504. /* Dropped packets don't need to re-allocate */
  505. if (np->rx_skbuff[entry] == NULL) {
  506. skb = dev_alloc_skb (np->rx_buf_sz);
  507. if (skb == NULL) {
  508. np->rx_ring[entry].fraginfo = 0;
  509. printk (KERN_INFO
  510. "%s: Still unable to re-allocate Rx skbuff.#%dn",
  511. dev->name, entry);
  512. break;
  513. }
  514. np->rx_skbuff[entry] = skb;
  515. skb->dev = dev;
  516. /* 16 byte align the IP header */
  517. skb_reserve (skb, 2);
  518. np->rx_ring[entry].fraginfo =
  519.     cpu_to_le64 (pci_map_single
  520.  (np->pdev, skb->tail, np->rx_buf_sz,
  521.   PCI_DMA_FROMDEVICE));
  522. }
  523. np->rx_ring[entry].fraginfo |=
  524.     cpu_to_le64 (np->rx_buf_sz) << 48;
  525. np->rx_ring[entry].status = 0;
  526. } /* end for */
  527. } /* end if */
  528. spin_unlock_irqrestore (&np->rx_lock, flags);
  529. np->timer.expires = jiffies + next_tick;
  530. add_timer(&np->timer);
  531. }
  533. static void
  534. rio_tx_timeout (struct net_device *dev)
  535. {
  536. long ioaddr = dev->base_addr;
  538. printk (KERN_INFO "%s: Tx timed out (%4.4x), is buffer full?n",
  539. dev->name, readl (ioaddr + TxStatus));
  540. rio_free_tx(dev, 0);
  541. dev->if_port = 0;
  542. dev->trans_start = jiffies;
  543. }
  545.  /* allocate and initialize Tx and Rx descriptors */
  546. static void
  547. alloc_list (struct net_device *dev)
  548. {
  549. struct netdev_private *np = dev->priv;
  550. int i;
  552. np->cur_rx = np->cur_tx = 0;
  553. np->old_rx = np->old_tx = 0;
  554. np->rx_buf_sz = (dev->mtu <= 1500 ? PACKET_SIZE : dev->mtu + 32);
  556. /* Initialize Tx descriptors, TFDListPtr leaves in start_xmit(). */
  557. for (i = 0; i < TX_RING_SIZE; i++) {
  558. np->tx_skbuff[i] = 0;
  559. np->tx_ring[i].status = cpu_to_le64 (TFDDone);
  560. np->tx_ring[i].next_desc = cpu_to_le64 (np->tx_ring_dma +
  561.       ((i+1)%TX_RING_SIZE) *
  562.       sizeof (struct netdev_desc));
  563. }
  565. /* Initialize Rx descriptors */
  566. for (i = 0; i < RX_RING_SIZE; i++) {
  567. np->rx_ring[i].next_desc = cpu_to_le64 (np->rx_ring_dma +
  568. ((i + 1) % RX_RING_SIZE) *
  569. sizeof (struct netdev_desc));
  570. np->rx_ring[i].status = 0;
  571. np->rx_ring[i].fraginfo = 0;
  572. np->rx_skbuff[i] = 0;
  573. }
  575. /* Allocate the rx buffers */
  576. for (i = 0; i < RX_RING_SIZE; i++) {
  577. /* Allocated fixed size of skbuff */
  578. struct sk_buff *skb = dev_alloc_skb (np->rx_buf_sz);
  579. np->rx_skbuff[i] = skb;
  580. if (skb == NULL) {
  581. printk (KERN_ERR
  582. "%s: alloc_list: allocate Rx buffer error! ",
  583. dev->name);
  584. break;
  585. }
  586. skb->dev = dev; /* Mark as being used by this device. */
  587. skb_reserve (skb, 2); /* 16 byte align the IP header. */
  588. /* Rubicon now supports 40 bits of addressing space. */
  589. np->rx_ring[i].fraginfo =
  590.     cpu_to_le64 ( pci_map_single (
  591.     np->pdev, skb->tail, np->rx_buf_sz,
  592.   PCI_DMA_FROMDEVICE));
  593. np->rx_ring[i].fraginfo |= cpu_to_le64 (np->rx_buf_sz) << 48;
  594. }
  596. /* Set RFDListPtr */
  597. writel (cpu_to_le32 (np->rx_ring_dma), dev->base_addr + RFDListPtr0);
  598. writel (0, dev->base_addr + RFDListPtr1);
  600. return;
  601. }
  603. static int
  604. start_xmit (struct sk_buff *skb, struct net_device *dev)
  605. {
  606. struct netdev_private *np = dev->priv;
  607. struct netdev_desc *txdesc;
  608. unsigned entry;
  609. u32 ioaddr;
  610. u64 tfc_vlan_tag = 0;
  612. if (np->link_status == 0) { /* Link Down */
  613. dev_kfree_skb(skb);
  614. return 0;
  615. }
  616. ioaddr = dev->base_addr;
  617. entry = np->cur_tx % TX_RING_SIZE;
  618. np->tx_skbuff[entry] = skb;
  619. txdesc = &np->tx_ring[entry];
  621. #if 0
  622. if (skb->ip_summed == CHECKSUM_HW) {
  623. txdesc->status |=
  624.     cpu_to_le64 (TCPChecksumEnable | UDPChecksumEnable |
  625.  IPChecksumEnable);
  626. }
  627. #endif
  628. if (np->vlan) {
  629. txdesc->status |=
  630.     cpu_to_le64 (VLANTagInsert) |
  631.     (cpu_to_le64 (np->vlan) << 32) |
  632.     (cpu_to_le64 (skb->priority) << 45);
  633. }
  634. txdesc->fraginfo = cpu_to_le64 (pci_map_single (np->pdev, skb->data,
  635. skb->len,
  636. PCI_DMA_TODEVICE));
  637. txdesc->fraginfo |= cpu_to_le64 (skb->len) << 48;
  639. /* DL2K bug: DMA fails to get next descriptor ptr in 10Mbps mode
  640.  * Work around: Always use 1 descriptor in 10Mbps mode */
  641. if (entry % np->tx_coalesce == 0 || np->speed == 10)
  642. txdesc->status = cpu_to_le64 (entry | tfc_vlan_tag |
  643.       WordAlignDisable | 
  644.       TxDMAIndicate |
  645.       (1 << FragCountShift));
  646. else
  647. txdesc->status = cpu_to_le64 (entry | tfc_vlan_tag |
  648.       WordAlignDisable | 
  649.       (1 << FragCountShift));
  651. /* TxDMAPollNow */
  652. writel (readl (ioaddr + DMACtrl) | 0x00001000, ioaddr + DMACtrl);
  653. /* Schedule ISR */
  654. writel(10000, ioaddr + CountDown);
  655. np->cur_tx = (np->cur_tx + 1) % TX_RING_SIZE;
  656. if ((np->cur_tx - np->old_tx + TX_RING_SIZE) % TX_RING_SIZE
  657. < TX_QUEUE_LEN - 1 && np->speed != 10) {
  658. /* do nothing */
  659. } else if (!netif_queue_stopped(dev)) {
  660. netif_stop_queue (dev);
  661. }
  663. /* The first TFDListPtr */
  664. if (readl (dev->base_addr + TFDListPtr0) == 0) {
  665. writel (np->tx_ring_dma + entry * sizeof (struct netdev_desc),
  666. dev->base_addr + TFDListPtr0);
  667. writel (0, dev->base_addr + TFDListPtr1);
  668. }
  670. /* NETDEV WATCHDOG timer */
  671. dev->trans_start = jiffies;
  672. return 0;
  673. }
  675. static void
  676. rio_interrupt (int irq, void *dev_instance, struct pt_regs *rgs)
  677. {
  678. struct net_device *dev = dev_instance;
  679. struct netdev_private *np;
  680. unsigned int_status;
  681. long ioaddr;
  682. int cnt = max_intrloop;
  684. ioaddr = dev->base_addr;
  685. np = dev->priv;
  686. while (1) {
  687. int_status = readw (ioaddr + IntStatus); 
  688. writew (int_status, ioaddr + IntStatus);
  689. int_status &= DEFAULT_INTR;
  690. if (int_status == 0 || --cnt < 0)
  691. break;
  692. /* Processing received packets */
  693. if (int_status & RxDMAComplete)
  694. receive_packet (dev);
  695. /* TxDMAComplete interrupt */
  696. if ((int_status & (TxDMAComplete|IntRequested))) {
  697. int tx_status;
  698. tx_status = readl (ioaddr + TxStatus);
  699. if (tx_status & 0x01)
  700. tx_error (dev, tx_status);
  701. /* Free used tx skbuffs */
  702. rio_free_tx (dev, 1);
  703. }
  705. /* Handle uncommon events */
  706. if (int_status &
  707.     (HostError | LinkEvent | UpdateStats))
  708. rio_error (dev, int_status);
  709. }
  710. if (np->cur_tx != np->old_tx)
  711. writel (100, ioaddr + CountDown);
  712. }
  714. static void 
  715. rio_free_tx (struct net_device *dev, int irq) 
  716. {
  717. struct netdev_private *np = (struct netdev_private *) dev->priv;
  718. int entry = np->old_tx % TX_RING_SIZE;
  719. int tx_use = 0;
  720. long flag = 0;
  722. if (irq)
  723. spin_lock_irqsave(&np->tx_lock, flag);
  724. else
  725. spin_lock(&np->tx_lock);
  726. /* Free used tx skbuffs */
  727. while (entry != np->cur_tx) {
  728. struct sk_buff *skb;
  730. if (!(np->tx_ring[entry].status & TFDDone))
  731. break;
  732. skb = np->tx_skbuff[entry];
  733. pci_unmap_single (np->pdev,
  734.   np->tx_ring[entry].fraginfo,
  735.   skb->len, PCI_DMA_TODEVICE);
  736. if (irq)
  737. dev_kfree_skb_irq (skb);
  738. else
  739. dev_kfree_skb (skb);
  741. np->tx_skbuff[entry] = 0;
  742. entry = (entry + 1) % TX_RING_SIZE;
  743. tx_use++;
  744. }
  745. if (irq)
  746. spin_unlock_irqrestore(&np->tx_lock, flag);
  747. else
  748. spin_unlock(&np->tx_lock);
  749. np->old_tx = entry;
  751. /* If the ring is no longer full, clear tx_full and 
  752.    call netif_wake_queue() */
  754. if (netif_queue_stopped(dev) &&
  755.     ((np->cur_tx - np->old_tx + TX_RING_SIZE) % TX_RING_SIZE 
  756.     < TX_QUEUE_LEN - 1 || np->speed == 10)) {
  757. netif_wake_queue (dev);
  758. }
  759. }
  761. static void
  762. tx_error (struct net_device *dev, int tx_status)
  763. {
  764. struct netdev_private *np;
  765. long ioaddr = dev->base_addr;
  766. int frame_id;
  767. int i;
  769. np = dev->priv;
  771. frame_id = (tx_status & 0xffff0000);
  772. printk (KERN_ERR "%s: Transmit error, TxStatus %4.4x, FrameId %d.n",
  773. dev->name, tx_status, frame_id);
  774. np->stats.tx_errors++;
  775. /* Ttransmit Underrun */
  776. if (tx_status & 0x10) {
  777. np->stats.tx_fifo_errors++;
  778. writew (readw (ioaddr + TxStartThresh) + 0x10,
  779. ioaddr + TxStartThresh);
  780. /* Transmit Underrun need to set TxReset, DMARest, FIFOReset */
  781. writew (TxReset | DMAReset | FIFOReset | NetworkReset,
  782. ioaddr + ASICCtrl + 2);
  783. /* Wait for ResetBusy bit clear */
  784. for (i = 50; i > 0; i--) {
  785. if ((readw (ioaddr + ASICCtrl + 2) & ResetBusy) == 0)
  786. break;
  787. mdelay (1);
  788. }
  789. rio_free_tx (dev, 1);
  790. /* Reset TFDListPtr */
  791. writel (np->tx_ring_dma +
  792. np->old_tx * sizeof (struct netdev_desc),
  793. dev->base_addr + TFDListPtr0);
  794. writel (0, dev->base_addr + TFDListPtr1);
  796. /* Let TxStartThresh stay default value */
  797. }
  798. /* Late Collision */
  799. if (tx_status & 0x04) {
  800. np->stats.tx_fifo_errors++;
  801. /* TxReset and clear FIFO */
  802. writew (TxReset | FIFOReset, ioaddr + ASICCtrl + 2);
  803. /* Wait reset done */
  804. for (i = 50; i > 0; i--) {
  805. if ((readw (ioaddr + ASICCtrl + 2) & ResetBusy) == 0)
  806. break;
  807. mdelay (1);
  808. }
  809. /* Let TxStartThresh stay default value */
  810. }
  811. /* Maximum Collisions */
  812. if (tx_status & 0x08) 
  813. np->stats.collisions++;
  814. /* Restart the Tx */
  815. writel (readw (dev->base_addr + MACCtrl) | TxEnable, ioaddr + MACCtrl);
  816. }
  818. static int
  819. receive_packet (struct net_device *dev)
  820. {
  821. struct netdev_private *np = (struct netdev_private *) dev->priv;
  822. int entry = np->cur_rx % RX_RING_SIZE;
  823. int cnt = 30;
  825. /* If RFDDone, FrameStart and FrameEnd set, there is a new packet in. */
  826. while (1) {
  827. struct netdev_desc *desc = &np->rx_ring[entry];
  828. int pkt_len;
  829. u64 frame_status;
  831. if (!(desc->status & RFDDone) ||
  832.     !(desc->status & FrameStart) || !(desc->status & FrameEnd))
  833. break;
  835. /* Chip omits the CRC. */
  836. pkt_len = le64_to_cpu (desc->status & 0xffff);
  837. frame_status = le64_to_cpu (desc->status);
  838. if (--cnt < 0)
  839. break;
  840. pci_dma_sync_single (np->pdev, desc->fraginfo, np->rx_buf_sz,
  841.      PCI_DMA_FROMDEVICE);
  842. /* Update rx error statistics, drop packet. */
  843. if (frame_status & RFS_Errors) {
  844. np->stats.rx_errors++;
  845. if (frame_status & (RxRuntFrame | RxLengthError))
  846. np->stats.rx_length_errors++;
  847. if (frame_status & RxFCSError)
  848. np->stats.rx_crc_errors++;
  849. if (frame_status & RxAlignmentError && np->speed != 1000)
  850. np->stats.rx_frame_errors++;
  851. if (frame_status & RxFIFOOverrun)
  852.   np->stats.rx_fifo_errors++;
  853. } else {
  854. struct sk_buff *skb;
  856. /* Small skbuffs for short packets */
  857. if (pkt_len > copy_thresh) {
  858. pci_unmap_single (np->pdev, desc->fraginfo,
  859.   np->rx_buf_sz,
  860.   PCI_DMA_FROMDEVICE);
  861. skb_put (skb = np->rx_skbuff[entry], pkt_len);
  862. np->rx_skbuff[entry] = NULL;
  863. } else if ((skb = dev_alloc_skb (pkt_len + 2)) != NULL) {
  864. skb->dev = dev;
  865. /* 16 byte align the IP header */
  866. skb_reserve (skb, 2);
  867. eth_copy_and_sum (skb,
  868.   np->rx_skbuff[entry]->tail,
  869.   pkt_len, 0);
  870. skb_put (skb, pkt_len);
  871. }
  872. skb->protocol = eth_type_trans (skb, dev);
  873. #if 0
  874. /* Checksum done by hw, but csum value unavailable. */
  875. if (np->pci_rev_id >= 0x0c && 
  876. !(frame_status & (TCPError | UDPError | IPError))) {
  877. skb->ip_summed = CHECKSUM_UNNECESSARY;
  878. } 
  879. #endif
  880. netif_rx (skb);
  881. dev->last_rx = jiffies;
  882. }
  883. entry = (entry + 1) % RX_RING_SIZE;
  884. }
  885. spin_lock(&np->rx_lock);
  886. np->cur_rx = entry;
  887. /* Re-allocate skbuffs to fill the descriptor ring */
  888. entry = np->old_rx;
  889. while (entry != np->cur_rx) {
  890. struct sk_buff *skb;
  891. /* Dropped packets don't need to re-allocate */
  892. if (np->rx_skbuff[entry] == NULL) {
  893. skb = dev_alloc_skb (np->rx_buf_sz);
  894. if (skb == NULL) {
  895. np->rx_ring[entry].fraginfo = 0;
  896. printk (KERN_INFO
  897. "%s: receive_packet: "
  898. "Unable to re-allocate Rx skbuff.#%dn",
  899. dev->name, entry);
  900. break;
  901. }
  902. np->rx_skbuff[entry] = skb;
  903. skb->dev = dev;
  904. /* 16 byte align the IP header */
  905. skb_reserve (skb, 2);
  906. np->rx_ring[entry].fraginfo =
  907.     cpu_to_le64 (pci_map_single
  908.  (np->pdev, skb->tail, np->rx_buf_sz,
  909.   PCI_DMA_FROMDEVICE));
  910. }
  911. np->rx_ring[entry].fraginfo |=
  912.     cpu_to_le64 (np->rx_buf_sz) << 48;
  913. np->rx_ring[entry].status = 0;
  914. entry = (entry + 1) % RX_RING_SIZE;
  915. }
  916. np->old_rx = entry;
  917. spin_unlock(&np->rx_lock);
  918. return 0;
  919. }
  921. static void
  922. rio_error (struct net_device *dev, int int_status)
  923. {
  924. long ioaddr = dev->base_addr;
  925. struct netdev_private *np = dev->priv;
  926. u16 macctrl;
  928. /* Link change event */
  929. if (int_status & LinkEvent) {
  930. if (mii_wait_link (dev, 10) == 0) {
  931. printk (KERN_INFO "%s: Link upn", dev->name);
  932. if (np->phy_media)
  933. mii_get_media_pcs (dev);
  934. else
  935. mii_get_media (dev);
  936. if (np->speed == 1000)
  937. np->tx_coalesce = tx_coalesce;
  938. else 
  939. np->tx_coalesce = 1;
  940. macctrl = 0;
  941. macctrl |= (np->vlan) ? AutoVLANuntagging : 0;
  942. macctrl |= (np->full_duplex) ? DuplexSelect : 0;
  943. macctrl |= (np->tx_flow) ? 
  944. TxFlowControlEnable : 0;
  945. macctrl |= (np->rx_flow) ? 
  946. RxFlowControlEnable : 0;
  947. writew(macctrl, ioaddr + MACCtrl);
  948. np->link_status = 1;
  949. netif_carrier_on(dev);
  950. } else {
  951. printk (KERN_INFO "%s: Link offn", dev->name);
  952. np->link_status = 0;
  953. netif_carrier_off(dev);
  954. }
  955. }
  957. /* UpdateStats statistics registers */
  958. if (int_status & UpdateStats) {
  959. get_stats (dev);
  960. }
  962. /* PCI Error, a catastronphic error related to the bus interface 
  963.    occurs, set GlobalReset and HostReset to reset. */
  964. if (int_status & HostError) {
  965. printk (KERN_ERR "%s: HostError! IntStatus %4.4x.n",
  966. dev->name, int_status);
  967. writew (GlobalReset | HostReset, ioaddr + ASICCtrl + 2);
  968. mdelay (500);
  969. }
  970. }
  972. static struct net_device_stats *
  973. get_stats (struct net_device *dev)
  974. {
  975. long ioaddr = dev->base_addr;
  976. struct netdev_private *np = dev->priv;
  977. int i;
  978. unsigned int stat_reg;
  980. /* All statistics registers need to be acknowledged,
  981.    else statistic overflow could cause problems */
  983. np->stats.rx_packets += readl (ioaddr + FramesRcvOk);
  984. np->stats.tx_packets += readl (ioaddr + FramesXmtOk);
  985. np->stats.rx_bytes += readl (ioaddr + OctetRcvOk);
  986. np->stats.tx_bytes += readl (ioaddr + OctetXmtOk);
  988. np->stats.multicast = readl (ioaddr + McstFramesRcvdOk);
  989. np->stats.collisions += readl (ioaddr + SingleColFrames) 
  990.      +  readl (ioaddr + MultiColFrames); 
  992. /* detailed tx errors */
  993. stat_reg = readw (ioaddr + FramesAbortXSColls);
  994. np->stats.tx_aborted_errors += stat_reg;
  995. np->stats.tx_errors += stat_reg;
  997. stat_reg = readw (ioaddr + CarrierSenseErrors);
  998. np->stats.tx_carrier_errors += stat_reg;
  999. np->stats.tx_errors += stat_reg;
  1001. /* Clear all other statistic register. */
  1002. readl (ioaddr + McstOctetXmtOk);
  1003. readw (ioaddr + BcstFramesXmtdOk);
  1004. readl (ioaddr + McstFramesXmtdOk);
  1005. readw (ioaddr + BcstFramesRcvdOk);
  1006. readw (ioaddr + MacControlFramesRcvd);
  1007. readw (ioaddr + FrameTooLongErrors);
  1008. readw (ioaddr + InRangeLengthErrors);
  1009. readw (ioaddr + FramesCheckSeqErrors);
  1010. readw (ioaddr + FramesLostRxErrors);
  1011. readl (ioaddr + McstOctetXmtOk);
  1012. readl (ioaddr + BcstOctetXmtOk);
  1013. readl (ioaddr + McstFramesXmtdOk);
  1014. readl (ioaddr + FramesWDeferredXmt);
  1015. readl (ioaddr + LateCollisions);
  1016. readw (ioaddr + BcstFramesXmtdOk);
  1017. readw (ioaddr + MacControlFramesXmtd);
  1018. readw (ioaddr + FramesWEXDeferal);
  1021. for (i = 0x100; i <= 0x150; i += 4)
  1022. readl (ioaddr + i);
  1023. readw (ioaddr + TxJumboFrames);
  1024. readw (ioaddr + RxJumboFrames);
  1025. readw (ioaddr + TCPCheckSumErrors);
  1026. readw (ioaddr + UDPCheckSumErrors);
  1027. readw (ioaddr + IPCheckSumErrors);
  1028. return &np->stats;
  1029. }
  1031. static int
  1032. clear_stats (struct net_device *dev)
  1033. {
  1034. long ioaddr = dev->base_addr;
  1035. int i;
  1037. /* All statistics registers need to be acknowledged,
  1038.    else statistic overflow could cause problems */
  1039. readl (ioaddr + FramesRcvOk);
  1040. readl (ioaddr + FramesXmtOk);
  1041. readl (ioaddr + OctetRcvOk);
  1042. readl (ioaddr + OctetXmtOk);
  1044. readl (ioaddr + McstFramesRcvdOk);
  1045. readl (ioaddr + SingleColFrames);
  1046. readl (ioaddr + MultiColFrames);
  1047. readl (ioaddr + LateCollisions);
  1048. /* detailed rx errors */
  1049. readw (ioaddr + FrameTooLongErrors);
  1050. readw (ioaddr + InRangeLengthErrors);
  1051. readw (ioaddr + FramesCheckSeqErrors);
  1052. readw (ioaddr + FramesLostRxErrors);
  1054. /* detailed tx errors */
  1055. readw (ioaddr + FramesAbortXSColls);
  1056. readw (ioaddr + CarrierSenseErrors);
  1058. /* Clear all other statistic register. */
  1059. readl (ioaddr + McstOctetXmtOk);
  1060. readw (ioaddr + BcstFramesXmtdOk);
  1061. readl (ioaddr + McstFramesXmtdOk);
  1062. readw (ioaddr + BcstFramesRcvdOk);
  1063. readw (ioaddr + MacControlFramesRcvd);
  1064. readl (ioaddr + McstOctetXmtOk);
  1065. readl (ioaddr + BcstOctetXmtOk);
  1066. readl (ioaddr + McstFramesXmtdOk);
  1067. readl (ioaddr + FramesWDeferredXmt);
  1068. readw (ioaddr + BcstFramesXmtdOk);
  1069. readw (ioaddr + MacControlFramesXmtd);
  1070. readw (ioaddr + FramesWEXDeferal);
  1072. for (i = 0x100; i <= 0x150; i += 4)
  1073. readl (ioaddr + i);
  1074. readw (ioaddr + TxJumboFrames);
  1075. readw (ioaddr + RxJumboFrames);
  1076. readw (ioaddr + TCPCheckSumErrors);
  1077. readw (ioaddr + UDPCheckSumErrors);
  1078. readw (ioaddr + IPCheckSumErrors);
  1079. return 0;
  1080. }
  1083. int
  1084. change_mtu (struct net_device *dev, int new_mtu)
  1085. {
  1086. struct netdev_private *np = dev->priv;
  1087. int max = (np->jumbo) ? MAX_JUMBO : 1536;
  1089. if ((new_mtu < 68) || (new_mtu > max)) {
  1090. return -EINVAL;
  1091. }
  1093. dev->mtu = new_mtu;
  1095. return 0;
  1096. }
  1098. static void
  1099. set_multicast (struct net_device *dev)
  1100. {
  1101. long ioaddr = dev->base_addr;
  1102. u32 hash_table[2];
  1103. u16 rx_mode = 0;
  1104. int i;
  1105. int bit;
  1106. struct dev_mc_list *mclist;
  1107. struct netdev_private *np = dev->priv;
  1109. hash_table[0] = hash_table[1] = 0;
  1110. /* RxFlowcontrol DA: 01-80-C2-00-00-01. Hash index=0x39 */
  1111. hash_table[1] |= cpu_to_le32(0x02000000);
  1112. if (dev->flags & IFF_PROMISC) {
  1113. /* Receive all frames promiscuously. */
  1114. rx_mode = ReceiveAllFrames;
  1115. } else if ((dev->flags & IFF_ALLMULTI) || 
  1116. (dev->mc_count > multicast_filter_limit)) {
  1117. /* Receive broadcast and multicast frames */
  1118. rx_mode = ReceiveBroadcast | ReceiveMulticast | ReceiveUnicast;
  1119. } else if (dev->mc_count > 0) {
  1120. /* Receive broadcast frames and multicast frames filtering 
  1121.    by Hashtable */
  1122. rx_mode =
  1123.     ReceiveBroadcast | ReceiveMulticastHash | ReceiveUnicast;
  1124. for (i=0, mclist = dev->mc_list; mclist && i < dev->mc_count; 
  1125. i++, mclist=mclist->next) {
  1127. int index = 0;
  1128. int crc = ether_crc_le (ETH_ALEN, mclist->dmi_addr);
  1130. /* The inverted high significant 6 bits of CRC are
  1131.    used as an index to hashtable */
  1132. for (bit = 0; bit < 6; bit++)
  1133. if (crc & (1 << (31 - bit)))
  1134. index |= (1 << bit);
  1136. hash_table[index / 32] |= (1 << (index % 32));
  1137. }
  1138. } else {
  1139. rx_mode = ReceiveBroadcast | ReceiveUnicast;
  1140. }
  1141. if (np->vlan) {
  1142. /* ReceiveVLANMatch field in ReceiveMode */
  1143. rx_mode |= ReceiveVLANMatch;
  1144. }
  1146. writel (hash_table[0], ioaddr + HashTable0);
  1147. writel (hash_table[1], ioaddr + HashTable1);
  1148. writew (rx_mode, ioaddr + ReceiveMode);
  1149. }
  1151. static int
  1152. rio_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
  1153. {
  1154. int phy_addr;
  1155. struct netdev_private *np = dev->priv;
  1156. struct mii_data *miidata = (struct mii_data *) &rq->ifr_data;
  1158. struct netdev_desc *desc;
  1159. int i;
  1161. phy_addr = np->phy_addr;
  1162. switch (cmd) {
  1163. case SIOCDEVPRIVATE:
  1164. break;
  1166. case SIOCDEVPRIVATE + 1:
  1167. miidata->out_value = mii_read (dev, phy_addr, miidata->reg_num);
  1168. break;
  1169. case SIOCDEVPRIVATE + 2:
  1170. mii_write (dev, phy_addr, miidata->reg_num, miidata->in_value);
  1171. break;
  1172. case SIOCDEVPRIVATE + 3:
  1173. break;
  1174. case SIOCDEVPRIVATE + 4:
  1175. break;
  1176. case SIOCDEVPRIVATE + 5:
  1177. netif_stop_queue (dev);
  1178. break;
  1179. case SIOCDEVPRIVATE + 6:
  1180. netif_wake_queue (dev);
  1181. break;
  1182. case SIOCDEVPRIVATE + 7:
  1183. printk
  1184.     ("tx_full=%x cur_tx=%lx old_tx=%lx cur_rx=%lx old_rx=%lxn",
  1185.      netif_queue_stopped(dev), np->cur_tx, np->old_tx, np->cur_rx,
  1186.      np->old_rx);
  1187. break;
  1188. case SIOCDEVPRIVATE + 8:
  1189. printk("TX ring:n");
  1190. for (i = 0; i < TX_RING_SIZE; i++) {
  1191. desc = &np->tx_ring[i];
  1192. printk
  1193.     ("%02x:cur:%08x next:%08x status:%08x frag1:%08x frag0:%08x",
  1194.      i,
  1195.      (u32) (np->tx_ring_dma + i * sizeof (*desc)),
  1196.      (u32) desc->next_desc,
  1197.      (u32) desc->status, (u32) (desc->fraginfo >> 32),
  1198.      (u32) desc->fraginfo);
  1199. printk ("n");
  1200. }
  1201. printk ("n");
  1202. break;
  1204. default:
  1205. return -EOPNOTSUPP;
  1206. }
  1207. return 0;
  1208. }
  1210. #define EEP_READ 0x0200
  1211. #define EEP_BUSY 0x8000
  1212. /* Read the EEPROM word */
  1213. int
  1214. read_eeprom (long ioaddr, int eep_addr)
  1215. {
  1216. int i = 1000;
  1217. writew (EEP_READ | (eep_addr & 0xff), ioaddr + EepromCtrl);
  1218. while (i-- > 0) {
  1219. if (!(readw (ioaddr + EepromCtrl) & EEP_BUSY)) {
  1220. return readw (ioaddr + EepromData);
  1221. }
  1222. }
  1223. return 0;
  1224. }
  1226. enum phy_ctrl_bits {
  1227. MII_READ = 0x00, MII_CLK = 0x01, MII_DATA1 = 0x02, MII_WRITE = 0x04,
  1228. MII_DUPLEX = 0x08,
  1229. };
  1231. #define mii_delay() readb(ioaddr)
  1232. static void
  1233. mii_sendbit (struct net_device *dev, u32 data)
  1234. {
  1235. long ioaddr = dev->base_addr + PhyCtrl;
  1236. data = (data) ? MII_DATA1 : 0;
  1237. data |= MII_WRITE;
  1238. data |= (readb (ioaddr) & 0xf8) | MII_WRITE;
  1239. writeb (data, ioaddr);
  1240. mii_delay ();
  1241. writeb (data | MII_CLK, ioaddr);
  1242. mii_delay ();
  1243. }
  1245. static int
  1246. mii_getbit (struct net_device *dev)
  1247. {
  1248. long ioaddr = dev->base_addr + PhyCtrl;
  1249. u8 data;
  1251. data = (readb (ioaddr) & 0xf8) | MII_READ;
  1252. writeb (data, ioaddr);
  1253. mii_delay ();
  1254. writeb (data | MII_CLK, ioaddr);
  1255. mii_delay ();
  1256. return ((readb (ioaddr) >> 1) & 1);
  1257. }
  1259. static void
  1260. mii_send_bits (struct net_device *dev, u32 data, int len)
  1261. {
  1262. int i;
  1263. for (i = len - 1; i >= 0; i--) {
  1264. mii_sendbit (dev, data & (1 << i));
  1265. }
  1266. }
  1268. static int
  1269. mii_read (struct net_device *dev, int phy_addr, int reg_num)
  1270. {
  1271. u32 cmd;
  1272. int i;
  1273. u32 retval = 0;
  1275. /* Preamble */
  1276. mii_send_bits (dev, 0xffffffff, 32);
  1277. /* ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits */
  1278. /* ST,OP = 0110'b for read operation */
  1279. cmd = (0x06 << 10 | phy_addr << 5 | reg_num);
  1280. mii_send_bits (dev, cmd, 14);
  1281. /* Turnaround */
  1282. if (mii_getbit (dev))
  1283. goto err_out;
  1284. /* Read data */
  1285. for (i = 0; i < 16; i++) {
  1286. retval |= mii_getbit (dev);
  1287. retval <<= 1;
  1288. }
  1289. /* End cycle */
  1290. mii_getbit (dev);
  1291. return (retval >> 1) & 0xffff;
  1293.       err_out:
  1294. return 0;
  1295. }
  1296. static int
  1297. mii_write (struct net_device *dev, int phy_addr, int reg_num, u16 data)
  1298. {
  1299. u32 cmd;
  1301. /* Preamble */
  1302. mii_send_bits (dev, 0xffffffff, 32);
  1303. /* ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits */
  1304. /* ST,OP,AAAAA,RRRRR,TA = 0101xxxxxxxxxx10'b = 0x5002 for write */
  1305. cmd = (0x5002 << 16) | (phy_addr << 23) | (reg_num << 18) | data;
  1306. mii_send_bits (dev, cmd, 32);
  1307. /* End cycle */
  1308. mii_getbit (dev);
  1309. return 0;
  1310. }
  1311. static int
  1312. mii_wait_link (struct net_device *dev, int wait)
  1313. {
  1314. BMSR_t bmsr;
  1315. int phy_addr;
  1316. struct netdev_private *np;
  1318. np = dev->priv;
  1319. phy_addr = np->phy_addr;
  1321. do {
  1322. bmsr.image = mii_read (dev, phy_addr, MII_BMSR);
  1323. if (bmsr.bits.link_status)
  1324. return 0;
  1325. mdelay (1);
  1326. } while (--wait > 0);
  1327. return -1;
  1328. }
  1329. static int
  1330. mii_get_media (struct net_device *dev)
  1331. {
  1332. ANAR_t negotiate;
  1333. BMSR_t bmsr;
  1334. BMCR_t bmcr;
  1335. MSCR_t mscr;
  1336. MSSR_t mssr;
  1337. int phy_addr;
  1338. struct netdev_private *np;
  1340. np = dev->priv;
  1341. phy_addr = np->phy_addr;
  1343. bmsr.image = mii_read (dev, phy_addr, MII_BMSR);
  1344. if (np->an_enable) {
  1345. if (!bmsr.bits.an_complete) {
  1346. /* Auto-Negotiation not completed */
  1347. return -1;
  1348. }
  1349. negotiate.image = mii_read (dev, phy_addr, MII_ANAR) & 
  1350. mii_read (dev, phy_addr, MII_ANLPAR);
  1351. mscr.image = mii_read (dev, phy_addr, MII_MSCR);
  1352. mssr.image = mii_read (dev, phy_addr, MII_MSSR);
  1353. if (mscr.bits.media_1000BT_FD & mssr.bits.lp_1000BT_FD) {
  1354. np->speed = 1000;
  1355. np->full_duplex = 1;
  1356. printk (KERN_INFO "Auto 1000 Mbps, Full duplexn");
  1357. } else if (mscr.bits.media_1000BT_HD & mssr.bits.lp_1000BT_HD) {
  1358. np->speed = 1000;
  1359. np->full_duplex = 0;
  1360. printk (KERN_INFO "Auto 1000 Mbps, Half duplexn");
  1361. } else if (negotiate.bits.media_100BX_FD) {
  1362. np->speed = 100;
  1363. np->full_duplex = 1;
  1364. printk (KERN_INFO "Auto 100 Mbps, Full duplexn");
  1365. } else if (negotiate.bits.media_100BX_HD) {
  1366. np->speed = 100;
  1367. np->full_duplex = 0;
  1368. printk (KERN_INFO "Auto 100 Mbps, Half duplexn");
  1369. } else if (negotiate.bits.media_10BT_FD) {
  1370. np->speed = 10;
  1371. np->full_duplex = 1;
  1372. printk (KERN_INFO "Auto 10 Mbps, Full duplexn");
  1373. } else if (negotiate.bits.media_10BT_HD) {
  1374. np->speed = 10;
  1375. np->full_duplex = 0;
  1376. printk (KERN_INFO "Auto 10 Mbps, Half duplexn");
  1377. }
  1378. if (negotiate.bits.pause) {
  1379. np->tx_flow &= 1;
  1380. np->rx_flow &= 1;
  1381. } else if (negotiate.bits.asymmetric) {
  1382. np->tx_flow = 0;
  1383. np->rx_flow &= 1;
  1384. }
  1385. /* else tx_flow, rx_flow = user select  */
  1386. } else {
  1387. bmcr.image = mii_read (dev, phy_addr, MII_BMCR);
  1388. if (bmcr.bits.speed100 == 1 && bmcr.bits.speed1000 == 0) {
  1389. printk (KERN_INFO "Operating at 100 Mbps, ");
  1390. } else if (bmcr.bits.speed100 == 0 && bmcr.bits.speed1000 == 0) {
  1391. printk (KERN_INFO "Operating at 10 Mbps, ");
  1392. } else if (bmcr.bits.speed100 == 0 && bmcr.bits.speed1000 == 1) {
  1393. printk (KERN_INFO "Operating at 1000 Mbps, ");
  1394. }
  1395. if (bmcr.bits.duplex_mode) {
  1396. printk ("Full duplexn");
  1397. } else {
  1398. printk ("Half duplexn");
  1399. }
  1400. }
  1401. if (np->tx_flow) 
  1402. printk(KERN_INFO "Enable Tx Flow Controln");
  1403. else
  1404. printk(KERN_INFO "Disable Tx Flow Controln");
  1405. if (np->rx_flow)
  1406. printk(KERN_INFO "Enable Rx Flow Controln");
  1407. else
  1408. printk(KERN_INFO "Disable Rx Flow Controln");
  1410. return 0;
  1411. }
  1413. static int
  1414. mii_set_media (struct net_device *dev)
  1415. {
  1416. PHY_SCR_t pscr;
  1417. BMCR_t bmcr;
  1418. BMSR_t bmsr;
  1419. ANAR_t anar;
  1420. int phy_addr;
  1421. struct netdev_private *np;
  1422. np = dev->priv;
  1423. phy_addr = np->phy_addr;
  1425. /* Does user set speed? */
  1426. if (np->an_enable) {
  1427. /* Advertise capabilities */
  1428. bmsr.image = mii_read (dev, phy_addr, MII_BMSR);
  1429. anar.image = mii_read (dev, phy_addr, MII_ANAR);
  1430. anar.bits.media_100BX_FD = bmsr.bits.media_100BX_FD;
  1431. anar.bits.media_100BX_HD = bmsr.bits.media_100BX_HD;
  1432. anar.bits.media_100BT4 = bmsr.bits.media_100BT4;
  1433. anar.bits.media_10BT_FD = bmsr.bits.media_10BT_FD;
  1434. anar.bits.media_10BT_HD = bmsr.bits.media_10BT_HD;
  1435. anar.bits.pause = 1;
  1436. anar.bits.asymmetric = 1;
  1437. mii_write (dev, phy_addr, MII_ANAR, anar.image);
  1439. /* Enable Auto crossover */
  1440. pscr.image = mii_read (dev, phy_addr, MII_PHY_SCR);
  1441. pscr.bits.mdi_crossover_mode = 3; /* 11'b */
  1442. mii_write (dev, phy_addr, MII_PHY_SCR, pscr.image);
  1444. /* Soft reset PHY */
  1445. mii_write (dev, phy_addr, MII_BMCR, MII_BMCR_RESET);
  1446. bmcr.image = 0;
  1447. bmcr.bits.an_enable = 1;
  1448. bmcr.bits.restart_an = 1;
  1449. bmcr.bits.reset = 1;
  1450. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1451. mdelay(1);
  1452. } else {
  1453. /* Force speed setting */
  1454. /* 1) Disable Auto crossover */
  1455. pscr.image = mii_read (dev, phy_addr, MII_PHY_SCR);
  1456. pscr.bits.mdi_crossover_mode = 0;
  1457. mii_write (dev, phy_addr, MII_PHY_SCR, pscr.image);
  1459. /* 2) PHY Reset */
  1460. bmcr.image = mii_read (dev, phy_addr, MII_BMCR);
  1461. bmcr.bits.reset = 1;
  1462. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1464. /* 3) Power Down */
  1465. bmcr.image = 0x1940; /* must be 0x1940 */
  1466. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1467. mdelay (10); /* wait a certain time */
  1469. /* 4) Advertise nothing */
  1470. mii_write (dev, phy_addr, MII_ANAR, 0);
  1472. /* 5) Set media and Power Up */
  1473. bmcr.image = 0;
  1474. bmcr.bits.power_down = 1;
  1475. if (np->speed == 100) {
  1476. bmcr.bits.speed100 = 1;
  1477. bmcr.bits.speed1000 = 0;
  1478. printk (KERN_INFO "Manual 100 Mbps, ");
  1479. } else if (np->speed == 10) {
  1480. bmcr.bits.speed100 = 0;
  1481. bmcr.bits.speed1000 = 0;
  1482. printk (KERN_INFO "Manual 10 Mbps, ");
  1483. }
  1484. if (np->full_duplex) {
  1485. bmcr.bits.duplex_mode = 1;
  1486. printk ("Full duplexn");
  1487. } else {
  1488. bmcr.bits.duplex_mode = 0;
  1489. printk ("Half duplexn");
  1490. }
  1491. #if 0
  1492. /* Set 1000BaseT Master/Slave setting */
  1493. mscr.image = mii_read (dev, phy_addr, MII_MSCR);
  1494. mscr.bits.cfg_enable = 1;
  1495. mscr.bits.cfg_value = 0;
  1496. #endif
  1497. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1498. mdelay(10);
  1499. }
  1500. return 0;
  1501. }
  1503. static int
  1504. mii_get_media_pcs (struct net_device *dev)
  1505. {
  1506. ANAR_PCS_t negotiate;
  1507. BMSR_t bmsr;
  1508. BMCR_t bmcr;
  1509. int phy_addr;
  1510. struct netdev_private *np;
  1512. np = dev->priv;
  1513. phy_addr = np->phy_addr;
  1515. bmsr.image = mii_read (dev, phy_addr, PCS_BMSR);
  1516. if (np->an_enable) {
  1517. if (!bmsr.bits.an_complete) {
  1518. /* Auto-Negotiation not completed */
  1519. return -1;
  1520. }
  1521. negotiate.image = mii_read (dev, phy_addr, PCS_ANAR) & 
  1522. mii_read (dev, phy_addr, PCS_ANLPAR);
  1523. np->speed = 1000;
  1524. if (negotiate.bits.full_duplex) {
  1525. printk (KERN_INFO "Auto 1000 Mbps, Full duplexn");
  1526. np->full_duplex = 1;
  1527. } else {
  1528. printk (KERN_INFO "Auto 1000 Mbps, half duplexn");
  1529. np->full_duplex = 0;
  1530. }
  1531. if (negotiate.bits.pause) {
  1532. np->tx_flow &= 1;
  1533. np->rx_flow &= 1;
  1534. } else if (negotiate.bits.asymmetric) {
  1535. np->tx_flow = 0;
  1536. np->rx_flow &= 1;
  1537. }
  1538. /* else tx_flow, rx_flow = user select  */
  1539. } else {
  1540. bmcr.image = mii_read (dev, phy_addr, PCS_BMCR);
  1541. printk (KERN_INFO "Operating at 1000 Mbps, ");
  1542. if (bmcr.bits.duplex_mode) {
  1543. printk ("Full duplexn");
  1544. } else {
  1545. printk ("Half duplexn");
  1546. }
  1547. }
  1548. if (np->tx_flow) 
  1549. printk(KERN_INFO "Enable Tx Flow Controln");
  1550. else
  1551. printk(KERN_INFO "Disable Tx Flow Controln");
  1552. if (np->rx_flow)
  1553. printk(KERN_INFO "Enable Rx Flow Controln");
  1554. else
  1555. printk(KERN_INFO "Disable Rx Flow Controln");
  1557. return 0;
  1558. }
  1560. static int
  1561. mii_set_media_pcs (struct net_device *dev)
  1562. {
  1563. BMCR_t bmcr;
  1564. ESR_t esr;
  1565. ANAR_PCS_t anar;
  1566. int phy_addr;
  1567. struct netdev_private *np;
  1568. np = dev->priv;
  1569. phy_addr = np->phy_addr;
  1571. /* Auto-Negotiation? */
  1572. if (np->an_enable) {
  1573. /* Advertise capabilities */
  1574. esr.image = mii_read (dev, phy_addr, PCS_ESR);
  1575. anar.image = mii_read (dev, phy_addr, MII_ANAR);
  1576. anar.bits.half_duplex = 
  1577. esr.bits.media_1000BT_HD | esr.bits.media_1000BX_HD;
  1578. anar.bits.full_duplex = 
  1579. esr.bits.media_1000BT_FD | esr.bits.media_1000BX_FD;
  1580. anar.bits.pause = 1;
  1581. anar.bits.asymmetric = 1;
  1582. mii_write (dev, phy_addr, MII_ANAR, anar.image);
  1584. /* Soft reset PHY */
  1585. mii_write (dev, phy_addr, MII_BMCR, MII_BMCR_RESET);
  1586. bmcr.image = 0;
  1587. bmcr.bits.an_enable = 1;
  1588. bmcr.bits.restart_an = 1;
  1589. bmcr.bits.reset = 1;
  1590. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1591. mdelay(1);
  1592. } else {
  1593. /* Force speed setting */
  1594. /* PHY Reset */
  1595. bmcr.image = 0;
  1596. bmcr.bits.reset = 1;
  1597. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1598. mdelay(10);
  1599. bmcr.image = 0;
  1600. bmcr.bits.an_enable = 0;
  1601. if (np->full_duplex) {
  1602. bmcr.bits.duplex_mode = 1;
  1603. printk (KERN_INFO "Manual full duplexn");
  1604. } else {
  1605. bmcr.bits.duplex_mode = 0;
  1606. printk (KERN_INFO "Manual half duplexn");
  1607. }
  1608. mii_write (dev, phy_addr, MII_BMCR, bmcr.image);
  1609. mdelay(10);
  1611. /*  Advertise nothing */
  1612. mii_write (dev, phy_addr, MII_ANAR, 0);
  1613. }
  1614. return 0;
  1615. }
  1618. static int
  1619. rio_close (struct net_device *dev)
  1620. {
  1621. long ioaddr = dev->base_addr;
  1622. struct netdev_private *np = dev->priv;
  1623. struct sk_buff *skb;
  1624. int i;
  1626. netif_stop_queue (dev);
  1628. /* Disable interrupts */
  1629. writew (0, ioaddr + IntEnable);
  1631. /* Stop Tx and Rx logics */
  1632. writel (TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl);
  1633. synchronize_irq ();
  1634. free_irq (dev->irq, dev);
  1635. del_timer_sync (&np->timer);
  1637. /* Free all the skbuffs in the queue. */
  1638. for (i = 0; i < RX_RING_SIZE; i++) {
  1639. np->rx_ring[i].status = 0;
  1640. np->rx_ring[i].fraginfo = 0;
  1641. skb = np->rx_skbuff[i];
  1642. if (skb) {
  1643. pci_unmap_single (np->pdev, np->rx_ring[i].fraginfo,
  1644.   skb->len, PCI_DMA_FROMDEVICE);
  1645. dev_kfree_skb (skb);
  1646. np->rx_skbuff[i] = 0;
  1647. }
  1648. }
  1649. for (i = 0; i < TX_RING_SIZE; i++) {
  1650. skb = np->tx_skbuff[i];
  1651. if (skb) {
  1652. pci_unmap_single (np->pdev, np->tx_ring[i].fraginfo,
  1653.   skb->len, PCI_DMA_TODEVICE);
  1654. dev_kfree_skb (skb);
  1655. np->tx_skbuff[i] = 0;
  1656. }
  1657. }
  1659. return 0;
  1660. }
  1662. static void __devexit
  1663. rio_remove1 (struct pci_dev *pdev)
  1664. {
  1665. struct net_device *dev = pci_get_drvdata (pdev);
  1667. if (dev) {
  1668. struct netdev_private *np = dev->priv;
  1670. unregister_netdev (dev);
  1671. pci_free_consistent (pdev, RX_TOTAL_SIZE, np->rx_ring,
  1672.      np->rx_ring_dma);
  1673. pci_free_consistent (pdev, TX_TOTAL_SIZE, np->tx_ring,
  1674.      np->tx_ring_dma);
  1675. #ifdef MEM_MAPPING
  1676. iounmap ((char *) (dev->base_addr));
  1677. #endif
  1678. kfree (dev);
  1679. pci_release_regions (pdev);
  1680. pci_disable_device (pdev);
  1681. }
  1682. pci_set_drvdata (pdev, NULL);
  1683. }
  1685. static struct pci_driver rio_driver = {
  1686. name: "dl2k",
  1687. id_table: rio_pci_tbl,
  1688. probe: rio_probe1,
  1689. remove: __devexit_p(rio_remove1),
  1690. };
  1692. static int __init
  1693. rio_init (void)
  1694. {
  1695. return pci_module_init (&rio_driver);
  1696. }
  1698. static void __exit
  1699. rio_exit (void)
  1700. {
  1701. pci_unregister_driver (&rio_driver);
  1702. }
  1704. module_init (rio_init);
  1705. module_exit (rio_exit);
  1707. /*
  1708.  
  1709. Compile command: 
  1710.  
  1711. gcc -D__KERNEL__ -DMODULE -I/usr/src/linux/include -Wall -Wstrict-prototypes -O2 -c dl2k.c
  1713. Read Documentation/networking/dl2k.txt for details.
  1715. */