1/* 2 * File Name: 3 * skfddi.c 4 * 5 * Copyright Information: 6 * Copyright SysKonnect 1998,1999. 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * The information in this file is provided "AS IS" without warranty. 14 * 15 * Abstract: 16 * A Linux device driver supporting the SysKonnect FDDI PCI controller 17 * familie. 18 * 19 * Maintainers: 20 * CG Christoph Goos (cgoos@syskonnect.de) 21 * 22 * Contributors: 23 * DM David S. Miller 24 * 25 * Address all question to: 26 * linux@syskonnect.de 27 * 28 * The technical manual for the adapters is available from SysKonnect's 29 * web pages: www.syskonnect.com 30 * Goto "Support" and search Knowledge Base for "manual". 31 * 32 * Driver Architecture: 33 * The driver architecture is based on the DEC FDDI driver by 34 * Lawrence V. Stefani and several ethernet drivers. 35 * I also used an existing Windows NT miniport driver. 36 * All hardware dependent functions are handled by the SysKonnect 37 * Hardware Module. 38 * The only headerfiles that are directly related to this source 39 * are skfddi.c, h/types.h, h/osdef1st.h, h/targetos.h. 40 * The others belong to the SysKonnect FDDI Hardware Module and 41 * should better not be changed. 42 * 43 * Modification History: 44 * Date Name Description 45 * 02-Mar-98 CG Created. 46 * 47 * 10-Mar-99 CG Support for 2.2.x added. 48 * 25-Mar-99 CG Corrected IRQ routing for SMP (APIC) 49 * 26-Oct-99 CG Fixed compilation error on 2.2.13 50 * 12-Nov-99 CG Source code release 51 * 22-Nov-99 CG Included in kernel source. 52 * 07-May-00 DM 64 bit fixes, new dma interface 53 * 31-Jul-03 DB Audit copy_*_user in skfp_ioctl 54 * Daniele Bellucci <bellucda@tiscali.it> 55 * 03-Dec-03 SH Convert to PCI device model 56 * 57 * Compilation options (-Dxxx): 58 * DRIVERDEBUG print lots of messages to log file 59 * DUMPPACKETS print received/transmitted packets to logfile 60 * 61 * Tested cpu architectures: 62 * - i386 63 * - sparc64 64 */ 65 66/* Version information string - should be updated prior to */ 67/* each new release!!! */ 68#define VERSION "2.07" 69 70static const char * const boot_msg = 71 "SysKonnect FDDI PCI Adapter driver v" VERSION " for\n" 72 " SK-55xx/SK-58xx adapters (SK-NET FDDI-FP/UP/LP)"; 73 74/* Include files */ 75 76#include <linux/capability.h> 77#include <linux/module.h> 78#include <linux/kernel.h> 79#include <linux/errno.h> 80#include <linux/ioport.h> 81#include <linux/interrupt.h> 82#include <linux/pci.h> 83#include <linux/netdevice.h> 84#include <linux/fddidevice.h> 85#include <linux/skbuff.h> 86#include <linux/bitops.h> 87#include <linux/gfp.h> 88 89#include <asm/byteorder.h> 90#include <asm/io.h> 91#include <asm/uaccess.h> 92 93#include "h/types.h" 94#undef ADDR // undo Linux definition 95#include "h/skfbi.h" 96#include "h/fddi.h" 97#include "h/smc.h" 98#include "h/smtstate.h" 99 100 101// Define module-wide (static) routines 102static int skfp_driver_init(struct net_device *dev); 103static int skfp_open(struct net_device *dev); 104static int skfp_close(struct net_device *dev); 105static irqreturn_t skfp_interrupt(int irq, void *dev_id); 106static struct net_device_stats *skfp_ctl_get_stats(struct net_device *dev); 107static void skfp_ctl_set_multicast_list(struct net_device *dev); 108static void skfp_ctl_set_multicast_list_wo_lock(struct net_device *dev); 109static int skfp_ctl_set_mac_address(struct net_device *dev, void *addr); 110static int skfp_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 111static netdev_tx_t skfp_send_pkt(struct sk_buff *skb, 112 struct net_device *dev); 113static void send_queued_packets(struct s_smc *smc); 114static void CheckSourceAddress(unsigned char *frame, unsigned char *hw_addr); 115static void ResetAdapter(struct s_smc *smc); 116 117 118// Functions needed by the hardware module 119void *mac_drv_get_space(struct s_smc *smc, u_int size); 120void *mac_drv_get_desc_mem(struct s_smc *smc, u_int size); 121unsigned long mac_drv_virt2phys(struct s_smc *smc, void *virt); 122unsigned long dma_master(struct s_smc *smc, void *virt, int len, int flag); 123void dma_complete(struct s_smc *smc, volatile union s_fp_descr *descr, 124 int flag); 125void mac_drv_tx_complete(struct s_smc *smc, volatile struct s_smt_fp_txd *txd); 126void llc_restart_tx(struct s_smc *smc); 127void mac_drv_rx_complete(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 128 int frag_count, int len); 129void mac_drv_requeue_rxd(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 130 int frag_count); 131void mac_drv_fill_rxd(struct s_smc *smc); 132void mac_drv_clear_rxd(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 133 int frag_count); 134int mac_drv_rx_init(struct s_smc *smc, int len, int fc, char *look_ahead, 135 int la_len); 136void dump_data(unsigned char *Data, int length); 137 138// External functions from the hardware module 139extern u_int mac_drv_check_space(void); 140extern int mac_drv_init(struct s_smc *smc); 141extern void hwm_tx_frag(struct s_smc *smc, char far * virt, u_long phys, 142 int len, int frame_status); 143extern int hwm_tx_init(struct s_smc *smc, u_char fc, int frag_count, 144 int frame_len, int frame_status); 145extern void fddi_isr(struct s_smc *smc); 146extern void hwm_rx_frag(struct s_smc *smc, char far * virt, u_long phys, 147 int len, int frame_status); 148extern void mac_drv_rx_mode(struct s_smc *smc, int mode); 149extern void mac_drv_clear_rx_queue(struct s_smc *smc); 150extern void enable_tx_irq(struct s_smc *smc, u_short queue); 151 152static DEFINE_PCI_DEVICE_TABLE(skfddi_pci_tbl) = { 153 { PCI_VENDOR_ID_SK, PCI_DEVICE_ID_SK_FP, PCI_ANY_ID, PCI_ANY_ID, }, 154 { } /* Terminating entry */ 155}; 156MODULE_DEVICE_TABLE(pci, skfddi_pci_tbl); 157MODULE_LICENSE("GPL"); 158MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>"); 159 160// Define module-wide (static) variables 161 162static int num_boards; /* total number of adapters configured */ 163 164static const struct net_device_ops skfp_netdev_ops = { 165 .ndo_open = skfp_open, 166 .ndo_stop = skfp_close, 167 .ndo_start_xmit = skfp_send_pkt, 168 .ndo_get_stats = skfp_ctl_get_stats, 169 .ndo_change_mtu = fddi_change_mtu, 170 .ndo_set_rx_mode = skfp_ctl_set_multicast_list, 171 .ndo_set_mac_address = skfp_ctl_set_mac_address, 172 .ndo_do_ioctl = skfp_ioctl, 173}; 174 175/* 176 * ================= 177 * = skfp_init_one = 178 * ================= 179 * 180 * Overview: 181 * Probes for supported FDDI PCI controllers 182 * 183 * Returns: 184 * Condition code 185 * 186 * Arguments: 187 * pdev - pointer to PCI device information 188 * 189 * Functional Description: 190 * This is now called by PCI driver registration process 191 * for each board found. 192 * 193 * Return Codes: 194 * 0 - This device (fddi0, fddi1, etc) configured successfully 195 * -ENODEV - No devices present, or no SysKonnect FDDI PCI device 196 * present for this device name 197 * 198 * 199 * Side Effects: 200 * Device structures for FDDI adapters (fddi0, fddi1, etc) are 201 * initialized and the board resources are read and stored in 202 * the device structure. 203 */ 204static int skfp_init_one(struct pci_dev *pdev, 205 const struct pci_device_id *ent) 206{ 207 struct net_device *dev; 208 struct s_smc *smc; /* board pointer */ 209 void __iomem *mem; 210 int err; 211 212 pr_debug("entering skfp_init_one\n"); 213 214 if (num_boards == 0) 215 printk("%s\n", boot_msg); 216 217 err = pci_enable_device(pdev); 218 if (err) 219 return err; 220 221 err = pci_request_regions(pdev, "skfddi"); 222 if (err) 223 goto err_out1; 224 225 pci_set_master(pdev); 226 227#ifdef MEM_MAPPED_IO 228 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 229 printk(KERN_ERR "skfp: region is not an MMIO resource\n"); 230 err = -EIO; 231 goto err_out2; 232 } 233 234 mem = ioremap(pci_resource_start(pdev, 0), 0x4000); 235#else 236 if (!(pci_resource_flags(pdev, 1) & IO_RESOURCE_IO)) { 237 printk(KERN_ERR "skfp: region is not PIO resource\n"); 238 err = -EIO; 239 goto err_out2; 240 } 241 242 mem = ioport_map(pci_resource_start(pdev, 1), FP_IO_LEN); 243#endif 244 if (!mem) { 245 printk(KERN_ERR "skfp: Unable to map register, " 246 "FDDI adapter will be disabled.\n"); 247 err = -EIO; 248 goto err_out2; 249 } 250 251 dev = alloc_fddidev(sizeof(struct s_smc)); 252 if (!dev) { 253 printk(KERN_ERR "skfp: Unable to allocate fddi device, " 254 "FDDI adapter will be disabled.\n"); 255 err = -ENOMEM; 256 goto err_out3; 257 } 258 259 dev->irq = pdev->irq; 260 dev->netdev_ops = &skfp_netdev_ops; 261 262 SET_NETDEV_DEV(dev, &pdev->dev); 263 264 /* Initialize board structure with bus-specific info */ 265 smc = netdev_priv(dev); 266 smc->os.dev = dev; 267 smc->os.bus_type = SK_BUS_TYPE_PCI; 268 smc->os.pdev = *pdev; 269 smc->os.QueueSkb = MAX_TX_QUEUE_LEN; 270 smc->os.MaxFrameSize = MAX_FRAME_SIZE; 271 smc->os.dev = dev; 272 smc->hw.slot = -1; 273 smc->hw.iop = mem; 274 smc->os.ResetRequested = FALSE; 275 skb_queue_head_init(&smc->os.SendSkbQueue); 276 277 dev->base_addr = (unsigned long)mem; 278 279 err = skfp_driver_init(dev); 280 if (err) 281 goto err_out4; 282 283 err = register_netdev(dev); 284 if (err) 285 goto err_out5; 286 287 ++num_boards; 288 pci_set_drvdata(pdev, dev); 289 290 if ((pdev->subsystem_device & 0xff00) == 0x5500 || 291 (pdev->subsystem_device & 0xff00) == 0x5800) 292 printk("%s: SysKonnect FDDI PCI adapter" 293 " found (SK-%04X)\n", dev->name, 294 pdev->subsystem_device); 295 else 296 printk("%s: FDDI PCI adapter found\n", dev->name); 297 298 return 0; 299err_out5: 300 if (smc->os.SharedMemAddr) 301 pci_free_consistent(pdev, smc->os.SharedMemSize, 302 smc->os.SharedMemAddr, 303 smc->os.SharedMemDMA); 304 pci_free_consistent(pdev, MAX_FRAME_SIZE, 305 smc->os.LocalRxBuffer, smc->os.LocalRxBufferDMA); 306err_out4: 307 free_netdev(dev); 308err_out3: 309#ifdef MEM_MAPPED_IO 310 iounmap(mem); 311#else 312 ioport_unmap(mem); 313#endif 314err_out2: 315 pci_release_regions(pdev); 316err_out1: 317 pci_disable_device(pdev); 318 return err; 319} 320 321/* 322 * Called for each adapter board from pci_unregister_driver 323 */ 324static void __devexit skfp_remove_one(struct pci_dev *pdev) 325{ 326 struct net_device *p = pci_get_drvdata(pdev); 327 struct s_smc *lp = netdev_priv(p); 328 329 unregister_netdev(p); 330 331 if (lp->os.SharedMemAddr) { 332 pci_free_consistent(&lp->os.pdev, 333 lp->os.SharedMemSize, 334 lp->os.SharedMemAddr, 335 lp->os.SharedMemDMA); 336 lp->os.SharedMemAddr = NULL; 337 } 338 if (lp->os.LocalRxBuffer) { 339 pci_free_consistent(&lp->os.pdev, 340 MAX_FRAME_SIZE, 341 lp->os.LocalRxBuffer, 342 lp->os.LocalRxBufferDMA); 343 lp->os.LocalRxBuffer = NULL; 344 } 345#ifdef MEM_MAPPED_IO 346 iounmap(lp->hw.iop); 347#else 348 ioport_unmap(lp->hw.iop); 349#endif 350 pci_release_regions(pdev); 351 free_netdev(p); 352 353 pci_disable_device(pdev); 354 pci_set_drvdata(pdev, NULL); 355} 356 357/* 358 * ==================== 359 * = skfp_driver_init = 360 * ==================== 361 * 362 * Overview: 363 * Initializes remaining adapter board structure information 364 * and makes sure adapter is in a safe state prior to skfp_open(). 365 * 366 * Returns: 367 * Condition code 368 * 369 * Arguments: 370 * dev - pointer to device information 371 * 372 * Functional Description: 373 * This function allocates additional resources such as the host memory 374 * blocks needed by the adapter. 375 * The adapter is also reset. The OS must call skfp_open() to open 376 * the adapter and bring it on-line. 377 * 378 * Return Codes: 379 * 0 - initialization succeeded 380 * -1 - initialization failed 381 */ 382static int skfp_driver_init(struct net_device *dev) 383{ 384 struct s_smc *smc = netdev_priv(dev); 385 skfddi_priv *bp = &smc->os; 386 int err = -EIO; 387 388 pr_debug("entering skfp_driver_init\n"); 389 390 // set the io address in private structures 391 bp->base_addr = dev->base_addr; 392 393 // Get the interrupt level from the PCI Configuration Table 394 smc->hw.irq = dev->irq; 395 396 spin_lock_init(&bp->DriverLock); 397 398 // Allocate invalid frame 399 bp->LocalRxBuffer = pci_alloc_consistent(&bp->pdev, MAX_FRAME_SIZE, &bp->LocalRxBufferDMA); 400 if (!bp->LocalRxBuffer) { 401 printk("could not allocate mem for "); 402 printk("LocalRxBuffer: %d byte\n", MAX_FRAME_SIZE); 403 goto fail; 404 } 405 406 // Determine the required size of the 'shared' memory area. 407 bp->SharedMemSize = mac_drv_check_space(); 408 pr_debug("Memory for HWM: %ld\n", bp->SharedMemSize); 409 if (bp->SharedMemSize > 0) { 410 bp->SharedMemSize += 16; // for descriptor alignment 411 412 bp->SharedMemAddr = pci_alloc_consistent(&bp->pdev, 413 bp->SharedMemSize, 414 &bp->SharedMemDMA); 415 if (!bp->SharedMemAddr) { 416 printk("could not allocate mem for "); 417 printk("hardware module: %ld byte\n", 418 bp->SharedMemSize); 419 goto fail; 420 } 421 bp->SharedMemHeap = 0; // Nothing used yet. 422 423 } else { 424 bp->SharedMemAddr = NULL; 425 bp->SharedMemHeap = 0; 426 } // SharedMemSize > 0 427 428 memset(bp->SharedMemAddr, 0, bp->SharedMemSize); 429 430 card_stop(smc); // Reset adapter. 431 432 pr_debug("mac_drv_init()..\n"); 433 if (mac_drv_init(smc) != 0) { 434 pr_debug("mac_drv_init() failed\n"); 435 goto fail; 436 } 437 read_address(smc, NULL); 438 pr_debug("HW-Addr: %pMF\n", smc->hw.fddi_canon_addr.a); 439 memcpy(dev->dev_addr, smc->hw.fddi_canon_addr.a, 6); 440 441 smt_reset_defaults(smc, 0); 442 443 return 0; 444 445fail: 446 if (bp->SharedMemAddr) { 447 pci_free_consistent(&bp->pdev, 448 bp->SharedMemSize, 449 bp->SharedMemAddr, 450 bp->SharedMemDMA); 451 bp->SharedMemAddr = NULL; 452 } 453 if (bp->LocalRxBuffer) { 454 pci_free_consistent(&bp->pdev, MAX_FRAME_SIZE, 455 bp->LocalRxBuffer, bp->LocalRxBufferDMA); 456 bp->LocalRxBuffer = NULL; 457 } 458 return err; 459} // skfp_driver_init 460 461 462/* 463 * ============= 464 * = skfp_open = 465 * ============= 466 * 467 * Overview: 468 * Opens the adapter 469 * 470 * Returns: 471 * Condition code 472 * 473 * Arguments: 474 * dev - pointer to device information 475 * 476 * Functional Description: 477 * This function brings the adapter to an operational state. 478 * 479 * Return Codes: 480 * 0 - Adapter was successfully opened 481 * -EAGAIN - Could not register IRQ 482 */ 483static int skfp_open(struct net_device *dev) 484{ 485 struct s_smc *smc = netdev_priv(dev); 486 int err; 487 488 pr_debug("entering skfp_open\n"); 489 /* Register IRQ - support shared interrupts by passing device ptr */ 490 err = request_irq(dev->irq, skfp_interrupt, IRQF_SHARED, 491 dev->name, dev); 492 if (err) 493 return err; 494 495 /* 496 * Set current address to factory MAC address 497 * 498 * Note: We've already done this step in skfp_driver_init. 499 * However, it's possible that a user has set a node 500 * address override, then closed and reopened the 501 * adapter. Unless we reset the device address field 502 * now, we'll continue to use the existing modified 503 * address. 504 */ 505 read_address(smc, NULL); 506 memcpy(dev->dev_addr, smc->hw.fddi_canon_addr.a, 6); 507 508 init_smt(smc, NULL); 509 smt_online(smc, 1); 510 STI_FBI(); 511 512 /* Clear local multicast address tables */ 513 mac_clear_multicast(smc); 514 515 /* Disable promiscuous filter settings */ 516 mac_drv_rx_mode(smc, RX_DISABLE_PROMISC); 517 518 netif_start_queue(dev); 519 return 0; 520} // skfp_open 521 522 523/* 524 * ============== 525 * = skfp_close = 526 * ============== 527 * 528 * Overview: 529 * Closes the device/module. 530 * 531 * Returns: 532 * Condition code 533 * 534 * Arguments: 535 * dev - pointer to device information 536 * 537 * Functional Description: 538 * This routine closes the adapter and brings it to a safe state. 539 * The interrupt service routine is deregistered with the OS. 540 * The adapter can be opened again with another call to skfp_open(). 541 * 542 * Return Codes: 543 * Always return 0. 544 * 545 * Assumptions: 546 * No further requests for this adapter are made after this routine is 547 * called. skfp_open() can be called to reset and reinitialize the 548 * adapter. 549 */ 550static int skfp_close(struct net_device *dev) 551{ 552 struct s_smc *smc = netdev_priv(dev); 553 skfddi_priv *bp = &smc->os; 554 555 CLI_FBI(); 556 smt_reset_defaults(smc, 1); 557 card_stop(smc); 558 mac_drv_clear_tx_queue(smc); 559 mac_drv_clear_rx_queue(smc); 560 561 netif_stop_queue(dev); 562 /* Deregister (free) IRQ */ 563 free_irq(dev->irq, dev); 564 565 skb_queue_purge(&bp->SendSkbQueue); 566 bp->QueueSkb = MAX_TX_QUEUE_LEN; 567 568 return 0; 569} // skfp_close 570 571 572/* 573 * ================== 574 * = skfp_interrupt = 575 * ================== 576 * 577 * Overview: 578 * Interrupt processing routine 579 * 580 * Returns: 581 * None 582 * 583 * Arguments: 584 * irq - interrupt vector 585 * dev_id - pointer to device information 586 * 587 * Functional Description: 588 * This routine calls the interrupt processing routine for this adapter. It 589 * disables and reenables adapter interrupts, as appropriate. We can support 590 * shared interrupts since the incoming dev_id pointer provides our device 591 * structure context. All the real work is done in the hardware module. 592 * 593 * Return Codes: 594 * None 595 * 596 * Assumptions: 597 * The interrupt acknowledgement at the hardware level (eg. ACKing the PIC 598 * on Intel-based systems) is done by the operating system outside this 599 * routine. 600 * 601 * System interrupts are enabled through this call. 602 * 603 * Side Effects: 604 * Interrupts are disabled, then reenabled at the adapter. 605 */ 606 607static irqreturn_t skfp_interrupt(int irq, void *dev_id) 608{ 609 struct net_device *dev = dev_id; 610 struct s_smc *smc; /* private board structure pointer */ 611 skfddi_priv *bp; 612 613 smc = netdev_priv(dev); 614 bp = &smc->os; 615 616 // IRQs enabled or disabled ? 617 if (inpd(ADDR(B0_IMSK)) == 0) { 618 // IRQs are disabled: must be shared interrupt 619 return IRQ_NONE; 620 } 621 // Note: At this point, IRQs are enabled. 622 if ((inpd(ISR_A) & smc->hw.is_imask) == 0) { // IRQ? 623 // Adapter did not issue an IRQ: must be shared interrupt 624 return IRQ_NONE; 625 } 626 CLI_FBI(); // Disable IRQs from our adapter. 627 spin_lock(&bp->DriverLock); 628 629 // Call interrupt handler in hardware module (HWM). 630 fddi_isr(smc); 631 632 if (smc->os.ResetRequested) { 633 ResetAdapter(smc); 634 smc->os.ResetRequested = FALSE; 635 } 636 spin_unlock(&bp->DriverLock); 637 STI_FBI(); // Enable IRQs from our adapter. 638 639 return IRQ_HANDLED; 640} // skfp_interrupt 641 642 643/* 644 * ====================== 645 * = skfp_ctl_get_stats = 646 * ====================== 647 * 648 * Overview: 649 * Get statistics for FDDI adapter 650 * 651 * Returns: 652 * Pointer to FDDI statistics structure 653 * 654 * Arguments: 655 * dev - pointer to device information 656 * 657 * Functional Description: 658 * Gets current MIB objects from adapter, then 659 * returns FDDI statistics structure as defined 660 * in if_fddi.h. 661 * 662 * Note: Since the FDDI statistics structure is 663 * still new and the device structure doesn't 664 * have an FDDI-specific get statistics handler, 665 * we'll return the FDDI statistics structure as 666 * a pointer to an Ethernet statistics structure. 667 * That way, at least the first part of the statistics 668 * structure can be decoded properly. 669 * We'll have to pay attention to this routine as the 670 * device structure becomes more mature and LAN media 671 * independent. 672 * 673 */ 674static struct net_device_stats *skfp_ctl_get_stats(struct net_device *dev) 675{ 676 struct s_smc *bp = netdev_priv(dev); 677 678 /* Fill the bp->stats structure with driver-maintained counters */ 679 680 bp->os.MacStat.port_bs_flag[0] = 0x1234; 681 bp->os.MacStat.port_bs_flag[1] = 0x5678; 682// goos: need to fill out fddi statistic 683#if 0 684 /* Get FDDI SMT MIB objects */ 685 686/* Fill the bp->stats structure with the SMT MIB object values */ 687 688 memcpy(bp->stats.smt_station_id, &bp->cmd_rsp_virt->smt_mib_get.smt_station_id, sizeof(bp->cmd_rsp_virt->smt_mib_get.smt_station_id)); 689 bp->stats.smt_op_version_id = bp->cmd_rsp_virt->smt_mib_get.smt_op_version_id; 690 bp->stats.smt_hi_version_id = bp->cmd_rsp_virt->smt_mib_get.smt_hi_version_id; 691 bp->stats.smt_lo_version_id = bp->cmd_rsp_virt->smt_mib_get.smt_lo_version_id; 692 memcpy(bp->stats.smt_user_data, &bp->cmd_rsp_virt->smt_mib_get.smt_user_data, sizeof(bp->cmd_rsp_virt->smt_mib_get.smt_user_data)); 693 bp->stats.smt_mib_version_id = bp->cmd_rsp_virt->smt_mib_get.smt_mib_version_id; 694 bp->stats.smt_mac_cts = bp->cmd_rsp_virt->smt_mib_get.smt_mac_ct; 695 bp->stats.smt_non_master_cts = bp->cmd_rsp_virt->smt_mib_get.smt_non_master_ct; 696 bp->stats.smt_master_cts = bp->cmd_rsp_virt->smt_mib_get.smt_master_ct; 697 bp->stats.smt_available_paths = bp->cmd_rsp_virt->smt_mib_get.smt_available_paths; 698 bp->stats.smt_config_capabilities = bp->cmd_rsp_virt->smt_mib_get.smt_config_capabilities; 699 bp->stats.smt_config_policy = bp->cmd_rsp_virt->smt_mib_get.smt_config_policy; 700 bp->stats.smt_connection_policy = bp->cmd_rsp_virt->smt_mib_get.smt_connection_policy; 701 bp->stats.smt_t_notify = bp->cmd_rsp_virt->smt_mib_get.smt_t_notify; 702 bp->stats.smt_stat_rpt_policy = bp->cmd_rsp_virt->smt_mib_get.smt_stat_rpt_policy; 703 bp->stats.smt_trace_max_expiration = bp->cmd_rsp_virt->smt_mib_get.smt_trace_max_expiration; 704 bp->stats.smt_bypass_present = bp->cmd_rsp_virt->smt_mib_get.smt_bypass_present; 705 bp->stats.smt_ecm_state = bp->cmd_rsp_virt->smt_mib_get.smt_ecm_state; 706 bp->stats.smt_cf_state = bp->cmd_rsp_virt->smt_mib_get.smt_cf_state; 707 bp->stats.smt_remote_disconnect_flag = bp->cmd_rsp_virt->smt_mib_get.smt_remote_disconnect_flag; 708 bp->stats.smt_station_status = bp->cmd_rsp_virt->smt_mib_get.smt_station_status; 709 bp->stats.smt_peer_wrap_flag = bp->cmd_rsp_virt->smt_mib_get.smt_peer_wrap_flag; 710 bp->stats.smt_time_stamp = bp->cmd_rsp_virt->smt_mib_get.smt_msg_time_stamp.ls; 711 bp->stats.smt_transition_time_stamp = bp->cmd_rsp_virt->smt_mib_get.smt_transition_time_stamp.ls; 712 bp->stats.mac_frame_status_functions = bp->cmd_rsp_virt->smt_mib_get.mac_frame_status_functions; 713 bp->stats.mac_t_max_capability = bp->cmd_rsp_virt->smt_mib_get.mac_t_max_capability; 714 bp->stats.mac_tvx_capability = bp->cmd_rsp_virt->smt_mib_get.mac_tvx_capability; 715 bp->stats.mac_available_paths = bp->cmd_rsp_virt->smt_mib_get.mac_available_paths; 716 bp->stats.mac_current_path = bp->cmd_rsp_virt->smt_mib_get.mac_current_path; 717 memcpy(bp->stats.mac_upstream_nbr, &bp->cmd_rsp_virt->smt_mib_get.mac_upstream_nbr, FDDI_K_ALEN); 718 memcpy(bp->stats.mac_downstream_nbr, &bp->cmd_rsp_virt->smt_mib_get.mac_downstream_nbr, FDDI_K_ALEN); 719 memcpy(bp->stats.mac_old_upstream_nbr, &bp->cmd_rsp_virt->smt_mib_get.mac_old_upstream_nbr, FDDI_K_ALEN); 720 memcpy(bp->stats.mac_old_downstream_nbr, &bp->cmd_rsp_virt->smt_mib_get.mac_old_downstream_nbr, FDDI_K_ALEN); 721 bp->stats.mac_dup_address_test = bp->cmd_rsp_virt->smt_mib_get.mac_dup_address_test; 722 bp->stats.mac_requested_paths = bp->cmd_rsp_virt->smt_mib_get.mac_requested_paths; 723 bp->stats.mac_downstream_port_type = bp->cmd_rsp_virt->smt_mib_get.mac_downstream_port_type; 724 memcpy(bp->stats.mac_smt_address, &bp->cmd_rsp_virt->smt_mib_get.mac_smt_address, FDDI_K_ALEN); 725 bp->stats.mac_t_req = bp->cmd_rsp_virt->smt_mib_get.mac_t_req; 726 bp->stats.mac_t_neg = bp->cmd_rsp_virt->smt_mib_get.mac_t_neg; 727 bp->stats.mac_t_max = bp->cmd_rsp_virt->smt_mib_get.mac_t_max; 728 bp->stats.mac_tvx_value = bp->cmd_rsp_virt->smt_mib_get.mac_tvx_value; 729 bp->stats.mac_frame_error_threshold = bp->cmd_rsp_virt->smt_mib_get.mac_frame_error_threshold; 730 bp->stats.mac_frame_error_ratio = bp->cmd_rsp_virt->smt_mib_get.mac_frame_error_ratio; 731 bp->stats.mac_rmt_state = bp->cmd_rsp_virt->smt_mib_get.mac_rmt_state; 732 bp->stats.mac_da_flag = bp->cmd_rsp_virt->smt_mib_get.mac_da_flag; 733 bp->stats.mac_una_da_flag = bp->cmd_rsp_virt->smt_mib_get.mac_unda_flag; 734 bp->stats.mac_frame_error_flag = bp->cmd_rsp_virt->smt_mib_get.mac_frame_error_flag; 735 bp->stats.mac_ma_unitdata_available = bp->cmd_rsp_virt->smt_mib_get.mac_ma_unitdata_available; 736 bp->stats.mac_hardware_present = bp->cmd_rsp_virt->smt_mib_get.mac_hardware_present; 737 bp->stats.mac_ma_unitdata_enable = bp->cmd_rsp_virt->smt_mib_get.mac_ma_unitdata_enable; 738 bp->stats.path_tvx_lower_bound = bp->cmd_rsp_virt->smt_mib_get.path_tvx_lower_bound; 739 bp->stats.path_t_max_lower_bound = bp->cmd_rsp_virt->smt_mib_get.path_t_max_lower_bound; 740 bp->stats.path_max_t_req = bp->cmd_rsp_virt->smt_mib_get.path_max_t_req; 741 memcpy(bp->stats.path_configuration, &bp->cmd_rsp_virt->smt_mib_get.path_configuration, sizeof(bp->cmd_rsp_virt->smt_mib_get.path_configuration)); 742 bp->stats.port_my_type[0] = bp->cmd_rsp_virt->smt_mib_get.port_my_type[0]; 743 bp->stats.port_my_type[1] = bp->cmd_rsp_virt->smt_mib_get.port_my_type[1]; 744 bp->stats.port_neighbor_type[0] = bp->cmd_rsp_virt->smt_mib_get.port_neighbor_type[0]; 745 bp->stats.port_neighbor_type[1] = bp->cmd_rsp_virt->smt_mib_get.port_neighbor_type[1]; 746 bp->stats.port_connection_policies[0] = bp->cmd_rsp_virt->smt_mib_get.port_connection_policies[0]; 747 bp->stats.port_connection_policies[1] = bp->cmd_rsp_virt->smt_mib_get.port_connection_policies[1]; 748 bp->stats.port_mac_indicated[0] = bp->cmd_rsp_virt->smt_mib_get.port_mac_indicated[0]; 749 bp->stats.port_mac_indicated[1] = bp->cmd_rsp_virt->smt_mib_get.port_mac_indicated[1]; 750 bp->stats.port_current_path[0] = bp->cmd_rsp_virt->smt_mib_get.port_current_path[0]; 751 bp->stats.port_current_path[1] = bp->cmd_rsp_virt->smt_mib_get.port_current_path[1]; 752 memcpy(&bp->stats.port_requested_paths[0 * 3], &bp->cmd_rsp_virt->smt_mib_get.port_requested_paths[0], 3); 753 memcpy(&bp->stats.port_requested_paths[1 * 3], &bp->cmd_rsp_virt->smt_mib_get.port_requested_paths[1], 3); 754 bp->stats.port_mac_placement[0] = bp->cmd_rsp_virt->smt_mib_get.port_mac_placement[0]; 755 bp->stats.port_mac_placement[1] = bp->cmd_rsp_virt->smt_mib_get.port_mac_placement[1]; 756 bp->stats.port_available_paths[0] = bp->cmd_rsp_virt->smt_mib_get.port_available_paths[0]; 757 bp->stats.port_available_paths[1] = bp->cmd_rsp_virt->smt_mib_get.port_available_paths[1]; 758 bp->stats.port_pmd_class[0] = bp->cmd_rsp_virt->smt_mib_get.port_pmd_class[0]; 759 bp->stats.port_pmd_class[1] = bp->cmd_rsp_virt->smt_mib_get.port_pmd_class[1]; 760 bp->stats.port_connection_capabilities[0] = bp->cmd_rsp_virt->smt_mib_get.port_connection_capabilities[0]; 761 bp->stats.port_connection_capabilities[1] = bp->cmd_rsp_virt->smt_mib_get.port_connection_capabilities[1]; 762 bp->stats.port_bs_flag[0] = bp->cmd_rsp_virt->smt_mib_get.port_bs_flag[0]; 763 bp->stats.port_bs_flag[1] = bp->cmd_rsp_virt->smt_mib_get.port_bs_flag[1]; 764 bp->stats.port_ler_estimate[0] = bp->cmd_rsp_virt->smt_mib_get.port_ler_estimate[0]; 765 bp->stats.port_ler_estimate[1] = bp->cmd_rsp_virt->smt_mib_get.port_ler_estimate[1]; 766 bp->stats.port_ler_cutoff[0] = bp->cmd_rsp_virt->smt_mib_get.port_ler_cutoff[0]; 767 bp->stats.port_ler_cutoff[1] = bp->cmd_rsp_virt->smt_mib_get.port_ler_cutoff[1]; 768 bp->stats.port_ler_alarm[0] = bp->cmd_rsp_virt->smt_mib_get.port_ler_alarm[0]; 769 bp->stats.port_ler_alarm[1] = bp->cmd_rsp_virt->smt_mib_get.port_ler_alarm[1]; 770 bp->stats.port_connect_state[0] = bp->cmd_rsp_virt->smt_mib_get.port_connect_state[0]; 771 bp->stats.port_connect_state[1] = bp->cmd_rsp_virt->smt_mib_get.port_connect_state[1]; 772 bp->stats.port_pcm_state[0] = bp->cmd_rsp_virt->smt_mib_get.port_pcm_state[0]; 773 bp->stats.port_pcm_state[1] = bp->cmd_rsp_virt->smt_mib_get.port_pcm_state[1]; 774 bp->stats.port_pc_withhold[0] = bp->cmd_rsp_virt->smt_mib_get.port_pc_withhold[0]; 775 bp->stats.port_pc_withhold[1] = bp->cmd_rsp_virt->smt_mib_get.port_pc_withhold[1]; 776 bp->stats.port_ler_flag[0] = bp->cmd_rsp_virt->smt_mib_get.port_ler_flag[0]; 777 bp->stats.port_ler_flag[1] = bp->cmd_rsp_virt->smt_mib_get.port_ler_flag[1]; 778 bp->stats.port_hardware_present[0] = bp->cmd_rsp_virt->smt_mib_get.port_hardware_present[0]; 779 bp->stats.port_hardware_present[1] = bp->cmd_rsp_virt->smt_mib_get.port_hardware_present[1]; 780 781 782 /* Fill the bp->stats structure with the FDDI counter values */ 783 784 bp->stats.mac_frame_cts = bp->cmd_rsp_virt->cntrs_get.cntrs.frame_cnt.ls; 785 bp->stats.mac_copied_cts = bp->cmd_rsp_virt->cntrs_get.cntrs.copied_cnt.ls; 786 bp->stats.mac_transmit_cts = bp->cmd_rsp_virt->cntrs_get.cntrs.transmit_cnt.ls; 787 bp->stats.mac_error_cts = bp->cmd_rsp_virt->cntrs_get.cntrs.error_cnt.ls; 788 bp->stats.mac_lost_cts = bp->cmd_rsp_virt->cntrs_get.cntrs.lost_cnt.ls; 789 bp->stats.port_lct_fail_cts[0] = bp->cmd_rsp_virt->cntrs_get.cntrs.lct_rejects[0].ls; 790 bp->stats.port_lct_fail_cts[1] = bp->cmd_rsp_virt->cntrs_get.cntrs.lct_rejects[1].ls; 791 bp->stats.port_lem_reject_cts[0] = bp->cmd_rsp_virt->cntrs_get.cntrs.lem_rejects[0].ls; 792 bp->stats.port_lem_reject_cts[1] = bp->cmd_rsp_virt->cntrs_get.cntrs.lem_rejects[1].ls; 793 bp->stats.port_lem_cts[0] = bp->cmd_rsp_virt->cntrs_get.cntrs.link_errors[0].ls; 794 bp->stats.port_lem_cts[1] = bp->cmd_rsp_virt->cntrs_get.cntrs.link_errors[1].ls; 795 796#endif 797 return (struct net_device_stats *)&bp->os.MacStat; 798} // ctl_get_stat 799 800 801/* 802 * ============================== 803 * = skfp_ctl_set_multicast_list = 804 * ============================== 805 * 806 * Overview: 807 * Enable/Disable LLC frame promiscuous mode reception 808 * on the adapter and/or update multicast address table. 809 * 810 * Returns: 811 * None 812 * 813 * Arguments: 814 * dev - pointer to device information 815 * 816 * Functional Description: 817 * This function acquires the driver lock and only calls 818 * skfp_ctl_set_multicast_list_wo_lock then. 819 * This routine follows a fairly simple algorithm for setting the 820 * adapter filters and CAM: 821 * 822 * if IFF_PROMISC flag is set 823 * enable promiscuous mode 824 * else 825 * disable promiscuous mode 826 * if number of multicast addresses <= max. multicast number 827 * add mc addresses to adapter table 828 * else 829 * enable promiscuous mode 830 * update adapter filters 831 * 832 * Assumptions: 833 * Multicast addresses are presented in canonical (LSB) format. 834 * 835 * Side Effects: 836 * On-board adapter filters are updated. 837 */ 838static void skfp_ctl_set_multicast_list(struct net_device *dev) 839{ 840 struct s_smc *smc = netdev_priv(dev); 841 skfddi_priv *bp = &smc->os; 842 unsigned long Flags; 843 844 spin_lock_irqsave(&bp->DriverLock, Flags); 845 skfp_ctl_set_multicast_list_wo_lock(dev); 846 spin_unlock_irqrestore(&bp->DriverLock, Flags); 847} // skfp_ctl_set_multicast_list 848 849 850 851static void skfp_ctl_set_multicast_list_wo_lock(struct net_device *dev) 852{ 853 struct s_smc *smc = netdev_priv(dev); 854 struct netdev_hw_addr *ha; 855 856 /* Enable promiscuous mode, if necessary */ 857 if (dev->flags & IFF_PROMISC) { 858 mac_drv_rx_mode(smc, RX_ENABLE_PROMISC); 859 pr_debug("PROMISCUOUS MODE ENABLED\n"); 860 } 861 /* Else, update multicast address table */ 862 else { 863 mac_drv_rx_mode(smc, RX_DISABLE_PROMISC); 864 pr_debug("PROMISCUOUS MODE DISABLED\n"); 865 866 // Reset all MC addresses 867 mac_clear_multicast(smc); 868 mac_drv_rx_mode(smc, RX_DISABLE_ALLMULTI); 869 870 if (dev->flags & IFF_ALLMULTI) { 871 mac_drv_rx_mode(smc, RX_ENABLE_ALLMULTI); 872 pr_debug("ENABLE ALL MC ADDRESSES\n"); 873 } else if (!netdev_mc_empty(dev)) { 874 if (netdev_mc_count(dev) <= FPMAX_MULTICAST) { 875 /* use exact filtering */ 876 877 // point to first multicast addr 878 netdev_for_each_mc_addr(ha, dev) { 879 mac_add_multicast(smc, 880 (struct fddi_addr *)ha->addr, 881 1); 882 883 pr_debug("ENABLE MC ADDRESS: %pMF\n", 884 ha->addr); 885 } 886 887 } else { // more MC addresses than HW supports 888 889 mac_drv_rx_mode(smc, RX_ENABLE_ALLMULTI); 890 pr_debug("ENABLE ALL MC ADDRESSES\n"); 891 } 892 } else { // no MC addresses 893 894 pr_debug("DISABLE ALL MC ADDRESSES\n"); 895 } 896 897 /* Update adapter filters */ 898 mac_update_multicast(smc); 899 } 900} // skfp_ctl_set_multicast_list_wo_lock 901 902 903/* 904 * =========================== 905 * = skfp_ctl_set_mac_address = 906 * =========================== 907 * 908 * Overview: 909 * set new mac address on adapter and update dev_addr field in device table. 910 * 911 * Returns: 912 * None 913 * 914 * Arguments: 915 * dev - pointer to device information 916 * addr - pointer to sockaddr structure containing unicast address to set 917 * 918 * Assumptions: 919 * The address pointed to by addr->sa_data is a valid unicast 920 * address and is presented in canonical (LSB) format. 921 */ 922static int skfp_ctl_set_mac_address(struct net_device *dev, void *addr) 923{ 924 struct s_smc *smc = netdev_priv(dev); 925 struct sockaddr *p_sockaddr = (struct sockaddr *) addr; 926 skfddi_priv *bp = &smc->os; 927 unsigned long Flags; 928 929 930 memcpy(dev->dev_addr, p_sockaddr->sa_data, FDDI_K_ALEN); 931 spin_lock_irqsave(&bp->DriverLock, Flags); 932 ResetAdapter(smc); 933 spin_unlock_irqrestore(&bp->DriverLock, Flags); 934 935 return 0; /* always return zero */ 936} // skfp_ctl_set_mac_address 937 938 939/* 940 * ============== 941 * = skfp_ioctl = 942 * ============== 943 * 944 * Overview: 945 * 946 * Perform IOCTL call functions here. Some are privileged operations and the 947 * effective uid is checked in those cases. 948 * 949 * Returns: 950 * status value 951 * 0 - success 952 * other - failure 953 * 954 * Arguments: 955 * dev - pointer to device information 956 * rq - pointer to ioctl request structure 957 * cmd - ? 958 * 959 */ 960 961 962static int skfp_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 963{ 964 struct s_smc *smc = netdev_priv(dev); 965 skfddi_priv *lp = &smc->os; 966 struct s_skfp_ioctl ioc; 967 int status = 0; 968 969 if (copy_from_user(&ioc, rq->ifr_data, sizeof(struct s_skfp_ioctl))) 970 return -EFAULT; 971 972 switch (ioc.cmd) { 973 case SKFP_GET_STATS: /* Get the driver statistics */ 974 ioc.len = sizeof(lp->MacStat); 975 status = copy_to_user(ioc.data, skfp_ctl_get_stats(dev), ioc.len) 976 ? -EFAULT : 0; 977 break; 978 case SKFP_CLR_STATS: /* Zero out the driver statistics */ 979 if (!capable(CAP_NET_ADMIN)) { 980 status = -EPERM; 981 } else { 982 memset(&lp->MacStat, 0, sizeof(lp->MacStat)); 983 } 984 break; 985 default: 986 printk("ioctl for %s: unknown cmd: %04x\n", dev->name, ioc.cmd); 987 status = -EOPNOTSUPP; 988 989 } // switch 990 991 return status; 992} // skfp_ioctl 993 994 995/* 996 * ===================== 997 * = skfp_send_pkt = 998 * ===================== 999 * 1000 * Overview: 1001 * Queues a packet for transmission and try to transmit it. 1002 * 1003 * Returns: 1004 * Condition code 1005 * 1006 * Arguments: 1007 * skb - pointer to sk_buff to queue for transmission 1008 * dev - pointer to device information 1009 * 1010 * Functional Description: 1011 * Here we assume that an incoming skb transmit request 1012 * is contained in a single physically contiguous buffer 1013 * in which the virtual address of the start of packet 1014 * (skb->data) can be converted to a physical address 1015 * by using pci_map_single(). 1016 * 1017 * We have an internal queue for packets we can not send 1018 * immediately. Packets in this queue can be given to the 1019 * adapter if transmit buffers are freed. 1020 * 1021 * We can't free the skb until after it's been DMA'd 1022 * out by the adapter, so we'll keep it in the driver and 1023 * return it in mac_drv_tx_complete. 1024 * 1025 * Return Codes: 1026 * 0 - driver has queued and/or sent packet 1027 * 1 - caller should requeue the sk_buff for later transmission 1028 * 1029 * Assumptions: 1030 * The entire packet is stored in one physically 1031 * contiguous buffer which is not cached and whose 1032 * 32-bit physical address can be determined. 1033 * 1034 * It's vital that this routine is NOT reentered for the 1035 * same board and that the OS is not in another section of 1036 * code (eg. skfp_interrupt) for the same board on a 1037 * different thread. 1038 * 1039 * Side Effects: 1040 * None 1041 */ 1042static netdev_tx_t skfp_send_pkt(struct sk_buff *skb, 1043 struct net_device *dev) 1044{ 1045 struct s_smc *smc = netdev_priv(dev); 1046 skfddi_priv *bp = &smc->os; 1047 1048 pr_debug("skfp_send_pkt\n"); 1049 1050 /* 1051 * Verify that incoming transmit request is OK 1052 * 1053 * Note: The packet size check is consistent with other 1054 * Linux device drivers, although the correct packet 1055 * size should be verified before calling the 1056 * transmit routine. 1057 */ 1058 1059 if (!(skb->len >= FDDI_K_LLC_ZLEN && skb->len <= FDDI_K_LLC_LEN)) { 1060 bp->MacStat.gen.tx_errors++; /* bump error counter */ 1061 // dequeue packets from xmt queue and send them 1062 netif_start_queue(dev); 1063 dev_kfree_skb(skb); 1064 return NETDEV_TX_OK; /* return "success" */ 1065 } 1066 if (bp->QueueSkb == 0) { // return with tbusy set: queue full 1067 1068 netif_stop_queue(dev); 1069 return NETDEV_TX_BUSY; 1070 } 1071 bp->QueueSkb--; 1072 skb_queue_tail(&bp->SendSkbQueue, skb); 1073 send_queued_packets(netdev_priv(dev)); 1074 if (bp->QueueSkb == 0) { 1075 netif_stop_queue(dev); 1076 } 1077 return NETDEV_TX_OK; 1078 1079} // skfp_send_pkt 1080 1081 1082/* 1083 * ======================= 1084 * = send_queued_packets = 1085 * ======================= 1086 * 1087 * Overview: 1088 * Send packets from the driver queue as long as there are some and 1089 * transmit resources are available. 1090 * 1091 * Returns: 1092 * None 1093 * 1094 * Arguments: 1095 * smc - pointer to smc (adapter) structure 1096 * 1097 * Functional Description: 1098 * Take a packet from queue if there is any. If not, then we are done. 1099 * Check if there are resources to send the packet. If not, requeue it 1100 * and exit. 1101 * Set packet descriptor flags and give packet to adapter. 1102 * Check if any send resources can be freed (we do not use the 1103 * transmit complete interrupt). 1104 */ 1105static void send_queued_packets(struct s_smc *smc) 1106{ 1107 skfddi_priv *bp = &smc->os; 1108 struct sk_buff *skb; 1109 unsigned char fc; 1110 int queue; 1111 struct s_smt_fp_txd *txd; // Current TxD. 1112 dma_addr_t dma_address; 1113 unsigned long Flags; 1114 1115 int frame_status; // HWM tx frame status. 1116 1117 pr_debug("send queued packets\n"); 1118 for (;;) { 1119 // send first buffer from queue 1120 skb = skb_dequeue(&bp->SendSkbQueue); 1121 1122 if (!skb) { 1123 pr_debug("queue empty\n"); 1124 return; 1125 } // queue empty ! 1126 1127 spin_lock_irqsave(&bp->DriverLock, Flags); 1128 fc = skb->data[0]; 1129 queue = (fc & FC_SYNC_BIT) ? QUEUE_S : QUEUE_A0; 1130#ifdef ESS 1131 // Check if the frame may/must be sent as a synchronous frame. 1132 1133 if ((fc & ~(FC_SYNC_BIT | FC_LLC_PRIOR)) == FC_ASYNC_LLC) { 1134 // It's an LLC frame. 1135 if (!smc->ess.sync_bw_available) 1136 fc &= ~FC_SYNC_BIT; // No bandwidth available. 1137 1138 else { // Bandwidth is available. 1139 1140 if (smc->mib.fddiESSSynchTxMode) { 1141 // Send as sync. frame. 1142 fc |= FC_SYNC_BIT; 1143 } 1144 } 1145 } 1146#endif // ESS 1147 frame_status = hwm_tx_init(smc, fc, 1, skb->len, queue); 1148 1149 if ((frame_status & (LOC_TX | LAN_TX)) == 0) { 1150 // Unable to send the frame. 1151 1152 if ((frame_status & RING_DOWN) != 0) { 1153 // Ring is down. 1154 pr_debug("Tx attempt while ring down.\n"); 1155 } else if ((frame_status & OUT_OF_TXD) != 0) { 1156 pr_debug("%s: out of TXDs.\n", bp->dev->name); 1157 } else { 1158 pr_debug("%s: out of transmit resources", 1159 bp->dev->name); 1160 } 1161 1162 // Note: We will retry the operation as soon as 1163 // transmit resources become available. 1164 skb_queue_head(&bp->SendSkbQueue, skb); 1165 spin_unlock_irqrestore(&bp->DriverLock, Flags); 1166 return; // Packet has been queued. 1167 1168 } // if (unable to send frame) 1169 1170 bp->QueueSkb++; // one packet less in local queue 1171 1172 // source address in packet ? 1173 CheckSourceAddress(skb->data, smc->hw.fddi_canon_addr.a); 1174 1175 txd = (struct s_smt_fp_txd *) HWM_GET_CURR_TXD(smc, queue); 1176 1177 dma_address = pci_map_single(&bp->pdev, skb->data, 1178 skb->len, PCI_DMA_TODEVICE); 1179 if (frame_status & LAN_TX) { 1180 txd->txd_os.skb = skb; // save skb 1181 txd->txd_os.dma_addr = dma_address; // save dma mapping 1182 } 1183 hwm_tx_frag(smc, skb->data, dma_address, skb->len, 1184 frame_status | FIRST_FRAG | LAST_FRAG | EN_IRQ_EOF); 1185 1186 if (!(frame_status & LAN_TX)) { // local only frame 1187 pci_unmap_single(&bp->pdev, dma_address, 1188 skb->len, PCI_DMA_TODEVICE); 1189 dev_kfree_skb_irq(skb); 1190 } 1191 spin_unlock_irqrestore(&bp->DriverLock, Flags); 1192 } // for 1193 1194 return; // never reached 1195 1196} // send_queued_packets 1197 1198 1199/************************ 1200 * 1201 * CheckSourceAddress 1202 * 1203 * Verify if the source address is set. Insert it if necessary. 1204 * 1205 ************************/ 1206static void CheckSourceAddress(unsigned char *frame, unsigned char *hw_addr) 1207{ 1208 unsigned char SRBit; 1209 1210 if ((((unsigned long) frame[1 + 6]) & ~0x01) != 0) // source routing bit 1211 1212 return; 1213 if ((unsigned short) frame[1 + 10] != 0) 1214 return; 1215 SRBit = frame[1 + 6] & 0x01; 1216 memcpy(&frame[1 + 6], hw_addr, 6); 1217 frame[8] |= SRBit; 1218} // CheckSourceAddress 1219 1220 1221/************************ 1222 * 1223 * ResetAdapter 1224 * 1225 * Reset the adapter and bring it back to operational mode. 1226 * Args 1227 * smc - A pointer to the SMT context struct. 1228 * Out 1229 * Nothing. 1230 * 1231 ************************/ 1232static void ResetAdapter(struct s_smc *smc) 1233{ 1234 1235 pr_debug("[fddi: ResetAdapter]\n"); 1236 1237 // Stop the adapter. 1238 1239 card_stop(smc); // Stop all activity. 1240 1241 // Clear the transmit and receive descriptor queues. 1242 mac_drv_clear_tx_queue(smc); 1243 mac_drv_clear_rx_queue(smc); 1244 1245 // Restart the adapter. 1246 1247 smt_reset_defaults(smc, 1); // Initialize the SMT module. 1248 1249 init_smt(smc, (smc->os.dev)->dev_addr); // Initialize the hardware. 1250 1251 smt_online(smc, 1); // Insert into the ring again. 1252 STI_FBI(); 1253 1254 // Restore original receive mode (multicasts, promiscuous, etc.). 1255 skfp_ctl_set_multicast_list_wo_lock(smc->os.dev); 1256} // ResetAdapter 1257 1258 1259//--------------- functions called by hardware module ---------------- 1260 1261/************************ 1262 * 1263 * llc_restart_tx 1264 * 1265 * The hardware driver calls this routine when the transmit complete 1266 * interrupt bits (end of frame) for the synchronous or asynchronous 1267 * queue is set. 1268 * 1269 * NOTE The hardware driver calls this function also if no packets are queued. 1270 * The routine must be able to handle this case. 1271 * Args 1272 * smc - A pointer to the SMT context struct. 1273 * Out 1274 * Nothing. 1275 * 1276 ************************/ 1277void llc_restart_tx(struct s_smc *smc) 1278{ 1279 skfddi_priv *bp = &smc->os; 1280 1281 pr_debug("[llc_restart_tx]\n"); 1282 1283 // Try to send queued packets 1284 spin_unlock(&bp->DriverLock); 1285 send_queued_packets(smc); 1286 spin_lock(&bp->DriverLock); 1287 netif_start_queue(bp->dev);// system may send again if it was blocked 1288 1289} // llc_restart_tx 1290 1291 1292/************************ 1293 * 1294 * mac_drv_get_space 1295 * 1296 * The hardware module calls this function to allocate the memory 1297 * for the SMT MBufs if the define MB_OUTSIDE_SMC is specified. 1298 * Args 1299 * smc - A pointer to the SMT context struct. 1300 * 1301 * size - Size of memory in bytes to allocate. 1302 * Out 1303 * != 0 A pointer to the virtual address of the allocated memory. 1304 * == 0 Allocation error. 1305 * 1306 ************************/ 1307void *mac_drv_get_space(struct s_smc *smc, unsigned int size) 1308{ 1309 void *virt; 1310 1311 pr_debug("mac_drv_get_space (%d bytes), ", size); 1312 virt = (void *) (smc->os.SharedMemAddr + smc->os.SharedMemHeap); 1313 1314 if ((smc->os.SharedMemHeap + size) > smc->os.SharedMemSize) { 1315 printk("Unexpected SMT memory size requested: %d\n", size); 1316 return NULL; 1317 } 1318 smc->os.SharedMemHeap += size; // Move heap pointer. 1319 1320 pr_debug("mac_drv_get_space end\n"); 1321 pr_debug("virt addr: %lx\n", (ulong) virt); 1322 pr_debug("bus addr: %lx\n", (ulong) 1323 (smc->os.SharedMemDMA + 1324 ((char *) virt - (char *)smc->os.SharedMemAddr))); 1325 return virt; 1326} // mac_drv_get_space 1327 1328 1329/************************ 1330 * 1331 * mac_drv_get_desc_mem 1332 * 1333 * This function is called by the hardware dependent module. 1334 * It allocates the memory for the RxD and TxD descriptors. 1335 * 1336 * This memory must be non-cached, non-movable and non-swappable. 1337 * This memory should start at a physical page boundary. 1338 * Args 1339 * smc - A pointer to the SMT context struct. 1340 * 1341 * size - Size of memory in bytes to allocate. 1342 * Out 1343 * != 0 A pointer to the virtual address of the allocated memory. 1344 * == 0 Allocation error. 1345 * 1346 ************************/ 1347void *mac_drv_get_desc_mem(struct s_smc *smc, unsigned int size) 1348{ 1349 1350 char *virt; 1351 1352 pr_debug("mac_drv_get_desc_mem\n"); 1353 1354 // Descriptor memory must be aligned on 16-byte boundary. 1355 1356 virt = mac_drv_get_space(smc, size); 1357 1358 size = (u_int) (16 - (((unsigned long) virt) & 15UL)); 1359 size = size % 16; 1360 1361 pr_debug("Allocate %u bytes alignment gap ", size); 1362 pr_debug("for descriptor memory.\n"); 1363 1364 if (!mac_drv_get_space(smc, size)) { 1365 printk("fddi: Unable to align descriptor memory.\n"); 1366 return NULL; 1367 } 1368 return virt + size; 1369} // mac_drv_get_desc_mem 1370 1371 1372/************************ 1373 * 1374 * mac_drv_virt2phys 1375 * 1376 * Get the physical address of a given virtual address. 1377 * Args 1378 * smc - A pointer to the SMT context struct. 1379 * 1380 * virt - A (virtual) pointer into our 'shared' memory area. 1381 * Out 1382 * Physical address of the given virtual address. 1383 * 1384 ************************/ 1385unsigned long mac_drv_virt2phys(struct s_smc *smc, void *virt) 1386{ 1387 return smc->os.SharedMemDMA + 1388 ((char *) virt - (char *)smc->os.SharedMemAddr); 1389} // mac_drv_virt2phys 1390 1391 1392/************************ 1393 * 1394 * dma_master 1395 * 1396 * The HWM calls this function, when the driver leads through a DMA 1397 * transfer. If the OS-specific module must prepare the system hardware 1398 * for the DMA transfer, it should do it in this function. 1399 * 1400 * The hardware module calls this dma_master if it wants to send an SMT 1401 * frame. This means that the virt address passed in here is part of 1402 * the 'shared' memory area. 1403 * Args 1404 * smc - A pointer to the SMT context struct. 1405 * 1406 * virt - The virtual address of the data. 1407 * 1408 * len - The length in bytes of the data. 1409 * 1410 * flag - Indicates the transmit direction and the buffer type: 1411 * DMA_RD (0x01) system RAM ==> adapter buffer memory 1412 * DMA_WR (0x02) adapter buffer memory ==> system RAM 1413 * SMT_BUF (0x80) SMT buffer 1414 * 1415 * >> NOTE: SMT_BUF and DMA_RD are always set for PCI. << 1416 * Out 1417 * Returns the pyhsical address for the DMA transfer. 1418 * 1419 ************************/ 1420u_long dma_master(struct s_smc * smc, void *virt, int len, int flag) 1421{ 1422 return smc->os.SharedMemDMA + 1423 ((char *) virt - (char *)smc->os.SharedMemAddr); 1424} // dma_master 1425 1426 1427/************************ 1428 * 1429 * dma_complete 1430 * 1431 * The hardware module calls this routine when it has completed a DMA 1432 * transfer. If the operating system dependent module has set up the DMA 1433 * channel via dma_master() (e.g. Windows NT or AIX) it should clean up 1434 * the DMA channel. 1435 * Args 1436 * smc - A pointer to the SMT context struct. 1437 * 1438 * descr - A pointer to a TxD or RxD, respectively. 1439 * 1440 * flag - Indicates the DMA transfer direction / SMT buffer: 1441 * DMA_RD (0x01) system RAM ==> adapter buffer memory 1442 * DMA_WR (0x02) adapter buffer memory ==> system RAM 1443 * SMT_BUF (0x80) SMT buffer (managed by HWM) 1444 * Out 1445 * Nothing. 1446 * 1447 ************************/ 1448void dma_complete(struct s_smc *smc, volatile union s_fp_descr *descr, int flag) 1449{ 1450 /* For TX buffers, there are two cases. If it is an SMT transmit 1451 * buffer, there is nothing to do since we use consistent memory 1452 * for the 'shared' memory area. The other case is for normal 1453 * transmit packets given to us by the networking stack, and in 1454 * that case we cleanup the PCI DMA mapping in mac_drv_tx_complete 1455 * below. 1456 * 1457 * For RX buffers, we have to unmap dynamic PCI DMA mappings here 1458 * because the hardware module is about to potentially look at 1459 * the contents of the buffer. If we did not call the PCI DMA 1460 * unmap first, the hardware module could read inconsistent data. 1461 */ 1462 if (flag & DMA_WR) { 1463 skfddi_priv *bp = &smc->os; 1464 volatile struct s_smt_fp_rxd *r = &descr->r; 1465 1466 /* If SKB is NULL, we used the local buffer. */ 1467 if (r->rxd_os.skb && r->rxd_os.dma_addr) { 1468 int MaxFrameSize = bp->MaxFrameSize; 1469 1470 pci_unmap_single(&bp->pdev, r->rxd_os.dma_addr, 1471 MaxFrameSize, PCI_DMA_FROMDEVICE); 1472 r->rxd_os.dma_addr = 0; 1473 } 1474 } 1475} // dma_complete 1476 1477 1478/************************ 1479 * 1480 * mac_drv_tx_complete 1481 * 1482 * Transmit of a packet is complete. Release the tx staging buffer. 1483 * 1484 * Args 1485 * smc - A pointer to the SMT context struct. 1486 * 1487 * txd - A pointer to the last TxD which is used by the frame. 1488 * Out 1489 * Returns nothing. 1490 * 1491 ************************/ 1492void mac_drv_tx_complete(struct s_smc *smc, volatile struct s_smt_fp_txd *txd) 1493{ 1494 struct sk_buff *skb; 1495 1496 pr_debug("entering mac_drv_tx_complete\n"); 1497 // Check if this TxD points to a skb 1498 1499 if (!(skb = txd->txd_os.skb)) { 1500 pr_debug("TXD with no skb assigned.\n"); 1501 return; 1502 } 1503 txd->txd_os.skb = NULL; 1504 1505 // release the DMA mapping 1506 pci_unmap_single(&smc->os.pdev, txd->txd_os.dma_addr, 1507 skb->len, PCI_DMA_TODEVICE); 1508 txd->txd_os.dma_addr = 0; 1509 1510 smc->os.MacStat.gen.tx_packets++; // Count transmitted packets. 1511 smc->os.MacStat.gen.tx_bytes+=skb->len; // Count bytes 1512 1513 // free the skb 1514 dev_kfree_skb_irq(skb); 1515 1516 pr_debug("leaving mac_drv_tx_complete\n"); 1517} // mac_drv_tx_complete 1518 1519 1520/************************ 1521 * 1522 * dump packets to logfile 1523 * 1524 ************************/ 1525#ifdef DUMPPACKETS 1526void dump_data(unsigned char *Data, int length) 1527{ 1528 int i, j; 1529 unsigned char s[255], sh[10]; 1530 if (length > 64) { 1531 length = 64; 1532 } 1533 printk(KERN_INFO "---Packet start---\n"); 1534 for (i = 0, j = 0; i < length / 8; i++, j += 8) 1535 printk(KERN_INFO "%02x %02x %02x %02x %02x %02x %02x %02x\n", 1536 Data[j + 0], Data[j + 1], Data[j + 2], Data[j + 3], 1537 Data[j + 4], Data[j + 5], Data[j + 6], Data[j + 7]); 1538 strcpy(s, ""); 1539 for (i = 0; i < length % 8; i++) { 1540 sprintf(sh, "%02x ", Data[j + i]); 1541 strcat(s, sh); 1542 } 1543 printk(KERN_INFO "%s\n", s); 1544 printk(KERN_INFO "------------------\n"); 1545} // dump_data 1546#else 1547#define dump_data(data,len) 1548#endif // DUMPPACKETS 1549 1550/************************ 1551 * 1552 * mac_drv_rx_complete 1553 * 1554 * The hardware module calls this function if an LLC frame is received 1555 * in a receive buffer. Also the SMT, NSA, and directed beacon frames 1556 * from the network will be passed to the LLC layer by this function 1557 * if passing is enabled. 1558 * 1559 * mac_drv_rx_complete forwards the frame to the LLC layer if it should 1560 * be received. It also fills the RxD ring with new receive buffers if 1561 * some can be queued. 1562 * Args 1563 * smc - A pointer to the SMT context struct. 1564 * 1565 * rxd - A pointer to the first RxD which is used by the receive frame. 1566 * 1567 * frag_count - Count of RxDs used by the received frame. 1568 * 1569 * len - Frame length. 1570 * Out 1571 * Nothing. 1572 * 1573 ************************/ 1574void mac_drv_rx_complete(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 1575 int frag_count, int len) 1576{ 1577 skfddi_priv *bp = &smc->os; 1578 struct sk_buff *skb; 1579 unsigned char *virt, *cp; 1580 unsigned short ri; 1581 u_int RifLength; 1582 1583 pr_debug("entering mac_drv_rx_complete (len=%d)\n", len); 1584 if (frag_count != 1) { // This is not allowed to happen. 1585 1586 printk("fddi: Multi-fragment receive!\n"); 1587 goto RequeueRxd; // Re-use the given RXD(s). 1588 1589 } 1590 skb = rxd->rxd_os.skb; 1591 if (!skb) { 1592 pr_debug("No skb in rxd\n"); 1593 smc->os.MacStat.gen.rx_errors++; 1594 goto RequeueRxd; 1595 } 1596 virt = skb->data; 1597 1598 // The DMA mapping was released in dma_complete above. 1599 1600 dump_data(skb->data, len); 1601 1602 /* 1603 * FDDI Frame format: 1604 * +-------+-------+-------+------------+--------+------------+ 1605 * | FC[1] | DA[6] | SA[6] | RIF[0..18] | LLC[3] | Data[0..n] | 1606 * +-------+-------+-------+------------+--------+------------+ 1607 * 1608 * FC = Frame Control 1609 * DA = Destination Address 1610 * SA = Source Address 1611 * RIF = Routing Information Field 1612 * LLC = Logical Link Control 1613 */ 1614 1615 // Remove Routing Information Field (RIF), if present. 1616 1617 if ((virt[1 + 6] & FDDI_RII) == 0) 1618 RifLength = 0; 1619 else { 1620 int n; 1621// goos: RIF removal has still to be tested 1622 pr_debug("RIF found\n"); 1623 // Get RIF length from Routing Control (RC) field. 1624 cp = virt + FDDI_MAC_HDR_LEN; // Point behind MAC header. 1625 1626 ri = ntohs(*((__be16 *) cp)); 1627 RifLength = ri & FDDI_RCF_LEN_MASK; 1628 if (len < (int) (FDDI_MAC_HDR_LEN + RifLength)) { 1629 printk("fddi: Invalid RIF.\n"); 1630 goto RequeueRxd; // Discard the frame. 1631 1632 } 1633 virt[1 + 6] &= ~FDDI_RII; // Clear RII bit. 1634 // regions overlap 1635 1636 virt = cp + RifLength; 1637 for (n = FDDI_MAC_HDR_LEN; n; n--) 1638 *--virt = *--cp; 1639 // adjust sbd->data pointer 1640 skb_pull(skb, RifLength); 1641 len -= RifLength; 1642 RifLength = 0; 1643 } 1644 1645 // Count statistics. 1646 smc->os.MacStat.gen.rx_packets++; // Count indicated receive 1647 // packets. 1648 smc->os.MacStat.gen.rx_bytes+=len; // Count bytes. 1649 1650 // virt points to header again 1651 if (virt[1] & 0x01) { // Check group (multicast) bit. 1652 1653 smc->os.MacStat.gen.multicast++; 1654 } 1655 1656 // deliver frame to system 1657 rxd->rxd_os.skb = NULL; 1658 skb_trim(skb, len); 1659 skb->protocol = fddi_type_trans(skb, bp->dev); 1660 1661 netif_rx(skb); 1662 1663 HWM_RX_CHECK(smc, RX_LOW_WATERMARK); 1664 return; 1665 1666 RequeueRxd: 1667 pr_debug("Rx: re-queue RXD.\n"); 1668 mac_drv_requeue_rxd(smc, rxd, frag_count); 1669 smc->os.MacStat.gen.rx_errors++; // Count receive packets 1670 // not indicated. 1671 1672} // mac_drv_rx_complete 1673 1674 1675/************************ 1676 * 1677 * mac_drv_requeue_rxd 1678 * 1679 * The hardware module calls this function to request the OS-specific 1680 * module to queue the receive buffer(s) represented by the pointer 1681 * to the RxD and the frag_count into the receive queue again. This 1682 * buffer was filled with an invalid frame or an SMT frame. 1683 * Args 1684 * smc - A pointer to the SMT context struct. 1685 * 1686 * rxd - A pointer to the first RxD which is used by the receive frame. 1687 * 1688 * frag_count - Count of RxDs used by the received frame. 1689 * Out 1690 * Nothing. 1691 * 1692 ************************/ 1693void mac_drv_requeue_rxd(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 1694 int frag_count) 1695{ 1696 volatile struct s_smt_fp_rxd *next_rxd; 1697 volatile struct s_smt_fp_rxd *src_rxd; 1698 struct sk_buff *skb; 1699 int MaxFrameSize; 1700 unsigned char *v_addr; 1701 dma_addr_t b_addr; 1702 1703 if (frag_count != 1) // This is not allowed to happen. 1704 1705 printk("fddi: Multi-fragment requeue!\n"); 1706 1707 MaxFrameSize = smc->os.MaxFrameSize; 1708 src_rxd = rxd; 1709 for (; frag_count > 0; frag_count--) { 1710 next_rxd = src_rxd->rxd_next; 1711 rxd = HWM_GET_CURR_RXD(smc); 1712 1713 skb = src_rxd->rxd_os.skb; 1714 if (skb == NULL) { // this should not happen 1715 1716 pr_debug("Requeue with no skb in rxd!\n"); 1717 skb = alloc_skb(MaxFrameSize + 3, GFP_ATOMIC); 1718 if (skb) { 1719 // we got a skb 1720 rxd->rxd_os.skb = skb; 1721 skb_reserve(skb, 3); 1722 skb_put(skb, MaxFrameSize); 1723 v_addr = skb->data; 1724 b_addr = pci_map_single(&smc->os.pdev, 1725 v_addr, 1726 MaxFrameSize, 1727 PCI_DMA_FROMDEVICE); 1728 rxd->rxd_os.dma_addr = b_addr; 1729 } else { 1730 // no skb available, use local buffer 1731 pr_debug("Queueing invalid buffer!\n"); 1732 rxd->rxd_os.skb = NULL; 1733 v_addr = smc->os.LocalRxBuffer; 1734 b_addr = smc->os.LocalRxBufferDMA; 1735 } 1736 } else { 1737 // we use skb from old rxd 1738 rxd->rxd_os.skb = skb; 1739 v_addr = skb->data; 1740 b_addr = pci_map_single(&smc->os.pdev, 1741 v_addr, 1742 MaxFrameSize, 1743 PCI_DMA_FROMDEVICE); 1744 rxd->rxd_os.dma_addr = b_addr; 1745 } 1746 hwm_rx_frag(smc, v_addr, b_addr, MaxFrameSize, 1747 FIRST_FRAG | LAST_FRAG); 1748 1749 src_rxd = next_rxd; 1750 } 1751} // mac_drv_requeue_rxd 1752 1753 1754/************************ 1755 * 1756 * mac_drv_fill_rxd 1757 * 1758 * The hardware module calls this function at initialization time 1759 * to fill the RxD ring with receive buffers. It is also called by 1760 * mac_drv_rx_complete if rx_free is large enough to queue some new 1761 * receive buffers into the RxD ring. mac_drv_fill_rxd queues new 1762 * receive buffers as long as enough RxDs and receive buffers are 1763 * available. 1764 * Args 1765 * smc - A pointer to the SMT context struct. 1766 * Out 1767 * Nothing. 1768 * 1769 ************************/ 1770void mac_drv_fill_rxd(struct s_smc *smc) 1771{ 1772 int MaxFrameSize; 1773 unsigned char *v_addr; 1774 unsigned long b_addr; 1775 struct sk_buff *skb; 1776 volatile struct s_smt_fp_rxd *rxd; 1777 1778 pr_debug("entering mac_drv_fill_rxd\n"); 1779 1780 // Walk through the list of free receive buffers, passing receive 1781 // buffers to the HWM as long as RXDs are available. 1782 1783 MaxFrameSize = smc->os.MaxFrameSize; 1784 // Check if there is any RXD left. 1785 while (HWM_GET_RX_FREE(smc) > 0) { 1786 pr_debug(".\n"); 1787 1788 rxd = HWM_GET_CURR_RXD(smc); 1789 skb = alloc_skb(MaxFrameSize + 3, GFP_ATOMIC); 1790 if (skb) { 1791 // we got a skb 1792 skb_reserve(skb, 3); 1793 skb_put(skb, MaxFrameSize); 1794 v_addr = skb->data; 1795 b_addr = pci_map_single(&smc->os.pdev, 1796 v_addr, 1797 MaxFrameSize, 1798 PCI_DMA_FROMDEVICE); 1799 rxd->rxd_os.dma_addr = b_addr; 1800 } else { 1801 // no skb available, use local buffer 1802 // System has run out of buffer memory, but we want to 1803 // keep the receiver running in hope of better times. 1804 // Multiple descriptors may point to this local buffer, 1805 // so data in it must be considered invalid. 1806 pr_debug("Queueing invalid buffer!\n"); 1807 v_addr = smc->os.LocalRxBuffer; 1808 b_addr = smc->os.LocalRxBufferDMA; 1809 } 1810 1811 rxd->rxd_os.skb = skb; 1812 1813 // Pass receive buffer to HWM. 1814 hwm_rx_frag(smc, v_addr, b_addr, MaxFrameSize, 1815 FIRST_FRAG | LAST_FRAG); 1816 } 1817 pr_debug("leaving mac_drv_fill_rxd\n"); 1818} // mac_drv_fill_rxd 1819 1820 1821/************************ 1822 * 1823 * mac_drv_clear_rxd 1824 * 1825 * The hardware module calls this function to release unused 1826 * receive buffers. 1827 * Args 1828 * smc - A pointer to the SMT context struct. 1829 * 1830 * rxd - A pointer to the first RxD which is used by the receive buffer. 1831 * 1832 * frag_count - Count of RxDs used by the receive buffer. 1833 * Out 1834 * Nothing. 1835 * 1836 ************************/ 1837void mac_drv_clear_rxd(struct s_smc *smc, volatile struct s_smt_fp_rxd *rxd, 1838 int frag_count) 1839{ 1840 1841 struct sk_buff *skb; 1842 1843 pr_debug("entering mac_drv_clear_rxd\n"); 1844 1845 if (frag_count != 1) // This is not allowed to happen. 1846 1847 printk("fddi: Multi-fragment clear!\n"); 1848 1849 for (; frag_count > 0; frag_count--) { 1850 skb = rxd->rxd_os.skb; 1851 if (skb != NULL) { 1852 skfddi_priv *bp = &smc->os; 1853 int MaxFrameSize = bp->MaxFrameSize; 1854 1855 pci_unmap_single(&bp->pdev, rxd->rxd_os.dma_addr, 1856 MaxFrameSize, PCI_DMA_FROMDEVICE); 1857 1858 dev_kfree_skb(skb); 1859 rxd->rxd_os.skb = NULL; 1860 } 1861 rxd = rxd->rxd_next; // Next RXD. 1862 1863 } 1864} // mac_drv_clear_rxd 1865 1866 1867/************************ 1868 * 1869 * mac_drv_rx_init 1870 * 1871 * The hardware module calls this routine when an SMT or NSA frame of the 1872 * local SMT should be delivered to the LLC layer. 1873 * 1874 * It is necessary to have this function, because there is no other way to 1875 * copy the contents of SMT MBufs into receive buffers. 1876 * 1877 * mac_drv_rx_init allocates the required target memory for this frame, 1878 * and receives the frame fragment by fragment by calling mac_drv_rx_frag. 1879 * Args 1880 * smc - A pointer to the SMT context struct. 1881 * 1882 * len - The length (in bytes) of the received frame (FC, DA, SA, Data). 1883 * 1884 * fc - The Frame Control field of the received frame. 1885 * 1886 * look_ahead - A pointer to the lookahead data buffer (may be NULL). 1887 * 1888 * la_len - The length of the lookahead data stored in the lookahead 1889 * buffer (may be zero). 1890 * Out 1891 * Always returns zero (0). 1892 * 1893 ************************/ 1894int mac_drv_rx_init(struct s_smc *smc, int len, int fc, 1895 char *look_ahead, int la_len) 1896{ 1897 struct sk_buff *skb; 1898 1899 pr_debug("entering mac_drv_rx_init(len=%d)\n", len); 1900 1901 // "Received" a SMT or NSA frame of the local SMT. 1902 1903 if (len != la_len || len < FDDI_MAC_HDR_LEN || !look_ahead) { 1904 pr_debug("fddi: Discard invalid local SMT frame\n"); 1905 pr_debug(" len=%d, la_len=%d, (ULONG) look_ahead=%08lXh.\n", 1906 len, la_len, (unsigned long) look_ahead); 1907 return 0; 1908 } 1909 skb = alloc_skb(len + 3, GFP_ATOMIC); 1910 if (!skb) { 1911 pr_debug("fddi: Local SMT: skb memory exhausted.\n"); 1912 return 0; 1913 } 1914 skb_reserve(skb, 3); 1915 skb_put(skb, len); 1916 skb_copy_to_linear_data(skb, look_ahead, len); 1917 1918 // deliver frame to system 1919 skb->protocol = fddi_type_trans(skb, smc->os.dev); 1920 netif_rx(skb); 1921 1922 return 0; 1923} // mac_drv_rx_init 1924 1925 1926/************************ 1927 * 1928 * smt_timer_poll 1929 * 1930 * This routine is called periodically by the SMT module to clean up the 1931 * driver. 1932 * 1933 * Return any queued frames back to the upper protocol layers if the ring 1934 * is down. 1935 * Args 1936 * smc - A pointer to the SMT context struct. 1937 * Out 1938 * Nothing. 1939 * 1940 ************************/ 1941void smt_timer_poll(struct s_smc *smc) 1942{ 1943} // smt_timer_poll 1944 1945 1946/************************ 1947 * 1948 * ring_status_indication 1949 * 1950 * This function indicates a change of the ring state. 1951 * Args 1952 * smc - A pointer to the SMT context struct. 1953 * 1954 * status - The current ring status. 1955 * Out 1956 * Nothing. 1957 * 1958 ************************/ 1959void ring_status_indication(struct s_smc *smc, u_long status) 1960{ 1961 pr_debug("ring_status_indication( "); 1962 if (status & RS_RES15) 1963 pr_debug("RS_RES15 "); 1964 if (status & RS_HARDERROR) 1965 pr_debug("RS_HARDERROR "); 1966 if (status & RS_SOFTERROR) 1967 pr_debug("RS_SOFTERROR "); 1968 if (status & RS_BEACON) 1969 pr_debug("RS_BEACON "); 1970 if (status & RS_PATHTEST) 1971 pr_debug("RS_PATHTEST "); 1972 if (status & RS_SELFTEST) 1973 pr_debug("RS_SELFTEST "); 1974 if (status & RS_RES9) 1975 pr_debug("RS_RES9 "); 1976 if (status & RS_DISCONNECT) 1977 pr_debug("RS_DISCONNECT "); 1978 if (status & RS_RES7) 1979 pr_debug("RS_RES7 "); 1980 if (status & RS_DUPADDR) 1981 pr_debug("RS_DUPADDR "); 1982 if (status & RS_NORINGOP) 1983 pr_debug("RS_NORINGOP "); 1984 if (status & RS_VERSION) 1985 pr_debug("RS_VERSION "); 1986 if (status & RS_STUCKBYPASSS) 1987 pr_debug("RS_STUCKBYPASSS "); 1988 if (status & RS_EVENT) 1989 pr_debug("RS_EVENT "); 1990 if (status & RS_RINGOPCHANGE) 1991 pr_debug("RS_RINGOPCHANGE "); 1992 if (status & RS_RES0) 1993 pr_debug("RS_RES0 "); 1994 pr_debug("]\n"); 1995} // ring_status_indication 1996 1997 1998/************************ 1999 * 2000 * smt_get_time 2001 * 2002 * Gets the current time from the system. 2003 * Args 2004 * None. 2005 * Out 2006 * The current time in TICKS_PER_SECOND. 2007 * 2008 * TICKS_PER_SECOND has the unit 'count of timer ticks per second'. It is 2009 * defined in "targetos.h". The definition of TICKS_PER_SECOND must comply 2010 * to the time returned by smt_get_time(). 2011 * 2012 ************************/ 2013unsigned long smt_get_time(void) 2014{ 2015 return jiffies; 2016} // smt_get_time 2017 2018 2019/************************ 2020 * 2021 * smt_stat_counter 2022 * 2023 * Status counter update (ring_op, fifo full). 2024 * Args 2025 * smc - A pointer to the SMT context struct. 2026 * 2027 * stat - = 0: A ring operational change occurred. 2028 * = 1: The FORMAC FIFO buffer is full / FIFO overflow. 2029 * Out 2030 * Nothing. 2031 * 2032 ************************/ 2033void smt_stat_counter(struct s_smc *smc, int stat) 2034{ 2035// BOOLEAN RingIsUp ; 2036 2037 pr_debug("smt_stat_counter\n"); 2038 switch (stat) { 2039 case 0: 2040 pr_debug("Ring operational change.\n"); 2041 break; 2042 case 1: 2043 pr_debug("Receive fifo overflow.\n"); 2044 smc->os.MacStat.gen.rx_errors++; 2045 break; 2046 default: 2047 pr_debug("Unknown status (%d).\n", stat); 2048 break; 2049 } 2050} // smt_stat_counter 2051 2052 2053/************************ 2054 * 2055 * cfm_state_change 2056 * 2057 * Sets CFM state in custom statistics. 2058 * Args 2059 * smc - A pointer to the SMT context struct. 2060 * 2061 * c_state - Possible values are: 2062 * 2063 * EC0_OUT, EC1_IN, EC2_TRACE, EC3_LEAVE, EC4_PATH_TEST, 2064 * EC5_INSERT, EC6_CHECK, EC7_DEINSERT 2065 * Out 2066 * Nothing. 2067 * 2068 ************************/ 2069void cfm_state_change(struct s_smc *smc, int c_state) 2070{ 2071#ifdef DRIVERDEBUG 2072 char *s; 2073 2074 switch (c_state) { 2075 case SC0_ISOLATED: 2076 s = "SC0_ISOLATED"; 2077 break; 2078 case SC1_WRAP_A: 2079 s = "SC1_WRAP_A"; 2080 break; 2081 case SC2_WRAP_B: 2082 s = "SC2_WRAP_B"; 2083 break; 2084 case SC4_THRU_A: 2085 s = "SC4_THRU_A"; 2086 break; 2087 case SC5_THRU_B: 2088 s = "SC5_THRU_B"; 2089 break; 2090 case SC7_WRAP_S: 2091 s = "SC7_WRAP_S"; 2092 break; 2093 case SC9_C_WRAP_A: 2094 s = "SC9_C_WRAP_A"; 2095 break; 2096 case SC10_C_WRAP_B: 2097 s = "SC10_C_WRAP_B"; 2098 break; 2099 case SC11_C_WRAP_S: 2100 s = "SC11_C_WRAP_S"; 2101 break; 2102 default: 2103 pr_debug("cfm_state_change: unknown %d\n", c_state); 2104 return; 2105 } 2106 pr_debug("cfm_state_change: %s\n", s); 2107#endif // DRIVERDEBUG 2108} // cfm_state_change 2109 2110 2111/************************ 2112 * 2113 * ecm_state_change 2114 * 2115 * Sets ECM state in custom statistics. 2116 * Args 2117 * smc - A pointer to the SMT context struct. 2118 * 2119 * e_state - Possible values are: 2120 * 2121 * SC0_ISOLATED, SC1_WRAP_A (5), SC2_WRAP_B (6), SC4_THRU_A (12), 2122 * SC5_THRU_B (7), SC7_WRAP_S (8) 2123 * Out 2124 * Nothing. 2125 * 2126 ************************/ 2127void ecm_state_change(struct s_smc *smc, int e_state) 2128{ 2129#ifdef DRIVERDEBUG 2130 char *s; 2131 2132 switch (e_state) { 2133 case EC0_OUT: 2134 s = "EC0_OUT"; 2135 break; 2136 case EC1_IN: 2137 s = "EC1_IN"; 2138 break; 2139 case EC2_TRACE: 2140 s = "EC2_TRACE"; 2141 break; 2142 case EC3_LEAVE: 2143 s = "EC3_LEAVE"; 2144 break; 2145 case EC4_PATH_TEST: 2146 s = "EC4_PATH_TEST"; 2147 break; 2148 case EC5_INSERT: 2149 s = "EC5_INSERT"; 2150 break; 2151 case EC6_CHECK: 2152 s = "EC6_CHECK"; 2153 break; 2154 case EC7_DEINSERT: 2155 s = "EC7_DEINSERT"; 2156 break; 2157 default: 2158 s = "unknown"; 2159 break; 2160 } 2161 pr_debug("ecm_state_change: %s\n", s); 2162#endif //DRIVERDEBUG 2163} // ecm_state_change 2164 2165 2166/************************ 2167 * 2168 * rmt_state_change 2169 * 2170 * Sets RMT state in custom statistics. 2171 * Args 2172 * smc - A pointer to the SMT context struct. 2173 * 2174 * r_state - Possible values are: 2175 * 2176 * RM0_ISOLATED, RM1_NON_OP, RM2_RING_OP, RM3_DETECT, 2177 * RM4_NON_OP_DUP, RM5_RING_OP_DUP, RM6_DIRECTED, RM7_TRACE 2178 * Out 2179 * Nothing. 2180 * 2181 ************************/ 2182void rmt_state_change(struct s_smc *smc, int r_state) 2183{ 2184#ifdef DRIVERDEBUG 2185 char *s; 2186 2187 switch (r_state) { 2188 case RM0_ISOLATED: 2189 s = "RM0_ISOLATED"; 2190 break; 2191 case RM1_NON_OP: 2192 s = "RM1_NON_OP - not operational"; 2193 break; 2194 case RM2_RING_OP: 2195 s = "RM2_RING_OP - ring operational"; 2196 break; 2197 case RM3_DETECT: 2198 s = "RM3_DETECT - detect dupl addresses"; 2199 break; 2200 case RM4_NON_OP_DUP: 2201 s = "RM4_NON_OP_DUP - dupl. addr detected"; 2202 break; 2203 case RM5_RING_OP_DUP: 2204 s = "RM5_RING_OP_DUP - ring oper. with dupl. addr"; 2205 break; 2206 case RM6_DIRECTED: 2207 s = "RM6_DIRECTED - sending directed beacons"; 2208 break; 2209 case RM7_TRACE: 2210 s = "RM7_TRACE - trace initiated"; 2211 break; 2212 default: 2213 s = "unknown"; 2214 break; 2215 } 2216 pr_debug("[rmt_state_change: %s]\n", s); 2217#endif // DRIVERDEBUG 2218} // rmt_state_change 2219 2220 2221/************************ 2222 * 2223 * drv_reset_indication 2224 * 2225 * This function is called by the SMT when it has detected a severe 2226 * hardware problem. The driver should perform a reset on the adapter 2227 * as soon as possible, but not from within this function. 2228 * Args 2229 * smc - A pointer to the SMT context struct. 2230 * Out 2231 * Nothing. 2232 * 2233 ************************/ 2234void drv_reset_indication(struct s_smc *smc) 2235{ 2236 pr_debug("entering drv_reset_indication\n"); 2237 2238 smc->os.ResetRequested = TRUE; // Set flag. 2239 2240} // drv_reset_indication 2241 2242static struct pci_driver skfddi_pci_driver = { 2243 .name = "skfddi", 2244 .id_table = skfddi_pci_tbl, 2245 .probe = skfp_init_one, 2246 .remove = __devexit_p(skfp_remove_one), 2247}; 2248 2249static int __init skfd_init(void) 2250{ 2251 return pci_register_driver(&skfddi_pci_driver); 2252} 2253 2254static void __exit skfd_exit(void) 2255{ 2256 pci_unregister_driver(&skfddi_pci_driver); 2257} 2258 2259module_init(skfd_init); 2260module_exit(skfd_exit); 2261