blob: cab96ad49e601488100d744ecacc6a76539f9b34 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * This code is derived from the VIA reference driver (copyright message
3 * below) provided to Red Hat by VIA Networking Technologies, Inc. for
4 * addition to the Linux kernel.
5 *
6 * The code has been merged into one source file, cleaned up to follow
7 * Linux coding style, ported to the Linux 2.6 kernel tree and cleaned
8 * for 64bit hardware platforms.
9 *
10 * TODO
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * rx_copybreak/alignment
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * More testing
13 *
Alan Cox113aa832008-10-13 19:01:08 -070014 * The changes are (c) Copyright 2004, Red Hat Inc. <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * Additional fixes and clean up: Francois Romieu
16 *
17 * This source has not been verified for use in safety critical systems.
18 *
19 * Please direct queries about the revamped driver to the linux-kernel
20 * list not VIA.
21 *
22 * Original code:
23 *
24 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
25 * All rights reserved.
26 *
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.
31 *
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.
36 *
37 * Author: Chuang Liang-Shing, AJ Jiang
38 *
39 * Date: Jan 24, 2003
40 *
41 * MODULE_LICENSE("GPL");
42 *
43 */
44
45
46#include <linux/module.h>
47#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/init.h>
49#include <linux/mm.h>
50#include <linux/errno.h>
51#include <linux/ioport.h>
52#include <linux/pci.h>
53#include <linux/kernel.h>
54#include <linux/netdevice.h>
55#include <linux/etherdevice.h>
56#include <linux/skbuff.h>
57#include <linux/delay.h>
58#include <linux/timer.h>
59#include <linux/slab.h>
60#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <linux/string.h>
62#include <linux/wait.h>
Dave Jonesc4067402009-07-20 17:35:21 +000063#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/if.h>
Dave Jonesc4067402009-07-20 17:35:21 +000065#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <linux/proc_fs.h>
67#include <linux/inetdevice.h>
68#include <linux/reboot.h>
69#include <linux/ethtool.h>
70#include <linux/mii.h>
71#include <linux/in.h>
72#include <linux/if_arp.h>
Stephen Hemminger501e4d22007-08-24 13:56:49 -070073#include <linux/if_vlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <linux/ip.h>
75#include <linux/tcp.h>
76#include <linux/udp.h>
77#include <linux/crc-ccitt.h>
78#include <linux/crc32.h>
79
80#include "via-velocity.h"
81
82
Dave Jonesc4067402009-07-20 17:35:21 +000083static int velocity_nics;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static int msglevel = MSG_LEVEL_INFO;
85
Stephen Hemminger01faccb2007-08-24 14:40:45 -070086/**
87 * mac_get_cam_mask - Read a CAM mask
88 * @regs: register block for this velocity
89 * @mask: buffer to store mask
90 *
91 * Fetch the mask bits of the selected CAM and store them into the
92 * provided mask buffer.
93 */
Dave Jonesc4067402009-07-20 17:35:21 +000094static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
Stephen Hemminger01faccb2007-08-24 14:40:45 -070095{
96 int i;
97
98 /* Select CAM mask */
99 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
100
101 writeb(0, &regs->CAMADDR);
102
103 /* read mask */
104 for (i = 0; i < 8; i++)
105 *mask++ = readb(&(regs->MARCAM[i]));
106
107 /* disable CAMEN */
108 writeb(0, &regs->CAMADDR);
109
110 /* Select mar */
111 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700112}
113
114
115/**
116 * mac_set_cam_mask - Set a CAM mask
117 * @regs: register block for this velocity
118 * @mask: CAM mask to load
119 *
120 * Store a new mask into a CAM
121 */
Dave Jonesc4067402009-07-20 17:35:21 +0000122static void mac_set_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700123{
124 int i;
125 /* Select CAM mask */
126 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
127
128 writeb(CAMADDR_CAMEN, &regs->CAMADDR);
129
Dave Jonesc4067402009-07-20 17:35:21 +0000130 for (i = 0; i < 8; i++)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700131 writeb(*mask++, &(regs->MARCAM[i]));
Dave Jonesc4067402009-07-20 17:35:21 +0000132
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700133 /* disable CAMEN */
134 writeb(0, &regs->CAMADDR);
135
136 /* Select mar */
137 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
138}
139
Dave Jonesc4067402009-07-20 17:35:21 +0000140static void mac_set_vlan_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700141{
142 int i;
143 /* Select CAM mask */
144 BYTE_REG_BITS_SET(CAMCR_PS_CAM_MASK, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
145
146 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL, &regs->CAMADDR);
147
Dave Jonesc4067402009-07-20 17:35:21 +0000148 for (i = 0; i < 8; i++)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700149 writeb(*mask++, &(regs->MARCAM[i]));
Dave Jonesc4067402009-07-20 17:35:21 +0000150
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700151 /* disable CAMEN */
152 writeb(0, &regs->CAMADDR);
153
154 /* Select mar */
155 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
156}
157
158/**
159 * mac_set_cam - set CAM data
160 * @regs: register block of this velocity
161 * @idx: Cam index
162 * @addr: 2 or 6 bytes of CAM data
163 *
164 * Load an address or vlan tag into a CAM
165 */
Dave Jonesc4067402009-07-20 17:35:21 +0000166static void mac_set_cam(struct mac_regs __iomem *regs, int idx, const u8 *addr)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700167{
168 int i;
169
170 /* Select CAM mask */
171 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
172
173 idx &= (64 - 1);
174
175 writeb(CAMADDR_CAMEN | idx, &regs->CAMADDR);
176
Dave Jonesc4067402009-07-20 17:35:21 +0000177 for (i = 0; i < 6; i++)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700178 writeb(*addr++, &(regs->MARCAM[i]));
Dave Jonesc4067402009-07-20 17:35:21 +0000179
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700180 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
181
182 udelay(10);
183
184 writeb(0, &regs->CAMADDR);
185
186 /* Select mar */
187 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
188}
189
Dave Jonesc4067402009-07-20 17:35:21 +0000190static void mac_set_vlan_cam(struct mac_regs __iomem *regs, int idx,
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700191 const u8 *addr)
192{
193
194 /* Select CAM mask */
195 BYTE_REG_BITS_SET(CAMCR_PS_CAM_DATA, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
196
197 idx &= (64 - 1);
198
199 writeb(CAMADDR_CAMEN | CAMADDR_VCAMSL | idx, &regs->CAMADDR);
200 writew(*((u16 *) addr), &regs->MARCAM[0]);
201
202 BYTE_REG_BITS_ON(CAMCR_CAMWR, &regs->CAMCR);
203
204 udelay(10);
205
206 writeb(0, &regs->CAMADDR);
207
208 /* Select mar */
209 BYTE_REG_BITS_SET(CAMCR_PS_MAR, CAMCR_PS1 | CAMCR_PS0, &regs->CAMCR);
210}
211
212
213/**
214 * mac_wol_reset - reset WOL after exiting low power
215 * @regs: register block of this velocity
216 *
217 * Called after we drop out of wake on lan mode in order to
218 * reset the Wake on lan features. This function doesn't restore
219 * the rest of the logic from the result of sleep/wakeup
220 */
Dave Jonesc4067402009-07-20 17:35:21 +0000221static void mac_wol_reset(struct mac_regs __iomem *regs)
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700222{
223
224 /* Turn off SWPTAG right after leaving power mode */
225 BYTE_REG_BITS_OFF(STICKHW_SWPTAG, &regs->STICKHW);
226 /* clear sticky bits */
227 BYTE_REG_BITS_OFF((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
228
229 BYTE_REG_BITS_OFF(CHIPGCR_FCGMII, &regs->CHIPGCR);
230 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
231 /* disable force PME-enable */
232 writeb(WOLCFG_PMEOVR, &regs->WOLCFGClr);
233 /* disable power-event config bit */
234 writew(0xFFFF, &regs->WOLCRClr);
235 /* clear power status */
236 writew(0xFFFF, &regs->WOLSRClr);
237}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Jeff Garzik7282d492006-09-13 14:30:00 -0400239static const struct ethtool_ops velocity_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241/*
242 Define module options
243*/
244
245MODULE_AUTHOR("VIA Networking Technologies, Inc.");
246MODULE_LICENSE("GPL");
247MODULE_DESCRIPTION("VIA Networking Velocity Family Gigabit Ethernet Adapter Driver");
248
Dave Jonesc4067402009-07-20 17:35:21 +0000249#define VELOCITY_PARAM(N, D) \
250 static int N[MAX_UNITS] = OPTION_DEFAULT;\
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 module_param_array(N, int, NULL, 0); \
Dave Jonesc4067402009-07-20 17:35:21 +0000252 MODULE_PARM_DESC(N, D);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254#define RX_DESC_MIN 64
255#define RX_DESC_MAX 255
256#define RX_DESC_DEF 64
257VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
258
259#define TX_DESC_MIN 16
260#define TX_DESC_MAX 256
261#define TX_DESC_DEF 64
262VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264#define RX_THRESH_MIN 0
265#define RX_THRESH_MAX 3
266#define RX_THRESH_DEF 0
267/* rx_thresh[] is used for controlling the receive fifo threshold.
268 0: indicate the rxfifo threshold is 128 bytes.
269 1: indicate the rxfifo threshold is 512 bytes.
270 2: indicate the rxfifo threshold is 1024 bytes.
271 3: indicate the rxfifo threshold is store & forward.
272*/
273VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
274
275#define DMA_LENGTH_MIN 0
276#define DMA_LENGTH_MAX 7
Simon Kagstrom2a5774f2009-11-25 22:10:34 +0000277#define DMA_LENGTH_DEF 6
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279/* DMA_length[] is used for controlling the DMA length
280 0: 8 DWORDs
281 1: 16 DWORDs
282 2: 32 DWORDs
283 3: 64 DWORDs
284 4: 128 DWORDs
285 5: 256 DWORDs
286 6: SF(flush till emply)
287 7: SF(flush till emply)
288*/
289VELOCITY_PARAM(DMA_length, "DMA length");
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291#define IP_ALIG_DEF 0
292/* IP_byte_align[] is used for IP header DWORD byte aligned
293 0: indicate the IP header won't be DWORD byte aligned.(Default) .
294 1: indicate the IP header will be DWORD byte aligned.
295 In some enviroment, the IP header should be DWORD byte aligned,
296 or the packet will be droped when we receive it. (eg: IPVS)
297*/
298VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300#define FLOW_CNTL_DEF 1
301#define FLOW_CNTL_MIN 1
302#define FLOW_CNTL_MAX 5
303
304/* flow_control[] is used for setting the flow control ability of NIC.
305 1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
306 2: enable TX flow control.
307 3: enable RX flow control.
308 4: enable RX/TX flow control.
309 5: disable
310*/
311VELOCITY_PARAM(flow_control, "Enable flow control ability");
312
313#define MED_LNK_DEF 0
314#define MED_LNK_MIN 0
françois romieu15419222010-10-13 09:26:05 +0000315#define MED_LNK_MAX 5
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316/* speed_duplex[] is used for setting the speed and duplex mode of NIC.
317 0: indicate autonegotiation for both speed and duplex mode
318 1: indicate 100Mbps half duplex mode
319 2: indicate 100Mbps full duplex mode
320 3: indicate 10Mbps half duplex mode
321 4: indicate 10Mbps full duplex mode
françois romieu15419222010-10-13 09:26:05 +0000322 5: indicate 1000Mbps full duplex mode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 Note:
Dave Jonesc4067402009-07-20 17:35:21 +0000325 if EEPROM have been set to the force mode, this option is ignored
326 by driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327*/
328VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
329
330#define VAL_PKT_LEN_DEF 0
331/* ValPktLen[] is used for setting the checksum offload ability of NIC.
332 0: Receive frame with invalid layer 2 length (Default)
333 1: Drop frame with invalid layer 2 length
334*/
335VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
336
337#define WOL_OPT_DEF 0
338#define WOL_OPT_MIN 0
339#define WOL_OPT_MAX 7
340/* wol_opts[] is used for controlling wake on lan behavior.
341 0: Wake up if recevied a magic packet. (Default)
342 1: Wake up if link status is on/off.
343 2: Wake up if recevied an arp packet.
344 4: Wake up if recevied any unicast packet.
345 Those value can be sumed up to support more than one option.
346*/
347VELOCITY_PARAM(wol_opts, "Wake On Lan options");
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349static int rx_copybreak = 200;
350module_param(rx_copybreak, int, 0644);
351MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353/*
354 * Internal board variants. At the moment we have only one
355 */
Andrew Morton4f14b922008-02-09 23:41:40 -0800356static struct velocity_info_tbl chip_info_table[] = {
Jeff Garzikcabb7662006-06-27 09:25:28 -0400357 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
358 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359};
360
361/*
362 * Describe the PCI device identifiers that we support in this
363 * device driver. Used for hotplug autoloading.
364 */
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000365static DEFINE_PCI_DEVICE_TABLE(velocity_id_table) = {
Jeff Garzike54f4892006-06-27 09:20:08 -0400366 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
367 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368};
369
370MODULE_DEVICE_TABLE(pci, velocity_id_table);
371
372/**
373 * get_chip_name - identifier to name
374 * @id: chip identifier
375 *
376 * Given a chip identifier return a suitable description. Returns
377 * a pointer a static string valid while the driver is loaded.
378 */
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700379static const char __devinit *get_chip_name(enum chip_type chip_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
381 int i;
382 for (i = 0; chip_info_table[i].name != NULL; i++)
383 if (chip_info_table[i].chip_id == chip_id)
384 break;
385 return chip_info_table[i].name;
386}
387
388/**
389 * velocity_remove1 - device unplug
390 * @pdev: PCI device being removed
391 *
392 * Device unload callback. Called on an unplug or on module
393 * unload for each active device that is present. Disconnects
394 * the device from the network layer and frees all the resources
395 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396static void __devexit velocity_remove1(struct pci_dev *pdev)
397{
398 struct net_device *dev = pci_get_drvdata(pdev);
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -0400399 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 unregister_netdev(dev);
402 iounmap(vptr->mac_regs);
403 pci_release_regions(pdev);
404 pci_disable_device(pdev);
405 pci_set_drvdata(pdev, NULL);
406 free_netdev(dev);
407
408 velocity_nics--;
409}
410
411/**
412 * velocity_set_int_opt - parser for integer options
413 * @opt: pointer to option value
414 * @val: value the user requested (or -1 for default)
415 * @min: lowest value allowed
416 * @max: highest value allowed
417 * @def: default value
418 * @name: property name
419 * @dev: device name
420 *
421 * Set an integer property in the module options. This function does
422 * all the verification and checking as well as reporting so that
423 * we don't duplicate code for each option.
424 */
Sven Hartge07b5f6a2008-10-23 13:03:44 +0000425static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 if (val == -1)
428 *opt = def;
429 else if (val < min || val > max) {
430 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
431 devname, name, min, max);
432 *opt = def;
433 } else {
434 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
435 devname, name, val);
436 *opt = val;
437 }
438}
439
440/**
441 * velocity_set_bool_opt - parser for boolean options
442 * @opt: pointer to option value
443 * @val: value the user requested (or -1 for default)
444 * @def: default value (yes/no)
445 * @flag: numeric value to set for true.
446 * @name: property name
447 * @dev: device name
448 *
449 * Set a boolean property in the module options. This function does
450 * all the verification and checking as well as reporting so that
451 * we don't duplicate code for each option.
452 */
Dave Jonesc4067402009-07-20 17:35:21 +0000453static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag, char *name, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
455 (*opt) &= (~flag);
456 if (val == -1)
457 *opt |= (def ? flag : 0);
458 else if (val < 0 || val > 1) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400459 printk(KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 devname, name);
461 *opt |= (def ? flag : 0);
462 } else {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400463 printk(KERN_INFO "%s: set parameter %s to %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 devname, name, val ? "TRUE" : "FALSE");
465 *opt |= (val ? flag : 0);
466 }
467}
468
469/**
470 * velocity_get_options - set options on device
471 * @opts: option structure for the device
472 * @index: index of option to use in module options array
473 * @devname: device name
474 *
475 * Turn the module and command options into a single structure
476 * for the current device
477 */
Sven Hartge07b5f6a2008-10-23 13:03:44 +0000478static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480
481 velocity_set_int_opt(&opts->rx_thresh, rx_thresh[index], RX_THRESH_MIN, RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh", devname);
482 velocity_set_int_opt(&opts->DMA_length, DMA_length[index], DMA_LENGTH_MIN, DMA_LENGTH_MAX, DMA_LENGTH_DEF, "DMA_length", devname);
483 velocity_set_int_opt(&opts->numrx, RxDescriptors[index], RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF, "RxDescriptors", devname);
484 velocity_set_int_opt(&opts->numtx, TxDescriptors[index], TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF, "TxDescriptors", devname);
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 velocity_set_int_opt(&opts->flow_cntl, flow_control[index], FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF, "flow_control", devname);
487 velocity_set_bool_opt(&opts->flags, IP_byte_align[index], IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN, "IP_byte_align", devname);
488 velocity_set_bool_opt(&opts->flags, ValPktLen[index], VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN, "ValPktLen", devname);
489 velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index], MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF, "Media link mode", devname);
490 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 opts->numrx = (opts->numrx & ~3);
492}
493
494/**
495 * velocity_init_cam_filter - initialise CAM
496 * @vptr: velocity to program
497 *
498 * Initialize the content addressable memory used for filters. Load
499 * appropriately according to the presence of VLAN
500 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501static void velocity_init_cam_filter(struct velocity_info *vptr)
502{
Dave Jonesc4067402009-07-20 17:35:21 +0000503 struct mac_regs __iomem *regs = vptr->mac_regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
506 WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
507 WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
508
509 /* Disable all CAMs */
510 memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
511 memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700512 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
513 mac_set_cam_mask(regs, vptr->mCAMmask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Francois Romieud4f73c82008-04-24 23:32:33 +0200515 /* Enable VCAMs */
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700516 if (vptr->vlgrp) {
Francois Romieud4f73c82008-04-24 23:32:33 +0200517 unsigned int vid, i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Francois Romieud4f73c82008-04-24 23:32:33 +0200519 if (!vlan_group_get_device(vptr->vlgrp, 0))
520 WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
521
522 for (vid = 1; (vid < VLAN_VID_MASK); vid++) {
523 if (vlan_group_get_device(vptr->vlgrp, vid)) {
524 mac_set_vlan_cam(regs, i, (u8 *) &vid);
525 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
526 if (++i >= VCAM_SIZE)
527 break;
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700528 }
529 }
Stephen Hemminger01faccb2007-08-24 14:40:45 -0700530 mac_set_vlan_cam_mask(regs, vptr->vCAMmask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532}
533
Francois Romieud4f73c82008-04-24 23:32:33 +0200534static void velocity_vlan_rx_register(struct net_device *dev,
535 struct vlan_group *grp)
536{
537 struct velocity_info *vptr = netdev_priv(dev);
538
539 vptr->vlgrp = grp;
540}
541
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700542static void velocity_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
543{
544 struct velocity_info *vptr = netdev_priv(dev);
545
Dave Jonesc4067402009-07-20 17:35:21 +0000546 spin_lock_irq(&vptr->lock);
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700547 velocity_init_cam_filter(vptr);
Dave Jonesc4067402009-07-20 17:35:21 +0000548 spin_unlock_irq(&vptr->lock);
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700549}
550
551static void velocity_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
552{
553 struct velocity_info *vptr = netdev_priv(dev);
554
Dave Jonesc4067402009-07-20 17:35:21 +0000555 spin_lock_irq(&vptr->lock);
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700556 vlan_group_set_device(vptr->vlgrp, vid, NULL);
557 velocity_init_cam_filter(vptr);
Dave Jonesc4067402009-07-20 17:35:21 +0000558 spin_unlock_irq(&vptr->lock);
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700559}
560
Francois Romieu3c4dc712008-07-31 22:51:18 +0200561static void velocity_init_rx_ring_indexes(struct velocity_info *vptr)
562{
563 vptr->rx.dirty = vptr->rx.filled = vptr->rx.curr = 0;
564}
Stephen Hemminger501e4d22007-08-24 13:56:49 -0700565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566/**
567 * velocity_rx_reset - handle a receive reset
568 * @vptr: velocity we are resetting
569 *
570 * Reset the ownership and status for the receive ring side.
571 * Hand all the receive queue to the NIC.
572 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573static void velocity_rx_reset(struct velocity_info *vptr)
574{
575
Dave Jonesc4067402009-07-20 17:35:21 +0000576 struct mac_regs __iomem *regs = vptr->mac_regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 int i;
578
Francois Romieu3c4dc712008-07-31 22:51:18 +0200579 velocity_init_rx_ring_indexes(vptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 /*
582 * Init state, all RD entries belong to the NIC
583 */
584 for (i = 0; i < vptr->options.numrx; ++i)
Francois Romieu0fe9f152008-07-31 22:10:10 +0200585 vptr->rx.ring[i].rdesc0.len |= OWNED_BY_NIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587 writew(vptr->options.numrx, &regs->RBRDU);
Francois Romieu0fe9f152008-07-31 22:10:10 +0200588 writel(vptr->rx.pool_dma, &regs->RDBaseLo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 writew(0, &regs->RDIdx);
590 writew(vptr->options.numrx - 1, &regs->RDCSize);
591}
592
593/**
Dave Jones2cf71d22009-07-23 18:11:12 -0700594 * velocity_get_opt_media_mode - get media selection
595 * @vptr: velocity adapter
596 *
597 * Get the media mode stored in EEPROM or module options and load
598 * mii_status accordingly. The requested link state information
599 * is also returned.
600 */
601static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
602{
603 u32 status = 0;
604
605 switch (vptr->options.spd_dpx) {
606 case SPD_DPX_AUTO:
607 status = VELOCITY_AUTONEG_ENABLE;
608 break;
609 case SPD_DPX_100_FULL:
610 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
611 break;
612 case SPD_DPX_10_FULL:
613 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
614 break;
615 case SPD_DPX_100_HALF:
616 status = VELOCITY_SPEED_100;
617 break;
618 case SPD_DPX_10_HALF:
619 status = VELOCITY_SPEED_10;
620 break;
françois romieu15419222010-10-13 09:26:05 +0000621 case SPD_DPX_1000_FULL:
622 status = VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
623 break;
Dave Jones2cf71d22009-07-23 18:11:12 -0700624 }
625 vptr->mii_status = status;
626 return status;
627}
628
629/**
630 * safe_disable_mii_autopoll - autopoll off
631 * @regs: velocity registers
632 *
633 * Turn off the autopoll and wait for it to disable on the chip
634 */
635static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs)
636{
637 u16 ww;
638
639 /* turn off MAUTO */
640 writeb(0, &regs->MIICR);
641 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
642 udelay(1);
643 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
644 break;
645 }
646}
647
648/**
649 * enable_mii_autopoll - turn on autopolling
650 * @regs: velocity registers
651 *
652 * Enable the MII link status autopoll feature on the Velocity
653 * hardware. Wait for it to enable.
654 */
655static void enable_mii_autopoll(struct mac_regs __iomem *regs)
656{
657 int ii;
658
659 writeb(0, &(regs->MIICR));
660 writeb(MIIADR_SWMPL, &regs->MIIADR);
661
662 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
663 udelay(1);
664 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
665 break;
666 }
667
668 writeb(MIICR_MAUTO, &regs->MIICR);
669
670 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
671 udelay(1);
672 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
673 break;
674 }
675
676}
677
678/**
679 * velocity_mii_read - read MII data
680 * @regs: velocity registers
681 * @index: MII register index
682 * @data: buffer for received data
683 *
684 * Perform a single read of an MII 16bit register. Returns zero
685 * on success or -ETIMEDOUT if the PHY did not respond.
686 */
687static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
688{
689 u16 ww;
690
691 /*
692 * Disable MIICR_MAUTO, so that mii addr can be set normally
693 */
694 safe_disable_mii_autopoll(regs);
695
696 writeb(index, &regs->MIIADR);
697
698 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
699
700 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
701 if (!(readb(&regs->MIICR) & MIICR_RCMD))
702 break;
703 }
704
705 *data = readw(&regs->MIIDATA);
706
707 enable_mii_autopoll(regs);
708 if (ww == W_MAX_TIMEOUT)
709 return -ETIMEDOUT;
710 return 0;
711}
712
713
714/**
715 * mii_check_media_mode - check media state
716 * @regs: velocity registers
717 *
718 * Check the current MII status and determine the link status
719 * accordingly
720 */
721static u32 mii_check_media_mode(struct mac_regs __iomem *regs)
722{
723 u32 status = 0;
724 u16 ANAR;
725
Francois Romieu3a7f8682010-04-06 14:24:53 -0700726 if (!MII_REG_BITS_IS_ON(BMSR_LSTATUS, MII_BMSR, regs))
Dave Jones2cf71d22009-07-23 18:11:12 -0700727 status |= VELOCITY_LINK_FAIL;
728
Francois Romieu3a7f8682010-04-06 14:24:53 -0700729 if (MII_REG_BITS_IS_ON(ADVERTISE_1000FULL, MII_CTRL1000, regs))
Dave Jones2cf71d22009-07-23 18:11:12 -0700730 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
Francois Romieu3a7f8682010-04-06 14:24:53 -0700731 else if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF, MII_CTRL1000, regs))
Dave Jones2cf71d22009-07-23 18:11:12 -0700732 status |= (VELOCITY_SPEED_1000);
733 else {
Francois Romieu3a7f8682010-04-06 14:24:53 -0700734 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
735 if (ANAR & ADVERTISE_100FULL)
Dave Jones2cf71d22009-07-23 18:11:12 -0700736 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
Francois Romieu3a7f8682010-04-06 14:24:53 -0700737 else if (ANAR & ADVERTISE_100HALF)
Dave Jones2cf71d22009-07-23 18:11:12 -0700738 status |= VELOCITY_SPEED_100;
Francois Romieu3a7f8682010-04-06 14:24:53 -0700739 else if (ANAR & ADVERTISE_10FULL)
Dave Jones2cf71d22009-07-23 18:11:12 -0700740 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
741 else
742 status |= (VELOCITY_SPEED_10);
743 }
744
Francois Romieu3a7f8682010-04-06 14:24:53 -0700745 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, regs)) {
746 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
747 if ((ANAR & (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF))
748 == (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF)) {
749 if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF | ADVERTISE_1000FULL, MII_CTRL1000, regs))
Dave Jones2cf71d22009-07-23 18:11:12 -0700750 status |= VELOCITY_AUTONEG_ENABLE;
751 }
752 }
753
754 return status;
755}
756
757/**
758 * velocity_mii_write - write MII data
759 * @regs: velocity registers
760 * @index: MII register index
761 * @data: 16bit data for the MII register
762 *
763 * Perform a single write to an MII 16bit register. Returns zero
764 * on success or -ETIMEDOUT if the PHY did not respond.
765 */
766static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
767{
768 u16 ww;
769
770 /*
771 * Disable MIICR_MAUTO, so that mii addr can be set normally
772 */
773 safe_disable_mii_autopoll(regs);
774
775 /* MII reg offset */
776 writeb(mii_addr, &regs->MIIADR);
777 /* set MII data */
778 writew(data, &regs->MIIDATA);
779
780 /* turn on MIICR_WCMD */
781 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
782
783 /* W_MAX_TIMEOUT is the timeout period */
784 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
785 udelay(5);
786 if (!(readb(&regs->MIICR) & MIICR_WCMD))
787 break;
788 }
789 enable_mii_autopoll(regs);
790
791 if (ww == W_MAX_TIMEOUT)
792 return -ETIMEDOUT;
793 return 0;
794}
795
796/**
797 * set_mii_flow_control - flow control setup
798 * @vptr: velocity interface
799 *
800 * Set up the flow control on this interface according to
801 * the supplied user/eeprom options.
802 */
803static void set_mii_flow_control(struct velocity_info *vptr)
804{
805 /*Enable or Disable PAUSE in ANAR */
806 switch (vptr->options.flow_cntl) {
807 case FLOW_CNTL_TX:
Francois Romieu3a7f8682010-04-06 14:24:53 -0700808 MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
809 MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700810 break;
811
812 case FLOW_CNTL_RX:
Francois Romieu3a7f8682010-04-06 14:24:53 -0700813 MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
814 MII_REG_BITS_ON(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700815 break;
816
817 case FLOW_CNTL_TX_RX:
Francois Romieu3a7f8682010-04-06 14:24:53 -0700818 MII_REG_BITS_ON(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
David S. Miller4a35ecf2010-04-06 23:53:30 -0700819 MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700820 break;
821
822 case FLOW_CNTL_DISABLE:
Francois Romieu3a7f8682010-04-06 14:24:53 -0700823 MII_REG_BITS_OFF(ADVERTISE_PAUSE_CAP, MII_ADVERTISE, vptr->mac_regs);
824 MII_REG_BITS_OFF(ADVERTISE_PAUSE_ASYM, MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700825 break;
826 default:
827 break;
828 }
829}
830
831/**
832 * mii_set_auto_on - autonegotiate on
833 * @vptr: velocity
834 *
835 * Enable autonegotation on this interface
836 */
837static void mii_set_auto_on(struct velocity_info *vptr)
838{
Francois Romieu3a7f8682010-04-06 14:24:53 -0700839 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs))
840 MII_REG_BITS_ON(BMCR_ANRESTART, MII_BMCR, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700841 else
Francois Romieu3a7f8682010-04-06 14:24:53 -0700842 MII_REG_BITS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700843}
844
845static u32 check_connection_type(struct mac_regs __iomem *regs)
846{
847 u32 status = 0;
848 u8 PHYSR0;
849 u16 ANAR;
850 PHYSR0 = readb(&regs->PHYSR0);
851
852 /*
853 if (!(PHYSR0 & PHYSR0_LINKGD))
854 status|=VELOCITY_LINK_FAIL;
855 */
856
857 if (PHYSR0 & PHYSR0_FDPX)
858 status |= VELOCITY_DUPLEX_FULL;
859
860 if (PHYSR0 & PHYSR0_SPDG)
861 status |= VELOCITY_SPEED_1000;
862 else if (PHYSR0 & PHYSR0_SPD10)
863 status |= VELOCITY_SPEED_10;
864 else
865 status |= VELOCITY_SPEED_100;
866
Francois Romieu3a7f8682010-04-06 14:24:53 -0700867 if (MII_REG_BITS_IS_ON(BMCR_ANENABLE, MII_BMCR, regs)) {
868 velocity_mii_read(regs, MII_ADVERTISE, &ANAR);
869 if ((ANAR & (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF))
870 == (ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF)) {
871 if (MII_REG_BITS_IS_ON(ADVERTISE_1000HALF | ADVERTISE_1000FULL, MII_CTRL1000, regs))
Dave Jones2cf71d22009-07-23 18:11:12 -0700872 status |= VELOCITY_AUTONEG_ENABLE;
873 }
874 }
875
876 return status;
877}
878
879
880
881/**
882 * velocity_set_media_mode - set media mode
883 * @mii_status: old MII link state
884 *
885 * Check the media link state and configure the flow control
886 * PHY and also velocity hardware setup accordingly. In particular
887 * we need to set up CD polling and frame bursting.
888 */
889static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
890{
891 u32 curr_status;
892 struct mac_regs __iomem *regs = vptr->mac_regs;
893
894 vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
895 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
896
897 /* Set mii link status */
898 set_mii_flow_control(vptr);
899
900 /*
901 Check if new status is consisent with current status
Joe Perches8e95a202009-12-03 07:58:21 +0000902 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE) ||
903 (mii_status==curr_status)) {
Dave Jones2cf71d22009-07-23 18:11:12 -0700904 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
905 vptr->mii_status=check_connection_type(vptr->mac_regs);
906 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
907 return 0;
908 }
909 */
910
911 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
Francois Romieu3a7f8682010-04-06 14:24:53 -0700912 MII_REG_BITS_ON(AUXCR_MDPPS, MII_NCONFIG, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700913
914 /*
915 * If connection type is AUTO
916 */
917 if (mii_status & VELOCITY_AUTONEG_ENABLE) {
918 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
919 /* clear force MAC mode bit */
920 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
921 /* set duplex mode of MAC according to duplex mode of MII */
Francois Romieu3a7f8682010-04-06 14:24:53 -0700922 MII_REG_BITS_ON(ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF, MII_ADVERTISE, vptr->mac_regs);
923 MII_REG_BITS_ON(ADVERTISE_1000FULL | ADVERTISE_1000HALF, MII_CTRL1000, vptr->mac_regs);
924 MII_REG_BITS_ON(BMCR_SPEED1000, MII_BMCR, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -0700925
926 /* enable AUTO-NEGO mode */
927 mii_set_auto_on(vptr);
928 } else {
françois romieu15419222010-10-13 09:26:05 +0000929 u16 CTRL1000;
Dave Jones2cf71d22009-07-23 18:11:12 -0700930 u16 ANAR;
931 u8 CHIPGCR;
932
933 /*
934 * 1. if it's 3119, disable frame bursting in halfduplex mode
935 * and enable it in fullduplex mode
936 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
937 * 3. only enable CD heart beat counter in 10HD mode
938 */
939
940 /* set force MAC mode bit */
941 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
942
943 CHIPGCR = readb(&regs->CHIPGCR);
françois romieu15419222010-10-13 09:26:05 +0000944
945 if (mii_status & VELOCITY_SPEED_1000)
946 CHIPGCR |= CHIPGCR_FCGMII;
947 else
948 CHIPGCR &= ~CHIPGCR_FCGMII;
Dave Jones2cf71d22009-07-23 18:11:12 -0700949
950 if (mii_status & VELOCITY_DUPLEX_FULL) {
951 CHIPGCR |= CHIPGCR_FCFDX;
952 writeb(CHIPGCR, &regs->CHIPGCR);
953 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
954 if (vptr->rev_id < REV_ID_VT3216_A0)
955 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
956 } else {
957 CHIPGCR &= ~CHIPGCR_FCFDX;
958 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
959 writeb(CHIPGCR, &regs->CHIPGCR);
960 if (vptr->rev_id < REV_ID_VT3216_A0)
961 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
962 }
963
françois romieu15419222010-10-13 09:26:05 +0000964 velocity_mii_read(vptr->mac_regs, MII_CTRL1000, &CTRL1000);
965 CTRL1000 &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
966 if ((mii_status & VELOCITY_SPEED_1000) &&
967 (mii_status & VELOCITY_DUPLEX_FULL)) {
968 CTRL1000 |= ADVERTISE_1000FULL;
969 }
970 velocity_mii_write(vptr->mac_regs, MII_CTRL1000, CTRL1000);
Dave Jones2cf71d22009-07-23 18:11:12 -0700971
972 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10))
973 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
974 else
975 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
976
Francois Romieu3a7f8682010-04-06 14:24:53 -0700977 /* MII_REG_BITS_OFF(BMCR_SPEED1000, MII_BMCR, vptr->mac_regs); */
978 velocity_mii_read(vptr->mac_regs, MII_ADVERTISE, &ANAR);
979 ANAR &= (~(ADVERTISE_100FULL | ADVERTISE_100HALF | ADVERTISE_10FULL | ADVERTISE_10HALF));
Dave Jones2cf71d22009-07-23 18:11:12 -0700980 if (mii_status & VELOCITY_SPEED_100) {
981 if (mii_status & VELOCITY_DUPLEX_FULL)
Francois Romieu3a7f8682010-04-06 14:24:53 -0700982 ANAR |= ADVERTISE_100FULL;
Dave Jones2cf71d22009-07-23 18:11:12 -0700983 else
Francois Romieu3a7f8682010-04-06 14:24:53 -0700984 ANAR |= ADVERTISE_100HALF;
françois romieu15419222010-10-13 09:26:05 +0000985 } else if (mii_status & VELOCITY_SPEED_10) {
Dave Jones2cf71d22009-07-23 18:11:12 -0700986 if (mii_status & VELOCITY_DUPLEX_FULL)
Francois Romieu3a7f8682010-04-06 14:24:53 -0700987 ANAR |= ADVERTISE_10FULL;
Dave Jones2cf71d22009-07-23 18:11:12 -0700988 else
Francois Romieu3a7f8682010-04-06 14:24:53 -0700989 ANAR |= ADVERTISE_10HALF;
Dave Jones2cf71d22009-07-23 18:11:12 -0700990 }
Francois Romieu3a7f8682010-04-06 14:24:53 -0700991 velocity_mii_write(vptr->mac_regs, MII_ADVERTISE, ANAR);
Dave Jones2cf71d22009-07-23 18:11:12 -0700992 /* enable AUTO-NEGO mode */
993 mii_set_auto_on(vptr);
Francois Romieu3a7f8682010-04-06 14:24:53 -0700994 /* MII_REG_BITS_ON(BMCR_ANENABLE, MII_BMCR, vptr->mac_regs); */
Dave Jones2cf71d22009-07-23 18:11:12 -0700995 }
996 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
997 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
998 return VELOCITY_LINK_CHANGE;
999}
1000
1001/**
1002 * velocity_print_link_status - link status reporting
1003 * @vptr: velocity to report on
1004 *
1005 * Turn the link status of the velocity card into a kernel log
1006 * description of the new link state, detailing speed and duplex
1007 * status
1008 */
1009static void velocity_print_link_status(struct velocity_info *vptr)
1010{
1011
1012 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1013 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1014 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1015 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1016
1017 if (vptr->mii_status & VELOCITY_SPEED_1000)
1018 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1019 else if (vptr->mii_status & VELOCITY_SPEED_100)
1020 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1021 else
1022 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1023
1024 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1025 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1026 else
1027 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1028 } else {
1029 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1030 switch (vptr->options.spd_dpx) {
françois romieu15419222010-10-13 09:26:05 +00001031 case SPD_DPX_1000_FULL:
1032 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps full duplex\n");
1033 break;
Dave Jones2cf71d22009-07-23 18:11:12 -07001034 case SPD_DPX_100_HALF:
1035 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1036 break;
1037 case SPD_DPX_100_FULL:
1038 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1039 break;
1040 case SPD_DPX_10_HALF:
1041 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1042 break;
1043 case SPD_DPX_10_FULL:
1044 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1045 break;
1046 default:
1047 break;
1048 }
1049 }
1050}
1051
1052/**
1053 * enable_flow_control_ability - flow control
1054 * @vptr: veloity to configure
1055 *
1056 * Set up flow control according to the flow control options
1057 * determined by the eeprom/configuration.
1058 */
1059static void enable_flow_control_ability(struct velocity_info *vptr)
1060{
1061
1062 struct mac_regs __iomem *regs = vptr->mac_regs;
1063
1064 switch (vptr->options.flow_cntl) {
1065
1066 case FLOW_CNTL_DEFAULT:
1067 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
1068 writel(CR0_FDXRFCEN, &regs->CR0Set);
1069 else
1070 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1071
1072 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
1073 writel(CR0_FDXTFCEN, &regs->CR0Set);
1074 else
1075 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1076 break;
1077
1078 case FLOW_CNTL_TX:
1079 writel(CR0_FDXTFCEN, &regs->CR0Set);
1080 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1081 break;
1082
1083 case FLOW_CNTL_RX:
1084 writel(CR0_FDXRFCEN, &regs->CR0Set);
1085 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1086 break;
1087
1088 case FLOW_CNTL_TX_RX:
1089 writel(CR0_FDXTFCEN, &regs->CR0Set);
1090 writel(CR0_FDXRFCEN, &regs->CR0Set);
1091 break;
1092
1093 case FLOW_CNTL_DISABLE:
1094 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1095 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1096 break;
1097
1098 default:
1099 break;
1100 }
1101
1102}
1103
1104/**
1105 * velocity_soft_reset - soft reset
1106 * @vptr: velocity to reset
1107 *
1108 * Kick off a soft reset of the velocity adapter and then poll
1109 * until the reset sequence has completed before returning.
1110 */
1111static int velocity_soft_reset(struct velocity_info *vptr)
1112{
1113 struct mac_regs __iomem *regs = vptr->mac_regs;
1114 int i = 0;
1115
1116 writel(CR0_SFRST, &regs->CR0Set);
1117
1118 for (i = 0; i < W_MAX_TIMEOUT; i++) {
1119 udelay(5);
1120 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
1121 break;
1122 }
1123
1124 if (i == W_MAX_TIMEOUT) {
1125 writel(CR0_FORSRST, &regs->CR0Set);
1126 /* FIXME: PCI POSTING */
1127 /* delay 2ms */
1128 mdelay(2);
1129 }
1130 return 0;
1131}
1132
1133/**
1134 * velocity_set_multi - filter list change callback
1135 * @dev: network device
1136 *
1137 * Called by the network layer when the filter lists need to change
1138 * for a velocity adapter. Reload the CAMs with the new address
1139 * filter ruleset.
1140 */
1141static void velocity_set_multi(struct net_device *dev)
1142{
1143 struct velocity_info *vptr = netdev_priv(dev);
1144 struct mac_regs __iomem *regs = vptr->mac_regs;
1145 u8 rx_mode;
1146 int i;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001147 struct netdev_hw_addr *ha;
Dave Jones2cf71d22009-07-23 18:11:12 -07001148
1149 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1150 writel(0xffffffff, &regs->MARCAM[0]);
1151 writel(0xffffffff, &regs->MARCAM[4]);
1152 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001153 } else if ((netdev_mc_count(dev) > vptr->multicast_limit) ||
Joe Perches8e95a202009-12-03 07:58:21 +00001154 (dev->flags & IFF_ALLMULTI)) {
Dave Jones2cf71d22009-07-23 18:11:12 -07001155 writel(0xffffffff, &regs->MARCAM[0]);
1156 writel(0xffffffff, &regs->MARCAM[4]);
1157 rx_mode = (RCR_AM | RCR_AB);
1158 } else {
1159 int offset = MCAM_SIZE - vptr->multicast_limit;
1160 mac_get_cam_mask(regs, vptr->mCAMmask);
1161
Jiri Pirko567ec872010-02-23 23:17:07 +00001162 i = 0;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001163 netdev_for_each_mc_addr(ha, dev) {
1164 mac_set_cam(regs, i + offset, ha->addr);
Dave Jones2cf71d22009-07-23 18:11:12 -07001165 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
Jiri Pirko567ec872010-02-23 23:17:07 +00001166 i++;
Dave Jones2cf71d22009-07-23 18:11:12 -07001167 }
1168
1169 mac_set_cam_mask(regs, vptr->mCAMmask);
1170 rx_mode = RCR_AM | RCR_AB | RCR_AP;
1171 }
1172 if (dev->mtu > 1500)
1173 rx_mode |= RCR_AL;
1174
1175 BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
1176
1177}
1178
1179/*
1180 * MII access , media link mode setting functions
1181 */
1182
1183/**
1184 * mii_init - set up MII
1185 * @vptr: velocity adapter
1186 * @mii_status: links tatus
1187 *
1188 * Set up the PHY for the current link state.
1189 */
1190static void mii_init(struct velocity_info *vptr, u32 mii_status)
1191{
1192 u16 BMCR;
1193
1194 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
1195 case PHYID_CICADA_CS8201:
1196 /*
1197 * Reset to hardware default
1198 */
Francois Romieu3a7f8682010-04-06 14:24:53 -07001199 MII_REG_BITS_OFF((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001200 /*
1201 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1202 * off it in NWay-forced half mode for NWay-forced v.s.
1203 * legacy-forced issue.
1204 */
1205 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
Francois Romieu3a7f8682010-04-06 14:24:53 -07001206 MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001207 else
Francois Romieu3a7f8682010-04-06 14:24:53 -07001208 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001209 /*
1210 * Turn on Link/Activity LED enable bit for CIS8201
1211 */
Francois Romieu3a7f8682010-04-06 14:24:53 -07001212 MII_REG_BITS_ON(PLED_LALBE, MII_TPISTATUS, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001213 break;
1214 case PHYID_VT3216_32BIT:
1215 case PHYID_VT3216_64BIT:
1216 /*
1217 * Reset to hardware default
1218 */
Francois Romieu3a7f8682010-04-06 14:24:53 -07001219 MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001220 /*
1221 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1222 * off it in NWay-forced half mode for NWay-forced v.s.
1223 * legacy-forced issue
1224 */
1225 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
Francois Romieu3a7f8682010-04-06 14:24:53 -07001226 MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001227 else
Francois Romieu3a7f8682010-04-06 14:24:53 -07001228 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001229 break;
1230
1231 case PHYID_MARVELL_1000:
1232 case PHYID_MARVELL_1000S:
1233 /*
1234 * Assert CRS on Transmit
1235 */
1236 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
1237 /*
1238 * Reset to hardware default
1239 */
Francois Romieu3a7f8682010-04-06 14:24:53 -07001240 MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP), MII_ADVERTISE, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07001241 break;
1242 default:
1243 ;
1244 }
Francois Romieu3a7f8682010-04-06 14:24:53 -07001245 velocity_mii_read(vptr->mac_regs, MII_BMCR, &BMCR);
1246 if (BMCR & BMCR_ISOLATE) {
1247 BMCR &= ~BMCR_ISOLATE;
1248 velocity_mii_write(vptr->mac_regs, MII_BMCR, BMCR);
Dave Jones2cf71d22009-07-23 18:11:12 -07001249 }
1250}
1251
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00001252/**
1253 * setup_queue_timers - Setup interrupt timers
1254 *
1255 * Setup interrupt frequency during suppression (timeout if the frame
1256 * count isn't filled).
1257 */
1258static void setup_queue_timers(struct velocity_info *vptr)
1259{
1260 /* Only for newer revisions */
1261 if (vptr->rev_id >= REV_ID_VT3216_A0) {
1262 u8 txqueue_timer = 0;
1263 u8 rxqueue_timer = 0;
1264
1265 if (vptr->mii_status & (VELOCITY_SPEED_1000 |
1266 VELOCITY_SPEED_100)) {
1267 txqueue_timer = vptr->options.txqueue_timer;
1268 rxqueue_timer = vptr->options.rxqueue_timer;
1269 }
1270
1271 writeb(txqueue_timer, &vptr->mac_regs->TQETMR);
1272 writeb(rxqueue_timer, &vptr->mac_regs->RQETMR);
1273 }
1274}
1275/**
1276 * setup_adaptive_interrupts - Setup interrupt suppression
1277 *
1278 * @vptr velocity adapter
1279 *
1280 * The velocity is able to suppress interrupt during high interrupt load.
1281 * This function turns on that feature.
1282 */
1283static void setup_adaptive_interrupts(struct velocity_info *vptr)
1284{
1285 struct mac_regs __iomem *regs = vptr->mac_regs;
1286 u16 tx_intsup = vptr->options.tx_intsup;
1287 u16 rx_intsup = vptr->options.rx_intsup;
1288
1289 /* Setup default interrupt mask (will be changed below) */
1290 vptr->int_mask = INT_MASK_DEF;
1291
1292 /* Set Tx Interrupt Suppression Threshold */
1293 writeb(CAMCR_PS0, &regs->CAMCR);
1294 if (tx_intsup != 0) {
1295 vptr->int_mask &= ~(ISR_PTXI | ISR_PTX0I | ISR_PTX1I |
1296 ISR_PTX2I | ISR_PTX3I);
1297 writew(tx_intsup, &regs->ISRCTL);
1298 } else
1299 writew(ISRCTL_TSUPDIS, &regs->ISRCTL);
1300
1301 /* Set Rx Interrupt Suppression Threshold */
1302 writeb(CAMCR_PS1, &regs->CAMCR);
1303 if (rx_intsup != 0) {
1304 vptr->int_mask &= ~ISR_PRXI;
1305 writew(rx_intsup, &regs->ISRCTL);
1306 } else
1307 writew(ISRCTL_RSUPDIS, &regs->ISRCTL);
1308
1309 /* Select page to interrupt hold timer */
1310 writeb(0, &regs->CAMCR);
1311}
Dave Jones2cf71d22009-07-23 18:11:12 -07001312
1313/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 * velocity_init_registers - initialise MAC registers
1315 * @vptr: velocity to init
1316 * @type: type of initialisation (hot or cold)
1317 *
1318 * Initialise the MAC on a reset or on first set up on the
1319 * hardware.
1320 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001321static void velocity_init_registers(struct velocity_info *vptr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 enum velocity_init_type type)
1323{
Dave Jonesc4067402009-07-20 17:35:21 +00001324 struct mac_regs __iomem *regs = vptr->mac_regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 int i, mii_status;
1326
1327 mac_wol_reset(regs);
1328
1329 switch (type) {
1330 case VELOCITY_INIT_RESET:
1331 case VELOCITY_INIT_WOL:
1332
1333 netif_stop_queue(vptr->dev);
1334
1335 /*
1336 * Reset RX to prevent RX pointer not on the 4X location
1337 */
1338 velocity_rx_reset(vptr);
1339 mac_rx_queue_run(regs);
1340 mac_rx_queue_wake(regs);
1341
1342 mii_status = velocity_get_opt_media_mode(vptr);
1343 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1344 velocity_print_link_status(vptr);
1345 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1346 netif_wake_queue(vptr->dev);
1347 }
1348
1349 enable_flow_control_ability(vptr);
1350
1351 mac_clear_isr(regs);
1352 writel(CR0_STOP, &regs->CR0Clr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001353 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 &regs->CR0Set);
1355
1356 break;
1357
1358 case VELOCITY_INIT_COLD:
1359 default:
1360 /*
1361 * Do reset
1362 */
1363 velocity_soft_reset(vptr);
1364 mdelay(5);
1365
1366 mac_eeprom_reload(regs);
Dave Jonesc4067402009-07-20 17:35:21 +00001367 for (i = 0; i < 6; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
Dave Jonesc4067402009-07-20 17:35:21 +00001369
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 /*
1371 * clear Pre_ACPI bit.
1372 */
1373 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
1374 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
1375 mac_set_dma_length(regs, vptr->options.DMA_length);
1376
1377 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
1378 /*
1379 * Back off algorithm use original IEEE standard
1380 */
1381 BYTE_REG_BITS_SET(CFGB_OFSET, (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA | CFGB_BAKOPT), &regs->CFGB);
1382
1383 /*
1384 * Init CAM filter
1385 */
1386 velocity_init_cam_filter(vptr);
1387
1388 /*
1389 * Set packet filter: Receive directed and broadcast address
1390 */
1391 velocity_set_multi(vptr->dev);
1392
1393 /*
1394 * Enable MII auto-polling
1395 */
1396 enable_mii_autopoll(regs);
1397
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00001398 setup_adaptive_interrupts(vptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Francois Romieu0fe9f152008-07-31 22:10:10 +02001400 writel(vptr->rx.pool_dma, &regs->RDBaseLo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 writew(vptr->options.numrx - 1, &regs->RDCSize);
1402 mac_rx_queue_run(regs);
1403 mac_rx_queue_wake(regs);
1404
1405 writew(vptr->options.numtx - 1, &regs->TDCSize);
1406
Francois Romieu0fe9f152008-07-31 22:10:10 +02001407 for (i = 0; i < vptr->tx.numq; i++) {
1408 writel(vptr->tx.pool_dma[i], &regs->TDBaseLo[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 mac_tx_queue_run(regs, i);
1410 }
1411
1412 init_flow_control_register(vptr);
1413
1414 writel(CR0_STOP, &regs->CR0Clr);
1415 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
1416
1417 mii_status = velocity_get_opt_media_mode(vptr);
1418 netif_stop_queue(vptr->dev);
1419
1420 mii_init(vptr, mii_status);
1421
1422 if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
1423 velocity_print_link_status(vptr);
1424 if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1425 netif_wake_queue(vptr->dev);
1426 }
1427
1428 enable_flow_control_ability(vptr);
1429 mac_hw_mibs_init(regs);
1430 mac_write_int_mask(vptr->int_mask, regs);
1431 mac_clear_isr(regs);
1432
1433 }
1434}
1435
Dave Jones2cf71d22009-07-23 18:11:12 -07001436static void velocity_give_many_rx_descs(struct velocity_info *vptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
Dave Jonesc4067402009-07-20 17:35:21 +00001438 struct mac_regs __iomem *regs = vptr->mac_regs;
Dave Jones2cf71d22009-07-23 18:11:12 -07001439 int avail, dirty, unusable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Dave Jones2cf71d22009-07-23 18:11:12 -07001441 /*
1442 * RD number must be equal to 4X per hardware spec
1443 * (programming guide rev 1.20, p.13)
1444 */
1445 if (vptr->rx.filled < 4)
1446 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Dave Jones2cf71d22009-07-23 18:11:12 -07001448 wmb();
1449
1450 unusable = vptr->rx.filled & 0x0003;
1451 dirty = vptr->rx.dirty - unusable;
1452 for (avail = vptr->rx.filled & 0xfffc; avail; avail--) {
1453 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1454 vptr->rx.ring[dirty].rdesc0.len |= OWNED_BY_NIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 }
1456
Dave Jones2cf71d22009-07-23 18:11:12 -07001457 writew(vptr->rx.filled & 0xfffc, &regs->RBRDU);
1458 vptr->rx.filled = unusable;
1459}
1460
1461/**
1462 * velocity_init_dma_rings - set up DMA rings
1463 * @vptr: Velocity to set up
1464 *
1465 * Allocate PCI mapped DMA rings for the receive and transmit layer
1466 * to use.
1467 */
1468static int velocity_init_dma_rings(struct velocity_info *vptr)
1469{
1470 struct velocity_opt *opt = &vptr->options;
1471 const unsigned int rx_ring_size = opt->numrx * sizeof(struct rx_desc);
1472 const unsigned int tx_ring_size = opt->numtx * sizeof(struct tx_desc);
1473 struct pci_dev *pdev = vptr->pdev;
1474 dma_addr_t pool_dma;
1475 void *pool;
1476 unsigned int i;
1477
1478 /*
1479 * Allocate all RD/TD rings a single pool.
1480 *
1481 * pci_alloc_consistent() fulfills the requirement for 64 bytes
1482 * alignment
1483 */
1484 pool = pci_alloc_consistent(pdev, tx_ring_size * vptr->tx.numq +
1485 rx_ring_size, &pool_dma);
1486 if (!pool) {
1487 dev_err(&pdev->dev, "%s : DMA memory allocation failed.\n",
1488 vptr->dev->name);
1489 return -ENOMEM;
1490 }
1491
1492 vptr->rx.ring = pool;
1493 vptr->rx.pool_dma = pool_dma;
1494
1495 pool += rx_ring_size;
1496 pool_dma += rx_ring_size;
1497
1498 for (i = 0; i < vptr->tx.numq; i++) {
1499 vptr->tx.rings[i] = pool;
1500 vptr->tx.pool_dma[i] = pool_dma;
1501 pool += tx_ring_size;
1502 pool_dma += tx_ring_size;
1503 }
1504
1505 return 0;
1506}
1507
1508static void velocity_set_rxbufsize(struct velocity_info *vptr, int mtu)
1509{
1510 vptr->rx.buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1511}
1512
1513/**
1514 * velocity_alloc_rx_buf - allocate aligned receive buffer
1515 * @vptr: velocity
1516 * @idx: ring index
1517 *
1518 * Allocate a new full sized buffer for the reception of a frame and
1519 * map it into PCI space for the hardware to use. The hardware
1520 * requires *64* byte alignment of the buffer which makes life
1521 * less fun than would be ideal.
1522 */
1523static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1524{
1525 struct rx_desc *rd = &(vptr->rx.ring[idx]);
1526 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
1527
1528 rd_info->skb = dev_alloc_skb(vptr->rx.buf_sz + 64);
1529 if (rd_info->skb == NULL)
1530 return -ENOMEM;
1531
1532 /*
1533 * Do the gymnastics to get the buffer head for data at
1534 * 64byte alignment.
1535 */
Simon Kagstromda95b2d2009-11-25 22:09:53 +00001536 skb_reserve(rd_info->skb,
1537 64 - ((unsigned long) rd_info->skb->data & 63));
Dave Jones2cf71d22009-07-23 18:11:12 -07001538 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
1539 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
1540
1541 /*
1542 * Fill in the descriptor to match
1543 */
1544
1545 *((u32 *) & (rd->rdesc0)) = 0;
1546 rd->size = cpu_to_le16(vptr->rx.buf_sz) | RX_INTEN;
1547 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1548 rd->pa_high = 0;
1549 return 0;
1550}
1551
1552
1553static int velocity_rx_refill(struct velocity_info *vptr)
1554{
1555 int dirty = vptr->rx.dirty, done = 0;
1556
1557 do {
1558 struct rx_desc *rd = vptr->rx.ring + dirty;
1559
1560 /* Fine for an all zero Rx desc at init time as well */
1561 if (rd->rdesc0.len & OWNED_BY_NIC)
1562 break;
1563
1564 if (!vptr->rx.info[dirty].skb) {
1565 if (velocity_alloc_rx_buf(vptr, dirty) < 0)
1566 break;
1567 }
1568 done++;
1569 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
1570 } while (dirty != vptr->rx.curr);
1571
1572 if (done) {
1573 vptr->rx.dirty = dirty;
1574 vptr->rx.filled += done;
1575 }
1576
1577 return done;
1578}
1579
1580/**
1581 * velocity_free_rd_ring - free receive ring
1582 * @vptr: velocity to clean up
1583 *
1584 * Free the receive buffers for each ring slot and any
1585 * attached socket buffers that need to go away.
1586 */
1587static void velocity_free_rd_ring(struct velocity_info *vptr)
1588{
1589 int i;
1590
1591 if (vptr->rx.info == NULL)
1592 return;
1593
1594 for (i = 0; i < vptr->options.numrx; i++) {
1595 struct velocity_rd_info *rd_info = &(vptr->rx.info[i]);
1596 struct rx_desc *rd = vptr->rx.ring + i;
1597
1598 memset(rd, 0, sizeof(*rd));
1599
1600 if (!rd_info->skb)
1601 continue;
1602 pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
1603 PCI_DMA_FROMDEVICE);
1604 rd_info->skb_dma = 0;
1605
1606 dev_kfree_skb(rd_info->skb);
1607 rd_info->skb = NULL;
1608 }
1609
1610 kfree(vptr->rx.info);
1611 vptr->rx.info = NULL;
1612}
1613
1614
1615
1616/**
1617 * velocity_init_rd_ring - set up receive ring
1618 * @vptr: velocity to configure
1619 *
1620 * Allocate and set up the receive buffers for each ring slot and
1621 * assign them to the network adapter.
1622 */
1623static int velocity_init_rd_ring(struct velocity_info *vptr)
1624{
1625 int ret = -ENOMEM;
1626
1627 vptr->rx.info = kcalloc(vptr->options.numrx,
1628 sizeof(struct velocity_rd_info), GFP_KERNEL);
1629 if (!vptr->rx.info)
1630 goto out;
1631
1632 velocity_init_rx_ring_indexes(vptr);
1633
1634 if (velocity_rx_refill(vptr) != vptr->options.numrx) {
1635 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1636 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1637 velocity_free_rd_ring(vptr);
1638 goto out;
1639 }
1640
1641 ret = 0;
1642out:
1643 return ret;
1644}
1645
1646/**
1647 * velocity_init_td_ring - set up transmit ring
1648 * @vptr: velocity
1649 *
1650 * Set up the transmit ring and chain the ring pointers together.
1651 * Returns zero on success or a negative posix errno code for
1652 * failure.
1653 */
1654static int velocity_init_td_ring(struct velocity_info *vptr)
1655{
Dave Jones2cf71d22009-07-23 18:11:12 -07001656 int j;
1657
1658 /* Init the TD ring entries */
1659 for (j = 0; j < vptr->tx.numq; j++) {
Dave Jones2cf71d22009-07-23 18:11:12 -07001660
1661 vptr->tx.infos[j] = kcalloc(vptr->options.numtx,
1662 sizeof(struct velocity_td_info),
1663 GFP_KERNEL);
1664 if (!vptr->tx.infos[j]) {
1665 while (--j >= 0)
1666 kfree(vptr->tx.infos[j]);
1667 return -ENOMEM;
1668 }
1669
1670 vptr->tx.tail[j] = vptr->tx.curr[j] = vptr->tx.used[j] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 }
1672 return 0;
1673}
1674
Dave Jones2cf71d22009-07-23 18:11:12 -07001675/**
1676 * velocity_free_dma_rings - free PCI ring pointers
1677 * @vptr: Velocity to free from
1678 *
1679 * Clean up the PCI ring buffers allocated to this velocity.
1680 */
1681static void velocity_free_dma_rings(struct velocity_info *vptr)
1682{
1683 const int size = vptr->options.numrx * sizeof(struct rx_desc) +
1684 vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq;
1685
1686 pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
1687}
1688
1689
1690static int velocity_init_rings(struct velocity_info *vptr, int mtu)
1691{
1692 int ret;
1693
1694 velocity_set_rxbufsize(vptr, mtu);
1695
1696 ret = velocity_init_dma_rings(vptr);
1697 if (ret < 0)
1698 goto out;
1699
1700 ret = velocity_init_rd_ring(vptr);
1701 if (ret < 0)
1702 goto err_free_dma_rings_0;
1703
1704 ret = velocity_init_td_ring(vptr);
1705 if (ret < 0)
1706 goto err_free_rd_ring_1;
1707out:
1708 return ret;
1709
1710err_free_rd_ring_1:
1711 velocity_free_rd_ring(vptr);
1712err_free_dma_rings_0:
1713 velocity_free_dma_rings(vptr);
1714 goto out;
1715}
1716
1717/**
1718 * velocity_free_tx_buf - free transmit buffer
1719 * @vptr: velocity
1720 * @tdinfo: buffer
1721 *
1722 * Release an transmit buffer. If the buffer was preallocated then
1723 * recycle it, if not then unmap the buffer.
1724 */
Simon Kagstromc79992f2009-11-25 22:10:43 +00001725static void velocity_free_tx_buf(struct velocity_info *vptr,
1726 struct velocity_td_info *tdinfo, struct tx_desc *td)
Dave Jones2cf71d22009-07-23 18:11:12 -07001727{
1728 struct sk_buff *skb = tdinfo->skb;
Dave Jones2cf71d22009-07-23 18:11:12 -07001729
1730 /*
1731 * Don't unmap the pre-allocated tx_bufs
1732 */
1733 if (tdinfo->skb_dma) {
Simon Kagstromc79992f2009-11-25 22:10:43 +00001734 int i;
Dave Jones2cf71d22009-07-23 18:11:12 -07001735
Dave Jones2cf71d22009-07-23 18:11:12 -07001736 for (i = 0; i < tdinfo->nskb_dma; i++) {
Simon Kagstromc79992f2009-11-25 22:10:43 +00001737 size_t pktlen = max_t(size_t, skb->len, ETH_ZLEN);
1738
1739 /* For scatter-gather */
1740 if (skb_shinfo(skb)->nr_frags > 0)
1741 pktlen = max_t(size_t, pktlen,
1742 td->td_buf[i].size & ~TD_QUEUE);
1743
1744 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i],
1745 le16_to_cpu(pktlen), PCI_DMA_TODEVICE);
Dave Jones2cf71d22009-07-23 18:11:12 -07001746 }
1747 }
1748 dev_kfree_skb_irq(skb);
1749 tdinfo->skb = NULL;
1750}
1751
1752
1753/*
1754 * FIXME: could we merge this with velocity_free_tx_buf ?
1755 */
1756static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1757 int q, int n)
1758{
1759 struct velocity_td_info *td_info = &(vptr->tx.infos[q][n]);
1760 int i;
1761
1762 if (td_info == NULL)
1763 return;
1764
1765 if (td_info->skb) {
1766 for (i = 0; i < td_info->nskb_dma; i++) {
1767 if (td_info->skb_dma[i]) {
1768 pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
1769 td_info->skb->len, PCI_DMA_TODEVICE);
1770 td_info->skb_dma[i] = 0;
1771 }
1772 }
1773 dev_kfree_skb(td_info->skb);
1774 td_info->skb = NULL;
1775 }
1776}
1777
1778/**
1779 * velocity_free_td_ring - free td ring
1780 * @vptr: velocity
1781 *
1782 * Free up the transmit ring for this particular velocity adapter.
1783 * We free the ring contents but not the ring itself.
1784 */
1785static void velocity_free_td_ring(struct velocity_info *vptr)
1786{
1787 int i, j;
1788
1789 for (j = 0; j < vptr->tx.numq; j++) {
1790 if (vptr->tx.infos[j] == NULL)
1791 continue;
1792 for (i = 0; i < vptr->options.numtx; i++)
1793 velocity_free_td_ring_entry(vptr, j, i);
1794
1795 kfree(vptr->tx.infos[j]);
1796 vptr->tx.infos[j] = NULL;
1797 }
1798}
1799
1800
1801static void velocity_free_rings(struct velocity_info *vptr)
1802{
1803 velocity_free_td_ring(vptr);
1804 velocity_free_rd_ring(vptr);
1805 velocity_free_dma_rings(vptr);
1806}
1807
1808/**
1809 * velocity_error - handle error from controller
1810 * @vptr: velocity
1811 * @status: card status
1812 *
1813 * Process an error report from the hardware and attempt to recover
1814 * the card itself. At the moment we cannot recover from some
1815 * theoretically impossible errors but this could be fixed using
1816 * the pci_device_failed logic to bounce the hardware
1817 *
1818 */
1819static void velocity_error(struct velocity_info *vptr, int status)
1820{
1821
1822 if (status & ISR_TXSTLI) {
1823 struct mac_regs __iomem *regs = vptr->mac_regs;
1824
1825 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1826 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1827 writew(TRDCSR_RUN, &regs->TDCSRClr);
1828 netif_stop_queue(vptr->dev);
1829
1830 /* FIXME: port over the pci_device_failed code and use it
1831 here */
1832 }
1833
1834 if (status & ISR_SRCI) {
1835 struct mac_regs __iomem *regs = vptr->mac_regs;
1836 int linked;
1837
1838 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1839 vptr->mii_status = check_connection_type(regs);
1840
1841 /*
1842 * If it is a 3119, disable frame bursting in
1843 * halfduplex mode and enable it in fullduplex
1844 * mode
1845 */
1846 if (vptr->rev_id < REV_ID_VT3216_A0) {
David S. Miller6cdee2f2009-09-02 00:32:56 -07001847 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
Dave Jones2cf71d22009-07-23 18:11:12 -07001848 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1849 else
1850 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1851 }
1852 /*
1853 * Only enable CD heart beat counter in 10HD mode
1854 */
1855 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10))
1856 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1857 else
1858 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00001859
1860 setup_queue_timers(vptr);
Dave Jones2cf71d22009-07-23 18:11:12 -07001861 }
1862 /*
1863 * Get link status from PHYSR0
1864 */
1865 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1866
1867 if (linked) {
1868 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1869 netif_carrier_on(vptr->dev);
1870 } else {
1871 vptr->mii_status |= VELOCITY_LINK_FAIL;
1872 netif_carrier_off(vptr->dev);
1873 }
1874
1875 velocity_print_link_status(vptr);
1876 enable_flow_control_ability(vptr);
1877
1878 /*
1879 * Re-enable auto-polling because SRCI will disable
1880 * auto-polling
1881 */
1882
1883 enable_mii_autopoll(regs);
1884
1885 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1886 netif_stop_queue(vptr->dev);
1887 else
1888 netif_wake_queue(vptr->dev);
1889
1890 };
1891 if (status & ISR_MIBFI)
1892 velocity_update_hw_mibs(vptr);
1893 if (status & ISR_LSTEI)
1894 mac_rx_queue_wake(vptr->mac_regs);
1895}
1896
1897/**
1898 * tx_srv - transmit interrupt service
1899 * @vptr; Velocity
Dave Jones2cf71d22009-07-23 18:11:12 -07001900 *
1901 * Scan the queues looking for transmitted packets that
1902 * we can complete and clean up. Update any statistics as
1903 * necessary/
1904 */
Simon Kagstromd6cade02010-02-09 23:37:54 +00001905static int velocity_tx_srv(struct velocity_info *vptr)
Dave Jones2cf71d22009-07-23 18:11:12 -07001906{
1907 struct tx_desc *td;
1908 int qnum;
1909 int full = 0;
1910 int idx;
1911 int works = 0;
1912 struct velocity_td_info *tdinfo;
1913 struct net_device_stats *stats = &vptr->dev->stats;
1914
1915 for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
1916 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
1917 idx = (idx + 1) % vptr->options.numtx) {
1918
1919 /*
1920 * Get Tx Descriptor
1921 */
1922 td = &(vptr->tx.rings[qnum][idx]);
1923 tdinfo = &(vptr->tx.infos[qnum][idx]);
1924
1925 if (td->tdesc0.len & OWNED_BY_NIC)
1926 break;
1927
1928 if ((works++ > 15))
1929 break;
1930
1931 if (td->tdesc0.TSR & TSR0_TERR) {
1932 stats->tx_errors++;
1933 stats->tx_dropped++;
1934 if (td->tdesc0.TSR & TSR0_CDH)
1935 stats->tx_heartbeat_errors++;
1936 if (td->tdesc0.TSR & TSR0_CRS)
1937 stats->tx_carrier_errors++;
1938 if (td->tdesc0.TSR & TSR0_ABT)
1939 stats->tx_aborted_errors++;
1940 if (td->tdesc0.TSR & TSR0_OWC)
1941 stats->tx_window_errors++;
1942 } else {
1943 stats->tx_packets++;
1944 stats->tx_bytes += tdinfo->skb->len;
1945 }
Simon Kagstromc79992f2009-11-25 22:10:43 +00001946 velocity_free_tx_buf(vptr, tdinfo, td);
Dave Jones2cf71d22009-07-23 18:11:12 -07001947 vptr->tx.used[qnum]--;
1948 }
1949 vptr->tx.tail[qnum] = idx;
1950
1951 if (AVAIL_TD(vptr, qnum) < 1)
1952 full = 1;
1953 }
1954 /*
1955 * Look to see if we should kick the transmit network
1956 * layer for more work.
1957 */
Joe Perches8e95a202009-12-03 07:58:21 +00001958 if (netif_queue_stopped(vptr->dev) && (full == 0) &&
1959 (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
Dave Jones2cf71d22009-07-23 18:11:12 -07001960 netif_wake_queue(vptr->dev);
1961 }
1962 return works;
1963}
1964
1965/**
1966 * velocity_rx_csum - checksum process
1967 * @rd: receive packet descriptor
1968 * @skb: network layer packet buffer
1969 *
1970 * Process the status bits for the received packet and determine
1971 * if the checksum was computed and verified by the hardware
1972 */
1973static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1974{
Eric Dumazetbc8acf22010-09-02 13:07:41 -07001975 skb_checksum_none_assert(skb);
Dave Jones2cf71d22009-07-23 18:11:12 -07001976
1977 if (rd->rdesc1.CSM & CSM_IPKT) {
1978 if (rd->rdesc1.CSM & CSM_IPOK) {
1979 if ((rd->rdesc1.CSM & CSM_TCPKT) ||
1980 (rd->rdesc1.CSM & CSM_UDPKT)) {
1981 if (!(rd->rdesc1.CSM & CSM_TUPOK))
1982 return;
1983 }
1984 skb->ip_summed = CHECKSUM_UNNECESSARY;
1985 }
1986 }
1987}
1988
1989/**
1990 * velocity_rx_copy - in place Rx copy for small packets
1991 * @rx_skb: network layer packet buffer candidate
1992 * @pkt_size: received data size
1993 * @rd: receive packet descriptor
1994 * @dev: network device
1995 *
1996 * Replace the current skb that is scheduled for Rx processing by a
1997 * shorter, immediatly allocated skb, if the received packet is small
1998 * enough. This function returns a negative value if the received
1999 * packet is too big or if memory is exhausted.
2000 */
2001static int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
2002 struct velocity_info *vptr)
2003{
2004 int ret = -1;
2005 if (pkt_size < rx_copybreak) {
2006 struct sk_buff *new_skb;
2007
Eric Dumazet89d71a62009-10-13 05:34:20 +00002008 new_skb = netdev_alloc_skb_ip_align(vptr->dev, pkt_size);
Dave Jones2cf71d22009-07-23 18:11:12 -07002009 if (new_skb) {
2010 new_skb->ip_summed = rx_skb[0]->ip_summed;
Dave Jones2cf71d22009-07-23 18:11:12 -07002011 skb_copy_from_linear_data(*rx_skb, new_skb->data, pkt_size);
2012 *rx_skb = new_skb;
2013 ret = 0;
2014 }
2015
2016 }
2017 return ret;
2018}
2019
2020/**
2021 * velocity_iph_realign - IP header alignment
2022 * @vptr: velocity we are handling
2023 * @skb: network layer packet buffer
2024 * @pkt_size: received data size
2025 *
2026 * Align IP header on a 2 bytes boundary. This behavior can be
2027 * configured by the user.
2028 */
2029static inline void velocity_iph_realign(struct velocity_info *vptr,
2030 struct sk_buff *skb, int pkt_size)
2031{
2032 if (vptr->flags & VELOCITY_FLAGS_IP_ALIGN) {
2033 memmove(skb->data + 2, skb->data, pkt_size);
2034 skb_reserve(skb, 2);
2035 }
2036}
2037
2038
2039/**
2040 * velocity_receive_frame - received packet processor
2041 * @vptr: velocity we are handling
2042 * @idx: ring index
2043 *
2044 * A packet has arrived. We process the packet and if appropriate
2045 * pass the frame up the network stack
2046 */
2047static int velocity_receive_frame(struct velocity_info *vptr, int idx)
2048{
2049 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
2050 struct net_device_stats *stats = &vptr->dev->stats;
2051 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
2052 struct rx_desc *rd = &(vptr->rx.ring[idx]);
2053 int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
2054 struct sk_buff *skb;
2055
2056 if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
2057 VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
2058 stats->rx_length_errors++;
2059 return -EINVAL;
2060 }
2061
2062 if (rd->rdesc0.RSR & RSR_MAR)
2063 stats->multicast++;
2064
2065 skb = rd_info->skb;
2066
2067 pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
2068 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
2069
2070 /*
2071 * Drop frame not meeting IEEE 802.3
2072 */
2073
2074 if (vptr->flags & VELOCITY_FLAGS_VAL_PKT_LEN) {
2075 if (rd->rdesc0.RSR & RSR_RL) {
2076 stats->rx_length_errors++;
2077 return -EINVAL;
2078 }
2079 }
2080
2081 pci_action = pci_dma_sync_single_for_device;
2082
2083 velocity_rx_csum(rd, skb);
2084
2085 if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
2086 velocity_iph_realign(vptr, skb, pkt_len);
2087 pci_action = pci_unmap_single;
2088 rd_info->skb = NULL;
2089 }
2090
2091 pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
2092 PCI_DMA_FROMDEVICE);
2093
2094 skb_put(skb, pkt_len - 4);
2095 skb->protocol = eth_type_trans(skb, vptr->dev);
2096
2097 if (vptr->vlgrp && (rd->rdesc0.RSR & RSR_DETAG)) {
2098 vlan_hwaccel_rx(skb, vptr->vlgrp,
2099 swab16(le16_to_cpu(rd->rdesc1.PQTAG)));
2100 } else
2101 netif_rx(skb);
2102
2103 stats->rx_bytes += pkt_len;
2104
2105 return 0;
2106}
2107
2108
2109/**
2110 * velocity_rx_srv - service RX interrupt
2111 * @vptr: velocity
Dave Jones2cf71d22009-07-23 18:11:12 -07002112 *
2113 * Walk the receive ring of the velocity adapter and remove
2114 * any received packets from the receive queue. Hand the ring
2115 * slots back to the adapter for reuse.
2116 */
Simon Kagstromd6cade02010-02-09 23:37:54 +00002117static int velocity_rx_srv(struct velocity_info *vptr, int budget_left)
Dave Jones2cf71d22009-07-23 18:11:12 -07002118{
2119 struct net_device_stats *stats = &vptr->dev->stats;
2120 int rd_curr = vptr->rx.curr;
2121 int works = 0;
2122
Simon Kagstromdfff7142009-11-25 22:10:26 +00002123 while (works < budget_left) {
Dave Jones2cf71d22009-07-23 18:11:12 -07002124 struct rx_desc *rd = vptr->rx.ring + rd_curr;
2125
2126 if (!vptr->rx.info[rd_curr].skb)
2127 break;
2128
2129 if (rd->rdesc0.len & OWNED_BY_NIC)
2130 break;
2131
2132 rmb();
2133
2134 /*
2135 * Don't drop CE or RL error frame although RXOK is off
2136 */
2137 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) {
2138 if (velocity_receive_frame(vptr, rd_curr) < 0)
2139 stats->rx_dropped++;
2140 } else {
2141 if (rd->rdesc0.RSR & RSR_CRC)
2142 stats->rx_crc_errors++;
2143 if (rd->rdesc0.RSR & RSR_FAE)
2144 stats->rx_frame_errors++;
2145
2146 stats->rx_dropped++;
2147 }
2148
2149 rd->size |= RX_INTEN;
2150
2151 rd_curr++;
2152 if (rd_curr >= vptr->options.numrx)
2153 rd_curr = 0;
Simon Kagstromdfff7142009-11-25 22:10:26 +00002154 works++;
2155 }
Dave Jones2cf71d22009-07-23 18:11:12 -07002156
2157 vptr->rx.curr = rd_curr;
2158
2159 if ((works > 0) && (velocity_rx_refill(vptr) > 0))
2160 velocity_give_many_rx_descs(vptr);
2161
2162 VAR_USED(stats);
2163 return works;
2164}
2165
Simon Kagstromdfff7142009-11-25 22:10:26 +00002166static int velocity_poll(struct napi_struct *napi, int budget)
2167{
2168 struct velocity_info *vptr = container_of(napi,
2169 struct velocity_info, napi);
2170 unsigned int rx_done;
Simon Kagstrom3f2e8d92010-02-09 23:38:25 +00002171 unsigned long flags;
Simon Kagstromdfff7142009-11-25 22:10:26 +00002172
Simon Kagstrom3f2e8d92010-02-09 23:38:25 +00002173 spin_lock_irqsave(&vptr->lock, flags);
Simon Kagstromdfff7142009-11-25 22:10:26 +00002174 /*
2175 * Do rx and tx twice for performance (taken from the VIA
2176 * out-of-tree driver).
2177 */
Simon Kagstromd6cade02010-02-09 23:37:54 +00002178 rx_done = velocity_rx_srv(vptr, budget / 2);
2179 velocity_tx_srv(vptr);
2180 rx_done += velocity_rx_srv(vptr, budget - rx_done);
2181 velocity_tx_srv(vptr);
Simon Kagstromdfff7142009-11-25 22:10:26 +00002182
2183 /* If budget not fully consumed, exit the polling mode */
2184 if (rx_done < budget) {
2185 napi_complete(napi);
2186 mac_enable_int(vptr->mac_regs);
2187 }
Simon Kagstrom3f2e8d92010-02-09 23:38:25 +00002188 spin_unlock_irqrestore(&vptr->lock, flags);
Simon Kagstromdfff7142009-11-25 22:10:26 +00002189
2190 return rx_done;
2191}
Dave Jones2cf71d22009-07-23 18:11:12 -07002192
2193/**
2194 * velocity_intr - interrupt callback
2195 * @irq: interrupt number
2196 * @dev_instance: interrupting device
2197 *
2198 * Called whenever an interrupt is generated by the velocity
2199 * adapter IRQ line. We may not be the source of the interrupt
2200 * and need to identify initially if we are, and if not exit as
2201 * efficiently as possible.
2202 */
2203static irqreturn_t velocity_intr(int irq, void *dev_instance)
2204{
2205 struct net_device *dev = dev_instance;
2206 struct velocity_info *vptr = netdev_priv(dev);
2207 u32 isr_status;
Dave Jones2cf71d22009-07-23 18:11:12 -07002208
2209 spin_lock(&vptr->lock);
2210 isr_status = mac_read_isr(vptr->mac_regs);
2211
2212 /* Not us ? */
2213 if (isr_status == 0) {
2214 spin_unlock(&vptr->lock);
2215 return IRQ_NONE;
2216 }
2217
Simon Kagstrom3f2e8d92010-02-09 23:38:25 +00002218 /* Ack the interrupt */
2219 mac_write_isr(vptr->mac_regs, isr_status);
2220
Simon Kagstromdfff7142009-11-25 22:10:26 +00002221 if (likely(napi_schedule_prep(&vptr->napi))) {
2222 mac_disable_int(vptr->mac_regs);
2223 __napi_schedule(&vptr->napi);
Dave Jones2cf71d22009-07-23 18:11:12 -07002224 }
Simon Kagstrom3f2e8d92010-02-09 23:38:25 +00002225
2226 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2227 velocity_error(vptr, isr_status);
2228
Dave Jones2cf71d22009-07-23 18:11:12 -07002229 spin_unlock(&vptr->lock);
Dave Jones2cf71d22009-07-23 18:11:12 -07002230
Simon Kagstromdfff7142009-11-25 22:10:26 +00002231 return IRQ_HANDLED;
Dave Jones2cf71d22009-07-23 18:11:12 -07002232}
2233
2234/**
2235 * velocity_open - interface activation callback
2236 * @dev: network layer device to open
2237 *
2238 * Called when the network layer brings the interface up. Returns
2239 * a negative posix error code on failure, or zero on success.
2240 *
2241 * All the ring allocation and set up is done on open for this
2242 * adapter to minimise memory usage when inactive
2243 */
2244static int velocity_open(struct net_device *dev)
2245{
2246 struct velocity_info *vptr = netdev_priv(dev);
2247 int ret;
2248
2249 ret = velocity_init_rings(vptr, dev->mtu);
2250 if (ret < 0)
2251 goto out;
2252
2253 /* Ensure chip is running */
2254 pci_set_power_state(vptr->pdev, PCI_D0);
2255
Dave Jones2cf71d22009-07-23 18:11:12 -07002256 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2257
Julia Lawall1ede9b52009-11-18 08:24:13 +00002258 ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
Dave Jones2cf71d22009-07-23 18:11:12 -07002259 dev->name, dev);
2260 if (ret < 0) {
2261 /* Power down the chip */
2262 pci_set_power_state(vptr->pdev, PCI_D3hot);
2263 velocity_free_rings(vptr);
2264 goto out;
2265 }
2266
Ben Hutchings35bb5ca2009-12-14 16:05:09 +00002267 velocity_give_many_rx_descs(vptr);
2268
Dave Jones2cf71d22009-07-23 18:11:12 -07002269 mac_enable_int(vptr->mac_regs);
2270 netif_start_queue(dev);
Simon Kagstromdfff7142009-11-25 22:10:26 +00002271 napi_enable(&vptr->napi);
Dave Jones2cf71d22009-07-23 18:11:12 -07002272 vptr->flags |= VELOCITY_FLAGS_OPENED;
2273out:
2274 return ret;
2275}
2276
2277/**
2278 * velocity_shutdown - shut down the chip
2279 * @vptr: velocity to deactivate
2280 *
2281 * Shuts down the internal operations of the velocity and
2282 * disables interrupts, autopolling, transmit and receive
2283 */
2284static void velocity_shutdown(struct velocity_info *vptr)
2285{
2286 struct mac_regs __iomem *regs = vptr->mac_regs;
2287 mac_disable_int(regs);
2288 writel(CR0_STOP, &regs->CR0Set);
2289 writew(0xFFFF, &regs->TDCSRClr);
2290 writeb(0xFF, &regs->RDCSRClr);
2291 safe_disable_mii_autopoll(regs);
2292 mac_clear_isr(regs);
2293}
2294
2295/**
2296 * velocity_change_mtu - MTU change callback
2297 * @dev: network device
2298 * @new_mtu: desired MTU
2299 *
2300 * Handle requests from the networking layer for MTU change on
2301 * this interface. It gets called on a change by the network layer.
2302 * Return zero for success or negative posix error code.
2303 */
2304static int velocity_change_mtu(struct net_device *dev, int new_mtu)
2305{
2306 struct velocity_info *vptr = netdev_priv(dev);
2307 int ret = 0;
2308
2309 if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
2310 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
2311 vptr->dev->name);
2312 ret = -EINVAL;
2313 goto out_0;
2314 }
2315
2316 if (!netif_running(dev)) {
2317 dev->mtu = new_mtu;
2318 goto out_0;
2319 }
2320
2321 if (dev->mtu != new_mtu) {
2322 struct velocity_info *tmp_vptr;
2323 unsigned long flags;
2324 struct rx_info rx;
2325 struct tx_info tx;
2326
2327 tmp_vptr = kzalloc(sizeof(*tmp_vptr), GFP_KERNEL);
2328 if (!tmp_vptr) {
2329 ret = -ENOMEM;
2330 goto out_0;
2331 }
2332
2333 tmp_vptr->dev = dev;
2334 tmp_vptr->pdev = vptr->pdev;
2335 tmp_vptr->options = vptr->options;
2336 tmp_vptr->tx.numq = vptr->tx.numq;
2337
2338 ret = velocity_init_rings(tmp_vptr, new_mtu);
2339 if (ret < 0)
2340 goto out_free_tmp_vptr_1;
2341
2342 spin_lock_irqsave(&vptr->lock, flags);
2343
2344 netif_stop_queue(dev);
2345 velocity_shutdown(vptr);
2346
2347 rx = vptr->rx;
2348 tx = vptr->tx;
2349
2350 vptr->rx = tmp_vptr->rx;
2351 vptr->tx = tmp_vptr->tx;
2352
2353 tmp_vptr->rx = rx;
2354 tmp_vptr->tx = tx;
2355
2356 dev->mtu = new_mtu;
2357
Dave Jones2cf71d22009-07-23 18:11:12 -07002358 velocity_init_registers(vptr, VELOCITY_INIT_COLD);
2359
Ben Hutchings35bb5ca2009-12-14 16:05:09 +00002360 velocity_give_many_rx_descs(vptr);
2361
Dave Jones2cf71d22009-07-23 18:11:12 -07002362 mac_enable_int(vptr->mac_regs);
2363 netif_start_queue(dev);
2364
2365 spin_unlock_irqrestore(&vptr->lock, flags);
2366
2367 velocity_free_rings(tmp_vptr);
2368
2369out_free_tmp_vptr_1:
2370 kfree(tmp_vptr);
2371 }
2372out_0:
2373 return ret;
2374}
2375
2376/**
2377 * velocity_mii_ioctl - MII ioctl handler
2378 * @dev: network device
2379 * @ifr: the ifreq block for the ioctl
2380 * @cmd: the command
2381 *
2382 * Process MII requests made via ioctl from the network layer. These
2383 * are used by tools like kudzu to interrogate the link state of the
2384 * hardware
2385 */
2386static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2387{
2388 struct velocity_info *vptr = netdev_priv(dev);
2389 struct mac_regs __iomem *regs = vptr->mac_regs;
2390 unsigned long flags;
2391 struct mii_ioctl_data *miidata = if_mii(ifr);
2392 int err;
2393
2394 switch (cmd) {
2395 case SIOCGMIIPHY:
2396 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
2397 break;
2398 case SIOCGMIIREG:
Dave Jones2cf71d22009-07-23 18:11:12 -07002399 if (velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
2400 return -ETIMEDOUT;
2401 break;
2402 case SIOCSMIIREG:
Dave Jones2cf71d22009-07-23 18:11:12 -07002403 spin_lock_irqsave(&vptr->lock, flags);
2404 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
2405 spin_unlock_irqrestore(&vptr->lock, flags);
2406 check_connection_type(vptr->mac_regs);
2407 if (err)
2408 return err;
2409 break;
2410 default:
2411 return -EOPNOTSUPP;
2412 }
2413 return 0;
2414}
2415
2416
2417/**
2418 * velocity_ioctl - ioctl entry point
2419 * @dev: network device
2420 * @rq: interface request ioctl
2421 * @cmd: command code
2422 *
2423 * Called when the user issues an ioctl request to the network
2424 * device in question. The velocity interface supports MII.
2425 */
2426static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2427{
2428 struct velocity_info *vptr = netdev_priv(dev);
2429 int ret;
2430
2431 /* If we are asked for information and the device is power
2432 saving then we need to bring the device back up to talk to it */
2433
2434 if (!netif_running(dev))
2435 pci_set_power_state(vptr->pdev, PCI_D0);
2436
2437 switch (cmd) {
2438 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2439 case SIOCGMIIREG: /* Read MII PHY register. */
2440 case SIOCSMIIREG: /* Write to MII PHY register. */
2441 ret = velocity_mii_ioctl(dev, rq, cmd);
2442 break;
2443
2444 default:
2445 ret = -EOPNOTSUPP;
2446 }
2447 if (!netif_running(dev))
2448 pci_set_power_state(vptr->pdev, PCI_D3hot);
2449
2450
2451 return ret;
2452}
2453
2454/**
2455 * velocity_get_status - statistics callback
2456 * @dev: network device
2457 *
2458 * Callback from the network layer to allow driver statistics
2459 * to be resynchronized with hardware collected state. In the
2460 * case of the velocity we need to pull the MIB counters from
2461 * the hardware into the counters before letting the network
2462 * layer display them.
2463 */
2464static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2465{
2466 struct velocity_info *vptr = netdev_priv(dev);
2467
2468 /* If the hardware is down, don't touch MII */
2469 if (!netif_running(dev))
2470 return &dev->stats;
2471
2472 spin_lock_irq(&vptr->lock);
2473 velocity_update_hw_mibs(vptr);
2474 spin_unlock_irq(&vptr->lock);
2475
2476 dev->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2477 dev->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2478 dev->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2479
2480// unsigned long rx_dropped; /* no space in linux buffers */
2481 dev->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2482 /* detailed rx_errors: */
2483// unsigned long rx_length_errors;
2484// unsigned long rx_over_errors; /* receiver ring buff overflow */
2485 dev->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2486// unsigned long rx_frame_errors; /* recv'd frame alignment error */
2487// unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2488// unsigned long rx_missed_errors; /* receiver missed packet */
2489
2490 /* detailed tx_errors */
2491// unsigned long tx_fifo_errors;
2492
2493 return &dev->stats;
2494}
2495
2496/**
2497 * velocity_close - close adapter callback
2498 * @dev: network device
2499 *
2500 * Callback from the network layer when the velocity is being
2501 * deactivated by the network layer
2502 */
2503static int velocity_close(struct net_device *dev)
2504{
2505 struct velocity_info *vptr = netdev_priv(dev);
2506
Simon Kagstromdfff7142009-11-25 22:10:26 +00002507 napi_disable(&vptr->napi);
Dave Jones2cf71d22009-07-23 18:11:12 -07002508 netif_stop_queue(dev);
2509 velocity_shutdown(vptr);
2510
2511 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
2512 velocity_get_ip(vptr);
2513 if (dev->irq != 0)
2514 free_irq(dev->irq, dev);
2515
2516 /* Power down the chip */
2517 pci_set_power_state(vptr->pdev, PCI_D3hot);
2518
2519 velocity_free_rings(vptr);
2520
2521 vptr->flags &= (~VELOCITY_FLAGS_OPENED);
2522 return 0;
2523}
2524
2525/**
2526 * velocity_xmit - transmit packet callback
2527 * @skb: buffer to transmit
2528 * @dev: network device
2529 *
2530 * Called by the networ layer to request a packet is queued to
2531 * the velocity. Returns zero on success.
2532 */
Stephen Hemminger613573252009-08-31 19:50:58 +00002533static netdev_tx_t velocity_xmit(struct sk_buff *skb,
2534 struct net_device *dev)
Dave Jones2cf71d22009-07-23 18:11:12 -07002535{
2536 struct velocity_info *vptr = netdev_priv(dev);
2537 int qnum = 0;
2538 struct tx_desc *td_ptr;
2539 struct velocity_td_info *tdinfo;
2540 unsigned long flags;
2541 int pktlen;
Simon Kagstromc79992f2009-11-25 22:10:43 +00002542 int index, prev;
2543 int i = 0;
Dave Jones2cf71d22009-07-23 18:11:12 -07002544
2545 if (skb_padto(skb, ETH_ZLEN))
2546 goto out;
Dave Jones2cf71d22009-07-23 18:11:12 -07002547
Simon Kagstromc79992f2009-11-25 22:10:43 +00002548 /* The hardware can handle at most 7 memory segments, so merge
2549 * the skb if there are more */
2550 if (skb_shinfo(skb)->nr_frags > 6 && __skb_linearize(skb)) {
2551 kfree_skb(skb);
2552 return NETDEV_TX_OK;
2553 }
2554
2555 pktlen = skb_shinfo(skb)->nr_frags == 0 ?
2556 max_t(unsigned int, skb->len, ETH_ZLEN) :
2557 skb_headlen(skb);
Dave Jones2cf71d22009-07-23 18:11:12 -07002558
2559 spin_lock_irqsave(&vptr->lock, flags);
2560
2561 index = vptr->tx.curr[qnum];
2562 td_ptr = &(vptr->tx.rings[qnum][index]);
2563 tdinfo = &(vptr->tx.infos[qnum][index]);
2564
2565 td_ptr->tdesc1.TCR = TCR0_TIC;
2566 td_ptr->td_buf[0].size &= ~TD_QUEUE;
2567
2568 /*
2569 * Map the linear network buffer into PCI space and
2570 * add it to the transmit ring.
2571 */
2572 tdinfo->skb = skb;
2573 tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
Simon Kagstromc79992f2009-11-25 22:10:43 +00002574 td_ptr->tdesc0.len = cpu_to_le16(pktlen);
Dave Jones2cf71d22009-07-23 18:11:12 -07002575 td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
2576 td_ptr->td_buf[0].pa_high = 0;
Simon Kagstromc79992f2009-11-25 22:10:43 +00002577 td_ptr->td_buf[0].size = cpu_to_le16(pktlen);
2578
2579 /* Handle fragments */
2580 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2581 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2582
2583 tdinfo->skb_dma[i + 1] = pci_map_page(vptr->pdev, frag->page,
2584 frag->page_offset, frag->size,
2585 PCI_DMA_TODEVICE);
2586
2587 td_ptr->td_buf[i + 1].pa_low = cpu_to_le32(tdinfo->skb_dma[i + 1]);
2588 td_ptr->td_buf[i + 1].pa_high = 0;
2589 td_ptr->td_buf[i + 1].size = cpu_to_le16(frag->size);
2590 }
2591 tdinfo->nskb_dma = i + 1;
Dave Jones2cf71d22009-07-23 18:11:12 -07002592
2593 td_ptr->tdesc1.cmd = TCPLS_NORMAL + (tdinfo->nskb_dma + 1) * 16;
2594
Jesse Grosseab6d182010-10-20 13:56:03 +00002595 if (vlan_tx_tag_present(skb)) {
Dave Jones2cf71d22009-07-23 18:11:12 -07002596 td_ptr->tdesc1.vlan = cpu_to_le16(vlan_tx_tag_get(skb));
2597 td_ptr->tdesc1.TCR |= TCR0_VETAG;
2598 }
2599
2600 /*
2601 * Handle hardware checksum
2602 */
Joe Perches8e95a202009-12-03 07:58:21 +00002603 if ((dev->features & NETIF_F_IP_CSUM) &&
2604 (skb->ip_summed == CHECKSUM_PARTIAL)) {
Dave Jones2cf71d22009-07-23 18:11:12 -07002605 const struct iphdr *ip = ip_hdr(skb);
2606 if (ip->protocol == IPPROTO_TCP)
2607 td_ptr->tdesc1.TCR |= TCR0_TCPCK;
2608 else if (ip->protocol == IPPROTO_UDP)
2609 td_ptr->tdesc1.TCR |= (TCR0_UDPCK);
2610 td_ptr->tdesc1.TCR |= TCR0_IPCK;
2611 }
Dave Jones2cf71d22009-07-23 18:11:12 -07002612
Simon Kagstromc79992f2009-11-25 22:10:43 +00002613 prev = index - 1;
2614 if (prev < 0)
2615 prev = vptr->options.numtx - 1;
2616 td_ptr->tdesc0.len |= OWNED_BY_NIC;
2617 vptr->tx.used[qnum]++;
2618 vptr->tx.curr[qnum] = (index + 1) % vptr->options.numtx;
Dave Jones2cf71d22009-07-23 18:11:12 -07002619
Simon Kagstromc79992f2009-11-25 22:10:43 +00002620 if (AVAIL_TD(vptr, qnum) < 1)
2621 netif_stop_queue(dev);
Dave Jones2cf71d22009-07-23 18:11:12 -07002622
Simon Kagstromc79992f2009-11-25 22:10:43 +00002623 td_ptr = &(vptr->tx.rings[qnum][prev]);
2624 td_ptr->td_buf[0].size |= TD_QUEUE;
2625 mac_tx_queue_wake(vptr->mac_regs, qnum);
Dave Jones2cf71d22009-07-23 18:11:12 -07002626
Dave Jones2cf71d22009-07-23 18:11:12 -07002627 spin_unlock_irqrestore(&vptr->lock, flags);
2628out:
2629 return NETDEV_TX_OK;
2630}
2631
2632
Stephen Hemminger39a11bd2008-11-19 22:19:33 -08002633static const struct net_device_ops velocity_netdev_ops = {
2634 .ndo_open = velocity_open,
2635 .ndo_stop = velocity_close,
Stephen Hemminger00829822008-11-20 20:14:53 -08002636 .ndo_start_xmit = velocity_xmit,
Stephen Hemminger39a11bd2008-11-19 22:19:33 -08002637 .ndo_get_stats = velocity_get_stats,
2638 .ndo_validate_addr = eth_validate_addr,
Stephen Hemmingerfe96aaa2009-01-09 11:13:14 +00002639 .ndo_set_mac_address = eth_mac_addr,
Stephen Hemminger39a11bd2008-11-19 22:19:33 -08002640 .ndo_set_multicast_list = velocity_set_multi,
2641 .ndo_change_mtu = velocity_change_mtu,
2642 .ndo_do_ioctl = velocity_ioctl,
2643 .ndo_vlan_rx_add_vid = velocity_vlan_rx_add_vid,
2644 .ndo_vlan_rx_kill_vid = velocity_vlan_rx_kill_vid,
2645 .ndo_vlan_rx_register = velocity_vlan_rx_register,
2646};
2647
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648/**
Dave Jones2cf71d22009-07-23 18:11:12 -07002649 * velocity_init_info - init private data
2650 * @pdev: PCI device
2651 * @vptr: Velocity info
2652 * @info: Board type
2653 *
2654 * Set up the initial velocity_info struct for the device that has been
2655 * discovered.
2656 */
2657static void __devinit velocity_init_info(struct pci_dev *pdev,
2658 struct velocity_info *vptr,
2659 const struct velocity_info_tbl *info)
2660{
2661 memset(vptr, 0, sizeof(struct velocity_info));
2662
2663 vptr->pdev = pdev;
2664 vptr->chip_id = info->chip_id;
2665 vptr->tx.numq = info->txqueue;
2666 vptr->multicast_limit = MCAM_SIZE;
2667 spin_lock_init(&vptr->lock);
Dave Jones2cf71d22009-07-23 18:11:12 -07002668}
2669
2670/**
2671 * velocity_get_pci_info - retrieve PCI info for device
2672 * @vptr: velocity device
2673 * @pdev: PCI device it matches
2674 *
2675 * Retrieve the PCI configuration space data that interests us from
2676 * the kernel PCI layer
2677 */
2678static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
2679{
2680 vptr->rev_id = pdev->revision;
2681
2682 pci_set_master(pdev);
2683
2684 vptr->ioaddr = pci_resource_start(pdev, 0);
2685 vptr->memaddr = pci_resource_start(pdev, 1);
2686
2687 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2688 dev_err(&pdev->dev,
2689 "region #0 is not an I/O resource, aborting.\n");
2690 return -EINVAL;
2691 }
2692
2693 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
2694 dev_err(&pdev->dev,
2695 "region #1 is an I/O resource, aborting.\n");
2696 return -EINVAL;
2697 }
2698
2699 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
2700 dev_err(&pdev->dev, "region #1 is too small.\n");
2701 return -EINVAL;
2702 }
2703 vptr->pdev = pdev;
2704
2705 return 0;
2706}
2707
2708/**
2709 * velocity_print_info - per driver data
2710 * @vptr: velocity
2711 *
2712 * Print per driver data as the kernel driver finds Velocity
2713 * hardware
2714 */
2715static void __devinit velocity_print_info(struct velocity_info *vptr)
2716{
2717 struct net_device *dev = vptr->dev;
2718
2719 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
H Hartley Sweetenaa7c68a2009-12-29 20:04:14 -08002720 printk(KERN_INFO "%s: Ethernet Address: %pM\n",
2721 dev->name, dev->dev_addr);
Dave Jones2cf71d22009-07-23 18:11:12 -07002722}
2723
2724static u32 velocity_get_link(struct net_device *dev)
2725{
2726 struct velocity_info *vptr = netdev_priv(dev);
2727 struct mac_regs __iomem *regs = vptr->mac_regs;
2728 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
2729}
2730
2731
2732/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 * velocity_found1 - set up discovered velocity card
2734 * @pdev: PCI device
2735 * @ent: PCI device table entry that matched
2736 *
2737 * Configure a discovered adapter from scratch. Return a negative
2738 * errno error code on failure paths.
2739 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
2741{
2742 static int first = 1;
2743 struct net_device *dev;
2744 int i;
Sven Hartge07b5f6a2008-10-23 13:03:44 +00002745 const char *drv_string;
Jeff Garzikcabb7662006-06-27 09:25:28 -04002746 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 struct velocity_info *vptr;
Dave Jonesc4067402009-07-20 17:35:21 +00002748 struct mac_regs __iomem *regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 int ret = -ENOMEM;
2750
Jeff Garzike54f4892006-06-27 09:20:08 -04002751 /* FIXME: this driver, like almost all other ethernet drivers,
2752 * can support more than MAX_UNITS.
2753 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 if (velocity_nics >= MAX_UNITS) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002755 dev_notice(&pdev->dev, "already found %d NICs.\n",
Jeff Garzike54f4892006-06-27 09:20:08 -04002756 velocity_nics);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 return -ENODEV;
2758 }
2759
2760 dev = alloc_etherdev(sizeof(struct velocity_info));
Jeff Garzike54f4892006-06-27 09:20:08 -04002761 if (!dev) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04002762 dev_err(&pdev->dev, "allocate net device failed.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 goto out;
2764 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002765
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 /* Chain it all together */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002767
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 SET_NETDEV_DEV(dev, &pdev->dev);
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04002769 vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770
2771
2772 if (first) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002773 printk(KERN_INFO "%s Ver. %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
2775 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
2776 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
2777 first = 0;
2778 }
2779
2780 velocity_init_info(pdev, vptr, info);
2781
2782 vptr->dev = dev;
2783
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 ret = pci_enable_device(pdev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002785 if (ret < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 goto err_free_dev;
2787
Kulikov Vasiliy889635f2010-08-03 05:43:18 +00002788 dev->irq = pdev->irq;
2789
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 ret = velocity_get_pci_info(vptr, pdev);
2791 if (ret < 0) {
Jeff Garzike54f4892006-06-27 09:20:08 -04002792 /* error message already printed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 goto err_disable;
2794 }
2795
2796 ret = pci_request_regions(pdev, VELOCITY_NAME);
2797 if (ret < 0) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -04002798 dev_err(&pdev->dev, "No PCI resources.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 goto err_disable;
2800 }
2801
Jeff Garzikcabb7662006-06-27 09:25:28 -04002802 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 if (regs == NULL) {
2804 ret = -EIO;
2805 goto err_release_res;
2806 }
2807
2808 vptr->mac_regs = regs;
2809
2810 mac_wol_reset(regs);
2811
2812 dev->base_addr = vptr->ioaddr;
2813
2814 for (i = 0; i < 6; i++)
2815 dev->dev_addr[i] = readb(&regs->PAR[i]);
2816
2817
Sven Hartge07b5f6a2008-10-23 13:03:44 +00002818 drv_string = dev_driver_string(&pdev->dev);
2819
2820 velocity_get_options(&vptr->options, velocity_nics, drv_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002822 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 * Mask out the options cannot be set to the chip
2824 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002825
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 vptr->options.flags &= info->flags;
2827
2828 /*
2829 * Enable the chip specified capbilities
2830 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002831
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
2833
2834 vptr->wol_opts = vptr->options.wol_opts;
2835 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
2836
2837 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
2838
2839 dev->irq = pdev->irq;
Stephen Hemminger39a11bd2008-11-19 22:19:33 -08002840 dev->netdev_ops = &velocity_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 dev->ethtool_ops = &velocity_ethtool_ops;
Simon Kagstromdfff7142009-11-25 22:10:26 +00002842 netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
Stephen Hemminger501e4d22007-08-24 13:56:49 -07002843
Francois Romieud4f73c82008-04-24 23:32:33 +02002844 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
David S. Millerde2b96f2010-09-07 13:49:44 -07002845 NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
2847 ret = register_netdev(dev);
2848 if (ret < 0)
2849 goto err_iounmap;
2850
Séguier Régisd3b238a2009-06-16 11:25:49 +00002851 if (!velocity_get_link(dev)) {
Francois Romieu8a22ddd2006-06-23 00:47:06 +02002852 netif_carrier_off(dev);
Séguier Régisd3b238a2009-06-16 11:25:49 +00002853 vptr->mii_status |= VELOCITY_LINK_FAIL;
2854 }
Francois Romieu8a22ddd2006-06-23 00:47:06 +02002855
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 velocity_print_info(vptr);
2857 pci_set_drvdata(pdev, dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002858
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859 /* and leave the chip powered down */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002860
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 pci_set_power_state(pdev, PCI_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 velocity_nics++;
2863out:
2864 return ret;
2865
2866err_iounmap:
2867 iounmap(regs);
2868err_release_res:
2869 pci_release_regions(pdev);
2870err_disable:
2871 pci_disable_device(pdev);
2872err_free_dev:
2873 free_netdev(dev);
2874 goto out;
2875}
2876
Dave Jones2cf71d22009-07-23 18:11:12 -07002877
2878#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879/**
Dave Jones2cf71d22009-07-23 18:11:12 -07002880 * wol_calc_crc - WOL CRC
2881 * @pattern: data pattern
2882 * @mask_pattern: mask
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 *
Dave Jones2cf71d22009-07-23 18:11:12 -07002884 * Compute the wake on lan crc hashes for the packet header
2885 * we are interested in.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 */
Dave Jones2cf71d22009-07-23 18:11:12 -07002887static u16 wol_calc_crc(int size, u8 *pattern, u8 *mask_pattern)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888{
Dave Jones2cf71d22009-07-23 18:11:12 -07002889 u16 crc = 0xFFFF;
2890 u8 mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 int i, j;
2892
Dave Jones2cf71d22009-07-23 18:11:12 -07002893 for (i = 0; i < size; i++) {
2894 mask = mask_pattern[i];
2895
2896 /* Skip this loop if the mask equals to zero */
2897 if (mask == 0x00)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899
Dave Jones2cf71d22009-07-23 18:11:12 -07002900 for (j = 0; j < 8; j++) {
2901 if ((mask & 0x01) == 0) {
2902 mask >>= 1;
2903 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 }
Dave Jones2cf71d22009-07-23 18:11:12 -07002905 mask >>= 1;
2906 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 }
2908 }
Dave Jones2cf71d22009-07-23 18:11:12 -07002909 /* Finally, invert the result once to get the correct data */
2910 crc = ~crc;
2911 return bitrev32(crc) >> 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912}
2913
2914/**
Dave Jones2cf71d22009-07-23 18:11:12 -07002915 * velocity_set_wol - set up for wake on lan
2916 * @vptr: velocity to set WOL status on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 *
Dave Jones2cf71d22009-07-23 18:11:12 -07002918 * Set a card up for wake on lan either by unicast or by
2919 * ARP packet.
2920 *
2921 * FIXME: check static buffer is safe here
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922 */
Dave Jones2cf71d22009-07-23 18:11:12 -07002923static int velocity_set_wol(struct velocity_info *vptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924{
Dave Jonesc4067402009-07-20 17:35:21 +00002925 struct mac_regs __iomem *regs = vptr->mac_regs;
Dave Jones2cf71d22009-07-23 18:11:12 -07002926 static u8 buf[256];
2927 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928
Dave Jones2cf71d22009-07-23 18:11:12 -07002929 static u32 mask_pattern[2][4] = {
2930 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
2931 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
2932 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933
Dave Jones2cf71d22009-07-23 18:11:12 -07002934 writew(0xFFFF, &regs->WOLCRClr);
2935 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
2936 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937
Dave Jones2cf71d22009-07-23 18:11:12 -07002938 /*
2939 if (vptr->wol_opts & VELOCITY_WOL_PHY)
2940 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
2941 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942
Dave Jones2cf71d22009-07-23 18:11:12 -07002943 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
2944 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002945
Dave Jones2cf71d22009-07-23 18:11:12 -07002946 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
2947 struct arp_packet *arp = (struct arp_packet *) buf;
2948 u16 crc;
2949 memset(buf, 0, sizeof(struct arp_packet) + 7);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002950
Dave Jones2cf71d22009-07-23 18:11:12 -07002951 for (i = 0; i < 4; i++)
2952 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953
Dave Jones2cf71d22009-07-23 18:11:12 -07002954 arp->type = htons(ETH_P_ARP);
2955 arp->ar_op = htons(1);
2956
2957 memcpy(arp->ar_tip, vptr->ip_addr, 4);
2958
2959 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
2960 (u8 *) & mask_pattern[0][0]);
2961
2962 writew(crc, &regs->PatternCRC[0]);
2963 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
2964 }
2965
2966 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
2967 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
2968
2969 writew(0x0FFF, &regs->WOLSRClr);
2970
2971 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
2972 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
Francois Romieu3a7f8682010-04-06 14:24:53 -07002973 MII_REG_BITS_ON(AUXCR_MDPPS, MII_NCONFIG, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07002974
Francois Romieu3a7f8682010-04-06 14:24:53 -07002975 MII_REG_BITS_OFF(ADVERTISE_1000FULL | ADVERTISE_1000HALF, MII_CTRL1000, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07002976 }
2977
2978 if (vptr->mii_status & VELOCITY_SPEED_1000)
Francois Romieu3a7f8682010-04-06 14:24:53 -07002979 MII_REG_BITS_ON(BMCR_ANRESTART, MII_BMCR, vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07002980
2981 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2982
2983 {
2984 u8 GCR;
2985 GCR = readb(&regs->CHIPGCR);
2986 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
2987 writeb(GCR, &regs->CHIPGCR);
2988 }
2989
2990 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
2991 /* Turn on SWPTAG just before entering power mode */
2992 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
2993 /* Go to bed ..... */
2994 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
2995
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 return 0;
2997}
2998
2999/**
Dave Jones2cf71d22009-07-23 18:11:12 -07003000 * velocity_save_context - save registers
3001 * @vptr: velocity
3002 * @context: buffer for stored context
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 *
Dave Jones2cf71d22009-07-23 18:11:12 -07003004 * Retrieve the current configuration from the velocity hardware
3005 * and stash it in the context structure, for use by the context
3006 * restore functions. This allows us to save things we need across
3007 * power down states
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 */
Dave Jones2cf71d22009-07-23 18:11:12 -07003009static void velocity_save_context(struct velocity_info *vptr, struct velocity_context *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010{
Dave Jones2cf71d22009-07-23 18:11:12 -07003011 struct mac_regs __iomem *regs = vptr->mac_regs;
3012 u16 i;
3013 u8 __iomem *ptr = (u8 __iomem *)regs;
3014
3015 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
3016 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3017
3018 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
3019 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3020
3021 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3022 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3023
3024}
3025
3026static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
3027{
3028 struct net_device *dev = pci_get_drvdata(pdev);
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003029 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 unsigned long flags;
Francois Romieu580a6902008-07-11 00:03:44 +02003031
Dave Jones2cf71d22009-07-23 18:11:12 -07003032 if (!netif_running(vptr->dev))
3033 return 0;
Francois Romieu580a6902008-07-11 00:03:44 +02003034
Dave Jones2cf71d22009-07-23 18:11:12 -07003035 netif_device_detach(vptr->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036
3037 spin_lock_irqsave(&vptr->lock, flags);
Dave Jones2cf71d22009-07-23 18:11:12 -07003038 pci_save_state(pdev);
3039#ifdef ETHTOOL_GWOL
3040 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3041 velocity_get_ip(vptr);
3042 velocity_save_context(vptr, &vptr->context);
3043 velocity_shutdown(vptr);
3044 velocity_set_wol(vptr);
3045 pci_enable_wake(pdev, PCI_D3hot, 1);
3046 pci_set_power_state(pdev, PCI_D3hot);
3047 } else {
3048 velocity_save_context(vptr, &vptr->context);
3049 velocity_shutdown(vptr);
3050 pci_disable_device(pdev);
3051 pci_set_power_state(pdev, pci_choose_state(pdev, state));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 }
Dave Jones2cf71d22009-07-23 18:11:12 -07003053#else
3054 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3055#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 spin_unlock_irqrestore(&vptr->lock, flags);
Dave Jones2cf71d22009-07-23 18:11:12 -07003057 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058}
3059
3060/**
Dave Jones2cf71d22009-07-23 18:11:12 -07003061 * velocity_restore_context - restore registers
3062 * @vptr: velocity
3063 * @context: buffer for stored context
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 *
Dave Jones2cf71d22009-07-23 18:11:12 -07003065 * Reload the register configuration from the velocity context
3066 * created by velocity_save_context.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 */
Dave Jones2cf71d22009-07-23 18:11:12 -07003068static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069{
Dave Jones2cf71d22009-07-23 18:11:12 -07003070 struct mac_regs __iomem *regs = vptr->mac_regs;
3071 int i;
3072 u8 __iomem *ptr = (u8 __iomem *)regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073
Dave Jones2cf71d22009-07-23 18:11:12 -07003074 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4)
3075 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076
Dave Jones2cf71d22009-07-23 18:11:12 -07003077 /* Just skip cr0 */
3078 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3079 /* Clear */
3080 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3081 /* Set */
3082 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 }
3084
Dave Jones2cf71d22009-07-23 18:11:12 -07003085 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4)
3086 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3087
3088 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3089 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3090
3091 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++)
3092 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3093}
3094
3095static int velocity_resume(struct pci_dev *pdev)
3096{
3097 struct net_device *dev = pci_get_drvdata(pdev);
3098 struct velocity_info *vptr = netdev_priv(dev);
3099 unsigned long flags;
3100 int i;
3101
3102 if (!netif_running(vptr->dev))
3103 return 0;
3104
3105 pci_set_power_state(pdev, PCI_D0);
3106 pci_enable_wake(pdev, 0, 0);
3107 pci_restore_state(pdev);
3108
3109 mac_wol_reset(vptr->mac_regs);
3110
3111 spin_lock_irqsave(&vptr->lock, flags);
3112 velocity_restore_context(vptr, &vptr->context);
3113 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 mac_disable_int(vptr->mac_regs);
3115
Simon Kagstromd6cade02010-02-09 23:37:54 +00003116 velocity_tx_srv(vptr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003117
Dave Jones2cf71d22009-07-23 18:11:12 -07003118 for (i = 0; i < vptr->tx.numq; i++) {
3119 if (vptr->tx.used[i])
3120 mac_tx_queue_wake(vptr->mac_regs, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 }
Dave Jones2cf71d22009-07-23 18:11:12 -07003122
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 mac_enable_int(vptr->mac_regs);
Dave Jones2cf71d22009-07-23 18:11:12 -07003124 spin_unlock_irqrestore(&vptr->lock, flags);
3125 netif_device_attach(vptr->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126
Dave Jones2cf71d22009-07-23 18:11:12 -07003127 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128}
Dave Jones2cf71d22009-07-23 18:11:12 -07003129#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003130
3131/*
3132 * Definition for our device driver. The PCI layer interface
3133 * uses this to handle all our card discover and plugging
3134 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135static struct pci_driver velocity_driver = {
3136 .name = VELOCITY_NAME,
3137 .id_table = velocity_id_table,
3138 .probe = velocity_found1,
3139 .remove = __devexit_p(velocity_remove1),
3140#ifdef CONFIG_PM
3141 .suspend = velocity_suspend,
3142 .resume = velocity_resume,
3143#endif
3144};
3145
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146
3147/**
3148 * velocity_ethtool_up - pre hook for ethtool
3149 * @dev: network device
3150 *
3151 * Called before an ethtool operation. We need to make sure the
3152 * chip is out of D3 state before we poke at it.
3153 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154static int velocity_ethtool_up(struct net_device *dev)
3155{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003156 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 if (!netif_running(dev))
3158 pci_set_power_state(vptr->pdev, PCI_D0);
3159 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003160}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003161
3162/**
3163 * velocity_ethtool_down - post hook for ethtool
3164 * @dev: network device
3165 *
3166 * Called after an ethtool operation. Restore the chip back to D3
3167 * state if it isn't running.
3168 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169static void velocity_ethtool_down(struct net_device *dev)
3170{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003171 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172 if (!netif_running(dev))
3173 pci_set_power_state(vptr->pdev, PCI_D3hot);
3174}
3175
3176static int velocity_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3177{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003178 struct velocity_info *vptr = netdev_priv(dev);
Dave Jonesc4067402009-07-20 17:35:21 +00003179 struct mac_regs __iomem *regs = vptr->mac_regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 u32 status;
3181 status = check_connection_type(vptr->mac_regs);
3182
Jay Cliburn59b693f2006-07-20 23:23:57 +02003183 cmd->supported = SUPPORTED_TP |
3184 SUPPORTED_Autoneg |
3185 SUPPORTED_10baseT_Half |
3186 SUPPORTED_10baseT_Full |
3187 SUPPORTED_100baseT_Half |
3188 SUPPORTED_100baseT_Full |
3189 SUPPORTED_1000baseT_Half |
3190 SUPPORTED_1000baseT_Full;
françois romieu15419222010-10-13 09:26:05 +00003191
3192 cmd->advertising = ADVERTISED_TP | ADVERTISED_Autoneg;
3193 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
3194 cmd->advertising |=
3195 ADVERTISED_10baseT_Half |
3196 ADVERTISED_10baseT_Full |
3197 ADVERTISED_100baseT_Half |
3198 ADVERTISED_100baseT_Full |
3199 ADVERTISED_1000baseT_Half |
3200 ADVERTISED_1000baseT_Full;
3201 } else {
3202 switch (vptr->options.spd_dpx) {
3203 case SPD_DPX_1000_FULL:
3204 cmd->advertising |= ADVERTISED_1000baseT_Full;
3205 break;
3206 case SPD_DPX_100_HALF:
3207 cmd->advertising |= ADVERTISED_100baseT_Half;
3208 break;
3209 case SPD_DPX_100_FULL:
3210 cmd->advertising |= ADVERTISED_100baseT_Full;
3211 break;
3212 case SPD_DPX_10_HALF:
3213 cmd->advertising |= ADVERTISED_10baseT_Half;
3214 break;
3215 case SPD_DPX_10_FULL:
3216 cmd->advertising |= ADVERTISED_10baseT_Full;
3217 break;
3218 default:
3219 break;
3220 }
3221 }
Jay Cliburn59b693f2006-07-20 23:23:57 +02003222 if (status & VELOCITY_SPEED_1000)
3223 cmd->speed = SPEED_1000;
3224 else if (status & VELOCITY_SPEED_100)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225 cmd->speed = SPEED_100;
3226 else
3227 cmd->speed = SPEED_10;
3228 cmd->autoneg = (status & VELOCITY_AUTONEG_ENABLE) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
3229 cmd->port = PORT_TP;
3230 cmd->transceiver = XCVR_INTERNAL;
3231 cmd->phy_address = readb(&regs->MIIADR) & 0x1F;
3232
3233 if (status & VELOCITY_DUPLEX_FULL)
3234 cmd->duplex = DUPLEX_FULL;
3235 else
3236 cmd->duplex = DUPLEX_HALF;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003237
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 return 0;
3239}
3240
3241static int velocity_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
3242{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003243 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 u32 curr_status;
3245 u32 new_status = 0;
3246 int ret = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04003247
Linus Torvalds1da177e2005-04-16 15:20:36 -07003248 curr_status = check_connection_type(vptr->mac_regs);
3249 curr_status &= (~VELOCITY_LINK_FAIL);
3250
3251 new_status |= ((cmd->autoneg) ? VELOCITY_AUTONEG_ENABLE : 0);
françois romieu15419222010-10-13 09:26:05 +00003252 new_status |= ((cmd->speed == SPEED_1000) ? VELOCITY_SPEED_1000 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253 new_status |= ((cmd->speed == SPEED_100) ? VELOCITY_SPEED_100 : 0);
3254 new_status |= ((cmd->speed == SPEED_10) ? VELOCITY_SPEED_10 : 0);
3255 new_status |= ((cmd->duplex == DUPLEX_FULL) ? VELOCITY_DUPLEX_FULL : 0);
3256
françois romieu15419222010-10-13 09:26:05 +00003257 if ((new_status & VELOCITY_AUTONEG_ENABLE) &&
3258 (new_status != (curr_status | VELOCITY_AUTONEG_ENABLE))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 ret = -EINVAL;
françois romieu15419222010-10-13 09:26:05 +00003260 } else {
3261 enum speed_opt spd_dpx;
3262
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;
3276
3277 vptr->options.spd_dpx = spd_dpx;
3278
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 velocity_set_media_mode(vptr, new_status);
françois romieu15419222010-10-13 09:26:05 +00003280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281
3282 return ret;
3283}
3284
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3286{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003287 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288 strcpy(info->driver, VELOCITY_NAME);
3289 strcpy(info->version, VELOCITY_VERSION);
3290 strcpy(info->bus_info, pci_name(vptr->pdev));
3291}
3292
3293static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3294{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003295 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 wol->supported = WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP;
3297 wol->wolopts |= WAKE_MAGIC;
3298 /*
3299 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3300 wol.wolopts|=WAKE_PHY;
3301 */
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);
3307}
3308
3309static int velocity_ethtool_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
3310{
Jeff Garzik8ab6f3f2006-06-27 08:56:23 -04003311 struct velocity_info *vptr = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312
3313 if (!(wol->wolopts & (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_ARP)))
3314 return -EFAULT;
3315 vptr->wol_opts = VELOCITY_WOL_MAGIC;
3316
3317 /*
3318 if (wol.wolopts & WAKE_PHY) {
3319 vptr->wol_opts|=VELOCITY_WOL_PHY;
3320 vptr->flags |=VELOCITY_FLAGS_WOL_ENABLED;
3321 }
3322 */
3323
3324 if (wol->wolopts & WAKE_MAGIC) {
3325 vptr->wol_opts |= VELOCITY_WOL_MAGIC;
3326 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3327 }
3328 if (wol->wolopts & WAKE_UCAST) {
3329 vptr->wol_opts |= VELOCITY_WOL_UCAST;
3330 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3331 }
3332 if (wol->wolopts & WAKE_ARP) {
3333 vptr->wol_opts |= VELOCITY_WOL_ARP;
3334 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
3335 }
3336 memcpy(vptr->wol_passwd, wol->sopass, 6);
3337 return 0;
3338}
3339
3340static u32 velocity_get_msglevel(struct net_device *dev)
3341{
3342 return msglevel;
3343}
3344
3345static void velocity_set_msglevel(struct net_device *dev, u32 value)
3346{
3347 msglevel = value;
3348}
3349
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00003350static int get_pending_timer_val(int val)
3351{
3352 int mult_bits = val >> 6;
3353 int mult = 1;
3354
3355 switch (mult_bits)
3356 {
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;
3366 }
3367
3368 return (val & 0x3f) * mult;
3369}
3370
3371static void set_pending_timer_val(int *val, u32 us)
3372{
3373 u8 mult = 0;
3374 u8 shift = 0;
3375
3376 if (us >= 0x3f) {
3377 mult = 1; /* mult with 4 */
3378 shift = 2;
3379 }
3380 if (us >= 0x3f * 4) {
3381 mult = 2; /* mult with 16 */
3382 shift = 4;
3383 }
3384 if (us >= 0x3f * 16) {
3385 mult = 3; /* mult with 64 */
3386 shift = 6;
3387 }
3388
3389 *val = (mult << 6) | ((us >> shift) & 0x3f);
3390}
3391
3392
3393static int velocity_get_coalesce(struct net_device *dev,
3394 struct ethtool_coalesce *ecmd)
3395{
3396 struct velocity_info *vptr = netdev_priv(dev);
3397
3398 ecmd->tx_max_coalesced_frames = vptr->options.tx_intsup;
3399 ecmd->rx_max_coalesced_frames = vptr->options.rx_intsup;
3400
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);
3403
3404 return 0;
3405}
3406
3407static int velocity_set_coalesce(struct net_device *dev,
3408 struct ethtool_coalesce *ecmd)
3409{
3410 struct velocity_info *vptr = netdev_priv(dev);
3411 int max_us = 0x3f * 64;
Simon Kagstrom39c2ff42010-02-09 23:38:07 +00003412 unsigned long flags;
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00003413
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;
3419
3420 if (ecmd->tx_max_coalesced_frames > 0xff)
3421 return -EINVAL;
3422 if (ecmd->rx_max_coalesced_frames > 0xff)
3423 return -EINVAL;
3424
3425 vptr->options.rx_intsup = ecmd->rx_max_coalesced_frames;
3426 vptr->options.tx_intsup = ecmd->tx_max_coalesced_frames;
3427
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);
3432
3433 /* Setup the interrupt suppression and queue timers */
Simon Kagstrom39c2ff42010-02-09 23:38:07 +00003434 spin_lock_irqsave(&vptr->lock, flags);
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00003435 mac_disable_int(vptr->mac_regs);
3436 setup_adaptive_interrupts(vptr);
3437 setup_queue_timers(vptr);
3438
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);
Simon Kagstrom39c2ff42010-02-09 23:38:07 +00003442 spin_unlock_irqrestore(&vptr->lock, flags);
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00003443
3444 return 0;
3445}
3446
Jeff Garzik7282d492006-09-13 14:30:00 -04003447static const struct ethtool_ops velocity_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 .get_settings = velocity_get_settings,
3449 .set_settings = velocity_set_settings,
3450 .get_drvinfo = velocity_get_drvinfo,
Simon Kagstromb06f78f2009-11-25 22:10:52 +00003451 .set_tx_csum = ethtool_op_set_tx_csum,
3452 .get_tx_csum = ethtool_op_get_tx_csum,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 .get_wol = velocity_ethtool_get_wol,
3454 .set_wol = velocity_ethtool_set_wol,
3455 .get_msglevel = velocity_get_msglevel,
3456 .set_msglevel = velocity_set_msglevel,
Simon Kagstromc79992f2009-11-25 22:10:43 +00003457 .set_sg = ethtool_op_set_sg,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 .get_link = velocity_get_link,
Simon Kagstrom6dfc4b92009-11-25 22:10:12 +00003459 .get_coalesce = velocity_get_coalesce,
3460 .set_coalesce = velocity_set_coalesce,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 .begin = velocity_ethtool_up,
3462 .complete = velocity_ethtool_down
3463};
3464
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465#ifdef CONFIG_PM
Randy Dunlapce9f7fe2006-12-18 21:21:10 -08003466#ifdef CONFIG_INET
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3468{
3469 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
Denis V. Luneva3374992008-02-28 20:44:27 -08003470 struct net_device *dev = ifa->ifa_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471
Ben Hutchings516b4df2009-10-28 04:01:46 -07003472 if (dev_net(dev) == &init_net &&
3473 dev->netdev_ops == &velocity_netdev_ops)
3474 velocity_get_ip(netdev_priv(dev));
Denis V. Luneva3374992008-02-28 20:44:27 -08003475
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476 return NOTIFY_DONE;
3477}
Dave Jones2cf71d22009-07-23 18:11:12 -07003478#endif /* CONFIG_INET */
3479#endif /* CONFIG_PM */
Randy Dunlapce9f7fe2006-12-18 21:21:10 -08003480
Dave Jones2cf71d22009-07-23 18:11:12 -07003481#if defined(CONFIG_PM) && defined(CONFIG_INET)
3482static struct notifier_block velocity_inetaddr_notifier = {
3483 .notifier_call = velocity_netdev_event,
3484};
3485
3486static void velocity_register_notifier(void)
3487{
3488 register_inetaddr_notifier(&velocity_inetaddr_notifier);
3489}
3490
3491static void velocity_unregister_notifier(void)
3492{
3493 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
3494}
3495
3496#else
3497
3498#define velocity_register_notifier() do {} while (0)
3499#define velocity_unregister_notifier() do {} while (0)
3500
3501#endif /* defined(CONFIG_PM) && defined(CONFIG_INET) */
3502
3503/**
3504 * velocity_init_module - load time function
3505 *
3506 * Called when the velocity module is loaded. The PCI driver
3507 * is registered with the PCI layer, and in turn will call
3508 * the probe functions for each velocity adapter installed
3509 * in the system.
3510 */
3511static int __init velocity_init_module(void)
3512{
3513 int ret;
3514
3515 velocity_register_notifier();
3516 ret = pci_register_driver(&velocity_driver);
3517 if (ret < 0)
3518 velocity_unregister_notifier();
3519 return ret;
3520}
3521
3522/**
3523 * velocity_cleanup - module unload
3524 *
3525 * When the velocity hardware is unloaded this function is called.
3526 * It will clean up the notifiers and the unregister the PCI
3527 * driver interface for this hardware. This in turn cleans up
3528 * all discovered interfaces before returning from the function
3529 */
3530static void __exit velocity_cleanup_module(void)
3531{
3532 velocity_unregister_notifier();
3533 pci_unregister_driver(&velocity_driver);
3534}
3535
3536module_init(velocity_init_module);
3537module_exit(velocity_cleanup_module);