drivers/scsi/qla2xxx/qla_mid.c

   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 #include "qla_target.h"
   9
  10 #include <linux/moduleparam.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/slab.h>
  13 #include <linux/list.h>
  14
  15 #include <scsi/scsi_tcq.h>
  16 #include <scsi/scsicam.h>
  17 #include <linux/delay.h>
  18
  19 void
  20 qla2x00_vp_stop_timer(scsi_qla_host_t *vha)
  21 {
  22         if (vha->vp_idx && vha->timer_active) {
  23                 del_timer_sync(&vha->timer);
  24                 vha->timer_active = 0;
  25         }
  26 }
  27
  28 static uint32_t
  29 qla24xx_allocate_vp_id(scsi_qla_host_t *vha)
  30 {
  31         uint32_t vp_id;
  32         struct qla_hw_data *ha = vha->hw;
  33         unsigned long flags;
  34
  35         /* Find an empty slot and assign an vp_id */
  36         mutex_lock(&ha->vport_lock);
  37         vp_id = find_first_zero_bit(ha->vp_idx_map, ha->max_npiv_vports + 1);
  38         if (vp_id > ha->max_npiv_vports) {
  39                 ql_dbg(ql_dbg_vport, vha, 0xa000,
  40                     "vp_id %d is bigger than max-supported %d.\n",
  41                     vp_id, ha->max_npiv_vports);
  42                 mutex_unlock(&ha->vport_lock);
  43                 return vp_id;
  44         }
  45
  46         set_bit(vp_id, ha->vp_idx_map);
  47         ha->num_vhosts++;
  48         vha->vp_idx = vp_id;
  49
  50         spin_lock_irqsave(&ha->vport_slock, flags);
  51         list_add_tail(&vha->list, &ha->vp_list);
  52         spin_unlock_irqrestore(&ha->vport_slock, flags);
  53
  54         spin_lock_irqsave(&ha->hardware_lock, flags);
  55         qla_update_vp_map(vha, SET_VP_IDX);
  56         spin_unlock_irqrestore(&ha->hardware_lock, flags);
  57
  58         mutex_unlock(&ha->vport_lock);
  59         return vp_id;
  60 }
  61
  62 void
  63 qla24xx_deallocate_vp_id(scsi_qla_host_t *vha)
  64 {
  65         uint16_t vp_id;
  66         struct qla_hw_data *ha = vha->hw;
  67         unsigned long flags = 0;
  68         u32 i, bailout;
  69
  70         mutex_lock(&ha->vport_lock);
  71         /*
  72          * Wait for all pending activities to finish before removing vport from
  73          * the list.
  74          * Lock needs to be held for safe removal from the list (it
  75          * ensures no active vp_list traversal while the vport is removed
  76          * from the queue)
  77          */
  78         bailout = 0;
  79         for (i = 0; i < 500; i++) {
  80                 spin_lock_irqsave(&ha->vport_slock, flags);
  81                 if (atomic_read(&vha->vref_count) == 0) {
  82                         list_del(&vha->list);
  83                         qla_update_vp_map(vha, RESET_VP_IDX);
  84                         bailout = 1;
  85                 }
  86                 spin_unlock_irqrestore(&ha->vport_slock, flags);
  87
  88                 if (bailout)
  89                         break;
  90                 else
  91                         msleep(20);
  92         }
  93         if (!bailout) {
  94                 ql_log(ql_log_info, vha, 0xfffa,
  95                         "vha->vref_count=%u timeout\n", vha->vref_count.counter);
  96                 spin_lock_irqsave(&ha->vport_slock, flags);
  97                 list_del(&vha->list);
  98                 qla_update_vp_map(vha, RESET_VP_IDX);
  99                 spin_unlock_irqrestore(&ha->vport_slock, flags);
 100         }
 101
 102         vp_id = vha->vp_idx;
 103         ha->num_vhosts--;
 104         clear_bit(vp_id, ha->vp_idx_map);
 105
 106         mutex_unlock(&ha->vport_lock);
 107 }
 108
 109 static scsi_qla_host_t *
 110 qla24xx_find_vhost_by_name(struct qla_hw_data *ha, uint8_t *port_name)
 111 {
 112         scsi_qla_host_t *vha;
 113         struct scsi_qla_host *tvha;
 114         unsigned long flags;
 115
 116         spin_lock_irqsave(&ha->vport_slock, flags);
 117         /* Locate matching device in database. */
 118         list_for_each_entry_safe(vha, tvha, &ha->vp_list, list) {
 119                 if (!memcmp(port_name, vha->port_name, WWN_SIZE)) {
 120                         spin_unlock_irqrestore(&ha->vport_slock, flags);
 121                         return vha;
 122                 }
 123         }
 124         spin_unlock_irqrestore(&ha->vport_slock, flags);
 125         return NULL;
 126 }
 127
 128 /*
 129  * qla2x00_mark_vp_devices_dead
 130  *      Updates fcport state when device goes offline.
 131  *
 132  * Input:
 133  *      ha = adapter block pointer.
 134  *      fcport = port structure pointer.
 135  *
 136  * Return:
 137  *      None.
 138  *
 139  * Context:
 140  */
 141 static void
 142 qla2x00_mark_vp_devices_dead(scsi_qla_host_t *vha)
 143 {
 144         /*
 145          * !!! NOTE !!!
 146          * This function, if called in contexts other than vp create, disable
 147          * or delete, please make sure this is synchronized with the
 148          * delete thread.
 149          */
 150         fc_port_t *fcport;
 151
 152         list_for_each_entry(fcport, &vha->vp_fcports, list) {
 153                 ql_dbg(ql_dbg_vport, vha, 0xa001,
 154                     "Marking port dead, loop_id=0x%04x : %x.\n",
 155                     fcport->loop_id, fcport->vha->vp_idx);
 156
 157                 qla2x00_mark_device_lost(vha, fcport, 0);
 158                 qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
 159         }
 160 }
 161
 162 int
 163 qla24xx_disable_vp(scsi_qla_host_t *vha)
 164 {
 165         unsigned long flags;
 166         int ret = QLA_SUCCESS;
 167         fc_port_t *fcport;
 168
 169         if (vha->hw->flags.edif_enabled) {
 170                 if (DBELL_ACTIVE(vha))
 171                         qla2x00_post_aen_work(vha, FCH_EVT_VENDOR_UNIQUE,
 172                             FCH_EVT_VENDOR_UNIQUE_VPORT_DOWN);
 173                 /* delete sessions and flush sa_indexes */
 174                 qla2x00_wait_for_sess_deletion(vha);
 175         }
 176
 177         if (vha->hw->flags.fw_started)
 178                 ret = qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
 179
 180         atomic_set(&vha->loop_state, LOOP_DOWN);
 181         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 182         list_for_each_entry(fcport, &vha->vp_fcports, list)
 183                 fcport->logout_on_delete = 0;
 184
 185         if (!vha->hw->flags.edif_enabled)
 186                 qla2x00_wait_for_sess_deletion(vha);
 187
 188         /* Remove port id from vp target map */
 189         spin_lock_irqsave(&vha->hw->hardware_lock, flags);
 190         qla_update_vp_map(vha, RESET_AL_PA);
 191         spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
 192
 193         qla2x00_mark_vp_devices_dead(vha);
 194         atomic_set(&vha->vp_state, VP_FAILED);
 195         vha->flags.management_server_logged_in = 0;
 196         if (ret == QLA_SUCCESS) {
 197                 fc_vport_set_state(vha->fc_vport, FC_VPORT_DISABLED);
 198         } else {
 199                 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 200                 return -1;
 201         }
 202         return 0;
 203 }
 204
 205 int
 206 qla24xx_enable_vp(scsi_qla_host_t *vha)
 207 {
 208         int ret;
 209         struct qla_hw_data *ha = vha->hw;
 210         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 211
 212         /* Check if physical ha port is Up */
 213         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN  ||
 214                 atomic_read(&base_vha->loop_state) == LOOP_DEAD ||
 215                 !(ha->current_topology & ISP_CFG_F)) {
 216                 vha->vp_err_state =  VP_ERR_PORTDWN;
 217                 fc_vport_set_state(vha->fc_vport, FC_VPORT_LINKDOWN);
 218                 ql_dbg(ql_dbg_taskm, vha, 0x800b,
 219                     "%s skip enable. loop_state %x topo %x\n",
 220                     __func__, base_vha->loop_state.counter,
 221                     ha->current_topology);
 222
 223                 goto enable_failed;
 224         }
 225
 226         /* Initialize the new vport unless it is a persistent port */
 227         mutex_lock(&ha->vport_lock);
 228         ret = qla24xx_modify_vp_config(vha);
 229         mutex_unlock(&ha->vport_lock);
 230
 231         if (ret != QLA_SUCCESS) {
 232                 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 233                 goto enable_failed;
 234         }
 235
 236         ql_dbg(ql_dbg_taskm, vha, 0x801a,
 237             "Virtual port with id: %d - Enabled.\n", vha->vp_idx);
 238         return 0;
 239
 240 enable_failed:
 241         ql_dbg(ql_dbg_taskm, vha, 0x801b,
 242             "Virtual port with id: %d - Disabled.\n", vha->vp_idx);
 243         return 1;
 244 }
 245
 246 static void
 247 qla24xx_configure_vp(scsi_qla_host_t *vha)
 248 {
 249         struct fc_vport *fc_vport;
 250         int ret;
 251
 252         fc_vport = vha->fc_vport;
 253
 254         ql_dbg(ql_dbg_vport, vha, 0xa002,
 255             "%s: change request #3.\n", __func__);
 256         ret = qla2x00_send_change_request(vha, 0x3, vha->vp_idx);
 257         if (ret != QLA_SUCCESS) {
 258                 ql_dbg(ql_dbg_vport, vha, 0xa003, "Failed to enable "
 259                     "receiving of RSCN requests: 0x%x.\n", ret);
 260                 return;
 261         } else {
 262                 /* Corresponds to SCR enabled */
 263                 clear_bit(VP_SCR_NEEDED, &vha->vp_flags);
 264         }
 265
 266         vha->flags.online = 1;
 267         if (qla24xx_configure_vhba(vha))
 268                 return;
 269
 270         atomic_set(&vha->vp_state, VP_ACTIVE);
 271         fc_vport_set_state(fc_vport, FC_VPORT_ACTIVE);
 272 }
 273
 274 void
 275 qla2x00_alert_all_vps(struct rsp_que *rsp, uint16_t *mb)
 276 {
 277         scsi_qla_host_t *vha, *tvp;
 278         struct qla_hw_data *ha = rsp->hw;
 279         int i = 0;
 280         unsigned long flags;
 281
 282         spin_lock_irqsave(&ha->vport_slock, flags);
 283         list_for_each_entry_safe(vha, tvp, &ha->vp_list, list) {
 284                 if (vha->vp_idx) {
 285                         if (test_bit(VPORT_DELETE, &vha->dpc_flags))
 286                                 continue;
 287
 288                         atomic_inc(&vha->vref_count);
 289                         spin_unlock_irqrestore(&ha->vport_slock, flags);
 290
 291                         switch (mb[0]) {
 292                         case MBA_LIP_OCCURRED:
 293                         case MBA_LOOP_UP:
 294                         case MBA_LOOP_DOWN:
 295                         case MBA_LIP_RESET:
 296                         case MBA_POINT_TO_POINT:
 297                         case MBA_CHG_IN_CONNECTION:
 298                                 ql_dbg(ql_dbg_async, vha, 0x5024,
 299                                     "Async_event for VP[%d], mb=0x%x vha=%p.\n",
 300                                     i, *mb, vha);
 301                                 qla2x00_async_event(vha, rsp, mb);
 302                                 break;
 303                         case MBA_PORT_UPDATE:
 304                         case MBA_RSCN_UPDATE:
 305                                 if ((mb[3] & 0xff) == vha->vp_idx) {
 306                                         ql_dbg(ql_dbg_async, vha, 0x5024,
 307                                             "Async_event for VP[%d], mb=0x%x vha=%p\n",
 308                                             i, *mb, vha);
 309                                         qla2x00_async_event(vha, rsp, mb);
 310                                 }
 311                                 break;
 312                         }
 313
 314                         spin_lock_irqsave(&ha->vport_slock, flags);
 315                         atomic_dec(&vha->vref_count);
 316                         wake_up(&vha->vref_waitq);
 317                 }
 318                 i++;
 319         }
 320         spin_unlock_irqrestore(&ha->vport_slock, flags);
 321 }
 322
 323 int
 324 qla2x00_vp_abort_isp(scsi_qla_host_t *vha)
 325 {
 326         fc_port_t *fcport;
 327
 328         /*
 329          * To exclusively reset vport, we need to log it out first.
 330          * Note: This control_vp can fail if ISP reset is already
 331          * issued, this is expected, as the vp would be already
 332          * logged out due to ISP reset.
 333          */
 334         if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
 335                 qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
 336                 list_for_each_entry(fcport, &vha->vp_fcports, list)
 337                         fcport->logout_on_delete = 0;
 338         }
 339
 340         /*
 341          * Physical port will do most of the abort and recovery work. We can
 342          * just treat it as a loop down
 343          */
 344         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 345                 atomic_set(&vha->loop_state, LOOP_DOWN);
 346                 qla2x00_mark_all_devices_lost(vha);
 347         } else {
 348                 if (!atomic_read(&vha->loop_down_timer))
 349                         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 350         }
 351
 352         ql_dbg(ql_dbg_taskm, vha, 0x801d,
 353             "Scheduling enable of Vport %d.\n", vha->vp_idx);
 354
 355         return qla24xx_enable_vp(vha);
 356 }
 357
 358 static int
 359 qla2x00_do_dpc_vp(scsi_qla_host_t *vha)
 360 {
 361         struct qla_hw_data *ha = vha->hw;
 362         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 363
 364         ql_dbg(ql_dbg_dpc + ql_dbg_verbose, vha, 0x4012,
 365             "Entering %s vp_flags: 0x%lx.\n", __func__, vha->vp_flags);
 366
 367         /* Check if Fw is ready to configure VP first */
 368         if (test_bit(VP_CONFIG_OK, &base_vha->vp_flags)) {
 369                 if (test_and_clear_bit(VP_IDX_ACQUIRED, &vha->vp_flags)) {
 370                         /* VP acquired. complete port configuration */
 371                         ql_dbg(ql_dbg_dpc, vha, 0x4014,
 372                             "Configure VP scheduled.\n");
 373                         qla24xx_configure_vp(vha);
 374                         ql_dbg(ql_dbg_dpc, vha, 0x4015,
 375                             "Configure VP end.\n");
 376                         return 0;
 377                 }
 378         }
 379
 380         if (test_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags)) {
 381                 if (atomic_read(&vha->loop_state) == LOOP_READY) {
 382                         qla24xx_process_purex_list(&vha->purex_list);
 383                         clear_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
 384                 }
 385         }
 386
 387         if (test_bit(RELOGIN_NEEDED, &vha->dpc_flags) &&
 388             !test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) &&
 389             atomic_read(&vha->loop_state) != LOOP_DOWN) {
 390
 391                 if (!vha->relogin_jif ||
 392                     time_after_eq(jiffies, vha->relogin_jif)) {
 393                         vha->relogin_jif = jiffies + HZ;
 394                         clear_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 395
 396                         ql_dbg(ql_dbg_dpc, vha, 0x4018,
 397                             "Relogin needed scheduled.\n");
 398                         qla24xx_post_relogin_work(vha);
 399                 }
 400         }
 401
 402         if (test_and_clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) &&
 403             (!(test_and_set_bit(RESET_ACTIVE, &vha->dpc_flags)))) {
 404                 clear_bit(RESET_ACTIVE, &vha->dpc_flags);
 405         }
 406
 407         if (test_and_clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
 408                 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))) {
 409                         ql_dbg(ql_dbg_dpc, vha, 0x401a,
 410                             "Loop resync scheduled.\n");
 411                         qla2x00_loop_resync(vha);
 412                         clear_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags);
 413                         ql_dbg(ql_dbg_dpc, vha, 0x401b,
 414                             "Loop resync end.\n");
 415                 }
 416         }
 417
 418         ql_dbg(ql_dbg_dpc + ql_dbg_verbose, vha, 0x401c,
 419             "Exiting %s.\n", __func__);
 420         return 0;
 421 }
 422
 423 void
 424 qla2x00_do_dpc_all_vps(scsi_qla_host_t *vha)
 425 {
 426         struct qla_hw_data *ha = vha->hw;
 427         scsi_qla_host_t *vp, *tvp;
 428         unsigned long flags = 0;
 429
 430         if (vha->vp_idx)
 431                 return;
 432         if (list_empty(&ha->vp_list))
 433                 return;
 434
 435         clear_bit(VP_DPC_NEEDED, &vha->dpc_flags);
 436
 437         if (!(ha->current_topology & ISP_CFG_F))
 438                 return;
 439
 440         spin_lock_irqsave(&ha->vport_slock, flags);
 441         list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
 442                 if (vp->vp_idx) {
 443                         atomic_inc(&vp->vref_count);
 444                         spin_unlock_irqrestore(&ha->vport_slock, flags);
 445
 446                         qla2x00_do_dpc_vp(vp);
 447
 448                         spin_lock_irqsave(&ha->vport_slock, flags);
 449                         atomic_dec(&vp->vref_count);
 450                 }
 451         }
 452         spin_unlock_irqrestore(&ha->vport_slock, flags);
 453 }
 454
 455 int
 456 qla24xx_vport_create_req_sanity_check(struct fc_vport *fc_vport)
 457 {
 458         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
 459         struct qla_hw_data *ha = base_vha->hw;
 460         scsi_qla_host_t *vha;
 461         uint8_t port_name[WWN_SIZE];
 462
 463         if (fc_vport->roles != FC_PORT_ROLE_FCP_INITIATOR)
 464                 return VPCERR_UNSUPPORTED;
 465
 466         /* Check up the F/W and H/W support NPIV */
 467         if (!ha->flags.npiv_supported)
 468                 return VPCERR_UNSUPPORTED;
 469
 470         /* Check up whether npiv supported switch presented */
 471         if (!(ha->switch_cap & FLOGI_MID_SUPPORT))
 472                 return VPCERR_NO_FABRIC_SUPP;
 473
 474         /* Check up unique WWPN */
 475         u64_to_wwn(fc_vport->port_name, port_name);
 476         if (!memcmp(port_name, base_vha->port_name, WWN_SIZE))
 477                 return VPCERR_BAD_WWN;
 478         vha = qla24xx_find_vhost_by_name(ha, port_name);
 479         if (vha)
 480                 return VPCERR_BAD_WWN;
 481
 482         /* Check up max-npiv-supports */
 483         if (ha->num_vhosts > ha->max_npiv_vports) {
 484                 ql_dbg(ql_dbg_vport, vha, 0xa004,
 485                     "num_vhosts %ud is bigger "
 486                     "than max_npiv_vports %ud.\n",
 487                     ha->num_vhosts, ha->max_npiv_vports);
 488                 return VPCERR_UNSUPPORTED;
 489         }
 490         return 0;
 491 }
 492
 493 scsi_qla_host_t *
 494 qla24xx_create_vhost(struct fc_vport *fc_vport)
 495 {
 496         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
 497         struct qla_hw_data *ha = base_vha->hw;
 498         scsi_qla_host_t *vha;
 499         const struct scsi_host_template *sht = &qla2xxx_driver_template;
 500         struct Scsi_Host *host;
 501
 502         vha = qla2x00_create_host(sht, ha);
 503         if (!vha) {
 504                 ql_log(ql_log_warn, vha, 0xa005,
 505                     "scsi_host_alloc() failed for vport.\n");
 506                 return(NULL);
 507         }
 508
 509         host = vha->host;
 510         fc_vport->dd_data = vha;
 511         /* New host info */
 512         u64_to_wwn(fc_vport->node_name, vha->node_name);
 513         u64_to_wwn(fc_vport->port_name, vha->port_name);
 514
 515         vha->fc_vport = fc_vport;
 516         vha->device_flags = 0;
 517         vha->vp_idx = qla24xx_allocate_vp_id(vha);
 518         if (vha->vp_idx > ha->max_npiv_vports) {
 519                 ql_dbg(ql_dbg_vport, vha, 0xa006,
 520                     "Couldn't allocate vp_id.\n");
 521                 goto create_vhost_failed;
 522         }
 523         vha->mgmt_svr_loop_id = qla2x00_reserve_mgmt_server_loop_id(vha);
 524
 525         vha->dpc_flags = 0L;
 526         ha->dpc_active = 0;
 527         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 528         set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 529
 530         /*
 531          * To fix the issue of processing a parent's RSCN for the vport before
 532          * its SCR is complete.
 533          */
 534         set_bit(VP_SCR_NEEDED, &vha->vp_flags);
 535         atomic_set(&vha->loop_state, LOOP_DOWN);
 536         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 537
 538         qla2x00_start_timer(vha, WATCH_INTERVAL);
 539
 540         vha->req = base_vha->req;
 541         vha->flags.nvme_enabled = base_vha->flags.nvme_enabled;
 542         host->can_queue = base_vha->req->length + 128;
 543         host->cmd_per_lun = 3;
 544         if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif)
 545                 host->max_cmd_len = 32;
 546         else
 547                 host->max_cmd_len = MAX_CMDSZ;
 548         host->max_channel = MAX_BUSES - 1;
 549         host->max_lun = ql2xmaxlun;
 550         host->unique_id = host->host_no;
 551         host->max_id = ha->max_fibre_devices;
 552         host->transportt = qla2xxx_transport_vport_template;
 553
 554         ql_dbg(ql_dbg_vport, vha, 0xa007,
 555             "Detect vport hba %ld at address = %p.\n",
 556             vha->host_no, vha);
 557
 558         vha->flags.init_done = 1;
 559
 560         mutex_lock(&ha->vport_lock);
 561         set_bit(vha->vp_idx, ha->vp_idx_map);
 562         ha->cur_vport_count++;
 563         mutex_unlock(&ha->vport_lock);
 564
 565         return vha;
 566
 567 create_vhost_failed:
 568         return NULL;
 569 }
 570
 571 static void
 572 qla25xx_free_req_que(struct scsi_qla_host *vha, struct req_que *req)
 573 {
 574         struct qla_hw_data *ha = vha->hw;
 575         uint16_t que_id = req->id;
 576
 577         dma_free_coherent(&ha->pdev->dev, (req->length + 1) *
 578                 sizeof(request_t), req->ring, req->dma);
 579         req->ring = NULL;
 580         req->dma = 0;
 581         if (que_id) {
 582                 ha->req_q_map[que_id] = NULL;
 583                 mutex_lock(&ha->vport_lock);
 584                 clear_bit(que_id, ha->req_qid_map);
 585                 mutex_unlock(&ha->vport_lock);
 586         }
 587         kfree(req->outstanding_cmds);
 588         kfree(req);
 589 }
 590
 591 static void
 592 qla25xx_free_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
 593 {
 594         struct qla_hw_data *ha = vha->hw;
 595         uint16_t que_id = rsp->id;
 596
 597         if (rsp->msix && rsp->msix->have_irq) {
 598                 free_irq(rsp->msix->vector, rsp->msix->handle);
 599                 rsp->msix->have_irq = 0;
 600                 rsp->msix->in_use = 0;
 601                 rsp->msix->handle = NULL;
 602         }
 603         dma_free_coherent(&ha->pdev->dev, (rsp->length + 1) *
 604                 sizeof(response_t), rsp->ring, rsp->dma);
 605         rsp->ring = NULL;
 606         rsp->dma = 0;
 607         if (que_id) {
 608                 ha->rsp_q_map[que_id] = NULL;
 609                 mutex_lock(&ha->vport_lock);
 610                 clear_bit(que_id, ha->rsp_qid_map);
 611                 mutex_unlock(&ha->vport_lock);
 612         }
 613         kfree(rsp);
 614 }
 615
 616 int
 617 qla25xx_delete_req_que(struct scsi_qla_host *vha, struct req_que *req)
 618 {
 619         int ret = QLA_SUCCESS;
 620
 621         if (req && vha->flags.qpairs_req_created) {
 622                 req->options |= BIT_0;
 623                 ret = qla25xx_init_req_que(vha, req);
 624                 if (ret != QLA_SUCCESS)
 625                         return QLA_FUNCTION_FAILED;
 626
 627                 qla25xx_free_req_que(vha, req);
 628         }
 629
 630         return ret;
 631 }
 632
 633 int
 634 qla25xx_delete_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
 635 {
 636         int ret = QLA_SUCCESS;
 637
 638         if (rsp && vha->flags.qpairs_rsp_created) {
 639                 rsp->options |= BIT_0;
 640                 ret = qla25xx_init_rsp_que(vha, rsp);
 641                 if (ret != QLA_SUCCESS)
 642                         return QLA_FUNCTION_FAILED;
 643
 644                 qla25xx_free_rsp_que(vha, rsp);
 645         }
 646
 647         return ret;
 648 }
 649
 650 /* Delete all queues for a given vhost */
 651 int
 652 qla25xx_delete_queues(struct scsi_qla_host *vha)
 653 {
 654         int cnt, ret = 0;
 655         struct req_que *req = NULL;
 656         struct rsp_que *rsp = NULL;
 657         struct qla_hw_data *ha = vha->hw;
 658         struct qla_qpair *qpair, *tqpair;
 659
 660         if (ql2xmqsupport || ql2xnvmeenable) {
 661                 list_for_each_entry_safe(qpair, tqpair, &vha->qp_list,
 662                     qp_list_elem)
 663                         qla2xxx_delete_qpair(vha, qpair);
 664         } else {
 665                 /* Delete request queues */
 666                 for (cnt = 1; cnt < ha->max_req_queues; cnt++) {
 667                         req = ha->req_q_map[cnt];
 668                         if (req && test_bit(cnt, ha->req_qid_map)) {
 669                                 ret = qla25xx_delete_req_que(vha, req);
 670                                 if (ret != QLA_SUCCESS) {
 671                                         ql_log(ql_log_warn, vha, 0x00ea,
 672                                             "Couldn't delete req que %d.\n",
 673                                             req->id);
 674                                         return ret;
 675                                 }
 676                         }
 677                 }
 678
 679                 /* Delete response queues */
 680                 for (cnt = 1; cnt < ha->max_rsp_queues; cnt++) {
 681                         rsp = ha->rsp_q_map[cnt];
 682                         if (rsp && test_bit(cnt, ha->rsp_qid_map)) {
 683                                 ret = qla25xx_delete_rsp_que(vha, rsp);
 684                                 if (ret != QLA_SUCCESS) {
 685                                         ql_log(ql_log_warn, vha, 0x00eb,
 686                                             "Couldn't delete rsp que %d.\n",
 687                                             rsp->id);
 688                                         return ret;
 689                                 }
 690                         }
 691                 }
 692         }
 693
 694         return ret;
 695 }
 696
 697 int
 698 qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
 699     uint8_t vp_idx, uint16_t rid, int rsp_que, uint8_t qos, bool startqp)
 700 {
 701         int ret = 0;
 702         struct req_que *req = NULL;
 703         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 704         struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
 705         uint16_t que_id = 0;
 706         device_reg_t *reg;
 707         uint32_t cnt;
 708
 709         req = kzalloc(sizeof(struct req_que), GFP_KERNEL);
 710         if (req == NULL) {
 711                 ql_log(ql_log_fatal, base_vha, 0x00d9,
 712                     "Failed to allocate memory for request queue.\n");
 713                 goto failed;
 714         }
 715
 716         req->length = REQUEST_ENTRY_CNT_24XX;
 717         req->ring = dma_alloc_coherent(&ha->pdev->dev,
 718                         (req->length + 1) * sizeof(request_t),
 719                         &req->dma, GFP_KERNEL);
 720         if (req->ring == NULL) {
 721                 ql_log(ql_log_fatal, base_vha, 0x00da,
 722                     "Failed to allocate memory for request_ring.\n");
 723                 goto que_failed;
 724         }
 725
 726         ret = qla2x00_alloc_outstanding_cmds(ha, req);
 727         if (ret != QLA_SUCCESS)
 728                 goto que_failed;
 729
 730         mutex_lock(&ha->mq_lock);
 731         que_id = find_first_zero_bit(ha->req_qid_map, ha->max_req_queues);
 732         if (que_id >= ha->max_req_queues) {
 733                 mutex_unlock(&ha->mq_lock);
 734                 ql_log(ql_log_warn, base_vha, 0x00db,
 735                     "No resources to create additional request queue.\n");
 736                 goto que_failed;
 737         }
 738         set_bit(que_id, ha->req_qid_map);
 739         ha->req_q_map[que_id] = req;
 740         req->rid = rid;
 741         req->vp_idx = vp_idx;
 742         req->qos = qos;
 743
 744         ql_dbg(ql_dbg_multiq, base_vha, 0xc002,
 745             "queue_id=%d rid=%d vp_idx=%d qos=%d.\n",
 746             que_id, req->rid, req->vp_idx, req->qos);
 747         ql_dbg(ql_dbg_init, base_vha, 0x00dc,
 748             "queue_id=%d rid=%d vp_idx=%d qos=%d.\n",
 749             que_id, req->rid, req->vp_idx, req->qos);
 750         if (rsp_que < 0)
 751                 req->rsp = NULL;
 752         else
 753                 req->rsp = ha->rsp_q_map[rsp_que];
 754         /* Use alternate PCI bus number */
 755         if (MSB(req->rid))
 756                 options |= BIT_4;
 757         /* Use alternate PCI devfn */
 758         if (LSB(req->rid))
 759                 options |= BIT_5;
 760         req->options = options;
 761
 762         ql_dbg(ql_dbg_multiq, base_vha, 0xc003,
 763             "options=0x%x.\n", req->options);
 764         ql_dbg(ql_dbg_init, base_vha, 0x00dd,
 765             "options=0x%x.\n", req->options);
 766         for (cnt = 1; cnt < req->num_outstanding_cmds; cnt++)
 767                 req->outstanding_cmds[cnt] = NULL;
 768         req->current_outstanding_cmd = 1;
 769
 770         req->ring_ptr = req->ring;
 771         req->ring_index = 0;
 772         req->cnt = req->length;
 773         req->id = que_id;
 774         reg = ISP_QUE_REG(ha, que_id);
 775         req->req_q_in = &reg->isp25mq.req_q_in;
 776         req->req_q_out = &reg->isp25mq.req_q_out;
 777         req->max_q_depth = ha->req_q_map[0]->max_q_depth;
 778         req->out_ptr = (uint16_t *)(req->ring + req->length);
 779         mutex_unlock(&ha->mq_lock);
 780         ql_dbg(ql_dbg_multiq, base_vha, 0xc004,
 781             "ring_ptr=%p ring_index=%d, "
 782             "cnt=%d id=%d max_q_depth=%d.\n",
 783             req->ring_ptr, req->ring_index,
 784             req->cnt, req->id, req->max_q_depth);
 785         ql_dbg(ql_dbg_init, base_vha, 0x00de,
 786             "ring_ptr=%p ring_index=%d, "
 787             "cnt=%d id=%d max_q_depth=%d.\n",
 788             req->ring_ptr, req->ring_index, req->cnt,
 789             req->id, req->max_q_depth);
 790
 791         if (startqp) {
 792                 ret = qla25xx_init_req_que(base_vha, req);
 793                 if (ret != QLA_SUCCESS) {
 794                         ql_log(ql_log_fatal, base_vha, 0x00df,
 795                             "%s failed.\n", __func__);
 796                         mutex_lock(&ha->mq_lock);
 797                         clear_bit(que_id, ha->req_qid_map);
 798                         mutex_unlock(&ha->mq_lock);
 799                         goto que_failed;
 800                 }
 801                 vha->flags.qpairs_req_created = 1;
 802         }
 803
 804         return req->id;
 805
 806 que_failed:
 807         qla25xx_free_req_que(base_vha, req);
 808 failed:
 809         return 0;
 810 }
 811
 812 static void qla_do_work(struct work_struct *work)
 813 {
 814         unsigned long flags;
 815         struct qla_qpair *qpair = container_of(work, struct qla_qpair, q_work);
 816         struct scsi_qla_host *vha = qpair->vha;
 817
 818         spin_lock_irqsave(&qpair->qp_lock, flags);
 819         qla24xx_process_response_queue(vha, qpair->rsp);
 820         spin_unlock_irqrestore(&qpair->qp_lock, flags);
 821
 822 }
 823
 824 /* create response queue */
 825 int
 826 qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
 827     uint8_t vp_idx, uint16_t rid, struct qla_qpair *qpair, bool startqp)
 828 {
 829         int ret = 0;
 830         struct rsp_que *rsp = NULL;
 831         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 832         struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
 833         uint16_t que_id = 0;
 834         device_reg_t *reg;
 835
 836         rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL);
 837         if (rsp == NULL) {
 838                 ql_log(ql_log_warn, base_vha, 0x0066,
 839                     "Failed to allocate memory for response queue.\n");
 840                 goto failed;
 841         }
 842
 843         rsp->length = RESPONSE_ENTRY_CNT_MQ;
 844         rsp->ring = dma_alloc_coherent(&ha->pdev->dev,
 845                         (rsp->length + 1) * sizeof(response_t),
 846                         &rsp->dma, GFP_KERNEL);
 847         if (rsp->ring == NULL) {
 848                 ql_log(ql_log_warn, base_vha, 0x00e1,
 849                     "Failed to allocate memory for response ring.\n");
 850                 goto que_failed;
 851         }
 852
 853         mutex_lock(&ha->mq_lock);
 854         que_id = find_first_zero_bit(ha->rsp_qid_map, ha->max_rsp_queues);
 855         if (que_id >= ha->max_rsp_queues) {
 856                 mutex_unlock(&ha->mq_lock);
 857                 ql_log(ql_log_warn, base_vha, 0x00e2,
 858                     "No resources to create additional request queue.\n");
 859                 goto que_failed;
 860         }
 861         set_bit(que_id, ha->rsp_qid_map);
 862
 863         rsp->msix = qpair->msix;
 864
 865         ha->rsp_q_map[que_id] = rsp;
 866         rsp->rid = rid;
 867         rsp->vp_idx = vp_idx;
 868         rsp->hw = ha;
 869         ql_dbg(ql_dbg_init, base_vha, 0x00e4,
 870             "rsp queue_id=%d rid=%d vp_idx=%d hw=%p.\n",
 871             que_id, rsp->rid, rsp->vp_idx, rsp->hw);
 872         /* Use alternate PCI bus number */
 873         if (MSB(rsp->rid))
 874                 options |= BIT_4;
 875         /* Use alternate PCI devfn */
 876         if (LSB(rsp->rid))
 877                 options |= BIT_5;
 878         /* Enable MSIX handshake mode on for uncapable adapters */
 879         if (!IS_MSIX_NACK_CAPABLE(ha))
 880                 options |= BIT_6;
 881
 882         /* Set option to indicate response queue creation */
 883         options |= BIT_1;
 884
 885         rsp->options = options;
 886         rsp->id = que_id;
 887         reg = ISP_QUE_REG(ha, que_id);
 888         rsp->rsp_q_in = &reg->isp25mq.rsp_q_in;
 889         rsp->rsp_q_out = &reg->isp25mq.rsp_q_out;
 890         rsp->in_ptr = (uint16_t *)(rsp->ring + rsp->length);
 891         mutex_unlock(&ha->mq_lock);
 892         ql_dbg(ql_dbg_multiq, base_vha, 0xc00b,
 893             "options=%x id=%d rsp_q_in=%p rsp_q_out=%p\n",
 894             rsp->options, rsp->id, rsp->rsp_q_in,
 895             rsp->rsp_q_out);
 896         ql_dbg(ql_dbg_init, base_vha, 0x00e5,
 897             "options=%x id=%d rsp_q_in=%p rsp_q_out=%p\n",
 898             rsp->options, rsp->id, rsp->rsp_q_in,
 899             rsp->rsp_q_out);
 900
 901         ret = qla25xx_request_irq(ha, qpair, qpair->msix,
 902                 ha->flags.disable_msix_handshake ?
 903                 QLA_MSIX_QPAIR_MULTIQ_RSP_Q : QLA_MSIX_QPAIR_MULTIQ_RSP_Q_HS);
 904         if (ret)
 905                 goto que_failed;
 906
 907         if (startqp) {
 908                 ret = qla25xx_init_rsp_que(base_vha, rsp);
 909                 if (ret != QLA_SUCCESS) {
 910                         ql_log(ql_log_fatal, base_vha, 0x00e7,
 911                             "%s failed.\n", __func__);
 912                         mutex_lock(&ha->mq_lock);
 913                         clear_bit(que_id, ha->rsp_qid_map);
 914                         mutex_unlock(&ha->mq_lock);
 915                         goto que_failed;
 916                 }
 917                 vha->flags.qpairs_rsp_created = 1;
 918         }
 919         rsp->req = NULL;
 920
 921         qla2x00_init_response_q_entries(rsp);
 922         if (qpair->hw->wq)
 923                 INIT_WORK(&qpair->q_work, qla_do_work);
 924         return rsp->id;
 925
 926 que_failed:
 927         qla25xx_free_rsp_que(base_vha, rsp);
 928 failed:
 929         return 0;
 930 }
 931
 932 static void qla_ctrlvp_sp_done(srb_t *sp, int res)
 933 {
 934         if (sp->comp)
 935                 complete(sp->comp);
 936         /* don't free sp here. Let the caller do the free */
 937 }
 938
 939 /**
 940  * qla24xx_control_vp() - Enable a virtual port for given host
 941  * @vha:        adapter block pointer
 942  * @cmd:        command type to be sent for enable virtual port
 943  *
 944  * Return:      qla2xxx local function return status code.
 945  */
 946 int qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
 947 {
 948         int rval = QLA_MEMORY_ALLOC_FAILED;
 949         struct qla_hw_data *ha = vha->hw;
 950         int     vp_index = vha->vp_idx;
 951         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 952         DECLARE_COMPLETION_ONSTACK(comp);
 953         srb_t *sp;
 954
 955         ql_dbg(ql_dbg_vport, vha, 0x10c1,
 956             "Entered %s cmd %x index %d.\n", __func__, cmd, vp_index);
 957
 958         if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
 959                 return QLA_PARAMETER_ERROR;
 960
 961         /* ref: INIT */
 962         sp = qla2x00_get_sp(base_vha, NULL, GFP_KERNEL);
 963         if (!sp)
 964                 return rval;
 965
 966         sp->type = SRB_CTRL_VP;
 967         sp->name = "ctrl_vp";
 968         sp->comp = &comp;
 969         qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
 970                               qla_ctrlvp_sp_done);
 971         sp->u.iocb_cmd.u.ctrlvp.cmd = cmd;
 972         sp->u.iocb_cmd.u.ctrlvp.vp_index = vp_index;
 973
 974         rval = qla2x00_start_sp(sp);
 975         if (rval != QLA_SUCCESS) {
 976                 ql_dbg(ql_dbg_async, vha, 0xffff,
 977                     "%s: %s Failed submission. %x.\n",
 978                     __func__, sp->name, rval);
 979                 goto done;
 980         }
 981
 982         ql_dbg(ql_dbg_vport, vha, 0x113f, "%s hndl %x submitted\n",
 983             sp->name, sp->handle);
 984
 985         wait_for_completion(&comp);
 986         sp->comp = NULL;
 987
 988         rval = sp->rc;
 989         switch (rval) {
 990         case QLA_FUNCTION_TIMEOUT:
 991                 ql_dbg(ql_dbg_vport, vha, 0xffff, "%s: %s Timeout. %x.\n",
 992                     __func__, sp->name, rval);
 993                 break;
 994         case QLA_SUCCESS:
 995                 ql_dbg(ql_dbg_vport, vha, 0xffff, "%s: %s done.\n",
 996                     __func__, sp->name);
 997                 break;
 998         default:
 999                 ql_dbg(ql_dbg_vport, vha, 0xffff, "%s: %s Failed. %x.\n",
1000                     __func__, sp->name, rval);
1001                 break;
1002         }
1003 done:
1004         /* ref: INIT */
1005         kref_put(&sp->cmd_kref, qla2x00_sp_release);
1006         return rval;
1007 }
1008
1009 struct scsi_qla_host *qla_find_host_by_vp_idx(struct scsi_qla_host *vha, uint16_t vp_idx)
1010 {
1011         struct qla_hw_data *ha = vha->hw;
1012
1013         if (vha->vp_idx == vp_idx)
1014                 return vha;
1015
1016         BUG_ON(ha->vp_map == NULL);
1017         if (likely(test_bit(vp_idx, ha->vp_idx_map)))
1018                 return ha->vp_map[vp_idx].vha;
1019
1020         return NULL;
1021 }
1022
1023 /* vport_slock to be held by the caller */
1024 void
1025 qla_update_vp_map(struct scsi_qla_host *vha, int cmd)
1026 {
1027         void *slot;
1028         u32 key;
1029         int rc;
1030
1031         if (!vha->hw->vp_map)
1032                 return;
1033
1034         key = vha->d_id.b24;
1035
1036         switch (cmd) {
1037         case SET_VP_IDX:
1038                 vha->hw->vp_map[vha->vp_idx].vha = vha;
1039                 break;
1040         case SET_AL_PA:
1041                 slot = btree_lookup32(&vha->hw->host_map, key);
1042                 if (!slot) {
1043                         ql_dbg(ql_dbg_disc, vha, 0xf018,
1044                             "Save vha in host_map %p %06x\n", vha, key);
1045                         rc = btree_insert32(&vha->hw->host_map,
1046                             key, vha, GFP_ATOMIC);
1047                         if (rc)
1048                                 ql_log(ql_log_info, vha, 0xd03e,
1049                                     "Unable to insert s_id into host_map: %06x\n",
1050                                     key);
1051                         return;
1052                 }
1053                 ql_dbg(ql_dbg_disc, vha, 0xf019,
1054                     "replace existing vha in host_map %p %06x\n", vha, key);
1055                 btree_update32(&vha->hw->host_map, key, vha);
1056                 break;
1057         case RESET_VP_IDX:
1058                 vha->hw->vp_map[vha->vp_idx].vha = NULL;
1059                 break;
1060         case RESET_AL_PA:
1061                 ql_dbg(ql_dbg_disc, vha, 0xf01a,
1062                     "clear vha in host_map %p %06x\n", vha, key);
1063                 slot = btree_lookup32(&vha->hw->host_map, key);
1064                 if (slot)
1065                         btree_remove32(&vha->hw->host_map, key);
1066                 vha->d_id.b24 = 0;
1067                 break;
1068         }
1069 }
1070
1071 void qla_update_host_map(struct scsi_qla_host *vha, port_id_t id)
1072 {
1073
1074         if (!vha->d_id.b24) {
1075                 vha->d_id = id;
1076                 qla_update_vp_map(vha, SET_AL_PA);
1077         } else if (vha->d_id.b24 != id.b24) {
1078                 qla_update_vp_map(vha, RESET_AL_PA);
1079                 vha->d_id = id;
1080                 qla_update_vp_map(vha, SET_AL_PA);
1081         }
1082 }
1083
1084 int qla_create_buf_pool(struct scsi_qla_host *vha, struct qla_qpair *qp)
1085 {
1086         int sz;
1087
1088         qp->buf_pool.num_bufs = qp->req->length;
1089
1090         sz = BITS_TO_LONGS(qp->req->length);
1091         qp->buf_pool.buf_map   = kcalloc(sz, sizeof(long), GFP_KERNEL);
1092         if (!qp->buf_pool.buf_map) {
1093                 ql_log(ql_log_warn, vha, 0x0186,
1094                     "Failed to allocate buf_map(%zd).\n", sz * sizeof(unsigned long));
1095                 return -ENOMEM;
1096         }
1097         sz = qp->req->length * sizeof(void *);
1098         qp->buf_pool.buf_array = kcalloc(qp->req->length, sizeof(void *), GFP_KERNEL);
1099         if (!qp->buf_pool.buf_array) {
1100                 ql_log(ql_log_warn, vha, 0x0186,
1101                     "Failed to allocate buf_array(%d).\n", sz);
1102                 kfree(qp->buf_pool.buf_map);
1103                 return -ENOMEM;
1104         }
1105         sz = qp->req->length * sizeof(dma_addr_t);
1106         qp->buf_pool.dma_array = kcalloc(qp->req->length, sizeof(dma_addr_t), GFP_KERNEL);
1107         if (!qp->buf_pool.dma_array) {
1108                 ql_log(ql_log_warn, vha, 0x0186,
1109                     "Failed to allocate dma_array(%d).\n", sz);
1110                 kfree(qp->buf_pool.buf_map);
1111                 kfree(qp->buf_pool.buf_array);
1112                 return -ENOMEM;
1113         }
1114         set_bit(0, qp->buf_pool.buf_map);
1115         return 0;
1116 }
1117
1118 void qla_free_buf_pool(struct qla_qpair *qp)
1119 {
1120         int i;
1121         struct qla_hw_data *ha = qp->vha->hw;
1122
1123         for (i = 0; i < qp->buf_pool.num_bufs; i++) {
1124                 if (qp->buf_pool.buf_array[i] && qp->buf_pool.dma_array[i])
1125                         dma_pool_free(ha->fcp_cmnd_dma_pool, qp->buf_pool.buf_array[i],
1126                             qp->buf_pool.dma_array[i]);
1127                 qp->buf_pool.buf_array[i] = NULL;
1128                 qp->buf_pool.dma_array[i] = 0;
1129         }
1130
1131         kfree(qp->buf_pool.dma_array);
1132         kfree(qp->buf_pool.buf_array);
1133         kfree(qp->buf_pool.buf_map);
1134 }
1135
1136 /* it is assume qp->qp_lock is held at this point */
1137 int qla_get_buf(struct scsi_qla_host *vha, struct qla_qpair *qp, struct qla_buf_dsc *dsc)
1138 {
1139         u16 tag, i = 0;
1140         void *buf;
1141         dma_addr_t buf_dma;
1142         struct qla_hw_data *ha = vha->hw;
1143
1144         dsc->tag = TAG_FREED;
1145 again:
1146         tag = find_first_zero_bit(qp->buf_pool.buf_map, qp->buf_pool.num_bufs);
1147         if (tag >= qp->buf_pool.num_bufs) {
1148                 ql_dbg(ql_dbg_io, vha, 0x00e2,
1149                     "qp(%d) ran out of buf resource.\n", qp->id);
1150                 return  -EIO;
1151         }
1152         if (tag == 0) {
1153                 set_bit(0, qp->buf_pool.buf_map);
1154                 i++;
1155                 if (i == 5) {
1156                         ql_dbg(ql_dbg_io, vha, 0x00e3,
1157                             "qp(%d) unable to get tag.\n", qp->id);
1158                         return -EIO;
1159                 }
1160                 goto again;
1161         }
1162
1163         if (!qp->buf_pool.buf_array[tag]) {
1164                 buf = dma_pool_zalloc(ha->fcp_cmnd_dma_pool, GFP_ATOMIC, &buf_dma);
1165                 if (!buf) {
1166                         ql_log(ql_log_fatal, vha, 0x13b1,
1167                             "Failed to allocate buf.\n");
1168                         return -ENOMEM;
1169                 }
1170
1171                 dsc->buf = qp->buf_pool.buf_array[tag] = buf;
1172                 dsc->buf_dma = qp->buf_pool.dma_array[tag] = buf_dma;
1173                 qp->buf_pool.num_alloc++;
1174         } else {
1175                 dsc->buf = qp->buf_pool.buf_array[tag];
1176                 dsc->buf_dma = qp->buf_pool.dma_array[tag];
1177                 memset(dsc->buf, 0, FCP_CMND_DMA_POOL_SIZE);
1178         }
1179
1180         qp->buf_pool.num_active++;
1181         if (qp->buf_pool.num_active > qp->buf_pool.max_used)
1182                 qp->buf_pool.max_used = qp->buf_pool.num_active;
1183
1184         dsc->tag = tag;
1185         set_bit(tag, qp->buf_pool.buf_map);
1186         return 0;
1187 }
1188
1189 static void qla_trim_buf(struct qla_qpair *qp, u16 trim)
1190 {
1191         int i, j;
1192         struct qla_hw_data *ha = qp->vha->hw;
1193
1194         if (!trim)
1195                 return;
1196
1197         for (i = 0; i < trim; i++) {
1198                 j = qp->buf_pool.num_alloc - 1;
1199                 if (test_bit(j, qp->buf_pool.buf_map)) {
1200                         ql_dbg(ql_dbg_io + ql_dbg_verbose, qp->vha, 0x300b,
1201                                "QP id(%d): trim active buf[%d]. Remain %d bufs\n",
1202                                qp->id, j, qp->buf_pool.num_alloc);
1203                         return;
1204                 }
1205
1206                 if (qp->buf_pool.buf_array[j]) {
1207                         dma_pool_free(ha->fcp_cmnd_dma_pool, qp->buf_pool.buf_array[j],
1208                                       qp->buf_pool.dma_array[j]);
1209                         qp->buf_pool.buf_array[j] = NULL;
1210                         qp->buf_pool.dma_array[j] = 0;
1211                 }
1212                 qp->buf_pool.num_alloc--;
1213                 if (!qp->buf_pool.num_alloc)
1214                         break;
1215         }
1216         ql_dbg(ql_dbg_io + ql_dbg_verbose, qp->vha, 0x3010,
1217                "QP id(%d): trimmed %d bufs. Remain %d bufs\n",
1218                qp->id, trim, qp->buf_pool.num_alloc);
1219 }
1220
1221 static void __qla_adjust_buf(struct qla_qpair *qp)
1222 {
1223         u32 trim;
1224
1225         qp->buf_pool.take_snapshot = 0;
1226         qp->buf_pool.prev_max = qp->buf_pool.max_used;
1227         qp->buf_pool.max_used = qp->buf_pool.num_active;
1228
1229         if (qp->buf_pool.prev_max > qp->buf_pool.max_used &&
1230             qp->buf_pool.num_alloc > qp->buf_pool.max_used) {
1231                 /* down trend */
1232                 trim = qp->buf_pool.num_alloc - qp->buf_pool.max_used;
1233                 trim  = (trim * 10) / 100;
1234                 trim = trim ? trim : 1;
1235                 qla_trim_buf(qp, trim);
1236         } else if (!qp->buf_pool.prev_max  && !qp->buf_pool.max_used) {
1237                 /* 2 periods of no io */
1238                 qla_trim_buf(qp, qp->buf_pool.num_alloc);
1239         }
1240 }
1241
1242 /* it is assume qp->qp_lock is held at this point */
1243 void qla_put_buf(struct qla_qpair *qp, struct qla_buf_dsc *dsc)
1244 {
1245         if (dsc->tag == TAG_FREED)
1246                 return;
1247         lockdep_assert_held(qp->qp_lock_ptr);
1248
1249         clear_bit(dsc->tag, qp->buf_pool.buf_map);
1250         qp->buf_pool.num_active--;
1251         dsc->tag = TAG_FREED;
1252
1253         if (qp->buf_pool.take_snapshot)
1254                 __qla_adjust_buf(qp);
1255 }
1256
1257 #define EXPIRE (60 * HZ)
1258 void qla_adjust_buf(struct scsi_qla_host *vha)
1259 {
1260         unsigned long flags;
1261         int i;
1262         struct qla_qpair *qp;
1263
1264         if (vha->vp_idx)
1265                 return;
1266
1267         if (!vha->buf_expired) {
1268                 vha->buf_expired = jiffies + EXPIRE;
1269                 return;
1270         }
1271         if (time_before(jiffies, vha->buf_expired))
1272                 return;
1273
1274         vha->buf_expired = jiffies + EXPIRE;
1275
1276         for (i = 0; i < vha->hw->num_qpairs; i++) {
1277                 qp = vha->hw->queue_pair_map[i];
1278                 if (!qp)
1279                         continue;
1280                 if (!qp->buf_pool.num_alloc)
1281                         continue;
1282
1283                 if (qp->buf_pool.take_snapshot) {
1284                         /* no io has gone through in the last EXPIRE period */
1285                         spin_lock_irqsave(qp->qp_lock_ptr, flags);
1286                         __qla_adjust_buf(qp);
1287                         spin_unlock_irqrestore(qp->qp_lock_ptr, flags);
1288                 } else {
1289                         qp->buf_pool.take_snapshot = 1;
1290                 }
1291         }
1292 }