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