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

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

嵌入式Linux

开发平台：

Unix_Linux

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