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