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