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