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