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

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

Linux/Unix编程

开发平台：

Unix_Linux

rrunner.c：源码内容
  1. /*
  2.  * rrunner.c: Linux driver for the Essential RoadRunner HIPPI board.
  3.  *
  4.  * Copyright (C) 1998-2000 by Jes Sorensen, <Jes.Sorensen@cern.ch>.
  5.  *
  6.  * Thanks to Essential Communication for providing us with hardware
  7.  * and very comprehensive documentation without which I would not have
  8.  * been able to write this driver. A special thank you to John Gibbon
  9.  * for sorting out the legal issues, with the NDA, allowing the code to
  10.  * be released under the GPL.
  11.  *
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2 of the License, or
  15.  * (at your option) any later version.
  16.  *
  17.  * Thanks to Jayaram Bhat from ODS/Essential for fixing some of the
  18.  * stupid bugs in my code.
  19.  *
  20.  * Softnet support and various other patches from Val Henson of
  21.  * ODS/Essential.
  22.  */
  24. #define DEBUG 1
  25. #define RX_DMA_SKBUFF 1
  26. #define PKT_COPY_THRESHOLD 512
  28. #include <linux/config.h>
  29. #include <linux/module.h>
  30. #include <linux/version.h>
  31. #include <linux/types.h>
  32. #include <linux/errno.h>
  33. #include <linux/ioport.h>
  34. #include <linux/pci.h>
  35. #include <linux/kernel.h>
  36. #include <linux/netdevice.h>
  37. #include <linux/hippidevice.h>
  38. #include <linux/skbuff.h>
  39. #include <linux/init.h>
  40. #include <linux/delay.h>
  41. #include <linux/mm.h>
  42. #include <net/sock.h>
  44. #include <asm/system.h>
  45. #include <asm/cache.h>
  46. #include <asm/byteorder.h>
  47. #include <asm/io.h>
  48. #include <asm/irq.h>
  49. #include <asm/uaccess.h>
  51. #if (LINUX_VERSION_CODE < 0x02030e)
  52. #define net_device device
  53. #endif
  55. #if (LINUX_VERSION_CODE >= 0x02031b)
  56. #define NEW_NETINIT
  57. #endif
  59. #if (LINUX_VERSION_CODE < 0x02032b)
  60. /*
  61.  * SoftNet changes
  62.  */
  63. #define dev_kfree_skb_irq(a) dev_kfree_skb(a)
  64. #define netif_wake_queue(dev) clear_bit(0, &dev->tbusy)
  65. #define netif_stop_queue(dev) set_bit(0, &dev->tbusy)
  67. static inline void netif_start_queue(struct net_device *dev)
  68. {
  69. dev->tbusy = 0;
  70. dev->start = 1;
  71. }
  73. #define rr_mark_net_bh(foo) mark_bh(foo)
  74. #define rr_if_busy(dev)     dev->tbusy
  75. #define rr_if_running(dev)  dev->start /* Currently unused. */
  76. #define rr_if_down(dev)     do { dev->start = 0; } while (0)
  77. #else
  78. #define NET_BH              0
  79. #define rr_mark_net_bh(foo) do { } while(0)
  80. #define rr_if_busy(dev)     netif_queue_stopped(dev)
  81. #define rr_if_running(dev)  netif_running(dev)
  82. #define rr_if_down(dev)     do { } while(0)
  83. #endif
  85. #include "rrunner.h"
  87. #define RUN_AT(x) (jiffies + (x))
  90. /*
  91.  * Implementation notes:
  92.  *
  93.  * The DMA engine only allows for DMA within physical 64KB chunks of
  94.  * memory. The current approach of the driver (and stack) is to use
  95.  * linear blocks of memory for the skbuffs. However, as the data block
  96.  * is always the first part of the skb and skbs are 2^n aligned so we
  97.  * are guarantted to get the whole block within one 64KB align 64KB
  98.  * chunk.
  99.  *
  100.  * On the long term, relying on being able to allocate 64KB linear
  101.  * chunks of memory is not feasible and the skb handling code and the
  102.  * stack will need to know about I/O vectors or something similar.
  103.  */
  105. static char version[] __initdata = "rrunner.c: v0.22 03/01/2000  Jes Sorensen (Jes.Sorensen@cern.ch)n";
  107. static struct net_device *root_dev;
  110. /*
  111.  * These are checked at init time to see if they are at least 256KB
  112.  * and increased to 256KB if they are not. This is done to avoid ending
  113.  * up with socket buffers smaller than the MTU size,
  114.  */
  115. extern __u32 sysctl_wmem_max;
  116. extern __u32 sysctl_rmem_max;
  118. static int probed __initdata = 0;
  120. #if LINUX_VERSION_CODE >= 0x20400
  121. static struct pci_device_id rrunner_pci_tbl[] __initdata = {
  122. { PCI_VENDOR_ID_ESSENTIAL, PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER, PCI_ANY_ID, PCI_ANY_ID, },
  123. { } /* Terminating entry */
  124. };
  125. MODULE_DEVICE_TABLE(pci, rrunner_pci_tbl);
  126. #endif /* LINUX_VERSION_CODE >= 0x20400 */
  128. #ifdef NEW_NETINIT
  129. int __init rr_hippi_probe (void)
  130. #else
  131. int __init rr_hippi_probe (struct net_device *dev)
  132. #endif
  133. {
  134. #ifdef NEW_NETINIT
  135. struct net_device *dev;
  136. #endif
  137. int boards_found = 0;
  138. int version_disp; /* was version info already displayed? */
  139. struct pci_dev *pdev = NULL;
  140. struct pci_dev *opdev = NULL;
  141. u8 pci_latency;
  142. struct rr_private *rrpriv;
  144. if (probed)
  145. return -ENODEV;
  146. probed++;
  148. version_disp = 0;
  150. while((pdev = pci_find_device(PCI_VENDOR_ID_ESSENTIAL,
  151.       PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER,
  152.       pdev)))
  153. {
  154. if (pci_enable_device(pdev))
  155. continue;
  157. if (pdev == opdev)
  158. return 0;
  160. /*
  161.  * So we found our HIPPI ... time to tell the system.
  162.  */
  164. dev = init_hippi_dev(NULL, sizeof(struct rr_private));
  166. if (!dev)
  167. break;
  169. if (!dev->priv)
  170. dev->priv = kmalloc(sizeof(*rrpriv), GFP_KERNEL);
  172. if (!dev->priv)
  173. return -ENOMEM;
  175. rrpriv = (struct rr_private *)dev->priv;
  176. memset(rrpriv, 0, sizeof(*rrpriv));
  178. #ifdef CONFIG_SMP
  179. spin_lock_init(&rrpriv->lock);
  180. #endif
  181. sprintf(rrpriv->name, "RoadRunner serial HIPPI");
  183. dev->irq = pdev->irq;
  184. SET_MODULE_OWNER(dev);
  185. dev->open = &rr_open;
  186. dev->hard_start_xmit = &rr_start_xmit;
  187. dev->stop = &rr_close;
  188. dev->get_stats = &rr_get_stats;
  189. dev->do_ioctl = &rr_ioctl;
  191. #if (LINUX_VERSION_CODE < 0x02030d)
  192. dev->base_addr = pdev->base_address[0];
  193. #else
  194. dev->base_addr = pdev->resource[0].start;
  195. #endif
  197. /* display version info if adapter is found */
  198. if (!version_disp)
  199. {
  200. /* set display flag to TRUE so that */
  201. /* we only display this string ONCE */
  202. version_disp = 1;
  203. printk(version);
  204. }
  206. pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
  207. if (pci_latency <= 0x58){
  208. pci_latency = 0x58;
  209. pci_write_config_byte(pdev, PCI_LATENCY_TIMER,
  210.       pci_latency);
  211. }
  213. pci_set_master(pdev);
  215. printk(KERN_INFO "%s: Essential RoadRunner serial HIPPI "
  216.        "at 0x%08lx, irq %i, PCI latency %in", dev->name,
  217.        dev->base_addr, dev->irq, pci_latency);
  219. /*
  220.  * Remap the regs into kernel space.
  221.  */
  223. rrpriv->regs = (struct rr_regs *)
  224. ioremap(dev->base_addr, 0x1000);
  226. if (!rrpriv->regs){
  227. printk(KERN_ERR "%s:  Unable to map I/O register, "
  228.        "RoadRunner %i will be disabled.n",
  229.        dev->name, boards_found);
  230. break;
  231. }
  233. /*
  234.  * Don't access any registes before this point!
  235.  */
  236. #ifdef __BIG_ENDIAN
  237. writel(readl(&regs->HostCtrl) | NO_SWAP, &regs->HostCtrl);
  238. #endif
  239. /*
  240.  * Need to add a case for little-endian 64-bit hosts here.
  241.  */
  243. rr_init(dev);
  245. boards_found++;
  246. dev->base_addr = 0;
  247. dev = NULL;
  248. opdev = pdev;
  249. }
  251. /*
  252.  * If we're at this point we're going through rr_hippi_probe()
  253.  * for the first time.  Return success (0) if we've initialized
  254.  * 1 or more boards. Otherwise, return failure (-ENODEV).
  255.  */
  257. #ifdef MODULE
  258. return boards_found;
  259. #else
  260. if (boards_found > 0)
  261. return 0;
  262. else
  263. return -ENODEV;
  264. #endif
  265. }
  268. #ifdef MODULE
  269. #if LINUX_VERSION_CODE > 0x20118
  270. MODULE_AUTHOR("Jes Sorensen <Jes.Sorensen@cern.ch>");
  271. MODULE_DESCRIPTION("Essential RoadRunner HIPPI driver");
  272. MODULE_LICENSE("GPL");
  273. #endif
  275. int init_module(void)
  276. {
  277. int cards;
  279. root_dev = NULL;
  281. #ifdef NEW_NETINIT
  282. cards = rr_hippi_probe();
  283. #else
  284. cards = rr_hippi_probe(NULL);
  285. #endif
  286. return cards ? 0 : -ENODEV;
  287. }
  289. void cleanup_module(void)
  290. {
  291. struct rr_private *rr;
  292. struct net_device *next;
  294. while (root_dev) {
  295. next = ((struct rr_private *)root_dev->priv)->next;
  296. rr = (struct rr_private *)root_dev->priv;
  298. if (!(readl(&rr->regs->HostCtrl) & NIC_HALTED)){
  299. printk(KERN_ERR "%s: trying to unload running NICn",
  300.        root_dev->name);
  301. writel(HALT_NIC, &rr->regs->HostCtrl);
  302. }
  304. iounmap(rr->regs);
  305. unregister_hipdev(root_dev);
  306. kfree(root_dev);
  308. root_dev = next;
  309. }
  310. }
  311. #endif
  314. /*
  315.  * Commands are considered to be slow, thus there is no reason to
  316.  * inline this.
  317.  */
  318. static void rr_issue_cmd(struct rr_private *rrpriv, struct cmd *cmd)
  319. {
  320. struct rr_regs *regs;
  321. u32 idx;
  323. regs = rrpriv->regs;
  324. /*
  325.  * This is temporary - it will go away in the final version.
  326.  * We probably also want to make this function inline.
  327.  */
  328. if (readl(&regs->HostCtrl) & NIC_HALTED){
  329. printk("issuing command for halted NIC, code 0x%x, "
  330.        "HostCtrl %08xn", cmd->code, readl(&regs->HostCtrl));
  331. if (readl(&regs->Mode) & FATAL_ERR)
  332. printk("error codes Fail1 %02x, Fail2 %02xn",
  333.        readl(&regs->Fail1), readl(&regs->Fail2));
  334. }
  336. idx = rrpriv->info->cmd_ctrl.pi;
  338. writel(*(u32*)(cmd), &regs->CmdRing[idx]);
  339. wmb();
  341. idx = (idx - 1) % CMD_RING_ENTRIES;
  342. rrpriv->info->cmd_ctrl.pi = idx;
  343. wmb();
  345. if (readl(&regs->Mode) & FATAL_ERR)
  346. printk("error code %02xn", readl(&regs->Fail1));
  347. }
  350. /*
  351.  * Reset the board in a sensible manner. The NIC is already halted
  352.  * when we get here and a spin-lock is held.
  353.  */
  354. static int rr_reset(struct net_device *dev)
  355. {
  356. struct rr_private *rrpriv;
  357. struct rr_regs *regs;
  358. struct eeprom *hw = NULL;
  359. u32 start_pc;
  360. int i;
  362. rrpriv = (struct rr_private *)dev->priv;
  363. regs = rrpriv->regs;
  365. rr_load_firmware(dev);
  367. writel(0x01000000, &regs->TX_state);
  368. writel(0xff800000, &regs->RX_state);
  369. writel(0, &regs->AssistState);
  370. writel(CLEAR_INTA, &regs->LocalCtrl);
  371. writel(0x01, &regs->BrkPt);
  372. writel(0, &regs->Timer);
  373. writel(0, &regs->TimerRef);
  374. writel(RESET_DMA, &regs->DmaReadState);
  375. writel(RESET_DMA, &regs->DmaWriteState);
  376. writel(0, &regs->DmaWriteHostHi);
  377. writel(0, &regs->DmaWriteHostLo);
  378. writel(0, &regs->DmaReadHostHi);
  379. writel(0, &regs->DmaReadHostLo);
  380. writel(0, &regs->DmaReadLen);
  381. writel(0, &regs->DmaWriteLen);
  382. writel(0, &regs->DmaWriteLcl);
  383. writel(0, &regs->DmaWriteIPchecksum);
  384. writel(0, &regs->DmaReadLcl);
  385. writel(0, &regs->DmaReadIPchecksum);
  386. writel(0, &regs->PciState);
  387. #if (BITS_PER_LONG == 64) && defined __LITTLE_ENDIAN
  388. writel(SWAP_DATA | PTR64BIT | PTR_WD_SWAP, &regs->Mode);
  389. #elif (BITS_PER_LONG == 64)
  390. writel(SWAP_DATA | PTR64BIT | PTR_WD_NOSWAP, &regs->Mode);
  391. #else
  392. writel(SWAP_DATA | PTR32BIT | PTR_WD_NOSWAP, &regs->Mode);
  393. #endif
  395. #if 0
  396. /*
  397.  * Don't worry, this is just black magic.
  398.  */
  399. writel(0xdf000, &regs->RxBase);
  400. writel(0xdf000, &regs->RxPrd);
  401. writel(0xdf000, &regs->RxCon);
  402. writel(0xce000, &regs->TxBase);
  403. writel(0xce000, &regs->TxPrd);
  404. writel(0xce000, &regs->TxCon);
  405. writel(0, &regs->RxIndPro);
  406. writel(0, &regs->RxIndCon);
  407. writel(0, &regs->RxIndRef);
  408. writel(0, &regs->TxIndPro);
  409. writel(0, &regs->TxIndCon);
  410. writel(0, &regs->TxIndRef);
  411. writel(0xcc000, &regs->pad10[0]);
  412. writel(0, &regs->DrCmndPro);
  413. writel(0, &regs->DrCmndCon);
  414. writel(0, &regs->DwCmndPro);
  415. writel(0, &regs->DwCmndCon);
  416. writel(0, &regs->DwCmndRef);
  417. writel(0, &regs->DrDataPro);
  418. writel(0, &regs->DrDataCon);
  419. writel(0, &regs->DrDataRef);
  420. writel(0, &regs->DwDataPro);
  421. writel(0, &regs->DwDataCon);
  422. writel(0, &regs->DwDataRef);
  423. #endif
  425. writel(0xffffffff, &regs->MbEvent);
  426. writel(0, &regs->Event);
  428. writel(0, &regs->TxPi);
  429. writel(0, &regs->IpRxPi);
  431. writel(0, &regs->EvtCon);
  432. writel(0, &regs->EvtPrd);
  434. rrpriv->info->evt_ctrl.pi = 0;
  436. for (i = 0; i < CMD_RING_ENTRIES; i++)
  437. writel(0, &regs->CmdRing[i]);
  439. /*
  440.  * Why 32 ? is this not cache line size dependant?
  441.  */
  442. writel(RBURST_64|WBURST_64, &regs->PciState);
  443. wmb();
  445. start_pc = rr_read_eeprom_word(rrpriv, &hw->rncd_info.FwStart);
  447. #if (DEBUG > 1)
  448. printk("%s: Executing firmware at address 0x%06xn",
  449.        dev->name, start_pc);
  450. #endif
  452. writel(start_pc + 0x800, &regs->Pc);
  453. wmb();
  454. udelay(5);
  456. writel(start_pc, &regs->Pc);
  457. wmb();
  459. return 0;
  460. }
  463. /*
  464.  * Read a string from the EEPROM.
  465.  */
  466. static unsigned int rr_read_eeprom(struct rr_private *rrpriv,
  467. unsigned long offset,
  468. unsigned char *buf,
  469. unsigned long length)
  470. {
  471. struct rr_regs *regs = rrpriv->regs;
  472. u32 misc, io, host, i;
  474. io = readl(&regs->ExtIo);
  475. writel(0, &regs->ExtIo);
  476. misc = readl(&regs->LocalCtrl);
  477. writel(0, &regs->LocalCtrl);
  478. host = readl(&regs->HostCtrl);
  479. writel(host | HALT_NIC, &regs->HostCtrl);
  480. mb();
  482. for (i = 0; i < length; i++){
  483. writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
  484. mb();
  485. buf[i] = (readl(&regs->WinData) >> 24) & 0xff;
  486. mb();
  487. }
  489. writel(host, &regs->HostCtrl);
  490. writel(misc, &regs->LocalCtrl);
  491. writel(io, &regs->ExtIo);
  492. mb();
  493. return i;
  494. }
  497. /*
  498.  * Shortcut to read one word (4 bytes) out of the EEPROM and convert
  499.  * it to our CPU byte-order.
  500.  */
  501. static u32 rr_read_eeprom_word(struct rr_private *rrpriv,
  502.     void * offset)
  503. {
  504. u32 word;
  506. if ((rr_read_eeprom(rrpriv, (unsigned long)offset,
  507.     (char *)&word, 4) == 4))
  508. return be32_to_cpu(word);
  509. return 0;
  510. }
  513. /*
  514.  * Write a string to the EEPROM.
  515.  *
  516.  * This is only called when the firmware is not running.
  517.  */
  518. static unsigned int write_eeprom(struct rr_private *rrpriv,
  519.  unsigned long offset,
  520.  unsigned char *buf,
  521.  unsigned long length)
  522. {
  523. struct rr_regs *regs = rrpriv->regs;
  524. u32 misc, io, data, i, j, ready, error = 0;
  526. io = readl(&regs->ExtIo);
  527. writel(0, &regs->ExtIo);
  528. misc = readl(&regs->LocalCtrl);
  529. writel(ENABLE_EEPROM_WRITE, &regs->LocalCtrl);
  530. mb();
  532. for (i = 0; i < length; i++){
  533. writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
  534. mb();
  535. data = buf[i] << 24;
  536. /*
  537.  * Only try to write the data if it is not the same
  538.  * value already.
  539.  */
  540. if ((readl(&regs->WinData) & 0xff000000) != data){
  541. writel(data, &regs->WinData);
  542. ready = 0;
  543. j = 0;
  544. mb();
  545. while(!ready){
  546. udelay(20);
  547. if ((readl(&regs->WinData) & 0xff000000) ==
  548.     data)
  549. ready = 1;
  550. mb();
  551. if (j++ > 5000){
  552. printk("data mismatch: %08x, "
  553.        "WinData %08xn", data,
  554.        readl(&regs->WinData));
  555. ready = 1;
  556. error = 1;
  557. }
  558. }
  559. }
  560. }
  562. writel(misc, &regs->LocalCtrl);
  563. writel(io, &regs->ExtIo);
  564. mb();
  566. return error;
  567. }
  570. static int __init rr_init(struct net_device *dev)
  571. {
  572. struct rr_private *rrpriv;
  573. struct rr_regs *regs;
  574. struct eeprom *hw = NULL;
  575. u32 sram_size, rev;
  576. int i;
  578. rrpriv = (struct rr_private *)dev->priv;
  579. regs = rrpriv->regs;
  581. rev = readl(&regs->FwRev);
  582. rrpriv->fw_rev = rev;
  583. if (rev > 0x00020024)
  584. printk("  Firmware revision: %i.%i.%in", (rev >> 16),
  585.        ((rev >> 8) & 0xff), (rev & 0xff));
  586. else if (rev >= 0x00020000) {
  587. printk("  Firmware revision: %i.%i.%i (2.0.37 or "
  588.        "later is recommended)n", (rev >> 16),
  589.        ((rev >> 8) & 0xff), (rev & 0xff));
  590. }else{
  591. printk("  Firmware revision too old: %i.%i.%i, please "
  592.        "upgrade to 2.0.37 or later.n",
  593.        (rev >> 16), ((rev >> 8) & 0xff), (rev & 0xff));
  594. }
  596. #if (DEBUG > 2)
  597. printk("  Maximum receive rings %in", readl(&regs->MaxRxRng));
  598. #endif
  600. /*
  601.  * Read the hardware address from the eeprom.  The HW address
  602.  * is not really necessary for HIPPI but awfully convenient.
  603.  * The pointer arithmetic to put it in dev_addr is ugly, but
  604.  * Donald Becker does it this way for the GigE version of this
  605.  * card and it's shorter and more portable than any
  606.  * other method I've seen.  -VAL
  607.  */
  609. *(u16 *)(dev->dev_addr) =
  610.   htons(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA));
  611. *(u32 *)(dev->dev_addr+2) =
  612.   htonl(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA[4]));
  614. printk("  MAC: ");
  616. for (i = 0; i < 5; i++)
  617. printk("%2.2x:", dev->dev_addr[i]);
  618. printk("%2.2xn", dev->dev_addr[i]);
  620. sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
  621. printk("  SRAM size 0x%06xn", sram_size);
  623. if (sysctl_rmem_max < 262144){
  624. printk("  Receive socket buffer limit too low (%i), "
  625.        "setting to 262144n", sysctl_rmem_max);
  626. sysctl_rmem_max = 262144;
  627. }
  629. if (sysctl_wmem_max < 262144){
  630. printk("  Transmit socket buffer limit too low (%i), "
  631.        "setting to 262144n", sysctl_wmem_max);
  632. sysctl_wmem_max = 262144;
  633. }
  635. rrpriv->next = root_dev;
  636. root_dev = dev;
  638. return 0;
  639. }
  642. static int rr_init1(struct net_device *dev)
  643. {
  644. struct rr_private *rrpriv;
  645. struct rr_regs *regs;
  646. unsigned long myjif, flags;
  647. struct cmd cmd;
  648. u32 hostctrl;
  649. int ecode = 0;
  650. short i;
  652. rrpriv = (struct rr_private *)dev->priv;
  653. regs = rrpriv->regs;
  655. spin_lock_irqsave(&rrpriv->lock, flags);
  657. hostctrl = readl(&regs->HostCtrl);
  658. writel(hostctrl | HALT_NIC | RR_CLEAR_INT, &regs->HostCtrl);
  659. wmb();
  661. if (hostctrl & PARITY_ERR){
  662. printk("%s: Parity error halting NIC - this is serious!n",
  663.        dev->name);
  664. spin_unlock_irqrestore(&rrpriv->lock, flags);
  665. ecode = -EFAULT;
  666. goto error;
  667. }
  669. set_rxaddr(regs, rrpriv->rx_ctrl);
  670. set_infoaddr(regs, rrpriv->info);
  672. rrpriv->info->evt_ctrl.entry_size = sizeof(struct event);
  673. rrpriv->info->evt_ctrl.entries = EVT_RING_ENTRIES;
  674. rrpriv->info->evt_ctrl.mode = 0;
  675. rrpriv->info->evt_ctrl.pi = 0;
  676. set_rraddr(&rrpriv->info->evt_ctrl.rngptr, rrpriv->evt_ring);
  678. rrpriv->info->cmd_ctrl.entry_size = sizeof(struct cmd);
  679. rrpriv->info->cmd_ctrl.entries = CMD_RING_ENTRIES;
  680. rrpriv->info->cmd_ctrl.mode = 0;
  681. rrpriv->info->cmd_ctrl.pi = 15;
  683. for (i = 0; i < CMD_RING_ENTRIES; i++) {
  684. writel(0, &regs->CmdRing[i]);
  685. }
  687. for (i = 0; i < TX_RING_ENTRIES; i++) {
  688. rrpriv->tx_ring[i].size = 0;
  689. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  690. rrpriv->tx_skbuff[i] = 0;
  691. }
  692. rrpriv->info->tx_ctrl.entry_size = sizeof(struct tx_desc);
  693. rrpriv->info->tx_ctrl.entries = TX_RING_ENTRIES;
  694. rrpriv->info->tx_ctrl.mode = 0;
  695. rrpriv->info->tx_ctrl.pi = 0;
  696. set_rraddr(&rrpriv->info->tx_ctrl.rngptr, rrpriv->tx_ring);
  698. /*
  699.  * Set dirty_tx before we start receiving interrupts, otherwise
  700.  * the interrupt handler might think it is supposed to process
  701.  * tx ints before we are up and running, which may cause a null
  702.  * pointer access in the int handler.
  703.  */
  704. rrpriv->tx_full = 0;
  705. rrpriv->cur_rx = 0;
  706. rrpriv->dirty_rx = rrpriv->dirty_tx = 0;
  708. rr_reset(dev);
  710. /* Tuning values */
  711. writel(0x5000, &regs->ConRetry);
  712. writel(0x100, &regs->ConRetryTmr);
  713. writel(0x500000, &regs->ConTmout);
  714.   writel(0x60, &regs->IntrTmr);
  715. writel(0x500000, &regs->TxDataMvTimeout);
  716. writel(0x200000, &regs->RxDataMvTimeout);
  717.   writel(0x80, &regs->WriteDmaThresh);
  718.   writel(0x80, &regs->ReadDmaThresh);
  720. rrpriv->fw_running = 0;
  721. wmb();
  723. hostctrl &= ~(HALT_NIC | INVALID_INST_B | PARITY_ERR);
  724. writel(hostctrl, &regs->HostCtrl);
  725. wmb();
  727. spin_unlock_irqrestore(&rrpriv->lock, flags);
  729. for (i = 0; i < RX_RING_ENTRIES; i++) {
  730. struct sk_buff *skb;
  732. rrpriv->rx_ring[i].mode = 0;
  733. skb = alloc_skb(dev->mtu + HIPPI_HLEN, GFP_ATOMIC);
  734. if (!skb) {
  735. printk(KERN_WARNING "%s: Unable to allocate memory "
  736.        "for receive ring - halting NICn", dev->name);
  737. ecode = -ENOMEM;
  738. goto error;
  739. }
  740. rrpriv->rx_skbuff[i] = skb;
  741. /*
  742.  * Sanity test to see if we conflict with the DMA
  743.  * limitations of the Roadrunner.
  744.  */
  745. if ((((unsigned long)skb->data) & 0xfff) > ~65320)
  746. printk("skb alloc errorn");
  748. set_rraddr(&rrpriv->rx_ring[i].addr, skb->data);
  749. rrpriv->rx_ring[i].size = dev->mtu + HIPPI_HLEN;
  750. }
  752. rrpriv->rx_ctrl[4].entry_size = sizeof(struct rx_desc);
  753. rrpriv->rx_ctrl[4].entries = RX_RING_ENTRIES;
  754. rrpriv->rx_ctrl[4].mode = 8;
  755. rrpriv->rx_ctrl[4].pi = 0;
  756. wmb();
  757. set_rraddr(&rrpriv->rx_ctrl[4].rngptr, rrpriv->rx_ring);
  759. udelay(1000);
  761. /*
  762.  * Now start the FirmWare.
  763.  */
  764. cmd.code = C_START_FW;
  765. cmd.ring = 0;
  766. cmd.index = 0;
  768. rr_issue_cmd(rrpriv, &cmd);
  770. /*
  771.  * Give the FirmWare time to chew on the `get running' command.
  772.  */
  773. myjif = jiffies + 5 * HZ;
  774. while (time_before(jiffies, myjif) && !rrpriv->fw_running);
  776. netif_start_queue(dev);
  778. return ecode;
  780.  error:
  781. /*
  782.  * We might have gotten here because we are out of memory,
  783.  * make sure we release everything we allocated before failing
  784.  */
  785. for (i = 0; i < RX_RING_ENTRIES; i++) {
  786. if (rrpriv->rx_skbuff[i]) {
  787. rrpriv->rx_ring[i].size = 0;
  788. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  789. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  790. }
  791. }
  792. return ecode;
  793. }
  796. /*
  797.  * All events are considered to be slow (RX/TX ints do not generate
  798.  * events) and are handled here, outside the main interrupt handler,
  799.  * to reduce the size of the handler.
  800.  */
  801. static u32 rr_handle_event(struct net_device *dev, u32 prodidx, u32 eidx)
  802. {
  803. struct rr_private *rrpriv;
  804. struct rr_regs *regs;
  805. u32 tmp;
  807. rrpriv = (struct rr_private *)dev->priv;
  808. regs = rrpriv->regs;
  810. while (prodidx != eidx){
  811. switch (rrpriv->evt_ring[eidx].code){
  812. case E_NIC_UP:
  813. tmp = readl(&regs->FwRev);
  814. printk(KERN_INFO "%s: Firmware revision %i.%i.%i "
  815.        "up and runningn", dev->name,
  816.        (tmp >> 16), ((tmp >> 8) & 0xff), (tmp & 0xff));
  817. rrpriv->fw_running = 1;
  818. writel(RX_RING_ENTRIES - 1, &regs->IpRxPi);
  819. wmb();
  820. break;
  821. case E_LINK_ON:
  822. printk(KERN_INFO "%s: Optical link ONn", dev->name);
  823. break;
  824. case E_LINK_OFF:
  825. printk(KERN_INFO "%s: Optical link OFFn", dev->name);
  826. break;
  827. case E_RX_IDLE:
  828. printk(KERN_WARNING "%s: RX data not movingn",
  829.        dev->name);
  830. goto drop;
  831. case E_WATCHDOG:
  832. printk(KERN_INFO "%s: The watchdog is here to see "
  833.        "usn", dev->name);
  834. break;
  835. case E_INTERN_ERR:
  836. printk(KERN_ERR "%s: HIPPI Internal NIC errorn",
  837.        dev->name);
  838. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  839.        &regs->HostCtrl);
  840. wmb();
  841. break;
  842. case E_HOST_ERR:
  843. printk(KERN_ERR "%s: Host software errorn",
  844.        dev->name);
  845. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  846.        &regs->HostCtrl);
  847. wmb();
  848. break;
  849. /*
  850.  * TX events.
  851.  */
  852. case E_CON_REJ:
  853. printk(KERN_WARNING "%s: Connection rejectedn",
  854.        dev->name);
  855. rrpriv->stats.tx_aborted_errors++;
  856. break;
  857. case E_CON_TMOUT:
  858. printk(KERN_WARNING "%s: Connection timeoutn",
  859.        dev->name);
  860. break;
  861. case E_DISC_ERR:
  862. printk(KERN_WARNING "%s: HIPPI disconnect errorn",
  863.        dev->name);
  864. rrpriv->stats.tx_aborted_errors++;
  865. break;
  866. case E_INT_PRTY:
  867. printk(KERN_ERR "%s: HIPPI Internal Parity errorn",
  868.        dev->name);
  869. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  870.        &regs->HostCtrl);
  871. wmb();
  872. break;
  873. case E_TX_IDLE:
  874. printk(KERN_WARNING "%s: Transmitter idlen",
  875.        dev->name);
  876. break;
  877. case E_TX_LINK_DROP:
  878. printk(KERN_WARNING "%s: Link lost during transmitn",
  879.        dev->name);
  880. rrpriv->stats.tx_aborted_errors++;
  881. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  882.        &regs->HostCtrl);
  883. wmb();
  884. break;
  885. case E_TX_INV_RNG:
  886. printk(KERN_ERR "%s: Invalid send ring blockn",
  887.        dev->name);
  888. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  889.        &regs->HostCtrl);
  890. wmb();
  891. break;
  892. case E_TX_INV_BUF:
  893. printk(KERN_ERR "%s: Invalid send buffer addressn",
  894.        dev->name);
  895. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  896.        &regs->HostCtrl);
  897. wmb();
  898. break;
  899. case E_TX_INV_DSC:
  900. printk(KERN_ERR "%s: Invalid descriptor addressn",
  901.        dev->name);
  902. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  903.        &regs->HostCtrl);
  904. wmb();
  905. break;
  906. /*
  907.  * RX events.
  908.  */
  909. case E_RX_RNG_OUT:
  910. printk(KERN_INFO "%s: Receive ring fulln", dev->name);
  911. break;
  913. case E_RX_PAR_ERR:
  914. printk(KERN_WARNING "%s: Receive parity errorn",
  915.        dev->name);
  916. goto drop;
  917. case E_RX_LLRC_ERR:
  918. printk(KERN_WARNING "%s: Receive LLRC errorn",
  919.        dev->name);
  920. goto drop;
  921. case E_PKT_LN_ERR:
  922. printk(KERN_WARNING "%s: Receive packet length "
  923.        "errorn", dev->name);
  924. goto drop;
  925. case E_DTA_CKSM_ERR:
  926. printk(KERN_WARNING "%s: Data checksum errorn",
  927.        dev->name);
  928. goto drop;
  929. case E_SHT_BST:
  930. printk(KERN_WARNING "%s: Unexpected short burst "
  931.        "errorn", dev->name);
  932. goto drop;
  933. case E_STATE_ERR:
  934. printk(KERN_WARNING "%s: Recv. state transition"
  935.        " errorn", dev->name);
  936. goto drop;
  937. case E_UNEXP_DATA:
  938. printk(KERN_WARNING "%s: Unexpected data errorn",
  939.        dev->name);
  940. goto drop;
  941. case E_LST_LNK_ERR:
  942. printk(KERN_WARNING "%s: Link lost errorn",
  943.        dev->name);
  944. goto drop;
  945. case E_FRM_ERR:
  946. printk(KERN_WARNING "%s: Framming Errorn",
  947.        dev->name);
  948. goto drop;
  949. case E_FLG_SYN_ERR:
  950. printk(KERN_WARNING "%s: Flag sync. lost during"
  951.        "packetn", dev->name);
  952. goto drop;
  953. case E_RX_INV_BUF:
  954. printk(KERN_ERR "%s: Invalid receive buffer "
  955.        "addressn", dev->name);
  956. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  957.        &regs->HostCtrl);
  958. wmb();
  959. break;
  960. case E_RX_INV_DSC:
  961. printk(KERN_ERR "%s: Invalid receive descriptor "
  962.        "addressn", dev->name);
  963. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  964.        &regs->HostCtrl);
  965. wmb();
  966. break;
  967. case E_RNG_BLK:
  968. printk(KERN_ERR "%s: Invalid ring blockn",
  969.        dev->name);
  970. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  971.        &regs->HostCtrl);
  972. wmb();
  973. break;
  974. drop:
  975. /* Label packet to be dropped.
  976.  * Actual dropping occurs in rx
  977.  * handling.
  978.  *
  979.  * The index of packet we get to drop is
  980.  * the index of the packet following
  981.  * the bad packet. -kbf
  982.  */
  983. {
  984. u16 index = rrpriv->evt_ring[eidx].index;
  985. index = (index + (RX_RING_ENTRIES - 1)) %
  986. RX_RING_ENTRIES;
  987. rrpriv->rx_ring[index].mode |=
  988. (PACKET_BAD | PACKET_END);
  989. }
  990. break;
  991. default:
  992. printk(KERN_WARNING "%s: Unhandled event 0x%02xn",
  993.        dev->name, rrpriv->evt_ring[eidx].code);
  994. }
  995. eidx = (eidx + 1) % EVT_RING_ENTRIES;
  996. }
  998. rrpriv->info->evt_ctrl.pi = eidx;
  999. wmb();
  1000. return eidx;
  1001. }
  1004. static void rx_int(struct net_device *dev, u32 rxlimit, u32 index)
  1005. {
  1006. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1007. struct rr_regs *regs = rrpriv->regs;
  1009. do {
  1010. u32 pkt_len;
  1011. pkt_len = rrpriv->rx_ring[index].size;
  1012. #if (DEBUG > 2)
  1013. printk("index %i, rxlimit %in", index, rxlimit);
  1014. printk("len %x, mode %xn", pkt_len,
  1015.        rrpriv->rx_ring[index].mode);
  1016. #endif
  1017. if ( (rrpriv->rx_ring[index].mode & PACKET_BAD) == PACKET_BAD){
  1018. rrpriv->stats.rx_dropped++;
  1019. goto defer;
  1020. }
  1022. if (pkt_len > 0){
  1023. struct sk_buff *skb;
  1025. if (pkt_len < PKT_COPY_THRESHOLD) {
  1026. skb = alloc_skb(pkt_len, GFP_ATOMIC);
  1027. if (skb == NULL){
  1028. printk(KERN_WARNING "%s: Unable to allocate skb (%i bytes), deferring packetn", dev->name, pkt_len);
  1029. rrpriv->stats.rx_dropped++;
  1030. goto defer;
  1031. }else
  1032. memcpy(skb_put(skb, pkt_len),
  1033.        rrpriv->rx_skbuff[index]->data,
  1034.        pkt_len);
  1035. }else{
  1036. struct sk_buff *newskb;
  1038. newskb = alloc_skb(dev->mtu + HIPPI_HLEN,
  1039.    GFP_ATOMIC);
  1040. if (newskb){
  1041. skb = rrpriv->rx_skbuff[index];
  1042. skb_put(skb, pkt_len);
  1043. rrpriv->rx_skbuff[index] = newskb;
  1044. set_rraddr(&rrpriv->rx_ring[index].addr, newskb->data);
  1045. }else{
  1046. printk("%s: Out of memory, deferring "
  1047.        "packetn", dev->name);
  1048. rrpriv->stats.rx_dropped++;
  1049. goto defer;
  1050. }
  1051. }
  1052. skb->dev = dev;
  1053. skb->protocol = hippi_type_trans(skb, dev);
  1055. netif_rx(skb); /* send it up */
  1057. dev->last_rx = jiffies;
  1058. rrpriv->stats.rx_packets++;
  1059. rrpriv->stats.rx_bytes += pkt_len;
  1060. }
  1061. defer:
  1062. rrpriv->rx_ring[index].mode = 0;
  1063. rrpriv->rx_ring[index].size = dev->mtu + HIPPI_HLEN;
  1065. if ((index & 7) == 7)
  1066. writel(index, &regs->IpRxPi);
  1068. index = (index + 1) % RX_RING_ENTRIES;
  1069. } while(index != rxlimit);
  1071. rrpriv->cur_rx = index;
  1072. wmb();
  1073. }
  1076. static void rr_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
  1077. {
  1078. struct rr_private *rrpriv;
  1079. struct rr_regs *regs;
  1080. struct net_device *dev = (struct net_device *)dev_id;
  1081. u32 prodidx, rxindex, eidx, txcsmr, rxlimit, txcon;
  1083. rrpriv = (struct rr_private *)dev->priv;
  1084. regs = rrpriv->regs;
  1086. if (!(readl(&regs->HostCtrl) & RR_INT))
  1087. return;
  1089. spin_lock(&rrpriv->lock);
  1091. prodidx = readl(&regs->EvtPrd);
  1092. txcsmr = (prodidx >> 8) & 0xff;
  1093. rxlimit = (prodidx >> 16) & 0xff;
  1094. prodidx &= 0xff;
  1096. #if (DEBUG > 2)
  1097. printk("%s: interrupt, prodidx = %i, eidx = %in", dev->name,
  1098.        prodidx, rrpriv->info->evt_ctrl.pi);
  1099. #endif
  1100. /*
  1101.  * Order here is important.  We must handle events
  1102.  * before doing anything else in order to catch
  1103.  * such things as LLRC errors, etc -kbf
  1104.  */
  1106. eidx = rrpriv->info->evt_ctrl.pi;
  1107. if (prodidx != eidx)
  1108. eidx = rr_handle_event(dev, prodidx, eidx);
  1110. rxindex = rrpriv->cur_rx;
  1111. if (rxindex != rxlimit)
  1112. rx_int(dev, rxlimit, rxindex);
  1114. txcon = rrpriv->dirty_tx;
  1115. if (txcsmr != txcon) {
  1116. do {
  1117. /* Due to occational firmware TX producer/consumer out
  1118.  * of sync. error need to check entry in ring -kbf
  1119.  */
  1120. if(rrpriv->tx_skbuff[txcon]){
  1121. rrpriv->stats.tx_packets++;
  1122. rrpriv->stats.tx_bytes +=rrpriv->tx_skbuff[txcon]->len;
  1123. dev_kfree_skb_irq(rrpriv->tx_skbuff[txcon]);
  1125. rrpriv->tx_skbuff[txcon] = NULL;
  1126. rrpriv->tx_ring[txcon].size = 0;
  1127. set_rraddr(&rrpriv->tx_ring[txcon].addr, 0);
  1128. rrpriv->tx_ring[txcon].mode = 0;
  1129. }
  1130. txcon = (txcon + 1) % TX_RING_ENTRIES;
  1131. } while (txcsmr != txcon);
  1132. wmb();
  1134. rrpriv->dirty_tx = txcon;
  1135. if (rrpriv->tx_full && rr_if_busy(dev) &&
  1136.     (((rrpriv->info->tx_ctrl.pi + 1) % TX_RING_ENTRIES)
  1137.      != rrpriv->dirty_tx)){
  1138. rrpriv->tx_full = 0;
  1139. netif_wake_queue(dev);
  1140. rr_mark_net_bh(NET_BH);
  1141. }
  1142. }
  1144. eidx |= ((txcsmr << 8) | (rxlimit << 16));
  1145. writel(eidx, &regs->EvtCon);
  1146. wmb();
  1148. spin_unlock(&rrpriv->lock);
  1149. }
  1152. static void rr_timer(unsigned long data)
  1153. {
  1154. struct net_device *dev = (struct net_device *)data;
  1155. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1156. struct rr_regs *regs = rrpriv->regs;
  1157. unsigned long flags;
  1158. int i;
  1160. if (readl(&regs->HostCtrl) & NIC_HALTED){
  1161. printk("%s: Restarting nicn", dev->name);
  1162. memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
  1163. memset(rrpriv->info, 0, sizeof(struct rr_info));
  1164. wmb();
  1165. for (i = 0; i < TX_RING_ENTRIES; i++) {
  1166. if (rrpriv->tx_skbuff[i]) {
  1167. rrpriv->tx_ring[i].size = 0;
  1168. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  1169. dev_kfree_skb(rrpriv->tx_skbuff[i]);
  1170. rrpriv->tx_skbuff[i] = NULL;
  1171. }
  1172. }
  1174. for (i = 0; i < RX_RING_ENTRIES; i++) {
  1175. if (rrpriv->rx_skbuff[i]) {
  1176. rrpriv->rx_ring[i].size = 0;
  1177. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  1178. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  1179. rrpriv->rx_skbuff[i] = NULL;
  1180. }
  1181. }
  1182. if (rr_init1(dev)) {
  1183. spin_lock_irqsave(&rrpriv->lock, flags);
  1184. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  1185.        &regs->HostCtrl);
  1186. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1187. }
  1188. }
  1189. rrpriv->timer.expires = RUN_AT(5*HZ);
  1190. add_timer(&rrpriv->timer);
  1191. }
  1194. static int rr_open(struct net_device *dev)
  1195. {
  1196. struct rr_private *rrpriv;
  1197. struct rr_regs *regs;
  1198. int ecode = 0;
  1199. unsigned long flags;
  1201. rrpriv = (struct rr_private *)dev->priv;
  1202. regs = rrpriv->regs;
  1204. if (rrpriv->fw_rev < 0x00020000) {
  1205. printk(KERN_WARNING "%s: trying to configure device with "
  1206.        "obsolete firmwaren", dev->name);
  1207. ecode = -EBUSY;
  1208. goto error;
  1209. }
  1211. rrpriv->rx_ctrl = kmalloc(256*sizeof(struct ring_ctrl), GFP_KERNEL);
  1212. if (!rrpriv->rx_ctrl) {
  1213. ecode = -ENOMEM;
  1214. goto error;
  1215. }
  1217. rrpriv->info = kmalloc(sizeof(struct rr_info), GFP_KERNEL);
  1218. if (!rrpriv->info){
  1219. rrpriv->rx_ctrl = NULL;
  1220. ecode = -ENOMEM;
  1221. goto error;
  1222. }
  1223. memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
  1224. memset(rrpriv->info, 0, sizeof(struct rr_info));
  1225. wmb();
  1227. spin_lock_irqsave(&rrpriv->lock, flags);
  1228. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
  1229. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1231. if (request_irq(dev->irq, rr_interrupt, SA_SHIRQ, rrpriv->name, dev))
  1232. {
  1233. printk(KERN_WARNING "%s: Requested IRQ %d is busyn",
  1234.        dev->name, dev->irq);
  1235. ecode = -EAGAIN;
  1236. goto error;
  1237. }
  1239. if ((ecode = rr_init1(dev)))
  1240. goto error;
  1242. /* Set the timer to switch to check for link beat and perhaps switch
  1243.    to an alternate media type. */
  1244. init_timer(&rrpriv->timer);
  1245. rrpriv->timer.expires = RUN_AT(5*HZ);           /* 5 sec. watchdog */
  1246. rrpriv->timer.data = (unsigned long)dev;
  1247. rrpriv->timer.function = &rr_timer;               /* timer handler */
  1248. add_timer(&rrpriv->timer);
  1250. netif_start_queue(dev);
  1252. return ecode;
  1254.  error:
  1255. spin_lock_irqsave(&rrpriv->lock, flags);
  1256. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
  1257. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1259. if (rrpriv->info) {
  1260. kfree(rrpriv->info);
  1261. rrpriv->info = NULL;
  1262. }
  1263. if (rrpriv->rx_ctrl) {
  1264. kfree(rrpriv->rx_ctrl);
  1265. rrpriv->rx_ctrl = NULL;
  1266. }
  1268. netif_stop_queue(dev);
  1269. rr_if_down(dev);
  1271. return ecode;
  1272. }
  1275. static void rr_dump(struct net_device *dev)
  1276. {
  1277. struct rr_private *rrpriv;
  1278. struct rr_regs *regs;
  1279. u32 index, cons;
  1280. short i;
  1281. int len;
  1283. rrpriv = (struct rr_private *)dev->priv;
  1284. regs = rrpriv->regs;
  1286. printk("%s: dumping NIC TX ringsn", dev->name);
  1288. printk("RxPrd %08x, TxPrd %02x, EvtPrd %08x, TxPi %02x, TxCtrlPi %02xn",
  1289.        readl(&regs->RxPrd), readl(&regs->TxPrd),
  1290.        readl(&regs->EvtPrd), readl(&regs->TxPi),
  1291.        rrpriv->info->tx_ctrl.pi);
  1293. printk("Error code 0x%xn", readl(&regs->Fail1));
  1295. index = (((readl(&regs->EvtPrd) >> 8) & 0xff ) - 1) % EVT_RING_ENTRIES;
  1296. cons = rrpriv->dirty_tx;
  1297. printk("TX ring index %i, TX consumer %in",
  1298.        index, cons);
  1300. if (rrpriv->tx_skbuff[index]){
  1301. len = min_t(int, 0x80, rrpriv->tx_skbuff[index]->len);
  1302. printk("skbuff for index %i is valid - dumping data (0x%x bytes - DMA len 0x%x)n", index, len, rrpriv->tx_ring[index].size);
  1303. for (i = 0; i < len; i++){
  1304. if (!(i & 7))
  1305. printk("n");
  1306. printk("%02x ", (unsigned char) rrpriv->tx_skbuff[index]->data[i]);
  1307. }
  1308. printk("n");
  1309. }
  1311. if (rrpriv->tx_skbuff[cons]){
  1312. len = min_t(int, 0x80, rrpriv->tx_skbuff[cons]->len);
  1313. printk("skbuff for cons %i is valid - dumping data (0x%x bytes - skbuff len 0x%x)n", cons, len, rrpriv->tx_skbuff[cons]->len);
  1314. printk("mode 0x%x, size 0x%x,n phys %08x (virt %08lx), skbuff-addr %08lx, truesize 0x%xn",
  1315.        rrpriv->tx_ring[cons].mode,
  1316.        rrpriv->tx_ring[cons].size,
  1317.        rrpriv->tx_ring[cons].addr.addrlo,
  1318.        (unsigned long)bus_to_virt(rrpriv->tx_ring[cons].addr.addrlo),
  1319.        (unsigned long)rrpriv->tx_skbuff[cons]->data,
  1320.        (unsigned int)rrpriv->tx_skbuff[cons]->truesize);
  1321. for (i = 0; i < len; i++){
  1322. if (!(i & 7))
  1323. printk("n");
  1324. printk("%02x ", (unsigned char)rrpriv->tx_ring[cons].size);
  1325. }
  1326. printk("n");
  1327. }
  1329. printk("dumping TX ring info:n");
  1330. for (i = 0; i < TX_RING_ENTRIES; i++)
  1331. printk("mode 0x%x, size 0x%x, phys-addr %08xn",
  1332.        rrpriv->tx_ring[i].mode,
  1333.        rrpriv->tx_ring[i].size,
  1334.        rrpriv->tx_ring[i].addr.addrlo);
  1336. }
  1339. static int rr_close(struct net_device *dev)
  1340. {
  1341. struct rr_private *rrpriv;
  1342. struct rr_regs *regs;
  1343. u32 tmp;
  1344. short i;
  1346. netif_stop_queue(dev);
  1347. rr_if_down(dev);
  1349. rrpriv = (struct rr_private *)dev->priv;
  1350. regs = rrpriv->regs;
  1352. /*
  1353.  * Lock to make sure we are not cleaning up while another CPU
  1354.  * handling interrupts.
  1355.  */
  1356. spin_lock(&rrpriv->lock);
  1358. tmp = readl(&regs->HostCtrl);
  1359. if (tmp & NIC_HALTED){
  1360. printk("%s: NIC already haltedn", dev->name);
  1361. rr_dump(dev);
  1362. }else{
  1363. tmp |= HALT_NIC | RR_CLEAR_INT;
  1364. writel(tmp, &regs->HostCtrl);
  1365. wmb();
  1366. }
  1368. rrpriv->fw_running = 0;
  1370. del_timer(&rrpriv->timer);
  1372. writel(0, &regs->TxPi);
  1373. writel(0, &regs->IpRxPi);
  1375. writel(0, &regs->EvtCon);
  1376. writel(0, &regs->EvtPrd);
  1378. for (i = 0; i < CMD_RING_ENTRIES; i++)
  1379. writel(0, &regs->CmdRing[i]);
  1381. rrpriv->info->tx_ctrl.entries = 0;
  1382. rrpriv->info->cmd_ctrl.pi = 0;
  1383. rrpriv->info->evt_ctrl.pi = 0;
  1384. rrpriv->rx_ctrl[4].entries = 0;
  1386. for (i = 0; i < TX_RING_ENTRIES; i++) {
  1387. if (rrpriv->tx_skbuff[i]) {
  1388. rrpriv->tx_ring[i].size = 0;
  1389. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  1390. dev_kfree_skb(rrpriv->tx_skbuff[i]);
  1391. rrpriv->tx_skbuff[i] = NULL;
  1392. }
  1393. }
  1395. for (i = 0; i < RX_RING_ENTRIES; i++) {
  1396. if (rrpriv->rx_skbuff[i]) {
  1397. rrpriv->rx_ring[i].size = 0;
  1398. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  1399. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  1400. rrpriv->rx_skbuff[i] = NULL;
  1401. }
  1402. }
  1404. if (rrpriv->rx_ctrl) {
  1405. kfree(rrpriv->rx_ctrl);
  1406. rrpriv->rx_ctrl = NULL;
  1407. }
  1408. if (rrpriv->info) {
  1409. kfree(rrpriv->info);
  1410. rrpriv->info = NULL;
  1411. }
  1413. free_irq(dev->irq, dev);
  1414. spin_unlock(&rrpriv->lock);
  1416. return 0;
  1417. }
  1420. static int rr_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1421. {
  1422. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1423. struct rr_regs *regs = rrpriv->regs;
  1424. struct ring_ctrl *txctrl;
  1425. unsigned long flags;
  1426. u32 index, len = skb->len;
  1427. u32 *ifield;
  1428. struct sk_buff *new_skb;
  1430. if (readl(&regs->Mode) & FATAL_ERR)
  1431. printk("error codes Fail1 %02x, Fail2 %02xn",
  1432.        readl(&regs->Fail1), readl(&regs->Fail2));
  1434. /*
  1435.  * We probably need to deal with tbusy here to prevent overruns.
  1436.  */
  1438. if (skb_headroom(skb) < 8){
  1439. printk("incoming skb too small - reallocatingn");
  1440. if (!(new_skb = dev_alloc_skb(len + 8))) {
  1441. dev_kfree_skb(skb);
  1442. netif_wake_queue(dev);
  1443. return -EBUSY;
  1444. }
  1445. skb_reserve(new_skb, 8);
  1446. skb_put(new_skb, len);
  1447. memcpy(new_skb->data, skb->data, len);
  1448. dev_kfree_skb(skb);
  1449. skb = new_skb;
  1450. }
  1452. ifield = (u32 *)skb_push(skb, 8);
  1454. ifield[0] = 0;
  1455. ifield[1] = skb->private.ifield;
  1457. /*
  1458.  * We don't need the lock before we are actually going to start
  1459.  * fiddling with the control blocks.
  1460.  */
  1461. spin_lock_irqsave(&rrpriv->lock, flags);
  1463. txctrl = &rrpriv->info->tx_ctrl;
  1465. index = txctrl->pi;
  1467. rrpriv->tx_skbuff[index] = skb;
  1468. set_rraddr(&rrpriv->tx_ring[index].addr, skb->data);
  1469. rrpriv->tx_ring[index].size = len + 8; /* include IFIELD */
  1470. rrpriv->tx_ring[index].mode = PACKET_START | PACKET_END;
  1471. txctrl->pi = (index + 1) % TX_RING_ENTRIES;
  1472. wmb();
  1473. writel(txctrl->pi, &regs->TxPi);
  1475. if (txctrl->pi == rrpriv->dirty_tx){
  1476. rrpriv->tx_full = 1;
  1477. netif_stop_queue(dev);
  1478. }
  1480. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1482. dev->trans_start = jiffies;
  1483. return 0;
  1484. }
  1487. static struct net_device_stats *rr_get_stats(struct net_device *dev)
  1488. {
  1489. struct rr_private *rrpriv;
  1491. rrpriv = (struct rr_private *)dev->priv;
  1493. return(&rrpriv->stats);
  1494. }
  1497. /*
  1498.  * Read the firmware out of the EEPROM and put it into the SRAM
  1499.  * (or from user space - later)
  1500.  *
  1501.  * This operation requires the NIC to be halted and is performed with
  1502.  * interrupts disabled and with the spinlock hold.
  1503.  */
  1504. static int rr_load_firmware(struct net_device *dev)
  1505. {
  1506. struct rr_private *rrpriv;
  1507. struct rr_regs *regs;
  1508. unsigned long eptr, segptr;
  1509. int i, j;
  1510. u32 localctrl, sptr, len, tmp;
  1511. u32 p2len, p2size, nr_seg, revision, io, sram_size;
  1512. struct eeprom *hw = NULL;
  1514. rrpriv = (struct rr_private *)dev->priv;
  1515. regs = rrpriv->regs;
  1517. if (dev->flags & IFF_UP)
  1518. return -EBUSY;
  1520. if (!(readl(&regs->HostCtrl) & NIC_HALTED)){
  1521. printk("%s: Trying to load firmware to a running NIC.n", 
  1522.        dev->name);
  1523. return -EBUSY;
  1524. }
  1526. localctrl = readl(&regs->LocalCtrl);
  1527. writel(0, &regs->LocalCtrl);
  1529. writel(0, &regs->EvtPrd);
  1530. writel(0, &regs->RxPrd);
  1531. writel(0, &regs->TxPrd);
  1533. /*
  1534.  * First wipe the entire SRAM, otherwise we might run into all
  1535.  * kinds of trouble ... sigh, this took almost all afternoon
  1536.  * to track down ;-(
  1537.  */
  1538. io = readl(&regs->ExtIo);
  1539. writel(0, &regs->ExtIo);
  1540. sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
  1542. for (i = 200; i < sram_size / 4; i++){
  1543. writel(i * 4, &regs->WinBase);
  1544. mb();
  1545. writel(0, &regs->WinData);
  1546. mb();
  1547. }
  1548. writel(io, &regs->ExtIo);
  1549. mb();
  1551. eptr = (unsigned long)rr_read_eeprom_word(rrpriv,
  1552.        &hw->rncd_info.AddrRunCodeSegs);
  1553. eptr = ((eptr & 0x1fffff) >> 3);
  1555. p2len = rr_read_eeprom_word(rrpriv, (void *)(0x83*4));
  1556. p2len = (p2len << 2);
  1557. p2size = rr_read_eeprom_word(rrpriv, (void *)(0x84*4));
  1558. p2size = ((p2size & 0x1fffff) >> 3);
  1560. if ((eptr < p2size) || (eptr > (p2size + p2len))){
  1561. printk("%s: eptr is invalidn", dev->name);
  1562. goto out;
  1563. }
  1565. revision = rr_read_eeprom_word(rrpriv, &hw->manf.HeaderFmt);
  1567. if (revision != 1){
  1568. printk("%s: invalid firmware format (%i)n",
  1569.        dev->name, revision);
  1570. goto out;
  1571. }
  1573. nr_seg = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1574. eptr +=4;
  1575. #if (DEBUG > 1)
  1576. printk("%s: nr_seg %in", dev->name, nr_seg);
  1577. #endif
  1579. for (i = 0; i < nr_seg; i++){
  1580. sptr = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1581. eptr += 4;
  1582. len = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1583. eptr += 4;
  1584. segptr = (unsigned long)rr_read_eeprom_word(rrpriv, (void *)eptr);
  1585. segptr = ((segptr & 0x1fffff) >> 3);
  1586. eptr += 4;
  1587. #if (DEBUG > 1)
  1588. printk("%s: segment %i, sram address %06x, length %04x, segptr %06xn",
  1589.        dev->name, i, sptr, len, segptr);
  1590. #endif
  1591. for (j = 0; j < len; j++){
  1592. tmp = rr_read_eeprom_word(rrpriv, (void *)segptr);
  1593. writel(sptr, &regs->WinBase);
  1594. mb();
  1595. writel(tmp, &regs->WinData);
  1596. mb();
  1597. segptr += 4;
  1598. sptr += 4;
  1599. }
  1600. }
  1602. out:
  1603. writel(localctrl, &regs->LocalCtrl);
  1604. mb();
  1605. return 0;
  1606. }
  1609. static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1610. {
  1611. struct rr_private *rrpriv;
  1612. unsigned char *image, *oldimage;
  1613. unsigned int i;
  1614. int error = -EOPNOTSUPP;
  1616. rrpriv = dev->priv;
  1618. switch(cmd){
  1619. case SIOCRRGFW:
  1620. if (!capable(CAP_SYS_RAWIO)){
  1621. return -EPERM;
  1622. }
  1624. image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1625. if (!image){
  1626. printk(KERN_ERR "%s: Unable to allocate memory "
  1627.        "for EEPROM imagen", dev->name);
  1628. return -ENOMEM;
  1629. }
  1631. spin_lock(&rrpriv->lock);
  1633. if (rrpriv->fw_running){
  1634. printk("%s: Firmware already runningn", dev->name);
  1635. error = -EPERM;
  1636. goto out_spin;
  1637. }
  1639. i = rr_read_eeprom(rrpriv, 0, image, EEPROM_BYTES);
  1640. if (i != EEPROM_BYTES){
  1641. printk(KERN_ERR "%s: Error reading EEPROMn", dev->name);
  1642. error = -EFAULT;
  1643. goto out_spin;
  1644. }
  1645. spin_unlock(&rrpriv->lock);
  1646. error = copy_to_user(rq->ifr_data, image, EEPROM_BYTES);
  1647. if (error)
  1648. error = -EFAULT;
  1649. kfree(image);
  1650. return error;
  1652. case SIOCRRPFW:
  1653. if (!capable(CAP_SYS_RAWIO)){
  1654. return -EPERM;
  1655. }
  1657. image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1658. if (!image){
  1659. printk(KERN_ERR "%s: Unable to allocate memory "
  1660.        "for EEPROM imagen", dev->name);
  1661. return -ENOMEM;
  1662. }
  1664. oldimage = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1665. if (!oldimage){
  1666. kfree(image);
  1667. printk(KERN_ERR "%s: Unable to allocate memory "
  1668.        "for old EEPROM imagen", dev->name);
  1669. return -ENOMEM;
  1670. }
  1672. error = copy_from_user(image, rq->ifr_data, EEPROM_BYTES);
  1673. if (error) {
  1674. kfree(image);
  1675. kfree(oldimage);
  1676. return -EFAULT;
  1677. }
  1679. spin_lock(&rrpriv->lock);
  1680. if (rrpriv->fw_running){
  1681. kfree(oldimage);
  1682. printk("%s: Firmware already runningn", dev->name);
  1683. error = -EPERM;
  1684. goto out_spin;
  1685. }
  1687. printk("%s: Updating EEPROM firmwaren", dev->name);
  1689. error = write_eeprom(rrpriv, 0, image, EEPROM_BYTES);
  1690. if (error)
  1691. printk(KERN_ERR "%s: Error writing EEPROMn",
  1692.        dev->name);
  1694. i = rr_read_eeprom(rrpriv, 0, oldimage, EEPROM_BYTES);
  1695. if (i != EEPROM_BYTES)
  1696. printk(KERN_ERR "%s: Error reading back EEPROM "
  1697.        "imagen", dev->name);
  1699. spin_unlock(&rrpriv->lock);
  1700. error = memcmp(image, oldimage, EEPROM_BYTES);
  1701. if (error){
  1702. printk(KERN_ERR "%s: Error verifying EEPROM imagen",
  1703.        dev->name);
  1704. error = -EFAULT;
  1705. }
  1706. kfree(image);
  1707. kfree(oldimage);
  1708. return error;
  1710. case SIOCRRID:
  1711. return put_user(0x52523032, (int *)(&rq->ifr_data[0]));
  1712. default:
  1713. return error;
  1714. }
  1716.  out_spin:
  1717. kfree(image);
  1718. spin_unlock(&rrpriv->lock);
  1719. return error;
  1720. }
  1723. /*
  1724.  * Local variables:
  1725.  * compile-command: "gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -pipe -fomit-frame-pointer -fno-strength-reduce -m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h -c rrunner.c"
  1726.  * End:
  1727.  */