Merge master.kernel.org:/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
[linux-2.6] / drivers / scsi / qla2xxx / qla_mbx.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2005 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
11 static void
12 qla2x00_mbx_sem_timeout(unsigned long data)
13 {
14         struct semaphore        *sem_ptr = (struct semaphore *)data;
15
16         DEBUG11(printk("qla2x00_sem_timeout: entered.\n"));
17
18         if (sem_ptr != NULL) {
19                 up(sem_ptr);
20         }
21
22         DEBUG11(printk("qla2x00_mbx_sem_timeout: exiting.\n"));
23 }
24
25 /*
26  * qla2x00_mailbox_command
27  *      Issue mailbox command and waits for completion.
28  *
29  * Input:
30  *      ha = adapter block pointer.
31  *      mcp = driver internal mbx struct pointer.
32  *
33  * Output:
34  *      mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
35  *
36  * Returns:
37  *      0 : QLA_SUCCESS = cmd performed success
38  *      1 : QLA_FUNCTION_FAILED   (error encountered)
39  *      6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
40  *
41  * Context:
42  *      Kernel context.
43  */
44 static int
45 qla2x00_mailbox_command(scsi_qla_host_t *ha, mbx_cmd_t *mcp)
46 {
47         int             rval;
48         unsigned long    flags = 0;
49         device_reg_t __iomem *reg = ha->iobase;
50         struct timer_list       tmp_intr_timer;
51         uint8_t         abort_active;
52         uint8_t         io_lock_on = ha->flags.init_done;
53         uint16_t        command;
54         uint16_t        *iptr;
55         uint16_t __iomem *optr;
56         uint32_t        cnt;
57         uint32_t        mboxes;
58         unsigned long   wait_time;
59
60         rval = QLA_SUCCESS;
61         abort_active = test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
62
63         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
64
65         /*
66          * Wait for active mailbox commands to finish by waiting at most tov
67          * seconds. This is to serialize actual issuing of mailbox cmds during
68          * non ISP abort time.
69          */
70         if (!abort_active) {
71                 if (qla2x00_down_timeout(&ha->mbx_cmd_sem, mcp->tov * HZ)) {
72                         /* Timeout occurred. Return error. */
73                         DEBUG2_3_11(printk("%s(%ld): cmd access timeout. "
74                             "Exiting.\n", __func__, ha->host_no));
75                         return QLA_FUNCTION_TIMEOUT;
76                 }
77         }
78
79         ha->flags.mbox_busy = 1;
80         /* Save mailbox command for debug */
81         ha->mcp = mcp;
82
83         DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n",
84             ha->host_no, mcp->mb[0]));
85
86         spin_lock_irqsave(&ha->hardware_lock, flags);
87
88         /* Load mailbox registers. */
89         if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
90                 optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
91         else
92                 optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
93
94         iptr = mcp->mb;
95         command = mcp->mb[0];
96         mboxes = mcp->out_mb;
97
98         for (cnt = 0; cnt < ha->mbx_count; cnt++) {
99                 if (IS_QLA2200(ha) && cnt == 8)
100                         optr =
101                             (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 8);
102                 if (mboxes & BIT_0)
103                         WRT_REG_WORD(optr, *iptr);
104
105                 mboxes >>= 1;
106                 optr++;
107                 iptr++;
108         }
109
110 #if defined(QL_DEBUG_LEVEL_1)
111         printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n",
112             __func__, ha->host_no);
113         qla2x00_dump_buffer((uint8_t *)mcp->mb, 16);
114         printk("\n");
115         qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16);
116         printk("\n");
117         qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8);
118         printk("\n");
119         printk("%s(%ld): I/O address = %p.\n", __func__, ha->host_no, optr);
120         qla2x00_dump_regs(ha);
121 #endif
122
123         /* Issue set host interrupt command to send cmd out. */
124         ha->flags.mbox_int = 0;
125         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
126
127         /* Unlock mbx registers and wait for interrupt */
128         DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. "
129             "jiffies=%lx.\n", __func__, ha->host_no, jiffies));
130
131         /* Wait for mbx cmd completion until timeout */
132
133         if (!abort_active && io_lock_on) {
134                 /* sleep on completion semaphore */
135                 DEBUG11(printk("%s(%ld): INTERRUPT MODE. Initializing timer.\n",
136                     __func__, ha->host_no));
137
138                 init_timer(&tmp_intr_timer);
139                 tmp_intr_timer.data = (unsigned long)&ha->mbx_intr_sem;
140                 tmp_intr_timer.expires = jiffies + mcp->tov * HZ;
141                 tmp_intr_timer.function =
142                     (void (*)(unsigned long))qla2x00_mbx_sem_timeout;
143
144                 DEBUG11(printk("%s(%ld): Adding timer.\n", __func__,
145                     ha->host_no));
146                 add_timer(&tmp_intr_timer);
147
148                 DEBUG11(printk("%s(%ld): going to unlock & sleep. "
149                     "time=0x%lx.\n", __func__, ha->host_no, jiffies));
150
151                 set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
152
153                 if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
154                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
155                 else
156                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
157                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
158
159                 /* Wait for either the timer to expire
160                  * or the mbox completion interrupt
161                  */
162                 down(&ha->mbx_intr_sem);
163
164                 DEBUG11(printk("%s(%ld): waking up. time=0x%lx\n", __func__,
165                     ha->host_no, jiffies));
166                 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
167
168                 /* delete the timer */
169                 del_timer(&tmp_intr_timer);
170         } else {
171                 DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__,
172                     ha->host_no, command));
173
174                 if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
175                         WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
176                 else
177                         WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
178                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
179
180                 wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
181                 while (!ha->flags.mbox_int) {
182                         if (time_after(jiffies, wait_time))
183                                 break;
184
185                         /* Check for pending interrupts. */
186                         qla2x00_poll(ha);
187
188                         if (command != MBC_LOAD_RISC_RAM_EXTENDED &&
189                             !ha->flags.mbox_int)
190                                 msleep(10);
191                 } /* while */
192         }
193
194         /* Check whether we timed out */
195         if (ha->flags.mbox_int) {
196                 uint16_t *iptr2;
197
198                 DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__,
199                     ha->host_no, command));
200
201                 /* Got interrupt. Clear the flag. */
202                 ha->flags.mbox_int = 0;
203                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
204
205                 if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
206                         rval = QLA_FUNCTION_FAILED;
207
208                 /* Load return mailbox registers. */
209                 iptr2 = mcp->mb;
210                 iptr = (uint16_t *)&ha->mailbox_out[0];
211                 mboxes = mcp->in_mb;
212                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
213                         if (mboxes & BIT_0)
214                                 *iptr2 = *iptr;
215
216                         mboxes >>= 1;
217                         iptr2++;
218                         iptr++;
219                 }
220         } else {
221
222 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \
223                 defined(QL_DEBUG_LEVEL_11)
224                 uint16_t mb0;
225                 uint32_t ictrl;
226
227                 if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
228                         mb0 = RD_REG_WORD(&reg->isp24.mailbox0);
229                         ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
230                 } else {
231                         mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
232                         ictrl = RD_REG_WORD(&reg->isp.ictrl);
233                 }
234                 printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n",
235                     __func__, ha->host_no, command);
236                 printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__,
237                     ha->host_no, ictrl, jiffies);
238                 printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__,
239                     ha->host_no, mb0);
240                 qla2x00_dump_regs(ha);
241 #endif
242
243                 rval = QLA_FUNCTION_TIMEOUT;
244         }
245
246         ha->flags.mbox_busy = 0;
247
248         /* Clean up */
249         ha->mcp = NULL;
250
251         if (!abort_active) {
252                 DEBUG11(printk("%s(%ld): checking for additional resp "
253                     "interrupt.\n", __func__, ha->host_no));
254
255                 /* polling mode for non isp_abort commands. */
256                 qla2x00_poll(ha);
257         }
258
259         if (rval == QLA_FUNCTION_TIMEOUT &&
260             mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
261                 if (!io_lock_on || (mcp->flags & IOCTL_CMD)) {
262                         /* not in dpc. schedule it for dpc to take over. */
263                         DEBUG(printk("%s(%ld): timeout schedule "
264                             "isp_abort_needed.\n", __func__, ha->host_no));
265                         DEBUG2_3_11(printk("%s(%ld): timeout schedule "
266                             "isp_abort_needed.\n", __func__, ha->host_no));
267                         qla_printk(KERN_WARNING, ha,
268                             "Mailbox command timeout occured. Scheduling ISP "
269                             "abort.\n");
270                         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
271                         qla2xxx_wake_dpc(ha);
272                 } else if (!abort_active) {
273                         /* call abort directly since we are in the DPC thread */
274                         DEBUG(printk("%s(%ld): timeout calling abort_isp\n",
275                             __func__, ha->host_no));
276                         DEBUG2_3_11(printk("%s(%ld): timeout calling "
277                             "abort_isp\n", __func__, ha->host_no));
278                         qla_printk(KERN_WARNING, ha,
279                             "Mailbox command timeout occured. Issuing ISP "
280                             "abort.\n");
281
282                         set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
283                         clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
284                         if (qla2x00_abort_isp(ha)) {
285                                 /* Failed. retry later. */
286                                 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
287                         }
288                         clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
289                         DEBUG(printk("%s(%ld): finished abort_isp\n", __func__,
290                             ha->host_no));
291                         DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n",
292                             __func__, ha->host_no));
293                 }
294         }
295
296         /* Allow next mbx cmd to come in. */
297         if (!abort_active)
298                 up(&ha->mbx_cmd_sem);
299
300         if (rval) {
301                 DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, "
302                     "mbx2=%x, cmd=%x ****\n", __func__, ha->host_no,
303                     mcp->mb[0], mcp->mb[1], mcp->mb[2], command));
304         } else {
305                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
306         }
307
308         return rval;
309 }
310
311 int
312 qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr,
313     uint32_t risc_code_size)
314 {
315         int rval;
316         mbx_cmd_t mc;
317         mbx_cmd_t *mcp = &mc;
318
319         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
320
321         if (MSW(risc_addr) || IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
322                 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
323                 mcp->mb[8] = MSW(risc_addr);
324                 mcp->out_mb = MBX_8|MBX_0;
325         } else {
326                 mcp->mb[0] = MBC_LOAD_RISC_RAM;
327                 mcp->out_mb = MBX_0;
328         }
329         mcp->mb[1] = LSW(risc_addr);
330         mcp->mb[2] = MSW(req_dma);
331         mcp->mb[3] = LSW(req_dma);
332         mcp->mb[6] = MSW(MSD(req_dma));
333         mcp->mb[7] = LSW(MSD(req_dma));
334         mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
335         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
336                 mcp->mb[4] = MSW(risc_code_size);
337                 mcp->mb[5] = LSW(risc_code_size);
338                 mcp->out_mb |= MBX_5|MBX_4;
339         } else {
340                 mcp->mb[4] = LSW(risc_code_size);
341                 mcp->out_mb |= MBX_4;
342         }
343
344         mcp->in_mb = MBX_0;
345         mcp->tov = 30;
346         mcp->flags = 0;
347         rval = qla2x00_mailbox_command(ha, mcp);
348
349         if (rval != QLA_SUCCESS) {
350                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
351                     ha->host_no, rval, mcp->mb[0]));
352         } else {
353                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
354         }
355
356         return rval;
357 }
358
359 /*
360  * qla2x00_execute_fw
361  *     Start adapter firmware.
362  *
363  * Input:
364  *     ha = adapter block pointer.
365  *     TARGET_QUEUE_LOCK must be released.
366  *     ADAPTER_STATE_LOCK must be released.
367  *
368  * Returns:
369  *     qla2x00 local function return status code.
370  *
371  * Context:
372  *     Kernel context.
373  */
374 int
375 qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr)
376 {
377         int rval;
378         mbx_cmd_t mc;
379         mbx_cmd_t *mcp = &mc;
380
381         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
382
383         mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
384         mcp->out_mb = MBX_0;
385         mcp->in_mb = MBX_0;
386         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
387                 mcp->mb[1] = MSW(risc_addr);
388                 mcp->mb[2] = LSW(risc_addr);
389                 mcp->mb[3] = 0;
390                 mcp->out_mb |= MBX_3|MBX_2|MBX_1;
391                 mcp->in_mb |= MBX_1;
392         } else {
393                 mcp->mb[1] = LSW(risc_addr);
394                 mcp->out_mb |= MBX_1;
395                 if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
396                         mcp->mb[2] = 0;
397                         mcp->out_mb |= MBX_2;
398                 }
399         }
400
401         mcp->tov = 30;
402         mcp->flags = 0;
403         rval = qla2x00_mailbox_command(ha, mcp);
404
405         if (rval != QLA_SUCCESS) {
406                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
407                     ha->host_no, rval, mcp->mb[0]));
408         } else {
409                 if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
410                         DEBUG11(printk("%s(%ld): done exchanges=%x.\n",
411                             __func__, ha->host_no, mcp->mb[1]));
412                 } else {
413                         DEBUG11(printk("%s(%ld): done.\n", __func__,
414                             ha->host_no));
415                 }
416         }
417
418         return rval;
419 }
420
421 /*
422  * qla2x00_get_fw_version
423  *      Get firmware version.
424  *
425  * Input:
426  *      ha:             adapter state pointer.
427  *      major:          pointer for major number.
428  *      minor:          pointer for minor number.
429  *      subminor:       pointer for subminor number.
430  *
431  * Returns:
432  *      qla2x00 local function return status code.
433  *
434  * Context:
435  *      Kernel context.
436  */
437 void
438 qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor,
439     uint16_t *subminor, uint16_t *attributes, uint32_t *memory)
440 {
441         int             rval;
442         mbx_cmd_t       mc;
443         mbx_cmd_t       *mcp = &mc;
444
445         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
446
447         mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
448         mcp->out_mb = MBX_0;
449         mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
450         mcp->flags = 0;
451         mcp->tov = 30;
452         rval = qla2x00_mailbox_command(ha, mcp);
453
454         /* Return mailbox data. */
455         *major = mcp->mb[1];
456         *minor = mcp->mb[2];
457         *subminor = mcp->mb[3];
458         *attributes = mcp->mb[6];
459         if (IS_QLA2100(ha) || IS_QLA2200(ha))
460                 *memory = 0x1FFFF;                      /* Defaults to 128KB. */
461         else
462                 *memory = (mcp->mb[5] << 16) | mcp->mb[4];
463
464         if (rval != QLA_SUCCESS) {
465                 /*EMPTY*/
466                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
467                     ha->host_no, rval));
468         } else {
469                 /*EMPTY*/
470                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
471         }
472 }
473
474 /*
475  * qla2x00_get_fw_options
476  *      Set firmware options.
477  *
478  * Input:
479  *      ha = adapter block pointer.
480  *      fwopt = pointer for firmware options.
481  *
482  * Returns:
483  *      qla2x00 local function return status code.
484  *
485  * Context:
486  *      Kernel context.
487  */
488 int
489 qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
490 {
491         int rval;
492         mbx_cmd_t mc;
493         mbx_cmd_t *mcp = &mc;
494
495         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
496
497         mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
498         mcp->out_mb = MBX_0;
499         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
500         mcp->tov = 30;
501         mcp->flags = 0;
502         rval = qla2x00_mailbox_command(ha, mcp);
503
504         if (rval != QLA_SUCCESS) {
505                 /*EMPTY*/
506                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
507                     ha->host_no, rval));
508         } else {
509                 fwopts[0] = mcp->mb[0];
510                 fwopts[1] = mcp->mb[1];
511                 fwopts[2] = mcp->mb[2];
512                 fwopts[3] = mcp->mb[3];
513
514                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
515         }
516
517         return rval;
518 }
519
520
521 /*
522  * qla2x00_set_fw_options
523  *      Set firmware options.
524  *
525  * Input:
526  *      ha = adapter block pointer.
527  *      fwopt = pointer for firmware options.
528  *
529  * Returns:
530  *      qla2x00 local function return status code.
531  *
532  * Context:
533  *      Kernel context.
534  */
535 int
536 qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
537 {
538         int rval;
539         mbx_cmd_t mc;
540         mbx_cmd_t *mcp = &mc;
541
542         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
543
544         mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
545         mcp->mb[1] = fwopts[1];
546         mcp->mb[2] = fwopts[2];
547         mcp->mb[3] = fwopts[3];
548         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
549         mcp->in_mb = MBX_0;
550         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
551                 mcp->in_mb |= MBX_1;
552         } else {
553                 mcp->mb[10] = fwopts[10];
554                 mcp->mb[11] = fwopts[11];
555                 mcp->mb[12] = 0;        /* Undocumented, but used */
556                 mcp->out_mb |= MBX_12|MBX_11|MBX_10;
557         }
558         mcp->tov = 30;
559         mcp->flags = 0;
560         rval = qla2x00_mailbox_command(ha, mcp);
561
562         fwopts[0] = mcp->mb[0];
563
564         if (rval != QLA_SUCCESS) {
565                 /*EMPTY*/
566                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__,
567                     ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
568         } else {
569                 /*EMPTY*/
570                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
571         }
572
573         return rval;
574 }
575
576 /*
577  * qla2x00_mbx_reg_test
578  *      Mailbox register wrap test.
579  *
580  * Input:
581  *      ha = adapter block pointer.
582  *      TARGET_QUEUE_LOCK must be released.
583  *      ADAPTER_STATE_LOCK must be released.
584  *
585  * Returns:
586  *      qla2x00 local function return status code.
587  *
588  * Context:
589  *      Kernel context.
590  */
591 int
592 qla2x00_mbx_reg_test(scsi_qla_host_t *ha)
593 {
594         int rval;
595         mbx_cmd_t mc;
596         mbx_cmd_t *mcp = &mc;
597
598         DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", ha->host_no));
599
600         mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
601         mcp->mb[1] = 0xAAAA;
602         mcp->mb[2] = 0x5555;
603         mcp->mb[3] = 0xAA55;
604         mcp->mb[4] = 0x55AA;
605         mcp->mb[5] = 0xA5A5;
606         mcp->mb[6] = 0x5A5A;
607         mcp->mb[7] = 0x2525;
608         mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
609         mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
610         mcp->tov = 30;
611         mcp->flags = 0;
612         rval = qla2x00_mailbox_command(ha, mcp);
613
614         if (rval == QLA_SUCCESS) {
615                 if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
616                     mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
617                         rval = QLA_FUNCTION_FAILED;
618                 if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
619                     mcp->mb[7] != 0x2525)
620                         rval = QLA_FUNCTION_FAILED;
621         }
622
623         if (rval != QLA_SUCCESS) {
624                 /*EMPTY*/
625                 DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n",
626                     ha->host_no, rval));
627         } else {
628                 /*EMPTY*/
629                 DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n",
630                     ha->host_no));
631         }
632
633         return rval;
634 }
635
636 /*
637  * qla2x00_verify_checksum
638  *      Verify firmware checksum.
639  *
640  * Input:
641  *      ha = adapter block pointer.
642  *      TARGET_QUEUE_LOCK must be released.
643  *      ADAPTER_STATE_LOCK must be released.
644  *
645  * Returns:
646  *      qla2x00 local function return status code.
647  *
648  * Context:
649  *      Kernel context.
650  */
651 int
652 qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr)
653 {
654         int rval;
655         mbx_cmd_t mc;
656         mbx_cmd_t *mcp = &mc;
657
658         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
659
660         mcp->mb[0] = MBC_VERIFY_CHECKSUM;
661         mcp->out_mb = MBX_0;
662         mcp->in_mb = MBX_0;
663         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
664                 mcp->mb[1] = MSW(risc_addr);
665                 mcp->mb[2] = LSW(risc_addr);
666                 mcp->out_mb |= MBX_2|MBX_1;
667                 mcp->in_mb |= MBX_2|MBX_1;
668         } else {
669                 mcp->mb[1] = LSW(risc_addr);
670                 mcp->out_mb |= MBX_1;
671                 mcp->in_mb |= MBX_1;
672         }
673
674         mcp->tov = 30;
675         mcp->flags = 0;
676         rval = qla2x00_mailbox_command(ha, mcp);
677
678         if (rval != QLA_SUCCESS) {
679                 DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__,
680                     ha->host_no, rval, (IS_QLA24XX(ha) || IS_QLA54XX(ha) ?
681                     (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1])));
682         } else {
683                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
684         }
685
686         return rval;
687 }
688
689 /*
690  * qla2x00_issue_iocb
691  *      Issue IOCB using mailbox command
692  *
693  * Input:
694  *      ha = adapter state pointer.
695  *      buffer = buffer pointer.
696  *      phys_addr = physical address of buffer.
697  *      size = size of buffer.
698  *      TARGET_QUEUE_LOCK must be released.
699  *      ADAPTER_STATE_LOCK must be released.
700  *
701  * Returns:
702  *      qla2x00 local function return status code.
703  *
704  * Context:
705  *      Kernel context.
706  */
707 int
708 qla2x00_issue_iocb(scsi_qla_host_t *ha, void*  buffer, dma_addr_t phys_addr,
709     size_t size)
710 {
711         int             rval;
712         mbx_cmd_t       mc;
713         mbx_cmd_t       *mcp = &mc;
714
715         mcp->mb[0] = MBC_IOCB_COMMAND_A64;
716         mcp->mb[1] = 0;
717         mcp->mb[2] = MSW(phys_addr);
718         mcp->mb[3] = LSW(phys_addr);
719         mcp->mb[6] = MSW(MSD(phys_addr));
720         mcp->mb[7] = LSW(MSD(phys_addr));
721         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
722         mcp->in_mb = MBX_2|MBX_0;
723         mcp->tov = 30;
724         mcp->flags = 0;
725         rval = qla2x00_mailbox_command(ha, mcp);
726
727         if (rval != QLA_SUCCESS) {
728                 /*EMPTY*/
729                 DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
730                     ha->host_no, rval));
731                 DEBUG2(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
732                     ha->host_no, rval));
733         } else {
734                 sts_entry_t *sts_entry = (sts_entry_t *) buffer;
735
736                 /* Mask reserved bits. */
737                 sts_entry->entry_status &=
738                     IS_QLA24XX(ha) || IS_QLA54XX(ha) ? RF_MASK_24XX :RF_MASK;
739         }
740
741         return rval;
742 }
743
744 /*
745  * qla2x00_abort_command
746  *      Abort command aborts a specified IOCB.
747  *
748  * Input:
749  *      ha = adapter block pointer.
750  *      sp = SB structure pointer.
751  *
752  * Returns:
753  *      qla2x00 local function return status code.
754  *
755  * Context:
756  *      Kernel context.
757  */
758 int
759 qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp)
760 {
761         unsigned long   flags = 0;
762         fc_port_t       *fcport;
763         int             rval;
764         uint32_t        handle;
765         mbx_cmd_t       mc;
766         mbx_cmd_t       *mcp = &mc;
767
768         DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", ha->host_no));
769
770         fcport = sp->fcport;
771
772         spin_lock_irqsave(&ha->hardware_lock, flags);
773         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
774                 if (ha->outstanding_cmds[handle] == sp)
775                         break;
776         }
777         spin_unlock_irqrestore(&ha->hardware_lock, flags);
778
779         if (handle == MAX_OUTSTANDING_COMMANDS) {
780                 /* command not found */
781                 return QLA_FUNCTION_FAILED;
782         }
783
784         mcp->mb[0] = MBC_ABORT_COMMAND;
785         if (HAS_EXTENDED_IDS(ha))
786                 mcp->mb[1] = fcport->loop_id;
787         else
788                 mcp->mb[1] = fcport->loop_id << 8;
789         mcp->mb[2] = (uint16_t)handle;
790         mcp->mb[3] = (uint16_t)(handle >> 16);
791         mcp->mb[6] = (uint16_t)sp->cmd->device->lun;
792         mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
793         mcp->in_mb = MBX_0;
794         mcp->tov = 30;
795         mcp->flags = 0;
796         rval = qla2x00_mailbox_command(ha, mcp);
797
798         if (rval != QLA_SUCCESS) {
799                 DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
800                     ha->host_no, rval));
801         } else {
802                 sp->flags |= SRB_ABORT_PENDING;
803                 DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
804                     ha->host_no));
805         }
806
807         return rval;
808 }
809
810 #if USE_ABORT_TGT
811 /*
812  * qla2x00_abort_target
813  *      Issue abort target mailbox command.
814  *
815  * Input:
816  *      ha = adapter block pointer.
817  *
818  * Returns:
819  *      qla2x00 local function return status code.
820  *
821  * Context:
822  *      Kernel context.
823  */
824 int
825 qla2x00_abort_target(fc_port_t *fcport)
826 {
827         int        rval;
828         mbx_cmd_t  mc;
829         mbx_cmd_t  *mcp = &mc;
830         scsi_qla_host_t *ha;
831
832         if (fcport == NULL)
833                 return 0;
834
835         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no));
836
837         ha = fcport->ha;
838         mcp->mb[0] = MBC_ABORT_TARGET;
839         mcp->out_mb = MBX_2|MBX_1|MBX_0;
840         if (HAS_EXTENDED_IDS(ha)) {
841                 mcp->mb[1] = fcport->loop_id;
842                 mcp->mb[10] = 0;
843                 mcp->out_mb |= MBX_10;
844         } else {
845                 mcp->mb[1] = fcport->loop_id << 8;
846         }
847         mcp->mb[2] = ha->loop_reset_delay;
848
849         mcp->in_mb = MBX_0;
850         mcp->tov = 30;
851         mcp->flags = 0;
852         rval = qla2x00_mailbox_command(ha, mcp);
853
854         /* Issue marker command. */
855         ha->marker_needed = 1;
856
857         if (rval != QLA_SUCCESS) {
858                 DEBUG2_3_11(printk("qla2x00_abort_target(%ld): failed=%x.\n",
859                     ha->host_no, rval));
860         } else {
861                 /*EMPTY*/
862                 DEBUG11(printk("qla2x00_abort_target(%ld): done.\n",
863                     ha->host_no));
864         }
865
866         return rval;
867 }
868 #endif
869
870 /*
871  * qla2x00_get_adapter_id
872  *      Get adapter ID and topology.
873  *
874  * Input:
875  *      ha = adapter block pointer.
876  *      id = pointer for loop ID.
877  *      al_pa = pointer for AL_PA.
878  *      area = pointer for area.
879  *      domain = pointer for domain.
880  *      top = pointer for topology.
881  *      TARGET_QUEUE_LOCK must be released.
882  *      ADAPTER_STATE_LOCK must be released.
883  *
884  * Returns:
885  *      qla2x00 local function return status code.
886  *
887  * Context:
888  *      Kernel context.
889  */
890 int
891 qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa,
892     uint8_t *area, uint8_t *domain, uint16_t *top)
893 {
894         int rval;
895         mbx_cmd_t mc;
896         mbx_cmd_t *mcp = &mc;
897
898         DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
899             ha->host_no));
900
901         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
902         mcp->out_mb = MBX_0;
903         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
904         mcp->tov = 30;
905         mcp->flags = 0;
906         rval = qla2x00_mailbox_command(ha, mcp);
907         if (mcp->mb[0] == MBS_COMMAND_ERROR)
908                 rval = QLA_COMMAND_ERROR;
909
910         /* Return data. */
911         *id = mcp->mb[1];
912         *al_pa = LSB(mcp->mb[2]);
913         *area = MSB(mcp->mb[2]);
914         *domain = LSB(mcp->mb[3]);
915         *top = mcp->mb[6];
916
917         if (rval != QLA_SUCCESS) {
918                 /*EMPTY*/
919                 DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
920                     ha->host_no, rval));
921         } else {
922                 /*EMPTY*/
923                 DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
924                     ha->host_no));
925         }
926
927         return rval;
928 }
929
930 /*
931  * qla2x00_get_retry_cnt
932  *      Get current firmware login retry count and delay.
933  *
934  * Input:
935  *      ha = adapter block pointer.
936  *      retry_cnt = pointer to login retry count.
937  *      tov = pointer to login timeout value.
938  *
939  * Returns:
940  *      qla2x00 local function return status code.
941  *
942  * Context:
943  *      Kernel context.
944  */
945 int
946 qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
947     uint16_t *r_a_tov)
948 {
949         int rval;
950         uint16_t ratov;
951         mbx_cmd_t mc;
952         mbx_cmd_t *mcp = &mc;
953
954         DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
955                         ha->host_no));
956
957         mcp->mb[0] = MBC_GET_RETRY_COUNT;
958         mcp->out_mb = MBX_0;
959         mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
960         mcp->tov = 30;
961         mcp->flags = 0;
962         rval = qla2x00_mailbox_command(ha, mcp);
963
964         if (rval != QLA_SUCCESS) {
965                 /*EMPTY*/
966                 DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
967                     ha->host_no, mcp->mb[0]));
968         } else {
969                 /* Convert returned data and check our values. */
970                 *r_a_tov = mcp->mb[3] / 2;
971                 ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
972                 if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
973                         /* Update to the larger values */
974                         *retry_cnt = (uint8_t)mcp->mb[1];
975                         *tov = ratov;
976                 }
977
978                 DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
979                     "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov));
980         }
981
982         return rval;
983 }
984
985 /*
986  * qla2x00_init_firmware
987  *      Initialize adapter firmware.
988  *
989  * Input:
990  *      ha = adapter block pointer.
991  *      dptr = Initialization control block pointer.
992  *      size = size of initialization control block.
993  *      TARGET_QUEUE_LOCK must be released.
994  *      ADAPTER_STATE_LOCK must be released.
995  *
996  * Returns:
997  *      qla2x00 local function return status code.
998  *
999  * Context:
1000  *      Kernel context.
1001  */
1002 int
1003 qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size)
1004 {
1005         int rval;
1006         mbx_cmd_t mc;
1007         mbx_cmd_t *mcp = &mc;
1008
1009         DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
1010             ha->host_no));
1011
1012         mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
1013         mcp->mb[2] = MSW(ha->init_cb_dma);
1014         mcp->mb[3] = LSW(ha->init_cb_dma);
1015         mcp->mb[4] = 0;
1016         mcp->mb[5] = 0;
1017         mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
1018         mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1019         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1020         mcp->in_mb = MBX_5|MBX_4|MBX_0;
1021         mcp->buf_size = size;
1022         mcp->flags = MBX_DMA_OUT;
1023         mcp->tov = 30;
1024         rval = qla2x00_mailbox_command(ha, mcp);
1025
1026         if (rval != QLA_SUCCESS) {
1027                 /*EMPTY*/
1028                 DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
1029                     "mb0=%x.\n",
1030                     ha->host_no, rval, mcp->mb[0]));
1031         } else {
1032                 /*EMPTY*/
1033                 DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
1034                     ha->host_no));
1035         }
1036
1037         return rval;
1038 }
1039
1040 /*
1041  * qla2x00_get_port_database
1042  *      Issue normal/enhanced get port database mailbox command
1043  *      and copy device name as necessary.
1044  *
1045  * Input:
1046  *      ha = adapter state pointer.
1047  *      dev = structure pointer.
1048  *      opt = enhanced cmd option byte.
1049  *
1050  * Returns:
1051  *      qla2x00 local function return status code.
1052  *
1053  * Context:
1054  *      Kernel context.
1055  */
1056 int
1057 qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
1058 {
1059         int rval;
1060         mbx_cmd_t mc;
1061         mbx_cmd_t *mcp = &mc;
1062         port_database_t *pd;
1063         struct port_database_24xx *pd24;
1064         dma_addr_t pd_dma;
1065
1066         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1067
1068         pd24 = NULL;
1069         pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1070         if (pd  == NULL) {
1071                 DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
1072                     "structure.\n", __func__, ha->host_no));
1073                 return QLA_MEMORY_ALLOC_FAILED;
1074         }
1075         memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
1076
1077         mcp->mb[0] = MBC_GET_PORT_DATABASE;
1078         if (opt != 0 && !IS_QLA24XX(ha) && !IS_QLA54XX(ha))
1079                 mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
1080         mcp->mb[2] = MSW(pd_dma);
1081         mcp->mb[3] = LSW(pd_dma);
1082         mcp->mb[6] = MSW(MSD(pd_dma));
1083         mcp->mb[7] = LSW(MSD(pd_dma));
1084         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1085         mcp->in_mb = MBX_0;
1086         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
1087                 mcp->mb[1] = fcport->loop_id;
1088                 mcp->mb[10] = opt;
1089                 mcp->out_mb |= MBX_10|MBX_1;
1090                 mcp->in_mb |= MBX_1;
1091         } else if (HAS_EXTENDED_IDS(ha)) {
1092                 mcp->mb[1] = fcport->loop_id;
1093                 mcp->mb[10] = opt;
1094                 mcp->out_mb |= MBX_10|MBX_1;
1095         } else {
1096                 mcp->mb[1] = fcport->loop_id << 8 | opt;
1097                 mcp->out_mb |= MBX_1;
1098         }
1099         mcp->buf_size = (IS_QLA24XX(ha) || IS_QLA54XX(ha) ?
1100             PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE);
1101         mcp->flags = MBX_DMA_IN;
1102         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1103         rval = qla2x00_mailbox_command(ha, mcp);
1104         if (rval != QLA_SUCCESS)
1105                 goto gpd_error_out;
1106
1107         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
1108                 pd24 = (struct port_database_24xx *) pd;
1109
1110                 /* Check for logged in state. */
1111                 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
1112                     pd24->last_login_state != PDS_PRLI_COMPLETE) {
1113                         DEBUG2(printk("%s(%ld): Unable to verify "
1114                             "login-state (%x/%x) for loop_id %x\n",
1115                             __func__, ha->host_no,
1116                             pd24->current_login_state,
1117                             pd24->last_login_state, fcport->loop_id));
1118                         rval = QLA_FUNCTION_FAILED;
1119                         goto gpd_error_out;
1120                 }
1121
1122                 /* Names are little-endian. */
1123                 memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
1124                 memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
1125
1126                 /* Get port_id of device. */
1127                 fcport->d_id.b.domain = pd24->port_id[0];
1128                 fcport->d_id.b.area = pd24->port_id[1];
1129                 fcport->d_id.b.al_pa = pd24->port_id[2];
1130                 fcport->d_id.b.rsvd_1 = 0;
1131
1132                 /* If not target must be initiator or unknown type. */
1133                 if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
1134                         fcport->port_type = FCT_INITIATOR;
1135                 else
1136                         fcport->port_type = FCT_TARGET;
1137         } else {
1138                 /* Check for logged in state. */
1139                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
1140                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
1141                         rval = QLA_FUNCTION_FAILED;
1142                         goto gpd_error_out;
1143                 }
1144
1145                 /* Names are little-endian. */
1146                 memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
1147                 memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
1148
1149                 /* Get port_id of device. */
1150                 fcport->d_id.b.domain = pd->port_id[0];
1151                 fcport->d_id.b.area = pd->port_id[3];
1152                 fcport->d_id.b.al_pa = pd->port_id[2];
1153                 fcport->d_id.b.rsvd_1 = 0;
1154
1155                 /* Check for device require authentication. */
1156                 pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) :
1157                     (fcport->flags &= ~FCF_AUTH_REQ);
1158
1159                 /* If not target must be initiator or unknown type. */
1160                 if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
1161                         fcport->port_type = FCT_INITIATOR;
1162                 else
1163                         fcport->port_type = FCT_TARGET;
1164
1165                 /* Passback COS information. */
1166                 fcport->supported_classes = (pd->options & BIT_4) ?
1167                     FC_COS_CLASS2: FC_COS_CLASS3;
1168         }
1169
1170 gpd_error_out:
1171         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1172
1173         if (rval != QLA_SUCCESS) {
1174                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
1175                     __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1176         } else {
1177                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
1178         }
1179
1180         return rval;
1181 }
1182
1183 /*
1184  * qla2x00_get_firmware_state
1185  *      Get adapter firmware state.
1186  *
1187  * Input:
1188  *      ha = adapter block pointer.
1189  *      dptr = pointer for firmware state.
1190  *      TARGET_QUEUE_LOCK must be released.
1191  *      ADAPTER_STATE_LOCK must be released.
1192  *
1193  * Returns:
1194  *      qla2x00 local function return status code.
1195  *
1196  * Context:
1197  *      Kernel context.
1198  */
1199 int
1200 qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *dptr)
1201 {
1202         int rval;
1203         mbx_cmd_t mc;
1204         mbx_cmd_t *mcp = &mc;
1205
1206         DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
1207             ha->host_no));
1208
1209         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
1210         mcp->out_mb = MBX_0;
1211         mcp->in_mb = MBX_2|MBX_1|MBX_0;
1212         mcp->tov = 30;
1213         mcp->flags = 0;
1214         rval = qla2x00_mailbox_command(ha, mcp);
1215
1216         /* Return firmware state. */
1217         *dptr = mcp->mb[1];
1218
1219         if (rval != QLA_SUCCESS) {
1220                 /*EMPTY*/
1221                 DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
1222                     "failed=%x.\n", ha->host_no, rval));
1223         } else {
1224                 /*EMPTY*/
1225                 DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
1226                     ha->host_no));
1227         }
1228
1229         return rval;
1230 }
1231
1232 /*
1233  * qla2x00_get_port_name
1234  *      Issue get port name mailbox command.
1235  *      Returned name is in big endian format.
1236  *
1237  * Input:
1238  *      ha = adapter block pointer.
1239  *      loop_id = loop ID of device.
1240  *      name = pointer for name.
1241  *      TARGET_QUEUE_LOCK must be released.
1242  *      ADAPTER_STATE_LOCK must be released.
1243  *
1244  * Returns:
1245  *      qla2x00 local function return status code.
1246  *
1247  * Context:
1248  *      Kernel context.
1249  */
1250 int
1251 qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
1252     uint8_t opt)
1253 {
1254         int rval;
1255         mbx_cmd_t mc;
1256         mbx_cmd_t *mcp = &mc;
1257
1258         DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
1259             ha->host_no));
1260
1261         mcp->mb[0] = MBC_GET_PORT_NAME;
1262         mcp->out_mb = MBX_1|MBX_0;
1263         if (HAS_EXTENDED_IDS(ha)) {
1264                 mcp->mb[1] = loop_id;
1265                 mcp->mb[10] = opt;
1266                 mcp->out_mb |= MBX_10;
1267         } else {
1268                 mcp->mb[1] = loop_id << 8 | opt;
1269         }
1270
1271         mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1272         mcp->tov = 30;
1273         mcp->flags = 0;
1274         rval = qla2x00_mailbox_command(ha, mcp);
1275
1276         if (rval != QLA_SUCCESS) {
1277                 /*EMPTY*/
1278                 DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
1279                     ha->host_no, rval));
1280         } else {
1281                 if (name != NULL) {
1282                         /* This function returns name in big endian. */
1283                         name[0] = MSB(mcp->mb[2]);
1284                         name[1] = LSB(mcp->mb[2]);
1285                         name[2] = MSB(mcp->mb[3]);
1286                         name[3] = LSB(mcp->mb[3]);
1287                         name[4] = MSB(mcp->mb[6]);
1288                         name[5] = LSB(mcp->mb[6]);
1289                         name[6] = MSB(mcp->mb[7]);
1290                         name[7] = LSB(mcp->mb[7]);
1291                 }
1292
1293                 DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
1294                     ha->host_no));
1295         }
1296
1297         return rval;
1298 }
1299
1300 /*
1301  * qla2x00_lip_reset
1302  *      Issue LIP reset mailbox command.
1303  *
1304  * Input:
1305  *      ha = adapter block pointer.
1306  *      TARGET_QUEUE_LOCK must be released.
1307  *      ADAPTER_STATE_LOCK must be released.
1308  *
1309  * Returns:
1310  *      qla2x00 local function return status code.
1311  *
1312  * Context:
1313  *      Kernel context.
1314  */
1315 int
1316 qla2x00_lip_reset(scsi_qla_host_t *ha)
1317 {
1318         int rval;
1319         mbx_cmd_t mc;
1320         mbx_cmd_t *mcp = &mc;
1321
1322         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1323
1324         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
1325                 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1326                 mcp->mb[1] = BIT_6;
1327                 mcp->mb[2] = 0;
1328                 mcp->mb[3] = ha->loop_reset_delay;
1329                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1330         } else {
1331                 mcp->mb[0] = MBC_LIP_RESET;
1332                 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1333                 if (HAS_EXTENDED_IDS(ha)) {
1334                         mcp->mb[1] = 0x00ff;
1335                         mcp->mb[10] = 0;
1336                         mcp->out_mb |= MBX_10;
1337                 } else {
1338                         mcp->mb[1] = 0xff00;
1339                 }
1340                 mcp->mb[2] = ha->loop_reset_delay;
1341                 mcp->mb[3] = 0;
1342         }
1343         mcp->in_mb = MBX_0;
1344         mcp->tov = 30;
1345         mcp->flags = 0;
1346         rval = qla2x00_mailbox_command(ha, mcp);
1347
1348         if (rval != QLA_SUCCESS) {
1349                 /*EMPTY*/
1350                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
1351                     __func__, ha->host_no, rval));
1352         } else {
1353                 /*EMPTY*/
1354                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
1355         }
1356
1357         return rval;
1358 }
1359
1360 /*
1361  * qla2x00_send_sns
1362  *      Send SNS command.
1363  *
1364  * Input:
1365  *      ha = adapter block pointer.
1366  *      sns = pointer for command.
1367  *      cmd_size = command size.
1368  *      buf_size = response/command size.
1369  *      TARGET_QUEUE_LOCK must be released.
1370  *      ADAPTER_STATE_LOCK must be released.
1371  *
1372  * Returns:
1373  *      qla2x00 local function return status code.
1374  *
1375  * Context:
1376  *      Kernel context.
1377  */
1378 int
1379 qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address,
1380     uint16_t cmd_size, size_t buf_size)
1381 {
1382         int rval;
1383         mbx_cmd_t mc;
1384         mbx_cmd_t *mcp = &mc;
1385
1386         DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
1387             ha->host_no));
1388
1389         DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
1390             "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov));
1391
1392         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
1393         mcp->mb[1] = cmd_size;
1394         mcp->mb[2] = MSW(sns_phys_address);
1395         mcp->mb[3] = LSW(sns_phys_address);
1396         mcp->mb[6] = MSW(MSD(sns_phys_address));
1397         mcp->mb[7] = LSW(MSD(sns_phys_address));
1398         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1399         mcp->in_mb = MBX_0|MBX_1;
1400         mcp->buf_size = buf_size;
1401         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1402         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1403         rval = qla2x00_mailbox_command(ha, mcp);
1404
1405         if (rval != QLA_SUCCESS) {
1406                 /*EMPTY*/
1407                 DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1408                     "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1409                 DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1410                     "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
1411         } else {
1412                 /*EMPTY*/
1413                 DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no));
1414         }
1415
1416         return rval;
1417 }
1418
1419 int
1420 qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1421     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1422 {
1423         int             rval;
1424
1425         struct logio_entry_24xx *lg;
1426         dma_addr_t      lg_dma;
1427         uint32_t        iop[2];
1428
1429         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1430
1431         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1432         if (lg == NULL) {
1433                 DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
1434                     __func__, ha->host_no));
1435                 return QLA_MEMORY_ALLOC_FAILED;
1436         }
1437         memset(lg, 0, sizeof(struct logio_entry_24xx));
1438
1439         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1440         lg->entry_count = 1;
1441         lg->nport_handle = cpu_to_le16(loop_id);
1442         lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
1443         if (opt & BIT_0)
1444                 lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1445         if (opt & BIT_1)
1446                 lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI);
1447         lg->port_id[0] = al_pa;
1448         lg->port_id[1] = area;
1449         lg->port_id[2] = domain;
1450         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
1451         if (rval != QLA_SUCCESS) {
1452                 DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
1453                     "(%x).\n", __func__, ha->host_no, rval));
1454         } else if (lg->entry_status != 0) {
1455                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1456                     "-- error status (%x).\n", __func__, ha->host_no,
1457                     lg->entry_status));
1458                 rval = QLA_FUNCTION_FAILED;
1459         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1460                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1461                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
1462
1463                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1464                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1465                     ha->host_no, le16_to_cpu(lg->comp_status), iop[0],
1466                     iop[1]));
1467
1468                 switch (iop[0]) {
1469                 case LSC_SCODE_PORTID_USED:
1470                         mb[0] = MBS_PORT_ID_USED;
1471                         mb[1] = LSW(iop[1]);
1472                         break;
1473                 case LSC_SCODE_NPORT_USED:
1474                         mb[0] = MBS_LOOP_ID_USED;
1475                         break;
1476                 case LSC_SCODE_NOLINK:
1477                 case LSC_SCODE_NOIOCB:
1478                 case LSC_SCODE_NOXCB:
1479                 case LSC_SCODE_CMD_FAILED:
1480                 case LSC_SCODE_NOFABRIC:
1481                 case LSC_SCODE_FW_NOT_READY:
1482                 case LSC_SCODE_NOT_LOGGED_IN:
1483                 case LSC_SCODE_NOPCB:
1484                 case LSC_SCODE_ELS_REJECT:
1485                 case LSC_SCODE_CMD_PARAM_ERR:
1486                 case LSC_SCODE_NONPORT:
1487                 case LSC_SCODE_LOGGED_IN:
1488                 case LSC_SCODE_NOFLOGI_ACC:
1489                 default:
1490                         mb[0] = MBS_COMMAND_ERROR;
1491                         break;
1492                 }
1493         } else {
1494                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
1495
1496                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
1497
1498                 mb[0] = MBS_COMMAND_COMPLETE;
1499                 mb[1] = 0;
1500                 if (iop[0] & BIT_4) {
1501                         if (iop[0] & BIT_8)
1502                                 mb[1] |= BIT_1;
1503                 } else
1504                         mb[1] = BIT_0;
1505
1506                 /* Passback COS information. */
1507                 mb[10] = 0;
1508                 if (lg->io_parameter[7] || lg->io_parameter[8])
1509                         mb[10] |= BIT_0;        /* Class 2. */
1510                 if (lg->io_parameter[9] || lg->io_parameter[10])
1511                         mb[10] |= BIT_1;        /* Class 3. */
1512         }
1513
1514         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1515
1516         return rval;
1517 }
1518
1519 /*
1520  * qla2x00_login_fabric
1521  *      Issue login fabric port mailbox command.
1522  *
1523  * Input:
1524  *      ha = adapter block pointer.
1525  *      loop_id = device loop ID.
1526  *      domain = device domain.
1527  *      area = device area.
1528  *      al_pa = device AL_PA.
1529  *      status = pointer for return status.
1530  *      opt = command options.
1531  *      TARGET_QUEUE_LOCK must be released.
1532  *      ADAPTER_STATE_LOCK must be released.
1533  *
1534  * Returns:
1535  *      qla2x00 local function return status code.
1536  *
1537  * Context:
1538  *      Kernel context.
1539  */
1540 int
1541 qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1542     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
1543 {
1544         int rval;
1545         mbx_cmd_t mc;
1546         mbx_cmd_t *mcp = &mc;
1547
1548         DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no));
1549
1550         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1551         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1552         if (HAS_EXTENDED_IDS(ha)) {
1553                 mcp->mb[1] = loop_id;
1554                 mcp->mb[10] = opt;
1555                 mcp->out_mb |= MBX_10;
1556         } else {
1557                 mcp->mb[1] = (loop_id << 8) | opt;
1558         }
1559         mcp->mb[2] = domain;
1560         mcp->mb[3] = area << 8 | al_pa;
1561
1562         mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1563         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1564         mcp->flags = 0;
1565         rval = qla2x00_mailbox_command(ha, mcp);
1566
1567         /* Return mailbox statuses. */
1568         if (mb != NULL) {
1569                 mb[0] = mcp->mb[0];
1570                 mb[1] = mcp->mb[1];
1571                 mb[2] = mcp->mb[2];
1572                 mb[6] = mcp->mb[6];
1573                 mb[7] = mcp->mb[7];
1574                 /* COS retrieved from Get-Port-Database mailbox command. */
1575                 mb[10] = 0;
1576         }
1577
1578         if (rval != QLA_SUCCESS) {
1579                 /* RLU tmp code: need to change main mailbox_command function to
1580                  * return ok even when the mailbox completion value is not
1581                  * SUCCESS. The caller needs to be responsible to interpret
1582                  * the return values of this mailbox command if we're not
1583                  * to change too much of the existing code.
1584                  */
1585                 if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
1586                     mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
1587                     mcp->mb[0] == 0x4006)
1588                         rval = QLA_SUCCESS;
1589
1590                 /*EMPTY*/
1591                 DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
1592                     "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval,
1593                     mcp->mb[0], mcp->mb[1], mcp->mb[2]));
1594         } else {
1595                 /*EMPTY*/
1596                 DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
1597                     ha->host_no));
1598         }
1599
1600         return rval;
1601 }
1602
1603 /*
1604  * qla2x00_login_local_device
1605  *           Issue login loop port mailbox command.
1606  *
1607  * Input:
1608  *           ha = adapter block pointer.
1609  *           loop_id = device loop ID.
1610  *           opt = command options.
1611  *
1612  * Returns:
1613  *            Return status code.
1614  *
1615  * Context:
1616  *            Kernel context.
1617  *
1618  */
1619 int
1620 qla2x00_login_local_device(scsi_qla_host_t *ha, fc_port_t *fcport,
1621     uint16_t *mb_ret, uint8_t opt)
1622 {
1623         int rval;
1624         mbx_cmd_t mc;
1625         mbx_cmd_t *mcp = &mc;
1626
1627         if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
1628                 return qla24xx_login_fabric(ha, fcport->loop_id,
1629                     fcport->d_id.b.domain, fcport->d_id.b.area,
1630                     fcport->d_id.b.al_pa, mb_ret, opt);
1631
1632         DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1633
1634         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
1635         if (HAS_EXTENDED_IDS(ha))
1636                 mcp->mb[1] = fcport->loop_id;
1637         else
1638                 mcp->mb[1] = fcport->loop_id << 8;
1639         mcp->mb[2] = opt;
1640         mcp->out_mb = MBX_2|MBX_1|MBX_0;
1641         mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
1642         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1643         mcp->flags = 0;
1644         rval = qla2x00_mailbox_command(ha, mcp);
1645
1646         /* Return mailbox statuses. */
1647         if (mb_ret != NULL) {
1648                 mb_ret[0] = mcp->mb[0];
1649                 mb_ret[1] = mcp->mb[1];
1650                 mb_ret[6] = mcp->mb[6];
1651                 mb_ret[7] = mcp->mb[7];
1652         }
1653
1654         if (rval != QLA_SUCCESS) {
1655                 /* AV tmp code: need to change main mailbox_command function to
1656                  * return ok even when the mailbox completion value is not
1657                  * SUCCESS. The caller needs to be responsible to interpret
1658                  * the return values of this mailbox command if we're not
1659                  * to change too much of the existing code.
1660                  */
1661                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
1662                         rval = QLA_SUCCESS;
1663
1664                 DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1665                     "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
1666                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
1667                 DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1668                     "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
1669                     mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
1670         } else {
1671                 /*EMPTY*/
1672                 DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no));
1673         }
1674
1675         return (rval);
1676 }
1677
1678 int
1679 qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1680     uint8_t area, uint8_t al_pa)
1681 {
1682         int             rval;
1683         struct logio_entry_24xx *lg;
1684         dma_addr_t      lg_dma;
1685
1686         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1687
1688         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
1689         if (lg == NULL) {
1690                 DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
1691                     __func__, ha->host_no));
1692                 return QLA_MEMORY_ALLOC_FAILED;
1693         }
1694         memset(lg, 0, sizeof(struct logio_entry_24xx));
1695
1696         lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1697         lg->entry_count = 1;
1698         lg->nport_handle = cpu_to_le16(loop_id);
1699         lg->control_flags =
1700             __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
1701         lg->port_id[0] = al_pa;
1702         lg->port_id[1] = area;
1703         lg->port_id[2] = domain;
1704         rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
1705         if (rval != QLA_SUCCESS) {
1706                 DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
1707                     "(%x).\n", __func__, ha->host_no, rval));
1708         } else if (lg->entry_status != 0) {
1709                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1710                     "-- error status (%x).\n", __func__, ha->host_no,
1711                     lg->entry_status));
1712                 rval = QLA_FUNCTION_FAILED;
1713         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1714                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1715                     "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1716                     ha->host_no, le16_to_cpu(lg->comp_status),
1717                     le32_to_cpu(lg->io_parameter[0]),
1718                     le32_to_cpu(lg->io_parameter[1])));
1719         } else {
1720                 /*EMPTY*/
1721                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
1722         }
1723
1724         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
1725
1726         return rval;
1727 }
1728
1729 /*
1730  * qla2x00_fabric_logout
1731  *      Issue logout fabric port mailbox command.
1732  *
1733  * Input:
1734  *      ha = adapter block pointer.
1735  *      loop_id = device loop ID.
1736  *      TARGET_QUEUE_LOCK must be released.
1737  *      ADAPTER_STATE_LOCK must be released.
1738  *
1739  * Returns:
1740  *      qla2x00 local function return status code.
1741  *
1742  * Context:
1743  *      Kernel context.
1744  */
1745 int
1746 qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
1747     uint8_t area, uint8_t al_pa)
1748 {
1749         int rval;
1750         mbx_cmd_t mc;
1751         mbx_cmd_t *mcp = &mc;
1752
1753         DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
1754             ha->host_no));
1755
1756         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
1757         mcp->out_mb = MBX_1|MBX_0;
1758         if (HAS_EXTENDED_IDS(ha)) {
1759                 mcp->mb[1] = loop_id;
1760                 mcp->mb[10] = 0;
1761                 mcp->out_mb |= MBX_10;
1762         } else {
1763                 mcp->mb[1] = loop_id << 8;
1764         }
1765
1766         mcp->in_mb = MBX_1|MBX_0;
1767         mcp->tov = 30;
1768         mcp->flags = 0;
1769         rval = qla2x00_mailbox_command(ha, mcp);
1770
1771         if (rval != QLA_SUCCESS) {
1772                 /*EMPTY*/
1773                 DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
1774                     "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1]));
1775         } else {
1776                 /*EMPTY*/
1777                 DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
1778                     ha->host_no));
1779         }
1780
1781         return rval;
1782 }
1783
1784 /*
1785  * qla2x00_full_login_lip
1786  *      Issue full login LIP mailbox command.
1787  *
1788  * Input:
1789  *      ha = adapter block pointer.
1790  *      TARGET_QUEUE_LOCK must be released.
1791  *      ADAPTER_STATE_LOCK must be released.
1792  *
1793  * Returns:
1794  *      qla2x00 local function return status code.
1795  *
1796  * Context:
1797  *      Kernel context.
1798  */
1799 int
1800 qla2x00_full_login_lip(scsi_qla_host_t *ha)
1801 {
1802         int rval;
1803         mbx_cmd_t mc;
1804         mbx_cmd_t *mcp = &mc;
1805
1806         DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
1807             ha->host_no));
1808
1809         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1810         mcp->mb[1] = IS_QLA24XX(ha) || IS_QLA54XX(ha) ? BIT_3: 0;
1811         mcp->mb[2] = 0;
1812         mcp->mb[3] = 0;
1813         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1814         mcp->in_mb = MBX_0;
1815         mcp->tov = 30;
1816         mcp->flags = 0;
1817         rval = qla2x00_mailbox_command(ha, mcp);
1818
1819         if (rval != QLA_SUCCESS) {
1820                 /*EMPTY*/
1821                 DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
1822                     ha->host_no, rval));
1823         } else {
1824                 /*EMPTY*/
1825                 DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
1826                     ha->host_no));
1827         }
1828
1829         return rval;
1830 }
1831
1832 /*
1833  * qla2x00_get_id_list
1834  *
1835  * Input:
1836  *      ha = adapter block pointer.
1837  *
1838  * Returns:
1839  *      qla2x00 local function return status code.
1840  *
1841  * Context:
1842  *      Kernel context.
1843  */
1844 int
1845 qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
1846     uint16_t *entries)
1847 {
1848         int rval;
1849         mbx_cmd_t mc;
1850         mbx_cmd_t *mcp = &mc;
1851
1852         DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
1853             ha->host_no));
1854
1855         if (id_list == NULL)
1856                 return QLA_FUNCTION_FAILED;
1857
1858         mcp->mb[0] = MBC_GET_ID_LIST;
1859         mcp->out_mb = MBX_0;
1860         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
1861                 mcp->mb[2] = MSW(id_list_dma);
1862                 mcp->mb[3] = LSW(id_list_dma);
1863                 mcp->mb[6] = MSW(MSD(id_list_dma));
1864                 mcp->mb[7] = LSW(MSD(id_list_dma));
1865                 mcp->mb[8] = 0;
1866                 mcp->out_mb |= MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
1867         } else {
1868                 mcp->mb[1] = MSW(id_list_dma);
1869                 mcp->mb[2] = LSW(id_list_dma);
1870                 mcp->mb[3] = MSW(MSD(id_list_dma));
1871                 mcp->mb[6] = LSW(MSD(id_list_dma));
1872                 mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
1873         }
1874         mcp->in_mb = MBX_1|MBX_0;
1875         mcp->tov = 30;
1876         mcp->flags = 0;
1877         rval = qla2x00_mailbox_command(ha, mcp);
1878
1879         if (rval != QLA_SUCCESS) {
1880                 /*EMPTY*/
1881                 DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
1882                     ha->host_no, rval));
1883         } else {
1884                 *entries = mcp->mb[1];
1885                 DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
1886                     ha->host_no));
1887         }
1888
1889         return rval;
1890 }
1891
1892 /*
1893  * qla2x00_get_resource_cnts
1894  *      Get current firmware resource counts.
1895  *
1896  * Input:
1897  *      ha = adapter block pointer.
1898  *
1899  * Returns:
1900  *      qla2x00 local function return status code.
1901  *
1902  * Context:
1903  *      Kernel context.
1904  */
1905 int
1906 qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt,
1907     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt, uint16_t *orig_iocb_cnt)
1908 {
1909         int rval;
1910         mbx_cmd_t mc;
1911         mbx_cmd_t *mcp = &mc;
1912
1913         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
1914
1915         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
1916         mcp->out_mb = MBX_0;
1917         mcp->in_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1918         mcp->tov = 30;
1919         mcp->flags = 0;
1920         rval = qla2x00_mailbox_command(ha, mcp);
1921
1922         if (rval != QLA_SUCCESS) {
1923                 /*EMPTY*/
1924                 DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
1925                     ha->host_no, mcp->mb[0]));
1926         } else {
1927                 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
1928                     "mb7=%x mb10=%x.\n", __func__, ha->host_no,
1929                     mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7],
1930                     mcp->mb[10]));
1931
1932                 if (cur_xchg_cnt)
1933                         *cur_xchg_cnt = mcp->mb[3];
1934                 if (orig_xchg_cnt)
1935                         *orig_xchg_cnt = mcp->mb[6];
1936                 if (cur_iocb_cnt)
1937                         *cur_iocb_cnt = mcp->mb[7];
1938                 if (orig_iocb_cnt)
1939                         *orig_iocb_cnt = mcp->mb[10];
1940         }
1941
1942         return (rval);
1943 }
1944
1945 #if defined(QL_DEBUG_LEVEL_3)
1946 /*
1947  * qla2x00_get_fcal_position_map
1948  *      Get FCAL (LILP) position map using mailbox command
1949  *
1950  * Input:
1951  *      ha = adapter state pointer.
1952  *      pos_map = buffer pointer (can be NULL).
1953  *
1954  * Returns:
1955  *      qla2x00 local function return status code.
1956  *
1957  * Context:
1958  *      Kernel context.
1959  */
1960 int
1961 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
1962 {
1963         int rval;
1964         mbx_cmd_t mc;
1965         mbx_cmd_t *mcp = &mc;
1966         char *pmap;
1967         dma_addr_t pmap_dma;
1968
1969         pmap = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &pmap_dma);
1970         if (pmap  == NULL) {
1971                 DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
1972                     __func__, ha->host_no));
1973                 return QLA_MEMORY_ALLOC_FAILED;
1974         }
1975         memset(pmap, 0, FCAL_MAP_SIZE);
1976
1977         mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
1978         mcp->mb[2] = MSW(pmap_dma);
1979         mcp->mb[3] = LSW(pmap_dma);
1980         mcp->mb[6] = MSW(MSD(pmap_dma));
1981         mcp->mb[7] = LSW(MSD(pmap_dma));
1982         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
1983         mcp->in_mb = MBX_1|MBX_0;
1984         mcp->buf_size = FCAL_MAP_SIZE;
1985         mcp->flags = MBX_DMA_IN;
1986         mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1987         rval = qla2x00_mailbox_command(ha, mcp);
1988
1989         if (rval == QLA_SUCCESS) {
1990                 DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
1991                     "size (%x)\n", __func__, ha->host_no, mcp->mb[0],
1992                     mcp->mb[1], (unsigned)pmap[0]));
1993                 DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));
1994
1995                 if (pos_map)
1996                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
1997         }
1998         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
1999
2000         if (rval != QLA_SUCCESS) {
2001                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2002                     ha->host_no, rval));
2003         } else {
2004                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2005         }
2006
2007         return rval;
2008 }
2009 #endif
2010
2011 /*
2012  * qla2x00_get_link_status
2013  *
2014  * Input:
2015  *      ha = adapter block pointer.
2016  *      loop_id = device loop ID.
2017  *      ret_buf = pointer to link status return buffer.
2018  *
2019  * Returns:
2020  *      0 = success.
2021  *      BIT_0 = mem alloc error.
2022  *      BIT_1 = mailbox error.
2023  */
2024 int
2025 qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id,
2026     link_stat_t *ret_buf, uint16_t *status)
2027 {
2028         int rval;
2029         mbx_cmd_t mc;
2030         mbx_cmd_t *mcp = &mc;
2031         link_stat_t *stat_buf;
2032         dma_addr_t stat_buf_dma;
2033
2034         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2035
2036         stat_buf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &stat_buf_dma);
2037         if (stat_buf == NULL) {
2038                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
2039                     __func__, ha->host_no));
2040                 return BIT_0;
2041         }
2042         memset(stat_buf, 0, sizeof(link_stat_t));
2043
2044         mcp->mb[0] = MBC_GET_LINK_STATUS;
2045         mcp->mb[2] = MSW(stat_buf_dma);
2046         mcp->mb[3] = LSW(stat_buf_dma);
2047         mcp->mb[6] = MSW(MSD(stat_buf_dma));
2048         mcp->mb[7] = LSW(MSD(stat_buf_dma));
2049         mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2050         mcp->in_mb = MBX_0;
2051         if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
2052                 mcp->mb[1] = loop_id;
2053                 mcp->mb[4] = 0;
2054                 mcp->mb[10] = 0;
2055                 mcp->out_mb |= MBX_10|MBX_4|MBX_1;
2056                 mcp->in_mb |= MBX_1;
2057         } else if (HAS_EXTENDED_IDS(ha)) {
2058                 mcp->mb[1] = loop_id;
2059                 mcp->mb[10] = 0;
2060                 mcp->out_mb |= MBX_10|MBX_1;
2061         } else {
2062                 mcp->mb[1] = loop_id << 8;
2063                 mcp->out_mb |= MBX_1;
2064         }
2065         mcp->tov = 30;
2066         mcp->flags = IOCTL_CMD;
2067         rval = qla2x00_mailbox_command(ha, mcp);
2068
2069         if (rval == QLA_SUCCESS) {
2070                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2071                         DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2072                             __func__, ha->host_no, mcp->mb[0]));
2073                         status[0] = mcp->mb[0];
2074                         rval = BIT_1;
2075                 } else {
2076                         /* copy over data -- firmware data is LE. */
2077                         ret_buf->link_fail_cnt =
2078                             le32_to_cpu(stat_buf->link_fail_cnt);
2079                         ret_buf->loss_sync_cnt =
2080                             le32_to_cpu(stat_buf->loss_sync_cnt);
2081                         ret_buf->loss_sig_cnt =
2082                             le32_to_cpu(stat_buf->loss_sig_cnt);
2083                         ret_buf->prim_seq_err_cnt =
2084                             le32_to_cpu(stat_buf->prim_seq_err_cnt);
2085                         ret_buf->inval_xmit_word_cnt =
2086                             le32_to_cpu(stat_buf->inval_xmit_word_cnt);
2087                         ret_buf->inval_crc_cnt =
2088                             le32_to_cpu(stat_buf->inval_crc_cnt);
2089
2090                         DEBUG11(printk("%s(%ld): stat dump: fail_cnt=%d "
2091                             "loss_sync=%d loss_sig=%d seq_err=%d "
2092                             "inval_xmt_word=%d inval_crc=%d.\n", __func__,
2093                             ha->host_no, stat_buf->link_fail_cnt,
2094                             stat_buf->loss_sync_cnt, stat_buf->loss_sig_cnt,
2095                             stat_buf->prim_seq_err_cnt,
2096                             stat_buf->inval_xmit_word_cnt,
2097                             stat_buf->inval_crc_cnt));
2098                 }
2099         } else {
2100                 /* Failed. */
2101                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2102                     ha->host_no, rval));
2103                 rval = BIT_1;
2104         }
2105
2106         dma_pool_free(ha->s_dma_pool, stat_buf, stat_buf_dma);
2107
2108         return rval;
2109 }
2110
2111 int
2112 qla24xx_get_isp_stats(scsi_qla_host_t *ha, uint32_t *dwbuf, uint32_t dwords,
2113     uint16_t *status)
2114 {
2115         int rval;
2116         mbx_cmd_t mc;
2117         mbx_cmd_t *mcp = &mc;
2118         uint32_t *sbuf, *siter;
2119         dma_addr_t sbuf_dma;
2120
2121         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2122
2123         if (dwords > (DMA_POOL_SIZE / 4)) {
2124                 DEBUG2_3_11(printk("%s(%ld): Unabled to retrieve %d DWORDs "
2125                     "(max %d).\n", __func__, ha->host_no, dwords,
2126                     DMA_POOL_SIZE / 4));
2127                 return BIT_0;
2128         }
2129         sbuf = dma_pool_alloc(ha->s_dma_pool, GFP_ATOMIC, &sbuf_dma);
2130         if (sbuf == NULL) {
2131                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
2132                     __func__, ha->host_no));
2133                 return BIT_0;
2134         }
2135         memset(sbuf, 0, DMA_POOL_SIZE);
2136
2137         mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2138         mcp->mb[2] = MSW(sbuf_dma);
2139         mcp->mb[3] = LSW(sbuf_dma);
2140         mcp->mb[6] = MSW(MSD(sbuf_dma));
2141         mcp->mb[7] = LSW(MSD(sbuf_dma));
2142         mcp->mb[8] = dwords;
2143         mcp->mb[10] = 0;
2144         mcp->out_mb = MBX_10|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2145         mcp->in_mb = MBX_2|MBX_1|MBX_0;
2146         mcp->tov = 30;
2147         mcp->flags = IOCTL_CMD;
2148         rval = qla2x00_mailbox_command(ha, mcp);
2149
2150         if (rval == QLA_SUCCESS) {
2151                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
2152                         DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2153                             __func__, ha->host_no, mcp->mb[0]));
2154                         status[0] = mcp->mb[0];
2155                         rval = BIT_1;
2156                 } else {
2157                         /* Copy over data -- firmware data is LE. */
2158                         siter = sbuf;
2159                         while (dwords--)
2160                                 *dwbuf++ = le32_to_cpu(*siter++);
2161                 }
2162         } else {
2163                 /* Failed. */
2164                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2165                     ha->host_no, rval));
2166                 rval = BIT_1;
2167         }
2168
2169         dma_pool_free(ha->s_dma_pool, sbuf, sbuf_dma);
2170
2171         return rval;
2172 }
2173
2174 int
2175 qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
2176 {
2177         int             rval;
2178         fc_port_t       *fcport;
2179         unsigned long   flags = 0;
2180
2181         struct abort_entry_24xx *abt;
2182         dma_addr_t      abt_dma;
2183         uint32_t        handle;
2184
2185         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2186
2187         fcport = sp->fcport;
2188
2189         spin_lock_irqsave(&ha->hardware_lock, flags);
2190         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
2191                 if (ha->outstanding_cmds[handle] == sp)
2192                         break;
2193         }
2194         spin_unlock_irqrestore(&ha->hardware_lock, flags);
2195         if (handle == MAX_OUTSTANDING_COMMANDS) {
2196                 /* Command not found. */
2197                 return QLA_FUNCTION_FAILED;
2198         }
2199
2200         abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
2201         if (abt == NULL) {
2202                 DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
2203                     __func__, ha->host_no));
2204                 return QLA_MEMORY_ALLOC_FAILED;
2205         }
2206         memset(abt, 0, sizeof(struct abort_entry_24xx));
2207
2208         abt->entry_type = ABORT_IOCB_TYPE;
2209         abt->entry_count = 1;
2210         abt->nport_handle = cpu_to_le16(fcport->loop_id);
2211         abt->handle_to_abort = handle;
2212         abt->port_id[0] = fcport->d_id.b.al_pa;
2213         abt->port_id[1] = fcport->d_id.b.area;
2214         abt->port_id[2] = fcport->d_id.b.domain;
2215         rval = qla2x00_issue_iocb(ha, abt, abt_dma, 0);
2216         if (rval != QLA_SUCCESS) {
2217                 DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
2218                     __func__, ha->host_no, rval));
2219         } else if (abt->entry_status != 0) {
2220                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2221                     "-- error status (%x).\n", __func__, ha->host_no,
2222                     abt->entry_status));
2223                 rval = QLA_FUNCTION_FAILED;
2224         } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
2225                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2226                     "-- completion status (%x).\n", __func__, ha->host_no,
2227                     le16_to_cpu(abt->nport_handle)));
2228                 rval = QLA_FUNCTION_FAILED;
2229         } else {
2230                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2231                 sp->flags |= SRB_ABORT_PENDING;
2232         }
2233
2234         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
2235
2236         return rval;
2237 }
2238
2239 struct tsk_mgmt_cmd {
2240         union {
2241                 struct tsk_mgmt_entry tsk;
2242                 struct sts_entry_24xx sts;
2243         } p;
2244 };
2245
2246 int
2247 qla24xx_abort_target(fc_port_t *fcport)
2248 {
2249         int             rval;
2250         struct tsk_mgmt_cmd *tsk;
2251         dma_addr_t      tsk_dma;
2252         scsi_qla_host_t *ha;
2253
2254         if (fcport == NULL)
2255                 return 0;
2256
2257         DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no));
2258
2259         ha = fcport->ha;
2260         tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2261         if (tsk == NULL) {
2262                 DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
2263                     "IOCB.\n", __func__, ha->host_no));
2264                 return QLA_MEMORY_ALLOC_FAILED;
2265         }
2266         memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
2267
2268         tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
2269         tsk->p.tsk.entry_count = 1;
2270         tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2271         tsk->p.tsk.timeout = __constant_cpu_to_le16(25);
2272         tsk->p.tsk.control_flags = __constant_cpu_to_le32(TCF_TARGET_RESET);
2273         tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
2274         tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
2275         tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2276         rval = qla2x00_issue_iocb(ha, tsk, tsk_dma, 0);
2277         if (rval != QLA_SUCCESS) {
2278                 DEBUG2_3_11(printk("%s(%ld): failed to issue Target Reset IOCB "
2279                     "(%x).\n", __func__, ha->host_no, rval));
2280                 goto atarget_done;
2281         } else if (tsk->p.sts.entry_status != 0) {
2282                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2283                     "-- error status (%x).\n", __func__, ha->host_no,
2284                     tsk->p.sts.entry_status));
2285                 rval = QLA_FUNCTION_FAILED;
2286                 goto atarget_done;
2287         } else if (tsk->p.sts.comp_status !=
2288             __constant_cpu_to_le16(CS_COMPLETE)) {
2289                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2290                     "-- completion status (%x).\n", __func__,
2291                     ha->host_no, le16_to_cpu(tsk->p.sts.comp_status)));
2292                 rval = QLA_FUNCTION_FAILED;
2293                 goto atarget_done;
2294         }
2295
2296         /* Issue marker IOCB. */
2297         rval = qla2x00_marker(ha, fcport->loop_id, 0, MK_SYNC_ID);
2298         if (rval != QLA_SUCCESS) {
2299                 DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
2300                     "(%x).\n", __func__, ha->host_no, rval));
2301         } else {
2302                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2303         }
2304
2305 atarget_done:
2306         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2307
2308         return rval;
2309 }
2310
2311 int
2312 qla2x00_system_error(scsi_qla_host_t *ha)
2313 {
2314         int rval;
2315         mbx_cmd_t mc;
2316         mbx_cmd_t *mcp = &mc;
2317
2318         if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
2319                 return QLA_FUNCTION_FAILED;
2320
2321         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2322
2323         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
2324         mcp->out_mb = MBX_0;
2325         mcp->in_mb = MBX_0;
2326         mcp->tov = 5;
2327         mcp->flags = 0;
2328         rval = qla2x00_mailbox_command(ha, mcp);
2329
2330         if (rval != QLA_SUCCESS) {
2331                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2332                     ha->host_no, rval));
2333         } else {
2334                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2335         }
2336
2337         return rval;
2338 }
2339
2340 /**
2341  * qla2x00_get_serdes_params() -
2342  * @ha: HA context
2343  *
2344  * Returns
2345  */
2346 int
2347 qla2x00_get_serdes_params(scsi_qla_host_t *ha, uint16_t *sw_em_1g,
2348     uint16_t *sw_em_2g, uint16_t *sw_em_4g)
2349 {
2350         int rval;
2351         mbx_cmd_t mc;
2352         mbx_cmd_t *mcp = &mc;
2353
2354         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2355
2356         mcp->mb[0] = MBC_SERDES_PARAMS;
2357         mcp->mb[1] = 0;
2358         mcp->out_mb = MBX_1|MBX_0;
2359         mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0;
2360         mcp->tov = 30;
2361         mcp->flags = 0;
2362         rval = qla2x00_mailbox_command(ha, mcp);
2363
2364         if (rval != QLA_SUCCESS) {
2365                 /*EMPTY*/
2366                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2367                     ha->host_no, rval, mcp->mb[0]));
2368         } else {
2369                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2370
2371                 if (sw_em_1g)
2372                         *sw_em_1g = mcp->mb[2];
2373                 if (sw_em_2g)
2374                         *sw_em_2g = mcp->mb[3];
2375                 if (sw_em_4g)
2376                         *sw_em_4g = mcp->mb[4];
2377         }
2378
2379         return rval;
2380 }
2381
2382 /**
2383  * qla2x00_set_serdes_params() -
2384  * @ha: HA context
2385  *
2386  * Returns
2387  */
2388 int
2389 qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g,
2390     uint16_t sw_em_2g, uint16_t sw_em_4g)
2391 {
2392         int rval;
2393         mbx_cmd_t mc;
2394         mbx_cmd_t *mcp = &mc;
2395
2396         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2397
2398         mcp->mb[0] = MBC_SERDES_PARAMS;
2399         mcp->mb[1] = BIT_0;
2400         mcp->mb[2] = sw_em_1g | BIT_15;
2401         mcp->mb[3] = sw_em_2g | BIT_15;
2402         mcp->mb[4] = sw_em_4g | BIT_15;
2403         mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2404         mcp->in_mb = MBX_0;
2405         mcp->tov = 30;
2406         mcp->flags = 0;
2407         rval = qla2x00_mailbox_command(ha, mcp);
2408
2409         if (rval != QLA_SUCCESS) {
2410                 /*EMPTY*/
2411                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2412                     ha->host_no, rval, mcp->mb[0]));
2413         } else {
2414                 /*EMPTY*/
2415                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2416         }
2417
2418         return rval;
2419 }
2420
2421 int
2422 qla2x00_stop_firmware(scsi_qla_host_t *ha)
2423 {
2424         int rval;
2425         mbx_cmd_t mc;
2426         mbx_cmd_t *mcp = &mc;
2427
2428         if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
2429                 return QLA_FUNCTION_FAILED;
2430
2431         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2432
2433         mcp->mb[0] = MBC_STOP_FIRMWARE;
2434         mcp->out_mb = MBX_0;
2435         mcp->in_mb = MBX_0;
2436         mcp->tov = 5;
2437         mcp->flags = 0;
2438         rval = qla2x00_mailbox_command(ha, mcp);
2439
2440         if (rval != QLA_SUCCESS) {
2441                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2442                     ha->host_no, rval));
2443         } else {
2444                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2445         }
2446
2447         return rval;
2448 }
2449
2450 int
2451 qla2x00_trace_control(scsi_qla_host_t *ha, uint16_t ctrl, dma_addr_t eft_dma,
2452     uint16_t buffers)
2453 {
2454         int rval;
2455         mbx_cmd_t mc;
2456         mbx_cmd_t *mcp = &mc;
2457
2458         if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
2459                 return QLA_FUNCTION_FAILED;
2460
2461         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2462
2463         mcp->mb[0] = MBC_TRACE_CONTROL;
2464         mcp->mb[1] = ctrl;
2465         mcp->out_mb = MBX_1|MBX_0;
2466         mcp->in_mb = MBX_1|MBX_0;
2467         if (ctrl == TC_ENABLE) {
2468                 mcp->mb[2] = LSW(eft_dma);
2469                 mcp->mb[3] = MSW(eft_dma);
2470                 mcp->mb[4] = LSW(MSD(eft_dma));
2471                 mcp->mb[5] = MSW(MSD(eft_dma));
2472                 mcp->mb[6] = buffers;
2473                 mcp->mb[7] = 0;
2474                 mcp->out_mb |= MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2;
2475         }
2476         mcp->tov = 30;
2477         mcp->flags = 0;
2478         rval = qla2x00_mailbox_command(ha, mcp);
2479
2480         if (rval != QLA_SUCCESS) {
2481                 DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2482                     __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2483         } else {
2484                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2485         }
2486
2487         return rval;
2488 }
2489
2490 int
2491 qla2x00_read_sfp(scsi_qla_host_t *ha, dma_addr_t sfp_dma, uint16_t addr,
2492     uint16_t off, uint16_t count)
2493 {
2494         int rval;
2495         mbx_cmd_t mc;
2496         mbx_cmd_t *mcp = &mc;
2497
2498         if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))
2499                 return QLA_FUNCTION_FAILED;
2500
2501         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2502
2503         mcp->mb[0] = MBC_READ_SFP;
2504         mcp->mb[1] = addr;
2505         mcp->mb[2] = MSW(sfp_dma);
2506         mcp->mb[3] = LSW(sfp_dma);
2507         mcp->mb[6] = MSW(MSD(sfp_dma));
2508         mcp->mb[7] = LSW(MSD(sfp_dma));
2509         mcp->mb[8] = count;
2510         mcp->mb[9] = off;
2511         mcp->mb[10] = 0;
2512         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2513         mcp->in_mb = MBX_0;
2514         mcp->tov = 30;
2515         mcp->flags = 0;
2516         rval = qla2x00_mailbox_command(ha, mcp);
2517
2518         if (rval != QLA_SUCCESS) {
2519                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2520                     ha->host_no, rval, mcp->mb[0]));
2521         } else {
2522                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2523         }
2524
2525         return rval;
2526 }
2527
2528 int
2529 qla2x00_get_idma_speed(scsi_qla_host_t *ha, uint16_t loop_id,
2530     uint16_t *port_speed, uint16_t *mb)
2531 {
2532         int rval;
2533         mbx_cmd_t mc;
2534         mbx_cmd_t *mcp = &mc;
2535
2536         if (!IS_QLA24XX(ha))
2537                 return QLA_FUNCTION_FAILED;
2538
2539         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2540
2541         mcp->mb[0] = MBC_PORT_PARAMS;
2542         mcp->mb[1] = loop_id;
2543         mcp->mb[2] = mcp->mb[3] = mcp->mb[4] = mcp->mb[5] = 0;
2544         mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2545         mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
2546         mcp->tov = 30;
2547         mcp->flags = 0;
2548         rval = qla2x00_mailbox_command(ha, mcp);
2549
2550         /* Return mailbox statuses. */
2551         if (mb != NULL) {
2552                 mb[0] = mcp->mb[0];
2553                 mb[1] = mcp->mb[1];
2554                 mb[3] = mcp->mb[3];
2555                 mb[4] = mcp->mb[4];
2556                 mb[5] = mcp->mb[5];
2557         }
2558
2559         if (rval != QLA_SUCCESS) {
2560                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2561                     ha->host_no, rval));
2562         } else {
2563                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2564                 if (port_speed)
2565                         *port_speed = mcp->mb[3];
2566         }
2567
2568         return rval;
2569 }
2570
2571 int
2572 qla2x00_set_idma_speed(scsi_qla_host_t *ha, uint16_t loop_id,
2573     uint16_t port_speed, uint16_t *mb)
2574 {
2575         int rval;
2576         mbx_cmd_t mc;
2577         mbx_cmd_t *mcp = &mc;
2578
2579         if (!IS_QLA24XX(ha))
2580                 return QLA_FUNCTION_FAILED;
2581
2582         DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
2583
2584         mcp->mb[0] = MBC_PORT_PARAMS;
2585         mcp->mb[1] = loop_id;
2586         mcp->mb[2] = BIT_0;
2587         mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
2588         mcp->mb[4] = mcp->mb[5] = 0;
2589         mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2590         mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
2591         mcp->tov = 30;
2592         mcp->flags = 0;
2593         rval = qla2x00_mailbox_command(ha, mcp);
2594
2595         /* Return mailbox statuses. */
2596         if (mb != NULL) {
2597                 mb[0] = mcp->mb[0];
2598                 mb[1] = mcp->mb[1];
2599                 mb[3] = mcp->mb[3];
2600                 mb[4] = mcp->mb[4];
2601                 mb[5] = mcp->mb[5];
2602         }
2603
2604         if (rval != QLA_SUCCESS) {
2605                 DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2606                     ha->host_no, rval));
2607         } else {
2608                 DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
2609         }
2610
2611         return rval;
2612 }