1 /**************************************************************************
3 * Copyright 2000-2006 Alacritech, Inc. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above
12 * copyright notice, this list of conditions and the following
13 * disclaimer in the documentation and/or other materials provided
14 * with the distribution.
16 * Alternatively, this software may be distributed under the terms of the
17 * GNU General Public License ("GPL") version 2 as published by the Free
18 * Software Foundation.
20 * THIS SOFTWARE IS PROVIDED BY ALACRITECH, INC. ``AS IS'' AND ANY
21 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ALACRITECH, INC. OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
27 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
28 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * The views and conclusions contained in the software and documentation
34 * are those of the authors and should not be interpreted as representing
35 * official policies, either expressed or implied, of Alacritech, Inc.
37 **************************************************************************/
42 * The SLICOSS driver for Alacritech's IS-NIC products.
44 * This driver is supposed to support:
46 * Mojave cards (single port PCI Gigabit) both copper and fiber
47 * Oasis cards (single and dual port PCI-x Gigabit) copper and fiber
48 * Kalahari cards (dual and quad port PCI-e Gigabit) copper and fiber
50 * The driver was acutally tested on Oasis and Kalahari cards.
53 * NOTE: This is the standard, non-accelerated version of Alacritech's
58 #define KLUDGE_FOR_4GB_BOUNDARY 1
59 #define DEBUG_MICROCODE 1
61 #define SLIC_INTERRUPT_PROCESS_LIMIT 1
62 #define SLIC_OFFLOAD_IP_CHECKSUM 1
63 #define STATS_TIMER_INTERVAL 2
64 #define PING_TIMER_INTERVAL 1
66 #include <linux/kernel.h>
67 #include <linux/string.h>
68 #include <linux/errno.h>
69 #include <linux/ioport.h>
70 #include <linux/slab.h>
71 #include <linux/interrupt.h>
72 #include <linux/timer.h>
73 #include <linux/pci.h>
74 #include <linux/spinlock.h>
75 #include <linux/init.h>
76 #include <linux/bitops.h>
78 #include <linux/netdevice.h>
79 #include <linux/etherdevice.h>
80 #include <linux/skbuff.h>
81 #include <linux/delay.h>
82 #include <linux/debugfs.h>
83 #include <linux/seq_file.h>
84 #include <linux/kthread.h>
85 #include <linux/module.h>
86 #include <linux/moduleparam.h>
88 #include <linux/firmware.h>
89 #include <linux/types.h>
90 #include <linux/dma-mapping.h>
91 #include <linux/mii.h>
92 #include <linux/if_vlan.h>
93 #include <asm/unaligned.h>
95 #include <linux/ethtool.h>
96 #include <linux/uaccess.h>
100 static uint slic_first_init
= 1;
101 static char *slic_banner
= "Alacritech SLIC Technology(tm) Server "\
102 "and Storage Accelerator (Non-Accelerated)";
104 static char *slic_proc_version
= "2.0.351 2006/07/14 12:26:00";
105 static char *slic_product_name
= "SLIC Technology(tm) Server "\
106 "and Storage Accelerator (Non-Accelerated)";
107 static char *slic_vendor
= "Alacritech, Inc.";
109 static int slic_debug
= 1;
110 static int debug
= -1;
111 static struct net_device
*head_netdevice
;
113 static struct base_driver slic_global
= { {}, 0, 0, 0, 1, NULL
, NULL
};
114 static int intagg_delay
= 100;
115 static u32 dynamic_intagg
;
116 static unsigned int rcv_count
;
117 static struct dentry
*slic_debugfs
;
119 #define DRV_NAME "slicoss"
120 #define DRV_VERSION "2.0.1"
121 #define DRV_AUTHOR "Alacritech, Inc. Engineering"
122 #define DRV_DESCRIPTION "Alacritech SLIC Techonology(tm) "\
123 "Non-Accelerated Driver"
124 #define DRV_COPYRIGHT "Copyright 2000-2006 Alacritech, Inc. "\
125 "All rights reserved."
126 #define PFX DRV_NAME " "
128 MODULE_AUTHOR(DRV_AUTHOR
);
129 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
130 MODULE_LICENSE("Dual BSD/GPL");
132 module_param(dynamic_intagg
, int, 0);
133 MODULE_PARM_DESC(dynamic_intagg
, "Dynamic Interrupt Aggregation Setting");
134 module_param(intagg_delay
, int, 0);
135 MODULE_PARM_DESC(intagg_delay
, "uSec Interrupt Aggregation Delay");
137 static DEFINE_PCI_DEVICE_TABLE(slic_pci_tbl
) = {
138 { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH
, SLIC_1GB_DEVICE_ID
) },
139 { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH
, SLIC_2GB_DEVICE_ID
) },
143 MODULE_DEVICE_TABLE(pci
, slic_pci_tbl
);
149 static void slic_assert_fail(void)
153 cpuid
= smp_processor_id();
154 curr_pid
= current
->pid
;
156 printk(KERN_ERR
"%s CPU # %d ---- PID # %d\n",
157 __func__
, cpuid
, curr_pid
);
161 #define ASSERT(a) do { \
163 printk(KERN_ERR "slicoss ASSERT() Failure: function %s" \
164 "line %d\n", __func__, __LINE__); \
165 slic_assert_fail(); \
171 #define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \
173 spin_lock_irqsave(&_adapter->handle_lock.lock, \
174 _adapter->handle_lock.flags); \
175 _pslic_handle = _adapter->pfree_slic_handles; \
176 if (_pslic_handle) { \
177 ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \
178 _adapter->pfree_slic_handles = _pslic_handle->next; \
180 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
181 _adapter->handle_lock.flags); \
184 #define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \
186 _pslic_handle->type = SLIC_HANDLE_FREE; \
187 spin_lock_irqsave(&_adapter->handle_lock.lock, \
188 _adapter->handle_lock.flags); \
189 _pslic_handle->next = _adapter->pfree_slic_handles; \
190 _adapter->pfree_slic_handles = _pslic_handle; \
191 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
192 _adapter->handle_lock.flags); \
195 static inline void slic_reg32_write(void __iomem
*reg
, u32 value
, bool flush
)
202 static inline void slic_reg64_write(struct adapter
*adapter
, void __iomem
*reg
,
203 u32 value
, void __iomem
*regh
, u32 paddrh
,
206 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
207 adapter
->bit64reglock
.flags
);
208 if (paddrh
!= adapter
->curaddrupper
) {
209 adapter
->curaddrupper
= paddrh
;
210 writel(paddrh
, regh
);
215 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
216 adapter
->bit64reglock
.flags
);
220 * Functions to obtain the CRC corresponding to the destination mac address.
221 * This is a standard ethernet CRC in that it is a 32-bit, reflected CRC using
223 * x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 +
226 * After the CRC for the 6 bytes is generated (but before the value is
228 * we must then transpose the value and return bits 30-23.
231 static u32 slic_crc_table
[256]; /* Table of CRCs for all possible byte values */
232 static u32 slic_crc_init
; /* Is table initialized */
235 * Contruct the CRC32 table
237 static void slic_mcast_init_crc32(void)
239 u32 c
; /* CRC shit reg */
240 u32 e
= 0; /* Poly X-or pattern */
242 int k
; /* byte being shifted into crc */
244 static int p
[] = { 0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26 };
246 for (i
= 0; i
< ARRAY_SIZE(p
); i
++)
247 e
|= 1L << (31 - p
[i
]);
249 for (i
= 1; i
< 256; i
++) {
252 c
= c
& 1 ? (c
>> 1) ^ e
: c
>> 1;
253 slic_crc_table
[i
] = c
;
258 * Return the MAC hast as described above.
260 static unsigned char slic_mcast_get_mac_hash(char *macaddr
)
265 unsigned char machash
= 0;
267 if (!slic_crc_init
) {
268 slic_mcast_init_crc32();
272 crc
= 0xFFFFFFFF; /* Preload shift register, per crc-32 spec */
273 for (i
= 0, p
= macaddr
; i
< 6; ++p
, ++i
)
274 crc
= (crc
>> 8) ^ slic_crc_table
[(crc
^ *p
) & 0xFF];
276 /* Return bits 1-8, transposed */
277 for (i
= 1; i
< 9; i
++)
278 machash
|= (((crc
>> i
) & 1) << (8 - i
));
283 static void slic_mcast_set_bit(struct adapter
*adapter
, char *address
)
285 unsigned char crcpoly
;
287 /* Get the CRC polynomial for the mac address */
288 crcpoly
= slic_mcast_get_mac_hash(address
);
290 /* We only have space on the SLIC for 64 entries. Lop
291 * off the top two bits. (2^6 = 64)
295 /* OR in the new bit into our 64 bit mask. */
296 adapter
->mcastmask
|= (u64
) 1 << crcpoly
;
299 static void slic_mcast_set_mask(struct adapter
*adapter
)
301 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
303 if (adapter
->macopts
& (MAC_ALLMCAST
| MAC_PROMISC
)) {
304 /* Turn on all multicast addresses. We have to do this for
305 * promiscuous mode as well as ALLMCAST mode. It saves the
306 * Microcode from having to keep state about the MAC
309 slic_reg32_write(&slic_regs
->slic_mcastlow
, 0xFFFFFFFF, FLUSH
);
310 slic_reg32_write(&slic_regs
->slic_mcasthigh
, 0xFFFFFFFF,
313 /* Commit our multicast mast to the SLIC by writing to the
314 * multicast address mask registers
316 slic_reg32_write(&slic_regs
->slic_mcastlow
,
317 (u32
)(adapter
->mcastmask
& 0xFFFFFFFF), FLUSH
);
318 slic_reg32_write(&slic_regs
->slic_mcasthigh
,
319 (u32
)((adapter
->mcastmask
>> 32) & 0xFFFFFFFF), FLUSH
);
323 static void slic_timer_ping(ulong dev
)
325 struct adapter
*adapter
;
326 struct sliccard
*card
;
329 adapter
= netdev_priv((struct net_device
*)dev
);
331 card
= adapter
->card
;
334 adapter
->pingtimer
.expires
= jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
335 add_timer(&adapter
->pingtimer
);
338 static void slic_unmap_mmio_space(struct adapter
*adapter
)
340 if (adapter
->slic_regs
)
341 iounmap(adapter
->slic_regs
);
342 adapter
->slic_regs
= NULL
;
348 * Write phy control to configure link duplex/speed
351 static void slic_link_config(struct adapter
*adapter
,
352 u32 linkspeed
, u32 linkduplex
)
361 if (adapter
->state
!= ADAPT_UP
)
364 ASSERT((adapter
->devid
== SLIC_1GB_DEVICE_ID
)
365 || (adapter
->devid
== SLIC_2GB_DEVICE_ID
));
367 if (linkspeed
> LINK_1000MB
)
368 linkspeed
= LINK_AUTOSPEED
;
369 if (linkduplex
> LINK_AUTOD
)
370 linkduplex
= LINK_AUTOD
;
372 wphy
= &adapter
->slic_regs
->slic_wphy
;
374 if ((linkspeed
== LINK_AUTOSPEED
) || (linkspeed
== LINK_1000MB
)) {
375 if (adapter
->flags
& ADAPT_FLAGS_FIBERMEDIA
) {
376 /* We've got a fiber gigabit interface, and register
377 * 4 is different in fiber mode than in copper mode
380 /* advertise FD only @1000 Mb */
381 phy_advreg
= (MIICR_REG_4
| (PAR_ADV1000XFD
));
382 /* enable PAUSE frames */
383 phy_advreg
|= PAR_ASYMPAUSE_FIBER
;
384 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
386 if (linkspeed
== LINK_AUTOSPEED
) {
387 /* reset phy, enable auto-neg */
390 (PCR_RESET
| PCR_AUTONEG
|
392 slic_reg32_write(wphy
, phy_config
, FLUSH
);
393 } else { /* forced 1000 Mb FD*/
394 /* power down phy to break link
395 this may not work) */
396 phy_config
= (MIICR_REG_PCR
| PCR_POWERDOWN
);
397 slic_reg32_write(wphy
, phy_config
, FLUSH
);
398 /* wait, Marvell says 1 sec,
399 try to get away with 10 ms */
402 /* disable auto-neg, set speed/duplex,
403 soft reset phy, powerup */
406 (PCR_RESET
| PCR_SPEED_1000
|
408 slic_reg32_write(wphy
, phy_config
, FLUSH
);
410 } else { /* copper gigabit */
412 /* Auto-Negotiate or 1000 Mb must be auto negotiated
413 * We've got a copper gigabit interface, and
414 * register 4 is different in copper mode than
417 if (linkspeed
== LINK_AUTOSPEED
) {
418 /* advertise 10/100 Mb modes */
421 (PAR_ADV100FD
| PAR_ADV100HD
| PAR_ADV10FD
424 /* linkspeed == LINK_1000MB -
425 don't advertise 10/100 Mb modes */
426 phy_advreg
= MIICR_REG_4
;
428 /* enable PAUSE frames */
429 phy_advreg
|= PAR_ASYMPAUSE
;
430 /* required by the Cicada PHY */
431 phy_advreg
|= PAR_802_3
;
432 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
433 /* advertise FD only @1000 Mb */
434 phy_gctlreg
= (MIICR_REG_9
| (PGC_ADV1000FD
));
435 slic_reg32_write(wphy
, phy_gctlreg
, FLUSH
);
437 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
439 enable auto crossover */
441 (MIICR_REG_16
| (MRV_REG16_XOVERON
));
442 slic_reg32_write(wphy
, phy_config
, FLUSH
);
444 /* reset phy, enable auto-neg */
447 (PCR_RESET
| PCR_AUTONEG
|
449 slic_reg32_write(wphy
, phy_config
, FLUSH
);
450 } else { /* it's a Cicada PHY */
451 /* enable and restart auto-neg (don't reset) */
454 (PCR_AUTONEG
| PCR_AUTONEG_RST
));
455 slic_reg32_write(wphy
, phy_config
, FLUSH
);
460 if (linkspeed
== LINK_10MB
)
463 speed
= PCR_SPEED_100
;
464 if (linkduplex
== LINK_HALFD
)
467 duplex
= PCR_DUPLEX_FULL
;
469 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
471 disable auto crossover */
472 phy_config
= (MIICR_REG_16
| (MRV_REG16_XOVEROFF
));
473 slic_reg32_write(wphy
, phy_config
, FLUSH
);
476 /* power down phy to break link (this may not work) */
477 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
| speed
| duplex
));
478 slic_reg32_write(wphy
, phy_config
, FLUSH
);
480 /* wait, Marvell says 1 sec, try to get away with 10 ms */
483 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
485 disable auto-neg, set speed,
486 soft reset phy, powerup */
488 (MIICR_REG_PCR
| (PCR_RESET
| speed
| duplex
));
489 slic_reg32_write(wphy
, phy_config
, FLUSH
);
490 } else { /* it's a Cicada PHY */
491 /* disable auto-neg, set speed, powerup */
492 phy_config
= (MIICR_REG_PCR
| (speed
| duplex
));
493 slic_reg32_write(wphy
, phy_config
, FLUSH
);
498 static int slic_card_download_gbrcv(struct adapter
*adapter
)
500 const struct firmware
*fw
;
501 const char *file
= "";
503 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
509 switch (adapter
->devid
) {
510 case SLIC_2GB_DEVICE_ID
:
511 file
= "slicoss/oasisrcvucode.sys";
513 case SLIC_1GB_DEVICE_ID
:
514 file
= "slicoss/gbrcvucode.sys";
521 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
523 dev_err(&adapter
->pcidev
->dev
,
524 "SLICOSS: Failed to load firmware %s\n", file
);
528 rcvucodelen
= *(u32
*)(fw
->data
+ index
);
530 switch (adapter
->devid
) {
531 case SLIC_2GB_DEVICE_ID
:
532 if (rcvucodelen
!= OasisRcvUCodeLen
)
535 case SLIC_1GB_DEVICE_ID
:
536 if (rcvucodelen
!= GBRcvUCodeLen
)
544 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_BEGIN
, FLUSH
);
545 /* download the rcv sequencer ucode */
546 for (codeaddr
= 0; codeaddr
< rcvucodelen
; codeaddr
++) {
547 /* write out instruction address */
548 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, codeaddr
, FLUSH
);
550 instruction
= *(u32
*)(fw
->data
+ index
);
552 /* write out the instruction data low addr */
553 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, instruction
, FLUSH
);
555 instruction
= *(u8
*)(fw
->data
+ index
);
557 /* write out the instruction data high addr */
558 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, (u8
)instruction
,
562 /* download finished */
563 release_firmware(fw
);
564 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_FINISH
, FLUSH
);
568 MODULE_FIRMWARE("slicoss/oasisrcvucode.sys");
569 MODULE_FIRMWARE("slicoss/gbrcvucode.sys");
571 static int slic_card_download(struct adapter
*adapter
)
573 const struct firmware
*fw
;
574 const char *file
= "";
579 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
586 int ucode_start
, index
= 0;
588 switch (adapter
->devid
) {
589 case SLIC_2GB_DEVICE_ID
:
590 file
= "slicoss/oasisdownload.sys";
592 case SLIC_1GB_DEVICE_ID
:
593 file
= "slicoss/gbdownload.sys";
599 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
601 dev_err(&adapter
->pcidev
->dev
,
602 "SLICOSS: Failed to load firmware %s\n", file
);
605 numsects
= *(u32
*)(fw
->data
+ index
);
607 ASSERT(numsects
<= 3);
608 for (i
= 0; i
< numsects
; i
++) {
609 sectsize
[i
] = *(u32
*)(fw
->data
+ index
);
612 for (i
= 0; i
< numsects
; i
++) {
613 sectstart
[i
] = *(u32
*)(fw
->data
+ index
);
617 instruction
= *(u32
*)(fw
->data
+ index
);
619 for (section
= 0; section
< numsects
; section
++) {
620 baseaddress
= sectstart
[section
];
621 thissectionsize
= sectsize
[section
] >> 3;
623 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
624 /* Write out instruction address */
625 slic_reg32_write(&slic_regs
->slic_wcs
,
626 baseaddress
+ codeaddr
, FLUSH
);
627 /* Write out instruction to low addr */
628 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
, FLUSH
);
629 instruction
= *(u32
*)(fw
->data
+ index
);
632 /* Write out instruction to high addr */
633 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
, FLUSH
);
634 instruction
= *(u32
*)(fw
->data
+ index
);
639 for (section
= 0; section
< numsects
; section
++) {
640 instruction
= *(u32
*)(fw
->data
+ index
);
641 baseaddress
= sectstart
[section
];
642 if (baseaddress
< 0x8000)
644 thissectionsize
= sectsize
[section
] >> 3;
646 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
647 /* Write out instruction address */
648 slic_reg32_write(&slic_regs
->slic_wcs
,
649 SLIC_WCS_COMPARE
| (baseaddress
+ codeaddr
),
651 /* Write out instruction to low addr */
652 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
654 instruction
= *(u32
*)(fw
->data
+ index
);
656 /* Write out instruction to high addr */
657 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
659 instruction
= *(u32
*)(fw
->data
+ index
);
662 /* Check SRAM location zero. If it is non-zero. Abort.*/
663 /* failure = readl((u32 __iomem *)&slic_regs->slic_reset);
665 release_firmware(fw);
670 release_firmware(fw
);
671 /* Everything OK, kick off the card */
673 slic_reg32_write(&slic_regs
->slic_wcs
, SLIC_WCS_START
, FLUSH
);
675 /* stall for 20 ms, long enough for ucode to init card
676 and reach mainloop */
682 MODULE_FIRMWARE("slicoss/oasisdownload.sys");
683 MODULE_FIRMWARE("slicoss/gbdownload.sys");
685 static void slic_adapter_set_hwaddr(struct adapter
*adapter
)
687 struct sliccard
*card
= adapter
->card
;
689 if ((adapter
->card
) && (card
->config_set
)) {
690 memcpy(adapter
->macaddr
,
691 card
->config
.MacInfo
[adapter
->functionnumber
].macaddrA
,
692 sizeof(struct slic_config_mac
));
693 if (!(adapter
->currmacaddr
[0] || adapter
->currmacaddr
[1] ||
694 adapter
->currmacaddr
[2] || adapter
->currmacaddr
[3] ||
695 adapter
->currmacaddr
[4] || adapter
->currmacaddr
[5])) {
696 memcpy(adapter
->currmacaddr
, adapter
->macaddr
, 6);
698 if (adapter
->netdev
) {
699 memcpy(adapter
->netdev
->dev_addr
, adapter
->currmacaddr
,
705 static void slic_intagg_set(struct adapter
*adapter
, u32 value
)
707 slic_reg32_write(&adapter
->slic_regs
->slic_intagg
, value
, FLUSH
);
708 adapter
->card
->loadlevel_current
= value
;
711 static void slic_soft_reset(struct adapter
*adapter
)
713 if (adapter
->card
->state
== CARD_UP
) {
714 slic_reg32_write(&adapter
->slic_regs
->slic_quiesce
, 0, FLUSH
);
718 slic_reg32_write(&adapter
->slic_regs
->slic_reset
, SLIC_RESET_MAGIC
,
723 static void slic_mac_address_config(struct adapter
*adapter
)
727 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
729 value
= *(u32
*) &adapter
->currmacaddr
[2];
730 value
= ntohl(value
);
731 slic_reg32_write(&slic_regs
->slic_wraddral
, value
, FLUSH
);
732 slic_reg32_write(&slic_regs
->slic_wraddrbl
, value
, FLUSH
);
734 value2
= (u32
) ((adapter
->currmacaddr
[0] << 8 |
735 adapter
->currmacaddr
[1]) & 0xFFFF);
737 slic_reg32_write(&slic_regs
->slic_wraddrah
, value2
, FLUSH
);
738 slic_reg32_write(&slic_regs
->slic_wraddrbh
, value2
, FLUSH
);
740 /* Write our multicast mask out to the card. This is done */
741 /* here in addition to the slic_mcast_addr_set routine */
742 /* because ALL_MCAST may have been enabled or disabled */
743 slic_mcast_set_mask(adapter
);
746 static void slic_mac_config(struct adapter
*adapter
)
749 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
751 /* Setup GMAC gaps */
752 if (adapter
->linkspeed
== LINK_1000MB
) {
753 value
= ((GMCR_GAPBB_1000
<< GMCR_GAPBB_SHIFT
) |
754 (GMCR_GAPR1_1000
<< GMCR_GAPR1_SHIFT
) |
755 (GMCR_GAPR2_1000
<< GMCR_GAPR2_SHIFT
));
757 value
= ((GMCR_GAPBB_100
<< GMCR_GAPBB_SHIFT
) |
758 (GMCR_GAPR1_100
<< GMCR_GAPR1_SHIFT
) |
759 (GMCR_GAPR2_100
<< GMCR_GAPR2_SHIFT
));
763 if (adapter
->linkspeed
== LINK_1000MB
)
766 /* enable fullduplex */
767 if ((adapter
->linkduplex
== LINK_FULLD
)
768 || (adapter
->macopts
& MAC_LOOPBACK
)) {
772 /* write mac config */
773 slic_reg32_write(&slic_regs
->slic_wmcfg
, value
, FLUSH
);
775 /* setup mac addresses */
776 slic_mac_address_config(adapter
);
779 static void slic_config_set(struct adapter
*adapter
, bool linkchange
)
783 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
787 slic_mac_config(adapter
);
788 RcrReset
= GRCR_RESET
;
790 slic_mac_address_config(adapter
);
794 if (adapter
->linkduplex
== LINK_FULLD
) {
796 value
= (GXCR_RESET
| /* Always reset */
797 GXCR_XMTEN
| /* Enable transmit */
798 GXCR_PAUSEEN
); /* Enable pause */
800 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
802 /* Setup rcvcfg last */
803 value
= (RcrReset
| /* Reset, if linkchange */
804 GRCR_CTLEN
| /* Enable CTL frames */
805 GRCR_ADDRAEN
| /* Address A enable */
806 GRCR_RCVBAD
| /* Rcv bad frames */
807 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
810 value
= (GXCR_RESET
| /* Always reset */
811 GXCR_XMTEN
); /* Enable transmit */
813 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
815 /* Setup rcvcfg last */
816 value
= (RcrReset
| /* Reset, if linkchange */
817 GRCR_ADDRAEN
| /* Address A enable */
818 GRCR_RCVBAD
| /* Rcv bad frames */
819 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
822 if (adapter
->state
!= ADAPT_DOWN
) {
823 /* Only enable receive if we are restarting or running */
827 if (adapter
->macopts
& MAC_PROMISC
)
828 value
|= GRCR_RCVALL
;
830 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
834 * Turn off RCV and XMT, power down PHY
836 static void slic_config_clear(struct adapter
*adapter
)
840 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
843 value
= (GXCR_RESET
| /* Always reset */
844 GXCR_PAUSEEN
); /* Enable pause */
846 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
848 value
= (GRCR_RESET
| /* Always reset */
849 GRCR_CTLEN
| /* Enable CTL frames */
850 GRCR_ADDRAEN
| /* Address A enable */
851 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
853 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
856 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
));
857 slic_reg32_write(&slic_regs
->slic_wphy
, phy_config
, FLUSH
);
860 static bool slic_mac_filter(struct adapter
*adapter
,
861 struct ether_header
*ether_frame
)
863 struct net_device
*netdev
= adapter
->netdev
;
864 u32 opts
= adapter
->macopts
;
865 u32
*dhost4
= (u32
*)ðer_frame
->ether_dhost
[0];
866 u16
*dhost2
= (u16
*)ðer_frame
->ether_dhost
[4];
868 if (opts
& MAC_PROMISC
)
871 if ((*dhost4
== 0xFFFFFFFF) && (*dhost2
== 0xFFFF)) {
872 if (opts
& MAC_BCAST
) {
873 adapter
->rcv_broadcasts
++;
880 if (ether_frame
->ether_dhost
[0] & 0x01) {
881 if (opts
& MAC_ALLMCAST
) {
882 adapter
->rcv_multicasts
++;
883 netdev
->stats
.multicast
++;
886 if (opts
& MAC_MCAST
) {
887 struct mcast_address
*mcaddr
= adapter
->mcastaddrs
;
890 if (!compare_ether_addr(mcaddr
->address
,
891 ether_frame
->ether_dhost
)) {
892 adapter
->rcv_multicasts
++;
893 netdev
->stats
.multicast
++;
896 mcaddr
= mcaddr
->next
;
903 if (opts
& MAC_DIRECTED
) {
904 adapter
->rcv_unicasts
++;
911 static int slic_mac_set_address(struct net_device
*dev
, void *ptr
)
913 struct adapter
*adapter
= netdev_priv(dev
);
914 struct sockaddr
*addr
= ptr
;
916 if (netif_running(dev
))
921 if (!is_valid_ether_addr(addr
->sa_data
))
924 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
925 memcpy(adapter
->currmacaddr
, addr
->sa_data
, dev
->addr_len
);
927 slic_config_set(adapter
, true);
931 static void slic_timer_load_check(ulong cardaddr
)
933 struct sliccard
*card
= (struct sliccard
*)cardaddr
;
934 struct adapter
*adapter
= card
->master
;
936 u32 load
= card
->events
;
939 intagg
= &adapter
->slic_regs
->slic_intagg
;
941 if ((adapter
) && (adapter
->state
== ADAPT_UP
) &&
942 (card
->state
== CARD_UP
) && (slic_global
.dynamic_intagg
)) {
943 if (adapter
->devid
== SLIC_1GB_DEVICE_ID
) {
944 if (adapter
->linkspeed
== LINK_1000MB
)
947 if (load
> SLIC_LOAD_5
)
948 level
= SLIC_INTAGG_5
;
949 else if (load
> SLIC_LOAD_4
)
950 level
= SLIC_INTAGG_4
;
951 else if (load
> SLIC_LOAD_3
)
952 level
= SLIC_INTAGG_3
;
953 else if (load
> SLIC_LOAD_2
)
954 level
= SLIC_INTAGG_2
;
955 else if (load
> SLIC_LOAD_1
)
956 level
= SLIC_INTAGG_1
;
958 level
= SLIC_INTAGG_0
;
960 if (card
->loadlevel_current
!= level
) {
961 card
->loadlevel_current
= level
;
962 slic_reg32_write(intagg
, level
, FLUSH
);
965 if (load
> SLIC_LOAD_5
)
966 level
= SLIC_INTAGG_5
;
967 else if (load
> SLIC_LOAD_4
)
968 level
= SLIC_INTAGG_4
;
969 else if (load
> SLIC_LOAD_3
)
970 level
= SLIC_INTAGG_3
;
971 else if (load
> SLIC_LOAD_2
)
972 level
= SLIC_INTAGG_2
;
973 else if (load
> SLIC_LOAD_1
)
974 level
= SLIC_INTAGG_1
;
976 level
= SLIC_INTAGG_0
;
977 if (card
->loadlevel_current
!= level
) {
978 card
->loadlevel_current
= level
;
979 slic_reg32_write(intagg
, level
, FLUSH
);
984 card
->loadtimer
.expires
= jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
985 add_timer(&card
->loadtimer
);
988 static int slic_upr_queue_request(struct adapter
*adapter
,
992 u32 upr_buffer
, u32 upr_buffer_h
)
994 struct slic_upr
*upr
;
995 struct slic_upr
*uprqueue
;
997 upr
= kmalloc(sizeof(struct slic_upr
), GFP_ATOMIC
);
1001 upr
->adapter
= adapter
->port
;
1002 upr
->upr_request
= upr_request
;
1003 upr
->upr_data
= upr_data
;
1004 upr
->upr_buffer
= upr_buffer
;
1005 upr
->upr_data_h
= upr_data_h
;
1006 upr
->upr_buffer_h
= upr_buffer_h
;
1008 if (adapter
->upr_list
) {
1009 uprqueue
= adapter
->upr_list
;
1011 while (uprqueue
->next
)
1012 uprqueue
= uprqueue
->next
;
1013 uprqueue
->next
= upr
;
1015 adapter
->upr_list
= upr
;
1020 static void slic_upr_start(struct adapter
*adapter
)
1022 struct slic_upr
*upr
;
1023 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1029 upr
= adapter
->upr_list
;
1032 if (adapter
->upr_busy
)
1034 adapter
->upr_busy
= 1;
1036 switch (upr
->upr_request
) {
1037 case SLIC_UPR_STATS
:
1038 if (upr
->upr_data_h
== 0) {
1039 slic_reg32_write(&slic_regs
->slic_stats
, upr
->upr_data
,
1042 slic_reg64_write(adapter
, &slic_regs
->slic_stats64
,
1044 &slic_regs
->slic_addr_upper
,
1045 upr
->upr_data_h
, FLUSH
);
1050 slic_reg64_write(adapter
, &slic_regs
->slic_rlsr
, upr
->upr_data
,
1051 &slic_regs
->slic_addr_upper
, upr
->upr_data_h
,
1055 case SLIC_UPR_RCONFIG
:
1056 slic_reg64_write(adapter
, &slic_regs
->slic_rconfig
,
1057 upr
->upr_data
, &slic_regs
->slic_addr_upper
,
1058 upr
->upr_data_h
, FLUSH
);
1061 slic_reg32_write(&slic_regs
->slic_ping
, 1, FLUSH
);
1068 static int slic_upr_request(struct adapter
*adapter
,
1072 u32 upr_buffer
, u32 upr_buffer_h
)
1076 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
1077 rc
= slic_upr_queue_request(adapter
,
1080 upr_data_h
, upr_buffer
, upr_buffer_h
);
1082 goto err_unlock_irq
;
1084 slic_upr_start(adapter
);
1086 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
1087 adapter
->upr_lock
.flags
);
1091 static void slic_link_upr_complete(struct adapter
*adapter
, u32 isr
)
1093 u32 linkstatus
= adapter
->pshmem
->linkstatus
;
1095 unsigned char linkspeed
;
1096 unsigned char linkduplex
;
1098 if ((isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
1099 struct slic_shmem
*pshmem
;
1101 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
1102 #if defined(CONFIG_X86_64)
1103 slic_upr_queue_request(adapter
,
1105 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
1106 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
1108 #elif defined(CONFIG_X86)
1109 slic_upr_queue_request(adapter
,
1111 (u32
) &pshmem
->linkstatus
,
1112 SLIC_GET_ADDR_HIGH(pshmem
), 0, 0);
1118 if (adapter
->state
!= ADAPT_UP
)
1121 ASSERT((adapter
->devid
== SLIC_1GB_DEVICE_ID
)
1122 || (adapter
->devid
== SLIC_2GB_DEVICE_ID
));
1124 linkup
= linkstatus
& GIG_LINKUP
? LINK_UP
: LINK_DOWN
;
1125 if (linkstatus
& GIG_SPEED_1000
)
1126 linkspeed
= LINK_1000MB
;
1127 else if (linkstatus
& GIG_SPEED_100
)
1128 linkspeed
= LINK_100MB
;
1130 linkspeed
= LINK_10MB
;
1132 if (linkstatus
& GIG_FULLDUPLEX
)
1133 linkduplex
= LINK_FULLD
;
1135 linkduplex
= LINK_HALFD
;
1137 if ((adapter
->linkstate
== LINK_DOWN
) && (linkup
== LINK_DOWN
))
1140 /* link up event, but nothing has changed */
1141 if ((adapter
->linkstate
== LINK_UP
) &&
1142 (linkup
== LINK_UP
) &&
1143 (adapter
->linkspeed
== linkspeed
) &&
1144 (adapter
->linkduplex
== linkduplex
))
1147 /* link has changed at this point */
1149 /* link has gone from up to down */
1150 if (linkup
== LINK_DOWN
) {
1151 adapter
->linkstate
= LINK_DOWN
;
1155 /* link has gone from down to up */
1156 adapter
->linkspeed
= linkspeed
;
1157 adapter
->linkduplex
= linkduplex
;
1159 if (adapter
->linkstate
!= LINK_UP
) {
1161 slic_config_set(adapter
, true);
1162 adapter
->linkstate
= LINK_UP
;
1163 netif_start_queue(adapter
->netdev
);
1167 static void slic_upr_request_complete(struct adapter
*adapter
, u32 isr
)
1169 struct sliccard
*card
= adapter
->card
;
1170 struct slic_upr
*upr
;
1172 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
1173 upr
= adapter
->upr_list
;
1176 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
1177 adapter
->upr_lock
.flags
);
1180 adapter
->upr_list
= upr
->next
;
1182 adapter
->upr_busy
= 0;
1183 ASSERT(adapter
->port
== upr
->adapter
);
1184 switch (upr
->upr_request
) {
1185 case SLIC_UPR_STATS
:
1187 struct slic_stats
*slicstats
=
1188 (struct slic_stats
*) &adapter
->pshmem
->inicstats
;
1189 struct slic_stats
*newstats
= slicstats
;
1190 struct slic_stats
*old
= &adapter
->inicstats_prev
;
1191 struct slicnet_stats
*stst
= &adapter
->slic_stats
;
1193 if (isr
& ISR_UPCERR
) {
1194 dev_err(&adapter
->netdev
->dev
,
1195 "SLIC_UPR_STATS command failed isr[%x]\n",
1200 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_segs
,
1201 newstats
->xmit_tcp_segs_gb
,
1202 old
->xmit_tcp_segs_gb
);
1204 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_bytes
,
1205 newstats
->xmit_tcp_bytes_gb
,
1206 old
->xmit_tcp_bytes_gb
);
1208 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_segs
,
1209 newstats
->rcv_tcp_segs_gb
,
1210 old
->rcv_tcp_segs_gb
);
1212 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_bytes
,
1213 newstats
->rcv_tcp_bytes_gb
,
1214 old
->rcv_tcp_bytes_gb
);
1216 UPDATE_STATS_GB(stst
->iface
.xmt_bytes
,
1217 newstats
->xmit_bytes_gb
,
1218 old
->xmit_bytes_gb
);
1220 UPDATE_STATS_GB(stst
->iface
.xmt_ucast
,
1221 newstats
->xmit_unicasts_gb
,
1222 old
->xmit_unicasts_gb
);
1224 UPDATE_STATS_GB(stst
->iface
.rcv_bytes
,
1225 newstats
->rcv_bytes_gb
,
1228 UPDATE_STATS_GB(stst
->iface
.rcv_ucast
,
1229 newstats
->rcv_unicasts_gb
,
1230 old
->rcv_unicasts_gb
);
1232 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1233 newstats
->xmit_collisions_gb
,
1234 old
->xmit_collisions_gb
);
1236 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1237 newstats
->xmit_excess_collisions_gb
,
1238 old
->xmit_excess_collisions_gb
);
1240 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1241 newstats
->xmit_other_error_gb
,
1242 old
->xmit_other_error_gb
);
1244 UPDATE_STATS_GB(stst
->iface
.rcv_errors
,
1245 newstats
->rcv_other_error_gb
,
1246 old
->rcv_other_error_gb
);
1248 UPDATE_STATS_GB(stst
->iface
.rcv_discards
,
1249 newstats
->rcv_drops_gb
,
1252 if (newstats
->rcv_drops_gb
> old
->rcv_drops_gb
) {
1253 adapter
->rcv_drops
+=
1254 (newstats
->rcv_drops_gb
-
1257 memcpy(old
, newstats
, sizeof(struct slic_stats
));
1261 slic_link_upr_complete(adapter
, isr
);
1263 case SLIC_UPR_RCONFIG
:
1278 card
->pingstatus
|= (isr
& ISR_PINGDSMASK
);
1284 slic_upr_start(adapter
);
1285 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
1286 adapter
->upr_lock
.flags
);
1289 static void slic_config_get(struct adapter
*adapter
, u32 config
,
1294 status
= slic_upr_request(adapter
,
1296 (u32
) config
, (u32
) config_h
, 0, 0);
1297 ASSERT(status
== 0);
1301 * this is here to checksum the eeprom, there is some ucode bug
1302 * which prevens us from using the ucode result.
1303 * remove this once ucode is fixed.
1305 static ushort
slic_eeprom_cksum(char *m
, int len
)
1307 #define ADDCARRY(x) (x > 65535 ? x -= 65535 : x)
1308 #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\
1313 u32 byte_swapped
= 0;
1330 #ifdef CONFIG_X86_64
1331 w_int
= (u32
) ((ulong
) w
& 0x00000000FFFFFFFF);
1335 if ((1 & w_int
) && (len
> 0)) {
1338 s_util
.c
[0] = *(unsigned char *)w
;
1339 w
= (u16
*)((char *)w
+ 1);
1344 /* Unroll the loop to make overhead from branches &c small. */
1345 while ((len
-= 32) >= 0) {
1362 w
= (u16
*)((ulong
) w
+ 16); /* verify */
1365 while ((len
-= 8) >= 0) {
1370 w
= (u16
*)((ulong
) w
+ 4); /* verify */
1373 if (len
!= 0 || byte_swapped
!= 0) {
1375 while ((len
-= 2) >= 0)
1376 sum
+= *w
++; /* verify */
1382 s_util
.c
[1] = *(char *) w
;
1389 } else if (len
== -1) {
1390 s_util
.c
[0] = *(char *) w
;
1399 return (ushort
) sum
;
1402 static void slic_rspqueue_free(struct adapter
*adapter
)
1405 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1407 for (i
= 0; i
< rspq
->num_pages
; i
++) {
1408 if (rspq
->vaddr
[i
]) {
1409 pci_free_consistent(adapter
->pcidev
, PAGE_SIZE
,
1410 rspq
->vaddr
[i
], rspq
->paddr
[i
]);
1412 rspq
->vaddr
[i
] = NULL
;
1416 rspq
->pageindex
= 0;
1417 rspq
->rspbuf
= NULL
;
1420 static int slic_rspqueue_init(struct adapter
*adapter
)
1423 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1424 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1427 ASSERT(adapter
->state
== ADAPT_DOWN
);
1428 memset(rspq
, 0, sizeof(struct slic_rspqueue
));
1430 rspq
->num_pages
= SLIC_RSPQ_PAGES_GB
;
1432 for (i
= 0; i
< rspq
->num_pages
; i
++) {
1433 rspq
->vaddr
[i
] = pci_alloc_consistent(adapter
->pcidev
,
1436 if (!rspq
->vaddr
[i
]) {
1437 dev_err(&adapter
->pcidev
->dev
,
1438 "pci_alloc_consistent failed\n");
1439 slic_rspqueue_free(adapter
);
1442 #ifndef CONFIG_X86_64
1443 ASSERT(((u32
) rspq
->vaddr
[i
] & 0xFFFFF000) ==
1444 (u32
) rspq
->vaddr
[i
]);
1445 ASSERT(((u32
) rspq
->paddr
[i
] & 0xFFFFF000) ==
1446 (u32
) rspq
->paddr
[i
]);
1448 memset(rspq
->vaddr
[i
], 0, PAGE_SIZE
);
1451 slic_reg32_write(&slic_regs
->slic_rbar
,
1452 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
1455 slic_reg64_write(adapter
, &slic_regs
->slic_rbar64
,
1456 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
1457 &slic_regs
->slic_addr_upper
,
1458 paddrh
, DONT_FLUSH
);
1462 rspq
->pageindex
= 0;
1463 rspq
->rspbuf
= (struct slic_rspbuf
*)rspq
->vaddr
[0];
1467 static struct slic_rspbuf
*slic_rspqueue_getnext(struct adapter
*adapter
)
1469 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1470 struct slic_rspbuf
*buf
;
1472 if (!(rspq
->rspbuf
->status
))
1476 #ifndef CONFIG_X86_64
1477 ASSERT((buf
->status
& 0xFFFFFFE0) == 0);
1479 ASSERT(buf
->hosthandle
);
1480 if (++rspq
->offset
< SLIC_RSPQ_BUFSINPAGE
) {
1482 #ifndef CONFIG_X86_64
1483 ASSERT(((u32
) rspq
->rspbuf
& 0xFFFFFFE0) ==
1484 (u32
) rspq
->rspbuf
);
1487 ASSERT(rspq
->offset
== SLIC_RSPQ_BUFSINPAGE
);
1488 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_rbar64
,
1489 (rspq
->paddr
[rspq
->pageindex
] | SLIC_RSPQ_BUFSINPAGE
),
1490 &adapter
->slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
1491 rspq
->pageindex
= (++rspq
->pageindex
) % rspq
->num_pages
;
1493 rspq
->rspbuf
= (struct slic_rspbuf
*)
1494 rspq
->vaddr
[rspq
->pageindex
];
1495 #ifndef CONFIG_X86_64
1496 ASSERT(((u32
) rspq
->rspbuf
& 0xFFFFF000) ==
1497 (u32
) rspq
->rspbuf
);
1500 #ifndef CONFIG_X86_64
1501 ASSERT(((u32
) buf
& 0xFFFFFFE0) == (u32
) buf
);
1506 static void slic_cmdqmem_init(struct adapter
*adapter
)
1508 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
1510 memset(cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
1513 static void slic_cmdqmem_free(struct adapter
*adapter
)
1515 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
1518 for (i
= 0; i
< SLIC_CMDQ_MAXPAGES
; i
++) {
1519 if (cmdqmem
->pages
[i
]) {
1520 pci_free_consistent(adapter
->pcidev
,
1522 (void *) cmdqmem
->pages
[i
],
1523 cmdqmem
->dma_pages
[i
]);
1526 memset(cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
1529 static u32
*slic_cmdqmem_addpage(struct adapter
*adapter
)
1531 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
1534 if (cmdqmem
->pagecnt
>= SLIC_CMDQ_MAXPAGES
)
1536 pageaddr
= pci_alloc_consistent(adapter
->pcidev
,
1538 &cmdqmem
->dma_pages
[cmdqmem
->pagecnt
]);
1541 #ifndef CONFIG_X86_64
1542 ASSERT(((u32
) pageaddr
& 0xFFFFF000) == (u32
) pageaddr
);
1544 cmdqmem
->pages
[cmdqmem
->pagecnt
] = pageaddr
;
1549 static void slic_cmdq_free(struct adapter
*adapter
)
1551 struct slic_hostcmd
*cmd
;
1553 cmd
= adapter
->cmdq_all
.head
;
1556 struct sk_buff
*tempskb
;
1561 dev_kfree_skb_irq(tempskb
);
1564 cmd
= cmd
->next_all
;
1566 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
1567 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
1568 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
1569 slic_cmdqmem_free(adapter
);
1572 static void slic_cmdq_addcmdpage(struct adapter
*adapter
, u32
*page
)
1574 struct slic_hostcmd
*cmd
;
1575 struct slic_hostcmd
*prev
;
1576 struct slic_hostcmd
*tail
;
1577 struct slic_cmdqueue
*cmdq
;
1583 struct slic_handle
*pslic_handle
;
1586 cmd
= (struct slic_hostcmd
*)cmdaddr
;
1589 phys_addr
= virt_to_bus((void *)page
);
1590 phys_addrl
= SLIC_GET_ADDR_LOW(phys_addr
);
1591 phys_addrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
1595 while ((cmdcnt
< SLIC_CMDQ_CMDSINPAGE
) &&
1596 (adapter
->slic_handle_ix
< 256)) {
1597 /* Allocate and initialize a SLIC_HANDLE for this command */
1598 SLIC_GET_SLIC_HANDLE(adapter
, pslic_handle
);
1599 if (pslic_handle
== NULL
)
1601 ASSERT(pslic_handle
==
1602 &adapter
->slic_handles
[pslic_handle
->token
.
1604 pslic_handle
->type
= SLIC_HANDLE_CMD
;
1605 pslic_handle
->address
= (void *) cmd
;
1606 pslic_handle
->offset
= (ushort
) adapter
->slic_handle_ix
++;
1607 pslic_handle
->other_handle
= NULL
;
1608 pslic_handle
->next
= NULL
;
1610 cmd
->pslic_handle
= pslic_handle
;
1611 cmd
->cmd64
.hosthandle
= pslic_handle
->token
.handle_token
;
1613 cmd
->paddrl
= phys_addrl
;
1614 cmd
->paddrh
= phys_addrh
;
1615 cmd
->next_all
= prev
;
1618 phys_addrl
+= SLIC_HOSTCMD_SIZE
;
1619 cmdaddr
+= SLIC_HOSTCMD_SIZE
;
1621 cmd
= (struct slic_hostcmd
*)cmdaddr
;
1625 cmdq
= &adapter
->cmdq_all
;
1626 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
1627 tail
->next_all
= cmdq
->head
;
1629 cmdq
= &adapter
->cmdq_free
;
1630 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1631 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
1632 tail
->next
= cmdq
->head
;
1634 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1637 static int slic_cmdq_init(struct adapter
*adapter
)
1642 ASSERT(adapter
->state
== ADAPT_DOWN
);
1643 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
1644 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
1645 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
1646 spin_lock_init(&adapter
->cmdq_all
.lock
.lock
);
1647 spin_lock_init(&adapter
->cmdq_free
.lock
.lock
);
1648 spin_lock_init(&adapter
->cmdq_done
.lock
.lock
);
1649 slic_cmdqmem_init(adapter
);
1650 adapter
->slic_handle_ix
= 1;
1651 for (i
= 0; i
< SLIC_CMDQ_INITPAGES
; i
++) {
1652 pageaddr
= slic_cmdqmem_addpage(adapter
);
1653 #ifndef CONFIG_X86_64
1654 ASSERT(((u32
) pageaddr
& 0xFFFFF000) == (u32
) pageaddr
);
1657 slic_cmdq_free(adapter
);
1660 slic_cmdq_addcmdpage(adapter
, pageaddr
);
1662 adapter
->slic_handle_ix
= 1;
1667 static void slic_cmdq_reset(struct adapter
*adapter
)
1669 struct slic_hostcmd
*hcmd
;
1670 struct sk_buff
*skb
;
1673 spin_lock_irqsave(&adapter
->cmdq_free
.lock
.lock
,
1674 adapter
->cmdq_free
.lock
.flags
);
1675 spin_lock_irqsave(&adapter
->cmdq_done
.lock
.lock
,
1676 adapter
->cmdq_done
.lock
.flags
);
1677 outstanding
= adapter
->cmdq_all
.count
- adapter
->cmdq_done
.count
;
1678 outstanding
-= adapter
->cmdq_free
.count
;
1679 hcmd
= adapter
->cmdq_all
.head
;
1686 dev_kfree_skb_irq(skb
);
1688 hcmd
= hcmd
->next_all
;
1690 adapter
->cmdq_free
.count
= 0;
1691 adapter
->cmdq_free
.head
= NULL
;
1692 adapter
->cmdq_free
.tail
= NULL
;
1693 adapter
->cmdq_done
.count
= 0;
1694 adapter
->cmdq_done
.head
= NULL
;
1695 adapter
->cmdq_done
.tail
= NULL
;
1696 adapter
->cmdq_free
.head
= adapter
->cmdq_all
.head
;
1697 hcmd
= adapter
->cmdq_all
.head
;
1699 adapter
->cmdq_free
.count
++;
1700 hcmd
->next
= hcmd
->next_all
;
1701 hcmd
= hcmd
->next_all
;
1703 if (adapter
->cmdq_free
.count
!= adapter
->cmdq_all
.count
) {
1704 dev_err(&adapter
->netdev
->dev
,
1705 "free_count %d != all count %d\n",
1706 adapter
->cmdq_free
.count
, adapter
->cmdq_all
.count
);
1708 spin_unlock_irqrestore(&adapter
->cmdq_done
.lock
.lock
,
1709 adapter
->cmdq_done
.lock
.flags
);
1710 spin_unlock_irqrestore(&adapter
->cmdq_free
.lock
.lock
,
1711 adapter
->cmdq_free
.lock
.flags
);
1714 static void slic_cmdq_getdone(struct adapter
*adapter
)
1716 struct slic_cmdqueue
*done_cmdq
= &adapter
->cmdq_done
;
1717 struct slic_cmdqueue
*free_cmdq
= &adapter
->cmdq_free
;
1719 ASSERT(free_cmdq
->head
== NULL
);
1720 spin_lock_irqsave(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
1722 free_cmdq
->head
= done_cmdq
->head
;
1723 free_cmdq
->count
= done_cmdq
->count
;
1724 done_cmdq
->head
= NULL
;
1725 done_cmdq
->tail
= NULL
;
1726 done_cmdq
->count
= 0;
1727 spin_unlock_irqrestore(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
1730 static struct slic_hostcmd
*slic_cmdq_getfree(struct adapter
*adapter
)
1732 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_free
;
1733 struct slic_hostcmd
*cmd
= NULL
;
1736 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1740 cmdq
->head
= cmd
->next
;
1742 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1744 slic_cmdq_getdone(adapter
);
1751 spin_unlock_irqrestore(&cmdq
->lock
.lock
,
1753 pageaddr
= slic_cmdqmem_addpage(adapter
);
1755 slic_cmdq_addcmdpage(adapter
, pageaddr
);
1756 goto lock_and_retry
;
1763 static void slic_cmdq_putdone_irq(struct adapter
*adapter
,
1764 struct slic_hostcmd
*cmd
)
1766 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_done
;
1768 spin_lock(&cmdq
->lock
.lock
);
1770 cmd
->next
= cmdq
->head
;
1773 if ((adapter
->xmitq_full
) && (cmdq
->count
> 10))
1774 netif_wake_queue(adapter
->netdev
);
1775 spin_unlock(&cmdq
->lock
.lock
);
1778 static int slic_rcvqueue_fill(struct adapter
*adapter
)
1783 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1785 struct device
*dev
= &adapter
->netdev
->dev
;
1787 while (i
< SLIC_RCVQ_FILLENTRIES
) {
1788 struct slic_rcvbuf
*rcvbuf
;
1789 struct sk_buff
*skb
;
1790 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1793 skb
= alloc_skb(SLIC_RCVQ_RCVBUFSIZE
, GFP_ATOMIC
);
1795 paddr
= (void *)pci_map_single(adapter
->pcidev
,
1797 SLIC_RCVQ_RCVBUFSIZE
,
1798 PCI_DMA_FROMDEVICE
);
1799 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
1800 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
1802 skb
->len
= SLIC_RCVBUF_HEADSIZE
;
1803 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1806 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1808 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1810 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1811 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
1812 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1813 dev_err(dev
, " paddr[%p]\n", paddr
);
1814 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1815 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1816 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
1817 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
1818 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
1819 dev_err(dev
, "SKIP THIS SKB!!!!!!!!\n");
1820 goto retry_rcvqfill
;
1824 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1826 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1827 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
1828 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1829 dev_err(dev
, " paddr[%p]\n", paddr
);
1830 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1831 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1832 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
1833 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
1834 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
1835 dev_err(dev
, "GIVE TO CARD ANYWAY\n");
1839 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
,
1840 (u32
)paddrl
, DONT_FLUSH
);
1842 slic_reg64_write(adapter
,
1843 &adapter
->slic_regs
->slic_hbar64
,
1845 &adapter
->slic_regs
->slic_addr_upper
,
1846 paddrh
, DONT_FLUSH
);
1849 rcvq
->tail
->next
= skb
;
1856 dev_err(&adapter
->netdev
->dev
,
1857 "slic_rcvqueue_fill could only get [%d] skbuffs\n",
1865 static void slic_rcvqueue_free(struct adapter
*adapter
)
1867 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1868 struct sk_buff
*skb
;
1870 while (rcvq
->head
) {
1872 rcvq
->head
= rcvq
->head
->next
;
1880 static int slic_rcvqueue_init(struct adapter
*adapter
)
1883 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1885 ASSERT(adapter
->state
== ADAPT_DOWN
);
1888 rcvq
->size
= SLIC_RCVQ_ENTRIES
;
1891 i
= (SLIC_RCVQ_ENTRIES
/ SLIC_RCVQ_FILLENTRIES
);
1894 count
+= slic_rcvqueue_fill(adapter
);
1897 if (rcvq
->count
< SLIC_RCVQ_MINENTRIES
) {
1898 slic_rcvqueue_free(adapter
);
1904 static struct sk_buff
*slic_rcvqueue_getnext(struct adapter
*adapter
)
1906 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1907 struct sk_buff
*skb
;
1908 struct slic_rcvbuf
*rcvbuf
;
1913 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1916 if (rcvbuf
->status
& IRHDDR_SVALID
) {
1917 rcvq
->head
= rcvq
->head
->next
;
1924 dev_err(&adapter
->netdev
->dev
,
1925 "RcvQ Empty!! rcvq[%p] count[%x]\n", rcvq
, rcvq
->count
);
1928 while (rcvq
->count
< SLIC_RCVQ_FILLTHRESH
) {
1929 count
= slic_rcvqueue_fill(adapter
);
1938 static u32
slic_rcvqueue_reinsert(struct adapter
*adapter
, struct sk_buff
*skb
)
1940 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1944 struct slic_rcvbuf
*rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1947 ASSERT(skb
->len
== SLIC_RCVBUF_HEADSIZE
);
1949 paddr
= (void *)pci_map_single(adapter
->pcidev
, skb
->head
,
1950 SLIC_RCVQ_RCVBUFSIZE
, PCI_DMA_FROMDEVICE
);
1954 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
1955 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
1958 dev
= &adapter
->netdev
->dev
;
1959 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1961 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1962 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
1963 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1964 dev_err(dev
, " paddr[%p]\n", paddr
);
1965 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1966 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1967 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
1968 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
1969 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
1972 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
, (u32
)paddrl
,
1975 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_hbar64
,
1976 paddrl
, &adapter
->slic_regs
->slic_addr_upper
,
1977 paddrh
, DONT_FLUSH
);
1980 rcvq
->tail
->next
= skb
;
1988 static int slic_debug_card_show(struct seq_file
*seq
, void *v
)
1992 struct sliccard
*card
= seq
->private;
1993 struct slic_config
*config
= &card
->config
;
1994 unsigned char *fru
= (unsigned char *)(&card
->config
.atk_fru
);
1995 unsigned char *oemfru
= (unsigned char *)(&card
->config
.OemFru
);
1998 seq_printf(seq
, "driver_version : %s\n", slic_proc_version
);
1999 seq_printf(seq
, "Microcode versions: \n");
2000 seq_printf(seq
, " Gigabit (gb) : %s %s\n",
2001 MOJAVE_UCODE_VERS_STRING
, MOJAVE_UCODE_VERS_DATE
);
2002 seq_printf(seq
, " Gigabit Receiver : %s %s\n",
2003 GB_RCVUCODE_VERS_STRING
, GB_RCVUCODE_VERS_DATE
);
2004 seq_printf(seq
, "Vendor : %s\n", slic_vendor
);
2005 seq_printf(seq
, "Product Name : %s\n", slic_product_name
);
2007 seq_printf(seq
, "VendorId : %4.4X\n",
2009 seq_printf(seq
, "DeviceId : %4.4X\n",
2011 seq_printf(seq
, "RevisionId : %2.2x\n",
2012 config
->RevisionId
);
2013 seq_printf(seq
, "Bus # : %d\n", card
->busnumber
);
2014 seq_printf(seq
, "Device # : %d\n", card
->slotnumber
);
2015 seq_printf(seq
, "Interfaces : %d\n", card
->card_size
);
2016 seq_printf(seq
, " Initialized : %d\n",
2017 card
->adapters_activated
);
2018 seq_printf(seq
, " Allocated : %d\n",
2019 card
->adapters_allocated
);
2020 ASSERT(card
->card_size
<= SLIC_NBR_MACS
);
2021 for (i
= 0; i
< card
->card_size
; i
++) {
2023 " MAC%d : %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
2024 i
, config
->macinfo
[i
].macaddrA
[0],
2025 config
->macinfo
[i
].macaddrA
[1],
2026 config
->macinfo
[i
].macaddrA
[2],
2027 config
->macinfo
[i
].macaddrA
[3],
2028 config
->macinfo
[i
].macaddrA
[4],
2029 config
->macinfo
[i
].macaddrA
[5]);
2031 seq_printf(seq
, " IF Init State Duplex/Speed irq\n");
2032 seq_printf(seq
, " -------------------------------\n");
2033 for (i
= 0; i
< card
->adapters_allocated
; i
++) {
2034 struct adapter
*adapter
;
2036 adapter
= card
->adapter
[i
];
2039 " %d %d %s %s %s 0x%X\n",
2040 adapter
->physport
, adapter
->state
,
2041 SLIC_LINKSTATE(adapter
->linkstate
),
2042 SLIC_DUPLEX(adapter
->linkduplex
),
2043 SLIC_SPEED(adapter
->linkspeed
),
2044 (uint
) adapter
->irq
);
2047 seq_printf(seq
, "Generation # : %4.4X\n", card
->gennumber
);
2048 seq_printf(seq
, "RcvQ max entries : %4.4X\n",
2050 seq_printf(seq
, "Ping Status : %8.8X\n",
2052 seq_printf(seq
, "Minimum grant : %2.2x\n",
2054 seq_printf(seq
, "Maximum Latency : %2.2x\n", config
->MaxLat
);
2055 seq_printf(seq
, "PciStatus : %4.4x\n",
2057 seq_printf(seq
, "Debug Device Id : %4.4x\n",
2059 seq_printf(seq
, "DRAM ROM Function : %4.4x\n",
2061 seq_printf(seq
, "Network interface Pin 1 : %2.2x\n",
2062 config
->NetIntPin1
);
2063 seq_printf(seq
, "Network interface Pin 2 : %2.2x\n",
2064 config
->NetIntPin1
);
2065 seq_printf(seq
, "Network interface Pin 3 : %2.2x\n",
2066 config
->NetIntPin1
);
2067 seq_printf(seq
, "PM capabilities : %4.4X\n",
2069 seq_printf(seq
, "Network Clock Controls : %4.4X\n",
2070 config
->NwClkCtrls
);
2072 switch (config
->FruFormat
) {
2073 case ATK_FRU_FORMAT
:
2076 "Vendor : Alacritech, Inc.\n");
2078 "Assembly # : %c%c%c%c%c%c\n",
2079 fru
[0], fru
[1], fru
[2], fru
[3], fru
[4],
2082 "Revision # : %c%c\n",
2085 if (config
->OEMFruFormat
== VENDOR4_FRU_FORMAT
) {
2088 "%c%c%c%c%c%c%c%c%c%c%c%c\n",
2089 fru
[8], fru
[9], fru
[10],
2090 fru
[11], fru
[12], fru
[13],
2091 fru
[16], fru
[17], fru
[18],
2092 fru
[19], fru
[20], fru
[21]);
2096 "%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",
2097 fru
[8], fru
[9], fru
[10],
2098 fru
[11], fru
[12], fru
[13],
2099 fru
[14], fru
[15], fru
[16],
2100 fru
[17], fru
[18], fru
[19],
2109 "Vendor : Alacritech, Inc.\n");
2111 "Serial # : Empty FRU\n");
2116 switch (config
->OEMFruFormat
) {
2117 case VENDOR1_FRU_FORMAT
:
2119 seq_printf(seq
, "FRU Information:\n");
2120 seq_printf(seq
, " Commodity # : %c\n",
2123 " Assembly # : %c%c%c%c\n",
2124 oemfru
[1], oemfru
[2], oemfru
[3], oemfru
[4]);
2126 " Revision # : %c%c\n",
2127 oemfru
[5], oemfru
[6]);
2129 " Supplier # : %c%c\n",
2130 oemfru
[7], oemfru
[8]);
2133 oemfru
[9], oemfru
[10]);
2135 " Sequence # : %c%c%c\n",
2136 oemfru
[11], oemfru
[12], oemfru
[13]);
2140 case VENDOR2_FRU_FORMAT
:
2142 seq_printf(seq
, "FRU Information:\n");
2145 "%c%c%c%c%c%c%c%c\n",
2146 oemfru
[0], oemfru
[1], oemfru
[2],
2147 oemfru
[3], oemfru
[4], oemfru
[5],
2148 oemfru
[6], oemfru
[7]);
2150 " Supplier # : %c%c%c%c%c\n",
2151 oemfru
[8], oemfru
[9], oemfru
[10],
2152 oemfru
[11], oemfru
[12]);
2155 oemfru
[13], oemfru
[14], oemfru
[15]);
2157 " Sequence # : %c%c%c%c\n",
2158 oemfru
[16], oemfru
[17], oemfru
[18],
2163 case VENDOR3_FRU_FORMAT
:
2165 seq_printf(seq
, "FRU Information:\n");
2168 case VENDOR4_FRU_FORMAT
:
2170 seq_printf(seq
, "FRU Information:\n");
2173 "%c%c%c%c%c%c%c%c\n",
2174 oemfru
[0], oemfru
[1], oemfru
[2],
2175 oemfru
[3], oemfru
[4], oemfru
[5],
2176 oemfru
[6], oemfru
[7]);
2179 "%c%c%c%c%c%c%c%c\n",
2180 oemfru
[8], oemfru
[9], oemfru
[10],
2181 oemfru
[11], oemfru
[12], oemfru
[13],
2182 oemfru
[14], oemfru
[15]);
2185 "%c%c%c%c%c%c%c%c\n",
2186 oemfru
[16], oemfru
[17], oemfru
[18],
2187 oemfru
[19], oemfru
[20], oemfru
[21],
2188 oemfru
[22], oemfru
[23]);
2200 static int slic_debug_adapter_show(struct seq_file
*seq
, void *v
)
2202 struct adapter
*adapter
= seq
->private;
2203 struct net_device
*netdev
= adapter
->netdev
;
2205 seq_printf(seq
, "info: interface : %s\n",
2206 adapter
->netdev
->name
);
2207 seq_printf(seq
, "info: status : %s\n",
2208 SLIC_LINKSTATE(adapter
->linkstate
));
2209 seq_printf(seq
, "info: port : %d\n",
2211 seq_printf(seq
, "info: speed : %s\n",
2212 SLIC_SPEED(adapter
->linkspeed
));
2213 seq_printf(seq
, "info: duplex : %s\n",
2214 SLIC_DUPLEX(adapter
->linkduplex
));
2215 seq_printf(seq
, "info: irq : 0x%X\n",
2216 (uint
) adapter
->irq
);
2217 seq_printf(seq
, "info: Interrupt Agg Delay: %d usec\n",
2218 adapter
->card
->loadlevel_current
);
2219 seq_printf(seq
, "info: RcvQ max entries : %4.4X\n",
2221 seq_printf(seq
, "info: RcvQ current : %4.4X\n",
2222 adapter
->rcvqueue
.count
);
2223 seq_printf(seq
, "rx stats: packets : %8.8lX\n",
2224 netdev
->stats
.rx_packets
);
2225 seq_printf(seq
, "rx stats: bytes : %8.8lX\n",
2226 netdev
->stats
.rx_bytes
);
2227 seq_printf(seq
, "rx stats: broadcasts : %8.8X\n",
2228 adapter
->rcv_broadcasts
);
2229 seq_printf(seq
, "rx stats: multicasts : %8.8X\n",
2230 adapter
->rcv_multicasts
);
2231 seq_printf(seq
, "rx stats: unicasts : %8.8X\n",
2232 adapter
->rcv_unicasts
);
2233 seq_printf(seq
, "rx stats: errors : %8.8X\n",
2234 (u32
) adapter
->slic_stats
.iface
.rcv_errors
);
2235 seq_printf(seq
, "rx stats: Missed errors : %8.8X\n",
2236 (u32
) adapter
->slic_stats
.iface
.rcv_discards
);
2237 seq_printf(seq
, "rx stats: drops : %8.8X\n",
2238 (u32
) adapter
->rcv_drops
);
2239 seq_printf(seq
, "tx stats: packets : %8.8lX\n",
2240 netdev
->stats
.tx_packets
);
2241 seq_printf(seq
, "tx stats: bytes : %8.8lX\n",
2242 netdev
->stats
.tx_bytes
);
2243 seq_printf(seq
, "tx stats: errors : %8.8X\n",
2244 (u32
) adapter
->slic_stats
.iface
.xmt_errors
);
2245 seq_printf(seq
, "rx stats: multicasts : %8.8lX\n",
2246 netdev
->stats
.multicast
);
2247 seq_printf(seq
, "tx stats: collision errors : %8.8X\n",
2248 (u32
) adapter
->slic_stats
.iface
.xmit_collisions
);
2249 seq_printf(seq
, "perf: Max rcv frames/isr : %8.8X\n",
2250 adapter
->max_isr_rcvs
);
2251 seq_printf(seq
, "perf: Rcv interrupt yields : %8.8X\n",
2252 adapter
->rcv_interrupt_yields
);
2253 seq_printf(seq
, "perf: Max xmit complete/isr : %8.8X\n",
2254 adapter
->max_isr_xmits
);
2255 seq_printf(seq
, "perf: error interrupts : %8.8X\n",
2256 adapter
->error_interrupts
);
2257 seq_printf(seq
, "perf: error rmiss interrupts : %8.8X\n",
2258 adapter
->error_rmiss_interrupts
);
2259 seq_printf(seq
, "perf: rcv interrupts : %8.8X\n",
2260 adapter
->rcv_interrupts
);
2261 seq_printf(seq
, "perf: xmit interrupts : %8.8X\n",
2262 adapter
->xmit_interrupts
);
2263 seq_printf(seq
, "perf: link event interrupts : %8.8X\n",
2264 adapter
->linkevent_interrupts
);
2265 seq_printf(seq
, "perf: UPR interrupts : %8.8X\n",
2266 adapter
->upr_interrupts
);
2267 seq_printf(seq
, "perf: interrupt count : %8.8X\n",
2269 seq_printf(seq
, "perf: false interrupts : %8.8X\n",
2270 adapter
->false_interrupts
);
2271 seq_printf(seq
, "perf: All register writes : %8.8X\n",
2272 adapter
->all_reg_writes
);
2273 seq_printf(seq
, "perf: ICR register writes : %8.8X\n",
2274 adapter
->icr_reg_writes
);
2275 seq_printf(seq
, "perf: ISR register writes : %8.8X\n",
2276 adapter
->isr_reg_writes
);
2277 seq_printf(seq
, "ifevents: overflow 802 errors : %8.8X\n",
2278 adapter
->if_events
.oflow802
);
2279 seq_printf(seq
, "ifevents: transport overflow errors: %8.8X\n",
2280 adapter
->if_events
.Tprtoflow
);
2281 seq_printf(seq
, "ifevents: underflow errors : %8.8X\n",
2282 adapter
->if_events
.uflow802
);
2283 seq_printf(seq
, "ifevents: receive early : %8.8X\n",
2284 adapter
->if_events
.rcvearly
);
2285 seq_printf(seq
, "ifevents: buffer overflows : %8.8X\n",
2286 adapter
->if_events
.Bufov
);
2287 seq_printf(seq
, "ifevents: carrier errors : %8.8X\n",
2288 adapter
->if_events
.Carre
);
2289 seq_printf(seq
, "ifevents: Long : %8.8X\n",
2290 adapter
->if_events
.Longe
);
2291 seq_printf(seq
, "ifevents: invalid preambles : %8.8X\n",
2292 adapter
->if_events
.Invp
);
2293 seq_printf(seq
, "ifevents: CRC errors : %8.8X\n",
2294 adapter
->if_events
.Crc
);
2295 seq_printf(seq
, "ifevents: dribble nibbles : %8.8X\n",
2296 adapter
->if_events
.Drbl
);
2297 seq_printf(seq
, "ifevents: Code violations : %8.8X\n",
2298 adapter
->if_events
.Code
);
2299 seq_printf(seq
, "ifevents: TCP checksum errors : %8.8X\n",
2300 adapter
->if_events
.TpCsum
);
2301 seq_printf(seq
, "ifevents: TCP header short errors : %8.8X\n",
2302 adapter
->if_events
.TpHlen
);
2303 seq_printf(seq
, "ifevents: IP checksum errors : %8.8X\n",
2304 adapter
->if_events
.IpCsum
);
2305 seq_printf(seq
, "ifevents: IP frame incompletes : %8.8X\n",
2306 adapter
->if_events
.IpLen
);
2307 seq_printf(seq
, "ifevents: IP headers shorts : %8.8X\n",
2308 adapter
->if_events
.IpHlen
);
2312 static int slic_debug_adapter_open(struct inode
*inode
, struct file
*file
)
2314 return single_open(file
, slic_debug_adapter_show
, inode
->i_private
);
2317 static int slic_debug_card_open(struct inode
*inode
, struct file
*file
)
2319 return single_open(file
, slic_debug_card_show
, inode
->i_private
);
2322 static const struct file_operations slic_debug_adapter_fops
= {
2323 .owner
= THIS_MODULE
,
2324 .open
= slic_debug_adapter_open
,
2326 .llseek
= seq_lseek
,
2327 .release
= single_release
,
2330 static const struct file_operations slic_debug_card_fops
= {
2331 .owner
= THIS_MODULE
,
2332 .open
= slic_debug_card_open
,
2334 .llseek
= seq_lseek
,
2335 .release
= single_release
,
2338 static void slic_debug_adapter_create(struct adapter
*adapter
)
2342 struct sliccard
*card
= adapter
->card
;
2344 if (!card
->debugfs_dir
)
2347 sprintf(name
, "port%d", adapter
->port
);
2348 d
= debugfs_create_file(name
, S_IRUGO
,
2349 card
->debugfs_dir
, adapter
,
2350 &slic_debug_adapter_fops
);
2351 if (!d
|| IS_ERR(d
))
2352 pr_info(PFX
"%s: debugfs create failed\n", name
);
2354 adapter
->debugfs_entry
= d
;
2357 static void slic_debug_adapter_destroy(struct adapter
*adapter
)
2359 debugfs_remove(adapter
->debugfs_entry
);
2360 adapter
->debugfs_entry
= NULL
;
2363 static void slic_debug_card_create(struct sliccard
*card
)
2366 char name
[IFNAMSIZ
];
2368 snprintf(name
, sizeof(name
), "slic%d", card
->cardnum
);
2369 d
= debugfs_create_dir(name
, slic_debugfs
);
2370 if (!d
|| IS_ERR(d
))
2371 pr_info(PFX
"%s: debugfs create dir failed\n",
2374 card
->debugfs_dir
= d
;
2375 d
= debugfs_create_file("cardinfo", S_IRUGO
,
2377 &slic_debug_card_fops
);
2378 if (!d
|| IS_ERR(d
))
2379 pr_info(PFX
"%s: debugfs create failed\n",
2382 card
->debugfs_cardinfo
= d
;
2386 static void slic_debug_card_destroy(struct sliccard
*card
)
2390 for (i
= 0; i
< card
->card_size
; i
++) {
2391 struct adapter
*adapter
;
2393 adapter
= card
->adapter
[i
];
2395 slic_debug_adapter_destroy(adapter
);
2397 if (card
->debugfs_cardinfo
) {
2398 debugfs_remove(card
->debugfs_cardinfo
);
2399 card
->debugfs_cardinfo
= NULL
;
2401 if (card
->debugfs_dir
) {
2402 debugfs_remove(card
->debugfs_dir
);
2403 card
->debugfs_dir
= NULL
;
2407 static void slic_debug_init(void)
2411 ent
= debugfs_create_dir("slic", NULL
);
2412 if (!ent
|| IS_ERR(ent
)) {
2413 pr_info(PFX
"debugfs create directory failed\n");
2420 static void slic_debug_cleanup(void)
2423 debugfs_remove(slic_debugfs
);
2424 slic_debugfs
= NULL
;
2429 * slic_link_event_handler -
2431 * Initiate a link configuration sequence. The link configuration begins
2432 * by issuing a READ_LINK_STATUS command to the Utility Processor on the
2433 * SLIC. Since the command finishes asynchronously, the slic_upr_comlete
2434 * routine will follow it up witha UP configuration write command, which
2435 * will also complete asynchronously.
2438 static void slic_link_event_handler(struct adapter
*adapter
)
2441 struct slic_shmem
*pshmem
;
2443 if (adapter
->state
!= ADAPT_UP
) {
2444 /* Adapter is not operational. Ignore. */
2448 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
2450 #if defined(CONFIG_X86_64)
2451 status
= slic_upr_request(adapter
,
2453 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
2454 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
2456 #elif defined(CONFIG_X86)
2457 status
= slic_upr_request(adapter
, SLIC_UPR_RLSR
,
2458 (u32
) &pshmem
->linkstatus
, /* no 4GB wrap guaranteed */
2463 ASSERT(status
== 0);
2466 static void slic_init_cleanup(struct adapter
*adapter
)
2468 if (adapter
->intrregistered
) {
2469 adapter
->intrregistered
= 0;
2470 free_irq(adapter
->netdev
->irq
, adapter
->netdev
);
2473 if (adapter
->pshmem
) {
2474 pci_free_consistent(adapter
->pcidev
,
2475 sizeof(struct slic_shmem
),
2476 adapter
->pshmem
, adapter
->phys_shmem
);
2477 adapter
->pshmem
= NULL
;
2478 adapter
->phys_shmem
= (dma_addr_t
) NULL
;
2481 if (adapter
->pingtimerset
) {
2482 adapter
->pingtimerset
= 0;
2483 del_timer(&adapter
->pingtimer
);
2486 slic_rspqueue_free(adapter
);
2487 slic_cmdq_free(adapter
);
2488 slic_rcvqueue_free(adapter
);
2492 * Allocate a mcast_address structure to hold the multicast address.
2495 static int slic_mcast_add_list(struct adapter
*adapter
, char *address
)
2497 struct mcast_address
*mcaddr
, *mlist
;
2499 /* Check to see if it already exists */
2500 mlist
= adapter
->mcastaddrs
;
2502 if (!compare_ether_addr(mlist
->address
, address
))
2504 mlist
= mlist
->next
;
2507 /* Doesn't already exist. Allocate a structure to hold it */
2508 mcaddr
= kmalloc(sizeof(struct mcast_address
), GFP_ATOMIC
);
2512 memcpy(mcaddr
->address
, address
, 6);
2514 mcaddr
->next
= adapter
->mcastaddrs
;
2515 adapter
->mcastaddrs
= mcaddr
;
2520 static void slic_mcast_set_list(struct net_device
*dev
)
2522 struct adapter
*adapter
= netdev_priv(dev
);
2525 struct netdev_hw_addr
*ha
;
2529 netdev_for_each_mc_addr(ha
, dev
) {
2530 addresses
= (char *) &ha
->addr
;
2531 status
= slic_mcast_add_list(adapter
, addresses
);
2534 slic_mcast_set_bit(adapter
, addresses
);
2537 if (adapter
->devflags_prev
!= dev
->flags
) {
2538 adapter
->macopts
= MAC_DIRECTED
;
2540 if (dev
->flags
& IFF_BROADCAST
)
2541 adapter
->macopts
|= MAC_BCAST
;
2542 if (dev
->flags
& IFF_PROMISC
)
2543 adapter
->macopts
|= MAC_PROMISC
;
2544 if (dev
->flags
& IFF_ALLMULTI
)
2545 adapter
->macopts
|= MAC_ALLMCAST
;
2546 if (dev
->flags
& IFF_MULTICAST
)
2547 adapter
->macopts
|= MAC_MCAST
;
2549 adapter
->devflags_prev
= dev
->flags
;
2550 slic_config_set(adapter
, true);
2553 slic_mcast_set_mask(adapter
);
2558 #define XMIT_FAIL_LINK_STATE 1
2559 #define XMIT_FAIL_ZERO_LENGTH 2
2560 #define XMIT_FAIL_HOSTCMD_FAIL 3
2562 static void slic_xmit_build_request(struct adapter
*adapter
,
2563 struct slic_hostcmd
*hcmd
, struct sk_buff
*skb
)
2565 struct slic_host64_cmd
*ihcmd
;
2568 ihcmd
= &hcmd
->cmd64
;
2570 ihcmd
->flags
= (adapter
->port
<< IHFLG_IFSHFT
);
2571 ihcmd
->command
= IHCMD_XMT_REQ
;
2572 ihcmd
->u
.slic_buffers
.totlen
= skb
->len
;
2573 phys_addr
= pci_map_single(adapter
->pcidev
, skb
->data
, skb
->len
,
2575 ihcmd
->u
.slic_buffers
.bufs
[0].paddrl
= SLIC_GET_ADDR_LOW(phys_addr
);
2576 ihcmd
->u
.slic_buffers
.bufs
[0].paddrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
2577 ihcmd
->u
.slic_buffers
.bufs
[0].length
= skb
->len
;
2578 #if defined(CONFIG_X86_64)
2579 hcmd
->cmdsize
= (u32
) ((((u64
)&ihcmd
->u
.slic_buffers
.bufs
[1] -
2580 (u64
) hcmd
) + 31) >> 5);
2581 #elif defined(CONFIG_X86)
2582 hcmd
->cmdsize
= ((((u32
) &ihcmd
->u
.slic_buffers
.bufs
[1] -
2583 (u32
) hcmd
) + 31) >> 5);
2589 static void slic_xmit_fail(struct adapter
*adapter
,
2590 struct sk_buff
*skb
,
2591 void *cmd
, u32 skbtype
, u32 status
)
2593 if (adapter
->xmitq_full
)
2594 netif_stop_queue(adapter
->netdev
);
2595 if ((cmd
== NULL
) && (status
<= XMIT_FAIL_HOSTCMD_FAIL
)) {
2597 case XMIT_FAIL_LINK_STATE
:
2598 dev_err(&adapter
->netdev
->dev
,
2599 "reject xmit skb[%p: %x] linkstate[%s] "
2600 "adapter[%s:%d] card[%s:%d]\n",
2602 SLIC_LINKSTATE(adapter
->linkstate
),
2603 SLIC_ADAPTER_STATE(adapter
->state
),
2605 SLIC_CARD_STATE(adapter
->card
->state
),
2606 adapter
->card
->state
);
2608 case XMIT_FAIL_ZERO_LENGTH
:
2609 dev_err(&adapter
->netdev
->dev
,
2610 "xmit_start skb->len == 0 skb[%p] type[%x]\n",
2611 skb
, skb
->pkt_type
);
2613 case XMIT_FAIL_HOSTCMD_FAIL
:
2614 dev_err(&adapter
->netdev
->dev
,
2615 "xmit_start skb[%p] type[%x] No host commands "
2616 "available\n", skb
, skb
->pkt_type
);
2623 adapter
->netdev
->stats
.tx_dropped
++;
2626 static void slic_rcv_handle_error(struct adapter
*adapter
,
2627 struct slic_rcvbuf
*rcvbuf
)
2629 struct slic_hddr_wds
*hdr
= (struct slic_hddr_wds
*)rcvbuf
->data
;
2630 struct net_device
*netdev
= adapter
->netdev
;
2632 if (adapter
->devid
!= SLIC_1GB_DEVICE_ID
) {
2633 if (hdr
->frame_status14
& VRHSTAT_802OE
)
2634 adapter
->if_events
.oflow802
++;
2635 if (hdr
->frame_status14
& VRHSTAT_TPOFLO
)
2636 adapter
->if_events
.Tprtoflow
++;
2637 if (hdr
->frame_status_b14
& VRHSTATB_802UE
)
2638 adapter
->if_events
.uflow802
++;
2639 if (hdr
->frame_status_b14
& VRHSTATB_RCVE
) {
2640 adapter
->if_events
.rcvearly
++;
2641 netdev
->stats
.rx_fifo_errors
++;
2643 if (hdr
->frame_status_b14
& VRHSTATB_BUFF
) {
2644 adapter
->if_events
.Bufov
++;
2645 netdev
->stats
.rx_over_errors
++;
2647 if (hdr
->frame_status_b14
& VRHSTATB_CARRE
) {
2648 adapter
->if_events
.Carre
++;
2649 netdev
->stats
.tx_carrier_errors
++;
2651 if (hdr
->frame_status_b14
& VRHSTATB_LONGE
)
2652 adapter
->if_events
.Longe
++;
2653 if (hdr
->frame_status_b14
& VRHSTATB_PREA
)
2654 adapter
->if_events
.Invp
++;
2655 if (hdr
->frame_status_b14
& VRHSTATB_CRC
) {
2656 adapter
->if_events
.Crc
++;
2657 netdev
->stats
.rx_crc_errors
++;
2659 if (hdr
->frame_status_b14
& VRHSTATB_DRBL
)
2660 adapter
->if_events
.Drbl
++;
2661 if (hdr
->frame_status_b14
& VRHSTATB_CODE
)
2662 adapter
->if_events
.Code
++;
2663 if (hdr
->frame_status_b14
& VRHSTATB_TPCSUM
)
2664 adapter
->if_events
.TpCsum
++;
2665 if (hdr
->frame_status_b14
& VRHSTATB_TPHLEN
)
2666 adapter
->if_events
.TpHlen
++;
2667 if (hdr
->frame_status_b14
& VRHSTATB_IPCSUM
)
2668 adapter
->if_events
.IpCsum
++;
2669 if (hdr
->frame_status_b14
& VRHSTATB_IPLERR
)
2670 adapter
->if_events
.IpLen
++;
2671 if (hdr
->frame_status_b14
& VRHSTATB_IPHERR
)
2672 adapter
->if_events
.IpHlen
++;
2674 if (hdr
->frame_statusGB
& VGBSTAT_XPERR
) {
2675 u32 xerr
= hdr
->frame_statusGB
>> VGBSTAT_XERRSHFT
;
2677 if (xerr
== VGBSTAT_XCSERR
)
2678 adapter
->if_events
.TpCsum
++;
2679 if (xerr
== VGBSTAT_XUFLOW
)
2680 adapter
->if_events
.Tprtoflow
++;
2681 if (xerr
== VGBSTAT_XHLEN
)
2682 adapter
->if_events
.TpHlen
++;
2684 if (hdr
->frame_statusGB
& VGBSTAT_NETERR
) {
2687 frame_statusGB
>> VGBSTAT_NERRSHFT
) &
2689 if (nerr
== VGBSTAT_NCSERR
)
2690 adapter
->if_events
.IpCsum
++;
2691 if (nerr
== VGBSTAT_NUFLOW
)
2692 adapter
->if_events
.IpLen
++;
2693 if (nerr
== VGBSTAT_NHLEN
)
2694 adapter
->if_events
.IpHlen
++;
2696 if (hdr
->frame_statusGB
& VGBSTAT_LNKERR
) {
2697 u32 lerr
= hdr
->frame_statusGB
& VGBSTAT_LERRMSK
;
2699 if (lerr
== VGBSTAT_LDEARLY
)
2700 adapter
->if_events
.rcvearly
++;
2701 if (lerr
== VGBSTAT_LBOFLO
)
2702 adapter
->if_events
.Bufov
++;
2703 if (lerr
== VGBSTAT_LCODERR
)
2704 adapter
->if_events
.Code
++;
2705 if (lerr
== VGBSTAT_LDBLNBL
)
2706 adapter
->if_events
.Drbl
++;
2707 if (lerr
== VGBSTAT_LCRCERR
)
2708 adapter
->if_events
.Crc
++;
2709 if (lerr
== VGBSTAT_LOFLO
)
2710 adapter
->if_events
.oflow802
++;
2711 if (lerr
== VGBSTAT_LUFLO
)
2712 adapter
->if_events
.uflow802
++;
2718 #define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000
2719 #define M_FAST_PATH 0x0040
2721 static void slic_rcv_handler(struct adapter
*adapter
)
2723 struct net_device
*netdev
= adapter
->netdev
;
2724 struct sk_buff
*skb
;
2725 struct slic_rcvbuf
*rcvbuf
;
2728 while ((skb
= slic_rcvqueue_getnext(adapter
))) {
2732 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
2733 adapter
->card
->events
++;
2734 if (rcvbuf
->status
& IRHDDR_ERR
) {
2735 adapter
->rx_errors
++;
2736 slic_rcv_handle_error(adapter
, rcvbuf
);
2737 slic_rcvqueue_reinsert(adapter
, skb
);
2741 if (!slic_mac_filter(adapter
, (struct ether_header
*)
2743 slic_rcvqueue_reinsert(adapter
, skb
);
2746 skb_pull(skb
, SLIC_RCVBUF_HEADSIZE
);
2747 rx_bytes
= (rcvbuf
->length
& IRHDDR_FLEN_MSK
);
2748 skb_put(skb
, rx_bytes
);
2749 netdev
->stats
.rx_packets
++;
2750 netdev
->stats
.rx_bytes
+= rx_bytes
;
2751 #if SLIC_OFFLOAD_IP_CHECKSUM
2752 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2755 skb
->dev
= adapter
->netdev
;
2756 skb
->protocol
= eth_type_trans(skb
, skb
->dev
);
2760 #if SLIC_INTERRUPT_PROCESS_LIMIT
2761 if (frames
>= SLIC_RCVQ_MAX_PROCESS_ISR
) {
2762 adapter
->rcv_interrupt_yields
++;
2767 adapter
->max_isr_rcvs
= max(adapter
->max_isr_rcvs
, frames
);
2770 static void slic_xmit_complete(struct adapter
*adapter
)
2772 struct slic_hostcmd
*hcmd
;
2773 struct slic_rspbuf
*rspbuf
;
2775 struct slic_handle_word slic_handle_word
;
2778 rspbuf
= slic_rspqueue_getnext(adapter
);
2781 adapter
->xmit_completes
++;
2782 adapter
->card
->events
++;
2784 Get the complete host command buffer
2786 slic_handle_word
.handle_token
= rspbuf
->hosthandle
;
2787 ASSERT(slic_handle_word
.handle_index
);
2788 ASSERT(slic_handle_word
.handle_index
<= SLIC_CMDQ_MAXCMDS
);
2790 (struct slic_hostcmd
*)
2791 adapter
->slic_handles
[slic_handle_word
.handle_index
].
2793 /* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
2795 ASSERT(hcmd
->pslic_handle
==
2796 &adapter
->slic_handles
[slic_handle_word
.handle_index
]);
2797 if (hcmd
->type
== SLIC_CMD_DUMB
) {
2799 dev_kfree_skb_irq(hcmd
->skb
);
2800 slic_cmdq_putdone_irq(adapter
, hcmd
);
2803 rspbuf
->hosthandle
= 0;
2806 adapter
->max_isr_xmits
= max(adapter
->max_isr_xmits
, frames
);
2809 static irqreturn_t
slic_interrupt(int irq
, void *dev_id
)
2811 struct net_device
*dev
= (struct net_device
*)dev_id
;
2812 struct adapter
*adapter
= netdev_priv(dev
);
2815 if ((adapter
->pshmem
) && (adapter
->pshmem
->isr
)) {
2816 slic_reg32_write(&adapter
->slic_regs
->slic_icr
,
2817 ICR_INT_MASK
, FLUSH
);
2818 isr
= adapter
->isrcopy
= adapter
->pshmem
->isr
;
2819 adapter
->pshmem
->isr
= 0;
2820 adapter
->num_isrs
++;
2821 switch (adapter
->card
->state
) {
2823 if (isr
& ~ISR_IO
) {
2824 if (isr
& ISR_ERR
) {
2825 adapter
->error_interrupts
++;
2826 if (isr
& ISR_RMISS
) {
2831 struct slic_rcvqueue
*rcvq
=
2835 error_rmiss_interrupts
++;
2837 rcv_count
= rcvq
->count
;
2838 pre_count
= rcvq
->count
;
2839 errors
= rcvq
->errors
;
2841 while (rcvq
->count
<
2842 SLIC_RCVQ_FILLTHRESH
) {
2849 } else if (isr
& ISR_XDROP
) {
2851 "isr & ISR_ERR [%x] "
2852 "ISR_XDROP \n", isr
);
2855 "isr & ISR_ERR [%x]\n",
2860 if (isr
& ISR_LEVENT
) {
2861 adapter
->linkevent_interrupts
++;
2862 slic_link_event_handler(adapter
);
2865 if ((isr
& ISR_UPC
) ||
2866 (isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
2867 adapter
->upr_interrupts
++;
2868 slic_upr_request_complete(adapter
, isr
);
2872 if (isr
& ISR_RCV
) {
2873 adapter
->rcv_interrupts
++;
2874 slic_rcv_handler(adapter
);
2877 if (isr
& ISR_CMD
) {
2878 adapter
->xmit_interrupts
++;
2879 slic_xmit_complete(adapter
);
2884 if ((isr
& ISR_UPC
) ||
2885 (isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
2886 adapter
->upr_interrupts
++;
2887 slic_upr_request_complete(adapter
, isr
);
2895 adapter
->isrcopy
= 0;
2896 adapter
->all_reg_writes
+= 2;
2897 adapter
->isr_reg_writes
++;
2898 slic_reg32_write(&adapter
->slic_regs
->slic_isr
, 0, FLUSH
);
2900 adapter
->false_interrupts
++;
2905 #define NORMAL_ETHFRAME 0
2907 static netdev_tx_t
slic_xmit_start(struct sk_buff
*skb
, struct net_device
*dev
)
2909 struct sliccard
*card
;
2910 struct adapter
*adapter
= netdev_priv(dev
);
2911 struct slic_hostcmd
*hcmd
= NULL
;
2913 u32 skbtype
= NORMAL_ETHFRAME
;
2914 void *offloadcmd
= NULL
;
2916 card
= adapter
->card
;
2918 if ((adapter
->linkstate
!= LINK_UP
) ||
2919 (adapter
->state
!= ADAPT_UP
) || (card
->state
!= CARD_UP
)) {
2920 status
= XMIT_FAIL_LINK_STATE
;
2923 } else if (skb
->len
== 0) {
2924 status
= XMIT_FAIL_ZERO_LENGTH
;
2928 if (skbtype
== NORMAL_ETHFRAME
) {
2929 hcmd
= slic_cmdq_getfree(adapter
);
2931 adapter
->xmitq_full
= 1;
2932 status
= XMIT_FAIL_HOSTCMD_FAIL
;
2935 ASSERT(hcmd
->pslic_handle
);
2936 ASSERT(hcmd
->cmd64
.hosthandle
==
2937 hcmd
->pslic_handle
->token
.handle_token
);
2940 hcmd
->type
= SLIC_CMD_DUMB
;
2941 if (skbtype
== NORMAL_ETHFRAME
)
2942 slic_xmit_build_request(adapter
, hcmd
, skb
);
2944 dev
->stats
.tx_packets
++;
2945 dev
->stats
.tx_bytes
+= skb
->len
;
2948 if (adapter
->kill_card
) {
2949 struct slic_host64_cmd ihcmd
;
2951 ihcmd
= &hcmd
->cmd64
;
2953 ihcmd
->flags
|= 0x40;
2954 adapter
->kill_card
= 0; /* only do this once */
2957 if (hcmd
->paddrh
== 0) {
2958 slic_reg32_write(&adapter
->slic_regs
->slic_cbar
,
2959 (hcmd
->paddrl
| hcmd
->cmdsize
), DONT_FLUSH
);
2961 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_cbar64
,
2962 (hcmd
->paddrl
| hcmd
->cmdsize
),
2963 &adapter
->slic_regs
->slic_addr_upper
,
2964 hcmd
->paddrh
, DONT_FLUSH
);
2967 return NETDEV_TX_OK
;
2969 slic_xmit_fail(adapter
, skb
, offloadcmd
, skbtype
, status
);
2974 static void slic_adapter_freeresources(struct adapter
*adapter
)
2976 slic_init_cleanup(adapter
);
2977 adapter
->error_interrupts
= 0;
2978 adapter
->rcv_interrupts
= 0;
2979 adapter
->xmit_interrupts
= 0;
2980 adapter
->linkevent_interrupts
= 0;
2981 adapter
->upr_interrupts
= 0;
2982 adapter
->num_isrs
= 0;
2983 adapter
->xmit_completes
= 0;
2984 adapter
->rcv_broadcasts
= 0;
2985 adapter
->rcv_multicasts
= 0;
2986 adapter
->rcv_unicasts
= 0;
2989 static int slic_adapter_allocresources(struct adapter
*adapter
)
2991 if (!adapter
->intrregistered
) {
2994 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
2995 slic_global
.driver_lock
.flags
);
2997 retval
= request_irq(adapter
->netdev
->irq
,
3000 adapter
->netdev
->name
, adapter
->netdev
);
3002 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
3003 slic_global
.driver_lock
.flags
);
3006 dev_err(&adapter
->netdev
->dev
,
3007 "request_irq (%s) FAILED [%x]\n",
3008 adapter
->netdev
->name
, retval
);
3011 adapter
->intrregistered
= 1;
3019 * Perform initialization of our slic interface.
3022 static int slic_if_init(struct adapter
*adapter
)
3024 struct sliccard
*card
= adapter
->card
;
3025 struct net_device
*dev
= adapter
->netdev
;
3026 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
3027 struct slic_shmem
*pshmem
;
3032 /* adapter should be down at this point */
3033 if (adapter
->state
!= ADAPT_DOWN
) {
3034 dev_err(&dev
->dev
, "%s: adapter->state != ADAPT_DOWN\n",
3039 ASSERT(adapter
->linkstate
== LINK_DOWN
);
3041 adapter
->devflags_prev
= dev
->flags
;
3042 adapter
->macopts
= MAC_DIRECTED
;
3044 if (dev
->flags
& IFF_BROADCAST
)
3045 adapter
->macopts
|= MAC_BCAST
;
3046 if (dev
->flags
& IFF_PROMISC
)
3047 adapter
->macopts
|= MAC_PROMISC
;
3048 if (dev
->flags
& IFF_ALLMULTI
)
3049 adapter
->macopts
|= MAC_ALLMCAST
;
3050 if (dev
->flags
& IFF_MULTICAST
)
3051 adapter
->macopts
|= MAC_MCAST
;
3053 rc
= slic_adapter_allocresources(adapter
);
3056 "%s: slic_adapter_allocresources FAILED %x\n",
3058 slic_adapter_freeresources(adapter
);
3062 if (!adapter
->queues_initialized
) {
3063 if ((rc
= slic_rspqueue_init(adapter
)))
3065 if ((rc
= slic_cmdq_init(adapter
)))
3067 if ((rc
= slic_rcvqueue_init(adapter
)))
3069 adapter
->queues_initialized
= 1;
3072 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
3075 if (!adapter
->isp_initialized
) {
3076 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
3078 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
3079 adapter
->bit64reglock
.flags
);
3081 #if defined(CONFIG_X86_64)
3082 slic_reg32_write(&slic_regs
->slic_addr_upper
,
3083 SLIC_GET_ADDR_HIGH(&pshmem
->isr
), DONT_FLUSH
);
3084 slic_reg32_write(&slic_regs
->slic_isp
,
3085 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
3086 #elif defined(CONFIG_X86)
3087 slic_reg32_write(&slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
3088 slic_reg32_write(&slic_regs
->slic_isp
, (u32
)&pshmem
->isr
, FLUSH
);
3092 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
3093 adapter
->bit64reglock
.flags
);
3094 adapter
->isp_initialized
= 1;
3097 adapter
->state
= ADAPT_UP
;
3098 if (!card
->loadtimerset
) {
3099 init_timer(&card
->loadtimer
);
3100 card
->loadtimer
.expires
=
3101 jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
3102 card
->loadtimer
.data
= (ulong
) card
;
3103 card
->loadtimer
.function
= &slic_timer_load_check
;
3104 add_timer(&card
->loadtimer
);
3106 card
->loadtimerset
= 1;
3109 if (!adapter
->pingtimerset
) {
3110 init_timer(&adapter
->pingtimer
);
3111 adapter
->pingtimer
.expires
=
3112 jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
3113 adapter
->pingtimer
.data
= (ulong
) dev
;
3114 adapter
->pingtimer
.function
= &slic_timer_ping
;
3115 add_timer(&adapter
->pingtimer
);
3116 adapter
->pingtimerset
= 1;
3117 adapter
->card
->pingstatus
= ISR_PINGMASK
;
3121 * clear any pending events, then enable interrupts
3123 adapter
->isrcopy
= 0;
3124 adapter
->pshmem
->isr
= 0;
3125 slic_reg32_write(&slic_regs
->slic_isr
, 0, FLUSH
);
3126 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_ON
, FLUSH
);
3128 slic_link_config(adapter
, LINK_AUTOSPEED
, LINK_AUTOD
);
3129 slic_link_event_handler(adapter
);
3135 static int slic_entry_open(struct net_device
*dev
)
3137 struct adapter
*adapter
= netdev_priv(dev
);
3138 struct sliccard
*card
= adapter
->card
;
3145 netif_stop_queue(adapter
->netdev
);
3147 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
3148 slic_global
.driver_lock
.flags
);
3150 if (!adapter
->activated
) {
3151 card
->adapters_activated
++;
3152 slic_global
.num_slic_ports_active
++;
3153 adapter
->activated
= 1;
3155 status
= slic_if_init(adapter
);
3158 if (adapter
->activated
) {
3159 card
->adapters_activated
--;
3160 slic_global
.num_slic_ports_active
--;
3161 adapter
->activated
= 0;
3164 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
3165 slic_global
.driver_lock
.flags
);
3171 card
->master
= adapter
;
3174 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
3175 slic_global
.driver_lock
.flags
);
3182 static void slic_card_cleanup(struct sliccard
*card
)
3184 if (card
->loadtimerset
) {
3185 card
->loadtimerset
= 0;
3186 del_timer(&card
->loadtimer
);
3189 slic_debug_card_destroy(card
);
3194 static void __devexit
slic_entry_remove(struct pci_dev
*pcidev
)
3196 struct net_device
*dev
= pci_get_drvdata(pcidev
);
3199 struct adapter
*adapter
= netdev_priv(dev
);
3200 struct sliccard
*card
;
3201 struct mcast_address
*mcaddr
, *mlist
;
3204 slic_adapter_freeresources(adapter
);
3205 slic_unmap_mmio_space(adapter
);
3206 unregister_netdev(dev
);
3208 mmio_start
= pci_resource_start(pcidev
, 0);
3209 mmio_len
= pci_resource_len(pcidev
, 0);
3211 release_mem_region(mmio_start
, mmio_len
);
3213 iounmap((void __iomem
*)dev
->base_addr
);
3214 /* free multicast addresses */
3215 mlist
= adapter
->mcastaddrs
;
3218 mlist
= mlist
->next
;
3221 ASSERT(adapter
->card
);
3222 card
= adapter
->card
;
3223 ASSERT(card
->adapters_allocated
);
3224 card
->adapters_allocated
--;
3225 adapter
->allocated
= 0;
3226 if (!card
->adapters_allocated
) {
3227 struct sliccard
*curr_card
= slic_global
.slic_card
;
3228 if (curr_card
== card
) {
3229 slic_global
.slic_card
= card
->next
;
3231 while (curr_card
->next
!= card
)
3232 curr_card
= curr_card
->next
;
3234 curr_card
->next
= card
->next
;
3236 ASSERT(slic_global
.num_slic_cards
);
3237 slic_global
.num_slic_cards
--;
3238 slic_card_cleanup(card
);
3241 pci_release_regions(pcidev
);
3244 static int slic_entry_halt(struct net_device
*dev
)
3246 struct adapter
*adapter
= netdev_priv(dev
);
3247 struct sliccard
*card
= adapter
->card
;
3248 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
3250 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
3251 slic_global
.driver_lock
.flags
);
3253 netif_stop_queue(adapter
->netdev
);
3254 adapter
->state
= ADAPT_DOWN
;
3255 adapter
->linkstate
= LINK_DOWN
;
3256 adapter
->upr_list
= NULL
;
3257 adapter
->upr_busy
= 0;
3258 adapter
->devflags_prev
= 0;
3259 ASSERT(card
->adapter
[adapter
->cardindex
] == adapter
);
3260 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
3261 adapter
->all_reg_writes
++;
3262 adapter
->icr_reg_writes
++;
3263 slic_config_clear(adapter
);
3264 if (adapter
->activated
) {
3265 card
->adapters_activated
--;
3266 slic_global
.num_slic_ports_active
--;
3267 adapter
->activated
= 0;
3269 #ifdef AUTOMATIC_RESET
3270 slic_reg32_write(&slic_regs
->slic_reset_iface
, 0, FLUSH
);
3273 * Reset the adapter's cmd queues
3275 slic_cmdq_reset(adapter
);
3277 #ifdef AUTOMATIC_RESET
3278 if (!card
->adapters_activated
)
3279 slic_card_init(card
, adapter
);
3282 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
3283 slic_global
.driver_lock
.flags
);
3287 static struct net_device_stats
*slic_get_stats(struct net_device
*dev
)
3289 struct adapter
*adapter
= netdev_priv(dev
);
3292 dev
->stats
.collisions
= adapter
->slic_stats
.iface
.xmit_collisions
;
3293 dev
->stats
.rx_errors
= adapter
->slic_stats
.iface
.rcv_errors
;
3294 dev
->stats
.tx_errors
= adapter
->slic_stats
.iface
.xmt_errors
;
3295 dev
->stats
.rx_missed_errors
= adapter
->slic_stats
.iface
.rcv_discards
;
3296 dev
->stats
.tx_heartbeat_errors
= 0;
3297 dev
->stats
.tx_aborted_errors
= 0;
3298 dev
->stats
.tx_window_errors
= 0;
3299 dev
->stats
.tx_fifo_errors
= 0;
3300 dev
->stats
.rx_frame_errors
= 0;
3301 dev
->stats
.rx_length_errors
= 0;
3306 static int slic_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
3308 struct adapter
*adapter
= netdev_priv(dev
);
3309 struct ethtool_cmd edata
;
3310 struct ethtool_cmd ecmd
;
3316 case SIOCSLICSETINTAGG
:
3317 if (copy_from_user(data
, rq
->ifr_data
, 28))
3320 dev_err(&dev
->dev
, "%s: set interrupt aggregation to %d\n",
3322 slic_intagg_set(adapter
, intagg
);
3325 #ifdef SLIC_TRACE_DUMP_ENABLED
3326 case SIOCSLICTRACEDUMP
:
3329 DBG_IOCTL("slic_ioctl SIOCSLIC_TRACE_DUMP\n");
3331 if (copy_from_user(data
, rq
->ifr_data
, 28)) {
3333 ("slic: copy_from_user FAILED getting initial simba param\n");
3338 if (tracemon_request
== SLIC_DUMP_DONE
) {
3340 ("ATK Diagnostic Trace Dump Requested\n");
3341 tracemon_request
= SLIC_DUMP_REQUESTED
;
3342 tracemon_request_type
= value
;
3343 tracemon_timestamp
= jiffies
;
3344 } else if ((tracemon_request
== SLIC_DUMP_REQUESTED
) ||
3345 (tracemon_request
==
3346 SLIC_DUMP_IN_PROGRESS
)) {
3348 ("ATK Diagnostic Trace Dump Requested but already in progress... ignore\n");
3351 ("ATK Diagnostic Trace Dump Requested\n");
3352 tracemon_request
= SLIC_DUMP_REQUESTED
;
3353 tracemon_request_type
= value
;
3354 tracemon_timestamp
= jiffies
;
3361 if (copy_from_user(&ecmd
, rq
->ifr_data
, sizeof(ecmd
)))
3364 if (ecmd
.cmd
== ETHTOOL_GSET
) {
3365 edata
.supported
= (SUPPORTED_10baseT_Half
|
3366 SUPPORTED_10baseT_Full
|
3367 SUPPORTED_100baseT_Half
|
3368 SUPPORTED_100baseT_Full
|
3369 SUPPORTED_Autoneg
| SUPPORTED_MII
);
3370 edata
.port
= PORT_MII
;
3371 edata
.transceiver
= XCVR_INTERNAL
;
3372 edata
.phy_address
= 0;
3373 if (adapter
->linkspeed
== LINK_100MB
)
3374 edata
.speed
= SPEED_100
;
3375 else if (adapter
->linkspeed
== LINK_10MB
)
3376 edata
.speed
= SPEED_10
;
3380 if (adapter
->linkduplex
== LINK_FULLD
)
3381 edata
.duplex
= DUPLEX_FULL
;
3383 edata
.duplex
= DUPLEX_HALF
;
3385 edata
.autoneg
= AUTONEG_ENABLE
;
3388 if (copy_to_user(rq
->ifr_data
, &edata
, sizeof(edata
)))
3391 } else if (ecmd
.cmd
== ETHTOOL_SSET
) {
3392 if (!capable(CAP_NET_ADMIN
))
3395 if (adapter
->linkspeed
== LINK_100MB
)
3396 edata
.speed
= SPEED_100
;
3397 else if (adapter
->linkspeed
== LINK_10MB
)
3398 edata
.speed
= SPEED_10
;
3402 if (adapter
->linkduplex
== LINK_FULLD
)
3403 edata
.duplex
= DUPLEX_FULL
;
3405 edata
.duplex
= DUPLEX_HALF
;
3407 edata
.autoneg
= AUTONEG_ENABLE
;
3410 if ((ecmd
.speed
!= edata
.speed
) ||
3411 (ecmd
.duplex
!= edata
.duplex
)) {
3415 if (ecmd
.speed
== SPEED_10
)
3418 speed
= PCR_SPEED_100
;
3419 if (ecmd
.duplex
== DUPLEX_FULL
)
3420 duplex
= PCR_DUPLEX_FULL
;
3423 slic_link_config(adapter
, speed
, duplex
);
3424 slic_link_event_handler(adapter
);
3433 static void slic_config_pci(struct pci_dev
*pcidev
)
3438 pci_read_config_word(pcidev
, PCI_COMMAND
, &pci_command
);
3440 new_command
= pci_command
| PCI_COMMAND_MASTER
3441 | PCI_COMMAND_MEMORY
3442 | PCI_COMMAND_INVALIDATE
3443 | PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
| PCI_COMMAND_FAST_BACK
;
3444 if (pci_command
!= new_command
)
3445 pci_write_config_word(pcidev
, PCI_COMMAND
, new_command
);
3448 static int slic_card_init(struct sliccard
*card
, struct adapter
*adapter
)
3450 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
3451 struct slic_eeprom
*peeprom
;
3452 struct oslic_eeprom
*pOeeprom
;
3453 dma_addr_t phys_config
;
3457 struct slic_shmem
*pshmem
;
3459 uint macaddrs
= card
->card_size
;
3464 struct slic_config_mac
*pmac
;
3465 unsigned char fruformat
;
3466 unsigned char oemfruformat
;
3467 struct atk_fru
*patkfru
;
3468 union oemfru
*poemfru
;
3470 /* Reset everything except PCI configuration space */
3471 slic_soft_reset(adapter
);
3473 /* Download the microcode */
3474 status
= slic_card_download(adapter
);
3477 dev_err(&adapter
->pcidev
->dev
,
3478 "download failed bus %d slot %d\n",
3479 adapter
->busnumber
, adapter
->slotnumber
);
3483 if (!card
->config_set
) {
3484 peeprom
= pci_alloc_consistent(adapter
->pcidev
,
3485 sizeof(struct slic_eeprom
),
3488 phys_configl
= SLIC_GET_ADDR_LOW(phys_config
);
3489 phys_configh
= SLIC_GET_ADDR_HIGH(phys_config
);
3492 dev_err(&adapter
->pcidev
->dev
,
3493 "eeprom read failed to get memory "
3494 "bus %d slot %d\n", adapter
->busnumber
,
3495 adapter
->slotnumber
);
3498 memset(peeprom
, 0, sizeof(struct slic_eeprom
));
3500 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
3502 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
3504 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
3505 adapter
->bit64reglock
.flags
);
3506 slic_reg32_write(&slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
3507 slic_reg32_write(&slic_regs
->slic_isp
,
3508 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
3509 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
3510 adapter
->bit64reglock
.flags
);
3512 slic_config_get(adapter
, phys_configl
, phys_configh
);
3515 if (adapter
->pshmem
->isr
) {
3516 if (adapter
->pshmem
->isr
& ISR_UPC
) {
3517 adapter
->pshmem
->isr
= 0;
3518 slic_reg64_write(adapter
,
3519 &slic_regs
->slic_isp
, 0,
3520 &slic_regs
->slic_addr_upper
,
3522 slic_reg32_write(&slic_regs
->slic_isr
,
3525 slic_upr_request_complete(adapter
, 0);
3528 adapter
->pshmem
->isr
= 0;
3529 slic_reg32_write(&slic_regs
->slic_isr
,
3536 dev_err(&adapter
->pcidev
->dev
,
3537 "%d config data fetch timed out!\n",
3539 slic_reg64_write(adapter
,
3540 &slic_regs
->slic_isp
, 0,
3541 &slic_regs
->slic_addr_upper
,
3548 switch (adapter
->devid
) {
3550 case SLIC_2GB_DEVICE_ID
:
3551 /* extract EEPROM data and pointers to EEPROM data */
3552 pOeeprom
= (struct oslic_eeprom
*) peeprom
;
3553 eecodesize
= pOeeprom
->EecodeSize
;
3554 dramsize
= pOeeprom
->DramSize
;
3555 pmac
= pOeeprom
->MacInfo
;
3556 fruformat
= pOeeprom
->FruFormat
;
3557 patkfru
= &pOeeprom
->AtkFru
;
3558 oemfruformat
= pOeeprom
->OemFruFormat
;
3559 poemfru
= &pOeeprom
->OemFru
;
3561 /* Minor kludge for Oasis card
3562 get 2 MAC addresses from the
3563 EEPROM to ensure that function 1
3564 gets the Port 1 MAC address */
3567 /* extract EEPROM data and pointers to EEPROM data */
3568 eecodesize
= peeprom
->EecodeSize
;
3569 dramsize
= peeprom
->DramSize
;
3570 pmac
= peeprom
->u2
.mac
.MacInfo
;
3571 fruformat
= peeprom
->FruFormat
;
3572 patkfru
= &peeprom
->AtkFru
;
3573 oemfruformat
= peeprom
->OemFruFormat
;
3574 poemfru
= &peeprom
->OemFru
;
3578 card
->config
.EepromValid
= false;
3580 /* see if the EEPROM is valid by checking it's checksum */
3581 if ((eecodesize
<= MAX_EECODE_SIZE
) &&
3582 (eecodesize
>= MIN_EECODE_SIZE
)) {
3585 *(u16
*) ((char *) peeprom
+ (eecodesize
- 2));
3587 calculate the EEPROM checksum
3590 ~slic_eeprom_cksum((char *) peeprom
,
3593 if the ucdoe chksum flag bit worked,
3594 we wouldn't need this shit
3596 if (ee_chksum
== calc_chksum
)
3597 card
->config
.EepromValid
= true;
3599 /* copy in the DRAM size */
3600 card
->config
.DramSize
= dramsize
;
3602 /* copy in the MAC address(es) */
3603 for (i
= 0; i
< macaddrs
; i
++) {
3604 memcpy(&card
->config
.MacInfo
[i
],
3605 &pmac
[i
], sizeof(struct slic_config_mac
));
3608 /* copy the Alacritech FRU information */
3609 card
->config
.FruFormat
= fruformat
;
3610 memcpy(&card
->config
.AtkFru
, patkfru
,
3611 sizeof(struct atk_fru
));
3613 pci_free_consistent(adapter
->pcidev
,
3614 sizeof(struct slic_eeprom
),
3615 peeprom
, phys_config
);
3617 if ((!card
->config
.EepromValid
) &&
3618 (adapter
->reg_params
.fail_on_bad_eeprom
)) {
3619 slic_reg64_write(adapter
, &slic_regs
->slic_isp
, 0,
3620 &slic_regs
->slic_addr_upper
,
3622 dev_err(&adapter
->pcidev
->dev
,
3623 "unsupported CONFIGURATION EEPROM invalid\n");
3627 card
->config_set
= 1;
3630 if (slic_card_download_gbrcv(adapter
)) {
3631 dev_err(&adapter
->pcidev
->dev
,
3632 "unable to download GB receive microcode\n");
3636 if (slic_global
.dynamic_intagg
)
3637 slic_intagg_set(adapter
, 0);
3639 slic_intagg_set(adapter
, intagg_delay
);
3642 * Initialize ping status to "ok"
3644 card
->pingstatus
= ISR_PINGMASK
;
3647 * Lastly, mark our card state as up and return success
3649 card
->state
= CARD_UP
;
3650 card
->reset_in_progress
= 0;
3655 static void slic_init_driver(void)
3657 if (slic_first_init
) {
3658 slic_first_init
= 0;
3659 spin_lock_init(&slic_global
.driver_lock
.lock
);
3664 static void slic_init_adapter(struct net_device
*netdev
,
3665 struct pci_dev
*pcidev
,
3666 const struct pci_device_id
*pci_tbl_entry
,
3667 void __iomem
*memaddr
, int chip_idx
)
3670 struct slic_handle
*pslic_handle
;
3671 struct adapter
*adapter
= netdev_priv(netdev
);
3673 /* adapter->pcidev = pcidev;*/
3674 adapter
->vendid
= pci_tbl_entry
->vendor
;
3675 adapter
->devid
= pci_tbl_entry
->device
;
3676 adapter
->subsysid
= pci_tbl_entry
->subdevice
;
3677 adapter
->busnumber
= pcidev
->bus
->number
;
3678 adapter
->slotnumber
= ((pcidev
->devfn
>> 3) & 0x1F);
3679 adapter
->functionnumber
= (pcidev
->devfn
& 0x7);
3680 adapter
->memorylength
= pci_resource_len(pcidev
, 0);
3681 adapter
->slic_regs
= (__iomem
struct slic_regs
*)memaddr
;
3682 adapter
->irq
= pcidev
->irq
;
3683 /* adapter->netdev = netdev;*/
3684 adapter
->next_netdevice
= head_netdevice
;
3685 head_netdevice
= netdev
;
3686 adapter
->chipid
= chip_idx
;
3687 adapter
->port
= 0; /*adapter->functionnumber;*/
3688 adapter
->cardindex
= adapter
->port
;
3689 adapter
->memorybase
= memaddr
;
3690 spin_lock_init(&adapter
->upr_lock
.lock
);
3691 spin_lock_init(&adapter
->bit64reglock
.lock
);
3692 spin_lock_init(&adapter
->adapter_lock
.lock
);
3693 spin_lock_init(&adapter
->reset_lock
.lock
);
3694 spin_lock_init(&adapter
->handle_lock
.lock
);
3696 adapter
->card_size
= 1;
3698 Initialize slic_handle array
3700 ASSERT(SLIC_CMDQ_MAXCMDS
<= 0xFFFF);
3702 Start with 1. 0 is an invalid host handle.
3704 for (index
= 1, pslic_handle
= &adapter
->slic_handles
[1];
3705 index
< SLIC_CMDQ_MAXCMDS
; index
++, pslic_handle
++) {
3707 pslic_handle
->token
.handle_index
= index
;
3708 pslic_handle
->type
= SLIC_HANDLE_FREE
;
3709 pslic_handle
->next
= adapter
->pfree_slic_handles
;
3710 adapter
->pfree_slic_handles
= pslic_handle
;
3712 adapter
->pshmem
= (struct slic_shmem
*)
3713 pci_alloc_consistent(adapter
->pcidev
,
3714 sizeof(struct slic_shmem
),
3717 ASSERT(adapter
->pshmem
);
3719 memset(adapter
->pshmem
, 0, sizeof(struct slic_shmem
));
3724 static const struct net_device_ops slic_netdev_ops
= {
3725 .ndo_open
= slic_entry_open
,
3726 .ndo_stop
= slic_entry_halt
,
3727 .ndo_start_xmit
= slic_xmit_start
,
3728 .ndo_do_ioctl
= slic_ioctl
,
3729 .ndo_set_mac_address
= slic_mac_set_address
,
3730 .ndo_get_stats
= slic_get_stats
,
3731 .ndo_set_multicast_list
= slic_mcast_set_list
,
3732 .ndo_validate_addr
= eth_validate_addr
,
3733 .ndo_change_mtu
= eth_change_mtu
,
3736 static u32
slic_card_locate(struct adapter
*adapter
)
3738 struct sliccard
*card
= slic_global
.slic_card
;
3739 struct physcard
*physcard
= slic_global
.phys_card
;
3741 u16 __iomem
*hostid_reg
;
3743 uint rdhostid_offset
= 0;
3745 switch (adapter
->devid
) {
3746 case SLIC_2GB_DEVICE_ID
:
3747 rdhostid_offset
= SLIC_RDHOSTID_2GB
;
3749 case SLIC_1GB_DEVICE_ID
:
3750 rdhostid_offset
= SLIC_RDHOSTID_1GB
;
3758 (u16 __iomem
*) (((u8 __iomem
*) (adapter
->slic_regs
)) +
3761 /* read the 16 bit hostid from SRAM */
3762 card_hostid
= (ushort
) readw(hostid_reg
);
3764 /* Initialize a new card structure if need be */
3765 if (card_hostid
== SLIC_HOSTID_DEFAULT
) {
3766 card
= kzalloc(sizeof(struct sliccard
), GFP_KERNEL
);
3770 card
->next
= slic_global
.slic_card
;
3771 slic_global
.slic_card
= card
;
3772 card
->busnumber
= adapter
->busnumber
;
3773 card
->slotnumber
= adapter
->slotnumber
;
3775 /* Find an available cardnum */
3776 for (i
= 0; i
< SLIC_MAX_CARDS
; i
++) {
3777 if (slic_global
.cardnuminuse
[i
] == 0) {
3778 slic_global
.cardnuminuse
[i
] = 1;
3783 slic_global
.num_slic_cards
++;
3785 slic_debug_card_create(card
);
3787 /* Card exists, find the card this adapter belongs to */
3789 if (card
->cardnum
== card_hostid
)
3798 /* Put the adapter in the card's adapter list */
3799 ASSERT(card
->adapter
[adapter
->port
] == NULL
);
3800 if (!card
->adapter
[adapter
->port
]) {
3801 card
->adapter
[adapter
->port
] = adapter
;
3802 adapter
->card
= card
;
3805 card
->card_size
= 1; /* one port per *logical* card */
3808 for (i
= 0; i
< SLIC_MAX_PORTS
; i
++) {
3809 if (!physcard
->adapter
[i
])
3814 ASSERT(i
!= SLIC_MAX_PORTS
);
3815 if (physcard
->adapter
[i
]->slotnumber
== adapter
->slotnumber
)
3817 physcard
= physcard
->next
;
3820 /* no structure allocated for this physical card yet */
3821 physcard
= kzalloc(sizeof(struct physcard
), GFP_ATOMIC
);
3824 physcard
->next
= slic_global
.phys_card
;
3825 slic_global
.phys_card
= physcard
;
3826 physcard
->adapters_allocd
= 1;
3828 physcard
->adapters_allocd
++;
3830 /* Note - this is ZERO relative */
3831 adapter
->physport
= physcard
->adapters_allocd
- 1;
3833 ASSERT(physcard
->adapter
[adapter
->physport
] == NULL
);
3834 physcard
->adapter
[adapter
->physport
] = adapter
;
3835 adapter
->physcard
= physcard
;
3840 static int __devinit
slic_entry_probe(struct pci_dev
*pcidev
,
3841 const struct pci_device_id
*pci_tbl_entry
)
3843 static int cards_found
;
3844 static int did_version
;
3846 struct net_device
*netdev
;
3847 struct adapter
*adapter
;
3848 void __iomem
*memmapped_ioaddr
= NULL
;
3850 ulong mmio_start
= 0;
3852 struct sliccard
*card
= NULL
;
3853 int pci_using_dac
= 0;
3855 slic_global
.dynamic_intagg
= dynamic_intagg
;
3857 err
= pci_enable_device(pcidev
);
3862 if (slic_debug
> 0 && did_version
++ == 0) {
3863 printk(KERN_DEBUG
"%s\n", slic_banner
);
3864 printk(KERN_DEBUG
"%s\n", slic_proc_version
);
3867 if (!pci_set_dma_mask(pcidev
, DMA_BIT_MASK(64))) {
3869 if (pci_set_consistent_dma_mask(pcidev
, DMA_BIT_MASK(64))) {
3870 dev_err(&pcidev
->dev
, "unable to obtain 64-bit DMA for "
3871 "consistent allocations\n");
3872 goto err_out_disable_pci
;
3874 } else if (pci_set_dma_mask(pcidev
, DMA_BIT_MASK(32))) {
3876 pci_set_consistent_dma_mask(pcidev
, DMA_BIT_MASK(32));
3878 dev_err(&pcidev
->dev
, "no usable DMA configuration\n");
3879 goto err_out_disable_pci
;
3882 err
= pci_request_regions(pcidev
, DRV_NAME
);
3884 dev_err(&pcidev
->dev
, "can't obtain PCI resources\n");
3885 goto err_out_disable_pci
;
3888 pci_set_master(pcidev
);
3890 netdev
= alloc_etherdev(sizeof(struct adapter
));
3893 goto err_out_exit_slic_probe
;
3896 SET_NETDEV_DEV(netdev
, &pcidev
->dev
);
3898 pci_set_drvdata(pcidev
, netdev
);
3899 adapter
= netdev_priv(netdev
);
3900 adapter
->netdev
= netdev
;
3901 adapter
->pcidev
= pcidev
;
3903 netdev
->features
|= NETIF_F_HIGHDMA
;
3905 mmio_start
= pci_resource_start(pcidev
, 0);
3906 mmio_len
= pci_resource_len(pcidev
, 0);
3909 /* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/
3910 memmapped_ioaddr
= ioremap(mmio_start
, mmio_len
);
3911 if (!memmapped_ioaddr
) {
3912 dev_err(&pcidev
->dev
, "cannot remap MMIO region %lx @ %lx\n",
3913 mmio_len
, mmio_start
);
3914 goto err_out_free_netdev
;
3917 slic_config_pci(pcidev
);
3921 slic_init_adapter(netdev
,
3922 pcidev
, pci_tbl_entry
, memmapped_ioaddr
, cards_found
);
3924 status
= slic_card_locate(adapter
);
3926 dev_err(&pcidev
->dev
, "cannot locate card\n");
3927 goto err_out_free_mmio_region
;
3930 card
= adapter
->card
;
3932 if (!adapter
->allocated
) {
3933 card
->adapters_allocated
++;
3934 adapter
->allocated
= 1;
3937 status
= slic_card_init(card
, adapter
);
3940 card
->state
= CARD_FAIL
;
3941 adapter
->state
= ADAPT_FAIL
;
3942 adapter
->linkstate
= LINK_DOWN
;
3943 dev_err(&pcidev
->dev
, "FAILED status[%x]\n", status
);
3945 slic_adapter_set_hwaddr(adapter
);
3948 netdev
->base_addr
= (unsigned long)adapter
->memorybase
;
3949 netdev
->irq
= adapter
->irq
;
3950 netdev
->netdev_ops
= &slic_netdev_ops
;
3952 slic_debug_adapter_create(adapter
);
3954 strcpy(netdev
->name
, "eth%d");
3955 err
= register_netdev(netdev
);
3957 dev_err(&pcidev
->dev
, "Cannot register net device, aborting.\n");
3966 iounmap(memmapped_ioaddr
);
3967 err_out_free_mmio_region
:
3968 release_mem_region(mmio_start
, mmio_len
);
3969 err_out_free_netdev
:
3970 free_netdev(netdev
);
3971 err_out_exit_slic_probe
:
3972 pci_release_regions(pcidev
);
3973 err_out_disable_pci
:
3974 pci_disable_device(pcidev
);
3978 static struct pci_driver slic_driver
= {
3980 .id_table
= slic_pci_tbl
,
3981 .probe
= slic_entry_probe
,
3982 .remove
= __devexit_p(slic_entry_remove
),
3985 static int __init
slic_module_init(void)
3989 if (debug
>= 0 && slic_debug
!= debug
)
3990 printk(KERN_DEBUG KBUILD_MODNAME
": debug level is %d.\n",
3995 return pci_register_driver(&slic_driver
);
3998 static void __exit
slic_module_cleanup(void)
4000 pci_unregister_driver(&slic_driver
);
4001 slic_debug_cleanup();
4004 module_init(slic_module_init
);
4005 module_exit(slic_module_cleanup
);