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