1 /* 2 * rrunner.c: Linux driver for the Essential RoadRunner HIPPI board. 3 * 4 * Copyright (C) 1998-2002 by Jes Sorensen, <jes@wildopensource.com>. 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 * 23 * PCI DMA mapping code partly based on work by Francois Romieu. 24 */ 25 26 27 #define DEBUG 1 28 #define RX_DMA_SKBUFF 1 29 #define PKT_COPY_THRESHOLD 512 30 31 #include <linux/module.h> 32 #include <linux/types.h> 33 #include <linux/errno.h> 34 #include <linux/ioport.h> 35 #include <linux/pci.h> 36 #include <linux/kernel.h> 37 #include <linux/netdevice.h> 38 #include <linux/hippidevice.h> 39 #include <linux/skbuff.h> 40 #include <linux/delay.h> 41 #include <linux/mm.h> 42 #include <linux/slab.h> 43 #include <net/sock.h> 44 45 #include <asm/cache.h> 46 #include <asm/byteorder.h> 47 #include <asm/io.h> 48 #include <asm/irq.h> 49 #include <linux/uaccess.h> 50 51 #define rr_if_busy(dev) netif_queue_stopped(dev) 52 #define rr_if_running(dev) netif_running(dev) 53 54 #include "rrunner.h" 55 56 #define RUN_AT(x) (jiffies + (x)) 57 58 59 MODULE_AUTHOR("Jes Sorensen <jes@wildopensource.com>"); 60 MODULE_DESCRIPTION("Essential RoadRunner HIPPI driver"); 61 MODULE_LICENSE("GPL"); 62 63 static const char version[] = 64 "rrunner.c: v0.50 11/11/2002 Jes Sorensen (jes@wildopensource.com)\n"; 65 66 67 static const struct net_device_ops rr_netdev_ops = { 68 .ndo_open = rr_open, 69 .ndo_stop = rr_close, 70 .ndo_do_ioctl = rr_ioctl, 71 .ndo_start_xmit = rr_start_xmit, 72 .ndo_set_mac_address = hippi_mac_addr, 73 }; 74 75 /* 76 * Implementation notes: 77 * 78 * The DMA engine only allows for DMA within physical 64KB chunks of 79 * memory. The current approach of the driver (and stack) is to use 80 * linear blocks of memory for the skbuffs. However, as the data block 81 * is always the first part of the skb and skbs are 2^n aligned so we 82 * are guarantted to get the whole block within one 64KB align 64KB 83 * chunk. 84 * 85 * On the long term, relying on being able to allocate 64KB linear 86 * chunks of memory is not feasible and the skb handling code and the 87 * stack will need to know about I/O vectors or something similar. 88 */ 89 90 static int rr_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 91 { 92 struct net_device *dev; 93 static int version_disp; 94 u8 pci_latency; 95 struct rr_private *rrpriv; 96 void *tmpptr; 97 dma_addr_t ring_dma; 98 int ret = -ENOMEM; 99 100 dev = alloc_hippi_dev(sizeof(struct rr_private)); 101 if (!dev) 102 goto out3; 103 104 ret = pci_enable_device(pdev); 105 if (ret) { 106 ret = -ENODEV; 107 goto out2; 108 } 109 110 rrpriv = netdev_priv(dev); 111 112 SET_NETDEV_DEV(dev, &pdev->dev); 113 114 ret = pci_request_regions(pdev, "rrunner"); 115 if (ret < 0) 116 goto out; 117 118 pci_set_drvdata(pdev, dev); 119 120 rrpriv->pci_dev = pdev; 121 122 spin_lock_init(&rrpriv->lock); 123 124 dev->netdev_ops = &rr_netdev_ops; 125 126 /* display version info if adapter is found */ 127 if (!version_disp) { 128 /* set display flag to TRUE so that */ 129 /* we only display this string ONCE */ 130 version_disp = 1; 131 printk(version); 132 } 133 134 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency); 135 if (pci_latency <= 0x58){ 136 pci_latency = 0x58; 137 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, pci_latency); 138 } 139 140 pci_set_master(pdev); 141 142 printk(KERN_INFO "%s: Essential RoadRunner serial HIPPI " 143 "at 0x%llx, irq %i, PCI latency %i\n", dev->name, 144 (unsigned long long)pci_resource_start(pdev, 0), 145 pdev->irq, pci_latency); 146 147 /* 148 * Remap the MMIO regs into kernel space. 149 */ 150 rrpriv->regs = pci_iomap(pdev, 0, 0x1000); 151 if (!rrpriv->regs) { 152 printk(KERN_ERR "%s: Unable to map I/O register, " 153 "RoadRunner will be disabled.\n", dev->name); 154 ret = -EIO; 155 goto out; 156 } 157 158 tmpptr = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma); 159 rrpriv->tx_ring = tmpptr; 160 rrpriv->tx_ring_dma = ring_dma; 161 162 if (!tmpptr) { 163 ret = -ENOMEM; 164 goto out; 165 } 166 167 tmpptr = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma); 168 rrpriv->rx_ring = tmpptr; 169 rrpriv->rx_ring_dma = ring_dma; 170 171 if (!tmpptr) { 172 ret = -ENOMEM; 173 goto out; 174 } 175 176 tmpptr = pci_alloc_consistent(pdev, EVT_RING_SIZE, &ring_dma); 177 rrpriv->evt_ring = tmpptr; 178 rrpriv->evt_ring_dma = ring_dma; 179 180 if (!tmpptr) { 181 ret = -ENOMEM; 182 goto out; 183 } 184 185 /* 186 * Don't access any register before this point! 187 */ 188 #ifdef __BIG_ENDIAN 189 writel(readl(&rrpriv->regs->HostCtrl) | NO_SWAP, 190 &rrpriv->regs->HostCtrl); 191 #endif 192 /* 193 * Need to add a case for little-endian 64-bit hosts here. 194 */ 195 196 rr_init(dev); 197 198 ret = register_netdev(dev); 199 if (ret) 200 goto out; 201 return 0; 202 203 out: 204 if (rrpriv->evt_ring) 205 pci_free_consistent(pdev, EVT_RING_SIZE, rrpriv->evt_ring, 206 rrpriv->evt_ring_dma); 207 if (rrpriv->rx_ring) 208 pci_free_consistent(pdev, RX_TOTAL_SIZE, rrpriv->rx_ring, 209 rrpriv->rx_ring_dma); 210 if (rrpriv->tx_ring) 211 pci_free_consistent(pdev, TX_TOTAL_SIZE, rrpriv->tx_ring, 212 rrpriv->tx_ring_dma); 213 if (rrpriv->regs) 214 pci_iounmap(pdev, rrpriv->regs); 215 if (pdev) 216 pci_release_regions(pdev); 217 out2: 218 free_netdev(dev); 219 out3: 220 return ret; 221 } 222 223 static void rr_remove_one(struct pci_dev *pdev) 224 { 225 struct net_device *dev = pci_get_drvdata(pdev); 226 struct rr_private *rr = netdev_priv(dev); 227 228 if (!(readl(&rr->regs->HostCtrl) & NIC_HALTED)) { 229 printk(KERN_ERR "%s: trying to unload running NIC\n", 230 dev->name); 231 writel(HALT_NIC, &rr->regs->HostCtrl); 232 } 233 234 unregister_netdev(dev); 235 pci_free_consistent(pdev, EVT_RING_SIZE, rr->evt_ring, 236 rr->evt_ring_dma); 237 pci_free_consistent(pdev, RX_TOTAL_SIZE, rr->rx_ring, 238 rr->rx_ring_dma); 239 pci_free_consistent(pdev, TX_TOTAL_SIZE, rr->tx_ring, 240 rr->tx_ring_dma); 241 pci_iounmap(pdev, rr->regs); 242 pci_release_regions(pdev); 243 pci_disable_device(pdev); 244 free_netdev(dev); 245 } 246 247 248 /* 249 * Commands are considered to be slow, thus there is no reason to 250 * inline this. 251 */ 252 static void rr_issue_cmd(struct rr_private *rrpriv, struct cmd *cmd) 253 { 254 struct rr_regs __iomem *regs; 255 u32 idx; 256 257 regs = rrpriv->regs; 258 /* 259 * This is temporary - it will go away in the final version. 260 * We probably also want to make this function inline. 261 */ 262 if (readl(®s->HostCtrl) & NIC_HALTED){ 263 printk("issuing command for halted NIC, code 0x%x, " 264 "HostCtrl %08x\n", cmd->code, readl(®s->HostCtrl)); 265 if (readl(®s->Mode) & FATAL_ERR) 266 printk("error codes Fail1 %02x, Fail2 %02x\n", 267 readl(®s->Fail1), readl(®s->Fail2)); 268 } 269 270 idx = rrpriv->info->cmd_ctrl.pi; 271 272 writel(*(u32*)(cmd), ®s->CmdRing[idx]); 273 wmb(); 274 275 idx = (idx - 1) % CMD_RING_ENTRIES; 276 rrpriv->info->cmd_ctrl.pi = idx; 277 wmb(); 278 279 if (readl(®s->Mode) & FATAL_ERR) 280 printk("error code %02x\n", readl(®s->Fail1)); 281 } 282 283 284 /* 285 * Reset the board in a sensible manner. The NIC is already halted 286 * when we get here and a spin-lock is held. 287 */ 288 static int rr_reset(struct net_device *dev) 289 { 290 struct rr_private *rrpriv; 291 struct rr_regs __iomem *regs; 292 u32 start_pc; 293 int i; 294 295 rrpriv = netdev_priv(dev); 296 regs = rrpriv->regs; 297 298 rr_load_firmware(dev); 299 300 writel(0x01000000, ®s->TX_state); 301 writel(0xff800000, ®s->RX_state); 302 writel(0, ®s->AssistState); 303 writel(CLEAR_INTA, ®s->LocalCtrl); 304 writel(0x01, ®s->BrkPt); 305 writel(0, ®s->Timer); 306 writel(0, ®s->TimerRef); 307 writel(RESET_DMA, ®s->DmaReadState); 308 writel(RESET_DMA, ®s->DmaWriteState); 309 writel(0, ®s->DmaWriteHostHi); 310 writel(0, ®s->DmaWriteHostLo); 311 writel(0, ®s->DmaReadHostHi); 312 writel(0, ®s->DmaReadHostLo); 313 writel(0, ®s->DmaReadLen); 314 writel(0, ®s->DmaWriteLen); 315 writel(0, ®s->DmaWriteLcl); 316 writel(0, ®s->DmaWriteIPchecksum); 317 writel(0, ®s->DmaReadLcl); 318 writel(0, ®s->DmaReadIPchecksum); 319 writel(0, ®s->PciState); 320 #if (BITS_PER_LONG == 64) && defined __LITTLE_ENDIAN 321 writel(SWAP_DATA | PTR64BIT | PTR_WD_SWAP, ®s->Mode); 322 #elif (BITS_PER_LONG == 64) 323 writel(SWAP_DATA | PTR64BIT | PTR_WD_NOSWAP, ®s->Mode); 324 #else 325 writel(SWAP_DATA | PTR32BIT | PTR_WD_NOSWAP, ®s->Mode); 326 #endif 327 328 #if 0 329 /* 330 * Don't worry, this is just black magic. 331 */ 332 writel(0xdf000, ®s->RxBase); 333 writel(0xdf000, ®s->RxPrd); 334 writel(0xdf000, ®s->RxCon); 335 writel(0xce000, ®s->TxBase); 336 writel(0xce000, ®s->TxPrd); 337 writel(0xce000, ®s->TxCon); 338 writel(0, ®s->RxIndPro); 339 writel(0, ®s->RxIndCon); 340 writel(0, ®s->RxIndRef); 341 writel(0, ®s->TxIndPro); 342 writel(0, ®s->TxIndCon); 343 writel(0, ®s->TxIndRef); 344 writel(0xcc000, ®s->pad10[0]); 345 writel(0, ®s->DrCmndPro); 346 writel(0, ®s->DrCmndCon); 347 writel(0, ®s->DwCmndPro); 348 writel(0, ®s->DwCmndCon); 349 writel(0, ®s->DwCmndRef); 350 writel(0, ®s->DrDataPro); 351 writel(0, ®s->DrDataCon); 352 writel(0, ®s->DrDataRef); 353 writel(0, ®s->DwDataPro); 354 writel(0, ®s->DwDataCon); 355 writel(0, ®s->DwDataRef); 356 #endif 357 358 writel(0xffffffff, ®s->MbEvent); 359 writel(0, ®s->Event); 360 361 writel(0, ®s->TxPi); 362 writel(0, ®s->IpRxPi); 363 364 writel(0, ®s->EvtCon); 365 writel(0, ®s->EvtPrd); 366 367 rrpriv->info->evt_ctrl.pi = 0; 368 369 for (i = 0; i < CMD_RING_ENTRIES; i++) 370 writel(0, ®s->CmdRing[i]); 371 372 /* 373 * Why 32 ? is this not cache line size dependent? 374 */ 375 writel(RBURST_64|WBURST_64, ®s->PciState); 376 wmb(); 377 378 start_pc = rr_read_eeprom_word(rrpriv, 379 offsetof(struct eeprom, rncd_info.FwStart)); 380 381 #if (DEBUG > 1) 382 printk("%s: Executing firmware at address 0x%06x\n", 383 dev->name, start_pc); 384 #endif 385 386 writel(start_pc + 0x800, ®s->Pc); 387 wmb(); 388 udelay(5); 389 390 writel(start_pc, ®s->Pc); 391 wmb(); 392 393 return 0; 394 } 395 396 397 /* 398 * Read a string from the EEPROM. 399 */ 400 static unsigned int rr_read_eeprom(struct rr_private *rrpriv, 401 unsigned long offset, 402 unsigned char *buf, 403 unsigned long length) 404 { 405 struct rr_regs __iomem *regs = rrpriv->regs; 406 u32 misc, io, host, i; 407 408 io = readl(®s->ExtIo); 409 writel(0, ®s->ExtIo); 410 misc = readl(®s->LocalCtrl); 411 writel(0, ®s->LocalCtrl); 412 host = readl(®s->HostCtrl); 413 writel(host | HALT_NIC, ®s->HostCtrl); 414 mb(); 415 416 for (i = 0; i < length; i++){ 417 writel((EEPROM_BASE + ((offset+i) << 3)), ®s->WinBase); 418 mb(); 419 buf[i] = (readl(®s->WinData) >> 24) & 0xff; 420 mb(); 421 } 422 423 writel(host, ®s->HostCtrl); 424 writel(misc, ®s->LocalCtrl); 425 writel(io, ®s->ExtIo); 426 mb(); 427 return i; 428 } 429 430 431 /* 432 * Shortcut to read one word (4 bytes) out of the EEPROM and convert 433 * it to our CPU byte-order. 434 */ 435 static u32 rr_read_eeprom_word(struct rr_private *rrpriv, 436 size_t offset) 437 { 438 __be32 word; 439 440 if ((rr_read_eeprom(rrpriv, offset, 441 (unsigned char *)&word, 4) == 4)) 442 return be32_to_cpu(word); 443 return 0; 444 } 445 446 447 /* 448 * Write a string to the EEPROM. 449 * 450 * This is only called when the firmware is not running. 451 */ 452 static unsigned int write_eeprom(struct rr_private *rrpriv, 453 unsigned long offset, 454 unsigned char *buf, 455 unsigned long length) 456 { 457 struct rr_regs __iomem *regs = rrpriv->regs; 458 u32 misc, io, data, i, j, ready, error = 0; 459 460 io = readl(®s->ExtIo); 461 writel(0, ®s->ExtIo); 462 misc = readl(®s->LocalCtrl); 463 writel(ENABLE_EEPROM_WRITE, ®s->LocalCtrl); 464 mb(); 465 466 for (i = 0; i < length; i++){ 467 writel((EEPROM_BASE + ((offset+i) << 3)), ®s->WinBase); 468 mb(); 469 data = buf[i] << 24; 470 /* 471 * Only try to write the data if it is not the same 472 * value already. 473 */ 474 if ((readl(®s->WinData) & 0xff000000) != data){ 475 writel(data, ®s->WinData); 476 ready = 0; 477 j = 0; 478 mb(); 479 while(!ready){ 480 udelay(20); 481 if ((readl(®s->WinData) & 0xff000000) == 482 data) 483 ready = 1; 484 mb(); 485 if (j++ > 5000){ 486 printk("data mismatch: %08x, " 487 "WinData %08x\n", data, 488 readl(®s->WinData)); 489 ready = 1; 490 error = 1; 491 } 492 } 493 } 494 } 495 496 writel(misc, ®s->LocalCtrl); 497 writel(io, ®s->ExtIo); 498 mb(); 499 500 return error; 501 } 502 503 504 static int rr_init(struct net_device *dev) 505 { 506 struct rr_private *rrpriv; 507 struct rr_regs __iomem *regs; 508 u32 sram_size, rev; 509 510 rrpriv = netdev_priv(dev); 511 regs = rrpriv->regs; 512 513 rev = readl(®s->FwRev); 514 rrpriv->fw_rev = rev; 515 if (rev > 0x00020024) 516 printk(" Firmware revision: %i.%i.%i\n", (rev >> 16), 517 ((rev >> 8) & 0xff), (rev & 0xff)); 518 else if (rev >= 0x00020000) { 519 printk(" Firmware revision: %i.%i.%i (2.0.37 or " 520 "later is recommended)\n", (rev >> 16), 521 ((rev >> 8) & 0xff), (rev & 0xff)); 522 }else{ 523 printk(" Firmware revision too old: %i.%i.%i, please " 524 "upgrade to 2.0.37 or later.\n", 525 (rev >> 16), ((rev >> 8) & 0xff), (rev & 0xff)); 526 } 527 528 #if (DEBUG > 2) 529 printk(" Maximum receive rings %i\n", readl(®s->MaxRxRng)); 530 #endif 531 532 /* 533 * Read the hardware address from the eeprom. The HW address 534 * is not really necessary for HIPPI but awfully convenient. 535 * The pointer arithmetic to put it in dev_addr is ugly, but 536 * Donald Becker does it this way for the GigE version of this 537 * card and it's shorter and more portable than any 538 * other method I've seen. -VAL 539 */ 540 541 *(__be16 *)(dev->dev_addr) = 542 htons(rr_read_eeprom_word(rrpriv, offsetof(struct eeprom, manf.BoardULA))); 543 *(__be32 *)(dev->dev_addr+2) = 544 htonl(rr_read_eeprom_word(rrpriv, offsetof(struct eeprom, manf.BoardULA[4]))); 545 546 printk(" MAC: %pM\n", dev->dev_addr); 547 548 sram_size = rr_read_eeprom_word(rrpriv, 8); 549 printk(" SRAM size 0x%06x\n", sram_size); 550 551 return 0; 552 } 553 554 555 static int rr_init1(struct net_device *dev) 556 { 557 struct rr_private *rrpriv; 558 struct rr_regs __iomem *regs; 559 unsigned long myjif, flags; 560 struct cmd cmd; 561 u32 hostctrl; 562 int ecode = 0; 563 short i; 564 565 rrpriv = netdev_priv(dev); 566 regs = rrpriv->regs; 567 568 spin_lock_irqsave(&rrpriv->lock, flags); 569 570 hostctrl = readl(®s->HostCtrl); 571 writel(hostctrl | HALT_NIC | RR_CLEAR_INT, ®s->HostCtrl); 572 wmb(); 573 574 if (hostctrl & PARITY_ERR){ 575 printk("%s: Parity error halting NIC - this is serious!\n", 576 dev->name); 577 spin_unlock_irqrestore(&rrpriv->lock, flags); 578 ecode = -EFAULT; 579 goto error; 580 } 581 582 set_rxaddr(regs, rrpriv->rx_ctrl_dma); 583 set_infoaddr(regs, rrpriv->info_dma); 584 585 rrpriv->info->evt_ctrl.entry_size = sizeof(struct event); 586 rrpriv->info->evt_ctrl.entries = EVT_RING_ENTRIES; 587 rrpriv->info->evt_ctrl.mode = 0; 588 rrpriv->info->evt_ctrl.pi = 0; 589 set_rraddr(&rrpriv->info->evt_ctrl.rngptr, rrpriv->evt_ring_dma); 590 591 rrpriv->info->cmd_ctrl.entry_size = sizeof(struct cmd); 592 rrpriv->info->cmd_ctrl.entries = CMD_RING_ENTRIES; 593 rrpriv->info->cmd_ctrl.mode = 0; 594 rrpriv->info->cmd_ctrl.pi = 15; 595 596 for (i = 0; i < CMD_RING_ENTRIES; i++) { 597 writel(0, ®s->CmdRing[i]); 598 } 599 600 for (i = 0; i < TX_RING_ENTRIES; i++) { 601 rrpriv->tx_ring[i].size = 0; 602 set_rraddr(&rrpriv->tx_ring[i].addr, 0); 603 rrpriv->tx_skbuff[i] = NULL; 604 } 605 rrpriv->info->tx_ctrl.entry_size = sizeof(struct tx_desc); 606 rrpriv->info->tx_ctrl.entries = TX_RING_ENTRIES; 607 rrpriv->info->tx_ctrl.mode = 0; 608 rrpriv->info->tx_ctrl.pi = 0; 609 set_rraddr(&rrpriv->info->tx_ctrl.rngptr, rrpriv->tx_ring_dma); 610 611 /* 612 * Set dirty_tx before we start receiving interrupts, otherwise 613 * the interrupt handler might think it is supposed to process 614 * tx ints before we are up and running, which may cause a null 615 * pointer access in the int handler. 616 */ 617 rrpriv->tx_full = 0; 618 rrpriv->cur_rx = 0; 619 rrpriv->dirty_rx = rrpriv->dirty_tx = 0; 620 621 rr_reset(dev); 622 623 /* Tuning values */ 624 writel(0x5000, ®s->ConRetry); 625 writel(0x100, ®s->ConRetryTmr); 626 writel(0x500000, ®s->ConTmout); 627 writel(0x60, ®s->IntrTmr); 628 writel(0x500000, ®s->TxDataMvTimeout); 629 writel(0x200000, ®s->RxDataMvTimeout); 630 writel(0x80, ®s->WriteDmaThresh); 631 writel(0x80, ®s->ReadDmaThresh); 632 633 rrpriv->fw_running = 0; 634 wmb(); 635 636 hostctrl &= ~(HALT_NIC | INVALID_INST_B | PARITY_ERR); 637 writel(hostctrl, ®s->HostCtrl); 638 wmb(); 639 640 spin_unlock_irqrestore(&rrpriv->lock, flags); 641 642 for (i = 0; i < RX_RING_ENTRIES; i++) { 643 struct sk_buff *skb; 644 dma_addr_t addr; 645 646 rrpriv->rx_ring[i].mode = 0; 647 skb = alloc_skb(dev->mtu + HIPPI_HLEN, GFP_ATOMIC); 648 if (!skb) { 649 printk(KERN_WARNING "%s: Unable to allocate memory " 650 "for receive ring - halting NIC\n", dev->name); 651 ecode = -ENOMEM; 652 goto error; 653 } 654 rrpriv->rx_skbuff[i] = skb; 655 addr = pci_map_single(rrpriv->pci_dev, skb->data, 656 dev->mtu + HIPPI_HLEN, PCI_DMA_FROMDEVICE); 657 /* 658 * Sanity test to see if we conflict with the DMA 659 * limitations of the Roadrunner. 660 */ 661 if ((((unsigned long)skb->data) & 0xfff) > ~65320) 662 printk("skb alloc error\n"); 663 664 set_rraddr(&rrpriv->rx_ring[i].addr, addr); 665 rrpriv->rx_ring[i].size = dev->mtu + HIPPI_HLEN; 666 } 667 668 rrpriv->rx_ctrl[4].entry_size = sizeof(struct rx_desc); 669 rrpriv->rx_ctrl[4].entries = RX_RING_ENTRIES; 670 rrpriv->rx_ctrl[4].mode = 8; 671 rrpriv->rx_ctrl[4].pi = 0; 672 wmb(); 673 set_rraddr(&rrpriv->rx_ctrl[4].rngptr, rrpriv->rx_ring_dma); 674 675 udelay(1000); 676 677 /* 678 * Now start the FirmWare. 679 */ 680 cmd.code = C_START_FW; 681 cmd.ring = 0; 682 cmd.index = 0; 683 684 rr_issue_cmd(rrpriv, &cmd); 685 686 /* 687 * Give the FirmWare time to chew on the `get running' command. 688 */ 689 myjif = jiffies + 5 * HZ; 690 while (time_before(jiffies, myjif) && !rrpriv->fw_running) 691 cpu_relax(); 692 693 netif_start_queue(dev); 694 695 return ecode; 696 697 error: 698 /* 699 * We might have gotten here because we are out of memory, 700 * make sure we release everything we allocated before failing 701 */ 702 for (i = 0; i < RX_RING_ENTRIES; i++) { 703 struct sk_buff *skb = rrpriv->rx_skbuff[i]; 704 705 if (skb) { 706 pci_unmap_single(rrpriv->pci_dev, 707 rrpriv->rx_ring[i].addr.addrlo, 708 dev->mtu + HIPPI_HLEN, 709 PCI_DMA_FROMDEVICE); 710 rrpriv->rx_ring[i].size = 0; 711 set_rraddr(&rrpriv->rx_ring[i].addr, 0); 712 dev_kfree_skb(skb); 713 rrpriv->rx_skbuff[i] = NULL; 714 } 715 } 716 return ecode; 717 } 718 719 720 /* 721 * All events are considered to be slow (RX/TX ints do not generate 722 * events) and are handled here, outside the main interrupt handler, 723 * to reduce the size of the handler. 724 */ 725 static u32 rr_handle_event(struct net_device *dev, u32 prodidx, u32 eidx) 726 { 727 struct rr_private *rrpriv; 728 struct rr_regs __iomem *regs; 729 u32 tmp; 730 731 rrpriv = netdev_priv(dev); 732 regs = rrpriv->regs; 733 734 while (prodidx != eidx){ 735 switch (rrpriv->evt_ring[eidx].code){ 736 case E_NIC_UP: 737 tmp = readl(®s->FwRev); 738 printk(KERN_INFO "%s: Firmware revision %i.%i.%i " 739 "up and running\n", dev->name, 740 (tmp >> 16), ((tmp >> 8) & 0xff), (tmp & 0xff)); 741 rrpriv->fw_running = 1; 742 writel(RX_RING_ENTRIES - 1, ®s->IpRxPi); 743 wmb(); 744 break; 745 case E_LINK_ON: 746 printk(KERN_INFO "%s: Optical link ON\n", dev->name); 747 break; 748 case E_LINK_OFF: 749 printk(KERN_INFO "%s: Optical link OFF\n", dev->name); 750 break; 751 case E_RX_IDLE: 752 printk(KERN_WARNING "%s: RX data not moving\n", 753 dev->name); 754 goto drop; 755 case E_WATCHDOG: 756 printk(KERN_INFO "%s: The watchdog is here to see " 757 "us\n", dev->name); 758 break; 759 case E_INTERN_ERR: 760 printk(KERN_ERR "%s: HIPPI Internal NIC error\n", 761 dev->name); 762 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 763 ®s->HostCtrl); 764 wmb(); 765 break; 766 case E_HOST_ERR: 767 printk(KERN_ERR "%s: Host software error\n", 768 dev->name); 769 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 770 ®s->HostCtrl); 771 wmb(); 772 break; 773 /* 774 * TX events. 775 */ 776 case E_CON_REJ: 777 printk(KERN_WARNING "%s: Connection rejected\n", 778 dev->name); 779 dev->stats.tx_aborted_errors++; 780 break; 781 case E_CON_TMOUT: 782 printk(KERN_WARNING "%s: Connection timeout\n", 783 dev->name); 784 break; 785 case E_DISC_ERR: 786 printk(KERN_WARNING "%s: HIPPI disconnect error\n", 787 dev->name); 788 dev->stats.tx_aborted_errors++; 789 break; 790 case E_INT_PRTY: 791 printk(KERN_ERR "%s: HIPPI Internal Parity error\n", 792 dev->name); 793 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 794 ®s->HostCtrl); 795 wmb(); 796 break; 797 case E_TX_IDLE: 798 printk(KERN_WARNING "%s: Transmitter idle\n", 799 dev->name); 800 break; 801 case E_TX_LINK_DROP: 802 printk(KERN_WARNING "%s: Link lost during transmit\n", 803 dev->name); 804 dev->stats.tx_aborted_errors++; 805 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 806 ®s->HostCtrl); 807 wmb(); 808 break; 809 case E_TX_INV_RNG: 810 printk(KERN_ERR "%s: Invalid send ring block\n", 811 dev->name); 812 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 813 ®s->HostCtrl); 814 wmb(); 815 break; 816 case E_TX_INV_BUF: 817 printk(KERN_ERR "%s: Invalid send buffer address\n", 818 dev->name); 819 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 820 ®s->HostCtrl); 821 wmb(); 822 break; 823 case E_TX_INV_DSC: 824 printk(KERN_ERR "%s: Invalid descriptor address\n", 825 dev->name); 826 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 827 ®s->HostCtrl); 828 wmb(); 829 break; 830 /* 831 * RX events. 832 */ 833 case E_RX_RNG_OUT: 834 printk(KERN_INFO "%s: Receive ring full\n", dev->name); 835 break; 836 837 case E_RX_PAR_ERR: 838 printk(KERN_WARNING "%s: Receive parity error\n", 839 dev->name); 840 goto drop; 841 case E_RX_LLRC_ERR: 842 printk(KERN_WARNING "%s: Receive LLRC error\n", 843 dev->name); 844 goto drop; 845 case E_PKT_LN_ERR: 846 printk(KERN_WARNING "%s: Receive packet length " 847 "error\n", dev->name); 848 goto drop; 849 case E_DTA_CKSM_ERR: 850 printk(KERN_WARNING "%s: Data checksum error\n", 851 dev->name); 852 goto drop; 853 case E_SHT_BST: 854 printk(KERN_WARNING "%s: Unexpected short burst " 855 "error\n", dev->name); 856 goto drop; 857 case E_STATE_ERR: 858 printk(KERN_WARNING "%s: Recv. state transition" 859 " error\n", dev->name); 860 goto drop; 861 case E_UNEXP_DATA: 862 printk(KERN_WARNING "%s: Unexpected data error\n", 863 dev->name); 864 goto drop; 865 case E_LST_LNK_ERR: 866 printk(KERN_WARNING "%s: Link lost error\n", 867 dev->name); 868 goto drop; 869 case E_FRM_ERR: 870 printk(KERN_WARNING "%s: Framming Error\n", 871 dev->name); 872 goto drop; 873 case E_FLG_SYN_ERR: 874 printk(KERN_WARNING "%s: Flag sync. lost during " 875 "packet\n", dev->name); 876 goto drop; 877 case E_RX_INV_BUF: 878 printk(KERN_ERR "%s: Invalid receive buffer " 879 "address\n", dev->name); 880 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 881 ®s->HostCtrl); 882 wmb(); 883 break; 884 case E_RX_INV_DSC: 885 printk(KERN_ERR "%s: Invalid receive descriptor " 886 "address\n", dev->name); 887 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 888 ®s->HostCtrl); 889 wmb(); 890 break; 891 case E_RNG_BLK: 892 printk(KERN_ERR "%s: Invalid ring block\n", 893 dev->name); 894 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 895 ®s->HostCtrl); 896 wmb(); 897 break; 898 drop: 899 /* Label packet to be dropped. 900 * Actual dropping occurs in rx 901 * handling. 902 * 903 * The index of packet we get to drop is 904 * the index of the packet following 905 * the bad packet. -kbf 906 */ 907 { 908 u16 index = rrpriv->evt_ring[eidx].index; 909 index = (index + (RX_RING_ENTRIES - 1)) % 910 RX_RING_ENTRIES; 911 rrpriv->rx_ring[index].mode |= 912 (PACKET_BAD | PACKET_END); 913 } 914 break; 915 default: 916 printk(KERN_WARNING "%s: Unhandled event 0x%02x\n", 917 dev->name, rrpriv->evt_ring[eidx].code); 918 } 919 eidx = (eidx + 1) % EVT_RING_ENTRIES; 920 } 921 922 rrpriv->info->evt_ctrl.pi = eidx; 923 wmb(); 924 return eidx; 925 } 926 927 928 static void rx_int(struct net_device *dev, u32 rxlimit, u32 index) 929 { 930 struct rr_private *rrpriv = netdev_priv(dev); 931 struct rr_regs __iomem *regs = rrpriv->regs; 932 933 do { 934 struct rx_desc *desc; 935 u32 pkt_len; 936 937 desc = &(rrpriv->rx_ring[index]); 938 pkt_len = desc->size; 939 #if (DEBUG > 2) 940 printk("index %i, rxlimit %i\n", index, rxlimit); 941 printk("len %x, mode %x\n", pkt_len, desc->mode); 942 #endif 943 if ( (rrpriv->rx_ring[index].mode & PACKET_BAD) == PACKET_BAD){ 944 dev->stats.rx_dropped++; 945 goto defer; 946 } 947 948 if (pkt_len > 0){ 949 struct sk_buff *skb, *rx_skb; 950 951 rx_skb = rrpriv->rx_skbuff[index]; 952 953 if (pkt_len < PKT_COPY_THRESHOLD) { 954 skb = alloc_skb(pkt_len, GFP_ATOMIC); 955 if (skb == NULL){ 956 printk(KERN_WARNING "%s: Unable to allocate skb (%i bytes), deferring packet\n", dev->name, pkt_len); 957 dev->stats.rx_dropped++; 958 goto defer; 959 } else { 960 pci_dma_sync_single_for_cpu(rrpriv->pci_dev, 961 desc->addr.addrlo, 962 pkt_len, 963 PCI_DMA_FROMDEVICE); 964 965 skb_put_data(skb, rx_skb->data, 966 pkt_len); 967 968 pci_dma_sync_single_for_device(rrpriv->pci_dev, 969 desc->addr.addrlo, 970 pkt_len, 971 PCI_DMA_FROMDEVICE); 972 } 973 }else{ 974 struct sk_buff *newskb; 975 976 newskb = alloc_skb(dev->mtu + HIPPI_HLEN, 977 GFP_ATOMIC); 978 if (newskb){ 979 dma_addr_t addr; 980 981 pci_unmap_single(rrpriv->pci_dev, 982 desc->addr.addrlo, dev->mtu + 983 HIPPI_HLEN, PCI_DMA_FROMDEVICE); 984 skb = rx_skb; 985 skb_put(skb, pkt_len); 986 rrpriv->rx_skbuff[index] = newskb; 987 addr = pci_map_single(rrpriv->pci_dev, 988 newskb->data, 989 dev->mtu + HIPPI_HLEN, 990 PCI_DMA_FROMDEVICE); 991 set_rraddr(&desc->addr, addr); 992 } else { 993 printk("%s: Out of memory, deferring " 994 "packet\n", dev->name); 995 dev->stats.rx_dropped++; 996 goto defer; 997 } 998 } 999 skb->protocol = hippi_type_trans(skb, dev); 1000 1001 netif_rx(skb); /* send it up */ 1002 1003 dev->stats.rx_packets++; 1004 dev->stats.rx_bytes += pkt_len; 1005 } 1006 defer: 1007 desc->mode = 0; 1008 desc->size = dev->mtu + HIPPI_HLEN; 1009 1010 if ((index & 7) == 7) 1011 writel(index, ®s->IpRxPi); 1012 1013 index = (index + 1) % RX_RING_ENTRIES; 1014 } while(index != rxlimit); 1015 1016 rrpriv->cur_rx = index; 1017 wmb(); 1018 } 1019 1020 1021 static irqreturn_t rr_interrupt(int irq, void *dev_id) 1022 { 1023 struct rr_private *rrpriv; 1024 struct rr_regs __iomem *regs; 1025 struct net_device *dev = (struct net_device *)dev_id; 1026 u32 prodidx, rxindex, eidx, txcsmr, rxlimit, txcon; 1027 1028 rrpriv = netdev_priv(dev); 1029 regs = rrpriv->regs; 1030 1031 if (!(readl(®s->HostCtrl) & RR_INT)) 1032 return IRQ_NONE; 1033 1034 spin_lock(&rrpriv->lock); 1035 1036 prodidx = readl(®s->EvtPrd); 1037 txcsmr = (prodidx >> 8) & 0xff; 1038 rxlimit = (prodidx >> 16) & 0xff; 1039 prodidx &= 0xff; 1040 1041 #if (DEBUG > 2) 1042 printk("%s: interrupt, prodidx = %i, eidx = %i\n", dev->name, 1043 prodidx, rrpriv->info->evt_ctrl.pi); 1044 #endif 1045 /* 1046 * Order here is important. We must handle events 1047 * before doing anything else in order to catch 1048 * such things as LLRC errors, etc -kbf 1049 */ 1050 1051 eidx = rrpriv->info->evt_ctrl.pi; 1052 if (prodidx != eidx) 1053 eidx = rr_handle_event(dev, prodidx, eidx); 1054 1055 rxindex = rrpriv->cur_rx; 1056 if (rxindex != rxlimit) 1057 rx_int(dev, rxlimit, rxindex); 1058 1059 txcon = rrpriv->dirty_tx; 1060 if (txcsmr != txcon) { 1061 do { 1062 /* Due to occational firmware TX producer/consumer out 1063 * of sync. error need to check entry in ring -kbf 1064 */ 1065 if(rrpriv->tx_skbuff[txcon]){ 1066 struct tx_desc *desc; 1067 struct sk_buff *skb; 1068 1069 desc = &(rrpriv->tx_ring[txcon]); 1070 skb = rrpriv->tx_skbuff[txcon]; 1071 1072 dev->stats.tx_packets++; 1073 dev->stats.tx_bytes += skb->len; 1074 1075 pci_unmap_single(rrpriv->pci_dev, 1076 desc->addr.addrlo, skb->len, 1077 PCI_DMA_TODEVICE); 1078 dev_kfree_skb_irq(skb); 1079 1080 rrpriv->tx_skbuff[txcon] = NULL; 1081 desc->size = 0; 1082 set_rraddr(&rrpriv->tx_ring[txcon].addr, 0); 1083 desc->mode = 0; 1084 } 1085 txcon = (txcon + 1) % TX_RING_ENTRIES; 1086 } while (txcsmr != txcon); 1087 wmb(); 1088 1089 rrpriv->dirty_tx = txcon; 1090 if (rrpriv->tx_full && rr_if_busy(dev) && 1091 (((rrpriv->info->tx_ctrl.pi + 1) % TX_RING_ENTRIES) 1092 != rrpriv->dirty_tx)){ 1093 rrpriv->tx_full = 0; 1094 netif_wake_queue(dev); 1095 } 1096 } 1097 1098 eidx |= ((txcsmr << 8) | (rxlimit << 16)); 1099 writel(eidx, ®s->EvtCon); 1100 wmb(); 1101 1102 spin_unlock(&rrpriv->lock); 1103 return IRQ_HANDLED; 1104 } 1105 1106 static inline void rr_raz_tx(struct rr_private *rrpriv, 1107 struct net_device *dev) 1108 { 1109 int i; 1110 1111 for (i = 0; i < TX_RING_ENTRIES; i++) { 1112 struct sk_buff *skb = rrpriv->tx_skbuff[i]; 1113 1114 if (skb) { 1115 struct tx_desc *desc = &(rrpriv->tx_ring[i]); 1116 1117 pci_unmap_single(rrpriv->pci_dev, desc->addr.addrlo, 1118 skb->len, PCI_DMA_TODEVICE); 1119 desc->size = 0; 1120 set_rraddr(&desc->addr, 0); 1121 dev_kfree_skb(skb); 1122 rrpriv->tx_skbuff[i] = NULL; 1123 } 1124 } 1125 } 1126 1127 1128 static inline void rr_raz_rx(struct rr_private *rrpriv, 1129 struct net_device *dev) 1130 { 1131 int i; 1132 1133 for (i = 0; i < RX_RING_ENTRIES; i++) { 1134 struct sk_buff *skb = rrpriv->rx_skbuff[i]; 1135 1136 if (skb) { 1137 struct rx_desc *desc = &(rrpriv->rx_ring[i]); 1138 1139 pci_unmap_single(rrpriv->pci_dev, desc->addr.addrlo, 1140 dev->mtu + HIPPI_HLEN, PCI_DMA_FROMDEVICE); 1141 desc->size = 0; 1142 set_rraddr(&desc->addr, 0); 1143 dev_kfree_skb(skb); 1144 rrpriv->rx_skbuff[i] = NULL; 1145 } 1146 } 1147 } 1148 1149 static void rr_timer(struct timer_list *t) 1150 { 1151 struct rr_private *rrpriv = from_timer(rrpriv, t, timer); 1152 struct net_device *dev = pci_get_drvdata(rrpriv->pci_dev); 1153 struct rr_regs __iomem *regs = rrpriv->regs; 1154 unsigned long flags; 1155 1156 if (readl(®s->HostCtrl) & NIC_HALTED){ 1157 printk("%s: Restarting nic\n", dev->name); 1158 memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl)); 1159 memset(rrpriv->info, 0, sizeof(struct rr_info)); 1160 wmb(); 1161 1162 rr_raz_tx(rrpriv, dev); 1163 rr_raz_rx(rrpriv, dev); 1164 1165 if (rr_init1(dev)) { 1166 spin_lock_irqsave(&rrpriv->lock, flags); 1167 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, 1168 ®s->HostCtrl); 1169 spin_unlock_irqrestore(&rrpriv->lock, flags); 1170 } 1171 } 1172 rrpriv->timer.expires = RUN_AT(5*HZ); 1173 add_timer(&rrpriv->timer); 1174 } 1175 1176 1177 static int rr_open(struct net_device *dev) 1178 { 1179 struct rr_private *rrpriv = netdev_priv(dev); 1180 struct pci_dev *pdev = rrpriv->pci_dev; 1181 struct rr_regs __iomem *regs; 1182 int ecode = 0; 1183 unsigned long flags; 1184 dma_addr_t dma_addr; 1185 1186 regs = rrpriv->regs; 1187 1188 if (rrpriv->fw_rev < 0x00020000) { 1189 printk(KERN_WARNING "%s: trying to configure device with " 1190 "obsolete firmware\n", dev->name); 1191 ecode = -EBUSY; 1192 goto error; 1193 } 1194 1195 rrpriv->rx_ctrl = pci_alloc_consistent(pdev, 1196 256 * sizeof(struct ring_ctrl), 1197 &dma_addr); 1198 if (!rrpriv->rx_ctrl) { 1199 ecode = -ENOMEM; 1200 goto error; 1201 } 1202 rrpriv->rx_ctrl_dma = dma_addr; 1203 memset(rrpriv->rx_ctrl, 0, 256*sizeof(struct ring_ctrl)); 1204 1205 rrpriv->info = pci_alloc_consistent(pdev, sizeof(struct rr_info), 1206 &dma_addr); 1207 if (!rrpriv->info) { 1208 ecode = -ENOMEM; 1209 goto error; 1210 } 1211 rrpriv->info_dma = dma_addr; 1212 memset(rrpriv->info, 0, sizeof(struct rr_info)); 1213 wmb(); 1214 1215 spin_lock_irqsave(&rrpriv->lock, flags); 1216 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, ®s->HostCtrl); 1217 readl(®s->HostCtrl); 1218 spin_unlock_irqrestore(&rrpriv->lock, flags); 1219 1220 if (request_irq(pdev->irq, rr_interrupt, IRQF_SHARED, dev->name, dev)) { 1221 printk(KERN_WARNING "%s: Requested IRQ %d is busy\n", 1222 dev->name, pdev->irq); 1223 ecode = -EAGAIN; 1224 goto error; 1225 } 1226 1227 if ((ecode = rr_init1(dev))) 1228 goto error; 1229 1230 /* Set the timer to switch to check for link beat and perhaps switch 1231 to an alternate media type. */ 1232 timer_setup(&rrpriv->timer, rr_timer, 0); 1233 rrpriv->timer.expires = RUN_AT(5*HZ); /* 5 sec. watchdog */ 1234 add_timer(&rrpriv->timer); 1235 1236 netif_start_queue(dev); 1237 1238 return ecode; 1239 1240 error: 1241 spin_lock_irqsave(&rrpriv->lock, flags); 1242 writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, ®s->HostCtrl); 1243 spin_unlock_irqrestore(&rrpriv->lock, flags); 1244 1245 if (rrpriv->info) { 1246 pci_free_consistent(pdev, sizeof(struct rr_info), rrpriv->info, 1247 rrpriv->info_dma); 1248 rrpriv->info = NULL; 1249 } 1250 if (rrpriv->rx_ctrl) { 1251 pci_free_consistent(pdev, sizeof(struct ring_ctrl), 1252 rrpriv->rx_ctrl, rrpriv->rx_ctrl_dma); 1253 rrpriv->rx_ctrl = NULL; 1254 } 1255 1256 netif_stop_queue(dev); 1257 1258 return ecode; 1259 } 1260 1261 1262 static void rr_dump(struct net_device *dev) 1263 { 1264 struct rr_private *rrpriv; 1265 struct rr_regs __iomem *regs; 1266 u32 index, cons; 1267 short i; 1268 int len; 1269 1270 rrpriv = netdev_priv(dev); 1271 regs = rrpriv->regs; 1272 1273 printk("%s: dumping NIC TX rings\n", dev->name); 1274 1275 printk("RxPrd %08x, TxPrd %02x, EvtPrd %08x, TxPi %02x, TxCtrlPi %02x\n", 1276 readl(®s->RxPrd), readl(®s->TxPrd), 1277 readl(®s->EvtPrd), readl(®s->TxPi), 1278 rrpriv->info->tx_ctrl.pi); 1279 1280 printk("Error code 0x%x\n", readl(®s->Fail1)); 1281 1282 index = (((readl(®s->EvtPrd) >> 8) & 0xff) - 1) % TX_RING_ENTRIES; 1283 cons = rrpriv->dirty_tx; 1284 printk("TX ring index %i, TX consumer %i\n", 1285 index, cons); 1286 1287 if (rrpriv->tx_skbuff[index]){ 1288 len = min_t(int, 0x80, rrpriv->tx_skbuff[index]->len); 1289 printk("skbuff for index %i is valid - dumping data (0x%x bytes - DMA len 0x%x)\n", index, len, rrpriv->tx_ring[index].size); 1290 for (i = 0; i < len; i++){ 1291 if (!(i & 7)) 1292 printk("\n"); 1293 printk("%02x ", (unsigned char) rrpriv->tx_skbuff[index]->data[i]); 1294 } 1295 printk("\n"); 1296 } 1297 1298 if (rrpriv->tx_skbuff[cons]){ 1299 len = min_t(int, 0x80, rrpriv->tx_skbuff[cons]->len); 1300 printk("skbuff for cons %i is valid - dumping data (0x%x bytes - skbuff len 0x%x)\n", cons, len, rrpriv->tx_skbuff[cons]->len); 1301 printk("mode 0x%x, size 0x%x,\n phys %08Lx, skbuff-addr %08lx, truesize 0x%x\n", 1302 rrpriv->tx_ring[cons].mode, 1303 rrpriv->tx_ring[cons].size, 1304 (unsigned long long) rrpriv->tx_ring[cons].addr.addrlo, 1305 (unsigned long)rrpriv->tx_skbuff[cons]->data, 1306 (unsigned int)rrpriv->tx_skbuff[cons]->truesize); 1307 for (i = 0; i < len; i++){ 1308 if (!(i & 7)) 1309 printk("\n"); 1310 printk("%02x ", (unsigned char)rrpriv->tx_ring[cons].size); 1311 } 1312 printk("\n"); 1313 } 1314 1315 printk("dumping TX ring info:\n"); 1316 for (i = 0; i < TX_RING_ENTRIES; i++) 1317 printk("mode 0x%x, size 0x%x, phys-addr %08Lx\n", 1318 rrpriv->tx_ring[i].mode, 1319 rrpriv->tx_ring[i].size, 1320 (unsigned long long) rrpriv->tx_ring[i].addr.addrlo); 1321 1322 } 1323 1324 1325 static int rr_close(struct net_device *dev) 1326 { 1327 struct rr_private *rrpriv = netdev_priv(dev); 1328 struct rr_regs __iomem *regs = rrpriv->regs; 1329 struct pci_dev *pdev = rrpriv->pci_dev; 1330 unsigned long flags; 1331 u32 tmp; 1332 short i; 1333 1334 netif_stop_queue(dev); 1335 1336 1337 /* 1338 * Lock to make sure we are not cleaning up while another CPU 1339 * is handling interrupts. 1340 */ 1341 spin_lock_irqsave(&rrpriv->lock, flags); 1342 1343 tmp = readl(®s->HostCtrl); 1344 if (tmp & NIC_HALTED){ 1345 printk("%s: NIC already halted\n", dev->name); 1346 rr_dump(dev); 1347 }else{ 1348 tmp |= HALT_NIC | RR_CLEAR_INT; 1349 writel(tmp, ®s->HostCtrl); 1350 readl(®s->HostCtrl); 1351 } 1352 1353 rrpriv->fw_running = 0; 1354 1355 del_timer_sync(&rrpriv->timer); 1356 1357 writel(0, ®s->TxPi); 1358 writel(0, ®s->IpRxPi); 1359 1360 writel(0, ®s->EvtCon); 1361 writel(0, ®s->EvtPrd); 1362 1363 for (i = 0; i < CMD_RING_ENTRIES; i++) 1364 writel(0, ®s->CmdRing[i]); 1365 1366 rrpriv->info->tx_ctrl.entries = 0; 1367 rrpriv->info->cmd_ctrl.pi = 0; 1368 rrpriv->info->evt_ctrl.pi = 0; 1369 rrpriv->rx_ctrl[4].entries = 0; 1370 1371 rr_raz_tx(rrpriv, dev); 1372 rr_raz_rx(rrpriv, dev); 1373 1374 pci_free_consistent(pdev, 256 * sizeof(struct ring_ctrl), 1375 rrpriv->rx_ctrl, rrpriv->rx_ctrl_dma); 1376 rrpriv->rx_ctrl = NULL; 1377 1378 pci_free_consistent(pdev, sizeof(struct rr_info), rrpriv->info, 1379 rrpriv->info_dma); 1380 rrpriv->info = NULL; 1381 1382 spin_unlock_irqrestore(&rrpriv->lock, flags); 1383 free_irq(pdev->irq, dev); 1384 1385 return 0; 1386 } 1387 1388 1389 static netdev_tx_t rr_start_xmit(struct sk_buff *skb, 1390 struct net_device *dev) 1391 { 1392 struct rr_private *rrpriv = netdev_priv(dev); 1393 struct rr_regs __iomem *regs = rrpriv->regs; 1394 struct hippi_cb *hcb = (struct hippi_cb *) skb->cb; 1395 struct ring_ctrl *txctrl; 1396 unsigned long flags; 1397 u32 index, len = skb->len; 1398 u32 *ifield; 1399 struct sk_buff *new_skb; 1400 1401 if (readl(®s->Mode) & FATAL_ERR) 1402 printk("error codes Fail1 %02x, Fail2 %02x\n", 1403 readl(®s->Fail1), readl(®s->Fail2)); 1404 1405 /* 1406 * We probably need to deal with tbusy here to prevent overruns. 1407 */ 1408 1409 if (skb_headroom(skb) < 8){ 1410 printk("incoming skb too small - reallocating\n"); 1411 if (!(new_skb = dev_alloc_skb(len + 8))) { 1412 dev_kfree_skb(skb); 1413 netif_wake_queue(dev); 1414 return NETDEV_TX_OK; 1415 } 1416 skb_reserve(new_skb, 8); 1417 skb_put(new_skb, len); 1418 skb_copy_from_linear_data(skb, new_skb->data, len); 1419 dev_kfree_skb(skb); 1420 skb = new_skb; 1421 } 1422 1423 ifield = skb_push(skb, 8); 1424 1425 ifield[0] = 0; 1426 ifield[1] = hcb->ifield; 1427 1428 /* 1429 * We don't need the lock before we are actually going to start 1430 * fiddling with the control blocks. 1431 */ 1432 spin_lock_irqsave(&rrpriv->lock, flags); 1433 1434 txctrl = &rrpriv->info->tx_ctrl; 1435 1436 index = txctrl->pi; 1437 1438 rrpriv->tx_skbuff[index] = skb; 1439 set_rraddr(&rrpriv->tx_ring[index].addr, pci_map_single( 1440 rrpriv->pci_dev, skb->data, len + 8, PCI_DMA_TODEVICE)); 1441 rrpriv->tx_ring[index].size = len + 8; /* include IFIELD */ 1442 rrpriv->tx_ring[index].mode = PACKET_START | PACKET_END; 1443 txctrl->pi = (index + 1) % TX_RING_ENTRIES; 1444 wmb(); 1445 writel(txctrl->pi, ®s->TxPi); 1446 1447 if (txctrl->pi == rrpriv->dirty_tx){ 1448 rrpriv->tx_full = 1; 1449 netif_stop_queue(dev); 1450 } 1451 1452 spin_unlock_irqrestore(&rrpriv->lock, flags); 1453 1454 return NETDEV_TX_OK; 1455 } 1456 1457 1458 /* 1459 * Read the firmware out of the EEPROM and put it into the SRAM 1460 * (or from user space - later) 1461 * 1462 * This operation requires the NIC to be halted and is performed with 1463 * interrupts disabled and with the spinlock hold. 1464 */ 1465 static int rr_load_firmware(struct net_device *dev) 1466 { 1467 struct rr_private *rrpriv; 1468 struct rr_regs __iomem *regs; 1469 size_t eptr, segptr; 1470 int i, j; 1471 u32 localctrl, sptr, len, tmp; 1472 u32 p2len, p2size, nr_seg, revision, io, sram_size; 1473 1474 rrpriv = netdev_priv(dev); 1475 regs = rrpriv->regs; 1476 1477 if (dev->flags & IFF_UP) 1478 return -EBUSY; 1479 1480 if (!(readl(®s->HostCtrl) & NIC_HALTED)){ 1481 printk("%s: Trying to load firmware to a running NIC.\n", 1482 dev->name); 1483 return -EBUSY; 1484 } 1485 1486 localctrl = readl(®s->LocalCtrl); 1487 writel(0, ®s->LocalCtrl); 1488 1489 writel(0, ®s->EvtPrd); 1490 writel(0, ®s->RxPrd); 1491 writel(0, ®s->TxPrd); 1492 1493 /* 1494 * First wipe the entire SRAM, otherwise we might run into all 1495 * kinds of trouble ... sigh, this took almost all afternoon 1496 * to track down ;-( 1497 */ 1498 io = readl(®s->ExtIo); 1499 writel(0, ®s->ExtIo); 1500 sram_size = rr_read_eeprom_word(rrpriv, 8); 1501 1502 for (i = 200; i < sram_size / 4; i++){ 1503 writel(i * 4, ®s->WinBase); 1504 mb(); 1505 writel(0, ®s->WinData); 1506 mb(); 1507 } 1508 writel(io, ®s->ExtIo); 1509 mb(); 1510 1511 eptr = rr_read_eeprom_word(rrpriv, 1512 offsetof(struct eeprom, rncd_info.AddrRunCodeSegs)); 1513 eptr = ((eptr & 0x1fffff) >> 3); 1514 1515 p2len = rr_read_eeprom_word(rrpriv, 0x83*4); 1516 p2len = (p2len << 2); 1517 p2size = rr_read_eeprom_word(rrpriv, 0x84*4); 1518 p2size = ((p2size & 0x1fffff) >> 3); 1519 1520 if ((eptr < p2size) || (eptr > (p2size + p2len))){ 1521 printk("%s: eptr is invalid\n", dev->name); 1522 goto out; 1523 } 1524 1525 revision = rr_read_eeprom_word(rrpriv, 1526 offsetof(struct eeprom, manf.HeaderFmt)); 1527 1528 if (revision != 1){ 1529 printk("%s: invalid firmware format (%i)\n", 1530 dev->name, revision); 1531 goto out; 1532 } 1533 1534 nr_seg = rr_read_eeprom_word(rrpriv, eptr); 1535 eptr +=4; 1536 #if (DEBUG > 1) 1537 printk("%s: nr_seg %i\n", dev->name, nr_seg); 1538 #endif 1539 1540 for (i = 0; i < nr_seg; i++){ 1541 sptr = rr_read_eeprom_word(rrpriv, eptr); 1542 eptr += 4; 1543 len = rr_read_eeprom_word(rrpriv, eptr); 1544 eptr += 4; 1545 segptr = rr_read_eeprom_word(rrpriv, eptr); 1546 segptr = ((segptr & 0x1fffff) >> 3); 1547 eptr += 4; 1548 #if (DEBUG > 1) 1549 printk("%s: segment %i, sram address %06x, length %04x, segptr %06x\n", 1550 dev->name, i, sptr, len, segptr); 1551 #endif 1552 for (j = 0; j < len; j++){ 1553 tmp = rr_read_eeprom_word(rrpriv, segptr); 1554 writel(sptr, ®s->WinBase); 1555 mb(); 1556 writel(tmp, ®s->WinData); 1557 mb(); 1558 segptr += 4; 1559 sptr += 4; 1560 } 1561 } 1562 1563 out: 1564 writel(localctrl, ®s->LocalCtrl); 1565 mb(); 1566 return 0; 1567 } 1568 1569 1570 static int rr_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1571 { 1572 struct rr_private *rrpriv; 1573 unsigned char *image, *oldimage; 1574 unsigned long flags; 1575 unsigned int i; 1576 int error = -EOPNOTSUPP; 1577 1578 rrpriv = netdev_priv(dev); 1579 1580 switch(cmd){ 1581 case SIOCRRGFW: 1582 if (!capable(CAP_SYS_RAWIO)){ 1583 return -EPERM; 1584 } 1585 1586 image = kmalloc(EEPROM_WORDS * sizeof(u32), GFP_KERNEL); 1587 if (!image) 1588 return -ENOMEM; 1589 1590 if (rrpriv->fw_running){ 1591 printk("%s: Firmware already running\n", dev->name); 1592 error = -EPERM; 1593 goto gf_out; 1594 } 1595 1596 spin_lock_irqsave(&rrpriv->lock, flags); 1597 i = rr_read_eeprom(rrpriv, 0, image, EEPROM_BYTES); 1598 spin_unlock_irqrestore(&rrpriv->lock, flags); 1599 if (i != EEPROM_BYTES){ 1600 printk(KERN_ERR "%s: Error reading EEPROM\n", 1601 dev->name); 1602 error = -EFAULT; 1603 goto gf_out; 1604 } 1605 error = copy_to_user(rq->ifr_data, image, EEPROM_BYTES); 1606 if (error) 1607 error = -EFAULT; 1608 gf_out: 1609 kfree(image); 1610 return error; 1611 1612 case SIOCRRPFW: 1613 if (!capable(CAP_SYS_RAWIO)){ 1614 return -EPERM; 1615 } 1616 1617 image = memdup_user(rq->ifr_data, EEPROM_BYTES); 1618 if (IS_ERR(image)) 1619 return PTR_ERR(image); 1620 1621 oldimage = kmalloc(EEPROM_BYTES, GFP_KERNEL); 1622 if (!oldimage) { 1623 kfree(image); 1624 return -ENOMEM; 1625 } 1626 1627 if (rrpriv->fw_running){ 1628 printk("%s: Firmware already running\n", dev->name); 1629 error = -EPERM; 1630 goto wf_out; 1631 } 1632 1633 printk("%s: Updating EEPROM firmware\n", dev->name); 1634 1635 spin_lock_irqsave(&rrpriv->lock, flags); 1636 error = write_eeprom(rrpriv, 0, image, EEPROM_BYTES); 1637 if (error) 1638 printk(KERN_ERR "%s: Error writing EEPROM\n", 1639 dev->name); 1640 1641 i = rr_read_eeprom(rrpriv, 0, oldimage, EEPROM_BYTES); 1642 spin_unlock_irqrestore(&rrpriv->lock, flags); 1643 1644 if (i != EEPROM_BYTES) 1645 printk(KERN_ERR "%s: Error reading back EEPROM " 1646 "image\n", dev->name); 1647 1648 error = memcmp(image, oldimage, EEPROM_BYTES); 1649 if (error){ 1650 printk(KERN_ERR "%s: Error verifying EEPROM image\n", 1651 dev->name); 1652 error = -EFAULT; 1653 } 1654 wf_out: 1655 kfree(oldimage); 1656 kfree(image); 1657 return error; 1658 1659 case SIOCRRID: 1660 return put_user(0x52523032, (int __user *)rq->ifr_data); 1661 default: 1662 return error; 1663 } 1664 } 1665 1666 static const struct pci_device_id rr_pci_tbl[] = { 1667 { PCI_VENDOR_ID_ESSENTIAL, PCI_DEVICE_ID_ESSENTIAL_ROADRUNNER, 1668 PCI_ANY_ID, PCI_ANY_ID, }, 1669 { 0,} 1670 }; 1671 MODULE_DEVICE_TABLE(pci, rr_pci_tbl); 1672 1673 static struct pci_driver rr_driver = { 1674 .name = "rrunner", 1675 .id_table = rr_pci_tbl, 1676 .probe = rr_init_one, 1677 .remove = rr_remove_one, 1678 }; 1679 1680 module_pci_driver(rr_driver); 1681