drivers/scsi/bfa/bfad_bsg.c

   1 /*
   2  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   3  * Copyright (c) 2014- QLogic Corporation.
   4  * All rights reserved
   5  * www.qlogic.com
   6  *
   7  * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License (GPL) Version 2 as
  11  * published by the Free Software Foundation
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  */
  18
  19 #include <linux/uaccess.h>
  20 #include "bfad_drv.h"
  21 #include "bfad_im.h"
  22 #include "bfad_bsg.h"
  23
  24 BFA_TRC_FILE(LDRV, BSG);
  25
  26 int
  27 bfad_iocmd_ioc_enable(struct bfad_s *bfad, void *cmd)
  28 {
  29         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
  30         unsigned long   flags;
  31
  32         spin_lock_irqsave(&bfad->bfad_lock, flags);
  33         /* If IOC is not in disabled state - return */
  34         if (!bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
  35                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  36                 iocmd->status = BFA_STATUS_OK;
  37                 return 0;
  38         }
  39
  40         init_completion(&bfad->enable_comp);
  41         bfa_iocfc_enable(&bfad->bfa);
  42         iocmd->status = BFA_STATUS_OK;
  43         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  44         wait_for_completion(&bfad->enable_comp);
  45
  46         return 0;
  47 }
  48
  49 int
  50 bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
  51 {
  52         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
  53         unsigned long   flags;
  54
  55         spin_lock_irqsave(&bfad->bfad_lock, flags);
  56         if (bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
  57                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  58                 iocmd->status = BFA_STATUS_OK;
  59                 return 0;
  60         }
  61
  62         if (bfad->disable_active) {
  63                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  64                 return -EBUSY;
  65         }
  66
  67         bfad->disable_active = BFA_TRUE;
  68         init_completion(&bfad->disable_comp);
  69         bfa_iocfc_disable(&bfad->bfa);
  70         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  71
  72         wait_for_completion(&bfad->disable_comp);
  73         bfad->disable_active = BFA_FALSE;
  74         iocmd->status = BFA_STATUS_OK;
  75
  76         return 0;
  77 }
  78
  79 static int
  80 bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
  81 {
  82         int     i;
  83         struct bfa_bsg_ioc_info_s *iocmd = (struct bfa_bsg_ioc_info_s *)cmd;
  84         struct bfad_im_port_s   *im_port;
  85         struct bfa_port_attr_s  pattr;
  86         unsigned long   flags;
  87
  88         spin_lock_irqsave(&bfad->bfad_lock, flags);
  89         bfa_fcport_get_attr(&bfad->bfa, &pattr);
  90         iocmd->nwwn = pattr.nwwn;
  91         iocmd->pwwn = pattr.pwwn;
  92         iocmd->ioc_type = bfa_get_type(&bfad->bfa);
  93         iocmd->mac = bfa_get_mac(&bfad->bfa);
  94         iocmd->factory_mac = bfa_get_mfg_mac(&bfad->bfa);
  95         bfa_get_adapter_serial_num(&bfad->bfa, iocmd->serialnum);
  96         iocmd->factorynwwn = pattr.factorynwwn;
  97         iocmd->factorypwwn = pattr.factorypwwn;
  98         iocmd->bfad_num = bfad->inst_no;
  99         im_port = bfad->pport.im_port;
 100         iocmd->host = im_port->shost->host_no;
 101         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 102
 103         strcpy(iocmd->name, bfad->adapter_name);
 104         strcpy(iocmd->port_name, bfad->port_name);
 105         strcpy(iocmd->hwpath, bfad->pci_name);
 106
 107         /* set adapter hw path */
 108         strcpy(iocmd->adapter_hwpath, bfad->pci_name);
 109         for (i = 0; iocmd->adapter_hwpath[i] != ':' && i < BFA_STRING_32; i++)
 110                 ;
 111         for (; iocmd->adapter_hwpath[++i] != ':' && i < BFA_STRING_32; )
 112                 ;
 113         iocmd->adapter_hwpath[i] = '\0';
 114         iocmd->status = BFA_STATUS_OK;
 115         return 0;
 116 }
 117
 118 static int
 119 bfad_iocmd_ioc_get_attr(struct bfad_s *bfad, void *cmd)
 120 {
 121         struct bfa_bsg_ioc_attr_s *iocmd = (struct bfa_bsg_ioc_attr_s *)cmd;
 122         unsigned long   flags;
 123
 124         spin_lock_irqsave(&bfad->bfad_lock, flags);
 125         bfa_ioc_get_attr(&bfad->bfa.ioc, &iocmd->ioc_attr);
 126         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 127
 128         /* fill in driver attr info */
 129         strcpy(iocmd->ioc_attr.driver_attr.driver, BFAD_DRIVER_NAME);
 130         strlcpy(iocmd->ioc_attr.driver_attr.driver_ver,
 131                 BFAD_DRIVER_VERSION, BFA_VERSION_LEN);
 132         strcpy(iocmd->ioc_attr.driver_attr.fw_ver,
 133                 iocmd->ioc_attr.adapter_attr.fw_ver);
 134         strcpy(iocmd->ioc_attr.driver_attr.bios_ver,
 135                 iocmd->ioc_attr.adapter_attr.optrom_ver);
 136
 137         /* copy chip rev info first otherwise it will be overwritten */
 138         memcpy(bfad->pci_attr.chip_rev, iocmd->ioc_attr.pci_attr.chip_rev,
 139                 sizeof(bfad->pci_attr.chip_rev));
 140         memcpy(&iocmd->ioc_attr.pci_attr, &bfad->pci_attr,
 141                 sizeof(struct bfa_ioc_pci_attr_s));
 142
 143         iocmd->status = BFA_STATUS_OK;
 144         return 0;
 145 }
 146
 147 int
 148 bfad_iocmd_ioc_get_stats(struct bfad_s *bfad, void *cmd)
 149 {
 150         struct bfa_bsg_ioc_stats_s *iocmd = (struct bfa_bsg_ioc_stats_s *)cmd;
 151
 152         bfa_ioc_get_stats(&bfad->bfa, &iocmd->ioc_stats);
 153         iocmd->status = BFA_STATUS_OK;
 154         return 0;
 155 }
 156
 157 int
 158 bfad_iocmd_ioc_get_fwstats(struct bfad_s *bfad, void *cmd,
 159                         unsigned int payload_len)
 160 {
 161         struct bfa_bsg_ioc_fwstats_s *iocmd =
 162                         (struct bfa_bsg_ioc_fwstats_s *)cmd;
 163         void    *iocmd_bufptr;
 164         unsigned long   flags;
 165
 166         if (bfad_chk_iocmd_sz(payload_len,
 167                         sizeof(struct bfa_bsg_ioc_fwstats_s),
 168                         sizeof(struct bfa_fw_stats_s)) != BFA_STATUS_OK) {
 169                 iocmd->status = BFA_STATUS_VERSION_FAIL;
 170                 goto out;
 171         }
 172
 173         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_ioc_fwstats_s);
 174         spin_lock_irqsave(&bfad->bfad_lock, flags);
 175         iocmd->status = bfa_ioc_fw_stats_get(&bfad->bfa.ioc, iocmd_bufptr);
 176         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 177
 178         if (iocmd->status != BFA_STATUS_OK) {
 179                 bfa_trc(bfad, iocmd->status);
 180                 goto out;
 181         }
 182 out:
 183         bfa_trc(bfad, 0x6666);
 184         return 0;
 185 }
 186
 187 int
 188 bfad_iocmd_ioc_reset_stats(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
 189 {
 190         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
 191         unsigned long   flags;
 192
 193         if (v_cmd == IOCMD_IOC_RESET_STATS) {
 194                 bfa_ioc_clear_stats(&bfad->bfa);
 195                 iocmd->status = BFA_STATUS_OK;
 196         } else if (v_cmd == IOCMD_IOC_RESET_FWSTATS) {
 197                 spin_lock_irqsave(&bfad->bfad_lock, flags);
 198                 iocmd->status = bfa_ioc_fw_stats_clear(&bfad->bfa.ioc);
 199                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 200         }
 201
 202         return 0;
 203 }
 204
 205 int
 206 bfad_iocmd_ioc_set_name(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
 207 {
 208         struct bfa_bsg_ioc_name_s *iocmd = (struct bfa_bsg_ioc_name_s *) cmd;
 209
 210         if (v_cmd == IOCMD_IOC_SET_ADAPTER_NAME)
 211                 strcpy(bfad->adapter_name, iocmd->name);
 212         else if (v_cmd == IOCMD_IOC_SET_PORT_NAME)
 213                 strcpy(bfad->port_name, iocmd->name);
 214
 215         iocmd->status = BFA_STATUS_OK;
 216         return 0;
 217 }
 218
 219 int
 220 bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)
 221 {
 222         struct bfa_bsg_iocfc_attr_s *iocmd = (struct bfa_bsg_iocfc_attr_s *)cmd;
 223
 224         iocmd->status = BFA_STATUS_OK;
 225         bfa_iocfc_get_attr(&bfad->bfa, &iocmd->iocfc_attr);
 226
 227         return 0;
 228 }
 229
 230 int
 231 bfad_iocmd_ioc_fw_sig_inv(struct bfad_s *bfad, void *cmd)
 232 {
 233         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
 234         unsigned long flags;
 235
 236         spin_lock_irqsave(&bfad->bfad_lock, flags);
 237         iocmd->status = bfa_ioc_fwsig_invalidate(&bfad->bfa.ioc);
 238         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 239         return 0;
 240 }
 241
 242 int
 243 bfad_iocmd_iocfc_set_intr(struct bfad_s *bfad, void *cmd)
 244 {
 245         struct bfa_bsg_iocfc_intr_s *iocmd = (struct bfa_bsg_iocfc_intr_s *)cmd;
 246         unsigned long   flags;
 247
 248         spin_lock_irqsave(&bfad->bfad_lock, flags);
 249         iocmd->status = bfa_iocfc_israttr_set(&bfad->bfa, &iocmd->attr);
 250         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 251
 252         return 0;
 253 }
 254
 255 int
 256 bfad_iocmd_port_enable(struct bfad_s *bfad, void *cmd)
 257 {
 258         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
 259         struct bfad_hal_comp fcomp;
 260         unsigned long flags;
 261
 262         init_completion(&fcomp.comp);
 263         spin_lock_irqsave(&bfad->bfad_lock, flags);
 264         iocmd->status = bfa_port_enable(&bfad->bfa.modules.port,
 265                                         bfad_hcb_comp, &fcomp);
 266         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 267         if (iocmd->status != BFA_STATUS_OK) {
 268                 bfa_trc(bfad, iocmd->status);
 269                 return 0;
 270         }
 271         wait_for_completion(&fcomp.comp);
 272         iocmd->status = fcomp.status;
 273         return 0;
 274 }
 275
 276 int
 277 bfad_iocmd_port_disable(struct bfad_s *bfad, void *cmd)
 278 {
 279         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
 280         struct bfad_hal_comp fcomp;
 281         unsigned long flags;
 282
 283         init_completion(&fcomp.comp);
 284         spin_lock_irqsave(&bfad->bfad_lock, flags);
 285         iocmd->status = bfa_port_disable(&bfad->bfa.modules.port,
 286                                 bfad_hcb_comp, &fcomp);
 287         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 288
 289         if (iocmd->status != BFA_STATUS_OK) {
 290                 bfa_trc(bfad, iocmd->status);
 291                 return 0;
 292         }
 293         wait_for_completion(&fcomp.comp);
 294         iocmd->status = fcomp.status;
 295         return 0;
 296 }
 297
 298 static int
 299 bfad_iocmd_port_get_attr(struct bfad_s *bfad, void *cmd)
 300 {
 301         struct bfa_bsg_port_attr_s *iocmd = (struct bfa_bsg_port_attr_s *)cmd;
 302         struct bfa_lport_attr_s port_attr;
 303         unsigned long   flags;
 304
 305         spin_lock_irqsave(&bfad->bfad_lock, flags);
 306         bfa_fcport_get_attr(&bfad->bfa, &iocmd->attr);
 307         bfa_fcs_lport_get_attr(&bfad->bfa_fcs.fabric.bport, &port_attr);
 308         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 309
 310         if (iocmd->attr.topology != BFA_PORT_TOPOLOGY_NONE)
 311                 iocmd->attr.pid = port_attr.pid;
 312         else
 313                 iocmd->attr.pid = 0;
 314
 315         iocmd->attr.port_type = port_attr.port_type;
 316         iocmd->attr.loopback = port_attr.loopback;
 317         iocmd->attr.authfail = port_attr.authfail;
 318         strlcpy(iocmd->attr.port_symname.symname,
 319                 port_attr.port_cfg.sym_name.symname,
 320                 sizeof(iocmd->attr.port_symname.symname));
 321
 322         iocmd->status = BFA_STATUS_OK;
 323         return 0;
 324 }
 325
 326 int
 327 bfad_iocmd_port_get_stats(struct bfad_s *bfad, void *cmd,
 328                         unsigned int payload_len)
 329 {
 330         struct bfa_bsg_port_stats_s *iocmd = (struct bfa_bsg_port_stats_s *)cmd;
 331         struct bfad_hal_comp fcomp;
 332         void    *iocmd_bufptr;
 333         unsigned long   flags;
 334
 335         if (bfad_chk_iocmd_sz(payload_len,
 336                         sizeof(struct bfa_bsg_port_stats_s),
 337                         sizeof(union bfa_port_stats_u)) != BFA_STATUS_OK) {
 338                 iocmd->status = BFA_STATUS_VERSION_FAIL;
 339                 return 0;
 340         }
 341
 342         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_port_stats_s);
 343
 344         init_completion(&fcomp.comp);
 345         spin_lock_irqsave(&bfad->bfad_lock, flags);
 346         iocmd->status = bfa_port_get_stats(&bfad->bfa.modules.port,
 347                                 iocmd_bufptr, bfad_hcb_comp, &fcomp);
 348         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 349         if (iocmd->status != BFA_STATUS_OK) {
 350                 bfa_trc(bfad, iocmd->status);
 351                 goto out;
 352         }
 353
 354         wait_for_completion(&fcomp.comp);
 355         iocmd->status = fcomp.status;
 356 out:
 357         return 0;
 358 }
 359
 360 int
 361 bfad_iocmd_port_reset_stats(struct bfad_s *bfad, void *cmd)
 362 {
 363         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
 364         struct bfad_hal_comp fcomp;
 365         unsigned long   flags;
 366
 367         init_completion(&fcomp.comp);
 368         spin_lock_irqsave(&bfad->bfad_lock, flags);
 369         iocmd->status = bfa_port_clear_stats(&bfad->bfa.modules.port,
 370                                         bfad_hcb_comp, &fcomp);
 371         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 372         if (iocmd->status != BFA_STATUS_OK) {
 373                 bfa_trc(bfad, iocmd->status);
 374                 return 0;
 375         }
 376         wait_for_completion(&fcomp.comp);
 377         iocmd->status = fcomp.status;
 378         return 0;
 379 }
 380
 381 int
 382 bfad_iocmd_set_port_cfg(struct bfad_s *bfad, void *iocmd, unsigned int v_cmd)
 383 {
 384         struct bfa_bsg_port_cfg_s *cmd = (struct bfa_bsg_port_cfg_s *)iocmd;
 385         unsigned long   flags;
 386
 387         spin_lock_irqsave(&bfad->bfad_lock, flags);
 388         if (v_cmd == IOCMD_PORT_CFG_TOPO)
 389                 cmd->status = bfa_fcport_cfg_topology(&bfad->bfa, cmd->param);
 390         else if (v_cmd == IOCMD_PORT_CFG_SPEED)
 391                 cmd->status = bfa_fcport_cfg_speed(&bfad->bfa, cmd->param);
 392         else if (v_cmd == IOCMD_PORT_CFG_ALPA)
 393                 cmd->status = bfa_fcport_cfg_hardalpa(&bfad->bfa, cmd->param);
 394         else if (v_cmd == IOCMD_PORT_CLR_ALPA)
 395                 cmd->status = bfa_fcport_clr_hardalpa(&bfad->bfa);
 396         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 397
 398         return 0;
 399 }
 400
 401 int
 402 bfad_iocmd_port_cfg_maxfrsize(struct bfad_s *bfad, void *cmd)
 403 {
 404         struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =
 405                                 (struct bfa_bsg_port_cfg_maxfrsize_s *)cmd;
 406         unsigned long   flags;
 407
 408         spin_lock_irqsave(&bfad->bfad_lock, flags);
 409         iocmd->status = bfa_fcport_cfg_maxfrsize(&bfad->bfa, iocmd->maxfrsize);
 410         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 411
 412         return 0;
 413 }
 414
 415 int
 416 bfad_iocmd_port_cfg_bbcr(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
 417 {
 418         struct bfa_bsg_bbcr_enable_s *iocmd =
 419                         (struct bfa_bsg_bbcr_enable_s *)pcmd;
 420         unsigned long flags;
 421         int rc;
 422
 423         spin_lock_irqsave(&bfad->bfad_lock, flags);
 424         if (cmd == IOCMD_PORT_BBCR_ENABLE)
 425                 rc = bfa_fcport_cfg_bbcr(&bfad->bfa, BFA_TRUE, iocmd->bb_scn);
 426         else if (cmd == IOCMD_PORT_BBCR_DISABLE)
 427                 rc = bfa_fcport_cfg_bbcr(&bfad->bfa, BFA_FALSE, 0);
 428         else {
 429                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 430                 return -EINVAL;
 431         }
 432         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 433
 434         iocmd->status = rc;
 435         return 0;
 436 }
 437
 438 int
 439 bfad_iocmd_port_get_bbcr_attr(struct bfad_s *bfad, void *pcmd)
 440 {
 441         struct bfa_bsg_bbcr_attr_s *iocmd = (struct bfa_bsg_bbcr_attr_s *) pcmd;
 442         unsigned long flags;
 443
 444         spin_lock_irqsave(&bfad->bfad_lock, flags);
 445         iocmd->status =
 446                 bfa_fcport_get_bbcr_attr(&bfad->bfa, &iocmd->attr);
 447         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 448
 449         return 0;
 450 }
 451
 452
 453 static int
 454 bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)
 455 {
 456         struct bfa_fcs_lport_s  *fcs_port;
 457         struct bfa_bsg_lport_attr_s *iocmd = (struct bfa_bsg_lport_attr_s *)cmd;
 458         unsigned long   flags;
 459
 460         spin_lock_irqsave(&bfad->bfad_lock, flags);
 461         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 462                                 iocmd->vf_id, iocmd->pwwn);
 463         if (fcs_port == NULL) {
 464                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 465                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 466                 goto out;
 467         }
 468
 469         bfa_fcs_lport_get_attr(fcs_port, &iocmd->port_attr);
 470         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 471         iocmd->status = BFA_STATUS_OK;
 472 out:
 473         return 0;
 474 }
 475
 476 int
 477 bfad_iocmd_lport_get_stats(struct bfad_s *bfad, void *cmd)
 478 {
 479         struct bfa_fcs_lport_s *fcs_port;
 480         struct bfa_bsg_lport_stats_s *iocmd =
 481                         (struct bfa_bsg_lport_stats_s *)cmd;
 482         unsigned long   flags;
 483
 484         spin_lock_irqsave(&bfad->bfad_lock, flags);
 485         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 486                                 iocmd->vf_id, iocmd->pwwn);
 487         if (fcs_port == NULL) {
 488                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 489                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 490                 goto out;
 491         }
 492
 493         bfa_fcs_lport_get_stats(fcs_port, &iocmd->port_stats);
 494         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 495         iocmd->status = BFA_STATUS_OK;
 496 out:
 497         return 0;
 498 }
 499
 500 int
 501 bfad_iocmd_lport_reset_stats(struct bfad_s *bfad, void *cmd)
 502 {
 503         struct bfa_fcs_lport_s *fcs_port;
 504         struct bfa_bsg_reset_stats_s *iocmd =
 505                         (struct bfa_bsg_reset_stats_s *)cmd;
 506         struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
 507         struct list_head *qe, *qen;
 508         struct bfa_itnim_s *itnim;
 509         unsigned long   flags;
 510
 511         spin_lock_irqsave(&bfad->bfad_lock, flags);
 512         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 513                                 iocmd->vf_id, iocmd->vpwwn);
 514         if (fcs_port == NULL) {
 515                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 516                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 517                 goto out;
 518         }
 519
 520         bfa_fcs_lport_clear_stats(fcs_port);
 521         /* clear IO stats from all active itnims */
 522         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
 523                 itnim = (struct bfa_itnim_s *) qe;
 524                 if (itnim->rport->rport_info.lp_tag != fcs_port->lp_tag)
 525                         continue;
 526                 bfa_itnim_clear_stats(itnim);
 527         }
 528         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 529         iocmd->status = BFA_STATUS_OK;
 530 out:
 531         return 0;
 532 }
 533
 534 int
 535 bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)
 536 {
 537         struct bfa_fcs_lport_s *fcs_port;
 538         struct bfa_bsg_lport_iostats_s *iocmd =
 539                         (struct bfa_bsg_lport_iostats_s *)cmd;
 540         unsigned long   flags;
 541
 542         spin_lock_irqsave(&bfad->bfad_lock, flags);
 543         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 544                                 iocmd->vf_id, iocmd->pwwn);
 545         if (fcs_port == NULL) {
 546                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 547                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 548                 goto out;
 549         }
 550
 551         bfa_fcpim_port_iostats(&bfad->bfa, &iocmd->iostats,
 552                         fcs_port->lp_tag);
 553         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 554         iocmd->status = BFA_STATUS_OK;
 555 out:
 556         return 0;
 557 }
 558
 559 int
 560 bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
 561                         unsigned int payload_len)
 562 {
 563         struct bfa_bsg_lport_get_rports_s *iocmd =
 564                         (struct bfa_bsg_lport_get_rports_s *)cmd;
 565         struct bfa_fcs_lport_s *fcs_port;
 566         unsigned long   flags;
 567         void    *iocmd_bufptr;
 568
 569         if (iocmd->nrports == 0)
 570                 return -EINVAL;
 571
 572         if (bfad_chk_iocmd_sz(payload_len,
 573                         sizeof(struct bfa_bsg_lport_get_rports_s),
 574                         sizeof(struct bfa_rport_qualifier_s) * iocmd->nrports)
 575                         != BFA_STATUS_OK) {
 576                 iocmd->status = BFA_STATUS_VERSION_FAIL;
 577                 return 0;
 578         }
 579
 580         iocmd_bufptr = (char *)iocmd +
 581                         sizeof(struct bfa_bsg_lport_get_rports_s);
 582         spin_lock_irqsave(&bfad->bfad_lock, flags);
 583         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 584                                 iocmd->vf_id, iocmd->pwwn);
 585         if (fcs_port == NULL) {
 586                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 587                 bfa_trc(bfad, 0);
 588                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 589                 goto out;
 590         }
 591
 592         bfa_fcs_lport_get_rport_quals(fcs_port,
 593                         (struct bfa_rport_qualifier_s *)iocmd_bufptr,
 594                         &iocmd->nrports);
 595         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 596         iocmd->status = BFA_STATUS_OK;
 597 out:
 598         return 0;
 599 }
 600
 601 int
 602 bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
 603 {
 604         struct bfa_bsg_rport_attr_s *iocmd = (struct bfa_bsg_rport_attr_s *)cmd;
 605         struct bfa_fcs_lport_s *fcs_port;
 606         struct bfa_fcs_rport_s *fcs_rport;
 607         unsigned long   flags;
 608
 609         spin_lock_irqsave(&bfad->bfad_lock, flags);
 610         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 611                                 iocmd->vf_id, iocmd->pwwn);
 612         if (fcs_port == NULL) {
 613                 bfa_trc(bfad, 0);
 614                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 615                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 616                 goto out;
 617         }
 618
 619         if (iocmd->pid)
 620                 fcs_rport = bfa_fcs_lport_get_rport_by_qualifier(fcs_port,
 621                                                 iocmd->rpwwn, iocmd->pid);
 622         else
 623                 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
 624         if (fcs_rport == NULL) {
 625                 bfa_trc(bfad, 0);
 626                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 627                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 628                 goto out;
 629         }
 630
 631         bfa_fcs_rport_get_attr(fcs_rport, &iocmd->attr);
 632         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 633         iocmd->status = BFA_STATUS_OK;
 634 out:
 635         return 0;
 636 }
 637
 638 static int
 639 bfad_iocmd_rport_get_addr(struct bfad_s *bfad, void *cmd)
 640 {
 641         struct bfa_bsg_rport_scsi_addr_s *iocmd =
 642                         (struct bfa_bsg_rport_scsi_addr_s *)cmd;
 643         struct bfa_fcs_lport_s  *fcs_port;
 644         struct bfa_fcs_itnim_s  *fcs_itnim;
 645         struct bfad_itnim_s     *drv_itnim;
 646         unsigned long   flags;
 647
 648         spin_lock_irqsave(&bfad->bfad_lock, flags);
 649         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 650                                 iocmd->vf_id, iocmd->pwwn);
 651         if (fcs_port == NULL) {
 652                 bfa_trc(bfad, 0);
 653                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 654                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 655                 goto out;
 656         }
 657
 658         fcs_itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
 659         if (fcs_itnim == NULL) {
 660                 bfa_trc(bfad, 0);
 661                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 662                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 663                 goto out;
 664         }
 665
 666         drv_itnim = fcs_itnim->itnim_drv;
 667
 668         if (drv_itnim && drv_itnim->im_port)
 669                 iocmd->host = drv_itnim->im_port->shost->host_no;
 670         else {
 671                 bfa_trc(bfad, 0);
 672                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 673                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 674                 goto out;
 675         }
 676
 677         iocmd->target = drv_itnim->scsi_tgt_id;
 678         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 679
 680         iocmd->bus = 0;
 681         iocmd->lun = 0;
 682         iocmd->status = BFA_STATUS_OK;
 683 out:
 684         return 0;
 685 }
 686
 687 int
 688 bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
 689 {
 690         struct bfa_bsg_rport_stats_s *iocmd =
 691                         (struct bfa_bsg_rport_stats_s *)cmd;
 692         struct bfa_fcs_lport_s *fcs_port;
 693         struct bfa_fcs_rport_s *fcs_rport;
 694         unsigned long   flags;
 695
 696         spin_lock_irqsave(&bfad->bfad_lock, flags);
 697         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 698                                 iocmd->vf_id, iocmd->pwwn);
 699         if (fcs_port == NULL) {
 700                 bfa_trc(bfad, 0);
 701                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 702                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 703                 goto out;
 704         }
 705
 706         fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
 707         if (fcs_rport == NULL) {
 708                 bfa_trc(bfad, 0);
 709                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 710                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 711                 goto out;
 712         }
 713
 714         memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
 715                 sizeof(struct bfa_rport_stats_s));
 716         if (bfa_fcs_rport_get_halrport(fcs_rport)) {
 717                 memcpy((void *)&iocmd->stats.hal_stats,
 718                        (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
 719                         sizeof(struct bfa_rport_hal_stats_s));
 720         }
 721
 722         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 723         iocmd->status = BFA_STATUS_OK;
 724 out:
 725         return 0;
 726 }
 727
 728 int
 729 bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
 730 {
 731         struct bfa_bsg_rport_reset_stats_s *iocmd =
 732                                 (struct bfa_bsg_rport_reset_stats_s *)cmd;
 733         struct bfa_fcs_lport_s *fcs_port;
 734         struct bfa_fcs_rport_s *fcs_rport;
 735         struct bfa_rport_s *rport;
 736         unsigned long   flags;
 737
 738         spin_lock_irqsave(&bfad->bfad_lock, flags);
 739         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 740                                 iocmd->vf_id, iocmd->pwwn);
 741         if (fcs_port == NULL) {
 742                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 743                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 744                 goto out;
 745         }
 746
 747         fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
 748         if (fcs_rport == NULL) {
 749                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 750                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 751                 goto out;
 752         }
 753
 754         memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
 755         rport = bfa_fcs_rport_get_halrport(fcs_rport);
 756         if (rport)
 757                 memset(&rport->stats, 0, sizeof(rport->stats));
 758         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 759         iocmd->status = BFA_STATUS_OK;
 760 out:
 761         return 0;
 762 }
 763
 764 int
 765 bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
 766 {
 767         struct bfa_bsg_rport_set_speed_s *iocmd =
 768                                 (struct bfa_bsg_rport_set_speed_s *)cmd;
 769         struct bfa_fcs_lport_s *fcs_port;
 770         struct bfa_fcs_rport_s *fcs_rport;
 771         unsigned long   flags;
 772
 773         spin_lock_irqsave(&bfad->bfad_lock, flags);
 774         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
 775                                 iocmd->vf_id, iocmd->pwwn);
 776         if (fcs_port == NULL) {
 777                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 778                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
 779                 goto out;
 780         }
 781
 782         fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
 783         if (fcs_rport == NULL) {
 784                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 785                 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
 786                 goto out;
 787         }
 788
 789         fcs_rport->rpf.assigned_speed  = iocmd->speed;
 790         /* Set this speed in f/w only if the RPSC speed is not available */
 791         if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
 792                 if (fcs_rport->bfa_rport)
 793                         bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
 794         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 795         iocmd->status = BFA_STATUS_OK;
 796 out:
 797         return 0;
 798 }
 799
 800 int
 801 bfad_iocmd_vport_get_attr(struct bfad_s *bfad, void *cmd)
 802 {
 803         struct bfa_fcs_vport_s *fcs_vport;
 804         struct bfa_bsg_vport_attr_s *iocmd = (struct bfa_bsg_vport_attr_s *)cmd;
 805         unsigned long   flags;
 806
 807         spin_lock_irqsave(&bfad->bfad_lock, flags);
 808         fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
 809                                 iocmd->vf_id, iocmd->vpwwn);
 810         if (fcs_vport == NULL) {
 811                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 812                 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
 813                 goto out;
 814         }
 815
 816         bfa_fcs_vport_get_attr(fcs_vport, &iocmd->vport_attr);
 817         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 818         iocmd->status = BFA_STATUS_OK;
 819 out:
 820         return 0;
 821 }
 822
 823 int
 824 bfad_iocmd_vport_get_stats(struct bfad_s *bfad, void *cmd)
 825 {
 826         struct bfa_fcs_vport_s *fcs_vport;
 827         struct bfa_bsg_vport_stats_s *iocmd =
 828                                 (struct bfa_bsg_vport_stats_s *)cmd;
 829         unsigned long   flags;
 830
 831         spin_lock_irqsave(&bfad->bfad_lock, flags);
 832         fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
 833                                 iocmd->vf_id, iocmd->vpwwn);
 834         if (fcs_vport == NULL) {
 835                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 836                 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
 837                 goto out;
 838         }
 839
 840         memcpy((void *)&iocmd->vport_stats, (void *)&fcs_vport->vport_stats,
 841                 sizeof(struct bfa_vport_stats_s));
 842         memcpy((void *)&iocmd->vport_stats.port_stats,
 843                (void *)&fcs_vport->lport.stats,
 844                 sizeof(struct bfa_lport_stats_s));
 845         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 846         iocmd->status = BFA_STATUS_OK;
 847 out:
 848         return 0;
 849 }
 850
 851 int
 852 bfad_iocmd_vport_clr_stats(struct bfad_s *bfad, void *cmd)
 853 {
 854         struct bfa_fcs_vport_s *fcs_vport;
 855         struct bfa_bsg_reset_stats_s *iocmd =
 856                                 (struct bfa_bsg_reset_stats_s *)cmd;
 857         unsigned long   flags;
 858
 859         spin_lock_irqsave(&bfad->bfad_lock, flags);
 860         fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
 861                                 iocmd->vf_id, iocmd->vpwwn);
 862         if (fcs_vport == NULL) {
 863                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 864                 iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
 865                 goto out;
 866         }
 867
 868         memset(&fcs_vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));
 869         memset(&fcs_vport->lport.stats, 0, sizeof(struct bfa_lport_stats_s));
 870         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 871         iocmd->status = BFA_STATUS_OK;
 872 out:
 873         return 0;
 874 }
 875
 876 static int
 877 bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,
 878                         unsigned int payload_len)
 879 {
 880         struct bfa_bsg_fabric_get_lports_s *iocmd =
 881                         (struct bfa_bsg_fabric_get_lports_s *)cmd;
 882         bfa_fcs_vf_t    *fcs_vf;
 883         uint32_t        nports = iocmd->nports;
 884         unsigned long   flags;
 885         void    *iocmd_bufptr;
 886
 887         if (nports == 0) {
 888                 iocmd->status = BFA_STATUS_EINVAL;
 889                 goto out;
 890         }
 891
 892         if (bfad_chk_iocmd_sz(payload_len,
 893                 sizeof(struct bfa_bsg_fabric_get_lports_s),
 894                 sizeof(wwn_t) * iocmd->nports) != BFA_STATUS_OK) {
 895                 iocmd->status = BFA_STATUS_VERSION_FAIL;
 896                 goto out;
 897         }
 898
 899         iocmd_bufptr = (char *)iocmd +
 900                         sizeof(struct bfa_bsg_fabric_get_lports_s);
 901
 902         spin_lock_irqsave(&bfad->bfad_lock, flags);
 903         fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
 904         if (fcs_vf == NULL) {
 905                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 906                 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
 907                 goto out;
 908         }
 909         bfa_fcs_vf_get_ports(fcs_vf, (wwn_t *)iocmd_bufptr, &nports);
 910         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 911
 912         iocmd->nports = nports;
 913         iocmd->status = BFA_STATUS_OK;
 914 out:
 915         return 0;
 916 }
 917
 918 int
 919 bfad_iocmd_qos_set_bw(struct bfad_s *bfad, void *pcmd)
 920 {
 921         struct bfa_bsg_qos_bw_s *iocmd = (struct bfa_bsg_qos_bw_s *)pcmd;
 922         unsigned long   flags;
 923
 924         spin_lock_irqsave(&bfad->bfad_lock, flags);
 925         iocmd->status = bfa_fcport_set_qos_bw(&bfad->bfa, &iocmd->qos_bw);
 926         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 927
 928         return 0;
 929 }
 930
 931 int
 932 bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
 933 {
 934         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
 935         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
 936         unsigned long   flags;
 937
 938         spin_lock_irqsave(&bfad->bfad_lock, flags);
 939
 940         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
 941                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
 942                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
 943         else {
 944                 if (cmd == IOCMD_RATELIM_ENABLE)
 945                         fcport->cfg.ratelimit = BFA_TRUE;
 946                 else if (cmd == IOCMD_RATELIM_DISABLE)
 947                         fcport->cfg.ratelimit = BFA_FALSE;
 948
 949                 if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
 950                         fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
 951
 952                 iocmd->status = BFA_STATUS_OK;
 953         }
 954
 955         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 956
 957         return 0;
 958 }
 959
 960 int
 961 bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
 962 {
 963         struct bfa_bsg_trl_speed_s *iocmd = (struct bfa_bsg_trl_speed_s *)pcmd;
 964         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
 965         unsigned long   flags;
 966
 967         spin_lock_irqsave(&bfad->bfad_lock, flags);
 968
 969         /* Auto and speeds greater than the supported speed, are invalid */
 970         if ((iocmd->speed == BFA_PORT_SPEED_AUTO) ||
 971             (iocmd->speed > fcport->speed_sup)) {
 972                 iocmd->status = BFA_STATUS_UNSUPP_SPEED;
 973                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 974                 return 0;
 975         }
 976
 977         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
 978                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
 979                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
 980         else {
 981                 fcport->cfg.trl_def_speed = iocmd->speed;
 982                 iocmd->status = BFA_STATUS_OK;
 983         }
 984         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 985
 986         return 0;
 987 }
 988
 989 int
 990 bfad_iocmd_cfg_fcpim(struct bfad_s *bfad, void *cmd)
 991 {
 992         struct bfa_bsg_fcpim_s *iocmd = (struct bfa_bsg_fcpim_s *)cmd;
 993         unsigned long   flags;
 994
 995         spin_lock_irqsave(&bfad->bfad_lock, flags);
 996         bfa_fcpim_path_tov_set(&bfad->bfa, iocmd->param);
 997         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 998         iocmd->status = BFA_STATUS_OK;
 999         return 0;
1000 }
1001
1002 int
1003 bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
1004 {
1005         struct bfa_bsg_fcpim_modstats_s *iocmd =
1006                         (struct bfa_bsg_fcpim_modstats_s *)cmd;
1007         struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1008         struct list_head *qe, *qen;
1009         struct bfa_itnim_s *itnim;
1010         unsigned long   flags;
1011
1012         spin_lock_irqsave(&bfad->bfad_lock, flags);
1013         /* accumulate IO stats from itnim */
1014         memset((void *)&iocmd->modstats, 0, sizeof(struct bfa_itnim_iostats_s));
1015         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1016                 itnim = (struct bfa_itnim_s *) qe;
1017                 bfa_fcpim_add_stats(&iocmd->modstats, &(itnim->stats));
1018         }
1019         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1020         iocmd->status = BFA_STATUS_OK;
1021         return 0;
1022 }
1023
1024 int
1025 bfad_iocmd_fcpim_clr_modstats(struct bfad_s *bfad, void *cmd)
1026 {
1027         struct bfa_bsg_fcpim_modstatsclr_s *iocmd =
1028                                 (struct bfa_bsg_fcpim_modstatsclr_s *)cmd;
1029         struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1030         struct list_head *qe, *qen;
1031         struct bfa_itnim_s *itnim;
1032         unsigned long   flags;
1033
1034         spin_lock_irqsave(&bfad->bfad_lock, flags);
1035         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
1036                 itnim = (struct bfa_itnim_s *) qe;
1037                 bfa_itnim_clear_stats(itnim);
1038         }
1039         memset(&fcpim->del_itn_stats, 0,
1040                 sizeof(struct bfa_fcpim_del_itn_stats_s));
1041         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1042         iocmd->status = BFA_STATUS_OK;
1043         return 0;
1044 }
1045
1046 int
1047 bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)
1048 {
1049         struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
1050                         (struct bfa_bsg_fcpim_del_itn_stats_s *)cmd;
1051         struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
1052         unsigned long   flags;
1053
1054         spin_lock_irqsave(&bfad->bfad_lock, flags);
1055         memcpy((void *)&iocmd->modstats, (void *)&fcpim->del_itn_stats,
1056                 sizeof(struct bfa_fcpim_del_itn_stats_s));
1057         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1058
1059         iocmd->status = BFA_STATUS_OK;
1060         return 0;
1061 }
1062
1063 static int
1064 bfad_iocmd_itnim_get_attr(struct bfad_s *bfad, void *cmd)
1065 {
1066         struct bfa_bsg_itnim_attr_s *iocmd = (struct bfa_bsg_itnim_attr_s *)cmd;
1067         struct bfa_fcs_lport_s  *fcs_port;
1068         unsigned long   flags;
1069
1070         spin_lock_irqsave(&bfad->bfad_lock, flags);
1071         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1072                                 iocmd->vf_id, iocmd->lpwwn);
1073         if (!fcs_port)
1074                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1075         else
1076                 iocmd->status = bfa_fcs_itnim_attr_get(fcs_port,
1077                                         iocmd->rpwwn, &iocmd->attr);
1078         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1079         return 0;
1080 }
1081
1082 static int
1083 bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
1084 {
1085         struct bfa_bsg_itnim_iostats_s *iocmd =
1086                         (struct bfa_bsg_itnim_iostats_s *)cmd;
1087         struct bfa_fcs_lport_s *fcs_port;
1088         struct bfa_fcs_itnim_s *itnim;
1089         unsigned long   flags;
1090
1091         spin_lock_irqsave(&bfad->bfad_lock, flags);
1092         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1093                                 iocmd->vf_id, iocmd->lpwwn);
1094         if (!fcs_port) {
1095                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1096                 bfa_trc(bfad, 0);
1097         } else {
1098                 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1099                 if (itnim == NULL)
1100                         iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1101                 else {
1102                         iocmd->status = BFA_STATUS_OK;
1103                         if (bfa_fcs_itnim_get_halitn(itnim))
1104                                 memcpy((void *)&iocmd->iostats, (void *)
1105                                 &(bfa_fcs_itnim_get_halitn(itnim)->stats),
1106                                        sizeof(struct bfa_itnim_iostats_s));
1107                 }
1108         }
1109         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1110         return 0;
1111 }
1112
1113 static int
1114 bfad_iocmd_itnim_reset_stats(struct bfad_s *bfad, void *cmd)
1115 {
1116         struct bfa_bsg_rport_reset_stats_s *iocmd =
1117                         (struct bfa_bsg_rport_reset_stats_s *)cmd;
1118         struct bfa_fcs_lport_s  *fcs_port;
1119         struct bfa_fcs_itnim_s  *itnim;
1120         unsigned long   flags;
1121
1122         spin_lock_irqsave(&bfad->bfad_lock, flags);
1123         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1124                                 iocmd->vf_id, iocmd->pwwn);
1125         if (!fcs_port)
1126                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1127         else {
1128                 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1129                 if (itnim == NULL)
1130                         iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1131                 else {
1132                         iocmd->status = BFA_STATUS_OK;
1133                         bfa_fcs_itnim_stats_clear(fcs_port, iocmd->rpwwn);
1134                         bfa_itnim_clear_stats(bfa_fcs_itnim_get_halitn(itnim));
1135                 }
1136         }
1137         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1138
1139         return 0;
1140 }
1141
1142 static int
1143 bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)
1144 {
1145         struct bfa_bsg_itnim_itnstats_s *iocmd =
1146                         (struct bfa_bsg_itnim_itnstats_s *)cmd;
1147         struct bfa_fcs_lport_s *fcs_port;
1148         struct bfa_fcs_itnim_s *itnim;
1149         unsigned long   flags;
1150
1151         spin_lock_irqsave(&bfad->bfad_lock, flags);
1152         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
1153                                 iocmd->vf_id, iocmd->lpwwn);
1154         if (!fcs_port) {
1155                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
1156                 bfa_trc(bfad, 0);
1157         } else {
1158                 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
1159                 if (itnim == NULL)
1160                         iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1161                 else {
1162                         iocmd->status = BFA_STATUS_OK;
1163                         bfa_fcs_itnim_stats_get(fcs_port, iocmd->rpwwn,
1164                                         &iocmd->itnstats);
1165                 }
1166         }
1167         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1168         return 0;
1169 }
1170
1171 int
1172 bfad_iocmd_fcport_enable(struct bfad_s *bfad, void *cmd)
1173 {
1174         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1175         unsigned long flags;
1176
1177         spin_lock_irqsave(&bfad->bfad_lock, flags);
1178         iocmd->status = bfa_fcport_enable(&bfad->bfa);
1179         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1180
1181         return 0;
1182 }
1183
1184 int
1185 bfad_iocmd_fcport_disable(struct bfad_s *bfad, void *cmd)
1186 {
1187         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1188         unsigned long flags;
1189
1190         spin_lock_irqsave(&bfad->bfad_lock, flags);
1191         iocmd->status = bfa_fcport_disable(&bfad->bfa);
1192         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1193
1194         return 0;
1195 }
1196
1197 int
1198 bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s *bfad, void *cmd)
1199 {
1200         struct bfa_bsg_pcifn_cfg_s *iocmd = (struct bfa_bsg_pcifn_cfg_s *)cmd;
1201         struct bfad_hal_comp fcomp;
1202         unsigned long flags;
1203
1204         init_completion(&fcomp.comp);
1205         spin_lock_irqsave(&bfad->bfad_lock, flags);
1206         iocmd->status = bfa_ablk_query(&bfad->bfa.modules.ablk,
1207                                 &iocmd->pcifn_cfg,
1208                                 bfad_hcb_comp, &fcomp);
1209         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1210         if (iocmd->status != BFA_STATUS_OK)
1211                 goto out;
1212
1213         wait_for_completion(&fcomp.comp);
1214         iocmd->status = fcomp.status;
1215 out:
1216         return 0;
1217 }
1218
1219 int
1220 bfad_iocmd_pcifn_create(struct bfad_s *bfad, void *cmd)
1221 {
1222         struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1223         struct bfad_hal_comp fcomp;
1224         unsigned long flags;
1225
1226         init_completion(&fcomp.comp);
1227         spin_lock_irqsave(&bfad->bfad_lock, flags);
1228         iocmd->status = bfa_ablk_pf_create(&bfad->bfa.modules.ablk,
1229                                 &iocmd->pcifn_id, iocmd->port,
1230                                 iocmd->pcifn_class, iocmd->bw_min,
1231                                 iocmd->bw_max, bfad_hcb_comp, &fcomp);
1232         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1233         if (iocmd->status != BFA_STATUS_OK)
1234                 goto out;
1235
1236         wait_for_completion(&fcomp.comp);
1237         iocmd->status = fcomp.status;
1238 out:
1239         return 0;
1240 }
1241
1242 int
1243 bfad_iocmd_pcifn_delete(struct bfad_s *bfad, void *cmd)
1244 {
1245         struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1246         struct bfad_hal_comp fcomp;
1247         unsigned long flags;
1248
1249         init_completion(&fcomp.comp);
1250         spin_lock_irqsave(&bfad->bfad_lock, flags);
1251         iocmd->status = bfa_ablk_pf_delete(&bfad->bfa.modules.ablk,
1252                                 iocmd->pcifn_id,
1253                                 bfad_hcb_comp, &fcomp);
1254         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1255         if (iocmd->status != BFA_STATUS_OK)
1256                 goto out;
1257
1258         wait_for_completion(&fcomp.comp);
1259         iocmd->status = fcomp.status;
1260 out:
1261         return 0;
1262 }
1263
1264 int
1265 bfad_iocmd_pcifn_bw(struct bfad_s *bfad, void *cmd)
1266 {
1267         struct bfa_bsg_pcifn_s *iocmd = (struct bfa_bsg_pcifn_s *)cmd;
1268         struct bfad_hal_comp fcomp;
1269         unsigned long flags;
1270
1271         init_completion(&fcomp.comp);
1272         spin_lock_irqsave(&bfad->bfad_lock, flags);
1273         iocmd->status = bfa_ablk_pf_update(&bfad->bfa.modules.ablk,
1274                                 iocmd->pcifn_id, iocmd->bw_min,
1275                                 iocmd->bw_max, bfad_hcb_comp, &fcomp);
1276         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1277         bfa_trc(bfad, iocmd->status);
1278         if (iocmd->status != BFA_STATUS_OK)
1279                 goto out;
1280
1281         wait_for_completion(&fcomp.comp);
1282         iocmd->status = fcomp.status;
1283         bfa_trc(bfad, iocmd->status);
1284 out:
1285         return 0;
1286 }
1287
1288 int
1289 bfad_iocmd_adapter_cfg_mode(struct bfad_s *bfad, void *cmd)
1290 {
1291         struct bfa_bsg_adapter_cfg_mode_s *iocmd =
1292                         (struct bfa_bsg_adapter_cfg_mode_s *)cmd;
1293         struct bfad_hal_comp fcomp;
1294         unsigned long flags = 0;
1295
1296         init_completion(&fcomp.comp);
1297         spin_lock_irqsave(&bfad->bfad_lock, flags);
1298         iocmd->status = bfa_ablk_adapter_config(&bfad->bfa.modules.ablk,
1299                                 iocmd->cfg.mode, iocmd->cfg.max_pf,
1300                                 iocmd->cfg.max_vf, bfad_hcb_comp, &fcomp);
1301         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1302         if (iocmd->status != BFA_STATUS_OK)
1303                 goto out;
1304
1305         wait_for_completion(&fcomp.comp);
1306         iocmd->status = fcomp.status;
1307 out:
1308         return 0;
1309 }
1310
1311 int
1312 bfad_iocmd_port_cfg_mode(struct bfad_s *bfad, void *cmd)
1313 {
1314         struct bfa_bsg_port_cfg_mode_s *iocmd =
1315                         (struct bfa_bsg_port_cfg_mode_s *)cmd;
1316         struct bfad_hal_comp fcomp;
1317         unsigned long flags = 0;
1318
1319         init_completion(&fcomp.comp);
1320         spin_lock_irqsave(&bfad->bfad_lock, flags);
1321         iocmd->status = bfa_ablk_port_config(&bfad->bfa.modules.ablk,
1322                                 iocmd->instance, iocmd->cfg.mode,
1323                                 iocmd->cfg.max_pf, iocmd->cfg.max_vf,
1324                                 bfad_hcb_comp, &fcomp);
1325         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1326         if (iocmd->status != BFA_STATUS_OK)
1327                 goto out;
1328
1329         wait_for_completion(&fcomp.comp);
1330         iocmd->status = fcomp.status;
1331 out:
1332         return 0;
1333 }
1334
1335 int
1336 bfad_iocmd_ablk_optrom(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
1337 {
1338         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1339         struct bfad_hal_comp fcomp;
1340         unsigned long   flags;
1341
1342         init_completion(&fcomp.comp);
1343         spin_lock_irqsave(&bfad->bfad_lock, flags);
1344         if (cmd == IOCMD_FLASH_ENABLE_OPTROM)
1345                 iocmd->status = bfa_ablk_optrom_en(&bfad->bfa.modules.ablk,
1346                                         bfad_hcb_comp, &fcomp);
1347         else
1348                 iocmd->status = bfa_ablk_optrom_dis(&bfad->bfa.modules.ablk,
1349                                         bfad_hcb_comp, &fcomp);
1350         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1351
1352         if (iocmd->status != BFA_STATUS_OK)
1353                 goto out;
1354
1355         wait_for_completion(&fcomp.comp);
1356         iocmd->status = fcomp.status;
1357 out:
1358         return 0;
1359 }
1360
1361 int
1362 bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd)
1363 {
1364         struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd;
1365         struct bfad_hal_comp    fcomp;
1366         unsigned long   flags;
1367
1368         init_completion(&fcomp.comp);
1369         iocmd->status = BFA_STATUS_OK;
1370         spin_lock_irqsave(&bfad->bfad_lock, flags);
1371         iocmd->status = bfa_faa_query(&bfad->bfa, &iocmd->faa_attr,
1372                                 bfad_hcb_comp, &fcomp);
1373         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1374
1375         if (iocmd->status != BFA_STATUS_OK)
1376                 goto out;
1377
1378         wait_for_completion(&fcomp.comp);
1379         iocmd->status = fcomp.status;
1380 out:
1381         return 0;
1382 }
1383
1384 int
1385 bfad_iocmd_cee_attr(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1386 {
1387         struct bfa_bsg_cee_attr_s *iocmd =
1388                                 (struct bfa_bsg_cee_attr_s *)cmd;
1389         void    *iocmd_bufptr;
1390         struct bfad_hal_comp    cee_comp;
1391         unsigned long   flags;
1392
1393         if (bfad_chk_iocmd_sz(payload_len,
1394                         sizeof(struct bfa_bsg_cee_attr_s),
1395                         sizeof(struct bfa_cee_attr_s)) != BFA_STATUS_OK) {
1396                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1397                 return 0;
1398         }
1399
1400         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_attr_s);
1401
1402         cee_comp.status = 0;
1403         init_completion(&cee_comp.comp);
1404         mutex_lock(&bfad_mutex);
1405         spin_lock_irqsave(&bfad->bfad_lock, flags);
1406         iocmd->status = bfa_cee_get_attr(&bfad->bfa.modules.cee, iocmd_bufptr,
1407                                          bfad_hcb_comp, &cee_comp);
1408         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1409         if (iocmd->status != BFA_STATUS_OK) {
1410                 mutex_unlock(&bfad_mutex);
1411                 bfa_trc(bfad, 0x5555);
1412                 goto out;
1413         }
1414         wait_for_completion(&cee_comp.comp);
1415         mutex_unlock(&bfad_mutex);
1416 out:
1417         return 0;
1418 }
1419
1420 int
1421 bfad_iocmd_cee_get_stats(struct bfad_s *bfad, void *cmd,
1422                         unsigned int payload_len)
1423 {
1424         struct bfa_bsg_cee_stats_s *iocmd =
1425                                 (struct bfa_bsg_cee_stats_s *)cmd;
1426         void    *iocmd_bufptr;
1427         struct bfad_hal_comp    cee_comp;
1428         unsigned long   flags;
1429
1430         if (bfad_chk_iocmd_sz(payload_len,
1431                         sizeof(struct bfa_bsg_cee_stats_s),
1432                         sizeof(struct bfa_cee_stats_s)) != BFA_STATUS_OK) {
1433                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1434                 return 0;
1435         }
1436
1437         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_cee_stats_s);
1438
1439         cee_comp.status = 0;
1440         init_completion(&cee_comp.comp);
1441         mutex_lock(&bfad_mutex);
1442         spin_lock_irqsave(&bfad->bfad_lock, flags);
1443         iocmd->status = bfa_cee_get_stats(&bfad->bfa.modules.cee, iocmd_bufptr,
1444                                         bfad_hcb_comp, &cee_comp);
1445         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1446         if (iocmd->status != BFA_STATUS_OK) {
1447                 mutex_unlock(&bfad_mutex);
1448                 bfa_trc(bfad, 0x5555);
1449                 goto out;
1450         }
1451         wait_for_completion(&cee_comp.comp);
1452         mutex_unlock(&bfad_mutex);
1453 out:
1454         return 0;
1455 }
1456
1457 int
1458 bfad_iocmd_cee_reset_stats(struct bfad_s *bfad, void *cmd)
1459 {
1460         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1461         unsigned long   flags;
1462
1463         spin_lock_irqsave(&bfad->bfad_lock, flags);
1464         iocmd->status = bfa_cee_reset_stats(&bfad->bfa.modules.cee, NULL, NULL);
1465         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1466         if (iocmd->status != BFA_STATUS_OK)
1467                 bfa_trc(bfad, 0x5555);
1468         return 0;
1469 }
1470
1471 int
1472 bfad_iocmd_sfp_media(struct bfad_s *bfad, void *cmd)
1473 {
1474         struct bfa_bsg_sfp_media_s *iocmd = (struct bfa_bsg_sfp_media_s *)cmd;
1475         struct bfad_hal_comp    fcomp;
1476         unsigned long   flags;
1477
1478         init_completion(&fcomp.comp);
1479         spin_lock_irqsave(&bfad->bfad_lock, flags);
1480         iocmd->status = bfa_sfp_media(BFA_SFP_MOD(&bfad->bfa), &iocmd->media,
1481                                 bfad_hcb_comp, &fcomp);
1482         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1483         bfa_trc(bfad, iocmd->status);
1484         if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1485                 goto out;
1486
1487         wait_for_completion(&fcomp.comp);
1488         iocmd->status = fcomp.status;
1489 out:
1490         return 0;
1491 }
1492
1493 int
1494 bfad_iocmd_sfp_speed(struct bfad_s *bfad, void *cmd)
1495 {
1496         struct bfa_bsg_sfp_speed_s *iocmd = (struct bfa_bsg_sfp_speed_s *)cmd;
1497         struct bfad_hal_comp    fcomp;
1498         unsigned long   flags;
1499
1500         init_completion(&fcomp.comp);
1501         spin_lock_irqsave(&bfad->bfad_lock, flags);
1502         iocmd->status = bfa_sfp_speed(BFA_SFP_MOD(&bfad->bfa), iocmd->speed,
1503                                 bfad_hcb_comp, &fcomp);
1504         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1505         bfa_trc(bfad, iocmd->status);
1506         if (iocmd->status != BFA_STATUS_SFP_NOT_READY)
1507                 goto out;
1508         wait_for_completion(&fcomp.comp);
1509         iocmd->status = fcomp.status;
1510 out:
1511         return 0;
1512 }
1513
1514 int
1515 bfad_iocmd_flash_get_attr(struct bfad_s *bfad, void *cmd)
1516 {
1517         struct bfa_bsg_flash_attr_s *iocmd =
1518                         (struct bfa_bsg_flash_attr_s *)cmd;
1519         struct bfad_hal_comp fcomp;
1520         unsigned long   flags;
1521
1522         init_completion(&fcomp.comp);
1523         spin_lock_irqsave(&bfad->bfad_lock, flags);
1524         iocmd->status = bfa_flash_get_attr(BFA_FLASH(&bfad->bfa), &iocmd->attr,
1525                                 bfad_hcb_comp, &fcomp);
1526         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1527         if (iocmd->status != BFA_STATUS_OK)
1528                 goto out;
1529         wait_for_completion(&fcomp.comp);
1530         iocmd->status = fcomp.status;
1531 out:
1532         return 0;
1533 }
1534
1535 int
1536 bfad_iocmd_flash_erase_part(struct bfad_s *bfad, void *cmd)
1537 {
1538         struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1539         struct bfad_hal_comp fcomp;
1540         unsigned long   flags;
1541
1542         init_completion(&fcomp.comp);
1543         spin_lock_irqsave(&bfad->bfad_lock, flags);
1544         iocmd->status = bfa_flash_erase_part(BFA_FLASH(&bfad->bfa), iocmd->type,
1545                                 iocmd->instance, bfad_hcb_comp, &fcomp);
1546         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1547         if (iocmd->status != BFA_STATUS_OK)
1548                 goto out;
1549         wait_for_completion(&fcomp.comp);
1550         iocmd->status = fcomp.status;
1551 out:
1552         return 0;
1553 }
1554
1555 int
1556 bfad_iocmd_flash_update_part(struct bfad_s *bfad, void *cmd,
1557                         unsigned int payload_len)
1558 {
1559         struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1560         void    *iocmd_bufptr;
1561         struct bfad_hal_comp fcomp;
1562         unsigned long   flags;
1563
1564         if (bfad_chk_iocmd_sz(payload_len,
1565                         sizeof(struct bfa_bsg_flash_s),
1566                         iocmd->bufsz) != BFA_STATUS_OK) {
1567                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1568                 return 0;
1569         }
1570
1571         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1572
1573         init_completion(&fcomp.comp);
1574         spin_lock_irqsave(&bfad->bfad_lock, flags);
1575         iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
1576                                 iocmd->type, iocmd->instance, iocmd_bufptr,
1577                                 iocmd->bufsz, 0, bfad_hcb_comp, &fcomp);
1578         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1579         if (iocmd->status != BFA_STATUS_OK)
1580                 goto out;
1581         wait_for_completion(&fcomp.comp);
1582         iocmd->status = fcomp.status;
1583 out:
1584         return 0;
1585 }
1586
1587 int
1588 bfad_iocmd_flash_read_part(struct bfad_s *bfad, void *cmd,
1589                         unsigned int payload_len)
1590 {
1591         struct bfa_bsg_flash_s *iocmd = (struct bfa_bsg_flash_s *)cmd;
1592         struct bfad_hal_comp fcomp;
1593         void    *iocmd_bufptr;
1594         unsigned long   flags;
1595
1596         if (bfad_chk_iocmd_sz(payload_len,
1597                         sizeof(struct bfa_bsg_flash_s),
1598                         iocmd->bufsz) != BFA_STATUS_OK) {
1599                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1600                 return 0;
1601         }
1602
1603         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_flash_s);
1604
1605         init_completion(&fcomp.comp);
1606         spin_lock_irqsave(&bfad->bfad_lock, flags);
1607         iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa), iocmd->type,
1608                                 iocmd->instance, iocmd_bufptr, iocmd->bufsz, 0,
1609                                 bfad_hcb_comp, &fcomp);
1610         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1611         if (iocmd->status != BFA_STATUS_OK)
1612                 goto out;
1613         wait_for_completion(&fcomp.comp);
1614         iocmd->status = fcomp.status;
1615 out:
1616         return 0;
1617 }
1618
1619 int
1620 bfad_iocmd_diag_temp(struct bfad_s *bfad, void *cmd)
1621 {
1622         struct bfa_bsg_diag_get_temp_s *iocmd =
1623                         (struct bfa_bsg_diag_get_temp_s *)cmd;
1624         struct bfad_hal_comp fcomp;
1625         unsigned long   flags;
1626
1627         init_completion(&fcomp.comp);
1628         spin_lock_irqsave(&bfad->bfad_lock, flags);
1629         iocmd->status = bfa_diag_tsensor_query(BFA_DIAG_MOD(&bfad->bfa),
1630                                 &iocmd->result, bfad_hcb_comp, &fcomp);
1631         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1632         bfa_trc(bfad, iocmd->status);
1633         if (iocmd->status != BFA_STATUS_OK)
1634                 goto out;
1635         wait_for_completion(&fcomp.comp);
1636         iocmd->status = fcomp.status;
1637 out:
1638         return 0;
1639 }
1640
1641 int
1642 bfad_iocmd_diag_memtest(struct bfad_s *bfad, void *cmd)
1643 {
1644         struct bfa_bsg_diag_memtest_s *iocmd =
1645                         (struct bfa_bsg_diag_memtest_s *)cmd;
1646         struct bfad_hal_comp fcomp;
1647         unsigned long   flags;
1648
1649         init_completion(&fcomp.comp);
1650         spin_lock_irqsave(&bfad->bfad_lock, flags);
1651         iocmd->status = bfa_diag_memtest(BFA_DIAG_MOD(&bfad->bfa),
1652                                 &iocmd->memtest, iocmd->pat,
1653                                 &iocmd->result, bfad_hcb_comp, &fcomp);
1654         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1655         bfa_trc(bfad, iocmd->status);
1656         if (iocmd->status != BFA_STATUS_OK)
1657                 goto out;
1658         wait_for_completion(&fcomp.comp);
1659         iocmd->status = fcomp.status;
1660 out:
1661         return 0;
1662 }
1663
1664 int
1665 bfad_iocmd_diag_loopback(struct bfad_s *bfad, void *cmd)
1666 {
1667         struct bfa_bsg_diag_loopback_s *iocmd =
1668                         (struct bfa_bsg_diag_loopback_s *)cmd;
1669         struct bfad_hal_comp fcomp;
1670         unsigned long   flags;
1671
1672         init_completion(&fcomp.comp);
1673         spin_lock_irqsave(&bfad->bfad_lock, flags);
1674         iocmd->status = bfa_fcdiag_loopback(&bfad->bfa, iocmd->opmode,
1675                                 iocmd->speed, iocmd->lpcnt, iocmd->pat,
1676                                 &iocmd->result, bfad_hcb_comp, &fcomp);
1677         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1678         bfa_trc(bfad, iocmd->status);
1679         if (iocmd->status != BFA_STATUS_OK)
1680                 goto out;
1681         wait_for_completion(&fcomp.comp);
1682         iocmd->status = fcomp.status;
1683 out:
1684         return 0;
1685 }
1686
1687 int
1688 bfad_iocmd_diag_fwping(struct bfad_s *bfad, void *cmd)
1689 {
1690         struct bfa_bsg_diag_fwping_s *iocmd =
1691                         (struct bfa_bsg_diag_fwping_s *)cmd;
1692         struct bfad_hal_comp fcomp;
1693         unsigned long   flags;
1694
1695         init_completion(&fcomp.comp);
1696         spin_lock_irqsave(&bfad->bfad_lock, flags);
1697         iocmd->status = bfa_diag_fwping(BFA_DIAG_MOD(&bfad->bfa), iocmd->cnt,
1698                                 iocmd->pattern, &iocmd->result,
1699                                 bfad_hcb_comp, &fcomp);
1700         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1701         bfa_trc(bfad, iocmd->status);
1702         if (iocmd->status != BFA_STATUS_OK)
1703                 goto out;
1704         bfa_trc(bfad, 0x77771);
1705         wait_for_completion(&fcomp.comp);
1706         iocmd->status = fcomp.status;
1707 out:
1708         return 0;
1709 }
1710
1711 int
1712 bfad_iocmd_diag_queuetest(struct bfad_s *bfad, void *cmd)
1713 {
1714         struct bfa_bsg_diag_qtest_s *iocmd = (struct bfa_bsg_diag_qtest_s *)cmd;
1715         struct bfad_hal_comp fcomp;
1716         unsigned long   flags;
1717
1718         init_completion(&fcomp.comp);
1719         spin_lock_irqsave(&bfad->bfad_lock, flags);
1720         iocmd->status = bfa_fcdiag_queuetest(&bfad->bfa, iocmd->force,
1721                                 iocmd->queue, &iocmd->result,
1722                                 bfad_hcb_comp, &fcomp);
1723         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1724         if (iocmd->status != BFA_STATUS_OK)
1725                 goto out;
1726         wait_for_completion(&fcomp.comp);
1727         iocmd->status = fcomp.status;
1728 out:
1729         return 0;
1730 }
1731
1732 int
1733 bfad_iocmd_diag_sfp(struct bfad_s *bfad, void *cmd)
1734 {
1735         struct bfa_bsg_sfp_show_s *iocmd =
1736                         (struct bfa_bsg_sfp_show_s *)cmd;
1737         struct bfad_hal_comp fcomp;
1738         unsigned long   flags;
1739
1740         init_completion(&fcomp.comp);
1741         spin_lock_irqsave(&bfad->bfad_lock, flags);
1742         iocmd->status = bfa_sfp_show(BFA_SFP_MOD(&bfad->bfa), &iocmd->sfp,
1743                                 bfad_hcb_comp, &fcomp);
1744         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1745         bfa_trc(bfad, iocmd->status);
1746         if (iocmd->status != BFA_STATUS_OK)
1747                 goto out;
1748         wait_for_completion(&fcomp.comp);
1749         iocmd->status = fcomp.status;
1750         bfa_trc(bfad, iocmd->status);
1751 out:
1752         return 0;
1753 }
1754
1755 int
1756 bfad_iocmd_diag_led(struct bfad_s *bfad, void *cmd)
1757 {
1758         struct bfa_bsg_diag_led_s *iocmd = (struct bfa_bsg_diag_led_s *)cmd;
1759         unsigned long   flags;
1760
1761         spin_lock_irqsave(&bfad->bfad_lock, flags);
1762         iocmd->status = bfa_diag_ledtest(BFA_DIAG_MOD(&bfad->bfa),
1763                                 &iocmd->ledtest);
1764         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1765         return 0;
1766 }
1767
1768 int
1769 bfad_iocmd_diag_beacon_lport(struct bfad_s *bfad, void *cmd)
1770 {
1771         struct bfa_bsg_diag_beacon_s *iocmd =
1772                         (struct bfa_bsg_diag_beacon_s *)cmd;
1773         unsigned long   flags;
1774
1775         spin_lock_irqsave(&bfad->bfad_lock, flags);
1776         iocmd->status = bfa_diag_beacon_port(BFA_DIAG_MOD(&bfad->bfa),
1777                                 iocmd->beacon, iocmd->link_e2e_beacon,
1778                                 iocmd->second);
1779         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1780         return 0;
1781 }
1782
1783 int
1784 bfad_iocmd_diag_lb_stat(struct bfad_s *bfad, void *cmd)
1785 {
1786         struct bfa_bsg_diag_lb_stat_s *iocmd =
1787                         (struct bfa_bsg_diag_lb_stat_s *)cmd;
1788         unsigned long   flags;
1789
1790         spin_lock_irqsave(&bfad->bfad_lock, flags);
1791         iocmd->status = bfa_fcdiag_lb_is_running(&bfad->bfa);
1792         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1793         bfa_trc(bfad, iocmd->status);
1794
1795         return 0;
1796 }
1797
1798 int
1799 bfad_iocmd_diag_dport_enable(struct bfad_s *bfad, void *pcmd)
1800 {
1801         struct bfa_bsg_dport_enable_s *iocmd =
1802                                 (struct bfa_bsg_dport_enable_s *)pcmd;
1803         unsigned long   flags;
1804         struct bfad_hal_comp fcomp;
1805
1806         init_completion(&fcomp.comp);
1807         spin_lock_irqsave(&bfad->bfad_lock, flags);
1808         iocmd->status = bfa_dport_enable(&bfad->bfa, iocmd->lpcnt,
1809                                         iocmd->pat, bfad_hcb_comp, &fcomp);
1810         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1811         if (iocmd->status != BFA_STATUS_OK)
1812                 bfa_trc(bfad, iocmd->status);
1813         else {
1814                 wait_for_completion(&fcomp.comp);
1815                 iocmd->status = fcomp.status;
1816         }
1817         return 0;
1818 }
1819
1820 int
1821 bfad_iocmd_diag_dport_disable(struct bfad_s *bfad, void *pcmd)
1822 {
1823         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1824         unsigned long   flags;
1825         struct bfad_hal_comp fcomp;
1826
1827         init_completion(&fcomp.comp);
1828         spin_lock_irqsave(&bfad->bfad_lock, flags);
1829         iocmd->status = bfa_dport_disable(&bfad->bfa, bfad_hcb_comp, &fcomp);
1830         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1831         if (iocmd->status != BFA_STATUS_OK)
1832                 bfa_trc(bfad, iocmd->status);
1833         else {
1834                 wait_for_completion(&fcomp.comp);
1835                 iocmd->status = fcomp.status;
1836         }
1837         return 0;
1838 }
1839
1840 int
1841 bfad_iocmd_diag_dport_start(struct bfad_s *bfad, void *pcmd)
1842 {
1843         struct bfa_bsg_dport_enable_s *iocmd =
1844                                 (struct bfa_bsg_dport_enable_s *)pcmd;
1845         unsigned long   flags;
1846         struct bfad_hal_comp fcomp;
1847
1848         init_completion(&fcomp.comp);
1849         spin_lock_irqsave(&bfad->bfad_lock, flags);
1850         iocmd->status = bfa_dport_start(&bfad->bfa, iocmd->lpcnt,
1851                                         iocmd->pat, bfad_hcb_comp,
1852                                         &fcomp);
1853         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1854
1855         if (iocmd->status != BFA_STATUS_OK) {
1856                 bfa_trc(bfad, iocmd->status);
1857         } else {
1858                 wait_for_completion(&fcomp.comp);
1859                 iocmd->status = fcomp.status;
1860         }
1861
1862         return 0;
1863 }
1864
1865 int
1866 bfad_iocmd_diag_dport_show(struct bfad_s *bfad, void *pcmd)
1867 {
1868         struct bfa_bsg_diag_dport_show_s *iocmd =
1869                                 (struct bfa_bsg_diag_dport_show_s *)pcmd;
1870         unsigned long   flags;
1871
1872         spin_lock_irqsave(&bfad->bfad_lock, flags);
1873         iocmd->status = bfa_dport_show(&bfad->bfa, &iocmd->result);
1874         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1875
1876         return 0;
1877 }
1878
1879
1880 int
1881 bfad_iocmd_phy_get_attr(struct bfad_s *bfad, void *cmd)
1882 {
1883         struct bfa_bsg_phy_attr_s *iocmd =
1884                         (struct bfa_bsg_phy_attr_s *)cmd;
1885         struct bfad_hal_comp fcomp;
1886         unsigned long   flags;
1887
1888         init_completion(&fcomp.comp);
1889         spin_lock_irqsave(&bfad->bfad_lock, flags);
1890         iocmd->status = bfa_phy_get_attr(BFA_PHY(&bfad->bfa), iocmd->instance,
1891                                 &iocmd->attr, bfad_hcb_comp, &fcomp);
1892         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1893         if (iocmd->status != BFA_STATUS_OK)
1894                 goto out;
1895         wait_for_completion(&fcomp.comp);
1896         iocmd->status = fcomp.status;
1897 out:
1898         return 0;
1899 }
1900
1901 int
1902 bfad_iocmd_phy_get_stats(struct bfad_s *bfad, void *cmd)
1903 {
1904         struct bfa_bsg_phy_stats_s *iocmd =
1905                         (struct bfa_bsg_phy_stats_s *)cmd;
1906         struct bfad_hal_comp fcomp;
1907         unsigned long   flags;
1908
1909         init_completion(&fcomp.comp);
1910         spin_lock_irqsave(&bfad->bfad_lock, flags);
1911         iocmd->status = bfa_phy_get_stats(BFA_PHY(&bfad->bfa), iocmd->instance,
1912                                 &iocmd->stats, bfad_hcb_comp, &fcomp);
1913         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1914         if (iocmd->status != BFA_STATUS_OK)
1915                 goto out;
1916         wait_for_completion(&fcomp.comp);
1917         iocmd->status = fcomp.status;
1918 out:
1919         return 0;
1920 }
1921
1922 int
1923 bfad_iocmd_phy_read(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1924 {
1925         struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1926         struct bfad_hal_comp fcomp;
1927         void    *iocmd_bufptr;
1928         unsigned long   flags;
1929
1930         if (bfad_chk_iocmd_sz(payload_len,
1931                         sizeof(struct bfa_bsg_phy_s),
1932                         iocmd->bufsz) != BFA_STATUS_OK) {
1933                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1934                 return 0;
1935         }
1936
1937         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1938         init_completion(&fcomp.comp);
1939         spin_lock_irqsave(&bfad->bfad_lock, flags);
1940         iocmd->status = bfa_phy_read(BFA_PHY(&bfad->bfa),
1941                                 iocmd->instance, iocmd_bufptr, iocmd->bufsz,
1942                                 0, bfad_hcb_comp, &fcomp);
1943         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1944         if (iocmd->status != BFA_STATUS_OK)
1945                 goto out;
1946         wait_for_completion(&fcomp.comp);
1947         iocmd->status = fcomp.status;
1948         if (iocmd->status != BFA_STATUS_OK)
1949                 goto out;
1950 out:
1951         return 0;
1952 }
1953
1954 int
1955 bfad_iocmd_vhba_query(struct bfad_s *bfad, void *cmd)
1956 {
1957         struct bfa_bsg_vhba_attr_s *iocmd =
1958                         (struct bfa_bsg_vhba_attr_s *)cmd;
1959         struct bfa_vhba_attr_s *attr = &iocmd->attr;
1960         unsigned long flags;
1961
1962         spin_lock_irqsave(&bfad->bfad_lock, flags);
1963         attr->pwwn =  bfad->bfa.ioc.attr->pwwn;
1964         attr->nwwn =  bfad->bfa.ioc.attr->nwwn;
1965         attr->plog_enabled = (bfa_boolean_t)bfad->bfa.plog->plog_enabled;
1966         attr->io_profile = bfa_fcpim_get_io_profile(&bfad->bfa);
1967         attr->path_tov  = bfa_fcpim_path_tov_get(&bfad->bfa);
1968         iocmd->status = BFA_STATUS_OK;
1969         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1970         return 0;
1971 }
1972
1973 int
1974 bfad_iocmd_phy_update(struct bfad_s *bfad, void *cmd, unsigned int payload_len)
1975 {
1976         struct bfa_bsg_phy_s *iocmd = (struct bfa_bsg_phy_s *)cmd;
1977         void    *iocmd_bufptr;
1978         struct bfad_hal_comp fcomp;
1979         unsigned long   flags;
1980
1981         if (bfad_chk_iocmd_sz(payload_len,
1982                         sizeof(struct bfa_bsg_phy_s),
1983                         iocmd->bufsz) != BFA_STATUS_OK) {
1984                 iocmd->status = BFA_STATUS_VERSION_FAIL;
1985                 return 0;
1986         }
1987
1988         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_phy_s);
1989         init_completion(&fcomp.comp);
1990         spin_lock_irqsave(&bfad->bfad_lock, flags);
1991         iocmd->status = bfa_phy_update(BFA_PHY(&bfad->bfa),
1992                                 iocmd->instance, iocmd_bufptr, iocmd->bufsz,
1993                                 0, bfad_hcb_comp, &fcomp);
1994         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1995         if (iocmd->status != BFA_STATUS_OK)
1996                 goto out;
1997         wait_for_completion(&fcomp.comp);
1998         iocmd->status = fcomp.status;
1999 out:
2000         return 0;
2001 }
2002
2003 int
2004 bfad_iocmd_porglog_get(struct bfad_s *bfad, void *cmd)
2005 {
2006         struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
2007         void *iocmd_bufptr;
2008
2009         if (iocmd->bufsz < sizeof(struct bfa_plog_s)) {
2010                 bfa_trc(bfad, sizeof(struct bfa_plog_s));
2011                 iocmd->status = BFA_STATUS_EINVAL;
2012                 goto out;
2013         }
2014
2015         iocmd->status = BFA_STATUS_OK;
2016         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2017         memcpy(iocmd_bufptr, (u8 *) &bfad->plog_buf, sizeof(struct bfa_plog_s));
2018 out:
2019         return 0;
2020 }
2021
2022 #define BFA_DEBUG_FW_CORE_CHUNK_SZ      0x4000U /* 16K chunks for FW dump */
2023 int
2024 bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
2025                         unsigned int payload_len)
2026 {
2027         struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
2028         void    *iocmd_bufptr;
2029         unsigned long   flags;
2030         u32 offset;
2031
2032         if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),
2033                         BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {
2034                 iocmd->status = BFA_STATUS_VERSION_FAIL;
2035                 return 0;
2036         }
2037
2038         if (iocmd->bufsz < BFA_DEBUG_FW_CORE_CHUNK_SZ ||
2039                         !IS_ALIGNED(iocmd->bufsz, sizeof(u16)) ||
2040                         !IS_ALIGNED(iocmd->offset, sizeof(u32))) {
2041                 bfa_trc(bfad, BFA_DEBUG_FW_CORE_CHUNK_SZ);
2042                 iocmd->status = BFA_STATUS_EINVAL;
2043                 goto out;
2044         }
2045
2046         iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
2047         spin_lock_irqsave(&bfad->bfad_lock, flags);
2048         offset = iocmd->offset;
2049         iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr,
2050                                 &offset, &iocmd->bufsz);
2051         iocmd->offset = offset;
2052         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2053 out:
2054         return 0;
2055 }
2056
2057 int
2058 bfad_iocmd_debug_ctl(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2059 {
2060         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2061         unsigned long   flags;
2062
2063         if (v_cmd == IOCMD_DEBUG_FW_STATE_CLR) {
2064                 spin_lock_irqsave(&bfad->bfad_lock, flags);
2065                 bfad->bfa.ioc.dbg_fwsave_once = BFA_TRUE;
2066                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2067         } else if (v_cmd == IOCMD_DEBUG_PORTLOG_CLR)
2068                 bfad->plog_buf.head = bfad->plog_buf.tail = 0;
2069         else if (v_cmd == IOCMD_DEBUG_START_DTRC)
2070                 bfa_trc_init(bfad->trcmod);
2071         else if (v_cmd == IOCMD_DEBUG_STOP_DTRC)
2072                 bfa_trc_stop(bfad->trcmod);
2073
2074         iocmd->status = BFA_STATUS_OK;
2075         return 0;
2076 }
2077
2078 int
2079 bfad_iocmd_porglog_ctl(struct bfad_s *bfad, void *cmd)
2080 {
2081         struct bfa_bsg_portlogctl_s *iocmd = (struct bfa_bsg_portlogctl_s *)cmd;
2082
2083         if (iocmd->ctl == BFA_TRUE)
2084                 bfad->plog_buf.plog_enabled = 1;
2085         else
2086                 bfad->plog_buf.plog_enabled = 0;
2087
2088         iocmd->status = BFA_STATUS_OK;
2089         return 0;
2090 }
2091
2092 int
2093 bfad_iocmd_fcpim_cfg_profile(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2094 {
2095         struct bfa_bsg_fcpim_profile_s *iocmd =
2096                                 (struct bfa_bsg_fcpim_profile_s *)cmd;
2097         unsigned long   flags;
2098
2099         spin_lock_irqsave(&bfad->bfad_lock, flags);
2100         if (v_cmd == IOCMD_FCPIM_PROFILE_ON)
2101                 iocmd->status = bfa_fcpim_profile_on(&bfad->bfa, ktime_get_real_seconds());
2102         else if (v_cmd == IOCMD_FCPIM_PROFILE_OFF)
2103                 iocmd->status = bfa_fcpim_profile_off(&bfad->bfa);
2104         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2105
2106         return 0;
2107 }
2108
2109 static int
2110 bfad_iocmd_itnim_get_ioprofile(struct bfad_s *bfad, void *cmd)
2111 {
2112         struct bfa_bsg_itnim_ioprofile_s *iocmd =
2113                                 (struct bfa_bsg_itnim_ioprofile_s *)cmd;
2114         struct bfa_fcs_lport_s *fcs_port;
2115         struct bfa_fcs_itnim_s *itnim;
2116         unsigned long   flags;
2117
2118         spin_lock_irqsave(&bfad->bfad_lock, flags);
2119         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
2120                                 iocmd->vf_id, iocmd->lpwwn);
2121         if (!fcs_port)
2122                 iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
2123         else {
2124                 itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
2125                 if (itnim == NULL)
2126                         iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
2127                 else
2128                         iocmd->status = bfa_itnim_get_ioprofile(
2129                                                 bfa_fcs_itnim_get_halitn(itnim),
2130                                                 &iocmd->ioprofile);
2131         }
2132         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2133         return 0;
2134 }
2135
2136 int
2137 bfad_iocmd_fcport_get_stats(struct bfad_s *bfad, void *cmd)
2138 {
2139         struct bfa_bsg_fcport_stats_s *iocmd =
2140                                 (struct bfa_bsg_fcport_stats_s *)cmd;
2141         struct bfad_hal_comp fcomp;
2142         unsigned long   flags;
2143         struct bfa_cb_pending_q_s cb_qe;
2144
2145         init_completion(&fcomp.comp);
2146         bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2147                            &fcomp, &iocmd->stats);
2148         spin_lock_irqsave(&bfad->bfad_lock, flags);
2149         iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2150         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2151         if (iocmd->status != BFA_STATUS_OK) {
2152                 bfa_trc(bfad, iocmd->status);
2153                 goto out;
2154         }
2155         wait_for_completion(&fcomp.comp);
2156         iocmd->status = fcomp.status;
2157 out:
2158         return 0;
2159 }
2160
2161 int
2162 bfad_iocmd_fcport_reset_stats(struct bfad_s *bfad, void *cmd)
2163 {
2164         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2165         struct bfad_hal_comp fcomp;
2166         unsigned long   flags;
2167         struct bfa_cb_pending_q_s cb_qe;
2168
2169         init_completion(&fcomp.comp);
2170         bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp, &fcomp, NULL);
2171
2172         spin_lock_irqsave(&bfad->bfad_lock, flags);
2173         iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2174         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2175         if (iocmd->status != BFA_STATUS_OK) {
2176                 bfa_trc(bfad, iocmd->status);
2177                 goto out;
2178         }
2179         wait_for_completion(&fcomp.comp);
2180         iocmd->status = fcomp.status;
2181 out:
2182         return 0;
2183 }
2184
2185 int
2186 bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
2187 {
2188         struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2189         struct bfad_hal_comp fcomp;
2190         unsigned long   flags;
2191
2192         init_completion(&fcomp.comp);
2193         spin_lock_irqsave(&bfad->bfad_lock, flags);
2194         iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2195                         BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2196                         &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2197                         bfad_hcb_comp, &fcomp);
2198         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2199         if (iocmd->status != BFA_STATUS_OK)
2200                 goto out;
2201         wait_for_completion(&fcomp.comp);
2202         iocmd->status = fcomp.status;
2203 out:
2204         return 0;
2205 }
2206
2207 int
2208 bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
2209 {
2210         struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
2211         struct bfad_hal_comp fcomp;
2212         unsigned long   flags;
2213
2214         init_completion(&fcomp.comp);
2215         spin_lock_irqsave(&bfad->bfad_lock, flags);
2216         iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2217                         BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id,
2218                         &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2219                         bfad_hcb_comp, &fcomp);
2220         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2221         if (iocmd->status != BFA_STATUS_OK)
2222                 goto out;
2223         wait_for_completion(&fcomp.comp);
2224         iocmd->status = fcomp.status;
2225 out:
2226         return 0;
2227 }
2228
2229 int
2230 bfad_iocmd_preboot_query(struct bfad_s *bfad, void *cmd)
2231 {
2232         struct bfa_bsg_preboot_s *iocmd = (struct bfa_bsg_preboot_s *)cmd;
2233         struct bfi_iocfc_cfgrsp_s *cfgrsp = bfad->bfa.iocfc.cfgrsp;
2234         struct bfa_boot_pbc_s *pbcfg = &iocmd->cfg;
2235         unsigned long   flags;
2236
2237         spin_lock_irqsave(&bfad->bfad_lock, flags);
2238         pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
2239         pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
2240         pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
2241         memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
2242         iocmd->status = BFA_STATUS_OK;
2243         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2244
2245         return 0;
2246 }
2247
2248 int
2249 bfad_iocmd_ethboot_cfg(struct bfad_s *bfad, void *cmd)
2250 {
2251         struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2252         struct bfad_hal_comp fcomp;
2253         unsigned long   flags;
2254
2255         init_completion(&fcomp.comp);
2256         spin_lock_irqsave(&bfad->bfad_lock, flags);
2257         iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2258                                 BFA_FLASH_PART_PXECFG,
2259                                 bfad->bfa.ioc.port_id, &iocmd->cfg,
2260                                 sizeof(struct bfa_ethboot_cfg_s), 0,
2261                                 bfad_hcb_comp, &fcomp);
2262         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2263         if (iocmd->status != BFA_STATUS_OK)
2264                 goto out;
2265         wait_for_completion(&fcomp.comp);
2266         iocmd->status = fcomp.status;
2267 out:
2268         return 0;
2269 }
2270
2271 int
2272 bfad_iocmd_ethboot_query(struct bfad_s *bfad, void *cmd)
2273 {
2274         struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
2275         struct bfad_hal_comp fcomp;
2276         unsigned long   flags;
2277
2278         init_completion(&fcomp.comp);
2279         spin_lock_irqsave(&bfad->bfad_lock, flags);
2280         iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2281                                 BFA_FLASH_PART_PXECFG,
2282                                 bfad->bfa.ioc.port_id, &iocmd->cfg,
2283                                 sizeof(struct bfa_ethboot_cfg_s), 0,
2284                                 bfad_hcb_comp, &fcomp);
2285         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2286         if (iocmd->status != BFA_STATUS_OK)
2287                 goto out;
2288         wait_for_completion(&fcomp.comp);
2289         iocmd->status = fcomp.status;
2290 out:
2291         return 0;
2292 }
2293
2294 int
2295 bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2296 {
2297         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2298         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2299         struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2300         unsigned long   flags;
2301
2302         spin_lock_irqsave(&bfad->bfad_lock, flags);
2303
2304         if (bfa_fcport_is_dport(&bfad->bfa)) {
2305                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2306                 return BFA_STATUS_DPORT_ERR;
2307         }
2308
2309         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2310                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2311                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2312         else {
2313                 if (v_cmd == IOCMD_TRUNK_ENABLE) {
2314                         trunk->attr.state = BFA_TRUNK_OFFLINE;
2315                         bfa_fcport_disable(&bfad->bfa);
2316                         fcport->cfg.trunked = BFA_TRUE;
2317                 } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2318                         trunk->attr.state = BFA_TRUNK_DISABLED;
2319                         bfa_fcport_disable(&bfad->bfa);
2320                         fcport->cfg.trunked = BFA_FALSE;
2321                 }
2322
2323                 if (!bfa_fcport_is_disabled(&bfad->bfa))
2324                         bfa_fcport_enable(&bfad->bfa);
2325
2326                 iocmd->status = BFA_STATUS_OK;
2327         }
2328
2329         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2330
2331         return 0;
2332 }
2333
2334 int
2335 bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
2336 {
2337         struct bfa_bsg_trunk_attr_s *iocmd = (struct bfa_bsg_trunk_attr_s *)cmd;
2338         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2339         struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2340         unsigned long   flags;
2341
2342         spin_lock_irqsave(&bfad->bfad_lock, flags);
2343         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) ||
2344                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2345                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2346         else {
2347                 memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2348                         sizeof(struct bfa_trunk_attr_s));
2349                 iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
2350                 iocmd->status = BFA_STATUS_OK;
2351         }
2352         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2353
2354         return 0;
2355 }
2356
2357 int
2358 bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2359 {
2360         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2361         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2362         unsigned long   flags;
2363
2364         spin_lock_irqsave(&bfad->bfad_lock, flags);
2365         if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
2366                 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2367                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2368                         iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2369                 else {
2370                         if (v_cmd == IOCMD_QOS_ENABLE)
2371                                 fcport->cfg.qos_enabled = BFA_TRUE;
2372                         else if (v_cmd == IOCMD_QOS_DISABLE) {
2373                                 fcport->cfg.qos_enabled = BFA_FALSE;
2374                                 fcport->cfg.qos_bw.high = BFA_QOS_BW_HIGH;
2375                                 fcport->cfg.qos_bw.med = BFA_QOS_BW_MED;
2376                                 fcport->cfg.qos_bw.low = BFA_QOS_BW_LOW;
2377                         }
2378                 }
2379         }
2380         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2381
2382         return 0;
2383 }
2384
2385 int
2386 bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
2387 {
2388         struct bfa_bsg_qos_attr_s *iocmd = (struct bfa_bsg_qos_attr_s *)cmd;
2389         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2390         unsigned long   flags;
2391
2392         spin_lock_irqsave(&bfad->bfad_lock, flags);
2393         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2394                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2395                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2396         else {
2397                 iocmd->attr.state = fcport->qos_attr.state;
2398                 iocmd->attr.total_bb_cr =
2399                         be32_to_cpu(fcport->qos_attr.total_bb_cr);
2400                 iocmd->attr.qos_bw.high = fcport->cfg.qos_bw.high;
2401                 iocmd->attr.qos_bw.med = fcport->cfg.qos_bw.med;
2402                 iocmd->attr.qos_bw.low = fcport->cfg.qos_bw.low;
2403                 iocmd->attr.qos_bw_op = fcport->qos_attr.qos_bw_op;
2404                 iocmd->status = BFA_STATUS_OK;
2405         }
2406         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2407
2408         return 0;
2409 }
2410
2411 int
2412 bfad_iocmd_qos_get_vc_attr(struct bfad_s *bfad, void *cmd)
2413 {
2414         struct bfa_bsg_qos_vc_attr_s *iocmd =
2415                                 (struct bfa_bsg_qos_vc_attr_s *)cmd;
2416         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2417         struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
2418         unsigned long   flags;
2419         u32     i = 0;
2420
2421         spin_lock_irqsave(&bfad->bfad_lock, flags);
2422         iocmd->attr.total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
2423         iocmd->attr.shared_credit  = be16_to_cpu(bfa_vc_attr->shared_credit);
2424         iocmd->attr.elp_opmode_flags  =
2425                                 be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
2426
2427         /* Individual VC info */
2428         while (i < iocmd->attr.total_vc_count) {
2429                 iocmd->attr.vc_info[i].vc_credit =
2430                                 bfa_vc_attr->vc_info[i].vc_credit;
2431                 iocmd->attr.vc_info[i].borrow_credit =
2432                                 bfa_vc_attr->vc_info[i].borrow_credit;
2433                 iocmd->attr.vc_info[i].priority =
2434                                 bfa_vc_attr->vc_info[i].priority;
2435                 i++;
2436         }
2437         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2438
2439         iocmd->status = BFA_STATUS_OK;
2440         return 0;
2441 }
2442
2443 int
2444 bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2445 {
2446         struct bfa_bsg_fcport_stats_s *iocmd =
2447                                 (struct bfa_bsg_fcport_stats_s *)cmd;
2448         struct bfad_hal_comp fcomp;
2449         unsigned long   flags;
2450         struct bfa_cb_pending_q_s cb_qe;
2451         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2452
2453         init_completion(&fcomp.comp);
2454         bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2455                            &fcomp, &iocmd->stats);
2456
2457         spin_lock_irqsave(&bfad->bfad_lock, flags);
2458         WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2459         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2460                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2461                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2462         else
2463                 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2464         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2465         if (iocmd->status != BFA_STATUS_OK) {
2466                 bfa_trc(bfad, iocmd->status);
2467                 goto out;
2468         }
2469         wait_for_completion(&fcomp.comp);
2470         iocmd->status = fcomp.status;
2471 out:
2472         return 0;
2473 }
2474
2475 int
2476 bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2477 {
2478         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
2479         struct bfad_hal_comp fcomp;
2480         unsigned long   flags;
2481         struct bfa_cb_pending_q_s cb_qe;
2482         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2483
2484         init_completion(&fcomp.comp);
2485         bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
2486                            &fcomp, NULL);
2487
2488         spin_lock_irqsave(&bfad->bfad_lock, flags);
2489         WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2490         if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
2491                 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2492                 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2493         else
2494                 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2495         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2496         if (iocmd->status != BFA_STATUS_OK) {
2497                 bfa_trc(bfad, iocmd->status);
2498                 goto out;
2499         }
2500         wait_for_completion(&fcomp.comp);
2501         iocmd->status = fcomp.status;
2502 out:
2503         return 0;
2504 }
2505
2506 int
2507 bfad_iocmd_vf_get_stats(struct bfad_s *bfad, void *cmd)
2508 {
2509         struct bfa_bsg_vf_stats_s *iocmd =
2510                         (struct bfa_bsg_vf_stats_s *)cmd;
2511         struct bfa_fcs_fabric_s *fcs_vf;
2512         unsigned long   flags;
2513
2514         spin_lock_irqsave(&bfad->bfad_lock, flags);
2515         fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2516         if (fcs_vf == NULL) {
2517                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2518                 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2519                 goto out;
2520         }
2521         memcpy((void *)&iocmd->stats, (void *)&fcs_vf->stats,
2522                 sizeof(struct bfa_vf_stats_s));
2523         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2524         iocmd->status = BFA_STATUS_OK;
2525 out:
2526         return 0;
2527 }
2528
2529 int
2530 bfad_iocmd_vf_clr_stats(struct bfad_s *bfad, void *cmd)
2531 {
2532         struct bfa_bsg_vf_reset_stats_s *iocmd =
2533                         (struct bfa_bsg_vf_reset_stats_s *)cmd;
2534         struct bfa_fcs_fabric_s *fcs_vf;
2535         unsigned long   flags;
2536
2537         spin_lock_irqsave(&bfad->bfad_lock, flags);
2538         fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
2539         if (fcs_vf == NULL) {
2540                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2541                 iocmd->status = BFA_STATUS_UNKNOWN_VFID;
2542                 goto out;
2543         }
2544         memset((void *)&fcs_vf->stats, 0, sizeof(struct bfa_vf_stats_s));
2545         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2546         iocmd->status = BFA_STATUS_OK;
2547 out:
2548         return 0;
2549 }
2550
2551 /* Function to reset the LUN SCAN mode */
2552 static void
2553 bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg)
2554 {
2555         struct bfad_im_port_s *pport_im = bfad->pport.im_port;
2556         struct bfad_vport_s *vport = NULL;
2557
2558         /* Set the scsi device LUN SCAN flags for base port */
2559         bfad_reset_sdev_bflags(pport_im, lunmask_cfg);
2560
2561         /* Set the scsi device LUN SCAN flags for the vports */
2562         list_for_each_entry(vport, &bfad->vport_list, list_entry)
2563                 bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);
2564 }
2565
2566 int
2567 bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2568 {
2569         struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
2570         unsigned long   flags;
2571
2572         spin_lock_irqsave(&bfad->bfad_lock, flags);
2573         if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE) {
2574                 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE);
2575                 /* Set the LUN Scanning mode to be Sequential scan */
2576                 if (iocmd->status == BFA_STATUS_OK)
2577                         bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_TRUE);
2578         } else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE) {
2579                 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE);
2580                 /* Set the LUN Scanning mode to default REPORT_LUNS scan */
2581                 if (iocmd->status == BFA_STATUS_OK)
2582                         bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_FALSE);
2583         } else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2584                 iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa);
2585         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2586         return 0;
2587 }
2588
2589 int
2590 bfad_iocmd_fcpim_lunmask_query(struct bfad_s *bfad, void *cmd)
2591 {
2592         struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
2593                         (struct bfa_bsg_fcpim_lunmask_query_s *)cmd;
2594         struct bfa_lunmask_cfg_s *lun_mask = &iocmd->lun_mask;
2595         unsigned long   flags;
2596
2597         spin_lock_irqsave(&bfad->bfad_lock, flags);
2598         iocmd->status = bfa_fcpim_lunmask_query(&bfad->bfa, lun_mask);
2599         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2600         return 0;
2601 }
2602
2603 int
2604 bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2605 {
2606         struct bfa_bsg_fcpim_lunmask_s *iocmd =
2607                                 (struct bfa_bsg_fcpim_lunmask_s *)cmd;
2608         unsigned long   flags;
2609
2610         spin_lock_irqsave(&bfad->bfad_lock, flags);
2611         if (v_cmd == IOCMD_FCPIM_LUNMASK_ADD)
2612                 iocmd->status = bfa_fcpim_lunmask_add(&bfad->bfa, iocmd->vf_id,
2613                                         &iocmd->pwwn, iocmd->rpwwn, iocmd->lun);
2614         else if (v_cmd == IOCMD_FCPIM_LUNMASK_DELETE)
2615                 iocmd->status = bfa_fcpim_lunmask_delete(&bfad->bfa,
2616                                         iocmd->vf_id, &iocmd->pwwn,
2617                                         iocmd->rpwwn, iocmd->lun);
2618         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2619         return 0;
2620 }
2621
2622 int
2623 bfad_iocmd_fcpim_throttle_query(struct bfad_s *bfad, void *cmd)
2624 {
2625         struct bfa_bsg_fcpim_throttle_s *iocmd =
2626                         (struct bfa_bsg_fcpim_throttle_s *)cmd;
2627         unsigned long   flags;
2628
2629         spin_lock_irqsave(&bfad->bfad_lock, flags);
2630         iocmd->status = bfa_fcpim_throttle_get(&bfad->bfa,
2631                                 (void *)&iocmd->throttle);
2632         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2633
2634         return 0;
2635 }
2636
2637 int
2638 bfad_iocmd_fcpim_throttle_set(struct bfad_s *bfad, void *cmd)
2639 {
2640         struct bfa_bsg_fcpim_throttle_s *iocmd =
2641                         (struct bfa_bsg_fcpim_throttle_s *)cmd;
2642         unsigned long   flags;
2643
2644         spin_lock_irqsave(&bfad->bfad_lock, flags);
2645         iocmd->status = bfa_fcpim_throttle_set(&bfad->bfa,
2646                                 iocmd->throttle.cfg_value);
2647         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2648
2649         return 0;
2650 }
2651
2652 int
2653 bfad_iocmd_tfru_read(struct bfad_s *bfad, void *cmd)
2654 {
2655         struct bfa_bsg_tfru_s *iocmd =
2656                         (struct bfa_bsg_tfru_s *)cmd;
2657         struct bfad_hal_comp fcomp;
2658         unsigned long flags = 0;
2659
2660         init_completion(&fcomp.comp);
2661         spin_lock_irqsave(&bfad->bfad_lock, flags);
2662         iocmd->status = bfa_tfru_read(BFA_FRU(&bfad->bfa),
2663                                 &iocmd->data, iocmd->len, iocmd->offset,
2664                                 bfad_hcb_comp, &fcomp);
2665         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2666         if (iocmd->status == BFA_STATUS_OK) {
2667                 wait_for_completion(&fcomp.comp);
2668                 iocmd->status = fcomp.status;
2669         }
2670
2671         return 0;
2672 }
2673
2674 int
2675 bfad_iocmd_tfru_write(struct bfad_s *bfad, void *cmd)
2676 {
2677         struct bfa_bsg_tfru_s *iocmd =
2678                         (struct bfa_bsg_tfru_s *)cmd;
2679         struct bfad_hal_comp fcomp;
2680         unsigned long flags = 0;
2681
2682         init_completion(&fcomp.comp);
2683         spin_lock_irqsave(&bfad->bfad_lock, flags);
2684         iocmd->status = bfa_tfru_write(BFA_FRU(&bfad->bfa),
2685                                 &iocmd->data, iocmd->len, iocmd->offset,
2686                                 bfad_hcb_comp, &fcomp);
2687         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2688         if (iocmd->status == BFA_STATUS_OK) {
2689                 wait_for_completion(&fcomp.comp);
2690                 iocmd->status = fcomp.status;
2691         }
2692
2693         return 0;
2694 }
2695
2696 int
2697 bfad_iocmd_fruvpd_read(struct bfad_s *bfad, void *cmd)
2698 {
2699         struct bfa_bsg_fruvpd_s *iocmd =
2700                         (struct bfa_bsg_fruvpd_s *)cmd;
2701         struct bfad_hal_comp fcomp;
2702         unsigned long flags = 0;
2703
2704         init_completion(&fcomp.comp);
2705         spin_lock_irqsave(&bfad->bfad_lock, flags);
2706         iocmd->status = bfa_fruvpd_read(BFA_FRU(&bfad->bfa),
2707                                 &iocmd->data, iocmd->len, iocmd->offset,
2708                                 bfad_hcb_comp, &fcomp);
2709         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2710         if (iocmd->status == BFA_STATUS_OK) {
2711                 wait_for_completion(&fcomp.comp);
2712                 iocmd->status = fcomp.status;
2713         }
2714
2715         return 0;
2716 }
2717
2718 int
2719 bfad_iocmd_fruvpd_update(struct bfad_s *bfad, void *cmd)
2720 {
2721         struct bfa_bsg_fruvpd_s *iocmd =
2722                         (struct bfa_bsg_fruvpd_s *)cmd;
2723         struct bfad_hal_comp fcomp;
2724         unsigned long flags = 0;
2725
2726         init_completion(&fcomp.comp);
2727         spin_lock_irqsave(&bfad->bfad_lock, flags);
2728         iocmd->status = bfa_fruvpd_update(BFA_FRU(&bfad->bfa),
2729                                 &iocmd->data, iocmd->len, iocmd->offset,
2730                                 bfad_hcb_comp, &fcomp, iocmd->trfr_cmpl);
2731         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2732         if (iocmd->status == BFA_STATUS_OK) {
2733                 wait_for_completion(&fcomp.comp);
2734                 iocmd->status = fcomp.status;
2735         }
2736
2737         return 0;
2738 }
2739
2740 int
2741 bfad_iocmd_fruvpd_get_max_size(struct bfad_s *bfad, void *cmd)
2742 {
2743         struct bfa_bsg_fruvpd_max_size_s *iocmd =
2744                         (struct bfa_bsg_fruvpd_max_size_s *)cmd;
2745         unsigned long flags = 0;
2746
2747         spin_lock_irqsave(&bfad->bfad_lock, flags);
2748         iocmd->status = bfa_fruvpd_get_max_size(BFA_FRU(&bfad->bfa),
2749                                                 &iocmd->max_size);
2750         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2751
2752         return 0;
2753 }
2754
2755 static int
2756 bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2757                 unsigned int payload_len)
2758 {
2759         int rc = -EINVAL;
2760
2761         switch (cmd) {
2762         case IOCMD_IOC_ENABLE:
2763                 rc = bfad_iocmd_ioc_enable(bfad, iocmd);
2764                 break;
2765         case IOCMD_IOC_DISABLE:
2766                 rc = bfad_iocmd_ioc_disable(bfad, iocmd);
2767                 break;
2768         case IOCMD_IOC_GET_INFO:
2769                 rc = bfad_iocmd_ioc_get_info(bfad, iocmd);
2770                 break;
2771         case IOCMD_IOC_GET_ATTR:
2772                 rc = bfad_iocmd_ioc_get_attr(bfad, iocmd);
2773                 break;
2774         case IOCMD_IOC_GET_STATS:
2775                 rc = bfad_iocmd_ioc_get_stats(bfad, iocmd);
2776                 break;
2777         case IOCMD_IOC_GET_FWSTATS:
2778                 rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);
2779                 break;
2780         case IOCMD_IOC_RESET_STATS:
2781         case IOCMD_IOC_RESET_FWSTATS:
2782                 rc = bfad_iocmd_ioc_reset_stats(bfad, iocmd, cmd);
2783                 break;
2784         case IOCMD_IOC_SET_ADAPTER_NAME:
2785         case IOCMD_IOC_SET_PORT_NAME:
2786                 rc = bfad_iocmd_ioc_set_name(bfad, iocmd, cmd);
2787                 break;
2788         case IOCMD_IOCFC_GET_ATTR:
2789                 rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);
2790                 break;
2791         case IOCMD_IOCFC_SET_INTR:
2792                 rc = bfad_iocmd_iocfc_set_intr(bfad, iocmd);
2793                 break;
2794         case IOCMD_PORT_ENABLE:
2795                 rc = bfad_iocmd_port_enable(bfad, iocmd);
2796                 break;
2797         case IOCMD_PORT_DISABLE:
2798                 rc = bfad_iocmd_port_disable(bfad, iocmd);
2799                 break;
2800         case IOCMD_PORT_GET_ATTR:
2801                 rc = bfad_iocmd_port_get_attr(bfad, iocmd);
2802                 break;
2803         case IOCMD_PORT_GET_STATS:
2804                 rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);
2805                 break;
2806         case IOCMD_PORT_RESET_STATS:
2807                 rc = bfad_iocmd_port_reset_stats(bfad, iocmd);
2808                 break;
2809         case IOCMD_PORT_CFG_TOPO:
2810         case IOCMD_PORT_CFG_SPEED:
2811         case IOCMD_PORT_CFG_ALPA:
2812         case IOCMD_PORT_CLR_ALPA:
2813                 rc = bfad_iocmd_set_port_cfg(bfad, iocmd, cmd);
2814                 break;
2815         case IOCMD_PORT_CFG_MAXFRSZ:
2816                 rc = bfad_iocmd_port_cfg_maxfrsize(bfad, iocmd);
2817                 break;
2818         case IOCMD_PORT_BBCR_ENABLE:
2819         case IOCMD_PORT_BBCR_DISABLE:
2820                 rc = bfad_iocmd_port_cfg_bbcr(bfad, cmd, iocmd);
2821                 break;
2822         case IOCMD_PORT_BBCR_GET_ATTR:
2823                 rc = bfad_iocmd_port_get_bbcr_attr(bfad, iocmd);
2824                 break;
2825         case IOCMD_LPORT_GET_ATTR:
2826                 rc = bfad_iocmd_lport_get_attr(bfad, iocmd);
2827                 break;
2828         case IOCMD_LPORT_GET_STATS:
2829                 rc = bfad_iocmd_lport_get_stats(bfad, iocmd);
2830                 break;
2831         case IOCMD_LPORT_RESET_STATS:
2832                 rc = bfad_iocmd_lport_reset_stats(bfad, iocmd);
2833                 break;
2834         case IOCMD_LPORT_GET_IOSTATS:
2835                 rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);
2836                 break;
2837         case IOCMD_LPORT_GET_RPORTS:
2838                 rc = bfad_iocmd_lport_get_rports(bfad, iocmd, payload_len);
2839                 break;
2840         case IOCMD_RPORT_GET_ATTR:
2841                 rc = bfad_iocmd_rport_get_attr(bfad, iocmd);
2842                 break;
2843         case IOCMD_RPORT_GET_ADDR:
2844                 rc = bfad_iocmd_rport_get_addr(bfad, iocmd);
2845                 break;
2846         case IOCMD_RPORT_GET_STATS:
2847                 rc = bfad_iocmd_rport_get_stats(bfad, iocmd);
2848                 break;
2849         case IOCMD_RPORT_RESET_STATS:
2850                 rc = bfad_iocmd_rport_clr_stats(bfad, iocmd);
2851                 break;
2852         case IOCMD_RPORT_SET_SPEED:
2853                 rc = bfad_iocmd_rport_set_speed(bfad, iocmd);
2854                 break;
2855         case IOCMD_VPORT_GET_ATTR:
2856                 rc = bfad_iocmd_vport_get_attr(bfad, iocmd);
2857                 break;
2858         case IOCMD_VPORT_GET_STATS:
2859                 rc = bfad_iocmd_vport_get_stats(bfad, iocmd);
2860                 break;
2861         case IOCMD_VPORT_RESET_STATS:
2862                 rc = bfad_iocmd_vport_clr_stats(bfad, iocmd);
2863                 break;
2864         case IOCMD_FABRIC_GET_LPORTS:
2865                 rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);
2866                 break;
2867         case IOCMD_RATELIM_ENABLE:
2868         case IOCMD_RATELIM_DISABLE:
2869                 rc = bfad_iocmd_ratelim(bfad, cmd, iocmd);
2870                 break;
2871         case IOCMD_RATELIM_DEF_SPEED:
2872                 rc = bfad_iocmd_ratelim_speed(bfad, cmd, iocmd);
2873                 break;
2874         case IOCMD_FCPIM_FAILOVER:
2875                 rc = bfad_iocmd_cfg_fcpim(bfad, iocmd);
2876                 break;
2877         case IOCMD_FCPIM_MODSTATS:
2878                 rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);
2879                 break;
2880         case IOCMD_FCPIM_MODSTATSCLR:
2881                 rc = bfad_iocmd_fcpim_clr_modstats(bfad, iocmd);
2882                 break;
2883         case IOCMD_FCPIM_DEL_ITN_STATS:
2884                 rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);
2885                 break;
2886         case IOCMD_ITNIM_GET_ATTR:
2887                 rc = bfad_iocmd_itnim_get_attr(bfad, iocmd);
2888                 break;
2889         case IOCMD_ITNIM_GET_IOSTATS:
2890                 rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);
2891                 break;
2892         case IOCMD_ITNIM_RESET_STATS:
2893                 rc = bfad_iocmd_itnim_reset_stats(bfad, iocmd);
2894                 break;
2895         case IOCMD_ITNIM_GET_ITNSTATS:
2896                 rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);
2897                 break;
2898         case IOCMD_FCPORT_ENABLE:
2899                 rc = bfad_iocmd_fcport_enable(bfad, iocmd);
2900                 break;
2901         case IOCMD_FCPORT_DISABLE:
2902                 rc = bfad_iocmd_fcport_disable(bfad, iocmd);
2903                 break;
2904         case IOCMD_IOC_PCIFN_CFG:
2905                 rc = bfad_iocmd_ioc_get_pcifn_cfg(bfad, iocmd);
2906                 break;
2907         case IOCMD_IOC_FW_SIG_INV:
2908                 rc = bfad_iocmd_ioc_fw_sig_inv(bfad, iocmd);
2909                 break;
2910         case IOCMD_PCIFN_CREATE:
2911                 rc = bfad_iocmd_pcifn_create(bfad, iocmd);
2912                 break;
2913         case IOCMD_PCIFN_DELETE:
2914                 rc = bfad_iocmd_pcifn_delete(bfad, iocmd);
2915                 break;
2916         case IOCMD_PCIFN_BW:
2917                 rc = bfad_iocmd_pcifn_bw(bfad, iocmd);
2918                 break;
2919         case IOCMD_ADAPTER_CFG_MODE:
2920                 rc = bfad_iocmd_adapter_cfg_mode(bfad, iocmd);
2921                 break;
2922         case IOCMD_PORT_CFG_MODE:
2923                 rc = bfad_iocmd_port_cfg_mode(bfad, iocmd);
2924                 break;
2925         case IOCMD_FLASH_ENABLE_OPTROM:
2926         case IOCMD_FLASH_DISABLE_OPTROM:
2927                 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd);
2928                 break;
2929         case IOCMD_FAA_QUERY:
2930                 rc = bfad_iocmd_faa_query(bfad, iocmd);
2931                 break;
2932         case IOCMD_CEE_GET_ATTR:
2933                 rc = bfad_iocmd_cee_attr(bfad, iocmd, payload_len);
2934                 break;
2935         case IOCMD_CEE_GET_STATS:
2936                 rc = bfad_iocmd_cee_get_stats(bfad, iocmd, payload_len);
2937                 break;
2938         case IOCMD_CEE_RESET_STATS:
2939                 rc = bfad_iocmd_cee_reset_stats(bfad, iocmd);
2940                 break;
2941         case IOCMD_SFP_MEDIA:
2942                 rc = bfad_iocmd_sfp_media(bfad, iocmd);
2943                  break;
2944         case IOCMD_SFP_SPEED:
2945                 rc = bfad_iocmd_sfp_speed(bfad, iocmd);
2946                 break;
2947         case IOCMD_FLASH_GET_ATTR:
2948                 rc = bfad_iocmd_flash_get_attr(bfad, iocmd);
2949                 break;
2950         case IOCMD_FLASH_ERASE_PART:
2951                 rc = bfad_iocmd_flash_erase_part(bfad, iocmd);
2952                 break;
2953         case IOCMD_FLASH_UPDATE_PART:
2954                 rc = bfad_iocmd_flash_update_part(bfad, iocmd, payload_len);
2955                 break;
2956         case IOCMD_FLASH_READ_PART:
2957                 rc = bfad_iocmd_flash_read_part(bfad, iocmd, payload_len);
2958                 break;
2959         case IOCMD_DIAG_TEMP:
2960                 rc = bfad_iocmd_diag_temp(bfad, iocmd);
2961                 break;
2962         case IOCMD_DIAG_MEMTEST:
2963                 rc = bfad_iocmd_diag_memtest(bfad, iocmd);
2964                 break;
2965         case IOCMD_DIAG_LOOPBACK:
2966                 rc = bfad_iocmd_diag_loopback(bfad, iocmd);
2967                 break;
2968         case IOCMD_DIAG_FWPING:
2969                 rc = bfad_iocmd_diag_fwping(bfad, iocmd);
2970                 break;
2971         case IOCMD_DIAG_QUEUETEST:
2972                 rc = bfad_iocmd_diag_queuetest(bfad, iocmd);
2973                 break;
2974         case IOCMD_DIAG_SFP:
2975                 rc = bfad_iocmd_diag_sfp(bfad, iocmd);
2976                 break;
2977         case IOCMD_DIAG_LED:
2978                 rc = bfad_iocmd_diag_led(bfad, iocmd);
2979                 break;
2980         case IOCMD_DIAG_BEACON_LPORT:
2981                 rc = bfad_iocmd_diag_beacon_lport(bfad, iocmd);
2982                 break;
2983         case IOCMD_DIAG_LB_STAT:
2984                 rc = bfad_iocmd_diag_lb_stat(bfad, iocmd);
2985                 break;
2986         case IOCMD_DIAG_DPORT_ENABLE:
2987                 rc = bfad_iocmd_diag_dport_enable(bfad, iocmd);
2988                 break;
2989         case IOCMD_DIAG_DPORT_DISABLE:
2990                 rc = bfad_iocmd_diag_dport_disable(bfad, iocmd);
2991                 break;
2992         case IOCMD_DIAG_DPORT_SHOW:
2993                 rc = bfad_iocmd_diag_dport_show(bfad, iocmd);
2994                 break;
2995         case IOCMD_DIAG_DPORT_START:
2996                 rc = bfad_iocmd_diag_dport_start(bfad, iocmd);
2997                 break;
2998         case IOCMD_PHY_GET_ATTR:
2999                 rc = bfad_iocmd_phy_get_attr(bfad, iocmd);
3000                 break;
3001         case IOCMD_PHY_GET_STATS:
3002                 rc = bfad_iocmd_phy_get_stats(bfad, iocmd);
3003                 break;
3004         case IOCMD_PHY_UPDATE_FW:
3005                 rc = bfad_iocmd_phy_update(bfad, iocmd, payload_len);
3006                 break;
3007         case IOCMD_PHY_READ_FW:
3008                 rc = bfad_iocmd_phy_read(bfad, iocmd, payload_len);
3009                 break;
3010         case IOCMD_VHBA_QUERY:
3011                 rc = bfad_iocmd_vhba_query(bfad, iocmd);
3012                 break;
3013         case IOCMD_DEBUG_PORTLOG:
3014                 rc = bfad_iocmd_porglog_get(bfad, iocmd);
3015                 break;
3016         case IOCMD_DEBUG_FW_CORE:
3017                 rc = bfad_iocmd_debug_fw_core(bfad, iocmd, payload_len);
3018                 break;
3019         case IOCMD_DEBUG_FW_STATE_CLR:
3020         case IOCMD_DEBUG_PORTLOG_CLR:
3021         case IOCMD_DEBUG_START_DTRC:
3022         case IOCMD_DEBUG_STOP_DTRC:
3023                 rc = bfad_iocmd_debug_ctl(bfad, iocmd, cmd);
3024                 break;
3025         case IOCMD_DEBUG_PORTLOG_CTL:
3026                 rc = bfad_iocmd_porglog_ctl(bfad, iocmd);
3027                 break;
3028         case IOCMD_FCPIM_PROFILE_ON:
3029         case IOCMD_FCPIM_PROFILE_OFF:
3030                 rc = bfad_iocmd_fcpim_cfg_profile(bfad, iocmd, cmd);
3031                 break;
3032         case IOCMD_ITNIM_GET_IOPROFILE:
3033                 rc = bfad_iocmd_itnim_get_ioprofile(bfad, iocmd);
3034                 break;
3035         case IOCMD_FCPORT_GET_STATS:
3036                 rc = bfad_iocmd_fcport_get_stats(bfad, iocmd);
3037                 break;
3038         case IOCMD_FCPORT_RESET_STATS:
3039                 rc = bfad_iocmd_fcport_reset_stats(bfad, iocmd);
3040                 break;
3041         case IOCMD_BOOT_CFG:
3042                 rc = bfad_iocmd_boot_cfg(bfad, iocmd);
3043                 break;
3044         case IOCMD_BOOT_QUERY:
3045                 rc = bfad_iocmd_boot_query(bfad, iocmd);
3046                 break;
3047         case IOCMD_PREBOOT_QUERY:
3048                 rc = bfad_iocmd_preboot_query(bfad, iocmd);
3049                 break;
3050         case IOCMD_ETHBOOT_CFG:
3051                 rc = bfad_iocmd_ethboot_cfg(bfad, iocmd);
3052                 break;
3053         case IOCMD_ETHBOOT_QUERY:
3054                 rc = bfad_iocmd_ethboot_query(bfad, iocmd);
3055                 break;
3056         case IOCMD_TRUNK_ENABLE:
3057         case IOCMD_TRUNK_DISABLE:
3058                 rc = bfad_iocmd_cfg_trunk(bfad, iocmd, cmd);
3059                 break;
3060         case IOCMD_TRUNK_GET_ATTR:
3061                 rc = bfad_iocmd_trunk_get_attr(bfad, iocmd);
3062                 break;
3063         case IOCMD_QOS_ENABLE:
3064         case IOCMD_QOS_DISABLE:
3065                 rc = bfad_iocmd_qos(bfad, iocmd, cmd);
3066                 break;
3067         case IOCMD_QOS_GET_ATTR:
3068                 rc = bfad_iocmd_qos_get_attr(bfad, iocmd);
3069                 break;
3070         case IOCMD_QOS_GET_VC_ATTR:
3071                 rc = bfad_iocmd_qos_get_vc_attr(bfad, iocmd);
3072                 break;
3073         case IOCMD_QOS_GET_STATS:
3074                 rc = bfad_iocmd_qos_get_stats(bfad, iocmd);
3075                 break;
3076         case IOCMD_QOS_RESET_STATS:
3077                 rc = bfad_iocmd_qos_reset_stats(bfad, iocmd);
3078                 break;
3079         case IOCMD_QOS_SET_BW:
3080                 rc = bfad_iocmd_qos_set_bw(bfad, iocmd);
3081                 break;
3082         case IOCMD_VF_GET_STATS:
3083                 rc = bfad_iocmd_vf_get_stats(bfad, iocmd);
3084                 break;
3085         case IOCMD_VF_RESET_STATS:
3086                 rc = bfad_iocmd_vf_clr_stats(bfad, iocmd);
3087                 break;
3088         case IOCMD_FCPIM_LUNMASK_ENABLE:
3089         case IOCMD_FCPIM_LUNMASK_DISABLE:
3090         case IOCMD_FCPIM_LUNMASK_CLEAR:
3091                 rc = bfad_iocmd_lunmask(bfad, iocmd, cmd);
3092                 break;
3093         case IOCMD_FCPIM_LUNMASK_QUERY:
3094                 rc = bfad_iocmd_fcpim_lunmask_query(bfad, iocmd);
3095                 break;
3096         case IOCMD_FCPIM_LUNMASK_ADD:
3097         case IOCMD_FCPIM_LUNMASK_DELETE:
3098                 rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd);
3099                 break;
3100         case IOCMD_FCPIM_THROTTLE_QUERY:
3101                 rc = bfad_iocmd_fcpim_throttle_query(bfad, iocmd);
3102                 break;
3103         case IOCMD_FCPIM_THROTTLE_SET:
3104                 rc = bfad_iocmd_fcpim_throttle_set(bfad, iocmd);
3105                 break;
3106         /* TFRU */
3107         case IOCMD_TFRU_READ:
3108                 rc = bfad_iocmd_tfru_read(bfad, iocmd);
3109                 break;
3110         case IOCMD_TFRU_WRITE:
3111                 rc = bfad_iocmd_tfru_write(bfad, iocmd);
3112                 break;
3113         /* FRU */
3114         case IOCMD_FRUVPD_READ:
3115                 rc = bfad_iocmd_fruvpd_read(bfad, iocmd);
3116                 break;
3117         case IOCMD_FRUVPD_UPDATE:
3118                 rc = bfad_iocmd_fruvpd_update(bfad, iocmd);
3119                 break;
3120         case IOCMD_FRUVPD_GET_MAX_SIZE:
3121                 rc = bfad_iocmd_fruvpd_get_max_size(bfad, iocmd);
3122                 break;
3123         default:
3124                 rc = -EINVAL;
3125                 break;
3126         }
3127         return rc;
3128 }
3129
3130 static int
3131 bfad_im_bsg_vendor_request(struct bsg_job *job)
3132 {
3133         struct fc_bsg_request *bsg_request = job->request;
3134         struct fc_bsg_reply *bsg_reply = job->reply;
3135         uint32_t vendor_cmd = bsg_request->rqst_data.h_vendor.vendor_cmd[0];
3136         struct Scsi_Host *shost = fc_bsg_to_shost(job);
3137         struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3138         struct bfad_s *bfad = im_port->bfad;
3139         void *payload_kbuf;
3140         int rc = -EINVAL;
3141
3142         /* Allocate a temp buffer to hold the passed in user space command */
3143         payload_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3144         if (!payload_kbuf) {
3145                 rc = -ENOMEM;
3146                 goto out;
3147         }
3148
3149         /* Copy the sg_list passed in to a linear buffer: holds the cmnd data */
3150         sg_copy_to_buffer(job->request_payload.sg_list,
3151                           job->request_payload.sg_cnt, payload_kbuf,
3152                           job->request_payload.payload_len);
3153
3154         /* Invoke IOCMD handler - to handle all the vendor command requests */
3155         rc = bfad_iocmd_handler(bfad, vendor_cmd, payload_kbuf,
3156                                 job->request_payload.payload_len);
3157         if (rc != BFA_STATUS_OK)
3158                 goto error;
3159
3160         /* Copy the response data to the job->reply_payload sg_list */
3161         sg_copy_from_buffer(job->reply_payload.sg_list,
3162                             job->reply_payload.sg_cnt,
3163                             payload_kbuf,
3164                             job->reply_payload.payload_len);
3165
3166         /* free the command buffer */
3167         kfree(payload_kbuf);
3168
3169         /* Fill the BSG job reply data */
3170         job->reply_len = job->reply_payload.payload_len;
3171         bsg_reply->reply_payload_rcv_len = job->reply_payload.payload_len;
3172         bsg_reply->result = rc;
3173
3174         bsg_job_done(job, bsg_reply->result,
3175                        bsg_reply->reply_payload_rcv_len);
3176         return rc;
3177 error:
3178         /* free the command buffer */
3179         kfree(payload_kbuf);
3180 out:
3181         bsg_reply->result = rc;
3182         job->reply_len = sizeof(uint32_t);
3183         bsg_reply->reply_payload_rcv_len = 0;
3184         return rc;
3185 }
3186
3187 /* FC passthru call backs */
3188 u64
3189 bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)
3190 {
3191         struct bfad_fcxp        *drv_fcxp = bfad_fcxp;
3192         struct bfa_sge_s  *sge;
3193         u64     addr;
3194
3195         sge = drv_fcxp->req_sge + sgeid;
3196         addr = (u64)(size_t) sge->sg_addr;
3197         return addr;
3198 }
3199
3200 u32
3201 bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)
3202 {
3203         struct bfad_fcxp        *drv_fcxp = bfad_fcxp;
3204         struct bfa_sge_s        *sge;
3205
3206         sge = drv_fcxp->req_sge + sgeid;
3207         return sge->sg_len;
3208 }
3209
3210 u64
3211 bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)
3212 {
3213         struct bfad_fcxp        *drv_fcxp = bfad_fcxp;
3214         struct bfa_sge_s        *sge;
3215         u64     addr;
3216
3217         sge = drv_fcxp->rsp_sge + sgeid;
3218         addr = (u64)(size_t) sge->sg_addr;
3219         return addr;
3220 }
3221
3222 u32
3223 bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)
3224 {
3225         struct bfad_fcxp        *drv_fcxp = bfad_fcxp;
3226         struct bfa_sge_s        *sge;
3227
3228         sge = drv_fcxp->rsp_sge + sgeid;
3229         return sge->sg_len;
3230 }
3231
3232 void
3233 bfad_send_fcpt_cb(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
3234                 bfa_status_t req_status, u32 rsp_len, u32 resid_len,
3235                 struct fchs_s *rsp_fchs)
3236 {
3237         struct bfad_fcxp *drv_fcxp = bfad_fcxp;
3238
3239         drv_fcxp->req_status = req_status;
3240         drv_fcxp->rsp_len = rsp_len;
3241
3242         /* bfa_fcxp will be automatically freed by BFA */
3243         drv_fcxp->bfa_fcxp = NULL;
3244         complete(&drv_fcxp->comp);
3245 }
3246
3247 struct bfad_buf_info *
3248 bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
3249                  uint32_t payload_len, uint32_t *num_sgles)
3250 {
3251         struct bfad_buf_info    *buf_base, *buf_info;
3252         struct bfa_sge_s        *sg_table;
3253         int sge_num = 1;
3254
3255         buf_base = kcalloc(sizeof(struct bfad_buf_info) +
3256                                 sizeof(struct bfa_sge_s),
3257                            sge_num, GFP_KERNEL);
3258         if (!buf_base)
3259                 return NULL;
3260
3261         sg_table = (struct bfa_sge_s *) (((uint8_t *)buf_base) +
3262                         (sizeof(struct bfad_buf_info) * sge_num));
3263
3264         /* Allocate dma coherent memory */
3265         buf_info = buf_base;
3266         buf_info->size = payload_len;
3267         buf_info->virt = dma_alloc_coherent(&bfad->pcidev->dev,
3268                                             buf_info->size, &buf_info->phys,
3269                                             GFP_KERNEL);
3270         if (!buf_info->virt)
3271                 goto out_free_mem;
3272
3273         /* copy the linear bsg buffer to buf_info */
3274         memcpy(buf_info->virt, payload_kbuf, buf_info->size);
3275
3276         /*
3277          * Setup SG table
3278          */
3279         sg_table->sg_len = buf_info->size;
3280         sg_table->sg_addr = (void *)(size_t) buf_info->phys;
3281
3282         *num_sgles = sge_num;
3283
3284         return buf_base;
3285
3286 out_free_mem:
3287         kfree(buf_base);
3288         return NULL;
3289 }
3290
3291 void
3292 bfad_fcxp_free_mem(struct bfad_s *bfad, struct bfad_buf_info *buf_base,
3293                    uint32_t num_sgles)
3294 {
3295         int i;
3296         struct bfad_buf_info *buf_info = buf_base;
3297
3298         if (buf_base) {
3299                 for (i = 0; i < num_sgles; buf_info++, i++) {
3300                         if (buf_info->virt != NULL)
3301                                 dma_free_coherent(&bfad->pcidev->dev,
3302                                         buf_info->size, buf_info->virt,
3303                                         buf_info->phys);
3304                 }
3305                 kfree(buf_base);
3306         }
3307 }
3308
3309 int
3310 bfad_fcxp_bsg_send(struct bsg_job *job, struct bfad_fcxp *drv_fcxp,
3311                    bfa_bsg_fcpt_t *bsg_fcpt)
3312 {
3313         struct bfa_fcxp_s *hal_fcxp;
3314         struct bfad_s   *bfad = drv_fcxp->port->bfad;
3315         unsigned long   flags;
3316         uint8_t lp_tag;
3317
3318         spin_lock_irqsave(&bfad->bfad_lock, flags);
3319
3320         /* Allocate bfa_fcxp structure */
3321         hal_fcxp = bfa_fcxp_req_rsp_alloc(drv_fcxp, &bfad->bfa,
3322                                   drv_fcxp->num_req_sgles,
3323                                   drv_fcxp->num_rsp_sgles,
3324                                   bfad_fcxp_get_req_sgaddr_cb,
3325                                   bfad_fcxp_get_req_sglen_cb,
3326                                   bfad_fcxp_get_rsp_sgaddr_cb,
3327                                   bfad_fcxp_get_rsp_sglen_cb, BFA_TRUE);
3328         if (!hal_fcxp) {
3329                 bfa_trc(bfad, 0);
3330                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3331                 return BFA_STATUS_ENOMEM;
3332         }
3333
3334         drv_fcxp->bfa_fcxp = hal_fcxp;
3335
3336         lp_tag = bfa_lps_get_tag_from_pid(&bfad->bfa, bsg_fcpt->fchs.s_id);
3337
3338         bfa_fcxp_send(hal_fcxp, drv_fcxp->bfa_rport, bsg_fcpt->vf_id, lp_tag,
3339                       bsg_fcpt->cts, bsg_fcpt->cos,
3340                       job->request_payload.payload_len,
3341                       &bsg_fcpt->fchs, bfad_send_fcpt_cb, bfad,
3342                       job->reply_payload.payload_len, bsg_fcpt->tsecs);
3343
3344         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3345
3346         return BFA_STATUS_OK;
3347 }
3348
3349 int
3350 bfad_im_bsg_els_ct_request(struct bsg_job *job)
3351 {
3352         struct bfa_bsg_data *bsg_data;
3353         struct Scsi_Host *shost = fc_bsg_to_shost(job);
3354         struct bfad_im_port_s *im_port = bfad_get_im_port(shost);
3355         struct bfad_s *bfad = im_port->bfad;
3356         bfa_bsg_fcpt_t *bsg_fcpt;
3357         struct bfad_fcxp    *drv_fcxp;
3358         struct bfa_fcs_lport_s *fcs_port;
3359         struct bfa_fcs_rport_s *fcs_rport;
3360         struct fc_bsg_request *bsg_request = job->request;
3361         struct fc_bsg_reply *bsg_reply = job->reply;
3362         uint32_t command_type = bsg_request->msgcode;
3363         unsigned long flags;
3364         struct bfad_buf_info *rsp_buf_info;
3365         void *req_kbuf = NULL, *rsp_kbuf = NULL;
3366         int rc = -EINVAL;
3367
3368         job->reply_len  = sizeof(uint32_t);     /* Atleast uint32_t reply_len */
3369         bsg_reply->reply_payload_rcv_len = 0;
3370
3371         /* Get the payload passed in from userspace */
3372         bsg_data = (struct bfa_bsg_data *) (((char *)bsg_request) +
3373                                             sizeof(struct fc_bsg_request));
3374         if (bsg_data == NULL)
3375                 goto out;
3376
3377         /*
3378          * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3379          * buffer of size bsg_data->payload_len
3380          */
3381         bsg_fcpt = kzalloc(bsg_data->payload_len, GFP_KERNEL);
3382         if (!bsg_fcpt) {
3383                 rc = -ENOMEM;
3384                 goto out;
3385         }
3386
3387         if (copy_from_user((uint8_t *)bsg_fcpt,
3388                                 (void *)(unsigned long)bsg_data->payload,
3389                                 bsg_data->payload_len)) {
3390                 kfree(bsg_fcpt);
3391                 rc = -EIO;
3392                 goto out;
3393         }
3394
3395         drv_fcxp = kzalloc(sizeof(struct bfad_fcxp), GFP_KERNEL);
3396         if (drv_fcxp == NULL) {
3397                 kfree(bsg_fcpt);
3398                 rc = -ENOMEM;
3399                 goto out;
3400         }
3401
3402         spin_lock_irqsave(&bfad->bfad_lock, flags);
3403         fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs, bsg_fcpt->vf_id,
3404                                         bsg_fcpt->lpwwn);
3405         if (fcs_port == NULL) {
3406                 bsg_fcpt->status = BFA_STATUS_UNKNOWN_LWWN;
3407                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3408                 goto out_free_mem;
3409         }
3410
3411         /* Check if the port is online before sending FC Passthru cmd */
3412         if (!bfa_fcs_lport_is_online(fcs_port)) {
3413                 bsg_fcpt->status = BFA_STATUS_PORT_OFFLINE;
3414                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3415                 goto out_free_mem;
3416         }
3417
3418         drv_fcxp->port = fcs_port->bfad_port;
3419
3420         if (drv_fcxp->port->bfad == 0)
3421                 drv_fcxp->port->bfad = bfad;
3422
3423         /* Fetch the bfa_rport - if nexus needed */
3424         if (command_type == FC_BSG_HST_ELS_NOLOGIN ||
3425             command_type == FC_BSG_HST_CT) {
3426                 /* BSG HST commands: no nexus needed */
3427                 drv_fcxp->bfa_rport = NULL;
3428
3429         } else if (command_type == FC_BSG_RPT_ELS ||
3430                    command_type == FC_BSG_RPT_CT) {
3431                 /* BSG RPT commands: nexus needed */
3432                 fcs_rport = bfa_fcs_lport_get_rport_by_pwwn(fcs_port,
3433                                                             bsg_fcpt->dpwwn);
3434                 if (fcs_rport == NULL) {
3435                         bsg_fcpt->status = BFA_STATUS_UNKNOWN_RWWN;
3436                         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3437                         goto out_free_mem;
3438                 }
3439
3440                 drv_fcxp->bfa_rport = fcs_rport->bfa_rport;
3441
3442         } else { /* Unknown BSG msgcode; return -EINVAL */
3443                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3444                 goto out_free_mem;
3445         }
3446
3447         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
3448
3449         /* allocate memory for req / rsp buffers */
3450         req_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3451         if (!req_kbuf) {
3452                 printk(KERN_INFO "bfa %s: fcpt request buffer alloc failed\n",
3453                                 bfad->pci_name);
3454                 rc = -ENOMEM;
3455                 goto out_free_mem;
3456         }
3457
3458         rsp_kbuf = kzalloc(job->reply_payload.payload_len, GFP_KERNEL);
3459         if (!rsp_kbuf) {
3460                 printk(KERN_INFO "bfa %s: fcpt response buffer alloc failed\n",
3461                                 bfad->pci_name);
3462                 rc = -ENOMEM;
3463                 goto out_free_mem;
3464         }
3465
3466         /* map req sg - copy the sg_list passed in to the linear buffer */
3467         sg_copy_to_buffer(job->request_payload.sg_list,
3468                           job->request_payload.sg_cnt, req_kbuf,
3469                           job->request_payload.payload_len);
3470
3471         drv_fcxp->reqbuf_info = bfad_fcxp_map_sg(bfad, req_kbuf,
3472                                         job->request_payload.payload_len,
3473                                         &drv_fcxp->num_req_sgles);
3474         if (!drv_fcxp->reqbuf_info) {
3475                 printk(KERN_INFO "bfa %s: fcpt request fcxp_map_sg failed\n",
3476                                 bfad->pci_name);
3477                 rc = -ENOMEM;
3478                 goto out_free_mem;
3479         }
3480
3481         drv_fcxp->req_sge = (struct bfa_sge_s *)
3482                             (((uint8_t *)drv_fcxp->reqbuf_info) +
3483                             (sizeof(struct bfad_buf_info) *
3484                                         drv_fcxp->num_req_sgles));
3485
3486         /* map rsp sg */
3487         drv_fcxp->rspbuf_info = bfad_fcxp_map_sg(bfad, rsp_kbuf,
3488                                         job->reply_payload.payload_len,
3489                                         &drv_fcxp->num_rsp_sgles);
3490         if (!drv_fcxp->rspbuf_info) {
3491                 printk(KERN_INFO "bfa %s: fcpt response fcxp_map_sg failed\n",
3492                                 bfad->pci_name);
3493                 rc = -ENOMEM;
3494                 goto out_free_mem;
3495         }
3496
3497         rsp_buf_info = (struct bfad_buf_info *)drv_fcxp->rspbuf_info;
3498         drv_fcxp->rsp_sge = (struct bfa_sge_s  *)
3499                             (((uint8_t *)drv_fcxp->rspbuf_info) +
3500                             (sizeof(struct bfad_buf_info) *
3501                                         drv_fcxp->num_rsp_sgles));
3502
3503         /* fcxp send */
3504         init_completion(&drv_fcxp->comp);
3505         rc = bfad_fcxp_bsg_send(job, drv_fcxp, bsg_fcpt);
3506         if (rc == BFA_STATUS_OK) {
3507                 wait_for_completion(&drv_fcxp->comp);
3508                 bsg_fcpt->status = drv_fcxp->req_status;
3509         } else {
3510                 bsg_fcpt->status = rc;
3511                 goto out_free_mem;
3512         }
3513
3514         /* fill the job->reply data */
3515         if (drv_fcxp->req_status == BFA_STATUS_OK) {
3516                 job->reply_len = drv_fcxp->rsp_len;
3517                 bsg_reply->reply_payload_rcv_len = drv_fcxp->rsp_len;
3518                 bsg_reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
3519         } else {
3520                 bsg_reply->reply_payload_rcv_len =
3521                                         sizeof(struct fc_bsg_ctels_reply);
3522                 job->reply_len = sizeof(uint32_t);
3523                 bsg_reply->reply_data.ctels_reply.status =
3524                                                 FC_CTELS_STATUS_REJECT;
3525         }
3526
3527         /* Copy the response data to the reply_payload sg list */
3528         sg_copy_from_buffer(job->reply_payload.sg_list,
3529                             job->reply_payload.sg_cnt,
3530                             (uint8_t *)rsp_buf_info->virt,
3531                             job->reply_payload.payload_len);
3532
3533 out_free_mem:
3534         bfad_fcxp_free_mem(bfad, drv_fcxp->rspbuf_info,
3535                            drv_fcxp->num_rsp_sgles);
3536         bfad_fcxp_free_mem(bfad, drv_fcxp->reqbuf_info,
3537                            drv_fcxp->num_req_sgles);
3538         kfree(req_kbuf);
3539         kfree(rsp_kbuf);
3540
3541         /* Need a copy to user op */
3542         if (copy_to_user((void *)(unsigned long)bsg_data->payload,
3543                         (void *)bsg_fcpt, bsg_data->payload_len))
3544                 rc = -EIO;
3545
3546         kfree(bsg_fcpt);
3547         kfree(drv_fcxp);
3548 out:
3549         bsg_reply->result = rc;
3550
3551         if (rc == BFA_STATUS_OK)
3552                 bsg_job_done(job, bsg_reply->result,
3553                                bsg_reply->reply_payload_rcv_len);
3554
3555         return rc;
3556 }
3557
3558 int
3559 bfad_im_bsg_request(struct bsg_job *job)
3560 {
3561         struct fc_bsg_request *bsg_request = job->request;
3562         struct fc_bsg_reply *bsg_reply = job->reply;
3563         uint32_t rc = BFA_STATUS_OK;
3564
3565         switch (bsg_request->msgcode) {
3566         case FC_BSG_HST_VENDOR:
3567                 /* Process BSG HST Vendor requests */
3568                 rc = bfad_im_bsg_vendor_request(job);
3569                 break;
3570         case FC_BSG_HST_ELS_NOLOGIN:
3571         case FC_BSG_RPT_ELS:
3572         case FC_BSG_HST_CT:
3573         case FC_BSG_RPT_CT:
3574                 /* Process BSG ELS/CT commands */
3575                 rc = bfad_im_bsg_els_ct_request(job);
3576                 break;
3577         default:
3578                 bsg_reply->result = rc = -EINVAL;
3579                 bsg_reply->reply_payload_rcv_len = 0;
3580                 break;
3581         }
3582
3583         return rc;
3584 }
3585
3586 int
3587 bfad_im_bsg_timeout(struct bsg_job *job)
3588 {
3589         /* Don't complete the BSG job request - return -EAGAIN
3590          * to reset bsg job timeout : for ELS/CT pass thru we
3591          * already have timer to track the request.
3592          */
3593         return -EAGAIN;
3594 }