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