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

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

嵌入式Linux

开发平台：

Unix_Linux

rcpci45.c：源码内容
  1. /* 
  2. **
  3. **  RCpci45.c  
  4. **
  5. **
  6. **
  7. **  ---------------------------------------------------------------------
  8. **  ---     Copyright (c) 1998, 1999, RedCreek Communications Inc.    ---
  9. **  ---                   All rights reserved.                        ---
  10. **  ---------------------------------------------------------------------
  11. **
  12. ** Written by Pete Popov and Brian Moyle.
  13. **
  14. ** Known Problems
  15. ** 
  16. ** None known at this time.
  17. **
  18. **  This program is free software; you can redistribute it and/or modify
  19. **  it under the terms of the GNU General Public License as published by
  20. **  the Free Software Foundation; either version 2 of the License, or
  21. **  (at your option) any later version.
  23. **  This program is distributed in the hope that it will be useful,
  24. **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. **  GNU General Public License for more details.
  28. **  You should have received a copy of the GNU General Public License
  29. **  along with this program; if not, write to the Free Software
  30. **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. **
  32. **  Pete Popov, Oct 2001: Fixed a few bugs to make the driver functional
  33. **  again. Note that this card is not supported or manufactured by 
  34. **  RedCreek anymore.
  35. **   
  36. **  Rasmus Andersen, December 2000: Converted to new PCI API and general
  37. **  cleanup.
  38. **
  39. **  Pete Popov, January 11,99: Fixed a couple of 2.1.x problems 
  40. **  (virt_to_bus() not called), tested it under 2.2pre5 (as a module), and 
  41. **  added a #define(s) to enable the use of the same file for both, the 2.0.x 
  42. **  kernels as well as the 2.1.x.
  43. **
  44. **  Ported to 2.1.x by Alan Cox 1998/12/9. 
  45. **
  46. **  Sometime in mid 1998, written by Pete Popov and Brian Moyle.
  47. **
  48. ***************************************************************************/
  50. #include <linux/module.h>
  51. #include <linux/kernel.h>
  52. #include <linux/sched.h>
  53. #include <linux/string.h>
  54. #include <linux/ptrace.h>
  55. #include <linux/errno.h>
  56. #include <linux/in.h>
  57. #include <linux/init.h>
  58. #include <linux/ioport.h>
  59. #include <linux/slab.h>
  60. #include <linux/interrupt.h>
  61. #include <linux/pci.h>
  62. #include <linux/timer.h>
  63. #include <asm/irq.h> /* For NR_IRQS only. */
  64. #include <asm/bitops.h>
  65. #include <asm/uaccess.h>
  67. static char version[] __initdata =
  68.     "RedCreek Communications PCI linux driver version 2.20n";
  70. #define RC_LINUX_MODULE
  71. #include "rclanmtl.h"
  72. #include "rcif.h"
  74. #define RUN_AT(x) (jiffies + (x))
  76. #define NEW_MULTICAST
  78. /* PCI/45 Configuration space values */
  79. #define RC_PCI45_VENDOR_ID  0x4916
  80. #define RC_PCI45_DEVICE_ID  0x1960
  82. #define MAX_ETHER_SIZE        1520
  83. #define MAX_NMBR_RCV_BUFFERS    96
  84. #define RC_POSTED_BUFFERS_LOW_MARK MAX_NMBR_RCV_BUFFERS-16
  85. #define BD_SIZE 3 /* Bucket Descriptor size */
  86. #define BD_LEN_OFFSET 2 /* Bucket Descriptor offset to length field */
  88. /* RedCreek LAN device Target ID */
  89. #define RC_LAN_TARGET_ID  0x10
  90. /* RedCreek's OSM default LAN receive Initiator */
  91. #define DEFAULT_RECV_INIT_CONTEXT  0xA17
  93. /* minimum msg buffer size needed by the card 
  94.  * Note that the size of this buffer is hard code in the
  95.  * ipsec card's firmware. Thus, the size MUST be a minimum
  96.  * of 16K. Otherwise the card will end up using memory
  97.  * that does not belong to it.
  98.  */
  99. #define MSG_BUF_SIZE  16384
  101. static U32 DriverControlWord;
  103. static void rc_timer (unsigned long);
  105. static int RCinit (struct net_device *);
  107. static int RCopen (struct net_device *);
  108. static int RC_xmit_packet (struct sk_buff *, struct net_device *);
  109. static void RCinterrupt (int, void *, struct pt_regs *);
  110. static int RCclose (struct net_device *dev);
  111. static struct net_device_stats *RCget_stats (struct net_device *);
  112. static int RCioctl (struct net_device *, struct ifreq *, int);
  113. static int RCconfig (struct net_device *, struct ifmap *);
  114. static void RCxmit_callback (U32, U16, PU32, struct net_device *);
  115. static void RCrecv_callback (U32, U8, U32, PU32, struct net_device *);
  116. static void RCreset_callback (U32, U32, U32, struct net_device *);
  117. static void RCreboot_callback (U32, U32, U32, struct net_device *);
  118. static int RC_allocate_and_post_buffers (struct net_device *, int);
  120. static struct pci_device_id rcpci45_pci_table[] __devinitdata = {
  121. {RC_PCI45_VENDOR_ID, RC_PCI45_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
  122. {}
  123. };
  124. MODULE_DEVICE_TABLE (pci, rcpci45_pci_table);
  125. MODULE_LICENSE("GPL");
  127. static void __devexit
  128. rcpci45_remove_one (struct pci_dev *pdev)
  129. {
  130. struct net_device *dev = pci_get_drvdata (pdev);
  131. PDPA pDpa = dev->priv;
  133. if (!dev) {
  134. printk (KERN_ERR "%s: remove non-existent devicen",
  135. dev->name);
  136. return;
  137. }
  139. RCResetIOP (dev);
  140. unregister_netdev (dev);
  141. free_irq (dev->irq, dev);
  142. iounmap ((void *) dev->base_addr);
  143. pci_release_regions (pdev);
  144. if (pDpa->msgbuf)
  145. kfree (pDpa->msgbuf);
  146. if (pDpa->pPab)
  147. kfree (pDpa->pPab);
  148. kfree (dev);
  149. pci_set_drvdata (pdev, NULL);
  150. }
  152. static int
  153. rcpci45_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
  154. {
  155. unsigned long *vaddr;
  156. PDPA pDpa;
  157. int error;
  158. static int card_idx = -1;
  159. struct net_device *dev;
  160. unsigned long pci_start, pci_len;
  162. card_idx++;
  164. /* 
  165.  * Allocate and fill new device structure. 
  166.  * We need enough for struct net_device plus DPA plus the LAN 
  167.  * API private area, which requires a minimum of 16KB.  The top 
  168.  * of the allocated area will be assigned to struct net_device; 
  169.  * the next chunk will be assigned to DPA; and finally, the rest 
  170.  * will be assigned to the the LAN API layer.
  171.  */
  173. dev = init_etherdev (NULL, sizeof (*pDpa));
  174. if (!dev) {
  175. printk (KERN_ERR
  176. "(rcpci45 driver:) init_etherdev alloc failedn");
  177. error = -ENOMEM;
  178. goto err_out;
  179. }
  181. error = pci_enable_device (pdev);
  182. if (error) {
  183. printk (KERN_ERR
  184. "(rcpci45 driver:) %d: pci enable device errorn",
  185. card_idx);
  186. goto err_out;
  187. }
  188. error = -ENOMEM;
  189. pci_start = pci_resource_start (pdev, 0);
  190. pci_len = pci_resource_len (pdev, 0);
  191. printk("pci_start %x pci_len %xn", pci_start, pci_len);
  193. pci_set_drvdata (pdev, dev);
  195. pDpa = dev->priv;
  196. pDpa->id = card_idx;
  197. pDpa->pci_addr = pci_start;
  199. if (!pci_start || !(pci_resource_flags (pdev, 0) & IORESOURCE_MEM)) {
  200. printk (KERN_ERR
  201. "(rcpci45 driver:) No PCI mem resources! Abortingn");
  202. error = -EBUSY;
  203. goto err_out_free_dev;
  204. }
  206. /*
  207.  * pDpa->msgbuf is where the card will dma the I2O 
  208.  * messages. Thus, we need contiguous physical pages of
  209.  * memory.
  210.  */
  211. pDpa->msgbuf = kmalloc (MSG_BUF_SIZE, GFP_DMA|GFP_ATOMIC|GFP_KERNEL);
  212. if (!pDpa->msgbuf) {
  213. printk (KERN_ERR "(rcpci45 driver:) 
  214. Could not allocate %d byte memory for the 
  215. private msgbuf!n", MSG_BUF_SIZE);
  216. goto err_out_free_dev;
  217. }
  219. /*
  220.  * Save the starting address of the LAN API private area.  We'll
  221.  * pass that to RCInitI2OMsgLayer().
  222.  *
  223.  */
  224. pDpa->PLanApiPA = (void *) (((long) pDpa->msgbuf + 0xff) & ~0xff);
  226. /* The adapter is accessible through memory-access read/write, not
  227.  * I/O read/write.  Thus, we need to map it to some virtual address
  228.  * area in order to access the registers as normal memory.
  229.  */
  230. error = pci_request_regions (pdev, dev->name);
  231. if (error)
  232. goto err_out_free_msgbuf;
  234. vaddr = (ulong *) ioremap (pci_start, pci_len);
  235. if (!vaddr) {
  236. printk (KERN_ERR
  237. "(rcpci45 driver:) 
  238. Unable to remap address range from %lu to %lun",
  239. pci_start, pci_start + pci_len);
  240. goto err_out_free_region;
  241. }
  243. dev->base_addr = (unsigned long) vaddr;
  244. dev->irq = pdev->irq;
  245. dev->open = &RCopen;
  246. dev->hard_start_xmit = &RC_xmit_packet;
  247. dev->stop = &RCclose;
  248. dev->get_stats = &RCget_stats;
  249. dev->do_ioctl = &RCioctl;
  250. dev->set_config = &RCconfig;
  252. return 0; /* success */
  254. err_out_free_region:
  255. pci_release_regions (pdev);
  256. err_out_free_msgbuf:
  257. kfree (pDpa->msgbuf);
  258. err_out_free_dev:
  259. unregister_netdev (dev);
  260. kfree (dev);
  261. err_out:
  262. card_idx--;
  263. return -ENODEV;
  264. }
  266. static struct pci_driver rcpci45_driver = {
  267. name: "rcpci45",
  268. id_table: rcpci45_pci_table,
  269. probe: rcpci45_init_one,
  270. remove: __devexit_p(rcpci45_remove_one),
  271. };
  273. static int __init
  274. rcpci_init_module (void)
  275. {
  276. int rc = pci_module_init (&rcpci45_driver);
  277. if (!rc)
  278. printk (KERN_ERR "%s", version);
  279. return rc;
  280. }
  282. static int
  283. RCopen (struct net_device *dev)
  284. {
  285. int post_buffers = MAX_NMBR_RCV_BUFFERS;
  286. PDPA pDpa = dev->priv;
  287. int count = 0;
  288. int requested = 0;
  289. int error;
  291. MOD_INC_USE_COUNT;
  292. if (pDpa->nexus) {
  293. /* This is not the first time RCopen is called.  Thus,
  294.  * the interface was previously opened and later closed
  295.  * by RCclose().  RCclose() does a Shutdown; to wake up
  296.  * the adapter, a reset is mandatory before we can post
  297.  * receive buffers.  However, if the adapter initiated 
  298.  * a reboot while the interface was closed -- and interrupts
  299.  * were turned off -- we need will need to reinitialize
  300.  * the adapter, rather than simply waking it up.  
  301.  */
  302. printk (KERN_INFO "Waking up adapter...n");
  303. RCResetLANCard (dev, 0, 0, 0);
  304. } else {
  305. pDpa->nexus = 1;
  306. /* 
  307.  * RCInitI2OMsgLayer is done only once, unless the
  308.  * adapter was sent a warm reboot
  309.  */
  310. error = RCInitI2OMsgLayer (dev, (PFNTXCALLBACK) RCxmit_callback,
  311.    (PFNRXCALLBACK) RCrecv_callback,
  312.    (PFNCALLBACK) RCreboot_callback);
  313. if (error) {
  314. printk (KERN_ERR "%s: Unable to init msg layer (%x)n",
  315. dev->name, error);
  316. goto err_out;
  317. }
  318. if ((error = RCGetMAC (dev, NULL))) {
  319. printk (KERN_ERR "%s: Unable to get adapter MACn",
  320. dev->name);
  321. goto err_out;
  322. }
  323. }
  325. /* Request a shared interrupt line. */
  326. error = request_irq (dev->irq, RCinterrupt, SA_SHIRQ, dev->name, dev);
  327. if (error) {
  328. printk (KERN_ERR "%s: unable to get IRQ %dn", 
  329. dev->name, dev->irq);
  330. goto err_out;
  331. }
  333. DriverControlWord |= WARM_REBOOT_CAPABLE;
  334. RCReportDriverCapability (dev, DriverControlWord);
  336. printk (KERN_INFO "%s: RedCreek Communications IPSEC VPN adaptern",
  337. dev->name);
  339. RCEnableI2OInterrupts (dev);
  341. while (post_buffers) {
  342. if (post_buffers > MAX_NMBR_POST_BUFFERS_PER_MSG)
  343. requested = MAX_NMBR_POST_BUFFERS_PER_MSG;
  344. else
  345. requested = post_buffers;
  346. count = RC_allocate_and_post_buffers (dev, requested);
  348. if (count < requested) {
  349. /*
  350.  * Check to see if we were able to post 
  351.  * any buffers at all.
  352.  */
  353. if (post_buffers == MAX_NMBR_RCV_BUFFERS) {
  354. printk (KERN_ERR "%s: 
  355. unable to allocate any buffersn", 
  356. dev->name);
  357. goto err_out_free_irq;
  358. }
  359. printk (KERN_WARNING "%s: 
  360. unable to allocate all requested buffersn", dev->name);
  361. break; /* we'll try to post more buffers later */
  362. } else
  363. post_buffers -= count;
  364. }
  365. pDpa->numOutRcvBuffers = MAX_NMBR_RCV_BUFFERS - post_buffers;
  366. pDpa->shutdown = 0; /* just in case */
  367. netif_start_queue (dev);
  368. return 0;
  370. err_out_free_irq:
  371. free_irq (dev->irq, dev);
  372. err_out:
  373. MOD_DEC_USE_COUNT;
  374. return error;
  375. }
  377. static int
  378. RC_xmit_packet (struct sk_buff *skb, struct net_device *dev)
  379. {
  381. PDPA pDpa = dev->priv;
  382. singleTCB tcb;
  383. psingleTCB ptcb = &tcb;
  384. RC_RETURN status = 0;
  386. netif_stop_queue (dev);
  388. if (pDpa->shutdown || pDpa->reboot) {
  389. printk ("RC_xmit_packet: tbusy!n");
  390. return 1;
  391. }
  393. /*
  394.  * The user is free to reuse the TCB after RCI2OSendPacket() 
  395.  * returns, since the function copies the necessary info into its 
  396.  * own private space.  Thus, our TCB can be a local structure.  
  397.  * The skb, on the other hand, will be freed up in our interrupt 
  398.  * handler.
  399.  */
  401. ptcb->bcount = 1;
  403. /* 
  404.  * we'll get the context when the adapter interrupts us to tell us that
  405.  * the transmission is done. At that time, we can free skb.
  406.  */
  407. ptcb->b.context = (U32) skb;
  408. ptcb->b.scount = 1;
  409. ptcb->b.size = skb->len;
  410. ptcb->b.addr = virt_to_bus ((void *) skb->data);
  412. if ((status = RCI2OSendPacket (dev, (U32) NULL, (PRCTCB) ptcb))
  413.     != RC_RTN_NO_ERROR) {
  414. printk ("%s: send error 0x%xn", dev->name, (uint) status);
  415. return 1;
  416. } else {
  417. dev->trans_start = jiffies;
  418. netif_wake_queue (dev);
  419. }
  420. /*
  421.  * That's it!
  422.  */
  423. return 0;
  424. }
  426. /*
  427.  * RCxmit_callback()
  428.  *
  429.  * The transmit callback routine. It's called by RCProcI2OMsgQ()
  430.  * because the adapter is done with one or more transmit buffers and
  431.  * it's returning them to us, or we asked the adapter to return the
  432.  * outstanding transmit buffers by calling RCResetLANCard() with 
  433.  * RC_RESOURCE_RETURN_PEND_TX_BUFFERS flag. 
  434.  * All we need to do is free the buffers.
  435.  */
  436. static void
  437. RCxmit_callback (U32 Status,
  438.  U16 PcktCount, PU32 BufferContext, struct net_device *dev)
  439. {
  440. struct sk_buff *skb;
  441. PDPA pDpa = dev->priv;
  443. if (!pDpa) {
  444. printk (KERN_ERR "%s: Fatal Error in xmit callback, !pDpan",
  445. dev->name);
  446. return;
  447. }
  449. if (Status != I2O_REPLY_STATUS_SUCCESS)
  450. printk (KERN_INFO "%s: xmit_callback: Status = 0x%xn", 
  451. dev->name, (uint) Status);
  452. if (pDpa->shutdown || pDpa->reboot)
  453. printk (KERN_INFO "%s: xmit callback: shutdown||rebootn",
  454. dev->name);
  456. while (PcktCount--) {
  457. skb = (struct sk_buff *) (BufferContext[0]);
  458. BufferContext++;
  459. dev_kfree_skb_irq (skb);
  460. }
  461. netif_wake_queue (dev);
  462. }
  464. static void
  465. RCreset_callback (U32 Status, U32 p1, U32 p2, struct net_device *dev)
  466. {
  467. PDPA pDpa = dev->priv;
  469. printk ("RCreset_callback Status 0x%xn", (uint) Status);
  470. /*
  471.  * Check to see why we were called.
  472.  */
  473. if (pDpa->shutdown) {
  474. printk (KERN_INFO "%s: shutting down interfacen",
  475. dev->name);
  476. pDpa->shutdown = 0;
  477. pDpa->reboot = 0;
  478. } else if (pDpa->reboot) {
  479. printk (KERN_INFO "%s: reboot, shutdown adaptern",
  480. dev->name);
  481. /*
  482.  * We don't set any of the flags in RCShutdownLANCard()
  483.  * and we don't pass a callback routine to it.
  484.  * The adapter will have already initiated the reboot by
  485.  * the time the function returns.
  486.  */
  487. RCDisableI2OInterrupts (dev);
  488. RCShutdownLANCard (dev, 0, 0, 0);
  489. printk (KERN_INFO "%s: scheduling timer...n", dev->name);
  490. init_timer (&pDpa->timer);
  491. pDpa->timer.expires = RUN_AT ((40 * HZ) / 10); /* 4 sec. */
  492. pDpa->timer.data = (unsigned long) dev;
  493. pDpa->timer.function = &rc_timer; /* timer handler */
  494. add_timer (&pDpa->timer);
  495. }
  496. }
  498. static void
  499. RCreboot_callback (U32 Status, U32 p1, U32 p2, struct net_device *dev)
  500. {
  501. PDPA pDpa = dev->priv;
  503. printk (KERN_INFO "%s: reboot: rcv buffers outstanding = %dn",
  504.  dev->name, (uint) pDpa->numOutRcvBuffers);
  506. if (pDpa->shutdown) {
  507. printk (KERN_INFO "%s: skip reboot, shutdown initiatedn",
  508. dev->name);
  509. return;
  510. }
  511. pDpa->reboot = 1;
  512. /*
  513.  * OK, we reset the adapter and ask it to return all
  514.  * outstanding transmit buffers as well as the posted
  515.  * receive buffers.  When the adapter is done returning
  516.  * those buffers, it will call our RCreset_callback() 
  517.  * routine.  In that routine, we'll call RCShutdownLANCard()
  518.  * to tell the adapter that it's OK to start the reboot and
  519.  * schedule a timer callback routine to execute 3 seconds 
  520.  * later; this routine will reinitialize the adapter at that time.
  521.  */
  522. RCResetLANCard (dev, RC_RESOURCE_RETURN_POSTED_RX_BUCKETS |
  523. RC_RESOURCE_RETURN_PEND_TX_BUFFERS, 0,
  524. (PFNCALLBACK) RCreset_callback);
  525. }
  527. int
  528. broadcast_packet (unsigned char *address)
  529. {
  530. int i;
  531. for (i = 0; i < 6; i++)
  532. if (address[i] != 0xff)
  533. return 0;
  535. return 1;
  536. }
  538. /*
  539.  * RCrecv_callback()
  540.  * 
  541.  * The receive packet callback routine.  This is called by
  542.  * RCProcI2OMsgQ() after the adapter posts buffers which have been
  543.  * filled (one ethernet packet per buffer).
  544.  */
  545. static void
  546. RCrecv_callback (U32 Status,
  547.  U8 PktCount,
  548.  U32 BucketsRemain,
  549.  PU32 PacketDescBlock, struct net_device *dev)
  550. {
  552. U32 len, count;
  553. PDPA pDpa = dev->priv;
  554. struct sk_buff *skb;
  555. singleTCB tcb;
  556. psingleTCB ptcb = &tcb;
  558. ptcb->bcount = 1;
  560. if ((pDpa->shutdown || pDpa->reboot) && !Status)
  561. printk (KERN_INFO "%s: shutdown||reboot && !Status (%d)n",
  562. dev->name, PktCount);
  564. if ((Status != I2O_REPLY_STATUS_SUCCESS) || pDpa->shutdown) {
  565. /*
  566.  * Free whatever buffers the adapter returned, but don't
  567.  * pass them to the kernel.
  568.  */
  570. if (!pDpa->shutdown && !pDpa->reboot)
  571. printk (KERN_INFO "%s: recv error status = 0x%xn",
  572. dev->name, (uint) Status);
  573. else
  574. printk (KERN_DEBUG "%s: Returning %d buffs stat 0x%xn",
  575. dev->name, PktCount, (uint) Status);
  576. /*
  577.  * TO DO: check the nature of the failure and put the 
  578.  * adapter in failed mode if it's a hard failure.  
  579.  * Send a reset to the adapter and free all outstanding memory.
  580.  */
  581. if (PacketDescBlock) {
  582. while (PktCount--) {
  583. skb = (struct sk_buff *) PacketDescBlock[0];
  584. dev_kfree_skb (skb);
  585. pDpa->numOutRcvBuffers--;
  586. /* point to next context field */
  587. PacketDescBlock += BD_SIZE;
  588. }
  589. }
  590. return;
  591. } else {
  592. while (PktCount--) {
  593. skb = (struct sk_buff *) PacketDescBlock[0];
  594. len = PacketDescBlock[2];
  595. skb->dev = dev;
  596. skb_put (skb, len); /* adjust length and tail */
  597. skb->protocol = eth_type_trans (skb, dev);
  598. netif_rx (skb); /* send the packet to the kernel */
  599. dev->last_rx = jiffies;
  600. pDpa->numOutRcvBuffers--;
  601. /* point to next context field */
  602. PacketDescBlock += BD_SIZE;
  603. }
  604. }
  606. /*
  607.  * Replenish the posted receive buffers. 
  608.  * DO NOT replenish buffers if the driver has already
  609.  * initiated a reboot or shutdown!
  610.  */
  612. if (!pDpa->shutdown && !pDpa->reboot) {
  613. count = RC_allocate_and_post_buffers (dev,
  614.       MAX_NMBR_RCV_BUFFERS -
  615.       pDpa->numOutRcvBuffers);
  616. pDpa->numOutRcvBuffers += count;
  617. }
  619. }
  621. /*
  622.  * RCinterrupt()
  623.  * 
  624.  * Interrupt handler. 
  625.  * This routine sets up a couple of pointers and calls
  626.  * RCProcI2OMsgQ(), which in turn process the message and
  627.  * calls one of our callback functions.
  628.  */
  629. static void
  630. RCinterrupt (int irq, void *dev_id, struct pt_regs *regs)
  631. {
  633. PDPA pDpa;
  634. struct net_device *dev = dev_id;
  636. pDpa = dev->priv;
  638. if (pDpa->shutdown)
  639. printk (KERN_DEBUG "%s: shutdown, service irqn",
  640. dev->name);
  642. RCProcI2OMsgQ (dev);
  643. }
  645. #define REBOOT_REINIT_RETRY_LIMIT 4
  646. static void
  647. rc_timer (unsigned long data)
  648. {
  649. struct net_device *dev = (struct net_device *) data;
  650. PDPA pDpa = dev->priv;
  651. int init_status;
  652. static int retry;
  653. int post_buffers = MAX_NMBR_RCV_BUFFERS;
  654. int count = 0;
  655. int requested = 0;
  657. if (pDpa->reboot) {
  658. init_status =
  659.     RCInitI2OMsgLayer (dev, (PFNTXCALLBACK) RCxmit_callback,
  660.        (PFNRXCALLBACK) RCrecv_callback,
  661.        (PFNCALLBACK) RCreboot_callback);
  663. switch (init_status) {
  664. case RC_RTN_NO_ERROR:
  666. pDpa->reboot = 0;
  667. pDpa->shutdown = 0; /* just in case */
  668. RCReportDriverCapability (dev, DriverControlWord);
  669. RCEnableI2OInterrupts (dev);
  672. if (!(dev->flags & IFF_UP)) {
  673. retry = 0;
  674. return;
  675. }
  676. while (post_buffers) {
  677. if (post_buffers > 
  678. MAX_NMBR_POST_BUFFERS_PER_MSG)
  679. requested = 
  680. MAX_NMBR_POST_BUFFERS_PER_MSG;
  681. else
  682. requested = post_buffers;
  683. count =
  684.     RC_allocate_and_post_buffers (dev,
  685.   requested);
  686. post_buffers -= count;
  687. if (count < requested)
  688. break;
  689. }
  690. pDpa->numOutRcvBuffers =
  691.     MAX_NMBR_RCV_BUFFERS - post_buffers;
  692. printk ("Initialization done.n");
  693. netif_wake_queue (dev);
  694. retry = 0;
  695. return;
  696. case RC_RTN_FREE_Q_EMPTY:
  697. retry++;
  698. printk (KERN_WARNING "%s inbound free q emptyn",
  699. dev->name);
  700. break;
  701. default:
  702. retry++;
  703. printk (KERN_WARNING "%s bad stat after reboot: %dn",
  704. dev->name, init_status);
  705. break;
  706. }
  708. if (retry > REBOOT_REINIT_RETRY_LIMIT) {
  709. printk (KERN_WARNING "%s unable to reinitialize adapter after rebootn", dev->name);
  710. printk (KERN_WARNING "%s decrementing driver and closing interfacen", dev->name);
  711. RCDisableI2OInterrupts (dev);
  712. dev->flags &= ~IFF_UP;
  713. MOD_DEC_USE_COUNT;
  714. } else {
  715. printk (KERN_INFO "%s: rescheduling timer...n",
  716. dev->name);
  717. init_timer (&pDpa->timer);
  718. pDpa->timer.expires = RUN_AT ((40 * HZ) / 10);
  719. pDpa->timer.data = (unsigned long) dev;
  720. pDpa->timer.function = &rc_timer;
  721. add_timer (&pDpa->timer);
  722. }
  723. } else
  724. printk (KERN_WARNING "%s: unexpected timer irqn", dev->name);
  725. }
  727. static int
  728. RCclose (struct net_device *dev)
  729. {
  730. PDPA pDpa = dev->priv;
  732. printk("RCclosen");
  733. netif_stop_queue (dev);
  735. if (pDpa->reboot) {
  736. printk (KERN_INFO "%s skipping reset -- adapter already in reboot moden", dev->name);
  737. dev->flags &= ~IFF_UP;
  738. pDpa->shutdown = 1;
  739. MOD_DEC_USE_COUNT;
  740. return 0;
  741. }
  743. pDpa->shutdown = 1;
  745. /*
  746.  * We can't allow the driver to be unloaded until the adapter returns
  747.  * all posted receive buffers.  It doesn't hurt to tell the adapter
  748.  * to return all posted receive buffers and outstanding xmit buffers,
  749.  * even if there are none.
  750.  */
  752. RCShutdownLANCard (dev, RC_RESOURCE_RETURN_POSTED_RX_BUCKETS |
  753.    RC_RESOURCE_RETURN_PEND_TX_BUFFERS, 0,
  754.    (PFNCALLBACK) RCreset_callback);
  756. dev->flags &= ~IFF_UP;
  757. MOD_DEC_USE_COUNT;
  758. return 0;
  759. }
  761. static struct net_device_stats *
  762. RCget_stats (struct net_device *dev)
  763. {
  764. RCLINKSTATS RCstats;
  766. PDPA pDpa = dev->priv;
  768. if (!pDpa) {
  769. return 0;
  770. } else if (!(dev->flags & IFF_UP)) {
  771. return 0;
  772. }
  774. memset (&RCstats, 0, sizeof (RCLINKSTATS));
  775. if ((RCGetLinkStatistics (dev, &RCstats, (void *) 0)) ==
  776.     RC_RTN_NO_ERROR) {
  778. /* total packets received    */
  779. pDpa->stats.rx_packets = RCstats.Rcv_good
  780. /* total packets transmitted    */;
  781. pDpa->stats.tx_packets = RCstats.TX_good;
  783. pDpa->stats.rx_errors = RCstats.Rcv_CRCerr + 
  784. RCstats.Rcv_alignerr + RCstats.Rcv_reserr + 
  785. RCstats.Rcv_orun + RCstats.Rcv_cdt + RCstats.Rcv_runt;
  787. pDpa->stats.tx_errors = RCstats.TX_urun + RCstats.TX_crs + 
  788. RCstats.TX_def + RCstats.TX_totcol;
  790. /*
  791.  * This needs improvement.
  792.  */
  793. pDpa->stats.rx_dropped = 0; /* no space in linux buffers   */
  794. pDpa->stats.tx_dropped = 0; /* no space available in linux */
  795. pDpa->stats.multicast = 0;  /* multicast packets received  */
  796. pDpa->stats.collisions = RCstats.TX_totcol;
  798. /* detailed rx_errors: */
  799. pDpa->stats.rx_length_errors = 0;
  800. pDpa->stats.rx_over_errors = RCstats.Rcv_orun;
  801. pDpa->stats.rx_crc_errors = RCstats.Rcv_CRCerr;
  802. pDpa->stats.rx_frame_errors = 0;
  803. pDpa->stats.rx_fifo_errors = 0;
  804. pDpa->stats.rx_missed_errors = 0;
  806. /* detailed tx_errors */
  807. pDpa->stats.tx_aborted_errors = 0;
  808. pDpa->stats.tx_carrier_errors = 0;
  809. pDpa->stats.tx_fifo_errors = 0;
  810. pDpa->stats.tx_heartbeat_errors = 0;
  811. pDpa->stats.tx_window_errors = 0;
  813. return ((struct net_device_stats *) &(pDpa->stats));
  814. }
  815. return 0;
  816. }
  818. static int
  819. RCioctl (struct net_device *dev, struct ifreq *rq, int cmd)
  820. {
  821. RCuser_struct RCuser;
  822. PDPA pDpa = dev->priv;
  824. if (!capable (CAP_NET_ADMIN))
  825. return -EPERM;
  827. switch (cmd) {
  829. case RCU_PROTOCOL_REV:
  830. /*
  831.  * Assign user protocol revision, to tell user-level
  832.  * controller program whether or not it's in sync.
  833.  */
  834. rq->ifr_ifru.ifru_data = (caddr_t) USER_PROTOCOL_REV;
  835. break;
  837. case RCU_COMMAND:
  838. {
  839. if (copy_from_user
  840.     (&RCuser, rq->ifr_data, sizeof (RCuser)))
  841. return -EFAULT;
  843. dprintk ("RCioctl: RCuser_cmd = 0x%xn", RCuser.cmd);
  845. switch (RCuser.cmd) {
  846. case RCUC_GETFWVER:
  847. RCUD_GETFWVER = &RCuser.RCUS_GETFWVER;
  848. RCGetFirmwareVer (dev,
  849.   (PU8) & RCUD_GETFWVER->
  850.   FirmString, NULL);
  851. break;
  852. case RCUC_GETINFO:
  853. RCUD_GETINFO = &RCuser.RCUS_GETINFO;
  854. RCUD_GETINFO->mem_start = dev->base_addr;
  855. RCUD_GETINFO->mem_end =
  856.     dev->base_addr + pDpa->pci_addr_len;
  857. RCUD_GETINFO->base_addr = pDpa->pci_addr;
  858. RCUD_GETINFO->irq = dev->irq;
  859. break;
  860. case RCUC_GETIPANDMASK:
  861. RCUD_GETIPANDMASK = &RCuser.RCUS_GETIPANDMASK;
  862. RCGetRavlinIPandMask (dev,
  863.       (PU32) &
  864.       RCUD_GETIPANDMASK->IpAddr,
  865.       (PU32) &
  866.       RCUD_GETIPANDMASK->
  867.       NetMask, NULL);
  868. break;
  869. case RCUC_GETLINKSTATISTICS:
  870. RCUD_GETLINKSTATISTICS =
  871.     &RCuser.RCUS_GETLINKSTATISTICS;
  872. RCGetLinkStatistics (dev,
  873.      (P_RCLINKSTATS) &
  874.      RCUD_GETLINKSTATISTICS->
  875.      StatsReturn, NULL);
  876. break;
  877. case RCUC_GETLINKSTATUS:
  878. RCUD_GETLINKSTATUS = &RCuser.RCUS_GETLINKSTATUS;
  879. RCGetLinkStatus (dev,
  880.  (PU32) & RCUD_GETLINKSTATUS->
  881.  ReturnStatus, NULL);
  882. break;
  883. case RCUC_GETMAC:
  884. RCUD_GETMAC = &RCuser.RCUS_GETMAC;
  885. RCGetMAC (dev, NULL);
  886. memcpy(RCUD_GETMAC, dev->dev_addr, 8);
  887. break;
  888. case RCUC_GETPROM:
  889. RCUD_GETPROM = &RCuser.RCUS_GETPROM;
  890. RCGetPromiscuousMode (dev,
  891.       (PU32) & RCUD_GETPROM->
  892.       PromMode, NULL);
  893. break;
  894. case RCUC_GETBROADCAST:
  895. RCUD_GETBROADCAST = &RCuser.RCUS_GETBROADCAST;
  896. RCGetBroadcastMode (dev,
  897.     (PU32) & RCUD_GETBROADCAST->
  898.     BroadcastMode, NULL);
  899. break;
  900. case RCUC_GETSPEED:
  901. if (!(dev->flags & IFF_UP)) {
  902. return -ENODATA;
  903. }
  904. RCUD_GETSPEED = &RCuser.RCUS_GETSPEED;
  905. RCGetLinkSpeed (dev,
  906. (PU32) & RCUD_GETSPEED->
  907. LinkSpeedCode, NULL);
  908. break;
  909. case RCUC_SETIPANDMASK:
  910. RCUD_SETIPANDMASK = &RCuser.RCUS_SETIPANDMASK;
  911. RCSetRavlinIPandMask (dev,
  912.       (U32) RCUD_SETIPANDMASK->
  913.       IpAddr,
  914.       (U32) RCUD_SETIPANDMASK->
  915.       NetMask);
  916. break;
  917. case RCUC_SETMAC:
  918. RCSetMAC (dev, (PU8) & RCUD_SETMAC->mac);
  919. break;
  920. case RCUC_SETSPEED:
  921. RCUD_SETSPEED = &RCuser.RCUS_SETSPEED;
  922. RCSetLinkSpeed (dev,
  923. (U16) RCUD_SETSPEED->
  924. LinkSpeedCode);
  925. break;
  926. case RCUC_SETPROM:
  927. RCUD_SETPROM = &RCuser.RCUS_SETPROM;
  928. RCSetPromiscuousMode (dev,
  929.       (U16) RCUD_SETPROM->
  930.       PromMode);
  931. break;
  932. case RCUC_SETBROADCAST:
  933. RCUD_SETBROADCAST = &RCuser.RCUS_SETBROADCAST;
  934. RCSetBroadcastMode (dev,
  935.     (U16) RCUD_SETBROADCAST->
  936.     BroadcastMode);
  937. break;
  938. default:
  939. RCUD_DEFAULT = &RCuser.RCUS_DEFAULT;
  940. RCUD_DEFAULT->rc = 0x11223344;
  941. break;
  942. }
  943. if (copy_to_user (rq->ifr_data, &RCuser, 
  944. sizeof (RCuser)))
  945. return -EFAULT;
  946. break;
  947. } /* RCU_COMMAND */
  949. default:
  950. rq->ifr_ifru.ifru_data = (caddr_t) 0x12345678;
  951. return -EINVAL;
  952. }
  953. return 0;
  954. }
  956. static int
  957. RCconfig (struct net_device *dev, struct ifmap *map)
  958. {
  959. /*
  960.  * To be completed ...
  961.  */
  962. return 0;
  963. if (dev->flags & IFF_UP) /* can't act on a running interface */
  964. return -EBUSY;
  966. /* Don't allow changing the I/O address */
  967. if (map->base_addr != dev->base_addr) {
  968. printk (KERN_WARNING "%s Change I/O address not implementedn",
  969. dev->name);
  970. return -EOPNOTSUPP;
  971. }
  972. return 0;
  973. }
  975. static void __exit
  976. rcpci_cleanup_module (void)
  977. {
  978. pci_unregister_driver (&rcpci45_driver);
  979. }
  981. module_init (rcpci_init_module);
  982. module_exit (rcpci_cleanup_module);
  984. static int
  985. RC_allocate_and_post_buffers (struct net_device *dev, int numBuffers)
  986. {
  988. int i;
  989. PU32 p;
  990. psingleB pB;
  991. struct sk_buff *skb;
  992. RC_RETURN status;
  993. U32 res;
  995. if (!numBuffers)
  996. return 0;
  997. else if (numBuffers > MAX_NMBR_POST_BUFFERS_PER_MSG) {
  998. printk (KERN_ERR "%s: Too many buffers requested!n",
  999. dev->name);
  1000. numBuffers = 32;
  1001. }
  1003. p = (PU32) kmalloc (sizeof (U32) + numBuffers * sizeof (singleB),
  1004.     GFP_DMA|GFP_ATOMIC|GFP_KERNEL);
  1006. if (!p) {
  1007. printk (KERN_WARNING "%s unable to allocate TCBn",
  1008. dev->name);
  1009. return 0;
  1010. }
  1012. p[0] = 0; /* Buffer Count */
  1013. pB = (psingleB) ((U32) p + sizeof (U32));/* point to the first buffer */
  1015. for (i = 0; i < numBuffers; i++) {
  1016. skb = dev_alloc_skb (MAX_ETHER_SIZE + 2);
  1017. if (!skb) {
  1018. printk (KERN_WARNING 
  1019. "%s: unable to allocate enough skbs!n",
  1020. dev->name);
  1021. if (*p != 0) { /* did we allocate any buffers */
  1022. break;
  1023. } else {
  1024. kfree (p); /* Free the TCB */
  1025. return 0;
  1026. }
  1027. }
  1028. skb_reserve (skb, 2); /* Align IP on 16 byte boundaries */
  1029. pB->context = (U32) skb;
  1030. pB->scount = 1; /* segment count */
  1031. pB->size = MAX_ETHER_SIZE;
  1032. pB->addr = virt_to_bus ((void *) skb->data);
  1033. p[0]++;
  1034. pB++;
  1035. }
  1037. if ((status = RCPostRecvBuffers (dev, (PRCTCB) p)) != RC_RTN_NO_ERROR) {
  1038. printk (KERN_WARNING "%s: Post buffer failed, error 0x%xn",
  1039. dev->name, status);
  1040. /* point to the first buffer */
  1041. pB = (psingleB) ((U32) p + sizeof (U32));
  1042. while (p[0]) {
  1043. skb = (struct sk_buff *) pB->context;
  1044. dev_kfree_skb (skb);
  1045. p[0]--;
  1046. pB++;
  1047. }
  1048. }
  1049. res = p[0];
  1050. kfree (p);
  1051. return (res); /* return the number of posted buffers */
  1052. }