259f511374933cb4d7463098c26e746809e75d1b
[pandora-kernel.git] / drivers / scsi / qla2xxx / qla_init.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2010 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8 #include "qla_gbl.h"
9
10 #include <linux/delay.h>
11 #include <linux/slab.h>
12 #include <linux/vmalloc.h>
13
14 #include "qla_devtbl.h"
15
16 #ifdef CONFIG_SPARC
17 #include <asm/prom.h>
18 #endif
19
20 /*
21 *  QLogic ISP2x00 Hardware Support Function Prototypes.
22 */
23 static int qla2x00_isp_firmware(scsi_qla_host_t *);
24 static int qla2x00_setup_chip(scsi_qla_host_t *);
25 static int qla2x00_init_rings(scsi_qla_host_t *);
26 static int qla2x00_fw_ready(scsi_qla_host_t *);
27 static int qla2x00_configure_hba(scsi_qla_host_t *);
28 static int qla2x00_configure_loop(scsi_qla_host_t *);
29 static int qla2x00_configure_local_loop(scsi_qla_host_t *);
30 static int qla2x00_configure_fabric(scsi_qla_host_t *);
31 static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *, struct list_head *);
32 static int qla2x00_device_resync(scsi_qla_host_t *);
33 static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
34     uint16_t *);
35
36 static int qla2x00_restart_isp(scsi_qla_host_t *);
37
38 static int qla2x00_find_new_loop_id(scsi_qla_host_t *, fc_port_t *);
39
40 static struct qla_chip_state_84xx *qla84xx_get_chip(struct scsi_qla_host *);
41 static int qla84xx_init_chip(scsi_qla_host_t *);
42 static int qla25xx_init_queues(struct qla_hw_data *);
43
44 /* SRB Extensions ---------------------------------------------------------- */
45
46 static void
47 qla2x00_ctx_sp_timeout(unsigned long __data)
48 {
49         srb_t *sp = (srb_t *)__data;
50         struct srb_ctx *ctx;
51         struct srb_iocb *iocb;
52         fc_port_t *fcport = sp->fcport;
53         struct qla_hw_data *ha = fcport->vha->hw;
54         struct req_que *req;
55         unsigned long flags;
56
57         spin_lock_irqsave(&ha->hardware_lock, flags);
58         req = ha->req_q_map[0];
59         req->outstanding_cmds[sp->handle] = NULL;
60         ctx = sp->ctx;
61         iocb = ctx->u.iocb_cmd;
62         iocb->timeout(sp);
63         iocb->free(sp);
64         spin_unlock_irqrestore(&ha->hardware_lock, flags);
65 }
66
67 static void
68 qla2x00_ctx_sp_free(srb_t *sp)
69 {
70         struct srb_ctx *ctx = sp->ctx;
71         struct srb_iocb *iocb = ctx->u.iocb_cmd;
72         struct scsi_qla_host *vha = sp->fcport->vha;
73
74         del_timer(&iocb->timer);
75         kfree(iocb);
76         kfree(ctx);
77         mempool_free(sp, sp->fcport->vha->hw->srb_mempool);
78
79         QLA_VHA_MARK_NOT_BUSY(vha);
80 }
81
82 inline srb_t *
83 qla2x00_get_ctx_sp(scsi_qla_host_t *vha, fc_port_t *fcport, size_t size,
84     unsigned long tmo)
85 {
86         srb_t *sp = NULL;
87         struct qla_hw_data *ha = vha->hw;
88         struct srb_ctx *ctx;
89         struct srb_iocb *iocb;
90         uint8_t bail;
91
92         QLA_VHA_MARK_BUSY(vha, bail);
93         if (bail)
94                 return NULL;
95
96         sp = mempool_alloc(ha->srb_mempool, GFP_KERNEL);
97         if (!sp)
98                 goto done;
99         ctx = kzalloc(size, GFP_KERNEL);
100         if (!ctx) {
101                 mempool_free(sp, ha->srb_mempool);
102                 sp = NULL;
103                 goto done;
104         }
105         iocb = kzalloc(sizeof(struct srb_iocb), GFP_KERNEL);
106         if (!iocb) {
107                 mempool_free(sp, ha->srb_mempool);
108                 sp = NULL;
109                 kfree(ctx);
110                 goto done;
111         }
112
113         memset(sp, 0, sizeof(*sp));
114         sp->fcport = fcport;
115         sp->ctx = ctx;
116         ctx->u.iocb_cmd = iocb;
117         iocb->free = qla2x00_ctx_sp_free;
118
119         init_timer(&iocb->timer);
120         if (!tmo)
121                 goto done;
122         iocb->timer.expires = jiffies + tmo * HZ;
123         iocb->timer.data = (unsigned long)sp;
124         iocb->timer.function = qla2x00_ctx_sp_timeout;
125         add_timer(&iocb->timer);
126 done:
127         if (!sp)
128                 QLA_VHA_MARK_NOT_BUSY(vha);
129         return sp;
130 }
131
132 /* Asynchronous Login/Logout Routines -------------------------------------- */
133
134 static inline unsigned long
135 qla2x00_get_async_timeout(struct scsi_qla_host *vha)
136 {
137         unsigned long tmo;
138         struct qla_hw_data *ha = vha->hw;
139
140         /* Firmware should use switch negotiated r_a_tov for timeout. */
141         tmo = ha->r_a_tov / 10 * 2;
142         if (!IS_FWI2_CAPABLE(ha)) {
143                 /*
144                  * Except for earlier ISPs where the timeout is seeded from the
145                  * initialization control block.
146                  */
147                 tmo = ha->login_timeout;
148         }
149         return tmo;
150 }
151
152 static void
153 qla2x00_async_iocb_timeout(srb_t *sp)
154 {
155         fc_port_t *fcport = sp->fcport;
156         struct srb_ctx *ctx = sp->ctx;
157
158         DEBUG2(printk(KERN_WARNING
159                 "scsi(%ld:%x): Async-%s timeout - portid=%02x%02x%02x.\n",
160                 fcport->vha->host_no, sp->handle,
161                 ctx->name, fcport->d_id.b.domain,
162                 fcport->d_id.b.area, fcport->d_id.b.al_pa));
163
164         fcport->flags &= ~FCF_ASYNC_SENT;
165         if (ctx->type == SRB_LOGIN_CMD) {
166                 struct srb_iocb *lio = ctx->u.iocb_cmd;
167                 qla2x00_post_async_logout_work(fcport->vha, fcport, NULL);
168                 /* Retry as needed. */
169                 lio->u.logio.data[0] = MBS_COMMAND_ERROR;
170                 lio->u.logio.data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
171                         QLA_LOGIO_LOGIN_RETRIED : 0;
172                 qla2x00_post_async_login_done_work(fcport->vha, fcport,
173                         lio->u.logio.data);
174         }
175 }
176
177 static void
178 qla2x00_async_login_ctx_done(srb_t *sp)
179 {
180         struct srb_ctx *ctx = sp->ctx;
181         struct srb_iocb *lio = ctx->u.iocb_cmd;
182
183         qla2x00_post_async_login_done_work(sp->fcport->vha, sp->fcport,
184                 lio->u.logio.data);
185         lio->free(sp);
186 }
187
188 int
189 qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
190     uint16_t *data)
191 {
192         srb_t *sp;
193         struct srb_ctx *ctx;
194         struct srb_iocb *lio;
195         int rval;
196
197         rval = QLA_FUNCTION_FAILED;
198         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
199             qla2x00_get_async_timeout(vha) + 2);
200         if (!sp)
201                 goto done;
202
203         ctx = sp->ctx;
204         ctx->type = SRB_LOGIN_CMD;
205         ctx->name = "login";
206         lio = ctx->u.iocb_cmd;
207         lio->timeout = qla2x00_async_iocb_timeout;
208         lio->done = qla2x00_async_login_ctx_done;
209         lio->u.logio.flags |= SRB_LOGIN_COND_PLOGI;
210         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
211                 lio->u.logio.flags |= SRB_LOGIN_RETRIED;
212         rval = qla2x00_start_sp(sp);
213         if (rval != QLA_SUCCESS)
214                 goto done_free_sp;
215
216         DEBUG2(printk(KERN_DEBUG
217             "scsi(%ld:%x): Async-login - loop-id=%x portid=%02x%02x%02x "
218             "retries=%d.\n", fcport->vha->host_no, sp->handle, fcport->loop_id,
219             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
220             fcport->login_retry));
221         return rval;
222
223 done_free_sp:
224         lio->free(sp);
225 done:
226         return rval;
227 }
228
229 static void
230 qla2x00_async_logout_ctx_done(srb_t *sp)
231 {
232         struct srb_ctx *ctx = sp->ctx;
233         struct srb_iocb *lio = ctx->u.iocb_cmd;
234
235         qla2x00_post_async_logout_done_work(sp->fcport->vha, sp->fcport,
236             lio->u.logio.data);
237         lio->free(sp);
238 }
239
240 int
241 qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
242 {
243         srb_t *sp;
244         struct srb_ctx *ctx;
245         struct srb_iocb *lio;
246         int rval;
247
248         rval = QLA_FUNCTION_FAILED;
249         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
250             qla2x00_get_async_timeout(vha) + 2);
251         if (!sp)
252                 goto done;
253
254         ctx = sp->ctx;
255         ctx->type = SRB_LOGOUT_CMD;
256         ctx->name = "logout";
257         lio = ctx->u.iocb_cmd;
258         lio->timeout = qla2x00_async_iocb_timeout;
259         lio->done = qla2x00_async_logout_ctx_done;
260         rval = qla2x00_start_sp(sp);
261         if (rval != QLA_SUCCESS)
262                 goto done_free_sp;
263
264         DEBUG2(printk(KERN_DEBUG
265             "scsi(%ld:%x): Async-logout - loop-id=%x portid=%02x%02x%02x.\n",
266             fcport->vha->host_no, sp->handle, fcport->loop_id,
267             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
268         return rval;
269
270 done_free_sp:
271         lio->free(sp);
272 done:
273         return rval;
274 }
275
276 static void
277 qla2x00_async_adisc_ctx_done(srb_t *sp)
278 {
279         struct srb_ctx *ctx = sp->ctx;
280         struct srb_iocb *lio = ctx->u.iocb_cmd;
281
282         qla2x00_post_async_adisc_done_work(sp->fcport->vha, sp->fcport,
283             lio->u.logio.data);
284         lio->free(sp);
285 }
286
287 int
288 qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
289     uint16_t *data)
290 {
291         srb_t *sp;
292         struct srb_ctx *ctx;
293         struct srb_iocb *lio;
294         int rval;
295
296         rval = QLA_FUNCTION_FAILED;
297         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
298             qla2x00_get_async_timeout(vha) + 2);
299         if (!sp)
300                 goto done;
301
302         ctx = sp->ctx;
303         ctx->type = SRB_ADISC_CMD;
304         ctx->name = "adisc";
305         lio = ctx->u.iocb_cmd;
306         lio->timeout = qla2x00_async_iocb_timeout;
307         lio->done = qla2x00_async_adisc_ctx_done;
308         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
309                 lio->u.logio.flags |= SRB_LOGIN_RETRIED;
310         rval = qla2x00_start_sp(sp);
311         if (rval != QLA_SUCCESS)
312                 goto done_free_sp;
313
314         DEBUG2(printk(KERN_DEBUG
315             "scsi(%ld:%x): Async-adisc - loop-id=%x portid=%02x%02x%02x.\n",
316             fcport->vha->host_no, sp->handle, fcport->loop_id,
317             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
318
319         return rval;
320
321 done_free_sp:
322         lio->free(sp);
323 done:
324         return rval;
325 }
326
327 static void
328 qla2x00_async_tm_cmd_ctx_done(srb_t *sp)
329 {
330         struct srb_ctx *ctx = sp->ctx;
331         struct srb_iocb *iocb = (struct srb_iocb *)ctx->u.iocb_cmd;
332
333         qla2x00_async_tm_cmd_done(sp->fcport->vha, sp->fcport, iocb);
334         iocb->free(sp);
335 }
336
337 int
338 qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
339         uint32_t tag)
340 {
341         struct scsi_qla_host *vha = fcport->vha;
342         srb_t *sp;
343         struct srb_ctx *ctx;
344         struct srb_iocb *tcf;
345         int rval;
346
347         rval = QLA_FUNCTION_FAILED;
348         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
349             qla2x00_get_async_timeout(vha) + 2);
350         if (!sp)
351                 goto done;
352
353         ctx = sp->ctx;
354         ctx->type = SRB_TM_CMD;
355         ctx->name = "tmf";
356         tcf = ctx->u.iocb_cmd;
357         tcf->u.tmf.flags = flags;
358         tcf->u.tmf.lun = lun;
359         tcf->u.tmf.data = tag;
360         tcf->timeout = qla2x00_async_iocb_timeout;
361         tcf->done = qla2x00_async_tm_cmd_ctx_done;
362
363         rval = qla2x00_start_sp(sp);
364         if (rval != QLA_SUCCESS)
365                 goto done_free_sp;
366
367         DEBUG2(printk(KERN_DEBUG
368             "scsi(%ld:%x): Async-tmf - loop-id=%x portid=%02x%02x%02x.\n",
369             fcport->vha->host_no, sp->handle, fcport->loop_id,
370             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
371
372         return rval;
373
374 done_free_sp:
375         tcf->free(sp);
376 done:
377         return rval;
378 }
379
380 void
381 qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
382     uint16_t *data)
383 {
384         int rval;
385
386         switch (data[0]) {
387         case MBS_COMMAND_COMPLETE:
388                 if (fcport->flags & FCF_FCP2_DEVICE) {
389                         fcport->flags |= FCF_ASYNC_SENT;
390                         qla2x00_post_async_adisc_work(vha, fcport, data);
391                         break;
392                 }
393                 qla2x00_update_fcport(vha, fcport);
394                 break;
395         case MBS_COMMAND_ERROR:
396                 fcport->flags &= ~FCF_ASYNC_SENT;
397                 if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
398                         set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
399                 else
400                         qla2x00_mark_device_lost(vha, fcport, 1, 1);
401                 break;
402         case MBS_PORT_ID_USED:
403                 fcport->loop_id = data[1];
404                 qla2x00_post_async_logout_work(vha, fcport, NULL);
405                 qla2x00_post_async_login_work(vha, fcport, NULL);
406                 break;
407         case MBS_LOOP_ID_USED:
408                 fcport->loop_id++;
409                 rval = qla2x00_find_new_loop_id(vha, fcport);
410                 if (rval != QLA_SUCCESS) {
411                         fcport->flags &= ~FCF_ASYNC_SENT;
412                         qla2x00_mark_device_lost(vha, fcport, 1, 1);
413                         break;
414                 }
415                 qla2x00_post_async_login_work(vha, fcport, NULL);
416                 break;
417         }
418         return;
419 }
420
421 void
422 qla2x00_async_logout_done(struct scsi_qla_host *vha, fc_port_t *fcport,
423     uint16_t *data)
424 {
425         qla2x00_mark_device_lost(vha, fcport, 1, 0);
426         return;
427 }
428
429 void
430 qla2x00_async_adisc_done(struct scsi_qla_host *vha, fc_port_t *fcport,
431     uint16_t *data)
432 {
433         if (data[0] == MBS_COMMAND_COMPLETE) {
434                 qla2x00_update_fcport(vha, fcport);
435
436                 return;
437         }
438
439         /* Retry login. */
440         fcport->flags &= ~FCF_ASYNC_SENT;
441         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
442                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
443         else
444                 qla2x00_mark_device_lost(vha, fcport, 1, 1);
445
446         return;
447 }
448
449 void
450 qla2x00_async_tm_cmd_done(struct scsi_qla_host *vha, fc_port_t *fcport,
451     struct srb_iocb *iocb)
452 {
453         int rval;
454         uint32_t flags;
455         uint16_t lun;
456
457         flags = iocb->u.tmf.flags;
458         lun = (uint16_t)iocb->u.tmf.lun;
459
460         /* Issue Marker IOCB */
461         rval = qla2x00_marker(vha, vha->hw->req_q_map[0],
462                 vha->hw->rsp_q_map[0], fcport->loop_id, lun,
463                 flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
464
465         if ((rval != QLA_SUCCESS) || iocb->u.tmf.data) {
466                 DEBUG2_3_11(printk(KERN_WARNING
467                         "%s(%ld): TM IOCB failed (%x).\n",
468                         __func__, vha->host_no, rval));
469         }
470
471         return;
472 }
473
474 /****************************************************************************/
475 /*                QLogic ISP2x00 Hardware Support Functions.                */
476 /****************************************************************************/
477
478 /*
479 * qla2x00_initialize_adapter
480 *      Initialize board.
481 *
482 * Input:
483 *      ha = adapter block pointer.
484 *
485 * Returns:
486 *      0 = success
487 */
488 int
489 qla2x00_initialize_adapter(scsi_qla_host_t *vha)
490 {
491         int     rval;
492         struct qla_hw_data *ha = vha->hw;
493         struct req_que *req = ha->req_q_map[0];
494
495         /* Clear adapter flags. */
496         vha->flags.online = 0;
497         ha->flags.chip_reset_done = 0;
498         vha->flags.reset_active = 0;
499         ha->flags.pci_channel_io_perm_failure = 0;
500         ha->flags.eeh_busy = 0;
501         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
502         atomic_set(&vha->loop_state, LOOP_DOWN);
503         vha->device_flags = DFLG_NO_CABLE;
504         vha->dpc_flags = 0;
505         vha->flags.management_server_logged_in = 0;
506         vha->marker_needed = 0;
507         ha->isp_abort_cnt = 0;
508         ha->beacon_blink_led = 0;
509
510         set_bit(0, ha->req_qid_map);
511         set_bit(0, ha->rsp_qid_map);
512
513         qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
514         rval = ha->isp_ops->pci_config(vha);
515         if (rval) {
516                 DEBUG2(printk("scsi(%ld): Unable to configure PCI space.\n",
517                     vha->host_no));
518                 return (rval);
519         }
520
521         ha->isp_ops->reset_chip(vha);
522
523         rval = qla2xxx_get_flash_info(vha);
524         if (rval) {
525                 DEBUG2(printk("scsi(%ld): Unable to validate FLASH data.\n",
526                     vha->host_no));
527                 return (rval);
528         }
529
530         ha->isp_ops->get_flash_version(vha, req->ring);
531
532         qla_printk(KERN_INFO, ha, "Configure NVRAM parameters...\n");
533
534         ha->isp_ops->nvram_config(vha);
535
536         if (ha->flags.disable_serdes) {
537                 /* Mask HBA via NVRAM settings? */
538                 qla_printk(KERN_INFO, ha, "Masking HBA WWPN "
539                     "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
540                     vha->port_name[0], vha->port_name[1],
541                     vha->port_name[2], vha->port_name[3],
542                     vha->port_name[4], vha->port_name[5],
543                     vha->port_name[6], vha->port_name[7]);
544                 return QLA_FUNCTION_FAILED;
545         }
546
547         qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
548
549         if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
550                 rval = ha->isp_ops->chip_diag(vha);
551                 if (rval)
552                         return (rval);
553                 rval = qla2x00_setup_chip(vha);
554                 if (rval)
555                         return (rval);
556         }
557
558         if (IS_QLA84XX(ha)) {
559                 ha->cs84xx = qla84xx_get_chip(vha);
560                 if (!ha->cs84xx) {
561                         qla_printk(KERN_ERR, ha,
562                             "Unable to configure ISP84XX.\n");
563                         return QLA_FUNCTION_FAILED;
564                 }
565         }
566         rval = qla2x00_init_rings(vha);
567         ha->flags.chip_reset_done = 1;
568
569         if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
570                 /* Issue verify 84xx FW IOCB to complete 84xx initialization */
571                 rval = qla84xx_init_chip(vha);
572                 if (rval != QLA_SUCCESS) {
573                         qla_printk(KERN_ERR, ha,
574                                 "Unable to initialize ISP84XX.\n");
575                 qla84xx_put_chip(vha);
576                 }
577         }
578
579         if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
580                 qla24xx_read_fcp_prio_cfg(vha);
581
582         return (rval);
583 }
584
585 /**
586  * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
587  * @ha: HA context
588  *
589  * Returns 0 on success.
590  */
591 int
592 qla2100_pci_config(scsi_qla_host_t *vha)
593 {
594         uint16_t w;
595         unsigned long flags;
596         struct qla_hw_data *ha = vha->hw;
597         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
598
599         pci_set_master(ha->pdev);
600         pci_try_set_mwi(ha->pdev);
601
602         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
603         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
604         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
605
606         pci_disable_rom(ha->pdev);
607
608         /* Get PCI bus information. */
609         spin_lock_irqsave(&ha->hardware_lock, flags);
610         ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
611         spin_unlock_irqrestore(&ha->hardware_lock, flags);
612
613         return QLA_SUCCESS;
614 }
615
616 /**
617  * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
618  * @ha: HA context
619  *
620  * Returns 0 on success.
621  */
622 int
623 qla2300_pci_config(scsi_qla_host_t *vha)
624 {
625         uint16_t        w;
626         unsigned long   flags = 0;
627         uint32_t        cnt;
628         struct qla_hw_data *ha = vha->hw;
629         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
630
631         pci_set_master(ha->pdev);
632         pci_try_set_mwi(ha->pdev);
633
634         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
635         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
636
637         if (IS_QLA2322(ha) || IS_QLA6322(ha))
638                 w &= ~PCI_COMMAND_INTX_DISABLE;
639         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
640
641         /*
642          * If this is a 2300 card and not 2312, reset the
643          * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
644          * the 2310 also reports itself as a 2300 so we need to get the
645          * fb revision level -- a 6 indicates it really is a 2300 and
646          * not a 2310.
647          */
648         if (IS_QLA2300(ha)) {
649                 spin_lock_irqsave(&ha->hardware_lock, flags);
650
651                 /* Pause RISC. */
652                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
653                 for (cnt = 0; cnt < 30000; cnt++) {
654                         if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
655                                 break;
656
657                         udelay(10);
658                 }
659
660                 /* Select FPM registers. */
661                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
662                 RD_REG_WORD(&reg->ctrl_status);
663
664                 /* Get the fb rev level */
665                 ha->fb_rev = RD_FB_CMD_REG(ha, reg);
666
667                 if (ha->fb_rev == FPM_2300)
668                         pci_clear_mwi(ha->pdev);
669
670                 /* Deselect FPM registers. */
671                 WRT_REG_WORD(&reg->ctrl_status, 0x0);
672                 RD_REG_WORD(&reg->ctrl_status);
673
674                 /* Release RISC module. */
675                 WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
676                 for (cnt = 0; cnt < 30000; cnt++) {
677                         if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
678                                 break;
679
680                         udelay(10);
681                 }
682
683                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
684         }
685
686         pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
687
688         pci_disable_rom(ha->pdev);
689
690         /* Get PCI bus information. */
691         spin_lock_irqsave(&ha->hardware_lock, flags);
692         ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
693         spin_unlock_irqrestore(&ha->hardware_lock, flags);
694
695         return QLA_SUCCESS;
696 }
697
698 /**
699  * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
700  * @ha: HA context
701  *
702  * Returns 0 on success.
703  */
704 int
705 qla24xx_pci_config(scsi_qla_host_t *vha)
706 {
707         uint16_t w;
708         unsigned long flags = 0;
709         struct qla_hw_data *ha = vha->hw;
710         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
711
712         pci_set_master(ha->pdev);
713         pci_try_set_mwi(ha->pdev);
714
715         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
716         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
717         w &= ~PCI_COMMAND_INTX_DISABLE;
718         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
719
720         pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
721
722         /* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
723         if (pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX))
724                 pcix_set_mmrbc(ha->pdev, 2048);
725
726         /* PCIe -- adjust Maximum Read Request Size (2048). */
727         if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
728                 pcie_set_readrq(ha->pdev, 2048);
729
730         pci_disable_rom(ha->pdev);
731
732         ha->chip_revision = ha->pdev->revision;
733
734         /* Get PCI bus information. */
735         spin_lock_irqsave(&ha->hardware_lock, flags);
736         ha->pci_attr = RD_REG_DWORD(&reg->ctrl_status);
737         spin_unlock_irqrestore(&ha->hardware_lock, flags);
738
739         return QLA_SUCCESS;
740 }
741
742 /**
743  * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
744  * @ha: HA context
745  *
746  * Returns 0 on success.
747  */
748 int
749 qla25xx_pci_config(scsi_qla_host_t *vha)
750 {
751         uint16_t w;
752         struct qla_hw_data *ha = vha->hw;
753
754         pci_set_master(ha->pdev);
755         pci_try_set_mwi(ha->pdev);
756
757         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
758         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
759         w &= ~PCI_COMMAND_INTX_DISABLE;
760         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
761
762         /* PCIe -- adjust Maximum Read Request Size (2048). */
763         if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
764                 pcie_set_readrq(ha->pdev, 2048);
765
766         pci_disable_rom(ha->pdev);
767
768         ha->chip_revision = ha->pdev->revision;
769
770         return QLA_SUCCESS;
771 }
772
773 /**
774  * qla2x00_isp_firmware() - Choose firmware image.
775  * @ha: HA context
776  *
777  * Returns 0 on success.
778  */
779 static int
780 qla2x00_isp_firmware(scsi_qla_host_t *vha)
781 {
782         int  rval;
783         uint16_t loop_id, topo, sw_cap;
784         uint8_t domain, area, al_pa;
785         struct qla_hw_data *ha = vha->hw;
786
787         /* Assume loading risc code */
788         rval = QLA_FUNCTION_FAILED;
789
790         if (ha->flags.disable_risc_code_load) {
791                 DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
792                     vha->host_no));
793                 qla_printk(KERN_INFO, ha, "RISC CODE NOT loaded\n");
794
795                 /* Verify checksum of loaded RISC code. */
796                 rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
797                 if (rval == QLA_SUCCESS) {
798                         /* And, verify we are not in ROM code. */
799                         rval = qla2x00_get_adapter_id(vha, &loop_id, &al_pa,
800                             &area, &domain, &topo, &sw_cap);
801                 }
802         }
803
804         if (rval) {
805                 DEBUG2_3(printk("scsi(%ld): **** Load RISC code ****\n",
806                     vha->host_no));
807         }
808
809         return (rval);
810 }
811
812 /**
813  * qla2x00_reset_chip() - Reset ISP chip.
814  * @ha: HA context
815  *
816  * Returns 0 on success.
817  */
818 void
819 qla2x00_reset_chip(scsi_qla_host_t *vha)
820 {
821         unsigned long   flags = 0;
822         struct qla_hw_data *ha = vha->hw;
823         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
824         uint32_t        cnt;
825         uint16_t        cmd;
826
827         if (unlikely(pci_channel_offline(ha->pdev)))
828                 return;
829
830         ha->isp_ops->disable_intrs(ha);
831
832         spin_lock_irqsave(&ha->hardware_lock, flags);
833
834         /* Turn off master enable */
835         cmd = 0;
836         pci_read_config_word(ha->pdev, PCI_COMMAND, &cmd);
837         cmd &= ~PCI_COMMAND_MASTER;
838         pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
839
840         if (!IS_QLA2100(ha)) {
841                 /* Pause RISC. */
842                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
843                 if (IS_QLA2200(ha) || IS_QLA2300(ha)) {
844                         for (cnt = 0; cnt < 30000; cnt++) {
845                                 if ((RD_REG_WORD(&reg->hccr) &
846                                     HCCR_RISC_PAUSE) != 0)
847                                         break;
848                                 udelay(100);
849                         }
850                 } else {
851                         RD_REG_WORD(&reg->hccr);        /* PCI Posting. */
852                         udelay(10);
853                 }
854
855                 /* Select FPM registers. */
856                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
857                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
858
859                 /* FPM Soft Reset. */
860                 WRT_REG_WORD(&reg->fpm_diag_config, 0x100);
861                 RD_REG_WORD(&reg->fpm_diag_config);     /* PCI Posting. */
862
863                 /* Toggle Fpm Reset. */
864                 if (!IS_QLA2200(ha)) {
865                         WRT_REG_WORD(&reg->fpm_diag_config, 0x0);
866                         RD_REG_WORD(&reg->fpm_diag_config); /* PCI Posting. */
867                 }
868
869                 /* Select frame buffer registers. */
870                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
871                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
872
873                 /* Reset frame buffer FIFOs. */
874                 if (IS_QLA2200(ha)) {
875                         WRT_FB_CMD_REG(ha, reg, 0xa000);
876                         RD_FB_CMD_REG(ha, reg);         /* PCI Posting. */
877                 } else {
878                         WRT_FB_CMD_REG(ha, reg, 0x00fc);
879
880                         /* Read back fb_cmd until zero or 3 seconds max */
881                         for (cnt = 0; cnt < 3000; cnt++) {
882                                 if ((RD_FB_CMD_REG(ha, reg) & 0xff) == 0)
883                                         break;
884                                 udelay(100);
885                         }
886                 }
887
888                 /* Select RISC module registers. */
889                 WRT_REG_WORD(&reg->ctrl_status, 0);
890                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
891
892                 /* Reset RISC processor. */
893                 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
894                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
895
896                 /* Release RISC processor. */
897                 WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
898                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
899         }
900
901         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
902         WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);
903
904         /* Reset ISP chip. */
905         WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
906
907         /* Wait for RISC to recover from reset. */
908         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
909                 /*
910                  * It is necessary to for a delay here since the card doesn't
911                  * respond to PCI reads during a reset. On some architectures
912                  * this will result in an MCA.
913                  */
914                 udelay(20);
915                 for (cnt = 30000; cnt; cnt--) {
916                         if ((RD_REG_WORD(&reg->ctrl_status) &
917                             CSR_ISP_SOFT_RESET) == 0)
918                                 break;
919                         udelay(100);
920                 }
921         } else
922                 udelay(10);
923
924         /* Reset RISC processor. */
925         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
926
927         WRT_REG_WORD(&reg->semaphore, 0);
928
929         /* Release RISC processor. */
930         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
931         RD_REG_WORD(&reg->hccr);                        /* PCI Posting. */
932
933         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
934                 for (cnt = 0; cnt < 30000; cnt++) {
935                         if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
936                                 break;
937
938                         udelay(100);
939                 }
940         } else
941                 udelay(100);
942
943         /* Turn on master enable */
944         cmd |= PCI_COMMAND_MASTER;
945         pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
946
947         /* Disable RISC pause on FPM parity error. */
948         if (!IS_QLA2100(ha)) {
949                 WRT_REG_WORD(&reg->hccr, HCCR_DISABLE_PARITY_PAUSE);
950                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
951         }
952
953         spin_unlock_irqrestore(&ha->hardware_lock, flags);
954 }
955
956 /**
957  * qla81xx_reset_mpi() - Reset's MPI FW via Write MPI Register MBC.
958  *
959  * Returns 0 on success.
960  */
961 int
962 qla81xx_reset_mpi(scsi_qla_host_t *vha)
963 {
964         uint16_t mb[4] = {0x1010, 0, 1, 0};
965
966         return qla81xx_write_mpi_register(vha, mb);
967 }
968
969 /**
970  * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
971  * @ha: HA context
972  *
973  * Returns 0 on success.
974  */
975 static inline void
976 qla24xx_reset_risc(scsi_qla_host_t *vha)
977 {
978         unsigned long flags = 0;
979         struct qla_hw_data *ha = vha->hw;
980         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
981         uint32_t cnt, d2;
982         uint16_t wd;
983         static int abts_cnt; /* ISP abort retry counts */
984
985         spin_lock_irqsave(&ha->hardware_lock, flags);
986
987         /* Reset RISC. */
988         WRT_REG_DWORD(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
989         for (cnt = 0; cnt < 30000; cnt++) {
990                 if ((RD_REG_DWORD(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
991                         break;
992
993                 udelay(10);
994         }
995
996         WRT_REG_DWORD(&reg->ctrl_status,
997             CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
998         pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
999
1000         udelay(100);
1001         /* Wait for firmware to complete NVRAM accesses. */
1002         d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1003         for (cnt = 10000 ; cnt && d2; cnt--) {
1004                 udelay(5);
1005                 d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1006                 barrier();
1007         }
1008
1009         /* Wait for soft-reset to complete. */
1010         d2 = RD_REG_DWORD(&reg->ctrl_status);
1011         for (cnt = 6000000 ; cnt && (d2 & CSRX_ISP_SOFT_RESET); cnt--) {
1012                 udelay(5);
1013                 d2 = RD_REG_DWORD(&reg->ctrl_status);
1014                 barrier();
1015         }
1016
1017         /* If required, do an MPI FW reset now */
1018         if (test_and_clear_bit(MPI_RESET_NEEDED, &vha->dpc_flags)) {
1019                 if (qla81xx_reset_mpi(vha) != QLA_SUCCESS) {
1020                         if (++abts_cnt < 5) {
1021                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1022                                 set_bit(MPI_RESET_NEEDED, &vha->dpc_flags);
1023                         } else {
1024                                 /*
1025                                  * We exhausted the ISP abort retries. We have to
1026                                  * set the board offline.
1027                                  */
1028                                 abts_cnt = 0;
1029                                 vha->flags.online = 0;
1030                         }
1031                 }
1032         }
1033
1034         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
1035         RD_REG_DWORD(&reg->hccr);
1036
1037         WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
1038         RD_REG_DWORD(&reg->hccr);
1039
1040         WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
1041         RD_REG_DWORD(&reg->hccr);
1042
1043         d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1044         for (cnt = 6000000 ; cnt && d2; cnt--) {
1045                 udelay(5);
1046                 d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1047                 barrier();
1048         }
1049
1050         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1051
1052         if (IS_NOPOLLING_TYPE(ha))
1053                 ha->isp_ops->enable_intrs(ha);
1054 }
1055
1056 /**
1057  * qla24xx_reset_chip() - Reset ISP24xx chip.
1058  * @ha: HA context
1059  *
1060  * Returns 0 on success.
1061  */
1062 void
1063 qla24xx_reset_chip(scsi_qla_host_t *vha)
1064 {
1065         struct qla_hw_data *ha = vha->hw;
1066
1067         if (pci_channel_offline(ha->pdev) &&
1068             ha->flags.pci_channel_io_perm_failure) {
1069                 return;
1070         }
1071
1072         ha->isp_ops->disable_intrs(ha);
1073
1074         /* Perform RISC reset. */
1075         qla24xx_reset_risc(vha);
1076 }
1077
1078 /**
1079  * qla2x00_chip_diag() - Test chip for proper operation.
1080  * @ha: HA context
1081  *
1082  * Returns 0 on success.
1083  */
1084 int
1085 qla2x00_chip_diag(scsi_qla_host_t *vha)
1086 {
1087         int             rval;
1088         struct qla_hw_data *ha = vha->hw;
1089         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1090         unsigned long   flags = 0;
1091         uint16_t        data;
1092         uint32_t        cnt;
1093         uint16_t        mb[5];
1094         struct req_que *req = ha->req_q_map[0];
1095
1096         /* Assume a failed state */
1097         rval = QLA_FUNCTION_FAILED;
1098
1099         DEBUG3(printk("scsi(%ld): Testing device at %lx.\n",
1100             vha->host_no, (u_long)&reg->flash_address));
1101
1102         spin_lock_irqsave(&ha->hardware_lock, flags);
1103
1104         /* Reset ISP chip. */
1105         WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
1106
1107         /*
1108          * We need to have a delay here since the card will not respond while
1109          * in reset causing an MCA on some architectures.
1110          */
1111         udelay(20);
1112         data = qla2x00_debounce_register(&reg->ctrl_status);
1113         for (cnt = 6000000 ; cnt && (data & CSR_ISP_SOFT_RESET); cnt--) {
1114                 udelay(5);
1115                 data = RD_REG_WORD(&reg->ctrl_status);
1116                 barrier();
1117         }
1118
1119         if (!cnt)
1120                 goto chip_diag_failed;
1121
1122         DEBUG3(printk("scsi(%ld): Reset register cleared by chip reset\n",
1123             vha->host_no));
1124
1125         /* Reset RISC processor. */
1126         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
1127         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
1128
1129         /* Workaround for QLA2312 PCI parity error */
1130         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
1131                 data = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 0));
1132                 for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
1133                         udelay(5);
1134                         data = RD_MAILBOX_REG(ha, reg, 0);
1135                         barrier();
1136                 }
1137         } else
1138                 udelay(10);
1139
1140         if (!cnt)
1141                 goto chip_diag_failed;
1142
1143         /* Check product ID of chip */
1144         DEBUG3(printk("scsi(%ld): Checking product ID of chip\n", vha->host_no));
1145
1146         mb[1] = RD_MAILBOX_REG(ha, reg, 1);
1147         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
1148         mb[3] = RD_MAILBOX_REG(ha, reg, 3);
1149         mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
1150         if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
1151             mb[3] != PROD_ID_3) {
1152                 qla_printk(KERN_WARNING, ha,
1153                     "Wrong product ID = 0x%x,0x%x,0x%x\n", mb[1], mb[2], mb[3]);
1154
1155                 goto chip_diag_failed;
1156         }
1157         ha->product_id[0] = mb[1];
1158         ha->product_id[1] = mb[2];
1159         ha->product_id[2] = mb[3];
1160         ha->product_id[3] = mb[4];
1161
1162         /* Adjust fw RISC transfer size */
1163         if (req->length > 1024)
1164                 ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
1165         else
1166                 ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
1167                     req->length;
1168
1169         if (IS_QLA2200(ha) &&
1170             RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
1171                 /* Limit firmware transfer size with a 2200A */
1172                 DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
1173                     vha->host_no));
1174
1175                 ha->device_type |= DT_ISP2200A;
1176                 ha->fw_transfer_size = 128;
1177         }
1178
1179         /* Wrap Incoming Mailboxes Test. */
1180         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1181
1182         DEBUG3(printk("scsi(%ld): Checking mailboxes.\n", vha->host_no));
1183         rval = qla2x00_mbx_reg_test(vha);
1184         if (rval) {
1185                 DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
1186                     vha->host_no));
1187                 qla_printk(KERN_WARNING, ha,
1188                     "Failed mailbox send register test\n");
1189         }
1190         else {
1191                 /* Flag a successful rval */
1192                 rval = QLA_SUCCESS;
1193         }
1194         spin_lock_irqsave(&ha->hardware_lock, flags);
1195
1196 chip_diag_failed:
1197         if (rval)
1198                 DEBUG2_3(printk("scsi(%ld): Chip diagnostics **** FAILED "
1199                     "****\n", vha->host_no));
1200
1201         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1202
1203         return (rval);
1204 }
1205
1206 /**
1207  * qla24xx_chip_diag() - Test ISP24xx for proper operation.
1208  * @ha: HA context
1209  *
1210  * Returns 0 on success.
1211  */
1212 int
1213 qla24xx_chip_diag(scsi_qla_host_t *vha)
1214 {
1215         int rval;
1216         struct qla_hw_data *ha = vha->hw;
1217         struct req_que *req = ha->req_q_map[0];
1218
1219         if (IS_QLA82XX(ha))
1220                 return QLA_SUCCESS;
1221
1222         ha->fw_transfer_size = REQUEST_ENTRY_SIZE * req->length;
1223
1224         rval = qla2x00_mbx_reg_test(vha);
1225         if (rval) {
1226                 DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
1227                     vha->host_no));
1228                 qla_printk(KERN_WARNING, ha,
1229                     "Failed mailbox send register test\n");
1230         } else {
1231                 /* Flag a successful rval */
1232                 rval = QLA_SUCCESS;
1233         }
1234
1235         return rval;
1236 }
1237
1238 void
1239 qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
1240 {
1241         int rval;
1242         uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
1243             eft_size, fce_size, mq_size;
1244         dma_addr_t tc_dma;
1245         void *tc;
1246         struct qla_hw_data *ha = vha->hw;
1247         struct req_que *req = ha->req_q_map[0];
1248         struct rsp_que *rsp = ha->rsp_q_map[0];
1249
1250         if (ha->fw_dump) {
1251                 qla_printk(KERN_WARNING, ha,
1252                     "Firmware dump previously allocated.\n");
1253                 return;
1254         }
1255
1256         ha->fw_dumped = 0;
1257         fixed_size = mem_size = eft_size = fce_size = mq_size = 0;
1258         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
1259                 fixed_size = sizeof(struct qla2100_fw_dump);
1260         } else if (IS_QLA23XX(ha)) {
1261                 fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
1262                 mem_size = (ha->fw_memory_size - 0x11000 + 1) *
1263                     sizeof(uint16_t);
1264         } else if (IS_FWI2_CAPABLE(ha)) {
1265                 if (IS_QLA81XX(ha))
1266                         fixed_size = offsetof(struct qla81xx_fw_dump, ext_mem);
1267                 else if (IS_QLA25XX(ha))
1268                         fixed_size = offsetof(struct qla25xx_fw_dump, ext_mem);
1269                 else
1270                         fixed_size = offsetof(struct qla24xx_fw_dump, ext_mem);
1271                 mem_size = (ha->fw_memory_size - 0x100000 + 1) *
1272                     sizeof(uint32_t);
1273                 if (ha->mqenable)
1274                         mq_size = sizeof(struct qla2xxx_mq_chain);
1275                 /* Allocate memory for Fibre Channel Event Buffer. */
1276                 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
1277                         goto try_eft;
1278
1279                 tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
1280                     GFP_KERNEL);
1281                 if (!tc) {
1282                         qla_printk(KERN_WARNING, ha, "Unable to allocate "
1283                             "(%d KB) for FCE.\n", FCE_SIZE / 1024);
1284                         goto try_eft;
1285                 }
1286
1287                 memset(tc, 0, FCE_SIZE);
1288                 rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
1289                     ha->fce_mb, &ha->fce_bufs);
1290                 if (rval) {
1291                         qla_printk(KERN_WARNING, ha, "Unable to initialize "
1292                             "FCE (%d).\n", rval);
1293                         dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc,
1294                             tc_dma);
1295                         ha->flags.fce_enabled = 0;
1296                         goto try_eft;
1297                 }
1298
1299                 qla_printk(KERN_INFO, ha, "Allocated (%d KB) for FCE...\n",
1300                     FCE_SIZE / 1024);
1301
1302                 fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
1303                 ha->flags.fce_enabled = 1;
1304                 ha->fce_dma = tc_dma;
1305                 ha->fce = tc;
1306 try_eft:
1307                 /* Allocate memory for Extended Trace Buffer. */
1308                 tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
1309                     GFP_KERNEL);
1310                 if (!tc) {
1311                         qla_printk(KERN_WARNING, ha, "Unable to allocate "
1312                             "(%d KB) for EFT.\n", EFT_SIZE / 1024);
1313                         goto cont_alloc;
1314                 }
1315
1316                 memset(tc, 0, EFT_SIZE);
1317                 rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
1318                 if (rval) {
1319                         qla_printk(KERN_WARNING, ha, "Unable to initialize "
1320                             "EFT (%d).\n", rval);
1321                         dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc,
1322                             tc_dma);
1323                         goto cont_alloc;
1324                 }
1325
1326                 qla_printk(KERN_INFO, ha, "Allocated (%d KB) for EFT...\n",
1327                     EFT_SIZE / 1024);
1328
1329                 eft_size = EFT_SIZE;
1330                 ha->eft_dma = tc_dma;
1331                 ha->eft = tc;
1332         }
1333 cont_alloc:
1334         req_q_size = req->length * sizeof(request_t);
1335         rsp_q_size = rsp->length * sizeof(response_t);
1336
1337         dump_size = offsetof(struct qla2xxx_fw_dump, isp);
1338         dump_size += fixed_size + mem_size + req_q_size + rsp_q_size + eft_size;
1339         ha->chain_offset = dump_size;
1340         dump_size += mq_size + fce_size;
1341
1342         ha->fw_dump = vmalloc(dump_size);
1343         if (!ha->fw_dump) {
1344                 qla_printk(KERN_WARNING, ha, "Unable to allocate (%d KB) for "
1345                     "firmware dump!!!\n", dump_size / 1024);
1346
1347                 if (ha->fce) {
1348                         dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce,
1349                             ha->fce_dma);
1350                         ha->fce = NULL;
1351                         ha->fce_dma = 0;
1352                 }
1353
1354                 if (ha->eft) {
1355                         dma_free_coherent(&ha->pdev->dev, eft_size, ha->eft,
1356                             ha->eft_dma);
1357                         ha->eft = NULL;
1358                         ha->eft_dma = 0;
1359                 }
1360                 return;
1361         }
1362         qla_printk(KERN_INFO, ha, "Allocated (%d KB) for firmware dump...\n",
1363             dump_size / 1024);
1364
1365         ha->fw_dump_len = dump_size;
1366         ha->fw_dump->signature[0] = 'Q';
1367         ha->fw_dump->signature[1] = 'L';
1368         ha->fw_dump->signature[2] = 'G';
1369         ha->fw_dump->signature[3] = 'C';
1370         ha->fw_dump->version = __constant_htonl(1);
1371
1372         ha->fw_dump->fixed_size = htonl(fixed_size);
1373         ha->fw_dump->mem_size = htonl(mem_size);
1374         ha->fw_dump->req_q_size = htonl(req_q_size);
1375         ha->fw_dump->rsp_q_size = htonl(rsp_q_size);
1376
1377         ha->fw_dump->eft_size = htonl(eft_size);
1378         ha->fw_dump->eft_addr_l = htonl(LSD(ha->eft_dma));
1379         ha->fw_dump->eft_addr_h = htonl(MSD(ha->eft_dma));
1380
1381         ha->fw_dump->header_size =
1382             htonl(offsetof(struct qla2xxx_fw_dump, isp));
1383 }
1384
1385 static int
1386 qla81xx_mpi_sync(scsi_qla_host_t *vha)
1387 {
1388 #define MPS_MASK        0xe0
1389         int rval;
1390         uint16_t dc;
1391         uint32_t dw;
1392         struct qla_hw_data *ha = vha->hw;
1393
1394         if (!IS_QLA81XX(vha->hw))
1395                 return QLA_SUCCESS;
1396
1397         rval = qla2x00_write_ram_word(vha, 0x7c00, 1);
1398         if (rval != QLA_SUCCESS) {
1399                 DEBUG2(qla_printk(KERN_WARNING, ha,
1400                     "Sync-MPI: Unable to acquire semaphore.\n"));
1401                 goto done;
1402         }
1403
1404         pci_read_config_word(vha->hw->pdev, 0x54, &dc);
1405         rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
1406         if (rval != QLA_SUCCESS) {
1407                 DEBUG2(qla_printk(KERN_WARNING, ha,
1408                     "Sync-MPI: Unable to read sync.\n"));
1409                 goto done_release;
1410         }
1411
1412         dc &= MPS_MASK;
1413         if (dc == (dw & MPS_MASK))
1414                 goto done_release;
1415
1416         dw &= ~MPS_MASK;
1417         dw |= dc;
1418         rval = qla2x00_write_ram_word(vha, 0x7a15, dw);
1419         if (rval != QLA_SUCCESS) {
1420                 DEBUG2(qla_printk(KERN_WARNING, ha,
1421                     "Sync-MPI: Unable to gain sync.\n"));
1422         }
1423
1424 done_release:
1425         rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
1426         if (rval != QLA_SUCCESS) {
1427                 DEBUG2(qla_printk(KERN_WARNING, ha,
1428                     "Sync-MPI: Unable to release semaphore.\n"));
1429         }
1430
1431 done:
1432         return rval;
1433 }
1434
1435 /**
1436  * qla2x00_setup_chip() - Load and start RISC firmware.
1437  * @ha: HA context
1438  *
1439  * Returns 0 on success.
1440  */
1441 static int
1442 qla2x00_setup_chip(scsi_qla_host_t *vha)
1443 {
1444         int rval;
1445         uint32_t srisc_address = 0;
1446         struct qla_hw_data *ha = vha->hw;
1447         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1448         unsigned long flags;
1449         uint16_t fw_major_version;
1450
1451         if (IS_QLA82XX(ha)) {
1452                 rval = ha->isp_ops->load_risc(vha, &srisc_address);
1453                 if (rval == QLA_SUCCESS) {
1454                         qla2x00_stop_firmware(vha);
1455                         goto enable_82xx_npiv;
1456                 } else
1457                         goto failed;
1458         }
1459
1460         if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
1461                 /* Disable SRAM, Instruction RAM and GP RAM parity.  */
1462                 spin_lock_irqsave(&ha->hardware_lock, flags);
1463                 WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x0));
1464                 RD_REG_WORD(&reg->hccr);
1465                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1466         }
1467
1468         qla81xx_mpi_sync(vha);
1469
1470         /* Load firmware sequences */
1471         rval = ha->isp_ops->load_risc(vha, &srisc_address);
1472         if (rval == QLA_SUCCESS) {
1473                 DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
1474                     "code.\n", vha->host_no));
1475
1476                 rval = qla2x00_verify_checksum(vha, srisc_address);
1477                 if (rval == QLA_SUCCESS) {
1478                         /* Start firmware execution. */
1479                         DEBUG(printk("scsi(%ld): Checksum OK, start "
1480                             "firmware.\n", vha->host_no));
1481
1482                         rval = qla2x00_execute_fw(vha, srisc_address);
1483                         /* Retrieve firmware information. */
1484                         if (rval == QLA_SUCCESS) {
1485 enable_82xx_npiv:
1486                                 fw_major_version = ha->fw_major_version;
1487                                 rval = qla2x00_get_fw_version(vha,
1488                                     &ha->fw_major_version,
1489                                     &ha->fw_minor_version,
1490                                     &ha->fw_subminor_version,
1491                                     &ha->fw_attributes, &ha->fw_memory_size,
1492                                     ha->mpi_version, &ha->mpi_capabilities,
1493                                     ha->phy_version);
1494                                 if (rval != QLA_SUCCESS)
1495                                         goto failed;
1496                                 ha->flags.npiv_supported = 0;
1497                                 if (IS_QLA2XXX_MIDTYPE(ha) &&
1498                                          (ha->fw_attributes & BIT_2)) {
1499                                         ha->flags.npiv_supported = 1;
1500                                         if ((!ha->max_npiv_vports) ||
1501                                             ((ha->max_npiv_vports + 1) %
1502                                             MIN_MULTI_ID_FABRIC))
1503                                                 ha->max_npiv_vports =
1504                                                     MIN_MULTI_ID_FABRIC - 1;
1505                                 }
1506                                 qla2x00_get_resource_cnts(vha, NULL,
1507                                     &ha->fw_xcb_count, NULL, NULL,
1508                                     &ha->max_npiv_vports, NULL);
1509
1510                                 if (!fw_major_version && ql2xallocfwdump) {
1511                                         if (!IS_QLA82XX(ha))
1512                                                 qla2x00_alloc_fw_dump(vha);
1513                                 }
1514                         }
1515                 } else {
1516                         DEBUG2(printk(KERN_INFO
1517                             "scsi(%ld): ISP Firmware failed checksum.\n",
1518                             vha->host_no));
1519                 }
1520         }
1521
1522         if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
1523                 /* Enable proper parity. */
1524                 spin_lock_irqsave(&ha->hardware_lock, flags);
1525                 if (IS_QLA2300(ha))
1526                         /* SRAM parity */
1527                         WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x1);
1528                 else
1529                         /* SRAM, Instruction RAM and GP RAM parity */
1530                         WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x7);
1531                 RD_REG_WORD(&reg->hccr);
1532                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1533         }
1534
1535         if (rval == QLA_SUCCESS && IS_FAC_REQUIRED(ha)) {
1536                 uint32_t size;
1537
1538                 rval = qla81xx_fac_get_sector_size(vha, &size);
1539                 if (rval == QLA_SUCCESS) {
1540                         ha->flags.fac_supported = 1;
1541                         ha->fdt_block_size = size << 2;
1542                 } else {
1543                         qla_printk(KERN_ERR, ha,
1544                             "Unsupported FAC firmware (%d.%02d.%02d).\n",
1545                             ha->fw_major_version, ha->fw_minor_version,
1546                             ha->fw_subminor_version);
1547                 }
1548         }
1549 failed:
1550         if (rval) {
1551                 DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
1552                     vha->host_no));
1553         }
1554
1555         return (rval);
1556 }
1557
1558 /**
1559  * qla2x00_init_response_q_entries() - Initializes response queue entries.
1560  * @ha: HA context
1561  *
1562  * Beginning of request ring has initialization control block already built
1563  * by nvram config routine.
1564  *
1565  * Returns 0 on success.
1566  */
1567 void
1568 qla2x00_init_response_q_entries(struct rsp_que *rsp)
1569 {
1570         uint16_t cnt;
1571         response_t *pkt;
1572
1573         rsp->ring_ptr = rsp->ring;
1574         rsp->ring_index    = 0;
1575         rsp->status_srb = NULL;
1576         pkt = rsp->ring_ptr;
1577         for (cnt = 0; cnt < rsp->length; cnt++) {
1578                 pkt->signature = RESPONSE_PROCESSED;
1579                 pkt++;
1580         }
1581 }
1582
1583 /**
1584  * qla2x00_update_fw_options() - Read and process firmware options.
1585  * @ha: HA context
1586  *
1587  * Returns 0 on success.
1588  */
1589 void
1590 qla2x00_update_fw_options(scsi_qla_host_t *vha)
1591 {
1592         uint16_t swing, emphasis, tx_sens, rx_sens;
1593         struct qla_hw_data *ha = vha->hw;
1594
1595         memset(ha->fw_options, 0, sizeof(ha->fw_options));
1596         qla2x00_get_fw_options(vha, ha->fw_options);
1597
1598         if (IS_QLA2100(ha) || IS_QLA2200(ha))
1599                 return;
1600
1601         /* Serial Link options. */
1602         DEBUG3(printk("scsi(%ld): Serial link options:\n",
1603             vha->host_no));
1604         DEBUG3(qla2x00_dump_buffer((uint8_t *)&ha->fw_seriallink_options,
1605             sizeof(ha->fw_seriallink_options)));
1606
1607         ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
1608         if (ha->fw_seriallink_options[3] & BIT_2) {
1609                 ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;
1610
1611                 /*  1G settings */
1612                 swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
1613                 emphasis = (ha->fw_seriallink_options[2] &
1614                     (BIT_4 | BIT_3)) >> 3;
1615                 tx_sens = ha->fw_seriallink_options[0] &
1616                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
1617                 rx_sens = (ha->fw_seriallink_options[0] &
1618                     (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
1619                 ha->fw_options[10] = (emphasis << 14) | (swing << 8);
1620                 if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
1621                         if (rx_sens == 0x0)
1622                                 rx_sens = 0x3;
1623                         ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
1624                 } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
1625                         ha->fw_options[10] |= BIT_5 |
1626                             ((rx_sens & (BIT_1 | BIT_0)) << 2) |
1627                             (tx_sens & (BIT_1 | BIT_0));
1628
1629                 /*  2G settings */
1630                 swing = (ha->fw_seriallink_options[2] &
1631                     (BIT_7 | BIT_6 | BIT_5)) >> 5;
1632                 emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
1633                 tx_sens = ha->fw_seriallink_options[1] &
1634                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
1635                 rx_sens = (ha->fw_seriallink_options[1] &
1636                     (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
1637                 ha->fw_options[11] = (emphasis << 14) | (swing << 8);
1638                 if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
1639                         if (rx_sens == 0x0)
1640                                 rx_sens = 0x3;
1641                         ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
1642                 } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
1643                         ha->fw_options[11] |= BIT_5 |
1644                             ((rx_sens & (BIT_1 | BIT_0)) << 2) |
1645                             (tx_sens & (BIT_1 | BIT_0));
1646         }
1647
1648         /* FCP2 options. */
1649         /*  Return command IOCBs without waiting for an ABTS to complete. */
1650         ha->fw_options[3] |= BIT_13;
1651
1652         /* LED scheme. */
1653         if (ha->flags.enable_led_scheme)
1654                 ha->fw_options[2] |= BIT_12;
1655
1656         /* Detect ISP6312. */
1657         if (IS_QLA6312(ha))
1658                 ha->fw_options[2] |= BIT_13;
1659
1660         /* Update firmware options. */
1661         qla2x00_set_fw_options(vha, ha->fw_options);
1662 }
1663
1664 void
1665 qla24xx_update_fw_options(scsi_qla_host_t *vha)
1666 {
1667         int rval;
1668         struct qla_hw_data *ha = vha->hw;
1669
1670         if (IS_QLA82XX(ha))
1671                 return;
1672
1673         /* Update Serial Link options. */
1674         if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
1675                 return;
1676
1677         rval = qla2x00_set_serdes_params(vha,
1678             le16_to_cpu(ha->fw_seriallink_options24[1]),
1679             le16_to_cpu(ha->fw_seriallink_options24[2]),
1680             le16_to_cpu(ha->fw_seriallink_options24[3]));
1681         if (rval != QLA_SUCCESS) {
1682                 qla_printk(KERN_WARNING, ha,
1683                     "Unable to update Serial Link options (%x).\n", rval);
1684         }
1685 }
1686
1687 void
1688 qla2x00_config_rings(struct scsi_qla_host *vha)
1689 {
1690         struct qla_hw_data *ha = vha->hw;
1691         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1692         struct req_que *req = ha->req_q_map[0];
1693         struct rsp_que *rsp = ha->rsp_q_map[0];
1694
1695         /* Setup ring parameters in initialization control block. */
1696         ha->init_cb->request_q_outpointer = __constant_cpu_to_le16(0);
1697         ha->init_cb->response_q_inpointer = __constant_cpu_to_le16(0);
1698         ha->init_cb->request_q_length = cpu_to_le16(req->length);
1699         ha->init_cb->response_q_length = cpu_to_le16(rsp->length);
1700         ha->init_cb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
1701         ha->init_cb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
1702         ha->init_cb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
1703         ha->init_cb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1704
1705         WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
1706         WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
1707         WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
1708         WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
1709         RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg));            /* PCI Posting. */
1710 }
1711
1712 void
1713 qla24xx_config_rings(struct scsi_qla_host *vha)
1714 {
1715         struct qla_hw_data *ha = vha->hw;
1716         device_reg_t __iomem *reg = ISP_QUE_REG(ha, 0);
1717         struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp;
1718         struct qla_msix_entry *msix;
1719         struct init_cb_24xx *icb;
1720         uint16_t rid = 0;
1721         struct req_que *req = ha->req_q_map[0];
1722         struct rsp_que *rsp = ha->rsp_q_map[0];
1723
1724 /* Setup ring parameters in initialization control block. */
1725         icb = (struct init_cb_24xx *)ha->init_cb;
1726         icb->request_q_outpointer = __constant_cpu_to_le16(0);
1727         icb->response_q_inpointer = __constant_cpu_to_le16(0);
1728         icb->request_q_length = cpu_to_le16(req->length);
1729         icb->response_q_length = cpu_to_le16(rsp->length);
1730         icb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
1731         icb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
1732         icb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
1733         icb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1734
1735         if (ha->mqenable) {
1736                 icb->qos = __constant_cpu_to_le16(QLA_DEFAULT_QUE_QOS);
1737                 icb->rid = __constant_cpu_to_le16(rid);
1738                 if (ha->flags.msix_enabled) {
1739                         msix = &ha->msix_entries[1];
1740                         DEBUG2_17(printk(KERN_INFO
1741                         "Registering vector 0x%x for base que\n", msix->entry));
1742                         icb->msix = cpu_to_le16(msix->entry);
1743                 }
1744                 /* Use alternate PCI bus number */
1745                 if (MSB(rid))
1746                         icb->firmware_options_2 |=
1747                                 __constant_cpu_to_le32(BIT_19);
1748                 /* Use alternate PCI devfn */
1749                 if (LSB(rid))
1750                         icb->firmware_options_2 |=
1751                                 __constant_cpu_to_le32(BIT_18);
1752
1753                 /* Use Disable MSIX Handshake mode for capable adapters */
1754                 if (IS_MSIX_NACK_CAPABLE(ha)) {
1755                         icb->firmware_options_2 &=
1756                                 __constant_cpu_to_le32(~BIT_22);
1757                         ha->flags.disable_msix_handshake = 1;
1758                         qla_printk(KERN_INFO, ha,
1759                                 "MSIX Handshake Disable Mode turned on\n");
1760                 } else {
1761                         icb->firmware_options_2 |=
1762                                 __constant_cpu_to_le32(BIT_22);
1763                 }
1764                 icb->firmware_options_2 |= __constant_cpu_to_le32(BIT_23);
1765
1766                 WRT_REG_DWORD(&reg->isp25mq.req_q_in, 0);
1767                 WRT_REG_DWORD(&reg->isp25mq.req_q_out, 0);
1768                 WRT_REG_DWORD(&reg->isp25mq.rsp_q_in, 0);
1769                 WRT_REG_DWORD(&reg->isp25mq.rsp_q_out, 0);
1770         } else {
1771                 WRT_REG_DWORD(&reg->isp24.req_q_in, 0);
1772                 WRT_REG_DWORD(&reg->isp24.req_q_out, 0);
1773                 WRT_REG_DWORD(&reg->isp24.rsp_q_in, 0);
1774                 WRT_REG_DWORD(&reg->isp24.rsp_q_out, 0);
1775         }
1776         /* PCI posting */
1777         RD_REG_DWORD(&ioreg->hccr);
1778 }
1779
1780 /**
1781  * qla2x00_init_rings() - Initializes firmware.
1782  * @ha: HA context
1783  *
1784  * Beginning of request ring has initialization control block already built
1785  * by nvram config routine.
1786  *
1787  * Returns 0 on success.
1788  */
1789 static int
1790 qla2x00_init_rings(scsi_qla_host_t *vha)
1791 {
1792         int     rval;
1793         unsigned long flags = 0;
1794         int cnt, que;
1795         struct qla_hw_data *ha = vha->hw;
1796         struct req_que *req;
1797         struct rsp_que *rsp;
1798         struct scsi_qla_host *vp;
1799         struct mid_init_cb_24xx *mid_init_cb =
1800             (struct mid_init_cb_24xx *) ha->init_cb;
1801
1802         spin_lock_irqsave(&ha->hardware_lock, flags);
1803
1804         /* Clear outstanding commands array. */
1805         for (que = 0; que < ha->max_req_queues; que++) {
1806                 req = ha->req_q_map[que];
1807                 if (!req)
1808                         continue;
1809                 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
1810                         req->outstanding_cmds[cnt] = NULL;
1811
1812                 req->current_outstanding_cmd = 1;
1813
1814                 /* Initialize firmware. */
1815                 req->ring_ptr  = req->ring;
1816                 req->ring_index    = 0;
1817                 req->cnt      = req->length;
1818         }
1819
1820         for (que = 0; que < ha->max_rsp_queues; que++) {
1821                 rsp = ha->rsp_q_map[que];
1822                 if (!rsp)
1823                         continue;
1824                 /* Initialize response queue entries */
1825                 qla2x00_init_response_q_entries(rsp);
1826         }
1827
1828         spin_lock(&ha->vport_slock);
1829         /* Clear RSCN queue. */
1830         list_for_each_entry(vp, &ha->vp_list, list) {
1831                 vp->rscn_in_ptr = 0;
1832                 vp->rscn_out_ptr = 0;
1833         }
1834
1835         spin_unlock(&ha->vport_slock);
1836
1837         ha->isp_ops->config_rings(vha);
1838
1839         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1840
1841         /* Update any ISP specific firmware options before initialization. */
1842         ha->isp_ops->update_fw_options(vha);
1843
1844         DEBUG(printk("scsi(%ld): Issue init firmware.\n", vha->host_no));
1845
1846         if (ha->flags.npiv_supported) {
1847                 if (ha->operating_mode == LOOP)
1848                         ha->max_npiv_vports = MIN_MULTI_ID_FABRIC - 1;
1849                 mid_init_cb->count = cpu_to_le16(ha->max_npiv_vports);
1850         }
1851
1852         if (IS_FWI2_CAPABLE(ha)) {
1853                 mid_init_cb->options = __constant_cpu_to_le16(BIT_1);
1854                 mid_init_cb->init_cb.execution_throttle =
1855                     cpu_to_le16(ha->fw_xcb_count);
1856         }
1857
1858         rval = qla2x00_init_firmware(vha, ha->init_cb_size);
1859         if (rval) {
1860                 DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
1861                     vha->host_no));
1862         } else {
1863                 DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
1864                     vha->host_no));
1865         }
1866
1867         return (rval);
1868 }
1869
1870 /**
1871  * qla2x00_fw_ready() - Waits for firmware ready.
1872  * @ha: HA context
1873  *
1874  * Returns 0 on success.
1875  */
1876 static int
1877 qla2x00_fw_ready(scsi_qla_host_t *vha)
1878 {
1879         int             rval;
1880         unsigned long   wtime, mtime, cs84xx_time;
1881         uint16_t        min_wait;       /* Minimum wait time if loop is down */
1882         uint16_t        wait_time;      /* Wait time if loop is coming ready */
1883         uint16_t        state[5];
1884         struct qla_hw_data *ha = vha->hw;
1885
1886         rval = QLA_SUCCESS;
1887
1888         /* 20 seconds for loop down. */
1889         min_wait = 20;
1890
1891         /*
1892          * Firmware should take at most one RATOV to login, plus 5 seconds for
1893          * our own processing.
1894          */
1895         if ((wait_time = (ha->retry_count*ha->login_timeout) + 5) < min_wait) {
1896                 wait_time = min_wait;
1897         }
1898
1899         /* Min wait time if loop down */
1900         mtime = jiffies + (min_wait * HZ);
1901
1902         /* wait time before firmware ready */
1903         wtime = jiffies + (wait_time * HZ);
1904
1905         /* Wait for ISP to finish LIP */
1906         if (!vha->flags.init_done)
1907                 qla_printk(KERN_INFO, ha, "Waiting for LIP to complete...\n");
1908
1909         DEBUG3(printk("scsi(%ld): Waiting for LIP to complete...\n",
1910             vha->host_no));
1911
1912         do {
1913                 rval = qla2x00_get_firmware_state(vha, state);
1914                 if (rval == QLA_SUCCESS) {
1915                         if (state[0] < FSTATE_LOSS_OF_SYNC) {
1916                                 vha->device_flags &= ~DFLG_NO_CABLE;
1917                         }
1918                         if (IS_QLA84XX(ha) && state[0] != FSTATE_READY) {
1919                                 DEBUG16(printk("scsi(%ld): fw_state=%x "
1920                                     "84xx=%x.\n", vha->host_no, state[0],
1921                                     state[2]));
1922                                 if ((state[2] & FSTATE_LOGGED_IN) &&
1923                                      (state[2] & FSTATE_WAITING_FOR_VERIFY)) {
1924                                         DEBUG16(printk("scsi(%ld): Sending "
1925                                             "verify iocb.\n", vha->host_no));
1926
1927                                         cs84xx_time = jiffies;
1928                                         rval = qla84xx_init_chip(vha);
1929                                         if (rval != QLA_SUCCESS)
1930                                                 break;
1931
1932                                         /* Add time taken to initialize. */
1933                                         cs84xx_time = jiffies - cs84xx_time;
1934                                         wtime += cs84xx_time;
1935                                         mtime += cs84xx_time;
1936                                         DEBUG16(printk("scsi(%ld): Increasing "
1937                                             "wait time by %ld. New time %ld\n",
1938                                             vha->host_no, cs84xx_time, wtime));
1939                                 }
1940                         } else if (state[0] == FSTATE_READY) {
1941                                 DEBUG(printk("scsi(%ld): F/W Ready - OK \n",
1942                                     vha->host_no));
1943
1944                                 qla2x00_get_retry_cnt(vha, &ha->retry_count,
1945                                     &ha->login_timeout, &ha->r_a_tov);
1946
1947                                 rval = QLA_SUCCESS;
1948                                 break;
1949                         }
1950
1951                         rval = QLA_FUNCTION_FAILED;
1952
1953                         if (atomic_read(&vha->loop_down_timer) &&
1954                             state[0] != FSTATE_READY) {
1955                                 /* Loop down. Timeout on min_wait for states
1956                                  * other than Wait for Login.
1957                                  */
1958                                 if (time_after_eq(jiffies, mtime)) {
1959                                         qla_printk(KERN_INFO, ha,
1960                                             "Cable is unplugged...\n");
1961
1962                                         vha->device_flags |= DFLG_NO_CABLE;
1963                                         break;
1964                                 }
1965                         }
1966                 } else {
1967                         /* Mailbox cmd failed. Timeout on min_wait. */
1968                         if (time_after_eq(jiffies, mtime) ||
1969                             (IS_QLA82XX(ha) && ha->flags.fw_hung))
1970                                 break;
1971                 }
1972
1973                 if (time_after_eq(jiffies, wtime))
1974                         break;
1975
1976                 /* Delay for a while */
1977                 msleep(500);
1978
1979                 DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1980                     vha->host_no, state[0], jiffies));
1981         } while (1);
1982
1983         DEBUG(printk("scsi(%ld): fw_state=%x (%x, %x, %x, %x) curr time=%lx.\n",
1984             vha->host_no, state[0], state[1], state[2], state[3], state[4],
1985             jiffies));
1986
1987         if (rval) {
1988                 DEBUG2_3(printk("scsi(%ld): Firmware ready **** FAILED ****.\n",
1989                     vha->host_no));
1990         }
1991
1992         return (rval);
1993 }
1994
1995 /*
1996 *  qla2x00_configure_hba
1997 *      Setup adapter context.
1998 *
1999 * Input:
2000 *      ha = adapter state pointer.
2001 *
2002 * Returns:
2003 *      0 = success
2004 *
2005 * Context:
2006 *      Kernel context.
2007 */
2008 static int
2009 qla2x00_configure_hba(scsi_qla_host_t *vha)
2010 {
2011         int       rval;
2012         uint16_t      loop_id;
2013         uint16_t      topo;
2014         uint16_t      sw_cap;
2015         uint8_t       al_pa;
2016         uint8_t       area;
2017         uint8_t       domain;
2018         char            connect_type[22];
2019         struct qla_hw_data *ha = vha->hw;
2020
2021         /* Get host addresses. */
2022         rval = qla2x00_get_adapter_id(vha,
2023             &loop_id, &al_pa, &area, &domain, &topo, &sw_cap);
2024         if (rval != QLA_SUCCESS) {
2025                 if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
2026                     (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
2027                         DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
2028                             __func__, vha->host_no));
2029                 } else {
2030                         qla_printk(KERN_WARNING, ha,
2031                             "ERROR -- Unable to get host loop ID.\n");
2032                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2033                 }
2034                 return (rval);
2035         }
2036
2037         if (topo == 4) {
2038                 qla_printk(KERN_INFO, ha,
2039                         "Cannot get topology - retrying.\n");
2040                 return (QLA_FUNCTION_FAILED);
2041         }
2042
2043         vha->loop_id = loop_id;
2044
2045         /* initialize */
2046         ha->min_external_loopid = SNS_FIRST_LOOP_ID;
2047         ha->operating_mode = LOOP;
2048         ha->switch_cap = 0;
2049
2050         switch (topo) {
2051         case 0:
2052                 DEBUG3(printk("scsi(%ld): HBA in NL topology.\n",
2053                     vha->host_no));
2054                 ha->current_topology = ISP_CFG_NL;
2055                 strcpy(connect_type, "(Loop)");
2056                 break;
2057
2058         case 1:
2059                 DEBUG3(printk("scsi(%ld): HBA in FL topology.\n",
2060                     vha->host_no));
2061                 ha->switch_cap = sw_cap;
2062                 ha->current_topology = ISP_CFG_FL;
2063                 strcpy(connect_type, "(FL_Port)");
2064                 break;
2065
2066         case 2:
2067                 DEBUG3(printk("scsi(%ld): HBA in N P2P topology.\n",
2068                     vha->host_no));
2069                 ha->operating_mode = P2P;
2070                 ha->current_topology = ISP_CFG_N;
2071                 strcpy(connect_type, "(N_Port-to-N_Port)");
2072                 break;
2073
2074         case 3:
2075                 DEBUG3(printk("scsi(%ld): HBA in F P2P topology.\n",
2076                     vha->host_no));
2077                 ha->switch_cap = sw_cap;
2078                 ha->operating_mode = P2P;
2079                 ha->current_topology = ISP_CFG_F;
2080                 strcpy(connect_type, "(F_Port)");
2081                 break;
2082
2083         default:
2084                 DEBUG3(printk("scsi(%ld): HBA in unknown topology %x. "
2085                     "Using NL.\n",
2086                     vha->host_no, topo));
2087                 ha->current_topology = ISP_CFG_NL;
2088                 strcpy(connect_type, "(Loop)");
2089                 break;
2090         }
2091
2092         /* Save Host port and loop ID. */
2093         /* byte order - Big Endian */
2094         vha->d_id.b.domain = domain;
2095         vha->d_id.b.area = area;
2096         vha->d_id.b.al_pa = al_pa;
2097
2098         if (!vha->flags.init_done)
2099                 qla_printk(KERN_INFO, ha,
2100                     "Topology - %s, Host Loop address 0x%x\n",
2101                     connect_type, vha->loop_id);
2102
2103         if (rval) {
2104                 DEBUG2_3(printk("scsi(%ld): FAILED.\n", vha->host_no));
2105         } else {
2106                 DEBUG3(printk("scsi(%ld): exiting normally.\n", vha->host_no));
2107         }
2108
2109         return(rval);
2110 }
2111
2112 inline void
2113 qla2x00_set_model_info(scsi_qla_host_t *vha, uint8_t *model, size_t len,
2114         char *def)
2115 {
2116         char *st, *en;
2117         uint16_t index;
2118         struct qla_hw_data *ha = vha->hw;
2119         int use_tbl = !IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha) &&
2120             !IS_QLA8XXX_TYPE(ha);
2121
2122         if (memcmp(model, BINZERO, len) != 0) {
2123                 strncpy(ha->model_number, model, len);
2124                 st = en = ha->model_number;
2125                 en += len - 1;
2126                 while (en > st) {
2127                         if (*en != 0x20 && *en != 0x00)
2128                                 break;
2129                         *en-- = '\0';
2130                 }
2131
2132                 index = (ha->pdev->subsystem_device & 0xff);
2133                 if (use_tbl &&
2134                     ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2135                     index < QLA_MODEL_NAMES)
2136                         strncpy(ha->model_desc,
2137                             qla2x00_model_name[index * 2 + 1],
2138                             sizeof(ha->model_desc) - 1);
2139         } else {
2140                 index = (ha->pdev->subsystem_device & 0xff);
2141                 if (use_tbl &&
2142                     ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2143                     index < QLA_MODEL_NAMES) {
2144                         strcpy(ha->model_number,
2145                             qla2x00_model_name[index * 2]);
2146                         strncpy(ha->model_desc,
2147                             qla2x00_model_name[index * 2 + 1],
2148                             sizeof(ha->model_desc) - 1);
2149                 } else {
2150                         strcpy(ha->model_number, def);
2151                 }
2152         }
2153         if (IS_FWI2_CAPABLE(ha))
2154                 qla2xxx_get_vpd_field(vha, "\x82", ha->model_desc,
2155                     sizeof(ha->model_desc));
2156 }
2157
2158 /* On sparc systems, obtain port and node WWN from firmware
2159  * properties.
2160  */
2161 static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t *vha, nvram_t *nv)
2162 {
2163 #ifdef CONFIG_SPARC
2164         struct qla_hw_data *ha = vha->hw;
2165         struct pci_dev *pdev = ha->pdev;
2166         struct device_node *dp = pci_device_to_OF_node(pdev);
2167         const u8 *val;
2168         int len;
2169
2170         val = of_get_property(dp, "port-wwn", &len);
2171         if (val && len >= WWN_SIZE)
2172                 memcpy(nv->port_name, val, WWN_SIZE);
2173
2174         val = of_get_property(dp, "node-wwn", &len);
2175         if (val && len >= WWN_SIZE)
2176                 memcpy(nv->node_name, val, WWN_SIZE);
2177 #endif
2178 }
2179
2180 /*
2181 * NVRAM configuration for ISP 2xxx
2182 *
2183 * Input:
2184 *      ha                = adapter block pointer.
2185 *
2186 * Output:
2187 *      initialization control block in response_ring
2188 *      host adapters parameters in host adapter block
2189 *
2190 * Returns:
2191 *      0 = success.
2192 */
2193 int
2194 qla2x00_nvram_config(scsi_qla_host_t *vha)
2195 {
2196         int             rval;
2197         uint8_t         chksum = 0;
2198         uint16_t        cnt;
2199         uint8_t         *dptr1, *dptr2;
2200         struct qla_hw_data *ha = vha->hw;
2201         init_cb_t       *icb = ha->init_cb;
2202         nvram_t         *nv = ha->nvram;
2203         uint8_t         *ptr = ha->nvram;
2204         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2205
2206         rval = QLA_SUCCESS;
2207
2208         /* Determine NVRAM starting address. */
2209         ha->nvram_size = sizeof(nvram_t);
2210         ha->nvram_base = 0;
2211         if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha))
2212                 if ((RD_REG_WORD(&reg->ctrl_status) >> 14) == 1)
2213                         ha->nvram_base = 0x80;
2214
2215         /* Get NVRAM data and calculate checksum. */
2216         ha->isp_ops->read_nvram(vha, ptr, ha->nvram_base, ha->nvram_size);
2217         for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
2218                 chksum += *ptr++;
2219
2220         DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
2221         DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
2222
2223         /* Bad NVRAM data, set defaults parameters. */
2224         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
2225             nv->id[2] != 'P' || nv->id[3] != ' ' || nv->nvram_version < 1) {
2226                 /* Reset NVRAM data. */
2227                 qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
2228                     "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
2229                     nv->nvram_version);
2230                 qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
2231                     "invalid -- WWPN) defaults.\n");
2232
2233                 /*
2234                  * Set default initialization control block.
2235                  */
2236                 memset(nv, 0, ha->nvram_size);
2237                 nv->parameter_block_version = ICB_VERSION;
2238
2239                 if (IS_QLA23XX(ha)) {
2240                         nv->firmware_options[0] = BIT_2 | BIT_1;
2241                         nv->firmware_options[1] = BIT_7 | BIT_5;
2242                         nv->add_firmware_options[0] = BIT_5;
2243                         nv->add_firmware_options[1] = BIT_5 | BIT_4;
2244                         nv->frame_payload_size = __constant_cpu_to_le16(2048);
2245                         nv->special_options[1] = BIT_7;
2246                 } else if (IS_QLA2200(ha)) {
2247                         nv->firmware_options[0] = BIT_2 | BIT_1;
2248                         nv->firmware_options[1] = BIT_7 | BIT_5;
2249                         nv->add_firmware_options[0] = BIT_5;
2250                         nv->add_firmware_options[1] = BIT_5 | BIT_4;
2251                         nv->frame_payload_size = __constant_cpu_to_le16(1024);
2252                 } else if (IS_QLA2100(ha)) {
2253                         nv->firmware_options[0] = BIT_3 | BIT_1;
2254                         nv->firmware_options[1] = BIT_5;
2255                         nv->frame_payload_size = __constant_cpu_to_le16(1024);
2256                 }
2257
2258                 nv->max_iocb_allocation = __constant_cpu_to_le16(256);
2259                 nv->execution_throttle = __constant_cpu_to_le16(16);
2260                 nv->retry_count = 8;
2261                 nv->retry_delay = 1;
2262
2263                 nv->port_name[0] = 33;
2264                 nv->port_name[3] = 224;
2265                 nv->port_name[4] = 139;
2266
2267                 qla2xxx_nvram_wwn_from_ofw(vha, nv);
2268
2269                 nv->login_timeout = 4;
2270
2271                 /*
2272                  * Set default host adapter parameters
2273                  */
2274                 nv->host_p[1] = BIT_2;
2275                 nv->reset_delay = 5;
2276                 nv->port_down_retry_count = 8;
2277                 nv->max_luns_per_target = __constant_cpu_to_le16(8);
2278                 nv->link_down_timeout = 60;
2279
2280                 rval = 1;
2281         }
2282
2283 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2284         /*
2285          * The SN2 does not provide BIOS emulation which means you can't change
2286          * potentially bogus BIOS settings. Force the use of default settings
2287          * for link rate and frame size.  Hope that the rest of the settings
2288          * are valid.
2289          */
2290         if (ia64_platform_is("sn2")) {
2291                 nv->frame_payload_size = __constant_cpu_to_le16(2048);
2292                 if (IS_QLA23XX(ha))
2293                         nv->special_options[1] = BIT_7;
2294         }
2295 #endif
2296
2297         /* Reset Initialization control block */
2298         memset(icb, 0, ha->init_cb_size);
2299
2300         /*
2301          * Setup driver NVRAM options.
2302          */
2303         nv->firmware_options[0] |= (BIT_6 | BIT_1);
2304         nv->firmware_options[0] &= ~(BIT_5 | BIT_4);
2305         nv->firmware_options[1] |= (BIT_5 | BIT_0);
2306         nv->firmware_options[1] &= ~BIT_4;
2307
2308         if (IS_QLA23XX(ha)) {
2309                 nv->firmware_options[0] |= BIT_2;
2310                 nv->firmware_options[0] &= ~BIT_3;
2311                 nv->firmware_options[0] &= ~BIT_6;
2312                 nv->add_firmware_options[1] |= BIT_5 | BIT_4;
2313
2314                 if (IS_QLA2300(ha)) {
2315                         if (ha->fb_rev == FPM_2310) {
2316                                 strcpy(ha->model_number, "QLA2310");
2317                         } else {
2318                                 strcpy(ha->model_number, "QLA2300");
2319                         }
2320                 } else {
2321                         qla2x00_set_model_info(vha, nv->model_number,
2322                             sizeof(nv->model_number), "QLA23xx");
2323                 }
2324         } else if (IS_QLA2200(ha)) {
2325                 nv->firmware_options[0] |= BIT_2;
2326                 /*
2327                  * 'Point-to-point preferred, else loop' is not a safe
2328                  * connection mode setting.
2329                  */
2330                 if ((nv->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) ==
2331                     (BIT_5 | BIT_4)) {
2332                         /* Force 'loop preferred, else point-to-point'. */
2333                         nv->add_firmware_options[0] &= ~(BIT_6 | BIT_5 | BIT_4);
2334                         nv->add_firmware_options[0] |= BIT_5;
2335                 }
2336                 strcpy(ha->model_number, "QLA22xx");
2337         } else /*if (IS_QLA2100(ha))*/ {
2338                 strcpy(ha->model_number, "QLA2100");
2339         }
2340
2341         /*
2342          * Copy over NVRAM RISC parameter block to initialization control block.
2343          */
2344         dptr1 = (uint8_t *)icb;
2345         dptr2 = (uint8_t *)&nv->parameter_block_version;
2346         cnt = (uint8_t *)&icb->request_q_outpointer - (uint8_t *)&icb->version;
2347         while (cnt--)
2348                 *dptr1++ = *dptr2++;
2349
2350         /* Copy 2nd half. */
2351         dptr1 = (uint8_t *)icb->add_firmware_options;
2352         cnt = (uint8_t *)icb->reserved_3 - (uint8_t *)icb->add_firmware_options;
2353         while (cnt--)
2354                 *dptr1++ = *dptr2++;
2355
2356         /* Use alternate WWN? */
2357         if (nv->host_p[1] & BIT_7) {
2358                 memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
2359                 memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
2360         }
2361
2362         /* Prepare nodename */
2363         if ((icb->firmware_options[1] & BIT_6) == 0) {
2364                 /*
2365                  * Firmware will apply the following mask if the nodename was
2366                  * not provided.
2367                  */
2368                 memcpy(icb->node_name, icb->port_name, WWN_SIZE);
2369                 icb->node_name[0] &= 0xF0;
2370         }
2371
2372         /*
2373          * Set host adapter parameters.
2374          */
2375         if (nv->host_p[0] & BIT_7)
2376                 ql2xextended_error_logging = 1;
2377         ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
2378         /* Always load RISC code on non ISP2[12]00 chips. */
2379         if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
2380                 ha->flags.disable_risc_code_load = 0;
2381         ha->flags.enable_lip_reset = ((nv->host_p[1] & BIT_1) ? 1 : 0);
2382         ha->flags.enable_lip_full_login = ((nv->host_p[1] & BIT_2) ? 1 : 0);
2383         ha->flags.enable_target_reset = ((nv->host_p[1] & BIT_3) ? 1 : 0);
2384         ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
2385         ha->flags.disable_serdes = 0;
2386
2387         ha->operating_mode =
2388             (icb->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) >> 4;
2389
2390         memcpy(ha->fw_seriallink_options, nv->seriallink_options,
2391             sizeof(ha->fw_seriallink_options));
2392
2393         /* save HBA serial number */
2394         ha->serial0 = icb->port_name[5];
2395         ha->serial1 = icb->port_name[6];
2396         ha->serial2 = icb->port_name[7];
2397         memcpy(vha->node_name, icb->node_name, WWN_SIZE);
2398         memcpy(vha->port_name, icb->port_name, WWN_SIZE);
2399
2400         icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
2401
2402         ha->retry_count = nv->retry_count;
2403
2404         /* Set minimum login_timeout to 4 seconds. */
2405         if (nv->login_timeout != ql2xlogintimeout)
2406                 nv->login_timeout = ql2xlogintimeout;
2407         if (nv->login_timeout < 4)
2408                 nv->login_timeout = 4;
2409         ha->login_timeout = nv->login_timeout;
2410         icb->login_timeout = nv->login_timeout;
2411
2412         /* Set minimum RATOV to 100 tenths of a second. */
2413         ha->r_a_tov = 100;
2414
2415         ha->loop_reset_delay = nv->reset_delay;
2416
2417         /* Link Down Timeout = 0:
2418          *
2419          *      When Port Down timer expires we will start returning
2420          *      I/O's to OS with "DID_NO_CONNECT".
2421          *
2422          * Link Down Timeout != 0:
2423          *
2424          *       The driver waits for the link to come up after link down
2425          *       before returning I/Os to OS with "DID_NO_CONNECT".
2426          */
2427         if (nv->link_down_timeout == 0) {
2428                 ha->loop_down_abort_time =
2429                     (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
2430         } else {
2431                 ha->link_down_timeout =  nv->link_down_timeout;
2432                 ha->loop_down_abort_time =
2433                     (LOOP_DOWN_TIME - ha->link_down_timeout);
2434         }
2435
2436         /*
2437          * Need enough time to try and get the port back.
2438          */
2439         ha->port_down_retry_count = nv->port_down_retry_count;
2440         if (qlport_down_retry)
2441                 ha->port_down_retry_count = qlport_down_retry;
2442         /* Set login_retry_count */
2443         ha->login_retry_count  = nv->retry_count;
2444         if (ha->port_down_retry_count == nv->port_down_retry_count &&
2445             ha->port_down_retry_count > 3)
2446                 ha->login_retry_count = ha->port_down_retry_count;
2447         else if (ha->port_down_retry_count > (int)ha->login_retry_count)
2448                 ha->login_retry_count = ha->port_down_retry_count;
2449         if (ql2xloginretrycount)
2450                 ha->login_retry_count = ql2xloginretrycount;
2451
2452         icb->lun_enables = __constant_cpu_to_le16(0);
2453         icb->command_resource_count = 0;
2454         icb->immediate_notify_resource_count = 0;
2455         icb->timeout = __constant_cpu_to_le16(0);
2456
2457         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
2458                 /* Enable RIO */
2459                 icb->firmware_options[0] &= ~BIT_3;
2460                 icb->add_firmware_options[0] &=
2461                     ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2462                 icb->add_firmware_options[0] |= BIT_2;
2463                 icb->response_accumulation_timer = 3;
2464                 icb->interrupt_delay_timer = 5;
2465
2466                 vha->flags.process_response_queue = 1;
2467         } else {
2468                 /* Enable ZIO. */
2469                 if (!vha->flags.init_done) {
2470                         ha->zio_mode = icb->add_firmware_options[0] &
2471                             (BIT_3 | BIT_2 | BIT_1 | BIT_0);
2472                         ha->zio_timer = icb->interrupt_delay_timer ?
2473                             icb->interrupt_delay_timer: 2;
2474                 }
2475                 icb->add_firmware_options[0] &=
2476                     ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2477                 vha->flags.process_response_queue = 0;
2478                 if (ha->zio_mode != QLA_ZIO_DISABLED) {
2479                         ha->zio_mode = QLA_ZIO_MODE_6;
2480
2481                         DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
2482                             "delay (%d us).\n", vha->host_no, ha->zio_mode,
2483                             ha->zio_timer * 100));
2484                         qla_printk(KERN_INFO, ha,
2485                             "ZIO mode %d enabled; timer delay (%d us).\n",
2486                             ha->zio_mode, ha->zio_timer * 100);
2487
2488                         icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
2489                         icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
2490                         vha->flags.process_response_queue = 1;
2491                 }
2492         }
2493
2494         if (rval) {
2495                 DEBUG2_3(printk(KERN_WARNING
2496                     "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
2497         }
2498         return (rval);
2499 }
2500
2501 static void
2502 qla2x00_rport_del(void *data)
2503 {
2504         fc_port_t *fcport = data;
2505         struct fc_rport *rport;
2506
2507         spin_lock_irq(fcport->vha->host->host_lock);
2508         rport = fcport->drport ? fcport->drport: fcport->rport;
2509         fcport->drport = NULL;
2510         spin_unlock_irq(fcport->vha->host->host_lock);
2511         if (rport)
2512                 fc_remote_port_delete(rport);
2513 }
2514
2515 /**
2516  * qla2x00_alloc_fcport() - Allocate a generic fcport.
2517  * @ha: HA context
2518  * @flags: allocation flags
2519  *
2520  * Returns a pointer to the allocated fcport, or NULL, if none available.
2521  */
2522 fc_port_t *
2523 qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
2524 {
2525         fc_port_t *fcport;
2526
2527         fcport = kzalloc(sizeof(fc_port_t), flags);
2528         if (!fcport)
2529                 return NULL;
2530
2531         /* Setup fcport template structure. */
2532         fcport->vha = vha;
2533         fcport->vp_idx = vha->vp_idx;
2534         fcport->port_type = FCT_UNKNOWN;
2535         fcport->loop_id = FC_NO_LOOP_ID;
2536         atomic_set(&fcport->state, FCS_UNCONFIGURED);
2537         fcport->supported_classes = FC_COS_UNSPECIFIED;
2538
2539         return fcport;
2540 }
2541
2542 /*
2543  * qla2x00_configure_loop
2544  *      Updates Fibre Channel Device Database with what is actually on loop.
2545  *
2546  * Input:
2547  *      ha                = adapter block pointer.
2548  *
2549  * Returns:
2550  *      0 = success.
2551  *      1 = error.
2552  *      2 = database was full and device was not configured.
2553  */
2554 static int
2555 qla2x00_configure_loop(scsi_qla_host_t *vha)
2556 {
2557         int  rval;
2558         unsigned long flags, save_flags;
2559         struct qla_hw_data *ha = vha->hw;
2560         rval = QLA_SUCCESS;
2561
2562         /* Get Initiator ID */
2563         if (test_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags)) {
2564                 rval = qla2x00_configure_hba(vha);
2565                 if (rval != QLA_SUCCESS) {
2566                         DEBUG(printk("scsi(%ld): Unable to configure HBA.\n",
2567                             vha->host_no));
2568                         return (rval);
2569                 }
2570         }
2571
2572         save_flags = flags = vha->dpc_flags;
2573         DEBUG(printk("scsi(%ld): Configure loop -- dpc flags =0x%lx\n",
2574             vha->host_no, flags));
2575
2576         /*
2577          * If we have both an RSCN and PORT UPDATE pending then handle them
2578          * both at the same time.
2579          */
2580         clear_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2581         clear_bit(RSCN_UPDATE, &vha->dpc_flags);
2582
2583         qla2x00_get_data_rate(vha);
2584
2585         /* Determine what we need to do */
2586         if (ha->current_topology == ISP_CFG_FL &&
2587             (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
2588
2589                 vha->flags.rscn_queue_overflow = 1;
2590                 set_bit(RSCN_UPDATE, &flags);
2591
2592         } else if (ha->current_topology == ISP_CFG_F &&
2593             (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
2594
2595                 vha->flags.rscn_queue_overflow = 1;
2596                 set_bit(RSCN_UPDATE, &flags);
2597                 clear_bit(LOCAL_LOOP_UPDATE, &flags);
2598
2599         } else if (ha->current_topology == ISP_CFG_N) {
2600                 clear_bit(RSCN_UPDATE, &flags);
2601
2602         } else if (!vha->flags.online ||
2603             (test_bit(ABORT_ISP_ACTIVE, &flags))) {
2604
2605                 vha->flags.rscn_queue_overflow = 1;
2606                 set_bit(RSCN_UPDATE, &flags);
2607                 set_bit(LOCAL_LOOP_UPDATE, &flags);
2608         }
2609
2610         if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
2611                 if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
2612                         rval = QLA_FUNCTION_FAILED;
2613                 else
2614                         rval = qla2x00_configure_local_loop(vha);
2615         }
2616
2617         if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
2618                 if (LOOP_TRANSITION(vha))
2619                         rval = QLA_FUNCTION_FAILED;
2620                 else
2621                         rval = qla2x00_configure_fabric(vha);
2622         }
2623
2624         if (rval == QLA_SUCCESS) {
2625                 if (atomic_read(&vha->loop_down_timer) ||
2626                     test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
2627                         rval = QLA_FUNCTION_FAILED;
2628                 } else {
2629                         atomic_set(&vha->loop_state, LOOP_READY);
2630
2631                         DEBUG(printk("scsi(%ld): LOOP READY\n", vha->host_no));
2632                 }
2633         }
2634
2635         if (rval) {
2636                 DEBUG2_3(printk("%s(%ld): *** FAILED ***\n",
2637                     __func__, vha->host_no));
2638         } else {
2639                 DEBUG3(printk("%s: exiting normally\n", __func__));
2640         }
2641
2642         /* Restore state if a resync event occurred during processing */
2643         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
2644                 if (test_bit(LOCAL_LOOP_UPDATE, &save_flags))
2645                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2646                 if (test_bit(RSCN_UPDATE, &save_flags)) {
2647                         set_bit(RSCN_UPDATE, &vha->dpc_flags);
2648                         if (!IS_ALOGIO_CAPABLE(ha))
2649                                 vha->flags.rscn_queue_overflow = 1;
2650                 }
2651         }
2652
2653         return (rval);
2654 }
2655
2656
2657
2658 /*
2659  * qla2x00_configure_local_loop
2660  *      Updates Fibre Channel Device Database with local loop devices.
2661  *
2662  * Input:
2663  *      ha = adapter block pointer.
2664  *
2665  * Returns:
2666  *      0 = success.
2667  */
2668 static int
2669 qla2x00_configure_local_loop(scsi_qla_host_t *vha)
2670 {
2671         int             rval, rval2;
2672         int             found_devs;
2673         int             found;
2674         fc_port_t       *fcport, *new_fcport;
2675
2676         uint16_t        index;
2677         uint16_t        entries;
2678         char            *id_iter;
2679         uint16_t        loop_id;
2680         uint8_t         domain, area, al_pa;
2681         struct qla_hw_data *ha = vha->hw;
2682
2683         found_devs = 0;
2684         new_fcport = NULL;
2685         entries = MAX_FIBRE_DEVICES;
2686
2687         DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", vha->host_no));
2688         DEBUG3(qla2x00_get_fcal_position_map(vha, NULL));
2689
2690         /* Get list of logged in devices. */
2691         memset(ha->gid_list, 0, GID_LIST_SIZE);
2692         rval = qla2x00_get_id_list(vha, ha->gid_list, ha->gid_list_dma,
2693             &entries);
2694         if (rval != QLA_SUCCESS)
2695                 goto cleanup_allocation;
2696
2697         DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
2698             vha->host_no, entries));
2699         DEBUG3(qla2x00_dump_buffer((uint8_t *)ha->gid_list,
2700             entries * sizeof(struct gid_list_info)));
2701
2702         /* Allocate temporary fcport for any new fcports discovered. */
2703         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2704         if (new_fcport == NULL) {
2705                 rval = QLA_MEMORY_ALLOC_FAILED;
2706                 goto cleanup_allocation;
2707         }
2708         new_fcport->flags &= ~FCF_FABRIC_DEVICE;
2709
2710         /*
2711          * Mark local devices that were present with FCF_DEVICE_LOST for now.
2712          */
2713         list_for_each_entry(fcport, &vha->vp_fcports, list) {
2714                 if (atomic_read(&fcport->state) == FCS_ONLINE &&
2715                     fcport->port_type != FCT_BROADCAST &&
2716                     (fcport->flags & FCF_FABRIC_DEVICE) == 0) {
2717
2718                         DEBUG(printk("scsi(%ld): Marking port lost, "
2719                             "loop_id=0x%04x\n",
2720                             vha->host_no, fcport->loop_id));
2721
2722                         atomic_set(&fcport->state, FCS_DEVICE_LOST);
2723                 }
2724         }
2725
2726         /* Add devices to port list. */
2727         id_iter = (char *)ha->gid_list;
2728         for (index = 0; index < entries; index++) {
2729                 domain = ((struct gid_list_info *)id_iter)->domain;
2730                 area = ((struct gid_list_info *)id_iter)->area;
2731                 al_pa = ((struct gid_list_info *)id_iter)->al_pa;
2732                 if (IS_QLA2100(ha) || IS_QLA2200(ha))
2733                         loop_id = (uint16_t)
2734                             ((struct gid_list_info *)id_iter)->loop_id_2100;
2735                 else
2736                         loop_id = le16_to_cpu(
2737                             ((struct gid_list_info *)id_iter)->loop_id);
2738                 id_iter += ha->gid_list_info_size;
2739
2740                 /* Bypass reserved domain fields. */
2741                 if ((domain & 0xf0) == 0xf0)
2742                         continue;
2743
2744                 /* Bypass if not same domain and area of adapter. */
2745                 if (area && domain &&
2746                     (area != vha->d_id.b.area || domain != vha->d_id.b.domain))
2747                         continue;
2748
2749                 /* Bypass invalid local loop ID. */
2750                 if (loop_id > LAST_LOCAL_LOOP_ID)
2751                         continue;
2752
2753                 /* Fill in member data. */
2754                 new_fcport->d_id.b.domain = domain;
2755                 new_fcport->d_id.b.area = area;
2756                 new_fcport->d_id.b.al_pa = al_pa;
2757                 new_fcport->loop_id = loop_id;
2758                 new_fcport->vp_idx = vha->vp_idx;
2759                 rval2 = qla2x00_get_port_database(vha, new_fcport, 0);
2760                 if (rval2 != QLA_SUCCESS) {
2761                         DEBUG2(printk("scsi(%ld): Failed to retrieve fcport "
2762                             "information -- get_port_database=%x, "
2763                             "loop_id=0x%04x\n",
2764                             vha->host_no, rval2, new_fcport->loop_id));
2765                         DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
2766                             vha->host_no));
2767                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
2768                         continue;
2769                 }
2770
2771                 /* Check for matching device in port list. */
2772                 found = 0;
2773                 fcport = NULL;
2774                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2775                         if (memcmp(new_fcport->port_name, fcport->port_name,
2776                             WWN_SIZE))
2777                                 continue;
2778
2779                         fcport->flags &= ~FCF_FABRIC_DEVICE;
2780                         fcport->loop_id = new_fcport->loop_id;
2781                         fcport->port_type = new_fcport->port_type;
2782                         fcport->d_id.b24 = new_fcport->d_id.b24;
2783                         memcpy(fcport->node_name, new_fcport->node_name,
2784                             WWN_SIZE);
2785
2786                         found++;
2787                         break;
2788                 }
2789
2790                 if (!found) {
2791                         /* New device, add to fcports list. */
2792                         if (vha->vp_idx) {
2793                                 new_fcport->vha = vha;
2794                                 new_fcport->vp_idx = vha->vp_idx;
2795                         }
2796                         list_add_tail(&new_fcport->list, &vha->vp_fcports);
2797
2798                         /* Allocate a new replacement fcport. */
2799                         fcport = new_fcport;
2800                         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2801                         if (new_fcport == NULL) {
2802                                 rval = QLA_MEMORY_ALLOC_FAILED;
2803                                 goto cleanup_allocation;
2804                         }
2805                         new_fcport->flags &= ~FCF_FABRIC_DEVICE;
2806                 }
2807
2808                 /* Base iIDMA settings on HBA port speed. */
2809                 fcport->fp_speed = ha->link_data_rate;
2810
2811                 qla2x00_update_fcport(vha, fcport);
2812
2813                 found_devs++;
2814         }
2815
2816 cleanup_allocation:
2817         kfree(new_fcport);
2818
2819         if (rval != QLA_SUCCESS) {
2820                 DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
2821                     "rval=%x\n", vha->host_no, rval));
2822         }
2823
2824         return (rval);
2825 }
2826
2827 static void
2828 qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2829 {
2830 #define LS_UNKNOWN      2
2831         static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
2832         char *link_speed;
2833         int rval;
2834         uint16_t mb[4];
2835         struct qla_hw_data *ha = vha->hw;
2836
2837         if (!IS_IIDMA_CAPABLE(ha))
2838                 return;
2839
2840         if (atomic_read(&fcport->state) != FCS_ONLINE)
2841                 return;
2842
2843         if (fcport->fp_speed == PORT_SPEED_UNKNOWN ||
2844             fcport->fp_speed > ha->link_data_rate)
2845                 return;
2846
2847         rval = qla2x00_set_idma_speed(vha, fcport->loop_id, fcport->fp_speed,
2848             mb);
2849         if (rval != QLA_SUCCESS) {
2850                 DEBUG2(printk("scsi(%ld): Unable to adjust iIDMA "
2851                     "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x %04x.\n",
2852                     vha->host_no, fcport->port_name[0], fcport->port_name[1],
2853                     fcport->port_name[2], fcport->port_name[3],
2854                     fcport->port_name[4], fcport->port_name[5],
2855                     fcport->port_name[6], fcport->port_name[7], rval,
2856                     fcport->fp_speed, mb[0], mb[1]));
2857         } else {
2858                 link_speed = link_speeds[LS_UNKNOWN];
2859                 if (fcport->fp_speed < 5)
2860                         link_speed = link_speeds[fcport->fp_speed];
2861                 else if (fcport->fp_speed == 0x13)
2862                         link_speed = link_speeds[5];
2863                 DEBUG2(qla_printk(KERN_INFO, ha,
2864                     "iIDMA adjusted to %s GB/s on "
2865                     "%02x%02x%02x%02x%02x%02x%02x%02x.\n",
2866                     link_speed, fcport->port_name[0],
2867                     fcport->port_name[1], fcport->port_name[2],
2868                     fcport->port_name[3], fcport->port_name[4],
2869                     fcport->port_name[5], fcport->port_name[6],
2870                     fcport->port_name[7]));
2871         }
2872 }
2873
2874 static void
2875 qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
2876 {
2877         struct fc_rport_identifiers rport_ids;
2878         struct fc_rport *rport;
2879         struct qla_hw_data *ha = vha->hw;
2880
2881         qla2x00_rport_del(fcport);
2882
2883         rport_ids.node_name = wwn_to_u64(fcport->node_name);
2884         rport_ids.port_name = wwn_to_u64(fcport->port_name);
2885         rport_ids.port_id = fcport->d_id.b.domain << 16 |
2886             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2887         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2888         fcport->rport = rport = fc_remote_port_add(vha->host, 0, &rport_ids);
2889         if (!rport) {
2890                 qla_printk(KERN_WARNING, ha,
2891                     "Unable to allocate fc remote port!\n");
2892                 return;
2893         }
2894         spin_lock_irq(fcport->vha->host->host_lock);
2895         *((fc_port_t **)rport->dd_data) = fcport;
2896         spin_unlock_irq(fcport->vha->host->host_lock);
2897
2898         rport->supported_classes = fcport->supported_classes;
2899
2900         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2901         if (fcport->port_type == FCT_INITIATOR)
2902                 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
2903         if (fcport->port_type == FCT_TARGET)
2904                 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
2905         fc_remote_port_rolechg(rport, rport_ids.roles);
2906 }
2907
2908 /*
2909  * qla2x00_update_fcport
2910  *      Updates device on list.
2911  *
2912  * Input:
2913  *      ha = adapter block pointer.
2914  *      fcport = port structure pointer.
2915  *
2916  * Return:
2917  *      0  - Success
2918  *  BIT_0 - error
2919  *
2920  * Context:
2921  *      Kernel context.
2922  */
2923 void
2924 qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2925 {
2926         fcport->vha = vha;
2927         fcport->login_retry = 0;
2928         fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
2929
2930         qla2x00_iidma_fcport(vha, fcport);
2931         qla2x00_reg_remote_port(vha, fcport);
2932         atomic_set(&fcport->state, FCS_ONLINE);
2933 }
2934
2935 /*
2936  * qla2x00_configure_fabric
2937  *      Setup SNS devices with loop ID's.
2938  *
2939  * Input:
2940  *      ha = adapter block pointer.
2941  *
2942  * Returns:
2943  *      0 = success.
2944  *      BIT_0 = error
2945  */
2946 static int
2947 qla2x00_configure_fabric(scsi_qla_host_t *vha)
2948 {
2949         int     rval, rval2;
2950         fc_port_t       *fcport, *fcptemp;
2951         uint16_t        next_loopid;
2952         uint16_t        mb[MAILBOX_REGISTER_COUNT];
2953         uint16_t        loop_id;
2954         LIST_HEAD(new_fcports);
2955         struct qla_hw_data *ha = vha->hw;
2956         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2957
2958         /* If FL port exists, then SNS is present */
2959         if (IS_FWI2_CAPABLE(ha))
2960                 loop_id = NPH_F_PORT;
2961         else
2962                 loop_id = SNS_FL_PORT;
2963         rval = qla2x00_get_port_name(vha, loop_id, vha->fabric_node_name, 1);
2964         if (rval != QLA_SUCCESS) {
2965                 DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
2966                     "Port\n", vha->host_no));
2967
2968                 vha->device_flags &= ~SWITCH_FOUND;
2969                 return (QLA_SUCCESS);
2970         }
2971         vha->device_flags |= SWITCH_FOUND;
2972
2973         /* Mark devices that need re-synchronization. */
2974         rval2 = qla2x00_device_resync(vha);
2975         if (rval2 == QLA_RSCNS_HANDLED) {
2976                 /* No point doing the scan, just continue. */
2977                 return (QLA_SUCCESS);
2978         }
2979         do {
2980                 /* FDMI support. */
2981                 if (ql2xfdmienable &&
2982                     test_and_clear_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags))
2983                         qla2x00_fdmi_register(vha);
2984
2985                 /* Ensure we are logged into the SNS. */
2986                 if (IS_FWI2_CAPABLE(ha))
2987                         loop_id = NPH_SNS;
2988                 else
2989                         loop_id = SIMPLE_NAME_SERVER;
2990                 ha->isp_ops->fabric_login(vha, loop_id, 0xff, 0xff,
2991                     0xfc, mb, BIT_1 | BIT_0);
2992                 if (mb[0] != MBS_COMMAND_COMPLETE) {
2993                         DEBUG2(qla_printk(KERN_INFO, ha,
2994                             "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
2995                             "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id,
2996                             mb[0], mb[1], mb[2], mb[6], mb[7]));
2997                         return (QLA_SUCCESS);
2998                 }
2999
3000                 if (test_and_clear_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags)) {
3001                         if (qla2x00_rft_id(vha)) {
3002                                 /* EMPTY */
3003                                 DEBUG2(printk("scsi(%ld): Register FC-4 "
3004                                     "TYPE failed.\n", vha->host_no));
3005                         }
3006                         if (qla2x00_rff_id(vha)) {
3007                                 /* EMPTY */
3008                                 DEBUG2(printk("scsi(%ld): Register FC-4 "
3009                                     "Features failed.\n", vha->host_no));
3010                         }
3011                         if (qla2x00_rnn_id(vha)) {
3012                                 /* EMPTY */
3013                                 DEBUG2(printk("scsi(%ld): Register Node Name "
3014                                     "failed.\n", vha->host_no));
3015                         } else if (qla2x00_rsnn_nn(vha)) {
3016                                 /* EMPTY */
3017                                 DEBUG2(printk("scsi(%ld): Register Symbolic "
3018                                     "Node Name failed.\n", vha->host_no));
3019                         }
3020                 }
3021
3022                 rval = qla2x00_find_all_fabric_devs(vha, &new_fcports);
3023                 if (rval != QLA_SUCCESS)
3024                         break;
3025
3026                 /*
3027                  * Logout all previous fabric devices marked lost, except
3028                  * FCP2 devices.
3029                  */
3030                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3031                         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
3032                                 break;
3033
3034                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0)
3035                                 continue;
3036
3037                         if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
3038                                 qla2x00_mark_device_lost(vha, fcport,
3039                                     ql2xplogiabsentdevice, 0);
3040                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
3041                                     (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
3042                                     fcport->port_type != FCT_INITIATOR &&
3043                                     fcport->port_type != FCT_BROADCAST) {
3044                                         ha->isp_ops->fabric_logout(vha,
3045                                             fcport->loop_id,
3046                                             fcport->d_id.b.domain,
3047                                             fcport->d_id.b.area,
3048                                             fcport->d_id.b.al_pa);
3049                                         fcport->loop_id = FC_NO_LOOP_ID;
3050                                 }
3051                         }
3052                 }
3053
3054                 /* Starting free loop ID. */
3055                 next_loopid = ha->min_external_loopid;
3056
3057                 /*
3058                  * Scan through our port list and login entries that need to be
3059                  * logged in.
3060                  */
3061                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3062                         if (atomic_read(&vha->loop_down_timer) ||
3063                             test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
3064                                 break;
3065
3066                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
3067                             (fcport->flags & FCF_LOGIN_NEEDED) == 0)
3068                                 continue;
3069
3070                         if (fcport->loop_id == FC_NO_LOOP_ID) {
3071                                 fcport->loop_id = next_loopid;
3072                                 rval = qla2x00_find_new_loop_id(
3073                                     base_vha, fcport);
3074                                 if (rval != QLA_SUCCESS) {
3075                                         /* Ran out of IDs to use */
3076                                         break;
3077                                 }
3078                         }
3079                         /* Login and update database */
3080                         qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
3081                 }
3082
3083                 /* Exit if out of loop IDs. */
3084                 if (rval != QLA_SUCCESS) {
3085                         break;
3086                 }
3087
3088                 /*
3089                  * Login and add the new devices to our port list.
3090                  */
3091                 list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
3092                         if (atomic_read(&vha->loop_down_timer) ||
3093                             test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
3094                                 break;
3095
3096                         /* Find a new loop ID to use. */
3097                         fcport->loop_id = next_loopid;
3098                         rval = qla2x00_find_new_loop_id(base_vha, fcport);
3099                         if (rval != QLA_SUCCESS) {
3100                                 /* Ran out of IDs to use */
3101                                 break;
3102                         }
3103
3104                         /* Login and update database */
3105                         qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
3106
3107                         if (vha->vp_idx) {
3108                                 fcport->vha = vha;
3109                                 fcport->vp_idx = vha->vp_idx;
3110                         }
3111                         list_move_tail(&fcport->list, &vha->vp_fcports);
3112                 }
3113         } while (0);
3114
3115         /* Free all new device structures not processed. */
3116         list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
3117                 list_del(&fcport->list);
3118                 kfree(fcport);
3119         }
3120
3121         if (rval) {
3122                 DEBUG2(printk("scsi(%ld): Configure fabric error exit: "
3123                     "rval=%d\n", vha->host_no, rval));
3124         }
3125
3126         return (rval);
3127 }
3128
3129 /*
3130  * qla2x00_find_all_fabric_devs
3131  *
3132  * Input:
3133  *      ha = adapter block pointer.
3134  *      dev = database device entry pointer.
3135  *
3136  * Returns:
3137  *      0 = success.
3138  *
3139  * Context:
3140  *      Kernel context.
3141  */
3142 static int
3143 qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
3144         struct list_head *new_fcports)
3145 {
3146         int             rval;
3147         uint16_t        loop_id;
3148         fc_port_t       *fcport, *new_fcport, *fcptemp;
3149         int             found;
3150
3151         sw_info_t       *swl;
3152         int             swl_idx;
3153         int             first_dev, last_dev;
3154         port_id_t       wrap = {}, nxt_d_id;
3155         struct qla_hw_data *ha = vha->hw;
3156         struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
3157         struct scsi_qla_host *tvp;
3158
3159         rval = QLA_SUCCESS;
3160
3161         /* Try GID_PT to get device list, else GAN. */
3162         swl = kcalloc(MAX_FIBRE_DEVICES, sizeof(sw_info_t), GFP_KERNEL);
3163         if (!swl) {
3164                 /*EMPTY*/
3165                 DEBUG2(printk("scsi(%ld): GID_PT allocations failed, fallback "
3166                     "on GA_NXT\n", vha->host_no));
3167         } else {
3168                 if (qla2x00_gid_pt(vha, swl) != QLA_SUCCESS) {
3169                         kfree(swl);
3170                         swl = NULL;
3171                 } else if (qla2x00_gpn_id(vha, swl) != QLA_SUCCESS) {
3172                         kfree(swl);
3173                         swl = NULL;
3174                 } else if (qla2x00_gnn_id(vha, swl) != QLA_SUCCESS) {
3175                         kfree(swl);
3176                         swl = NULL;
3177                 } else if (ql2xiidmaenable &&
3178                     qla2x00_gfpn_id(vha, swl) == QLA_SUCCESS) {
3179                         qla2x00_gpsc(vha, swl);
3180                 }
3181
3182                 /* If other queries succeeded probe for FC-4 type */
3183                 if (swl)
3184                         qla2x00_gff_id(vha, swl);
3185         }
3186         swl_idx = 0;
3187
3188         /* Allocate temporary fcport for any new fcports discovered. */
3189         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
3190         if (new_fcport == NULL) {
3191                 kfree(swl);
3192                 return (QLA_MEMORY_ALLOC_FAILED);
3193         }
3194         new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
3195         /* Set start port ID scan at adapter ID. */
3196         first_dev = 1;
3197         last_dev = 0;
3198
3199         /* Starting free loop ID. */
3200         loop_id = ha->min_external_loopid;
3201         for (; loop_id <= ha->max_loop_id; loop_id++) {
3202                 if (qla2x00_is_reserved_id(vha, loop_id))
3203                         continue;
3204
3205                 if (ha->current_topology == ISP_CFG_FL &&
3206                     (atomic_read(&vha->loop_down_timer) ||
3207                      LOOP_TRANSITION(vha))) {
3208                         atomic_set(&vha->loop_down_timer, 0);
3209                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3210                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3211                         break;
3212                 }
3213
3214                 if (swl != NULL) {
3215                         if (last_dev) {
3216                                 wrap.b24 = new_fcport->d_id.b24;
3217                         } else {
3218                                 new_fcport->d_id.b24 = swl[swl_idx].d_id.b24;
3219                                 memcpy(new_fcport->node_name,
3220                                     swl[swl_idx].node_name, WWN_SIZE);
3221                                 memcpy(new_fcport->port_name,
3222                                     swl[swl_idx].port_name, WWN_SIZE);
3223                                 memcpy(new_fcport->fabric_port_name,
3224                                     swl[swl_idx].fabric_port_name, WWN_SIZE);
3225                                 new_fcport->fp_speed = swl[swl_idx].fp_speed;
3226                                 new_fcport->fc4_type = swl[swl_idx].fc4_type;
3227
3228                                 if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
3229                                         last_dev = 1;
3230                                 }
3231                                 swl_idx++;
3232                         }
3233                 } else {
3234                         /* Send GA_NXT to the switch */
3235                         rval = qla2x00_ga_nxt(vha, new_fcport);
3236                         if (rval != QLA_SUCCESS) {
3237                                 qla_printk(KERN_WARNING, ha,
3238                                     "SNS scan failed -- assuming zero-entry "
3239                                     "result...\n");
3240                                 list_for_each_entry_safe(fcport, fcptemp,
3241                                     new_fcports, list) {
3242                                         list_del(&fcport->list);
3243                                         kfree(fcport);
3244                                 }
3245                                 rval = QLA_SUCCESS;
3246                                 break;
3247                         }
3248                 }
3249
3250                 /* If wrap on switch device list, exit. */
3251                 if (first_dev) {
3252                         wrap.b24 = new_fcport->d_id.b24;
3253                         first_dev = 0;
3254                 } else if (new_fcport->d_id.b24 == wrap.b24) {
3255                         DEBUG2(printk("scsi(%ld): device wrap (%02x%02x%02x)\n",
3256                             vha->host_no, new_fcport->d_id.b.domain,
3257                             new_fcport->d_id.b.area, new_fcport->d_id.b.al_pa));
3258                         break;
3259                 }
3260
3261                 /* Bypass if same physical adapter. */
3262                 if (new_fcport->d_id.b24 == base_vha->d_id.b24)
3263                         continue;
3264
3265                 /* Bypass virtual ports of the same host. */
3266                 found = 0;
3267                 if (ha->num_vhosts) {
3268                         unsigned long flags;
3269
3270                         spin_lock_irqsave(&ha->vport_slock, flags);
3271                         list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3272                                 if (new_fcport->d_id.b24 == vp->d_id.b24) {
3273                                         found = 1;
3274                                         break;
3275                                 }
3276                         }
3277                         spin_unlock_irqrestore(&ha->vport_slock, flags);
3278
3279                         if (found)
3280                                 continue;
3281                 }
3282
3283                 /* Bypass if same domain and area of adapter. */
3284                 if (((new_fcport->d_id.b24 & 0xffff00) ==
3285                     (vha->d_id.b24 & 0xffff00)) && ha->current_topology ==
3286                         ISP_CFG_FL)
3287                             continue;
3288
3289                 /* Bypass reserved domain fields. */
3290                 if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
3291                         continue;
3292
3293                 /* Bypass ports whose FCP-4 type is not FCP_SCSI */
3294                 if (ql2xgffidenable &&
3295                     (new_fcport->fc4_type != FC4_TYPE_FCP_SCSI &&
3296                     new_fcport->fc4_type != FC4_TYPE_UNKNOWN))
3297                         continue;
3298
3299                 /* Locate matching device in database. */
3300                 found = 0;
3301                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3302                         if (memcmp(new_fcport->port_name, fcport->port_name,
3303                             WWN_SIZE))
3304                                 continue;
3305
3306                         found++;
3307
3308                         /* Update port state. */
3309                         memcpy(fcport->fabric_port_name,
3310                             new_fcport->fabric_port_name, WWN_SIZE);
3311                         fcport->fp_speed = new_fcport->fp_speed;
3312
3313                         /*
3314                          * If address the same and state FCS_ONLINE, nothing
3315                          * changed.
3316                          */
3317                         if (fcport->d_id.b24 == new_fcport->d_id.b24 &&
3318                             atomic_read(&fcport->state) == FCS_ONLINE) {
3319                                 break;
3320                         }
3321
3322                         /*
3323                          * If device was not a fabric device before.
3324                          */
3325                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3326                                 fcport->d_id.b24 = new_fcport->d_id.b24;
3327                                 fcport->loop_id = FC_NO_LOOP_ID;
3328                                 fcport->flags |= (FCF_FABRIC_DEVICE |
3329                                     FCF_LOGIN_NEEDED);
3330                                 break;
3331                         }
3332
3333                         /*
3334                          * Port ID changed or device was marked to be updated;
3335                          * Log it out if still logged in and mark it for
3336                          * relogin later.
3337                          */
3338                         fcport->d_id.b24 = new_fcport->d_id.b24;
3339                         fcport->flags |= FCF_LOGIN_NEEDED;
3340                         if (fcport->loop_id != FC_NO_LOOP_ID &&
3341                             (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
3342                             fcport->port_type != FCT_INITIATOR &&
3343                             fcport->port_type != FCT_BROADCAST) {
3344                                 ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3345                                     fcport->d_id.b.domain, fcport->d_id.b.area,
3346                                     fcport->d_id.b.al_pa);
3347                                 fcport->loop_id = FC_NO_LOOP_ID;
3348                         }
3349
3350                         break;
3351                 }
3352
3353                 if (found)
3354                         continue;
3355                 /* If device was not in our fcports list, then add it. */
3356                 list_add_tail(&new_fcport->list, new_fcports);
3357
3358                 /* Allocate a new replacement fcport. */
3359                 nxt_d_id.b24 = new_fcport->d_id.b24;
3360                 new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
3361                 if (new_fcport == NULL) {
3362                         kfree(swl);
3363                         return (QLA_MEMORY_ALLOC_FAILED);
3364                 }
3365                 new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
3366                 new_fcport->d_id.b24 = nxt_d_id.b24;
3367         }
3368
3369         kfree(swl);
3370         kfree(new_fcport);
3371
3372         return (rval);
3373 }
3374
3375 /*
3376  * qla2x00_find_new_loop_id
3377  *      Scan through our port list and find a new usable loop ID.
3378  *
3379  * Input:
3380  *      ha:     adapter state pointer.
3381  *      dev:    port structure pointer.
3382  *
3383  * Returns:
3384  *      qla2x00 local function return status code.
3385  *
3386  * Context:
3387  *      Kernel context.
3388  */
3389 static int
3390 qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
3391 {
3392         int     rval;
3393         int     found;
3394         fc_port_t *fcport;
3395         uint16_t first_loop_id;
3396         struct qla_hw_data *ha = vha->hw;
3397         struct scsi_qla_host *vp;
3398         struct scsi_qla_host *tvp;
3399         unsigned long flags = 0;
3400
3401         rval = QLA_SUCCESS;
3402
3403         /* Save starting loop ID. */
3404         first_loop_id = dev->loop_id;
3405
3406         for (;;) {
3407                 /* Skip loop ID if already used by adapter. */
3408                 if (dev->loop_id == vha->loop_id)
3409                         dev->loop_id++;
3410
3411                 /* Skip reserved loop IDs. */
3412                 while (qla2x00_is_reserved_id(vha, dev->loop_id))
3413                         dev->loop_id++;
3414
3415                 /* Reset loop ID if passed the end. */
3416                 if (dev->loop_id > ha->max_loop_id) {
3417                         /* first loop ID. */
3418                         dev->loop_id = ha->min_external_loopid;
3419                 }
3420
3421                 /* Check for loop ID being already in use. */
3422                 found = 0;
3423                 fcport = NULL;
3424
3425                 spin_lock_irqsave(&ha->vport_slock, flags);
3426                 list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3427                         list_for_each_entry(fcport, &vp->vp_fcports, list) {
3428                                 if (fcport->loop_id == dev->loop_id &&
3429                                                                 fcport != dev) {
3430                                         /* ID possibly in use */
3431                                         found++;
3432                                         break;
3433                                 }
3434                         }
3435                         if (found)
3436                                 break;
3437                 }
3438                 spin_unlock_irqrestore(&ha->vport_slock, flags);
3439
3440                 /* If not in use then it is free to use. */
3441                 if (!found) {
3442                         break;
3443                 }
3444
3445                 /* ID in use. Try next value. */
3446                 dev->loop_id++;
3447
3448                 /* If wrap around. No free ID to use. */
3449                 if (dev->loop_id == first_loop_id) {
3450                         dev->loop_id = FC_NO_LOOP_ID;
3451                         rval = QLA_FUNCTION_FAILED;
3452                         break;
3453                 }
3454         }
3455
3456         return (rval);
3457 }
3458
3459 /*
3460  * qla2x00_device_resync
3461  *      Marks devices in the database that needs resynchronization.</