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 struct net_device_stats
*slic_get_stats(struct net_device
*dev
);
101 static int slic_entry_open(struct net_device
*dev
);
102 static int slic_entry_halt(struct net_device
*dev
);
103 static int slic_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
104 static int slic_xmit_start(struct sk_buff
*skb
, struct net_device
*dev
);
105 static void slic_xmit_fail(struct adapter
*adapter
, struct sk_buff
*skb
,
106 void *cmd
, u32 skbtype
, u32 status
);
107 static void slic_config_pci(struct pci_dev
*pcidev
);
108 static struct sk_buff
*slic_rcvqueue_getnext(struct adapter
*adapter
);
109 static int slic_mac_set_address(struct net_device
*dev
, void *ptr
);
110 static void slic_link_event_handler(struct adapter
*adapter
);
111 static void slic_upr_request_complete(struct adapter
*adapter
, u32 isr
);
112 static int slic_rspqueue_init(struct adapter
*adapter
);
113 static void slic_rspqueue_free(struct adapter
*adapter
);
114 static struct slic_rspbuf
*slic_rspqueue_getnext(struct adapter
*adapter
);
115 static int slic_cmdq_init(struct adapter
*adapter
);
116 static void slic_cmdq_free(struct adapter
*adapter
);
117 static void slic_cmdq_reset(struct adapter
*adapter
);
118 static void slic_cmdq_addcmdpage(struct adapter
*adapter
, u32
*page
);
119 static void slic_cmdq_getdone(struct adapter
*adapter
);
120 static void slic_cmdq_putdone_irq(struct adapter
*adapter
,
121 struct slic_hostcmd
*cmd
);
122 static struct slic_hostcmd
*slic_cmdq_getfree(struct adapter
*adapter
);
123 static int slic_rcvqueue_init(struct adapter
*adapter
);
124 static int slic_rcvqueue_fill(struct adapter
*adapter
);
125 static u32
slic_rcvqueue_reinsert(struct adapter
*adapter
, struct sk_buff
*skb
);
126 static void slic_rcvqueue_free(struct adapter
*adapter
);
127 static void slic_adapter_set_hwaddr(struct adapter
*adapter
);
128 static int slic_card_init(struct sliccard
*card
, struct adapter
*adapter
);
129 static void slic_intagg_set(struct adapter
*adapter
, u32 value
);
130 static int slic_card_download(struct adapter
*adapter
);
131 static u32
slic_card_locate(struct adapter
*adapter
);
132 static int slic_if_init(struct adapter
*adapter
);
133 static int slic_adapter_allocresources(struct adapter
*adapter
);
134 static void slic_adapter_freeresources(struct adapter
*adapter
);
135 static void slic_link_config(struct adapter
*adapter
, u32 linkspeed
,
137 static void slic_unmap_mmio_space(struct adapter
*adapter
);
138 static void slic_card_cleanup(struct sliccard
*card
);
139 static void slic_soft_reset(struct adapter
*adapter
);
140 static bool slic_mac_filter(struct adapter
*adapter
,
141 struct ether_header
*ether_frame
);
142 static void slic_mac_address_config(struct adapter
*adapter
);
143 static void slic_mac_config(struct adapter
*adapter
);
144 static void slic_mcast_set_mask(struct adapter
*adapter
);
145 static void slic_config_set(struct adapter
*adapter
, bool linkchange
);
146 static void slic_config_clear(struct adapter
*adapter
);
147 static void slic_config_get(struct adapter
*adapter
, u32 config
,
149 static void slic_timer_load_check(ulong context
);
150 static void slic_assert_fail(void);
151 static ushort
slic_eeprom_cksum(char *m
, int len
);
152 static void slic_upr_start(struct adapter
*adapter
);
153 static void slic_link_upr_complete(struct adapter
*adapter
, u32 Isr
);
154 static int slic_upr_request(struct adapter
*adapter
, u32 upr_request
,
155 u32 upr_data
, u32 upr_data_h
, u32 upr_buffer
,
157 static void slic_mcast_set_list(struct net_device
*dev
);
160 static uint slic_first_init
= 1;
161 static char *slic_banner
= "Alacritech SLIC Technology(tm) Server "\
162 "and Storage Accelerator (Non-Accelerated)";
164 static char *slic_proc_version
= "2.0.351 2006/07/14 12:26:00";
165 static char *slic_product_name
= "SLIC Technology(tm) Server "\
166 "and Storage Accelerator (Non-Accelerated)";
167 static char *slic_vendor
= "Alacritech, Inc.";
169 static int slic_debug
= 1;
170 static int debug
= -1;
171 static struct net_device
*head_netdevice
;
173 static struct base_driver slic_global
= { {}, 0, 0, 0, 1, NULL
, NULL
};
174 static int intagg_delay
= 100;
175 static u32 dynamic_intagg
;
176 static unsigned int rcv_count
;
177 static struct dentry
*slic_debugfs
;
179 #define DRV_NAME "slicoss"
180 #define DRV_VERSION "2.0.1"
181 #define DRV_AUTHOR "Alacritech, Inc. Engineering"
182 #define DRV_DESCRIPTION "Alacritech SLIC Techonology(tm) "\
183 "Non-Accelerated Driver"
184 #define DRV_COPYRIGHT "Copyright 2000-2006 Alacritech, Inc. "\
185 "All rights reserved."
186 #define PFX DRV_NAME " "
188 MODULE_AUTHOR(DRV_AUTHOR
);
189 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
190 MODULE_LICENSE("Dual BSD/GPL");
192 module_param(dynamic_intagg
, int, 0);
193 MODULE_PARM_DESC(dynamic_intagg
, "Dynamic Interrupt Aggregation Setting");
194 module_param(intagg_delay
, int, 0);
195 MODULE_PARM_DESC(intagg_delay
, "uSec Interrupt Aggregation Delay");
197 static struct pci_device_id slic_pci_tbl
[] __devinitdata
= {
198 {PCI_VENDOR_ID_ALACRITECH
,
200 PCI_ANY_ID
, PCI_ANY_ID
,},
201 {PCI_VENDOR_ID_ALACRITECH
,
203 PCI_ANY_ID
, PCI_ANY_ID
,},
207 MODULE_DEVICE_TABLE(pci
, slic_pci_tbl
);
214 #define ASSERT(a) do { \
216 printk(KERN_ERR "slicoss ASSERT() Failure: function %s" \
217 "line %d\n", __func__, __LINE__); \
218 slic_assert_fail(); \
224 #define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \
226 spin_lock_irqsave(&_adapter->handle_lock.lock, \
227 _adapter->handle_lock.flags); \
228 _pslic_handle = _adapter->pfree_slic_handles; \
229 if (_pslic_handle) { \
230 ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \
231 _adapter->pfree_slic_handles = _pslic_handle->next; \
233 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
234 _adapter->handle_lock.flags); \
237 #define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \
239 _pslic_handle->type = SLIC_HANDLE_FREE; \
240 spin_lock_irqsave(&_adapter->handle_lock.lock, \
241 _adapter->handle_lock.flags); \
242 _pslic_handle->next = _adapter->pfree_slic_handles; \
243 _adapter->pfree_slic_handles = _pslic_handle; \
244 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
245 _adapter->handle_lock.flags); \
248 static void slic_debug_init(void);
249 static void slic_debug_cleanup(void);
250 static void slic_debug_adapter_create(struct adapter
*adapter
);
251 static void slic_debug_adapter_destroy(struct adapter
*adapter
);
252 static void slic_debug_card_create(struct sliccard
*card
);
253 static void slic_debug_card_destroy(struct sliccard
*card
);
255 static inline void slic_reg32_write(void __iomem
*reg
, u32 value
, bool flush
)
262 static inline void slic_reg64_write(struct adapter
*adapter
, void __iomem
*reg
,
263 u32 value
, void __iomem
*regh
, u32 paddrh
,
266 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
267 adapter
->bit64reglock
.flags
);
268 if (paddrh
!= adapter
->curaddrupper
) {
269 adapter
->curaddrupper
= paddrh
;
270 writel(paddrh
, regh
);
275 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
276 adapter
->bit64reglock
.flags
);
279 static void slic_init_driver(void)
281 if (slic_first_init
) {
283 spin_lock_init(&slic_global
.driver_lock
.lock
);
288 static void slic_init_adapter(struct net_device
*netdev
,
289 struct pci_dev
*pcidev
,
290 const struct pci_device_id
*pci_tbl_entry
,
291 void __iomem
*memaddr
, int chip_idx
)
294 struct slic_handle
*pslic_handle
;
295 struct adapter
*adapter
= (struct adapter
*)netdev_priv(netdev
);
297 /* adapter->pcidev = pcidev;*/
298 adapter
->vendid
= pci_tbl_entry
->vendor
;
299 adapter
->devid
= pci_tbl_entry
->device
;
300 adapter
->subsysid
= pci_tbl_entry
->subdevice
;
301 adapter
->busnumber
= pcidev
->bus
->number
;
302 adapter
->slotnumber
= ((pcidev
->devfn
>> 3) & 0x1F);
303 adapter
->functionnumber
= (pcidev
->devfn
& 0x7);
304 adapter
->memorylength
= pci_resource_len(pcidev
, 0);
305 adapter
->slic_regs
= (__iomem
struct slic_regs
*)memaddr
;
306 adapter
->irq
= pcidev
->irq
;
307 /* adapter->netdev = netdev;*/
308 adapter
->next_netdevice
= head_netdevice
;
309 head_netdevice
= netdev
;
310 adapter
->chipid
= chip_idx
;
311 adapter
->port
= 0; /*adapter->functionnumber;*/
312 adapter
->cardindex
= adapter
->port
;
313 adapter
->memorybase
= memaddr
;
314 spin_lock_init(&adapter
->upr_lock
.lock
);
315 spin_lock_init(&adapter
->bit64reglock
.lock
);
316 spin_lock_init(&adapter
->adapter_lock
.lock
);
317 spin_lock_init(&adapter
->reset_lock
.lock
);
318 spin_lock_init(&adapter
->handle_lock
.lock
);
320 adapter
->card_size
= 1;
322 Initialize slic_handle array
324 ASSERT(SLIC_CMDQ_MAXCMDS
<= 0xFFFF);
326 Start with 1. 0 is an invalid host handle.
328 for (index
= 1, pslic_handle
= &adapter
->slic_handles
[1];
329 index
< SLIC_CMDQ_MAXCMDS
; index
++, pslic_handle
++) {
331 pslic_handle
->token
.handle_index
= index
;
332 pslic_handle
->type
= SLIC_HANDLE_FREE
;
333 pslic_handle
->next
= adapter
->pfree_slic_handles
;
334 adapter
->pfree_slic_handles
= pslic_handle
;
336 adapter
->pshmem
= (struct slic_shmem
*)
337 pci_alloc_consistent(adapter
->pcidev
,
338 sizeof(struct slic_shmem
),
341 ASSERT(adapter
->pshmem
);
343 memset(adapter
->pshmem
, 0, sizeof(struct slic_shmem
));
348 static const struct net_device_ops slic_netdev_ops
= {
349 .ndo_open
= slic_entry_open
,
350 .ndo_stop
= slic_entry_halt
,
351 .ndo_start_xmit
= slic_xmit_start
,
352 .ndo_do_ioctl
= slic_ioctl
,
353 .ndo_set_mac_address
= slic_mac_set_address
,
354 .ndo_get_stats
= slic_get_stats
,
355 .ndo_set_multicast_list
= slic_mcast_set_list
,
356 .ndo_validate_addr
= eth_validate_addr
,
357 .ndo_change_mtu
= eth_change_mtu
,
360 static int __devinit
slic_entry_probe(struct pci_dev
*pcidev
,
361 const struct pci_device_id
*pci_tbl_entry
)
363 static int cards_found
;
364 static int did_version
;
366 struct net_device
*netdev
;
367 struct adapter
*adapter
;
368 void __iomem
*memmapped_ioaddr
= NULL
;
370 ulong mmio_start
= 0;
372 struct sliccard
*card
= NULL
;
374 slic_global
.dynamic_intagg
= dynamic_intagg
;
376 err
= pci_enable_device(pcidev
);
381 if (slic_debug
> 0 && did_version
++ == 0) {
382 printk(KERN_DEBUG
"%s\n", slic_banner
);
383 printk(KERN_DEBUG
"%s\n", slic_proc_version
);
386 err
= pci_set_dma_mask(pcidev
, DMA_BIT_MASK(64));
388 err
= pci_set_dma_mask(pcidev
, DMA_BIT_MASK(32));
390 goto err_out_disable_pci
;
393 err
= pci_request_regions(pcidev
, DRV_NAME
);
395 goto err_out_disable_pci
;
397 pci_set_master(pcidev
);
399 netdev
= alloc_etherdev(sizeof(struct adapter
));
402 goto err_out_exit_slic_probe
;
405 SET_NETDEV_DEV(netdev
, &pcidev
->dev
);
407 pci_set_drvdata(pcidev
, netdev
);
408 adapter
= netdev_priv(netdev
);
409 adapter
->netdev
= netdev
;
410 adapter
->pcidev
= pcidev
;
412 mmio_start
= pci_resource_start(pcidev
, 0);
413 mmio_len
= pci_resource_len(pcidev
, 0);
416 /* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/
417 memmapped_ioaddr
= ioremap(mmio_start
, mmio_len
);
418 if (!memmapped_ioaddr
) {
419 dev_err(&pcidev
->dev
, "cannot remap MMIO region %lx @ %lx\n",
420 mmio_len
, mmio_start
);
421 goto err_out_free_netdev
;
424 slic_config_pci(pcidev
);
428 slic_init_adapter(netdev
,
429 pcidev
, pci_tbl_entry
, memmapped_ioaddr
, cards_found
);
431 status
= slic_card_locate(adapter
);
433 dev_err(&pcidev
->dev
, "cannot locate card\n");
434 goto err_out_free_mmio_region
;
437 card
= adapter
->card
;
439 if (!adapter
->allocated
) {
440 card
->adapters_allocated
++;
441 adapter
->allocated
= 1;
444 status
= slic_card_init(card
, adapter
);
446 if (status
!= STATUS_SUCCESS
) {
447 card
->state
= CARD_FAIL
;
448 adapter
->state
= ADAPT_FAIL
;
449 adapter
->linkstate
= LINK_DOWN
;
450 dev_err(&pcidev
->dev
, "FAILED status[%x]\n", status
);
452 slic_adapter_set_hwaddr(adapter
);
455 netdev
->base_addr
= (unsigned long)adapter
->memorybase
;
456 netdev
->irq
= adapter
->irq
;
457 netdev
->netdev_ops
= &slic_netdev_ops
;
459 slic_debug_adapter_create(adapter
);
461 strcpy(netdev
->name
, "eth%d");
462 err
= register_netdev(netdev
);
464 dev_err(&pcidev
->dev
, "Cannot register net device, aborting.\n");
473 iounmap(memmapped_ioaddr
);
474 err_out_free_mmio_region
:
475 release_mem_region(mmio_start
, mmio_len
);
478 err_out_exit_slic_probe
:
479 pci_release_regions(pcidev
);
481 pci_disable_device(pcidev
);
485 static int slic_entry_open(struct net_device
*dev
)
487 struct adapter
*adapter
= (struct adapter
*) netdev_priv(dev
);
488 struct sliccard
*card
= adapter
->card
;
495 netif_stop_queue(adapter
->netdev
);
497 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
498 slic_global
.driver_lock
.flags
);
500 if (!adapter
->activated
) {
501 card
->adapters_activated
++;
502 slic_global
.num_slic_ports_active
++;
503 adapter
->activated
= 1;
505 status
= slic_if_init(adapter
);
507 if (status
!= STATUS_SUCCESS
) {
508 if (adapter
->activated
) {
509 card
->adapters_activated
--;
510 slic_global
.num_slic_ports_active
--;
511 adapter
->activated
= 0;
514 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
515 slic_global
.driver_lock
.flags
);
521 card
->master
= adapter
;
524 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
525 slic_global
.driver_lock
.flags
);
529 return STATUS_SUCCESS
;
532 static void __devexit
slic_entry_remove(struct pci_dev
*pcidev
)
534 struct net_device
*dev
= pci_get_drvdata(pcidev
);
537 struct adapter
*adapter
= (struct adapter
*) netdev_priv(dev
);
538 struct sliccard
*card
;
539 struct mcast_address
*mcaddr
, *mlist
;
542 slic_adapter_freeresources(adapter
);
543 slic_unmap_mmio_space(adapter
);
544 unregister_netdev(dev
);
546 mmio_start
= pci_resource_start(pcidev
, 0);
547 mmio_len
= pci_resource_len(pcidev
, 0);
549 release_mem_region(mmio_start
, mmio_len
);
551 iounmap((void __iomem
*)dev
->base_addr
);
552 /* free multicast addresses */
553 mlist
= adapter
->mcastaddrs
;
559 ASSERT(adapter
->card
);
560 card
= adapter
->card
;
561 ASSERT(card
->adapters_allocated
);
562 card
->adapters_allocated
--;
563 adapter
->allocated
= 0;
564 if (!card
->adapters_allocated
) {
565 struct sliccard
*curr_card
= slic_global
.slic_card
;
566 if (curr_card
== card
) {
567 slic_global
.slic_card
= card
->next
;
569 while (curr_card
->next
!= card
)
570 curr_card
= curr_card
->next
;
572 curr_card
->next
= card
->next
;
574 ASSERT(slic_global
.num_slic_cards
);
575 slic_global
.num_slic_cards
--;
576 slic_card_cleanup(card
);
579 pci_release_regions(pcidev
);
582 static int slic_entry_halt(struct net_device
*dev
)
584 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
585 struct sliccard
*card
= adapter
->card
;
586 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
588 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
589 slic_global
.driver_lock
.flags
);
591 netif_stop_queue(adapter
->netdev
);
592 adapter
->state
= ADAPT_DOWN
;
593 adapter
->linkstate
= LINK_DOWN
;
594 adapter
->upr_list
= NULL
;
595 adapter
->upr_busy
= 0;
596 adapter
->devflags_prev
= 0;
597 ASSERT(card
->adapter
[adapter
->cardindex
] == adapter
);
598 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
599 adapter
->all_reg_writes
++;
600 adapter
->icr_reg_writes
++;
601 slic_config_clear(adapter
);
602 if (adapter
->activated
) {
603 card
->adapters_activated
--;
604 slic_global
.num_slic_ports_active
--;
605 adapter
->activated
= 0;
607 #ifdef AUTOMATIC_RESET
608 slic_reg32_write(&slic_regs
->slic_reset_iface
, 0, FLUSH
);
611 * Reset the adapter's cmd queues
613 slic_cmdq_reset(adapter
);
615 #ifdef AUTOMATIC_RESET
616 if (!card
->adapters_activated
)
617 slic_card_init(card
, adapter
);
620 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
621 slic_global
.driver_lock
.flags
);
622 return STATUS_SUCCESS
;
625 static int slic_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
627 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
628 struct ethtool_cmd edata
;
629 struct ethtool_cmd ecmd
;
635 case SIOCSLICSETINTAGG
:
636 if (copy_from_user(data
, rq
->ifr_data
, 28))
639 dev_err(&dev
->dev
, "%s: set interrupt aggregation to %d\n",
641 slic_intagg_set(adapter
, intagg
);
644 #ifdef SLIC_TRACE_DUMP_ENABLED
645 case SIOCSLICTRACEDUMP
:
648 DBG_IOCTL("slic_ioctl SIOCSLIC_TRACE_DUMP\n");
650 if (copy_from_user(data
, rq
->ifr_data
, 28)) {
652 ("slic: copy_from_user FAILED getting \
653 initial simba param\n");
658 if (tracemon_request
== SLIC_DUMP_DONE
) {
660 ("ATK Diagnostic Trace Dump Requested\n");
661 tracemon_request
= SLIC_DUMP_REQUESTED
;
662 tracemon_request_type
= value
;
663 tracemon_timestamp
= jiffies
;
664 } else if ((tracemon_request
== SLIC_DUMP_REQUESTED
) ||
666 SLIC_DUMP_IN_PROGRESS
)) {
668 ("ATK Diagnostic Trace Dump Requested but \
669 already in progress... ignore\n");
672 ("ATK Diagnostic Trace Dump Requested\n");
673 tracemon_request
= SLIC_DUMP_REQUESTED
;
674 tracemon_request_type
= value
;
675 tracemon_timestamp
= jiffies
;
682 if (copy_from_user(&ecmd
, rq
->ifr_data
, sizeof(ecmd
)))
685 if (ecmd
.cmd
== ETHTOOL_GSET
) {
686 edata
.supported
= (SUPPORTED_10baseT_Half
|
687 SUPPORTED_10baseT_Full
|
688 SUPPORTED_100baseT_Half
|
689 SUPPORTED_100baseT_Full
|
690 SUPPORTED_Autoneg
| SUPPORTED_MII
);
691 edata
.port
= PORT_MII
;
692 edata
.transceiver
= XCVR_INTERNAL
;
693 edata
.phy_address
= 0;
694 if (adapter
->linkspeed
== LINK_100MB
)
695 edata
.speed
= SPEED_100
;
696 else if (adapter
->linkspeed
== LINK_10MB
)
697 edata
.speed
= SPEED_10
;
701 if (adapter
->linkduplex
== LINK_FULLD
)
702 edata
.duplex
= DUPLEX_FULL
;
704 edata
.duplex
= DUPLEX_HALF
;
706 edata
.autoneg
= AUTONEG_ENABLE
;
709 if (copy_to_user(rq
->ifr_data
, &edata
, sizeof(edata
)))
712 } else if (ecmd
.cmd
== ETHTOOL_SSET
) {
713 if (!capable(CAP_NET_ADMIN
))
716 if (adapter
->linkspeed
== LINK_100MB
)
717 edata
.speed
= SPEED_100
;
718 else if (adapter
->linkspeed
== LINK_10MB
)
719 edata
.speed
= SPEED_10
;
723 if (adapter
->linkduplex
== LINK_FULLD
)
724 edata
.duplex
= DUPLEX_FULL
;
726 edata
.duplex
= DUPLEX_HALF
;
728 edata
.autoneg
= AUTONEG_ENABLE
;
731 if ((ecmd
.speed
!= edata
.speed
) ||
732 (ecmd
.duplex
!= edata
.duplex
)) {
736 if (ecmd
.speed
== SPEED_10
)
739 speed
= PCR_SPEED_100
;
740 if (ecmd
.duplex
== DUPLEX_FULL
)
741 duplex
= PCR_DUPLEX_FULL
;
744 slic_link_config(adapter
, speed
, duplex
);
745 slic_link_event_handler(adapter
);
754 #define XMIT_FAIL_LINK_STATE 1
755 #define XMIT_FAIL_ZERO_LENGTH 2
756 #define XMIT_FAIL_HOSTCMD_FAIL 3
758 static void slic_xmit_build_request(struct adapter
*adapter
,
759 struct slic_hostcmd
*hcmd
, struct sk_buff
*skb
)
761 struct slic_host64_cmd
*ihcmd
;
764 ihcmd
= &hcmd
->cmd64
;
766 ihcmd
->flags
= (adapter
->port
<< IHFLG_IFSHFT
);
767 ihcmd
->command
= IHCMD_XMT_REQ
;
768 ihcmd
->u
.slic_buffers
.totlen
= skb
->len
;
769 phys_addr
= pci_map_single(adapter
->pcidev
, skb
->data
, skb
->len
,
771 ihcmd
->u
.slic_buffers
.bufs
[0].paddrl
= SLIC_GET_ADDR_LOW(phys_addr
);
772 ihcmd
->u
.slic_buffers
.bufs
[0].paddrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
773 ihcmd
->u
.slic_buffers
.bufs
[0].length
= skb
->len
;
774 #if defined(CONFIG_X86_64)
775 hcmd
->cmdsize
= (u32
) ((((u64
)&ihcmd
->u
.slic_buffers
.bufs
[1] -
776 (u64
) hcmd
) + 31) >> 5);
777 #elif defined(CONFIG_X86)
778 hcmd
->cmdsize
= ((((u32
) &ihcmd
->u
.slic_buffers
.bufs
[1] -
779 (u32
) hcmd
) + 31) >> 5);
785 #define NORMAL_ETHFRAME 0
787 static int slic_xmit_start(struct sk_buff
*skb
, struct net_device
*dev
)
789 struct sliccard
*card
;
790 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
791 struct slic_hostcmd
*hcmd
= NULL
;
793 u32 skbtype
= NORMAL_ETHFRAME
;
794 void *offloadcmd
= NULL
;
796 card
= adapter
->card
;
798 if ((adapter
->linkstate
!= LINK_UP
) ||
799 (adapter
->state
!= ADAPT_UP
) || (card
->state
!= CARD_UP
)) {
800 status
= XMIT_FAIL_LINK_STATE
;
803 } else if (skb
->len
== 0) {
804 status
= XMIT_FAIL_ZERO_LENGTH
;
808 if (skbtype
== NORMAL_ETHFRAME
) {
809 hcmd
= slic_cmdq_getfree(adapter
);
811 adapter
->xmitq_full
= 1;
812 status
= XMIT_FAIL_HOSTCMD_FAIL
;
815 ASSERT(hcmd
->pslic_handle
);
816 ASSERT(hcmd
->cmd64
.hosthandle
==
817 hcmd
->pslic_handle
->token
.handle_token
);
820 hcmd
->type
= SLIC_CMD_DUMB
;
821 if (skbtype
== NORMAL_ETHFRAME
)
822 slic_xmit_build_request(adapter
, hcmd
, skb
);
824 adapter
->stats
.tx_packets
++;
825 adapter
->stats
.tx_bytes
+= skb
->len
;
828 if (adapter
->kill_card
) {
829 struct slic_host64_cmd ihcmd
;
831 ihcmd
= &hcmd
->cmd64
;
833 ihcmd
->flags
|= 0x40;
834 adapter
->kill_card
= 0; /* only do this once */
837 if (hcmd
->paddrh
== 0) {
838 slic_reg32_write(&adapter
->slic_regs
->slic_cbar
,
839 (hcmd
->paddrl
| hcmd
->cmdsize
), DONT_FLUSH
);
841 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_cbar64
,
842 (hcmd
->paddrl
| hcmd
->cmdsize
),
843 &adapter
->slic_regs
->slic_addr_upper
,
844 hcmd
->paddrh
, DONT_FLUSH
);
849 slic_xmit_fail(adapter
, skb
, offloadcmd
, skbtype
, status
);
853 static void slic_xmit_fail(struct adapter
*adapter
,
855 void *cmd
, u32 skbtype
, u32 status
)
857 if (adapter
->xmitq_full
)
858 netif_stop_queue(adapter
->netdev
);
859 if ((cmd
== NULL
) && (status
<= XMIT_FAIL_HOSTCMD_FAIL
)) {
861 case XMIT_FAIL_LINK_STATE
:
862 dev_err(&adapter
->netdev
->dev
,
863 "reject xmit skb[%p: %x] linkstate[%s] "
864 "adapter[%s:%d] card[%s:%d]\n",
866 SLIC_LINKSTATE(adapter
->linkstate
),
867 SLIC_ADAPTER_STATE(adapter
->state
),
869 SLIC_CARD_STATE(adapter
->card
->state
),
870 adapter
->card
->state
);
872 case XMIT_FAIL_ZERO_LENGTH
:
873 dev_err(&adapter
->netdev
->dev
,
874 "xmit_start skb->len == 0 skb[%p] type[%x]\n",
877 case XMIT_FAIL_HOSTCMD_FAIL
:
878 dev_err(&adapter
->netdev
->dev
,
879 "xmit_start skb[%p] type[%x] No host commands "
880 "available\n", skb
, skb
->pkt_type
);
887 adapter
->stats
.tx_dropped
++;
890 static void slic_rcv_handle_error(struct adapter
*adapter
,
891 struct slic_rcvbuf
*rcvbuf
)
893 struct slic_hddr_wds
*hdr
= (struct slic_hddr_wds
*)rcvbuf
->data
;
895 if (adapter
->devid
!= SLIC_1GB_DEVICE_ID
) {
896 if (hdr
->frame_status14
& VRHSTAT_802OE
)
897 adapter
->if_events
.oflow802
++;
898 if (hdr
->frame_status14
& VRHSTAT_TPOFLO
)
899 adapter
->if_events
.Tprtoflow
++;
900 if (hdr
->frame_status_b14
& VRHSTATB_802UE
)
901 adapter
->if_events
.uflow802
++;
902 if (hdr
->frame_status_b14
& VRHSTATB_RCVE
) {
903 adapter
->if_events
.rcvearly
++;
904 adapter
->stats
.rx_fifo_errors
++;
906 if (hdr
->frame_status_b14
& VRHSTATB_BUFF
) {
907 adapter
->if_events
.Bufov
++;
908 adapter
->stats
.rx_over_errors
++;
910 if (hdr
->frame_status_b14
& VRHSTATB_CARRE
) {
911 adapter
->if_events
.Carre
++;
912 adapter
->stats
.tx_carrier_errors
++;
914 if (hdr
->frame_status_b14
& VRHSTATB_LONGE
)
915 adapter
->if_events
.Longe
++;
916 if (hdr
->frame_status_b14
& VRHSTATB_PREA
)
917 adapter
->if_events
.Invp
++;
918 if (hdr
->frame_status_b14
& VRHSTATB_CRC
) {
919 adapter
->if_events
.Crc
++;
920 adapter
->stats
.rx_crc_errors
++;
922 if (hdr
->frame_status_b14
& VRHSTATB_DRBL
)
923 adapter
->if_events
.Drbl
++;
924 if (hdr
->frame_status_b14
& VRHSTATB_CODE
)
925 adapter
->if_events
.Code
++;
926 if (hdr
->frame_status_b14
& VRHSTATB_TPCSUM
)
927 adapter
->if_events
.TpCsum
++;
928 if (hdr
->frame_status_b14
& VRHSTATB_TPHLEN
)
929 adapter
->if_events
.TpHlen
++;
930 if (hdr
->frame_status_b14
& VRHSTATB_IPCSUM
)
931 adapter
->if_events
.IpCsum
++;
932 if (hdr
->frame_status_b14
& VRHSTATB_IPLERR
)
933 adapter
->if_events
.IpLen
++;
934 if (hdr
->frame_status_b14
& VRHSTATB_IPHERR
)
935 adapter
->if_events
.IpHlen
++;
937 if (hdr
->frame_statusGB
& VGBSTAT_XPERR
) {
938 u32 xerr
= hdr
->frame_statusGB
>> VGBSTAT_XERRSHFT
;
940 if (xerr
== VGBSTAT_XCSERR
)
941 adapter
->if_events
.TpCsum
++;
942 if (xerr
== VGBSTAT_XUFLOW
)
943 adapter
->if_events
.Tprtoflow
++;
944 if (xerr
== VGBSTAT_XHLEN
)
945 adapter
->if_events
.TpHlen
++;
947 if (hdr
->frame_statusGB
& VGBSTAT_NETERR
) {
950 frame_statusGB
>> VGBSTAT_NERRSHFT
) &
952 if (nerr
== VGBSTAT_NCSERR
)
953 adapter
->if_events
.IpCsum
++;
954 if (nerr
== VGBSTAT_NUFLOW
)
955 adapter
->if_events
.IpLen
++;
956 if (nerr
== VGBSTAT_NHLEN
)
957 adapter
->if_events
.IpHlen
++;
959 if (hdr
->frame_statusGB
& VGBSTAT_LNKERR
) {
960 u32 lerr
= hdr
->frame_statusGB
& VGBSTAT_LERRMSK
;
962 if (lerr
== VGBSTAT_LDEARLY
)
963 adapter
->if_events
.rcvearly
++;
964 if (lerr
== VGBSTAT_LBOFLO
)
965 adapter
->if_events
.Bufov
++;
966 if (lerr
== VGBSTAT_LCODERR
)
967 adapter
->if_events
.Code
++;
968 if (lerr
== VGBSTAT_LDBLNBL
)
969 adapter
->if_events
.Drbl
++;
970 if (lerr
== VGBSTAT_LCRCERR
)
971 adapter
->if_events
.Crc
++;
972 if (lerr
== VGBSTAT_LOFLO
)
973 adapter
->if_events
.oflow802
++;
974 if (lerr
== VGBSTAT_LUFLO
)
975 adapter
->if_events
.uflow802
++;
981 #define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000
982 #define M_FAST_PATH 0x0040
984 static void slic_rcv_handler(struct adapter
*adapter
)
987 struct slic_rcvbuf
*rcvbuf
;
990 while ((skb
= slic_rcvqueue_getnext(adapter
))) {
994 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
995 adapter
->card
->events
++;
996 if (rcvbuf
->status
& IRHDDR_ERR
) {
997 adapter
->rx_errors
++;
998 slic_rcv_handle_error(adapter
, rcvbuf
);
999 slic_rcvqueue_reinsert(adapter
, skb
);
1003 if (!slic_mac_filter(adapter
, (struct ether_header
*)
1005 slic_rcvqueue_reinsert(adapter
, skb
);
1008 skb_pull(skb
, SLIC_RCVBUF_HEADSIZE
);
1009 rx_bytes
= (rcvbuf
->length
& IRHDDR_FLEN_MSK
);
1010 skb_put(skb
, rx_bytes
);
1011 adapter
->stats
.rx_packets
++;
1012 adapter
->stats
.rx_bytes
+= rx_bytes
;
1013 #if SLIC_OFFLOAD_IP_CHECKSUM
1014 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1017 skb
->dev
= adapter
->netdev
;
1018 skb
->protocol
= eth_type_trans(skb
, skb
->dev
);
1022 #if SLIC_INTERRUPT_PROCESS_LIMIT
1023 if (frames
>= SLIC_RCVQ_MAX_PROCESS_ISR
) {
1024 adapter
->rcv_interrupt_yields
++;
1029 adapter
->max_isr_rcvs
= max(adapter
->max_isr_rcvs
, frames
);
1032 static void slic_xmit_complete(struct adapter
*adapter
)
1034 struct slic_hostcmd
*hcmd
;
1035 struct slic_rspbuf
*rspbuf
;
1037 struct slic_handle_word slic_handle_word
;
1040 rspbuf
= slic_rspqueue_getnext(adapter
);
1043 adapter
->xmit_completes
++;
1044 adapter
->card
->events
++;
1046 Get the complete host command buffer
1048 slic_handle_word
.handle_token
= rspbuf
->hosthandle
;
1049 ASSERT(slic_handle_word
.handle_index
);
1050 ASSERT(slic_handle_word
.handle_index
<= SLIC_CMDQ_MAXCMDS
);
1052 (struct slic_hostcmd
*)
1053 adapter
->slic_handles
[slic_handle_word
.handle_index
].
1055 /* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
1057 ASSERT(hcmd
->pslic_handle
==
1058 &adapter
->slic_handles
[slic_handle_word
.handle_index
]);
1059 if (hcmd
->type
== SLIC_CMD_DUMB
) {
1061 dev_kfree_skb_irq(hcmd
->skb
);
1062 slic_cmdq_putdone_irq(adapter
, hcmd
);
1065 rspbuf
->hosthandle
= 0;
1068 adapter
->max_isr_xmits
= max(adapter
->max_isr_xmits
, frames
);
1071 static irqreturn_t
slic_interrupt(int irq
, void *dev_id
)
1073 struct net_device
*dev
= (struct net_device
*)dev_id
;
1074 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
1077 if ((adapter
->pshmem
) && (adapter
->pshmem
->isr
)) {
1078 slic_reg32_write(&adapter
->slic_regs
->slic_icr
,
1079 ICR_INT_MASK
, FLUSH
);
1080 isr
= adapter
->isrcopy
= adapter
->pshmem
->isr
;
1081 adapter
->pshmem
->isr
= 0;
1082 adapter
->num_isrs
++;
1083 switch (adapter
->card
->state
) {
1085 if (isr
& ~ISR_IO
) {
1086 if (isr
& ISR_ERR
) {
1087 adapter
->error_interrupts
++;
1088 if (isr
& ISR_RMISS
) {
1093 struct slic_rcvqueue
*rcvq
=
1097 error_rmiss_interrupts
++;
1099 rcv_count
= rcvq
->count
;
1100 pre_count
= rcvq
->count
;
1101 errors
= rcvq
->errors
;
1103 while (rcvq
->count
<
1104 SLIC_RCVQ_FILLTHRESH
) {
1111 } else if (isr
& ISR_XDROP
) {
1113 "isr & ISR_ERR [%x] "
1114 "ISR_XDROP \n", isr
);
1117 "isr & ISR_ERR [%x]\n",
1122 if (isr
& ISR_LEVENT
) {
1123 adapter
->linkevent_interrupts
++;
1124 slic_link_event_handler(adapter
);
1127 if ((isr
& ISR_UPC
) ||
1128 (isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
1129 adapter
->upr_interrupts
++;
1130 slic_upr_request_complete(adapter
, isr
);
1134 if (isr
& ISR_RCV
) {
1135 adapter
->rcv_interrupts
++;
1136 slic_rcv_handler(adapter
);
1139 if (isr
& ISR_CMD
) {
1140 adapter
->xmit_interrupts
++;
1141 slic_xmit_complete(adapter
);
1146 if ((isr
& ISR_UPC
) ||
1147 (isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
1148 adapter
->upr_interrupts
++;
1149 slic_upr_request_complete(adapter
, isr
);
1157 adapter
->isrcopy
= 0;
1158 adapter
->all_reg_writes
+= 2;
1159 adapter
->isr_reg_writes
++;
1160 slic_reg32_write(&adapter
->slic_regs
->slic_isr
, 0, FLUSH
);
1162 adapter
->false_interrupts
++;
1168 * slic_link_event_handler -
1170 * Initiate a link configuration sequence. The link configuration begins
1171 * by issuing a READ_LINK_STATUS command to the Utility Processor on the
1172 * SLIC. Since the command finishes asynchronously, the slic_upr_comlete
1173 * routine will follow it up witha UP configuration write command, which
1174 * will also complete asynchronously.
1177 static void slic_link_event_handler(struct adapter
*adapter
)
1180 struct slic_shmem
*pshmem
;
1182 if (adapter
->state
!= ADAPT_UP
) {
1183 /* Adapter is not operational. Ignore. */
1187 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
1189 #if defined(CONFIG_X86_64)
1190 status
= slic_upr_request(adapter
,
1192 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
1193 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
1195 #elif defined(CONFIG_X86)
1196 status
= slic_upr_request(adapter
, SLIC_UPR_RLSR
,
1197 (u32
) &pshmem
->linkstatus
, /* no 4GB wrap guaranteed */
1202 ASSERT((status
== STATUS_SUCCESS
) || (status
== STATUS_PENDING
));
1205 static void slic_init_cleanup(struct adapter
*adapter
)
1207 if (adapter
->intrregistered
) {
1208 adapter
->intrregistered
= 0;
1209 free_irq(adapter
->netdev
->irq
, adapter
->netdev
);
1212 if (adapter
->pshmem
) {
1213 pci_free_consistent(adapter
->pcidev
,
1214 sizeof(struct slic_shmem
),
1215 adapter
->pshmem
, adapter
->phys_shmem
);
1216 adapter
->pshmem
= NULL
;
1217 adapter
->phys_shmem
= (dma_addr_t
) NULL
;
1220 if (adapter
->pingtimerset
) {
1221 adapter
->pingtimerset
= 0;
1222 del_timer(&adapter
->pingtimer
);
1225 slic_rspqueue_free(adapter
);
1226 slic_cmdq_free(adapter
);
1227 slic_rcvqueue_free(adapter
);
1230 static struct net_device_stats
*slic_get_stats(struct net_device
*dev
)
1232 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
1233 struct net_device_stats
*stats
;
1236 stats
= &adapter
->stats
;
1237 stats
->collisions
= adapter
->slic_stats
.iface
.xmit_collisions
;
1238 stats
->rx_errors
= adapter
->slic_stats
.iface
.rcv_errors
;
1239 stats
->tx_errors
= adapter
->slic_stats
.iface
.xmt_errors
;
1240 stats
->rx_missed_errors
= adapter
->slic_stats
.iface
.rcv_discards
;
1241 stats
->tx_heartbeat_errors
= 0;
1242 stats
->tx_aborted_errors
= 0;
1243 stats
->tx_window_errors
= 0;
1244 stats
->tx_fifo_errors
= 0;
1245 stats
->rx_frame_errors
= 0;
1246 stats
->rx_length_errors
= 0;
1247 return &adapter
->stats
;
1251 * Allocate a mcast_address structure to hold the multicast address.
1254 static int slic_mcast_add_list(struct adapter
*adapter
, char *address
)
1256 struct mcast_address
*mcaddr
, *mlist
;
1259 /* Check to see if it already exists */
1260 mlist
= adapter
->mcastaddrs
;
1262 ETHER_EQ_ADDR(mlist
->address
, address
, equaladdr
);
1264 return STATUS_SUCCESS
;
1265 mlist
= mlist
->next
;
1268 /* Doesn't already exist. Allocate a structure to hold it */
1269 mcaddr
= kmalloc(sizeof(struct mcast_address
), GFP_ATOMIC
);
1273 memcpy(mcaddr
->address
, address
, 6);
1275 mcaddr
->next
= adapter
->mcastaddrs
;
1276 adapter
->mcastaddrs
= mcaddr
;
1278 return STATUS_SUCCESS
;
1282 * Functions to obtain the CRC corresponding to the destination mac address.
1283 * This is a standard ethernet CRC in that it is a 32-bit, reflected CRC using
1285 * x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 +
1288 * After the CRC for the 6 bytes is generated (but before the value is
1290 * we must then transpose the value and return bits 30-23.
1293 static u32 slic_crc_table
[256]; /* Table of CRCs for all possible byte values */
1294 static u32 slic_crc_init
; /* Is table initialized */
1297 * Contruct the CRC32 table
1299 static void slic_mcast_init_crc32(void)
1301 u32 c
; /* CRC shit reg */
1302 u32 e
= 0; /* Poly X-or pattern */
1303 int i
; /* counter */
1304 int k
; /* byte being shifted into crc */
1306 static int p
[] = { 0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26 };
1308 for (i
= 0; i
< ARRAY_SIZE(p
); i
++)
1309 e
|= 1L << (31 - p
[i
]);
1311 for (i
= 1; i
< 256; i
++) {
1314 c
= c
& 1 ? (c
>> 1) ^ e
: c
>> 1;
1315 slic_crc_table
[i
] = c
;
1320 * Return the MAC hast as described above.
1322 static unsigned char slic_mcast_get_mac_hash(char *macaddr
)
1327 unsigned char machash
= 0;
1329 if (!slic_crc_init
) {
1330 slic_mcast_init_crc32();
1334 crc
= 0xFFFFFFFF; /* Preload shift register, per crc-32 spec */
1335 for (i
= 0, p
= macaddr
; i
< 6; ++p
, ++i
)
1336 crc
= (crc
>> 8) ^ slic_crc_table
[(crc
^ *p
) & 0xFF];
1338 /* Return bits 1-8, transposed */
1339 for (i
= 1; i
< 9; i
++)
1340 machash
|= (((crc
>> i
) & 1) << (8 - i
));
1345 static void slic_mcast_set_bit(struct adapter
*adapter
, char *address
)
1347 unsigned char crcpoly
;
1349 /* Get the CRC polynomial for the mac address */
1350 crcpoly
= slic_mcast_get_mac_hash(address
);
1352 /* We only have space on the SLIC for 64 entries. Lop
1353 * off the top two bits. (2^6 = 64)
1357 /* OR in the new bit into our 64 bit mask. */
1358 adapter
->mcastmask
|= (u64
) 1 << crcpoly
;
1361 static void slic_mcast_set_list(struct net_device
*dev
)
1363 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
1364 int status
= STATUS_SUCCESS
;
1367 struct dev_mc_list
*mc_list
= dev
->mc_list
;
1368 int mc_count
= dev
->mc_count
;
1372 for (i
= 1; i
<= mc_count
; i
++) {
1373 addresses
= (char *) &mc_list
->dmi_addr
;
1374 if (mc_list
->dmi_addrlen
== 6) {
1375 status
= slic_mcast_add_list(adapter
, addresses
);
1376 if (status
!= STATUS_SUCCESS
)
1382 slic_mcast_set_bit(adapter
, addresses
);
1383 mc_list
= mc_list
->next
;
1386 if (adapter
->devflags_prev
!= dev
->flags
) {
1387 adapter
->macopts
= MAC_DIRECTED
;
1389 if (dev
->flags
& IFF_BROADCAST
)
1390 adapter
->macopts
|= MAC_BCAST
;
1391 if (dev
->flags
& IFF_PROMISC
)
1392 adapter
->macopts
|= MAC_PROMISC
;
1393 if (dev
->flags
& IFF_ALLMULTI
)
1394 adapter
->macopts
|= MAC_ALLMCAST
;
1395 if (dev
->flags
& IFF_MULTICAST
)
1396 adapter
->macopts
|= MAC_MCAST
;
1398 adapter
->devflags_prev
= dev
->flags
;
1399 slic_config_set(adapter
, true);
1401 if (status
== STATUS_SUCCESS
)
1402 slic_mcast_set_mask(adapter
);
1407 static void slic_mcast_set_mask(struct adapter
*adapter
)
1409 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1411 if (adapter
->macopts
& (MAC_ALLMCAST
| MAC_PROMISC
)) {
1412 /* Turn on all multicast addresses. We have to do this for
1413 * promiscuous mode as well as ALLMCAST mode. It saves the
1414 * Microcode from having to keep state about the MAC
1417 slic_reg32_write(&slic_regs
->slic_mcastlow
, 0xFFFFFFFF, FLUSH
);
1418 slic_reg32_write(&slic_regs
->slic_mcasthigh
, 0xFFFFFFFF,
1421 /* Commit our multicast mast to the SLIC by writing to the
1422 * multicast address mask registers
1424 slic_reg32_write(&slic_regs
->slic_mcastlow
,
1425 (u32
)(adapter
->mcastmask
& 0xFFFFFFFF), FLUSH
);
1426 slic_reg32_write(&slic_regs
->slic_mcasthigh
,
1427 (u32
)((adapter
->mcastmask
>> 32) & 0xFFFFFFFF), FLUSH
);
1431 static void slic_timer_ping(ulong dev
)
1433 struct adapter
*adapter
;
1434 struct sliccard
*card
;
1437 adapter
= netdev_priv((struct net_device
*)dev
);
1439 card
= adapter
->card
;
1442 adapter
->pingtimer
.expires
= jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
1443 add_timer(&adapter
->pingtimer
);
1449 * Perform initialization of our slic interface.
1452 static int slic_if_init(struct adapter
*adapter
)
1454 struct sliccard
*card
= adapter
->card
;
1455 struct net_device
*dev
= adapter
->netdev
;
1456 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1457 struct slic_shmem
*pshmem
;
1462 /* adapter should be down at this point */
1463 if (adapter
->state
!= ADAPT_DOWN
) {
1464 dev_err(&dev
->dev
, "%s: adapter->state != ADAPT_DOWN\n",
1468 ASSERT(adapter
->linkstate
== LINK_DOWN
);
1470 adapter
->devflags_prev
= dev
->flags
;
1471 adapter
->macopts
= MAC_DIRECTED
;
1473 if (dev
->flags
& IFF_BROADCAST
)
1474 adapter
->macopts
|= MAC_BCAST
;
1475 if (dev
->flags
& IFF_PROMISC
)
1476 adapter
->macopts
|= MAC_PROMISC
;
1477 if (dev
->flags
& IFF_ALLMULTI
)
1478 adapter
->macopts
|= MAC_ALLMCAST
;
1479 if (dev
->flags
& IFF_MULTICAST
)
1480 adapter
->macopts
|= MAC_MCAST
;
1482 status
= slic_adapter_allocresources(adapter
);
1483 if (status
!= STATUS_SUCCESS
) {
1485 "%s: slic_adapter_allocresources FAILED %x\n",
1487 slic_adapter_freeresources(adapter
);
1491 if (!adapter
->queues_initialized
) {
1492 if (slic_rspqueue_init(adapter
))
1494 if (slic_cmdq_init(adapter
))
1496 if (slic_rcvqueue_init(adapter
))
1498 adapter
->queues_initialized
= 1;
1501 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
1504 if (!adapter
->isp_initialized
) {
1505 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
1507 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
1508 adapter
->bit64reglock
.flags
);
1510 #if defined(CONFIG_X86_64)
1511 slic_reg32_write(&slic_regs
->slic_addr_upper
,
1512 SLIC_GET_ADDR_HIGH(&pshmem
->isr
), DONT_FLUSH
);
1513 slic_reg32_write(&slic_regs
->slic_isp
,
1514 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
1515 #elif defined(CONFIG_X86)
1516 slic_reg32_write(&slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
1517 slic_reg32_write(&slic_regs
->slic_isp
, (u32
)&pshmem
->isr
, FLUSH
);
1521 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
1522 adapter
->bit64reglock
.flags
);
1523 adapter
->isp_initialized
= 1;
1526 adapter
->state
= ADAPT_UP
;
1527 if (!card
->loadtimerset
) {
1528 init_timer(&card
->loadtimer
);
1529 card
->loadtimer
.expires
=
1530 jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
1531 card
->loadtimer
.data
= (ulong
) card
;
1532 card
->loadtimer
.function
= &slic_timer_load_check
;
1533 add_timer(&card
->loadtimer
);
1535 card
->loadtimerset
= 1;
1538 if (!adapter
->pingtimerset
) {
1539 init_timer(&adapter
->pingtimer
);
1540 adapter
->pingtimer
.expires
=
1541 jiffies
+ (PING_TIMER_INTERVAL
* HZ
);
1542 adapter
->pingtimer
.data
= (ulong
) dev
;
1543 adapter
->pingtimer
.function
= &slic_timer_ping
;
1544 add_timer(&adapter
->pingtimer
);
1545 adapter
->pingtimerset
= 1;
1546 adapter
->card
->pingstatus
= ISR_PINGMASK
;
1550 * clear any pending events, then enable interrupts
1552 adapter
->isrcopy
= 0;
1553 adapter
->pshmem
->isr
= 0;
1554 slic_reg32_write(&slic_regs
->slic_isr
, 0, FLUSH
);
1555 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_ON
, FLUSH
);
1557 slic_link_config(adapter
, LINK_AUTOSPEED
, LINK_AUTOD
);
1558 slic_link_event_handler(adapter
);
1560 return STATUS_SUCCESS
;
1563 static void slic_unmap_mmio_space(struct adapter
*adapter
)
1565 if (adapter
->slic_regs
)
1566 iounmap(adapter
->slic_regs
);
1567 adapter
->slic_regs
= NULL
;
1570 static int slic_adapter_allocresources(struct adapter
*adapter
)
1572 if (!adapter
->intrregistered
) {
1575 spin_unlock_irqrestore(&slic_global
.driver_lock
.lock
,
1576 slic_global
.driver_lock
.flags
);
1578 retval
= request_irq(adapter
->netdev
->irq
,
1581 adapter
->netdev
->name
, adapter
->netdev
);
1583 spin_lock_irqsave(&slic_global
.driver_lock
.lock
,
1584 slic_global
.driver_lock
.flags
);
1587 dev_err(&adapter
->netdev
->dev
,
1588 "request_irq (%s) FAILED [%x]\n",
1589 adapter
->netdev
->name
, retval
);
1592 adapter
->intrregistered
= 1;
1594 return STATUS_SUCCESS
;
1597 static void slic_config_pci(struct pci_dev
*pcidev
)
1602 pci_read_config_word(pcidev
, PCI_COMMAND
, &pci_command
);
1604 new_command
= pci_command
| PCI_COMMAND_MASTER
1605 | PCI_COMMAND_MEMORY
1606 | PCI_COMMAND_INVALIDATE
1607 | PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
| PCI_COMMAND_FAST_BACK
;
1608 if (pci_command
!= new_command
)
1609 pci_write_config_word(pcidev
, PCI_COMMAND
, new_command
);
1612 static void slic_adapter_freeresources(struct adapter
*adapter
)
1614 slic_init_cleanup(adapter
);
1615 memset(&adapter
->stats
, 0, sizeof(struct net_device_stats
));
1616 adapter
->error_interrupts
= 0;
1617 adapter
->rcv_interrupts
= 0;
1618 adapter
->xmit_interrupts
= 0;
1619 adapter
->linkevent_interrupts
= 0;
1620 adapter
->upr_interrupts
= 0;
1621 adapter
->num_isrs
= 0;
1622 adapter
->xmit_completes
= 0;
1623 adapter
->rcv_broadcasts
= 0;
1624 adapter
->rcv_multicasts
= 0;
1625 adapter
->rcv_unicasts
= 0;
1631 * Write phy control to configure link duplex/speed
1634 static void slic_link_config(struct adapter
*adapter
,
1635 u32 linkspeed
, u32 linkduplex
)
1644 if (adapter
->state
!= ADAPT_UP
)
1647 ASSERT((adapter
->devid
== SLIC_1GB_DEVICE_ID
)
1648 || (adapter
->devid
== SLIC_2GB_DEVICE_ID
));
1650 if (linkspeed
> LINK_1000MB
)
1651 linkspeed
= LINK_AUTOSPEED
;
1652 if (linkduplex
> LINK_AUTOD
)
1653 linkduplex
= LINK_AUTOD
;
1655 wphy
= &adapter
->slic_regs
->slic_wphy
;
1657 if ((linkspeed
== LINK_AUTOSPEED
) || (linkspeed
== LINK_1000MB
)) {
1658 if (adapter
->flags
& ADAPT_FLAGS_FIBERMEDIA
) {
1659 /* We've got a fiber gigabit interface, and register
1660 * 4 is different in fiber mode than in copper mode
1663 /* advertise FD only @1000 Mb */
1664 phy_advreg
= (MIICR_REG_4
| (PAR_ADV1000XFD
));
1665 /* enable PAUSE frames */
1666 phy_advreg
|= PAR_ASYMPAUSE_FIBER
;
1667 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
1669 if (linkspeed
== LINK_AUTOSPEED
) {
1670 /* reset phy, enable auto-neg */
1673 (PCR_RESET
| PCR_AUTONEG
|
1675 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1676 } else { /* forced 1000 Mb FD*/
1677 /* power down phy to break link
1678 this may not work) */
1679 phy_config
= (MIICR_REG_PCR
| PCR_POWERDOWN
);
1680 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1681 /* wait, Marvell says 1 sec,
1682 try to get away with 10 ms */
1685 /* disable auto-neg, set speed/duplex,
1686 soft reset phy, powerup */
1689 (PCR_RESET
| PCR_SPEED_1000
|
1691 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1693 } else { /* copper gigabit */
1695 /* Auto-Negotiate or 1000 Mb must be auto negotiated
1696 * We've got a copper gigabit interface, and
1697 * register 4 is different in copper mode than
1700 if (linkspeed
== LINK_AUTOSPEED
) {
1701 /* advertise 10/100 Mb modes */
1704 (PAR_ADV100FD
| PAR_ADV100HD
| PAR_ADV10FD
1707 /* linkspeed == LINK_1000MB -
1708 don't advertise 10/100 Mb modes */
1709 phy_advreg
= MIICR_REG_4
;
1711 /* enable PAUSE frames */
1712 phy_advreg
|= PAR_ASYMPAUSE
;
1713 /* required by the Cicada PHY */
1714 phy_advreg
|= PAR_802_3
;
1715 slic_reg32_write(wphy
, phy_advreg
, FLUSH
);
1716 /* advertise FD only @1000 Mb */
1717 phy_gctlreg
= (MIICR_REG_9
| (PGC_ADV1000FD
));
1718 slic_reg32_write(wphy
, phy_gctlreg
, FLUSH
);
1720 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
1722 enable auto crossover */
1724 (MIICR_REG_16
| (MRV_REG16_XOVERON
));
1725 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1727 /* reset phy, enable auto-neg */
1730 (PCR_RESET
| PCR_AUTONEG
|
1732 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1733 } else { /* it's a Cicada PHY */
1734 /* enable and restart auto-neg (don't reset) */
1737 (PCR_AUTONEG
| PCR_AUTONEG_RST
));
1738 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1743 if (linkspeed
== LINK_10MB
)
1746 speed
= PCR_SPEED_100
;
1747 if (linkduplex
== LINK_HALFD
)
1750 duplex
= PCR_DUPLEX_FULL
;
1752 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
1754 disable auto crossover */
1755 phy_config
= (MIICR_REG_16
| (MRV_REG16_XOVEROFF
));
1756 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1759 /* power down phy to break link (this may not work) */
1760 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
| speed
| duplex
));
1761 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1763 /* wait, Marvell says 1 sec, try to get away with 10 ms */
1766 if (adapter
->subsysid
!= SLIC_1GB_CICADA_SUBSYS_ID
) {
1768 disable auto-neg, set speed,
1769 soft reset phy, powerup */
1771 (MIICR_REG_PCR
| (PCR_RESET
| speed
| duplex
));
1772 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1773 } else { /* it's a Cicada PHY */
1774 /* disable auto-neg, set speed, powerup */
1775 phy_config
= (MIICR_REG_PCR
| (speed
| duplex
));
1776 slic_reg32_write(wphy
, phy_config
, FLUSH
);
1781 static void slic_card_cleanup(struct sliccard
*card
)
1783 if (card
->loadtimerset
) {
1784 card
->loadtimerset
= 0;
1785 del_timer(&card
->loadtimer
);
1788 slic_debug_card_destroy(card
);
1793 static int slic_card_download_gbrcv(struct adapter
*adapter
)
1795 const struct firmware
*fw
;
1796 const char *file
= "";
1798 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1802 u32 rcvucodelen
= 0;
1804 switch (adapter
->devid
) {
1805 case SLIC_2GB_DEVICE_ID
:
1806 file
= "slicoss/oasisrcvucode.sys";
1808 case SLIC_1GB_DEVICE_ID
:
1809 file
= "slicoss/gbrcvucode.sys";
1816 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
1818 dev_err(&adapter
->pcidev
->dev
,
1819 "SLICOSS: Failed to load firmware %s\n", file
);
1823 rcvucodelen
= *(u32
*)(fw
->data
+ index
);
1825 switch (adapter
->devid
) {
1826 case SLIC_2GB_DEVICE_ID
:
1827 if (rcvucodelen
!= OasisRcvUCodeLen
)
1830 case SLIC_1GB_DEVICE_ID
:
1831 if (rcvucodelen
!= GBRcvUCodeLen
)
1838 /* start download */
1839 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_BEGIN
, FLUSH
);
1840 /* download the rcv sequencer ucode */
1841 for (codeaddr
= 0; codeaddr
< rcvucodelen
; codeaddr
++) {
1842 /* write out instruction address */
1843 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, codeaddr
, FLUSH
);
1845 instruction
= *(u32
*)(fw
->data
+ index
);
1847 /* write out the instruction data low addr */
1848 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, instruction
, FLUSH
);
1850 instruction
= *(u8
*)(fw
->data
+ index
);
1852 /* write out the instruction data high addr */
1853 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, (u8
)instruction
,
1857 /* download finished */
1858 release_firmware(fw
);
1859 slic_reg32_write(&slic_regs
->slic_rcv_wcs
, SLIC_RCVWCS_FINISH
, FLUSH
);
1863 static int slic_card_download(struct adapter
*adapter
)
1865 const struct firmware
*fw
;
1866 const char *file
= "";
1869 int thissectionsize
;
1871 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
1878 int ucode_start
, index
= 0;
1880 switch (adapter
->devid
) {
1881 case SLIC_2GB_DEVICE_ID
:
1882 file
= "slicoss/oasisdownload.sys";
1884 case SLIC_1GB_DEVICE_ID
:
1885 file
= "slicoss/gbdownload.sys";
1891 ret
= request_firmware(&fw
, file
, &adapter
->pcidev
->dev
);
1893 dev_err(&adapter
->pcidev
->dev
,
1894 "SLICOSS: Failed to load firmware %s\n", file
);
1897 numsects
= *(u32
*)(fw
->data
+ index
);
1899 ASSERT(numsects
<= 3);
1900 for (i
= 0; i
< numsects
; i
++) {
1901 sectsize
[i
] = *(u32
*)(fw
->data
+ index
);
1904 for (i
= 0; i
< numsects
; i
++) {
1905 sectstart
[i
] = *(u32
*)(fw
->data
+ index
);
1908 ucode_start
= index
;
1909 instruction
= *(u32
*)(fw
->data
+ index
);
1911 for (section
= 0; section
< numsects
; section
++) {
1912 baseaddress
= sectstart
[section
];
1913 thissectionsize
= sectsize
[section
] >> 3;
1915 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
1916 /* Write out instruction address */
1917 slic_reg32_write(&slic_regs
->slic_wcs
,
1918 baseaddress
+ codeaddr
, FLUSH
);
1919 /* Write out instruction to low addr */
1920 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
, FLUSH
);
1921 instruction
= *(u32
*)(fw
->data
+ index
);
1924 /* Write out instruction to high addr */
1925 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
, FLUSH
);
1926 instruction
= *(u32
*)(fw
->data
+ index
);
1930 index
= ucode_start
;
1931 for (section
= 0; section
< numsects
; section
++) {
1932 instruction
= *(u32
*)(fw
->data
+ index
);
1933 baseaddress
= sectstart
[section
];
1934 if (baseaddress
< 0x8000)
1936 thissectionsize
= sectsize
[section
] >> 3;
1938 for (codeaddr
= 0; codeaddr
< thissectionsize
; codeaddr
++) {
1939 /* Write out instruction address */
1940 slic_reg32_write(&slic_regs
->slic_wcs
,
1941 SLIC_WCS_COMPARE
| (baseaddress
+ codeaddr
),
1943 /* Write out instruction to low addr */
1944 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
1946 instruction
= *(u32
*)(fw
->data
+ index
);
1948 /* Write out instruction to high addr */
1949 slic_reg32_write(&slic_regs
->slic_wcs
, instruction
,
1951 instruction
= *(u32
*)(fw
->data
+ index
);
1954 /* Check SRAM location zero. If it is non-zero. Abort.*/
1955 /* failure = readl((u32 __iomem *)&slic_regs->slic_reset);
1957 release_firmware(fw);
1962 release_firmware(fw
);
1963 /* Everything OK, kick off the card */
1965 slic_reg32_write(&slic_regs
->slic_wcs
, SLIC_WCS_START
, FLUSH
);
1967 /* stall for 20 ms, long enough for ucode to init card
1968 and reach mainloop */
1971 return STATUS_SUCCESS
;
1974 static void slic_adapter_set_hwaddr(struct adapter
*adapter
)
1976 struct sliccard
*card
= adapter
->card
;
1978 if ((adapter
->card
) && (card
->config_set
)) {
1979 memcpy(adapter
->macaddr
,
1980 card
->config
.MacInfo
[adapter
->functionnumber
].macaddrA
,
1981 sizeof(struct slic_config_mac
));
1982 if (!(adapter
->currmacaddr
[0] || adapter
->currmacaddr
[1] ||
1983 adapter
->currmacaddr
[2] || adapter
->currmacaddr
[3] ||
1984 adapter
->currmacaddr
[4] || adapter
->currmacaddr
[5])) {
1985 memcpy(adapter
->currmacaddr
, adapter
->macaddr
, 6);
1987 if (adapter
->netdev
) {
1988 memcpy(adapter
->netdev
->dev_addr
, adapter
->currmacaddr
,
1994 static void slic_intagg_set(struct adapter
*adapter
, u32 value
)
1996 slic_reg32_write(&adapter
->slic_regs
->slic_intagg
, value
, FLUSH
);
1997 adapter
->card
->loadlevel_current
= value
;
2000 static int slic_card_init(struct sliccard
*card
, struct adapter
*adapter
)
2002 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2003 struct slic_eeprom
*peeprom
;
2004 struct oslic_eeprom
*pOeeprom
;
2005 dma_addr_t phys_config
;
2009 struct slic_shmem
*pshmem
;
2011 uint macaddrs
= card
->card_size
;
2016 struct slic_config_mac
*pmac
;
2017 unsigned char fruformat
;
2018 unsigned char oemfruformat
;
2019 struct atk_fru
*patkfru
;
2020 union oemfru
*poemfru
;
2022 /* Reset everything except PCI configuration space */
2023 slic_soft_reset(adapter
);
2025 /* Download the microcode */
2026 status
= slic_card_download(adapter
);
2028 if (status
!= STATUS_SUCCESS
) {
2029 dev_err(&adapter
->pcidev
->dev
,
2030 "download failed bus %d slot %d\n",
2031 adapter
->busnumber
, adapter
->slotnumber
);
2035 if (!card
->config_set
) {
2036 peeprom
= pci_alloc_consistent(adapter
->pcidev
,
2037 sizeof(struct slic_eeprom
),
2040 phys_configl
= SLIC_GET_ADDR_LOW(phys_config
);
2041 phys_configh
= SLIC_GET_ADDR_HIGH(phys_config
);
2044 dev_err(&adapter
->pcidev
->dev
,
2045 "eeprom read failed to get memory "
2046 "bus %d slot %d\n", adapter
->busnumber
,
2047 adapter
->slotnumber
);
2050 memset(peeprom
, 0, sizeof(struct slic_eeprom
));
2052 slic_reg32_write(&slic_regs
->slic_icr
, ICR_INT_OFF
, FLUSH
);
2054 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
2056 spin_lock_irqsave(&adapter
->bit64reglock
.lock
,
2057 adapter
->bit64reglock
.flags
);
2058 slic_reg32_write(&slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
2059 slic_reg32_write(&slic_regs
->slic_isp
,
2060 SLIC_GET_ADDR_LOW(&pshmem
->isr
), FLUSH
);
2061 spin_unlock_irqrestore(&adapter
->bit64reglock
.lock
,
2062 adapter
->bit64reglock
.flags
);
2064 slic_config_get(adapter
, phys_configl
, phys_configh
);
2067 if (adapter
->pshmem
->isr
) {
2068 if (adapter
->pshmem
->isr
& ISR_UPC
) {
2069 adapter
->pshmem
->isr
= 0;
2070 slic_reg64_write(adapter
,
2071 &slic_regs
->slic_isp
, 0,
2072 &slic_regs
->slic_addr_upper
,
2074 slic_reg32_write(&slic_regs
->slic_isr
,
2077 slic_upr_request_complete(adapter
, 0);
2080 adapter
->pshmem
->isr
= 0;
2081 slic_reg32_write(&slic_regs
->slic_isr
,
2088 dev_err(&adapter
->pcidev
->dev
,
2089 "%d config data fetch timed out!\n",
2091 slic_reg64_write(adapter
,
2092 &slic_regs
->slic_isp
, 0,
2093 &slic_regs
->slic_addr_upper
,
2100 switch (adapter
->devid
) {
2102 case SLIC_2GB_DEVICE_ID
:
2103 /* extract EEPROM data and pointers to EEPROM data */
2104 pOeeprom
= (struct oslic_eeprom
*) peeprom
;
2105 eecodesize
= pOeeprom
->EecodeSize
;
2106 dramsize
= pOeeprom
->DramSize
;
2107 pmac
= pOeeprom
->MacInfo
;
2108 fruformat
= pOeeprom
->FruFormat
;
2109 patkfru
= &pOeeprom
->AtkFru
;
2110 oemfruformat
= pOeeprom
->OemFruFormat
;
2111 poemfru
= &pOeeprom
->OemFru
;
2113 /* Minor kludge for Oasis card
2114 get 2 MAC addresses from the
2115 EEPROM to ensure that function 1
2116 gets the Port 1 MAC address */
2119 /* extract EEPROM data and pointers to EEPROM data */
2120 eecodesize
= peeprom
->EecodeSize
;
2121 dramsize
= peeprom
->DramSize
;
2122 pmac
= peeprom
->u2
.mac
.MacInfo
;
2123 fruformat
= peeprom
->FruFormat
;
2124 patkfru
= &peeprom
->AtkFru
;
2125 oemfruformat
= peeprom
->OemFruFormat
;
2126 poemfru
= &peeprom
->OemFru
;
2130 card
->config
.EepromValid
= false;
2132 /* see if the EEPROM is valid by checking it's checksum */
2133 if ((eecodesize
<= MAX_EECODE_SIZE
) &&
2134 (eecodesize
>= MIN_EECODE_SIZE
)) {
2137 *(u16
*) ((char *) peeprom
+ (eecodesize
- 2));
2139 calculate the EEPROM checksum
2142 ~slic_eeprom_cksum((char *) peeprom
,
2145 if the ucdoe chksum flag bit worked,
2146 we wouldn't need this shit
2148 if (ee_chksum
== calc_chksum
)
2149 card
->config
.EepromValid
= true;
2151 /* copy in the DRAM size */
2152 card
->config
.DramSize
= dramsize
;
2154 /* copy in the MAC address(es) */
2155 for (i
= 0; i
< macaddrs
; i
++) {
2156 memcpy(&card
->config
.MacInfo
[i
],
2157 &pmac
[i
], sizeof(struct slic_config_mac
));
2160 /* copy the Alacritech FRU information */
2161 card
->config
.FruFormat
= fruformat
;
2162 memcpy(&card
->config
.AtkFru
, patkfru
,
2163 sizeof(struct atk_fru
));
2165 pci_free_consistent(adapter
->pcidev
,
2166 sizeof(struct slic_eeprom
),
2167 peeprom
, phys_config
);
2169 if ((!card
->config
.EepromValid
) &&
2170 (adapter
->reg_params
.fail_on_bad_eeprom
)) {
2171 slic_reg64_write(adapter
, &slic_regs
->slic_isp
, 0,
2172 &slic_regs
->slic_addr_upper
,
2174 dev_err(&adapter
->pcidev
->dev
,
2175 "unsupported CONFIGURATION EEPROM invalid\n");
2179 card
->config_set
= 1;
2182 if (slic_card_download_gbrcv(adapter
)) {
2183 dev_err(&adapter
->pcidev
->dev
,
2184 "unable to download GB receive microcode\n");
2188 if (slic_global
.dynamic_intagg
)
2189 slic_intagg_set(adapter
, 0);
2191 slic_intagg_set(adapter
, intagg_delay
);
2194 * Initialize ping status to "ok"
2196 card
->pingstatus
= ISR_PINGMASK
;
2199 * Lastly, mark our card state as up and return success
2201 card
->state
= CARD_UP
;
2202 card
->reset_in_progress
= 0;
2204 return STATUS_SUCCESS
;
2207 static u32
slic_card_locate(struct adapter
*adapter
)
2209 struct sliccard
*card
= slic_global
.slic_card
;
2210 struct physcard
*physcard
= slic_global
.phys_card
;
2212 u16 __iomem
*hostid_reg
;
2214 uint rdhostid_offset
= 0;
2216 switch (adapter
->devid
) {
2217 case SLIC_2GB_DEVICE_ID
:
2218 rdhostid_offset
= SLIC_RDHOSTID_2GB
;
2220 case SLIC_1GB_DEVICE_ID
:
2221 rdhostid_offset
= SLIC_RDHOSTID_1GB
;
2229 (u16 __iomem
*) (((u8 __iomem
*) (adapter
->slic_regs
)) +
2232 /* read the 16 bit hostid from SRAM */
2233 card_hostid
= (ushort
) readw(hostid_reg
);
2235 /* Initialize a new card structure if need be */
2236 if (card_hostid
== SLIC_HOSTID_DEFAULT
) {
2237 card
= kzalloc(sizeof(struct sliccard
), GFP_KERNEL
);
2241 card
->next
= slic_global
.slic_card
;
2242 slic_global
.slic_card
= card
;
2243 card
->busnumber
= adapter
->busnumber
;
2244 card
->slotnumber
= adapter
->slotnumber
;
2246 /* Find an available cardnum */
2247 for (i
= 0; i
< SLIC_MAX_CARDS
; i
++) {
2248 if (slic_global
.cardnuminuse
[i
] == 0) {
2249 slic_global
.cardnuminuse
[i
] = 1;
2254 slic_global
.num_slic_cards
++;
2256 slic_debug_card_create(card
);
2258 /* Card exists, find the card this adapter belongs to */
2260 if (card
->cardnum
== card_hostid
)
2268 return STATUS_FAILURE
;
2269 /* Put the adapter in the card's adapter list */
2270 ASSERT(card
->adapter
[adapter
->port
] == NULL
);
2271 if (!card
->adapter
[adapter
->port
]) {
2272 card
->adapter
[adapter
->port
] = adapter
;
2273 adapter
->card
= card
;
2276 card
->card_size
= 1; /* one port per *logical* card */
2279 for (i
= 0; i
< SLIC_MAX_PORTS
; i
++) {
2280 if (!physcard
->adapter
[i
])
2285 ASSERT(i
!= SLIC_MAX_PORTS
);
2286 if (physcard
->adapter
[i
]->slotnumber
== adapter
->slotnumber
)
2288 physcard
= physcard
->next
;
2291 /* no structure allocated for this physical card yet */
2292 physcard
= kzalloc(sizeof(struct physcard
), GFP_ATOMIC
);
2295 physcard
->next
= slic_global
.phys_card
;
2296 slic_global
.phys_card
= physcard
;
2297 physcard
->adapters_allocd
= 1;
2299 physcard
->adapters_allocd
++;
2301 /* Note - this is ZERO relative */
2302 adapter
->physport
= physcard
->adapters_allocd
- 1;
2304 ASSERT(physcard
->adapter
[adapter
->physport
] == NULL
);
2305 physcard
->adapter
[adapter
->physport
] = adapter
;
2306 adapter
->physcard
= physcard
;
2311 static void slic_soft_reset(struct adapter
*adapter
)
2313 if (adapter
->card
->state
== CARD_UP
) {
2314 slic_reg32_write(&adapter
->slic_regs
->slic_quiesce
, 0, FLUSH
);
2318 slic_reg32_write(&adapter
->slic_regs
->slic_reset
, SLIC_RESET_MAGIC
,
2323 static void slic_config_set(struct adapter
*adapter
, bool linkchange
)
2327 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2331 slic_mac_config(adapter
);
2332 RcrReset
= GRCR_RESET
;
2334 slic_mac_address_config(adapter
);
2338 if (adapter
->linkduplex
== LINK_FULLD
) {
2340 value
= (GXCR_RESET
| /* Always reset */
2341 GXCR_XMTEN
| /* Enable transmit */
2342 GXCR_PAUSEEN
); /* Enable pause */
2344 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
2346 /* Setup rcvcfg last */
2347 value
= (RcrReset
| /* Reset, if linkchange */
2348 GRCR_CTLEN
| /* Enable CTL frames */
2349 GRCR_ADDRAEN
| /* Address A enable */
2350 GRCR_RCVBAD
| /* Rcv bad frames */
2351 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
2354 value
= (GXCR_RESET
| /* Always reset */
2355 GXCR_XMTEN
); /* Enable transmit */
2357 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
2359 /* Setup rcvcfg last */
2360 value
= (RcrReset
| /* Reset, if linkchange */
2361 GRCR_ADDRAEN
| /* Address A enable */
2362 GRCR_RCVBAD
| /* Rcv bad frames */
2363 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
2366 if (adapter
->state
!= ADAPT_DOWN
) {
2367 /* Only enable receive if we are restarting or running */
2368 value
|= GRCR_RCVEN
;
2371 if (adapter
->macopts
& MAC_PROMISC
)
2372 value
|= GRCR_RCVALL
;
2374 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
2378 * Turn off RCV and XMT, power down PHY
2380 static void slic_config_clear(struct adapter
*adapter
)
2384 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2387 value
= (GXCR_RESET
| /* Always reset */
2388 GXCR_PAUSEEN
); /* Enable pause */
2390 slic_reg32_write(&slic_regs
->slic_wxcfg
, value
, FLUSH
);
2392 value
= (GRCR_RESET
| /* Always reset */
2393 GRCR_CTLEN
| /* Enable CTL frames */
2394 GRCR_ADDRAEN
| /* Address A enable */
2395 (GRCR_HASHSIZE
<< GRCR_HASHSIZE_SHIFT
));
2397 slic_reg32_write(&slic_regs
->slic_wrcfg
, value
, FLUSH
);
2399 /* power down phy */
2400 phy_config
= (MIICR_REG_PCR
| (PCR_POWERDOWN
));
2401 slic_reg32_write(&slic_regs
->slic_wphy
, phy_config
, FLUSH
);
2404 static void slic_config_get(struct adapter
*adapter
, u32 config
,
2409 status
= slic_upr_request(adapter
,
2411 (u32
) config
, (u32
) config_h
, 0, 0);
2412 ASSERT(status
== 0);
2415 static void slic_mac_address_config(struct adapter
*adapter
)
2419 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2421 value
= *(u32
*) &adapter
->currmacaddr
[2];
2422 value
= ntohl(value
);
2423 slic_reg32_write(&slic_regs
->slic_wraddral
, value
, FLUSH
);
2424 slic_reg32_write(&slic_regs
->slic_wraddrbl
, value
, FLUSH
);
2426 value2
= (u32
) ((adapter
->currmacaddr
[0] << 8 |
2427 adapter
->currmacaddr
[1]) & 0xFFFF);
2429 slic_reg32_write(&slic_regs
->slic_wraddrah
, value2
, FLUSH
);
2430 slic_reg32_write(&slic_regs
->slic_wraddrbh
, value2
, FLUSH
);
2432 /* Write our multicast mask out to the card. This is done */
2433 /* here in addition to the slic_mcast_addr_set routine */
2434 /* because ALL_MCAST may have been enabled or disabled */
2435 slic_mcast_set_mask(adapter
);
2438 static void slic_mac_config(struct adapter
*adapter
)
2441 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2443 /* Setup GMAC gaps */
2444 if (adapter
->linkspeed
== LINK_1000MB
) {
2445 value
= ((GMCR_GAPBB_1000
<< GMCR_GAPBB_SHIFT
) |
2446 (GMCR_GAPR1_1000
<< GMCR_GAPR1_SHIFT
) |
2447 (GMCR_GAPR2_1000
<< GMCR_GAPR2_SHIFT
));
2449 value
= ((GMCR_GAPBB_100
<< GMCR_GAPBB_SHIFT
) |
2450 (GMCR_GAPR1_100
<< GMCR_GAPR1_SHIFT
) |
2451 (GMCR_GAPR2_100
<< GMCR_GAPR2_SHIFT
));
2455 if (adapter
->linkspeed
== LINK_1000MB
)
2458 /* enable fullduplex */
2459 if ((adapter
->linkduplex
== LINK_FULLD
)
2460 || (adapter
->macopts
& MAC_LOOPBACK
)) {
2461 value
|= GMCR_FULLD
;
2464 /* write mac config */
2465 slic_reg32_write(&slic_regs
->slic_wmcfg
, value
, FLUSH
);
2467 /* setup mac addresses */
2468 slic_mac_address_config(adapter
);
2471 static bool slic_mac_filter(struct adapter
*adapter
,
2472 struct ether_header
*ether_frame
)
2474 u32 opts
= adapter
->macopts
;
2475 u32
*dhost4
= (u32
*)ðer_frame
->ether_dhost
[0];
2476 u16
*dhost2
= (u16
*)ðer_frame
->ether_dhost
[4];
2479 if (opts
& MAC_PROMISC
)
2482 if ((*dhost4
== 0xFFFFFFFF) && (*dhost2
== 0xFFFF)) {
2483 if (opts
& MAC_BCAST
) {
2484 adapter
->rcv_broadcasts
++;
2491 if (ether_frame
->ether_dhost
[0] & 0x01) {
2492 if (opts
& MAC_ALLMCAST
) {
2493 adapter
->rcv_multicasts
++;
2494 adapter
->stats
.multicast
++;
2497 if (opts
& MAC_MCAST
) {
2498 struct mcast_address
*mcaddr
= adapter
->mcastaddrs
;
2501 ETHER_EQ_ADDR(mcaddr
->address
,
2502 ether_frame
->ether_dhost
,
2505 adapter
->rcv_multicasts
++;
2506 adapter
->stats
.multicast
++;
2509 mcaddr
= mcaddr
->next
;
2516 if (opts
& MAC_DIRECTED
) {
2517 adapter
->rcv_unicasts
++;
2524 static int slic_mac_set_address(struct net_device
*dev
, void *ptr
)
2526 struct adapter
*adapter
= (struct adapter
*)netdev_priv(dev
);
2527 struct sockaddr
*addr
= ptr
;
2529 if (netif_running(dev
))
2534 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
2535 memcpy(adapter
->currmacaddr
, addr
->sa_data
, dev
->addr_len
);
2537 slic_config_set(adapter
, true);
2541 static void slic_timer_load_check(ulong cardaddr
)
2543 struct sliccard
*card
= (struct sliccard
*)cardaddr
;
2544 struct adapter
*adapter
= card
->master
;
2545 u32 __iomem
*intagg
;
2546 u32 load
= card
->events
;
2549 intagg
= &adapter
->slic_regs
->slic_intagg
;
2551 if ((adapter
) && (adapter
->state
== ADAPT_UP
) &&
2552 (card
->state
== CARD_UP
) && (slic_global
.dynamic_intagg
)) {
2553 if (adapter
->devid
== SLIC_1GB_DEVICE_ID
) {
2554 if (adapter
->linkspeed
== LINK_1000MB
)
2557 if (load
> SLIC_LOAD_5
)
2558 level
= SLIC_INTAGG_5
;
2559 else if (load
> SLIC_LOAD_4
)
2560 level
= SLIC_INTAGG_4
;
2561 else if (load
> SLIC_LOAD_3
)
2562 level
= SLIC_INTAGG_3
;
2563 else if (load
> SLIC_LOAD_2
)
2564 level
= SLIC_INTAGG_2
;
2565 else if (load
> SLIC_LOAD_1
)
2566 level
= SLIC_INTAGG_1
;
2568 level
= SLIC_INTAGG_0
;
2570 if (card
->loadlevel_current
!= level
) {
2571 card
->loadlevel_current
= level
;
2572 slic_reg32_write(intagg
, level
, FLUSH
);
2575 if (load
> SLIC_LOAD_5
)
2576 level
= SLIC_INTAGG_5
;
2577 else if (load
> SLIC_LOAD_4
)
2578 level
= SLIC_INTAGG_4
;
2579 else if (load
> SLIC_LOAD_3
)
2580 level
= SLIC_INTAGG_3
;
2581 else if (load
> SLIC_LOAD_2
)
2582 level
= SLIC_INTAGG_2
;
2583 else if (load
> SLIC_LOAD_1
)
2584 level
= SLIC_INTAGG_1
;
2586 level
= SLIC_INTAGG_0
;
2587 if (card
->loadlevel_current
!= level
) {
2588 card
->loadlevel_current
= level
;
2589 slic_reg32_write(intagg
, level
, FLUSH
);
2594 card
->loadtimer
.expires
= jiffies
+ (SLIC_LOADTIMER_PERIOD
* HZ
);
2595 add_timer(&card
->loadtimer
);
2598 static void slic_assert_fail(void)
2602 cpuid
= smp_processor_id();
2603 curr_pid
= current
->pid
;
2605 printk(KERN_ERR
"%s CPU # %d ---- PID # %d\n",
2606 __func__
, cpuid
, curr_pid
);
2609 static int slic_upr_queue_request(struct adapter
*adapter
,
2613 u32 upr_buffer
, u32 upr_buffer_h
)
2615 struct slic_upr
*upr
;
2616 struct slic_upr
*uprqueue
;
2618 upr
= kmalloc(sizeof(struct slic_upr
), GFP_ATOMIC
);
2622 upr
->adapter
= adapter
->port
;
2623 upr
->upr_request
= upr_request
;
2624 upr
->upr_data
= upr_data
;
2625 upr
->upr_buffer
= upr_buffer
;
2626 upr
->upr_data_h
= upr_data_h
;
2627 upr
->upr_buffer_h
= upr_buffer_h
;
2629 if (adapter
->upr_list
) {
2630 uprqueue
= adapter
->upr_list
;
2632 while (uprqueue
->next
)
2633 uprqueue
= uprqueue
->next
;
2634 uprqueue
->next
= upr
;
2636 adapter
->upr_list
= upr
;
2638 return STATUS_SUCCESS
;
2641 static int slic_upr_request(struct adapter
*adapter
,
2645 u32 upr_buffer
, u32 upr_buffer_h
)
2649 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
2650 status
= slic_upr_queue_request(adapter
,
2653 upr_data_h
, upr_buffer
, upr_buffer_h
);
2654 if (status
!= STATUS_SUCCESS
) {
2655 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
2656 adapter
->upr_lock
.flags
);
2659 slic_upr_start(adapter
);
2660 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
2661 adapter
->upr_lock
.flags
);
2662 return STATUS_PENDING
;
2665 static void slic_upr_request_complete(struct adapter
*adapter
, u32 isr
)
2667 struct sliccard
*card
= adapter
->card
;
2668 struct slic_upr
*upr
;
2670 spin_lock_irqsave(&adapter
->upr_lock
.lock
, adapter
->upr_lock
.flags
);
2671 upr
= adapter
->upr_list
;
2674 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
2675 adapter
->upr_lock
.flags
);
2678 adapter
->upr_list
= upr
->next
;
2680 adapter
->upr_busy
= 0;
2681 ASSERT(adapter
->port
== upr
->adapter
);
2682 switch (upr
->upr_request
) {
2683 case SLIC_UPR_STATS
:
2685 struct slic_stats
*slicstats
=
2686 (struct slic_stats
*) &adapter
->pshmem
->inicstats
;
2687 struct slic_stats
*newstats
= slicstats
;
2688 struct slic_stats
*old
= &adapter
->inicstats_prev
;
2689 struct slicnet_stats
*stst
= &adapter
->slic_stats
;
2691 if (isr
& ISR_UPCERR
) {
2692 dev_err(&adapter
->netdev
->dev
,
2693 "SLIC_UPR_STATS command failed isr[%x]\n",
2698 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_segs
,
2699 newstats
->xmit_tcp_segs_gb
,
2700 old
->xmit_tcp_segs_gb
);
2702 UPDATE_STATS_GB(stst
->tcp
.xmit_tcp_bytes
,
2703 newstats
->xmit_tcp_bytes_gb
,
2704 old
->xmit_tcp_bytes_gb
);
2706 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_segs
,
2707 newstats
->rcv_tcp_segs_gb
,
2708 old
->rcv_tcp_segs_gb
);
2710 UPDATE_STATS_GB(stst
->tcp
.rcv_tcp_bytes
,
2711 newstats
->rcv_tcp_bytes_gb
,
2712 old
->rcv_tcp_bytes_gb
);
2714 UPDATE_STATS_GB(stst
->iface
.xmt_bytes
,
2715 newstats
->xmit_bytes_gb
,
2716 old
->xmit_bytes_gb
);
2718 UPDATE_STATS_GB(stst
->iface
.xmt_ucast
,
2719 newstats
->xmit_unicasts_gb
,
2720 old
->xmit_unicasts_gb
);
2722 UPDATE_STATS_GB(stst
->iface
.rcv_bytes
,
2723 newstats
->rcv_bytes_gb
,
2726 UPDATE_STATS_GB(stst
->iface
.rcv_ucast
,
2727 newstats
->rcv_unicasts_gb
,
2728 old
->rcv_unicasts_gb
);
2730 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
2731 newstats
->xmit_collisions_gb
,
2732 old
->xmit_collisions_gb
);
2734 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
2735 newstats
->xmit_excess_collisions_gb
,
2736 old
->xmit_excess_collisions_gb
);
2738 UPDATE_STATS_GB(stst
->iface
.xmt_errors
,
2739 newstats
->xmit_other_error_gb
,
2740 old
->xmit_other_error_gb
);
2742 UPDATE_STATS_GB(stst
->iface
.rcv_errors
,
2743 newstats
->rcv_other_error_gb
,
2744 old
->rcv_other_error_gb
);
2746 UPDATE_STATS_GB(stst
->iface
.rcv_discards
,
2747 newstats
->rcv_drops_gb
,
2750 if (newstats
->rcv_drops_gb
> old
->rcv_drops_gb
) {
2751 adapter
->rcv_drops
+=
2752 (newstats
->rcv_drops_gb
-
2755 memcpy(old
, newstats
, sizeof(struct slic_stats
));
2759 slic_link_upr_complete(adapter
, isr
);
2761 case SLIC_UPR_RCONFIG
:
2776 card
->pingstatus
|= (isr
& ISR_PINGDSMASK
);
2782 slic_upr_start(adapter
);
2783 spin_unlock_irqrestore(&adapter
->upr_lock
.lock
,
2784 adapter
->upr_lock
.flags
);
2787 static void slic_upr_start(struct adapter
*adapter
)
2789 struct slic_upr
*upr
;
2790 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
2796 upr
= adapter
->upr_list
;
2799 if (adapter
->upr_busy
)
2801 adapter
->upr_busy
= 1;
2803 switch (upr
->upr_request
) {
2804 case SLIC_UPR_STATS
:
2805 if (upr
->upr_data_h
== 0) {
2806 slic_reg32_write(&slic_regs
->slic_stats
, upr
->upr_data
,
2809 slic_reg64_write(adapter
, &slic_regs
->slic_stats64
,
2811 &slic_regs
->slic_addr_upper
,
2812 upr
->upr_data_h
, FLUSH
);
2817 slic_reg64_write(adapter
, &slic_regs
->slic_rlsr
, upr
->upr_data
,
2818 &slic_regs
->slic_addr_upper
, upr
->upr_data_h
,
2822 case SLIC_UPR_RCONFIG
:
2823 slic_reg64_write(adapter
, &slic_regs
->slic_rconfig
,
2824 upr
->upr_data
, &slic_regs
->slic_addr_upper
,
2825 upr
->upr_data_h
, FLUSH
);
2828 slic_reg32_write(&slic_regs
->slic_ping
, 1, FLUSH
);
2835 static void slic_link_upr_complete(struct adapter
*adapter
, u32 isr
)
2837 u32 linkstatus
= adapter
->pshmem
->linkstatus
;
2839 unsigned char linkspeed
;
2840 unsigned char linkduplex
;
2842 if ((isr
& ISR_UPCERR
) || (isr
& ISR_UPCBSY
)) {
2843 struct slic_shmem
*pshmem
;
2845 pshmem
= (struct slic_shmem
*)adapter
->phys_shmem
;
2846 #if defined(CONFIG_X86_64)
2847 slic_upr_queue_request(adapter
,
2849 SLIC_GET_ADDR_LOW(&pshmem
->linkstatus
),
2850 SLIC_GET_ADDR_HIGH(&pshmem
->linkstatus
),
2852 #elif defined(CONFIG_X86)
2853 slic_upr_queue_request(adapter
,
2855 (u32
) &pshmem
->linkstatus
,
2856 SLIC_GET_ADDR_HIGH(pshmem
), 0, 0);
2862 if (adapter
->state
!= ADAPT_UP
)
2865 ASSERT((adapter
->devid
== SLIC_1GB_DEVICE_ID
)
2866 || (adapter
->devid
== SLIC_2GB_DEVICE_ID
));
2868 linkup
= linkstatus
& GIG_LINKUP
? LINK_UP
: LINK_DOWN
;
2869 if (linkstatus
& GIG_SPEED_1000
)
2870 linkspeed
= LINK_1000MB
;
2871 else if (linkstatus
& GIG_SPEED_100
)
2872 linkspeed
= LINK_100MB
;
2874 linkspeed
= LINK_10MB
;
2876 if (linkstatus
& GIG_FULLDUPLEX
)
2877 linkduplex
= LINK_FULLD
;
2879 linkduplex
= LINK_HALFD
;
2881 if ((adapter
->linkstate
== LINK_DOWN
) && (linkup
== LINK_DOWN
))
2884 /* link up event, but nothing has changed */
2885 if ((adapter
->linkstate
== LINK_UP
) &&
2886 (linkup
== LINK_UP
) &&
2887 (adapter
->linkspeed
== linkspeed
) &&
2888 (adapter
->linkduplex
== linkduplex
))
2891 /* link has changed at this point */
2893 /* link has gone from up to down */
2894 if (linkup
== LINK_DOWN
) {
2895 adapter
->linkstate
= LINK_DOWN
;
2899 /* link has gone from down to up */
2900 adapter
->linkspeed
= linkspeed
;
2901 adapter
->linkduplex
= linkduplex
;
2903 if (adapter
->linkstate
!= LINK_UP
) {
2905 slic_config_set(adapter
, true);
2906 adapter
->linkstate
= LINK_UP
;
2907 netif_start_queue(adapter
->netdev
);
2912 * this is here to checksum the eeprom, there is some ucode bug
2913 * which prevens us from using the ucode result.
2914 * remove this once ucode is fixed.
2916 static ushort
slic_eeprom_cksum(char *m
, int len
)
2918 #define ADDCARRY(x) (x > 65535 ? x -= 65535 : x)
2919 #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\
2924 u32 byte_swapped
= 0;
2941 #ifdef CONFIG_X86_64
2942 w_int
= (u32
) ((ulong
) w
& 0x00000000FFFFFFFF);
2946 if ((1 & w_int
) && (len
> 0)) {
2949 s_util
.c
[0] = *(unsigned char *)w
;
2950 w
= (u16
*)((char *)w
+ 1);
2955 /* Unroll the loop to make overhead from branches &c small. */
2956 while ((len
-= 32) >= 0) {
2973 w
= (u16
*)((ulong
) w
+ 16); /* verify */
2976 while ((len
-= 8) >= 0) {
2981 w
= (u16
*)((ulong
) w
+ 4); /* verify */
2984 if (len
!= 0 || byte_swapped
!= 0) {
2986 while ((len
-= 2) >= 0)
2987 sum
+= *w
++; /* verify */
2993 s_util
.c
[1] = *(char *) w
;
3000 } else if (len
== -1) {
3001 s_util
.c
[0] = *(char *) w
;
3010 return (ushort
) sum
;
3013 static int slic_rspqueue_init(struct adapter
*adapter
)
3016 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
3017 __iomem
struct slic_regs
*slic_regs
= adapter
->slic_regs
;
3020 ASSERT(adapter
->state
== ADAPT_DOWN
);
3021 memset(rspq
, 0, sizeof(struct slic_rspqueue
));
3023 rspq
->num_pages
= SLIC_RSPQ_PAGES_GB
;
3025 for (i
= 0; i
< rspq
->num_pages
; i
++) {
3026 rspq
->vaddr
[i
] = pci_alloc_consistent(adapter
->pcidev
,
3029 if (!rspq
->vaddr
[i
]) {
3030 dev_err(&adapter
->pcidev
->dev
,
3031 "pci_alloc_consistent failed\n");
3032 slic_rspqueue_free(adapter
);
3033 return STATUS_FAILURE
;
3035 #ifndef CONFIG_X86_64
3036 ASSERT(((u32
) rspq
->vaddr
[i
] & 0xFFFFF000) ==
3037 (u32
) rspq
->vaddr
[i
]);
3038 ASSERT(((u32
) rspq
->paddr
[i
] & 0xFFFFF000) ==
3039 (u32
) rspq
->paddr
[i
]);
3041 memset(rspq
->vaddr
[i
], 0, PAGE_SIZE
);
3044 slic_reg32_write(&slic_regs
->slic_rbar
,
3045 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
3048 slic_reg64_write(adapter
, &slic_regs
->slic_rbar64
,
3049 (rspq
->paddr
[i
] | SLIC_RSPQ_BUFSINPAGE
),
3050 &slic_regs
->slic_addr_upper
,
3051 paddrh
, DONT_FLUSH
);
3055 rspq
->pageindex
= 0;
3056 rspq
->rspbuf
= (struct slic_rspbuf
*)rspq
->vaddr
[0];
3057 return STATUS_SUCCESS
;
3060 static void slic_rspqueue_free(struct adapter
*adapter
)
3063 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
3065 for (i
= 0; i
< rspq
->num_pages
; i
++) {
3066 if (rspq
->vaddr
[i
]) {
3067 pci_free_consistent(adapter
->pcidev
, PAGE_SIZE
,
3068 rspq
->vaddr
[i
], rspq
->paddr
[i
]);
3070 rspq
->vaddr
[i
] = NULL
;
3074 rspq
->pageindex
= 0;
3075 rspq
->rspbuf
= NULL
;
3078 static struct slic_rspbuf
*slic_rspqueue_getnext(struct adapter
*adapter
)
3080 struct slic_rspqueue
*rspq
= &adapter
->rspqueue
;
3081 struct slic_rspbuf
*buf
;
3083 if (!(rspq
->rspbuf
->status
))
3087 #ifndef CONFIG_X86_64
3088 ASSERT((buf
->status
& 0xFFFFFFE0) == 0);
3090 ASSERT(buf
->hosthandle
);
3091 if (++rspq
->offset
< SLIC_RSPQ_BUFSINPAGE
) {
3093 #ifndef CONFIG_X86_64
3094 ASSERT(((u32
) rspq
->rspbuf
& 0xFFFFFFE0) ==
3095 (u32
) rspq
->rspbuf
);
3098 ASSERT(rspq
->offset
== SLIC_RSPQ_BUFSINPAGE
);
3099 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_rbar64
,
3100 (rspq
->paddr
[rspq
->pageindex
] | SLIC_RSPQ_BUFSINPAGE
),
3101 &adapter
->slic_regs
->slic_addr_upper
, 0, DONT_FLUSH
);
3102 rspq
->pageindex
= (++rspq
->pageindex
) % rspq
->num_pages
;
3104 rspq
->rspbuf
= (struct slic_rspbuf
*)
3105 rspq
->vaddr
[rspq
->pageindex
];
3106 #ifndef CONFIG_X86_64
3107 ASSERT(((u32
) rspq
->rspbuf
& 0xFFFFF000) ==
3108 (u32
) rspq
->rspbuf
);
3111 #ifndef CONFIG_X86_64
3112 ASSERT(((u32
) buf
& 0xFFFFFFE0) == (u32
) buf
);
3117 static void slic_cmdqmem_init(struct adapter
*adapter
)
3119 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
3121 memset(cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
3124 static void slic_cmdqmem_free(struct adapter
*adapter
)
3126 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
3129 for (i
= 0; i
< SLIC_CMDQ_MAXPAGES
; i
++) {
3130 if (cmdqmem
->pages
[i
]) {
3131 pci_free_consistent(adapter
->pcidev
,
3133 (void *) cmdqmem
->pages
[i
],
3134 cmdqmem
->dma_pages
[i
]);
3137 memset(cmdqmem
, 0, sizeof(struct slic_cmdqmem
));
3140 static u32
*slic_cmdqmem_addpage(struct adapter
*adapter
)
3142 struct slic_cmdqmem
*cmdqmem
= &adapter
->cmdqmem
;
3145 if (cmdqmem
->pagecnt
>= SLIC_CMDQ_MAXPAGES
)
3147 pageaddr
= pci_alloc_consistent(adapter
->pcidev
,
3149 &cmdqmem
->dma_pages
[cmdqmem
->pagecnt
]);
3152 #ifndef CONFIG_X86_64
3153 ASSERT(((u32
) pageaddr
& 0xFFFFF000) == (u32
) pageaddr
);
3155 cmdqmem
->pages
[cmdqmem
->pagecnt
] = pageaddr
;
3160 static int slic_cmdq_init(struct adapter
*adapter
)
3165 ASSERT(adapter
->state
== ADAPT_DOWN
);
3166 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
3167 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
3168 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
3169 spin_lock_init(&adapter
->cmdq_all
.lock
.lock
);
3170 spin_lock_init(&adapter
->cmdq_free
.lock
.lock
);
3171 spin_lock_init(&adapter
->cmdq_done
.lock
.lock
);
3172 slic_cmdqmem_init(adapter
);
3173 adapter
->slic_handle_ix
= 1;
3174 for (i
= 0; i
< SLIC_CMDQ_INITPAGES
; i
++) {
3175 pageaddr
= slic_cmdqmem_addpage(adapter
);
3176 #ifndef CONFIG_X86_64
3177 ASSERT(((u32
) pageaddr
& 0xFFFFF000) == (u32
) pageaddr
);
3180 slic_cmdq_free(adapter
);
3181 return STATUS_FAILURE
;
3183 slic_cmdq_addcmdpage(adapter
, pageaddr
);
3185 adapter
->slic_handle_ix
= 1;
3187 return STATUS_SUCCESS
;
3190 static void slic_cmdq_free(struct adapter
*adapter
)
3192 struct slic_hostcmd
*cmd
;
3194 cmd
= adapter
->cmdq_all
.head
;
3197 struct sk_buff
*tempskb
;
3202 dev_kfree_skb_irq(tempskb
);
3205 cmd
= cmd
->next_all
;
3207 memset(&adapter
->cmdq_all
, 0, sizeof(struct slic_cmdqueue
));
3208 memset(&adapter
->cmdq_free
, 0, sizeof(struct slic_cmdqueue
));
3209 memset(&adapter
->cmdq_done
, 0, sizeof(struct slic_cmdqueue
));
3210 slic_cmdqmem_free(adapter
);
3213 static void slic_cmdq_reset(struct adapter
*adapter
)
3215 struct slic_hostcmd
*hcmd
;
3216 struct sk_buff
*skb
;
3219 spin_lock_irqsave(&adapter
->cmdq_free
.lock
.lock
,
3220 adapter
->cmdq_free
.lock
.flags
);
3221 spin_lock_irqsave(&adapter
->cmdq_done
.lock
.lock
,
3222 adapter
->cmdq_done
.lock
.flags
);
3223 outstanding
= adapter
->cmdq_all
.count
- adapter
->cmdq_done
.count
;
3224 outstanding
-= adapter
->cmdq_free
.count
;
3225 hcmd
= adapter
->cmdq_all
.head
;
3232 dev_kfree_skb_irq(skb
);
3234 hcmd
= hcmd
->next_all
;
3236 adapter
->cmdq_free
.count
= 0;
3237 adapter
->cmdq_free
.head
= NULL
;
3238 adapter
->cmdq_free
.tail
= NULL
;
3239 adapter
->cmdq_done
.count
= 0;
3240 adapter
->cmdq_done
.head
= NULL
;
3241 adapter
->cmdq_done
.tail
= NULL
;
3242 adapter
->cmdq_free
.head
= adapter
->cmdq_all
.head
;
3243 hcmd
= adapter
->cmdq_all
.head
;
3245 adapter
->cmdq_free
.count
++;
3246 hcmd
->next
= hcmd
->next_all
;
3247 hcmd
= hcmd
->next_all
;
3249 if (adapter
->cmdq_free
.count
!= adapter
->cmdq_all
.count
) {
3250 dev_err(&adapter
->netdev
->dev
,
3251 "free_count %d != all count %d\n",
3252 adapter
->cmdq_free
.count
, adapter
->cmdq_all
.count
);
3254 spin_unlock_irqrestore(&adapter
->cmdq_done
.lock
.lock
,
3255 adapter
->cmdq_done
.lock
.flags
);
3256 spin_unlock_irqrestore(&adapter
->cmdq_free
.lock
.lock
,
3257 adapter
->cmdq_free
.lock
.flags
);
3260 static void slic_cmdq_addcmdpage(struct adapter
*adapter
, u32
*page
)
3262 struct slic_hostcmd
*cmd
;
3263 struct slic_hostcmd
*prev
;
3264 struct slic_hostcmd
*tail
;
3265 struct slic_cmdqueue
*cmdq
;
3271 struct slic_handle
*pslic_handle
;
3274 cmd
= (struct slic_hostcmd
*)cmdaddr
;
3277 phys_addr
= virt_to_bus((void *)page
);
3278 phys_addrl
= SLIC_GET_ADDR_LOW(phys_addr
);
3279 phys_addrh
= SLIC_GET_ADDR_HIGH(phys_addr
);
3283 while ((cmdcnt
< SLIC_CMDQ_CMDSINPAGE
) &&
3284 (adapter
->slic_handle_ix
< 256)) {
3285 /* Allocate and initialize a SLIC_HANDLE for this command */
3286 SLIC_GET_SLIC_HANDLE(adapter
, pslic_handle
);
3287 if (pslic_handle
== NULL
)
3289 ASSERT(pslic_handle
==
3290 &adapter
->slic_handles
[pslic_handle
->token
.
3292 pslic_handle
->type
= SLIC_HANDLE_CMD
;
3293 pslic_handle
->address
= (void *) cmd
;
3294 pslic_handle
->offset
= (ushort
) adapter
->slic_handle_ix
++;
3295 pslic_handle
->other_handle
= NULL
;
3296 pslic_handle
->next
= NULL
;
3298 cmd
->pslic_handle
= pslic_handle
;
3299 cmd
->cmd64
.hosthandle
= pslic_handle
->token
.handle_token
;
3301 cmd
->paddrl
= phys_addrl
;
3302 cmd
->paddrh
= phys_addrh
;
3303 cmd
->next_all
= prev
;
3306 phys_addrl
+= SLIC_HOSTCMD_SIZE
;
3307 cmdaddr
+= SLIC_HOSTCMD_SIZE
;
3309 cmd
= (struct slic_hostcmd
*)cmdaddr
;
3313 cmdq
= &adapter
->cmdq_all
;
3314 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
3315 tail
->next_all
= cmdq
->head
;
3317 cmdq
= &adapter
->cmdq_free
;
3318 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
3319 cmdq
->count
+= cmdcnt
; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
3320 tail
->next
= cmdq
->head
;
3322 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
3325 static struct slic_hostcmd
*slic_cmdq_getfree(struct adapter
*adapter
)
3327 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_free
;
3328 struct slic_hostcmd
*cmd
= NULL
;
3331 spin_lock_irqsave(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
3335 cmdq
->head
= cmd
->next
;
3337 spin_unlock_irqrestore(&cmdq
->lock
.lock
, cmdq
->lock
.flags
);
3339 slic_cmdq_getdone(adapter
);
3346 spin_unlock_irqrestore(&cmdq
->lock
.lock
,
3348 pageaddr
= slic_cmdqmem_addpage(adapter
);
3350 slic_cmdq_addcmdpage(adapter
, pageaddr
);
3351 goto lock_and_retry
;
3358 static void slic_cmdq_getdone(struct adapter
*adapter
)
3360 struct slic_cmdqueue
*done_cmdq
= &adapter
->cmdq_done
;
3361 struct slic_cmdqueue
*free_cmdq
= &adapter
->cmdq_free
;
3363 ASSERT(free_cmdq
->head
== NULL
);
3364 spin_lock_irqsave(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
3366 free_cmdq
->head
= done_cmdq
->head
;
3367 free_cmdq
->count
= done_cmdq
->count
;
3368 done_cmdq
->head
= NULL
;
3369 done_cmdq
->tail
= NULL
;
3370 done_cmdq
->count
= 0;
3371 spin_unlock_irqrestore(&done_cmdq
->lock
.lock
, done_cmdq
->lock
.flags
);
3374 static void slic_cmdq_putdone_irq(struct adapter
*adapter
,
3375 struct slic_hostcmd
*cmd
)
3377 struct slic_cmdqueue
*cmdq
= &adapter
->cmdq_done
;
3379 spin_lock(&cmdq
->lock
.lock
);
3381 cmd
->next
= cmdq
->head
;
3384 if ((adapter
->xmitq_full
) && (cmdq
->count
> 10))
3385 netif_wake_queue(adapter
->netdev
);
3386 spin_unlock(&cmdq
->lock
.lock
);
3389 static int slic_rcvqueue_init(struct adapter
*adapter
)
3392 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
3394 ASSERT(adapter
->state
== ADAPT_DOWN
);
3397 rcvq
->size
= SLIC_RCVQ_ENTRIES
;
3400 i
= (SLIC_RCVQ_ENTRIES
/ SLIC_RCVQ_FILLENTRIES
);
3403 count
+= slic_rcvqueue_fill(adapter
);
3406 if (rcvq
->count
< SLIC_RCVQ_MINENTRIES
) {
3407 slic_rcvqueue_free(adapter
);
3408 return STATUS_FAILURE
;
3410 return STATUS_SUCCESS
;
3413 static void slic_rcvqueue_free(struct adapter
*adapter
)
3415 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
3416 struct sk_buff
*skb
;
3418 while (rcvq
->head
) {
3420 rcvq
->head
= rcvq
->head
->next
;
3428 static struct sk_buff
*slic_rcvqueue_getnext(struct adapter
*adapter
)
3430 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
3431 struct sk_buff
*skb
;
3432 struct slic_rcvbuf
*rcvbuf
;
3437 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
3440 if (rcvbuf
->status
& IRHDDR_SVALID
) {
3441 rcvq
->head
= rcvq
->head
->next
;
3448 dev_err(&adapter
->netdev
->dev
,
3449 "RcvQ Empty!! rcvq[%p] count[%x]\n", rcvq
, rcvq
->count
);
3452 while (rcvq
->count
< SLIC_RCVQ_FILLTHRESH
) {
3453 count
= slic_rcvqueue_fill(adapter
);
3462 static int slic_rcvqueue_fill(struct adapter
*adapter
)
3467 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
3469 struct device
*dev
= &adapter
->netdev
->dev
;
3471 while (i
< SLIC_RCVQ_FILLENTRIES
) {
3472 struct slic_rcvbuf
*rcvbuf
;
3473 struct sk_buff
*skb
;
3474 #ifdef KLUDGE_FOR_4GB_BOUNDARY
3477 skb
= alloc_skb(SLIC_RCVQ_RCVBUFSIZE
, GFP_ATOMIC
);
3479 paddr
= (void *)pci_map_single(adapter
->pcidev
,
3481 SLIC_RCVQ_RCVBUFSIZE
,
3482 PCI_DMA_FROMDEVICE
);
3483 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
3484 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
3486 skb
->len
= SLIC_RCVBUF_HEADSIZE
;
3487 rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
3490 #ifdef KLUDGE_FOR_4GB_BOUNDARY
3492 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
3494 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
3495 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
3496 dev_err(dev
, " skblen[%x]\n", skb
->len
);
3497 dev_err(dev
, " paddr[%p]\n", paddr
);
3498 dev_err(dev
, " paddrl[%x]\n", paddrl
);
3499 dev_err(dev
, " paddrh[%x]\n", paddrh
);
3500 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
3501 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
3502 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
3503 dev_err(dev
, "SKIP THIS SKB!!!!!!!!\n");
3504 goto retry_rcvqfill
;
3508 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
3510 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
3511 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
3512 dev_err(dev
, " skblen[%x]\n", skb
->len
);
3513 dev_err(dev
, " paddr[%p]\n", paddr
);
3514 dev_err(dev
, " paddrl[%x]\n", paddrl
);
3515 dev_err(dev
, " paddrh[%x]\n", paddrh
);
3516 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
3517 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
3518 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
3519 dev_err(dev
, "GIVE TO CARD ANYWAY\n");
3523 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
,
3524 (u32
)paddrl
, DONT_FLUSH
);
3526 slic_reg64_write(adapter
,
3527 &adapter
->slic_regs
->slic_hbar64
,
3529 &adapter
->slic_regs
->slic_addr_upper
,
3530 paddrh
, DONT_FLUSH
);
3533 rcvq
->tail
->next
= skb
;
3540 dev_err(&adapter
->netdev
->dev
,
3541 "slic_rcvqueue_fill could only get [%d] skbuffs\n",
3549 static u32
slic_rcvqueue_reinsert(struct adapter
*adapter
, struct sk_buff
*skb
)
3551 struct slic_rcvqueue
*rcvq
= &adapter
->rcvqueue
;
3555 struct slic_rcvbuf
*rcvbuf
= (struct slic_rcvbuf
*)skb
->head
;
3558 ASSERT(skb
->len
== SLIC_RCVBUF_HEADSIZE
);
3560 paddr
= (void *)pci_map_single(adapter
->pcidev
, skb
->head
,
3561 SLIC_RCVQ_RCVBUFSIZE
, PCI_DMA_FROMDEVICE
);
3565 paddrl
= SLIC_GET_ADDR_LOW(paddr
);
3566 paddrh
= SLIC_GET_ADDR_HIGH(paddr
);
3569 dev
= &adapter
->netdev
->dev
;
3570 dev_err(dev
, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
3572 dev_err(dev
, "skb[%p] PROBLEM\n", skb
);
3573 dev_err(dev
, " skbdata[%p]\n", skb
->data
);
3574 dev_err(dev
, " skblen[%x]\n", skb
->len
);
3575 dev_err(dev
, " paddr[%p]\n", paddr
);
3576 dev_err(dev
, " paddrl[%x]\n", paddrl
);
3577 dev_err(dev
, " paddrh[%x]\n", paddrh
);
3578 dev_err(dev
, " rcvq->head[%p]\n", rcvq
->head
);
3579 dev_err(dev
, " rcvq->tail[%p]\n", rcvq
->tail
);
3580 dev_err(dev
, " rcvq->count[%x]\n", rcvq
->count
);
3583 slic_reg32_write(&adapter
->slic_regs
->slic_hbar
, (u32
)paddrl
,
3586 slic_reg64_write(adapter
, &adapter
->slic_regs
->slic_hbar64
,
3587 paddrl
, &adapter
->slic_regs
->slic_addr_upper
,
3588 paddrh
, DONT_FLUSH
);
3591 rcvq
->tail
->next
= skb
;
3599 static int slic_debug_card_show(struct seq_file
*seq
, void *v
)
3603 struct sliccard
*card
= seq
->private;
3604 struct slic_config
*config
= &card
->config
;
3605 unsigned char *fru
= (unsigned char *)(&card
->config
.atk_fru
);
3606 unsigned char *oemfru
= (unsigned char *)(&card
->config
.OemFru
);
3609 seq_printf(seq
, "driver_version : %s\n", slic_proc_version
);
3610 seq_printf(seq
, "Microcode versions: \n");
3611 seq_printf(seq
, " Gigabit (gb) : %s %s\n",
3612 MOJAVE_UCODE_VERS_STRING
, MOJAVE_UCODE_VERS_DATE
);
3613 seq_printf(seq
, " Gigabit Receiver : %s %s\n",
3614 GB_RCVUCODE_VERS_STRING
, GB_RCVUCODE_VERS_DATE
);
3615 seq_printf(seq
, "Vendor : %s\n", slic_vendor
);
3616 seq_printf(seq
, "Product Name : %s\n", slic_product_name
);
3618 seq_printf(seq
, "VendorId : %4.4X\n",
3620 seq_printf(seq
, "DeviceId : %4.4X\n",
3622 seq_printf(seq
, "RevisionId : %2.2x\n",
3623 config
->RevisionId
);
3624 seq_printf(seq
, "Bus # : %d\n", card
->busnumber
);
3625 seq_printf(seq
, "Device # : %d\n", card
->slotnumber
);
3626 seq_printf(seq
, "Interfaces : %d\n", card
->card_size
);
3627 seq_printf(seq
, " Initialized : %d\n",
3628 card
->adapters_activated
);
3629 seq_printf(seq
, " Allocated : %d\n",
3630 card
->adapters_allocated
);
3631 ASSERT(card
->card_size
<= SLIC_NBR_MACS
);
3632 for (i
= 0; i
< card
->card_size
; i
++) {
3634 " MAC%d : %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
3635 i
, config
->macinfo
[i
].macaddrA
[0],
3636 config
->macinfo
[i
].macaddrA
[1],
3637 config
->macinfo
[i
].macaddrA
[2],
3638 config
->macinfo
[i
].macaddrA
[3],
3639 config
->macinfo
[i
].macaddrA
[4],
3640 config
->macinfo
[i
].macaddrA
[5]);
3642 seq_printf(seq
, " IF Init State Duplex/Speed irq\n");
3643 seq_printf(seq
, " -------------------------------\n");
3644 for (i
= 0; i
< card
->adapters_allocated
; i
++) {
3645 struct adapter
*adapter
;
3647 adapter
= card
->adapter
[i
];
3650 " %d %d %s %s %s 0x%X\n",
3651 adapter
->physport
, adapter
->state
,
3652 SLIC_LINKSTATE(adapter
->linkstate
),
3653 SLIC_DUPLEX(adapter
->linkduplex
),
3654 SLIC_SPEED(adapter
->linkspeed
),
3655 (uint
) adapter
->irq
);
3658 seq_printf(seq
, "Generation # : %4.4X\n", card
->gennumber
);
3659 seq_printf(seq
, "RcvQ max entries : %4.4X\n",
3661 seq_printf(seq
, "Ping Status : %8.8X\n",
3663 seq_printf(seq
, "Minimum grant : %2.2x\n",
3665 seq_printf(seq
, "Maximum Latency : %2.2x\n", config
->MaxLat
);
3666 seq_printf(seq
, "PciStatus : %4.4x\n",
3668 seq_printf(seq
, "Debug Device Id : %4.4x\n",
3670 seq_printf(seq
, "DRAM ROM Function : %4.4x\n",
3672 seq_printf(seq
, "Network interface Pin 1 : %2.2x\n",
3673 config
->NetIntPin1
);
3674 seq_printf(seq
, "Network interface Pin 2 : %2.2x\n",
3675 config
->NetIntPin1
);
3676 seq_printf(seq
, "Network interface Pin 3 : %2.2x\n",
3677 config
->NetIntPin1
);
3678 seq_printf(seq
, "PM capabilities : %4.4X\n",
3680 seq_printf(seq
, "Network Clock Controls : %4.4X\n",
3681 config
->NwClkCtrls
);
3683 switch (config
->FruFormat
) {
3684 case ATK_FRU_FORMAT
:
3687 "Vendor : Alacritech, Inc.\n");
3689 "Assembly # : %c%c%c%c%c%c\n",
3690 fru
[0], fru
[1], fru
[2], fru
[3], fru
[4],
3693 "Revision # : %c%c\n",
3696 if (config
->OEMFruFormat
== VENDOR4_FRU_FORMAT
) {
3699 "%c%c%c%c%c%c%c%c%c%c%c%c\n",
3700 fru
[8], fru
[9], fru
[10],
3701 fru
[11], fru
[12], fru
[13],
3702 fru
[16], fru
[17], fru
[18],
3703 fru
[19], fru
[20], fru
[21]);
3707 "%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",
3708 fru
[8], fru
[9], fru
[10],
3709 fru
[11], fru
[12], fru
[13],
3710 fru
[14], fru
[15], fru
[16],
3711 fru
[17], fru
[18], fru
[19],
3720 "Vendor : Alacritech, Inc.\n");
3722 "Serial # : Empty FRU\n");
3727 switch (config
->OEMFruFormat
) {
3728 case VENDOR1_FRU_FORMAT
:
3730 seq_printf(seq
, "FRU Information:\n");
3731 seq_printf(seq
, " Commodity # : %c\n",
3734 " Assembly # : %c%c%c%c\n",
3735 oemfru
[1], oemfru
[2], oemfru
[3], oemfru
[4]);
3737 " Revision # : %c%c\n",
3738 oemfru
[5], oemfru
[6]);
3740 " Supplier # : %c%c\n",
3741 oemfru
[7], oemfru
[8]);
3744 oemfru
[9], oemfru
[10]);
3746 " Sequence # : %c%c%c\n",
3747 oemfru
[11], oemfru
[12], oemfru
[13]);
3751 case VENDOR2_FRU_FORMAT
:
3753 seq_printf(seq
, "FRU Information:\n");
3756 "%c%c%c%c%c%c%c%c\n",
3757 oemfru
[0], oemfru
[1], oemfru
[2],
3758 oemfru
[3], oemfru
[4], oemfru
[5],
3759 oemfru
[6], oemfru
[7]);
3761 " Supplier # : %c%c%c%c%c\n",
3762 oemfru
[8], oemfru
[9], oemfru
[10],
3763 oemfru
[11], oemfru
[12]);
3766 oemfru
[13], oemfru
[14], oemfru
[15]);
3768 " Sequence # : %c%c%c%c\n",
3769 oemfru
[16], oemfru
[17], oemfru
[18],
3774 case VENDOR3_FRU_FORMAT
:
3776 seq_printf(seq
, "FRU Information:\n");
3779 case VENDOR4_FRU_FORMAT
:
3781 seq_printf(seq
, "FRU Information:\n");
3784 "%c%c%c%c%c%c%c%c\n",
3785 oemfru
[0], oemfru
[1], oemfru
[2],
3786 oemfru
[3], oemfru
[4], oemfru
[5],
3787 oemfru
[6], oemfru
[7]);
3790 "%c%c%c%c%c%c%c%c\n",
3791 oemfru
[8], oemfru
[9], oemfru
[10],
3792 oemfru
[11], oemfru
[12], oemfru
[13],
3793 oemfru
[14], oemfru
[15]);
3796 "%c%c%c%c%c%c%c%c\n",
3797 oemfru
[16], oemfru
[17], oemfru
[18],
3798 oemfru
[19], oemfru
[20], oemfru
[21],
3799 oemfru
[22], oemfru
[23]);
3811 static int slic_debug_adapter_show(struct seq_file
*seq
, void *v
)
3813 struct adapter
*adapter
= seq
->private;
3815 if ((adapter
->netdev
) && (adapter
->netdev
->name
)) {
3816 seq_printf(seq
, "info: interface : %s\n",
3817 adapter
->netdev
->name
);
3819 seq_printf(seq
, "info: status : %s\n",
3820 SLIC_LINKSTATE(adapter
->linkstate
));
3821 seq_printf(seq
, "info: port : %d\n",
3823 seq_printf(seq
, "info: speed : %s\n",
3824 SLIC_SPEED(adapter
->linkspeed
));
3825 seq_printf(seq
, "info: duplex : %s\n",
3826 SLIC_DUPLEX(adapter
->linkduplex
));
3827 seq_printf(seq
, "info: irq : 0x%X\n",
3828 (uint
) adapter
->irq
);
3829 seq_printf(seq
, "info: Interrupt Agg Delay: %d usec\n",
3830 adapter
->card
->loadlevel_current
);
3831 seq_printf(seq
, "info: RcvQ max entries : %4.4X\n",
3833 seq_printf(seq
, "info: RcvQ current : %4.4X\n",
3834 adapter
->rcvqueue
.count
);
3835 seq_printf(seq
, "rx stats: packets : %8.8lX\n",
3836 adapter
->stats
.rx_packets
);
3837 seq_printf(seq
, "rx stats: bytes : %8.8lX\n",
3838 adapter
->stats
.rx_bytes
);
3839 seq_printf(seq
, "rx stats: broadcasts : %8.8X\n",
3840 adapter
->rcv_broadcasts
);
3841 seq_printf(seq
, "rx stats: multicasts : %8.8X\n",
3842 adapter
->rcv_multicasts
);
3843 seq_printf(seq
, "rx stats: unicasts : %8.8X\n",
3844 adapter
->rcv_unicasts
);
3845 seq_printf(seq
, "rx stats: errors : %8.8X\n",
3846 (u32
) adapter
->slic_stats
.iface
.rcv_errors
);
3847 seq_printf(seq
, "rx stats: Missed errors : %8.8X\n",
3848 (u32
) adapter
->slic_stats
.iface
.rcv_discards
);
3849 seq_printf(seq
, "rx stats: drops : %8.8X\n",
3850 (u32
) adapter
->rcv_drops
);
3851 seq_printf(seq
, "tx stats: packets : %8.8lX\n",
3852 adapter
->stats
.tx_packets
);
3853 seq_printf(seq
, "tx stats: bytes : %8.8lX\n",
3854 adapter
->stats
.tx_bytes
);
3855 seq_printf(seq
, "tx stats: errors : %8.8X\n",
3856 (u32
) adapter
->slic_stats
.iface
.xmt_errors
);
3857 seq_printf(seq
, "rx stats: multicasts : %8.8lX\n",
3858 adapter
->stats
.multicast
);
3859 seq_printf(seq
, "tx stats: collision errors : %8.8X\n",
3860 (u32
) adapter
->slic_stats
.iface
.xmit_collisions
);
3861 seq_printf(seq
, "perf: Max rcv frames/isr : %8.8X\n",
3862 adapter
->max_isr_rcvs
);
3863 seq_printf(seq
, "perf: Rcv interrupt yields : %8.8X\n",
3864 adapter
->rcv_interrupt_yields
);
3865 seq_printf(seq
, "perf: Max xmit complete/isr : %8.8X\n",
3866 adapter
->max_isr_xmits
);
3867 seq_printf(seq
, "perf: error interrupts : %8.8X\n",
3868 adapter
->error_interrupts
);
3869 seq_printf(seq
, "perf: error rmiss interrupts : %8.8X\n",
3870 adapter
->error_rmiss_interrupts
);
3871 seq_printf(seq
, "perf: rcv interrupts : %8.8X\n",
3872 adapter
->rcv_interrupts
);
3873 seq_printf(seq
, "perf: xmit interrupts : %8.8X\n",
3874 adapter
->xmit_interrupts
);
3875 seq_printf(seq
, "perf: link event interrupts : %8.8X\n",
3876 adapter
->linkevent_interrupts
);
3877 seq_printf(seq
, "perf: UPR interrupts : %8.8X\n",
3878 adapter
->upr_interrupts
);
3879 seq_printf(seq
, "perf: interrupt count : %8.8X\n",
3881 seq_printf(seq
, "perf: false interrupts : %8.8X\n",
3882 adapter
->false_interrupts
);
3883 seq_printf(seq
, "perf: All register writes : %8.8X\n",
3884 adapter
->all_reg_writes
);
3885 seq_printf(seq
, "perf: ICR register writes : %8.8X\n",
3886 adapter
->icr_reg_writes
);
3887 seq_printf(seq
, "perf: ISR register writes : %8.8X\n",
3888 adapter
->isr_reg_writes
);
3889 seq_printf(seq
, "ifevents: overflow 802 errors : %8.8X\n",
3890 adapter
->if_events
.oflow802
);
3891 seq_printf(seq
, "ifevents: transport overflow errors: %8.8X\n",
3892 adapter
->if_events
.Tprtoflow
);
3893 seq_printf(seq
, "ifevents: underflow errors : %8.8X\n",
3894 adapter
->if_events
.uflow802
);
3895 seq_printf(seq
, "ifevents: receive early : %8.8X\n",
3896 adapter
->if_events
.rcvearly
);
3897 seq_printf(seq
, "ifevents: buffer overflows : %8.8X\n",
3898 adapter
->if_events
.Bufov
);
3899 seq_printf(seq
, "ifevents: carrier errors : %8.8X\n",
3900 adapter
->if_events
.Carre
);
3901 seq_printf(seq
, "ifevents: Long : %8.8X\n",
3902 adapter
->if_events
.Longe
);
3903 seq_printf(seq
, "ifevents: invalid preambles : %8.8X\n",
3904 adapter
->if_events
.Invp
);
3905 seq_printf(seq
, "ifevents: CRC errors : %8.8X\n",
3906 adapter
->if_events
.Crc
);
3907 seq_printf(seq
, "ifevents: dribble nibbles : %8.8X\n",
3908 adapter
->if_events
.Drbl
);
3909 seq_printf(seq
, "ifevents: Code violations : %8.8X\n",
3910 adapter
->if_events
.Code
);
3911 seq_printf(seq
, "ifevents: TCP checksum errors : %8.8X\n",
3912 adapter
->if_events
.TpCsum
);
3913 seq_printf(seq
, "ifevents: TCP header short errors : %8.8X\n",
3914 adapter
->if_events
.TpHlen
);
3915 seq_printf(seq
, "ifevents: IP checksum errors : %8.8X\n",
3916 adapter
->if_events
.IpCsum
);
3917 seq_printf(seq
, "ifevents: IP frame incompletes : %8.8X\n",
3918 adapter
->if_events
.IpLen
);
3919 seq_printf(seq
, "ifevents: IP headers shorts : %8.8X\n",
3920 adapter
->if_events
.IpHlen
);
3924 static int slic_debug_adapter_open(struct inode
*inode
, struct file
*file
)
3926 return single_open(file
, slic_debug_adapter_show
, inode
->i_private
);
3929 static int slic_debug_card_open(struct inode
*inode
, struct file
*file
)
3931 return single_open(file
, slic_debug_card_show
, inode
->i_private
);
3934 static const struct file_operations slic_debug_adapter_fops
= {
3935 .owner
= THIS_MODULE
,
3936 .open
= slic_debug_adapter_open
,
3938 .llseek
= seq_lseek
,
3939 .release
= single_release
,
3942 static const struct file_operations slic_debug_card_fops
= {
3943 .owner
= THIS_MODULE
,
3944 .open
= slic_debug_card_open
,
3946 .llseek
= seq_lseek
,
3947 .release
= single_release
,
3950 static void slic_debug_adapter_create(struct adapter
*adapter
)
3954 struct sliccard
*card
= adapter
->card
;
3956 if (!card
->debugfs_dir
)
3959 sprintf(name
, "port%d", adapter
->port
);
3960 d
= debugfs_create_file(name
, S_IRUGO
,
3961 card
->debugfs_dir
, adapter
,
3962 &slic_debug_adapter_fops
);
3963 if (!d
|| IS_ERR(d
))
3964 pr_info(PFX
"%s: debugfs create failed\n", name
);
3966 adapter
->debugfs_entry
= d
;
3969 static void slic_debug_adapter_destroy(struct adapter
*adapter
)
3971 if (adapter
->debugfs_entry
) {
3972 debugfs_remove(adapter
->debugfs_entry
);
3973 adapter
->debugfs_entry
= NULL
;
3977 static void slic_debug_card_create(struct sliccard
*card
)
3980 char name
[IFNAMSIZ
];
3982 snprintf(name
, sizeof(name
), "slic%d", card
->cardnum
);
3983 d
= debugfs_create_dir(name
, slic_debugfs
);
3984 if (!d
|| IS_ERR(d
))
3985 pr_info(PFX
"%s: debugfs create dir failed\n",
3988 card
->debugfs_dir
= d
;
3989 d
= debugfs_create_file("cardinfo", S_IRUGO
,
3991 &slic_debug_card_fops
);
3992 if (!d
|| IS_ERR(d
))
3993 pr_info(PFX
"%s: debugfs create failed\n",
3996 card
->debugfs_cardinfo
= d
;
4000 static void slic_debug_card_destroy(struct sliccard
*card
)
4004 for (i
= 0; i
< card
->card_size
; i
++) {
4005 struct adapter
*adapter
;
4007 adapter
= card
->adapter
[i
];
4009 slic_debug_adapter_destroy(adapter
);
4011 if (card
->debugfs_cardinfo
) {
4012 debugfs_remove(card
->debugfs_cardinfo
);
4013 card
->debugfs_cardinfo
= NULL
;
4015 if (card
->debugfs_dir
) {
4016 debugfs_remove(card
->debugfs_dir
);
4017 card
->debugfs_dir
= NULL
;
4021 static void slic_debug_init(void)
4025 ent
= debugfs_create_dir("slic", NULL
);
4026 if (!ent
|| IS_ERR(ent
)) {
4027 pr_info(PFX
"debugfs create directory failed\n");
4034 static void slic_debug_cleanup(void)
4037 debugfs_remove(slic_debugfs
);
4038 slic_debugfs
= NULL
;
4042 /******************************************************************************/
4043 /**************** MODULE INITIATION / TERMINATION FUNCTIONS ***************/
4044 /******************************************************************************/
4046 static struct pci_driver slic_driver
= {
4048 .id_table
= slic_pci_tbl
,
4049 .probe
= slic_entry_probe
,
4050 .remove
= __devexit_p(slic_entry_remove
),
4053 static int __init
slic_module_init(void)
4057 if (debug
>= 0 && slic_debug
!= debug
)
4058 printk(KERN_DEBUG KBUILD_MODNAME
": debug level is %d.\n",
4063 return pci_register_driver(&slic_driver
);
4066 static void __exit
slic_module_cleanup(void)
4068 pci_unregister_driver(&slic_driver
);
4069 slic_debug_cleanup();
4072 module_init(slic_module_init
);
4073 module_exit(slic_module_cleanup
);