avr32: Clean up and optimize the TLB operations
[linux/fpc-iii.git] / drivers / net / via-velocity.c
blob6b8d882d197b4c450e25c302e238d462718226c8
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 * rx_copybreak/alignment
12 * Scatter gather
13 * More testing
15 * The changes are (c) Copyright 2004, Red Hat Inc. <alan@redhat.com>
16 * Additional fixes and clean up: Francois Romieu
18 * This source has not been verified for use in safety critical systems.
20 * Please direct queries about the revamped driver to the linux-kernel
21 * list not VIA.
23 * Original code:
25 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
26 * All rights reserved.
28 * This software may be redistributed and/or modified under
29 * the terms of the GNU General Public License as published by the Free
30 * Software Foundation; either version 2 of the License, or
31 * any later version.
33 * This program is distributed in the hope that it will be useful, but
34 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
35 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
36 * for more details.
38 * Author: Chuang Liang-Shing, AJ Jiang
40 * Date: Jan 24, 2003
42 * MODULE_LICENSE("GPL");
47 #include <linux/module.h>
48 #include <linux/types.h>
49 #include <linux/init.h>
50 #include <linux/mm.h>
51 #include <linux/errno.h>
52 #include <linux/ioport.h>
53 #include <linux/pci.h>
54 #include <linux/kernel.h>
55 #include <linux/netdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/skbuff.h>
58 #include <linux/delay.h>
59 #include <linux/timer.h>
60 #include <linux/slab.h>
61 #include <linux/interrupt.h>
62 #include <linux/string.h>
63 #include <linux/wait.h>
64 #include <asm/io.h>
65 #include <linux/if.h>
66 #include <asm/uaccess.h>
67 #include <linux/proc_fs.h>
68 #include <linux/inetdevice.h>
69 #include <linux/reboot.h>
70 #include <linux/ethtool.h>
71 #include <linux/mii.h>
72 #include <linux/in.h>
73 #include <linux/if_arp.h>
74 #include <linux/if_vlan.h>
75 #include <linux/ip.h>
76 #include <linux/tcp.h>
77 #include <linux/udp.h>
78 #include <linux/crc-ccitt.h>
79 #include <linux/crc32.h>
81 #include "via-velocity.h"
84 static int velocity_nics = 0;
85 static int msglevel = MSG_LEVEL_INFO;
87 /**
88 * mac_get_cam_mask - Read a CAM mask
89 * @regs: register block for this velocity
90 * @mask: buffer to store mask
92 * Fetch the mask bits of the selected CAM and store them into the
93 * provided mask buffer.
96 static void mac_get_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
98 int i;
100 /* Select CAM mask */
101 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
103 writeb(0, &regs->CAMADDR);
105 /* read mask */
106 for (i = 0; i < 8; i++)
107 *mask++ = readb(&(regs->MARCAM[i]));
109 /* disable CAMEN */
110 writeb(0, &regs->CAMADDR);
112 /* Select mar */
113 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
119 * mac_set_cam_mask - Set a CAM mask
120 * @regs: register block for this velocity
121 * @mask: CAM mask to load
123 * Store a new mask into a CAM
126 static void mac_set_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
128 int i;
129 /* Select CAM mask */
130 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
132 writeb(CAMADDR_CAMEN, &regs->CAMADDR);
134 for (i = 0; i < 8; i++) {
135 writeb(*mask++, &(regs->MARCAM[i]));
137 /* disable CAMEN */
138 writeb(0, &regs->CAMADDR);
140 /* Select mar */
141 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
144 static void mac_set_vlan_cam_mask(struct mac_regs __iomem * regs, u8 * mask)
146 int i;
147 /* Select CAM mask */
148 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
150 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL, &regs->CAMADDR);
152 for (i = 0; i < 8; i++) {
153 writeb(*mask++, &(regs->MARCAM[i]));
155 /* disable CAMEN */
156 writeb(0, &regs->CAMADDR);
158 /* Select mar */
159 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
163 * mac_set_cam - set CAM data
164 * @regs: register block of this velocity
165 * @idx: Cam index
166 * @addr: 2 or 6 bytes of CAM data
168 * Load an address or vlan tag into a CAM
171 static void mac_set_cam(struct mac_regs __iomem * regs, int idx, const u8 *addr)
173 int i;
175 /* Select CAM mask */
176 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
178 idx &= (64 - 1);
180 writeb(CAMADDR_CAMEN | idx, &regs->CAMADDR);
182 for (i = 0; i < 6; i++) {
183 writeb(*addr++, &(regs->MARCAM[i]));
185 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
187 udelay(10);
189 writeb(0, &regs->CAMADDR);
191 /* Select mar */
192 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
195 static void mac_set_vlan_cam(struct mac_regs __iomem * regs, int idx,
196 const u8 *addr)
199 /* Select CAM mask */
200 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
202 idx &= (64 - 1);
204 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL | idx, &regs->CAMADDR);
205 writew(*((u16 *) addr), &regs->MARCAM[0]);
207 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
209 udelay(10);
211 writeb(0, &regs->CAMADDR);
213 /* Select mar */
214 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
219 * mac_wol_reset - reset WOL after exiting low power
220 * @regs: register block of this velocity
222 * Called after we drop out of wake on lan mode in order to
223 * reset the Wake on lan features. This function doesn't restore
224 * the rest of the logic from the result of sleep/wakeup
227 static void mac_wol_reset(struct mac_regs __iomem * regs)
230 /* Turn off SWPTAG right after leaving power mode */
231 BYTE_REG_BITS_OFF(STICKHW_SWPTAG, &regs->STICKHW);
232 /* clear sticky bits */
233 BYTE_REG_BITS_OFF((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
235 BYTE_REG_BITS_OFF(CHIPGCR_FCGMII, &regs->CHIPGCR);
236 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
237 /* disable force PME-enable */
238 writeb(WOLCFG_PMEOVR, &regs->WOLCFGClr);
239 /* disable power-event config bit */
240 writew(0xFFFF, &regs->WOLCRClr);
241 /* clear power status */
242 writew(0xFFFF, &regs->WOLSRClr);
245 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
246 static const struct ethtool_ops velocity_ethtool_ops;
249 Define module options
252 MODULE_AUTHOR("VIA Networking Technologies, Inc.");
253 MODULE_LICENSE("GPL");
254 MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
256 #define VELOCITY_PARAM(N,D) \
257 static int N[MAX_UNITS]=OPTION_DEFAULT;\
258 module_param_array(N, int, NULL, 0); \
259 MODULE_PARM_DESC(N, D);
261 #define RX_DESC_MIN 64
262 #define RX_DESC_MAX 255
263 #define RX_DESC_DEF 64
264 VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
266 #define TX_DESC_MIN 16
267 #define TX_DESC_MAX 256
268 #define TX_DESC_DEF 64
269 VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
271 #define RX_THRESH_MIN 0
272 #define RX_THRESH_MAX 3
273 #define RX_THRESH_DEF 0
274 /* rx_thresh[] is used for controlling the receive fifo threshold.
275 0: indicate the rxfifo threshold is 128 bytes.
276 1: indicate the rxfifo threshold is 512 bytes.
277 2: indicate the rxfifo threshold is 1024 bytes.
278 3: indicate the rxfifo threshold is store & forward.
280 VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
282 #define DMA_LENGTH_MIN 0
283 #define DMA_LENGTH_MAX 7
284 #define DMA_LENGTH_DEF 0
286 /* DMA_length[] is used for controlling the DMA length
287 0: 8 DWORDs
288 1: 16 DWORDs
289 2: 32 DWORDs
290 3: 64 DWORDs
291 4: 128 DWORDs
292 5: 256 DWORDs
293 6: SF(flush till emply)
294 7: SF(flush till emply)
296 VELOCITY_PARAM(DMA_length, "DMA length");
298 #define IP_ALIG_DEF 0
299 /* IP_byte_align[] is used for IP header DWORD byte aligned
300 0: indicate the IP header won't be DWORD byte aligned.(Default) .
301 1: indicate the IP header will be DWORD byte aligned.
302 In some enviroment, the IP header should be DWORD byte aligned,
303 or the packet will be droped when we receive it. (eg: IPVS)
305 VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
307 #define TX_CSUM_DEF 1
308 /* txcsum_offload[] is used for setting the checksum offload ability of NIC.
309 (We only support RX checksum offload now)
310 0: disable csum_offload[checksum offload
311 1: enable checksum offload. (Default)
313 VELOCITY_PARAM(txcsum_offload, "Enable transmit packet checksum offload");
315 #define FLOW_CNTL_DEF 1
316 #define FLOW_CNTL_MIN 1
317 #define FLOW_CNTL_MAX 5
319 /* flow_control[] is used for setting the flow control ability of NIC.
320 1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
321 2: enable TX flow control.
322 3: enable RX flow control.
323 4: enable RX/TX flow control.
324 5: disable
326 VELOCITY_PARAM(flow_control, "Enable flow control ability");
328 #define MED_LNK_DEF 0
329 #define MED_LNK_MIN 0
330 #define MED_LNK_MAX 4
331 /* speed_duplex[] is used for setting the speed and duplex mode of NIC.
332 0: indicate autonegotiation for both speed and duplex mode
333 1: indicate 100Mbps half duplex mode
334 2: indicate 100Mbps full duplex mode
335 3: indicate 10Mbps half duplex mode
336 4: indicate 10Mbps full duplex mode
338 Note:
339 if EEPROM have been set to the force mode, this option is ignored
340 by driver.
342 VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
344 #define VAL_PKT_LEN_DEF 0
345 /* ValPktLen[] is used for setting the checksum offload ability of NIC.
346 0: Receive frame with invalid layer 2 length (Default)
347 1: Drop frame with invalid layer 2 length
349 VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
351 #define WOL_OPT_DEF 0
352 #define WOL_OPT_MIN 0
353 #define WOL_OPT_MAX 7
354 /* wol_opts[] is used for controlling wake on lan behavior.
355 0: Wake up if recevied a magic packet. (Default)
356 1: Wake up if link status is on/off.
357 2: Wake up if recevied an arp packet.
358 4: Wake up if recevied any unicast packet.
359 Those value can be sumed up to support more than one option.
361 VELOCITY_PARAM(wol_opts, "Wake On Lan options");
363 #define INT_WORKS_DEF 20
364 #define INT_WORKS_MIN 10
365 #define INT_WORKS_MAX 64
367 VELOCITY_PARAM(int_works, "Number of packets per interrupt services");
369 static int rx_copybreak = 200;
370 module_param(rx_copybreak, int, 0644);
371 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
373 static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
374 const struct velocity_info_tbl *info);
375 static int velocity_get_pci_info(struct velocity_info *, struct pci_dev *pdev);
376 static void velocity_print_info(struct velocity_info *vptr);
377 static int velocity_open(struct net_device *dev);
378 static int velocity_change_mtu(struct net_device *dev, int mtu);
379 static int velocity_xmit(struct sk_buff *skb, struct net_device *dev);
380 static int velocity_intr(int irq, void *dev_instance);
381 static void velocity_set_multi(struct net_device *dev);
382 static struct net_device_stats *velocity_get_stats(struct net_device *dev);
383 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
384 static int velocity_close(struct net_device *dev);
385 static int velocity_receive_frame(struct velocity_info *, int idx);
386 static int velocity_alloc_rx_buf(struct velocity_info *, int idx);
387 static void velocity_free_rd_ring(struct velocity_info *vptr);
388 static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *);
389 static int velocity_soft_reset(struct velocity_info *vptr);
390 static void mii_init(struct velocity_info *vptr, u32 mii_status);
391 static u32 velocity_get_link(struct net_device *dev);
392 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr);
393 static void velocity_print_link_status(struct velocity_info *vptr);
394 static void safe_disable_mii_autopoll(struct mac_regs __iomem * regs);
395 static void velocity_shutdown(struct velocity_info *vptr);
396 static void enable_flow_control_ability(struct velocity_info *vptr);
397 static void enable_mii_autopoll(struct mac_regs __iomem * regs);
398 static int velocity_mii_read(struct mac_regs __iomem *, u8 byIdx, u16 * pdata);
399 static int velocity_mii_write(struct mac_regs __iomem *, u8 byMiiAddr, u16 data);
400 static u32 mii_check_media_mode(struct mac_regs __iomem * regs);
401 static u32 check_connection_type(struct mac_regs __iomem * regs);
402 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status);
404 #ifdef CONFIG_PM
406 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state);
407 static int velocity_resume(struct pci_dev *pdev);
409 static DEFINE_SPINLOCK(velocity_dev_list_lock);
410 static LIST_HEAD(velocity_dev_list);
412 #endif
414 #if defined(CONFIG_PM) && defined(CONFIG_INET)
416 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr);
418 static struct notifier_block velocity_inetaddr_notifier = {
419 .notifier_call = velocity_netdev_event,
422 static void velocity_register_notifier(void)
424 register_inetaddr_notifier(&velocity_inetaddr_notifier);
427 static void velocity_unregister_notifier(void)
429 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
432 #else
434 #define velocity_register_notifier() do {} while (0)
435 #define velocity_unregister_notifier() do {} while (0)
437 #endif
440 * Internal board variants. At the moment we have only one
443 static struct velocity_info_tbl chip_info_table[] = {
444 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
449 * Describe the PCI device identifiers that we support in this
450 * device driver. Used for hotplug autoloading.
453 static const struct pci_device_id velocity_id_table[] __devinitdata = {
454 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
458 MODULE_DEVICE_TABLE(pci, velocity_id_table);
461 * get_chip_name - identifier to name
462 * @id: chip identifier
464 * Given a chip identifier return a suitable description. Returns
465 * a pointer a static string valid while the driver is loaded.
468 static const char __devinit *get_chip_name(enum chip_type chip_id)
470 int i;
471 for (i = 0; chip_info_table[i].name != NULL; i++)
472 if (chip_info_table[i].chip_id == chip_id)
473 break;
474 return chip_info_table[i].name;
478 * velocity_remove1 - device unplug
479 * @pdev: PCI device being removed
481 * Device unload callback. Called on an unplug or on module
482 * unload for each active device that is present. Disconnects
483 * the device from the network layer and frees all the resources
486 static void __devexit velocity_remove1(struct pci_dev *pdev)
488 struct net_device *dev = pci_get_drvdata(pdev);
489 struct velocity_info *vptr = netdev_priv(dev);
491 #ifdef CONFIG_PM
492 unsigned long flags;
494 spin_lock_irqsave(&velocity_dev_list_lock, flags);
495 if (!list_empty(&velocity_dev_list))
496 list_del(&vptr->list);
497 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
498 #endif
499 unregister_netdev(dev);
500 iounmap(vptr->mac_regs);
501 pci_release_regions(pdev);
502 pci_disable_device(pdev);
503 pci_set_drvdata(pdev, NULL);
504 free_netdev(dev);
506 velocity_nics--;
510 * velocity_set_int_opt - parser for integer options
511 * @opt: pointer to option value
512 * @val: value the user requested (or -1 for default)
513 * @min: lowest value allowed
514 * @max: highest value allowed
515 * @def: default value
516 * @name: property name
517 * @dev: device name
519 * Set an integer property in the module options. This function does
520 * all the verification and checking as well as reporting so that
521 * we don't duplicate code for each option.
524 static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, char *devname)
526 if (val == -1)
527 *opt = def;
528 else if (val < min || val > max) {
529 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
530 devname, name, min, max);
531 *opt = def;
532 } else {
533 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
534 devname, name, val);
535 *opt = val;
540 * velocity_set_bool_opt - parser for boolean options
541 * @opt: pointer to option value
542 * @val: value the user requested (or -1 for default)
543 * @def: default value (yes/no)
544 * @flag: numeric value to set for true.
545 * @name: property name
546 * @dev: device name
548 * Set a boolean property in the module options. This function does
549 * all the verification and checking as well as reporting so that
550 * we don't duplicate code for each option.
553 static void __devinit velocity_set_bool_opt(u32 * opt, int val, int def, u32 flag, char *name, char *devname)
555 (*opt) &= (~flag);
556 if (val == -1)
557 *opt |= (def ? flag : 0);
558 else if (val < 0 || val > 1) {
559 printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
560 devname, name);
561 *opt |= (def ? flag : 0);
562 } else {
563 printk(KERN_INFO "%s: set parameter %s to %s\n",
564 devname, name, val ? "TRUE" : "FALSE");
565 *opt |= (val ? flag : 0);
570 * velocity_get_options - set options on device
571 * @opts: option structure for the device
572 * @index: index of option to use in module options array
573 * @devname: device name
575 * Turn the module and command options into a single structure
576 * for the current device
579 static void __devinit velocity_get_options(struct velocity_opt *opts, int index, char *devname)
582 velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
583 velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
584 velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
585 velocity_set_int_opt(&opts->numtx, TxDescriptors[index], TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF, "TxDescriptors", devname);
587 velocity_set_bool_opt(&opts->flags, txcsum_offload[index], TX_CSUM_DEF, VELOCITY_FLAGS_TX_CSUM, "txcsum_offload", devname);
588 velocity_set_int_opt(&opts->flow_cntl, flow_control[index], FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF, "flow_control", devname);
589 velocity_set_bool_opt(&opts->flags, IP_byte_align[index], IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN, "IP_byte_align", devname);
590 velocity_set_bool_opt(&opts->flags, ValPktLen[index], VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN, "ValPktLen", devname);
591 velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index], MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF, "Media link mode", devname);
592 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);
593 velocity_set_int_opt((int *) &opts->int_works, int_works[index], INT_WORKS_MIN, INT_WORKS_MAX, INT_WORKS_DEF, "Interrupt service works", devname);
594 opts->numrx = (opts->numrx & ~3);
598 * velocity_init_cam_filter - initialise CAM
599 * @vptr: velocity to program
601 * Initialize the content addressable memory used for filters. Load
602 * appropriately according to the presence of VLAN
605 static void velocity_init_cam_filter(struct velocity_info *vptr)
607 struct mac_regs __iomem * regs = vptr->mac_regs;
609 /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
610 WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
611 WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
613 /* Disable all CAMs */
614 memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
615 memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
616 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
617 mac_set_cam_mask(regs, vptr->mCAMmask);
619 /* Enable VCAMs */
620 if (vptr->vlgrp) {
621 unsigned int vid, i = 0;
623 if (!vlan_group_get_device(vptr->vlgrp, 0))
624 WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
626 for (vid = 1; (vid < VLAN_VID_MASK); vid++) {
627 if (vlan_group_get_device(vptr->vlgrp, vid)) {
628 mac_set_vlan_cam(regs, i, (u8 *) &vid);
629 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
630 if (++i >= VCAM_SIZE)
631 break;
634 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
638 static void velocity_vlan_rx_register(struct net_device *dev,
639 struct vlan_group *grp)
641 struct velocity_info *vptr = netdev_priv(dev);
643 vptr->vlgrp = grp;
646 static void velocity_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
648 struct velocity_info *vptr = netdev_priv(dev);
650 spin_lock_irq(&vptr->lock);
651 velocity_init_cam_filter(vptr);
652 spin_unlock_irq(&vptr->lock);
655 static void velocity_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
657 struct velocity_info *vptr = netdev_priv(dev);
659 spin_lock_irq(&vptr->lock);
660 vlan_group_set_device(vptr->vlgrp, vid, NULL);
661 velocity_init_cam_filter(vptr);
662 spin_unlock_irq(&vptr->lock);
667 * velocity_rx_reset - handle a receive reset
668 * @vptr: velocity we are resetting
670 * Reset the ownership and status for the receive ring side.
671 * Hand all the receive queue to the NIC.
674 static void velocity_rx_reset(struct velocity_info *vptr)
677 struct mac_regs __iomem * regs = vptr->mac_regs;
678 int i;
680 vptr->rd_dirty = vptr->rd_filled = vptr->rd_curr = 0;
683 * Init state, all RD entries belong to the NIC
685 for (i = 0; i < vptr->options.numrx; ++i)
686 vptr->rd_ring[i].rdesc0.len |= OWNED_BY_NIC;
688 writew(vptr->options.numrx, &regs->RBRDU);
689 writel(vptr->rd_pool_dma, &regs->RDBaseLo);
690 writew(0, &regs->RDIdx);
691 writew(vptr->options.numrx - 1, &regs->RDCSize);
695 * velocity_init_registers - initialise MAC registers
696 * @vptr: velocity to init
697 * @type: type of initialisation (hot or cold)
699 * Initialise the MAC on a reset or on first set up on the
700 * hardware.
703 static void velocity_init_registers(struct velocity_info *vptr,
704 enum velocity_init_type type)
706 struct mac_regs __iomem * regs = vptr->mac_regs;
707 int i, mii_status;
709 mac_wol_reset(regs);
711 switch (type) {
712 case VELOCITY_INIT_RESET:
713 case VELOCITY_INIT_WOL:
715 netif_stop_queue(vptr->dev);
718 * Reset RX to prevent RX pointer not on the 4X location
720 velocity_rx_reset(vptr);
721 mac_rx_queue_run(regs);
722 mac_rx_queue_wake(regs);
724 mii_status = velocity_get_opt_media_mode(vptr);
725 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
726 velocity_print_link_status(vptr);
727 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
728 netif_wake_queue(vptr->dev);
731 enable_flow_control_ability(vptr);
733 mac_clear_isr(regs);
734 writel(CR0_STOP, &regs->CR0Clr);
735 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
736 &regs->CR0Set);
738 break;
740 case VELOCITY_INIT_COLD:
741 default:
743 * Do reset
745 velocity_soft_reset(vptr);
746 mdelay(5);
748 mac_eeprom_reload(regs);
749 for (i = 0; i < 6; i++) {
750 writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
753 * clear Pre_ACPI bit.
755 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
756 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
757 mac_set_dma_length(regs, vptr->options.DMA_length);
759 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
761 * Back off algorithm use original IEEE standard
763 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
766 * Init CAM filter
768 velocity_init_cam_filter(vptr);
771 * Set packet filter: Receive directed and broadcast address
773 velocity_set_multi(vptr->dev);
776 * Enable MII auto-polling
778 enable_mii_autopoll(regs);
780 vptr->int_mask = INT_MASK_DEF;
782 writel(vptr->rd_pool_dma, &regs->RDBaseLo);
783 writew(vptr->options.numrx - 1, &regs->RDCSize);
784 mac_rx_queue_run(regs);
785 mac_rx_queue_wake(regs);
787 writew(vptr->options.numtx - 1, &regs->TDCSize);
789 for (i = 0; i < vptr->num_txq; i++) {
790 writel(vptr->td_pool_dma[i], &regs->TDBaseLo[i]);
791 mac_tx_queue_run(regs, i);
794 init_flow_control_register(vptr);
796 writel(CR0_STOP, &regs->CR0Clr);
797 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
799 mii_status = velocity_get_opt_media_mode(vptr);
800 netif_stop_queue(vptr->dev);
802 mii_init(vptr, mii_status);
804 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
805 velocity_print_link_status(vptr);
806 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
807 netif_wake_queue(vptr->dev);
810 enable_flow_control_ability(vptr);
811 mac_hw_mibs_init(regs);
812 mac_write_int_mask(vptr->int_mask, regs);
813 mac_clear_isr(regs);
819 * velocity_soft_reset - soft reset
820 * @vptr: velocity to reset
822 * Kick off a soft reset of the velocity adapter and then poll
823 * until the reset sequence has completed before returning.
826 static int velocity_soft_reset(struct velocity_info *vptr)
828 struct mac_regs __iomem * regs = vptr->mac_regs;
829 int i = 0;
831 writel(CR0_SFRST, &regs->CR0Set);
833 for (i = 0; i < W_MAX_TIMEOUT; i++) {
834 udelay(5);
835 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
836 break;
839 if (i == W_MAX_TIMEOUT) {
840 writel(CR0_FORSRST, &regs->CR0Set);
841 /* FIXME: PCI POSTING */
842 /* delay 2ms */
843 mdelay(2);
845 return 0;
849 * velocity_found1 - set up discovered velocity card
850 * @pdev: PCI device
851 * @ent: PCI device table entry that matched
853 * Configure a discovered adapter from scratch. Return a negative
854 * errno error code on failure paths.
857 static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
859 static int first = 1;
860 struct net_device *dev;
861 int i;
862 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
863 struct velocity_info *vptr;
864 struct mac_regs __iomem * regs;
865 int ret = -ENOMEM;
867 /* FIXME: this driver, like almost all other ethernet drivers,
868 * can support more than MAX_UNITS.
870 if (velocity_nics >= MAX_UNITS) {
871 dev_notice(&pdev->dev, "already found %d NICs.\n",
872 velocity_nics);
873 return -ENODEV;
876 dev = alloc_etherdev(sizeof(struct velocity_info));
877 if (!dev) {
878 dev_err(&pdev->dev, "allocate net device failed.\n");
879 goto out;
882 /* Chain it all together */
884 SET_NETDEV_DEV(dev, &pdev->dev);
885 vptr = netdev_priv(dev);
888 if (first) {
889 printk(KERN_INFO "%s Ver. %s\n",
890 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
891 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
892 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
893 first = 0;
896 velocity_init_info(pdev, vptr, info);
898 vptr->dev = dev;
900 dev->irq = pdev->irq;
902 ret = pci_enable_device(pdev);
903 if (ret < 0)
904 goto err_free_dev;
906 ret = velocity_get_pci_info(vptr, pdev);
907 if (ret < 0) {
908 /* error message already printed */
909 goto err_disable;
912 ret = pci_request_regions(pdev, VELOCITY_NAME);
913 if (ret < 0) {
914 dev_err(&pdev->dev, "No PCI resources.\n");
915 goto err_disable;
918 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
919 if (regs == NULL) {
920 ret = -EIO;
921 goto err_release_res;
924 vptr->mac_regs = regs;
926 mac_wol_reset(regs);
928 dev->base_addr = vptr->ioaddr;
930 for (i = 0; i < 6; i++)
931 dev->dev_addr[i] = readb(&regs->PAR[i]);
934 velocity_get_options(&vptr->options, velocity_nics, dev->name);
937 * Mask out the options cannot be set to the chip
940 vptr->options.flags &= info->flags;
943 * Enable the chip specified capbilities
946 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
948 vptr->wol_opts = vptr->options.wol_opts;
949 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
951 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
953 dev->irq = pdev->irq;
954 dev->open = velocity_open;
955 dev->hard_start_xmit = velocity_xmit;
956 dev->stop = velocity_close;
957 dev->get_stats = velocity_get_stats;
958 dev->set_multicast_list = velocity_set_multi;
959 dev->do_ioctl = velocity_ioctl;
960 dev->ethtool_ops = &velocity_ethtool_ops;
961 dev->change_mtu = velocity_change_mtu;
963 dev->vlan_rx_add_vid = velocity_vlan_rx_add_vid;
964 dev->vlan_rx_kill_vid = velocity_vlan_rx_kill_vid;
965 dev->vlan_rx_register = velocity_vlan_rx_register;
967 #ifdef VELOCITY_ZERO_COPY_SUPPORT
968 dev->features |= NETIF_F_SG;
969 #endif
970 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
971 NETIF_F_HW_VLAN_RX;
973 if (vptr->flags & VELOCITY_FLAGS_TX_CSUM)
974 dev->features |= NETIF_F_IP_CSUM;
976 ret = register_netdev(dev);
977 if (ret < 0)
978 goto err_iounmap;
980 if (velocity_get_link(dev))
981 netif_carrier_off(dev);
983 velocity_print_info(vptr);
984 pci_set_drvdata(pdev, dev);
986 /* and leave the chip powered down */
988 pci_set_power_state(pdev, PCI_D3hot);
989 #ifdef CONFIG_PM
991 unsigned long flags;
993 spin_lock_irqsave(&velocity_dev_list_lock, flags);
994 list_add(&vptr->list, &velocity_dev_list);
995 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
997 #endif
998 velocity_nics++;
999 out:
1000 return ret;
1002 err_iounmap:
1003 iounmap(regs);
1004 err_release_res:
1005 pci_release_regions(pdev);
1006 err_disable:
1007 pci_disable_device(pdev);
1008 err_free_dev:
1009 free_netdev(dev);
1010 goto out;
1014 * velocity_print_info - per driver data
1015 * @vptr: velocity
1017 * Print per driver data as the kernel driver finds Velocity
1018 * hardware
1021 static void __devinit velocity_print_info(struct velocity_info *vptr)
1023 struct net_device *dev = vptr->dev;
1025 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
1026 printk(KERN_INFO "%s: Ethernet Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1027 dev->name,
1028 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1029 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1033 * velocity_init_info - init private data
1034 * @pdev: PCI device
1035 * @vptr: Velocity info
1036 * @info: Board type
1038 * Set up the initial velocity_info struct for the device that has been
1039 * discovered.
1042 static void __devinit velocity_init_info(struct pci_dev *pdev,
1043 struct velocity_info *vptr,
1044 const struct velocity_info_tbl *info)
1046 memset(vptr, 0, sizeof(struct velocity_info));
1048 vptr->pdev = pdev;
1049 vptr->chip_id = info->chip_id;
1050 vptr->num_txq = info->txqueue;
1051 vptr->multicast_limit = MCAM_SIZE;
1052 spin_lock_init(&vptr->lock);
1053 INIT_LIST_HEAD(&vptr->list);
1057 * velocity_get_pci_info - retrieve PCI info for device
1058 * @vptr: velocity device
1059 * @pdev: PCI device it matches
1061 * Retrieve the PCI configuration space data that interests us from
1062 * the kernel PCI layer
1065 static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
1067 vptr->rev_id = pdev->revision;
1069 pci_set_master(pdev);
1071 vptr->ioaddr = pci_resource_start(pdev, 0);
1072 vptr->memaddr = pci_resource_start(pdev, 1);
1074 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
1075 dev_err(&pdev->dev,
1076 "region #0 is not an I/O resource, aborting.\n");
1077 return -EINVAL;
1080 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
1081 dev_err(&pdev->dev,
1082 "region #1 is an I/O resource, aborting.\n");
1083 return -EINVAL;
1086 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
1087 dev_err(&pdev->dev, "region #1 is too small.\n");
1088 return -EINVAL;
1090 vptr->pdev = pdev;
1092 return 0;
1096 * velocity_init_rings - set up DMA rings
1097 * @vptr: Velocity to set up
1099 * Allocate PCI mapped DMA rings for the receive and transmit layer
1100 * to use.
1103 static int velocity_init_rings(struct velocity_info *vptr)
1105 int i;
1106 unsigned int psize;
1107 unsigned int tsize;
1108 dma_addr_t pool_dma;
1109 u8 *pool;
1112 * Allocate all RD/TD rings a single pool
1115 psize = vptr->options.numrx * sizeof(struct rx_desc) +
1116 vptr->options.numtx * sizeof(struct tx_desc) * vptr->num_txq;
1119 * pci_alloc_consistent() fulfills the requirement for 64 bytes
1120 * alignment
1122 pool = pci_alloc_consistent(vptr->pdev, psize, &pool_dma);
1124 if (pool == NULL) {
1125 printk(KERN_ERR "%s : DMA memory allocation failed.\n",
1126 vptr->dev->name);
1127 return -ENOMEM;
1130 memset(pool, 0, psize);
1132 vptr->rd_ring = (struct rx_desc *) pool;
1134 vptr->rd_pool_dma = pool_dma;
1136 tsize = vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq;
1137 vptr->tx_bufs = pci_alloc_consistent(vptr->pdev, tsize,
1138 &vptr->tx_bufs_dma);
1140 if (vptr->tx_bufs == NULL) {
1141 printk(KERN_ERR "%s: DMA memory allocation failed.\n",
1142 vptr->dev->name);
1143 pci_free_consistent(vptr->pdev, psize, pool, pool_dma);
1144 return -ENOMEM;
1147 memset(vptr->tx_bufs, 0, vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq);
1149 i = vptr->options.numrx * sizeof(struct rx_desc);
1150 pool += i;
1151 pool_dma += i;
1152 for (i = 0; i < vptr->num_txq; i++) {
1153 int offset = vptr->options.numtx * sizeof(struct tx_desc);
1155 vptr->td_pool_dma[i] = pool_dma;
1156 vptr->td_rings[i] = (struct tx_desc *) pool;
1157 pool += offset;
1158 pool_dma += offset;
1160 return 0;
1164 * velocity_free_rings - free PCI ring pointers
1165 * @vptr: Velocity to free from
1167 * Clean up the PCI ring buffers allocated to this velocity.
1170 static void velocity_free_rings(struct velocity_info *vptr)
1172 int size;
1174 size = vptr->options.numrx * sizeof(struct rx_desc) +
1175 vptr->options.numtx * sizeof(struct tx_desc) * vptr->num_txq;
1177 pci_free_consistent(vptr->pdev, size, vptr->rd_ring, vptr->rd_pool_dma);
1179 size = vptr->options.numtx * PKT_BUF_SZ * vptr->num_txq;
1181 pci_free_consistent(vptr->pdev, size, vptr->tx_bufs, vptr->tx_bufs_dma);
1184 static inline void velocity_give_many_rx_descs(struct velocity_info *vptr)
1186 struct mac_regs __iomem *regs = vptr->mac_regs;
1187 int avail, dirty, unusable;
1190 * RD number must be equal to 4X per hardware spec
1191 * (programming guide rev 1.20, p.13)
1193 if (vptr->rd_filled < 4)
1194 return;
1196 wmb();
1198 unusable = vptr->rd_filled & 0x0003;
1199 dirty = vptr->rd_dirty - unusable;
1200 for (avail = vptr->rd_filled & 0xfffc; avail; avail--) {
1201 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1202 vptr->rd_ring[dirty].rdesc0.len |= OWNED_BY_NIC;
1205 writew(vptr->rd_filled & 0xfffc, &regs->RBRDU);
1206 vptr->rd_filled = unusable;
1209 static int velocity_rx_refill(struct velocity_info *vptr)
1211 int dirty = vptr->rd_dirty, done = 0, ret = 0;
1213 do {
1214 struct rx_desc *rd = vptr->rd_ring + dirty;
1216 /* Fine for an all zero Rx desc at init time as well */
1217 if (rd->rdesc0.len & OWNED_BY_NIC)
1218 break;
1220 if (!vptr->rd_info[dirty].skb) {
1221 ret = velocity_alloc_rx_buf(vptr, dirty);
1222 if (ret < 0)
1223 break;
1225 done++;
1226 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
1227 } while (dirty != vptr->rd_curr);
1229 if (done) {
1230 vptr->rd_dirty = dirty;
1231 vptr->rd_filled += done;
1232 velocity_give_many_rx_descs(vptr);
1235 return ret;
1239 * velocity_init_rd_ring - set up receive ring
1240 * @vptr: velocity to configure
1242 * Allocate and set up the receive buffers for each ring slot and
1243 * assign them to the network adapter.
1246 static int velocity_init_rd_ring(struct velocity_info *vptr)
1248 int ret;
1249 int mtu = vptr->dev->mtu;
1251 vptr->rx_buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1253 vptr->rd_info = kcalloc(vptr->options.numrx,
1254 sizeof(struct velocity_rd_info), GFP_KERNEL);
1255 if (!vptr->rd_info)
1256 return -ENOMEM;
1258 vptr->rd_filled = vptr->rd_dirty = vptr->rd_curr = 0;
1260 ret = velocity_rx_refill(vptr);
1261 if (ret < 0) {
1262 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1263 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1264 velocity_free_rd_ring(vptr);
1267 return ret;
1271 * velocity_free_rd_ring - free receive ring
1272 * @vptr: velocity to clean up
1274 * Free the receive buffers for each ring slot and any
1275 * attached socket buffers that need to go away.
1278 static void velocity_free_rd_ring(struct velocity_info *vptr)
1280 int i;
1282 if (vptr->rd_info == NULL)
1283 return;
1285 for (i = 0; i < vptr->options.numrx; i++) {
1286 struct velocity_rd_info *rd_info = &(vptr->rd_info[i]);
1287 struct rx_desc *rd = vptr->rd_ring + i;
1289 memset(rd, 0, sizeof(*rd));
1291 if (!rd_info->skb)
1292 continue;
1293 pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx_buf_sz,
1294 PCI_DMA_FROMDEVICE);
1295 rd_info->skb_dma = (dma_addr_t) NULL;
1297 dev_kfree_skb(rd_info->skb);
1298 rd_info->skb = NULL;
1301 kfree(vptr->rd_info);
1302 vptr->rd_info = NULL;
1306 * velocity_init_td_ring - set up transmit ring
1307 * @vptr: velocity
1309 * Set up the transmit ring and chain the ring pointers together.
1310 * Returns zero on success or a negative posix errno code for
1311 * failure.
1314 static int velocity_init_td_ring(struct velocity_info *vptr)
1316 int i, j;
1317 dma_addr_t curr;
1318 struct tx_desc *td;
1319 struct velocity_td_info *td_info;
1321 /* Init the TD ring entries */
1322 for (j = 0; j < vptr->num_txq; j++) {
1323 curr = vptr->td_pool_dma[j];
1325 vptr->td_infos[j] = kcalloc(vptr->options.numtx,
1326 sizeof(struct velocity_td_info),
1327 GFP_KERNEL);
1328 if (!vptr->td_infos[j]) {
1329 while(--j >= 0)
1330 kfree(vptr->td_infos[j]);
1331 return -ENOMEM;
1334 for (i = 0; i < vptr->options.numtx; i++, curr += sizeof(struct tx_desc)) {
1335 td = &(vptr->td_rings[j][i]);
1336 td_info = &(vptr->td_infos[j][i]);
1337 td_info->buf = vptr->tx_bufs +
1338 (j * vptr->options.numtx + i) * PKT_BUF_SZ;
1339 td_info->buf_dma = vptr->tx_bufs_dma +
1340 (j * vptr->options.numtx + i) * PKT_BUF_SZ;
1342 vptr->td_tail[j] = vptr->td_curr[j] = vptr->td_used[j] = 0;
1344 return 0;
1348 * FIXME: could we merge this with velocity_free_tx_buf ?
1351 static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1352 int q, int n)
1354 struct velocity_td_info * td_info = &(vptr->td_infos[q][n]);
1355 int i;
1357 if (td_info == NULL)
1358 return;
1360 if (td_info->skb) {
1361 for (i = 0; i < td_info->nskb_dma; i++)
1363 if (td_info->skb_dma[i]) {
1364 pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
1365 td_info->skb->len, PCI_DMA_TODEVICE);
1366 td_info->skb_dma[i] = (dma_addr_t) NULL;
1369 dev_kfree_skb(td_info->skb);
1370 td_info->skb = NULL;
1375 * velocity_free_td_ring - free td ring
1376 * @vptr: velocity
1378 * Free up the transmit ring for this particular velocity adapter.
1379 * We free the ring contents but not the ring itself.
1382 static void velocity_free_td_ring(struct velocity_info *vptr)
1384 int i, j;
1386 for (j = 0; j < vptr->num_txq; j++) {
1387 if (vptr->td_infos[j] == NULL)
1388 continue;
1389 for (i = 0; i < vptr->options.numtx; i++) {
1390 velocity_free_td_ring_entry(vptr, j, i);
1393 kfree(vptr->td_infos[j]);
1394 vptr->td_infos[j] = NULL;
1399 * velocity_rx_srv - service RX interrupt
1400 * @vptr: velocity
1401 * @status: adapter status (unused)
1403 * Walk the receive ring of the velocity adapter and remove
1404 * any received packets from the receive queue. Hand the ring
1405 * slots back to the adapter for reuse.
1408 static int velocity_rx_srv(struct velocity_info *vptr, int status)
1410 struct net_device_stats *stats = &vptr->stats;
1411 int rd_curr = vptr->rd_curr;
1412 int works = 0;
1414 do {
1415 struct rx_desc *rd = vptr->rd_ring + rd_curr;
1417 if (!vptr->rd_info[rd_curr].skb)
1418 break;
1420 if (rd->rdesc0.len & OWNED_BY_NIC)
1421 break;
1423 rmb();
1426 * Don't drop CE or RL error frame although RXOK is off
1428 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) {
1429 if (velocity_receive_frame(vptr, rd_curr) < 0)
1430 stats->rx_dropped++;
1431 } else {
1432 if (rd->rdesc0.RSR & RSR_CRC)
1433 stats->rx_crc_errors++;
1434 if (rd->rdesc0.RSR & RSR_FAE)
1435 stats->rx_frame_errors++;
1437 stats->rx_dropped++;
1440 rd->size |= RX_INTEN;
1442 vptr->dev->last_rx = jiffies;
1444 rd_curr++;
1445 if (rd_curr >= vptr->options.numrx)
1446 rd_curr = 0;
1447 } while (++works <= 15);
1449 vptr->rd_curr = rd_curr;
1451 if (works > 0 && velocity_rx_refill(vptr) < 0) {
1452 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1453 "%s: rx buf allocation failure\n", vptr->dev->name);
1456 VAR_USED(stats);
1457 return works;
1461 * velocity_rx_csum - checksum process
1462 * @rd: receive packet descriptor
1463 * @skb: network layer packet buffer
1465 * Process the status bits for the received packet and determine
1466 * if the checksum was computed and verified by the hardware
1469 static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1471 skb->ip_summed = CHECKSUM_NONE;
1473 if (rd->rdesc1.CSM & CSM_IPKT) {
1474 if (rd->rdesc1.CSM & CSM_IPOK) {
1475 if ((rd->rdesc1.CSM & CSM_TCPKT) ||
1476 (rd->rdesc1.CSM & CSM_UDPKT)) {
1477 if (!(rd->rdesc1.CSM & CSM_TUPOK)) {
1478 return;
1481 skb->ip_summed = CHECKSUM_UNNECESSARY;
1487 * velocity_rx_copy - in place Rx copy for small packets
1488 * @rx_skb: network layer packet buffer candidate
1489 * @pkt_size: received data size
1490 * @rd: receive packet descriptor
1491 * @dev: network device
1493 * Replace the current skb that is scheduled for Rx processing by a
1494 * shorter, immediatly allocated skb, if the received packet is small
1495 * enough. This function returns a negative value if the received
1496 * packet is too big or if memory is exhausted.
1498 static inline int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
1499 struct velocity_info *vptr)
1501 int ret = -1;
1503 if (pkt_size < rx_copybreak) {
1504 struct sk_buff *new_skb;
1506 new_skb = dev_alloc_skb(pkt_size + 2);
1507 if (new_skb) {
1508 new_skb->dev = vptr->dev;
1509 new_skb->ip_summed = rx_skb[0]->ip_summed;
1511 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN)
1512 skb_reserve(new_skb, 2);
1514 skb_copy_from_linear_data(rx_skb[0], new_skb->data,
1515 pkt_size);
1516 *rx_skb = new_skb;
1517 ret = 0;
1521 return ret;
1525 * velocity_iph_realign - IP header alignment
1526 * @vptr: velocity we are handling
1527 * @skb: network layer packet buffer
1528 * @pkt_size: received data size
1530 * Align IP header on a 2 bytes boundary. This behavior can be
1531 * configured by the user.
1533 static inline void velocity_iph_realign(struct velocity_info *vptr,
1534 struct sk_buff *skb, int pkt_size)
1536 /* FIXME - memmove ? */
1537 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
1538 int i;
1540 for (i = pkt_size; i >= 0; i--)
1541 *(skb->data + i + 2) = *(skb->data + i);
1542 skb_reserve(skb, 2);
1547 * velocity_receive_frame - received packet processor
1548 * @vptr: velocity we are handling
1549 * @idx: ring index
1551 * A packet has arrived. We process the packet and if appropriate
1552 * pass the frame up the network stack
1555 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
1557 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
1558 struct net_device_stats *stats = &vptr->stats;
1559 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
1560 struct rx_desc *rd = &(vptr->rd_ring[idx]);
1561 int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
1562 struct sk_buff *skb;
1564 if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
1565 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
1566 stats->rx_length_errors++;
1567 return -EINVAL;
1570 if (rd->rdesc0.RSR & RSR_MAR)
1571 vptr->stats.multicast++;
1573 skb = rd_info->skb;
1575 pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
1576 vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1579 * Drop frame not meeting IEEE 802.3
1582 if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
1583 if (rd->rdesc0.RSR & RSR_RL) {
1584 stats->rx_length_errors++;
1585 return -EINVAL;
1589 pci_action = pci_dma_sync_single_for_device;
1591 velocity_rx_csum(rd, skb);
1593 if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
1594 velocity_iph_realign(vptr, skb, pkt_len);
1595 pci_action = pci_unmap_single;
1596 rd_info->skb = NULL;
1599 pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx_buf_sz,
1600 PCI_DMA_FROMDEVICE);
1602 skb_put(skb, pkt_len - 4);
1603 skb->protocol = eth_type_trans(skb, vptr->dev);
1605 if (vptr->vlgrp && (rd->rdesc0.RSR & RSR_DETAG)) {
1606 vlan_hwaccel_rx(skb, vptr->vlgrp,
1607 swab16(le16_to_cpu(rd->rdesc1.PQTAG)));
1608 } else
1609 netif_rx(skb);
1611 stats->rx_bytes += pkt_len;
1613 return 0;
1617 * velocity_alloc_rx_buf - allocate aligned receive buffer
1618 * @vptr: velocity
1619 * @idx: ring index
1621 * Allocate a new full sized buffer for the reception of a frame and
1622 * map it into PCI space for the hardware to use. The hardware
1623 * requires *64* byte alignment of the buffer which makes life
1624 * less fun than would be ideal.
1627 static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1629 struct rx_desc *rd = &(vptr->rd_ring[idx]);
1630 struct velocity_rd_info *rd_info = &(vptr->rd_info[idx]);
1632 rd_info->skb = dev_alloc_skb(vptr->rx_buf_sz + 64);
1633 if (rd_info->skb == NULL)
1634 return -ENOMEM;
1637 * Do the gymnastics to get the buffer head for data at
1638 * 64byte alignment.
1640 skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->data & 63);
1641 rd_info->skb->dev = vptr->dev;
1642 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data, vptr->rx_buf_sz, PCI_DMA_FROMDEVICE);
1645 * Fill in the descriptor to match
1648 *((u32 *) & (rd->rdesc0)) = 0;
1649 rd->size = cpu_to_le16(vptr->rx_buf_sz) | RX_INTEN;
1650 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1651 rd->pa_high = 0;
1652 return 0;
1656 * tx_srv - transmit interrupt service
1657 * @vptr; Velocity
1658 * @status:
1660 * Scan the queues looking for transmitted packets that
1661 * we can complete and clean up. Update any statistics as
1662 * necessary/
1665 static int velocity_tx_srv(struct velocity_info *vptr, u32 status)
1667 struct tx_desc *td;
1668 int qnum;
1669 int full = 0;
1670 int idx;
1671 int works = 0;
1672 struct velocity_td_info *tdinfo;
1673 struct net_device_stats *stats = &vptr->stats;
1675 for (qnum = 0; qnum < vptr->num_txq; qnum++) {
1676 for (idx = vptr->td_tail[qnum]; vptr->td_used[qnum] > 0;
1677 idx = (idx + 1) % vptr->options.numtx) {
1680 * Get Tx Descriptor
1682 td = &(vptr->td_rings[qnum][idx]);
1683 tdinfo = &(vptr->td_infos[qnum][idx]);
1685 if (td->tdesc0.len & OWNED_BY_NIC)
1686 break;
1688 if ((works++ > 15))
1689 break;
1691 if (td->tdesc0.TSR & TSR0_TERR) {
1692 stats->tx_errors++;
1693 stats->tx_dropped++;
1694 if (td->tdesc0.TSR & TSR0_CDH)
1695 stats->tx_heartbeat_errors++;
1696 if (td->tdesc0.TSR & TSR0_CRS)
1697 stats->tx_carrier_errors++;
1698 if (td->tdesc0.TSR & TSR0_ABT)
1699 stats->tx_aborted_errors++;
1700 if (td->tdesc0.TSR & TSR0_OWC)
1701 stats->tx_window_errors++;
1702 } else {
1703 stats->tx_packets++;
1704 stats->tx_bytes += tdinfo->skb->len;
1706 velocity_free_tx_buf(vptr, tdinfo);
1707 vptr->td_used[qnum]--;
1709 vptr->td_tail[qnum] = idx;
1711 if (AVAIL_TD(vptr, qnum) < 1) {
1712 full = 1;
1716 * Look to see if we should kick the transmit network
1717 * layer for more work.
1719 if (netif_queue_stopped(vptr->dev) && (full == 0)
1720 && (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1721 netif_wake_queue(vptr->dev);
1723 return works;
1727 * velocity_print_link_status - link status reporting
1728 * @vptr: velocity to report on
1730 * Turn the link status of the velocity card into a kernel log
1731 * description of the new link state, detailing speed and duplex
1732 * status
1735 static void velocity_print_link_status(struct velocity_info *vptr)
1738 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1739 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1740 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1741 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1743 if (vptr->mii_status & VELOCITY_SPEED_1000)
1744 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1745 else if (vptr->mii_status & VELOCITY_SPEED_100)
1746 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1747 else
1748 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1750 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1751 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1752 else
1753 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1754 } else {
1755 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1756 switch (vptr->options.spd_dpx) {
1757 case SPD_DPX_100_HALF:
1758 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1759 break;
1760 case SPD_DPX_100_FULL:
1761 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1762 break;
1763 case SPD_DPX_10_HALF:
1764 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1765 break;
1766 case SPD_DPX_10_FULL:
1767 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1768 break;
1769 default:
1770 break;
1776 * velocity_error - handle error from controller
1777 * @vptr: velocity
1778 * @status: card status
1780 * Process an error report from the hardware and attempt to recover
1781 * the card itself. At the moment we cannot recover from some
1782 * theoretically impossible errors but this could be fixed using
1783 * the pci_device_failed logic to bounce the hardware
1787 static void velocity_error(struct velocity_info *vptr, int status)
1790 if (status & ISR_TXSTLI) {
1791 struct mac_regs __iomem * regs = vptr->mac_regs;
1793 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1794 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1795 writew(TRDCSR_RUN, &regs->TDCSRClr);
1796 netif_stop_queue(vptr->dev);
1798 /* FIXME: port over the pci_device_failed code and use it
1799 here */
1802 if (status & ISR_SRCI) {
1803 struct mac_regs __iomem * regs = vptr->mac_regs;
1804 int linked;
1806 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1807 vptr->mii_status = check_connection_type(regs);
1810 * If it is a 3119, disable frame bursting in
1811 * halfduplex mode and enable it in fullduplex
1812 * mode
1814 if (vptr->rev_id < REV_ID_VT3216_A0) {
1815 if (vptr->mii_status | VELOCITY_DUPLEX_FULL)
1816 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1817 else
1818 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1821 * Only enable CD heart beat counter in 10HD mode
1823 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10)) {
1824 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1825 } else {
1826 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1830 * Get link status from PHYSR0
1832 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1834 if (linked) {
1835 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1836 netif_carrier_on(vptr->dev);
1837 } else {
1838 vptr->mii_status |= VELOCITY_LINK_FAIL;
1839 netif_carrier_off(vptr->dev);
1842 velocity_print_link_status(vptr);
1843 enable_flow_control_ability(vptr);
1846 * Re-enable auto-polling because SRCI will disable
1847 * auto-polling
1850 enable_mii_autopoll(regs);
1852 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1853 netif_stop_queue(vptr->dev);
1854 else
1855 netif_wake_queue(vptr->dev);
1858 if (status & ISR_MIBFI)
1859 velocity_update_hw_mibs(vptr);
1860 if (status & ISR_LSTEI)
1861 mac_rx_queue_wake(vptr->mac_regs);
1865 * velocity_free_tx_buf - free transmit buffer
1866 * @vptr: velocity
1867 * @tdinfo: buffer
1869 * Release an transmit buffer. If the buffer was preallocated then
1870 * recycle it, if not then unmap the buffer.
1873 static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *tdinfo)
1875 struct sk_buff *skb = tdinfo->skb;
1876 int i;
1879 * Don't unmap the pre-allocated tx_bufs
1881 if (tdinfo->skb_dma && (tdinfo->skb_dma[0] != tdinfo->buf_dma)) {
1883 for (i = 0; i < tdinfo->nskb_dma; i++) {
1884 #ifdef VELOCITY_ZERO_COPY_SUPPORT
1885 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], le16_to_cpu(td->tdesc1.len), PCI_DMA_TODEVICE);
1886 #else
1887 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], skb->len, PCI_DMA_TODEVICE);
1888 #endif
1889 tdinfo->skb_dma[i] = 0;
1892 dev_kfree_skb_irq(skb);
1893 tdinfo->skb = NULL;
1897 * velocity_open - interface activation callback
1898 * @dev: network layer device to open
1900 * Called when the network layer brings the interface up. Returns
1901 * a negative posix error code on failure, or zero on success.
1903 * All the ring allocation and set up is done on open for this
1904 * adapter to minimise memory usage when inactive
1907 static int velocity_open(struct net_device *dev)
1909 struct velocity_info *vptr = netdev_priv(dev);
1910 int ret;
1912 ret = velocity_init_rings(vptr);
1913 if (ret < 0)
1914 goto out;
1916 ret = velocity_init_rd_ring(vptr);
1917 if (ret < 0)
1918 goto err_free_desc_rings;
1920 ret = velocity_init_td_ring(vptr);
1921 if (ret < 0)
1922 goto err_free_rd_ring;
1924 /* Ensure chip is running */
1925 pci_set_power_state(vptr->pdev, PCI_D0);
1927 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
1929 ret = request_irq(vptr->pdev->irq, &velocity_intr, IRQF_SHARED,
1930 dev->name, dev);
1931 if (ret < 0) {
1932 /* Power down the chip */
1933 pci_set_power_state(vptr->pdev, PCI_D3hot);
1934 goto err_free_td_ring;
1937 mac_enable_int(vptr->mac_regs);
1938 netif_start_queue(dev);
1939 vptr->flags |= VELOCITY_FLAGS_OPENED;
1940 out:
1941 return ret;
1943 err_free_td_ring:
1944 velocity_free_td_ring(vptr);
1945 err_free_rd_ring:
1946 velocity_free_rd_ring(vptr);
1947 err_free_desc_rings:
1948 velocity_free_rings(vptr);
1949 goto out;
1953 * velocity_change_mtu - MTU change callback
1954 * @dev: network device
1955 * @new_mtu: desired MTU
1957 * Handle requests from the networking layer for MTU change on
1958 * this interface. It gets called on a change by the network layer.
1959 * Return zero for success or negative posix error code.
1962 static int velocity_change_mtu(struct net_device *dev, int new_mtu)
1964 struct velocity_info *vptr = netdev_priv(dev);
1965 unsigned long flags;
1966 int oldmtu = dev->mtu;
1967 int ret = 0;
1969 if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
1970 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
1971 vptr->dev->name);
1972 return -EINVAL;
1975 if (!netif_running(dev)) {
1976 dev->mtu = new_mtu;
1977 return 0;
1980 if (new_mtu != oldmtu) {
1981 spin_lock_irqsave(&vptr->lock, flags);
1983 netif_stop_queue(dev);
1984 velocity_shutdown(vptr);
1986 velocity_free_td_ring(vptr);
1987 velocity_free_rd_ring(vptr);
1989 dev->mtu = new_mtu;
1991 ret = velocity_init_rd_ring(vptr);
1992 if (ret < 0)
1993 goto out_unlock;
1995 ret = velocity_init_td_ring(vptr);
1996 if (ret < 0)
1997 goto out_unlock;
1999 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2001 mac_enable_int(vptr->mac_regs);
2002 netif_start_queue(dev);
2003 out_unlock:
2004 spin_unlock_irqrestore(&vptr->lock, flags);
2007 return ret;
2011 * velocity_shutdown - shut down the chip
2012 * @vptr: velocity to deactivate
2014 * Shuts down the internal operations of the velocity and
2015 * disables interrupts, autopolling, transmit and receive
2018 static void velocity_shutdown(struct velocity_info *vptr)
2020 struct mac_regs __iomem * regs = vptr->mac_regs;
2021 mac_disable_int(regs);
2022 writel(CR0_STOP, &regs->CR0Set);
2023 writew(0xFFFF, &regs->TDCSRClr);
2024 writeb(0xFF, &regs->RDCSRClr);
2025 safe_disable_mii_autopoll(regs);
2026 mac_clear_isr(regs);
2030 * velocity_close - close adapter callback
2031 * @dev: network device
2033 * Callback from the network layer when the velocity is being
2034 * deactivated by the network layer
2037 static int velocity_close(struct net_device *dev)
2039 struct velocity_info *vptr = netdev_priv(dev);
2041 netif_stop_queue(dev);
2042 velocity_shutdown(vptr);
2044 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
2045 velocity_get_ip(vptr);
2046 if (dev->irq != 0)
2047 free_irq(dev->irq, dev);
2049 /* Power down the chip */
2050 pci_set_power_state(vptr->pdev, PCI_D3hot);
2052 /* Free the resources */
2053 velocity_free_td_ring(vptr);
2054 velocity_free_rd_ring(vptr);
2055 velocity_free_rings(vptr);
2057 vptr->flags &= (~VELOCITY_FLAGS_OPENED);
2058 return 0;
2062 * velocity_xmit - transmit packet callback
2063 * @skb: buffer to transmit
2064 * @dev: network device
2066 * Called by the networ layer to request a packet is queued to
2067 * the velocity. Returns zero on success.
2070 static int velocity_xmit(struct sk_buff *skb, struct net_device *dev)
2072 struct velocity_info *vptr = netdev_priv(dev);
2073 int qnum = 0;
2074 struct tx_desc *td_ptr;
2075 struct velocity_td_info *tdinfo;
2076 unsigned long flags;
2077 int index;
2078 int pktlen = skb->len;
2079 __le16 len = cpu_to_le16(pktlen);
2081 #ifdef VELOCITY_ZERO_COPY_SUPPORT
2082 if (skb_shinfo(skb)->nr_frags > 6 && __skb_linearize(skb)) {
2083 kfree_skb(skb);
2084 return 0;
2086 #endif
2088 spin_lock_irqsave(&vptr->lock, flags);
2090 index = vptr->td_curr[qnum];
2091 td_ptr = &(vptr->td_rings[qnum][index]);
2092 tdinfo = &(vptr->td_infos[qnum][index]);
2094 td_ptr->tdesc1.TCR = TCR0_TIC;
2095 td_ptr->td_buf[0].size &= ~TD_QUEUE;
2098 * Pad short frames.
2100 if (pktlen < ETH_ZLEN) {
2101 /* Cannot occur until ZC support */
2102 pktlen = ETH_ZLEN;
2103 len = cpu_to_le16(ETH_ZLEN);
2104 skb_copy_from_linear_data(skb, tdinfo->buf, skb->len);
2105 memset(tdinfo->buf + skb->len, 0, ETH_ZLEN - skb->len);
2106 tdinfo->skb = skb;
2107 tdinfo->skb_dma[0] = tdinfo->buf_dma;
2108 td_ptr->tdesc0.len = len;
2109 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2110 td_ptr->td_buf[0].pa_high = 0;
2111 td_ptr->td_buf[0].size = len; /* queue is 0 anyway */
2112 tdinfo->nskb_dma = 1;
2113 } else
2114 #ifdef VELOCITY_ZERO_COPY_SUPPORT
2115 if (skb_shinfo(skb)->nr_frags > 0) {
2116 int nfrags = skb_shinfo(skb)->nr_frags;
2117 tdinfo->skb = skb;
2118 if (nfrags > 6) {
2119 skb_copy_from_linear_data(skb, tdinfo->buf, skb->len);
2120 tdinfo->skb_dma[0] = tdinfo->buf_dma;
2121 td_ptr->tdesc0.len = len;
2122 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2123 td_ptr->td_buf[0].pa_high = 0;
2124 td_ptr->td_buf[0].size = len; /* queue is 0 anyway */
2125 tdinfo->nskb_dma = 1;
2126 } else {
2127 int i = 0;
2128 tdinfo->nskb_dma = 0;
2129 tdinfo->skb_dma[i] = pci_map_single(vptr->pdev, skb->data,
2130 skb_headlen(skb), PCI_DMA_TODEVICE);
2132 td_ptr->tdesc0.len = len;
2134 /* FIXME: support 48bit DMA later */
2135 td_ptr->td_buf[i].pa_low = cpu_to_le32(tdinfo->skb_dma);
2136 td_ptr->td_buf[i].pa_high = 0;
2137 td_ptr->td_buf[i].size = cpu_to_le16(skb_headlen(skb));
2139 for (i = 0; i < nfrags; i++) {
2140 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2141 void *addr = (void *)page_address(frag->page) + frag->page_offset;
2143 tdinfo->skb_dma[i + 1] = pci_map_single(vptr->pdev, addr, frag->size, PCI_DMA_TODEVICE);
2145 td_ptr->td_buf[i + 1].pa_low = cpu_to_le32(tdinfo->skb_dma[i + 1]);
2146 td_ptr->td_buf[i + 1].pa_high = 0;
2147 td_ptr->td_buf[i + 1].size = cpu_to_le16(frag->size);
2149 tdinfo->nskb_dma = i - 1;
2152 } else
2153 #endif
2156 * Map the linear network buffer into PCI space and
2157 * add it to the transmit ring.
2159 tdinfo->skb = skb;
2160 tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
2161 td_ptr->tdesc0.len = len;
2162 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2163 td_ptr->td_buf[0].pa_high = 0;
2164 td_ptr->td_buf[0].size = len;
2165 tdinfo->nskb_dma = 1;
2167 td_ptr->tdesc1.cmd = TCPLS_NORMAL + (tdinfo->nskb_dma + 1) * 16;
2169 if (vptr->vlgrp && vlan_tx_tag_present(skb)) {
2170 td_ptr->tdesc1.vlan = cpu_to_le16(vlan_tx_tag_get(skb));
2171 td_ptr->tdesc1.TCR |= TCR0_VETAG;
2175 * Handle hardware checksum
2177 if ((vptr->flags & VELOCITY_FLAGS_TX_CSUM)
2178 && (skb->ip_summed == CHECKSUM_PARTIAL)) {
2179 const struct iphdr *ip = ip_hdr(skb);
2180 if (ip->protocol == IPPROTO_TCP)
2181 td_ptr->tdesc1.TCR |= TCR0_TCPCK;
2182 else if (ip->protocol == IPPROTO_UDP)
2183 td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
2184 td_ptr->tdesc1.TCR |= TCR0_IPCK;
2188 int prev = index - 1;
2190 if (prev < 0)
2191 prev = vptr->options.numtx - 1;
2192 td_ptr->tdesc0.len |= OWNED_BY_NIC;
2193 vptr->td_used[qnum]++;
2194 vptr->td_curr[qnum] = (index + 1) % vptr->options.numtx;
2196 if (AVAIL_TD(vptr, qnum) < 1)
2197 netif_stop_queue(dev);
2199 td_ptr = &(vptr->td_rings[qnum][prev]);
2200 td_ptr->td_buf[0].size |= TD_QUEUE;
2201 mac_tx_queue_wake(vptr->mac_regs, qnum);
2203 dev->trans_start = jiffies;
2204 spin_unlock_irqrestore(&vptr->lock, flags);
2205 return 0;
2209 * velocity_intr - interrupt callback
2210 * @irq: interrupt number
2211 * @dev_instance: interrupting device
2213 * Called whenever an interrupt is generated by the velocity
2214 * adapter IRQ line. We may not be the source of the interrupt
2215 * and need to identify initially if we are, and if not exit as
2216 * efficiently as possible.
2219 static int velocity_intr(int irq, void *dev_instance)
2221 struct net_device *dev = dev_instance;
2222 struct velocity_info *vptr = netdev_priv(dev);
2223 u32 isr_status;
2224 int max_count = 0;
2227 spin_lock(&vptr->lock);
2228 isr_status = mac_read_isr(vptr->mac_regs);
2230 /* Not us ? */
2231 if (isr_status == 0) {
2232 spin_unlock(&vptr->lock);
2233 return IRQ_NONE;
2236 mac_disable_int(vptr->mac_regs);
2239 * Keep processing the ISR until we have completed
2240 * processing and the isr_status becomes zero
2243 while (isr_status != 0) {
2244 mac_write_isr(vptr->mac_regs, isr_status);
2245 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2246 velocity_error(vptr, isr_status);
2247 if (isr_status & (ISR_PRXI | ISR_PPRXI))
2248 max_count += velocity_rx_srv(vptr, isr_status);
2249 if (isr_status & (ISR_PTXI | ISR_PPTXI))
2250 max_count += velocity_tx_srv(vptr, isr_status);
2251 isr_status = mac_read_isr(vptr->mac_regs);
2252 if (max_count > vptr->options.int_works)
2254 printk(KERN_WARNING "%s: excessive work at interrupt.\n",
2255 dev->name);
2256 max_count = 0;
2259 spin_unlock(&vptr->lock);
2260 mac_enable_int(vptr->mac_regs);
2261 return IRQ_HANDLED;
2267 * velocity_set_multi - filter list change callback
2268 * @dev: network device
2270 * Called by the network layer when the filter lists need to change
2271 * for a velocity adapter. Reload the CAMs with the new address
2272 * filter ruleset.
2275 static void velocity_set_multi(struct net_device *dev)
2277 struct velocity_info *vptr = netdev_priv(dev);
2278 struct mac_regs __iomem * regs = vptr->mac_regs;
2279 u8 rx_mode;
2280 int i;
2281 struct dev_mc_list *mclist;
2283 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2284 writel(0xffffffff, &regs->MARCAM[0]);
2285 writel(0xffffffff, &regs->MARCAM[4]);
2286 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
2287 } else if ((dev->mc_count > vptr->multicast_limit)
2288 || (dev->flags & IFF_ALLMULTI)) {
2289 writel(0xffffffff, &regs->MARCAM[0]);
2290 writel(0xffffffff, &regs->MARCAM[4]);
2291 rx_mode = (RCR_AM | RCR_AB);
2292 } else {
2293 int offset = MCAM_SIZE - vptr->multicast_limit;
2294 mac_get_cam_mask(regs, vptr->mCAMmask);
2296 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) {
2297 mac_set_cam(regs, i + offset, mclist->dmi_addr);
2298 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
2301 mac_set_cam_mask(regs, vptr->mCAMmask);
2302 rx_mode = (RCR_AM | RCR_AB);
2304 if (dev->mtu > 1500)
2305 rx_mode |= RCR_AL;
2307 BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
2312 * velocity_get_status - statistics callback
2313 * @dev: network device
2315 * Callback from the network layer to allow driver statistics
2316 * to be resynchronized with hardware collected state. In the
2317 * case of the velocity we need to pull the MIB counters from
2318 * the hardware into the counters before letting the network
2319 * layer display them.
2322 static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2324 struct velocity_info *vptr = netdev_priv(dev);
2326 /* If the hardware is down, don't touch MII */
2327 if(!netif_running(dev))
2328 return &vptr->stats;
2330 spin_lock_irq(&vptr->lock);
2331 velocity_update_hw_mibs(vptr);
2332 spin_unlock_irq(&vptr->lock);
2334 vptr->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2335 vptr->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2336 vptr->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2338 // unsigned long rx_dropped; /* no space in linux buffers */
2339 vptr->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2340 /* detailed rx_errors: */
2341 // unsigned long rx_length_errors;
2342 // unsigned long rx_over_errors; /* receiver ring buff overflow */
2343 vptr->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2344 // unsigned long rx_frame_errors; /* recv'd frame alignment error */
2345 // unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2346 // unsigned long rx_missed_errors; /* receiver missed packet */
2348 /* detailed tx_errors */
2349 // unsigned long tx_fifo_errors;
2351 return &vptr->stats;
2356 * velocity_ioctl - ioctl entry point
2357 * @dev: network device
2358 * @rq: interface request ioctl
2359 * @cmd: command code
2361 * Called when the user issues an ioctl request to the network
2362 * device in question. The velocity interface supports MII.
2365 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2367 struct velocity_info *vptr = netdev_priv(dev);
2368 int ret;
2370 /* If we are asked for information and the device is power
2371 saving then we need to bring the device back up to talk to it */
2373 if (!netif_running(dev))
2374 pci_set_power_state(vptr->pdev, PCI_D0);
2376 switch (cmd) {
2377 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2378 case SIOCGMIIREG: /* Read MII PHY register. */
2379 case SIOCSMIIREG: /* Write to MII PHY register. */
2380 ret = velocity_mii_ioctl(dev, rq, cmd);
2381 break;
2383 default:
2384 ret = -EOPNOTSUPP;
2386 if (!netif_running(dev))
2387 pci_set_power_state(vptr->pdev, PCI_D3hot);
2390 return ret;
2394 * Definition for our device driver. The PCI layer interface
2395 * uses this to handle all our card discover and plugging
2398 static struct pci_driver velocity_driver = {
2399 .name = VELOCITY_NAME,
2400 .id_table = velocity_id_table,
2401 .probe = velocity_found1,
2402 .remove = __devexit_p(velocity_remove1),
2403 #ifdef CONFIG_PM
2404 .suspend = velocity_suspend,
2405 .resume = velocity_resume,
2406 #endif
2410 * velocity_init_module - load time function
2412 * Called when the velocity module is loaded. The PCI driver
2413 * is registered with the PCI layer, and in turn will call
2414 * the probe functions for each velocity adapter installed
2415 * in the system.
2418 static int __init velocity_init_module(void)
2420 int ret;
2422 velocity_register_notifier();
2423 ret = pci_register_driver(&velocity_driver);
2424 if (ret < 0)
2425 velocity_unregister_notifier();
2426 return ret;
2430 * velocity_cleanup - module unload
2432 * When the velocity hardware is unloaded this function is called.
2433 * It will clean up the notifiers and the unregister the PCI
2434 * driver interface for this hardware. This in turn cleans up
2435 * all discovered interfaces before returning from the function
2438 static void __exit velocity_cleanup_module(void)
2440 velocity_unregister_notifier();
2441 pci_unregister_driver(&velocity_driver);
2444 module_init(velocity_init_module);
2445 module_exit(velocity_cleanup_module);
2449 * MII access , media link mode setting functions
2454 * mii_init - set up MII
2455 * @vptr: velocity adapter
2456 * @mii_status: links tatus
2458 * Set up the PHY for the current link state.
2461 static void mii_init(struct velocity_info *vptr, u32 mii_status)
2463 u16 BMCR;
2465 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
2466 case PHYID_CICADA_CS8201:
2468 * Reset to hardware default
2470 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2472 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2473 * off it in NWay-forced half mode for NWay-forced v.s.
2474 * legacy-forced issue.
2476 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2477 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2478 else
2479 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2481 * Turn on Link/Activity LED enable bit for CIS8201
2483 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
2484 break;
2485 case PHYID_VT3216_32BIT:
2486 case PHYID_VT3216_64BIT:
2488 * Reset to hardware default
2490 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2492 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2493 * off it in NWay-forced half mode for NWay-forced v.s.
2494 * legacy-forced issue
2496 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2497 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2498 else
2499 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2500 break;
2502 case PHYID_MARVELL_1000:
2503 case PHYID_MARVELL_1000S:
2505 * Assert CRS on Transmit
2507 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
2509 * Reset to hardware default
2511 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2512 break;
2513 default:
2516 velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
2517 if (BMCR & BMCR_ISO) {
2518 BMCR &= ~BMCR_ISO;
2519 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
2524 * safe_disable_mii_autopoll - autopoll off
2525 * @regs: velocity registers
2527 * Turn off the autopoll and wait for it to disable on the chip
2530 static void safe_disable_mii_autopoll(struct mac_regs __iomem * regs)
2532 u16 ww;
2534 /* turn off MAUTO */
2535 writeb(0, &regs->MIICR);
2536 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2537 udelay(1);
2538 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2539 break;
2544 * enable_mii_autopoll - turn on autopolling
2545 * @regs: velocity registers
2547 * Enable the MII link status autopoll feature on the Velocity
2548 * hardware. Wait for it to enable.
2551 static void enable_mii_autopoll(struct mac_regs __iomem * regs)
2553 int ii;
2555 writeb(0, &(regs->MIICR));
2556 writeb(MIIADR_SWMPL, &regs->MIIADR);
2558 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
2559 udelay(1);
2560 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2561 break;
2564 writeb(MIICR_MAUTO, &regs->MIICR);
2566 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
2567 udelay(1);
2568 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2569 break;
2575 * velocity_mii_read - read MII data
2576 * @regs: velocity registers
2577 * @index: MII register index
2578 * @data: buffer for received data
2580 * Perform a single read of an MII 16bit register. Returns zero
2581 * on success or -ETIMEDOUT if the PHY did not respond.
2584 static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
2586 u16 ww;
2589 * Disable MIICR_MAUTO, so that mii addr can be set normally
2591 safe_disable_mii_autopoll(regs);
2593 writeb(index, &regs->MIIADR);
2595 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
2597 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2598 if (!(readb(&regs->MIICR) & MIICR_RCMD))
2599 break;
2602 *data = readw(&regs->MIIDATA);
2604 enable_mii_autopoll(regs);
2605 if (ww == W_MAX_TIMEOUT)
2606 return -ETIMEDOUT;
2607 return 0;
2611 * velocity_mii_write - write MII data
2612 * @regs: velocity registers
2613 * @index: MII register index
2614 * @data: 16bit data for the MII register
2616 * Perform a single write to an MII 16bit register. Returns zero
2617 * on success or -ETIMEDOUT if the PHY did not respond.
2620 static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
2622 u16 ww;
2625 * Disable MIICR_MAUTO, so that mii addr can be set normally
2627 safe_disable_mii_autopoll(regs);
2629 /* MII reg offset */
2630 writeb(mii_addr, &regs->MIIADR);
2631 /* set MII data */
2632 writew(data, &regs->MIIDATA);
2634 /* turn on MIICR_WCMD */
2635 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
2637 /* W_MAX_TIMEOUT is the timeout period */
2638 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2639 udelay(5);
2640 if (!(readb(&regs->MIICR) & MIICR_WCMD))
2641 break;
2643 enable_mii_autopoll(regs);
2645 if (ww == W_MAX_TIMEOUT)
2646 return -ETIMEDOUT;
2647 return 0;
2651 * velocity_get_opt_media_mode - get media selection
2652 * @vptr: velocity adapter
2654 * Get the media mode stored in EEPROM or module options and load
2655 * mii_status accordingly. The requested link state information
2656 * is also returned.
2659 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
2661 u32 status = 0;
2663 switch (vptr->options.spd_dpx) {
2664 case SPD_DPX_AUTO:
2665 status = VELOCITY_AUTONEG_ENABLE;
2666 break;
2667 case SPD_DPX_100_FULL:
2668 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
2669 break;
2670 case SPD_DPX_10_FULL:
2671 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
2672 break;
2673 case SPD_DPX_100_HALF:
2674 status = VELOCITY_SPEED_100;
2675 break;
2676 case SPD_DPX_10_HALF:
2677 status = VELOCITY_SPEED_10;
2678 break;
2680 vptr->mii_status = status;
2681 return status;
2685 * mii_set_auto_on - autonegotiate on
2686 * @vptr: velocity
2688 * Enable autonegotation on this interface
2691 static void mii_set_auto_on(struct velocity_info *vptr)
2693 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs))
2694 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
2695 else
2696 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
2701 static void mii_set_auto_off(struct velocity_info * vptr)
2703 MII_REG_BITS_OFF(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
2708 * set_mii_flow_control - flow control setup
2709 * @vptr: velocity interface
2711 * Set up the flow control on this interface according to
2712 * the supplied user/eeprom options.
2715 static void set_mii_flow_control(struct velocity_info *vptr)
2717 /*Enable or Disable PAUSE in ANAR */
2718 switch (vptr->options.flow_cntl) {
2719 case FLOW_CNTL_TX:
2720 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2721 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2722 break;
2724 case FLOW_CNTL_RX:
2725 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2726 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2727 break;
2729 case FLOW_CNTL_TX_RX:
2730 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2731 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2732 break;
2734 case FLOW_CNTL_DISABLE:
2735 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2736 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2737 break;
2738 default:
2739 break;
2744 * velocity_set_media_mode - set media mode
2745 * @mii_status: old MII link state
2747 * Check the media link state and configure the flow control
2748 * PHY and also velocity hardware setup accordingly. In particular
2749 * we need to set up CD polling and frame bursting.
2752 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
2754 u32 curr_status;
2755 struct mac_regs __iomem * regs = vptr->mac_regs;
2757 vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
2758 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
2760 /* Set mii link status */
2761 set_mii_flow_control(vptr);
2764 Check if new status is consisent with current status
2765 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE)
2766 || (mii_status==curr_status)) {
2767 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
2768 vptr->mii_status=check_connection_type(vptr->mac_regs);
2769 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
2770 return 0;
2774 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201) {
2775 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
2779 * If connection type is AUTO
2781 if (mii_status & VELOCITY_AUTONEG_ENABLE) {
2782 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
2783 /* clear force MAC mode bit */
2784 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
2785 /* set duplex mode of MAC according to duplex mode of MII */
2786 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10, MII_REG_ANAR, vptr->mac_regs);
2787 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2788 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs);
2790 /* enable AUTO-NEGO mode */
2791 mii_set_auto_on(vptr);
2792 } else {
2793 u16 ANAR;
2794 u8 CHIPGCR;
2797 * 1. if it's 3119, disable frame bursting in halfduplex mode
2798 * and enable it in fullduplex mode
2799 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
2800 * 3. only enable CD heart beat counter in 10HD mode
2803 /* set force MAC mode bit */
2804 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2806 CHIPGCR = readb(&regs->CHIPGCR);
2807 CHIPGCR &= ~CHIPGCR_FCGMII;
2809 if (mii_status & VELOCITY_DUPLEX_FULL) {
2810 CHIPGCR |= CHIPGCR_FCFDX;
2811 writeb(CHIPGCR, &regs->CHIPGCR);
2812 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
2813 if (vptr->rev_id < REV_ID_VT3216_A0)
2814 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
2815 } else {
2816 CHIPGCR &= ~CHIPGCR_FCFDX;
2817 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
2818 writeb(CHIPGCR, &regs->CHIPGCR);
2819 if (vptr->rev_id < REV_ID_VT3216_A0)
2820 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
2823 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2825 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10)) {
2826 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
2827 } else {
2828 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
2830 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */
2831 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR);
2832 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10));
2833 if (mii_status & VELOCITY_SPEED_100) {
2834 if (mii_status & VELOCITY_DUPLEX_FULL)
2835 ANAR |= ANAR_TXFD;
2836 else
2837 ANAR |= ANAR_TX;
2838 } else {
2839 if (mii_status & VELOCITY_DUPLEX_FULL)
2840 ANAR |= ANAR_10FD;
2841 else
2842 ANAR |= ANAR_10;
2844 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
2845 /* enable AUTO-NEGO mode */
2846 mii_set_auto_on(vptr);
2847 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
2849 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
2850 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
2851 return VELOCITY_LINK_CHANGE;
2855 * mii_check_media_mode - check media state
2856 * @regs: velocity registers
2858 * Check the current MII status and determine the link status
2859 * accordingly
2862 static u32 mii_check_media_mode(struct mac_regs __iomem * regs)
2864 u32 status = 0;
2865 u16 ANAR;
2867 if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs))
2868 status |= VELOCITY_LINK_FAIL;
2870 if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs))
2871 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
2872 else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
2873 status |= (VELOCITY_SPEED_1000);
2874 else {
2875 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2876 if (ANAR & ANAR_TXFD)
2877 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
2878 else if (ANAR & ANAR_TX)
2879 status |= VELOCITY_SPEED_100;
2880 else if (ANAR & ANAR_10FD)
2881 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
2882 else
2883 status |= (VELOCITY_SPEED_10);
2886 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
2887 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2888 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
2889 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
2890 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
2891 status |= VELOCITY_AUTONEG_ENABLE;
2895 return status;
2898 static u32 check_connection_type(struct mac_regs __iomem * regs)
2900 u32 status = 0;
2901 u8 PHYSR0;
2902 u16 ANAR;
2903 PHYSR0 = readb(&regs->PHYSR0);
2906 if (!(PHYSR0 & PHYSR0_LINKGD))
2907 status|=VELOCITY_LINK_FAIL;
2910 if (PHYSR0 & PHYSR0_FDPX)
2911 status |= VELOCITY_DUPLEX_FULL;
2913 if (PHYSR0 & PHYSR0_SPDG)
2914 status |= VELOCITY_SPEED_1000;
2915 else if (PHYSR0 & PHYSR0_SPD10)
2916 status |= VELOCITY_SPEED_10;
2917 else
2918 status |= VELOCITY_SPEED_100;
2920 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
2921 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2922 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
2923 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
2924 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
2925 status |= VELOCITY_AUTONEG_ENABLE;
2929 return status;
2933 * enable_flow_control_ability - flow control
2934 * @vptr: veloity to configure
2936 * Set up flow control according to the flow control options
2937 * determined by the eeprom/configuration.
2940 static void enable_flow_control_ability(struct velocity_info *vptr)
2943 struct mac_regs __iomem * regs = vptr->mac_regs;
2945 switch (vptr->options.flow_cntl) {
2947 case FLOW_CNTL_DEFAULT:
2948 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
2949 writel(CR0_FDXRFCEN, &regs->CR0Set);
2950 else
2951 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2953 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
2954 writel(CR0_FDXTFCEN, &regs->CR0Set);
2955 else
2956 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2957 break;
2959 case FLOW_CNTL_TX:
2960 writel(CR0_FDXTFCEN, &regs->CR0Set);
2961 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2962 break;
2964 case FLOW_CNTL_RX:
2965 writel(CR0_FDXRFCEN, &regs->CR0Set);
2966 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2967 break;
2969 case FLOW_CNTL_TX_RX:
2970 writel(CR0_FDXTFCEN, &regs->CR0Set);
2971 writel(CR0_FDXRFCEN, &regs->CR0Set);
2972 break;
2974 case FLOW_CNTL_DISABLE:
2975 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2976 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2977 break;
2979 default:
2980 break;
2987 * velocity_ethtool_up - pre hook for ethtool
2988 * @dev: network device
2990 * Called before an ethtool operation. We need to make sure the
2991 * chip is out of D3 state before we poke at it.
2994 static int velocity_ethtool_up(struct net_device *dev)
2996 struct velocity_info *vptr = netdev_priv(dev);
2997 if (!netif_running(dev))
2998 pci_set_power_state(vptr->pdev, PCI_D0);
2999 return 0;
3003 * velocity_ethtool_down - post hook for ethtool
3004 * @dev: network device
3006 * Called after an ethtool operation. Restore the chip back to D3
3007 * state if it isn't running.
3010 static void velocity_ethtool_down(struct net_device *dev)
3012 struct velocity_info *vptr = netdev_priv(dev);
3013 if (!netif_running(dev))
3014 pci_set_power_state(vptr->pdev, PCI_D3hot);
3017 static int velocity_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3019 struct velocity_info *vptr = netdev_priv(dev);
3020 struct mac_regs __iomem * regs = vptr->mac_regs;
3021 u32 status;
3022 status = check_connection_type(vptr->mac_regs);
3024 cmd->supported = SUPPORTED_TP |
3025 SUPPORTED_Autoneg |
3026 SUPPORTED_10baseT_Half |
3027 SUPPORTED_10baseT_Full |
3028 SUPPORTED_100baseT_Half |
3029 SUPPORTED_100baseT_Full |
3030 SUPPORTED_1000baseT_Half |
3031 SUPPORTED_1000baseT_Full;
3032 if (status & VELOCITY_SPEED_1000)
3033 cmd->speed = SPEED_1000;
3034 else if (status & VELOCITY_SPEED_100)
3035 cmd->speed = SPEED_100;
3036 else
3037 cmd->speed = SPEED_10;
3038 cmd->autoneg = (status & VELOCITY_AUTONEG_ENABLE) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3039 cmd->port = PORT_TP;
3040 cmd->transceiver = XCVR_INTERNAL;
3041 cmd->phy_address = readb(&regs->MIIADR) & 0x1F;
3043 if (status & VELOCITY_DUPLEX_FULL)
3044 cmd->duplex = DUPLEX_FULL;
3045 else
3046 cmd->duplex = DUPLEX_HALF;
3048 return 0;
3051 static int velocity_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3053 struct velocity_info *vptr = netdev_priv(dev);
3054 u32 curr_status;
3055 u32 new_status = 0;
3056 int ret = 0;
3058 curr_status = check_connection_type(vptr->mac_regs);
3059 curr_status &= (~VELOCITY_LINK_FAIL);
3061 new_status |= ((cmd->autoneg) ? VELOCITY_AUTONEG_ENABLE : 0);
3062 new_status |= ((cmd->speed == SPEED_100) ? VELOCITY_SPEED_100 : 0);
3063 new_status |= ((cmd->speed == SPEED_10) ? VELOCITY_SPEED_10 : 0);
3064 new_status |= ((cmd->duplex == DUPLEX_FULL) ? VELOCITY_DUPLEX_FULL : 0);
3066 if ((new_status & VELOCITY_AUTONEG_ENABLE) && (new_status != (curr_status | VELOCITY_AUTONEG_ENABLE)))
3067 ret = -EINVAL;
3068 else
3069 velocity_set_media_mode(vptr, new_status);
3071 return ret;
3074 static u32 velocity_get_link(struct net_device *dev)
3076 struct velocity_info *vptr = netdev_priv(dev);
3077 struct mac_regs __iomem * regs = vptr->mac_regs;
3078 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
3081 static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3083 struct velocity_info *vptr = netdev_priv(dev);
3084 strcpy(info->driver, VELOCITY_NAME);
3085 strcpy(info->version, VELOCITY_VERSION);
3086 strcpy(info->bus_info, pci_name(vptr->pdev));
3089 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3091 struct velocity_info *vptr = netdev_priv(dev);
3092 wol->supported = WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP;
3093 wol->wolopts |= WAKE_MAGIC;
3095 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3096 wol.wolopts|=WAKE_PHY;
3098 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
3099 wol->wolopts |= WAKE_UCAST;
3100 if (vptr->wol_opts & VELOCITY_WOL_ARP)
3101 wol->wolopts |= WAKE_ARP;
3102 memcpy(&wol->sopass, vptr->wol_passwd, 6);
3105 static int velocity_ethtool_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3107 struct velocity_info *vptr = netdev_priv(dev);
3109 if (!(wol->wolopts & (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP)))
3110 return -EFAULT;
3111 vptr->wol_opts = VELOCITY_WOL_MAGIC;
3114 if (wol.wolopts & WAKE_PHY) {
3115 vptr->wol_opts|=VELOCITY_WOL_PHY;
3116 vptr->flags |=VELOCITY_FLAGS_WOL_ENABLED;
3120 if (wol->wolopts & WAKE_MAGIC) {
3121 vptr->wol_opts |= VELOCITY_WOL_MAGIC;
3122 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3124 if (wol->wolopts & WAKE_UCAST) {
3125 vptr->wol_opts |= VELOCITY_WOL_UCAST;
3126 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3128 if (wol->wolopts & WAKE_ARP) {
3129 vptr->wol_opts |= VELOCITY_WOL_ARP;
3130 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3132 memcpy(vptr->wol_passwd, wol->sopass, 6);
3133 return 0;
3136 static u32 velocity_get_msglevel(struct net_device *dev)
3138 return msglevel;
3141 static void velocity_set_msglevel(struct net_device *dev, u32 value)
3143 msglevel = value;
3146 static const struct ethtool_ops velocity_ethtool_ops = {
3147 .get_settings = velocity_get_settings,
3148 .set_settings = velocity_set_settings,
3149 .get_drvinfo = velocity_get_drvinfo,
3150 .get_wol = velocity_ethtool_get_wol,
3151 .set_wol = velocity_ethtool_set_wol,
3152 .get_msglevel = velocity_get_msglevel,
3153 .set_msglevel = velocity_set_msglevel,
3154 .get_link = velocity_get_link,
3155 .begin = velocity_ethtool_up,
3156 .complete = velocity_ethtool_down
3160 * velocity_mii_ioctl - MII ioctl handler
3161 * @dev: network device
3162 * @ifr: the ifreq block for the ioctl
3163 * @cmd: the command
3165 * Process MII requests made via ioctl from the network layer. These
3166 * are used by tools like kudzu to interrogate the link state of the
3167 * hardware
3170 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3172 struct velocity_info *vptr = netdev_priv(dev);
3173 struct mac_regs __iomem * regs = vptr->mac_regs;
3174 unsigned long flags;
3175 struct mii_ioctl_data *miidata = if_mii(ifr);
3176 int err;
3178 switch (cmd) {
3179 case SIOCGMIIPHY:
3180 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
3181 break;
3182 case SIOCGMIIREG:
3183 if (!capable(CAP_NET_ADMIN))
3184 return -EPERM;
3185 if(velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
3186 return -ETIMEDOUT;
3187 break;
3188 case SIOCSMIIREG:
3189 if (!capable(CAP_NET_ADMIN))
3190 return -EPERM;
3191 spin_lock_irqsave(&vptr->lock, flags);
3192 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
3193 spin_unlock_irqrestore(&vptr->lock, flags);
3194 check_connection_type(vptr->mac_regs);
3195 if(err)
3196 return err;
3197 break;
3198 default:
3199 return -EOPNOTSUPP;
3201 return 0;
3204 #ifdef CONFIG_PM
3207 * velocity_save_context - save registers
3208 * @vptr: velocity
3209 * @context: buffer for stored context
3211 * Retrieve the current configuration from the velocity hardware
3212 * and stash it in the context structure, for use by the context
3213 * restore functions. This allows us to save things we need across
3214 * power down states
3217 static void velocity_save_context(struct velocity_info *vptr, struct velocity_context * context)
3219 struct mac_regs __iomem * regs = vptr->mac_regs;
3220 u16 i;
3221 u8 __iomem *ptr = (u8 __iomem *)regs;
3223 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
3224 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3226 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
3227 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3229 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3230 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3235 * velocity_restore_context - restore registers
3236 * @vptr: velocity
3237 * @context: buffer for stored context
3239 * Reload the register configuration from the velocity context
3240 * created by velocity_save_context.
3243 static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
3245 struct mac_regs __iomem * regs = vptr->mac_regs;
3246 int i;
3247 u8 __iomem *ptr = (u8 __iomem *)regs;
3249 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4) {
3250 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3253 /* Just skip cr0 */
3254 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3255 /* Clear */
3256 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3257 /* Set */
3258 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3261 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4) {
3262 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3265 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4) {
3266 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3269 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++) {
3270 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3276 * wol_calc_crc - WOL CRC
3277 * @pattern: data pattern
3278 * @mask_pattern: mask
3280 * Compute the wake on lan crc hashes for the packet header
3281 * we are interested in.
3284 static u16 wol_calc_crc(int size, u8 * pattern, u8 *mask_pattern)
3286 u16 crc = 0xFFFF;
3287 u8 mask;
3288 int i, j;
3290 for (i = 0; i < size; i++) {
3291 mask = mask_pattern[i];
3293 /* Skip this loop if the mask equals to zero */
3294 if (mask == 0x00)
3295 continue;
3297 for (j = 0; j < 8; j++) {
3298 if ((mask & 0x01) == 0) {
3299 mask >>= 1;
3300 continue;
3302 mask >>= 1;
3303 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
3306 /* Finally, invert the result once to get the correct data */
3307 crc = ~crc;
3308 return bitrev32(crc) >> 16;
3312 * velocity_set_wol - set up for wake on lan
3313 * @vptr: velocity to set WOL status on
3315 * Set a card up for wake on lan either by unicast or by
3316 * ARP packet.
3318 * FIXME: check static buffer is safe here
3321 static int velocity_set_wol(struct velocity_info *vptr)
3323 struct mac_regs __iomem * regs = vptr->mac_regs;
3324 static u8 buf[256];
3325 int i;
3327 static u32 mask_pattern[2][4] = {
3328 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
3329 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
3332 writew(0xFFFF, &regs->WOLCRClr);
3333 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
3334 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
3337 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3338 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
3341 if (vptr->wol_opts & VELOCITY_WOL_UCAST) {
3342 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
3345 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
3346 struct arp_packet *arp = (struct arp_packet *) buf;
3347 u16 crc;
3348 memset(buf, 0, sizeof(struct arp_packet) + 7);
3350 for (i = 0; i < 4; i++)
3351 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
3353 arp->type = htons(ETH_P_ARP);
3354 arp->ar_op = htons(1);
3356 memcpy(arp->ar_tip, vptr->ip_addr, 4);
3358 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
3359 (u8 *) & mask_pattern[0][0]);
3361 writew(crc, &regs->PatternCRC[0]);
3362 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
3365 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
3366 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
3368 writew(0x0FFF, &regs->WOLSRClr);
3370 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
3371 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
3372 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
3374 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
3377 if (vptr->mii_status & VELOCITY_SPEED_1000)
3378 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
3380 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
3383 u8 GCR;
3384 GCR = readb(&regs->CHIPGCR);
3385 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
3386 writeb(GCR, &regs->CHIPGCR);
3389 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
3390 /* Turn on SWPTAG just before entering power mode */
3391 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
3392 /* Go to bed ..... */
3393 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
3395 return 0;
3398 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
3400 struct net_device *dev = pci_get_drvdata(pdev);
3401 struct velocity_info *vptr = netdev_priv(dev);
3402 unsigned long flags;
3404 if(!netif_running(vptr->dev))
3405 return 0;
3407 netif_device_detach(vptr->dev);
3409 spin_lock_irqsave(&vptr->lock, flags);
3410 pci_save_state(pdev);
3411 #ifdef ETHTOOL_GWOL
3412 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3413 velocity_get_ip(vptr);
3414 velocity_save_context(vptr, &vptr->context);
3415 velocity_shutdown(vptr);
3416 velocity_set_wol(vptr);
3417 pci_enable_wake(pdev, PCI_D3hot, 1);
3418 pci_set_power_state(pdev, PCI_D3hot);
3419 } else {
3420 velocity_save_context(vptr, &vptr->context);
3421 velocity_shutdown(vptr);
3422 pci_disable_device(pdev);
3423 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3425 #else
3426 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3427 #endif
3428 spin_unlock_irqrestore(&vptr->lock, flags);
3429 return 0;
3432 static int velocity_resume(struct pci_dev *pdev)
3434 struct net_device *dev = pci_get_drvdata(pdev);
3435 struct velocity_info *vptr = netdev_priv(dev);
3436 unsigned long flags;
3437 int i;
3439 if(!netif_running(vptr->dev))
3440 return 0;
3442 pci_set_power_state(pdev, PCI_D0);
3443 pci_enable_wake(pdev, 0, 0);
3444 pci_restore_state(pdev);
3446 mac_wol_reset(vptr->mac_regs);
3448 spin_lock_irqsave(&vptr->lock, flags);
3449 velocity_restore_context(vptr, &vptr->context);
3450 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3451 mac_disable_int(vptr->mac_regs);
3453 velocity_tx_srv(vptr, 0);
3455 for (i = 0; i < vptr->num_txq; i++) {
3456 if (vptr->td_used[i]) {
3457 mac_tx_queue_wake(vptr->mac_regs, i);
3461 mac_enable_int(vptr->mac_regs);
3462 spin_unlock_irqrestore(&vptr->lock, flags);
3463 netif_device_attach(vptr->dev);
3465 return 0;
3468 #ifdef CONFIG_INET
3470 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3472 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3473 struct net_device *dev = ifa->ifa_dev->dev;
3474 struct velocity_info *vptr;
3475 unsigned long flags;
3477 if (dev_net(dev) != &init_net)
3478 return NOTIFY_DONE;
3480 spin_lock_irqsave(&velocity_dev_list_lock, flags);
3481 list_for_each_entry(vptr, &velocity_dev_list, list) {
3482 if (vptr->dev == dev) {
3483 velocity_get_ip(vptr);
3484 break;
3487 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
3489 return NOTIFY_DONE;
3492 #endif
3493 #endif