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