?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86, UV: Fix for nodes with memory and no cpus
[linux/fpc-iii.git] / drivers / net / netxen / netxen_nic_init.c
blob0759c35f16ac6005416b8986f74f548b1221cbd4
1 /*
2 * Copyright (C) 2003 - 2009 NetXen, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 * MA 02111-1307, USA.
19 *
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
22 *
23 * Contact Information:
24 * info@netxen.com
25 * NetXen Inc,
26 * 18922 Forge Drive
27 * Cupertino, CA 95014-0701
28 *
29 */
30
31 #include <linux/netdevice.h>
32 #include <linux/delay.h>
33 #include "netxen_nic.h"
34 #include "netxen_nic_hw.h"
35 #include "netxen_nic_phan_reg.h"
36
37 struct crb_addr_pair {
38 u32 addr;
39 u32 data;
40 };
41
42 #define NETXEN_MAX_CRB_XFORM 60
43 static unsigned int crb_addr_xform[NETXEN_MAX_CRB_XFORM];
44 #define NETXEN_ADDR_ERROR (0xffffffff)
45
46 #define crb_addr_transform(name) \
47 crb_addr_xform[NETXEN_HW_PX_MAP_CRB_##name] = \
48 NETXEN_HW_CRB_HUB_AGT_ADR_##name << 20
49
50 #define NETXEN_NIC_XDMA_RESET 0x8000ff
51
52 static void
53 netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
54 struct nx_host_rds_ring *rds_ring);
55
56 static void crb_addr_transform_setup(void)
57 {
58 crb_addr_transform(XDMA);
59 crb_addr_transform(TIMR);
60 crb_addr_transform(SRE);
61 crb_addr_transform(SQN3);
62 crb_addr_transform(SQN2);
63 crb_addr_transform(SQN1);
64 crb_addr_transform(SQN0);
65 crb_addr_transform(SQS3);
66 crb_addr_transform(SQS2);
67 crb_addr_transform(SQS1);
68 crb_addr_transform(SQS0);
69 crb_addr_transform(RPMX7);
70 crb_addr_transform(RPMX6);
71 crb_addr_transform(RPMX5);
72 crb_addr_transform(RPMX4);
73 crb_addr_transform(RPMX3);
74 crb_addr_transform(RPMX2);
75 crb_addr_transform(RPMX1);
76 crb_addr_transform(RPMX0);
77 crb_addr_transform(ROMUSB);
78 crb_addr_transform(SN);
79 crb_addr_transform(QMN);
80 crb_addr_transform(QMS);
81 crb_addr_transform(PGNI);
82 crb_addr_transform(PGND);
83 crb_addr_transform(PGN3);
84 crb_addr_transform(PGN2);
85 crb_addr_transform(PGN1);
86 crb_addr_transform(PGN0);
87 crb_addr_transform(PGSI);
88 crb_addr_transform(PGSD);
89 crb_addr_transform(PGS3);
90 crb_addr_transform(PGS2);
91 crb_addr_transform(PGS1);
92 crb_addr_transform(PGS0);
93 crb_addr_transform(PS);
94 crb_addr_transform(PH);
95 crb_addr_transform(NIU);
96 crb_addr_transform(I2Q);
97 crb_addr_transform(EG);
98 crb_addr_transform(MN);
99 crb_addr_transform(MS);
100 crb_addr_transform(CAS2);
101 crb_addr_transform(CAS1);
102 crb_addr_transform(CAS0);
103 crb_addr_transform(CAM);
104 crb_addr_transform(C2C1);
105 crb_addr_transform(C2C0);
106 crb_addr_transform(SMB);
107 crb_addr_transform(OCM0);
108 crb_addr_transform(I2C0);
109 }
110
111 int netxen_init_firmware(struct netxen_adapter *adapter)
112 {
113 u32 state = 0, loops = 0, err = 0;
114
115 /* Window 1 call */
116 state = adapter->pci_read_normalize(adapter, CRB_CMDPEG_STATE);
117
118 if (state == PHAN_INITIALIZE_ACK)
119 return 0;
120
121 while (state != PHAN_INITIALIZE_COMPLETE && loops < 2000) {
122 msleep(1);
123 /* Window 1 call */
124 state = adapter->pci_read_normalize(adapter, CRB_CMDPEG_STATE);
125
126 loops++;
127 }
128 if (loops >= 2000) {
129 printk(KERN_ERR "Cmd Peg initialization not complete:%x.\n",
130 state);
131 err = -EIO;
132 return err;
133 }
134 /* Window 1 call */
135 adapter->pci_write_normalize(adapter,
136 CRB_NIC_CAPABILITIES_HOST, INTR_SCHEME_PERPORT);
137 adapter->pci_write_normalize(adapter,
138 CRB_NIC_MSI_MODE_HOST, MSI_MODE_MULTIFUNC);
139 adapter->pci_write_normalize(adapter,
140 CRB_MPORT_MODE, MPORT_MULTI_FUNCTION_MODE);
141 adapter->pci_write_normalize(adapter,
142 CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
143
144 return err;
145 }
146
147 void netxen_release_rx_buffers(struct netxen_adapter *adapter)
148 {
149 struct netxen_recv_context *recv_ctx;
150 struct nx_host_rds_ring *rds_ring;
151 struct netxen_rx_buffer *rx_buf;
152 int i, ring;
153
154 recv_ctx = &adapter->recv_ctx;
155 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
156 rds_ring = &recv_ctx->rds_rings[ring];
157 for (i = 0; i < rds_ring->num_desc; ++i) {
158 rx_buf = &(rds_ring->rx_buf_arr[i]);
159 if (rx_buf->state == NETXEN_BUFFER_FREE)
160 continue;
161 pci_unmap_single(adapter->pdev,
162 rx_buf->dma,
163 rds_ring->dma_size,
164 PCI_DMA_FROMDEVICE);
165 if (rx_buf->skb != NULL)
166 dev_kfree_skb_any(rx_buf->skb);
167 }
168 }
169 }
170
171 void netxen_release_tx_buffers(struct netxen_adapter *adapter)
172 {
173 struct netxen_cmd_buffer *cmd_buf;
174 struct netxen_skb_frag *buffrag;
175 int i, j;
176
177 cmd_buf = adapter->cmd_buf_arr;
178 for (i = 0; i < adapter->num_txd; i++) {
179 buffrag = cmd_buf->frag_array;
180 if (buffrag->dma) {
181 pci_unmap_single(adapter->pdev, buffrag->dma,
182 buffrag->length, PCI_DMA_TODEVICE);
183 buffrag->dma = 0ULL;
184 }
185 for (j = 0; j < cmd_buf->frag_count; j++) {
186 buffrag++;
187 if (buffrag->dma) {
188 pci_unmap_page(adapter->pdev, buffrag->dma,
189 buffrag->length,
190 PCI_DMA_TODEVICE);
191 buffrag->dma = 0ULL;
192 }
193 }
194 if (cmd_buf->skb) {
195 dev_kfree_skb_any(cmd_buf->skb);
196 cmd_buf->skb = NULL;
197 }
198 cmd_buf++;
199 }
200 }
201
202 void netxen_free_sw_resources(struct netxen_adapter *adapter)
203 {
204 struct netxen_recv_context *recv_ctx;
205 struct nx_host_rds_ring *rds_ring;
206 int ring;
207
208 recv_ctx = &adapter->recv_ctx;
209 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
210 rds_ring = &recv_ctx->rds_rings[ring];
211 if (rds_ring->rx_buf_arr) {
212 vfree(rds_ring->rx_buf_arr);
213 rds_ring->rx_buf_arr = NULL;
214 }
215 }
216
217 if (adapter->cmd_buf_arr)
218 vfree(adapter->cmd_buf_arr);
219 return;
220 }
221
222 int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
223 {
224 struct netxen_recv_context *recv_ctx;
225 struct nx_host_rds_ring *rds_ring;
226 struct nx_host_sds_ring *sds_ring;
227 struct netxen_rx_buffer *rx_buf;
228 int ring, i, num_rx_bufs;
229
230 struct netxen_cmd_buffer *cmd_buf_arr;
231 struct net_device *netdev = adapter->netdev;
232
233 cmd_buf_arr =
234 (struct netxen_cmd_buffer *)vmalloc(TX_BUFF_RINGSIZE(adapter));
235 if (cmd_buf_arr == NULL) {
236 printk(KERN_ERR "%s: Failed to allocate cmd buffer ring\n",
237 netdev->name);
238 return -ENOMEM;
239 }
240 memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(adapter));
241 adapter->cmd_buf_arr = cmd_buf_arr;
242
243 recv_ctx = &adapter->recv_ctx;
244 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
245 rds_ring = &recv_ctx->rds_rings[ring];
246 switch (ring) {
247 case RCV_RING_NORMAL:
248 rds_ring->num_desc = adapter->num_rxd;
249 if (adapter->ahw.cut_through) {
250 rds_ring->dma_size =
251 NX_CT_DEFAULT_RX_BUF_LEN;
252 rds_ring->skb_size =
253 NX_CT_DEFAULT_RX_BUF_LEN;
254 } else {
255 rds_ring->dma_size = RX_DMA_MAP_LEN;
256 rds_ring->skb_size =
257 MAX_RX_BUFFER_LENGTH;
258 }
259 break;
260
261 case RCV_RING_JUMBO:
262 rds_ring->num_desc = adapter->num_jumbo_rxd;
263 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
264 rds_ring->dma_size =
265 NX_P3_RX_JUMBO_BUF_MAX_LEN;
266 else
267 rds_ring->dma_size =
268 NX_P2_RX_JUMBO_BUF_MAX_LEN;
269 rds_ring->skb_size =
270 rds_ring->dma_size + NET_IP_ALIGN;
271 break;
272
273 case RCV_RING_LRO:
274 rds_ring->num_desc = adapter->num_lro_rxd;
275 rds_ring->dma_size = RX_LRO_DMA_MAP_LEN;
276 rds_ring->skb_size = MAX_RX_LRO_BUFFER_LENGTH;
277 break;
278
279 }
280 rds_ring->rx_buf_arr = (struct netxen_rx_buffer *)
281 vmalloc(RCV_BUFF_RINGSIZE(rds_ring));
282 if (rds_ring->rx_buf_arr == NULL) {
283 printk(KERN_ERR "%s: Failed to allocate "
284 "rx buffer ring %d\n",
285 netdev->name, ring);
286 /* free whatever was already allocated */
287 goto err_out;
288 }
289 memset(rds_ring->rx_buf_arr, 0, RCV_BUFF_RINGSIZE(rds_ring));
290 INIT_LIST_HEAD(&rds_ring->free_list);
291 /*
292 * Now go through all of them, set reference handles
293 * and put them in the queues.
294 */
295 num_rx_bufs = rds_ring->num_desc;
296 rx_buf = rds_ring->rx_buf_arr;
297 for (i = 0; i < num_rx_bufs; i++) {
298 list_add_tail(&rx_buf->list,
299 &rds_ring->free_list);
300 rx_buf->ref_handle = i;
301 rx_buf->state = NETXEN_BUFFER_FREE;
302 rx_buf++;
303 }
304 spin_lock_init(&rds_ring->lock);
305 }
306
307 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
308 sds_ring = &recv_ctx->sds_rings[ring];
309 sds_ring->irq = adapter->msix_entries[ring].vector;
310 sds_ring->clean_tx = (ring == 0);
311 sds_ring->post_rxd = (ring == 0);
312 sds_ring->adapter = adapter;
313 sds_ring->num_desc = adapter->num_rxd;
314
315 for (i = 0; i < NUM_RCV_DESC_RINGS; i++)
316 INIT_LIST_HEAD(&sds_ring->free_list[i]);
317 }
318
319 return 0;
320
321 err_out:
322 netxen_free_sw_resources(adapter);
323 return -ENOMEM;
324 }
325
326 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter)
327 {
328 switch (adapter->ahw.port_type) {
329 case NETXEN_NIC_GBE:
330 adapter->enable_phy_interrupts =
331 netxen_niu_gbe_enable_phy_interrupts;
332 adapter->disable_phy_interrupts =
333 netxen_niu_gbe_disable_phy_interrupts;
334 adapter->macaddr_set = netxen_niu_macaddr_set;
335 adapter->set_mtu = netxen_nic_set_mtu_gb;
336 adapter->set_promisc = netxen_niu_set_promiscuous_mode;
337 adapter->phy_read = netxen_niu_gbe_phy_read;
338 adapter->phy_write = netxen_niu_gbe_phy_write;
339 adapter->init_port = netxen_niu_gbe_init_port;
340 adapter->stop_port = netxen_niu_disable_gbe_port;
341 break;
342
343 case NETXEN_NIC_XGBE:
344 adapter->enable_phy_interrupts =
345 netxen_niu_xgbe_enable_phy_interrupts;
346 adapter->disable_phy_interrupts =
347 netxen_niu_xgbe_disable_phy_interrupts;
348 adapter->macaddr_set = netxen_niu_xg_macaddr_set;
349 adapter->set_mtu = netxen_nic_set_mtu_xgb;
350 adapter->init_port = netxen_niu_xg_init_port;
351 adapter->set_promisc = netxen_niu_xg_set_promiscuous_mode;
352 adapter->stop_port = netxen_niu_disable_xg_port;
353 break;
354
355 default:
356 break;
357 }
358
359 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
360 adapter->set_mtu = nx_fw_cmd_set_mtu;
361 adapter->set_promisc = netxen_p3_nic_set_promisc;
362 }
363 }
364
365 /*
366 * netxen_decode_crb_addr(0 - utility to translate from internal Phantom CRB
367 * address to external PCI CRB address.
368 */
369 static u32 netxen_decode_crb_addr(u32 addr)
370 {
371 int i;
372 u32 base_addr, offset, pci_base;
373
374 crb_addr_transform_setup();
375
376 pci_base = NETXEN_ADDR_ERROR;
377 base_addr = addr & 0xfff00000;
378 offset = addr & 0x000fffff;
379
380 for (i = 0; i < NETXEN_MAX_CRB_XFORM; i++) {
381 if (crb_addr_xform[i] == base_addr) {
382 pci_base = i << 20;
383 break;
384 }
385 }
386 if (pci_base == NETXEN_ADDR_ERROR)
387 return pci_base;
388 else
389 return (pci_base + offset);
390 }
391
392 static long rom_max_timeout = 100;
393 static long rom_lock_timeout = 10000;
394
395 static int rom_lock(struct netxen_adapter *adapter)
396 {
397 int iter;
398 u32 done = 0;
399 int timeout = 0;
400
401 while (!done) {
402 /* acquire semaphore2 from PCI HW block */
403 netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_LOCK),
404 &done);
405 if (done == 1)
406 break;
407 if (timeout >= rom_lock_timeout)
408 return -EIO;
409
410 timeout++;
411 /*
412 * Yield CPU
413 */
414 if (!in_atomic())
415 schedule();
416 else {
417 for (iter = 0; iter < 20; iter++)
418 cpu_relax(); /*This a nop instr on i386 */
419 }
420 }
421 netxen_nic_reg_write(adapter, NETXEN_ROM_LOCK_ID, ROM_LOCK_DRIVER);
422 return 0;
423 }
424
425 static int netxen_wait_rom_done(struct netxen_adapter *adapter)
426 {
427 long timeout = 0;
428 long done = 0;
429
430 cond_resched();
431
432 while (done == 0) {
433 done = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_GLB_STATUS);
434 done &= 2;
435 timeout++;
436 if (timeout >= rom_max_timeout) {
437 printk("Timeout reached waiting for rom done");
438 return -EIO;
439 }
440 }
441 return 0;
442 }
443
444 static void netxen_rom_unlock(struct netxen_adapter *adapter)
445 {
446 u32 val;
447
448 /* release semaphore2 */
449 netxen_nic_read_w0(adapter, NETXEN_PCIE_REG(PCIE_SEM2_UNLOCK), &val);
450
451 }
452
453 static int do_rom_fast_read(struct netxen_adapter *adapter,
454 int addr, int *valp)
455 {
456 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
457 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
458 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
459 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
460 if (netxen_wait_rom_done(adapter)) {
461 printk("Error waiting for rom done\n");
462 return -EIO;
463 }
464 /* reset abyte_cnt and dummy_byte_cnt */
465 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
466 udelay(10);
467 netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
468
469 *valp = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_ROM_RDATA);
470 return 0;
471 }
472
473 static int do_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
474 u8 *bytes, size_t size)
475 {
476 int addridx;
477 int ret = 0;
478
479 for (addridx = addr; addridx < (addr + size); addridx += 4) {
480 int v;
481 ret = do_rom_fast_read(adapter, addridx, &v);
482 if (ret != 0)
483 break;
484 *(__le32 *)bytes = cpu_to_le32(v);
485 bytes += 4;
486 }
487
488 return ret;
489 }
490
491 int
492 netxen_rom_fast_read_words(struct netxen_adapter *adapter, int addr,
493 u8 *bytes, size_t size)
494 {
495 int ret;
496
497 ret = rom_lock(adapter);
498 if (ret < 0)
499 return ret;
500
501 ret = do_rom_fast_read_words(adapter, addr, bytes, size);
502
503 netxen_rom_unlock(adapter);
504 return ret;
505 }
506
507 int netxen_rom_fast_read(struct netxen_adapter *adapter, int addr, int *valp)
508 {
509 int ret;
510
511 if (rom_lock(adapter) != 0)
512 return -EIO;
513
514 ret = do_rom_fast_read(adapter, addr, valp);
515 netxen_rom_unlock(adapter);
516 return ret;
517 }
518
519 #define NETXEN_BOARDTYPE 0x4008
520 #define NETXEN_BOARDNUM 0x400c
521 #define NETXEN_CHIPNUM 0x4010
522
523 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
524 {
525 int addr, val;
526 int i, n, init_delay = 0;
527 struct crb_addr_pair *buf;
528 unsigned offset;
529 u32 off;
530
531 /* resetall */
532 rom_lock(adapter);
533 netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
534 0xffffffff);
535 netxen_rom_unlock(adapter);
536
537 if (verbose) {
538 if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
539 printk("P2 ROM board type: 0x%08x\n", val);
540 else
541 printk("Could not read board type\n");
542 if (netxen_rom_fast_read(adapter, NETXEN_BOARDNUM, &val) == 0)
543 printk("P2 ROM board num: 0x%08x\n", val);
544 else
545 printk("Could not read board number\n");
546 if (netxen_rom_fast_read(adapter, NETXEN_CHIPNUM, &val) == 0)
547 printk("P2 ROM chip num: 0x%08x\n", val);
548 else
549 printk("Could not read chip number\n");
550 }
551
552 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
553 if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
554 (n != 0xcafecafe) ||
555 netxen_rom_fast_read(adapter, 4, &n) != 0) {
556 printk(KERN_ERR "%s: ERROR Reading crb_init area: "
557 "n: %08x\n", netxen_nic_driver_name, n);
558 return -EIO;
559 }
560 offset = n & 0xffffU;
561 n = (n >> 16) & 0xffffU;
562 } else {
563 if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
564 !(n & 0x80000000)) {
565 printk(KERN_ERR "%s: ERROR Reading crb_init area: "
566 "n: %08x\n", netxen_nic_driver_name, n);
567 return -EIO;
568 }
569 offset = 1;
570 n &= ~0x80000000;
571 }
572
573 if (n < 1024) {
574 if (verbose)
575 printk(KERN_DEBUG "%s: %d CRB init values found"
576 " in ROM.\n", netxen_nic_driver_name, n);
577 } else {
578 printk(KERN_ERR "%s:n=0x%x Error! NetXen card flash not"
579 " initialized.\n", __func__, n);
580 return -EIO;
581 }
582
583 buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
584 if (buf == NULL) {
585 printk("%s: netxen_pinit_from_rom: Unable to calloc memory.\n",
586 netxen_nic_driver_name);
587 return -ENOMEM;
588 }
589 for (i = 0; i < n; i++) {
590 if (netxen_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
591 netxen_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
592 kfree(buf);
593 return -EIO;
594 }
595
596 buf[i].addr = addr;
597 buf[i].data = val;
598
599 if (verbose)
600 printk(KERN_DEBUG "%s: PCI: 0x%08x == 0x%08x\n",
601 netxen_nic_driver_name,
602 (u32)netxen_decode_crb_addr(addr), val);
603 }
604 for (i = 0; i < n; i++) {
605
606 off = netxen_decode_crb_addr(buf[i].addr);
607 if (off == NETXEN_ADDR_ERROR) {
608 printk(KERN_ERR"CRB init value out of range %x\n",
609 buf[i].addr);
610 continue;
611 }
612 off += NETXEN_PCI_CRBSPACE;
613 /* skipping cold reboot MAGIC */
614 if (off == NETXEN_CAM_RAM(0x1fc))
615 continue;
616
617 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
618 /* do not reset PCI */
619 if (off == (ROMUSB_GLB + 0xbc))
620 continue;
621 if (off == (ROMUSB_GLB + 0xa8))
622 continue;
623 if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
624 continue;
625 if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
626 continue;
627 if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
628 continue;
629 if (off == (NETXEN_CRB_PEG_NET_1 + 0x18))
630 buf[i].data = 0x1020;
631 /* skip the function enable register */
632 if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION))
633 continue;
634 if (off == NETXEN_PCIE_REG(PCIE_SETUP_FUNCTION2))
635 continue;
636 if ((off & 0x0ff00000) == NETXEN_CRB_SMB)
637 continue;
638 }
639
640 if (off == NETXEN_ADDR_ERROR) {
641 printk(KERN_ERR "%s: Err: Unknown addr: 0x%08x\n",
642 netxen_nic_driver_name, buf[i].addr);
643 continue;
644 }
645
646 init_delay = 1;
647 /* After writing this register, HW needs time for CRB */
648 /* to quiet down (else crb_window returns 0xffffffff) */
649 if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
650 init_delay = 1000;
651 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
652 /* hold xdma in reset also */
653 buf[i].data = NETXEN_NIC_XDMA_RESET;
654 buf[i].data = 0x8000ff;
655 }
656 }
657
658 adapter->hw_write_wx(adapter, off, &buf[i].data, 4);
659
660 msleep(init_delay);
661 }
662 kfree(buf);
663
664 /* disable_peg_cache_all */
665
666 /* unreset_net_cache */
667 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
668 adapter->hw_read_wx(adapter,
669 NETXEN_ROMUSB_GLB_SW_RESET, &val, 4);
670 netxen_crb_writelit_adapter(adapter,
671 NETXEN_ROMUSB_GLB_SW_RESET, (val & 0xffffff0f));
672 }
673
674 /* p2dn replyCount */
675 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_D + 0xec, 0x1e);
676 /* disable_peg_cache 0 */
677 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_D + 0x4c, 8);
678 /* disable_peg_cache 1 */
679 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_I + 0x4c, 8);
680
681 /* peg_clr_all */
682
683 /* peg_clr 0 */
684 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0x8, 0);
685 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_0 + 0xc, 0);
686 /* peg_clr 1 */
687 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0x8, 0);
688 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_1 + 0xc, 0);
689 /* peg_clr 2 */
690 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0x8, 0);
691 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_2 + 0xc, 0);
692 /* peg_clr 3 */
693 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0x8, 0);
694 netxen_crb_writelit_adapter(adapter, NETXEN_CRB_PEG_NET_3 + 0xc, 0);
695 return 0;
696 }
697
698 int netxen_initialize_adapter_offload(struct netxen_adapter *adapter)
699 {
700 uint64_t addr;
701 uint32_t hi;
702 uint32_t lo;
703
704 adapter->dummy_dma.addr =
705 pci_alloc_consistent(adapter->pdev,
706 NETXEN_HOST_DUMMY_DMA_SIZE,
707 &adapter->dummy_dma.phys_addr);
708 if (adapter->dummy_dma.addr == NULL) {
709 printk("%s: ERROR: Could not allocate dummy DMA memory\n",
710 __func__);
711 return -ENOMEM;
712 }
713
714 addr = (uint64_t) adapter->dummy_dma.phys_addr;
715 hi = (addr >> 32) & 0xffffffff;
716 lo = addr & 0xffffffff;
717
718 adapter->pci_write_normalize(adapter, CRB_HOST_DUMMY_BUF_ADDR_HI, hi);
719 adapter->pci_write_normalize(adapter, CRB_HOST_DUMMY_BUF_ADDR_LO, lo);
720
721 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
722 uint32_t temp = 0;
723 adapter->hw_write_wx(adapter, CRB_HOST_DUMMY_BUF, &temp, 4);
724 }
725
726 return 0;
727 }
728
729 void netxen_free_adapter_offload(struct netxen_adapter *adapter)
730 {
731 int i = 100;
732
733 if (!adapter->dummy_dma.addr)
734 return;
735
736 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
737 do {
738 if (dma_watchdog_shutdown_request(adapter) == 1)
739 break;
740 msleep(50);
741 if (dma_watchdog_shutdown_poll_result(adapter) == 1)
742 break;
743 } while (--i);
744 }
745
746 if (i) {
747 pci_free_consistent(adapter->pdev,
748 NETXEN_HOST_DUMMY_DMA_SIZE,
749 adapter->dummy_dma.addr,
750 adapter->dummy_dma.phys_addr);
751 adapter->dummy_dma.addr = NULL;
752 } else {
753 printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
754 adapter->netdev->name);
755 }
756 }
757
758 int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
759 {
760 u32 val = 0;
761 int retries = 60;
762
763 if (!pegtune_val) {
764 do {
765 val = adapter->pci_read_normalize(adapter,
766 CRB_CMDPEG_STATE);
767
768 if (val == PHAN_INITIALIZE_COMPLETE ||
769 val == PHAN_INITIALIZE_ACK)
770 return 0;
771
772 msleep(500);
773
774 } while (--retries);
775
776 if (!retries) {
777 pegtune_val = adapter->pci_read_normalize(adapter,
778 NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
779 printk(KERN_WARNING "netxen_phantom_init: init failed, "
780 "pegtune_val=%x\n", pegtune_val);
781 return -1;
782 }
783 }
784
785 return 0;
786 }
787
788 int netxen_receive_peg_ready(struct netxen_adapter *adapter)
789 {
790 u32 val = 0;
791 int retries = 2000;
792
793 do {
794 val = adapter->pci_read_normalize(adapter, CRB_RCVPEG_STATE);
795
796 if (val == PHAN_PEG_RCV_INITIALIZED)
797 return 0;
798
799 msleep(10);
800
801 } while (--retries);
802
803 if (!retries) {
804 printk(KERN_ERR "Receive Peg initialization not "
805 "complete, state: 0x%x.\n", val);
806 return -EIO;
807 }
808
809 return 0;
810 }
811
812 static int
813 netxen_alloc_rx_skb(struct netxen_adapter *adapter,
814 struct nx_host_rds_ring *rds_ring,
815 struct netxen_rx_buffer *buffer)
816 {
817 struct sk_buff *skb;
818 dma_addr_t dma;
819 struct pci_dev *pdev = adapter->pdev;
820
821 buffer->skb = dev_alloc_skb(rds_ring->skb_size);
822 if (!buffer->skb)
823 return 1;
824
825 skb = buffer->skb;
826
827 if (!adapter->ahw.cut_through)
828 skb_reserve(skb, 2);
829
830 dma = pci_map_single(pdev, skb->data,
831 rds_ring->dma_size, PCI_DMA_FROMDEVICE);
832
833 if (pci_dma_mapping_error(pdev, dma)) {
834 dev_kfree_skb_any(skb);
835 buffer->skb = NULL;
836 return 1;
837 }
838
839 buffer->skb = skb;
840 buffer->dma = dma;
841 buffer->state = NETXEN_BUFFER_BUSY;
842
843 return 0;
844 }
845
846 static struct sk_buff *netxen_process_rxbuf(struct netxen_adapter *adapter,
847 struct nx_host_rds_ring *rds_ring, u16 index, u16 cksum)
848 {
849 struct netxen_rx_buffer *buffer;
850 struct sk_buff *skb;
851
852 buffer = &rds_ring->rx_buf_arr[index];
853
854 pci_unmap_single(adapter->pdev, buffer->dma, rds_ring->dma_size,
855 PCI_DMA_FROMDEVICE);
856
857 skb = buffer->skb;
858 if (!skb)
859 goto no_skb;
860
861 if (likely(adapter->rx_csum && cksum == STATUS_CKSUM_OK)) {
862 adapter->stats.csummed++;
863 skb->ip_summed = CHECKSUM_UNNECESSARY;
864 } else
865 skb->ip_summed = CHECKSUM_NONE;
866
867 skb->dev = adapter->netdev;
868
869 buffer->skb = NULL;
870 no_skb:
871 buffer->state = NETXEN_BUFFER_FREE;
872 return skb;
873 }
874
875 static struct netxen_rx_buffer *
876 netxen_process_rcv(struct netxen_adapter *adapter,
877 int ring, int index, int length, int cksum, int pkt_offset)
878 {
879 struct net_device *netdev = adapter->netdev;
880 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
881 struct netxen_rx_buffer *buffer;
882 struct sk_buff *skb;
883 struct nx_host_rds_ring *rds_ring = &recv_ctx->rds_rings[ring];
884
885 if (unlikely(index > rds_ring->num_desc))
886 return NULL;
887
888 buffer = &rds_ring->rx_buf_arr[index];
889
890 skb = netxen_process_rxbuf(adapter, rds_ring, index, cksum);
891 if (!skb)
892 return buffer;
893
894 if (length > rds_ring->skb_size)
895 skb_put(skb, rds_ring->skb_size);
896 else
897 skb_put(skb, length);
898
899
900 if (pkt_offset)
901 skb_pull(skb, pkt_offset);
902
903 skb->protocol = eth_type_trans(skb, netdev);
904
905 netif_receive_skb(skb);
906
907 adapter->stats.no_rcv++;
908 adapter->stats.rxbytes += length;
909
910 return buffer;
911 }
912
913 #define netxen_merge_rx_buffers(list, head) \
914 do { list_splice_tail_init(list, head); } while (0);
915
916 int
917 netxen_process_rcv_ring(struct nx_host_sds_ring *sds_ring, int max)
918 {
919 struct netxen_adapter *adapter = sds_ring->adapter;
920
921 struct list_head *cur;
922
923 struct status_desc *desc;
924 struct netxen_rx_buffer *rxbuf;
925
926 u32 consumer = sds_ring->consumer;
927
928 int count = 0;
929 u64 sts_data;
930 int opcode, ring, index, length, cksum, pkt_offset;
931
932 while (count < max) {
933 desc = &sds_ring->desc_head[consumer];
934 sts_data = le64_to_cpu(desc->status_desc_data);
935
936 if (!(sts_data & STATUS_OWNER_HOST))
937 break;
938
939 ring = netxen_get_sts_type(sts_data);
940 if (ring > RCV_RING_JUMBO)
941 continue;
942
943 opcode = netxen_get_sts_opcode(sts_data);
944
945 index = netxen_get_sts_refhandle(sts_data);
946 length = netxen_get_sts_totallength(sts_data);
947 cksum = netxen_get_sts_status(sts_data);
948 pkt_offset = netxen_get_sts_pkt_offset(sts_data);
949
950 rxbuf = netxen_process_rcv(adapter, ring, index,
951 length, cksum, pkt_offset);
952
953 if (rxbuf)
954 list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
955
956 desc->status_desc_data = cpu_to_le64(STATUS_OWNER_PHANTOM);
957
958 consumer = get_next_index(consumer, sds_ring->num_desc);
959 count++;
960 }
961
962 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
963 struct nx_host_rds_ring *rds_ring =
964 &adapter->recv_ctx.rds_rings[ring];
965
966 if (!list_empty(&sds_ring->free_list[ring])) {
967 list_for_each(cur, &sds_ring->free_list[ring]) {
968 rxbuf = list_entry(cur,
969 struct netxen_rx_buffer, list);
970 netxen_alloc_rx_skb(adapter, rds_ring, rxbuf);
971 }
972 spin_lock(&rds_ring->lock);
973 netxen_merge_rx_buffers(&sds_ring->free_list[ring],
974 &rds_ring->free_list);
975 spin_unlock(&rds_ring->lock);
976 }
977
978 netxen_post_rx_buffers_nodb(adapter, rds_ring);
979 }
980
981 if (count) {
982 sds_ring->consumer = consumer;
983 adapter->pci_write_normalize(adapter,
984 sds_ring->crb_sts_consumer, consumer);
985 }
986
987 return count;
988 }
989
990 /* Process Command status ring */
991 int netxen_process_cmd_ring(struct netxen_adapter *adapter)
992 {
993 u32 last_consumer, consumer;
994 int count = 0, i;
995 struct netxen_cmd_buffer *buffer;
996 struct pci_dev *pdev = adapter->pdev;
997 struct net_device *netdev = adapter->netdev;
998 struct netxen_skb_frag *frag;
999 int done = 0;
1000
1001 if (!spin_trylock(&adapter->tx_clean_lock))
1002 return 1;
1003
1004 last_consumer = adapter->last_cmd_consumer;
1005 barrier(); /* cmd_consumer can change underneath */
1006 consumer = le32_to_cpu(*(adapter->cmd_consumer));
1007
1008 while (last_consumer != consumer) {
1009 buffer = &adapter->cmd_buf_arr[last_consumer];
1010 if (buffer->skb) {
1011 frag = &buffer->frag_array[0];
1012 pci_unmap_single(pdev, frag->dma, frag->length,
1013 PCI_DMA_TODEVICE);
1014 frag->dma = 0ULL;
1015 for (i = 1; i < buffer->frag_count; i++) {
1016 frag++; /* Get the next frag */
1017 pci_unmap_page(pdev, frag->dma, frag->length,
1018 PCI_DMA_TODEVICE);
1019 frag->dma = 0ULL;
1020 }
1021
1022 adapter->stats.xmitfinished++;
1023 dev_kfree_skb_any(buffer->skb);
1024 buffer->skb = NULL;
1025 }
1026
1027 last_consumer = get_next_index(last_consumer,
1028 adapter->num_txd);
1029 if (++count >= MAX_STATUS_HANDLE)
1030 break;
1031 }
1032
1033 if (count) {
1034 adapter->last_cmd_consumer = last_consumer;
1035 smp_mb();
1036 if (netif_queue_stopped(netdev) && netif_running(netdev)) {
1037 netif_tx_lock(netdev);
1038 netif_wake_queue(netdev);
1039 smp_mb();
1040 netif_tx_unlock(netdev);
1041 }
1042 }
1043 /*
1044 * If everything is freed up to consumer then check if the ring is full
1045 * If the ring is full then check if more needs to be freed and
1046 * schedule the call back again.
1047 *
1048 * This happens when there are 2 CPUs. One could be freeing and the
1049 * other filling it. If the ring is full when we get out of here and
1050 * the card has already interrupted the host then the host can miss the
1051 * interrupt.
1052 *
1053 * There is still a possible race condition and the host could miss an
1054 * interrupt. The card has to take care of this.
1055 */
1056 barrier(); /* cmd_consumer can change underneath */
1057 consumer = le32_to_cpu(*(adapter->cmd_consumer));
1058 done = (last_consumer == consumer);
1059 spin_unlock(&adapter->tx_clean_lock);
1060
1061 return (done);
1062 }
1063
1064 void
1065 netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ringid,
1066 struct nx_host_rds_ring *rds_ring)
1067 {
1068 struct rcv_desc *pdesc;
1069 struct netxen_rx_buffer *buffer;
1070 int producer, count = 0;
1071 netxen_ctx_msg msg = 0;
1072 struct list_head *head;
1073
1074 producer = rds_ring->producer;
1075
1076 spin_lock(&rds_ring->lock);
1077 head = &rds_ring->free_list;
1078 while (!list_empty(head)) {
1079
1080 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1081
1082 if (!buffer->skb) {
1083 if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
1084 break;
1085 }
1086
1087 count++;
1088 list_del(&buffer->list);
1089
1090 /* make a rcv descriptor */
1091 pdesc = &rds_ring->desc_head[producer];
1092 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1093 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1094 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1095
1096 producer = get_next_index(producer, rds_ring->num_desc);
1097 }
1098 spin_unlock(&rds_ring->lock);
1099
1100 if (count) {
1101 rds_ring->producer = producer;
1102 adapter->pci_write_normalize(adapter,
1103 rds_ring->crb_rcv_producer,
1104 (producer-1) & (rds_ring->num_desc-1));
1105
1106 if (adapter->fw_major < 4) {
1107 /*
1108 * Write a doorbell msg to tell phanmon of change in
1109 * receive ring producer
1110 * Only for firmware version < 4.0.0
1111 */
1112 netxen_set_msg_peg_id(msg, NETXEN_RCV_PEG_DB_ID);
1113 netxen_set_msg_privid(msg);
1114 netxen_set_msg_count(msg,
1115 ((producer - 1) &
1116 (rds_ring->num_desc - 1)));
1117 netxen_set_msg_ctxid(msg, adapter->portnum);
1118 netxen_set_msg_opcode(msg, NETXEN_RCV_PRODUCER(ringid));
1119 writel(msg,
1120 DB_NORMALIZE(adapter,
1121 NETXEN_RCV_PRODUCER_OFFSET));
1122 }
1123 }
1124 }
1125
1126 static void
1127 netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
1128 struct nx_host_rds_ring *rds_ring)
1129 {
1130 struct rcv_desc *pdesc;
1131 struct netxen_rx_buffer *buffer;
1132 int producer, count = 0;
1133 struct list_head *head;
1134
1135 producer = rds_ring->producer;
1136 if (!spin_trylock(&rds_ring->lock))
1137 return;
1138
1139 head = &rds_ring->free_list;
1140 while (!list_empty(head)) {
1141
1142 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
1143
1144 if (!buffer->skb) {
1145 if (netxen_alloc_rx_skb(adapter, rds_ring, buffer))
1146 break;
1147 }
1148
1149 count++;
1150 list_del(&buffer->list);
1151
1152 /* make a rcv descriptor */
1153 pdesc = &rds_ring->desc_head[producer];
1154 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1155 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1156 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1157
1158 producer = get_next_index(producer, rds_ring->num_desc);
1159 }
1160
1161 if (count) {
1162 rds_ring->producer = producer;
1163 adapter->pci_write_normalize(adapter,
1164 rds_ring->crb_rcv_producer,
1165 (producer - 1) & (rds_ring->num_desc - 1));
1166 wmb();
1167 }
1168 spin_unlock(&rds_ring->lock);
1169 }
1170
1171 void netxen_nic_clear_stats(struct netxen_adapter *adapter)
1172 {
1173 memset(&adapter->stats, 0, sizeof(adapter->stats));
1174 return;
1175 }
1176
Linux with added FPC-III support