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