2006-10-21 19:33:03 +00:00
|
|
|
/*
|
2009-02-25 15:57:56 +00:00
|
|
|
* Copyright (C) 2003 - 2009 NetXen, Inc.
|
2009-09-11 11:28:15 +00:00
|
|
|
* Copyright (C) 2009 - QLogic Corporation.
|
2006-10-21 19:33:03 +00:00
|
|
|
* All rights reserved.
|
2006-12-04 17:18:00 +00:00
|
|
|
*
|
2006-10-21 19:33:03 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2006-12-04 17:18:00 +00:00
|
|
|
*
|
2006-10-21 19:33:03 +00:00
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2006-12-04 17:18:00 +00:00
|
|
|
*
|
2006-10-21 19:33:03 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
|
|
|
* MA 02111-1307, USA.
|
2006-12-04 17:18:00 +00:00
|
|
|
*
|
2006-10-21 19:33:03 +00:00
|
|
|
* The full GNU General Public License is included in this distribution
|
2010-01-14 01:53:23 +00:00
|
|
|
* in the file called "COPYING".
|
2006-12-04 17:18:00 +00:00
|
|
|
*
|
2006-10-21 19:33:03 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/delay.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2006-10-21 19:33:03 +00:00
|
|
|
#include "netxen_nic.h"
|
|
|
|
#include "netxen_nic_hw.h"
|
|
|
|
|
|
|
|
struct crb_addr_pair {
|
2007-02-28 13:16:40 +00:00
|
|
|
u32 addr;
|
|
|
|
u32 data;
|
2006-10-21 19:33:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define NETXEN_MAX_CRB_XFORM 60
|
|
|
|
static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
|
2007-02-28 13:16:40 +00:00
|
|
|
#define NETXEN_ADDR_ERROR (0xffffffff)
|
2006-10-21 19:33:03 +00:00
|
|
|
|
|
|
|
#define crb_addr_transform(name) \
|
|
|
|
crb_addr_xform[NETXEN_HW_PX_MAP_CRB_##name] = \
|
|
|
|
NETXEN_HW_CRB_HUB_AGT_ADR_##name << 20
|
|
|
|
|
2006-11-29 17:00:10 +00:00
|
|
|
#define NETXEN_NIC_XDMA_RESET 0x8000ff
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
static void
|
2009-03-13 14:52:05 +00:00
|
|
|
netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
|
|
|
|
struct nx_host_rds_ring *rds_ring);
|
2009-10-24 16:03:58 +00:00
|
|
|
static int netxen_p3_has_mn(struct netxen_adapter *adapter);
|
2007-11-05 17:07:31 +00:00
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
static void crb_addr_transform_setup(void)
|
|
|
|
{
|
|
|
|
crb_addr_transform(XDMA);
|
|
|
|
crb_addr_transform(TIMR);
|
|
|
|
crb_addr_transform(SRE);
|
|
|
|
crb_addr_transform(SQN3);
|
|
|
|
crb_addr_transform(SQN2);
|
|
|
|
crb_addr_transform(SQN1);
|
|
|
|
crb_addr_transform(SQN0);
|
|
|
|
crb_addr_transform(SQS3);
|
|
|
|
crb_addr_transform(SQS2);
|
|
|
|
crb_addr_transform(SQS1);
|
|
|
|
crb_addr_transform(SQS0);
|
|
|
|
crb_addr_transform(RPMX7);
|
|
|
|
crb_addr_transform(RPMX6);
|
|
|
|
crb_addr_transform(RPMX5);
|
|
|
|
crb_addr_transform(RPMX4);
|
|
|
|
crb_addr_transform(RPMX3);
|
|
|
|
crb_addr_transform(RPMX2);
|
|
|
|
crb_addr_transform(RPMX1);
|
|
|
|
crb_addr_transform(RPMX0);
|
|
|
|
crb_addr_transform(ROMUSB);
|
|
|
|
crb_addr_transform(SN);
|
|
|
|
crb_addr_transform(QMN);
|
|
|
|
crb_addr_transform(QMS);
|
|
|
|
crb_addr_transform(PGNI);
|
|
|
|
crb_addr_transform(PGND);
|
|
|
|
crb_addr_transform(PGN3);
|
|
|
|
crb_addr_transform(PGN2);
|
|
|
|
crb_addr_transform(PGN1);
|
|
|
|
crb_addr_transform(PGN0);
|
|
|
|
crb_addr_transform(PGSI);
|
|
|
|
crb_addr_transform(PGSD);
|
|
|
|
crb_addr_transform(PGS3);
|
|
|
|
crb_addr_transform(PGS2);
|
|
|
|
crb_addr_transform(PGS1);
|
|
|
|
crb_addr_transform(PGS0);
|
|
|
|
crb_addr_transform(PS);
|
|
|
|
crb_addr_transform(PH);
|
|
|
|
crb_addr_transform(NIU);
|
|
|
|
crb_addr_transform(I2Q);
|
|
|
|
crb_addr_transform(EG);
|
|
|
|
crb_addr_transform(MN);
|
|
|
|
crb_addr_transform(MS);
|
|
|
|
crb_addr_transform(CAS2);
|
|
|
|
crb_addr_transform(CAS1);
|
|
|
|
crb_addr_transform(CAS0);
|
|
|
|
crb_addr_transform(CAM);
|
|
|
|
crb_addr_transform(C2C1);
|
|
|
|
crb_addr_transform(C2C0);
|
2007-02-05 15:35:26 +00:00
|
|
|
crb_addr_transform(SMB);
|
2008-07-22 02:44:02 +00:00
|
|
|
crb_addr_transform(OCM0);
|
|
|
|
crb_addr_transform(I2C0);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
void netxen_release_rx_buffers(struct netxen_adapter *adapter)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2008-07-22 02:44:04 +00:00
|
|
|
struct netxen_recv_context *recv_ctx;
|
2008-07-22 02:44:06 +00:00
|
|
|
struct nx_host_rds_ring *rds_ring;
|
2008-07-22 02:44:04 +00:00
|
|
|
struct netxen_rx_buffer *rx_buf;
|
2009-03-09 08:50:55 +00:00
|
|
|
int i, ring;
|
|
|
|
|
|
|
|
recv_ctx = &adapter->recv_ctx;
|
|
|
|
for (ring = 0; ring < adapter->max_rds_rings; ring++) {
|
|
|
|
rds_ring = &recv_ctx->rds_rings[ring];
|
2009-03-13 14:52:03 +00:00
|
|
|
for (i = 0; i < rds_ring->num_desc; ++i) {
|
2009-03-09 08:50:55 +00:00
|
|
|
rx_buf = &(rds_ring->rx_buf_arr[i]);
|
|
|
|
if (rx_buf->state == NETXEN_BUFFER_FREE)
|
|
|
|
continue;
|
|
|
|
pci_unmap_single(adapter->pdev,
|
|
|
|
rx_buf->dma,
|
|
|
|
rds_ring->dma_size,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
if (rx_buf->skb != NULL)
|
|
|
|
dev_kfree_skb_any(rx_buf->skb);
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void netxen_release_tx_buffers(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct netxen_cmd_buffer *cmd_buf;
|
|
|
|
struct netxen_skb_frag *buffrag;
|
|
|
|
int i, j;
|
2009-04-28 15:29:10 +00:00
|
|
|
struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-04-07 22:50:40 +00:00
|
|
|
cmd_buf = tx_ring->cmd_buf_arr;
|
|
|
|
for (i = 0; i < tx_ring->num_desc; i++) {
|
2008-07-22 02:44:04 +00:00
|
|
|
buffrag = cmd_buf->frag_array;
|
|
|
|
if (buffrag->dma) {
|
|
|
|
pci_unmap_single(adapter->pdev, buffrag->dma,
|
|
|
|
buffrag->length, PCI_DMA_TODEVICE);
|
|
|
|
buffrag->dma = 0ULL;
|
|
|
|
}
|
|
|
|
for (j = 0; j < cmd_buf->frag_count; j++) {
|
|
|
|
buffrag++;
|
|
|
|
if (buffrag->dma) {
|
|
|
|
pci_unmap_page(adapter->pdev, buffrag->dma,
|
|
|
|
buffrag->length,
|
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
buffrag->dma = 0ULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cmd_buf->skb) {
|
|
|
|
dev_kfree_skb_any(cmd_buf->skb);
|
|
|
|
cmd_buf->skb = NULL;
|
|
|
|
}
|
|
|
|
cmd_buf++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void netxen_free_sw_resources(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct netxen_recv_context *recv_ctx;
|
2008-07-22 02:44:06 +00:00
|
|
|
struct nx_host_rds_ring *rds_ring;
|
2009-04-07 22:50:40 +00:00
|
|
|
struct nx_host_tx_ring *tx_ring;
|
2009-03-09 08:50:55 +00:00
|
|
|
int ring;
|
|
|
|
|
|
|
|
recv_ctx = &adapter->recv_ctx;
|
2009-04-28 15:29:10 +00:00
|
|
|
|
|
|
|
if (recv_ctx->rds_rings == NULL)
|
|
|
|
goto skip_rds;
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
for (ring = 0; ring < adapter->max_rds_rings; ring++) {
|
|
|
|
rds_ring = &recv_ctx->rds_rings[ring];
|
2009-06-11 09:49:10 +00:00
|
|
|
vfree(rds_ring->rx_buf_arr);
|
|
|
|
rds_ring->rx_buf_arr = NULL;
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
2009-04-28 15:29:10 +00:00
|
|
|
kfree(recv_ctx->rds_rings);
|
|
|
|
|
|
|
|
skip_rds:
|
|
|
|
if (adapter->tx_ring == NULL)
|
|
|
|
return;
|
2009-03-09 08:50:55 +00:00
|
|
|
|
2009-04-28 15:29:10 +00:00
|
|
|
tx_ring = adapter->tx_ring;
|
2009-06-11 09:49:10 +00:00
|
|
|
vfree(tx_ring->cmd_buf_arr);
|
2010-01-07 22:10:14 +00:00
|
|
|
kfree(tx_ring);
|
|
|
|
adapter->tx_ring = NULL;
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct netxen_recv_context *recv_ctx;
|
2008-07-22 02:44:06 +00:00
|
|
|
struct nx_host_rds_ring *rds_ring;
|
2009-03-13 14:52:05 +00:00
|
|
|
struct nx_host_sds_ring *sds_ring;
|
2009-04-28 15:29:10 +00:00
|
|
|
struct nx_host_tx_ring *tx_ring;
|
2008-07-22 02:44:04 +00:00
|
|
|
struct netxen_rx_buffer *rx_buf;
|
2009-04-28 15:29:10 +00:00
|
|
|
int ring, i, size;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
struct netxen_cmd_buffer *cmd_buf_arr;
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
2009-04-07 22:50:40 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-04-28 15:29:10 +00:00
|
|
|
size = sizeof(struct nx_host_tx_ring);
|
|
|
|
tx_ring = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (tx_ring == NULL) {
|
|
|
|
dev_err(&pdev->dev, "%s: failed to allocate tx ring struct\n",
|
|
|
|
netdev->name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
adapter->tx_ring = tx_ring;
|
|
|
|
|
2009-04-07 22:50:40 +00:00
|
|
|
tx_ring->num_desc = adapter->num_txd;
|
2009-07-17 15:27:07 +00:00
|
|
|
tx_ring->txq = netdev_get_tx_queue(netdev, 0);
|
2009-04-28 15:29:10 +00:00
|
|
|
|
2010-11-22 00:15:06 +00:00
|
|
|
cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
|
2008-07-22 02:44:04 +00:00
|
|
|
if (cmd_buf_arr == NULL) {
|
2009-04-07 22:50:40 +00:00
|
|
|
dev_err(&pdev->dev, "%s: failed to allocate cmd buffer ring\n",
|
2008-07-22 02:44:04 +00:00
|
|
|
netdev->name);
|
2010-06-13 23:39:03 +00:00
|
|
|
goto err_out;
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
2009-04-07 22:50:40 +00:00
|
|
|
tx_ring->cmd_buf_arr = cmd_buf_arr;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
recv_ctx = &adapter->recv_ctx;
|
2009-04-28 15:29:10 +00:00
|
|
|
|
|
|
|
size = adapter->max_rds_rings * sizeof (struct nx_host_rds_ring);
|
|
|
|
rds_ring = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (rds_ring == NULL) {
|
|
|
|
dev_err(&pdev->dev, "%s: failed to allocate rds ring struct\n",
|
|
|
|
netdev->name);
|
2010-06-13 23:39:03 +00:00
|
|
|
goto err_out;
|
2009-04-28 15:29:10 +00:00
|
|
|
}
|
|
|
|
recv_ctx->rds_rings = rds_ring;
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
for (ring = 0; ring < adapter->max_rds_rings; ring++) {
|
|
|
|
rds_ring = &recv_ctx->rds_rings[ring];
|
2009-03-13 14:52:03 +00:00
|
|
|
switch (ring) {
|
|
|
|
case RCV_RING_NORMAL:
|
|
|
|
rds_ring->num_desc = adapter->num_rxd;
|
2009-03-09 08:50:55 +00:00
|
|
|
if (adapter->ahw.cut_through) {
|
|
|
|
rds_ring->dma_size =
|
|
|
|
NX_CT_DEFAULT_RX_BUF_LEN;
|
2008-07-22 02:44:06 +00:00
|
|
|
rds_ring->skb_size =
|
2009-03-09 08:50:55 +00:00
|
|
|
NX_CT_DEFAULT_RX_BUF_LEN;
|
|
|
|
} else {
|
2009-07-26 20:07:44 +00:00
|
|
|
if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
|
|
|
|
rds_ring->dma_size =
|
|
|
|
NX_P3_RX_BUF_MAX_LEN;
|
|
|
|
else
|
|
|
|
rds_ring->dma_size =
|
|
|
|
NX_P2_RX_BUF_MAX_LEN;
|
2009-03-09 08:50:55 +00:00
|
|
|
rds_ring->skb_size =
|
2009-07-26 20:07:44 +00:00
|
|
|
rds_ring->dma_size + NET_IP_ALIGN;
|
2009-03-09 08:50:55 +00:00
|
|
|
}
|
|
|
|
break;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-03-13 14:52:03 +00:00
|
|
|
case RCV_RING_JUMBO:
|
|
|
|
rds_ring->num_desc = adapter->num_jumbo_rxd;
|
2009-03-09 08:50:55 +00:00
|
|
|
if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
|
|
|
|
rds_ring->dma_size =
|
|
|
|
NX_P3_RX_JUMBO_BUF_MAX_LEN;
|
|
|
|
else
|
|
|
|
rds_ring->dma_size =
|
|
|
|
NX_P2_RX_JUMBO_BUF_MAX_LEN;
|
2009-09-03 13:10:53 +00:00
|
|
|
|
|
|
|
if (adapter->capabilities & NX_CAP0_HW_LRO)
|
|
|
|
rds_ring->dma_size += NX_LRO_BUFFER_EXTRA;
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
rds_ring->skb_size =
|
|
|
|
rds_ring->dma_size + NET_IP_ALIGN;
|
|
|
|
break;
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
case RCV_RING_LRO:
|
2009-03-13 14:52:03 +00:00
|
|
|
rds_ring->num_desc = adapter->num_lro_rxd;
|
2009-07-26 20:07:44 +00:00
|
|
|
rds_ring->dma_size = NX_RX_LRO_BUFFER_LENGTH;
|
|
|
|
rds_ring->skb_size = rds_ring->dma_size + NET_IP_ALIGN;
|
2009-03-09 08:50:55 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
2010-11-27 23:05:43 +00:00
|
|
|
rds_ring->rx_buf_arr = vzalloc(RCV_BUFF_RINGSIZE(rds_ring));
|
2009-03-09 08:50:55 +00:00
|
|
|
if (rds_ring->rx_buf_arr == NULL) {
|
|
|
|
printk(KERN_ERR "%s: Failed to allocate "
|
|
|
|
"rx buffer ring %d\n",
|
|
|
|
netdev->name, ring);
|
|
|
|
/* free whatever was already allocated */
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
INIT_LIST_HEAD(&rds_ring->free_list);
|
|
|
|
/*
|
|
|
|
* Now go through all of them, set reference handles
|
|
|
|
* and put them in the queues.
|
|
|
|
*/
|
|
|
|
rx_buf = rds_ring->rx_buf_arr;
|
2009-04-28 15:29:10 +00:00
|
|
|
for (i = 0; i < rds_ring->num_desc; i++) {
|
2009-03-09 08:50:55 +00:00
|
|
|
list_add_tail(&rx_buf->list,
|
|
|
|
&rds_ring->free_list);
|
|
|
|
rx_buf->ref_handle = i;
|
|
|
|
rx_buf->state = NETXEN_BUFFER_FREE;
|
|
|
|
rx_buf++;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2009-03-13 14:52:05 +00:00
|
|
|
spin_lock_init(&rds_ring->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ring = 0; ring < adapter->max_sds_rings; ring++) {
|
|
|
|
sds_ring = &recv_ctx->sds_rings[ring];
|
|
|
|
sds_ring->irq = adapter->msix_entries[ring].vector;
|
|
|
|
sds_ring->adapter = adapter;
|
|
|
|
sds_ring->num_desc = adapter->num_rxd;
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_RCV_DESC_RINGS; i++)
|
|
|
|
INIT_LIST_HEAD(&sds_ring->free_list[i]);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
netxen_free_sw_resources(adapter);
|
|
|
|
return -ENOMEM;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
|
|
|
|
* address to external PCI CRB address.
|
|
|
|
*/
|
2007-11-05 17:07:31 +00:00
|
|
|
static u32 netxen_decode_crb_addr(u32 addr)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
|
|
|
int i;
|
2007-02-28 13:16:40 +00:00
|
|
|
u32 base_addr, offset, pci_base;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
|
|
|
crb_addr_transform_setup();
|
|
|
|
|
|
|
|
pci_base = NETXEN_ADDR_ERROR;
|
|
|
|
base_addr = addr & 0xfff00000;
|
|
|
|
offset = addr & 0x000fffff;
|
|
|
|
|
|
|
|
for (i = 0; i < NETXEN_MAX_CRB_XFORM; i++) {
|
|
|
|
if (crb_addr_xform[i] == base_addr) {
|
|
|
|
pci_base = i << 20;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pci_base == NETXEN_ADDR_ERROR)
|
|
|
|
return pci_base;
|
|
|
|
else
|
2010-09-23 05:40:09 +00:00
|
|
|
return pci_base + offset;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-08-24 19:23:26 +00:00
|
|
|
#define NETXEN_MAX_ROM_WAIT_USEC 100
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2007-11-05 17:07:31 +00:00
|
|
|
static int netxen_wait_rom_done(struct netxen_adapter *adapter)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
|
|
|
long timeout = 0;
|
|
|
|
long done = 0;
|
|
|
|
|
2009-01-15 04:49:00 +00:00
|
|
|
cond_resched();
|
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
while (done == 0) {
|
2009-04-07 22:50:45 +00:00
|
|
|
done = NXRD32(adapter, NETXEN_ROMUSB_GLB_STATUS);
|
2006-10-21 19:33:03 +00:00
|
|
|
done &= 2;
|
2009-08-24 19:23:26 +00:00
|
|
|
if (++timeout >= NETXEN_MAX_ROM_WAIT_USEC) {
|
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"Timeout reached waiting for rom done");
|
2006-10-21 19:33:03 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
2009-08-24 19:23:26 +00:00
|
|
|
udelay(1);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-05 17:07:31 +00:00
|
|
|
static int do_rom_fast_read(struct netxen_adapter *adapter,
|
|
|
|
int addr, int *valp)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
|
2006-10-21 19:33:03 +00:00
|
|
|
if (netxen_wait_rom_done(adapter)) {
|
|
|
|
printk("Error waiting for rom done\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
/* reset abyte_cnt and dummy_byte_cnt */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
|
2009-01-15 04:49:00 +00:00
|
|
|
udelay(10);
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-04-07 22:50:45 +00:00
|
|
|
*valp = NXRD32(adapter, NETXEN_ROMUSB_ROM_RDATA);
|
2006-10-21 19:33:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-05 17:07:31 +00:00
|
|
|
static int do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
|
|
|
|
u8 *bytes, size_t size)
|
2007-02-05 15:40:49 +00:00
|
|
|
{
|
|
|
|
int addridx;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
for (addridx = addr; addridx < (addr + size); addridx += 4) {
|
2007-12-22 19:44:00 +00:00
|
|
|
int v;
|
|
|
|
ret = do_rom_fast_read(adapter, addridx, &v);
|
2007-02-05 15:40:49 +00:00
|
|
|
if (ret != 0)
|
|
|
|
break;
|
2007-12-22 19:44:00 +00:00
|
|
|
*(__le32 *)bytes = cpu_to_le32(v);
|
2007-02-05 15:40:49 +00:00
|
|
|
bytes += 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2007-11-24 02:23:36 +00:00
|
|
|
netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
|
2007-02-05 15:40:49 +00:00
|
|
|
u8 *bytes, size_t size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2009-08-24 19:23:26 +00:00
|
|
|
ret = netxen_rom_lock(adapter);
|
2007-02-05 15:40:49 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = do_rom_fast_read_words(adapter, addr, bytes, size);
|
|
|
|
|
|
|
|
netxen_rom_unlock(adapter);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2009-08-24 19:23:26 +00:00
|
|
|
if (netxen_rom_lock(adapter) != 0)
|
2006-10-21 19:33:03 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
ret = do_rom_fast_read(adapter, addr, valp);
|
2006-11-29 17:00:10 +00:00
|
|
|
netxen_rom_unlock(adapter);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
#define NETXEN_BOARDTYPE 0x4008
|
|
|
|
#define NETXEN_BOARDNUM 0x400c
|
|
|
|
#define NETXEN_CHIPNUM 0x4010
|
|
|
|
|
2009-10-16 15:50:08 +00:00
|
|
|
int netxen_pinit_from_rom(struct netxen_adapter *adapter)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2008-06-16 05:59:45 +00:00
|
|
|
int addr, val;
|
2009-01-15 04:49:00 +00:00
|
|
|
int i, n, init_delay = 0;
|
2006-10-21 19:33:03 +00:00
|
|
|
struct crb_addr_pair *buf;
|
2009-01-15 04:49:00 +00:00
|
|
|
unsigned offset;
|
2007-02-28 13:16:40 +00:00
|
|
|
u32 off;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
|
|
|
/* resetall */
|
2009-08-24 19:23:26 +00:00
|
|
|
netxen_rom_lock(adapter);
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0xffffffff);
|
2009-01-15 04:49:00 +00:00
|
|
|
netxen_rom_unlock(adapter);
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
|
|
|
|
if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
|
2009-01-15 04:49:00 +00:00
|
|
|
(n != 0xcafecafe) ||
|
2008-07-22 02:44:04 +00:00
|
|
|
netxen_rom_fast_read(adapter, 4, &n) != 0) {
|
|
|
|
printk(KERN_ERR "%s: ERROR Reading crb_init area: "
|
|
|
|
"n: %08x\n", netxen_nic_driver_name, n);
|
2006-10-21 19:33:03 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
offset = n & 0xffffU;
|
|
|
|
n = (n >> 16) & 0xffffU;
|
|
|
|
} else {
|
|
|
|
if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
|
|
|
|
!(n & 0x80000000)) {
|
|
|
|
printk(KERN_ERR "%s: ERROR Reading crb_init area: "
|
|
|
|
"n: %08x\n", netxen_nic_driver_name, n);
|
|
|
|
return -EIO;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
offset = 1;
|
|
|
|
n &= ~0x80000000;
|
|
|
|
}
|
|
|
|
|
2009-10-16 15:50:08 +00:00
|
|
|
if (n >= 1024) {
|
2008-07-22 02:44:04 +00:00
|
|
|
printk(KERN_ERR "%s:n=0x%x Error! NetXen card flash not"
|
|
|
|
" initialized.\n", __func__, n);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
|
|
|
|
if (buf == NULL) {
|
|
|
|
printk("%s: netxen_pinit_from_rom: Unable to calloc memory.\n",
|
|
|
|
netxen_nic_driver_name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-10-16 15:50:08 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
|
2009-01-29 08:55:56 +00:00
|
|
|
netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
|
|
|
|
kfree(buf);
|
2008-07-22 02:44:04 +00:00
|
|
|
return -EIO;
|
2009-01-29 08:55:56 +00:00
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
buf[i].addr = addr;
|
|
|
|
buf[i].data = val;
|
|
|
|
|
|
|
|
}
|
2009-10-16 15:50:08 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
|
|
|
|
off = netxen_decode_crb_addr(buf[i].addr);
|
|
|
|
if (off == NETXEN_ADDR_ERROR) {
|
|
|
|
printk(KERN_ERR"CRB init value out of range %x\n",
|
2007-02-05 15:35:26 +00:00
|
|
|
buf[i].addr);
|
2008-07-22 02:44:04 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
off += NETXEN_PCI_CRBSPACE;
|
2009-10-16 15:50:08 +00:00
|
|
|
|
|
|
|
if (off & 1)
|
|
|
|
continue;
|
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
/* skipping cold reboot MAGIC */
|
|
|
|
if (off == NETXEN_CAM_RAM(0x1fc))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
|
2009-10-21 19:39:01 +00:00
|
|
|
if (off == (NETXEN_CRB_I2C0 + 0x1c))
|
|
|
|
continue;
|
2008-07-22 02:44:04 +00:00
|
|
|
/* do not reset PCI */
|
|
|
|
if (off == (ROMUSB_GLB + 0xbc))
|
2007-02-05 15:35:26 +00:00
|
|
|
continue;
|
2009-01-15 04:49:00 +00:00
|
|
|
if (off == (ROMUSB_GLB + 0xa8))
|
|
|
|
continue;
|
|
|
|
if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
|
|
|
|
continue;
|
|
|
|
if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
|
|
|
|
continue;
|
|
|
|
if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
|
|
|
|
continue;
|
2009-11-30 05:54:55 +00:00
|
|
|
if ((off & 0x0ff00000) == NETXEN_CRB_DDR_NET)
|
|
|
|
continue;
|
2009-10-16 15:50:08 +00:00
|
|
|
if (off == (NETXEN_CRB_PEG_NET_1 + 0x18) &&
|
|
|
|
!NX_IS_REVISION_P3P(adapter->ahw.revision_id))
|
2008-07-22 02:44:04 +00:00
|
|
|
buf[i].data = 0x1020;
|
|
|
|
/* skip the function enable register */
|
|
|
|
if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION))
|
2006-10-21 19:33:03 +00:00
|
|
|
continue;
|
2008-07-22 02:44:04 +00:00
|
|
|
if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION2))
|
|
|
|
continue;
|
|
|
|
if ((off & 0x0ff00000) == NETXEN_CRB_SMB)
|
|
|
|
continue;
|
|
|
|
}
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-01-15 04:49:00 +00:00
|
|
|
init_delay = 1;
|
2008-07-22 02:44:04 +00:00
|
|
|
/* After writing this register, HW needs time for CRB */
|
|
|
|
/* to quiet down (else crb_window returns 0xffffffff) */
|
|
|
|
if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
|
2009-01-15 04:49:00 +00:00
|
|
|
init_delay = 1000;
|
2008-07-22 02:44:04 +00:00
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
|
2006-10-21 19:33:03 +00:00
|
|
|
/* hold xdma in reset also */
|
2006-11-29 17:00:10 +00:00
|
|
|
buf[i].data = NETXEN_NIC_XDMA_RESET;
|
2009-01-15 04:49:00 +00:00
|
|
|
buf[i].data = 0x8000ff;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, off, buf[i].data);
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-01-15 04:49:00 +00:00
|
|
|
msleep(init_delay);
|
2008-07-22 02:44:04 +00:00
|
|
|
}
|
|
|
|
kfree(buf);
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
/* disable_peg_cache_all */
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2008-07-22 02:44:04 +00:00
|
|
|
/* unreset_net_cache */
|
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
|
2009-04-07 22:50:45 +00:00
|
|
|
val = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
/* p2dn replyCount */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
|
2008-07-22 02:44:04 +00:00
|
|
|
/* disable_peg_cache 0 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
|
2008-07-22 02:44:04 +00:00
|
|
|
/* disable_peg_cache 1 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
/* peg_clr_all */
|
|
|
|
|
|
|
|
/* peg_clr 0 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
|
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
|
2008-07-22 02:44:04 +00:00
|
|
|
/* peg_clr 1 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
|
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
|
2008-07-22 02:44:04 +00:00
|
|
|
/* peg_clr 2 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
|
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
|
2008-07-22 02:44:04 +00:00
|
|
|
/* peg_clr 3 */
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
|
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
|
2006-10-21 19:33:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
static struct uni_table_desc *nx_get_table_desc(const u8 *unirom, int section)
|
|
|
|
{
|
|
|
|
uint32_t i;
|
|
|
|
struct uni_table_desc *directory = (struct uni_table_desc *) &unirom[0];
|
|
|
|
__le32 entries = cpu_to_le32(directory->num_entries);
|
|
|
|
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
|
|
|
|
__le32 offs = cpu_to_le32(directory->findex) +
|
|
|
|
(i * cpu_to_le32(directory->entry_size));
|
|
|
|
__le32 tab_type = cpu_to_le32(*((u32 *)&unirom[offs] + 8));
|
|
|
|
|
|
|
|
if (tab_type == section)
|
|
|
|
return (struct uni_table_desc *) &unirom[offs];
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-03-29 02:43:43 +00:00
|
|
|
#define QLCNIC_FILEHEADER_SIZE (14 * 4)
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
static int
|
2010-03-29 02:43:43 +00:00
|
|
|
netxen_nic_validate_header(struct netxen_adapter *adapter)
|
|
|
|
{
|
2009-10-24 16:03:58 +00:00
|
|
|
const u8 *unirom = adapter->fw->data;
|
2010-03-29 02:43:43 +00:00
|
|
|
struct uni_table_desc *directory = (struct uni_table_desc *) &unirom[0];
|
|
|
|
u32 fw_file_size = adapter->fw->size;
|
|
|
|
u32 tab_size;
|
2009-10-24 16:03:58 +00:00
|
|
|
__le32 entries;
|
2010-03-29 02:43:43 +00:00
|
|
|
__le32 entry_size;
|
|
|
|
|
|
|
|
if (fw_file_size < QLCNIC_FILEHEADER_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
entries = cpu_to_le32(directory->num_entries);
|
|
|
|
entry_size = cpu_to_le32(directory->entry_size);
|
|
|
|
tab_size = cpu_to_le32(directory->findex) + (entries * entry_size);
|
|
|
|
|
|
|
|
if (fw_file_size < tab_size)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
netxen_nic_validate_bootld(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct uni_table_desc *tab_desc;
|
|
|
|
struct uni_data_desc *descr;
|
|
|
|
const u8 *unirom = adapter->fw->data;
|
|
|
|
__le32 idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
|
|
|
|
NX_UNI_BOOTLD_IDX_OFF));
|
|
|
|
u32 offs;
|
|
|
|
u32 tab_size;
|
|
|
|
u32 data_size;
|
|
|
|
|
|
|
|
tab_desc = nx_get_table_desc(unirom, NX_UNI_DIR_SECT_BOOTLD);
|
|
|
|
|
|
|
|
if (!tab_desc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
tab_size = cpu_to_le32(tab_desc->findex) +
|
|
|
|
(cpu_to_le32(tab_desc->entry_size) * (idx + 1));
|
|
|
|
|
|
|
|
if (adapter->fw->size < tab_size)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
offs = cpu_to_le32(tab_desc->findex) +
|
|
|
|
(cpu_to_le32(tab_desc->entry_size) * (idx));
|
|
|
|
descr = (struct uni_data_desc *)&unirom[offs];
|
|
|
|
|
|
|
|
data_size = cpu_to_le32(descr->findex) + cpu_to_le32(descr->size);
|
|
|
|
|
|
|
|
if (adapter->fw->size < data_size)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
netxen_nic_validate_fw(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct uni_table_desc *tab_desc;
|
|
|
|
struct uni_data_desc *descr;
|
|
|
|
const u8 *unirom = adapter->fw->data;
|
|
|
|
__le32 idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
|
|
|
|
NX_UNI_FIRMWARE_IDX_OFF));
|
|
|
|
u32 offs;
|
|
|
|
u32 tab_size;
|
|
|
|
u32 data_size;
|
|
|
|
|
|
|
|
tab_desc = nx_get_table_desc(unirom, NX_UNI_DIR_SECT_FW);
|
|
|
|
|
|
|
|
if (!tab_desc)
|
|
|
|
return -EINVAL;
|
2009-10-24 16:03:58 +00:00
|
|
|
|
2010-03-29 02:43:43 +00:00
|
|
|
tab_size = cpu_to_le32(tab_desc->findex) +
|
|
|
|
(cpu_to_le32(tab_desc->entry_size) * (idx + 1));
|
|
|
|
|
|
|
|
if (adapter->fw->size < tab_size)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
offs = cpu_to_le32(tab_desc->findex) +
|
|
|
|
(cpu_to_le32(tab_desc->entry_size) * (idx));
|
|
|
|
descr = (struct uni_data_desc *)&unirom[offs];
|
|
|
|
data_size = cpu_to_le32(descr->findex) + cpu_to_le32(descr->size);
|
|
|
|
|
|
|
|
if (adapter->fw->size < data_size)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
netxen_nic_validate_product_offs(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct uni_table_desc *ptab_descr;
|
|
|
|
const u8 *unirom = adapter->fw->data;
|
2009-12-05 12:23:56 +00:00
|
|
|
int mn_present = (NX_IS_REVISION_P2(adapter->ahw.revision_id)) ?
|
|
|
|
1 : netxen_p3_has_mn(adapter);
|
2010-03-29 02:43:43 +00:00
|
|
|
__le32 entries;
|
|
|
|
__le32 entry_size;
|
|
|
|
u32 tab_size;
|
|
|
|
u32 i;
|
2009-12-05 12:23:56 +00:00
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
ptab_descr = nx_get_table_desc(unirom, NX_UNI_DIR_SECT_PRODUCT_TBL);
|
|
|
|
if (ptab_descr == NULL)
|
2010-03-29 02:43:43 +00:00
|
|
|
return -EINVAL;
|
2009-10-24 16:03:58 +00:00
|
|
|
|
|
|
|
entries = cpu_to_le32(ptab_descr->num_entries);
|
2010-03-29 02:43:43 +00:00
|
|
|
entry_size = cpu_to_le32(ptab_descr->entry_size);
|
|
|
|
tab_size = cpu_to_le32(ptab_descr->findex) + (entries * entry_size);
|
|
|
|
|
|
|
|
if (adapter->fw->size < tab_size)
|
|
|
|
return -EINVAL;
|
2009-10-24 16:03:58 +00:00
|
|
|
|
2009-12-05 12:23:56 +00:00
|
|
|
nomn:
|
2009-10-24 16:03:58 +00:00
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
|
|
|
|
__le32 flags, file_chiprev, offs;
|
|
|
|
u8 chiprev = adapter->ahw.revision_id;
|
|
|
|
uint32_t flagbit;
|
|
|
|
|
|
|
|
offs = cpu_to_le32(ptab_descr->findex) +
|
|
|
|
(i * cpu_to_le32(ptab_descr->entry_size));
|
|
|
|
flags = cpu_to_le32(*((int *)&unirom[offs] + NX_UNI_FLAGS_OFF));
|
|
|
|
file_chiprev = cpu_to_le32(*((int *)&unirom[offs] +
|
|
|
|
NX_UNI_CHIP_REV_OFF));
|
|
|
|
|
|
|
|
flagbit = mn_present ? 1 : 2;
|
|
|
|
|
|
|
|
if ((chiprev == file_chiprev) &&
|
|
|
|
((1ULL << flagbit) & flags)) {
|
|
|
|
adapter->file_prd_off = offs;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-05 12:23:56 +00:00
|
|
|
if (mn_present && NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
|
|
|
|
mn_present = 0;
|
|
|
|
goto nomn;
|
|
|
|
}
|
|
|
|
|
2010-03-29 02:43:43 +00:00
|
|
|
return -EINVAL;
|
2009-10-24 16:03:58 +00:00
|
|
|
}
|
|
|
|
|
2010-03-29 02:43:43 +00:00
|
|
|
static int
|
|
|
|
netxen_nic_validate_unified_romimage(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
if (netxen_nic_validate_header(adapter)) {
|
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"unified image: header validation failed\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (netxen_nic_validate_product_offs(adapter)) {
|
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"unified image: product validation failed\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (netxen_nic_validate_bootld(adapter)) {
|
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"unified image: bootld validation failed\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (netxen_nic_validate_fw(adapter)) {
|
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"unified image: firmware validation failed\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-24 16:03:58 +00:00
|
|
|
|
|
|
|
static struct uni_data_desc *nx_get_data_desc(struct netxen_adapter *adapter,
|
|
|
|
u32 section, u32 idx_offset)
|
|
|
|
{
|
|
|
|
const u8 *unirom = adapter->fw->data;
|
|
|
|
int idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
|
|
|
|
idx_offset));
|
|
|
|
struct uni_table_desc *tab_desc;
|
|
|
|
__le32 offs;
|
|
|
|
|
|
|
|
tab_desc = nx_get_table_desc(unirom, section);
|
|
|
|
|
|
|
|
if (tab_desc == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
offs = cpu_to_le32(tab_desc->findex) +
|
|
|
|
(cpu_to_le32(tab_desc->entry_size) * idx);
|
|
|
|
|
|
|
|
return (struct uni_data_desc *)&unirom[offs];
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 *
|
|
|
|
nx_get_bootld_offs(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u32 offs = NETXEN_BOOTLD_START;
|
|
|
|
|
|
|
|
if (adapter->fw_type == NX_UNIFIED_ROMIMAGE)
|
|
|
|
offs = cpu_to_le32((nx_get_data_desc(adapter,
|
|
|
|
NX_UNI_DIR_SECT_BOOTLD,
|
|
|
|
NX_UNI_BOOTLD_IDX_OFF))->findex);
|
|
|
|
|
|
|
|
return (u8 *)&adapter->fw->data[offs];
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 *
|
|
|
|
nx_get_fw_offs(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u32 offs = NETXEN_IMAGE_START;
|
|
|
|
|
|
|
|
if (adapter->fw_type == NX_UNIFIED_ROMIMAGE)
|
|
|
|
offs = cpu_to_le32((nx_get_data_desc(adapter,
|
|
|
|
NX_UNI_DIR_SECT_FW,
|
|
|
|
NX_UNI_FIRMWARE_IDX_OFF))->findex);
|
|
|
|
|
|
|
|
return (u8 *)&adapter->fw->data[offs];
|
|
|
|
}
|
|
|
|
|
|
|
|
static __le32
|
|
|
|
nx_get_fw_size(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
if (adapter->fw_type == NX_UNIFIED_ROMIMAGE)
|
|
|
|
return cpu_to_le32((nx_get_data_desc(adapter,
|
|
|
|
NX_UNI_DIR_SECT_FW,
|
|
|
|
NX_UNI_FIRMWARE_IDX_OFF))->size);
|
|
|
|
else
|
|
|
|
return cpu_to_le32(
|
|
|
|
*(u32 *)&adapter->fw->data[NX_FW_SIZE_OFFSET]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __le32
|
|
|
|
nx_get_fw_version(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct uni_data_desc *fw_data_desc;
|
|
|
|
const struct firmware *fw = adapter->fw;
|
|
|
|
__le32 major, minor, sub;
|
|
|
|
const u8 *ver_str;
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
if (adapter->fw_type == NX_UNIFIED_ROMIMAGE) {
|
|
|
|
|
|
|
|
fw_data_desc = nx_get_data_desc(adapter,
|
|
|
|
NX_UNI_DIR_SECT_FW, NX_UNI_FIRMWARE_IDX_OFF);
|
|
|
|
ver_str = fw->data + cpu_to_le32(fw_data_desc->findex) +
|
|
|
|
cpu_to_le32(fw_data_desc->size) - 17;
|
|
|
|
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
|
|
if (!strncmp(&ver_str[i], "REV=", 4)) {
|
|
|
|
ret = sscanf(&ver_str[i+4], "%u.%u.%u ",
|
|
|
|
&major, &minor, &sub);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != 3)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return major + (minor << 8) + (sub << 16);
|
|
|
|
|
|
|
|
} else
|
|
|
|
return cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __le32
|
|
|
|
nx_get_bios_version(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
const struct firmware *fw = adapter->fw;
|
|
|
|
__le32 bios_ver, prd_off = adapter->file_prd_off;
|
|
|
|
|
|
|
|
if (adapter->fw_type == NX_UNIFIED_ROMIMAGE) {
|
|
|
|
bios_ver = cpu_to_le32(*((u32 *) (&fw->data[prd_off])
|
|
|
|
+ NX_UNI_BIOS_VERSION_OFF));
|
2010-03-26 00:30:07 +00:00
|
|
|
return (bios_ver << 16) + ((bios_ver >> 8) & 0xff00) +
|
2009-10-24 16:03:58 +00:00
|
|
|
(bios_ver >> 24);
|
|
|
|
} else
|
|
|
|
return cpu_to_le32(*(u32 *)&fw->data[NX_BIOS_VERSION_OFFSET]);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-07-01 11:41:43 +00:00
|
|
|
int
|
|
|
|
netxen_need_fw_reset(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u32 count, old_count;
|
|
|
|
u32 val, version, major, minor, build;
|
|
|
|
int i, timeout;
|
|
|
|
u8 fw_type;
|
|
|
|
|
|
|
|
/* NX2031 firmware doesn't support heartbit */
|
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
return 1;
|
|
|
|
|
2009-12-08 20:40:55 +00:00
|
|
|
if (adapter->need_fw_reset)
|
|
|
|
return 1;
|
|
|
|
|
2009-07-01 11:41:43 +00:00
|
|
|
/* last attempt had failed */
|
|
|
|
if (NXRD32(adapter, CRB_CMDPEG_STATE) == PHAN_INITIALIZE_FAILED)
|
|
|
|
return 1;
|
|
|
|
|
2010-01-07 22:10:15 +00:00
|
|
|
old_count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
|
2009-07-01 11:41:43 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 10; i++) {
|
|
|
|
|
|
|
|
timeout = msleep_interruptible(200);
|
|
|
|
if (timeout) {
|
|
|
|
NXWR32(adapter, CRB_CMDPEG_STATE,
|
|
|
|
PHAN_INITIALIZE_FAILED);
|
|
|
|
return -EINTR;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
|
|
|
|
if (count != old_count)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* firmware is dead */
|
|
|
|
if (count == old_count)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* check if we have got newer or different file firmware */
|
|
|
|
if (adapter->fw) {
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
val = nx_get_fw_version(adapter);
|
2009-07-01 11:41:43 +00:00
|
|
|
|
|
|
|
version = NETXEN_DECODE_VERSION(val);
|
|
|
|
|
|
|
|
major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
|
|
|
|
minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
|
|
|
|
build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
|
|
|
|
|
|
|
|
if (version > NETXEN_VERSION_CODE(major, minor, build))
|
|
|
|
return 1;
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
if (version == NETXEN_VERSION_CODE(major, minor, build) &&
|
|
|
|
adapter->fw_type != NX_UNIFIED_ROMIMAGE) {
|
2009-07-01 11:41:43 +00:00
|
|
|
|
|
|
|
val = NXRD32(adapter, NETXEN_MIU_MN_CONTROL);
|
|
|
|
fw_type = (val & 0x4) ?
|
|
|
|
NX_P3_CT_ROMIMAGE : NX_P3_MN_ROMIMAGE;
|
|
|
|
|
|
|
|
if (adapter->fw_type != fw_type)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-20 00:08:53 +00:00
|
|
|
#define NETXEN_MIN_P3_FW_SUPP NETXEN_VERSION_CODE(4, 0, 505)
|
|
|
|
|
|
|
|
int
|
|
|
|
netxen_check_flash_fw_compatibility(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u32 flash_fw_ver, min_fw_ver;
|
|
|
|
|
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (netxen_rom_fast_read(adapter,
|
|
|
|
NX_FW_VERSION_OFFSET, (int *)&flash_fw_ver)) {
|
|
|
|
dev_err(&adapter->pdev->dev, "Unable to read flash fw"
|
|
|
|
"version\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
flash_fw_ver = NETXEN_DECODE_VERSION(flash_fw_ver);
|
|
|
|
min_fw_ver = NETXEN_MIN_P3_FW_SUPP;
|
|
|
|
if (flash_fw_ver >= min_fw_ver)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev_info(&adapter->pdev->dev, "Flash fw[%d.%d.%d] is < min fw supported"
|
|
|
|
"[4.0.505]. Please update firmware on flash\n",
|
|
|
|
_major(flash_fw_ver), _minor(flash_fw_ver),
|
|
|
|
_build(flash_fw_ver));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-07-01 11:41:43 +00:00
|
|
|
static char *fw_name[] = {
|
2009-10-24 16:04:02 +00:00
|
|
|
NX_P2_MN_ROMIMAGE_NAME,
|
|
|
|
NX_P3_CT_ROMIMAGE_NAME,
|
|
|
|
NX_P3_MN_ROMIMAGE_NAME,
|
|
|
|
NX_UNIFIED_ROMIMAGE_NAME,
|
|
|
|
NX_FLASH_ROMIMAGE_NAME,
|
2009-07-01 11:41:43 +00:00
|
|
|
};
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
int
|
|
|
|
netxen_load_firmware(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u64 *ptr64;
|
|
|
|
u32 i, flashaddr, size;
|
|
|
|
const struct firmware *fw = adapter->fw;
|
2009-07-01 11:41:43 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
|
|
|
|
dev_info(&pdev->dev, "loading firmware from %s\n",
|
|
|
|
fw_name[adapter->fw_type]);
|
2009-04-28 15:29:11 +00:00
|
|
|
|
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 1);
|
|
|
|
|
|
|
|
if (fw) {
|
|
|
|
__le64 data;
|
|
|
|
|
|
|
|
size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START) / 8;
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
ptr64 = (u64 *)nx_get_bootld_offs(adapter);
|
2009-04-28 15:29:11 +00:00
|
|
|
flashaddr = NETXEN_BOOTLD_START;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
data = cpu_to_le64(ptr64[i]);
|
2009-10-24 16:03:58 +00:00
|
|
|
|
|
|
|
if (adapter->pci_mem_write(adapter, flashaddr, data))
|
2009-10-13 05:31:41 +00:00
|
|
|
return -EIO;
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
flashaddr += 8;
|
|
|
|
}
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
size = (__force u32)nx_get_fw_size(adapter) / 8;
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
ptr64 = (u64 *)nx_get_fw_offs(adapter);
|
2009-04-28 15:29:11 +00:00
|
|
|
flashaddr = NETXEN_IMAGE_START;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
data = cpu_to_le64(ptr64[i]);
|
|
|
|
|
|
|
|
if (adapter->pci_mem_write(adapter,
|
2009-10-13 05:31:41 +00:00
|
|
|
flashaddr, data))
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
flashaddr += 8;
|
|
|
|
}
|
2010-03-29 02:43:44 +00:00
|
|
|
|
|
|
|
size = (__force u32)nx_get_fw_size(adapter) % 8;
|
|
|
|
if (size) {
|
|
|
|
data = cpu_to_le64(ptr64[i]);
|
|
|
|
|
|
|
|
if (adapter->pci_mem_write(adapter,
|
|
|
|
flashaddr, data))
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
} else {
|
2009-09-11 11:28:11 +00:00
|
|
|
u64 data;
|
|
|
|
u32 hi, lo;
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2009-09-11 11:28:11 +00:00
|
|
|
size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START) / 8;
|
2009-04-28 15:29:11 +00:00
|
|
|
flashaddr = NETXEN_BOOTLD_START;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
if (netxen_rom_fast_read(adapter,
|
2009-10-13 05:31:41 +00:00
|
|
|
flashaddr, (int *)&lo) != 0)
|
2009-09-11 11:28:11 +00:00
|
|
|
return -EIO;
|
|
|
|
if (netxen_rom_fast_read(adapter,
|
2009-10-13 05:31:41 +00:00
|
|
|
flashaddr + 4, (int *)&hi) != 0)
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EIO;
|
|
|
|
|
2009-09-11 11:28:11 +00:00
|
|
|
/* hi, lo are already in host endian byteorder */
|
|
|
|
data = (((u64)hi << 32) | lo);
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
if (adapter->pci_mem_write(adapter,
|
2009-10-13 05:31:41 +00:00
|
|
|
flashaddr, data))
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EIO;
|
|
|
|
|
2009-09-11 11:28:11 +00:00
|
|
|
flashaddr += 8;
|
2009-04-28 15:29:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
msleep(1);
|
|
|
|
|
2009-10-16 15:50:08 +00:00
|
|
|
if (NX_IS_REVISION_P3P(adapter->ahw.revision_id)) {
|
|
|
|
NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0x18, 0x1020);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0x80001e);
|
|
|
|
} else if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
|
2009-04-28 15:29:11 +00:00
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0x80001d);
|
|
|
|
else {
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_CHIP_CLK_CTRL, 0x3fff);
|
|
|
|
NXWR32(adapter, NETXEN_ROMUSB_GLB_CAS_RST, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-10-24 16:03:58 +00:00
|
|
|
netxen_validate_firmware(struct netxen_adapter *adapter)
|
2009-04-28 15:29:11 +00:00
|
|
|
{
|
|
|
|
__le32 val;
|
2011-07-20 00:08:53 +00:00
|
|
|
__le32 flash_fw_ver;
|
|
|
|
u32 file_fw_ver, min_ver, bios;
|
2009-04-28 15:29:11 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
const struct firmware *fw = adapter->fw;
|
2009-10-24 16:03:58 +00:00
|
|
|
u8 fw_type = adapter->fw_type;
|
2011-07-20 00:08:53 +00:00
|
|
|
u32 crbinit_fix_fw;
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
if (fw_type == NX_UNIFIED_ROMIMAGE) {
|
2010-03-29 02:43:43 +00:00
|
|
|
if (netxen_nic_validate_unified_romimage(adapter))
|
2009-10-24 16:03:58 +00:00
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_MAGIC_OFFSET]);
|
|
|
|
if ((__force u32)val != NETXEN_BDINFO_MAGIC)
|
|
|
|
return -EINVAL;
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2010-03-29 02:43:43 +00:00
|
|
|
if (fw->size < NX_FW_MIN_SIZE)
|
|
|
|
return -EINVAL;
|
2009-10-24 16:03:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
val = nx_get_fw_version(adapter);
|
2009-04-28 15:29:11 +00:00
|
|
|
|
|
|
|
if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
|
2011-07-20 00:08:53 +00:00
|
|
|
min_ver = NETXEN_MIN_P3_FW_SUPP;
|
2009-04-28 15:29:11 +00:00
|
|
|
else
|
|
|
|
min_ver = NETXEN_VERSION_CODE(3, 4, 216);
|
|
|
|
|
2011-07-20 00:08:53 +00:00
|
|
|
file_fw_ver = NETXEN_DECODE_VERSION(val);
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2011-07-20 00:08:53 +00:00
|
|
|
if ((_major(file_fw_ver) > _NETXEN_NIC_LINUX_MAJOR) ||
|
|
|
|
(file_fw_ver < min_ver)) {
|
2009-04-28 15:29:11 +00:00
|
|
|
dev_err(&pdev->dev,
|
|
|
|
"%s: firmware version %d.%d.%d unsupported\n",
|
2011-07-20 00:08:53 +00:00
|
|
|
fw_name[fw_type], _major(file_fw_ver), _minor(file_fw_ver),
|
|
|
|
_build(file_fw_ver));
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
val = nx_get_bios_version(adapter);
|
2009-04-28 15:29:11 +00:00
|
|
|
netxen_rom_fast_read(adapter, NX_BIOS_VERSION_OFFSET, (int *)&bios);
|
|
|
|
if ((__force u32)val != bios) {
|
|
|
|
dev_err(&pdev->dev, "%s: firmware bios is incompatible\n",
|
2009-10-24 16:03:58 +00:00
|
|
|
fw_name[fw_type]);
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (netxen_rom_fast_read(adapter,
|
2011-07-20 00:08:53 +00:00
|
|
|
NX_FW_VERSION_OFFSET, (int *)&flash_fw_ver)) {
|
|
|
|
dev_err(&pdev->dev, "Unable to read flash fw version\n");
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EIO;
|
2011-07-20 00:08:53 +00:00
|
|
|
}
|
|
|
|
flash_fw_ver = NETXEN_DECODE_VERSION(flash_fw_ver);
|
|
|
|
|
|
|
|
/* New fw from file is not allowed, if fw on flash is < 4.0.554 */
|
|
|
|
crbinit_fix_fw = NETXEN_VERSION_CODE(4, 0, 554);
|
|
|
|
if (file_fw_ver >= crbinit_fix_fw && flash_fw_ver < crbinit_fix_fw &&
|
|
|
|
NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
|
|
|
|
dev_err(&pdev->dev, "Incompatibility detected between driver "
|
|
|
|
"and firmware version on flash. This configuration "
|
|
|
|
"is not recommended. Please update the firmware on "
|
|
|
|
"flash immediately\n");
|
2009-04-28 15:29:11 +00:00
|
|
|
return -EINVAL;
|
2009-07-01 11:41:42 +00:00
|
|
|
}
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2011-07-20 00:08:53 +00:00
|
|
|
/* check if flashed firmware is newer only for no-mn and P2 case*/
|
|
|
|
if (!netxen_p3_has_mn(adapter) ||
|
|
|
|
NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
|
|
|
|
if (flash_fw_ver > file_fw_ver) {
|
|
|
|
dev_info(&pdev->dev, "%s: firmware is older than flash\n",
|
|
|
|
fw_name[fw_type]);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
static void
|
|
|
|
nx_get_next_fwtype(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
u8 fw_type;
|
|
|
|
|
|
|
|
switch (adapter->fw_type) {
|
|
|
|
case NX_UNKNOWN_ROMIMAGE:
|
|
|
|
fw_type = NX_UNIFIED_ROMIMAGE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NX_UNIFIED_ROMIMAGE:
|
|
|
|
if (NX_IS_REVISION_P3P(adapter->ahw.revision_id))
|
|
|
|
fw_type = NX_FLASH_ROMIMAGE;
|
|
|
|
else if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
fw_type = NX_P2_MN_ROMIMAGE;
|
|
|
|
else if (netxen_p3_has_mn(adapter))
|
|
|
|
fw_type = NX_P3_MN_ROMIMAGE;
|
|
|
|
else
|
|
|
|
fw_type = NX_P3_CT_ROMIMAGE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NX_P3_MN_ROMIMAGE:
|
|
|
|
fw_type = NX_P3_CT_ROMIMAGE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NX_P2_MN_ROMIMAGE:
|
|
|
|
case NX_P3_CT_ROMIMAGE:
|
|
|
|
default:
|
|
|
|
fw_type = NX_FLASH_ROMIMAGE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
adapter->fw_type = fw_type;
|
|
|
|
}
|
|
|
|
|
2009-07-26 20:07:37 +00:00
|
|
|
static int
|
|
|
|
netxen_p3_has_mn(struct netxen_adapter *adapter)
|
2009-04-28 15:29:11 +00:00
|
|
|
{
|
|
|
|
u32 capability, flashed_ver;
|
|
|
|
capability = 0;
|
|
|
|
|
2009-12-05 12:23:56 +00:00
|
|
|
/* NX2031 always had MN */
|
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
return 1;
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
netxen_rom_fast_read(adapter,
|
|
|
|
NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
|
2009-07-01 11:41:42 +00:00
|
|
|
flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);
|
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
if (flashed_ver >= NETXEN_VERSION_CODE(4, 0, 220)) {
|
2009-07-26 20:07:37 +00:00
|
|
|
|
2009-04-28 15:29:11 +00:00
|
|
|
capability = NXRD32(adapter, NX_PEG_TUNE_CAPABILITY);
|
2009-07-26 20:07:37 +00:00
|
|
|
if (capability & NX_PEG_TUNE_MN_PRESENT)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void netxen_request_firmware(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
int rc = 0;
|
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
adapter->fw_type = NX_UNKNOWN_ROMIMAGE;
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
next:
|
|
|
|
nx_get_next_fwtype(adapter);
|
2009-04-28 15:29:11 +00:00
|
|
|
|
2009-10-24 16:03:58 +00:00
|
|
|
if (adapter->fw_type == NX_FLASH_ROMIMAGE) {
|
2009-04-28 15:29:11 +00:00
|
|
|
adapter->fw = NULL;
|
2009-10-24 16:03:58 +00:00
|
|
|
} else {
|
|
|
|
rc = request_firmware(&adapter->fw,
|
|
|
|
fw_name[adapter->fw_type], &pdev->dev);
|
|
|
|
if (rc != 0)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
rc = netxen_validate_firmware(adapter);
|
|
|
|
if (rc != 0) {
|
|
|
|
release_firmware(adapter->fw);
|
2009-04-28 15:29:11 +00:00
|
|
|
msleep(1);
|
2009-10-24 16:03:58 +00:00
|
|
|
goto next;
|
2009-04-28 15:29:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
netxen_release_firmware(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
if (adapter->fw)
|
|
|
|
release_firmware(adapter->fw);
|
2009-09-05 17:43:07 +00:00
|
|
|
adapter->fw = NULL;
|
2009-04-28 15:29:11 +00:00
|
|
|
}
|
|
|
|
|
2009-07-26 20:07:39 +00:00
|
|
|
int netxen_init_dummy_dma(struct netxen_adapter *adapter)
|
2006-12-04 17:23:25 +00:00
|
|
|
{
|
2009-07-26 20:07:39 +00:00
|
|
|
u64 addr;
|
|
|
|
u32 hi, lo;
|
2006-12-04 17:23:25 +00:00
|
|
|
|
2009-07-26 20:07:39 +00:00
|
|
|
if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
adapter->dummy_dma.addr = pci_alloc_consistent(adapter->pdev,
|
2006-12-04 17:23:25 +00:00
|
|
|
NETXEN_HOST_DUMMY_DMA_SIZE,
|
|
|
|
&adapter->dummy_dma.phys_addr);
|
|
|
|
if (adapter->dummy_dma.addr == NULL) {
|
2009-07-26 20:07:39 +00:00
|
|
|
dev_err(&adapter->pdev->dev,
|
|
|
|
"ERROR: Could not allocate dummy DMA memory\n");
|
2006-12-04 17:23:25 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr = (uint64_t) adapter->dummy_dma.phys_addr;
|
|
|
|
hi = (addr >> 32) & 0xffffffff;
|
|
|
|
lo = addr & 0xffffffff;
|
|
|
|
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
|
|
|
|
NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
|
2006-12-04 17:23:25 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-26 20:07:39 +00:00
|
|
|
/*
|
|
|
|
* NetXen DMA watchdog control:
|
|
|
|
*
|
|
|
|
* Bit 0 : enabled => R/O: 1 watchdog active, 0 inactive
|
|
|
|
* Bit 1 : disable_request => 1 req disable dma watchdog
|
|
|
|
* Bit 2 : enable_request => 1 req enable dma watchdog
|
|
|
|
* Bit 3-31 : unused
|
|
|
|
*/
|
|
|
|
void netxen_free_dummy_dma(struct netxen_adapter *adapter)
|
2006-12-04 17:23:25 +00:00
|
|
|
{
|
2008-08-08 07:08:42 +00:00
|
|
|
int i = 100;
|
2009-07-26 20:07:39 +00:00
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
return;
|
2008-08-08 07:08:42 +00:00
|
|
|
|
|
|
|
if (!adapter->dummy_dma.addr)
|
|
|
|
return;
|
2008-06-16 05:59:46 +00:00
|
|
|
|
2009-07-26 20:07:39 +00:00
|
|
|
ctrl = NXRD32(adapter, NETXEN_DMA_WATCHDOG_CTRL);
|
|
|
|
if ((ctrl & 0x1) != 0) {
|
|
|
|
NXWR32(adapter, NETXEN_DMA_WATCHDOG_CTRL, (ctrl | 0x2));
|
|
|
|
|
|
|
|
while ((ctrl & 0x1) != 0) {
|
|
|
|
|
2008-06-16 05:59:46 +00:00
|
|
|
msleep(50);
|
2009-07-26 20:07:39 +00:00
|
|
|
|
|
|
|
ctrl = NXRD32(adapter, NETXEN_DMA_WATCHDOG_CTRL);
|
|
|
|
|
|
|
|
if (--i == 0)
|
2008-06-16 05:59:46 +00:00
|
|
|
break;
|
2011-06-03 11:51:20 +00:00
|
|
|
}
|
2008-08-08 07:08:42 +00:00
|
|
|
}
|
2008-06-16 05:59:46 +00:00
|
|
|
|
2008-08-08 07:08:42 +00:00
|
|
|
if (i) {
|
|
|
|
pci_free_consistent(adapter->pdev,
|
|
|
|
NETXEN_HOST_DUMMY_DMA_SIZE,
|
|
|
|
adapter->dummy_dma.addr,
|
|
|
|
adapter->dummy_dma.phys_addr);
|
|
|
|
adapter->dummy_dma.addr = NULL;
|
2009-07-26 20:07:39 +00:00
|
|
|
} else
|
|
|
|
dev_err(&adapter->pdev->dev, "dma_watchdog_shutdown failed\n");
|
2006-12-04 17:23:25 +00:00
|
|
|
}
|
|
|
|
|
2007-07-02 04:07:57 +00:00
|
|
|
int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
|
|
|
u32 val = 0;
|
2008-07-22 02:44:04 +00:00
|
|
|
int retries = 60;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
if (pegtune_val)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
val = NXRD32(adapter, CRB_CMDPEG_STATE);
|
2007-07-02 04:07:57 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
switch (val) {
|
|
|
|
case PHAN_INITIALIZE_COMPLETE:
|
|
|
|
case PHAN_INITIALIZE_ACK:
|
|
|
|
return 0;
|
|
|
|
case PHAN_INITIALIZE_FAILED:
|
|
|
|
goto out_err;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2007-07-02 04:07:57 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
msleep(500);
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
} while (--retries);
|
2008-07-22 02:44:04 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
|
2007-07-02 04:07:57 +00:00
|
|
|
|
2009-06-22 20:26:21 +00:00
|
|
|
out_err:
|
|
|
|
dev_warn(&adapter->pdev->dev, "firmware init failed\n");
|
|
|
|
return -EIO;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-04-07 22:50:41 +00:00
|
|
|
static int
|
|
|
|
netxen_receive_peg_ready(struct netxen_adapter *adapter)
|
2008-07-22 02:44:04 +00:00
|
|
|
{
|
|
|
|
u32 val = 0;
|
|
|
|
int retries = 2000;
|
|
|
|
|
|
|
|
do {
|
2009-04-07 22:50:45 +00:00
|
|
|
val = NXRD32(adapter, CRB_RCVPEG_STATE);
|
2008-07-22 02:44:04 +00:00
|
|
|
|
|
|
|
if (val == PHAN_PEG_RCV_INITIALIZED)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
msleep(10);
|
|
|
|
|
|
|
|
} while (--retries);
|
|
|
|
|
|
|
|
if (!retries) {
|
|
|
|
printk(KERN_ERR "Receive Peg initialization not "
|
|
|
|
"complete, state: 0x%x.\n", val);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-07 22:50:41 +00:00
|
|
|
int netxen_init_firmware(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = netxen_receive_peg_ready(adapter);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2009-04-07 22:50:45 +00:00
|
|
|
NXWR32(adapter, CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
|
|
|
|
NXWR32(adapter, CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
|
|
|
|
NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
|
2009-04-07 22:50:41 +00:00
|
|
|
|
2010-05-11 23:53:02 +00:00
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
|
|
|
|
NXWR32(adapter, CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
|
|
|
|
|
2009-04-07 22:50:41 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-04-07 22:50:42 +00:00
|
|
|
static void
|
|
|
|
netxen_handle_linkevent(struct netxen_adapter *adapter, nx_fw_msg_t *msg)
|
|
|
|
{
|
|
|
|
u32 cable_OUI;
|
|
|
|
u16 cable_len;
|
|
|
|
u16 link_speed;
|
|
|
|
u8 link_status, module, duplex, autoneg;
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
|
|
|
|
adapter->has_link_events = 1;
|
|
|
|
|
|
|
|
cable_OUI = msg->body[1] & 0xffffffff;
|
|
|
|
cable_len = (msg->body[1] >> 32) & 0xffff;
|
|
|
|
link_speed = (msg->body[1] >> 48) & 0xffff;
|
|
|
|
|
|
|
|
link_status = msg->body[2] & 0xff;
|
|
|
|
duplex = (msg->body[2] >> 16) & 0xff;
|
|
|
|
autoneg = (msg->body[2] >> 24) & 0xff;
|
|
|
|
|
|
|
|
module = (msg->body[2] >> 8) & 0xff;
|
|
|
|
if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE) {
|
|
|
|
printk(KERN_INFO "%s: unsupported cable: OUI 0x%x, length %d\n",
|
|
|
|
netdev->name, cable_OUI, cable_len);
|
|
|
|
} else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN) {
|
|
|
|
printk(KERN_INFO "%s: unsupported cable length %d\n",
|
|
|
|
netdev->name, cable_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
netxen_advert_link_change(adapter, link_status);
|
|
|
|
|
|
|
|
/* update link parameters */
|
|
|
|
if (duplex == LINKEVENT_FULL_DUPLEX)
|
|
|
|
adapter->link_duplex = DUPLEX_FULL;
|
|
|
|
else
|
|
|
|
adapter->link_duplex = DUPLEX_HALF;
|
|
|
|
adapter->module_type = module;
|
|
|
|
adapter->link_autoneg = autoneg;
|
|
|
|
adapter->link_speed = link_speed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
netxen_handle_fw_message(int desc_cnt, int index,
|
|
|
|
struct nx_host_sds_ring *sds_ring)
|
|
|
|
{
|
|
|
|
nx_fw_msg_t msg;
|
|
|
|
struct status_desc *desc;
|
|
|
|
int i = 0, opcode;
|
|
|
|
|
|
|
|
while (desc_cnt > 0 && i < 8) {
|
|
|
|
desc = &sds_ring->desc_head[index];
|
|
|
|
msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
|
|
|
|
msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
|
|
|
|
|
|
|
|
index = get_next_index(index, sds_ring->num_desc);
|
|
|
|
desc_cnt--;
|
|
|
|
}
|
|
|
|
|
|
|
|
opcode = netxen_get_nic_msg_opcode(msg.body[0]);
|
|
|
|
switch (opcode) {
|
|
|
|
case NX_NIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
|
|
|
|
netxen_handle_linkevent(sds_ring->adapter, &msg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
static int
|
|
|
|
netxen_alloc_rx_skb(struct netxen_adapter *adapter,
|
|
|
|
struct nx_host_rds_ring *rds_ring,
|
|
|
|
struct netxen_rx_buffer *buffer)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
dma_addr_t dma;
|
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
|
|
|
|
buffer->skb = dev_alloc_skb(rds_ring->skb_size);
|
|
|
|
if (!buffer->skb)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
skb = buffer->skb;
|
|
|
|
|
|
|
|
if (!adapter->ahw.cut_through)
|
|
|
|
skb_reserve(skb, 2);
|
|
|
|
|
|
|
|
dma = pci_map_single(pdev, skb->data,
|
|
|
|
rds_ring->dma_size, PCI_DMA_FROMDEVICE);
|
|
|
|
|
|
|
|
if (pci_dma_mapping_error(pdev, dma)) {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
buffer->skb = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer->skb = skb;
|
|
|
|
buffer->dma = dma;
|
|
|
|
buffer->state = NETXEN_BUFFER_BUSY;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-22 02:44:08 +00:00
|
|
|
static struct sk_buff *netxen_process_rxbuf(struct netxen_adapter *adapter,
|
|
|
|
struct nx_host_rds_ring *rds_ring, u16 index, u16 cksum)
|
|
|
|
{
|
|
|
|
struct netxen_rx_buffer *buffer;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
buffer = &rds_ring->rx_buf_arr[index];
|
|
|
|
|
|
|
|
pci_unmap_single(adapter->pdev, buffer->dma, rds_ring->dma_size,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
|
|
|
|
|
|
|
skb = buffer->skb;
|
|
|
|
if (!skb)
|
|
|
|
goto no_skb;
|
|
|
|
|
2011-04-05 01:36:58 +00:00
|
|
|
if (likely((adapter->netdev->features & NETIF_F_RXCSUM)
|
|
|
|
&& cksum == STATUS_CKSUM_OK)) {
|
2008-07-22 02:44:08 +00:00
|
|
|
adapter->stats.csummed++;
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
} else
|
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
|
|
|
|
skb->dev = adapter->netdev;
|
|
|
|
|
|
|
|
buffer->skb = NULL;
|
|
|
|
no_skb:
|
|
|
|
buffer->state = NETXEN_BUFFER_FREE;
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
static struct netxen_rx_buffer *
|
2009-03-13 14:52:04 +00:00
|
|
|
netxen_process_rcv(struct netxen_adapter *adapter,
|
2009-08-05 07:34:09 +00:00
|
|
|
struct nx_host_sds_ring *sds_ring,
|
|
|
|
int ring, u64 sts_data0)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2007-04-20 14:52:37 +00:00
|
|
|
struct net_device *netdev = adapter->netdev;
|
2009-03-09 08:50:55 +00:00
|
|
|
struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
|
2006-10-21 19:33:03 +00:00
|
|
|
struct netxen_rx_buffer *buffer;
|
|
|
|
struct sk_buff *skb;
|
2009-08-05 07:34:09 +00:00
|
|
|
struct nx_host_rds_ring *rds_ring;
|
|
|
|
int index, length, cksum, pkt_offset;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
if (unlikely(ring >= adapter->max_rds_rings))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
rds_ring = &recv_ctx->rds_rings[ring];
|
|
|
|
|
|
|
|
index = netxen_get_sts_refhandle(sts_data0);
|
|
|
|
if (unlikely(index >= rds_ring->num_desc))
|
2009-03-13 14:52:05 +00:00
|
|
|
return NULL;
|
2009-03-13 14:52:03 +00:00
|
|
|
|
2008-07-22 02:44:06 +00:00
|
|
|
buffer = &rds_ring->rx_buf_arr[index];
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
length = netxen_get_sts_totallength(sts_data0);
|
|
|
|
cksum = netxen_get_sts_status(sts_data0);
|
|
|
|
pkt_offset = netxen_get_sts_pkt_offset(sts_data0);
|
|
|
|
|
2008-07-22 02:44:08 +00:00
|
|
|
skb = netxen_process_rxbuf(adapter, rds_ring, index, cksum);
|
|
|
|
if (!skb)
|
2009-03-13 14:52:05 +00:00
|
|
|
return buffer;
|
2007-09-03 05:03:35 +00:00
|
|
|
|
2009-03-13 14:52:04 +00:00
|
|
|
if (length > rds_ring->skb_size)
|
|
|
|
skb_put(skb, rds_ring->skb_size);
|
|
|
|
else
|
|
|
|
skb_put(skb, length);
|
2008-07-22 02:44:08 +00:00
|
|
|
|
2009-03-13 14:52:04 +00:00
|
|
|
|
|
|
|
if (pkt_offset)
|
|
|
|
skb_pull(skb, pkt_offset);
|
2006-12-04 17:23:25 +00:00
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
skb->protocol = eth_type_trans(skb, netdev);
|
|
|
|
|
2009-04-07 22:50:47 +00:00
|
|
|
napi_gro_receive(&sds_ring->napi, skb);
|
2008-07-22 02:44:08 +00:00
|
|
|
|
2009-08-23 08:35:09 +00:00
|
|
|
adapter->stats.rx_pkts++;
|
2009-03-09 08:50:52 +00:00
|
|
|
adapter->stats.rxbytes += length;
|
2009-03-13 14:52:05 +00:00
|
|
|
|
|
|
|
return buffer;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
#define TCP_HDR_SIZE 20
|
|
|
|
#define TCP_TS_OPTION_SIZE 12
|
|
|
|
#define TCP_TS_HDR_SIZE (TCP_HDR_SIZE + TCP_TS_OPTION_SIZE)
|
|
|
|
|
|
|
|
static struct netxen_rx_buffer *
|
|
|
|
netxen_process_lro(struct netxen_adapter *adapter,
|
|
|
|
struct nx_host_sds_ring *sds_ring,
|
|
|
|
int ring, u64 sts_data0, u64 sts_data1)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
|
|
|
struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
|
|
|
|
struct netxen_rx_buffer *buffer;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct nx_host_rds_ring *rds_ring;
|
|
|
|
struct iphdr *iph;
|
|
|
|
struct tcphdr *th;
|
|
|
|
bool push, timestamp;
|
|
|
|
int l2_hdr_offset, l4_hdr_offset;
|
|
|
|
int index;
|
|
|
|
u16 lro_length, length, data_offset;
|
|
|
|
u32 seq_number;
|
|
|
|
|
|
|
|
if (unlikely(ring > adapter->max_rds_rings))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
rds_ring = &recv_ctx->rds_rings[ring];
|
|
|
|
|
|
|
|
index = netxen_get_lro_sts_refhandle(sts_data0);
|
|
|
|
if (unlikely(index > rds_ring->num_desc))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
buffer = &rds_ring->rx_buf_arr[index];
|
|
|
|
|
|
|
|
timestamp = netxen_get_lro_sts_timestamp(sts_data0);
|
|
|
|
lro_length = netxen_get_lro_sts_length(sts_data0);
|
|
|
|
l2_hdr_offset = netxen_get_lro_sts_l2_hdr_offset(sts_data0);
|
|
|
|
l4_hdr_offset = netxen_get_lro_sts_l4_hdr_offset(sts_data0);
|
|
|
|
push = netxen_get_lro_sts_push_flag(sts_data0);
|
|
|
|
seq_number = netxen_get_lro_sts_seq_number(sts_data1);
|
|
|
|
|
|
|
|
skb = netxen_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
|
|
|
|
if (!skb)
|
|
|
|
return buffer;
|
|
|
|
|
|
|
|
if (timestamp)
|
|
|
|
data_offset = l4_hdr_offset + TCP_TS_HDR_SIZE;
|
|
|
|
else
|
|
|
|
data_offset = l4_hdr_offset + TCP_HDR_SIZE;
|
|
|
|
|
|
|
|
skb_put(skb, lro_length + data_offset);
|
|
|
|
|
|
|
|
skb_pull(skb, l2_hdr_offset);
|
|
|
|
skb->protocol = eth_type_trans(skb, netdev);
|
|
|
|
|
|
|
|
iph = (struct iphdr *)skb->data;
|
|
|
|
th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
|
|
|
|
|
|
|
|
length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
|
|
|
|
iph->tot_len = htons(length);
|
|
|
|
iph->check = 0;
|
|
|
|
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
|
|
|
|
th->psh = push;
|
|
|
|
th->seq = htonl(seq_number);
|
|
|
|
|
2009-08-23 08:35:09 +00:00
|
|
|
length = skb->len;
|
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
netif_receive_skb(skb);
|
|
|
|
|
2009-08-23 08:35:09 +00:00
|
|
|
adapter->stats.lro_pkts++;
|
|
|
|
adapter->stats.rxbytes += length;
|
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
#define netxen_merge_rx_buffers(list, head) \
|
|
|
|
do { list_splice_tail_init(list, head); } while (0);
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
int
|
2009-03-13 14:52:05 +00:00
|
|
|
netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2009-03-13 14:52:05 +00:00
|
|
|
struct netxen_adapter *adapter = sds_ring->adapter;
|
|
|
|
|
|
|
|
struct list_head *cur;
|
|
|
|
|
2009-03-09 08:50:52 +00:00
|
|
|
struct status_desc *desc;
|
2009-03-13 14:52:05 +00:00
|
|
|
struct netxen_rx_buffer *rxbuf;
|
|
|
|
|
|
|
|
u32 consumer = sds_ring->consumer;
|
|
|
|
|
2009-03-13 14:52:04 +00:00
|
|
|
int count = 0;
|
2009-08-05 07:34:09 +00:00
|
|
|
u64 sts_data0, sts_data1;
|
|
|
|
int opcode, ring = 0, desc_cnt;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
|
|
|
while (count < max) {
|
2009-03-13 14:52:05 +00:00
|
|
|
desc = &sds_ring->desc_head[consumer];
|
2009-08-05 07:34:09 +00:00
|
|
|
sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
|
2009-03-09 08:50:52 +00:00
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
if (!(sts_data0 & STATUS_OWNER_HOST))
|
2006-10-21 19:33:03 +00:00
|
|
|
break;
|
2008-07-22 02:44:08 +00:00
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
desc_cnt = netxen_get_sts_desc_cnt(sts_data0);
|
2009-04-07 22:50:42 +00:00
|
|
|
|
2009-08-05 07:34:09 +00:00
|
|
|
opcode = netxen_get_sts_opcode(sts_data0);
|
2008-07-22 02:44:08 +00:00
|
|
|
|
2009-04-07 22:50:42 +00:00
|
|
|
switch (opcode) {
|
|
|
|
case NETXEN_NIC_RXPKT_DESC:
|
|
|
|
case NETXEN_OLD_RXPKT_DESC:
|
2009-07-26 20:07:37 +00:00
|
|
|
case NETXEN_NIC_SYN_OFFLOAD:
|
2009-08-05 07:34:09 +00:00
|
|
|
ring = netxen_get_sts_type(sts_data0);
|
|
|
|
rxbuf = netxen_process_rcv(adapter, sds_ring,
|
|
|
|
ring, sts_data0);
|
|
|
|
break;
|
|
|
|
case NETXEN_NIC_LRO_DESC:
|
|
|
|
ring = netxen_get_lro_sts_type(sts_data0);
|
|
|
|
sts_data1 = le64_to_cpu(desc->status_desc_data[1]);
|
|
|
|
rxbuf = netxen_process_lro(adapter, sds_ring,
|
|
|
|
ring, sts_data0, sts_data1);
|
2009-04-07 22:50:42 +00:00
|
|
|
break;
|
|
|
|
case NETXEN_NIC_RESPONSE_DESC:
|
|
|
|
netxen_handle_fw_message(desc_cnt, consumer, sds_ring);
|
|
|
|
default:
|
|
|
|
goto skip;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(desc_cnt > 1);
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
if (rxbuf)
|
|
|
|
list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
|
|
|
|
|
2009-04-07 22:50:42 +00:00
|
|
|
skip:
|
|
|
|
for (; desc_cnt > 0; desc_cnt--) {
|
|
|
|
desc = &sds_ring->desc_head[consumer];
|
|
|
|
desc->status_desc_data[0] =
|
|
|
|
cpu_to_le64(STATUS_OWNER_PHANTOM);
|
|
|
|
consumer = get_next_index(consumer, sds_ring->num_desc);
|
|
|
|
}
|
2006-10-21 19:33:03 +00:00
|
|
|
count++;
|
|
|
|
}
|
2009-03-09 08:50:52 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
for (ring = 0; ring < adapter->max_rds_rings; ring++) {
|
|
|
|
struct nx_host_rds_ring *rds_ring =
|
|
|
|
&adapter->recv_ctx.rds_rings[ring];
|
|
|
|
|
|
|
|
if (!list_empty(&sds_ring->free_list[ring])) {
|
|
|
|
list_for_each(cur, &sds_ring->free_list[ring]) {
|
|
|
|
rxbuf = list_entry(cur,
|
|
|
|
struct netxen_rx_buffer, list);
|
|
|
|
netxen_alloc_rx_skb(adapter, rds_ring, rxbuf);
|
|
|
|
}
|
|
|
|
spin_lock(&rds_ring->lock);
|
|
|
|
netxen_merge_rx_buffers(&sds_ring->free_list[ring],
|
|
|
|
&rds_ring->free_list);
|
|
|
|
spin_unlock(&rds_ring->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
netxen_post_rx_buffers_nodb(adapter, rds_ring);
|
|
|
|
}
|
2006-10-21 19:33:03 +00:00
|
|
|
|
|
|
|
if (count) {
|
2009-03-13 14:52:05 +00:00
|
|
|
sds_ring->consumer = consumer;
|
2009-09-05 17:43:10 +00:00
|
|
|
NXWRIO(adapter, sds_ring->crb_sts_consumer, consumer);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process Command status ring */
|
2008-03-18 02:59:49 +00:00
|
|
|
int netxen_process_cmd_ring(struct netxen_adapter *adapter)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
2009-04-07 22:50:40 +00:00
|
|
|
u32 sw_consumer, hw_consumer;
|
2008-03-18 02:59:50 +00:00
|
|
|
int count = 0, i;
|
2006-10-21 19:33:03 +00:00
|
|
|
struct netxen_cmd_buffer *buffer;
|
2008-03-18 02:59:50 +00:00
|
|
|
struct pci_dev *pdev = adapter->pdev;
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
2006-10-21 19:33:03 +00:00
|
|
|
struct netxen_skb_frag *frag;
|
2008-03-18 02:59:50 +00:00
|
|
|
int done = 0;
|
2009-04-28 15:29:10 +00:00
|
|
|
struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
if (!spin_trylock(&adapter->tx_clean_lock))
|
|
|
|
return 1;
|
|
|
|
|
2009-04-07 22:50:40 +00:00
|
|
|
sw_consumer = tx_ring->sw_consumer;
|
|
|
|
hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2009-04-07 22:50:40 +00:00
|
|
|
while (sw_consumer != hw_consumer) {
|
|
|
|
buffer = &tx_ring->cmd_buf_arr[sw_consumer];
|
2007-12-26 18:23:58 +00:00
|
|
|
if (buffer->skb) {
|
|
|
|
frag = &buffer->frag_array[0];
|
2006-10-21 19:33:03 +00:00
|
|
|
pci_unmap_single(pdev, frag->dma, frag->length,
|
|
|
|
PCI_DMA_TODEVICE);
|
2007-07-02 04:07:57 +00:00
|
|
|
frag->dma = 0ULL;
|
2006-10-21 19:33:03 +00:00
|
|
|
for (i = 1; i < buffer->frag_count; i++) {
|
|
|
|
frag++; /* Get the next frag */
|
|
|
|
pci_unmap_page(pdev, frag->dma, frag->length,
|
|
|
|
PCI_DMA_TODEVICE);
|
2007-07-02 04:07:57 +00:00
|
|
|
frag->dma = 0ULL;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2008-03-18 02:59:50 +00:00
|
|
|
adapter->stats.xmitfinished++;
|
2007-12-26 18:23:58 +00:00
|
|
|
dev_kfree_skb_any(buffer->skb);
|
|
|
|
buffer->skb = NULL;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-04-07 22:50:40 +00:00
|
|
|
sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
|
2008-03-18 02:59:50 +00:00
|
|
|
if (++count >= MAX_STATUS_HANDLE)
|
|
|
|
break;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-05-05 19:05:06 +00:00
|
|
|
if (count && netif_running(netdev)) {
|
2009-06-17 17:27:25 +00:00
|
|
|
tx_ring->sw_consumer = sw_consumer;
|
|
|
|
|
2008-03-18 02:59:50 +00:00
|
|
|
smp_mb();
|
2009-06-17 17:27:25 +00:00
|
|
|
|
2010-10-18 02:03:41 +00:00
|
|
|
if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev))
|
|
|
|
if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
|
2009-06-17 17:27:25 +00:00
|
|
|
netif_wake_queue(netdev);
|
2010-10-18 02:03:41 +00:00
|
|
|
adapter->tx_timeo_cnt = 0;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2006-12-04 17:23:25 +00:00
|
|
|
/*
|
|
|
|
* If everything is freed up to consumer then check if the ring is full
|
|
|
|
* If the ring is full then check if more needs to be freed and
|
|
|
|
* schedule the call back again.
|
|
|
|
*
|
|
|
|
* This happens when there are 2 CPUs. One could be freeing and the
|
|
|
|
* other filling it. If the ring is full when we get out of here and
|
|
|
|
* the card has already interrupted the host then the host can miss the
|
|
|
|
* interrupt.
|
|
|
|
*
|
|
|
|
* There is still a possible race condition and the host could miss an
|
|
|
|
* interrupt. The card has to take care of this.
|
|
|
|
*/
|
2009-04-07 22:50:40 +00:00
|
|
|
hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
|
|
|
|
done = (sw_consumer == hw_consumer);
|
2009-03-13 14:52:05 +00:00
|
|
|
spin_unlock(&adapter->tx_clean_lock);
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2010-09-23 05:40:09 +00:00
|
|
|
return done;
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
void
|
2009-03-13 14:52:05 +00:00
|
|
|
netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
|
|
|
|
struct nx_host_rds_ring *rds_ring)
|
2006-10-21 19:33:03 +00:00
|
|
|
{
|
|
|
|
struct rcv_desc *pdesc;
|
|
|
|
struct netxen_rx_buffer *buffer;
|
2009-03-13 14:52:05 +00:00
|
|
|
int producer, count = 0;
|
2006-12-04 17:23:25 +00:00
|
|
|
netxen_ctx_msg msg = 0;
|
2008-07-22 02:44:08 +00:00
|
|
|
struct list_head *head;
|
2006-10-21 19:33:03 +00:00
|
|
|
|
2008-07-22 02:44:06 +00:00
|
|
|
producer = rds_ring->producer;
|
2008-07-22 02:44:08 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
head = &rds_ring->free_list;
|
2008-07-22 02:44:08 +00:00
|
|
|
while (!list_empty(head)) {
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
buffer = list_entry(head->next, struct netxen_rx_buffer, list);
|
2009-01-15 04:50:00 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
if (!buffer->skb) {
|
|
|
|
if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
|
|
|
|
break;
|
2009-01-15 04:50:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
count++;
|
2008-07-22 02:44:08 +00:00
|
|
|
list_del(&buffer->list);
|
|
|
|
|
2006-12-04 17:23:25 +00:00
|
|
|
/* make a rcv descriptor */
|
2009-01-15 04:50:00 +00:00
|
|
|
pdesc = &rds_ring->desc_head[producer];
|
2009-03-13 14:52:05 +00:00
|
|
|
pdesc->addr_buffer = cpu_to_le64(buffer->dma);
|
2006-12-18 13:53:59 +00:00
|
|
|
pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
|
2008-07-22 02:44:06 +00:00
|
|
|
pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
|
2009-01-15 04:50:00 +00:00
|
|
|
|
2009-03-13 14:52:03 +00:00
|
|
|
producer = get_next_index(producer, rds_ring->num_desc);
|
2006-12-04 17:23:25 +00:00
|
|
|
}
|
2009-03-13 14:52:04 +00:00
|
|
|
|
2006-12-04 17:23:25 +00:00
|
|
|
if (count) {
|
2008-07-22 02:44:06 +00:00
|
|
|
rds_ring->producer = producer;
|
2009-09-05 17:43:10 +00:00
|
|
|
NXWRIO(adapter, rds_ring->crb_rcv_producer,
|
2009-03-13 14:52:03 +00:00
|
|
|
(producer-1) & (rds_ring->num_desc-1));
|
2008-07-22 02:44:06 +00:00
|
|
|
|
2009-07-26 20:07:42 +00:00
|
|
|
if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
|
2006-12-04 17:23:25 +00:00
|
|
|
/*
|
|
|
|
* Write a doorbell msg to tell phanmon of change in
|
|
|
|
* receive ring producer
|
2008-07-22 02:44:06 +00:00
|
|
|
* Only for firmware version < 4.0.0
|
2006-12-04 17:23:25 +00:00
|
|
|
*/
|
|
|
|
netxen_set_msg_peg_id(msg, NETXEN_RCV_PEG_DB_ID);
|
|
|
|
netxen_set_msg_privid(msg);
|
|
|
|
netxen_set_msg_count(msg,
|
2009-03-13 14:52:03 +00:00
|
|
|
((producer - 1) &
|
|
|
|
(rds_ring->num_desc - 1)));
|
2007-04-20 14:52:37 +00:00
|
|
|
netxen_set_msg_ctxid(msg, adapter->portnum);
|
2006-12-04 17:23:25 +00:00
|
|
|
netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
|
2009-10-13 05:31:44 +00:00
|
|
|
NXWRIO(adapter, DB_NORMALIZE(adapter,
|
|
|
|
NETXEN_RCV_PRODUCER_OFFSET), msg);
|
2008-07-22 02:44:06 +00:00
|
|
|
}
|
2006-12-04 17:23:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-09 08:50:55 +00:00
|
|
|
static void
|
2009-03-13 14:52:05 +00:00
|
|
|
netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
|
|
|
|
struct nx_host_rds_ring *rds_ring)
|
2006-12-04 17:23:25 +00:00
|
|
|
{
|
|
|
|
struct rcv_desc *pdesc;
|
|
|
|
struct netxen_rx_buffer *buffer;
|
2009-03-13 14:52:05 +00:00
|
|
|
int producer, count = 0;
|
2008-07-22 02:44:08 +00:00
|
|
|
struct list_head *head;
|
2006-12-04 17:23:25 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
if (!spin_trylock(&rds_ring->lock))
|
|
|
|
return;
|
|
|
|
|
2010-06-13 23:39:04 +00:00
|
|
|
producer = rds_ring->producer;
|
|
|
|
|
2008-07-22 02:44:08 +00:00
|
|
|
head = &rds_ring->free_list;
|
|
|
|
while (!list_empty(head)) {
|
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
buffer = list_entry(head->next, struct netxen_rx_buffer, list);
|
2009-01-15 04:50:00 +00:00
|
|
|
|
2009-03-13 14:52:05 +00:00
|
|
|
if (!buffer->skb) {
|
|
|
|
if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
|
|
|
|
break;
|
2009-01-15 04:50:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
count++;
|
2008-07-22 02:44:08 +00:00
|
|
|
list_del(&buffer->list);
|
|
|
|
|
2006-10-21 19:33:03 +00:00
|
|
|
/* make a rcv descriptor */
|
2009-01-15 04:50:00 +00:00
|
|
|
pdesc = &rds_ring->desc_head[producer];
|
2006-12-18 13:53:59 +00:00
|
|
|
pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
|
2008-07-22 02:44:06 +00:00
|
|
|
pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
|
2006-10-21 19:33:03 +00:00
|
|
|
pdesc->addr_buffer = cpu_to_le64(buffer->dma);
|
2009-01-15 04:50:00 +00:00
|
|
|
|
2009-03-13 14:52:03 +00:00
|
|
|
producer = get_next_index(producer, rds_ring->num_desc);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count) {
|
2008-07-22 02:44:06 +00:00
|
|
|
rds_ring->producer = producer;
|
2009-09-05 17:43:10 +00:00
|
|
|
NXWRIO(adapter, rds_ring->crb_rcv_producer,
|
2009-03-13 14:52:03 +00:00
|
|
|
(producer - 1) & (rds_ring->num_desc - 1));
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
2009-03-13 14:52:05 +00:00
|
|
|
spin_unlock(&rds_ring->lock);
|
2006-10-21 19:33:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void netxen_nic_clear_stats(struct netxen_adapter *adapter)
|
|
|
|
{
|
|
|
|
memset(&adapter->stats, 0, sizeof(adapter->stats));
|
|
|
|
}
|
|
|
|
|