1 /* 2 * This file is part of the Chelsio FCoE driver for Linux. 3 * 4 * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 */ 34 35 #include <linux/kernel.h> 36 #include <linux/delay.h> 37 #include <linux/slab.h> 38 #include <linux/utsname.h> 39 #include <scsi/scsi_device.h> 40 #include <scsi/scsi_transport_fc.h> 41 #include <asm/unaligned.h> 42 #include <scsi/fc/fc_els.h> 43 #include <scsi/fc/fc_fs.h> 44 #include <scsi/fc/fc_gs.h> 45 #include <scsi/fc/fc_ms.h> 46 47 #include "csio_hw.h" 48 #include "csio_mb.h" 49 #include "csio_lnode.h" 50 #include "csio_rnode.h" 51 52 int csio_fcoe_rnodes = 1024; 53 int csio_fdmi_enable = 1; 54 55 #define PORT_ID_PTR(_x) ((uint8_t *)(&_x) + 1) 56 57 /* Lnode SM declarations */ 58 static void csio_lns_uninit(struct csio_lnode *, enum csio_ln_ev); 59 static void csio_lns_online(struct csio_lnode *, enum csio_ln_ev); 60 static void csio_lns_ready(struct csio_lnode *, enum csio_ln_ev); 61 static void csio_lns_offline(struct csio_lnode *, enum csio_ln_ev); 62 63 static int csio_ln_mgmt_submit_req(struct csio_ioreq *, 64 void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *), 65 enum fcoe_cmn_type, struct csio_dma_buf *, uint32_t); 66 67 /* LN event mapping */ 68 static enum csio_ln_ev fwevt_to_lnevt[] = { 69 CSIO_LNE_NONE, /* None */ 70 CSIO_LNE_NONE, /* PLOGI_ACC_RCVD */ 71 CSIO_LNE_NONE, /* PLOGI_RJT_RCVD */ 72 CSIO_LNE_NONE, /* PLOGI_RCVD */ 73 CSIO_LNE_NONE, /* PLOGO_RCVD */ 74 CSIO_LNE_NONE, /* PRLI_ACC_RCVD */ 75 CSIO_LNE_NONE, /* PRLI_RJT_RCVD */ 76 CSIO_LNE_NONE, /* PRLI_RCVD */ 77 CSIO_LNE_NONE, /* PRLO_RCVD */ 78 CSIO_LNE_NONE, /* NPORT_ID_CHGD */ 79 CSIO_LNE_LOGO, /* FLOGO_RCVD */ 80 CSIO_LNE_LOGO, /* CLR_VIRT_LNK_RCVD */ 81 CSIO_LNE_FAB_INIT_DONE,/* FLOGI_ACC_RCVD */ 82 CSIO_LNE_NONE, /* FLOGI_RJT_RCVD */ 83 CSIO_LNE_FAB_INIT_DONE,/* FDISC_ACC_RCVD */ 84 CSIO_LNE_NONE, /* FDISC_RJT_RCVD */ 85 CSIO_LNE_NONE, /* FLOGI_TMO_MAX_RETRY */ 86 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_ACC */ 87 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_RJT */ 88 CSIO_LNE_NONE, /* IMPL_LOGO_ADISC_CNFLT */ 89 CSIO_LNE_NONE, /* PRLI_TMO */ 90 CSIO_LNE_NONE, /* ADISC_TMO */ 91 CSIO_LNE_NONE, /* RSCN_DEV_LOST */ 92 CSIO_LNE_NONE, /* SCR_ACC_RCVD */ 93 CSIO_LNE_NONE, /* ADISC_RJT_RCVD */ 94 CSIO_LNE_NONE, /* LOGO_SNT */ 95 CSIO_LNE_NONE, /* PROTO_ERR_IMPL_LOGO */ 96 }; 97 98 #define CSIO_FWE_TO_LNE(_evt) ((_evt > PROTO_ERR_IMPL_LOGO) ? \ 99 CSIO_LNE_NONE : \ 100 fwevt_to_lnevt[_evt]) 101 102 #define csio_ct_rsp(cp) (((struct fc_ct_hdr *)cp)->ct_cmd) 103 #define csio_ct_reason(cp) (((struct fc_ct_hdr *)cp)->ct_reason) 104 #define csio_ct_expl(cp) (((struct fc_ct_hdr *)cp)->ct_explan) 105 #define csio_ct_get_pld(cp) ((void *)(((uint8_t *)cp) + FC_CT_HDR_LEN)) 106 107 /* 108 * csio_ln_match_by_portid - lookup lnode using given portid. 109 * @hw: HW module 110 * @portid: port-id. 111 * 112 * If found, returns lnode matching given portid otherwise returns NULL. 113 */ 114 static struct csio_lnode * 115 csio_ln_lookup_by_portid(struct csio_hw *hw, uint8_t portid) 116 { 117 struct csio_lnode *ln = hw->rln; 118 struct list_head *tmp; 119 120 /* Match siblings lnode with portid */ 121 list_for_each(tmp, &hw->sln_head) { 122 ln = (struct csio_lnode *) tmp; 123 if (ln->portid == portid) 124 return ln; 125 } 126 127 return NULL; 128 } 129 130 /* 131 * csio_ln_lookup_by_vnpi - Lookup lnode using given vnp id. 132 * @hw - HW module 133 * @vnpi - vnp index. 134 * Returns - If found, returns lnode matching given vnp id 135 * otherwise returns NULL. 136 */ 137 static struct csio_lnode * 138 csio_ln_lookup_by_vnpi(struct csio_hw *hw, uint32_t vnp_id) 139 { 140 struct list_head *tmp1, *tmp2; 141 struct csio_lnode *sln = NULL, *cln = NULL; 142 143 if (list_empty(&hw->sln_head)) { 144 CSIO_INC_STATS(hw, n_lnlkup_miss); 145 return NULL; 146 } 147 /* Traverse sibling lnodes */ 148 list_for_each(tmp1, &hw->sln_head) { 149 sln = (struct csio_lnode *) tmp1; 150 151 /* Match sibling lnode */ 152 if (sln->vnp_flowid == vnp_id) 153 return sln; 154 155 if (list_empty(&sln->cln_head)) 156 continue; 157 158 /* Traverse children lnodes */ 159 list_for_each(tmp2, &sln->cln_head) { 160 cln = (struct csio_lnode *) tmp2; 161 162 if (cln->vnp_flowid == vnp_id) 163 return cln; 164 } 165 } 166 CSIO_INC_STATS(hw, n_lnlkup_miss); 167 return NULL; 168 } 169 170 /** 171 * csio_lnode_lookup_by_wwpn - Lookup lnode using given wwpn. 172 * @hw: HW module. 173 * @wwpn: WWPN. 174 * 175 * If found, returns lnode matching given wwpn, returns NULL otherwise. 176 */ 177 struct csio_lnode * 178 csio_lnode_lookup_by_wwpn(struct csio_hw *hw, uint8_t *wwpn) 179 { 180 struct list_head *tmp1, *tmp2; 181 struct csio_lnode *sln = NULL, *cln = NULL; 182 183 if (list_empty(&hw->sln_head)) { 184 CSIO_INC_STATS(hw, n_lnlkup_miss); 185 return NULL; 186 } 187 /* Traverse sibling lnodes */ 188 list_for_each(tmp1, &hw->sln_head) { 189 sln = (struct csio_lnode *) tmp1; 190 191 /* Match sibling lnode */ 192 if (!memcmp(csio_ln_wwpn(sln), wwpn, 8)) 193 return sln; 194 195 if (list_empty(&sln->cln_head)) 196 continue; 197 198 /* Traverse children lnodes */ 199 list_for_each(tmp2, &sln->cln_head) { 200 cln = (struct csio_lnode *) tmp2; 201 202 if (!memcmp(csio_ln_wwpn(cln), wwpn, 8)) 203 return cln; 204 } 205 } 206 return NULL; 207 } 208 209 /* FDMI */ 210 static void 211 csio_fill_ct_iu(void *buf, uint8_t type, uint8_t sub_type, uint16_t op) 212 { 213 struct fc_ct_hdr *cmd = (struct fc_ct_hdr *)buf; 214 cmd->ct_rev = FC_CT_REV; 215 cmd->ct_fs_type = type; 216 cmd->ct_fs_subtype = sub_type; 217 cmd->ct_cmd = htons(op); 218 } 219 220 static int 221 csio_hostname(uint8_t *buf, size_t buf_len) 222 { 223 if (snprintf(buf, buf_len, "%s", init_utsname()->nodename) > 0) 224 return 0; 225 return -1; 226 } 227 228 static int 229 csio_osname(uint8_t *buf, size_t buf_len) 230 { 231 if (snprintf(buf, buf_len, "%s %s %s", 232 init_utsname()->sysname, 233 init_utsname()->release, 234 init_utsname()->version) > 0) 235 return 0; 236 237 return -1; 238 } 239 240 static inline void 241 csio_append_attrib(uint8_t **ptr, uint16_t type, void *val, size_t val_len) 242 { 243 uint16_t len; 244 struct fc_fdmi_attr_entry *ae = (struct fc_fdmi_attr_entry *)*ptr; 245 246 if (WARN_ON(val_len > U16_MAX)) 247 return; 248 249 len = val_len; 250 251 ae->type = htons(type); 252 len += 4; /* includes attribute type and length */ 253 len = (len + 3) & ~3; /* should be multiple of 4 bytes */ 254 ae->len = htons(len); 255 memcpy(ae->value, val, val_len); 256 if (len > val_len) 257 memset(ae->value + val_len, 0, len - val_len); 258 *ptr += len; 259 } 260 261 /* 262 * csio_ln_fdmi_done - FDMI registeration completion 263 * @hw: HW context 264 * @fdmi_req: fdmi request 265 */ 266 static void 267 csio_ln_fdmi_done(struct csio_hw *hw, struct csio_ioreq *fdmi_req) 268 { 269 void *cmd; 270 struct csio_lnode *ln = fdmi_req->lnode; 271 272 if (fdmi_req->wr_status != FW_SUCCESS) { 273 csio_ln_dbg(ln, "WR error:%x in processing fdmi rpa cmd\n", 274 fdmi_req->wr_status); 275 CSIO_INC_STATS(ln, n_fdmi_err); 276 } 277 278 cmd = fdmi_req->dma_buf.vaddr; 279 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { 280 csio_ln_dbg(ln, "fdmi rpa cmd rejected reason %x expl %x\n", 281 csio_ct_reason(cmd), csio_ct_expl(cmd)); 282 } 283 } 284 285 /* 286 * csio_ln_fdmi_rhba_cbfn - RHBA completion 287 * @hw: HW context 288 * @fdmi_req: fdmi request 289 */ 290 static void 291 csio_ln_fdmi_rhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) 292 { 293 void *cmd; 294 uint8_t *pld; 295 uint32_t len = 0; 296 __be32 val; 297 __be16 mfs; 298 uint32_t numattrs = 0; 299 struct csio_lnode *ln = fdmi_req->lnode; 300 struct fs_fdmi_attrs *attrib_blk; 301 struct fc_fdmi_port_name *port_name; 302 uint8_t buf[64]; 303 uint8_t *fc4_type; 304 305 if (fdmi_req->wr_status != FW_SUCCESS) { 306 csio_ln_dbg(ln, "WR error:%x in processing fdmi rhba cmd\n", 307 fdmi_req->wr_status); 308 CSIO_INC_STATS(ln, n_fdmi_err); 309 } 310 311 cmd = fdmi_req->dma_buf.vaddr; 312 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { 313 csio_ln_dbg(ln, "fdmi rhba cmd rejected reason %x expl %x\n", 314 csio_ct_reason(cmd), csio_ct_expl(cmd)); 315 } 316 317 if (!csio_is_rnode_ready(fdmi_req->rnode)) { 318 CSIO_INC_STATS(ln, n_fdmi_err); 319 return; 320 } 321 322 /* Prepare CT hdr for RPA cmd */ 323 memset(cmd, 0, FC_CT_HDR_LEN); 324 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RPA); 325 326 /* Prepare RPA payload */ 327 pld = (uint8_t *)csio_ct_get_pld(cmd); 328 port_name = (struct fc_fdmi_port_name *)pld; 329 memcpy(&port_name->portname, csio_ln_wwpn(ln), 8); 330 pld += sizeof(*port_name); 331 332 /* Start appending Port attributes */ 333 attrib_blk = (struct fs_fdmi_attrs *)pld; 334 attrib_blk->numattrs = 0; 335 len += sizeof(attrib_blk->numattrs); 336 pld += sizeof(attrib_blk->numattrs); 337 338 fc4_type = &buf[0]; 339 memset(fc4_type, 0, FC_FDMI_PORT_ATTR_FC4TYPES_LEN); 340 fc4_type[2] = 1; 341 fc4_type[7] = 1; 342 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_FC4TYPES, 343 fc4_type, FC_FDMI_PORT_ATTR_FC4TYPES_LEN); 344 numattrs++; 345 val = htonl(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT); 346 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_SUPPORTEDSPEED, 347 &val, 348 FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN); 349 numattrs++; 350 351 if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_1G) 352 val = htonl(FC_PORTSPEED_1GBIT); 353 else if (hw->pport[ln->portid].link_speed == FW_PORT_CAP_SPEED_10G) 354 val = htonl(FC_PORTSPEED_10GBIT); 355 else 356 val = htonl(CSIO_HBA_PORTSPEED_UNKNOWN); 357 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED, 358 &val, FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN); 359 numattrs++; 360 361 mfs = ln->ln_sparm.csp.sp_bb_data; 362 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_MAXFRAMESIZE, 363 &mfs, sizeof(mfs)); 364 numattrs++; 365 366 strcpy(buf, "csiostor"); 367 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_OSDEVICENAME, buf, 368 strlen(buf)); 369 numattrs++; 370 371 if (!csio_hostname(buf, sizeof(buf))) { 372 csio_append_attrib(&pld, FC_FDMI_PORT_ATTR_HOSTNAME, 373 buf, strlen(buf)); 374 numattrs++; 375 } 376 attrib_blk->numattrs = htonl(numattrs); 377 len = (uint32_t)(pld - (uint8_t *)cmd); 378 379 /* Submit FDMI RPA request */ 380 spin_lock_irq(&hw->lock); 381 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_done, 382 FCOE_CT, &fdmi_req->dma_buf, len)) { 383 CSIO_INC_STATS(ln, n_fdmi_err); 384 csio_ln_dbg(ln, "Failed to issue fdmi rpa req\n"); 385 } 386 spin_unlock_irq(&hw->lock); 387 } 388 389 /* 390 * csio_ln_fdmi_dprt_cbfn - DPRT completion 391 * @hw: HW context 392 * @fdmi_req: fdmi request 393 */ 394 static void 395 csio_ln_fdmi_dprt_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) 396 { 397 void *cmd; 398 uint8_t *pld; 399 uint32_t len = 0; 400 uint32_t numattrs = 0; 401 __be32 maxpayload = htonl(65536); 402 struct fc_fdmi_hba_identifier *hbaid; 403 struct csio_lnode *ln = fdmi_req->lnode; 404 struct fc_fdmi_rpl *reg_pl; 405 struct fs_fdmi_attrs *attrib_blk; 406 uint8_t buf[64]; 407 408 if (fdmi_req->wr_status != FW_SUCCESS) { 409 csio_ln_dbg(ln, "WR error:%x in processing fdmi dprt cmd\n", 410 fdmi_req->wr_status); 411 CSIO_INC_STATS(ln, n_fdmi_err); 412 } 413 414 if (!csio_is_rnode_ready(fdmi_req->rnode)) { 415 CSIO_INC_STATS(ln, n_fdmi_err); 416 return; 417 } 418 cmd = fdmi_req->dma_buf.vaddr; 419 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { 420 csio_ln_dbg(ln, "fdmi dprt cmd rejected reason %x expl %x\n", 421 csio_ct_reason(cmd), csio_ct_expl(cmd)); 422 } 423 424 /* Prepare CT hdr for RHBA cmd */ 425 memset(cmd, 0, FC_CT_HDR_LEN); 426 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_RHBA); 427 len = FC_CT_HDR_LEN; 428 429 /* Prepare RHBA payload */ 430 pld = (uint8_t *)csio_ct_get_pld(cmd); 431 hbaid = (struct fc_fdmi_hba_identifier *)pld; 432 memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); /* HBA identifer */ 433 pld += sizeof(*hbaid); 434 435 /* Register one port per hba */ 436 reg_pl = (struct fc_fdmi_rpl *)pld; 437 reg_pl->numport = htonl(1); 438 memcpy(®_pl->port[0].portname, csio_ln_wwpn(ln), 8); 439 pld += sizeof(*reg_pl); 440 441 /* Start appending HBA attributes hba */ 442 attrib_blk = (struct fs_fdmi_attrs *)pld; 443 attrib_blk->numattrs = 0; 444 len += sizeof(attrib_blk->numattrs); 445 pld += sizeof(attrib_blk->numattrs); 446 447 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_NODENAME, csio_ln_wwnn(ln), 448 FC_FDMI_HBA_ATTR_NODENAME_LEN); 449 numattrs++; 450 451 memset(buf, 0, sizeof(buf)); 452 453 strcpy(buf, "Chelsio Communications"); 454 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MANUFACTURER, buf, 455 strlen(buf)); 456 numattrs++; 457 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_SERIALNUMBER, 458 hw->vpd.sn, sizeof(hw->vpd.sn)); 459 numattrs++; 460 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODEL, hw->vpd.id, 461 sizeof(hw->vpd.id)); 462 numattrs++; 463 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MODELDESCRIPTION, 464 hw->model_desc, strlen(hw->model_desc)); 465 numattrs++; 466 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_HARDWAREVERSION, 467 hw->hw_ver, sizeof(hw->hw_ver)); 468 numattrs++; 469 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_FIRMWAREVERSION, 470 hw->fwrev_str, strlen(hw->fwrev_str)); 471 numattrs++; 472 473 if (!csio_osname(buf, sizeof(buf))) { 474 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_OSNAMEVERSION, 475 buf, strlen(buf)); 476 numattrs++; 477 } 478 479 csio_append_attrib(&pld, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD, 480 &maxpayload, FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN); 481 len = (uint32_t)(pld - (uint8_t *)cmd); 482 numattrs++; 483 attrib_blk->numattrs = htonl(numattrs); 484 485 /* Submit FDMI RHBA request */ 486 spin_lock_irq(&hw->lock); 487 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_rhba_cbfn, 488 FCOE_CT, &fdmi_req->dma_buf, len)) { 489 CSIO_INC_STATS(ln, n_fdmi_err); 490 csio_ln_dbg(ln, "Failed to issue fdmi rhba req\n"); 491 } 492 spin_unlock_irq(&hw->lock); 493 } 494 495 /* 496 * csio_ln_fdmi_dhba_cbfn - DHBA completion 497 * @hw: HW context 498 * @fdmi_req: fdmi request 499 */ 500 static void 501 csio_ln_fdmi_dhba_cbfn(struct csio_hw *hw, struct csio_ioreq *fdmi_req) 502 { 503 struct csio_lnode *ln = fdmi_req->lnode; 504 void *cmd; 505 struct fc_fdmi_port_name *port_name; 506 uint32_t len; 507 508 if (fdmi_req->wr_status != FW_SUCCESS) { 509 csio_ln_dbg(ln, "WR error:%x in processing fdmi dhba cmd\n", 510 fdmi_req->wr_status); 511 CSIO_INC_STATS(ln, n_fdmi_err); 512 } 513 514 if (!csio_is_rnode_ready(fdmi_req->rnode)) { 515 CSIO_INC_STATS(ln, n_fdmi_err); 516 return; 517 } 518 cmd = fdmi_req->dma_buf.vaddr; 519 if (ntohs(csio_ct_rsp(cmd)) != FC_FS_ACC) { 520 csio_ln_dbg(ln, "fdmi dhba cmd rejected reason %x expl %x\n", 521 csio_ct_reason(cmd), csio_ct_expl(cmd)); 522 } 523 524 /* Send FDMI cmd to de-register any Port attributes if registered 525 * before 526 */ 527 528 /* Prepare FDMI DPRT cmd */ 529 memset(cmd, 0, FC_CT_HDR_LEN); 530 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DPRT); 531 len = FC_CT_HDR_LEN; 532 port_name = (struct fc_fdmi_port_name *)csio_ct_get_pld(cmd); 533 memcpy(&port_name->portname, csio_ln_wwpn(ln), 8); 534 len += sizeof(*port_name); 535 536 /* Submit FDMI request */ 537 spin_lock_irq(&hw->lock); 538 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dprt_cbfn, 539 FCOE_CT, &fdmi_req->dma_buf, len)) { 540 CSIO_INC_STATS(ln, n_fdmi_err); 541 csio_ln_dbg(ln, "Failed to issue fdmi dprt req\n"); 542 } 543 spin_unlock_irq(&hw->lock); 544 } 545 546 /** 547 * csio_ln_fdmi_start - Start an FDMI request. 548 * @ln: lnode 549 * @context: session context 550 * 551 * Issued with lock held. 552 */ 553 int 554 csio_ln_fdmi_start(struct csio_lnode *ln, void *context) 555 { 556 struct csio_ioreq *fdmi_req; 557 struct csio_rnode *fdmi_rn = (struct csio_rnode *)context; 558 void *cmd; 559 struct fc_fdmi_hba_identifier *hbaid; 560 uint32_t len; 561 562 if (!(ln->flags & CSIO_LNF_FDMI_ENABLE)) 563 return -EPROTONOSUPPORT; 564 565 if (!csio_is_rnode_ready(fdmi_rn)) 566 CSIO_INC_STATS(ln, n_fdmi_err); 567 568 /* Send FDMI cmd to de-register any HBA attributes if registered 569 * before 570 */ 571 572 fdmi_req = ln->mgmt_req; 573 fdmi_req->lnode = ln; 574 fdmi_req->rnode = fdmi_rn; 575 576 /* Prepare FDMI DHBA cmd */ 577 cmd = fdmi_req->dma_buf.vaddr; 578 memset(cmd, 0, FC_CT_HDR_LEN); 579 csio_fill_ct_iu(cmd, FC_FST_MGMT, FC_FDMI_SUBTYPE, FC_FDMI_DHBA); 580 len = FC_CT_HDR_LEN; 581 582 hbaid = (struct fc_fdmi_hba_identifier *)csio_ct_get_pld(cmd); 583 memcpy(&hbaid->id, csio_ln_wwpn(ln), 8); 584 len += sizeof(*hbaid); 585 586 /* Submit FDMI request */ 587 if (csio_ln_mgmt_submit_req(fdmi_req, csio_ln_fdmi_dhba_cbfn, 588 FCOE_CT, &fdmi_req->dma_buf, len)) { 589 CSIO_INC_STATS(ln, n_fdmi_err); 590 csio_ln_dbg(ln, "Failed to issue fdmi dhba req\n"); 591 } 592 593 return 0; 594 } 595 596 /* 597 * csio_ln_vnp_read_cbfn - vnp read completion handler. 598 * @hw: HW lnode 599 * @cbfn: Completion handler. 600 * 601 * Reads vnp response and updates ln parameters. 602 */ 603 static void 604 csio_ln_vnp_read_cbfn(struct csio_hw *hw, struct csio_mb *mbp) 605 { 606 struct csio_lnode *ln = ((struct csio_lnode *)mbp->priv); 607 struct fw_fcoe_vnp_cmd *rsp = (struct fw_fcoe_vnp_cmd *)(mbp->mb); 608 struct fc_els_csp *csp; 609 struct fc_els_cssp *clsp; 610 enum fw_retval retval; 611 __be32 nport_id; 612 613 retval = FW_CMD_RETVAL_G(ntohl(rsp->alloc_to_len16)); 614 if (retval != FW_SUCCESS) { 615 csio_err(hw, "FCOE VNP read cmd returned error:0x%x\n", retval); 616 mempool_free(mbp, hw->mb_mempool); 617 return; 618 } 619 620 spin_lock_irq(&hw->lock); 621 622 memcpy(ln->mac, rsp->vnport_mac, sizeof(ln->mac)); 623 memcpy(&nport_id, &rsp->vnport_mac[3], sizeof(uint8_t)*3); 624 ln->nport_id = ntohl(nport_id); 625 ln->nport_id = ln->nport_id >> 8; 626 627 /* Update WWNs */ 628 /* 629 * This may look like a duplication of what csio_fcoe_enable_link() 630 * does, but is absolutely necessary if the vnpi changes between 631 * a FCOE LINK UP and FCOE LINK DOWN. 632 */ 633 memcpy(csio_ln_wwnn(ln), rsp->vnport_wwnn, 8); 634 memcpy(csio_ln_wwpn(ln), rsp->vnport_wwpn, 8); 635 636 /* Copy common sparam */ 637 csp = (struct fc_els_csp *)rsp->cmn_srv_parms; 638 ln->ln_sparm.csp.sp_hi_ver = csp->sp_hi_ver; 639 ln->ln_sparm.csp.sp_lo_ver = csp->sp_lo_ver; 640 ln->ln_sparm.csp.sp_bb_cred = csp->sp_bb_cred; 641 ln->ln_sparm.csp.sp_features = csp->sp_features; 642 ln->ln_sparm.csp.sp_bb_data = csp->sp_bb_data; 643 ln->ln_sparm.csp.sp_r_a_tov = csp->sp_r_a_tov; 644 ln->ln_sparm.csp.sp_e_d_tov = csp->sp_e_d_tov; 645 646 /* Copy word 0 & word 1 of class sparam */ 647 clsp = (struct fc_els_cssp *)rsp->clsp_word_0_1; 648 ln->ln_sparm.clsp[2].cp_class = clsp->cp_class; 649 ln->ln_sparm.clsp[2].cp_init = clsp->cp_init; 650 ln->ln_sparm.clsp[2].cp_recip = clsp->cp_recip; 651 ln->ln_sparm.clsp[2].cp_rdfs = clsp->cp_rdfs; 652 653 spin_unlock_irq(&hw->lock); 654 655 mempool_free(mbp, hw->mb_mempool); 656 657 /* Send an event to update local attribs */ 658 csio_lnode_async_event(ln, CSIO_LN_FC_ATTRIB_UPDATE); 659 } 660 661 /* 662 * csio_ln_vnp_read - Read vnp params. 663 * @ln: lnode 664 * @cbfn: Completion handler. 665 * 666 * Issued with lock held. 667 */ 668 static int 669 csio_ln_vnp_read(struct csio_lnode *ln, 670 void (*cbfn) (struct csio_hw *, struct csio_mb *)) 671 { 672 struct csio_hw *hw = ln->hwp; 673 struct csio_mb *mbp; 674 675 /* Allocate Mbox request */ 676 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); 677 if (!mbp) { 678 CSIO_INC_STATS(hw, n_err_nomem); 679 return -ENOMEM; 680 } 681 682 /* Prepare VNP Command */ 683 csio_fcoe_vnp_read_init_mb(ln, mbp, 684 CSIO_MB_DEFAULT_TMO, 685 ln->fcf_flowid, 686 ln->vnp_flowid, 687 cbfn); 688 689 /* Issue MBOX cmd */ 690 if (csio_mb_issue(hw, mbp)) { 691 csio_err(hw, "Failed to issue mbox FCoE VNP command\n"); 692 mempool_free(mbp, hw->mb_mempool); 693 return -EINVAL; 694 } 695 696 return 0; 697 } 698 699 /* 700 * csio_fcoe_enable_link - Enable fcoe link. 701 * @ln: lnode 702 * @enable: enable/disable 703 * Issued with lock held. 704 * Issues mbox cmd to bring up FCOE link on port associated with given ln. 705 */ 706 static int 707 csio_fcoe_enable_link(struct csio_lnode *ln, bool enable) 708 { 709 struct csio_hw *hw = ln->hwp; 710 struct csio_mb *mbp; 711 enum fw_retval retval; 712 uint8_t portid; 713 uint8_t sub_op; 714 struct fw_fcoe_link_cmd *lcmd; 715 int i; 716 717 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); 718 if (!mbp) { 719 CSIO_INC_STATS(hw, n_err_nomem); 720 return -ENOMEM; 721 } 722 723 portid = ln->portid; 724 sub_op = enable ? FCOE_LINK_UP : FCOE_LINK_DOWN; 725 726 csio_dbg(hw, "bringing FCOE LINK %s on Port:%d\n", 727 sub_op ? "UP" : "DOWN", portid); 728 729 csio_write_fcoe_link_cond_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO, 730 portid, sub_op, 0, 0, 0, NULL); 731 732 if (csio_mb_issue(hw, mbp)) { 733 csio_err(hw, "failed to issue FCOE LINK cmd on port[%d]\n", 734 portid); 735 mempool_free(mbp, hw->mb_mempool); 736 return -EINVAL; 737 } 738 739 retval = csio_mb_fw_retval(mbp); 740 if (retval != FW_SUCCESS) { 741 csio_err(hw, 742 "FCOE LINK %s cmd on port[%d] failed with " 743 "ret:x%x\n", sub_op ? "UP" : "DOWN", portid, retval); 744 mempool_free(mbp, hw->mb_mempool); 745 return -EINVAL; 746 } 747 748 if (!enable) 749 goto out; 750 751 lcmd = (struct fw_fcoe_link_cmd *)mbp->mb; 752 753 memcpy(csio_ln_wwnn(ln), lcmd->vnport_wwnn, 8); 754 memcpy(csio_ln_wwpn(ln), lcmd->vnport_wwpn, 8); 755 756 for (i = 0; i < CSIO_MAX_PPORTS; i++) 757 if (hw->pport[i].portid == portid) 758 memcpy(hw->pport[i].mac, lcmd->phy_mac, 6); 759 760 out: 761 mempool_free(mbp, hw->mb_mempool); 762 return 0; 763 } 764 765 /* 766 * csio_ln_read_fcf_cbfn - Read fcf parameters 767 * @ln: lnode 768 * 769 * read fcf response and Update ln fcf information. 770 */ 771 static void 772 csio_ln_read_fcf_cbfn(struct csio_hw *hw, struct csio_mb *mbp) 773 { 774 struct csio_lnode *ln = (struct csio_lnode *)mbp->priv; 775 struct csio_fcf_info *fcf_info; 776 struct fw_fcoe_fcf_cmd *rsp = 777 (struct fw_fcoe_fcf_cmd *)(mbp->mb); 778 enum fw_retval retval; 779 780 retval = FW_CMD_RETVAL_G(ntohl(rsp->retval_len16)); 781 if (retval != FW_SUCCESS) { 782 csio_ln_err(ln, "FCOE FCF cmd failed with ret x%x\n", 783 retval); 784 mempool_free(mbp, hw->mb_mempool); 785 return; 786 } 787 788 spin_lock_irq(&hw->lock); 789 fcf_info = ln->fcfinfo; 790 fcf_info->priority = FW_FCOE_FCF_CMD_PRIORITY_GET( 791 ntohs(rsp->priority_pkd)); 792 fcf_info->vf_id = ntohs(rsp->vf_id); 793 fcf_info->vlan_id = rsp->vlan_id; 794 fcf_info->max_fcoe_size = ntohs(rsp->max_fcoe_size); 795 fcf_info->fka_adv = be32_to_cpu(rsp->fka_adv); 796 fcf_info->fcfi = FW_FCOE_FCF_CMD_FCFI_GET(ntohl(rsp->op_to_fcfi)); 797 fcf_info->fpma = FW_FCOE_FCF_CMD_FPMA_GET(rsp->fpma_to_portid); 798 fcf_info->spma = FW_FCOE_FCF_CMD_SPMA_GET(rsp->fpma_to_portid); 799 fcf_info->login = FW_FCOE_FCF_CMD_LOGIN_GET(rsp->fpma_to_portid); 800 fcf_info->portid = FW_FCOE_FCF_CMD_PORTID_GET(rsp->fpma_to_portid); 801 memcpy(fcf_info->fc_map, rsp->fc_map, sizeof(fcf_info->fc_map)); 802 memcpy(fcf_info->mac, rsp->mac, sizeof(fcf_info->mac)); 803 memcpy(fcf_info->name_id, rsp->name_id, sizeof(fcf_info->name_id)); 804 memcpy(fcf_info->fabric, rsp->fabric, sizeof(fcf_info->fabric)); 805 memcpy(fcf_info->spma_mac, rsp->spma_mac, sizeof(fcf_info->spma_mac)); 806 807 spin_unlock_irq(&hw->lock); 808 809 mempool_free(mbp, hw->mb_mempool); 810 } 811 812 /* 813 * csio_ln_read_fcf_entry - Read fcf entry. 814 * @ln: lnode 815 * @cbfn: Completion handler. 816 * 817 * Issued with lock held. 818 */ 819 static int 820 csio_ln_read_fcf_entry(struct csio_lnode *ln, 821 void (*cbfn) (struct csio_hw *, struct csio_mb *)) 822 { 823 struct csio_hw *hw = ln->hwp; 824 struct csio_mb *mbp; 825 826 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); 827 if (!mbp) { 828 CSIO_INC_STATS(hw, n_err_nomem); 829 return -ENOMEM; 830 } 831 832 /* Get FCoE FCF information */ 833 csio_fcoe_read_fcf_init_mb(ln, mbp, CSIO_MB_DEFAULT_TMO, 834 ln->portid, ln->fcf_flowid, cbfn); 835 836 if (csio_mb_issue(hw, mbp)) { 837 csio_err(hw, "failed to issue FCOE FCF cmd\n"); 838 mempool_free(mbp, hw->mb_mempool); 839 return -EINVAL; 840 } 841 842 return 0; 843 } 844 845 /* 846 * csio_handle_link_up - Logical Linkup event. 847 * @hw - HW module. 848 * @portid - Physical port number 849 * @fcfi - FCF index. 850 * @vnpi - VNP index. 851 * Returns - none. 852 * 853 * This event is received from FW, when virtual link is established between 854 * Physical port[ENode] and FCF. If its new vnpi, then local node object is 855 * created on this FCF and set to [ONLINE] state. 856 * Lnode waits for FW_RDEV_CMD event to be received indicating that 857 * Fabric login is completed and lnode moves to [READY] state. 858 * 859 * This called with hw lock held 860 */ 861 static void 862 csio_handle_link_up(struct csio_hw *hw, uint8_t portid, uint32_t fcfi, 863 uint32_t vnpi) 864 { 865 struct csio_lnode *ln = NULL; 866 867 /* Lookup lnode based on vnpi */ 868 ln = csio_ln_lookup_by_vnpi(hw, vnpi); 869 if (!ln) { 870 /* Pick lnode based on portid */ 871 ln = csio_ln_lookup_by_portid(hw, portid); 872 if (!ln) { 873 csio_err(hw, "failed to lookup fcoe lnode on port:%d\n", 874 portid); 875 CSIO_DB_ASSERT(0); 876 return; 877 } 878 879 /* Check if lnode has valid vnp flowid */ 880 if (ln->vnp_flowid != CSIO_INVALID_IDX) { 881 /* New VN-Port */ 882 spin_unlock_irq(&hw->lock); 883 csio_lnode_alloc(hw); 884 spin_lock_irq(&hw->lock); 885 if (!ln) { 886 csio_err(hw, 887 "failed to allocate fcoe lnode" 888 "for port:%d vnpi:x%x\n", 889 portid, vnpi); 890 CSIO_DB_ASSERT(0); 891 return; 892 } 893 ln->portid = portid; 894 } 895 ln->vnp_flowid = vnpi; 896 ln->dev_num &= ~0xFFFF; 897 ln->dev_num |= vnpi; 898 } 899 900 /*Initialize fcfi */ 901 ln->fcf_flowid = fcfi; 902 903 csio_info(hw, "Port:%d - FCOE LINK UP\n", portid); 904 905 CSIO_INC_STATS(ln, n_link_up); 906 907 /* Send LINKUP event to SM */ 908 csio_post_event(&ln->sm, CSIO_LNE_LINKUP); 909 } 910 911 /* 912 * csio_post_event_rns 913 * @ln - FCOE lnode 914 * @evt - Given rnode event 915 * Returns - none 916 * 917 * Posts given rnode event to all FCOE rnodes connected with given Lnode. 918 * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE 919 * event. 920 * 921 * This called with hw lock held 922 */ 923 static void 924 csio_post_event_rns(struct csio_lnode *ln, enum csio_rn_ev evt) 925 { 926 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead; 927 struct list_head *tmp, *next; 928 struct csio_rnode *rn; 929 930 list_for_each_safe(tmp, next, &rnhead->sm.sm_list) { 931 rn = (struct csio_rnode *) tmp; 932 csio_post_event(&rn->sm, evt); 933 } 934 } 935 936 /* 937 * csio_cleanup_rns 938 * @ln - FCOE lnode 939 * Returns - none 940 * 941 * Frees all FCOE rnodes connected with given Lnode. 942 * 943 * This called with hw lock held 944 */ 945 static void 946 csio_cleanup_rns(struct csio_lnode *ln) 947 { 948 struct csio_rnode *rnhead = (struct csio_rnode *) &ln->rnhead; 949 struct list_head *tmp, *next_rn; 950 struct csio_rnode *rn; 951 952 list_for_each_safe(tmp, next_rn, &rnhead->sm.sm_list) { 953 rn = (struct csio_rnode *) tmp; 954 csio_put_rnode(ln, rn); 955 } 956 957 } 958 959 /* 960 * csio_post_event_lns 961 * @ln - FCOE lnode 962 * @evt - Given lnode event 963 * Returns - none 964 * 965 * Posts given lnode event to all FCOE lnodes connected with given Lnode. 966 * This routine is invoked when lnode receives LINK_DOWN/DOWN_LINK/CLOSE 967 * event. 968 * 969 * This called with hw lock held 970 */ 971 static void 972 csio_post_event_lns(struct csio_lnode *ln, enum csio_ln_ev evt) 973 { 974 struct list_head *tmp; 975 struct csio_lnode *cln, *sln; 976 977 /* If NPIV lnode, send evt only to that and return */ 978 if (csio_is_npiv_ln(ln)) { 979 csio_post_event(&ln->sm, evt); 980 return; 981 } 982 983 sln = ln; 984 /* Traverse children lnodes list and send evt */ 985 list_for_each(tmp, &sln->cln_head) { 986 cln = (struct csio_lnode *) tmp; 987 csio_post_event(&cln->sm, evt); 988 } 989 990 /* Send evt to parent lnode */ 991 csio_post_event(&ln->sm, evt); 992 } 993 994 /* 995 * csio_ln_down - Lcoal nport is down 996 * @ln - FCOE Lnode 997 * Returns - none 998 * 999 * Sends LINK_DOWN events to Lnode and its associated NPIVs lnodes. 1000 * 1001 * This called with hw lock held 1002 */ 1003 static void 1004 csio_ln_down(struct csio_lnode *ln) 1005 { 1006 csio_post_event_lns(ln, CSIO_LNE_LINK_DOWN); 1007 } 1008 1009 /* 1010 * csio_handle_link_down - Logical Linkdown event. 1011 * @hw - HW module. 1012 * @portid - Physical port number 1013 * @fcfi - FCF index. 1014 * @vnpi - VNP index. 1015 * Returns - none 1016 * 1017 * This event is received from FW, when virtual link goes down between 1018 * Physical port[ENode] and FCF. Lnode and its associated NPIVs lnode hosted on 1019 * this vnpi[VN-Port] will be de-instantiated. 1020 * 1021 * This called with hw lock held 1022 */ 1023 static void 1024 csio_handle_link_down(struct csio_hw *hw, uint8_t portid, uint32_t fcfi, 1025 uint32_t vnpi) 1026 { 1027 struct csio_fcf_info *fp; 1028 struct csio_lnode *ln; 1029 1030 /* Lookup lnode based on vnpi */ 1031 ln = csio_ln_lookup_by_vnpi(hw, vnpi); 1032 if (ln) { 1033 fp = ln->fcfinfo; 1034 CSIO_INC_STATS(ln, n_link_down); 1035 1036 /*Warn if linkdown received if lnode is not in ready state */ 1037 if (!csio_is_lnode_ready(ln)) { 1038 csio_ln_warn(ln, 1039 "warn: FCOE link is already in offline " 1040 "Ignoring Fcoe linkdown event on portid %d\n", 1041 portid); 1042 CSIO_INC_STATS(ln, n_evt_drop); 1043 return; 1044 } 1045 1046 /* Verify portid */ 1047 if (fp->portid != portid) { 1048 csio_ln_warn(ln, 1049 "warn: FCOE linkdown recv with " 1050 "invalid port %d\n", portid); 1051 CSIO_INC_STATS(ln, n_evt_drop); 1052 return; 1053 } 1054 1055 /* verify fcfi */ 1056 if (ln->fcf_flowid != fcfi) { 1057 csio_ln_warn(ln, 1058 "warn: FCOE linkdown recv with " 1059 "invalid fcfi x%x\n", fcfi); 1060 CSIO_INC_STATS(ln, n_evt_drop); 1061 return; 1062 } 1063 1064 csio_info(hw, "Port:%d - FCOE LINK DOWN\n", portid); 1065 1066 /* Send LINK_DOWN event to lnode s/m */ 1067 csio_ln_down(ln); 1068 1069 return; 1070 } else { 1071 csio_warn(hw, 1072 "warn: FCOE linkdown recv with invalid vnpi x%x\n", 1073 vnpi); 1074 CSIO_INC_STATS(hw, n_evt_drop); 1075 } 1076 } 1077 1078 /* 1079 * csio_is_lnode_ready - Checks FCOE lnode is in ready state. 1080 * @ln: Lnode module 1081 * 1082 * Returns True if FCOE lnode is in ready state. 1083 */ 1084 int 1085 csio_is_lnode_ready(struct csio_lnode *ln) 1086 { 1087 return (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)); 1088 } 1089 1090 /*****************************************************************************/ 1091 /* START: Lnode SM */ 1092 /*****************************************************************************/ 1093 /* 1094 * csio_lns_uninit - The request in uninit state. 1095 * @ln - FCOE lnode. 1096 * @evt - Event to be processed. 1097 * 1098 * Process the given lnode event which is currently in "uninit" state. 1099 * Invoked with HW lock held. 1100 * Return - none. 1101 */ 1102 static void 1103 csio_lns_uninit(struct csio_lnode *ln, enum csio_ln_ev evt) 1104 { 1105 struct csio_hw *hw = csio_lnode_to_hw(ln); 1106 struct csio_lnode *rln = hw->rln; 1107 int rv; 1108 1109 CSIO_INC_STATS(ln, n_evt_sm[evt]); 1110 switch (evt) { 1111 case CSIO_LNE_LINKUP: 1112 csio_set_state(&ln->sm, csio_lns_online); 1113 /* Read FCF only for physical lnode */ 1114 if (csio_is_phys_ln(ln)) { 1115 rv = csio_ln_read_fcf_entry(ln, 1116 csio_ln_read_fcf_cbfn); 1117 if (rv != 0) { 1118 /* TODO: Send HW RESET event */ 1119 CSIO_INC_STATS(ln, n_err); 1120 break; 1121 } 1122 1123 /* Add FCF record */ 1124 list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead); 1125 } 1126 1127 rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn); 1128 if (rv != 0) { 1129 /* TODO: Send HW RESET event */ 1130 CSIO_INC_STATS(ln, n_err); 1131 } 1132 break; 1133 1134 case CSIO_LNE_DOWN_LINK: 1135 break; 1136 1137 default: 1138 csio_ln_dbg(ln, 1139 "unexp ln event %d recv from did:x%x in " 1140 "ln state[uninit].\n", evt, ln->nport_id); 1141 CSIO_INC_STATS(ln, n_evt_unexp); 1142 break; 1143 } /* switch event */ 1144 } 1145 1146 /* 1147 * csio_lns_online - The request in online state. 1148 * @ln - FCOE lnode. 1149 * @evt - Event to be processed. 1150 * 1151 * Process the given lnode event which is currently in "online" state. 1152 * Invoked with HW lock held. 1153 * Return - none. 1154 */ 1155 static void 1156 csio_lns_online(struct csio_lnode *ln, enum csio_ln_ev evt) 1157 { 1158 struct csio_hw *hw = csio_lnode_to_hw(ln); 1159 1160 CSIO_INC_STATS(ln, n_evt_sm[evt]); 1161 switch (evt) { 1162 case CSIO_LNE_LINKUP: 1163 csio_ln_warn(ln, 1164 "warn: FCOE link is up already " 1165 "Ignoring linkup on port:%d\n", ln->portid); 1166 CSIO_INC_STATS(ln, n_evt_drop); 1167 break; 1168 1169 case CSIO_LNE_FAB_INIT_DONE: 1170 csio_set_state(&ln->sm, csio_lns_ready); 1171 1172 spin_unlock_irq(&hw->lock); 1173 csio_lnode_async_event(ln, CSIO_LN_FC_LINKUP); 1174 spin_lock_irq(&hw->lock); 1175 1176 break; 1177 1178 case CSIO_LNE_LINK_DOWN: 1179 /* Fall through */ 1180 case CSIO_LNE_DOWN_LINK: 1181 csio_set_state(&ln->sm, csio_lns_uninit); 1182 if (csio_is_phys_ln(ln)) { 1183 /* Remove FCF entry */ 1184 list_del_init(&ln->fcfinfo->list); 1185 } 1186 break; 1187 1188 default: 1189 csio_ln_dbg(ln, 1190 "unexp ln event %d recv from did:x%x in " 1191 "ln state[uninit].\n", evt, ln->nport_id); 1192 CSIO_INC_STATS(ln, n_evt_unexp); 1193 1194 break; 1195 } /* switch event */ 1196 } 1197 1198 /* 1199 * csio_lns_ready - The request in ready state. 1200 * @ln - FCOE lnode. 1201 * @evt - Event to be processed. 1202 * 1203 * Process the given lnode event which is currently in "ready" state. 1204 * Invoked with HW lock held. 1205 * Return - none. 1206 */ 1207 static void 1208 csio_lns_ready(struct csio_lnode *ln, enum csio_ln_ev evt) 1209 { 1210 struct csio_hw *hw = csio_lnode_to_hw(ln); 1211 1212 CSIO_INC_STATS(ln, n_evt_sm[evt]); 1213 switch (evt) { 1214 case CSIO_LNE_FAB_INIT_DONE: 1215 csio_ln_dbg(ln, 1216 "ignoring event %d recv from did x%x" 1217 "in ln state[ready].\n", evt, ln->nport_id); 1218 CSIO_INC_STATS(ln, n_evt_drop); 1219 break; 1220 1221 case CSIO_LNE_LINK_DOWN: 1222 csio_set_state(&ln->sm, csio_lns_offline); 1223 csio_post_event_rns(ln, CSIO_RNFE_DOWN); 1224 1225 spin_unlock_irq(&hw->lock); 1226 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN); 1227 spin_lock_irq(&hw->lock); 1228 1229 if (csio_is_phys_ln(ln)) { 1230 /* Remove FCF entry */ 1231 list_del_init(&ln->fcfinfo->list); 1232 } 1233 break; 1234 1235 case CSIO_LNE_DOWN_LINK: 1236 csio_set_state(&ln->sm, csio_lns_offline); 1237 csio_post_event_rns(ln, CSIO_RNFE_DOWN); 1238 1239 /* Host need to issue aborts in case if FW has not returned 1240 * WRs with status "ABORTED" 1241 */ 1242 spin_unlock_irq(&hw->lock); 1243 csio_lnode_async_event(ln, CSIO_LN_FC_LINKDOWN); 1244 spin_lock_irq(&hw->lock); 1245 1246 if (csio_is_phys_ln(ln)) { 1247 /* Remove FCF entry */ 1248 list_del_init(&ln->fcfinfo->list); 1249 } 1250 break; 1251 1252 case CSIO_LNE_CLOSE: 1253 csio_set_state(&ln->sm, csio_lns_uninit); 1254 csio_post_event_rns(ln, CSIO_RNFE_CLOSE); 1255 break; 1256 1257 case CSIO_LNE_LOGO: 1258 csio_set_state(&ln->sm, csio_lns_offline); 1259 csio_post_event_rns(ln, CSIO_RNFE_DOWN); 1260 break; 1261 1262 default: 1263 csio_ln_dbg(ln, 1264 "unexp ln event %d recv from did:x%x in " 1265 "ln state[uninit].\n", evt, ln->nport_id); 1266 CSIO_INC_STATS(ln, n_evt_unexp); 1267 CSIO_DB_ASSERT(0); 1268 break; 1269 } /* switch event */ 1270 } 1271 1272 /* 1273 * csio_lns_offline - The request in offline state. 1274 * @ln - FCOE lnode. 1275 * @evt - Event to be processed. 1276 * 1277 * Process the given lnode event which is currently in "offline" state. 1278 * Invoked with HW lock held. 1279 * Return - none. 1280 */ 1281 static void 1282 csio_lns_offline(struct csio_lnode *ln, enum csio_ln_ev evt) 1283 { 1284 struct csio_hw *hw = csio_lnode_to_hw(ln); 1285 struct csio_lnode *rln = hw->rln; 1286 int rv; 1287 1288 CSIO_INC_STATS(ln, n_evt_sm[evt]); 1289 switch (evt) { 1290 case CSIO_LNE_LINKUP: 1291 csio_set_state(&ln->sm, csio_lns_online); 1292 /* Read FCF only for physical lnode */ 1293 if (csio_is_phys_ln(ln)) { 1294 rv = csio_ln_read_fcf_entry(ln, 1295 csio_ln_read_fcf_cbfn); 1296 if (rv != 0) { 1297 /* TODO: Send HW RESET event */ 1298 CSIO_INC_STATS(ln, n_err); 1299 break; 1300 } 1301 1302 /* Add FCF record */ 1303 list_add_tail(&ln->fcfinfo->list, &rln->fcf_lsthead); 1304 } 1305 1306 rv = csio_ln_vnp_read(ln, csio_ln_vnp_read_cbfn); 1307 if (rv != 0) { 1308 /* TODO: Send HW RESET event */ 1309 CSIO_INC_STATS(ln, n_err); 1310 } 1311 break; 1312 1313 case CSIO_LNE_LINK_DOWN: 1314 case CSIO_LNE_DOWN_LINK: 1315 case CSIO_LNE_LOGO: 1316 csio_ln_dbg(ln, 1317 "ignoring event %d recv from did x%x" 1318 "in ln state[offline].\n", evt, ln->nport_id); 1319 CSIO_INC_STATS(ln, n_evt_drop); 1320 break; 1321 1322 case CSIO_LNE_CLOSE: 1323 csio_set_state(&ln->sm, csio_lns_uninit); 1324 csio_post_event_rns(ln, CSIO_RNFE_CLOSE); 1325 break; 1326 1327 default: 1328 csio_ln_dbg(ln, 1329 "unexp ln event %d recv from did:x%x in " 1330 "ln state[offline]\n", evt, ln->nport_id); 1331 CSIO_INC_STATS(ln, n_evt_unexp); 1332 CSIO_DB_ASSERT(0); 1333 break; 1334 } /* switch event */ 1335 } 1336 1337 /*****************************************************************************/ 1338 /* END: Lnode SM */ 1339 /*****************************************************************************/ 1340 1341 static void 1342 csio_free_fcfinfo(struct kref *kref) 1343 { 1344 struct csio_fcf_info *fcfinfo = container_of(kref, 1345 struct csio_fcf_info, kref); 1346 kfree(fcfinfo); 1347 } 1348 1349 /* Helper routines for attributes */ 1350 /* 1351 * csio_lnode_state_to_str - Get current state of FCOE lnode. 1352 * @ln - lnode 1353 * @str - state of lnode. 1354 * 1355 */ 1356 void 1357 csio_lnode_state_to_str(struct csio_lnode *ln, int8_t *str) 1358 { 1359 if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_uninit)) { 1360 strcpy(str, "UNINIT"); 1361 return; 1362 } 1363 if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_ready)) { 1364 strcpy(str, "READY"); 1365 return; 1366 } 1367 if (csio_get_state(ln) == ((csio_sm_state_t)csio_lns_offline)) { 1368 strcpy(str, "OFFLINE"); 1369 return; 1370 } 1371 strcpy(str, "UNKNOWN"); 1372 } /* csio_lnode_state_to_str */ 1373 1374 1375 int 1376 csio_get_phy_port_stats(struct csio_hw *hw, uint8_t portid, 1377 struct fw_fcoe_port_stats *port_stats) 1378 { 1379 struct csio_mb *mbp; 1380 struct fw_fcoe_port_cmd_params portparams; 1381 enum fw_retval retval; 1382 int idx; 1383 1384 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC); 1385 if (!mbp) { 1386 csio_err(hw, "FCoE FCF PARAMS command out of memory!\n"); 1387 return -EINVAL; 1388 } 1389 portparams.portid = portid; 1390 1391 for (idx = 1; idx <= 3; idx++) { 1392 portparams.idx = (idx-1)*6 + 1; 1393 portparams.nstats = 6; 1394 if (idx == 3) 1395 portparams.nstats = 4; 1396 csio_fcoe_read_portparams_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO, 1397 &portparams, NULL); 1398 if (csio_mb_issue(hw, mbp)) { 1399 csio_err(hw, "Issue of FCoE port params failed!\n"); 1400 mempool_free(mbp, hw->mb_mempool); 1401 return -EINVAL; 1402 } 1403 csio_mb_process_portparams_rsp(hw, mbp, &retval, 1404 &portparams, port_stats); 1405 } 1406 1407 mempool_free(mbp, hw->mb_mempool); 1408 return 0; 1409 } 1410 1411 /* 1412 * csio_ln_mgmt_wr_handler -Mgmt Work Request handler. 1413 * @wr - WR. 1414 * @len - WR len. 1415 * This handler is invoked when an outstanding mgmt WR is completed. 1416 * Its invoked in the context of FW event worker thread for every 1417 * mgmt event received. 1418 * Return - none. 1419 */ 1420 1421 static void 1422 csio_ln_mgmt_wr_handler(struct csio_hw *hw, void *wr, uint32_t len) 1423 { 1424 struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw); 1425 struct csio_ioreq *io_req = NULL; 1426 struct fw_fcoe_els_ct_wr *wr_cmd; 1427 1428 1429 wr_cmd = (struct fw_fcoe_els_ct_wr *) wr; 1430 1431 if (len < sizeof(struct fw_fcoe_els_ct_wr)) { 1432 csio_err(mgmtm->hw, 1433 "Invalid ELS CT WR length recvd, len:%x\n", len); 1434 mgmtm->stats.n_err++; 1435 return; 1436 } 1437 1438 io_req = (struct csio_ioreq *) ((uintptr_t) wr_cmd->cookie); 1439 io_req->wr_status = csio_wr_status(wr_cmd); 1440 1441 /* lookup ioreq exists in our active Q */ 1442 spin_lock_irq(&hw->lock); 1443 if (csio_mgmt_req_lookup(mgmtm, io_req) != 0) { 1444 csio_err(mgmtm->hw, 1445 "Error- Invalid IO handle recv in WR. handle: %p\n", 1446 io_req); 1447 mgmtm->stats.n_err++; 1448 spin_unlock_irq(&hw->lock); 1449 return; 1450 } 1451 1452 mgmtm = csio_hw_to_mgmtm(hw); 1453 1454 /* Dequeue from active queue */ 1455 list_del_init(&io_req->sm.sm_list); 1456 mgmtm->stats.n_active--; 1457 spin_unlock_irq(&hw->lock); 1458 1459 /* io_req will be freed by completion handler */ 1460 if (io_req->io_cbfn) 1461 io_req->io_cbfn(hw, io_req); 1462 } 1463 1464 /** 1465 * csio_fcoe_fwevt_handler - Event handler for Firmware FCoE events. 1466 * @hw: HW module 1467 * @cpl_op: CPL opcode 1468 * @cmd: FW cmd/WR. 1469 * 1470 * Process received FCoE cmd/WR event from FW. 1471 */ 1472 void 1473 csio_fcoe_fwevt_handler(struct csio_hw *hw, __u8 cpl_op, __be64 *cmd) 1474 { 1475 struct csio_lnode *ln; 1476 struct csio_rnode *rn; 1477 uint8_t portid, opcode = *(uint8_t *)cmd; 1478 struct fw_fcoe_link_cmd *lcmd; 1479 struct fw_wr_hdr *wr; 1480 struct fw_rdev_wr *rdev_wr; 1481 enum fw_fcoe_link_status lstatus; 1482 uint32_t fcfi, rdev_flowid, vnpi; 1483 enum csio_ln_ev evt; 1484 1485 if (cpl_op == CPL_FW6_MSG && opcode == FW_FCOE_LINK_CMD) { 1486 1487 lcmd = (struct fw_fcoe_link_cmd *)cmd; 1488 lstatus = lcmd->lstatus; 1489 portid = FW_FCOE_LINK_CMD_PORTID_GET( 1490 ntohl(lcmd->op_to_portid)); 1491 fcfi = FW_FCOE_LINK_CMD_FCFI_GET(ntohl(lcmd->sub_opcode_fcfi)); 1492 vnpi = FW_FCOE_LINK_CMD_VNPI_GET(ntohl(lcmd->vnpi_pkd)); 1493 1494 if (lstatus == FCOE_LINKUP) { 1495 1496 /* HW lock here */ 1497 spin_lock_irq(&hw->lock); 1498 csio_handle_link_up(hw, portid, fcfi, vnpi); 1499 spin_unlock_irq(&hw->lock); 1500 /* HW un lock here */ 1501 1502 } else if (lstatus == FCOE_LINKDOWN) { 1503 1504 /* HW lock here */ 1505 spin_lock_irq(&hw->lock); 1506 csio_handle_link_down(hw, portid, fcfi, vnpi); 1507 spin_unlock_irq(&hw->lock); 1508 /* HW un lock here */ 1509 } else { 1510 csio_warn(hw, "Unexpected FCOE LINK status:0x%x\n", 1511 lcmd->lstatus); 1512 CSIO_INC_STATS(hw, n_cpl_unexp); 1513 } 1514 } else if (cpl_op == CPL_FW6_PLD) { 1515 wr = (struct fw_wr_hdr *) (cmd + 4); 1516 if (FW_WR_OP_G(be32_to_cpu(wr->hi)) 1517 == FW_RDEV_WR) { 1518 1519 rdev_wr = (struct fw_rdev_wr *) (cmd + 4); 1520 1521 rdev_flowid = FW_RDEV_WR_FLOWID_GET( 1522 ntohl(rdev_wr->alloc_to_len16)); 1523 vnpi = FW_RDEV_WR_ASSOC_FLOWID_GET( 1524 ntohl(rdev_wr->flags_to_assoc_flowid)); 1525 1526 csio_dbg(hw, 1527 "FW_RDEV_WR: flowid:x%x ev_cause:x%x " 1528 "vnpi:0x%x\n", rdev_flowid, 1529 rdev_wr->event_cause, vnpi); 1530 1531 if (rdev_wr->protocol != PROT_FCOE) { 1532 csio_err(hw, 1533 "FW_RDEV_WR: invalid proto:x%x " 1534 "received with flowid:x%x\n", 1535 rdev_wr->protocol, 1536 rdev_flowid); 1537 CSIO_INC_STATS(hw, n_evt_drop); 1538 return; 1539 } 1540 1541 /* HW lock here */ 1542 spin_lock_irq(&hw->lock); 1543 ln = csio_ln_lookup_by_vnpi(hw, vnpi); 1544 if (!ln) { 1545 csio_err(hw, 1546 "FW_DEV_WR: invalid vnpi:x%x received " 1547 "with flowid:x%x\n", vnpi, rdev_flowid); 1548 CSIO_INC_STATS(hw, n_evt_drop); 1549 goto out_pld; 1550 } 1551 1552 rn = csio_confirm_rnode(ln, rdev_flowid, 1553 &rdev_wr->u.fcoe_rdev); 1554 if (!rn) { 1555 csio_ln_dbg(ln, 1556 "Failed to confirm rnode " 1557 "for flowid:x%x\n", rdev_flowid); 1558 CSIO_INC_STATS(hw, n_evt_drop); 1559 goto out_pld; 1560 } 1561 1562 /* save previous event for debugging */ 1563 ln->prev_evt = ln->cur_evt; 1564 ln->cur_evt = rdev_wr->event_cause; 1565 CSIO_INC_STATS(ln, n_evt_fw[rdev_wr->event_cause]); 1566 1567 /* Translate all the fabric events to lnode SM events */ 1568 evt = CSIO_FWE_TO_LNE(rdev_wr->event_cause); 1569 if (evt) { 1570 csio_ln_dbg(ln, 1571 "Posting event to lnode event:%d " 1572 "cause:%d flowid:x%x\n", evt, 1573 rdev_wr->event_cause, rdev_flowid); 1574 csio_post_event(&ln->sm, evt); 1575 } 1576 1577 /* Handover event to rn SM here. */ 1578 csio_rnode_fwevt_handler(rn, rdev_wr->event_cause); 1579 out_pld: 1580 spin_unlock_irq(&hw->lock); 1581 return; 1582 } else { 1583 csio_warn(hw, "unexpected WR op(0x%x) recv\n", 1584 FW_WR_OP_G(be32_to_cpu((wr->hi)))); 1585 CSIO_INC_STATS(hw, n_cpl_unexp); 1586 } 1587 } else if (cpl_op == CPL_FW6_MSG) { 1588 wr = (struct fw_wr_hdr *) (cmd); 1589 if (FW_WR_OP_G(be32_to_cpu(wr->hi)) == FW_FCOE_ELS_CT_WR) { 1590 csio_ln_mgmt_wr_handler(hw, wr, 1591 sizeof(struct fw_fcoe_els_ct_wr)); 1592 } else { 1593 csio_warn(hw, "unexpected WR op(0x%x) recv\n", 1594 FW_WR_OP_G(be32_to_cpu((wr->hi)))); 1595 CSIO_INC_STATS(hw, n_cpl_unexp); 1596 } 1597 } else { 1598 csio_warn(hw, "unexpected CPL op(0x%x) recv\n", opcode); 1599 CSIO_INC_STATS(hw, n_cpl_unexp); 1600 } 1601 } 1602 1603 /** 1604 * csio_lnode_start - Kickstart lnode discovery. 1605 * @ln: lnode 1606 * 1607 * This routine kickstarts the discovery by issuing an FCOE_LINK (up) command. 1608 */ 1609 int 1610 csio_lnode_start(struct csio_lnode *ln) 1611 { 1612 int rv = 0; 1613 if (csio_is_phys_ln(ln) && !(ln->flags & CSIO_LNF_LINK_ENABLE)) { 1614 rv = csio_fcoe_enable_link(ln, 1); 1615 ln->flags |= CSIO_LNF_LINK_ENABLE; 1616 } 1617 1618 return rv; 1619 } 1620 1621 /** 1622 * csio_lnode_stop - Stop the lnode. 1623 * @ln: lnode 1624 * 1625 * This routine is invoked by HW module to stop lnode and its associated NPIV 1626 * lnodes. 1627 */ 1628 void 1629 csio_lnode_stop(struct csio_lnode *ln) 1630 { 1631 csio_post_event_lns(ln, CSIO_LNE_DOWN_LINK); 1632 if (csio_is_phys_ln(ln) && (ln->flags & CSIO_LNF_LINK_ENABLE)) { 1633 csio_fcoe_enable_link(ln, 0); 1634 ln->flags &= ~CSIO_LNF_LINK_ENABLE; 1635 } 1636 csio_ln_dbg(ln, "stopping ln :%p\n", ln); 1637 } 1638 1639 /** 1640 * csio_lnode_close - Close an lnode. 1641 * @ln: lnode 1642 * 1643 * This routine is invoked by HW module to close an lnode and its 1644 * associated NPIV lnodes. Lnode and its associated NPIV lnodes are 1645 * set to uninitialized state. 1646 */ 1647 void 1648 csio_lnode_close(struct csio_lnode *ln) 1649 { 1650 csio_post_event_lns(ln, CSIO_LNE_CLOSE); 1651 if (csio_is_phys_ln(ln)) 1652 ln->vnp_flowid = CSIO_INVALID_IDX; 1653 1654 csio_ln_dbg(ln, "closed ln :%p\n", ln); 1655 } 1656 1657 /* 1658 * csio_ln_prep_ecwr - Prepare ELS/CT WR. 1659 * @io_req - IO request. 1660 * @wr_len - WR len 1661 * @immd_len - WR immediate data 1662 * @sub_op - Sub opcode 1663 * @sid - source portid. 1664 * @did - destination portid 1665 * @flow_id - flowid 1666 * @fw_wr - ELS/CT WR to be prepared. 1667 * Returns: 0 - on success 1668 */ 1669 static int 1670 csio_ln_prep_ecwr(struct csio_ioreq *io_req, uint32_t wr_len, 1671 uint32_t immd_len, uint8_t sub_op, uint32_t sid, 1672 uint32_t did, uint32_t flow_id, uint8_t *fw_wr) 1673 { 1674 struct fw_fcoe_els_ct_wr *wr; 1675 __be32 port_id; 1676 1677 wr = (struct fw_fcoe_els_ct_wr *)fw_wr; 1678 wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_FCOE_ELS_CT_WR) | 1679 FW_FCOE_ELS_CT_WR_IMMDLEN(immd_len)); 1680 1681 wr_len = DIV_ROUND_UP(wr_len, 16); 1682 wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(flow_id) | 1683 FW_WR_LEN16_V(wr_len)); 1684 wr->els_ct_type = sub_op; 1685 wr->ctl_pri = 0; 1686 wr->cp_en_class = 0; 1687 wr->cookie = io_req->fw_handle; 1688 wr->iqid = cpu_to_be16(csio_q_physiqid( 1689 io_req->lnode->hwp, io_req->iq_idx)); 1690 wr->fl_to_sp = FW_FCOE_ELS_CT_WR_SP(1); 1691 wr->tmo_val = (uint8_t) io_req->tmo; 1692 port_id = htonl(sid); 1693 memcpy(wr->l_id, PORT_ID_PTR(port_id), 3); 1694 port_id = htonl(did); 1695 memcpy(wr->r_id, PORT_ID_PTR(port_id), 3); 1696 1697 /* Prepare RSP SGL */ 1698 wr->rsp_dmalen = cpu_to_be32(io_req->dma_buf.len); 1699 wr->rsp_dmaaddr = cpu_to_be64(io_req->dma_buf.paddr); 1700 return 0; 1701 } 1702 1703 /* 1704 * csio_ln_mgmt_submit_wr - Post elsct work request. 1705 * @mgmtm - mgmtm 1706 * @io_req - io request. 1707 * @sub_op - ELS or CT request type 1708 * @pld - Dma Payload buffer 1709 * @pld_len - Payload len 1710 * Prepares ELSCT Work request and sents it to FW. 1711 * Returns: 0 - on success 1712 */ 1713 static int 1714 csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req, 1715 uint8_t sub_op, struct csio_dma_buf *pld, 1716 uint32_t pld_len) 1717 { 1718 struct csio_wr_pair wrp; 1719 struct csio_lnode *ln = io_req->lnode; 1720 struct csio_rnode *rn = io_req->rnode; 1721 struct csio_hw *hw = mgmtm->hw; 1722 uint8_t fw_wr[64]; 1723 struct ulptx_sgl dsgl; 1724 uint32_t wr_size = 0; 1725 uint8_t im_len = 0; 1726 uint32_t wr_off = 0; 1727 1728 int ret = 0; 1729 1730 /* Calculate WR Size for this ELS REQ */ 1731 wr_size = sizeof(struct fw_fcoe_els_ct_wr); 1732 1733 /* Send as immediate data if pld < 256 */ 1734 if (pld_len < 256) { 1735 wr_size += ALIGN(pld_len, 8); 1736 im_len = (uint8_t)pld_len; 1737 } else 1738 wr_size += sizeof(struct ulptx_sgl); 1739 1740 /* Roundup WR size in units of 16 bytes */ 1741 wr_size = ALIGN(wr_size, 16); 1742 1743 /* Get WR to send ELS REQ */ 1744 ret = csio_wr_get(hw, mgmtm->eq_idx, wr_size, &wrp); 1745 if (ret != 0) { 1746 csio_err(hw, "Failed to get WR for ec_req %p ret:%d\n", 1747 io_req, ret); 1748 return ret; 1749 } 1750 1751 /* Prepare Generic WR used by all ELS/CT cmd */ 1752 csio_ln_prep_ecwr(io_req, wr_size, im_len, sub_op, 1753 ln->nport_id, rn->nport_id, 1754 csio_rn_flowid(rn), 1755 &fw_wr[0]); 1756 1757 /* Copy ELS/CT WR CMD */ 1758 csio_wr_copy_to_wrp(&fw_wr[0], &wrp, wr_off, 1759 sizeof(struct fw_fcoe_els_ct_wr)); 1760 wr_off += sizeof(struct fw_fcoe_els_ct_wr); 1761 1762 /* Copy payload to Immediate section of WR */ 1763 if (im_len) 1764 csio_wr_copy_to_wrp(pld->vaddr, &wrp, wr_off, im_len); 1765 else { 1766 /* Program DSGL to dma payload */ 1767 dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | 1768 ULPTX_MORE_F | ULPTX_NSGE_V(1)); 1769 dsgl.len0 = cpu_to_be32(pld_len); 1770 dsgl.addr0 = cpu_to_be64(pld->paddr); 1771 csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8), 1772 sizeof(struct ulptx_sgl)); 1773 } 1774 1775 /* Issue work request to xmit ELS/CT req to FW */ 1776 csio_wr_issue(mgmtm->hw, mgmtm->eq_idx, false); 1777 return ret; 1778 } 1779 1780 /* 1781 * csio_ln_mgmt_submit_req - Submit FCOE Mgmt request. 1782 * @io_req - IO Request 1783 * @io_cbfn - Completion handler. 1784 * @req_type - ELS or CT request type 1785 * @pld - Dma Payload buffer 1786 * @pld_len - Payload len 1787 * 1788 * 1789 * This API used submit managment ELS/CT request. 1790 * This called with hw lock held 1791 * Returns: 0 - on success 1792 * -ENOMEM - on error. 1793 */ 1794 static int 1795 csio_ln_mgmt_submit_req(struct csio_ioreq *io_req, 1796 void (*io_cbfn) (struct csio_hw *, struct csio_ioreq *), 1797 enum fcoe_cmn_type req_type, struct csio_dma_buf *pld, 1798 uint32_t pld_len) 1799 { 1800 struct csio_hw *hw = csio_lnode_to_hw(io_req->lnode); 1801 struct csio_mgmtm *mgmtm = csio_hw_to_mgmtm(hw); 1802 int rv; 1803 1804 BUG_ON(pld_len > pld->len); 1805 1806 io_req->io_cbfn = io_cbfn; /* Upper layer callback handler */ 1807 io_req->fw_handle = (uintptr_t) (io_req); 1808 io_req->eq_idx = mgmtm->eq_idx; 1809 io_req->iq_idx = mgmtm->iq_idx; 1810 1811 rv = csio_ln_mgmt_submit_wr(mgmtm, io_req, req_type, pld, pld_len); 1812 if (rv == 0) { 1813 list_add_tail(&io_req->sm.sm_list, &mgmtm->active_q); 1814 mgmtm->stats.n_active++; 1815 } 1816 return rv; 1817 } 1818 1819 /* 1820 * csio_ln_fdmi_init - FDMI Init entry point. 1821 * @ln: lnode 1822 */ 1823 static int 1824 csio_ln_fdmi_init(struct csio_lnode *ln) 1825 { 1826 struct csio_hw *hw = csio_lnode_to_hw(ln); 1827 struct csio_dma_buf *dma_buf; 1828 1829 /* Allocate MGMT request required for FDMI */ 1830 ln->mgmt_req = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL); 1831 if (!ln->mgmt_req) { 1832 csio_ln_err(ln, "Failed to alloc ioreq for FDMI\n"); 1833 CSIO_INC_STATS(hw, n_err_nomem); 1834 return -ENOMEM; 1835 } 1836 1837 /* Allocate Dma buffers for FDMI response Payload */ 1838 dma_buf = &ln->mgmt_req->dma_buf; 1839 dma_buf->len = 2048; 1840 dma_buf->vaddr = pci_alloc_consistent(hw->pdev, dma_buf->len, 1841 &dma_buf->paddr); 1842 if (!dma_buf->vaddr) { 1843 csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n"); 1844 kfree(ln->mgmt_req); 1845 ln->mgmt_req = NULL; 1846 return -ENOMEM; 1847 } 1848 1849 ln->flags |= CSIO_LNF_FDMI_ENABLE; 1850 return 0; 1851 } 1852 1853 /* 1854 * csio_ln_fdmi_exit - FDMI exit entry point. 1855 * @ln: lnode 1856 */ 1857 static int 1858 csio_ln_fdmi_exit(struct csio_lnode *ln) 1859 { 1860 struct csio_dma_buf *dma_buf; 1861 struct csio_hw *hw = csio_lnode_to_hw(ln); 1862 1863 if (!ln->mgmt_req) 1864 return 0; 1865 1866 dma_buf = &ln->mgmt_req->dma_buf; 1867 if (dma_buf->vaddr) 1868 pci_free_consistent(hw->pdev, dma_buf->len, dma_buf->vaddr, 1869 dma_buf->paddr); 1870 1871 kfree(ln->mgmt_req); 1872 return 0; 1873 } 1874 1875 int 1876 csio_scan_done(struct csio_lnode *ln, unsigned long ticks, 1877 unsigned long time, unsigned long max_scan_ticks, 1878 unsigned long delta_scan_ticks) 1879 { 1880 int rv = 0; 1881 1882 if (time >= max_scan_ticks) 1883 return 1; 1884 1885 if (!ln->tgt_scan_tick) 1886 ln->tgt_scan_tick = ticks; 1887 1888 if (((ticks - ln->tgt_scan_tick) >= delta_scan_ticks)) { 1889 if (!ln->last_scan_ntgts) 1890 ln->last_scan_ntgts = ln->n_scsi_tgts; 1891 else { 1892 if (ln->last_scan_ntgts == ln->n_scsi_tgts) 1893 return 1; 1894 1895 ln->last_scan_ntgts = ln->n_scsi_tgts; 1896 } 1897 ln->tgt_scan_tick = ticks; 1898 } 1899 return rv; 1900 } 1901 1902 /* 1903 * csio_notify_lnodes: 1904 * @hw: HW module 1905 * @note: Notification 1906 * 1907 * Called from the HW SM to fan out notifications to the 1908 * Lnode SM. Since the HW SM is entered with lock held, 1909 * there is no need to hold locks here. 1910 * 1911 */ 1912 void 1913 csio_notify_lnodes(struct csio_hw *hw, enum csio_ln_notify note) 1914 { 1915 struct list_head *tmp; 1916 struct csio_lnode *ln; 1917 1918 csio_dbg(hw, "Notifying all nodes of event %d\n", note); 1919 1920 /* Traverse children lnodes list and send evt */ 1921 list_for_each(tmp, &hw->sln_head) { 1922 ln = (struct csio_lnode *) tmp; 1923 1924 switch (note) { 1925 case CSIO_LN_NOTIFY_HWREADY: 1926 csio_lnode_start(ln); 1927 break; 1928 1929 case CSIO_LN_NOTIFY_HWRESET: 1930 case CSIO_LN_NOTIFY_HWREMOVE: 1931 csio_lnode_close(ln); 1932 break; 1933 1934 case CSIO_LN_NOTIFY_HWSTOP: 1935 csio_lnode_stop(ln); 1936 break; 1937 1938 default: 1939 break; 1940 1941 } 1942 } 1943 } 1944 1945 /* 1946 * csio_disable_lnodes: 1947 * @hw: HW module 1948 * @portid:port id 1949 * @disable: disable/enable flag. 1950 * If disable=1, disables all lnode hosted on given physical port. 1951 * otherwise enables all the lnodes on given phsysical port. 1952 * This routine need to called with hw lock held. 1953 */ 1954 void 1955 csio_disable_lnodes(struct csio_hw *hw, uint8_t portid, bool disable) 1956 { 1957 struct list_head *tmp; 1958 struct csio_lnode *ln; 1959 1960 csio_dbg(hw, "Notifying event to all nodes of port:%d\n", portid); 1961 1962 /* Traverse sibling lnodes list and send evt */ 1963 list_for_each(tmp, &hw->sln_head) { 1964 ln = (struct csio_lnode *) tmp; 1965 if (ln->portid != portid) 1966 continue; 1967 1968 if (disable) 1969 csio_lnode_stop(ln); 1970 else 1971 csio_lnode_start(ln); 1972 } 1973 } 1974 1975 /* 1976 * csio_ln_init - Initialize an lnode. 1977 * @ln: lnode 1978 * 1979 */ 1980 static int 1981 csio_ln_init(struct csio_lnode *ln) 1982 { 1983 int rv = -EINVAL; 1984 struct csio_lnode *rln, *pln; 1985 struct csio_hw *hw = csio_lnode_to_hw(ln); 1986 1987 csio_init_state(&ln->sm, csio_lns_uninit); 1988 ln->vnp_flowid = CSIO_INVALID_IDX; 1989 ln->fcf_flowid = CSIO_INVALID_IDX; 1990 1991 if (csio_is_root_ln(ln)) { 1992 1993 /* This is the lnode used during initialization */ 1994 1995 ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), GFP_KERNEL); 1996 if (!ln->fcfinfo) { 1997 csio_ln_err(ln, "Failed to alloc FCF record\n"); 1998 CSIO_INC_STATS(hw, n_err_nomem); 1999 goto err; 2000 } 2001 2002 INIT_LIST_HEAD(&ln->fcf_lsthead); 2003 kref_init(&ln->fcfinfo->kref); 2004 2005 if (csio_fdmi_enable && csio_ln_fdmi_init(ln)) 2006 goto err; 2007 2008 } else { /* Either a non-root physical or a virtual lnode */ 2009 2010 /* 2011 * THe rest is common for non-root physical and NPIV lnodes. 2012 * Just get references to all other modules 2013 */ 2014 rln = csio_root_lnode(ln); 2015 2016 if (csio_is_npiv_ln(ln)) { 2017 /* NPIV */ 2018 pln = csio_parent_lnode(ln); 2019 kref_get(&pln->fcfinfo->kref); 2020 ln->fcfinfo = pln->fcfinfo; 2021 } else { 2022 /* Another non-root physical lnode (FCF) */ 2023 ln->fcfinfo = kzalloc(sizeof(struct csio_fcf_info), 2024 GFP_KERNEL); 2025 if (!ln->fcfinfo) { 2026 csio_ln_err(ln, "Failed to alloc FCF info\n"); 2027 CSIO_INC_STATS(hw, n_err_nomem); 2028 goto err; 2029 } 2030 2031 kref_init(&ln->fcfinfo->kref); 2032 2033 if (csio_fdmi_enable && csio_ln_fdmi_init(ln)) 2034 goto err; 2035 } 2036 2037 } /* if (!csio_is_root_ln(ln)) */ 2038 2039 return 0; 2040 err: 2041 return rv; 2042 } 2043 2044 static void 2045 csio_ln_exit(struct csio_lnode *ln) 2046 { 2047 struct csio_lnode *pln; 2048 2049 csio_cleanup_rns(ln); 2050 if (csio_is_npiv_ln(ln)) { 2051 pln = csio_parent_lnode(ln); 2052 kref_put(&pln->fcfinfo->kref, csio_free_fcfinfo); 2053 } else { 2054 kref_put(&ln->fcfinfo->kref, csio_free_fcfinfo); 2055 if (csio_fdmi_enable) 2056 csio_ln_fdmi_exit(ln); 2057 } 2058 ln->fcfinfo = NULL; 2059 } 2060 2061 /** 2062 * csio_lnode_init - Initialize the members of an lnode. 2063 * @ln: lnode 2064 * 2065 */ 2066 int 2067 csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw, 2068 struct csio_lnode *pln) 2069 { 2070 int rv = -EINVAL; 2071 2072 /* Link this lnode to hw */ 2073 csio_lnode_to_hw(ln) = hw; 2074 2075 /* Link child to parent if child lnode */ 2076 if (pln) 2077 ln->pln = pln; 2078 else 2079 ln->pln = NULL; 2080 2081 /* Initialize scsi_tgt and timers to zero */ 2082 ln->n_scsi_tgts = 0; 2083 ln->last_scan_ntgts = 0; 2084 ln->tgt_scan_tick = 0; 2085 2086 /* Initialize rnode list */ 2087 INIT_LIST_HEAD(&ln->rnhead); 2088 INIT_LIST_HEAD(&ln->cln_head); 2089 2090 /* Initialize log level for debug */ 2091 ln->params.log_level = hw->params.log_level; 2092 2093 if (csio_ln_init(ln)) 2094 goto err; 2095 2096 /* Add lnode to list of sibling or children lnodes */ 2097 spin_lock_irq(&hw->lock); 2098 list_add_tail(&ln->sm.sm_list, pln ? &pln->cln_head : &hw->sln_head); 2099 if (pln) 2100 pln->num_vports++; 2101 spin_unlock_irq(&hw->lock); 2102 2103 hw->num_lns++; 2104 2105 return 0; 2106 err: 2107 csio_lnode_to_hw(ln) = NULL; 2108 return rv; 2109 } 2110 2111 /** 2112 * csio_lnode_exit - De-instantiate an lnode. 2113 * @ln: lnode 2114 * 2115 */ 2116 void 2117 csio_lnode_exit(struct csio_lnode *ln) 2118 { 2119 struct csio_hw *hw = csio_lnode_to_hw(ln); 2120 2121 csio_ln_exit(ln); 2122 2123 /* Remove this lnode from hw->sln_head */ 2124 spin_lock_irq(&hw->lock); 2125 2126 list_del_init(&ln->sm.sm_list); 2127 2128 /* If it is children lnode, decrement the 2129 * counter in its parent lnode 2130 */ 2131 if (ln->pln) 2132 ln->pln->num_vports--; 2133 2134 /* Update root lnode pointer */ 2135 if (list_empty(&hw->sln_head)) 2136 hw->rln = NULL; 2137 else 2138 hw->rln = (struct csio_lnode *)csio_list_next(&hw->sln_head); 2139 2140 spin_unlock_irq(&hw->lock); 2141 2142 csio_lnode_to_hw(ln) = NULL; 2143 hw->num_lns--; 2144 } 2145