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
21 /* Must be a power of 2 or else MODULO will BUG_ON */
22 static int be_get_temp_freq
= 32;
24 static void be_mcc_notify(struct be_adapter
*adapter
)
26 struct be_queue_info
*mccq
= &adapter
->mcc_obj
.q
;
29 if (adapter
->eeh_err
) {
30 dev_info(&adapter
->pdev
->dev
,
31 "Error in Card Detected! Cannot issue commands\n");
35 val
|= mccq
->id
& DB_MCCQ_RING_ID_MASK
;
36 val
|= 1 << DB_MCCQ_NUM_POSTED_SHIFT
;
39 iowrite32(val
, adapter
->db
+ DB_MCCQ_OFFSET
);
42 /* To check if valid bit is set, check the entire word as we don't know
43 * the endianness of the data (old entry is host endian while a new entry is
45 static inline bool be_mcc_compl_is_new(struct be_mcc_compl
*compl)
47 if (compl->flags
!= 0) {
48 compl->flags
= le32_to_cpu(compl->flags
);
49 BUG_ON((compl->flags
& CQE_FLAGS_VALID_MASK
) == 0);
56 /* Need to reset the entire word that houses the valid bit */
57 static inline void be_mcc_compl_use(struct be_mcc_compl
*compl)
62 static int be_mcc_compl_process(struct be_adapter
*adapter
,
63 struct be_mcc_compl
*compl)
65 u16 compl_status
, extd_status
;
67 /* Just swap the status to host endian; mcc tag is opaquely copied
69 be_dws_le_to_cpu(compl, 4);
71 compl_status
= (compl->status
>> CQE_STATUS_COMPL_SHIFT
) &
72 CQE_STATUS_COMPL_MASK
;
74 if ((compl->tag0
== OPCODE_COMMON_WRITE_FLASHROM
) &&
75 (compl->tag1
== CMD_SUBSYSTEM_COMMON
)) {
76 adapter
->flash_status
= compl_status
;
77 complete(&adapter
->flash_compl
);
80 if (compl_status
== MCC_STATUS_SUCCESS
) {
81 if ((compl->tag0
== OPCODE_ETH_GET_STATISTICS
) &&
82 (compl->tag1
== CMD_SUBSYSTEM_ETH
)) {
83 if (adapter
->generation
== BE_GEN3
) {
84 struct be_cmd_resp_get_stats_v1
*resp
=
85 adapter
->stats_cmd
.va
;
87 be_dws_le_to_cpu(&resp
->hw_stats
,
88 sizeof(resp
->hw_stats
));
90 struct be_cmd_resp_get_stats_v0
*resp
=
91 adapter
->stats_cmd
.va
;
93 be_dws_le_to_cpu(&resp
->hw_stats
,
94 sizeof(resp
->hw_stats
));
96 be_parse_stats(adapter
);
97 netdev_stats_update(adapter
);
98 adapter
->stats_cmd_sent
= false;
100 } else if ((compl_status
!= MCC_STATUS_NOT_SUPPORTED
) &&
101 (compl->tag0
!= OPCODE_COMMON_NTWK_MAC_QUERY
)) {
102 extd_status
= (compl->status
>> CQE_STATUS_EXTD_SHIFT
) &
103 CQE_STATUS_EXTD_MASK
;
104 dev_warn(&adapter
->pdev
->dev
,
105 "Error in cmd completion - opcode %d, compl %d, extd %d\n",
106 compl->tag0
, compl_status
, extd_status
);
111 /* Link state evt is a string of bytes; no need for endian swapping */
112 static void be_async_link_state_process(struct be_adapter
*adapter
,
113 struct be_async_event_link_state
*evt
)
115 be_link_status_update(adapter
,
116 evt
->port_link_status
== ASYNC_EVENT_LINK_UP
);
119 /* Grp5 CoS Priority evt */
120 static void be_async_grp5_cos_priority_process(struct be_adapter
*adapter
,
121 struct be_async_event_grp5_cos_priority
*evt
)
124 adapter
->vlan_prio_bmap
= evt
->available_priority_bmap
;
125 adapter
->recommended_prio
&= ~VLAN_PRIO_MASK
;
126 adapter
->recommended_prio
=
127 evt
->reco_default_priority
<< VLAN_PRIO_SHIFT
;
131 /* Grp5 QOS Speed evt */
132 static void be_async_grp5_qos_speed_process(struct be_adapter
*adapter
,
133 struct be_async_event_grp5_qos_link_speed
*evt
)
135 if (evt
->physical_port
== adapter
->port_num
) {
136 /* qos_link_speed is in units of 10 Mbps */
137 adapter
->link_speed
= evt
->qos_link_speed
* 10;
142 static void be_async_grp5_pvid_state_process(struct be_adapter
*adapter
,
143 struct be_async_event_grp5_pvid_state
*evt
)
146 adapter
->pvid
= le16_to_cpu(evt
->tag
);
151 static void be_async_grp5_evt_process(struct be_adapter
*adapter
,
152 u32 trailer
, struct be_mcc_compl
*evt
)
156 event_type
= (trailer
>> ASYNC_TRAILER_EVENT_TYPE_SHIFT
) &
157 ASYNC_TRAILER_EVENT_TYPE_MASK
;
159 switch (event_type
) {
160 case ASYNC_EVENT_COS_PRIORITY
:
161 be_async_grp5_cos_priority_process(adapter
,
162 (struct be_async_event_grp5_cos_priority
*)evt
);
164 case ASYNC_EVENT_QOS_SPEED
:
165 be_async_grp5_qos_speed_process(adapter
,
166 (struct be_async_event_grp5_qos_link_speed
*)evt
);
168 case ASYNC_EVENT_PVID_STATE
:
169 be_async_grp5_pvid_state_process(adapter
,
170 (struct be_async_event_grp5_pvid_state
*)evt
);
173 dev_warn(&adapter
->pdev
->dev
, "Unknown grp5 event!\n");
178 static inline bool is_link_state_evt(u32 trailer
)
180 return ((trailer
>> ASYNC_TRAILER_EVENT_CODE_SHIFT
) &
181 ASYNC_TRAILER_EVENT_CODE_MASK
) ==
182 ASYNC_EVENT_CODE_LINK_STATE
;
185 static inline bool is_grp5_evt(u32 trailer
)
187 return (((trailer
>> ASYNC_TRAILER_EVENT_CODE_SHIFT
) &
188 ASYNC_TRAILER_EVENT_CODE_MASK
) ==
189 ASYNC_EVENT_CODE_GRP_5
);
192 static struct be_mcc_compl
*be_mcc_compl_get(struct be_adapter
*adapter
)
194 struct be_queue_info
*mcc_cq
= &adapter
->mcc_obj
.cq
;
195 struct be_mcc_compl
*compl = queue_tail_node(mcc_cq
);
197 if (be_mcc_compl_is_new(compl)) {
198 queue_tail_inc(mcc_cq
);
204 void be_async_mcc_enable(struct be_adapter
*adapter
)
206 spin_lock_bh(&adapter
->mcc_cq_lock
);
208 be_cq_notify(adapter
, adapter
->mcc_obj
.cq
.id
, true, 0);
209 adapter
->mcc_obj
.rearm_cq
= true;
211 spin_unlock_bh(&adapter
->mcc_cq_lock
);
214 void be_async_mcc_disable(struct be_adapter
*adapter
)
216 adapter
->mcc_obj
.rearm_cq
= false;
219 int be_process_mcc(struct be_adapter
*adapter
, int *status
)
221 struct be_mcc_compl
*compl;
223 struct be_mcc_obj
*mcc_obj
= &adapter
->mcc_obj
;
225 spin_lock_bh(&adapter
->mcc_cq_lock
);
226 while ((compl = be_mcc_compl_get(adapter
))) {
227 if (compl->flags
& CQE_FLAGS_ASYNC_MASK
) {
228 /* Interpret flags as an async trailer */
229 if (is_link_state_evt(compl->flags
))
230 be_async_link_state_process(adapter
,
231 (struct be_async_event_link_state
*) compl);
232 else if (is_grp5_evt(compl->flags
))
233 be_async_grp5_evt_process(adapter
,
234 compl->flags
, compl);
235 } else if (compl->flags
& CQE_FLAGS_COMPLETED_MASK
) {
236 *status
= be_mcc_compl_process(adapter
, compl);
237 atomic_dec(&mcc_obj
->q
.used
);
239 be_mcc_compl_use(compl);
243 spin_unlock_bh(&adapter
->mcc_cq_lock
);
247 /* Wait till no more pending mcc requests are present */
248 static int be_mcc_wait_compl(struct be_adapter
*adapter
)
250 #define mcc_timeout 120000 /* 12s timeout */
251 int i
, num
, status
= 0;
252 struct be_mcc_obj
*mcc_obj
= &adapter
->mcc_obj
;
254 if (adapter
->eeh_err
)
257 for (i
= 0; i
< mcc_timeout
; i
++) {
258 num
= be_process_mcc(adapter
, &status
);
260 be_cq_notify(adapter
, mcc_obj
->cq
.id
,
261 mcc_obj
->rearm_cq
, num
);
263 if (atomic_read(&mcc_obj
->q
.used
) == 0)
267 if (i
== mcc_timeout
) {
268 dev_err(&adapter
->pdev
->dev
, "mccq poll timed out\n");
274 /* Notify MCC requests and wait for completion */
275 static int be_mcc_notify_wait(struct be_adapter
*adapter
)
277 be_mcc_notify(adapter
);
278 return be_mcc_wait_compl(adapter
);
281 static int be_mbox_db_ready_wait(struct be_adapter
*adapter
, void __iomem
*db
)
286 if (adapter
->eeh_err
) {
287 dev_err(&adapter
->pdev
->dev
,
288 "Error detected in card.Cannot issue commands\n");
293 ready
= ioread32(db
);
294 if (ready
== 0xffffffff) {
295 dev_err(&adapter
->pdev
->dev
,
296 "pci slot disconnected\n");
300 ready
&= MPU_MAILBOX_DB_RDY_MASK
;
305 dev_err(&adapter
->pdev
->dev
, "mbox poll timed out\n");
306 if (!lancer_chip(adapter
))
307 be_detect_dump_ue(adapter
);
319 * Insert the mailbox address into the doorbell in two steps
320 * Polls on the mbox doorbell till a command completion (or a timeout) occurs
322 static int be_mbox_notify_wait(struct be_adapter
*adapter
)
326 void __iomem
*db
= adapter
->db
+ MPU_MAILBOX_DB_OFFSET
;
327 struct be_dma_mem
*mbox_mem
= &adapter
->mbox_mem
;
328 struct be_mcc_mailbox
*mbox
= mbox_mem
->va
;
329 struct be_mcc_compl
*compl = &mbox
->compl;
331 /* wait for ready to be set */
332 status
= be_mbox_db_ready_wait(adapter
, db
);
336 val
|= MPU_MAILBOX_DB_HI_MASK
;
337 /* at bits 2 - 31 place mbox dma addr msb bits 34 - 63 */
338 val
|= (upper_32_bits(mbox_mem
->dma
) >> 2) << 2;
341 /* wait for ready to be set */
342 status
= be_mbox_db_ready_wait(adapter
, db
);
347 /* at bits 2 - 31 place mbox dma addr lsb bits 4 - 33 */
348 val
|= (u32
)(mbox_mem
->dma
>> 4) << 2;
351 status
= be_mbox_db_ready_wait(adapter
, db
);
355 /* A cq entry has been made now */
356 if (be_mcc_compl_is_new(compl)) {
357 status
= be_mcc_compl_process(adapter
, &mbox
->compl);
358 be_mcc_compl_use(compl);
362 dev_err(&adapter
->pdev
->dev
, "invalid mailbox completion\n");
368 static int be_POST_stage_get(struct be_adapter
*adapter
, u16
*stage
)
372 if (lancer_chip(adapter
))
373 sem
= ioread32(adapter
->db
+ MPU_EP_SEMAPHORE_IF_TYPE2_OFFSET
);
375 sem
= ioread32(adapter
->csr
+ MPU_EP_SEMAPHORE_OFFSET
);
377 *stage
= sem
& EP_SEMAPHORE_POST_STAGE_MASK
;
378 if ((sem
>> EP_SEMAPHORE_POST_ERR_SHIFT
) & EP_SEMAPHORE_POST_ERR_MASK
)
384 int be_cmd_POST(struct be_adapter
*adapter
)
387 int status
, timeout
= 0;
388 struct device
*dev
= &adapter
->pdev
->dev
;
391 status
= be_POST_stage_get(adapter
, &stage
);
393 dev_err(dev
, "POST error; stage=0x%x\n", stage
);
395 } else if (stage
!= POST_STAGE_ARMFW_RDY
) {
396 if (msleep_interruptible(2000)) {
397 dev_err(dev
, "Waiting for POST aborted\n");
404 } while (timeout
< 40);
406 dev_err(dev
, "POST timeout; stage=0x%x\n", stage
);
410 static inline void *embedded_payload(struct be_mcc_wrb
*wrb
)
412 return wrb
->payload
.embedded_payload
;
415 static inline struct be_sge
*nonembedded_sgl(struct be_mcc_wrb
*wrb
)
417 return &wrb
->payload
.sgl
[0];
420 /* Don't touch the hdr after it's prepared */
421 static void be_wrb_hdr_prepare(struct be_mcc_wrb
*wrb
, int payload_len
,
422 bool embedded
, u8 sge_cnt
, u32 opcode
)
425 wrb
->embedded
|= MCC_WRB_EMBEDDED_MASK
;
427 wrb
->embedded
|= (sge_cnt
& MCC_WRB_SGE_CNT_MASK
) <<
428 MCC_WRB_SGE_CNT_SHIFT
;
429 wrb
->payload_length
= payload_len
;
431 be_dws_cpu_to_le(wrb
, 8);
434 /* Don't touch the hdr after it's prepared */
435 static void be_cmd_hdr_prepare(struct be_cmd_req_hdr
*req_hdr
,
436 u8 subsystem
, u8 opcode
, int cmd_len
)
438 req_hdr
->opcode
= opcode
;
439 req_hdr
->subsystem
= subsystem
;
440 req_hdr
->request_length
= cpu_to_le32(cmd_len
- sizeof(*req_hdr
));
441 req_hdr
->version
= 0;
444 static void be_cmd_page_addrs_prepare(struct phys_addr
*pages
, u32 max_pages
,
445 struct be_dma_mem
*mem
)
447 int i
, buf_pages
= min(PAGES_4K_SPANNED(mem
->va
, mem
->size
), max_pages
);
448 u64 dma
= (u64
)mem
->dma
;
450 for (i
= 0; i
< buf_pages
; i
++) {
451 pages
[i
].lo
= cpu_to_le32(dma
& 0xFFFFFFFF);
452 pages
[i
].hi
= cpu_to_le32(upper_32_bits(dma
));
457 /* Converts interrupt delay in microseconds to multiplier value */
458 static u32
eq_delay_to_mult(u32 usec_delay
)
460 #define MAX_INTR_RATE 651042
461 const u32 round
= 10;
467 u32 interrupt_rate
= 1000000 / usec_delay
;
468 /* Max delay, corresponding to the lowest interrupt rate */
469 if (interrupt_rate
== 0)
472 multiplier
= (MAX_INTR_RATE
- interrupt_rate
) * round
;
473 multiplier
/= interrupt_rate
;
474 /* Round the multiplier to the closest value.*/
475 multiplier
= (multiplier
+ round
/2) / round
;
476 multiplier
= min(multiplier
, (u32
)1023);
482 static inline struct be_mcc_wrb
*wrb_from_mbox(struct be_adapter
*adapter
)
484 struct be_dma_mem
*mbox_mem
= &adapter
->mbox_mem
;
485 struct be_mcc_wrb
*wrb
486 = &((struct be_mcc_mailbox
*)(mbox_mem
->va
))->wrb
;
487 memset(wrb
, 0, sizeof(*wrb
));
491 static struct be_mcc_wrb
*wrb_from_mccq(struct be_adapter
*adapter
)
493 struct be_queue_info
*mccq
= &adapter
->mcc_obj
.q
;
494 struct be_mcc_wrb
*wrb
;
496 if (atomic_read(&mccq
->used
) >= mccq
->len
) {
497 dev_err(&adapter
->pdev
->dev
, "Out of MCCQ wrbs\n");
501 wrb
= queue_head_node(mccq
);
502 queue_head_inc(mccq
);
503 atomic_inc(&mccq
->used
);
504 memset(wrb
, 0, sizeof(*wrb
));
508 /* Tell fw we're about to start firing cmds by writing a
509 * special pattern across the wrb hdr; uses mbox
511 int be_cmd_fw_init(struct be_adapter
*adapter
)
516 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
519 wrb
= (u8
*)wrb_from_mbox(adapter
);
529 status
= be_mbox_notify_wait(adapter
);
531 mutex_unlock(&adapter
->mbox_lock
);
535 /* Tell fw we're done with firing cmds by writing a
536 * special pattern across the wrb hdr; uses mbox
538 int be_cmd_fw_clean(struct be_adapter
*adapter
)
543 if (adapter
->eeh_err
)
546 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
549 wrb
= (u8
*)wrb_from_mbox(adapter
);
559 status
= be_mbox_notify_wait(adapter
);
561 mutex_unlock(&adapter
->mbox_lock
);
564 int be_cmd_eq_create(struct be_adapter
*adapter
,
565 struct be_queue_info
*eq
, int eq_delay
)
567 struct be_mcc_wrb
*wrb
;
568 struct be_cmd_req_eq_create
*req
;
569 struct be_dma_mem
*q_mem
= &eq
->dma_mem
;
572 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
575 wrb
= wrb_from_mbox(adapter
);
576 req
= embedded_payload(wrb
);
578 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0, OPCODE_COMMON_EQ_CREATE
);
580 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
581 OPCODE_COMMON_EQ_CREATE
, sizeof(*req
));
583 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
585 AMAP_SET_BITS(struct amap_eq_context
, valid
, req
->context
, 1);
587 AMAP_SET_BITS(struct amap_eq_context
, size
, req
->context
, 0);
588 AMAP_SET_BITS(struct amap_eq_context
, count
, req
->context
,
589 __ilog2_u32(eq
->len
/256));
590 AMAP_SET_BITS(struct amap_eq_context
, delaymult
, req
->context
,
591 eq_delay_to_mult(eq_delay
));
592 be_dws_cpu_to_le(req
->context
, sizeof(req
->context
));
594 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
596 status
= be_mbox_notify_wait(adapter
);
598 struct be_cmd_resp_eq_create
*resp
= embedded_payload(wrb
);
599 eq
->id
= le16_to_cpu(resp
->eq_id
);
603 mutex_unlock(&adapter
->mbox_lock
);
608 int be_cmd_mac_addr_query(struct be_adapter
*adapter
, u8
*mac_addr
,
609 u8 type
, bool permanent
, u32 if_handle
)
611 struct be_mcc_wrb
*wrb
;
612 struct be_cmd_req_mac_query
*req
;
615 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
618 wrb
= wrb_from_mbox(adapter
);
619 req
= embedded_payload(wrb
);
621 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
622 OPCODE_COMMON_NTWK_MAC_QUERY
);
624 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
625 OPCODE_COMMON_NTWK_MAC_QUERY
, sizeof(*req
));
631 req
->if_id
= cpu_to_le16((u16
) if_handle
);
635 status
= be_mbox_notify_wait(adapter
);
637 struct be_cmd_resp_mac_query
*resp
= embedded_payload(wrb
);
638 memcpy(mac_addr
, resp
->mac
.addr
, ETH_ALEN
);
641 mutex_unlock(&adapter
->mbox_lock
);
645 /* Uses synchronous MCCQ */
646 int be_cmd_pmac_add(struct be_adapter
*adapter
, u8
*mac_addr
,
647 u32 if_id
, u32
*pmac_id
, u32 domain
)
649 struct be_mcc_wrb
*wrb
;
650 struct be_cmd_req_pmac_add
*req
;
653 spin_lock_bh(&adapter
->mcc_lock
);
655 wrb
= wrb_from_mccq(adapter
);
660 req
= embedded_payload(wrb
);
662 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
663 OPCODE_COMMON_NTWK_PMAC_ADD
);
665 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
666 OPCODE_COMMON_NTWK_PMAC_ADD
, sizeof(*req
));
668 req
->hdr
.domain
= domain
;
669 req
->if_id
= cpu_to_le32(if_id
);
670 memcpy(req
->mac_address
, mac_addr
, ETH_ALEN
);
672 status
= be_mcc_notify_wait(adapter
);
674 struct be_cmd_resp_pmac_add
*resp
= embedded_payload(wrb
);
675 *pmac_id
= le32_to_cpu(resp
->pmac_id
);
679 spin_unlock_bh(&adapter
->mcc_lock
);
683 /* Uses synchronous MCCQ */
684 int be_cmd_pmac_del(struct be_adapter
*adapter
, u32 if_id
, u32 pmac_id
, u32 dom
)
686 struct be_mcc_wrb
*wrb
;
687 struct be_cmd_req_pmac_del
*req
;
690 spin_lock_bh(&adapter
->mcc_lock
);
692 wrb
= wrb_from_mccq(adapter
);
697 req
= embedded_payload(wrb
);
699 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
700 OPCODE_COMMON_NTWK_PMAC_DEL
);
702 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
703 OPCODE_COMMON_NTWK_PMAC_DEL
, sizeof(*req
));
705 req
->hdr
.domain
= dom
;
706 req
->if_id
= cpu_to_le32(if_id
);
707 req
->pmac_id
= cpu_to_le32(pmac_id
);
709 status
= be_mcc_notify_wait(adapter
);
712 spin_unlock_bh(&adapter
->mcc_lock
);
717 int be_cmd_cq_create(struct be_adapter
*adapter
,
718 struct be_queue_info
*cq
, struct be_queue_info
*eq
,
719 bool sol_evts
, bool no_delay
, int coalesce_wm
)
721 struct be_mcc_wrb
*wrb
;
722 struct be_cmd_req_cq_create
*req
;
723 struct be_dma_mem
*q_mem
= &cq
->dma_mem
;
727 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
730 wrb
= wrb_from_mbox(adapter
);
731 req
= embedded_payload(wrb
);
732 ctxt
= &req
->context
;
734 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
735 OPCODE_COMMON_CQ_CREATE
);
737 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
738 OPCODE_COMMON_CQ_CREATE
, sizeof(*req
));
740 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
741 if (lancer_chip(adapter
)) {
742 req
->hdr
.version
= 2;
743 req
->page_size
= 1; /* 1 for 4K */
744 AMAP_SET_BITS(struct amap_cq_context_lancer
, nodelay
, ctxt
,
746 AMAP_SET_BITS(struct amap_cq_context_lancer
, count
, ctxt
,
747 __ilog2_u32(cq
->len
/256));
748 AMAP_SET_BITS(struct amap_cq_context_lancer
, valid
, ctxt
, 1);
749 AMAP_SET_BITS(struct amap_cq_context_lancer
, eventable
,
751 AMAP_SET_BITS(struct amap_cq_context_lancer
, eqid
,
753 AMAP_SET_BITS(struct amap_cq_context_lancer
, armed
, ctxt
, 1);
755 AMAP_SET_BITS(struct amap_cq_context_be
, coalescwm
, ctxt
,
757 AMAP_SET_BITS(struct amap_cq_context_be
, nodelay
,
759 AMAP_SET_BITS(struct amap_cq_context_be
, count
, ctxt
,
760 __ilog2_u32(cq
->len
/256));
761 AMAP_SET_BITS(struct amap_cq_context_be
, valid
, ctxt
, 1);
762 AMAP_SET_BITS(struct amap_cq_context_be
, solevent
,
764 AMAP_SET_BITS(struct amap_cq_context_be
, eventable
, ctxt
, 1);
765 AMAP_SET_BITS(struct amap_cq_context_be
, eqid
, ctxt
, eq
->id
);
766 AMAP_SET_BITS(struct amap_cq_context_be
, armed
, ctxt
, 1);
769 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
771 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
773 status
= be_mbox_notify_wait(adapter
);
775 struct be_cmd_resp_cq_create
*resp
= embedded_payload(wrb
);
776 cq
->id
= le16_to_cpu(resp
->cq_id
);
780 mutex_unlock(&adapter
->mbox_lock
);
785 static u32
be_encoded_q_len(int q_len
)
787 u32 len_encoded
= fls(q_len
); /* log2(len) + 1 */
788 if (len_encoded
== 16)
793 int be_cmd_mccq_create(struct be_adapter
*adapter
,
794 struct be_queue_info
*mccq
,
795 struct be_queue_info
*cq
)
797 struct be_mcc_wrb
*wrb
;
798 struct be_cmd_req_mcc_create
*req
;
799 struct be_dma_mem
*q_mem
= &mccq
->dma_mem
;
803 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
806 wrb
= wrb_from_mbox(adapter
);
807 req
= embedded_payload(wrb
);
808 ctxt
= &req
->context
;
810 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
811 OPCODE_COMMON_MCC_CREATE_EXT
);
813 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
814 OPCODE_COMMON_MCC_CREATE_EXT
, sizeof(*req
));
816 req
->num_pages
= cpu_to_le16(PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
));
817 if (lancer_chip(adapter
)) {
818 req
->hdr
.version
= 1;
819 req
->cq_id
= cpu_to_le16(cq
->id
);
821 AMAP_SET_BITS(struct amap_mcc_context_lancer
, ring_size
, ctxt
,
822 be_encoded_q_len(mccq
->len
));
823 AMAP_SET_BITS(struct amap_mcc_context_lancer
, valid
, ctxt
, 1);
824 AMAP_SET_BITS(struct amap_mcc_context_lancer
, async_cq_id
,
826 AMAP_SET_BITS(struct amap_mcc_context_lancer
, async_cq_valid
,
830 AMAP_SET_BITS(struct amap_mcc_context_be
, valid
, ctxt
, 1);
831 AMAP_SET_BITS(struct amap_mcc_context_be
, ring_size
, ctxt
,
832 be_encoded_q_len(mccq
->len
));
833 AMAP_SET_BITS(struct amap_mcc_context_be
, cq_id
, ctxt
, cq
->id
);
836 /* Subscribe to Link State and Group 5 Events(bits 1 and 5 set) */
837 req
->async_event_bitmap
[0] = cpu_to_le32(0x00000022);
838 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
840 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
842 status
= be_mbox_notify_wait(adapter
);
844 struct be_cmd_resp_mcc_create
*resp
= embedded_payload(wrb
);
845 mccq
->id
= le16_to_cpu(resp
->id
);
846 mccq
->created
= true;
848 mutex_unlock(&adapter
->mbox_lock
);
853 int be_cmd_txq_create(struct be_adapter
*adapter
,
854 struct be_queue_info
*txq
,
855 struct be_queue_info
*cq
)
857 struct be_mcc_wrb
*wrb
;
858 struct be_cmd_req_eth_tx_create
*req
;
859 struct be_dma_mem
*q_mem
= &txq
->dma_mem
;
863 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
866 wrb
= wrb_from_mbox(adapter
);
867 req
= embedded_payload(wrb
);
868 ctxt
= &req
->context
;
870 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
871 OPCODE_ETH_TX_CREATE
);
873 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
, OPCODE_ETH_TX_CREATE
,
876 if (lancer_chip(adapter
)) {
877 req
->hdr
.version
= 1;
878 AMAP_SET_BITS(struct amap_tx_context
, if_id
, ctxt
,
882 req
->num_pages
= PAGES_4K_SPANNED(q_mem
->va
, q_mem
->size
);
883 req
->ulp_num
= BE_ULP1_NUM
;
884 req
->type
= BE_ETH_TX_RING_TYPE_STANDARD
;
886 AMAP_SET_BITS(struct amap_tx_context
, tx_ring_size
, ctxt
,
887 be_encoded_q_len(txq
->len
));
888 AMAP_SET_BITS(struct amap_tx_context
, ctx_valid
, ctxt
, 1);
889 AMAP_SET_BITS(struct amap_tx_context
, cq_id_send
, ctxt
, cq
->id
);
891 be_dws_cpu_to_le(ctxt
, sizeof(req
->context
));
893 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
895 status
= be_mbox_notify_wait(adapter
);
897 struct be_cmd_resp_eth_tx_create
*resp
= embedded_payload(wrb
);
898 txq
->id
= le16_to_cpu(resp
->cid
);
902 mutex_unlock(&adapter
->mbox_lock
);
908 int be_cmd_rxq_create(struct be_adapter
*adapter
,
909 struct be_queue_info
*rxq
, u16 cq_id
, u16 frag_size
,
910 u16 max_frame_size
, u32 if_id
, u32 rss
, u8
*rss_id
)
912 struct be_mcc_wrb
*wrb
;
913 struct be_cmd_req_eth_rx_create
*req
;
914 struct be_dma_mem
*q_mem
= &rxq
->dma_mem
;
917 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
920 wrb
= wrb_from_mbox(adapter
);
921 req
= embedded_payload(wrb
);
923 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
924 OPCODE_ETH_RX_CREATE
);
926 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
, OPCODE_ETH_RX_CREATE
,
929 req
->cq_id
= cpu_to_le16(cq_id
);
930 req
->frag_size
= fls(frag_size
) - 1;
932 be_cmd_page_addrs_prepare(req
->pages
, ARRAY_SIZE(req
->pages
), q_mem
);
933 req
->interface_id
= cpu_to_le32(if_id
);
934 req
->max_frame_size
= cpu_to_le16(max_frame_size
);
935 req
->rss_queue
= cpu_to_le32(rss
);
937 status
= be_mbox_notify_wait(adapter
);
939 struct be_cmd_resp_eth_rx_create
*resp
= embedded_payload(wrb
);
940 rxq
->id
= le16_to_cpu(resp
->id
);
942 *rss_id
= resp
->rss_id
;
945 mutex_unlock(&adapter
->mbox_lock
);
950 /* Generic destroyer function for all types of queues
953 int be_cmd_q_destroy(struct be_adapter
*adapter
, struct be_queue_info
*q
,
956 struct be_mcc_wrb
*wrb
;
957 struct be_cmd_req_q_destroy
*req
;
958 u8 subsys
= 0, opcode
= 0;
961 if (adapter
->eeh_err
)
964 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
967 wrb
= wrb_from_mbox(adapter
);
968 req
= embedded_payload(wrb
);
970 switch (queue_type
) {
972 subsys
= CMD_SUBSYSTEM_COMMON
;
973 opcode
= OPCODE_COMMON_EQ_DESTROY
;
976 subsys
= CMD_SUBSYSTEM_COMMON
;
977 opcode
= OPCODE_COMMON_CQ_DESTROY
;
980 subsys
= CMD_SUBSYSTEM_ETH
;
981 opcode
= OPCODE_ETH_TX_DESTROY
;
984 subsys
= CMD_SUBSYSTEM_ETH
;
985 opcode
= OPCODE_ETH_RX_DESTROY
;
988 subsys
= CMD_SUBSYSTEM_COMMON
;
989 opcode
= OPCODE_COMMON_MCC_DESTROY
;
995 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0, opcode
);
997 be_cmd_hdr_prepare(&req
->hdr
, subsys
, opcode
, sizeof(*req
));
998 req
->id
= cpu_to_le16(q
->id
);
1000 status
= be_mbox_notify_wait(adapter
);
1002 mutex_unlock(&adapter
->mbox_lock
);
1007 /* Create an rx filtering policy configuration on an i/f
1010 int be_cmd_if_create(struct be_adapter
*adapter
, u32 cap_flags
, u32 en_flags
,
1011 u8
*mac
, bool pmac_invalid
, u32
*if_handle
, u32
*pmac_id
,
1014 struct be_mcc_wrb
*wrb
;
1015 struct be_cmd_req_if_create
*req
;
1018 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1021 wrb
= wrb_from_mbox(adapter
);
1022 req
= embedded_payload(wrb
);
1024 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1025 OPCODE_COMMON_NTWK_INTERFACE_CREATE
);
1027 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1028 OPCODE_COMMON_NTWK_INTERFACE_CREATE
, sizeof(*req
));
1030 req
->hdr
.domain
= domain
;
1031 req
->capability_flags
= cpu_to_le32(cap_flags
);
1032 req
->enable_flags
= cpu_to_le32(en_flags
);
1033 req
->pmac_invalid
= pmac_invalid
;
1035 memcpy(req
->mac_addr
, mac
, ETH_ALEN
);
1037 status
= be_mbox_notify_wait(adapter
);
1039 struct be_cmd_resp_if_create
*resp
= embedded_payload(wrb
);
1040 *if_handle
= le32_to_cpu(resp
->interface_id
);
1042 *pmac_id
= le32_to_cpu(resp
->pmac_id
);
1045 mutex_unlock(&adapter
->mbox_lock
);
1050 int be_cmd_if_destroy(struct be_adapter
*adapter
, u32 interface_id
, u32 domain
)
1052 struct be_mcc_wrb
*wrb
;
1053 struct be_cmd_req_if_destroy
*req
;
1056 if (adapter
->eeh_err
)
1059 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1062 wrb
= wrb_from_mbox(adapter
);
1063 req
= embedded_payload(wrb
);
1065 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1066 OPCODE_COMMON_NTWK_INTERFACE_DESTROY
);
1068 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1069 OPCODE_COMMON_NTWK_INTERFACE_DESTROY
, sizeof(*req
));
1071 req
->hdr
.domain
= domain
;
1072 req
->interface_id
= cpu_to_le32(interface_id
);
1074 status
= be_mbox_notify_wait(adapter
);
1076 mutex_unlock(&adapter
->mbox_lock
);
1081 /* Get stats is a non embedded command: the request is not embedded inside
1082 * WRB but is a separate dma memory block
1083 * Uses asynchronous MCC
1085 int be_cmd_get_stats(struct be_adapter
*adapter
, struct be_dma_mem
*nonemb_cmd
)
1087 struct be_mcc_wrb
*wrb
;
1088 struct be_cmd_req_hdr
*hdr
;
1092 if (MODULO(adapter
->work_counter
, be_get_temp_freq
) == 0)
1093 be_cmd_get_die_temperature(adapter
);
1095 spin_lock_bh(&adapter
->mcc_lock
);
1097 wrb
= wrb_from_mccq(adapter
);
1102 hdr
= nonemb_cmd
->va
;
1103 sge
= nonembedded_sgl(wrb
);
1105 be_wrb_hdr_prepare(wrb
, nonemb_cmd
->size
, false, 1,
1106 OPCODE_ETH_GET_STATISTICS
);
1108 be_cmd_hdr_prepare(hdr
, CMD_SUBSYSTEM_ETH
,
1109 OPCODE_ETH_GET_STATISTICS
, nonemb_cmd
->size
);
1111 if (adapter
->generation
== BE_GEN3
)
1114 wrb
->tag1
= CMD_SUBSYSTEM_ETH
;
1115 sge
->pa_hi
= cpu_to_le32(upper_32_bits(nonemb_cmd
->dma
));
1116 sge
->pa_lo
= cpu_to_le32(nonemb_cmd
->dma
& 0xFFFFFFFF);
1117 sge
->len
= cpu_to_le32(nonemb_cmd
->size
);
1119 be_mcc_notify(adapter
);
1120 adapter
->stats_cmd_sent
= true;
1123 spin_unlock_bh(&adapter
->mcc_lock
);
1127 /* Uses synchronous mcc */
1128 int be_cmd_link_status_query(struct be_adapter
*adapter
,
1129 bool *link_up
, u8
*mac_speed
, u16
*link_speed
, u32 dom
)
1131 struct be_mcc_wrb
*wrb
;
1132 struct be_cmd_req_link_status
*req
;
1135 spin_lock_bh(&adapter
->mcc_lock
);
1137 wrb
= wrb_from_mccq(adapter
);
1142 req
= embedded_payload(wrb
);
1146 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1147 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY
);
1149 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1150 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY
, sizeof(*req
));
1152 status
= be_mcc_notify_wait(adapter
);
1154 struct be_cmd_resp_link_status
*resp
= embedded_payload(wrb
);
1155 if (resp
->mac_speed
!= PHY_LINK_SPEED_ZERO
) {
1157 *link_speed
= le16_to_cpu(resp
->link_speed
);
1158 *mac_speed
= resp
->mac_speed
;
1163 spin_unlock_bh(&adapter
->mcc_lock
);
1167 /* Uses synchronous mcc */
1168 int be_cmd_get_die_temperature(struct be_adapter
*adapter
)
1170 struct be_mcc_wrb
*wrb
;
1171 struct be_cmd_req_get_cntl_addnl_attribs
*req
;
1174 spin_lock_bh(&adapter
->mcc_lock
);
1176 wrb
= wrb_from_mccq(adapter
);
1181 req
= embedded_payload(wrb
);
1183 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1184 OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES
);
1186 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1187 OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES
, sizeof(*req
));
1189 status
= be_mcc_notify_wait(adapter
);
1191 struct be_cmd_resp_get_cntl_addnl_attribs
*resp
=
1192 embedded_payload(wrb
);
1193 adapter
->drv_stats
.be_on_die_temperature
=
1194 resp
->on_die_temperature
;
1196 /* If IOCTL fails once, do not bother issuing it again */
1198 be_get_temp_freq
= 0;
1201 spin_unlock_bh(&adapter
->mcc_lock
);
1205 /* Uses synchronous mcc */
1206 int be_cmd_get_reg_len(struct be_adapter
*adapter
, u32
*log_size
)
1208 struct be_mcc_wrb
*wrb
;
1209 struct be_cmd_req_get_fat
*req
;
1212 spin_lock_bh(&adapter
->mcc_lock
);
1214 wrb
= wrb_from_mccq(adapter
);
1219 req
= embedded_payload(wrb
);
1221 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1222 OPCODE_COMMON_MANAGE_FAT
);
1224 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1225 OPCODE_COMMON_MANAGE_FAT
, sizeof(*req
));
1226 req
->fat_operation
= cpu_to_le32(QUERY_FAT
);
1227 status
= be_mcc_notify_wait(adapter
);
1229 struct be_cmd_resp_get_fat
*resp
= embedded_payload(wrb
);
1230 if (log_size
&& resp
->log_size
)
1231 *log_size
= le32_to_cpu(resp
->log_size
) -
1235 spin_unlock_bh(&adapter
->mcc_lock
);
1239 void be_cmd_get_regs(struct be_adapter
*adapter
, u32 buf_len
, void *buf
)
1241 struct be_dma_mem get_fat_cmd
;
1242 struct be_mcc_wrb
*wrb
;
1243 struct be_cmd_req_get_fat
*req
;
1245 u32 offset
= 0, total_size
, buf_size
,
1246 log_offset
= sizeof(u32
), payload_len
;
1252 total_size
= buf_len
;
1254 get_fat_cmd
.size
= sizeof(struct be_cmd_req_get_fat
) + 60*1024;
1255 get_fat_cmd
.va
= pci_alloc_consistent(adapter
->pdev
,
1258 if (!get_fat_cmd
.va
) {
1260 dev_err(&adapter
->pdev
->dev
,
1261 "Memory allocation failure while retrieving FAT data\n");
1265 spin_lock_bh(&adapter
->mcc_lock
);
1267 while (total_size
) {
1268 buf_size
= min(total_size
, (u32
)60*1024);
1269 total_size
-= buf_size
;
1271 wrb
= wrb_from_mccq(adapter
);
1276 req
= get_fat_cmd
.va
;
1277 sge
= nonembedded_sgl(wrb
);
1279 payload_len
= sizeof(struct be_cmd_req_get_fat
) + buf_size
;
1280 be_wrb_hdr_prepare(wrb
, payload_len
, false, 1,
1281 OPCODE_COMMON_MANAGE_FAT
);
1283 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1284 OPCODE_COMMON_MANAGE_FAT
, payload_len
);
1286 sge
->pa_hi
= cpu_to_le32(upper_32_bits(get_fat_cmd
.dma
));
1287 sge
->pa_lo
= cpu_to_le32(get_fat_cmd
.dma
& 0xFFFFFFFF);
1288 sge
->len
= cpu_to_le32(get_fat_cmd
.size
);
1290 req
->fat_operation
= cpu_to_le32(RETRIEVE_FAT
);
1291 req
->read_log_offset
= cpu_to_le32(log_offset
);
1292 req
->read_log_length
= cpu_to_le32(buf_size
);
1293 req
->data_buffer_size
= cpu_to_le32(buf_size
);
1295 status
= be_mcc_notify_wait(adapter
);
1297 struct be_cmd_resp_get_fat
*resp
= get_fat_cmd
.va
;
1298 memcpy(buf
+ offset
,
1300 resp
->read_log_length
);
1302 dev_err(&adapter
->pdev
->dev
, "FAT Table Retrieve error\n");
1306 log_offset
+= buf_size
;
1309 pci_free_consistent(adapter
->pdev
, get_fat_cmd
.size
,
1312 spin_unlock_bh(&adapter
->mcc_lock
);
1316 int be_cmd_get_fw_ver(struct be_adapter
*adapter
, char *fw_ver
)
1318 struct be_mcc_wrb
*wrb
;
1319 struct be_cmd_req_get_fw_version
*req
;
1322 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1325 wrb
= wrb_from_mbox(adapter
);
1326 req
= embedded_payload(wrb
);
1328 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1329 OPCODE_COMMON_GET_FW_VERSION
);
1331 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1332 OPCODE_COMMON_GET_FW_VERSION
, sizeof(*req
));
1334 status
= be_mbox_notify_wait(adapter
);
1336 struct be_cmd_resp_get_fw_version
*resp
= embedded_payload(wrb
);
1337 strncpy(fw_ver
, resp
->firmware_version_string
, FW_VER_LEN
);
1340 mutex_unlock(&adapter
->mbox_lock
);
1344 /* set the EQ delay interval of an EQ to specified value
1347 int be_cmd_modify_eqd(struct be_adapter
*adapter
, u32 eq_id
, u32 eqd
)
1349 struct be_mcc_wrb
*wrb
;
1350 struct be_cmd_req_modify_eq_delay
*req
;
1353 spin_lock_bh(&adapter
->mcc_lock
);
1355 wrb
= wrb_from_mccq(adapter
);
1360 req
= embedded_payload(wrb
);
1362 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1363 OPCODE_COMMON_MODIFY_EQ_DELAY
);
1365 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1366 OPCODE_COMMON_MODIFY_EQ_DELAY
, sizeof(*req
));
1368 req
->num_eq
= cpu_to_le32(1);
1369 req
->delay
[0].eq_id
= cpu_to_le32(eq_id
);
1370 req
->delay
[0].phase
= 0;
1371 req
->delay
[0].delay_multiplier
= cpu_to_le32(eqd
);
1373 be_mcc_notify(adapter
);
1376 spin_unlock_bh(&adapter
->mcc_lock
);
1380 /* Uses sycnhronous mcc */
1381 int be_cmd_vlan_config(struct be_adapter
*adapter
, u32 if_id
, u16
*vtag_array
,
1382 u32 num
, bool untagged
, bool promiscuous
)
1384 struct be_mcc_wrb
*wrb
;
1385 struct be_cmd_req_vlan_config
*req
;
1388 spin_lock_bh(&adapter
->mcc_lock
);
1390 wrb
= wrb_from_mccq(adapter
);
1395 req
= embedded_payload(wrb
);
1397 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1398 OPCODE_COMMON_NTWK_VLAN_CONFIG
);
1400 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1401 OPCODE_COMMON_NTWK_VLAN_CONFIG
, sizeof(*req
));
1403 req
->interface_id
= if_id
;
1404 req
->promiscuous
= promiscuous
;
1405 req
->untagged
= untagged
;
1406 req
->num_vlan
= num
;
1408 memcpy(req
->normal_vlan
, vtag_array
,
1409 req
->num_vlan
* sizeof(vtag_array
[0]));
1412 status
= be_mcc_notify_wait(adapter
);
1415 spin_unlock_bh(&adapter
->mcc_lock
);
1419 /* Uses MCC for this command as it may be called in BH context
1420 * Uses synchronous mcc
1422 int be_cmd_promiscuous_config(struct be_adapter
*adapter
, bool en
)
1424 struct be_mcc_wrb
*wrb
;
1425 struct be_cmd_req_rx_filter
*req
;
1426 struct be_dma_mem promiscous_cmd
;
1430 memset(&promiscous_cmd
, 0, sizeof(struct be_dma_mem
));
1431 promiscous_cmd
.size
= sizeof(struct be_cmd_req_rx_filter
);
1432 promiscous_cmd
.va
= pci_alloc_consistent(adapter
->pdev
,
1433 promiscous_cmd
.size
, &promiscous_cmd
.dma
);
1434 if (!promiscous_cmd
.va
) {
1435 dev_err(&adapter
->pdev
->dev
,
1436 "Memory allocation failure\n");
1440 spin_lock_bh(&adapter
->mcc_lock
);
1442 wrb
= wrb_from_mccq(adapter
);
1448 req
= promiscous_cmd
.va
;
1449 sge
= nonembedded_sgl(wrb
);
1451 be_wrb_hdr_prepare(wrb
, sizeof(*req
), false, 1,
1452 OPCODE_COMMON_NTWK_RX_FILTER
);
1453 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1454 OPCODE_COMMON_NTWK_RX_FILTER
, sizeof(*req
));
1456 req
->if_id
= cpu_to_le32(adapter
->if_handle
);
1457 req
->if_flags_mask
= cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS
);
1459 req
->if_flags
= cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS
);
1461 sge
->pa_hi
= cpu_to_le32(upper_32_bits(promiscous_cmd
.dma
));
1462 sge
->pa_lo
= cpu_to_le32(promiscous_cmd
.dma
& 0xFFFFFFFF);
1463 sge
->len
= cpu_to_le32(promiscous_cmd
.size
);
1465 status
= be_mcc_notify_wait(adapter
);
1468 spin_unlock_bh(&adapter
->mcc_lock
);
1469 pci_free_consistent(adapter
->pdev
, promiscous_cmd
.size
,
1470 promiscous_cmd
.va
, promiscous_cmd
.dma
);
1475 * Uses MCC for this command as it may be called in BH context
1476 * (mc == NULL) => multicast promiscuous
1478 int be_cmd_multicast_set(struct be_adapter
*adapter
, u32 if_id
,
1479 struct net_device
*netdev
, struct be_dma_mem
*mem
)
1481 struct be_mcc_wrb
*wrb
;
1482 struct be_cmd_req_mcast_mac_config
*req
= mem
->va
;
1486 spin_lock_bh(&adapter
->mcc_lock
);
1488 wrb
= wrb_from_mccq(adapter
);
1493 sge
= nonembedded_sgl(wrb
);
1494 memset(req
, 0, sizeof(*req
));
1496 be_wrb_hdr_prepare(wrb
, sizeof(*req
), false, 1,
1497 OPCODE_COMMON_NTWK_MULTICAST_SET
);
1498 sge
->pa_hi
= cpu_to_le32(upper_32_bits(mem
->dma
));
1499 sge
->pa_lo
= cpu_to_le32(mem
->dma
& 0xFFFFFFFF);
1500 sge
->len
= cpu_to_le32(mem
->size
);
1502 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1503 OPCODE_COMMON_NTWK_MULTICAST_SET
, sizeof(*req
));
1505 req
->interface_id
= if_id
;
1508 struct netdev_hw_addr
*ha
;
1510 req
->num_mac
= cpu_to_le16(netdev_mc_count(netdev
));
1513 netdev_for_each_mc_addr(ha
, netdev
)
1514 memcpy(req
->mac
[i
++].byte
, ha
->addr
, ETH_ALEN
);
1516 req
->promiscuous
= 1;
1519 status
= be_mcc_notify_wait(adapter
);
1522 spin_unlock_bh(&adapter
->mcc_lock
);
1526 /* Uses synchrounous mcc */
1527 int be_cmd_set_flow_control(struct be_adapter
*adapter
, u32 tx_fc
, u32 rx_fc
)
1529 struct be_mcc_wrb
*wrb
;
1530 struct be_cmd_req_set_flow_control
*req
;
1533 spin_lock_bh(&adapter
->mcc_lock
);
1535 wrb
= wrb_from_mccq(adapter
);
1540 req
= embedded_payload(wrb
);
1542 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1543 OPCODE_COMMON_SET_FLOW_CONTROL
);
1545 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1546 OPCODE_COMMON_SET_FLOW_CONTROL
, sizeof(*req
));
1548 req
->tx_flow_control
= cpu_to_le16((u16
)tx_fc
);
1549 req
->rx_flow_control
= cpu_to_le16((u16
)rx_fc
);
1551 status
= be_mcc_notify_wait(adapter
);
1554 spin_unlock_bh(&adapter
->mcc_lock
);
1559 int be_cmd_get_flow_control(struct be_adapter
*adapter
, u32
*tx_fc
, u32
*rx_fc
)
1561 struct be_mcc_wrb
*wrb
;
1562 struct be_cmd_req_get_flow_control
*req
;
1565 spin_lock_bh(&adapter
->mcc_lock
);
1567 wrb
= wrb_from_mccq(adapter
);
1572 req
= embedded_payload(wrb
);
1574 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1575 OPCODE_COMMON_GET_FLOW_CONTROL
);
1577 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1578 OPCODE_COMMON_GET_FLOW_CONTROL
, sizeof(*req
));
1580 status
= be_mcc_notify_wait(adapter
);
1582 struct be_cmd_resp_get_flow_control
*resp
=
1583 embedded_payload(wrb
);
1584 *tx_fc
= le16_to_cpu(resp
->tx_flow_control
);
1585 *rx_fc
= le16_to_cpu(resp
->rx_flow_control
);
1589 spin_unlock_bh(&adapter
->mcc_lock
);
1594 int be_cmd_query_fw_cfg(struct be_adapter
*adapter
, u32
*port_num
,
1595 u32
*mode
, u32
*caps
)
1597 struct be_mcc_wrb
*wrb
;
1598 struct be_cmd_req_query_fw_cfg
*req
;
1601 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1604 wrb
= wrb_from_mbox(adapter
);
1605 req
= embedded_payload(wrb
);
1607 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1608 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG
);
1610 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1611 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG
, sizeof(*req
));
1613 status
= be_mbox_notify_wait(adapter
);
1615 struct be_cmd_resp_query_fw_cfg
*resp
= embedded_payload(wrb
);
1616 *port_num
= le32_to_cpu(resp
->phys_port
);
1617 *mode
= le32_to_cpu(resp
->function_mode
);
1618 *caps
= le32_to_cpu(resp
->function_caps
);
1621 mutex_unlock(&adapter
->mbox_lock
);
1626 int be_cmd_reset_function(struct be_adapter
*adapter
)
1628 struct be_mcc_wrb
*wrb
;
1629 struct be_cmd_req_hdr
*req
;
1632 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1635 wrb
= wrb_from_mbox(adapter
);
1636 req
= embedded_payload(wrb
);
1638 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1639 OPCODE_COMMON_FUNCTION_RESET
);
1641 be_cmd_hdr_prepare(req
, CMD_SUBSYSTEM_COMMON
,
1642 OPCODE_COMMON_FUNCTION_RESET
, sizeof(*req
));
1644 status
= be_mbox_notify_wait(adapter
);
1646 mutex_unlock(&adapter
->mbox_lock
);
1650 int be_cmd_rss_config(struct be_adapter
*adapter
, u8
*rsstable
, u16 table_size
)
1652 struct be_mcc_wrb
*wrb
;
1653 struct be_cmd_req_rss_config
*req
;
1657 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
1660 wrb
= wrb_from_mbox(adapter
);
1661 req
= embedded_payload(wrb
);
1663 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1664 OPCODE_ETH_RSS_CONFIG
);
1666 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1667 OPCODE_ETH_RSS_CONFIG
, sizeof(*req
));
1669 req
->if_id
= cpu_to_le32(adapter
->if_handle
);
1670 req
->enable_rss
= cpu_to_le16(RSS_ENABLE_TCP_IPV4
| RSS_ENABLE_IPV4
);
1671 req
->cpu_table_size_log2
= cpu_to_le16(fls(table_size
) - 1);
1672 memcpy(req
->cpu_table
, rsstable
, table_size
);
1673 memcpy(req
->hash
, myhash
, sizeof(myhash
));
1674 be_dws_cpu_to_le(req
->hash
, sizeof(req
->hash
));
1676 status
= be_mbox_notify_wait(adapter
);
1678 mutex_unlock(&adapter
->mbox_lock
);
1683 int be_cmd_set_beacon_state(struct be_adapter
*adapter
, u8 port_num
,
1684 u8 bcn
, u8 sts
, u8 state
)
1686 struct be_mcc_wrb
*wrb
;
1687 struct be_cmd_req_enable_disable_beacon
*req
;
1690 spin_lock_bh(&adapter
->mcc_lock
);
1692 wrb
= wrb_from_mccq(adapter
);
1697 req
= embedded_payload(wrb
);
1699 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1700 OPCODE_COMMON_ENABLE_DISABLE_BEACON
);
1702 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1703 OPCODE_COMMON_ENABLE_DISABLE_BEACON
, sizeof(*req
));
1705 req
->port_num
= port_num
;
1706 req
->beacon_state
= state
;
1707 req
->beacon_duration
= bcn
;
1708 req
->status_duration
= sts
;
1710 status
= be_mcc_notify_wait(adapter
);
1713 spin_unlock_bh(&adapter
->mcc_lock
);
1718 int be_cmd_get_beacon_state(struct be_adapter
*adapter
, u8 port_num
, u32
*state
)
1720 struct be_mcc_wrb
*wrb
;
1721 struct be_cmd_req_get_beacon_state
*req
;
1724 spin_lock_bh(&adapter
->mcc_lock
);
1726 wrb
= wrb_from_mccq(adapter
);
1731 req
= embedded_payload(wrb
);
1733 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1734 OPCODE_COMMON_GET_BEACON_STATE
);
1736 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1737 OPCODE_COMMON_GET_BEACON_STATE
, sizeof(*req
));
1739 req
->port_num
= port_num
;
1741 status
= be_mcc_notify_wait(adapter
);
1743 struct be_cmd_resp_get_beacon_state
*resp
=
1744 embedded_payload(wrb
);
1745 *state
= resp
->beacon_state
;
1749 spin_unlock_bh(&adapter
->mcc_lock
);
1753 int be_cmd_write_flashrom(struct be_adapter
*adapter
, struct be_dma_mem
*cmd
,
1754 u32 flash_type
, u32 flash_opcode
, u32 buf_size
)
1756 struct be_mcc_wrb
*wrb
;
1757 struct be_cmd_write_flashrom
*req
;
1761 spin_lock_bh(&adapter
->mcc_lock
);
1762 adapter
->flash_status
= 0;
1764 wrb
= wrb_from_mccq(adapter
);
1770 sge
= nonembedded_sgl(wrb
);
1772 be_wrb_hdr_prepare(wrb
, cmd
->size
, false, 1,
1773 OPCODE_COMMON_WRITE_FLASHROM
);
1774 wrb
->tag1
= CMD_SUBSYSTEM_COMMON
;
1776 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1777 OPCODE_COMMON_WRITE_FLASHROM
, cmd
->size
);
1778 sge
->pa_hi
= cpu_to_le32(upper_32_bits(cmd
->dma
));
1779 sge
->pa_lo
= cpu_to_le32(cmd
->dma
& 0xFFFFFFFF);
1780 sge
->len
= cpu_to_le32(cmd
->size
);
1782 req
->params
.op_type
= cpu_to_le32(flash_type
);
1783 req
->params
.op_code
= cpu_to_le32(flash_opcode
);
1784 req
->params
.data_buf_size
= cpu_to_le32(buf_size
);
1786 be_mcc_notify(adapter
);
1787 spin_unlock_bh(&adapter
->mcc_lock
);
1789 if (!wait_for_completion_timeout(&adapter
->flash_compl
,
1790 msecs_to_jiffies(12000)))
1793 status
= adapter
->flash_status
;
1798 spin_unlock_bh(&adapter
->mcc_lock
);
1802 int be_cmd_get_flash_crc(struct be_adapter
*adapter
, u8
*flashed_crc
,
1805 struct be_mcc_wrb
*wrb
;
1806 struct be_cmd_write_flashrom
*req
;
1809 spin_lock_bh(&adapter
->mcc_lock
);
1811 wrb
= wrb_from_mccq(adapter
);
1816 req
= embedded_payload(wrb
);
1818 be_wrb_hdr_prepare(wrb
, sizeof(*req
)+4, true, 0,
1819 OPCODE_COMMON_READ_FLASHROM
);
1821 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
1822 OPCODE_COMMON_READ_FLASHROM
, sizeof(*req
)+4);
1824 req
->params
.op_type
= cpu_to_le32(IMG_TYPE_REDBOOT
);
1825 req
->params
.op_code
= cpu_to_le32(FLASHROM_OPER_REPORT
);
1826 req
->params
.offset
= cpu_to_le32(offset
);
1827 req
->params
.data_buf_size
= cpu_to_le32(0x4);
1829 status
= be_mcc_notify_wait(adapter
);
1831 memcpy(flashed_crc
, req
->params
.data_buf
, 4);
1834 spin_unlock_bh(&adapter
->mcc_lock
);
1838 int be_cmd_enable_magic_wol(struct be_adapter
*adapter
, u8
*mac
,
1839 struct be_dma_mem
*nonemb_cmd
)
1841 struct be_mcc_wrb
*wrb
;
1842 struct be_cmd_req_acpi_wol_magic_config
*req
;
1846 spin_lock_bh(&adapter
->mcc_lock
);
1848 wrb
= wrb_from_mccq(adapter
);
1853 req
= nonemb_cmd
->va
;
1854 sge
= nonembedded_sgl(wrb
);
1856 be_wrb_hdr_prepare(wrb
, sizeof(*req
), false, 1,
1857 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
);
1859 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_ETH
,
1860 OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG
, sizeof(*req
));
1861 memcpy(req
->magic_mac
, mac
, ETH_ALEN
);
1863 sge
->pa_hi
= cpu_to_le32(upper_32_bits(nonemb_cmd
->dma
));
1864 sge
->pa_lo
= cpu_to_le32(nonemb_cmd
->dma
& 0xFFFFFFFF);
1865 sge
->len
= cpu_to_le32(nonemb_cmd
->size
);
1867 status
= be_mcc_notify_wait(adapter
);
1870 spin_unlock_bh(&adapter
->mcc_lock
);
1874 int be_cmd_set_loopback(struct be_adapter
*adapter
, u8 port_num
,
1875 u8 loopback_type
, u8 enable
)
1877 struct be_mcc_wrb
*wrb
;
1878 struct be_cmd_req_set_lmode
*req
;
1881 spin_lock_bh(&adapter
->mcc_lock
);
1883 wrb
= wrb_from_mccq(adapter
);
1889 req
= embedded_payload(wrb
);
1891 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1892 OPCODE_LOWLEVEL_SET_LOOPBACK_MODE
);
1894 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
1895 OPCODE_LOWLEVEL_SET_LOOPBACK_MODE
,
1898 req
->src_port
= port_num
;
1899 req
->dest_port
= port_num
;
1900 req
->loopback_type
= loopback_type
;
1901 req
->loopback_state
= enable
;
1903 status
= be_mcc_notify_wait(adapter
);
1905 spin_unlock_bh(&adapter
->mcc_lock
);
1909 int be_cmd_loopback_test(struct be_adapter
*adapter
, u32 port_num
,
1910 u32 loopback_type
, u32 pkt_size
, u32 num_pkts
, u64 pattern
)
1912 struct be_mcc_wrb
*wrb
;
1913 struct be_cmd_req_loopback_test
*req
;
1916 spin_lock_bh(&adapter
->mcc_lock
);
1918 wrb
= wrb_from_mccq(adapter
);
1924 req
= embedded_payload(wrb
);
1926 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
1927 OPCODE_LOWLEVEL_LOOPBACK_TEST
);
1929 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
1930 OPCODE_LOWLEVEL_LOOPBACK_TEST
, sizeof(*req
));
1931 req
->hdr
.timeout
= cpu_to_le32(4);
1933 req
->pattern
= cpu_to_le64(pattern
);
1934 req
->src_port
= cpu_to_le32(port_num
);
1935 req
->dest_port
= cpu_to_le32(port_num
);
1936 req
->pkt_size
= cpu_to_le32(pkt_size
);
1937 req
->num_pkts
= cpu_to_le32(num_pkts
);
1938 req
->loopback_type
= cpu_to_le32(loopback_type
);
1940 status
= be_mcc_notify_wait(adapter
);
1942 struct be_cmd_resp_loopback_test
*resp
= embedded_payload(wrb
);
1943 status
= le32_to_cpu(resp
->status
);
1947 spin_unlock_bh(&adapter
->mcc_lock
);
1951 int be_cmd_ddr_dma_test(struct be_adapter
*adapter
, u64 pattern
,
1952 u32 byte_cnt
, struct be_dma_mem
*cmd
)
1954 struct be_mcc_wrb
*wrb
;
1955 struct be_cmd_req_ddrdma_test
*req
;
1960 spin_lock_bh(&adapter
->mcc_lock
);
1962 wrb
= wrb_from_mccq(adapter
);
1968 sge
= nonembedded_sgl(wrb
);
1969 be_wrb_hdr_prepare(wrb
, cmd
->size
, false, 1,
1970 OPCODE_LOWLEVEL_HOST_DDR_DMA
);
1971 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_LOWLEVEL
,
1972 OPCODE_LOWLEVEL_HOST_DDR_DMA
, cmd
->size
);
1974 sge
->pa_hi
= cpu_to_le32(upper_32_bits(cmd
->dma
));
1975 sge
->pa_lo
= cpu_to_le32(cmd
->dma
& 0xFFFFFFFF);
1976 sge
->len
= cpu_to_le32(cmd
->size
);
1978 req
->pattern
= cpu_to_le64(pattern
);
1979 req
->byte_count
= cpu_to_le32(byte_cnt
);
1980 for (i
= 0; i
< byte_cnt
; i
++) {
1981 req
->snd_buff
[i
] = (u8
)(pattern
>> (j
*8));
1987 status
= be_mcc_notify_wait(adapter
);
1990 struct be_cmd_resp_ddrdma_test
*resp
;
1992 if ((memcmp(resp
->rcv_buff
, req
->snd_buff
, byte_cnt
) != 0) ||
1999 spin_unlock_bh(&adapter
->mcc_lock
);
2003 int be_cmd_get_seeprom_data(struct be_adapter
*adapter
,
2004 struct be_dma_mem
*nonemb_cmd
)
2006 struct be_mcc_wrb
*wrb
;
2007 struct be_cmd_req_seeprom_read
*req
;
2011 spin_lock_bh(&adapter
->mcc_lock
);
2013 wrb
= wrb_from_mccq(adapter
);
2018 req
= nonemb_cmd
->va
;
2019 sge
= nonembedded_sgl(wrb
);
2021 be_wrb_hdr_prepare(wrb
, sizeof(*req
), false, 1,
2022 OPCODE_COMMON_SEEPROM_READ
);
2024 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2025 OPCODE_COMMON_SEEPROM_READ
, sizeof(*req
));
2027 sge
->pa_hi
= cpu_to_le32(upper_32_bits(nonemb_cmd
->dma
));
2028 sge
->pa_lo
= cpu_to_le32(nonemb_cmd
->dma
& 0xFFFFFFFF);
2029 sge
->len
= cpu_to_le32(nonemb_cmd
->size
);
2031 status
= be_mcc_notify_wait(adapter
);
2034 spin_unlock_bh(&adapter
->mcc_lock
);
2038 int be_cmd_get_phy_info(struct be_adapter
*adapter
, struct be_dma_mem
*cmd
)
2040 struct be_mcc_wrb
*wrb
;
2041 struct be_cmd_req_get_phy_info
*req
;
2045 spin_lock_bh(&adapter
->mcc_lock
);
2047 wrb
= wrb_from_mccq(adapter
);
2054 sge
= nonembedded_sgl(wrb
);
2056 be_wrb_hdr_prepare(wrb
, sizeof(*req
), false, 1,
2057 OPCODE_COMMON_GET_PHY_DETAILS
);
2059 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2060 OPCODE_COMMON_GET_PHY_DETAILS
,
2063 sge
->pa_hi
= cpu_to_le32(upper_32_bits(cmd
->dma
));
2064 sge
->pa_lo
= cpu_to_le32(cmd
->dma
& 0xFFFFFFFF);
2065 sge
->len
= cpu_to_le32(cmd
->size
);
2067 status
= be_mcc_notify_wait(adapter
);
2069 spin_unlock_bh(&adapter
->mcc_lock
);
2073 int be_cmd_set_qos(struct be_adapter
*adapter
, u32 bps
, u32 domain
)
2075 struct be_mcc_wrb
*wrb
;
2076 struct be_cmd_req_set_qos
*req
;
2079 spin_lock_bh(&adapter
->mcc_lock
);
2081 wrb
= wrb_from_mccq(adapter
);
2087 req
= embedded_payload(wrb
);
2089 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
2090 OPCODE_COMMON_SET_QOS
);
2092 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2093 OPCODE_COMMON_SET_QOS
, sizeof(*req
));
2095 req
->hdr
.domain
= domain
;
2096 req
->valid_bits
= cpu_to_le32(BE_QOS_BITS_NIC
);
2097 req
->max_bps_nic
= cpu_to_le32(bps
);
2099 status
= be_mcc_notify_wait(adapter
);
2102 spin_unlock_bh(&adapter
->mcc_lock
);
2106 int be_cmd_get_cntl_attributes(struct be_adapter
*adapter
)
2108 struct be_mcc_wrb
*wrb
;
2109 struct be_cmd_req_cntl_attribs
*req
;
2110 struct be_cmd_resp_cntl_attribs
*resp
;
2113 int payload_len
= max(sizeof(*req
), sizeof(*resp
));
2114 struct mgmt_controller_attrib
*attribs
;
2115 struct be_dma_mem attribs_cmd
;
2117 memset(&attribs_cmd
, 0, sizeof(struct be_dma_mem
));
2118 attribs_cmd
.size
= sizeof(struct be_cmd_resp_cntl_attribs
);
2119 attribs_cmd
.va
= pci_alloc_consistent(adapter
->pdev
, attribs_cmd
.size
,
2121 if (!attribs_cmd
.va
) {
2122 dev_err(&adapter
->pdev
->dev
,
2123 "Memory allocation failure\n");
2127 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2130 wrb
= wrb_from_mbox(adapter
);
2135 req
= attribs_cmd
.va
;
2136 sge
= nonembedded_sgl(wrb
);
2138 be_wrb_hdr_prepare(wrb
, payload_len
, false, 1,
2139 OPCODE_COMMON_GET_CNTL_ATTRIBUTES
);
2140 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2141 OPCODE_COMMON_GET_CNTL_ATTRIBUTES
, payload_len
);
2142 sge
->pa_hi
= cpu_to_le32(upper_32_bits(attribs_cmd
.dma
));
2143 sge
->pa_lo
= cpu_to_le32(attribs_cmd
.dma
& 0xFFFFFFFF);
2144 sge
->len
= cpu_to_le32(attribs_cmd
.size
);
2146 status
= be_mbox_notify_wait(adapter
);
2148 attribs
= (struct mgmt_controller_attrib
*)( attribs_cmd
.va
+
2149 sizeof(struct be_cmd_resp_hdr
));
2150 adapter
->hba_port_num
= attribs
->hba_attribs
.phy_port
;
2154 mutex_unlock(&adapter
->mbox_lock
);
2155 pci_free_consistent(adapter
->pdev
, attribs_cmd
.size
, attribs_cmd
.va
,
2161 int be_cmd_check_native_mode(struct be_adapter
*adapter
)
2163 struct be_mcc_wrb
*wrb
;
2164 struct be_cmd_req_set_func_cap
*req
;
2167 if (mutex_lock_interruptible(&adapter
->mbox_lock
))
2170 wrb
= wrb_from_mbox(adapter
);
2176 req
= embedded_payload(wrb
);
2178 be_wrb_hdr_prepare(wrb
, sizeof(*req
), true, 0,
2179 OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP
);
2181 be_cmd_hdr_prepare(&req
->hdr
, CMD_SUBSYSTEM_COMMON
,
2182 OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP
, sizeof(*req
));
2184 req
->valid_cap_flags
= cpu_to_le32(CAPABILITY_SW_TIMESTAMPS
|
2185 CAPABILITY_BE3_NATIVE_ERX_API
);
2186 req
->cap_flags
= cpu_to_le32(CAPABILITY_BE3_NATIVE_ERX_API
);
2188 status
= be_mbox_notify_wait(adapter
);
2190 struct be_cmd_resp_set_func_cap
*resp
= embedded_payload(wrb
);
2191 adapter
->be3_native
= le32_to_cpu(resp
->cap_flags
) &
2192 CAPABILITY_BE3_NATIVE_ERX_API
;
2195 mutex_unlock(&adapter
->mbox_lock
);