Merge branch 'for-linus' of git://git.infradead.org/users/sameo/mfd-2.6
[linux-btrfs-devel.git] / drivers / net / via-velocity.c
blob7c5336c5c37f09c91d2bacfdb0fbe92fdfbddd31
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 * More testing
14 * The changes are (c) Copyright 2004, Red Hat Inc. <alan@lxorguk.ukuu.org.uk>
15 * Additional fixes and clean up: Francois Romieu
17 * This source has not been verified for use in safety critical systems.
19 * Please direct queries about the revamped driver to the linux-kernel
20 * list not VIA.
22 * Original code:
24 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
25 * All rights reserved.
27 * This software may be redistributed and/or modified under
28 * the terms of the GNU General Public License as published by the Free
29 * Software Foundation; either version 2 of the License, or
30 * any later version.
32 * This program is distributed in the hope that it will be useful, but
33 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
34 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
35 * for more details.
37 * Author: Chuang Liang-Shing, AJ Jiang
39 * Date: Jan 24, 2003
41 * MODULE_LICENSE("GPL");
46 #include <linux/module.h>
47 #include <linux/types.h>
48 #include <linux/bitops.h>
49 #include <linux/init.h>
50 #include <linux/mm.h>
51 #include <linux/errno.h>
52 #include <linux/ioport.h>
53 #include <linux/pci.h>
54 #include <linux/kernel.h>
55 #include <linux/netdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/skbuff.h>
58 #include <linux/delay.h>
59 #include <linux/timer.h>
60 #include <linux/slab.h>
61 #include <linux/interrupt.h>
62 #include <linux/string.h>
63 #include <linux/wait.h>
64 #include <linux/io.h>
65 #include <linux/if.h>
66 #include <linux/uaccess.h>
67 #include <linux/proc_fs.h>
68 #include <linux/inetdevice.h>
69 #include <linux/reboot.h>
70 #include <linux/ethtool.h>
71 #include <linux/mii.h>
72 #include <linux/in.h>
73 #include <linux/if_arp.h>
74 #include <linux/if_vlan.h>
75 #include <linux/ip.h>
76 #include <linux/tcp.h>
77 #include <linux/udp.h>
78 #include <linux/crc-ccitt.h>
79 #include <linux/crc32.h>
81 #include "via-velocity.h"
84 static int velocity_nics;
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.
95 static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
97 int i;
99 /* Select CAM mask */
100 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
102 writeb(0, &regs->CAMADDR);
104 /* read mask */
105 for (i = 0; i < 8; i++)
106 *mask++ = readb(&(regs->MARCAM[i]));
108 /* disable CAMEN */
109 writeb(0, &regs->CAMADDR);
111 /* Select mar */
112 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
117 * mac_set_cam_mask - Set a CAM mask
118 * @regs: register block for this velocity
119 * @mask: CAM mask to load
121 * Store a new mask into a CAM
123 static void mac_set_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
125 int i;
126 /* Select CAM mask */
127 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
129 writeb(CAMADDR_CAMEN, &regs->CAMADDR);
131 for (i = 0; i < 8; i++)
132 writeb(*mask++, &(regs->MARCAM[i]));
134 /* disable CAMEN */
135 writeb(0, &regs->CAMADDR);
137 /* Select mar */
138 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
141 static void mac_set_vlan_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
143 int i;
144 /* Select CAM mask */
145 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
147 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL, &regs->CAMADDR);
149 for (i = 0; i < 8; i++)
150 writeb(*mask++, &(regs->MARCAM[i]));
152 /* disable CAMEN */
153 writeb(0, &regs->CAMADDR);
155 /* Select mar */
156 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
160 * mac_set_cam - set CAM data
161 * @regs: register block of this velocity
162 * @idx: Cam index
163 * @addr: 2 or 6 bytes of CAM data
165 * Load an address or vlan tag into a CAM
167 static void mac_set_cam(struct mac_regs __iomem *regs, int idx, const u8 *addr)
169 int i;
171 /* Select CAM mask */
172 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
174 idx &= (64 - 1);
176 writeb(CAMADDR_CAMEN | idx, &regs->CAMADDR);
178 for (i = 0; i < 6; i++)
179 writeb(*addr++, &(regs->MARCAM[i]));
181 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
183 udelay(10);
185 writeb(0, &regs->CAMADDR);
187 /* Select mar */
188 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
191 static void mac_set_vlan_cam(struct mac_regs __iomem *regs, int idx,
192 const u8 *addr)
195 /* Select CAM mask */
196 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
198 idx &= (64 - 1);
200 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL | idx, &regs->CAMADDR);
201 writew(*((u16 *) addr), &regs->MARCAM[0]);
203 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
205 udelay(10);
207 writeb(0, &regs->CAMADDR);
209 /* Select mar */
210 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
215 * mac_wol_reset - reset WOL after exiting low power
216 * @regs: register block of this velocity
218 * Called after we drop out of wake on lan mode in order to
219 * reset the Wake on lan features. This function doesn't restore
220 * the rest of the logic from the result of sleep/wakeup
222 static void mac_wol_reset(struct mac_regs __iomem *regs)
225 /* Turn off SWPTAG right after leaving power mode */
226 BYTE_REG_BITS_OFF(STICKHW_SWPTAG, &regs->STICKHW);
227 /* clear sticky bits */
228 BYTE_REG_BITS_OFF((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
230 BYTE_REG_BITS_OFF(CHIPGCR_FCGMII, &regs->CHIPGCR);
231 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
232 /* disable force PME-enable */
233 writeb(WOLCFG_PMEOVR, &regs->WOLCFGClr);
234 /* disable power-event config bit */
235 writew(0xFFFF, &regs->WOLCRClr);
236 /* clear power status */
237 writew(0xFFFF, &regs->WOLSRClr);
240 static const struct ethtool_ops velocity_ethtool_ops;
243 Define module options
246 MODULE_AUTHOR("VIA Networking Technologies, Inc.");
247 MODULE_LICENSE("GPL");
248 MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
250 #define VELOCITY_PARAM(N, D) \
251 static int N[MAX_UNITS] = OPTION_DEFAULT;\
252 module_param_array(N, int, NULL, 0); \
253 MODULE_PARM_DESC(N, D);
255 #define RX_DESC_MIN 64
256 #define RX_DESC_MAX 255
257 #define RX_DESC_DEF 64
258 VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
260 #define TX_DESC_MIN 16
261 #define TX_DESC_MAX 256
262 #define TX_DESC_DEF 64
263 VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
265 #define RX_THRESH_MIN 0
266 #define RX_THRESH_MAX 3
267 #define RX_THRESH_DEF 0
268 /* rx_thresh[] is used for controlling the receive fifo threshold.
269 0: indicate the rxfifo threshold is 128 bytes.
270 1: indicate the rxfifo threshold is 512 bytes.
271 2: indicate the rxfifo threshold is 1024 bytes.
272 3: indicate the rxfifo threshold is store & forward.
274 VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
276 #define DMA_LENGTH_MIN 0
277 #define DMA_LENGTH_MAX 7
278 #define DMA_LENGTH_DEF 6
280 /* DMA_length[] is used for controlling the DMA length
281 0: 8 DWORDs
282 1: 16 DWORDs
283 2: 32 DWORDs
284 3: 64 DWORDs
285 4: 128 DWORDs
286 5: 256 DWORDs
287 6: SF(flush till emply)
288 7: SF(flush till emply)
290 VELOCITY_PARAM(DMA_length, "DMA length");
292 #define IP_ALIG_DEF 0
293 /* IP_byte_align[] is used for IP header DWORD byte aligned
294 0: indicate the IP header won't be DWORD byte aligned.(Default) .
295 1: indicate the IP header will be DWORD byte aligned.
296 In some environment, the IP header should be DWORD byte aligned,
297 or the packet will be droped when we receive it. (eg: IPVS)
299 VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
301 #define FLOW_CNTL_DEF 1
302 #define FLOW_CNTL_MIN 1
303 #define FLOW_CNTL_MAX 5
305 /* flow_control[] is used for setting the flow control ability of NIC.
306 1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
307 2: enable TX flow control.
308 3: enable RX flow control.
309 4: enable RX/TX flow control.
310 5: disable
312 VELOCITY_PARAM(flow_control, "Enable flow control ability");
314 #define MED_LNK_DEF 0
315 #define MED_LNK_MIN 0
316 #define MED_LNK_MAX 5
317 /* speed_duplex[] is used for setting the speed and duplex mode of NIC.
318 0: indicate autonegotiation for both speed and duplex mode
319 1: indicate 100Mbps half duplex mode
320 2: indicate 100Mbps full duplex mode
321 3: indicate 10Mbps half duplex mode
322 4: indicate 10Mbps full duplex mode
323 5: indicate 1000Mbps full duplex mode
325 Note:
326 if EEPROM have been set to the force mode, this option is ignored
327 by driver.
329 VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
331 #define VAL_PKT_LEN_DEF 0
332 /* ValPktLen[] is used for setting the checksum offload ability of NIC.
333 0: Receive frame with invalid layer 2 length (Default)
334 1: Drop frame with invalid layer 2 length
336 VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
338 #define WOL_OPT_DEF 0
339 #define WOL_OPT_MIN 0
340 #define WOL_OPT_MAX 7
341 /* wol_opts[] is used for controlling wake on lan behavior.
342 0: Wake up if recevied a magic packet. (Default)
343 1: Wake up if link status is on/off.
344 2: Wake up if recevied an arp packet.
345 4: Wake up if recevied any unicast packet.
346 Those value can be sumed up to support more than one option.
348 VELOCITY_PARAM(wol_opts, "Wake On Lan options");
350 static int rx_copybreak = 200;
351 module_param(rx_copybreak, int, 0644);
352 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
355 * Internal board variants. At the moment we have only one
357 static struct velocity_info_tbl chip_info_table[] = {
358 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
363 * Describe the PCI device identifiers that we support in this
364 * device driver. Used for hotplug autoloading.
366 static DEFINE_PCI_DEVICE_TABLE(velocity_id_table) = {
367 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
371 MODULE_DEVICE_TABLE(pci, velocity_id_table);
374 * get_chip_name - identifier to name
375 * @id: chip identifier
377 * Given a chip identifier return a suitable description. Returns
378 * a pointer a static string valid while the driver is loaded.
380 static const char __devinit *get_chip_name(enum chip_type chip_id)
382 int i;
383 for (i = 0; chip_info_table[i].name != NULL; i++)
384 if (chip_info_table[i].chip_id == chip_id)
385 break;
386 return chip_info_table[i].name;
390 * velocity_remove1 - device unplug
391 * @pdev: PCI device being removed
393 * Device unload callback. Called on an unplug or on module
394 * unload for each active device that is present. Disconnects
395 * the device from the network layer and frees all the resources
397 static void __devexit velocity_remove1(struct pci_dev *pdev)
399 struct net_device *dev = pci_get_drvdata(pdev);
400 struct velocity_info *vptr = netdev_priv(dev);
402 unregister_netdev(dev);
403 iounmap(vptr->mac_regs);
404 pci_release_regions(pdev);
405 pci_disable_device(pdev);
406 pci_set_drvdata(pdev, NULL);
407 free_netdev(dev);
409 velocity_nics--;
413 * velocity_set_int_opt - parser for integer options
414 * @opt: pointer to option value
415 * @val: value the user requested (or -1 for default)
416 * @min: lowest value allowed
417 * @max: highest value allowed
418 * @def: default value
419 * @name: property name
420 * @dev: device name
422 * Set an integer property in the module options. This function does
423 * all the verification and checking as well as reporting so that
424 * we don't duplicate code for each option.
426 static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname)
428 if (val == -1)
429 *opt = def;
430 else if (val < min || val > max) {
431 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
432 devname, name, min, max);
433 *opt = def;
434 } else {
435 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
436 devname, name, val);
437 *opt = val;
442 * velocity_set_bool_opt - parser for boolean options
443 * @opt: pointer to option value
444 * @val: value the user requested (or -1 for default)
445 * @def: default value (yes/no)
446 * @flag: numeric value to set for true.
447 * @name: property name
448 * @dev: device name
450 * Set a boolean property in the module options. This function does
451 * all the verification and checking as well as reporting so that
452 * we don't duplicate code for each option.
454 static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag, char *name, const char *devname)
456 (*opt) &= (~flag);
457 if (val == -1)
458 *opt |= (def ? flag : 0);
459 else if (val < 0 || val > 1) {
460 printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
461 devname, name);
462 *opt |= (def ? flag : 0);
463 } else {
464 printk(KERN_INFO "%s: set parameter %s to %s\n",
465 devname, name, val ? "TRUE" : "FALSE");
466 *opt |= (val ? flag : 0);
471 * velocity_get_options - set options on device
472 * @opts: option structure for the device
473 * @index: index of option to use in module options array
474 * @devname: device name
476 * Turn the module and command options into a single structure
477 * for the current device
479 static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname)
482 velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
483 velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
484 velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
485 velocity_set_int_opt(&opts->numtx, TxDescriptors[index], TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF, "TxDescriptors", devname);
487 velocity_set_int_opt(&opts->flow_cntl, flow_control[index], FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF, "flow_control", devname);
488 velocity_set_bool_opt(&opts->flags, IP_byte_align[index], IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN, "IP_byte_align", devname);
489 velocity_set_bool_opt(&opts->flags, ValPktLen[index], VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN, "ValPktLen", devname);
490 velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index], MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF, "Media link mode", devname);
491 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);
492 opts->numrx = (opts->numrx & ~3);
496 * velocity_init_cam_filter - initialise CAM
497 * @vptr: velocity to program
499 * Initialize the content addressable memory used for filters. Load
500 * appropriately according to the presence of VLAN
502 static void velocity_init_cam_filter(struct velocity_info *vptr)
504 struct mac_regs __iomem *regs = vptr->mac_regs;
505 unsigned int vid, i = 0;
507 /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
508 WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
509 WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
511 /* Disable all CAMs */
512 memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
513 memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
514 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
515 mac_set_cam_mask(regs, vptr->mCAMmask);
517 /* Enable VCAMs */
518 for_each_set_bit(vid, vptr->active_vlans, VLAN_N_VID) {
519 mac_set_vlan_cam(regs, i, (u8 *) &vid);
520 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
521 if (++i >= VCAM_SIZE)
522 break;
524 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
527 static void velocity_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
529 struct velocity_info *vptr = netdev_priv(dev);
531 spin_lock_irq(&vptr->lock);
532 set_bit(vid, vptr->active_vlans);
533 velocity_init_cam_filter(vptr);
534 spin_unlock_irq(&vptr->lock);
537 static void velocity_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
539 struct velocity_info *vptr = netdev_priv(dev);
541 spin_lock_irq(&vptr->lock);
542 clear_bit(vid, vptr->active_vlans);
543 velocity_init_cam_filter(vptr);
544 spin_unlock_irq(&vptr->lock);
547 static void velocity_init_rx_ring_indexes(struct velocity_info *vptr)
549 vptr->rx.dirty = vptr->rx.filled = vptr->rx.curr = 0;
553 * velocity_rx_reset - handle a receive reset
554 * @vptr: velocity we are resetting
556 * Reset the ownership and status for the receive ring side.
557 * Hand all the receive queue to the NIC.
559 static void velocity_rx_reset(struct velocity_info *vptr)
562 struct mac_regs __iomem *regs = vptr->mac_regs;
563 int i;
565 velocity_init_rx_ring_indexes(vptr);
568 * Init state, all RD entries belong to the NIC
570 for (i = 0; i < vptr->options.numrx; ++i)
571 vptr->rx.ring[i].rdesc0.len |= OWNED_BY_NIC;
573 writew(vptr->options.numrx, &regs->RBRDU);
574 writel(vptr->rx.pool_dma, &regs->RDBaseLo);
575 writew(0, &regs->RDIdx);
576 writew(vptr->options.numrx - 1, &regs->RDCSize);
580 * velocity_get_opt_media_mode - get media selection
581 * @vptr: velocity adapter
583 * Get the media mode stored in EEPROM or module options and load
584 * mii_status accordingly. The requested link state information
585 * is also returned.
587 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
589 u32 status = 0;
591 switch (vptr->options.spd_dpx) {
592 case SPD_DPX_AUTO:
593 status = VELOCITY_AUTONEG_ENABLE;
594 break;
595 case SPD_DPX_100_FULL:
596 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
597 break;
598 case SPD_DPX_10_FULL:
599 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
600 break;
601 case SPD_DPX_100_HALF:
602 status = VELOCITY_SPEED_100;
603 break;
604 case SPD_DPX_10_HALF:
605 status = VELOCITY_SPEED_10;
606 break;
607 case SPD_DPX_1000_FULL:
608 status = VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
609 break;
611 vptr->mii_status = status;
612 return status;
616 * safe_disable_mii_autopoll - autopoll off
617 * @regs: velocity registers
619 * Turn off the autopoll and wait for it to disable on the chip
621 static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs)
623 u16 ww;
625 /* turn off MAUTO */
626 writeb(0, &regs->MIICR);
627 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
628 udelay(1);
629 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
630 break;
635 * enable_mii_autopoll - turn on autopolling
636 * @regs: velocity registers
638 * Enable the MII link status autopoll feature on the Velocity
639 * hardware. Wait for it to enable.
641 static void enable_mii_autopoll(struct mac_regs __iomem *regs)
643 int ii;
645 writeb(0, &(regs->MIICR));
646 writeb(MIIADR_SWMPL, &regs->MIIADR);
648 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
649 udelay(1);
650 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
651 break;
654 writeb(MIICR_MAUTO, &regs->MIICR);
656 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
657 udelay(1);
658 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
659 break;
665 * velocity_mii_read - read MII data
666 * @regs: velocity registers
667 * @index: MII register index
668 * @data: buffer for received data
670 * Perform a single read of an MII 16bit register. Returns zero
671 * on success or -ETIMEDOUT if the PHY did not respond.
673 static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
675 u16 ww;
678 * Disable MIICR_MAUTO, so that mii addr can be set normally
680 safe_disable_mii_autopoll(regs);
682 writeb(index, &regs->MIIADR);
684 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
686 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
687 if (!(readb(&regs->MIICR) & MIICR_RCMD))
688 break;
691 *data = readw(&regs->MIIDATA);
693 enable_mii_autopoll(regs);
694 if (ww == W_MAX_TIMEOUT)
695 return -ETIMEDOUT;
696 return 0;
701 * mii_check_media_mode - check media state
702 * @regs: velocity registers
704 * Check the current MII status and determine the link status
705 * accordingly
707 static u32 mii_check_media_mode(struct mac_regs __iomem *regs)
709 u32 status = 0;
710 u16 ANAR;
712 if (!MII_REG_BITS_IS_ON(BMSR_LSTATUS, MII_BMSR, regs))
713 status |= VELOCITY_LINK_FAIL;
715 if (MII_REG_BITS_IS_ON(ADVERTISE_1000FULL, MII_CTRL1000, regs))
716 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
717 else if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF, MII_CTRL1000, regs))
718 status |= (VELOCITY_SPEED_1000);
719 else {
720 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
721 if (ANAR & ADVERTISE_100FULL)
722 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
723 else if (ANAR & ADVERTISE_100HALF)
724 status |= VELOCITY_SPEED_100;
725 else if (ANAR & ADVERTISE_10FULL)
726 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
727 else
728 status |= (VELOCITY_SPEED_10);
731 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, regs)) {
732 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
733 if ((ANAR & (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF))
734 == (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF)) {
735 if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF | ADVERTISE_1000FULL, MII_CTRL1000, regs))
736 status |= VELOCITY_AUTONEG_ENABLE;
740 return status;
744 * velocity_mii_write - write MII data
745 * @regs: velocity registers
746 * @index: MII register index
747 * @data: 16bit data for the MII register
749 * Perform a single write to an MII 16bit register. Returns zero
750 * on success or -ETIMEDOUT if the PHY did not respond.
752 static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
754 u16 ww;
757 * Disable MIICR_MAUTO, so that mii addr can be set normally
759 safe_disable_mii_autopoll(regs);
761 /* MII reg offset */
762 writeb(mii_addr, &regs->MIIADR);
763 /* set MII data */
764 writew(data, &regs->MIIDATA);
766 /* turn on MIICR_WCMD */
767 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
769 /* W_MAX_TIMEOUT is the timeout period */
770 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
771 udelay(5);
772 if (!(readb(&regs->MIICR) & MIICR_WCMD))
773 break;
775 enable_mii_autopoll(regs);
777 if (ww == W_MAX_TIMEOUT)
778 return -ETIMEDOUT;
779 return 0;
783 * set_mii_flow_control - flow control setup
784 * @vptr: velocity interface
786 * Set up the flow control on this interface according to
787 * the supplied user/eeprom options.
789 static void set_mii_flow_control(struct velocity_info *vptr)
791 /*Enable or Disable PAUSE in ANAR */
792 switch (vptr->options.flow_cntl) {
793 case FLOW_CNTL_TX:
794 MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
795 MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
796 break;
798 case FLOW_CNTL_RX:
799 MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
800 MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
801 break;
803 case FLOW_CNTL_TX_RX:
804 MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
805 MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
806 break;
808 case FLOW_CNTL_DISABLE:
809 MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
810 MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
811 break;
812 default:
813 break;
818 * mii_set_auto_on - autonegotiate on
819 * @vptr: velocity
821 * Enable autonegotation on this interface
823 static void mii_set_auto_on(struct velocity_info *vptr)
825 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs))
826 MII_REG_BITS_ON(BMCR_ANRESTART, MII_BMCR, vptr->mac_regs);
827 else
828 MII_REG_BITS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs);
831 static u32 check_connection_type(struct mac_regs __iomem *regs)
833 u32 status = 0;
834 u8 PHYSR0;
835 u16 ANAR;
836 PHYSR0 = readb(&regs->PHYSR0);
839 if (!(PHYSR0 & PHYSR0_LINKGD))
840 status|=VELOCITY_LINK_FAIL;
843 if (PHYSR0 & PHYSR0_FDPX)
844 status |= VELOCITY_DUPLEX_FULL;
846 if (PHYSR0 & PHYSR0_SPDG)
847 status |= VELOCITY_SPEED_1000;
848 else if (PHYSR0 & PHYSR0_SPD10)
849 status |= VELOCITY_SPEED_10;
850 else
851 status |= VELOCITY_SPEED_100;
853 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, regs)) {
854 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
855 if ((ANAR & (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF))
856 == (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF)) {
857 if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF | ADVERTISE_1000FULL, MII_CTRL1000, regs))
858 status |= VELOCITY_AUTONEG_ENABLE;
862 return status;
868 * velocity_set_media_mode - set media mode
869 * @mii_status: old MII link state
871 * Check the media link state and configure the flow control
872 * PHY and also velocity hardware setup accordingly. In particular
873 * we need to set up CD polling and frame bursting.
875 static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
877 u32 curr_status;
878 struct mac_regs __iomem *regs = vptr->mac_regs;
880 vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
881 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
883 /* Set mii link status */
884 set_mii_flow_control(vptr);
887 Check if new status is consistent with current status
888 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE) ||
889 (mii_status==curr_status)) {
890 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
891 vptr->mii_status=check_connection_type(vptr->mac_regs);
892 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
893 return 0;
897 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
898 MII_REG_BITS_ON(AUXCR_MDPPS, MII_NCONFIG, vptr->mac_regs);
901 * If connection type is AUTO
903 if (mii_status & VELOCITY_AUTONEG_ENABLE) {
904 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
905 /* clear force MAC mode bit */
906 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
907 /* set duplex mode of MAC according to duplex mode of MII */
908 MII_REG_BITS_ON(ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF, MII_ADVERTISE, vptr->mac_regs);
909 MII_REG_BITS_ON(ADVERTISE_1000FULL | ADVERTISE_1000HALF, MII_CTRL1000, vptr->mac_regs);
910 MII_REG_BITS_ON(BMCR_SPEED1000, MII_BMCR, vptr->mac_regs);
912 /* enable AUTO-NEGO mode */
913 mii_set_auto_on(vptr);
914 } else {
915 u16 CTRL1000;
916 u16 ANAR;
917 u8 CHIPGCR;
920 * 1. if it's 3119, disable frame bursting in halfduplex mode
921 * and enable it in fullduplex mode
922 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
923 * 3. only enable CD heart beat counter in 10HD mode
926 /* set force MAC mode bit */
927 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
929 CHIPGCR = readb(&regs->CHIPGCR);
931 if (mii_status & VELOCITY_SPEED_1000)
932 CHIPGCR |= CHIPGCR_FCGMII;
933 else
934 CHIPGCR &= ~CHIPGCR_FCGMII;
936 if (mii_status & VELOCITY_DUPLEX_FULL) {
937 CHIPGCR |= CHIPGCR_FCFDX;
938 writeb(CHIPGCR, &regs->CHIPGCR);
939 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
940 if (vptr->rev_id < REV_ID_VT3216_A0)
941 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
942 } else {
943 CHIPGCR &= ~CHIPGCR_FCFDX;
944 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
945 writeb(CHIPGCR, &regs->CHIPGCR);
946 if (vptr->rev_id < REV_ID_VT3216_A0)
947 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
950 velocity_mii_read(vptr->mac_regs, MII_CTRL1000, &CTRL1000);
951 CTRL1000 &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
952 if ((mii_status & VELOCITY_SPEED_1000) &&
953 (mii_status & VELOCITY_DUPLEX_FULL)) {
954 CTRL1000 |= ADVERTISE_1000FULL;
956 velocity_mii_write(vptr->mac_regs, MII_CTRL1000, CTRL1000);
958 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10))
959 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
960 else
961 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
963 /* MII_REG_BITS_OFF(BMCR_SPEED1000, MII_BMCR, vptr->mac_regs); */
964 velocity_mii_read(vptr->mac_regs, MII_ADVERTISE, &ANAR);
965 ANAR &= (~(ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF));
966 if (mii_status & VELOCITY_SPEED_100) {
967 if (mii_status & VELOCITY_DUPLEX_FULL)
968 ANAR |= ADVERTISE_100FULL;
969 else
970 ANAR |= ADVERTISE_100HALF;
971 } else if (mii_status & VELOCITY_SPEED_10) {
972 if (mii_status & VELOCITY_DUPLEX_FULL)
973 ANAR |= ADVERTISE_10FULL;
974 else
975 ANAR |= ADVERTISE_10HALF;
977 velocity_mii_write(vptr->mac_regs, MII_ADVERTISE, ANAR);
978 /* enable AUTO-NEGO mode */
979 mii_set_auto_on(vptr);
980 /* MII_REG_BITS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs); */
982 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
983 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
984 return VELOCITY_LINK_CHANGE;
988 * velocity_print_link_status - link status reporting
989 * @vptr: velocity to report on
991 * Turn the link status of the velocity card into a kernel log
992 * description of the new link state, detailing speed and duplex
993 * status
995 static void velocity_print_link_status(struct velocity_info *vptr)
998 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
999 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1000 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1001 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1003 if (vptr->mii_status & VELOCITY_SPEED_1000)
1004 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1005 else if (vptr->mii_status & VELOCITY_SPEED_100)
1006 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1007 else
1008 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1010 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1011 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1012 else
1013 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1014 } else {
1015 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1016 switch (vptr->options.spd_dpx) {
1017 case SPD_DPX_1000_FULL:
1018 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps full duplex\n");
1019 break;
1020 case SPD_DPX_100_HALF:
1021 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1022 break;
1023 case SPD_DPX_100_FULL:
1024 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1025 break;
1026 case SPD_DPX_10_HALF:
1027 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1028 break;
1029 case SPD_DPX_10_FULL:
1030 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1031 break;
1032 default:
1033 break;
1039 * enable_flow_control_ability - flow control
1040 * @vptr: veloity to configure
1042 * Set up flow control according to the flow control options
1043 * determined by the eeprom/configuration.
1045 static void enable_flow_control_ability(struct velocity_info *vptr)
1048 struct mac_regs __iomem *regs = vptr->mac_regs;
1050 switch (vptr->options.flow_cntl) {
1052 case FLOW_CNTL_DEFAULT:
1053 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
1054 writel(CR0_FDXRFCEN, &regs->CR0Set);
1055 else
1056 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1058 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
1059 writel(CR0_FDXTFCEN, &regs->CR0Set);
1060 else
1061 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1062 break;
1064 case FLOW_CNTL_TX:
1065 writel(CR0_FDXTFCEN, &regs->CR0Set);
1066 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1067 break;
1069 case FLOW_CNTL_RX:
1070 writel(CR0_FDXRFCEN, &regs->CR0Set);
1071 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1072 break;
1074 case FLOW_CNTL_TX_RX:
1075 writel(CR0_FDXTFCEN, &regs->CR0Set);
1076 writel(CR0_FDXRFCEN, &regs->CR0Set);
1077 break;
1079 case FLOW_CNTL_DISABLE:
1080 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1081 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1082 break;
1084 default:
1085 break;
1091 * velocity_soft_reset - soft reset
1092 * @vptr: velocity to reset
1094 * Kick off a soft reset of the velocity adapter and then poll
1095 * until the reset sequence has completed before returning.
1097 static int velocity_soft_reset(struct velocity_info *vptr)
1099 struct mac_regs __iomem *regs = vptr->mac_regs;
1100 int i = 0;
1102 writel(CR0_SFRST, &regs->CR0Set);
1104 for (i = 0; i < W_MAX_TIMEOUT; i++) {
1105 udelay(5);
1106 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
1107 break;
1110 if (i == W_MAX_TIMEOUT) {
1111 writel(CR0_FORSRST, &regs->CR0Set);
1112 /* FIXME: PCI POSTING */
1113 /* delay 2ms */
1114 mdelay(2);
1116 return 0;
1120 * velocity_set_multi - filter list change callback
1121 * @dev: network device
1123 * Called by the network layer when the filter lists need to change
1124 * for a velocity adapter. Reload the CAMs with the new address
1125 * filter ruleset.
1127 static void velocity_set_multi(struct net_device *dev)
1129 struct velocity_info *vptr = netdev_priv(dev);
1130 struct mac_regs __iomem *regs = vptr->mac_regs;
1131 u8 rx_mode;
1132 int i;
1133 struct netdev_hw_addr *ha;
1135 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1136 writel(0xffffffff, &regs->MARCAM[0]);
1137 writel(0xffffffff, &regs->MARCAM[4]);
1138 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
1139 } else if ((netdev_mc_count(dev) > vptr->multicast_limit) ||
1140 (dev->flags & IFF_ALLMULTI)) {
1141 writel(0xffffffff, &regs->MARCAM[0]);
1142 writel(0xffffffff, &regs->MARCAM[4]);
1143 rx_mode = (RCR_AM | RCR_AB);
1144 } else {
1145 int offset = MCAM_SIZE - vptr->multicast_limit;
1146 mac_get_cam_mask(regs, vptr->mCAMmask);
1148 i = 0;
1149 netdev_for_each_mc_addr(ha, dev) {
1150 mac_set_cam(regs, i + offset, ha->addr);
1151 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
1152 i++;
1155 mac_set_cam_mask(regs, vptr->mCAMmask);
1156 rx_mode = RCR_AM | RCR_AB | RCR_AP;
1158 if (dev->mtu > 1500)
1159 rx_mode |= RCR_AL;
1161 BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
1166 * MII access , media link mode setting functions
1170 * mii_init - set up MII
1171 * @vptr: velocity adapter
1172 * @mii_status: links tatus
1174 * Set up the PHY for the current link state.
1176 static void mii_init(struct velocity_info *vptr, u32 mii_status)
1178 u16 BMCR;
1180 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
1181 case PHYID_CICADA_CS8201:
1183 * Reset to hardware default
1185 MII_REG_BITS_OFF((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
1187 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1188 * off it in NWay-forced half mode for NWay-forced v.s.
1189 * legacy-forced issue.
1191 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1192 MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
1193 else
1194 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
1196 * Turn on Link/Activity LED enable bit for CIS8201
1198 MII_REG_BITS_ON(PLED_LALBE, MII_TPISTATUS, vptr->mac_regs);
1199 break;
1200 case PHYID_VT3216_32BIT:
1201 case PHYID_VT3216_64BIT:
1203 * Reset to hardware default
1205 MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
1207 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1208 * off it in NWay-forced half mode for NWay-forced v.s.
1209 * legacy-forced issue
1211 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1212 MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
1213 else
1214 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
1215 break;
1217 case PHYID_MARVELL_1000:
1218 case PHYID_MARVELL_1000S:
1220 * Assert CRS on Transmit
1222 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
1224 * Reset to hardware default
1226 MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
1227 break;
1228 default:
1231 velocity_mii_read(vptr->mac_regs, MII_BMCR, &BMCR);
1232 if (BMCR & BMCR_ISOLATE) {
1233 BMCR &= ~BMCR_ISOLATE;
1234 velocity_mii_write(vptr->mac_regs, MII_BMCR, BMCR);
1239 * setup_queue_timers - Setup interrupt timers
1241 * Setup interrupt frequency during suppression (timeout if the frame
1242 * count isn't filled).
1244 static void setup_queue_timers(struct velocity_info *vptr)
1246 /* Only for newer revisions */
1247 if (vptr->rev_id >= REV_ID_VT3216_A0) {
1248 u8 txqueue_timer = 0;
1249 u8 rxqueue_timer = 0;
1251 if (vptr->mii_status & (VELOCITY_SPEED_1000 |
1252 VELOCITY_SPEED_100)) {
1253 txqueue_timer = vptr->options.txqueue_timer;
1254 rxqueue_timer = vptr->options.rxqueue_timer;
1257 writeb(txqueue_timer, &vptr->mac_regs->TQETMR);
1258 writeb(rxqueue_timer, &vptr->mac_regs->RQETMR);
1262 * setup_adaptive_interrupts - Setup interrupt suppression
1264 * @vptr velocity adapter
1266 * The velocity is able to suppress interrupt during high interrupt load.
1267 * This function turns on that feature.
1269 static void setup_adaptive_interrupts(struct velocity_info *vptr)
1271 struct mac_regs __iomem *regs = vptr->mac_regs;
1272 u16 tx_intsup = vptr->options.tx_intsup;
1273 u16 rx_intsup = vptr->options.rx_intsup;
1275 /* Setup default interrupt mask (will be changed below) */
1276 vptr->int_mask = INT_MASK_DEF;
1278 /* Set Tx Interrupt Suppression Threshold */
1279 writeb(CAMCR_PS0, &regs->CAMCR);
1280 if (tx_intsup != 0) {
1281 vptr->int_mask &= ~(ISR_PTXI | ISR_PTX0I | ISR_PTX1I |
1282 ISR_PTX2I | ISR_PTX3I);
1283 writew(tx_intsup, &regs->ISRCTL);
1284 } else
1285 writew(ISRCTL_TSUPDIS, &regs->ISRCTL);
1287 /* Set Rx Interrupt Suppression Threshold */
1288 writeb(CAMCR_PS1, &regs->CAMCR);
1289 if (rx_intsup != 0) {
1290 vptr->int_mask &= ~ISR_PRXI;
1291 writew(rx_intsup, &regs->ISRCTL);
1292 } else
1293 writew(ISRCTL_RSUPDIS, &regs->ISRCTL);
1295 /* Select page to interrupt hold timer */
1296 writeb(0, &regs->CAMCR);
1300 * velocity_init_registers - initialise MAC registers
1301 * @vptr: velocity to init
1302 * @type: type of initialisation (hot or cold)
1304 * Initialise the MAC on a reset or on first set up on the
1305 * hardware.
1307 static void velocity_init_registers(struct velocity_info *vptr,
1308 enum velocity_init_type type)
1310 struct mac_regs __iomem *regs = vptr->mac_regs;
1311 int i, mii_status;
1313 mac_wol_reset(regs);
1315 switch (type) {
1316 case VELOCITY_INIT_RESET:
1317 case VELOCITY_INIT_WOL:
1319 netif_stop_queue(vptr->dev);
1322 * Reset RX to prevent RX pointer not on the 4X location
1324 velocity_rx_reset(vptr);
1325 mac_rx_queue_run(regs);
1326 mac_rx_queue_wake(regs);
1328 mii_status = velocity_get_opt_media_mode(vptr);
1329 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1330 velocity_print_link_status(vptr);
1331 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1332 netif_wake_queue(vptr->dev);
1335 enable_flow_control_ability(vptr);
1337 mac_clear_isr(regs);
1338 writel(CR0_STOP, &regs->CR0Clr);
1339 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
1340 &regs->CR0Set);
1342 break;
1344 case VELOCITY_INIT_COLD:
1345 default:
1347 * Do reset
1349 velocity_soft_reset(vptr);
1350 mdelay(5);
1352 mac_eeprom_reload(regs);
1353 for (i = 0; i < 6; i++)
1354 writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
1357 * clear Pre_ACPI bit.
1359 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
1360 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
1361 mac_set_dma_length(regs, vptr->options.DMA_length);
1363 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
1365 * Back off algorithm use original IEEE standard
1367 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
1370 * Init CAM filter
1372 velocity_init_cam_filter(vptr);
1375 * Set packet filter: Receive directed and broadcast address
1377 velocity_set_multi(vptr->dev);
1380 * Enable MII auto-polling
1382 enable_mii_autopoll(regs);
1384 setup_adaptive_interrupts(vptr);
1386 writel(vptr->rx.pool_dma, &regs->RDBaseLo);
1387 writew(vptr->options.numrx - 1, &regs->RDCSize);
1388 mac_rx_queue_run(regs);
1389 mac_rx_queue_wake(regs);
1391 writew(vptr->options.numtx - 1, &regs->TDCSize);
1393 for (i = 0; i < vptr->tx.numq; i++) {
1394 writel(vptr->tx.pool_dma[i], &regs->TDBaseLo[i]);
1395 mac_tx_queue_run(regs, i);
1398 init_flow_control_register(vptr);
1400 writel(CR0_STOP, &regs->CR0Clr);
1401 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
1403 mii_status = velocity_get_opt_media_mode(vptr);
1404 netif_stop_queue(vptr->dev);
1406 mii_init(vptr, mii_status);
1408 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1409 velocity_print_link_status(vptr);
1410 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1411 netif_wake_queue(vptr->dev);
1414 enable_flow_control_ability(vptr);
1415 mac_hw_mibs_init(regs);
1416 mac_write_int_mask(vptr->int_mask, regs);
1417 mac_clear_isr(regs);
1422 static void velocity_give_many_rx_descs(struct velocity_info *vptr)
1424 struct mac_regs __iomem *regs = vptr->mac_regs;
1425 int avail, dirty, unusable;
1428 * RD number must be equal to 4X per hardware spec
1429 * (programming guide rev 1.20, p.13)
1431 if (vptr->rx.filled < 4)
1432 return;
1434 wmb();
1436 unusable = vptr->rx.filled & 0x0003;
1437 dirty = vptr->rx.dirty - unusable;
1438 for (avail = vptr->rx.filled & 0xfffc; avail; avail--) {
1439 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1440 vptr->rx.ring[dirty].rdesc0.len |= OWNED_BY_NIC;
1443 writew(vptr->rx.filled & 0xfffc, &regs->RBRDU);
1444 vptr->rx.filled = unusable;
1448 * velocity_init_dma_rings - set up DMA rings
1449 * @vptr: Velocity to set up
1451 * Allocate PCI mapped DMA rings for the receive and transmit layer
1452 * to use.
1454 static int velocity_init_dma_rings(struct velocity_info *vptr)
1456 struct velocity_opt *opt = &vptr->options;
1457 const unsigned int rx_ring_size = opt->numrx * sizeof(struct rx_desc);
1458 const unsigned int tx_ring_size = opt->numtx * sizeof(struct tx_desc);
1459 struct pci_dev *pdev = vptr->pdev;
1460 dma_addr_t pool_dma;
1461 void *pool;
1462 unsigned int i;
1465 * Allocate all RD/TD rings a single pool.
1467 * pci_alloc_consistent() fulfills the requirement for 64 bytes
1468 * alignment
1470 pool = pci_alloc_consistent(pdev, tx_ring_size * vptr->tx.numq +
1471 rx_ring_size, &pool_dma);
1472 if (!pool) {
1473 dev_err(&pdev->dev, "%s : DMA memory allocation failed.\n",
1474 vptr->dev->name);
1475 return -ENOMEM;
1478 vptr->rx.ring = pool;
1479 vptr->rx.pool_dma = pool_dma;
1481 pool += rx_ring_size;
1482 pool_dma += rx_ring_size;
1484 for (i = 0; i < vptr->tx.numq; i++) {
1485 vptr->tx.rings[i] = pool;
1486 vptr->tx.pool_dma[i] = pool_dma;
1487 pool += tx_ring_size;
1488 pool_dma += tx_ring_size;
1491 return 0;
1494 static void velocity_set_rxbufsize(struct velocity_info *vptr, int mtu)
1496 vptr->rx.buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1500 * velocity_alloc_rx_buf - allocate aligned receive buffer
1501 * @vptr: velocity
1502 * @idx: ring index
1504 * Allocate a new full sized buffer for the reception of a frame and
1505 * map it into PCI space for the hardware to use. The hardware
1506 * requires *64* byte alignment of the buffer which makes life
1507 * less fun than would be ideal.
1509 static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1511 struct rx_desc *rd = &(vptr->rx.ring[idx]);
1512 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
1514 rd_info->skb = dev_alloc_skb(vptr->rx.buf_sz + 64);
1515 if (rd_info->skb == NULL)
1516 return -ENOMEM;
1519 * Do the gymnastics to get the buffer head for data at
1520 * 64byte alignment.
1522 skb_reserve(rd_info->skb,
1523 64 - ((unsigned long) rd_info->skb->data & 63));
1524 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
1525 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
1528 * Fill in the descriptor to match
1531 *((u32 *) & (rd->rdesc0)) = 0;
1532 rd->size = cpu_to_le16(vptr->rx.buf_sz) | RX_INTEN;
1533 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1534 rd->pa_high = 0;
1535 return 0;
1539 static int velocity_rx_refill(struct velocity_info *vptr)
1541 int dirty = vptr->rx.dirty, done = 0;
1543 do {
1544 struct rx_desc *rd = vptr->rx.ring + dirty;
1546 /* Fine for an all zero Rx desc at init time as well */
1547 if (rd->rdesc0.len & OWNED_BY_NIC)
1548 break;
1550 if (!vptr->rx.info[dirty].skb) {
1551 if (velocity_alloc_rx_buf(vptr, dirty) < 0)
1552 break;
1554 done++;
1555 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
1556 } while (dirty != vptr->rx.curr);
1558 if (done) {
1559 vptr->rx.dirty = dirty;
1560 vptr->rx.filled += done;
1563 return done;
1567 * velocity_free_rd_ring - free receive ring
1568 * @vptr: velocity to clean up
1570 * Free the receive buffers for each ring slot and any
1571 * attached socket buffers that need to go away.
1573 static void velocity_free_rd_ring(struct velocity_info *vptr)
1575 int i;
1577 if (vptr->rx.info == NULL)
1578 return;
1580 for (i = 0; i < vptr->options.numrx; i++) {
1581 struct velocity_rd_info *rd_info = &(vptr->rx.info[i]);
1582 struct rx_desc *rd = vptr->rx.ring + i;
1584 memset(rd, 0, sizeof(*rd));
1586 if (!rd_info->skb)
1587 continue;
1588 pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
1589 PCI_DMA_FROMDEVICE);
1590 rd_info->skb_dma = 0;
1592 dev_kfree_skb(rd_info->skb);
1593 rd_info->skb = NULL;
1596 kfree(vptr->rx.info);
1597 vptr->rx.info = NULL;
1603 * velocity_init_rd_ring - set up receive ring
1604 * @vptr: velocity to configure
1606 * Allocate and set up the receive buffers for each ring slot and
1607 * assign them to the network adapter.
1609 static int velocity_init_rd_ring(struct velocity_info *vptr)
1611 int ret = -ENOMEM;
1613 vptr->rx.info = kcalloc(vptr->options.numrx,
1614 sizeof(struct velocity_rd_info), GFP_KERNEL);
1615 if (!vptr->rx.info)
1616 goto out;
1618 velocity_init_rx_ring_indexes(vptr);
1620 if (velocity_rx_refill(vptr) != vptr->options.numrx) {
1621 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1622 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1623 velocity_free_rd_ring(vptr);
1624 goto out;
1627 ret = 0;
1628 out:
1629 return ret;
1633 * velocity_init_td_ring - set up transmit ring
1634 * @vptr: velocity
1636 * Set up the transmit ring and chain the ring pointers together.
1637 * Returns zero on success or a negative posix errno code for
1638 * failure.
1640 static int velocity_init_td_ring(struct velocity_info *vptr)
1642 int j;
1644 /* Init the TD ring entries */
1645 for (j = 0; j < vptr->tx.numq; j++) {
1647 vptr->tx.infos[j] = kcalloc(vptr->options.numtx,
1648 sizeof(struct velocity_td_info),
1649 GFP_KERNEL);
1650 if (!vptr->tx.infos[j]) {
1651 while (--j >= 0)
1652 kfree(vptr->tx.infos[j]);
1653 return -ENOMEM;
1656 vptr->tx.tail[j] = vptr->tx.curr[j] = vptr->tx.used[j] = 0;
1658 return 0;
1662 * velocity_free_dma_rings - free PCI ring pointers
1663 * @vptr: Velocity to free from
1665 * Clean up the PCI ring buffers allocated to this velocity.
1667 static void velocity_free_dma_rings(struct velocity_info *vptr)
1669 const int size = vptr->options.numrx * sizeof(struct rx_desc) +
1670 vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq;
1672 pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
1676 static int velocity_init_rings(struct velocity_info *vptr, int mtu)
1678 int ret;
1680 velocity_set_rxbufsize(vptr, mtu);
1682 ret = velocity_init_dma_rings(vptr);
1683 if (ret < 0)
1684 goto out;
1686 ret = velocity_init_rd_ring(vptr);
1687 if (ret < 0)
1688 goto err_free_dma_rings_0;
1690 ret = velocity_init_td_ring(vptr);
1691 if (ret < 0)
1692 goto err_free_rd_ring_1;
1693 out:
1694 return ret;
1696 err_free_rd_ring_1:
1697 velocity_free_rd_ring(vptr);
1698 err_free_dma_rings_0:
1699 velocity_free_dma_rings(vptr);
1700 goto out;
1704 * velocity_free_tx_buf - free transmit buffer
1705 * @vptr: velocity
1706 * @tdinfo: buffer
1708 * Release an transmit buffer. If the buffer was preallocated then
1709 * recycle it, if not then unmap the buffer.
1711 static void velocity_free_tx_buf(struct velocity_info *vptr,
1712 struct velocity_td_info *tdinfo, struct tx_desc *td)
1714 struct sk_buff *skb = tdinfo->skb;
1717 * Don't unmap the pre-allocated tx_bufs
1719 if (tdinfo->skb_dma) {
1720 int i;
1722 for (i = 0; i < tdinfo->nskb_dma; i++) {
1723 size_t pktlen = max_t(size_t, skb->len, ETH_ZLEN);
1725 /* For scatter-gather */
1726 if (skb_shinfo(skb)->nr_frags > 0)
1727 pktlen = max_t(size_t, pktlen,
1728 td->td_buf[i].size & ~TD_QUEUE);
1730 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i],
1731 le16_to_cpu(pktlen), PCI_DMA_TODEVICE);
1734 dev_kfree_skb_irq(skb);
1735 tdinfo->skb = NULL;
1740 * FIXME: could we merge this with velocity_free_tx_buf ?
1742 static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1743 int q, int n)
1745 struct velocity_td_info *td_info = &(vptr->tx.infos[q][n]);
1746 int i;
1748 if (td_info == NULL)
1749 return;
1751 if (td_info->skb) {
1752 for (i = 0; i < td_info->nskb_dma; i++) {
1753 if (td_info->skb_dma[i]) {
1754 pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
1755 td_info->skb->len, PCI_DMA_TODEVICE);
1756 td_info->skb_dma[i] = 0;
1759 dev_kfree_skb(td_info->skb);
1760 td_info->skb = NULL;
1765 * velocity_free_td_ring - free td ring
1766 * @vptr: velocity
1768 * Free up the transmit ring for this particular velocity adapter.
1769 * We free the ring contents but not the ring itself.
1771 static void velocity_free_td_ring(struct velocity_info *vptr)
1773 int i, j;
1775 for (j = 0; j < vptr->tx.numq; j++) {
1776 if (vptr->tx.infos[j] == NULL)
1777 continue;
1778 for (i = 0; i < vptr->options.numtx; i++)
1779 velocity_free_td_ring_entry(vptr, j, i);
1781 kfree(vptr->tx.infos[j]);
1782 vptr->tx.infos[j] = NULL;
1787 static void velocity_free_rings(struct velocity_info *vptr)
1789 velocity_free_td_ring(vptr);
1790 velocity_free_rd_ring(vptr);
1791 velocity_free_dma_rings(vptr);
1795 * velocity_error - handle error from controller
1796 * @vptr: velocity
1797 * @status: card status
1799 * Process an error report from the hardware and attempt to recover
1800 * the card itself. At the moment we cannot recover from some
1801 * theoretically impossible errors but this could be fixed using
1802 * the pci_device_failed logic to bounce the hardware
1805 static void velocity_error(struct velocity_info *vptr, int status)
1808 if (status & ISR_TXSTLI) {
1809 struct mac_regs __iomem *regs = vptr->mac_regs;
1811 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1812 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1813 writew(TRDCSR_RUN, &regs->TDCSRClr);
1814 netif_stop_queue(vptr->dev);
1816 /* FIXME: port over the pci_device_failed code and use it
1817 here */
1820 if (status & ISR_SRCI) {
1821 struct mac_regs __iomem *regs = vptr->mac_regs;
1822 int linked;
1824 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1825 vptr->mii_status = check_connection_type(regs);
1828 * If it is a 3119, disable frame bursting in
1829 * halfduplex mode and enable it in fullduplex
1830 * mode
1832 if (vptr->rev_id < REV_ID_VT3216_A0) {
1833 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1834 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1835 else
1836 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1839 * Only enable CD heart beat counter in 10HD mode
1841 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10))
1842 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1843 else
1844 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1846 setup_queue_timers(vptr);
1849 * Get link status from PHYSR0
1851 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1853 if (linked) {
1854 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1855 netif_carrier_on(vptr->dev);
1856 } else {
1857 vptr->mii_status |= VELOCITY_LINK_FAIL;
1858 netif_carrier_off(vptr->dev);
1861 velocity_print_link_status(vptr);
1862 enable_flow_control_ability(vptr);
1865 * Re-enable auto-polling because SRCI will disable
1866 * auto-polling
1869 enable_mii_autopoll(regs);
1871 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1872 netif_stop_queue(vptr->dev);
1873 else
1874 netif_wake_queue(vptr->dev);
1877 if (status & ISR_MIBFI)
1878 velocity_update_hw_mibs(vptr);
1879 if (status & ISR_LSTEI)
1880 mac_rx_queue_wake(vptr->mac_regs);
1884 * tx_srv - transmit interrupt service
1885 * @vptr; Velocity
1887 * Scan the queues looking for transmitted packets that
1888 * we can complete and clean up. Update any statistics as
1889 * necessary/
1891 static int velocity_tx_srv(struct velocity_info *vptr)
1893 struct tx_desc *td;
1894 int qnum;
1895 int full = 0;
1896 int idx;
1897 int works = 0;
1898 struct velocity_td_info *tdinfo;
1899 struct net_device_stats *stats = &vptr->dev->stats;
1901 for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
1902 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
1903 idx = (idx + 1) % vptr->options.numtx) {
1906 * Get Tx Descriptor
1908 td = &(vptr->tx.rings[qnum][idx]);
1909 tdinfo = &(vptr->tx.infos[qnum][idx]);
1911 if (td->tdesc0.len & OWNED_BY_NIC)
1912 break;
1914 if ((works++ > 15))
1915 break;
1917 if (td->tdesc0.TSR & TSR0_TERR) {
1918 stats->tx_errors++;
1919 stats->tx_dropped++;
1920 if (td->tdesc0.TSR & TSR0_CDH)
1921 stats->tx_heartbeat_errors++;
1922 if (td->tdesc0.TSR & TSR0_CRS)
1923 stats->tx_carrier_errors++;
1924 if (td->tdesc0.TSR & TSR0_ABT)
1925 stats->tx_aborted_errors++;
1926 if (td->tdesc0.TSR & TSR0_OWC)
1927 stats->tx_window_errors++;
1928 } else {
1929 stats->tx_packets++;
1930 stats->tx_bytes += tdinfo->skb->len;
1932 velocity_free_tx_buf(vptr, tdinfo, td);
1933 vptr->tx.used[qnum]--;
1935 vptr->tx.tail[qnum] = idx;
1937 if (AVAIL_TD(vptr, qnum) < 1)
1938 full = 1;
1941 * Look to see if we should kick the transmit network
1942 * layer for more work.
1944 if (netif_queue_stopped(vptr->dev) && (full == 0) &&
1945 (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1946 netif_wake_queue(vptr->dev);
1948 return works;
1952 * velocity_rx_csum - checksum process
1953 * @rd: receive packet descriptor
1954 * @skb: network layer packet buffer
1956 * Process the status bits for the received packet and determine
1957 * if the checksum was computed and verified by the hardware
1959 static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1961 skb_checksum_none_assert(skb);
1963 if (rd->rdesc1.CSM & CSM_IPKT) {
1964 if (rd->rdesc1.CSM & CSM_IPOK) {
1965 if ((rd->rdesc1.CSM & CSM_TCPKT) ||
1966 (rd->rdesc1.CSM & CSM_UDPKT)) {
1967 if (!(rd->rdesc1.CSM & CSM_TUPOK))
1968 return;
1970 skb->ip_summed = CHECKSUM_UNNECESSARY;
1976 * velocity_rx_copy - in place Rx copy for small packets
1977 * @rx_skb: network layer packet buffer candidate
1978 * @pkt_size: received data size
1979 * @rd: receive packet descriptor
1980 * @dev: network device
1982 * Replace the current skb that is scheduled for Rx processing by a
1983 * shorter, immediately allocated skb, if the received packet is small
1984 * enough. This function returns a negative value if the received
1985 * packet is too big or if memory is exhausted.
1987 static int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
1988 struct velocity_info *vptr)
1990 int ret = -1;
1991 if (pkt_size < rx_copybreak) {
1992 struct sk_buff *new_skb;
1994 new_skb = netdev_alloc_skb_ip_align(vptr->dev, pkt_size);
1995 if (new_skb) {
1996 new_skb->ip_summed = rx_skb[0]->ip_summed;
1997 skb_copy_from_linear_data(*rx_skb, new_skb->data, pkt_size);
1998 *rx_skb = new_skb;
1999 ret = 0;
2003 return ret;
2007 * velocity_iph_realign - IP header alignment
2008 * @vptr: velocity we are handling
2009 * @skb: network layer packet buffer
2010 * @pkt_size: received data size
2012 * Align IP header on a 2 bytes boundary. This behavior can be
2013 * configured by the user.
2015 static inline void velocity_iph_realign(struct velocity_info *vptr,
2016 struct sk_buff *skb, int pkt_size)
2018 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
2019 memmove(skb->data + 2, skb->data, pkt_size);
2020 skb_reserve(skb, 2);
2026 * velocity_receive_frame - received packet processor
2027 * @vptr: velocity we are handling
2028 * @idx: ring index
2030 * A packet has arrived. We process the packet and if appropriate
2031 * pass the frame up the network stack
2033 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
2035 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
2036 struct net_device_stats *stats = &vptr->dev->stats;
2037 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
2038 struct rx_desc *rd = &(vptr->rx.ring[idx]);
2039 int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
2040 struct sk_buff *skb;
2042 if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
2043 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
2044 stats->rx_length_errors++;
2045 return -EINVAL;
2048 if (rd->rdesc0.RSR & RSR_MAR)
2049 stats->multicast++;
2051 skb = rd_info->skb;
2053 pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
2054 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
2057 * Drop frame not meeting IEEE 802.3
2060 if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
2061 if (rd->rdesc0.RSR & RSR_RL) {
2062 stats->rx_length_errors++;
2063 return -EINVAL;
2067 pci_action = pci_dma_sync_single_for_device;
2069 velocity_rx_csum(rd, skb);
2071 if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
2072 velocity_iph_realign(vptr, skb, pkt_len);
2073 pci_action = pci_unmap_single;
2074 rd_info->skb = NULL;
2077 pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
2078 PCI_DMA_FROMDEVICE);
2080 skb_put(skb, pkt_len - 4);
2081 skb->protocol = eth_type_trans(skb, vptr->dev);
2083 if (rd->rdesc0.RSR & RSR_DETAG) {
2084 u16 vid = swab16(le16_to_cpu(rd->rdesc1.PQTAG));
2086 __vlan_hwaccel_put_tag(skb, vid);
2088 netif_rx(skb);
2090 stats->rx_bytes += pkt_len;
2092 return 0;
2097 * velocity_rx_srv - service RX interrupt
2098 * @vptr: velocity
2100 * Walk the receive ring of the velocity adapter and remove
2101 * any received packets from the receive queue. Hand the ring
2102 * slots back to the adapter for reuse.
2104 static int velocity_rx_srv(struct velocity_info *vptr, int budget_left)
2106 struct net_device_stats *stats = &vptr->dev->stats;
2107 int rd_curr = vptr->rx.curr;
2108 int works = 0;
2110 while (works < budget_left) {
2111 struct rx_desc *rd = vptr->rx.ring + rd_curr;
2113 if (!vptr->rx.info[rd_curr].skb)
2114 break;
2116 if (rd->rdesc0.len & OWNED_BY_NIC)
2117 break;
2119 rmb();
2122 * Don't drop CE or RL error frame although RXOK is off
2124 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) {
2125 if (velocity_receive_frame(vptr, rd_curr) < 0)
2126 stats->rx_dropped++;
2127 } else {
2128 if (rd->rdesc0.RSR & RSR_CRC)
2129 stats->rx_crc_errors++;
2130 if (rd->rdesc0.RSR & RSR_FAE)
2131 stats->rx_frame_errors++;
2133 stats->rx_dropped++;
2136 rd->size |= RX_INTEN;
2138 rd_curr++;
2139 if (rd_curr >= vptr->options.numrx)
2140 rd_curr = 0;
2141 works++;
2144 vptr->rx.curr = rd_curr;
2146 if ((works > 0) && (velocity_rx_refill(vptr) > 0))
2147 velocity_give_many_rx_descs(vptr);
2149 VAR_USED(stats);
2150 return works;
2153 static int velocity_poll(struct napi_struct *napi, int budget)
2155 struct velocity_info *vptr = container_of(napi,
2156 struct velocity_info, napi);
2157 unsigned int rx_done;
2158 unsigned long flags;
2160 spin_lock_irqsave(&vptr->lock, flags);
2162 * Do rx and tx twice for performance (taken from the VIA
2163 * out-of-tree driver).
2165 rx_done = velocity_rx_srv(vptr, budget / 2);
2166 velocity_tx_srv(vptr);
2167 rx_done += velocity_rx_srv(vptr, budget - rx_done);
2168 velocity_tx_srv(vptr);
2170 /* If budget not fully consumed, exit the polling mode */
2171 if (rx_done < budget) {
2172 napi_complete(napi);
2173 mac_enable_int(vptr->mac_regs);
2175 spin_unlock_irqrestore(&vptr->lock, flags);
2177 return rx_done;
2181 * velocity_intr - interrupt callback
2182 * @irq: interrupt number
2183 * @dev_instance: interrupting device
2185 * Called whenever an interrupt is generated by the velocity
2186 * adapter IRQ line. We may not be the source of the interrupt
2187 * and need to identify initially if we are, and if not exit as
2188 * efficiently as possible.
2190 static irqreturn_t velocity_intr(int irq, void *dev_instance)
2192 struct net_device *dev = dev_instance;
2193 struct velocity_info *vptr = netdev_priv(dev);
2194 u32 isr_status;
2196 spin_lock(&vptr->lock);
2197 isr_status = mac_read_isr(vptr->mac_regs);
2199 /* Not us ? */
2200 if (isr_status == 0) {
2201 spin_unlock(&vptr->lock);
2202 return IRQ_NONE;
2205 /* Ack the interrupt */
2206 mac_write_isr(vptr->mac_regs, isr_status);
2208 if (likely(napi_schedule_prep(&vptr->napi))) {
2209 mac_disable_int(vptr->mac_regs);
2210 __napi_schedule(&vptr->napi);
2213 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2214 velocity_error(vptr, isr_status);
2216 spin_unlock(&vptr->lock);
2218 return IRQ_HANDLED;
2222 * velocity_open - interface activation callback
2223 * @dev: network layer device to open
2225 * Called when the network layer brings the interface up. Returns
2226 * a negative posix error code on failure, or zero on success.
2228 * All the ring allocation and set up is done on open for this
2229 * adapter to minimise memory usage when inactive
2231 static int velocity_open(struct net_device *dev)
2233 struct velocity_info *vptr = netdev_priv(dev);
2234 int ret;
2236 ret = velocity_init_rings(vptr, dev->mtu);
2237 if (ret < 0)
2238 goto out;
2240 /* Ensure chip is running */
2241 pci_set_power_state(vptr->pdev, PCI_D0);
2243 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2245 ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
2246 dev->name, dev);
2247 if (ret < 0) {
2248 /* Power down the chip */
2249 pci_set_power_state(vptr->pdev, PCI_D3hot);
2250 velocity_free_rings(vptr);
2251 goto out;
2254 velocity_give_many_rx_descs(vptr);
2256 mac_enable_int(vptr->mac_regs);
2257 netif_start_queue(dev);
2258 napi_enable(&vptr->napi);
2259 vptr->flags |= VELOCITY_FLAGS_OPENED;
2260 out:
2261 return ret;
2265 * velocity_shutdown - shut down the chip
2266 * @vptr: velocity to deactivate
2268 * Shuts down the internal operations of the velocity and
2269 * disables interrupts, autopolling, transmit and receive
2271 static void velocity_shutdown(struct velocity_info *vptr)
2273 struct mac_regs __iomem *regs = vptr->mac_regs;
2274 mac_disable_int(regs);
2275 writel(CR0_STOP, &regs->CR0Set);
2276 writew(0xFFFF, &regs->TDCSRClr);
2277 writeb(0xFF, &regs->RDCSRClr);
2278 safe_disable_mii_autopoll(regs);
2279 mac_clear_isr(regs);
2283 * velocity_change_mtu - MTU change callback
2284 * @dev: network device
2285 * @new_mtu: desired MTU
2287 * Handle requests from the networking layer for MTU change on
2288 * this interface. It gets called on a change by the network layer.
2289 * Return zero for success or negative posix error code.
2291 static int velocity_change_mtu(struct net_device *dev, int new_mtu)
2293 struct velocity_info *vptr = netdev_priv(dev);
2294 int ret = 0;
2296 if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
2297 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
2298 vptr->dev->name);
2299 ret = -EINVAL;
2300 goto out_0;
2303 if (!netif_running(dev)) {
2304 dev->mtu = new_mtu;
2305 goto out_0;
2308 if (dev->mtu != new_mtu) {
2309 struct velocity_info *tmp_vptr;
2310 unsigned long flags;
2311 struct rx_info rx;
2312 struct tx_info tx;
2314 tmp_vptr = kzalloc(sizeof(*tmp_vptr), GFP_KERNEL);
2315 if (!tmp_vptr) {
2316 ret = -ENOMEM;
2317 goto out_0;
2320 tmp_vptr->dev = dev;
2321 tmp_vptr->pdev = vptr->pdev;
2322 tmp_vptr->options = vptr->options;
2323 tmp_vptr->tx.numq = vptr->tx.numq;
2325 ret = velocity_init_rings(tmp_vptr, new_mtu);
2326 if (ret < 0)
2327 goto out_free_tmp_vptr_1;
2329 spin_lock_irqsave(&vptr->lock, flags);
2331 netif_stop_queue(dev);
2332 velocity_shutdown(vptr);
2334 rx = vptr->rx;
2335 tx = vptr->tx;
2337 vptr->rx = tmp_vptr->rx;
2338 vptr->tx = tmp_vptr->tx;
2340 tmp_vptr->rx = rx;
2341 tmp_vptr->tx = tx;
2343 dev->mtu = new_mtu;
2345 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2347 velocity_give_many_rx_descs(vptr);
2349 mac_enable_int(vptr->mac_regs);
2350 netif_start_queue(dev);
2352 spin_unlock_irqrestore(&vptr->lock, flags);
2354 velocity_free_rings(tmp_vptr);
2356 out_free_tmp_vptr_1:
2357 kfree(tmp_vptr);
2359 out_0:
2360 return ret;
2364 * velocity_mii_ioctl - MII ioctl handler
2365 * @dev: network device
2366 * @ifr: the ifreq block for the ioctl
2367 * @cmd: the command
2369 * Process MII requests made via ioctl from the network layer. These
2370 * are used by tools like kudzu to interrogate the link state of the
2371 * hardware
2373 static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2375 struct velocity_info *vptr = netdev_priv(dev);
2376 struct mac_regs __iomem *regs = vptr->mac_regs;
2377 unsigned long flags;
2378 struct mii_ioctl_data *miidata = if_mii(ifr);
2379 int err;
2381 switch (cmd) {
2382 case SIOCGMIIPHY:
2383 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
2384 break;
2385 case SIOCGMIIREG:
2386 if (velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
2387 return -ETIMEDOUT;
2388 break;
2389 case SIOCSMIIREG:
2390 spin_lock_irqsave(&vptr->lock, flags);
2391 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
2392 spin_unlock_irqrestore(&vptr->lock, flags);
2393 check_connection_type(vptr->mac_regs);
2394 if (err)
2395 return err;
2396 break;
2397 default:
2398 return -EOPNOTSUPP;
2400 return 0;
2405 * velocity_ioctl - ioctl entry point
2406 * @dev: network device
2407 * @rq: interface request ioctl
2408 * @cmd: command code
2410 * Called when the user issues an ioctl request to the network
2411 * device in question. The velocity interface supports MII.
2413 static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2415 struct velocity_info *vptr = netdev_priv(dev);
2416 int ret;
2418 /* If we are asked for information and the device is power
2419 saving then we need to bring the device back up to talk to it */
2421 if (!netif_running(dev))
2422 pci_set_power_state(vptr->pdev, PCI_D0);
2424 switch (cmd) {
2425 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2426 case SIOCGMIIREG: /* Read MII PHY register. */
2427 case SIOCSMIIREG: /* Write to MII PHY register. */
2428 ret = velocity_mii_ioctl(dev, rq, cmd);
2429 break;
2431 default:
2432 ret = -EOPNOTSUPP;
2434 if (!netif_running(dev))
2435 pci_set_power_state(vptr->pdev, PCI_D3hot);
2438 return ret;
2442 * velocity_get_status - statistics callback
2443 * @dev: network device
2445 * Callback from the network layer to allow driver statistics
2446 * to be resynchronized with hardware collected state. In the
2447 * case of the velocity we need to pull the MIB counters from
2448 * the hardware into the counters before letting the network
2449 * layer display them.
2451 static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2453 struct velocity_info *vptr = netdev_priv(dev);
2455 /* If the hardware is down, don't touch MII */
2456 if (!netif_running(dev))
2457 return &dev->stats;
2459 spin_lock_irq(&vptr->lock);
2460 velocity_update_hw_mibs(vptr);
2461 spin_unlock_irq(&vptr->lock);
2463 dev->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2464 dev->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2465 dev->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2467 // unsigned long rx_dropped; /* no space in linux buffers */
2468 dev->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2469 /* detailed rx_errors: */
2470 // unsigned long rx_length_errors;
2471 // unsigned long rx_over_errors; /* receiver ring buff overflow */
2472 dev->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2473 // unsigned long rx_frame_errors; /* recv'd frame alignment error */
2474 // unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2475 // unsigned long rx_missed_errors; /* receiver missed packet */
2477 /* detailed tx_errors */
2478 // unsigned long tx_fifo_errors;
2480 return &dev->stats;
2484 * velocity_close - close adapter callback
2485 * @dev: network device
2487 * Callback from the network layer when the velocity is being
2488 * deactivated by the network layer
2490 static int velocity_close(struct net_device *dev)
2492 struct velocity_info *vptr = netdev_priv(dev);
2494 napi_disable(&vptr->napi);
2495 netif_stop_queue(dev);
2496 velocity_shutdown(vptr);
2498 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
2499 velocity_get_ip(vptr);
2500 if (dev->irq != 0)
2501 free_irq(dev->irq, dev);
2503 /* Power down the chip */
2504 pci_set_power_state(vptr->pdev, PCI_D3hot);
2506 velocity_free_rings(vptr);
2508 vptr->flags &= (~VELOCITY_FLAGS_OPENED);
2509 return 0;
2513 * velocity_xmit - transmit packet callback
2514 * @skb: buffer to transmit
2515 * @dev: network device
2517 * Called by the networ layer to request a packet is queued to
2518 * the velocity. Returns zero on success.
2520 static netdev_tx_t velocity_xmit(struct sk_buff *skb,
2521 struct net_device *dev)
2523 struct velocity_info *vptr = netdev_priv(dev);
2524 int qnum = 0;
2525 struct tx_desc *td_ptr;
2526 struct velocity_td_info *tdinfo;
2527 unsigned long flags;
2528 int pktlen;
2529 int index, prev;
2530 int i = 0;
2532 if (skb_padto(skb, ETH_ZLEN))
2533 goto out;
2535 /* The hardware can handle at most 7 memory segments, so merge
2536 * the skb if there are more */
2537 if (skb_shinfo(skb)->nr_frags > 6 && __skb_linearize(skb)) {
2538 kfree_skb(skb);
2539 return NETDEV_TX_OK;
2542 pktlen = skb_shinfo(skb)->nr_frags == 0 ?
2543 max_t(unsigned int, skb->len, ETH_ZLEN) :
2544 skb_headlen(skb);
2546 spin_lock_irqsave(&vptr->lock, flags);
2548 index = vptr->tx.curr[qnum];
2549 td_ptr = &(vptr->tx.rings[qnum][index]);
2550 tdinfo = &(vptr->tx.infos[qnum][index]);
2552 td_ptr->tdesc1.TCR = TCR0_TIC;
2553 td_ptr->td_buf[0].size &= ~TD_QUEUE;
2556 * Map the linear network buffer into PCI space and
2557 * add it to the transmit ring.
2559 tdinfo->skb = skb;
2560 tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
2561 td_ptr->tdesc0.len = cpu_to_le16(pktlen);
2562 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2563 td_ptr->td_buf[0].pa_high = 0;
2564 td_ptr->td_buf[0].size = cpu_to_le16(pktlen);
2566 /* Handle fragments */
2567 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2568 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2570 tdinfo->skb_dma[i + 1] = pci_map_page(vptr->pdev, frag->page,
2571 frag->page_offset, frag->size,
2572 PCI_DMA_TODEVICE);
2574 td_ptr->td_buf[i + 1].pa_low = cpu_to_le32(tdinfo->skb_dma[i + 1]);
2575 td_ptr->td_buf[i + 1].pa_high = 0;
2576 td_ptr->td_buf[i + 1].size = cpu_to_le16(frag->size);
2578 tdinfo->nskb_dma = i + 1;
2580 td_ptr->tdesc1.cmd = TCPLS_NORMAL + (tdinfo->nskb_dma + 1) * 16;
2582 if (vlan_tx_tag_present(skb)) {
2583 td_ptr->tdesc1.vlan = cpu_to_le16(vlan_tx_tag_get(skb));
2584 td_ptr->tdesc1.TCR |= TCR0_VETAG;
2588 * Handle hardware checksum
2590 if (skb->ip_summed == CHECKSUM_PARTIAL) {
2591 const struct iphdr *ip = ip_hdr(skb);
2592 if (ip->protocol == IPPROTO_TCP)
2593 td_ptr->tdesc1.TCR |= TCR0_TCPCK;
2594 else if (ip->protocol == IPPROTO_UDP)
2595 td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
2596 td_ptr->tdesc1.TCR |= TCR0_IPCK;
2599 prev = index - 1;
2600 if (prev < 0)
2601 prev = vptr->options.numtx - 1;
2602 td_ptr->tdesc0.len |= OWNED_BY_NIC;
2603 vptr->tx.used[qnum]++;
2604 vptr->tx.curr[qnum] = (index + 1) % vptr->options.numtx;
2606 if (AVAIL_TD(vptr, qnum) < 1)
2607 netif_stop_queue(dev);
2609 td_ptr = &(vptr->tx.rings[qnum][prev]);
2610 td_ptr->td_buf[0].size |= TD_QUEUE;
2611 mac_tx_queue_wake(vptr->mac_regs, qnum);
2613 spin_unlock_irqrestore(&vptr->lock, flags);
2614 out:
2615 return NETDEV_TX_OK;
2619 static const struct net_device_ops velocity_netdev_ops = {
2620 .ndo_open = velocity_open,
2621 .ndo_stop = velocity_close,
2622 .ndo_start_xmit = velocity_xmit,
2623 .ndo_get_stats = velocity_get_stats,
2624 .ndo_validate_addr = eth_validate_addr,
2625 .ndo_set_mac_address = eth_mac_addr,
2626 .ndo_set_multicast_list = velocity_set_multi,
2627 .ndo_change_mtu = velocity_change_mtu,
2628 .ndo_do_ioctl = velocity_ioctl,
2629 .ndo_vlan_rx_add_vid = velocity_vlan_rx_add_vid,
2630 .ndo_vlan_rx_kill_vid = velocity_vlan_rx_kill_vid,
2634 * velocity_init_info - init private data
2635 * @pdev: PCI device
2636 * @vptr: Velocity info
2637 * @info: Board type
2639 * Set up the initial velocity_info struct for the device that has been
2640 * discovered.
2642 static void __devinit velocity_init_info(struct pci_dev *pdev,
2643 struct velocity_info *vptr,
2644 const struct velocity_info_tbl *info)
2646 memset(vptr, 0, sizeof(struct velocity_info));
2648 vptr->pdev = pdev;
2649 vptr->chip_id = info->chip_id;
2650 vptr->tx.numq = info->txqueue;
2651 vptr->multicast_limit = MCAM_SIZE;
2652 spin_lock_init(&vptr->lock);
2656 * velocity_get_pci_info - retrieve PCI info for device
2657 * @vptr: velocity device
2658 * @pdev: PCI device it matches
2660 * Retrieve the PCI configuration space data that interests us from
2661 * the kernel PCI layer
2663 static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
2665 vptr->rev_id = pdev->revision;
2667 pci_set_master(pdev);
2669 vptr->ioaddr = pci_resource_start(pdev, 0);
2670 vptr->memaddr = pci_resource_start(pdev, 1);
2672 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2673 dev_err(&pdev->dev,
2674 "region #0 is not an I/O resource, aborting.\n");
2675 return -EINVAL;
2678 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
2679 dev_err(&pdev->dev,
2680 "region #1 is an I/O resource, aborting.\n");
2681 return -EINVAL;
2684 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
2685 dev_err(&pdev->dev, "region #1 is too small.\n");
2686 return -EINVAL;
2688 vptr->pdev = pdev;
2690 return 0;
2694 * velocity_print_info - per driver data
2695 * @vptr: velocity
2697 * Print per driver data as the kernel driver finds Velocity
2698 * hardware
2700 static void __devinit velocity_print_info(struct velocity_info *vptr)
2702 struct net_device *dev = vptr->dev;
2704 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
2705 printk(KERN_INFO "%s: Ethernet Address: %pM\n",
2706 dev->name, dev->dev_addr);
2709 static u32 velocity_get_link(struct net_device *dev)
2711 struct velocity_info *vptr = netdev_priv(dev);
2712 struct mac_regs __iomem *regs = vptr->mac_regs;
2713 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
2718 * velocity_found1 - set up discovered velocity card
2719 * @pdev: PCI device
2720 * @ent: PCI device table entry that matched
2722 * Configure a discovered adapter from scratch. Return a negative
2723 * errno error code on failure paths.
2725 static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
2727 static int first = 1;
2728 struct net_device *dev;
2729 int i;
2730 const char *drv_string;
2731 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
2732 struct velocity_info *vptr;
2733 struct mac_regs __iomem *regs;
2734 int ret = -ENOMEM;
2736 /* FIXME: this driver, like almost all other ethernet drivers,
2737 * can support more than MAX_UNITS.
2739 if (velocity_nics >= MAX_UNITS) {
2740 dev_notice(&pdev->dev, "already found %d NICs.\n",
2741 velocity_nics);
2742 return -ENODEV;
2745 dev = alloc_etherdev(sizeof(struct velocity_info));
2746 if (!dev) {
2747 dev_err(&pdev->dev, "allocate net device failed.\n");
2748 goto out;
2751 /* Chain it all together */
2753 SET_NETDEV_DEV(dev, &pdev->dev);
2754 vptr = netdev_priv(dev);
2757 if (first) {
2758 printk(KERN_INFO "%s Ver. %s\n",
2759 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
2760 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
2761 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
2762 first = 0;
2765 velocity_init_info(pdev, vptr, info);
2767 vptr->dev = dev;
2769 ret = pci_enable_device(pdev);
2770 if (ret < 0)
2771 goto err_free_dev;
2773 dev->irq = pdev->irq;
2775 ret = velocity_get_pci_info(vptr, pdev);
2776 if (ret < 0) {
2777 /* error message already printed */
2778 goto err_disable;
2781 ret = pci_request_regions(pdev, VELOCITY_NAME);
2782 if (ret < 0) {
2783 dev_err(&pdev->dev, "No PCI resources.\n");
2784 goto err_disable;
2787 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
2788 if (regs == NULL) {
2789 ret = -EIO;
2790 goto err_release_res;
2793 vptr->mac_regs = regs;
2795 mac_wol_reset(regs);
2797 dev->base_addr = vptr->ioaddr;
2799 for (i = 0; i < 6; i++)
2800 dev->dev_addr[i] = readb(&regs->PAR[i]);
2803 drv_string = dev_driver_string(&pdev->dev);
2805 velocity_get_options(&vptr->options, velocity_nics, drv_string);
2808 * Mask out the options cannot be set to the chip
2811 vptr->options.flags &= info->flags;
2814 * Enable the chip specified capbilities
2817 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
2819 vptr->wol_opts = vptr->options.wol_opts;
2820 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
2822 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
2824 dev->irq = pdev->irq;
2825 dev->netdev_ops = &velocity_netdev_ops;
2826 dev->ethtool_ops = &velocity_ethtool_ops;
2827 netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
2829 dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_HW_VLAN_TX;
2830 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
2831 NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM;
2833 ret = register_netdev(dev);
2834 if (ret < 0)
2835 goto err_iounmap;
2837 if (!velocity_get_link(dev)) {
2838 netif_carrier_off(dev);
2839 vptr->mii_status |= VELOCITY_LINK_FAIL;
2842 velocity_print_info(vptr);
2843 pci_set_drvdata(pdev, dev);
2845 /* and leave the chip powered down */
2847 pci_set_power_state(pdev, PCI_D3hot);
2848 velocity_nics++;
2849 out:
2850 return ret;
2852 err_iounmap:
2853 iounmap(regs);
2854 err_release_res:
2855 pci_release_regions(pdev);
2856 err_disable:
2857 pci_disable_device(pdev);
2858 err_free_dev:
2859 free_netdev(dev);
2860 goto out;
2864 #ifdef CONFIG_PM
2866 * wol_calc_crc - WOL CRC
2867 * @pattern: data pattern
2868 * @mask_pattern: mask
2870 * Compute the wake on lan crc hashes for the packet header
2871 * we are interested in.
2873 static u16 wol_calc_crc(int size, u8 *pattern, u8 *mask_pattern)
2875 u16 crc = 0xFFFF;
2876 u8 mask;
2877 int i, j;
2879 for (i = 0; i < size; i++) {
2880 mask = mask_pattern[i];
2882 /* Skip this loop if the mask equals to zero */
2883 if (mask == 0x00)
2884 continue;
2886 for (j = 0; j < 8; j++) {
2887 if ((mask & 0x01) == 0) {
2888 mask >>= 1;
2889 continue;
2891 mask >>= 1;
2892 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
2895 /* Finally, invert the result once to get the correct data */
2896 crc = ~crc;
2897 return bitrev32(crc) >> 16;
2901 * velocity_set_wol - set up for wake on lan
2902 * @vptr: velocity to set WOL status on
2904 * Set a card up for wake on lan either by unicast or by
2905 * ARP packet.
2907 * FIXME: check static buffer is safe here
2909 static int velocity_set_wol(struct velocity_info *vptr)
2911 struct mac_regs __iomem *regs = vptr->mac_regs;
2912 enum speed_opt spd_dpx = vptr->options.spd_dpx;
2913 static u8 buf[256];
2914 int i;
2916 static u32 mask_pattern[2][4] = {
2917 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
2918 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
2921 writew(0xFFFF, &regs->WOLCRClr);
2922 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
2923 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
2926 if (vptr->wol_opts & VELOCITY_WOL_PHY)
2927 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
2930 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
2931 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
2933 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
2934 struct arp_packet *arp = (struct arp_packet *) buf;
2935 u16 crc;
2936 memset(buf, 0, sizeof(struct arp_packet) + 7);
2938 for (i = 0; i < 4; i++)
2939 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
2941 arp->type = htons(ETH_P_ARP);
2942 arp->ar_op = htons(1);
2944 memcpy(arp->ar_tip, vptr->ip_addr, 4);
2946 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
2947 (u8 *) & mask_pattern[0][0]);
2949 writew(crc, &regs->PatternCRC[0]);
2950 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
2953 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
2954 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
2956 writew(0x0FFF, &regs->WOLSRClr);
2958 if (spd_dpx == SPD_DPX_1000_FULL)
2959 goto mac_done;
2961 if (spd_dpx != SPD_DPX_AUTO)
2962 goto advertise_done;
2964 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
2965 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
2966 MII_REG_BITS_ON(AUXCR_MDPPS, MII_NCONFIG, vptr->mac_regs);
2968 MII_REG_BITS_OFF(ADVERTISE_1000FULL | ADVERTISE_1000HALF, MII_CTRL1000, vptr->mac_regs);
2971 if (vptr->mii_status & VELOCITY_SPEED_1000)
2972 MII_REG_BITS_ON(BMCR_ANRESTART, MII_BMCR, vptr->mac_regs);
2974 advertise_done:
2975 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2978 u8 GCR;
2979 GCR = readb(&regs->CHIPGCR);
2980 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
2981 writeb(GCR, &regs->CHIPGCR);
2984 mac_done:
2985 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
2986 /* Turn on SWPTAG just before entering power mode */
2987 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
2988 /* Go to bed ..... */
2989 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
2991 return 0;
2995 * velocity_save_context - save registers
2996 * @vptr: velocity
2997 * @context: buffer for stored context
2999 * Retrieve the current configuration from the velocity hardware
3000 * and stash it in the context structure, for use by the context
3001 * restore functions. This allows us to save things we need across
3002 * power down states
3004 static void velocity_save_context(struct velocity_info *vptr, struct velocity_context *context)
3006 struct mac_regs __iomem *regs = vptr->mac_regs;
3007 u16 i;
3008 u8 __iomem *ptr = (u8 __iomem *)regs;
3010 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
3011 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3013 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
3014 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3016 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3017 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3021 static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
3023 struct net_device *dev = pci_get_drvdata(pdev);
3024 struct velocity_info *vptr = netdev_priv(dev);
3025 unsigned long flags;
3027 if (!netif_running(vptr->dev))
3028 return 0;
3030 netif_device_detach(vptr->dev);
3032 spin_lock_irqsave(&vptr->lock, flags);
3033 pci_save_state(pdev);
3034 #ifdef ETHTOOL_GWOL
3035 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3036 velocity_get_ip(vptr);
3037 velocity_save_context(vptr, &vptr->context);
3038 velocity_shutdown(vptr);
3039 velocity_set_wol(vptr);
3040 pci_enable_wake(pdev, PCI_D3hot, 1);
3041 pci_set_power_state(pdev, PCI_D3hot);
3042 } else {
3043 velocity_save_context(vptr, &vptr->context);
3044 velocity_shutdown(vptr);
3045 pci_disable_device(pdev);
3046 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3048 #else
3049 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3050 #endif
3051 spin_unlock_irqrestore(&vptr->lock, flags);
3052 return 0;
3056 * velocity_restore_context - restore registers
3057 * @vptr: velocity
3058 * @context: buffer for stored context
3060 * Reload the register configuration from the velocity context
3061 * created by velocity_save_context.
3063 static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
3065 struct mac_regs __iomem *regs = vptr->mac_regs;
3066 int i;
3067 u8 __iomem *ptr = (u8 __iomem *)regs;
3069 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4)
3070 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3072 /* Just skip cr0 */
3073 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3074 /* Clear */
3075 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3076 /* Set */
3077 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3080 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4)
3081 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3083 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3084 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3086 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++)
3087 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3090 static int velocity_resume(struct pci_dev *pdev)
3092 struct net_device *dev = pci_get_drvdata(pdev);
3093 struct velocity_info *vptr = netdev_priv(dev);
3094 unsigned long flags;
3095 int i;
3097 if (!netif_running(vptr->dev))
3098 return 0;
3100 pci_set_power_state(pdev, PCI_D0);
3101 pci_enable_wake(pdev, 0, 0);
3102 pci_restore_state(pdev);
3104 mac_wol_reset(vptr->mac_regs);
3106 spin_lock_irqsave(&vptr->lock, flags);
3107 velocity_restore_context(vptr, &vptr->context);
3108 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3109 mac_disable_int(vptr->mac_regs);
3111 velocity_tx_srv(vptr);
3113 for (i = 0; i < vptr->tx.numq; i++) {
3114 if (vptr->tx.used[i])
3115 mac_tx_queue_wake(vptr->mac_regs, i);
3118 mac_enable_int(vptr->mac_regs);
3119 spin_unlock_irqrestore(&vptr->lock, flags);
3120 netif_device_attach(vptr->dev);
3122 return 0;
3124 #endif
3127 * Definition for our device driver. The PCI layer interface
3128 * uses this to handle all our card discover and plugging
3130 static struct pci_driver velocity_driver = {
3131 .name = VELOCITY_NAME,
3132 .id_table = velocity_id_table,
3133 .probe = velocity_found1,
3134 .remove = __devexit_p(velocity_remove1),
3135 #ifdef CONFIG_PM
3136 .suspend = velocity_suspend,
3137 .resume = velocity_resume,
3138 #endif
3143 * velocity_ethtool_up - pre hook for ethtool
3144 * @dev: network device
3146 * Called before an ethtool operation. We need to make sure the
3147 * chip is out of D3 state before we poke at it.
3149 static int velocity_ethtool_up(struct net_device *dev)
3151 struct velocity_info *vptr = netdev_priv(dev);
3152 if (!netif_running(dev))
3153 pci_set_power_state(vptr->pdev, PCI_D0);
3154 return 0;
3158 * velocity_ethtool_down - post hook for ethtool
3159 * @dev: network device
3161 * Called after an ethtool operation. Restore the chip back to D3
3162 * state if it isn't running.
3164 static void velocity_ethtool_down(struct net_device *dev)
3166 struct velocity_info *vptr = netdev_priv(dev);
3167 if (!netif_running(dev))
3168 pci_set_power_state(vptr->pdev, PCI_D3hot);
3171 static int velocity_get_settings(struct net_device *dev,
3172 struct ethtool_cmd *cmd)
3174 struct velocity_info *vptr = netdev_priv(dev);
3175 struct mac_regs __iomem *regs = vptr->mac_regs;
3176 u32 status;
3177 status = check_connection_type(vptr->mac_regs);
3179 cmd->supported = SUPPORTED_TP |
3180 SUPPORTED_Autoneg |
3181 SUPPORTED_10baseT_Half |
3182 SUPPORTED_10baseT_Full |
3183 SUPPORTED_100baseT_Half |
3184 SUPPORTED_100baseT_Full |
3185 SUPPORTED_1000baseT_Half |
3186 SUPPORTED_1000baseT_Full;
3188 cmd->advertising = ADVERTISED_TP | ADVERTISED_Autoneg;
3189 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
3190 cmd->advertising |=
3191 ADVERTISED_10baseT_Half |
3192 ADVERTISED_10baseT_Full |
3193 ADVERTISED_100baseT_Half |
3194 ADVERTISED_100baseT_Full |
3195 ADVERTISED_1000baseT_Half |
3196 ADVERTISED_1000baseT_Full;
3197 } else {
3198 switch (vptr->options.spd_dpx) {
3199 case SPD_DPX_1000_FULL:
3200 cmd->advertising |= ADVERTISED_1000baseT_Full;
3201 break;
3202 case SPD_DPX_100_HALF:
3203 cmd->advertising |= ADVERTISED_100baseT_Half;
3204 break;
3205 case SPD_DPX_100_FULL:
3206 cmd->advertising |= ADVERTISED_100baseT_Full;
3207 break;
3208 case SPD_DPX_10_HALF:
3209 cmd->advertising |= ADVERTISED_10baseT_Half;
3210 break;
3211 case SPD_DPX_10_FULL:
3212 cmd->advertising |= ADVERTISED_10baseT_Full;
3213 break;
3214 default:
3215 break;
3219 if (status & VELOCITY_SPEED_1000)
3220 ethtool_cmd_speed_set(cmd, SPEED_1000);
3221 else if (status & VELOCITY_SPEED_100)
3222 ethtool_cmd_speed_set(cmd, SPEED_100);
3223 else
3224 ethtool_cmd_speed_set(cmd, SPEED_10);
3226 cmd->autoneg = (status & VELOCITY_AUTONEG_ENABLE) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3227 cmd->port = PORT_TP;
3228 cmd->transceiver = XCVR_INTERNAL;
3229 cmd->phy_address = readb(&regs->MIIADR) & 0x1F;
3231 if (status & VELOCITY_DUPLEX_FULL)
3232 cmd->duplex = DUPLEX_FULL;
3233 else
3234 cmd->duplex = DUPLEX_HALF;
3236 return 0;
3239 static int velocity_set_settings(struct net_device *dev,
3240 struct ethtool_cmd *cmd)
3242 struct velocity_info *vptr = netdev_priv(dev);
3243 u32 speed = ethtool_cmd_speed(cmd);
3244 u32 curr_status;
3245 u32 new_status = 0;
3246 int ret = 0;
3248 curr_status = check_connection_type(vptr->mac_regs);
3249 curr_status &= (~VELOCITY_LINK_FAIL);
3251 new_status |= ((cmd->autoneg) ? VELOCITY_AUTONEG_ENABLE : 0);
3252 new_status |= ((speed == SPEED_1000) ? VELOCITY_SPEED_1000 : 0);
3253 new_status |= ((speed == SPEED_100) ? VELOCITY_SPEED_100 : 0);
3254 new_status |= ((speed == SPEED_10) ? VELOCITY_SPEED_10 : 0);
3255 new_status |= ((cmd->duplex == DUPLEX_FULL) ? VELOCITY_DUPLEX_FULL : 0);
3257 if ((new_status & VELOCITY_AUTONEG_ENABLE) &&
3258 (new_status != (curr_status | VELOCITY_AUTONEG_ENABLE))) {
3259 ret = -EINVAL;
3260 } else {
3261 enum speed_opt spd_dpx;
3263 if (new_status & VELOCITY_AUTONEG_ENABLE)
3264 spd_dpx = SPD_DPX_AUTO;
3265 else if ((new_status & VELOCITY_SPEED_1000) &&
3266 (new_status & VELOCITY_DUPLEX_FULL)) {
3267 spd_dpx = SPD_DPX_1000_FULL;
3268 } else if (new_status & VELOCITY_SPEED_100)
3269 spd_dpx = (new_status & VELOCITY_DUPLEX_FULL) ?
3270 SPD_DPX_100_FULL : SPD_DPX_100_HALF;
3271 else if (new_status & VELOCITY_SPEED_10)
3272 spd_dpx = (new_status & VELOCITY_DUPLEX_FULL) ?
3273 SPD_DPX_10_FULL : SPD_DPX_10_HALF;
3274 else
3275 return -EOPNOTSUPP;
3277 vptr->options.spd_dpx = spd_dpx;
3279 velocity_set_media_mode(vptr, new_status);
3282 return ret;
3285 static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3287 struct velocity_info *vptr = netdev_priv(dev);
3288 strcpy(info->driver, VELOCITY_NAME);
3289 strcpy(info->version, VELOCITY_VERSION);
3290 strcpy(info->bus_info, pci_name(vptr->pdev));
3293 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3295 struct velocity_info *vptr = netdev_priv(dev);
3296 wol->supported = WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP;
3297 wol->wolopts |= WAKE_MAGIC;
3299 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3300 wol.wolopts|=WAKE_PHY;
3302 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
3303 wol->wolopts |= WAKE_UCAST;
3304 if (vptr->wol_opts & VELOCITY_WOL_ARP)
3305 wol->wolopts |= WAKE_ARP;
3306 memcpy(&wol->sopass, vptr->wol_passwd, 6);
3309 static int velocity_ethtool_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3311 struct velocity_info *vptr = netdev_priv(dev);
3313 if (!(wol->wolopts & (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP)))
3314 return -EFAULT;
3315 vptr->wol_opts = VELOCITY_WOL_MAGIC;
3318 if (wol.wolopts & WAKE_PHY) {
3319 vptr->wol_opts|=VELOCITY_WOL_PHY;
3320 vptr->flags |=VELOCITY_FLAGS_WOL_ENABLED;
3324 if (wol->wolopts & WAKE_MAGIC) {
3325 vptr->wol_opts |= VELOCITY_WOL_MAGIC;
3326 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3328 if (wol->wolopts & WAKE_UCAST) {
3329 vptr->wol_opts |= VELOCITY_WOL_UCAST;
3330 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3332 if (wol->wolopts & WAKE_ARP) {
3333 vptr->wol_opts |= VELOCITY_WOL_ARP;
3334 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3336 memcpy(vptr->wol_passwd, wol->sopass, 6);
3337 return 0;
3340 static u32 velocity_get_msglevel(struct net_device *dev)
3342 return msglevel;
3345 static void velocity_set_msglevel(struct net_device *dev, u32 value)
3347 msglevel = value;
3350 static int get_pending_timer_val(int val)
3352 int mult_bits = val >> 6;
3353 int mult = 1;
3355 switch (mult_bits)
3357 case 1:
3358 mult = 4; break;
3359 case 2:
3360 mult = 16; break;
3361 case 3:
3362 mult = 64; break;
3363 case 0:
3364 default:
3365 break;
3368 return (val & 0x3f) * mult;
3371 static void set_pending_timer_val(int *val, u32 us)
3373 u8 mult = 0;
3374 u8 shift = 0;
3376 if (us >= 0x3f) {
3377 mult = 1; /* mult with 4 */
3378 shift = 2;
3380 if (us >= 0x3f * 4) {
3381 mult = 2; /* mult with 16 */
3382 shift = 4;
3384 if (us >= 0x3f * 16) {
3385 mult = 3; /* mult with 64 */
3386 shift = 6;
3389 *val = (mult << 6) | ((us >> shift) & 0x3f);
3393 static int velocity_get_coalesce(struct net_device *dev,
3394 struct ethtool_coalesce *ecmd)
3396 struct velocity_info *vptr = netdev_priv(dev);
3398 ecmd->tx_max_coalesced_frames = vptr->options.tx_intsup;
3399 ecmd->rx_max_coalesced_frames = vptr->options.rx_intsup;
3401 ecmd->rx_coalesce_usecs = get_pending_timer_val(vptr->options.rxqueue_timer);
3402 ecmd->tx_coalesce_usecs = get_pending_timer_val(vptr->options.txqueue_timer);
3404 return 0;
3407 static int velocity_set_coalesce(struct net_device *dev,
3408 struct ethtool_coalesce *ecmd)
3410 struct velocity_info *vptr = netdev_priv(dev);
3411 int max_us = 0x3f * 64;
3412 unsigned long flags;
3414 /* 6 bits of */
3415 if (ecmd->tx_coalesce_usecs > max_us)
3416 return -EINVAL;
3417 if (ecmd->rx_coalesce_usecs > max_us)
3418 return -EINVAL;
3420 if (ecmd->tx_max_coalesced_frames > 0xff)
3421 return -EINVAL;
3422 if (ecmd->rx_max_coalesced_frames > 0xff)
3423 return -EINVAL;
3425 vptr->options.rx_intsup = ecmd->rx_max_coalesced_frames;
3426 vptr->options.tx_intsup = ecmd->tx_max_coalesced_frames;
3428 set_pending_timer_val(&vptr->options.rxqueue_timer,
3429 ecmd->rx_coalesce_usecs);
3430 set_pending_timer_val(&vptr->options.txqueue_timer,
3431 ecmd->tx_coalesce_usecs);
3433 /* Setup the interrupt suppression and queue timers */
3434 spin_lock_irqsave(&vptr->lock, flags);
3435 mac_disable_int(vptr->mac_regs);
3436 setup_adaptive_interrupts(vptr);
3437 setup_queue_timers(vptr);
3439 mac_write_int_mask(vptr->int_mask, vptr->mac_regs);
3440 mac_clear_isr(vptr->mac_regs);
3441 mac_enable_int(vptr->mac_regs);
3442 spin_unlock_irqrestore(&vptr->lock, flags);
3444 return 0;
3447 static const struct ethtool_ops velocity_ethtool_ops = {
3448 .get_settings = velocity_get_settings,
3449 .set_settings = velocity_set_settings,
3450 .get_drvinfo = velocity_get_drvinfo,
3451 .get_wol = velocity_ethtool_get_wol,
3452 .set_wol = velocity_ethtool_set_wol,
3453 .get_msglevel = velocity_get_msglevel,
3454 .set_msglevel = velocity_set_msglevel,
3455 .get_link = velocity_get_link,
3456 .get_coalesce = velocity_get_coalesce,
3457 .set_coalesce = velocity_set_coalesce,
3458 .begin = velocity_ethtool_up,
3459 .complete = velocity_ethtool_down
3462 #ifdef CONFIG_PM
3463 #ifdef CONFIG_INET
3464 static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3466 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3467 struct net_device *dev = ifa->ifa_dev->dev;
3469 if (dev_net(dev) == &init_net &&
3470 dev->netdev_ops == &velocity_netdev_ops)
3471 velocity_get_ip(netdev_priv(dev));
3473 return NOTIFY_DONE;
3475 #endif /* CONFIG_INET */
3476 #endif /* CONFIG_PM */
3478 #if defined(CONFIG_PM) && defined(CONFIG_INET)
3479 static struct notifier_block velocity_inetaddr_notifier = {
3480 .notifier_call = velocity_netdev_event,
3483 static void velocity_register_notifier(void)
3485 register_inetaddr_notifier(&velocity_inetaddr_notifier);
3488 static void velocity_unregister_notifier(void)
3490 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
3493 #else
3495 #define velocity_register_notifier() do {} while (0)
3496 #define velocity_unregister_notifier() do {} while (0)
3498 #endif /* defined(CONFIG_PM) && defined(CONFIG_INET) */
3501 * velocity_init_module - load time function
3503 * Called when the velocity module is loaded. The PCI driver
3504 * is registered with the PCI layer, and in turn will call
3505 * the probe functions for each velocity adapter installed
3506 * in the system.
3508 static int __init velocity_init_module(void)
3510 int ret;
3512 velocity_register_notifier();
3513 ret = pci_register_driver(&velocity_driver);
3514 if (ret < 0)
3515 velocity_unregister_notifier();
3516 return ret;
3520 * velocity_cleanup - module unload
3522 * When the velocity hardware is unloaded this function is called.
3523 * It will clean up the notifiers and the unregister the PCI
3524 * driver interface for this hardware. This in turn cleans up
3525 * all discovered interfaces before returning from the function
3527 static void __exit velocity_cleanup_module(void)
3529 velocity_unregister_notifier();
3530 pci_unregister_driver(&velocity_driver);
3533 module_init(velocity_init_module);
3534 module_exit(velocity_cleanup_module);