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 actually 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
65 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
67 #include <linux/kernel.h>
68 #include <linux/string.h>
69 #include <linux/errno.h>
70 #include <linux/ioport.h>
71 #include <linux/slab.h>
72 #include <linux/interrupt.h>
73 #include <linux/timer.h>
74 #include <linux/pci.h>
75 #include <linux/spinlock.h>
76 #include <linux/init.h>
77 #include <linux/bitops.h>
79 #include <linux/netdevice.h>
80 #include <linux/crc32.h>
81 #include <linux/etherdevice.h>
82 #include <linux/skbuff.h>
83 #include <linux/delay.h>
84 #include <linux/seq_file.h>
85 #include <linux/kthread.h>
86 #include <linux/module.h>
87 #include <linux/moduleparam.h>
89 #include <linux/firmware.h>
90 #include <linux/types.h>
91 #include <linux/dma-mapping.h>
92 #include <linux/mii.h>
93 #include <linux/if_vlan.h>
94 #include <asm/unaligned.h>
96 #include <linux/ethtool.h>
97 #include <linux/uaccess.h>
101 static uint slic_first_init
= 1;
102 static char *slic_banner
= "Alacritech SLIC Technology(tm) Server and Storage Accelerator (Non-Accelerated)";
104 static char *slic_proc_version
= "2.0.351 2006/07/14 12:26:00";
106 static struct base_driver slic_global
= { {}, 0, 0, 0, 1, NULL
, NULL
};
107 static int intagg_delay
= 100;
108 static u32 dynamic_intagg
;
109 static unsigned int rcv_count
;
111 #define DRV_NAME "slicoss"
112 #define DRV_VERSION "2.0.1"
113 #define DRV_AUTHOR "Alacritech, Inc. Engineering"
114 #define DRV_DESCRIPTION "Alacritech SLIC Techonology(tm) "\
115 "Non-Accelerated Driver"
116 #define DRV_COPYRIGHT "Copyright 2000-2006 Alacritech, Inc. "\
117 "All rights reserved."
118 #define PFX DRV_NAME " "
120 MODULE_AUTHOR(DRV_AUTHOR
);
121 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
122 MODULE_LICENSE("Dual BSD/GPL");
124 module_param(dynamic_intagg
, int, 0);
125 MODULE_PARM_DESC(dynamic_intagg
, "Dynamic Interrupt Aggregation Setting");
126 module_param(intagg_delay
, int, 0);
127 MODULE_PARM_DESC(intagg_delay
, "uSec Interrupt Aggregation Delay");
129 static const struct pci_device_id slic_pci_tbl
[] = {
130 { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH
, SLIC_1GB_DEVICE_ID
) },
131 { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH
, SLIC_2GB_DEVICE_ID
) },
135 MODULE_DEVICE_TABLE(pci
, slic_pci_tbl
);
137 static inline void slic_reg32_write(void __iomem
*reg
, u32 value
, bool flush
)
144 static inline void slic_reg64_write(struct adapter
*adapter
, void __iomem
*reg
,
145 u32 value
, void __iomem
*regh
, u32 paddrh
,
148 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
149 adapter
->bit64reglock
.flags
);
150 if (paddrh
!= adapter
->curaddrupper
) {
151 adapter
->curaddrupper
= paddrh
;
152 writel(paddrh
, regh
);
157 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
158 adapter
->bit64reglock
.flags
);
161 static void slic_mcast_set_bit(struct adapter
*adapter
, char *address
)
163 unsigned char crcpoly
;
165 /* Get the CRC polynomial for the mac address */
166 /* we use bits 1-8 (lsb), bitwise reversed,
167 * msb (= lsb bit 0 before bitrev) is automatically discarded */
168 crcpoly
= (ether_crc(ETH_ALEN
, address
)>>23);
170 /* We only have space on the SLIC for 64 entries. Lop
171 * off the top two bits. (2^6 = 64)
175 /* OR in the new bit into our 64 bit mask. */
176 adapter
->mcastmask
|= (u64
) 1 << crcpoly
;
179 static void slic_mcast_set_mask(struct adapter
*adapter
)
181 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
183 if (adapter
->macopts
& (MAC_ALLMCAST
| MAC_PROMISC
)) {
184 /* Turn on all multicast addresses. We have to do this for
185 * promiscuous mode as well as ALLMCAST mode. It saves the
186 * Microcode from having to keep state about the MAC
189 slic_reg32_write(&slic_regs
->slic_mcastlow
, 0xFFFFFFFF, FLUSH
);
190 slic_reg32_write(&slic_regs
->slic_mcasthigh
, 0xFFFFFFFF,
193 /* Commit our multicast mast to the SLIC by writing to the
194 * multicast address mask registers
196 slic_reg32_write(&slic_regs
->slic_mcastlow
,
197 (u32
)(adapter
->mcastmask
& 0xFFFFFFFF), FLUSH
);
198 slic_reg32_write(&slic_regs
->slic_mcasthigh
,
199 (u32
)((adapter
->mcastmask
>> 32) & 0xFFFFFFFF), FLUSH
);
203 static void slic_timer_ping(ulong dev
)
205 struct adapter
*adapter
;
206 struct sliccard
*card
;
208 adapter
= netdev_priv((struct net_device
*)dev
);
209 card
= adapter
->card
;
211 adapter
->pingtimer
.expires
= jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
212 add_timer(&adapter
->pingtimer
);
215 static void slic_unmap_mmio_space(struct adapter
*adapter
)
217 if (adapter
->slic_regs
)
218 iounmap(adapter
->slic_regs
);
219 adapter
->slic_regs
= NULL
;
225 * Write phy control to configure link duplex/speed
228 static void slic_link_config(struct adapter
*adapter
,
229 u32 linkspeed
, u32 linkduplex
)
238 if (adapter
->state
!= ADAPT_UP
)
241 if (linkspeed
> LINK_1000MB
)
242 linkspeed
= LINK_AUTOSPEED
;
243 if (linkduplex
> LINK_AUTOD
)
244 linkduplex
= LINK_AUTOD
;
246 wphy
= &adapter
->slic_regs
->slic_wphy
;
248 if ((linkspeed
== LINK_AUTOSPEED
) || (linkspeed
== LINK_1000MB
)) {
249 if (adapter
->flags
& ADAPT_FLAGS_FIBERMEDIA
) {
250 /* We've got a fiber gigabit interface, and register
251 * 4 is different in fiber mode than in copper mode
254 /* advertise FD only @1000 Mb */
255 phy_advreg
= (MIICR_REG_4
| (PAR_ADV1000XFD
));
256 /* enable PAUSE frames */
257 phy_advreg
|= PAR_ASYMPAUSE_FIBER
;
258 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
260 if (linkspeed
== LINK_AUTOSPEED
) {
261 /* reset phy, enable auto-neg */
264 (PCR_RESET
| PCR_AUTONEG
|
266 slic_reg32_write(wphy
, phy_config
, FLUSH
);
267 } else { /* forced 1000 Mb FD*/
268 /* power down phy to break link
269 this may not work) */
270 phy_config
= (MIICR_REG_PCR
| PCR_POWERDOWN
);
271 slic_reg32_write(wphy
, phy_config
, FLUSH
);
272 /* wait, Marvell says 1 sec,
273 try to get away with 10 ms */
276 /* disable auto-neg, set speed/duplex,
277 soft reset phy, powerup */
280 (PCR_RESET
| PCR_SPEED_1000
|
282 slic_reg32_write(wphy
, phy_config
, FLUSH
);
284 } else { /* copper gigabit */
286 /* Auto-Negotiate or 1000 Mb must be auto negotiated
287 * We've got a copper gigabit interface, and
288 * register 4 is different in copper mode than
291 if (linkspeed
== LINK_AUTOSPEED
) {
292 /* advertise 10/100 Mb modes */
295 (PAR_ADV100FD
| PAR_ADV100HD
| PAR_ADV10FD
298 /* linkspeed == LINK_1000MB -
299 don't advertise 10/100 Mb modes */
300 phy_advreg
= MIICR_REG_4
;
302 /* enable PAUSE frames */
303 phy_advreg
|= PAR_ASYMPAUSE
;
304 /* required by the Cicada PHY */
305 phy_advreg
|= PAR_802_3
;
306 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
307 /* advertise FD only @1000 Mb */
308 phy_gctlreg
= (MIICR_REG_9
| (PGC_ADV1000FD
));
309 slic_reg32_write(wphy
, phy_gctlreg
, FLUSH
);
311 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
313 enable auto crossover */
315 (MIICR_REG_16
| (MRV_REG16_XOVERON
));
316 slic_reg32_write(wphy
, phy_config
, FLUSH
);
318 /* reset phy, enable auto-neg */
321 (PCR_RESET
| PCR_AUTONEG
|
323 slic_reg32_write(wphy
, phy_config
, FLUSH
);
324 } else { /* it's a Cicada PHY */
325 /* enable and restart auto-neg (don't reset) */
328 (PCR_AUTONEG
| PCR_AUTONEG_RST
));
329 slic_reg32_write(wphy
, phy_config
, FLUSH
);
334 if (linkspeed
== LINK_10MB
)
337 speed
= PCR_SPEED_100
;
338 if (linkduplex
== LINK_HALFD
)
341 duplex
= PCR_DUPLEX_FULL
;
343 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
345 disable auto crossover */
346 phy_config
= (MIICR_REG_16
| (MRV_REG16_XOVEROFF
));
347 slic_reg32_write(wphy
, phy_config
, FLUSH
);
350 /* power down phy to break link (this may not work) */
351 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
| speed
| duplex
));
352 slic_reg32_write(wphy
, phy_config
, FLUSH
);
354 /* wait, Marvell says 1 sec, try to get away with 10 ms */
357 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
359 disable auto-neg, set speed,
360 soft reset phy, powerup */
362 (MIICR_REG_PCR
| (PCR_RESET
| speed
| duplex
));
363 slic_reg32_write(wphy
, phy_config
, FLUSH
);
364 } else { /* it's a Cicada PHY */
365 /* disable auto-neg, set speed, powerup */
366 phy_config
= (MIICR_REG_PCR
| (speed
| duplex
));
367 slic_reg32_write(wphy
, phy_config
, FLUSH
);
372 static int slic_card_download_gbrcv(struct adapter
*adapter
)
374 const struct firmware
*fw
;
375 const char *file
= "";
377 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
383 switch (adapter
->devid
) {
384 case SLIC_2GB_DEVICE_ID
:
385 file
= "slicoss/oasisrcvucode.sys";
387 case SLIC_1GB_DEVICE_ID
:
388 file
= "slicoss/gbrcvucode.sys";
394 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
396 dev_err(&adapter
->pcidev
->dev
,
397 "Failed to load firmware %s\n", file
);
401 rcvucodelen
= *(u32
*)(fw
->data
+ index
);
403 switch (adapter
->devid
) {
404 case SLIC_2GB_DEVICE_ID
:
405 if (rcvucodelen
!= OasisRcvUCodeLen
) {
406 release_firmware(fw
);
410 case SLIC_1GB_DEVICE_ID
:
411 if (rcvucodelen
!= GBRcvUCodeLen
) {
412 release_firmware(fw
);
418 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_BEGIN
, FLUSH
);
419 /* download the rcv sequencer ucode */
420 for (codeaddr
= 0; codeaddr
< rcvucodelen
; codeaddr
++) {
421 /* write out instruction address */
422 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, codeaddr
, FLUSH
);
424 instruction
= *(u32
*)(fw
->data
+ index
);
426 /* write out the instruction data low addr */
427 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, instruction
, FLUSH
);
429 instruction
= *(u8
*)(fw
->data
+ index
);
431 /* write out the instruction data high addr */
432 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, (u8
)instruction
,
436 /* download finished */
437 release_firmware(fw
);
438 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_FINISH
, FLUSH
);
442 MODULE_FIRMWARE("slicoss/oasisrcvucode.sys");
443 MODULE_FIRMWARE("slicoss/gbrcvucode.sys");
445 static int slic_card_download(struct adapter
*adapter
)
447 const struct firmware
*fw
;
448 const char *file
= "";
453 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
460 int ucode_start
, index
= 0;
462 switch (adapter
->devid
) {
463 case SLIC_2GB_DEVICE_ID
:
464 file
= "slicoss/oasisdownload.sys";
466 case SLIC_1GB_DEVICE_ID
:
467 file
= "slicoss/gbdownload.sys";
472 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
474 dev_err(&adapter
->pcidev
->dev
,
475 "Failed to load firmware %s\n", file
);
478 numsects
= *(u32
*)(fw
->data
+ index
);
480 for (i
= 0; i
< numsects
; i
++) {
481 sectsize
[i
] = *(u32
*)(fw
->data
+ index
);
484 for (i
= 0; i
< numsects
; i
++) {
485 sectstart
[i
] = *(u32
*)(fw
->data
+ index
);
489 instruction
= *(u32
*)(fw
->data
+ index
);
491 for (section
= 0; section
< numsects
; section
++) {
492 baseaddress
= sectstart
[section
];
493 thissectionsize
= sectsize
[section
] >> 3;
495 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
496 /* Write out instruction address */
497 slic_reg32_write(&slic_regs
->slic_wcs
,
498 baseaddress
+ codeaddr
, FLUSH
);
499 /* Write out instruction to low addr */
500 slic_reg32_write(&slic_regs
->slic_wcs
,
502 instruction
= *(u32
*)(fw
->data
+ index
);
505 /* Write out instruction to high addr */
506 slic_reg32_write(&slic_regs
->slic_wcs
,
508 instruction
= *(u32
*)(fw
->data
+ index
);
513 for (section
= 0; section
< numsects
; section
++) {
514 instruction
= *(u32
*)(fw
->data
+ index
);
515 baseaddress
= sectstart
[section
];
516 if (baseaddress
< 0x8000)
518 thissectionsize
= sectsize
[section
] >> 3;
520 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
521 /* Write out instruction address */
522 slic_reg32_write(&slic_regs
->slic_wcs
,
523 SLIC_WCS_COMPARE
| (baseaddress
+ codeaddr
),
525 /* Write out instruction to low addr */
526 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
528 instruction
= *(u32
*)(fw
->data
+ index
);
530 /* Write out instruction to high addr */
531 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
533 instruction
= *(u32
*)(fw
->data
+ index
);
536 /* Check SRAM location zero. If it is non-zero. Abort.*/
537 /* failure = readl((u32 __iomem *)&slic_regs->slic_reset);
539 release_firmware(fw);
544 release_firmware(fw
);
545 /* Everything OK, kick off the card */
547 slic_reg32_write(&slic_regs
->slic_wcs
, SLIC_WCS_START
, FLUSH
);
549 /* stall for 20 ms, long enough for ucode to init card
550 and reach mainloop */
556 MODULE_FIRMWARE("slicoss/oasisdownload.sys");
557 MODULE_FIRMWARE("slicoss/gbdownload.sys");
559 static void slic_adapter_set_hwaddr(struct adapter
*adapter
)
561 struct sliccard
*card
= adapter
->card
;
563 if ((adapter
->card
) && (card
->config_set
)) {
564 memcpy(adapter
->macaddr
,
565 card
->config
.MacInfo
[adapter
->functionnumber
].macaddrA
,
566 sizeof(struct slic_config_mac
));
567 if (is_zero_ether_addr(adapter
->currmacaddr
))
568 memcpy(adapter
->currmacaddr
, adapter
->macaddr
,
571 memcpy(adapter
->netdev
->dev_addr
, adapter
->currmacaddr
,
576 static void slic_intagg_set(struct adapter
*adapter
, u32 value
)
578 slic_reg32_write(&adapter
->slic_regs
->slic_intagg
, value
, FLUSH
);
579 adapter
->card
->loadlevel_current
= value
;
582 static void slic_soft_reset(struct adapter
*adapter
)
584 if (adapter
->card
->state
== CARD_UP
) {
585 slic_reg32_write(&adapter
->slic_regs
->slic_quiesce
, 0, FLUSH
);
589 slic_reg32_write(&adapter
->slic_regs
->slic_reset
, SLIC_RESET_MAGIC
,
594 static void slic_mac_address_config(struct adapter
*adapter
)
598 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
600 value
= ntohl(*(__be32
*) &adapter
->currmacaddr
[2]);
601 slic_reg32_write(&slic_regs
->slic_wraddral
, value
, FLUSH
);
602 slic_reg32_write(&slic_regs
->slic_wraddrbl
, value
, FLUSH
);
604 value2
= (u32
) ((adapter
->currmacaddr
[0] << 8 |
605 adapter
->currmacaddr
[1]) & 0xFFFF);
607 slic_reg32_write(&slic_regs
->slic_wraddrah
, value2
, FLUSH
);
608 slic_reg32_write(&slic_regs
->slic_wraddrbh
, value2
, FLUSH
);
610 /* Write our multicast mask out to the card. This is done */
611 /* here in addition to the slic_mcast_addr_set routine */
612 /* because ALL_MCAST may have been enabled or disabled */
613 slic_mcast_set_mask(adapter
);
616 static void slic_mac_config(struct adapter
*adapter
)
619 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
621 /* Setup GMAC gaps */
622 if (adapter
->linkspeed
== LINK_1000MB
) {
623 value
= ((GMCR_GAPBB_1000
<< GMCR_GAPBB_SHIFT
) |
624 (GMCR_GAPR1_1000
<< GMCR_GAPR1_SHIFT
) |
625 (GMCR_GAPR2_1000
<< GMCR_GAPR2_SHIFT
));
627 value
= ((GMCR_GAPBB_100
<< GMCR_GAPBB_SHIFT
) |
628 (GMCR_GAPR1_100
<< GMCR_GAPR1_SHIFT
) |
629 (GMCR_GAPR2_100
<< GMCR_GAPR2_SHIFT
));
633 if (adapter
->linkspeed
== LINK_1000MB
)
636 /* enable fullduplex */
637 if ((adapter
->linkduplex
== LINK_FULLD
)
638 || (adapter
->macopts
& MAC_LOOPBACK
)) {
642 /* write mac config */
643 slic_reg32_write(&slic_regs
->slic_wmcfg
, value
, FLUSH
);
645 /* setup mac addresses */
646 slic_mac_address_config(adapter
);
649 static void slic_config_set(struct adapter
*adapter
, bool linkchange
)
653 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
657 slic_mac_config(adapter
);
658 RcrReset
= GRCR_RESET
;
660 slic_mac_address_config(adapter
);
664 if (adapter
->linkduplex
== LINK_FULLD
) {
666 value
= (GXCR_RESET
| /* Always reset */
667 GXCR_XMTEN
| /* Enable transmit */
668 GXCR_PAUSEEN
); /* Enable pause */
670 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
672 /* Setup rcvcfg last */
673 value
= (RcrReset
| /* Reset, if linkchange */
674 GRCR_CTLEN
| /* Enable CTL frames */
675 GRCR_ADDRAEN
| /* Address A enable */
676 GRCR_RCVBAD
| /* Rcv bad frames */
677 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
680 value
= (GXCR_RESET
| /* Always reset */
681 GXCR_XMTEN
); /* Enable transmit */
683 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
685 /* Setup rcvcfg last */
686 value
= (RcrReset
| /* Reset, if linkchange */
687 GRCR_ADDRAEN
| /* Address A enable */
688 GRCR_RCVBAD
| /* Rcv bad frames */
689 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
692 if (adapter
->state
!= ADAPT_DOWN
) {
693 /* Only enable receive if we are restarting or running */
697 if (adapter
->macopts
& MAC_PROMISC
)
698 value
|= GRCR_RCVALL
;
700 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
704 * Turn off RCV and XMT, power down PHY
706 static void slic_config_clear(struct adapter
*adapter
)
710 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
713 value
= (GXCR_RESET
| /* Always reset */
714 GXCR_PAUSEEN
); /* Enable pause */
716 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
718 value
= (GRCR_RESET
| /* Always reset */
719 GRCR_CTLEN
| /* Enable CTL frames */
720 GRCR_ADDRAEN
| /* Address A enable */
721 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
723 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
726 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
));
727 slic_reg32_write(&slic_regs
->slic_wphy
, phy_config
, FLUSH
);
730 static bool slic_mac_filter(struct adapter
*adapter
,
731 struct ether_header
*ether_frame
)
733 struct net_device
*netdev
= adapter
->netdev
;
734 u32 opts
= adapter
->macopts
;
736 if (opts
& MAC_PROMISC
)
739 if (is_broadcast_ether_addr(ether_frame
->ether_dhost
)) {
740 if (opts
& MAC_BCAST
) {
741 adapter
->rcv_broadcasts
++;
748 if (is_multicast_ether_addr(ether_frame
->ether_dhost
)) {
749 if (opts
& MAC_ALLMCAST
) {
750 adapter
->rcv_multicasts
++;
751 netdev
->stats
.multicast
++;
754 if (opts
& MAC_MCAST
) {
755 struct mcast_address
*mcaddr
= adapter
->mcastaddrs
;
758 if (ether_addr_equal(mcaddr
->address
,
759 ether_frame
->ether_dhost
)) {
760 adapter
->rcv_multicasts
++;
761 netdev
->stats
.multicast
++;
764 mcaddr
= mcaddr
->next
;
772 if (opts
& MAC_DIRECTED
) {
773 adapter
->rcv_unicasts
++;
780 static int slic_mac_set_address(struct net_device
*dev
, void *ptr
)
782 struct adapter
*adapter
= netdev_priv(dev
);
783 struct sockaddr
*addr
= ptr
;
785 if (netif_running(dev
))
790 if (!is_valid_ether_addr(addr
->sa_data
))
793 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
794 memcpy(adapter
->currmacaddr
, addr
->sa_data
, dev
->addr_len
);
796 slic_config_set(adapter
, true);
800 static void slic_timer_load_check(ulong cardaddr
)
802 struct sliccard
*card
= (struct sliccard
*)cardaddr
;
803 struct adapter
*adapter
= card
->master
;
805 u32 load
= card
->events
;
808 if ((adapter
) && (adapter
->state
== ADAPT_UP
) &&
809 (card
->state
== CARD_UP
) && (slic_global
.dynamic_intagg
)) {
810 intagg
= &adapter
->slic_regs
->slic_intagg
;
811 if (adapter
->devid
== SLIC_1GB_DEVICE_ID
) {
812 if (adapter
->linkspeed
== LINK_1000MB
)
815 if (load
> SLIC_LOAD_5
)
816 level
= SLIC_INTAGG_5
;
817 else if (load
> SLIC_LOAD_4
)
818 level
= SLIC_INTAGG_4
;
819 else if (load
> SLIC_LOAD_3
)
820 level
= SLIC_INTAGG_3
;
821 else if (load
> SLIC_LOAD_2
)
822 level
= SLIC_INTAGG_2
;
823 else if (load
> SLIC_LOAD_1
)
824 level
= SLIC_INTAGG_1
;
826 level
= SLIC_INTAGG_0
;
828 if (card
->loadlevel_current
!= level
) {
829 card
->loadlevel_current
= level
;
830 slic_reg32_write(intagg
, level
, FLUSH
);
833 if (load
> SLIC_LOAD_5
)
834 level
= SLIC_INTAGG_5
;
835 else if (load
> SLIC_LOAD_4
)
836 level
= SLIC_INTAGG_4
;
837 else if (load
> SLIC_LOAD_3
)
838 level
= SLIC_INTAGG_3
;
839 else if (load
> SLIC_LOAD_2
)
840 level
= SLIC_INTAGG_2
;
841 else if (load
> SLIC_LOAD_1
)
842 level
= SLIC_INTAGG_1
;
844 level
= SLIC_INTAGG_0
;
845 if (card
->loadlevel_current
!= level
) {
846 card
->loadlevel_current
= level
;
847 slic_reg32_write(intagg
, level
, FLUSH
);
852 card
->loadtimer
.expires
= jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
853 add_timer(&card
->loadtimer
);
856 static int slic_upr_queue_request(struct adapter
*adapter
,
860 u32 upr_buffer
, u32 upr_buffer_h
)
862 struct slic_upr
*upr
;
863 struct slic_upr
*uprqueue
;
865 upr
= kmalloc(sizeof(struct slic_upr
), GFP_ATOMIC
);
869 upr
->adapter
= adapter
->port
;
870 upr
->upr_request
= upr_request
;
871 upr
->upr_data
= upr_data
;
872 upr
->upr_buffer
= upr_buffer
;
873 upr
->upr_data_h
= upr_data_h
;
874 upr
->upr_buffer_h
= upr_buffer_h
;
876 if (adapter
->upr_list
) {
877 uprqueue
= adapter
->upr_list
;
879 while (uprqueue
->next
)
880 uprqueue
= uprqueue
->next
;
881 uprqueue
->next
= upr
;
883 adapter
->upr_list
= upr
;
888 static void slic_upr_start(struct adapter
*adapter
)
890 struct slic_upr
*upr
;
891 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
897 upr
= adapter
->upr_list
;
900 if (adapter
->upr_busy
)
902 adapter
->upr_busy
= 1;
904 switch (upr
->upr_request
) {
906 if (upr
->upr_data_h
== 0) {
907 slic_reg32_write(&slic_regs
->slic_stats
, upr
->upr_data
,
910 slic_reg64_write(adapter
, &slic_regs
->slic_stats64
,
912 &slic_regs
->slic_addr_upper
,
913 upr
->upr_data_h
, FLUSH
);
918 slic_reg64_write(adapter
, &slic_regs
->slic_rlsr
, upr
->upr_data
,
919 &slic_regs
->slic_addr_upper
, upr
->upr_data_h
,
923 case SLIC_UPR_RCONFIG
:
924 slic_reg64_write(adapter
, &slic_regs
->slic_rconfig
,
925 upr
->upr_data
, &slic_regs
->slic_addr_upper
,
926 upr
->upr_data_h
, FLUSH
);
929 slic_reg32_write(&slic_regs
->slic_ping
, 1, FLUSH
);
934 static int slic_upr_request(struct adapter
*adapter
,
938 u32 upr_buffer
, u32 upr_buffer_h
)
942 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
943 rc
= slic_upr_queue_request(adapter
,
946 upr_data_h
, upr_buffer
, upr_buffer_h
);
950 slic_upr_start(adapter
);
952 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
953 adapter
->upr_lock
.flags
);
957 static void slic_link_upr_complete(struct adapter
*adapter
, u32 isr
)
959 u32 linkstatus
= adapter
->pshmem
->linkstatus
;
961 unsigned char linkspeed
;
962 unsigned char linkduplex
;
964 if ((isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
965 struct slic_shmem
*pshmem
;
967 pshmem
= (struct slic_shmem
*)(unsigned long)
969 #if BITS_PER_LONG == 64
970 slic_upr_queue_request(adapter
,
972 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
973 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
976 slic_upr_queue_request(adapter
,
978 (u32
) &pshmem
->linkstatus
,
979 SLIC_GET_ADDR_HIGH(pshmem
), 0, 0);
983 if (adapter
->state
!= ADAPT_UP
)
986 linkup
= linkstatus
& GIG_LINKUP
? LINK_UP
: LINK_DOWN
;
987 if (linkstatus
& GIG_SPEED_1000
)
988 linkspeed
= LINK_1000MB
;
989 else if (linkstatus
& GIG_SPEED_100
)
990 linkspeed
= LINK_100MB
;
992 linkspeed
= LINK_10MB
;
994 if (linkstatus
& GIG_FULLDUPLEX
)
995 linkduplex
= LINK_FULLD
;
997 linkduplex
= LINK_HALFD
;
999 if ((adapter
->linkstate
== LINK_DOWN
) && (linkup
== LINK_DOWN
))
1002 /* link up event, but nothing has changed */
1003 if ((adapter
->linkstate
== LINK_UP
) &&
1004 (linkup
== LINK_UP
) &&
1005 (adapter
->linkspeed
== linkspeed
) &&
1006 (adapter
->linkduplex
== linkduplex
))
1009 /* link has changed at this point */
1011 /* link has gone from up to down */
1012 if (linkup
== LINK_DOWN
) {
1013 adapter
->linkstate
= LINK_DOWN
;
1017 /* link has gone from down to up */
1018 adapter
->linkspeed
= linkspeed
;
1019 adapter
->linkduplex
= linkduplex
;
1021 if (adapter
->linkstate
!= LINK_UP
) {
1023 slic_config_set(adapter
, true);
1024 adapter
->linkstate
= LINK_UP
;
1025 netif_start_queue(adapter
->netdev
);
1029 static void slic_upr_request_complete(struct adapter
*adapter
, u32 isr
)
1031 struct sliccard
*card
= adapter
->card
;
1032 struct slic_upr
*upr
;
1034 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
1035 upr
= adapter
->upr_list
;
1037 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
1038 adapter
->upr_lock
.flags
);
1041 adapter
->upr_list
= upr
->next
;
1043 adapter
->upr_busy
= 0;
1044 switch (upr
->upr_request
) {
1045 case SLIC_UPR_STATS
:
1047 struct slic_stats
*slicstats
=
1048 (struct slic_stats
*) &adapter
->pshmem
->inicstats
;
1049 struct slic_stats
*newstats
= slicstats
;
1050 struct slic_stats
*old
= &adapter
->inicstats_prev
;
1051 struct slicnet_stats
*stst
= &adapter
->slic_stats
;
1053 if (isr
& ISR_UPCERR
) {
1054 dev_err(&adapter
->netdev
->dev
,
1055 "SLIC_UPR_STATS command failed isr[%x]\n",
1060 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_segs
,
1061 newstats
->xmit_tcp_segs_gb
,
1062 old
->xmit_tcp_segs_gb
);
1064 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_bytes
,
1065 newstats
->xmit_tcp_bytes_gb
,
1066 old
->xmit_tcp_bytes_gb
);
1068 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_segs
,
1069 newstats
->rcv_tcp_segs_gb
,
1070 old
->rcv_tcp_segs_gb
);
1072 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_bytes
,
1073 newstats
->rcv_tcp_bytes_gb
,
1074 old
->rcv_tcp_bytes_gb
);
1076 UPDATE_STATS_GB(stst
->iface
.xmt_bytes
,
1077 newstats
->xmit_bytes_gb
,
1078 old
->xmit_bytes_gb
);
1080 UPDATE_STATS_GB(stst
->iface
.xmt_ucast
,
1081 newstats
->xmit_unicasts_gb
,
1082 old
->xmit_unicasts_gb
);
1084 UPDATE_STATS_GB(stst
->iface
.rcv_bytes
,
1085 newstats
->rcv_bytes_gb
,
1088 UPDATE_STATS_GB(stst
->iface
.rcv_ucast
,
1089 newstats
->rcv_unicasts_gb
,
1090 old
->rcv_unicasts_gb
);
1092 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1093 newstats
->xmit_collisions_gb
,
1094 old
->xmit_collisions_gb
);
1096 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1097 newstats
->xmit_excess_collisions_gb
,
1098 old
->xmit_excess_collisions_gb
);
1100 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
1101 newstats
->xmit_other_error_gb
,
1102 old
->xmit_other_error_gb
);
1104 UPDATE_STATS_GB(stst
->iface
.rcv_errors
,
1105 newstats
->rcv_other_error_gb
,
1106 old
->rcv_other_error_gb
);
1108 UPDATE_STATS_GB(stst
->iface
.rcv_discards
,
1109 newstats
->rcv_drops_gb
,
1112 if (newstats
->rcv_drops_gb
> old
->rcv_drops_gb
) {
1113 adapter
->rcv_drops
+=
1114 (newstats
->rcv_drops_gb
-
1117 memcpy(old
, newstats
, sizeof(struct slic_stats
));
1121 slic_link_upr_complete(adapter
, isr
);
1123 case SLIC_UPR_RCONFIG
:
1126 card
->pingstatus
|= (isr
& ISR_PINGDSMASK
);
1130 slic_upr_start(adapter
);
1131 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
1132 adapter
->upr_lock
.flags
);
1135 static int slic_config_get(struct adapter
*adapter
, u32 config
, u32 config_h
)
1137 return slic_upr_request(adapter
, SLIC_UPR_RCONFIG
, config
, config_h
,
1142 * Compute a checksum of the EEPROM according to RFC 1071.
1144 static u16
slic_eeprom_cksum(void *eeprom
, unsigned len
)
1150 checksum
+= *(wp
++);
1155 checksum
+= *(u8
*) wp
;
1158 while (checksum
>> 16)
1159 checksum
= (checksum
& 0xFFFF) + ((checksum
>> 16) & 0xFFFF);
1164 static void slic_rspqueue_free(struct adapter
*adapter
)
1167 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1169 for (i
= 0; i
< rspq
->num_pages
; i
++) {
1170 if (rspq
->vaddr
[i
]) {
1171 pci_free_consistent(adapter
->pcidev
, PAGE_SIZE
,
1172 rspq
->vaddr
[i
], rspq
->paddr
[i
]);
1174 rspq
->vaddr
[i
] = NULL
;
1178 rspq
->pageindex
= 0;
1179 rspq
->rspbuf
= NULL
;
1182 static int slic_rspqueue_init(struct adapter
*adapter
)
1185 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1186 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1189 memset(rspq
, 0, sizeof(struct slic_rspqueue
));
1191 rspq
->num_pages
= SLIC_RSPQ_PAGES_GB
;
1193 for (i
= 0; i
< rspq
->num_pages
; i
++) {
1194 rspq
->vaddr
[i
] = pci_zalloc_consistent(adapter
->pcidev
,
1197 if (!rspq
->vaddr
[i
]) {
1198 dev_err(&adapter
->pcidev
->dev
,
1199 "pci_alloc_consistent failed\n");
1200 slic_rspqueue_free(adapter
);
1205 slic_reg32_write(&slic_regs
->slic_rbar
,
1206 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
1209 slic_reg64_write(adapter
, &slic_regs
->slic_rbar64
,
1210 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
1211 &slic_regs
->slic_addr_upper
,
1212 paddrh
, DONT_FLUSH
);
1216 rspq
->pageindex
= 0;
1217 rspq
->rspbuf
= (struct slic_rspbuf
*)rspq
->vaddr
[0];
1221 static struct slic_rspbuf
*slic_rspqueue_getnext(struct adapter
*adapter
)
1223 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
1224 struct slic_rspbuf
*buf
;
1226 if (!(rspq
->rspbuf
->status
))
1230 if (++rspq
->offset
< SLIC_RSPQ_BUFSINPAGE
) {
1233 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_rbar64
,
1234 (rspq
->paddr
[rspq
->pageindex
] | SLIC_RSPQ_BUFSINPAGE
),
1235 &adapter
->slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
1236 rspq
->pageindex
= (rspq
->pageindex
+ 1) % rspq
->num_pages
;
1238 rspq
->rspbuf
= (struct slic_rspbuf
*)
1239 rspq
->vaddr
[rspq
->pageindex
];
1245 static void slic_cmdqmem_free(struct adapter
*adapter
)
1247 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
1250 for (i
= 0; i
< SLIC_CMDQ_MAXPAGES
; i
++) {
1251 if (cmdqmem
->pages
[i
]) {
1252 pci_free_consistent(adapter
->pcidev
,
1254 (void *) cmdqmem
->pages
[i
],
1255 cmdqmem
->dma_pages
[i
]);
1258 memset(cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
1261 static u32
*slic_cmdqmem_addpage(struct adapter
*adapter
)
1263 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
1266 if (cmdqmem
->pagecnt
>= SLIC_CMDQ_MAXPAGES
)
1268 pageaddr
= pci_alloc_consistent(adapter
->pcidev
,
1270 &cmdqmem
->dma_pages
[cmdqmem
->pagecnt
]);
1274 cmdqmem
->pages
[cmdqmem
->pagecnt
] = pageaddr
;
1279 static void slic_cmdq_free(struct adapter
*adapter
)
1281 struct slic_hostcmd
*cmd
;
1283 cmd
= adapter
->cmdq_all
.head
;
1286 struct sk_buff
*tempskb
;
1291 dev_kfree_skb_irq(tempskb
);
1294 cmd
= cmd
->next_all
;
1296 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
1297 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
1298 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
1299 slic_cmdqmem_free(adapter
);
1302 static void slic_cmdq_addcmdpage(struct adapter
*adapter
, u32
*page
)
1304 struct slic_hostcmd
*cmd
;
1305 struct slic_hostcmd
*prev
;
1306 struct slic_hostcmd
*tail
;
1307 struct slic_cmdqueue
*cmdq
;
1313 struct slic_handle
*pslic_handle
;
1316 cmd
= (struct slic_hostcmd
*)cmdaddr
;
1319 phys_addr
= virt_to_bus((void *)page
);
1320 phys_addrl
= SLIC_GET_ADDR_LOW(phys_addr
);
1321 phys_addrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
1325 while ((cmdcnt
< SLIC_CMDQ_CMDSINPAGE
) &&
1326 (adapter
->slic_handle_ix
< 256)) {
1327 /* Allocate and initialize a SLIC_HANDLE for this command */
1328 spin_lock_irqsave(&adapter
->handle_lock
.lock
,
1329 adapter
->handle_lock
.flags
);
1330 pslic_handle
= adapter
->pfree_slic_handles
;
1331 adapter
->pfree_slic_handles
= pslic_handle
->next
;
1332 spin_unlock_irqrestore(&adapter
->handle_lock
.lock
,
1333 adapter
->handle_lock
.flags
);
1334 pslic_handle
->type
= SLIC_HANDLE_CMD
;
1335 pslic_handle
->address
= (void *) cmd
;
1336 pslic_handle
->offset
= (ushort
) adapter
->slic_handle_ix
++;
1337 pslic_handle
->other_handle
= NULL
;
1338 pslic_handle
->next
= NULL
;
1340 cmd
->pslic_handle
= pslic_handle
;
1341 cmd
->cmd64
.hosthandle
= pslic_handle
->token
.handle_token
;
1343 cmd
->paddrl
= phys_addrl
;
1344 cmd
->paddrh
= phys_addrh
;
1345 cmd
->next_all
= prev
;
1348 phys_addrl
+= SLIC_HOSTCMD_SIZE
;
1349 cmdaddr
+= SLIC_HOSTCMD_SIZE
;
1351 cmd
= (struct slic_hostcmd
*)cmdaddr
;
1355 cmdq
= &adapter
->cmdq_all
;
1356 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
1357 tail
->next_all
= cmdq
->head
;
1359 cmdq
= &adapter
->cmdq_free
;
1360 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1361 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
1362 tail
->next
= cmdq
->head
;
1364 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1367 static int slic_cmdq_init(struct adapter
*adapter
)
1372 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
1373 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
1374 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
1375 spin_lock_init(&adapter
->cmdq_all
.lock
.lock
);
1376 spin_lock_init(&adapter
->cmdq_free
.lock
.lock
);
1377 spin_lock_init(&adapter
->cmdq_done
.lock
.lock
);
1378 memset(&adapter
->cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
1379 adapter
->slic_handle_ix
= 1;
1380 for (i
= 0; i
< SLIC_CMDQ_INITPAGES
; i
++) {
1381 pageaddr
= slic_cmdqmem_addpage(adapter
);
1383 slic_cmdq_free(adapter
);
1386 slic_cmdq_addcmdpage(adapter
, pageaddr
);
1388 adapter
->slic_handle_ix
= 1;
1393 static void slic_cmdq_reset(struct adapter
*adapter
)
1395 struct slic_hostcmd
*hcmd
;
1396 struct sk_buff
*skb
;
1399 spin_lock_irqsave(&adapter
->cmdq_free
.lock
.lock
,
1400 adapter
->cmdq_free
.lock
.flags
);
1401 spin_lock_irqsave(&adapter
->cmdq_done
.lock
.lock
,
1402 adapter
->cmdq_done
.lock
.flags
);
1403 outstanding
= adapter
->cmdq_all
.count
- adapter
->cmdq_done
.count
;
1404 outstanding
-= adapter
->cmdq_free
.count
;
1405 hcmd
= adapter
->cmdq_all
.head
;
1411 dev_kfree_skb_irq(skb
);
1413 hcmd
= hcmd
->next_all
;
1415 adapter
->cmdq_free
.count
= 0;
1416 adapter
->cmdq_free
.head
= NULL
;
1417 adapter
->cmdq_free
.tail
= NULL
;
1418 adapter
->cmdq_done
.count
= 0;
1419 adapter
->cmdq_done
.head
= NULL
;
1420 adapter
->cmdq_done
.tail
= NULL
;
1421 adapter
->cmdq_free
.head
= adapter
->cmdq_all
.head
;
1422 hcmd
= adapter
->cmdq_all
.head
;
1424 adapter
->cmdq_free
.count
++;
1425 hcmd
->next
= hcmd
->next_all
;
1426 hcmd
= hcmd
->next_all
;
1428 if (adapter
->cmdq_free
.count
!= adapter
->cmdq_all
.count
) {
1429 dev_err(&adapter
->netdev
->dev
,
1430 "free_count %d != all count %d\n",
1431 adapter
->cmdq_free
.count
, adapter
->cmdq_all
.count
);
1433 spin_unlock_irqrestore(&adapter
->cmdq_done
.lock
.lock
,
1434 adapter
->cmdq_done
.lock
.flags
);
1435 spin_unlock_irqrestore(&adapter
->cmdq_free
.lock
.lock
,
1436 adapter
->cmdq_free
.lock
.flags
);
1439 static void slic_cmdq_getdone(struct adapter
*adapter
)
1441 struct slic_cmdqueue
*done_cmdq
= &adapter
->cmdq_done
;
1442 struct slic_cmdqueue
*free_cmdq
= &adapter
->cmdq_free
;
1444 spin_lock_irqsave(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
1446 free_cmdq
->head
= done_cmdq
->head
;
1447 free_cmdq
->count
= done_cmdq
->count
;
1448 done_cmdq
->head
= NULL
;
1449 done_cmdq
->tail
= NULL
;
1450 done_cmdq
->count
= 0;
1451 spin_unlock_irqrestore(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
1454 static struct slic_hostcmd
*slic_cmdq_getfree(struct adapter
*adapter
)
1456 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_free
;
1457 struct slic_hostcmd
*cmd
= NULL
;
1460 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1464 cmdq
->head
= cmd
->next
;
1466 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
1468 slic_cmdq_getdone(adapter
);
1475 spin_unlock_irqrestore(&cmdq
->lock
.lock
,
1477 pageaddr
= slic_cmdqmem_addpage(adapter
);
1479 slic_cmdq_addcmdpage(adapter
, pageaddr
);
1480 goto lock_and_retry
;
1487 static void slic_cmdq_putdone_irq(struct adapter
*adapter
,
1488 struct slic_hostcmd
*cmd
)
1490 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_done
;
1492 spin_lock(&cmdq
->lock
.lock
);
1494 cmd
->next
= cmdq
->head
;
1497 if ((adapter
->xmitq_full
) && (cmdq
->count
> 10))
1498 netif_wake_queue(adapter
->netdev
);
1499 spin_unlock(&cmdq
->lock
.lock
);
1502 static int slic_rcvqueue_fill(struct adapter
*adapter
)
1507 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1509 struct device
*dev
= &adapter
->netdev
->dev
;
1511 while (i
< SLIC_RCVQ_FILLENTRIES
) {
1512 struct slic_rcvbuf
*rcvbuf
;
1513 struct sk_buff
*skb
;
1514 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1517 skb
= alloc_skb(SLIC_RCVQ_RCVBUFSIZE
, GFP_ATOMIC
);
1519 paddr
= (void *)(unsigned long)
1520 pci_map_single(adapter
->pcidev
,
1522 SLIC_RCVQ_RCVBUFSIZE
,
1523 PCI_DMA_FROMDEVICE
);
1524 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
1525 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
1527 skb
->len
= SLIC_RCVBUF_HEADSIZE
;
1528 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1531 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1533 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1535 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1536 dev_err(dev
, " skbdata[%p]\n",
1538 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1539 dev_err(dev
, " paddr[%p]\n", paddr
);
1540 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1541 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1542 dev_err(dev
, " rcvq->head[%p]\n",
1544 dev_err(dev
, " rcvq->tail[%p]\n",
1546 dev_err(dev
, " rcvq->count[%x]\n",
1548 dev_err(dev
, "SKIP THIS SKB!!!!!!!!\n");
1549 goto retry_rcvqfill
;
1553 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1555 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1556 dev_err(dev
, " skbdata[%p]\n",
1558 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1559 dev_err(dev
, " paddr[%p]\n", paddr
);
1560 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1561 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1562 dev_err(dev
, " rcvq->head[%p]\n",
1564 dev_err(dev
, " rcvq->tail[%p]\n",
1566 dev_err(dev
, " rcvq->count[%x]\n",
1568 dev_err(dev
, "GIVE TO CARD ANYWAY\n");
1572 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
,
1573 (u32
)paddrl
, DONT_FLUSH
);
1575 slic_reg64_write(adapter
,
1576 &adapter
->slic_regs
->slic_hbar64
,
1578 &adapter
->slic_regs
->slic_addr_upper
,
1579 paddrh
, DONT_FLUSH
);
1582 rcvq
->tail
->next
= skb
;
1589 dev_err(&adapter
->netdev
->dev
,
1590 "slic_rcvqueue_fill could only get [%d] skbuffs\n",
1598 static void slic_rcvqueue_free(struct adapter
*adapter
)
1600 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1601 struct sk_buff
*skb
;
1603 while (rcvq
->head
) {
1605 rcvq
->head
= rcvq
->head
->next
;
1613 static int slic_rcvqueue_init(struct adapter
*adapter
)
1616 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1620 rcvq
->size
= SLIC_RCVQ_ENTRIES
;
1623 i
= SLIC_RCVQ_ENTRIES
/ SLIC_RCVQ_FILLENTRIES
;
1626 count
+= slic_rcvqueue_fill(adapter
);
1629 if (rcvq
->count
< SLIC_RCVQ_MINENTRIES
) {
1630 slic_rcvqueue_free(adapter
);
1636 static struct sk_buff
*slic_rcvqueue_getnext(struct adapter
*adapter
)
1638 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1639 struct sk_buff
*skb
;
1640 struct slic_rcvbuf
*rcvbuf
;
1645 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1647 if (rcvbuf
->status
& IRHDDR_SVALID
) {
1648 rcvq
->head
= rcvq
->head
->next
;
1655 dev_err(&adapter
->netdev
->dev
,
1656 "RcvQ Empty!! rcvq[%p] count[%x]\n", rcvq
, rcvq
->count
);
1659 while (rcvq
->count
< SLIC_RCVQ_FILLTHRESH
) {
1660 count
= slic_rcvqueue_fill(adapter
);
1669 static u32
slic_rcvqueue_reinsert(struct adapter
*adapter
, struct sk_buff
*skb
)
1671 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
1675 struct slic_rcvbuf
*rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
1678 paddr
= (void *)(unsigned long)
1679 pci_map_single(adapter
->pcidev
, skb
->head
,
1680 SLIC_RCVQ_RCVBUFSIZE
, PCI_DMA_FROMDEVICE
);
1684 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
1685 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
1688 dev
= &adapter
->netdev
->dev
;
1689 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1691 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
1692 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
1693 dev_err(dev
, " skblen[%x]\n", skb
->len
);
1694 dev_err(dev
, " paddr[%p]\n", paddr
);
1695 dev_err(dev
, " paddrl[%x]\n", paddrl
);
1696 dev_err(dev
, " paddrh[%x]\n", paddrh
);
1697 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
1698 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
1699 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
1702 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
, (u32
)paddrl
,
1705 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_hbar64
,
1706 paddrl
, &adapter
->slic_regs
->slic_addr_upper
,
1707 paddrh
, DONT_FLUSH
);
1710 rcvq
->tail
->next
= skb
;
1719 * slic_link_event_handler -
1721 * Initiate a link configuration sequence. The link configuration begins
1722 * by issuing a READ_LINK_STATUS command to the Utility Processor on the
1723 * SLIC. Since the command finishes asynchronously, the slic_upr_comlete
1724 * routine will follow it up witha UP configuration write command, which
1725 * will also complete asynchronously.
1728 static void slic_link_event_handler(struct adapter
*adapter
)
1731 struct slic_shmem
*pshmem
;
1733 if (adapter
->state
!= ADAPT_UP
) {
1734 /* Adapter is not operational. Ignore. */
1738 pshmem
= (struct slic_shmem
*)(unsigned long)adapter
->phys_shmem
;
1740 #if BITS_PER_LONG == 64
1741 status
= slic_upr_request(adapter
,
1743 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
1744 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
1747 status
= slic_upr_request(adapter
, SLIC_UPR_RLSR
,
1748 (u32
) &pshmem
->linkstatus
, /* no 4GB wrap guaranteed */
1753 static void slic_init_cleanup(struct adapter
*adapter
)
1755 if (adapter
->intrregistered
) {
1756 adapter
->intrregistered
= 0;
1757 free_irq(adapter
->netdev
->irq
, adapter
->netdev
);
1760 if (adapter
->pshmem
) {
1761 pci_free_consistent(adapter
->pcidev
,
1762 sizeof(struct slic_shmem
),
1763 adapter
->pshmem
, adapter
->phys_shmem
);
1764 adapter
->pshmem
= NULL
;
1765 adapter
->phys_shmem
= (dma_addr_t
)(unsigned long)NULL
;
1768 if (adapter
->pingtimerset
) {
1769 adapter
->pingtimerset
= 0;
1770 del_timer(&adapter
->pingtimer
);
1773 slic_rspqueue_free(adapter
);
1774 slic_cmdq_free(adapter
);
1775 slic_rcvqueue_free(adapter
);
1779 * Allocate a mcast_address structure to hold the multicast address.
1782 static int slic_mcast_add_list(struct adapter
*adapter
, char *address
)
1784 struct mcast_address
*mcaddr
, *mlist
;
1786 /* Check to see if it already exists */
1787 mlist
= adapter
->mcastaddrs
;
1789 if (ether_addr_equal(mlist
->address
, address
))
1791 mlist
= mlist
->next
;
1794 /* Doesn't already exist. Allocate a structure to hold it */
1795 mcaddr
= kmalloc(sizeof(struct mcast_address
), GFP_ATOMIC
);
1799 ether_addr_copy(mcaddr
->address
, address
);
1801 mcaddr
->next
= adapter
->mcastaddrs
;
1802 adapter
->mcastaddrs
= mcaddr
;
1807 static void slic_mcast_set_list(struct net_device
*dev
)
1809 struct adapter
*adapter
= netdev_priv(dev
);
1812 struct netdev_hw_addr
*ha
;
1814 netdev_for_each_mc_addr(ha
, dev
) {
1815 addresses
= (char *) &ha
->addr
;
1816 status
= slic_mcast_add_list(adapter
, addresses
);
1819 slic_mcast_set_bit(adapter
, addresses
);
1822 if (adapter
->devflags_prev
!= dev
->flags
) {
1823 adapter
->macopts
= MAC_DIRECTED
;
1825 if (dev
->flags
& IFF_BROADCAST
)
1826 adapter
->macopts
|= MAC_BCAST
;
1827 if (dev
->flags
& IFF_PROMISC
)
1828 adapter
->macopts
|= MAC_PROMISC
;
1829 if (dev
->flags
& IFF_ALLMULTI
)
1830 adapter
->macopts
|= MAC_ALLMCAST
;
1831 if (dev
->flags
& IFF_MULTICAST
)
1832 adapter
->macopts
|= MAC_MCAST
;
1834 adapter
->devflags_prev
= dev
->flags
;
1835 slic_config_set(adapter
, true);
1838 slic_mcast_set_mask(adapter
);
1842 #define XMIT_FAIL_LINK_STATE 1
1843 #define XMIT_FAIL_ZERO_LENGTH 2
1844 #define XMIT_FAIL_HOSTCMD_FAIL 3
1846 static void slic_xmit_build_request(struct adapter
*adapter
,
1847 struct slic_hostcmd
*hcmd
, struct sk_buff
*skb
)
1849 struct slic_host64_cmd
*ihcmd
;
1852 ihcmd
= &hcmd
->cmd64
;
1854 ihcmd
->flags
= (adapter
->port
<< IHFLG_IFSHFT
);
1855 ihcmd
->command
= IHCMD_XMT_REQ
;
1856 ihcmd
->u
.slic_buffers
.totlen
= skb
->len
;
1857 phys_addr
= pci_map_single(adapter
->pcidev
, skb
->data
, skb
->len
,
1859 ihcmd
->u
.slic_buffers
.bufs
[0].paddrl
= SLIC_GET_ADDR_LOW(phys_addr
);
1860 ihcmd
->u
.slic_buffers
.bufs
[0].paddrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
1861 ihcmd
->u
.slic_buffers
.bufs
[0].length
= skb
->len
;
1862 #if BITS_PER_LONG == 64
1863 hcmd
->cmdsize
= (u32
) ((((u64
)&ihcmd
->u
.slic_buffers
.bufs
[1] -
1864 (u64
) hcmd
) + 31) >> 5);
1866 hcmd
->cmdsize
= ((((u32
) &ihcmd
->u
.slic_buffers
.bufs
[1] -
1867 (u32
) hcmd
) + 31) >> 5);
1871 static void slic_xmit_fail(struct adapter
*adapter
,
1872 struct sk_buff
*skb
,
1873 void *cmd
, u32 skbtype
, u32 status
)
1875 if (adapter
->xmitq_full
)
1876 netif_stop_queue(adapter
->netdev
);
1877 if ((cmd
== NULL
) && (status
<= XMIT_FAIL_HOSTCMD_FAIL
)) {
1879 case XMIT_FAIL_LINK_STATE
:
1880 dev_err(&adapter
->netdev
->dev
,
1881 "reject xmit skb[%p: %x] linkstate[%s] adapter[%s:%d] card[%s:%d]\n",
1883 SLIC_LINKSTATE(adapter
->linkstate
),
1884 SLIC_ADAPTER_STATE(adapter
->state
),
1886 SLIC_CARD_STATE(adapter
->card
->state
),
1887 adapter
->card
->state
);
1889 case XMIT_FAIL_ZERO_LENGTH
:
1890 dev_err(&adapter
->netdev
->dev
,
1891 "xmit_start skb->len == 0 skb[%p] type[%x]\n",
1892 skb
, skb
->pkt_type
);
1894 case XMIT_FAIL_HOSTCMD_FAIL
:
1895 dev_err(&adapter
->netdev
->dev
,
1896 "xmit_start skb[%p] type[%x] No host commands available\n",
1897 skb
, skb
->pkt_type
);
1902 adapter
->netdev
->stats
.tx_dropped
++;
1905 static void slic_rcv_handle_error(struct adapter
*adapter
,
1906 struct slic_rcvbuf
*rcvbuf
)
1908 struct slic_hddr_wds
*hdr
= (struct slic_hddr_wds
*)rcvbuf
->data
;
1909 struct net_device
*netdev
= adapter
->netdev
;
1911 if (adapter
->devid
!= SLIC_1GB_DEVICE_ID
) {
1912 if (hdr
->frame_status14
& VRHSTAT_802OE
)
1913 adapter
->if_events
.oflow802
++;
1914 if (hdr
->frame_status14
& VRHSTAT_TPOFLO
)
1915 adapter
->if_events
.Tprtoflow
++;
1916 if (hdr
->frame_status_b14
& VRHSTATB_802UE
)
1917 adapter
->if_events
.uflow802
++;
1918 if (hdr
->frame_status_b14
& VRHSTATB_RCVE
) {
1919 adapter
->if_events
.rcvearly
++;
1920 netdev
->stats
.rx_fifo_errors
++;
1922 if (hdr
->frame_status_b14
& VRHSTATB_BUFF
) {
1923 adapter
->if_events
.Bufov
++;
1924 netdev
->stats
.rx_over_errors
++;
1926 if (hdr
->frame_status_b14
& VRHSTATB_CARRE
) {
1927 adapter
->if_events
.Carre
++;
1928 netdev
->stats
.tx_carrier_errors
++;
1930 if (hdr
->frame_status_b14
& VRHSTATB_LONGE
)
1931 adapter
->if_events
.Longe
++;
1932 if (hdr
->frame_status_b14
& VRHSTATB_PREA
)
1933 adapter
->if_events
.Invp
++;
1934 if (hdr
->frame_status_b14
& VRHSTATB_CRC
) {
1935 adapter
->if_events
.Crc
++;
1936 netdev
->stats
.rx_crc_errors
++;
1938 if (hdr
->frame_status_b14
& VRHSTATB_DRBL
)
1939 adapter
->if_events
.Drbl
++;
1940 if (hdr
->frame_status_b14
& VRHSTATB_CODE
)
1941 adapter
->if_events
.Code
++;
1942 if (hdr
->frame_status_b14
& VRHSTATB_TPCSUM
)
1943 adapter
->if_events
.TpCsum
++;
1944 if (hdr
->frame_status_b14
& VRHSTATB_TPHLEN
)
1945 adapter
->if_events
.TpHlen
++;
1946 if (hdr
->frame_status_b14
& VRHSTATB_IPCSUM
)
1947 adapter
->if_events
.IpCsum
++;
1948 if (hdr
->frame_status_b14
& VRHSTATB_IPLERR
)
1949 adapter
->if_events
.IpLen
++;
1950 if (hdr
->frame_status_b14
& VRHSTATB_IPHERR
)
1951 adapter
->if_events
.IpHlen
++;
1953 if (hdr
->frame_statusGB
& VGBSTAT_XPERR
) {
1954 u32 xerr
= hdr
->frame_statusGB
>> VGBSTAT_XERRSHFT
;
1956 if (xerr
== VGBSTAT_XCSERR
)
1957 adapter
->if_events
.TpCsum
++;
1958 if (xerr
== VGBSTAT_XUFLOW
)
1959 adapter
->if_events
.Tprtoflow
++;
1960 if (xerr
== VGBSTAT_XHLEN
)
1961 adapter
->if_events
.TpHlen
++;
1963 if (hdr
->frame_statusGB
& VGBSTAT_NETERR
) {
1966 frame_statusGB
>> VGBSTAT_NERRSHFT
) &
1968 if (nerr
== VGBSTAT_NCSERR
)
1969 adapter
->if_events
.IpCsum
++;
1970 if (nerr
== VGBSTAT_NUFLOW
)
1971 adapter
->if_events
.IpLen
++;
1972 if (nerr
== VGBSTAT_NHLEN
)
1973 adapter
->if_events
.IpHlen
++;
1975 if (hdr
->frame_statusGB
& VGBSTAT_LNKERR
) {
1976 u32 lerr
= hdr
->frame_statusGB
& VGBSTAT_LERRMSK
;
1978 if (lerr
== VGBSTAT_LDEARLY
)
1979 adapter
->if_events
.rcvearly
++;
1980 if (lerr
== VGBSTAT_LBOFLO
)
1981 adapter
->if_events
.Bufov
++;
1982 if (lerr
== VGBSTAT_LCODERR
)
1983 adapter
->if_events
.Code
++;
1984 if (lerr
== VGBSTAT_LDBLNBL
)
1985 adapter
->if_events
.Drbl
++;
1986 if (lerr
== VGBSTAT_LCRCERR
)
1987 adapter
->if_events
.Crc
++;
1988 if (lerr
== VGBSTAT_LOFLO
)
1989 adapter
->if_events
.oflow802
++;
1990 if (lerr
== VGBSTAT_LUFLO
)
1991 adapter
->if_events
.uflow802
++;
1996 #define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000
1997 #define M_FAST_PATH 0x0040
1999 static void slic_rcv_handler(struct adapter
*adapter
)
2001 struct net_device
*netdev
= adapter
->netdev
;
2002 struct sk_buff
*skb
;
2003 struct slic_rcvbuf
*rcvbuf
;
2006 while ((skb
= slic_rcvqueue_getnext(adapter
))) {
2009 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
2010 adapter
->card
->events
++;
2011 if (rcvbuf
->status
& IRHDDR_ERR
) {
2012 adapter
->rx_errors
++;
2013 slic_rcv_handle_error(adapter
, rcvbuf
);
2014 slic_rcvqueue_reinsert(adapter
, skb
);
2018 if (!slic_mac_filter(adapter
, (struct ether_header
*)
2020 slic_rcvqueue_reinsert(adapter
, skb
);
2023 skb_pull(skb
, SLIC_RCVBUF_HEADSIZE
);
2024 rx_bytes
= (rcvbuf
->length
& IRHDDR_FLEN_MSK
);
2025 skb_put(skb
, rx_bytes
);
2026 netdev
->stats
.rx_packets
++;
2027 netdev
->stats
.rx_bytes
+= rx_bytes
;
2028 #if SLIC_OFFLOAD_IP_CHECKSUM
2029 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2032 skb
->dev
= adapter
->netdev
;
2033 skb
->protocol
= eth_type_trans(skb
, skb
->dev
);
2037 #if SLIC_INTERRUPT_PROCESS_LIMIT
2038 if (frames
>= SLIC_RCVQ_MAX_PROCESS_ISR
) {
2039 adapter
->rcv_interrupt_yields
++;
2044 adapter
->max_isr_rcvs
= max(adapter
->max_isr_rcvs
, frames
);
2047 static void slic_xmit_complete(struct adapter
*adapter
)
2049 struct slic_hostcmd
*hcmd
;
2050 struct slic_rspbuf
*rspbuf
;
2052 struct slic_handle_word slic_handle_word
;
2055 rspbuf
= slic_rspqueue_getnext(adapter
);
2058 adapter
->xmit_completes
++;
2059 adapter
->card
->events
++;
2061 Get the complete host command buffer
2063 slic_handle_word
.handle_token
= rspbuf
->hosthandle
;
2065 (struct slic_hostcmd
*)
2066 adapter
->slic_handles
[slic_handle_word
.handle_index
].
2068 /* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
2069 if (hcmd
->type
== SLIC_CMD_DUMB
) {
2071 dev_kfree_skb_irq(hcmd
->skb
);
2072 slic_cmdq_putdone_irq(adapter
, hcmd
);
2075 rspbuf
->hosthandle
= 0;
2078 adapter
->max_isr_xmits
= max(adapter
->max_isr_xmits
, frames
);
2081 static void slic_interrupt_card_up(u32 isr
, struct adapter
*adapter
,
2082 struct net_device
*dev
)
2084 if (isr
& ~ISR_IO
) {
2085 if (isr
& ISR_ERR
) {
2086 adapter
->error_interrupts
++;
2087 if (isr
& ISR_RMISS
) {
2092 struct slic_rcvqueue
*rcvq
=
2095 adapter
->error_rmiss_interrupts
++;
2098 rcv_count
= rcvq
->count
;
2099 pre_count
= rcvq
->count
;
2100 errors
= rcvq
->errors
;
2102 while (rcvq
->count
< SLIC_RCVQ_FILLTHRESH
) {
2103 count
= slic_rcvqueue_fill(adapter
);
2107 } else if (isr
& ISR_XDROP
) {
2109 "isr & ISR_ERR [%x] ISR_XDROP\n",
2113 "isr & ISR_ERR [%x]\n",
2118 if (isr
& ISR_LEVENT
) {
2119 adapter
->linkevent_interrupts
++;
2120 slic_link_event_handler(adapter
);
2123 if ((isr
& ISR_UPC
) || (isr
& ISR_UPCERR
) ||
2124 (isr
& ISR_UPCBSY
)) {
2125 adapter
->upr_interrupts
++;
2126 slic_upr_request_complete(adapter
, isr
);
2130 if (isr
& ISR_RCV
) {
2131 adapter
->rcv_interrupts
++;
2132 slic_rcv_handler(adapter
);
2135 if (isr
& ISR_CMD
) {
2136 adapter
->xmit_interrupts
++;
2137 slic_xmit_complete(adapter
);
2142 static irqreturn_t
slic_interrupt(int irq
, void *dev_id
)
2144 struct net_device
*dev
= (struct net_device
*)dev_id
;
2145 struct adapter
*adapter
= netdev_priv(dev
);
2148 if ((adapter
->pshmem
) && (adapter
->pshmem
->isr
)) {
2149 slic_reg32_write(&adapter
->slic_regs
->slic_icr
,
2150 ICR_INT_MASK
, FLUSH
);
2151 isr
= adapter
->isrcopy
= adapter
->pshmem
->isr
;
2152 adapter
->pshmem
->isr
= 0;
2153 adapter
->num_isrs
++;
2154 switch (adapter
->card
->state
) {
2156 slic_interrupt_card_up(isr
, adapter
, dev
);
2160 if ((isr
& ISR_UPC
) ||
2161 (isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
2162 adapter
->upr_interrupts
++;
2163 slic_upr_request_complete(adapter
, isr
);
2168 adapter
->isrcopy
= 0;
2169 adapter
->all_reg_writes
+= 2;
2170 adapter
->isr_reg_writes
++;
2171 slic_reg32_write(&adapter
->slic_regs
->slic_isr
, 0, FLUSH
);
2173 adapter
->false_interrupts
++;
2178 #define NORMAL_ETHFRAME 0
2180 static netdev_tx_t
slic_xmit_start(struct sk_buff
*skb
, struct net_device
*dev
)
2182 struct sliccard
*card
;
2183 struct adapter
*adapter
= netdev_priv(dev
);
2184 struct slic_hostcmd
*hcmd
= NULL
;
2186 void *offloadcmd
= NULL
;
2188 card
= adapter
->card
;
2189 if ((adapter
->linkstate
!= LINK_UP
) ||
2190 (adapter
->state
!= ADAPT_UP
) || (card
->state
!= CARD_UP
)) {
2191 status
= XMIT_FAIL_LINK_STATE
;
2194 } else if (skb
->len
== 0) {
2195 status
= XMIT_FAIL_ZERO_LENGTH
;
2199 hcmd
= slic_cmdq_getfree(adapter
);
2201 adapter
->xmitq_full
= 1;
2202 status
= XMIT_FAIL_HOSTCMD_FAIL
;
2207 hcmd
->type
= SLIC_CMD_DUMB
;
2208 slic_xmit_build_request(adapter
, hcmd
, skb
);
2209 dev
->stats
.tx_packets
++;
2210 dev
->stats
.tx_bytes
+= skb
->len
;
2213 if (adapter
->kill_card
) {
2214 struct slic_host64_cmd ihcmd
;
2216 ihcmd
= &hcmd
->cmd64
;
2218 ihcmd
->flags
|= 0x40;
2219 adapter
->kill_card
= 0; /* only do this once */
2222 if (hcmd
->paddrh
== 0) {
2223 slic_reg32_write(&adapter
->slic_regs
->slic_cbar
,
2224 (hcmd
->paddrl
| hcmd
->cmdsize
), DONT_FLUSH
);
2226 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_cbar64
,
2227 (hcmd
->paddrl
| hcmd
->cmdsize
),
2228 &adapter
->slic_regs
->slic_addr_upper
,
2229 hcmd
->paddrh
, DONT_FLUSH
);
2232 return NETDEV_TX_OK
;
2234 slic_xmit_fail(adapter
, skb
, offloadcmd
, NORMAL_ETHFRAME
, status
);
2239 static void slic_adapter_freeresources(struct adapter
*adapter
)
2241 slic_init_cleanup(adapter
);
2242 adapter
->error_interrupts
= 0;
2243 adapter
->rcv_interrupts
= 0;
2244 adapter
->xmit_interrupts
= 0;
2245 adapter
->linkevent_interrupts
= 0;
2246 adapter
->upr_interrupts
= 0;
2247 adapter
->num_isrs
= 0;
2248 adapter
->xmit_completes
= 0;
2249 adapter
->rcv_broadcasts
= 0;
2250 adapter
->rcv_multicasts
= 0;
2251 adapter
->rcv_unicasts
= 0;
2254 static int slic_adapter_allocresources(struct adapter
*adapter
)
2256 if (!adapter
->intrregistered
) {
2259 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
2260 slic_global
.driver_lock
.flags
);
2262 retval
= request_irq(adapter
->netdev
->irq
,
2265 adapter
->netdev
->name
, adapter
->netdev
);
2267 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
2268 slic_global
.driver_lock
.flags
);
2271 dev_err(&adapter
->netdev
->dev
,
2272 "request_irq (%s) FAILED [%x]\n",
2273 adapter
->netdev
->name
, retval
);
2276 adapter
->intrregistered
= 1;
2284 * Perform initialization of our slic interface.
2287 static int slic_if_init(struct adapter
*adapter
)
2289 struct sliccard
*card
= adapter
->card
;
2290 struct net_device
*dev
= adapter
->netdev
;
2291 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2292 struct slic_shmem
*pshmem
;
2295 /* adapter should be down at this point */
2296 if (adapter
->state
!= ADAPT_DOWN
) {
2297 dev_err(&dev
->dev
, "%s: adapter->state != ADAPT_DOWN\n",
2303 adapter
->devflags_prev
= dev
->flags
;
2304 adapter
->macopts
= MAC_DIRECTED
;
2306 if (dev
->flags
& IFF_BROADCAST
)
2307 adapter
->macopts
|= MAC_BCAST
;
2308 if (dev
->flags
& IFF_PROMISC
)
2309 adapter
->macopts
|= MAC_PROMISC
;
2310 if (dev
->flags
& IFF_ALLMULTI
)
2311 adapter
->macopts
|= MAC_ALLMCAST
;
2312 if (dev
->flags
& IFF_MULTICAST
)
2313 adapter
->macopts
|= MAC_MCAST
;
2315 rc
= slic_adapter_allocresources(adapter
);
2318 "%s: slic_adapter_allocresources FAILED %x\n",
2320 slic_adapter_freeresources(adapter
);
2324 if (!adapter
->queues_initialized
) {
2325 rc
= slic_rspqueue_init(adapter
);
2328 rc
= slic_cmdq_init(adapter
);
2331 rc
= slic_rcvqueue_init(adapter
);
2334 adapter
->queues_initialized
= 1;
2337 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
2340 if (!adapter
->isp_initialized
) {
2341 pshmem
= (struct slic_shmem
*)(unsigned long)
2342 adapter
->phys_shmem
;
2344 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
2345 adapter
->bit64reglock
.flags
);
2347 #if BITS_PER_LONG == 64
2348 slic_reg32_write(&slic_regs
->slic_addr_upper
,
2349 SLIC_GET_ADDR_HIGH(&pshmem
->isr
), DONT_FLUSH
);
2350 slic_reg32_write(&slic_regs
->slic_isp
,
2351 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
2353 slic_reg32_write(&slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
2354 slic_reg32_write(&slic_regs
->slic_isp
, (u32
)&pshmem
->isr
,
2357 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
2358 adapter
->bit64reglock
.flags
);
2359 adapter
->isp_initialized
= 1;
2362 adapter
->state
= ADAPT_UP
;
2363 if (!card
->loadtimerset
) {
2364 setup_timer(&card
->loadtimer
, &slic_timer_load_check
,
2366 card
->loadtimer
.expires
=
2367 jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
2368 add_timer(&card
->loadtimer
);
2370 card
->loadtimerset
= 1;
2373 if (!adapter
->pingtimerset
) {
2374 setup_timer(&adapter
->pingtimer
, &slic_timer_ping
, (ulong
)dev
);
2375 adapter
->pingtimer
.expires
=
2376 jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
2377 add_timer(&adapter
->pingtimer
);
2378 adapter
->pingtimerset
= 1;
2379 adapter
->card
->pingstatus
= ISR_PINGMASK
;
2383 * clear any pending events, then enable interrupts
2385 adapter
->isrcopy
= 0;
2386 adapter
->pshmem
->isr
= 0;
2387 slic_reg32_write(&slic_regs
->slic_isr
, 0, FLUSH
);
2388 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_ON
, FLUSH
);
2390 slic_link_config(adapter
, LINK_AUTOSPEED
, LINK_AUTOD
);
2391 slic_link_event_handler(adapter
);
2397 static int slic_entry_open(struct net_device
*dev
)
2399 struct adapter
*adapter
= netdev_priv(dev
);
2400 struct sliccard
*card
= adapter
->card
;
2403 netif_stop_queue(adapter
->netdev
);
2405 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
2406 slic_global
.driver_lock
.flags
);
2407 if (!adapter
->activated
) {
2408 card
->adapters_activated
++;
2409 slic_global
.num_slic_ports_active
++;
2410 adapter
->activated
= 1;
2412 status
= slic_if_init(adapter
);
2415 if (adapter
->activated
) {
2416 card
->adapters_activated
--;
2417 slic_global
.num_slic_ports_active
--;
2418 adapter
->activated
= 0;
2423 card
->master
= adapter
;
2426 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
2427 slic_global
.driver_lock
.flags
);
2431 static void slic_card_cleanup(struct sliccard
*card
)
2433 if (card
->loadtimerset
) {
2434 card
->loadtimerset
= 0;
2435 del_timer_sync(&card
->loadtimer
);
2441 static void slic_entry_remove(struct pci_dev
*pcidev
)
2443 struct net_device
*dev
= pci_get_drvdata(pcidev
);
2444 struct adapter
*adapter
= netdev_priv(dev
);
2445 struct sliccard
*card
;
2446 struct mcast_address
*mcaddr
, *mlist
;
2448 unregister_netdev(dev
);
2450 slic_adapter_freeresources(adapter
);
2451 slic_unmap_mmio_space(adapter
);
2453 /* free multicast addresses */
2454 mlist
= adapter
->mcastaddrs
;
2457 mlist
= mlist
->next
;
2460 card
= adapter
->card
;
2461 card
->adapters_allocated
--;
2462 adapter
->allocated
= 0;
2463 if (!card
->adapters_allocated
) {
2464 struct sliccard
*curr_card
= slic_global
.slic_card
;
2466 if (curr_card
== card
) {
2467 slic_global
.slic_card
= card
->next
;
2469 while (curr_card
->next
!= card
)
2470 curr_card
= curr_card
->next
;
2471 curr_card
->next
= card
->next
;
2473 slic_global
.num_slic_cards
--;
2474 slic_card_cleanup(card
);
2477 pci_release_regions(pcidev
);
2478 pci_disable_device(pcidev
);
2481 static int slic_entry_halt(struct net_device
*dev
)
2483 struct adapter
*adapter
= netdev_priv(dev
);
2484 struct sliccard
*card
= adapter
->card
;
2485 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2487 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
2488 slic_global
.driver_lock
.flags
);
2489 netif_stop_queue(adapter
->netdev
);
2490 adapter
->state
= ADAPT_DOWN
;
2491 adapter
->linkstate
= LINK_DOWN
;
2492 adapter
->upr_list
= NULL
;
2493 adapter
->upr_busy
= 0;
2494 adapter
->devflags_prev
= 0;
2495 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
2496 adapter
->all_reg_writes
++;
2497 adapter
->icr_reg_writes
++;
2498 slic_config_clear(adapter
);
2499 if (adapter
->activated
) {
2500 card
->adapters_activated
--;
2501 slic_global
.num_slic_ports_active
--;
2502 adapter
->activated
= 0;
2504 #ifdef AUTOMATIC_RESET
2505 slic_reg32_write(&slic_regs
->slic_reset_iface
, 0, FLUSH
);
2508 * Reset the adapter's cmd queues
2510 slic_cmdq_reset(adapter
);
2512 #ifdef AUTOMATIC_RESET
2513 if (!card
->adapters_activated
)
2514 slic_card_init(card
, adapter
);
2517 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
2518 slic_global
.driver_lock
.flags
);
2522 static struct net_device_stats
*slic_get_stats(struct net_device
*dev
)
2524 struct adapter
*adapter
= netdev_priv(dev
);
2526 dev
->stats
.collisions
= adapter
->slic_stats
.iface
.xmit_collisions
;
2527 dev
->stats
.rx_errors
= adapter
->slic_stats
.iface
.rcv_errors
;
2528 dev
->stats
.tx_errors
= adapter
->slic_stats
.iface
.xmt_errors
;
2529 dev
->stats
.rx_missed_errors
= adapter
->slic_stats
.iface
.rcv_discards
;
2530 dev
->stats
.tx_heartbeat_errors
= 0;
2531 dev
->stats
.tx_aborted_errors
= 0;
2532 dev
->stats
.tx_window_errors
= 0;
2533 dev
->stats
.tx_fifo_errors
= 0;
2534 dev
->stats
.rx_frame_errors
= 0;
2535 dev
->stats
.rx_length_errors
= 0;
2540 static int slic_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
2542 struct adapter
*adapter
= netdev_priv(dev
);
2543 struct ethtool_cmd edata
;
2544 struct ethtool_cmd ecmd
;
2549 case SIOCSLICSETINTAGG
:
2550 if (copy_from_user(data
, rq
->ifr_data
, 28))
2553 dev_err(&dev
->dev
, "%s: set interrupt aggregation to %d\n",
2555 slic_intagg_set(adapter
, intagg
);
2558 #ifdef SLIC_TRACE_DUMP_ENABLED
2559 case SIOCSLICTRACEDUMP
:
2563 DBG_IOCTL("slic_ioctl SIOCSLIC_TRACE_DUMP\n");
2565 if (copy_from_user(data
, rq
->ifr_data
, 28)) {
2567 ("slic: copy_from_user FAILED getting initial simba param\n");
2572 if (tracemon_request
== SLIC_DUMP_DONE
) {
2574 ("ATK Diagnostic Trace Dump Requested\n");
2575 tracemon_request
= SLIC_DUMP_REQUESTED
;
2576 tracemon_request_type
= value
;
2577 tracemon_timestamp
= jiffies
;
2578 } else if ((tracemon_request
== SLIC_DUMP_REQUESTED
) ||
2579 (tracemon_request
==
2580 SLIC_DUMP_IN_PROGRESS
)) {
2582 ("ATK Diagnostic Trace Dump Requested but already in progress... ignore\n");
2585 ("ATK Diagnostic Trace Dump Requested\n");
2586 tracemon_request
= SLIC_DUMP_REQUESTED
;
2587 tracemon_request_type
= value
;
2588 tracemon_timestamp
= jiffies
;
2594 if (copy_from_user(&ecmd
, rq
->ifr_data
, sizeof(ecmd
)))
2597 if (ecmd
.cmd
== ETHTOOL_GSET
) {
2598 memset(&edata
, 0, sizeof(edata
));
2599 edata
.supported
= (SUPPORTED_10baseT_Half
|
2600 SUPPORTED_10baseT_Full
|
2601 SUPPORTED_100baseT_Half
|
2602 SUPPORTED_100baseT_Full
|
2603 SUPPORTED_Autoneg
| SUPPORTED_MII
);
2604 edata
.port
= PORT_MII
;
2605 edata
.transceiver
= XCVR_INTERNAL
;
2606 edata
.phy_address
= 0;
2607 if (adapter
->linkspeed
== LINK_100MB
)
2608 edata
.speed
= SPEED_100
;
2609 else if (adapter
->linkspeed
== LINK_10MB
)
2610 edata
.speed
= SPEED_10
;
2614 if (adapter
->linkduplex
== LINK_FULLD
)
2615 edata
.duplex
= DUPLEX_FULL
;
2617 edata
.duplex
= DUPLEX_HALF
;
2619 edata
.autoneg
= AUTONEG_ENABLE
;
2622 if (copy_to_user(rq
->ifr_data
, &edata
, sizeof(edata
)))
2625 } else if (ecmd
.cmd
== ETHTOOL_SSET
) {
2626 if (!capable(CAP_NET_ADMIN
))
2629 if (adapter
->linkspeed
== LINK_100MB
)
2630 edata
.speed
= SPEED_100
;
2631 else if (adapter
->linkspeed
== LINK_10MB
)
2632 edata
.speed
= SPEED_10
;
2636 if (adapter
->linkduplex
== LINK_FULLD
)
2637 edata
.duplex
= DUPLEX_FULL
;
2639 edata
.duplex
= DUPLEX_HALF
;
2641 edata
.autoneg
= AUTONEG_ENABLE
;
2644 if ((ecmd
.speed
!= edata
.speed
) ||
2645 (ecmd
.duplex
!= edata
.duplex
)) {
2649 if (ecmd
.speed
== SPEED_10
)
2652 speed
= PCR_SPEED_100
;
2653 if (ecmd
.duplex
== DUPLEX_FULL
)
2654 duplex
= PCR_DUPLEX_FULL
;
2657 slic_link_config(adapter
, speed
, duplex
);
2658 slic_link_event_handler(adapter
);
2667 static void slic_config_pci(struct pci_dev
*pcidev
)
2672 pci_read_config_word(pcidev
, PCI_COMMAND
, &pci_command
);
2674 new_command
= pci_command
| PCI_COMMAND_MASTER
2675 | PCI_COMMAND_MEMORY
2676 | PCI_COMMAND_INVALIDATE
2677 | PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
| PCI_COMMAND_FAST_BACK
;
2678 if (pci_command
!= new_command
)
2679 pci_write_config_word(pcidev
, PCI_COMMAND
, new_command
);
2682 static int slic_card_init(struct sliccard
*card
, struct adapter
*adapter
)
2684 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2685 struct slic_eeprom
*peeprom
;
2686 struct oslic_eeprom
*pOeeprom
;
2687 dma_addr_t phys_config
;
2691 struct slic_shmem
*pshmem
;
2693 uint macaddrs
= card
->card_size
;
2698 struct slic_config_mac
*pmac
;
2699 unsigned char fruformat
;
2700 unsigned char oemfruformat
;
2701 struct atk_fru
*patkfru
;
2702 union oemfru
*poemfru
;
2704 /* Reset everything except PCI configuration space */
2705 slic_soft_reset(adapter
);
2707 /* Download the microcode */
2708 status
= slic_card_download(adapter
);
2712 if (!card
->config_set
) {
2713 peeprom
= pci_alloc_consistent(adapter
->pcidev
,
2714 sizeof(struct slic_eeprom
),
2717 phys_configl
= SLIC_GET_ADDR_LOW(phys_config
);
2718 phys_configh
= SLIC_GET_ADDR_HIGH(phys_config
);
2721 dev_err(&adapter
->pcidev
->dev
,
2722 "Failed to allocate DMA memory for EEPROM.\n");
2726 memset(peeprom
, 0, sizeof(struct slic_eeprom
));
2728 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
2730 pshmem
= (struct slic_shmem
*)(unsigned long)
2731 adapter
->phys_shmem
;
2733 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
2734 adapter
->bit64reglock
.flags
);
2735 slic_reg32_write(&slic_regs
->slic_addr_upper
,
2736 SLIC_GET_ADDR_HIGH(&pshmem
->isr
), DONT_FLUSH
);
2737 slic_reg32_write(&slic_regs
->slic_isp
,
2738 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
2739 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
2740 adapter
->bit64reglock
.flags
);
2742 status
= slic_config_get(adapter
, phys_configl
, phys_configh
);
2744 dev_err(&adapter
->pcidev
->dev
,
2745 "Failed to fetch config data from device.\n");
2750 if (adapter
->pshmem
->isr
) {
2751 if (adapter
->pshmem
->isr
& ISR_UPC
) {
2752 adapter
->pshmem
->isr
= 0;
2753 slic_reg64_write(adapter
,
2754 &slic_regs
->slic_isp
, 0,
2755 &slic_regs
->slic_addr_upper
,
2757 slic_reg32_write(&slic_regs
->slic_isr
,
2760 slic_upr_request_complete(adapter
, 0);
2764 adapter
->pshmem
->isr
= 0;
2765 slic_reg32_write(&slic_regs
->slic_isr
,
2771 dev_err(&adapter
->pcidev
->dev
,
2772 "Fetch of config data timed out.\n");
2773 slic_reg64_write(adapter
,
2774 &slic_regs
->slic_isp
, 0,
2775 &slic_regs
->slic_addr_upper
,
2783 switch (adapter
->devid
) {
2785 case SLIC_2GB_DEVICE_ID
:
2786 /* extract EEPROM data and pointers to EEPROM data */
2787 pOeeprom
= (struct oslic_eeprom
*) peeprom
;
2788 eecodesize
= pOeeprom
->EecodeSize
;
2789 dramsize
= pOeeprom
->DramSize
;
2790 pmac
= pOeeprom
->MacInfo
;
2791 fruformat
= pOeeprom
->FruFormat
;
2792 patkfru
= &pOeeprom
->AtkFru
;
2793 oemfruformat
= pOeeprom
->OemFruFormat
;
2794 poemfru
= &pOeeprom
->OemFru
;
2796 /* Minor kludge for Oasis card
2797 get 2 MAC addresses from the
2798 EEPROM to ensure that function 1
2799 gets the Port 1 MAC address */
2802 /* extract EEPROM data and pointers to EEPROM data */
2803 eecodesize
= peeprom
->EecodeSize
;
2804 dramsize
= peeprom
->DramSize
;
2805 pmac
= peeprom
->u2
.mac
.MacInfo
;
2806 fruformat
= peeprom
->FruFormat
;
2807 patkfru
= &peeprom
->AtkFru
;
2808 oemfruformat
= peeprom
->OemFruFormat
;
2809 poemfru
= &peeprom
->OemFru
;
2813 card
->config
.EepromValid
= false;
2815 /* see if the EEPROM is valid by checking it's checksum */
2816 if ((eecodesize
<= MAX_EECODE_SIZE
) &&
2817 (eecodesize
>= MIN_EECODE_SIZE
)) {
2820 *(u16
*) ((char *) peeprom
+ (eecodesize
- 2));
2822 calculate the EEPROM checksum
2824 calc_chksum
= slic_eeprom_cksum(peeprom
,
2827 if the ucdoe chksum flag bit worked,
2828 we wouldn't need this
2830 if (ee_chksum
== calc_chksum
)
2831 card
->config
.EepromValid
= true;
2833 /* copy in the DRAM size */
2834 card
->config
.DramSize
= dramsize
;
2836 /* copy in the MAC address(es) */
2837 for (i
= 0; i
< macaddrs
; i
++) {
2838 memcpy(&card
->config
.MacInfo
[i
],
2839 &pmac
[i
], sizeof(struct slic_config_mac
));
2842 /* copy the Alacritech FRU information */
2843 card
->config
.FruFormat
= fruformat
;
2844 memcpy(&card
->config
.AtkFru
, patkfru
,
2845 sizeof(struct atk_fru
));
2847 pci_free_consistent(adapter
->pcidev
,
2848 sizeof(struct slic_eeprom
),
2849 peeprom
, phys_config
);
2851 if (!card
->config
.EepromValid
) {
2852 slic_reg64_write(adapter
, &slic_regs
->slic_isp
, 0,
2853 &slic_regs
->slic_addr_upper
,
2855 dev_err(&adapter
->pcidev
->dev
, "EEPROM invalid.\n");
2859 card
->config_set
= 1;
2862 status
= slic_card_download_gbrcv(adapter
);
2866 if (slic_global
.dynamic_intagg
)
2867 slic_intagg_set(adapter
, 0);
2869 slic_intagg_set(adapter
, intagg_delay
);
2872 * Initialize ping status to "ok"
2874 card
->pingstatus
= ISR_PINGMASK
;
2877 * Lastly, mark our card state as up and return success
2879 card
->state
= CARD_UP
;
2880 card
->reset_in_progress
= 0;
2885 pci_free_consistent(adapter
->pcidev
, sizeof(struct slic_eeprom
),
2886 peeprom
, phys_config
);
2890 static void slic_init_driver(void)
2892 if (slic_first_init
) {
2893 slic_first_init
= 0;
2894 spin_lock_init(&slic_global
.driver_lock
.lock
);
2898 static void slic_init_adapter(struct net_device
*netdev
,
2899 struct pci_dev
*pcidev
,
2900 const struct pci_device_id
*pci_tbl_entry
,
2901 void __iomem
*memaddr
, int chip_idx
)
2904 struct slic_handle
*pslic_handle
;
2905 struct adapter
*adapter
= netdev_priv(netdev
);
2907 /* adapter->pcidev = pcidev;*/
2908 adapter
->vendid
= pci_tbl_entry
->vendor
;
2909 adapter
->devid
= pci_tbl_entry
->device
;
2910 adapter
->subsysid
= pci_tbl_entry
->subdevice
;
2911 adapter
->busnumber
= pcidev
->bus
->number
;
2912 adapter
->slotnumber
= ((pcidev
->devfn
>> 3) & 0x1F);
2913 adapter
->functionnumber
= (pcidev
->devfn
& 0x7);
2914 adapter
->slic_regs
= (__iomem
struct slic_regs
*)memaddr
;
2915 adapter
->irq
= pcidev
->irq
;
2916 /* adapter->netdev = netdev;*/
2917 adapter
->chipid
= chip_idx
;
2918 adapter
->port
= 0; /*adapter->functionnumber;*/
2919 adapter
->cardindex
= adapter
->port
;
2920 spin_lock_init(&adapter
->upr_lock
.lock
);
2921 spin_lock_init(&adapter
->bit64reglock
.lock
);
2922 spin_lock_init(&adapter
->adapter_lock
.lock
);
2923 spin_lock_init(&adapter
->reset_lock
.lock
);
2924 spin_lock_init(&adapter
->handle_lock
.lock
);
2926 adapter
->card_size
= 1;
2928 Initialize slic_handle array
2931 Start with 1. 0 is an invalid host handle.
2933 for (index
= 1, pslic_handle
= &adapter
->slic_handles
[1];
2934 index
< SLIC_CMDQ_MAXCMDS
; index
++, pslic_handle
++) {
2936 pslic_handle
->token
.handle_index
= index
;
2937 pslic_handle
->type
= SLIC_HANDLE_FREE
;
2938 pslic_handle
->next
= adapter
->pfree_slic_handles
;
2939 adapter
->pfree_slic_handles
= pslic_handle
;
2941 adapter
->pshmem
= (struct slic_shmem
*)
2942 pci_alloc_consistent(adapter
->pcidev
,
2943 sizeof(struct slic_shmem
),
2946 if (adapter
->pshmem
)
2947 memset(adapter
->pshmem
, 0, sizeof(struct slic_shmem
));
2950 static const struct net_device_ops slic_netdev_ops
= {
2951 .ndo_open
= slic_entry_open
,
2952 .ndo_stop
= slic_entry_halt
,
2953 .ndo_start_xmit
= slic_xmit_start
,
2954 .ndo_do_ioctl
= slic_ioctl
,
2955 .ndo_set_mac_address
= slic_mac_set_address
,
2956 .ndo_get_stats
= slic_get_stats
,
2957 .ndo_set_rx_mode
= slic_mcast_set_list
,
2958 .ndo_validate_addr
= eth_validate_addr
,
2959 .ndo_change_mtu
= eth_change_mtu
,
2962 static u32
slic_card_locate(struct adapter
*adapter
)
2964 struct sliccard
*card
= slic_global
.slic_card
;
2965 struct physcard
*physcard
= slic_global
.phys_card
;
2967 u16 __iomem
*hostid_reg
;
2969 uint rdhostid_offset
= 0;
2971 switch (adapter
->devid
) {
2972 case SLIC_2GB_DEVICE_ID
:
2973 rdhostid_offset
= SLIC_RDHOSTID_2GB
;
2975 case SLIC_1GB_DEVICE_ID
:
2976 rdhostid_offset
= SLIC_RDHOSTID_1GB
;
2983 (u16 __iomem
*) (((u8 __iomem
*) (adapter
->slic_regs
)) +
2986 /* read the 16 bit hostid from SRAM */
2987 card_hostid
= (ushort
) readw(hostid_reg
);
2989 /* Initialize a new card structure if need be */
2990 if (card_hostid
== SLIC_HOSTID_DEFAULT
) {
2991 card
= kzalloc(sizeof(struct sliccard
), GFP_KERNEL
);
2995 card
->next
= slic_global
.slic_card
;
2996 slic_global
.slic_card
= card
;
2997 card
->busnumber
= adapter
->busnumber
;
2998 card
->slotnumber
= adapter
->slotnumber
;
3000 /* Find an available cardnum */
3001 for (i
= 0; i
< SLIC_MAX_CARDS
; i
++) {
3002 if (slic_global
.cardnuminuse
[i
] == 0) {
3003 slic_global
.cardnuminuse
[i
] = 1;
3008 slic_global
.num_slic_cards
++;
3010 /* Card exists, find the card this adapter belongs to */
3012 if (card
->cardnum
== card_hostid
)
3020 /* Put the adapter in the card's adapter list */
3021 if (!card
->adapter
[adapter
->port
]) {
3022 card
->adapter
[adapter
->port
] = adapter
;
3023 adapter
->card
= card
;
3026 card
->card_size
= 1; /* one port per *logical* card */
3029 for (i
= 0; i
< SLIC_MAX_PORTS
; i
++) {
3030 if (physcard
->adapter
[i
])
3033 if (i
== SLIC_MAX_PORTS
)
3036 if (physcard
->adapter
[i
]->slotnumber
== adapter
->slotnumber
)
3038 physcard
= physcard
->next
;
3041 /* no structure allocated for this physical card yet */
3042 physcard
= kzalloc(sizeof(struct physcard
), GFP_ATOMIC
);
3044 if (card_hostid
== SLIC_HOSTID_DEFAULT
)
3049 physcard
->next
= slic_global
.phys_card
;
3050 slic_global
.phys_card
= physcard
;
3051 physcard
->adapters_allocd
= 1;
3053 physcard
->adapters_allocd
++;
3055 /* Note - this is ZERO relative */
3056 adapter
->physport
= physcard
->adapters_allocd
- 1;
3058 physcard
->adapter
[adapter
->physport
] = adapter
;
3059 adapter
->physcard
= physcard
;
3064 static int slic_entry_probe(struct pci_dev
*pcidev
,
3065 const struct pci_device_id
*pci_tbl_entry
)
3067 static int cards_found
;
3068 static int did_version
;
3070 struct net_device
*netdev
;
3071 struct adapter
*adapter
;
3072 void __iomem
*memmapped_ioaddr
= NULL
;
3073 ulong mmio_start
= 0;
3075 struct sliccard
*card
= NULL
;
3076 int pci_using_dac
= 0;
3078 slic_global
.dynamic_intagg
= dynamic_intagg
;
3080 err
= pci_enable_device(pcidev
);
3085 if (did_version
++ == 0) {
3086 dev_info(&pcidev
->dev
, "%s\n", slic_banner
);
3087 dev_info(&pcidev
->dev
, "%s\n", slic_proc_version
);
3090 if (!pci_set_dma_mask(pcidev
, DMA_BIT_MASK(64))) {
3092 err
= pci_set_consistent_dma_mask(pcidev
, DMA_BIT_MASK(64));
3094 dev_err(&pcidev
->dev
, "unable to obtain 64-bit DMA for consistent allocations\n");
3095 goto err_out_disable_pci
;
3098 err
= pci_set_dma_mask(pcidev
, DMA_BIT_MASK(32));
3100 dev_err(&pcidev
->dev
, "no usable DMA configuration\n");
3101 goto err_out_disable_pci
;
3104 pci_set_consistent_dma_mask(pcidev
, DMA_BIT_MASK(32));
3107 err
= pci_request_regions(pcidev
, DRV_NAME
);
3109 dev_err(&pcidev
->dev
, "can't obtain PCI resources\n");
3110 goto err_out_disable_pci
;
3113 pci_set_master(pcidev
);
3115 netdev
= alloc_etherdev(sizeof(struct adapter
));
3118 goto err_out_exit_slic_probe
;
3121 SET_NETDEV_DEV(netdev
, &pcidev
->dev
);
3123 pci_set_drvdata(pcidev
, netdev
);
3124 adapter
= netdev_priv(netdev
);
3125 adapter
->netdev
= netdev
;
3126 adapter
->pcidev
= pcidev
;
3128 netdev
->features
|= NETIF_F_HIGHDMA
;
3130 mmio_start
= pci_resource_start(pcidev
, 0);
3131 mmio_len
= pci_resource_len(pcidev
, 0);
3134 /* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/
3135 memmapped_ioaddr
= ioremap(mmio_start
, mmio_len
);
3136 if (!memmapped_ioaddr
) {
3137 dev_err(&pcidev
->dev
, "cannot remap MMIO region %lx @ %lx\n",
3138 mmio_len
, mmio_start
);
3140 goto err_out_free_netdev
;
3143 slic_config_pci(pcidev
);
3147 slic_init_adapter(netdev
,
3148 pcidev
, pci_tbl_entry
, memmapped_ioaddr
, cards_found
);
3150 err
= slic_card_locate(adapter
);
3152 dev_err(&pcidev
->dev
, "cannot locate card\n");
3156 card
= adapter
->card
;
3158 if (!adapter
->allocated
) {
3159 card
->adapters_allocated
++;
3160 adapter
->allocated
= 1;
3163 err
= slic_card_init(card
, adapter
);
3167 slic_adapter_set_hwaddr(adapter
);
3169 netdev
->base_addr
= (unsigned long) memmapped_ioaddr
;
3170 netdev
->irq
= adapter
->irq
;
3171 netdev
->netdev_ops
= &slic_netdev_ops
;
3173 strcpy(netdev
->name
, "eth%d");
3174 err
= register_netdev(netdev
);
3176 dev_err(&pcidev
->dev
, "Cannot register net device, aborting.\n");
3185 iounmap(memmapped_ioaddr
);
3186 err_out_free_netdev
:
3187 free_netdev(netdev
);
3188 err_out_exit_slic_probe
:
3189 pci_release_regions(pcidev
);
3190 err_out_disable_pci
:
3191 pci_disable_device(pcidev
);
3195 static struct pci_driver slic_driver
= {
3197 .id_table
= slic_pci_tbl
,
3198 .probe
= slic_entry_probe
,
3199 .remove
= slic_entry_remove
,
3202 static int __init
slic_module_init(void)
3206 return pci_register_driver(&slic_driver
);
3209 static void __exit
slic_module_cleanup(void)
3211 pci_unregister_driver(&slic_driver
);
3214 module_init(slic_module_init
);
3215 module_exit(slic_module_cleanup
);