2 * Copyright (C) 2003 - 2009 NetXen, Inc.
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.
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.
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,
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
23 * Contact Information:
27 * Cupertino, CA 95014-0701
31 #include "netxen_nic_hw.h"
32 #include "netxen_nic.h"
34 #define NXHAL_VERSION 1
37 netxen_api_lock(struct netxen_adapter
*adapter
)
39 u32 done
= 0, timeout
= 0;
42 /* Acquire PCIE HW semaphore5 */
43 done
= NXRD32(adapter
, NETXEN_PCIE_REG(PCIE_SEM5_LOCK
));
48 if (++timeout
>= NX_OS_CRB_RETRY_COUNT
) {
49 printk(KERN_ERR
"%s: lock timeout.\n", __func__
);
58 NETXEN_API_LOCK_ID
, NX_OS_API_LOCK_DRIVER
);
64 netxen_api_unlock(struct netxen_adapter
*adapter
)
66 /* Release PCIE HW semaphore5 */
67 NXRD32(adapter
, NETXEN_PCIE_REG(PCIE_SEM5_UNLOCK
));
72 netxen_poll_rsp(struct netxen_adapter
*adapter
)
74 u32 rsp
= NX_CDRP_RSP_OK
;
78 /* give atleast 1ms for firmware to respond */
81 if (++timeout
> NX_OS_CRB_RETRY_COUNT
)
82 return NX_CDRP_RSP_TIMEOUT
;
84 rsp
= NXRD32(adapter
, NX_CDRP_CRB_OFFSET
);
85 } while (!NX_CDRP_IS_RSP(rsp
));
91 netxen_issue_cmd(struct netxen_adapter
*adapter
,
92 u32 pci_fn
, u32 version
, u32 arg1
, u32 arg2
, u32 arg3
, u32 cmd
)
96 u32 rcode
= NX_RCODE_SUCCESS
;
98 signature
= NX_CDRP_SIGNATURE_MAKE(pci_fn
, version
);
100 /* Acquire semaphore before accessing CRB */
101 if (netxen_api_lock(adapter
))
102 return NX_RCODE_TIMEOUT
;
104 NXWR32(adapter
, NX_SIGN_CRB_OFFSET
, signature
);
106 NXWR32(adapter
, NX_ARG1_CRB_OFFSET
, arg1
);
108 NXWR32(adapter
, NX_ARG2_CRB_OFFSET
, arg2
);
110 NXWR32(adapter
, NX_ARG3_CRB_OFFSET
, arg3
);
112 NXWR32(adapter
, NX_CDRP_CRB_OFFSET
, NX_CDRP_FORM_CMD(cmd
));
114 rsp
= netxen_poll_rsp(adapter
);
116 if (rsp
== NX_CDRP_RSP_TIMEOUT
) {
117 printk(KERN_ERR
"%s: card response timeout.\n",
118 netxen_nic_driver_name
);
120 rcode
= NX_RCODE_TIMEOUT
;
121 } else if (rsp
== NX_CDRP_RSP_FAIL
) {
122 rcode
= NXRD32(adapter
, NX_ARG1_CRB_OFFSET
);
124 printk(KERN_ERR
"%s: failed card response code:0x%x\n",
125 netxen_nic_driver_name
, rcode
);
128 /* Release semaphore */
129 netxen_api_unlock(adapter
);
135 nx_fw_cmd_set_mtu(struct netxen_adapter
*adapter
, int mtu
)
137 u32 rcode
= NX_RCODE_SUCCESS
;
138 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
140 if (recv_ctx
->state
== NX_HOST_CTX_STATE_ACTIVE
)
141 rcode
= netxen_issue_cmd(adapter
,
142 adapter
->ahw
.pci_func
,
144 recv_ctx
->context_id
,
147 NX_CDRP_CMD_SET_MTU
);
149 if (rcode
!= NX_RCODE_SUCCESS
)
156 nx_fw_cmd_create_rx_ctx(struct netxen_adapter
*adapter
)
159 nx_hostrq_rx_ctx_t
*prq
;
160 nx_cardrsp_rx_ctx_t
*prsp
;
161 nx_hostrq_rds_ring_t
*prq_rds
;
162 nx_hostrq_sds_ring_t
*prq_sds
;
163 nx_cardrsp_rds_ring_t
*prsp_rds
;
164 nx_cardrsp_sds_ring_t
*prsp_sds
;
165 struct nx_host_rds_ring
*rds_ring
;
166 struct nx_host_sds_ring
*sds_ring
;
168 dma_addr_t hostrq_phys_addr
, cardrsp_phys_addr
;
171 int i
, nrds_rings
, nsds_rings
;
172 size_t rq_size
, rsp_size
;
177 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
179 nrds_rings
= adapter
->max_rds_rings
;
180 nsds_rings
= adapter
->max_sds_rings
;
183 SIZEOF_HOSTRQ_RX(nx_hostrq_rx_ctx_t
, nrds_rings
, nsds_rings
);
185 SIZEOF_CARDRSP_RX(nx_cardrsp_rx_ctx_t
, nrds_rings
, nsds_rings
);
187 addr
= pci_alloc_consistent(adapter
->pdev
,
188 rq_size
, &hostrq_phys_addr
);
191 prq
= (nx_hostrq_rx_ctx_t
*)addr
;
193 addr
= pci_alloc_consistent(adapter
->pdev
,
194 rsp_size
, &cardrsp_phys_addr
);
199 prsp
= (nx_cardrsp_rx_ctx_t
*)addr
;
201 prq
->host_rsp_dma_addr
= cpu_to_le64(cardrsp_phys_addr
);
203 cap
= (NX_CAP0_LEGACY_CONTEXT
| NX_CAP0_LEGACY_MN
);
204 cap
|= (NX_CAP0_JUMBO_CONTIGUOUS
| NX_CAP0_LRO_CONTIGUOUS
);
206 prq
->capabilities
[0] = cpu_to_le32(cap
);
207 prq
->host_int_crb_mode
=
208 cpu_to_le32(NX_HOST_INT_CRB_MODE_SHARED
);
209 prq
->host_rds_crb_mode
=
210 cpu_to_le32(NX_HOST_RDS_CRB_MODE_UNIQUE
);
212 prq
->num_rds_rings
= cpu_to_le16(nrds_rings
);
213 prq
->num_sds_rings
= cpu_to_le16(nsds_rings
);
214 prq
->rds_ring_offset
= cpu_to_le32(0);
216 val
= le32_to_cpu(prq
->rds_ring_offset
) +
217 (sizeof(nx_hostrq_rds_ring_t
) * nrds_rings
);
218 prq
->sds_ring_offset
= cpu_to_le32(val
);
220 prq_rds
= (nx_hostrq_rds_ring_t
*)(prq
->data
+
221 le32_to_cpu(prq
->rds_ring_offset
));
223 for (i
= 0; i
< nrds_rings
; i
++) {
225 rds_ring
= &recv_ctx
->rds_rings
[i
];
227 prq_rds
[i
].host_phys_addr
= cpu_to_le64(rds_ring
->phys_addr
);
228 prq_rds
[i
].ring_size
= cpu_to_le32(rds_ring
->num_desc
);
229 prq_rds
[i
].ring_kind
= cpu_to_le32(i
);
230 prq_rds
[i
].buff_size
= cpu_to_le64(rds_ring
->dma_size
);
233 prq_sds
= (nx_hostrq_sds_ring_t
*)(prq
->data
+
234 le32_to_cpu(prq
->sds_ring_offset
));
236 for (i
= 0; i
< nsds_rings
; i
++) {
238 sds_ring
= &recv_ctx
->sds_rings
[i
];
240 prq_sds
[i
].host_phys_addr
= cpu_to_le64(sds_ring
->phys_addr
);
241 prq_sds
[i
].ring_size
= cpu_to_le32(sds_ring
->num_desc
);
242 prq_sds
[i
].msi_index
= cpu_to_le16(i
);
245 phys_addr
= hostrq_phys_addr
;
246 err
= netxen_issue_cmd(adapter
,
247 adapter
->ahw
.pci_func
,
249 (u32
)(phys_addr
>> 32),
250 (u32
)(phys_addr
& 0xffffffff),
252 NX_CDRP_CMD_CREATE_RX_CTX
);
255 "Failed to create rx ctx in firmware%d\n", err
);
260 prsp_rds
= ((nx_cardrsp_rds_ring_t
*)
261 &prsp
->data
[le32_to_cpu(prsp
->rds_ring_offset
)]);
263 for (i
= 0; i
< le16_to_cpu(prsp
->num_rds_rings
); i
++) {
264 rds_ring
= &recv_ctx
->rds_rings
[i
];
266 reg
= le32_to_cpu(prsp_rds
[i
].host_producer_crb
);
267 rds_ring
->crb_rcv_producer
= NETXEN_NIC_REG(reg
- 0x200);
270 prsp_sds
= ((nx_cardrsp_sds_ring_t
*)
271 &prsp
->data
[le32_to_cpu(prsp
->sds_ring_offset
)]);
273 for (i
= 0; i
< le16_to_cpu(prsp
->num_sds_rings
); i
++) {
274 sds_ring
= &recv_ctx
->sds_rings
[i
];
276 reg
= le32_to_cpu(prsp_sds
[i
].host_consumer_crb
);
277 sds_ring
->crb_sts_consumer
= NETXEN_NIC_REG(reg
- 0x200);
279 reg
= le32_to_cpu(prsp_sds
[i
].interrupt_crb
);
280 sds_ring
->crb_intr_mask
= NETXEN_NIC_REG(reg
- 0x200);
283 recv_ctx
->state
= le32_to_cpu(prsp
->host_ctx_state
);
284 recv_ctx
->context_id
= le16_to_cpu(prsp
->context_id
);
285 recv_ctx
->virt_port
= prsp
->virt_port
;
288 pci_free_consistent(adapter
->pdev
, rsp_size
, prsp
, cardrsp_phys_addr
);
290 pci_free_consistent(adapter
->pdev
, rq_size
, prq
, hostrq_phys_addr
);
295 nx_fw_cmd_destroy_rx_ctx(struct netxen_adapter
*adapter
)
297 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
299 if (netxen_issue_cmd(adapter
,
300 adapter
->ahw
.pci_func
,
302 recv_ctx
->context_id
,
303 NX_DESTROY_CTX_RESET
,
305 NX_CDRP_CMD_DESTROY_RX_CTX
)) {
308 "%s: Failed to destroy rx ctx in firmware\n",
309 netxen_nic_driver_name
);
314 nx_fw_cmd_create_tx_ctx(struct netxen_adapter
*adapter
)
316 nx_hostrq_tx_ctx_t
*prq
;
317 nx_hostrq_cds_ring_t
*prq_cds
;
318 nx_cardrsp_tx_ctx_t
*prsp
;
319 void *rq_addr
, *rsp_addr
;
320 size_t rq_size
, rsp_size
;
323 u64 offset
, phys_addr
;
324 dma_addr_t rq_phys_addr
, rsp_phys_addr
;
325 struct nx_host_tx_ring
*tx_ring
= adapter
->tx_ring
;
326 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
328 rq_size
= SIZEOF_HOSTRQ_TX(nx_hostrq_tx_ctx_t
);
329 rq_addr
= pci_alloc_consistent(adapter
->pdev
,
330 rq_size
, &rq_phys_addr
);
334 rsp_size
= SIZEOF_CARDRSP_TX(nx_cardrsp_tx_ctx_t
);
335 rsp_addr
= pci_alloc_consistent(adapter
->pdev
,
336 rsp_size
, &rsp_phys_addr
);
342 memset(rq_addr
, 0, rq_size
);
343 prq
= (nx_hostrq_tx_ctx_t
*)rq_addr
;
345 memset(rsp_addr
, 0, rsp_size
);
346 prsp
= (nx_cardrsp_tx_ctx_t
*)rsp_addr
;
348 prq
->host_rsp_dma_addr
= cpu_to_le64(rsp_phys_addr
);
350 temp
= (NX_CAP0_LEGACY_CONTEXT
| NX_CAP0_LEGACY_MN
| NX_CAP0_LSO
);
351 prq
->capabilities
[0] = cpu_to_le32(temp
);
353 prq
->host_int_crb_mode
=
354 cpu_to_le32(NX_HOST_INT_CRB_MODE_SHARED
);
356 prq
->interrupt_ctl
= 0;
359 prq
->dummy_dma_addr
= cpu_to_le64(adapter
->dummy_dma
.phys_addr
);
361 offset
= recv_ctx
->phys_addr
+ sizeof(struct netxen_ring_ctx
);
362 prq
->cmd_cons_dma_addr
= cpu_to_le64(offset
);
364 prq_cds
= &prq
->cds_ring
;
366 prq_cds
->host_phys_addr
= cpu_to_le64(tx_ring
->phys_addr
);
367 prq_cds
->ring_size
= cpu_to_le32(tx_ring
->num_desc
);
369 phys_addr
= rq_phys_addr
;
370 err
= netxen_issue_cmd(adapter
,
371 adapter
->ahw
.pci_func
,
373 (u32
)(phys_addr
>> 32),
374 ((u32
)phys_addr
& 0xffffffff),
376 NX_CDRP_CMD_CREATE_TX_CTX
);
378 if (err
== NX_RCODE_SUCCESS
) {
379 temp
= le32_to_cpu(prsp
->cds_ring
.host_producer_crb
);
380 tx_ring
->crb_cmd_producer
= NETXEN_NIC_REG(temp
- 0x200);
383 le32_to_cpu(prsp
->host_ctx_state
);
385 adapter
->tx_context_id
=
386 le16_to_cpu(prsp
->context_id
);
389 "Failed to create tx ctx in firmware%d\n", err
);
393 pci_free_consistent(adapter
->pdev
, rsp_size
, rsp_addr
, rsp_phys_addr
);
396 pci_free_consistent(adapter
->pdev
, rq_size
, rq_addr
, rq_phys_addr
);
402 nx_fw_cmd_destroy_tx_ctx(struct netxen_adapter
*adapter
)
404 if (netxen_issue_cmd(adapter
,
405 adapter
->ahw
.pci_func
,
407 adapter
->tx_context_id
,
408 NX_DESTROY_CTX_RESET
,
410 NX_CDRP_CMD_DESTROY_TX_CTX
)) {
413 "%s: Failed to destroy tx ctx in firmware\n",
414 netxen_nic_driver_name
);
418 static u64 ctx_addr_sig_regs
[][3] = {
419 {NETXEN_NIC_REG(0x188), NETXEN_NIC_REG(0x18c), NETXEN_NIC_REG(0x1c0)},
420 {NETXEN_NIC_REG(0x190), NETXEN_NIC_REG(0x194), NETXEN_NIC_REG(0x1c4)},
421 {NETXEN_NIC_REG(0x198), NETXEN_NIC_REG(0x19c), NETXEN_NIC_REG(0x1c8)},
422 {NETXEN_NIC_REG(0x1a0), NETXEN_NIC_REG(0x1a4), NETXEN_NIC_REG(0x1cc)}
425 #define CRB_CTX_ADDR_REG_LO(FUNC_ID) (ctx_addr_sig_regs[FUNC_ID][0])
426 #define CRB_CTX_ADDR_REG_HI(FUNC_ID) (ctx_addr_sig_regs[FUNC_ID][2])
427 #define CRB_CTX_SIGNATURE_REG(FUNC_ID) (ctx_addr_sig_regs[FUNC_ID][1])
429 #define lower32(x) ((u32)((x) & 0xffffffff))
430 #define upper32(x) ((u32)(((u64)(x) >> 32) & 0xffffffff))
432 static struct netxen_recv_crb recv_crb_registers
[] = {
435 /* crb_rcv_producer: */
437 NETXEN_NIC_REG(0x100),
439 NETXEN_NIC_REG(0x110),
441 NETXEN_NIC_REG(0x120)
443 /* crb_sts_consumer: */
445 NETXEN_NIC_REG(0x138),
446 NETXEN_NIC_REG_2(0x000),
447 NETXEN_NIC_REG_2(0x004),
448 NETXEN_NIC_REG_2(0x008),
453 NETXEN_NIC_REG_2(0x044),
454 NETXEN_NIC_REG_2(0x048),
455 NETXEN_NIC_REG_2(0x04c),
460 /* crb_rcv_producer: */
462 NETXEN_NIC_REG(0x144),
464 NETXEN_NIC_REG(0x154),
466 NETXEN_NIC_REG(0x164)
468 /* crb_sts_consumer: */
470 NETXEN_NIC_REG(0x17c),
471 NETXEN_NIC_REG_2(0x020),
472 NETXEN_NIC_REG_2(0x024),
473 NETXEN_NIC_REG_2(0x028),
478 NETXEN_NIC_REG_2(0x064),
479 NETXEN_NIC_REG_2(0x068),
480 NETXEN_NIC_REG_2(0x06c),
485 /* crb_rcv_producer: */
487 NETXEN_NIC_REG(0x1d8),
489 NETXEN_NIC_REG(0x1f8),
491 NETXEN_NIC_REG(0x208)
493 /* crb_sts_consumer: */
495 NETXEN_NIC_REG(0x220),
496 NETXEN_NIC_REG_2(0x03c),
497 NETXEN_NIC_REG_2(0x03c),
498 NETXEN_NIC_REG_2(0x03c),
503 NETXEN_NIC_REG_2(0x03c),
504 NETXEN_NIC_REG_2(0x03c),
505 NETXEN_NIC_REG_2(0x03c),
510 /* crb_rcv_producer: */
512 NETXEN_NIC_REG(0x22c),
514 NETXEN_NIC_REG(0x23c),
516 NETXEN_NIC_REG(0x24c)
518 /* crb_sts_consumer: */
520 NETXEN_NIC_REG(0x264),
521 NETXEN_NIC_REG_2(0x03c),
522 NETXEN_NIC_REG_2(0x03c),
523 NETXEN_NIC_REG_2(0x03c),
528 NETXEN_NIC_REG_2(0x03c),
529 NETXEN_NIC_REG_2(0x03c),
530 NETXEN_NIC_REG_2(0x03c),
536 netxen_init_old_ctx(struct netxen_adapter
*adapter
)
538 struct netxen_recv_context
*recv_ctx
;
539 struct nx_host_rds_ring
*rds_ring
;
540 struct nx_host_sds_ring
*sds_ring
;
541 struct nx_host_tx_ring
*tx_ring
;
543 int port
= adapter
->portnum
;
544 struct netxen_ring_ctx
*hwctx
;
547 tx_ring
= adapter
->tx_ring
;
548 recv_ctx
= &adapter
->recv_ctx
;
549 hwctx
= recv_ctx
->hwctx
;
551 hwctx
->cmd_ring_addr
= cpu_to_le64(tx_ring
->phys_addr
);
552 hwctx
->cmd_ring_size
= cpu_to_le32(tx_ring
->num_desc
);
555 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
556 rds_ring
= &recv_ctx
->rds_rings
[ring
];
558 hwctx
->rcv_rings
[ring
].addr
=
559 cpu_to_le64(rds_ring
->phys_addr
);
560 hwctx
->rcv_rings
[ring
].size
=
561 cpu_to_le32(rds_ring
->num_desc
);
564 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
565 sds_ring
= &recv_ctx
->sds_rings
[ring
];
568 hwctx
->sts_ring_addr
= cpu_to_le64(sds_ring
->phys_addr
);
569 hwctx
->sts_ring_size
= cpu_to_le32(sds_ring
->num_desc
);
571 hwctx
->sts_rings
[ring
].addr
= cpu_to_le64(sds_ring
->phys_addr
);
572 hwctx
->sts_rings
[ring
].size
= cpu_to_le32(sds_ring
->num_desc
);
573 hwctx
->sts_rings
[ring
].msi_index
= cpu_to_le16(ring
);
575 hwctx
->sts_ring_count
= cpu_to_le32(adapter
->max_sds_rings
);
577 signature
= (adapter
->max_sds_rings
> 1) ?
578 NETXEN_CTX_SIGNATURE_V2
: NETXEN_CTX_SIGNATURE
;
580 NXWR32(adapter
, CRB_CTX_ADDR_REG_LO(port
),
581 lower32(recv_ctx
->phys_addr
));
582 NXWR32(adapter
, CRB_CTX_ADDR_REG_HI(port
),
583 upper32(recv_ctx
->phys_addr
));
584 NXWR32(adapter
, CRB_CTX_SIGNATURE_REG(port
),
589 int netxen_alloc_hw_resources(struct netxen_adapter
*adapter
)
594 struct netxen_recv_context
*recv_ctx
;
595 struct nx_host_rds_ring
*rds_ring
;
596 struct nx_host_sds_ring
*sds_ring
;
597 struct nx_host_tx_ring
*tx_ring
;
599 struct pci_dev
*pdev
= adapter
->pdev
;
600 struct net_device
*netdev
= adapter
->netdev
;
601 int port
= adapter
->portnum
;
603 recv_ctx
= &adapter
->recv_ctx
;
604 tx_ring
= adapter
->tx_ring
;
606 addr
= pci_alloc_consistent(pdev
,
607 sizeof(struct netxen_ring_ctx
) + sizeof(uint32_t),
608 &recv_ctx
->phys_addr
);
610 dev_err(&pdev
->dev
, "failed to allocate hw context\n");
614 memset(addr
, 0, sizeof(struct netxen_ring_ctx
));
615 recv_ctx
->hwctx
= (struct netxen_ring_ctx
*)addr
;
616 recv_ctx
->hwctx
->ctx_id
= cpu_to_le32(port
);
617 recv_ctx
->hwctx
->cmd_consumer_offset
=
618 cpu_to_le64(recv_ctx
->phys_addr
+
619 sizeof(struct netxen_ring_ctx
));
620 tx_ring
->hw_consumer
=
621 (__le32
*)(((char *)addr
) + sizeof(struct netxen_ring_ctx
));
624 addr
= pci_alloc_consistent(pdev
, TX_DESC_RINGSIZE(tx_ring
),
625 &tx_ring
->phys_addr
);
628 dev_err(&pdev
->dev
, "%s: failed to allocate tx desc ring\n",
633 tx_ring
->desc_head
= (struct cmd_desc_type0
*)addr
;
635 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
636 rds_ring
= &recv_ctx
->rds_rings
[ring
];
637 addr
= pci_alloc_consistent(adapter
->pdev
,
638 RCV_DESC_RINGSIZE(rds_ring
),
639 &rds_ring
->phys_addr
);
642 "%s: failed to allocate rds ring [%d]\n",
647 rds_ring
->desc_head
= (struct rcv_desc
*)addr
;
649 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
650 rds_ring
->crb_rcv_producer
=
651 recv_crb_registers
[port
].crb_rcv_producer
[ring
];
654 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
655 sds_ring
= &recv_ctx
->sds_rings
[ring
];
657 addr
= pci_alloc_consistent(adapter
->pdev
,
658 STATUS_DESC_RINGSIZE(sds_ring
),
659 &sds_ring
->phys_addr
);
662 "%s: failed to allocate sds ring [%d]\n",
667 sds_ring
->desc_head
= (struct status_desc
*)addr
;
669 sds_ring
->crb_sts_consumer
=
670 recv_crb_registers
[port
].crb_sts_consumer
[ring
];
672 sds_ring
->crb_intr_mask
=
673 recv_crb_registers
[port
].sw_int_mask
[ring
];
677 if (!NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
678 err
= nx_fw_cmd_create_rx_ctx(adapter
);
681 err
= nx_fw_cmd_create_tx_ctx(adapter
);
685 err
= netxen_init_old_ctx(adapter
);
693 netxen_free_hw_resources(adapter
);
697 void netxen_free_hw_resources(struct netxen_adapter
*adapter
)
699 struct netxen_recv_context
*recv_ctx
;
700 struct nx_host_rds_ring
*rds_ring
;
701 struct nx_host_sds_ring
*sds_ring
;
702 struct nx_host_tx_ring
*tx_ring
;
705 int port
= adapter
->portnum
;
707 if (!NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
708 nx_fw_cmd_destroy_rx_ctx(adapter
);
709 nx_fw_cmd_destroy_tx_ctx(adapter
);
711 netxen_api_lock(adapter
);
712 NXWR32(adapter
, CRB_CTX_SIGNATURE_REG(port
),
713 NETXEN_CTX_D3_RESET
| port
);
714 netxen_api_unlock(adapter
);
717 /* Allow dma queues to drain after context reset */
720 recv_ctx
= &adapter
->recv_ctx
;
722 if (recv_ctx
->hwctx
!= NULL
) {
723 pci_free_consistent(adapter
->pdev
,
724 sizeof(struct netxen_ring_ctx
) +
727 recv_ctx
->phys_addr
);
728 recv_ctx
->hwctx
= NULL
;
731 tx_ring
= adapter
->tx_ring
;
732 if (tx_ring
->desc_head
!= NULL
) {
733 pci_free_consistent(adapter
->pdev
,
734 TX_DESC_RINGSIZE(tx_ring
),
735 tx_ring
->desc_head
, tx_ring
->phys_addr
);
736 tx_ring
->desc_head
= NULL
;
739 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
740 rds_ring
= &recv_ctx
->rds_rings
[ring
];
742 if (rds_ring
->desc_head
!= NULL
) {
743 pci_free_consistent(adapter
->pdev
,
744 RCV_DESC_RINGSIZE(rds_ring
),
746 rds_ring
->phys_addr
);
747 rds_ring
->desc_head
= NULL
;
751 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
752 sds_ring
= &recv_ctx
->sds_rings
[ring
];
754 if (sds_ring
->desc_head
!= NULL
) {
755 pci_free_consistent(adapter
->pdev
,
756 STATUS_DESC_RINGSIZE(sds_ring
),
758 sds_ring
->phys_addr
);
759 sds_ring
->desc_head
= NULL
;