netxen_nic_init.c 37.2 KB
Newer Older
A
Amit S. Kale 已提交
1
/*
D
Dhananjay Phadke 已提交
2
 * Copyright (C) 2003 - 2009 NetXen, Inc.
A
Amit S. Kale 已提交
3
 * All rights reserved.
4
 *
A
Amit S. Kale 已提交
5 6 7 8
 * 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.
9
 *
A
Amit S. Kale 已提交
10 11 12 13
 * 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.
14
 *
A
Amit S. Kale 已提交
15 16 17 18
 * 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.
19
 *
A
Amit S. Kale 已提交
20 21
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.
22
 *
A
Amit S. Kale 已提交
23 24
 * Contact Information:
 *    info@netxen.com
D
Dhananjay Phadke 已提交
25 26 27
 * NetXen Inc,
 * 18922 Forge Drive
 * Cupertino, CA 95014-0701
A
Amit S. Kale 已提交
28 29 30 31 32 33 34 35 36 37
 *
 */

#include <linux/netdevice.h>
#include <linux/delay.h>
#include "netxen_nic.h"
#include "netxen_nic_hw.h"
#include "netxen_nic_phan_reg.h"

struct crb_addr_pair {
38 39
	u32 addr;
	u32 data;
A
Amit S. Kale 已提交
40 41 42 43
};

#define NETXEN_MAX_CRB_XFORM 60
static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
44
#define NETXEN_ADDR_ERROR (0xffffffff)
A
Amit S. Kale 已提交
45 46 47 48 49

#define crb_addr_transform(name) \
	crb_addr_xform[NETXEN_HW_PX_MAP_CRB_##name] = \
	NETXEN_HW_CRB_HUB_AGT_ADR_##name << 20

50 51
#define NETXEN_NIC_XDMA_RESET 0x8000ff

52
static void
53 54
netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
		struct nx_host_rds_ring *rds_ring);
A
Adrian Bunk 已提交
55

A
Amit S. Kale 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
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);
106
	crb_addr_transform(SMB);
107 108
	crb_addr_transform(OCM0);
	crb_addr_transform(I2C0);
A
Amit S. Kale 已提交
109 110
}

111
void netxen_release_rx_buffers(struct netxen_adapter *adapter)
A
Amit S. Kale 已提交
112
{
113
	struct netxen_recv_context *recv_ctx;
D
Dhananjay Phadke 已提交
114
	struct nx_host_rds_ring *rds_ring;
115
	struct netxen_rx_buffer *rx_buf;
116 117 118 119 120
	int i, ring;

	recv_ctx = &adapter->recv_ctx;
	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
		rds_ring = &recv_ctx->rds_rings[ring];
121
		for (i = 0; i < rds_ring->num_desc; ++i) {
122 123 124 125 126 127 128 129 130
			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);
131 132 133 134 135 136 137 138 139
		}
	}
}

void netxen_release_tx_buffers(struct netxen_adapter *adapter)
{
	struct netxen_cmd_buffer *cmd_buf;
	struct netxen_skb_frag *buffrag;
	int i, j;
140
	struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
141

142 143
	cmd_buf = tx_ring->cmd_buf_arr;
	for (i = 0; i < tx_ring->num_desc; i++) {
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
		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;
D
Dhananjay Phadke 已提交
170
	struct nx_host_rds_ring *rds_ring;
171
	struct nx_host_tx_ring *tx_ring;
172 173 174
	int ring;

	recv_ctx = &adapter->recv_ctx;
175 176 177 178

	if (recv_ctx->rds_rings == NULL)
		goto skip_rds;

179 180
	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
		rds_ring = &recv_ctx->rds_rings[ring];
181 182
		vfree(rds_ring->rx_buf_arr);
		rds_ring->rx_buf_arr = NULL;
183
	}
184 185 186 187 188
	kfree(recv_ctx->rds_rings);

skip_rds:
	if (adapter->tx_ring == NULL)
		return;
189

190
	tx_ring = adapter->tx_ring;
191
	vfree(tx_ring->cmd_buf_arr);
192 193 194 195 196
}

int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
{
	struct netxen_recv_context *recv_ctx;
D
Dhananjay Phadke 已提交
197
	struct nx_host_rds_ring *rds_ring;
198
	struct nx_host_sds_ring *sds_ring;
199
	struct nx_host_tx_ring *tx_ring;
200
	struct netxen_rx_buffer *rx_buf;
201
	int ring, i, size;
202 203 204

	struct netxen_cmd_buffer *cmd_buf_arr;
	struct net_device *netdev = adapter->netdev;
205
	struct pci_dev *pdev = adapter->pdev;
206

207 208 209 210 211 212 213 214 215
	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;

216
	tx_ring->num_desc = adapter->num_txd;
217
	tx_ring->txq = netdev_get_tx_queue(netdev, 0);
218 219

	cmd_buf_arr = vmalloc(TX_BUFF_RINGSIZE(tx_ring));
220
	if (cmd_buf_arr == NULL) {
221
		dev_err(&pdev->dev, "%s: failed to allocate cmd buffer ring\n",
222 223 224
		       netdev->name);
		return -ENOMEM;
	}
225 226
	memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
	tx_ring->cmd_buf_arr = cmd_buf_arr;
227

228
	recv_ctx = &adapter->recv_ctx;
229 230 231 232 233 234 235 236 237 238

	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);
		return -ENOMEM;
	}
	recv_ctx->rds_rings = rds_ring;

239 240
	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
		rds_ring = &recv_ctx->rds_rings[ring];
241 242 243
		switch (ring) {
		case RCV_RING_NORMAL:
			rds_ring->num_desc = adapter->num_rxd;
244 245 246
			if (adapter->ahw.cut_through) {
				rds_ring->dma_size =
					NX_CT_DEFAULT_RX_BUF_LEN;
D
Dhananjay Phadke 已提交
247
				rds_ring->skb_size =
248 249 250 251 252 253 254
					NX_CT_DEFAULT_RX_BUF_LEN;
			} else {
				rds_ring->dma_size = RX_DMA_MAP_LEN;
				rds_ring->skb_size =
					MAX_RX_BUFFER_LENGTH;
			}
			break;
255

256 257
		case RCV_RING_JUMBO:
			rds_ring->num_desc = adapter->num_jumbo_rxd;
258 259 260 261 262 263 264 265 266
			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;
			rds_ring->skb_size =
				rds_ring->dma_size + NET_IP_ALIGN;
			break;
267

268
		case RCV_RING_LRO:
269
			rds_ring->num_desc = adapter->num_lro_rxd;
270 271 272 273 274 275
			rds_ring->dma_size = RX_LRO_DMA_MAP_LEN;
			rds_ring->skb_size = MAX_RX_LRO_BUFFER_LENGTH;
			break;

		}
		rds_ring->rx_buf_arr = (struct netxen_rx_buffer *)
276
			vmalloc(RCV_BUFF_RINGSIZE(rds_ring));
277 278 279 280 281 282 283
		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;
		}
284
		memset(rds_ring->rx_buf_arr, 0, RCV_BUFF_RINGSIZE(rds_ring));
285 286 287 288 289 290
		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;
291
		for (i = 0; i < rds_ring->num_desc; i++) {
292 293 294 295 296
			list_add_tail(&rx_buf->list,
					&rds_ring->free_list);
			rx_buf->ref_handle = i;
			rx_buf->state = NETXEN_BUFFER_FREE;
			rx_buf++;
A
Amit S. Kale 已提交
297
		}
298 299 300 301 302 303 304 305 306 307 308
		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]);
A
Amit S. Kale 已提交
309
	}
310 311 312 313 314 315

	return 0;

err_out:
	netxen_free_sw_resources(adapter);
	return -ENOMEM;
A
Amit S. Kale 已提交
316 317 318 319
}

void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
{
D
Dhananjay Phadke 已提交
320 321 322
	adapter->macaddr_set = netxen_p2_nic_set_mac_addr;
	adapter->set_multi = netxen_p2_nic_set_multi;

323
	switch (adapter->ahw.port_type) {
A
Amit S. Kale 已提交
324
	case NETXEN_NIC_GBE:
325
		adapter->enable_phy_interrupts =
A
Amit S. Kale 已提交
326
		    netxen_niu_gbe_enable_phy_interrupts;
327
		adapter->disable_phy_interrupts =
A
Amit S. Kale 已提交
328
		    netxen_niu_gbe_disable_phy_interrupts;
329 330 331 332
		adapter->set_mtu = netxen_nic_set_mtu_gb;
		adapter->set_promisc = netxen_niu_set_promiscuous_mode;
		adapter->phy_read = netxen_niu_gbe_phy_read;
		adapter->phy_write = netxen_niu_gbe_phy_write;
333
		adapter->init_port = netxen_niu_gbe_init_port;
334
		adapter->stop_port = netxen_niu_disable_gbe_port;
A
Amit S. Kale 已提交
335 336 337
		break;

	case NETXEN_NIC_XGBE:
338
		adapter->enable_phy_interrupts =
A
Amit S. Kale 已提交
339
		    netxen_niu_xgbe_enable_phy_interrupts;
340
		adapter->disable_phy_interrupts =
A
Amit S. Kale 已提交
341
		    netxen_niu_xgbe_disable_phy_interrupts;
342 343 344 345
		adapter->set_mtu = netxen_nic_set_mtu_xgb;
		adapter->init_port = netxen_niu_xg_init_port;
		adapter->set_promisc = netxen_niu_xg_set_promiscuous_mode;
		adapter->stop_port = netxen_niu_disable_xg_port;
A
Amit S. Kale 已提交
346 347 348 349 350
		break;

	default:
		break;
	}
351 352 353 354

	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
		adapter->set_mtu = nx_fw_cmd_set_mtu;
		adapter->set_promisc = netxen_p3_nic_set_promisc;
D
Dhananjay Phadke 已提交
355 356
		adapter->macaddr_set = netxen_p3_nic_set_mac_addr;
		adapter->set_multi = netxen_p3_nic_set_multi;
357
	}
A
Amit S. Kale 已提交
358 359 360 361 362 363
}

/*
 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
 * address to external PCI CRB address.
 */
A
Adrian Bunk 已提交
364
static u32 netxen_decode_crb_addr(u32 addr)
A
Amit S. Kale 已提交
365 366
{
	int i;
367
	u32 base_addr, offset, pci_base;
A
Amit S. Kale 已提交
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386

	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
		return (pci_base + offset);
}

387 388
static long rom_max_timeout = 100;
static long rom_lock_timeout = 10000;
A
Amit S. Kale 已提交
389

A
Adrian Bunk 已提交
390
static int rom_lock(struct netxen_adapter *adapter)
A
Amit S. Kale 已提交
391 392 393 394 395 396 397
{
	int iter;
	u32 done = 0;
	int timeout = 0;

	while (!done) {
		/* acquire semaphore2 from PCI HW block */
398
		done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK));
A
Amit S. Kale 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
		if (done == 1)
			break;
		if (timeout >= rom_lock_timeout)
			return -EIO;

		timeout++;
		/*
		 * Yield CPU
		 */
		if (!in_atomic())
			schedule();
		else {
			for (iter = 0; iter < 20; iter++)
				cpu_relax();	/*This a nop instr on i386 */
		}
	}
415
	NXWR32(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
A
Amit S. Kale 已提交
416 417 418
	return 0;
}

A
Adrian Bunk 已提交
419
static int netxen_wait_rom_done(struct netxen_adapter *adapter)
A
Amit S. Kale 已提交
420 421 422 423
{
	long timeout = 0;
	long done = 0;

D
Dhananjay Phadke 已提交
424 425
	cond_resched();

A
Amit S. Kale 已提交
426
	while (done == 0) {
427
		done = NXRD32(adapter, NETXEN_ROMUSB_GLB_STATUS);
A
Amit S. Kale 已提交
428 429 430 431 432 433 434 435 436 437
		done &= 2;
		timeout++;
		if (timeout >= rom_max_timeout) {
			printk("Timeout reached  waiting for rom done");
			return -EIO;
		}
	}
	return 0;
}

A
Adrian Bunk 已提交
438
static void netxen_rom_unlock(struct netxen_adapter *adapter)
439 440
{
	/* release semaphore2 */
441
	NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK));
442 443 444

}

A
Adrian Bunk 已提交
445 446
static int do_rom_fast_read(struct netxen_adapter *adapter,
			    int addr, int *valp)
A
Amit S. Kale 已提交
447
{
448 449 450 451
	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);
A
Amit S. Kale 已提交
452 453 454 455 456
	if (netxen_wait_rom_done(adapter)) {
		printk("Error waiting for rom done\n");
		return -EIO;
	}
	/* reset abyte_cnt and dummy_byte_cnt */
457
	NXWR32(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
D
Dhananjay Phadke 已提交
458
	udelay(10);
459
	NXWR32(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
A
Amit S. Kale 已提交
460

461
	*valp = NXRD32(adapter, NETXEN_ROMUSB_ROM_RDATA);
A
Amit S. Kale 已提交
462 463 464
	return 0;
}

A
Adrian Bunk 已提交
465 466
static int do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
				  u8 *bytes, size_t size)
467 468 469 470 471
{
	int addridx;
	int ret = 0;

	for (addridx = addr; addridx < (addr + size); addridx += 4) {
A
Al Viro 已提交
472 473
		int v;
		ret = do_rom_fast_read(adapter, addridx, &v);
474 475
		if (ret != 0)
			break;
A
Al Viro 已提交
476
		*(__le32 *)bytes = cpu_to_le32(v);
477 478 479 480 481 482 483
		bytes += 4;
	}

	return ret;
}

int
484
netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
485 486 487 488 489 490 491 492 493 494 495 496 497 498
				u8 *bytes, size_t size)
{
	int ret;

	ret = rom_lock(adapter);
	if (ret < 0)
		return ret;

	ret = do_rom_fast_read_words(adapter, addr, bytes, size);

	netxen_rom_unlock(adapter);
	return ret;
}

A
Amit S. Kale 已提交
499 500 501 502 503 504 505 506
int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
{
	int ret;

	if (rom_lock(adapter) != 0)
		return -EIO;

	ret = do_rom_fast_read(adapter, addr, valp);
507 508 509 510
	netxen_rom_unlock(adapter);
	return ret;
}

A
Amit S. Kale 已提交
511 512 513 514 515 516
#define NETXEN_BOARDTYPE		0x4008
#define NETXEN_BOARDNUM 		0x400c
#define NETXEN_CHIPNUM			0x4010

int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
{
517
	int addr, val;
D
Dhananjay Phadke 已提交
518
	int i, n, init_delay = 0;
A
Amit S. Kale 已提交
519
	struct crb_addr_pair *buf;
D
Dhananjay Phadke 已提交
520
	unsigned offset;
521
	u32 off;
A
Amit S. Kale 已提交
522 523

	/* resetall */
D
Dhananjay Phadke 已提交
524
	rom_lock(adapter);
525
	NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, 0xffffffff);
D
Dhananjay Phadke 已提交
526
	netxen_rom_unlock(adapter);
A
Amit S. Kale 已提交
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542

	if (verbose) {
		if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
			printk("P2 ROM board type: 0x%08x\n", val);
		else
			printk("Could not read board type\n");
		if (netxen_rom_fast_read(adapter, NETXEN_BOARDNUM, &val) == 0)
			printk("P2 ROM board  num: 0x%08x\n", val);
		else
			printk("Could not read board number\n");
		if (netxen_rom_fast_read(adapter, NETXEN_CHIPNUM, &val) == 0)
			printk("P2 ROM chip   num: 0x%08x\n", val);
		else
			printk("Could not read chip number\n");
	}

543 544
	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
		if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
D
Dhananjay Phadke 已提交
545
			(n != 0xcafecafe) ||
546 547 548
			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);
A
Amit S. Kale 已提交
549 550
			return -EIO;
		}
551 552 553 554 555 556 557 558
		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;
A
Amit S. Kale 已提交
559
		}
560 561 562 563 564 565 566 567 568 569 570 571 572
		offset = 1;
		n &= ~0x80000000;
	}

	if (n < 1024) {
		if (verbose)
			printk(KERN_DEBUG "%s: %d CRB init values found"
			       " in ROM.\n", netxen_nic_driver_name, n);
	} else {
		printk(KERN_ERR "%s:n=0x%x Error! NetXen card flash not"
		       " initialized.\n", __func__, n);
		return -EIO;
	}
A
Amit S. Kale 已提交
573

574 575 576 577 578 579 580 581
	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;
	}
	for (i = 0; i < n; i++) {
		if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
582 583
		netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
			kfree(buf);
584
			return -EIO;
585
		}
586 587 588 589 590 591 592 593 594 595 596 597 598 599

		buf[i].addr = addr;
		buf[i].data = val;

		if (verbose)
			printk(KERN_DEBUG "%s: PCI:     0x%08x == 0x%08x\n",
				netxen_nic_driver_name,
				(u32)netxen_decode_crb_addr(addr), val);
	}
	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",
600
					buf[i].addr);
601 602 603 604 605 606 607 608 609 610
			continue;
		}
		off += NETXEN_PCI_CRBSPACE;
		/* skipping cold reboot MAGIC */
		if (off == NETXEN_CAM_RAM(0x1fc))
			continue;

		if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
			/* do not reset PCI */
			if (off == (ROMUSB_GLB + 0xbc))
611
				continue;
D
Dhananjay Phadke 已提交
612 613 614 615 616 617 618 619
			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;
620 621 622 623
			if (off == (NETXEN_CRB_PEG_NET_1 + 0x18))
				buf[i].data = 0x1020;
			/* skip the function enable register */
			if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION))
A
Amit S. Kale 已提交
624
				continue;
625 626 627 628 629
			if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION2))
				continue;
			if ((off & 0x0ff00000) == NETXEN_CRB_SMB)
				continue;
		}
A
Amit S. Kale 已提交
630

631 632 633 634 635 636
		if (off == NETXEN_ADDR_ERROR) {
			printk(KERN_ERR "%s: Err: Unknown addr: 0x%08x\n",
					netxen_nic_driver_name, buf[i].addr);
			continue;
		}

D
Dhananjay Phadke 已提交
637
		init_delay = 1;
638 639 640
		/* After writing this register, HW needs time for CRB */
		/* to quiet down (else crb_window returns 0xffffffff) */
		if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
D
Dhananjay Phadke 已提交
641
			init_delay = 1000;
642
			if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
A
Amit S. Kale 已提交
643
				/* hold xdma in reset also */
644
				buf[i].data = NETXEN_NIC_XDMA_RESET;
D
Dhananjay Phadke 已提交
645
				buf[i].data = 0x8000ff;
A
Amit S. Kale 已提交
646
			}
647
		}
A
Amit S. Kale 已提交
648

649
		NXWR32(adapter, off, buf[i].data);
A
Amit S. Kale 已提交
650

D
Dhananjay Phadke 已提交
651
		msleep(init_delay);
652 653
	}
	kfree(buf);
A
Amit S. Kale 已提交
654

655
	/* disable_peg_cache_all */
A
Amit S. Kale 已提交
656

657 658
	/* unreset_net_cache */
	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
659 660
		val = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
		NXWR32(adapter, NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
A
Amit S. Kale 已提交
661
	}
662 663

	/* p2dn replyCount */
664
	NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
665
	/* disable_peg_cache 0 */
666
	NXWR32(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
667
	/* disable_peg_cache 1 */
668
	NXWR32(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
669 670 671 672

	/* peg_clr_all */

	/* peg_clr 0 */
673 674
	NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
	NXWR32(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
675
	/* peg_clr 1 */
676 677
	NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
	NXWR32(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
678
	/* peg_clr 2 */
679 680
	NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
	NXWR32(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
681
	/* peg_clr 3 */
682 683
	NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
	NXWR32(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
A
Amit S. Kale 已提交
684 685 686
	return 0;
}

687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
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;

	/* last attempt had failed */
	if (NXRD32(adapter, CRB_CMDPEG_STATE) == PHAN_INITIALIZE_FAILED)
		return 1;

	old_count = count = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);

	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) {

		const struct firmware *fw = adapter->fw;

		val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);
		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;

		if (version == NETXEN_VERSION_CODE(major, minor, build)) {

			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;
}

static char *fw_name[] = {
	"nxromimg.bin", "nx3fwct.bin", "nx3fwmn.bin", "flash",
};

D
Dhananjay Phadke 已提交
756 757 758 759 760 761
int
netxen_load_firmware(struct netxen_adapter *adapter)
{
	u64 *ptr64;
	u32 i, flashaddr, size;
	const struct firmware *fw = adapter->fw;
762 763 764 765
	struct pci_dev *pdev = adapter->pdev;

	dev_info(&pdev->dev, "loading firmware from %s\n",
			fw_name[adapter->fw_type]);
D
Dhananjay Phadke 已提交
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832

	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;

		ptr64 = (u64 *)&fw->data[NETXEN_BOOTLD_START];
		flashaddr = NETXEN_BOOTLD_START;

		for (i = 0; i < size; i++) {
			data = cpu_to_le64(ptr64[i]);
			adapter->pci_mem_write(adapter, flashaddr, &data, 8);
			flashaddr += 8;
		}

		size = *(u32 *)&fw->data[NX_FW_SIZE_OFFSET];
		size = (__force u32)cpu_to_le32(size) / 8;

		ptr64 = (u64 *)&fw->data[NETXEN_IMAGE_START];
		flashaddr = NETXEN_IMAGE_START;

		for (i = 0; i < size; i++) {
			data = cpu_to_le64(ptr64[i]);

			if (adapter->pci_mem_write(adapter,
						flashaddr, &data, 8))
				return -EIO;

			flashaddr += 8;
		}
	} else {
		u32 data;

		size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START) / 4;
		flashaddr = NETXEN_BOOTLD_START;

		for (i = 0; i < size; i++) {
			if (netxen_rom_fast_read(adapter,
					flashaddr, (int *)&data) != 0)
				return -EIO;

			if (adapter->pci_mem_write(adapter,
						flashaddr, &data, 4))
				return -EIO;

			flashaddr += 4;
		}
	}
	msleep(1);

	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
		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
netxen_validate_firmware(struct netxen_adapter *adapter, const char *fwname)
{
	__le32 val;
833
	u32 ver, min_ver, bios;
D
Dhananjay Phadke 已提交
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
	struct pci_dev *pdev = adapter->pdev;
	const struct firmware *fw = adapter->fw;

	if (fw->size < NX_FW_MIN_SIZE)
		return -EINVAL;

	val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_MAGIC_OFFSET]);
	if ((__force u32)val != NETXEN_BDINFO_MAGIC)
		return -EINVAL;

	val = cpu_to_le32(*(u32 *)&fw->data[NX_FW_VERSION_OFFSET]);

	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
		min_ver = NETXEN_VERSION_CODE(4, 0, 216);
	else
		min_ver = NETXEN_VERSION_CODE(3, 4, 216);

851
	ver = NETXEN_DECODE_VERSION(val);
D
Dhananjay Phadke 已提交
852

853
	if ((_major(ver) > _NETXEN_NIC_LINUX_MAJOR) || (ver < min_ver)) {
D
Dhananjay Phadke 已提交
854 855
		dev_err(&pdev->dev,
				"%s: firmware version %d.%d.%d unsupported\n",
856
				fwname, _major(ver), _minor(ver), _build(ver));
D
Dhananjay Phadke 已提交
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
		return -EINVAL;
	}

	val = cpu_to_le32(*(u32 *)&fw->data[NX_BIOS_VERSION_OFFSET]);
	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",
				fwname);
		return -EINVAL;
	}

	/* check if flashed firmware is newer */
	if (netxen_rom_fast_read(adapter,
			NX_FW_VERSION_OFFSET, (int *)&val))
		return -EIO;
872 873 874 875
	val = NETXEN_DECODE_VERSION(val);
	if (val > ver) {
		dev_info(&pdev->dev, "%s: firmware is older than flash\n",
				fwname);
D
Dhananjay Phadke 已提交
876
		return -EINVAL;
877
	}
D
Dhananjay Phadke 已提交
878 879 880 881 882 883 884 885

	NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
	return 0;
}

void netxen_request_firmware(struct netxen_adapter *adapter)
{
	u32 capability, flashed_ver;
886
	u8 fw_type;
D
Dhananjay Phadke 已提交
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
	struct pci_dev *pdev = adapter->pdev;
	int rc = 0;

	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
		fw_type = NX_P2_MN_ROMIMAGE;
		goto request_fw;
	} else {
		fw_type = NX_P3_CT_ROMIMAGE;
		goto request_fw;
	}

request_mn:
	capability = 0;

	netxen_rom_fast_read(adapter,
			NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
903 904
	flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);

D
Dhananjay Phadke 已提交
905 906 907 908 909 910 911 912
	if (flashed_ver >= NETXEN_VERSION_CODE(4, 0, 220)) {
		capability = NXRD32(adapter, NX_PEG_TUNE_CAPABILITY);
		if (capability & NX_PEG_TUNE_MN_PRESENT) {
			fw_type = NX_P3_MN_ROMIMAGE;
			goto request_fw;
		}
	}

913
	fw_type = NX_FLASH_ROMIMAGE;
914 915 916
	adapter->fw = NULL;
	goto done;

D
Dhananjay Phadke 已提交
917 918 919 920 921 922 923 924
request_fw:
	rc = request_firmware(&adapter->fw, fw_name[fw_type], &pdev->dev);
	if (rc != 0) {
		if (fw_type == NX_P3_CT_ROMIMAGE) {
			msleep(1);
			goto request_mn;
		}

925
		fw_type = NX_FLASH_ROMIMAGE;
D
Dhananjay Phadke 已提交
926 927 928 929 930 931 932 933 934 935 936 937 938
		adapter->fw = NULL;
		goto done;
	}

	rc = netxen_validate_firmware(adapter, fw_name[fw_type]);
	if (rc != 0) {
		release_firmware(adapter->fw);

		if (fw_type == NX_P3_CT_ROMIMAGE) {
			msleep(1);
			goto request_mn;
		}

939
		fw_type = NX_FLASH_ROMIMAGE;
D
Dhananjay Phadke 已提交
940 941 942 943 944
		adapter->fw = NULL;
		goto done;
	}

done:
945
	adapter->fw_type = fw_type;
D
Dhananjay Phadke 已提交
946 947 948 949 950 951 952 953 954 955
}


void
netxen_release_firmware(struct netxen_adapter *adapter)
{
	if (adapter->fw)
		release_firmware(adapter->fw);
}

956 957 958 959 960 961 962
int netxen_initialize_adapter_offload(struct netxen_adapter *adapter)
{
	uint64_t addr;
	uint32_t hi;
	uint32_t lo;

	adapter->dummy_dma.addr =
963
	    pci_alloc_consistent(adapter->pdev,
964 965 966 967
				 NETXEN_HOST_DUMMY_DMA_SIZE,
				 &adapter->dummy_dma.phys_addr);
	if (adapter->dummy_dma.addr == NULL) {
		printk("%s: ERROR: Could not allocate dummy DMA memory\n",
968
		       __func__);
969 970 971 972 973 974 975
		return -ENOMEM;
	}

	addr = (uint64_t) adapter->dummy_dma.phys_addr;
	hi = (addr >> 32) & 0xffffffff;
	lo = addr & 0xffffffff;

976 977
	NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
	NXWR32(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
978

979 980
	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
		uint32_t temp = 0;
981
		NXWR32(adapter, CRB_HOST_DUMMY_BUF, temp);
982 983
	}

984 985 986 987 988
	return 0;
}

void netxen_free_adapter_offload(struct netxen_adapter *adapter)
{
D
Dhananjay Phadke 已提交
989 990 991 992
	int i = 100;

	if (!adapter->dummy_dma.addr)
		return;
993

D
Dhananjay Phadke 已提交
994
	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
995 996 997 998 999 1000 1001
		do {
			if (dma_watchdog_shutdown_request(adapter) == 1)
				break;
			msleep(50);
			if (dma_watchdog_shutdown_poll_result(adapter) == 1)
				break;
		} while (--i);
D
Dhananjay Phadke 已提交
1002
	}
1003

D
Dhananjay Phadke 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012
	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;
	} else {
		printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
				adapter->netdev->name);
1013 1014 1015
	}
}

1016
int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
A
Amit S. Kale 已提交
1017 1018
{
	u32 val = 0;
1019
	int retries = 60;
A
Amit S. Kale 已提交
1020

1021 1022 1023 1024 1025
	if (pegtune_val)
		return 0;

	do {
		val = NXRD32(adapter, CRB_CMDPEG_STATE);
1026

1027 1028 1029 1030 1031 1032 1033 1034 1035
		switch (val) {
		case PHAN_INITIALIZE_COMPLETE:
		case PHAN_INITIALIZE_ACK:
			return 0;
		case PHAN_INITIALIZE_FAILED:
			goto out_err;
		default:
			break;
		}
1036

1037
		msleep(500);
1038

1039
	} while (--retries);
1040

1041
	NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
1042

1043 1044 1045
out_err:
	dev_warn(&adapter->pdev->dev, "firmware init failed\n");
	return -EIO;
A
Amit S. Kale 已提交
1046 1047
}

1048 1049
static int
netxen_receive_peg_ready(struct netxen_adapter *adapter)
1050 1051 1052 1053 1054
{
	u32 val = 0;
	int retries = 2000;

	do {
1055
		val = NXRD32(adapter, CRB_RCVPEG_STATE);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072

		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;
}

1073 1074 1075 1076 1077 1078 1079 1080
int netxen_init_firmware(struct netxen_adapter *adapter)
{
	int err;

	err = netxen_receive_peg_ready(adapter);
	if (err)
		return err;

1081 1082 1083 1084
	NXWR32(adapter, CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
	NXWR32(adapter, CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
	NXWR32(adapter, CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
	NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
1085

1086
	if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222)) {
1087
		adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
1088 1089
	}

1090 1091 1092
	return err;
}

1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
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;
	}
}

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
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;
}

1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
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;

	if (likely(adapter->rx_csum && cksum == STATUS_CKSUM_OK)) {
		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;
}

1223
static struct netxen_rx_buffer *
D
Dhananjay Phadke 已提交
1224
netxen_process_rcv(struct netxen_adapter *adapter,
A
Amit Kumar Salecha 已提交
1225 1226
		int ring, int index, int length, int cksum, int pkt_offset,
		struct nx_host_sds_ring *sds_ring)
A
Amit S. Kale 已提交
1227
{
1228
	struct net_device *netdev = adapter->netdev;
1229
	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
A
Amit S. Kale 已提交
1230 1231
	struct netxen_rx_buffer *buffer;
	struct sk_buff *skb;
D
Dhananjay Phadke 已提交
1232
	struct nx_host_rds_ring *rds_ring = &recv_ctx->rds_rings[ring];
A
Amit S. Kale 已提交
1233

1234
	if (unlikely(index > rds_ring->num_desc))
1235
		return NULL;
1236

D
Dhananjay Phadke 已提交
1237
	buffer = &rds_ring->rx_buf_arr[index];
A
Amit S. Kale 已提交
1238

1239 1240
	skb = netxen_process_rxbuf(adapter, rds_ring, index, cksum);
	if (!skb)
1241
		return buffer;
D
Dhananjay Phadke 已提交
1242

D
Dhananjay Phadke 已提交
1243 1244 1245 1246
	if (length > rds_ring->skb_size)
		skb_put(skb, rds_ring->skb_size);
	else
		skb_put(skb, length);
1247

D
Dhananjay Phadke 已提交
1248 1249 1250

	if (pkt_offset)
		skb_pull(skb, pkt_offset);
1251

A
Amit S. Kale 已提交
1252 1253
	skb->protocol = eth_type_trans(skb, netdev);

A
Amit Kumar Salecha 已提交
1254
	napi_gro_receive(&sds_ring->napi, skb);
1255

D
Dhananjay Phadke 已提交
1256 1257
	adapter->stats.no_rcv++;
	adapter->stats.rxbytes += length;
1258 1259

	return buffer;
A
Amit S. Kale 已提交
1260 1261
}

1262 1263 1264
#define netxen_merge_rx_buffers(list, head) \
	do { list_splice_tail_init(list, head); } while (0);

1265
int
1266
netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
A
Amit S. Kale 已提交
1267
{
1268 1269 1270 1271
	struct netxen_adapter *adapter = sds_ring->adapter;

	struct list_head *cur;

D
Dhananjay Phadke 已提交
1272
	struct status_desc *desc;
1273 1274 1275 1276
	struct netxen_rx_buffer *rxbuf;

	u32 consumer = sds_ring->consumer;

D
Dhananjay Phadke 已提交
1277
	int count = 0;
1278
	u64 sts_data;
1279
	int opcode, ring, index, length, cksum, pkt_offset, desc_cnt;
A
Amit S. Kale 已提交
1280 1281

	while (count < max) {
1282
		desc = &sds_ring->desc_head[consumer];
1283
		sts_data = le64_to_cpu(desc->status_desc_data[0]);
D
Dhananjay Phadke 已提交
1284 1285

		if (!(sts_data & STATUS_OWNER_HOST))
A
Amit S. Kale 已提交
1286
			break;
1287

1288
		desc_cnt = netxen_get_sts_desc_cnt(sts_data);
D
Dhananjay Phadke 已提交
1289
		ring   = netxen_get_sts_type(sts_data);
1290

D
Dhananjay Phadke 已提交
1291
		if (ring > RCV_RING_JUMBO)
1292
			goto skip;
D
Dhananjay Phadke 已提交
1293

1294 1295
		opcode = netxen_get_sts_opcode(sts_data);

1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
		switch (opcode) {
		case NETXEN_NIC_RXPKT_DESC:
		case NETXEN_OLD_RXPKT_DESC:
			break;
		case NETXEN_NIC_RESPONSE_DESC:
			netxen_handle_fw_message(desc_cnt, consumer, sds_ring);
		default:
			goto skip;
		}

		WARN_ON(desc_cnt > 1);

D
Dhananjay Phadke 已提交
1308 1309 1310 1311 1312
		index  = netxen_get_sts_refhandle(sts_data);
		length = netxen_get_sts_totallength(sts_data);
		cksum  = netxen_get_sts_status(sts_data);
		pkt_offset = netxen_get_sts_pkt_offset(sts_data);

1313
		rxbuf = netxen_process_rcv(adapter, ring, index,
A
Amit Kumar Salecha 已提交
1314
				length, cksum, pkt_offset, sds_ring);
1315

1316 1317 1318
		if (rxbuf)
			list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);

1319 1320 1321 1322 1323 1324 1325
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);
		}
A
Amit S. Kale 已提交
1326 1327
		count++;
	}
D
Dhananjay Phadke 已提交
1328

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
	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);
	}
A
Amit S. Kale 已提交
1347 1348

	if (count) {
1349
		sds_ring->consumer = consumer;
1350
		NXWR32(adapter, sds_ring->crb_sts_consumer, consumer);
A
Amit S. Kale 已提交
1351 1352 1353 1354 1355 1356
	}

	return count;
}

/* Process Command status ring */
D
Dhananjay Phadke 已提交
1357
int netxen_process_cmd_ring(struct netxen_adapter *adapter)
A
Amit S. Kale 已提交
1358
{
1359
	u32 sw_consumer, hw_consumer;
1360
	int count = 0, i;
A
Amit S. Kale 已提交
1361
	struct netxen_cmd_buffer *buffer;
1362 1363
	struct pci_dev *pdev = adapter->pdev;
	struct net_device *netdev = adapter->netdev;
A
Amit S. Kale 已提交
1364
	struct netxen_skb_frag *frag;
1365
	int done = 0;
1366
	struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
A
Amit S. Kale 已提交
1367

1368 1369 1370
	if (!spin_trylock(&adapter->tx_clean_lock))
		return 1;

1371 1372
	sw_consumer = tx_ring->sw_consumer;
	hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
A
Amit S. Kale 已提交
1373

1374 1375
	while (sw_consumer != hw_consumer) {
		buffer = &tx_ring->cmd_buf_arr[sw_consumer];
1376 1377
		if (buffer->skb) {
			frag = &buffer->frag_array[0];
A
Amit S. Kale 已提交
1378 1379
			pci_unmap_single(pdev, frag->dma, frag->length,
					 PCI_DMA_TODEVICE);
1380
			frag->dma = 0ULL;
A
Amit S. Kale 已提交
1381 1382 1383 1384
			for (i = 1; i < buffer->frag_count; i++) {
				frag++;	/* Get the next frag */
				pci_unmap_page(pdev, frag->dma, frag->length,
					       PCI_DMA_TODEVICE);
1385
				frag->dma = 0ULL;
A
Amit S. Kale 已提交
1386 1387
			}

1388
			adapter->stats.xmitfinished++;
1389 1390
			dev_kfree_skb_any(buffer->skb);
			buffer->skb = NULL;
A
Amit S. Kale 已提交
1391 1392
		}

1393
		sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
1394 1395
		if (++count >= MAX_STATUS_HANDLE)
			break;
A
Amit S. Kale 已提交
1396 1397
	}

1398
	if (count && netif_running(netdev)) {
1399 1400
		tx_ring->sw_consumer = sw_consumer;

1401
		smp_mb();
1402

1403
		if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
1404
			__netif_tx_lock(tx_ring->txq, smp_processor_id());
1405 1406
			if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
				netif_wake_queue(netdev);
1407
			__netif_tx_unlock(tx_ring->txq);
A
Amit S. Kale 已提交
1408 1409
		}
	}
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
	/*
	 * 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.
	 */
1423 1424
	hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
	done = (sw_consumer == hw_consumer);
1425
	spin_unlock(&adapter->tx_clean_lock);
A
Amit S. Kale 已提交
1426

1427
	return (done);
A
Amit S. Kale 已提交
1428 1429
}

1430
void
1431 1432
netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
	struct nx_host_rds_ring *rds_ring)
A
Amit S. Kale 已提交
1433 1434 1435
{
	struct rcv_desc *pdesc;
	struct netxen_rx_buffer *buffer;
1436
	int producer, count = 0;
1437
	netxen_ctx_msg msg = 0;
1438
	struct list_head *head;
A
Amit S. Kale 已提交
1439

D
Dhananjay Phadke 已提交
1440
	producer = rds_ring->producer;
1441

1442 1443
	spin_lock(&rds_ring->lock);
	head = &rds_ring->free_list;
1444 1445
	while (!list_empty(head)) {

1446
		buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1447

1448 1449 1450
		if (!buffer->skb) {
			if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
				break;
1451 1452 1453
		}

		count++;
1454 1455
		list_del(&buffer->list);

1456
		/* make a rcv descriptor  */
1457
		pdesc = &rds_ring->desc_head[producer];
1458
		pdesc->addr_buffer = cpu_to_le64(buffer->dma);
A
Amit S. Kale 已提交
1459
		pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
D
Dhananjay Phadke 已提交
1460
		pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1461

1462
		producer = get_next_index(producer, rds_ring->num_desc);
1463
	}
1464
	spin_unlock(&rds_ring->lock);
D
Dhananjay Phadke 已提交
1465

1466
	if (count) {
D
Dhananjay Phadke 已提交
1467
		rds_ring->producer = producer;
1468
		NXWR32(adapter, rds_ring->crb_rcv_producer,
1469
				(producer-1) & (rds_ring->num_desc-1));
D
Dhananjay Phadke 已提交
1470 1471

		if (adapter->fw_major < 4) {
1472 1473 1474
			/*
			 * Write a doorbell msg to tell phanmon of change in
			 * receive ring producer
D
Dhananjay Phadke 已提交
1475
			 * Only for firmware version < 4.0.0
1476 1477 1478 1479
			 */
			netxen_set_msg_peg_id(msg, NETXEN_RCV_PEG_DB_ID);
			netxen_set_msg_privid(msg);
			netxen_set_msg_count(msg,
1480 1481
					     ((producer - 1) &
					      (rds_ring->num_desc - 1)));
1482
			netxen_set_msg_ctxid(msg, adapter->portnum);
1483 1484 1485 1486
			netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
			writel(msg,
			       DB_NORMALIZE(adapter,
					    NETXEN_RCV_PRODUCER_OFFSET));
D
Dhananjay Phadke 已提交
1487
		}
1488 1489 1490
	}
}

1491
static void
1492 1493
netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
		struct nx_host_rds_ring *rds_ring)
1494 1495 1496
{
	struct rcv_desc *pdesc;
	struct netxen_rx_buffer *buffer;
1497
	int producer, count = 0;
1498
	struct list_head *head;
1499

D
Dhananjay Phadke 已提交
1500
	producer = rds_ring->producer;
1501 1502 1503
	if (!spin_trylock(&rds_ring->lock))
		return;

1504 1505 1506
	head = &rds_ring->free_list;
	while (!list_empty(head)) {

1507
		buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1508

1509 1510 1511
		if (!buffer->skb) {
			if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
				break;
1512 1513 1514
		}

		count++;
1515 1516
		list_del(&buffer->list);

A
Amit S. Kale 已提交
1517
		/* make a rcv descriptor  */
1518
		pdesc = &rds_ring->desc_head[producer];
A
Amit S. Kale 已提交
1519
		pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
D
Dhananjay Phadke 已提交
1520
		pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
A
Amit S. Kale 已提交
1521
		pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1522

1523
		producer = get_next_index(producer, rds_ring->num_desc);
A
Amit S. Kale 已提交
1524 1525 1526
	}

	if (count) {
D
Dhananjay Phadke 已提交
1527
		rds_ring->producer = producer;
1528
		NXWR32(adapter, rds_ring->crb_rcv_producer,
1529
				(producer - 1) & (rds_ring->num_desc - 1));
A
Amit S. Kale 已提交
1530
	}
1531
	spin_unlock(&rds_ring->lock);
A
Amit S. Kale 已提交
1532 1533 1534 1535 1536
}

void netxen_nic_clear_stats(struct netxen_adapter *adapter)
{
	memset(&adapter->stats, 0, sizeof(adapter->stats));
1537
	return;
A
Amit S. Kale 已提交
1538 1539
}