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