pcmcia: CompactFlash driver for PA Semi Electra boards
[pv_ops_mirror.git] / drivers / net / via-velocity.c
blob4ae05799ac447b571412990d6fd9c7f2bdfc2ac2
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.
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.
10 * TODO
11 * Big-endian support
12 * rx_copybreak/alignment
13 * Scatter gather
14 * More testing
16 * The changes are (c) Copyright 2004, Red Hat Inc. <alan@redhat.com>
17 * Additional fixes and clean up: Francois Romieu
19 * This source has not been verified for use in safety critical systems.
21 * Please direct queries about the revamped driver to the linux-kernel
22 * list not VIA.
24 * Original code:
26 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
27 * All rights reserved.
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.
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.
39 * Author: Chuang Liang-Shing, AJ Jiang
41 * Date: Jan 24, 2003
43 * MODULE_LICENSE("GPL");
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/if_vlan.h>
76 #include <linux/ip.h>
77 #include <linux/tcp.h>
78 #include <linux/udp.h>
79 #include <linux/crc-ccitt.h>
80 #include <linux/crc32.h>
82 #include "via-velocity.h"
85 static int velocity_nics = 0;
86 static int msglevel = MSG_LEVEL_INFO;
88 /**
89 * mac_get_cam_mask - Read a CAM mask
90 * @regs: register block for this velocity
91 * @mask: buffer to store mask
93 * Fetch the mask bits of the selected CAM and store them into the
94 * provided mask buffer.
97 static void mac_get_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
99 int i;
101 /* Select CAM mask */
102 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
104 writeb(0, &regs->CAMADDR);
106 /* read mask */
107 for (i = 0; i < 8; i++)
108 *mask++ = readb(&(regs->MARCAM[i]));
110 /* disable CAMEN */
111 writeb(0, &regs->CAMADDR);
113 /* Select mar */
114 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
120 * mac_set_cam_mask - Set a CAM mask
121 * @regs: register block for this velocity
122 * @mask: CAM mask to load
124 * Store a new mask into a CAM
127 static void mac_set_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
129 int i;
130 /* Select CAM mask */
131 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
133 writeb(CAMADDR_CAMEN, &regs->CAMADDR);
135 for (i = 0; i < 8; i++) {
136 writeb(*mask++, &(regs->MARCAM[i]));
138 /* disable CAMEN */
139 writeb(0, &regs->CAMADDR);
141 /* Select mar */
142 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
145 static void mac_set_vlan_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
147 int i;
148 /* Select CAM mask */
149 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
151 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL, &regs->CAMADDR);
153 for (i = 0; i < 8; i++) {
154 writeb(*mask++, &(regs->MARCAM[i]));
156 /* disable CAMEN */
157 writeb(0, &regs->CAMADDR);
159 /* Select mar */
160 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
164 * mac_set_cam - set CAM data
165 * @regs: register block of this velocity
166 * @idx: Cam index
167 * @addr: 2 or 6 bytes of CAM data
169 * Load an address or vlan tag into a CAM
172 static void mac_set_cam(struct mac_regs __iomem * regs, int idx, const u8 *addr)
174 int i;
176 /* Select CAM mask */
177 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
179 idx &= (64 - 1);
181 writeb(CAMADDR_CAMEN | idx, &regs->CAMADDR);
183 for (i = 0; i < 6; i++) {
184 writeb(*addr++, &(regs->MARCAM[i]));
186 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
188 udelay(10);
190 writeb(0, &regs->CAMADDR);
192 /* Select mar */
193 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
196 static void mac_set_vlan_cam(struct mac_regs __iomem * regs, int idx,
197 const u8 *addr)
200 /* Select CAM mask */
201 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
203 idx &= (64 - 1);
205 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL | idx, &regs->CAMADDR);
206 writew(*((u16 *) addr), &regs->MARCAM[0]);
208 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
210 udelay(10);
212 writeb(0, &regs->CAMADDR);
214 /* Select mar */
215 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
220 * mac_wol_reset - reset WOL after exiting low power
221 * @regs: register block of this velocity
223 * Called after we drop out of wake on lan mode in order to
224 * reset the Wake on lan features. This function doesn't restore
225 * the rest of the logic from the result of sleep/wakeup
228 static void mac_wol_reset(struct mac_regs __iomem * regs)
231 /* Turn off SWPTAG right after leaving power mode */
232 BYTE_REG_BITS_OFF(STICKHW_SWPTAG, &regs->STICKHW);
233 /* clear sticky bits */
234 BYTE_REG_BITS_OFF((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
236 BYTE_REG_BITS_OFF(CHIPGCR_FCGMII, &regs->CHIPGCR);
237 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
238 /* disable force PME-enable */
239 writeb(WOLCFG_PMEOVR, &regs->WOLCFGClr);
240 /* disable power-event config bit */
241 writew(0xFFFF, &regs->WOLCRClr);
242 /* clear power status */
243 writew(0xFFFF, &regs->WOLSRClr);
246 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
247 static const struct ethtool_ops velocity_ethtool_ops;
250 Define module options
253 MODULE_AUTHOR("VIA Networking Technologies, Inc.");
254 MODULE_LICENSE("GPL");
255 MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
257 #define VELOCITY_PARAM(N,D) \
258 static int N[MAX_UNITS]=OPTION_DEFAULT;\
259 module_param_array(N, int, NULL, 0); \
260 MODULE_PARM_DESC(N, D);
262 #define RX_DESC_MIN 64
263 #define RX_DESC_MAX 255
264 #define RX_DESC_DEF 64
265 VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
267 #define TX_DESC_MIN 16
268 #define TX_DESC_MAX 256
269 #define TX_DESC_DEF 64
270 VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
272 #define RX_THRESH_MIN 0
273 #define RX_THRESH_MAX 3
274 #define RX_THRESH_DEF 0
275 /* rx_thresh[] is used for controlling the receive fifo threshold.
276 0: indicate the rxfifo threshold is 128 bytes.
277 1: indicate the rxfifo threshold is 512 bytes.
278 2: indicate the rxfifo threshold is 1024 bytes.
279 3: indicate the rxfifo threshold is store & forward.
281 VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
283 #define DMA_LENGTH_MIN 0
284 #define DMA_LENGTH_MAX 7
285 #define DMA_LENGTH_DEF 0
287 /* DMA_length[] is used for controlling the DMA length
288 0: 8 DWORDs
289 1: 16 DWORDs
290 2: 32 DWORDs
291 3: 64 DWORDs
292 4: 128 DWORDs
293 5: 256 DWORDs
294 6: SF(flush till emply)
295 7: SF(flush till emply)
297 VELOCITY_PARAM(DMA_length, "DMA length");
299 #define IP_ALIG_DEF 0
300 /* IP_byte_align[] is used for IP header DWORD byte aligned
301 0: indicate the IP header won't be DWORD byte aligned.(Default) .
302 1: indicate the IP header will be DWORD byte aligned.
303 In some enviroment, the IP header should be DWORD byte aligned,
304 or the packet will be droped when we receive it. (eg: IPVS)
306 VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
308 #define TX_CSUM_DEF 1
309 /* txcsum_offload[] is used for setting the checksum offload ability of NIC.
310 (We only support RX checksum offload now)
311 0: disable csum_offload[checksum offload
312 1: enable checksum offload. (Default)
314 VELOCITY_PARAM(txcsum_offload, "Enable transmit packet checksum offload");
316 #define FLOW_CNTL_DEF 1
317 #define FLOW_CNTL_MIN 1
318 #define FLOW_CNTL_MAX 5
320 /* flow_control[] is used for setting the flow control ability of NIC.
321 1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
322 2: enable TX flow control.
323 3: enable RX flow control.
324 4: enable RX/TX flow control.
325 5: disable
327 VELOCITY_PARAM(flow_control, "Enable flow control ability");
329 #define MED_LNK_DEF 0
330 #define MED_LNK_MIN 0
331 #define MED_LNK_MAX 4
332 /* speed_duplex[] is used for setting the speed and duplex mode of NIC.
333 0: indicate autonegotiation for both speed and duplex mode
334 1: indicate 100Mbps half duplex mode
335 2: indicate 100Mbps full duplex mode
336 3: indicate 10Mbps half duplex mode
337 4: indicate 10Mbps full duplex mode
339 Note:
340 if EEPROM have been set to the force mode, this option is ignored
341 by driver.
343 VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
345 #define VAL_PKT_LEN_DEF 0
346 /* ValPktLen[] is used for setting the checksum offload ability of NIC.
347 0: Receive frame with invalid layer 2 length (Default)
348 1: Drop frame with invalid layer 2 length
350 VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
352 #define WOL_OPT_DEF 0
353 #define WOL_OPT_MIN 0
354 #define WOL_OPT_MAX 7
355 /* wol_opts[] is used for controlling wake on lan behavior.
356 0: Wake up if recevied a magic packet. (Default)
357 1: Wake up if link status is on/off.
358 2: Wake up if recevied an arp packet.
359 4: Wake up if recevied any unicast packet.
360 Those value can be sumed up to support more than one option.
362 VELOCITY_PARAM(wol_opts, "Wake On Lan options");
364 #define INT_WORKS_DEF 20
365 #define INT_WORKS_MIN 10
366 #define INT_WORKS_MAX 64
368 VELOCITY_PARAM(int_works, "Number of packets per interrupt services");
370 static int rx_copybreak = 200;
371 module_param(rx_copybreak, int, 0644);
372 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
374 static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
375 const struct velocity_info_tbl *info);
376 static int velocity_get_pci_info(struct velocity_info *, struct pci_dev *pdev);
377 static void velocity_print_info(struct velocity_info *vptr);
378 static int velocity_open(struct net_device *dev);
379 static int velocity_change_mtu(struct net_device *dev, int mtu);
380 static int velocity_xmit(struct sk_buff *skb, struct net_device *dev);
381 static int velocity_intr(int irq, void *dev_instance);
382 static void velocity_set_multi(struct net_device *dev);
383 static struct net_device_stats *velocity_get_stats(struct net_device *dev);
384 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
385 static int velocity_close(struct net_device *dev);
386 static int velocity_receive_frame(struct velocity_info *, int idx);
387 static int velocity_alloc_rx_buf(struct velocity_info *, int idx);
388 static void velocity_free_rd_ring(struct velocity_info *vptr);
389 static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *);
390 static int velocity_soft_reset(struct velocity_info *vptr);
391 static void mii_init(struct velocity_info *vptr, u32 mii_status);
392 static u32 velocity_get_link(struct net_device *dev);
393 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr);
394 static void velocity_print_link_status(struct velocity_info *vptr);
395 static void safe_disable_mii_autopoll(struct mac_regs __iomem * regs);
396 static void velocity_shutdown(struct velocity_info *vptr);
397 static void enable_flow_control_ability(struct velocity_info *vptr);
398 static void enable_mii_autopoll(struct mac_regs __iomem * regs);
399 static int velocity_mii_read(struct mac_regs __iomem *, u8 byIdx, u16 * pdata);
400 static int velocity_mii_write(struct mac_regs __iomem *, u8 byMiiAddr, u16 data);
401 static u32 mii_check_media_mode(struct mac_regs __iomem * regs);
402 static u32 check_connection_type(struct mac_regs __iomem * regs);
403 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status);
405 #ifdef CONFIG_PM
407 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state);
408 static int velocity_resume(struct pci_dev *pdev);
410 static DEFINE_SPINLOCK(velocity_dev_list_lock);
411 static LIST_HEAD(velocity_dev_list);
413 #endif
415 #if defined(CONFIG_PM) && defined(CONFIG_INET)
417 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr);
419 static struct notifier_block velocity_inetaddr_notifier = {
420 .notifier_call = velocity_netdev_event,
423 static void velocity_register_notifier(void)
425 register_inetaddr_notifier(&velocity_inetaddr_notifier);
428 static void velocity_unregister_notifier(void)
430 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
433 #else
435 #define velocity_register_notifier() do {} while (0)
436 #define velocity_unregister_notifier() do {} while (0)
438 #endif
441 * Internal board variants. At the moment we have only one
444 static const struct velocity_info_tbl chip_info_table[] __devinitdata = {
445 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
450 * Describe the PCI device identifiers that we support in this
451 * device driver. Used for hotplug autoloading.
454 static const struct pci_device_id velocity_id_table[] __devinitdata = {
455 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
459 MODULE_DEVICE_TABLE(pci, velocity_id_table);
462 * get_chip_name - identifier to name
463 * @id: chip identifier
465 * Given a chip identifier return a suitable description. Returns
466 * a pointer a static string valid while the driver is loaded.
469 static const char __devinit *get_chip_name(enum chip_type chip_id)
471 int i;
472 for (i = 0; chip_info_table[i].name != NULL; i++)
473 if (chip_info_table[i].chip_id == chip_id)
474 break;
475 return chip_info_table[i].name;
479 * velocity_remove1 - device unplug
480 * @pdev: PCI device being removed
482 * Device unload callback. Called on an unplug or on module
483 * unload for each active device that is present. Disconnects
484 * the device from the network layer and frees all the resources
487 static void __devexit velocity_remove1(struct pci_dev *pdev)
489 struct net_device *dev = pci_get_drvdata(pdev);
490 struct velocity_info *vptr = netdev_priv(dev);
492 #ifdef CONFIG_PM
493 unsigned long flags;
495 spin_lock_irqsave(&velocity_dev_list_lock, flags);
496 if (!list_empty(&velocity_dev_list))
497 list_del(&vptr->list);
498 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
499 #endif
500 unregister_netdev(dev);
501 iounmap(vptr->mac_regs);
502 pci_release_regions(pdev);
503 pci_disable_device(pdev);
504 pci_set_drvdata(pdev, NULL);
505 free_netdev(dev);
507 velocity_nics--;
511 * velocity_set_int_opt - parser for integer options
512 * @opt: pointer to option value
513 * @val: value the user requested (or -1 for default)
514 * @min: lowest value allowed
515 * @max: highest value allowed
516 * @def: default value
517 * @name: property name
518 * @dev: device name
520 * Set an integer property in the module options. This function does
521 * all the verification and checking as well as reporting so that
522 * we don't duplicate code for each option.
525 static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, char *devname)
527 if (val == -1)
528 *opt = def;
529 else if (val < min || val > max) {
530 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
531 devname, name, min, max);
532 *opt = def;
533 } else {
534 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
535 devname, name, val);
536 *opt = val;
541 * velocity_set_bool_opt - parser for boolean options
542 * @opt: pointer to option value
543 * @val: value the user requested (or -1 for default)
544 * @def: default value (yes/no)
545 * @flag: numeric value to set for true.
546 * @name: property name
547 * @dev: device name
549 * Set a boolean property in the module options. This function does
550 * all the verification and checking as well as reporting so that
551 * we don't duplicate code for each option.
554 static void __devinit velocity_set_bool_opt(u32 * opt, int val, int def, u32 flag, char *name, char *devname)
556 (*opt) &= (~flag);
557 if (val == -1)
558 *opt |= (def ? flag : 0);
559 else if (val < 0 || val > 1) {
560 printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
561 devname, name);
562 *opt |= (def ? flag : 0);
563 } else {
564 printk(KERN_INFO "%s: set parameter %s to %s\n",
565 devname, name, val ? "TRUE" : "FALSE");
566 *opt |= (val ? flag : 0);
571 * velocity_get_options - set options on device
572 * @opts: option structure for the device
573 * @index: index of option to use in module options array
574 * @devname: device name
576 * Turn the module and command options into a single structure
577 * for the current device
580 static void __devinit velocity_get_options(struct velocity_opt *opts, int index, char *devname)
583 velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
584 velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
585 velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
586 velocity_set_int_opt(&opts->numtx, TxDescriptors[index], TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF, "TxDescriptors", devname);
588 velocity_set_bool_opt(&opts->flags, txcsum_offload[index], TX_CSUM_DEF, VELOCITY_FLAGS_TX_CSUM, "txcsum_offload", devname);
589 velocity_set_int_opt(&opts->flow_cntl, flow_control[index], FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF, "flow_control", devname);
590 velocity_set_bool_opt(&opts->flags, IP_byte_align[index], IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN, "IP_byte_align", devname);
591 velocity_set_bool_opt(&opts->flags, ValPktLen[index], VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN, "ValPktLen", devname);
592 velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index], MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF, "Media link mode", devname);
593 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);
594 velocity_set_int_opt((int *) &opts->int_works, int_works[index], INT_WORKS_MIN, INT_WORKS_MAX, INT_WORKS_DEF, "Interrupt service works", devname);
595 opts->numrx = (opts->numrx & ~3);
599 * velocity_init_cam_filter - initialise CAM
600 * @vptr: velocity to program
602 * Initialize the content addressable memory used for filters. Load
603 * appropriately according to the presence of VLAN
606 static void velocity_init_cam_filter(struct velocity_info *vptr)
608 struct mac_regs __iomem * regs = vptr->mac_regs;
609 unsigned short vid;
611 /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
612 WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
613 WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
615 /* Disable all CAMs */
616 memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
617 memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
618 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
619 mac_set_cam_mask(regs, vptr->mCAMmask);
621 /* Enable first VCAM */
622 if (vptr->vlgrp) {
623 for (vid = 0; vid < VLAN_VID_MASK; vid++) {
624 if (vlan_group_get_device(vptr->vlgrp, vid)) {
625 /* If Tagging option is enabled and
626 VLAN ID is not zero, then
627 turn on MCFG_RTGOPT also */
628 if (vid != 0)
629 WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
631 mac_set_vlan_cam(regs, 0, (u8 *) &vid);
634 vptr->vCAMmask[0] |= 1;
635 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
636 } else {
637 u16 temp = 0;
638 mac_set_vlan_cam(regs, 0, (u8 *) &temp);
639 temp = 1;
640 mac_set_vlan_cam_mask(regs, (u8 *) &temp);
644 static void velocity_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
646 struct velocity_info *vptr = netdev_priv(dev);
648 spin_lock_irq(&vptr->lock);
649 velocity_init_cam_filter(vptr);
650 spin_unlock_irq(&vptr->lock);
653 static void velocity_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
655 struct velocity_info *vptr = netdev_priv(dev);
657 spin_lock_irq(&vptr->lock);
658 vlan_group_set_device(vptr->vlgrp, vid, NULL);
659 velocity_init_cam_filter(vptr);
660 spin_unlock_irq(&vptr->lock);
665 * velocity_rx_reset - handle a receive reset
666 * @vptr: velocity we are resetting
668 * Reset the ownership and status for the receive ring side.
669 * Hand all the receive queue to the NIC.
672 static void velocity_rx_reset(struct velocity_info *vptr)
675 struct mac_regs __iomem * regs = vptr->mac_regs;
676 int i;
678 vptr->rd_dirty = vptr->rd_filled = vptr->rd_curr = 0;
681 * Init state, all RD entries belong to the NIC
683 for (i = 0; i < vptr->options.numrx; ++i)
684 vptr->rd_ring[i].rdesc0.owner = OWNED_BY_NIC;
686 writew(vptr->options.numrx, &regs->RBRDU);
687 writel(vptr->rd_pool_dma, &regs->RDBaseLo);
688 writew(0, &regs->RDIdx);
689 writew(vptr->options.numrx - 1, &regs->RDCSize);
693 * velocity_init_registers - initialise MAC registers
694 * @vptr: velocity to init
695 * @type: type of initialisation (hot or cold)
697 * Initialise the MAC on a reset or on first set up on the
698 * hardware.
701 static void velocity_init_registers(struct velocity_info *vptr,
702 enum velocity_init_type type)
704 struct mac_regs __iomem * regs = vptr->mac_regs;
705 int i, mii_status;
707 mac_wol_reset(regs);
709 switch (type) {
710 case VELOCITY_INIT_RESET:
711 case VELOCITY_INIT_WOL:
713 netif_stop_queue(vptr->dev);
716 * Reset RX to prevent RX pointer not on the 4X location
718 velocity_rx_reset(vptr);
719 mac_rx_queue_run(regs);
720 mac_rx_queue_wake(regs);
722 mii_status = velocity_get_opt_media_mode(vptr);
723 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
724 velocity_print_link_status(vptr);
725 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
726 netif_wake_queue(vptr->dev);
729 enable_flow_control_ability(vptr);
731 mac_clear_isr(regs);
732 writel(CR0_STOP, &regs->CR0Clr);
733 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
734 &regs->CR0Set);
736 break;
738 case VELOCITY_INIT_COLD:
739 default:
741 * Do reset
743 velocity_soft_reset(vptr);
744 mdelay(5);
746 mac_eeprom_reload(regs);
747 for (i = 0; i < 6; i++) {
748 writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
751 * clear Pre_ACPI bit.
753 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
754 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
755 mac_set_dma_length(regs, vptr->options.DMA_length);
757 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
759 * Back off algorithm use original IEEE standard
761 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
764 * Init CAM filter
766 velocity_init_cam_filter(vptr);
769 * Set packet filter: Receive directed and broadcast address
771 velocity_set_multi(vptr->dev);
774 * Enable MII auto-polling
776 enable_mii_autopoll(regs);
778 vptr->int_mask = INT_MASK_DEF;
780 writel(cpu_to_le32(vptr->rd_pool_dma), &regs->RDBaseLo);
781 writew(vptr->options.numrx - 1, &regs->RDCSize);
782 mac_rx_queue_run(regs);
783 mac_rx_queue_wake(regs);
785 writew(vptr->options.numtx - 1, &regs->TDCSize);
787 for (i = 0; i < vptr->num_txq; i++) {
788 writel(cpu_to_le32(vptr->td_pool_dma[i]), &(regs->TDBaseLo[i]));
789 mac_tx_queue_run(regs, i);
792 init_flow_control_register(vptr);
794 writel(CR0_STOP, &regs->CR0Clr);
795 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
797 mii_status = velocity_get_opt_media_mode(vptr);
798 netif_stop_queue(vptr->dev);
800 mii_init(vptr, mii_status);
802 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
803 velocity_print_link_status(vptr);
804 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
805 netif_wake_queue(vptr->dev);
808 enable_flow_control_ability(vptr);
809 mac_hw_mibs_init(regs);
810 mac_write_int_mask(vptr->int_mask, regs);
811 mac_clear_isr(regs);
817 * velocity_soft_reset - soft reset
818 * @vptr: velocity to reset
820 * Kick off a soft reset of the velocity adapter and then poll
821 * until the reset sequence has completed before returning.
824 static int velocity_soft_reset(struct velocity_info *vptr)
826 struct mac_regs __iomem * regs = vptr->mac_regs;
827 int i = 0;
829 writel(CR0_SFRST, &regs->CR0Set);
831 for (i = 0; i < W_MAX_TIMEOUT; i++) {
832 udelay(5);
833 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
834 break;
837 if (i == W_MAX_TIMEOUT) {
838 writel(CR0_FORSRST, &regs->CR0Set);
839 /* FIXME: PCI POSTING */
840 /* delay 2ms */
841 mdelay(2);
843 return 0;
847 * velocity_found1 - set up discovered velocity card
848 * @pdev: PCI device
849 * @ent: PCI device table entry that matched
851 * Configure a discovered adapter from scratch. Return a negative
852 * errno error code on failure paths.
855 static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
857 static int first = 1;
858 struct net_device *dev;
859 int i;
860 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
861 struct velocity_info *vptr;
862 struct mac_regs __iomem * regs;
863 int ret = -ENOMEM;
865 /* FIXME: this driver, like almost all other ethernet drivers,
866 * can support more than MAX_UNITS.
868 if (velocity_nics >= MAX_UNITS) {
869 dev_notice(&pdev->dev, "already found %d NICs.\n",
870 velocity_nics);
871 return -ENODEV;
874 dev = alloc_etherdev(sizeof(struct velocity_info));
875 if (!dev) {
876 dev_err(&pdev->dev, "allocate net device failed.\n");
877 goto out;
880 /* Chain it all together */
882 SET_NETDEV_DEV(dev, &pdev->dev);
883 vptr = netdev_priv(dev);
886 if (first) {
887 printk(KERN_INFO "%s Ver. %s\n",
888 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
889 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
890 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
891 first = 0;
894 velocity_init_info(pdev, vptr, info);
896 vptr->dev = dev;
898 dev->irq = pdev->irq;
900 ret = pci_enable_device(pdev);
901 if (ret < 0)
902 goto err_free_dev;
904 ret = velocity_get_pci_info(vptr, pdev);
905 if (ret < 0) {
906 /* error message already printed */
907 goto err_disable;
910 ret = pci_request_regions(pdev, VELOCITY_NAME);
911 if (ret < 0) {
912 dev_err(&pdev->dev, "No PCI resources.\n");
913 goto err_disable;
916 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
917 if (regs == NULL) {
918 ret = -EIO;
919 goto err_release_res;
922 vptr->mac_regs = regs;
924 mac_wol_reset(regs);
926 dev->base_addr = vptr->ioaddr;
928 for (i = 0; i < 6; i++)
929 dev->dev_addr[i] = readb(&regs->PAR[i]);
932 velocity_get_options(&vptr->options, velocity_nics, dev->name);
935 * Mask out the options cannot be set to the chip
938 vptr->options.flags &= info->flags;
941 * Enable the chip specified capbilities
944 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
946 vptr->wol_opts = vptr->options.wol_opts;
947 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
949 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
951 dev->irq = pdev->irq;
952 dev->open = velocity_open;
953 dev->hard_start_xmit = velocity_xmit;
954 dev->stop = velocity_close;
955 dev->get_stats = velocity_get_stats;
956 dev->set_multicast_list = velocity_set_multi;
957 dev->do_ioctl = velocity_ioctl;
958 dev->ethtool_ops = &velocity_ethtool_ops;
959 dev->change_mtu = velocity_change_mtu;
961 dev->vlan_rx_add_vid = velocity_vlan_rx_add_vid;
962 dev->vlan_rx_kill_vid = velocity_vlan_rx_kill_vid;
964 #ifdef VELOCITY_ZERO_COPY_SUPPORT
965 dev->features |= NETIF_F_SG;
966 #endif
967 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER;
969 if (vptr->flags & VELOCITY_FLAGS_TX_CSUM)
970 dev->features |= NETIF_F_IP_CSUM;
972 ret = register_netdev(dev);
973 if (ret < 0)
974 goto err_iounmap;
976 if (velocity_get_link(dev))
977 netif_carrier_off(dev);
979 velocity_print_info(vptr);
980 pci_set_drvdata(pdev, dev);
982 /* and leave the chip powered down */
984 pci_set_power_state(pdev, PCI_D3hot);
985 #ifdef CONFIG_PM
987 unsigned long flags;
989 spin_lock_irqsave(&velocity_dev_list_lock, flags);
990 list_add(&vptr->list, &velocity_dev_list);
991 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
993 #endif
994 velocity_nics++;
995 out:
996 return ret;
998 err_iounmap:
999 iounmap(regs);
1000 err_release_res:
1001 pci_release_regions(pdev);
1002 err_disable:
1003 pci_disable_device(pdev);
1004 err_free_dev:
1005 free_netdev(dev);
1006 goto out;
1010 * velocity_print_info - per driver data
1011 * @vptr: velocity
1013 * Print per driver data as the kernel driver finds Velocity
1014 * hardware
1017 static void __devinit velocity_print_info(struct velocity_info *vptr)
1019 struct net_device *dev = vptr->dev;
1021 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
1022 printk(KERN_INFO "%s: Ethernet Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1023 dev->name,
1024 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1025 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1029 * velocity_init_info - init private data
1030 * @pdev: PCI device
1031 * @vptr: Velocity info
1032 * @info: Board type
1034 * Set up the initial velocity_info struct for the device that has been
1035 * discovered.
1038 static void __devinit velocity_init_info(struct pci_dev *pdev,
1039 struct velocity_info *vptr,
1040 const struct velocity_info_tbl *info)
1042 memset(vptr, 0, sizeof(struct velocity_info));
1044 vptr->pdev = pdev;
1045 vptr->chip_id = info->chip_id;
1046 vptr->num_txq = info->txqueue;
1047 vptr->multicast_limit = MCAM_SIZE;
1048 spin_lock_init(&vptr->lock);
1049 INIT_LIST_HEAD(&vptr->list);
1053 * velocity_get_pci_info - retrieve PCI info for device
1054 * @vptr: velocity device
1055 * @pdev: PCI device it matches
1057 * Retrieve the PCI configuration space data that interests us from
1058 * the kernel PCI layer
1061 static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
1063 vptr->rev_id = pdev->revision;
1065 pci_set_master(pdev);
1067 vptr->ioaddr = pci_resource_start(pdev, 0);
1068 vptr->memaddr = pci_resource_start(pdev, 1);
1070 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
1071 dev_err(&pdev->dev,
1072 "region #0 is not an I/O resource, aborting.\n");
1073 return -EINVAL;
1076 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
1077 dev_err(&pdev->dev,
1078 "region #1 is an I/O resource, aborting.\n");
1079 return -EINVAL;
1082 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
1083 dev_err(&pdev->dev, "region #1 is too small.\n");
1084 return -EINVAL;
1086 vptr->pdev = pdev;
1088 return 0;
1092 * velocity_init_rings - set up DMA rings
1093 * @vptr: Velocity to set up
1095 * Allocate PCI mapped DMA rings for the receive and transmit layer
1096 * to use.
1099 static int velocity_init_rings(struct velocity_info *vptr)
1101 int i;
1102 unsigned int psize;
1103 unsigned int tsize;
1104 dma_addr_t pool_dma;
1105 u8 *pool;
1108 * Allocate all RD/TD rings a single pool
1111 psize = vptr->options.numrx * sizeof(struct rx_desc) +
1112 vptr->options.numtx * sizeof(struct tx_desc) * vptr->num_txq;
1115 * pci_alloc_consistent() fulfills the requirement for 64 bytes
1116 * alignment
1118 pool = pci_alloc_consistent(vptr->pdev, psize, &pool_dma);
1120 if (pool == NULL) {
1121 printk(KERN_ERR "%s : DMA memory allocation failed.\n",
1122 vptr->dev->name);
1123 return -ENOMEM;
1126 memset(pool, 0, psize);
1128 vptr->rd_ring = (struct rx_desc *) pool;
1130 vptr->rd_pool_dma = pool_dma;
1132 tsize = vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq;
1133 vptr->tx_bufs = pci_alloc_consistent(vptr->pdev, tsize,
1134 &vptr->tx_bufs_dma);
1136 if (vptr->tx_bufs == NULL) {
1137 printk(KERN_ERR "%s: DMA memory allocation failed.\n",
1138 vptr->dev->name);
1139 pci_free_consistent(vptr->pdev, psize, pool, pool_dma);
1140 return -ENOMEM;
1143 memset(vptr->tx_bufs, 0, vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq);
1145 i = vptr->options.numrx * sizeof(struct rx_desc);
1146 pool += i;
1147 pool_dma += i;
1148 for (i = 0; i < vptr->num_txq; i++) {
1149 int offset = vptr->options.numtx * sizeof(struct tx_desc);
1151 vptr->td_pool_dma[i] = pool_dma;
1152 vptr->td_rings[i] = (struct tx_desc *) pool;
1153 pool += offset;
1154 pool_dma += offset;
1156 return 0;
1160 * velocity_free_rings - free PCI ring pointers
1161 * @vptr: Velocity to free from
1163 * Clean up the PCI ring buffers allocated to this velocity.
1166 static void velocity_free_rings(struct velocity_info *vptr)
1168 int size;
1170 size = vptr->options.numrx * sizeof(struct rx_desc) +
1171 vptr->options.numtx * sizeof(struct tx_desc) * vptr->num_txq;
1173 pci_free_consistent(vptr->pdev, size, vptr->rd_ring, vptr->rd_pool_dma);
1175 size = vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq;
1177 pci_free_consistent(vptr->pdev, size, vptr->tx_bufs, vptr->tx_bufs_dma);
1180 static inline void velocity_give_many_rx_descs(struct velocity_info *vptr)
1182 struct mac_regs __iomem *regs = vptr->mac_regs;
1183 int avail, dirty, unusable;
1186 * RD number must be equal to 4X per hardware spec
1187 * (programming guide rev 1.20, p.13)
1189 if (vptr->rd_filled < 4)
1190 return;
1192 wmb();
1194 unusable = vptr->rd_filled & 0x0003;
1195 dirty = vptr->rd_dirty - unusable;
1196 for (avail = vptr->rd_filled & 0xfffc; avail; avail--) {
1197 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1198 vptr->rd_ring[dirty].rdesc0.owner = OWNED_BY_NIC;
1201 writew(vptr->rd_filled & 0xfffc, &regs->RBRDU);
1202 vptr->rd_filled = unusable;
1205 static int velocity_rx_refill(struct velocity_info *vptr)
1207 int dirty = vptr->rd_dirty, done = 0, ret = 0;
1209 do {
1210 struct rx_desc *rd = vptr->rd_ring + dirty;
1212 /* Fine for an all zero Rx desc at init time as well */
1213 if (rd->rdesc0.owner == OWNED_BY_NIC)
1214 break;
1216 if (!vptr->rd_info[dirty].skb) {
1217 ret = velocity_alloc_rx_buf(vptr, dirty);
1218 if (ret < 0)
1219 break;
1221 done++;
1222 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
1223 } while (dirty != vptr->rd_curr);
1225 if (done) {
1226 vptr->rd_dirty = dirty;
1227 vptr->rd_filled += done;
1228 velocity_give_many_rx_descs(vptr);
1231 return ret;
1235 * velocity_init_rd_ring - set up receive ring
1236 * @vptr: velocity to configure
1238 * Allocate and set up the receive buffers for each ring slot and
1239 * assign them to the network adapter.
1242 static int velocity_init_rd_ring(struct velocity_info *vptr)
1244 int ret;
1246 vptr->rd_info = kcalloc(vptr->options.numrx,
1247 sizeof(struct velocity_rd_info), GFP_KERNEL);
1248 if (!vptr->rd_info)
1249 return -ENOMEM;
1251 vptr->rd_filled = vptr->rd_dirty = vptr->rd_curr = 0;
1253 ret = velocity_rx_refill(vptr);
1254 if (ret < 0) {
1255 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1256 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1257 velocity_free_rd_ring(vptr);
1260 return ret;
1264 * velocity_free_rd_ring - free receive ring
1265 * @vptr: velocity to clean up
1267 * Free the receive buffers for each ring slot and any
1268 * attached socket buffers that need to go away.
1271 static void velocity_free_rd_ring(struct velocity_info *vptr)
1273 int i;
1275 if (vptr->rd_info == NULL)
1276 return;
1278 for (i = 0; i < vptr->options.numrx; i++) {
1279 struct velocity_rd_info *rd_info = &(vptr->rd_info[i]);
1280 struct rx_desc *rd = vptr->rd_ring + i;
1282 memset(rd, 0, sizeof(*rd));
1284 if (!rd_info->skb)
1285 continue;
1286 pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx_buf_sz,
1287 PCI_DMA_FROMDEVICE);
1288 rd_info->skb_dma = (dma_addr_t) NULL;
1290 dev_kfree_skb(rd_info->skb);
1291 rd_info->skb = NULL;
1294 kfree(vptr->rd_info);
1295 vptr->rd_info = NULL;
1299 * velocity_init_td_ring - set up transmit ring
1300 * @vptr: velocity
1302 * Set up the transmit ring and chain the ring pointers together.
1303 * Returns zero on success or a negative posix errno code for
1304 * failure.
1307 static int velocity_init_td_ring(struct velocity_info *vptr)
1309 int i, j;
1310 dma_addr_t curr;
1311 struct tx_desc *td;
1312 struct velocity_td_info *td_info;
1314 /* Init the TD ring entries */
1315 for (j = 0; j < vptr->num_txq; j++) {
1316 curr = vptr->td_pool_dma[j];
1318 vptr->td_infos[j] = kcalloc(vptr->options.numtx,
1319 sizeof(struct velocity_td_info),
1320 GFP_KERNEL);
1321 if (!vptr->td_infos[j]) {
1322 while(--j >= 0)
1323 kfree(vptr->td_infos[j]);
1324 return -ENOMEM;
1327 for (i = 0; i < vptr->options.numtx; i++, curr += sizeof(struct tx_desc)) {
1328 td = &(vptr->td_rings[j][i]);
1329 td_info = &(vptr->td_infos[j][i]);
1330 td_info->buf = vptr->tx_bufs +
1331 (j * vptr->options.numtx + i) * PKT_BUF_SZ;
1332 td_info->buf_dma = vptr->tx_bufs_dma +
1333 (j * vptr->options.numtx + i) * PKT_BUF_SZ;
1335 vptr->td_tail[j] = vptr->td_curr[j] = vptr->td_used[j] = 0;
1337 return 0;
1341 * FIXME: could we merge this with velocity_free_tx_buf ?
1344 static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1345 int q, int n)
1347 struct velocity_td_info * td_info = &(vptr->td_infos[q][n]);
1348 int i;
1350 if (td_info == NULL)
1351 return;
1353 if (td_info->skb) {
1354 for (i = 0; i < td_info->nskb_dma; i++)
1356 if (td_info->skb_dma[i]) {
1357 pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
1358 td_info->skb->len, PCI_DMA_TODEVICE);
1359 td_info->skb_dma[i] = (dma_addr_t) NULL;
1362 dev_kfree_skb(td_info->skb);
1363 td_info->skb = NULL;
1368 * velocity_free_td_ring - free td ring
1369 * @vptr: velocity
1371 * Free up the transmit ring for this particular velocity adapter.
1372 * We free the ring contents but not the ring itself.
1375 static void velocity_free_td_ring(struct velocity_info *vptr)
1377 int i, j;
1379 for (j = 0; j < vptr->num_txq; j++) {
1380 if (vptr->td_infos[j] == NULL)
1381 continue;
1382 for (i = 0; i < vptr->options.numtx; i++) {
1383 velocity_free_td_ring_entry(vptr, j, i);
1386 kfree(vptr->td_infos[j]);
1387 vptr->td_infos[j] = NULL;
1392 * velocity_rx_srv - service RX interrupt
1393 * @vptr: velocity
1394 * @status: adapter status (unused)
1396 * Walk the receive ring of the velocity adapter and remove
1397 * any received packets from the receive queue. Hand the ring
1398 * slots back to the adapter for reuse.
1401 static int velocity_rx_srv(struct velocity_info *vptr, int status)
1403 struct net_device_stats *stats = &vptr->stats;
1404 int rd_curr = vptr->rd_curr;
1405 int works = 0;
1407 do {
1408 struct rx_desc *rd = vptr->rd_ring + rd_curr;
1410 if (!vptr->rd_info[rd_curr].skb)
1411 break;
1413 if (rd->rdesc0.owner == OWNED_BY_NIC)
1414 break;
1416 rmb();
1419 * Don't drop CE or RL error frame although RXOK is off
1421 if ((rd->rdesc0.RSR & RSR_RXOK) || (!(rd->rdesc0.RSR & RSR_RXOK) && (rd->rdesc0.RSR & (RSR_CE | RSR_RL)))) {
1422 if (velocity_receive_frame(vptr, rd_curr) < 0)
1423 stats->rx_dropped++;
1424 } else {
1425 if (rd->rdesc0.RSR & RSR_CRC)
1426 stats->rx_crc_errors++;
1427 if (rd->rdesc0.RSR & RSR_FAE)
1428 stats->rx_frame_errors++;
1430 stats->rx_dropped++;
1433 rd->inten = 1;
1435 vptr->dev->last_rx = jiffies;
1437 rd_curr++;
1438 if (rd_curr >= vptr->options.numrx)
1439 rd_curr = 0;
1440 } while (++works <= 15);
1442 vptr->rd_curr = rd_curr;
1444 if (works > 0 && velocity_rx_refill(vptr) < 0) {
1445 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1446 "%s: rx buf allocation failure\n", vptr->dev->name);
1449 VAR_USED(stats);
1450 return works;
1454 * velocity_rx_csum - checksum process
1455 * @rd: receive packet descriptor
1456 * @skb: network layer packet buffer
1458 * Process the status bits for the received packet and determine
1459 * if the checksum was computed and verified by the hardware
1462 static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1464 skb->ip_summed = CHECKSUM_NONE;
1466 if (rd->rdesc1.CSM & CSM_IPKT) {
1467 if (rd->rdesc1.CSM & CSM_IPOK) {
1468 if ((rd->rdesc1.CSM & CSM_TCPKT) ||
1469 (rd->rdesc1.CSM & CSM_UDPKT)) {
1470 if (!(rd->rdesc1.CSM & CSM_TUPOK)) {
1471 return;
1474 skb->ip_summed = CHECKSUM_UNNECESSARY;
1480 * velocity_rx_copy - in place Rx copy for small packets
1481 * @rx_skb: network layer packet buffer candidate
1482 * @pkt_size: received data size
1483 * @rd: receive packet descriptor
1484 * @dev: network device
1486 * Replace the current skb that is scheduled for Rx processing by a
1487 * shorter, immediatly allocated skb, if the received packet is small
1488 * enough. This function returns a negative value if the received
1489 * packet is too big or if memory is exhausted.
1491 static inline int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
1492 struct velocity_info *vptr)
1494 int ret = -1;
1496 if (pkt_size < rx_copybreak) {
1497 struct sk_buff *new_skb;
1499 new_skb = dev_alloc_skb(pkt_size + 2);
1500 if (new_skb) {
1501 new_skb->dev = vptr->dev;
1502 new_skb->ip_summed = rx_skb[0]->ip_summed;
1504 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN)
1505 skb_reserve(new_skb, 2);
1507 skb_copy_from_linear_data(rx_skb[0], new_skb->data,
1508 pkt_size);
1509 *rx_skb = new_skb;
1510 ret = 0;
1514 return ret;
1518 * velocity_iph_realign - IP header alignment
1519 * @vptr: velocity we are handling
1520 * @skb: network layer packet buffer
1521 * @pkt_size: received data size
1523 * Align IP header on a 2 bytes boundary. This behavior can be
1524 * configured by the user.
1526 static inline void velocity_iph_realign(struct velocity_info *vptr,
1527 struct sk_buff *skb, int pkt_size)
1529 /* FIXME - memmove ? */
1530 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
1531 int i;
1533 for (i = pkt_size; i >= 0; i--)
1534 *(skb->data + i + 2) = *(skb->data + i);
1535 skb_reserve(skb, 2);
1540 * velocity_receive_frame - received packet processor
1541 * @vptr: velocity we are handling
1542 * @idx: ring index
1544 * A packet has arrived. We process the packet and if appropriate
1545 * pass the frame up the network stack
1548 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
1550 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
1551 struct net_device_stats *stats = &vptr->stats;
1552 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
1553 struct rx_desc *rd = &(vptr->rd_ring[idx]);
1554 int pkt_len = rd->rdesc0.len;
1555 struct sk_buff *skb;
1557 if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
1558 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
1559 stats->rx_length_errors++;
1560 return -EINVAL;
1563 if (rd->rdesc0.RSR & RSR_MAR)
1564 vptr->stats.multicast++;
1566 skb = rd_info->skb;
1568 pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
1569 vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1572 * Drop frame not meeting IEEE 802.3
1575 if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
1576 if (rd->rdesc0.RSR & RSR_RL) {
1577 stats->rx_length_errors++;
1578 return -EINVAL;
1582 pci_action = pci_dma_sync_single_for_device;
1584 velocity_rx_csum(rd, skb);
1586 if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
1587 velocity_iph_realign(vptr, skb, pkt_len);
1588 pci_action = pci_unmap_single;
1589 rd_info->skb = NULL;
1592 pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx_buf_sz,
1593 PCI_DMA_FROMDEVICE);
1595 skb_put(skb, pkt_len - 4);
1596 skb->protocol = eth_type_trans(skb, vptr->dev);
1598 stats->rx_bytes += pkt_len;
1599 netif_rx(skb);
1601 return 0;
1605 * velocity_alloc_rx_buf - allocate aligned receive buffer
1606 * @vptr: velocity
1607 * @idx: ring index
1609 * Allocate a new full sized buffer for the reception of a frame and
1610 * map it into PCI space for the hardware to use. The hardware
1611 * requires *64* byte alignment of the buffer which makes life
1612 * less fun than would be ideal.
1615 static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1617 struct rx_desc *rd = &(vptr->rd_ring[idx]);
1618 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
1620 rd_info->skb = dev_alloc_skb(vptr->rx_buf_sz + 64);
1621 if (rd_info->skb == NULL)
1622 return -ENOMEM;
1625 * Do the gymnastics to get the buffer head for data at
1626 * 64byte alignment.
1628 skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->data & 63);
1629 rd_info->skb->dev = vptr->dev;
1630 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data, vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1633 * Fill in the descriptor to match
1636 *((u32 *) & (rd->rdesc0)) = 0;
1637 rd->len = cpu_to_le32(vptr->rx_buf_sz);
1638 rd->inten = 1;
1639 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1640 rd->pa_high = 0;
1641 return 0;
1645 * tx_srv - transmit interrupt service
1646 * @vptr; Velocity
1647 * @status:
1649 * Scan the queues looking for transmitted packets that
1650 * we can complete and clean up. Update any statistics as
1651 * neccessary/
1654 static int velocity_tx_srv(struct velocity_info *vptr, u32 status)
1656 struct tx_desc *td;
1657 int qnum;
1658 int full = 0;
1659 int idx;
1660 int works = 0;
1661 struct velocity_td_info *tdinfo;
1662 struct net_device_stats *stats = &vptr->stats;
1664 for (qnum = 0; qnum < vptr->num_txq; qnum++) {
1665 for (idx = vptr->td_tail[qnum]; vptr->td_used[qnum] > 0;
1666 idx = (idx + 1) % vptr->options.numtx) {
1669 * Get Tx Descriptor
1671 td = &(vptr->td_rings[qnum][idx]);
1672 tdinfo = &(vptr->td_infos[qnum][idx]);
1674 if (td->tdesc0.owner == OWNED_BY_NIC)
1675 break;
1677 if ((works++ > 15))
1678 break;
1680 if (td->tdesc0.TSR & TSR0_TERR) {
1681 stats->tx_errors++;
1682 stats->tx_dropped++;
1683 if (td->tdesc0.TSR & TSR0_CDH)
1684 stats->tx_heartbeat_errors++;
1685 if (td->tdesc0.TSR & TSR0_CRS)
1686 stats->tx_carrier_errors++;
1687 if (td->tdesc0.TSR & TSR0_ABT)
1688 stats->tx_aborted_errors++;
1689 if (td->tdesc0.TSR & TSR0_OWC)
1690 stats->tx_window_errors++;
1691 } else {
1692 stats->tx_packets++;
1693 stats->tx_bytes += tdinfo->skb->len;
1695 velocity_free_tx_buf(vptr, tdinfo);
1696 vptr->td_used[qnum]--;
1698 vptr->td_tail[qnum] = idx;
1700 if (AVAIL_TD(vptr, qnum) < 1) {
1701 full = 1;
1705 * Look to see if we should kick the transmit network
1706 * layer for more work.
1708 if (netif_queue_stopped(vptr->dev) && (full == 0)
1709 && (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1710 netif_wake_queue(vptr->dev);
1712 return works;
1716 * velocity_print_link_status - link status reporting
1717 * @vptr: velocity to report on
1719 * Turn the link status of the velocity card into a kernel log
1720 * description of the new link state, detailing speed and duplex
1721 * status
1724 static void velocity_print_link_status(struct velocity_info *vptr)
1727 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1728 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1729 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1730 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1732 if (vptr->mii_status & VELOCITY_SPEED_1000)
1733 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1734 else if (vptr->mii_status & VELOCITY_SPEED_100)
1735 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1736 else
1737 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1739 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1740 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1741 else
1742 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1743 } else {
1744 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1745 switch (vptr->options.spd_dpx) {
1746 case SPD_DPX_100_HALF:
1747 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1748 break;
1749 case SPD_DPX_100_FULL:
1750 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1751 break;
1752 case SPD_DPX_10_HALF:
1753 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1754 break;
1755 case SPD_DPX_10_FULL:
1756 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1757 break;
1758 default:
1759 break;
1765 * velocity_error - handle error from controller
1766 * @vptr: velocity
1767 * @status: card status
1769 * Process an error report from the hardware and attempt to recover
1770 * the card itself. At the moment we cannot recover from some
1771 * theoretically impossible errors but this could be fixed using
1772 * the pci_device_failed logic to bounce the hardware
1776 static void velocity_error(struct velocity_info *vptr, int status)
1779 if (status & ISR_TXSTLI) {
1780 struct mac_regs __iomem * regs = vptr->mac_regs;
1782 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1783 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1784 writew(TRDCSR_RUN, &regs->TDCSRClr);
1785 netif_stop_queue(vptr->dev);
1787 /* FIXME: port over the pci_device_failed code and use it
1788 here */
1791 if (status & ISR_SRCI) {
1792 struct mac_regs __iomem * regs = vptr->mac_regs;
1793 int linked;
1795 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1796 vptr->mii_status = check_connection_type(regs);
1799 * If it is a 3119, disable frame bursting in
1800 * halfduplex mode and enable it in fullduplex
1801 * mode
1803 if (vptr->rev_id < REV_ID_VT3216_A0) {
1804 if (vptr->mii_status | VELOCITY_DUPLEX_FULL)
1805 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1806 else
1807 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1810 * Only enable CD heart beat counter in 10HD mode
1812 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10)) {
1813 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1814 } else {
1815 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1819 * Get link status from PHYSR0
1821 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1823 if (linked) {
1824 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1825 netif_carrier_on(vptr->dev);
1826 } else {
1827 vptr->mii_status |= VELOCITY_LINK_FAIL;
1828 netif_carrier_off(vptr->dev);
1831 velocity_print_link_status(vptr);
1832 enable_flow_control_ability(vptr);
1835 * Re-enable auto-polling because SRCI will disable
1836 * auto-polling
1839 enable_mii_autopoll(regs);
1841 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1842 netif_stop_queue(vptr->dev);
1843 else
1844 netif_wake_queue(vptr->dev);
1847 if (status & ISR_MIBFI)
1848 velocity_update_hw_mibs(vptr);
1849 if (status & ISR_LSTEI)
1850 mac_rx_queue_wake(vptr->mac_regs);
1854 * velocity_free_tx_buf - free transmit buffer
1855 * @vptr: velocity
1856 * @tdinfo: buffer
1858 * Release an transmit buffer. If the buffer was preallocated then
1859 * recycle it, if not then unmap the buffer.
1862 static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *tdinfo)
1864 struct sk_buff *skb = tdinfo->skb;
1865 int i;
1868 * Don't unmap the pre-allocated tx_bufs
1870 if (tdinfo->skb_dma && (tdinfo->skb_dma[0] != tdinfo->buf_dma)) {
1872 for (i = 0; i < tdinfo->nskb_dma; i++) {
1873 #ifdef VELOCITY_ZERO_COPY_SUPPORT
1874 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], td->tdesc1.len, PCI_DMA_TODEVICE);
1875 #else
1876 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], skb->len, PCI_DMA_TODEVICE);
1877 #endif
1878 tdinfo->skb_dma[i] = 0;
1881 dev_kfree_skb_irq(skb);
1882 tdinfo->skb = NULL;
1886 * velocity_open - interface activation callback
1887 * @dev: network layer device to open
1889 * Called when the network layer brings the interface up. Returns
1890 * a negative posix error code on failure, or zero on success.
1892 * All the ring allocation and set up is done on open for this
1893 * adapter to minimise memory usage when inactive
1896 static int velocity_open(struct net_device *dev)
1898 struct velocity_info *vptr = netdev_priv(dev);
1899 int ret;
1901 vptr->rx_buf_sz = (dev->mtu <= 1504 ? PKT_BUF_SZ : dev->mtu + 32);
1903 ret = velocity_init_rings(vptr);
1904 if (ret < 0)
1905 goto out;
1907 ret = velocity_init_rd_ring(vptr);
1908 if (ret < 0)
1909 goto err_free_desc_rings;
1911 ret = velocity_init_td_ring(vptr);
1912 if (ret < 0)
1913 goto err_free_rd_ring;
1915 /* Ensure chip is running */
1916 pci_set_power_state(vptr->pdev, PCI_D0);
1918 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
1920 ret = request_irq(vptr->pdev->irq, &velocity_intr, IRQF_SHARED,
1921 dev->name, dev);
1922 if (ret < 0) {
1923 /* Power down the chip */
1924 pci_set_power_state(vptr->pdev, PCI_D3hot);
1925 goto err_free_td_ring;
1928 mac_enable_int(vptr->mac_regs);
1929 netif_start_queue(dev);
1930 vptr->flags |= VELOCITY_FLAGS_OPENED;
1931 out:
1932 return ret;
1934 err_free_td_ring:
1935 velocity_free_td_ring(vptr);
1936 err_free_rd_ring:
1937 velocity_free_rd_ring(vptr);
1938 err_free_desc_rings:
1939 velocity_free_rings(vptr);
1940 goto out;
1944 * velocity_change_mtu - MTU change callback
1945 * @dev: network device
1946 * @new_mtu: desired MTU
1948 * Handle requests from the networking layer for MTU change on
1949 * this interface. It gets called on a change by the network layer.
1950 * Return zero for success or negative posix error code.
1953 static int velocity_change_mtu(struct net_device *dev, int new_mtu)
1955 struct velocity_info *vptr = netdev_priv(dev);
1956 unsigned long flags;
1957 int oldmtu = dev->mtu;
1958 int ret = 0;
1960 if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
1961 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
1962 vptr->dev->name);
1963 return -EINVAL;
1966 if (new_mtu != oldmtu) {
1967 spin_lock_irqsave(&vptr->lock, flags);
1969 netif_stop_queue(dev);
1970 velocity_shutdown(vptr);
1972 velocity_free_td_ring(vptr);
1973 velocity_free_rd_ring(vptr);
1975 dev->mtu = new_mtu;
1976 if (new_mtu > 8192)
1977 vptr->rx_buf_sz = 9 * 1024;
1978 else if (new_mtu > 4096)
1979 vptr->rx_buf_sz = 8192;
1980 else
1981 vptr->rx_buf_sz = 4 * 1024;
1983 ret = velocity_init_rd_ring(vptr);
1984 if (ret < 0)
1985 goto out_unlock;
1987 ret = velocity_init_td_ring(vptr);
1988 if (ret < 0)
1989 goto out_unlock;
1991 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
1993 mac_enable_int(vptr->mac_regs);
1994 netif_start_queue(dev);
1995 out_unlock:
1996 spin_unlock_irqrestore(&vptr->lock, flags);
1999 return ret;
2003 * velocity_shutdown - shut down the chip
2004 * @vptr: velocity to deactivate
2006 * Shuts down the internal operations of the velocity and
2007 * disables interrupts, autopolling, transmit and receive
2010 static void velocity_shutdown(struct velocity_info *vptr)
2012 struct mac_regs __iomem * regs = vptr->mac_regs;
2013 mac_disable_int(regs);
2014 writel(CR0_STOP, &regs->CR0Set);
2015 writew(0xFFFF, &regs->TDCSRClr);
2016 writeb(0xFF, &regs->RDCSRClr);
2017 safe_disable_mii_autopoll(regs);
2018 mac_clear_isr(regs);
2022 * velocity_close - close adapter callback
2023 * @dev: network device
2025 * Callback from the network layer when the velocity is being
2026 * deactivated by the network layer
2029 static int velocity_close(struct net_device *dev)
2031 struct velocity_info *vptr = netdev_priv(dev);
2033 netif_stop_queue(dev);
2034 velocity_shutdown(vptr);
2036 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
2037 velocity_get_ip(vptr);
2038 if (dev->irq != 0)
2039 free_irq(dev->irq, dev);
2041 /* Power down the chip */
2042 pci_set_power_state(vptr->pdev, PCI_D3hot);
2044 /* Free the resources */
2045 velocity_free_td_ring(vptr);
2046 velocity_free_rd_ring(vptr);
2047 velocity_free_rings(vptr);
2049 vptr->flags &= (~VELOCITY_FLAGS_OPENED);
2050 return 0;
2054 * velocity_xmit - transmit packet callback
2055 * @skb: buffer to transmit
2056 * @dev: network device
2058 * Called by the networ layer to request a packet is queued to
2059 * the velocity. Returns zero on success.
2062 static int velocity_xmit(struct sk_buff *skb, struct net_device *dev)
2064 struct velocity_info *vptr = netdev_priv(dev);
2065 int qnum = 0;
2066 struct tx_desc *td_ptr;
2067 struct velocity_td_info *tdinfo;
2068 unsigned long flags;
2069 int index;
2071 int pktlen = skb->len;
2073 #ifdef VELOCITY_ZERO_COPY_SUPPORT
2074 if (skb_shinfo(skb)->nr_frags > 6 && __skb_linearize(skb)) {
2075 kfree_skb(skb);
2076 return 0;
2078 #endif
2080 spin_lock_irqsave(&vptr->lock, flags);
2082 index = vptr->td_curr[qnum];
2083 td_ptr = &(vptr->td_rings[qnum][index]);
2084 tdinfo = &(vptr->td_infos[qnum][index]);
2086 td_ptr->tdesc1.TCPLS = TCPLS_NORMAL;
2087 td_ptr->tdesc1.TCR = TCR0_TIC;
2088 td_ptr->td_buf[0].queue = 0;
2091 * Pad short frames.
2093 if (pktlen < ETH_ZLEN) {
2094 /* Cannot occur until ZC support */
2095 pktlen = ETH_ZLEN;
2096 skb_copy_from_linear_data(skb, tdinfo->buf, skb->len);
2097 memset(tdinfo->buf + skb->len, 0, ETH_ZLEN - skb->len);
2098 tdinfo->skb = skb;
2099 tdinfo->skb_dma[0] = tdinfo->buf_dma;
2100 td_ptr->tdesc0.pktsize = pktlen;
2101 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2102 td_ptr->td_buf[0].pa_high = 0;
2103 td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
2104 tdinfo->nskb_dma = 1;
2105 td_ptr->tdesc1.CMDZ = 2;
2106 } else
2107 #ifdef VELOCITY_ZERO_COPY_SUPPORT
2108 if (skb_shinfo(skb)->nr_frags > 0) {
2109 int nfrags = skb_shinfo(skb)->nr_frags;
2110 tdinfo->skb = skb;
2111 if (nfrags > 6) {
2112 skb_copy_from_linear_data(skb, tdinfo->buf, skb->len);
2113 tdinfo->skb_dma[0] = tdinfo->buf_dma;
2114 td_ptr->tdesc0.pktsize =
2115 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2116 td_ptr->td_buf[0].pa_high = 0;
2117 td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
2118 tdinfo->nskb_dma = 1;
2119 td_ptr->tdesc1.CMDZ = 2;
2120 } else {
2121 int i = 0;
2122 tdinfo->nskb_dma = 0;
2123 tdinfo->skb_dma[i] = pci_map_single(vptr->pdev, skb->data, skb->len - skb->data_len, PCI_DMA_TODEVICE);
2125 td_ptr->tdesc0.pktsize = pktlen;
2127 /* FIXME: support 48bit DMA later */
2128 td_ptr->td_buf[i].pa_low = cpu_to_le32(tdinfo->skb_dma);
2129 td_ptr->td_buf[i].pa_high = 0;
2130 td_ptr->td_buf[i].bufsize = skb->len->skb->data_len;
2132 for (i = 0; i < nfrags; i++) {
2133 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2134 void *addr = ((void *) page_address(frag->page + frag->page_offset));
2136 tdinfo->skb_dma[i + 1] = pci_map_single(vptr->pdev, addr, frag->size, PCI_DMA_TODEVICE);
2138 td_ptr->td_buf[i + 1].pa_low = cpu_to_le32(tdinfo->skb_dma[i + 1]);
2139 td_ptr->td_buf[i + 1].pa_high = 0;
2140 td_ptr->td_buf[i + 1].bufsize = frag->size;
2142 tdinfo->nskb_dma = i - 1;
2143 td_ptr->tdesc1.CMDZ = i;
2146 } else
2147 #endif
2150 * Map the linear network buffer into PCI space and
2151 * add it to the transmit ring.
2153 tdinfo->skb = skb;
2154 tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
2155 td_ptr->tdesc0.pktsize = pktlen;
2156 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2157 td_ptr->td_buf[0].pa_high = 0;
2158 td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
2159 tdinfo->nskb_dma = 1;
2160 td_ptr->tdesc1.CMDZ = 2;
2163 if (vptr->vlgrp && vlan_tx_tag_present(skb)) {
2164 td_ptr->tdesc1.pqinf.VID = vlan_tx_tag_get(skb);
2165 td_ptr->tdesc1.pqinf.priority = 0;
2166 td_ptr->tdesc1.pqinf.CFI = 0;
2167 td_ptr->tdesc1.TCR |= TCR0_VETAG;
2171 * Handle hardware checksum
2173 if ((vptr->flags & VELOCITY_FLAGS_TX_CSUM)
2174 && (skb->ip_summed == CHECKSUM_PARTIAL)) {
2175 const struct iphdr *ip = ip_hdr(skb);
2176 if (ip->protocol == IPPROTO_TCP)
2177 td_ptr->tdesc1.TCR |= TCR0_TCPCK;
2178 else if (ip->protocol == IPPROTO_UDP)
2179 td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
2180 td_ptr->tdesc1.TCR |= TCR0_IPCK;
2184 int prev = index - 1;
2186 if (prev < 0)
2187 prev = vptr->options.numtx - 1;
2188 td_ptr->tdesc0.owner = OWNED_BY_NIC;
2189 vptr->td_used[qnum]++;
2190 vptr->td_curr[qnum] = (index + 1) % vptr->options.numtx;
2192 if (AVAIL_TD(vptr, qnum) < 1)
2193 netif_stop_queue(dev);
2195 td_ptr = &(vptr->td_rings[qnum][prev]);
2196 td_ptr->td_buf[0].queue = 1;
2197 mac_tx_queue_wake(vptr->mac_regs, qnum);
2199 dev->trans_start = jiffies;
2200 spin_unlock_irqrestore(&vptr->lock, flags);
2201 return 0;
2205 * velocity_intr - interrupt callback
2206 * @irq: interrupt number
2207 * @dev_instance: interrupting device
2209 * Called whenever an interrupt is generated by the velocity
2210 * adapter IRQ line. We may not be the source of the interrupt
2211 * and need to identify initially if we are, and if not exit as
2212 * efficiently as possible.
2215 static int velocity_intr(int irq, void *dev_instance)
2217 struct net_device *dev = dev_instance;
2218 struct velocity_info *vptr = netdev_priv(dev);
2219 u32 isr_status;
2220 int max_count = 0;
2223 spin_lock(&vptr->lock);
2224 isr_status = mac_read_isr(vptr->mac_regs);
2226 /* Not us ? */
2227 if (isr_status == 0) {
2228 spin_unlock(&vptr->lock);
2229 return IRQ_NONE;
2232 mac_disable_int(vptr->mac_regs);
2235 * Keep processing the ISR until we have completed
2236 * processing and the isr_status becomes zero
2239 while (isr_status != 0) {
2240 mac_write_isr(vptr->mac_regs, isr_status);
2241 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2242 velocity_error(vptr, isr_status);
2243 if (isr_status & (ISR_PRXI | ISR_PPRXI))
2244 max_count += velocity_rx_srv(vptr, isr_status);
2245 if (isr_status & (ISR_PTXI | ISR_PPTXI))
2246 max_count += velocity_tx_srv(vptr, isr_status);
2247 isr_status = mac_read_isr(vptr->mac_regs);
2248 if (max_count > vptr->options.int_works)
2250 printk(KERN_WARNING "%s: excessive work at interrupt.\n",
2251 dev->name);
2252 max_count = 0;
2255 spin_unlock(&vptr->lock);
2256 mac_enable_int(vptr->mac_regs);
2257 return IRQ_HANDLED;
2263 * velocity_set_multi - filter list change callback
2264 * @dev: network device
2266 * Called by the network layer when the filter lists need to change
2267 * for a velocity adapter. Reload the CAMs with the new address
2268 * filter ruleset.
2271 static void velocity_set_multi(struct net_device *dev)
2273 struct velocity_info *vptr = netdev_priv(dev);
2274 struct mac_regs __iomem * regs = vptr->mac_regs;
2275 u8 rx_mode;
2276 int i;
2277 struct dev_mc_list *mclist;
2279 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2280 writel(0xffffffff, &regs->MARCAM[0]);
2281 writel(0xffffffff, &regs->MARCAM[4]);
2282 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
2283 } else if ((dev->mc_count > vptr->multicast_limit)
2284 || (dev->flags & IFF_ALLMULTI)) {
2285 writel(0xffffffff, &regs->MARCAM[0]);
2286 writel(0xffffffff, &regs->MARCAM[4]);
2287 rx_mode = (RCR_AM | RCR_AB);
2288 } else {
2289 int offset = MCAM_SIZE - vptr->multicast_limit;
2290 mac_get_cam_mask(regs, vptr->mCAMmask);
2292 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) {
2293 mac_set_cam(regs, i + offset, mclist->dmi_addr);
2294 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
2297 mac_set_cam_mask(regs, vptr->mCAMmask);
2298 rx_mode = (RCR_AM | RCR_AB);
2300 if (dev->mtu > 1500)
2301 rx_mode |= RCR_AL;
2303 BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
2308 * velocity_get_status - statistics callback
2309 * @dev: network device
2311 * Callback from the network layer to allow driver statistics
2312 * to be resynchronized with hardware collected state. In the
2313 * case of the velocity we need to pull the MIB counters from
2314 * the hardware into the counters before letting the network
2315 * layer display them.
2318 static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2320 struct velocity_info *vptr = netdev_priv(dev);
2322 /* If the hardware is down, don't touch MII */
2323 if(!netif_running(dev))
2324 return &vptr->stats;
2326 spin_lock_irq(&vptr->lock);
2327 velocity_update_hw_mibs(vptr);
2328 spin_unlock_irq(&vptr->lock);
2330 vptr->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2331 vptr->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2332 vptr->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2334 // unsigned long rx_dropped; /* no space in linux buffers */
2335 vptr->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2336 /* detailed rx_errors: */
2337 // unsigned long rx_length_errors;
2338 // unsigned long rx_over_errors; /* receiver ring buff overflow */
2339 vptr->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2340 // unsigned long rx_frame_errors; /* recv'd frame alignment error */
2341 // unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2342 // unsigned long rx_missed_errors; /* receiver missed packet */
2344 /* detailed tx_errors */
2345 // unsigned long tx_fifo_errors;
2347 return &vptr->stats;
2352 * velocity_ioctl - ioctl entry point
2353 * @dev: network device
2354 * @rq: interface request ioctl
2355 * @cmd: command code
2357 * Called when the user issues an ioctl request to the network
2358 * device in question. The velocity interface supports MII.
2361 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2363 struct velocity_info *vptr = netdev_priv(dev);
2364 int ret;
2366 /* If we are asked for information and the device is power
2367 saving then we need to bring the device back up to talk to it */
2369 if (!netif_running(dev))
2370 pci_set_power_state(vptr->pdev, PCI_D0);
2372 switch (cmd) {
2373 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2374 case SIOCGMIIREG: /* Read MII PHY register. */
2375 case SIOCSMIIREG: /* Write to MII PHY register. */
2376 ret = velocity_mii_ioctl(dev, rq, cmd);
2377 break;
2379 default:
2380 ret = -EOPNOTSUPP;
2382 if (!netif_running(dev))
2383 pci_set_power_state(vptr->pdev, PCI_D3hot);
2386 return ret;
2390 * Definition for our device driver. The PCI layer interface
2391 * uses this to handle all our card discover and plugging
2394 static struct pci_driver velocity_driver = {
2395 .name = VELOCITY_NAME,
2396 .id_table = velocity_id_table,
2397 .probe = velocity_found1,
2398 .remove = __devexit_p(velocity_remove1),
2399 #ifdef CONFIG_PM
2400 .suspend = velocity_suspend,
2401 .resume = velocity_resume,
2402 #endif
2406 * velocity_init_module - load time function
2408 * Called when the velocity module is loaded. The PCI driver
2409 * is registered with the PCI layer, and in turn will call
2410 * the probe functions for each velocity adapter installed
2411 * in the system.
2414 static int __init velocity_init_module(void)
2416 int ret;
2418 velocity_register_notifier();
2419 ret = pci_register_driver(&velocity_driver);
2420 if (ret < 0)
2421 velocity_unregister_notifier();
2422 return ret;
2426 * velocity_cleanup - module unload
2428 * When the velocity hardware is unloaded this function is called.
2429 * It will clean up the notifiers and the unregister the PCI
2430 * driver interface for this hardware. This in turn cleans up
2431 * all discovered interfaces before returning from the function
2434 static void __exit velocity_cleanup_module(void)
2436 velocity_unregister_notifier();
2437 pci_unregister_driver(&velocity_driver);
2440 module_init(velocity_init_module);
2441 module_exit(velocity_cleanup_module);
2445 * MII access , media link mode setting functions
2450 * mii_init - set up MII
2451 * @vptr: velocity adapter
2452 * @mii_status: links tatus
2454 * Set up the PHY for the current link state.
2457 static void mii_init(struct velocity_info *vptr, u32 mii_status)
2459 u16 BMCR;
2461 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
2462 case PHYID_CICADA_CS8201:
2464 * Reset to hardware default
2466 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2468 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2469 * off it in NWay-forced half mode for NWay-forced v.s.
2470 * legacy-forced issue.
2472 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2473 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2474 else
2475 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2477 * Turn on Link/Activity LED enable bit for CIS8201
2479 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
2480 break;
2481 case PHYID_VT3216_32BIT:
2482 case PHYID_VT3216_64BIT:
2484 * Reset to hardware default
2486 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2488 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2489 * off it in NWay-forced half mode for NWay-forced v.s.
2490 * legacy-forced issue
2492 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2493 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2494 else
2495 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2496 break;
2498 case PHYID_MARVELL_1000:
2499 case PHYID_MARVELL_1000S:
2501 * Assert CRS on Transmit
2503 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
2505 * Reset to hardware default
2507 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2508 break;
2509 default:
2512 velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
2513 if (BMCR & BMCR_ISO) {
2514 BMCR &= ~BMCR_ISO;
2515 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
2520 * safe_disable_mii_autopoll - autopoll off
2521 * @regs: velocity registers
2523 * Turn off the autopoll and wait for it to disable on the chip
2526 static void safe_disable_mii_autopoll(struct mac_regs __iomem * regs)
2528 u16 ww;
2530 /* turn off MAUTO */
2531 writeb(0, &regs->MIICR);
2532 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2533 udelay(1);
2534 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2535 break;
2540 * enable_mii_autopoll - turn on autopolling
2541 * @regs: velocity registers
2543 * Enable the MII link status autopoll feature on the Velocity
2544 * hardware. Wait for it to enable.
2547 static void enable_mii_autopoll(struct mac_regs __iomem * regs)
2549 int ii;
2551 writeb(0, &(regs->MIICR));
2552 writeb(MIIADR_SWMPL, &regs->MIIADR);
2554 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
2555 udelay(1);
2556 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2557 break;
2560 writeb(MIICR_MAUTO, &regs->MIICR);
2562 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
2563 udelay(1);
2564 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2565 break;
2571 * velocity_mii_read - read MII data
2572 * @regs: velocity registers
2573 * @index: MII register index
2574 * @data: buffer for received data
2576 * Perform a single read of an MII 16bit register. Returns zero
2577 * on success or -ETIMEDOUT if the PHY did not respond.
2580 static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
2582 u16 ww;
2585 * Disable MIICR_MAUTO, so that mii addr can be set normally
2587 safe_disable_mii_autopoll(regs);
2589 writeb(index, &regs->MIIADR);
2591 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
2593 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2594 if (!(readb(&regs->MIICR) & MIICR_RCMD))
2595 break;
2598 *data = readw(&regs->MIIDATA);
2600 enable_mii_autopoll(regs);
2601 if (ww == W_MAX_TIMEOUT)
2602 return -ETIMEDOUT;
2603 return 0;
2607 * velocity_mii_write - write MII data
2608 * @regs: velocity registers
2609 * @index: MII register index
2610 * @data: 16bit data for the MII register
2612 * Perform a single write to an MII 16bit register. Returns zero
2613 * on success or -ETIMEDOUT if the PHY did not respond.
2616 static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
2618 u16 ww;
2621 * Disable MIICR_MAUTO, so that mii addr can be set normally
2623 safe_disable_mii_autopoll(regs);
2625 /* MII reg offset */
2626 writeb(mii_addr, &regs->MIIADR);
2627 /* set MII data */
2628 writew(data, &regs->MIIDATA);
2630 /* turn on MIICR_WCMD */
2631 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
2633 /* W_MAX_TIMEOUT is the timeout period */
2634 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2635 udelay(5);
2636 if (!(readb(&regs->MIICR) & MIICR_WCMD))
2637 break;
2639 enable_mii_autopoll(regs);
2641 if (ww == W_MAX_TIMEOUT)
2642 return -ETIMEDOUT;
2643 return 0;
2647 * velocity_get_opt_media_mode - get media selection
2648 * @vptr: velocity adapter
2650 * Get the media mode stored in EEPROM or module options and load
2651 * mii_status accordingly. The requested link state information
2652 * is also returned.
2655 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
2657 u32 status = 0;
2659 switch (vptr->options.spd_dpx) {
2660 case SPD_DPX_AUTO:
2661 status = VELOCITY_AUTONEG_ENABLE;
2662 break;
2663 case SPD_DPX_100_FULL:
2664 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
2665 break;
2666 case SPD_DPX_10_FULL:
2667 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
2668 break;
2669 case SPD_DPX_100_HALF:
2670 status = VELOCITY_SPEED_100;
2671 break;
2672 case SPD_DPX_10_HALF:
2673 status = VELOCITY_SPEED_10;
2674 break;
2676 vptr->mii_status = status;
2677 return status;
2681 * mii_set_auto_on - autonegotiate on
2682 * @vptr: velocity
2684 * Enable autonegotation on this interface
2687 static void mii_set_auto_on(struct velocity_info *vptr)
2689 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs))
2690 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
2691 else
2692 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
2697 static void mii_set_auto_off(struct velocity_info * vptr)
2699 MII_REG_BITS_OFF(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
2704 * set_mii_flow_control - flow control setup
2705 * @vptr: velocity interface
2707 * Set up the flow control on this interface according to
2708 * the supplied user/eeprom options.
2711 static void set_mii_flow_control(struct velocity_info *vptr)
2713 /*Enable or Disable PAUSE in ANAR */
2714 switch (vptr->options.flow_cntl) {
2715 case FLOW_CNTL_TX:
2716 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2717 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2718 break;
2720 case FLOW_CNTL_RX:
2721 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2722 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2723 break;
2725 case FLOW_CNTL_TX_RX:
2726 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2727 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2728 break;
2730 case FLOW_CNTL_DISABLE:
2731 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2732 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2733 break;
2734 default:
2735 break;
2740 * velocity_set_media_mode - set media mode
2741 * @mii_status: old MII link state
2743 * Check the media link state and configure the flow control
2744 * PHY and also velocity hardware setup accordingly. In particular
2745 * we need to set up CD polling and frame bursting.
2748 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
2750 u32 curr_status;
2751 struct mac_regs __iomem * regs = vptr->mac_regs;
2753 vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
2754 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
2756 /* Set mii link status */
2757 set_mii_flow_control(vptr);
2760 Check if new status is consisent with current status
2761 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE)
2762 || (mii_status==curr_status)) {
2763 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
2764 vptr->mii_status=check_connection_type(vptr->mac_regs);
2765 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
2766 return 0;
2770 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201) {
2771 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
2775 * If connection type is AUTO
2777 if (mii_status & VELOCITY_AUTONEG_ENABLE) {
2778 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
2779 /* clear force MAC mode bit */
2780 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
2781 /* set duplex mode of MAC according to duplex mode of MII */
2782 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10, MII_REG_ANAR, vptr->mac_regs);
2783 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2784 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs);
2786 /* enable AUTO-NEGO mode */
2787 mii_set_auto_on(vptr);
2788 } else {
2789 u16 ANAR;
2790 u8 CHIPGCR;
2793 * 1. if it's 3119, disable frame bursting in halfduplex mode
2794 * and enable it in fullduplex mode
2795 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
2796 * 3. only enable CD heart beat counter in 10HD mode
2799 /* set force MAC mode bit */
2800 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2802 CHIPGCR = readb(&regs->CHIPGCR);
2803 CHIPGCR &= ~CHIPGCR_FCGMII;
2805 if (mii_status & VELOCITY_DUPLEX_FULL) {
2806 CHIPGCR |= CHIPGCR_FCFDX;
2807 writeb(CHIPGCR, &regs->CHIPGCR);
2808 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
2809 if (vptr->rev_id < REV_ID_VT3216_A0)
2810 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
2811 } else {
2812 CHIPGCR &= ~CHIPGCR_FCFDX;
2813 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
2814 writeb(CHIPGCR, &regs->CHIPGCR);
2815 if (vptr->rev_id < REV_ID_VT3216_A0)
2816 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
2819 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2821 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10)) {
2822 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
2823 } else {
2824 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
2826 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */
2827 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR);
2828 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10));
2829 if (mii_status & VELOCITY_SPEED_100) {
2830 if (mii_status & VELOCITY_DUPLEX_FULL)
2831 ANAR |= ANAR_TXFD;
2832 else
2833 ANAR |= ANAR_TX;
2834 } else {
2835 if (mii_status & VELOCITY_DUPLEX_FULL)
2836 ANAR |= ANAR_10FD;
2837 else
2838 ANAR |= ANAR_10;
2840 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
2841 /* enable AUTO-NEGO mode */
2842 mii_set_auto_on(vptr);
2843 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
2845 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
2846 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
2847 return VELOCITY_LINK_CHANGE;
2851 * mii_check_media_mode - check media state
2852 * @regs: velocity registers
2854 * Check the current MII status and determine the link status
2855 * accordingly
2858 static u32 mii_check_media_mode(struct mac_regs __iomem * regs)
2860 u32 status = 0;
2861 u16 ANAR;
2863 if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs))
2864 status |= VELOCITY_LINK_FAIL;
2866 if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs))
2867 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
2868 else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
2869 status |= (VELOCITY_SPEED_1000);
2870 else {
2871 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2872 if (ANAR & ANAR_TXFD)
2873 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
2874 else if (ANAR & ANAR_TX)
2875 status |= VELOCITY_SPEED_100;
2876 else if (ANAR & ANAR_10FD)
2877 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
2878 else
2879 status |= (VELOCITY_SPEED_10);
2882 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
2883 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2884 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
2885 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
2886 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
2887 status |= VELOCITY_AUTONEG_ENABLE;
2891 return status;
2894 static u32 check_connection_type(struct mac_regs __iomem * regs)
2896 u32 status = 0;
2897 u8 PHYSR0;
2898 u16 ANAR;
2899 PHYSR0 = readb(&regs->PHYSR0);
2902 if (!(PHYSR0 & PHYSR0_LINKGD))
2903 status|=VELOCITY_LINK_FAIL;
2906 if (PHYSR0 & PHYSR0_FDPX)
2907 status |= VELOCITY_DUPLEX_FULL;
2909 if (PHYSR0 & PHYSR0_SPDG)
2910 status |= VELOCITY_SPEED_1000;
2911 else if (PHYSR0 & PHYSR0_SPD10)
2912 status |= VELOCITY_SPEED_10;
2913 else
2914 status |= VELOCITY_SPEED_100;
2916 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
2917 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2918 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
2919 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
2920 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
2921 status |= VELOCITY_AUTONEG_ENABLE;
2925 return status;
2929 * enable_flow_control_ability - flow control
2930 * @vptr: veloity to configure
2932 * Set up flow control according to the flow control options
2933 * determined by the eeprom/configuration.
2936 static void enable_flow_control_ability(struct velocity_info *vptr)
2939 struct mac_regs __iomem * regs = vptr->mac_regs;
2941 switch (vptr->options.flow_cntl) {
2943 case FLOW_CNTL_DEFAULT:
2944 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
2945 writel(CR0_FDXRFCEN, &regs->CR0Set);
2946 else
2947 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2949 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
2950 writel(CR0_FDXTFCEN, &regs->CR0Set);
2951 else
2952 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2953 break;
2955 case FLOW_CNTL_TX:
2956 writel(CR0_FDXTFCEN, &regs->CR0Set);
2957 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2958 break;
2960 case FLOW_CNTL_RX:
2961 writel(CR0_FDXRFCEN, &regs->CR0Set);
2962 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2963 break;
2965 case FLOW_CNTL_TX_RX:
2966 writel(CR0_FDXTFCEN, &regs->CR0Set);
2967 writel(CR0_FDXRFCEN, &regs->CR0Set);
2968 break;
2970 case FLOW_CNTL_DISABLE:
2971 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2972 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2973 break;
2975 default:
2976 break;
2983 * velocity_ethtool_up - pre hook for ethtool
2984 * @dev: network device
2986 * Called before an ethtool operation. We need to make sure the
2987 * chip is out of D3 state before we poke at it.
2990 static int velocity_ethtool_up(struct net_device *dev)
2992 struct velocity_info *vptr = netdev_priv(dev);
2993 if (!netif_running(dev))
2994 pci_set_power_state(vptr->pdev, PCI_D0);
2995 return 0;
2999 * velocity_ethtool_down - post hook for ethtool
3000 * @dev: network device
3002 * Called after an ethtool operation. Restore the chip back to D3
3003 * state if it isn't running.
3006 static void velocity_ethtool_down(struct net_device *dev)
3008 struct velocity_info *vptr = netdev_priv(dev);
3009 if (!netif_running(dev))
3010 pci_set_power_state(vptr->pdev, PCI_D3hot);
3013 static int velocity_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3015 struct velocity_info *vptr = netdev_priv(dev);
3016 struct mac_regs __iomem * regs = vptr->mac_regs;
3017 u32 status;
3018 status = check_connection_type(vptr->mac_regs);
3020 cmd->supported = SUPPORTED_TP |
3021 SUPPORTED_Autoneg |
3022 SUPPORTED_10baseT_Half |
3023 SUPPORTED_10baseT_Full |
3024 SUPPORTED_100baseT_Half |
3025 SUPPORTED_100baseT_Full |
3026 SUPPORTED_1000baseT_Half |
3027 SUPPORTED_1000baseT_Full;
3028 if (status & VELOCITY_SPEED_1000)
3029 cmd->speed = SPEED_1000;
3030 else if (status & VELOCITY_SPEED_100)
3031 cmd->speed = SPEED_100;
3032 else
3033 cmd->speed = SPEED_10;
3034 cmd->autoneg = (status & VELOCITY_AUTONEG_ENABLE) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3035 cmd->port = PORT_TP;
3036 cmd->transceiver = XCVR_INTERNAL;
3037 cmd->phy_address = readb(&regs->MIIADR) & 0x1F;
3039 if (status & VELOCITY_DUPLEX_FULL)
3040 cmd->duplex = DUPLEX_FULL;
3041 else
3042 cmd->duplex = DUPLEX_HALF;
3044 return 0;
3047 static int velocity_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3049 struct velocity_info *vptr = netdev_priv(dev);
3050 u32 curr_status;
3051 u32 new_status = 0;
3052 int ret = 0;
3054 curr_status = check_connection_type(vptr->mac_regs);
3055 curr_status &= (~VELOCITY_LINK_FAIL);
3057 new_status |= ((cmd->autoneg) ? VELOCITY_AUTONEG_ENABLE : 0);
3058 new_status |= ((cmd->speed == SPEED_100) ? VELOCITY_SPEED_100 : 0);
3059 new_status |= ((cmd->speed == SPEED_10) ? VELOCITY_SPEED_10 : 0);
3060 new_status |= ((cmd->duplex == DUPLEX_FULL) ? VELOCITY_DUPLEX_FULL : 0);
3062 if ((new_status & VELOCITY_AUTONEG_ENABLE) && (new_status != (curr_status | VELOCITY_AUTONEG_ENABLE)))
3063 ret = -EINVAL;
3064 else
3065 velocity_set_media_mode(vptr, new_status);
3067 return ret;
3070 static u32 velocity_get_link(struct net_device *dev)
3072 struct velocity_info *vptr = netdev_priv(dev);
3073 struct mac_regs __iomem * regs = vptr->mac_regs;
3074 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
3077 static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3079 struct velocity_info *vptr = netdev_priv(dev);
3080 strcpy(info->driver, VELOCITY_NAME);
3081 strcpy(info->version, VELOCITY_VERSION);
3082 strcpy(info->bus_info, pci_name(vptr->pdev));
3085 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3087 struct velocity_info *vptr = netdev_priv(dev);
3088 wol->supported = WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP;
3089 wol->wolopts |= WAKE_MAGIC;
3091 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3092 wol.wolopts|=WAKE_PHY;
3094 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
3095 wol->wolopts |= WAKE_UCAST;
3096 if (vptr->wol_opts & VELOCITY_WOL_ARP)
3097 wol->wolopts |= WAKE_ARP;
3098 memcpy(&wol->sopass, vptr->wol_passwd, 6);
3101 static int velocity_ethtool_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3103 struct velocity_info *vptr = netdev_priv(dev);
3105 if (!(wol->wolopts & (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP)))
3106 return -EFAULT;
3107 vptr->wol_opts = VELOCITY_WOL_MAGIC;
3110 if (wol.wolopts & WAKE_PHY) {
3111 vptr->wol_opts|=VELOCITY_WOL_PHY;
3112 vptr->flags |=VELOCITY_FLAGS_WOL_ENABLED;
3116 if (wol->wolopts & WAKE_MAGIC) {
3117 vptr->wol_opts |= VELOCITY_WOL_MAGIC;
3118 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3120 if (wol->wolopts & WAKE_UCAST) {
3121 vptr->wol_opts |= VELOCITY_WOL_UCAST;
3122 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3124 if (wol->wolopts & WAKE_ARP) {
3125 vptr->wol_opts |= VELOCITY_WOL_ARP;
3126 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3128 memcpy(vptr->wol_passwd, wol->sopass, 6);
3129 return 0;
3132 static u32 velocity_get_msglevel(struct net_device *dev)
3134 return msglevel;
3137 static void velocity_set_msglevel(struct net_device *dev, u32 value)
3139 msglevel = value;
3142 static const struct ethtool_ops velocity_ethtool_ops = {
3143 .get_settings = velocity_get_settings,
3144 .set_settings = velocity_set_settings,
3145 .get_drvinfo = velocity_get_drvinfo,
3146 .get_wol = velocity_ethtool_get_wol,
3147 .set_wol = velocity_ethtool_set_wol,
3148 .get_msglevel = velocity_get_msglevel,
3149 .set_msglevel = velocity_set_msglevel,
3150 .get_link = velocity_get_link,
3151 .begin = velocity_ethtool_up,
3152 .complete = velocity_ethtool_down
3156 * velocity_mii_ioctl - MII ioctl handler
3157 * @dev: network device
3158 * @ifr: the ifreq block for the ioctl
3159 * @cmd: the command
3161 * Process MII requests made via ioctl from the network layer. These
3162 * are used by tools like kudzu to interrogate the link state of the
3163 * hardware
3166 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3168 struct velocity_info *vptr = netdev_priv(dev);
3169 struct mac_regs __iomem * regs = vptr->mac_regs;
3170 unsigned long flags;
3171 struct mii_ioctl_data *miidata = if_mii(ifr);
3172 int err;
3174 switch (cmd) {
3175 case SIOCGMIIPHY:
3176 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
3177 break;
3178 case SIOCGMIIREG:
3179 if (!capable(CAP_NET_ADMIN))
3180 return -EPERM;
3181 if(velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
3182 return -ETIMEDOUT;
3183 break;
3184 case SIOCSMIIREG:
3185 if (!capable(CAP_NET_ADMIN))
3186 return -EPERM;
3187 spin_lock_irqsave(&vptr->lock, flags);
3188 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
3189 spin_unlock_irqrestore(&vptr->lock, flags);
3190 check_connection_type(vptr->mac_regs);
3191 if(err)
3192 return err;
3193 break;
3194 default:
3195 return -EOPNOTSUPP;
3197 return 0;
3200 #ifdef CONFIG_PM
3203 * velocity_save_context - save registers
3204 * @vptr: velocity
3205 * @context: buffer for stored context
3207 * Retrieve the current configuration from the velocity hardware
3208 * and stash it in the context structure, for use by the context
3209 * restore functions. This allows us to save things we need across
3210 * power down states
3213 static void velocity_save_context(struct velocity_info *vptr, struct velocity_context * context)
3215 struct mac_regs __iomem * regs = vptr->mac_regs;
3216 u16 i;
3217 u8 __iomem *ptr = (u8 __iomem *)regs;
3219 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
3220 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3222 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
3223 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3225 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3226 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3231 * velocity_restore_context - restore registers
3232 * @vptr: velocity
3233 * @context: buffer for stored context
3235 * Reload the register configuration from the velocity context
3236 * created by velocity_save_context.
3239 static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
3241 struct mac_regs __iomem * regs = vptr->mac_regs;
3242 int i;
3243 u8 __iomem *ptr = (u8 __iomem *)regs;
3245 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4) {
3246 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3249 /* Just skip cr0 */
3250 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3251 /* Clear */
3252 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3253 /* Set */
3254 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3257 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4) {
3258 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3261 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4) {
3262 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3265 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++) {
3266 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3272 * wol_calc_crc - WOL CRC
3273 * @pattern: data pattern
3274 * @mask_pattern: mask
3276 * Compute the wake on lan crc hashes for the packet header
3277 * we are interested in.
3280 static u16 wol_calc_crc(int size, u8 * pattern, u8 *mask_pattern)
3282 u16 crc = 0xFFFF;
3283 u8 mask;
3284 int i, j;
3286 for (i = 0; i < size; i++) {
3287 mask = mask_pattern[i];
3289 /* Skip this loop if the mask equals to zero */
3290 if (mask == 0x00)
3291 continue;
3293 for (j = 0; j < 8; j++) {
3294 if ((mask & 0x01) == 0) {
3295 mask >>= 1;
3296 continue;
3298 mask >>= 1;
3299 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
3302 /* Finally, invert the result once to get the correct data */
3303 crc = ~crc;
3304 return bitrev32(crc) >> 16;
3308 * velocity_set_wol - set up for wake on lan
3309 * @vptr: velocity to set WOL status on
3311 * Set a card up for wake on lan either by unicast or by
3312 * ARP packet.
3314 * FIXME: check static buffer is safe here
3317 static int velocity_set_wol(struct velocity_info *vptr)
3319 struct mac_regs __iomem * regs = vptr->mac_regs;
3320 static u8 buf[256];
3321 int i;
3323 static u32 mask_pattern[2][4] = {
3324 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
3325 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
3328 writew(0xFFFF, &regs->WOLCRClr);
3329 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
3330 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
3333 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3334 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
3337 if (vptr->wol_opts & VELOCITY_WOL_UCAST) {
3338 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
3341 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
3342 struct arp_packet *arp = (struct arp_packet *) buf;
3343 u16 crc;
3344 memset(buf, 0, sizeof(struct arp_packet) + 7);
3346 for (i = 0; i < 4; i++)
3347 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
3349 arp->type = htons(ETH_P_ARP);
3350 arp->ar_op = htons(1);
3352 memcpy(arp->ar_tip, vptr->ip_addr, 4);
3354 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
3355 (u8 *) & mask_pattern[0][0]);
3357 writew(crc, &regs->PatternCRC[0]);
3358 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
3361 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
3362 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
3364 writew(0x0FFF, &regs->WOLSRClr);
3366 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
3367 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
3368 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
3370 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
3373 if (vptr->mii_status & VELOCITY_SPEED_1000)
3374 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
3376 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
3379 u8 GCR;
3380 GCR = readb(&regs->CHIPGCR);
3381 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
3382 writeb(GCR, &regs->CHIPGCR);
3385 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
3386 /* Turn on SWPTAG just before entering power mode */
3387 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
3388 /* Go to bed ..... */
3389 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
3391 return 0;
3394 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
3396 struct net_device *dev = pci_get_drvdata(pdev);
3397 struct velocity_info *vptr = netdev_priv(dev);
3398 unsigned long flags;
3400 if(!netif_running(vptr->dev))
3401 return 0;
3403 netif_device_detach(vptr->dev);
3405 spin_lock_irqsave(&vptr->lock, flags);
3406 pci_save_state(pdev);
3407 #ifdef ETHTOOL_GWOL
3408 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3409 velocity_get_ip(vptr);
3410 velocity_save_context(vptr, &vptr->context);
3411 velocity_shutdown(vptr);
3412 velocity_set_wol(vptr);
3413 pci_enable_wake(pdev, 3, 1);
3414 pci_set_power_state(pdev, PCI_D3hot);
3415 } else {
3416 velocity_save_context(vptr, &vptr->context);
3417 velocity_shutdown(vptr);
3418 pci_disable_device(pdev);
3419 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3421 #else
3422 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3423 #endif
3424 spin_unlock_irqrestore(&vptr->lock, flags);
3425 return 0;
3428 static int velocity_resume(struct pci_dev *pdev)
3430 struct net_device *dev = pci_get_drvdata(pdev);
3431 struct velocity_info *vptr = netdev_priv(dev);
3432 unsigned long flags;
3433 int i;
3435 if(!netif_running(vptr->dev))
3436 return 0;
3438 pci_set_power_state(pdev, PCI_D0);
3439 pci_enable_wake(pdev, 0, 0);
3440 pci_restore_state(pdev);
3442 mac_wol_reset(vptr->mac_regs);
3444 spin_lock_irqsave(&vptr->lock, flags);
3445 velocity_restore_context(vptr, &vptr->context);
3446 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3447 mac_disable_int(vptr->mac_regs);
3449 velocity_tx_srv(vptr, 0);
3451 for (i = 0; i < vptr->num_txq; i++) {
3452 if (vptr->td_used[i]) {
3453 mac_tx_queue_wake(vptr->mac_regs, i);
3457 mac_enable_int(vptr->mac_regs);
3458 spin_unlock_irqrestore(&vptr->lock, flags);
3459 netif_device_attach(vptr->dev);
3461 return 0;
3464 #ifdef CONFIG_INET
3466 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3468 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3470 if (ifa) {
3471 struct net_device *dev = ifa->ifa_dev->dev;
3472 struct velocity_info *vptr;
3473 unsigned long flags;
3475 spin_lock_irqsave(&velocity_dev_list_lock, flags);
3476 list_for_each_entry(vptr, &velocity_dev_list, list) {
3477 if (vptr->dev == dev) {
3478 velocity_get_ip(vptr);
3479 break;
3482 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
3484 return NOTIFY_DONE;
3487 #endif
3488 #endif