1
2
3
4
5
6
7
8
9
10#include <scsi/iscsi_proto.h>
11
12#include "be_main.h"
13#include "be.h"
14#include "be_mgmt.h"
15
16
17static const char * const desc_ue_status_low[] = {
18 "CEV",
19 "CTX",
20 "DBUF",
21 "ERX",
22 "Host",
23 "MPU",
24 "NDMA",
25 "PTC ",
26 "RDMA ",
27 "RXF ",
28 "RXIPS ",
29 "RXULP0 ",
30 "RXULP1 ",
31 "RXULP2 ",
32 "TIM ",
33 "TPOST ",
34 "TPRE ",
35 "TXIPS ",
36 "TXULP0 ",
37 "TXULP1 ",
38 "UC ",
39 "WDMA ",
40 "TXULP2 ",
41 "HOST1 ",
42 "P0_OB_LINK ",
43 "P1_OB_LINK ",
44 "HOST_GPIO ",
45 "MBOX ",
46 "AXGMAC0",
47 "AXGMAC1",
48 "JTAG",
49 "MPU_INTPEND"
50};
51
52
53static const char * const desc_ue_status_hi[] = {
54 "LPCMEMHOST",
55 "MGMT_MAC",
56 "PCS0ONLINE",
57 "MPU_IRAM",
58 "PCS1ONLINE",
59 "PCTL0",
60 "PCTL1",
61 "PMEM",
62 "RR",
63 "TXPB",
64 "RXPP",
65 "XAUI",
66 "TXP",
67 "ARM",
68 "IPC",
69 "HOST2",
70 "HOST3",
71 "HOST4",
72 "HOST5",
73 "HOST6",
74 "HOST7",
75 "HOST8",
76 "HOST9",
77 "NETC",
78 "Unknown",
79 "Unknown",
80 "Unknown",
81 "Unknown",
82 "Unknown",
83 "Unknown",
84 "Unknown",
85 "Unknown"
86};
87
88struct be_mcc_wrb *alloc_mcc_wrb(struct beiscsi_hba *phba,
89 unsigned int *ref_tag)
90{
91 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
92 struct be_mcc_wrb *wrb = NULL;
93 unsigned int tag;
94
95 spin_lock(&phba->ctrl.mcc_lock);
96 if (mccq->used == mccq->len) {
97 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT |
98 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
99 "BC_%d : MCC queue full: WRB used %u tag avail %u\n",
100 mccq->used, phba->ctrl.mcc_tag_available);
101 goto alloc_failed;
102 }
103
104 if (!phba->ctrl.mcc_tag_available)
105 goto alloc_failed;
106
107 tag = phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index];
108 if (!tag) {
109 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT |
110 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
111 "BC_%d : MCC tag 0 allocated: tag avail %u alloc index %u\n",
112 phba->ctrl.mcc_tag_available,
113 phba->ctrl.mcc_alloc_index);
114 goto alloc_failed;
115 }
116
117
118 *ref_tag = tag;
119 phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index] = 0;
120 phba->ctrl.mcc_tag_status[tag] = 0;
121 phba->ctrl.ptag_state[tag].tag_state = 0;
122 phba->ctrl.ptag_state[tag].cbfn = NULL;
123 phba->ctrl.mcc_tag_available--;
124 if (phba->ctrl.mcc_alloc_index == (MAX_MCC_CMD - 1))
125 phba->ctrl.mcc_alloc_index = 0;
126 else
127 phba->ctrl.mcc_alloc_index++;
128
129 wrb = queue_head_node(mccq);
130 memset(wrb, 0, sizeof(*wrb));
131 wrb->tag0 = tag;
132 wrb->tag0 |= (mccq->head << MCC_Q_WRB_IDX_SHIFT) & MCC_Q_WRB_IDX_MASK;
133 queue_head_inc(mccq);
134 mccq->used++;
135
136alloc_failed:
137 spin_unlock(&phba->ctrl.mcc_lock);
138 return wrb;
139}
140
141void free_mcc_wrb(struct be_ctrl_info *ctrl, unsigned int tag)
142{
143 struct be_queue_info *mccq = &ctrl->mcc_obj.q;
144
145 spin_lock(&ctrl->mcc_lock);
146 tag = tag & MCC_Q_CMD_TAG_MASK;
147 ctrl->mcc_tag[ctrl->mcc_free_index] = tag;
148 if (ctrl->mcc_free_index == (MAX_MCC_CMD - 1))
149 ctrl->mcc_free_index = 0;
150 else
151 ctrl->mcc_free_index++;
152 ctrl->mcc_tag_available++;
153 mccq->used--;
154 spin_unlock(&ctrl->mcc_lock);
155}
156
157
158
159
160
161
162
163
164
165
166
167
168int __beiscsi_mcc_compl_status(struct beiscsi_hba *phba,
169 unsigned int tag,
170 struct be_mcc_wrb **wrb,
171 struct be_dma_mem *mbx_cmd_mem)
172{
173 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
174 uint16_t status = 0, addl_status = 0, wrb_num = 0;
175 struct be_cmd_resp_hdr *mbx_resp_hdr;
176 struct be_cmd_req_hdr *mbx_hdr;
177 struct be_mcc_wrb *temp_wrb;
178 uint32_t mcc_tag_status;
179 int rc = 0;
180
181 mcc_tag_status = phba->ctrl.mcc_tag_status[tag];
182 status = (mcc_tag_status & CQE_STATUS_MASK);
183 addl_status = ((mcc_tag_status & CQE_STATUS_ADDL_MASK) >>
184 CQE_STATUS_ADDL_SHIFT);
185
186 if (mbx_cmd_mem) {
187 mbx_hdr = (struct be_cmd_req_hdr *)mbx_cmd_mem->va;
188 } else {
189 wrb_num = (mcc_tag_status & CQE_STATUS_WRB_MASK) >>
190 CQE_STATUS_WRB_SHIFT;
191 temp_wrb = (struct be_mcc_wrb *)queue_get_wrb(mccq, wrb_num);
192 mbx_hdr = embedded_payload(temp_wrb);
193
194 if (wrb)
195 *wrb = temp_wrb;
196 }
197
198 if (status || addl_status) {
199 beiscsi_log(phba, KERN_WARNING,
200 BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
201 BEISCSI_LOG_CONFIG,
202 "BC_%d : MBX Cmd Failed for Subsys : %d Opcode : %d with Status : %d and Extd_Status : %d\n",
203 mbx_hdr->subsystem, mbx_hdr->opcode,
204 status, addl_status);
205 rc = -EIO;
206 if (status == MCC_STATUS_INSUFFICIENT_BUFFER) {
207 mbx_resp_hdr = (struct be_cmd_resp_hdr *)mbx_hdr;
208 beiscsi_log(phba, KERN_WARNING,
209 BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
210 BEISCSI_LOG_CONFIG,
211 "BC_%d : Insufficient Buffer Error Resp_Len : %d Actual_Resp_Len : %d\n",
212 mbx_resp_hdr->response_length,
213 mbx_resp_hdr->actual_resp_len);
214 rc = -EAGAIN;
215 }
216 }
217
218 return rc;
219}
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234int beiscsi_mccq_compl_wait(struct beiscsi_hba *phba,
235 unsigned int tag,
236 struct be_mcc_wrb **wrb,
237 struct be_dma_mem *mbx_cmd_mem)
238{
239 int rc = 0;
240
241 if (!tag || tag > MAX_MCC_CMD) {
242 __beiscsi_log(phba, KERN_ERR,
243 "BC_%d : invalid tag %u\n", tag);
244 return -EINVAL;
245 }
246
247 if (beiscsi_hba_in_error(phba)) {
248 clear_bit(MCC_TAG_STATE_RUNNING,
249 &phba->ctrl.ptag_state[tag].tag_state);
250 return -EIO;
251 }
252
253
254 rc = wait_event_interruptible_timeout(phba->ctrl.mcc_wait[tag],
255 phba->ctrl.mcc_tag_status[tag],
256 msecs_to_jiffies(
257 BEISCSI_HOST_MBX_TIMEOUT));
258
259
260
261
262
263 if (!test_bit(BEISCSI_HBA_ONLINE, &phba->state)) {
264 clear_bit(MCC_TAG_STATE_RUNNING,
265 &phba->ctrl.ptag_state[tag].tag_state);
266 return -EIO;
267 }
268
269
270
271
272
273 if (rc <= 0) {
274 struct be_dma_mem *tag_mem;
275
276
277
278
279
280
281
282 tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state;
283 if (mbx_cmd_mem) {
284 tag_mem->size = mbx_cmd_mem->size;
285 tag_mem->va = mbx_cmd_mem->va;
286 tag_mem->dma = mbx_cmd_mem->dma;
287 } else
288 tag_mem->size = 0;
289
290
291 wmb();
292 set_bit(MCC_TAG_STATE_TIMEOUT,
293 &phba->ctrl.ptag_state[tag].tag_state);
294
295 beiscsi_log(phba, KERN_ERR,
296 BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
297 BEISCSI_LOG_CONFIG,
298 "BC_%d : MBX Cmd Completion timed out\n");
299 return -EBUSY;
300 }
301
302 rc = __beiscsi_mcc_compl_status(phba, tag, wrb, mbx_cmd_mem);
303
304 free_mcc_wrb(&phba->ctrl, tag);
305 return rc;
306}
307
308
309
310
311
312
313
314
315
316
317
318
319static int beiscsi_process_mbox_compl(struct be_ctrl_info *ctrl,
320 struct be_mcc_compl *compl)
321{
322 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
323 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
324 struct be_cmd_req_hdr *hdr = embedded_payload(wrb);
325 u16 compl_status, extd_status;
326
327
328
329
330
331
332 if (!compl->flags) {
333 beiscsi_log(phba, KERN_ERR,
334 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
335 "BC_%d : BMBX busy, no completion\n");
336 return -EBUSY;
337 }
338 compl->flags = le32_to_cpu(compl->flags);
339 WARN_ON((compl->flags & CQE_FLAGS_VALID_MASK) == 0);
340
341
342
343
344
345 be_dws_le_to_cpu(compl, 4);
346 compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
347 CQE_STATUS_COMPL_MASK;
348 extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) &
349 CQE_STATUS_EXTD_MASK;
350
351 compl->flags = 0;
352
353 if (compl_status == MCC_STATUS_SUCCESS)
354 return 0;
355
356 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
357 "BC_%d : error in cmd completion: Subsystem : %d Opcode : %d status(compl/extd)=%d/%d\n",
358 hdr->subsystem, hdr->opcode, compl_status, extd_status);
359 return compl_status;
360}
361
362static void beiscsi_process_async_link(struct beiscsi_hba *phba,
363 struct be_mcc_compl *compl)
364{
365 struct be_async_event_link_state *evt;
366
367 evt = (struct be_async_event_link_state *)compl;
368
369 phba->port_speed = evt->port_speed;
370
371
372
373
374 if (evt->port_link_status & BE_ASYNC_LINK_UP_MASK) {
375 set_bit(BEISCSI_HBA_LINK_UP, &phba->state);
376 if (test_bit(BEISCSI_HBA_BOOT_FOUND, &phba->state))
377 beiscsi_start_boot_work(phba, BE_BOOT_INVALID_SHANDLE);
378 __beiscsi_log(phba, KERN_ERR,
379 "BC_%d : Link Up on Port %d tag 0x%x\n",
380 evt->physical_port, evt->event_tag);
381 } else {
382 clear_bit(BEISCSI_HBA_LINK_UP, &phba->state);
383 __beiscsi_log(phba, KERN_ERR,
384 "BC_%d : Link Down on Port %d tag 0x%x\n",
385 evt->physical_port, evt->event_tag);
386 iscsi_host_for_each_session(phba->shost,
387 beiscsi_session_fail);
388 }
389}
390
391static char *beiscsi_port_misconf_event_msg[] = {
392 "Physical Link is functional.",
393 "Optics faulted/incorrectly installed/not installed - Reseat optics, if issue not resolved, replace.",
394 "Optics of two types installed - Remove one optic or install matching pair of optics.",
395 "Incompatible optics - Replace with compatible optics for card to function.",
396 "Unqualified optics - Replace with Avago optics for Warranty and Technical Support.",
397 "Uncertified optics - Replace with Avago Certified optics to enable link operation."
398};
399
400static void beiscsi_process_async_sli(struct beiscsi_hba *phba,
401 struct be_mcc_compl *compl)
402{
403 struct be_async_event_sli *async_sli;
404 u8 evt_type, state, old_state, le;
405 char *sev = KERN_WARNING;
406 char *msg = NULL;
407
408 evt_type = compl->flags >> ASYNC_TRAILER_EVENT_TYPE_SHIFT;
409 evt_type &= ASYNC_TRAILER_EVENT_TYPE_MASK;
410
411
412 if (evt_type != ASYNC_SLI_EVENT_TYPE_MISCONFIGURED)
413 return;
414
415 async_sli = (struct be_async_event_sli *)compl;
416 state = async_sli->event_data1 >>
417 (phba->fw_config.phys_port * 8) & 0xff;
418 le = async_sli->event_data2 >>
419 (phba->fw_config.phys_port * 8) & 0xff;
420
421 old_state = phba->optic_state;
422 phba->optic_state = state;
423
424 if (state >= ARRAY_SIZE(beiscsi_port_misconf_event_msg)) {
425
426 __beiscsi_log(phba, KERN_ERR,
427 "BC_%d : Port %c: Unrecognized optic state 0x%x\n",
428 phba->port_name, async_sli->event_data1);
429 return;
430 }
431
432 if (ASYNC_SLI_LINK_EFFECT_VALID(le)) {
433
434 if (state > 3)
435 msg = (ASYNC_SLI_LINK_EFFECT_STATE(le)) ?
436 " Link is non-operational." :
437 " Link is operational.";
438
439 if (ASYNC_SLI_LINK_EFFECT_SEV(le) == 1)
440 sev = KERN_INFO;
441
442 if (ASYNC_SLI_LINK_EFFECT_SEV(le) == 2)
443 sev = KERN_ERR;
444 }
445
446 if (old_state != phba->optic_state)
447 __beiscsi_log(phba, sev, "BC_%d : Port %c: %s%s\n",
448 phba->port_name,
449 beiscsi_port_misconf_event_msg[state],
450 !msg ? "" : msg);
451}
452
453void beiscsi_process_async_event(struct beiscsi_hba *phba,
454 struct be_mcc_compl *compl)
455{
456 char *sev = KERN_INFO;
457 u8 evt_code;
458
459
460 evt_code = compl->flags >> ASYNC_TRAILER_EVENT_CODE_SHIFT;
461 evt_code &= ASYNC_TRAILER_EVENT_CODE_MASK;
462 switch (evt_code) {
463 case ASYNC_EVENT_CODE_LINK_STATE:
464 beiscsi_process_async_link(phba, compl);
465 break;
466 case ASYNC_EVENT_CODE_ISCSI:
467 if (test_bit(BEISCSI_HBA_BOOT_FOUND, &phba->state))
468 beiscsi_start_boot_work(phba, BE_BOOT_INVALID_SHANDLE);
469 sev = KERN_ERR;
470 break;
471 case ASYNC_EVENT_CODE_SLI:
472 beiscsi_process_async_sli(phba, compl);
473 break;
474 default:
475
476 sev = KERN_ERR;
477 }
478
479 beiscsi_log(phba, sev, BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
480 "BC_%d : ASYNC Event %x: status 0x%08x flags 0x%08x\n",
481 evt_code, compl->status, compl->flags);
482}
483
484int beiscsi_process_mcc_compl(struct be_ctrl_info *ctrl,
485 struct be_mcc_compl *compl)
486{
487 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
488 u16 compl_status, extd_status;
489 struct be_dma_mem *tag_mem;
490 unsigned int tag, wrb_idx;
491
492 be_dws_le_to_cpu(compl, 4);
493 tag = (compl->tag0 & MCC_Q_CMD_TAG_MASK);
494 wrb_idx = (compl->tag0 & CQE_STATUS_WRB_MASK) >> CQE_STATUS_WRB_SHIFT;
495
496 if (!test_bit(MCC_TAG_STATE_RUNNING,
497 &ctrl->ptag_state[tag].tag_state)) {
498 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_MBOX |
499 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
500 "BC_%d : MBX cmd completed but not posted\n");
501 return 0;
502 }
503
504
505 clear_bit(MCC_TAG_STATE_RUNNING, &ctrl->ptag_state[tag].tag_state);
506
507 if (test_bit(MCC_TAG_STATE_TIMEOUT, &ctrl->ptag_state[tag].tag_state)) {
508 beiscsi_log(phba, KERN_WARNING,
509 BEISCSI_LOG_MBOX | BEISCSI_LOG_INIT |
510 BEISCSI_LOG_CONFIG,
511 "BC_%d : MBX Completion for timeout Command from FW\n");
512
513
514
515
516 tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
517 if (tag_mem->size) {
518 dma_free_coherent(&ctrl->pdev->dev, tag_mem->size,
519 tag_mem->va, tag_mem->dma);
520 tag_mem->size = 0;
521 }
522 free_mcc_wrb(ctrl, tag);
523 return 0;
524 }
525
526 compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
527 CQE_STATUS_COMPL_MASK;
528 extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) &
529 CQE_STATUS_EXTD_MASK;
530
531
532
533
534 ctrl->mcc_tag_status[tag] = CQE_VALID_MASK;
535 ctrl->mcc_tag_status[tag] |= (wrb_idx << CQE_STATUS_WRB_SHIFT);
536 ctrl->mcc_tag_status[tag] |= (extd_status << CQE_STATUS_ADDL_SHIFT) &
537 CQE_STATUS_ADDL_MASK;
538 ctrl->mcc_tag_status[tag] |= (compl_status & CQE_STATUS_MASK);
539
540 if (test_bit(MCC_TAG_STATE_ASYNC, &ctrl->ptag_state[tag].tag_state)) {
541 if (ctrl->ptag_state[tag].cbfn)
542 ctrl->ptag_state[tag].cbfn(phba, tag);
543 else
544 __beiscsi_log(phba, KERN_ERR,
545 "BC_%d : MBX ASYNC command with no callback\n");
546 free_mcc_wrb(ctrl, tag);
547 return 0;
548 }
549
550 if (test_bit(MCC_TAG_STATE_IGNORE, &ctrl->ptag_state[tag].tag_state)) {
551
552 __beiscsi_mcc_compl_status(phba, tag, NULL, NULL);
553 free_mcc_wrb(ctrl, tag);
554 return 0;
555 }
556
557 wake_up_interruptible(&ctrl->mcc_wait[tag]);
558 return 0;
559}
560
561void be_mcc_notify(struct beiscsi_hba *phba, unsigned int tag)
562{
563 struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
564 u32 val = 0;
565
566 set_bit(MCC_TAG_STATE_RUNNING, &phba->ctrl.ptag_state[tag].tag_state);
567 val |= mccq->id & DB_MCCQ_RING_ID_MASK;
568 val |= 1 << DB_MCCQ_NUM_POSTED_SHIFT;
569
570 wmb();
571 iowrite32(val, phba->db_va + DB_MCCQ_OFFSET);
572}
573
574
575
576
577
578
579
580
581
582
583
584
585static int be_mbox_db_ready_poll(struct be_ctrl_info *ctrl)
586{
587
588#define BEISCSI_MBX_RDY_BIT_TIMEOUT 30000
589 void __iomem *db = ctrl->db + MPU_MAILBOX_DB_OFFSET;
590 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
591 unsigned long timeout;
592 u32 ready;
593
594
595
596
597
598 timeout = jiffies + msecs_to_jiffies(BEISCSI_MBX_RDY_BIT_TIMEOUT);
599 do {
600 if (beiscsi_hba_in_error(phba))
601 return -EIO;
602
603 ready = ioread32(db);
604 if (ready == 0xffffffff)
605 return -EIO;
606
607 ready &= MPU_MAILBOX_DB_RDY_MASK;
608 if (ready)
609 return 0;
610
611 if (time_after(jiffies, timeout))
612 break;
613
614 schedule_timeout_uninterruptible(msecs_to_jiffies(1));
615 } while (!ready);
616
617 beiscsi_log(phba, KERN_ERR,
618 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
619 "BC_%d : FW Timed Out\n");
620 set_bit(BEISCSI_HBA_FW_TIMEOUT, &phba->state);
621 return -EBUSY;
622}
623
624
625
626
627
628
629
630
631
632
633
634
635static int be_mbox_notify(struct be_ctrl_info *ctrl)
636{
637 int status;
638 u32 val = 0;
639 void __iomem *db = ctrl->db + MPU_MAILBOX_DB_OFFSET;
640 struct be_dma_mem *mbox_mem = &ctrl->mbox_mem;
641 struct be_mcc_mailbox *mbox = mbox_mem->va;
642
643 status = be_mbox_db_ready_poll(ctrl);
644 if (status)
645 return status;
646
647 val &= ~MPU_MAILBOX_DB_RDY_MASK;
648 val |= MPU_MAILBOX_DB_HI_MASK;
649 val |= (upper_32_bits(mbox_mem->dma) >> 2) << 2;
650 iowrite32(val, db);
651
652 status = be_mbox_db_ready_poll(ctrl);
653 if (status)
654 return status;
655
656 val = 0;
657 val &= ~MPU_MAILBOX_DB_RDY_MASK;
658 val &= ~MPU_MAILBOX_DB_HI_MASK;
659 val |= (u32) (mbox_mem->dma >> 4) << 2;
660 iowrite32(val, db);
661
662 status = be_mbox_db_ready_poll(ctrl);
663 if (status)
664 return status;
665
666
667 udelay(1);
668
669 status = beiscsi_process_mbox_compl(ctrl, &mbox->compl);
670 return status;
671}
672
673void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, u32 payload_len,
674 bool embedded, u8 sge_cnt)
675{
676 if (embedded)
677 wrb->emb_sgecnt_special |= MCC_WRB_EMBEDDED_MASK;
678 else
679 wrb->emb_sgecnt_special |= (sge_cnt & MCC_WRB_SGE_CNT_MASK) <<
680 MCC_WRB_SGE_CNT_SHIFT;
681 wrb->payload_length = payload_len;
682 be_dws_cpu_to_le(wrb, 8);
683}
684
685void be_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,
686 u8 subsystem, u8 opcode, u32 cmd_len)
687{
688 req_hdr->opcode = opcode;
689 req_hdr->subsystem = subsystem;
690 req_hdr->request_length = cpu_to_le32(cmd_len - sizeof(*req_hdr));
691 req_hdr->timeout = BEISCSI_FW_MBX_TIMEOUT;
692}
693
694static void be_cmd_page_addrs_prepare(struct phys_addr *pages, u32 max_pages,
695 struct be_dma_mem *mem)
696{
697 int i, buf_pages;
698 u64 dma = (u64) mem->dma;
699
700 buf_pages = min(PAGES_4K_SPANNED(mem->va, mem->size), max_pages);
701 for (i = 0; i < buf_pages; i++) {
702 pages[i].lo = cpu_to_le32(dma & 0xFFFFFFFF);
703 pages[i].hi = cpu_to_le32(upper_32_bits(dma));
704 dma += PAGE_SIZE_4K;
705 }
706}
707
708static u32 eq_delay_to_mult(u32 usec_delay)
709{
710#define MAX_INTR_RATE 651042
711 const u32 round = 10;
712 u32 multiplier;
713
714 if (usec_delay == 0)
715 multiplier = 0;
716 else {
717 u32 interrupt_rate = 1000000 / usec_delay;
718 if (interrupt_rate == 0)
719 multiplier = 1023;
720 else {
721 multiplier = (MAX_INTR_RATE - interrupt_rate) * round;
722 multiplier /= interrupt_rate;
723 multiplier = (multiplier + round / 2) / round;
724 multiplier = min(multiplier, (u32) 1023);
725 }
726 }
727 return multiplier;
728}
729
730struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem)
731{
732 return &((struct be_mcc_mailbox *)(mbox_mem->va))->wrb;
733}
734
735int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
736 struct be_queue_info *eq, int eq_delay)
737{
738 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
739 struct be_cmd_req_eq_create *req = embedded_payload(wrb);
740 struct be_cmd_resp_eq_create *resp = embedded_payload(wrb);
741 struct be_dma_mem *q_mem = &eq->dma_mem;
742 int status;
743
744 mutex_lock(&ctrl->mbox_lock);
745 memset(wrb, 0, sizeof(*wrb));
746
747 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
748
749 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
750 OPCODE_COMMON_EQ_CREATE, sizeof(*req));
751
752 req->num_pages = cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
753
754 AMAP_SET_BITS(struct amap_eq_context, func, req->context,
755 PCI_FUNC(ctrl->pdev->devfn));
756 AMAP_SET_BITS(struct amap_eq_context, valid, req->context, 1);
757 AMAP_SET_BITS(struct amap_eq_context, size, req->context, 0);
758 AMAP_SET_BITS(struct amap_eq_context, count, req->context,
759 __ilog2_u32(eq->len / 256));
760 AMAP_SET_BITS(struct amap_eq_context, delaymult, req->context,
761 eq_delay_to_mult(eq_delay));
762 be_dws_cpu_to_le(req->context, sizeof(req->context));
763
764 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
765
766 status = be_mbox_notify(ctrl);
767 if (!status) {
768 eq->id = le16_to_cpu(resp->eq_id);
769 eq->created = true;
770 }
771 mutex_unlock(&ctrl->mbox_lock);
772 return status;
773}
774
775int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
776 struct be_queue_info *cq, struct be_queue_info *eq,
777 bool sol_evts, bool no_delay, int coalesce_wm)
778{
779 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
780 struct be_cmd_req_cq_create *req = embedded_payload(wrb);
781 struct be_cmd_resp_cq_create *resp = embedded_payload(wrb);
782 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
783 struct be_dma_mem *q_mem = &cq->dma_mem;
784 void *ctxt = &req->context;
785 int status;
786
787 mutex_lock(&ctrl->mbox_lock);
788 memset(wrb, 0, sizeof(*wrb));
789
790 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
791
792 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
793 OPCODE_COMMON_CQ_CREATE, sizeof(*req));
794
795 req->num_pages = cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
796 if (is_chip_be2_be3r(phba)) {
797 AMAP_SET_BITS(struct amap_cq_context, coalescwm,
798 ctxt, coalesce_wm);
799 AMAP_SET_BITS(struct amap_cq_context, nodelay, ctxt, no_delay);
800 AMAP_SET_BITS(struct amap_cq_context, count, ctxt,
801 __ilog2_u32(cq->len / 256));
802 AMAP_SET_BITS(struct amap_cq_context, valid, ctxt, 1);
803 AMAP_SET_BITS(struct amap_cq_context, solevent, ctxt, sol_evts);
804 AMAP_SET_BITS(struct amap_cq_context, eventable, ctxt, 1);
805 AMAP_SET_BITS(struct amap_cq_context, eqid, ctxt, eq->id);
806 AMAP_SET_BITS(struct amap_cq_context, armed, ctxt, 1);
807 AMAP_SET_BITS(struct amap_cq_context, func, ctxt,
808 PCI_FUNC(ctrl->pdev->devfn));
809 } else {
810 req->hdr.version = MBX_CMD_VER2;
811 req->page_size = 1;
812 AMAP_SET_BITS(struct amap_cq_context_v2, coalescwm,
813 ctxt, coalesce_wm);
814 AMAP_SET_BITS(struct amap_cq_context_v2, nodelay,
815 ctxt, no_delay);
816 AMAP_SET_BITS(struct amap_cq_context_v2, count, ctxt,
817 __ilog2_u32(cq->len / 256));
818 AMAP_SET_BITS(struct amap_cq_context_v2, valid, ctxt, 1);
819 AMAP_SET_BITS(struct amap_cq_context_v2, eventable, ctxt, 1);
820 AMAP_SET_BITS(struct amap_cq_context_v2, eqid, ctxt, eq->id);
821 AMAP_SET_BITS(struct amap_cq_context_v2, armed, ctxt, 1);
822 }
823
824 be_dws_cpu_to_le(ctxt, sizeof(req->context));
825
826 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
827
828 status = be_mbox_notify(ctrl);
829 if (!status) {
830 cq->id = le16_to_cpu(resp->cq_id);
831 cq->created = true;
832 } else
833 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
834 "BC_%d : In be_cmd_cq_create, status=ox%08x\n",
835 status);
836
837 mutex_unlock(&ctrl->mbox_lock);
838
839 return status;
840}
841
842static u32 be_encoded_q_len(int q_len)
843{
844 u32 len_encoded = fls(q_len);
845 if (len_encoded == 16)
846 len_encoded = 0;
847 return len_encoded;
848}
849
850int beiscsi_cmd_mccq_create(struct beiscsi_hba *phba,
851 struct be_queue_info *mccq,
852 struct be_queue_info *cq)
853{
854 struct be_mcc_wrb *wrb;
855 struct be_cmd_req_mcc_create_ext *req;
856 struct be_dma_mem *q_mem = &mccq->dma_mem;
857 struct be_ctrl_info *ctrl;
858 void *ctxt;
859 int status;
860
861 mutex_lock(&phba->ctrl.mbox_lock);
862 ctrl = &phba->ctrl;
863 wrb = wrb_from_mbox(&ctrl->mbox_mem);
864 memset(wrb, 0, sizeof(*wrb));
865 req = embedded_payload(wrb);
866 ctxt = &req->context;
867
868 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
869
870 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
871 OPCODE_COMMON_MCC_CREATE_EXT, sizeof(*req));
872
873 req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
874 req->async_evt_bitmap = 1 << ASYNC_EVENT_CODE_LINK_STATE;
875 req->async_evt_bitmap |= 1 << ASYNC_EVENT_CODE_ISCSI;
876 req->async_evt_bitmap |= 1 << ASYNC_EVENT_CODE_SLI;
877
878 AMAP_SET_BITS(struct amap_mcc_context, fid, ctxt,
879 PCI_FUNC(phba->pcidev->devfn));
880 AMAP_SET_BITS(struct amap_mcc_context, valid, ctxt, 1);
881 AMAP_SET_BITS(struct amap_mcc_context, ring_size, ctxt,
882 be_encoded_q_len(mccq->len));
883 AMAP_SET_BITS(struct amap_mcc_context, cq_id, ctxt, cq->id);
884
885 be_dws_cpu_to_le(ctxt, sizeof(req->context));
886
887 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
888
889 status = be_mbox_notify(ctrl);
890 if (!status) {
891 struct be_cmd_resp_mcc_create *resp = embedded_payload(wrb);
892 mccq->id = le16_to_cpu(resp->id);
893 mccq->created = true;
894 }
895 mutex_unlock(&phba->ctrl.mbox_lock);
896
897 return status;
898}
899
900int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
901 int queue_type)
902{
903 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
904 struct be_cmd_req_q_destroy *req = embedded_payload(wrb);
905 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
906 u8 subsys = 0, opcode = 0;
907 int status;
908
909 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
910 "BC_%d : In beiscsi_cmd_q_destroy "
911 "queue_type : %d\n", queue_type);
912
913 mutex_lock(&ctrl->mbox_lock);
914 memset(wrb, 0, sizeof(*wrb));
915 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
916
917 switch (queue_type) {
918 case QTYPE_EQ:
919 subsys = CMD_SUBSYSTEM_COMMON;
920 opcode = OPCODE_COMMON_EQ_DESTROY;
921 break;
922 case QTYPE_CQ:
923 subsys = CMD_SUBSYSTEM_COMMON;
924 opcode = OPCODE_COMMON_CQ_DESTROY;
925 break;
926 case QTYPE_MCCQ:
927 subsys = CMD_SUBSYSTEM_COMMON;
928 opcode = OPCODE_COMMON_MCC_DESTROY;
929 break;
930 case QTYPE_WRBQ:
931 subsys = CMD_SUBSYSTEM_ISCSI;
932 opcode = OPCODE_COMMON_ISCSI_WRBQ_DESTROY;
933 break;
934 case QTYPE_DPDUQ:
935 subsys = CMD_SUBSYSTEM_ISCSI;
936 opcode = OPCODE_COMMON_ISCSI_DEFQ_DESTROY;
937 break;
938 case QTYPE_SGL:
939 subsys = CMD_SUBSYSTEM_ISCSI;
940 opcode = OPCODE_COMMON_ISCSI_CFG_REMOVE_SGL_PAGES;
941 break;
942 default:
943 mutex_unlock(&ctrl->mbox_lock);
944 BUG();
945 }
946 be_cmd_hdr_prepare(&req->hdr, subsys, opcode, sizeof(*req));
947 if (queue_type != QTYPE_SGL)
948 req->id = cpu_to_le16(q->id);
949
950 status = be_mbox_notify(ctrl);
951
952 mutex_unlock(&ctrl->mbox_lock);
953 return status;
954}
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
975 struct be_queue_info *cq,
976 struct be_queue_info *dq, int length,
977 int entry_size, uint8_t is_header,
978 uint8_t ulp_num)
979{
980 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
981 struct be_defq_create_req *req = embedded_payload(wrb);
982 struct be_dma_mem *q_mem = &dq->dma_mem;
983 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
984 void *ctxt = &req->context;
985 int status;
986
987 mutex_lock(&ctrl->mbox_lock);
988 memset(wrb, 0, sizeof(*wrb));
989
990 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
991
992 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
993 OPCODE_COMMON_ISCSI_DEFQ_CREATE, sizeof(*req));
994
995 req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
996 if (phba->fw_config.dual_ulp_aware) {
997 req->ulp_num = ulp_num;
998 req->dua_feature |= (1 << BEISCSI_DUAL_ULP_AWARE_BIT);
999 req->dua_feature |= (1 << BEISCSI_BIND_Q_TO_ULP_BIT);
1000 }
1001
1002 if (is_chip_be2_be3r(phba)) {
1003 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1004 rx_pdid, ctxt, 0);
1005 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1006 rx_pdid_valid, ctxt, 1);
1007 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1008 pci_func_id, ctxt, PCI_FUNC(ctrl->pdev->devfn));
1009 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1010 ring_size, ctxt,
1011 be_encoded_q_len(length /
1012 sizeof(struct phys_addr)));
1013 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1014 default_buffer_size, ctxt, entry_size);
1015 AMAP_SET_BITS(struct amap_be_default_pdu_context,
1016 cq_id_recv, ctxt, cq->id);
1017 } else {
1018 AMAP_SET_BITS(struct amap_default_pdu_context_ext,
1019 rx_pdid, ctxt, 0);
1020 AMAP_SET_BITS(struct amap_default_pdu_context_ext,
1021 rx_pdid_valid, ctxt, 1);
1022 AMAP_SET_BITS(struct amap_default_pdu_context_ext,
1023 ring_size, ctxt,
1024 be_encoded_q_len(length /
1025 sizeof(struct phys_addr)));
1026 AMAP_SET_BITS(struct amap_default_pdu_context_ext,
1027 default_buffer_size, ctxt, entry_size);
1028 AMAP_SET_BITS(struct amap_default_pdu_context_ext,
1029 cq_id_recv, ctxt, cq->id);
1030 }
1031
1032 be_dws_cpu_to_le(ctxt, sizeof(req->context));
1033
1034 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
1035
1036 status = be_mbox_notify(ctrl);
1037 if (!status) {
1038 struct be_ring *defq_ring;
1039 struct be_defq_create_resp *resp = embedded_payload(wrb);
1040
1041 dq->id = le16_to_cpu(resp->id);
1042 dq->created = true;
1043 if (is_header)
1044 defq_ring = &phba->phwi_ctrlr->default_pdu_hdr[ulp_num];
1045 else
1046 defq_ring = &phba->phwi_ctrlr->
1047 default_pdu_data[ulp_num];
1048
1049 defq_ring->id = dq->id;
1050
1051 if (!phba->fw_config.dual_ulp_aware) {
1052 defq_ring->ulp_num = BEISCSI_ULP0;
1053 defq_ring->doorbell_offset = DB_RXULP0_OFFSET;
1054 } else {
1055 defq_ring->ulp_num = resp->ulp_num;
1056 defq_ring->doorbell_offset = resp->doorbell_offset;
1057 }
1058 }
1059 mutex_unlock(&ctrl->mbox_lock);
1060
1061 return status;
1062}
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075int be_cmd_wrbq_create(struct be_ctrl_info *ctrl,
1076 struct be_dma_mem *q_mem,
1077 struct be_queue_info *wrbq,
1078 struct hwi_wrb_context *pwrb_context,
1079 uint8_t ulp_num)
1080{
1081 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1082 struct be_wrbq_create_req *req = embedded_payload(wrb);
1083 struct be_wrbq_create_resp *resp = embedded_payload(wrb);
1084 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
1085 int status;
1086
1087 mutex_lock(&ctrl->mbox_lock);
1088 memset(wrb, 0, sizeof(*wrb));
1089
1090 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1091
1092 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
1093 OPCODE_COMMON_ISCSI_WRBQ_CREATE, sizeof(*req));
1094 req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
1095
1096 if (phba->fw_config.dual_ulp_aware) {
1097 req->ulp_num = ulp_num;
1098 req->dua_feature |= (1 << BEISCSI_DUAL_ULP_AWARE_BIT);
1099 req->dua_feature |= (1 << BEISCSI_BIND_Q_TO_ULP_BIT);
1100 }
1101
1102 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
1103
1104 status = be_mbox_notify(ctrl);
1105 if (!status) {
1106 wrbq->id = le16_to_cpu(resp->cid);
1107 wrbq->created = true;
1108
1109 pwrb_context->cid = wrbq->id;
1110 if (!phba->fw_config.dual_ulp_aware) {
1111 pwrb_context->doorbell_offset = DB_TXULP0_OFFSET;
1112 pwrb_context->ulp_num = BEISCSI_ULP0;
1113 } else {
1114 pwrb_context->ulp_num = resp->ulp_num;
1115 pwrb_context->doorbell_offset = resp->doorbell_offset;
1116 }
1117 }
1118 mutex_unlock(&ctrl->mbox_lock);
1119 return status;
1120}
1121
1122int be_cmd_iscsi_post_template_hdr(struct be_ctrl_info *ctrl,
1123 struct be_dma_mem *q_mem)
1124{
1125 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1126 struct be_post_template_pages_req *req = embedded_payload(wrb);
1127 int status;
1128
1129 mutex_lock(&ctrl->mbox_lock);
1130
1131 memset(wrb, 0, sizeof(*wrb));
1132 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1133 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1134 OPCODE_COMMON_ADD_TEMPLATE_HEADER_BUFFERS,
1135 sizeof(*req));
1136
1137 req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
1138 req->type = BEISCSI_TEMPLATE_HDR_TYPE_ISCSI;
1139 be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
1140
1141 status = be_mbox_notify(ctrl);
1142 mutex_unlock(&ctrl->mbox_lock);
1143 return status;
1144}
1145
1146int be_cmd_iscsi_remove_template_hdr(struct be_ctrl_info *ctrl)
1147{
1148 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1149 struct be_remove_template_pages_req *req = embedded_payload(wrb);
1150 int status;
1151
1152 mutex_lock(&ctrl->mbox_lock);
1153
1154 memset(wrb, 0, sizeof(*wrb));
1155 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1156 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1157 OPCODE_COMMON_REMOVE_TEMPLATE_HEADER_BUFFERS,
1158 sizeof(*req));
1159
1160 req->type = BEISCSI_TEMPLATE_HDR_TYPE_ISCSI;
1161
1162 status = be_mbox_notify(ctrl);
1163 mutex_unlock(&ctrl->mbox_lock);
1164 return status;
1165}
1166
1167int be_cmd_iscsi_post_sgl_pages(struct be_ctrl_info *ctrl,
1168 struct be_dma_mem *q_mem,
1169 u32 page_offset, u32 num_pages)
1170{
1171 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1172 struct be_post_sgl_pages_req *req = embedded_payload(wrb);
1173 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
1174 int status;
1175 unsigned int curr_pages;
1176 u32 internal_page_offset = 0;
1177 u32 temp_num_pages = num_pages;
1178
1179 if (num_pages == 0xff)
1180 num_pages = 1;
1181
1182 mutex_lock(&ctrl->mbox_lock);
1183 do {
1184 memset(wrb, 0, sizeof(*wrb));
1185 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1186 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
1187 OPCODE_COMMON_ISCSI_CFG_POST_SGL_PAGES,
1188 sizeof(*req));
1189 curr_pages = BE_NUMBER_OF_FIELD(struct be_post_sgl_pages_req,
1190 pages);
1191 req->num_pages = min(num_pages, curr_pages);
1192 req->page_offset = page_offset;
1193 be_cmd_page_addrs_prepare(req->pages, req->num_pages, q_mem);
1194 q_mem->dma = q_mem->dma + (req->num_pages * PAGE_SIZE);
1195 internal_page_offset += req->num_pages;
1196 page_offset += req->num_pages;
1197 num_pages -= req->num_pages;
1198
1199 if (temp_num_pages == 0xff)
1200 req->num_pages = temp_num_pages;
1201
1202 status = be_mbox_notify(ctrl);
1203 if (status) {
1204 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1205 "BC_%d : FW CMD to map iscsi frags failed.\n");
1206
1207 goto error;
1208 }
1209 } while (num_pages > 0);
1210error:
1211 mutex_unlock(&ctrl->mbox_lock);
1212 if (status != 0)
1213 beiscsi_cmd_q_destroy(ctrl, NULL, QTYPE_SGL);
1214 return status;
1215}
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227int be_cmd_set_vlan(struct beiscsi_hba *phba,
1228 uint16_t vlan_tag)
1229{
1230 unsigned int tag;
1231 struct be_mcc_wrb *wrb;
1232 struct be_cmd_set_vlan_req *req;
1233 struct be_ctrl_info *ctrl = &phba->ctrl;
1234
1235 if (mutex_lock_interruptible(&ctrl->mbox_lock))
1236 return 0;
1237 wrb = alloc_mcc_wrb(phba, &tag);
1238 if (!wrb) {
1239 mutex_unlock(&ctrl->mbox_lock);
1240 return 0;
1241 }
1242
1243 req = embedded_payload(wrb);
1244 be_wrb_hdr_prepare(wrb, sizeof(*wrb), true, 0);
1245 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
1246 OPCODE_COMMON_ISCSI_NTWK_SET_VLAN,
1247 sizeof(*req));
1248
1249 req->interface_hndl = phba->interface_handle;
1250 req->vlan_priority = vlan_tag;
1251
1252 be_mcc_notify(phba, tag);
1253 mutex_unlock(&ctrl->mbox_lock);
1254
1255 return tag;
1256}
1257
1258int beiscsi_check_supported_fw(struct be_ctrl_info *ctrl,
1259 struct beiscsi_hba *phba)
1260{
1261 struct be_dma_mem nonemb_cmd;
1262 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1263 struct be_mgmt_controller_attributes *req;
1264 struct be_sge *sge = nonembedded_sgl(wrb);
1265 int status = 0;
1266
1267 nonemb_cmd.va = dma_alloc_coherent(&ctrl->pdev->dev,
1268 sizeof(struct be_mgmt_controller_attributes),
1269 &nonemb_cmd.dma, GFP_KERNEL);
1270 if (nonemb_cmd.va == NULL) {
1271 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1272 "BG_%d : dma_alloc_coherent failed in %s\n",
1273 __func__);
1274 return -ENOMEM;
1275 }
1276 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
1277 req = nonemb_cmd.va;
1278 memset(req, 0, sizeof(*req));
1279 mutex_lock(&ctrl->mbox_lock);
1280 memset(wrb, 0, sizeof(*wrb));
1281 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
1282 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1283 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req));
1284 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma));
1285 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
1286 sge->len = cpu_to_le32(nonemb_cmd.size);
1287 status = be_mbox_notify(ctrl);
1288 if (!status) {
1289 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va;
1290
1291 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1292 "BG_%d : Firmware Version of CMD : %s\n"
1293 "Firmware Version is : %s\n"
1294 "Developer Build, not performing version check...\n",
1295 resp->params.hba_attribs
1296 .flashrom_version_string,
1297 resp->params.hba_attribs.
1298 firmware_version_string);
1299
1300 phba->fw_config.iscsi_features =
1301 resp->params.hba_attribs.iscsi_features;
1302 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1303 "BM_%d : phba->fw_config.iscsi_features = %d\n",
1304 phba->fw_config.iscsi_features);
1305 memcpy(phba->fw_ver_str, resp->params.hba_attribs.
1306 firmware_version_string, BEISCSI_VER_STRLEN);
1307 } else
1308 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1309 "BG_%d : Failed in beiscsi_check_supported_fw\n");
1310 mutex_unlock(&ctrl->mbox_lock);
1311 if (nonemb_cmd.va)
1312 dma_free_coherent(&ctrl->pdev->dev, nonemb_cmd.size,
1313 nonemb_cmd.va, nonemb_cmd.dma);
1314
1315 return status;
1316}
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330int beiscsi_get_fw_config(struct be_ctrl_info *ctrl,
1331 struct beiscsi_hba *phba)
1332{
1333 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1334 struct be_fw_cfg *pfw_cfg = embedded_payload(wrb);
1335 uint32_t cid_count, icd_count;
1336 int status = -EINVAL;
1337 uint8_t ulp_num = 0;
1338
1339 mutex_lock(&ctrl->mbox_lock);
1340 memset(wrb, 0, sizeof(*wrb));
1341 be_wrb_hdr_prepare(wrb, sizeof(*pfw_cfg), true, 0);
1342
1343 be_cmd_hdr_prepare(&pfw_cfg->hdr, CMD_SUBSYSTEM_COMMON,
1344 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG,
1345 EMBED_MBX_MAX_PAYLOAD_SIZE);
1346
1347 if (be_mbox_notify(ctrl)) {
1348 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1349 "BG_%d : Failed in beiscsi_get_fw_config\n");
1350 goto fail_init;
1351 }
1352
1353
1354 phba->fw_config.phys_port = pfw_cfg->phys_port;
1355 if (phba->fw_config.phys_port >= BEISCSI_PHYS_PORT_MAX) {
1356 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1357 "BG_%d : invalid physical port id %d\n",
1358 phba->fw_config.phys_port);
1359 goto fail_init;
1360 }
1361
1362
1363 if (!is_chip_be2_be3r(phba)) {
1364 phba->fw_config.eqid_count = pfw_cfg->eqid_count;
1365 phba->fw_config.cqid_count = pfw_cfg->cqid_count;
1366 if (phba->fw_config.eqid_count == 0 ||
1367 phba->fw_config.eqid_count > 2048) {
1368 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1369 "BG_%d : invalid EQ count %d\n",
1370 phba->fw_config.eqid_count);
1371 goto fail_init;
1372 }
1373 if (phba->fw_config.cqid_count == 0 ||
1374 phba->fw_config.cqid_count > 4096) {
1375 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1376 "BG_%d : invalid CQ count %d\n",
1377 phba->fw_config.cqid_count);
1378 goto fail_init;
1379 }
1380 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1381 "BG_%d : EQ_Count : %d CQ_Count : %d\n",
1382 phba->fw_config.eqid_count,
1383 phba->fw_config.cqid_count);
1384 }
1385
1386
1387
1388
1389
1390
1391
1392 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
1393 if (pfw_cfg->ulp[ulp_num].ulp_mode &
1394 BEISCSI_ULP_ISCSI_INI_MODE) {
1395 set_bit(ulp_num, &phba->fw_config.ulp_supported);
1396
1397
1398 phba->fw_config.iscsi_cid_start[ulp_num] =
1399 pfw_cfg->ulp[ulp_num].sq_base;
1400 phba->fw_config.iscsi_cid_count[ulp_num] =
1401 pfw_cfg->ulp[ulp_num].sq_count;
1402
1403 phba->fw_config.iscsi_icd_start[ulp_num] =
1404 pfw_cfg->ulp[ulp_num].icd_base;
1405 phba->fw_config.iscsi_icd_count[ulp_num] =
1406 pfw_cfg->ulp[ulp_num].icd_count;
1407
1408 phba->fw_config.iscsi_chain_start[ulp_num] =
1409 pfw_cfg->chain_icd[ulp_num].chain_base;
1410 phba->fw_config.iscsi_chain_count[ulp_num] =
1411 pfw_cfg->chain_icd[ulp_num].chain_count;
1412
1413 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1414 "BG_%d : Function loaded on ULP : %d\n"
1415 "\tiscsi_cid_count : %d\n"
1416 "\tiscsi_cid_start : %d\n"
1417 "\t iscsi_icd_count : %d\n"
1418 "\t iscsi_icd_start : %d\n",
1419 ulp_num,
1420 phba->fw_config.
1421 iscsi_cid_count[ulp_num],
1422 phba->fw_config.
1423 iscsi_cid_start[ulp_num],
1424 phba->fw_config.
1425 iscsi_icd_count[ulp_num],
1426 phba->fw_config.
1427 iscsi_icd_start[ulp_num]);
1428 }
1429 }
1430
1431 if (phba->fw_config.ulp_supported == 0) {
1432 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1433 "BG_%d : iSCSI initiator mode not set: ULP0 %x ULP1 %x\n",
1434 pfw_cfg->ulp[BEISCSI_ULP0].ulp_mode,
1435 pfw_cfg->ulp[BEISCSI_ULP1].ulp_mode);
1436 goto fail_init;
1437 }
1438
1439
1440
1441
1442 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++)
1443 if (test_bit(ulp_num, &phba->fw_config.ulp_supported))
1444 break;
1445 icd_count = phba->fw_config.iscsi_icd_count[ulp_num];
1446 if (icd_count == 0 || icd_count > 65536) {
1447 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1448 "BG_%d: invalid ICD count %d\n", icd_count);
1449 goto fail_init;
1450 }
1451
1452 cid_count = BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP0) +
1453 BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP1);
1454 if (cid_count == 0 || cid_count > 4096) {
1455 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1456 "BG_%d: invalid CID count %d\n", cid_count);
1457 goto fail_init;
1458 }
1459
1460
1461
1462
1463
1464 phba->fw_config.dual_ulp_aware = (pfw_cfg->function_mode &
1465 BEISCSI_FUNC_DUA_MODE);
1466
1467 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1468 "BG_%d : DUA Mode : 0x%x\n",
1469 phba->fw_config.dual_ulp_aware);
1470
1471
1472 status = 0;
1473fail_init:
1474 mutex_unlock(&ctrl->mbox_lock);
1475 return status;
1476}
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486int beiscsi_get_port_name(struct be_ctrl_info *ctrl, struct beiscsi_hba *phba)
1487{
1488 int ret = 0;
1489 struct be_mcc_wrb *wrb;
1490 struct be_cmd_get_port_name *ioctl;
1491
1492 mutex_lock(&ctrl->mbox_lock);
1493 wrb = wrb_from_mbox(&ctrl->mbox_mem);
1494 memset(wrb, 0, sizeof(*wrb));
1495 ioctl = embedded_payload(wrb);
1496
1497 be_wrb_hdr_prepare(wrb, sizeof(*ioctl), true, 0);
1498 be_cmd_hdr_prepare(&ioctl->h.req_hdr, CMD_SUBSYSTEM_COMMON,
1499 OPCODE_COMMON_GET_PORT_NAME,
1500 EMBED_MBX_MAX_PAYLOAD_SIZE);
1501 ret = be_mbox_notify(ctrl);
1502 phba->port_name = 0;
1503 if (!ret) {
1504 phba->port_name = ioctl->p.resp.port_names >>
1505 (phba->fw_config.phys_port * 8) & 0xff;
1506 } else {
1507 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1508 "BG_%d : GET_PORT_NAME ret 0x%x status 0x%x\n",
1509 ret, ioctl->h.resp_hdr.status);
1510 }
1511
1512 if (phba->port_name == 0)
1513 phba->port_name = '?';
1514
1515 mutex_unlock(&ctrl->mbox_lock);
1516 return ret;
1517}
1518
1519int beiscsi_set_host_data(struct beiscsi_hba *phba)
1520{
1521 struct be_ctrl_info *ctrl = &phba->ctrl;
1522 struct be_cmd_set_host_data *ioctl;
1523 struct be_mcc_wrb *wrb;
1524 int ret = 0;
1525
1526 if (is_chip_be2_be3r(phba))
1527 return ret;
1528
1529 mutex_lock(&ctrl->mbox_lock);
1530 wrb = wrb_from_mbox(&ctrl->mbox_mem);
1531 memset(wrb, 0, sizeof(*wrb));
1532 ioctl = embedded_payload(wrb);
1533
1534 be_wrb_hdr_prepare(wrb, sizeof(*ioctl), true, 0);
1535 be_cmd_hdr_prepare(&ioctl->h.req_hdr, CMD_SUBSYSTEM_COMMON,
1536 OPCODE_COMMON_SET_HOST_DATA,
1537 EMBED_MBX_MAX_PAYLOAD_SIZE);
1538 ioctl->param.req.param_id = BE_CMD_SET_HOST_PARAM_ID;
1539 ioctl->param.req.param_len =
1540 snprintf((char *)ioctl->param.req.param_data,
1541 sizeof(ioctl->param.req.param_data),
1542 "Linux iSCSI v%s", BUILD_STR);
1543 ioctl->param.req.param_len = ALIGN(ioctl->param.req.param_len + 1, 4);
1544 if (ioctl->param.req.param_len > BE_CMD_MAX_DRV_VERSION)
1545 ioctl->param.req.param_len = BE_CMD_MAX_DRV_VERSION;
1546 ret = be_mbox_notify(ctrl);
1547 if (!ret) {
1548 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1549 "BG_%d : HBA set host driver version\n");
1550 } else {
1551
1552
1553
1554
1555 if (ret == MCC_STATUS_ILLEGAL_REQUEST ||
1556 ret == MCC_STATUS_INVALID_LENGTH)
1557 __beiscsi_log(phba, KERN_INFO,
1558 "BG_%d : HBA failed to set host driver version\n");
1559 }
1560
1561 mutex_unlock(&ctrl->mbox_lock);
1562 return ret;
1563}
1564
1565int beiscsi_set_uer_feature(struct beiscsi_hba *phba)
1566{
1567 struct be_ctrl_info *ctrl = &phba->ctrl;
1568 struct be_cmd_set_features *ioctl;
1569 struct be_mcc_wrb *wrb;
1570 int ret = 0;
1571
1572 mutex_lock(&ctrl->mbox_lock);
1573 wrb = wrb_from_mbox(&ctrl->mbox_mem);
1574 memset(wrb, 0, sizeof(*wrb));
1575 ioctl = embedded_payload(wrb);
1576
1577 be_wrb_hdr_prepare(wrb, sizeof(*ioctl), true, 0);
1578 be_cmd_hdr_prepare(&ioctl->h.req_hdr, CMD_SUBSYSTEM_COMMON,
1579 OPCODE_COMMON_SET_FEATURES,
1580 EMBED_MBX_MAX_PAYLOAD_SIZE);
1581 ioctl->feature = BE_CMD_SET_FEATURE_UER;
1582 ioctl->param_len = sizeof(ioctl->param.req);
1583 ioctl->param.req.uer = BE_CMD_UER_SUPP_BIT;
1584 ret = be_mbox_notify(ctrl);
1585 if (!ret) {
1586 phba->ue2rp = ioctl->param.resp.ue2rp;
1587 set_bit(BEISCSI_HBA_UER_SUPP, &phba->state);
1588 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1589 "BG_%d : HBA error recovery supported\n");
1590 } else {
1591
1592
1593
1594
1595 if (ret == MCC_STATUS_ILLEGAL_REQUEST ||
1596 ret == MCC_STATUS_INVALID_LENGTH)
1597 __beiscsi_log(phba, KERN_INFO,
1598 "BG_%d : HBA error recovery not supported\n");
1599 }
1600
1601 mutex_unlock(&ctrl->mbox_lock);
1602 return ret;
1603}
1604
1605static u32 beiscsi_get_post_stage(struct beiscsi_hba *phba)
1606{
1607 u32 sem;
1608
1609 if (is_chip_be2_be3r(phba))
1610 sem = ioread32(phba->csr_va + SLIPORT_SEMAPHORE_OFFSET_BEx);
1611 else
1612 pci_read_config_dword(phba->pcidev,
1613 SLIPORT_SEMAPHORE_OFFSET_SH, &sem);
1614 return sem;
1615}
1616
1617int beiscsi_check_fw_rdy(struct beiscsi_hba *phba)
1618{
1619 u32 loop, post, rdy = 0;
1620
1621 loop = 1000;
1622 while (loop--) {
1623 post = beiscsi_get_post_stage(phba);
1624 if (post & POST_ERROR_BIT)
1625 break;
1626 if ((post & POST_STAGE_MASK) == POST_STAGE_ARMFW_RDY) {
1627 rdy = 1;
1628 break;
1629 }
1630 msleep(60);
1631 }
1632
1633 if (!rdy) {
1634 __beiscsi_log(phba, KERN_ERR,
1635 "BC_%d : FW not ready 0x%x\n", post);
1636 }
1637
1638 return rdy;
1639}
1640
1641int beiscsi_cmd_function_reset(struct beiscsi_hba *phba)
1642{
1643 struct be_ctrl_info *ctrl = &phba->ctrl;
1644 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1645 struct be_post_sgl_pages_req *req;
1646 int status;
1647
1648 mutex_lock(&ctrl->mbox_lock);
1649
1650 req = embedded_payload(wrb);
1651 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1652 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1653 OPCODE_COMMON_FUNCTION_RESET, sizeof(*req));
1654 status = be_mbox_notify(ctrl);
1655
1656 mutex_unlock(&ctrl->mbox_lock);
1657 return status;
1658}
1659
1660int beiscsi_cmd_special_wrb(struct be_ctrl_info *ctrl, u32 load)
1661{
1662 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
1663 struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
1664 u8 *endian_check;
1665 int status;
1666
1667 mutex_lock(&ctrl->mbox_lock);
1668 memset(wrb, 0, sizeof(*wrb));
1669
1670 endian_check = (u8 *) wrb;
1671 if (load) {
1672
1673 *endian_check++ = 0xFF;
1674 *endian_check++ = 0x12;
1675 *endian_check++ = 0x34;
1676 *endian_check++ = 0xFF;
1677 *endian_check++ = 0xFF;
1678 *endian_check++ = 0x56;
1679 *endian_check++ = 0x78;
1680 *endian_check++ = 0xFF;
1681 } else {
1682
1683 *endian_check++ = 0xFF;
1684 *endian_check++ = 0xAA;
1685 *endian_check++ = 0xBB;
1686 *endian_check++ = 0xFF;
1687 *endian_check++ = 0xFF;
1688 *endian_check++ = 0xCC;
1689 *endian_check++ = 0xDD;
1690 *endian_check = 0xFF;
1691 }
1692 be_dws_cpu_to_le(wrb, sizeof(*wrb));
1693
1694 status = be_mbox_notify(ctrl);
1695 if (status)
1696 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
1697 "BC_%d : special WRB message failed\n");
1698 mutex_unlock(&ctrl->mbox_lock);
1699 return status;
1700}
1701
1702int beiscsi_init_sliport(struct beiscsi_hba *phba)
1703{
1704 int status;
1705
1706
1707 status = beiscsi_check_fw_rdy(phba);
1708 if (!status)
1709 return -EIO;
1710
1711
1712 phba->state &= ~BEISCSI_HBA_IN_ERR;
1713
1714
1715 phba->state &= ~BEISCSI_HBA_UER_SUPP;
1716
1717
1718
1719
1720
1721 status = beiscsi_cmd_function_reset(phba);
1722 if (status) {
1723 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1724 "BC_%d : SLI Function Reset failed\n");
1725 return status;
1726 }
1727
1728
1729 return beiscsi_cmd_special_wrb(&phba->ctrl, 1);
1730}
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741int beiscsi_cmd_iscsi_cleanup(struct beiscsi_hba *phba, unsigned short ulp)
1742{
1743 struct be_ctrl_info *ctrl = &phba->ctrl;
1744 struct iscsi_cleanup_req_v1 *req_v1;
1745 struct iscsi_cleanup_req *req;
1746 u16 hdr_ring_id, data_ring_id;
1747 struct be_mcc_wrb *wrb;
1748 int status;
1749
1750 mutex_lock(&ctrl->mbox_lock);
1751 wrb = wrb_from_mbox(&ctrl->mbox_mem);
1752
1753 hdr_ring_id = HWI_GET_DEF_HDRQ_ID(phba, ulp);
1754 data_ring_id = HWI_GET_DEF_BUFQ_ID(phba, ulp);
1755 if (is_chip_be2_be3r(phba)) {
1756 req = embedded_payload(wrb);
1757 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
1758 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
1759 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
1760 req->chute = (1 << ulp);
1761
1762 req->hdr_ring_id = hdr_ring_id;
1763 req->data_ring_id = data_ring_id;
1764 } else {
1765 req_v1 = embedded_payload(wrb);
1766 be_wrb_hdr_prepare(wrb, sizeof(*req_v1), true, 0);
1767 be_cmd_hdr_prepare(&req_v1->hdr, CMD_SUBSYSTEM_ISCSI,
1768 OPCODE_COMMON_ISCSI_CLEANUP,
1769 sizeof(*req_v1));
1770 req_v1->hdr.version = 1;
1771 req_v1->chute = (1 << ulp);
1772 req_v1->hdr_ring_id = cpu_to_le16(hdr_ring_id);
1773 req_v1->data_ring_id = cpu_to_le16(data_ring_id);
1774 }
1775
1776 status = be_mbox_notify(ctrl);
1777 if (status)
1778 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
1779 "BG_%d : %s failed %d\n", __func__, ulp);
1780 mutex_unlock(&ctrl->mbox_lock);
1781 return status;
1782}
1783
1784
1785
1786
1787
1788
1789
1790int beiscsi_detect_ue(struct beiscsi_hba *phba)
1791{
1792 uint32_t ue_mask_hi = 0, ue_mask_lo = 0;
1793 uint32_t ue_hi = 0, ue_lo = 0;
1794 uint8_t i = 0;
1795 int ret = 0;
1796
1797 pci_read_config_dword(phba->pcidev,
1798 PCICFG_UE_STATUS_LOW, &ue_lo);
1799 pci_read_config_dword(phba->pcidev,
1800 PCICFG_UE_STATUS_MASK_LOW,
1801 &ue_mask_lo);
1802 pci_read_config_dword(phba->pcidev,
1803 PCICFG_UE_STATUS_HIGH,
1804 &ue_hi);
1805 pci_read_config_dword(phba->pcidev,
1806 PCICFG_UE_STATUS_MASK_HI,
1807 &ue_mask_hi);
1808
1809 ue_lo = (ue_lo & ~ue_mask_lo);
1810 ue_hi = (ue_hi & ~ue_mask_hi);
1811
1812
1813 if (ue_lo || ue_hi) {
1814 set_bit(BEISCSI_HBA_IN_UE, &phba->state);
1815 __beiscsi_log(phba, KERN_ERR,
1816 "BC_%d : HBA error detected\n");
1817 ret = 1;
1818 }
1819
1820 if (ue_lo) {
1821 for (i = 0; ue_lo; ue_lo >>= 1, i++) {
1822 if (ue_lo & 1)
1823 __beiscsi_log(phba, KERN_ERR,
1824 "BC_%d : UE_LOW %s bit set\n",
1825 desc_ue_status_low[i]);
1826 }
1827 }
1828
1829 if (ue_hi) {
1830 for (i = 0; ue_hi; ue_hi >>= 1, i++) {
1831 if (ue_hi & 1)
1832 __beiscsi_log(phba, KERN_ERR,
1833 "BC_%d : UE_HIGH %s bit set\n",
1834 desc_ue_status_hi[i]);
1835 }
1836 }
1837 return ret;
1838}
1839
1840
1841
1842
1843
1844
1845
1846
1847int beiscsi_detect_tpe(struct beiscsi_hba *phba)
1848{
1849 u32 post, status;
1850 int ret = 0;
1851
1852 post = beiscsi_get_post_stage(phba);
1853 status = post & POST_STAGE_MASK;
1854 if ((status & POST_ERR_RECOVERY_CODE_MASK) ==
1855 POST_STAGE_RECOVERABLE_ERR) {
1856 set_bit(BEISCSI_HBA_IN_TPE, &phba->state);
1857 __beiscsi_log(phba, KERN_INFO,
1858 "BC_%d : HBA error recoverable: 0x%x\n", post);
1859 ret = 1;
1860 } else {
1861 __beiscsi_log(phba, KERN_INFO,
1862 "BC_%d : HBA in UE: 0x%x\n", post);
1863 }
1864
1865 return ret;
1866}
1867
