linux/drivers/scsi/qla2xxx/qla_init.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * QLogic Fibre Channel HBA Driver
   4 * Copyright (c)  2003-2014 QLogic Corporation
   5 */
   6#include "qla_def.h"
   7#include "qla_gbl.h"
   8
   9#include <linux/delay.h>
  10#include <linux/slab.h>
  11#include <linux/vmalloc.h>
  12
  13#include "qla_devtbl.h"
  14
  15#ifdef CONFIG_SPARC
  16#include <asm/prom.h>
  17#endif
  18
  19#include "qla_target.h"
  20
  21/*
  22*  QLogic ISP2x00 Hardware Support Function Prototypes.
  23*/
  24static int qla2x00_isp_firmware(scsi_qla_host_t *);
  25static int qla2x00_setup_chip(scsi_qla_host_t *);
  26static int qla2x00_fw_ready(scsi_qla_host_t *);
  27static int qla2x00_configure_hba(scsi_qla_host_t *);
  28static int qla2x00_configure_loop(scsi_qla_host_t *);
  29static int qla2x00_configure_local_loop(scsi_qla_host_t *);
  30static int qla2x00_configure_fabric(scsi_qla_host_t *);
  31static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *);
  32static int qla2x00_restart_isp(scsi_qla_host_t *);
  33
  34static struct qla_chip_state_84xx *qla84xx_get_chip(struct scsi_qla_host *);
  35static int qla84xx_init_chip(scsi_qla_host_t *);
  36static int qla25xx_init_queues(struct qla_hw_data *);
  37static int qla24xx_post_prli_work(struct scsi_qla_host*, fc_port_t *);
  38static void qla24xx_handle_gpdb_event(scsi_qla_host_t *vha,
  39                                      struct event_arg *ea);
  40static void qla24xx_handle_prli_done_event(struct scsi_qla_host *,
  41    struct event_arg *);
  42static void __qla24xx_handle_gpdb_event(scsi_qla_host_t *, struct event_arg *);
  43
  44/* SRB Extensions ---------------------------------------------------------- */
  45
  46void
  47qla2x00_sp_timeout(struct timer_list *t)
  48{
  49        srb_t *sp = from_timer(sp, t, u.iocb_cmd.timer);
  50        struct srb_iocb *iocb;
  51
  52        WARN_ON(irqs_disabled());
  53        iocb = &sp->u.iocb_cmd;
  54        iocb->timeout(sp);
  55}
  56
  57void qla2x00_sp_free(srb_t *sp)
  58{
  59        struct srb_iocb *iocb = &sp->u.iocb_cmd;
  60
  61        del_timer(&iocb->timer);
  62        qla2x00_rel_sp(sp);
  63}
  64
  65void qla2xxx_rel_done_warning(srb_t *sp, int res)
  66{
  67        WARN_ONCE(1, "Calling done() of an already freed srb %p object\n", sp);
  68}
  69
  70void qla2xxx_rel_free_warning(srb_t *sp)
  71{
  72        WARN_ONCE(1, "Calling free() of an already freed srb %p object\n", sp);
  73}
  74
  75/* Asynchronous Login/Logout Routines -------------------------------------- */
  76
  77unsigned long
  78qla2x00_get_async_timeout(struct scsi_qla_host *vha)
  79{
  80        unsigned long tmo;
  81        struct qla_hw_data *ha = vha->hw;
  82
  83        /* Firmware should use switch negotiated r_a_tov for timeout. */
  84        tmo = ha->r_a_tov / 10 * 2;
  85        if (IS_QLAFX00(ha)) {
  86                tmo = FX00_DEF_RATOV * 2;
  87        } else if (!IS_FWI2_CAPABLE(ha)) {
  88                /*
  89                 * Except for earlier ISPs where the timeout is seeded from the
  90                 * initialization control block.
  91                 */
  92                tmo = ha->login_timeout;
  93        }
  94        return tmo;
  95}
  96
  97static void qla24xx_abort_iocb_timeout(void *data)
  98{
  99        srb_t *sp = data;
 100        struct srb_iocb *abt = &sp->u.iocb_cmd;
 101        struct qla_qpair *qpair = sp->qpair;
 102        u32 handle;
 103        unsigned long flags;
 104
 105        if (sp->cmd_sp)
 106                ql_dbg(ql_dbg_async, sp->vha, 0x507c,
 107                    "Abort timeout - cmd hdl=%x, cmd type=%x hdl=%x, type=%x\n",
 108                    sp->cmd_sp->handle, sp->cmd_sp->type,
 109                    sp->handle, sp->type);
 110        else
 111                ql_dbg(ql_dbg_async, sp->vha, 0x507c,
 112                    "Abort timeout 2 - hdl=%x, type=%x\n",
 113                    sp->handle, sp->type);
 114
 115        spin_lock_irqsave(qpair->qp_lock_ptr, flags);
 116        for (handle = 1; handle < qpair->req->num_outstanding_cmds; handle++) {
 117                if (sp->cmd_sp && (qpair->req->outstanding_cmds[handle] ==
 118                    sp->cmd_sp))
 119                        qpair->req->outstanding_cmds[handle] = NULL;
 120
 121                /* removing the abort */
 122                if (qpair->req->outstanding_cmds[handle] == sp) {
 123                        qpair->req->outstanding_cmds[handle] = NULL;
 124                        break;
 125                }
 126        }
 127        spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
 128
 129        if (sp->cmd_sp)
 130                sp->cmd_sp->done(sp->cmd_sp, QLA_OS_TIMER_EXPIRED);
 131
 132        abt->u.abt.comp_status = cpu_to_le16(CS_TIMEOUT);
 133        sp->done(sp, QLA_OS_TIMER_EXPIRED);
 134}
 135
 136static void qla24xx_abort_sp_done(srb_t *sp, int res)
 137{
 138        struct srb_iocb *abt = &sp->u.iocb_cmd;
 139        srb_t *orig_sp = sp->cmd_sp;
 140
 141        if (orig_sp)
 142                qla_wait_nvme_release_cmd_kref(orig_sp);
 143
 144        del_timer(&sp->u.iocb_cmd.timer);
 145        if (sp->flags & SRB_WAKEUP_ON_COMP)
 146                complete(&abt->u.abt.comp);
 147        else
 148                sp->free(sp);
 149}
 150
 151int qla24xx_async_abort_cmd(srb_t *cmd_sp, bool wait)
 152{
 153        scsi_qla_host_t *vha = cmd_sp->vha;
 154        struct srb_iocb *abt_iocb;
 155        srb_t *sp;
 156        int rval = QLA_FUNCTION_FAILED;
 157
 158        sp = qla2xxx_get_qpair_sp(cmd_sp->vha, cmd_sp->qpair, cmd_sp->fcport,
 159                                  GFP_ATOMIC);
 160        if (!sp)
 161                return rval;
 162
 163        abt_iocb = &sp->u.iocb_cmd;
 164        sp->type = SRB_ABT_CMD;
 165        sp->name = "abort";
 166        sp->qpair = cmd_sp->qpair;
 167        sp->cmd_sp = cmd_sp;
 168        if (wait)
 169                sp->flags = SRB_WAKEUP_ON_COMP;
 170
 171        abt_iocb->timeout = qla24xx_abort_iocb_timeout;
 172        init_completion(&abt_iocb->u.abt.comp);
 173        /* FW can send 2 x ABTS's timeout/20s */
 174        qla2x00_init_timer(sp, 42);
 175
 176        abt_iocb->u.abt.cmd_hndl = cmd_sp->handle;
 177        abt_iocb->u.abt.req_que_no = cpu_to_le16(cmd_sp->qpair->req->id);
 178
 179        sp->done = qla24xx_abort_sp_done;
 180
 181        ql_dbg(ql_dbg_async, vha, 0x507c,
 182               "Abort command issued - hdl=%x, type=%x\n", cmd_sp->handle,
 183               cmd_sp->type);
 184
 185        rval = qla2x00_start_sp(sp);
 186        if (rval != QLA_SUCCESS) {
 187                sp->free(sp);
 188                return rval;
 189        }
 190
 191        if (wait) {
 192                wait_for_completion(&abt_iocb->u.abt.comp);
 193                rval = abt_iocb->u.abt.comp_status == CS_COMPLETE ?
 194                        QLA_SUCCESS : QLA_FUNCTION_FAILED;
 195                sp->free(sp);
 196        }
 197
 198        return rval;
 199}
 200
 201void
 202qla2x00_async_iocb_timeout(void *data)
 203{
 204        srb_t *sp = data;
 205        fc_port_t *fcport = sp->fcport;
 206        struct srb_iocb *lio = &sp->u.iocb_cmd;
 207        int rc, h;
 208        unsigned long flags;
 209
 210        if (fcport) {
 211                ql_dbg(ql_dbg_disc, fcport->vha, 0x2071,
 212                    "Async-%s timeout - hdl=%x portid=%06x %8phC.\n",
 213                    sp->name, sp->handle, fcport->d_id.b24, fcport->port_name);
 214
 215                fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 216        } else {
 217                pr_info("Async-%s timeout - hdl=%x.\n",
 218                    sp->name, sp->handle);
 219        }
 220
 221        switch (sp->type) {
 222        case SRB_LOGIN_CMD:
 223                rc = qla24xx_async_abort_cmd(sp, false);
 224                if (rc) {
 225                        /* Retry as needed. */
 226                        lio->u.logio.data[0] = MBS_COMMAND_ERROR;
 227                        lio->u.logio.data[1] =
 228                                lio->u.logio.flags & SRB_LOGIN_RETRIED ?
 229                                QLA_LOGIO_LOGIN_RETRIED : 0;
 230                        spin_lock_irqsave(sp->qpair->qp_lock_ptr, flags);
 231                        for (h = 1; h < sp->qpair->req->num_outstanding_cmds;
 232                            h++) {
 233                                if (sp->qpair->req->outstanding_cmds[h] ==
 234                                    sp) {
 235                                        sp->qpair->req->outstanding_cmds[h] =
 236                                            NULL;
 237                                        break;
 238                                }
 239                        }
 240                        spin_unlock_irqrestore(sp->qpair->qp_lock_ptr, flags);
 241                        sp->done(sp, QLA_FUNCTION_TIMEOUT);
 242                }
 243                break;
 244        case SRB_LOGOUT_CMD:
 245        case SRB_CT_PTHRU_CMD:
 246        case SRB_MB_IOCB:
 247        case SRB_NACK_PLOGI:
 248        case SRB_NACK_PRLI:
 249        case SRB_NACK_LOGO:
 250        case SRB_CTRL_VP:
 251        default:
 252                rc = qla24xx_async_abort_cmd(sp, false);
 253                if (rc) {
 254                        spin_lock_irqsave(sp->qpair->qp_lock_ptr, flags);
 255                        for (h = 1; h < sp->qpair->req->num_outstanding_cmds;
 256                            h++) {
 257                                if (sp->qpair->req->outstanding_cmds[h] ==
 258                                    sp) {
 259                                        sp->qpair->req->outstanding_cmds[h] =
 260                                            NULL;
 261                                        break;
 262                                }
 263                        }
 264                        spin_unlock_irqrestore(sp->qpair->qp_lock_ptr, flags);
 265                        sp->done(sp, QLA_FUNCTION_TIMEOUT);
 266                }
 267                break;
 268        }
 269}
 270
 271static void qla2x00_async_login_sp_done(srb_t *sp, int res)
 272{
 273        struct scsi_qla_host *vha = sp->vha;
 274        struct srb_iocb *lio = &sp->u.iocb_cmd;
 275        struct event_arg ea;
 276
 277        ql_dbg(ql_dbg_disc, vha, 0x20dd,
 278            "%s %8phC res %d \n", __func__, sp->fcport->port_name, res);
 279
 280        sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 281
 282        if (!test_bit(UNLOADING, &vha->dpc_flags)) {
 283                memset(&ea, 0, sizeof(ea));
 284                ea.fcport = sp->fcport;
 285                ea.data[0] = lio->u.logio.data[0];
 286                ea.data[1] = lio->u.logio.data[1];
 287                ea.iop[0] = lio->u.logio.iop[0];
 288                ea.iop[1] = lio->u.logio.iop[1];
 289                ea.sp = sp;
 290                qla24xx_handle_plogi_done_event(vha, &ea);
 291        }
 292
 293        sp->free(sp);
 294}
 295
 296static inline bool
 297fcport_is_smaller(fc_port_t *fcport)
 298{
 299        if (wwn_to_u64(fcport->port_name) <
 300            wwn_to_u64(fcport->vha->port_name))
 301                return true;
 302        else
 303                return false;
 304}
 305
 306static inline bool
 307fcport_is_bigger(fc_port_t *fcport)
 308{
 309        return !fcport_is_smaller(fcport);
 310}
 311
 312int
 313qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
 314    uint16_t *data)
 315{
 316        srb_t *sp;
 317        struct srb_iocb *lio;
 318        int rval = QLA_FUNCTION_FAILED;
 319
 320        if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT) ||
 321            fcport->loop_id == FC_NO_LOOP_ID) {
 322                ql_log(ql_log_warn, vha, 0xffff,
 323                    "%s: %8phC - not sending command.\n",
 324                    __func__, fcport->port_name);
 325                return rval;
 326        }
 327
 328        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 329        if (!sp)
 330                goto done;
 331
 332        qla2x00_set_fcport_disc_state(fcport, DSC_LOGIN_PEND);
 333        fcport->flags |= FCF_ASYNC_SENT;
 334        fcport->logout_completed = 0;
 335
 336        sp->type = SRB_LOGIN_CMD;
 337        sp->name = "login";
 338        sp->gen1 = fcport->rscn_gen;
 339        sp->gen2 = fcport->login_gen;
 340
 341        lio = &sp->u.iocb_cmd;
 342        lio->timeout = qla2x00_async_iocb_timeout;
 343        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 344
 345        sp->done = qla2x00_async_login_sp_done;
 346        if (N2N_TOPO(fcport->vha->hw) && fcport_is_bigger(fcport))
 347                lio->u.logio.flags |= SRB_LOGIN_PRLI_ONLY;
 348        else
 349                lio->u.logio.flags |= SRB_LOGIN_COND_PLOGI;
 350
 351        if (NVME_TARGET(vha->hw, fcport))
 352                lio->u.logio.flags |= SRB_LOGIN_SKIP_PRLI;
 353
 354        ql_log(ql_log_warn, vha, 0x2072,
 355               "Async-login - %8phC hdl=%x, loopid=%x portid=%02x%02x%02x retries=%d.\n",
 356               fcport->port_name, sp->handle, fcport->loop_id,
 357               fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
 358               fcport->login_retry);
 359
 360        rval = qla2x00_start_sp(sp);
 361        if (rval != QLA_SUCCESS) {
 362                fcport->flags |= FCF_LOGIN_NEEDED;
 363                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 364                goto done_free_sp;
 365        }
 366
 367        return rval;
 368
 369done_free_sp:
 370        sp->free(sp);
 371        fcport->flags &= ~FCF_ASYNC_SENT;
 372done:
 373        fcport->flags &= ~FCF_ASYNC_ACTIVE;
 374        return rval;
 375}
 376
 377static void qla2x00_async_logout_sp_done(srb_t *sp, int res)
 378{
 379        sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 380        sp->fcport->login_gen++;
 381        qlt_logo_completion_handler(sp->fcport, res);
 382        sp->free(sp);
 383}
 384
 385int
 386qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
 387{
 388        srb_t *sp;
 389        struct srb_iocb *lio;
 390        int rval = QLA_FUNCTION_FAILED;
 391
 392        fcport->flags |= FCF_ASYNC_SENT;
 393        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 394        if (!sp)
 395                goto done;
 396
 397        sp->type = SRB_LOGOUT_CMD;
 398        sp->name = "logout";
 399
 400        lio = &sp->u.iocb_cmd;
 401        lio->timeout = qla2x00_async_iocb_timeout;
 402        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 403
 404        sp->done = qla2x00_async_logout_sp_done;
 405
 406        ql_dbg(ql_dbg_disc, vha, 0x2070,
 407            "Async-logout - hdl=%x loop-id=%x portid=%02x%02x%02x %8phC.\n",
 408            sp->handle, fcport->loop_id, fcport->d_id.b.domain,
 409                fcport->d_id.b.area, fcport->d_id.b.al_pa,
 410                fcport->port_name);
 411
 412        rval = qla2x00_start_sp(sp);
 413        if (rval != QLA_SUCCESS)
 414                goto done_free_sp;
 415        return rval;
 416
 417done_free_sp:
 418        sp->free(sp);
 419done:
 420        fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 421        return rval;
 422}
 423
 424void
 425qla2x00_async_prlo_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 426    uint16_t *data)
 427{
 428        fcport->flags &= ~FCF_ASYNC_ACTIVE;
 429        /* Don't re-login in target mode */
 430        if (!fcport->tgt_session)
 431                qla2x00_mark_device_lost(vha, fcport, 1);
 432        qlt_logo_completion_handler(fcport, data[0]);
 433}
 434
 435static void qla2x00_async_prlo_sp_done(srb_t *sp, int res)
 436{
 437        struct srb_iocb *lio = &sp->u.iocb_cmd;
 438        struct scsi_qla_host *vha = sp->vha;
 439
 440        sp->fcport->flags &= ~FCF_ASYNC_ACTIVE;
 441        if (!test_bit(UNLOADING, &vha->dpc_flags))
 442                qla2x00_post_async_prlo_done_work(sp->fcport->vha, sp->fcport,
 443                    lio->u.logio.data);
 444        sp->free(sp);
 445}
 446
 447int
 448qla2x00_async_prlo(struct scsi_qla_host *vha, fc_port_t *fcport)
 449{
 450        srb_t *sp;
 451        struct srb_iocb *lio;
 452        int rval;
 453
 454        rval = QLA_FUNCTION_FAILED;
 455        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 456        if (!sp)
 457                goto done;
 458
 459        sp->type = SRB_PRLO_CMD;
 460        sp->name = "prlo";
 461
 462        lio = &sp->u.iocb_cmd;
 463        lio->timeout = qla2x00_async_iocb_timeout;
 464        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 465
 466        sp->done = qla2x00_async_prlo_sp_done;
 467
 468        ql_dbg(ql_dbg_disc, vha, 0x2070,
 469            "Async-prlo - hdl=%x loop-id=%x portid=%02x%02x%02x.\n",
 470            sp->handle, fcport->loop_id, fcport->d_id.b.domain,
 471            fcport->d_id.b.area, fcport->d_id.b.al_pa);
 472
 473        rval = qla2x00_start_sp(sp);
 474        if (rval != QLA_SUCCESS)
 475                goto done_free_sp;
 476
 477        return rval;
 478
 479done_free_sp:
 480        sp->free(sp);
 481done:
 482        fcport->flags &= ~FCF_ASYNC_ACTIVE;
 483        return rval;
 484}
 485
 486static
 487void qla24xx_handle_adisc_event(scsi_qla_host_t *vha, struct event_arg *ea)
 488{
 489        struct fc_port *fcport = ea->fcport;
 490
 491        ql_dbg(ql_dbg_disc, vha, 0x20d2,
 492            "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d lid %d\n",
 493            __func__, fcport->port_name, fcport->disc_state,
 494            fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
 495            fcport->rscn_gen, ea->sp->gen1, fcport->loop_id);
 496
 497        WARN_ONCE(!qla2xxx_is_valid_mbs(ea->data[0]), "mbs: %#x\n",
 498                  ea->data[0]);
 499
 500        if (ea->data[0] != MBS_COMMAND_COMPLETE) {
 501                ql_dbg(ql_dbg_disc, vha, 0x2066,
 502                    "%s %8phC: adisc fail: post delete\n",
 503                    __func__, ea->fcport->port_name);
 504                /* deleted = 0 & logout_on_delete = force fw cleanup */
 505                fcport->deleted = 0;
 506                fcport->logout_on_delete = 1;
 507                qlt_schedule_sess_for_deletion(ea->fcport);
 508                return;
 509        }
 510
 511        if (ea->fcport->disc_state == DSC_DELETE_PEND)
 512                return;
 513
 514        if (ea->sp->gen2 != ea->fcport->login_gen) {
 515                /* target side must have changed it. */
 516                ql_dbg(ql_dbg_disc, vha, 0x20d3,
 517                    "%s %8phC generation changed\n",
 518                    __func__, ea->fcport->port_name);
 519                return;
 520        } else if (ea->sp->gen1 != ea->fcport->rscn_gen) {
 521                qla_rscn_replay(fcport);
 522                qlt_schedule_sess_for_deletion(fcport);
 523                return;
 524        }
 525
 526        __qla24xx_handle_gpdb_event(vha, ea);
 527}
 528
 529static int qla_post_els_plogi_work(struct scsi_qla_host *vha, fc_port_t *fcport)
 530{
 531        struct qla_work_evt *e;
 532
 533        e = qla2x00_alloc_work(vha, QLA_EVT_ELS_PLOGI);
 534        if (!e)
 535                return QLA_FUNCTION_FAILED;
 536
 537        e->u.fcport.fcport = fcport;
 538        fcport->flags |= FCF_ASYNC_ACTIVE;
 539        qla2x00_set_fcport_disc_state(fcport, DSC_LOGIN_PEND);
 540        return qla2x00_post_work(vha, e);
 541}
 542
 543static void qla2x00_async_adisc_sp_done(srb_t *sp, int res)
 544{
 545        struct scsi_qla_host *vha = sp->vha;
 546        struct event_arg ea;
 547        struct srb_iocb *lio = &sp->u.iocb_cmd;
 548
 549        ql_dbg(ql_dbg_disc, vha, 0x2066,
 550            "Async done-%s res %x %8phC\n",
 551            sp->name, res, sp->fcport->port_name);
 552
 553        sp->fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 554
 555        memset(&ea, 0, sizeof(ea));
 556        ea.rc = res;
 557        ea.data[0] = lio->u.logio.data[0];
 558        ea.data[1] = lio->u.logio.data[1];
 559        ea.iop[0] = lio->u.logio.iop[0];
 560        ea.iop[1] = lio->u.logio.iop[1];
 561        ea.fcport = sp->fcport;
 562        ea.sp = sp;
 563
 564        qla24xx_handle_adisc_event(vha, &ea);
 565
 566        sp->free(sp);
 567}
 568
 569int
 570qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
 571    uint16_t *data)
 572{
 573        srb_t *sp;
 574        struct srb_iocb *lio;
 575        int rval = QLA_FUNCTION_FAILED;
 576
 577        if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
 578                return rval;
 579
 580        fcport->flags |= FCF_ASYNC_SENT;
 581        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 582        if (!sp)
 583                goto done;
 584
 585        sp->type = SRB_ADISC_CMD;
 586        sp->name = "adisc";
 587
 588        lio = &sp->u.iocb_cmd;
 589        lio->timeout = qla2x00_async_iocb_timeout;
 590        sp->gen1 = fcport->rscn_gen;
 591        sp->gen2 = fcport->login_gen;
 592        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 593
 594        sp->done = qla2x00_async_adisc_sp_done;
 595        if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
 596                lio->u.logio.flags |= SRB_LOGIN_RETRIED;
 597
 598        ql_dbg(ql_dbg_disc, vha, 0x206f,
 599            "Async-adisc - hdl=%x loopid=%x portid=%06x %8phC.\n",
 600            sp->handle, fcport->loop_id, fcport->d_id.b24, fcport->port_name);
 601
 602        rval = qla2x00_start_sp(sp);
 603        if (rval != QLA_SUCCESS)
 604                goto done_free_sp;
 605
 606        return rval;
 607
 608done_free_sp:
 609        sp->free(sp);
 610done:
 611        fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
 612        qla2x00_post_async_adisc_work(vha, fcport, data);
 613        return rval;
 614}
 615
 616static bool qla2x00_is_reserved_id(scsi_qla_host_t *vha, uint16_t loop_id)
 617{
 618        struct qla_hw_data *ha = vha->hw;
 619
 620        if (IS_FWI2_CAPABLE(ha))
 621                return loop_id > NPH_LAST_HANDLE;
 622
 623        return (loop_id > ha->max_loop_id && loop_id < SNS_FIRST_LOOP_ID) ||
 624                loop_id == MANAGEMENT_SERVER || loop_id == BROADCAST;
 625}
 626
 627/**
 628 * qla2x00_find_new_loop_id - scan through our port list and find a new usable loop ID
 629 * @vha: adapter state pointer.
 630 * @dev: port structure pointer.
 631 *
 632 * Returns:
 633 *      qla2x00 local function return status code.
 634 *
 635 * Context:
 636 *      Kernel context.
 637 */
 638static int qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
 639{
 640        int     rval;
 641        struct qla_hw_data *ha = vha->hw;
 642        unsigned long flags = 0;
 643
 644        rval = QLA_SUCCESS;
 645
 646        spin_lock_irqsave(&ha->vport_slock, flags);
 647
 648        dev->loop_id = find_first_zero_bit(ha->loop_id_map, LOOPID_MAP_SIZE);
 649        if (dev->loop_id >= LOOPID_MAP_SIZE ||
 650            qla2x00_is_reserved_id(vha, dev->loop_id)) {
 651                dev->loop_id = FC_NO_LOOP_ID;
 652                rval = QLA_FUNCTION_FAILED;
 653        } else {
 654                set_bit(dev->loop_id, ha->loop_id_map);
 655        }
 656        spin_unlock_irqrestore(&ha->vport_slock, flags);
 657
 658        if (rval == QLA_SUCCESS)
 659                ql_dbg(ql_dbg_disc, dev->vha, 0x2086,
 660                       "Assigning new loopid=%x, portid=%x.\n",
 661                       dev->loop_id, dev->d_id.b24);
 662        else
 663                ql_log(ql_log_warn, dev->vha, 0x2087,
 664                       "No loop_id's available, portid=%x.\n",
 665                       dev->d_id.b24);
 666
 667        return rval;
 668}
 669
 670void qla2x00_clear_loop_id(fc_port_t *fcport)
 671{
 672        struct qla_hw_data *ha = fcport->vha->hw;
 673
 674        if (fcport->loop_id == FC_NO_LOOP_ID ||
 675            qla2x00_is_reserved_id(fcport->vha, fcport->loop_id))
 676                return;
 677
 678        clear_bit(fcport->loop_id, ha->loop_id_map);
 679        fcport->loop_id = FC_NO_LOOP_ID;
 680}
 681
 682static void qla24xx_handle_gnl_done_event(scsi_qla_host_t *vha,
 683        struct event_arg *ea)
 684{
 685        fc_port_t *fcport, *conflict_fcport;
 686        struct get_name_list_extended *e;
 687        u16 i, n, found = 0, loop_id;
 688        port_id_t id;
 689        u64 wwn;
 690        u16 data[2];
 691        u8 current_login_state, nvme_cls;
 692
 693        fcport = ea->fcport;
 694        ql_dbg(ql_dbg_disc, vha, 0xffff,
 695            "%s %8phC DS %d LS rc %d %d login %d|%d rscn %d|%d lid %d\n",
 696            __func__, fcport->port_name, fcport->disc_state,
 697            fcport->fw_login_state, ea->rc,
 698            fcport->login_gen, fcport->last_login_gen,
 699            fcport->rscn_gen, fcport->last_rscn_gen, vha->loop_id);
 700
 701        if (fcport->disc_state == DSC_DELETE_PEND)
 702                return;
 703
 704        if (ea->rc) { /* rval */
 705                if (fcport->login_retry == 0) {
 706                        ql_dbg(ql_dbg_disc, vha, 0x20de,
 707                            "GNL failed Port login retry %8phN, retry cnt=%d.\n",
 708                            fcport->port_name, fcport->login_retry);
 709                }
 710                return;
 711        }
 712
 713        if (fcport->last_rscn_gen != fcport->rscn_gen) {
 714                qla_rscn_replay(fcport);
 715                qlt_schedule_sess_for_deletion(fcport);
 716                return;
 717        } else if (fcport->last_login_gen != fcport->login_gen) {
 718                ql_dbg(ql_dbg_disc, vha, 0x20e0,
 719                    "%s %8phC login gen changed\n",
 720                    __func__, fcport->port_name);
 721                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 722                return;
 723        }
 724
 725        n = ea->data[0] / sizeof(struct get_name_list_extended);
 726
 727        ql_dbg(ql_dbg_disc, vha, 0x20e1,
 728            "%s %d %8phC n %d %02x%02x%02x lid %d \n",
 729            __func__, __LINE__, fcport->port_name, n,
 730            fcport->d_id.b.domain, fcport->d_id.b.area,
 731            fcport->d_id.b.al_pa, fcport->loop_id);
 732
 733        for (i = 0; i < n; i++) {
 734                e = &vha->gnl.l[i];
 735                wwn = wwn_to_u64(e->port_name);
 736                id.b.domain = e->port_id[2];
 737                id.b.area = e->port_id[1];
 738                id.b.al_pa = e->port_id[0];
 739                id.b.rsvd_1 = 0;
 740
 741                if (memcmp((u8 *)&wwn, fcport->port_name, WWN_SIZE))
 742                        continue;
 743
 744                if (IS_SW_RESV_ADDR(id))
 745                        continue;
 746
 747                found = 1;
 748
 749                loop_id = le16_to_cpu(e->nport_handle);
 750                loop_id = (loop_id & 0x7fff);
 751                nvme_cls = e->current_login_state >> 4;
 752                current_login_state = e->current_login_state & 0xf;
 753
 754                if (PRLI_PHASE(nvme_cls)) {
 755                        current_login_state = nvme_cls;
 756                        fcport->fc4_type &= ~FS_FC4TYPE_FCP;
 757                        fcport->fc4_type |= FS_FC4TYPE_NVME;
 758                } else if (PRLI_PHASE(current_login_state)) {
 759                        fcport->fc4_type |= FS_FC4TYPE_FCP;
 760                        fcport->fc4_type &= ~FS_FC4TYPE_NVME;
 761                }
 762
 763                ql_dbg(ql_dbg_disc, vha, 0x20e2,
 764                    "%s found %8phC CLS [%x|%x] fc4_type %d ID[%06x|%06x] lid[%d|%d]\n",
 765                    __func__, fcport->port_name,
 766                    e->current_login_state, fcport->fw_login_state,
 767                    fcport->fc4_type, id.b24, fcport->d_id.b24,
 768                    loop_id, fcport->loop_id);
 769
 770                switch (fcport->disc_state) {
 771                case DSC_DELETE_PEND:
 772                case DSC_DELETED:
 773                        break;
 774                default:
 775                        if ((id.b24 != fcport->d_id.b24 &&
 776                            fcport->d_id.b24 &&
 777                            fcport->loop_id != FC_NO_LOOP_ID) ||
 778                            (fcport->loop_id != FC_NO_LOOP_ID &&
 779                                fcport->loop_id != loop_id)) {
 780                                ql_dbg(ql_dbg_disc, vha, 0x20e3,
 781                                    "%s %d %8phC post del sess\n",
 782                                    __func__, __LINE__, fcport->port_name);
 783                                if (fcport->n2n_flag)
 784                                        fcport->d_id.b24 = 0;
 785                                qlt_schedule_sess_for_deletion(fcport);
 786                                return;
 787                        }
 788                        break;
 789                }
 790
 791                fcport->loop_id = loop_id;
 792                if (fcport->n2n_flag)
 793                        fcport->d_id.b24 = id.b24;
 794
 795                wwn = wwn_to_u64(fcport->port_name);
 796                qlt_find_sess_invalidate_other(vha, wwn,
 797                        id, loop_id, &conflict_fcport);
 798
 799                if (conflict_fcport) {
 800                        /*
 801                         * Another share fcport share the same loop_id &
 802                         * nport id. Conflict fcport needs to finish
 803                         * cleanup before this fcport can proceed to login.
 804                         */
 805                        conflict_fcport->conflict = fcport;
 806                        fcport->login_pause = 1;
 807                }
 808
 809                switch (vha->hw->current_topology) {
 810                default:
 811                        switch (current_login_state) {
 812                        case DSC_LS_PRLI_COMP:
 813                                ql_dbg(ql_dbg_disc + ql_dbg_verbose,
 814                                    vha, 0x20e4, "%s %d %8phC post gpdb\n",
 815                                    __func__, __LINE__, fcport->port_name);
 816
 817                                if ((e->prli_svc_param_word_3[0] & BIT_4) == 0)
 818                                        fcport->port_type = FCT_INITIATOR;
 819                                else
 820                                        fcport->port_type = FCT_TARGET;
 821                                data[0] = data[1] = 0;
 822                                qla2x00_post_async_adisc_work(vha, fcport,
 823                                    data);
 824                                break;
 825                        case DSC_LS_PORT_UNAVAIL:
 826                        default:
 827                                if (fcport->loop_id == FC_NO_LOOP_ID) {
 828                                        qla2x00_find_new_loop_id(vha, fcport);
 829                                        fcport->fw_login_state =
 830                                            DSC_LS_PORT_UNAVAIL;
 831                                }
 832                                ql_dbg(ql_dbg_disc, vha, 0x20e5,
 833                                    "%s %d %8phC\n", __func__, __LINE__,
 834                                    fcport->port_name);
 835                                qla24xx_fcport_handle_login(vha, fcport);
 836                                break;
 837                        }
 838                        break;
 839                case ISP_CFG_N:
 840                        fcport->fw_login_state = current_login_state;
 841                        fcport->d_id = id;
 842                        switch (current_login_state) {
 843                        case DSC_LS_PRLI_PEND:
 844                                /*
 845                                 * In the middle of PRLI. Let it finish.
 846                                 * Allow relogin code to recheck state again
 847                                 * with GNL. Push disc_state back to DELETED
 848                                 * so GNL can go out again
 849                                 */
 850                                qla2x00_set_fcport_disc_state(fcport,
 851                                    DSC_DELETED);
 852                                break;
 853                        case DSC_LS_PRLI_COMP:
 854                                if ((e->prli_svc_param_word_3[0] & BIT_4) == 0)
 855                                        fcport->port_type = FCT_INITIATOR;
 856                                else
 857                                        fcport->port_type = FCT_TARGET;
 858
 859                                data[0] = data[1] = 0;
 860                                qla2x00_post_async_adisc_work(vha, fcport,
 861                                    data);
 862                                break;
 863                        case DSC_LS_PLOGI_COMP:
 864                                if (fcport_is_bigger(fcport)) {
 865                                        /* local adapter is smaller */
 866                                        if (fcport->loop_id != FC_NO_LOOP_ID)
 867                                                qla2x00_clear_loop_id(fcport);
 868
 869                                        fcport->loop_id = loop_id;
 870                                        qla24xx_fcport_handle_login(vha,
 871                                            fcport);
 872                                        break;
 873                                }
 874                                fallthrough;
 875                        default:
 876                                if (fcport_is_smaller(fcport)) {
 877                                        /* local adapter is bigger */
 878                                        if (fcport->loop_id != FC_NO_LOOP_ID)
 879                                                qla2x00_clear_loop_id(fcport);
 880
 881                                        fcport->loop_id = loop_id;
 882                                        qla24xx_fcport_handle_login(vha,
 883                                            fcport);
 884                                }
 885                                break;
 886                        }
 887                        break;
 888                } /* switch (ha->current_topology) */
 889        }
 890
 891        if (!found) {
 892                switch (vha->hw->current_topology) {
 893                case ISP_CFG_F:
 894                case ISP_CFG_FL:
 895                        for (i = 0; i < n; i++) {
 896                                e = &vha->gnl.l[i];
 897                                id.b.domain = e->port_id[0];
 898                                id.b.area = e->port_id[1];
 899                                id.b.al_pa = e->port_id[2];
 900                                id.b.rsvd_1 = 0;
 901                                loop_id = le16_to_cpu(e->nport_handle);
 902
 903                                if (fcport->d_id.b24 == id.b24) {
 904                                        conflict_fcport =
 905                                            qla2x00_find_fcport_by_wwpn(vha,
 906                                                e->port_name, 0);
 907                                        if (conflict_fcport) {
 908                                                ql_dbg(ql_dbg_disc + ql_dbg_verbose,
 909                                                    vha, 0x20e5,
 910                                                    "%s %d %8phC post del sess\n",
 911                                                    __func__, __LINE__,
 912                                                    conflict_fcport->port_name);
 913                                                qlt_schedule_sess_for_deletion
 914                                                        (conflict_fcport);
 915                                        }
 916                                }
 917                                /*
 918                                 * FW already picked this loop id for
 919                                 * another fcport
 920                                 */
 921                                if (fcport->loop_id == loop_id)
 922                                        fcport->loop_id = FC_NO_LOOP_ID;
 923                        }
 924                        qla24xx_fcport_handle_login(vha, fcport);
 925                        break;
 926                case ISP_CFG_N:
 927                        qla2x00_set_fcport_disc_state(fcport, DSC_DELETED);
 928                        if (time_after_eq(jiffies, fcport->dm_login_expire)) {
 929                                if (fcport->n2n_link_reset_cnt < 2) {
 930                                        fcport->n2n_link_reset_cnt++;
 931                                        /*
 932                                         * remote port is not sending PLOGI.
 933                                         * Reset link to kick start his state
 934                                         * machine
 935                                         */
 936                                        set_bit(N2N_LINK_RESET,
 937                                            &vha->dpc_flags);
 938                                } else {
 939                                        if (fcport->n2n_chip_reset < 1) {
 940                                                ql_log(ql_log_info, vha, 0x705d,
 941                                                    "Chip reset to bring laser down");
 942                                                set_bit(ISP_ABORT_NEEDED,
 943                                                    &vha->dpc_flags);
 944                                                fcport->n2n_chip_reset++;
 945                                        } else {
 946                                                ql_log(ql_log_info, vha, 0x705d,
 947                                                    "Remote port %8ph is not coming back\n",
 948                                                    fcport->port_name);
 949                                                fcport->scan_state = 0;
 950                                        }
 951                                }
 952                                qla2xxx_wake_dpc(vha);
 953                        } else {
 954                                /*
 955                                 * report port suppose to do PLOGI. Give him
 956                                 * more time. FW will catch it.
 957                                 */
 958                                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 959                        }
 960                        break;
 961                default:
 962                        break;
 963                }
 964        }
 965} /* gnl_event */
 966
 967static void qla24xx_async_gnl_sp_done(srb_t *sp, int res)
 968{
 969        struct scsi_qla_host *vha = sp->vha;
 970        unsigned long flags;
 971        struct fc_port *fcport = NULL, *tf;
 972        u16 i, n = 0, loop_id;
 973        struct event_arg ea;
 974        struct get_name_list_extended *e;
 975        u64 wwn;
 976        struct list_head h;
 977        bool found = false;
 978
 979        ql_dbg(ql_dbg_disc, vha, 0x20e7,
 980            "Async done-%s res %x mb[1]=%x mb[2]=%x \n",
 981            sp->name, res, sp->u.iocb_cmd.u.mbx.in_mb[1],
 982            sp->u.iocb_cmd.u.mbx.in_mb[2]);
 983
 984        if (res == QLA_FUNCTION_TIMEOUT)
 985                return;
 986
 987        sp->fcport->flags &= ~(FCF_ASYNC_SENT|FCF_ASYNC_ACTIVE);
 988        memset(&ea, 0, sizeof(ea));
 989        ea.sp = sp;
 990        ea.rc = res;
 991
 992        if (sp->u.iocb_cmd.u.mbx.in_mb[1] >=
 993            sizeof(struct get_name_list_extended)) {
 994                n = sp->u.iocb_cmd.u.mbx.in_mb[1] /
 995                    sizeof(struct get_name_list_extended);
 996                ea.data[0] = sp->u.iocb_cmd.u.mbx.in_mb[1]; /* amnt xfered */
 997        }
 998
 999        for (i = 0; i < n; i++) {
1000                e = &vha->gnl.l[i];
1001                loop_id = le16_to_cpu(e->nport_handle);
1002                /* mask out reserve bit */
1003                loop_id = (loop_id & 0x7fff);
1004                set_bit(loop_id, vha->hw->loop_id_map);
1005                wwn = wwn_to_u64(e->port_name);
1006
1007                ql_dbg(ql_dbg_disc, vha, 0x20e8,
1008                    "%s %8phC %02x:%02x:%02x CLS %x/%x lid %x \n",
1009                    __func__, &wwn, e->port_id[2], e->port_id[1],
1010                    e->port_id[0], e->current_login_state, e->last_login_state,
1011                    (loop_id & 0x7fff));
1012        }
1013
1014        spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1015
1016        INIT_LIST_HEAD(&h);
1017        fcport = tf = NULL;
1018        if (!list_empty(&vha->gnl.fcports))
1019                list_splice_init(&vha->gnl.fcports, &h);
1020        spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1021
1022        list_for_each_entry_safe(fcport, tf, &h, gnl_entry) {
1023                list_del_init(&fcport->gnl_entry);
1024                spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1025                fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
1026                spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1027                ea.fcport = fcport;
1028
1029                qla24xx_handle_gnl_done_event(vha, &ea);
1030        }
1031
1032        /* create new fcport if fw has knowledge of new sessions */
1033        for (i = 0; i < n; i++) {
1034                port_id_t id;
1035                u64 wwnn;
1036
1037                e = &vha->gnl.l[i];
1038                wwn = wwn_to_u64(e->port_name);
1039
1040                found = false;
1041                list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list) {
1042                        if (!memcmp((u8 *)&wwn, fcport->port_name,
1043                            WWN_SIZE)) {
1044                                found = true;
1045                                break;
1046                        }
1047                }
1048
1049                id.b.domain = e->port_id[2];
1050                id.b.area = e->port_id[1];
1051                id.b.al_pa = e->port_id[0];
1052                id.b.rsvd_1 = 0;
1053
1054                if (!found && wwn && !IS_SW_RESV_ADDR(id)) {
1055                        ql_dbg(ql_dbg_disc, vha, 0x2065,
1056                            "%s %d %8phC %06x post new sess\n",
1057                            __func__, __LINE__, (u8 *)&wwn, id.b24);
1058                        wwnn = wwn_to_u64(e->node_name);
1059                        qla24xx_post_newsess_work(vha, &id, (u8 *)&wwn,
1060                            (u8 *)&wwnn, NULL, 0);
1061                }
1062        }
1063
1064        spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1065        vha->gnl.sent = 0;
1066        if (!list_empty(&vha->gnl.fcports)) {
1067                /* retrigger gnl */
1068                list_for_each_entry_safe(fcport, tf, &vha->gnl.fcports,
1069                    gnl_entry) {
1070                        list_del_init(&fcport->gnl_entry);
1071                        fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
1072                        if (qla24xx_post_gnl_work(vha, fcport) == QLA_SUCCESS)
1073                                break;
1074                }
1075        }
1076        spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1077
1078        sp->free(sp);
1079}
1080
1081int qla24xx_async_gnl(struct scsi_qla_host *vha, fc_port_t *fcport)
1082{
1083        srb_t *sp;
1084        struct srb_iocb *mbx;
1085        int rval = QLA_FUNCTION_FAILED;
1086        unsigned long flags;
1087        u16 *mb;
1088
1089        if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
1090                return rval;
1091
1092        ql_dbg(ql_dbg_disc, vha, 0x20d9,
1093            "Async-gnlist WWPN %8phC \n", fcport->port_name);
1094
1095        spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1096        fcport->flags |= FCF_ASYNC_SENT;
1097        qla2x00_set_fcport_disc_state(fcport, DSC_GNL);
1098        fcport->last_rscn_gen = fcport->rscn_gen;
1099        fcport->last_login_gen = fcport->login_gen;
1100
1101        list_add_tail(&fcport->gnl_entry, &vha->gnl.fcports);
1102        if (vha->gnl.sent) {
1103                spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1104                return QLA_SUCCESS;
1105        }
1106        vha->gnl.sent = 1;
1107        spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1108
1109        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
1110        if (!sp)
1111                goto done;
1112
1113        sp->type = SRB_MB_IOCB;
1114        sp->name = "gnlist";
1115        sp->gen1 = fcport->rscn_gen;
1116        sp->gen2 = fcport->login_gen;
1117
1118        mbx = &sp->u.iocb_cmd;
1119        mbx->timeout = qla2x00_async_iocb_timeout;
1120        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha)+2);
1121
1122        mb = sp->u.iocb_cmd.u.mbx.out_mb;
1123        mb[0] = MBC_PORT_NODE_NAME_LIST;
1124        mb[1] = BIT_2 | BIT_3;
1125        mb[2] = MSW(vha->gnl.ldma);
1126        mb[3] = LSW(vha->gnl.ldma);
1127        mb[6] = MSW(MSD(vha->gnl.ldma));
1128        mb[7] = LSW(MSD(vha->gnl.ldma));
1129        mb[8] = vha->gnl.size;
1130        mb[9] = vha->vp_idx;
1131
1132        sp->done = qla24xx_async_gnl_sp_done;
1133
1134        ql_dbg(ql_dbg_disc, vha, 0x20da,
1135            "Async-%s - OUT WWPN %8phC hndl %x\n",
1136            sp->name, fcport->port_name, sp->handle);
1137
1138        rval = qla2x00_start_sp(sp);
1139        if (rval != QLA_SUCCESS)
1140                goto done_free_sp;
1141
1142        return rval;
1143
1144done_free_sp:
1145        sp->free(sp);
1146done:
1147        fcport->flags &= ~(FCF_ASYNC_ACTIVE | FCF_ASYNC_SENT);
1148        return rval;
1149}
1150
1151int qla24xx_post_gnl_work(struct scsi_qla_host *vha, fc_port_t *fcport)
1152{
1153        struct qla_work_evt *e;
1154
1155        e = qla2x00_alloc_work(vha, QLA_EVT_GNL);
1156        if (!e)
1157                return QLA_FUNCTION_FAILED;
1158
1159        e->u.fcport.fcport = fcport;
1160        fcport->flags |= FCF_ASYNC_ACTIVE;
1161        return qla2x00_post_work(vha, e);
1162}
1163
1164static void qla24xx_async_gpdb_sp_done(srb_t *sp, int res)
1165{
1166        struct scsi_qla_host *vha = sp->vha;
1167        struct qla_hw_data *ha = vha->hw;
1168        fc_port_t *fcport = sp->fcport;
1169        u16 *mb = sp->u.iocb_cmd.u.mbx.in_mb;
1170        struct event_arg ea;
1171
1172        ql_dbg(ql_dbg_disc, vha, 0x20db,
1173            "Async done-%s res %x, WWPN %8phC mb[1]=%x mb[2]=%x \n",
1174            sp->name, res, fcport->port_name, mb[1], mb[2]);
1175
1176        fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
1177
1178        if (res == QLA_FUNCTION_TIMEOUT)
1179                goto done;
1180
1181        memset(&ea, 0, sizeof(ea));
1182        ea.fcport = fcport;
1183        ea.sp = sp;
1184
1185        qla24xx_handle_gpdb_event(vha, &ea);
1186
1187done:
1188        dma_pool_free(ha->s_dma_pool, sp->u.iocb_cmd.u.mbx.in,
1189                sp->u.iocb_cmd.u.mbx.in_dma);
1190
1191        sp->free(sp);
1192}
1193
1194static int qla24xx_post_prli_work(struct scsi_qla_host *vha, fc_port_t *fcport)
1195{
1196        struct qla_work_evt *e;
1197
1198        if (vha->host->active_mode == MODE_TARGET)
1199                return QLA_FUNCTION_FAILED;
1200
1201        e = qla2x00_alloc_work(vha, QLA_EVT_PRLI);
1202        if (!e)
1203                return QLA_FUNCTION_FAILED;
1204
1205        e->u.fcport.fcport = fcport;
1206
1207        return qla2x00_post_work(vha, e);
1208}
1209
1210static void qla2x00_async_prli_sp_done(srb_t *sp, int res)
1211{
1212        struct scsi_qla_host *vha = sp->vha;
1213        struct srb_iocb *lio = &sp->u.iocb_cmd;
1214        struct event_arg ea;
1215
1216        ql_dbg(ql_dbg_disc, vha, 0x2129,
1217            "%s %8phC res %d \n", __func__,
1218            sp->fcport->port_name, res);
1219
1220        sp->fcport->flags &= ~FCF_ASYNC_SENT;
1221
1222        if (!test_bit(UNLOADING, &vha->dpc_flags)) {
1223                memset(&ea, 0, sizeof(ea));
1224                ea.fcport = sp->fcport;
1225                ea.data[0] = lio->u.logio.data[0];
1226                ea.data[1] = lio->u.logio.data[1];
1227                ea.iop[0] = lio->u.logio.iop[0];
1228                ea.iop[1] = lio->u.logio.iop[1];
1229                ea.sp = sp;
1230
1231                qla24xx_handle_prli_done_event(vha, &ea);
1232        }
1233
1234        sp->free(sp);
1235}
1236
1237int
1238qla24xx_async_prli(struct scsi_qla_host *vha, fc_port_t *fcport)
1239{
1240        srb_t *sp;
1241        struct srb_iocb *lio;
1242        int rval = QLA_FUNCTION_FAILED;
1243
1244        if (!vha->flags.online) {
1245                ql_dbg(ql_dbg_disc, vha, 0xffff, "%s %d %8phC exit\n",
1246                    __func__, __LINE__, fcport->port_name);
1247                return rval;
1248        }
1249
1250        if ((fcport->fw_login_state == DSC_LS_PLOGI_PEND ||
1251            fcport->fw_login_state == DSC_LS_PRLI_PEND) &&
1252            qla_dual_mode_enabled(vha)) {
1253                ql_dbg(ql_dbg_disc, vha, 0xffff, "%s %d %8phC exit\n",
1254                    __func__, __LINE__, fcport->port_name);
1255                return rval;
1256        }
1257
1258        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
1259        if (!sp)
1260                return rval;
1261
1262        fcport->flags |= FCF_ASYNC_SENT;
1263        fcport->logout_completed = 0;
1264
1265        sp->type = SRB_PRLI_CMD;
1266        sp->name = "prli";
1267
1268        lio = &sp->u.iocb_cmd;
1269        lio->timeout = qla2x00_async_iocb_timeout;
1270        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
1271
1272        sp->done = qla2x00_async_prli_sp_done;
1273        lio->u.logio.flags = 0;
1274
1275        if (NVME_TARGET(vha->hw, fcport))
1276                lio->u.logio.flags |= SRB_LOGIN_NVME_PRLI;
1277
1278        ql_dbg(ql_dbg_disc, vha, 0x211b,
1279            "Async-prli - %8phC hdl=%x, loopid=%x portid=%06x retries=%d fc4type %x priority %x %s.\n",
1280            fcport->port_name, sp->handle, fcport->loop_id, fcport->d_id.b24,
1281            fcport->login_retry, fcport->fc4_type, vha->hw->fc4_type_priority,
1282            NVME_TARGET(vha->hw, fcport) ? "nvme" : "fcp");
1283
1284        rval = qla2x00_start_sp(sp);
1285        if (rval != QLA_SUCCESS) {
1286                fcport->flags |= FCF_LOGIN_NEEDED;
1287                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1288                goto done_free_sp;
1289        }
1290
1291        return rval;
1292
1293done_free_sp:
1294        sp->free(sp);
1295        fcport->flags &= ~FCF_ASYNC_SENT;
1296        return rval;
1297}
1298
1299int qla24xx_post_gpdb_work(struct scsi_qla_host *vha, fc_port_t *fcport, u8 opt)
1300{
1301        struct qla_work_evt *e;
1302
1303        e = qla2x00_alloc_work(vha, QLA_EVT_GPDB);
1304        if (!e)
1305                return QLA_FUNCTION_FAILED;
1306
1307        e->u.fcport.fcport = fcport;
1308        e->u.fcport.opt = opt;
1309        fcport->flags |= FCF_ASYNC_ACTIVE;
1310        return qla2x00_post_work(vha, e);
1311}
1312
1313int qla24xx_async_gpdb(struct scsi_qla_host *vha, fc_port_t *fcport, u8 opt)
1314{
1315        srb_t *sp;
1316        struct srb_iocb *mbx;
1317        int rval = QLA_FUNCTION_FAILED;
1318        u16 *mb;
1319        dma_addr_t pd_dma;
1320        struct port_database_24xx *pd;
1321        struct qla_hw_data *ha = vha->hw;
1322
1323        if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT) ||
1324            fcport->loop_id == FC_NO_LOOP_ID) {
1325                ql_log(ql_log_warn, vha, 0xffff,
1326                    "%s: %8phC - not sending command.\n",
1327                    __func__, fcport->port_name);
1328                return rval;
1329        }
1330
1331        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
1332        if (!sp)
1333                goto done;
1334
1335        qla2x00_set_fcport_disc_state(fcport, DSC_GPDB);
1336
1337        fcport->flags |= FCF_ASYNC_SENT;
1338        sp->type = SRB_MB_IOCB;
1339        sp->name = "gpdb";
1340        sp->gen1 = fcport->rscn_gen;
1341        sp->gen2 = fcport->login_gen;
1342
1343        mbx = &sp->u.iocb_cmd;
1344        mbx->timeout = qla2x00_async_iocb_timeout;
1345        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
1346
1347        pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
1348        if (pd == NULL) {
1349                ql_log(ql_log_warn, vha, 0xd043,
1350                    "Failed to allocate port database structure.\n");
1351                goto done_free_sp;
1352        }
1353
1354        mb = sp->u.iocb_cmd.u.mbx.out_mb;
1355        mb[0] = MBC_GET_PORT_DATABASE;
1356        mb[1] = fcport->loop_id;
1357        mb[2] = MSW(pd_dma);
1358        mb[3] = LSW(pd_dma);
1359        mb[6] = MSW(MSD(pd_dma));
1360        mb[7] = LSW(MSD(pd_dma));
1361        mb[9] = vha->vp_idx;
1362        mb[10] = opt;
1363
1364        mbx->u.mbx.in = pd;
1365        mbx->u.mbx.in_dma = pd_dma;
1366
1367        sp->done = qla24xx_async_gpdb_sp_done;
1368
1369        ql_dbg(ql_dbg_disc, vha, 0x20dc,
1370            "Async-%s %8phC hndl %x opt %x\n",
1371            sp->name, fcport->port_name, sp->handle, opt);
1372
1373        rval = qla2x00_start_sp(sp);
1374        if (rval != QLA_SUCCESS)
1375                goto done_free_sp;
1376        return rval;
1377
1378done_free_sp:
1379        if (pd)
1380                dma_pool_free(ha->s_dma_pool, pd, pd_dma);
1381
1382        sp->free(sp);
1383        fcport->flags &= ~FCF_ASYNC_SENT;
1384done:
1385        fcport->flags &= ~FCF_ASYNC_ACTIVE;
1386        qla24xx_post_gpdb_work(vha, fcport, opt);
1387        return rval;
1388}
1389
1390static
1391void __qla24xx_handle_gpdb_event(scsi_qla_host_t *vha, struct event_arg *ea)
1392{
1393        unsigned long flags;
1394
1395        spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1396        ea->fcport->login_gen++;
1397        ea->fcport->deleted = 0;
1398        ea->fcport->logout_on_delete = 1;
1399
1400        if (!ea->fcport->login_succ && !IS_SW_RESV_ADDR(ea->fcport->d_id)) {
1401                vha->fcport_count++;
1402                ea->fcport->login_succ = 1;
1403
1404                spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1405                qla24xx_sched_upd_fcport(ea->fcport);
1406                spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
1407        } else if (ea->fcport->login_succ) {
1408                /*
1409                 * We have an existing session. A late RSCN delivery
1410                 * must have triggered the session to be re-validate.
1411                 * Session is still valid.
1412                 */
1413                ql_dbg(ql_dbg_disc, vha, 0x20d6,
1414                    "%s %d %8phC session revalidate success\n",
1415                    __func__, __LINE__, ea->fcport->port_name);
1416                qla2x00_set_fcport_disc_state(ea->fcport, DSC_LOGIN_COMPLETE);
1417        }
1418        spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1419}
1420
1421static
1422void qla24xx_handle_gpdb_event(scsi_qla_host_t *vha, struct event_arg *ea)
1423{
1424        fc_port_t *fcport = ea->fcport;
1425        struct port_database_24xx *pd;
1426        struct srb *sp = ea->sp;
1427        uint8_t ls;
1428
1429        pd = (struct port_database_24xx *)sp->u.iocb_cmd.u.mbx.in;
1430
1431        fcport->flags &= ~FCF_ASYNC_SENT;
1432
1433        ql_dbg(ql_dbg_disc, vha, 0x20d2,
1434            "%s %8phC DS %d LS %d fc4_type %x rc %d\n", __func__,
1435            fcport->port_name, fcport->disc_state, pd->current_login_state,
1436            fcport->fc4_type, ea->rc);
1437
1438        if (fcport->disc_state == DSC_DELETE_PEND)
1439                return;
1440
1441        if (NVME_TARGET(vha->hw, fcport))
1442                ls = pd->current_login_state >> 4;
1443        else
1444                ls = pd->current_login_state & 0xf;
1445
1446        if (ea->sp->gen2 != fcport->login_gen) {
1447                /* target side must have changed it. */
1448
1449                ql_dbg(ql_dbg_disc, vha, 0x20d3,
1450                    "%s %8phC generation changed\n",
1451                    __func__, fcport->port_name);
1452                return;
1453        } else if (ea->sp->gen1 != fcport->rscn_gen) {
1454                qla_rscn_replay(fcport);
1455                qlt_schedule_sess_for_deletion(fcport);
1456                return;
1457        }
1458
1459        switch (ls) {
1460        case PDS_PRLI_COMPLETE:
1461                __qla24xx_parse_gpdb(vha, fcport, pd);
1462                break;
1463        case PDS_PLOGI_PENDING:
1464        case PDS_PLOGI_COMPLETE:
1465        case PDS_PRLI_PENDING:
1466        case PDS_PRLI2_PENDING:
1467                /* Set discovery state back to GNL to Relogin attempt */
1468                if (qla_dual_mode_enabled(vha) ||
1469                    qla_ini_mode_enabled(vha)) {
1470                        qla2x00_set_fcport_disc_state(fcport, DSC_GNL);
1471                        set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1472                }
1473                return;
1474        case PDS_LOGO_PENDING:
1475        case PDS_PORT_UNAVAILABLE:
1476        default:
1477                ql_dbg(ql_dbg_disc, vha, 0x20d5, "%s %d %8phC post del sess\n",
1478                    __func__, __LINE__, fcport->port_name);
1479                qlt_schedule_sess_for_deletion(fcport);
1480                return;
1481        }
1482        __qla24xx_handle_gpdb_event(vha, ea);
1483} /* gpdb event */
1484
1485static void qla_chk_n2n_b4_login(struct scsi_qla_host *vha, fc_port_t *fcport)
1486{
1487        u8 login = 0;
1488        int rc;
1489
1490        if (qla_tgt_mode_enabled(vha))
1491                return;
1492
1493        if (qla_dual_mode_enabled(vha)) {
1494                if (N2N_TOPO(vha->hw)) {
1495                        u64 mywwn, wwn;
1496
1497                        mywwn = wwn_to_u64(vha->port_name);
1498                        wwn = wwn_to_u64(fcport->port_name);
1499                        if (mywwn > wwn)
1500                                login = 1;
1501                        else if ((fcport->fw_login_state == DSC_LS_PLOGI_COMP)
1502                            && time_after_eq(jiffies,
1503                                    fcport->plogi_nack_done_deadline))
1504                                login = 1;
1505                } else {
1506                        login = 1;
1507                }
1508        } else {
1509                /* initiator mode */
1510                login = 1;
1511        }
1512
1513        if (login && fcport->login_retry) {
1514                fcport->login_retry--;
1515                if (fcport->loop_id == FC_NO_LOOP_ID) {
1516                        fcport->fw_login_state = DSC_LS_PORT_UNAVAIL;
1517                        rc = qla2x00_find_new_loop_id(vha, fcport);
1518                        if (rc) {
1519                                ql_dbg(ql_dbg_disc, vha, 0x20e6,
1520                                    "%s %d %8phC post del sess - out of loopid\n",
1521                                    __func__, __LINE__, fcport->port_name);
1522                                fcport->scan_state = 0;
1523                                qlt_schedule_sess_for_deletion(fcport);
1524                                return;
1525                        }
1526                }
1527                ql_dbg(ql_dbg_disc, vha, 0x20bf,
1528                    "%s %d %8phC post login\n",
1529                    __func__, __LINE__, fcport->port_name);
1530                qla2x00_post_async_login_work(vha, fcport, NULL);
1531        }
1532}
1533
1534int qla24xx_fcport_handle_login(struct scsi_qla_host *vha, fc_port_t *fcport)
1535{
1536        u16 data[2];
1537        u64 wwn;
1538        u16 sec;
1539
1540        ql_dbg(ql_dbg_disc, vha, 0x20d8,
1541            "%s %8phC DS %d LS %d P %d fl %x confl %p rscn %d|%d login %d lid %d scan %d\n",
1542            __func__, fcport->port_name, fcport->disc_state,
1543            fcport->fw_login_state, fcport->login_pause, fcport->flags,
1544            fcport->conflict, fcport->last_rscn_gen, fcport->rscn_gen,
1545            fcport->login_gen, fcport->loop_id, fcport->scan_state);
1546
1547        if (fcport->scan_state != QLA_FCPORT_FOUND)
1548                return 0;
1549
1550        if ((fcport->loop_id != FC_NO_LOOP_ID) &&
1551            qla_dual_mode_enabled(vha) &&
1552            ((fcport->fw_login_state == DSC_LS_PLOGI_PEND) ||
1553             (fcport->fw_login_state == DSC_LS_PRLI_PEND)))
1554                return 0;
1555
1556        if (fcport->fw_login_state == DSC_LS_PLOGI_COMP &&
1557            !N2N_TOPO(vha->hw)) {
1558                if (time_before_eq(jiffies, fcport->plogi_nack_done_deadline)) {
1559                        set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1560                        return 0;
1561                }
1562        }
1563
1564        /* Target won't initiate port login if fabric is present */
1565        if (vha->host->active_mode == MODE_TARGET && !N2N_TOPO(vha->hw))
1566                return 0;
1567
1568        if (fcport->flags & FCF_ASYNC_SENT) {
1569                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1570                return 0;
1571        }
1572
1573        switch (fcport->disc_state) {
1574        case DSC_DELETED:
1575                wwn = wwn_to_u64(fcport->node_name);
1576                switch (vha->hw->current_topology) {
1577                case ISP_CFG_N:
1578                        if (fcport_is_smaller(fcport)) {
1579                                /* this adapter is bigger */
1580                                if (fcport->login_retry) {
1581                                        if (fcport->loop_id == FC_NO_LOOP_ID) {
1582                                                qla2x00_find_new_loop_id(vha,
1583                                                    fcport);
1584                                                fcport->fw_login_state =
1585                                                    DSC_LS_PORT_UNAVAIL;
1586                                        }
1587                                        fcport->login_retry--;
1588                                        qla_post_els_plogi_work(vha, fcport);
1589                                } else {
1590                                        ql_log(ql_log_info, vha, 0x705d,
1591                                            "Unable to reach remote port %8phC",
1592                                            fcport->port_name);
1593                                }
1594                        } else {
1595                                qla24xx_post_gnl_work(vha, fcport);
1596                        }
1597                        break;
1598                default:
1599                        if (wwn == 0)    {
1600                                ql_dbg(ql_dbg_disc, vha, 0xffff,
1601                                    "%s %d %8phC post GNNID\n",
1602                                    __func__, __LINE__, fcport->port_name);
1603                                qla24xx_post_gnnid_work(vha, fcport);
1604                        } else if (fcport->loop_id == FC_NO_LOOP_ID) {
1605                                ql_dbg(ql_dbg_disc, vha, 0x20bd,
1606                                    "%s %d %8phC post gnl\n",
1607                                    __func__, __LINE__, fcport->port_name);
1608                                qla24xx_post_gnl_work(vha, fcport);
1609                        } else {
1610                                qla_chk_n2n_b4_login(vha, fcport);
1611                        }
1612                        break;
1613                }
1614                break;
1615
1616        case DSC_GNL:
1617                switch (vha->hw->current_topology) {
1618                case ISP_CFG_N:
1619                        if ((fcport->current_login_state & 0xf) == 0x6) {
1620                                ql_dbg(ql_dbg_disc, vha, 0x2118,
1621                                    "%s %d %8phC post GPDB work\n",
1622                                    __func__, __LINE__, fcport->port_name);
1623                                fcport->chip_reset =
1624                                        vha->hw->base_qpair->chip_reset;
1625                                qla24xx_post_gpdb_work(vha, fcport, 0);
1626                        }  else {
1627                                ql_dbg(ql_dbg_disc, vha, 0x2118,
1628                                    "%s %d %8phC post %s PRLI\n",
1629                                    __func__, __LINE__, fcport->port_name,
1630                                    NVME_TARGET(vha->hw, fcport) ? "NVME" :
1631                                    "FC");
1632                                qla24xx_post_prli_work(vha, fcport);
1633                        }
1634                        break;
1635                default:
1636                        if (fcport->login_pause) {
1637                                ql_dbg(ql_dbg_disc, vha, 0x20d8,
1638                                    "%s %d %8phC exit\n",
1639                                    __func__, __LINE__,
1640                                    fcport->port_name);
1641                                fcport->last_rscn_gen = fcport->rscn_gen;
1642                                fcport->last_login_gen = fcport->login_gen;
1643                                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1644                                break;
1645                        }
1646                        qla_chk_n2n_b4_login(vha, fcport);
1647                        break;
1648                }
1649                break;
1650
1651        case DSC_LOGIN_FAILED:
1652                if (N2N_TOPO(vha->hw))
1653                        qla_chk_n2n_b4_login(vha, fcport);
1654                else
1655                        qlt_schedule_sess_for_deletion(fcport);
1656                break;
1657
1658        case DSC_LOGIN_COMPLETE:
1659                /* recheck login state */
1660                data[0] = data[1] = 0;
1661                qla2x00_post_async_adisc_work(vha, fcport, data);
1662                break;
1663
1664        case DSC_LOGIN_PEND:
1665                if (fcport->fw_login_state == DSC_LS_PLOGI_COMP)
1666                        qla24xx_post_prli_work(vha, fcport);
1667                break;
1668
1669        case DSC_UPD_FCPORT:
1670                sec =  jiffies_to_msecs(jiffies -
1671                    fcport->jiffies_at_registration)/1000;
1672                if (fcport->sec_since_registration < sec && sec &&
1673                    !(sec % 60)) {
1674                        fcport->sec_since_registration = sec;
1675                        ql_dbg(ql_dbg_disc, fcport->vha, 0xffff,
1676                            "%s %8phC - Slow Rport registration(%d Sec)\n",
1677                            __func__, fcport->port_name, sec);
1678                }
1679
1680                if (fcport->next_disc_state != DSC_DELETE_PEND)
1681                        fcport->next_disc_state = DSC_ADISC;
1682                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1683                break;
1684
1685        default:
1686                break;
1687        }
1688
1689        return 0;
1690}
1691
1692int qla24xx_post_newsess_work(struct scsi_qla_host *vha, port_id_t *id,
1693    u8 *port_name, u8 *node_name, void *pla, u8 fc4_type)
1694{
1695        struct qla_work_evt *e;
1696
1697        e = qla2x00_alloc_work(vha, QLA_EVT_NEW_SESS);
1698        if (!e)
1699                return QLA_FUNCTION_FAILED;
1700
1701        e->u.new_sess.id = *id;
1702        e->u.new_sess.pla = pla;
1703        e->u.new_sess.fc4_type = fc4_type;
1704        memcpy(e->u.new_sess.port_name, port_name, WWN_SIZE);
1705        if (node_name)
1706                memcpy(e->u.new_sess.node_name, node_name, WWN_SIZE);
1707
1708        return qla2x00_post_work(vha, e);
1709}
1710
1711void qla2x00_handle_rscn(scsi_qla_host_t *vha, struct event_arg *ea)
1712{
1713        fc_port_t *fcport;
1714        unsigned long flags;
1715
1716        fcport = qla2x00_find_fcport_by_nportid(vha, &ea->id, 1);
1717        if (fcport) {
1718                fcport->scan_needed = 1;
1719                fcport->rscn_gen++;
1720        }
1721
1722        spin_lock_irqsave(&vha->work_lock, flags);
1723        if (vha->scan.scan_flags == 0) {
1724                ql_dbg(ql_dbg_disc, vha, 0xffff, "%s: schedule\n", __func__);
1725                vha->scan.scan_flags |= SF_QUEUED;
1726                schedule_delayed_work(&vha->scan.scan_work, 5);
1727        }
1728        spin_unlock_irqrestore(&vha->work_lock, flags);
1729}
1730
1731void qla24xx_handle_relogin_event(scsi_qla_host_t *vha,
1732        struct event_arg *ea)
1733{
1734        fc_port_t *fcport = ea->fcport;
1735
1736        if (test_bit(UNLOADING, &vha->dpc_flags))
1737                return;
1738
1739        ql_dbg(ql_dbg_disc, vha, 0x2102,
1740            "%s %8phC DS %d LS %d P %d del %d cnfl %p rscn %d|%d login %d|%d fl %x\n",
1741            __func__, fcport->port_name, fcport->disc_state,
1742            fcport->fw_login_state, fcport->login_pause,
1743            fcport->deleted, fcport->conflict,
1744            fcport->last_rscn_gen, fcport->rscn_gen,
1745            fcport->last_login_gen, fcport->login_gen,
1746            fcport->flags);
1747
1748        if (fcport->last_rscn_gen != fcport->rscn_gen) {
1749                ql_dbg(ql_dbg_disc, vha, 0x20e9, "%s %d %8phC post gnl\n",
1750                    __func__, __LINE__, fcport->port_name);
1751                qla24xx_post_gnl_work(vha, fcport);
1752                return;
1753        }
1754
1755        qla24xx_fcport_handle_login(vha, fcport);
1756}
1757
1758void qla_handle_els_plogi_done(scsi_qla_host_t *vha,
1759                                      struct event_arg *ea)
1760{
1761        /* for pure Target Mode, PRLI will not be initiated */
1762        if (vha->host->active_mode == MODE_TARGET)
1763                return;
1764
1765        ql_dbg(ql_dbg_disc, vha, 0x2118,
1766            "%s %d %8phC post PRLI\n",
1767            __func__, __LINE__, ea->fcport->port_name);
1768        qla24xx_post_prli_work(vha, ea->fcport);
1769}
1770
1771/*
1772 * RSCN(s) came in for this fcport, but the RSCN(s) was not able
1773 * to be consumed by the fcport
1774 */
1775void qla_rscn_replay(fc_port_t *fcport)
1776{
1777        struct event_arg ea;
1778
1779        switch (fcport->disc_state) {
1780        case DSC_DELETE_PEND:
1781                return;
1782        default:
1783                break;
1784        }
1785
1786        if (fcport->scan_needed) {
1787                memset(&ea, 0, sizeof(ea));
1788                ea.id = fcport->d_id;
1789                ea.id.b.rsvd_1 = RSCN_PORT_ADDR;
1790                qla2x00_handle_rscn(fcport->vha, &ea);
1791        }
1792}
1793
1794static void
1795qla2x00_tmf_iocb_timeout(void *data)
1796{
1797        srb_t *sp = data;
1798        struct srb_iocb *tmf = &sp->u.iocb_cmd;
1799        int rc, h;
1800        unsigned long flags;
1801
1802        rc = qla24xx_async_abort_cmd(sp, false);
1803        if (rc) {
1804                spin_lock_irqsave(sp->qpair->qp_lock_ptr, flags);
1805                for (h = 1; h < sp->qpair->req->num_outstanding_cmds; h++) {
1806                        if (sp->qpair->req->outstanding_cmds[h] == sp) {
1807                                sp->qpair->req->outstanding_cmds[h] = NULL;
1808                                break;
1809                        }
1810                }
1811                spin_unlock_irqrestore(sp->qpair->qp_lock_ptr, flags);
1812                tmf->u.tmf.comp_status = cpu_to_le16(CS_TIMEOUT);
1813                tmf->u.tmf.data = QLA_FUNCTION_FAILED;
1814                complete(&tmf->u.tmf.comp);
1815        }
1816}
1817
1818static void qla2x00_tmf_sp_done(srb_t *sp, int res)
1819{
1820        struct srb_iocb *tmf = &sp->u.iocb_cmd;
1821
1822        complete(&tmf->u.tmf.comp);
1823}
1824
1825int
1826qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
1827        uint32_t tag)
1828{
1829        struct scsi_qla_host *vha = fcport->vha;
1830        struct srb_iocb *tm_iocb;
1831        srb_t *sp;
1832        int rval = QLA_FUNCTION_FAILED;
1833
1834        sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
1835        if (!sp)
1836                goto done;
1837
1838        tm_iocb = &sp->u.iocb_cmd;
1839        sp->type = SRB_TM_CMD;
1840        sp->name = "tmf";
1841
1842        tm_iocb->timeout = qla2x00_tmf_iocb_timeout;
1843        init_completion(&tm_iocb->u.tmf.comp);
1844        qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha));
1845
1846        tm_iocb->u.tmf.flags = flags;
1847        tm_iocb->u.tmf.lun = lun;
1848        tm_iocb->u.tmf.data = tag;
1849        sp->done = qla2x00_tmf_sp_done;
1850
1851        ql_dbg(ql_dbg_taskm, vha, 0x802f,
1852            "Async-tmf hdl=%x loop-id=%x portid=%02x%02x%02x.\n",
1853            sp->handle, fcport->loop_id, fcport->d_id.b.domain,
1854            fcport->d_id.b.area, fcport->d_id.b.al_pa);
1855
1856        rval = qla2x00_start_sp(sp);
1857        if (rval != QLA_SUCCESS)
1858                goto done_free_sp;
1859        wait_for_completion(&tm_iocb->u.tmf.comp);
1860
1861        rval = tm_iocb->u.tmf.data;
1862
1863        if (rval != QLA_SUCCESS) {
1864                ql_log(ql_log_warn, vha, 0x8030,
1865                    "TM IOCB failed (%x).\n", rval);
1866        }
1867
1868        if (!test_bit(UNLOADING, &vha->dpc_flags) && !IS_QLAFX00(vha->hw)) {
1869                flags = tm_iocb->u.tmf.flags;
1870                lun = (uint16_t)tm_iocb->u.tmf.lun;
1871
1872                /* Issue Marker IOCB */
1873                qla2x00_marker(vha, vha->hw->base_qpair,
1874                    fcport->loop_id, lun,
1875                    flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
1876        }
1877
1878done_free_sp:
1879        sp->free(sp);
1880        fcport->flags &= ~FCF_ASYNC_SENT;
1881done:
1882        return rval;
1883}
1884
1885int
1886qla24xx_async_abort_command(srb_t *sp)
1887{
1888        unsigned long   flags = 0;
1889
1890        uint32_t        handle;
1891        fc_port_t       *fcport = sp->fcport;
1892        struct qla_qpair *qpair = sp->qpair;
1893        struct scsi_qla_host *vha = fcport->vha;
1894        struct req_que *req = qpair->req;
1895
1896        spin_lock_irqsave(qpair->qp_lock_ptr, flags);
1897        for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
1898                if (req->outstanding_cmds[handle] == sp)
1899                        break;
1900        }
1901        spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
1902
1903        if (handle == req->num_outstanding_cmds) {
1904                /* Command not found. */
1905                return QLA_FUNCTION_FAILED;
1906        }
1907        if (sp->type == SRB_FXIOCB_DCMD)
1908                return qlafx00_fx_disc(vha, &vha->hw->mr.fcport,
1909                    FXDISC_ABORT_IOCTL);
1910
1911        return qla24xx_async_abort_cmd(sp, true);
1912}
1913
1914static void
1915qla24xx_handle_prli_done_event(struct scsi_qla_host *vha, struct event_arg *ea)
1916{
1917        WARN_ONCE(!qla2xxx_is_valid_mbs(ea->data[0]), "mbs: %#x\n",
1918                  ea->data[0]);
1919
1920        switch (ea->data[0]) {
1921        case MBS_COMMAND_COMPLETE:
1922                ql_dbg(ql_dbg_disc, vha, 0x2118,
1923                    "%s %d %8phC post gpdb\n",
1924                    __func__, __LINE__, ea->fcport->port_name);
1925
1926                ea->fcport->chip_reset = vha->hw->base_qpair->chip_reset;
1927                ea->fcport->logout_on_delete = 1;
1928                ea->fcport->nvme_prli_service_param = ea->iop[0];
1929                if (ea->iop[0] & NVME_PRLI_SP_FIRST_BURST)
1930                        ea->fcport->nvme_first_burst_size =
1931                            (ea->iop[1] & 0xffff) * 512;
1932                else
1933                        ea->fcport->nvme_first_burst_size = 0;
1934                qla24xx_post_gpdb_work(vha, ea->fcport, 0);
1935                break;
1936        default:
1937                if ((ea->iop[0] == LSC_SCODE_ELS_REJECT) &&
1938                    (ea->iop[1] == 0x50000)) {   /* reson 5=busy expl:0x0 */
1939                        set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1940                        ea->fcport->fw_login_state = DSC_LS_PLOGI_COMP;
1941                        break;
1942                }
1943
1944                ql_dbg(ql_dbg_disc, vha, 0x2118,
1945                       "%s %d %8phC priority %s, fc4type %x\n",
1946                       __func__, __LINE__, ea->fcport->port_name,
1947                       vha->hw->fc4_type_priority == FC4_PRIORITY_FCP ?
1948                       "FCP" : "NVMe", ea->fcport->fc4_type);
1949
1950                if (N2N_TOPO(vha->hw)) {
1951                        if (vha->hw->fc4_type_priority == FC4_PRIORITY_NVME) {
1952                                ea->fcport->fc4_type &= ~FS_FC4TYPE_NVME;
1953                                ea->fcport->fc4_type |= FS_FC4TYPE_FCP;
1954                        } else {
1955                                ea->fcport->fc4_type &= ~FS_FC4TYPE_FCP;
1956                                ea->fcport->fc4_type |= FS_FC4TYPE_NVME;
1957                        }
1958
1959                        if (ea->fcport->n2n_link_reset_cnt < 3) {
1960                                ea->fcport->n2n_link_reset_cnt++;
1961                                vha->relogin_jif = jiffies + 2 * HZ;
1962                                /*
1963                                 * PRLI failed. Reset link to kick start
1964                                 * state machine
1965                                 */
1966                                set_bit(N2N_LINK_RESET, &vha->dpc_flags);
1967                        } else {
1968                                ql_log(ql_log_warn, vha, 0x2119,
1969                                       "%s %d %8phC Unable to reconnect\n",
1970                                       __func__, __LINE__,
1971                                       ea->fcport->port_name);
1972                        }
1973                } else {
1974                        /*
1975                         * switch connect. login failed. Take connection down
1976                         * and allow relogin to retrigger
1977                         */
1978                        if (NVME_FCP_TARGET(ea->fcport)) {
1979                                ql_dbg(ql_dbg_disc, vha, 0x2118,
1980                                       "%s %d %8phC post %s prli\n",
1981                                       __func__, __LINE__,
1982                                       ea->fcport->port_name,
1983                                       (ea->fcport->fc4_type & FS_FC4TYPE_NVME)
1984                                       ? "NVMe" : "FCP");
1985                                if (vha->hw->fc4_type_priority == FC4_PRIORITY_NVME)
1986                                        ea->fcport->fc4_type &= ~FS_FC4TYPE_NVME;
1987                                else
1988                                        ea->fcport->fc4_type &= ~FS_FC4TYPE_FCP;
1989                        }
1990
1991                        ea->fcport->flags &= ~FCF_ASYNC_SENT;
1992                        ea->fcport->keep_nport_handle = 0;
1993                        ea->fcport->logout_on_delete = 1;
1994                        qlt_schedule_sess_for_deletion(ea->fcport);
1995                }
1996                break;
1997        }
1998}
1999
2000void
2001qla24xx_handle_plogi_done_event(struct scsi_qla_host *vha, struct event_arg *ea)
2002{
2003        port_id_t cid;  /* conflict Nport id */
2004        u16 lid;
2005        struct fc_port *conflict_fcport;
2006        unsigned long flags;
2007        struct fc_port *fcport = ea->fcport;
2008
2009        ql_dbg(ql_dbg_disc, vha, 0xffff,
2010            "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d data %x|%x iop %x|%x\n",
2011            __func__, fcport->port_name, fcport->disc_state,
2012            fcport->fw_login_state, ea->rc, ea->sp->gen2, fcport->login_gen,
2013            ea->sp->gen1, fcport->rscn_gen,
2014            ea->data[0], ea->data[1], ea->iop[0], ea->iop[1]);
2015
2016        if ((fcport->fw_login_state == DSC_LS_PLOGI_PEND) ||
2017            (fcport->fw_login_state == DSC_LS_PRLI_PEND)) {
2018                ql_dbg(ql_dbg_disc, vha, 0x20ea,
2019                    "%s %d %8phC Remote is trying to login\n",
2020                    __func__, __LINE__, fcport->port_name);
2021                return;
2022        }
2023
2024        if ((fcport->disc_state == DSC_DELETE_PEND) ||
2025            (fcport->disc_state == DSC_DELETED)) {
2026                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
2027                return;
2028        }
2029
2030        if (ea->sp->gen2 != fcport->login_gen) {
2031                /* target side must have changed it. */
2032                ql_dbg(ql_dbg_disc, vha, 0x20d3,
2033                    "%s %8phC generation changed\n",
2034                    __func__, fcport->port_name);
2035                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
2036                return;
2037        } else if (ea->sp->gen1 != fcport->rscn_gen) {
2038                ql_dbg(ql_dbg_disc, vha, 0x20d3,
2039                    "%s %8phC RSCN generation changed\n",
2040                    __func__, fcport->port_name);
2041                qla_rscn_replay(fcport);
2042                qlt_schedule_sess_for_deletion(fcport);
2043                return;
2044        }
2045
2046        WARN_ONCE(!qla2xxx_is_valid_mbs(ea->data[0]), "mbs: %#x\n",
2047                  ea->data[0]);
2048
2049        switch (ea->data[0]) {
2050        case MBS_COMMAND_COMPLETE:
2051                /*
2052                 * Driver must validate login state - If PRLI not complete,
2053                 * force a relogin attempt via implicit LOGO, PLOGI, and PRLI
2054                 * requests.
2055                 */
2056                if (NVME_TARGET(vha->hw, ea->fcport)) {
2057                        ql_dbg(ql_dbg_disc, vha, 0x2117,
2058                                "%s %d %8phC post prli\n",
2059                                __func__, __LINE__, ea->fcport->port_name);
2060                        qla24xx_post_prli_work(vha, ea->fcport);
2061                } else {
2062                        ql_dbg(ql_dbg_disc, vha, 0x20ea,
2063                            "%s %d %8phC LoopID 0x%x in use with %06x. post gpdb\n",
2064                            __func__, __LINE__, ea->fcport->port_name,
2065                            ea->fcport->loop_id, ea->fcport->d_id.b24);
2066
2067                        set_bit(ea->fcport->loop_id, vha->hw->loop_id_map);
2068                        spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
2069                        ea->fcport->chip_reset = vha->hw->base_qpair->chip_reset;
2070                        ea->fcport->logout_on_delete = 1;
2071                        ea->fcport->send_els_logo = 0;
2072                        ea->fcport->fw_login_state = DSC_LS_PRLI_COMP;
2073                        spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
2074
2075                        qla24xx_post_gpdb_work(vha, ea->fcport, 0);
2076                }
2077                break;
2078        case MBS_COMMAND_ERROR:
2079                ql_dbg(ql_dbg_disc, vha, 0x20eb, "%s %d %8phC cmd error %x\n",
2080                    __func__, __LINE__, ea->fcport->port_name, ea->data[1]);
2081
2082                ea->fcport->flags &= ~FCF_ASYNC_SENT;
2083                qla2x00_set_fcport_disc_state(ea->fcport, DSC_LOGIN_FAILED);
2084                if (ea->data[1] & QLA_LOGIO_LOGIN_RETRIED)
2085                        set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
2086                else
2087                        qla2x00_mark_device_lost(vha, ea->fcport, 1);
2088                break;
2089        case MBS_LOOP_ID_USED:
2090                /* data[1] = IO PARAM 1 = nport ID  */
2091                cid.b.domain = (ea->iop[1] >> 16) & 0xff;
2092                cid.b.area   = (ea->iop[1] >>  8) & 0xff;
2093                cid.b.al_pa  = ea->iop[1] & 0xff;
2094                cid.b.rsvd_1 = 0;
2095
2096                ql_dbg(ql_dbg_disc, vha, 0x20ec,
2097                    "%s %d %8phC lid %#x in use with pid %06x post gnl\n",
2098                    __func__, __LINE__, ea->fcport->port_name,
2099                    ea->fcport->loop_id, cid.b24);
2100
2101                set_bit(ea->fcport->loop_id, vha->hw->loop_id_map);
2102                ea->fcport->loop_id = FC_NO_LOOP_ID;
2103                qla24xx_post_gnl_work(vha, ea->fcport);
2104                break;
2105        case MBS_PORT_ID_USED:
2106                lid = ea->iop[1] & 0xffff;
2107                qlt_find_sess_invalidate_other(vha,
2108                    wwn_to_u64(ea->fcport->port_name),
2109                    ea->fcport->d_id, lid, &conflict_fcport);
2110
2111                if (conflict_fcport) {
2112                        /*
2113                         * Another fcport share the same loop_id/nport id.
2114                         * Conflict fcport needs to finish cleanup before this
2115                         * fcport can proceed to login.
2116                         */
2117                        conflict_fcport->conflict = ea->fcport;
2118                        ea->fcport->login_pause = 1;
2119
2120                        ql_dbg(ql_dbg_disc, vha, 0x20ed,
2121                            "%s %d %8phC NPortId %06x inuse with loopid 0x%x. post gidpn\n",
2122                            __func__, __LINE__, ea->fcport->port_name,
2123                            ea->fcport->d_id.b24, lid);
2124                } else {
2125                        ql_dbg(ql_dbg_disc, vha, 0x20ed,
2126                            "%s %d %8phC NPortId %06x inuse with loopid 0x%x. sched delete\n",
2127                            __func__, __LINE__, ea->fcport->port_name,
2128                            ea->fcport->d_id.b24, lid);
2129
2130                        qla2x00_clear_loop_id(ea->fcport);
2131                        set_bit(lid, vha->hw->loop_id_map);
2132                        ea->fcport->loop_id = lid;
2133                        ea->fcport->keep_nport_handle = 0;
2134                        ea->fcport->logout_on_delete = 1;
2135                        qlt_schedule_sess_for_deletion(ea->fcport);
2136                }
2137                break;
2138        }
2139        return;
2140}
2141
2142/****************************************************************************/
2143/*                QLogic ISP2x00 Hardware Support Functions.                */
2144/****************************************************************************/
2145
2146static int
2147qla83xx_nic_core_fw_load(scsi_qla_host_t *vha)
2148{
2149        int rval = QLA_SUCCESS;
2150        struct qla_hw_data *ha = vha->hw;
2151        uint32_t idc_major_ver, idc_minor_ver;
2152        uint16_t config[4];
2153
2154        qla83xx_idc_lock(vha, 0);
2155
2156        /* SV: TODO: Assign initialization timeout from
2157         * flash-info / other param
2158         */
2159        ha->fcoe_dev_init_timeout = QLA83XX_IDC_INITIALIZATION_TIMEOUT;
2160        ha->fcoe_reset_timeout = QLA83XX_IDC_RESET_ACK_TIMEOUT;
2161
2162        /* Set our fcoe function presence */
2163        if (__qla83xx_set_drv_presence(vha) != QLA_SUCCESS) {
2164                ql_dbg(ql_dbg_p3p, vha, 0xb077,
2165                    "Error while setting DRV-Presence.\n");
2166                rval = QLA_FUNCTION_FAILED;
2167                goto exit;
2168        }
2169
2170        /* Decide the reset ownership */
2171        qla83xx_reset_ownership(vha);
2172
2173        /*
2174         * On first protocol driver load:
2175         * Init-Owner: Set IDC-Major-Version and Clear IDC-Lock-Recovery
2176         * register.
2177         * Others: Check compatibility with current IDC Major version.
2178         */
2179        qla83xx_rd_reg(vha, QLA83XX_IDC_MAJOR_VERSION, &idc_major_ver);
2180        if (ha->flags.nic_core_reset_owner) {
2181                /* Set IDC Major version */
2182                idc_major_ver = QLA83XX_SUPP_IDC_MAJOR_VERSION;
2183                qla83xx_wr_reg(vha, QLA83XX_IDC_MAJOR_VERSION, idc_major_ver);
2184
2185                /* Clearing IDC-Lock-Recovery register */
2186                qla83xx_wr_reg(vha, QLA83XX_IDC_LOCK_RECOVERY, 0);
2187        } else if (idc_major_ver != QLA83XX_SUPP_IDC_MAJOR_VERSION) {
2188                /*
2189                 * Clear further IDC participation if we are not compatible with
2190                 * the current IDC Major Version.
2191                 */
2192                ql_log(ql_log_warn, vha, 0xb07d,
2193                    "Failing load, idc_major_ver=%d, expected_major_ver=%d.\n",
2194                    idc_major_ver, QLA83XX_SUPP_IDC_MAJOR_VERSION);
2195                __qla83xx_clear_drv_presence(vha);
2196                rval = QLA_FUNCTION_FAILED;
2197                goto exit;
2198        }
2199        /* Each function sets its supported Minor version. */
2200        qla83xx_rd_reg(vha, QLA83XX_IDC_MINOR_VERSION, &idc_minor_ver);
2201        idc_minor_ver |= (QLA83XX_SUPP_IDC_MINOR_VERSION << (ha->portnum * 2));
2202        qla83xx_wr_reg(vha, QLA83XX_IDC_MINOR_VERSION, idc_minor_ver);
2203
2204        if (ha->flags.nic_core_reset_owner) {
2205                memset(config, 0, sizeof(config));
2206                if (!qla81xx_get_port_config(vha, config))
2207                        qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE,
2208                            QLA8XXX_DEV_READY);
2209        }
2210
2211        rval = qla83xx_idc_state_handler(vha);
2212
2213exit:
2214        qla83xx_idc_unlock(vha, 0);
2215
2216        return rval;
2217}
2218
2219/*
2220* qla2x00_initialize_adapter
2221*      Initialize board.
2222*
2223* Input:
2224*      ha = adapter block pointer.
2225*
2226* Returns:
2227*      0 = success
2228*/
2229int
2230qla2x00_initialize_adapter(scsi_qla_host_t *vha)
2231{
2232        int     rval;
2233        struct qla_hw_data *ha = vha->hw;
2234        struct req_que *req = ha->req_q_map[0];
2235        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2236
2237        memset(&vha->qla_stats, 0, sizeof(vha->qla_stats));
2238        memset(&vha->fc_host_stat, 0, sizeof(vha->fc_host_stat));
2239
2240        /* Clear adapter flags. */
2241        vha->flags.online = 0;
2242        ha->flags.chip_reset_done = 0;
2243        vha->flags.reset_active = 0;
2244        ha->flags.pci_channel_io_perm_failure = 0;
2245        ha->flags.eeh_busy = 0;
2246        vha->qla_stats.jiffies_at_last_reset = get_jiffies_64();
2247        atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
2248        atomic_set(&vha->loop_state, LOOP_DOWN);
2249        vha->device_flags = DFLG_NO_CABLE;
2250        vha->dpc_flags = 0;
2251        vha->flags.management_server_logged_in = 0;
2252        vha->marker_needed = 0;
2253        ha->isp_abort_cnt = 0;
2254        ha->beacon_blink_led = 0;
2255
2256        set_bit(0, ha->req_qid_map);
2257        set_bit(0, ha->rsp_qid_map);
2258
2259        ql_dbg(ql_dbg_init, vha, 0x0040,
2260            "Configuring PCI space...\n");
2261        rval = ha->isp_ops->pci_config(vha);
2262        if (rval) {
2263                ql_log(ql_log_warn, vha, 0x0044,
2264                    "Unable to configure PCI space.\n");
2265                return (rval);
2266        }
2267
2268        ha->isp_ops->reset_chip(vha);
2269
2270        /* Check for secure flash support */
2271        if (IS_QLA28XX(ha)) {
2272                if (rd_reg_word(&reg->mailbox12) & BIT_0)
2273                        ha->flags.secure_adapter = 1;
2274                ql_log(ql_log_info, vha, 0xffff, "Secure Adapter: %s\n",
2275                    (ha->flags.secure_adapter) ? "Yes" : "No");
2276        }
2277
2278
2279        rval = qla2xxx_get_flash_info(vha);
2280        if (rval) {
2281                ql_log(ql_log_fatal, vha, 0x004f,
2282                    "Unable to validate FLASH data.\n");
2283                return rval;
2284        }
2285
2286        if (IS_QLA8044(ha)) {
2287                qla8044_read_reset_template(vha);
2288
2289                /* NOTE: If ql2xdontresethba==1, set IDC_CTRL DONTRESET_BIT0.
2290                 * If DONRESET_BIT0 is set, drivers should not set dev_state
2291                 * to NEED_RESET. But if NEED_RESET is set, drivers should
2292                 * should honor the reset. */
2293                if (ql2xdontresethba == 1)
2294                        qla8044_set_idc_dontreset(vha);
2295        }
2296
2297        ha->isp_ops->get_flash_version(vha, req->ring);
2298        ql_dbg(ql_dbg_init, vha, 0x0061,
2299            "Configure NVRAM parameters...\n");
2300
2301        /* Let priority default to FCP, can be overridden by nvram_config */
2302        ha->fc4_type_priority = FC4_PRIORITY_FCP;
2303
2304        ha->isp_ops->nvram_config(vha);
2305
2306        if (ha->fc4_type_priority != FC4_PRIORITY_FCP &&
2307            ha->fc4_type_priority != FC4_PRIORITY_NVME)
2308                ha->fc4_type_priority = FC4_PRIORITY_FCP;
2309
2310        ql_log(ql_log_info, vha, 0xffff, "FC4 priority set to %s\n",
2311               ha->fc4_type_priority == FC4_PRIORITY_FCP ? "FCP" : "NVMe");
2312
2313        if (ha->flags.disable_serdes) {
2314                /* Mask HBA via NVRAM settings? */
2315                ql_log(ql_log_info, vha, 0x0077,
2316                    "Masking HBA WWPN %8phN (via NVRAM).\n", vha->port_name);
2317                return QLA_FUNCTION_FAILED;
2318        }
2319
2320        ql_dbg(ql_dbg_init, vha, 0x0078,
2321            "Verifying loaded RISC code...\n");
2322
2323        /* If smartsan enabled then require fdmi and rdp enabled */
2324        if (ql2xsmartsan) {
2325                ql2xfdmienable = 1;
2326                ql2xrdpenable = 1;
2327        }
2328
2329        if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
2330                rval = ha->isp_ops->chip_diag(vha);
2331                if (rval)
2332                        return (rval);
2333                rval = qla2x00_setup_chip(vha);
2334                if (rval)
2335                        return (rval);
2336        }
2337
2338        if (IS_QLA84XX(ha)) {
2339                ha->cs84xx = qla84xx_get_chip(vha);
2340                if (!ha->cs84xx) {
2341                        ql_log(ql_log_warn, vha, 0x00d0,
2342                            "Unable to configure ISP84XX.\n");
2343                        return QLA_FUNCTION_FAILED;
2344                }
2345        }
2346
2347        if (qla_ini_mode_enabled(vha) || qla_dual_mode_enabled(vha))
2348                rval = qla2x00_init_rings(vha);
2349
2350        /* No point in continuing if firmware initialization failed. */
2351        if (rval != QLA_SUCCESS)
2352                return rval;
2353
2354        ha->flags.chip_reset_done = 1;
2355
2356        if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
2357                /* Issue verify 84xx FW IOCB to complete 84xx initialization */
2358                rval = qla84xx_init_chip(vha);
2359                if (rval != QLA_SUCCESS) {
2360                        ql_log(ql_log_warn, vha, 0x00d4,
2361                            "Unable to initialize ISP84XX.\n");
2362                        qla84xx_put_chip(vha);
2363                }
2364        }
2365
2366        /* Load the NIC Core f/w if we are the first protocol driver. */
2367        if (IS_QLA8031(ha)) {
2368                rval = qla83xx_nic_core_fw_load(vha);
2369                if (rval)
2370                        ql_log(ql_log_warn, vha, 0x0124,
2371                            "Error in initializing NIC Core f/w.\n");
2372        }
2373
2374        if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
2375                qla24xx_read_fcp_prio_cfg(vha);
2376
2377        if (IS_P3P_TYPE(ha))
2378                qla82xx_set_driver_version(vha, QLA2XXX_VERSION);
2379        else
2380                qla25xx_set_driver_version(vha, QLA2XXX_VERSION);
2381
2382        return (rval);
2383}
2384
2385/**
2386 * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
2387 * @vha: HA context
2388 *
2389 * Returns 0 on success.
2390 */
2391int
2392qla2100_pci_config(scsi_qla_host_t *vha)
2393{
2394        uint16_t w;
2395        unsigned long flags;
2396        struct qla_hw_data *ha = vha->hw;
2397        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2398
2399        pci_set_master(ha->pdev);
2400        pci_try_set_mwi(ha->pdev);
2401
2402        pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
2403        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
2404        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
2405
2406        pci_disable_rom(ha->pdev);
2407
2408        /* Get PCI bus information. */
2409        spin_lock_irqsave(&ha->hardware_lock, flags);
2410        ha->pci_attr = rd_reg_word(&reg->ctrl_status);
2411        spin_unlock_irqrestore(&ha->hardware_lock, flags);
2412
2413        return QLA_SUCCESS;
2414}
2415
2416/**
2417 * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
2418 * @vha: HA context
2419 *
2420 * Returns 0 on success.
2421 */
2422int
2423qla2300_pci_config(scsi_qla_host_t *vha)
2424{
2425        uint16_t        w;
2426        unsigned long   flags = 0;
2427        uint32_t        cnt;
2428        struct qla_hw_data *ha = vha->hw;
2429        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2430
2431        pci_set_master(ha->pdev);
2432        pci_try_set_mwi(ha->pdev);
2433
2434        pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
2435        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
2436
2437        if (IS_QLA2322(ha) || IS_QLA6322(ha))
2438                w &= ~PCI_COMMAND_INTX_DISABLE;
2439        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
2440
2441        /*
2442         * If this is a 2300 card and not 2312, reset the
2443         * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
2444         * the 2310 also reports itself as a 2300 so we need to get the
2445         * fb revision level -- a 6 indicates it really is a 2300 and
2446         * not a 2310.
2447         */
2448        if (IS_QLA2300(ha)) {
2449                spin_lock_irqsave(&ha->hardware_lock, flags);
2450
2451                /* Pause RISC. */
2452                wrt_reg_word(&reg->hccr, HCCR_PAUSE_RISC);
2453                for (cnt = 0; cnt < 30000; cnt++) {
2454                        if ((rd_reg_word(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
2455                                break;
2456
2457                        udelay(10);
2458                }
2459
2460                /* Select FPM registers. */
2461                wrt_reg_word(&reg->ctrl_status, 0x20);
2462                rd_reg_word(&reg->ctrl_status);
2463
2464                /* Get the fb rev level */
2465                ha->fb_rev = RD_FB_CMD_REG(ha, reg);
2466
2467                if (ha->fb_rev == FPM_2300)
2468                        pci_clear_mwi(ha->pdev);
2469
2470                /* Deselect FPM registers. */
2471                wrt_reg_word(&reg->ctrl_status, 0x0);
2472                rd_reg_word(&reg->ctrl_status);
2473
2474                /* Release RISC module. */
2475                wrt_reg_word(&reg->hccr, HCCR_RELEASE_RISC);
2476                for (cnt = 0; cnt < 30000; cnt++) {
2477                        if ((rd_reg_word(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
2478                                break;
2479
2480                        udelay(10);
2481                }
2482
2483                spin_unlock_irqrestore(&ha->hardware_lock, flags);
2484        }
2485
2486        pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
2487
2488        pci_disable_rom(ha->pdev);
2489
2490        /* Get PCI bus information. */
2491        spin_lock_irqsave(&ha->hardware_lock, flags);
2492        ha->pci_attr = rd_reg_word(&reg->ctrl_status);
2493        spin_unlock_irqrestore(&ha->hardware_lock, flags);
2494
2495        return QLA_SUCCESS;
2496}
2497
2498/**
2499 * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
2500 * @vha: HA context
2501 *
2502 * Returns 0 on success.
2503 */
2504int
2505qla24xx_pci_config(scsi_qla_host_t *vha)
2506{
2507        uint16_t w;
2508        unsigned long flags = 0;
2509        struct qla_hw_data *ha = vha->hw;
2510        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2511
2512        pci_set_master(ha->pdev);
2513        pci_try_set_mwi(ha->pdev);
2514
2515        pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
2516        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
2517        w &= ~PCI_COMMAND_INTX_DISABLE;
2518        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
2519
2520        pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
2521
2522        /* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
2523        if (pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX))
2524                pcix_set_mmrbc(ha->pdev, 2048);
2525
2526        /* PCIe -- adjust Maximum Read Request Size (2048). */
2527        if (pci_is_pcie(ha->pdev))
2528                pcie_set_readrq(ha->pdev, 4096);
2529
2530        pci_disable_rom(ha->pdev);
2531
2532        ha->chip_revision = ha->pdev->revision;
2533
2534        /* Get PCI bus information. */
2535        spin_lock_irqsave(&ha->hardware_lock, flags);
2536        ha->pci_attr = rd_reg_dword(&reg->ctrl_status);
2537        spin_unlock_irqrestore(&ha->hardware_lock, flags);
2538
2539        return QLA_SUCCESS;
2540}
2541
2542/**
2543 * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
2544 * @vha: HA context
2545 *
2546 * Returns 0 on success.
2547 */
2548int
2549qla25xx_pci_config(scsi_qla_host_t *vha)
2550{
2551        uint16_t w;
2552        struct qla_hw_data *ha = vha->hw;
2553
2554        pci_set_master(ha->pdev);
2555        pci_try_set_mwi(ha->pdev);
2556
2557        pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
2558        w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
2559        w &= ~PCI_COMMAND_INTX_DISABLE;
2560        pci_write_config_word(ha->pdev, PCI_COMMAND, w);
2561
2562        /* PCIe -- adjust Maximum Read Request Size (2048). */
2563        if (pci_is_pcie(ha->pdev))
2564                pcie_set_readrq(ha->pdev, 4096);
2565
2566        pci_disable_rom(ha->pdev);
2567
2568        ha->chip_revision = ha->pdev->revision;
2569
2570        return QLA_SUCCESS;
2571}
2572
2573/**
2574 * qla2x00_isp_firmware() - Choose firmware image.
2575 * @vha: HA context
2576 *
2577 * Returns 0 on success.
2578 */
2579static int
2580qla2x00_isp_firmware(scsi_qla_host_t *vha)
2581{
2582        int  rval;
2583        uint16_t loop_id, topo, sw_cap;
2584        uint8_t domain, area, al_pa;
2585        struct qla_hw_data *ha = vha->hw;
2586
2587        /* Assume loading risc code */
2588        rval = QLA_FUNCTION_FAILED;
2589
2590        if (ha->flags.disable_risc_code_load) {
2591                ql_log(ql_log_info, vha, 0x0079, "RISC CODE NOT loaded.\n");
2592
2593                /* Verify checksum of loaded RISC code. */
2594                rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
2595                if (rval == QLA_SUCCESS) {
2596                        /* And, verify we are not in ROM code. */
2597                        rval = qla2x00_get_adapter_id(vha, &loop_id, &al_pa,
2598                            &area, &domain, &topo, &sw_cap);
2599                }
2600        }
2601
2602        if (rval)
2603                ql_dbg(ql_dbg_init, vha, 0x007a,
2604                    "**** Load RISC code ****.\n");
2605
2606        return (rval);
2607}
2608
2609/**
2610 * qla2x00_reset_chip() - Reset ISP chip.
2611 * @vha: HA context
2612 *
2613 * Returns 0 on success.
2614 */
2615int
2616qla2x00_reset_chip(scsi_qla_host_t *vha)
2617{
2618        unsigned long   flags = 0;
2619        struct qla_hw_data *ha = vha->hw;
2620        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2621        uint32_t        cnt;
2622        uint16_t        cmd;
2623        int rval = QLA_FUNCTION_FAILED;
2624
2625        if (unlikely(pci_channel_offline(ha->pdev)))
2626                return rval;
2627
2628        ha->isp_ops->disable_intrs(ha);
2629
2630        spin_lock_irqsave(&ha->hardware_lock, flags);
2631
2632        /* Turn off master enable */
2633        cmd = 0;
2634        pci_read_config_word(ha->pdev, PCI_COMMAND, &cmd);
2635        cmd &= ~PCI_COMMAND_MASTER;
2636        pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
2637
2638        if (!IS_QLA2100(ha)) {
2639                /* Pause RISC. */
2640                wrt_reg_word(&reg->hccr, HCCR_PAUSE_RISC);
2641                if (IS_QLA2200(ha) || IS_QLA2300(ha)) {
2642                        for (cnt = 0; cnt < 30000; cnt++) {
2643                                if ((rd_reg_word(&reg->hccr) &
2644                                    HCCR_RISC_PAUSE) != 0)
2645                                        break;
2646                                udelay(100);
2647                        }
2648                } else {
2649                        rd_reg_word(&reg->hccr);        /* PCI Posting. */
2650                        udelay(10);
2651                }
2652
2653                /* Select FPM registers. */
2654                wrt_reg_word(&reg->ctrl_status, 0x20);
2655                rd_reg_word(&reg->ctrl_status);         /* PCI Posting. */
2656
2657                /* FPM Soft Reset. */
2658                wrt_reg_word(&reg->fpm_diag_config, 0x100);
2659                rd_reg_word(&reg->fpm_diag_config);     /* PCI Posting. */
2660
2661                /* Toggle Fpm Reset. */
2662                if (!IS_QLA2200(ha)) {
2663                        wrt_reg_word(&reg->fpm_diag_config, 0x0);
2664                        rd_reg_word(&reg->fpm_diag_config); /* PCI Posting. */
2665                }
2666
2667                /* Select frame buffer registers. */
2668                wrt_reg_word(&reg->ctrl_status, 0x10);
2669                rd_reg_word(&reg->ctrl_status);         /* PCI Posting. */
2670
2671                /* Reset frame buffer FIFOs. */
2672                if (IS_QLA2200(ha)) {
2673                        WRT_FB_CMD_REG(ha, reg, 0xa000);
2674                        RD_FB_CMD_REG(ha, reg);         /* PCI Posting. */
2675                } else {
2676                        WRT_FB_CMD_REG(ha, reg, 0x00fc);
2677
2678                        /* Read back fb_cmd until zero or 3 seconds max */
2679                        for (cnt = 0; cnt < 3000; cnt++) {
2680                                if ((RD_FB_CMD_REG(ha, reg) & 0xff) == 0)
2681                                        break;
2682                                udelay(100);
2683                        }
2684                }
2685
2686                /* Select RISC module registers. */
2687                wrt_reg_word(&reg->ctrl_status, 0);
2688                rd_reg_word(&reg->ctrl_status);         /* PCI Posting. */
2689
2690                /* Reset RISC processor. */
2691                wrt_reg_word(&reg->hccr, HCCR_RESET_RISC);
2692                rd_reg_word(&reg->hccr);                /* PCI Posting. */
2693
2694                /* Release RISC processor. */
2695                wrt_reg_word(&reg->hccr, HCCR_RELEASE_RISC);
2696                rd_reg_word(&reg->hccr);                /* PCI Posting. */
2697        }
2698
2699        wrt_reg_word(&reg->hccr, HCCR_CLR_RISC_INT);
2700        wrt_reg_word(&reg->hccr, HCCR_CLR_HOST_INT);
2701
2702        /* Reset ISP chip. */
2703        wrt_reg_word(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
2704
2705        /* Wait for RISC to recover from reset. */
2706        if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
2707                /*
2708                 * It is necessary to for a delay here since the card doesn't
2709                 * respond to PCI reads during a reset. On some architectures
2710                 * this will result in an MCA.
2711                 */
2712                udelay(20);
2713                for (cnt = 30000; cnt; cnt--) {
2714                        if ((rd_reg_word(&reg->ctrl_status) &
2715                            CSR_ISP_SOFT_RESET) == 0)
2716                                break;
2717                        udelay(100);
2718                }
2719        } else
2720                udelay(10);
2721
2722        /* Reset RISC processor. */
2723        wrt_reg_word(&reg->hccr, HCCR_RESET_RISC);
2724
2725        wrt_reg_word(&reg->semaphore, 0);
2726
2727        /* Release RISC processor. */
2728        wrt_reg_word(&reg->hccr, HCCR_RELEASE_RISC);
2729        rd_reg_word(&reg->hccr);                        /* PCI Posting. */
2730
2731        if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
2732                for (cnt = 0; cnt < 30000; cnt++) {
2733                        if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
2734                                break;
2735
2736                        udelay(100);
2737                }
2738        } else
2739                udelay(100);
2740
2741        /* Turn on master enable */
2742        cmd |= PCI_COMMAND_MASTER;
2743        pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
2744
2745        /* Disable RISC pause on FPM parity error. */
2746        if (!IS_QLA2100(ha)) {
2747                wrt_reg_word(&reg->hccr, HCCR_DISABLE_PARITY_PAUSE);
2748                rd_reg_word(&reg->hccr);                /* PCI Posting. */
2749        }
2750
2751        spin_unlock_irqrestore(&ha->hardware_lock, flags);
2752
2753        return QLA_SUCCESS;
2754}
2755
2756/**
2757 * qla81xx_reset_mpi() - Reset's MPI FW via Write MPI Register MBC.
2758 * @vha: HA context
2759 *
2760 * Returns 0 on success.
2761 */
2762static int
2763qla81xx_reset_mpi(scsi_qla_host_t *vha)
2764{
2765        uint16_t mb[4] = {0x1010, 0, 1, 0};
2766
2767        if (!IS_QLA81XX(vha->hw))
2768                return QLA_SUCCESS;
2769
2770        return qla81xx_write_mpi_register(vha, mb);
2771}
2772
2773static int
2774qla_chk_risc_recovery(scsi_qla_host_t *vha)
2775{
2776        struct qla_hw_data *ha = vha->hw;
2777        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2778        __le16 __iomem *mbptr = &reg->mailbox0;
2779        int i;
2780        u16 mb[32];
2781        int rc = QLA_SUCCESS;
2782
2783        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
2784                return rc;
2785
2786        /* this check is only valid after RISC reset */
2787        mb[0] = rd_reg_word(mbptr);
2788        mbptr++;
2789        if (mb[0] == 0xf) {
2790                rc = QLA_FUNCTION_FAILED;
2791
2792                for (i = 1; i < 32; i++) {
2793                        mb[i] = rd_reg_word(mbptr);
2794                        mbptr++;
2795                }
2796
2797                ql_log(ql_log_warn, vha, 0x1015,
2798                       "RISC reset failed. mb[0-7] %04xh %04xh %04xh %04xh %04xh %04xh %04xh %04xh\n",
2799                       mb[0], mb[1], mb[2], mb[3], mb[4], mb[5], mb[6], mb[7]);
2800                ql_log(ql_log_warn, vha, 0x1015,
2801                       "RISC reset failed. mb[8-15] %04xh %04xh %04xh %04xh %04xh %04xh %04xh %04xh\n",
2802                       mb[8], mb[9], mb[10], mb[11], mb[12], mb[13], mb[14],
2803                       mb[15]);
2804                ql_log(ql_log_warn, vha, 0x1015,
2805                       "RISC reset failed. mb[16-23] %04xh %04xh %04xh %04xh %04xh %04xh %04xh %04xh\n",
2806                       mb[16], mb[17], mb[18], mb[19], mb[20], mb[21], mb[22],
2807                       mb[23]);
2808                ql_log(ql_log_warn, vha, 0x1015,
2809                       "RISC reset failed. mb[24-31] %04xh %04xh %04xh %04xh %04xh %04xh %04xh %04xh\n",
2810                       mb[24], mb[25], mb[26], mb[27], mb[28], mb[29], mb[30],
2811                       mb[31]);
2812        }
2813        return rc;
2814}
2815
2816/**
2817 * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
2818 * @vha: HA context
2819 *
2820 * Returns 0 on success.
2821 */
2822static inline int
2823qla24xx_reset_risc(scsi_qla_host_t *vha)
2824{
2825        unsigned long flags = 0;
2826        struct qla_hw_data *ha = vha->hw;
2827        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2828        uint32_t cnt;
2829        uint16_t wd;
2830        static int abts_cnt; /* ISP abort retry counts */
2831        int rval = QLA_SUCCESS;
2832        int print = 1;
2833
2834        spin_lock_irqsave(&ha->hardware_lock, flags);
2835
2836        /* Reset RISC. */
2837        wrt_reg_dword(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
2838        for (cnt = 0; cnt < 30000; cnt++) {
2839                if ((rd_reg_dword(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
2840                        break;
2841
2842                udelay(10);
2843        }
2844
2845        if (!(rd_reg_dword(&reg->ctrl_status) & CSRX_DMA_ACTIVE))
2846                set_bit(DMA_SHUTDOWN_CMPL, &ha->fw_dump_cap_flags);
2847
2848        ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x017e,
2849            "HCCR: 0x%x, Control Status %x, DMA active status:0x%x\n",
2850            rd_reg_dword(&reg->hccr),
2851            rd_reg_dword(&reg->ctrl_status),
2852            (rd_reg_dword(&reg->ctrl_status) & CSRX_DMA_ACTIVE));
2853
2854        wrt_reg_dword(&reg->ctrl_status,
2855            CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
2856        pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
2857
2858        udelay(100);
2859
2860        /* Wait for firmware to complete NVRAM accesses. */
2861        rd_reg_word(&reg->mailbox0);
2862        for (cnt = 10000; rd_reg_word(&reg->mailbox0) != 0 &&
2863            rval == QLA_SUCCESS; cnt--) {
2864                barrier();
2865                if (cnt)
2866                        udelay(5);
2867                else
2868                        rval = QLA_FUNCTION_TIMEOUT;
2869        }
2870
2871        if (rval == QLA_SUCCESS)
2872                set_bit(ISP_MBX_RDY, &ha->fw_dump_cap_flags);
2873
2874        ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x017f,
2875            "HCCR: 0x%x, MailBox0 Status 0x%x\n",
2876            rd_reg_dword(&reg->hccr),
2877            rd_reg_word(&reg->mailbox0));
2878
2879        /* Wait for soft-reset to complete. */
2880        rd_reg_dword(&reg->ctrl_status);
2881        for (cnt = 0; cnt < 60; cnt++) {
2882                barrier();
2883                if ((rd_reg_dword(&reg->ctrl_status) &
2884                    CSRX_ISP_SOFT_RESET) == 0)
2885                        break;
2886
2887                udelay(5);
2888        }
2889        if (!(rd_reg_dword(&reg->ctrl_status) & CSRX_ISP_SOFT_RESET))
2890                set_bit(ISP_SOFT_RESET_CMPL, &ha->fw_dump_cap_flags);
2891
2892        ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x015d,
2893            "HCCR: 0x%x, Soft Reset status: 0x%x\n",
2894            rd_reg_dword(&reg->hccr),
2895            rd_reg_dword(&reg->ctrl_status));
2896
2897        /* If required, do an MPI FW reset now */
2898        if (test_and_clear_bit(MPI_RESET_NEEDED, &vha->dpc_flags)) {
2899                if (qla81xx_reset_mpi(vha) != QLA_SUCCESS) {
2900                        if (++abts_cnt < 5) {
2901                                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2902                                set_bit(MPI_RESET_NEEDED, &vha->dpc_flags);
2903                        } else {
2904                                /*
2905                                 * We exhausted the ISP abort retries. We have to
2906                                 * set the board offline.
2907                                 */
2908                                abts_cnt = 0;
2909                                vha->flags.online = 0;
2910                        }
2911                }
2912        }
2913
2914        wrt_reg_dword(&reg->hccr, HCCRX_SET_RISC_RESET);
2915        rd_reg_dword(&reg->hccr);
2916
2917        wrt_reg_dword(&reg->hccr, HCCRX_REL_RISC_PAUSE);
2918        rd_reg_dword(&reg->hccr);
2919
2920        wrt_reg_dword(&reg->hccr, HCCRX_CLR_RISC_RESET);
2921        mdelay(10);
2922        rd_reg_dword(&reg->hccr);
2923
2924        wd = rd_reg_word(&reg->mailbox0);
2925        for (cnt = 300; wd != 0 && rval == QLA_SUCCESS; cnt--) {
2926                barrier();
2927                if (cnt) {
2928                        mdelay(1);
2929                        if (print && qla_chk_risc_recovery(vha))
2930                                print = 0;
2931
2932                        wd = rd_reg_word(&reg->mailbox0);
2933                } else {
2934                        rval = QLA_FUNCTION_TIMEOUT;
2935
2936                        ql_log(ql_log_warn, vha, 0x015e,
2937                               "RISC reset timeout\n");
2938                }
2939        }
2940
2941        if (rval == QLA_SUCCESS)
2942                set_bit(RISC_RDY_AFT_RESET, &ha->fw_dump_cap_flags);
2943
2944        ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x015e,
2945            "Host Risc 0x%x, mailbox0 0x%x\n",
2946            rd_reg_dword(&reg->hccr),
2947             rd_reg_word(&reg->mailbox0));
2948
2949        spin_unlock_irqrestore(&ha->hardware_lock, flags);
2950
2951        ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x015f,
2952            "Driver in %s mode\n",
2953            IS_NOPOLLING_TYPE(ha) ? "Interrupt" : "Polling");
2954
2955        if (IS_NOPOLLING_TYPE(ha))
2956                ha->isp_ops->enable_intrs(ha);
2957
2958        return rval;
2959}
2960
2961static void
2962qla25xx_read_risc_sema_reg(scsi_qla_host_t *vha, uint32_t *data)
2963{
2964        struct device_reg_24xx __iomem *reg = &vha->hw->iobase->isp24;
2965
2966        wrt_reg_dword(&reg->iobase_addr, RISC_REGISTER_BASE_OFFSET);
2967        *data = rd_reg_dword(&reg->iobase_window + RISC_REGISTER_WINDOW_OFFSET);
2968}
2969
2970static void
2971qla25xx_write_risc_sema_reg(scsi_qla_host_t *vha, uint32_t data)
2972{
2973        struct device_reg_24xx __iomem *reg = &vha->hw->iobase->isp24;
2974
2975        wrt_reg_dword(&reg->iobase_addr, RISC_REGISTER_BASE_OFFSET);
2976        wrt_reg_dword(&reg->iobase_window + RISC_REGISTER_WINDOW_OFFSET, data);
2977}
2978
2979static void
2980qla25xx_manipulate_risc_semaphore(scsi_qla_host_t *vha)
2981{
2982        uint32_t wd32 = 0;
2983        uint delta_msec = 100;
2984        uint elapsed_msec = 0;
2985        uint timeout_msec;
2986        ulong n;
2987
2988        if (vha->hw->pdev->subsystem_device != 0x0175 &&
2989            vha->hw->pdev->subsystem_device != 0x0240)
2990                return;
2991
2992        wrt_reg_dword(&vha->hw->iobase->isp24.hccr, HCCRX_SET_RISC_PAUSE);
2993        udelay(100);
2994
2995attempt:
2996        timeout_msec = TIMEOUT_SEMAPHORE;
2997        n = timeout_msec / delta_msec;
2998        while (n--) {
2999                qla25xx_write_risc_sema_reg(vha, RISC_SEMAPHORE_SET);
3000                qla25xx_read_risc_sema_reg(vha, &wd32);
3001                if (wd32 & RISC_SEMAPHORE)
3002                        break;
3003                msleep(delta_msec);
3004                elapsed_msec += delta_msec;
3005                if (elapsed_msec > TIMEOUT_TOTAL_ELAPSED)
3006                        goto force;
3007        }
3008
3009        if (!(wd32 & RISC_SEMAPHORE))
3010                goto force;
3011
3012        if (!(wd32 & RISC_SEMAPHORE_FORCE))
3013                goto acquired;
3014
3015        qla25xx_write_risc_sema_reg(vha, RISC_SEMAPHORE_CLR);
3016        timeout_msec = TIMEOUT_SEMAPHORE_FORCE;
3017        n = timeout_msec / delta_msec;
3018        while (n--) {
3019                qla25xx_read_risc_sema_reg(vha, &wd32);
3020                if (!(wd32 & RISC_SEMAPHORE_FORCE))
3021                        break;
3022                msleep(delta_msec);
3023                elapsed_msec += delta_msec;
3024                if (elapsed_msec > TIMEOUT_TOTAL_ELAPSED)
3025                        goto force;
3026        }
3027
3028        if (wd32 & RISC_SEMAPHORE_FORCE)
3029                qla25xx_write_risc_sema_reg(vha, RISC_SEMAPHORE_FORCE_CLR);
3030
3031        goto attempt;
3032
3033force:
3034        qla25xx_write_risc_sema_reg(vha, RISC_SEMAPHORE_FORCE_SET);
3035
3036acquired:
3037        return;
3038}
3039
3040/**
3041 * qla24xx_reset_chip() - Reset ISP24xx chip.
3042 * @vha: HA context
3043 *
3044 * Returns 0 on success.
3045 */
3046int
3047qla24xx_reset_chip(scsi_qla_host_t *vha)
3048{
3049        struct qla_hw_data *ha = vha->hw;
3050        int rval = QLA_FUNCTION_FAILED;
3051
3052        if (pci_channel_offline(ha->pdev) &&
3053            ha->flags.pci_channel_io_perm_failure) {
3054                return rval;
3055        }
3056
3057        ha->isp_ops->disable_intrs(ha);
3058
3059        qla25xx_manipulate_risc_semaphore(vha);
3060
3061        /* Perform RISC reset. */
3062        rval = qla24xx_reset_risc(vha);
3063
3064        return rval;
3065}
3066
3067/**
3068 * qla2x00_chip_diag() - Test chip for proper operation.
3069 * @vha: HA context
3070 *
3071 * Returns 0 on success.
3072 */
3073int
3074qla2x00_chip_diag(scsi_qla_host_t *vha)
3075{
3076        int             rval;
3077        struct qla_hw_data *ha = vha->hw;
3078        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
3079        unsigned long   flags = 0;
3080        uint16_t        data;
3081        uint32_t        cnt;
3082        uint16_t        mb[5];
3083        struct req_que *req = ha->req_q_map[0];
3084
3085        /* Assume a failed state */
3086        rval = QLA_FUNCTION_FAILED;
3087
3088        ql_dbg(ql_dbg_init, vha, 0x007b, "Testing device at %p.\n",
3089               &reg->flash_address);
3090
3091        spin_lock_irqsave(&ha->hardware_lock, flags);
3092
3093        /* Reset ISP chip. */
3094        wrt_reg_word(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
3095
3096        /*
3097         * We need to have a delay here since the card will not respond while
3098         * in reset causing an MCA on some architectures.
3099         */
3100        udelay(20);
3101        data = qla2x00_debounce_register(&reg->ctrl_status);
3102        for (cnt = 6000000 ; cnt && (data & CSR_ISP_SOFT_RESET); cnt--) {
3103                udelay(5);
3104                data = rd_reg_word(&reg->ctrl_status);
3105                barrier();
3106        }
3107
3108        if (!cnt)
3109                goto chip_diag_failed;
3110
3111        ql_dbg(ql_dbg_init, vha, 0x007c,
3112            "Reset register cleared by chip reset.\n");
3113
3114        /* Reset RISC processor. */
3115        wrt_reg_word(&reg->hccr, HCCR_RESET_RISC);
3116        wrt_reg_word(&reg->hccr, HCCR_RELEASE_RISC);
3117
3118        /* Workaround for QLA2312 PCI parity error */
3119        if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
3120                data = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 0));
3121                for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
3122                        udelay(5);
3123                        data = RD_MAILBOX_REG(ha, reg, 0);
3124                        barrier();
3125                }
3126        } else
3127                udelay(10);
3128
3129        if (!cnt)
3130                goto chip_diag_failed;
3131
3132        /* Check product ID of chip */
3133        ql_dbg(ql_dbg_init, vha, 0x007d, "Checking product ID of chip.\n");
3134
3135        mb[1] = RD_MAILBOX_REG(ha, reg, 1);
3136        mb[2] = RD_MAILBOX_REG(ha, reg, 2);
3137        mb[3] = RD_MAILBOX_REG(ha, reg, 3);
3138        mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
3139        if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
3140            mb[3] != PROD_ID_3) {
3141                ql_log(ql_log_warn, vha, 0x0062,
3142                    "Wrong product ID = 0x%x,0x%x,0x%x.\n",
3143                    mb[1], mb[2], mb[3]);
3144
3145                goto chip_diag_failed;
3146        }
3147        ha->product_id[0] = mb[1];
3148        ha->product_id[1] = mb[2];
3149        ha->product_id[2] = mb[3];
3150        ha->product_id[3] = mb[4];
3151
3152        /* Adjust fw RISC transfer size */
3153        if (req->length > 1024)
3154                ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
3155        else
3156                ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
3157                    req->length;
3158
3159        if (IS_QLA2200(ha) &&
3160            RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
3161                /* Limit firmware transfer size with a 2200A */
3162                ql_dbg(ql_dbg_init, vha, 0x007e, "Found QLA2200A Chip.\n");
3163
3164                ha->device_type |= DT_ISP2200A;
3165                ha->fw_transfer_size = 128;
3166        }
3167
3168        /* Wrap Incoming Mailboxes Test. */
3169        spin_unlock_irqrestore(&ha->hardware_lock, flags);
3170
3171        ql_dbg(ql_dbg_init, vha, 0x007f, "Checking mailboxes.\n");
3172        rval = qla2x00_mbx_reg_test(vha);
3173        if (rval)
3174                ql_log(ql_log_warn, vha, 0x0080,
3175                    "Failed mailbox send register test.\n");
3176        else
3177                /* Flag a successful rval */
3178                rval = QLA_SUCCESS;
3179        spin_lock_irqsave(&ha->hardware_lock, flags);
3180
3181chip_diag_failed:
3182        if (rval)
3183                ql_log(ql_log_info, vha, 0x0081,
3184                    "Chip diagnostics **** FAILED ****.\n");
3185
3186        spin_unlock_irqrestore(&ha->hardware_lock, flags);
3187
3188        return (rval);
3189}
3190
3191/**
3192 * qla24xx_chip_diag() - Test ISP24xx for proper operation.
3193 * @vha: HA context
3194 *
3195 * Returns 0 on success.
3196 */
3197int
3198qla24xx_chip_diag(scsi_qla_host_t *vha)
3199{
3200        int rval;
3201        struct qla_hw_data *ha = vha->hw;
3202        struct req_que *req = ha->req_q_map[0];
3203
3204        if (IS_P3P_TYPE(ha))
3205                return QLA_SUCCESS;
3206
3207        ha->fw_transfer_size = REQUEST_ENTRY_SIZE * req->length;
3208
3209        rval = qla2x00_mbx_reg_test(vha);
3210        if (rval) {
3211                ql_log(ql_log_warn, vha, 0x0082,
3212                    "Failed mailbox send register test.\n");
3213        } else {
3214                /* Flag a successful rval */
3215                rval = QLA_SUCCESS;
3216        }
3217
3218        return rval;
3219}
3220
3221static void
3222qla2x00_init_fce_trace(scsi_qla_host_t *vha)
3223{
3224        int rval;
3225        dma_addr_t tc_dma;
3226        void *tc;
3227        struct qla_hw_data *ha = vha->hw;
3228
3229        if (!IS_FWI2_CAPABLE(ha))
3230                return;
3231
3232        if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
3233            !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
3234                return;
3235
3236        if (ha->fce) {
3237                ql_dbg(ql_dbg_init, vha, 0x00bd,
3238                       "%s: FCE Mem is already allocated.\n",
3239                       __func__);
3240                return;
3241        }
3242
3243        /* Allocate memory for Fibre Channel Event Buffer. */
3244        tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
3245                                GFP_KERNEL);
3246        if (!tc) {
3247                ql_log(ql_log_warn, vha, 0x00be,
3248                       "Unable to allocate (%d KB) for FCE.\n",
3249                       FCE_SIZE / 1024);
3250                return;
3251        }
3252
3253        rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
3254                                        ha->fce_mb, &ha->fce_bufs);
3255        if (rval) {
3256                ql_log(ql_log_warn, vha, 0x00bf,
3257                       "Unable to initialize FCE (%d).\n", rval);
3258                dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc, tc_dma);
3259                return;
3260        }
3261
3262        ql_dbg(ql_dbg_init, vha, 0x00c0,
3263               "Allocated (%d KB) for FCE...\n", FCE_SIZE / 1024);
3264
3265        ha->flags.fce_enabled = 1;
3266        ha->fce_dma = tc_dma;
3267        ha->fce = tc;
3268}
3269
3270static void
3271qla2x00_init_eft_trace(scsi_qla_host_t *vha)
3272{
3273        int rval;
3274        dma_addr_t tc_dma;
3275        void *tc;
3276        struct qla_hw_data *ha = vha->hw;
3277
3278        if (!IS_FWI2_CAPABLE(ha))
3279                return;
3280
3281        if (ha->eft) {
3282                ql_dbg(ql_dbg_init, vha, 0x00bd,
3283                    "%s: EFT Mem is already allocated.\n",
3284                    __func__);
3285                return;
3286        }
3287
3288        /* Allocate memory for Extended Trace Buffer. */
3289        tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
3290                                GFP_KERNEL);
3291        if (!tc) {
3292                ql_log(ql_log_warn, vha, 0x00c1,
3293                       "Unable to allocate (%d KB) for EFT.\n",
3294                       EFT_SIZE / 1024);
3295                return;
3296        }
3297
3298        rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
3299        if (rval) {
3300                ql_log(ql_log_warn, vha, 0x00c2,
3301                       "Unable to initialize EFT (%d).\n", rval);
3302                dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc, tc_dma);
3303                return;
3304        }
3305
3306        ql_dbg(ql_dbg_init, vha, 0x00c3,
3307               "Allocated (%d KB) EFT ...\n", EFT_SIZE / 1024);
3308
3309        ha->eft_dma = tc_dma;
3310        ha->eft = tc;
3311}
3312
3313static void
3314qla2x00_alloc_offload_mem(scsi_qla_host_t *vha)
3315{
3316        qla2x00_init_fce_trace(vha);
3317        qla2x00_init_eft_trace(vha);
3318}
3319
3320void
3321qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
3322{
3323        uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
3324            eft_size, fce_size, mq_size;
3325        struct qla_hw_data *ha = vha->hw;
3326        struct req_que *req = ha->req_q_map[0];
3327        struct rsp_que *rsp = ha->rsp_q_map[0];
3328        struct qla2xxx_fw_dump *fw_dump;
3329
3330        dump_size = fixed_size = mem_size = eft_size = fce_size = mq_size = 0;
3331        req_q_size = rsp_q_size = 0;
3332
3333        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
3334                fixed_size = sizeof(struct qla2100_fw_dump);
3335        } else if (IS_QLA23XX(ha)) {
3336                fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
3337                mem_size = (ha->fw_memory_size - 0x11000 + 1) *
3338                    sizeof(uint16_t);
3339        } else if (IS_FWI2_CAPABLE(ha)) {
3340                if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
3341                        fixed_size = offsetof(struct qla83xx_fw_dump, ext_mem);
3342                else if (IS_QLA81XX(ha))
3343                        fixed_size = offsetof(struct qla81xx_fw_dump, ext_mem);
3344                else if (IS_QLA25XX(ha))
3345                        fixed_size = offsetof(struct qla25xx_fw_dump, ext_mem);
3346                else
3347                        fixed_size = offsetof(struct qla24xx_fw_dump, ext_mem);
3348
3349                mem_size = (ha->fw_memory_size - 0x100000 + 1) *
3350                    sizeof(uint32_t);
3351                if (ha->mqenable) {
3352                        if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha) &&
3353                            !IS_QLA28XX(ha))
3354                                mq_size = sizeof(struct qla2xxx_mq_chain);
3355                        /*
3356                         * Allocate maximum buffer size for all queues - Q0.
3357                         * Resizing must be done at end-of-dump processing.
3358                         */
3359                        mq_size += (ha->max_req_queues - 1) *
3360                            (req->length * sizeof(request_t));
3361                        mq_size += (ha->max_rsp_queues - 1) *
3362                            (rsp->length * sizeof(response_t));
3363                }
3364                if (ha->tgt.atio_ring)
3365                        mq_size += ha->tgt.atio_q_length * sizeof(request_t);
3366
3367                qla2x00_init_fce_trace(vha);
3368                if (ha->fce)
3369                        fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
3370                qla2x00_init_eft_trace(vha);
3371                if (ha->eft)
3372                        eft_size = EFT_SIZE;
3373        }
3374
3375        if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
3376                struct fwdt *fwdt = ha->fwdt;
3377                uint j;
3378
3379                for (j = 0; j < 2; j++, fwdt++) {
3380                        if (!fwdt->template) {
3381                                ql_dbg(ql_dbg_init, vha, 0x00ba,
3382                                    "-> fwdt%u no template\n", j);
3383                                continue;
3384                        }
3385                        ql_dbg(ql_dbg_init, vha, 0x00fa,
3386                            "-> fwdt%u calculating fwdump size...\n", j);
3387                        fwdt->dump_size = qla27xx_fwdt_calculate_dump_size(
3388                            vha, fwdt->template);
3389                        ql_dbg(ql_dbg_init, vha, 0x00fa,
3390                            "-> fwdt%u calculated fwdump size = %#lx bytes\n",
3391                            j, fwdt->dump_size);
3392                        dump_size += fwdt->dump_size;
3393                }
3394                /* Add space for spare MPI fw dump. */
3395                dump_size += ha->fwdt[1].dump_size;
3396        } else {
3397                req_q_size = req->length * sizeof(request_t);
3398                rsp_q_size = rsp->length * sizeof(response_t);
3399                dump_size = offsetof(struct qla2xxx_fw_dump, isp);
3400                dump_size += fixed_size + mem_size + req_q_size + rsp_q_size
3401                        + eft_size;
3402                ha->chain_offset = dump_size;
3403                dump_size += mq_size + fce_size;
3404                if (ha->exchoffld_buf)
3405                        dump_size += sizeof(struct qla2xxx_offld_chain) +
3406                                ha->exchoffld_size;
3407                if (ha->exlogin_buf)
3408                        dump_size += sizeof(struct qla2xxx_offld_chain) +
3409                                ha->exlogin_size;
3410        }
3411
3412        if (!ha->fw_dump_len || dump_size > ha->fw_dump_alloc_len) {
3413
3414                ql_dbg(ql_dbg_init, vha, 0x00c5,
3415                    "%s dump_size %d fw_dump_len %d fw_dump_alloc_len %d\n",
3416                    __func__, dump_size, ha->fw_dump_len,
3417                    ha->fw_dump_alloc_len);
3418
3419                fw_dump = vmalloc(dump_size);
3420                if (!fw_dump) {
3421                        ql_log(ql_log_warn, vha, 0x00c4,
3422                            "Unable to allocate (%d KB) for firmware dump.\n",
3423                            dump_size / 1024);
3424                } else {
3425                        mutex_lock(&ha->optrom_mutex);
3426                        if (ha->fw_dumped) {
3427                                memcpy(fw_dump, ha->fw_dump, ha->fw_dump_len);
3428                                vfree(ha->fw_dump);
3429                                ha->fw_dump = fw_dump;
3430                                ha->fw_dump_alloc_len =  dump_size;
3431                                ql_dbg(ql_dbg_init, vha, 0x00c5,
3432                                    "Re-Allocated (%d KB) and save firmware dump.\n",
3433                                    dump_size / 1024);
3434                        } else {
3435                                vfree(ha->fw_dump);
3436                                ha->fw_dump = fw_dump;
3437
3438                                ha->fw_dump_len = ha->fw_dump_alloc_len =
3439                                    dump_size;
3440                                ql_dbg(ql_dbg_init, vha, 0x00c5,
3441                                    "Allocated (%d KB) for firmware dump.\n",
3442                                    dump_size / 1024);
3443
3444                                if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
3445                                        ha->mpi_fw_dump = (char *)fw_dump +
3446                                                ha->fwdt[1].dump_size;
3447                                        mutex_unlock(&ha->optrom_mutex);
3448                                        return;
3449                                }
3450
3451                                ha->fw_dump->signature[0] = 'Q';
3452                                ha->fw_dump->signature[1] = 'L';
3453                                ha->fw_dump->signature[2] = 'G';
3454                                ha->fw_dump->signature[3] = 'C';
3455                                ha->fw_dump->version = htonl(1);
3456
3457                                ha->fw_dump->fixed_size = htonl(fixed_size);
3458                                ha->fw_dump->mem_size = htonl(mem_size);
3459                                ha->fw_dump->req_q_size = htonl(req_q_size);
3460                                ha->fw_dump->rsp_q_size = htonl(rsp_q_size);
3461
3462                                ha->fw_dump->eft_size = htonl(eft_size);
3463                                ha->fw_dump->eft_addr_l =
3464                                    htonl(LSD(ha->eft_dma));
3465                                ha->fw_dump->eft_addr_h =
3466                                    htonl(MSD(ha->eft_dma));
3467
3468                                ha->fw_dump->header_size =
3469                                        htonl(offsetof
3470                                            (struct qla2xxx_fw_dump, isp));
3471                        }
3472                        mutex_unlock(&ha->optrom_mutex);
3473                }
3474        }
3475}
3476
3477static int
3478qla81xx_mpi_sync(scsi_qla_host_t *vha)
3479{
3480#define MPS_MASK        0xe0
3481        int rval;
3482        uint16_t dc;
3483        uint32_t dw;
3484
3485        if (!IS_QLA81XX(vha->hw))
3486                return QLA_SUCCESS;
3487
3488        rval = qla2x00_write_ram_word(vha, 0x7c00, 1);
3489        if (rval != QLA_SUCCESS) {
3490                ql_log(ql_log_warn, vha, 0x0105,
3491                    "Unable to acquire semaphore.\n");
3492                goto done;
3493        }
3494
3495        pci_read_config_word(vha->hw->pdev, 0x54, &dc);
3496        rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
3497        if (rval != QLA_SUCCESS) {
3498                ql_log(ql_log_warn, vha, 0x0067, "Unable to read sync.\n");
3499                goto done_release;
3500        }
3501
3502        dc &= MPS_MASK;
3503        if (dc == (dw & MPS_MASK))
3504                goto done_release;
3505
3506        dw &= ~MPS_MASK;
3507        dw |= dc;
3508        rval = qla2x00_write_ram_word(vha, 0x7a15, dw);
3509        if (rval != QLA_SUCCESS) {
3510                ql_log(ql_log_warn, vha, 0x0114, "Unable to gain sync.\n");
3511        }
3512
3513done_release:
3514        rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
3515        if (rval != QLA_SUCCESS) {
3516                ql_log(ql_log_warn, vha, 0x006d,
3517                    "Unable to release semaphore.\n");
3518        }
3519
3520done:
3521        return rval;
3522}
3523
3524int
3525qla2x00_alloc_outstanding_cmds(struct qla_hw_data *ha, struct req_que *req)
3526{
3527        /* Don't try to reallocate the array */
3528        if (req->outstanding_cmds)
3529                return QLA_SUCCESS;
3530
3531        if (!IS_FWI2_CAPABLE(ha))
3532                req->num_outstanding_cmds = DEFAULT_OUTSTANDING_COMMANDS;
3533        else {
3534                if (ha->cur_fw_xcb_count <= ha->cur_fw_iocb_count)
3535                        req->num_outstanding_cmds = ha->cur_fw_xcb_count;
3536                else
3537                        req->num_outstanding_cmds = ha->cur_fw_iocb_count;
3538        }
3539
3540        req->outstanding_cmds = kcalloc(req->num_outstanding_cmds,
3541                                        sizeof(srb_t *),
3542                                        GFP_KERNEL);
3543
3544        if (!req->outstanding_cmds) {
3545                /*
3546                 * Try to allocate a minimal size just so we can get through
3547                 * initialization.
3548                 */
3549                req->num_outstanding_cmds = MIN_OUTSTANDING_COMMANDS;
3550                req->outstanding_cmds = kcalloc(req->num_outstanding_cmds,
3551                                                sizeof(srb_t *),
3552                                                GFP_KERNEL);
3553
3554                if (!req->outstanding_cmds) {
3555                        ql_log(ql_log_fatal, NULL, 0x0126,
3556                            "Failed to allocate memory for "
3557                            "outstanding_cmds for req_que %p.\n", req);
3558                        req->num_outstanding_cmds = 0;
3559                        return QLA_FUNCTION_FAILED;
3560                }
3561        }
3562
3563        return QLA_SUCCESS;
3564}
3565
3566#define PRINT_FIELD(_field, _flag, _str) {              \
3567        if (a0->_field & _flag) {\
3568                if (p) {\
3569                        strcat(ptr, "|");\
3570                        ptr++;\
3571                        leftover--;\
3572                } \
3573                len = snprintf(ptr, leftover, "%s", _str);      \
3574                p = 1;\
3575                leftover -= len;\
3576                ptr += len; \
3577        } \
3578}
3579
3580static void qla2xxx_print_sfp_info(struct scsi_qla_host *vha)
3581{
3582#define STR_LEN 64
3583        struct sff_8247_a0 *a0 = (struct sff_8247_a0 *)vha->hw->sfp_data;
3584        u8 str[STR_LEN], *ptr, p;
3585        int leftover, len;
3586
3587        memset(str, 0, STR_LEN);
3588        snprintf(str, SFF_VEN_NAME_LEN+1, a0->vendor_name);
3589        ql_dbg(ql_dbg_init, vha, 0x015a,
3590            "SFP MFG Name: %s\n", str);
3591
3592        memset(str, 0, STR_LEN);
3593        snprintf(str, SFF_PART_NAME_LEN+1, a0->vendor_pn);
3594        ql_dbg(ql_dbg_init, vha, 0x015c,
3595            "SFP Part Name: %s\n", str);
3596
3597        /* media */
3598        memset(str, 0, STR_LEN);
3599        ptr = str;
3600        leftover = STR_LEN;
3601        p = len = 0;
3602        PRINT_FIELD(fc_med_cc9, FC_MED_TW, "Twin AX");
3603        PRINT_FIELD(fc_med_cc9, FC_MED_TP, "Twisted Pair");
3604        PRINT_FIELD(fc_med_cc9, FC_MED_MI, "Min Coax");
3605        PRINT_FIELD(fc_med_cc9, FC_MED_TV, "Video Coax");
3606        PRINT_FIELD(fc_med_cc9, FC_MED_M6, "MultiMode 62.5um");
3607        PRINT_FIELD(fc_med_cc9, FC_MED_M5, "MultiMode 50um");
3608        PRINT_FIELD(fc_med_cc9, FC_MED_SM, "SingleMode");
3609        ql_dbg(ql_dbg_init, vha, 0x0160,
3610            "SFP Media: %s\n", str);
3611
3612        /* link length */
3613        memset(str, 0, STR_LEN);
3614        ptr = str;
3615        leftover = STR_LEN;
3616        p = len = 0;
3617        PRINT_FIELD(fc_ll_cc7, FC_LL_VL, "Very Long");
3618        PRINT_FIELD(fc_ll_cc7, FC_LL_S, "Short");
3619        PRINT_FIELD(fc_ll_cc7, FC_LL_I, "Intermediate");
3620        PRINT_FIELD(fc_ll_cc7, FC_LL_L, "Long");
3621        PRINT_FIELD(fc_ll_cc7, FC_LL_M, "Medium");
3622        ql_dbg(ql_dbg_init, vha, 0x0196,
3623            "SFP Link Length: %s\n", str);
3624
3625        memset(str, 0, STR_LEN);
3626        ptr = str;
3627        leftover = STR_LEN;
3628        p = len = 0;
3629        PRINT_FIELD(fc_ll_cc7, FC_LL_SA, "Short Wave (SA)");
3630        PRINT_FIELD(fc_ll_cc7, FC_LL_LC, "Long Wave(LC)");
3631        PRINT_FIELD(fc_tec_cc8, FC_TEC_SN, "Short Wave (SN)");
3632        PRINT_FIELD(fc_tec_cc8, FC_TEC_SL, "Short Wave (SL)");
3633        PRINT_FIELD(fc_tec_cc8, FC_TEC_LL, "Long Wave (LL)");
3634        ql_dbg(ql_dbg_init, vha, 0x016e,
3635            "SFP FC Link Tech: %s\n", str);
3636
3637        if (a0->length_km)
3638                ql_dbg(ql_dbg_init, vha, 0x016f,
3639                    "SFP Distant: %d km\n", a0->length_km);
3640        if (a0->length_100m)
3641                ql_dbg(ql_dbg_init, vha, 0x0170,
3642                    "SFP Distant: %d m\n", a0->length_100m*100);
3643        if (a0->length_50um_10m)
3644                ql_dbg(ql_dbg_init, vha, 0x0189,
3645                    "SFP Distant (WL=50um): %d m\n", a0->length_50um_10m * 10);
3646        if (a0->length_62um_10m)
3647                ql_dbg(ql_dbg_init, vha, 0x018a,
3648                  "SFP Distant (WL=62.5um): %d m\n", a0->length_62um_10m * 10);
3649        if (a0->length_om4_10m)
3650                ql_dbg(ql_dbg_init, vha, 0x0194,
3651                    "SFP Distant (OM4): %d m\n", a0->length_om4_10m * 10);
3652        if (a0->length_om3_10m)
3653                ql_dbg(ql_dbg_init, vha, 0x0195,
3654                    "SFP Distant (OM3): %d m\n", a0->length_om3_10m * 10);
3655}
3656
3657
3658/**
3659 * qla24xx_detect_sfp()
3660 *
3661 * @vha: adapter state pointer.
3662 *
3663 * @return
3664 *      0 -- Configure firmware to use short-range settings -- normal
3665 *           buffer-to-buffer credits.
3666 *
3667 *      1 -- Configure firmware to use long-range settings -- extra
3668 *           buffer-to-buffer credits should be allocated with
3669 *           ha->lr_distance containing distance settings from NVRAM or SFP
3670 *           (if supported).
3671 */
3672int
3673qla24xx_detect_sfp(scsi_qla_host_t *vha)
3674{
3675        int rc, used_nvram;
3676        struct sff_8247_a0 *a;
3677        struct qla_hw_data *ha = vha->hw;
3678        struct nvram_81xx *nv = ha->nvram;
3679#define LR_DISTANCE_UNKNOWN     2
3680        static const char * const types[] = { "Short", "Long" };
3681        static const char * const lengths[] = { "(10km)", "(5km)", "" };
3682        u8 ll = 0;
3683
3684        /* Seed with NVRAM settings. */
3685        used_nvram = 0;
3686        ha->flags.lr_detected = 0;
3687        if (IS_BPM_RANGE_CAPABLE(ha) &&
3688            (nv->enhanced_features & NEF_LR_DIST_ENABLE)) {
3689                used_nvram = 1;
3690                ha->flags.lr_detected = 1;
3691                ha->lr_distance =
3692                    (nv->enhanced_features >> LR_DIST_NV_POS)
3693                     & LR_DIST_NV_MASK;
3694        }
3695
3696        if (!IS_BPM_ENABLED(vha))
3697                goto out;
3698        /* Determine SR/LR capabilities of SFP/Transceiver. */
3699        rc = qla2x00_read_sfp_dev(vha, NULL, 0);
3700        if (rc)
3701                goto out;
3702
3703        used_nvram = 0;
3704        a = (struct sff_8247_a0 *)vha->hw->sfp_data;
3705        qla2xxx_print_sfp_info(vha);
3706
3707        ha->flags.lr_detected = 0;
3708        ll = a->fc_ll_cc7;
3709        if (ll & FC_LL_VL || ll & FC_LL_L) {
3710                /* Long range, track length. */
3711                ha->flags.lr_detected = 1;
3712
3713                if (a->length_km > 5 || a->length_100m > 50)
3714                        ha->lr_distance = LR_DISTANCE_10K;
3715                else
3716                        ha->lr_distance = LR_DISTANCE_5K;
3717        }
3718
3719out:
3720        ql_dbg(ql_dbg_async, vha, 0x507b,
3721            "SFP detect: %s-Range SFP %s (nvr=%x ll=%x lr=%x lrd=%x).\n",
3722            types[ha->flags.lr_detected],
3723            ha->flags.lr_detected ? lengths[ha->lr_distance] :
3724               lengths[LR_DISTANCE_UNKNOWN],
3725            used_nvram, ll, ha->flags.lr_detected, ha->lr_distance);
3726        return ha->flags.lr_detected;
3727}
3728
3729void qla_init_iocb_limit(scsi_qla_host_t *vha)
3730{
3731        u16 i, num_qps;
3732        u32 limit;
3733        struct qla_hw_data *ha = vha->hw;
3734
3735        num_qps = ha->num_qpairs + 1;
3736        limit = (ha->orig_fw_iocb_count * QLA_IOCB_PCT_LIMIT) / 100;
3737
3738        ha->base_qpair->fwres.iocbs_total = ha->orig_fw_iocb_count;
3739        ha->base_qpair->fwres.iocbs_limit = limit;
3740        ha->base_qpair->fwres.iocbs_qp_limit = limit / num_qps;
3741        ha->base_qpair->fwres.iocbs_used = 0;
3742        for (i = 0; i < ha->max_qpairs; i++) {
3743                if (ha->queue_pair_map[i])  {
3744                        ha->queue_pair_map[i]->fwres.iocbs_total =
3745                                ha->orig_fw_iocb_count;
3746                        ha->queue_pair_map[i]->fwres.iocbs_limit = limit;
3747                        ha->queue_pair_map[i]->fwres.iocbs_qp_limit =
3748                                limit / num_qps;
3749                        ha->queue_pair_map[i]->fwres.iocbs_used = 0;
3750                }
3751        }
3752}
3753
3754/**
3755 * qla2x00_setup_chip() - Load and start RISC firmware.
3756 * @vha: HA context
3757 *
3758 * Returns 0 on success.
3759 */
3760static int
3761qla2x00_setup_chip(scsi_qla_host_t *vha)
3762{
3763        int rval;
3764        uint32_t srisc_address = 0;
3765        struct qla_hw_data *ha = vha->hw;
3766        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
3767        unsigned long flags;
3768        uint16_t fw_major_version;
3769        int done_once = 0;
3770
3771        if (IS_P3P_TYPE(ha)) {
3772                rval = ha->isp_ops->load_risc(vha, &srisc_address);
3773                if (rval == QLA_SUCCESS) {
3774                        qla2x00_stop_firmware(vha);
3775                        goto enable_82xx_npiv;
3776                } else
3777                        goto failed;
3778        }
3779
3780        if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
3781                /* Disable SRAM, Instruction RAM and GP RAM parity.  */
3782                spin_lock_irqsave(&ha->hardware_lock, flags);
3783                wrt_reg_word(&reg->hccr, (HCCR_ENABLE_PARITY + 0x0));
3784                rd_reg_word(&reg->hccr);
3785                spin_unlock_irqrestore(&ha->hardware_lock, flags);
3786        }
3787
3788        qla81xx_mpi_sync(vha);
3789
3790execute_fw_with_lr:
3791        /* Load firmware sequences */
3792        rval = ha->isp_ops->load_risc(vha, &srisc_address);
3793        if (rval == QLA_SUCCESS) {
3794                ql_dbg(ql_dbg_init, vha, 0x00c9,
3795                    "Verifying Checksum of loaded RISC code.\n");
3796
3797                rval = qla2x00_verify_checksum(vha, srisc_address);
3798                if (rval == QLA_SUCCESS) {
3799                        /* Start firmware execution. */
3800                        ql_dbg(ql_dbg_init, vha, 0x00ca,
3801                            "Starting firmware.\n");
3802
3803                        if (ql2xexlogins)
3804                                ha->flags.exlogins_enabled = 1;
3805
3806                        if (qla_is_exch_offld_enabled(vha))
3807                                ha->flags.exchoffld_enabled = 1;
3808
3809                        rval = qla2x00_execute_fw(vha, srisc_address);
3810                        /* Retrieve firmware information. */
3811                        if (rval == QLA_SUCCESS) {
3812                                /* Enable BPM support? */
3813                                if (!done_once++ && qla24xx_detect_sfp(vha)) {
3814                                        ql_dbg(ql_dbg_init, vha, 0x00ca,
3815                                            "Re-starting firmware -- BPM.\n");
3816                                        /* Best-effort - re-init. */
3817                                        ha->isp_ops->reset_chip(vha);
3818                                        ha->isp_ops->chip_diag(vha);
3819                                        goto execute_fw_with_lr;
3820                                }
3821
3822                                if (IS_ZIO_THRESHOLD_CAPABLE(ha))
3823                                        qla27xx_set_zio_threshold(vha,
3824                                            ha->last_zio_threshold);
3825
3826                                rval = qla2x00_set_exlogins_buffer(vha);
3827                                if (rval != QLA_SUCCESS)
3828                                        goto failed;
3829
3830                                rval = qla2x00_set_exchoffld_buffer(vha);
3831                                if (rval != QLA_SUCCESS)
3832                                        goto failed;
3833
3834enable_82xx_npiv:
3835                                fw_major_version = ha->fw_major_version;
3836                                if (IS_P3P_TYPE(ha))
3837                                        qla82xx_check_md_needed(vha);
3838                                else
3839                                        rval = qla2x00_get_fw_version(vha);
3840                                if (rval != QLA_SUCCESS)
3841                                        goto failed;
3842                                ha->flags.npiv_supported = 0;
3843                                if (IS_QLA2XXX_MIDTYPE(ha) &&
3844                                         (ha->fw_attributes & BIT_2)) {
3845                                        ha->flags.npiv_supported = 1;
3846                                        if ((!ha->max_npiv_vports) ||
3847                                            ((ha->max_npiv_vports + 1) %
3848                                            MIN_MULTI_ID_FABRIC))
3849                                                ha->max_npiv_vports =
3850                                                    MIN_MULTI_ID_FABRIC - 1;
3851                                }
3852                                qla2x00_get_resource_cnts(vha);
3853                                qla_init_iocb_limit(vha);
3854
3855                                /*
3856                                 * Allocate the array of outstanding commands
3857                                 * now that we know the firmware resources.
3858                                 */
3859                                rval = qla2x00_alloc_outstanding_cmds(ha,
3860                                    vha->req);
3861                                if (rval != QLA_SUCCESS)
3862                                        goto failed;
3863
3864                                if (!fw_major_version && !(IS_P3P_TYPE(ha)))
3865                                        qla2x00_alloc_offload_mem(vha);
3866
3867                                if (ql2xallocfwdump && !(IS_P3P_TYPE(ha)))
3868                                        qla2x00_alloc_fw_dump(vha);
3869
3870                        } else {
3871                                goto failed;
3872                        }
3873                } else {
3874                        ql_log(ql_log_fatal, vha, 0x00cd,
3875                            "ISP Firmware failed checksum.\n");
3876                        goto failed;
3877                }
3878
3879                /* Enable PUREX PASSTHRU */
3880                if (ql2xrdpenable || ha->flags.scm_supported_f)
3881                        qla25xx_set_els_cmds_supported(vha);
3882        } else
3883                goto failed;
3884
3885        if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
3886                /* Enable proper parity. */
3887                spin_lock_irqsave(&ha->hardware_lock, flags);
3888                if (IS_QLA2300(ha))
3889                        /* SRAM parity */
3890                        wrt_reg_word(&reg->hccr, HCCR_ENABLE_PARITY + 0x1);
3891                else
3892                        /* SRAM, Instruction RAM and GP RAM parity */
3893                        wrt_reg_word(&reg->hccr, HCCR_ENABLE_PARITY + 0x7);
3894                rd_reg_word(&reg->hccr);
3895                spin_unlock_irqrestore(&ha->hardware_lock, flags);
3896        }
3897
3898        if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
3899                ha->flags.fac_supported = 1;
3900        else if (rval == QLA_SUCCESS && IS_FAC_REQUIRED(ha)) {
3901                uint32_t size;
3902
3903                rval = qla81xx_fac_get_sector_size(vha, &size);
3904                if (rval == QLA_SUCCESS) {
3905                        ha->flags.fac_supported = 1;
3906                        ha->fdt_block_size = size << 2;
3907                } else {
3908                        ql_log(ql_log_warn, vha, 0x00ce,
3909                            "Unsupported FAC firmware (%d.%02d.%02d).\n",
3910                            ha->fw_major_version, ha->fw_minor_version,
3911                            ha->fw_subminor_version);
3912
3913                        if (IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
3914                            IS_QLA28XX(ha)) {
3915                                ha->flags.fac_supported = 0;
3916                                rval = QLA_SUCCESS;
3917                        }
3918                }
3919        }
3920failed:
3921        if (rval) {
3922                ql_log(ql_log_fatal, vha, 0x00cf,
3923                    "Setup chip ****FAILED****.\n");
3924        }
3925
3926        return (rval);
3927}
3928
3929/**
3930 * qla2x00_init_response_q_entries() - Initializes response queue entries.
3931 * @rsp: response queue
3932 *
3933 * Beginning of request ring has initialization control block already built
3934 * by nvram config routine.
3935 *
3936 * Returns 0 on success.
3937 */
3938void
3939qla2x00_init_response_q_entries(struct rsp_que *rsp)
3940{
3941        uint16_t cnt;
3942        response_t *pkt;
3943
3944        rsp->ring_ptr = rsp->ring;
3945        rsp->ring_index    = 0;
3946        rsp->status_srb = NULL;
3947        pkt = rsp->ring_ptr;
3948        for (cnt = 0; cnt < rsp->length; cnt++) {
3949                pkt->signature = RESPONSE_PROCESSED;
3950                pkt++;
3951        }
3952}
3953
3954/**
3955 * qla2x00_update_fw_options() - Read and process firmware options.
3956 * @vha: HA context
3957 *
3958 * Returns 0 on success.
3959 */
3960void
3961qla2x00_update_fw_options(scsi_qla_host_t *vha)
3962{
3963        uint16_t swing, emphasis, tx_sens, rx_sens;
3964        struct qla_hw_data *ha = vha->hw;
3965
3966        memset(ha->fw_options, 0, sizeof(ha->fw_options));
3967        qla2x00_get_fw_options(vha, ha->fw_options);
3968
3969        if (IS_QLA2100(ha) || IS_QLA2200(ha))
3970                return;
3971
3972        /* Serial Link options. */
3973        ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x0115,
3974            "Serial link options.\n");
3975        ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0109,
3976            ha->fw_seriallink_options, sizeof(ha->fw_seriallink_options));
3977
3978        ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
3979        if (ha->fw_seriallink_options[3] & BIT_2) {
3980                ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;
3981
3982                /*  1G settings */
3983                swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
3984                emphasis = (ha->fw_seriallink_options[2] &
3985                    (BIT_4 | BIT_3)) >> 3;
3986                tx_sens = ha->fw_seriallink_options[0] &
3987                    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
3988                rx_sens = (ha->fw_seriallink_options[0] &
3989                    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
3990                ha->fw_options[10] = (emphasis << 14) | (swing << 8);
3991                if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
3992                        if (rx_sens == 0x0)
3993                                rx_sens = 0x3;
3994                        ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
3995                } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
3996                        ha->fw_options[10] |= BIT_5 |
3997                            ((rx_sens & (BIT_1 | BIT_0)) << 2) |
3998                            (tx_sens & (BIT_1 | BIT_0));
3999
4000                /*  2G settings */
4001                swing = (ha->fw_seriallink_options[2] &
4002                    (BIT_7 | BIT_6 | BIT_5)) >> 5;
4003                emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
4004                tx_sens = ha->fw_seriallink_options[1] &
4005                    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
4006                rx_sens = (ha->fw_seriallink_options[1] &
4007                    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
4008                ha->fw_options[11] = (emphasis << 14) | (swing << 8);
4009                if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
4010                        if (rx_sens == 0x0)
4011                                rx_sens = 0x3;
4012                        ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
4013                } else if (IS_QLA2322(ha) || IS_QLA6322(ha))
4014                        ha->fw_options[11] |= BIT_5 |
4015                            ((rx_sens & (BIT_1 | BIT_0)) << 2) |
4016                            (tx_sens & (BIT_1 | BIT_0));
4017        }
4018
4019        /* FCP2 options. */
4020        /*  Return command IOCBs without waiting for an ABTS to complete. */
4021        ha->fw_options[3] |= BIT_13;
4022
4023        /* LED scheme. */
4024        if (ha->flags.enable_led_scheme)
4025                ha->fw_options[2] |= BIT_12;
4026
4027        /* Detect ISP6312. */
4028        if (IS_QLA6312(ha))
4029                ha->fw_options[2] |= BIT_13;
4030
4031        /* Set Retry FLOGI in case of P2P connection */
4032        if (ha->operating_mode == P2P) {
4033                ha->fw_options[2] |= BIT_3;
4034                ql_dbg(ql_dbg_disc, vha, 0x2100,
4035                    "(%s): Setting FLOGI retry BIT in fw_options[2]: 0x%x\n",
4036                        __func__, ha->fw_options[2]);
4037        }
4038
4039        /* Update firmware options. */
4040        qla2x00_set_fw_options(vha, ha->fw_options);
4041}
4042
4043void
4044qla24xx_update_fw_options(scsi_qla_host_t *vha)
4045{
4046        int rval;
4047        struct qla_hw_data *ha = vha->hw;
4048
4049        if (IS_P3P_TYPE(ha))
4050                return;
4051
4052        /*  Hold status IOCBs until ABTS response received. */
4053        if (ql2xfwholdabts)
4054                ha->fw_options[3] |= BIT_12;
4055
4056        /* Set Retry FLOGI in case of P2P connection */
4057        if (ha->operating_mode == P2P) {
4058                ha->fw_options[2] |= BIT_3;
4059                ql_dbg(ql_dbg_disc, vha, 0x2101,
4060                    "(%s): Setting FLOGI retry BIT in fw_options[2]: 0x%x\n",
4061                        __func__, ha->fw_options[2]);
4062        }
4063
4064        /* Move PUREX, ABTS RX & RIDA to ATIOQ */
4065        if (ql2xmvasynctoatio &&
4066            (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))) {
4067                if (qla_tgt_mode_enabled(vha) ||
4068                    qla_dual_mode_enabled(vha))
4069                        ha->fw_options[2] |= BIT_11;
4070                else
4071                        ha->fw_options[2] &= ~BIT_11;
4072        }
4073
4074        if (IS_QLA25XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
4075            IS_QLA28XX(ha)) {
4076                /*
4077                 * Tell FW to track each exchange to prevent
4078                 * driver from using stale exchange.
4079                 */
4080                if (qla_tgt_mode_enabled(vha) ||
4081                    qla_dual_mode_enabled(vha))
4082                        ha->fw_options[2] |= BIT_4;
4083                else
4084                        ha->fw_options[2] &= ~BIT_4;
4085
4086                /* Reserve 1/2 of emergency exchanges for ELS.*/
4087                if (qla2xuseresexchforels)
4088                        ha->fw_options[2] |= BIT_8;
4089                else
4090                        ha->fw_options[2] &= ~BIT_8;
4091        }
4092
4093        if (ql2xrdpenable || ha->flags.scm_supported_f)
4094                ha->fw_options[1] |= ADD_FO1_ENABLE_PUREX_IOCB;
4095
4096        /* Enable Async 8130/8131 events -- transceiver insertion/removal */
4097        if (IS_BPM_RANGE_CAPABLE(ha))
4098                ha->fw_options[3] |= BIT_10;
4099
4100        ql_dbg(ql_dbg_init, vha, 0x00e8,
4101            "%s, add FW options 1-3 = 0x%04x 0x%04x 0x%04x mode %x\n",
4102            __func__, ha->fw_options[1], ha->fw_options[2],
4103            ha->fw_options[3], vha->host->active_mode);
4104
4105        if (ha->fw_options[1] || ha->fw_options[2] || ha->fw_options[3])
4106                qla2x00_set_fw_options(vha, ha->fw_options);
4107
4108        /* Update Serial Link options. */
4109        if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
4110                return;
4111
4112        rval = qla2x00_set_serdes_params(vha,
4113            le16_to_cpu(ha->fw_seriallink_options24[1]),
4114            le16_to_cpu(ha->fw_seriallink_options24[2]),
4115            le16_to_cpu(ha->fw_seriallink_options24[3]));
4116        if (rval != QLA_SUCCESS) {
4117                ql_log(ql_log_warn, vha, 0x0104,
4118                    "Unable to update Serial Link options (%x).\n", rval);
4119        }
4120}
4121
4122void
4123qla2x00_config_rings(struct scsi_qla_host *vha)
4124{