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
  73         del_timer_sync(&iocb->timer);
  74         kfree(iocb);
  75         kfree(ctx);
  76         mempool_free(sp, sp->fcport->vha->hw->srb_mempool);
  77 }
  78
  79 inline srb_t *
  80 qla2x00_get_ctx_sp(scsi_qla_host_t *vha, fc_port_t *fcport, size_t size,
  81     unsigned long tmo)
  82 {
  83         srb_t *sp;
  84         struct qla_hw_data *ha = vha->hw;
  85         struct srb_ctx *ctx;
  86         struct srb_iocb *iocb;
  87
  88         sp = mempool_alloc(ha->srb_mempool, GFP_KERNEL);
  89         if (!sp)
  90                 goto done;
  91         ctx = kzalloc(size, GFP_KERNEL);
  92         if (!ctx) {
  93                 mempool_free(sp, ha->srb_mempool);
  94                 sp = NULL;
  95                 goto done;
  96         }
  97         iocb = kzalloc(sizeof(struct srb_iocb), GFP_KERNEL);
  98         if (!iocb) {
  99                 mempool_free(sp, ha->srb_mempool);
 100                 sp = NULL;
 101                 kfree(ctx);
 102                 goto done;
 103         }
 104
 105         memset(sp, 0, sizeof(*sp));
 106         sp->fcport = fcport;
 107         sp->ctx = ctx;
 108         ctx->u.iocb_cmd = iocb;
 109         iocb->free = qla2x00_ctx_sp_free;
 110
 111         init_timer(&iocb->timer);
 112         if (!tmo)
 113                 goto done;
 114         iocb->timer.expires = jiffies + tmo * HZ;
 115         iocb->timer.data = (unsigned long)sp;
 116         iocb->timer.function = qla2x00_ctx_sp_timeout;
 117         add_timer(&iocb->timer);
 118 done:
 119         return sp;
 120 }
 121
 122 /* Asynchronous Login/Logout Routines -------------------------------------- */
 123
 124 static inline unsigned long
 125 qla2x00_get_async_timeout(struct scsi_qla_host *vha)
 126 {
 127         unsigned long tmo;
 128         struct qla_hw_data *ha = vha->hw;
 129
 130         /* Firmware should use switch negotiated r_a_tov for timeout. */
 131         tmo = ha->r_a_tov / 10 * 2;
 132         if (!IS_FWI2_CAPABLE(ha)) {
 133                 /*
 134                  * Except for earlier ISPs where the timeout is seeded from the
 135                  * initialization control block.
 136                  */
 137                 tmo = ha->login_timeout;
 138         }
 139         return tmo;
 140 }
 141
 142 static void
 143 qla2x00_async_iocb_timeout(srb_t *sp)
 144 {
 145         fc_port_t *fcport = sp->fcport;
 146         struct srb_ctx *ctx = sp->ctx;
 147
 148         DEBUG2(printk(KERN_WARNING
 149                 "scsi(%ld:%x): Async-%s timeout - portid=%02x%02x%02x.\n",
 150                 fcport->vha->host_no, sp->handle,
 151                 ctx->name, fcport->d_id.b.domain,
 152                 fcport->d_id.b.area, fcport->d_id.b.al_pa));
 153
 154         fcport->flags &= ~FCF_ASYNC_SENT;
 155         if (ctx->type == SRB_LOGIN_CMD) {
 156                 struct srb_iocb *lio = ctx->u.iocb_cmd;
 157                 qla2x00_post_async_logout_work(fcport->vha, fcport, NULL);
 158                 /* Retry as needed. */
 159                 lio->u.logio.data[0] = MBS_COMMAND_ERROR;
 160                 lio->u.logio.data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
 161                         QLA_LOGIO_LOGIN_RETRIED : 0;
 162                 qla2x00_post_async_login_done_work(fcport->vha, fcport,
 163                         lio->u.logio.data);
 164         }
 165 }
 166
 167 static void
 168 qla2x00_async_login_ctx_done(srb_t *sp)
 169 {
 170         struct srb_ctx *ctx = sp->ctx;
 171         struct srb_iocb *lio = ctx->u.iocb_cmd;
 172
 173         qla2x00_post_async_login_done_work(sp->fcport->vha, sp->fcport,
 174                 lio->u.logio.data);
 175         lio->free(sp);
 176 }
 177
 178 int
 179 qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
 180     uint16_t *data)
 181 {
 182         srb_t *sp;
 183         struct srb_ctx *ctx;
 184         struct srb_iocb *lio;
 185         int rval;
 186
 187         rval = QLA_FUNCTION_FAILED;
 188         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
 189             qla2x00_get_async_timeout(vha) + 2);
 190         if (!sp)
 191                 goto done;
 192
 193         ctx = sp->ctx;
 194         ctx->type = SRB_LOGIN_CMD;
 195         ctx->name = "login";
 196         lio = ctx->u.iocb_cmd;
 197         lio->timeout = qla2x00_async_iocb_timeout;
 198         lio->done = qla2x00_async_login_ctx_done;
 199         lio->u.logio.flags |= SRB_LOGIN_COND_PLOGI;
 200         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
 201                 lio->u.logio.flags |= SRB_LOGIN_RETRIED;
 202         rval = qla2x00_start_sp(sp);
 203         if (rval != QLA_SUCCESS)
 204                 goto done_free_sp;
 205
 206         DEBUG2(printk(KERN_DEBUG
 207             "scsi(%ld:%x): Async-login - loop-id=%x portid=%02x%02x%02x "
 208             "retries=%d.\n", fcport->vha->host_no, sp->handle, fcport->loop_id,
 209             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
 210             fcport->login_retry));
 211         return rval;
 212
 213 done_free_sp:
 214         lio->free(sp);
 215 done:
 216         return rval;
 217 }
 218
 219 static void
 220 qla2x00_async_logout_ctx_done(srb_t *sp)
 221 {
 222         struct srb_ctx *ctx = sp->ctx;
 223         struct srb_iocb *lio = ctx->u.iocb_cmd;
 224
 225         qla2x00_post_async_logout_done_work(sp->fcport->vha, sp->fcport,
 226             lio->u.logio.data);
 227         lio->free(sp);
 228 }
 229
 230 int
 231 qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
 232 {
 233         srb_t *sp;
 234         struct srb_ctx *ctx;
 235         struct srb_iocb *lio;
 236         int rval;
 237
 238         rval = QLA_FUNCTION_FAILED;
 239         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
 240             qla2x00_get_async_timeout(vha) + 2);
 241         if (!sp)
 242                 goto done;
 243
 244         ctx = sp->ctx;
 245         ctx->type = SRB_LOGOUT_CMD;
 246         ctx->name = "logout";
 247         lio = ctx->u.iocb_cmd;
 248         lio->timeout = qla2x00_async_iocb_timeout;
 249         lio->done = qla2x00_async_logout_ctx_done;
 250         rval = qla2x00_start_sp(sp);
 251         if (rval != QLA_SUCCESS)
 252                 goto done_free_sp;
 253
 254         DEBUG2(printk(KERN_DEBUG
 255             "scsi(%ld:%x): Async-logout - loop-id=%x portid=%02x%02x%02x.\n",
 256             fcport->vha->host_no, sp->handle, fcport->loop_id,
 257             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
 258         return rval;
 259
 260 done_free_sp:
 261         lio->free(sp);
 262 done:
 263         return rval;
 264 }
 265
 266 static void
 267 qla2x00_async_adisc_ctx_done(srb_t *sp)
 268 {
 269         struct srb_ctx *ctx = sp->ctx;
 270         struct srb_iocb *lio = ctx->u.iocb_cmd;
 271
 272         qla2x00_post_async_adisc_done_work(sp->fcport->vha, sp->fcport,
 273             lio->u.logio.data);
 274         lio->free(sp);
 275 }
 276
 277 int
 278 qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
 279     uint16_t *data)
 280 {
 281         srb_t *sp;
 282         struct srb_ctx *ctx;
 283         struct srb_iocb *lio;
 284         int rval;
 285
 286         rval = QLA_FUNCTION_FAILED;
 287         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
 288             qla2x00_get_async_timeout(vha) + 2);
 289         if (!sp)
 290                 goto done;
 291
 292         ctx = sp->ctx;
 293         ctx->type = SRB_ADISC_CMD;
 294         ctx->name = "adisc";
 295         lio = ctx->u.iocb_cmd;
 296         lio->timeout = qla2x00_async_iocb_timeout;
 297         lio->done = qla2x00_async_adisc_ctx_done;
 298         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
 299                 lio->u.logio.flags |= SRB_LOGIN_RETRIED;
 300         rval = qla2x00_start_sp(sp);
 301         if (rval != QLA_SUCCESS)
 302                 goto done_free_sp;
 303
 304         DEBUG2(printk(KERN_DEBUG
 305             "scsi(%ld:%x): Async-adisc - loop-id=%x portid=%02x%02x%02x.\n",
 306             fcport->vha->host_no, sp->handle, fcport->loop_id,
 307             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
 308
 309         return rval;
 310
 311 done_free_sp:
 312         lio->free(sp);
 313 done:
 314         return rval;
 315 }
 316
 317 static void
 318 qla2x00_async_tm_cmd_ctx_done(srb_t *sp)
 319 {
 320         struct srb_ctx *ctx = sp->ctx;
 321         struct srb_iocb *iocb = (struct srb_iocb *)ctx->u.iocb_cmd;
 322
 323         qla2x00_async_tm_cmd_done(sp->fcport->vha, sp->fcport, iocb);
 324         iocb->free(sp);
 325 }
 326
 327 int
 328 qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
 329         uint32_t tag)
 330 {
 331         struct scsi_qla_host *vha = fcport->vha;
 332         srb_t *sp;
 333         struct srb_ctx *ctx;
 334         struct srb_iocb *tcf;
 335         int rval;
 336
 337         rval = QLA_FUNCTION_FAILED;
 338         sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
 339             qla2x00_get_async_timeout(vha) + 2);
 340         if (!sp)
 341                 goto done;
 342
 343         ctx = sp->ctx;
 344         ctx->type = SRB_TM_CMD;
 345         ctx->name = "tmf";
 346         tcf = ctx->u.iocb_cmd;
 347         tcf->u.tmf.flags = flags;
 348         tcf->u.tmf.lun = lun;
 349         tcf->u.tmf.data = tag;
 350         tcf->timeout = qla2x00_async_iocb_timeout;
 351         tcf->done = qla2x00_async_tm_cmd_ctx_done;
 352
 353         rval = qla2x00_start_sp(sp);
 354         if (rval != QLA_SUCCESS)
 355                 goto done_free_sp;
 356
 357         DEBUG2(printk(KERN_DEBUG
 358             "scsi(%ld:%x): Async-tmf - loop-id=%x portid=%02x%02x%02x.\n",
 359             fcport->vha->host_no, sp->handle, fcport->loop_id,
 360             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
 361
 362         return rval;
 363
 364 done_free_sp:
 365         tcf->free(sp);
 366 done:
 367         return rval;
 368 }
 369
 370 void
 371 qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 372     uint16_t *data)
 373 {
 374         int rval;
 375
 376         switch (data[0]) {
 377         case MBS_COMMAND_COMPLETE:
 378                 if (fcport->flags & FCF_FCP2_DEVICE) {
 379                         fcport->flags |= FCF_ASYNC_SENT;
 380                         qla2x00_post_async_adisc_work(vha, fcport, data);
 381                         break;
 382                 }
 383                 qla2x00_update_fcport(vha, fcport);
 384                 break;
 385         case MBS_COMMAND_ERROR:
 386                 fcport->flags &= ~FCF_ASYNC_SENT;
 387                 if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
 388                         set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 389                 else
 390                         qla2x00_mark_device_lost(vha, fcport, 1, 1);
 391                 break;
 392         case MBS_PORT_ID_USED:
 393                 fcport->loop_id = data[1];
 394                 qla2x00_post_async_logout_work(vha, fcport, NULL);
 395                 qla2x00_post_async_login_work(vha, fcport, NULL);
 396                 break;
 397         case MBS_LOOP_ID_USED:
 398                 fcport->loop_id++;
 399                 rval = qla2x00_find_new_loop_id(vha, fcport);
 400                 if (rval != QLA_SUCCESS) {
 401                         fcport->flags &= ~FCF_ASYNC_SENT;
 402                         qla2x00_mark_device_lost(vha, fcport, 1, 1);
 403                         break;
 404                 }
 405                 qla2x00_post_async_login_work(vha, fcport, NULL);
 406                 break;
 407         }
 408         return;
 409 }
 410
 411 void
 412 qla2x00_async_logout_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 413     uint16_t *data)
 414 {
 415         qla2x00_mark_device_lost(vha, fcport, 1, 0);
 416         return;
 417 }
 418
 419 void
 420 qla2x00_async_adisc_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 421     uint16_t *data)
 422 {
 423         if (data[0] == MBS_COMMAND_COMPLETE) {
 424                 qla2x00_update_fcport(vha, fcport);
 425
 426                 return;
 427         }
 428
 429         /* Retry login. */
 430         fcport->flags &= ~FCF_ASYNC_SENT;
 431         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
 432                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 433         else
 434                 qla2x00_mark_device_lost(vha, fcport, 1, 1);
 435
 436         return;
 437 }
 438
 439 void
 440 qla2x00_async_tm_cmd_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 441     struct srb_iocb *iocb)
 442 {
 443         int rval;
 444         uint32_t flags;
 445         uint16_t lun;
 446
 447         flags = iocb->u.tmf.flags;
 448         lun = (uint16_t)iocb->u.tmf.lun;
 449
 450         /* Issue Marker IOCB */
 451         rval = qla2x00_marker(vha, vha->hw->req_q_map[0],
 452                 vha->hw->rsp_q_map[0], fcport->loop_id, lun,
 453                 flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
 454
 455         if ((rval != QLA_SUCCESS) || iocb->u.tmf.data) {
 456                 DEBUG2_3_11(printk(KERN_WARNING
 457                         "%s(%ld): TM IOCB failed (%x).\n",
 458                         __func__, vha->host_no, rval));
 459         }
 460
 461         return;
 462 }
 463
 464 /****************************************************************************/
 465 /*                QLogic ISP2x00 Hardware Support Functions.                */
 466 /****************************************************************************/
 467
 468 /*
 469 * qla2x00_initialize_adapter
 470 *      Initialize board.
 471 *
 472 * Input:
 473 *      ha = adapter block pointer.
 474 *
 475 * Returns:
 476 *      0 = success
 477 */
 478 int
 479 qla2x00_initialize_adapter(scsi_qla_host_t *vha)
 480 {
 481         int     rval;
 482         struct qla_hw_data *ha = vha->hw;
 483         struct req_que *req = ha->req_q_map[0];
 484
 485         /* Clear adapter flags. */
 486         vha->flags.online = 0;
 487         ha->flags.chip_reset_done = 0;
 488         vha->flags.reset_active = 0;
 489         ha->flags.pci_channel_io_perm_failure = 0;
 490         ha->flags.eeh_busy = 0;
 491         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 492         atomic_set(&vha->loop_state, LOOP_DOWN);
 493         vha->device_flags = DFLG_NO_CABLE;
 494         vha->dpc_flags = 0;
 495         vha->flags.management_server_logged_in = 0;
 496         vha->marker_needed = 0;
 497         ha->isp_abort_cnt = 0;
 498         ha->beacon_blink_led = 0;
 499
 500         set_bit(0, ha->req_qid_map);
 501         set_bit(0, ha->rsp_qid_map);
 502
 503         qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
 504         rval = ha->isp_ops->pci_config(vha);
 505         if (rval) {
 506                 DEBUG2(printk("scsi(%ld): Unable to configure PCI space.\n",
 507                     vha->host_no));
 508                 return (rval);
 509         }
 510
 511         ha->isp_ops->reset_chip(vha);
 512
 513         rval = qla2xxx_get_flash_info(vha);
 514         if (rval) {
 515                 DEBUG2(printk("scsi(%ld): Unable to validate FLASH data.\n",
 516                     vha->host_no));
 517                 return (rval);
 518         }
 519
 520         ha->isp_ops->get_flash_version(vha, req->ring);
 521
 522         qla_printk(KERN_INFO, ha, "Configure NVRAM parameters...\n");
 523
 524         ha->isp_ops->nvram_config(vha);
 525
 526         if (ha->flags.disable_serdes) {
 527                 /* Mask HBA via NVRAM settings? */
 528                 qla_printk(KERN_INFO, ha, "Masking HBA WWPN "
 529                     "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
 530                     vha->port_name[0], vha->port_name[1],
 531                     vha->port_name[2], vha->port_name[3],
 532                     vha->port_name[4], vha->port_name[5],
 533                     vha->port_name[6], vha->port_name[7]);
 534                 return QLA_FUNCTION_FAILED;
 535         }
 536
 537         qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
 538
 539         if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
 540                 rval = ha->isp_ops->chip_diag(vha);
 541                 if (rval)
 542                         return (rval);
 543                 rval = qla2x00_setup_chip(vha);
 544                 if (rval)
 545                         return (rval);
 546         }
 547
 548         if (IS_QLA84XX(ha)) {
 549                 ha->cs84xx = qla84xx_get_chip(vha);
 550                 if (!ha->cs84xx) {
 551                         qla_printk(KERN_ERR, ha,
 552                             "Unable to configure ISP84XX.\n");
 553                         return QLA_FUNCTION_FAILED;
 554                 }
 555         }
 556         rval = qla2x00_init_rings(vha);
 557         ha->flags.chip_reset_done = 1;
 558
 559         if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
 560                 /* Issue verify 84xx FW IOCB to complete 84xx initialization */
 561                 rval = qla84xx_init_chip(vha);
 562                 if (rval != QLA_SUCCESS) {
 563                         qla_printk(KERN_ERR, ha,
 564                                 "Unable to initialize ISP84XX.\n");
 565                 qla84xx_put_chip(vha);
 566                 }
 567         }
 568
 569         if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
 570                 qla24xx_read_fcp_prio_cfg(vha);
 571
 572         return (rval);
 573 }
 574
 575 /**
 576  * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
 577  * @ha: HA context
 578  *
 579  * Returns 0 on success.
 580  */
 581 int
 582 qla2100_pci_config(scsi_qla_host_t *vha)
 583 {
 584         uint16_t w;
 585         unsigned long flags;
 586         struct qla_hw_data *ha = vha->hw;
 587         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 588
 589         pci_set_master(ha->pdev);
 590         pci_try_set_mwi(ha->pdev);
 591
 592         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
 593         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
 594         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 595
 596         pci_disable_rom(ha->pdev);
 597
 598         /* Get PCI bus information. */
 599         spin_lock_irqsave(&ha->hardware_lock, flags);
 600         ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
 601         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 602
 603         return QLA_SUCCESS;
 604 }
 605
 606 /**
 607  * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
 608  * @ha: HA context
 609  *
 610  * Returns 0 on success.
 611  */
 612 int
 613 qla2300_pci_config(scsi_qla_host_t *vha)
 614 {
 615         uint16_t        w;
 616         unsigned long   flags = 0;
 617         uint32_t        cnt;
 618         struct qla_hw_data *ha = vha->hw;
 619         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 620
 621         pci_set_master(ha->pdev);
 622         pci_try_set_mwi(ha->pdev);
 623
 624         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
 625         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
 626
 627         if (IS_QLA2322(ha) || IS_QLA6322(ha))
 628                 w &= ~PCI_COMMAND_INTX_DISABLE;
 629         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 630
 631         /*
 632          * If this is a 2300 card and not 2312, reset the
 633          * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
 634          * the 2310 also reports itself as a 2300 so we need to get the
 635          * fb revision level -- a 6 indicates it really is a 2300 and
 636          * not a 2310.
 637          */
 638         if (IS_QLA2300(ha)) {
 639                 spin_lock_irqsave(&ha->hardware_lock, flags);
 640
 641                 /* Pause RISC. */
 642                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
 643                 for (cnt = 0; cnt < 30000; cnt++) {
 644                         if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
 645                                 break;
 646
 647                         udelay(10);
 648                 }
 649
 650                 /* Select FPM registers. */
 651                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
 652                 RD_REG_WORD(&reg->ctrl_status);
 653
 654                 /* Get the fb rev level */
 655                 ha->fb_rev = RD_FB_CMD_REG(ha, reg);
 656
 657                 if (ha->fb_rev == FPM_2300)
 658                         pci_clear_mwi(ha->pdev);
 659
 660                 /* Deselect FPM registers. */
 661                 WRT_REG_WORD(&reg->ctrl_status, 0x0);
 662                 RD_REG_WORD(&reg->ctrl_status);
 663
 664                 /* Release RISC module. */
 665                 WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
 666                 for (cnt = 0; cnt < 30000; cnt++) {
 667                         if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
 668                                 break;
 669
 670                         udelay(10);
 671                 }
 672
 673                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 674         }
 675
 676         pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
 677
 678         pci_disable_rom(ha->pdev);
 679
 680         /* Get PCI bus information. */
 681         spin_lock_irqsave(&ha->hardware_lock, flags);
 682         ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
 683         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 684
 685         return QLA_SUCCESS;
 686 }
 687
 688 /**
 689  * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
 690  * @ha: HA context
 691  *
 692  * Returns 0 on success.
 693  */
 694 int
 695 qla24xx_pci_config(scsi_qla_host_t *vha)
 696 {
 697         uint16_t w;
 698         unsigned long flags = 0;
 699         struct qla_hw_data *ha = vha->hw;
 700         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
 701
 702         pci_set_master(ha->pdev);
 703         pci_try_set_mwi(ha->pdev);
 704
 705         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
 706         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
 707         w &= ~PCI_COMMAND_INTX_DISABLE;
 708         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 709
 710         pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
 711
 712         /* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
 713         if (pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX))
 714                 pcix_set_mmrbc(ha->pdev, 2048);
 715
 716         /* PCIe -- adjust Maximum Read Request Size (2048). */
 717         if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
 718                 pcie_set_readrq(ha->pdev, 2048);
 719
 720         pci_disable_rom(ha->pdev);
 721
 722         ha->chip_revision = ha->pdev->revision;
 723
 724         /* Get PCI bus information. */
 725         spin_lock_irqsave(&ha->hardware_lock, flags);
 726         ha->pci_attr = RD_REG_DWORD(&reg->ctrl_status);
 727         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 728
 729         return QLA_SUCCESS;
 730 }
 731
 732 /**
 733  * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
 734  * @ha: HA context
 735  *
 736  * Returns 0 on success.
 737  */
 738 int
 739 qla25xx_pci_config(scsi_qla_host_t *vha)
 740 {
 741         uint16_t w;
 742         struct qla_hw_data *ha = vha->hw;
 743
 744         pci_set_master(ha->pdev);
 745         pci_try_set_mwi(ha->pdev);
 746
 747         pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
 748         w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
 749         w &= ~PCI_COMMAND_INTX_DISABLE;
 750         pci_write_config_word(ha->pdev, PCI_COMMAND, w);
 751
 752         /* PCIe -- adjust Maximum Read Request Size (2048). */
 753         if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
 754                 pcie_set_readrq(ha->pdev, 2048);
 755
 756         pci_disable_rom(ha->pdev);
 757
 758         ha->chip_revision = ha->pdev->revision;
 759
 760         return QLA_SUCCESS;
 761 }
 762
 763 /**
 764  * qla2x00_isp_firmware() - Choose firmware image.
 765  * @ha: HA context
 766  *
 767  * Returns 0 on success.
 768  */
 769 static int
 770 qla2x00_isp_firmware(scsi_qla_host_t *vha)
 771 {
 772         int  rval;
 773         uint16_t loop_id, topo, sw_cap;
 774         uint8_t domain, area, al_pa;
 775         struct qla_hw_data *ha = vha->hw;
 776
 777         /* Assume loading risc code */
 778         rval = QLA_FUNCTION_FAILED;
 779
 780         if (ha->flags.disable_risc_code_load) {
 781                 DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
 782                     vha->host_no));
 783                 qla_printk(KERN_INFO, ha, "RISC CODE NOT loaded\n");
 784
 785                 /* Verify checksum of loaded RISC code. */
 786                 rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
 787                 if (rval == QLA_SUCCESS) {
 788                         /* And, verify we are not in ROM code. */
 789                         rval = qla2x00_get_adapter_id(vha, &loop_id, &al_pa,
 790                             &area, &domain, &topo, &sw_cap);
 791                 }
 792         }
 793
 794         if (rval) {
 795                 DEBUG2_3(printk("scsi(%ld): **** Load RISC code ****\n",
 796                     vha->host_no));
 797         }
 798
 799         return (rval);
 800 }
 801
 802 /**
 803  * qla2x00_reset_chip() - Reset ISP chip.
 804  * @ha: HA context
 805  *
 806  * Returns 0 on success.
 807  */
 808 void
 809 qla2x00_reset_chip(scsi_qla_host_t *vha)
 810 {
 811         unsigned long   flags = 0;
 812         struct qla_hw_data *ha = vha->hw;
 813         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 814         uint32_t        cnt;
 815         uint16_t        cmd;
 816
 817         if (unlikely(pci_channel_offline(ha->pdev)))
 818                 return;
 819
 820         ha->isp_ops->disable_intrs(ha);
 821
 822         spin_lock_irqsave(&ha->hardware_lock, flags);
 823
 824         /* Turn off master enable */
 825         cmd = 0;
 826         pci_read_config_word(ha->pdev, PCI_COMMAND, &cmd);
 827         cmd &= ~PCI_COMMAND_MASTER;
 828         pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
 829
 830         if (!IS_QLA2100(ha)) {
 831                 /* Pause RISC. */
 832                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
 833                 if (IS_QLA2200(ha) || IS_QLA2300(ha)) {
 834                         for (cnt = 0; cnt < 30000; cnt++) {
 835                                 if ((RD_REG_WORD(&reg->hccr) &
 836                                     HCCR_RISC_PAUSE) != 0)
 837                                         break;
 838                                 udelay(100);
 839                         }
 840                 } else {
 841                         RD_REG_WORD(&reg->hccr);        /* PCI Posting. */
 842                         udelay(10);
 843                 }
 844
 845                 /* Select FPM registers. */
 846                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
 847                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
 848
 849                 /* FPM Soft Reset. */
 850                 WRT_REG_WORD(&reg->fpm_diag_config, 0x100);
 851                 RD_REG_WORD(&reg->fpm_diag_config);     /* PCI Posting. */
 852
 853                 /* Toggle Fpm Reset. */
 854                 if (!IS_QLA2200(ha)) {
 855                         WRT_REG_WORD(&reg->fpm_diag_config, 0x0);
 856                         RD_REG_WORD(&reg->fpm_diag_config); /* PCI Posting. */
 857                 }
 858
 859                 /* Select frame buffer registers. */
 860                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
 861                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
 862
 863                 /* Reset frame buffer FIFOs. */
 864                 if (IS_QLA2200(ha)) {
 865                         WRT_FB_CMD_REG(ha, reg, 0xa000);
 866                         RD_FB_CMD_REG(ha, reg);         /* PCI Posting. */
 867                 } else {
 868                         WRT_FB_CMD_REG(ha, reg, 0x00fc);
 869
 870                         /* Read back fb_cmd until zero or 3 seconds max */
 871                         for (cnt = 0; cnt < 3000; cnt++) {
 872                                 if ((RD_FB_CMD_REG(ha, reg) & 0xff) == 0)
 873                                         break;
 874                                 udelay(100);
 875                         }
 876                 }
 877
 878                 /* Select RISC module registers. */
 879                 WRT_REG_WORD(&reg->ctrl_status, 0);
 880                 RD_REG_WORD(&reg->ctrl_status);         /* PCI Posting. */
 881
 882                 /* Reset RISC processor. */
 883                 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
 884                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
 885
 886                 /* Release RISC processor. */
 887                 WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
 888                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
 889         }
 890
 891         WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 892         WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);
 893
 894         /* Reset ISP chip. */
 895         WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
 896
 897         /* Wait for RISC to recover from reset. */
 898         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
 899                 /*
 900                  * It is necessary to for a delay here since the card doesn't
 901                  * respond to PCI reads during a reset. On some architectures
 902                  * this will result in an MCA.
 903                  */
 904                 udelay(20);
 905                 for (cnt = 30000; cnt; cnt--) {
 906                         if ((RD_REG_WORD(&reg->ctrl_status) &
 907                             CSR_ISP_SOFT_RESET) == 0)
 908                                 break;
 909                         udelay(100);
 910                 }
 911         } else
 912                 udelay(10);
 913
 914         /* Reset RISC processor. */
 915         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
 916
 917         WRT_REG_WORD(&reg->semaphore, 0);
 918
 919         /* Release RISC processor. */
 920         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
 921         RD_REG_WORD(&reg->hccr);                        /* PCI Posting. */
 922
 923         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
 924                 for (cnt = 0; cnt < 30000; cnt++) {
 925                         if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
 926                                 break;
 927
 928                         udelay(100);
 929                 }
 930         } else
 931                 udelay(100);
 932
 933         /* Turn on master enable */
 934         cmd |= PCI_COMMAND_MASTER;
 935         pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
 936
 937         /* Disable RISC pause on FPM parity error. */
 938         if (!IS_QLA2100(ha)) {
 939                 WRT_REG_WORD(&reg->hccr, HCCR_DISABLE_PARITY_PAUSE);
 940                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
 941         }
 942
 943         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 944 }
 945
 946 /**
 947  * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
 948  * @ha: HA context
 949  *
 950  * Returns 0 on success.
 951  */
 952 static inline void
 953 qla24xx_reset_risc(scsi_qla_host_t *vha)
 954 {
 955         unsigned long flags = 0;
 956         struct qla_hw_data *ha = vha->hw;
 957         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
 958         uint32_t cnt, d2;
 959         uint16_t wd;
 960
 961         spin_lock_irqsave(&ha->hardware_lock, flags);
 962
 963         /* Reset RISC. */
 964         WRT_REG_DWORD(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
 965         for (cnt = 0; cnt < 30000; cnt++) {
 966                 if ((RD_REG_DWORD(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
 967                         break;
 968
 969                 udelay(10);
 970         }
 971
 972         WRT_REG_DWORD(&reg->ctrl_status,
 973             CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
 974         pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
 975
 976         udelay(100);
 977         /* Wait for firmware to complete NVRAM accesses. */
 978         d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
 979         for (cnt = 10000 ; cnt && d2; cnt--) {
 980                 udelay(5);
 981                 d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
 982                 barrier();
 983         }
 984
 985         /* Wait for soft-reset to complete. */
 986         d2 = RD_REG_DWORD(&reg->ctrl_status);
 987         for (cnt = 6000000 ; cnt && (d2 & CSRX_ISP_SOFT_RESET); cnt--) {
 988                 udelay(5);
 989                 d2 = RD_REG_DWORD(&reg->ctrl_status);
 990                 barrier();
 991         }
 992
 993         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
 994         RD_REG_DWORD(&reg->hccr);
 995
 996         WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
 997         RD_REG_DWORD(&reg->hccr);
 998
 999         WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
1000         RD_REG_DWORD(&reg->hccr);
1001
1002         d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1003         for (cnt = 6000000 ; cnt && d2; cnt--) {
1004                 udelay(5);
1005                 d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1006                 barrier();
1007         }
1008
1009         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1010
1011         if (IS_NOPOLLING_TYPE(ha))
1012                 ha->isp_ops->enable_intrs(ha);
1013 }
1014
1015 /**
1016  * qla24xx_reset_chip() - Reset ISP24xx chip.
1017  * @ha: HA context
1018  *
1019  * Returns 0 on success.
1020  */
1021 void
1022 qla24xx_reset_chip(scsi_qla_host_t *vha)
1023 {
1024         struct qla_hw_data *ha = vha->hw;
1025
1026         if (pci_channel_offline(ha->pdev) &&
1027             ha->flags.pci_channel_io_perm_failure) {
1028                 return;
1029         }
1030
1031         ha->isp_ops->disable_intrs(ha);
1032
1033         /* Perform RISC reset. */
1034         qla24xx_reset_risc(vha);
1035 }
1036
1037 /**
1038  * qla2x00_chip_diag() - Test chip for proper operation.
1039  * @ha: HA context
1040  *
1041  * Returns 0 on success.
1042  */
1043 int
1044 qla2x00_chip_diag(scsi_qla_host_t *vha)
1045 {
1046         int             rval;
1047         struct qla_hw_data *ha = vha->hw;
1048         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1049         unsigned long   flags = 0;
1050         uint16_t        data;
1051         uint32_t        cnt;
1052         uint16_t        mb[5];
1053         struct req_que *req = ha->req_q_map[0];
1054
1055         /* Assume a failed state */
1056         rval = QLA_FUNCTION_FAILED;
1057
1058         DEBUG3(printk("scsi(%ld): Testing device at %lx.\n",
1059             vha->host_no, (u_long)&reg->flash_address));
1060
1061         spin_lock_irqsave(&ha->hardware_lock, flags);
1062
1063         /* Reset ISP chip. */
1064         WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
1065
1066         /*
1067          * We need to have a delay here since the card will not respond while
1068          * in reset causing an MCA on some architectures.
1069          */
1070         udelay(20);
1071         data = qla2x00_debounce_register(&reg->ctrl_status);
1072         for (cnt = 6000000 ; cnt && (data & CSR_ISP_SOFT_RESET); cnt--) {
1073                 udelay(5);
1074                 data = RD_REG_WORD(&reg->ctrl_status);
1075                 barrier();
1076         }
1077
1078         if (!cnt)
1079                 goto chip_diag_failed;
1080
1081         DEBUG3(printk("scsi(%ld): Reset register cleared by chip reset\n",
1082             vha->host_no));
1083
1084         /* Reset RISC processor. */
1085         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
1086         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
1087
1088         /* Workaround for QLA2312 PCI parity error */
1089         if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
1090                 data = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 0));
1091                 for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
1092                         udelay(5);
1093                         data = RD_MAILBOX_REG(ha, reg, 0);
1094                         barrier();
1095                 }
1096         } else
1097                 udelay(10);
1098
1099         if (!cnt)
1100                 goto chip_diag_failed;
1101
1102         /* Check product ID of chip */
1103         DEBUG3(printk("scsi(%ld): Checking product ID of chip\n", vha->host_no));
1104
1105         mb[1] = RD_MAILBOX_REG(ha, reg, 1);
1106         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
1107         mb[3] = RD_MAILBOX_REG(ha, reg, 3);
1108         mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
1109         if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
1110             mb[3] != PROD_ID_3) {
1111                 qla_printk(KERN_WARNING, ha,
1112                     "Wrong product ID = 0x%x,0x%x,0x%x\n", mb[1], mb[2], mb[3]);
1113
1114                 goto chip_diag_failed;
1115         }
1116         ha->product_id[0] = mb[1];
1117         ha->product_id[1] = mb[2];
1118         ha->product_id[2] = mb[3];
1119         ha->product_id[3] = mb[4];
1120
1121         /* Adjust fw RISC transfer size */
1122         if (req->length > 1024)
1123                 ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
1124         else
1125                 ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
1126                     req->length;
1127
1128         if (IS_QLA2200(ha) &&
1129             RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
1130                 /* Limit firmware transfer size with a 2200A */
1131                 DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
1132                     vha->host_no));
1133
1134                 ha->device_type |= DT_ISP2200A;
1135                 ha->fw_transfer_size = 128;
1136         }
1137
1138         /* Wrap Incoming Mailboxes Test. */
1139         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1140
1141         DEBUG3(printk("scsi(%ld): Checking mailboxes.\n", vha->host_no));
1142         rval = qla2x00_mbx_reg_test(vha);
1143         if (rval) {
1144                 DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
1145                     vha->host_no));
1146                 qla_printk(KERN_WARNING, ha,
1147                     "Failed mailbox send register test\n");
1148         }
1149         else {
1150                 /* Flag a successful rval */
1151                 rval = QLA_SUCCESS;
1152         }
1153         spin_lock_irqsave(&ha->hardware_lock, flags);
1154
1155 chip_diag_failed:
1156         if (rval)
1157                 DEBUG2_3(printk("scsi(%ld): Chip diagnostics **** FAILED "
1158                     "****\n", vha->host_no));
1159
1160         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1161
1162         return (rval);
1163 }
1164
1165 /**
1166  * qla24xx_chip_diag() - Test ISP24xx for proper operation.
1167  * @ha: HA context
1168  *
1169  * Returns 0 on success.
1170  */
1171 int
1172 qla24xx_chip_diag(scsi_qla_host_t *vha)
1173 {
1174         int rval;
1175         struct qla_hw_data *ha = vha->hw;
1176         struct req_que *req = ha->req_q_map[0];
1177
1178         if (IS_QLA82XX(ha))
1179                 return QLA_SUCCESS;
1180
1181         ha->fw_transfer_size = REQUEST_ENTRY_SIZE * req->length;
1182
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         } else {
1190                 /* Flag a successful rval */
1191                 rval = QLA_SUCCESS;
1192         }
1193
1194         return rval;
1195 }
1196
1197 void
1198 qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
1199 {
1200         int rval;
1201         uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
1202             eft_size, fce_size, mq_size;
1203         dma_addr_t tc_dma;
1204         void *tc;
1205         struct qla_hw_data *ha = vha->hw;
1206         struct req_que *req = ha->req_q_map[0];
1207         struct rsp_que *rsp = ha->rsp_q_map[0];
1208
1209         if (ha->fw_dump) {
1210                 qla_printk(KERN_WARNING, ha,
1211                     "Firmware dump previously allocated.\n");
1212                 return;
1213         }
1214
1215         ha->fw_dumped = 0;
1216         fixed_size = mem_size = eft_size = fce_size = mq_size = 0;
1217         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
1218                 fixed_size = sizeof(struct qla2100_fw_dump);
1219         } else if (IS_QLA23XX(ha)) {
1220                 fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
1221                 mem_size = (ha->fw_memory_size - 0x11000 + 1) *
1222                     sizeof(uint16_t);
1223         } else if (IS_FWI2_CAPABLE(ha)) {
1224                 if (IS_QLA81XX(ha))
1225                         fixed_size = offsetof(struct qla81xx_fw_dump, ext_mem);
1226                 else if (IS_QLA25XX(ha))
1227                         fixed_size = offsetof(struct qla25xx_fw_dump, ext_mem);
1228                 else
1229                         fixed_size = offsetof(struct qla24xx_fw_dump, ext_mem);
1230                 mem_size = (ha->fw_memory_size - 0x100000 + 1) *
1231                     sizeof(uint32_t);
1232                 if (ha->mqenable)
1233                         mq_size = sizeof(struct qla2xxx_mq_chain);
1234                 /* Allocate memory for Fibre Channel Event Buffer. */
1235                 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
1236                         goto try_eft;
1237
1238                 tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
1239                     GFP_KERNEL);
1240                 if (!tc) {
1241                         qla_printk(KERN_WARNING, ha, "Unable to allocate "
1242                             "(%d KB) for FCE.\n", FCE_SIZE / 1024);
1243                         goto try_eft;
1244                 }
1245
1246                 memset(tc, 0, FCE_SIZE);
1247                 rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
1248                     ha->fce_mb, &ha->fce_bufs);
1249                 if (rval) {
1250                         qla_printk(KERN_WARNING, ha, "Unable to initialize "
1251                             "FCE (%d).\n", rval);
1252                         dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc,
1253                             tc_dma);
1254                         ha->flags.fce_enabled = 0;
1255                         goto try_eft;
1256                 }
1257
1258                 qla_printk(KERN_INFO, ha, "Allocated (%d KB) for FCE...\n",
1259                     FCE_SIZE / 1024);
1260
1261                 fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
1262                 ha->flags.fce_enabled = 1;
1263                 ha->fce_dma = tc_dma;
1264                 ha->fce = tc;
1265 try_eft:
1266                 /* Allocate memory for Extended Trace Buffer. */
1267                 tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
1268                     GFP_KERNEL);
1269                 if (!tc) {
1270                         qla_printk(KERN_WARNING, ha, "Unable to allocate "
1271                             "(%d KB) for EFT.\n", EFT_SIZE / 1024);
1272                         goto cont_alloc;
1273                 }
1274
1275                 memset(tc, 0, EFT_SIZE);
1276                 rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
1277                 if (rval) {
1278                         qla_printk(KERN_WARNING, ha, "Unable to initialize "
1279                             "EFT (%d).\n", rval);
1280                         dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc,
1281                             tc_dma);
1282                         goto cont_alloc;
1283                 }
1284
1285                 qla_printk(KERN_INFO, ha, "Allocated (%d KB) for EFT...\n",
1286                     EFT_SIZE / 1024);
1287
1288                 eft_size = EFT_SIZE;
1289                 ha->eft_dma = tc_dma;
1290                 ha->eft = tc;
1291         }
1292 cont_alloc:
1293         req_q_size = req->length * sizeof(request_t);
1294         rsp_q_size = rsp->length * sizeof(response_t);
1295
1296         dump_size = offsetof(struct qla2xxx_fw_dump, isp);
1297         dump_size += fixed_size + mem_size + req_q_size + rsp_q_size + eft_size;
1298         ha->chain_offset = dump_size;
1299         dump_size += mq_size + fce_size;
1300
1301         ha->fw_dump = vmalloc(dump_size);
1302         if (!ha->fw_dump) {
1303                 qla_printk(KERN_WARNING, ha, "Unable to allocate (%d KB) for "
1304                     "firmware dump!!!\n", dump_size / 1024);
1305
1306                 if (ha->eft) {
1307                         dma_free_coherent(&ha->pdev->dev, eft_size, ha->eft,
1308                             ha->eft_dma);
1309                         ha->eft = NULL;
1310                         ha->eft_dma = 0;
1311                 }
1312                 return;
1313         }
1314         qla_printk(KERN_INFO, ha, "Allocated (%d KB) for firmware dump...\n",
1315             dump_size / 1024);
1316
1317         ha->fw_dump_len = dump_size;
1318         ha->fw_dump->signature[0] = 'Q';
1319         ha->fw_dump->signature[1] = 'L';
1320         ha->fw_dump->signature[2] = 'G';
1321         ha->fw_dump->signature[3] = 'C';
1322         ha->fw_dump->version = __constant_htonl(1);
1323
1324         ha->fw_dump->fixed_size = htonl(fixed_size);
1325         ha->fw_dump->mem_size = htonl(mem_size);
1326         ha->fw_dump->req_q_size = htonl(req_q_size);
1327         ha->fw_dump->rsp_q_size = htonl(rsp_q_size);
1328
1329         ha->fw_dump->eft_size = htonl(eft_size);
1330         ha->fw_dump->eft_addr_l = htonl(LSD(ha->eft_dma));
1331         ha->fw_dump->eft_addr_h = htonl(MSD(ha->eft_dma));
1332
1333         ha->fw_dump->header_size =
1334             htonl(offsetof(struct qla2xxx_fw_dump, isp));
1335 }
1336
1337 static int
1338 qla81xx_mpi_sync(scsi_qla_host_t *vha)
1339 {
1340 #define MPS_MASK        0xe0
1341         int rval;
1342         uint16_t dc;
1343         uint32_t dw;
1344         struct qla_hw_data *ha = vha->hw;
1345
1346         if (!IS_QLA81XX(vha->hw))
1347                 return QLA_SUCCESS;
1348
1349         rval = qla2x00_write_ram_word(vha, 0x7c00, 1);
1350         if (rval != QLA_SUCCESS) {
1351                 DEBUG2(qla_printk(KERN_WARNING, ha,
1352                     "Sync-MPI: Unable to acquire semaphore.\n"));
1353                 goto done;
1354         }
1355
1356         pci_read_config_word(vha->hw->pdev, 0x54, &dc);
1357         rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
1358         if (rval != QLA_SUCCESS) {
1359                 DEBUG2(qla_printk(KERN_WARNING, ha,
1360                     "Sync-MPI: Unable to read sync.\n"));
1361                 goto done_release;
1362         }
1363
1364         dc &= MPS_MASK;
1365         if (dc == (dw & MPS_MASK))
1366                 goto done_release;
1367
1368         dw &= ~MPS_MASK;
1369         dw |= dc;
1370         rval = qla2x00_write_ram_word(vha, 0x7a15, dw);
1371         if (rval != QLA_SUCCESS) {
1372                 DEBUG2(qla_printk(KERN_WARNING, ha,
1373                     "Sync-MPI: Unable to gain sync.\n"));
1374         }
1375
1376 done_release:
1377         rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
1378         if (rval != QLA_SUCCESS) {
1379                 DEBUG2(qla_printk(KERN_WARNING, ha,
1380                     "Sync-MPI: Unable to release semaphore.\n"));
1381         }
1382
1383 done:
1384         return rval;
1385 }
1386
1387 /**
1388  * qla2x00_setup_chip() - Load and start RISC firmware.
1389  * @ha: HA context
1390  *
1391  * Returns 0 on success.
1392  */
1393 static int
1394 qla2x00_setup_chip(scsi_qla_host_t *vha)
1395 {
1396         int rval;
1397         uint32_t srisc_address = 0;
1398         struct qla_hw_data *ha = vha->hw;
1399         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1400         unsigned long flags;
1401         uint16_t fw_major_version;
1402
1403         if (IS_QLA82XX(ha)) {
1404                 rval = ha->isp_ops->load_risc(vha, &srisc_address);
1405                 if (rval == QLA_SUCCESS) {
1406                         qla2x00_stop_firmware(vha);
1407                         goto enable_82xx_npiv;
1408                 } else
1409                         goto failed;
1410         }
1411
1412         if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
1413                 /* Disable SRAM, Instruction RAM and GP RAM parity.  */
1414                 spin_lock_irqsave(&ha->hardware_lock, flags);
1415                 WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x0));
1416                 RD_REG_WORD(&reg->hccr);
1417                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1418         }
1419
1420         qla81xx_mpi_sync(vha);
1421
1422         /* Load firmware sequences */
1423         rval = ha->isp_ops->load_risc(vha, &srisc_address);
1424         if (rval == QLA_SUCCESS) {
1425                 DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
1426                     "code.\n", vha->host_no));
1427
1428                 rval = qla2x00_verify_checksum(vha, srisc_address);
1429                 if (rval == QLA_SUCCESS) {
1430                         /* Start firmware execution. */
1431                         DEBUG(printk("scsi(%ld): Checksum OK, start "
1432                             "firmware.\n", vha->host_no));
1433
1434                         rval = qla2x00_execute_fw(vha, srisc_address);
1435                         /* Retrieve firmware information. */
1436                         if (rval == QLA_SUCCESS) {
1437 enable_82xx_npiv:
1438                                 fw_major_version = ha->fw_major_version;
1439                                 rval = qla2x00_get_fw_version(vha,
1440                                     &ha->fw_major_version,
1441                                     &ha->fw_minor_version,
1442                                     &ha->fw_subminor_version,
1443                                     &ha->fw_attributes, &ha->fw_memory_size,
1444                                     ha->mpi_version, &ha->mpi_capabilities,
1445                                     ha->phy_version);
1446                                 if (rval != QLA_SUCCESS)
1447                                         goto failed;
1448                                 ha->flags.npiv_supported = 0;
1449                                 if (IS_QLA2XXX_MIDTYPE(ha) &&
1450                                          (ha->fw_attributes & BIT_2)) {
1451                                         ha->flags.npiv_supported = 1;
1452                                         if ((!ha->max_npiv_vports) ||
1453                                             ((ha->max_npiv_vports + 1) %
1454                                             MIN_MULTI_ID_FABRIC))
1455                                                 ha->max_npiv_vports =
1456                                                     MIN_MULTI_ID_FABRIC - 1;
1457                                 }
1458                                 qla2x00_get_resource_cnts(vha, NULL,
1459                                     &ha->fw_xcb_count, NULL, NULL,
1460                                     &ha->max_npiv_vports, NULL);
1461
1462                                 if (!fw_major_version && ql2xallocfwdump) {
1463                                         if (!IS_QLA82XX(ha))
1464                                                 qla2x00_alloc_fw_dump(vha);
1465                                 }
1466                         }
1467                 } else {
1468                         DEBUG2(printk(KERN_INFO
1469                             "scsi(%ld): ISP Firmware failed checksum.\n",
1470                             vha->host_no));
1471                 }
1472         }
1473
1474         if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
1475                 /* Enable proper parity. */
1476                 spin_lock_irqsave(&ha->hardware_lock, flags);
1477                 if (IS_QLA2300(ha))
1478                         /* SRAM parity */
1479                         WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x1);
1480                 else
1481                         /* SRAM, Instruction RAM and GP RAM parity */
1482                         WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x7);
1483                 RD_REG_WORD(&reg->hccr);
1484                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1485         }
1486
1487         if (rval == QLA_SUCCESS && IS_FAC_REQUIRED(ha)) {
1488                 uint32_t size;
1489
1490                 rval = qla81xx_fac_get_sector_size(vha, &size);
1491                 if (rval == QLA_SUCCESS) {
1492                         ha->flags.fac_supported = 1;
1493                         ha->fdt_block_size = size << 2;
1494                 } else {
1495                         qla_printk(KERN_ERR, ha,
1496                             "Unsupported FAC firmware (%d.%02d.%02d).\n",
1497                             ha->fw_major_version, ha->fw_minor_version,
1498                             ha->fw_subminor_version);
1499                 }
1500         }
1501 failed:
1502         if (rval) {
1503                 DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
1504                     vha->host_no));
1505         }
1506
1507         return (rval);
1508 }
1509
1510 /**
1511  * qla2x00_init_response_q_entries() - Initializes response queue entries.
1512  * @ha: HA context
1513  *
1514  * Beginning of request ring has initialization control block already built
1515  * by nvram config routine.
1516  *
1517  * Returns 0 on success.
1518  */
1519 void
1520 qla2x00_init_response_q_entries(struct rsp_que *rsp)
1521 {
1522         uint16_t cnt;
1523         response_t *pkt;
1524
1525         rsp->ring_ptr = rsp->ring;
1526         rsp->ring_index    = 0;
1527         rsp->status_srb = NULL;
1528         pkt = rsp->ring_ptr;
1529         for (cnt = 0; cnt < rsp->length; cnt++) {
1530                 pkt->signature = RESPONSE_PROCESSED;
1531                 pkt++;
1532         }
1533 }
1534
1535 /**
1536  * qla2x00_update_fw_options() - Read and process firmware options.
1537  * @ha: HA context
1538  *
1539  * Returns 0 on success.
1540  */
1541 void
1542 qla2x00_update_fw_options(scsi_qla_host_t *vha)
1543 {
1544         uint16_t swing, emphasis, tx_sens, rx_sens;
1545         struct qla_hw_data *ha = vha->hw;
1546
1547         memset(ha->fw_options, 0, sizeof(ha->fw_options));
1548         qla2x00_get_fw_options(vha, ha->fw_options);
1549
1550         if (IS_QLA2100(ha) || IS_QLA2200(ha))
1551                 return;
1552
1553         /* Serial Link options. */
1554         DEBUG3(printk("scsi(%ld): Serial link options:\n",
1555             vha->host_no));
1556         DEBUG3(qla2x00_dump_buffer((uint8_t *)&ha->fw_seriallink_options,
1557             sizeof(ha->fw_seriallink_options)));
1558
1559         ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
1560         if (ha->fw_seriallink_options[3] & BIT_2) {
1561                 ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;
1562
1563                 /*  1G settings */
1564                 swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
1565                 emphasis = (ha->fw_seriallink_options[2] &
1566                     (BIT_4 | BIT_3)) >> 3;
1567                 tx_sens = ha->fw_seriallink_options[0] &
1568                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
1569                 rx_sens = (ha->fw_seriallink_options[0] &
1570                     (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
1571                 ha->fw_options[10] = (emphasis << 14) | (swing << 8);
1572                 if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
1573                         if (rx_sens == 0x0)
1574                                 rx_sens = 0x3;
1575                         ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
1576                 } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
1577                         ha->fw_options[10] |= BIT_5 |
1578                             ((rx_sens & (BIT_1 | BIT_0)) << 2) |
1579                             (tx_sens & (BIT_1 | BIT_0));
1580
1581                 /*  2G settings */
1582                 swing = (ha->fw_seriallink_options[2] &
1583                     (BIT_7 | BIT_6 | BIT_5)) >> 5;
1584                 emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
1585                 tx_sens = ha->fw_seriallink_options[1] &
1586                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
1587                 rx_sens = (ha->fw_seriallink_options[1] &
1588                     (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
1589                 ha->fw_options[11] = (emphasis << 14) | (swing << 8);
1590                 if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
1591                         if (rx_sens == 0x0)
1592                                 rx_sens = 0x3;
1593                         ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
1594                 } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
1595                         ha->fw_options[11] |= BIT_5 |
1596                             ((rx_sens & (BIT_1 | BIT_0)) << 2) |
1597                             (tx_sens & (BIT_1 | BIT_0));
1598         }
1599
1600         /* FCP2 options. */
1601         /*  Return command IOCBs without waiting for an ABTS to complete. */
1602         ha->fw_options[3] |= BIT_13;
1603
1604         /* LED scheme. */
1605         if (ha->flags.enable_led_scheme)
1606                 ha->fw_options[2] |= BIT_12;
1607
1608         /* Detect ISP6312. */
1609         if (IS_QLA6312(ha))
1610                 ha->fw_options[2] |= BIT_13;
1611
1612         /* Update firmware options. */
1613         qla2x00_set_fw_options(vha, ha->fw_options);
1614 }
1615
1616 void
1617 qla24xx_update_fw_options(scsi_qla_host_t *vha)
1618 {
1619         int rval;
1620         struct qla_hw_data *ha = vha->hw;
1621
1622         if (IS_QLA82XX(ha))
1623                 return;
1624
1625         /* Update Serial Link options. */
1626         if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
1627                 return;
1628
1629         rval = qla2x00_set_serdes_params(vha,
1630             le16_to_cpu(ha->fw_seriallink_options24[1]),
1631             le16_to_cpu(ha->fw_seriallink_options24[2]),
1632             le16_to_cpu(ha->fw_seriallink_options24[3]));
1633         if (rval != QLA_SUCCESS) {
1634                 qla_printk(KERN_WARNING, ha,
1635                     "Unable to update Serial Link options (%x).\n", rval);
1636         }
1637 }
1638
1639 void
1640 qla2x00_config_rings(struct scsi_qla_host *vha)
1641 {
1642         struct qla_hw_data *ha = vha->hw;
1643         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1644         struct req_que *req = ha->req_q_map[0];
1645         struct rsp_que *rsp = ha->rsp_q_map[0];
1646
1647         /* Setup ring parameters in initialization control block. */
1648         ha->init_cb->request_q_outpointer = __constant_cpu_to_le16(0);
1649         ha->init_cb->response_q_inpointer = __constant_cpu_to_le16(0);
1650         ha->init_cb->request_q_length = cpu_to_le16(req->length);
1651         ha->init_cb->response_q_length = cpu_to_le16(rsp->length);
1652         ha->init_cb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
1653         ha->init_cb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
1654         ha->init_cb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
1655         ha->init_cb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1656
1657         WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
1658         WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
1659         WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
1660         WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
1661         RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg));            /* PCI Posting. */
1662 }
1663
1664 void
1665 qla24xx_config_rings(struct scsi_qla_host *vha)
1666 {
1667         struct qla_hw_data *ha = vha->hw;
1668         device_reg_t __iomem *reg = ISP_QUE_REG(ha, 0);
1669         struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp;
1670         struct qla_msix_entry *msix;
1671         struct init_cb_24xx *icb;
1672         uint16_t rid = 0;
1673         struct req_que *req = ha->req_q_map[0];
1674         struct rsp_que *rsp = ha->rsp_q_map[0];
1675
1676 /* Setup ring parameters in initialization control block. */
1677         icb = (struct init_cb_24xx *)ha->init_cb;
1678         icb->request_q_outpointer = __constant_cpu_to_le16(0);
1679         icb->response_q_inpointer = __constant_cpu_to_le16(0);
1680         icb->request_q_length = cpu_to_le16(req->length);
1681         icb->response_q_length = cpu_to_le16(rsp->length);
1682         icb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
1683         icb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
1684         icb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
1685         icb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1686
1687         if (ha->mqenable) {
1688                 icb->qos = __constant_cpu_to_le16(QLA_DEFAULT_QUE_QOS);
1689                 icb->rid = __constant_cpu_to_le16(rid);
1690                 if (ha->flags.msix_enabled) {
1691                         msix = &ha->msix_entries[1];
1692                         DEBUG2_17(printk(KERN_INFO
1693                         "Registering vector 0x%x for base que\n", msix->entry));
1694                         icb->msix = cpu_to_le16(msix->entry);
1695                 }
1696                 /* Use alternate PCI bus number */
1697                 if (MSB(rid))
1698                         icb->firmware_options_2 |=
1699                                 __constant_cpu_to_le32(BIT_19);
1700                 /* Use alternate PCI devfn */
1701                 if (LSB(rid))
1702                         icb->firmware_options_2 |=
1703                                 __constant_cpu_to_le32(BIT_18);
1704
1705                 /* Use Disable MSIX Handshake mode for capable adapters */
1706                 if (IS_MSIX_NACK_CAPABLE(ha)) {
1707                         icb->firmware_options_2 &=
1708                                 __constant_cpu_to_le32(~BIT_22);
1709                         ha->flags.disable_msix_handshake = 1;
1710                         qla_printk(KERN_INFO, ha,
1711                                 "MSIX Handshake Disable Mode turned on\n");
1712                 } else {
1713                         icb->firmware_options_2 |=
1714                                 __constant_cpu_to_le32(BIT_22);
1715                 }
1716                 icb->firmware_options_2 |= __constant_cpu_to_le32(BIT_23);
1717
1718                 WRT_REG_DWORD(&reg->isp25mq.req_q_in, 0);
1719                 WRT_REG_DWORD(&reg->isp25mq.req_q_out, 0);
1720                 WRT_REG_DWORD(&reg->isp25mq.rsp_q_in, 0);
1721                 WRT_REG_DWORD(&reg->isp25mq.rsp_q_out, 0);
1722         } else {
1723                 WRT_REG_DWORD(&reg->isp24.req_q_in, 0);
1724                 WRT_REG_DWORD(&reg->isp24.req_q_out, 0);
1725                 WRT_REG_DWORD(&reg->isp24.rsp_q_in, 0);
1726                 WRT_REG_DWORD(&reg->isp24.rsp_q_out, 0);
1727         }
1728         /* PCI posting */
1729         RD_REG_DWORD(&ioreg->hccr);
1730 }
1731
1732 /**
1733  * qla2x00_init_rings() - Initializes firmware.
1734  * @ha: HA context
1735  *
1736  * Beginning of request ring has initialization control block already built
1737  * by nvram config routine.
1738  *
1739  * Returns 0 on success.
1740  */
1741 static int
1742 qla2x00_init_rings(scsi_qla_host_t *vha)
1743 {
1744         int     rval;
1745         unsigned long flags = 0;
1746         int cnt, que;
1747         struct qla_hw_data *ha = vha->hw;
1748         struct req_que *req;
1749         struct rsp_que *rsp;
1750         struct scsi_qla_host *vp;
1751         struct mid_init_cb_24xx *mid_init_cb =
1752             (struct mid_init_cb_24xx *) ha->init_cb;
1753
1754         spin_lock_irqsave(&ha->hardware_lock, flags);
1755
1756         /* Clear outstanding commands array. */
1757         for (que = 0; que < ha->max_req_queues; que++) {
1758                 req = ha->req_q_map[que];
1759                 if (!req)
1760                         continue;
1761                 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
1762                         req->outstanding_cmds[cnt] = NULL;
1763
1764                 req->current_outstanding_cmd = 1;
1765
1766                 /* Initialize firmware. */
1767                 req->ring_ptr  = req->ring;
1768                 req->ring_index    = 0;
1769                 req->cnt      = req->length;
1770         }
1771
1772         for (que = 0; que < ha->max_rsp_queues; que++) {
1773                 rsp = ha->rsp_q_map[que];
1774                 if (!rsp)
1775                         continue;
1776                 /* Initialize response queue entries */
1777                 qla2x00_init_response_q_entries(rsp);
1778         }
1779
1780         /* Clear RSCN queue. */
1781         list_for_each_entry(vp, &ha->vp_list, list) {
1782                 vp->rscn_in_ptr = 0;
1783                 vp->rscn_out_ptr = 0;
1784         }
1785         ha->isp_ops->config_rings(vha);
1786
1787         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1788
1789         /* Update any ISP specific firmware options before initialization. */
1790         ha->isp_ops->update_fw_options(vha);
1791
1792         DEBUG(printk("scsi(%ld): Issue init firmware.\n", vha->host_no));
1793
1794         if (ha->flags.npiv_supported) {
1795                 if (ha->operating_mode == LOOP)
1796                         ha->max_npiv_vports = MIN_MULTI_ID_FABRIC - 1;
1797                 mid_init_cb->count = cpu_to_le16(ha->max_npiv_vports);
1798         }
1799
1800         if (IS_FWI2_CAPABLE(ha)) {
1801                 mid_init_cb->options = __constant_cpu_to_le16(BIT_1);
1802                 mid_init_cb->init_cb.execution_throttle =
1803                     cpu_to_le16(ha->fw_xcb_count);
1804         }
1805
1806         rval = qla2x00_init_firmware(vha, ha->init_cb_size);
1807         if (rval) {
1808                 DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
1809                     vha->host_no));
1810         } else {
1811                 DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
1812                     vha->host_no));
1813         }
1814
1815         return (rval);
1816 }
1817
1818 /**
1819  * qla2x00_fw_ready() - Waits for firmware ready.
1820  * @ha: HA context
1821  *
1822  * Returns 0 on success.
1823  */
1824 static int
1825 qla2x00_fw_ready(scsi_qla_host_t *vha)
1826 {
1827         int             rval;
1828         unsigned long   wtime, mtime, cs84xx_time;
1829         uint16_t        min_wait;       /* Minimum wait time if loop is down */
1830         uint16_t        wait_time;      /* Wait time if loop is coming ready */
1831         uint16_t        state[5];
1832         struct qla_hw_data *ha = vha->hw;
1833
1834         rval = QLA_SUCCESS;
1835
1836         /* 20 seconds for loop down. */
1837         min_wait = 20;
1838
1839         /*
1840          * Firmware should take at most one RATOV to login, plus 5 seconds for
1841          * our own processing.
1842          */
1843         if ((wait_time = (ha->retry_count*ha->login_timeout) + 5) < min_wait) {
1844                 wait_time = min_wait;
1845         }
1846
1847         /* Min wait time if loop down */
1848         mtime = jiffies + (min_wait * HZ);
1849
1850         /* wait time before firmware ready */
1851         wtime = jiffies + (wait_time * HZ);
1852
1853         /* Wait for ISP to finish LIP */
1854         if (!vha->flags.init_done)
1855                 qla_printk(KERN_INFO, ha, "Waiting for LIP to complete...\n");
1856
1857         DEBUG3(printk("scsi(%ld): Waiting for LIP to complete...\n",
1858             vha->host_no));
1859
1860         do {
1861                 rval = qla2x00_get_firmware_state(vha, state);
1862                 if (rval == QLA_SUCCESS) {
1863                         if (state[0] < FSTATE_LOSS_OF_SYNC) {
1864                                 vha->device_flags &= ~DFLG_NO_CABLE;
1865                         }
1866                         if (IS_QLA84XX(ha) && state[0] != FSTATE_READY) {
1867                                 DEBUG16(printk("scsi(%ld): fw_state=%x "
1868                                     "84xx=%x.\n", vha->host_no, state[0],
1869                                     state[2]));
1870                                 if ((state[2] & FSTATE_LOGGED_IN) &&
1871                                      (state[2] & FSTATE_WAITING_FOR_VERIFY)) {
1872                                         DEBUG16(printk("scsi(%ld): Sending "
1873                                             "verify iocb.\n", vha->host_no));
1874
1875                                         cs84xx_time = jiffies;
1876                                         rval = qla84xx_init_chip(vha);
1877                                         if (rval != QLA_SUCCESS)
1878                                                 break;
1879
1880                                         /* Add time taken to initialize. */
1881                                         cs84xx_time = jiffies - cs84xx_time;
1882                                         wtime += cs84xx_time;
1883                                         mtime += cs84xx_time;
1884                                         DEBUG16(printk("scsi(%ld): Increasing "
1885                                             "wait time by %ld. New time %ld\n",
1886                                             vha->host_no, cs84xx_time, wtime));
1887                                 }
1888                         } else if (state[0] == FSTATE_READY) {
1889                                 DEBUG(printk("scsi(%ld): F/W Ready - OK \n",
1890                                     vha->host_no));
1891
1892                                 qla2x00_get_retry_cnt(vha, &ha->retry_count,
1893                                     &ha->login_timeout, &ha->r_a_tov);
1894
1895                                 rval = QLA_SUCCESS;
1896                                 break;
1897                         }
1898
1899                         rval = QLA_FUNCTION_FAILED;
1900
1901                         if (atomic_read(&vha->loop_down_timer) &&
1902                             state[0] != FSTATE_READY) {
1903                                 /* Loop down. Timeout on min_wait for states
1904                                  * other than Wait for Login.
1905                                  */
1906                                 if (time_after_eq(jiffies, mtime)) {
1907                                         qla_printk(KERN_INFO, ha,
1908                                             "Cable is unplugged...\n");
1909
1910                                         vha->device_flags |= DFLG_NO_CABLE;
1911                                         break;
1912                                 }
1913                         }
1914                 } else {
1915                         /* Mailbox cmd failed. Timeout on min_wait. */
1916                         if (time_after_eq(jiffies, mtime) ||
1917                             (IS_QLA82XX(ha) && ha->flags.fw_hung))
1918                                 break;
1919                 }
1920
1921                 if (time_after_eq(jiffies, wtime))
1922                         break;
1923
1924                 /* Delay for a while */
1925                 msleep(500);
1926
1927                 DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1928                     vha->host_no, state[0], jiffies));
1929         } while (1);
1930
1931         DEBUG(printk("scsi(%ld): fw_state=%x (%x, %x, %x, %x) curr time=%lx.\n",
1932             vha->host_no, state[0], state[1], state[2], state[3], state[4],
1933             jiffies));
1934
1935         if (rval) {
1936                 DEBUG2_3(printk("scsi(%ld): Firmware ready **** FAILED ****.\n",
1937                     vha->host_no));
1938         }
1939
1940         return (rval);
1941 }
1942
1943 /*
1944 *  qla2x00_configure_hba
1945 *      Setup adapter context.
1946 *
1947 * Input:
1948 *      ha = adapter state pointer.
1949 *
1950 * Returns:
1951 *      0 = success
1952 *
1953 * Context:
1954 *      Kernel context.
1955 */
1956 static int
1957 qla2x00_configure_hba(scsi_qla_host_t *vha)
1958 {
1959         int       rval;
1960         uint16_t      loop_id;
1961         uint16_t      topo;
1962         uint16_t      sw_cap;
1963         uint8_t       al_pa;
1964         uint8_t       area;
1965         uint8_t       domain;
1966         char            connect_type[22];
1967         struct qla_hw_data *ha = vha->hw;
1968
1969         /* Get host addresses. */
1970         rval = qla2x00_get_adapter_id(vha,
1971             &loop_id, &al_pa, &area, &domain, &topo, &sw_cap);
1972         if (rval != QLA_SUCCESS) {
1973                 if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
1974                     (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
1975                         DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
1976                             __func__, vha->host_no));
1977                 } else {
1978                         qla_printk(KERN_WARNING, ha,
1979                             "ERROR -- Unable to get host loop ID.\n");
1980                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1981                 }
1982                 return (rval);
1983         }
1984
1985         if (topo == 4) {
1986                 qla_printk(KERN_INFO, ha,
1987                         "Cannot get topology - retrying.\n");
1988                 return (QLA_FUNCTION_FAILED);
1989         }
1990
1991         vha->loop_id = loop_id;
1992
1993         /* initialize */
1994         ha->min_external_loopid = SNS_FIRST_LOOP_ID;
1995         ha->operating_mode = LOOP;
1996         ha->switch_cap = 0;
1997
1998         switch (topo) {
1999         case 0:
2000                 DEBUG3(printk("scsi(%ld): HBA in NL topology.\n",
2001                     vha->host_no));
2002                 ha->current_topology = ISP_CFG_NL;
2003                 strcpy(connect_type, "(Loop)");
2004                 break;
2005
2006         case 1:
2007                 DEBUG3(printk("scsi(%ld): HBA in FL topology.\n",
2008                     vha->host_no));
2009                 ha->switch_cap = sw_cap;
2010                 ha->current_topology = ISP_CFG_FL;
2011                 strcpy(connect_type, "(FL_Port)");
2012                 break;
2013
2014         case 2:
2015                 DEBUG3(printk("scsi(%ld): HBA in N P2P topology.\n",
2016                     vha->host_no));
2017                 ha->operating_mode = P2P;
2018                 ha->current_topology = ISP_CFG_N;
2019                 strcpy(connect_type, "(N_Port-to-N_Port)");
2020                 break;
2021
2022         case 3:
2023                 DEBUG3(printk("scsi(%ld): HBA in F P2P topology.\n",
2024                     vha->host_no));
2025                 ha->switch_cap = sw_cap;
2026                 ha->operating_mode = P2P;
2027                 ha->current_topology = ISP_CFG_F;
2028                 strcpy(connect_type, "(F_Port)");
2029                 break;
2030
2031         default:
2032                 DEBUG3(printk("scsi(%ld): HBA in unknown topology %x. "
2033                     "Using NL.\n",
2034                     vha->host_no, topo));
2035                 ha->current_topology = ISP_CFG_NL;
2036                 strcpy(connect_type, "(Loop)");
2037                 break;
2038         }
2039
2040         /* Save Host port and loop ID. */
2041         /* byte order - Big Endian */
2042         vha->d_id.b.domain = domain;
2043         vha->d_id.b.area = area;
2044         vha->d_id.b.al_pa = al_pa;
2045
2046         if (!vha->flags.init_done)
2047                 qla_printk(KERN_INFO, ha,
2048                     "Topology - %s, Host Loop address 0x%x\n",
2049                     connect_type, vha->loop_id);
2050
2051         if (rval) {
2052                 DEBUG2_3(printk("scsi(%ld): FAILED.\n", vha->host_no));
2053         } else {
2054                 DEBUG3(printk("scsi(%ld): exiting normally.\n", vha->host_no));
2055         }
2056
2057         return(rval);
2058 }
2059
2060 inline void
2061 qla2x00_set_model_info(scsi_qla_host_t *vha, uint8_t *model, size_t len,
2062         char *def)
2063 {
2064         char *st, *en;
2065         uint16_t index;
2066         struct qla_hw_data *ha = vha->hw;
2067         int use_tbl = !IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha) &&
2068             !IS_QLA8XXX_TYPE(ha);
2069
2070         if (memcmp(model, BINZERO, len) != 0) {
2071                 strncpy(ha->model_number, model, len);
2072                 st = en = ha->model_number;
2073                 en += len - 1;
2074                 while (en > st) {
2075                         if (*en != 0x20 && *en != 0x00)
2076                                 break;
2077                         *en-- = '\0';
2078                 }
2079
2080                 index = (ha->pdev->subsystem_device & 0xff);
2081                 if (use_tbl &&
2082                     ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2083                     index < QLA_MODEL_NAMES)
2084                         strncpy(ha->model_desc,
2085                             qla2x00_model_name[index * 2 + 1],
2086                             sizeof(ha->model_desc) - 1);
2087         } else {
2088                 index = (ha->pdev->subsystem_device & 0xff);
2089                 if (use_tbl &&
2090                     ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2091                     index < QLA_MODEL_NAMES) {
2092                         strcpy(ha->model_number,
2093                             qla2x00_model_name[index * 2]);
2094                         strncpy(ha->model_desc,
2095                             qla2x00_model_name[index * 2 + 1],
2096                             sizeof(ha->model_desc) - 1);
2097                 } else {
2098                         strcpy(ha->model_number, def);
2099                 }
2100         }
2101         if (IS_FWI2_CAPABLE(ha))
2102                 qla2xxx_get_vpd_field(vha, "\x82", ha->model_desc,
2103                     sizeof(ha->model_desc));
2104 }
2105
2106 /* On sparc systems, obtain port and node WWN from firmware
2107  * properties.
2108  */
2109 static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t *vha, nvram_t *nv)
2110 {
2111 #ifdef CONFIG_SPARC
2112         struct qla_hw_data *ha = vha->hw;
2113         struct pci_dev *pdev = ha->pdev;
2114         struct device_node *dp = pci_device_to_OF_node(pdev);
2115         const u8 *val;
2116         int len;
2117
2118         val = of_get_property(dp, "port-wwn", &len);
2119         if (val && len >= WWN_SIZE)
2120                 memcpy(nv->port_name, val, WWN_SIZE);
2121
2122         val = of_get_property(dp, "node-wwn", &len);
2123         if (val && len >= WWN_SIZE)
2124                 memcpy(nv->node_name, val, WWN_SIZE);
2125 #endif
2126 }
2127
2128 /*
2129 * NVRAM configuration for ISP 2xxx
2130 *
2131 * Input:
2132 *      ha                = adapter block pointer.
2133 *
2134 * Output:
2135 *      initialization control block in response_ring
2136 *      host adapters parameters in host adapter block
2137 *
2138 * Returns:
2139 *      0 = success.
2140 */
2141 int
2142 qla2x00_nvram_config(scsi_qla_host_t *vha)
2143 {
2144         int             rval;
2145         uint8_t         chksum = 0;
2146         uint16_t        cnt;
2147         uint8_t         *dptr1, *dptr2;
2148         struct qla_hw_data *ha = vha->hw;
2149         init_cb_t       *icb = ha->init_cb;
2150         nvram_t         *nv = ha->nvram;
2151         uint8_t         *ptr = ha->nvram;
2152         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2153
2154         rval = QLA_SUCCESS;
2155
2156         /* Determine NVRAM starting address. */
2157         ha->nvram_size = sizeof(nvram_t);
2158         ha->nvram_base = 0;
2159         if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha))
2160                 if ((RD_REG_WORD(&reg->ctrl_status) >> 14) == 1)
2161                         ha->nvram_base = 0x80;
2162
2163         /* Get NVRAM data and calculate checksum. */
2164         ha->isp_ops->read_nvram(vha, ptr, ha->nvram_base, ha->nvram_size);
2165         for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
2166                 chksum += *ptr++;
2167
2168         DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
2169         DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
2170
2171         /* Bad NVRAM data, set defaults parameters. */
2172         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
2173             nv->id[2] != 'P' || nv->id[3] != ' ' || nv->nvram_version < 1) {
2174                 /* Reset NVRAM data. */
2175                 qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
2176                     "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
2177                     nv->nvram_version);
2178                 qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
2179                     "invalid -- WWPN) defaults.\n");
2180
2181                 /*
2182                  * Set default initialization control block.
2183                  */
2184                 memset(nv, 0, ha->nvram_size);
2185                 nv->parameter_block_version = ICB_VERSION;
2186
2187                 if (IS_QLA23XX(ha)) {
2188                         nv->firmware_options[0] = BIT_2 | BIT_1;
2189                         nv->firmware_options[1] = BIT_7 | BIT_5;
2190                         nv->add_firmware_options[0] = BIT_5;
2191                         nv->add_firmware_options[1] = BIT_5 | BIT_4;
2192                         nv->frame_payload_size = __constant_cpu_to_le16(2048);
2193                         nv->special_options[1] = BIT_7;
2194                 } else if (IS_QLA2200(ha)) {
2195                         nv->firmware_options[0] = BIT_2 | BIT_1;
2196                         nv->firmware_options[1] = BIT_7 | BIT_5;
2197                         nv->add_firmware_options[0] = BIT_5;
2198                         nv->add_firmware_options[1] = BIT_5 | BIT_4;
2199                         nv->frame_payload_size = __constant_cpu_to_le16(1024);
2200                 } else if (IS_QLA2100(ha)) {
2201                         nv->firmware_options[0] = BIT_3 | BIT_1;
2202                         nv->firmware_options[1] = BIT_5;
2203                         nv->frame_payload_size = __constant_cpu_to_le16(1024);
2204                 }
2205
2206                 nv->max_iocb_allocation = __constant_cpu_to_le16(256);
2207                 nv->execution_throttle = __constant_cpu_to_le16(16);
2208                 nv->retry_count = 8;
2209                 nv->retry_delay = 1;
2210
2211                 nv->port_name[0] = 33;
2212                 nv->port_name[3] = 224;
2213                 nv->port_name[4] = 139;
2214
2215                 qla2xxx_nvram_wwn_from_ofw(vha, nv);
2216
2217                 nv->login_timeout = 4;
2218
2219                 /*
2220                  * Set default host adapter parameters
2221                  */
2222                 nv->host_p[1] = BIT_2;
2223                 nv->reset_delay = 5;
2224                 nv->port_down_retry_count = 8;
2225                 nv->max_luns_per_target = __constant_cpu_to_le16(8);
2226                 nv->link_down_timeout = 60;
2227
2228                 rval = 1;
2229         }
2230
2231 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2232         /*
2233          * The SN2 does not provide BIOS emulation which means you can't change
2234          * potentially bogus BIOS settings. Force the use of default settings
2235          * for link rate and frame size.  Hope that the rest of the settings
2236          * are valid.
2237          */
2238         if (ia64_platform_is("sn2")) {
2239                 nv->frame_payload_size = __constant_cpu_to_le16(2048);
2240                 if (IS_QLA23XX(ha))
2241                         nv->special_options[1] = BIT_7;
2242         }
2243 #endif
2244
2245         /* Reset Initialization control block */
2246         memset(icb, 0, ha->init_cb_size);
2247
2248         /*
2249          * Setup driver NVRAM options.
2250          */
2251         nv->firmware_options[0] |= (BIT_6 | BIT_1);
2252         nv->firmware_options[0] &= ~(BIT_5 | BIT_4);
2253         nv->firmware_options[1] |= (BIT_5 | BIT_0);
2254         nv->firmware_options[1] &= ~BIT_4;
2255
2256         if (IS_QLA23XX(ha)) {
2257                 nv->firmware_options[0] |= BIT_2;
2258                 nv->firmware_options[0] &= ~BIT_3;
2259                 nv->firmware_options[0] &= ~BIT_6;
2260                 nv->add_firmware_options[1] |= BIT_5 | BIT_4;
2261
2262                 if (IS_QLA2300(ha)) {
2263                         if (ha->fb_rev == FPM_2310) {
2264                                 strcpy(ha->model_number, "QLA2310");
2265                         } else {
2266                                 strcpy(ha->model_number, "QLA2300");
2267                         }
2268                 } else {
2269                         qla2x00_set_model_info(vha, nv->model_number,
2270                             sizeof(nv->model_number), "QLA23xx");
2271                 }
2272         } else if (IS_QLA2200(ha)) {
2273                 nv->firmware_options[0] |= BIT_2;
2274                 /*
2275                  * 'Point-to-point preferred, else loop' is not a safe
2276                  * connection mode setting.
2277                  */
2278                 if ((nv->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) ==
2279                     (BIT_5 | BIT_4)) {
2280                         /* Force 'loop preferred, else point-to-point'. */
2281                         nv->add_firmware_options[0] &= ~(BIT_6 | BIT_5 | BIT_4);
2282                         nv->add_firmware_options[0] |= BIT_5;
2283                 }
2284                 strcpy(ha->model_number, "QLA22xx");
2285         } else /*if (IS_QLA2100(ha))*/ {
2286                 strcpy(ha->model_number, "QLA2100");
2287         }
2288
2289         /*
2290          * Copy over NVRAM RISC parameter block to initialization control block.
2291          */
2292         dptr1 = (uint8_t *)icb;
2293         dptr2 = (uint8_t *)&nv->parameter_block_version;
2294         cnt = (uint8_t *)&icb->request_q_outpointer - (uint8_t *)&icb->version;
2295         while (cnt--)
2296                 *dptr1++ = *dptr2++;
2297
2298         /* Copy 2nd half. */
2299         dptr1 = (uint8_t *)icb->add_firmware_options;
2300         cnt = (uint8_t *)icb->reserved_3 - (uint8_t *)icb->add_firmware_options;
2301         while (cnt--)
2302                 *dptr1++ = *dptr2++;
2303
2304         /* Use alternate WWN? */
2305         if (nv->host_p[1] & BIT_7) {
2306                 memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
2307                 memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
2308         }
2309
2310         /* Prepare nodename */
2311         if ((icb->firmware_options[1] & BIT_6) == 0) {
2312                 /*
2313                  * Firmware will apply the following mask if the nodename was
2314                  * not provided.
2315                  */
2316                 memcpy(icb->node_name, icb->port_name, WWN_SIZE);
2317                 icb->node_name[0] &= 0xF0;
2318         }
2319
2320         /*
2321          * Set host adapter parameters.
2322          */
2323         if (nv->host_p[0] & BIT_7)
2324                 ql2xextended_error_logging = 1;
2325         ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
2326         /* Always load RISC code on non ISP2[12]00 chips. */
2327         if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
2328                 ha->flags.disable_risc_code_load = 0;
2329         ha->flags.enable_lip_reset = ((nv->host_p[1] & BIT_1) ? 1 : 0);
2330         ha->flags.enable_lip_full_login = ((nv->host_p[1] & BIT_2) ? 1 : 0);
2331         ha->flags.enable_target_reset = ((nv->host_p[1] & BIT_3) ? 1 : 0);
2332         ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
2333         ha->flags.disable_serdes = 0;
2334
2335         ha->operating_mode =
2336             (icb->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) >> 4;
2337
2338         memcpy(ha->fw_seriallink_options, nv->seriallink_options,
2339             sizeof(ha->fw_seriallink_options));
2340
2341         /* save HBA serial number */
2342         ha->serial0 = icb->port_name[5];
2343         ha->serial1 = icb->port_name[6];
2344         ha->serial2 = icb->port_name[7];
2345         memcpy(vha->node_name, icb->node_name, WWN_SIZE);
2346         memcpy(vha->port_name, icb->port_name, WWN_SIZE);
2347
2348         icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
2349
2350         ha->retry_count = nv->retry_count;
2351
2352         /* Set minimum login_timeout to 4 seconds. */
2353         if (nv->login_timeout != ql2xlogintimeout)
2354                 nv->login_timeout = ql2xlogintimeout;
2355         if (nv->login_timeout < 4)
2356                 nv->login_timeout = 4;
2357         ha->login_timeout = nv->login_timeout;
2358         icb->login_timeout = nv->login_timeout;
2359
2360         /* Set minimum RATOV to 100 tenths of a second. */
2361         ha->r_a_tov = 100;
2362
2363         ha->loop_reset_delay = nv->reset_delay;
2364
2365         /* Link Down Timeout = 0:
2366          *
2367          *      When Port Down timer expires we will start returning
2368          *      I/O's to OS with "DID_NO_CONNECT".
2369          *
2370          * Link Down Timeout != 0:
2371          *
2372          *       The driver waits for the link to come up after link down
2373          *       before returning I/Os to OS with "DID_NO_CONNECT".
2374          */
2375         if (nv->link_down_timeout == 0) {
2376                 ha->loop_down_abort_time =
2377                     (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
2378         } else {
2379                 ha->link_down_timeout =  nv->link_down_timeout;
2380                 ha->loop_down_abort_time =
2381                     (LOOP_DOWN_TIME - ha->link_down_timeout);
2382         }
2383
2384         /*
2385          * Need enough time to try and get the port back.
2386          */
2387         ha->port_down_retry_count = nv->port_down_retry_count;
2388         if (qlport_down_retry)
2389                 ha->port_down_retry_count = qlport_down_retry;
2390         /* Set login_retry_count */
2391         ha->login_retry_count  = nv->retry_count;
2392         if (ha->port_down_retry_count == nv->port_down_retry_count &&
2393             ha->port_down_retry_count > 3)
2394                 ha->login_retry_count = ha->port_down_retry_count;
2395         else if (ha->port_down_retry_count > (int)ha->login_retry_count)
2396                 ha->login_retry_count = ha->port_down_retry_count;
2397         if (ql2xloginretrycount)
2398                 ha->login_retry_count = ql2xloginretrycount;
2399
2400         icb->lun_enables = __constant_cpu_to_le16(0);
2401         icb->command_resource_count = 0;
2402         icb->immediate_notify_resource_count = 0;
2403         icb->timeout = __constant_cpu_to_le16(0);
2404
2405         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
2406                 /* Enable RIO */
2407                 icb->firmware_options[0] &= ~BIT_3;
2408                 icb->add_firmware_options[0] &=
2409                     ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2410                 icb->add_firmware_options[0] |= BIT_2;
2411                 icb->response_accumulation_timer = 3;
2412                 icb->interrupt_delay_timer = 5;
2413
2414                 vha->flags.process_response_queue = 1;
2415         } else {
2416                 /* Enable ZIO. */
2417                 if (!vha->flags.init_done) {
2418                         ha->zio_mode = icb->add_firmware_options[0] &
2419                             (BIT_3 | BIT_2 | BIT_1 | BIT_0);
2420                         ha->zio_timer = icb->interrupt_delay_timer ?
2421                             icb->interrupt_delay_timer: 2;
2422                 }
2423                 icb->add_firmware_options[0] &=
2424                     ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2425                 vha->flags.process_response_queue = 0;
2426                 if (ha->zio_mode != QLA_ZIO_DISABLED) {
2427                         ha->zio_mode = QLA_ZIO_MODE_6;
2428
2429                         DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
2430                             "delay (%d us).\n", vha->host_no, ha->zio_mode,
2431                             ha->zio_timer * 100));
2432                         qla_printk(KERN_INFO, ha,
2433                             "ZIO mode %d enabled; timer delay (%d us).\n",
2434                             ha->zio_mode, ha->zio_timer * 100);
2435
2436                         icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
2437                         icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
2438                         vha->flags.process_response_queue = 1;
2439                 }
2440         }
2441
2442         if (rval) {
2443                 DEBUG2_3(printk(KERN_WARNING
2444                     "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
2445         }
2446         return (rval);
2447 }
2448
2449 static void
2450 qla2x00_rport_del(void *data)
2451 {
2452         fc_port_t *fcport = data;
2453         struct fc_rport *rport;
2454
2455         spin_lock_irq(fcport->vha->host->host_lock);
2456         rport = fcport->drport ? fcport->drport: fcport->rport;
2457         fcport->drport = NULL;
2458         spin_unlock_irq(fcport->vha->host->host_lock);
2459         if (rport)
2460                 fc_remote_port_delete(rport);
2461 }
2462
2463 /**
2464  * qla2x00_alloc_fcport() - Allocate a generic fcport.
2465  * @ha: HA context
2466  * @flags: allocation flags
2467  *
2468  * Returns a pointer to the allocated fcport, or NULL, if none available.
2469  */
2470 fc_port_t *
2471 qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
2472 {
2473         fc_port_t *fcport;
2474
2475         fcport = kzalloc(sizeof(fc_port_t), flags);
2476         if (!fcport)
2477                 return NULL;
2478
2479         /* Setup fcport template structure. */
2480         fcport->vha = vha;
2481         fcport->vp_idx = vha->vp_idx;
2482         fcport->port_type = FCT_UNKNOWN;
2483         fcport->loop_id = FC_NO_LOOP_ID;
2484         atomic_set(&fcport->state, FCS_UNCONFIGURED);
2485         fcport->supported_classes = FC_COS_UNSPECIFIED;
2486
2487         return fcport;
2488 }
2489
2490 /*
2491  * qla2x00_configure_loop
2492  *      Updates Fibre Channel Device Database with what is actually on loop.
2493  *
2494  * Input:
2495  *      ha                = adapter block pointer.
2496  *
2497  * Returns:
2498  *      0 = success.
2499  *      1 = error.
2500  *      2 = database was full and device was not configured.
2501  */
2502 static int
2503 qla2x00_configure_loop(scsi_qla_host_t *vha)
2504 {
2505         int  rval;
2506         unsigned long flags, save_flags;
2507         struct qla_hw_data *ha = vha->hw;
2508         rval = QLA_SUCCESS;
2509
2510         /* Get Initiator ID */
2511         if (test_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags)) {
2512                 rval = qla2x00_configure_hba(vha);
2513                 if (rval != QLA_SUCCESS) {
2514                         DEBUG(printk("scsi(%ld): Unable to configure HBA.\n",
2515                             vha->host_no));
2516                         return (rval);
2517                 }
2518         }
2519
2520         save_flags = flags = vha->dpc_flags;
2521         DEBUG(printk("scsi(%ld): Configure loop -- dpc flags =0x%lx\n",
2522             vha->host_no, flags));
2523
2524         /*
2525          * If we have both an RSCN and PORT UPDATE pending then handle them
2526          * both at the same time.
2527          */
2528         clear_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2529         clear_bit(RSCN_UPDATE, &vha->dpc_flags);
2530
2531         qla2x00_get_data_rate(vha);
2532
2533         /* Determine what we need to do */
2534         if (ha->current_topology == ISP_CFG_FL &&
2535             (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
2536
2537                 vha->flags.rscn_queue_overflow = 1;
2538                 set_bit(RSCN_UPDATE, &flags);
2539
2540         } else if (ha->current_topology == ISP_CFG_F &&
2541             (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
2542
2543                 vha->flags.rscn_queue_overflow = 1;
2544                 set_bit(RSCN_UPDATE, &flags);
2545                 clear_bit(LOCAL_LOOP_UPDATE, &flags);
2546
2547         } else if (ha->current_topology == ISP_CFG_N) {
2548                 clear_bit(RSCN_UPDATE, &flags);
2549
2550         } else if (!vha->flags.online ||
2551             (test_bit(ABORT_ISP_ACTIVE, &flags))) {
2552
2553                 vha->flags.rscn_queue_overflow = 1;
2554                 set_bit(RSCN_UPDATE, &flags);
2555                 set_bit(LOCAL_LOOP_UPDATE, &flags);
2556         }
2557
2558         if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
2559                 if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
2560                         rval = QLA_FUNCTION_FAILED;
2561                 else
2562                         rval = qla2x00_configure_local_loop(vha);
2563         }
2564
2565         if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
2566                 if (LOOP_TRANSITION(vha))
2567                         rval = QLA_FUNCTION_FAILED;
2568                 else
2569                         rval = qla2x00_configure_fabric(vha);
2570         }
2571
2572         if (rval == QLA_SUCCESS) {
2573                 if (atomic_read(&vha->loop_down_timer) ||
2574                     test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
2575                         rval = QLA_FUNCTION_FAILED;
2576                 } else {
2577                         atomic_set(&vha->loop_state, LOOP_READY);
2578
2579                         DEBUG(printk("scsi(%ld): LOOP READY\n", vha->host_no));
2580                 }
2581         }
2582
2583         if (rval) {
2584                 DEBUG2_3(printk("%s(%ld): *** FAILED ***\n",
2585                     __func__, vha->host_no));
2586         } else {
2587                 DEBUG3(printk("%s: exiting normally\n", __func__));
2588         }
2589
2590         /* Restore state if a resync event occurred during processing */
2591         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
2592                 if (test_bit(LOCAL_LOOP_UPDATE, &save_flags))
2593                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2594                 if (test_bit(RSCN_UPDATE, &save_flags)) {
2595                         set_bit(RSCN_UPDATE, &vha->dpc_flags);
2596                         if (!IS_ALOGIO_CAPABLE(ha))
2597                                 vha->flags.rscn_queue_overflow = 1;
2598                 }
2599         }
2600
2601         return (rval);
2602 }
2603
2604
2605
2606 /*
2607  * qla2x00_configure_local_loop
2608  *      Updates Fibre Channel Device Database with local loop devices.
2609  *
2610  * Input:
2611  *      ha = adapter block pointer.
2612  *
2613  * Returns:
2614  *      0 = success.
2615  */
2616 static int
2617 qla2x00_configure_local_loop(scsi_qla_host_t *vha)
2618 {
2619         int             rval, rval2;
2620         int             found_devs;
2621         int             found;
2622         fc_port_t       *fcport, *new_fcport;
2623
2624         uint16_t        index;
2625         uint16_t        entries;
2626         char            *id_iter;
2627         uint16_t        loop_id;
2628         uint8_t         domain, area, al_pa;
2629         struct qla_hw_data *ha = vha->hw;
2630
2631         found_devs = 0;
2632         new_fcport = NULL;
2633         entries = MAX_FIBRE_DEVICES;
2634
2635         DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", vha->host_no));
2636         DEBUG3(qla2x00_get_fcal_position_map(vha, NULL));
2637
2638         /* Get list of logged in devices. */
2639         memset(ha->gid_list, 0, GID_LIST_SIZE);
2640         rval = qla2x00_get_id_list(vha, ha->gid_list, ha->gid_list_dma,
2641             &entries);
2642         if (rval != QLA_SUCCESS)
2643                 goto cleanup_allocation;
2644
2645         DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
2646             vha->host_no, entries));
2647         DEBUG3(qla2x00_dump_buffer((uint8_t *)ha->gid_list,
2648             entries * sizeof(struct gid_list_info)));
2649
2650         /* Allocate temporary fcport for any new fcports discovered. */
2651         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2652         if (new_fcport == NULL) {
2653                 rval = QLA_MEMORY_ALLOC_FAILED;
2654                 goto cleanup_allocation;
2655         }
2656         new_fcport->flags &= ~FCF_FABRIC_DEVICE;
2657
2658         /*
2659          * Mark local devices that were present with FCF_DEVICE_LOST for now.
2660          */
2661         list_for_each_entry(fcport, &vha->vp_fcports, list) {
2662                 if (atomic_read(&fcport->state) == FCS_ONLINE &&
2663                     fcport->port_type != FCT_BROADCAST &&
2664                     (fcport->flags & FCF_FABRIC_DEVICE) == 0) {
2665
2666                         DEBUG(printk("scsi(%ld): Marking port lost, "
2667                             "loop_id=0x%04x\n",
2668                             vha->host_no, fcport->loop_id));
2669
2670                         atomic_set(&fcport->state, FCS_DEVICE_LOST);
2671                 }
2672         }
2673
2674         /* Add devices to port list. */
2675         id_iter = (char *)ha->gid_list;
2676         for (index = 0; index < entries; index++) {
2677                 domain = ((struct gid_list_info *)id_iter)->domain;
2678                 area = ((struct gid_list_info *)id_iter)->area;
2679                 al_pa = ((struct gid_list_info *)id_iter)->al_pa;
2680                 if (IS_QLA2100(ha) || IS_QLA2200(ha))
2681                         loop_id = (uint16_t)
2682                             ((struct gid_list_info *)id_iter)->loop_id_2100;
2683                 else
2684                         loop_id = le16_to_cpu(
2685                             ((struct gid_list_info *)id_iter)->loop_id);
2686                 id_iter += ha->gid_list_info_size;
2687
2688                 /* Bypass reserved domain fields. */
2689                 if ((domain & 0xf0) == 0xf0)
2690                         continue;
2691
2692                 /* Bypass if not same domain and area of adapter. */
2693                 if (area && domain &&
2694                     (area != vha->d_id.b.area || domain != vha->d_id.b.domain))
2695                         continue;
2696
2697                 /* Bypass invalid local loop ID. */
2698                 if (loop_id > LAST_LOCAL_LOOP_ID)
2699                         continue;
2700
2701                 /* Fill in member data. */
2702                 new_fcport->d_id.b.domain = domain;
2703                 new_fcport->d_id.b.area = area;
2704                 new_fcport->d_id.b.al_pa = al_pa;
2705                 new_fcport->loop_id = loop_id;
2706                 new_fcport->vp_idx = vha->vp_idx;
2707                 rval2 = qla2x00_get_port_database(vha, new_fcport, 0);
2708                 if (rval2 != QLA_SUCCESS) {
2709                         DEBUG2(printk("scsi(%ld): Failed to retrieve fcport "
2710                             "information -- get_port_database=%x, "
2711                             "loop_id=0x%04x\n",
2712                             vha->host_no, rval2, new_fcport->loop_id));
2713                         DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
2714                             vha->host_no));
2715                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
2716                         continue;
2717                 }
2718
2719                 /* Check for matching device in port list. */
2720                 found = 0;
2721                 fcport = NULL;
2722                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2723                         if (memcmp(new_fcport->port_name, fcport->port_name,
2724                             WWN_SIZE))
2725                                 continue;
2726
2727                         fcport->flags &= ~FCF_FABRIC_DEVICE;
2728                         fcport->loop_id = new_fcport->loop_id;
2729                         fcport->port_type = new_fcport->port_type;
2730                         fcport->d_id.b24 = new_fcport->d_id.b24;
2731                         memcpy(fcport->node_name, new_fcport->node_name,
2732                             WWN_SIZE);
2733
2734                         found++;
2735                         break;
2736                 }
2737
2738                 if (!found) {
2739                         /* New device, add to fcports list. */
2740                         if (vha->vp_idx) {
2741                                 new_fcport->vha = vha;
2742                                 new_fcport->vp_idx = vha->vp_idx;
2743                         }
2744                         list_add_tail(&new_fcport->list, &vha->vp_fcports);
2745
2746                         /* Allocate a new replacement fcport. */
2747                         fcport = new_fcport;
2748                         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2749                         if (new_fcport == NULL) {
2750                                 rval = QLA_MEMORY_ALLOC_FAILED;
2751                                 goto cleanup_allocation;
2752                         }
2753                         new_fcport->flags &= ~FCF_FABRIC_DEVICE;
2754                 }
2755
2756                 /* Base iIDMA settings on HBA port speed. */
2757                 fcport->fp_speed = ha->link_data_rate;
2758
2759                 qla2x00_update_fcport(vha, fcport);
2760
2761                 found_devs++;
2762         }
2763
2764 cleanup_allocation:
2765         kfree(new_fcport);
2766
2767         if (rval != QLA_SUCCESS) {
2768                 DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
2769                     "rval=%x\n", vha->host_no, rval));
2770         }
2771
2772         return (rval);
2773 }
2774
2775 static void
2776 qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2777 {
2778 #define LS_UNKNOWN      2
2779         static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
2780         char *link_speed;
2781         int rval;
2782         uint16_t mb[4];
2783         struct qla_hw_data *ha = vha->hw;
2784
2785         if (!IS_IIDMA_CAPABLE(ha))
2786                 return;
2787
2788         if (fcport->fp_speed == PORT_SPEED_UNKNOWN ||
2789             fcport->fp_speed > ha->link_data_rate)
2790                 return;
2791
2792         rval = qla2x00_set_idma_speed(vha, fcport->loop_id, fcport->fp_speed,
2793             mb);
2794         if (rval != QLA_SUCCESS) {
2795                 DEBUG2(printk("scsi(%ld): Unable to adjust iIDMA "
2796                     "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x %04x.\n",
2797                     vha->host_no, fcport->port_name[0], fcport->port_name[1],
2798                     fcport->port_name[2], fcport->port_name[3],
2799                     fcport->port_name[4], fcport->port_name[5],
2800                     fcport->port_name[6], fcport->port_name[7], rval,
2801                     fcport->fp_speed, mb[0], mb[1]));
2802         } else {
2803                 link_speed = link_speeds[LS_UNKNOWN];
2804                 if (fcport->fp_speed < 5)
2805                         link_speed = link_speeds[fcport->fp_speed];
2806                 else if (fcport->fp_speed == 0x13)
2807                         link_speed = link_speeds[5];
2808                 DEBUG2(qla_printk(KERN_INFO, ha,
2809                     "iIDMA adjusted to %s GB/s on "
2810                     "%02x%02x%02x%02x%02x%02x%02x%02x.\n",
2811                     link_speed, fcport->port_name[0],
2812                     fcport->port_name[1], fcport->port_name[2],
2813                     fcport->port_name[3], fcport->port_name[4],
2814                     fcport->port_name[5], fcport->port_name[6],
2815                     fcport->port_name[7]));
2816         }
2817 }
2818
2819 static void
2820 qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
2821 {
2822         struct fc_rport_identifiers rport_ids;
2823         struct fc_rport *rport;
2824         struct qla_hw_data *ha = vha->hw;
2825
2826         qla2x00_rport_del(fcport);
2827
2828         rport_ids.node_name = wwn_to_u64(fcport->node_name);
2829         rport_ids.port_name = wwn_to_u64(fcport->port_name);
2830         rport_ids.port_id = fcport->d_id.b.domain << 16 |
2831             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2832         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2833         fcport->rport = rport = fc_remote_port_add(vha->host, 0, &rport_ids);
2834         if (!rport) {
2835                 qla_printk(KERN_WARNING, ha,
2836                     "Unable to allocate fc remote port!\n");
2837                 return;
2838         }
2839         spin_lock_irq(fcport->vha->host->host_lock);
2840         *((fc_port_t **)rport->dd_data) = fcport;
2841         spin_unlock_irq(fcport->vha->host->host_lock);
2842
2843         rport->supported_classes = fcport->supported_classes;
2844
2845         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2846         if (fcport->port_type == FCT_INITIATOR)
2847                 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
2848         if (fcport->port_type == FCT_TARGET)
2849                 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
2850         fc_remote_port_rolechg(rport, rport_ids.roles);
2851 }
2852
2853 /*
2854  * qla2x00_update_fcport
2855  *      Updates device on list.
2856  *
2857  * Input:
2858  *      ha = adapter block pointer.
2859  *      fcport = port structure pointer.
2860  *
2861  * Return:
2862  *      0  - Success
2863  *  BIT_0 - error
2864  *
2865  * Context:
2866  *      Kernel context.
2867  */
2868 void
2869 qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2870 {
2871         struct qla_hw_data *ha = vha->hw;
2872
2873         fcport->vha = vha;
2874         fcport->login_retry = 0;
2875         fcport->port_login_retry_count = ha->port_down_retry_count *
2876             PORT_RETRY_TIME;
2877         atomic_set(&fcport->port_down_timer, ha->port_down_retry_count *
2878             PORT_RETRY_TIME);
2879         fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
2880
2881         qla2x00_iidma_fcport(vha, fcport);
2882
2883         atomic_set(&fcport->state, FCS_ONLINE);
2884
2885         qla2x00_reg_remote_port(vha, fcport);
2886 }
2887
2888 /*
2889  * qla2x00_configure_fabric
2890  *      Setup SNS devices with loop ID's.
2891  *
2892  * Input:
2893  *      ha = adapter block pointer.
2894  *
2895  * Returns:
2896  *      0 = success.
2897  *      BIT_0 = error
2898  */
2899 static int
2900 qla2x00_configure_fabric(scsi_qla_host_t *vha)
2901 {
2902         int     rval, rval2;
2903         fc_port_t       *fcport, *fcptemp;
2904         uint16_t        next_loopid;
2905         uint16_t        mb[MAILBOX_REGISTER_COUNT];
2906         uint16_t        loop_id;
2907         LIST_HEAD(new_fcports);
2908         struct qla_hw_data *ha = vha->hw;
2909         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2910
2911         /* If FL port exists, then SNS is present */
2912         if (IS_FWI2_CAPABLE(ha))
2913                 loop_id = NPH_F_PORT;
2914         else
2915                 loop_id = SNS_FL_PORT;
2916         rval = qla2x00_get_port_name(vha, loop_id, vha->fabric_node_name, 1);
2917         if (rval != QLA_SUCCESS) {
2918                 DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
2919                     "Port\n", vha->host_no));
2920
2921                 vha->device_flags &= ~SWITCH_FOUND;
2922                 return (QLA_SUCCESS);
2923         }
2924         vha->device_flags |= SWITCH_FOUND;
2925
2926         /* Mark devices that need re-synchronization. */
2927         rval2 = qla2x00_device_resync(vha);
2928         if (rval2 == QLA_RSCNS_HANDLED) {
2929                 /* No point doing the scan, just continue. */
2930                 return (QLA_SUCCESS);
2931         }
2932         do {
2933                 /* FDMI support. */
2934                 if (ql2xfdmienable &&
2935                     test_and_clear_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags))
2936                         qla2x00_fdmi_register(vha);
2937
2938                 /* Ensure we are logged into the SNS. */
2939                 if (IS_FWI2_CAPABLE(ha))
2940                         loop_id = NPH_SNS;
2941                 else
2942                         loop_id = SIMPLE_NAME_SERVER;
2943                 ha->isp_ops->fabric_login(vha, loop_id, 0xff, 0xff,
2944                     0xfc, mb, BIT_1 | BIT_0);
2945                 if (mb[0] != MBS_COMMAND_COMPLETE) {
2946                         DEBUG2(qla_printk(KERN_INFO, ha,
2947                             "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
2948                             "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id,
2949                             mb[0], mb[1], mb[2], mb[6], mb[7]));
2950                         return (QLA_SUCCESS);
2951                 }
2952
2953                 if (test_and_clear_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags)) {
2954                         if (qla2x00_rft_id(vha)) {
2955                                 /* EMPTY */
2956                                 DEBUG2(printk("scsi(%ld): Register FC-4 "
2957                                     "TYPE failed.\n", vha->host_no));
2958                         }
2959                         if (qla2x00_rff_id(vha)) {
2960                                 /* EMPTY */
2961                                 DEBUG2(printk("scsi(%ld): Register FC-4 "
2962                                     "Features failed.\n", vha->host_no));
2963                         }
2964                         if (qla2x00_rnn_id(vha)) {
2965                                 /* EMPTY */
2966                                 DEBUG2(printk("scsi(%ld): Register Node Name "
2967                                     "failed.\n", vha->host_no));
2968                         } else if (qla2x00_rsnn_nn(vha)) {
2969                                 /* EMPTY */
2970                                 DEBUG2(printk("scsi(%ld): Register Symbolic "
2971                                     "Node Name failed.\n", vha->host_no));
2972                         }
2973                 }
2974
2975                 rval = qla2x00_find_all_fabric_devs(vha, &new_fcports);
2976                 if (rval != QLA_SUCCESS)
2977                         break;
2978
2979                 /*
2980                  * Logout all previous fabric devices marked lost, except
2981                  * FCP2 devices.
2982                  */
2983                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2984                         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
2985                                 break;
2986
2987                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0)
2988                                 continue;
2989
2990                         if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
2991                                 qla2x00_mark_device_lost(vha, fcport,
2992                                     ql2xplogiabsentdevice, 0);
2993                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
2994                                     (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
2995                                     fcport->port_type != FCT_INITIATOR &&
2996                                     fcport->port_type != FCT_BROADCAST) {
2997                                         ha->isp_ops->fabric_logout(vha,
2998                                             fcport->loop_id,
2999                                             fcport->d_id.b.domain,
3000                                             fcport->d_id.b.area,
3001                                             fcport->d_id.b.al_pa);
3002                                         fcport->loop_id = FC_NO_LOOP_ID;
3003                                 }
3004                         }
3005                 }
3006
3007                 /* Starting free loop ID. */
3008                 next_loopid = ha->min_external_loopid;
3009
3010                 /*
3011                  * Scan through our port list and login entries that need to be
3012                  * logged in.
3013                  */
3014                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3015                         if (atomic_read(&vha->loop_down_timer) ||
3016                             test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
3017                                 break;
3018
3019                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
3020                             (fcport->flags & FCF_LOGIN_NEEDED) == 0)
3021                                 continue;
3022
3023                         if (fcport->loop_id == FC_NO_LOOP_ID) {
3024                                 fcport->loop_id = next_loopid;
3025                                 rval = qla2x00_find_new_loop_id(
3026                                     base_vha, fcport);
3027                                 if (rval != QLA_SUCCESS) {
3028                                         /* Ran out of IDs to use */
3029                                         break;
3030                                 }
3031                         }
3032                         /* Login and update database */
3033                         qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
3034                 }
3035
3036                 /* Exit if out of loop IDs. */
3037                 if (rval != QLA_SUCCESS) {
3038                         break;
3039                 }
3040
3041                 /*
3042                  * Login and add the new devices to our port list.
3043                  */
3044                 list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
3045                         if (atomic_read(&vha->loop_down_timer) ||
3046                             test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
3047                                 break;
3048
3049                         /* Find a new loop ID to use. */
3050                         fcport->loop_id = next_loopid;
3051                         rval = qla2x00_find_new_loop_id(base_vha, fcport);
3052                         if (rval != QLA_SUCCESS) {
3053                                 /* Ran out of IDs to use */
3054                                 break;
3055                         }
3056
3057                         /* Login and update database */
3058                         qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
3059
3060                         if (vha->vp_idx) {
3061                                 fcport->vha = vha;
3062                                 fcport->vp_idx = vha->vp_idx;
3063                         }
3064                         list_move_tail(&fcport->list, &vha->vp_fcports);
3065                 }
3066         } while (0);
3067
3068         /* Free all new device structures not processed. */
3069         list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
3070                 list_del(&fcport->list);
3071                 kfree(fcport);
3072         }
3073
3074         if (rval) {
3075                 DEBUG2(printk("scsi(%ld): Configure fabric error exit: "
3076                     "rval=%d\n", vha->host_no, rval));
3077         }
3078
3079         return (rval);
3080 }
3081
3082 /*
3083  * qla2x00_find_all_fabric_devs
3084  *
3085  * Input:
3086  *      ha = adapter block pointer.
3087  *      dev = database device entry pointer.
3088  *
3089  * Returns:
3090  *      0 = success.
3091  *
3092  * Context:
3093  *      Kernel context.
3094  */
3095 static int
3096 qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
3097         struct list_head *new_fcports)
3098 {
3099         int             rval;
3100         uint16_t        loop_id;
3101         fc_port_t       *fcport, *new_fcport, *fcptemp;
3102         int             found;
3103
3104         sw_info_t       *swl;
3105         int             swl_idx;
3106         int             first_dev, last_dev;
3107         port_id_t       wrap = {}, nxt_d_id;
3108         struct qla_hw_data *ha = vha->hw;
3109         struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
3110         struct scsi_qla_host *tvp;
3111
3112         rval = QLA_SUCCESS;
3113
3114         /* Try GID_PT to get device list, else GAN. */
3115         swl = kcalloc(MAX_FIBRE_DEVICES, sizeof(sw_info_t), GFP_KERNEL);
3116         if (!swl) {
3117                 /*EMPTY*/
3118                 DEBUG2(printk("scsi(%ld): GID_PT allocations failed, fallback "
3119                     "on GA_NXT\n", vha->host_no));
3120         } else {
3121                 if (qla2x00_gid_pt(vha, swl) != QLA_SUCCESS) {
3122                         kfree(swl);
3123                         swl = NULL;
3124                 } else if (qla2x00_gpn_id(vha, swl) != QLA_SUCCESS) {
3125                         kfree(swl);
3126                         swl = NULL;
3127                 } else if (qla2x00_gnn_id(vha, swl) != QLA_SUCCESS) {
3128                         kfree(swl);
3129                         swl = NULL;
3130                 } else if (ql2xiidmaenable &&
3131                     qla2x00_gfpn_id(vha, swl) == QLA_SUCCESS) {
3132                         qla2x00_gpsc(vha, swl);
3133                 }
3134
3135                 /* If other queries succeeded probe for FC-4 type */
3136                 if (swl)
3137                         qla2x00_gff_id(vha, swl);
3138         }
3139         swl_idx = 0;
3140
3141         /* Allocate temporary fcport for any new fcports discovered. */
3142         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
3143         if (new_fcport == NULL) {
3144                 kfree(swl);
3145                 return (QLA_MEMORY_ALLOC_FAILED);
3146         }
3147         new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
3148         /* Set start port ID scan at adapter ID. */
3149         first_dev = 1;
3150         last_dev = 0;
3151
3152         /* Starting free loop ID. */
3153         loop_id = ha->min_external_loopid;
3154         for (; loop_id <= ha->max_loop_id; loop_id++) {
3155                 if (qla2x00_is_reserved_id(vha, loop_id))
3156                         continue;
3157
3158                 if (ha->current_topology == ISP_CFG_FL &&
3159                     (atomic_read(&vha->loop_down_timer) ||
3160                      LOOP_TRANSITION(vha))) {
3161                         atomic_set(&vha->loop_down_timer, 0);
3162                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3163                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3164                         break;
3165                 }
3166
3167                 if (swl != NULL) {
3168                         if (last_dev) {
3169                                 wrap.b24 = new_fcport->d_id.b24;
3170                         } else {
3171                                 new_fcport->d_id.b24 = swl[swl_idx].d_id.b24;
3172                                 memcpy(new_fcport->node_name,
3173                                     swl[swl_idx].node_name, WWN_SIZE);
3174                                 memcpy(new_fcport->port_name,
3175                                     swl[swl_idx].port_name, WWN_SIZE);
3176                                 memcpy(new_fcport->fabric_port_name,
3177                                     swl[swl_idx].fabric_port_name, WWN_SIZE);
3178                                 new_fcport->fp_speed = swl[swl_idx].fp_speed;
3179                                 new_fcport->fc4_type = swl[swl_idx].fc4_type;
3180
3181                                 if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
3182                                         last_dev = 1;
3183                                 }
3184                                 swl_idx++;
3185                         }
3186                 } else {
3187                         /* Send GA_NXT to the switch */
3188                         rval = qla2x00_ga_nxt(vha, new_fcport);
3189                         if (rval != QLA_SUCCESS) {
3190                                 qla_printk(KERN_WARNING, ha,
3191                                     "SNS scan failed -- assuming zero-entry "
3192                                     "result...\n");
3193                                 list_for_each_entry_safe(fcport, fcptemp,
3194                                     new_fcports, list) {
3195                                         list_del(&fcport->list);
3196                                         kfree(fcport);
3197                                 }
3198                                 rval = QLA_SUCCESS;
3199                                 break;
3200                         }
3201                 }
3202
3203                 /* If wrap on switch device list, exit. */
3204                 if (first_dev) {
3205                         wrap.b24 = new_fcport->d_id.b24;
3206                         first_dev = 0;
3207                 } else if (new_fcport->d_id.b24 == wrap.b24) {
3208                         DEBUG2(printk("scsi(%ld): device wrap (%02x%02x%02x)\n",
3209                             vha->host_no, new_fcport->d_id.b.domain,
3210                             new_fcport->d_id.b.area, new_fcport->d_id.b.al_pa));
3211                         break;
3212                 }
3213
3214                 /* Bypass if same physical adapter. */
3215                 if (new_fcport->d_id.b24 == base_vha->d_id.b24)
3216                         continue;
3217
3218                 /* Bypass virtual ports of the same host. */
3219                 found = 0;
3220                 if (ha->num_vhosts) {
3221                         list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3222                                 if (new_fcport->d_id.b24 == vp->d_id.b24) {
3223                                         found = 1;
3224                                         break;
3225                                 }
3226                         }
3227                         if (found)
3228                                 continue;
3229                 }
3230
3231                 /* Bypass if same domain and area of adapter. */
3232                 if (((new_fcport->d_id.b24 & 0xffff00) ==
3233                     (vha->d_id.b24 & 0xffff00)) && ha->current_topology ==
3234                         ISP_CFG_FL)
3235                             continue;
3236
3237                 /* Bypass reserved domain fields. */
3238                 if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
3239                         continue;
3240
3241                 /* Bypass ports whose FCP-4 type is not FCP_SCSI */
3242                 if (new_fcport->fc4_type != FC4_TYPE_FCP_SCSI &&
3243                     new_fcport->fc4_type != FC4_TYPE_UNKNOWN)
3244                         continue;
3245
3246                 /* Locate matching device in database. */
3247                 found = 0;
3248                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3249                         if (memcmp(new_fcport->port_name, fcport->port_name,
3250                             WWN_SIZE))
3251                                 continue;
3252
3253                         found++;
3254
3255                         /* Update port state. */
3256                         memcpy(fcport->fabric_port_name,
3257                             new_fcport->fabric_port_name, WWN_SIZE);
3258                         fcport->fp_speed = new_fcport->fp_speed;
3259
3260                         /*
3261                          * If address the same and state FCS_ONLINE, nothing
3262                          * changed.
3263                          */
3264                         if (fcport->d_id.b24 == new_fcport->d_id.b24 &&
3265                             atomic_read(&fcport->state) == FCS_ONLINE) {
3266                                 break;
3267                         }
3268
3269                         /*
3270                          * If device was not a fabric device before.
3271                          */
3272                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3273                                 fcport->d_id.b24 = new_fcport->d_id.b24;
3274                                 fcport->loop_id = FC_NO_LOOP_ID;
3275                                 fcport->flags |= (FCF_FABRIC_DEVICE |
3276                                     FCF_LOGIN_NEEDED);
3277                                 break;
3278                         }
3279
3280                         /*
3281                          * Port ID changed or device was marked to be updated;
3282                          * Log it out if still logged in and mark it for
3283                          * relogin later.
3284                          */
3285                         fcport->d_id.b24 = new_fcport->d_id.b24;
3286                         fcport->flags |= FCF_LOGIN_NEEDED;
3287                         if (fcport->loop_id != FC_NO_LOOP_ID &&
3288                             (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
3289                             fcport->port_type != FCT_INITIATOR &&
3290                             fcport->port_type != FCT_BROADCAST) {
3291                                 ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3292                                     fcport->d_id.b.domain, fcport->d_id.b.area,
3293                                     fcport->d_id.b.al_pa);
3294                                 fcport->loop_id = FC_NO_LOOP_ID;
3295                         }
3296
3297                         break;
3298                 }
3299
3300                 if (found)
3301                         continue;
3302                 /* If device was not in our fcports list, then add it. */
3303                 list_add_tail(&new_fcport->list, new_fcports);
3304
3305                 /* Allocate a new replacement fcport. */
3306                 nxt_d_id.b24 = new_fcport->d_id.b24;
3307                 new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
3308                 if (new_fcport == NULL) {
3309                         kfree(swl);
3310                         return (QLA_MEMORY_ALLOC_FAILED);
3311                 }
3312                 new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
3313                 new_fcport->d_id.b24 = nxt_d_id.b24;
3314         }
3315
3316         kfree(swl);
3317         kfree(new_fcport);
3318
3319         return (rval);
3320 }
3321
3322 /*
3323  * qla2x00_find_new_loop_id
3324  *      Scan through our port list and find a new usable loop ID.
3325  *
3326  * Input:
3327  *      ha:     adapter state pointer.
3328  *      dev:    port structure pointer.
3329  *
3330  * Returns:
3331  *      qla2x00 local function return status code.
3332  *
3333  * Context:
3334  *      Kernel context.
3335  */
3336 static int
3337 qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
3338 {
3339         int     rval;
3340         int     found;
3341         fc_port_t *fcport;
3342         uint16_t first_loop_id;
3343         struct qla_hw_data *ha = vha->hw;
3344         struct scsi_qla_host *vp;
3345         struct scsi_qla_host *tvp;
3346
3347         rval = QLA_SUCCESS;
3348
3349         /* Save starting loop ID. */
3350         first_loop_id = dev->loop_id;
3351
3352         for (;;) {
3353                 /* Skip loop ID if already used by adapter. */
3354                 if (dev->loop_id == vha->loop_id)
3355                         dev->loop_id++;
3356
3357                 /* Skip reserved loop IDs. */
3358                 while (qla2x00_is_reserved_id(vha, dev->loop_id))
3359                         dev->loop_id++;
3360
3361                 /* Reset loop ID if passed the end. */
3362                 if (dev->loop_id > ha->max_loop_id) {
3363                         /* first loop ID. */
3364                         dev->loop_id = ha->min_external_loopid;
3365                 }
3366
3367                 /* Check for loop ID being already in use. */
3368                 found = 0;
3369                 fcport = NULL;
3370                 list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3371                         list_for_each_entry(fcport, &vp->vp_fcports, list) {
3372                                 if (fcport->loop_id == dev->loop_id &&
3373                                                                 fcport != dev) {
3374                                         /* ID possibly in use */
3375                                         found++;
3376                                         break;
3377                                 }
3378                         }
3379                         if (found)
3380                                 break;
3381                 }
3382
3383                 /* If not in use then it is free to use. */
3384                 if (!found) {
3385                         break;
3386                 }
3387
3388                 /* ID in use. Try next value. */
3389                 dev->loop_id++;
3390
3391                 /* If wrap around. No free ID to use. */
3392                 if (dev->loop_id == first_loop_id) {
3393                         dev->loop_id = FC_NO_LOOP_ID;
3394                         rval = QLA_FUNCTION_FAILED;
3395                         break;
3396                 }
3397         }
3398
3399         return (rval);
3400 }
3401
3402 /*
3403  * qla2x00_device_resync
3404  *      Marks devices in the database that needs resynchronization.
3405  *
3406  * Input:
3407  *      ha = adapter block pointer.
3408  *
3409  * Context:
3410  *      Kernel context.
3411  */
3412 static int
3413 qla2x00_device_resync(scsi_qla_host_t *vha)
3414 {
3415         int     rval;
3416         uint32_t mask;
3417         fc_port_t *fcport;
3418         uint32_t rscn_entry;
3419         uint8_t rscn_out_iter;
3420         uint8_t format;
3421         port_id_t d_id = {};
3422
3423         rval = QLA_RSCNS_HANDLED;
3424
3425         while (vha->rscn_out_ptr != vha->rscn_in_ptr ||
3426             vha->flags.rscn_queue_overflow) {
3427
3428                 rscn_entry = vha->rscn_queue[vha->rscn_out_ptr];
3429                 format = MSB(MSW(rscn_entry));
3430                 d_id.b.domain = LSB(MSW(rscn_entry));
3431                 d_id.b.area = MSB(LSW(rscn_entry));
3432                 d_id.b.al_pa = LSB(LSW(rscn_entry));
3433
3434                 DEBUG(printk("scsi(%ld): RSCN queue entry[%d] = "
3435                     "[%02x/%02x%02x%02x].\n",
3436                     vha->host_no, vha->rscn_out_ptr, format, d_id.b.domain,
3437                     d_id.b.area, d_id.b.al_pa));
3438
3439                 vha->rscn_out_ptr++;
3440                 if (vha->rscn_out_ptr == MAX_RSCN_COUNT)
3441                         vha->rscn_out_ptr = 0;
3442
3443                 /* Skip duplicate entries. */
3444                 for (rscn_out_iter = vha->rscn_out_ptr;
3445                     !vha->flags.rscn_queue_overflow &&
3446                     rscn_out_iter != vha->rscn_in_ptr;
3447                     rscn_out_iter = (rscn_out_iter ==
3448                         (MAX_RSCN_COUNT - 1)) ? 0: rscn_out_iter + 1) {
3449
3450                         if (rscn_entry != vha->rscn_queue[rscn_out_iter])
3451                                 break;
3452
3453                         DEBUG(printk("scsi(%ld): Skipping duplicate RSCN queue "
3454                             "entry found at [%d].\n", vha->host_no,
3455                             rscn_out_iter));
3456
3457                         vha->rscn_out_ptr = rscn_out_iter;
3458                 }
3459
3460                 /* Queue overflow, set switch default case. */
3461                 if (vha->flags.rscn_queue_overflow) {
3462                         DEBUG(printk("scsi(%ld): device_resync: rscn "
3463                             "overflow.\n", vha->host_no));
3464
3465                         format = 3;
3466                         vha->flags.rscn_queue_overflow = 0;
3467                 }
3468
3469                 switch (format) {
3470                 case 0:
3471                         mask = 0xffffff;
3472                         break;
3473                 case 1:
3474                         mask = 0xffff00;
3475                         break;
3476                 case 2:
3477                         mask = 0xff0000;
3478                         break;
3479                 default:
3480                         mask = 0x0;
3481                         d_id.b24 = 0;
3482                         vha->rscn_out_ptr = vha->rscn_in_ptr;
3483                         break;
3484                 }
3485
3486                 rval = QLA_SUCCESS;
3487
3488                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3489                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
3490                             (fcport->d_id.b24 & mask) != d_id.b24 ||
3491                             fcport->port_type == FCT_BROADCAST)
3492                                 continue;
3493
3494                         if (atomic_read(&fcport->state) == FCS_ONLINE) {
3495                                 if (format != 3 ||
3496                                     fcport->port_type != FCT_INITIATOR) {
3497                                         qla2x00_mark_device_lost(vha, fcport,
3498                                             0, 0);
3499                                 }
3500                         }
3501                 }
3502         }
3503         return (rval);
3504 }
3505
3506 /*
3507  * qla2x00_fabric_dev_login
3508  *      Login fabric target device and update FC port database.
3509  *
3510  * Input:
3511  *      ha:             adapter state pointer.
3512  *      fcport:         port structure list pointer.
3513  *      next_loopid:    contains value of a new loop ID that can be used
3514  *                      by the next login attempt.
3515  *
3516  * Returns:
3517  *      qla2x00 local function return status code.
3518  *
3519  * Context:
3520  *      Kernel context.
3521  */
3522 static int
3523 qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
3524     uint16_t *next_loopid)
3525 {
3526         int     rval;
3527         int     retry;
3528         uint8_t opts;
3529         struct qla_hw_data *ha = vha->hw;
3530
3531         rval = QLA_SUCCESS;
3532         retry = 0;
3533
3534         if (IS_ALOGIO_CAPABLE(ha)) {
3535                 if (fcport->flags & FCF_ASYNC_SENT)
3536                         return rval;
3537                 fcport->flags |= FCF_ASYNC_SENT;
3538                 rval = qla2x00_post_async_login_work(vha, fcport, NULL);
3539                 if (!rval)
3540                         return rval;
3541         }
3542
3543         fcport->flags &= ~FCF_ASYNC_SENT;
3544         rval = qla2x00_fabric_login(vha, fcport, next_loopid);
3545         if (rval == QLA_SUCCESS) {
3546                 /* Send an ADISC to FCP2 devices.*/
3547                 opts = 0;
3548                 if (fcport->flags & FCF_FCP2_DEVICE)
3549                         opts |= BIT_1;
3550                 rval = qla2x00_get_port_database(vha, fcport, opts);
3551                 if (rval != QLA_SUCCESS) {
3552                         ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3553                             fcport->d_id.b.domain, fcport->d_id.b.area,
3554                             fcport->d_id.b.al_pa);
3555                         qla2x00_mark_device_lost(vha, fcport, 1, 0);
3556                 } else {
3557                         qla2x00_update_fcport(vha, fcport);
3558                 }
3559         }
3560
3561         return (rval);
3562 }
3563
3564 /*
3565  * qla2x00_fabric_login
3566  *      Issue fabric login command.
3567  *
3568  * Input:
3569  *      ha = adapter block pointer.
3570  *      device = pointer to FC device type structure.
3571  *
3572  * Returns:
3573  *      0 - Login successfully
3574  *      1 - Login failed
3575  *      2 - Initiator device
3576  *      3 - Fatal error
3577  */
3578 int
3579 qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
3580     uint16_t *next_loopid)
3581 {
3582         int     rval;
3583         int     retry;
3584         uint16_t tmp_loopid;
3585         uint16_t mb[MAILBOX_REGISTER_COUNT];
3586         struct qla_hw_data *ha = vha->hw;
3587
3588         retry = 0;
3589         tmp_loopid = 0;
3590
3591         for (;;) {
3592                 DEBUG(printk("scsi(%ld): Trying Fabric Login w/loop id 0x%04x "
3593                     "for port %02x%02x%02x.\n",
3594                     vha->host_no, fcport->loop_id, fcport->d_id.b.domain,
3595                     fcport->d_id.b.area, fcport->d_id.b.al_pa));
3596
3597                 /* Login fcport on switch. */
3598                 ha->isp_ops->fabric_login(vha, fcport->loop_id,
3599                     fcport->d_id.b.domain, fcport->d_id.b.area,
3600                     fcport->d_id.b.al_pa, mb, BIT_0);
3601                 if (mb[0] == MBS_PORT_ID_USED) {
3602                         /*
3603                          * Device has another loop ID.  The firmware team
3604                          * recommends the driver perform an implicit login with
3605                          * the specified ID again. The ID we just used is save
3606                          * here so we return with an ID that can be tried by
3607                          * the next login.
3608                          */
3609                         retry++;
3610                         tmp_loopid = fcport->loop_id;
3611                         fcport->loop_id = mb[1];
3612
3613                         DEBUG(printk("Fabric Login: port in use - next "
3614                             "loop id=0x%04x, port Id=%02x%02x%02x.\n",
3615                             fcport->loop_id, fcport->d_id.b.domain,
3616                             fcport->d_id.b.area, fcport->d_id.b.al_pa));
3617
3618                 } else if (mb[0] == MBS_COMMAND_COMPLETE) {
3619                         /*
3620                          * Login succeeded.
3621                          */
3622                         if (retry) {
3623                                 /* A retry occurred before. */
3624                                 *next_loopid = tmp_loopid;
3625                         } else {
3626                                 /*
3627                                  * No retry occurred before. Just increment the
3628                                  * ID value for next login.
3629                                  */
3630                                 *next_loopid = (fcport->loop_id + 1);
3631                         }
3632
3633                         if (mb[1] & BIT_0) {
3634                                 fcport->port_type = FCT_INITIATOR;
3635                         } else {
3636                                 fcport->port_type = FCT_TARGET;
3637                                 if (mb[1] & BIT_1) {
3638                                         fcport->flags |= FCF_FCP2_DEVICE;
3639                                 }
3640                         }
3641
3642                         if (mb[10] & BIT_0)
3643                                 fcport->supported_classes |= FC_COS_CLASS2;
3644                         if (mb[10] & BIT_1)
3645                                 fcport->supported_classes |= FC_COS_CLASS3;
3646
3647                         rval = QLA_SUCCESS;
3648                         break;
3649                 } else if (mb[0] == MBS_LOOP_ID_USED) {
3650                         /*
3651                          * Loop ID already used, try next loop ID.
3652                          */
3653                         fcport->loop_id++;
3654                         rval = qla2x00_find_new_loop_id(vha, fcport);
3655                         if (rval != QLA_SUCCESS) {
3656                                 /* Ran out of loop IDs to use */
3657                                 break;
3658                         }
3659                 } else if (mb[0] == MBS_COMMAND_ERROR) {
3660                         /*
3661                          * Firmware possibly timed out during login. If NO
3662                          * retries are left to do then the device is declared
3663                          * dead.
3664                          */
3665                         *next_loopid = fcport->loop_id;
3666                         ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3667                             fcport->d_id.b.domain, fcport->d_id.b.area,
3668                             fcport->d_id.b.al_pa);
3669                         qla2x00_mark_device_lost(vha, fcport, 1, 0);
3670
3671                         rval = 1;
3672                         break;
3673                 } else {
3674                         /*
3675                          * unrecoverable / not handled error
3676                          */
3677                         DEBUG2(printk("%s(%ld): failed=%x port_id=%02x%02x%02x "
3678                             "loop_id=%x jiffies=%lx.\n",
3679                             __func__, vha->host_no, mb[0],
3680                             fcport->d_id.b.domain, fcport->d_id.b.area,
3681                             fcport->d_id.b.al_pa, fcport->loop_id, jiffies));
3682
3683                         *next_loopid = fcport->loop_id;
3684                         ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3685                             fcport->d_id.b.domain, fcport->d_id.b.area,
3686                             fcport->d_id.b.al_pa);
3687                         fcport->loop_id = FC_NO_LOOP_ID;
3688                         fcport->login_retry = 0;
3689
3690                         rval = 3;
3691                         break;
3692                 }
3693         }
3694
3695         return (rval);
3696 }
3697
3698 /*
3699  * qla2x00_local_device_login
3700  *      Issue local device login command.
3701  *
3702  * Input:
3703  *      ha = adapter block pointer.
3704  *      loop_id = loop id of device to login to.
3705  *
3706  * Returns (Where's the #define!!!!):
3707  *      0 - Login successfully
3708  *      1 - Login failed
3709  *      3 - Fatal error
3710  */
3711 int
3712 qla2x00_local_device_login(scsi_qla_host_t *vha, fc_port_t *fcport)
3713 {
3714         int             rval;
3715         uint16_t        mb[MAILBOX_REGISTER_COUNT];
3716
3717         memset(mb, 0, sizeof(mb));
3718         rval = qla2x00_login_local_device(vha, fcport, mb, BIT_0);
3719         if (rval == QLA_SUCCESS) {
3720                 /* Interrogate mailbox registers for any errors */
3721                 if (mb[0] == MBS_COMMAND_ERROR)
3722                         rval = 1;
3723                 else if (mb[0] == MBS_COMMAND_PARAMETER_ERROR)
3724                         /* device not in PCB table */
3725                         rval = 3;
3726         }
3727
3728         return (rval);
3729 }
3730
3731 /*
3732  *  qla2x00_loop_resync
3733  *      Resync with fibre channel devices.
3734  *
3735  * Input:
3736  *      ha = adapter block pointer.
3737  *
3738  * Returns:
3739  *      0 = success
3740  */
3741 int
3742 qla2x00_loop_resync(scsi_qla_host_t *vha)
3743 {
3744         int rval = QLA_SUCCESS;
3745         uint32_t wait_time;
3746         struct req_que *req;
3747         struct rsp_que *rsp;
3748
3749         if (vha->hw->flags.cpu_affinity_enabled)
3750                 req = vha->hw->req_q_map[0];
3751         else
3752                 req = vha->req;
3753         rsp = req->rsp;
3754
3755         atomic_set(&vha->loop_state, LOOP_UPDATE);
3756         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
3757         if (vha->flags.online) {
3758                 if (!(rval = qla2x00_fw_ready(vha))) {
3759                         /* Wait at most MAX_TARGET RSCNs for a stable link. */
3760                         wait_time = 256;
3761                         do {
3762                                 atomic_set(&vha->loop_state, LOOP_UPDATE);
3763
3764                                 /* Issue a marker after FW becomes ready. */
3765                                 qla2x00_marker(vha, req, rsp, 0, 0,
3766                                         MK_SYNC_ALL);
3767                                 vha->marker_needed = 0;
3768
3769                                 /* Remap devices on Loop. */
3770                                 clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3771
3772                                 qla2x00_configure_loop(vha);
3773                                 wait_time--;
3774                         } while (!atomic_read(&vha->loop_down_timer) &&
3775                                 !(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
3776                                 && wait_time && (test_bit(LOOP_RESYNC_NEEDED,
3777                                 &vha->dpc_flags)));
3778                 }
3779         }
3780
3781         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
3782                 return (QLA_FUNCTION_FAILED);
3783
3784         if (rval)
3785                 DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
3786
3787         return (rval);
3788 }
3789
3790 void
3791 qla2x00_update_fcports(scsi_qla_host_t *base_vha)
3792 {
3793         fc_port_t *fcport;
3794         struct scsi_qla_host *tvp, *vha;
3795
3796         /* Go with deferred removal of rport references. */
3797         list_for_each_entry_safe(vha, tvp, &base_vha->hw->vp_list, list)
3798                 list_for_each_entry(fcport, &vha->vp_fcports, list)
3799                         if (fcport && fcport->drport &&
3800                             atomic_read(&fcport->state) != FCS_UNCONFIGURED)
3801                                 qla2x00_rport_del(fcport);
3802 }
3803
3804 void
3805 qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
3806 {
3807         struct qla_hw_data *ha = vha->hw;
3808         struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
3809         struct scsi_qla_host *tvp;
3810
3811         vha->flags.online = 0;
3812         ha->flags.chip_reset_done = 0;
3813         clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3814         ha->qla_stats.total_isp_aborts++;
3815
3816         qla_printk(KERN_INFO, ha,
3817             "Performing ISP error recovery - ha= %p.\n", ha);
3818
3819         /* Chip reset does not apply to 82XX */
3820         if (!IS_QLA82XX(ha))
3821                 ha->isp_ops->reset_chip(vha);
3822
3823         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
3824         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
3825                 atomic_set(&vha->loop_state, LOOP_DOWN);
3826                 qla2x00_mark_all_devices_lost(vha, 0);
3827                 list_for_each_entry_safe(vp, tvp, &base_vha->hw->vp_list, list)
3828                         qla2x00_mark_all_devices_lost(vp, 0);
3829         } else {
3830                 if (!atomic_read(&vha->loop_down_timer))
3831                         atomic_set(&vha->loop_down_timer,
3832                             LOOP_DOWN_TIME);
3833         }
3834
3835         /* Make sure for ISP 82XX IO DMA is complete */
3836         if (IS_QLA82XX(ha)) {
3837                 if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0,
3838                         WAIT_HOST) == QLA_SUCCESS) {
3839                         DEBUG2(qla_printk(KERN_INFO, ha,
3840                         "Done wait for pending commands\n"));
3841                 }
3842         }
3843
3844         /* Requeue all commands in outstanding command list. */
3845         qla2x00_abort_all_cmds(vha, DID_RESET << 16);
3846 }
3847
3848 /*
3849 *  qla2x00_abort_isp
3850 *      Resets ISP and aborts all outstanding commands.
3851 *
3852 * Input:
3853 *      ha           = adapter block pointer.
3854 *
3855 * Returns:
3856 *      0 = success
3857 */
3858 int
3859 qla2x00_abort_isp(scsi_qla_host_t *vha)
3860 {
3861         int rval;
3862         uint8_t        status = 0;
3863         struct qla_hw_data *ha = vha->hw;
3864         struct scsi_qla_host *vp;
3865         struct scsi_qla_host *tvp;
3866         struct req_que *req = ha->req_q_map[0];
3867
3868         if (vha->flags.online) {
3869                 qla2x00_abort_isp_cleanup(vha);
3870
3871                 if (unlikely(pci_channel_offline(ha->pdev) &&
3872                     ha->flags.pci_channel_io_perm_failure)) {
3873                         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
3874                         status = 0;
3875                         return status;
3876                 }
3877
3878                 ha->isp_ops->get_flash_version(vha, req->ring);
3879
3880                 ha->isp_ops->nvram_config(vha);
3881
3882                 if (!qla2x00_restart_isp(vha)) {
3883                         clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
3884
3885                         if (!atomic_read(&vha->loop_down_timer)) {
3886                                 /*
3887                                  * Issue marker command only when we are going
3888                                  * to start the I/O .
3889                                  */
3890                                 vha->marker_needed = 1;
3891                         }
3892
3893                         vha->flags.online = 1;
3894
3895                         ha->isp_ops->enable_intrs(ha);
3896
3897                         ha->isp_abort_cnt = 0;
3898                         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
3899
3900                         if (IS_QLA81XX(ha))
3901                                 qla2x00_get_fw_version(vha,
3902                                     &ha->fw_major_version,
3903                                     &ha->fw_minor_version,
3904                                     &ha->fw_subminor_version,
3905                                     &ha->fw_attributes, &ha->fw_memory_size,
3906                                     ha->mpi_version, &ha->mpi_capabilities,
3907                                     ha->phy_version);
3908
3909                         if (ha->fce) {
3910                                 ha->flags.fce_enabled = 1;
3911                                 memset(ha->fce, 0,
3912                                     fce_calc_size(ha->fce_bufs));
3913                                 rval = qla2x00_enable_fce_trace(vha,
3914                                     ha->fce_dma, ha->fce_bufs, ha->fce_mb,
3915                                     &ha->fce_bufs);
3916                                 if (rval) {
3917                                         qla_printk(KERN_WARNING, ha,
3918                                             "Unable to reinitialize FCE "
3919                                             "(%d).\n", rval);
3920                                         ha->flags.fce_enabled = 0;
3921                                 }
3922                         }
3923
3924                         if (ha->eft) {
3925                                 memset(ha->eft, 0, EFT_SIZE);
3926                                 rval = qla2x00_enable_eft_trace(vha,
3927                                     ha->eft_dma, EFT_NUM_BUFFERS);
3928                                 if (rval) {
3929                                         qla_printk(KERN_WARNING, ha,
3930                                             "Unable to reinitialize EFT "
3931                                             "(%d).\n", rval);
3932                                 }
3933                         }
3934                 } else {        /* failed the ISP abort */
3935                         vha->flags.online = 1;
3936                         if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
3937                                 if (ha->isp_abort_cnt == 0) {
3938                                         qla_printk(KERN_WARNING, ha,
3939                                             "ISP error recovery failed - "
3940                                             "board disabled\n");
3941                                         /*
3942                                          * The next call disables the board
3943                                          * completely.
3944                                          */
3945                                         ha->isp_ops->reset_adapter(vha);
3946                                         vha->flags.online = 0;
3947                                         clear_bit(ISP_ABORT_RETRY,
3948                                             &vha->dpc_flags);
3949                                         status = 0;
3950                                 } else { /* schedule another ISP abort */
3951                                         ha->isp_abort_cnt--;
3952                                         DEBUG(printk("qla%ld: ISP abort - "
3953                                             "retry remaining %d\n",
3954                                             vha->host_no, ha->isp_abort_cnt));
3955                                         status = 1;
3956                                 }
3957                         } else {
3958                                 ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
3959                                 DEBUG(printk("qla2x00(%ld): ISP error recovery "
3960                                     "- retrying (%d) more times\n",
3961                                     vha->host_no, ha->isp_abort_cnt));
3962                                 set_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
3963                                 status = 1;
3964                         }
3965                 }
3966
3967         }
3968
3969         if (!status) {
3970                 DEBUG(printk(KERN_INFO
3971                                 "qla2x00_abort_isp(%ld): succeeded.\n",
3972                                 vha->host_no));
3973                 list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3974                         if (vp->vp_idx)
3975                                 qla2x00_vp_abort_isp(vp);
3976                 }
3977         } else {
3978                 qla_printk(KERN_INFO, ha,
3979                         "qla2x00_abort_isp: **** FAILED ****\n");
3980         }
3981
3982         return(status);
3983 }
3984
3985 /*
3986 *  qla2x00_restart_isp
3987 *      restarts the ISP after a reset
3988 *
3989 * Input:
3990 *      ha = adapter block pointer.
3991 *
3992 * Returns:
3993 *      0 = success
3994 */
3995 static int
3996 qla2x00_restart_isp(scsi_qla_host_t *vha)
3997 {
3998         int status = 0;
3999         uint32_t wait_time;
4000         struct qla_hw_data *ha = vha->hw;
4001         struct req_que *req = ha->req_q_map[0];
4002         struct rsp_que *rsp = ha->rsp_q_map[0];
4003
4004         /* If firmware needs to be loaded */
4005         if (qla2x00_isp_firmware(vha)) {
4006                 vha->flags.online = 0;
4007                 status = ha->isp_ops->chip_diag(vha);
4008                 if (!status)
4009                         status = qla2x00_setup_chip(vha);
4010         }
4011
4012         if (!status && !(status = qla2x00_init_rings(vha))) {
4013                 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
4014                 ha->flags.chip_reset_done = 1;
4015                 /* Initialize the queues in use */
4016                 qla25xx_init_queues(ha);
4017
4018                 status = qla2x00_fw_ready(vha);
4019                 if (!status) {
4020                         DEBUG(printk("%s(): Start configure loop, "
4021                             "status = %d\n", __func__, status));
4022
4023                         /* Issue a marker after FW becomes ready. */
4024                         qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
4025
4026                         vha->flags.online = 1;
4027                         /* Wait at most MAX_TARGET RSCNs for a stable link. */
4028                         wait_time = 256;
4029                         do {
4030                                 clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4031                                 qla2x00_configure_loop(vha);
4032                                 wait_time--;
4033                         } while (!atomic_read(&vha->loop_down_timer) &&
4034                                 !(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
4035                                 && wait_time && (test_bit(LOOP_RESYNC_NEEDED,
4036                                 &vha->dpc_flags)));
4037                 }
4038
4039                 /* if no cable then assume it's good */
4040                 if ((vha->device_flags & DFLG_NO_CABLE))
4041                         status = 0;
4042
4043                 DEBUG(printk("%s(): Configure loop done, status = 0x%x\n",
4044                                 __func__,
4045                                 status));
4046         }
4047         return (status);
4048 }
4049
4050 static int
4051 qla25xx_init_queues(struct qla_hw_data *ha)
4052 {
4053         struct rsp_que *rsp = NULL;
4054         struct req_que *req = NULL;
4055         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
4056         int ret = -1;
4057         int i;
4058
4059         for (i = 1; i < ha->max_rsp_queues; i++) {
4060                 rsp = ha->rsp_q_map[i];
4061                 if (rsp) {
4062                         rsp->options &= ~BIT_0;
4063                         ret = qla25xx_init_rsp_que(base_vha, rsp);
4064                         if (ret != QLA_SUCCESS)
4065                                 DEBUG2_17(printk(KERN_WARNING
4066                                         "%s Rsp que:%d init failed\n", __func__,
4067                                                 rsp->id));
4068                         else
4069                                 DEBUG2_17(printk(KERN_INFO
4070                                         "%s Rsp que:%d inited\n", __func__,
4071                                                 rsp->id));
4072                 }
4073         }
4074         for (i = 1; i < ha->max_req_queues; i++) {
4075                 req = ha->req_q_map[i];
4076                 if (req) {
4077                 /* Clear outstanding commands array. */
4078                         req->options &= ~BIT_0;
4079                         ret = qla25xx_init_req_que(base_vha, req);
4080                         if (ret != QLA_SUCCESS)
4081                                 DEBUG2_17(printk(KERN_WARNING
4082                                         "%s Req que:%d init failed\n", __func__,
4083                                                 req->id));
4084                         else
4085                                 DEBUG2_17(printk(KERN_WARNING
4086                                         "%s Req que:%d inited\n", __func__,
4087                                                 req->id));
4088                 }
4089         }
4090         return ret;
4091 }
4092
4093 /*
4094 * qla2x00_reset_adapter
4095 *      Reset adapter.
4096 *
4097 * Input:
4098 *      ha = adapter block pointer.
4099 */
4100 void
4101 qla2x00_reset_adapter(scsi_qla_host_t *vha)
4102 {
4103         unsigned long flags = 0;
4104         struct qla_hw_data *ha = vha->hw;
4105         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
4106
4107         vha->flags.online = 0;
4108         ha->isp_ops->disable_intrs(ha);
4109
4110         spin_lock_irqsave(&ha->hardware_lock, flags);
4111         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
4112         RD_REG_WORD(&reg->hccr);                        /* PCI Posting. */
4113         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
4114         RD_REG_WORD(&reg->hccr);                        /* PCI Posting. */
4115         spin_unlock_irqrestore(&ha->hardware_lock, flags);
4116 }
4117
4118 void
4119 qla24xx_reset_adapter(scsi_qla_host_t *vha)
4120 {
4121         unsigned long flags = 0;
4122         struct qla_hw_data *ha = vha->hw;
4123         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
4124
4125         if (IS_QLA82XX(ha))
4126                 return;
4127
4128         vha->flags.online = 0;
4129         ha->isp_ops->disable_intrs(ha);
4130
4131         spin_lock_irqsave(&ha->hardware_lock, flags);
4132         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
4133         RD_REG_DWORD(&reg->hccr);
4134         WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
4135         RD_REG_DWORD(&reg->hccr);
4136         spin_unlock_irqrestore(&ha->hardware_lock, flags);
4137
4138         if (IS_NOPOLLING_TYPE(ha))
4139                 ha->isp_ops->enable_intrs(ha);
4140 }
4141
4142 /* On sparc systems, obtain port and node WWN from firmware
4143  * properties.
4144  */
4145 static void qla24xx_nvram_wwn_from_ofw(scsi_qla_host_t *vha,
4146         struct nvram_24xx *nv)
4147 {
4148 #ifdef CONFIG_SPARC
4149         struct qla_hw_data *ha = vha->hw;
4150         struct pci_dev *pdev = ha->pdev;
4151         struct device_node *dp = pci_device_to_OF_node(pdev);
4152         const u8 *val;
4153         int len;
4154
4155         val = of_get_property(dp, "port-wwn", &len);
4156         if (val && len >= WWN_SIZE)
4157                 memcpy(nv->port_name, val, WWN_SIZE);
4158
4159         val = of_get_property(dp, "node-wwn", &len);
4160         if (val && len >= WWN_SIZE)
4161                 memcpy(nv->node_name, val, WWN_SIZE);
4162 #endif
4163 }
4164
4165 int
4166 qla24xx_nvram_config(scsi_qla_host_t *vha)
4167 {
4168         int   rval;
4169         struct init_cb_24xx *icb;
4170         struct nvram_24xx *nv;
4171         uint32_t *dptr;
4172         uint8_t  *dptr1, *dptr2;
4173         uint32_t chksum;
4174         uint16_t cnt;
4175         struct qla_hw_data *ha = vha->hw;
4176
4177         rval = QLA_SUCCESS;
4178         icb = (struct init_cb_24xx *)ha->init_cb;
4179         nv = ha->nvram;
4180
4181         /* Determine NVRAM starting address. */
4182         if (ha->flags.port0) {
4183                 ha->nvram_base = FA_NVRAM_FUNC0_ADDR;
4184                 ha->vpd_base = FA_NVRAM_VPD0_ADDR;
4185         } else {
4186                 ha->nvram_base = FA_NVRAM_FUNC1_ADDR;
4187                 ha->vpd_base = FA_NVRAM_VPD1_ADDR;
4188         }
4189         ha->nvram_size = sizeof(struct nvram_24xx);
4190         ha->vpd_size = FA_NVRAM_VPD_SIZE;
4191         if (IS_QLA82XX(ha))
4192                 ha->vpd_size = FA_VPD_SIZE_82XX;
4193
4194         /* Get VPD data into cache */
4195         ha->vpd = ha->nvram + VPD_OFFSET;
4196         ha->isp_ops->read_nvram(vha, (uint8_t *)ha->vpd,
4197             ha->nvram_base - FA_NVRAM_FUNC0_ADDR, FA_NVRAM_VPD_SIZE * 4);
4198
4199         /* Get NVRAM data into cache and calculate checksum. */
4200         dptr = (uint32_t *)nv;
4201         ha->isp_ops->read_nvram(vha, (uint8_t *)dptr, ha->nvram_base,
4202             ha->nvram_size);
4203         for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
4204                 chksum += le32_to_cpu(*dptr++);
4205
4206         DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
4207         DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
4208
4209         /* Bad NVRAM data, set defaults parameters. */
4210         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
4211             || nv->id[3] != ' ' ||
4212             nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
4213                 /* Reset NVRAM data. */
4214                 qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
4215                     "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
4216                     le16_to_cpu(nv->nvram_version));
4217                 qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
4218                     "invalid -- WWPN) defaults.\n");
4219
4220                 /*
4221                  * Set default initialization control block.
4222                  */
4223                 memset(nv, 0, ha->nvram_size);
4224                 nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
4225                 nv->version = __constant_cpu_to_le16(ICB_VERSION);
4226                 nv->frame_payload_size = __constant_cpu_to_le16(2048);
4227                 nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
4228                 nv->exchange_count = __constant_cpu_to_le16(0);
4229                 nv->hard_address = __constant_cpu_to_le16(124);
4230                 nv->port_name[0] = 0x21;
4231                 nv->port_name[1] = 0x00 + ha->port_no;
4232                 nv->port_name[2] = 0x00;
4233                 nv->port_name[3] = 0xe0;
4234                 nv->port_name[4] = 0x8b;
4235                 nv->port_name[5] = 0x1c;
4236                 nv->port_name[6] = 0x55;
4237                 nv->port_name[7] = 0x86;
4238                 nv->node_name[0] = 0x20;
4239                 nv->node_name[1] = 0x00;
4240                 nv->node_name[2] = 0x00;
4241                 nv->node_name[3] = 0xe0;
4242                 nv->node_name[4] = 0x8b;
4243                 nv->node_name[5] = 0x1c;
4244                 nv->node_name[6] = 0x55;
4245                 nv->node_name[7] = 0x86;
4246                 qla24xx_nvram_wwn_from_ofw(vha, nv);
4247                 nv->login_retry_count = __constant_cpu_to_le16(8);
4248                 nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
4249                 nv->login_timeout = __constant_cpu_to_le16(0);
4250                 nv->firmware_options_1 =
4251                     __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
4252                 nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
4253                 nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
4254                 nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
4255                 nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
4256                 nv->efi_parameters = __constant_cpu_to_le32(0);
4257                 nv->reset_delay = 5;
4258                 nv->max_luns_per_target = __constant_cpu_to_le16(128);
4259                 nv->port_down_retry_count = __constant_cpu_to_le16(30);
4260                 nv->link_down_timeout = __constant_cpu_to_le16(30);
4261
4262                 rval = 1;
4263         }
4264
4265         /* Reset Initialization control block */
4266         memset(icb, 0, ha->init_cb_size);
4267
4268         /* Copy 1st segment. */
4269         dptr1 = (uint8_t *)icb;
4270         dptr2 = (uint8_t *)&nv->version;
4271         cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
4272         while (cnt--)
4273                 *dptr1++ = *dptr2++;
4274
4275         icb->login_retry_count = nv->login_retry_count;
4276         icb->link_down_on_nos = nv->link_down_on_nos;
4277
4278         /* Copy 2nd segment. */
4279         dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
4280         dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
4281         cnt = (uint8_t *)&icb->reserved_3 -
4282             (uint8_t *)&icb->interrupt_delay_timer;
4283         while (cnt--)
4284                 *dptr1++ = *dptr2++;
4285
4286         /*
4287          * Setup driver NVRAM options.
4288          */
4289         qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
4290             "QLA2462");
4291
4292         /* Use alternate WWN? */
4293         if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
4294                 memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
4295                 memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
4296         }
4297
4298         /* Prepare nodename */
4299         if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
4300                 /*
4301                  * Firmware will apply the following mask if the nodename was
4302                  * not provided.
4303                  */
4304                 memcpy(icb->node_name, icb->port_name, WWN_SIZE);
4305                 icb->node_name[0] &= 0xF0;
4306         }
4307
4308         /* Set host adapter parameters. */
4309         ha->flags.disable_risc_code_load = 0;
4310         ha->flags.enable_lip_reset = 0;
4311         ha->flags.enable_lip_full_login =
4312             le32_to_cpu(nv->host_p) & BIT_10 ? 1: 0;
4313         ha->flags.enable_target_reset =
4314             le32_to_cpu(nv->host_p) & BIT_11 ? 1: 0;
4315         ha->flags.enable_led_scheme = 0;
4316         ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;
4317
4318         ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
4319             (BIT_6 | BIT_5 | BIT_4)) >> 4;
4320
4321         memcpy(ha->fw_seriallink_options24, nv->seriallink_options,
4322             sizeof(ha->fw_seriallink_options24));
4323
4324         /* save HBA serial number */
4325         ha->serial0 = icb->port_name[5];
4326         ha->serial1 = icb->port_name[6];
4327         ha->serial2 = icb->port_name[7];
4328         memcpy(vha->node_name, icb->node_name, WWN_SIZE);
4329         memcpy(vha->port_name, icb->port_name, WWN_SIZE);
4330
4331         icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
4332
4333         ha->retry_count = le16_to_cpu(nv->login_retry_count);
4334
4335         /* Set minimum login_timeout to 4 seconds. */
4336         if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
4337                 nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
4338         if (le16_to_cpu(nv->login_timeout) < 4)
4339                 nv->login_timeout = __constant_cpu_to_le16(4);
4340         ha->login_timeout = le16_to_cpu(nv->login_timeout);
4341         icb->login_timeout = nv->login_timeout;
4342
4343         /* Set minimum RATOV to 100 tenths of a second. */
4344         ha->r_a_tov = 100;
4345
4346         ha->loop_reset_delay = nv->reset_delay;
4347
4348         /* Link Down Timeout = 0:
4349          *
4350          *      When Port Down timer expires we will start returning
4351          *      I/O's to OS with "DID_NO_CONNECT".
4352          *
4353          * Link Down Timeout != 0:
4354          *
4355          *       The driver waits for the link to come up after link down
4356          *       before returning I/Os to OS with "DID_NO_CONNECT".
4357          */
4358         if (le16_to_cpu(nv->link_down_timeout) == 0) {
4359                 ha->loop_down_abort_time =
4360                     (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
4361         } else {
4362                 ha->link_down_timeout = le16_to_cpu(nv->link_down_timeout);
4363                 ha->loop_down_abort_time =
4364                     (LOOP_DOWN_TIME - ha->link_down_timeout);
4365         }
4366
4367         /* Need enough time to try and get the port back. */
4368         ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
4369         if (qlport_down_retry)
4370                 ha->port_down_retry_count = qlport_down_retry;
4371
4372         /* Set login_retry_count */
4373         ha->login_retry_count  = le16_to_cpu(nv->login_retry_count);
4374         if (ha->port_down_retry_count ==
4375             le16_to_cpu(nv->port_down_retry_count) &&
4376             ha->port_down_retry_count > 3)
4377                 ha->login_retry_count = ha->port_down_retry_count;
4378         else if (ha->port_down_retry_count > (int)ha->login_retry_count)
4379                 ha->login_retry_count = ha->port_down_retry_count;
4380         if (ql2xloginretrycount)
4381                 ha->login_retry_count = ql2xloginretrycount;
4382
4383         /* Enable ZIO. */
4384         if (!vha->flags.init_done) {
4385                 ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
4386                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
4387                 ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
4388                     le16_to_cpu(icb->interrupt_delay_timer): 2;
4389         }
4390         icb->firmware_options_2 &= __constant_cpu_to_le32(
4391             ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
4392         vha->flags.process_response_queue = 0;
4393         if (ha->zio_mode != QLA_ZIO_DISABLED) {
4394                 ha->zio_mode = QLA_ZIO_MODE_6;
4395
4396                 DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
4397                     "(%d us).\n", vha->host_no, ha->zio_mode,
4398                     ha->zio_timer * 100));
4399                 qla_printk(KERN_INFO, ha,
4400                     "ZIO mode %d enabled; timer delay (%d us).\n",
4401                     ha->zio_mode, ha->zio_timer * 100);
4402
4403                 icb->firmware_options_2 |= cpu_to_le32(
4404                     (uint32_t)ha->zio_mode);
4405                 icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
4406                 vha->flags.process_response_queue = 1;
4407         }
4408
4409         if (rval) {
4410                 DEBUG2_3(printk(KERN_WARNING
4411                     "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
4412         }
4413         return (rval);
4414 }
4415
4416 static int
4417 qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
4418     uint32_t faddr)
4419 {
4420         int     rval = QLA_SUCCESS;
4421         int     segments, fragment;
4422         uint32_t *dcode, dlen;
4423         uint32_t risc_addr;
4424         uint32_t risc_size;
4425         uint32_t i;
4426         struct qla_hw_data *ha = vha->hw;
4427         struct req_que *req = ha->req_q_map[0];
4428
4429         qla_printk(KERN_INFO, ha,
4430             "FW: Loading from flash (%x)...\n", faddr);
4431
4432         rval = QLA_SUCCESS;
4433
4434         segments = FA_RISC_CODE_SEGMENTS;
4435         dcode = (uint32_t *)req->ring;
4436         *srisc_addr = 0;
4437
4438         /* Validate firmware image by checking version. */
4439         qla24xx_read_flash_data(vha, dcode, faddr + 4, 4);
4440         for (i = 0; i < 4; i++)
4441                 dcode[i] = be32_to_cpu(dcode[i]);
4442         if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
4443             dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
4444             (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
4445                 dcode[3] == 0)) {
4446                 qla_printk(KERN_WARNING, ha,
4447                     "Unable to verify integrity of flash firmware image!\n");
4448                 qla_printk(KERN_WARNING, ha,
4449                     "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
4450                     dcode[1], dcode[2], dcode[3]);
4451
4452                 return QLA_FUNCTION_FAILED;
4453         }
4454
4455         while (segments && rval == QLA_SUCCESS) {
4456                 /* Read segment's load information. */
4457                 qla24xx_read_flash_data(vha, dcode, faddr, 4);
4458
4459                 risc_addr = be32_to_cpu(dcode[2]);
4460                 *srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
4461                 risc_size = be32_to_cpu(dcode[3]);
4462
4463                 fragment = 0;
4464                 while (risc_size > 0 && rval == QLA_SUCCESS) {
4465                         dlen = (uint32_t)(ha->fw_transfer_size >> 2);
4466                         if (dlen > risc_size)
4467                                 dlen = risc_size;
4468
4469                         DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
4470                             "addr %x, number of dwords 0x%x, offset 0x%x.\n",
4471                             vha->host_no, risc_addr, dlen, faddr));
4472
4473                         qla24xx_read_flash_data(vha, dcode, faddr, dlen);
4474                         for (i = 0; i < dlen; i++)
4475                                 dcode[i] = swab32(dcode[i]);
4476
4477                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4478                             dlen);
4479                         if (rval) {
4480                                 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
4481                                     "segment %d of firmware\n", vha->host_no,
4482                                     fragment));
4483                                 qla_printk(KERN_WARNING, ha,
4484                                     "[ERROR] Failed to load segment %d of "
4485                                     "firmware\n", fragment);
4486                                 break;
4487                         }
4488
4489                         faddr += dlen;
4490                         risc_addr += dlen;
4491                         risc_size -= dlen;
4492                         fragment++;
4493                 }
4494
4495                 /* Next segment. */
4496                 segments--;
4497         }
4498
4499         return rval;
4500 }
4501
4502 #define QLA_FW_URL "ftp://ftp.qlogic.com/outgoing/linux/firmware/"
4503
4504 int
4505 qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4506 {
4507         int     rval;
4508         int     i, fragment;
4509         uint16_t *wcode, *fwcode;
4510         uint32_t risc_addr, risc_size, fwclen, wlen, *seg;
4511         struct fw_blob *blob;
4512         struct qla_hw_data *ha = vha->hw;
4513         struct req_que *req = ha->req_q_map[0];
4514
4515         /* Load firmware blob. */
4516         blob = qla2x00_request_firmware(vha);
4517         if (!blob) {
4518                 qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
4519                 qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
4520                     "from: " QLA_FW_URL ".\n");
4521                 return QLA_FUNCTION_FAILED;
4522         }
4523
4524         rval = QLA_SUCCESS;
4525
4526         wcode = (uint16_t *)req->ring;
4527         *srisc_addr = 0;
4528         fwcode = (uint16_t *)blob->fw->data;
4529         fwclen = 0;
4530
4531         /* Validate firmware image by checking version. */
4532         if (blob->fw->size < 8 * sizeof(uint16_t)) {
4533                 qla_printk(KERN_WARNING, ha,
4534                     "Unable to verify integrity of firmware image (%Zd)!\n",
4535                     blob->fw->size);
4536                 goto fail_fw_integrity;
4537         }
4538         for (i = 0; i < 4; i++)
4539                 wcode[i] = be16_to_cpu(fwcode[i + 4]);
4540         if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff &&
4541             wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 &&
4542                 wcode[2] == 0 && wcode[3] == 0)) {
4543                 qla_printk(KERN_WARNING, ha,
4544                     "Unable to verify integrity of firmware image!\n");
4545                 qla_printk(KERN_WARNING, ha,
4546                     "Firmware data: %04x %04x %04x %04x!\n", wcode[0],
4547                     wcode[1], wcode[2], wcode[3]);
4548                 goto fail_fw_integrity;
4549         }
4550
4551         seg = blob->segs;
4552         while (*seg && rval == QLA_SUCCESS) {
4553                 risc_addr = *seg;
4554                 *srisc_addr = *srisc_addr == 0 ? *seg : *srisc_addr;
4555                 risc_size = be16_to_cpu(fwcode[3]);
4556
4557                 /* Validate firmware image size. */
4558                 fwclen += risc_size * sizeof(uint16_t);
4559                 if (blob->fw->size < fwclen) {
4560                         qla_printk(KERN_WARNING, ha,
4561                             "Unable to verify integrity of firmware image "
4562                             "(%Zd)!\n", blob->fw->size);
4563                         goto fail_fw_integrity;
4564                 }
4565
4566                 fragment = 0;
4567                 while (risc_size > 0 && rval == QLA_SUCCESS) {
4568                         wlen = (uint16_t)(ha->fw_transfer_size >> 1);
4569                         if (wlen > risc_size)
4570                                 wlen = risc_size;
4571
4572                         DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
4573                             "addr %x, number of words 0x%x.\n", vha->host_no,
4574                             risc_addr, wlen));
4575
4576                         for (i = 0; i < wlen; i++)
4577                                 wcode[i] = swab16(fwcode[i]);
4578
4579                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4580                             wlen);
4581                         if (rval) {
4582                                 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
4583                                     "segment %d of firmware\n", vha->host_no,
4584                                     fragment));
4585                                 qla_printk(KERN_WARNING, ha,
4586                                     "[ERROR] Failed to load segment %d of "
4587                                     "firmware\n", fragment);
4588                                 break;
4589                         }
4590
4591                         fwcode += wlen;
4592                         risc_addr += wlen;
4593                         risc_size -= wlen;
4594                         fragment++;
4595                 }
4596
4597                 /* Next segment. */
4598                 seg++;
4599         }
4600         return rval;
4601
4602 fail_fw_integrity:
4603         return QLA_FUNCTION_FAILED;
4604 }
4605
4606 static int
4607 qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4608 {
4609         int     rval;
4610         int     segments, fragment;
4611         uint32_t *dcode, dlen;
4612         uint32_t risc_addr;
4613         uint32_t risc_size;
4614         uint32_t i;
4615         struct fw_blob *blob;
4616         uint32_t *fwcode, fwclen;
4617         struct qla_hw_data *ha = vha->hw;
4618         struct req_que *req = ha->req_q_map[0];
4619
4620         /* Load firmware blob. */
4621         blob = qla2x00_request_firmware(vha);
4622         if (!blob) {
4623                 qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
4624                 qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
4625                     "from: " QLA_FW_URL ".\n");
4626
4627                 return QLA_FUNCTION_FAILED;
4628         }
4629
4630         qla_printk(KERN_INFO, ha,
4631             "FW: Loading via request-firmware...\n");
4632
4633         rval = QLA_SUCCESS;
4634
4635         segments = FA_RISC_CODE_SEGMENTS;
4636         dcode = (uint32_t *)req->ring;
4637         *srisc_addr = 0;
4638         fwcode = (uint32_t *)blob->fw->data;
4639         fwclen = 0;
4640
4641         /* Validate firmware image by checking version. */
4642         if (blob->fw->size < 8 * sizeof(uint32_t)) {
4643                 qla_printk(KERN_WARNING, ha,
4644                     "Unable to verify integrity of firmware image (%Zd)!\n",
4645                     blob->fw->size);
4646                 goto fail_fw_integrity;
4647         }
4648         for (i = 0; i < 4; i++)
4649                 dcode[i] = be32_to_cpu(fwcode[i + 4]);
4650         if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
4651             dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
4652             (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
4653                 dcode[3] == 0)) {
4654                 qla_printk(KERN_WARNING, ha,
4655                     "Unable to verify integrity of firmware image!\n");
4656                 qla_printk(KERN_WARNING, ha,
4657                     "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
4658                     dcode[1], dcode[2], dcode[3]);
4659                 goto fail_fw_integrity;
4660         }
4661
4662         while (segments && rval == QLA_SUCCESS) {
4663                 risc_addr = be32_to_cpu(fwcode[2]);
4664                 *srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
4665                 risc_size = be32_to_cpu(fwcode[3]);
4666
4667                 /* Validate firmware image size. */
4668                 fwclen += risc_size * sizeof(uint32_t);
4669                 if (blob->fw->size < fwclen) {
4670                         qla_printk(KERN_WARNING, ha,
4671                             "Unable to verify integrity of firmware image "
4672                             "(%Zd)!\n", blob->fw->size);
4673
4674                         goto fail_fw_integrity;
4675                 }
4676
4677                 fragment = 0;
4678                 while (risc_size > 0 && rval == QLA_SUCCESS) {
4679                         dlen = (uint32_t)(ha->fw_transfer_size >> 2);
4680                         if (dlen > risc_size)
4681                                 dlen = risc_size;
4682
4683                         DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
4684                             "addr %x, number of dwords 0x%x.\n", vha->host_no,
4685                             risc_addr, dlen));
4686
4687                         for (i = 0; i < dlen; i++)
4688                                 dcode[i] = swab32(fwcode[i]);
4689
4690                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4691                             dlen);
4692                         if (rval) {
4693                                 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
4694                                     "segment %d of firmware\n", vha->host_no,
4695                                     fragment));
4696                                 qla_printk(KERN_WARNING, ha,
4697                                     "[ERROR] Failed to load segment %d of "
4698                                     "firmware\n", fragment);
4699                                 break;
4700                         }
4701
4702                         fwcode += dlen;
4703                         risc_addr += dlen;
4704                         risc_size -= dlen;
4705                         fragment++;
4706                 }
4707
4708                 /* Next segment. */
4709                 segments--;
4710         }
4711         return rval;
4712
4713 fail_fw_integrity:
4714         return QLA_FUNCTION_FAILED;
4715 }
4716
4717 int
4718 qla24xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4719 {
4720         int rval;
4721
4722         if (ql2xfwloadbin == 1)
4723                 return qla81xx_load_risc(vha, srisc_addr);
4724
4725         /*
4726          * FW Load priority:
4727          * 1) Firmware via request-firmware interface (.bin file).
4728          * 2) Firmware residing in flash.
4729          */
4730         rval = qla24xx_load_risc_blob(vha, srisc_addr);
4731         if (rval == QLA_SUCCESS)
4732                 return rval;
4733
4734         return qla24xx_load_risc_flash(vha, srisc_addr,
4735             vha->hw->flt_region_fw);
4736 }
4737
4738 int
4739 qla81xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4740 {
4741         int rval;
4742         struct qla_hw_data *ha = vha->hw;
4743
4744         if (ql2xfwloadbin == 2)
4745                 goto try_blob_fw;
4746
4747         /*
4748          * FW Load priority:
4749          * 1) Firmware residing in flash.
4750          * 2) Firmware via request-firmware interface (.bin file).
4751          * 3) Golden-Firmware residing in flash -- limited operation.
4752          */
4753         rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_fw);
4754         if (rval == QLA_SUCCESS)
4755                 return rval;
4756
4757 try_blob_fw:
4758         rval = qla24xx_load_risc_blob(vha, srisc_addr);
4759         if (rval == QLA_SUCCESS || !ha->flt_region_gold_fw)
4760                 return rval;
4761
4762         qla_printk(KERN_ERR, ha,
4763             "FW: Attempting to fallback to golden firmware...\n");
4764         rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_gold_fw);
4765         if (rval != QLA_SUCCESS)
4766                 return rval;
4767
4768         qla_printk(KERN_ERR, ha,
4769             "FW: Please update operational firmware...\n");
4770         ha->flags.running_gold_fw = 1;
4771
4772         return rval;
4773 }
4774
4775 void
4776 qla2x00_try_to_stop_firmware(scsi_qla_host_t *vha)
4777 {
4778         int ret, retries;
4779         struct qla_hw_data *ha = vha->hw;
4780
4781         if (ha->flags.pci_channel_io_perm_failure)
4782                 return;
4783         if (!IS_FWI2_CAPABLE(ha))
4784                 return;
4785         if (!ha->fw_major_version)
4786                 return;
4787
4788         ret = qla2x00_stop_firmware(vha);
4789         for (retries = 5; ret != QLA_SUCCESS && ret != QLA_FUNCTION_TIMEOUT &&
4790             ret != QLA_INVALID_COMMAND && retries ; retries--) {
4791                 ha->isp_ops->reset_chip(vha);
4792                 if (ha->isp_ops->chip_diag(vha) != QLA_SUCCESS)
4793                         continue;
4794                 if (qla2x00_setup_chip(vha) != QLA_SUCCESS)
4795                         continue;
4796                 qla_printk(KERN_INFO, ha,
4797                     "Attempting retry of stop-firmware command...\n");
4798                 ret = qla2x00_stop_firmware(vha);
4799         }
4800 }
4801
4802 int
4803 qla24xx_configure_vhba(scsi_qla_host_t *vha)
4804 {
4805         int rval = QLA_SUCCESS;
4806         uint16_t mb[MAILBOX_REGISTER_COUNT];
4807         struct qla_hw_data *ha = vha->hw;
4808         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
4809         struct req_que *req;
4810         struct rsp_que *rsp;
4811
4812         if (!vha->vp_idx)
4813                 return -EINVAL;
4814
4815         rval = qla2x00_fw_ready(base_vha);
4816         if (ha->flags.cpu_affinity_enabled)
4817                 req = ha->req_q_map[0];
4818         else
4819                 req = vha->req;
4820         rsp = req->rsp;
4821
4822         if (rval == QLA_SUCCESS) {
4823                 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
4824                 qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
4825         }
4826
4827         vha->flags.management_server_logged_in = 0;
4828
4829         /* Login to SNS first */
4830         ha->isp_ops->fabric_login(vha, NPH_SNS, 0xff, 0xff, 0xfc, mb, BIT_1);
4831         if (mb[0] != MBS_COMMAND_COMPLETE) {
4832                 DEBUG15(qla_printk(KERN_INFO, ha,
4833                     "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
4834                     "mb[2]=%x mb[6]=%x mb[7]=%x\n", NPH_SNS,
4835                     mb[0], mb[1], mb[2], mb[6], mb[7]));
4836                 return (QLA_FUNCTION_FAILED);
4837         }
4838
4839         atomic_set(&vha->loop_down_timer, 0);
4840         atomic_set(&vha->loop_state, LOOP_UP);
4841         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4842         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4843         rval = qla2x00_loop_resync(base_vha);
4844
4845         return rval;
4846 }
4847
4848 /* 84XX Support **************************************************************/
4849
4850 static LIST_HEAD(qla_cs84xx_list);
4851 static DEFINE_MUTEX(qla_cs84xx_mutex);
4852
4853 static struct qla_chip_state_84xx *
4854 qla84xx_get_chip(struct scsi_qla_host *vha)
4855 {
4856         struct qla_chip_state_84xx *cs84xx;
4857         struct qla_hw_data *ha = vha->hw;
4858
4859         mutex_lock(&qla_cs84xx_mutex);
4860
4861         /* Find any shared 84xx chip. */
4862         list_for_each_entry(cs84xx, &qla_cs84xx_list, list) {
4863                 if (cs84xx->bus == ha->pdev->bus) {
4864                         kref_get(&cs84xx->kref);
4865                         goto done;
4866                 }
4867         }
4868
4869         cs84xx = kzalloc(sizeof(*cs84xx), GFP_KERNEL);
4870         if (!cs84xx)
4871                 goto done;
4872
4873         kref_init(&cs84xx->kref);
4874         spin_lock_init(&cs84xx->access_lock);
4875         mutex_init(&cs84xx->fw_update_mutex);
4876         cs84xx->bus = ha->pdev->bus;
4877
4878         list_add_tail(&cs84xx->list, &qla_cs84xx_list);
4879 done:
4880         mutex_unlock(&qla_cs84xx_mutex);
4881         return cs84xx;
4882 }
4883
4884 static void
4885 __qla84xx_chip_release(struct kref *kref)
4886 {
4887         struct qla_chip_state_84xx *cs84xx =
4888             container_of(kref, struct qla_chip_state_84xx, kref);
4889
4890         mutex_lock(&qla_cs84xx_mutex);
4891         list_del(&cs84xx->list);
4892         mutex_unlock(&qla_cs84xx_mutex);
4893         kfree(cs84xx);
4894 }
4895
4896 void
4897 qla84xx_put_chip(struct scsi_qla_host *vha)
4898 {
4899         struct qla_hw_data *ha = vha->hw;
4900         if (ha->cs84xx)
4901                 kref_put(&ha->cs84xx->kref, __qla84xx_chip_release);
4902 }
4903
4904 static int
4905 qla84xx_init_chip(scsi_qla_host_t *vha)
4906 {
4907         int rval;
4908         uint16_t status[2];
4909         struct qla_hw_data *ha = vha->hw;
4910
4911         mutex_lock(&ha->cs84xx->fw_update_mutex);
4912
4913         rval = qla84xx_verify_chip(vha, status);
4914
4915         mutex_unlock(&ha->cs84xx->fw_update_mutex);
4916
4917         return rval != QLA_SUCCESS || status[0] ? QLA_FUNCTION_FAILED:
4918             QLA_SUCCESS;
4919 }
4920
4921 /* 81XX Support **************************************************************/
4922
4923 int
4924 qla81xx_nvram_config(scsi_qla_host_t *vha)
4925 {
4926         int   rval;
4927         struct init_cb_81xx *icb;
4928         struct nvram_81xx *nv;
4929         uint32_t *dptr;
4930         uint8_t  *dptr1, *dptr2;
4931         uint32_t chksum;
4932         uint16_t cnt;
4933         struct qla_hw_data *ha = vha->hw;
4934
4935         rval = QLA_SUCCESS;
4936         icb = (struct init_cb_81xx *)ha->init_cb;
4937         nv = ha->nvram;
4938
4939         /* Determine NVRAM starting address. */
4940         ha->nvram_size = sizeof(struct nvram_81xx);
4941         ha->vpd_size = FA_NVRAM_VPD_SIZE;
4942
4943         /* Get VPD data into cache */
4944         ha->vpd = ha->nvram + VPD_OFFSET;
4945         ha->isp_ops->read_optrom(vha, ha->vpd, ha->flt_region_vpd << 2,
4946             ha->vpd_size);
4947
4948         /* Get NVRAM data into cache and calculate checksum. */
4949         ha->isp_ops->read_optrom(vha, ha->nvram, ha->flt_region_nvram << 2,
4950             ha->nvram_size);
4951         dptr = (uint32_t *)nv;
4952         for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
4953                 chksum += le32_to_cpu(*dptr++);
4954
4955         DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
4956         DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
4957
4958         /* Bad NVRAM data, set defaults parameters. */
4959         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
4960             || nv->id[3] != ' ' ||
4961             nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
4962                 /* Reset NVRAM data. */
4963                 qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
4964                     "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
4965                     le16_to_cpu(nv->nvram_version));
4966                 qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
4967                     "invalid -- WWPN) defaults.\n");
4968
4969                 /*
4970                  * Set default initialization control block.
4971                  */
4972                 memset(nv, 0, ha->nvram_size);
4973                 nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
4974                 nv->version = __constant_cpu_to_le16(ICB_VERSION);
4975                 nv->frame_payload_size = __constant_cpu_to_le16(2048);
4976                 nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
4977                 nv->exchange_count = __constant_cpu_to_le16(0);
4978                 nv->port_name[0] = 0x21;
4979                 nv->port_name[1] = 0x00 + ha->port_no;
4980                 nv->port_name[2] = 0x00;
4981                 nv->port_name[3] = 0xe0;
4982                 nv->port_name[4] = 0x8b;
4983                 nv->port_name[5] = 0x1c;
4984                 nv->port_name[6] = 0x55;
4985                 nv->port_name[7] = 0x86;
4986                 nv->node_name[0] = 0x20;
4987                 nv->node_name[1] = 0x00;
4988                 nv->node_name[2] = 0x00;
4989                 nv->node_name[3] = 0xe0;
4990                 nv->node_name[4] = 0x8b;
4991                 nv->node_name[5] = 0x1c;
4992                 nv->node_name[6] = 0x55;
4993                 nv->node_name[7] = 0x86;
4994                 nv->login_retry_count = __constant_cpu_to_le16(8);
4995                 nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
4996                 nv->login_timeout = __constant_cpu_to_le16(0);
4997                 nv->firmware_options_1 =
4998                     __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
4999                 nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
5000                 nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
5001                 nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
5002                 nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
5003                 nv->efi_parameters = __constant_cpu_to_le32(0);
5004                 nv->reset_delay = 5;
5005                 nv->max_luns_per_target = __constant_cpu_to_le16(128);
5006                 nv->port_down_retry_count = __constant_cpu_to_le16(30);
5007                 nv->link_down_timeout = __constant_cpu_to_le16(30);
5008                 nv->enode_mac[0] = 0x00;
5009                 nv->enode_mac[1] = 0x02;
5010                 nv->enode_mac[2] = 0x03;
5011                 nv->enode_mac[3] = 0x04;
5012                 nv->enode_mac[4] = 0x05;
5013                 nv->enode_mac[5] = 0x06 + ha->port_no;
5014
5015                 rval = 1;
5016         }
5017
5018         /* Reset Initialization control block */
5019         memset(icb, 0, sizeof(struct init_cb_81xx));
5020
5021         /* Copy 1st segment. */
5022         dptr1 = (uint8_t *)icb;
5023         dptr2 = (uint8_t *)&nv->version;
5024         cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
5025         while (cnt--)
5026                 *dptr1++ = *dptr2++;
5027
5028         icb->login_retry_count = nv->login_retry_count;
5029
5030         /* Copy 2nd segment. */
5031         dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
5032         dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
5033         cnt = (uint8_t *)&icb->reserved_5 -
5034             (uint8_t *)&icb->interrupt_delay_timer;
5035         while (cnt--)
5036                 *dptr1++ = *dptr2++;
5037
5038         memcpy(icb->enode_mac, nv->enode_mac, sizeof(icb->enode_mac));
5039         /* Some boards (with valid NVRAMs) still have NULL enode_mac!! */
5040         if (!memcmp(icb->enode_mac, "\0\0\0\0\0\0", sizeof(icb->enode_mac))) {
5041                 icb->enode_mac[0] = 0x01;
5042                 icb->enode_mac[1] = 0x02;
5043                 icb->enode_mac[2] = 0x03;
5044                 icb->enode_mac[3] = 0x04;
5045                 icb->enode_mac[4] = 0x05;
5046                 icb->enode_mac[5] = 0x06 + ha->port_no;
5047         }
5048
5049         /* Use extended-initialization control block. */
5050         memcpy(ha->ex_init_cb, &nv->ex_version, sizeof(*ha->ex_init_cb));
5051
5052         /*
5053          * Setup driver NVRAM options.
5054          */
5055         qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
5056             "QLE8XXX");
5057
5058         /* Use alternate WWN? */
5059         if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
5060                 memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
5061                 memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
5062         }
5063
5064         /* Prepare nodename */
5065         if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
5066                 /*
5067                  * Firmware will apply the following mask if the nodename was
5068                  * not provided.
5069                  */
5070                 memcpy(icb->node_name, icb->port_name, WWN_SIZE);
5071                 icb->node_name[0] &= 0xF0;
5072         }
5073
5074         /* Set host adapter parameters. */
5075         ha->flags.disable_risc_code_load = 0;
5076         ha->flags.enable_lip_reset = 0;
5077         ha->flags.enable_lip_full_login =
5078             le32_to_cpu(nv->host_p) & BIT_10 ? 1: 0;
5079         ha->flags.enable_target_reset =
5080             le32_to_cpu(nv->host_p) & BIT_11 ? 1: 0;
5081         ha->flags.enable_led_scheme = 0;
5082         ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;
5083
5084         ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
5085             (BIT_6 | BIT_5 | BIT_4)) >> 4;
5086
5087         /* save HBA serial number */
5088         ha->serial0 = icb->port_name[5];
5089         ha->serial1 = icb->port_name[6];
5090         ha->serial2 = icb->port_name[7];
5091         memcpy(vha->node_name, icb->node_name, WWN_SIZE);
5092         memcpy(vha->port_name, icb->port_name, WWN_SIZE);
5093
5094         icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
5095
5096         ha->retry_count = le16_to_cpu(nv->login_retry_count);
5097
5098         /* Set minimum login_timeout to 4 seconds. */
5099         if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
5100                 nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
5101         if (le16_to_cpu(nv->login_timeout) < 4)
5102                 nv->login_timeout = __constant_cpu_to_le16(4);
5103         ha->login_timeout = le16_to_cpu(nv->login_timeout);
5104         icb->login_timeout = nv->login_timeout;
5105
5106         /* Set minimum RATOV to 100 tenths of a second. */
5107         ha->r_a_tov = 100;
5108
5109         ha->loop_reset_delay = nv->reset_delay;
5110
5111         /* Link Down Timeout = 0:
5112          *
5113          *      When Port Down timer expires we will start returning
5114          *      I/O's to OS with "DID_NO_CONNECT".
5115          *
5116          * Link Down Timeout != 0:
5117          *
5118          *       The driver waits for the link to come up after link down
5119          *       before returning I/Os to OS with "DID_NO_CONNECT".
5120          */
5121         if (le16_to_cpu(nv->link_down_timeout) == 0) {
5122                 ha->loop_down_abort_time =
5123                     (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
5124         } else {
5125                 ha->link_down_timeout = le16_to_cpu(nv->link_down_timeout);
5126                 ha->loop_down_abort_time =
5127                     (LOOP_DOWN_TIME - ha->link_down_timeout);
5128         }
5129
5130         /* Need enough time to try and get the port back. */
5131         ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
5132         if (qlport_down_retry)
5133                 ha->port_down_retry_count = qlport_down_retry;
5134
5135         /* Set login_retry_count */
5136         ha->login_retry_count  = le16_to_cpu(nv->login_retry_count);
5137         if (ha->port_down_retry_count ==
5138             le16_to_cpu(nv->port_down_retry_count) &&
5139             ha->port_down_retry_count > 3)
5140                 ha->login_retry_count = ha->port_down_retry_count;
5141         else if (ha->port_down_retry_count > (int)ha->login_retry_count)
5142                 ha->login_retry_count = ha->port_down_retry_count;
5143         if (ql2xloginretrycount)
5144                 ha->login_retry_count = ql2xloginretrycount;
5145
5146         /* Enable ZIO. */
5147         if (!vha->flags.init_done) {
5148                 ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
5149                     (BIT_3 | BIT_2 | BIT_1 | BIT_0);
5150                 ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
5151                     le16_to_cpu(icb->interrupt_delay_timer): 2;
5152         }
5153         icb->firmware_options_2 &= __constant_cpu_to_le32(
5154             ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
5155         vha->flags.process_response_queue = 0;
5156         if (ha->zio_mode != QLA_ZIO_DISABLED) {
5157                 ha->zio_mode = QLA_ZIO_MODE_6;
5158
5159                 DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
5160                     "(%d us).\n", vha->host_no, ha->zio_mode,
5161                     ha->zio_timer * 100));
5162                 qla_printk(KERN_INFO, ha,
5163                     "ZIO mode %d enabled; timer delay (%d us).\n",
5164                     ha->zio_mode, ha->zio_timer * 100);
5165
5166                 icb->firmware_options_2 |= cpu_to_le32(
5167                     (uint32_t)ha->zio_mode);
5168                 icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
5169                 vha->flags.process_response_queue = 1;
5170         }
5171
5172         if (rval) {
5173                 DEBUG2_3(printk(KERN_WARNING
5174                     "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
5175         }
5176         return (rval);
5177 }
5178
5179 int
5180 qla82xx_restart_isp(scsi_qla_host_t *vha)
5181 {
5182         int status, rval;
5183         uint32_t wait_time;
5184         struct qla_hw_data *ha = vha->hw;
5185         struct req_que *req = ha->req_q_map[0];
5186         struct rsp_que *rsp = ha->rsp_q_map[0];
5187         struct scsi_qla_host *vp;
5188         struct scsi_qla_host *tvp;
5189
5190         status = qla2x00_init_rings(vha);
5191         if (!status) {
5192                 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
5193                 ha->flags.chip_reset_done = 1;
5194
5195                 status = qla2x00_fw_ready(vha);
5196                 if (!status) {
5197                         qla_printk(KERN_INFO, ha,
5198                         "%s(): Start configure loop, "
5199                         "status = %d\n", __func__, status);
5200
5201                         /* Issue a marker after FW becomes ready. */
5202                         qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
5203
5204                         vha->flags.online = 1;
5205                         /* Wait at most MAX_TARGET RSCNs for a stable link. */
5206                         wait_time = 256;
5207                         do {
5208                                 clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
5209                                 qla2x00_configure_loop(vha);
5210                                 wait_time--;
5211                         } while (!atomic_read(&vha->loop_down_timer) &&
5212                             !(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) &&
5213                             wait_time &&
5214                             (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)));
5215                 }
5216
5217                 /* if no cable then assume it's good */
5218                 if ((vha->device_flags & DFLG_NO_CABLE))
5219                         status = 0;
5220
5221                 qla_printk(KERN_INFO, ha,
5222                         "%s(): Configure loop done, status = 0x%x\n",
5223                         __func__, status);
5224         }
5225
5226         if (!status) {
5227                 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
5228
5229                 if (!atomic_read(&vha->loop_down_timer)) {
5230                         /*
5231                          * Issue marker command only when we are going
5232                          * to start the I/O .
5233                          */
5234                         vha->marker_needed = 1;
5235                 }
5236
5237                 vha->flags.online = 1;
5238
5239                 ha->isp_ops->enable_intrs(ha);
5240
5241                 ha->isp_abort_cnt = 0;
5242                 clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
5243
5244                 if (ha->fce) {
5245                         ha->flags.fce_enabled = 1;
5246                         memset(ha->fce, 0,
5247                             fce_calc_size(ha->fce_bufs));
5248                         rval = qla2x00_enable_fce_trace(vha,
5249                             ha->fce_dma, ha->fce_bufs, ha->fce_mb,
5250                             &ha->fce_bufs);
5251                         if (rval) {
5252                                 qla_printk(KERN_WARNING, ha,
5253                                     "Unable to reinitialize FCE "
5254                                     "(%d).\n", rval);
5255                                 ha->flags.fce_enabled = 0;
5256                         }
5257                 }
5258
5259                 if (ha->eft) {
5260                         memset(ha->eft, 0, EFT_SIZE);
5261                         rval = qla2x00_enable_eft_trace(vha,
5262                             ha->eft_dma, EFT_NUM_BUFFERS);
5263                         if (rval) {
5264                                 qla_printk(KERN_WARNING, ha,
5265                                     "Unable to reinitialize EFT "
5266                                     "(%d).\n", rval);
5267                         }
5268                 }
5269         }
5270
5271         if (!status) {
5272                 DEBUG(printk(KERN_INFO
5273                         "qla82xx_restart_isp(%ld): succeeded.\n",
5274                         vha->host_no));
5275                 list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
5276                         if (vp->vp_idx)
5277                                 qla2x00_vp_abort_isp(vp);
5278                 }
5279         } else {
5280                 qla_printk(KERN_INFO, ha,
5281                         "qla82xx_restart_isp: **** FAILED ****\n");
5282         }
5283
5284         return status;
5285 }
5286
5287 void
5288 qla81xx_update_fw_options(scsi_qla_host_t *vha)
5289 {
5290         struct qla_hw_data *ha = vha->hw;
5291
5292         if (!ql2xetsenable)
5293                 return;
5294
5295         /* Enable ETS Burst. */
5296         memset(ha->fw_options, 0, sizeof(ha->fw_options));
5297         ha->fw_options[2] |= BIT_9;
5298         qla2x00_set_fw_options(vha, ha->fw_options);
5299 }
5300
5301 /*
5302  * qla24xx_get_fcp_prio
5303  *      Gets the fcp cmd priority value for the logged in port.
5304  *      Looks for a match of the port descriptors within
5305  *      each of the fcp prio config entries. If a match is found,
5306  *      the tag (priority) value is returned.
5307  *
5308  * Input:
5309  *      ha = adapter block po
5310  *      fcport = port structure pointer.
5311  *
5312  * Return:
5313  *      non-zero (if found)
5314  *      0 (if not found)
5315  *
5316  * Context:
5317  *      Kernel context
5318  */
5319 uint8_t
5320 qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
5321 {
5322         int i, entries;
5323         uint8_t pid_match, wwn_match;
5324         uint8_t priority;
5325         uint32_t pid1, pid2;
5326         uint64_t wwn1, wwn2;
5327         struct qla_fcp_prio_entry *pri_entry;
5328         struct qla_hw_data *ha = vha->hw;
5329
5330         if (!ha->fcp_prio_cfg || !ha->flags.fcp_prio_enabled)
5331                 return 0;
5332
5333         priority = 0;
5334         entries = ha->fcp_prio_cfg->num_entries;
5335         pri_entry = &ha->fcp_prio_cfg->entry[0];
5336
5337         for (i = 0; i < entries; i++) {
5338                 pid_match = wwn_match = 0;
5339
5340                 if (!(pri_entry->flags & FCP_PRIO_ENTRY_VALID)) {
5341                         pri_entry++;
5342                         continue;
5343                 }
5344
5345                 /* check source pid for a match */
5346                 if (pri_entry->flags & FCP_PRIO_ENTRY_SPID_VALID) {
5347                         pid1 = pri_entry->src_pid & INVALID_PORT_ID;
5348                         pid2 = vha->d_id.b24 & INVALID_PORT_ID;
5349                         if (pid1 == INVALID_PORT_ID)
5350                                 pid_match++;
5351                         else if (pid1 == pid2)
5352                                 pid_match++;
5353                 }
5354
5355                 /* check destination pid for a match */
5356                 if (pri_entry->flags & FCP_PRIO_ENTRY_DPID_VALID) {
5357                         pid1 = pri_entry->dst_pid & INVALID_PORT_ID;
5358                         pid2 = fcport->d_id.b24 & INVALID_PORT_ID;
5359                         if (pid1 == INVALID_PORT_ID)
5360                                 pid_match++;
5361                         else if (pid1 == pid2)
5362                                 pid_match++;
5363                 }
5364
5365                 /* check source WWN for a match */
5366                 if (pri_entry->flags & FCP_PRIO_ENTRY_SWWN_VALID) {
5367                         wwn1 = wwn_to_u64(vha->port_name);
5368                         wwn2 = wwn_to_u64(pri_entry->src_wwpn);
5369                         if (wwn2 == (uint64_t)-1)
5370                                 wwn_match++;
5371                         else if (wwn1 == wwn2)
5372                                 wwn_match++;
5373                 }
5374
5375                 /* check destination WWN for a match */
5376                 if (pri_entry->flags & FCP_PRIO_ENTRY_DWWN_VALID) {
5377                         wwn1 = wwn_to_u64(fcport->port_name);
5378                         wwn2 = wwn_to_u64(pri_entry->dst_wwpn);
5379                         if (wwn2 == (uint64_t)-1)
5380                                 wwn_match++;
5381                         else if (wwn1 == wwn2)
5382                                 wwn_match++;
5383                 }
5384
5385                 if (pid_match == 2 || wwn_match == 2) {
5386                         /* Found a matching entry */
5387                         if (pri_entry->flags & FCP_PRIO_ENTRY_TAG_VALID)
5388                                 priority = pri_entry->tag;
5389                         break;
5390                 }
5391
5392                 pri_entry++;
5393         }
5394
5395         return priority;
5396 }
5397
5398 /*
5399  * qla24xx_update_fcport_fcp_prio
5400  *      Activates fcp priority for the logged in fc port
5401  *
5402  * Input:
5403  *      ha = adapter block pointer.
5404  *      fcp = port structure pointer.
5405  *
5406  * Return:
5407  *      QLA_SUCCESS or QLA_FUNCTION_FAILED
5408  *
5409  * Context:
5410  *      Kernel context.
5411  */
5412 int
5413 qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *ha, fc_port_t *fcport)
5414 {
5415         int ret;
5416         uint8_t priority;
5417         uint16_t mb[5];
5418
5419         if (atomic_read(&fcport->state) == FCS_UNCONFIGURED ||
5420                 fcport->port_type != FCT_TARGET ||
5421                 fcport->loop_id == FC_NO_LOOP_ID)
5422                 return QLA_FUNCTION_FAILED;
5423
5424         priority = qla24xx_get_fcp_prio(ha, fcport);
5425         ret = qla24xx_set_fcp_prio(ha, fcport->loop_id, priority, mb);
5426         if (ret == QLA_SUCCESS)
5427                 fcport->fcp_prio = priority;
5428         else
5429                 DEBUG2(printk(KERN_WARNING
5430                         "scsi(%ld): Unable to activate fcp priority, "
5431                         " ret=0x%x\n", ha->host_no, ret));
5432
5433         return  ret;
5434 }
5435
5436 /*
5437  * qla24xx_update_all_fcp_prio
5438  *      Activates fcp priority for all the logged in ports
5439  *
5440  * Input:
5441  *      ha = adapter block pointer.
5442  *
5443  * Return:
5444  *      QLA_SUCCESS or QLA_FUNCTION_FAILED
5445  *
5446  * Context:
5447  *      Kernel context.
5448  */
5449 int
5450 qla24xx_update_all_fcp_prio(scsi_qla_host_t *vha)
5451 {
5452         int ret;
5453         fc_port_t *fcport;
5454
5455         ret = QLA_FUNCTION_FAILED;
5456         /* We need to set priority for all logged in ports */
5457         list_for_each_entry(fcport, &vha->vp_fcports, list)
5458                 ret = qla24xx_update_fcport_fcp_prio(vha, fcport);
5459
5460         return ret;
5461 }