2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2010 QLogic Corporation
5 * See LICENSE.qlcnic for copyright and licensing details.
11 qlcnic_poll_rsp(struct qlcnic_adapter
*adapter
)
17 /* give atleast 1ms for firmware to respond */
20 if (++timeout
> QLCNIC_OS_CRB_RETRY_COUNT
)
21 return QLCNIC_CDRP_RSP_TIMEOUT
;
23 rsp
= QLCRD32(adapter
, QLCNIC_CDRP_CRB_OFFSET
);
24 } while (!QLCNIC_CDRP_IS_RSP(rsp
));
30 qlcnic_issue_cmd(struct qlcnic_adapter
*adapter
,
31 u32 pci_fn
, u32 version
, u32 arg1
, u32 arg2
, u32 arg3
, u32 cmd
)
35 u32 rcode
= QLCNIC_RCODE_SUCCESS
;
36 struct pci_dev
*pdev
= adapter
->pdev
;
38 signature
= QLCNIC_CDRP_SIGNATURE_MAKE(pci_fn
, version
);
40 /* Acquire semaphore before accessing CRB */
41 if (qlcnic_api_lock(adapter
))
42 return QLCNIC_RCODE_TIMEOUT
;
44 QLCWR32(adapter
, QLCNIC_SIGN_CRB_OFFSET
, signature
);
45 QLCWR32(adapter
, QLCNIC_ARG1_CRB_OFFSET
, arg1
);
46 QLCWR32(adapter
, QLCNIC_ARG2_CRB_OFFSET
, arg2
);
47 QLCWR32(adapter
, QLCNIC_ARG3_CRB_OFFSET
, arg3
);
48 QLCWR32(adapter
, QLCNIC_CDRP_CRB_OFFSET
, QLCNIC_CDRP_FORM_CMD(cmd
));
50 rsp
= qlcnic_poll_rsp(adapter
);
52 if (rsp
== QLCNIC_CDRP_RSP_TIMEOUT
) {
53 dev_err(&pdev
->dev
, "card response timeout.\n");
54 rcode
= QLCNIC_RCODE_TIMEOUT
;
55 } else if (rsp
== QLCNIC_CDRP_RSP_FAIL
) {
56 rcode
= QLCRD32(adapter
, QLCNIC_ARG1_CRB_OFFSET
);
57 dev_err(&pdev
->dev
, "failed card response code:0x%x\n",
61 /* Release semaphore */
62 qlcnic_api_unlock(adapter
);
67 static uint32_t qlcnic_temp_checksum(uint32_t *temp_buffer
, u16 temp_size
)
70 int count
= temp_size
/ sizeof(uint32_t);
72 sum
+= *temp_buffer
++;
74 sum
= (sum
& 0xFFFFFFFF) + (sum
>> 32);
78 int qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter
*adapter
)
83 u32 version
, csum
, *template, *tmp_buf
;
84 struct qlcnic_hardware_context
*ahw
;
85 struct qlcnic_dump_template_hdr
*tmpl_hdr
, *tmp_tmpl
;
86 dma_addr_t tmp_addr_t
= 0;
89 err
= qlcnic_issue_cmd(adapter
,
90 adapter
->ahw
->pci_func
,
91 adapter
->fw_hal_version
,
95 QLCNIC_CDRP_CMD_TEMP_SIZE
);
96 if (err
!= QLCNIC_RCODE_SUCCESS
) {
97 err
= QLCRD32(adapter
, QLCNIC_ARG1_CRB_OFFSET
);
98 dev_info(&adapter
->pdev
->dev
,
99 "Can't get template size %d\n", err
);
103 version
= QLCRD32(adapter
, QLCNIC_ARG3_CRB_OFFSET
);
104 temp_size
= QLCRD32(adapter
, QLCNIC_ARG2_CRB_OFFSET
);
108 tmp_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, temp_size
,
109 &tmp_addr_t
, GFP_KERNEL
);
111 dev_err(&adapter
->pdev
->dev
,
112 "Can't get memory for FW dump template\n");
115 err
= qlcnic_issue_cmd(adapter
,
116 adapter
->ahw
->pci_func
,
117 adapter
->fw_hal_version
,
121 QLCNIC_CDRP_CMD_GET_TEMP_HDR
);
123 if (err
!= QLCNIC_RCODE_SUCCESS
) {
124 dev_err(&adapter
->pdev
->dev
,
125 "Failed to get mini dump template header %d\n", err
);
130 csum
= qlcnic_temp_checksum((uint32_t *) tmp_addr
, temp_size
);
132 dev_err(&adapter
->pdev
->dev
,
133 "Template header checksum validation failed\n");
137 ahw
->fw_dump
.tmpl_hdr
= vzalloc(temp_size
);
138 if (!ahw
->fw_dump
.tmpl_hdr
) {
143 template = (u32
*) ahw
->fw_dump
.tmpl_hdr
;
144 for (i
= 0; i
< temp_size
/sizeof(u32
); i
++)
145 *template++ = __le32_to_cpu(*tmp_buf
++);
147 tmpl_hdr
= ahw
->fw_dump
.tmpl_hdr
;
148 if (tmpl_hdr
->cap_mask
> QLCNIC_DUMP_MASK_DEF
&&
149 tmpl_hdr
->cap_mask
<= QLCNIC_DUMP_MASK_MAX
)
150 tmpl_hdr
->drv_cap_mask
= tmpl_hdr
->cap_mask
;
152 tmpl_hdr
->drv_cap_mask
= QLCNIC_DUMP_MASK_DEF
;
153 ahw
->fw_dump
.enable
= 1;
155 dma_free_coherent(&adapter
->pdev
->dev
, temp_size
, tmp_addr
, tmp_addr_t
);
160 qlcnic_fw_cmd_set_mtu(struct qlcnic_adapter
*adapter
, int mtu
)
162 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
164 if (recv_ctx
->state
== QLCNIC_HOST_CTX_STATE_ACTIVE
) {
165 if (qlcnic_issue_cmd(adapter
,
166 adapter
->ahw
->pci_func
,
167 adapter
->fw_hal_version
,
168 recv_ctx
->context_id
,
171 QLCNIC_CDRP_CMD_SET_MTU
)) {
173 dev_err(&adapter
->pdev
->dev
, "Failed to set mtu\n");
182 qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter
*adapter
)
185 struct qlcnic_hostrq_rx_ctx
*prq
;
186 struct qlcnic_cardrsp_rx_ctx
*prsp
;
187 struct qlcnic_hostrq_rds_ring
*prq_rds
;
188 struct qlcnic_hostrq_sds_ring
*prq_sds
;
189 struct qlcnic_cardrsp_rds_ring
*prsp_rds
;
190 struct qlcnic_cardrsp_sds_ring
*prsp_sds
;
191 struct qlcnic_host_rds_ring
*rds_ring
;
192 struct qlcnic_host_sds_ring
*sds_ring
;
194 dma_addr_t hostrq_phys_addr
, cardrsp_phys_addr
;
197 u8 i
, nrds_rings
, nsds_rings
;
198 size_t rq_size
, rsp_size
;
199 u32 cap
, reg
, val
, reg2
;
202 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
204 nrds_rings
= adapter
->max_rds_rings
;
205 nsds_rings
= adapter
->max_sds_rings
;
208 SIZEOF_HOSTRQ_RX(struct qlcnic_hostrq_rx_ctx
, nrds_rings
,
211 SIZEOF_CARDRSP_RX(struct qlcnic_cardrsp_rx_ctx
, nrds_rings
,
214 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rq_size
,
215 &hostrq_phys_addr
, GFP_KERNEL
);
220 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rsp_size
,
221 &cardrsp_phys_addr
, GFP_KERNEL
);
228 prq
->host_rsp_dma_addr
= cpu_to_le64(cardrsp_phys_addr
);
230 cap
= (QLCNIC_CAP0_LEGACY_CONTEXT
| QLCNIC_CAP0_LEGACY_MN
231 | QLCNIC_CAP0_VALIDOFF
);
232 cap
|= (QLCNIC_CAP0_JUMBO_CONTIGUOUS
| QLCNIC_CAP0_LRO_CONTIGUOUS
);
234 prq
->valid_field_offset
= offsetof(struct qlcnic_hostrq_rx_ctx
,
236 prq
->txrx_sds_binding
= nsds_rings
- 1;
238 prq
->capabilities
[0] = cpu_to_le32(cap
);
239 prq
->host_int_crb_mode
=
240 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED
);
241 prq
->host_rds_crb_mode
=
242 cpu_to_le32(QLCNIC_HOST_RDS_CRB_MODE_UNIQUE
);
244 prq
->num_rds_rings
= cpu_to_le16(nrds_rings
);
245 prq
->num_sds_rings
= cpu_to_le16(nsds_rings
);
246 prq
->rds_ring_offset
= 0;
248 val
= le32_to_cpu(prq
->rds_ring_offset
) +
249 (sizeof(struct qlcnic_hostrq_rds_ring
) * nrds_rings
);
250 prq
->sds_ring_offset
= cpu_to_le32(val
);
252 prq_rds
= (struct qlcnic_hostrq_rds_ring
*)(prq
->data
+
253 le32_to_cpu(prq
->rds_ring_offset
));
255 for (i
= 0; i
< nrds_rings
; i
++) {
257 rds_ring
= &recv_ctx
->rds_rings
[i
];
258 rds_ring
->producer
= 0;
260 prq_rds
[i
].host_phys_addr
= cpu_to_le64(rds_ring
->phys_addr
);
261 prq_rds
[i
].ring_size
= cpu_to_le32(rds_ring
->num_desc
);
262 prq_rds
[i
].ring_kind
= cpu_to_le32(i
);
263 prq_rds
[i
].buff_size
= cpu_to_le64(rds_ring
->dma_size
);
266 prq_sds
= (struct qlcnic_hostrq_sds_ring
*)(prq
->data
+
267 le32_to_cpu(prq
->sds_ring_offset
));
269 for (i
= 0; i
< nsds_rings
; i
++) {
271 sds_ring
= &recv_ctx
->sds_rings
[i
];
272 sds_ring
->consumer
= 0;
273 memset(sds_ring
->desc_head
, 0, STATUS_DESC_RINGSIZE(sds_ring
));
275 prq_sds
[i
].host_phys_addr
= cpu_to_le64(sds_ring
->phys_addr
);
276 prq_sds
[i
].ring_size
= cpu_to_le32(sds_ring
->num_desc
);
277 prq_sds
[i
].msi_index
= cpu_to_le16(i
);
280 phys_addr
= hostrq_phys_addr
;
281 err
= qlcnic_issue_cmd(adapter
,
282 adapter
->ahw
->pci_func
,
283 adapter
->fw_hal_version
,
284 (u32
)(phys_addr
>> 32),
285 (u32
)(phys_addr
& 0xffffffff),
287 QLCNIC_CDRP_CMD_CREATE_RX_CTX
);
289 dev_err(&adapter
->pdev
->dev
,
290 "Failed to create rx ctx in firmware%d\n", err
);
295 prsp_rds
= ((struct qlcnic_cardrsp_rds_ring
*)
296 &prsp
->data
[le32_to_cpu(prsp
->rds_ring_offset
)]);
298 for (i
= 0; i
< le16_to_cpu(prsp
->num_rds_rings
); i
++) {
299 rds_ring
= &recv_ctx
->rds_rings
[i
];
301 reg
= le32_to_cpu(prsp_rds
[i
].host_producer_crb
);
302 rds_ring
->crb_rcv_producer
= adapter
->ahw
->pci_base0
+ reg
;
305 prsp_sds
= ((struct qlcnic_cardrsp_sds_ring
*)
306 &prsp
->data
[le32_to_cpu(prsp
->sds_ring_offset
)]);
308 for (i
= 0; i
< le16_to_cpu(prsp
->num_sds_rings
); i
++) {
309 sds_ring
= &recv_ctx
->sds_rings
[i
];
311 reg
= le32_to_cpu(prsp_sds
[i
].host_consumer_crb
);
312 reg2
= le32_to_cpu(prsp_sds
[i
].interrupt_crb
);
314 sds_ring
->crb_sts_consumer
= adapter
->ahw
->pci_base0
+ reg
;
315 sds_ring
->crb_intr_mask
= adapter
->ahw
->pci_base0
+ reg2
;
318 recv_ctx
->state
= le32_to_cpu(prsp
->host_ctx_state
);
319 recv_ctx
->context_id
= le16_to_cpu(prsp
->context_id
);
320 recv_ctx
->virt_port
= prsp
->virt_port
;
323 dma_free_coherent(&adapter
->pdev
->dev
, rsp_size
, prsp
,
326 dma_free_coherent(&adapter
->pdev
->dev
, rq_size
, prq
, hostrq_phys_addr
);
331 qlcnic_fw_cmd_destroy_rx_ctx(struct qlcnic_adapter
*adapter
)
333 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
335 if (qlcnic_issue_cmd(adapter
,
336 adapter
->ahw
->pci_func
,
337 adapter
->fw_hal_version
,
338 recv_ctx
->context_id
,
339 QLCNIC_DESTROY_CTX_RESET
,
341 QLCNIC_CDRP_CMD_DESTROY_RX_CTX
)) {
343 dev_err(&adapter
->pdev
->dev
,
344 "Failed to destroy rx ctx in firmware\n");
347 recv_ctx
->state
= QLCNIC_HOST_CTX_STATE_FREED
;
351 qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter
*adapter
)
353 struct qlcnic_hostrq_tx_ctx
*prq
;
354 struct qlcnic_hostrq_cds_ring
*prq_cds
;
355 struct qlcnic_cardrsp_tx_ctx
*prsp
;
356 void *rq_addr
, *rsp_addr
;
357 size_t rq_size
, rsp_size
;
361 dma_addr_t rq_phys_addr
, rsp_phys_addr
;
362 struct qlcnic_host_tx_ring
*tx_ring
= adapter
->tx_ring
;
364 /* reset host resources */
365 tx_ring
->producer
= 0;
366 tx_ring
->sw_consumer
= 0;
367 *(tx_ring
->hw_consumer
) = 0;
369 rq_size
= SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx
);
370 rq_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rq_size
,
371 &rq_phys_addr
, GFP_KERNEL
);
375 rsp_size
= SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx
);
376 rsp_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rsp_size
,
377 &rsp_phys_addr
, GFP_KERNEL
);
383 memset(rq_addr
, 0, rq_size
);
386 memset(rsp_addr
, 0, rsp_size
);
389 prq
->host_rsp_dma_addr
= cpu_to_le64(rsp_phys_addr
);
391 temp
= (QLCNIC_CAP0_LEGACY_CONTEXT
| QLCNIC_CAP0_LEGACY_MN
|
393 prq
->capabilities
[0] = cpu_to_le32(temp
);
395 prq
->host_int_crb_mode
=
396 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED
);
398 prq
->interrupt_ctl
= 0;
400 prq
->cmd_cons_dma_addr
= cpu_to_le64(tx_ring
->hw_cons_phys_addr
);
402 prq_cds
= &prq
->cds_ring
;
404 prq_cds
->host_phys_addr
= cpu_to_le64(tx_ring
->phys_addr
);
405 prq_cds
->ring_size
= cpu_to_le32(tx_ring
->num_desc
);
407 phys_addr
= rq_phys_addr
;
408 err
= qlcnic_issue_cmd(adapter
,
409 adapter
->ahw
->pci_func
,
410 adapter
->fw_hal_version
,
411 (u32
)(phys_addr
>> 32),
412 ((u32
)phys_addr
& 0xffffffff),
414 QLCNIC_CDRP_CMD_CREATE_TX_CTX
);
416 if (err
== QLCNIC_RCODE_SUCCESS
) {
417 temp
= le32_to_cpu(prsp
->cds_ring
.host_producer_crb
);
418 tx_ring
->crb_cmd_producer
= adapter
->ahw
->pci_base0
+ temp
;
420 adapter
->tx_context_id
=
421 le16_to_cpu(prsp
->context_id
);
423 dev_err(&adapter
->pdev
->dev
,
424 "Failed to create tx ctx in firmware%d\n", err
);
428 dma_free_coherent(&adapter
->pdev
->dev
, rsp_size
, rsp_addr
,
432 dma_free_coherent(&adapter
->pdev
->dev
, rq_size
, rq_addr
, rq_phys_addr
);
438 qlcnic_fw_cmd_destroy_tx_ctx(struct qlcnic_adapter
*adapter
)
440 if (qlcnic_issue_cmd(adapter
,
441 adapter
->ahw
->pci_func
,
442 adapter
->fw_hal_version
,
443 adapter
->tx_context_id
,
444 QLCNIC_DESTROY_CTX_RESET
,
446 QLCNIC_CDRP_CMD_DESTROY_TX_CTX
)) {
448 dev_err(&adapter
->pdev
->dev
,
449 "Failed to destroy tx ctx in firmware\n");
454 qlcnic_fw_cmd_set_port(struct qlcnic_adapter
*adapter
, u32 config
)
456 return qlcnic_issue_cmd(adapter
,
457 adapter
->ahw
->pci_func
,
458 adapter
->fw_hal_version
,
462 QLCNIC_CDRP_CMD_CONFIG_PORT
);
465 int qlcnic_alloc_hw_resources(struct qlcnic_adapter
*adapter
)
470 struct qlcnic_recv_context
*recv_ctx
;
471 struct qlcnic_host_rds_ring
*rds_ring
;
472 struct qlcnic_host_sds_ring
*sds_ring
;
473 struct qlcnic_host_tx_ring
*tx_ring
;
475 struct pci_dev
*pdev
= adapter
->pdev
;
477 recv_ctx
= adapter
->recv_ctx
;
478 tx_ring
= adapter
->tx_ring
;
480 tx_ring
->hw_consumer
= (__le32
*) dma_alloc_coherent(&pdev
->dev
,
481 sizeof(u32
), &tx_ring
->hw_cons_phys_addr
, GFP_KERNEL
);
482 if (tx_ring
->hw_consumer
== NULL
) {
483 dev_err(&pdev
->dev
, "failed to allocate tx consumer\n");
488 addr
= dma_alloc_coherent(&pdev
->dev
, TX_DESC_RINGSIZE(tx_ring
),
489 &tx_ring
->phys_addr
, GFP_KERNEL
);
492 dev_err(&pdev
->dev
, "failed to allocate tx desc ring\n");
497 tx_ring
->desc_head
= addr
;
499 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
500 rds_ring
= &recv_ctx
->rds_rings
[ring
];
501 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
,
502 RCV_DESC_RINGSIZE(rds_ring
),
503 &rds_ring
->phys_addr
, GFP_KERNEL
);
506 "failed to allocate rds ring [%d]\n", ring
);
510 rds_ring
->desc_head
= addr
;
514 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
515 sds_ring
= &recv_ctx
->sds_rings
[ring
];
517 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
,
518 STATUS_DESC_RINGSIZE(sds_ring
),
519 &sds_ring
->phys_addr
, GFP_KERNEL
);
522 "failed to allocate sds ring [%d]\n", ring
);
526 sds_ring
->desc_head
= addr
;
532 qlcnic_free_hw_resources(adapter
);
537 int qlcnic_fw_create_ctx(struct qlcnic_adapter
*adapter
)
541 if (adapter
->flags
& QLCNIC_NEED_FLR
) {
542 pci_reset_function(adapter
->pdev
);
543 adapter
->flags
&= ~QLCNIC_NEED_FLR
;
546 err
= qlcnic_fw_cmd_create_rx_ctx(adapter
);
550 err
= qlcnic_fw_cmd_create_tx_ctx(adapter
);
552 qlcnic_fw_cmd_destroy_rx_ctx(adapter
);
556 set_bit(__QLCNIC_FW_ATTACHED
, &adapter
->state
);
560 void qlcnic_fw_destroy_ctx(struct qlcnic_adapter
*adapter
)
562 if (test_and_clear_bit(__QLCNIC_FW_ATTACHED
, &adapter
->state
)) {
563 qlcnic_fw_cmd_destroy_rx_ctx(adapter
);
564 qlcnic_fw_cmd_destroy_tx_ctx(adapter
);
566 /* Allow dma queues to drain after context reset */
571 void qlcnic_free_hw_resources(struct qlcnic_adapter
*adapter
)
573 struct qlcnic_recv_context
*recv_ctx
;
574 struct qlcnic_host_rds_ring
*rds_ring
;
575 struct qlcnic_host_sds_ring
*sds_ring
;
576 struct qlcnic_host_tx_ring
*tx_ring
;
579 recv_ctx
= adapter
->recv_ctx
;
581 tx_ring
= adapter
->tx_ring
;
582 if (tx_ring
->hw_consumer
!= NULL
) {
583 dma_free_coherent(&adapter
->pdev
->dev
,
585 tx_ring
->hw_consumer
,
586 tx_ring
->hw_cons_phys_addr
);
587 tx_ring
->hw_consumer
= NULL
;
590 if (tx_ring
->desc_head
!= NULL
) {
591 dma_free_coherent(&adapter
->pdev
->dev
,
592 TX_DESC_RINGSIZE(tx_ring
),
593 tx_ring
->desc_head
, tx_ring
->phys_addr
);
594 tx_ring
->desc_head
= NULL
;
597 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
598 rds_ring
= &recv_ctx
->rds_rings
[ring
];
600 if (rds_ring
->desc_head
!= NULL
) {
601 dma_free_coherent(&adapter
->pdev
->dev
,
602 RCV_DESC_RINGSIZE(rds_ring
),
604 rds_ring
->phys_addr
);
605 rds_ring
->desc_head
= NULL
;
609 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
610 sds_ring
= &recv_ctx
->sds_rings
[ring
];
612 if (sds_ring
->desc_head
!= NULL
) {
613 dma_free_coherent(&adapter
->pdev
->dev
,
614 STATUS_DESC_RINGSIZE(sds_ring
),
616 sds_ring
->phys_addr
);
617 sds_ring
->desc_head
= NULL
;
623 /* Get MAC address of a NIC partition */
624 int qlcnic_get_mac_address(struct qlcnic_adapter
*adapter
, u8
*mac
)
629 arg1
= adapter
->ahw
->pci_func
| BIT_8
;
630 err
= qlcnic_issue_cmd(adapter
,
631 adapter
->ahw
->pci_func
,
632 adapter
->fw_hal_version
,
636 QLCNIC_CDRP_CMD_MAC_ADDRESS
);
638 if (err
== QLCNIC_RCODE_SUCCESS
)
639 qlcnic_fetch_mac(adapter
, QLCNIC_ARG1_CRB_OFFSET
,
640 QLCNIC_ARG2_CRB_OFFSET
, 0, mac
);
642 dev_err(&adapter
->pdev
->dev
,
643 "Failed to get mac address%d\n", err
);
650 /* Get info of a NIC partition */
651 int qlcnic_get_nic_info(struct qlcnic_adapter
*adapter
,
652 struct qlcnic_info
*npar_info
, u8 func_id
)
655 dma_addr_t nic_dma_t
;
656 struct qlcnic_info
*nic_info
;
658 size_t nic_size
= sizeof(struct qlcnic_info
);
660 nic_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, nic_size
,
661 &nic_dma_t
, GFP_KERNEL
);
664 memset(nic_info_addr
, 0, nic_size
);
666 nic_info
= nic_info_addr
;
667 err
= qlcnic_issue_cmd(adapter
,
668 adapter
->ahw
->pci_func
,
669 adapter
->fw_hal_version
,
672 (func_id
<< 16 | nic_size
),
673 QLCNIC_CDRP_CMD_GET_NIC_INFO
);
675 if (err
== QLCNIC_RCODE_SUCCESS
) {
676 npar_info
->pci_func
= le16_to_cpu(nic_info
->pci_func
);
677 npar_info
->op_mode
= le16_to_cpu(nic_info
->op_mode
);
678 npar_info
->phys_port
= le16_to_cpu(nic_info
->phys_port
);
679 npar_info
->switch_mode
= le16_to_cpu(nic_info
->switch_mode
);
680 npar_info
->max_tx_ques
= le16_to_cpu(nic_info
->max_tx_ques
);
681 npar_info
->max_rx_ques
= le16_to_cpu(nic_info
->max_rx_ques
);
682 npar_info
->min_tx_bw
= le16_to_cpu(nic_info
->min_tx_bw
);
683 npar_info
->max_tx_bw
= le16_to_cpu(nic_info
->max_tx_bw
);
684 npar_info
->capabilities
= le32_to_cpu(nic_info
->capabilities
);
685 npar_info
->max_mtu
= le16_to_cpu(nic_info
->max_mtu
);
687 dev_info(&adapter
->pdev
->dev
,
688 "phy port: %d switch_mode: %d,\n"
689 "\tmax_tx_q: %d max_rx_q: %d min_tx_bw: 0x%x,\n"
690 "\tmax_tx_bw: 0x%x max_mtu:0x%x, capabilities: 0x%x\n",
691 npar_info
->phys_port
, npar_info
->switch_mode
,
692 npar_info
->max_tx_ques
, npar_info
->max_rx_ques
,
693 npar_info
->min_tx_bw
, npar_info
->max_tx_bw
,
694 npar_info
->max_mtu
, npar_info
->capabilities
);
696 dev_err(&adapter
->pdev
->dev
,
697 "Failed to get nic info%d\n", err
);
701 dma_free_coherent(&adapter
->pdev
->dev
, nic_size
, nic_info_addr
,
706 /* Configure a NIC partition */
707 int qlcnic_set_nic_info(struct qlcnic_adapter
*adapter
, struct qlcnic_info
*nic
)
710 dma_addr_t nic_dma_t
;
712 struct qlcnic_info
*nic_info
;
713 size_t nic_size
= sizeof(struct qlcnic_info
);
715 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
718 nic_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, nic_size
,
719 &nic_dma_t
, GFP_KERNEL
);
723 memset(nic_info_addr
, 0, nic_size
);
724 nic_info
= nic_info_addr
;
726 nic_info
->pci_func
= cpu_to_le16(nic
->pci_func
);
727 nic_info
->op_mode
= cpu_to_le16(nic
->op_mode
);
728 nic_info
->phys_port
= cpu_to_le16(nic
->phys_port
);
729 nic_info
->switch_mode
= cpu_to_le16(nic
->switch_mode
);
730 nic_info
->capabilities
= cpu_to_le32(nic
->capabilities
);
731 nic_info
->max_mac_filters
= nic
->max_mac_filters
;
732 nic_info
->max_tx_ques
= cpu_to_le16(nic
->max_tx_ques
);
733 nic_info
->max_rx_ques
= cpu_to_le16(nic
->max_rx_ques
);
734 nic_info
->min_tx_bw
= cpu_to_le16(nic
->min_tx_bw
);
735 nic_info
->max_tx_bw
= cpu_to_le16(nic
->max_tx_bw
);
737 err
= qlcnic_issue_cmd(adapter
,
738 adapter
->ahw
->pci_func
,
739 adapter
->fw_hal_version
,
742 ((nic
->pci_func
<< 16) | nic_size
),
743 QLCNIC_CDRP_CMD_SET_NIC_INFO
);
745 if (err
!= QLCNIC_RCODE_SUCCESS
) {
746 dev_err(&adapter
->pdev
->dev
,
747 "Failed to set nic info%d\n", err
);
751 dma_free_coherent(&adapter
->pdev
->dev
, nic_size
, nic_info_addr
,
756 /* Get PCI Info of a partition */
757 int qlcnic_get_pci_info(struct qlcnic_adapter
*adapter
,
758 struct qlcnic_pci_info
*pci_info
)
761 dma_addr_t pci_info_dma_t
;
762 struct qlcnic_pci_info
*npar
;
764 size_t npar_size
= sizeof(struct qlcnic_pci_info
);
765 size_t pci_size
= npar_size
* QLCNIC_MAX_PCI_FUNC
;
767 pci_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, pci_size
,
768 &pci_info_dma_t
, GFP_KERNEL
);
771 memset(pci_info_addr
, 0, pci_size
);
773 npar
= pci_info_addr
;
774 err
= qlcnic_issue_cmd(adapter
,
775 adapter
->ahw
->pci_func
,
776 adapter
->fw_hal_version
,
780 QLCNIC_CDRP_CMD_GET_PCI_INFO
);
782 if (err
== QLCNIC_RCODE_SUCCESS
) {
783 for (i
= 0; i
< QLCNIC_MAX_PCI_FUNC
; i
++, npar
++, pci_info
++) {
784 pci_info
->id
= le16_to_cpu(npar
->id
);
785 pci_info
->active
= le16_to_cpu(npar
->active
);
786 pci_info
->type
= le16_to_cpu(npar
->type
);
787 pci_info
->default_port
=
788 le16_to_cpu(npar
->default_port
);
789 pci_info
->tx_min_bw
=
790 le16_to_cpu(npar
->tx_min_bw
);
791 pci_info
->tx_max_bw
=
792 le16_to_cpu(npar
->tx_max_bw
);
793 memcpy(pci_info
->mac
, npar
->mac
, ETH_ALEN
);
796 dev_err(&adapter
->pdev
->dev
,
797 "Failed to get PCI Info%d\n", err
);
801 dma_free_coherent(&adapter
->pdev
->dev
, pci_size
, pci_info_addr
,
806 /* Configure eSwitch for port mirroring */
807 int qlcnic_config_port_mirroring(struct qlcnic_adapter
*adapter
, u8 id
,
808 u8 enable_mirroring
, u8 pci_func
)
813 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
||
814 !(adapter
->eswitch
[id
].flags
& QLCNIC_SWITCH_ENABLE
))
817 arg1
= id
| (enable_mirroring
? BIT_4
: 0);
818 arg1
|= pci_func
<< 8;
820 err
= qlcnic_issue_cmd(adapter
,
821 adapter
->ahw
->pci_func
,
822 adapter
->fw_hal_version
,
826 QLCNIC_CDRP_CMD_SET_PORTMIRRORING
);
828 if (err
!= QLCNIC_RCODE_SUCCESS
) {
829 dev_err(&adapter
->pdev
->dev
,
830 "Failed to configure port mirroring%d on eswitch:%d\n",
833 dev_info(&adapter
->pdev
->dev
,
834 "Configured eSwitch %d for port mirroring:%d\n",
841 int qlcnic_get_port_stats(struct qlcnic_adapter
*adapter
, const u8 func
,
842 const u8 rx_tx
, struct __qlcnic_esw_statistics
*esw_stats
) {
844 size_t stats_size
= sizeof(struct __qlcnic_esw_statistics
);
845 struct __qlcnic_esw_statistics
*stats
;
846 dma_addr_t stats_dma_t
;
851 if (esw_stats
== NULL
)
854 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
&&
855 func
!= adapter
->ahw
->pci_func
) {
856 dev_err(&adapter
->pdev
->dev
,
857 "Not privilege to query stats for func=%d", func
);
861 stats_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, stats_size
,
862 &stats_dma_t
, GFP_KERNEL
);
864 dev_err(&adapter
->pdev
->dev
, "Unable to allocate memory\n");
867 memset(stats_addr
, 0, stats_size
);
869 arg1
= func
| QLCNIC_STATS_VERSION
<< 8 | QLCNIC_STATS_PORT
<< 12;
870 arg1
|= rx_tx
<< 15 | stats_size
<< 16;
872 err
= qlcnic_issue_cmd(adapter
,
873 adapter
->ahw
->pci_func
,
874 adapter
->fw_hal_version
,
878 QLCNIC_CDRP_CMD_GET_ESWITCH_STATS
);
882 esw_stats
->context_id
= le16_to_cpu(stats
->context_id
);
883 esw_stats
->version
= le16_to_cpu(stats
->version
);
884 esw_stats
->size
= le16_to_cpu(stats
->size
);
885 esw_stats
->multicast_frames
=
886 le64_to_cpu(stats
->multicast_frames
);
887 esw_stats
->broadcast_frames
=
888 le64_to_cpu(stats
->broadcast_frames
);
889 esw_stats
->unicast_frames
= le64_to_cpu(stats
->unicast_frames
);
890 esw_stats
->dropped_frames
= le64_to_cpu(stats
->dropped_frames
);
891 esw_stats
->local_frames
= le64_to_cpu(stats
->local_frames
);
892 esw_stats
->errors
= le64_to_cpu(stats
->errors
);
893 esw_stats
->numbytes
= le64_to_cpu(stats
->numbytes
);
896 dma_free_coherent(&adapter
->pdev
->dev
, stats_size
, stats_addr
,
901 int qlcnic_get_eswitch_stats(struct qlcnic_adapter
*adapter
, const u8 eswitch
,
902 const u8 rx_tx
, struct __qlcnic_esw_statistics
*esw_stats
) {
904 struct __qlcnic_esw_statistics port_stats
;
908 if (esw_stats
== NULL
)
910 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
912 if (adapter
->npars
== NULL
)
915 memset(esw_stats
, 0, sizeof(u64
));
916 esw_stats
->unicast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
917 esw_stats
->multicast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
918 esw_stats
->broadcast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
919 esw_stats
->dropped_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
920 esw_stats
->errors
= QLCNIC_ESW_STATS_NOT_AVAIL
;
921 esw_stats
->local_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
922 esw_stats
->numbytes
= QLCNIC_ESW_STATS_NOT_AVAIL
;
923 esw_stats
->context_id
= eswitch
;
925 for (i
= 0; i
< QLCNIC_MAX_PCI_FUNC
; i
++) {
926 if (adapter
->npars
[i
].phy_port
!= eswitch
)
929 memset(&port_stats
, 0, sizeof(struct __qlcnic_esw_statistics
));
930 if (qlcnic_get_port_stats(adapter
, i
, rx_tx
, &port_stats
))
933 esw_stats
->size
= port_stats
.size
;
934 esw_stats
->version
= port_stats
.version
;
935 QLCNIC_ADD_ESW_STATS(esw_stats
->unicast_frames
,
936 port_stats
.unicast_frames
);
937 QLCNIC_ADD_ESW_STATS(esw_stats
->multicast_frames
,
938 port_stats
.multicast_frames
);
939 QLCNIC_ADD_ESW_STATS(esw_stats
->broadcast_frames
,
940 port_stats
.broadcast_frames
);
941 QLCNIC_ADD_ESW_STATS(esw_stats
->dropped_frames
,
942 port_stats
.dropped_frames
);
943 QLCNIC_ADD_ESW_STATS(esw_stats
->errors
,
945 QLCNIC_ADD_ESW_STATS(esw_stats
->local_frames
,
946 port_stats
.local_frames
);
947 QLCNIC_ADD_ESW_STATS(esw_stats
->numbytes
,
948 port_stats
.numbytes
);
954 int qlcnic_clear_esw_stats(struct qlcnic_adapter
*adapter
, const u8 func_esw
,
955 const u8 port
, const u8 rx_tx
)
960 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
963 if (func_esw
== QLCNIC_STATS_PORT
) {
964 if (port
>= QLCNIC_MAX_PCI_FUNC
)
966 } else if (func_esw
== QLCNIC_STATS_ESWITCH
) {
967 if (port
>= QLCNIC_NIU_MAX_XG_PORTS
)
973 if (rx_tx
> QLCNIC_QUERY_TX_COUNTER
)
976 arg1
= port
| QLCNIC_STATS_VERSION
<< 8 | func_esw
<< 12;
977 arg1
|= BIT_14
| rx_tx
<< 15;
979 return qlcnic_issue_cmd(adapter
,
980 adapter
->ahw
->pci_func
,
981 adapter
->fw_hal_version
,
985 QLCNIC_CDRP_CMD_GET_ESWITCH_STATS
);
988 dev_err(&adapter
->pdev
->dev
, "Invalid argument func_esw=%d port=%d"
989 "rx_ctx=%d\n", func_esw
, port
, rx_tx
);
994 __qlcnic_get_eswitch_port_config(struct qlcnic_adapter
*adapter
,
995 u32
*arg1
, u32
*arg2
)
999 pci_func
= (*arg1
>> 8);
1000 err
= qlcnic_issue_cmd(adapter
,
1001 adapter
->ahw
->pci_func
,
1002 adapter
->fw_hal_version
,
1006 QLCNIC_CDRP_CMD_GET_ESWITCH_PORT_CONFIG
);
1008 if (err
== QLCNIC_RCODE_SUCCESS
) {
1009 *arg1
= QLCRD32(adapter
, QLCNIC_ARG1_CRB_OFFSET
);
1010 *arg2
= QLCRD32(adapter
, QLCNIC_ARG2_CRB_OFFSET
);
1011 dev_info(&adapter
->pdev
->dev
,
1012 "eSwitch port config for pci func %d\n", pci_func
);
1014 dev_err(&adapter
->pdev
->dev
,
1015 "Failed to get eswitch port config for pci func %d\n",
1020 /* Configure eSwitch port
1021 op_mode = 0 for setting default port behavior
1022 op_mode = 1 for setting vlan id
1023 op_mode = 2 for deleting vlan id
1024 op_type = 0 for vlan_id
1025 op_type = 1 for port vlan_id
1027 int qlcnic_config_switch_port(struct qlcnic_adapter
*adapter
,
1028 struct qlcnic_esw_func_cfg
*esw_cfg
)
1034 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
1036 pci_func
= esw_cfg
->pci_func
;
1037 arg1
= (adapter
->npars
[pci_func
].phy_port
& BIT_0
);
1038 arg1
|= (pci_func
<< 8);
1040 if (__qlcnic_get_eswitch_port_config(adapter
, &arg1
, &arg2
))
1042 arg1
&= ~(0x0ff << 8);
1043 arg1
|= (pci_func
<< 8);
1044 arg1
&= ~(BIT_2
| BIT_3
);
1045 switch (esw_cfg
->op_mode
) {
1046 case QLCNIC_PORT_DEFAULTS
:
1047 arg1
|= (BIT_4
| BIT_6
| BIT_7
);
1048 arg2
|= (BIT_0
| BIT_1
);
1049 if (adapter
->capabilities
& QLCNIC_FW_CAPABILITY_TSO
)
1050 arg2
|= (BIT_2
| BIT_3
);
1051 if (!(esw_cfg
->discard_tagged
))
1053 if (!(esw_cfg
->promisc_mode
))
1055 if (!(esw_cfg
->mac_override
))
1057 if (!(esw_cfg
->mac_anti_spoof
))
1059 if (!(esw_cfg
->offload_flags
& BIT_0
))
1060 arg2
&= ~(BIT_1
| BIT_2
| BIT_3
);
1061 if (!(esw_cfg
->offload_flags
& BIT_1
))
1063 if (!(esw_cfg
->offload_flags
& BIT_2
))
1066 case QLCNIC_ADD_VLAN
:
1067 arg1
|= (BIT_2
| BIT_5
);
1068 arg1
|= (esw_cfg
->vlan_id
<< 16);
1070 case QLCNIC_DEL_VLAN
:
1071 arg1
|= (BIT_3
| BIT_5
);
1072 arg1
&= ~(0x0ffff << 16);
1078 err
= qlcnic_issue_cmd(adapter
,
1079 adapter
->ahw
->pci_func
,
1080 adapter
->fw_hal_version
,
1084 QLCNIC_CDRP_CMD_CONFIGURE_ESWITCH
);
1086 if (err
!= QLCNIC_RCODE_SUCCESS
) {
1087 dev_err(&adapter
->pdev
->dev
,
1088 "Failed to configure eswitch pci func %d\n", pci_func
);
1090 dev_info(&adapter
->pdev
->dev
,
1091 "Configured eSwitch for pci func %d\n", pci_func
);
1098 qlcnic_get_eswitch_port_config(struct qlcnic_adapter
*adapter
,
1099 struct qlcnic_esw_func_cfg
*esw_cfg
)
1103 if (adapter
->op_mode
== QLCNIC_MGMT_FUNC
)
1104 phy_port
= adapter
->npars
[esw_cfg
->pci_func
].phy_port
;
1106 phy_port
= adapter
->physical_port
;
1108 arg1
|= (esw_cfg
->pci_func
<< 8);
1109 if (__qlcnic_get_eswitch_port_config(adapter
, &arg1
, &arg2
))
1112 esw_cfg
->discard_tagged
= !!(arg1
& BIT_4
);
1113 esw_cfg
->host_vlan_tag
= !!(arg1
& BIT_5
);
1114 esw_cfg
->promisc_mode
= !!(arg1
& BIT_6
);
1115 esw_cfg
->mac_override
= !!(arg1
& BIT_7
);
1116 esw_cfg
->vlan_id
= LSW(arg1
>> 16);
1117 esw_cfg
->mac_anti_spoof
= (arg2
& 0x1);
1118 esw_cfg
->offload_flags
= ((arg2
>> 1) & 0x7);