1/* 2 * lanstreamer.c -- driver for the IBM Auto LANStreamer PCI Adapter 3 * 4 * Written By: Mike Sullivan, IBM Corporation 5 * 6 * Copyright (C) 1999 IBM Corporation 7 * 8 * Linux driver for IBM PCI tokenring cards based on the LanStreamer MPC 9 * chipset. 10 * 11 * This driver is based on the olympic driver for IBM PCI TokenRing cards (Pit/Pit-Phy/Olympic 12 * chipsets) written by: 13 * 1999 Peter De Schrijver All Rights Reserved 14 * 1999 Mike Phillips (phillim@amtrak.com) 15 * 16 * Base Driver Skeleton: 17 * Written 1993-94 by Donald Becker. 18 * 19 * Copyright 1993 United States Government as represented by the 20 * Director, National Security Agency. 21 * 22 * This program is free software; you can redistribute it and/or modify 23 * it under the terms of the GNU General Public License as published by 24 * the Free Software Foundation; either version 2 of the License, or 25 * (at your option) any later version. 26 * 27 * This program is distributed in the hope that it will be useful, 28 * but WITHOUT ANY WARRANTY; without even the implied warranty of 29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 30 * GNU General Public License for more details. 31 * 32 * NO WARRANTY 33 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 34 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 35 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 36 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 37 * solely responsible for determining the appropriateness of using and 38 * distributing the Program and assumes all risks associated with its 39 * exercise of rights under this Agreement, including but not limited to 40 * the risks and costs of program errors, damage to or loss of data, 41 * programs or equipment, and unavailability or interruption of operations. 42 * 43 * DISCLAIMER OF LIABILITY 44 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 45 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 47 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 48 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 49 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 50 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 51 * 52 * You should have received a copy of the GNU General Public License 53 * along with this program; if not, write to the Free Software 54 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 55 * 56 * 57 * 12/10/99 - Alpha Release 0.1.0 58 * First release to the public 59 * 03/03/00 - Merged to kernel, indented -kr -i8 -bri0, fixed some missing 60 * malloc free checks, reviewed code. <alan@redhat.com> 61 * 03/13/00 - Added spinlocks for smp 62 * 03/08/01 - Added support for module_init() and module_exit() 63 * 08/15/01 - Added ioctl() functionality for debugging, changed netif_*_queue 64 * calls and other incorrectness - Kent Yoder <yoder1@us.ibm.com> 65 * 11/05/01 - Restructured the interrupt function, added delays, reduced the 66 * the number of TX descriptors to 1, which together can prevent 67 * the card from locking up the box - <yoder1@us.ibm.com> 68 * 09/27/02 - New PCI interface + bug fix. - <yoder1@us.ibm.com> 69 * 11/13/02 - Removed free_irq calls which could cause a hang, added 70 * netif_carrier_{on|off} - <yoder1@us.ibm.com> 71 * 72 * To Do: 73 * 74 * 75 * If Problems do Occur 76 * Most problems can be rectified by either closing and opening the interface 77 * (ifconfig down and up) or rmmod and insmod'ing the driver (a bit difficult 78 * if compiled into the kernel). 79 */ 80 81/* Change STREAMER_DEBUG to 1 to get verbose, and I mean really verbose, messages */ 82 83#define STREAMER_DEBUG 0 84#define STREAMER_DEBUG_PACKETS 0 85 86/* Change STREAMER_NETWORK_MONITOR to receive mac frames through the arb channel. 87 * Will also create a /proc/net/streamer_tr entry if proc_fs is compiled into the 88 * kernel. 89 * Intended to be used to create a ring-error reporting network module 90 * i.e. it will give you the source address of beaconers on the ring 91 */ 92 93#define STREAMER_NETWORK_MONITOR 0 94 95/* #define CONFIG_PROC_FS */ 96 97/* 98 * Allow or disallow ioctl's for debugging 99 */ 100 101#define STREAMER_IOCTL 0 102 103#include <linux/module.h> 104#include <linux/kernel.h> 105#include <linux/errno.h> 106#include <linux/timer.h> 107#include <linux/in.h> 108#include <linux/ioport.h> 109#include <linux/string.h> 110#include <linux/proc_fs.h> 111#include <linux/ptrace.h> 112#include <linux/skbuff.h> 113#include <linux/interrupt.h> 114#include <linux/delay.h> 115#include <linux/netdevice.h> 116#include <linux/trdevice.h> 117#include <linux/stddef.h> 118#include <linux/init.h> 119#include <linux/pci.h> 120#include <linux/dma-mapping.h> 121#include <linux/spinlock.h> 122#include <linux/version.h> 123#include <linux/bitops.h> 124#include <linux/jiffies.h> 125 126#include <net/checksum.h> 127 128#include <asm/io.h> 129#include <asm/system.h> 130 131#include "lanstreamer.h" 132 133#if (BITS_PER_LONG == 64) 134#error broken on 64-bit: stores pointer to rx_ring->buffer in 32-bit int 135#endif 136 137 138/* I've got to put some intelligence into the version number so that Peter and I know 139 * which version of the code somebody has got. 140 * Version Number = a.b.c.d where a.b.c is the level of code and d is the latest author. 141 * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike 142 * 143 * Official releases will only have an a.b.c version number format. 144 */ 145 146static char version[] = "LanStreamer.c v0.4.0 03/08/01 - Mike Sullivan\n" 147 " v0.5.3 11/13/02 - Kent Yoder"; 148 149static struct pci_device_id streamer_pci_tbl[] = { 150 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_TR, PCI_ANY_ID, PCI_ANY_ID,}, 151 {} /* terminating entry */ 152}; 153MODULE_DEVICE_TABLE(pci,streamer_pci_tbl); 154 155 156static char *open_maj_error[] = { 157 "No error", "Lobe Media Test", "Physical Insertion", 158 "Address Verification", "Neighbor Notification (Ring Poll)", 159 "Request Parameters", "FDX Registration Request", 160 "FDX Lobe Media Test", "FDX Duplicate Address Check", 161 "Unknown stage" 162}; 163 164static char *open_min_error[] = { 165 "No error", "Function Failure", "Signal Lost", "Wire Fault", 166 "Ring Speed Mismatch", "Timeout", "Ring Failure", "Ring Beaconing", 167 "Duplicate Node Address", "Request Parameters", "Remove Received", 168 "Reserved", "Reserved", "No Monitor Detected for RPL", 169 "Monitor Contention failer for RPL", "FDX Protocol Error" 170}; 171 172/* Module paramters */ 173 174/* Ring Speed 0,4,16 175 * 0 = Autosense 176 * 4,16 = Selected speed only, no autosense 177 * This allows the card to be the first on the ring 178 * and become the active monitor. 179 * 180 * WARNING: Some hubs will allow you to insert 181 * at the wrong speed 182 */ 183 184static int ringspeed[STREAMER_MAX_ADAPTERS] = { 0, }; 185 186module_param_array(ringspeed, int, NULL, 0); 187 188/* Packet buffer size */ 189 190static int pkt_buf_sz[STREAMER_MAX_ADAPTERS] = { 0, }; 191 192module_param_array(pkt_buf_sz, int, NULL, 0); 193 194/* Message Level */ 195 196static int message_level[STREAMER_MAX_ADAPTERS] = { 1, }; 197 198module_param_array(message_level, int, NULL, 0); 199 200#if STREAMER_IOCTL 201static int streamer_ioctl(struct net_device *, struct ifreq *, int); 202#endif 203 204static int streamer_reset(struct net_device *dev); 205static int streamer_open(struct net_device *dev); 206static int streamer_xmit(struct sk_buff *skb, struct net_device *dev); 207static int streamer_close(struct net_device *dev); 208static void streamer_set_rx_mode(struct net_device *dev); 209static irqreturn_t streamer_interrupt(int irq, void *dev_id); 210static struct net_device_stats *streamer_get_stats(struct net_device *dev); 211static int streamer_set_mac_address(struct net_device *dev, void *addr); 212static void streamer_arb_cmd(struct net_device *dev); 213static int streamer_change_mtu(struct net_device *dev, int mtu); 214static void streamer_srb_bh(struct net_device *dev); 215static void streamer_asb_bh(struct net_device *dev); 216#if STREAMER_NETWORK_MONITOR 217#ifdef CONFIG_PROC_FS 218static int streamer_proc_info(char *buffer, char **start, off_t offset, 219 int length, int *eof, void *data); 220static int sprintf_info(char *buffer, struct net_device *dev); 221struct streamer_private *dev_streamer=NULL; 222#endif 223#endif 224 225static int __devinit streamer_init_one(struct pci_dev *pdev, 226 const struct pci_device_id *ent) 227{ 228 struct net_device *dev; 229 struct streamer_private *streamer_priv; 230 unsigned long pio_start, pio_end, pio_flags, pio_len; 231 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len; 232 int rc = 0; 233 static int card_no=-1; 234 u16 pcr; 235 236#if STREAMER_DEBUG 237 printk("lanstreamer::streamer_init_one, entry pdev %p\n",pdev); 238#endif 239 240 card_no++; 241 dev = alloc_trdev(sizeof(*streamer_priv)); 242 if (dev==NULL) { 243 printk(KERN_ERR "lanstreamer: out of memory.\n"); 244 return -ENOMEM; 245 } 246 247 SET_MODULE_OWNER(dev); 248 streamer_priv = dev->priv; 249 250#if STREAMER_NETWORK_MONITOR 251#ifdef CONFIG_PROC_FS 252 if (!dev_streamer) 253 create_proc_read_entry("net/streamer_tr", 0, 0, 254 streamer_proc_info, NULL); 255 streamer_priv->next = dev_streamer; 256 dev_streamer = streamer_priv; 257#endif 258#endif 259 260 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 261 if (rc) { 262 printk(KERN_ERR "%s: No suitable PCI mapping available.\n", 263 dev->name); 264 rc = -ENODEV; 265 goto err_out; 266 } 267 268 rc = pci_enable_device(pdev); 269 if (rc) { 270 printk(KERN_ERR "lanstreamer: unable to enable pci device\n"); 271 rc=-EIO; 272 goto err_out; 273 } 274 275 pci_set_master(pdev); 276 277 rc = pci_set_mwi(pdev); 278 if (rc) { 279 printk(KERN_ERR "lanstreamer: unable to enable MWI on pci device\n"); 280 goto err_out_disable; 281 } 282 283 pio_start = pci_resource_start(pdev, 0); 284 pio_end = pci_resource_end(pdev, 0); 285 pio_flags = pci_resource_flags(pdev, 0); 286 pio_len = pci_resource_len(pdev, 0); 287 288 mmio_start = pci_resource_start(pdev, 1); 289 mmio_end = pci_resource_end(pdev, 1); 290 mmio_flags = pci_resource_flags(pdev, 1); 291 mmio_len = pci_resource_len(pdev, 1); 292 293#if STREAMER_DEBUG 294 printk("lanstreamer: pio_start %x pio_end %x pio_len %x pio_flags %x\n", 295 pio_start, pio_end, pio_len, pio_flags); 296 printk("lanstreamer: mmio_start %x mmio_end %x mmio_len %x mmio_flags %x\n", 297 mmio_start, mmio_end, mmio_flags, mmio_len); 298#endif 299 300 if (!request_region(pio_start, pio_len, "lanstreamer")) { 301 printk(KERN_ERR "lanstreamer: unable to get pci io addr %lx\n", 302 pio_start); 303 rc= -EBUSY; 304 goto err_out_mwi; 305 } 306 307 if (!request_mem_region(mmio_start, mmio_len, "lanstreamer")) { 308 printk(KERN_ERR "lanstreamer: unable to get pci mmio addr %lx\n", 309 mmio_start); 310 rc= -EBUSY; 311 goto err_out_free_pio; 312 } 313 314 streamer_priv->streamer_mmio=ioremap(mmio_start, mmio_len); 315 if (streamer_priv->streamer_mmio == NULL) { 316 printk(KERN_ERR "lanstreamer: unable to remap MMIO %lx\n", 317 mmio_start); 318 rc= -EIO; 319 goto err_out_free_mmio; 320 } 321 322 init_waitqueue_head(&streamer_priv->srb_wait); 323 init_waitqueue_head(&streamer_priv->trb_wait); 324 325 dev->open = &streamer_open; 326 dev->hard_start_xmit = &streamer_xmit; 327 dev->change_mtu = &streamer_change_mtu; 328 dev->stop = &streamer_close; 329#if STREAMER_IOCTL 330 dev->do_ioctl = &streamer_ioctl; 331#else 332 dev->do_ioctl = NULL; 333#endif 334 dev->set_multicast_list = &streamer_set_rx_mode; 335 dev->get_stats = &streamer_get_stats; 336 dev->set_mac_address = &streamer_set_mac_address; 337 dev->irq = pdev->irq; 338 dev->base_addr=pio_start; 339 SET_NETDEV_DEV(dev, &pdev->dev); 340 341 streamer_priv->streamer_card_name = (char *)pdev->resource[0].name; 342 streamer_priv->pci_dev = pdev; 343 344 if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000)) 345 streamer_priv->pkt_buf_sz = PKT_BUF_SZ; 346 else 347 streamer_priv->pkt_buf_sz = pkt_buf_sz[card_no]; 348 349 streamer_priv->streamer_ring_speed = ringspeed[card_no]; 350 streamer_priv->streamer_message_level = message_level[card_no]; 351 352 pci_set_drvdata(pdev, dev); 353 354 spin_lock_init(&streamer_priv->streamer_lock); 355 356 pci_read_config_word (pdev, PCI_COMMAND, &pcr); 357 pcr |= PCI_COMMAND_SERR; 358 pci_write_config_word (pdev, PCI_COMMAND, pcr); 359 360 printk("%s \n", version); 361 printk("%s: %s. I/O at %hx, MMIO at %p, using irq %d\n",dev->name, 362 streamer_priv->streamer_card_name, 363 (unsigned int) dev->base_addr, 364 streamer_priv->streamer_mmio, 365 dev->irq); 366 367 if (streamer_reset(dev)) 368 goto err_out_unmap; 369 370 rc = register_netdev(dev); 371 if (rc) 372 goto err_out_unmap; 373 return 0; 374 375err_out_unmap: 376 iounmap(streamer_priv->streamer_mmio); 377err_out_free_mmio: 378 release_mem_region(mmio_start, mmio_len); 379err_out_free_pio: 380 release_region(pio_start, pio_len); 381err_out_mwi: 382 pci_clear_mwi(pdev); 383err_out_disable: 384 pci_disable_device(pdev); 385err_out: 386 free_netdev(dev); 387#if STREAMER_DEBUG 388 printk("lanstreamer: Exit error %x\n",rc); 389#endif 390 return rc; 391} 392 393static void __devexit streamer_remove_one(struct pci_dev *pdev) 394{ 395 struct net_device *dev=pci_get_drvdata(pdev); 396 struct streamer_private *streamer_priv; 397 398#if STREAMER_DEBUG 399 printk("lanstreamer::streamer_remove_one entry pdev %p\n",pdev); 400#endif 401 402 if (dev == NULL) { 403 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev is NULL\n"); 404 return; 405 } 406 407 streamer_priv=dev->priv; 408 if (streamer_priv == NULL) { 409 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev->priv is NULL\n"); 410 return; 411 } 412 413#if STREAMER_NETWORK_MONITOR 414#ifdef CONFIG_PROC_FS 415 { 416 struct streamer_private **p, **next; 417 418 for (p = &dev_streamer; *p; p = next) { 419 next = &(*p)->next; 420 if (*p == streamer_priv) { 421 *p = *next; 422 break; 423 } 424 } 425 if (!dev_streamer) 426 remove_proc_entry("net/streamer_tr", NULL); 427 } 428#endif 429#endif 430 431 unregister_netdev(dev); 432 iounmap(streamer_priv->streamer_mmio); 433 release_mem_region(pci_resource_start(pdev, 1), pci_resource_len(pdev,1)); 434 release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev,0)); 435 pci_clear_mwi(pdev); 436 pci_disable_device(pdev); 437 free_netdev(dev); 438 pci_set_drvdata(pdev, NULL); 439} 440 441 442static int streamer_reset(struct net_device *dev) 443{ 444 struct streamer_private *streamer_priv; 445 __u8 __iomem *streamer_mmio; 446 unsigned long t; 447 unsigned int uaa_addr; 448 struct sk_buff *skb = NULL; 449 __u16 misr; 450 451 streamer_priv = (struct streamer_private *) dev->priv; 452 streamer_mmio = streamer_priv->streamer_mmio; 453 454 writew(readw(streamer_mmio + BCTL) | BCTL_SOFTRESET, streamer_mmio + BCTL); 455 t = jiffies; 456 /* Hold soft reset bit for a while */ 457 ssleep(1); 458 459 writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET, 460 streamer_mmio + BCTL); 461 462#if STREAMER_DEBUG 463 printk("BCTL: %x\n", readw(streamer_mmio + BCTL)); 464 printk("GPR: %x\n", readw(streamer_mmio + GPR)); 465 printk("SISRMASK: %x\n", readw(streamer_mmio + SISR_MASK)); 466#endif 467 writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL ); 468 469 if (streamer_priv->streamer_ring_speed == 0) { /* Autosense */ 470 writew(readw(streamer_mmio + GPR) | GPR_AUTOSENSE, 471 streamer_mmio + GPR); 472 if (streamer_priv->streamer_message_level) 473 printk(KERN_INFO "%s: Ringspeed autosense mode on\n", 474 dev->name); 475 } else if (streamer_priv->streamer_ring_speed == 16) { 476 if (streamer_priv->streamer_message_level) 477 printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n", 478 dev->name); 479 writew(GPR_16MBPS, streamer_mmio + GPR); 480 } else if (streamer_priv->streamer_ring_speed == 4) { 481 if (streamer_priv->streamer_message_level) 482 printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n", 483 dev->name); 484 writew(0, streamer_mmio + GPR); 485 } 486 487 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz); 488 if (!skb) { 489 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n", 490 dev->name); 491 } else { 492 struct streamer_rx_desc *rx_ring; 493 u8 *data; 494 495 rx_ring=(struct streamer_rx_desc *)skb->data; 496 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc); 497 rx_ring->forward=0; 498 rx_ring->status=0; 499 rx_ring->buffer=cpu_to_le32(pci_map_single(streamer_priv->pci_dev, data, 500 512, PCI_DMA_FROMDEVICE)); 501 rx_ring->framelen_buflen=512; 502 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, rx_ring, 512, PCI_DMA_FROMDEVICE)), 503 streamer_mmio+RXBDA); 504 } 505 506#if STREAMER_DEBUG 507 printk("GPR = %x\n", readw(streamer_mmio + GPR)); 508#endif 509 /* start solo init */ 510 writew(SISR_MI, streamer_mmio + SISR_MASK_SUM); 511 512 while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) { 513 msleep_interruptible(100); 514 if (time_after(jiffies, t + 40 * HZ)) { 515 printk(KERN_ERR 516 "IBM PCI tokenring card not responding\n"); 517 release_region(dev->base_addr, STREAMER_IO_SPACE); 518 if (skb) 519 dev_kfree_skb(skb); 520 return -1; 521 } 522 } 523 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM); 524 misr = readw(streamer_mmio + MISR_RUM); 525 writew(~misr, streamer_mmio + MISR_RUM); 526 527 if (skb) 528 dev_kfree_skb(skb); /* release skb used for diagnostics */ 529 530#if STREAMER_DEBUG 531 printk("LAPWWO: %x, LAPA: %x LAPE: %x\n", 532 readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA), 533 readw(streamer_mmio + LAPE)); 534#endif 535 536#if STREAMER_DEBUG 537 { 538 int i; 539 writew(readw(streamer_mmio + LAPWWO), 540 streamer_mmio + LAPA); 541 printk("initialization response srb dump: "); 542 for (i = 0; i < 10; i++) 543 printk("%x:", 544 ntohs(readw(streamer_mmio + LAPDINC))); 545 printk("\n"); 546 } 547#endif 548 549 writew(readw(streamer_mmio + LAPWWO) + 6, streamer_mmio + LAPA); 550 if (readw(streamer_mmio + LAPD)) { 551 printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n", 552 ntohs(readw(streamer_mmio + LAPD))); 553 release_region(dev->base_addr, STREAMER_IO_SPACE); 554 return -1; 555 } 556 557 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA); 558 uaa_addr = ntohs(readw(streamer_mmio + LAPDINC)); 559 readw(streamer_mmio + LAPDINC); /* skip over Level.Addr field */ 560 streamer_priv->streamer_addr_table_addr = ntohs(readw(streamer_mmio + LAPDINC)); 561 streamer_priv->streamer_parms_addr = ntohs(readw(streamer_mmio + LAPDINC)); 562 563#if STREAMER_DEBUG 564 printk("UAA resides at %x\n", uaa_addr); 565#endif 566 567 /* setup uaa area for access with LAPD */ 568 { 569 int i; 570 __u16 addr; 571 writew(uaa_addr, streamer_mmio + LAPA); 572 for (i = 0; i < 6; i += 2) { 573 addr=ntohs(readw(streamer_mmio+LAPDINC)); 574 dev->dev_addr[i]= (addr >> 8) & 0xff; 575 dev->dev_addr[i+1]= addr & 0xff; 576 } 577#if STREAMER_DEBUG 578 printk("Adapter address: "); 579 for (i = 0; i < 6; i++) { 580 printk("%02x:", dev->dev_addr[i]); 581 } 582 printk("\n"); 583#endif 584 } 585 return 0; 586} 587 588static int streamer_open(struct net_device *dev) 589{ 590 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv; 591 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 592 unsigned long flags; 593 char open_error[255]; 594 int i, open_finished = 1; 595 __u16 srb_word; 596 __u16 srb_open; 597 int rc; 598 599 if (readw(streamer_mmio+BMCTL_SUM) & BMCTL_RX_ENABLED) { 600 rc=streamer_reset(dev); 601 } 602 603 if (request_irq(dev->irq, &streamer_interrupt, IRQF_SHARED, "lanstreamer", dev)) { 604 return -EAGAIN; 605 } 606#if STREAMER_DEBUG 607 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM)); 608 printk("pending ints: %x\n", readw(streamer_mmio + SISR)); 609#endif 610 611 writew(SISR_MI | SISR_SRB_REPLY, streamer_mmio + SISR_MASK); /* more ints later, doesn't stop arb cmd interrupt */ 612 writew(LISR_LIE, streamer_mmio + LISR); /* more ints later */ 613 614 /* adapter is closed, so SRB is pointed to by LAPWWO */ 615 writew(readw(streamer_mmio + LAPWWO), streamer_mmio + LAPA); 616 617#if STREAMER_DEBUG 618 printk("LAPWWO: %x, LAPA: %x\n", readw(streamer_mmio + LAPWWO), 619 readw(streamer_mmio + LAPA)); 620 printk("LAPE: %x\n", readw(streamer_mmio + LAPE)); 621 printk("SISR Mask = %04x\n", readw(streamer_mmio + SISR_MASK)); 622#endif 623 do { 624 int i; 625 626 for (i = 0; i < SRB_COMMAND_SIZE; i += 2) { 627 writew(0, streamer_mmio + LAPDINC); 628 } 629 630 writew(readw(streamer_mmio+LAPWWO),streamer_mmio+LAPA); 631 writew(htons(SRB_OPEN_ADAPTER<<8),streamer_mmio+LAPDINC) ; /* open */ 632 writew(htons(STREAMER_CLEAR_RET_CODE<<8),streamer_mmio+LAPDINC); 633 writew(STREAMER_CLEAR_RET_CODE, streamer_mmio + LAPDINC); 634 635 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA); 636#if STREAMER_NETWORK_MONITOR 637 /* If Network Monitor, instruct card to copy MAC frames through the ARB */ 638 writew(htons(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), streamer_mmio + LAPDINC); /* offset 8 word contains open options */ 639#else 640 writew(htons(OPEN_ADAPTER_ENABLE_FDX), streamer_mmio + LAPDINC); /* Offset 8 word contains Open.Options */ 641#endif 642 643 if (streamer_priv->streamer_laa[0]) { 644 writew(readw(streamer_mmio + LAPWWO) + 12, streamer_mmio + LAPA); 645 writew(htons((streamer_priv->streamer_laa[0] << 8) | 646 streamer_priv->streamer_laa[1]),streamer_mmio+LAPDINC); 647 writew(htons((streamer_priv->streamer_laa[2] << 8) | 648 streamer_priv->streamer_laa[3]),streamer_mmio+LAPDINC); 649 writew(htons((streamer_priv->streamer_laa[4] << 8) | 650 streamer_priv->streamer_laa[5]),streamer_mmio+LAPDINC); 651 memcpy(dev->dev_addr, streamer_priv->streamer_laa, dev->addr_len); 652 } 653 654 /* save off srb open offset */ 655 srb_open = readw(streamer_mmio + LAPWWO); 656#if STREAMER_DEBUG 657 writew(readw(streamer_mmio + LAPWWO), 658 streamer_mmio + LAPA); 659 printk("srb open request: \n"); 660 for (i = 0; i < 16; i++) { 661 printk("%x:", ntohs(readw(streamer_mmio + LAPDINC))); 662 } 663 printk("\n"); 664#endif 665 spin_lock_irqsave(&streamer_priv->streamer_lock, flags); 666 streamer_priv->srb_queued = 1; 667 668 /* signal solo that SRB command has been issued */ 669 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM); 670 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags); 671 672 while (streamer_priv->srb_queued) { 673 interruptible_sleep_on_timeout(&streamer_priv->srb_wait, 5 * HZ); 674 if (signal_pending(current)) { 675 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name); 676 printk(KERN_WARNING "SISR=%x MISR=%x, LISR=%x\n", 677 readw(streamer_mmio + SISR), 678 readw(streamer_mmio + MISR_RUM), 679 readw(streamer_mmio + LISR)); 680 streamer_priv->srb_queued = 0; 681 break; 682 } 683 } 684 685#if STREAMER_DEBUG 686 printk("SISR_MASK: %x\n", readw(streamer_mmio + SISR_MASK)); 687 printk("srb open response:\n"); 688 writew(srb_open, streamer_mmio + LAPA); 689 for (i = 0; i < 10; i++) { 690 printk("%x:", 691 ntohs(readw(streamer_mmio + LAPDINC))); 692 } 693#endif 694 695 /* If we get the same return response as we set, the interrupt wasn't raised and the open 696 * timed out. 697 */ 698 writew(srb_open + 2, streamer_mmio + LAPA); 699 srb_word = ntohs(readw(streamer_mmio + LAPD)) >> 8; 700 if (srb_word == STREAMER_CLEAR_RET_CODE) { 701 printk(KERN_WARNING "%s: Adapter Open time out or error.\n", 702 dev->name); 703 return -EIO; 704 } 705 706 if (srb_word != 0) { 707 if (srb_word == 0x07) { 708 if (!streamer_priv->streamer_ring_speed && open_finished) { /* Autosense , first time around */ 709 printk(KERN_WARNING "%s: Retrying at different ring speed \n", 710 dev->name); 711 open_finished = 0; 712 } else { 713 __u16 error_code; 714 715 writew(srb_open + 6, streamer_mmio + LAPA); 716 error_code = ntohs(readw(streamer_mmio + LAPD)); 717 strcpy(open_error, open_maj_error[(error_code & 0xf0) >> 4]); 718 strcat(open_error, " - "); 719 strcat(open_error, open_min_error[(error_code & 0x0f)]); 720 721 if (!streamer_priv->streamer_ring_speed 722 && ((error_code & 0x0f) == 0x0d)) 723 { 724 printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n", dev->name); 725 printk(KERN_WARNING "%s: Please try again with a specified ring speed \n", dev->name); 726 free_irq(dev->irq, dev); 727 return -EIO; 728 } 729 730 printk(KERN_WARNING "%s: %s\n", 731 dev->name, open_error); 732 free_irq(dev->irq, dev); 733 return -EIO; 734 735 } /* if autosense && open_finished */ 736 } else { 737 printk(KERN_WARNING "%s: Bad OPEN response: %x\n", 738 dev->name, srb_word); 739 free_irq(dev->irq, dev); 740 return -EIO; 741 } 742 } else 743 open_finished = 1; 744 } while (!(open_finished)); /* Will only loop if ring speed mismatch re-open attempted && autosense is on */ 745 746 writew(srb_open + 18, streamer_mmio + LAPA); 747 srb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8; 748 if (srb_word & (1 << 3)) 749 if (streamer_priv->streamer_message_level) 750 printk(KERN_INFO "%s: Opened in FDX Mode\n", dev->name); 751 752 if (srb_word & 1) 753 streamer_priv->streamer_ring_speed = 16; 754 else 755 streamer_priv->streamer_ring_speed = 4; 756 757 if (streamer_priv->streamer_message_level) 758 printk(KERN_INFO "%s: Opened in %d Mbps mode\n", 759 dev->name, 760 streamer_priv->streamer_ring_speed); 761 762 writew(srb_open + 8, streamer_mmio + LAPA); 763 streamer_priv->asb = ntohs(readw(streamer_mmio + LAPDINC)); 764 streamer_priv->srb = ntohs(readw(streamer_mmio + LAPDINC)); 765 streamer_priv->arb = ntohs(readw(streamer_mmio + LAPDINC)); 766 readw(streamer_mmio + LAPDINC); /* offset 14 word is rsvd */ 767 streamer_priv->trb = ntohs(readw(streamer_mmio + LAPDINC)); 768 769 streamer_priv->streamer_receive_options = 0x00; 770 streamer_priv->streamer_copy_all_options = 0; 771 772 /* setup rx ring */ 773 /* enable rx channel */ 774 writew(~BMCTL_RX_DIS, streamer_mmio + BMCTL_RUM); 775 776 /* setup rx descriptors */ 777 streamer_priv->streamer_rx_ring= 778 kmalloc( sizeof(struct streamer_rx_desc)* 779 STREAMER_RX_RING_SIZE,GFP_KERNEL); 780 if (!streamer_priv->streamer_rx_ring) { 781 printk(KERN_WARNING "%s ALLOC of streamer rx ring FAILED!!\n",dev->name); 782 return -EIO; 783 } 784 785 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) { 786 struct sk_buff *skb; 787 788 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz); 789 if (skb == NULL) 790 break; 791 792 skb->dev = dev; 793 794 streamer_priv->streamer_rx_ring[i].forward = 795 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[i + 1], 796 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)); 797 streamer_priv->streamer_rx_ring[i].status = 0; 798 streamer_priv->streamer_rx_ring[i].buffer = 799 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, 800 streamer_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)); 801 streamer_priv->streamer_rx_ring[i].framelen_buflen = streamer_priv->pkt_buf_sz; 802 streamer_priv->rx_ring_skb[i] = skb; 803 } 804 streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1].forward = 805 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0], 806 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)); 807 808 if (i == 0) { 809 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n", dev->name); 810 free_irq(dev->irq, dev); 811 return -EIO; 812 } 813 814 streamer_priv->rx_ring_last_received = STREAMER_RX_RING_SIZE - 1; /* last processed rx status */ 815 816 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0], 817 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)), 818 streamer_mmio + RXBDA); 819 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1], 820 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)), 821 streamer_mmio + RXLBDA); 822 823 /* set bus master interrupt event mask */ 824 writew(MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK); 825 826 827 /* setup tx ring */ 828 streamer_priv->streamer_tx_ring=kmalloc(sizeof(struct streamer_tx_desc)* 829 STREAMER_TX_RING_SIZE,GFP_KERNEL); 830 if (!streamer_priv->streamer_tx_ring) { 831 printk(KERN_WARNING "%s ALLOC of streamer_tx_ring FAILED\n",dev->name); 832 return -EIO; 833 } 834 835 writew(~BMCTL_TX2_DIS, streamer_mmio + BMCTL_RUM); /* Enables TX channel 2 */ 836 for (i = 0; i < STREAMER_TX_RING_SIZE; i++) { 837 streamer_priv->streamer_tx_ring[i].forward = cpu_to_le32(pci_map_single(streamer_priv->pci_dev, 838 &streamer_priv->streamer_tx_ring[i + 1], 839 sizeof(struct streamer_tx_desc), 840 PCI_DMA_TODEVICE)); 841 streamer_priv->streamer_tx_ring[i].status = 0; 842 streamer_priv->streamer_tx_ring[i].bufcnt_framelen = 0; 843 streamer_priv->streamer_tx_ring[i].buffer = 0; 844 streamer_priv->streamer_tx_ring[i].buflen = 0; 845 streamer_priv->streamer_tx_ring[i].rsvd1 = 0; 846 streamer_priv->streamer_tx_ring[i].rsvd2 = 0; 847 streamer_priv->streamer_tx_ring[i].rsvd3 = 0; 848 } 849 streamer_priv->streamer_tx_ring[STREAMER_TX_RING_SIZE - 1].forward = 850 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_tx_ring[0], 851 sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE)); 852 853 streamer_priv->free_tx_ring_entries = STREAMER_TX_RING_SIZE; 854 streamer_priv->tx_ring_free = 0; /* next entry in tx ring to use */ 855 streamer_priv->tx_ring_last_status = STREAMER_TX_RING_SIZE - 1; 856 857 /* set Busmaster interrupt event mask (handle receives on interrupt only */ 858 writew(MISR_TX2_EOF | MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK); 859 /* set system event interrupt mask */ 860 writew(SISR_ADAPTER_CHECK | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_ASB_FREE, streamer_mmio + SISR_MASK_SUM); 861 862#if STREAMER_DEBUG 863 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM)); 864 printk("SISR MASK: %x\n", readw(streamer_mmio + SISR_MASK)); 865#endif 866 867#if STREAMER_NETWORK_MONITOR 868 869 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA); 870 printk("%s: Node Address: %04x:%04x:%04x\n", dev->name, 871 ntohs(readw(streamer_mmio + LAPDINC)), 872 ntohs(readw(streamer_mmio + LAPDINC)), 873 ntohs(readw(streamer_mmio + LAPDINC))); 874 readw(streamer_mmio + LAPDINC); 875 readw(streamer_mmio + LAPDINC); 876 printk("%s: Functional Address: %04x:%04x\n", dev->name, 877 ntohs(readw(streamer_mmio + LAPDINC)), 878 ntohs(readw(streamer_mmio + LAPDINC))); 879 880 writew(streamer_priv->streamer_parms_addr + 4, 881 streamer_mmio + LAPA); 882 printk("%s: NAUN Address: %04x:%04x:%04x\n", dev->name, 883 ntohs(readw(streamer_mmio + LAPDINC)), 884 ntohs(readw(streamer_mmio + LAPDINC)), 885 ntohs(readw(streamer_mmio + LAPDINC))); 886#endif 887 888 netif_start_queue(dev); 889 netif_carrier_on(dev); 890 return 0; 891} 892 893/* 894 * When we enter the rx routine we do not know how many frames have been 895 * queued on the rx channel. Therefore we start at the next rx status 896 * position and travel around the receive ring until we have completed 897 * all the frames. 898 * 899 * This means that we may process the frame before we receive the end 900 * of frame interrupt. This is why we always test the status instead 901 * of blindly processing the next frame. 902 * 903 */ 904static void streamer_rx(struct net_device *dev) 905{ 906 struct streamer_private *streamer_priv = 907 (struct streamer_private *) dev->priv; 908 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 909 struct streamer_rx_desc *rx_desc; 910 int rx_ring_last_received, length, frame_length, buffer_cnt = 0; 911 struct sk_buff *skb, *skb2; 912 913 /* setup the next rx descriptor to be received */ 914 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)]; 915 rx_ring_last_received = streamer_priv->rx_ring_last_received; 916 917 while (rx_desc->status & 0x01000000) { /* While processed descriptors are available */ 918 if (rx_ring_last_received != streamer_priv->rx_ring_last_received) 919 { 920 printk(KERN_WARNING "RX Error 1 rx_ring_last_received not the same %x %x\n", 921 rx_ring_last_received, streamer_priv->rx_ring_last_received); 922 } 923 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1); 924 rx_ring_last_received = streamer_priv->rx_ring_last_received; 925 926 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */ 927 frame_length = (rx_desc->framelen_buflen >> 16) & 0xffff; 928 929 if (rx_desc->status & 0x7E830000) { /* errors */ 930 if (streamer_priv->streamer_message_level) { 931 printk(KERN_WARNING "%s: Rx Error %x \n", 932 dev->name, rx_desc->status); 933 } 934 } else { /* received without errors */ 935 if (rx_desc->status & 0x80000000) { /* frame complete */ 936 buffer_cnt = 1; 937 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz); 938 } else { 939 skb = dev_alloc_skb(frame_length); 940 } 941 942 if (skb == NULL) 943 { 944 printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers. \n", dev->name); 945 streamer_priv->streamer_stats.rx_dropped++; 946 } else { /* we allocated an skb OK */ 947 if (buffer_cnt == 1) { 948 /* release the DMA mapping */ 949 pci_unmap_single(streamer_priv->pci_dev, 950 le32_to_cpu(streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer), 951 streamer_priv->pkt_buf_sz, 952 PCI_DMA_FROMDEVICE); 953 skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received]; 954#if STREAMER_DEBUG_PACKETS 955 { 956 int i; 957 printk("streamer_rx packet print: skb->data2 %p skb->head %p\n", skb2->data, skb2->head); 958 for (i = 0; i < frame_length; i++) 959 { 960 printk("%x:", skb2->data[i]); 961 if (((i + 1) % 16) == 0) 962 printk("\n"); 963 } 964 printk("\n"); 965 } 966#endif 967 skb_put(skb2, length); 968 skb2->protocol = tr_type_trans(skb2, dev); 969 /* recycle this descriptor */ 970 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0; 971 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz; 972 streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer = 973 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, streamer_priv->pkt_buf_sz, 974 PCI_DMA_FROMDEVICE)); 975 streamer_priv->rx_ring_skb[rx_ring_last_received] = skb; 976 /* place recycled descriptor back on the adapter */ 977 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, 978 &streamer_priv->streamer_rx_ring[rx_ring_last_received], 979 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)), 980 streamer_mmio + RXLBDA); 981 /* pass the received skb up to the protocol */ 982 netif_rx(skb2); 983 } else { 984 do { /* Walk the buffers */ 985 pci_unmap_single(streamer_priv->pci_dev, le32_to_cpu(rx_desc->buffer), length, PCI_DMA_FROMDEVICE), 986 memcpy(skb_put(skb, length), (void *)rx_desc->buffer, length); /* copy this fragment */ 987 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0; 988 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz; 989 990 /* give descriptor back to the adapter */ 991 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, 992 &streamer_priv->streamer_rx_ring[rx_ring_last_received], 993 length, PCI_DMA_FROMDEVICE)), 994 streamer_mmio + RXLBDA); 995 996 if (rx_desc->status & 0x80000000) 997 break; /* this descriptor completes the frame */ 998 999 /* else get the next pending descriptor */ 1000 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received) 1001 { 1002 printk("RX Error rx_ring_last_received not the same %x %x\n", 1003 rx_ring_last_received, 1004 streamer_priv->rx_ring_last_received); 1005 } 1006 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)]; 1007 1008 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */ 1009 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE - 1); 1010 rx_ring_last_received = streamer_priv->rx_ring_last_received; 1011 } while (1); 1012 1013 skb->protocol = tr_type_trans(skb, dev); 1014 /* send up to the protocol */ 1015 netif_rx(skb); 1016 } 1017 dev->last_rx = jiffies; 1018 streamer_priv->streamer_stats.rx_packets++; 1019 streamer_priv->streamer_stats.rx_bytes += length; 1020 } /* if skb == null */ 1021 } /* end received without errors */ 1022 1023 /* try the next one */ 1024 rx_desc = &streamer_priv->streamer_rx_ring[(rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)]; 1025 } /* end for all completed rx descriptors */ 1026} 1027 1028static irqreturn_t streamer_interrupt(int irq, void *dev_id) 1029{ 1030 struct net_device *dev = (struct net_device *) dev_id; 1031 struct streamer_private *streamer_priv = 1032 (struct streamer_private *) dev->priv; 1033 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1034 __u16 sisr; 1035 __u16 misr; 1036 u8 max_intr = MAX_INTR; 1037 1038 spin_lock(&streamer_priv->streamer_lock); 1039 sisr = readw(streamer_mmio + SISR); 1040 1041 while((sisr & (SISR_MI | SISR_SRB_REPLY | SISR_ADAPTER_CHECK | SISR_ASB_FREE | 1042 SISR_ARB_CMD | SISR_TRB_REPLY | SISR_PAR_ERR | SISR_SERR_ERR)) 1043 && (max_intr > 0)) { 1044 1045 if(sisr & SISR_PAR_ERR) { 1046 writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM); 1047 (void)readw(streamer_mmio + SISR_RUM); 1048 } 1049 1050 else if(sisr & SISR_SERR_ERR) { 1051 writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM); 1052 (void)readw(streamer_mmio + SISR_RUM); 1053 } 1054 1055 else if(sisr & SISR_MI) { 1056 misr = readw(streamer_mmio + MISR_RUM); 1057 1058 if (misr & MISR_TX2_EOF) { 1059 while(streamer_priv->streamer_tx_ring[(streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1)].status) { 1060 streamer_priv->tx_ring_last_status = (streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1); 1061 streamer_priv->free_tx_ring_entries++; 1062 streamer_priv->streamer_stats.tx_bytes += streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]->len; 1063 streamer_priv->streamer_stats.tx_packets++; 1064 dev_kfree_skb_irq(streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]); 1065 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buffer = 0xdeadbeef; 1066 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].status = 0; 1067 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].bufcnt_framelen = 0; 1068 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buflen = 0; 1069 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd1 = 0; 1070 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd2 = 0; 1071 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd3 = 0; 1072 } 1073 netif_wake_queue(dev); 1074 } 1075 1076 if (misr & MISR_RX_EOF) { 1077 streamer_rx(dev); 1078 } 1079 /* MISR_RX_EOF */ 1080 1081 if (misr & MISR_RX_NOBUF) { 1082 /* According to the documentation, we don't have to do anything, 1083 * but trapping it keeps it out of /var/log/messages. 1084 */ 1085 } /* SISR_RX_NOBUF */ 1086 1087 writew(~misr, streamer_mmio + MISR_RUM); 1088 (void)readw(streamer_mmio + MISR_RUM); 1089 } 1090 1091 else if (sisr & SISR_SRB_REPLY) { 1092 if (streamer_priv->srb_queued == 1) { 1093 wake_up_interruptible(&streamer_priv->srb_wait); 1094 } else if (streamer_priv->srb_queued == 2) { 1095 streamer_srb_bh(dev); 1096 } 1097 streamer_priv->srb_queued = 0; 1098 1099 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM); 1100 (void)readw(streamer_mmio + SISR_RUM); 1101 } 1102 1103 else if (sisr & SISR_ADAPTER_CHECK) { 1104 printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name); 1105 writel(readl(streamer_mmio + LAPWWO), streamer_mmio + LAPA); 1106 printk(KERN_WARNING "%s: Words %x:%x:%x:%x:\n", 1107 dev->name, readw(streamer_mmio + LAPDINC), 1108 ntohs(readw(streamer_mmio + LAPDINC)), 1109 ntohs(readw(streamer_mmio + LAPDINC)), 1110 ntohs(readw(streamer_mmio + LAPDINC))); 1111 netif_stop_queue(dev); 1112 netif_carrier_off(dev); 1113 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name); 1114 } 1115 1116 /* SISR_ADAPTER_CHECK */ 1117 else if (sisr & SISR_ASB_FREE) { 1118 /* Wake up anything that is waiting for the asb response */ 1119 if (streamer_priv->asb_queued) { 1120 streamer_asb_bh(dev); 1121 } 1122 writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM); 1123 (void)readw(streamer_mmio + SISR_RUM); 1124 } 1125 /* SISR_ASB_FREE */ 1126 else if (sisr & SISR_ARB_CMD) { 1127 streamer_arb_cmd(dev); 1128 writew(~SISR_ARB_CMD, streamer_mmio + SISR_RUM); 1129 (void)readw(streamer_mmio + SISR_RUM); 1130 } 1131 /* SISR_ARB_CMD */ 1132 else if (sisr & SISR_TRB_REPLY) { 1133 /* Wake up anything that is waiting for the trb response */ 1134 if (streamer_priv->trb_queued) { 1135 wake_up_interruptible(&streamer_priv-> 1136 trb_wait); 1137 } 1138 streamer_priv->trb_queued = 0; 1139 writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM); 1140 (void)readw(streamer_mmio + SISR_RUM); 1141 } 1142 /* SISR_TRB_REPLY */ 1143 1144 sisr = readw(streamer_mmio + SISR); 1145 max_intr--; 1146 } /* while() */ 1147 1148 spin_unlock(&streamer_priv->streamer_lock) ; 1149 return IRQ_HANDLED; 1150} 1151 1152static int streamer_xmit(struct sk_buff *skb, struct net_device *dev) 1153{ 1154 struct streamer_private *streamer_priv = 1155 (struct streamer_private *) dev->priv; 1156 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1157 unsigned long flags ; 1158 1159 spin_lock_irqsave(&streamer_priv->streamer_lock, flags); 1160 1161 if (streamer_priv->free_tx_ring_entries) { 1162 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].status = 0; 1163 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].bufcnt_framelen = 0x00020000 | skb->len; 1164 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buffer = 1165 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE)); 1166 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd1 = skb->len; 1167 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd2 = 0; 1168 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd3 = 0; 1169 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buflen = skb->len; 1170 1171 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb; 1172 streamer_priv->free_tx_ring_entries--; 1173#if STREAMER_DEBUG_PACKETS 1174 { 1175 int i; 1176 printk("streamer_xmit packet print:\n"); 1177 for (i = 0; i < skb->len; i++) { 1178 printk("%x:", skb->data[i]); 1179 if (((i + 1) % 16) == 0) 1180 printk("\n"); 1181 } 1182 printk("\n"); 1183 } 1184#endif 1185 1186 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, 1187 &streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free], 1188 sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE)), 1189 streamer_mmio + TX2LFDA); 1190 (void)readl(streamer_mmio + TX2LFDA); 1191 1192 streamer_priv->tx_ring_free = (streamer_priv->tx_ring_free + 1) & (STREAMER_TX_RING_SIZE - 1); 1193 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags); 1194 return 0; 1195 } else { 1196 netif_stop_queue(dev); 1197 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags); 1198 return 1; 1199 } 1200} 1201 1202 1203static int streamer_close(struct net_device *dev) 1204{ 1205 struct streamer_private *streamer_priv = 1206 (struct streamer_private *) dev->priv; 1207 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1208 unsigned long flags; 1209 int i; 1210 1211 netif_stop_queue(dev); 1212 netif_carrier_off(dev); 1213 writew(streamer_priv->srb, streamer_mmio + LAPA); 1214 writew(htons(SRB_CLOSE_ADAPTER << 8),streamer_mmio+LAPDINC); 1215 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1216 1217 spin_lock_irqsave(&streamer_priv->streamer_lock, flags); 1218 1219 streamer_priv->srb_queued = 1; 1220 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM); 1221 1222 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags); 1223 1224 while (streamer_priv->srb_queued) 1225 { 1226 interruptible_sleep_on_timeout(&streamer_priv->srb_wait, 1227 jiffies + 60 * HZ); 1228 if (signal_pending(current)) 1229 { 1230 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name); 1231 printk(KERN_WARNING "SISR=%x MISR=%x LISR=%x\n", 1232 readw(streamer_mmio + SISR), 1233 readw(streamer_mmio + MISR_RUM), 1234 readw(streamer_mmio + LISR)); 1235 streamer_priv->srb_queued = 0; 1236 break; 1237 } 1238 } 1239 1240 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1); 1241 1242 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) { 1243 if (streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]) { 1244 dev_kfree_skb(streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]); 1245 } 1246 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1); 1247 } 1248 1249 /* reset tx/rx fifo's and busmaster logic */ 1250 1251 /* TBD. Add graceful way to reset the LLC channel without doing a soft reset. 1252 writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL); 1253 udelay(1); 1254 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); 1255 */ 1256 1257#if STREAMER_DEBUG 1258 writew(streamer_priv->srb, streamer_mmio + LAPA); 1259 printk("srb): "); 1260 for (i = 0; i < 2; i++) { 1261 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC))); 1262 } 1263 printk("\n"); 1264#endif 1265 free_irq(dev->irq, dev); 1266 return 0; 1267} 1268 1269static void streamer_set_rx_mode(struct net_device *dev) 1270{ 1271 struct streamer_private *streamer_priv = 1272 (struct streamer_private *) dev->priv; 1273 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1274 __u8 options = 0; 1275 struct dev_mc_list *dmi; 1276 unsigned char dev_mc_address[5]; 1277 int i; 1278 1279 writel(streamer_priv->srb, streamer_mmio + LAPA); 1280 options = streamer_priv->streamer_copy_all_options; 1281 1282 if (dev->flags & IFF_PROMISC) 1283 options |= (3 << 5); /* All LLC and MAC frames, all through the main rx channel */ 1284 else 1285 options &= ~(3 << 5); 1286 1287 /* Only issue the srb if there is a change in options */ 1288 1289 if ((options ^ streamer_priv->streamer_copy_all_options)) 1290 { 1291 /* Now to issue the srb command to alter the copy.all.options */ 1292 writew(htons(SRB_MODIFY_RECEIVE_OPTIONS << 8), streamer_mmio+LAPDINC); 1293 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1294 writew(htons((streamer_priv->streamer_receive_options << 8) | options),streamer_mmio+LAPDINC); 1295 writew(htons(0x4a41),streamer_mmio+LAPDINC); 1296 writew(htons(0x4d45),streamer_mmio+LAPDINC); 1297 writew(htons(0x5320),streamer_mmio+LAPDINC); 1298 writew(0x2020, streamer_mmio + LAPDINC); 1299 1300 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */ 1301 1302 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM); 1303 1304 streamer_priv->streamer_copy_all_options = options; 1305 return; 1306 } 1307 1308 /* Set the functional addresses we need for multicast */ 1309 writel(streamer_priv->srb,streamer_mmio+LAPA); 1310 dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ; 1311 1312 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next) 1313 { 1314 dev_mc_address[0] |= dmi->dmi_addr[2] ; 1315 dev_mc_address[1] |= dmi->dmi_addr[3] ; 1316 dev_mc_address[2] |= dmi->dmi_addr[4] ; 1317 dev_mc_address[3] |= dmi->dmi_addr[5] ; 1318 } 1319 1320 writew(htons(SRB_SET_FUNC_ADDRESS << 8),streamer_mmio+LAPDINC); 1321 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1322 writew(0,streamer_mmio+LAPDINC); 1323 writew(htons( (dev_mc_address[0] << 8) | dev_mc_address[1]),streamer_mmio+LAPDINC); 1324 writew(htons( (dev_mc_address[2] << 8) | dev_mc_address[3]),streamer_mmio+LAPDINC); 1325 streamer_priv->srb_queued = 2 ; 1326 writel(LISR_SRB_CMD,streamer_mmio+LISR_SUM); 1327} 1328 1329static void streamer_srb_bh(struct net_device *dev) 1330{ 1331 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv; 1332 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1333 __u16 srb_word; 1334 1335 writew(streamer_priv->srb, streamer_mmio + LAPA); 1336 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1337 1338 switch (srb_word) { 1339 1340 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous) 1341 * At some point we should do something if we get an error, such as 1342 * resetting the IFF_PROMISC flag in dev 1343 */ 1344 1345 case SRB_MODIFY_RECEIVE_OPTIONS: 1346 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1347 1348 switch (srb_word) { 1349 case 0x01: 1350 printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name); 1351 break; 1352 case 0x04: 1353 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1354 break; 1355 default: 1356 if (streamer_priv->streamer_message_level) 1357 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n", 1358 dev->name, 1359 streamer_priv->streamer_copy_all_options, 1360 streamer_priv->streamer_receive_options); 1361 break; 1362 } /* switch srb[2] */ 1363 break; 1364 1365 1366 /* SRB_SET_GROUP_ADDRESS - Multicast group setting 1367 */ 1368 case SRB_SET_GROUP_ADDRESS: 1369 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1370 switch (srb_word) { 1371 case 0x00: 1372 break; 1373 case 0x01: 1374 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name); 1375 break; 1376 case 0x04: 1377 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1378 break; 1379 case 0x3c: 1380 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name); 1381 break; 1382 case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */ 1383 printk(KERN_WARNING "%s: Group address registers full\n", dev->name); 1384 break; 1385 case 0x55: 1386 printk(KERN_INFO "%s: Group Address already set.\n", dev->name); 1387 break; 1388 default: 1389 break; 1390 } /* switch srb[2] */ 1391 break; 1392 1393 1394 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list 1395 */ 1396 case SRB_RESET_GROUP_ADDRESS: 1397 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1398 switch (srb_word) { 1399 case 0x00: 1400 break; 1401 case 0x01: 1402 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name); 1403 break; 1404 case 0x04: 1405 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1406 break; 1407 case 0x39: /* Must deal with this if individual multicast addresses used */ 1408 printk(KERN_INFO "%s: Group address not found \n", dev->name); 1409 break; 1410 default: 1411 break; 1412 } /* switch srb[2] */ 1413 break; 1414 1415 1416 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode 1417 */ 1418 1419 case SRB_SET_FUNC_ADDRESS: 1420 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1421 switch (srb_word) { 1422 case 0x00: 1423 if (streamer_priv->streamer_message_level) 1424 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name); 1425 break; 1426 case 0x01: 1427 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name); 1428 break; 1429 case 0x04: 1430 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1431 break; 1432 default: 1433 break; 1434 } /* switch srb[2] */ 1435 break; 1436 1437 /* SRB_READ_LOG - Read and reset the adapter error counters 1438 */ 1439 1440 case SRB_READ_LOG: 1441 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1442 switch (srb_word) { 1443 case 0x00: 1444 { 1445 int i; 1446 if (streamer_priv->streamer_message_level) 1447 printk(KERN_INFO "%s: Read Log command complete\n", dev->name); 1448 printk("Read Log statistics: "); 1449 writew(streamer_priv->srb + 6, 1450 streamer_mmio + LAPA); 1451 for (i = 0; i < 5; i++) { 1452 printk("%x:", ntohs(readw(streamer_mmio + LAPDINC))); 1453 } 1454 printk("\n"); 1455 } 1456 break; 1457 case 0x01: 1458 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name); 1459 break; 1460 case 0x04: 1461 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1462 break; 1463 1464 } /* switch srb[2] */ 1465 break; 1466 1467 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */ 1468 1469 case SRB_READ_SR_COUNTERS: 1470 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; 1471 switch (srb_word) { 1472 case 0x00: 1473 if (streamer_priv->streamer_message_level) 1474 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name); 1475 break; 1476 case 0x01: 1477 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name); 1478 break; 1479 case 0x04: 1480 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name); 1481 break; 1482 default: 1483 break; 1484 } /* switch srb[2] */ 1485 break; 1486 1487 default: 1488 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name); 1489 break; 1490 } /* switch srb[0] */ 1491} 1492 1493static struct net_device_stats *streamer_get_stats(struct net_device *dev) 1494{ 1495 struct streamer_private *streamer_priv; 1496 streamer_priv = (struct streamer_private *) dev->priv; 1497 return (struct net_device_stats *) &streamer_priv->streamer_stats; 1498} 1499 1500static int streamer_set_mac_address(struct net_device *dev, void *addr) 1501{ 1502 struct sockaddr *saddr = addr; 1503 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv; 1504 1505 if (netif_running(dev)) 1506 { 1507 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name); 1508 return -EIO; 1509 } 1510 1511 memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len); 1512 1513 if (streamer_priv->streamer_message_level) { 1514 printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n", 1515 dev->name, streamer_priv->streamer_laa[0], 1516 streamer_priv->streamer_laa[1], 1517 streamer_priv->streamer_laa[2], 1518 streamer_priv->streamer_laa[3], 1519 streamer_priv->streamer_laa[4], 1520 streamer_priv->streamer_laa[5]); 1521 } 1522 return 0; 1523} 1524 1525static void streamer_arb_cmd(struct net_device *dev) 1526{ 1527 struct streamer_private *streamer_priv = 1528 (struct streamer_private *) dev->priv; 1529 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1530 __u8 header_len; 1531 __u16 frame_len, buffer_len; 1532 struct sk_buff *mac_frame; 1533 __u8 frame_data[256]; 1534 __u16 buff_off; 1535 __u16 lan_status = 0, lan_status_diff; /* Initialize to stop compiler warning */ 1536 __u8 fdx_prot_error; 1537 __u16 next_ptr; 1538 __u16 arb_word; 1539 1540#if STREAMER_NETWORK_MONITOR 1541 struct trh_hdr *mac_hdr; 1542#endif 1543 1544 writew(streamer_priv->arb, streamer_mmio + LAPA); 1545 arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8; 1546 1547 if (arb_word == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */ 1548 writew(streamer_priv->arb + 6, streamer_mmio + LAPA); 1549 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC)); 1550 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */ 1551 frame_len = ntohs(readw(streamer_mmio + LAPDINC)); 1552 1553#if STREAMER_DEBUG 1554 { 1555 int i; 1556 __u16 next; 1557 __u8 status; 1558 __u16 len; 1559 1560 writew(ntohs(buff_off), streamer_mmio + LAPA); /*setup window to frame data */ 1561 next = htons(readw(streamer_mmio + LAPDINC)); 1562 status = 1563 ntohs(readw(streamer_mmio + LAPDINC)) & 0xff; 1564 len = ntohs(readw(streamer_mmio + LAPDINC)); 1565 1566 /* print out 1st 14 bytes of frame data */ 1567 for (i = 0; i < 7; i++) { 1568 printk("Loc %d = %04x\n", i, 1569 ntohs(readw 1570 (streamer_mmio + LAPDINC))); 1571 } 1572 1573 printk("next %04x, fs %02x, len %04x \n", next, 1574 status, len); 1575 } 1576#endif 1577 if (!(mac_frame = dev_alloc_skb(frame_len))) { 1578 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n", 1579 dev->name); 1580 goto drop_frame; 1581 } 1582 /* Walk the buffer chain, creating the frame */ 1583 1584 do { 1585 int i; 1586 __u16 rx_word; 1587 1588 writew(htons(buff_off), streamer_mmio + LAPA); /* setup window to frame data */ 1589 next_ptr = ntohs(readw(streamer_mmio + LAPDINC)); 1590 readw(streamer_mmio + LAPDINC); /* read thru status word */ 1591 buffer_len = ntohs(readw(streamer_mmio + LAPDINC)); 1592 1593 if (buffer_len > 256) 1594 break; 1595 1596 i = 0; 1597 while (i < buffer_len) { 1598 rx_word=ntohs(readw(streamer_mmio+LAPDINC)); 1599 frame_data[i]=rx_word >> 8; 1600 frame_data[i+1]=rx_word & 0xff; 1601 i += 2; 1602 } 1603 1604 memcpy(skb_put(mac_frame, buffer_len), 1605 frame_data, buffer_len); 1606 } while (next_ptr && (buff_off = next_ptr)); 1607 1608 mac_frame->protocol = tr_type_trans(mac_frame, dev); 1609#if STREAMER_NETWORK_MONITOR 1610 printk(KERN_WARNING "%s: Received MAC Frame, details: \n", 1611 dev->name); 1612 mac_hdr = tr_hdr(mac_frame); 1613 printk(KERN_WARNING 1614 "%s: MAC Frame Dest. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n", 1615 dev->name, mac_hdr->daddr[0], mac_hdr->daddr[1], 1616 mac_hdr->daddr[2], mac_hdr->daddr[3], 1617 mac_hdr->daddr[4], mac_hdr->daddr[5]); 1618 printk(KERN_WARNING 1619 "%s: MAC Frame Srce. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n", 1620 dev->name, mac_hdr->saddr[0], mac_hdr->saddr[1], 1621 mac_hdr->saddr[2], mac_hdr->saddr[3], 1622 mac_hdr->saddr[4], mac_hdr->saddr[5]); 1623#endif 1624 netif_rx(mac_frame); 1625 1626 /* Now tell the card we have dealt with the received frame */ 1627drop_frame: 1628 /* Set LISR Bit 1 */ 1629 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM); 1630 1631 /* Is the ASB free ? */ 1632 1633 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE)) 1634 { 1635 streamer_priv->asb_queued = 1; 1636 writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM); 1637 return; 1638 /* Drop out and wait for the bottom half to be run */ 1639 } 1640 1641 1642 writew(streamer_priv->asb, streamer_mmio + LAPA); 1643 writew(htons(ASB_RECEIVE_DATA << 8), streamer_mmio+LAPDINC); 1644 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1645 writew(0, streamer_mmio + LAPDINC); 1646 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD); 1647 1648 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM); 1649 1650 streamer_priv->asb_queued = 2; 1651 return; 1652 1653 } else if (arb_word == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */ 1654 writew(streamer_priv->arb + 6, streamer_mmio + LAPA); 1655 lan_status = ntohs(readw(streamer_mmio + LAPDINC)); 1656 fdx_prot_error = ntohs(readw(streamer_mmio+LAPD)) >> 8; 1657 1658 /* Issue ARB Free */ 1659 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM); 1660 1661 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) & 1662 lan_status; 1663 1664 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR)) 1665 { 1666 if (lan_status_diff & LSC_LWF) 1667 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n", dev->name); 1668 if (lan_status_diff & LSC_ARW) 1669 printk(KERN_WARNING "%s: Auto removal error\n", dev->name); 1670 if (lan_status_diff & LSC_FPE) 1671 printk(KERN_WARNING "%s: FDX Protocol Error\n", dev->name); 1672 if (lan_status_diff & LSC_RR) 1673 printk(KERN_WARNING "%s: Force remove MAC frame received\n", dev->name); 1674 1675 /* Adapter has been closed by the hardware */ 1676 1677 /* reset tx/rx fifo's and busmaster logic */ 1678 1679 /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL); 1680 udelay(1); 1681 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */ 1682 1683 netif_stop_queue(dev); 1684 netif_carrier_off(dev); 1685 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name); 1686 } 1687 /* If serious error */ 1688 if (streamer_priv->streamer_message_level) { 1689 if (lan_status_diff & LSC_SIG_LOSS) 1690 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name); 1691 if (lan_status_diff & LSC_HARD_ERR) 1692 printk(KERN_INFO "%s: Beaconing \n", dev->name); 1693 if (lan_status_diff & LSC_SOFT_ERR) 1694 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n", dev->name); 1695 if (lan_status_diff & LSC_TRAN_BCN) 1696 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n", dev->name); 1697 if (lan_status_diff & LSC_SS) 1698 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name); 1699 if (lan_status_diff & LSC_RING_REC) 1700 printk(KERN_INFO "%s: Ring recovery ongoing\n", dev->name); 1701 if (lan_status_diff & LSC_FDX_MODE) 1702 printk(KERN_INFO "%s: Operating in FDX mode\n", dev->name); 1703 } 1704 1705 if (lan_status_diff & LSC_CO) { 1706 if (streamer_priv->streamer_message_level) 1707 printk(KERN_INFO "%s: Counter Overflow \n", dev->name); 1708 1709 /* Issue READ.LOG command */ 1710 1711 writew(streamer_priv->srb, streamer_mmio + LAPA); 1712 writew(htons(SRB_READ_LOG << 8),streamer_mmio+LAPDINC); 1713 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1714 writew(0, streamer_mmio + LAPDINC); 1715 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */ 1716 1717 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM); 1718 } 1719 1720 if (lan_status_diff & LSC_SR_CO) { 1721 if (streamer_priv->streamer_message_level) 1722 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name); 1723 1724 /* Issue a READ.SR.COUNTERS */ 1725 writew(streamer_priv->srb, streamer_mmio + LAPA); 1726 writew(htons(SRB_READ_SR_COUNTERS << 8), 1727 streamer_mmio+LAPDINC); 1728 writew(htons(STREAMER_CLEAR_RET_CODE << 8), 1729 streamer_mmio+LAPDINC); 1730 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */ 1731 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM); 1732 1733 } 1734 streamer_priv->streamer_lan_status = lan_status; 1735 } /* Lan.change.status */ 1736 else 1737 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name); 1738} 1739 1740static void streamer_asb_bh(struct net_device *dev) 1741{ 1742 struct streamer_private *streamer_priv = 1743 (struct streamer_private *) dev->priv; 1744 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1745 1746 if (streamer_priv->asb_queued == 1) 1747 { 1748 /* Dropped through the first time */ 1749 1750 writew(streamer_priv->asb, streamer_mmio + LAPA); 1751 writew(htons(ASB_RECEIVE_DATA << 8),streamer_mmio+LAPDINC); 1752 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC); 1753 writew(0, streamer_mmio + LAPDINC); 1754 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD); 1755 1756 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM); 1757 streamer_priv->asb_queued = 2; 1758 1759 return; 1760 } 1761 1762 if (streamer_priv->asb_queued == 2) { 1763 __u8 rc; 1764 writew(streamer_priv->asb + 2, streamer_mmio + LAPA); 1765 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8; 1766 switch (rc) { 1767 case 0x01: 1768 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name); 1769 break; 1770 case 0x26: 1771 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name); 1772 break; 1773 case 0xFF: 1774 /* Valid response, everything should be ok again */ 1775 break; 1776 default: 1777 printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name); 1778 break; 1779 } 1780 } 1781 streamer_priv->asb_queued = 0; 1782} 1783 1784static int streamer_change_mtu(struct net_device *dev, int mtu) 1785{ 1786 struct streamer_private *streamer_priv = 1787 (struct streamer_private *) dev->priv; 1788 __u16 max_mtu; 1789 1790 if (streamer_priv->streamer_ring_speed == 4) 1791 max_mtu = 4500; 1792 else 1793 max_mtu = 18000; 1794 1795 if (mtu > max_mtu) 1796 return -EINVAL; 1797 if (mtu < 100) 1798 return -EINVAL; 1799 1800 dev->mtu = mtu; 1801 streamer_priv->pkt_buf_sz = mtu + TR_HLEN; 1802 1803 return 0; 1804} 1805 1806#if STREAMER_NETWORK_MONITOR 1807#ifdef CONFIG_PROC_FS 1808static int streamer_proc_info(char *buffer, char **start, off_t offset, 1809 int length, int *eof, void *data) 1810{ 1811 struct streamer_private *sdev=NULL; 1812 struct pci_dev *pci_device = NULL; 1813 int len = 0; 1814 off_t begin = 0; 1815 off_t pos = 0; 1816 int size; 1817 1818 struct net_device *dev; 1819 1820 size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n"); 1821 1822 pos += size; 1823 len += size; 1824 1825 for(sdev=dev_streamer; sdev; sdev=sdev->next) { 1826 pci_device=sdev->pci_dev; 1827 dev=pci_get_drvdata(pci_device); 1828 1829 size = sprintf_info(buffer + len, dev); 1830 len += size; 1831 pos = begin + len; 1832 1833 if (pos < offset) { 1834 len = 0; 1835 begin = pos; 1836 } 1837 if (pos > offset + length) 1838 break; 1839 } /* for */ 1840 1841 *start = buffer + (offset - begin); /* Start of wanted data */ 1842 len -= (offset - begin); /* Start slop */ 1843 if (len > length) 1844 len = length; /* Ending slop */ 1845 return len; 1846} 1847 1848static int sprintf_info(char *buffer, struct net_device *dev) 1849{ 1850 struct streamer_private *streamer_priv = 1851 (struct streamer_private *) dev->priv; 1852 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio; 1853 struct streamer_adapter_addr_table sat; 1854 struct streamer_parameters_table spt; 1855 int size = 0; 1856 int i; 1857 1858 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA); 1859 for (i = 0; i < 14; i += 2) { 1860 __u16 io_word; 1861 __u8 *datap = (__u8 *) & sat; 1862 io_word=ntohs(readw(streamer_mmio+LAPDINC)); 1863 datap[size]=io_word >> 8; 1864 datap[size+1]=io_word & 0xff; 1865 } 1866 writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA); 1867 for (i = 0; i < 68; i += 2) { 1868 __u16 io_word; 1869 __u8 *datap = (__u8 *) & spt; 1870 io_word=ntohs(readw(streamer_mmio+LAPDINC)); 1871 datap[size]=io_word >> 8; 1872 datap[size+1]=io_word & 0xff; 1873 } 1874 1875 size = sprintf(buffer, "\n%6s: Adapter Address : Node Address : Functional Addr\n", dev->name); 1876 1877 size += sprintf(buffer + size, 1878 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x\n", 1879 dev->name, dev->dev_addr[0], dev->dev_addr[1], 1880 dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4], 1881 dev->dev_addr[5], sat.node_addr[0], sat.node_addr[1], 1882 sat.node_addr[2], sat.node_addr[3], sat.node_addr[4], 1883 sat.node_addr[5], sat.func_addr[0], sat.func_addr[1], 1884 sat.func_addr[2], sat.func_addr[3]); 1885 1886 size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name); 1887 1888 size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n", dev->name); 1889 1890 size += sprintf(buffer + size, 1891 "%6s: %02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x :\n", 1892 dev->name, spt.phys_addr[0], spt.phys_addr[1], 1893 spt.phys_addr[2], spt.phys_addr[3], 1894 spt.up_node_addr[0], spt.up_node_addr[1], 1895 spt.up_node_addr[2], spt.up_node_addr[3], 1896 spt.up_node_addr[4], spt.up_node_addr[4], 1897 spt.poll_addr[0], spt.poll_addr[1], spt.poll_addr[2], 1898 spt.poll_addr[3], spt.poll_addr[4], spt.poll_addr[5], 1899 ntohs(spt.acc_priority), ntohs(spt.auth_source_class), 1900 ntohs(spt.att_code)); 1901 1902 size += sprintf(buffer + size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name); 1903 1904 size += sprintf(buffer + size, 1905 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x : %04x : %04x : %04x : \n", 1906 dev->name, spt.source_addr[0], spt.source_addr[1], 1907 spt.source_addr[2], spt.source_addr[3], 1908 spt.source_addr[4], spt.source_addr[5], 1909 ntohs(spt.beacon_type), ntohs(spt.major_vector), 1910 ntohs(spt.lan_status), ntohs(spt.local_ring), 1911 ntohs(spt.mon_error), ntohs(spt.frame_correl)); 1912 1913 size += sprintf(buffer + size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n", 1914 dev->name); 1915 1916 size += sprintf(buffer + size, 1917 "%6s: : %02x : %02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x : \n", 1918 dev->name, ntohs(spt.beacon_transmit), 1919 ntohs(spt.beacon_receive), spt.beacon_naun[0], 1920 spt.beacon_naun[1], spt.beacon_naun[2], 1921 spt.beacon_naun[3], spt.beacon_naun[4], 1922 spt.beacon_naun[5], spt.beacon_phys[0], 1923 spt.beacon_phys[1], spt.beacon_phys[2], 1924 spt.beacon_phys[3]); 1925 return size; 1926} 1927#endif 1928#endif 1929 1930static struct pci_driver streamer_pci_driver = { 1931 .name = "lanstreamer", 1932 .id_table = streamer_pci_tbl, 1933 .probe = streamer_init_one, 1934 .remove = __devexit_p(streamer_remove_one), 1935}; 1936 1937static int __init streamer_init_module(void) { 1938 return pci_register_driver(&streamer_pci_driver); 1939} 1940 1941static void __exit streamer_cleanup_module(void) { 1942 pci_unregister_driver(&streamer_pci_driver); 1943} 1944 1945module_init(streamer_init_module); 1946module_exit(streamer_cleanup_module); 1947MODULE_LICENSE("GPL"); 1948