?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi-topcliff-pch: add recovery processing in case wait-event timeout
[zen-stable.git] / drivers / scsi / qla2xxx / qla_mbx.c
blob08f1d01bdc1c7a8650682e8ea8fd63803e156e86
1 /*
2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2011 QLogic Corporation
4 *
5 * See LICENSE.qla2xxx for copyright and licensing details.
6 */
7 #include "qla_def.h"
8
9 #include <linux/delay.h>
10 #include <linux/gfp.h>
11
12
13 /*
14 * qla2x00_mailbox_command
15 * Issue mailbox command and waits for completion.
16 *
17 * Input:
18 * ha = adapter block pointer.
19 * mcp = driver internal mbx struct pointer.
20 *
21 * Output:
22 * mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
23 *
24 * Returns:
25 * 0 : QLA_SUCCESS = cmd performed success
26 * 1 : QLA_FUNCTION_FAILED (error encountered)
27 * 6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
28 *
29 * Context:
30 * Kernel context.
31 */
32 static int
33 qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
34 {
35 int rval;
36 unsigned long flags = 0;
37 device_reg_t __iomem *reg;
38 uint8_t abort_active;
39 uint8_t io_lock_on;
40 uint16_t command = 0;
41 uint16_t *iptr;
42 uint16_t __iomem *optr;
43 uint32_t cnt;
44 uint32_t mboxes;
45 unsigned long wait_time;
46 struct qla_hw_data *ha = vha->hw;
47 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
48
49 ql_dbg(ql_dbg_mbx, base_vha, 0x1000, "Entered %s.\n", __func__);
50
51 if (ha->pdev->error_state > pci_channel_io_frozen) {
52 ql_log(ql_log_warn, base_vha, 0x1001,
53 "error_state is greater than pci_channel_io_frozen, "
54 "exiting.\n");
55 return QLA_FUNCTION_TIMEOUT;
56 }
57
58 if (vha->device_flags & DFLG_DEV_FAILED) {
59 ql_log(ql_log_warn, base_vha, 0x1002,
60 "Device in failed state, exiting.\n");
61 return QLA_FUNCTION_TIMEOUT;
62 }
63
64 reg = ha->iobase;
65 io_lock_on = base_vha->flags.init_done;
66
67 rval = QLA_SUCCESS;
68 abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
69
70
71 if (ha->flags.pci_channel_io_perm_failure) {
72 ql_log(ql_log_warn, base_vha, 0x1003,
73 "Perm failure on EEH timeout MBX, exiting.\n");
74 return QLA_FUNCTION_TIMEOUT;
75 }
76
77 if (ha->flags.isp82xx_fw_hung) {
78 /* Setting Link-Down error */
79 mcp->mb[0] = MBS_LINK_DOWN_ERROR;
80 ql_log(ql_log_warn, base_vha, 0x1004,
81 "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
82 return QLA_FUNCTION_TIMEOUT;
83 }
84
85 /*
86 * Wait for active mailbox commands to finish by waiting at most tov
87 * seconds. This is to serialize actual issuing of mailbox cmds during
88 * non ISP abort time.
89 */
90 if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
91 /* Timeout occurred. Return error. */
92 ql_log(ql_log_warn, base_vha, 0x1005,
93 "Cmd access timeout, Exiting.\n");
94 return QLA_FUNCTION_TIMEOUT;
95 }
96
97 ha->flags.mbox_busy = 1;
98 /* Save mailbox command for debug */
99 ha->mcp = mcp;
100
101 ql_dbg(ql_dbg_mbx, base_vha, 0x1006,
102 "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
103
104 spin_lock_irqsave(&ha->hardware_lock, flags);
105
106 /* Load mailbox registers. */
107 if (IS_QLA82XX(ha))
108 optr = (uint16_t __iomem *)&reg->isp82.mailbox_in[0];
109 else if (IS_FWI2_CAPABLE(ha) && !IS_QLA82XX(ha))
110 optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
111 else
112 optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
113
114 iptr = mcp->mb;
115 command = mcp->mb[0];
116 mboxes = mcp->out_mb;
117
118 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
119 if (IS_QLA2200(ha) && cnt == 8)
120 optr =
121 (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 8);
122 if (mboxes & BIT_0)
123 WRT_REG_WORD(optr, *iptr);
124
125 mboxes >>= 1;
126 optr++;
127 iptr++;
128 }
129
130 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1111,
131 "Loaded MBX registers (displayed in bytes) =.\n");
132 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1112,
133 (uint8_t *)mcp->mb, 16);
134 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1113,
135 ".\n");
136 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1114,
137 ((uint8_t *)mcp->mb + 0x10), 16);
138 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1115,
139 ".\n");
140 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1116,
141 ((uint8_t *)mcp->mb + 0x20), 8);
142 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1117,
143 "I/O Address = %p.\n", optr);
144 ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x100e);
145
146 /* Issue set host interrupt command to send cmd out. */
147 ha->flags.mbox_int = 0;
148 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
149
150 /* Unlock mbx registers and wait for interrupt */
151 ql_dbg(ql_dbg_mbx, base_vha, 0x100f,
152 "Going to unlock irq & waiting for interrupts. "
153 "jiffies=%lx.\n", jiffies);
154
155 /* Wait for mbx cmd completion until timeout */
156
157 if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
158 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
159
160 if (IS_QLA82XX(ha)) {
161 if (RD_REG_DWORD(&reg->isp82.hint) &
162 HINT_MBX_INT_PENDING) {
163 spin_unlock_irqrestore(&ha->hardware_lock,
164 flags);
165 ha->flags.mbox_busy = 0;
166 ql_dbg(ql_dbg_mbx, base_vha, 0x1010,
167 "Pending mailbox timeout, exiting.\n");
168 rval = QLA_FUNCTION_TIMEOUT;
169 goto premature_exit;
170 }
171 WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
172 } else if (IS_FWI2_CAPABLE(ha))
173 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
174 else
175 WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
176 spin_unlock_irqrestore(&ha->hardware_lock, flags);
177
178 wait_for_completion_timeout(&ha->mbx_intr_comp, mcp->tov * HZ);
179
180 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
181
182 } else {
183 ql_dbg(ql_dbg_mbx, base_vha, 0x1011,
184 "Cmd=%x Polling Mode.\n", command);
185
186 if (IS_QLA82XX(ha)) {
187 if (RD_REG_DWORD(&reg->isp82.hint) &
188 HINT_MBX_INT_PENDING) {
189 spin_unlock_irqrestore(&ha->hardware_lock,
190 flags);
191 ha->flags.mbox_busy = 0;
192 ql_dbg(ql_dbg_mbx, base_vha, 0x1012,
193 "Pending mailbox timeout, exiting.\n");
194 rval = QLA_FUNCTION_TIMEOUT;
195 goto premature_exit;
196 }
197 WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
198 } else if (IS_FWI2_CAPABLE(ha))
199 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
200 else
201 WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
202 spin_unlock_irqrestore(&ha->hardware_lock, flags);
203
204 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
205 while (!ha->flags.mbox_int) {
206 if (time_after(jiffies, wait_time))
207 break;
208
209 /* Check for pending interrupts. */
210 qla2x00_poll(ha->rsp_q_map[0]);
211
212 if (!ha->flags.mbox_int &&
213 !(IS_QLA2200(ha) &&
214 command == MBC_LOAD_RISC_RAM_EXTENDED))
215 msleep(10);
216 } /* while */
217 ql_dbg(ql_dbg_mbx, base_vha, 0x1013,
218 "Waited %d sec.\n",
219 (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
220 }
221
222 /* Check whether we timed out */
223 if (ha->flags.mbox_int) {
224 uint16_t *iptr2;
225
226 ql_dbg(ql_dbg_mbx, base_vha, 0x1014,
227 "Cmd=%x completed.\n", command);
228
229 /* Got interrupt. Clear the flag. */
230 ha->flags.mbox_int = 0;
231 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
232
233 if (ha->flags.isp82xx_fw_hung) {
234 ha->flags.mbox_busy = 0;
235 /* Setting Link-Down error */
236 mcp->mb[0] = MBS_LINK_DOWN_ERROR;
237 ha->mcp = NULL;
238 rval = QLA_FUNCTION_FAILED;
239 ql_log(ql_log_warn, base_vha, 0x1015,
240 "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
241 goto premature_exit;
242 }
243
244 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
245 rval = QLA_FUNCTION_FAILED;
246
247 /* Load return mailbox registers. */
248 iptr2 = mcp->mb;
249 iptr = (uint16_t *)&ha->mailbox_out[0];
250 mboxes = mcp->in_mb;
251 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
252 if (mboxes & BIT_0)
253 *iptr2 = *iptr;
254
255 mboxes >>= 1;
256 iptr2++;
257 iptr++;
258 }
259 } else {
260
261 uint16_t mb0;
262 uint32_t ictrl;
263
264 if (IS_FWI2_CAPABLE(ha)) {
265 mb0 = RD_REG_WORD(&reg->isp24.mailbox0);
266 ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
267 } else {
268 mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
269 ictrl = RD_REG_WORD(&reg->isp.ictrl);
270 }
271 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1119,
272 "MBX Command timeout for cmd %x.\n", command);
273 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111a,
274 "iocontrol=%x jiffies=%lx.\n", ictrl, jiffies);
275 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111b,
276 "mb[0] = 0x%x.\n", mb0);
277 ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1019);
278
279 rval = QLA_FUNCTION_TIMEOUT;
280 }
281
282 ha->flags.mbox_busy = 0;
283
284 /* Clean up */
285 ha->mcp = NULL;
286
287 if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
288 ql_dbg(ql_dbg_mbx, base_vha, 0x101a,
289 "Checking for additional resp interrupt.\n");
290
291 /* polling mode for non isp_abort commands. */
292 qla2x00_poll(ha->rsp_q_map[0]);
293 }
294
295 if (rval == QLA_FUNCTION_TIMEOUT &&
296 mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
297 if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
298 ha->flags.eeh_busy) {
299 /* not in dpc. schedule it for dpc to take over. */
300 ql_dbg(ql_dbg_mbx, base_vha, 0x101b,
301 "Timeout, schedule isp_abort_needed.\n");
302
303 if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
304 !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
305 !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
306 if (IS_QLA82XX(ha)) {
307 ql_dbg(ql_dbg_mbx, vha, 0x112a,
308 "disabling pause transmit on port "
309 "0 & 1.\n");
310 qla82xx_wr_32(ha,
311 QLA82XX_CRB_NIU + 0x98,
312 CRB_NIU_XG_PAUSE_CTL_P0|
313 CRB_NIU_XG_PAUSE_CTL_P1);
314 }
315 ql_log(ql_log_info, base_vha, 0x101c,
316 "Mailbox cmd timeout occured. "
317 "Scheduling ISP abort eeh_busy=0x%x.\n",
318 ha->flags.eeh_busy);
319 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
320 qla2xxx_wake_dpc(vha);
321 }
322 } else if (!abort_active) {
323 /* call abort directly since we are in the DPC thread */
324 ql_dbg(ql_dbg_mbx, base_vha, 0x101d,
325 "Timeout, calling abort_isp.\n");
326
327 if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
328 !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
329 !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
330 if (IS_QLA82XX(ha)) {
331 ql_dbg(ql_dbg_mbx, vha, 0x112b,
332 "disabling pause transmit on port "
333 "0 & 1.\n");
334 qla82xx_wr_32(ha,
335 QLA82XX_CRB_NIU + 0x98,
336 CRB_NIU_XG_PAUSE_CTL_P0|
337 CRB_NIU_XG_PAUSE_CTL_P1);
338 }
339 ql_log(ql_log_info, base_vha, 0x101e,
340 "Mailbox cmd timeout occured. "
341 "Scheduling ISP abort.\n");
342
343 set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
344 clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
345 /* Allow next mbx cmd to come in. */
346 complete(&ha->mbx_cmd_comp);
347 if (ha->isp_ops->abort_isp(vha)) {
348 /* Failed. retry later. */
349 set_bit(ISP_ABORT_NEEDED,
350 &vha->dpc_flags);
351 }
352 clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
353 ql_dbg(ql_dbg_mbx, base_vha, 0x101f,
354 "Finished abort_isp.\n");
355 goto mbx_done;
356 }
357 }
358 }
359
360 premature_exit:
361 /* Allow next mbx cmd to come in. */
362 complete(&ha->mbx_cmd_comp);
363
364 mbx_done:
365 if (rval) {
366 ql_dbg(ql_dbg_mbx, base_vha, 0x1020,
367 "**** Failed mbx[0]=%x, mb[1]=%x, mb[2]=%x, cmd=%x ****.\n",
368 mcp->mb[0], mcp->mb[1], mcp->mb[2], command);
369 } else {
370 ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
371 }
372
373 return rval;
374 }
375
376 int
377 qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
378 uint32_t risc_code_size)
379 {
380 int rval;
381 struct qla_hw_data *ha = vha->hw;
382 mbx_cmd_t mc;
383 mbx_cmd_t *mcp = &mc;
384
385 ql_dbg(ql_dbg_mbx, vha, 0x1022, "Entered %s.\n", __func__);
386
387 if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
388 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
389 mcp->mb[8] = MSW(risc_addr);
390 mcp->out_mb = MBX_8|MBX_0;
391 } else {
392 mcp->mb[0] = MBC_LOAD_RISC_RAM;
393 mcp->out_mb = MBX_0;
394 }
395 mcp->mb[1] = LSW(risc_addr);
396 mcp->mb[2] = MSW(req_dma);
397 mcp->mb[3] = LSW(req_dma);
398 mcp->mb[6] = MSW(MSD(req_dma));
399 mcp->mb[7] = LSW(MSD(req_dma));
400 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
401 if (IS_FWI2_CAPABLE(ha)) {
402 mcp->mb[4] = MSW(risc_code_size);
403 mcp->mb[5] = LSW(risc_code_size);
404 mcp->out_mb |= MBX_5|MBX_4;
405 } else {
406 mcp->mb[4] = LSW(risc_code_size);
407 mcp->out_mb |= MBX_4;
408 }
409
410 mcp->in_mb = MBX_0;
411 mcp->tov = MBX_TOV_SECONDS;
412 mcp->flags = 0;
413 rval = qla2x00_mailbox_command(vha, mcp);
414
415 if (rval != QLA_SUCCESS) {
416 ql_dbg(ql_dbg_mbx, vha, 0x1023,
417 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
418 } else {
419 ql_dbg(ql_dbg_mbx, vha, 0x1024, "Done %s.\n", __func__);
420 }
421
422 return rval;
423 }
424
425 #define EXTENDED_BB_CREDITS BIT_0
426 /*
427 * qla2x00_execute_fw
428 * Start adapter firmware.
429 *
430 * Input:
431 * ha = adapter block pointer.
432 * TARGET_QUEUE_LOCK must be released.
433 * ADAPTER_STATE_LOCK must be released.
434 *
435 * Returns:
436 * qla2x00 local function return status code.
437 *
438 * Context:
439 * Kernel context.
440 */
441 int
442 qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
443 {
444 int rval;
445 struct qla_hw_data *ha = vha->hw;
446 mbx_cmd_t mc;
447 mbx_cmd_t *mcp = &mc;
448
449 ql_dbg(ql_dbg_mbx, vha, 0x1025, "Entered %s.\n", __func__);
450
451 mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
452 mcp->out_mb = MBX_0;
453 mcp->in_mb = MBX_0;
454 if (IS_FWI2_CAPABLE(ha)) {
455 mcp->mb[1] = MSW(risc_addr);
456 mcp->mb[2] = LSW(risc_addr);
457 mcp->mb[3] = 0;
458 if (IS_QLA81XX(ha)) {
459 struct nvram_81xx *nv = ha->nvram;
460 mcp->mb[4] = (nv->enhanced_features &
461 EXTENDED_BB_CREDITS);
462 } else
463 mcp->mb[4] = 0;
464 mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
465 mcp->in_mb |= MBX_1;
466 } else {
467 mcp->mb[1] = LSW(risc_addr);
468 mcp->out_mb |= MBX_1;
469 if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
470 mcp->mb[2] = 0;
471 mcp->out_mb |= MBX_2;
472 }
473 }
474
475 mcp->tov = MBX_TOV_SECONDS;
476 mcp->flags = 0;
477 rval = qla2x00_mailbox_command(vha, mcp);
478
479 if (rval != QLA_SUCCESS) {
480 ql_dbg(ql_dbg_mbx, vha, 0x1026,
481 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
482 } else {
483 if (IS_FWI2_CAPABLE(ha)) {
484 ql_dbg(ql_dbg_mbx, vha, 0x1027,
485 "Done exchanges=%x.\n", mcp->mb[1]);
486 } else {
487 ql_dbg(ql_dbg_mbx, vha, 0x1028, "Done %s.\n", __func__);
488 }
489 }
490
491 return rval;
492 }
493
494 /*
495 * qla2x00_get_fw_version
496 * Get firmware version.
497 *
498 * Input:
499 * ha: adapter state pointer.
500 * major: pointer for major number.
501 * minor: pointer for minor number.
502 * subminor: pointer for subminor number.
503 *
504 * Returns:
505 * qla2x00 local function return status code.
506 *
507 * Context:
508 * Kernel context.
509 */
510 int
511 qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
512 uint16_t *subminor, uint16_t *attributes, uint32_t *memory, uint8_t *mpi,
513 uint32_t *mpi_caps, uint8_t *phy)
514 {
515 int rval;
516 mbx_cmd_t mc;
517 mbx_cmd_t *mcp = &mc;
518
519 ql_dbg(ql_dbg_mbx, vha, 0x1029, "Entered %s.\n", __func__);
520
521 mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
522 mcp->out_mb = MBX_0;
523 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
524 if (IS_QLA81XX(vha->hw))
525 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
526 mcp->flags = 0;
527 mcp->tov = MBX_TOV_SECONDS;
528 rval = qla2x00_mailbox_command(vha, mcp);
529 if (rval != QLA_SUCCESS)
530 goto failed;
531
532 /* Return mailbox data. */
533 *major = mcp->mb[1];
534 *minor = mcp->mb[2];
535 *subminor = mcp->mb[3];
536 *attributes = mcp->mb[6];
537 if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
538 *memory = 0x1FFFF; /* Defaults to 128KB. */
539 else
540 *memory = (mcp->mb[5] << 16) | mcp->mb[4];
541 if (IS_QLA81XX(vha->hw)) {
542 mpi[0] = mcp->mb[10] & 0xff;
543 mpi[1] = mcp->mb[11] >> 8;
544 mpi[2] = mcp->mb[11] & 0xff;
545 *mpi_caps = (mcp->mb[12] << 16) | mcp->mb[13];
546 phy[0] = mcp->mb[8] & 0xff;
547 phy[1] = mcp->mb[9] >> 8;
548 phy[2] = mcp->mb[9] & 0xff;
549 }
550 failed:
551 if (rval != QLA_SUCCESS) {
552 /*EMPTY*/
553 ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
554 } else {
555 /*EMPTY*/
556 ql_dbg(ql_dbg_mbx, vha, 0x102b, "Done %s.\n", __func__);
557 }
558 return rval;
559 }
560
561 /*
562 * qla2x00_get_fw_options
563 * Set firmware options.
564 *
565 * Input:
566 * ha = adapter block pointer.
567 * fwopt = pointer for firmware options.
568 *
569 * Returns:
570 * qla2x00 local function return status code.
571 *
572 * Context:
573 * Kernel context.
574 */
575 int
576 qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
577 {
578 int rval;
579 mbx_cmd_t mc;
580 mbx_cmd_t *mcp = &mc;
581
582 ql_dbg(ql_dbg_mbx, vha, 0x102c, "Entered %s.\n", __func__);
583
584 mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
585 mcp->out_mb = MBX_0;
586 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
587 mcp->tov = MBX_TOV_SECONDS;
588 mcp->flags = 0;
589 rval = qla2x00_mailbox_command(vha, mcp);
590
591 if (rval != QLA_SUCCESS) {
592 /*EMPTY*/
593 ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
594 } else {
595 fwopts[0] = mcp->mb[0];
596 fwopts[1] = mcp->mb[1];
597 fwopts[2] = mcp->mb[2];
598 fwopts[3] = mcp->mb[3];
599
600 ql_dbg(ql_dbg_mbx, vha, 0x102e, "Done %s.\n", __func__);
601 }
602
603 return rval;
604 }
605
606
607 /*
608 * qla2x00_set_fw_options
609 * Set firmware options.
610 *
611 * Input:
612 * ha = adapter block pointer.
613 * fwopt = pointer for firmware options.
614 *
615 * Returns:
616 * qla2x00 local function return status code.
617 *
618 * Context:
619 * Kernel context.
620 */
621 int
622 qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
623 {
624 int rval;
625 mbx_cmd_t mc;
626 mbx_cmd_t *mcp = &mc;
627
628 ql_dbg(ql_dbg_mbx, vha, 0x102f, "Entered %s.\n", __func__);
629
630 mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
631 mcp->mb[1] = fwopts[1];
632 mcp->mb[2] = fwopts[2];
633 mcp->mb[3] = fwopts[3];
634 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
635 mcp->in_mb = MBX_0;
636 if (IS_FWI2_CAPABLE(vha->hw)) {
637 mcp->in_mb |= MBX_1;
638 } else {
639 mcp->mb[10] = fwopts[10];
640 mcp->mb[11] = fwopts[11];
641 mcp->mb[12] = 0; /* Undocumented, but used */
642 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
643 }
644 mcp->tov = MBX_TOV_SECONDS;
645 mcp->flags = 0;
646 rval = qla2x00_mailbox_command(vha, mcp);
647
648 fwopts[0] = mcp->mb[0];
649
650 if (rval != QLA_SUCCESS) {
651 /*EMPTY*/
652 ql_dbg(ql_dbg_mbx, vha, 0x1030,
653 "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
654 } else {
655 /*EMPTY*/
656 ql_dbg(ql_dbg_mbx, vha, 0x1031, "Done %s.\n", __func__);
657 }
658
659 return rval;
660 }
661
662 /*
663 * qla2x00_mbx_reg_test
664 * Mailbox register wrap test.
665 *
666 * Input:
667 * ha = adapter block pointer.
668 * TARGET_QUEUE_LOCK must be released.
669 * ADAPTER_STATE_LOCK must be released.
670 *
671 * Returns:
672 * qla2x00 local function return status code.
673 *
674 * Context:
675 * Kernel context.
676 */
677 int
678 qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
679 {
680 int rval;
681 mbx_cmd_t mc;
682 mbx_cmd_t *mcp = &mc;
683
684 ql_dbg(ql_dbg_mbx, vha, 0x1032, "Entered %s.\n", __func__);
685
686 mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
687 mcp->mb[1] = 0xAAAA;
688 mcp->mb[2] = 0x5555;
689 mcp->mb[3] = 0xAA55;
690 mcp->mb[4] = 0x55AA;
691 mcp->mb[5] = 0xA5A5;
692 mcp->mb[6] = 0x5A5A;
693 mcp->mb[7] = 0x2525;
694 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
695 mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
696 mcp->tov = MBX_TOV_SECONDS;
697 mcp->flags = 0;
698 rval = qla2x00_mailbox_command(vha, mcp);
699
700 if (rval == QLA_SUCCESS) {
701 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
702 mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
703 rval = QLA_FUNCTION_FAILED;
704 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
705 mcp->mb[7] != 0x2525)
706 rval = QLA_FUNCTION_FAILED;
707 }
708
709 if (rval != QLA_SUCCESS) {
710 /*EMPTY*/
711 ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
712 } else {
713 /*EMPTY*/
714 ql_dbg(ql_dbg_mbx, vha, 0x1034, "Done %s.\n", __func__);
715 }
716
717 return rval;
718 }
719
720 /*
721 * qla2x00_verify_checksum
722 * Verify firmware checksum.
723 *
724 * Input:
725 * ha = adapter block pointer.
726 * TARGET_QUEUE_LOCK must be released.
727 * ADAPTER_STATE_LOCK must be released.
728 *
729 * Returns:
730 * qla2x00 local function return status code.
731 *
732 * Context:
733 * Kernel context.
734 */
735 int
736 qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
737 {
738 int rval;
739 mbx_cmd_t mc;
740 mbx_cmd_t *mcp = &mc;
741
742 ql_dbg(ql_dbg_mbx, vha, 0x1035, "Entered %s.\n", __func__);
743
744 mcp->mb[0] = MBC_VERIFY_CHECKSUM;
745 mcp->out_mb = MBX_0;
746 mcp->in_mb = MBX_0;
747 if (IS_FWI2_CAPABLE(vha->hw)) {
748 mcp->mb[1] = MSW(risc_addr);
749 mcp->mb[2] = LSW(risc_addr);
750 mcp->out_mb |= MBX_2|MBX_1;
751 mcp->in_mb |= MBX_2|MBX_1;
752 } else {
753 mcp->mb[1] = LSW(risc_addr);
754 mcp->out_mb |= MBX_1;
755 mcp->in_mb |= MBX_1;
756 }
757
758 mcp->tov = MBX_TOV_SECONDS;
759 mcp->flags = 0;
760 rval = qla2x00_mailbox_command(vha, mcp);
761
762 if (rval != QLA_SUCCESS) {
763 ql_dbg(ql_dbg_mbx, vha, 0x1036,
764 "Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
765 (mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
766 } else {
767 ql_dbg(ql_dbg_mbx, vha, 0x1037, "Done %s.\n", __func__);
768 }
769
770 return rval;
771 }
772
773 /*
774 * qla2x00_issue_iocb
775 * Issue IOCB using mailbox command
776 *
777 * Input:
778 * ha = adapter state pointer.
779 * buffer = buffer pointer.
780 * phys_addr = physical address of buffer.
781 * size = size of buffer.
782 * TARGET_QUEUE_LOCK must be released.
783 * ADAPTER_STATE_LOCK must be released.
784 *
785 * Returns:
786 * qla2x00 local function return status code.
787 *
788 * Context:
789 * Kernel context.
790 */
791 int
792 qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
793 dma_addr_t phys_addr, size_t size, uint32_t tov)
794 {
795 int rval;
796 mbx_cmd_t mc;
797 mbx_cmd_t *mcp = &mc;
798
799 ql_dbg(ql_dbg_mbx, vha, 0x1038, "Entered %s.\n", __func__);
800
801 mcp->mb[0] = MBC_IOCB_COMMAND_A64;
802 mcp->mb[1] = 0;
803 mcp->mb[2] = MSW(phys_addr);
804 mcp->mb[3] = LSW(phys_addr);
805 mcp->mb[6] = MSW(MSD(phys_addr));
806 mcp->mb[7] = LSW(MSD(phys_addr));
807 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
808 mcp->in_mb = MBX_2|MBX_0;
809 mcp->tov = tov;
810 mcp->flags = 0;
811 rval = qla2x00_mailbox_command(vha, mcp);
812
813 if (rval != QLA_SUCCESS) {
814 /*EMPTY*/
815 ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
816 } else {
817 sts_entry_t *sts_entry = (sts_entry_t *) buffer;
818
819 /* Mask reserved bits. */
820 sts_entry->entry_status &=
821 IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
822 ql_dbg(ql_dbg_mbx, vha, 0x103a, "Done %s.\n", __func__);
823 }
824
825 return rval;
826 }
827
828 int
829 qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
830 size_t size)
831 {
832 return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
833 MBX_TOV_SECONDS);
834 }
835
836 /*
837 * qla2x00_abort_command
838 * Abort command aborts a specified IOCB.
839 *
840 * Input:
841 * ha = adapter block pointer.
842 * sp = SB structure pointer.
843 *
844 * Returns:
845 * qla2x00 local function return status code.
846 *
847 * Context:
848 * Kernel context.
849 */
850 int
851 qla2x00_abort_command(srb_t *sp)
852 {
853 unsigned long flags = 0;
854 int rval;
855 uint32_t handle = 0;
856 mbx_cmd_t mc;
857 mbx_cmd_t *mcp = &mc;
858 fc_port_t *fcport = sp->fcport;
859 scsi_qla_host_t *vha = fcport->vha;
860 struct qla_hw_data *ha = vha->hw;
861 struct req_que *req = vha->req;
862
863 ql_dbg(ql_dbg_mbx, vha, 0x103b, "Entered %s.\n", __func__);
864
865 spin_lock_irqsave(&ha->hardware_lock, flags);
866 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
867 if (req->outstanding_cmds[handle] == sp)
868 break;
869 }
870 spin_unlock_irqrestore(&ha->hardware_lock, flags);
871
872 if (handle == MAX_OUTSTANDING_COMMANDS) {
873 /* command not found */
874 return QLA_FUNCTION_FAILED;
875 }
876
877 mcp->mb[0] = MBC_ABORT_COMMAND;
878 if (HAS_EXTENDED_IDS(ha))
879 mcp->mb[1] = fcport->loop_id;
880 else
881 mcp->mb[1] = fcport->loop_id << 8;
882 mcp->mb[2] = (uint16_t)handle;
883 mcp->mb[3] = (uint16_t)(handle >> 16);
884 mcp->mb[6] = (uint16_t)sp->cmd->device->lun;
885 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
886 mcp->in_mb = MBX_0;
887 mcp->tov = MBX_TOV_SECONDS;
888 mcp->flags = 0;
889 rval = qla2x00_mailbox_command(vha, mcp);
890
891 if (rval != QLA_SUCCESS) {
892 ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
893 } else {
894 ql_dbg(ql_dbg_mbx, vha, 0x103d, "Done %s.\n", __func__);
895 }
896
897 return rval;
898 }
899
900 int
901 qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
902 {
903 int rval, rval2;
904 mbx_cmd_t mc;
905 mbx_cmd_t *mcp = &mc;
906 scsi_qla_host_t *vha;
907 struct req_que *req;
908 struct rsp_que *rsp;
909
910 l = l;
911 vha = fcport->vha;
912
913 ql_dbg(ql_dbg_mbx, vha, 0x103e, "Entered %s.\n", __func__);
914
915 req = vha->hw->req_q_map[0];
916 rsp = req->rsp;
917 mcp->mb[0] = MBC_ABORT_TARGET;
918 mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
919 if (HAS_EXTENDED_IDS(vha->hw)) {
920 mcp->mb[1] = fcport->loop_id;
921 mcp->mb[10] = 0;
922 mcp->out_mb |= MBX_10;
923 } else {
924 mcp->mb[1] = fcport->loop_id << 8;
925 }
926 mcp->mb[2] = vha->hw->loop_reset_delay;
927 mcp->mb[9] = vha->vp_idx;
928
929 mcp->in_mb = MBX_0;
930 mcp->tov = MBX_TOV_SECONDS;
931 mcp->flags = 0;
932 rval = qla2x00_mailbox_command(vha, mcp);
933 if (rval != QLA_SUCCESS) {
934 ql_dbg(ql_dbg_mbx, vha, 0x103f, "Failed=%x.\n", rval);
935 }
936
937 /* Issue marker IOCB. */
938 rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
939 MK_SYNC_ID);
940 if (rval2 != QLA_SUCCESS) {
941 ql_dbg(ql_dbg_mbx, vha, 0x1040,
942 "Failed to issue marker IOCB (%x).\n", rval2);
943 } else {
944 ql_dbg(ql_dbg_mbx, vha, 0x1041, "Done %s.\n", __func__);
945 }
946
947 return rval;
948 }
949
950 int
951 qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
952 {
953 int rval, rval2;
954 mbx_cmd_t mc;
955 mbx_cmd_t *mcp = &mc;
956 scsi_qla_host_t *vha;
957 struct req_que *req;
958 struct rsp_que *rsp;
959
960 vha = fcport->vha;
961
962 ql_dbg(ql_dbg_mbx, vha, 0x1042, "Entered %s.\n", __func__);
963
964 req = vha->hw->req_q_map[0];
965 rsp = req->rsp;
966 mcp->mb[0] = MBC_LUN_RESET;
967 mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
968 if (HAS_EXTENDED_IDS(vha->hw))
969 mcp->mb[1] = fcport->loop_id;
970 else
971 mcp->mb[1] = fcport->loop_id << 8;
972 mcp->mb[2] = l;
973 mcp->mb[3] = 0;
974 mcp->mb[9] = vha->vp_idx;
975
976 mcp->in_mb = MBX_0;
977 mcp->tov = MBX_TOV_SECONDS;
978 mcp->flags = 0;
979 rval = qla2x00_mailbox_command(vha, mcp);
980 if (rval != QLA_SUCCESS) {
981 ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
982 }
983
984 /* Issue marker IOCB. */
985 rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
986 MK_SYNC_ID_LUN);
987 if (rval2 != QLA_SUCCESS) {
988 ql_dbg(ql_dbg_mbx, vha, 0x1044,
989 "Failed to issue marker IOCB (%x).\n", rval2);
990 } else {
991 ql_dbg(ql_dbg_mbx, vha, 0x1045, "Done %s.\n", __func__);
992 }
993
994 return rval;
995 }
996
997 /*
998 * qla2x00_get_adapter_id
999 * Get adapter ID and topology.
1000 *
1001 * Input:
1002 * ha = adapter block pointer.
1003 * id = pointer for loop ID.
1004 * al_pa = pointer for AL_PA.
1005 * area = pointer for area.
1006 * domain = pointer for domain.
1007 * top = pointer for topology.
1008 * TARGET_QUEUE_LOCK must be released.
1009 * ADAPTER_STATE_LOCK must be released.
1010 *
1011 * Returns:
1012 * qla2x00 local function return status code.
1013 *
1014 * Context:
1015 * Kernel context.
1016 */
1017 int
1018 qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
1019 uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
1020 {
1021 int rval;
1022 mbx_cmd_t mc;
1023 mbx_cmd_t *mcp = &mc;
1024
1025 ql_dbg(ql_dbg_mbx, vha, 0x1046, "Entered %s.\n", __func__);
1026
1027 mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
1028 mcp->mb[9] = vha->vp_idx;
1029 mcp->out_mb = MBX_9|MBX_0;
1030 mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1031 if (IS_QLA8XXX_TYPE(vha->hw))
1032 mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
1033 mcp->tov = MBX_TOV_SECONDS;
1034 mcp->flags = 0;
1035 rval = qla2x00_mailbox_command(vha, mcp);
1036 if (mcp->mb[0] == MBS_COMMAND_ERROR)
1037 rval = QLA_COMMAND_ERROR;
1038 else if (mcp->mb[0] == MBS_INVALID_COMMAND)
1039 rval = QLA_INVALID_COMMAND;
1040
1041 /* Return data. */
1042 *id = mcp->mb[1];
1043 *al_pa = LSB(mcp->mb[2]);
1044 *area = MSB(mcp->mb[2]);
1045 *domain = LSB(mcp->mb[3]);
1046 *top = mcp->mb[6];
1047 *sw_cap = mcp->mb[7];
1048
1049 if (rval != QLA_SUCCESS) {
1050 /*EMPTY*/
1051 ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
1052 } else {
1053 ql_dbg(ql_dbg_mbx, vha, 0x1048, "Done %s.\n", __func__);
1054
1055 if (IS_QLA8XXX_TYPE(vha->hw)) {
1056 vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
1057 vha->fcoe_fcf_idx = mcp->mb[10];
1058 vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
1059 vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
1060 vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
1061 vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
1062 vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
1063 vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
1064 }
1065 }
1066
1067 return rval;
1068 }
1069
1070 /*
1071 * qla2x00_get_retry_cnt
1072 * Get current firmware login retry count and delay.
1073 *
1074 * Input:
1075 * ha = adapter block pointer.
1076 * retry_cnt = pointer to login retry count.
1077 * tov = pointer to login timeout value.
1078 *
1079 * Returns:
1080 * qla2x00 local function return status code.
1081 *
1082 * Context:
1083 * Kernel context.
1084 */
1085 int
1086 qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
1087 uint16_t *r_a_tov)
1088 {
1089 int rval;
1090 uint16_t ratov;
1091 mbx_cmd_t mc;
1092 mbx_cmd_t *mcp = &mc;
1093
1094 ql_dbg(ql_dbg_mbx, vha, 0x1049, "Entered %s.\n", __func__);
1095
1096 mcp->mb[0] = MBC_GET_RETRY_COUNT;
1097 mcp->out_mb = MBX_0;
1098 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1099 mcp->tov = MBX_TOV_SECONDS;
1100 mcp->flags = 0;
1101 rval = qla2x00_mailbox_command(vha, mcp);
1102
1103 if (rval != QLA_SUCCESS) {
1104 /*EMPTY*/
1105 ql_dbg(ql_dbg_mbx, vha, 0x104a,
1106 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
1107 } else {
1108 /* Convert returned data and check our values. */
1109 *r_a_tov = mcp->mb[3] / 2;
1110 ratov = (mcp->mb[3]/2) / 10; /* mb[3] value is in 100ms */
1111 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
1112 /* Update to the larger values */
1113 *retry_cnt = (uint8_t)mcp->mb[1];
1114 *tov = ratov;
1115 }
1116
1117 ql_dbg(ql_dbg_mbx, vha, 0x104b,
1118 "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
1119 }
1120
1121 return rval;
1122 }
1123
1124 /*
1125 * qla2x00_init_firmware
1126 * Initialize adapter firmware.
1127 *
1128 * Input:
1129 * ha = adapter block pointer.
1130 * dptr = Initialization control block pointer.
1131 * size = size of initialization control block.
1132 * TARGET_QUEUE_LOCK must be released.
1133 * ADAPTER_STATE_LOCK must be released.
1134 *
1135 * Returns:
1136 * qla2x00 local function return status code.
1137 *
1138 * Context:
1139 * Kernel context.
1140 */
1141 int
1142 qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
1143 {
1144 int rval;
1145 mbx_cmd_t mc;
1146 mbx_cmd_t *mcp = &mc;
1147 struct qla_hw_data *ha = vha->hw;
1148
1149 ql_dbg(ql_dbg_mbx, vha, 0x104c, "Entered %s.\n", __func__);
1150
1151 if (IS_QLA82XX(ha) && ql2xdbwr)
1152 qla82xx_wr_32(ha, ha->nxdb_wr_ptr,
1153 (0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));
1154
1155 if (ha->flags.npiv_supported)
1156 mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
1157 else
1158 mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1159
1160 mcp->mb[1] = 0;
1161 mcp->mb[2] = MSW(ha->init_cb_dma);
1162 mcp->mb[3] = LSW(ha->init_cb_dma);
1163 mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1164 mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1165 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1166 if (IS_QLA81XX(ha) && ha->ex_init_cb->ex_version) {
1167 mcp->mb[1] = BIT_0;
1168 mcp->mb[10] = MSW(ha->ex_init_cb_dma);
1169 mcp->mb[11] = LSW(ha->ex_init_cb_dma);
1170 mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
1171 mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
1172 mcp->mb[14] = sizeof(*ha->ex_init_cb);
1173 mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
1174 }
1175 mcp->in_mb = MBX_0;
1176 mcp->buf_size = size;
1177 mcp->flags = MBX_DMA_OUT;
1178 mcp->tov = MBX_TOV_SECONDS;
1179 rval = qla2x00_mailbox_command(vha, mcp);
1180
1181 if (rval != QLA_SUCCESS) {
1182 /*EMPTY*/
1183 ql_dbg(ql_dbg_mbx, vha, 0x104d,
1184 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
1185 } else {
1186 /*EMPTY*/
1187 ql_dbg(ql_dbg_mbx, vha, 0x104e, "Done %s.\n", __func__);
1188 }
1189
1190 return rval;
1191 }
1192
1193 /*
1194 * qla2x00_get_port_database
1195 * Issue normal/enhanced get port database mailbox command
1196 * and copy device name as necessary.
1197 *
1198 * Input:
1199 * ha = adapter state pointer.
1200 * dev = structure pointer.
1201 * opt = enhanced cmd option byte.
1202 *
1203 * Returns:
1204 * qla2x00 local function return status code.
1205 *
1206 * Context:
1207 * Kernel context.
1208 */
1209 int
1210 qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
1211 {
1212 int rval;
1213 mbx_cmd_t mc;
1214 mbx_cmd_t *mcp = &mc;
1215 port_database_t *pd;
1216 struct port_database_24xx *pd24;
1217 dma_addr_t pd_dma;
1218 struct qla_hw_data *ha = vha->hw;
1219
1220 ql_dbg(ql_dbg_mbx, vha, 0x104f, "Entered %s.\n", __func__);
1221
1222 pd24 = NULL;
1223 pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1224 if (pd == NULL) {
1225 ql_log(ql_log_warn, vha, 0x1050,
1226 "Failed to allocate port database structure.\n");
1227 return QLA_MEMORY_ALLOC_FAILED;
1228 }
1229 memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
1230
1231 mcp->mb[0] = MBC_GET_PORT_DATABASE;
1232 if (opt != 0 && !IS_FWI2_CAPABLE(ha))
1233 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1234 mcp->mb[2] = MSW(pd_dma);
1235 mcp->mb[3] = LSW(pd_dma);
1236 mcp->mb[6] = MSW(MSD(pd_dma));
1237 mcp->mb[7] = LSW(MSD(pd_dma));
1238 mcp->mb[9] = vha->vp_idx;
1239 mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1240 mcp->in_mb = MBX_0;
1241 if (IS_FWI2_CAPABLE(ha)) {
1242 mcp->mb[1] = fcport->loop_id;
1243 mcp->mb[10] = opt;
1244 mcp->out_mb |= MBX_10|MBX_1;
1245 mcp->in_mb |= MBX_1;
1246 } else if (HAS_EXTENDED_IDS(ha)) {
1247 mcp->mb[1] = fcport->loop_id;
1248 mcp->mb[10] = opt;
1249 mcp->out_mb |= MBX_10|MBX_1;
1250 } else {
1251 mcp->mb[1] = fcport->loop_id << 8 | opt;
1252 mcp->out_mb |= MBX_1;
1253 }
1254 mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
1255 PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
1256 mcp->flags = MBX_DMA_IN;
1257 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1258 rval = qla2x00_mailbox_command(vha, mcp);
1259 if (rval != QLA_SUCCESS)
1260 goto gpd_error_out;
1261
1262 if (IS_FWI2_CAPABLE(ha)) {
1263 pd24 = (struct port_database_24xx *) pd;
1264
1265 /* Check for logged in state. */
1266 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
1267 pd24->last_login_state != PDS_PRLI_COMPLETE) {
1268 ql_dbg(ql_dbg_mbx, vha, 0x1051,
1269 "Unable to verify login-state (%x/%x) for "
1270 "loop_id %x.\n", pd24->current_login_state,
1271 pd24->last_login_state, fcport->loop_id);
1272 rval = QLA_FUNCTION_FAILED;
1273 goto gpd_error_out;
1274 }
1275
1276 /* Names are little-endian. */
1277 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
1278 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
1279
1280 /* Get port_id of device. */
1281 fcport->d_id.b.domain = pd24->port_id[0];
1282 fcport->d_id.b.area = pd24->port_id[1];
1283 fcport->d_id.b.al_pa = pd24->port_id[2];
1284 fcport->d_id.b.rsvd_1 = 0;
1285
1286 /* If not target must be initiator or unknown type. */
1287 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
1288 fcport->port_type = FCT_INITIATOR;
1289 else
1290 fcport->port_type = FCT_TARGET;
1291 } else {
1292 /* Check for logged in state. */
1293 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
1294 pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
1295 ql_dbg(ql_dbg_mbx, vha, 0x100a,
1296 "Unable to verify login-state (%x/%x) - "
1297 "portid=%02x%02x%02x.\n", pd->master_state,
1298 pd->slave_state, fcport->d_id.b.domain,
1299 fcport->d_id.b.area, fcport->d_id.b.al_pa);
1300 rval = QLA_FUNCTION_FAILED;
1301 goto gpd_error_out;
1302 }
1303
1304 /* Names are little-endian. */
1305 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
1306 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
1307
1308 /* Get port_id of device. */
1309 fcport->d_id.b.domain = pd->port_id[0];
1310 fcport->d_id.b.area = pd->port_id[3];
1311 fcport->d_id.b.al_pa = pd->port_id[2];
1312 fcport->d_id.b.rsvd_1 = 0;
1313
1314 /* If not target must be initiator or unknown type. */
1315 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
1316 fcport->port_type = FCT_INITIATOR;
1317 else
1318 fcport->port_type = FCT_TARGET;
1319
1320 /* Passback COS information. */
1321 fcport->supported_classes = (pd->options & BIT_4) ?
1322 FC_COS_CLASS2: FC_COS_CLASS3;
1323 }
1324
1325 gpd_error_out:
1326 dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1327
1328 if (rval != QLA_SUCCESS) {
1329 ql_dbg(ql_dbg_mbx, vha, 0x1052,
1330 "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
1331 mcp->mb[0], mcp->mb[1]);
1332 } else {
1333 ql_dbg(ql_dbg_mbx, vha, 0x1053, "Done %s.\n", __func__);
1334 }
1335
1336 return rval;
1337 }
1338
1339 /*
1340 * qla2x00_get_firmware_state
1341 * Get adapter firmware state.
1342 *
1343 * Input:
1344 * ha = adapter block pointer.
1345 * dptr = pointer for firmware state.
1346 * TARGET_QUEUE_LOCK must be released.
1347 * ADAPTER_STATE_LOCK must be released.
1348 *
1349 * Returns:
1350 * qla2x00 local function return status code.
1351 *
1352 * Context:
1353 * Kernel context.
1354 */
1355 int
1356 qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
1357 {
1358 int rval;
1359 mbx_cmd_t mc;
1360 mbx_cmd_t *mcp = &mc;
1361
1362 ql_dbg(ql_dbg_mbx, vha, 0x1054, "Entered %s.\n", __func__);
1363
1364 mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
1365 mcp->out_mb = MBX_0;
1366 if (IS_FWI2_CAPABLE(vha->hw))
1367 mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
1368 else
1369 mcp->in_mb = MBX_1|MBX_0;
1370 mcp->tov = MBX_TOV_SECONDS;
1371 mcp->flags = 0;
1372 rval = qla2x00_mailbox_command(vha, mcp);
1373
1374 /* Return firmware states. */
1375 states[0] = mcp->mb[1];
1376 if (IS_FWI2_CAPABLE(vha->hw)) {
1377 states[1] = mcp->mb[2];
1378 states[2] = mcp->mb[3];
1379 states[3] = mcp->mb[4];
1380 states[4] = mcp->mb[5];
1381 }
1382
1383 if (rval != QLA_SUCCESS) {
1384 /*EMPTY*/
1385 ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
1386 } else {
1387 /*EMPTY*/
1388 ql_dbg(ql_dbg_mbx, vha, 0x1056, "Done %s.\n", __func__);
1389 }
1390
1391 return rval;
1392 }
1393
1394 /*
1395 * qla2x00_get_port_name
1396 * Issue get port name mailbox command.
1397 * Returned name is in big endian format.
1398 *
1399 * Input:
1400 * ha = adapter block pointer.
1401 * loop_id = loop ID of device.
1402 * name = pointer for name.
1403 * TARGET_QUEUE_LOCK must be released.
1404 * ADAPTER_STATE_LOCK must be released.
1405 *
1406 * Returns:
1407 * qla2x00 local function return status code.
1408 *
1409 * Context:
1410 * Kernel context.
1411 */
1412 int
1413 qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
1414 uint8_t opt)
1415 {
1416 int rval;
1417 mbx_cmd_t mc;
1418 mbx_cmd_t *mcp = &mc;
1419
1420 ql_dbg(ql_dbg_mbx, vha, 0x1057, "Entered %s.\n", __func__);
1421
1422 mcp->mb[0] = MBC_GET_PORT_NAME;
1423 mcp->mb[9] = vha->vp_idx;
1424 mcp->out_mb = MBX_9|MBX_1|MBX_0;
1425 if (HAS_EXTENDED_IDS(vha->hw)) {
1426 mcp->mb[1] = loop_id;
1427 mcp->mb[10] = opt;
1428 mcp->out_mb |= MBX_10;
1429 } else {
1430 mcp->mb[1] = loop_id << 8 | opt;
1431 }
1432
1433 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1434 mcp->tov = MBX_TOV_SECONDS;
1435 mcp->flags = 0;
1436 rval = qla2x00_mailbox_command(vha, mcp);
1437
1438 if (rval != QLA_SUCCESS) {
1439 /*EMPTY*/
1440 ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
1441 } else {
1442 if (name != NULL) {
1443 /* This function returns name in big endian. */
1444 name[0] = MSB(mcp->mb[2]);
1445 name[1] = LSB(mcp->mb[2]);
1446 name[2] = MSB(mcp->mb[3]);
1447 name[3] = LSB(mcp->mb[3]);
1448 name[4] = MSB(mcp->mb[6]);
1449 name[5] = LSB(mcp->mb[6]);
1450 name[6] = MSB(mcp->mb[7]);
1451 name[7] = LSB(mcp->mb[7]);
1452 }
1453
1454 ql_dbg(ql_dbg_mbx, vha, 0x1059, "Done %s.\n", __func__);
1455 }
1456
1457 return rval;
1458 }
1459
1460 /*
1461 * qla2x00_lip_reset
1462 * Issue LIP reset mailbox command.
1463 *
1464 * Input:
1465 * ha = adapter block pointer.
1466 * TARGET_QUEUE_LOCK must be released.
1467 * ADAPTER_STATE_LOCK must be released.
1468 *
1469 * Returns:
1470 * qla2x00 local function return status code.
1471 *
1472 * Context:
1473 * Kernel context.
1474 */
1475 int
1476 qla2x00_lip_reset(scsi_qla_host_t *vha)
1477 {
1478 int rval;
1479 mbx_cmd_t mc;
1480 mbx_cmd_t *mcp = &mc;
1481
1482 ql_dbg(ql_dbg_mbx, vha, 0x105a, "Entered %s.\n", __func__);
1483
1484 if (IS_QLA8XXX_TYPE(vha->hw)) {
1485 /* Logout across all FCFs. */
1486 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1487 mcp->mb[1] = BIT_1;
1488 mcp->mb[2] = 0;
1489 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1490 } else if (IS_FWI2_CAPABLE(vha->hw)) {
1491 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1492 mcp->mb[1] = BIT_6;
1493 mcp->mb[2] = 0;
1494 mcp->mb[3] = vha->hw->loop_reset_delay;
1495 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1496 } else {
1497 mcp->mb[0] = MBC_LIP_RESET;
1498 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1499 if (HAS_EXTENDED_IDS(vha->hw)) {
1500 mcp->mb[1] = 0x00ff;
1501 mcp->mb[10] = 0;
1502 mcp->out_mb |= MBX_10;
1503 } else {
1504 mcp->mb[1] = 0xff00;
1505 }
1506 mcp->mb[2] = vha->hw->loop_reset_delay;
1507 mcp->mb[3] = 0;
1508 }
1509 mcp->in_mb = MBX_0;
1510 mcp->tov = MBX_TOV_SECONDS;
1511 mcp->flags = 0;
1512 rval = qla2x00_mailbox_command(vha, mcp);
1513
1514 if (rval != QLA_SUCCESS) {
1515 /*EMPTY*/
1516 ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
1517 } else {
1518 /*EMPTY*/
1519 ql_dbg(ql_dbg_mbx, vha, 0x105c, "Done %s.\n", __func__);
1520 }
1521
1522 return rval;
1523 }
1524
1525 /*
1526 * qla2x00_send_sns
1527 * Send SNS command.
1528 *
1529 * Input:
1530 * ha = adapter block pointer.
1531 * sns = pointer for command.
1532 * cmd_size = command size.
1533 * buf_size = response/command size.
1534 * TARGET_QUEUE_LOCK must be released.
1535 * ADAPTER_STATE_LOCK must be released.
1536 *
1537 * Returns:
1538 * qla2x00 local function return status code.
1539 *
1540 * Context:
1541 * Kernel context.
1542 */
1543 int
1544 qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
1545 uint16_t cmd_size, size_t buf_size)
1546 {
1547 int rval;
1548 mbx_cmd_t mc;
1549 mbx_cmd_t *mcp = &mc;
1550
1551 ql_dbg(ql_dbg_mbx, vha, 0x105d, "Entered %s.\n", __func__);
1552
1553 ql_dbg(ql_dbg_mbx, vha, 0x105e,
1554 "Retry cnt=%d ratov=%d total tov=%d.\n",
1555 vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);
1556
1557 mcp->mb[0] = MBC_SEND_SNS_COMMAND;
1558 mcp->mb[1] = cmd_size;
1559 mcp->mb[2] = MSW(sns_phys_address);
1560 mcp->mb[3] = LSW(sns_phys_address);
1561 mcp->mb[6] = MSW(MSD(sns_phys_address));
1562 mcp->mb[7] = LSW(MSD(sns_phys_address));
1563 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1564 mcp->in_mb = MBX_0|MBX_1;
1565 mcp->buf_size = buf_size;
1566 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1567 mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
1568 rval = qla2x00_mailbox_command(vha, mcp);
1569
1570 if (rval != QLA_SUCCESS) {
1571 /*EMPTY*/
1572 ql_dbg(ql_dbg_mbx, vha, 0x105f,
1573 "Failed=%x mb[0]=%x mb[1]=%x.\n",
1574 rval, mcp->mb[0], mcp->mb[1]);
1575 } else {
1576 /*EMPTY*/
1577 ql_dbg(ql_dbg_mbx, vha, 0x1060, "Done %s.\n", __func__);
1578 }
1579
1580 return rval;
1581 }
1582
1583 int
1584 qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1585 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1586 {
1587 int rval;
1588
1589 struct logio_entry_24xx *lg;
1590 dma_addr_t lg_dma;
1591 uint32_t iop[2];
1592 struct qla_hw_data *ha = vha->hw;
1593 struct req_que *req;
1594 struct rsp_que *rsp;
1595
1596 ql_dbg(ql_dbg_mbx, vha, 0x1061, "Entered %s.\n", __func__);
1597
1598 if (ha->flags.cpu_affinity_enabled)
1599 req = ha->req_q_map[0];
1600 else
1601 req = vha->req;
1602 rsp = req->rsp;
1603
1604 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1605 if (lg == NULL) {
1606 ql_log(ql_log_warn, vha, 0x1062,
1607 "Failed to allocate login IOCB.\n");
1608 return QLA_MEMORY_ALLOC_FAILED;
1609 }
1610 memset(lg, 0, sizeof(struct logio_entry_24xx));
1611
1612 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1613 lg->entry_count = 1;
1614 lg->handle = MAKE_HANDLE(req->id, lg->handle);
1615 lg->nport_handle = cpu_to_le16(loop_id);
1616 lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
1617 if (opt & BIT_0)
1618 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1619 if (opt & BIT_1)
1620 lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI);
1621 lg->port_id[0] = al_pa;
1622 lg->port_id[1] = area;
1623 lg->port_id[2] = domain;
1624 lg->vp_index = vha->vp_idx;
1625 rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1626 if (rval != QLA_SUCCESS) {
1627 ql_dbg(ql_dbg_mbx, vha, 0x1063,
1628 "Failed to issue login IOCB (%x).\n", rval);
1629 } else if (lg->entry_status != 0) {
1630 ql_dbg(ql_dbg_mbx, vha, 0x1064,
1631 "Failed to complete IOCB -- error status (%x).\n",
1632 lg->entry_status);
1633 rval = QLA_FUNCTION_FAILED;
1634 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1635 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1636 iop[1] = le32_to_cpu(lg->io_parameter[1]);
1637
1638 ql_dbg(ql_dbg_mbx, vha, 0x1065,
1639 "Failed to complete IOCB -- completion status (%x) "
1640 "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
1641 iop[0], iop[1]);
1642
1643 switch (iop[0]) {
1644 case LSC_SCODE_PORTID_USED:
1645 mb[0] = MBS_PORT_ID_USED;
1646 mb[1] = LSW(iop[1]);
1647 break;
1648 case LSC_SCODE_NPORT_USED:
1649 mb[0] = MBS_LOOP_ID_USED;
1650 break;
1651 case LSC_SCODE_NOLINK:
1652 case LSC_SCODE_NOIOCB:
1653 case LSC_SCODE_NOXCB:
1654 case LSC_SCODE_CMD_FAILED:
1655 case LSC_SCODE_NOFABRIC:
1656 case LSC_SCODE_FW_NOT_READY:
1657 case LSC_SCODE_NOT_LOGGED_IN:
1658 case LSC_SCODE_NOPCB:
1659 case LSC_SCODE_ELS_REJECT:
1660 case LSC_SCODE_CMD_PARAM_ERR:
1661 case LSC_SCODE_NONPORT:
1662 case LSC_SCODE_LOGGED_IN:
1663 case LSC_SCODE_NOFLOGI_ACC:
1664 default:
1665 mb[0] = MBS_COMMAND_ERROR;
1666 break;
1667 }
1668 } else {
1669 ql_dbg(ql_dbg_mbx, vha, 0x1066, "Done %s.\n", __func__);
1670
1671 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1672
1673 mb[0] = MBS_COMMAND_COMPLETE;
1674 mb[1] = 0;
1675 if (iop[0] & BIT_4) {
1676 if (iop[0] & BIT_8)
1677 mb[1] |= BIT_1;
1678 } else
1679 mb[1] = BIT_0;
1680
1681 /* Passback COS information. */
1682 mb[10] = 0;
1683 if (lg->io_parameter[7] || lg->io_parameter[8])
1684 mb[10] |= BIT_0; /* Class 2. */
1685 if (lg->io_parameter[9] || lg->io_parameter[10])
1686 mb[10] |= BIT_1; /* Class 3. */
1687 }
1688
1689 dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1690
1691 return rval;
1692 }
1693
1694 /*
1695 * qla2x00_login_fabric
1696 * Issue login fabric port mailbox command.
1697 *
1698 * Input:
1699 * ha = adapter block pointer.
1700 * loop_id = device loop ID.
1701 * domain = device domain.
1702 * area = device area.
1703 * al_pa = device AL_PA.
1704 * status = pointer for return status.
1705 * opt = command options.
1706 * TARGET_QUEUE_LOCK must be released.
1707 * ADAPTER_STATE_LOCK must be released.
1708 *
1709 * Returns:
1710 * qla2x00 local function return status code.
1711 *
1712 * Context:
1713 * Kernel context.
1714 */
1715 int
1716 qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1717 uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1718 {
1719 int rval;
1720 mbx_cmd_t mc;
1721 mbx_cmd_t *mcp = &mc;
1722 struct qla_hw_data *ha = vha->hw;
1723
1724 ql_dbg(ql_dbg_mbx, vha, 0x1067, "Entered %s.\n", __func__);
1725
1726 mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1727 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1728 if (HAS_EXTENDED_IDS(ha)) {
1729 mcp->mb[1] = loop_id;
1730 mcp->mb[10] = opt;
1731 mcp->out_mb |= MBX_10;
1732 } else {
1733 mcp->mb[1] = (loop_id << 8) | opt;
1734 }
1735 mcp->mb[2] = domain;
1736 mcp->mb[3] = area << 8 | al_pa;
1737
1738 mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1739 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1740 mcp->flags = 0;
1741 rval = qla2x00_mailbox_command(vha, mcp);
1742
1743 /* Return mailbox statuses. */
1744 if (mb != NULL) {
1745 mb[0] = mcp->mb[0];
1746 mb[1] = mcp->mb[1];
1747 mb[2] = mcp->mb[2];
1748 mb[6] = mcp->mb[6];
1749 mb[7] = mcp->mb[7];
1750 /* COS retrieved from Get-Port-Database mailbox command. */
1751 mb[10] = 0;
1752 }
1753
1754 if (rval != QLA_SUCCESS) {
1755 /* RLU tmp code: need to change main mailbox_command function to
1756 * return ok even when the mailbox completion value is not
1757 * SUCCESS. The caller needs to be responsible to interpret
1758 * the return values of this mailbox command if we're not
1759 * to change too much of the existing code.
1760 */
1761 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
1762 mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
1763 mcp->mb[0] == 0x4006)
1764 rval = QLA_SUCCESS;
1765
1766 /*EMPTY*/
1767 ql_dbg(ql_dbg_mbx, vha, 0x1068,
1768 "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
1769 rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
1770 } else {
1771 /*EMPTY*/
1772 ql_dbg(ql_dbg_mbx, vha, 0x1069, "Done %s.\n", __func__);
1773 }
1774
1775 return rval;
1776 }
1777
1778 /*
1779 * qla2x00_login_local_device
1780 * Issue login loop port mailbox command.
1781 *
1782 * Input:
1783 * ha = adapter block pointer.
1784 * loop_id = device loop ID.
1785 * opt = command options.
1786 *
1787 * Returns:
1788 * Return status code.
1789 *
1790 * Context:
1791 * Kernel context.
1792 *
1793 */
1794 int
1795 qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
1796 uint16_t *mb_ret, uint8_t opt)
1797 {
1798 int rval;
1799 mbx_cmd_t mc;
1800 mbx_cmd_t *mcp = &mc;
1801 struct qla_hw_data *ha = vha->hw;
1802
1803 ql_dbg(ql_dbg_mbx, vha, 0x106a, "Entered %s.\n", __func__);
1804
1805 if (IS_FWI2_CAPABLE(ha))
1806 return qla24xx_login_fabric(vha, fcport->loop_id,
1807 fcport->d_id.b.domain, fcport->d_id.b.area,
1808 fcport->d_id.b.al_pa, mb_ret, opt);
1809
1810 mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
1811 if (HAS_EXTENDED_IDS(ha))
1812 mcp->mb[1] = fcport->loop_id;
1813 else
1814 mcp->mb[1] = fcport->loop_id << 8;
1815 mcp->mb[2] = opt;
1816 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1817 mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
1818 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1819 mcp->flags = 0;
1820 rval = qla2x00_mailbox_command(vha, mcp);
1821
1822 /* Return mailbox statuses. */
1823 if (mb_ret != NULL) {
1824 mb_ret[0] = mcp->mb[0];
1825 mb_ret[1] = mcp->mb[1];
1826 mb_ret[6] = mcp->mb[6];
1827 mb_ret[7] = mcp->mb[7];
1828 }
1829
1830 if (rval != QLA_SUCCESS) {
1831 /* AV tmp code: need to change main mailbox_command function to
1832 * return ok even when the mailbox completion value is not
1833 * SUCCESS. The caller needs to be responsible to interpret
1834 * the return values of this mailbox command if we're not
1835 * to change too much of the existing code.
1836 */
1837 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
1838 rval = QLA_SUCCESS;
1839
1840 ql_dbg(ql_dbg_mbx, vha, 0x106b,
1841 "Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
1842 rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
1843 } else {
1844 /*EMPTY*/
1845 ql_dbg(ql_dbg_mbx, vha, 0x106c, "Done %s.\n", __func__);
1846 }
1847
1848 return (rval);
1849 }
1850
1851 int
1852 qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1853 uint8_t area, uint8_t al_pa)
1854 {
1855 int rval;
1856 struct logio_entry_24xx *lg;
1857 dma_addr_t lg_dma;
1858 struct qla_hw_data *ha = vha->hw;
1859 struct req_que *req;
1860 struct rsp_que *rsp;
1861
1862 ql_dbg(ql_dbg_mbx, vha, 0x106d, "Entered %s.\n", __func__);
1863
1864 lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1865 if (lg == NULL) {
1866 ql_log(ql_log_warn, vha, 0x106e,
1867 "Failed to allocate logout IOCB.\n");
1868 return QLA_MEMORY_ALLOC_FAILED;
1869 }
1870 memset(lg, 0, sizeof(struct logio_entry_24xx));
1871
1872 if (ql2xmaxqueues > 1)
1873 req = ha->req_q_map[0];
1874 else
1875 req = vha->req;
1876 rsp = req->rsp;
1877 lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1878 lg->entry_count = 1;
1879 lg->handle = MAKE_HANDLE(req->id, lg->handle);
1880 lg->nport_handle = cpu_to_le16(loop_id);
1881 lg->control_flags =
1882 __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
1883 LCF_FREE_NPORT);
1884 lg->port_id[0] = al_pa;
1885 lg->port_id[1] = area;
1886 lg->port_id[2] = domain;
1887 lg->vp_index = vha->vp_idx;
1888
1889 rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1890 if (rval != QLA_SUCCESS) {
1891 ql_dbg(ql_dbg_mbx, vha, 0x106f,
1892 "Failed to issue logout IOCB (%x).\n", rval);
1893 } else if (lg->entry_status != 0) {
1894 ql_dbg(ql_dbg_mbx, vha, 0x1070,
1895 "Failed to complete IOCB -- error status (%x).\n",
1896 lg->entry_status);
1897 rval = QLA_FUNCTION_FAILED;
1898 } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1899 ql_dbg(ql_dbg_mbx, vha, 0x1071,
1900 "Failed to complete IOCB -- completion status (%x) "
1901 "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
1902 le32_to_cpu(lg->io_parameter[0]),
1903 le32_to_cpu(lg->io_parameter[1]));
1904 } else {
1905 /*EMPTY*/
1906 ql_dbg(ql_dbg_mbx, vha, 0x1072, "Done %s.\n", __func__);
1907 }
1908
1909 dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1910
1911 return rval;
1912 }
1913
1914 /*
1915 * qla2x00_fabric_logout
1916 * Issue logout fabric port mailbox command.
1917 *
1918 * Input:
1919 * ha = adapter block pointer.
1920 * loop_id = device loop ID.
1921 * TARGET_QUEUE_LOCK must be released.
1922 * ADAPTER_STATE_LOCK must be released.
1923 *
1924 * Returns:
1925 * qla2x00 local function return status code.
1926 *
1927 * Context:
1928 * Kernel context.
1929 */
1930 int
1931 qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1932 uint8_t area, uint8_t al_pa)
1933 {
1934 int rval;
1935 mbx_cmd_t mc;
1936 mbx_cmd_t *mcp = &mc;
1937
1938 ql_dbg(ql_dbg_mbx, vha, 0x1073, "Entered %s.\n", __func__);
1939
1940 mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
1941 mcp->out_mb = MBX_1|MBX_0;
1942 if (HAS_EXTENDED_IDS(vha->hw)) {
1943 mcp->mb[1] = loop_id;
1944 mcp->mb[10] = 0;
1945 mcp->out_mb |= MBX_10;
1946 } else {
1947 mcp->mb[1] = loop_id << 8;
1948 }
1949
1950 mcp->in_mb = MBX_1|MBX_0;
1951 mcp->tov = MBX_TOV_SECONDS;
1952 mcp->flags = 0;
1953 rval = qla2x00_mailbox_command(vha, mcp);
1954
1955 if (rval != QLA_SUCCESS) {
1956 /*EMPTY*/
1957 ql_dbg(ql_dbg_mbx, vha, 0x1074,
1958 "Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
1959 } else {
1960 /*EMPTY*/
1961 ql_dbg(ql_dbg_mbx, vha, 0x1075, "Done %s.\n", __func__);
1962 }
1963
1964 return rval;
1965 }
1966
1967 /*
1968 * qla2x00_full_login_lip
1969 * Issue full login LIP mailbox command.
1970 *
1971 * Input:
1972 * ha = adapter block pointer.
1973 * TARGET_QUEUE_LOCK must be released.
1974 * ADAPTER_STATE_LOCK must be released.
1975 *
1976 * Returns:
1977 * qla2x00 local function return status code.
1978 *
1979 * Context:
1980 * Kernel context.
1981 */
1982 int
1983 qla2x00_full_login_lip(scsi_qla_host_t *vha)
1984 {
1985 int rval;
1986 mbx_cmd_t mc;
1987 mbx_cmd_t *mcp = &mc;
1988
1989 ql_dbg(ql_dbg_mbx, vha, 0x1076, "Entered %s.\n", __func__);
1990
1991 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1992 mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
1993 mcp->mb[2] = 0;
1994 mcp->mb[3] = 0;
1995 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1996 mcp->in_mb = MBX_0;
1997 mcp->tov = MBX_TOV_SECONDS;
1998 mcp->flags = 0;
1999 rval = qla2x00_mailbox_command(vha, mcp);
2000
2001 if (rval != QLA_SUCCESS) {
2002 /*EMPTY*/
2003 ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
2004 } else {
2005 /*EMPTY*/
2006 ql_dbg(ql_dbg_mbx, vha, 0x1078, "Done %s.\n", __func__);
2007 }
2008
2009 return rval;
2010 }
2011
2012 /*
2013 * qla2x00_get_id_list
2014 *
2015 * Input:
2016 * ha = adapter block pointer.
2017 *
2018 * Returns:
2019 * qla2x00 local function return status code.
2020 *
2021 * Context:
2022 * Kernel context.
2023 */
2024 int
2025 qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
2026 uint16_t *entries)
2027 {
2028 int rval;
2029 mbx_cmd_t mc;
2030 mbx_cmd_t *mcp = &mc;
2031
2032 ql_dbg(ql_dbg_mbx, vha, 0x1079, "Entered %s.\n", __func__);
2033
2034 if (id_list == NULL)
2035 return QLA_FUNCTION_FAILED;
2036
2037 mcp->mb[0] = MBC_GET_ID_LIST;
2038 mcp->out_mb = MBX_0;
2039 if (IS_FWI2_CAPABLE(vha->hw)) {
2040 mcp->mb[2] = MSW(id_list_dma);
2041 mcp->mb[3] = LSW(id_list_dma);
2042 mcp->mb[6] = MSW(MSD(id_list_dma));
2043 mcp->mb[7] = LSW(MSD(id_list_dma));
2044 mcp->mb[8] = 0;
2045 mcp->mb[9] = vha->vp_idx;
2046 mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
2047 } else {
2048 mcp->mb[1] = MSW(id_list_dma);
2049 mcp->mb[2] = LSW(id_list_dma);
2050 mcp->mb[3] = MSW(MSD(id_list_dma));
2051 mcp->mb[6] = LSW(MSD(id_list_dma));
2052 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
2053 }
2054 mcp->in_mb = MBX_1|MBX_0;
2055 mcp->tov = MBX_TOV_SECONDS;
2056 mcp->flags = 0;
2057 rval = qla2x00_mailbox_command(vha, mcp);
2058
2059 if (rval != QLA_SUCCESS) {
2060 /*EMPTY*/
2061 ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
2062 } else {
2063 *entries = mcp->mb[1];
2064 ql_dbg(ql_dbg_mbx, vha, 0x107b, "Done %s.\n", __func__);
2065 }
2066
2067 return rval;
2068 }
2069
2070 /*
2071 * qla2x00_get_resource_cnts
2072 * Get current firmware resource counts.
2073 *
2074 * Input:
2075 * ha = adapter block pointer.
2076 *
2077 * Returns:
2078 * qla2x00 local function return status code.
2079 *
2080 * Context:
2081 * Kernel context.
2082 */
2083 int
2084 qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
2085 uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
2086 uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports, uint16_t *max_fcfs)
2087 {
2088 int rval;
2089 mbx_cmd_t mc;
2090 mbx_cmd_t *mcp = &mc;
2091
2092 ql_dbg(ql_dbg_mbx, vha, 0x107c, "Entered %s.\n", __func__);
2093
2094 mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
2095 mcp->out_mb = MBX_0;
2096 mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2097 if (IS_QLA81XX(vha->hw))
2098 mcp->in_mb |= MBX_12;
2099 mcp->tov = MBX_TOV_SECONDS;
2100 mcp->flags = 0;
2101 rval = qla2x00_mailbox_command(vha, mcp);
2102
2103 if (rval != QLA_SUCCESS) {
2104 /*EMPTY*/
2105 ql_dbg(ql_dbg_mbx, vha, 0x107d,
2106 "Failed mb[0]=%x.\n", mcp->mb[0]);
2107 } else {
2108 ql_dbg(ql_dbg_mbx, vha, 0x107e,
2109 "Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
2110 "mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
2111 mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
2112 mcp->mb[11], mcp->mb[12]);
2113
2114 if (cur_xchg_cnt)
2115 *cur_xchg_cnt = mcp->mb[3];
2116 if (orig_xchg_cnt)
2117 *orig_xchg_cnt = mcp->mb[6];
2118 if (cur_iocb_cnt)
2119 *cur_iocb_cnt = mcp->mb[7];
2120 if (orig_iocb_cnt)
2121 *orig_iocb_cnt = mcp->mb[10];
2122 if (vha->hw->flags.npiv_supported && max_npiv_vports)
2123 *max_npiv_vports = mcp->mb[11];
2124 if (IS_QLA81XX(vha->hw) && max_fcfs)
2125 *max_fcfs = mcp->mb[12];
2126 }
2127
2128 return (rval);
2129 }
2130
2131 /*
2132 * qla2x00_get_fcal_position_map
2133 * Get FCAL (LILP) position map using mailbox command
2134 *
2135 * Input:
2136 * ha = adapter state pointer.
2137 * pos_map = buffer pointer (can be NULL).
2138 *
2139 * Returns:
2140 * qla2x00 local function return status code.
2141 *
2142 * Context:
2143 * Kernel context.
2144 */
2145 int
2146 qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
2147 {
2148 int rval;
2149 mbx_cmd_t mc;
2150 mbx_cmd_t *mcp = &mc;
2151 char *pmap;
2152 dma_addr_t pmap_dma;
2153 struct qla_hw_data *ha = vha->hw;
2154
2155 ql_dbg(ql_dbg_mbx, vha, 0x107f, "Entered %s.\n", __func__);
2156
2157 pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
2158 if (pmap == NULL) {
2159 ql_log(ql_log_warn, vha, 0x1080,
2160 "Memory alloc failed.\n");
2161 return QLA_MEMORY_ALLOC_FAILED;
2162 }
2163 memset(pmap, 0, FCAL_MAP_SIZE);
2164
2165 mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
2166 mcp->mb[2] = MSW(pmap_dma);
2167 mcp->mb[3] = LSW(pmap_dma);
2168 mcp->mb[6] = MSW(MSD(pmap_dma));
2169 mcp->mb[7] = LSW(MSD(pmap_dma));
2170 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2171 mcp->in_mb = MBX_1|MBX_0;
2172 mcp->buf_size = FCAL_MAP_SIZE;
2173 mcp->flags = MBX_DMA_IN;
2174 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2175 rval = qla2x00_mailbox_command(vha, mcp);
2176
2177 if (rval == QLA_SUCCESS) {
2178 ql_dbg(ql_dbg_mbx, vha, 0x1081,
2179 "mb0/mb1=%x/%X FC/AL position map size (%x).\n",
2180 mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
2181 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
2182 pmap, pmap[0] + 1);
2183
2184 if (pos_map)
2185 memcpy(pos_map, pmap, FCAL_MAP_SIZE);
2186 }
2187 dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
2188
2189 if (rval != QLA_SUCCESS) {
2190 ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
2191 } else {
2192 ql_dbg(ql_dbg_mbx, vha, 0x1083, "Done %s.\n", __func__);
2193 }
2194
2195 return rval;
2196 }
2197
2198 /*
2199 * qla2x00_get_link_status
2200 *
2201 * Input:
2202 * ha = adapter block pointer.
2203 * loop_id = device loop ID.
2204 * ret_buf = pointer to link status return buffer.
2205 *
2206 * Returns:
2207 * 0 = success.
2208 * BIT_0 = mem alloc error.
2209 * BIT_1 = mailbox error.
2210 */
2211 int
2212 qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
2213 struct link_statistics *stats, dma_addr_t stats_dma)
2214 {
2215 int rval;
2216 mbx_cmd_t mc;
2217 mbx_cmd_t *mcp = &mc;
2218 uint32_t *siter, *diter, dwords;
2219 struct qla_hw_data *ha = vha->hw;
2220
2221 ql_dbg(ql_dbg_mbx, vha, 0x1084, "Entered %s.\n", __func__);
2222
2223 mcp->mb[0] = MBC_GET_LINK_STATUS;
2224 mcp->mb[2] = MSW(stats_dma);
2225 mcp->mb[3] = LSW(stats_dma);
2226 mcp->mb[6] = MSW(MSD(stats_dma));
2227 mcp->mb[7] = LSW(MSD(stats_dma));
2228 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2229 mcp->in_mb = MBX_0;
2230 if (IS_FWI2_CAPABLE(ha)) {
2231 mcp->mb[1] = loop_id;
2232 mcp->mb[4] = 0;
2233 mcp->mb[10] = 0;
2234 mcp->out_mb |= MBX_10|MBX_4|MBX_1;
2235 mcp->in_mb |= MBX_1;
2236 } else if (HAS_EXTENDED_IDS(ha)) {
2237 mcp->mb[1] = loop_id;
2238 mcp->mb[10] = 0;
2239 mcp->out_mb |= MBX_10|MBX_1;
2240 } else {
2241 mcp->mb[1] = loop_id << 8;
2242 mcp->out_mb |= MBX_1;
2243 }
2244 mcp->tov = MBX_TOV_SECONDS;
2245 mcp->flags = IOCTL_CMD;
2246 rval = qla2x00_mailbox_command(vha, mcp);
2247
2248 if (rval == QLA_SUCCESS) {
2249 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2250 ql_dbg(ql_dbg_mbx, vha, 0x1085,
2251 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
2252 rval = QLA_FUNCTION_FAILED;
2253 } else {
2254 /* Copy over data -- firmware data is LE. */
2255 ql_dbg(ql_dbg_mbx, vha, 0x1086, "Done %s.\n", __func__);
2256 dwords = offsetof(struct link_statistics, unused1) / 4;
2257 siter = diter = &stats->link_fail_cnt;
2258 while (dwords--)
2259 *diter++ = le32_to_cpu(*siter++);
2260 }
2261 } else {
2262 /* Failed. */
2263 ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
2264 }
2265
2266 return rval;
2267 }
2268
2269 int
2270 qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
2271 dma_addr_t stats_dma)
2272 {
2273 int rval;
2274 mbx_cmd_t mc;
2275 mbx_cmd_t *mcp = &mc;
2276 uint32_t *siter, *diter, dwords;
2277
2278 ql_dbg(ql_dbg_mbx, vha, 0x1088, "Entered %s.\n", __func__);
2279
2280 mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2281 mcp->mb[2] = MSW(stats_dma);
2282 mcp->mb[3] = LSW(stats_dma);
2283 mcp->mb[6] = MSW(MSD(stats_dma));
2284 mcp->mb[7] = LSW(MSD(stats_dma));
2285 mcp->mb[8] = sizeof(struct link_statistics) / 4;
2286 mcp->mb[9] = vha->vp_idx;
2287 mcp->mb[10] = 0;
2288 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2289 mcp->in_mb = MBX_2|MBX_1|MBX_0;
2290 mcp->tov = MBX_TOV_SECONDS;
2291 mcp->flags = IOCTL_CMD;
2292 rval = qla2x00_mailbox_command(vha, mcp);
2293
2294 if (rval == QLA_SUCCESS) {
2295 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2296 ql_dbg(ql_dbg_mbx, vha, 0x1089,
2297 "Failed mb[0]=%x.\n", mcp->mb[0]);
2298 rval = QLA_FUNCTION_FAILED;
2299 } else {
2300 ql_dbg(ql_dbg_mbx, vha, 0x108a, "Done %s.\n", __func__);
2301 /* Copy over data -- firmware data is LE. */
2302 dwords = sizeof(struct link_statistics) / 4;
2303 siter = diter = &stats->link_fail_cnt;
2304 while (dwords--)
2305 *diter++ = le32_to_cpu(*siter++);
2306 }
2307 } else {
2308 /* Failed. */
2309 ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
2310 }
2311
2312 return rval;
2313 }
2314
2315 int
2316 qla24xx_abort_command(srb_t *sp)
2317 {
2318 int rval;
2319 unsigned long flags = 0;
2320
2321 struct abort_entry_24xx *abt;
2322 dma_addr_t abt_dma;
2323 uint32_t handle;
2324 fc_port_t *fcport = sp->fcport;
2325 struct scsi_qla_host *vha = fcport->vha;
2326 struct qla_hw_data *ha = vha->hw;
2327 struct req_que *req = vha->req;
2328
2329 ql_dbg(ql_dbg_mbx, vha, 0x108c, "Entered %s.\n", __func__);
2330
2331 spin_lock_irqsave(&ha->hardware_lock, flags);
2332 for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
2333 if (req->outstanding_cmds[handle] == sp)
2334 break;
2335 }
2336 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2337 if (handle == MAX_OUTSTANDING_COMMANDS) {
2338 /* Command not found. */
2339 return QLA_FUNCTION_FAILED;
2340 }
2341
2342 abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
2343 if (abt == NULL) {
2344 ql_log(ql_log_warn, vha, 0x108d,
2345 "Failed to allocate abort IOCB.\n");
2346 return QLA_MEMORY_ALLOC_FAILED;
2347 }
2348 memset(abt, 0, sizeof(struct abort_entry_24xx));
2349
2350 abt->entry_type = ABORT_IOCB_TYPE;
2351 abt->entry_count = 1;
2352 abt->handle = MAKE_HANDLE(req->id, abt->handle);
2353 abt->nport_handle = cpu_to_le16(fcport->loop_id);
2354 abt->handle_to_abort = MAKE_HANDLE(req->id, handle);
2355 abt->port_id[0] = fcport->d_id.b.al_pa;
2356 abt->port_id[1] = fcport->d_id.b.area;
2357 abt->port_id[2] = fcport->d_id.b.domain;
2358 abt->vp_index = fcport->vp_idx;
2359
2360 abt->req_que_no = cpu_to_le16(req->id);
2361
2362 rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
2363 if (rval != QLA_SUCCESS) {
2364 ql_dbg(ql_dbg_mbx, vha, 0x108e,
2365 "Failed to issue IOCB (%x).\n", rval);
2366 } else if (abt->entry_status != 0) {
2367 ql_dbg(ql_dbg_mbx, vha, 0x108f,
2368 "Failed to complete IOCB -- error status (%x).\n",
2369 abt->entry_status);
2370 rval = QLA_FUNCTION_FAILED;
2371 } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
2372 ql_dbg(ql_dbg_mbx, vha, 0x1090,
2373 "Failed to complete IOCB -- completion status (%x).\n",
2374 le16_to_cpu(abt->nport_handle));
2375 rval = QLA_FUNCTION_FAILED;
2376 } else {
2377 ql_dbg(ql_dbg_mbx, vha, 0x1091, "Done %s.\n", __func__);
2378 }
2379
2380 dma_pool_free(ha->s_dma_pool, abt, abt_dma);
2381
2382 return rval;
2383 }
2384
2385 struct tsk_mgmt_cmd {
2386 union {
2387 struct tsk_mgmt_entry tsk;
2388 struct sts_entry_24xx sts;
2389 } p;
2390 };
2391
2392 static int
2393 __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
2394 unsigned int l, int tag)
2395 {
2396 int rval, rval2;
2397 struct tsk_mgmt_cmd *tsk;
2398 struct sts_entry_24xx *sts;
2399 dma_addr_t tsk_dma;
2400 scsi_qla_host_t *vha;
2401 struct qla_hw_data *ha;
2402 struct req_que *req;
2403 struct rsp_que *rsp;
2404
2405 vha = fcport->vha;
2406 ha = vha->hw;
2407 req = vha->req;
2408
2409 ql_dbg(ql_dbg_mbx, vha, 0x1092, "Entered %s.\n", __func__);
2410
2411 if (ha->flags.cpu_affinity_enabled)
2412 rsp = ha->rsp_q_map[tag + 1];
2413 else
2414 rsp = req->rsp;
2415 tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2416 if (tsk == NULL) {
2417 ql_log(ql_log_warn, vha, 0x1093,
2418 "Failed to allocate task management IOCB.\n");
2419 return QLA_MEMORY_ALLOC_FAILED;
2420 }
2421 memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
2422
2423 tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
2424 tsk->p.tsk.entry_count = 1;
2425 tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
2426 tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2427 tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2428 tsk->p.tsk.control_flags = cpu_to_le32(type);
2429 tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
2430 tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
2431 tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2432 tsk->p.tsk.vp_index = fcport->vp_idx;
2433 if (type == TCF_LUN_RESET) {
2434 int_to_scsilun(l, &tsk->p.tsk.lun);
2435 host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
2436 sizeof(tsk->p.tsk.lun));
2437 }
2438
2439 sts = &tsk->p.sts;
2440 rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
2441 if (rval != QLA_SUCCESS) {
2442 ql_dbg(ql_dbg_mbx, vha, 0x1094,
2443 "Failed to issue %s reset IOCB (%x).\n", name, rval);
2444 } else if (sts->entry_status != 0) {
2445 ql_dbg(ql_dbg_mbx, vha, 0x1095,
2446 "Failed to complete IOCB -- error status (%x).\n",
2447 sts->entry_status);
2448 rval = QLA_FUNCTION_FAILED;
2449 } else if (sts->comp_status !=
2450 __constant_cpu_to_le16(CS_COMPLETE)) {
2451 ql_dbg(ql_dbg_mbx, vha, 0x1096,
2452 "Failed to complete IOCB -- completion status (%x).\n",
2453 le16_to_cpu(sts->comp_status));
2454 rval = QLA_FUNCTION_FAILED;
2455 } else if (le16_to_cpu(sts->scsi_status) &
2456 SS_RESPONSE_INFO_LEN_VALID) {
2457 if (le32_to_cpu(sts->rsp_data_len) < 4) {
2458 ql_dbg(ql_dbg_mbx, vha, 0x1097,
2459 "Ignoring inconsistent data length -- not enough "
2460 "response info (%d).\n",
2461 le32_to_cpu(sts->rsp_data_len));
2462 } else if (sts->data[3]) {
2463 ql_dbg(ql_dbg_mbx, vha, 0x1098,
2464 "Failed to complete IOCB -- response (%x).\n",
2465 sts->data[3]);
2466 rval = QLA_FUNCTION_FAILED;
2467 }
2468 }
2469
2470 /* Issue marker IOCB. */
2471 rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
2472 type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
2473 if (rval2 != QLA_SUCCESS) {
2474 ql_dbg(ql_dbg_mbx, vha, 0x1099,
2475 "Failed to issue marker IOCB (%x).\n", rval2);
2476 } else {
2477 ql_dbg(ql_dbg_mbx, vha, 0x109a, "Done %s.\n", __func__);
2478 }
2479
2480 dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2481
2482 return rval;
2483 }
2484
2485 int
2486 qla24xx_abort_target(struct fc_port *fcport, unsigned int l, int tag)
2487 {
2488 struct qla_hw_data *ha = fcport->vha->hw;
2489
2490 if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2491 return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
2492
2493 return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
2494 }
2495
2496 int
2497 qla24xx_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
2498 {
2499 struct qla_hw_data *ha = fcport->vha->hw;
2500
2501 if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
2502 return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
2503
2504 return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
2505 }
2506
2507 int
2508 qla2x00_system_error(scsi_qla_host_t *vha)
2509 {
2510 int rval;
2511 mbx_cmd_t mc;
2512 mbx_cmd_t *mcp = &mc;
2513 struct qla_hw_data *ha = vha->hw;
2514
2515 if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
2516 return QLA_FUNCTION_FAILED;
2517
2518 ql_dbg(ql_dbg_mbx, vha, 0x109b, "Entered %s.\n", __func__);
2519
2520 mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
2521 mcp->out_mb = MBX_0;
2522 mcp->in_mb = MBX_0;
2523 mcp->tov = 5;
2524 mcp->flags = 0;
2525 rval = qla2x00_mailbox_command(vha, mcp);
2526
2527 if (rval != QLA_SUCCESS) {
2528 ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
2529 } else {
2530 ql_dbg(ql_dbg_mbx, vha, 0x109d, "Done %s.\n", __func__);
2531 }
2532
2533 return rval;
2534 }
2535
2536 /**
2537 * qla2x00_set_serdes_params() -
2538 * @ha: HA context
2539 *
2540 * Returns
2541 */
2542 int
2543 qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
2544 uint16_t sw_em_2g, uint16_t sw_em_4g)
2545 {
2546 int rval;
2547 mbx_cmd_t mc;
2548 mbx_cmd_t *mcp = &mc;
2549
2550 ql_dbg(ql_dbg_mbx, vha, 0x109e, "Entered %s.\n", __func__);
2551
2552 mcp->mb[0] = MBC_SERDES_PARAMS;
2553 mcp->mb[1] = BIT_0;
2554 mcp->mb[2] = sw_em_1g | BIT_15;
2555 mcp->mb[3] = sw_em_2g | BIT_15;
2556 mcp->mb[4] = sw_em_4g | BIT_15;
2557 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2558 mcp->in_mb = MBX_0;
2559 mcp->tov = MBX_TOV_SECONDS;
2560 mcp->flags = 0;
2561 rval = qla2x00_mailbox_command(vha, mcp);
2562
2563 if (rval != QLA_SUCCESS) {
2564 /*EMPTY*/
2565 ql_dbg(ql_dbg_mbx, vha, 0x109f,
2566 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
2567 } else {
2568 /*EMPTY*/
2569 ql_dbg(ql_dbg_mbx, vha, 0x10a0, "Done %s.\n", __func__);
2570 }
2571
2572 return rval;
2573 }
2574
2575 int
2576 qla2x00_stop_firmware(scsi_qla_host_t *vha)
2577 {
2578 int rval;
2579 mbx_cmd_t mc;
2580 mbx_cmd_t *mcp = &mc;
2581
2582 if (!IS_FWI2_CAPABLE(vha->hw))
2583 return QLA_FUNCTION_FAILED;
2584
2585 ql_dbg(ql_dbg_mbx, vha, 0x10a1, "Entered %s.\n", __func__);
2586
2587 mcp->mb[0] = MBC_STOP_FIRMWARE;
2588 mcp->mb[1] = 0;
2589 mcp->out_mb = MBX_1|MBX_0;
2590 mcp->in_mb = MBX_0;
2591 mcp->tov = 5;
2592 mcp->flags = 0;
2593 rval = qla2x00_mailbox_command(vha, mcp);
2594
2595 if (rval != QLA_SUCCESS) {
2596 ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
2597 if (mcp->mb[0] == MBS_INVALID_COMMAND)
2598 rval = QLA_INVALID_COMMAND;
2599 } else {
2600 ql_dbg(ql_dbg_mbx, vha, 0x10a3, "Done %s.\n", __func__);
2601 }
2602
2603 return rval;
2604 }
2605
2606 int
2607 qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
2608 uint16_t buffers)
2609 {
2610 int rval;
2611 mbx_cmd_t mc;
2612 mbx_cmd_t *mcp = &mc;
2613
2614 ql_dbg(ql_dbg_mbx, vha, 0x10a4, "Entered %s.\n", __func__);
2615
2616 if (!IS_FWI2_CAPABLE(vha->hw))
2617 return QLA_FUNCTION_FAILED;
2618
2619 if (unlikely(pci_channel_offline(vha->hw->pdev)))
2620 return QLA_FUNCTION_FAILED;
2621
2622 mcp->mb[0] = MBC_TRACE_CONTROL;
2623 mcp->mb[1] = TC_EFT_ENABLE;
2624 mcp->mb[2] = LSW(eft_dma);
2625 mcp->mb[3] = MSW(eft_dma);
2626 mcp->mb[4] = LSW(MSD(eft_dma));
2627 mcp->mb[5] = MSW(MSD(eft_dma));
2628 mcp->mb[6] = buffers;
2629 mcp->mb[7] = TC_AEN_DISABLE;
2630 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2631 mcp->in_mb = MBX_1|MBX_0;
2632 mcp->tov = MBX_TOV_SECONDS;
2633 mcp->flags = 0;
2634 rval = qla2x00_mailbox_command(vha, mcp);
2635 if (rval != QLA_SUCCESS) {
2636 ql_dbg(ql_dbg_mbx, vha, 0x10a5,
2637 "Failed=%x mb[0]=%x mb[1]=%x.\n",
2638 rval, mcp->mb[0], mcp->mb[1]);
2639 } else {
2640 ql_dbg(ql_dbg_mbx, vha, 0x10a6, "Done %s.\n", __func__);
2641 }
2642
2643 return rval;
2644 }
2645
2646 int
2647 qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
2648 {
2649 int rval;
2650 mbx_cmd_t mc;
2651 mbx_cmd_t *mcp = &mc;
2652
2653 ql_dbg(ql_dbg_mbx, vha, 0x10a7, "Entered %s.\n", __func__);
2654
2655 if (!IS_FWI2_CAPABLE(vha->hw))
2656 return QLA_FUNCTION_FAILED;
2657
2658 if (unlikely(pci_channel_offline(vha->hw->pdev)))
2659 return QLA_FUNCTION_FAILED;
2660
2661 mcp->mb[0] = MBC_TRACE_CONTROL;
2662 mcp->mb[1] = TC_EFT_DISABLE;
2663 mcp->out_mb = MBX_1|MBX_0;
2664 mcp->in_mb = MBX_1|MBX_0;
2665 mcp->tov = MBX_TOV_SECONDS;
2666 mcp->flags = 0;
2667 rval = qla2x00_mailbox_command(vha, mcp);
2668 if (rval != QLA_SUCCESS) {
2669 ql_dbg(ql_dbg_mbx, vha, 0x10a8,
2670 "Failed=%x mb[0]=%x mb[1]=%x.\n",
2671 rval, mcp->mb[0], mcp->mb[1]);
2672 } else {
2673 ql_dbg(ql_dbg_mbx, vha, 0x10a9, "Done %s.\n", __func__);
2674 }
2675
2676 return rval;
2677 }
2678
2679 int
2680 qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
2681 uint16_t buffers, uint16_t *mb, uint32_t *dwords)
2682 {
2683 int rval;
2684 mbx_cmd_t mc;
2685 mbx_cmd_t *mcp = &mc;
2686
2687 ql_dbg(ql_dbg_mbx, vha, 0x10aa, "Entered %s.\n", __func__);
2688
2689 if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
2690 return QLA_FUNCTION_FAILED;
2691
2692 if (unlikely(pci_channel_offline(vha->hw->pdev)))
2693 return QLA_FUNCTION_FAILED;
2694
2695 mcp->mb[0] = MBC_TRACE_CONTROL;
2696 mcp->mb[1] = TC_FCE_ENABLE;
2697 mcp->mb[2] = LSW(fce_dma);
2698 mcp->mb[3] = MSW(fce_dma);
2699 mcp->mb[4] = LSW(MSD(fce_dma));
2700 mcp->mb[5] = MSW(MSD(fce_dma));
2701 mcp->mb[6] = buffers;
2702 mcp->mb[7] = TC_AEN_DISABLE;
2703 mcp->mb[8] = 0;
2704 mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
2705 mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
2706 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
2707 MBX_1|MBX_0;
2708 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2709 mcp->tov = MBX_TOV_SECONDS;
2710 mcp->flags = 0;
2711 rval = qla2x00_mailbox_command(vha, mcp);
2712 if (rval != QLA_SUCCESS) {
2713 ql_dbg(ql_dbg_mbx, vha, 0x10ab,
2714 "Failed=%x mb[0]=%x mb[1]=%x.\n",
2715 rval, mcp->mb[0], mcp->mb[1]);
2716 } else {
2717 ql_dbg(ql_dbg_mbx, vha, 0x10ac, "Done %s.\n", __func__);
2718
2719 if (mb)
2720 memcpy(mb, mcp->mb, 8 * sizeof(*mb));
2721 if (dwords)
2722 *dwords = buffers;
2723 }
2724
2725 return rval;
2726 }
2727
2728 int
2729 qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
2730 {
2731 int rval;
2732 mbx_cmd_t mc;
2733 mbx_cmd_t *mcp = &mc;
2734
2735 ql_dbg(ql_dbg_mbx, vha, 0x10ad, "Entered %s.\n", __func__);
2736
2737 if (!IS_FWI2_CAPABLE(vha->hw))
2738 return QLA_FUNCTION_FAILED;
2739
2740 if (unlikely(pci_channel_offline(vha->hw->pdev)))
2741 return QLA_FUNCTION_FAILED;
2742
2743 mcp->mb[0] = MBC_TRACE_CONTROL;
2744 mcp->mb[1] = TC_FCE_DISABLE;
2745 mcp->mb[2] = TC_FCE_DISABLE_TRACE;
2746 mcp->out_mb = MBX_2|MBX_1|MBX_0;
2747 mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
2748 MBX_1|MBX_0;
2749 mcp->tov = MBX_TOV_SECONDS;
2750 mcp->flags = 0;
2751 rval = qla2x00_mailbox_command(vha, mcp);
2752 if (rval != QLA_SUCCESS) {
2753 ql_dbg(ql_dbg_mbx, vha, 0x10ae,
2754 "Failed=%x mb[0]=%x mb[1]=%x.\n",
2755 rval, mcp->mb[0], mcp->mb[1]);
2756 } else {
2757 ql_dbg(ql_dbg_mbx, vha, 0x10af, "Done %s.\n", __func__);
2758
2759 if (wr)
2760 *wr = (uint64_t) mcp->mb[5] << 48 |
2761 (uint64_t) mcp->mb[4] << 32 |
2762 (uint64_t) mcp->mb[3] << 16 |
2763 (uint64_t) mcp->mb[2];
2764 if (rd)
2765 *rd = (uint64_t) mcp->mb[9] << 48 |
2766 (uint64_t) mcp->mb[8] << 32 |
2767 (uint64_t) mcp->mb[7] << 16 |
2768 (uint64_t) mcp->mb[6];
2769 }
2770
2771 return rval;
2772 }
2773
2774 int
2775 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
2776 uint16_t *port_speed, uint16_t *mb)
2777 {
2778 int rval;
2779 mbx_cmd_t mc;
2780 mbx_cmd_t *mcp = &mc;
2781
2782 ql_dbg(ql_dbg_mbx, vha, 0x10b0, "Entered %s.\n", __func__);
2783
2784 if (!IS_IIDMA_CAPABLE(vha->hw))
2785 return QLA_FUNCTION_FAILED;
2786
2787 mcp->mb[0] = MBC_PORT_PARAMS;
2788 mcp->mb[1] = loop_id;
2789 mcp->mb[2] = mcp->mb[3] = 0;
2790 mcp->mb[9] = vha->vp_idx;
2791 mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
2792 mcp->in_mb = MBX_3|MBX_1|MBX_0;
2793 mcp->tov = MBX_TOV_SECONDS;
2794 mcp->flags = 0;
2795 rval = qla2x00_mailbox_command(vha, mcp);
2796
2797 /* Return mailbox statuses. */
2798 if (mb != NULL) {
2799 mb[0] = mcp->mb[0];
2800 mb[1] = mcp->mb[1];
2801 mb[3] = mcp->mb[3];
2802 }
2803
2804 if (rval != QLA_SUCCESS) {
2805 ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
2806 } else {
2807 ql_dbg(ql_dbg_mbx, vha, 0x10b2, "Done %s.\n", __func__);
2808 if (port_speed)
2809 *port_speed = mcp->mb[3];
2810 }
2811
2812 return rval;
2813 }
2814
2815 int
2816 qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
2817 uint16_t port_speed, uint16_t *mb)
2818 {
2819 int rval;
2820 mbx_cmd_t mc;
2821 mbx_cmd_t *mcp = &mc;
2822
2823 ql_dbg(ql_dbg_mbx, vha, 0x10b3, "Entered %s.\n", __func__);
2824
2825 if (!IS_IIDMA_CAPABLE(vha->hw))
2826 return QLA_FUNCTION_FAILED;
2827
2828 mcp->mb[0] = MBC_PORT_PARAMS;
2829 mcp->mb[1] = loop_id;
2830 mcp->mb[2] = BIT_0;
2831 if (IS_QLA8XXX_TYPE(vha->hw))
2832 mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
2833 else
2834 mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
2835 mcp->mb[9] = vha->vp_idx;
2836 mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
2837 mcp->in_mb = MBX_3|MBX_1|MBX_0;
2838 mcp->tov = MBX_TOV_SECONDS;
2839 mcp->flags = 0;
2840 rval = qla2x00_mailbox_command(vha, mcp);
2841
2842 /* Return mailbox statuses. */
2843 if (mb != NULL) {
2844 mb[0] = mcp->mb[0];
2845 mb[1] = mcp->mb[1];
2846 mb[3] = mcp->mb[3];
2847 }
2848
2849 if (rval != QLA_SUCCESS) {
2850 ql_dbg(ql_dbg_mbx, vha, 0x10b4, "Failed=%x.\n", rval);
2851 } else {
2852 ql_dbg(ql_dbg_mbx, vha, 0x10b5, "Done %s.\n", __func__);
2853 }
2854
2855 return rval;
2856 }
2857
2858 void
2859 qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
2860 struct vp_rpt_id_entry_24xx *rptid_entry)
2861 {
2862 uint8_t vp_idx;
2863 uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
2864 struct qla_hw_data *ha = vha->hw;
2865 scsi_qla_host_t *vp;
2866 unsigned long flags;
2867
2868 ql_dbg(ql_dbg_mbx, vha, 0x10b6, "Entered %s.\n", __func__);
2869
2870 if (rptid_entry->entry_status != 0)
2871 return;
2872
2873 if (rptid_entry->format == 0) {
2874 ql_dbg(ql_dbg_mbx, vha, 0x10b7,
2875 "Format 0 : Number of VPs setup %d, number of "
2876 "VPs acquired %d.\n",
2877 MSB(le16_to_cpu(rptid_entry->vp_count)),
2878 LSB(le16_to_cpu(rptid_entry->vp_count)));
2879 ql_dbg(ql_dbg_mbx, vha, 0x10b8,
2880 "Primary port id %02x%02x%02x.\n",
2881 rptid_entry->port_id[2], rptid_entry->port_id[1],
2882 rptid_entry->port_id[0]);
2883 } else if (rptid_entry->format == 1) {
2884 vp_idx = LSB(stat);
2885 ql_dbg(ql_dbg_mbx, vha, 0x10b9,
2886 "Format 1: VP[%d] enabled - status %d - with "
2887 "port id %02x%02x%02x.\n", vp_idx, MSB(stat),
2888 rptid_entry->port_id[2], rptid_entry->port_id[1],
2889 rptid_entry->port_id[0]);
2890
2891 vp = vha;
2892 if (vp_idx == 0 && (MSB(stat) != 1))
2893 goto reg_needed;
2894
2895 if (MSB(stat) != 0) {
2896 ql_dbg(ql_dbg_mbx, vha, 0x10ba,
2897 "Could not acquire ID for VP[%d].\n", vp_idx);
2898 return;
2899 }
2900
2901 spin_lock_irqsave(&ha->vport_slock, flags);
2902 list_for_each_entry(vp, &ha->vp_list, list)
2903 if (vp_idx == vp->vp_idx)
2904 break;
2905 spin_unlock_irqrestore(&ha->vport_slock, flags);
2906
2907 if (!vp)
2908 return;
2909
2910 vp->d_id.b.domain = rptid_entry->port_id[2];
2911 vp->d_id.b.area = rptid_entry->port_id[1];
2912 vp->d_id.b.al_pa = rptid_entry->port_id[0];
2913
2914 /*
2915 * Cannot configure here as we are still sitting on the
2916 * response queue. Handle it in dpc context.
2917 */
2918 set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
2919
2920 reg_needed:
2921 set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
2922 set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
2923 set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
2924 qla2xxx_wake_dpc(vha);
2925 }
2926 }
2927
2928 /*
2929 * qla24xx_modify_vp_config
2930 * Change VP configuration for vha
2931 *
2932 * Input:
2933 * vha = adapter block pointer.
2934 *
2935 * Returns:
2936 * qla2xxx local function return status code.
2937 *
2938 * Context:
2939 * Kernel context.
2940 */
2941 int
2942 qla24xx_modify_vp_config(scsi_qla_host_t *vha)
2943 {
2944 int rval;
2945 struct vp_config_entry_24xx *vpmod;
2946 dma_addr_t vpmod_dma;
2947 struct qla_hw_data *ha = vha->hw;
2948 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2949
2950 /* This can be called by the parent */
2951
2952 ql_dbg(ql_dbg_mbx, vha, 0x10bb, "Entered %s.\n", __func__);
2953
2954 vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
2955 if (!vpmod) {
2956 ql_log(ql_log_warn, vha, 0x10bc,
2957 "Failed to allocate modify VP IOCB.\n");
2958 return QLA_MEMORY_ALLOC_FAILED;
2959 }
2960
2961 memset(vpmod, 0, sizeof(struct vp_config_entry_24xx));
2962 vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
2963 vpmod->entry_count = 1;
2964 vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
2965 vpmod->vp_count = 1;
2966 vpmod->vp_index1 = vha->vp_idx;
2967 vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
2968 memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
2969 memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
2970 vpmod->entry_count = 1;
2971
2972 rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
2973 if (rval != QLA_SUCCESS) {
2974 ql_dbg(ql_dbg_mbx, vha, 0x10bd,
2975 "Failed to issue VP config IOCB (%x).\n", rval);
2976 } else if (vpmod->comp_status != 0) {
2977 ql_dbg(ql_dbg_mbx, vha, 0x10be,
2978 "Failed to complete IOCB -- error status (%x).\n",
2979 vpmod->comp_status);
2980 rval = QLA_FUNCTION_FAILED;
2981 } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
2982 ql_dbg(ql_dbg_mbx, vha, 0x10bf,
2983 "Failed to complete IOCB -- completion status (%x).\n",
2984 le16_to_cpu(vpmod->comp_status));
2985 rval = QLA_FUNCTION_FAILED;
2986 } else {
2987 /* EMPTY */
2988 ql_dbg(ql_dbg_mbx, vha, 0x10c0, "Done %s.\n", __func__);
2989 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
2990 }
2991 dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
2992
2993 return rval;
2994 }
2995
2996 /*
2997 * qla24xx_control_vp
2998 * Enable a virtual port for given host
2999 *
3000 * Input:
3001 * ha = adapter block pointer.
3002 * vhba = virtual adapter (unused)
3003 * index = index number for enabled VP
3004 *
3005 * Returns:
3006 * qla2xxx local function return status code.
3007 *
3008 * Context:
3009 * Kernel context.
3010 */
3011 int
3012 qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
3013 {
3014 int rval;
3015 int map, pos;
3016 struct vp_ctrl_entry_24xx *vce;
3017 dma_addr_t vce_dma;
3018 struct qla_hw_data *ha = vha->hw;
3019 int vp_index = vha->vp_idx;
3020 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
3021
3022 ql_dbg(ql_dbg_mbx, vha, 0x10c1,
3023 "Entered %s enabling index %d.\n", __func__, vp_index);
3024
3025 if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
3026 return QLA_PARAMETER_ERROR;
3027
3028 vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
3029 if (!vce) {
3030 ql_log(ql_log_warn, vha, 0x10c2,
3031 "Failed to allocate VP control IOCB.\n");
3032 return QLA_MEMORY_ALLOC_FAILED;
3033 }
3034 memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));
3035
3036 vce->entry_type = VP_CTRL_IOCB_TYPE;
3037 vce->entry_count = 1;
3038 vce->command = cpu_to_le16(cmd);
3039 vce->vp_count = __constant_cpu_to_le16(1);
3040
3041 /* index map in firmware starts with 1; decrement index
3042 * this is ok as we never use index 0
3043 */
3044 map = (vp_index - 1) / 8;
3045 pos = (vp_index - 1) & 7;
3046 mutex_lock(&ha->vport_lock);
3047 vce->vp_idx_map[map] |= 1 << pos;
3048 mutex_unlock(&ha->vport_lock);
3049
3050 rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
3051 if (rval != QLA_SUCCESS) {
3052 ql_dbg(ql_dbg_mbx, vha, 0x10c3,
3053 "Failed to issue VP control IOCB (%x).\n", rval);
3054 } else if (vce->entry_status != 0) {
3055 ql_dbg(ql_dbg_mbx, vha, 0x10c4,
3056 "Failed to complete IOCB -- error status (%x).\n",
3057 vce->entry_status);
3058 rval = QLA_FUNCTION_FAILED;
3059 } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
3060 ql_dbg(ql_dbg_mbx, vha, 0x10c5,
3061 "Failed to complet IOCB -- completion status (%x).\n",
3062 le16_to_cpu(vce->comp_status));
3063 rval = QLA_FUNCTION_FAILED;
3064 } else {
3065 ql_dbg(ql_dbg_mbx, vha, 0x10c6, "Done %s.\n", __func__);
3066 }
3067
3068 dma_pool_free(ha->s_dma_pool, vce, vce_dma);
3069
3070 return rval;
3071 }
3072
3073 /*
3074 * qla2x00_send_change_request
3075 * Receive or disable RSCN request from fabric controller
3076 *
3077 * Input:
3078 * ha = adapter block pointer
3079 * format = registration format:
3080 * 0 - Reserved
3081 * 1 - Fabric detected registration
3082 * 2 - N_port detected registration
3083 * 3 - Full registration
3084 * FF - clear registration
3085 * vp_idx = Virtual port index
3086 *
3087 * Returns:
3088 * qla2x00 local function return status code.
3089 *
3090 * Context:
3091 * Kernel Context
3092 */
3093
3094 int
3095 qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
3096 uint16_t vp_idx)
3097 {
3098 int rval;
3099 mbx_cmd_t mc;
3100 mbx_cmd_t *mcp = &mc;
3101
3102 ql_dbg(ql_dbg_mbx, vha, 0x10c7, "Entered %s.\n", __func__);
3103
3104 /*
3105 * This command is implicitly executed by firmware during login for the
3106 * physical hosts
3107 */
3108 if (vp_idx == 0)
3109 return QLA_FUNCTION_FAILED;
3110
3111 mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
3112 mcp->mb[1] = format;
3113 mcp->mb[9] = vp_idx;
3114 mcp->out_mb = MBX_9|MBX_1|MBX_0;
3115 mcp->in_mb = MBX_0|MBX_1;
3116 mcp->tov = MBX_TOV_SECONDS;
3117 mcp->flags = 0;
3118 rval = qla2x00_mailbox_command(vha, mcp);
3119
3120 if (rval == QLA_SUCCESS) {
3121 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
3122 rval = BIT_1;
3123 }
3124 } else
3125 rval = BIT_1;
3126
3127 return rval;
3128 }
3129
3130 int
3131 qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
3132 uint32_t size)
3133 {
3134 int rval;
3135 mbx_cmd_t mc;
3136 mbx_cmd_t *mcp = &mc;
3137
3138 ql_dbg(ql_dbg_mbx, vha, 0x1009, "Entered %s.\n", __func__);
3139
3140 if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
3141 mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
3142 mcp->mb[8] = MSW(addr);
3143 mcp->out_mb = MBX_8|MBX_0;
3144 } else {
3145 mcp->mb[0] = MBC_DUMP_RISC_RAM;
3146 mcp->out_mb = MBX_0;
3147 }
3148 mcp->mb[1] = LSW(addr);
3149 mcp->mb[2] = MSW(req_dma);
3150 mcp->mb[3] = LSW(req_dma);
3151 mcp->mb[6] = MSW(MSD(req_dma));
3152 mcp->mb[7] = LSW(MSD(req_dma));
3153 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
3154 if (IS_FWI2_CAPABLE(vha->hw)) {
3155 mcp->mb[4] = MSW(size);
3156 mcp->mb[5] = LSW(size);
3157 mcp->out_mb |= MBX_5|MBX_4;
3158 } else {
3159 mcp->mb[4] = LSW(size);
3160 mcp->out_mb |= MBX_4;
3161 }
3162
3163 mcp->in_mb = MBX_0;
3164 mcp->tov = MBX_TOV_SECONDS;
3165 mcp->flags = 0;
3166 rval = qla2x00_mailbox_command(vha, mcp);
3167
3168 if (rval != QLA_SUCCESS) {
3169 ql_dbg(ql_dbg_mbx, vha, 0x1008,
3170 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3171 } else {
3172 ql_dbg(ql_dbg_mbx, vha, 0x1007, "Done %s.\n", __func__);
3173 }
3174
3175 return rval;
3176 }
3177
3178 /* 84XX Support **************************************************************/
3179
3180 struct cs84xx_mgmt_cmd {
3181 union {
3182 struct verify_chip_entry_84xx req;
3183 struct verify_chip_rsp_84xx rsp;
3184 } p;
3185 };
3186
3187 int
3188 qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
3189 {
3190 int rval, retry;
3191 struct cs84xx_mgmt_cmd *mn;
3192 dma_addr_t mn_dma;
3193 uint16_t options;
3194 unsigned long flags;
3195 struct qla_hw_data *ha = vha->hw;
3196
3197 ql_dbg(ql_dbg_mbx, vha, 0x10c8, "Entered %s.\n", __func__);
3198
3199 mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
3200 if (mn == NULL) {
3201 return QLA_MEMORY_ALLOC_FAILED;
3202 }
3203
3204 /* Force Update? */
3205 options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
3206 /* Diagnostic firmware? */
3207 /* options |= MENLO_DIAG_FW; */
3208 /* We update the firmware with only one data sequence. */
3209 options |= VCO_END_OF_DATA;
3210
3211 do {
3212 retry = 0;
3213 memset(mn, 0, sizeof(*mn));
3214 mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
3215 mn->p.req.entry_count = 1;
3216 mn->p.req.options = cpu_to_le16(options);
3217
3218 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
3219 "Dump of Verify Request.\n");
3220 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
3221 (uint8_t *)mn, sizeof(*mn));
3222
3223 rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
3224 if (rval != QLA_SUCCESS) {
3225 ql_dbg(ql_dbg_mbx, vha, 0x10cb,
3226 "Failed to issue verify IOCB (%x).\n", rval);
3227 goto verify_done;
3228 }
3229
3230 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
3231 "Dump of Verify Response.\n");
3232 ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
3233 (uint8_t *)mn, sizeof(*mn));
3234
3235 status[0] = le16_to_cpu(mn->p.rsp.comp_status);
3236 status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
3237 le16_to_cpu(mn->p.rsp.failure_code) : 0;
3238 ql_dbg(ql_dbg_mbx, vha, 0x10ce,
3239 "cs=%x fc=%x.\n", status[0], status[1]);
3240
3241 if (status[0] != CS_COMPLETE) {
3242 rval = QLA_FUNCTION_FAILED;
3243 if (!(options & VCO_DONT_UPDATE_FW)) {
3244 ql_dbg(ql_dbg_mbx, vha, 0x10cf,
3245 "Firmware update failed. Retrying "
3246 "without update firmware.\n");
3247 options |= VCO_DONT_UPDATE_FW;
3248 options &= ~VCO_FORCE_UPDATE;
3249 retry = 1;
3250 }
3251 } else {
3252 ql_dbg(ql_dbg_mbx, vha, 0x10d0,
3253 "Firmware updated to %x.\n",
3254 le32_to_cpu(mn->p.rsp.fw_ver));
3255
3256 /* NOTE: we only update OP firmware. */
3257 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
3258 ha->cs84xx->op_fw_version =
3259 le32_to_cpu(mn->p.rsp.fw_ver);
3260 spin_unlock_irqrestore(&ha->cs84xx->access_lock,
3261 flags);
3262 }
3263 } while (retry);
3264
3265 verify_done:
3266 dma_pool_free(ha->s_dma_pool, mn, mn_dma);
3267
3268 if (rval != QLA_SUCCESS) {
3269 ql_dbg(ql_dbg_mbx, vha, 0x10d1, "Failed=%x.\n", rval);
3270 } else {
3271 ql_dbg(ql_dbg_mbx, vha, 0x10d2, "Done %s.\n", __func__);
3272 }
3273
3274 return rval;
3275 }
3276
3277 int
3278 qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
3279 {
3280 int rval;
3281 unsigned long flags;
3282 mbx_cmd_t mc;
3283 mbx_cmd_t *mcp = &mc;
3284 struct device_reg_25xxmq __iomem *reg;
3285 struct qla_hw_data *ha = vha->hw;
3286
3287 ql_dbg(ql_dbg_mbx, vha, 0x10d3, "Entered %s.\n", __func__);
3288
3289 mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3290 mcp->mb[1] = req->options;
3291 mcp->mb[2] = MSW(LSD(req->dma));
3292 mcp->mb[3] = LSW(LSD(req->dma));
3293 mcp->mb[6] = MSW(MSD(req->dma));
3294 mcp->mb[7] = LSW(MSD(req->dma));
3295 mcp->mb[5] = req->length;
3296 if (req->rsp)
3297 mcp->mb[10] = req->rsp->id;
3298 mcp->mb[12] = req->qos;
3299 mcp->mb[11] = req->vp_idx;
3300 mcp->mb[13] = req->rid;
3301
3302 reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
3303 QLA_QUE_PAGE * req->id);
3304
3305 mcp->mb[4] = req->id;
3306 /* que in ptr index */
3307 mcp->mb[8] = 0;
3308 /* que out ptr index */
3309 mcp->mb[9] = 0;
3310 mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
3311 MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3312 mcp->in_mb = MBX_0;
3313 mcp->flags = MBX_DMA_OUT;
3314 mcp->tov = 60;
3315
3316 spin_lock_irqsave(&ha->hardware_lock, flags);
3317 if (!(req->options & BIT_0)) {
3318 WRT_REG_DWORD(&reg->req_q_in, 0);
3319 WRT_REG_DWORD(&reg->req_q_out, 0);
3320 }
3321 req->req_q_in = &reg->req_q_in;
3322 req->req_q_out = &reg->req_q_out;
3323 spin_unlock_irqrestore(&ha->hardware_lock, flags);
3324
3325 rval = qla2x00_mailbox_command(vha, mcp);
3326 if (rval != QLA_SUCCESS) {
3327 ql_dbg(ql_dbg_mbx, vha, 0x10d4,
3328 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3329 } else {
3330 ql_dbg(ql_dbg_mbx, vha, 0x10d5, "Done %s.\n", __func__);
3331 }
3332
3333 return rval;
3334 }
3335
3336 int
3337 qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
3338 {
3339 int rval;
3340 unsigned long flags;
3341 mbx_cmd_t mc;
3342 mbx_cmd_t *mcp = &mc;
3343 struct device_reg_25xxmq __iomem *reg;
3344 struct qla_hw_data *ha = vha->hw;
3345
3346 ql_dbg(ql_dbg_mbx, vha, 0x10d6, "Entered %s.\n", __func__);
3347
3348 mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3349 mcp->mb[1] = rsp->options;
3350 mcp->mb[2] = MSW(LSD(rsp->dma));
3351 mcp->mb[3] = LSW(LSD(rsp->dma));
3352 mcp->mb[6] = MSW(MSD(rsp->dma));
3353 mcp->mb[7] = LSW(MSD(rsp->dma));
3354 mcp->mb[5] = rsp->length;
3355 mcp->mb[14] = rsp->msix->entry;
3356 mcp->mb[13] = rsp->rid;
3357
3358 reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
3359 QLA_QUE_PAGE * rsp->id);
3360
3361 mcp->mb[4] = rsp->id;
3362 /* que in ptr index */
3363 mcp->mb[8] = 0;
3364 /* que out ptr index */
3365 mcp->mb[9] = 0;
3366 mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
3367 |MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3368 mcp->in_mb = MBX_0;
3369 mcp->flags = MBX_DMA_OUT;
3370 mcp->tov = 60;
3371
3372 spin_lock_irqsave(&ha->hardware_lock, flags);
3373 if (!(rsp->options & BIT_0)) {
3374 WRT_REG_DWORD(&reg->rsp_q_out, 0);
3375 WRT_REG_DWORD(&reg->rsp_q_in, 0);
3376 }
3377
3378 spin_unlock_irqrestore(&ha->hardware_lock, flags);
3379
3380 rval = qla2x00_mailbox_command(vha, mcp);
3381 if (rval != QLA_SUCCESS) {
3382 ql_dbg(ql_dbg_mbx, vha, 0x10d7,
3383 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3384 } else {
3385 ql_dbg(ql_dbg_mbx, vha, 0x10d8, "Done %s.\n", __func__);
3386 }
3387
3388 return rval;
3389 }
3390
3391 int
3392 qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
3393 {
3394 int rval;
3395 mbx_cmd_t mc;
3396 mbx_cmd_t *mcp = &mc;
3397
3398 ql_dbg(ql_dbg_mbx, vha, 0x10d9, "Entered %s.\n", __func__);
3399
3400 mcp->mb[0] = MBC_IDC_ACK;
3401 memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
3402 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3403 mcp->in_mb = MBX_0;
3404 mcp->tov = MBX_TOV_SECONDS;
3405 mcp->flags = 0;
3406 rval = qla2x00_mailbox_command(vha, mcp);
3407
3408 if (rval != QLA_SUCCESS) {
3409 ql_dbg(ql_dbg_mbx, vha, 0x10da,
3410 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3411 } else {
3412 ql_dbg(ql_dbg_mbx, vha, 0x10db, "Done %s.\n", __func__);
3413 }
3414
3415 return rval;
3416 }
3417
3418 int
3419 qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
3420 {
3421 int rval;
3422 mbx_cmd_t mc;
3423 mbx_cmd_t *mcp = &mc;
3424
3425 ql_dbg(ql_dbg_mbx, vha, 0x10dc, "Entered %s.\n", __func__);
3426
3427 if (!IS_QLA81XX(vha->hw))
3428 return QLA_FUNCTION_FAILED;
3429
3430 mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3431 mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
3432 mcp->out_mb = MBX_1|MBX_0;
3433 mcp->in_mb = MBX_1|MBX_0;
3434 mcp->tov = MBX_TOV_SECONDS;
3435 mcp->flags = 0;
3436 rval = qla2x00_mailbox_command(vha, mcp);
3437
3438 if (rval != QLA_SUCCESS) {
3439 ql_dbg(ql_dbg_mbx, vha, 0x10dd,
3440 "Failed=%x mb[0]=%x mb[1]=%x.\n",
3441 rval, mcp->mb[0], mcp->mb[1]);
3442 } else {
3443 ql_dbg(ql_dbg_mbx, vha, 0x10de, "Done %s.\n", __func__);
3444 *sector_size = mcp->mb[1];
3445 }
3446
3447 return rval;
3448 }
3449
3450 int
3451 qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
3452 {
3453 int rval;
3454 mbx_cmd_t mc;
3455 mbx_cmd_t *mcp = &mc;
3456
3457 if (!IS_QLA81XX(vha->hw))
3458 return QLA_FUNCTION_FAILED;
3459
3460 ql_dbg(ql_dbg_mbx, vha, 0x10df, "Entered %s.\n", __func__);
3461
3462 mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3463 mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
3464 FAC_OPT_CMD_WRITE_PROTECT;
3465 mcp->out_mb = MBX_1|MBX_0;
3466 mcp->in_mb = MBX_1|MBX_0;
3467 mcp->tov = MBX_TOV_SECONDS;
3468 mcp->flags = 0;
3469 rval = qla2x00_mailbox_command(vha, mcp);
3470
3471 if (rval != QLA_SUCCESS) {
3472 ql_dbg(ql_dbg_mbx, vha, 0x10e0,
3473 "Failed=%x mb[0]=%x mb[1]=%x.\n",
3474 rval, mcp->mb[0], mcp->mb[1]);
3475 } else {
3476 ql_dbg(ql_dbg_mbx, vha, 0x10e1, "Done %s.\n", __func__);
3477 }
3478
3479 return rval;
3480 }
3481
3482 int
3483 qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
3484 {
3485 int rval;
3486 mbx_cmd_t mc;
3487 mbx_cmd_t *mcp = &mc;
3488
3489 if (!IS_QLA81XX(vha->hw))
3490 return QLA_FUNCTION_FAILED;
3491
3492 ql_dbg(ql_dbg_mbx, vha, 0x10e2, "Entered %s.\n", __func__);
3493
3494 mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
3495 mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
3496 mcp->mb[2] = LSW(start);
3497 mcp->mb[3] = MSW(start);
3498 mcp->mb[4] = LSW(finish);
3499 mcp->mb[5] = MSW(finish);
3500 mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3501 mcp->in_mb = MBX_2|MBX_1|MBX_0;
3502 mcp->tov = MBX_TOV_SECONDS;
3503 mcp->flags = 0;
3504 rval = qla2x00_mailbox_command(vha, mcp);
3505
3506 if (rval != QLA_SUCCESS) {
3507 ql_dbg(ql_dbg_mbx, vha, 0x10e3,
3508 "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
3509 rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
3510 } else {
3511 ql_dbg(ql_dbg_mbx, vha, 0x10e4, "Done %s.\n", __func__);
3512 }
3513
3514 return rval;
3515 }
3516
3517 int
3518 qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
3519 {
3520 int rval = 0;
3521 mbx_cmd_t mc;
3522 mbx_cmd_t *mcp = &mc;
3523
3524 ql_dbg(ql_dbg_mbx, vha, 0x10e5, "Entered %s.\n", __func__);
3525
3526 mcp->mb[0] = MBC_RESTART_MPI_FW;
3527 mcp->out_mb = MBX_0;
3528 mcp->in_mb = MBX_0|MBX_1;
3529 mcp->tov = MBX_TOV_SECONDS;
3530 mcp->flags = 0;
3531 rval = qla2x00_mailbox_command(vha, mcp);
3532
3533 if (rval != QLA_SUCCESS) {
3534 ql_dbg(ql_dbg_mbx, vha, 0x10e6,
3535 "Failed=%x mb[0]=%x mb[1]=%x.\n",
3536 rval, mcp->mb[0], mcp->mb[1]);
3537 } else {
3538 ql_dbg(ql_dbg_mbx, vha, 0x10e7, "Done %s.\n", __func__);
3539 }
3540
3541 return rval;
3542 }
3543
3544 int
3545 qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
3546 uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
3547 {
3548 int rval;
3549 mbx_cmd_t mc;
3550 mbx_cmd_t *mcp = &mc;
3551 struct qla_hw_data *ha = vha->hw;
3552
3553 ql_dbg(ql_dbg_mbx, vha, 0x10e8, "Entered %s.\n", __func__);
3554
3555 if (!IS_FWI2_CAPABLE(ha))
3556 return QLA_FUNCTION_FAILED;
3557
3558 if (len == 1)
3559 opt |= BIT_0;
3560
3561 mcp->mb[0] = MBC_READ_SFP;
3562 mcp->mb[1] = dev;
3563 mcp->mb[2] = MSW(sfp_dma);
3564 mcp->mb[3] = LSW(sfp_dma);
3565 mcp->mb[6] = MSW(MSD(sfp_dma));
3566 mcp->mb[7] = LSW(MSD(sfp_dma));
3567 mcp->mb[8] = len;
3568 mcp->mb[9] = off;
3569 mcp->mb[10] = opt;
3570 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3571 mcp->in_mb = MBX_1|MBX_0;
3572 mcp->tov = MBX_TOV_SECONDS;
3573 mcp->flags = 0;
3574 rval = qla2x00_mailbox_command(vha, mcp);
3575
3576 if (opt & BIT_0)
3577 *sfp = mcp->mb[1];
3578
3579 if (rval != QLA_SUCCESS) {
3580 ql_dbg(ql_dbg_mbx, vha, 0x10e9,
3581 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3582 } else {
3583 ql_dbg(ql_dbg_mbx, vha, 0x10ea, "Done %s.\n", __func__);
3584 }
3585
3586 return rval;
3587 }
3588
3589 int
3590 qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
3591 uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
3592 {
3593 int rval;
3594 mbx_cmd_t mc;
3595 mbx_cmd_t *mcp = &mc;
3596 struct qla_hw_data *ha = vha->hw;
3597
3598 ql_dbg(ql_dbg_mbx, vha, 0x10eb, "Entered %s.\n", __func__);
3599
3600 if (!IS_FWI2_CAPABLE(ha))
3601 return QLA_FUNCTION_FAILED;
3602
3603 if (len == 1)
3604 opt |= BIT_0;
3605
3606 if (opt & BIT_0)
3607 len = *sfp;
3608
3609 mcp->mb[0] = MBC_WRITE_SFP;
3610 mcp->mb[1] = dev;
3611 mcp->mb[2] = MSW(sfp_dma);
3612 mcp->mb[3] = LSW(sfp_dma);
3613 mcp->mb[6] = MSW(MSD(sfp_dma));
3614 mcp->mb[7] = LSW(MSD(sfp_dma));
3615 mcp->mb[8] = len;
3616 mcp->mb[9] = off;
3617 mcp->mb[10] = opt;
3618 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3619 mcp->in_mb = MBX_1|MBX_0;
3620 mcp->tov = MBX_TOV_SECONDS;
3621 mcp->flags = 0;
3622 rval = qla2x00_mailbox_command(vha, mcp);
3623
3624 if (rval != QLA_SUCCESS) {
3625 ql_dbg(ql_dbg_mbx, vha, 0x10ec,
3626 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3627 } else {
3628 ql_dbg(ql_dbg_mbx, vha, 0x10ed, "Done %s.\n", __func__);
3629 }
3630
3631 return rval;
3632 }
3633
3634 int
3635 qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
3636 uint16_t size_in_bytes, uint16_t *actual_size)
3637 {
3638 int rval;
3639 mbx_cmd_t mc;
3640 mbx_cmd_t *mcp = &mc;
3641
3642 ql_dbg(ql_dbg_mbx, vha, 0x10ee, "Entered %s.\n", __func__);
3643
3644 if (!IS_QLA8XXX_TYPE(vha->hw))
3645 return QLA_FUNCTION_FAILED;
3646
3647 mcp->mb[0] = MBC_GET_XGMAC_STATS;
3648 mcp->mb[2] = MSW(stats_dma);
3649 mcp->mb[3] = LSW(stats_dma);
3650 mcp->mb[6] = MSW(MSD(stats_dma));
3651 mcp->mb[7] = LSW(MSD(stats_dma));
3652 mcp->mb[8] = size_in_bytes >> 2;
3653 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
3654 mcp->in_mb = MBX_2|MBX_1|MBX_0;
3655 mcp->tov = MBX_TOV_SECONDS;
3656 mcp->flags = 0;
3657 rval = qla2x00_mailbox_command(vha, mcp);
3658
3659 if (rval != QLA_SUCCESS) {
3660 ql_dbg(ql_dbg_mbx, vha, 0x10ef,
3661 "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
3662 rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
3663 } else {
3664 ql_dbg(ql_dbg_mbx, vha, 0x10f0, "Done %s.\n", __func__);
3665
3666
3667 *actual_size = mcp->mb[2] << 2;
3668 }
3669
3670 return rval;
3671 }
3672
3673 int
3674 qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
3675 uint16_t size)
3676 {
3677 int rval;
3678 mbx_cmd_t mc;
3679 mbx_cmd_t *mcp = &mc;
3680
3681 ql_dbg(ql_dbg_mbx, vha, 0x10f1, "Entered %s.\n", __func__);
3682
3683 if (!IS_QLA8XXX_TYPE(vha->hw))
3684 return QLA_FUNCTION_FAILED;
3685
3686 mcp->mb[0] = MBC_GET_DCBX_PARAMS;
3687 mcp->mb[1] = 0;
3688 mcp->mb[2] = MSW(tlv_dma);
3689 mcp->mb[3] = LSW(tlv_dma);
3690 mcp->mb[6] = MSW(MSD(tlv_dma));
3691 mcp->mb[7] = LSW(MSD(tlv_dma));
3692 mcp->mb[8] = size;
3693 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3694 mcp->in_mb = MBX_2|MBX_1|MBX_0;
3695 mcp->tov = MBX_TOV_SECONDS;
3696 mcp->flags = 0;
3697 rval = qla2x00_mailbox_command(vha, mcp);
3698
3699 if (rval != QLA_SUCCESS) {
3700 ql_dbg(ql_dbg_mbx, vha, 0x10f2,
3701 "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
3702 rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
3703 } else {
3704 ql_dbg(ql_dbg_mbx, vha, 0x10f3, "Done %s.\n", __func__);
3705 }
3706
3707 return rval;
3708 }
3709
3710 int
3711 qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
3712 {
3713 int rval;
3714 mbx_cmd_t mc;
3715 mbx_cmd_t *mcp = &mc;
3716
3717 ql_dbg(ql_dbg_mbx, vha, 0x10f4, "Entered %s.\n", __func__);
3718
3719 if (!IS_FWI2_CAPABLE(vha->hw))
3720 return QLA_FUNCTION_FAILED;
3721
3722 mcp->mb[0] = MBC_READ_RAM_EXTENDED;
3723 mcp->mb[1] = LSW(risc_addr);
3724 mcp->mb[8] = MSW(risc_addr);
3725 mcp->out_mb = MBX_8|MBX_1|MBX_0;
3726 mcp->in_mb = MBX_3|MBX_2|MBX_0;
3727 mcp->tov = 30;
3728 mcp->flags = 0;
3729 rval = qla2x00_mailbox_command(vha, mcp);
3730 if (rval != QLA_SUCCESS) {
3731 ql_dbg(ql_dbg_mbx, vha, 0x10f5,
3732 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3733 } else {
3734 ql_dbg(ql_dbg_mbx, vha, 0x10f6, "Done %s.\n", __func__);
3735 *data = mcp->mb[3] << 16 | mcp->mb[2];
3736 }
3737
3738 return rval;
3739 }
3740
3741 int
3742 qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
3743 uint16_t *mresp)
3744 {
3745 int rval;
3746 mbx_cmd_t mc;
3747 mbx_cmd_t *mcp = &mc;
3748 uint32_t iter_cnt = 0x1;
3749
3750 ql_dbg(ql_dbg_mbx, vha, 0x10f7, "Entered %s.\n", __func__);
3751
3752 memset(mcp->mb, 0 , sizeof(mcp->mb));
3753 mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
3754 mcp->mb[1] = mreq->options | BIT_6; // BIT_6 specifies 64 bit addressing
3755
3756 /* transfer count */
3757 mcp->mb[10] = LSW(mreq->transfer_size);
3758 mcp->mb[11] = MSW(mreq->transfer_size);
3759
3760 /* send data address */
3761 mcp->mb[14] = LSW(mreq->send_dma);
3762 mcp->mb[15] = MSW(mreq->send_dma);
3763 mcp->mb[20] = LSW(MSD(mreq->send_dma));
3764 mcp->mb[21] = MSW(MSD(mreq->send_dma));
3765
3766 /* receive data address */
3767 mcp->mb[16] = LSW(mreq->rcv_dma);
3768 mcp->mb[17] = MSW(mreq->rcv_dma);
3769 mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
3770 mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
3771
3772 /* Iteration count */
3773 mcp->mb[18] = LSW(iter_cnt);
3774 mcp->mb[19] = MSW(iter_cnt);
3775
3776 mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
3777 MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
3778 if (IS_QLA8XXX_TYPE(vha->hw))
3779 mcp->out_mb |= MBX_2;
3780 mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
3781
3782 mcp->buf_size = mreq->transfer_size;
3783 mcp->tov = MBX_TOV_SECONDS;
3784 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3785
3786 rval = qla2x00_mailbox_command(vha, mcp);
3787
3788 if (rval != QLA_SUCCESS) {
3789 ql_dbg(ql_dbg_mbx, vha, 0x10f8,
3790 "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
3791 "mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
3792 mcp->mb[3], mcp->mb[18], mcp->mb[19]);
3793 } else {
3794 ql_dbg(ql_dbg_mbx, vha, 0x10f9, "Done %s.\n", __func__);
3795 }
3796
3797 /* Copy mailbox information */
3798 memcpy( mresp, mcp->mb, 64);
3799 return rval;
3800 }
3801
3802 int
3803 qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
3804 uint16_t *mresp)
3805 {
3806 int rval;
3807 mbx_cmd_t mc;
3808 mbx_cmd_t *mcp = &mc;
3809 struct qla_hw_data *ha = vha->hw;
3810
3811 ql_dbg(ql_dbg_mbx, vha, 0x10fa, "Entered %s.\n", __func__);
3812
3813 memset(mcp->mb, 0 , sizeof(mcp->mb));
3814 mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
3815 mcp->mb[1] = mreq->options | BIT_6; /* BIT_6 specifies 64bit address */
3816 if (IS_QLA8XXX_TYPE(ha)) {
3817 mcp->mb[1] |= BIT_15;
3818 mcp->mb[2] = vha->fcoe_fcf_idx;
3819 }
3820 mcp->mb[16] = LSW(mreq->rcv_dma);
3821 mcp->mb[17] = MSW(mreq->rcv_dma);
3822 mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
3823 mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
3824
3825 mcp->mb[10] = LSW(mreq->transfer_size);
3826
3827 mcp->mb[14] = LSW(mreq->send_dma);
3828 mcp->mb[15] = MSW(mreq->send_dma);
3829 mcp->mb[20] = LSW(MSD(mreq->send_dma));
3830 mcp->mb[21] = MSW(MSD(mreq->send_dma));
3831
3832 mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
3833 MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
3834 if (IS_QLA8XXX_TYPE(ha))
3835 mcp->out_mb |= MBX_2;
3836
3837 mcp->in_mb = MBX_0;
3838 if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA8XXX_TYPE(ha))
3839 mcp->in_mb |= MBX_1;
3840 if (IS_QLA8XXX_TYPE(ha))
3841 mcp->in_mb |= MBX_3;
3842
3843 mcp->tov = MBX_TOV_SECONDS;
3844 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3845 mcp->buf_size = mreq->transfer_size;
3846
3847 rval = qla2x00_mailbox_command(vha, mcp);
3848
3849 if (rval != QLA_SUCCESS) {
3850 ql_dbg(ql_dbg_mbx, vha, 0x10fb,
3851 "Failed=%x mb[0]=%x mb[1]=%x.\n",
3852 rval, mcp->mb[0], mcp->mb[1]);
3853 } else {
3854 ql_dbg(ql_dbg_mbx, vha, 0x10fc, "Done %s.\n", __func__);
3855 }
3856
3857 /* Copy mailbox information */
3858 memcpy(mresp, mcp->mb, 64);
3859 return rval;
3860 }
3861
3862 int
3863 qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
3864 {
3865 int rval;
3866 mbx_cmd_t mc;
3867 mbx_cmd_t *mcp = &mc;
3868
3869 ql_dbg(ql_dbg_mbx, vha, 0x10fd,
3870 "Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
3871
3872 mcp->mb[0] = MBC_ISP84XX_RESET;
3873 mcp->mb[1] = enable_diagnostic;
3874 mcp->out_mb = MBX_1|MBX_0;
3875 mcp->in_mb = MBX_1|MBX_0;
3876 mcp->tov = MBX_TOV_SECONDS;
3877 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
3878 rval = qla2x00_mailbox_command(vha, mcp);
3879
3880 if (rval != QLA_SUCCESS)
3881 ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
3882 else
3883 ql_dbg(ql_dbg_mbx, vha, 0x10ff, "Done %s.\n", __func__);
3884
3885 return rval;
3886 }
3887
3888 int
3889 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
3890 {
3891 int rval;
3892 mbx_cmd_t mc;
3893 mbx_cmd_t *mcp = &mc;
3894
3895 ql_dbg(ql_dbg_mbx, vha, 0x1100, "Entered %s.\n", __func__);
3896
3897 if (!IS_FWI2_CAPABLE(vha->hw))
3898 return QLA_FUNCTION_FAILED;
3899
3900 mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
3901 mcp->mb[1] = LSW(risc_addr);
3902 mcp->mb[2] = LSW(data);
3903 mcp->mb[3] = MSW(data);
3904 mcp->mb[8] = MSW(risc_addr);
3905 mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
3906 mcp->in_mb = MBX_0;
3907 mcp->tov = 30;
3908 mcp->flags = 0;
3909 rval = qla2x00_mailbox_command(vha, mcp);
3910 if (rval != QLA_SUCCESS) {
3911 ql_dbg(ql_dbg_mbx, vha, 0x1101,
3912 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
3913 } else {
3914 ql_dbg(ql_dbg_mbx, vha, 0x1102, "Done %s.\n", __func__);
3915 }
3916
3917 return rval;
3918 }
3919
3920 int
3921 qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
3922 {
3923 int rval;
3924 uint32_t stat, timer;
3925 uint16_t mb0 = 0;
3926 struct qla_hw_data *ha = vha->hw;
3927 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
3928
3929 rval = QLA_SUCCESS;
3930
3931 ql_dbg(ql_dbg_mbx, vha, 0x1103, "Entered %s.\n", __func__);
3932
3933 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
3934
3935 /* Write the MBC data to the registers */
3936 WRT_REG_WORD(&reg->mailbox0, MBC_WRITE_MPI_REGISTER);
3937 WRT_REG_WORD(&reg->mailbox1, mb[0]);
3938 WRT_REG_WORD(&reg->mailbox2, mb[1]);
3939 WRT_REG_WORD(&reg->mailbox3, mb[2]);
3940 WRT_REG_WORD(&reg->mailbox4, mb[3]);
3941
3942 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
3943
3944 /* Poll for MBC interrupt */
3945 for (timer = 6000000; timer; timer--) {
3946 /* Check for pending interrupts. */
3947 stat = RD_REG_DWORD(&reg->host_status);
3948 if (stat & HSRX_RISC_INT) {
3949 stat &= 0xff;
3950
3951 if (stat == 0x1 || stat == 0x2 ||
3952 stat == 0x10 || stat == 0x11) {
3953 set_bit(MBX_INTERRUPT,
3954 &ha->mbx_cmd_flags);
3955 mb0 = RD_REG_WORD(&reg->mailbox0);
3956 WRT_REG_DWORD(&reg->hccr,
3957 HCCRX_CLR_RISC_INT);
3958 RD_REG_DWORD(&reg->hccr);
3959 break;
3960 }
3961 }
3962 udelay(5);
3963 }
3964
3965 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
3966 rval = mb0 & MBS_MASK;
3967 else
3968 rval = QLA_FUNCTION_FAILED;
3969
3970 if (rval != QLA_SUCCESS) {
3971 ql_dbg(ql_dbg_mbx, vha, 0x1104,
3972 "Failed=%x mb[0]=%x.\n", rval, mb[0]);
3973 } else {
3974 ql_dbg(ql_dbg_mbx, vha, 0x1105, "Done %s.\n", __func__);
3975 }
3976
3977 return rval;
3978 }
3979 int
3980 qla2x00_get_data_rate(scsi_qla_host_t *vha)
3981 {
3982 int rval;
3983 mbx_cmd_t mc;
3984 mbx_cmd_t *mcp = &mc;
3985 struct qla_hw_data *ha = vha->hw;
3986
3987 ql_dbg(ql_dbg_mbx, vha, 0x1106, "Entered %s.\n", __func__);
3988
3989 if (!IS_FWI2_CAPABLE(ha))
3990 return QLA_FUNCTION_FAILED;
3991
3992 mcp->mb[0] = MBC_DATA_RATE;
3993 mcp->mb[1] = 0;
3994 mcp->out_mb = MBX_1|MBX_0;
3995 mcp->in_mb = MBX_2|MBX_1|MBX_0;
3996 mcp->tov = MBX_TOV_SECONDS;
3997 mcp->flags = 0;
3998 rval = qla2x00_mailbox_command(vha, mcp);
3999 if (rval != QLA_SUCCESS) {
4000 ql_dbg(ql_dbg_mbx, vha, 0x1107,
4001 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4002 } else {
4003 ql_dbg(ql_dbg_mbx, vha, 0x1108, "Done %s.\n", __func__);
4004 if (mcp->mb[1] != 0x7)
4005 ha->link_data_rate = mcp->mb[1];
4006 }
4007
4008 return rval;
4009 }
4010
4011 int
4012 qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
4013 {
4014 int rval;
4015 mbx_cmd_t mc;
4016 mbx_cmd_t *mcp = &mc;
4017 struct qla_hw_data *ha = vha->hw;
4018
4019 ql_dbg(ql_dbg_mbx, vha, 0x1109, "Entered %s.\n", __func__);
4020
4021 if (!IS_QLA81XX(ha))
4022 return QLA_FUNCTION_FAILED;
4023 mcp->mb[0] = MBC_GET_PORT_CONFIG;
4024 mcp->out_mb = MBX_0;
4025 mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4026 mcp->tov = MBX_TOV_SECONDS;
4027 mcp->flags = 0;
4028
4029 rval = qla2x00_mailbox_command(vha, mcp);
4030
4031 if (rval != QLA_SUCCESS) {
4032 ql_dbg(ql_dbg_mbx, vha, 0x110a,
4033 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4034 } else {
4035 /* Copy all bits to preserve original value */
4036 memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
4037
4038 ql_dbg(ql_dbg_mbx, vha, 0x110b, "Done %s.\n", __func__);
4039 }
4040 return rval;
4041 }
4042
4043 int
4044 qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
4045 {
4046 int rval;
4047 mbx_cmd_t mc;
4048 mbx_cmd_t *mcp = &mc;
4049
4050 ql_dbg(ql_dbg_mbx, vha, 0x110c, "Entered %s.\n", __func__);
4051
4052 mcp->mb[0] = MBC_SET_PORT_CONFIG;
4053 /* Copy all bits to preserve original setting */
4054 memcpy(&mcp->mb[1], mb, sizeof(uint16_t) * 4);
4055 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4056 mcp->in_mb = MBX_0;
4057 mcp->tov = MBX_TOV_SECONDS;
4058 mcp->flags = 0;
4059 rval = qla2x00_mailbox_command(vha, mcp);
4060
4061 if (rval != QLA_SUCCESS) {
4062 ql_dbg(ql_dbg_mbx, vha, 0x110d,
4063 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4064 } else
4065 ql_dbg(ql_dbg_mbx, vha, 0x110e, "Done %s.\n", __func__);
4066
4067 return rval;
4068 }
4069
4070
4071 int
4072 qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
4073 uint16_t *mb)
4074 {
4075 int rval;
4076 mbx_cmd_t mc;
4077 mbx_cmd_t *mcp = &mc;
4078 struct qla_hw_data *ha = vha->hw;
4079
4080 ql_dbg(ql_dbg_mbx, vha, 0x110f, "Entered %s.\n", __func__);
4081
4082 if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
4083 return QLA_FUNCTION_FAILED;
4084
4085 mcp->mb[0] = MBC_PORT_PARAMS;
4086 mcp->mb[1] = loop_id;
4087 if (ha->flags.fcp_prio_enabled)
4088 mcp->mb[2] = BIT_1;
4089 else
4090 mcp->mb[2] = BIT_2;
4091 mcp->mb[4] = priority & 0xf;
4092 mcp->mb[9] = vha->vp_idx;
4093 mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4094 mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
4095 mcp->tov = 30;
4096 mcp->flags = 0;
4097 rval = qla2x00_mailbox_command(vha, mcp);
4098 if (mb != NULL) {
4099 mb[0] = mcp->mb[0];
4100 mb[1] = mcp->mb[1];
4101 mb[3] = mcp->mb[3];
4102 mb[4] = mcp->mb[4];
4103 }
4104
4105 if (rval != QLA_SUCCESS) {
4106 ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
4107 } else {
4108 ql_dbg(ql_dbg_mbx, vha, 0x10cc, "Done %s.\n", __func__);
4109 }
4110
4111 return rval;
4112 }
4113
4114 int
4115 qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
4116 {
4117 int rval;
4118 uint8_t byte;
4119 struct qla_hw_data *ha = vha->hw;
4120
4121 ql_dbg(ql_dbg_mbx, vha, 0x10ca, "Entered %s.\n", __func__);
4122
4123 /* Integer part */
4124 rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x01, 1, BIT_13|BIT_0);
4125 if (rval != QLA_SUCCESS) {
4126 ql_dbg(ql_dbg_mbx, vha, 0x10c9, "Failed=%x.\n", rval);
4127 ha->flags.thermal_supported = 0;
4128 goto fail;
4129 }
4130 *temp = byte;
4131
4132 /* Fraction part */
4133 rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x10, 1, BIT_13|BIT_0);
4134 if (rval != QLA_SUCCESS) {
4135 ql_dbg(ql_dbg_mbx, vha, 0x1019, "Failed=%x.\n", rval);
4136 ha->flags.thermal_supported = 0;
4137 goto fail;
4138 }
4139 *frac = (byte >> 6) * 25;
4140
4141 ql_dbg(ql_dbg_mbx, vha, 0x1018, "Done %s.\n", __func__);
4142 fail:
4143 return rval;
4144 }
4145
4146 int
4147 qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
4148 {
4149 int rval;
4150 struct qla_hw_data *ha = vha->hw;
4151 mbx_cmd_t mc;
4152 mbx_cmd_t *mcp = &mc;
4153
4154 ql_dbg(ql_dbg_mbx, vha, 0x1017, "Entered %s.\n", __func__);
4155
4156 if (!IS_FWI2_CAPABLE(ha))
4157 return QLA_FUNCTION_FAILED;
4158
4159 memset(mcp, 0, sizeof(mbx_cmd_t));
4160 mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
4161 mcp->mb[1] = 1;
4162
4163 mcp->out_mb = MBX_1|MBX_0;
4164 mcp->in_mb = MBX_0;
4165 mcp->tov = 30;
4166 mcp->flags = 0;
4167
4168 rval = qla2x00_mailbox_command(vha, mcp);
4169 if (rval != QLA_SUCCESS) {
4170 ql_dbg(ql_dbg_mbx, vha, 0x1016,
4171 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4172 } else {
4173 ql_dbg(ql_dbg_mbx, vha, 0x100e, "Done %s.\n", __func__);
4174 }
4175
4176 return rval;
4177 }
4178
4179 int
4180 qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
4181 {
4182 int rval;
4183 struct qla_hw_data *ha = vha->hw;
4184 mbx_cmd_t mc;
4185 mbx_cmd_t *mcp = &mc;
4186
4187 ql_dbg(ql_dbg_mbx, vha, 0x100d, "Entered %s.\n", __func__);
4188
4189 if (!IS_QLA82XX(ha))
4190 return QLA_FUNCTION_FAILED;
4191
4192 memset(mcp, 0, sizeof(mbx_cmd_t));
4193 mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
4194 mcp->mb[1] = 0;
4195
4196 mcp->out_mb = MBX_1|MBX_0;
4197 mcp->in_mb = MBX_0;
4198 mcp->tov = 30;
4199 mcp->flags = 0;
4200
4201 rval = qla2x00_mailbox_command(vha, mcp);
4202 if (rval != QLA_SUCCESS) {
4203 ql_dbg(ql_dbg_mbx, vha, 0x100c,
4204 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4205 } else {
4206 ql_dbg(ql_dbg_mbx, vha, 0x100b, "Done %s.\n", __func__);
4207 }
4208
4209 return rval;
4210 }
4211
4212 int
4213 qla82xx_md_get_template_size(scsi_qla_host_t *vha)
4214 {
4215 struct qla_hw_data *ha = vha->hw;
4216 mbx_cmd_t mc;
4217 mbx_cmd_t *mcp = &mc;
4218 int rval = QLA_FUNCTION_FAILED;
4219
4220 ql_dbg(ql_dbg_mbx, vha, 0x111f, "Entered %s.\n", __func__);
4221
4222 memset(mcp->mb, 0 , sizeof(mcp->mb));
4223 mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4224 mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4225 mcp->mb[2] = LSW(RQST_TMPLT_SIZE);
4226 mcp->mb[3] = MSW(RQST_TMPLT_SIZE);
4227
4228 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
4229 mcp->in_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
4230 MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4231
4232 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4233 mcp->tov = MBX_TOV_SECONDS;
4234 rval = qla2x00_mailbox_command(vha, mcp);
4235
4236 /* Always copy back return mailbox values. */
4237 if (rval != QLA_SUCCESS) {
4238 ql_dbg(ql_dbg_mbx, vha, 0x1120,
4239 "mailbox command FAILED=0x%x, subcode=%x.\n",
4240 (mcp->mb[1] << 16) | mcp->mb[0],
4241 (mcp->mb[3] << 16) | mcp->mb[2]);
4242 } else {
4243 ql_dbg(ql_dbg_mbx, vha, 0x1121, "Done %s.\n", __func__);
4244 ha->md_template_size = ((mcp->mb[3] << 16) | mcp->mb[2]);
4245 if (!ha->md_template_size) {
4246 ql_dbg(ql_dbg_mbx, vha, 0x1122,
4247 "Null template size obtained.\n");
4248 rval = QLA_FUNCTION_FAILED;
4249 }
4250 }
4251 return rval;
4252 }
4253
4254 int
4255 qla82xx_md_get_template(scsi_qla_host_t *vha)
4256 {
4257 struct qla_hw_data *ha = vha->hw;
4258 mbx_cmd_t mc;
4259 mbx_cmd_t *mcp = &mc;
4260 int rval = QLA_FUNCTION_FAILED;
4261
4262 ql_dbg(ql_dbg_mbx, vha, 0x1123, "Entered %s.\n", __func__);
4263
4264 ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
4265 ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
4266 if (!ha->md_tmplt_hdr) {
4267 ql_log(ql_log_warn, vha, 0x1124,
4268 "Unable to allocate memory for Minidump template.\n");
4269 return rval;
4270 }
4271
4272 memset(mcp->mb, 0 , sizeof(mcp->mb));
4273 mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4274 mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
4275 mcp->mb[2] = LSW(RQST_TMPLT);
4276 mcp->mb[3] = MSW(RQST_TMPLT);
4277 mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma));
4278 mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma));
4279 mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma));
4280 mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma));
4281 mcp->mb[8] = LSW(ha->md_template_size);
4282 mcp->mb[9] = MSW(ha->md_template_size);
4283
4284 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
4285 mcp->tov = MBX_TOV_SECONDS;
4286 mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
4287 MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4288 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
4289 rval = qla2x00_mailbox_command(vha, mcp);
4290
4291 if (rval != QLA_SUCCESS) {
4292 ql_dbg(ql_dbg_mbx, vha, 0x1125,
4293 "mailbox command FAILED=0x%x, subcode=%x.\n",
4294 ((mcp->mb[1] << 16) | mcp->mb[0]),
4295 ((mcp->mb[3] << 16) | mcp->mb[2]));
4296 } else
4297 ql_dbg(ql_dbg_mbx, vha, 0x1126, "Done %s.\n", __func__);
4298 return rval;
4299 }
4300
4301 int
4302 qla82xx_mbx_beacon_ctl(scsi_qla_host_t *vha, int enable)
4303 {
4304 int rval;
4305 struct qla_hw_data *ha = vha->hw;
4306 mbx_cmd_t mc;
4307 mbx_cmd_t *mcp = &mc;
4308
4309 if (!IS_QLA82XX(ha))
4310 return QLA_FUNCTION_FAILED;
4311
4312 ql_dbg(ql_dbg_mbx, vha, 0x1127,
4313 "Entered %s.\n", __func__);
4314
4315 memset(mcp, 0, sizeof(mbx_cmd_t));
4316 mcp->mb[0] = MBC_SET_LED_CONFIG;
4317 if (enable)
4318 mcp->mb[7] = 0xE;
4319 else
4320 mcp->mb[7] = 0xD;
4321
4322 mcp->out_mb = MBX_7|MBX_0;
4323 mcp->in_mb = MBX_0;
4324 mcp->tov = 30;
4325 mcp->flags = 0;
4326
4327 rval = qla2x00_mailbox_command(vha, mcp);
4328 if (rval != QLA_SUCCESS) {
4329 ql_dbg(ql_dbg_mbx, vha, 0x1128,
4330 "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
4331 } else {
4332 ql_dbg(ql_dbg_mbx, vha, 0x1129,
4333 "Done %s.\n", __func__);
4334 }
4335
4336 return rval;
4337 }