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

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

嵌入式Linux

开发平台：

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. #endif
  274. int init_module(void)
  275. {
  276. int cards;
  278. root_dev = NULL;
  280. #ifdef NEW_NETINIT
  281. cards = rr_hippi_probe();
  282. #else
  283. cards = rr_hippi_probe(NULL);
  284. #endif
  285. return cards ? 0 : -ENODEV;
  286. }
  288. void cleanup_module(void)
  289. {
  290. struct rr_private *rr;
  291. struct net_device *next;
  293. while (root_dev) {
  294. next = ((struct rr_private *)root_dev->priv)->next;
  295. rr = (struct rr_private *)root_dev->priv;
  297. if (!(readl(&rr->regs->HostCtrl) & NIC_HALTED)){
  298. printk(KERN_ERR "%s: trying to unload running NICn",
  299.        root_dev->name);
  300. writel(HALT_NIC, &rr->regs->HostCtrl);
  301. }
  303. iounmap(rr->regs);
  304. unregister_hipdev(root_dev);
  305. kfree(root_dev);
  307. root_dev = next;
  308. }
  309. }
  310. #endif
  313. /*
  314.  * Commands are considered to be slow, thus there is no reason to
  315.  * inline this.
  316.  */
  317. static void rr_issue_cmd(struct rr_private *rrpriv, struct cmd *cmd)
  318. {
  319. struct rr_regs *regs;
  320. u32 idx;
  322. regs = rrpriv->regs;
  323. /*
  324.  * This is temporary - it will go away in the final version.
  325.  * We probably also want to make this function inline.
  326.  */
  327. if (readl(&regs->HostCtrl) & NIC_HALTED){
  328. printk("issuing command for halted NIC, code 0x%x, "
  329.        "HostCtrl %08xn", cmd->code, readl(&regs->HostCtrl));
  330. if (readl(&regs->Mode) & FATAL_ERR)
  331. printk("error codes Fail1 %02x, Fail2 %02xn",
  332.        readl(&regs->Fail1), readl(&regs->Fail2));
  333. }
  335. idx = rrpriv->info->cmd_ctrl.pi;
  337. writel(*(u32*)(cmd), &regs->CmdRing[idx]);
  338. wmb();
  340. idx = (idx - 1) % CMD_RING_ENTRIES;
  341. rrpriv->info->cmd_ctrl.pi = idx;
  342. wmb();
  344. if (readl(&regs->Mode) & FATAL_ERR)
  345. printk("error code %02xn", readl(&regs->Fail1));
  346. }
  349. /*
  350.  * Reset the board in a sensible manner. The NIC is already halted
  351.  * when we get here and a spin-lock is held.
  352.  */
  353. static int rr_reset(struct net_device *dev)
  354. {
  355. struct rr_private *rrpriv;
  356. struct rr_regs *regs;
  357. struct eeprom *hw = NULL;
  358. u32 start_pc;
  359. int i;
  361. rrpriv = (struct rr_private *)dev->priv;
  362. regs = rrpriv->regs;
  364. rr_load_firmware(dev);
  366. writel(0x01000000, &regs->TX_state);
  367. writel(0xff800000, &regs->RX_state);
  368. writel(0, &regs->AssistState);
  369. writel(CLEAR_INTA, &regs->LocalCtrl);
  370. writel(0x01, &regs->BrkPt);
  371. writel(0, &regs->Timer);
  372. writel(0, &regs->TimerRef);
  373. writel(RESET_DMA, &regs->DmaReadState);
  374. writel(RESET_DMA, &regs->DmaWriteState);
  375. writel(0, &regs->DmaWriteHostHi);
  376. writel(0, &regs->DmaWriteHostLo);
  377. writel(0, &regs->DmaReadHostHi);
  378. writel(0, &regs->DmaReadHostLo);
  379. writel(0, &regs->DmaReadLen);
  380. writel(0, &regs->DmaWriteLen);
  381. writel(0, &regs->DmaWriteLcl);
  382. writel(0, &regs->DmaWriteIPchecksum);
  383. writel(0, &regs->DmaReadLcl);
  384. writel(0, &regs->DmaReadIPchecksum);
  385. writel(0, &regs->PciState);
  386. #if (BITS_PER_LONG == 64) && defined __LITTLE_ENDIAN
  387. writel(SWAP_DATA | PTR64BIT | PTR_WD_SWAP, &regs->Mode);
  388. #elif (BITS_PER_LONG == 64)
  389. writel(SWAP_DATA | PTR64BIT | PTR_WD_NOSWAP, &regs->Mode);
  390. #else
  391. writel(SWAP_DATA | PTR32BIT | PTR_WD_NOSWAP, &regs->Mode);
  392. #endif
  394. #if 0
  395. /*
  396.  * Don't worry, this is just black magic.
  397.  */
  398. writel(0xdf000, &regs->RxBase);
  399. writel(0xdf000, &regs->RxPrd);
  400. writel(0xdf000, &regs->RxCon);
  401. writel(0xce000, &regs->TxBase);
  402. writel(0xce000, &regs->TxPrd);
  403. writel(0xce000, &regs->TxCon);
  404. writel(0, &regs->RxIndPro);
  405. writel(0, &regs->RxIndCon);
  406. writel(0, &regs->RxIndRef);
  407. writel(0, &regs->TxIndPro);
  408. writel(0, &regs->TxIndCon);
  409. writel(0, &regs->TxIndRef);
  410. writel(0xcc000, &regs->pad10[0]);
  411. writel(0, &regs->DrCmndPro);
  412. writel(0, &regs->DrCmndCon);
  413. writel(0, &regs->DwCmndPro);
  414. writel(0, &regs->DwCmndCon);
  415. writel(0, &regs->DwCmndRef);
  416. writel(0, &regs->DrDataPro);
  417. writel(0, &regs->DrDataCon);
  418. writel(0, &regs->DrDataRef);
  419. writel(0, &regs->DwDataPro);
  420. writel(0, &regs->DwDataCon);
  421. writel(0, &regs->DwDataRef);
  422. #endif
  424. writel(0xffffffff, &regs->MbEvent);
  425. writel(0, &regs->Event);
  427. writel(0, &regs->TxPi);
  428. writel(0, &regs->IpRxPi);
  430. writel(0, &regs->EvtCon);
  431. writel(0, &regs->EvtPrd);
  433. rrpriv->info->evt_ctrl.pi = 0;
  435. for (i = 0; i < CMD_RING_ENTRIES; i++)
  436. writel(0, &regs->CmdRing[i]);
  438. /*
  439.  * Why 32 ? is this not cache line size dependant?
  440.  */
  441. writel(RBURST_64|WBURST_64, &regs->PciState);
  442. wmb();
  444. start_pc = rr_read_eeprom_word(rrpriv, &hw->rncd_info.FwStart);
  446. #if (DEBUG > 1)
  447. printk("%s: Executing firmware at address 0x%06xn",
  448.        dev->name, start_pc);
  449. #endif
  451. writel(start_pc + 0x800, &regs->Pc);
  452. wmb();
  453. udelay(5);
  455. writel(start_pc, &regs->Pc);
  456. wmb();
  458. return 0;
  459. }
  462. /*
  463.  * Read a string from the EEPROM.
  464.  */
  465. static unsigned int rr_read_eeprom(struct rr_private *rrpriv,
  466. unsigned long offset,
  467. unsigned char *buf,
  468. unsigned long length)
  469. {
  470. struct rr_regs *regs = rrpriv->regs;
  471. u32 misc, io, host, i;
  473. io = readl(&regs->ExtIo);
  474. writel(0, &regs->ExtIo);
  475. misc = readl(&regs->LocalCtrl);
  476. writel(0, &regs->LocalCtrl);
  477. host = readl(&regs->HostCtrl);
  478. writel(host | HALT_NIC, &regs->HostCtrl);
  479. mb();
  481. for (i = 0; i < length; i++){
  482. writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
  483. mb();
  484. buf[i] = (readl(&regs->WinData) >> 24) & 0xff;
  485. mb();
  486. }
  488. writel(host, &regs->HostCtrl);
  489. writel(misc, &regs->LocalCtrl);
  490. writel(io, &regs->ExtIo);
  491. mb();
  492. return i;
  493. }
  496. /*
  497.  * Shortcut to read one word (4 bytes) out of the EEPROM and convert
  498.  * it to our CPU byte-order.
  499.  */
  500. static u32 rr_read_eeprom_word(struct rr_private *rrpriv,
  501.     void * offset)
  502. {
  503. u32 word;
  505. if ((rr_read_eeprom(rrpriv, (unsigned long)offset,
  506.     (char *)&word, 4) == 4))
  507. return be32_to_cpu(word);
  508. return 0;
  509. }
  512. /*
  513.  * Write a string to the EEPROM.
  514.  *
  515.  * This is only called when the firmware is not running.
  516.  */
  517. static unsigned int write_eeprom(struct rr_private *rrpriv,
  518.  unsigned long offset,
  519.  unsigned char *buf,
  520.  unsigned long length)
  521. {
  522. struct rr_regs *regs = rrpriv->regs;
  523. u32 misc, io, data, i, j, ready, error = 0;
  525. io = readl(&regs->ExtIo);
  526. writel(0, &regs->ExtIo);
  527. misc = readl(&regs->LocalCtrl);
  528. writel(ENABLE_EEPROM_WRITE, &regs->LocalCtrl);
  529. mb();
  531. for (i = 0; i < length; i++){
  532. writel((EEPROM_BASE + ((offset+i) << 3)), &regs->WinBase);
  533. mb();
  534. data = buf[i] << 24;
  535. /*
  536.  * Only try to write the data if it is not the same
  537.  * value already.
  538.  */
  539. if ((readl(&regs->WinData) & 0xff000000) != data){
  540. writel(data, &regs->WinData);
  541. ready = 0;
  542. j = 0;
  543. mb();
  544. while(!ready){
  545. udelay(20);
  546. if ((readl(&regs->WinData) & 0xff000000) ==
  547.     data)
  548. ready = 1;
  549. mb();
  550. if (j++ > 5000){
  551. printk("data mismatch: %08x, "
  552.        "WinData %08xn", data,
  553.        readl(&regs->WinData));
  554. ready = 1;
  555. error = 1;
  556. }
  557. }
  558. }
  559. }
  561. writel(misc, &regs->LocalCtrl);
  562. writel(io, &regs->ExtIo);
  563. mb();
  565. return error;
  566. }
  569. static int __init rr_init(struct net_device *dev)
  570. {
  571. struct rr_private *rrpriv;
  572. struct rr_regs *regs;
  573. struct eeprom *hw = NULL;
  574. u32 sram_size, rev;
  575. int i;
  577. rrpriv = (struct rr_private *)dev->priv;
  578. regs = rrpriv->regs;
  580. rev = readl(&regs->FwRev);
  581. rrpriv->fw_rev = rev;
  582. if (rev > 0x00020024)
  583. printk("  Firmware revision: %i.%i.%in", (rev >> 16),
  584.        ((rev >> 8) & 0xff), (rev & 0xff));
  585. else if (rev >= 0x00020000) {
  586. printk("  Firmware revision: %i.%i.%i (2.0.37 or "
  587.        "later is recommended)n", (rev >> 16),
  588.        ((rev >> 8) & 0xff), (rev & 0xff));
  589. }else{
  590. printk("  Firmware revision too old: %i.%i.%i, please "
  591.        "upgrade to 2.0.37 or later.n",
  592.        (rev >> 16), ((rev >> 8) & 0xff), (rev & 0xff));
  593. }
  595. #if (DEBUG > 2)
  596. printk("  Maximum receive rings %in", readl(&regs->MaxRxRng));
  597. #endif
  599. /*
  600.  * Read the hardware address from the eeprom.  The HW address
  601.  * is not really necessary for HIPPI but awfully convenient.
  602.  * The pointer arithmetic to put it in dev_addr is ugly, but
  603.  * Donald Becker does it this way for the GigE version of this
  604.  * card and it's shorter and more portable than any
  605.  * other method I've seen.  -VAL
  606.  */
  608. *(u16 *)(dev->dev_addr) =
  609.   htons(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA));
  610. *(u32 *)(dev->dev_addr+2) =
  611.   htonl(rr_read_eeprom_word(rrpriv, &hw->manf.BoardULA[4]));
  613. printk("  MAC: ");
  615. for (i = 0; i < 5; i++)
  616. printk("%2.2x:", dev->dev_addr[i]);
  617. printk("%2.2xn", dev->dev_addr[i]);
  619. sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
  620. printk("  SRAM size 0x%06xn", sram_size);
  622. if (sysctl_rmem_max < 262144){
  623. printk("  Receive socket buffer limit too low (%i), "
  624.        "setting to 262144n", sysctl_rmem_max);
  625. sysctl_rmem_max = 262144;
  626. }
  628. if (sysctl_wmem_max < 262144){
  629. printk("  Transmit socket buffer limit too low (%i), "
  630.        "setting to 262144n", sysctl_wmem_max);
  631. sysctl_wmem_max = 262144;
  632. }
  634. rrpriv->next = root_dev;
  635. root_dev = dev;
  637. return 0;
  638. }
  641. static int rr_init1(struct net_device *dev)
  642. {
  643. struct rr_private *rrpriv;
  644. struct rr_regs *regs;
  645. unsigned long myjif, flags;
  646. struct cmd cmd;
  647. u32 hostctrl;
  648. int ecode = 0;
  649. short i;
  651. rrpriv = (struct rr_private *)dev->priv;
  652. regs = rrpriv->regs;
  654. spin_lock_irqsave(&rrpriv->lock, flags);
  656. hostctrl = readl(&regs->HostCtrl);
  657. writel(hostctrl | HALT_NIC | RR_CLEAR_INT, &regs->HostCtrl);
  658. wmb();
  660. if (hostctrl & PARITY_ERR){
  661. printk("%s: Parity error halting NIC - this is serious!n",
  662.        dev->name);
  663. spin_unlock_irqrestore(&rrpriv->lock, flags);
  664. ecode = -EFAULT;
  665. goto error;
  666. }
  668. set_rxaddr(regs, rrpriv->rx_ctrl);
  669. set_infoaddr(regs, rrpriv->info);
  671. rrpriv->info->evt_ctrl.entry_size = sizeof(struct event);
  672. rrpriv->info->evt_ctrl.entries = EVT_RING_ENTRIES;
  673. rrpriv->info->evt_ctrl.mode = 0;
  674. rrpriv->info->evt_ctrl.pi = 0;
  675. set_rraddr(&rrpriv->info->evt_ctrl.rngptr, rrpriv->evt_ring);
  677. rrpriv->info->cmd_ctrl.entry_size = sizeof(struct cmd);
  678. rrpriv->info->cmd_ctrl.entries = CMD_RING_ENTRIES;
  679. rrpriv->info->cmd_ctrl.mode = 0;
  680. rrpriv->info->cmd_ctrl.pi = 15;
  682. for (i = 0; i < CMD_RING_ENTRIES; i++) {
  683. writel(0, &regs->CmdRing[i]);
  684. }
  686. for (i = 0; i < TX_RING_ENTRIES; i++) {
  687. rrpriv->tx_ring[i].size = 0;
  688. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  689. rrpriv->tx_skbuff[i] = 0;
  690. }
  691. rrpriv->info->tx_ctrl.entry_size = sizeof(struct tx_desc);
  692. rrpriv->info->tx_ctrl.entries = TX_RING_ENTRIES;
  693. rrpriv->info->tx_ctrl.mode = 0;
  694. rrpriv->info->tx_ctrl.pi = 0;
  695. set_rraddr(&rrpriv->info->tx_ctrl.rngptr, rrpriv->tx_ring);
  697. /*
  698.  * Set dirty_tx before we start receiving interrupts, otherwise
  699.  * the interrupt handler might think it is supposed to process
  700.  * tx ints before we are up and running, which may cause a null
  701.  * pointer access in the int handler.
  702.  */
  703. rrpriv->tx_full = 0;
  704. rrpriv->cur_rx = 0;
  705. rrpriv->dirty_rx = rrpriv->dirty_tx = 0;
  707. rr_reset(dev);
  709. /* Tuning values */
  710. writel(0x5000, &regs->ConRetry);
  711. writel(0x100, &regs->ConRetryTmr);
  712. writel(0x500000, &regs->ConTmout);
  713.   writel(0x60, &regs->IntrTmr);
  714. writel(0x500000, &regs->TxDataMvTimeout);
  715. writel(0x200000, &regs->RxDataMvTimeout);
  716.   writel(0x80, &regs->WriteDmaThresh);
  717.   writel(0x80, &regs->ReadDmaThresh);
  719. rrpriv->fw_running = 0;
  720. wmb();
  722. hostctrl &= ~(HALT_NIC | INVALID_INST_B | PARITY_ERR);
  723. writel(hostctrl, &regs->HostCtrl);
  724. wmb();
  726. spin_unlock_irqrestore(&rrpriv->lock, flags);
  728. for (i = 0; i < RX_RING_ENTRIES; i++) {
  729. struct sk_buff *skb;
  731. rrpriv->rx_ring[i].mode = 0;
  732. skb = alloc_skb(dev->mtu + HIPPI_HLEN, GFP_ATOMIC);
  733. if (!skb) {
  734. printk(KERN_WARNING "%s: Unable to allocate memory "
  735.        "for receive ring - halting NICn", dev->name);
  736. ecode = -ENOMEM;
  737. goto error;
  738. }
  739. rrpriv->rx_skbuff[i] = skb;
  740. /*
  741.  * Sanity test to see if we conflict with the DMA
  742.  * limitations of the Roadrunner.
  743.  */
  744. if ((((unsigned long)skb->data) & 0xfff) > ~65320)
  745. printk("skb alloc errorn");
  747. set_rraddr(&rrpriv->rx_ring[i].addr, skb->data);
  748. rrpriv->rx_ring[i].size = dev->mtu + HIPPI_HLEN;
  749. }
  751. rrpriv->rx_ctrl[4].entry_size = sizeof(struct rx_desc);
  752. rrpriv->rx_ctrl[4].entries = RX_RING_ENTRIES;
  753. rrpriv->rx_ctrl[4].mode = 8;
  754. rrpriv->rx_ctrl[4].pi = 0;
  755. wmb();
  756. set_rraddr(&rrpriv->rx_ctrl[4].rngptr, rrpriv->rx_ring);
  758. udelay(1000);
  760. /*
  761.  * Now start the FirmWare.
  762.  */
  763. cmd.code = C_START_FW;
  764. cmd.ring = 0;
  765. cmd.index = 0;
  767. rr_issue_cmd(rrpriv, &cmd);
  769. /*
  770.  * Give the FirmWare time to chew on the `get running' command.
  771.  */
  772. myjif = jiffies + 5 * HZ;
  773. while ((jiffies < myjif) && !rrpriv->fw_running);
  775. netif_start_queue(dev);
  777. return ecode;
  779.  error:
  780. /*
  781.  * We might have gotten here because we are out of memory,
  782.  * make sure we release everything we allocated before failing
  783.  */
  784. for (i = 0; i < RX_RING_ENTRIES; i++) {
  785. if (rrpriv->rx_skbuff[i]) {
  786. rrpriv->rx_ring[i].size = 0;
  787. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  788. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  789. }
  790. }
  791. return ecode;
  792. }
  795. /*
  796.  * All events are considered to be slow (RX/TX ints do not generate
  797.  * events) and are handled here, outside the main interrupt handler,
  798.  * to reduce the size of the handler.
  799.  */
  800. static u32 rr_handle_event(struct net_device *dev, u32 prodidx, u32 eidx)
  801. {
  802. struct rr_private *rrpriv;
  803. struct rr_regs *regs;
  804. u32 tmp;
  806. rrpriv = (struct rr_private *)dev->priv;
  807. regs = rrpriv->regs;
  809. while (prodidx != eidx){
  810. switch (rrpriv->evt_ring[eidx].code){
  811. case E_NIC_UP:
  812. tmp = readl(&regs->FwRev);
  813. printk(KERN_INFO "%s: Firmware revision %i.%i.%i "
  814.        "up and runningn", dev->name,
  815.        (tmp >> 16), ((tmp >> 8) & 0xff), (tmp & 0xff));
  816. rrpriv->fw_running = 1;
  817. writel(RX_RING_ENTRIES - 1, &regs->IpRxPi);
  818. wmb();
  819. break;
  820. case E_LINK_ON:
  821. printk(KERN_INFO "%s: Optical link ONn", dev->name);
  822. break;
  823. case E_LINK_OFF:
  824. printk(KERN_INFO "%s: Optical link OFFn", dev->name);
  825. break;
  826. case E_RX_IDLE:
  827. printk(KERN_WARNING "%s: RX data not movingn",
  828.        dev->name);
  829. goto drop;
  830. case E_WATCHDOG:
  831. printk(KERN_INFO "%s: The watchdog is here to see "
  832.        "usn", dev->name);
  833. break;
  834. case E_INTERN_ERR:
  835. printk(KERN_ERR "%s: HIPPI Internal NIC errorn",
  836.        dev->name);
  837. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  838.        &regs->HostCtrl);
  839. wmb();
  840. break;
  841. case E_HOST_ERR:
  842. printk(KERN_ERR "%s: Host software errorn",
  843.        dev->name);
  844. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  845.        &regs->HostCtrl);
  846. wmb();
  847. break;
  848. /*
  849.  * TX events.
  850.  */
  851. case E_CON_REJ:
  852. printk(KERN_WARNING "%s: Connection rejectedn",
  853.        dev->name);
  854. rrpriv->stats.tx_aborted_errors++;
  855. break;
  856. case E_CON_TMOUT:
  857. printk(KERN_WARNING "%s: Connection timeoutn",
  858.        dev->name);
  859. break;
  860. case E_DISC_ERR:
  861. printk(KERN_WARNING "%s: HIPPI disconnect errorn",
  862.        dev->name);
  863. rrpriv->stats.tx_aborted_errors++;
  864. break;
  865. case E_INT_PRTY:
  866. printk(KERN_ERR "%s: HIPPI Internal Parity errorn",
  867.        dev->name);
  868. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  869.        &regs->HostCtrl);
  870. wmb();
  871. break;
  872. case E_TX_IDLE:
  873. printk(KERN_WARNING "%s: Transmitter idlen",
  874.        dev->name);
  875. break;
  876. case E_TX_LINK_DROP:
  877. printk(KERN_WARNING "%s: Link lost during transmitn",
  878.        dev->name);
  879. rrpriv->stats.tx_aborted_errors++;
  880. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  881.        &regs->HostCtrl);
  882. wmb();
  883. break;
  884. case E_TX_INV_RNG:
  885. printk(KERN_ERR "%s: Invalid send ring blockn",
  886.        dev->name);
  887. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  888.        &regs->HostCtrl);
  889. wmb();
  890. break;
  891. case E_TX_INV_BUF:
  892. printk(KERN_ERR "%s: Invalid send buffer addressn",
  893.        dev->name);
  894. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  895.        &regs->HostCtrl);
  896. wmb();
  897. break;
  898. case E_TX_INV_DSC:
  899. printk(KERN_ERR "%s: Invalid descriptor addressn",
  900.        dev->name);
  901. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  902.        &regs->HostCtrl);
  903. wmb();
  904. break;
  905. /*
  906.  * RX events.
  907.  */
  908. case E_RX_RNG_OUT:
  909. printk(KERN_INFO "%s: Receive ring fulln", dev->name);
  910. break;
  912. case E_RX_PAR_ERR:
  913. printk(KERN_WARNING "%s: Receive parity errorn",
  914.        dev->name);
  915. goto drop;
  916. case E_RX_LLRC_ERR:
  917. printk(KERN_WARNING "%s: Receive LLRC errorn",
  918.        dev->name);
  919. goto drop;
  920. case E_PKT_LN_ERR:
  921. printk(KERN_WARNING "%s: Receive packet length "
  922.        "errorn", dev->name);
  923. goto drop;
  924. case E_DTA_CKSM_ERR:
  925. printk(KERN_WARNING "%s: Data checksum errorn",
  926.        dev->name);
  927. goto drop;
  928. case E_SHT_BST:
  929. printk(KERN_WARNING "%s: Unexpected short burst "
  930.        "errorn", dev->name);
  931. goto drop;
  932. case E_STATE_ERR:
  933. printk(KERN_WARNING "%s: Recv. state transition"
  934.        " errorn", dev->name);
  935. goto drop;
  936. case E_UNEXP_DATA:
  937. printk(KERN_WARNING "%s: Unexpected data errorn",
  938.        dev->name);
  939. goto drop;
  940. case E_LST_LNK_ERR:
  941. printk(KERN_WARNING "%s: Link lost errorn",
  942.        dev->name);
  943. goto drop;
  944. case E_FRM_ERR:
  945. printk(KERN_WARNING "%s: Framming Errorn",
  946.        dev->name);
  947. goto drop;
  948. case E_FLG_SYN_ERR:
  949. printk(KERN_WARNING "%s: Flag sync. lost during"
  950.        "packetn", dev->name);
  951. goto drop;
  952. case E_RX_INV_BUF:
  953. printk(KERN_ERR "%s: Invalid receive buffer "
  954.        "addressn", dev->name);
  955. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  956.        &regs->HostCtrl);
  957. wmb();
  958. break;
  959. case E_RX_INV_DSC:
  960. printk(KERN_ERR "%s: Invalid receive descriptor "
  961.        "addressn", dev->name);
  962. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  963.        &regs->HostCtrl);
  964. wmb();
  965. break;
  966. case E_RNG_BLK:
  967. printk(KERN_ERR "%s: Invalid ring blockn",
  968.        dev->name);
  969. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  970.        &regs->HostCtrl);
  971. wmb();
  972. break;
  973. drop:
  974. /* Label packet to be dropped.
  975.  * Actual dropping occurs in rx
  976.  * handling.
  977.  *
  978.  * The index of packet we get to drop is
  979.  * the index of the packet following
  980.  * the bad packet. -kbf
  981.  */
  982. {
  983. u16 index = rrpriv->evt_ring[eidx].index;
  984. index = (index + (RX_RING_ENTRIES - 1)) %
  985. RX_RING_ENTRIES;
  986. rrpriv->rx_ring[index].mode |=
  987. (PACKET_BAD | PACKET_END);
  988. }
  989. break;
  990. default:
  991. printk(KERN_WARNING "%s: Unhandled event 0x%02xn",
  992.        dev->name, rrpriv->evt_ring[eidx].code);
  993. }
  994. eidx = (eidx + 1) % EVT_RING_ENTRIES;
  995. }
  997. rrpriv->info->evt_ctrl.pi = eidx;
  998. wmb();
  999. return eidx;
  1000. }
  1003. static void rx_int(struct net_device *dev, u32 rxlimit, u32 index)
  1004. {
  1005. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1006. struct rr_regs *regs = rrpriv->regs;
  1008. do {
  1009. u32 pkt_len;
  1010. pkt_len = rrpriv->rx_ring[index].size;
  1011. #if (DEBUG > 2)
  1012. printk("index %i, rxlimit %in", index, rxlimit);
  1013. printk("len %x, mode %xn", pkt_len,
  1014.        rrpriv->rx_ring[index].mode);
  1015. #endif
  1016. if ( (rrpriv->rx_ring[index].mode & PACKET_BAD) == PACKET_BAD){
  1017. rrpriv->stats.rx_dropped++;
  1018. goto defer;
  1019. }
  1021. if (pkt_len > 0){
  1022. struct sk_buff *skb;
  1024. if (pkt_len < PKT_COPY_THRESHOLD) {
  1025. skb = alloc_skb(pkt_len, GFP_ATOMIC);
  1026. if (skb == NULL){
  1027. printk(KERN_WARNING "%s: Unable to allocate skb (%i bytes), deferring packetn", dev->name, pkt_len);
  1028. rrpriv->stats.rx_dropped++;
  1029. goto defer;
  1030. }else
  1031. memcpy(skb_put(skb, pkt_len),
  1032.        rrpriv->rx_skbuff[index]->data,
  1033.        pkt_len);
  1034. }else{
  1035. struct sk_buff *newskb;
  1037. newskb = alloc_skb(dev->mtu + HIPPI_HLEN,
  1038.    GFP_ATOMIC);
  1039. if (newskb){
  1040. skb = rrpriv->rx_skbuff[index];
  1041. skb_put(skb, pkt_len);
  1042. rrpriv->rx_skbuff[index] = newskb;
  1043. set_rraddr(&rrpriv->rx_ring[index].addr, newskb->data);
  1044. }else{
  1045. printk("%s: Out of memory, deferring "
  1046.        "packetn", dev->name);
  1047. rrpriv->stats.rx_dropped++;
  1048. goto defer;
  1049. }
  1050. }
  1051. skb->dev = dev;
  1052. skb->protocol = hippi_type_trans(skb, dev);
  1054. netif_rx(skb); /* send it up */
  1056. dev->last_rx = jiffies;
  1057. rrpriv->stats.rx_packets++;
  1058. rrpriv->stats.rx_bytes += pkt_len;
  1059. }
  1060. defer:
  1061. rrpriv->rx_ring[index].mode = 0;
  1062. rrpriv->rx_ring[index].size = dev->mtu + HIPPI_HLEN;
  1064. if ((index & 7) == 7)
  1065. writel(index, &regs->IpRxPi);
  1067. index = (index + 1) % RX_RING_ENTRIES;
  1068. } while(index != rxlimit);
  1070. rrpriv->cur_rx = index;
  1071. wmb();
  1072. }
  1075. static void rr_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
  1076. {
  1077. struct rr_private *rrpriv;
  1078. struct rr_regs *regs;
  1079. struct net_device *dev = (struct net_device *)dev_id;
  1080. u32 prodidx, rxindex, eidx, txcsmr, rxlimit, txcon;
  1082. rrpriv = (struct rr_private *)dev->priv;
  1083. regs = rrpriv->regs;
  1085. if (!(readl(&regs->HostCtrl) & RR_INT))
  1086. return;
  1088. spin_lock(&rrpriv->lock);
  1090. prodidx = readl(&regs->EvtPrd);
  1091. txcsmr = (prodidx >> 8) & 0xff;
  1092. rxlimit = (prodidx >> 16) & 0xff;
  1093. prodidx &= 0xff;
  1095. #if (DEBUG > 2)
  1096. printk("%s: interrupt, prodidx = %i, eidx = %in", dev->name,
  1097.        prodidx, rrpriv->info->evt_ctrl.pi);
  1098. #endif
  1099. /*
  1100.  * Order here is important.  We must handle events
  1101.  * before doing anything else in order to catch
  1102.  * such things as LLRC errors, etc -kbf
  1103.  */
  1105. eidx = rrpriv->info->evt_ctrl.pi;
  1106. if (prodidx != eidx)
  1107. eidx = rr_handle_event(dev, prodidx, eidx);
  1109. rxindex = rrpriv->cur_rx;
  1110. if (rxindex != rxlimit)
  1111. rx_int(dev, rxlimit, rxindex);
  1113. txcon = rrpriv->dirty_tx;
  1114. if (txcsmr != txcon) {
  1115. do {
  1116. /* Due to occational firmware TX producer/consumer out
  1117.  * of sync. error need to check entry in ring -kbf
  1118.  */
  1119. if(rrpriv->tx_skbuff[txcon]){
  1120. rrpriv->stats.tx_packets++;
  1121. rrpriv->stats.tx_bytes +=rrpriv->tx_skbuff[txcon]->len;
  1122. dev_kfree_skb_irq(rrpriv->tx_skbuff[txcon]);
  1124. rrpriv->tx_skbuff[txcon] = NULL;
  1125. rrpriv->tx_ring[txcon].size = 0;
  1126. set_rraddr(&rrpriv->tx_ring[txcon].addr, 0);
  1127. rrpriv->tx_ring[txcon].mode = 0;
  1128. }
  1129. txcon = (txcon + 1) % TX_RING_ENTRIES;
  1130. } while (txcsmr != txcon);
  1131. wmb();
  1133. rrpriv->dirty_tx = txcon;
  1134. if (rrpriv->tx_full && rr_if_busy(dev) &&
  1135.     (((rrpriv->info->tx_ctrl.pi + 1) % TX_RING_ENTRIES)
  1136.      != rrpriv->dirty_tx)){
  1137. rrpriv->tx_full = 0;
  1138. netif_wake_queue(dev);
  1139. rr_mark_net_bh(NET_BH);
  1140. }
  1141. }
  1143. eidx |= ((txcsmr << 8) | (rxlimit << 16));
  1144. writel(eidx, &regs->EvtCon);
  1145. wmb();
  1147. spin_unlock(&rrpriv->lock);
  1148. }
  1151. static void rr_timer(unsigned long data)
  1152. {
  1153. struct net_device *dev = (struct net_device *)data;
  1154. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1155. struct rr_regs *regs = rrpriv->regs;
  1156. unsigned long flags;
  1157. int i;
  1159. if (readl(&regs->HostCtrl) & NIC_HALTED){
  1160. printk("%s: Restarting nicn", dev->name);
  1161. memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
  1162. memset(rrpriv->info, 0, sizeof(struct rr_info));
  1163. wmb();
  1164. for (i = 0; i < TX_RING_ENTRIES; i++) {
  1165. if (rrpriv->tx_skbuff[i]) {
  1166. rrpriv->tx_ring[i].size = 0;
  1167. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  1168. dev_kfree_skb(rrpriv->tx_skbuff[i]);
  1169. rrpriv->tx_skbuff[i] = NULL;
  1170. }
  1171. }
  1173. for (i = 0; i < RX_RING_ENTRIES; i++) {
  1174. if (rrpriv->rx_skbuff[i]) {
  1175. rrpriv->rx_ring[i].size = 0;
  1176. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  1177. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  1178. rrpriv->rx_skbuff[i] = NULL;
  1179. }
  1180. }
  1181. if (rr_init1(dev)) {
  1182. spin_lock_irqsave(&rrpriv->lock, flags);
  1183. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 
  1184.        &regs->HostCtrl);
  1185. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1186. }
  1187. }
  1188. rrpriv->timer.expires = RUN_AT(5*HZ);
  1189. add_timer(&rrpriv->timer);
  1190. }
  1193. static int rr_open(struct net_device *dev)
  1194. {
  1195. struct rr_private *rrpriv;
  1196. struct rr_regs *regs;
  1197. int ecode = 0;
  1198. unsigned long flags;
  1200. rrpriv = (struct rr_private *)dev->priv;
  1201. regs = rrpriv->regs;
  1203. if (rrpriv->fw_rev < 0x00020000) {
  1204. printk(KERN_WARNING "%s: trying to configure device with "
  1205.        "obsolete firmwaren", dev->name);
  1206. ecode = -EBUSY;
  1207. goto error;
  1208. }
  1210. rrpriv->rx_ctrl = kmalloc(256*sizeof(struct ring_ctrl), GFP_KERNEL);
  1211. if (!rrpriv->rx_ctrl) {
  1212. ecode = -ENOMEM;
  1213. goto error;
  1214. }
  1216. rrpriv->info = kmalloc(sizeof(struct rr_info), GFP_KERNEL);
  1217. if (!rrpriv->info){
  1218. rrpriv->rx_ctrl = NULL;
  1219. ecode = -ENOMEM;
  1220. goto error;
  1221. }
  1222. memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
  1223. memset(rrpriv->info, 0, sizeof(struct rr_info));
  1224. wmb();
  1226. spin_lock_irqsave(&rrpriv->lock, flags);
  1227. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
  1228. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1230. if (request_irq(dev->irq, rr_interrupt, SA_SHIRQ, rrpriv->name, dev))
  1231. {
  1232. printk(KERN_WARNING "%s: Requested IRQ %d is busyn",
  1233.        dev->name, dev->irq);
  1234. ecode = -EAGAIN;
  1235. goto error;
  1236. }
  1238. if ((ecode = rr_init1(dev)))
  1239. goto error;
  1241. /* Set the timer to switch to check for link beat and perhaps switch
  1242.    to an alternate media type. */
  1243. init_timer(&rrpriv->timer);
  1244. rrpriv->timer.expires = RUN_AT(5*HZ);           /* 5 sec. watchdog */
  1245. rrpriv->timer.data = (unsigned long)dev;
  1246. rrpriv->timer.function = &rr_timer;               /* timer handler */
  1247. add_timer(&rrpriv->timer);
  1249. netif_start_queue(dev);
  1251. return ecode;
  1253.  error:
  1254. spin_lock_irqsave(&rrpriv->lock, flags);
  1255. writel(readl(&regs->HostCtrl)|HALT_NIC|RR_CLEAR_INT, &regs->HostCtrl);
  1256. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1258. if (rrpriv->info) {
  1259. kfree(rrpriv->info);
  1260. rrpriv->info = NULL;
  1261. }
  1262. if (rrpriv->rx_ctrl) {
  1263. kfree(rrpriv->rx_ctrl);
  1264. rrpriv->rx_ctrl = NULL;
  1265. }
  1267. netif_stop_queue(dev);
  1268. rr_if_down(dev);
  1270. return ecode;
  1271. }
  1274. static void rr_dump(struct net_device *dev)
  1275. {
  1276. struct rr_private *rrpriv;
  1277. struct rr_regs *regs;
  1278. u32 index, cons;
  1279. short i;
  1280. int len;
  1282. rrpriv = (struct rr_private *)dev->priv;
  1283. regs = rrpriv->regs;
  1285. printk("%s: dumping NIC TX ringsn", dev->name);
  1287. printk("RxPrd %08x, TxPrd %02x, EvtPrd %08x, TxPi %02x, TxCtrlPi %02xn",
  1288.        readl(&regs->RxPrd), readl(&regs->TxPrd),
  1289.        readl(&regs->EvtPrd), readl(&regs->TxPi),
  1290.        rrpriv->info->tx_ctrl.pi);
  1292. printk("Error code 0x%xn", readl(&regs->Fail1));
  1294. index = (((readl(&regs->EvtPrd) >> 8) & 0xff ) - 1) % EVT_RING_ENTRIES;
  1295. cons = rrpriv->dirty_tx;
  1296. printk("TX ring index %i, TX consumer %in",
  1297.        index, cons);
  1299. if (rrpriv->tx_skbuff[index]){
  1300. len = min_t(int, 0x80, rrpriv->tx_skbuff[index]->len);
  1301. printk("skbuff for index %i is valid - dumping data (0x%x bytes - DMA len 0x%x)n", index, len, rrpriv->tx_ring[index].size);
  1302. for (i = 0; i < len; i++){
  1303. if (!(i & 7))
  1304. printk("n");
  1305. printk("%02x ", (unsigned char) rrpriv->tx_skbuff[index]->data[i]);
  1306. }
  1307. printk("n");
  1308. }
  1310. if (rrpriv->tx_skbuff[cons]){
  1311. len = min_t(int, 0x80, rrpriv->tx_skbuff[cons]->len);
  1312. printk("skbuff for cons %i is valid - dumping data (0x%x bytes - skbuff len 0x%x)n", cons, len, rrpriv->tx_skbuff[cons]->len);
  1313. printk("mode 0x%x, size 0x%x,n phys %08x (virt %08lx), skbuff-addr %08lx, truesize 0x%xn",
  1314.        rrpriv->tx_ring[cons].mode,
  1315.        rrpriv->tx_ring[cons].size,
  1316.        rrpriv->tx_ring[cons].addr.addrlo,
  1317.        (unsigned long)bus_to_virt(rrpriv->tx_ring[cons].addr.addrlo),
  1318.        (unsigned long)rrpriv->tx_skbuff[cons]->data,
  1319.        (unsigned int)rrpriv->tx_skbuff[cons]->truesize);
  1320. for (i = 0; i < len; i++){
  1321. if (!(i & 7))
  1322. printk("n");
  1323. printk("%02x ", (unsigned char)rrpriv->tx_ring[cons].size);
  1324. }
  1325. printk("n");
  1326. }
  1328. printk("dumping TX ring info:n");
  1329. for (i = 0; i < TX_RING_ENTRIES; i++)
  1330. printk("mode 0x%x, size 0x%x, phys-addr %08xn",
  1331.        rrpriv->tx_ring[i].mode,
  1332.        rrpriv->tx_ring[i].size,
  1333.        rrpriv->tx_ring[i].addr.addrlo);
  1335. }
  1338. static int rr_close(struct net_device *dev)
  1339. {
  1340. struct rr_private *rrpriv;
  1341. struct rr_regs *regs;
  1342. u32 tmp;
  1343. short i;
  1345. netif_stop_queue(dev);
  1346. rr_if_down(dev);
  1348. rrpriv = (struct rr_private *)dev->priv;
  1349. regs = rrpriv->regs;
  1351. /*
  1352.  * Lock to make sure we are not cleaning up while another CPU
  1353.  * handling interrupts.
  1354.  */
  1355. spin_lock(&rrpriv->lock);
  1357. tmp = readl(&regs->HostCtrl);
  1358. if (tmp & NIC_HALTED){
  1359. printk("%s: NIC already haltedn", dev->name);
  1360. rr_dump(dev);
  1361. }else{
  1362. tmp |= HALT_NIC | RR_CLEAR_INT;
  1363. writel(tmp, &regs->HostCtrl);
  1364. wmb();
  1365. }
  1367. rrpriv->fw_running = 0;
  1369. del_timer(&rrpriv->timer);
  1371. writel(0, &regs->TxPi);
  1372. writel(0, &regs->IpRxPi);
  1374. writel(0, &regs->EvtCon);
  1375. writel(0, &regs->EvtPrd);
  1377. for (i = 0; i < CMD_RING_ENTRIES; i++)
  1378. writel(0, &regs->CmdRing[i]);
  1380. rrpriv->info->tx_ctrl.entries = 0;
  1381. rrpriv->info->cmd_ctrl.pi = 0;
  1382. rrpriv->info->evt_ctrl.pi = 0;
  1383. rrpriv->rx_ctrl[4].entries = 0;
  1385. for (i = 0; i < TX_RING_ENTRIES; i++) {
  1386. if (rrpriv->tx_skbuff[i]) {
  1387. rrpriv->tx_ring[i].size = 0;
  1388. set_rraddr(&rrpriv->tx_ring[i].addr, 0);
  1389. dev_kfree_skb(rrpriv->tx_skbuff[i]);
  1390. rrpriv->tx_skbuff[i] = NULL;
  1391. }
  1392. }
  1394. for (i = 0; i < RX_RING_ENTRIES; i++) {
  1395. if (rrpriv->rx_skbuff[i]) {
  1396. rrpriv->rx_ring[i].size = 0;
  1397. set_rraddr(&rrpriv->rx_ring[i].addr, 0);
  1398. dev_kfree_skb(rrpriv->rx_skbuff[i]);
  1399. rrpriv->rx_skbuff[i] = NULL;
  1400. }
  1401. }
  1403. if (rrpriv->rx_ctrl) {
  1404. kfree(rrpriv->rx_ctrl);
  1405. rrpriv->rx_ctrl = NULL;
  1406. }
  1407. if (rrpriv->info) {
  1408. kfree(rrpriv->info);
  1409. rrpriv->info = NULL;
  1410. }
  1412. free_irq(dev->irq, dev);
  1413. spin_unlock(&rrpriv->lock);
  1415. return 0;
  1416. }
  1419. static int rr_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1420. {
  1421. struct rr_private *rrpriv = (struct rr_private *)dev->priv;
  1422. struct rr_regs *regs = rrpriv->regs;
  1423. struct ring_ctrl *txctrl;
  1424. unsigned long flags;
  1425. u32 index, len = skb->len;
  1426. u32 *ifield;
  1427. struct sk_buff *new_skb;
  1429. if (readl(&regs->Mode) & FATAL_ERR)
  1430. printk("error codes Fail1 %02x, Fail2 %02xn",
  1431.        readl(&regs->Fail1), readl(&regs->Fail2));
  1433. /*
  1434.  * We probably need to deal with tbusy here to prevent overruns.
  1435.  */
  1437. if (skb_headroom(skb) < 8){
  1438. printk("incoming skb too small - reallocatingn");
  1439. if (!(new_skb = dev_alloc_skb(len + 8))) {
  1440. dev_kfree_skb(skb);
  1441. netif_wake_queue(dev);
  1442. return -EBUSY;
  1443. }
  1444. skb_reserve(new_skb, 8);
  1445. skb_put(new_skb, len);
  1446. memcpy(new_skb->data, skb->data, len);
  1447. dev_kfree_skb(skb);
  1448. skb = new_skb;
  1449. }
  1451. ifield = (u32 *)skb_push(skb, 8);
  1453. ifield[0] = 0;
  1454. ifield[1] = skb->private.ifield;
  1456. /*
  1457.  * We don't need the lock before we are actually going to start
  1458.  * fiddling with the control blocks.
  1459.  */
  1460. spin_lock_irqsave(&rrpriv->lock, flags);
  1462. txctrl = &rrpriv->info->tx_ctrl;
  1464. index = txctrl->pi;
  1466. rrpriv->tx_skbuff[index] = skb;
  1467. set_rraddr(&rrpriv->tx_ring[index].addr, skb->data);
  1468. rrpriv->tx_ring[index].size = len + 8; /* include IFIELD */
  1469. rrpriv->tx_ring[index].mode = PACKET_START | PACKET_END;
  1470. txctrl->pi = (index + 1) % TX_RING_ENTRIES;
  1471. wmb();
  1472. writel(txctrl->pi, &regs->TxPi);
  1474. if (txctrl->pi == rrpriv->dirty_tx){
  1475. rrpriv->tx_full = 1;
  1476. netif_stop_queue(dev);
  1477. }
  1479. spin_unlock_irqrestore(&rrpriv->lock, flags);
  1481. dev->trans_start = jiffies;
  1482. return 0;
  1483. }
  1486. static struct net_device_stats *rr_get_stats(struct net_device *dev)
  1487. {
  1488. struct rr_private *rrpriv;
  1490. rrpriv = (struct rr_private *)dev->priv;
  1492. return(&rrpriv->stats);
  1493. }
  1496. /*
  1497.  * Read the firmware out of the EEPROM and put it into the SRAM
  1498.  * (or from user space - later)
  1499.  *
  1500.  * This operation requires the NIC to be halted and is performed with
  1501.  * interrupts disabled and with the spinlock hold.
  1502.  */
  1503. static int rr_load_firmware(struct net_device *dev)
  1504. {
  1505. struct rr_private *rrpriv;
  1506. struct rr_regs *regs;
  1507. unsigned long eptr, segptr;
  1508. int i, j;
  1509. u32 localctrl, sptr, len, tmp;
  1510. u32 p2len, p2size, nr_seg, revision, io, sram_size;
  1511. struct eeprom *hw = NULL;
  1513. rrpriv = (struct rr_private *)dev->priv;
  1514. regs = rrpriv->regs;
  1516. if (dev->flags & IFF_UP)
  1517. return -EBUSY;
  1519. if (!(readl(&regs->HostCtrl) & NIC_HALTED)){
  1520. printk("%s: Trying to load firmware to a running NIC.n", 
  1521.        dev->name);
  1522. return -EBUSY;
  1523. }
  1525. localctrl = readl(&regs->LocalCtrl);
  1526. writel(0, &regs->LocalCtrl);
  1528. writel(0, &regs->EvtPrd);
  1529. writel(0, &regs->RxPrd);
  1530. writel(0, &regs->TxPrd);
  1532. /*
  1533.  * First wipe the entire SRAM, otherwise we might run into all
  1534.  * kinds of trouble ... sigh, this took almost all afternoon
  1535.  * to track down ;-(
  1536.  */
  1537. io = readl(&regs->ExtIo);
  1538. writel(0, &regs->ExtIo);
  1539. sram_size = rr_read_eeprom_word(rrpriv, (void *)8);
  1541. for (i = 200; i < sram_size / 4; i++){
  1542. writel(i * 4, &regs->WinBase);
  1543. mb();
  1544. writel(0, &regs->WinData);
  1545. mb();
  1546. }
  1547. writel(io, &regs->ExtIo);
  1548. mb();
  1550. eptr = (unsigned long)rr_read_eeprom_word(rrpriv,
  1551.        &hw->rncd_info.AddrRunCodeSegs);
  1552. eptr = ((eptr & 0x1fffff) >> 3);
  1554. p2len = rr_read_eeprom_word(rrpriv, (void *)(0x83*4));
  1555. p2len = (p2len << 2);
  1556. p2size = rr_read_eeprom_word(rrpriv, (void *)(0x84*4));
  1557. p2size = ((p2size & 0x1fffff) >> 3);
  1559. if ((eptr < p2size) || (eptr > (p2size + p2len))){
  1560. printk("%s: eptr is invalidn", dev->name);
  1561. goto out;
  1562. }
  1564. revision = rr_read_eeprom_word(rrpriv, &hw->manf.HeaderFmt);
  1566. if (revision != 1){
  1567. printk("%s: invalid firmware format (%i)n",
  1568.        dev->name, revision);
  1569. goto out;
  1570. }
  1572. nr_seg = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1573. eptr +=4;
  1574. #if (DEBUG > 1)
  1575. printk("%s: nr_seg %in", dev->name, nr_seg);
  1576. #endif
  1578. for (i = 0; i < nr_seg; i++){
  1579. sptr = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1580. eptr += 4;
  1581. len = rr_read_eeprom_word(rrpriv, (void *)eptr);
  1582. eptr += 4;
  1583. segptr = (unsigned long)rr_read_eeprom_word(rrpriv, (void *)eptr);
  1584. segptr = ((segptr & 0x1fffff) >> 3);
  1585. eptr += 4;
  1586. #if (DEBUG > 1)
  1587. printk("%s: segment %i, sram address %06x, length %04x, segptr %06xn",
  1588.        dev->name, i, sptr, len, segptr);
  1589. #endif
  1590. for (j = 0; j < len; j++){
  1591. tmp = rr_read_eeprom_word(rrpriv, (void *)segptr);
  1592. writel(sptr, &regs->WinBase);
  1593. mb();
  1594. writel(tmp, &regs->WinData);
  1595. mb();
  1596. segptr += 4;
  1597. sptr += 4;
  1598. }
  1599. }
  1601. out:
  1602. writel(localctrl, &regs->LocalCtrl);
  1603. mb();
  1604. return 0;
  1605. }
  1608. static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1609. {
  1610. struct rr_private *rrpriv;
  1611. unsigned char *image, *oldimage;
  1612. unsigned int i;
  1613. int error = -EOPNOTSUPP;
  1615. rrpriv = dev->priv;
  1617. switch(cmd){
  1618. case SIOCRRGFW:
  1619. if (!capable(CAP_SYS_RAWIO)){
  1620. return -EPERM;
  1621. }
  1623. image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1624. if (!image){
  1625. printk(KERN_ERR "%s: Unable to allocate memory "
  1626.        "for EEPROM imagen", dev->name);
  1627. return -ENOMEM;
  1628. }
  1630. spin_lock(&rrpriv->lock);
  1632. if (rrpriv->fw_running){
  1633. printk("%s: Firmware already runningn", dev->name);
  1634. error = -EPERM;
  1635. goto out_spin;
  1636. }
  1638. i = rr_read_eeprom(rrpriv, 0, image, EEPROM_BYTES);
  1639. if (i != EEPROM_BYTES){
  1640. printk(KERN_ERR "%s: Error reading EEPROMn", dev->name);
  1641. error = -EFAULT;
  1642. goto out_spin;
  1643. }
  1644. spin_unlock(&rrpriv->lock);
  1645. error = copy_to_user(rq->ifr_data, image, EEPROM_BYTES);
  1646. if (error)
  1647. error = -EFAULT;
  1648. kfree(image);
  1649. return error;
  1651. case SIOCRRPFW:
  1652. if (!capable(CAP_SYS_RAWIO)){
  1653. return -EPERM;
  1654. }
  1656. image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1657. if (!image){
  1658. printk(KERN_ERR "%s: Unable to allocate memory "
  1659.        "for EEPROM imagen", dev->name);
  1660. return -ENOMEM;
  1661. }
  1663. oldimage = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL);
  1664. if (!oldimage){
  1665. kfree(image);
  1666. printk(KERN_ERR "%s: Unable to allocate memory "
  1667.        "for old EEPROM imagen", dev->name);
  1668. return -ENOMEM;
  1669. }
  1671. error = copy_from_user(image, rq->ifr_data, EEPROM_BYTES);
  1672. if (error) {
  1673. kfree(image);
  1674. kfree(oldimage);
  1675. return -EFAULT;
  1676. }
  1678. spin_lock(&rrpriv->lock);
  1679. if (rrpriv->fw_running){
  1680. kfree(oldimage);
  1681. printk("%s: Firmware already runningn", dev->name);
  1682. error = -EPERM;
  1683. goto out_spin;
  1684. }
  1686. printk("%s: Updating EEPROM firmwaren", dev->name);
  1688. error = write_eeprom(rrpriv, 0, image, EEPROM_BYTES);
  1689. if (error)
  1690. printk(KERN_ERR "%s: Error writing EEPROMn",
  1691.        dev->name);
  1693. i = rr_read_eeprom(rrpriv, 0, oldimage, EEPROM_BYTES);
  1694. if (i != EEPROM_BYTES)
  1695. printk(KERN_ERR "%s: Error reading back EEPROM "
  1696.        "imagen", dev->name);
  1698. spin_unlock(&rrpriv->lock);
  1699. error = memcmp(image, oldimage, EEPROM_BYTES);
  1700. if (error){
  1701. printk(KERN_ERR "%s: Error verifying EEPROM imagen",
  1702.        dev->name);
  1703. error = -EFAULT;
  1704. }
  1705. kfree(image);
  1706. kfree(oldimage);
  1707. return error;
  1709. case SIOCRRID:
  1710. return put_user(0x52523032, (int *)(&rq->ifr_data[0]));
  1711. default:
  1712. return error;
  1713. }
  1715.  out_spin:
  1716. kfree(image);
  1717. spin_unlock(&rrpriv->lock);
  1718. return error;
  1719. }
  1722. /*
  1723.  * Local variables:
  1724.  * 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"
  1725.  * End:
  1726.  */