[SCSI] Maintain module-parameter name consistency with qla2xxx/qla4xxx.
[linux-2.6.git] / drivers / scsi / qla4xxx / ql4_mbx.c
1 /*
2  * QLogic iSCSI HBA Driver
3  * Copyright (c)  2003-2006 QLogic Corporation
4  *
5  * See LICENSE.qla4xxx for copyright and licensing details.
6  */
7
8 #include "ql4_def.h"
9
10
11 /**
12  * qla4xxx_mailbox_command - issues mailbox commands
13  * @ha: Pointer to host adapter structure.
14  * @inCount: number of mailbox registers to load.
15  * @outCount: number of mailbox registers to return.
16  * @mbx_cmd: data pointer for mailbox in registers.
17  * @mbx_sts: data pointer for mailbox out registers.
18  *
19  * This routine sssue mailbox commands and waits for completion.
20  * If outCount is 0, this routine completes successfully WITHOUT waiting
21  * for the mailbox command to complete.
22  **/
23 int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
24                             uint8_t outCount, uint32_t *mbx_cmd,
25                             uint32_t *mbx_sts)
26 {
27         int status = QLA_ERROR;
28         uint8_t i;
29         u_long wait_count;
30         uint32_t intr_status;
31         unsigned long flags = 0;
32         DECLARE_WAITQUEUE(wait, current);
33
34         mutex_lock(&ha->mbox_sem);
35
36         /* Mailbox code active */
37         set_bit(AF_MBOX_COMMAND, &ha->flags);
38
39         /* Make sure that pointers are valid */
40         if (!mbx_cmd || !mbx_sts) {
41                 DEBUG2(printk("scsi%ld: %s: Invalid mbx_cmd or mbx_sts "
42                               "pointer\n", ha->host_no, __func__));
43                 goto mbox_exit;
44         }
45
46         /* To prevent overwriting mailbox registers for a command that has
47          * not yet been serviced, check to see if a previously issued
48          * mailbox command is interrupting.
49          * -----------------------------------------------------------------
50          */
51         spin_lock_irqsave(&ha->hardware_lock, flags);
52         intr_status = readl(&ha->reg->ctrl_status);
53         if (intr_status & CSR_SCSI_PROCESSOR_INTR) {
54                 /* Service existing interrupt */
55                 qla4xxx_interrupt_service_routine(ha, intr_status);
56                 clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
57         }
58
59         /* Send the mailbox command to the firmware */
60         ha->mbox_status_count = outCount;
61         for (i = 0; i < outCount; i++)
62                 ha->mbox_status[i] = 0;
63
64         /* Load all mailbox registers, except mailbox 0. */
65         for (i = 1; i < inCount; i++)
66                 writel(mbx_cmd[i], &ha->reg->mailbox[i]);
67
68         /* Wakeup firmware  */
69         writel(mbx_cmd[0], &ha->reg->mailbox[0]);
70         readl(&ha->reg->mailbox[0]);
71         writel(set_rmask(CSR_INTR_RISC), &ha->reg->ctrl_status);
72         readl(&ha->reg->ctrl_status);
73         spin_unlock_irqrestore(&ha->hardware_lock, flags);
74
75         /* Wait for completion */
76         set_current_state(TASK_UNINTERRUPTIBLE);
77         add_wait_queue(&ha->mailbox_wait_queue, &wait);
78
79         /*
80          * If we don't want status, don't wait for the mailbox command to
81          * complete.  For example, MBOX_CMD_RESET_FW doesn't return status,
82          * you must poll the inbound Interrupt Mask for completion.
83          */
84         if (outCount == 0) {
85                 status = QLA_SUCCESS;
86                 set_current_state(TASK_RUNNING);
87                 remove_wait_queue(&ha->mailbox_wait_queue, &wait);
88                 goto mbox_exit;
89         }
90         /* Wait for command to complete */
91         wait_count = jiffies + MBOX_TOV * HZ;
92         while (test_bit(AF_MBOX_COMMAND_DONE, &ha->flags) == 0) {
93                 if (time_after_eq(jiffies, wait_count))
94                         break;
95
96                 spin_lock_irqsave(&ha->hardware_lock, flags);
97                 intr_status = readl(&ha->reg->ctrl_status);
98                 if (intr_status & INTR_PENDING) {
99                         /*
100                          * Service the interrupt.
101                          * The ISR will save the mailbox status registers
102                          * to a temporary storage location in the adapter
103                          * structure.
104                          */
105                         ha->mbox_status_count = outCount;
106                         qla4xxx_interrupt_service_routine(ha, intr_status);
107                 }
108                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
109                 msleep(10);
110         }
111         set_current_state(TASK_RUNNING);
112         remove_wait_queue(&ha->mailbox_wait_queue, &wait);
113
114         /* Check for mailbox timeout. */
115         if (!test_bit(AF_MBOX_COMMAND_DONE, &ha->flags)) {
116                 DEBUG2(printk("scsi%ld: Mailbox Cmd 0x%08X timed out ...,"
117                               " Scheduling Adapter Reset\n", ha->host_no,
118                               mbx_cmd[0]));
119                 ha->mailbox_timeout_count++;
120                 mbx_sts[0] = (-1);
121                 set_bit(DPC_RESET_HA, &ha->dpc_flags);
122                 goto mbox_exit;
123         }
124
125         /*
126          * Copy the mailbox out registers to the caller's mailbox in/out
127          * structure.
128          */
129         spin_lock_irqsave(&ha->hardware_lock, flags);
130         for (i = 0; i < outCount; i++)
131                 mbx_sts[i] = ha->mbox_status[i];
132
133         /* Set return status and error flags (if applicable). */
134         switch (ha->mbox_status[0]) {
135         case MBOX_STS_COMMAND_COMPLETE:
136                 status = QLA_SUCCESS;
137                 break;
138
139         case MBOX_STS_INTERMEDIATE_COMPLETION:
140                 status = QLA_SUCCESS;
141                 break;
142
143         case MBOX_STS_BUSY:
144                 DEBUG2( printk("scsi%ld: %s: Cmd = %08X, ISP BUSY\n",
145                                ha->host_no, __func__, mbx_cmd[0]));
146                 ha->mailbox_timeout_count++;
147                 break;
148
149         default:
150                 DEBUG2(printk("scsi%ld: %s: **** FAILED, cmd = %08X, "
151                               "sts = %08X ****\n", ha->host_no, __func__,
152                               mbx_cmd[0], mbx_sts[0]));
153                 break;
154         }
155         spin_unlock_irqrestore(&ha->hardware_lock, flags);
156
157 mbox_exit:
158         clear_bit(AF_MBOX_COMMAND, &ha->flags);
159         clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
160         mutex_unlock(&ha->mbox_sem);
161
162         return status;
163 }
164
165
166 /**
167  * qla4xxx_issue_iocb - issue mailbox iocb command
168  * @ha: adapter state pointer.
169  * @buffer: buffer pointer.
170  * @phys_addr: physical address of buffer.
171  * @size: size of buffer.
172  *
173  * Issues iocbs via mailbox commands.
174  * TARGET_QUEUE_LOCK must be released.
175  * ADAPTER_STATE_LOCK must be released.
176  **/
177 int
178 qla4xxx_issue_iocb(struct scsi_qla_host * ha, void *buffer,
179                    dma_addr_t phys_addr, size_t size)
180 {
181         uint32_t mbox_cmd[MBOX_REG_COUNT];
182         uint32_t mbox_sts[MBOX_REG_COUNT];
183         int status;
184
185         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
186         memset(&mbox_sts, 0, sizeof(mbox_sts));
187         mbox_cmd[0] = MBOX_CMD_EXECUTE_IOCB_A64;
188         mbox_cmd[1] = 0;
189         mbox_cmd[2] = LSDW(phys_addr);
190         mbox_cmd[3] = MSDW(phys_addr);
191         status = qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]);
192         return status;
193 }
194
195 int qla4xxx_conn_close_sess_logout(struct scsi_qla_host * ha,
196                                    uint16_t fw_ddb_index,
197                                    uint16_t connection_id,
198                                    uint16_t option)
199 {
200         uint32_t mbox_cmd[MBOX_REG_COUNT];
201         uint32_t mbox_sts[MBOX_REG_COUNT];
202
203         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
204         memset(&mbox_sts, 0, sizeof(mbox_sts));
205         mbox_cmd[0] = MBOX_CMD_CONN_CLOSE_SESS_LOGOUT;
206         mbox_cmd[1] = fw_ddb_index;
207         mbox_cmd[2] = connection_id;
208         mbox_cmd[3] = LOGOUT_OPTION_RELOGIN;
209         if (qla4xxx_mailbox_command(ha, 4, 2, &mbox_cmd[0], &mbox_sts[0]) !=
210             QLA_SUCCESS) {
211                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_CONN_CLOSE_SESS_LOGOUT "
212                               "option %04x failed sts %04X %04X",
213                               ha->host_no, __func__,
214                               option, mbox_sts[0], mbox_sts[1]));
215                 if (mbox_sts[0] == 0x4005)
216                         DEBUG2(printk("%s reason %04X\n", __func__,
217                                       mbox_sts[1]));
218         }
219         return QLA_SUCCESS;
220 }
221
222 int qla4xxx_clear_database_entry(struct scsi_qla_host * ha,
223                                  uint16_t fw_ddb_index)
224 {
225         uint32_t mbox_cmd[MBOX_REG_COUNT];
226         uint32_t mbox_sts[MBOX_REG_COUNT];
227
228         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
229         memset(&mbox_sts, 0, sizeof(mbox_sts));
230         mbox_cmd[0] = MBOX_CMD_CLEAR_DATABASE_ENTRY;
231         mbox_cmd[1] = fw_ddb_index;
232         if (qla4xxx_mailbox_command(ha, 2, 5, &mbox_cmd[0], &mbox_sts[0]) !=
233             QLA_SUCCESS)
234                 return QLA_ERROR;
235
236         return QLA_SUCCESS;
237 }
238
239 /**
240  * qla4xxx_initialize_fw_cb - initializes firmware control block.
241  * @ha: Pointer to host adapter structure.
242  **/
243 int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha)
244 {
245         struct init_fw_ctrl_blk *init_fw_cb;
246         dma_addr_t init_fw_cb_dma;
247         uint32_t mbox_cmd[MBOX_REG_COUNT];
248         uint32_t mbox_sts[MBOX_REG_COUNT];
249         int status = QLA_ERROR;
250
251         init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
252                                         sizeof(struct init_fw_ctrl_blk),
253                                         &init_fw_cb_dma, GFP_KERNEL);
254         if (init_fw_cb == NULL) {
255                 DEBUG2(printk("scsi%ld: %s: Unable to alloc init_cb\n",
256                               ha->host_no, __func__));
257                 return 10;
258         }
259         memset(init_fw_cb, 0, sizeof(struct init_fw_ctrl_blk));
260
261         /* Get Initialize Firmware Control Block. */
262         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
263         memset(&mbox_sts, 0, sizeof(mbox_sts));
264         mbox_cmd[0] = MBOX_CMD_GET_INIT_FW_CTRL_BLOCK;
265         mbox_cmd[2] = LSDW(init_fw_cb_dma);
266         mbox_cmd[3] = MSDW(init_fw_cb_dma);
267         if (qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]) !=
268             QLA_SUCCESS) {
269                 dma_free_coherent(&ha->pdev->dev,
270                                   sizeof(struct init_fw_ctrl_blk),
271                                   init_fw_cb, init_fw_cb_dma);
272                 return status;
273         }
274
275         /* Initialize request and response queues. */
276         qla4xxx_init_rings(ha);
277
278         /* Fill in the request and response queue information. */
279         init_fw_cb->ReqQConsumerIndex = cpu_to_le16(ha->request_out);
280         init_fw_cb->ComplQProducerIndex = cpu_to_le16(ha->response_in);
281         init_fw_cb->ReqQLen = __constant_cpu_to_le16(REQUEST_QUEUE_DEPTH);
282         init_fw_cb->ComplQLen = __constant_cpu_to_le16(RESPONSE_QUEUE_DEPTH);
283         init_fw_cb->ReqQAddrLo = cpu_to_le32(LSDW(ha->request_dma));
284         init_fw_cb->ReqQAddrHi = cpu_to_le32(MSDW(ha->request_dma));
285         init_fw_cb->ComplQAddrLo = cpu_to_le32(LSDW(ha->response_dma));
286         init_fw_cb->ComplQAddrHi = cpu_to_le32(MSDW(ha->response_dma));
287         init_fw_cb->ShadowRegBufAddrLo =
288                 cpu_to_le32(LSDW(ha->shadow_regs_dma));
289         init_fw_cb->ShadowRegBufAddrHi =
290                 cpu_to_le32(MSDW(ha->shadow_regs_dma));
291
292         /* Set up required options. */
293         init_fw_cb->FwOptions |=
294                 __constant_cpu_to_le16(FWOPT_SESSION_MODE |
295                                        FWOPT_INITIATOR_MODE);
296         init_fw_cb->FwOptions &= __constant_cpu_to_le16(~FWOPT_TARGET_MODE);
297
298         /* Save some info in adapter structure. */
299         ha->firmware_options = le16_to_cpu(init_fw_cb->FwOptions);
300         ha->tcp_options = le16_to_cpu(init_fw_cb->TCPOptions);
301         ha->heartbeat_interval = init_fw_cb->HeartbeatInterval;
302         memcpy(ha->ip_address, init_fw_cb->IPAddr,
303                min(sizeof(ha->ip_address), sizeof(init_fw_cb->IPAddr)));
304         memcpy(ha->subnet_mask, init_fw_cb->SubnetMask,
305                min(sizeof(ha->subnet_mask), sizeof(init_fw_cb->SubnetMask)));
306         memcpy(ha->gateway, init_fw_cb->GatewayIPAddr,
307                min(sizeof(ha->gateway), sizeof(init_fw_cb->GatewayIPAddr)));
308         memcpy(ha->name_string, init_fw_cb->iSCSINameString,
309                min(sizeof(ha->name_string),
310                    sizeof(init_fw_cb->iSCSINameString)));
311         memcpy(ha->alias, init_fw_cb->Alias,
312                min(sizeof(ha->alias), sizeof(init_fw_cb->Alias)));
313
314         /* Save Command Line Paramater info */
315         ha->port_down_retry_count = le16_to_cpu(init_fw_cb->KeepAliveTimeout);
316         ha->discovery_wait = ql4xdiscoverywait;
317
318         /* Send Initialize Firmware Control Block. */
319         mbox_cmd[0] = MBOX_CMD_INITIALIZE_FIRMWARE;
320         mbox_cmd[1] = 0;
321         mbox_cmd[2] = LSDW(init_fw_cb_dma);
322         mbox_cmd[3] = MSDW(init_fw_cb_dma);
323         if (qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]) ==
324             QLA_SUCCESS)
325                 status = QLA_SUCCESS;
326          else {
327                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_INITIALIZE_FIRMWARE "
328                               "failed w/ status %04X\n", ha->host_no, __func__,
329                               mbox_sts[0]));
330         }
331         dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk),
332                           init_fw_cb, init_fw_cb_dma);
333
334         return status;
335 }
336
337 /**
338  * qla4xxx_get_dhcp_ip_address - gets HBA ip address via DHCP
339  * @ha: Pointer to host adapter structure.
340  **/
341 int qla4xxx_get_dhcp_ip_address(struct scsi_qla_host * ha)
342 {
343         struct init_fw_ctrl_blk *init_fw_cb;
344         dma_addr_t init_fw_cb_dma;
345         uint32_t mbox_cmd[MBOX_REG_COUNT];
346         uint32_t mbox_sts[MBOX_REG_COUNT];
347
348         init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
349                                         sizeof(struct init_fw_ctrl_blk),
350                                         &init_fw_cb_dma, GFP_KERNEL);
351         if (init_fw_cb == NULL) {
352                 printk("scsi%ld: %s: Unable to alloc init_cb\n", ha->host_no,
353                        __func__);
354                 return 10;
355         }
356
357         /* Get Initialize Firmware Control Block. */
358         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
359         memset(&mbox_sts, 0, sizeof(mbox_sts));
360         memset(init_fw_cb, 0, sizeof(struct init_fw_ctrl_blk));
361         mbox_cmd[0] = MBOX_CMD_GET_INIT_FW_CTRL_BLOCK;
362         mbox_cmd[2] = LSDW(init_fw_cb_dma);
363         mbox_cmd[3] = MSDW(init_fw_cb_dma);
364
365         if (qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]) !=
366             QLA_SUCCESS) {
367                 DEBUG2(printk("scsi%ld: %s: Failed to get init_fw_ctrl_blk\n",
368                               ha->host_no, __func__));
369                 dma_free_coherent(&ha->pdev->dev,
370                                   sizeof(struct init_fw_ctrl_blk),
371                                   init_fw_cb, init_fw_cb_dma);
372                 return QLA_ERROR;
373         }
374
375         /* Save IP Address. */
376         memcpy(ha->ip_address, init_fw_cb->IPAddr,
377                min(sizeof(ha->ip_address), sizeof(init_fw_cb->IPAddr)));
378         memcpy(ha->subnet_mask, init_fw_cb->SubnetMask,
379                min(sizeof(ha->subnet_mask), sizeof(init_fw_cb->SubnetMask)));
380         memcpy(ha->gateway, init_fw_cb->GatewayIPAddr,
381                min(sizeof(ha->gateway), sizeof(init_fw_cb->GatewayIPAddr)));
382
383         dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk),
384                           init_fw_cb, init_fw_cb_dma);
385
386         return QLA_SUCCESS;
387 }
388
389 /**
390  * qla4xxx_get_firmware_state - gets firmware state of HBA
391  * @ha: Pointer to host adapter structure.
392  **/
393 int qla4xxx_get_firmware_state(struct scsi_qla_host * ha)
394 {
395         uint32_t mbox_cmd[MBOX_REG_COUNT];
396         uint32_t mbox_sts[MBOX_REG_COUNT];
397
398         /* Get firmware version */
399         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
400         memset(&mbox_sts, 0, sizeof(mbox_sts));
401         mbox_cmd[0] = MBOX_CMD_GET_FW_STATE;
402         if (qla4xxx_mailbox_command(ha, 1, 4, &mbox_cmd[0], &mbox_sts[0]) !=
403             QLA_SUCCESS) {
404                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_FW_STATE failed w/ "
405                               "status %04X\n", ha->host_no, __func__,
406                               mbox_sts[0]));
407                 return QLA_ERROR;
408         }
409         ha->firmware_state = mbox_sts[1];
410         ha->board_id = mbox_sts[2];
411         ha->addl_fw_state = mbox_sts[3];
412         DEBUG2(printk("scsi%ld: %s firmware_state=0x%x\n",
413                       ha->host_no, __func__, ha->firmware_state);)
414
415                 return QLA_SUCCESS;
416 }
417
418 /**
419  * qla4xxx_get_firmware_status - retrieves firmware status
420  * @ha: Pointer to host adapter structure.
421  **/
422 int qla4xxx_get_firmware_status(struct scsi_qla_host * ha)
423 {
424         uint32_t mbox_cmd[MBOX_REG_COUNT];
425         uint32_t mbox_sts[MBOX_REG_COUNT];
426
427         /* Get firmware version */
428         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
429         memset(&mbox_sts, 0, sizeof(mbox_sts));
430         mbox_cmd[0] = MBOX_CMD_GET_FW_STATUS;
431         if (qla4xxx_mailbox_command(ha, 1, 3, &mbox_cmd[0], &mbox_sts[0]) !=
432             QLA_SUCCESS) {
433                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_FW_STATUS failed w/ "
434                               "status %04X\n", ha->host_no, __func__,
435                               mbox_sts[0]));
436                 return QLA_ERROR;
437         }
438
439         /* High-water mark of IOCBs */
440         ha->iocb_hiwat = mbox_sts[2];
441         if (ha->iocb_hiwat > IOCB_HIWAT_CUSHION)
442                 ha->iocb_hiwat -= IOCB_HIWAT_CUSHION;
443         else
444                 dev_info(&ha->pdev->dev, "WARNING!!!  You have less than %d "
445                            "firmare IOCBs available (%d).\n",
446                            IOCB_HIWAT_CUSHION, ha->iocb_hiwat);
447
448         return QLA_SUCCESS;
449 }
450
451 /**
452  * qla4xxx_get_fwddb_entry - retrieves firmware ddb entry
453  * @ha: Pointer to host adapter structure.
454  * @fw_ddb_index: Firmware's device database index
455  * @fw_ddb_entry: Pointer to firmware's device database entry structure
456  * @num_valid_ddb_entries: Pointer to number of valid ddb entries
457  * @next_ddb_index: Pointer to next valid device database index
458  * @fw_ddb_device_state: Pointer to device state
459  **/
460 int qla4xxx_get_fwddb_entry(struct scsi_qla_host *ha,
461                             uint16_t fw_ddb_index,
462                             struct dev_db_entry *fw_ddb_entry,
463                             dma_addr_t fw_ddb_entry_dma,
464                             uint32_t *num_valid_ddb_entries,
465                             uint32_t *next_ddb_index,
466                             uint32_t *fw_ddb_device_state,
467                             uint32_t *conn_err_detail,
468                             uint16_t *tcp_source_port_num,
469                             uint16_t *connection_id)
470 {
471         int status = QLA_ERROR;
472         uint32_t mbox_cmd[MBOX_REG_COUNT];
473         uint32_t mbox_sts[MBOX_REG_COUNT];
474
475         /* Make sure the device index is valid */
476         if (fw_ddb_index >= MAX_DDB_ENTRIES) {
477                 DEBUG2(printk("scsi%ld: %s: index [%d] out of range.\n",
478                               ha->host_no, __func__, fw_ddb_index));
479                 goto exit_get_fwddb;
480         }
481         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
482         memset(&mbox_sts, 0, sizeof(mbox_sts));
483         mbox_cmd[0] = MBOX_CMD_GET_DATABASE_ENTRY;
484         mbox_cmd[1] = (uint32_t) fw_ddb_index;
485         mbox_cmd[2] = LSDW(fw_ddb_entry_dma);
486         mbox_cmd[3] = MSDW(fw_ddb_entry_dma);
487         if (qla4xxx_mailbox_command(ha, 4, 7, &mbox_cmd[0], &mbox_sts[0]) ==
488             QLA_ERROR) {
489                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_DATABASE_ENTRY failed"
490                               " with status 0x%04X\n", ha->host_no, __func__,
491                               mbox_sts[0]));
492                 goto exit_get_fwddb;
493         }
494         if (fw_ddb_index != mbox_sts[1]) {
495                 DEBUG2(printk("scsi%ld: %s: index mismatch [%d] != [%d].\n",
496                               ha->host_no, __func__, fw_ddb_index,
497                               mbox_sts[1]));
498                 goto exit_get_fwddb;
499         }
500         if (fw_ddb_entry) {
501                 dev_info(&ha->pdev->dev, "DDB[%d] MB0 %04x Tot %d Next %d "
502                            "State %04x ConnErr %08x %d.%d.%d.%d:%04d \"%s\"\n",
503                            fw_ddb_index, mbox_sts[0], mbox_sts[2], mbox_sts[3],
504                            mbox_sts[4], mbox_sts[5], fw_ddb_entry->ipAddr[0],
505                            fw_ddb_entry->ipAddr[1], fw_ddb_entry->ipAddr[2],
506                            fw_ddb_entry->ipAddr[3],
507                            le16_to_cpu(fw_ddb_entry->portNumber),
508                            fw_ddb_entry->iscsiName);
509         }
510         if (num_valid_ddb_entries)
511                 *num_valid_ddb_entries = mbox_sts[2];
512         if (next_ddb_index)
513                 *next_ddb_index = mbox_sts[3];
514         if (fw_ddb_device_state)
515                 *fw_ddb_device_state = mbox_sts[4];
516
517         /*
518          * RA: This mailbox has been changed to pass connection error and
519          * details.  Its true for ISP4010 as per Version E - Not sure when it
520          * was changed.  Get the time2wait from the fw_dd_entry field :
521          * default_time2wait which we call it as minTime2Wait DEV_DB_ENTRY
522          * struct.
523          */
524         if (conn_err_detail)
525                 *conn_err_detail = mbox_sts[5];
526         if (tcp_source_port_num)
527                 *tcp_source_port_num = (uint16_t) mbox_sts[6] >> 16;
528         if (connection_id)
529                 *connection_id = (uint16_t) mbox_sts[6] & 0x00FF;
530         status = QLA_SUCCESS;
531
532 exit_get_fwddb:
533         return status;
534 }
535
536 /**
537  * qla4xxx_set_fwddb_entry - sets a ddb entry.
538  * @ha: Pointer to host adapter structure.
539  * @fw_ddb_index: Firmware's device database index
540  * @fw_ddb_entry: Pointer to firmware's ddb entry structure, or NULL.
541  *
542  * This routine initializes or updates the adapter's device database
543  * entry for the specified device. It also triggers a login for the
544  * specified device. Therefore, it may also be used as a secondary
545  * login routine when a NULL pointer is specified for the fw_ddb_entry.
546  **/
547 int qla4xxx_set_ddb_entry(struct scsi_qla_host * ha, uint16_t fw_ddb_index,
548                           dma_addr_t fw_ddb_entry_dma)
549 {
550         uint32_t mbox_cmd[MBOX_REG_COUNT];
551         uint32_t mbox_sts[MBOX_REG_COUNT];
552
553         /* Do not wait for completion. The firmware will send us an
554          * ASTS_DATABASE_CHANGED (0x8014) to notify us of the login status.
555          */
556         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
557         memset(&mbox_sts, 0, sizeof(mbox_sts));
558
559         mbox_cmd[0] = MBOX_CMD_SET_DATABASE_ENTRY;
560         mbox_cmd[1] = (uint32_t) fw_ddb_index;
561         mbox_cmd[2] = LSDW(fw_ddb_entry_dma);
562         mbox_cmd[3] = MSDW(fw_ddb_entry_dma);
563         return qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]);
564 }
565
566 int qla4xxx_conn_open_session_login(struct scsi_qla_host * ha,
567                                     uint16_t fw_ddb_index)
568 {
569         int status = QLA_ERROR;
570         uint32_t mbox_cmd[MBOX_REG_COUNT];
571         uint32_t mbox_sts[MBOX_REG_COUNT];
572
573         /* Do not wait for completion. The firmware will send us an
574          * ASTS_DATABASE_CHANGED (0x8014) to notify us of the login status.
575          */
576         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
577         memset(&mbox_sts, 0, sizeof(mbox_sts));
578         mbox_cmd[0] = MBOX_CMD_CONN_OPEN_SESS_LOGIN;
579         mbox_cmd[1] = (uint32_t) fw_ddb_index;
580         mbox_cmd[2] = 0;
581         mbox_cmd[3] = 0;
582         mbox_cmd[4] = 0;
583         status = qla4xxx_mailbox_command(ha, 4, 0, &mbox_cmd[0], &mbox_sts[0]);
584         DEBUG2(printk("%s fw_ddb_index=%d status=%d mbx0_1=0x%x :0x%x\n",
585                       __func__, fw_ddb_index, status, mbox_sts[0],
586                       mbox_sts[1]);)
587
588                 return status;
589 }
590
591 /**
592  * qla4xxx_get_crash_record - retrieves crash record.
593  * @ha: Pointer to host adapter structure.
594  *
595  * This routine retrieves a crash record from the QLA4010 after an 8002h aen.
596  **/
597 void qla4xxx_get_crash_record(struct scsi_qla_host * ha)
598 {
599         uint32_t mbox_cmd[MBOX_REG_COUNT];
600         uint32_t mbox_sts[MBOX_REG_COUNT];
601         struct crash_record *crash_record = NULL;
602         dma_addr_t crash_record_dma = 0;
603         uint32_t crash_record_size = 0;
604         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
605         memset(&mbox_sts, 0, sizeof(mbox_cmd));
606
607         /* Get size of crash record. */
608         mbox_cmd[0] = MBOX_CMD_GET_CRASH_RECORD;
609         if (qla4xxx_mailbox_command(ha, 5, 5, &mbox_cmd[0], &mbox_sts[0]) !=
610             QLA_SUCCESS) {
611                 DEBUG2(printk("scsi%ld: %s: ERROR: Unable to retrieve size!\n",
612                               ha->host_no, __func__));
613                 goto exit_get_crash_record;
614         }
615         crash_record_size = mbox_sts[4];
616         if (crash_record_size == 0) {
617                 DEBUG2(printk("scsi%ld: %s: ERROR: Crash record size is 0!\n",
618                               ha->host_no, __func__));
619                 goto exit_get_crash_record;
620         }
621
622         /* Alloc Memory for Crash Record. */
623         crash_record = dma_alloc_coherent(&ha->pdev->dev, crash_record_size,
624                                           &crash_record_dma, GFP_KERNEL);
625         if (crash_record == NULL)
626                 goto exit_get_crash_record;
627
628         /* Get Crash Record. */
629         mbox_cmd[0] = MBOX_CMD_GET_CRASH_RECORD;
630         mbox_cmd[2] = LSDW(crash_record_dma);
631         mbox_cmd[3] = MSDW(crash_record_dma);
632         mbox_cmd[4] = crash_record_size;
633         if (qla4xxx_mailbox_command(ha, 5, 5, &mbox_cmd[0], &mbox_sts[0]) !=
634             QLA_SUCCESS)
635                 goto exit_get_crash_record;
636
637         /* Dump Crash Record. */
638
639 exit_get_crash_record:
640         if (crash_record)
641                 dma_free_coherent(&ha->pdev->dev, crash_record_size,
642                                   crash_record, crash_record_dma);
643 }
644
645 /**
646  * qla4xxx_get_conn_event_log - retrieves connection event log
647  * @ha: Pointer to host adapter structure.
648  **/
649 void qla4xxx_get_conn_event_log(struct scsi_qla_host * ha)
650 {
651         uint32_t mbox_cmd[MBOX_REG_COUNT];
652         uint32_t mbox_sts[MBOX_REG_COUNT];
653         struct conn_event_log_entry *event_log = NULL;
654         dma_addr_t event_log_dma = 0;
655         uint32_t event_log_size = 0;
656         uint32_t num_valid_entries;
657         uint32_t      oldest_entry = 0;
658         uint32_t        max_event_log_entries;
659         uint8_t         i;
660
661
662         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
663         memset(&mbox_sts, 0, sizeof(mbox_cmd));
664
665         /* Get size of crash record. */
666         mbox_cmd[0] = MBOX_CMD_GET_CONN_EVENT_LOG;
667         if (qla4xxx_mailbox_command(ha, 4, 5, &mbox_cmd[0], &mbox_sts[0]) !=
668             QLA_SUCCESS)
669                 goto exit_get_event_log;
670
671         event_log_size = mbox_sts[4];
672         if (event_log_size == 0)
673                 goto exit_get_event_log;
674
675         /* Alloc Memory for Crash Record. */
676         event_log = dma_alloc_coherent(&ha->pdev->dev, event_log_size,
677                                        &event_log_dma, GFP_KERNEL);
678         if (event_log == NULL)
679                 goto exit_get_event_log;
680
681         /* Get Crash Record. */
682         mbox_cmd[0] = MBOX_CMD_GET_CONN_EVENT_LOG;
683         mbox_cmd[2] = LSDW(event_log_dma);
684         mbox_cmd[3] = MSDW(event_log_dma);
685         if (qla4xxx_mailbox_command(ha, 4, 5, &mbox_cmd[0], &mbox_sts[0]) !=
686             QLA_SUCCESS) {
687                 DEBUG2(printk("scsi%ld: %s: ERROR: Unable to retrieve event "
688                               "log!\n", ha->host_no, __func__));
689                 goto exit_get_event_log;
690         }
691
692         /* Dump Event Log. */
693         num_valid_entries = mbox_sts[1];
694
695         max_event_log_entries = event_log_size /
696                 sizeof(struct conn_event_log_entry);
697
698         if (num_valid_entries > max_event_log_entries)
699                 oldest_entry = num_valid_entries % max_event_log_entries;
700
701         DEBUG3(printk("scsi%ld: Connection Event Log Dump (%d entries):\n",
702                       ha->host_no, num_valid_entries));
703
704         if (ql4xextended_error_logging == 3) {
705                 if (oldest_entry == 0) {
706                         /* Circular Buffer has not wrapped around */
707                         for (i=0; i < num_valid_entries; i++) {
708                                 qla4xxx_dump_buffer((uint8_t *)event_log+
709                                                     (i*sizeof(*event_log)),
710                                                     sizeof(*event_log));
711                         }
712                 }
713                 else {
714                         /* Circular Buffer has wrapped around -
715                          * display accordingly*/
716                         for (i=oldest_entry; i < max_event_log_entries; i++) {
717                                 qla4xxx_dump_buffer((uint8_t *)event_log+
718                                                     (i*sizeof(*event_log)),
719                                                     sizeof(*event_log));
720                         }
721                         for (i=0; i < oldest_entry; i++) {
722                                 qla4xxx_dump_buffer((uint8_t *)event_log+
723                                                     (i*sizeof(*event_log)),
724                                                     sizeof(*event_log));
725                         }
726                 }
727         }
728
729 exit_get_event_log:
730         if (event_log)
731                 dma_free_coherent(&ha->pdev->dev, event_log_size, event_log,
732                                   event_log_dma);
733 }
734
735 /**
736  * qla4xxx_reset_lun - issues LUN Reset
737  * @ha: Pointer to host adapter structure.
738  * @db_entry: Pointer to device database entry
739  * @un_entry: Pointer to lun entry structure
740  *
741  * This routine performs a LUN RESET on the specified target/lun.
742  * The caller must ensure that the ddb_entry and lun_entry pointers
743  * are valid before calling this routine.
744  **/
745 int qla4xxx_reset_lun(struct scsi_qla_host * ha, struct ddb_entry * ddb_entry,
746                       int lun)
747 {
748         uint32_t mbox_cmd[MBOX_REG_COUNT];
749         uint32_t mbox_sts[MBOX_REG_COUNT];
750         int status = QLA_SUCCESS;
751
752         DEBUG2(printk("scsi%ld:%d:%d: lun reset issued\n", ha->host_no,
753                       ddb_entry->os_target_id, lun));
754
755         /*
756          * Send lun reset command to ISP, so that the ISP will return all
757          * outstanding requests with RESET status
758          */
759         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
760         memset(&mbox_sts, 0, sizeof(mbox_sts));
761         mbox_cmd[0] = MBOX_CMD_LUN_RESET;
762         mbox_cmd[1] = ddb_entry->fw_ddb_index;
763         mbox_cmd[2] = lun << 8;
764         mbox_cmd[5] = 0x01;     /* Immediate Command Enable */
765         qla4xxx_mailbox_command(ha, 6, 1, &mbox_cmd[0], &mbox_sts[0]);
766         if (mbox_sts[0] != MBOX_STS_COMMAND_COMPLETE &&
767             mbox_sts[0] != MBOX_STS_COMMAND_ERROR)
768                 status = QLA_ERROR;
769
770         return status;
771 }
772
773
774 int qla4xxx_get_flash(struct scsi_qla_host * ha, dma_addr_t dma_addr,
775                       uint32_t offset, uint32_t len)
776 {
777         uint32_t mbox_cmd[MBOX_REG_COUNT];
778         uint32_t mbox_sts[MBOX_REG_COUNT];
779
780         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
781         memset(&mbox_sts, 0, sizeof(mbox_sts));
782         mbox_cmd[0] = MBOX_CMD_READ_FLASH;
783         mbox_cmd[1] = LSDW(dma_addr);
784         mbox_cmd[2] = MSDW(dma_addr);
785         mbox_cmd[3] = offset;
786         mbox_cmd[4] = len;
787         if (qla4xxx_mailbox_command(ha, 5, 2, &mbox_cmd[0], &mbox_sts[0]) !=
788             QLA_SUCCESS) {
789                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_READ_FLASH, failed w/ "
790                     "status %04X %04X, offset %08x, len %08x\n", ha->host_no,
791                     __func__, mbox_sts[0], mbox_sts[1], offset, len));
792                 return QLA_ERROR;
793         }
794         return QLA_SUCCESS;
795 }
796
797 /**
798  * qla4xxx_get_fw_version - gets firmware version
799  * @ha: Pointer to host adapter structure.
800  *
801  * Retrieves the firmware version on HBA. In QLA4010, mailboxes 2 & 3 may
802  * hold an address for data.  Make sure that we write 0 to those mailboxes,
803  * if unused.
804  **/
805 int qla4xxx_get_fw_version(struct scsi_qla_host * ha)
806 {
807         uint32_t mbox_cmd[MBOX_REG_COUNT];
808         uint32_t mbox_sts[MBOX_REG_COUNT];
809
810         /* Get firmware version. */
811         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
812         memset(&mbox_sts, 0, sizeof(mbox_sts));
813         mbox_cmd[0] = MBOX_CMD_ABOUT_FW;
814         if (qla4xxx_mailbox_command(ha, 4, 5, &mbox_cmd[0], &mbox_sts[0]) !=
815             QLA_SUCCESS) {
816                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_ABOUT_FW failed w/ "
817                     "status %04X\n", ha->host_no, __func__, mbox_sts[0]));
818                 return QLA_ERROR;
819         }
820
821         /* Save firmware version information. */
822         ha->firmware_version[0] = mbox_sts[1];
823         ha->firmware_version[1] = mbox_sts[2];
824         ha->patch_number = mbox_sts[3];
825         ha->build_number = mbox_sts[4];
826
827         return QLA_SUCCESS;
828 }
829
830 int qla4xxx_get_default_ddb(struct scsi_qla_host *ha, dma_addr_t dma_addr)
831 {
832         uint32_t mbox_cmd[MBOX_REG_COUNT];
833         uint32_t mbox_sts[MBOX_REG_COUNT];
834
835         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
836         memset(&mbox_sts, 0, sizeof(mbox_sts));
837
838         mbox_cmd[0] = MBOX_CMD_GET_DATABASE_ENTRY_DEFAULTS;
839         mbox_cmd[2] = LSDW(dma_addr);
840         mbox_cmd[3] = MSDW(dma_addr);
841
842         if (qla4xxx_mailbox_command(ha, 4, 1, &mbox_cmd[0], &mbox_sts[0]) !=
843             QLA_SUCCESS) {
844                 DEBUG2(printk("scsi%ld: %s: failed status %04X\n",
845                      ha->host_no, __func__, mbox_sts[0]));
846                 return QLA_ERROR;
847         }
848         return QLA_SUCCESS;
849 }
850
851 int qla4xxx_req_ddb_entry(struct scsi_qla_host *ha, uint32_t *ddb_index)
852 {
853         uint32_t mbox_cmd[MBOX_REG_COUNT];
854         uint32_t mbox_sts[MBOX_REG_COUNT];
855
856         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
857         memset(&mbox_sts, 0, sizeof(mbox_sts));
858
859         mbox_cmd[0] = MBOX_CMD_REQUEST_DATABASE_ENTRY;
860         mbox_cmd[1] = MAX_PRST_DEV_DB_ENTRIES;
861
862         if (qla4xxx_mailbox_command(ha, 2, 3, &mbox_cmd[0], &mbox_sts[0]) !=
863             QLA_SUCCESS) {
864                 if (mbox_sts[0] == MBOX_STS_COMMAND_ERROR) {
865                         *ddb_index = mbox_sts[2];
866                 } else {
867                         DEBUG2(printk("scsi%ld: %s: failed status %04X\n",
868                              ha->host_no, __func__, mbox_sts[0]));
869                         return QLA_ERROR;
870                 }
871         } else {
872                 *ddb_index = MAX_PRST_DEV_DB_ENTRIES;
873         }
874
875         return QLA_SUCCESS;
876 }
877
878
879 int qla4xxx_send_tgts(struct scsi_qla_host *ha, char *ip, uint16_t port)
880 {
881         struct dev_db_entry *fw_ddb_entry;
882         dma_addr_t fw_ddb_entry_dma;
883         uint32_t ddb_index;
884         int ret_val = QLA_SUCCESS;
885
886
887         fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev,
888                                           sizeof(*fw_ddb_entry),
889                                           &fw_ddb_entry_dma, GFP_KERNEL);
890         if (!fw_ddb_entry) {
891                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
892                               ha->host_no, __func__));
893                 ret_val = QLA_ERROR;
894                 goto qla4xxx_send_tgts_exit;
895         }
896
897         ret_val = qla4xxx_get_default_ddb(ha, fw_ddb_entry_dma);
898         if (ret_val != QLA_SUCCESS)
899                 goto qla4xxx_send_tgts_exit;
900
901         ret_val = qla4xxx_req_ddb_entry(ha, &ddb_index);
902         if (ret_val != QLA_SUCCESS)
903                 goto qla4xxx_send_tgts_exit;
904
905         memset((void *)fw_ddb_entry->iSCSIAlias, 0,
906                sizeof(fw_ddb_entry->iSCSIAlias));
907
908         memset((void *)fw_ddb_entry->iscsiName, 0,
909                sizeof(fw_ddb_entry->iscsiName));
910
911         memset((void *)fw_ddb_entry->ipAddr, 0, sizeof(fw_ddb_entry->ipAddr));
912         memset((void *)fw_ddb_entry->targetAddr, 0,
913                sizeof(fw_ddb_entry->targetAddr));
914
915         fw_ddb_entry->options = (DDB_OPT_DISC_SESSION | DDB_OPT_TARGET);
916         fw_ddb_entry->portNumber = cpu_to_le16(ntohs(port));
917
918         fw_ddb_entry->ipAddr[0] = *ip;
919         fw_ddb_entry->ipAddr[1] = *(ip + 1);
920         fw_ddb_entry->ipAddr[2] = *(ip + 2);
921         fw_ddb_entry->ipAddr[3] = *(ip + 3);
922
923         ret_val = qla4xxx_set_ddb_entry(ha, ddb_index, fw_ddb_entry_dma);
924
925 qla4xxx_send_tgts_exit:
926         dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
927                           fw_ddb_entry, fw_ddb_entry_dma);
928         return ret_val;
929 }
930