2 * Copyright (C) 2005 - 2011 Emulex
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
10 * Contact Information:
11 * linux-drivers@emulex.com
15 * Costa Mesa, CA 92626
18 #include <linux/module.h>
22 static struct be_cmd_priv_map cmd_priv_map
[] = {
24 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
,
26 BE_PRIV_LNKMGMT
| BE_PRIV_VHADM
|
27 BE_PRIV_DEVCFG
| BE_PRIV_DEVSEC
30 OPCODE_COMMON_GET_FLOW_CONTROL
,
32 BE_PRIV_LNKQUERY
| BE_PRIV_VHADM
|
33 BE_PRIV_DEVCFG
| BE_PRIV_DEVSEC
36 OPCODE_COMMON_SET_FLOW_CONTROL
,
38 BE_PRIV_LNKMGMT
| BE_PRIV_VHADM
|
39 BE_PRIV_DEVCFG
| BE_PRIV_DEVSEC
42 OPCODE_ETH_GET_PPORT_STATS
,
44 BE_PRIV_LNKMGMT
| BE_PRIV_VHADM
|
45 BE_PRIV_DEVCFG
| BE_PRIV_DEVSEC
48 OPCODE_COMMON_GET_PHY_DETAILS
,
50 BE_PRIV_LNKMGMT
| BE_PRIV_VHADM
|
51 BE_PRIV_DEVCFG
| BE_PRIV_DEVSEC
55 static bool be_cmd_allowed(struct be_adapter
*adapter
, u8 opcode
,
59 int num_entries
= sizeof(cmd_priv_map
)/sizeof(struct be_cmd_priv_map
);
60 u32 cmd_privileges
= adapter
->cmd_privileges
;
62 for (i
= 0; i
< num_entries
; i
++)
63 if (opcode
== cmd_priv_map
[i
].opcode
&&
64 subsystem
== cmd_priv_map
[i
].subsystem
)
65 if (!(cmd_privileges
& cmd_priv_map
[i
].priv_mask
))
71 static inline void *embedded_payload(struct be_mcc_wrb
*wrb
)
73 return wrb
->payload
.embedded_payload
;
76 static void be_mcc_notify(struct be_adapter
*adapter
)
78 struct be_queue_info
*mccq
= &adapter
->mcc_obj
.q
;
81 if (be_error(adapter
))
84 val
|= mccq
->id
& DB_MCCQ_RING_ID_MASK
;
85 val
|= 1 << DB_MCCQ_NUM_POSTED_SHIFT
;
88 iowrite32(val
, adapter
->db
+ DB_MCCQ_OFFSET
);
91 /* To check if valid bit is set, check the entire word as we don't know
92 * the endianness of the data (old entry is host endian while a new entry is
94 static inline bool be_mcc_compl_is_new(struct be_mcc_compl
*compl)
96 if (compl->flags
!= 0) {
97 compl->flags
= le32_to_cpu(compl->flags
);
98 BUG_ON((compl->flags
& CQE_FLAGS_VALID_MASK
) == 0);
105 /* Need to reset the entire word that houses the valid bit */
106 static inline void be_mcc_compl_use(struct be_mcc_compl
*compl)
111 static struct be_cmd_resp_hdr
*be_decode_resp_hdr(u32 tag0
, u32 tag1
)
116 addr
= ((addr
<< 16) << 16) | tag0
;
120 static int be_mcc_compl_process(struct be_adapter
*adapter
,
121 struct be_mcc_compl
*compl)
123 u16 compl_status
, extd_status
;
124 struct be_cmd_resp_hdr
*resp_hdr
;
125 u8 opcode
= 0, subsystem
= 0;
127 /* Just swap the status to host endian; mcc tag is opaquely copied
129 be_dws_le_to_cpu(compl, 4);
131 compl_status
= (compl->status
>> CQE_STATUS_COMPL_SHIFT
) &
132 CQE_STATUS_COMPL_MASK
;
134 resp_hdr
= be_decode_resp_hdr(compl->tag0
, compl->tag1
);
137 opcode
= resp_hdr
->opcode
;
138 subsystem
= resp_hdr
->subsystem
;
141 if (((opcode
== OPCODE_COMMON_WRITE_FLASHROM
) ||
142 (opcode
== OPCODE_COMMON_WRITE_OBJECT
)) &&
143 (subsystem
== CMD_SUBSYSTEM_COMMON
)) {
144 adapter
->flash_status
= compl_status
;
145 complete(&adapter
->flash_compl
);
148 if (compl_status
== MCC_STATUS_SUCCESS
) {
149 if (((opcode
== OPCODE_ETH_GET_STATISTICS
) ||
150 (opcode
== OPCODE_ETH_GET_PPORT_STATS
)) &&
151 (subsystem
== CMD_SUBSYSTEM_ETH
)) {
152 be_parse_stats(adapter
);
153 adapter
->stats_cmd_sent
= false;
155 if (opcode
== OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES
&&
156 subsystem
== CMD_SUBSYSTEM_COMMON
) {
157 struct be_cmd_resp_get_cntl_addnl_attribs
*resp
=
159 adapter
->drv_stats
.be_on_die_temperature
=
160 resp
->on_die_temperature
;
163 if (opcode
== OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES
)
164 adapter
->be_get_temp_freq
= 0;
166 if (compl_status
== MCC_STATUS_NOT_SUPPORTED
||
167 compl_status
== MCC_STATUS_ILLEGAL_REQUEST
)
170 if (compl_status
== MCC_STATUS_UNAUTHORIZED_REQUEST
) {
171 dev_warn(&adapter
->pdev
->dev
,
172 "VF is not privileged to issue opcode %d-%d\n",
175 extd_status
= (compl->status
>> CQE_STATUS_EXTD_SHIFT
) &
176 CQE_STATUS_EXTD_MASK
;
177 dev_err(&adapter
->pdev
->dev
,
178 "opcode %d-%d failed:status %d-%d\n",
179 opcode
, subsystem
, compl_status
, extd_status
);
186 /* Link state evt is a string of bytes; no need for endian swapping */
187 static void be_async_link_state_process(struct be_adapter
*adapter
,
188 struct be_async_event_link_state
*evt
)
190 /* When link status changes, link speed must be re-queried from FW */
191 adapter
->phy
.link_speed
= -1;
193 /* Ignore physical link event */
194 if (lancer_chip(adapter
) &&
195 !(evt
->port_link_status
& LOGICAL_LINK_STATUS_MASK
))
198 /* For the initial link status do not rely on the ASYNC event as
199 * it may not be received in some cases.
201 if (adapter
->flags
& BE_FLAGS_LINK_STATUS_INIT
)
202 be_link_status_update(adapter
, evt
->port_link_status
);
205 /* Grp5 CoS Priority evt */
206 static void be_async_grp5_cos_priority_process(struct be_adapter
*adapter
,
207 struct be_async_event_grp5_cos_priority
*evt
)
210 adapter
->vlan_prio_bmap
= evt
->available_priority_bmap
;
211 adapter
->recommended_prio
&= ~VLAN_PRIO_MASK
;
212 adapter
->recommended_prio
=
213 evt
->reco_default_priority
<< VLAN_PRIO_SHIFT
;
217 /* Grp5 QOS Speed evt: qos_link_speed is in units of 10 Mbps */
218 static void be_async_grp5_qos_speed_process(struct be_adapter
*adapter
,
219 struct be_async_event_grp5_qos_link_speed
*evt
)
221 if (adapter
->phy
.link_speed
>= 0 &&
222 evt
->physical_port
== adapter
->port_num
)
223 adapter
->phy
.link_speed
= le16_to_cpu(evt
->qos_link_speed
) * 10;
227 static void be_async_grp5_pvid_state_process(struct be_adapter
*adapter
,
228 struct be_async_event_grp5_pvid_state
*evt
)
231 adapter
->pvid
= le16_to_cpu(evt
->tag
) & VLAN_VID_MASK
;
236 static void be_async_grp5_evt_process(struct be_adapter
*adapter
,
237 u32 trailer
, struct be_mcc_compl
*evt
)
241 event_type
= (trailer
>> ASYNC_TRAILER_EVENT_TYPE_SHIFT
) &
242 ASYNC_TRAILER_EVENT_TYPE_MASK
;
244 switch (event_type
) {
245 case ASYNC_EVENT_COS_PRIORITY
:
246 be_async_grp5_cos_priority_process(adapter
,
247 (struct be_async_event_grp5_cos_priority
*)evt
);
249 case ASYNC_EVENT_QOS_SPEED
:
250 be_async_grp5_qos_speed_process(adapter
,
251 (struct be_async_event_grp5_qos_link_speed
*)evt
);
253 case ASYNC_EVENT_PVID_STATE
:
254 be_async_grp5_pvid_state_process(adapter
,
255 (struct be_async_event_grp5_pvid_state
*)evt
);
258 dev_warn(&adapter
->pdev
->dev
, "Unknown grp5 event!\n");
263 static inline bool is_link_state_evt(u32 trailer
)
265 return ((trailer
>> ASYNC_TRAILER_EVENT_CODE_SHIFT
) &
266 ASYNC_TRAILER_EVENT_CODE_MASK
) ==
267 ASYNC_EVENT_CODE_LINK_STATE
;
270 static inline bool is_grp5_evt(u32 trailer
)
272 return (((trailer
>> ASYNC_TRAILER_EVENT_CODE_SHIFT
) &
273 ASYNC_TRAILER_EVENT_CODE_MASK
) ==
274 ASYNC_EVENT_CODE_GRP_5
);
277 static struct be_mcc_compl
*be_mcc_compl_get(struct be_adapter
*adapter
)
279 struct be_queue_info
*mcc_cq
= &adapter
->mcc_obj
.cq
;
280 struct be_mcc_compl
*compl = queue_tail_node(mcc_cq
);
282 if (be_mcc_compl_is_new(compl)) {
283 queue_tail_inc(mcc_cq
);
289 void be_async_mcc_enable(struct be_adapter
*adapter
)
291 spin_lock_bh(&adapter
->mcc_cq_lock
);
293 be_cq_notify(adapter
, adapter
->mcc_obj
.cq
.id
, true, 0);
294 adapter
->mcc_obj
.rearm_cq
= true;
296 spin_unlock_bh(&adapter
->mcc_cq_lock
);
299 void be_async_mcc_disable(struct be_adapter
*adapter
)
301 adapter
->mcc_obj
.rearm_cq
= false;
304 int be_process_mcc(struct be_adapter
*adapter
)
306 struct be_mcc_compl
*compl;
307 int num
= 0, status
= 0;
308 struct be_mcc_obj
*mcc_obj
= &adapter
->mcc_obj
;
310 spin_lock(&adapter
->mcc_cq_lock
);
311 while ((compl = be_mcc_compl_get(adapter
))) {
312 if (compl->flags
& CQE_FLAGS_ASYNC_MASK
) {
313 /* Interpret flags as an async trailer */
314 if (is_link_state_evt(compl->flags
))
315 be_async_link_state_process(adapter
,
316 (struct be_async_event_link_state
*) compl);
317 else if (is_grp5_evt(compl->flags
))
318 be_async_grp5_evt_process(adapter
,
319 compl->flags
, compl);
320 } else if (compl->flags
& CQE_FLAGS_COMPLETED_MASK
) {
321 status
= be_mcc_compl_process(adapter
, compl);
322 atomic_dec(&mcc_obj
->q
.used
);
324 be_mcc_compl_use(compl);
329 be_cq_notify(adapter
, mcc_obj
->cq
.id
, mcc_obj
->rearm_cq
, num
);
331 spin_unlock(&adapter
->mcc_cq_lock
);
335 /* Wait till no more pending mcc requests are present */
336 static int be_mcc_wait_compl(struct be_adapter
*adapter
)
338 #define mcc_timeout 120000 /* 12s timeout */
340 struct be_mcc_obj
*mcc_obj
= &adapter
->mcc_obj
;
342 for (i
= 0; i
< mcc_timeout
; i
++) {
343 if (be_error(adapter
))
347 status
= be_process_mcc(adapter
);
350 if (atomic_read(&mcc_obj
->q
.used
) == 0)
354 if (i
== mcc_timeout
) {
355 dev_err(&adapter
->pdev
->dev
, "FW not responding\n");
356 adapter
->fw_timeout
= true;
362 /* Notify MCC requests and wait for completion */
363 static int be_mcc_notify_wait(struct be_adapter
*adapter
)
366 struct be_mcc_wrb
*wrb
;
367 struct be_mcc_obj
*mcc_obj
= &adapter
->mcc_obj
;
368 u16 index
= mcc_obj
->q
.head
;
369 struct be_cmd_resp_hdr
*resp
;
371 index_dec(&index
, mcc_obj
->q
.len
);
372 wrb
= queue_index_node(&mcc_obj
->q
, index
);
374 resp
= be_decode_resp_hdr(wrb
->tag0
, wrb
->tag1
);
376 be_mcc_notify(adapter
);
378 status
= be_mcc_wait_compl(adapter
);
382 status
= resp
->status
;
387 static int be_mbox_db_ready_wait(struct be_adapter
*adapter
, void __iomem
*db
)
393 if (be_error(adapter
))
396 ready
= ioread32(db
);
397 if (ready
== 0xffffffff)
400 ready
&= MPU_MAILBOX_DB_RDY_MASK
;
405 dev_err(&adapter
->pdev
->dev
, "FW not responding\n");
406 adapter
->fw_timeout
= true;
407 be_detect_error(adapter
);
419 * Insert the mailbox address into the doorbell in two steps
420 * Polls on the mbox doorbell till a command completion (or a timeout) occurs
422 static int be_mbox_notify_wait(struct be_adapter
*adapter
)
426 void __iomem
*db
= adapter
->db
+ MPU_MAILBOX_DB_OFFSET
;
427 struct be_dma_mem
*mbox_mem
= &adapter
->mbox_mem
;
428 struct be_mcc_mailbox
*mbox
= mbox_mem
->va
;
429 struct be_mcc_compl
*compl = &mbox
->compl;
431 /* wait for ready to be set */
432 status
= be_mbox_db_ready_wait(adapter
, db
);
436 val
|= MPU_MAILBOX_DB_HI_MASK
;
437 /* at bits 2 - 31 place mbox dma addr msb bits 34 - 63 */
438 val
|= (upper_32_bits(mbox_mem
->dma
) >> 2) << 2;
441 /* wait for ready to be set */
442 status
= be_mbox_db_ready_wait(adapter
, db
);
447 /* at bits 2 - 31 place mbox dma addr lsb bits 4 - 33 */
448 val
|= (u32
)(mbox_mem
->dma
>> 4) << 2;
451 status
= be_mbox_db_ready_wait(adapter
, db
);
455 /* A cq entry has been made now */
456 if (be_mcc_compl_is_new(compl)) {
457 status
= be_mcc_compl_process(adapter
, &mbox
->compl);
458 be_mcc_compl_use(compl);
462 dev_err(&adapter
->pdev
->dev
, "invalid mailbox completion\n");
468 static int be_POST_stage_get(struct be_adapter
*adapter
, u16
*stage
)
471 u32 reg
= skyhawk_chip(adapter
) ? SLIPORT_SEMAPHORE_OFFSET_SH
:
472 SLIPORT_SEMAPHORE_OFFSET_BE
;
474 pci_read_config_dword(adapter
->pdev
, reg
, &sem
);
475 *stage
= sem
& POST_STAGE_MASK
;
477 if ((sem
>> POST_ERR_SHIFT
) & POST_ERR_MASK
)
483 int lancer_wait_ready(struct be_adapter
*adapter
)
485 #define SLIPORT_READY_TIMEOUT 30
489 for (i
= 0; i
< SLIPORT_READY_TIMEOUT
; i
++) {
490 sliport_status
= ioread32(adapter
->db
+ SLIPORT_STATUS_OFFSET
);
491 if (sliport_status
& SLIPORT_STATUS_RDY_MASK
)
497 if (i
== SLIPORT_READY_TIMEOUT
)
503 static bool lancer_provisioning_error(struct be_adapter
*adapter
)
505 u32 sliport_status
= 0, sliport_err1
= 0, sliport_err2
= 0;
506 sliport_status
= ioread32(adapter
->db
+ SLIPORT_STATUS_OFFSET
);
507 if (sliport_status
& SLIPORT_STATUS_ERR_MASK
) {
508 sliport_err1
= ioread32(adapter
->db
+
509 SLIPORT_ERROR1_OFFSET
);
510 sliport_err2
= ioread32(adapter
->db
+
511 SLIPORT_ERROR2_OFFSET
);
513 if (sliport_err1
== SLIPORT_ERROR_NO_RESOURCE1
&&
514 sliport_err2
== SLIPORT_ERROR_NO_RESOURCE2
)
520 int lancer_test_and_set_rdy_state(struct be_adapter
*adapter
)
523 u32 sliport_status
, err
, reset_needed
;
526 resource_error
= lancer_provisioning_error(adapter
);
530 status
= lancer_wait_ready(adapter
);
532 sliport_status
= ioread32(adapter
->db
+ SLIPORT_STATUS_OFFSET
);
533 err
= sliport_status
& SLIPORT_STATUS_ERR_MASK
;
534 reset_needed
= sliport_status
& SLIPORT_STATUS_RN_MASK
;
535 if (err
&& reset_needed
) {
536 iowrite32(SLI_PORT_CONTROL_IP_MASK
,
537 adapter
->db
+ SLIPORT_CONTROL_OFFSET
);
539 /* check adapter has corrected the error */
540 status
= lancer_wait_ready(adapter
);
541 sliport_status
= ioread32(adapter
->db
+
542 SLIPORT_STATUS_OFFSET
);
543 sliport_status
&= (SLIPORT_STATUS_ERR_MASK
|
544 SLIPORT_STATUS_RN_MASK
);
545 if (status
|| sliport_status
)
547 } else if (err
|| reset_needed
) {
551 /* Stop error recovery if error is not recoverable.
552 * No resource error is temporary errors and will go away
553 * when PF provisions resources.
555 resource_error
= lancer_provisioning_error(adapter
);
556 if (status
== -1 && !resource_error
)
557 adapter
->eeh_error
= true;
562 int be_fw_wait_ready(struct be_adapter
*adapter
)
565 int status
, timeout
= 0;
566 struct device
*dev
= &adapter
->pdev
->dev
;
568 if (lancer_chip(adapter
)) {
569 status
= lancer_wait_ready(adapter
);
574 status
= be_POST_stage_get(adapter
, &stage
);
576 dev_err(dev
, "POST error; stage=0x%x\n", stage
);
578 } else if (stage
!= POST_STAGE_ARMFW_RDY
) {
579 if (msleep_interruptible(2000)) {
580 dev_err(dev
, "Waiting for POST aborted\n");
587 } while (timeout
< 60);
589 dev_err(dev
, "POST timeout; stage=0x%x\n", stage
);
594 static inline struct be_sge
*nonembedded_sgl(struct be_mcc_wrb
*wrb
)
596 return &wrb
->payload
.sgl
[0];
600 /* Don't touch the hdr after it's prepared */
601 /* mem will be NULL for embedded commands */
602 static void be_wrb_cmd_hdr_prepare(struct be_cmd_req_hdr
*req_hdr
,
603 u8 subsystem
, u8 opcode
, int cmd_len
,
604 struct be_mcc_wrb
*wrb
, struct be_dma_mem
*mem
)
607 unsigned long addr
= (unsigned long)req_hdr
;
610 req_hdr
->opcode
= opcode
;
611 req_hdr
->subsystem
= subsystem
;
612 req_hdr
->request_length
= cpu_to_le32(cmd_len
- sizeof(*req_hdr
));
613 req_hdr
->version
= 0;
615 wrb
->tag0
= req_addr
& 0xFFFFFFFF;
616 wrb
->tag1
= upper_32_bits(req_addr
);
618 wrb
->payload_length
= cmd_len
;
620 wrb
->embedded
|= (1 & MCC_WRB_SGE_CNT_MASK
) <<
621 MCC_WRB_SGE_CNT_SHIFT
;
622 sge
= nonembedded_sgl(wrb
);
623 sge
->pa_hi
= cpu_to_le32(upper_32_bits(mem
->dma
));
624 sge
->pa_lo
= cpu_to_le32(mem
->dma
& 0xFFFFFFFF);
625 sge
->len
= cpu_to_le32(mem
->size
);
627 wrb
->embedded
|= MCC_WRB_EMBEDDED_MASK
;
628 be_dws_cpu_to_le(wrb
, 8);
631 static void be_cmd_page_addrs_prepare(struct phys_addr
*pages
, u32 max_pages
,
632 struct be_dma_mem
*mem
)
634 int i
, buf_pages
= min(PAGES_4K_SPANNED(mem
->va
, mem
->size
), max_pages
);
635 u64 dma
= (u64
)mem
->dma
;
637 for (i
= 0; i
< buf_pages
; i
++) {
638 pages
[i
].lo
= cpu_to_le32(dma
& 0xFFFFFFFF);
639 pages
[i
].hi
= cpu_to_le32(upper_32_bits(dma
));
644 /* Converts interrupt delay in microseconds to multiplier value */
645 static u32
eq_delay_to_mult(u32 usec_delay
)
647 #define MAX_INTR_RATE 651042
648 const u32 round
= 10;
654 u32 interrupt_rate
= 1000000 / usec_delay
;
655 /* Max delay, corresponding to the lowest interrupt rate */
656 if (interrupt_rate
== 0)
659 multiplier
= (MAX_INTR_RATE
- interrupt_rate
) * round
;
660 multiplier
/= interrupt_rate
;
661 /* Round the multiplier to the closest value.*/
662 multiplier
= (multiplier
+ round
/2) / round
;
663 multiplier
= min(multiplier
, (u32
)1023);
669 static inline struct be_mcc_wrb
*wrb_from_mbox(struct be_adapter
*adapter
)
671 struct be_dma_mem
*mbox_mem
= &adapter
->mbox_mem
;
672 struct be_mcc_wrb
*wrb
673 = &((struct be_mcc_mailbox
*)(mbox_mem
->va
))->wrb
;
674 memset(wrb
, 0, sizeof(*wrb
));
678 static struct be_mcc_wrb
*wrb_from_mccq(struct be_adapter
*adapter
)
680 struct be_queue_info
*mccq
= &adapter
->mcc_obj
.q
;
681 struct be_mcc_wrb
*wrb
;
686 if (atomic_read(&mccq
->used
) >= mccq
->len
) {
687 dev_err(&adapter
->pdev
->dev
, "Out of MCCQ wrbs\n");
691 wrb
= queue_head_node(mccq
);
692 queue_head_inc(mccq
);
693 atomic_inc(&mccq
->used
);
694 memset(wrb
, 0, sizeof(*wrb
));
698 /* Tell fw we're about to start firing cmds by writing a
699 * special pattern across the wrb hdr; uses mbox
701 int be_cmd_fw_init(struct be_adapter
*adapter
)
706 if (lancer_chip(adapter
))
709 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
712 wrb
= (u8
*)wrb_from_mbox(adapter
);
722 status
= be_mbox_notify_wait(adapter
);
724 mutex_unlock(&adapter
->mbox_lock
);
728 /* Tell fw we're done with firing cmds by writing a
729 * special pattern across the wrb hdr; uses mbox
731 int be_cmd_fw_clean(struct be_adapter
*adapter
)
736 if (lancer_chip(adapter
))
739 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
742 wrb
= (u8
*)wrb_from_mbox(adapter
);
752 status
= be_mbox_notify_wait(adapter
);
754 mutex_unlock(&adapter
->mbox_lock
);
758 int be_cmd_eq_create(struct be_adapter
*adapter
,
759 struct be_queue_info
*eq
, int eq_delay
)
761 struct be_mcc_wrb
*wrb
;
762 struct be_cmd_req_eq_create
*req
;
763 struct be_dma_mem
*q_mem
= &eq
->dma_mem
;
766 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
769 wrb
= wrb_from_mbox(adapter
);
770 req
= embedded_payload(wrb
);
772 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
773 OPCODE_COMMON_EQ_CREATE
, sizeof(*req
), wrb
, NULL
);
775 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
777 AMAP_SET_BITS(struct amap_eq_context
, valid
, req
->context
, 1);
779 AMAP_SET_BITS(struct amap_eq_context
, size
, req
->context
, 0);
780 AMAP_SET_BITS(struct amap_eq_context
, count
, req
->context
,
781 __ilog2_u32(eq
->len
/256));
782 AMAP_SET_BITS(struct amap_eq_context
, delaymult
, req
->context
,
783 eq_delay_to_mult(eq_delay
));
784 be_dws_cpu_to_le(req
->context
, sizeof(req
->context
));
786 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
788 status
= be_mbox_notify_wait(adapter
);
790 struct be_cmd_resp_eq_create
*resp
= embedded_payload(wrb
);
791 eq
->id
= le16_to_cpu(resp
->eq_id
);
795 mutex_unlock(&adapter
->mbox_lock
);
800 int be_cmd_mac_addr_query(struct be_adapter
*adapter
, u8
*mac_addr
,
801 bool permanent
, u32 if_handle
, u32 pmac_id
)
803 struct be_mcc_wrb
*wrb
;
804 struct be_cmd_req_mac_query
*req
;
807 spin_lock_bh(&adapter
->mcc_lock
);
809 wrb
= wrb_from_mccq(adapter
);
814 req
= embedded_payload(wrb
);
816 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
817 OPCODE_COMMON_NTWK_MAC_QUERY
, sizeof(*req
), wrb
, NULL
);
818 req
->type
= MAC_ADDRESS_TYPE_NETWORK
;
822 req
->if_id
= cpu_to_le16((u16
) if_handle
);
823 req
->pmac_id
= cpu_to_le32(pmac_id
);
827 status
= be_mcc_notify_wait(adapter
);
829 struct be_cmd_resp_mac_query
*resp
= embedded_payload(wrb
);
830 memcpy(mac_addr
, resp
->mac
.addr
, ETH_ALEN
);
834 spin_unlock_bh(&adapter
->mcc_lock
);
838 /* Uses synchronous MCCQ */
839 int be_cmd_pmac_add(struct be_adapter
*adapter
, u8
*mac_addr
,
840 u32 if_id
, u32
*pmac_id
, u32 domain
)
842 struct be_mcc_wrb
*wrb
;
843 struct be_cmd_req_pmac_add
*req
;
846 spin_lock_bh(&adapter
->mcc_lock
);
848 wrb
= wrb_from_mccq(adapter
);
853 req
= embedded_payload(wrb
);
855 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
856 OPCODE_COMMON_NTWK_PMAC_ADD
, sizeof(*req
), wrb
, NULL
);
858 req
->hdr
.domain
= domain
;
859 req
->if_id
= cpu_to_le32(if_id
);
860 memcpy(req
->mac_address
, mac_addr
, ETH_ALEN
);
862 status
= be_mcc_notify_wait(adapter
);
864 struct be_cmd_resp_pmac_add
*resp
= embedded_payload(wrb
);
865 *pmac_id
= le32_to_cpu(resp
->pmac_id
);
869 spin_unlock_bh(&adapter
->mcc_lock
);
871 if (status
== MCC_STATUS_UNAUTHORIZED_REQUEST
)
877 /* Uses synchronous MCCQ */
878 int be_cmd_pmac_del(struct be_adapter
*adapter
, u32 if_id
, int pmac_id
, u32 dom
)
880 struct be_mcc_wrb
*wrb
;
881 struct be_cmd_req_pmac_del
*req
;
887 spin_lock_bh(&adapter
->mcc_lock
);
889 wrb
= wrb_from_mccq(adapter
);
894 req
= embedded_payload(wrb
);
896 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
897 OPCODE_COMMON_NTWK_PMAC_DEL
, sizeof(*req
), wrb
, NULL
);
899 req
->hdr
.domain
= dom
;
900 req
->if_id
= cpu_to_le32(if_id
);
901 req
->pmac_id
= cpu_to_le32(pmac_id
);
903 status
= be_mcc_notify_wait(adapter
);
906 spin_unlock_bh(&adapter
->mcc_lock
);
911 int be_cmd_cq_create(struct be_adapter
*adapter
, struct be_queue_info
*cq
,
912 struct be_queue_info
*eq
, bool no_delay
, int coalesce_wm
)
914 struct be_mcc_wrb
*wrb
;
915 struct be_cmd_req_cq_create
*req
;
916 struct be_dma_mem
*q_mem
= &cq
->dma_mem
;
920 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
923 wrb
= wrb_from_mbox(adapter
);
924 req
= embedded_payload(wrb
);
925 ctxt
= &req
->context
;
927 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
928 OPCODE_COMMON_CQ_CREATE
, sizeof(*req
), wrb
, NULL
);
930 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
931 if (lancer_chip(adapter
)) {
932 req
->hdr
.version
= 2;
933 req
->page_size
= 1; /* 1 for 4K */
934 AMAP_SET_BITS(struct amap_cq_context_lancer
, nodelay
, ctxt
,
936 AMAP_SET_BITS(struct amap_cq_context_lancer
, count
, ctxt
,
937 __ilog2_u32(cq
->len
/256));
938 AMAP_SET_BITS(struct amap_cq_context_lancer
, valid
, ctxt
, 1);
939 AMAP_SET_BITS(struct amap_cq_context_lancer
, eventable
,
941 AMAP_SET_BITS(struct amap_cq_context_lancer
, eqid
,
944 AMAP_SET_BITS(struct amap_cq_context_be
, coalescwm
, ctxt
,
946 AMAP_SET_BITS(struct amap_cq_context_be
, nodelay
,
948 AMAP_SET_BITS(struct amap_cq_context_be
, count
, ctxt
,
949 __ilog2_u32(cq
->len
/256));
950 AMAP_SET_BITS(struct amap_cq_context_be
, valid
, ctxt
, 1);
951 AMAP_SET_BITS(struct amap_cq_context_be
, eventable
, ctxt
, 1);
952 AMAP_SET_BITS(struct amap_cq_context_be
, eqid
, ctxt
, eq
->id
);
955 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
957 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
959 status
= be_mbox_notify_wait(adapter
);
961 struct be_cmd_resp_cq_create
*resp
= embedded_payload(wrb
);
962 cq
->id
= le16_to_cpu(resp
->cq_id
);
966 mutex_unlock(&adapter
->mbox_lock
);
971 static u32
be_encoded_q_len(int q_len
)
973 u32 len_encoded
= fls(q_len
); /* log2(len) + 1 */
974 if (len_encoded
== 16)
979 int be_cmd_mccq_ext_create(struct be_adapter
*adapter
,
980 struct be_queue_info
*mccq
,
981 struct be_queue_info
*cq
)
983 struct be_mcc_wrb
*wrb
;
984 struct be_cmd_req_mcc_ext_create
*req
;
985 struct be_dma_mem
*q_mem
= &mccq
->dma_mem
;
989 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
992 wrb
= wrb_from_mbox(adapter
);
993 req
= embedded_payload(wrb
);
994 ctxt
= &req
->context
;
996 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
997 OPCODE_COMMON_MCC_CREATE_EXT
, sizeof(*req
), wrb
, NULL
);
999 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
1000 if (lancer_chip(adapter
)) {
1001 req
->hdr
.version
= 1;
1002 req
->cq_id
= cpu_to_le16(cq
->id
);
1004 AMAP_SET_BITS(struct amap_mcc_context_lancer
, ring_size
, ctxt
,
1005 be_encoded_q_len(mccq
->len
));
1006 AMAP_SET_BITS(struct amap_mcc_context_lancer
, valid
, ctxt
, 1);
1007 AMAP_SET_BITS(struct amap_mcc_context_lancer
, async_cq_id
,
1009 AMAP_SET_BITS(struct amap_mcc_context_lancer
, async_cq_valid
,
1013 AMAP_SET_BITS(struct amap_mcc_context_be
, valid
, ctxt
, 1);
1014 AMAP_SET_BITS(struct amap_mcc_context_be
, ring_size
, ctxt
,
1015 be_encoded_q_len(mccq
->len
));
1016 AMAP_SET_BITS(struct amap_mcc_context_be
, cq_id
, ctxt
, cq
->id
);
1019 /* Subscribe to Link State and Group 5 Events(bits 1 and 5 set) */
1020 req
->async_event_bitmap
[0] = cpu_to_le32(0x00000022);
1021 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
1023 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
1025 status
= be_mbox_notify_wait(adapter
);
1027 struct be_cmd_resp_mcc_create
*resp
= embedded_payload(wrb
);
1028 mccq
->id
= le16_to_cpu(resp
->id
);
1029 mccq
->created
= true;
1031 mutex_unlock(&adapter
->mbox_lock
);
1036 int be_cmd_mccq_org_create(struct be_adapter
*adapter
,
1037 struct be_queue_info
*mccq
,
1038 struct be_queue_info
*cq
)
1040 struct be_mcc_wrb
*wrb
;
1041 struct be_cmd_req_mcc_create
*req
;
1042 struct be_dma_mem
*q_mem
= &mccq
->dma_mem
;
1046 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1049 wrb
= wrb_from_mbox(adapter
);
1050 req
= embedded_payload(wrb
);
1051 ctxt
= &req
->context
;
1053 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1054 OPCODE_COMMON_MCC_CREATE
, sizeof(*req
), wrb
, NULL
);
1056 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
1058 AMAP_SET_BITS(struct amap_mcc_context_be
, valid
, ctxt
, 1);
1059 AMAP_SET_BITS(struct amap_mcc_context_be
, ring_size
, ctxt
,
1060 be_encoded_q_len(mccq
->len
));
1061 AMAP_SET_BITS(struct amap_mcc_context_be
, cq_id
, ctxt
, cq
->id
);
1063 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
1065 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
1067 status
= be_mbox_notify_wait(adapter
);
1069 struct be_cmd_resp_mcc_create
*resp
= embedded_payload(wrb
);
1070 mccq
->id
= le16_to_cpu(resp
->id
);
1071 mccq
->created
= true;
1074 mutex_unlock(&adapter
->mbox_lock
);
1078 int be_cmd_mccq_create(struct be_adapter
*adapter
,
1079 struct be_queue_info
*mccq
,
1080 struct be_queue_info
*cq
)
1084 status
= be_cmd_mccq_ext_create(adapter
, mccq
, cq
);
1085 if (status
&& !lancer_chip(adapter
)) {
1086 dev_warn(&adapter
->pdev
->dev
, "Upgrade to F/W ver 2.102.235.0 "
1087 "or newer to avoid conflicting priorities between NIC "
1088 "and FCoE traffic");
1089 status
= be_cmd_mccq_org_create(adapter
, mccq
, cq
);
1094 int be_cmd_txq_create(struct be_adapter
*adapter
,
1095 struct be_queue_info
*txq
,
1096 struct be_queue_info
*cq
)
1098 struct be_mcc_wrb
*wrb
;
1099 struct be_cmd_req_eth_tx_create
*req
;
1100 struct be_dma_mem
*q_mem
= &txq
->dma_mem
;
1104 spin_lock_bh(&adapter
->mcc_lock
);
1106 wrb
= wrb_from_mccq(adapter
);
1112 req
= embedded_payload(wrb
);
1113 ctxt
= &req
->context
;
1115 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1116 OPCODE_ETH_TX_CREATE
, sizeof(*req
), wrb
, NULL
);
1118 if (lancer_chip(adapter
)) {
1119 req
->hdr
.version
= 1;
1120 AMAP_SET_BITS(struct amap_tx_context
, if_id
, ctxt
,
1121 adapter
->if_handle
);
1124 req
->num_pages
= PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
);
1125 req
->ulp_num
= BE_ULP1_NUM
;
1126 req
->type
= BE_ETH_TX_RING_TYPE_STANDARD
;
1128 AMAP_SET_BITS(struct amap_tx_context
, tx_ring_size
, ctxt
,
1129 be_encoded_q_len(txq
->len
));
1130 AMAP_SET_BITS(struct amap_tx_context
, ctx_valid
, ctxt
, 1);
1131 AMAP_SET_BITS(struct amap_tx_context
, cq_id_send
, ctxt
, cq
->id
);
1133 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
1135 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
1137 status
= be_mcc_notify_wait(adapter
);
1139 struct be_cmd_resp_eth_tx_create
*resp
= embedded_payload(wrb
);
1140 txq
->id
= le16_to_cpu(resp
->cid
);
1141 txq
->created
= true;
1145 spin_unlock_bh(&adapter
->mcc_lock
);
1151 int be_cmd_rxq_create(struct be_adapter
*adapter
,
1152 struct be_queue_info
*rxq
, u16 cq_id
, u16 frag_size
,
1153 u32 if_id
, u32 rss
, u8
*rss_id
)
1155 struct be_mcc_wrb
*wrb
;
1156 struct be_cmd_req_eth_rx_create
*req
;
1157 struct be_dma_mem
*q_mem
= &rxq
->dma_mem
;
1160 spin_lock_bh(&adapter
->mcc_lock
);
1162 wrb
= wrb_from_mccq(adapter
);
1167 req
= embedded_payload(wrb
);
1169 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1170 OPCODE_ETH_RX_CREATE
, sizeof(*req
), wrb
, NULL
);
1172 req
->cq_id
= cpu_to_le16(cq_id
);
1173 req
->frag_size
= fls(frag_size
) - 1;
1175 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
1176 req
->interface_id
= cpu_to_le32(if_id
);
1177 req
->max_frame_size
= cpu_to_le16(BE_MAX_JUMBO_FRAME_SIZE
);
1178 req
->rss_queue
= cpu_to_le32(rss
);
1180 status
= be_mcc_notify_wait(adapter
);
1182 struct be_cmd_resp_eth_rx_create
*resp
= embedded_payload(wrb
);
1183 rxq
->id
= le16_to_cpu(resp
->id
);
1184 rxq
->created
= true;
1185 *rss_id
= resp
->rss_id
;
1189 spin_unlock_bh(&adapter
->mcc_lock
);
1193 /* Generic destroyer function for all types of queues
1196 int be_cmd_q_destroy(struct be_adapter
*adapter
, struct be_queue_info
*q
,
1199 struct be_mcc_wrb
*wrb
;
1200 struct be_cmd_req_q_destroy
*req
;
1201 u8 subsys
= 0, opcode
= 0;
1204 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1207 wrb
= wrb_from_mbox(adapter
);
1208 req
= embedded_payload(wrb
);
1210 switch (queue_type
) {
1212 subsys
= CMD_SUBSYSTEM_COMMON
;
1213 opcode
= OPCODE_COMMON_EQ_DESTROY
;
1216 subsys
= CMD_SUBSYSTEM_COMMON
;
1217 opcode
= OPCODE_COMMON_CQ_DESTROY
;
1220 subsys
= CMD_SUBSYSTEM_ETH
;
1221 opcode
= OPCODE_ETH_TX_DESTROY
;
1224 subsys
= CMD_SUBSYSTEM_ETH
;
1225 opcode
= OPCODE_ETH_RX_DESTROY
;
1228 subsys
= CMD_SUBSYSTEM_COMMON
;
1229 opcode
= OPCODE_COMMON_MCC_DESTROY
;
1235 be_wrb_cmd_hdr_prepare(&req
->hdr
, subsys
, opcode
, sizeof(*req
), wrb
,
1237 req
->id
= cpu_to_le16(q
->id
);
1239 status
= be_mbox_notify_wait(adapter
);
1242 mutex_unlock(&adapter
->mbox_lock
);
1247 int be_cmd_rxq_destroy(struct be_adapter
*adapter
, struct be_queue_info
*q
)
1249 struct be_mcc_wrb
*wrb
;
1250 struct be_cmd_req_q_destroy
*req
;
1253 spin_lock_bh(&adapter
->mcc_lock
);
1255 wrb
= wrb_from_mccq(adapter
);
1260 req
= embedded_payload(wrb
);
1262 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1263 OPCODE_ETH_RX_DESTROY
, sizeof(*req
), wrb
, NULL
);
1264 req
->id
= cpu_to_le16(q
->id
);
1266 status
= be_mcc_notify_wait(adapter
);
1270 spin_unlock_bh(&adapter
->mcc_lock
);
1274 /* Create an rx filtering policy configuration on an i/f
1277 int be_cmd_if_create(struct be_adapter
*adapter
, u32 cap_flags
, u32 en_flags
,
1278 u32
*if_handle
, u32 domain
)
1280 struct be_mcc_wrb
*wrb
;
1281 struct be_cmd_req_if_create
*req
;
1284 spin_lock_bh(&adapter
->mcc_lock
);
1286 wrb
= wrb_from_mccq(adapter
);
1291 req
= embedded_payload(wrb
);
1293 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1294 OPCODE_COMMON_NTWK_INTERFACE_CREATE
, sizeof(*req
), wrb
, NULL
);
1295 req
->hdr
.domain
= domain
;
1296 req
->capability_flags
= cpu_to_le32(cap_flags
);
1297 req
->enable_flags
= cpu_to_le32(en_flags
);
1299 req
->pmac_invalid
= true;
1301 status
= be_mcc_notify_wait(adapter
);
1303 struct be_cmd_resp_if_create
*resp
= embedded_payload(wrb
);
1304 *if_handle
= le32_to_cpu(resp
->interface_id
);
1308 spin_unlock_bh(&adapter
->mcc_lock
);
1313 int be_cmd_if_destroy(struct be_adapter
*adapter
, int interface_id
, u32 domain
)
1315 struct be_mcc_wrb
*wrb
;
1316 struct be_cmd_req_if_destroy
*req
;
1319 if (interface_id
== -1)
1322 spin_lock_bh(&adapter
->mcc_lock
);
1324 wrb
= wrb_from_mccq(adapter
);
1329 req
= embedded_payload(wrb
);
1331 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1332 OPCODE_COMMON_NTWK_INTERFACE_DESTROY
, sizeof(*req
), wrb
, NULL
);
1333 req
->hdr
.domain
= domain
;
1334 req
->interface_id
= cpu_to_le32(interface_id
);
1336 status
= be_mcc_notify_wait(adapter
);
1338 spin_unlock_bh(&adapter
->mcc_lock
);
1342 /* Get stats is a non embedded command: the request is not embedded inside
1343 * WRB but is a separate dma memory block
1344 * Uses asynchronous MCC
1346 int be_cmd_get_stats(struct be_adapter
*adapter
, struct be_dma_mem
*nonemb_cmd
)
1348 struct be_mcc_wrb
*wrb
;
1349 struct be_cmd_req_hdr
*hdr
;
1352 spin_lock_bh(&adapter
->mcc_lock
);
1354 wrb
= wrb_from_mccq(adapter
);
1359 hdr
= nonemb_cmd
->va
;
1361 be_wrb_cmd_hdr_prepare(hdr
, CMD_SUBSYSTEM_ETH
,
1362 OPCODE_ETH_GET_STATISTICS
, nonemb_cmd
->size
, wrb
, nonemb_cmd
);
1364 /* version 1 of the cmd is not supported only by BE2 */
1365 if (!BE2_chip(adapter
))
1368 be_mcc_notify(adapter
);
1369 adapter
->stats_cmd_sent
= true;
1372 spin_unlock_bh(&adapter
->mcc_lock
);
1377 int lancer_cmd_get_pport_stats(struct be_adapter
*adapter
,
1378 struct be_dma_mem
*nonemb_cmd
)
1381 struct be_mcc_wrb
*wrb
;
1382 struct lancer_cmd_req_pport_stats
*req
;
1385 if (!be_cmd_allowed(adapter
, OPCODE_ETH_GET_PPORT_STATS
,
1389 spin_lock_bh(&adapter
->mcc_lock
);
1391 wrb
= wrb_from_mccq(adapter
);
1396 req
= nonemb_cmd
->va
;
1398 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1399 OPCODE_ETH_GET_PPORT_STATS
, nonemb_cmd
->size
, wrb
,
1402 req
->cmd_params
.params
.pport_num
= cpu_to_le16(adapter
->hba_port_num
);
1403 req
->cmd_params
.params
.reset_stats
= 0;
1405 be_mcc_notify(adapter
);
1406 adapter
->stats_cmd_sent
= true;
1409 spin_unlock_bh(&adapter
->mcc_lock
);
1413 static int be_mac_to_link_speed(int mac_speed
)
1415 switch (mac_speed
) {
1416 case PHY_LINK_SPEED_ZERO
:
1418 case PHY_LINK_SPEED_10MBPS
:
1420 case PHY_LINK_SPEED_100MBPS
:
1422 case PHY_LINK_SPEED_1GBPS
:
1424 case PHY_LINK_SPEED_10GBPS
:
1430 /* Uses synchronous mcc
1431 * Returns link_speed in Mbps
1433 int be_cmd_link_status_query(struct be_adapter
*adapter
, u16
*link_speed
,
1434 u8
*link_status
, u32 dom
)
1436 struct be_mcc_wrb
*wrb
;
1437 struct be_cmd_req_link_status
*req
;
1440 spin_lock_bh(&adapter
->mcc_lock
);
1443 *link_status
= LINK_DOWN
;
1445 wrb
= wrb_from_mccq(adapter
);
1450 req
= embedded_payload(wrb
);
1452 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1453 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY
, sizeof(*req
), wrb
, NULL
);
1455 /* version 1 of the cmd is not supported only by BE2 */
1456 if (!BE2_chip(adapter
))
1457 req
->hdr
.version
= 1;
1459 req
->hdr
.domain
= dom
;
1461 status
= be_mcc_notify_wait(adapter
);
1463 struct be_cmd_resp_link_status
*resp
= embedded_payload(wrb
);
1465 *link_speed
= resp
->link_speed
?
1466 le16_to_cpu(resp
->link_speed
) * 10 :
1467 be_mac_to_link_speed(resp
->mac_speed
);
1469 if (!resp
->logical_link_status
)
1473 *link_status
= resp
->logical_link_status
;
1477 spin_unlock_bh(&adapter
->mcc_lock
);
1481 /* Uses synchronous mcc */
1482 int be_cmd_get_die_temperature(struct be_adapter
*adapter
)
1484 struct be_mcc_wrb
*wrb
;
1485 struct be_cmd_req_get_cntl_addnl_attribs
*req
;
1488 spin_lock_bh(&adapter
->mcc_lock
);
1490 wrb
= wrb_from_mccq(adapter
);
1495 req
= embedded_payload(wrb
);
1497 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1498 OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES
, sizeof(*req
),
1501 be_mcc_notify(adapter
);
1504 spin_unlock_bh(&adapter
->mcc_lock
);
1508 /* Uses synchronous mcc */
1509 int be_cmd_get_reg_len(struct be_adapter
*adapter
, u32
*log_size
)
1511 struct be_mcc_wrb
*wrb
;
1512 struct be_cmd_req_get_fat
*req
;
1515 spin_lock_bh(&adapter
->mcc_lock
);
1517 wrb
= wrb_from_mccq(adapter
);
1522 req
= embedded_payload(wrb
);
1524 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1525 OPCODE_COMMON_MANAGE_FAT
, sizeof(*req
), wrb
, NULL
);
1526 req
->fat_operation
= cpu_to_le32(QUERY_FAT
);
1527 status
= be_mcc_notify_wait(adapter
);
1529 struct be_cmd_resp_get_fat
*resp
= embedded_payload(wrb
);
1530 if (log_size
&& resp
->log_size
)
1531 *log_size
= le32_to_cpu(resp
->log_size
) -
1535 spin_unlock_bh(&adapter
->mcc_lock
);
1539 void be_cmd_get_regs(struct be_adapter
*adapter
, u32 buf_len
, void *buf
)
1541 struct be_dma_mem get_fat_cmd
;
1542 struct be_mcc_wrb
*wrb
;
1543 struct be_cmd_req_get_fat
*req
;
1544 u32 offset
= 0, total_size
, buf_size
,
1545 log_offset
= sizeof(u32
), payload_len
;
1551 total_size
= buf_len
;
1553 get_fat_cmd
.size
= sizeof(struct be_cmd_req_get_fat
) + 60*1024;
1554 get_fat_cmd
.va
= pci_alloc_consistent(adapter
->pdev
,
1557 if (!get_fat_cmd
.va
) {
1559 dev_err(&adapter
->pdev
->dev
,
1560 "Memory allocation failure while retrieving FAT data\n");
1564 spin_lock_bh(&adapter
->mcc_lock
);
1566 while (total_size
) {
1567 buf_size
= min(total_size
, (u32
)60*1024);
1568 total_size
-= buf_size
;
1570 wrb
= wrb_from_mccq(adapter
);
1575 req
= get_fat_cmd
.va
;
1577 payload_len
= sizeof(struct be_cmd_req_get_fat
) + buf_size
;
1578 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1579 OPCODE_COMMON_MANAGE_FAT
, payload_len
, wrb
,
1582 req
->fat_operation
= cpu_to_le32(RETRIEVE_FAT
);
1583 req
->read_log_offset
= cpu_to_le32(log_offset
);
1584 req
->read_log_length
= cpu_to_le32(buf_size
);
1585 req
->data_buffer_size
= cpu_to_le32(buf_size
);
1587 status
= be_mcc_notify_wait(adapter
);
1589 struct be_cmd_resp_get_fat
*resp
= get_fat_cmd
.va
;
1590 memcpy(buf
+ offset
,
1592 le32_to_cpu(resp
->read_log_length
));
1594 dev_err(&adapter
->pdev
->dev
, "FAT Table Retrieve error\n");
1598 log_offset
+= buf_size
;
1601 pci_free_consistent(adapter
->pdev
, get_fat_cmd
.size
,
1604 spin_unlock_bh(&adapter
->mcc_lock
);
1607 /* Uses synchronous mcc */
1608 int be_cmd_get_fw_ver(struct be_adapter
*adapter
, char *fw_ver
,
1611 struct be_mcc_wrb
*wrb
;
1612 struct be_cmd_req_get_fw_version
*req
;
1615 spin_lock_bh(&adapter
->mcc_lock
);
1617 wrb
= wrb_from_mccq(adapter
);
1623 req
= embedded_payload(wrb
);
1625 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1626 OPCODE_COMMON_GET_FW_VERSION
, sizeof(*req
), wrb
, NULL
);
1627 status
= be_mcc_notify_wait(adapter
);
1629 struct be_cmd_resp_get_fw_version
*resp
= embedded_payload(wrb
);
1630 strcpy(fw_ver
, resp
->firmware_version_string
);
1632 strcpy(fw_on_flash
, resp
->fw_on_flash_version_string
);
1635 spin_unlock_bh(&adapter
->mcc_lock
);
1639 /* set the EQ delay interval of an EQ to specified value
1642 int be_cmd_modify_eqd(struct be_adapter
*adapter
, u32 eq_id
, u32 eqd
)
1644 struct be_mcc_wrb
*wrb
;
1645 struct be_cmd_req_modify_eq_delay
*req
;
1648 spin_lock_bh(&adapter
->mcc_lock
);
1650 wrb
= wrb_from_mccq(adapter
);
1655 req
= embedded_payload(wrb
);
1657 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1658 OPCODE_COMMON_MODIFY_EQ_DELAY
, sizeof(*req
), wrb
, NULL
);
1660 req
->num_eq
= cpu_to_le32(1);
1661 req
->delay
[0].eq_id
= cpu_to_le32(eq_id
);
1662 req
->delay
[0].phase
= 0;
1663 req
->delay
[0].delay_multiplier
= cpu_to_le32(eqd
);
1665 be_mcc_notify(adapter
);
1668 spin_unlock_bh(&adapter
->mcc_lock
);
1672 /* Uses sycnhronous mcc */
1673 int be_cmd_vlan_config(struct be_adapter
*adapter
, u32 if_id
, u16
*vtag_array
,
1674 u32 num
, bool untagged
, bool promiscuous
)
1676 struct be_mcc_wrb
*wrb
;
1677 struct be_cmd_req_vlan_config
*req
;
1680 spin_lock_bh(&adapter
->mcc_lock
);
1682 wrb
= wrb_from_mccq(adapter
);
1687 req
= embedded_payload(wrb
);
1689 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1690 OPCODE_COMMON_NTWK_VLAN_CONFIG
, sizeof(*req
), wrb
, NULL
);
1692 req
->interface_id
= if_id
;
1693 req
->promiscuous
= promiscuous
;
1694 req
->untagged
= untagged
;
1695 req
->num_vlan
= num
;
1697 memcpy(req
->normal_vlan
, vtag_array
,
1698 req
->num_vlan
* sizeof(vtag_array
[0]));
1701 status
= be_mcc_notify_wait(adapter
);
1704 spin_unlock_bh(&adapter
->mcc_lock
);
1708 int be_cmd_rx_filter(struct be_adapter
*adapter
, u32 flags
, u32 value
)
1710 struct be_mcc_wrb
*wrb
;
1711 struct be_dma_mem
*mem
= &adapter
->rx_filter
;
1712 struct be_cmd_req_rx_filter
*req
= mem
->va
;
1715 spin_lock_bh(&adapter
->mcc_lock
);
1717 wrb
= wrb_from_mccq(adapter
);
1722 memset(req
, 0, sizeof(*req
));
1723 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1724 OPCODE_COMMON_NTWK_RX_FILTER
, sizeof(*req
),
1727 req
->if_id
= cpu_to_le32(adapter
->if_handle
);
1728 if (flags
& IFF_PROMISC
) {
1729 req
->if_flags_mask
= cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS
|
1730 BE_IF_FLAGS_VLAN_PROMISCUOUS
);
1732 req
->if_flags
= cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS
|
1733 BE_IF_FLAGS_VLAN_PROMISCUOUS
);
1734 } else if (flags
& IFF_ALLMULTI
) {
1735 req
->if_flags_mask
= req
->if_flags
=
1736 cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS
);
1738 struct netdev_hw_addr
*ha
;
1741 req
->if_flags_mask
= req
->if_flags
=
1742 cpu_to_le32(BE_IF_FLAGS_MULTICAST
);
1744 /* Reset mcast promisc mode if already set by setting mask
1745 * and not setting flags field
1747 req
->if_flags_mask
|=
1748 cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS
&
1749 adapter
->if_cap_flags
);
1751 req
->mcast_num
= cpu_to_le32(netdev_mc_count(adapter
->netdev
));
1752 netdev_for_each_mc_addr(ha
, adapter
->netdev
)
1753 memcpy(req
->mcast_mac
[i
++].byte
, ha
->addr
, ETH_ALEN
);
1756 status
= be_mcc_notify_wait(adapter
);
1758 spin_unlock_bh(&adapter
->mcc_lock
);
1762 /* Uses synchrounous mcc */
1763 int be_cmd_set_flow_control(struct be_adapter
*adapter
, u32 tx_fc
, u32 rx_fc
)
1765 struct be_mcc_wrb
*wrb
;
1766 struct be_cmd_req_set_flow_control
*req
;
1769 if (!be_cmd_allowed(adapter
, OPCODE_COMMON_SET_FLOW_CONTROL
,
1770 CMD_SUBSYSTEM_COMMON
))
1773 spin_lock_bh(&adapter
->mcc_lock
);
1775 wrb
= wrb_from_mccq(adapter
);
1780 req
= embedded_payload(wrb
);
1782 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1783 OPCODE_COMMON_SET_FLOW_CONTROL
, sizeof(*req
), wrb
, NULL
);
1785 req
->tx_flow_control
= cpu_to_le16((u16
)tx_fc
);
1786 req
->rx_flow_control
= cpu_to_le16((u16
)rx_fc
);
1788 status
= be_mcc_notify_wait(adapter
);
1791 spin_unlock_bh(&adapter
->mcc_lock
);
1796 int be_cmd_get_flow_control(struct be_adapter
*adapter
, u32
*tx_fc
, u32
*rx_fc
)
1798 struct be_mcc_wrb
*wrb
;
1799 struct be_cmd_req_get_flow_control
*req
;
1802 if (!be_cmd_allowed(adapter
, OPCODE_COMMON_GET_FLOW_CONTROL
,
1803 CMD_SUBSYSTEM_COMMON
))
1806 spin_lock_bh(&adapter
->mcc_lock
);
1808 wrb
= wrb_from_mccq(adapter
);
1813 req
= embedded_payload(wrb
);
1815 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1816 OPCODE_COMMON_GET_FLOW_CONTROL
, sizeof(*req
), wrb
, NULL
);
1818 status
= be_mcc_notify_wait(adapter
);
1820 struct be_cmd_resp_get_flow_control
*resp
=
1821 embedded_payload(wrb
);
1822 *tx_fc
= le16_to_cpu(resp
->tx_flow_control
);
1823 *rx_fc
= le16_to_cpu(resp
->rx_flow_control
);
1827 spin_unlock_bh(&adapter
->mcc_lock
);
1832 int be_cmd_query_fw_cfg(struct be_adapter
*adapter
, u32
*port_num
,
1833 u32
*mode
, u32
*caps
)
1835 struct be_mcc_wrb
*wrb
;
1836 struct be_cmd_req_query_fw_cfg
*req
;
1839 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1842 wrb
= wrb_from_mbox(adapter
);
1843 req
= embedded_payload(wrb
);
1845 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1846 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG
, sizeof(*req
), wrb
, NULL
);
1848 status
= be_mbox_notify_wait(adapter
);
1850 struct be_cmd_resp_query_fw_cfg
*resp
= embedded_payload(wrb
);
1851 *port_num
= le32_to_cpu(resp
->phys_port
);
1852 *mode
= le32_to_cpu(resp
->function_mode
);
1853 *caps
= le32_to_cpu(resp
->function_caps
);
1856 mutex_unlock(&adapter
->mbox_lock
);
1861 int be_cmd_reset_function(struct be_adapter
*adapter
)
1863 struct be_mcc_wrb
*wrb
;
1864 struct be_cmd_req_hdr
*req
;
1867 if (lancer_chip(adapter
)) {
1868 status
= lancer_wait_ready(adapter
);
1870 iowrite32(SLI_PORT_CONTROL_IP_MASK
,
1871 adapter
->db
+ SLIPORT_CONTROL_OFFSET
);
1872 status
= lancer_test_and_set_rdy_state(adapter
);
1875 dev_err(&adapter
->pdev
->dev
,
1876 "Adapter in non recoverable error\n");
1881 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1884 wrb
= wrb_from_mbox(adapter
);
1885 req
= embedded_payload(wrb
);
1887 be_wrb_cmd_hdr_prepare(req
, CMD_SUBSYSTEM_COMMON
,
1888 OPCODE_COMMON_FUNCTION_RESET
, sizeof(*req
), wrb
, NULL
);
1890 status
= be_mbox_notify_wait(adapter
);
1892 mutex_unlock(&adapter
->mbox_lock
);
1896 int be_cmd_rss_config(struct be_adapter
*adapter
, u8
*rsstable
, u16 table_size
)
1898 struct be_mcc_wrb
*wrb
;
1899 struct be_cmd_req_rss_config
*req
;
1900 u32 myhash
[10] = {0x15d43fa5, 0x2534685a, 0x5f87693a, 0x5668494e,
1901 0x33cf6a53, 0x383334c6, 0x76ac4257, 0x59b242b2,
1902 0x3ea83c02, 0x4a110304};
1905 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1908 wrb
= wrb_from_mbox(adapter
);
1909 req
= embedded_payload(wrb
);
1911 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1912 OPCODE_ETH_RSS_CONFIG
, sizeof(*req
), wrb
, NULL
);
1914 req
->if_id
= cpu_to_le32(adapter
->if_handle
);
1915 req
->enable_rss
= cpu_to_le16(RSS_ENABLE_TCP_IPV4
| RSS_ENABLE_IPV4
|
1916 RSS_ENABLE_TCP_IPV6
| RSS_ENABLE_IPV6
);
1918 if (lancer_chip(adapter
) || skyhawk_chip(adapter
)) {
1919 req
->hdr
.version
= 1;
1920 req
->enable_rss
|= cpu_to_le16(RSS_ENABLE_UDP_IPV4
|
1921 RSS_ENABLE_UDP_IPV6
);
1924 req
->cpu_table_size_log2
= cpu_to_le16(fls(table_size
) - 1);
1925 memcpy(req
->cpu_table
, rsstable
, table_size
);
1926 memcpy(req
->hash
, myhash
, sizeof(myhash
));
1927 be_dws_cpu_to_le(req
->hash
, sizeof(req
->hash
));
1929 status
= be_mbox_notify_wait(adapter
);
1931 mutex_unlock(&adapter
->mbox_lock
);
1936 int be_cmd_set_beacon_state(struct be_adapter
*adapter
, u8 port_num
,
1937 u8 bcn
, u8 sts
, u8 state
)
1939 struct be_mcc_wrb
*wrb
;
1940 struct be_cmd_req_enable_disable_beacon
*req
;
1943 spin_lock_bh(&adapter
->mcc_lock
);
1945 wrb
= wrb_from_mccq(adapter
);
1950 req
= embedded_payload(wrb
);
1952 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1953 OPCODE_COMMON_ENABLE_DISABLE_BEACON
, sizeof(*req
), wrb
, NULL
);
1955 req
->port_num
= port_num
;
1956 req
->beacon_state
= state
;
1957 req
->beacon_duration
= bcn
;
1958 req
->status_duration
= sts
;
1960 status
= be_mcc_notify_wait(adapter
);
1963 spin_unlock_bh(&adapter
->mcc_lock
);
1968 int be_cmd_get_beacon_state(struct be_adapter
*adapter
, u8 port_num
, u32
*state
)
1970 struct be_mcc_wrb
*wrb
;
1971 struct be_cmd_req_get_beacon_state
*req
;
1974 spin_lock_bh(&adapter
->mcc_lock
);
1976 wrb
= wrb_from_mccq(adapter
);
1981 req
= embedded_payload(wrb
);
1983 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1984 OPCODE_COMMON_GET_BEACON_STATE
, sizeof(*req
), wrb
, NULL
);
1986 req
->port_num
= port_num
;
1988 status
= be_mcc_notify_wait(adapter
);
1990 struct be_cmd_resp_get_beacon_state
*resp
=
1991 embedded_payload(wrb
);
1992 *state
= resp
->beacon_state
;
1996 spin_unlock_bh(&adapter
->mcc_lock
);
2000 int lancer_cmd_write_object(struct be_adapter
*adapter
, struct be_dma_mem
*cmd
,
2001 u32 data_size
, u32 data_offset
,
2002 const char *obj_name
, u32
*data_written
,
2003 u8
*change_status
, u8
*addn_status
)
2005 struct be_mcc_wrb
*wrb
;
2006 struct lancer_cmd_req_write_object
*req
;
2007 struct lancer_cmd_resp_write_object
*resp
;
2011 spin_lock_bh(&adapter
->mcc_lock
);
2012 adapter
->flash_status
= 0;
2014 wrb
= wrb_from_mccq(adapter
);
2020 req
= embedded_payload(wrb
);
2022 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2023 OPCODE_COMMON_WRITE_OBJECT
,
2024 sizeof(struct lancer_cmd_req_write_object
), wrb
,
2027 ctxt
= &req
->context
;
2028 AMAP_SET_BITS(struct amap_lancer_write_obj_context
,
2029 write_length
, ctxt
, data_size
);
2032 AMAP_SET_BITS(struct amap_lancer_write_obj_context
,
2035 AMAP_SET_BITS(struct amap_lancer_write_obj_context
,
2038 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
2039 req
->write_offset
= cpu_to_le32(data_offset
);
2040 strcpy(req
->object_name
, obj_name
);
2041 req
->descriptor_count
= cpu_to_le32(1);
2042 req
->buf_len
= cpu_to_le32(data_size
);
2043 req
->addr_low
= cpu_to_le32((cmd
->dma
+
2044 sizeof(struct lancer_cmd_req_write_object
))
2046 req
->addr_high
= cpu_to_le32(upper_32_bits(cmd
->dma
+
2047 sizeof(struct lancer_cmd_req_write_object
)));
2049 be_mcc_notify(adapter
);
2050 spin_unlock_bh(&adapter
->mcc_lock
);
2052 if (!wait_for_completion_timeout(&adapter
->flash_compl
,
2053 msecs_to_jiffies(30000)))
2056 status
= adapter
->flash_status
;
2058 resp
= embedded_payload(wrb
);
2060 *data_written
= le32_to_cpu(resp
->actual_write_len
);
2061 *change_status
= resp
->change_status
;
2063 *addn_status
= resp
->additional_status
;
2069 spin_unlock_bh(&adapter
->mcc_lock
);
2073 int lancer_cmd_read_object(struct be_adapter
*adapter
, struct be_dma_mem
*cmd
,
2074 u32 data_size
, u32 data_offset
, const char *obj_name
,
2075 u32
*data_read
, u32
*eof
, u8
*addn_status
)
2077 struct be_mcc_wrb
*wrb
;
2078 struct lancer_cmd_req_read_object
*req
;
2079 struct lancer_cmd_resp_read_object
*resp
;
2082 spin_lock_bh(&adapter
->mcc_lock
);
2084 wrb
= wrb_from_mccq(adapter
);
2090 req
= embedded_payload(wrb
);
2092 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2093 OPCODE_COMMON_READ_OBJECT
,
2094 sizeof(struct lancer_cmd_req_read_object
), wrb
,
2097 req
->desired_read_len
= cpu_to_le32(data_size
);
2098 req
->read_offset
= cpu_to_le32(data_offset
);
2099 strcpy(req
->object_name
, obj_name
);
2100 req
->descriptor_count
= cpu_to_le32(1);
2101 req
->buf_len
= cpu_to_le32(data_size
);
2102 req
->addr_low
= cpu_to_le32((cmd
->dma
& 0xFFFFFFFF));
2103 req
->addr_high
= cpu_to_le32(upper_32_bits(cmd
->dma
));
2105 status
= be_mcc_notify_wait(adapter
);
2107 resp
= embedded_payload(wrb
);
2109 *data_read
= le32_to_cpu(resp
->actual_read_len
);
2110 *eof
= le32_to_cpu(resp
->eof
);
2112 *addn_status
= resp
->additional_status
;
2116 spin_unlock_bh(&adapter
->mcc_lock
);
2120 int be_cmd_write_flashrom(struct be_adapter
*adapter
, struct be_dma_mem
*cmd
,
2121 u32 flash_type
, u32 flash_opcode
, u32 buf_size
)
2123 struct be_mcc_wrb
*wrb
;
2124 struct be_cmd_write_flashrom
*req
;
2127 spin_lock_bh(&adapter
->mcc_lock
);
2128 adapter
->flash_status
= 0;
2130 wrb
= wrb_from_mccq(adapter
);
2137 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2138 OPCODE_COMMON_WRITE_FLASHROM
, cmd
->size
, wrb
, cmd
);
2140 req
->params
.op_type
= cpu_to_le32(flash_type
);
2141 req
->params
.op_code
= cpu_to_le32(flash_opcode
);
2142 req
->params
.data_buf_size
= cpu_to_le32(buf_size
);
2144 be_mcc_notify(adapter
);
2145 spin_unlock_bh(&adapter
->mcc_lock
);
2147 if (!wait_for_completion_timeout(&adapter
->flash_compl
,
2148 msecs_to_jiffies(40000)))
2151 status
= adapter
->flash_status
;
2156 spin_unlock_bh(&adapter
->mcc_lock
);
2160 int be_cmd_get_flash_crc(struct be_adapter
*adapter
, u8
*flashed_crc
,
2163 struct be_mcc_wrb
*wrb
;
2164 struct be_cmd_read_flash_crc
*req
;
2167 spin_lock_bh(&adapter
->mcc_lock
);
2169 wrb
= wrb_from_mccq(adapter
);
2174 req
= embedded_payload(wrb
);
2176 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2177 OPCODE_COMMON_READ_FLASHROM
, sizeof(*req
),
2180 req
->params
.op_type
= cpu_to_le32(OPTYPE_REDBOOT
);
2181 req
->params
.op_code
= cpu_to_le32(FLASHROM_OPER_REPORT
);
2182 req
->params
.offset
= cpu_to_le32(offset
);
2183 req
->params
.data_buf_size
= cpu_to_le32(0x4);
2185 status
= be_mcc_notify_wait(adapter
);
2187 memcpy(flashed_crc
, req
->crc
, 4);
2190 spin_unlock_bh(&adapter
->mcc_lock
);
2194 int be_cmd_enable_magic_wol(struct be_adapter
*adapter
, u8
*mac
,
2195 struct be_dma_mem
*nonemb_cmd
)
2197 struct be_mcc_wrb
*wrb
;
2198 struct be_cmd_req_acpi_wol_magic_config
*req
;
2201 spin_lock_bh(&adapter
->mcc_lock
);
2203 wrb
= wrb_from_mccq(adapter
);
2208 req
= nonemb_cmd
->va
;
2210 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
2211 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
, sizeof(*req
), wrb
,
2213 memcpy(req
->magic_mac
, mac
, ETH_ALEN
);
2215 status
= be_mcc_notify_wait(adapter
);
2218 spin_unlock_bh(&adapter
->mcc_lock
);
2222 int be_cmd_set_loopback(struct be_adapter
*adapter
, u8 port_num
,
2223 u8 loopback_type
, u8 enable
)
2225 struct be_mcc_wrb
*wrb
;
2226 struct be_cmd_req_set_lmode
*req
;
2229 spin_lock_bh(&adapter
->mcc_lock
);
2231 wrb
= wrb_from_mccq(adapter
);
2237 req
= embedded_payload(wrb
);
2239 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
2240 OPCODE_LOWLEVEL_SET_LOOPBACK_MODE
, sizeof(*req
), wrb
,
2243 req
->src_port
= port_num
;
2244 req
->dest_port
= port_num
;
2245 req
->loopback_type
= loopback_type
;
2246 req
->loopback_state
= enable
;
2248 status
= be_mcc_notify_wait(adapter
);
2250 spin_unlock_bh(&adapter
->mcc_lock
);
2254 int be_cmd_loopback_test(struct be_adapter
*adapter
, u32 port_num
,
2255 u32 loopback_type
, u32 pkt_size
, u32 num_pkts
, u64 pattern
)
2257 struct be_mcc_wrb
*wrb
;
2258 struct be_cmd_req_loopback_test
*req
;
2261 spin_lock_bh(&adapter
->mcc_lock
);
2263 wrb
= wrb_from_mccq(adapter
);
2269 req
= embedded_payload(wrb
);
2271 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
2272 OPCODE_LOWLEVEL_LOOPBACK_TEST
, sizeof(*req
), wrb
, NULL
);
2273 req
->hdr
.timeout
= cpu_to_le32(4);
2275 req
->pattern
= cpu_to_le64(pattern
);
2276 req
->src_port
= cpu_to_le32(port_num
);
2277 req
->dest_port
= cpu_to_le32(port_num
);
2278 req
->pkt_size
= cpu_to_le32(pkt_size
);
2279 req
->num_pkts
= cpu_to_le32(num_pkts
);
2280 req
->loopback_type
= cpu_to_le32(loopback_type
);
2282 status
= be_mcc_notify_wait(adapter
);
2284 struct be_cmd_resp_loopback_test
*resp
= embedded_payload(wrb
);
2285 status
= le32_to_cpu(resp
->status
);
2289 spin_unlock_bh(&adapter
->mcc_lock
);
2293 int be_cmd_ddr_dma_test(struct be_adapter
*adapter
, u64 pattern
,
2294 u32 byte_cnt
, struct be_dma_mem
*cmd
)
2296 struct be_mcc_wrb
*wrb
;
2297 struct be_cmd_req_ddrdma_test
*req
;
2301 spin_lock_bh(&adapter
->mcc_lock
);
2303 wrb
= wrb_from_mccq(adapter
);
2309 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
2310 OPCODE_LOWLEVEL_HOST_DDR_DMA
, cmd
->size
, wrb
, cmd
);
2312 req
->pattern
= cpu_to_le64(pattern
);
2313 req
->byte_count
= cpu_to_le32(byte_cnt
);
2314 for (i
= 0; i
< byte_cnt
; i
++) {
2315 req
->snd_buff
[i
] = (u8
)(pattern
>> (j
*8));
2321 status
= be_mcc_notify_wait(adapter
);
2324 struct be_cmd_resp_ddrdma_test
*resp
;
2326 if ((memcmp(resp
->rcv_buff
, req
->snd_buff
, byte_cnt
) != 0) ||
2333 spin_unlock_bh(&adapter
->mcc_lock
);
2337 int be_cmd_get_seeprom_data(struct be_adapter
*adapter
,
2338 struct be_dma_mem
*nonemb_cmd
)
2340 struct be_mcc_wrb
*wrb
;
2341 struct be_cmd_req_seeprom_read
*req
;
2345 spin_lock_bh(&adapter
->mcc_lock
);
2347 wrb
= wrb_from_mccq(adapter
);
2352 req
= nonemb_cmd
->va
;
2353 sge
= nonembedded_sgl(wrb
);
2355 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2356 OPCODE_COMMON_SEEPROM_READ
, sizeof(*req
), wrb
,
2359 status
= be_mcc_notify_wait(adapter
);
2362 spin_unlock_bh(&adapter
->mcc_lock
);
2366 int be_cmd_get_phy_info(struct be_adapter
*adapter
)
2368 struct be_mcc_wrb
*wrb
;
2369 struct be_cmd_req_get_phy_info
*req
;
2370 struct be_dma_mem cmd
;
2373 if (!be_cmd_allowed(adapter
, OPCODE_COMMON_GET_PHY_DETAILS
,
2374 CMD_SUBSYSTEM_COMMON
))
2377 spin_lock_bh(&adapter
->mcc_lock
);
2379 wrb
= wrb_from_mccq(adapter
);
2384 cmd
.size
= sizeof(struct be_cmd_req_get_phy_info
);
2385 cmd
.va
= pci_alloc_consistent(adapter
->pdev
, cmd
.size
,
2388 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
2395 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2396 OPCODE_COMMON_GET_PHY_DETAILS
, sizeof(*req
),
2399 status
= be_mcc_notify_wait(adapter
);
2401 struct be_phy_info
*resp_phy_info
=
2402 cmd
.va
+ sizeof(struct be_cmd_req_hdr
);
2403 adapter
->phy
.phy_type
= le16_to_cpu(resp_phy_info
->phy_type
);
2404 adapter
->phy
.interface_type
=
2405 le16_to_cpu(resp_phy_info
->interface_type
);
2406 adapter
->phy
.auto_speeds_supported
=
2407 le16_to_cpu(resp_phy_info
->auto_speeds_supported
);
2408 adapter
->phy
.fixed_speeds_supported
=
2409 le16_to_cpu(resp_phy_info
->fixed_speeds_supported
);
2410 adapter
->phy
.misc_params
=
2411 le32_to_cpu(resp_phy_info
->misc_params
);
2413 pci_free_consistent(adapter
->pdev
, cmd
.size
,
2416 spin_unlock_bh(&adapter
->mcc_lock
);
2420 int be_cmd_set_qos(struct be_adapter
*adapter
, u32 bps
, u32 domain
)
2422 struct be_mcc_wrb
*wrb
;
2423 struct be_cmd_req_set_qos
*req
;
2426 spin_lock_bh(&adapter
->mcc_lock
);
2428 wrb
= wrb_from_mccq(adapter
);
2434 req
= embedded_payload(wrb
);
2436 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2437 OPCODE_COMMON_SET_QOS
, sizeof(*req
), wrb
, NULL
);
2439 req
->hdr
.domain
= domain
;
2440 req
->valid_bits
= cpu_to_le32(BE_QOS_BITS_NIC
);
2441 req
->max_bps_nic
= cpu_to_le32(bps
);
2443 status
= be_mcc_notify_wait(adapter
);
2446 spin_unlock_bh(&adapter
->mcc_lock
);
2450 int be_cmd_get_cntl_attributes(struct be_adapter
*adapter
)
2452 struct be_mcc_wrb
*wrb
;
2453 struct be_cmd_req_cntl_attribs
*req
;
2454 struct be_cmd_resp_cntl_attribs
*resp
;
2456 int payload_len
= max(sizeof(*req
), sizeof(*resp
));
2457 struct mgmt_controller_attrib
*attribs
;
2458 struct be_dma_mem attribs_cmd
;
2460 memset(&attribs_cmd
, 0, sizeof(struct be_dma_mem
));
2461 attribs_cmd
.size
= sizeof(struct be_cmd_resp_cntl_attribs
);
2462 attribs_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, attribs_cmd
.size
,
2464 if (!attribs_cmd
.va
) {
2465 dev_err(&adapter
->pdev
->dev
,
2466 "Memory allocation failure\n");
2470 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2473 wrb
= wrb_from_mbox(adapter
);
2478 req
= attribs_cmd
.va
;
2480 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2481 OPCODE_COMMON_GET_CNTL_ATTRIBUTES
, payload_len
, wrb
,
2484 status
= be_mbox_notify_wait(adapter
);
2486 attribs
= attribs_cmd
.va
+ sizeof(struct be_cmd_resp_hdr
);
2487 adapter
->hba_port_num
= attribs
->hba_attribs
.phy_port
;
2491 mutex_unlock(&adapter
->mbox_lock
);
2492 pci_free_consistent(adapter
->pdev
, attribs_cmd
.size
, attribs_cmd
.va
,
2498 int be_cmd_req_native_mode(struct be_adapter
*adapter
)
2500 struct be_mcc_wrb
*wrb
;
2501 struct be_cmd_req_set_func_cap
*req
;
2504 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2507 wrb
= wrb_from_mbox(adapter
);
2513 req
= embedded_payload(wrb
);
2515 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2516 OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP
, sizeof(*req
), wrb
, NULL
);
2518 req
->valid_cap_flags
= cpu_to_le32(CAPABILITY_SW_TIMESTAMPS
|
2519 CAPABILITY_BE3_NATIVE_ERX_API
);
2520 req
->cap_flags
= cpu_to_le32(CAPABILITY_BE3_NATIVE_ERX_API
);
2522 status
= be_mbox_notify_wait(adapter
);
2524 struct be_cmd_resp_set_func_cap
*resp
= embedded_payload(wrb
);
2525 adapter
->be3_native
= le32_to_cpu(resp
->cap_flags
) &
2526 CAPABILITY_BE3_NATIVE_ERX_API
;
2527 if (!adapter
->be3_native
)
2528 dev_warn(&adapter
->pdev
->dev
,
2529 "adapter not in advanced mode\n");
2532 mutex_unlock(&adapter
->mbox_lock
);
2536 /* Get privilege(s) for a function */
2537 int be_cmd_get_fn_privileges(struct be_adapter
*adapter
, u32
*privilege
,
2540 struct be_mcc_wrb
*wrb
;
2541 struct be_cmd_req_get_fn_privileges
*req
;
2544 spin_lock_bh(&adapter
->mcc_lock
);
2546 wrb
= wrb_from_mccq(adapter
);
2552 req
= embedded_payload(wrb
);
2554 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2555 OPCODE_COMMON_GET_FN_PRIVILEGES
, sizeof(*req
),
2558 req
->hdr
.domain
= domain
;
2560 status
= be_mcc_notify_wait(adapter
);
2562 struct be_cmd_resp_get_fn_privileges
*resp
=
2563 embedded_payload(wrb
);
2564 *privilege
= le32_to_cpu(resp
->privilege_mask
);
2568 spin_unlock_bh(&adapter
->mcc_lock
);
2572 /* Uses synchronous MCCQ */
2573 int be_cmd_get_mac_from_list(struct be_adapter
*adapter
, u8
*mac
,
2574 bool *pmac_id_active
, u32
*pmac_id
, u8 domain
)
2576 struct be_mcc_wrb
*wrb
;
2577 struct be_cmd_req_get_mac_list
*req
;
2580 struct be_dma_mem get_mac_list_cmd
;
2583 memset(&get_mac_list_cmd
, 0, sizeof(struct be_dma_mem
));
2584 get_mac_list_cmd
.size
= sizeof(struct be_cmd_resp_get_mac_list
);
2585 get_mac_list_cmd
.va
= pci_alloc_consistent(adapter
->pdev
,
2586 get_mac_list_cmd
.size
,
2587 &get_mac_list_cmd
.dma
);
2589 if (!get_mac_list_cmd
.va
) {
2590 dev_err(&adapter
->pdev
->dev
,
2591 "Memory allocation failure during GET_MAC_LIST\n");
2595 spin_lock_bh(&adapter
->mcc_lock
);
2597 wrb
= wrb_from_mccq(adapter
);
2603 req
= get_mac_list_cmd
.va
;
2605 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2606 OPCODE_COMMON_GET_MAC_LIST
, sizeof(*req
),
2607 wrb
, &get_mac_list_cmd
);
2609 req
->hdr
.domain
= domain
;
2610 req
->mac_type
= MAC_ADDRESS_TYPE_NETWORK
;
2611 req
->perm_override
= 1;
2613 status
= be_mcc_notify_wait(adapter
);
2615 struct be_cmd_resp_get_mac_list
*resp
=
2616 get_mac_list_cmd
.va
;
2617 mac_count
= resp
->true_mac_count
+ resp
->pseudo_mac_count
;
2618 /* Mac list returned could contain one or more active mac_ids
2619 * or one or more true or pseudo permanant mac addresses.
2620 * If an active mac_id is present, return first active mac_id
2623 for (i
= 0; i
< mac_count
; i
++) {
2624 struct get_list_macaddr
*mac_entry
;
2628 mac_entry
= &resp
->macaddr_list
[i
];
2629 mac_addr_size
= le16_to_cpu(mac_entry
->mac_addr_size
);
2630 /* mac_id is a 32 bit value and mac_addr size
2633 if (mac_addr_size
== sizeof(u32
)) {
2634 *pmac_id_active
= true;
2635 mac_id
= mac_entry
->mac_addr_id
.s_mac_id
.mac_id
;
2636 *pmac_id
= le32_to_cpu(mac_id
);
2640 /* If no active mac_id found, return first mac addr */
2641 *pmac_id_active
= false;
2642 memcpy(mac
, resp
->macaddr_list
[0].mac_addr_id
.macaddr
,
2647 spin_unlock_bh(&adapter
->mcc_lock
);
2648 pci_free_consistent(adapter
->pdev
, get_mac_list_cmd
.size
,
2649 get_mac_list_cmd
.va
, get_mac_list_cmd
.dma
);
2653 /* Uses synchronous MCCQ */
2654 int be_cmd_set_mac_list(struct be_adapter
*adapter
, u8
*mac_array
,
2655 u8 mac_count
, u32 domain
)
2657 struct be_mcc_wrb
*wrb
;
2658 struct be_cmd_req_set_mac_list
*req
;
2660 struct be_dma_mem cmd
;
2662 memset(&cmd
, 0, sizeof(struct be_dma_mem
));
2663 cmd
.size
= sizeof(struct be_cmd_req_set_mac_list
);
2664 cmd
.va
= dma_alloc_coherent(&adapter
->pdev
->dev
, cmd
.size
,
2665 &cmd
.dma
, GFP_KERNEL
);
2667 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
2671 spin_lock_bh(&adapter
->mcc_lock
);
2673 wrb
= wrb_from_mccq(adapter
);
2680 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2681 OPCODE_COMMON_SET_MAC_LIST
, sizeof(*req
),
2684 req
->hdr
.domain
= domain
;
2685 req
->mac_count
= mac_count
;
2687 memcpy(req
->mac
, mac_array
, ETH_ALEN
*mac_count
);
2689 status
= be_mcc_notify_wait(adapter
);
2692 dma_free_coherent(&adapter
->pdev
->dev
, cmd
.size
,
2694 spin_unlock_bh(&adapter
->mcc_lock
);
2698 int be_cmd_set_hsw_config(struct be_adapter
*adapter
, u16 pvid
,
2699 u32 domain
, u16 intf_id
)
2701 struct be_mcc_wrb
*wrb
;
2702 struct be_cmd_req_set_hsw_config
*req
;
2706 spin_lock_bh(&adapter
->mcc_lock
);
2708 wrb
= wrb_from_mccq(adapter
);
2714 req
= embedded_payload(wrb
);
2715 ctxt
= &req
->context
;
2717 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2718 OPCODE_COMMON_SET_HSW_CONFIG
, sizeof(*req
), wrb
, NULL
);
2720 req
->hdr
.domain
= domain
;
2721 AMAP_SET_BITS(struct amap_set_hsw_context
, interface_id
, ctxt
, intf_id
);
2723 AMAP_SET_BITS(struct amap_set_hsw_context
, pvid_valid
, ctxt
, 1);
2724 AMAP_SET_BITS(struct amap_set_hsw_context
, pvid
, ctxt
, pvid
);
2727 be_dws_cpu_to_le(req
->context
, sizeof(req
->context
));
2728 status
= be_mcc_notify_wait(adapter
);
2731 spin_unlock_bh(&adapter
->mcc_lock
);
2735 /* Get Hyper switch config */
2736 int be_cmd_get_hsw_config(struct be_adapter
*adapter
, u16
*pvid
,
2737 u32 domain
, u16 intf_id
)
2739 struct be_mcc_wrb
*wrb
;
2740 struct be_cmd_req_get_hsw_config
*req
;
2745 spin_lock_bh(&adapter
->mcc_lock
);
2747 wrb
= wrb_from_mccq(adapter
);
2753 req
= embedded_payload(wrb
);
2754 ctxt
= &req
->context
;
2756 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2757 OPCODE_COMMON_GET_HSW_CONFIG
, sizeof(*req
), wrb
, NULL
);
2759 req
->hdr
.domain
= domain
;
2760 AMAP_SET_BITS(struct amap_get_hsw_req_context
, interface_id
, ctxt
,
2762 AMAP_SET_BITS(struct amap_get_hsw_req_context
, pvid_valid
, ctxt
, 1);
2763 be_dws_cpu_to_le(req
->context
, sizeof(req
->context
));
2765 status
= be_mcc_notify_wait(adapter
);
2767 struct be_cmd_resp_get_hsw_config
*resp
=
2768 embedded_payload(wrb
);
2769 be_dws_le_to_cpu(&resp
->context
,
2770 sizeof(resp
->context
));
2771 vid
= AMAP_GET_BITS(struct amap_get_hsw_resp_context
,
2772 pvid
, &resp
->context
);
2773 *pvid
= le16_to_cpu(vid
);
2777 spin_unlock_bh(&adapter
->mcc_lock
);
2781 int be_cmd_get_acpi_wol_cap(struct be_adapter
*adapter
)
2783 struct be_mcc_wrb
*wrb
;
2784 struct be_cmd_req_acpi_wol_magic_config_v1
*req
;
2786 int payload_len
= sizeof(*req
);
2787 struct be_dma_mem cmd
;
2789 if (!be_cmd_allowed(adapter
, OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
,
2793 memset(&cmd
, 0, sizeof(struct be_dma_mem
));
2794 cmd
.size
= sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1
);
2795 cmd
.va
= pci_alloc_consistent(adapter
->pdev
, cmd
.size
,
2798 dev_err(&adapter
->pdev
->dev
,
2799 "Memory allocation failure\n");
2803 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2806 wrb
= wrb_from_mbox(adapter
);
2814 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
2815 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
,
2816 payload_len
, wrb
, &cmd
);
2818 req
->hdr
.version
= 1;
2819 req
->query_options
= BE_GET_WOL_CAP
;
2821 status
= be_mbox_notify_wait(adapter
);
2823 struct be_cmd_resp_acpi_wol_magic_config_v1
*resp
;
2824 resp
= (struct be_cmd_resp_acpi_wol_magic_config_v1
*) cmd
.va
;
2826 /* the command could succeed misleadingly on old f/w
2827 * which is not aware of the V1 version. fake an error. */
2828 if (resp
->hdr
.response_length
< payload_len
) {
2832 adapter
->wol_cap
= resp
->wol_settings
;
2835 mutex_unlock(&adapter
->mbox_lock
);
2836 pci_free_consistent(adapter
->pdev
, cmd
.size
, cmd
.va
, cmd
.dma
);
2840 int be_cmd_get_ext_fat_capabilites(struct be_adapter
*adapter
,
2841 struct be_dma_mem
*cmd
)
2843 struct be_mcc_wrb
*wrb
;
2844 struct be_cmd_req_get_ext_fat_caps
*req
;
2847 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2850 wrb
= wrb_from_mbox(adapter
);
2857 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2858 OPCODE_COMMON_GET_EXT_FAT_CAPABILITES
,
2859 cmd
->size
, wrb
, cmd
);
2860 req
->parameter_type
= cpu_to_le32(1);
2862 status
= be_mbox_notify_wait(adapter
);
2864 mutex_unlock(&adapter
->mbox_lock
);
2868 int be_cmd_set_ext_fat_capabilites(struct be_adapter
*adapter
,
2869 struct be_dma_mem
*cmd
,
2870 struct be_fat_conf_params
*configs
)
2872 struct be_mcc_wrb
*wrb
;
2873 struct be_cmd_req_set_ext_fat_caps
*req
;
2876 spin_lock_bh(&adapter
->mcc_lock
);
2878 wrb
= wrb_from_mccq(adapter
);
2885 memcpy(&req
->set_params
, configs
, sizeof(struct be_fat_conf_params
));
2886 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2887 OPCODE_COMMON_SET_EXT_FAT_CAPABILITES
,
2888 cmd
->size
, wrb
, cmd
);
2890 status
= be_mcc_notify_wait(adapter
);
2892 spin_unlock_bh(&adapter
->mcc_lock
);
2896 int be_cmd_query_port_name(struct be_adapter
*adapter
, u8
*port_name
)
2898 struct be_mcc_wrb
*wrb
;
2899 struct be_cmd_req_get_port_name
*req
;
2902 if (!lancer_chip(adapter
)) {
2903 *port_name
= adapter
->hba_port_num
+ '0';
2907 spin_lock_bh(&adapter
->mcc_lock
);
2909 wrb
= wrb_from_mccq(adapter
);
2915 req
= embedded_payload(wrb
);
2917 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2918 OPCODE_COMMON_GET_PORT_NAME
, sizeof(*req
), wrb
,
2920 req
->hdr
.version
= 1;
2922 status
= be_mcc_notify_wait(adapter
);
2924 struct be_cmd_resp_get_port_name
*resp
= embedded_payload(wrb
);
2925 *port_name
= resp
->port_name
[adapter
->hba_port_num
];
2927 *port_name
= adapter
->hba_port_num
+ '0';
2930 spin_unlock_bh(&adapter
->mcc_lock
);
2934 static struct be_nic_resource_desc
*be_get_nic_desc(u8
*buf
, u32 desc_count
,
2937 struct be_nic_resource_desc
*desc
= (struct be_nic_resource_desc
*)buf
;
2940 for (i
= 0; i
< desc_count
; i
++) {
2941 desc
->desc_len
= RESOURCE_DESC_SIZE
;
2942 if (((void *)desc
+ desc
->desc_len
) >
2943 (void *)(buf
+ max_buf_size
)) {
2948 if (desc
->desc_type
== NIC_RESOURCE_DESC_TYPE_ID
)
2951 desc
= (void *)desc
+ desc
->desc_len
;
2954 if (!desc
|| i
== MAX_RESOURCE_DESC
)
2961 int be_cmd_get_func_config(struct be_adapter
*adapter
)
2963 struct be_mcc_wrb
*wrb
;
2964 struct be_cmd_req_get_func_config
*req
;
2966 struct be_dma_mem cmd
;
2968 memset(&cmd
, 0, sizeof(struct be_dma_mem
));
2969 cmd
.size
= sizeof(struct be_cmd_resp_get_func_config
);
2970 cmd
.va
= pci_alloc_consistent(adapter
->pdev
, cmd
.size
,
2973 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
2976 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2979 wrb
= wrb_from_mbox(adapter
);
2987 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2988 OPCODE_COMMON_GET_FUNC_CONFIG
,
2989 cmd
.size
, wrb
, &cmd
);
2991 status
= be_mbox_notify_wait(adapter
);
2993 struct be_cmd_resp_get_func_config
*resp
= cmd
.va
;
2994 u32 desc_count
= le32_to_cpu(resp
->desc_count
);
2995 struct be_nic_resource_desc
*desc
;
2997 desc
= be_get_nic_desc(resp
->func_param
, desc_count
,
2998 sizeof(resp
->func_param
));
3004 adapter
->pf_number
= desc
->pf_num
;
3005 adapter
->max_pmac_cnt
= le16_to_cpu(desc
->unicast_mac_count
);
3006 adapter
->max_vlans
= le16_to_cpu(desc
->vlan_count
);
3007 adapter
->max_mcast_mac
= le16_to_cpu(desc
->mcast_mac_count
);
3008 adapter
->max_tx_queues
= le16_to_cpu(desc
->txq_count
);
3009 adapter
->max_rss_queues
= le16_to_cpu(desc
->rssq_count
);
3010 adapter
->max_rx_queues
= le16_to_cpu(desc
->rq_count
);
3012 adapter
->max_event_queues
= le16_to_cpu(desc
->eq_count
);
3013 adapter
->if_cap_flags
= le32_to_cpu(desc
->cap_flags
);
3016 mutex_unlock(&adapter
->mbox_lock
);
3017 pci_free_consistent(adapter
->pdev
, cmd
.size
,
3023 int be_cmd_get_profile_config(struct be_adapter
*adapter
, u32
*cap_flags
,
3026 struct be_mcc_wrb
*wrb
;
3027 struct be_cmd_req_get_profile_config
*req
;
3029 struct be_dma_mem cmd
;
3031 memset(&cmd
, 0, sizeof(struct be_dma_mem
));
3032 cmd
.size
= sizeof(struct be_cmd_resp_get_profile_config
);
3033 cmd
.va
= pci_alloc_consistent(adapter
->pdev
, cmd
.size
,
3036 dev_err(&adapter
->pdev
->dev
, "Memory alloc failure\n");
3040 spin_lock_bh(&adapter
->mcc_lock
);
3042 wrb
= wrb_from_mccq(adapter
);
3050 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
3051 OPCODE_COMMON_GET_PROFILE_CONFIG
,
3052 cmd
.size
, wrb
, &cmd
);
3054 req
->type
= ACTIVE_PROFILE_TYPE
;
3055 req
->hdr
.domain
= domain
;
3057 status
= be_mcc_notify_wait(adapter
);
3059 struct be_cmd_resp_get_profile_config
*resp
= cmd
.va
;
3060 u32 desc_count
= le32_to_cpu(resp
->desc_count
);
3061 struct be_nic_resource_desc
*desc
;
3063 desc
= be_get_nic_desc(resp
->func_param
, desc_count
,
3064 sizeof(resp
->func_param
));
3070 *cap_flags
= le32_to_cpu(desc
->cap_flags
);
3073 spin_unlock_bh(&adapter
->mcc_lock
);
3074 pci_free_consistent(adapter
->pdev
, cmd
.size
,
3080 int be_cmd_set_profile_config(struct be_adapter
*adapter
, u32 bps
,
3083 struct be_mcc_wrb
*wrb
;
3084 struct be_cmd_req_set_profile_config
*req
;
3087 spin_lock_bh(&adapter
->mcc_lock
);
3089 wrb
= wrb_from_mccq(adapter
);
3095 req
= embedded_payload(wrb
);
3097 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
3098 OPCODE_COMMON_SET_PROFILE_CONFIG
, sizeof(*req
),
3101 req
->hdr
.domain
= domain
;
3102 req
->desc_count
= cpu_to_le32(1);
3104 req
->nic_desc
.desc_type
= NIC_RESOURCE_DESC_TYPE_ID
;
3105 req
->nic_desc
.desc_len
= RESOURCE_DESC_SIZE
;
3106 req
->nic_desc
.flags
= (1 << QUN
) | (1 << IMM
) | (1 << NOSV
);
3107 req
->nic_desc
.pf_num
= adapter
->pf_number
;
3108 req
->nic_desc
.vf_num
= domain
;
3110 /* Mark fields invalid */
3111 req
->nic_desc
.unicast_mac_count
= 0xFFFF;
3112 req
->nic_desc
.mcc_count
= 0xFFFF;
3113 req
->nic_desc
.vlan_count
= 0xFFFF;
3114 req
->nic_desc
.mcast_mac_count
= 0xFFFF;
3115 req
->nic_desc
.txq_count
= 0xFFFF;
3116 req
->nic_desc
.rq_count
= 0xFFFF;
3117 req
->nic_desc
.rssq_count
= 0xFFFF;
3118 req
->nic_desc
.lro_count
= 0xFFFF;
3119 req
->nic_desc
.cq_count
= 0xFFFF;
3120 req
->nic_desc
.toe_conn_count
= 0xFFFF;
3121 req
->nic_desc
.eq_count
= 0xFFFF;
3122 req
->nic_desc
.link_param
= 0xFF;
3123 req
->nic_desc
.bw_min
= 0xFFFFFFFF;
3124 req
->nic_desc
.acpi_params
= 0xFF;
3125 req
->nic_desc
.wol_param
= 0x0F;
3128 req
->nic_desc
.bw_min
= cpu_to_le32(bps
);
3129 req
->nic_desc
.bw_max
= cpu_to_le32(bps
);
3130 status
= be_mcc_notify_wait(adapter
);
3132 spin_unlock_bh(&adapter
->mcc_lock
);
3137 int be_cmd_enable_vf(struct be_adapter
*adapter
, u8 domain
)
3139 struct be_mcc_wrb
*wrb
;
3140 struct be_cmd_enable_disable_vf
*req
;
3143 if (!lancer_chip(adapter
))
3146 spin_lock_bh(&adapter
->mcc_lock
);
3148 wrb
= wrb_from_mccq(adapter
);
3154 req
= embedded_payload(wrb
);
3156 be_wrb_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
3157 OPCODE_COMMON_ENABLE_DISABLE_VF
, sizeof(*req
),
3160 req
->hdr
.domain
= domain
;
3162 status
= be_mcc_notify_wait(adapter
);
3164 spin_unlock_bh(&adapter
->mcc_lock
);
3168 int be_roce_mcc_cmd(void *netdev_handle
, void *wrb_payload
,
3169 int wrb_payload_size
, u16
*cmd_status
, u16
*ext_status
)
3171 struct be_adapter
*adapter
= netdev_priv(netdev_handle
);
3172 struct be_mcc_wrb
*wrb
;
3173 struct be_cmd_req_hdr
*hdr
= (struct be_cmd_req_hdr
*) wrb_payload
;
3174 struct be_cmd_req_hdr
*req
;
3175 struct be_cmd_resp_hdr
*resp
;
3178 spin_lock_bh(&adapter
->mcc_lock
);
3180 wrb
= wrb_from_mccq(adapter
);
3185 req
= embedded_payload(wrb
);
3186 resp
= embedded_payload(wrb
);
3188 be_wrb_cmd_hdr_prepare(req
, hdr
->subsystem
,
3189 hdr
->opcode
, wrb_payload_size
, wrb
, NULL
);
3190 memcpy(req
, wrb_payload
, wrb_payload_size
);
3191 be_dws_cpu_to_le(req
, wrb_payload_size
);
3193 status
= be_mcc_notify_wait(adapter
);
3195 *cmd_status
= (status
& 0xffff);
3198 memcpy(wrb_payload
, resp
, sizeof(*resp
) + resp
->response_length
);
3199 be_dws_le_to_cpu(wrb_payload
, sizeof(*resp
) + resp
->response_length
);
3201 spin_unlock_bh(&adapter
->mcc_lock
);
3204 EXPORT_SYMBOL(be_roce_mcc_cmd
);