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