blob: d9258d42090c30e93fa56a3e1cab1be0d739d375 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* typhoon.c: A Linux Ethernet device driver for 3Com 3CR990 family of NICs */
2/*
3 Written 2002-2004 by David Dillow <dave@thedillows.org>
4 Based on code written 1998-2000 by Donald Becker <becker@scyld.com> and
5 Linux 2.2.x driver by David P. McLean <davidpmclean@yahoo.com>.
6
7 This software may be used and distributed according to the terms of
8 the GNU General Public License (GPL), incorporated herein by reference.
9 Drivers based on or derived from this code fall under the GPL and must
10 retain the authorship, copyright and license notice. This file is not
11 a complete program and may only be used when the entire operating
12 system is licensed under the GPL.
13
14 This software is available on a public web site. It may enable
15 cryptographic capabilities of the 3Com hardware, and may be
16 exported from the United States under License Exception "TSU"
17 pursuant to 15 C.F.R. Section 740.13(e).
18
19 This work was funded by the National Library of Medicine under
20 the Department of Energy project number 0274DD06D1 and NLM project
21 number Y1-LM-2015-01.
22
23 This driver is designed for the 3Com 3CR990 Family of cards with the
24 3XP Processor. It has been tested on x86 and sparc64.
25
26 KNOWN ISSUES:
27 *) The current firmware always strips the VLAN tag off, even if
28 we tell it not to. You should filter VLANs at the switch
29 as a workaround (good practice in any event) until we can
30 get this fixed.
31 *) Cannot DMA Rx packets to a 2 byte aligned address. Also firmware
32 issue. Hopefully 3Com will fix it.
33 *) Waiting for a command response takes 8ms due to non-preemptable
34 polling. Only significant for getting stats and creating
35 SAs, but an ugly wart never the less.
36
37 TODO:
38 *) Doesn't do IPSEC offloading. Yet. Keep yer pants on, it's coming.
39 *) Add more support for ethtool (especially for NIC stats)
40 *) Allow disabling of RX checksum offloading
41 *) Fix MAC changing to work while the interface is up
42 (Need to put commands on the TX ring, which changes
43 the locking)
44 *) Add in FCS to {rx,tx}_bytes, since the hardware doesn't. See
45 http://oss.sgi.com/cgi-bin/mesg.cgi?a=netdev&i=20031215152211.7003fe8e.rddunlap%40osdl.org
46*/
47
48/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
49 * Setting to > 1518 effectively disables this feature.
50 */
51static int rx_copybreak = 200;
52
53/* Should we use MMIO or Port IO?
54 * 0: Port IO
55 * 1: MMIO
56 * 2: Try MMIO, fallback to Port IO
57 */
58static unsigned int use_mmio = 2;
59
60/* end user-configurable values */
61
62/* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
63 */
64static const int multicast_filter_limit = 32;
65
66/* Operational parameters that are set at compile time. */
67
68/* Keep the ring sizes a power of two for compile efficiency.
69 * The compiler will convert <unsigned>'%'<2^N> into a bit mask.
70 * Making the Tx ring too large decreases the effectiveness of channel
71 * bonding and packet priority.
72 * There are no ill effects from too-large receive rings.
73 *
74 * We don't currently use the Hi Tx ring so, don't make it very big.
75 *
76 * Beware that if we start using the Hi Tx ring, we will need to change
77 * typhoon_num_free_tx() and typhoon_tx_complete() to account for that.
78 */
79#define TXHI_ENTRIES 2
80#define TXLO_ENTRIES 128
81#define RX_ENTRIES 32
82#define COMMAND_ENTRIES 16
83#define RESPONSE_ENTRIES 32
84
85#define COMMAND_RING_SIZE (COMMAND_ENTRIES * sizeof(struct cmd_desc))
86#define RESPONSE_RING_SIZE (RESPONSE_ENTRIES * sizeof(struct resp_desc))
87
88/* The 3XP will preload and remove 64 entries from the free buffer
89 * list, and we need one entry to keep the ring from wrapping, so
90 * to keep this a power of two, we use 128 entries.
91 */
92#define RXFREE_ENTRIES 128
93#define RXENT_ENTRIES (RXFREE_ENTRIES - 1)
94
95/* Operational parameters that usually are not changed. */
96
97/* Time in jiffies before concluding the transmitter is hung. */
98#define TX_TIMEOUT (2*HZ)
99
100#define PKT_BUF_SZ 1536
101
102#define DRV_MODULE_NAME "typhoon"
103#define DRV_MODULE_VERSION "1.5.7"
104#define DRV_MODULE_RELDATE "05/01/07"
105#define PFX DRV_MODULE_NAME ": "
106#define ERR_PFX KERN_ERR PFX
107
108#include <linux/module.h>
109#include <linux/kernel.h>
110#include <linux/string.h>
111#include <linux/timer.h>
112#include <linux/errno.h>
113#include <linux/ioport.h>
114#include <linux/slab.h>
115#include <linux/interrupt.h>
116#include <linux/pci.h>
117#include <linux/netdevice.h>
118#include <linux/etherdevice.h>
119#include <linux/skbuff.h>
120#include <linux/init.h>
121#include <linux/delay.h>
122#include <linux/ethtool.h>
123#include <linux/if_vlan.h>
124#include <linux/crc32.h>
125#include <linux/bitops.h>
126#include <asm/processor.h>
127#include <asm/io.h>
128#include <asm/uaccess.h>
129#include <linux/in6.h>
130#include <asm/checksum.h>
131#include <linux/version.h>
132#include <linux/dma-mapping.h>
133
134#include "typhoon.h"
135#include "typhoon-firmware.h"
136
Randy Dunlape19360f2006-04-10 23:22:06 -0700137static const char version[] __devinitdata =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 "typhoon.c: version " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
139
140MODULE_AUTHOR("David Dillow <dave@thedillows.org>");
141MODULE_VERSION(DRV_MODULE_VERSION);
142MODULE_LICENSE("GPL");
143MODULE_DESCRIPTION("3Com Typhoon Family (3C990, 3CR990, and variants)");
144MODULE_PARM_DESC(rx_copybreak, "Packets smaller than this are copied and "
145 "the buffer given back to the NIC. Default "
146 "is 200.");
147MODULE_PARM_DESC(use_mmio, "Use MMIO (1) or PIO(0) to access the NIC. "
148 "Default is to try MMIO and fallback to PIO.");
149module_param(rx_copybreak, int, 0);
150module_param(use_mmio, int, 0);
151
152#if defined(NETIF_F_TSO) && MAX_SKB_FRAGS > 32
153#warning Typhoon only supports 32 entries in its SG list for TSO, disabling TSO
154#undef NETIF_F_TSO
155#endif
156
157#if TXLO_ENTRIES <= (2 * MAX_SKB_FRAGS)
158#error TX ring too small!
159#endif
160
161struct typhoon_card_info {
162 char *name;
163 int capabilities;
164};
165
166#define TYPHOON_CRYPTO_NONE 0x00
167#define TYPHOON_CRYPTO_DES 0x01
168#define TYPHOON_CRYPTO_3DES 0x02
169#define TYPHOON_CRYPTO_VARIABLE 0x04
170#define TYPHOON_FIBER 0x08
171#define TYPHOON_WAKEUP_NEEDS_RESET 0x10
172
173enum typhoon_cards {
174 TYPHOON_TX = 0, TYPHOON_TX95, TYPHOON_TX97, TYPHOON_SVR,
175 TYPHOON_SVR95, TYPHOON_SVR97, TYPHOON_TXM, TYPHOON_BSVR,
176 TYPHOON_FX95, TYPHOON_FX97, TYPHOON_FX95SVR, TYPHOON_FX97SVR,
177 TYPHOON_FXM,
178};
179
180/* directly indexed by enum typhoon_cards, above */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500181static const struct typhoon_card_info typhoon_card_info[] __devinitdata = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 { "3Com Typhoon (3C990-TX)",
183 TYPHOON_CRYPTO_NONE},
184 { "3Com Typhoon (3CR990-TX-95)",
185 TYPHOON_CRYPTO_DES},
186 { "3Com Typhoon (3CR990-TX-97)",
187 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
188 { "3Com Typhoon (3C990SVR)",
189 TYPHOON_CRYPTO_NONE},
190 { "3Com Typhoon (3CR990SVR95)",
191 TYPHOON_CRYPTO_DES},
192 { "3Com Typhoon (3CR990SVR97)",
193 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES},
194 { "3Com Typhoon2 (3C990B-TX-M)",
195 TYPHOON_CRYPTO_VARIABLE},
196 { "3Com Typhoon2 (3C990BSVR)",
197 TYPHOON_CRYPTO_VARIABLE},
198 { "3Com Typhoon (3CR990-FX-95)",
199 TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
200 { "3Com Typhoon (3CR990-FX-97)",
201 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
202 { "3Com Typhoon (3CR990-FX-95 Server)",
203 TYPHOON_CRYPTO_DES | TYPHOON_FIBER},
204 { "3Com Typhoon (3CR990-FX-97 Server)",
205 TYPHOON_CRYPTO_DES | TYPHOON_CRYPTO_3DES | TYPHOON_FIBER},
206 { "3Com Typhoon2 (3C990B-FX-97)",
207 TYPHOON_CRYPTO_VARIABLE | TYPHOON_FIBER},
208};
209
210/* Notes on the new subsystem numbering scheme:
Alexey Dobriyan7f927fc2006-03-28 01:56:53 -0800211 * bits 0-1 indicate crypto capabilities: (0) variable, (1) DES, or (2) 3DES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 * bit 4 indicates if this card has secured firmware (we don't support it)
213 * bit 8 indicates if this is a (0) copper or (1) fiber card
214 * bits 12-16 indicate card type: (0) client and (1) server
215 */
216static struct pci_device_id typhoon_pci_tbl[] = {
217 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990,
218 PCI_ANY_ID, PCI_ANY_ID, 0, 0,TYPHOON_TX },
219 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95,
220 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX95 },
221 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_97,
222 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX97 },
223 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
224 PCI_ANY_ID, 0x1000, 0, 0, TYPHOON_TXM },
225 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
226 PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FXM },
227 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
228 PCI_ANY_ID, 0x2000, 0, 0, TYPHOON_BSVR },
229 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
230 PCI_ANY_ID, 0x1101, 0, 0, TYPHOON_FX95 },
231 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
232 PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FX97 },
233 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
234 PCI_ANY_ID, 0x2101, 0, 0, TYPHOON_FX95SVR },
235 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
236 PCI_ANY_ID, 0x2102, 0, 0, TYPHOON_FX97SVR },
237 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR95,
238 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR95 },
239 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR97,
240 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR97 },
241 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR,
242 PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR },
243 { 0, }
244};
245MODULE_DEVICE_TABLE(pci, typhoon_pci_tbl);
246
247/* Define the shared memory area
248 * Align everything the 3XP will normally be using.
249 * We'll need to move/align txHi if we start using that ring.
250 */
251#define __3xp_aligned ____cacheline_aligned
252struct typhoon_shared {
253 struct typhoon_interface iface;
254 struct typhoon_indexes indexes __3xp_aligned;
255 struct tx_desc txLo[TXLO_ENTRIES] __3xp_aligned;
256 struct rx_desc rxLo[RX_ENTRIES] __3xp_aligned;
257 struct rx_desc rxHi[RX_ENTRIES] __3xp_aligned;
258 struct cmd_desc cmd[COMMAND_ENTRIES] __3xp_aligned;
259 struct resp_desc resp[RESPONSE_ENTRIES] __3xp_aligned;
260 struct rx_free rxBuff[RXFREE_ENTRIES] __3xp_aligned;
261 u32 zeroWord;
262 struct tx_desc txHi[TXHI_ENTRIES];
263} __attribute__ ((packed));
264
265struct rxbuff_ent {
266 struct sk_buff *skb;
267 dma_addr_t dma_addr;
268};
269
270struct typhoon {
271 /* Tx cache line section */
272 struct transmit_ring txLoRing ____cacheline_aligned;
273 struct pci_dev * tx_pdev;
274 void __iomem *tx_ioaddr;
275 u32 txlo_dma_addr;
276
277 /* Irq/Rx cache line section */
278 void __iomem *ioaddr ____cacheline_aligned;
279 struct typhoon_indexes *indexes;
280 u8 awaiting_resp;
281 u8 duplex;
282 u8 speed;
283 u8 card_state;
284 struct basic_ring rxLoRing;
285 struct pci_dev * pdev;
286 struct net_device * dev;
287 spinlock_t state_lock;
288 struct vlan_group * vlgrp;
289 struct basic_ring rxHiRing;
290 struct basic_ring rxBuffRing;
291 struct rxbuff_ent rxbuffers[RXENT_ENTRIES];
292
293 /* general section */
294 spinlock_t command_lock ____cacheline_aligned;
295 struct basic_ring cmdRing;
296 struct basic_ring respRing;
297 struct net_device_stats stats;
298 struct net_device_stats stats_saved;
299 const char * name;
300 struct typhoon_shared * shared;
301 dma_addr_t shared_dma;
302 u16 xcvr_select;
303 u16 wol_events;
304 u32 offload;
305
306 /* unused stuff (future use) */
307 int capabilities;
308 struct transmit_ring txHiRing;
309};
310
311enum completion_wait_values {
312 NoWait = 0, WaitNoSleep, WaitSleep,
313};
314
315/* These are the values for the typhoon.card_state variable.
316 * These determine where the statistics will come from in get_stats().
317 * The sleep image does not support the statistics we need.
318 */
319enum state_values {
320 Sleeping = 0, Running,
321};
322
323/* PCI writes are not guaranteed to be posted in order, but outstanding writes
324 * cannot pass a read, so this forces current writes to post.
325 */
326#define typhoon_post_pci_writes(x) \
327 do { if(likely(use_mmio)) ioread32(x+TYPHOON_REG_HEARTBEAT); } while(0)
328
329/* We'll wait up to six seconds for a reset, and half a second normally.
330 */
331#define TYPHOON_UDELAY 50
332#define TYPHOON_RESET_TIMEOUT_SLEEP (6 * HZ)
333#define TYPHOON_RESET_TIMEOUT_NOSLEEP ((6 * 1000000) / TYPHOON_UDELAY)
334#define TYPHOON_WAIT_TIMEOUT ((1000000 / 2) / TYPHOON_UDELAY)
335
336#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 28)
337#define typhoon_synchronize_irq(x) synchronize_irq()
338#else
339#define typhoon_synchronize_irq(x) synchronize_irq(x)
340#endif
341
342#if defined(NETIF_F_TSO)
343#define skb_tso_size(x) (skb_shinfo(x)->tso_size)
344#define TSO_NUM_DESCRIPTORS 2
345#define TSO_OFFLOAD_ON TYPHOON_OFFLOAD_TCP_SEGMENT
346#else
347#define NETIF_F_TSO 0
348#define skb_tso_size(x) 0
349#define TSO_NUM_DESCRIPTORS 0
350#define TSO_OFFLOAD_ON 0
351#endif
352
353static inline void
354typhoon_inc_index(u32 *index, const int count, const int num_entries)
355{
356 /* Increment a ring index -- we can use this for all rings execept
357 * the Rx rings, as they use different size descriptors
358 * otherwise, everything is the same size as a cmd_desc
359 */
360 *index += count * sizeof(struct cmd_desc);
361 *index %= num_entries * sizeof(struct cmd_desc);
362}
363
364static inline void
365typhoon_inc_cmd_index(u32 *index, const int count)
366{
367 typhoon_inc_index(index, count, COMMAND_ENTRIES);
368}
369
370static inline void
371typhoon_inc_resp_index(u32 *index, const int count)
372{
373 typhoon_inc_index(index, count, RESPONSE_ENTRIES);
374}
375
376static inline void
377typhoon_inc_rxfree_index(u32 *index, const int count)
378{
379 typhoon_inc_index(index, count, RXFREE_ENTRIES);
380}
381
382static inline void
383typhoon_inc_tx_index(u32 *index, const int count)
384{
385 /* if we start using the Hi Tx ring, this needs updateing */
386 typhoon_inc_index(index, count, TXLO_ENTRIES);
387}
388
389static inline void
390typhoon_inc_rx_index(u32 *index, const int count)
391{
392 /* sizeof(struct rx_desc) != sizeof(struct cmd_desc) */
393 *index += count * sizeof(struct rx_desc);
394 *index %= RX_ENTRIES * sizeof(struct rx_desc);
395}
396
397static int
398typhoon_reset(void __iomem *ioaddr, int wait_type)
399{
400 int i, err = 0;
401 int timeout;
402
403 if(wait_type == WaitNoSleep)
404 timeout = TYPHOON_RESET_TIMEOUT_NOSLEEP;
405 else
406 timeout = TYPHOON_RESET_TIMEOUT_SLEEP;
407
408 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
409 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
410
411 iowrite32(TYPHOON_RESET_ALL, ioaddr + TYPHOON_REG_SOFT_RESET);
412 typhoon_post_pci_writes(ioaddr);
413 udelay(1);
414 iowrite32(TYPHOON_RESET_NONE, ioaddr + TYPHOON_REG_SOFT_RESET);
415
416 if(wait_type != NoWait) {
417 for(i = 0; i < timeout; i++) {
418 if(ioread32(ioaddr + TYPHOON_REG_STATUS) ==
419 TYPHOON_STATUS_WAITING_FOR_HOST)
420 goto out;
421
Nishanth Aravamudan3173c892005-09-11 02:09:55 -0700422 if(wait_type == WaitSleep)
423 schedule_timeout_uninterruptible(1);
424 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 udelay(TYPHOON_UDELAY);
426 }
427
428 err = -ETIMEDOUT;
429 }
430
431out:
432 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
433 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
434
435 /* The 3XP seems to need a little extra time to complete the load
436 * of the sleep image before we can reliably boot it. Failure to
437 * do this occasionally results in a hung adapter after boot in
438 * typhoon_init_one() while trying to read the MAC address or
439 * putting the card to sleep. 3Com's driver waits 5ms, but
440 * that seems to be overkill. However, if we can sleep, we might
441 * as well give it that much time. Otherwise, we'll give it 500us,
442 * which should be enough (I've see it work well at 100us, but still
443 * saw occasional problems.)
444 */
445 if(wait_type == WaitSleep)
446 msleep(5);
447 else
448 udelay(500);
449 return err;
450}
451
452static int
453typhoon_wait_status(void __iomem *ioaddr, u32 wait_value)
454{
455 int i, err = 0;
456
457 for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
458 if(ioread32(ioaddr + TYPHOON_REG_STATUS) == wait_value)
459 goto out;
460 udelay(TYPHOON_UDELAY);
461 }
462
463 err = -ETIMEDOUT;
464
465out:
466 return err;
467}
468
469static inline void
470typhoon_media_status(struct net_device *dev, struct resp_desc *resp)
471{
472 if(resp->parm1 & TYPHOON_MEDIA_STAT_NO_LINK)
473 netif_carrier_off(dev);
474 else
475 netif_carrier_on(dev);
476}
477
478static inline void
479typhoon_hello(struct typhoon *tp)
480{
481 struct basic_ring *ring = &tp->cmdRing;
482 struct cmd_desc *cmd;
483
484 /* We only get a hello request if we've not sent anything to the
485 * card in a long while. If the lock is held, then we're in the
486 * process of issuing a command, so we don't need to respond.
487 */
488 if(spin_trylock(&tp->command_lock)) {
489 cmd = (struct cmd_desc *)(ring->ringBase + ring->lastWrite);
490 typhoon_inc_cmd_index(&ring->lastWrite, 1);
491
492 INIT_COMMAND_NO_RESPONSE(cmd, TYPHOON_CMD_HELLO_RESP);
493 smp_wmb();
494 iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
495 spin_unlock(&tp->command_lock);
496 }
497}
498
499static int
500typhoon_process_response(struct typhoon *tp, int resp_size,
501 struct resp_desc *resp_save)
502{
503 struct typhoon_indexes *indexes = tp->indexes;
504 struct resp_desc *resp;
505 u8 *base = tp->respRing.ringBase;
506 int count, len, wrap_len;
507 u32 cleared;
508 u32 ready;
509
510 cleared = le32_to_cpu(indexes->respCleared);
511 ready = le32_to_cpu(indexes->respReady);
512 while(cleared != ready) {
513 resp = (struct resp_desc *)(base + cleared);
514 count = resp->numDesc + 1;
515 if(resp_save && resp->seqNo) {
516 if(count > resp_size) {
517 resp_save->flags = TYPHOON_RESP_ERROR;
518 goto cleanup;
519 }
520
521 wrap_len = 0;
522 len = count * sizeof(*resp);
523 if(unlikely(cleared + len > RESPONSE_RING_SIZE)) {
524 wrap_len = cleared + len - RESPONSE_RING_SIZE;
525 len = RESPONSE_RING_SIZE - cleared;
526 }
527
528 memcpy(resp_save, resp, len);
529 if(unlikely(wrap_len)) {
530 resp_save += len / sizeof(*resp);
531 memcpy(resp_save, base, wrap_len);
532 }
533
534 resp_save = NULL;
535 } else if(resp->cmd == TYPHOON_CMD_READ_MEDIA_STATUS) {
536 typhoon_media_status(tp->dev, resp);
537 } else if(resp->cmd == TYPHOON_CMD_HELLO_RESP) {
538 typhoon_hello(tp);
539 } else {
540 printk(KERN_ERR "%s: dumping unexpected response "
541 "0x%04x:%d:0x%02x:0x%04x:%08x:%08x\n",
542 tp->name, le16_to_cpu(resp->cmd),
543 resp->numDesc, resp->flags,
544 le16_to_cpu(resp->parm1),
545 le32_to_cpu(resp->parm2),
546 le32_to_cpu(resp->parm3));
547 }
548
549cleanup:
550 typhoon_inc_resp_index(&cleared, count);
551 }
552
553 indexes->respCleared = cpu_to_le32(cleared);
554 wmb();
555 return (resp_save == NULL);
556}
557
558static inline int
559typhoon_num_free(int lastWrite, int lastRead, int ringSize)
560{
561 /* this works for all descriptors but rx_desc, as they are a
562 * different size than the cmd_desc -- everyone else is the same
563 */
564 lastWrite /= sizeof(struct cmd_desc);
565 lastRead /= sizeof(struct cmd_desc);
566 return (ringSize + lastRead - lastWrite - 1) % ringSize;
567}
568
569static inline int
570typhoon_num_free_cmd(struct typhoon *tp)
571{
572 int lastWrite = tp->cmdRing.lastWrite;
573 int cmdCleared = le32_to_cpu(tp->indexes->cmdCleared);
574
575 return typhoon_num_free(lastWrite, cmdCleared, COMMAND_ENTRIES);
576}
577
578static inline int
579typhoon_num_free_resp(struct typhoon *tp)
580{
581 int respReady = le32_to_cpu(tp->indexes->respReady);
582 int respCleared = le32_to_cpu(tp->indexes->respCleared);
583
584 return typhoon_num_free(respReady, respCleared, RESPONSE_ENTRIES);
585}
586
587static inline int
588typhoon_num_free_tx(struct transmit_ring *ring)
589{
590 /* if we start using the Hi Tx ring, this needs updating */
591 return typhoon_num_free(ring->lastWrite, ring->lastRead, TXLO_ENTRIES);
592}
593
594static int
595typhoon_issue_command(struct typhoon *tp, int num_cmd, struct cmd_desc *cmd,
596 int num_resp, struct resp_desc *resp)
597{
598 struct typhoon_indexes *indexes = tp->indexes;
599 struct basic_ring *ring = &tp->cmdRing;
600 struct resp_desc local_resp;
601 int i, err = 0;
602 int got_resp;
603 int freeCmd, freeResp;
604 int len, wrap_len;
605
606 spin_lock(&tp->command_lock);
607
608 freeCmd = typhoon_num_free_cmd(tp);
609 freeResp = typhoon_num_free_resp(tp);
610
611 if(freeCmd < num_cmd || freeResp < num_resp) {
612 printk("%s: no descs for cmd, had (needed) %d (%d) cmd, "
613 "%d (%d) resp\n", tp->name, freeCmd, num_cmd,
614 freeResp, num_resp);
615 err = -ENOMEM;
616 goto out;
617 }
618
619 if(cmd->flags & TYPHOON_CMD_RESPOND) {
620 /* If we're expecting a response, but the caller hasn't given
621 * us a place to put it, we'll provide one.
622 */
623 tp->awaiting_resp = 1;
624 if(resp == NULL) {
625 resp = &local_resp;
626 num_resp = 1;
627 }
628 }
629
630 wrap_len = 0;
631 len = num_cmd * sizeof(*cmd);
632 if(unlikely(ring->lastWrite + len > COMMAND_RING_SIZE)) {
633 wrap_len = ring->lastWrite + len - COMMAND_RING_SIZE;
634 len = COMMAND_RING_SIZE - ring->lastWrite;
635 }
636
637 memcpy(ring->ringBase + ring->lastWrite, cmd, len);
638 if(unlikely(wrap_len)) {
639 struct cmd_desc *wrap_ptr = cmd;
640 wrap_ptr += len / sizeof(*cmd);
641 memcpy(ring->ringBase, wrap_ptr, wrap_len);
642 }
643
644 typhoon_inc_cmd_index(&ring->lastWrite, num_cmd);
645
646 /* "I feel a presence... another warrior is on the the mesa."
647 */
648 wmb();
649 iowrite32(ring->lastWrite, tp->ioaddr + TYPHOON_REG_CMD_READY);
650 typhoon_post_pci_writes(tp->ioaddr);
651
652 if((cmd->flags & TYPHOON_CMD_RESPOND) == 0)
653 goto out;
654
655 /* Ugh. We'll be here about 8ms, spinning our thumbs, unable to
656 * preempt or do anything other than take interrupts. So, don't
657 * wait for a response unless you have to.
658 *
659 * I've thought about trying to sleep here, but we're called
660 * from many contexts that don't allow that. Also, given the way
661 * 3Com has implemented irq coalescing, we would likely timeout --
662 * this has been observed in real life!
663 *
664 * The big killer is we have to wait to get stats from the card,
665 * though we could go to a periodic refresh of those if we don't
666 * mind them getting somewhat stale. The rest of the waiting
667 * commands occur during open/close/suspend/resume, so they aren't
668 * time critical. Creating SAs in the future will also have to
669 * wait here.
670 */
671 got_resp = 0;
672 for(i = 0; i < TYPHOON_WAIT_TIMEOUT && !got_resp; i++) {
673 if(indexes->respCleared != indexes->respReady)
674 got_resp = typhoon_process_response(tp, num_resp,
675 resp);
676 udelay(TYPHOON_UDELAY);
677 }
678
679 if(!got_resp) {
680 err = -ETIMEDOUT;
681 goto out;
682 }
683
684 /* Collect the error response even if we don't care about the
685 * rest of the response
686 */
687 if(resp->flags & TYPHOON_RESP_ERROR)
688 err = -EIO;
689
690out:
691 if(tp->awaiting_resp) {
692 tp->awaiting_resp = 0;
693 smp_wmb();
694
695 /* Ugh. If a response was added to the ring between
696 * the call to typhoon_process_response() and the clearing
697 * of tp->awaiting_resp, we could have missed the interrupt
698 * and it could hang in the ring an indeterminate amount of
699 * time. So, check for it, and interrupt ourselves if this
700 * is the case.
701 */
702 if(indexes->respCleared != indexes->respReady)
703 iowrite32(1, tp->ioaddr + TYPHOON_REG_SELF_INTERRUPT);
704 }
705
706 spin_unlock(&tp->command_lock);
707 return err;
708}
709
710static void
711typhoon_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
712{
713 struct typhoon *tp = netdev_priv(dev);
714 struct cmd_desc xp_cmd;
715 int err;
716
717 spin_lock_bh(&tp->state_lock);
718 if(!tp->vlgrp != !grp) {
719 /* We've either been turned on for the first time, or we've
720 * been turned off. Update the 3XP.
721 */
722 if(grp)
723 tp->offload |= TYPHOON_OFFLOAD_VLAN;
724 else
725 tp->offload &= ~TYPHOON_OFFLOAD_VLAN;
726
727 /* If the interface is up, the runtime is running -- and we
728 * must be up for the vlan core to call us.
729 *
730 * Do the command outside of the spin lock, as it is slow.
731 */
732 INIT_COMMAND_WITH_RESPONSE(&xp_cmd,
733 TYPHOON_CMD_SET_OFFLOAD_TASKS);
734 xp_cmd.parm2 = tp->offload;
735 xp_cmd.parm3 = tp->offload;
736 spin_unlock_bh(&tp->state_lock);
737 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
738 if(err < 0)
739 printk("%s: vlan offload error %d\n", tp->name, -err);
740 spin_lock_bh(&tp->state_lock);
741 }
742
743 /* now make the change visible */
744 tp->vlgrp = grp;
745 spin_unlock_bh(&tp->state_lock);
746}
747
748static void
749typhoon_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
750{
751 struct typhoon *tp = netdev_priv(dev);
752 spin_lock_bh(&tp->state_lock);
753 if(tp->vlgrp)
754 tp->vlgrp->vlan_devices[vid] = NULL;
755 spin_unlock_bh(&tp->state_lock);
756}
757
758static inline void
759typhoon_tso_fill(struct sk_buff *skb, struct transmit_ring *txRing,
760 u32 ring_dma)
761{
762 struct tcpopt_desc *tcpd;
763 u32 tcpd_offset = ring_dma;
764
765 tcpd = (struct tcpopt_desc *) (txRing->ringBase + txRing->lastWrite);
766 tcpd_offset += txRing->lastWrite;
767 tcpd_offset += offsetof(struct tcpopt_desc, bytesTx);
768 typhoon_inc_tx_index(&txRing->lastWrite, 1);
769
770 tcpd->flags = TYPHOON_OPT_DESC | TYPHOON_OPT_TCP_SEG;
771 tcpd->numDesc = 1;
772 tcpd->mss_flags = cpu_to_le16(skb_tso_size(skb));
773 tcpd->mss_flags |= TYPHOON_TSO_FIRST | TYPHOON_TSO_LAST;
774 tcpd->respAddrLo = cpu_to_le32(tcpd_offset);
775 tcpd->bytesTx = cpu_to_le32(skb->len);
776 tcpd->status = 0;
777}
778
779static int
780typhoon_start_tx(struct sk_buff *skb, struct net_device *dev)
781{
782 struct typhoon *tp = netdev_priv(dev);
783 struct transmit_ring *txRing;
784 struct tx_desc *txd, *first_txd;
785 dma_addr_t skb_dma;
786 int numDesc;
787
788 /* we have two rings to choose from, but we only use txLo for now
789 * If we start using the Hi ring as well, we'll need to update
790 * typhoon_stop_runtime(), typhoon_interrupt(), typhoon_num_free_tx(),
Alexey Dobriyan7f927fc2006-03-28 01:56:53 -0800791 * and TXHI_ENTRIES to match, as well as update the TSO code below
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 * to get the right DMA address
793 */
794 txRing = &tp->txLoRing;
795
796 /* We need one descriptor for each fragment of the sk_buff, plus the
797 * one for the ->data area of it.
798 *
799 * The docs say a maximum of 16 fragment descriptors per TCP option
800 * descriptor, then make a new packet descriptor and option descriptor
801 * for the next 16 fragments. The engineers say just an option
802 * descriptor is needed. I've tested up to 26 fragments with a single
803 * packet descriptor/option descriptor combo, so I use that for now.
804 *
805 * If problems develop with TSO, check this first.
806 */
807 numDesc = skb_shinfo(skb)->nr_frags + 1;
808 if(skb_tso_size(skb))
809 numDesc++;
810
811 /* When checking for free space in the ring, we need to also
812 * account for the initial Tx descriptor, and we always must leave
813 * at least one descriptor unused in the ring so that it doesn't
814 * wrap and look empty.
815 *
816 * The only time we should loop here is when we hit the race
817 * between marking the queue awake and updating the cleared index.
818 * Just loop and it will appear. This comes from the acenic driver.
819 */
820 while(unlikely(typhoon_num_free_tx(txRing) < (numDesc + 2)))
821 smp_rmb();
822
823 first_txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
824 typhoon_inc_tx_index(&txRing->lastWrite, 1);
825
826 first_txd->flags = TYPHOON_TX_DESC | TYPHOON_DESC_VALID;
827 first_txd->numDesc = 0;
828 first_txd->len = 0;
829 first_txd->addr = (u64)((unsigned long) skb) & 0xffffffff;
830 first_txd->addrHi = (u64)((unsigned long) skb) >> 32;
831 first_txd->processFlags = 0;
832
833 if(skb->ip_summed == CHECKSUM_HW) {
834 /* The 3XP will figure out if this is UDP/TCP */
835 first_txd->processFlags |= TYPHOON_TX_PF_TCP_CHKSUM;
836 first_txd->processFlags |= TYPHOON_TX_PF_UDP_CHKSUM;
837 first_txd->processFlags |= TYPHOON_TX_PF_IP_CHKSUM;
838 }
839
840 if(vlan_tx_tag_present(skb)) {
841 first_txd->processFlags |=
842 TYPHOON_TX_PF_INSERT_VLAN | TYPHOON_TX_PF_VLAN_PRIORITY;
843 first_txd->processFlags |=
844 cpu_to_le32(htons(vlan_tx_tag_get(skb)) <<
845 TYPHOON_TX_PF_VLAN_TAG_SHIFT);
846 }
847
848 if(skb_tso_size(skb)) {
849 first_txd->processFlags |= TYPHOON_TX_PF_TCP_SEGMENT;
850 first_txd->numDesc++;
851
852 typhoon_tso_fill(skb, txRing, tp->txlo_dma_addr);
853 }
854
855 txd = (struct tx_desc *) (txRing->ringBase + txRing->lastWrite);
856 typhoon_inc_tx_index(&txRing->lastWrite, 1);
857
858 /* No need to worry about padding packet -- the firmware pads
859 * it with zeros to ETH_ZLEN for us.
860 */
861 if(skb_shinfo(skb)->nr_frags == 0) {
862 skb_dma = pci_map_single(tp->tx_pdev, skb->data, skb->len,
863 PCI_DMA_TODEVICE);
864 txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
865 txd->len = cpu_to_le16(skb->len);
866 txd->addr = cpu_to_le32(skb_dma);
867 txd->addrHi = 0;
868 first_txd->numDesc++;
869 } else {
870 int i, len;
871
872 len = skb_headlen(skb);
873 skb_dma = pci_map_single(tp->tx_pdev, skb->data, len,
874 PCI_DMA_TODEVICE);
875 txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
876 txd->len = cpu_to_le16(len);
877 txd->addr = cpu_to_le32(skb_dma);
878 txd->addrHi = 0;
879 first_txd->numDesc++;
880
881 for(i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
882 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
883 void *frag_addr;
884
885 txd = (struct tx_desc *) (txRing->ringBase +
886 txRing->lastWrite);
887 typhoon_inc_tx_index(&txRing->lastWrite, 1);
888
889 len = frag->size;
890 frag_addr = (void *) page_address(frag->page) +
891 frag->page_offset;
892 skb_dma = pci_map_single(tp->tx_pdev, frag_addr, len,
893 PCI_DMA_TODEVICE);
894 txd->flags = TYPHOON_FRAG_DESC | TYPHOON_DESC_VALID;
895 txd->len = cpu_to_le16(len);
896 txd->addr = cpu_to_le32(skb_dma);
897 txd->addrHi = 0;
898 first_txd->numDesc++;
899 }
900 }
901
902 /* Kick the 3XP
903 */
904 wmb();
905 iowrite32(txRing->lastWrite, tp->tx_ioaddr + txRing->writeRegister);
906
907 dev->trans_start = jiffies;
908
909 /* If we don't have room to put the worst case packet on the
910 * queue, then we must stop the queue. We need 2 extra
911 * descriptors -- one to prevent ring wrap, and one for the
912 * Tx header.
913 */
914 numDesc = MAX_SKB_FRAGS + TSO_NUM_DESCRIPTORS + 1;
915
916 if(typhoon_num_free_tx(txRing) < (numDesc + 2)) {
917 netif_stop_queue(dev);
918
919 /* A Tx complete IRQ could have gotten inbetween, making
920 * the ring free again. Only need to recheck here, since
921 * Tx is serialized.
922 */
923 if(typhoon_num_free_tx(txRing) >= (numDesc + 2))
924 netif_wake_queue(dev);
925 }
926
927 return 0;
928}
929
930static void
931typhoon_set_rx_mode(struct net_device *dev)
932{
933 struct typhoon *tp = netdev_priv(dev);
934 struct cmd_desc xp_cmd;
935 u32 mc_filter[2];
936 u16 filter;
937
938 filter = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
939 if(dev->flags & IFF_PROMISC) {
940 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n",
941 dev->name);
942 filter |= TYPHOON_RX_FILTER_PROMISCOUS;
943 } else if((dev->mc_count > multicast_filter_limit) ||
944 (dev->flags & IFF_ALLMULTI)) {
945 /* Too many to match, or accept all multicasts. */
946 filter |= TYPHOON_RX_FILTER_ALL_MCAST;
947 } else if(dev->mc_count) {
948 struct dev_mc_list *mclist;
949 int i;
950
951 memset(mc_filter, 0, sizeof(mc_filter));
952 for(i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
953 i++, mclist = mclist->next) {
954 int bit = ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x3f;
955 mc_filter[bit >> 5] |= 1 << (bit & 0x1f);
956 }
957
958 INIT_COMMAND_NO_RESPONSE(&xp_cmd,
959 TYPHOON_CMD_SET_MULTICAST_HASH);
960 xp_cmd.parm1 = TYPHOON_MCAST_HASH_SET;
961 xp_cmd.parm2 = cpu_to_le32(mc_filter[0]);
962 xp_cmd.parm3 = cpu_to_le32(mc_filter[1]);
963 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
964
965 filter |= TYPHOON_RX_FILTER_MCAST_HASH;
966 }
967
968 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
969 xp_cmd.parm1 = filter;
970 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
971}
972
973static int
974typhoon_do_get_stats(struct typhoon *tp)
975{
976 struct net_device_stats *stats = &tp->stats;
977 struct net_device_stats *saved = &tp->stats_saved;
978 struct cmd_desc xp_cmd;
979 struct resp_desc xp_resp[7];
980 struct stats_resp *s = (struct stats_resp *) xp_resp;
981 int err;
982
983 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_STATS);
984 err = typhoon_issue_command(tp, 1, &xp_cmd, 7, xp_resp);
985 if(err < 0)
986 return err;
987
988 /* 3Com's Linux driver uses txMultipleCollisions as it's
989 * collisions value, but there is some other collision info as well...
990 *
991 * The extra status reported would be a good candidate for
992 * ethtool_ops->get_{strings,stats}()
993 */
994 stats->tx_packets = le32_to_cpu(s->txPackets);
995 stats->tx_bytes = le32_to_cpu(s->txBytes);
996 stats->tx_errors = le32_to_cpu(s->txCarrierLost);
997 stats->tx_carrier_errors = le32_to_cpu(s->txCarrierLost);
998 stats->collisions = le32_to_cpu(s->txMultipleCollisions);
999 stats->rx_packets = le32_to_cpu(s->rxPacketsGood);
1000 stats->rx_bytes = le32_to_cpu(s->rxBytesGood);
1001 stats->rx_fifo_errors = le32_to_cpu(s->rxFifoOverruns);
1002 stats->rx_errors = le32_to_cpu(s->rxFifoOverruns) +
1003 le32_to_cpu(s->BadSSD) + le32_to_cpu(s->rxCrcErrors);
1004 stats->rx_crc_errors = le32_to_cpu(s->rxCrcErrors);
1005 stats->rx_length_errors = le32_to_cpu(s->rxOversized);
1006 tp->speed = (s->linkStatus & TYPHOON_LINK_100MBPS) ?
1007 SPEED_100 : SPEED_10;
1008 tp->duplex = (s->linkStatus & TYPHOON_LINK_FULL_DUPLEX) ?
1009 DUPLEX_FULL : DUPLEX_HALF;
1010
1011 /* add in the saved statistics
1012 */
1013 stats->tx_packets += saved->tx_packets;
1014 stats->tx_bytes += saved->tx_bytes;
1015 stats->tx_errors += saved->tx_errors;
1016 stats->collisions += saved->collisions;
1017 stats->rx_packets += saved->rx_packets;
1018 stats->rx_bytes += saved->rx_bytes;
1019 stats->rx_fifo_errors += saved->rx_fifo_errors;
1020 stats->rx_errors += saved->rx_errors;
1021 stats->rx_crc_errors += saved->rx_crc_errors;
1022 stats->rx_length_errors += saved->rx_length_errors;
1023
1024 return 0;
1025}
1026
1027static struct net_device_stats *
1028typhoon_get_stats(struct net_device *dev)
1029{
1030 struct typhoon *tp = netdev_priv(dev);
1031 struct net_device_stats *stats = &tp->stats;
1032 struct net_device_stats *saved = &tp->stats_saved;
1033
1034 smp_rmb();
1035 if(tp->card_state == Sleeping)
1036 return saved;
1037
1038 if(typhoon_do_get_stats(tp) < 0) {
1039 printk(KERN_ERR "%s: error getting stats\n", dev->name);
1040 return saved;
1041 }
1042
1043 return stats;
1044}
1045
1046static int
1047typhoon_set_mac_address(struct net_device *dev, void *addr)
1048{
1049 struct sockaddr *saddr = (struct sockaddr *) addr;
1050
1051 if(netif_running(dev))
1052 return -EBUSY;
1053
1054 memcpy(dev->dev_addr, saddr->sa_data, dev->addr_len);
1055 return 0;
1056}
1057
1058static void
1059typhoon_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1060{
1061 struct typhoon *tp = netdev_priv(dev);
1062 struct pci_dev *pci_dev = tp->pdev;
1063 struct cmd_desc xp_cmd;
1064 struct resp_desc xp_resp[3];
1065
1066 smp_rmb();
1067 if(tp->card_state == Sleeping) {
1068 strcpy(info->fw_version, "Sleep image");
1069 } else {
1070 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
1071 if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
1072 strcpy(info->fw_version, "Unknown runtime");
1073 } else {
1074 u32 sleep_ver = xp_resp[0].parm2;
1075 snprintf(info->fw_version, 32, "%02x.%03x.%03x",
1076 sleep_ver >> 24, (sleep_ver >> 12) & 0xfff,
1077 sleep_ver & 0xfff);
1078 }
1079 }
1080
1081 strcpy(info->driver, DRV_MODULE_NAME);
1082 strcpy(info->version, DRV_MODULE_VERSION);
1083 strcpy(info->bus_info, pci_name(pci_dev));
1084}
1085
1086static int
1087typhoon_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1088{
1089 struct typhoon *tp = netdev_priv(dev);
1090
1091 cmd->supported = SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1092 SUPPORTED_Autoneg;
1093
1094 switch (tp->xcvr_select) {
1095 case TYPHOON_XCVR_10HALF:
1096 cmd->advertising = ADVERTISED_10baseT_Half;
1097 break;
1098 case TYPHOON_XCVR_10FULL:
1099 cmd->advertising = ADVERTISED_10baseT_Full;
1100 break;
1101 case TYPHOON_XCVR_100HALF:
1102 cmd->advertising = ADVERTISED_100baseT_Half;
1103 break;
1104 case TYPHOON_XCVR_100FULL:
1105 cmd->advertising = ADVERTISED_100baseT_Full;
1106 break;
1107 case TYPHOON_XCVR_AUTONEG:
1108 cmd->advertising = ADVERTISED_10baseT_Half |
1109 ADVERTISED_10baseT_Full |
1110 ADVERTISED_100baseT_Half |
1111 ADVERTISED_100baseT_Full |
1112 ADVERTISED_Autoneg;
1113 break;
1114 }
1115
1116 if(tp->capabilities & TYPHOON_FIBER) {
1117 cmd->supported |= SUPPORTED_FIBRE;
1118 cmd->advertising |= ADVERTISED_FIBRE;
1119 cmd->port = PORT_FIBRE;
1120 } else {
1121 cmd->supported |= SUPPORTED_10baseT_Half |
1122 SUPPORTED_10baseT_Full |
1123 SUPPORTED_TP;
1124 cmd->advertising |= ADVERTISED_TP;
1125 cmd->port = PORT_TP;
1126 }
1127
1128 /* need to get stats to make these link speed/duplex valid */
1129 typhoon_do_get_stats(tp);
1130 cmd->speed = tp->speed;
1131 cmd->duplex = tp->duplex;
1132 cmd->phy_address = 0;
1133 cmd->transceiver = XCVR_INTERNAL;
1134 if(tp->xcvr_select == TYPHOON_XCVR_AUTONEG)
1135 cmd->autoneg = AUTONEG_ENABLE;
1136 else
1137 cmd->autoneg = AUTONEG_DISABLE;
1138 cmd->maxtxpkt = 1;
1139 cmd->maxrxpkt = 1;
1140
1141 return 0;
1142}
1143
1144static int
1145typhoon_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1146{
1147 struct typhoon *tp = netdev_priv(dev);
1148 struct cmd_desc xp_cmd;
1149 int xcvr;
1150 int err;
1151
1152 err = -EINVAL;
1153 if(cmd->autoneg == AUTONEG_ENABLE) {
1154 xcvr = TYPHOON_XCVR_AUTONEG;
1155 } else {
1156 if(cmd->duplex == DUPLEX_HALF) {
1157 if(cmd->speed == SPEED_10)
1158 xcvr = TYPHOON_XCVR_10HALF;
1159 else if(cmd->speed == SPEED_100)
1160 xcvr = TYPHOON_XCVR_100HALF;
1161 else
1162 goto out;
1163 } else if(cmd->duplex == DUPLEX_FULL) {
1164 if(cmd->speed == SPEED_10)
1165 xcvr = TYPHOON_XCVR_10FULL;
1166 else if(cmd->speed == SPEED_100)
1167 xcvr = TYPHOON_XCVR_100FULL;
1168 else
1169 goto out;
1170 } else
1171 goto out;
1172 }
1173
1174 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
1175 xp_cmd.parm1 = cpu_to_le16(xcvr);
1176 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1177 if(err < 0)
1178 goto out;
1179
1180 tp->xcvr_select = xcvr;
1181 if(cmd->autoneg == AUTONEG_ENABLE) {
1182 tp->speed = 0xff; /* invalid */
1183 tp->duplex = 0xff; /* invalid */
1184 } else {
1185 tp->speed = cmd->speed;
1186 tp->duplex = cmd->duplex;
1187 }
1188
1189out:
1190 return err;
1191}
1192
1193static void
1194typhoon_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1195{
1196 struct typhoon *tp = netdev_priv(dev);
1197
1198 wol->supported = WAKE_PHY | WAKE_MAGIC;
1199 wol->wolopts = 0;
1200 if(tp->wol_events & TYPHOON_WAKE_LINK_EVENT)
1201 wol->wolopts |= WAKE_PHY;
1202 if(tp->wol_events & TYPHOON_WAKE_MAGIC_PKT)
1203 wol->wolopts |= WAKE_MAGIC;
1204 memset(&wol->sopass, 0, sizeof(wol->sopass));
1205}
1206
1207static int
1208typhoon_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1209{
1210 struct typhoon *tp = netdev_priv(dev);
1211
1212 if(wol->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
1213 return -EINVAL;
1214
1215 tp->wol_events = 0;
1216 if(wol->wolopts & WAKE_PHY)
1217 tp->wol_events |= TYPHOON_WAKE_LINK_EVENT;
1218 if(wol->wolopts & WAKE_MAGIC)
1219 tp->wol_events |= TYPHOON_WAKE_MAGIC_PKT;
1220
1221 return 0;
1222}
1223
1224static u32
1225typhoon_get_rx_csum(struct net_device *dev)
1226{
1227 /* For now, we don't allow turning off RX checksums.
1228 */
1229 return 1;
1230}
1231
1232static void
1233typhoon_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
1234{
1235 ering->rx_max_pending = RXENT_ENTRIES;
1236 ering->rx_mini_max_pending = 0;
1237 ering->rx_jumbo_max_pending = 0;
1238 ering->tx_max_pending = TXLO_ENTRIES - 1;
1239
1240 ering->rx_pending = RXENT_ENTRIES;
1241 ering->rx_mini_pending = 0;
1242 ering->rx_jumbo_pending = 0;
1243 ering->tx_pending = TXLO_ENTRIES - 1;
1244}
1245
1246static struct ethtool_ops typhoon_ethtool_ops = {
1247 .get_settings = typhoon_get_settings,
1248 .set_settings = typhoon_set_settings,
1249 .get_drvinfo = typhoon_get_drvinfo,
1250 .get_wol = typhoon_get_wol,
1251 .set_wol = typhoon_set_wol,
1252 .get_link = ethtool_op_get_link,
1253 .get_rx_csum = typhoon_get_rx_csum,
1254 .get_tx_csum = ethtool_op_get_tx_csum,
1255 .set_tx_csum = ethtool_op_set_tx_csum,
1256 .get_sg = ethtool_op_get_sg,
1257 .set_sg = ethtool_op_set_sg,
1258 .get_tso = ethtool_op_get_tso,
1259 .set_tso = ethtool_op_set_tso,
1260 .get_ringparam = typhoon_get_ringparam,
1261};
1262
1263static int
1264typhoon_wait_interrupt(void __iomem *ioaddr)
1265{
1266 int i, err = 0;
1267
1268 for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
1269 if(ioread32(ioaddr + TYPHOON_REG_INTR_STATUS) &
1270 TYPHOON_INTR_BOOTCMD)
1271 goto out;
1272 udelay(TYPHOON_UDELAY);
1273 }
1274
1275 err = -ETIMEDOUT;
1276
1277out:
1278 iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
1279 return err;
1280}
1281
1282#define shared_offset(x) offsetof(struct typhoon_shared, x)
1283
1284static void
1285typhoon_init_interface(struct typhoon *tp)
1286{
1287 struct typhoon_interface *iface = &tp->shared->iface;
1288 dma_addr_t shared_dma;
1289
1290 memset(tp->shared, 0, sizeof(struct typhoon_shared));
1291
1292 /* The *Hi members of iface are all init'd to zero by the memset().
1293 */
1294 shared_dma = tp->shared_dma + shared_offset(indexes);
1295 iface->ringIndex = cpu_to_le32(shared_dma);
1296
1297 shared_dma = tp->shared_dma + shared_offset(txLo);
1298 iface->txLoAddr = cpu_to_le32(shared_dma);
1299 iface->txLoSize = cpu_to_le32(TXLO_ENTRIES * sizeof(struct tx_desc));
1300
1301 shared_dma = tp->shared_dma + shared_offset(txHi);
1302 iface->txHiAddr = cpu_to_le32(shared_dma);
1303 iface->txHiSize = cpu_to_le32(TXHI_ENTRIES * sizeof(struct tx_desc));
1304
1305 shared_dma = tp->shared_dma + shared_offset(rxBuff);
1306 iface->rxBuffAddr = cpu_to_le32(shared_dma);
1307 iface->rxBuffSize = cpu_to_le32(RXFREE_ENTRIES *
1308 sizeof(struct rx_free));
1309
1310 shared_dma = tp->shared_dma + shared_offset(rxLo);
1311 iface->rxLoAddr = cpu_to_le32(shared_dma);
1312 iface->rxLoSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
1313
1314 shared_dma = tp->shared_dma + shared_offset(rxHi);
1315 iface->rxHiAddr = cpu_to_le32(shared_dma);
1316 iface->rxHiSize = cpu_to_le32(RX_ENTRIES * sizeof(struct rx_desc));
1317
1318 shared_dma = tp->shared_dma + shared_offset(cmd);
1319 iface->cmdAddr = cpu_to_le32(shared_dma);
1320 iface->cmdSize = cpu_to_le32(COMMAND_RING_SIZE);
1321
1322 shared_dma = tp->shared_dma + shared_offset(resp);
1323 iface->respAddr = cpu_to_le32(shared_dma);
1324 iface->respSize = cpu_to_le32(RESPONSE_RING_SIZE);
1325
1326 shared_dma = tp->shared_dma + shared_offset(zeroWord);
1327 iface->zeroAddr = cpu_to_le32(shared_dma);
1328
1329 tp->indexes = &tp->shared->indexes;
1330 tp->txLoRing.ringBase = (u8 *) tp->shared->txLo;
1331 tp->txHiRing.ringBase = (u8 *) tp->shared->txHi;
1332 tp->rxLoRing.ringBase = (u8 *) tp->shared->rxLo;
1333 tp->rxHiRing.ringBase = (u8 *) tp->shared->rxHi;
1334 tp->rxBuffRing.ringBase = (u8 *) tp->shared->rxBuff;
1335 tp->cmdRing.ringBase = (u8 *) tp->shared->cmd;
1336 tp->respRing.ringBase = (u8 *) tp->shared->resp;
1337
1338 tp->txLoRing.writeRegister = TYPHOON_REG_TX_LO_READY;
1339 tp->txHiRing.writeRegister = TYPHOON_REG_TX_HI_READY;
1340
1341 tp->txlo_dma_addr = iface->txLoAddr;
1342 tp->card_state = Sleeping;
1343 smp_wmb();
1344
1345 tp->offload = TYPHOON_OFFLOAD_IP_CHKSUM | TYPHOON_OFFLOAD_TCP_CHKSUM;
1346 tp->offload |= TYPHOON_OFFLOAD_UDP_CHKSUM | TSO_OFFLOAD_ON;
1347
1348 spin_lock_init(&tp->command_lock);
1349 spin_lock_init(&tp->state_lock);
1350}
1351
1352static void
1353typhoon_init_rings(struct typhoon *tp)
1354{
1355 memset(tp->indexes, 0, sizeof(struct typhoon_indexes));
1356
1357 tp->txLoRing.lastWrite = 0;
1358 tp->txHiRing.lastWrite = 0;
1359 tp->rxLoRing.lastWrite = 0;
1360 tp->rxHiRing.lastWrite = 0;
1361 tp->rxBuffRing.lastWrite = 0;
1362 tp->cmdRing.lastWrite = 0;
1363 tp->cmdRing.lastWrite = 0;
1364
1365 tp->txLoRing.lastRead = 0;
1366 tp->txHiRing.lastRead = 0;
1367}
1368
1369static int
1370typhoon_download_firmware(struct typhoon *tp)
1371{
1372 void __iomem *ioaddr = tp->ioaddr;
1373 struct pci_dev *pdev = tp->pdev;
1374 struct typhoon_file_header *fHdr;
1375 struct typhoon_section_header *sHdr;
1376 u8 *image_data;
1377 void *dpage;
1378 dma_addr_t dpage_dma;
1379 unsigned int csum;
1380 u32 irqEnabled;
1381 u32 irqMasked;
1382 u32 numSections;
1383 u32 section_len;
1384 u32 len;
1385 u32 load_addr;
1386 u32 hmac;
1387 int i;
1388 int err;
1389
1390 err = -EINVAL;
1391 fHdr = (struct typhoon_file_header *) typhoon_firmware_image;
1392 image_data = (u8 *) fHdr;
1393
1394 if(memcmp(fHdr->tag, "TYPHOON", 8)) {
1395 printk(KERN_ERR "%s: Invalid firmware image!\n", tp->name);
1396 goto err_out;
1397 }
1398
1399 /* Cannot just map the firmware image using pci_map_single() as
1400 * the firmware is part of the kernel/module image, so we allocate
1401 * some consistent memory to copy the sections into, as it is simpler,
1402 * and short-lived. If we ever split out and require a userland
1403 * firmware loader, then we can revisit this.
1404 */
1405 err = -ENOMEM;
1406 dpage = pci_alloc_consistent(pdev, PAGE_SIZE, &dpage_dma);
1407 if(!dpage) {
1408 printk(KERN_ERR "%s: no DMA mem for firmware\n", tp->name);
1409 goto err_out;
1410 }
1411
1412 irqEnabled = ioread32(ioaddr + TYPHOON_REG_INTR_ENABLE);
1413 iowrite32(irqEnabled | TYPHOON_INTR_BOOTCMD,
1414 ioaddr + TYPHOON_REG_INTR_ENABLE);
1415 irqMasked = ioread32(ioaddr + TYPHOON_REG_INTR_MASK);
1416 iowrite32(irqMasked | TYPHOON_INTR_BOOTCMD,
1417 ioaddr + TYPHOON_REG_INTR_MASK);
1418
1419 err = -ETIMEDOUT;
1420 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
1421 printk(KERN_ERR "%s: card ready timeout\n", tp->name);
1422 goto err_out_irq;
1423 }
1424
1425 numSections = le32_to_cpu(fHdr->numSections);
1426 load_addr = le32_to_cpu(fHdr->startAddr);
1427
1428 iowrite32(TYPHOON_INTR_BOOTCMD, ioaddr + TYPHOON_REG_INTR_STATUS);
1429 iowrite32(load_addr, ioaddr + TYPHOON_REG_DOWNLOAD_BOOT_ADDR);
1430 hmac = le32_to_cpu(fHdr->hmacDigest[0]);
1431 iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_0);
1432 hmac = le32_to_cpu(fHdr->hmacDigest[1]);
1433 iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_1);
1434 hmac = le32_to_cpu(fHdr->hmacDigest[2]);
1435 iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_2);
1436 hmac = le32_to_cpu(fHdr->hmacDigest[3]);
1437 iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_3);
1438 hmac = le32_to_cpu(fHdr->hmacDigest[4]);
1439 iowrite32(hmac, ioaddr + TYPHOON_REG_DOWNLOAD_HMAC_4);
1440 typhoon_post_pci_writes(ioaddr);
1441 iowrite32(TYPHOON_BOOTCMD_RUNTIME_IMAGE, ioaddr + TYPHOON_REG_COMMAND);
1442
1443 image_data += sizeof(struct typhoon_file_header);
1444
1445 /* The ioread32() in typhoon_wait_interrupt() will force the
1446 * last write to the command register to post, so
1447 * we don't need a typhoon_post_pci_writes() after it.
1448 */
1449 for(i = 0; i < numSections; i++) {
1450 sHdr = (struct typhoon_section_header *) image_data;
1451 image_data += sizeof(struct typhoon_section_header);
1452 load_addr = le32_to_cpu(sHdr->startAddr);
1453 section_len = le32_to_cpu(sHdr->len);
1454
1455 while(section_len) {
1456 len = min_t(u32, section_len, PAGE_SIZE);
1457
1458 if(typhoon_wait_interrupt(ioaddr) < 0 ||
1459 ioread32(ioaddr + TYPHOON_REG_STATUS) !=
1460 TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
1461 printk(KERN_ERR "%s: segment ready timeout\n",
1462 tp->name);
1463 goto err_out_irq;
1464 }
1465
1466 /* Do an pseudo IPv4 checksum on the data -- first
1467 * need to convert each u16 to cpu order before
1468 * summing. Fortunately, due to the properties of
1469 * the checksum, we can do this once, at the end.
1470 */
1471 csum = csum_partial_copy_nocheck(image_data, dpage,
1472 len, 0);
1473 csum = csum_fold(csum);
1474 csum = le16_to_cpu(csum);
1475
1476 iowrite32(len, ioaddr + TYPHOON_REG_BOOT_LENGTH);
1477 iowrite32(csum, ioaddr + TYPHOON_REG_BOOT_CHECKSUM);
1478 iowrite32(load_addr,
1479 ioaddr + TYPHOON_REG_BOOT_DEST_ADDR);
1480 iowrite32(0, ioaddr + TYPHOON_REG_BOOT_DATA_HI);
1481 iowrite32(dpage_dma, ioaddr + TYPHOON_REG_BOOT_DATA_LO);
1482 typhoon_post_pci_writes(ioaddr);
1483 iowrite32(TYPHOON_BOOTCMD_SEG_AVAILABLE,
1484 ioaddr + TYPHOON_REG_COMMAND);
1485
1486 image_data += len;
1487 load_addr += len;
1488 section_len -= len;
1489 }
1490 }
1491
1492 if(typhoon_wait_interrupt(ioaddr) < 0 ||
1493 ioread32(ioaddr + TYPHOON_REG_STATUS) !=
1494 TYPHOON_STATUS_WAITING_FOR_SEGMENT) {
1495 printk(KERN_ERR "%s: final segment ready timeout\n", tp->name);
1496 goto err_out_irq;
1497 }
1498
1499 iowrite32(TYPHOON_BOOTCMD_DNLD_COMPLETE, ioaddr + TYPHOON_REG_COMMAND);
1500
1501 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
1502 printk(KERN_ERR "%s: boot ready timeout, status 0x%0x\n",
1503 tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
1504 goto err_out_irq;
1505 }
1506
1507 err = 0;
1508
1509err_out_irq:
1510 iowrite32(irqMasked, ioaddr + TYPHOON_REG_INTR_MASK);
1511 iowrite32(irqEnabled, ioaddr + TYPHOON_REG_INTR_ENABLE);
1512
1513 pci_free_consistent(pdev, PAGE_SIZE, dpage, dpage_dma);
1514
1515err_out:
1516 return err;
1517}
1518
1519static int
1520typhoon_boot_3XP(struct typhoon *tp, u32 initial_status)
1521{
1522 void __iomem *ioaddr = tp->ioaddr;
1523
1524 if(typhoon_wait_status(ioaddr, initial_status) < 0) {
1525 printk(KERN_ERR "%s: boot ready timeout\n", tp->name);
1526 goto out_timeout;
1527 }
1528
1529 iowrite32(0, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_HI);
1530 iowrite32(tp->shared_dma, ioaddr + TYPHOON_REG_BOOT_RECORD_ADDR_LO);
1531 typhoon_post_pci_writes(ioaddr);
1532 iowrite32(TYPHOON_BOOTCMD_REG_BOOT_RECORD,
1533 ioaddr + TYPHOON_REG_COMMAND);
1534
1535 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_RUNNING) < 0) {
1536 printk(KERN_ERR "%s: boot finish timeout (status 0x%x)\n",
1537 tp->name, ioread32(ioaddr + TYPHOON_REG_STATUS));
1538 goto out_timeout;
1539 }
1540
1541 /* Clear the Transmit and Command ready registers
1542 */
1543 iowrite32(0, ioaddr + TYPHOON_REG_TX_HI_READY);
1544 iowrite32(0, ioaddr + TYPHOON_REG_CMD_READY);
1545 iowrite32(0, ioaddr + TYPHOON_REG_TX_LO_READY);
1546 typhoon_post_pci_writes(ioaddr);
1547 iowrite32(TYPHOON_BOOTCMD_BOOT, ioaddr + TYPHOON_REG_COMMAND);
1548
1549 return 0;
1550
1551out_timeout:
1552 return -ETIMEDOUT;
1553}
1554
1555static u32
1556typhoon_clean_tx(struct typhoon *tp, struct transmit_ring *txRing,
1557 volatile u32 * index)
1558{
1559 u32 lastRead = txRing->lastRead;
1560 struct tx_desc *tx;
1561 dma_addr_t skb_dma;
1562 int dma_len;
1563 int type;
1564
1565 while(lastRead != le32_to_cpu(*index)) {
1566 tx = (struct tx_desc *) (txRing->ringBase + lastRead);
1567 type = tx->flags & TYPHOON_TYPE_MASK;
1568
1569 if(type == TYPHOON_TX_DESC) {
1570 /* This tx_desc describes a packet.
1571 */
1572 unsigned long ptr = tx->addr | ((u64)tx->addrHi << 32);
1573 struct sk_buff *skb = (struct sk_buff *) ptr;
1574 dev_kfree_skb_irq(skb);
1575 } else if(type == TYPHOON_FRAG_DESC) {
1576 /* This tx_desc describes a memory mapping. Free it.
1577 */
1578 skb_dma = (dma_addr_t) le32_to_cpu(tx->addr);
1579 dma_len = le16_to_cpu(tx->len);
1580 pci_unmap_single(tp->pdev, skb_dma, dma_len,
1581 PCI_DMA_TODEVICE);
1582 }
1583
1584 tx->flags = 0;
1585 typhoon_inc_tx_index(&lastRead, 1);
1586 }
1587
1588 return lastRead;
1589}
1590
1591static void
1592typhoon_tx_complete(struct typhoon *tp, struct transmit_ring *txRing,
1593 volatile u32 * index)
1594{
1595 u32 lastRead;
1596 int numDesc = MAX_SKB_FRAGS + 1;
1597
1598 /* This will need changing if we start to use the Hi Tx ring. */
1599 lastRead = typhoon_clean_tx(tp, txRing, index);
1600 if(netif_queue_stopped(tp->dev) && typhoon_num_free(txRing->lastWrite,
1601 lastRead, TXLO_ENTRIES) > (numDesc + 2))
1602 netif_wake_queue(tp->dev);
1603
1604 txRing->lastRead = lastRead;
1605 smp_wmb();
1606}
1607
1608static void
1609typhoon_recycle_rx_skb(struct typhoon *tp, u32 idx)
1610{
1611 struct typhoon_indexes *indexes = tp->indexes;
1612 struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
1613 struct basic_ring *ring = &tp->rxBuffRing;
1614 struct rx_free *r;
1615
1616 if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
1617 indexes->rxBuffCleared) {
1618 /* no room in ring, just drop the skb
1619 */
1620 dev_kfree_skb_any(rxb->skb);
1621 rxb->skb = NULL;
1622 return;
1623 }
1624
1625 r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
1626 typhoon_inc_rxfree_index(&ring->lastWrite, 1);
1627 r->virtAddr = idx;
1628 r->physAddr = cpu_to_le32(rxb->dma_addr);
1629
1630 /* Tell the card about it */
1631 wmb();
1632 indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
1633}
1634
1635static int
1636typhoon_alloc_rx_skb(struct typhoon *tp, u32 idx)
1637{
1638 struct typhoon_indexes *indexes = tp->indexes;
1639 struct rxbuff_ent *rxb = &tp->rxbuffers[idx];
1640 struct basic_ring *ring = &tp->rxBuffRing;
1641 struct rx_free *r;
1642 struct sk_buff *skb;
1643 dma_addr_t dma_addr;
1644
1645 rxb->skb = NULL;
1646
1647 if((ring->lastWrite + sizeof(*r)) % (RXFREE_ENTRIES * sizeof(*r)) ==
1648 indexes->rxBuffCleared)
1649 return -ENOMEM;
1650
1651 skb = dev_alloc_skb(PKT_BUF_SZ);
1652 if(!skb)
1653 return -ENOMEM;
1654
1655#if 0
1656 /* Please, 3com, fix the firmware to allow DMA to a unaligned
1657 * address! Pretty please?
1658 */
1659 skb_reserve(skb, 2);
1660#endif
1661
1662 skb->dev = tp->dev;
David S. Miller689be432005-06-28 15:25:31 -07001663 dma_addr = pci_map_single(tp->pdev, skb->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
1665
1666 /* Since no card does 64 bit DAC, the high bits will never
1667 * change from zero.
1668 */
1669 r = (struct rx_free *) (ring->ringBase + ring->lastWrite);
1670 typhoon_inc_rxfree_index(&ring->lastWrite, 1);
1671 r->virtAddr = idx;
1672 r->physAddr = cpu_to_le32(dma_addr);
1673 rxb->skb = skb;
1674 rxb->dma_addr = dma_addr;
1675
1676 /* Tell the card about it */
1677 wmb();
1678 indexes->rxBuffReady = cpu_to_le32(ring->lastWrite);
1679 return 0;
1680}
1681
1682static int
1683typhoon_rx(struct typhoon *tp, struct basic_ring *rxRing, volatile u32 * ready,
1684 volatile u32 * cleared, int budget)
1685{
1686 struct rx_desc *rx;
1687 struct sk_buff *skb, *new_skb;
1688 struct rxbuff_ent *rxb;
1689 dma_addr_t dma_addr;
1690 u32 local_ready;
1691 u32 rxaddr;
1692 int pkt_len;
1693 u32 idx;
1694 u32 csum_bits;
1695 int received;
1696
1697 received = 0;
1698 local_ready = le32_to_cpu(*ready);
1699 rxaddr = le32_to_cpu(*cleared);
1700 while(rxaddr != local_ready && budget > 0) {
1701 rx = (struct rx_desc *) (rxRing->ringBase + rxaddr);
1702 idx = rx->addr;
1703 rxb = &tp->rxbuffers[idx];
1704 skb = rxb->skb;
1705 dma_addr = rxb->dma_addr;
1706
1707 typhoon_inc_rx_index(&rxaddr, 1);
1708
1709 if(rx->flags & TYPHOON_RX_ERROR) {
1710 typhoon_recycle_rx_skb(tp, idx);
1711 continue;
1712 }
1713
1714 pkt_len = le16_to_cpu(rx->frameLen);
1715
1716 if(pkt_len < rx_copybreak &&
1717 (new_skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1718 new_skb->dev = tp->dev;
1719 skb_reserve(new_skb, 2);
1720 pci_dma_sync_single_for_cpu(tp->pdev, dma_addr,
1721 PKT_BUF_SZ,
1722 PCI_DMA_FROMDEVICE);
David S. Miller689be432005-06-28 15:25:31 -07001723 eth_copy_and_sum(new_skb, skb->data, pkt_len, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 pci_dma_sync_single_for_device(tp->pdev, dma_addr,
1725 PKT_BUF_SZ,
1726 PCI_DMA_FROMDEVICE);
1727 skb_put(new_skb, pkt_len);
1728 typhoon_recycle_rx_skb(tp, idx);
1729 } else {
1730 new_skb = skb;
1731 skb_put(new_skb, pkt_len);
1732 pci_unmap_single(tp->pdev, dma_addr, PKT_BUF_SZ,
1733 PCI_DMA_FROMDEVICE);
1734 typhoon_alloc_rx_skb(tp, idx);
1735 }
1736 new_skb->protocol = eth_type_trans(new_skb, tp->dev);
1737 csum_bits = rx->rxStatus & (TYPHOON_RX_IP_CHK_GOOD |
1738 TYPHOON_RX_UDP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD);
1739 if(csum_bits ==
1740 (TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_TCP_CHK_GOOD)
1741 || csum_bits ==
1742 (TYPHOON_RX_IP_CHK_GOOD | TYPHOON_RX_UDP_CHK_GOOD)) {
1743 new_skb->ip_summed = CHECKSUM_UNNECESSARY;
1744 } else
1745 new_skb->ip_summed = CHECKSUM_NONE;
1746
1747 spin_lock(&tp->state_lock);
1748 if(tp->vlgrp != NULL && rx->rxStatus & TYPHOON_RX_VLAN)
1749 vlan_hwaccel_receive_skb(new_skb, tp->vlgrp,
1750 ntohl(rx->vlanTag) & 0xffff);
1751 else
1752 netif_receive_skb(new_skb);
1753 spin_unlock(&tp->state_lock);
1754
1755 tp->dev->last_rx = jiffies;
1756 received++;
1757 budget--;
1758 }
1759 *cleared = cpu_to_le32(rxaddr);
1760
1761 return received;
1762}
1763
1764static void
1765typhoon_fill_free_ring(struct typhoon *tp)
1766{
1767 u32 i;
1768
1769 for(i = 0; i < RXENT_ENTRIES; i++) {
1770 struct rxbuff_ent *rxb = &tp->rxbuffers[i];
1771 if(rxb->skb)
1772 continue;
1773 if(typhoon_alloc_rx_skb(tp, i) < 0)
1774 break;
1775 }
1776}
1777
1778static int
1779typhoon_poll(struct net_device *dev, int *total_budget)
1780{
1781 struct typhoon *tp = netdev_priv(dev);
1782 struct typhoon_indexes *indexes = tp->indexes;
1783 int orig_budget = *total_budget;
1784 int budget, work_done, done;
1785
1786 rmb();
1787 if(!tp->awaiting_resp && indexes->respReady != indexes->respCleared)
1788 typhoon_process_response(tp, 0, NULL);
1789
1790 if(le32_to_cpu(indexes->txLoCleared) != tp->txLoRing.lastRead)
1791 typhoon_tx_complete(tp, &tp->txLoRing, &indexes->txLoCleared);
1792
1793 if(orig_budget > dev->quota)
1794 orig_budget = dev->quota;
1795
1796 budget = orig_budget;
1797 work_done = 0;
1798 done = 1;
1799
1800 if(indexes->rxHiCleared != indexes->rxHiReady) {
1801 work_done = typhoon_rx(tp, &tp->rxHiRing, &indexes->rxHiReady,
1802 &indexes->rxHiCleared, budget);
1803 budget -= work_done;
1804 }
1805
1806 if(indexes->rxLoCleared != indexes->rxLoReady) {
1807 work_done += typhoon_rx(tp, &tp->rxLoRing, &indexes->rxLoReady,
1808 &indexes->rxLoCleared, budget);
1809 }
1810
1811 if(work_done) {
1812 *total_budget -= work_done;
1813 dev->quota -= work_done;
1814
1815 if(work_done >= orig_budget)
1816 done = 0;
1817 }
1818
1819 if(le32_to_cpu(indexes->rxBuffCleared) == tp->rxBuffRing.lastWrite) {
1820 /* rxBuff ring is empty, try to fill it. */
1821 typhoon_fill_free_ring(tp);
1822 }
1823
1824 if(done) {
1825 netif_rx_complete(dev);
1826 iowrite32(TYPHOON_INTR_NONE,
1827 tp->ioaddr + TYPHOON_REG_INTR_MASK);
1828 typhoon_post_pci_writes(tp->ioaddr);
1829 }
1830
1831 return (done ? 0 : 1);
1832}
1833
1834static irqreturn_t
1835typhoon_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)
1836{
1837 struct net_device *dev = (struct net_device *) dev_instance;
1838 struct typhoon *tp = dev->priv;
1839 void __iomem *ioaddr = tp->ioaddr;
1840 u32 intr_status;
1841
1842 intr_status = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
1843 if(!(intr_status & TYPHOON_INTR_HOST_INT))
1844 return IRQ_NONE;
1845
1846 iowrite32(intr_status, ioaddr + TYPHOON_REG_INTR_STATUS);
1847
1848 if(netif_rx_schedule_prep(dev)) {
1849 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
1850 typhoon_post_pci_writes(ioaddr);
1851 __netif_rx_schedule(dev);
1852 } else {
1853 printk(KERN_ERR "%s: Error, poll already scheduled\n",
1854 dev->name);
1855 }
1856 return IRQ_HANDLED;
1857}
1858
1859static void
1860typhoon_free_rx_rings(struct typhoon *tp)
1861{
1862 u32 i;
1863
1864 for(i = 0; i < RXENT_ENTRIES; i++) {
1865 struct rxbuff_ent *rxb = &tp->rxbuffers[i];
1866 if(rxb->skb) {
1867 pci_unmap_single(tp->pdev, rxb->dma_addr, PKT_BUF_SZ,
1868 PCI_DMA_FROMDEVICE);
1869 dev_kfree_skb(rxb->skb);
1870 rxb->skb = NULL;
1871 }
1872 }
1873}
1874
1875static int
1876typhoon_sleep(struct typhoon *tp, pci_power_t state, u16 events)
1877{
1878 struct pci_dev *pdev = tp->pdev;
1879 void __iomem *ioaddr = tp->ioaddr;
1880 struct cmd_desc xp_cmd;
1881 int err;
1882
1883 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_ENABLE_WAKE_EVENTS);
1884 xp_cmd.parm1 = events;
1885 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1886 if(err < 0) {
1887 printk(KERN_ERR "%s: typhoon_sleep(): wake events cmd err %d\n",
1888 tp->name, err);
1889 return err;
1890 }
1891
1892 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_GOTO_SLEEP);
1893 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1894 if(err < 0) {
1895 printk(KERN_ERR "%s: typhoon_sleep(): sleep cmd err %d\n",
1896 tp->name, err);
1897 return err;
1898 }
1899
1900 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_SLEEPING) < 0)
1901 return -ETIMEDOUT;
1902
1903 /* Since we cannot monitor the status of the link while sleeping,
1904 * tell the world it went away.
1905 */
1906 netif_carrier_off(tp->dev);
1907
Pavel Machek2a569572005-07-07 17:56:40 -07001908 pci_enable_wake(tp->pdev, state, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 pci_disable_device(pdev);
Pavel Machek2a569572005-07-07 17:56:40 -07001910 return pci_set_power_state(pdev, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911}
1912
1913static int
1914typhoon_wakeup(struct typhoon *tp, int wait_type)
1915{
1916 struct pci_dev *pdev = tp->pdev;
1917 void __iomem *ioaddr = tp->ioaddr;
1918
1919 pci_set_power_state(pdev, PCI_D0);
1920 pci_restore_state(pdev);
1921
1922 /* Post 2.x.x versions of the Sleep Image require a reset before
1923 * we can download the Runtime Image. But let's not make users of
1924 * the old firmware pay for the reset.
1925 */
1926 iowrite32(TYPHOON_BOOTCMD_WAKEUP, ioaddr + TYPHOON_REG_COMMAND);
1927 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_WAITING_FOR_HOST) < 0 ||
1928 (tp->capabilities & TYPHOON_WAKEUP_NEEDS_RESET))
1929 return typhoon_reset(ioaddr, wait_type);
1930
1931 return 0;
1932}
1933
1934static int
1935typhoon_start_runtime(struct typhoon *tp)
1936{
1937 struct net_device *dev = tp->dev;
1938 void __iomem *ioaddr = tp->ioaddr;
1939 struct cmd_desc xp_cmd;
1940 int err;
1941
1942 typhoon_init_rings(tp);
1943 typhoon_fill_free_ring(tp);
1944
1945 err = typhoon_download_firmware(tp);
1946 if(err < 0) {
1947 printk("%s: cannot load runtime on 3XP\n", tp->name);
1948 goto error_out;
1949 }
1950
1951 if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_BOOT) < 0) {
1952 printk("%s: cannot boot 3XP\n", tp->name);
1953 err = -EIO;
1954 goto error_out;
1955 }
1956
1957 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAX_PKT_SIZE);
1958 xp_cmd.parm1 = cpu_to_le16(PKT_BUF_SZ);
1959 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1960 if(err < 0)
1961 goto error_out;
1962
1963 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
1964 xp_cmd.parm1 = cpu_to_le16(ntohs(*(u16 *)&dev->dev_addr[0]));
1965 xp_cmd.parm2 = cpu_to_le32(ntohl(*(u32 *)&dev->dev_addr[2]));
1966 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1967 if(err < 0)
1968 goto error_out;
1969
1970 /* Disable IRQ coalescing -- we can reenable it when 3Com gives
1971 * us some more information on how to control it.
1972 */
1973 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_IRQ_COALESCE_CTRL);
1974 xp_cmd.parm1 = 0;
1975 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1976 if(err < 0)
1977 goto error_out;
1978
1979 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_XCVR_SELECT);
1980 xp_cmd.parm1 = tp->xcvr_select;
1981 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1982 if(err < 0)
1983 goto error_out;
1984
1985 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_VLAN_TYPE_WRITE);
1986 xp_cmd.parm1 = __constant_cpu_to_le16(ETH_P_8021Q);
1987 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1988 if(err < 0)
1989 goto error_out;
1990
1991 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_OFFLOAD_TASKS);
1992 spin_lock_bh(&tp->state_lock);
1993 xp_cmd.parm2 = tp->offload;
1994 xp_cmd.parm3 = tp->offload;
1995 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
1996 spin_unlock_bh(&tp->state_lock);
1997 if(err < 0)
1998 goto error_out;
1999
2000 typhoon_set_rx_mode(dev);
2001
2002 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_ENABLE);
2003 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2004 if(err < 0)
2005 goto error_out;
2006
2007 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_ENABLE);
2008 err = typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2009 if(err < 0)
2010 goto error_out;
2011
2012 tp->card_state = Running;
2013 smp_wmb();
2014
2015 iowrite32(TYPHOON_INTR_ENABLE_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
2016 iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_MASK);
2017 typhoon_post_pci_writes(ioaddr);
2018
2019 return 0;
2020
2021error_out:
2022 typhoon_reset(ioaddr, WaitNoSleep);
2023 typhoon_free_rx_rings(tp);
2024 typhoon_init_rings(tp);
2025 return err;
2026}
2027
2028static int
2029typhoon_stop_runtime(struct typhoon *tp, int wait_type)
2030{
2031 struct typhoon_indexes *indexes = tp->indexes;
2032 struct transmit_ring *txLo = &tp->txLoRing;
2033 void __iomem *ioaddr = tp->ioaddr;
2034 struct cmd_desc xp_cmd;
2035 int i;
2036
2037 /* Disable interrupts early, since we can't schedule a poll
2038 * when called with !netif_running(). This will be posted
2039 * when we force the posting of the command.
2040 */
2041 iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
2042
2043 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_RX_DISABLE);
2044 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2045
2046 /* Wait 1/2 sec for any outstanding transmits to occur
2047 * We'll cleanup after the reset if this times out.
2048 */
2049 for(i = 0; i < TYPHOON_WAIT_TIMEOUT; i++) {
2050 if(indexes->txLoCleared == cpu_to_le32(txLo->lastWrite))
2051 break;
2052 udelay(TYPHOON_UDELAY);
2053 }
2054
2055 if(i == TYPHOON_WAIT_TIMEOUT)
2056 printk(KERN_ERR
2057 "%s: halt timed out waiting for Tx to complete\n",
2058 tp->name);
2059
2060 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_TX_DISABLE);
2061 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2062
2063 /* save the statistics so when we bring the interface up again,
2064 * the values reported to userspace are correct.
2065 */
2066 tp->card_state = Sleeping;
2067 smp_wmb();
2068 typhoon_do_get_stats(tp);
2069 memcpy(&tp->stats_saved, &tp->stats, sizeof(struct net_device_stats));
2070
2071 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_HALT);
2072 typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL);
2073
2074 if(typhoon_wait_status(ioaddr, TYPHOON_STATUS_HALTED) < 0)
2075 printk(KERN_ERR "%s: timed out waiting for 3XP to halt\n",
2076 tp->name);
2077
2078 if(typhoon_reset(ioaddr, wait_type) < 0) {
2079 printk(KERN_ERR "%s: unable to reset 3XP\n", tp->name);
2080 return -ETIMEDOUT;
2081 }
2082
2083 /* cleanup any outstanding Tx packets */
2084 if(indexes->txLoCleared != cpu_to_le32(txLo->lastWrite)) {
2085 indexes->txLoCleared = cpu_to_le32(txLo->lastWrite);
2086 typhoon_clean_tx(tp, &tp->txLoRing, &indexes->txLoCleared);
2087 }
2088
2089 return 0;
2090}
2091
2092static void
2093typhoon_tx_timeout(struct net_device *dev)
2094{
2095 struct typhoon *tp = netdev_priv(dev);
2096
2097 if(typhoon_reset(tp->ioaddr, WaitNoSleep) < 0) {
2098 printk(KERN_WARNING "%s: could not reset in tx timeout\n",
2099 dev->name);
2100 goto truely_dead;
2101 }
2102
2103 /* If we ever start using the Hi ring, it will need cleaning too */
2104 typhoon_clean_tx(tp, &tp->txLoRing, &tp->indexes->txLoCleared);
2105 typhoon_free_rx_rings(tp);
2106
2107 if(typhoon_start_runtime(tp) < 0) {
2108 printk(KERN_ERR "%s: could not start runtime in tx timeout\n",
2109 dev->name);
2110 goto truely_dead;
2111 }
2112
2113 netif_wake_queue(dev);
2114 return;
2115
2116truely_dead:
2117 /* Reset the hardware, and turn off carrier to avoid more timeouts */
2118 typhoon_reset(tp->ioaddr, NoWait);
2119 netif_carrier_off(dev);
2120}
2121
2122static int
2123typhoon_open(struct net_device *dev)
2124{
2125 struct typhoon *tp = netdev_priv(dev);
2126 int err;
2127
2128 err = typhoon_wakeup(tp, WaitSleep);
2129 if(err < 0) {
2130 printk(KERN_ERR "%s: unable to wakeup device\n", dev->name);
2131 goto out_sleep;
2132 }
2133
2134 err = request_irq(dev->irq, &typhoon_interrupt, SA_SHIRQ,
2135 dev->name, dev);
2136 if(err < 0)
2137 goto out_sleep;
2138
2139 err = typhoon_start_runtime(tp);
2140 if(err < 0)
2141 goto out_irq;
2142
2143 netif_start_queue(dev);
2144 return 0;
2145
2146out_irq:
2147 free_irq(dev->irq, dev);
2148
2149out_sleep:
2150 if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2151 printk(KERN_ERR "%s: unable to reboot into sleep img\n",
2152 dev->name);
2153 typhoon_reset(tp->ioaddr, NoWait);
2154 goto out;
2155 }
2156
2157 if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
2158 printk(KERN_ERR "%s: unable to go back to sleep\n", dev->name);
2159
2160out:
2161 return err;
2162}
2163
2164static int
2165typhoon_close(struct net_device *dev)
2166{
2167 struct typhoon *tp = netdev_priv(dev);
2168
2169 netif_stop_queue(dev);
2170
2171 if(typhoon_stop_runtime(tp, WaitSleep) < 0)
2172 printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
2173
2174 /* Make sure there is no irq handler running on a different CPU. */
2175 typhoon_synchronize_irq(dev->irq);
2176 free_irq(dev->irq, dev);
2177
2178 typhoon_free_rx_rings(tp);
2179 typhoon_init_rings(tp);
2180
2181 if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0)
2182 printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
2183
2184 if(typhoon_sleep(tp, PCI_D3hot, 0) < 0)
2185 printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
2186
2187 return 0;
2188}
2189
2190#ifdef CONFIG_PM
2191static int
2192typhoon_resume(struct pci_dev *pdev)
2193{
2194 struct net_device *dev = pci_get_drvdata(pdev);
2195 struct typhoon *tp = netdev_priv(dev);
2196
2197 /* If we're down, resume when we are upped.
2198 */
2199 if(!netif_running(dev))
2200 return 0;
2201
2202 if(typhoon_wakeup(tp, WaitNoSleep) < 0) {
2203 printk(KERN_ERR "%s: critical: could not wake up in resume\n",
2204 dev->name);
2205 goto reset;
2206 }
2207
2208 if(typhoon_start_runtime(tp) < 0) {
2209 printk(KERN_ERR "%s: critical: could not start runtime in "
2210 "resume\n", dev->name);
2211 goto reset;
2212 }
2213
2214 netif_device_attach(dev);
2215 netif_start_queue(dev);
2216 return 0;
2217
2218reset:
2219 typhoon_reset(tp->ioaddr, NoWait);
2220 return -EBUSY;
2221}
2222
2223static int
2224typhoon_suspend(struct pci_dev *pdev, pm_message_t state)
2225{
2226 struct net_device *dev = pci_get_drvdata(pdev);
2227 struct typhoon *tp = netdev_priv(dev);
2228 struct cmd_desc xp_cmd;
2229
2230 /* If we're down, we're already suspended.
2231 */
2232 if(!netif_running(dev))
2233 return 0;
2234
2235 spin_lock_bh(&tp->state_lock);
2236 if(tp->vlgrp && tp->wol_events & TYPHOON_WAKE_MAGIC_PKT) {
2237 spin_unlock_bh(&tp->state_lock);
2238 printk(KERN_ERR "%s: cannot do WAKE_MAGIC with VLANS\n",
2239 dev->name);
2240 return -EBUSY;
2241 }
2242 spin_unlock_bh(&tp->state_lock);
2243
2244 netif_device_detach(dev);
2245
2246 if(typhoon_stop_runtime(tp, WaitNoSleep) < 0) {
2247 printk(KERN_ERR "%s: unable to stop runtime\n", dev->name);
2248 goto need_resume;
2249 }
2250
2251 typhoon_free_rx_rings(tp);
2252 typhoon_init_rings(tp);
2253
2254 if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2255 printk(KERN_ERR "%s: unable to boot sleep image\n", dev->name);
2256 goto need_resume;
2257 }
2258
2259 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_MAC_ADDRESS);
2260 xp_cmd.parm1 = cpu_to_le16(ntohs(*(u16 *)&dev->dev_addr[0]));
2261 xp_cmd.parm2 = cpu_to_le32(ntohl(*(u32 *)&dev->dev_addr[2]));
2262 if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
2263 printk(KERN_ERR "%s: unable to set mac address in suspend\n",
2264 dev->name);
2265 goto need_resume;
2266 }
2267
2268 INIT_COMMAND_NO_RESPONSE(&xp_cmd, TYPHOON_CMD_SET_RX_FILTER);
2269 xp_cmd.parm1 = TYPHOON_RX_FILTER_DIRECTED | TYPHOON_RX_FILTER_BROADCAST;
2270 if(typhoon_issue_command(tp, 1, &xp_cmd, 0, NULL) < 0) {
2271 printk(KERN_ERR "%s: unable to set rx filter in suspend\n",
2272 dev->name);
2273 goto need_resume;
2274 }
2275
Pavel Machek2a569572005-07-07 17:56:40 -07002276 if(typhoon_sleep(tp, pci_choose_state(pdev, state), tp->wol_events) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
2278 goto need_resume;
2279 }
2280
2281 return 0;
2282
2283need_resume:
2284 typhoon_resume(pdev);
2285 return -EBUSY;
2286}
2287
2288static int
Pavel Machek05adc3b2005-04-16 15:25:25 -07002289typhoon_enable_wake(struct pci_dev *pdev, pci_power_t state, int enable)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290{
2291 return pci_enable_wake(pdev, state, enable);
2292}
2293#endif
2294
2295static int __devinit
2296typhoon_test_mmio(struct pci_dev *pdev)
2297{
2298 void __iomem *ioaddr = pci_iomap(pdev, 1, 128);
2299 int mode = 0;
2300 u32 val;
2301
2302 if(!ioaddr)
2303 goto out;
2304
2305 if(ioread32(ioaddr + TYPHOON_REG_STATUS) !=
2306 TYPHOON_STATUS_WAITING_FOR_HOST)
2307 goto out_unmap;
2308
2309 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
2310 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
2311 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_ENABLE);
2312
2313 /* Ok, see if we can change our interrupt status register by
2314 * sending ourselves an interrupt. If so, then MMIO works.
2315 * The 50usec delay is arbitrary -- it could probably be smaller.
2316 */
2317 val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2318 if((val & TYPHOON_INTR_SELF) == 0) {
2319 iowrite32(1, ioaddr + TYPHOON_REG_SELF_INTERRUPT);
2320 ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2321 udelay(50);
2322 val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2323 if(val & TYPHOON_INTR_SELF)
2324 mode = 1;
2325 }
2326
2327 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_MASK);
2328 iowrite32(TYPHOON_INTR_ALL, ioaddr + TYPHOON_REG_INTR_STATUS);
2329 iowrite32(TYPHOON_INTR_NONE, ioaddr + TYPHOON_REG_INTR_ENABLE);
2330 ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);
2331
2332out_unmap:
2333 pci_iounmap(pdev, ioaddr);
2334
2335out:
2336 if(!mode)
2337 printk(KERN_INFO PFX "falling back to port IO\n");
2338 return mode;
2339}
2340
2341static int __devinit
2342typhoon_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2343{
2344 static int did_version = 0;
2345 struct net_device *dev;
2346 struct typhoon *tp;
2347 int card_id = (int) ent->driver_data;
2348 void __iomem *ioaddr;
2349 void *shared;
2350 dma_addr_t shared_dma;
2351 struct cmd_desc xp_cmd;
2352 struct resp_desc xp_resp[3];
2353 int i;
2354 int err = 0;
2355
2356 if(!did_version++)
2357 printk(KERN_INFO "%s", version);
2358
2359 dev = alloc_etherdev(sizeof(*tp));
2360 if(dev == NULL) {
2361 printk(ERR_PFX "%s: unable to alloc new net device\n",
2362 pci_name(pdev));
2363 err = -ENOMEM;
2364 goto error_out;
2365 }
2366 SET_MODULE_OWNER(dev);
2367 SET_NETDEV_DEV(dev, &pdev->dev);
2368
2369 err = pci_enable_device(pdev);
2370 if(err < 0) {
2371 printk(ERR_PFX "%s: unable to enable device\n",
2372 pci_name(pdev));
2373 goto error_out_dev;
2374 }
2375
2376 err = pci_set_mwi(pdev);
2377 if(err < 0) {
2378 printk(ERR_PFX "%s: unable to set MWI\n", pci_name(pdev));
2379 goto error_out_disable;
2380 }
2381
2382 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
2383 if(err < 0) {
2384 printk(ERR_PFX "%s: No usable DMA configuration\n",
2385 pci_name(pdev));
2386 goto error_out_mwi;
2387 }
2388
2389 /* sanity checks on IO and MMIO BARs
2390 */
2391 if(!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2392 printk(ERR_PFX
2393 "%s: region #1 not a PCI IO resource, aborting\n",
2394 pci_name(pdev));
2395 err = -ENODEV;
2396 goto error_out_mwi;
2397 }
2398 if(pci_resource_len(pdev, 0) < 128) {
2399 printk(ERR_PFX "%s: Invalid PCI IO region size, aborting\n",
2400 pci_name(pdev));
2401 err = -ENODEV;
2402 goto error_out_mwi;
2403 }
2404 if(!(pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) {
2405 printk(ERR_PFX
2406 "%s: region #1 not a PCI MMIO resource, aborting\n",
2407 pci_name(pdev));
2408 err = -ENODEV;
2409 goto error_out_mwi;
2410 }
2411 if(pci_resource_len(pdev, 1) < 128) {
2412 printk(ERR_PFX "%s: Invalid PCI MMIO region size, aborting\n",
2413 pci_name(pdev));
2414 err = -ENODEV;
2415 goto error_out_mwi;
2416 }
2417
2418 err = pci_request_regions(pdev, "typhoon");
2419 if(err < 0) {
2420 printk(ERR_PFX "%s: could not request regions\n",
2421 pci_name(pdev));
2422 goto error_out_mwi;
2423 }
2424
2425 /* map our registers
2426 */
2427 if(use_mmio != 0 && use_mmio != 1)
2428 use_mmio = typhoon_test_mmio(pdev);
2429
2430 ioaddr = pci_iomap(pdev, use_mmio, 128);
2431 if (!ioaddr) {
2432 printk(ERR_PFX "%s: cannot remap registers, aborting\n",
2433 pci_name(pdev));
2434 err = -EIO;
2435 goto error_out_regions;
2436 }
2437
2438 /* allocate pci dma space for rx and tx descriptor rings
2439 */
2440 shared = pci_alloc_consistent(pdev, sizeof(struct typhoon_shared),
2441 &shared_dma);
2442 if(!shared) {
2443 printk(ERR_PFX "%s: could not allocate DMA memory\n",
2444 pci_name(pdev));
2445 err = -ENOMEM;
2446 goto error_out_remap;
2447 }
2448
2449 dev->irq = pdev->irq;
2450 tp = netdev_priv(dev);
2451 tp->shared = (struct typhoon_shared *) shared;
2452 tp->shared_dma = shared_dma;
2453 tp->pdev = pdev;
2454 tp->tx_pdev = pdev;
2455 tp->ioaddr = ioaddr;
2456 tp->tx_ioaddr = ioaddr;
2457 tp->dev = dev;
2458
2459 /* Init sequence:
2460 * 1) Reset the adapter to clear any bad juju
2461 * 2) Reload the sleep image
2462 * 3) Boot the sleep image
2463 * 4) Get the hardware address.
2464 * 5) Put the card to sleep.
2465 */
2466 if (typhoon_reset(ioaddr, WaitSleep) < 0) {
2467 printk(ERR_PFX "%s: could not reset 3XP\n", pci_name(pdev));
2468 err = -EIO;
2469 goto error_out_dma;
2470 }
2471
2472 /* Now that we've reset the 3XP and are sure it's not going to
2473 * write all over memory, enable bus mastering, and save our
2474 * state for resuming after a suspend.
2475 */
2476 pci_set_master(pdev);
2477 pci_save_state(pdev);
2478
2479 /* dev->name is not valid until we register, but we need to
2480 * use some common routines to initialize the card. So that those
2481 * routines print the right name, we keep our oun pointer to the name
2482 */
2483 tp->name = pci_name(pdev);
2484
2485 typhoon_init_interface(tp);
2486 typhoon_init_rings(tp);
2487
2488 if(typhoon_boot_3XP(tp, TYPHOON_STATUS_WAITING_FOR_HOST) < 0) {
2489 printk(ERR_PFX "%s: cannot boot 3XP sleep image\n",
2490 pci_name(pdev));
2491 err = -EIO;
2492 goto error_out_reset;
2493 }
2494
2495 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_MAC_ADDRESS);
2496 if(typhoon_issue_command(tp, 1, &xp_cmd, 1, xp_resp) < 0) {
2497 printk(ERR_PFX "%s: cannot read MAC address\n",
2498 pci_name(pdev));
2499 err = -EIO;
2500 goto error_out_reset;
2501 }
2502
2503 *(u16 *)&dev->dev_addr[0] = htons(le16_to_cpu(xp_resp[0].parm1));
2504 *(u32 *)&dev->dev_addr[2] = htonl(le32_to_cpu(xp_resp[0].parm2));
2505
2506 if(!is_valid_ether_addr(dev->dev_addr)) {
2507 printk(ERR_PFX "%s: Could not obtain valid ethernet address, "
2508 "aborting\n", pci_name(pdev));
2509 goto error_out_reset;
2510 }
2511
2512 /* Read the Sleep Image version last, so the response is valid
2513 * later when we print out the version reported.
2514 */
2515 INIT_COMMAND_WITH_RESPONSE(&xp_cmd, TYPHOON_CMD_READ_VERSIONS);
2516 if(typhoon_issue_command(tp, 1, &xp_cmd, 3, xp_resp) < 0) {
2517 printk(ERR_PFX "%s: Could not get Sleep Image version\n",
2518 pci_name(pdev));
2519 goto error_out_reset;
2520 }
2521
2522 tp->capabilities = typhoon_card_info[card_id].capabilities;
2523 tp->xcvr_select = TYPHOON_XCVR_AUTONEG;
2524
2525 /* Typhoon 1.0 Sleep Images return one response descriptor to the
2526 * READ_VERSIONS command. Those versions are OK after waking up
2527 * from sleep without needing a reset. Typhoon 1.1+ Sleep Images
2528 * seem to need a little extra help to get started. Since we don't
2529 * know how to nudge it along, just kick it.
2530 */
2531 if(xp_resp[0].numDesc != 0)
2532 tp->capabilities |= TYPHOON_WAKEUP_NEEDS_RESET;
2533
2534 if(typhoon_sleep(tp, PCI_D3hot, 0) < 0) {
2535 printk(ERR_PFX "%s: cannot put adapter to sleep\n",
2536 pci_name(pdev));
2537 err = -EIO;
2538 goto error_out_reset;
2539 }
2540
2541 /* The chip-specific entries in the device structure. */
2542 dev->open = typhoon_open;
2543 dev->hard_start_xmit = typhoon_start_tx;
2544 dev->stop = typhoon_close;
2545 dev->set_multicast_list = typhoon_set_rx_mode;
2546 dev->tx_timeout = typhoon_tx_timeout;
2547 dev->poll = typhoon_poll;
2548 dev->weight = 16;
2549 dev->watchdog_timeo = TX_TIMEOUT;
2550 dev->get_stats = typhoon_get_stats;
2551 dev->set_mac_address = typhoon_set_mac_address;
2552 dev->vlan_rx_register = typhoon_vlan_rx_register;
2553 dev->vlan_rx_kill_vid = typhoon_vlan_rx_kill_vid;
2554 SET_ETHTOOL_OPS(dev, &typhoon_ethtool_ops);
2555
2556 /* We can handle scatter gather, up to 16 entries, and
2557 * we can do IP checksumming (only version 4, doh...)
2558 */
2559 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
2560 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
2561 dev->features |= NETIF_F_TSO;
2562
2563 if(register_netdev(dev) < 0)
2564 goto error_out_reset;
2565
2566 /* fixup our local name */
2567 tp->name = dev->name;
2568
2569 pci_set_drvdata(pdev, dev);
2570
2571 printk(KERN_INFO "%s: %s at %s 0x%lx, ",
2572 dev->name, typhoon_card_info[card_id].name,
2573 use_mmio ? "MMIO" : "IO", pci_resource_start(pdev, use_mmio));
2574 for(i = 0; i < 5; i++)
2575 printk("%2.2x:", dev->dev_addr[i]);
2576 printk("%2.2x\n", dev->dev_addr[i]);
2577
2578 /* xp_resp still contains the response to the READ_VERSIONS command.
2579 * For debugging, let the user know what version he has.
2580 */
2581 if(xp_resp[0].numDesc == 0) {
2582 /* This is the Typhoon 1.0 type Sleep Image, last 16 bits
2583 * of version is Month/Day of build.
2584 */
2585 u16 monthday = le32_to_cpu(xp_resp[0].parm2) & 0xffff;
2586 printk(KERN_INFO "%s: Typhoon 1.0 Sleep Image built "
2587 "%02u/%02u/2000\n", dev->name, monthday >> 8,
2588 monthday & 0xff);
2589 } else if(xp_resp[0].numDesc == 2) {
2590 /* This is the Typhoon 1.1+ type Sleep Image
2591 */
2592 u32 sleep_ver = le32_to_cpu(xp_resp[0].parm2);
2593 u8 *ver_string = (u8 *) &xp_resp[1];
2594 ver_string[25] = 0;
2595 printk(KERN_INFO "%s: Typhoon 1.1+ Sleep Image version "
2596 "%02x.%03x.%03x %s\n", dev->name, sleep_ver >> 24,
2597 (sleep_ver >> 12) & 0xfff, sleep_ver & 0xfff,
2598 ver_string);
2599 } else {
2600 printk(KERN_WARNING "%s: Unknown Sleep Image version "
2601 "(%u:%04x)\n", dev->name, xp_resp[0].numDesc,
2602 le32_to_cpu(xp_resp[0].parm2));
2603 }
2604
2605 return 0;
2606
2607error_out_reset:
2608 typhoon_reset(ioaddr, NoWait);
2609
2610error_out_dma:
2611 pci_free_consistent(pdev, sizeof(struct typhoon_shared),
2612 shared, shared_dma);
2613error_out_remap:
2614 pci_iounmap(pdev, ioaddr);
2615error_out_regions:
2616 pci_release_regions(pdev);
2617error_out_mwi:
2618 pci_clear_mwi(pdev);
2619error_out_disable:
2620 pci_disable_device(pdev);
2621error_out_dev:
2622 free_netdev(dev);
2623error_out:
2624 return err;
2625}
2626
2627static void __devexit
2628typhoon_remove_one(struct pci_dev *pdev)
2629{
2630 struct net_device *dev = pci_get_drvdata(pdev);
2631 struct typhoon *tp = netdev_priv(dev);
2632
2633 unregister_netdev(dev);
2634 pci_set_power_state(pdev, PCI_D0);
2635 pci_restore_state(pdev);
2636 typhoon_reset(tp->ioaddr, NoWait);
2637 pci_iounmap(pdev, tp->ioaddr);
2638 pci_free_consistent(pdev, sizeof(struct typhoon_shared),
2639 tp->shared, tp->shared_dma);
2640 pci_release_regions(pdev);
2641 pci_clear_mwi(pdev);
2642 pci_disable_device(pdev);
2643 pci_set_drvdata(pdev, NULL);
2644 free_netdev(dev);
2645}
2646
2647static struct pci_driver typhoon_driver = {
2648 .name = DRV_MODULE_NAME,
2649 .id_table = typhoon_pci_tbl,
2650 .probe = typhoon_init_one,
2651 .remove = __devexit_p(typhoon_remove_one),
2652#ifdef CONFIG_PM
2653 .suspend = typhoon_suspend,
2654 .resume = typhoon_resume,
2655 .enable_wake = typhoon_enable_wake,
2656#endif
2657};
2658
2659static int __init
2660typhoon_init(void)
2661{
2662 return pci_module_init(&typhoon_driver);
2663}
2664
2665static void __exit
2666typhoon_cleanup(void)
2667{
2668 pci_unregister_driver(&typhoon_driver);
2669}
2670
2671module_init(typhoon_init);
2672module_exit(typhoon_cleanup);