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