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
);
68 qlcnic_fw_cmd_set_mtu(struct qlcnic_adapter
*adapter
, int mtu
)
70 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
72 if (recv_ctx
->state
== QLCNIC_HOST_CTX_STATE_ACTIVE
) {
73 if (qlcnic_issue_cmd(adapter
,
74 adapter
->ahw
->pci_func
,
75 adapter
->fw_hal_version
,
79 QLCNIC_CDRP_CMD_SET_MTU
)) {
81 dev_err(&adapter
->pdev
->dev
, "Failed to set mtu\n");
90 qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter
*adapter
)
93 struct qlcnic_hostrq_rx_ctx
*prq
;
94 struct qlcnic_cardrsp_rx_ctx
*prsp
;
95 struct qlcnic_hostrq_rds_ring
*prq_rds
;
96 struct qlcnic_hostrq_sds_ring
*prq_sds
;
97 struct qlcnic_cardrsp_rds_ring
*prsp_rds
;
98 struct qlcnic_cardrsp_sds_ring
*prsp_sds
;
99 struct qlcnic_host_rds_ring
*rds_ring
;
100 struct qlcnic_host_sds_ring
*sds_ring
;
102 dma_addr_t hostrq_phys_addr
, cardrsp_phys_addr
;
105 u8 i
, nrds_rings
, nsds_rings
;
106 size_t rq_size
, rsp_size
;
107 u32 cap
, reg
, val
, reg2
;
110 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
112 nrds_rings
= adapter
->max_rds_rings
;
113 nsds_rings
= adapter
->max_sds_rings
;
116 SIZEOF_HOSTRQ_RX(struct qlcnic_hostrq_rx_ctx
, nrds_rings
,
119 SIZEOF_CARDRSP_RX(struct qlcnic_cardrsp_rx_ctx
, nrds_rings
,
122 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rq_size
,
123 &hostrq_phys_addr
, GFP_KERNEL
);
126 prq
= (struct qlcnic_hostrq_rx_ctx
*)addr
;
128 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rsp_size
,
129 &cardrsp_phys_addr
, GFP_KERNEL
);
134 prsp
= (struct qlcnic_cardrsp_rx_ctx
*)addr
;
136 prq
->host_rsp_dma_addr
= cpu_to_le64(cardrsp_phys_addr
);
138 cap
= (QLCNIC_CAP0_LEGACY_CONTEXT
| QLCNIC_CAP0_LEGACY_MN
139 | QLCNIC_CAP0_VALIDOFF
);
140 cap
|= (QLCNIC_CAP0_JUMBO_CONTIGUOUS
| QLCNIC_CAP0_LRO_CONTIGUOUS
);
142 prq
->valid_field_offset
= offsetof(struct qlcnic_hostrq_rx_ctx
,
144 prq
->txrx_sds_binding
= nsds_rings
- 1;
146 prq
->capabilities
[0] = cpu_to_le32(cap
);
147 prq
->host_int_crb_mode
=
148 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED
);
149 prq
->host_rds_crb_mode
=
150 cpu_to_le32(QLCNIC_HOST_RDS_CRB_MODE_UNIQUE
);
152 prq
->num_rds_rings
= cpu_to_le16(nrds_rings
);
153 prq
->num_sds_rings
= cpu_to_le16(nsds_rings
);
154 prq
->rds_ring_offset
= 0;
156 val
= le32_to_cpu(prq
->rds_ring_offset
) +
157 (sizeof(struct qlcnic_hostrq_rds_ring
) * nrds_rings
);
158 prq
->sds_ring_offset
= cpu_to_le32(val
);
160 prq_rds
= (struct qlcnic_hostrq_rds_ring
*)(prq
->data
+
161 le32_to_cpu(prq
->rds_ring_offset
));
163 for (i
= 0; i
< nrds_rings
; i
++) {
165 rds_ring
= &recv_ctx
->rds_rings
[i
];
166 rds_ring
->producer
= 0;
168 prq_rds
[i
].host_phys_addr
= cpu_to_le64(rds_ring
->phys_addr
);
169 prq_rds
[i
].ring_size
= cpu_to_le32(rds_ring
->num_desc
);
170 prq_rds
[i
].ring_kind
= cpu_to_le32(i
);
171 prq_rds
[i
].buff_size
= cpu_to_le64(rds_ring
->dma_size
);
174 prq_sds
= (struct qlcnic_hostrq_sds_ring
*)(prq
->data
+
175 le32_to_cpu(prq
->sds_ring_offset
));
177 for (i
= 0; i
< nsds_rings
; i
++) {
179 sds_ring
= &recv_ctx
->sds_rings
[i
];
180 sds_ring
->consumer
= 0;
181 memset(sds_ring
->desc_head
, 0, STATUS_DESC_RINGSIZE(sds_ring
));
183 prq_sds
[i
].host_phys_addr
= cpu_to_le64(sds_ring
->phys_addr
);
184 prq_sds
[i
].ring_size
= cpu_to_le32(sds_ring
->num_desc
);
185 prq_sds
[i
].msi_index
= cpu_to_le16(i
);
188 phys_addr
= hostrq_phys_addr
;
189 err
= qlcnic_issue_cmd(adapter
,
190 adapter
->ahw
->pci_func
,
191 adapter
->fw_hal_version
,
192 (u32
)(phys_addr
>> 32),
193 (u32
)(phys_addr
& 0xffffffff),
195 QLCNIC_CDRP_CMD_CREATE_RX_CTX
);
197 dev_err(&adapter
->pdev
->dev
,
198 "Failed to create rx ctx in firmware%d\n", err
);
203 prsp_rds
= ((struct qlcnic_cardrsp_rds_ring
*)
204 &prsp
->data
[le32_to_cpu(prsp
->rds_ring_offset
)]);
206 for (i
= 0; i
< le16_to_cpu(prsp
->num_rds_rings
); i
++) {
207 rds_ring
= &recv_ctx
->rds_rings
[i
];
209 reg
= le32_to_cpu(prsp_rds
[i
].host_producer_crb
);
210 rds_ring
->crb_rcv_producer
= adapter
->ahw
->pci_base0
+ reg
;
213 prsp_sds
= ((struct qlcnic_cardrsp_sds_ring
*)
214 &prsp
->data
[le32_to_cpu(prsp
->sds_ring_offset
)]);
216 for (i
= 0; i
< le16_to_cpu(prsp
->num_sds_rings
); i
++) {
217 sds_ring
= &recv_ctx
->sds_rings
[i
];
219 reg
= le32_to_cpu(prsp_sds
[i
].host_consumer_crb
);
220 reg2
= le32_to_cpu(prsp_sds
[i
].interrupt_crb
);
222 sds_ring
->crb_sts_consumer
= adapter
->ahw
->pci_base0
+ reg
;
223 sds_ring
->crb_intr_mask
= adapter
->ahw
->pci_base0
+ reg2
;
226 recv_ctx
->state
= le32_to_cpu(prsp
->host_ctx_state
);
227 recv_ctx
->context_id
= le16_to_cpu(prsp
->context_id
);
228 recv_ctx
->virt_port
= prsp
->virt_port
;
231 dma_free_coherent(&adapter
->pdev
->dev
, rsp_size
, prsp
,
234 dma_free_coherent(&adapter
->pdev
->dev
, rq_size
, prq
, hostrq_phys_addr
);
239 qlcnic_fw_cmd_destroy_rx_ctx(struct qlcnic_adapter
*adapter
)
241 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
243 if (qlcnic_issue_cmd(adapter
,
244 adapter
->ahw
->pci_func
,
245 adapter
->fw_hal_version
,
246 recv_ctx
->context_id
,
247 QLCNIC_DESTROY_CTX_RESET
,
249 QLCNIC_CDRP_CMD_DESTROY_RX_CTX
)) {
251 dev_err(&adapter
->pdev
->dev
,
252 "Failed to destroy rx ctx in firmware\n");
255 recv_ctx
->state
= QLCNIC_HOST_CTX_STATE_FREED
;
259 qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter
*adapter
)
261 struct qlcnic_hostrq_tx_ctx
*prq
;
262 struct qlcnic_hostrq_cds_ring
*prq_cds
;
263 struct qlcnic_cardrsp_tx_ctx
*prsp
;
264 void *rq_addr
, *rsp_addr
;
265 size_t rq_size
, rsp_size
;
269 dma_addr_t rq_phys_addr
, rsp_phys_addr
;
270 struct qlcnic_host_tx_ring
*tx_ring
= adapter
->tx_ring
;
272 /* reset host resources */
273 tx_ring
->producer
= 0;
274 tx_ring
->sw_consumer
= 0;
275 *(tx_ring
->hw_consumer
) = 0;
277 rq_size
= SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx
);
278 rq_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rq_size
,
279 &rq_phys_addr
, GFP_KERNEL
);
283 rsp_size
= SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx
);
284 rsp_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, rsp_size
,
285 &rsp_phys_addr
, GFP_KERNEL
);
291 memset(rq_addr
, 0, rq_size
);
292 prq
= (struct qlcnic_hostrq_tx_ctx
*)rq_addr
;
294 memset(rsp_addr
, 0, rsp_size
);
295 prsp
= (struct qlcnic_cardrsp_tx_ctx
*)rsp_addr
;
297 prq
->host_rsp_dma_addr
= cpu_to_le64(rsp_phys_addr
);
299 temp
= (QLCNIC_CAP0_LEGACY_CONTEXT
| QLCNIC_CAP0_LEGACY_MN
|
301 prq
->capabilities
[0] = cpu_to_le32(temp
);
303 prq
->host_int_crb_mode
=
304 cpu_to_le32(QLCNIC_HOST_INT_CRB_MODE_SHARED
);
306 prq
->interrupt_ctl
= 0;
308 prq
->cmd_cons_dma_addr
= cpu_to_le64(tx_ring
->hw_cons_phys_addr
);
310 prq_cds
= &prq
->cds_ring
;
312 prq_cds
->host_phys_addr
= cpu_to_le64(tx_ring
->phys_addr
);
313 prq_cds
->ring_size
= cpu_to_le32(tx_ring
->num_desc
);
315 phys_addr
= rq_phys_addr
;
316 err
= qlcnic_issue_cmd(adapter
,
317 adapter
->ahw
->pci_func
,
318 adapter
->fw_hal_version
,
319 (u32
)(phys_addr
>> 32),
320 ((u32
)phys_addr
& 0xffffffff),
322 QLCNIC_CDRP_CMD_CREATE_TX_CTX
);
324 if (err
== QLCNIC_RCODE_SUCCESS
) {
325 temp
= le32_to_cpu(prsp
->cds_ring
.host_producer_crb
);
326 tx_ring
->crb_cmd_producer
= adapter
->ahw
->pci_base0
+ temp
;
328 adapter
->tx_context_id
=
329 le16_to_cpu(prsp
->context_id
);
331 dev_err(&adapter
->pdev
->dev
,
332 "Failed to create tx ctx in firmware%d\n", err
);
336 dma_free_coherent(&adapter
->pdev
->dev
, rsp_size
, rsp_addr
,
340 dma_free_coherent(&adapter
->pdev
->dev
, rq_size
, rq_addr
, rq_phys_addr
);
346 qlcnic_fw_cmd_destroy_tx_ctx(struct qlcnic_adapter
*adapter
)
348 if (qlcnic_issue_cmd(adapter
,
349 adapter
->ahw
->pci_func
,
350 adapter
->fw_hal_version
,
351 adapter
->tx_context_id
,
352 QLCNIC_DESTROY_CTX_RESET
,
354 QLCNIC_CDRP_CMD_DESTROY_TX_CTX
)) {
356 dev_err(&adapter
->pdev
->dev
,
357 "Failed to destroy tx ctx in firmware\n");
362 qlcnic_fw_cmd_set_port(struct qlcnic_adapter
*adapter
, u32 config
)
364 return qlcnic_issue_cmd(adapter
,
365 adapter
->ahw
->pci_func
,
366 adapter
->fw_hal_version
,
370 QLCNIC_CDRP_CMD_CONFIG_PORT
);
373 int qlcnic_alloc_hw_resources(struct qlcnic_adapter
*adapter
)
378 struct qlcnic_recv_context
*recv_ctx
;
379 struct qlcnic_host_rds_ring
*rds_ring
;
380 struct qlcnic_host_sds_ring
*sds_ring
;
381 struct qlcnic_host_tx_ring
*tx_ring
;
383 struct pci_dev
*pdev
= adapter
->pdev
;
385 recv_ctx
= adapter
->recv_ctx
;
386 tx_ring
= adapter
->tx_ring
;
388 tx_ring
->hw_consumer
= (__le32
*) dma_alloc_coherent(&pdev
->dev
,
389 sizeof(u32
), &tx_ring
->hw_cons_phys_addr
, GFP_KERNEL
);
390 if (tx_ring
->hw_consumer
== NULL
) {
391 dev_err(&pdev
->dev
, "failed to allocate tx consumer\n");
396 addr
= dma_alloc_coherent(&pdev
->dev
, TX_DESC_RINGSIZE(tx_ring
),
397 &tx_ring
->phys_addr
, GFP_KERNEL
);
400 dev_err(&pdev
->dev
, "failed to allocate tx desc ring\n");
405 tx_ring
->desc_head
= (struct cmd_desc_type0
*)addr
;
407 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
408 rds_ring
= &recv_ctx
->rds_rings
[ring
];
409 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
,
410 RCV_DESC_RINGSIZE(rds_ring
),
411 &rds_ring
->phys_addr
, GFP_KERNEL
);
414 "failed to allocate rds ring [%d]\n", ring
);
418 rds_ring
->desc_head
= (struct rcv_desc
*)addr
;
422 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
423 sds_ring
= &recv_ctx
->sds_rings
[ring
];
425 addr
= dma_alloc_coherent(&adapter
->pdev
->dev
,
426 STATUS_DESC_RINGSIZE(sds_ring
),
427 &sds_ring
->phys_addr
, GFP_KERNEL
);
430 "failed to allocate sds ring [%d]\n", ring
);
434 sds_ring
->desc_head
= (struct status_desc
*)addr
;
440 qlcnic_free_hw_resources(adapter
);
445 int qlcnic_fw_create_ctx(struct qlcnic_adapter
*adapter
)
449 if (adapter
->flags
& QLCNIC_NEED_FLR
) {
450 pci_reset_function(adapter
->pdev
);
451 adapter
->flags
&= ~QLCNIC_NEED_FLR
;
454 err
= qlcnic_fw_cmd_create_rx_ctx(adapter
);
458 err
= qlcnic_fw_cmd_create_tx_ctx(adapter
);
460 qlcnic_fw_cmd_destroy_rx_ctx(adapter
);
464 set_bit(__QLCNIC_FW_ATTACHED
, &adapter
->state
);
468 void qlcnic_fw_destroy_ctx(struct qlcnic_adapter
*adapter
)
470 if (test_and_clear_bit(__QLCNIC_FW_ATTACHED
, &adapter
->state
)) {
471 qlcnic_fw_cmd_destroy_rx_ctx(adapter
);
472 qlcnic_fw_cmd_destroy_tx_ctx(adapter
);
474 /* Allow dma queues to drain after context reset */
479 void qlcnic_free_hw_resources(struct qlcnic_adapter
*adapter
)
481 struct qlcnic_recv_context
*recv_ctx
;
482 struct qlcnic_host_rds_ring
*rds_ring
;
483 struct qlcnic_host_sds_ring
*sds_ring
;
484 struct qlcnic_host_tx_ring
*tx_ring
;
487 recv_ctx
= adapter
->recv_ctx
;
489 tx_ring
= adapter
->tx_ring
;
490 if (tx_ring
->hw_consumer
!= NULL
) {
491 dma_free_coherent(&adapter
->pdev
->dev
,
493 tx_ring
->hw_consumer
,
494 tx_ring
->hw_cons_phys_addr
);
495 tx_ring
->hw_consumer
= NULL
;
498 if (tx_ring
->desc_head
!= NULL
) {
499 dma_free_coherent(&adapter
->pdev
->dev
,
500 TX_DESC_RINGSIZE(tx_ring
),
501 tx_ring
->desc_head
, tx_ring
->phys_addr
);
502 tx_ring
->desc_head
= NULL
;
505 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
506 rds_ring
= &recv_ctx
->rds_rings
[ring
];
508 if (rds_ring
->desc_head
!= NULL
) {
509 dma_free_coherent(&adapter
->pdev
->dev
,
510 RCV_DESC_RINGSIZE(rds_ring
),
512 rds_ring
->phys_addr
);
513 rds_ring
->desc_head
= NULL
;
517 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
518 sds_ring
= &recv_ctx
->sds_rings
[ring
];
520 if (sds_ring
->desc_head
!= NULL
) {
521 dma_free_coherent(&adapter
->pdev
->dev
,
522 STATUS_DESC_RINGSIZE(sds_ring
),
524 sds_ring
->phys_addr
);
525 sds_ring
->desc_head
= NULL
;
531 /* Get MAC address of a NIC partition */
532 int qlcnic_get_mac_address(struct qlcnic_adapter
*adapter
, u8
*mac
)
537 arg1
= adapter
->ahw
->pci_func
| BIT_8
;
538 err
= qlcnic_issue_cmd(adapter
,
539 adapter
->ahw
->pci_func
,
540 adapter
->fw_hal_version
,
544 QLCNIC_CDRP_CMD_MAC_ADDRESS
);
546 if (err
== QLCNIC_RCODE_SUCCESS
)
547 qlcnic_fetch_mac(adapter
, QLCNIC_ARG1_CRB_OFFSET
,
548 QLCNIC_ARG2_CRB_OFFSET
, 0, mac
);
550 dev_err(&adapter
->pdev
->dev
,
551 "Failed to get mac address%d\n", err
);
558 /* Get info of a NIC partition */
559 int qlcnic_get_nic_info(struct qlcnic_adapter
*adapter
,
560 struct qlcnic_info
*npar_info
, u8 func_id
)
563 dma_addr_t nic_dma_t
;
564 struct qlcnic_info
*nic_info
;
566 size_t nic_size
= sizeof(struct qlcnic_info
);
568 nic_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, nic_size
,
569 &nic_dma_t
, GFP_KERNEL
);
572 memset(nic_info_addr
, 0, nic_size
);
574 nic_info
= (struct qlcnic_info
*) nic_info_addr
;
575 err
= qlcnic_issue_cmd(adapter
,
576 adapter
->ahw
->pci_func
,
577 adapter
->fw_hal_version
,
580 (func_id
<< 16 | nic_size
),
581 QLCNIC_CDRP_CMD_GET_NIC_INFO
);
583 if (err
== QLCNIC_RCODE_SUCCESS
) {
584 npar_info
->pci_func
= le16_to_cpu(nic_info
->pci_func
);
585 npar_info
->op_mode
= le16_to_cpu(nic_info
->op_mode
);
586 npar_info
->phys_port
= le16_to_cpu(nic_info
->phys_port
);
587 npar_info
->switch_mode
= le16_to_cpu(nic_info
->switch_mode
);
588 npar_info
->max_tx_ques
= le16_to_cpu(nic_info
->max_tx_ques
);
589 npar_info
->max_rx_ques
= le16_to_cpu(nic_info
->max_rx_ques
);
590 npar_info
->min_tx_bw
= le16_to_cpu(nic_info
->min_tx_bw
);
591 npar_info
->max_tx_bw
= le16_to_cpu(nic_info
->max_tx_bw
);
592 npar_info
->capabilities
= le32_to_cpu(nic_info
->capabilities
);
593 npar_info
->max_mtu
= le16_to_cpu(nic_info
->max_mtu
);
595 dev_info(&adapter
->pdev
->dev
,
596 "phy port: %d switch_mode: %d,\n"
597 "\tmax_tx_q: %d max_rx_q: %d min_tx_bw: 0x%x,\n"
598 "\tmax_tx_bw: 0x%x max_mtu:0x%x, capabilities: 0x%x\n",
599 npar_info
->phys_port
, npar_info
->switch_mode
,
600 npar_info
->max_tx_ques
, npar_info
->max_rx_ques
,
601 npar_info
->min_tx_bw
, npar_info
->max_tx_bw
,
602 npar_info
->max_mtu
, npar_info
->capabilities
);
604 dev_err(&adapter
->pdev
->dev
,
605 "Failed to get nic info%d\n", err
);
609 dma_free_coherent(&adapter
->pdev
->dev
, nic_size
, nic_info_addr
,
614 /* Configure a NIC partition */
615 int qlcnic_set_nic_info(struct qlcnic_adapter
*adapter
, struct qlcnic_info
*nic
)
618 dma_addr_t nic_dma_t
;
620 struct qlcnic_info
*nic_info
;
621 size_t nic_size
= sizeof(struct qlcnic_info
);
623 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
626 nic_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, nic_size
,
627 &nic_dma_t
, GFP_KERNEL
);
631 memset(nic_info_addr
, 0, nic_size
);
632 nic_info
= (struct qlcnic_info
*)nic_info_addr
;
634 nic_info
->pci_func
= cpu_to_le16(nic
->pci_func
);
635 nic_info
->op_mode
= cpu_to_le16(nic
->op_mode
);
636 nic_info
->phys_port
= cpu_to_le16(nic
->phys_port
);
637 nic_info
->switch_mode
= cpu_to_le16(nic
->switch_mode
);
638 nic_info
->capabilities
= cpu_to_le32(nic
->capabilities
);
639 nic_info
->max_mac_filters
= nic
->max_mac_filters
;
640 nic_info
->max_tx_ques
= cpu_to_le16(nic
->max_tx_ques
);
641 nic_info
->max_rx_ques
= cpu_to_le16(nic
->max_rx_ques
);
642 nic_info
->min_tx_bw
= cpu_to_le16(nic
->min_tx_bw
);
643 nic_info
->max_tx_bw
= cpu_to_le16(nic
->max_tx_bw
);
645 err
= qlcnic_issue_cmd(adapter
,
646 adapter
->ahw
->pci_func
,
647 adapter
->fw_hal_version
,
650 ((nic
->pci_func
<< 16) | nic_size
),
651 QLCNIC_CDRP_CMD_SET_NIC_INFO
);
653 if (err
!= QLCNIC_RCODE_SUCCESS
) {
654 dev_err(&adapter
->pdev
->dev
,
655 "Failed to set nic info%d\n", err
);
659 dma_free_coherent(&adapter
->pdev
->dev
, nic_size
, nic_info_addr
,
664 /* Get PCI Info of a partition */
665 int qlcnic_get_pci_info(struct qlcnic_adapter
*adapter
,
666 struct qlcnic_pci_info
*pci_info
)
669 dma_addr_t pci_info_dma_t
;
670 struct qlcnic_pci_info
*npar
;
672 size_t npar_size
= sizeof(struct qlcnic_pci_info
);
673 size_t pci_size
= npar_size
* QLCNIC_MAX_PCI_FUNC
;
675 pci_info_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, pci_size
,
676 &pci_info_dma_t
, GFP_KERNEL
);
679 memset(pci_info_addr
, 0, pci_size
);
681 npar
= (struct qlcnic_pci_info
*) pci_info_addr
;
682 err
= qlcnic_issue_cmd(adapter
,
683 adapter
->ahw
->pci_func
,
684 adapter
->fw_hal_version
,
688 QLCNIC_CDRP_CMD_GET_PCI_INFO
);
690 if (err
== QLCNIC_RCODE_SUCCESS
) {
691 for (i
= 0; i
< QLCNIC_MAX_PCI_FUNC
; i
++, npar
++, pci_info
++) {
692 pci_info
->id
= le16_to_cpu(npar
->id
);
693 pci_info
->active
= le16_to_cpu(npar
->active
);
694 pci_info
->type
= le16_to_cpu(npar
->type
);
695 pci_info
->default_port
=
696 le16_to_cpu(npar
->default_port
);
697 pci_info
->tx_min_bw
=
698 le16_to_cpu(npar
->tx_min_bw
);
699 pci_info
->tx_max_bw
=
700 le16_to_cpu(npar
->tx_max_bw
);
701 memcpy(pci_info
->mac
, npar
->mac
, ETH_ALEN
);
704 dev_err(&adapter
->pdev
->dev
,
705 "Failed to get PCI Info%d\n", err
);
709 dma_free_coherent(&adapter
->pdev
->dev
, pci_size
, pci_info_addr
,
714 /* Configure eSwitch for port mirroring */
715 int qlcnic_config_port_mirroring(struct qlcnic_adapter
*adapter
, u8 id
,
716 u8 enable_mirroring
, u8 pci_func
)
721 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
||
722 !(adapter
->eswitch
[id
].flags
& QLCNIC_SWITCH_ENABLE
))
725 arg1
= id
| (enable_mirroring
? BIT_4
: 0);
726 arg1
|= pci_func
<< 8;
728 err
= qlcnic_issue_cmd(adapter
,
729 adapter
->ahw
->pci_func
,
730 adapter
->fw_hal_version
,
734 QLCNIC_CDRP_CMD_SET_PORTMIRRORING
);
736 if (err
!= QLCNIC_RCODE_SUCCESS
) {
737 dev_err(&adapter
->pdev
->dev
,
738 "Failed to configure port mirroring%d on eswitch:%d\n",
741 dev_info(&adapter
->pdev
->dev
,
742 "Configured eSwitch %d for port mirroring:%d\n",
749 int qlcnic_get_port_stats(struct qlcnic_adapter
*adapter
, const u8 func
,
750 const u8 rx_tx
, struct __qlcnic_esw_statistics
*esw_stats
) {
752 size_t stats_size
= sizeof(struct __qlcnic_esw_statistics
);
753 struct __qlcnic_esw_statistics
*stats
;
754 dma_addr_t stats_dma_t
;
759 if (esw_stats
== NULL
)
762 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
&&
763 func
!= adapter
->ahw
->pci_func
) {
764 dev_err(&adapter
->pdev
->dev
,
765 "Not privilege to query stats for func=%d", func
);
769 stats_addr
= dma_alloc_coherent(&adapter
->pdev
->dev
, stats_size
,
770 &stats_dma_t
, GFP_KERNEL
);
772 dev_err(&adapter
->pdev
->dev
, "Unable to allocate memory\n");
775 memset(stats_addr
, 0, stats_size
);
777 arg1
= func
| QLCNIC_STATS_VERSION
<< 8 | QLCNIC_STATS_PORT
<< 12;
778 arg1
|= rx_tx
<< 15 | stats_size
<< 16;
780 err
= qlcnic_issue_cmd(adapter
,
781 adapter
->ahw
->pci_func
,
782 adapter
->fw_hal_version
,
786 QLCNIC_CDRP_CMD_GET_ESWITCH_STATS
);
789 stats
= (struct __qlcnic_esw_statistics
*)stats_addr
;
790 esw_stats
->context_id
= le16_to_cpu(stats
->context_id
);
791 esw_stats
->version
= le16_to_cpu(stats
->version
);
792 esw_stats
->size
= le16_to_cpu(stats
->size
);
793 esw_stats
->multicast_frames
=
794 le64_to_cpu(stats
->multicast_frames
);
795 esw_stats
->broadcast_frames
=
796 le64_to_cpu(stats
->broadcast_frames
);
797 esw_stats
->unicast_frames
= le64_to_cpu(stats
->unicast_frames
);
798 esw_stats
->dropped_frames
= le64_to_cpu(stats
->dropped_frames
);
799 esw_stats
->local_frames
= le64_to_cpu(stats
->local_frames
);
800 esw_stats
->errors
= le64_to_cpu(stats
->errors
);
801 esw_stats
->numbytes
= le64_to_cpu(stats
->numbytes
);
804 dma_free_coherent(&adapter
->pdev
->dev
, stats_size
, stats_addr
,
809 int qlcnic_get_eswitch_stats(struct qlcnic_adapter
*adapter
, const u8 eswitch
,
810 const u8 rx_tx
, struct __qlcnic_esw_statistics
*esw_stats
) {
812 struct __qlcnic_esw_statistics port_stats
;
816 if (esw_stats
== NULL
)
818 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
820 if (adapter
->npars
== NULL
)
823 memset(esw_stats
, 0, sizeof(u64
));
824 esw_stats
->unicast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
825 esw_stats
->multicast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
826 esw_stats
->broadcast_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
827 esw_stats
->dropped_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
828 esw_stats
->errors
= QLCNIC_ESW_STATS_NOT_AVAIL
;
829 esw_stats
->local_frames
= QLCNIC_ESW_STATS_NOT_AVAIL
;
830 esw_stats
->numbytes
= QLCNIC_ESW_STATS_NOT_AVAIL
;
831 esw_stats
->context_id
= eswitch
;
833 for (i
= 0; i
< QLCNIC_MAX_PCI_FUNC
; i
++) {
834 if (adapter
->npars
[i
].phy_port
!= eswitch
)
837 memset(&port_stats
, 0, sizeof(struct __qlcnic_esw_statistics
));
838 if (qlcnic_get_port_stats(adapter
, i
, rx_tx
, &port_stats
))
841 esw_stats
->size
= port_stats
.size
;
842 esw_stats
->version
= port_stats
.version
;
843 QLCNIC_ADD_ESW_STATS(esw_stats
->unicast_frames
,
844 port_stats
.unicast_frames
);
845 QLCNIC_ADD_ESW_STATS(esw_stats
->multicast_frames
,
846 port_stats
.multicast_frames
);
847 QLCNIC_ADD_ESW_STATS(esw_stats
->broadcast_frames
,
848 port_stats
.broadcast_frames
);
849 QLCNIC_ADD_ESW_STATS(esw_stats
->dropped_frames
,
850 port_stats
.dropped_frames
);
851 QLCNIC_ADD_ESW_STATS(esw_stats
->errors
,
853 QLCNIC_ADD_ESW_STATS(esw_stats
->local_frames
,
854 port_stats
.local_frames
);
855 QLCNIC_ADD_ESW_STATS(esw_stats
->numbytes
,
856 port_stats
.numbytes
);
862 int qlcnic_clear_esw_stats(struct qlcnic_adapter
*adapter
, const u8 func_esw
,
863 const u8 port
, const u8 rx_tx
)
868 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
871 if (func_esw
== QLCNIC_STATS_PORT
) {
872 if (port
>= QLCNIC_MAX_PCI_FUNC
)
874 } else if (func_esw
== QLCNIC_STATS_ESWITCH
) {
875 if (port
>= QLCNIC_NIU_MAX_XG_PORTS
)
881 if (rx_tx
> QLCNIC_QUERY_TX_COUNTER
)
884 arg1
= port
| QLCNIC_STATS_VERSION
<< 8 | func_esw
<< 12;
885 arg1
|= BIT_14
| rx_tx
<< 15;
887 return qlcnic_issue_cmd(adapter
,
888 adapter
->ahw
->pci_func
,
889 adapter
->fw_hal_version
,
893 QLCNIC_CDRP_CMD_GET_ESWITCH_STATS
);
896 dev_err(&adapter
->pdev
->dev
, "Invalid argument func_esw=%d port=%d"
897 "rx_ctx=%d\n", func_esw
, port
, rx_tx
);
902 __qlcnic_get_eswitch_port_config(struct qlcnic_adapter
*adapter
,
903 u32
*arg1
, u32
*arg2
)
907 pci_func
= (*arg1
>> 8);
908 err
= qlcnic_issue_cmd(adapter
,
909 adapter
->ahw
->pci_func
,
910 adapter
->fw_hal_version
,
914 QLCNIC_CDRP_CMD_GET_ESWITCH_PORT_CONFIG
);
916 if (err
== QLCNIC_RCODE_SUCCESS
) {
917 *arg1
= QLCRD32(adapter
, QLCNIC_ARG1_CRB_OFFSET
);
918 *arg2
= QLCRD32(adapter
, QLCNIC_ARG2_CRB_OFFSET
);
919 dev_info(&adapter
->pdev
->dev
,
920 "eSwitch port config for pci func %d\n", pci_func
);
922 dev_err(&adapter
->pdev
->dev
,
923 "Failed to get eswitch port config for pci func %d\n",
928 /* Configure eSwitch port
929 op_mode = 0 for setting default port behavior
930 op_mode = 1 for setting vlan id
931 op_mode = 2 for deleting vlan id
932 op_type = 0 for vlan_id
933 op_type = 1 for port vlan_id
935 int qlcnic_config_switch_port(struct qlcnic_adapter
*adapter
,
936 struct qlcnic_esw_func_cfg
*esw_cfg
)
942 if (adapter
->op_mode
!= QLCNIC_MGMT_FUNC
)
944 pci_func
= esw_cfg
->pci_func
;
945 arg1
= (adapter
->npars
[pci_func
].phy_port
& BIT_0
);
946 arg1
|= (pci_func
<< 8);
948 if (__qlcnic_get_eswitch_port_config(adapter
, &arg1
, &arg2
))
950 arg1
&= ~(0x0ff << 8);
951 arg1
|= (pci_func
<< 8);
952 arg1
&= ~(BIT_2
| BIT_3
);
953 switch (esw_cfg
->op_mode
) {
954 case QLCNIC_PORT_DEFAULTS
:
955 arg1
|= (BIT_4
| BIT_6
| BIT_7
);
956 arg2
|= (BIT_0
| BIT_1
);
957 if (adapter
->capabilities
& QLCNIC_FW_CAPABILITY_TSO
)
958 arg2
|= (BIT_2
| BIT_3
);
959 if (!(esw_cfg
->discard_tagged
))
961 if (!(esw_cfg
->promisc_mode
))
963 if (!(esw_cfg
->mac_override
))
965 if (!(esw_cfg
->mac_anti_spoof
))
967 if (!(esw_cfg
->offload_flags
& BIT_0
))
968 arg2
&= ~(BIT_1
| BIT_2
| BIT_3
);
969 if (!(esw_cfg
->offload_flags
& BIT_1
))
971 if (!(esw_cfg
->offload_flags
& BIT_2
))
974 case QLCNIC_ADD_VLAN
:
975 arg1
|= (BIT_2
| BIT_5
);
976 arg1
|= (esw_cfg
->vlan_id
<< 16);
978 case QLCNIC_DEL_VLAN
:
979 arg1
|= (BIT_3
| BIT_5
);
980 arg1
&= ~(0x0ffff << 16);
986 err
= qlcnic_issue_cmd(adapter
,
987 adapter
->ahw
->pci_func
,
988 adapter
->fw_hal_version
,
992 QLCNIC_CDRP_CMD_CONFIGURE_ESWITCH
);
994 if (err
!= QLCNIC_RCODE_SUCCESS
) {
995 dev_err(&adapter
->pdev
->dev
,
996 "Failed to configure eswitch pci func %d\n", pci_func
);
998 dev_info(&adapter
->pdev
->dev
,
999 "Configured eSwitch for pci func %d\n", pci_func
);
1006 qlcnic_get_eswitch_port_config(struct qlcnic_adapter
*adapter
,
1007 struct qlcnic_esw_func_cfg
*esw_cfg
)
1011 if (adapter
->op_mode
== QLCNIC_MGMT_FUNC
)
1012 phy_port
= adapter
->npars
[esw_cfg
->pci_func
].phy_port
;
1014 phy_port
= adapter
->physical_port
;
1016 arg1
|= (esw_cfg
->pci_func
<< 8);
1017 if (__qlcnic_get_eswitch_port_config(adapter
, &arg1
, &arg2
))
1020 esw_cfg
->discard_tagged
= !!(arg1
& BIT_4
);
1021 esw_cfg
->host_vlan_tag
= !!(arg1
& BIT_5
);
1022 esw_cfg
->promisc_mode
= !!(arg1
& BIT_6
);
1023 esw_cfg
->mac_override
= !!(arg1
& BIT_7
);
1024 esw_cfg
->vlan_id
= LSW(arg1
>> 16);
1025 esw_cfg
->mac_anti_spoof
= (arg2
& 0x1);
1026 esw_cfg
->offload_flags
= ((arg2
>> 1) & 0x7);