drivers/net/via-velocity.c

   1 /*
   2  * This code is derived from the VIA reference driver (copyright message
   3  * below) provided to Red Hat by VIA Networking Technologies, Inc. for
   4  * addition to the Linux kernel.
   5  *
   6  * The code has been merged into one source file, cleaned up to follow
   7  * Linux coding style,  ported to the Linux 2.6 kernel tree and cleaned
   8  * for 64bit hardware platforms.
   9  *
  10  * TODO
  11  *      rx_copybreak/alignment
  12  *      Scatter gather
  13  *      More testing
  14  *
  15  * The changes are (c) Copyright 2004, Red Hat Inc. <alan@lxorguk.ukuu.org.uk>
  16  * Additional fixes and clean up: Francois Romieu
  17  *
  18  * This source has not been verified for use in safety critical systems.
  19  *
  20  * Please direct queries about the revamped driver to the linux-kernel
  21  * list not VIA.
  22  *
  23  * Original code:
  24  *
  25  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
  26  * All rights reserved.
  27  *
  28  * This software may be redistributed and/or modified under
  29  * the terms of the GNU General Public License as published by the Free
  30  * Software Foundation; either version 2 of the License, or
  31  * any later version.
  32  *
  33  * This program is distributed in the hope that it will be useful, but
  34  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  35  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  36  * for more details.
  37  *
  38  * Author: Chuang Liang-Shing, AJ Jiang
  39  *
  40  * Date: Jan 24, 2003
  41  *
  42  * MODULE_LICENSE("GPL");
  43  *
  44  */
  45
  46
  47 #include <linux/module.h>
  48 #include <linux/types.h>
  49 #include <linux/init.h>
  50 #include <linux/mm.h>
  51 #include <linux/errno.h>
  52 #include <linux/ioport.h>
  53 #include <linux/pci.h>
  54 #include <linux/kernel.h>
  55 #include <linux/netdevice.h>
  56 #include <linux/etherdevice.h>
  57 #include <linux/skbuff.h>
  58 #include <linux/delay.h>
  59 #include <linux/timer.h>
  60 #include <linux/slab.h>
  61 #include <linux/interrupt.h>
  62 #include <linux/string.h>
  63 #include <linux/wait.h>
  64 #include <linux/io.h>
  65 #include <linux/if.h>
  66 #include <linux/uaccess.h>
  67 #include <linux/proc_fs.h>
  68 #include <linux/inetdevice.h>
  69 #include <linux/reboot.h>
  70 #include <linux/ethtool.h>
  71 #include <linux/mii.h>
  72 #include <linux/in.h>
  73 #include <linux/if_arp.h>
  74 #include <linux/if_vlan.h>
  75 #include <linux/ip.h>
  76 #include <linux/tcp.h>
  77 #include <linux/udp.h>
  78 #include <linux/crc-ccitt.h>
  79 #include <linux/crc32.h>
  80
  81 #include "via-velocity.h"
  82
  83
  84 static int velocity_nics;
  85 static int msglevel = MSG_LEVEL_INFO;
  86
  87 /**
  88  *      mac_get_cam_mask        -       Read a CAM mask
  89  *      @regs: register block for this velocity
  90  *      @mask: buffer to store mask
  91  *
  92  *      Fetch the mask bits of the selected CAM and store them into the
  93  *      provided mask buffer.
  94  */
  95 static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
  96 {
  97         int i;
  98
  99         /* Select CAM mask */
 100         BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 101
 102         writeb(0, &regs->CAMADDR);
 103
 104         /* read mask */
 105         for (i = 0; i < 8; i++)
 106                 *mask++ = readb(&(regs->MARCAM[i]));
 107
 108         /* disable CAMEN */
 109         writeb(0, &regs->CAMADDR);
 110
 111         /* Select mar */
 112         BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 113 }
 114
 115
 116 /**
 117  *      mac_set_cam_mask        -       Set a CAM mask
 118  *      @regs: register block for this velocity
 119  *      @mask: CAM mask to load
 120  *
 121  *      Store a new mask into a CAM
 122  */
 123 static void mac_set_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
 124 {
 125         int i;
 126         /* Select CAM mask */
 127         BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 128
 129         writeb(CAMADDR_CAMEN, &regs->CAMADDR);
 130
 131         for (i = 0; i < 8; i++)
 132                 writeb(*mask++, &(regs->MARCAM[i]));
 133
 134         /* disable CAMEN */
 135         writeb(0, &regs->CAMADDR);
 136
 137         /* Select mar */
 138         BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 139 }
 140
 141 static void mac_set_vlan_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
 142 {
 143         int i;
 144         /* Select CAM mask */
 145         BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 146
 147         writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL, &regs->CAMADDR);
 148
 149         for (i = 0; i < 8; i++)
 150                 writeb(*mask++, &(regs->MARCAM[i]));
 151
 152         /* disable CAMEN */
 153         writeb(0, &regs->CAMADDR);
 154
 155         /* Select mar */
 156         BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 157 }
 158
 159 /**
 160  *      mac_set_cam     -       set CAM data
 161  *      @regs: register block of this velocity
 162  *      @idx: Cam index
 163  *      @addr: 2 or 6 bytes of CAM data
 164  *
 165  *      Load an address or vlan tag into a CAM
 166  */
 167 static void mac_set_cam(struct mac_regs __iomem *regs, int idx, const u8 *addr)
 168 {
 169         int i;
 170
 171         /* Select CAM mask */
 172         BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 173
 174         idx &= (64 - 1);
 175
 176         writeb(CAMADDR_CAMEN | idx, &regs->CAMADDR);
 177
 178         for (i = 0; i < 6; i++)
 179                 writeb(*addr++, &(regs->MARCAM[i]));
 180
 181         BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
 182
 183         udelay(10);
 184
 185         writeb(0, &regs->CAMADDR);
 186
 187         /* Select mar */
 188         BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 189 }
 190
 191 static void mac_set_vlan_cam(struct mac_regs __iomem *regs, int idx,
 192                              const u8 *addr)
 193 {
 194
 195         /* Select CAM mask */
 196         BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 197
 198         idx &= (64 - 1);
 199
 200         writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL | idx, &regs->CAMADDR);
 201         writew(*((u16 *) addr), &regs->MARCAM[0]);
 202
 203         BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
 204
 205         udelay(10);
 206
 207         writeb(0, &regs->CAMADDR);
 208
 209         /* Select mar */
 210         BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
 211 }
 212
 213
 214 /**
 215  *      mac_wol_reset   -       reset WOL after exiting low power
 216  *      @regs: register block of this velocity
 217  *
 218  *      Called after we drop out of wake on lan mode in order to
 219  *      reset the Wake on lan features. This function doesn't restore
 220  *      the rest of the logic from the result of sleep/wakeup
 221  */
 222 static void mac_wol_reset(struct mac_regs __iomem *regs)
 223 {
 224
 225         /* Turn off SWPTAG right after leaving power mode */
 226         BYTE_REG_BITS_OFF(STICKHW_SWPTAG, &regs->STICKHW);
 227         /* clear sticky bits */
 228         BYTE_REG_BITS_OFF((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
 229
 230         BYTE_REG_BITS_OFF(CHIPGCR_FCGMII, &regs->CHIPGCR);
 231         BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
 232         /* disable force PME-enable */
 233         writeb(WOLCFG_PMEOVR, &regs->WOLCFGClr);
 234         /* disable power-event config bit */
 235         writew(0xFFFF, &regs->WOLCRClr);
 236         /* clear power status */
 237         writew(0xFFFF, &regs->WOLSRClr);
 238 }
 239
 240 static const struct ethtool_ops velocity_ethtool_ops;
 241
 242 /*
 243     Define module options
 244 */
 245
 246 MODULE_AUTHOR("VIA Networking Technologies, Inc.");
 247 MODULE_LICENSE("GPL");
 248 MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
 249
 250 #define VELOCITY_PARAM(N, D) \
 251         static int N[MAX_UNITS] = OPTION_DEFAULT;\
 252         module_param_array(N, int, NULL, 0); \
 253         MODULE_PARM_DESC(N, D);
 254
 255 #define RX_DESC_MIN     64
 256 #define RX_DESC_MAX     255
 257 #define RX_DESC_DEF     64
 258 VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
 259
 260 #define TX_DESC_MIN     16
 261 #define TX_DESC_MAX     256
 262 #define TX_DESC_DEF     64
 263 VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
 264
 265 #define RX_THRESH_MIN   0
 266 #define RX_THRESH_MAX   3
 267 #define RX_THRESH_DEF   0
 268 /* rx_thresh[] is used for controlling the receive fifo threshold.
 269    0: indicate the rxfifo threshold is 128 bytes.
 270    1: indicate the rxfifo threshold is 512 bytes.
 271    2: indicate the rxfifo threshold is 1024 bytes.
 272    3: indicate the rxfifo threshold is store & forward.
 273 */
 274 VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
 275
 276 #define DMA_LENGTH_MIN  0
 277 #define DMA_LENGTH_MAX  7
 278 #define DMA_LENGTH_DEF  0
 279
 280 /* DMA_length[] is used for controlling the DMA length
 281    0: 8 DWORDs
 282    1: 16 DWORDs
 283    2: 32 DWORDs
 284    3: 64 DWORDs
 285    4: 128 DWORDs
 286    5: 256 DWORDs
 287    6: SF(flush till emply)
 288    7: SF(flush till emply)
 289 */
 290 VELOCITY_PARAM(DMA_length, "DMA length");
 291
 292 #define IP_ALIG_DEF     0
 293 /* IP_byte_align[] is used for IP header DWORD byte aligned
 294    0: indicate the IP header won't be DWORD byte aligned.(Default) .
 295    1: indicate the IP header will be DWORD byte aligned.
 296       In some enviroment, the IP header should be DWORD byte aligned,
 297       or the packet will be droped when we receive it. (eg: IPVS)
 298 */
 299 VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
 300
 301 #define TX_CSUM_DEF     1
 302 /* txcsum_offload[] is used for setting the checksum offload ability of NIC.
 303    (We only support RX checksum offload now)
 304    0: disable csum_offload[checksum offload
 305    1: enable checksum offload. (Default)
 306 */
 307 VELOCITY_PARAM(txcsum_offload, "Enable transmit packet checksum offload");
 308
 309 #define FLOW_CNTL_DEF   1
 310 #define FLOW_CNTL_MIN   1
 311 #define FLOW_CNTL_MAX   5
 312
 313 /* flow_control[] is used for setting the flow control ability of NIC.
 314    1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
 315    2: enable TX flow control.
 316    3: enable RX flow control.
 317    4: enable RX/TX flow control.
 318    5: disable
 319 */
 320 VELOCITY_PARAM(flow_control, "Enable flow control ability");
 321
 322 #define MED_LNK_DEF 0
 323 #define MED_LNK_MIN 0
 324 #define MED_LNK_MAX 4
 325 /* speed_duplex[] is used for setting the speed and duplex mode of NIC.
 326    0: indicate autonegotiation for both speed and duplex mode
 327    1: indicate 100Mbps half duplex mode
 328    2: indicate 100Mbps full duplex mode
 329    3: indicate 10Mbps half duplex mode
 330    4: indicate 10Mbps full duplex mode
 331
 332    Note:
 333    if EEPROM have been set to the force mode, this option is ignored
 334    by driver.
 335 */
 336 VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
 337
 338 #define VAL_PKT_LEN_DEF     0
 339 /* ValPktLen[] is used for setting the checksum offload ability of NIC.
 340    0: Receive frame with invalid layer 2 length (Default)
 341    1: Drop frame with invalid layer 2 length
 342 */
 343 VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
 344
 345 #define WOL_OPT_DEF     0
 346 #define WOL_OPT_MIN     0
 347 #define WOL_OPT_MAX     7
 348 /* wol_opts[] is used for controlling wake on lan behavior.
 349    0: Wake up if recevied a magic packet. (Default)
 350    1: Wake up if link status is on/off.
 351    2: Wake up if recevied an arp packet.
 352    4: Wake up if recevied any unicast packet.
 353    Those value can be sumed up to support more than one option.
 354 */
 355 VELOCITY_PARAM(wol_opts, "Wake On Lan options");
 356
 357 #define INT_WORKS_DEF   20
 358 #define INT_WORKS_MIN   10
 359 #define INT_WORKS_MAX   64
 360
 361 VELOCITY_PARAM(int_works, "Number of packets per interrupt services");
 362
 363 static int rx_copybreak = 200;
 364 module_param(rx_copybreak, int, 0644);
 365 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
 366
 367 /*
 368  *      Internal board variants. At the moment we have only one
 369  */
 370 static struct velocity_info_tbl chip_info_table[] = {
 371         {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
 372         { }
 373 };
 374
 375 /*
 376  *      Describe the PCI device identifiers that we support in this
 377  *      device driver. Used for hotplug autoloading.
 378  */
 379 static const struct pci_device_id velocity_id_table[] __devinitdata = {
 380         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
 381         { }
 382 };
 383
 384 MODULE_DEVICE_TABLE(pci, velocity_id_table);
 385
 386 /**
 387  *      get_chip_name   -       identifier to name
 388  *      @id: chip identifier
 389  *
 390  *      Given a chip identifier return a suitable description. Returns
 391  *      a pointer a static string valid while the driver is loaded.
 392  */
 393 static const char __devinit *get_chip_name(enum chip_type chip_id)
 394 {
 395         int i;
 396         for (i = 0; chip_info_table[i].name != NULL; i++)
 397                 if (chip_info_table[i].chip_id == chip_id)
 398                         break;
 399         return chip_info_table[i].name;
 400 }
 401
 402 /**
 403  *      velocity_remove1        -       device unplug
 404  *      @pdev: PCI device being removed
 405  *
 406  *      Device unload callback. Called on an unplug or on module
 407  *      unload for each active device that is present. Disconnects
 408  *      the device from the network layer and frees all the resources
 409  */
 410 static void __devexit velocity_remove1(struct pci_dev *pdev)
 411 {
 412         struct net_device *dev = pci_get_drvdata(pdev);
 413         struct velocity_info *vptr = netdev_priv(dev);
 414
 415         unregister_netdev(dev);
 416         iounmap(vptr->mac_regs);
 417         pci_release_regions(pdev);
 418         pci_disable_device(pdev);
 419         pci_set_drvdata(pdev, NULL);
 420         free_netdev(dev);
 421
 422         velocity_nics--;
 423 }
 424
 425 /**
 426  *      velocity_set_int_opt    -       parser for integer options
 427  *      @opt: pointer to option value
 428  *      @val: value the user requested (or -1 for default)
 429  *      @min: lowest value allowed
 430  *      @max: highest value allowed
 431  *      @def: default value
 432  *      @name: property name
 433  *      @dev: device name
 434  *
 435  *      Set an integer property in the module options. This function does
 436  *      all the verification and checking as well as reporting so that
 437  *      we don't duplicate code for each option.
 438  */
 439 static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname)
 440 {
 441         if (val == -1)
 442                 *opt = def;
 443         else if (val < min || val > max) {
 444                 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
 445                                         devname, name, min, max);
 446                 *opt = def;
 447         } else {
 448                 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
 449                                         devname, name, val);
 450                 *opt = val;
 451         }
 452 }
 453
 454 /**
 455  *      velocity_set_bool_opt   -       parser for boolean options
 456  *      @opt: pointer to option value
 457  *      @val: value the user requested (or -1 for default)
 458  *      @def: default value (yes/no)
 459  *      @flag: numeric value to set for true.
 460  *      @name: property name
 461  *      @dev: device name
 462  *
 463  *      Set a boolean property in the module options. This function does
 464  *      all the verification and checking as well as reporting so that
 465  *      we don't duplicate code for each option.
 466  */
 467 static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag, char *name, const char *devname)
 468 {
 469         (*opt) &= (~flag);
 470         if (val == -1)
 471                 *opt |= (def ? flag : 0);
 472         else if (val < 0 || val > 1) {
 473                 printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
 474                         devname, name);
 475                 *opt |= (def ? flag : 0);
 476         } else {
 477                 printk(KERN_INFO "%s: set parameter %s to %s\n",
 478                         devname, name, val ? "TRUE" : "FALSE");
 479                 *opt |= (val ? flag : 0);
 480         }
 481 }
 482
 483 /**
 484  *      velocity_get_options    -       set options on device
 485  *      @opts: option structure for the device
 486  *      @index: index of option to use in module options array
 487  *      @devname: device name
 488  *
 489  *      Turn the module and command options into a single structure
 490  *      for the current device
 491  */
 492 static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname)
 493 {
 494
 495         velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
 496         velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
 497         velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
 498         velocity_set_int_opt(&opts->numtx, TxDescriptors[index], TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF, "TxDescriptors", devname);
 499
 500         velocity_set_bool_opt(&opts->flags, txcsum_offload[index], TX_CSUM_DEF, VELOCITY_FLAGS_TX_CSUM, "txcsum_offload", devname);
 501         velocity_set_int_opt(&opts->flow_cntl, flow_control[index], FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF, "flow_control", devname);
 502         velocity_set_bool_opt(&opts->flags, IP_byte_align[index], IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN, "IP_byte_align", devname);
 503         velocity_set_bool_opt(&opts->flags, ValPktLen[index], VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN, "ValPktLen", devname);
 504         velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index], MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF, "Media link mode", devname);
 505         velocity_set_int_opt((int *) &opts->wol_opts, wol_opts[index], WOL_OPT_MIN, WOL_OPT_MAX, WOL_OPT_DEF, "Wake On Lan options", devname);
 506         velocity_set_int_opt((int *) &opts->int_works, int_works[index], INT_WORKS_MIN, INT_WORKS_MAX, INT_WORKS_DEF, "Interrupt service works", devname);
 507         opts->numrx = (opts->numrx & ~3);
 508 }
 509
 510 /**
 511  *      velocity_init_cam_filter        -       initialise CAM
 512  *      @vptr: velocity to program
 513  *
 514  *      Initialize the content addressable memory used for filters. Load
 515  *      appropriately according to the presence of VLAN
 516  */
 517 static void velocity_init_cam_filter(struct velocity_info *vptr)
 518 {
 519         struct mac_regs __iomem *regs = vptr->mac_regs;
 520
 521         /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
 522         WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
 523         WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
 524
 525         /* Disable all CAMs */
 526         memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
 527         memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
 528         mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
 529         mac_set_cam_mask(regs, vptr->mCAMmask);
 530
 531         /* Enable VCAMs */
 532         if (vptr->vlgrp) {
 533                 unsigned int vid, i = 0;
 534
 535                 if (!vlan_group_get_device(vptr->vlgrp, 0))
 536                         WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
 537
 538                 for (vid = 1; (vid < VLAN_VID_MASK); vid++) {
 539                         if (vlan_group_get_device(vptr->vlgrp, vid)) {
 540                                 mac_set_vlan_cam(regs, i, (u8 *) &vid);
 541                                 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
 542                                 if (++i >= VCAM_SIZE)
 543                                         break;
 544                         }
 545                 }
 546                 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
 547         }
 548 }
 549
 550 static void velocity_vlan_rx_register(struct net_device *dev,
 551                                       struct vlan_group *grp)
 552 {
 553         struct velocity_info *vptr = netdev_priv(dev);
 554
 555         vptr->vlgrp = grp;
 556 }
 557
 558 static void velocity_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
 559 {
 560         struct velocity_info *vptr = netdev_priv(dev);
 561
 562         spin_lock_irq(&vptr->lock);
 563         velocity_init_cam_filter(vptr);
 564         spin_unlock_irq(&vptr->lock);
 565 }
 566
 567 static void velocity_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 568 {
 569         struct velocity_info *vptr = netdev_priv(dev);
 570
 571         spin_lock_irq(&vptr->lock);
 572         vlan_group_set_device(vptr->vlgrp, vid, NULL);
 573         velocity_init_cam_filter(vptr);
 574         spin_unlock_irq(&vptr->lock);
 575 }
 576
 577 static void velocity_init_rx_ring_indexes(struct velocity_info *vptr)
 578 {
 579         vptr->rx.dirty = vptr->rx.filled = vptr->rx.curr = 0;
 580 }
 581
 582 /**
 583  *      velocity_rx_reset       -       handle a receive reset
 584  *      @vptr: velocity we are resetting
 585  *
 586  *      Reset the ownership and status for the receive ring side.
 587  *      Hand all the receive queue to the NIC.
 588  */
 589 static void velocity_rx_reset(struct velocity_info *vptr)
 590 {
 591
 592         struct mac_regs __iomem *regs = vptr->mac_regs;
 593         int i;
 594
 595         velocity_init_rx_ring_indexes(vptr);
 596
 597         /*
 598          *      Init state, all RD entries belong to the NIC
 599          */
 600         for (i = 0; i < vptr->options.numrx; ++i)
 601                 vptr->rx.ring[i].rdesc0.len |= OWNED_BY_NIC;
 602
 603         writew(vptr->options.numrx, &regs->RBRDU);
 604         writel(vptr->rx.pool_dma, &regs->RDBaseLo);
 605         writew(0, &regs->RDIdx);
 606         writew(vptr->options.numrx - 1, &regs->RDCSize);
 607 }
 608
 609 /**
 610  *      velocity_get_opt_media_mode     -       get media selection
 611  *      @vptr: velocity adapter
 612  *
 613  *      Get the media mode stored in EEPROM or module options and load
 614  *      mii_status accordingly. The requested link state information
 615  *      is also returned.
 616  */
 617 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
 618 {
 619         u32 status = 0;
 620
 621         switch (vptr->options.spd_dpx) {
 622         case SPD_DPX_AUTO:
 623                 status = VELOCITY_AUTONEG_ENABLE;
 624                 break;
 625         case SPD_DPX_100_FULL:
 626                 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
 627                 break;
 628         case SPD_DPX_10_FULL:
 629                 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
 630                 break;
 631         case SPD_DPX_100_HALF:
 632                 status = VELOCITY_SPEED_100;
 633                 break;
 634         case SPD_DPX_10_HALF:
 635                 status = VELOCITY_SPEED_10;
 636                 break;
 637         }
 638         vptr->mii_status = status;
 639         return status;
 640 }
 641
 642 /**
 643  *      safe_disable_mii_autopoll       -       autopoll off
 644  *      @regs: velocity registers
 645  *
 646  *      Turn off the autopoll and wait for it to disable on the chip
 647  */
 648 static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs)
 649 {
 650         u16 ww;
 651
 652         /*  turn off MAUTO */
 653         writeb(0, &regs->MIICR);
 654         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 655                 udelay(1);
 656                 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
 657                         break;
 658         }
 659 }
 660
 661 /**
 662  *      enable_mii_autopoll     -       turn on autopolling
 663  *      @regs: velocity registers
 664  *
 665  *      Enable the MII link status autopoll feature on the Velocity
 666  *      hardware. Wait for it to enable.
 667  */
 668 static void enable_mii_autopoll(struct mac_regs __iomem *regs)
 669 {
 670         int ii;
 671
 672         writeb(0, &(regs->MIICR));
 673         writeb(MIIADR_SWMPL, &regs->MIIADR);
 674
 675         for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
 676                 udelay(1);
 677                 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
 678                         break;
 679         }
 680
 681         writeb(MIICR_MAUTO, &regs->MIICR);
 682
 683         for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
 684                 udelay(1);
 685                 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
 686                         break;
 687         }
 688
 689 }
 690
 691 /**
 692  *      velocity_mii_read       -       read MII data
 693  *      @regs: velocity registers
 694  *      @index: MII register index
 695  *      @data: buffer for received data
 696  *
 697  *      Perform a single read of an MII 16bit register. Returns zero
 698  *      on success or -ETIMEDOUT if the PHY did not respond.
 699  */
 700 static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
 701 {
 702         u16 ww;
 703
 704         /*
 705          *      Disable MIICR_MAUTO, so that mii addr can be set normally
 706          */
 707         safe_disable_mii_autopoll(regs);
 708
 709         writeb(index, &regs->MIIADR);
 710
 711         BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
 712
 713         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 714                 if (!(readb(&regs->MIICR) & MIICR_RCMD))
 715                         break;
 716         }
 717
 718         *data = readw(&regs->MIIDATA);
 719
 720         enable_mii_autopoll(regs);
 721         if (ww == W_MAX_TIMEOUT)
 722                 return -ETIMEDOUT;
 723         return 0;
 724 }
 725
 726
 727 /**
 728  *      mii_check_media_mode    -       check media state
 729  *      @regs: velocity registers
 730  *
 731  *      Check the current MII status and determine the link status
 732  *      accordingly
 733  */
 734 static u32 mii_check_media_mode(struct mac_regs __iomem *regs)
 735 {
 736         u32 status = 0;
 737         u16 ANAR;
 738
 739         if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs))
 740                 status |= VELOCITY_LINK_FAIL;
 741
 742         if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs))
 743                 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
 744         else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
 745                 status |= (VELOCITY_SPEED_1000);
 746         else {
 747                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
 748                 if (ANAR & ANAR_TXFD)
 749                         status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
 750                 else if (ANAR & ANAR_TX)
 751                         status |= VELOCITY_SPEED_100;
 752                 else if (ANAR & ANAR_10FD)
 753                         status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
 754                 else
 755                         status |= (VELOCITY_SPEED_10);
 756         }
 757
 758         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
 759                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
 760                 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
 761                     == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
 762                         if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
 763                                 status |= VELOCITY_AUTONEG_ENABLE;
 764                 }
 765         }
 766
 767         return status;
 768 }
 769
 770 /**
 771  *      velocity_mii_write      -       write MII data
 772  *      @regs: velocity registers
 773  *      @index: MII register index
 774  *      @data: 16bit data for the MII register
 775  *
 776  *      Perform a single write to an MII 16bit register. Returns zero
 777  *      on success or -ETIMEDOUT if the PHY did not respond.
 778  */
 779 static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
 780 {
 781         u16 ww;
 782
 783         /*
 784          *      Disable MIICR_MAUTO, so that mii addr can be set normally
 785          */
 786         safe_disable_mii_autopoll(regs);
 787
 788         /* MII reg offset */
 789         writeb(mii_addr, &regs->MIIADR);
 790         /* set MII data */
 791         writew(data, &regs->MIIDATA);
 792
 793         /* turn on MIICR_WCMD */
 794         BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
 795
 796         /* W_MAX_TIMEOUT is the timeout period */
 797         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 798                 udelay(5);
 799                 if (!(readb(&regs->MIICR) & MIICR_WCMD))
 800                         break;
 801         }
 802         enable_mii_autopoll(regs);
 803
 804         if (ww == W_MAX_TIMEOUT)
 805                 return -ETIMEDOUT;
 806         return 0;
 807 }
 808
 809 /**
 810  *      set_mii_flow_control    -       flow control setup
 811  *      @vptr: velocity interface
 812  *
 813  *      Set up the flow control on this interface according to
 814  *      the supplied user/eeprom options.
 815  */
 816 static void set_mii_flow_control(struct velocity_info *vptr)
 817 {
 818         /*Enable or Disable PAUSE in ANAR */
 819         switch (vptr->options.flow_cntl) {
 820         case FLOW_CNTL_TX:
 821                 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
 822                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
 823                 break;
 824
 825         case FLOW_CNTL_RX:
 826                 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
 827                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
 828                 break;
 829
 830         case FLOW_CNTL_TX_RX:
 831                 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
 832                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
 833                 break;
 834
 835         case FLOW_CNTL_DISABLE:
 836                 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
 837                 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
 838                 break;
 839         default:
 840                 break;
 841         }
 842 }
 843
 844 /**
 845  *      mii_set_auto_on         -       autonegotiate on
 846  *      @vptr: velocity
 847  *
 848  *      Enable autonegotation on this interface
 849  */
 850 static void mii_set_auto_on(struct velocity_info *vptr)
 851 {
 852         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs))
 853                 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
 854         else
 855                 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
 856 }
 857
 858 static u32 check_connection_type(struct mac_regs __iomem *regs)
 859 {
 860         u32 status = 0;
 861         u8 PHYSR0;
 862         u16 ANAR;
 863         PHYSR0 = readb(&regs->PHYSR0);
 864
 865         /*
 866            if (!(PHYSR0 & PHYSR0_LINKGD))
 867            status|=VELOCITY_LINK_FAIL;
 868          */
 869
 870         if (PHYSR0 & PHYSR0_FDPX)
 871                 status |= VELOCITY_DUPLEX_FULL;
 872
 873         if (PHYSR0 & PHYSR0_SPDG)
 874                 status |= VELOCITY_SPEED_1000;
 875         else if (PHYSR0 & PHYSR0_SPD10)
 876                 status |= VELOCITY_SPEED_10;
 877         else
 878                 status |= VELOCITY_SPEED_100;
 879
 880         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
 881                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
 882                 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
 883                     == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
 884                         if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
 885                                 status |= VELOCITY_AUTONEG_ENABLE;
 886                 }
 887         }
 888
 889         return status;
 890 }
 891
 892
 893
 894 /**
 895  *      velocity_set_media_mode         -       set media mode
 896  *      @mii_status: old MII link state
 897  *
 898  *      Check the media link state and configure the flow control
 899  *      PHY and also velocity hardware setup accordingly. In particular
 900  *      we need to set up CD polling and frame bursting.
 901  */
 902 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
 903 {
 904         u32 curr_status;
 905         struct mac_regs __iomem *regs = vptr->mac_regs;
 906
 907         vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
 908         curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
 909
 910         /* Set mii link status */
 911         set_mii_flow_control(vptr);
 912
 913         /*
 914            Check if new status is consisent with current status
 915            if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE)
 916            || (mii_status==curr_status)) {
 917            vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
 918            vptr->mii_status=check_connection_type(vptr->mac_regs);
 919            VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
 920            return 0;
 921            }
 922          */
 923
 924         if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
 925                 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
 926
 927         /*
 928          *      If connection type is AUTO
 929          */
 930         if (mii_status & VELOCITY_AUTONEG_ENABLE) {
 931                 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
 932                 /* clear force MAC mode bit */
 933                 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
 934                 /* set duplex mode of MAC according to duplex mode of MII */
 935                 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10, MII_REG_ANAR, vptr->mac_regs);
 936                 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
 937                 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs);
 938
 939                 /* enable AUTO-NEGO mode */
 940                 mii_set_auto_on(vptr);
 941         } else {
 942                 u16 ANAR;
 943                 u8 CHIPGCR;
 944
 945                 /*
 946                  * 1. if it's 3119, disable frame bursting in halfduplex mode
 947                  *    and enable it in fullduplex mode
 948                  * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
 949                  * 3. only enable CD heart beat counter in 10HD mode
 950                  */
 951
 952                 /* set force MAC mode bit */
 953                 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
 954
 955                 CHIPGCR = readb(&regs->CHIPGCR);
 956                 CHIPGCR &= ~CHIPGCR_FCGMII;
 957
 958                 if (mii_status & VELOCITY_DUPLEX_FULL) {
 959                         CHIPGCR |= CHIPGCR_FCFDX;
 960                         writeb(CHIPGCR, &regs->CHIPGCR);
 961                         VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
 962                         if (vptr->rev_id < REV_ID_VT3216_A0)
 963                                 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
 964                 } else {
 965                         CHIPGCR &= ~CHIPGCR_FCFDX;
 966                         VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
 967                         writeb(CHIPGCR, &regs->CHIPGCR);
 968                         if (vptr->rev_id < REV_ID_VT3216_A0)
 969                                 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
 970                 }
 971
 972                 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
 973
 974                 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10))
 975                         BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
 976                 else
 977                         BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
 978
 979                 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */
 980                 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR);
 981                 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10));
 982                 if (mii_status & VELOCITY_SPEED_100) {
 983                         if (mii_status & VELOCITY_DUPLEX_FULL)
 984                                 ANAR |= ANAR_TXFD;
 985                         else
 986                                 ANAR |= ANAR_TX;
 987                 } else {
 988                         if (mii_status & VELOCITY_DUPLEX_FULL)
 989                                 ANAR |= ANAR_10FD;
 990                         else
 991                                 ANAR |= ANAR_10;
 992                 }
 993                 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
 994                 /* enable AUTO-NEGO mode */
 995                 mii_set_auto_on(vptr);
 996                 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
 997         }
 998         /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
 999         /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
1000         return VELOCITY_LINK_CHANGE;
1001 }
1002
1003 /**
1004  *      velocity_print_link_status      -       link status reporting
1005  *      @vptr: velocity to report on
1006  *
1007  *      Turn the link status of the velocity card into a kernel log
1008  *      description of the new link state, detailing speed and duplex
1009  *      status
1010  */
1011 static void velocity_print_link_status(struct velocity_info *vptr)
1012 {
1013
1014         if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1015                 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1016         } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1017                 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1018
1019                 if (vptr->mii_status & VELOCITY_SPEED_1000)
1020                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1021                 else if (vptr->mii_status & VELOCITY_SPEED_100)
1022                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1023                 else
1024                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1025
1026                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1027                         VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1028                 else
1029                         VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1030         } else {
1031                 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1032                 switch (vptr->options.spd_dpx) {
1033                 case SPD_DPX_100_HALF:
1034                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1035                         break;
1036                 case SPD_DPX_100_FULL:
1037                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1038                         break;
1039                 case SPD_DPX_10_HALF:
1040                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1041                         break;
1042                 case SPD_DPX_10_FULL:
1043                         VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1044                         break;
1045                 default:
1046                         break;
1047                 }
1048         }
1049 }
1050
1051 /**
1052  *      enable_flow_control_ability     -       flow control
1053  *      @vptr: veloity to configure
1054  *
1055  *      Set up flow control according to the flow control options
1056  *      determined by the eeprom/configuration.
1057  */
1058 static void enable_flow_control_ability(struct velocity_info *vptr)
1059 {
1060
1061         struct mac_regs __iomem *regs = vptr->mac_regs;
1062
1063         switch (vptr->options.flow_cntl) {
1064
1065         case FLOW_CNTL_DEFAULT:
1066                 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
1067                         writel(CR0_FDXRFCEN, &regs->CR0Set);
1068                 else
1069                         writel(CR0_FDXRFCEN, &regs->CR0Clr);
1070
1071                 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
1072                         writel(CR0_FDXTFCEN, &regs->CR0Set);
1073                 else
1074                         writel(CR0_FDXTFCEN, &regs->CR0Clr);
1075                 break;
1076
1077         case FLOW_CNTL_TX:
1078                 writel(CR0_FDXTFCEN, &regs->CR0Set);
1079                 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1080                 break;
1081
1082         case FLOW_CNTL_RX:
1083                 writel(CR0_FDXRFCEN, &regs->CR0Set);
1084                 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1085                 break;
1086
1087         case FLOW_CNTL_TX_RX:
1088                 writel(CR0_FDXTFCEN, &regs->CR0Set);
1089                 writel(CR0_FDXRFCEN, &regs->CR0Set);
1090                 break;
1091
1092         case FLOW_CNTL_DISABLE:
1093                 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1094                 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1095                 break;
1096
1097         default:
1098                 break;
1099         }
1100
1101 }
1102
1103 /**
1104  *      velocity_soft_reset     -       soft reset
1105  *      @vptr: velocity to reset
1106  *
1107  *      Kick off a soft reset of the velocity adapter and then poll
1108  *      until the reset sequence has completed before returning.
1109  */
1110 static int velocity_soft_reset(struct velocity_info *vptr)
1111 {
1112         struct mac_regs __iomem *regs = vptr->mac_regs;
1113         int i = 0;
1114
1115         writel(CR0_SFRST, &regs->CR0Set);
1116
1117         for (i = 0; i < W_MAX_TIMEOUT; i++) {
1118                 udelay(5);
1119                 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
1120                         break;
1121         }
1122
1123         if (i == W_MAX_TIMEOUT) {
1124                 writel(CR0_FORSRST, &regs->CR0Set);
1125                 /* FIXME: PCI POSTING */
1126                 /* delay 2ms */
1127                 mdelay(2);
1128         }
1129         return 0;
1130 }
1131
1132 /**
1133  *      velocity_set_multi      -       filter list change callback
1134  *      @dev: network device
1135  *
1136  *      Called by the network layer when the filter lists need to change
1137  *      for a velocity adapter. Reload the CAMs with the new address
1138  *      filter ruleset.
1139  */
1140 static void velocity_set_multi(struct net_device *dev)
1141 {
1142         struct velocity_info *vptr = netdev_priv(dev);
1143         struct mac_regs __iomem *regs = vptr->mac_regs;
1144         u8 rx_mode;
1145         int i;
1146         struct dev_mc_list *mclist;
1147
1148         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1149                 writel(0xffffffff, &regs->MARCAM[0]);
1150                 writel(0xffffffff, &regs->MARCAM[4]);
1151                 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
1152         } else if ((dev->mc_count > vptr->multicast_limit)
1153                    || (dev->flags & IFF_ALLMULTI)) {
1154                 writel(0xffffffff, &regs->MARCAM[0]);
1155                 writel(0xffffffff, &regs->MARCAM[4]);
1156                 rx_mode = (RCR_AM | RCR_AB);
1157         } else {
1158                 int offset = MCAM_SIZE - vptr->multicast_limit;
1159                 mac_get_cam_mask(regs, vptr->mCAMmask);
1160
1161                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) {
1162                         mac_set_cam(regs, i + offset, mclist->dmi_addr);
1163                         vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
1164                 }
1165
1166                 mac_set_cam_mask(regs, vptr->mCAMmask);
1167                 rx_mode = RCR_AM | RCR_AB | RCR_AP;
1168         }
1169         if (dev->mtu > 1500)
1170                 rx_mode |= RCR_AL;
1171
1172         BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
1173
1174 }
1175
1176 /*
1177  * MII access , media link mode setting functions
1178  */
1179
1180 /**
1181  *      mii_init        -       set up MII
1182  *      @vptr: velocity adapter
1183  *      @mii_status:  links tatus
1184  *
1185  *      Set up the PHY for the current link state.
1186  */
1187 static void mii_init(struct velocity_info *vptr, u32 mii_status)
1188 {
1189         u16 BMCR;
1190
1191         switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
1192         case PHYID_CICADA_CS8201:
1193                 /*
1194                  *      Reset to hardware default
1195                  */
1196                 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1197                 /*
1198                  *      Turn on ECHODIS bit in NWay-forced full mode and turn it
1199                  *      off it in NWay-forced half mode for NWay-forced v.s.
1200                  *      legacy-forced issue.
1201                  */
1202                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1203                         MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1204                 else
1205                         MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1206                 /*
1207                  *      Turn on Link/Activity LED enable bit for CIS8201
1208                  */
1209                 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
1210                 break;
1211         case PHYID_VT3216_32BIT:
1212         case PHYID_VT3216_64BIT:
1213                 /*
1214                  *      Reset to hardware default
1215                  */
1216                 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1217                 /*
1218                  *      Turn on ECHODIS bit in NWay-forced full mode and turn it
1219                  *      off it in NWay-forced half mode for NWay-forced v.s.
1220                  *      legacy-forced issue
1221                  */
1222                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1223                         MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1224                 else
1225                         MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1226                 break;
1227
1228         case PHYID_MARVELL_1000:
1229         case PHYID_MARVELL_1000S:
1230                 /*
1231                  *      Assert CRS on Transmit
1232                  */
1233                 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
1234                 /*
1235                  *      Reset to hardware default
1236                  */
1237                 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1238                 break;
1239         default:
1240                 ;
1241         }
1242         velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
1243         if (BMCR & BMCR_ISO) {
1244                 BMCR &= ~BMCR_ISO;
1245                 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
1246         }
1247 }
1248
1249 /**
1250  * setup_queue_timers   -       Setup interrupt timers
1251  *
1252  * Setup interrupt frequency during suppression (timeout if the frame
1253  * count isn't filled).
1254  */
1255 static void setup_queue_timers(struct velocity_info *vptr)
1256 {
1257         /* Only for newer revisions */
1258         if (vptr->rev_id >= REV_ID_VT3216_A0) {
1259                 u8 txqueue_timer = 0;
1260                 u8 rxqueue_timer = 0;
1261
1262                 if (vptr->mii_status & (VELOCITY_SPEED_1000 |
1263                                 VELOCITY_SPEED_100)) {
1264                         txqueue_timer = vptr->options.txqueue_timer;
1265                         rxqueue_timer = vptr->options.rxqueue_timer;
1266                 }
1267
1268                 writeb(txqueue_timer, &vptr->mac_regs->TQETMR);
1269                 writeb(rxqueue_timer, &vptr->mac_regs->RQETMR);
1270         }
1271 }
1272 /**
1273  * setup_adaptive_interrupts  -  Setup interrupt suppression
1274  *
1275  * @vptr velocity adapter
1276  *
1277  * The velocity is able to suppress interrupt during high interrupt load.
1278  * This function turns on that feature.
1279  */
1280 static void setup_adaptive_interrupts(struct velocity_info *vptr)
1281 {
1282         struct mac_regs __iomem *regs = vptr->mac_regs;
1283         u16 tx_intsup = vptr->options.tx_intsup;
1284         u16 rx_intsup = vptr->options.rx_intsup;
1285
1286         /* Setup default interrupt mask (will be changed below) */
1287         vptr->int_mask = INT_MASK_DEF;
1288
1289         /* Set Tx Interrupt Suppression Threshold */
1290         writeb(CAMCR_PS0, &regs->CAMCR);
1291         if (tx_intsup != 0) {
1292                 vptr->int_mask &= ~(ISR_PTXI | ISR_PTX0I | ISR_PTX1I |
1293                                 ISR_PTX2I | ISR_PTX3I);
1294                 writew(tx_intsup, &regs->ISRCTL);
1295         } else
1296                 writew(ISRCTL_TSUPDIS, &regs->ISRCTL);
1297
1298         /* Set Rx Interrupt Suppression Threshold */
1299         writeb(CAMCR_PS1, &regs->CAMCR);
1300         if (rx_intsup != 0) {
1301                 vptr->int_mask &= ~ISR_PRXI;
1302                 writew(rx_intsup, &regs->ISRCTL);
1303         } else
1304                 writew(ISRCTL_RSUPDIS, &regs->ISRCTL);
1305
1306         /* Select page to interrupt hold timer */
1307         writeb(0, &regs->CAMCR);
1308 }
1309
1310 /**
1311  *      velocity_init_registers -       initialise MAC registers
1312  *      @vptr: velocity to init
1313  *      @type: type of initialisation (hot or cold)
1314  *
1315  *      Initialise the MAC on a reset or on first set up on the
1316  *      hardware.
1317  */
1318 static void velocity_init_registers(struct velocity_info *vptr,
1319                                     enum velocity_init_type type)
1320 {
1321         struct mac_regs __iomem *regs = vptr->mac_regs;
1322         int i, mii_status;
1323
1324         mac_wol_reset(regs);
1325
1326         switch (type) {
1327         case VELOCITY_INIT_RESET:
1328         case VELOCITY_INIT_WOL:
1329
1330                 netif_stop_queue(vptr->dev);
1331
1332                 /*
1333                  *      Reset RX to prevent RX pointer not on the 4X location
1334                  */
1335                 velocity_rx_reset(vptr);
1336                 mac_rx_queue_run(regs);
1337                 mac_rx_queue_wake(regs);
1338
1339                 mii_status = velocity_get_opt_media_mode(vptr);
1340                 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1341                         velocity_print_link_status(vptr);
1342                         if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1343                                 netif_wake_queue(vptr->dev);
1344                 }
1345
1346                 enable_flow_control_ability(vptr);
1347
1348                 mac_clear_isr(regs);
1349                 writel(CR0_STOP, &regs->CR0Clr);
1350                 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
1351                                                         &regs->CR0Set);
1352
1353                 break;
1354
1355         case VELOCITY_INIT_COLD:
1356         default:
1357                 /*
1358                  *      Do reset
1359                  */
1360                 velocity_soft_reset(vptr);
1361                 mdelay(5);
1362
1363                 mac_eeprom_reload(regs);
1364                 for (i = 0; i < 6; i++)
1365                         writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
1366
1367                 /*
1368                  *      clear Pre_ACPI bit.
1369                  */
1370                 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
1371                 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
1372                 mac_set_dma_length(regs, vptr->options.DMA_length);
1373
1374                 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
1375                 /*
1376                  *      Back off algorithm use original IEEE standard
1377                  */
1378                 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
1379
1380                 /*
1381                  *      Init CAM filter
1382                  */
1383                 velocity_init_cam_filter(vptr);
1384
1385                 /*
1386                  *      Set packet filter: Receive directed and broadcast address
1387                  */
1388                 velocity_set_multi(vptr->dev);
1389
1390                 /*
1391                  *      Enable MII auto-polling
1392                  */
1393                 enable_mii_autopoll(regs);
1394
1395                 setup_adaptive_interrupts(vptr);
1396
1397                 writel(vptr->rx.pool_dma, &regs->RDBaseLo);
1398                 writew(vptr->options.numrx - 1, &regs->RDCSize);
1399                 mac_rx_queue_run(regs);
1400                 mac_rx_queue_wake(regs);
1401
1402                 writew(vptr->options.numtx - 1, &regs->TDCSize);
1403
1404                 for (i = 0; i < vptr->tx.numq; i++) {
1405                         writel(vptr->tx.pool_dma[i], &regs->TDBaseLo[i]);
1406                         mac_tx_queue_run(regs, i);
1407                 }
1408
1409                 init_flow_control_register(vptr);
1410
1411                 writel(CR0_STOP, &regs->CR0Clr);
1412                 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
1413
1414                 mii_status = velocity_get_opt_media_mode(vptr);
1415                 netif_stop_queue(vptr->dev);
1416
1417                 mii_init(vptr, mii_status);
1418
1419                 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1420                         velocity_print_link_status(vptr);
1421                         if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1422                                 netif_wake_queue(vptr->dev);
1423                 }
1424
1425                 enable_flow_control_ability(vptr);
1426                 mac_hw_mibs_init(regs);
1427                 mac_write_int_mask(vptr->int_mask, regs);
1428                 mac_clear_isr(regs);
1429
1430         }
1431 }
1432
1433 static void velocity_give_many_rx_descs(struct velocity_info *vptr)
1434 {
1435         struct mac_regs __iomem *regs = vptr->mac_regs;
1436         int avail, dirty, unusable;
1437
1438         /*
1439          * RD number must be equal to 4X per hardware spec
1440          * (programming guide rev 1.20, p.13)
1441          */
1442         if (vptr->rx.filled < 4)
1443                 return;
1444
1445         wmb();
1446
1447         unusable = vptr->rx.filled & 0x0003;
1448         dirty = vptr->rx.dirty - unusable;
1449         for (avail = vptr->rx.filled & 0xfffc; avail; avail--) {
1450                 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1451                 vptr->rx.ring[dirty].rdesc0.len |= OWNED_BY_NIC;
1452         }
1453
1454         writew(vptr->rx.filled & 0xfffc, &regs->RBRDU);
1455         vptr->rx.filled = unusable;
1456 }
1457
1458 /**
1459  *      velocity_init_dma_rings -       set up DMA rings
1460  *      @vptr: Velocity to set up
1461  *
1462  *      Allocate PCI mapped DMA rings for the receive and transmit layer
1463  *      to use.
1464  */
1465 static int velocity_init_dma_rings(struct velocity_info *vptr)
1466 {
1467         struct velocity_opt *opt = &vptr->options;
1468         const unsigned int rx_ring_size = opt->numrx * sizeof(struct rx_desc);
1469         const unsigned int tx_ring_size = opt->numtx * sizeof(struct tx_desc);
1470         struct pci_dev *pdev = vptr->pdev;
1471         dma_addr_t pool_dma;
1472         void *pool;
1473         unsigned int i;
1474
1475         /*
1476          * Allocate all RD/TD rings a single pool.
1477          *
1478          * pci_alloc_consistent() fulfills the requirement for 64 bytes
1479          * alignment
1480          */
1481         pool = pci_alloc_consistent(pdev, tx_ring_size * vptr->tx.numq +
1482                                     rx_ring_size, &pool_dma);
1483         if (!pool) {
1484                 dev_err(&pdev->dev, "%s : DMA memory allocation failed.\n",
1485                         vptr->dev->name);
1486                 return -ENOMEM;
1487         }
1488
1489         vptr->rx.ring = pool;
1490         vptr->rx.pool_dma = pool_dma;
1491
1492         pool += rx_ring_size;
1493         pool_dma += rx_ring_size;
1494
1495         for (i = 0; i < vptr->tx.numq; i++) {
1496                 vptr->tx.rings[i] = pool;
1497                 vptr->tx.pool_dma[i] = pool_dma;
1498                 pool += tx_ring_size;
1499                 pool_dma += tx_ring_size;
1500         }
1501
1502         return 0;
1503 }
1504
1505 static void velocity_set_rxbufsize(struct velocity_info *vptr, int mtu)
1506 {
1507         vptr->rx.buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1508 }
1509
1510 /**
1511  *      velocity_alloc_rx_buf   -       allocate aligned receive buffer
1512  *      @vptr: velocity
1513  *      @idx: ring index
1514  *
1515  *      Allocate a new full sized buffer for the reception of a frame and
1516  *      map it into PCI space for the hardware to use. The hardware
1517  *      requires *64* byte alignment of the buffer which makes life
1518  *      less fun than would be ideal.
1519  */
1520 static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1521 {
1522         struct rx_desc *rd = &(vptr->rx.ring[idx]);
1523         struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
1524
1525         rd_info->skb = dev_alloc_skb(vptr->rx.buf_sz + 64);
1526         if (rd_info->skb == NULL)
1527                 return -ENOMEM;
1528
1529         /*
1530          *      Do the gymnastics to get the buffer head for data at
1531          *      64byte alignment.
1532          */
1533         skb_reserve(rd_info->skb,
1534                         64 - ((unsigned long) rd_info->skb->data & 63));
1535         rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
1536                                         vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
1537
1538         /*
1539          *      Fill in the descriptor to match
1540          */
1541
1542         *((u32 *) & (rd->rdesc0)) = 0;
1543         rd->size = cpu_to_le16(vptr->rx.buf_sz) | RX_INTEN;
1544         rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1545         rd->pa_high = 0;
1546         return 0;
1547 }
1548
1549
1550 static int velocity_rx_refill(struct velocity_info *vptr)
1551 {
1552         int dirty = vptr->rx.dirty, done = 0;
1553
1554         do {
1555                 struct rx_desc *rd = vptr->rx.ring + dirty;
1556
1557                 /* Fine for an all zero Rx desc at init time as well */
1558                 if (rd->rdesc0.len & OWNED_BY_NIC)
1559                         break;
1560
1561                 if (!vptr->rx.info[dirty].skb) {
1562                         if (velocity_alloc_rx_buf(vptr, dirty) < 0)
1563                                 break;
1564                 }
1565                 done++;
1566                 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
1567         } while (dirty != vptr->rx.curr);
1568
1569         if (done) {
1570                 vptr->rx.dirty = dirty;
1571                 vptr->rx.filled += done;
1572         }
1573
1574         return done;
1575 }
1576
1577 /**
1578  *      velocity_free_rd_ring   -       free receive ring
1579  *      @vptr: velocity to clean up
1580  *
1581  *      Free the receive buffers for each ring slot and any
1582  *      attached socket buffers that need to go away.
1583  */
1584 static void velocity_free_rd_ring(struct velocity_info *vptr)
1585 {
1586         int i;
1587
1588         if (vptr->rx.info == NULL)
1589                 return;
1590
1591         for (i = 0; i < vptr->options.numrx; i++) {
1592                 struct velocity_rd_info *rd_info = &(vptr->rx.info[i]);
1593                 struct rx_desc *rd = vptr->rx.ring + i;
1594
1595                 memset(rd, 0, sizeof(*rd));
1596
1597                 if (!rd_info->skb)
1598                         continue;
1599                 pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
1600                                  PCI_DMA_FROMDEVICE);
1601                 rd_info->skb_dma = 0;
1602
1603                 dev_kfree_skb(rd_info->skb);
1604                 rd_info->skb = NULL;
1605         }
1606
1607         kfree(vptr->rx.info);
1608         vptr->rx.info = NULL;
1609 }
1610
1611
1612
1613 /**
1614  *      velocity_init_rd_ring   -       set up receive ring
1615  *      @vptr: velocity to configure
1616  *
1617  *      Allocate and set up the receive buffers for each ring slot and
1618  *      assign them to the network adapter.
1619  */
1620 static int velocity_init_rd_ring(struct velocity_info *vptr)
1621 {
1622         int ret = -ENOMEM;
1623
1624         vptr->rx.info = kcalloc(vptr->options.numrx,
1625                                 sizeof(struct velocity_rd_info), GFP_KERNEL);
1626         if (!vptr->rx.info)
1627                 goto out;
1628
1629         velocity_init_rx_ring_indexes(vptr);
1630
1631         if (velocity_rx_refill(vptr) != vptr->options.numrx) {
1632                 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1633                         "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1634                 velocity_free_rd_ring(vptr);
1635                 goto out;
1636         }
1637
1638         ret = 0;
1639 out:
1640         return ret;
1641 }
1642
1643 /**
1644  *      velocity_init_td_ring   -       set up transmit ring
1645  *      @vptr:  velocity
1646  *
1647  *      Set up the transmit ring and chain the ring pointers together.
1648  *      Returns zero on success or a negative posix errno code for
1649  *      failure.
1650  */
1651 static int velocity_init_td_ring(struct velocity_info *vptr)
1652 {
1653         dma_addr_t curr;
1654         int j;
1655
1656         /* Init the TD ring entries */
1657         for (j = 0; j < vptr->tx.numq; j++) {
1658                 curr = vptr->tx.pool_dma[j];
1659
1660                 vptr->tx.infos[j] = kcalloc(vptr->options.numtx,
1661                                             sizeof(struct velocity_td_info),
1662                                             GFP_KERNEL);
1663                 if (!vptr->tx.infos[j]) {
1664                         while (--j >= 0)
1665                                 kfree(vptr->tx.infos[j]);
1666                         return -ENOMEM;
1667                 }
1668
1669                 vptr->tx.tail[j] = vptr->tx.curr[j] = vptr->tx.used[j] = 0;
1670         }
1671         return 0;
1672 }
1673
1674 /**
1675  *      velocity_free_dma_rings -       free PCI ring pointers
1676  *      @vptr: Velocity to free from
1677  *
1678  *      Clean up the PCI ring buffers allocated to this velocity.
1679  */
1680 static void velocity_free_dma_rings(struct velocity_info *vptr)
1681 {
1682         const int size = vptr->options.numrx * sizeof(struct rx_desc) +
1683                 vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq;
1684
1685         pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
1686 }
1687
1688
1689 static int velocity_init_rings(struct velocity_info *vptr, int mtu)
1690 {
1691         int ret;
1692
1693         velocity_set_rxbufsize(vptr, mtu);
1694
1695         ret = velocity_init_dma_rings(vptr);
1696         if (ret < 0)
1697                 goto out;
1698
1699         ret = velocity_init_rd_ring(vptr);
1700         if (ret < 0)
1701                 goto err_free_dma_rings_0;
1702
1703         ret = velocity_init_td_ring(vptr);
1704         if (ret < 0)
1705                 goto err_free_rd_ring_1;
1706 out:
1707         return ret;
1708
1709 err_free_rd_ring_1:
1710         velocity_free_rd_ring(vptr);
1711 err_free_dma_rings_0:
1712         velocity_free_dma_rings(vptr);
1713         goto out;
1714 }
1715
1716 /**
1717  *      velocity_free_tx_buf    -       free transmit buffer
1718  *      @vptr: velocity
1719  *      @tdinfo: buffer
1720  *
1721  *      Release an transmit buffer. If the buffer was preallocated then
1722  *      recycle it, if not then unmap the buffer.
1723  */
1724 static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *tdinfo)
1725 {
1726         struct sk_buff *skb = tdinfo->skb;
1727         int i;
1728         int pktlen;
1729
1730         /*
1731          *      Don't unmap the pre-allocated tx_bufs
1732          */
1733         if (tdinfo->skb_dma) {
1734
1735                 pktlen = max_t(unsigned int, skb->len, ETH_ZLEN);
1736                 for (i = 0; i < tdinfo->nskb_dma; i++) {
1737                         pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], pktlen, PCI_DMA_TODEVICE);
1738                         tdinfo->skb_dma[i] = 0;
1739                 }
1740         }
1741         dev_kfree_skb_irq(skb);
1742         tdinfo->skb = NULL;
1743 }
1744
1745
1746 /*
1747  *      FIXME: could we merge this with velocity_free_tx_buf ?
1748  */
1749 static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1750                                                          int q, int n)
1751 {
1752         struct velocity_td_info *td_info = &(vptr->tx.infos[q][n]);
1753         int i;
1754
1755         if (td_info == NULL)
1756                 return;
1757
1758         if (td_info->skb) {
1759                 for (i = 0; i < td_info->nskb_dma; i++) {
1760                         if (td_info->skb_dma[i]) {
1761                                 pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
1762                                         td_info->skb->len, PCI_DMA_TODEVICE);
1763                                 td_info->skb_dma[i] = 0;
1764                         }
1765                 }
1766                 dev_kfree_skb(td_info->skb);
1767                 td_info->skb = NULL;
1768         }
1769 }
1770
1771 /**
1772  *      velocity_free_td_ring   -       free td ring
1773  *      @vptr: velocity
1774  *
1775  *      Free up the transmit ring for this particular velocity adapter.
1776  *      We free the ring contents but not the ring itself.
1777  */
1778 static void velocity_free_td_ring(struct velocity_info *vptr)
1779 {
1780         int i, j;
1781
1782         for (j = 0; j < vptr->tx.numq; j++) {
1783                 if (vptr->tx.infos[j] == NULL)
1784                         continue;
1785                 for (i = 0; i < vptr->options.numtx; i++)
1786                         velocity_free_td_ring_entry(vptr, j, i);
1787
1788                 kfree(vptr->tx.infos[j]);
1789                 vptr->tx.infos[j] = NULL;
1790         }
1791 }
1792
1793
1794 static void velocity_free_rings(struct velocity_info *vptr)
1795 {
1796         velocity_free_td_ring(vptr);
1797         velocity_free_rd_ring(vptr);
1798         velocity_free_dma_rings(vptr);
1799 }
1800
1801 /**
1802  *      velocity_error  -       handle error from controller
1803  *      @vptr: velocity
1804  *      @status: card status
1805  *
1806  *      Process an error report from the hardware and attempt to recover
1807  *      the card itself. At the moment we cannot recover from some
1808  *      theoretically impossible errors but this could be fixed using
1809  *      the pci_device_failed logic to bounce the hardware
1810  *
1811  */
1812 static void velocity_error(struct velocity_info *vptr, int status)
1813 {
1814
1815         if (status & ISR_TXSTLI) {
1816                 struct mac_regs __iomem *regs = vptr->mac_regs;
1817
1818                 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1819                 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1820                 writew(TRDCSR_RUN, &regs->TDCSRClr);
1821                 netif_stop_queue(vptr->dev);
1822
1823                 /* FIXME: port over the pci_device_failed code and use it
1824                    here */
1825         }
1826
1827         if (status & ISR_SRCI) {
1828                 struct mac_regs __iomem *regs = vptr->mac_regs;
1829                 int linked;
1830
1831                 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1832                         vptr->mii_status = check_connection_type(regs);
1833
1834                         /*
1835                          *      If it is a 3119, disable frame bursting in
1836                          *      halfduplex mode and enable it in fullduplex
1837                          *       mode
1838                          */
1839                         if (vptr->rev_id < REV_ID_VT3216_A0) {
1840                                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1841                                         BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1842                                 else
1843                                         BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1844                         }
1845                         /*
1846                          *      Only enable CD heart beat counter in 10HD mode
1847                          */
1848                         if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10))
1849                                 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1850                         else
1851                                 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1852
1853                         setup_queue_timers(vptr);
1854                 }
1855                 /*
1856                  *      Get link status from PHYSR0
1857                  */
1858                 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1859
1860                 if (linked) {
1861                         vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1862                         netif_carrier_on(vptr->dev);
1863                 } else {
1864                         vptr->mii_status |= VELOCITY_LINK_FAIL;
1865                         netif_carrier_off(vptr->dev);
1866                 }
1867
1868                 velocity_print_link_status(vptr);
1869                 enable_flow_control_ability(vptr);
1870
1871                 /*
1872                  *      Re-enable auto-polling because SRCI will disable
1873                  *      auto-polling
1874                  */
1875
1876                 enable_mii_autopoll(regs);
1877
1878                 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1879                         netif_stop_queue(vptr->dev);
1880                 else
1881                         netif_wake_queue(vptr->dev);
1882
1883         };
1884         if (status & ISR_MIBFI)
1885                 velocity_update_hw_mibs(vptr);
1886         if (status & ISR_LSTEI)
1887                 mac_rx_queue_wake(vptr->mac_regs);
1888 }
1889
1890 /**
1891  *      tx_srv          -       transmit interrupt service
1892  *      @vptr; Velocity
1893  *      @status:
1894  *
1895  *      Scan the queues looking for transmitted packets that
1896  *      we can complete and clean up. Update any statistics as
1897  *      necessary/
1898  */
1899 static int velocity_tx_srv(struct velocity_info *vptr, u32 status)
1900 {
1901         struct tx_desc *td;
1902         int qnum;
1903         int full = 0;
1904         int idx;
1905         int works = 0;
1906         struct velocity_td_info *tdinfo;
1907         struct net_device_stats *stats = &vptr->dev->stats;
1908
1909         for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
1910                 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
1911                         idx = (idx + 1) % vptr->options.numtx) {
1912
1913                         /*
1914                          *      Get Tx Descriptor
1915                          */
1916                         td = &(vptr->tx.rings[qnum][idx]);
1917                         tdinfo = &(vptr->tx.infos[qnum][idx]);
1918
1919                         if (td->tdesc0.len & OWNED_BY_NIC)
1920                                 break;
1921
1922                         if ((works++ > 15))
1923                                 break;
1924
1925                         if (td->tdesc0.TSR & TSR0_TERR) {
1926                                 stats->tx_errors++;
1927                                 stats->tx_dropped++;
1928                                 if (td->tdesc0.TSR & TSR0_CDH)
1929                                         stats->tx_heartbeat_errors++;
1930                                 if (td->tdesc0.TSR & TSR0_CRS)
1931                                         stats->tx_carrier_errors++;
1932                                 if (td->tdesc0.TSR & TSR0_ABT)
1933                                         stats->tx_aborted_errors++;
1934                                 if (td->tdesc0.TSR & TSR0_OWC)
1935                                         stats->tx_window_errors++;
1936                         } else {
1937                                 stats->tx_packets++;
1938                                 stats->tx_bytes += tdinfo->skb->len;
1939                         }
1940                         velocity_free_tx_buf(vptr, tdinfo);
1941                         vptr->tx.used[qnum]--;
1942                 }
1943                 vptr->tx.tail[qnum] = idx;
1944
1945                 if (AVAIL_TD(vptr, qnum) < 1)
1946                         full = 1;
1947         }
1948         /*
1949          *      Look to see if we should kick the transmit network
1950          *      layer for more work.
1951          */
1952         if (netif_queue_stopped(vptr->dev) && (full == 0)
1953             && (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1954                 netif_wake_queue(vptr->dev);
1955         }
1956         return works;
1957 }
1958
1959 /**
1960  *      velocity_rx_csum        -       checksum process
1961  *      @rd: receive packet descriptor
1962  *      @skb: network layer packet buffer
1963  *
1964  *      Process the status bits for the received packet and determine
1965  *      if the checksum was computed and verified by the hardware
1966  */
1967 static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1968 {
1969         skb->ip_summed = CHECKSUM_NONE;
1970
1971         if (rd->rdesc1.CSM & CSM_IPKT) {
1972                 if (rd->rdesc1.CSM & CSM_IPOK) {
1973                         if ((rd->rdesc1.CSM & CSM_TCPKT) ||
1974                                         (rd->rdesc1.CSM & CSM_UDPKT)) {
1975                                 if (!(rd->rdesc1.CSM & CSM_TUPOK))
1976                                         return;
1977                         }
1978                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1979                 }
1980         }
1981 }
1982
1983 /**
1984  *      velocity_rx_copy        -       in place Rx copy for small packets
1985  *      @rx_skb: network layer packet buffer candidate
1986  *      @pkt_size: received data size
1987  *      @rd: receive packet descriptor
1988  *      @dev: network device
1989  *
1990  *      Replace the current skb that is scheduled for Rx processing by a
1991  *      shorter, immediatly allocated skb, if the received packet is small
1992  *      enough. This function returns a negative value if the received
1993  *      packet is too big or if memory is exhausted.
1994  */
1995 static int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
1996                             struct velocity_info *vptr)
1997 {
1998         int ret = -1;
1999         if (pkt_size < rx_copybreak) {
2000                 struct sk_buff *new_skb;
2001
2002                 new_skb = netdev_alloc_skb_ip_align(vptr->dev, pkt_size);
2003                 if (new_skb) {
2004                         new_skb->ip_summed = rx_skb[0]->ip_summed;
2005                         skb_copy_from_linear_data(*rx_skb, new_skb->data, pkt_size);
2006                         *rx_skb = new_skb;
2007                         ret = 0;
2008                 }
2009
2010         }
2011         return ret;
2012 }
2013
2014 /**
2015  *      velocity_iph_realign    -       IP header alignment
2016  *      @vptr: velocity we are handling
2017  *      @skb: network layer packet buffer
2018  *      @pkt_size: received data size
2019  *
2020  *      Align IP header on a 2 bytes boundary. This behavior can be
2021  *      configured by the user.
2022  */
2023 static inline void velocity_iph_realign(struct velocity_info *vptr,
2024                                         struct sk_buff *skb, int pkt_size)
2025 {
2026         if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
2027                 memmove(skb->data + 2, skb->data, pkt_size);
2028                 skb_reserve(skb, 2);
2029         }
2030 }
2031
2032
2033 /**
2034  *      velocity_receive_frame  -       received packet processor
2035  *      @vptr: velocity we are handling
2036  *      @idx: ring index
2037  *
2038  *      A packet has arrived. We process the packet and if appropriate
2039  *      pass the frame up the network stack
2040  */
2041 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
2042 {
2043         void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
2044         struct net_device_stats *stats = &vptr->dev->stats;
2045         struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
2046         struct rx_desc *rd = &(vptr->rx.ring[idx]);
2047         int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
2048         struct sk_buff *skb;
2049
2050         if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
2051                 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
2052                 stats->rx_length_errors++;
2053                 return -EINVAL;
2054         }
2055
2056         if (rd->rdesc0.RSR & RSR_MAR)
2057                 stats->multicast++;
2058
2059         skb = rd_info->skb;
2060
2061         pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
2062                                     vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
2063
2064         /*
2065          *      Drop frame not meeting IEEE 802.3
2066          */
2067
2068         if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
2069                 if (rd->rdesc0.RSR & RSR_RL) {
2070                         stats->rx_length_errors++;
2071                         return -EINVAL;
2072                 }
2073         }
2074
2075         pci_action = pci_dma_sync_single_for_device;
2076
2077         velocity_rx_csum(rd, skb);
2078
2079         if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
2080                 velocity_iph_realign(vptr, skb, pkt_len);
2081                 pci_action = pci_unmap_single;
2082                 rd_info->skb = NULL;
2083         }
2084
2085         pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
2086                    PCI_DMA_FROMDEVICE);
2087
2088         skb_put(skb, pkt_len - 4);
2089         skb->protocol = eth_type_trans(skb, vptr->dev);
2090
2091         if (vptr->vlgrp && (rd->rdesc0.RSR & RSR_DETAG)) {
2092                 vlan_hwaccel_rx(skb, vptr->vlgrp,
2093                                 swab16(le16_to_cpu(rd->rdesc1.PQTAG)));
2094         } else
2095                 netif_rx(skb);
2096
2097         stats->rx_bytes += pkt_len;
2098
2099         return 0;
2100 }
2101
2102
2103 /**
2104  *      velocity_rx_srv         -       service RX interrupt
2105  *      @vptr: velocity
2106  *      @status: adapter status (unused)
2107  *
2108  *      Walk the receive ring of the velocity adapter and remove
2109  *      any received packets from the receive queue. Hand the ring
2110  *      slots back to the adapter for reuse.
2111  */
2112 static int velocity_rx_srv(struct velocity_info *vptr, int status)
2113 {
2114         struct net_device_stats *stats = &vptr->dev->stats;
2115         int rd_curr = vptr->rx.curr;
2116         int works = 0;
2117
2118         do {
2119                 struct rx_desc *rd = vptr->rx.ring + rd_curr;
2120
2121                 if (!vptr->rx.info[rd_curr].skb)
2122                         break;
2123
2124                 if (rd->rdesc0.len & OWNED_BY_NIC)
2125                         break;
2126
2127                 rmb();
2128
2129                 /*
2130                  *      Don't drop CE or RL error frame although RXOK is off
2131                  */
2132                 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) {
2133                         if (velocity_receive_frame(vptr, rd_curr) < 0)
2134                                 stats->rx_dropped++;
2135                 } else {
2136                         if (rd->rdesc0.RSR & RSR_CRC)
2137                                 stats->rx_crc_errors++;
2138                         if (rd->rdesc0.RSR & RSR_FAE)
2139                                 stats->rx_frame_errors++;
2140
2141                         stats->rx_dropped++;
2142                 }
2143
2144                 rd->size |= RX_INTEN;
2145
2146                 rd_curr++;
2147                 if (rd_curr >= vptr->options.numrx)
2148                         rd_curr = 0;
2149         } while (++works <= 15);
2150
2151         vptr->rx.curr = rd_curr;
2152
2153         if ((works > 0) && (velocity_rx_refill(vptr) > 0))
2154                 velocity_give_many_rx_descs(vptr);
2155
2156         VAR_USED(stats);
2157         return works;
2158 }
2159
2160
2161 /**
2162  *      velocity_intr           -       interrupt callback
2163  *      @irq: interrupt number
2164  *      @dev_instance: interrupting device
2165  *
2166  *      Called whenever an interrupt is generated by the velocity
2167  *      adapter IRQ line. We may not be the source of the interrupt
2168  *      and need to identify initially if we are, and if not exit as
2169  *      efficiently as possible.
2170  */
2171 static irqreturn_t velocity_intr(int irq, void *dev_instance)
2172 {
2173         struct net_device *dev = dev_instance;
2174         struct velocity_info *vptr = netdev_priv(dev);
2175         u32 isr_status;
2176         int max_count = 0;
2177
2178
2179         spin_lock(&vptr->lock);
2180         isr_status = mac_read_isr(vptr->mac_regs);
2181
2182         /* Not us ? */
2183         if (isr_status == 0) {
2184                 spin_unlock(&vptr->lock);
2185                 return IRQ_NONE;
2186         }
2187
2188         mac_disable_int(vptr->mac_regs);
2189
2190         /*
2191          *      Keep processing the ISR until we have completed
2192          *      processing and the isr_status becomes zero
2193          */
2194
2195         while (isr_status != 0) {
2196                 mac_write_isr(vptr->mac_regs, isr_status);
2197                 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2198                         velocity_error(vptr, isr_status);
2199                 if (isr_status & (ISR_PRXI | ISR_PPRXI))
2200                         max_count += velocity_rx_srv(vptr, isr_status);
2201                 if (isr_status & (ISR_PTXI | ISR_PPTXI))
2202                         max_count += velocity_tx_srv(vptr, isr_status);
2203                 isr_status = mac_read_isr(vptr->mac_regs);
2204                 if (max_count > vptr->options.int_works) {
2205                         printk(KERN_WARNING "%s: excessive work at interrupt.\n",
2206                                 dev->name);
2207                         max_count = 0;
2208                 }
2209         }
2210         spin_unlock(&vptr->lock);
2211         mac_enable_int(vptr->mac_regs);
2212         return IRQ_HANDLED;
2213
2214 }
2215
2216 /**
2217  *      velocity_open           -       interface activation callback
2218  *      @dev: network layer device to open
2219  *
2220  *      Called when the network layer brings the interface up. Returns
2221  *      a negative posix error code on failure, or zero on success.
2222  *
2223  *      All the ring allocation and set up is done on open for this
2224  *      adapter to minimise memory usage when inactive
2225  */
2226 static int velocity_open(struct net_device *dev)
2227 {
2228         struct velocity_info *vptr = netdev_priv(dev);
2229         int ret;
2230
2231         ret = velocity_init_rings(vptr, dev->mtu);
2232         if (ret < 0)
2233                 goto out;
2234
2235         /* Ensure chip is running */
2236         pci_set_power_state(vptr->pdev, PCI_D0);
2237
2238         velocity_give_many_rx_descs(vptr);
2239
2240         velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2241
2242         ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
2243                           dev->name, dev);
2244         if (ret < 0) {
2245                 /* Power down the chip */
2246                 pci_set_power_state(vptr->pdev, PCI_D3hot);
2247                 velocity_free_rings(vptr);
2248                 goto out;
2249         }
2250
2251         mac_enable_int(vptr->mac_regs);
2252         netif_start_queue(dev);
2253         vptr->flags |= VELOCITY_FLAGS_OPENED;
2254 out:
2255         return ret;
2256 }
2257
2258 /**
2259  *      velocity_shutdown       -       shut down the chip
2260  *      @vptr: velocity to deactivate
2261  *
2262  *      Shuts down the internal operations of the velocity and
2263  *      disables interrupts, autopolling, transmit and receive
2264  */
2265 static void velocity_shutdown(struct velocity_info *vptr)
2266 {
2267         struct mac_regs __iomem *regs = vptr->mac_regs;
2268         mac_disable_int(regs);
2269         writel(CR0_STOP, &regs->CR0Set);
2270         writew(0xFFFF, &regs->TDCSRClr);
2271         writeb(0xFF, &regs->RDCSRClr);
2272         safe_disable_mii_autopoll(regs);
2273         mac_clear_isr(regs);
2274 }
2275
2276 /**
2277  *      velocity_change_mtu     -       MTU change callback
2278  *      @dev: network device
2279  *      @new_mtu: desired MTU
2280  *
2281  *      Handle requests from the networking layer for MTU change on
2282  *      this interface. It gets called on a change by the network layer.
2283  *      Return zero for success or negative posix error code.
2284  */
2285 static int velocity_change_mtu(struct net_device *dev, int new_mtu)
2286 {
2287         struct velocity_info *vptr = netdev_priv(dev);
2288         int ret = 0;
2289
2290         if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
2291                 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
2292                                 vptr->dev->name);
2293                 ret = -EINVAL;
2294                 goto out_0;
2295         }
2296
2297         if (!netif_running(dev)) {
2298                 dev->mtu = new_mtu;
2299                 goto out_0;
2300         }
2301
2302         if (dev->mtu != new_mtu) {
2303                 struct velocity_info *tmp_vptr;
2304                 unsigned long flags;
2305                 struct rx_info rx;
2306                 struct tx_info tx;
2307
2308                 tmp_vptr = kzalloc(sizeof(*tmp_vptr), GFP_KERNEL);
2309                 if (!tmp_vptr) {
2310                         ret = -ENOMEM;
2311                         goto out_0;
2312                 }
2313
2314                 tmp_vptr->dev = dev;
2315                 tmp_vptr->pdev = vptr->pdev;
2316                 tmp_vptr->options = vptr->options;
2317                 tmp_vptr->tx.numq = vptr->tx.numq;
2318
2319                 ret = velocity_init_rings(tmp_vptr, new_mtu);
2320                 if (ret < 0)
2321                         goto out_free_tmp_vptr_1;
2322
2323                 spin_lock_irqsave(&vptr->lock, flags);
2324
2325                 netif_stop_queue(dev);
2326                 velocity_shutdown(vptr);
2327
2328                 rx = vptr->rx;
2329                 tx = vptr->tx;
2330
2331                 vptr->rx = tmp_vptr->rx;
2332                 vptr->tx = tmp_vptr->tx;
2333
2334                 tmp_vptr->rx = rx;
2335                 tmp_vptr->tx = tx;
2336
2337                 dev->mtu = new_mtu;
2338
2339                 velocity_give_many_rx_descs(vptr);
2340
2341                 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2342
2343                 mac_enable_int(vptr->mac_regs);
2344                 netif_start_queue(dev);
2345
2346                 spin_unlock_irqrestore(&vptr->lock, flags);
2347
2348                 velocity_free_rings(tmp_vptr);
2349
2350 out_free_tmp_vptr_1:
2351                 kfree(tmp_vptr);
2352         }
2353 out_0:
2354         return ret;
2355 }
2356
2357 /**
2358  *      velocity_mii_ioctl              -       MII ioctl handler
2359  *      @dev: network device
2360  *      @ifr: the ifreq block for the ioctl
2361  *      @cmd: the command
2362  *
2363  *      Process MII requests made via ioctl from the network layer. These
2364  *      are used by tools like kudzu to interrogate the link state of the
2365  *      hardware
2366  */
2367 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2368 {
2369         struct velocity_info *vptr = netdev_priv(dev);
2370         struct mac_regs __iomem *regs = vptr->mac_regs;
2371         unsigned long flags;
2372         struct mii_ioctl_data *miidata = if_mii(ifr);
2373         int err;
2374
2375         switch (cmd) {
2376         case SIOCGMIIPHY:
2377                 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
2378                 break;
2379         case SIOCGMIIREG:
2380                 if (velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
2381                         return -ETIMEDOUT;
2382                 break;
2383         case SIOCSMIIREG:
2384                 spin_lock_irqsave(&vptr->lock, flags);
2385                 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
2386                 spin_unlock_irqrestore(&vptr->lock, flags);
2387                 check_connection_type(vptr->mac_regs);
2388                 if (err)
2389                         return err;
2390                 break;
2391         default:
2392                 return -EOPNOTSUPP;
2393         }
2394         return 0;
2395 }
2396
2397
2398 /**
2399  *      velocity_ioctl          -       ioctl entry point
2400  *      @dev: network device
2401  *      @rq: interface request ioctl
2402  *      @cmd: command code
2403  *
2404  *      Called when the user issues an ioctl request to the network
2405  *      device in question. The velocity interface supports MII.
2406  */
2407 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2408 {
2409         struct velocity_info *vptr = netdev_priv(dev);
2410         int ret;
2411
2412         /* If we are asked for information and the device is power
2413            saving then we need to bring the device back up to talk to it */
2414
2415         if (!netif_running(dev))
2416                 pci_set_power_state(vptr->pdev, PCI_D0);
2417
2418         switch (cmd) {
2419         case SIOCGMIIPHY:       /* Get address of MII PHY in use. */
2420         case SIOCGMIIREG:       /* Read MII PHY register. */
2421         case SIOCSMIIREG:       /* Write to MII PHY register. */
2422                 ret = velocity_mii_ioctl(dev, rq, cmd);
2423                 break;
2424
2425         default:
2426                 ret = -EOPNOTSUPP;
2427         }
2428         if (!netif_running(dev))
2429                 pci_set_power_state(vptr->pdev, PCI_D3hot);
2430
2431
2432         return ret;
2433 }
2434
2435 /**
2436  *      velocity_get_status     -       statistics callback
2437  *      @dev: network device
2438  *
2439  *      Callback from the network layer to allow driver statistics
2440  *      to be resynchronized with hardware collected state. In the
2441  *      case of the velocity we need to pull the MIB counters from
2442  *      the hardware into the counters before letting the network
2443  *      layer display them.
2444  */
2445 static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2446 {
2447         struct velocity_info *vptr = netdev_priv(dev);
2448
2449         /* If the hardware is down, don't touch MII */
2450         if (!netif_running(dev))
2451                 return &dev->stats;
2452
2453         spin_lock_irq(&vptr->lock);
2454         velocity_update_hw_mibs(vptr);
2455         spin_unlock_irq(&vptr->lock);
2456
2457         dev->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2458         dev->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2459         dev->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2460
2461 //  unsigned long   rx_dropped;     /* no space in linux buffers    */
2462         dev->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2463         /* detailed rx_errors: */
2464 //  unsigned long   rx_length_errors;
2465 //  unsigned long   rx_over_errors;     /* receiver ring buff overflow  */
2466         dev->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2467 //  unsigned long   rx_frame_errors;    /* recv'd frame alignment error */
2468 //  unsigned long   rx_fifo_errors;     /* recv'r fifo overrun      */
2469 //  unsigned long   rx_missed_errors;   /* receiver missed packet   */
2470
2471         /* detailed tx_errors */
2472 //  unsigned long   tx_fifo_errors;
2473
2474         return &dev->stats;
2475 }
2476
2477 /**
2478  *      velocity_close          -       close adapter callback
2479  *      @dev: network device
2480  *
2481  *      Callback from the network layer when the velocity is being
2482  *      deactivated by the network layer
2483  */
2484 static int velocity_close(struct net_device *dev)
2485 {
2486         struct velocity_info *vptr = netdev_priv(dev);
2487
2488         netif_stop_queue(dev);
2489         velocity_shutdown(vptr);
2490
2491         if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
2492                 velocity_get_ip(vptr);
2493         if (dev->irq != 0)
2494                 free_irq(dev->irq, dev);
2495
2496         /* Power down the chip */
2497         pci_set_power_state(vptr->pdev, PCI_D3hot);
2498
2499         velocity_free_rings(vptr);
2500
2501         vptr->flags &= (~VELOCITY_FLAGS_OPENED);
2502         return 0;
2503 }
2504
2505 /**
2506  *      velocity_xmit           -       transmit packet callback
2507  *      @skb: buffer to transmit
2508  *      @dev: network device
2509  *
2510  *      Called by the networ layer to request a packet is queued to
2511  *      the velocity. Returns zero on success.
2512  */
2513 static netdev_tx_t velocity_xmit(struct sk_buff *skb,
2514                                  struct net_device *dev)
2515 {
2516         struct velocity_info *vptr = netdev_priv(dev);
2517         int qnum = 0;
2518         struct tx_desc *td_ptr;
2519         struct velocity_td_info *tdinfo;
2520         unsigned long flags;
2521         int pktlen;
2522         __le16 len;
2523         int index;
2524
2525         if (skb_padto(skb, ETH_ZLEN))
2526                 goto out;
2527         pktlen = max_t(unsigned int, skb->len, ETH_ZLEN);
2528
2529         len = cpu_to_le16(pktlen);
2530
2531         spin_lock_irqsave(&vptr->lock, flags);
2532
2533         index = vptr->tx.curr[qnum];
2534         td_ptr = &(vptr->tx.rings[qnum][index]);
2535         tdinfo = &(vptr->tx.infos[qnum][index]);
2536
2537         td_ptr->tdesc1.TCR = TCR0_TIC;
2538         td_ptr->td_buf[0].size &= ~TD_QUEUE;
2539
2540         /*
2541          *      Map the linear network buffer into PCI space and
2542          *      add it to the transmit ring.
2543          */
2544         tdinfo->skb = skb;
2545         tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
2546         td_ptr->tdesc0.len = len;
2547         td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2548         td_ptr->td_buf[0].pa_high = 0;
2549         td_ptr->td_buf[0].size = len;
2550         tdinfo->nskb_dma = 1;
2551
2552         td_ptr->tdesc1.cmd = TCPLS_NORMAL + (tdinfo->nskb_dma + 1) * 16;
2553
2554         if (vptr->vlgrp && vlan_tx_tag_present(skb)) {
2555                 td_ptr->tdesc1.vlan = cpu_to_le16(vlan_tx_tag_get(skb));
2556                 td_ptr->tdesc1.TCR |= TCR0_VETAG;
2557         }
2558
2559         /*
2560          *      Handle hardware checksum
2561          */
2562         if ((vptr->flags & VELOCITY_FLAGS_TX_CSUM)
2563                                  && (skb->ip_summed == CHECKSUM_PARTIAL)) {
2564                 const struct iphdr *ip = ip_hdr(skb);
2565                 if (ip->protocol == IPPROTO_TCP)
2566                         td_ptr->tdesc1.TCR |= TCR0_TCPCK;
2567                 else if (ip->protocol == IPPROTO_UDP)
2568                         td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
2569                 td_ptr->tdesc1.TCR |= TCR0_IPCK;
2570         }
2571         {
2572
2573                 int prev = index - 1;
2574
2575                 if (prev < 0)
2576                         prev = vptr->options.numtx - 1;
2577                 td_ptr->tdesc0.len |= OWNED_BY_NIC;
2578                 vptr->tx.used[qnum]++;
2579                 vptr->tx.curr[qnum] = (index + 1) % vptr->options.numtx;
2580
2581                 if (AVAIL_TD(vptr, qnum) < 1)
2582                         netif_stop_queue(dev);
2583
2584                 td_ptr = &(vptr->tx.rings[qnum][prev]);
2585                 td_ptr->td_buf[0].size |= TD_QUEUE;
2586                 mac_tx_queue_wake(vptr->mac_regs, qnum);
2587         }
2588         dev->trans_start = jiffies;
2589         spin_unlock_irqrestore(&vptr->lock, flags);
2590 out:
2591         return NETDEV_TX_OK;
2592 }
2593
2594
2595 static const struct net_device_ops velocity_netdev_ops = {
2596         .ndo_open               = velocity_open,
2597         .ndo_stop               = velocity_close,
2598         .ndo_start_xmit         = velocity_xmit,
2599         .ndo_get_stats          = velocity_get_stats,
2600         .ndo_validate_addr      = eth_validate_addr,
2601         .ndo_set_mac_address    = eth_mac_addr,
2602         .ndo_set_multicast_list = velocity_set_multi,
2603         .ndo_change_mtu         = velocity_change_mtu,
2604         .ndo_do_ioctl           = velocity_ioctl,
2605         .ndo_vlan_rx_add_vid    = velocity_vlan_rx_add_vid,
2606         .ndo_vlan_rx_kill_vid   = velocity_vlan_rx_kill_vid,
2607         .ndo_vlan_rx_register   = velocity_vlan_rx_register,
2608 };
2609
2610 /**
2611  *      velocity_init_info      -       init private data
2612  *      @pdev: PCI device
2613  *      @vptr: Velocity info
2614  *      @info: Board type
2615  *
2616  *      Set up the initial velocity_info struct for the device that has been
2617  *      discovered.
2618  */
2619 static void __devinit velocity_init_info(struct pci_dev *pdev,
2620                                          struct velocity_info *vptr,
2621                                          const struct velocity_info_tbl *info)
2622 {
2623         memset(vptr, 0, sizeof(struct velocity_info));
2624
2625         vptr->pdev = pdev;
2626         vptr->chip_id = info->chip_id;
2627         vptr->tx.numq = info->txqueue;
2628         vptr->multicast_limit = MCAM_SIZE;
2629         spin_lock_init(&vptr->lock);
2630 }
2631
2632 /**
2633  *      velocity_get_pci_info   -       retrieve PCI info for device
2634  *      @vptr: velocity device
2635  *      @pdev: PCI device it matches
2636  *
2637  *      Retrieve the PCI configuration space data that interests us from
2638  *      the kernel PCI layer
2639  */
2640 static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
2641 {
2642         vptr->rev_id = pdev->revision;
2643
2644         pci_set_master(pdev);
2645
2646         vptr->ioaddr = pci_resource_start(pdev, 0);
2647         vptr->memaddr = pci_resource_start(pdev, 1);
2648
2649         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2650                 dev_err(&pdev->dev,
2651                            "region #0 is not an I/O resource, aborting.\n");
2652                 return -EINVAL;
2653         }
2654
2655         if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
2656                 dev_err(&pdev->dev,
2657                            "region #1 is an I/O resource, aborting.\n");
2658                 return -EINVAL;
2659         }
2660
2661         if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
2662                 dev_err(&pdev->dev, "region #1 is too small.\n");
2663                 return -EINVAL;
2664         }
2665         vptr->pdev = pdev;
2666
2667         return 0;
2668 }
2669
2670 /**
2671  *      velocity_print_info     -       per driver data
2672  *      @vptr: velocity
2673  *
2674  *      Print per driver data as the kernel driver finds Velocity
2675  *      hardware
2676  */
2677 static void __devinit velocity_print_info(struct velocity_info *vptr)
2678 {
2679         struct net_device *dev = vptr->dev;
2680
2681         printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
2682         printk(KERN_INFO "%s: Ethernet Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2683                 dev->name,
2684                 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2685                 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2686 }
2687
2688 static u32 velocity_get_link(struct net_device *dev)
2689 {
2690         struct velocity_info *vptr = netdev_priv(dev);
2691         struct mac_regs __iomem *regs = vptr->mac_regs;
2692         return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
2693 }
2694
2695
2696 /**
2697  *      velocity_found1         -       set up discovered velocity card
2698  *      @pdev: PCI device
2699  *      @ent: PCI device table entry that matched
2700  *
2701  *      Configure a discovered adapter from scratch. Return a negative
2702  *      errno error code on failure paths.
2703  */
2704 static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
2705 {
2706         static int first = 1;
2707         struct net_device *dev;
2708         int i;
2709         const char *drv_string;
2710         const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
2711         struct velocity_info *vptr;
2712         struct mac_regs __iomem *regs;
2713         int ret = -ENOMEM;
2714
2715         /* FIXME: this driver, like almost all other ethernet drivers,
2716          * can support more than MAX_UNITS.
2717          */
2718         if (velocity_nics >= MAX_UNITS) {
2719                 dev_notice(&pdev->dev, "already found %d NICs.\n",
2720                            velocity_nics);
2721                 return -ENODEV;
2722         }
2723
2724         dev = alloc_etherdev(sizeof(struct velocity_info));
2725         if (!dev) {
2726                 dev_err(&pdev->dev, "allocate net device failed.\n");
2727                 goto out;
2728         }
2729
2730         /* Chain it all together */
2731
2732         SET_NETDEV_DEV(dev, &pdev->dev);
2733         vptr = netdev_priv(dev);
2734
2735
2736         if (first) {
2737                 printk(KERN_INFO "%s Ver. %s\n",
2738                         VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
2739                 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
2740                 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
2741                 first = 0;
2742         }
2743
2744         velocity_init_info(pdev, vptr, info);
2745
2746         vptr->dev = dev;
2747
2748         dev->irq = pdev->irq;
2749
2750         ret = pci_enable_device(pdev);
2751         if (ret < 0)
2752                 goto err_free_dev;
2753
2754         ret = velocity_get_pci_info(vptr, pdev);
2755         if (ret < 0) {
2756                 /* error message already printed */
2757                 goto err_disable;
2758         }
2759
2760         ret = pci_request_regions(pdev, VELOCITY_NAME);
2761         if (ret < 0) {
2762                 dev_err(&pdev->dev, "No PCI resources.\n");
2763                 goto err_disable;
2764         }
2765
2766         regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
2767         if (regs == NULL) {
2768                 ret = -EIO;
2769                 goto err_release_res;
2770         }
2771
2772         vptr->mac_regs = regs;
2773
2774         mac_wol_reset(regs);
2775
2776         dev->base_addr = vptr->ioaddr;
2777
2778         for (i = 0; i < 6; i++)
2779                 dev->dev_addr[i] = readb(&regs->PAR[i]);
2780
2781
2782         drv_string = dev_driver_string(&pdev->dev);
2783
2784         velocity_get_options(&vptr->options, velocity_nics, drv_string);
2785
2786         /*
2787          *      Mask out the options cannot be set to the chip
2788          */
2789
2790         vptr->options.flags &= info->flags;
2791
2792         /*
2793          *      Enable the chip specified capbilities
2794          */
2795
2796         vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
2797
2798         vptr->wol_opts = vptr->options.wol_opts;
2799         vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
2800
2801         vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
2802
2803         dev->irq = pdev->irq;
2804         dev->netdev_ops = &velocity_netdev_ops;
2805         dev->ethtool_ops = &velocity_ethtool_ops;
2806
2807         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
2808                 NETIF_F_HW_VLAN_RX;
2809
2810         if (vptr->flags & VELOCITY_FLAGS_TX_CSUM)
2811                 dev->features |= NETIF_F_IP_CSUM;
2812
2813         ret = register_netdev(dev);
2814         if (ret < 0)
2815                 goto err_iounmap;
2816
2817         if (!velocity_get_link(dev)) {
2818                 netif_carrier_off(dev);
2819                 vptr->mii_status |= VELOCITY_LINK_FAIL;
2820         }
2821
2822         velocity_print_info(vptr);
2823         pci_set_drvdata(pdev, dev);
2824
2825         /* and leave the chip powered down */
2826
2827         pci_set_power_state(pdev, PCI_D3hot);
2828         velocity_nics++;
2829 out:
2830         return ret;
2831
2832 err_iounmap:
2833         iounmap(regs);
2834 err_release_res:
2835         pci_release_regions(pdev);
2836 err_disable:
2837         pci_disable_device(pdev);
2838 err_free_dev:
2839         free_netdev(dev);
2840         goto out;
2841 }
2842
2843
2844 #ifdef CONFIG_PM
2845 /**
2846  *      wol_calc_crc            -       WOL CRC
2847  *      @pattern: data pattern
2848  *      @mask_pattern: mask
2849  *
2850  *      Compute the wake on lan crc hashes for the packet header
2851  *      we are interested in.
2852  */
2853 static u16 wol_calc_crc(int size, u8 *pattern, u8 *mask_pattern)
2854 {
2855         u16 crc = 0xFFFF;
2856         u8 mask;
2857         int i, j;
2858
2859         for (i = 0; i < size; i++) {
2860                 mask = mask_pattern[i];
2861
2862                 /* Skip this loop if the mask equals to zero */
2863                 if (mask == 0x00)
2864                         continue;
2865
2866                 for (j = 0; j < 8; j++) {
2867                         if ((mask & 0x01) == 0) {
2868                                 mask >>= 1;
2869                                 continue;
2870                         }
2871                         mask >>= 1;
2872                         crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
2873                 }
2874         }
2875         /*      Finally, invert the result once to get the correct data */
2876         crc = ~crc;
2877         return bitrev32(crc) >> 16;
2878 }
2879
2880 /**
2881  *      velocity_set_wol        -       set up for wake on lan
2882  *      @vptr: velocity to set WOL status on
2883  *
2884  *      Set a card up for wake on lan either by unicast or by
2885  *      ARP packet.
2886  *
2887  *      FIXME: check static buffer is safe here
2888  */
2889 static int velocity_set_wol(struct velocity_info *vptr)
2890 {
2891         struct mac_regs __iomem *regs = vptr->mac_regs;
2892         static u8 buf[256];
2893         int i;
2894
2895         static u32 mask_pattern[2][4] = {
2896                 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
2897                 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff}  /* Magic Packet */
2898         };
2899
2900         writew(0xFFFF, &regs->WOLCRClr);
2901         writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
2902         writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
2903
2904         /*
2905            if (vptr->wol_opts & VELOCITY_WOL_PHY)
2906            writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
2907          */
2908
2909         if (vptr->wol_opts & VELOCITY_WOL_UCAST)
2910                 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
2911
2912         if (vptr->wol_opts & VELOCITY_WOL_ARP) {
2913                 struct arp_packet *arp = (struct arp_packet *) buf;
2914                 u16 crc;
2915                 memset(buf, 0, sizeof(struct arp_packet) + 7);
2916
2917                 for (i = 0; i < 4; i++)
2918                         writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
2919
2920                 arp->type = htons(ETH_P_ARP);
2921                 arp->ar_op = htons(1);
2922
2923                 memcpy(arp->ar_tip, vptr->ip_addr, 4);
2924
2925                 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
2926                                 (u8 *) & mask_pattern[0][0]);
2927
2928                 writew(crc, &regs->PatternCRC[0]);
2929                 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
2930         }
2931
2932         BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
2933         BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
2934
2935         writew(0x0FFF, &regs->WOLSRClr);
2936
2937         if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
2938                 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
2939                         MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
2940
2941                 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2942         }
2943
2944         if (vptr->mii_status & VELOCITY_SPEED_1000)
2945                 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
2946
2947         BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2948
2949         {
2950                 u8 GCR;
2951                 GCR = readb(&regs->CHIPGCR);
2952                 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
2953                 writeb(GCR, &regs->CHIPGCR);
2954         }
2955
2956         BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
2957         /* Turn on SWPTAG just before entering power mode */
2958         BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
2959         /* Go to bed ..... */
2960         BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
2961
2962         return 0;
2963 }
2964
2965 /**
2966  *      velocity_save_context   -       save registers
2967  *      @vptr: velocity
2968  *      @context: buffer for stored context
2969  *
2970  *      Retrieve the current configuration from the velocity hardware
2971  *      and stash it in the context structure, for use by the context
2972  *      restore functions. This allows us to save things we need across
2973  *      power down states
2974  */
2975 static void velocity_save_context(struct velocity_info *vptr, struct velocity_context *context)
2976 {
2977         struct mac_regs __iomem *regs = vptr->mac_regs;
2978         u16 i;
2979         u8 __iomem *ptr = (u8 __iomem *)regs;
2980
2981         for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
2982                 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2983
2984         for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
2985                 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2986
2987         for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
2988                 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2989
2990 }
2991
2992 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
2993 {
2994         struct net_device *dev = pci_get_drvdata(pdev);
2995         struct velocity_info *vptr = netdev_priv(dev);
2996         unsigned long flags;
2997
2998         if (!netif_running(vptr->dev))
2999                 return 0;
3000
3001         netif_device_detach(vptr->dev);
3002
3003         spin_lock_irqsave(&vptr->lock, flags);
3004         pci_save_state(pdev);
3005 #ifdef ETHTOOL_GWOL
3006         if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3007                 velocity_get_ip(vptr);
3008                 velocity_save_context(vptr, &vptr->context);
3009                 velocity_shutdown(vptr);
3010                 velocity_set_wol(vptr);
3011                 pci_enable_wake(pdev, PCI_D3hot, 1);
3012                 pci_set_power_state(pdev, PCI_D3hot);
3013         } else {
3014                 velocity_save_context(vptr, &vptr->context);
3015                 velocity_shutdown(vptr);
3016                 pci_disable_device(pdev);
3017                 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3018         }
3019 #else
3020         pci_set_power_state(pdev, pci_choose_state(pdev, state));
3021 #endif
3022         spin_unlock_irqrestore(&vptr->lock, flags);
3023         return 0;
3024 }
3025
3026 /**
3027  *      velocity_restore_context        -       restore registers
3028  *      @vptr: velocity
3029  *      @context: buffer for stored context
3030  *
3031  *      Reload the register configuration from the velocity context
3032  *      created by velocity_save_context.
3033  */
3034 static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
3035 {
3036         struct mac_regs __iomem *regs = vptr->mac_regs;
3037         int i;
3038         u8 __iomem *ptr = (u8 __iomem *)regs;
3039
3040         for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4)
3041                 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3042
3043         /* Just skip cr0 */
3044         for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3045                 /* Clear */
3046                 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3047                 /* Set */
3048                 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3049         }
3050
3051         for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4)
3052                 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3053
3054         for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3055                 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3056
3057         for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++)
3058                 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3059 }
3060
3061 static int velocity_resume(struct pci_dev *pdev)
3062 {
3063         struct net_device *dev = pci_get_drvdata(pdev);
3064         struct velocity_info *vptr = netdev_priv(dev);
3065         unsigned long flags;
3066         int i;
3067
3068         if (!netif_running(vptr->dev))
3069                 return 0;
3070
3071         pci_set_power_state(pdev, PCI_D0);
3072         pci_enable_wake(pdev, 0, 0);
3073         pci_restore_state(pdev);
3074
3075         mac_wol_reset(vptr->mac_regs);
3076
3077         spin_lock_irqsave(&vptr->lock, flags);
3078         velocity_restore_context(vptr, &vptr->context);
3079         velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3080         mac_disable_int(vptr->mac_regs);
3081
3082         velocity_tx_srv(vptr, 0);
3083
3084         for (i = 0; i < vptr->tx.numq; i++) {
3085                 if (vptr->tx.used[i])
3086                         mac_tx_queue_wake(vptr->mac_regs, i);
3087         }
3088
3089         mac_enable_int(vptr->mac_regs);
3090         spin_unlock_irqrestore(&vptr->lock, flags);
3091         netif_device_attach(vptr->dev);
3092
3093         return 0;
3094 }
3095 #endif
3096
3097 /*
3098  *      Definition for our device driver. The PCI layer interface
3099  *      uses this to handle all our card discover and plugging
3100  */
3101 static struct pci_driver velocity_driver = {
3102       .name     = VELOCITY_NAME,
3103       .id_table = velocity_id_table,
3104       .probe    = velocity_found1,
3105       .remove   = __devexit_p(velocity_remove1),
3106 #ifdef CONFIG_PM
3107       .suspend  = velocity_suspend,
3108       .resume   = velocity_resume,
3109 #endif
3110 };
3111
3112
3113 /**
3114  *      velocity_ethtool_up     -       pre hook for ethtool
3115  *      @dev: network device
3116  *
3117  *      Called before an ethtool operation. We need to make sure the
3118  *      chip is out of D3 state before we poke at it.
3119  */
3120 static int velocity_ethtool_up(struct net_device *dev)
3121 {
3122         struct velocity_info *vptr = netdev_priv(dev);
3123         if (!netif_running(dev))
3124                 pci_set_power_state(vptr->pdev, PCI_D0);
3125         return 0;
3126 }
3127
3128 /**
3129  *      velocity_ethtool_down   -       post hook for ethtool
3130  *      @dev: network device
3131  *
3132  *      Called after an ethtool operation. Restore the chip back to D3
3133  *      state if it isn't running.
3134  */
3135 static void velocity_ethtool_down(struct net_device *dev)
3136 {
3137         struct velocity_info *vptr = netdev_priv(dev);
3138         if (!netif_running(dev))
3139                 pci_set_power_state(vptr->pdev, PCI_D3hot);
3140 }
3141
3142 static int velocity_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3143 {
3144         struct velocity_info *vptr = netdev_priv(dev);
3145         struct mac_regs __iomem *regs = vptr->mac_regs;
3146         u32 status;
3147         status = check_connection_type(vptr->mac_regs);
3148
3149         cmd->supported = SUPPORTED_TP |
3150                         SUPPORTED_Autoneg |
3151                         SUPPORTED_10baseT_Half |
3152                         SUPPORTED_10baseT_Full |
3153                         SUPPORTED_100baseT_Half |
3154                         SUPPORTED_100baseT_Full |
3155                         SUPPORTED_1000baseT_Half |
3156                         SUPPORTED_1000baseT_Full;
3157         if (status & VELOCITY_SPEED_1000)
3158                 cmd->speed = SPEED_1000;
3159         else if (status & VELOCITY_SPEED_100)
3160                 cmd->speed = SPEED_100;
3161         else
3162                 cmd->speed = SPEED_10;
3163         cmd->autoneg = (status & VELOCITY_AUTONEG_ENABLE) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3164         cmd->port = PORT_TP;
3165         cmd->transceiver = XCVR_INTERNAL;
3166         cmd->phy_address = readb(&regs->MIIADR) & 0x1F;
3167
3168         if (status & VELOCITY_DUPLEX_FULL)
3169                 cmd->duplex = DUPLEX_FULL;
3170         else
3171                 cmd->duplex = DUPLEX_HALF;
3172
3173         return 0;
3174 }
3175
3176 static int velocity_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3177 {
3178         struct velocity_info *vptr = netdev_priv(dev);
3179         u32 curr_status;
3180         u32 new_status = 0;
3181         int ret = 0;
3182
3183         curr_status = check_connection_type(vptr->mac_regs);
3184         curr_status &= (~VELOCITY_LINK_FAIL);
3185
3186         new_status |= ((cmd->autoneg) ? VELOCITY_AUTONEG_ENABLE : 0);
3187         new_status |= ((cmd->speed == SPEED_100) ? VELOCITY_SPEED_100 : 0);
3188         new_status |= ((cmd->speed == SPEED_10) ? VELOCITY_SPEED_10 : 0);
3189         new_status |= ((cmd->duplex == DUPLEX_FULL) ? VELOCITY_DUPLEX_FULL : 0);
3190
3191         if ((new_status & VELOCITY_AUTONEG_ENABLE) && (new_status != (curr_status | VELOCITY_AUTONEG_ENABLE)))
3192                 ret = -EINVAL;
3193         else
3194                 velocity_set_media_mode(vptr, new_status);
3195
3196         return ret;
3197 }
3198
3199 static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3200 {
3201         struct velocity_info *vptr = netdev_priv(dev);
3202         strcpy(info->driver, VELOCITY_NAME);
3203         strcpy(info->version, VELOCITY_VERSION);
3204         strcpy(info->bus_info, pci_name(vptr->pdev));
3205 }
3206
3207 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3208 {
3209         struct velocity_info *vptr = netdev_priv(dev);
3210         wol->supported = WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP;
3211         wol->wolopts |= WAKE_MAGIC;
3212         /*
3213            if (vptr->wol_opts & VELOCITY_WOL_PHY)
3214                    wol.wolopts|=WAKE_PHY;
3215                          */
3216         if (vptr->wol_opts & VELOCITY_WOL_UCAST)
3217                 wol->wolopts |= WAKE_UCAST;
3218         if (vptr->wol_opts & VELOCITY_WOL_ARP)
3219                 wol->wolopts |= WAKE_ARP;
3220         memcpy(&wol->sopass, vptr->wol_passwd, 6);
3221 }
3222
3223 static int velocity_ethtool_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3224 {
3225         struct velocity_info *vptr = netdev_priv(dev);
3226
3227         if (!(wol->wolopts & (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP)))
3228                 return -EFAULT;
3229         vptr->wol_opts = VELOCITY_WOL_MAGIC;
3230
3231         /*
3232            if (wol.wolopts & WAKE_PHY) {
3233            vptr->wol_opts|=VELOCITY_WOL_PHY;
3234            vptr->flags |=VELOCITY_FLAGS_WOL_ENABLED;
3235            }
3236          */
3237
3238         if (wol->wolopts & WAKE_MAGIC) {
3239                 vptr->wol_opts |= VELOCITY_WOL_MAGIC;
3240                 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3241         }
3242         if (wol->wolopts & WAKE_UCAST) {
3243                 vptr->wol_opts |= VELOCITY_WOL_UCAST;
3244                 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3245         }
3246         if (wol->wolopts & WAKE_ARP) {
3247                 vptr->wol_opts |= VELOCITY_WOL_ARP;
3248                 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3249         }
3250         memcpy(vptr->wol_passwd, wol->sopass, 6);
3251         return 0;
3252 }
3253
3254 static u32 velocity_get_msglevel(struct net_device *dev)
3255 {
3256         return msglevel;
3257 }
3258
3259 static void velocity_set_msglevel(struct net_device *dev, u32 value)
3260 {
3261          msglevel = value;
3262 }
3263
3264 static int get_pending_timer_val(int val)
3265 {
3266         int mult_bits = val >> 6;
3267         int mult = 1;
3268
3269         switch (mult_bits)
3270         {
3271         case 1:
3272                 mult = 4; break;
3273         case 2:
3274                 mult = 16; break;
3275         case 3:
3276                 mult = 64; break;
3277         case 0:
3278         default:
3279                 break;
3280         }
3281
3282         return (val & 0x3f) * mult;
3283 }
3284
3285 static void set_pending_timer_val(int *val, u32 us)
3286 {
3287         u8 mult = 0;
3288         u8 shift = 0;
3289
3290         if (us >= 0x3f) {
3291                 mult = 1; /* mult with 4 */
3292                 shift = 2;
3293         }
3294         if (us >= 0x3f * 4) {
3295                 mult = 2; /* mult with 16 */
3296                 shift = 4;
3297         }
3298         if (us >= 0x3f * 16) {
3299                 mult = 3; /* mult with 64 */
3300                 shift = 6;
3301         }
3302
3303         *val = (mult << 6) | ((us >> shift) & 0x3f);
3304 }
3305
3306
3307 static int velocity_get_coalesce(struct net_device *dev,
3308                 struct ethtool_coalesce *ecmd)
3309 {
3310         struct velocity_info *vptr = netdev_priv(dev);
3311
3312         ecmd->tx_max_coalesced_frames = vptr->options.tx_intsup;
3313         ecmd->rx_max_coalesced_frames = vptr->options.rx_intsup;
3314
3315         ecmd->rx_coalesce_usecs = get_pending_timer_val(vptr->options.rxqueue_timer);
3316         ecmd->tx_coalesce_usecs = get_pending_timer_val(vptr->options.txqueue_timer);
3317
3318         return 0;
3319 }
3320
3321 static int velocity_set_coalesce(struct net_device *dev,
3322                 struct ethtool_coalesce *ecmd)
3323 {
3324         struct velocity_info *vptr = netdev_priv(dev);
3325         int max_us = 0x3f * 64;
3326
3327         /* 6 bits of  */
3328         if (ecmd->tx_coalesce_usecs > max_us)
3329                 return -EINVAL;
3330         if (ecmd->rx_coalesce_usecs > max_us)
3331                 return -EINVAL;
3332
3333         if (ecmd->tx_max_coalesced_frames > 0xff)
3334                 return -EINVAL;
3335         if (ecmd->rx_max_coalesced_frames > 0xff)
3336                 return -EINVAL;
3337
3338         vptr->options.rx_intsup = ecmd->rx_max_coalesced_frames;
3339         vptr->options.tx_intsup = ecmd->tx_max_coalesced_frames;
3340
3341         set_pending_timer_val(&vptr->options.rxqueue_timer,
3342                         ecmd->rx_coalesce_usecs);
3343         set_pending_timer_val(&vptr->options.txqueue_timer,
3344                         ecmd->tx_coalesce_usecs);
3345
3346         /* Setup the interrupt suppression and queue timers */
3347         mac_disable_int(vptr->mac_regs);
3348         setup_adaptive_interrupts(vptr);
3349         setup_queue_timers(vptr);
3350
3351         mac_write_int_mask(vptr->int_mask, vptr->mac_regs);
3352         mac_clear_isr(vptr->mac_regs);
3353         mac_enable_int(vptr->mac_regs);
3354
3355         return 0;
3356 }
3357
3358 static const struct ethtool_ops velocity_ethtool_ops = {
3359         .get_settings   =       velocity_get_settings,
3360         .set_settings   =       velocity_set_settings,
3361         .get_drvinfo    =       velocity_get_drvinfo,
3362         .get_wol        =       velocity_ethtool_get_wol,
3363         .set_wol        =       velocity_ethtool_set_wol,
3364         .get_msglevel   =       velocity_get_msglevel,
3365         .set_msglevel   =       velocity_set_msglevel,
3366         .get_link       =       velocity_get_link,
3367         .get_coalesce   =       velocity_get_coalesce,
3368         .set_coalesce   =       velocity_set_coalesce,
3369         .begin          =       velocity_ethtool_up,
3370         .complete       =       velocity_ethtool_down
3371 };
3372
3373 #ifdef CONFIG_PM
3374 #ifdef CONFIG_INET
3375 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3376 {
3377         struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3378         struct net_device *dev = ifa->ifa_dev->dev;
3379
3380         if (dev_net(dev) == &init_net &&
3381             dev->netdev_ops == &velocity_netdev_ops)
3382                 velocity_get_ip(netdev_priv(dev));
3383
3384         return NOTIFY_DONE;
3385 }
3386 #endif  /* CONFIG_INET */
3387 #endif  /* CONFIG_PM */
3388
3389 #if defined(CONFIG_PM) && defined(CONFIG_INET)
3390 static struct notifier_block velocity_inetaddr_notifier = {
3391       .notifier_call    = velocity_netdev_event,
3392 };
3393
3394 static void velocity_register_notifier(void)
3395 {
3396         register_inetaddr_notifier(&velocity_inetaddr_notifier);
3397 }
3398
3399 static void velocity_unregister_notifier(void)
3400 {
3401         unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
3402 }
3403
3404 #else
3405
3406 #define velocity_register_notifier()    do {} while (0)
3407 #define velocity_unregister_notifier()  do {} while (0)
3408
3409 #endif  /* defined(CONFIG_PM) && defined(CONFIG_INET) */
3410
3411 /**
3412  *      velocity_init_module    -       load time function
3413  *
3414  *      Called when the velocity module is loaded. The PCI driver
3415  *      is registered with the PCI layer, and in turn will call
3416  *      the probe functions for each velocity adapter installed
3417  *      in the system.
3418  */
3419 static int __init velocity_init_module(void)
3420 {
3421         int ret;
3422
3423         velocity_register_notifier();
3424         ret = pci_register_driver(&velocity_driver);
3425         if (ret < 0)
3426                 velocity_unregister_notifier();
3427         return ret;
3428 }
3429
3430 /**
3431  *      velocity_cleanup        -       module unload
3432  *
3433  *      When the velocity hardware is unloaded this function is called.
3434  *      It will clean up the notifiers and the unregister the PCI
3435  *      driver interface for this hardware. This in turn cleans up
3436  *      all discovered interfaces before returning from the function
3437  */
3438 static void __exit velocity_cleanup_module(void)
3439 {
3440         velocity_unregister_notifier();
3441         pci_unregister_driver(&velocity_driver);
3442 }
3443
3444 module_init(velocity_init_module);
3445 module_exit(velocity_cleanup_module);