1 /* 2 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 3 * Copyright (c) 2014- QLogic Corporation. 4 * All rights reserved 5 * www.qlogic.com 6 * 7 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License (GPL) Version 2 as 11 * published by the Free Software Foundation 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 */ 18 /* 19 * fcbuild.c - FC link service frame building and parsing routines 20 */ 21 22 #include "bfad_drv.h" 23 #include "bfa_fcbuild.h" 24 25 /* 26 * static build functions 27 */ 28 static void fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, 29 __be16 ox_id); 30 static void fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, 31 __be16 ox_id); 32 static struct fchs_s fc_els_req_tmpl; 33 static struct fchs_s fc_els_rsp_tmpl; 34 static struct fchs_s fc_bls_req_tmpl; 35 static struct fchs_s fc_bls_rsp_tmpl; 36 static struct fc_ba_acc_s ba_acc_tmpl; 37 static struct fc_logi_s plogi_tmpl; 38 static struct fc_prli_s prli_tmpl; 39 static struct fc_rrq_s rrq_tmpl; 40 static struct fchs_s fcp_fchs_tmpl; 41 42 void 43 fcbuild_init(void) 44 { 45 /* 46 * fc_els_req_tmpl 47 */ 48 fc_els_req_tmpl.routing = FC_RTG_EXT_LINK; 49 fc_els_req_tmpl.cat_info = FC_CAT_LD_REQUEST; 50 fc_els_req_tmpl.type = FC_TYPE_ELS; 51 fc_els_req_tmpl.f_ctl = 52 bfa_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ | 53 FCTL_SI_XFER); 54 fc_els_req_tmpl.rx_id = FC_RXID_ANY; 55 56 /* 57 * fc_els_rsp_tmpl 58 */ 59 fc_els_rsp_tmpl.routing = FC_RTG_EXT_LINK; 60 fc_els_rsp_tmpl.cat_info = FC_CAT_LD_REPLY; 61 fc_els_rsp_tmpl.type = FC_TYPE_ELS; 62 fc_els_rsp_tmpl.f_ctl = 63 bfa_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH | 64 FCTL_END_SEQ | FCTL_SI_XFER); 65 fc_els_rsp_tmpl.rx_id = FC_RXID_ANY; 66 67 /* 68 * fc_bls_req_tmpl 69 */ 70 fc_bls_req_tmpl.routing = FC_RTG_BASIC_LINK; 71 fc_bls_req_tmpl.type = FC_TYPE_BLS; 72 fc_bls_req_tmpl.f_ctl = bfa_hton3b(FCTL_END_SEQ | FCTL_SI_XFER); 73 fc_bls_req_tmpl.rx_id = FC_RXID_ANY; 74 75 /* 76 * fc_bls_rsp_tmpl 77 */ 78 fc_bls_rsp_tmpl.routing = FC_RTG_BASIC_LINK; 79 fc_bls_rsp_tmpl.cat_info = FC_CAT_BA_ACC; 80 fc_bls_rsp_tmpl.type = FC_TYPE_BLS; 81 fc_bls_rsp_tmpl.f_ctl = 82 bfa_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH | 83 FCTL_END_SEQ | FCTL_SI_XFER); 84 fc_bls_rsp_tmpl.rx_id = FC_RXID_ANY; 85 86 /* 87 * ba_acc_tmpl 88 */ 89 ba_acc_tmpl.seq_id_valid = 0; 90 ba_acc_tmpl.low_seq_cnt = 0; 91 ba_acc_tmpl.high_seq_cnt = 0xFFFF; 92 93 /* 94 * plogi_tmpl 95 */ 96 plogi_tmpl.csp.verhi = FC_PH_VER_PH_3; 97 plogi_tmpl.csp.verlo = FC_PH_VER_4_3; 98 plogi_tmpl.csp.ciro = 0x1; 99 plogi_tmpl.csp.cisc = 0x0; 100 plogi_tmpl.csp.altbbcred = 0x0; 101 plogi_tmpl.csp.conseq = cpu_to_be16(0x00FF); 102 plogi_tmpl.csp.ro_bitmap = cpu_to_be16(0x0002); 103 plogi_tmpl.csp.e_d_tov = cpu_to_be32(2000); 104 105 plogi_tmpl.class3.class_valid = 1; 106 plogi_tmpl.class3.sequential = 1; 107 plogi_tmpl.class3.conseq = 0xFF; 108 plogi_tmpl.class3.ospx = 1; 109 110 /* 111 * prli_tmpl 112 */ 113 prli_tmpl.command = FC_ELS_PRLI; 114 prli_tmpl.pglen = 0x10; 115 prli_tmpl.pagebytes = cpu_to_be16(0x0014); 116 prli_tmpl.parampage.type = FC_TYPE_FCP; 117 prli_tmpl.parampage.imagepair = 1; 118 prli_tmpl.parampage.servparams.rxrdisab = 1; 119 120 /* 121 * rrq_tmpl 122 */ 123 rrq_tmpl.els_cmd.els_code = FC_ELS_RRQ; 124 125 /* 126 * fcp_struct fchs_s mpl 127 */ 128 fcp_fchs_tmpl.routing = FC_RTG_FC4_DEV_DATA; 129 fcp_fchs_tmpl.cat_info = FC_CAT_UNSOLICIT_CMD; 130 fcp_fchs_tmpl.type = FC_TYPE_FCP; 131 fcp_fchs_tmpl.f_ctl = 132 bfa_hton3b(FCTL_FS_EXCH | FCTL_END_SEQ | FCTL_SI_XFER); 133 fcp_fchs_tmpl.seq_id = 1; 134 fcp_fchs_tmpl.rx_id = FC_RXID_ANY; 135 } 136 137 static void 138 fc_gs_fchdr_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u32 ox_id) 139 { 140 memset(fchs, 0, sizeof(struct fchs_s)); 141 142 fchs->routing = FC_RTG_FC4_DEV_DATA; 143 fchs->cat_info = FC_CAT_UNSOLICIT_CTRL; 144 fchs->type = FC_TYPE_SERVICES; 145 fchs->f_ctl = 146 bfa_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ | 147 FCTL_SI_XFER); 148 fchs->rx_id = FC_RXID_ANY; 149 fchs->d_id = (d_id); 150 fchs->s_id = (s_id); 151 fchs->ox_id = cpu_to_be16(ox_id); 152 153 /* 154 * @todo no need to set ox_id for request 155 * no need to set rx_id for response 156 */ 157 } 158 159 static void 160 fc_gsresp_fchdr_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id) 161 { 162 memset(fchs, 0, sizeof(struct fchs_s)); 163 164 fchs->routing = FC_RTG_FC4_DEV_DATA; 165 fchs->cat_info = FC_CAT_SOLICIT_CTRL; 166 fchs->type = FC_TYPE_SERVICES; 167 fchs->f_ctl = 168 bfa_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH | 169 FCTL_END_SEQ | FCTL_SI_XFER); 170 fchs->d_id = d_id; 171 fchs->s_id = s_id; 172 fchs->ox_id = ox_id; 173 } 174 175 void 176 fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id) 177 { 178 memcpy(fchs, &fc_els_req_tmpl, sizeof(struct fchs_s)); 179 fchs->d_id = (d_id); 180 fchs->s_id = (s_id); 181 fchs->ox_id = cpu_to_be16(ox_id); 182 } 183 184 static void 185 fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id) 186 { 187 memcpy(fchs, &fc_els_rsp_tmpl, sizeof(struct fchs_s)); 188 fchs->d_id = d_id; 189 fchs->s_id = s_id; 190 fchs->ox_id = ox_id; 191 } 192 193 enum fc_parse_status 194 fc_els_rsp_parse(struct fchs_s *fchs, int len) 195 { 196 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1); 197 struct fc_ls_rjt_s *ls_rjt = (struct fc_ls_rjt_s *) els_cmd; 198 199 len = len; 200 201 switch (els_cmd->els_code) { 202 case FC_ELS_LS_RJT: 203 if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY) 204 return FC_PARSE_BUSY; 205 else 206 return FC_PARSE_FAILURE; 207 208 case FC_ELS_ACC: 209 return FC_PARSE_OK; 210 } 211 return FC_PARSE_OK; 212 } 213 214 static void 215 fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id) 216 { 217 memcpy(fchs, &fc_bls_rsp_tmpl, sizeof(struct fchs_s)); 218 fchs->d_id = d_id; 219 fchs->s_id = s_id; 220 fchs->ox_id = ox_id; 221 } 222 223 static u16 224 fc_plogi_x_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 225 __be16 ox_id, wwn_t port_name, wwn_t node_name, 226 u16 pdu_size, u16 bb_cr, u8 els_code) 227 { 228 struct fc_logi_s *plogi = (struct fc_logi_s *) (pld); 229 230 memcpy(plogi, &plogi_tmpl, sizeof(struct fc_logi_s)); 231 232 /* For FC AL bb_cr is 0 and altbbcred is 1 */ 233 if (!bb_cr) 234 plogi->csp.altbbcred = 1; 235 236 plogi->els_cmd.els_code = els_code; 237 if (els_code == FC_ELS_PLOGI) 238 fc_els_req_build(fchs, d_id, s_id, ox_id); 239 else 240 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 241 242 plogi->csp.rxsz = plogi->class3.rxsz = cpu_to_be16(pdu_size); 243 plogi->csp.bbcred = cpu_to_be16(bb_cr); 244 245 memcpy(&plogi->port_name, &port_name, sizeof(wwn_t)); 246 memcpy(&plogi->node_name, &node_name, sizeof(wwn_t)); 247 248 return sizeof(struct fc_logi_s); 249 } 250 251 u16 252 fc_flogi_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id, 253 u16 ox_id, wwn_t port_name, wwn_t node_name, u16 pdu_size, 254 u8 set_npiv, u8 set_auth, u16 local_bb_credits) 255 { 256 u32 d_id = bfa_hton3b(FC_FABRIC_PORT); 257 __be32 *vvl_info; 258 259 memcpy(flogi, &plogi_tmpl, sizeof(struct fc_logi_s)); 260 261 flogi->els_cmd.els_code = FC_ELS_FLOGI; 262 fc_els_req_build(fchs, d_id, s_id, ox_id); 263 264 flogi->csp.rxsz = flogi->class3.rxsz = cpu_to_be16(pdu_size); 265 flogi->port_name = port_name; 266 flogi->node_name = node_name; 267 268 /* 269 * Set the NPIV Capability Bit ( word 1, bit 31) of Common 270 * Service Parameters. 271 */ 272 flogi->csp.ciro = set_npiv; 273 274 /* set AUTH capability */ 275 flogi->csp.security = set_auth; 276 277 flogi->csp.bbcred = cpu_to_be16(local_bb_credits); 278 279 /* Set brcd token in VVL */ 280 vvl_info = (u32 *)&flogi->vvl[0]; 281 282 /* set the flag to indicate the presence of VVL */ 283 flogi->csp.npiv_supp = 1; /* @todo. field name is not correct */ 284 vvl_info[0] = cpu_to_be32(FLOGI_VVL_BRCD); 285 286 return sizeof(struct fc_logi_s); 287 } 288 289 u16 290 fc_flogi_acc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id, 291 __be16 ox_id, wwn_t port_name, wwn_t node_name, 292 u16 pdu_size, u16 local_bb_credits, u8 bb_scn) 293 { 294 u32 d_id = 0; 295 u16 bbscn_rxsz = (bb_scn << 12) | pdu_size; 296 297 memcpy(flogi, &plogi_tmpl, sizeof(struct fc_logi_s)); 298 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 299 300 flogi->els_cmd.els_code = FC_ELS_ACC; 301 flogi->class3.rxsz = cpu_to_be16(pdu_size); 302 flogi->csp.rxsz = cpu_to_be16(bbscn_rxsz); /* bb_scn/rxsz */ 303 flogi->port_name = port_name; 304 flogi->node_name = node_name; 305 306 flogi->csp.bbcred = cpu_to_be16(local_bb_credits); 307 308 return sizeof(struct fc_logi_s); 309 } 310 311 u16 312 fc_fdisc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id, 313 u16 ox_id, wwn_t port_name, wwn_t node_name, u16 pdu_size) 314 { 315 u32 d_id = bfa_hton3b(FC_FABRIC_PORT); 316 317 memcpy(flogi, &plogi_tmpl, sizeof(struct fc_logi_s)); 318 319 flogi->els_cmd.els_code = FC_ELS_FDISC; 320 fc_els_req_build(fchs, d_id, s_id, ox_id); 321 322 flogi->csp.rxsz = flogi->class3.rxsz = cpu_to_be16(pdu_size); 323 flogi->port_name = port_name; 324 flogi->node_name = node_name; 325 326 return sizeof(struct fc_logi_s); 327 } 328 329 u16 330 fc_plogi_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 331 u16 ox_id, wwn_t port_name, wwn_t node_name, 332 u16 pdu_size, u16 bb_cr) 333 { 334 return fc_plogi_x_build(fchs, pld, d_id, s_id, ox_id, port_name, 335 node_name, pdu_size, bb_cr, FC_ELS_PLOGI); 336 } 337 338 u16 339 fc_plogi_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 340 u16 ox_id, wwn_t port_name, wwn_t node_name, 341 u16 pdu_size, u16 bb_cr) 342 { 343 return fc_plogi_x_build(fchs, pld, d_id, s_id, ox_id, port_name, 344 node_name, pdu_size, bb_cr, FC_ELS_ACC); 345 } 346 347 enum fc_parse_status 348 fc_plogi_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name) 349 { 350 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1); 351 struct fc_logi_s *plogi; 352 struct fc_ls_rjt_s *ls_rjt; 353 354 switch (els_cmd->els_code) { 355 case FC_ELS_LS_RJT: 356 ls_rjt = (struct fc_ls_rjt_s *) (fchs + 1); 357 if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY) 358 return FC_PARSE_BUSY; 359 else 360 return FC_PARSE_FAILURE; 361 case FC_ELS_ACC: 362 plogi = (struct fc_logi_s *) (fchs + 1); 363 if (len < sizeof(struct fc_logi_s)) 364 return FC_PARSE_FAILURE; 365 366 if (!wwn_is_equal(plogi->port_name, port_name)) 367 return FC_PARSE_FAILURE; 368 369 if (!plogi->class3.class_valid) 370 return FC_PARSE_FAILURE; 371 372 if (be16_to_cpu(plogi->class3.rxsz) < (FC_MIN_PDUSZ)) 373 return FC_PARSE_FAILURE; 374 375 return FC_PARSE_OK; 376 default: 377 return FC_PARSE_FAILURE; 378 } 379 } 380 381 enum fc_parse_status 382 fc_plogi_parse(struct fchs_s *fchs) 383 { 384 struct fc_logi_s *plogi = (struct fc_logi_s *) (fchs + 1); 385 386 if (plogi->class3.class_valid != 1) 387 return FC_PARSE_FAILURE; 388 389 if ((be16_to_cpu(plogi->class3.rxsz) < FC_MIN_PDUSZ) 390 || (be16_to_cpu(plogi->class3.rxsz) > FC_MAX_PDUSZ) 391 || (plogi->class3.rxsz == 0)) 392 return FC_PARSE_FAILURE; 393 394 return FC_PARSE_OK; 395 } 396 397 u16 398 fc_prli_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 399 u16 ox_id) 400 { 401 struct fc_prli_s *prli = (struct fc_prli_s *) (pld); 402 403 fc_els_req_build(fchs, d_id, s_id, ox_id); 404 memcpy(prli, &prli_tmpl, sizeof(struct fc_prli_s)); 405 406 prli->command = FC_ELS_PRLI; 407 prli->parampage.servparams.initiator = 1; 408 prli->parampage.servparams.retry = 1; 409 prli->parampage.servparams.rec_support = 1; 410 prli->parampage.servparams.task_retry_id = 0; 411 prli->parampage.servparams.confirm = 1; 412 413 return sizeof(struct fc_prli_s); 414 } 415 416 u16 417 fc_prli_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 418 __be16 ox_id, enum bfa_lport_role role) 419 { 420 struct fc_prli_s *prli = (struct fc_prli_s *) (pld); 421 422 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 423 memcpy(prli, &prli_tmpl, sizeof(struct fc_prli_s)); 424 425 prli->command = FC_ELS_ACC; 426 427 prli->parampage.servparams.initiator = 1; 428 429 prli->parampage.rspcode = FC_PRLI_ACC_XQTD; 430 431 return sizeof(struct fc_prli_s); 432 } 433 434 enum fc_parse_status 435 fc_prli_rsp_parse(struct fc_prli_s *prli, int len) 436 { 437 if (len < sizeof(struct fc_prli_s)) 438 return FC_PARSE_FAILURE; 439 440 if (prli->command != FC_ELS_ACC) 441 return FC_PARSE_FAILURE; 442 443 if ((prli->parampage.rspcode != FC_PRLI_ACC_XQTD) 444 && (prli->parampage.rspcode != FC_PRLI_ACC_PREDEF_IMG)) 445 return FC_PARSE_FAILURE; 446 447 if (prli->parampage.servparams.target != 1) 448 return FC_PARSE_FAILURE; 449 450 return FC_PARSE_OK; 451 } 452 453 enum fc_parse_status 454 fc_prli_parse(struct fc_prli_s *prli) 455 { 456 if (prli->parampage.type != FC_TYPE_FCP) 457 return FC_PARSE_FAILURE; 458 459 if (!prli->parampage.imagepair) 460 return FC_PARSE_FAILURE; 461 462 if (!prli->parampage.servparams.initiator) 463 return FC_PARSE_FAILURE; 464 465 return FC_PARSE_OK; 466 } 467 468 u16 469 fc_logo_build(struct fchs_s *fchs, struct fc_logo_s *logo, u32 d_id, u32 s_id, 470 u16 ox_id, wwn_t port_name) 471 { 472 fc_els_req_build(fchs, d_id, s_id, ox_id); 473 474 memset(logo, '\0', sizeof(struct fc_logo_s)); 475 logo->els_cmd.els_code = FC_ELS_LOGO; 476 logo->nport_id = (s_id); 477 logo->orig_port_name = port_name; 478 479 return sizeof(struct fc_logo_s); 480 } 481 482 static u16 483 fc_adisc_x_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id, 484 u32 s_id, __be16 ox_id, wwn_t port_name, 485 wwn_t node_name, u8 els_code) 486 { 487 memset(adisc, '\0', sizeof(struct fc_adisc_s)); 488 489 adisc->els_cmd.els_code = els_code; 490 491 if (els_code == FC_ELS_ADISC) 492 fc_els_req_build(fchs, d_id, s_id, ox_id); 493 else 494 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 495 496 adisc->orig_HA = 0; 497 adisc->orig_port_name = port_name; 498 adisc->orig_node_name = node_name; 499 adisc->nport_id = (s_id); 500 501 return sizeof(struct fc_adisc_s); 502 } 503 504 u16 505 fc_adisc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id, 506 u32 s_id, __be16 ox_id, wwn_t port_name, wwn_t node_name) 507 { 508 return fc_adisc_x_build(fchs, adisc, d_id, s_id, ox_id, port_name, 509 node_name, FC_ELS_ADISC); 510 } 511 512 u16 513 fc_adisc_acc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id, 514 u32 s_id, __be16 ox_id, wwn_t port_name, 515 wwn_t node_name) 516 { 517 return fc_adisc_x_build(fchs, adisc, d_id, s_id, ox_id, port_name, 518 node_name, FC_ELS_ACC); 519 } 520 521 enum fc_parse_status 522 fc_adisc_rsp_parse(struct fc_adisc_s *adisc, int len, wwn_t port_name, 523 wwn_t node_name) 524 { 525 526 if (len < sizeof(struct fc_adisc_s)) 527 return FC_PARSE_FAILURE; 528 529 if (adisc->els_cmd.els_code != FC_ELS_ACC) 530 return FC_PARSE_FAILURE; 531 532 if (!wwn_is_equal(adisc->orig_port_name, port_name)) 533 return FC_PARSE_FAILURE; 534 535 return FC_PARSE_OK; 536 } 537 538 enum fc_parse_status 539 fc_adisc_parse(struct fchs_s *fchs, void *pld, u32 host_dap, wwn_t node_name, 540 wwn_t port_name) 541 { 542 struct fc_adisc_s *adisc = (struct fc_adisc_s *) pld; 543 544 if (adisc->els_cmd.els_code != FC_ELS_ACC) 545 return FC_PARSE_FAILURE; 546 547 if ((adisc->nport_id == (host_dap)) 548 && wwn_is_equal(adisc->orig_port_name, port_name) 549 && wwn_is_equal(adisc->orig_node_name, node_name)) 550 return FC_PARSE_OK; 551 552 return FC_PARSE_FAILURE; 553 } 554 555 enum fc_parse_status 556 fc_pdisc_parse(struct fchs_s *fchs, wwn_t node_name, wwn_t port_name) 557 { 558 struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1); 559 560 if (pdisc->class3.class_valid != 1) 561 return FC_PARSE_FAILURE; 562 563 if ((be16_to_cpu(pdisc->class3.rxsz) < 564 (FC_MIN_PDUSZ - sizeof(struct fchs_s))) 565 || (pdisc->class3.rxsz == 0)) 566 return FC_PARSE_FAILURE; 567 568 if (!wwn_is_equal(pdisc->port_name, port_name)) 569 return FC_PARSE_FAILURE; 570 571 if (!wwn_is_equal(pdisc->node_name, node_name)) 572 return FC_PARSE_FAILURE; 573 574 return FC_PARSE_OK; 575 } 576 577 u16 578 fc_abts_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id) 579 { 580 memcpy(fchs, &fc_bls_req_tmpl, sizeof(struct fchs_s)); 581 fchs->cat_info = FC_CAT_ABTS; 582 fchs->d_id = (d_id); 583 fchs->s_id = (s_id); 584 fchs->ox_id = cpu_to_be16(ox_id); 585 586 return sizeof(struct fchs_s); 587 } 588 589 enum fc_parse_status 590 fc_abts_rsp_parse(struct fchs_s *fchs, int len) 591 { 592 if ((fchs->cat_info == FC_CAT_BA_ACC) 593 || (fchs->cat_info == FC_CAT_BA_RJT)) 594 return FC_PARSE_OK; 595 596 return FC_PARSE_FAILURE; 597 } 598 599 u16 600 fc_rrq_build(struct fchs_s *fchs, struct fc_rrq_s *rrq, u32 d_id, u32 s_id, 601 u16 ox_id, u16 rrq_oxid) 602 { 603 fc_els_req_build(fchs, d_id, s_id, ox_id); 604 605 /* 606 * build rrq payload 607 */ 608 memcpy(rrq, &rrq_tmpl, sizeof(struct fc_rrq_s)); 609 rrq->s_id = (s_id); 610 rrq->ox_id = cpu_to_be16(rrq_oxid); 611 rrq->rx_id = FC_RXID_ANY; 612 613 return sizeof(struct fc_rrq_s); 614 } 615 616 u16 617 fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id, 618 __be16 ox_id) 619 { 620 struct fc_els_cmd_s *acc = pld; 621 622 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 623 624 memset(acc, 0, sizeof(struct fc_els_cmd_s)); 625 acc->els_code = FC_ELS_ACC; 626 627 return sizeof(struct fc_els_cmd_s); 628 } 629 630 u16 631 fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt, u32 d_id, 632 u32 s_id, __be16 ox_id, u8 reason_code, 633 u8 reason_code_expl) 634 { 635 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 636 memset(ls_rjt, 0, sizeof(struct fc_ls_rjt_s)); 637 638 ls_rjt->els_cmd.els_code = FC_ELS_LS_RJT; 639 ls_rjt->reason_code = reason_code; 640 ls_rjt->reason_code_expl = reason_code_expl; 641 ls_rjt->vendor_unique = 0x00; 642 643 return sizeof(struct fc_ls_rjt_s); 644 } 645 646 u16 647 fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id, 648 u32 s_id, __be16 ox_id, u16 rx_id) 649 { 650 fc_bls_rsp_build(fchs, d_id, s_id, ox_id); 651 652 memcpy(ba_acc, &ba_acc_tmpl, sizeof(struct fc_ba_acc_s)); 653 654 fchs->rx_id = rx_id; 655 656 ba_acc->ox_id = fchs->ox_id; 657 ba_acc->rx_id = fchs->rx_id; 658 659 return sizeof(struct fc_ba_acc_s); 660 } 661 662 u16 663 fc_ls_acc_build(struct fchs_s *fchs, struct fc_els_cmd_s *els_cmd, u32 d_id, 664 u32 s_id, __be16 ox_id) 665 { 666 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 667 memset(els_cmd, 0, sizeof(struct fc_els_cmd_s)); 668 els_cmd->els_code = FC_ELS_ACC; 669 670 return sizeof(struct fc_els_cmd_s); 671 } 672 673 int 674 fc_logout_params_pages(struct fchs_s *fc_frame, u8 els_code) 675 { 676 int num_pages = 0; 677 struct fc_prlo_s *prlo; 678 struct fc_tprlo_s *tprlo; 679 680 if (els_code == FC_ELS_PRLO) { 681 prlo = (struct fc_prlo_s *) (fc_frame + 1); 682 num_pages = (be16_to_cpu(prlo->payload_len) - 4) / 16; 683 } else { 684 tprlo = (struct fc_tprlo_s *) (fc_frame + 1); 685 num_pages = (be16_to_cpu(tprlo->payload_len) - 4) / 16; 686 } 687 return num_pages; 688 } 689 690 u16 691 fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc, 692 u32 d_id, u32 s_id, __be16 ox_id, int num_pages) 693 { 694 int page; 695 696 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 697 698 memset(tprlo_acc, 0, (num_pages * 16) + 4); 699 tprlo_acc->command = FC_ELS_ACC; 700 701 tprlo_acc->page_len = 0x10; 702 tprlo_acc->payload_len = cpu_to_be16((num_pages * 16) + 4); 703 704 for (page = 0; page < num_pages; page++) { 705 tprlo_acc->tprlo_acc_params[page].opa_valid = 0; 706 tprlo_acc->tprlo_acc_params[page].rpa_valid = 0; 707 tprlo_acc->tprlo_acc_params[page].fc4type_csp = FC_TYPE_FCP; 708 tprlo_acc->tprlo_acc_params[page].orig_process_assc = 0; 709 tprlo_acc->tprlo_acc_params[page].resp_process_assc = 0; 710 } 711 return be16_to_cpu(tprlo_acc->payload_len); 712 } 713 714 u16 715 fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc, u32 d_id, 716 u32 s_id, __be16 ox_id, int num_pages) 717 { 718 int page; 719 720 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 721 722 memset(prlo_acc, 0, (num_pages * 16) + 4); 723 prlo_acc->command = FC_ELS_ACC; 724 prlo_acc->page_len = 0x10; 725 prlo_acc->payload_len = cpu_to_be16((num_pages * 16) + 4); 726 727 for (page = 0; page < num_pages; page++) { 728 prlo_acc->prlo_acc_params[page].opa_valid = 0; 729 prlo_acc->prlo_acc_params[page].rpa_valid = 0; 730 prlo_acc->prlo_acc_params[page].fc4type_csp = FC_TYPE_FCP; 731 prlo_acc->prlo_acc_params[page].orig_process_assc = 0; 732 prlo_acc->prlo_acc_params[page].resp_process_assc = 0; 733 } 734 735 return be16_to_cpu(prlo_acc->payload_len); 736 } 737 738 u16 739 fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid, u32 d_id, 740 u32 s_id, u16 ox_id, u32 data_format) 741 { 742 fc_els_req_build(fchs, d_id, s_id, ox_id); 743 744 memset(rnid, 0, sizeof(struct fc_rnid_cmd_s)); 745 746 rnid->els_cmd.els_code = FC_ELS_RNID; 747 rnid->node_id_data_format = data_format; 748 749 return sizeof(struct fc_rnid_cmd_s); 750 } 751 752 u16 753 fc_rnid_acc_build(struct fchs_s *fchs, struct fc_rnid_acc_s *rnid_acc, u32 d_id, 754 u32 s_id, __be16 ox_id, u32 data_format, 755 struct fc_rnid_common_id_data_s *common_id_data, 756 struct fc_rnid_general_topology_data_s *gen_topo_data) 757 { 758 memset(rnid_acc, 0, sizeof(struct fc_rnid_acc_s)); 759 760 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 761 762 rnid_acc->els_cmd.els_code = FC_ELS_ACC; 763 rnid_acc->node_id_data_format = data_format; 764 rnid_acc->common_id_data_length = 765 sizeof(struct fc_rnid_common_id_data_s); 766 rnid_acc->common_id_data = *common_id_data; 767 768 if (data_format == RNID_NODEID_DATA_FORMAT_DISCOVERY) { 769 rnid_acc->specific_id_data_length = 770 sizeof(struct fc_rnid_general_topology_data_s); 771 rnid_acc->gen_topology_data = *gen_topo_data; 772 return sizeof(struct fc_rnid_acc_s); 773 } else { 774 return sizeof(struct fc_rnid_acc_s) - 775 sizeof(struct fc_rnid_general_topology_data_s); 776 } 777 778 } 779 780 u16 781 fc_rpsc_build(struct fchs_s *fchs, struct fc_rpsc_cmd_s *rpsc, u32 d_id, 782 u32 s_id, u16 ox_id) 783 { 784 fc_els_req_build(fchs, d_id, s_id, ox_id); 785 786 memset(rpsc, 0, sizeof(struct fc_rpsc_cmd_s)); 787 788 rpsc->els_cmd.els_code = FC_ELS_RPSC; 789 return sizeof(struct fc_rpsc_cmd_s); 790 } 791 792 u16 793 fc_rpsc2_build(struct fchs_s *fchs, struct fc_rpsc2_cmd_s *rpsc2, u32 d_id, 794 u32 s_id, u32 *pid_list, u16 npids) 795 { 796 u32 dctlr_id = FC_DOMAIN_CTRLR(bfa_hton3b(d_id)); 797 int i = 0; 798 799 fc_els_req_build(fchs, bfa_hton3b(dctlr_id), s_id, 0); 800 801 memset(rpsc2, 0, sizeof(struct fc_rpsc2_cmd_s)); 802 803 rpsc2->els_cmd.els_code = FC_ELS_RPSC; 804 rpsc2->token = cpu_to_be32(FC_BRCD_TOKEN); 805 rpsc2->num_pids = cpu_to_be16(npids); 806 for (i = 0; i < npids; i++) 807 rpsc2->pid_list[i].pid = pid_list[i]; 808 809 return sizeof(struct fc_rpsc2_cmd_s) + ((npids - 1) * (sizeof(u32))); 810 } 811 812 u16 813 fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc, 814 u32 d_id, u32 s_id, __be16 ox_id, 815 struct fc_rpsc_speed_info_s *oper_speed) 816 { 817 memset(rpsc_acc, 0, sizeof(struct fc_rpsc_acc_s)); 818 819 fc_els_rsp_build(fchs, d_id, s_id, ox_id); 820 821 rpsc_acc->command = FC_ELS_ACC; 822 rpsc_acc->num_entries = cpu_to_be16(1); 823 824 rpsc_acc->speed_info[0].port_speed_cap = 825 cpu_to_be16(oper_speed->port_speed_cap); 826 827 rpsc_acc->speed_info[0].port_op_speed = 828 cpu_to_be16(oper_speed->port_op_speed); 829 830 return sizeof(struct fc_rpsc_acc_s); 831 } 832 833 u16 834 fc_logo_rsp_parse(struct fchs_s *fchs, int len) 835 { 836 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1); 837 838 len = len; 839 if (els_cmd->els_code != FC_ELS_ACC) 840 return FC_PARSE_FAILURE; 841 842 return FC_PARSE_OK; 843 } 844 845 u16 846 fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id, 847 wwn_t port_name, wwn_t node_name, u16 pdu_size) 848 { 849 struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1); 850 851 memcpy(pdisc, &plogi_tmpl, sizeof(struct fc_logi_s)); 852 853 pdisc->els_cmd.els_code = FC_ELS_PDISC; 854 fc_els_req_build(fchs, d_id, s_id, ox_id); 855 856 pdisc->csp.rxsz = pdisc->class3.rxsz = cpu_to_be16(pdu_size); 857 pdisc->port_name = port_name; 858 pdisc->node_name = node_name; 859 860 return sizeof(struct fc_logi_s); 861 } 862 863 u16 864 fc_pdisc_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name) 865 { 866 struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1); 867 868 if (len < sizeof(struct fc_logi_s)) 869 return FC_PARSE_LEN_INVAL; 870 871 if (pdisc->els_cmd.els_code != FC_ELS_ACC) 872 return FC_PARSE_ACC_INVAL; 873 874 if (!wwn_is_equal(pdisc->port_name, port_name)) 875 return FC_PARSE_PWWN_NOT_EQUAL; 876 877 if (!pdisc->class3.class_valid) 878 return FC_PARSE_NWWN_NOT_EQUAL; 879 880 if (be16_to_cpu(pdisc->class3.rxsz) < (FC_MIN_PDUSZ)) 881 return FC_PARSE_RXSZ_INVAL; 882 883 return FC_PARSE_OK; 884 } 885 886 u16 887 fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id, 888 int num_pages) 889 { 890 struct fc_prlo_s *prlo = (struct fc_prlo_s *) (fchs + 1); 891 int page; 892 893 fc_els_req_build(fchs, d_id, s_id, ox_id); 894 memset(prlo, 0, (num_pages * 16) + 4); 895 prlo->command = FC_ELS_PRLO; 896 prlo->page_len = 0x10; 897 prlo->payload_len = cpu_to_be16((num_pages * 16) + 4); 898 899 for (page = 0; page < num_pages; page++) { 900 prlo->prlo_params[page].type = FC_TYPE_FCP; 901 prlo->prlo_params[page].opa_valid = 0; 902 prlo->prlo_params[page].rpa_valid = 0; 903 prlo->prlo_params[page].orig_process_assc = 0; 904 prlo->prlo_params[page].resp_process_assc = 0; 905 } 906 907 return be16_to_cpu(prlo->payload_len); 908 } 909 910 u16 911 fc_prlo_rsp_parse(struct fchs_s *fchs, int len) 912 { 913 struct fc_prlo_acc_s *prlo = (struct fc_prlo_acc_s *) (fchs + 1); 914 int num_pages = 0; 915 int page = 0; 916 917 len = len; 918 919 if (prlo->command != FC_ELS_ACC) 920 return FC_PARSE_FAILURE; 921 922 num_pages = ((be16_to_cpu(prlo->payload_len)) - 4) / 16; 923 924 for (page = 0; page < num_pages; page++) { 925 if (prlo->prlo_acc_params[page].type != FC_TYPE_FCP) 926 return FC_PARSE_FAILURE; 927 928 if (prlo->prlo_acc_params[page].opa_valid != 0) 929 return FC_PARSE_FAILURE; 930 931 if (prlo->prlo_acc_params[page].rpa_valid != 0) 932 return FC_PARSE_FAILURE; 933 934 if (prlo->prlo_acc_params[page].orig_process_assc != 0) 935 return FC_PARSE_FAILURE; 936 937 if (prlo->prlo_acc_params[page].resp_process_assc != 0) 938 return FC_PARSE_FAILURE; 939 } 940 return FC_PARSE_OK; 941 942 } 943 944 u16 945 fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id, 946 int num_pages, enum fc_tprlo_type tprlo_type, u32 tpr_id) 947 { 948 struct fc_tprlo_s *tprlo = (struct fc_tprlo_s *) (fchs + 1); 949 int page; 950 951 fc_els_req_build(fchs, d_id, s_id, ox_id); 952 memset(tprlo, 0, (num_pages * 16) + 4); 953 tprlo->command = FC_ELS_TPRLO; 954 tprlo->page_len = 0x10; 955 tprlo->payload_len = cpu_to_be16((num_pages * 16) + 4); 956 957 for (page = 0; page < num_pages; page++) { 958 tprlo->tprlo_params[page].type = FC_TYPE_FCP; 959 tprlo->tprlo_params[page].opa_valid = 0; 960 tprlo->tprlo_params[page].rpa_valid = 0; 961 tprlo->tprlo_params[page].orig_process_assc = 0; 962 tprlo->tprlo_params[page].resp_process_assc = 0; 963 if (tprlo_type == FC_GLOBAL_LOGO) { 964 tprlo->tprlo_params[page].global_process_logout = 1; 965 } else if (tprlo_type == FC_TPR_LOGO) { 966 tprlo->tprlo_params[page].tpo_nport_valid = 1; 967 tprlo->tprlo_params[page].tpo_nport_id = (tpr_id); 968 } 969 } 970 971 return be16_to_cpu(tprlo->payload_len); 972 } 973 974 u16 975 fc_tprlo_rsp_parse(struct fchs_s *fchs, int len) 976 { 977 struct fc_tprlo_acc_s *tprlo = (struct fc_tprlo_acc_s *) (fchs + 1); 978 int num_pages = 0; 979 int page = 0; 980 981 len = len; 982 983 if (tprlo->command != FC_ELS_ACC) 984 return FC_PARSE_ACC_INVAL; 985 986 num_pages = (be16_to_cpu(tprlo->payload_len) - 4) / 16; 987 988 for (page = 0; page < num_pages; page++) { 989 if (tprlo->tprlo_acc_params[page].type != FC_TYPE_FCP) 990 return FC_PARSE_NOT_FCP; 991 if (tprlo->tprlo_acc_params[page].opa_valid != 0) 992 return FC_PARSE_OPAFLAG_INVAL; 993 if (tprlo->tprlo_acc_params[page].rpa_valid != 0) 994 return FC_PARSE_RPAFLAG_INVAL; 995 if (tprlo->tprlo_acc_params[page].orig_process_assc != 0) 996 return FC_PARSE_OPA_INVAL; 997 if (tprlo->tprlo_acc_params[page].resp_process_assc != 0) 998 return FC_PARSE_RPA_INVAL; 999 } 1000 return FC_PARSE_OK; 1001 } 1002 1003 enum fc_parse_status 1004 fc_rrq_rsp_parse(struct fchs_s *fchs, int len) 1005 { 1006 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1); 1007 1008 len = len; 1009 if (els_cmd->els_code != FC_ELS_ACC) 1010 return FC_PARSE_FAILURE; 1011 1012 return FC_PARSE_OK; 1013 } 1014 1015 u16 1016 fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id, 1017 u32 reason_code, u32 reason_expl) 1018 { 1019 struct fc_ba_rjt_s *ba_rjt = (struct fc_ba_rjt_s *) (fchs + 1); 1020 1021 fc_bls_rsp_build(fchs, d_id, s_id, ox_id); 1022 1023 fchs->cat_info = FC_CAT_BA_RJT; 1024 ba_rjt->reason_code = reason_code; 1025 ba_rjt->reason_expl = reason_expl; 1026 return sizeof(struct fc_ba_rjt_s); 1027 } 1028 1029 static void 1030 fc_gs_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code) 1031 { 1032 memset(cthdr, 0, sizeof(struct ct_hdr_s)); 1033 cthdr->rev_id = CT_GS3_REVISION; 1034 cthdr->gs_type = CT_GSTYPE_DIRSERVICE; 1035 cthdr->gs_sub_type = CT_GSSUBTYPE_NAMESERVER; 1036 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code); 1037 } 1038 1039 static void 1040 fc_gs_fdmi_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code) 1041 { 1042 memset(cthdr, 0, sizeof(struct ct_hdr_s)); 1043 cthdr->rev_id = CT_GS3_REVISION; 1044 cthdr->gs_type = CT_GSTYPE_MGMTSERVICE; 1045 cthdr->gs_sub_type = CT_GSSUBTYPE_HBA_MGMTSERVER; 1046 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code); 1047 } 1048 1049 static void 1050 fc_gs_ms_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code, 1051 u8 sub_type) 1052 { 1053 memset(cthdr, 0, sizeof(struct ct_hdr_s)); 1054 cthdr->rev_id = CT_GS3_REVISION; 1055 cthdr->gs_type = CT_GSTYPE_MGMTSERVICE; 1056 cthdr->gs_sub_type = sub_type; 1057 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code); 1058 } 1059 1060 u16 1061 fc_gidpn_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1062 wwn_t port_name) 1063 { 1064 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1065 struct fcgs_gidpn_req_s *gidpn = (struct fcgs_gidpn_req_s *)(cthdr + 1); 1066 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1067 1068 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1069 fc_gs_cthdr_build(cthdr, s_id, GS_GID_PN); 1070 1071 memset(gidpn, 0, sizeof(struct fcgs_gidpn_req_s)); 1072 gidpn->port_name = port_name; 1073 return sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s); 1074 } 1075 1076 u16 1077 fc_gpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1078 u32 port_id) 1079 { 1080 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1081 fcgs_gpnid_req_t *gpnid = (fcgs_gpnid_req_t *) (cthdr + 1); 1082 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1083 1084 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1085 fc_gs_cthdr_build(cthdr, s_id, GS_GPN_ID); 1086 1087 memset(gpnid, 0, sizeof(fcgs_gpnid_req_t)); 1088 gpnid->dap = port_id; 1089 return sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s); 1090 } 1091 1092 u16 1093 fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1094 u32 port_id) 1095 { 1096 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1097 fcgs_gnnid_req_t *gnnid = (fcgs_gnnid_req_t *) (cthdr + 1); 1098 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1099 1100 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1101 fc_gs_cthdr_build(cthdr, s_id, GS_GNN_ID); 1102 1103 memset(gnnid, 0, sizeof(fcgs_gnnid_req_t)); 1104 gnnid->dap = port_id; 1105 return sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s); 1106 } 1107 1108 u16 1109 fc_ct_rsp_parse(struct ct_hdr_s *cthdr) 1110 { 1111 if (be16_to_cpu(cthdr->cmd_rsp_code) != CT_RSP_ACCEPT) { 1112 if (cthdr->reason_code == CT_RSN_LOGICAL_BUSY) 1113 return FC_PARSE_BUSY; 1114 else 1115 return FC_PARSE_FAILURE; 1116 } 1117 1118 return FC_PARSE_OK; 1119 } 1120 1121 u16 1122 fc_gs_rjt_build(struct fchs_s *fchs, struct ct_hdr_s *cthdr, 1123 u32 d_id, u32 s_id, u16 ox_id, u8 reason_code, 1124 u8 reason_code_expl) 1125 { 1126 fc_gsresp_fchdr_build(fchs, d_id, s_id, ox_id); 1127 1128 cthdr->cmd_rsp_code = cpu_to_be16(CT_RSP_REJECT); 1129 cthdr->rev_id = CT_GS3_REVISION; 1130 1131 cthdr->reason_code = reason_code; 1132 cthdr->exp_code = reason_code_expl; 1133 return sizeof(struct ct_hdr_s); 1134 } 1135 1136 u16 1137 fc_scr_build(struct fchs_s *fchs, struct fc_scr_s *scr, 1138 u8 set_br_reg, u32 s_id, u16 ox_id) 1139 { 1140 u32 d_id = bfa_hton3b(FC_FABRIC_CONTROLLER); 1141 1142 fc_els_req_build(fchs, d_id, s_id, ox_id); 1143 1144 memset(scr, 0, sizeof(struct fc_scr_s)); 1145 scr->command = FC_ELS_SCR; 1146 scr->reg_func = FC_SCR_REG_FUNC_FULL; 1147 if (set_br_reg) 1148 scr->vu_reg_func = FC_VU_SCR_REG_FUNC_FABRIC_NAME_CHANGE; 1149 1150 return sizeof(struct fc_scr_s); 1151 } 1152 1153 u16 1154 fc_rscn_build(struct fchs_s *fchs, struct fc_rscn_pl_s *rscn, 1155 u32 s_id, u16 ox_id) 1156 { 1157 u32 d_id = bfa_hton3b(FC_FABRIC_CONTROLLER); 1158 u16 payldlen; 1159 1160 fc_els_req_build(fchs, d_id, s_id, ox_id); 1161 rscn->command = FC_ELS_RSCN; 1162 rscn->pagelen = sizeof(rscn->event[0]); 1163 1164 payldlen = sizeof(u32) + rscn->pagelen; 1165 rscn->payldlen = cpu_to_be16(payldlen); 1166 1167 rscn->event[0].format = FC_RSCN_FORMAT_PORTID; 1168 rscn->event[0].portid = s_id; 1169 1170 return sizeof(struct fc_rscn_pl_s); 1171 } 1172 1173 u16 1174 fc_rftid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1175 enum bfa_lport_role roles) 1176 { 1177 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1178 struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1); 1179 u32 type_value, d_id = bfa_hton3b(FC_NAME_SERVER); 1180 u8 index; 1181 1182 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1183 fc_gs_cthdr_build(cthdr, s_id, GS_RFT_ID); 1184 1185 memset(rftid, 0, sizeof(struct fcgs_rftid_req_s)); 1186 1187 rftid->dap = s_id; 1188 1189 /* By default, FCP FC4 Type is registered */ 1190 index = FC_TYPE_FCP >> 5; 1191 type_value = 1 << (FC_TYPE_FCP % 32); 1192 rftid->fc4_type[index] = cpu_to_be32(type_value); 1193 1194 return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s); 1195 } 1196 1197 u16 1198 fc_rftid_build_sol(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1199 u8 *fc4_bitmap, u32 bitmap_size) 1200 { 1201 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1202 struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1); 1203 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1204 1205 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1206 fc_gs_cthdr_build(cthdr, s_id, GS_RFT_ID); 1207 1208 memset(rftid, 0, sizeof(struct fcgs_rftid_req_s)); 1209 1210 rftid->dap = s_id; 1211 memcpy((void *)rftid->fc4_type, (void *)fc4_bitmap, 1212 (bitmap_size < 32 ? bitmap_size : 32)); 1213 1214 return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s); 1215 } 1216 1217 u16 1218 fc_rffid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1219 u8 fc4_type, u8 fc4_ftrs) 1220 { 1221 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1222 struct fcgs_rffid_req_s *rffid = (struct fcgs_rffid_req_s *)(cthdr + 1); 1223 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1224 1225 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1226 fc_gs_cthdr_build(cthdr, s_id, GS_RFF_ID); 1227 1228 memset(rffid, 0, sizeof(struct fcgs_rffid_req_s)); 1229 1230 rffid->dap = s_id; 1231 rffid->fc4ftr_bits = fc4_ftrs; 1232 rffid->fc4_type = fc4_type; 1233 1234 return sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s); 1235 } 1236 1237 u16 1238 fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id, 1239 u8 *name) 1240 { 1241 1242 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1243 struct fcgs_rspnid_req_s *rspnid = 1244 (struct fcgs_rspnid_req_s *)(cthdr + 1); 1245 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1246 1247 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id); 1248 fc_gs_cthdr_build(cthdr, s_id, GS_RSPN_ID); 1249 1250 memset(rspnid, 0, sizeof(struct fcgs_rspnid_req_s)); 1251 1252 rspnid->dap = s_id; 1253 rspnid->spn_len = (u8) strlen((char *)name); 1254 strncpy((char *)rspnid->spn, (char *)name, rspnid->spn_len); 1255 1256 return sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s); 1257 } 1258 1259 u16 1260 fc_rsnn_nn_build(struct fchs_s *fchs, void *pyld, u32 s_id, 1261 wwn_t node_name, u8 *name) 1262 { 1263 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1264 struct fcgs_rsnn_nn_req_s *rsnn_nn = 1265 (struct fcgs_rsnn_nn_req_s *) (cthdr + 1); 1266 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1267 1268 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1269 fc_gs_cthdr_build(cthdr, s_id, GS_RSNN_NN); 1270 1271 memset(rsnn_nn, 0, sizeof(struct fcgs_rsnn_nn_req_s)); 1272 1273 rsnn_nn->node_name = node_name; 1274 rsnn_nn->snn_len = (u8) strlen((char *)name); 1275 strncpy((char *)rsnn_nn->snn, (char *)name, rsnn_nn->snn_len); 1276 1277 return sizeof(struct fcgs_rsnn_nn_req_s) + sizeof(struct ct_hdr_s); 1278 } 1279 1280 u16 1281 fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type) 1282 { 1283 1284 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1285 struct fcgs_gidft_req_s *gidft = (struct fcgs_gidft_req_s *)(cthdr + 1); 1286 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1287 1288 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1289 1290 fc_gs_cthdr_build(cthdr, s_id, GS_GID_FT); 1291 1292 memset(gidft, 0, sizeof(struct fcgs_gidft_req_s)); 1293 gidft->fc4_type = fc4_type; 1294 gidft->domain_id = 0; 1295 gidft->area_id = 0; 1296 1297 return sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s); 1298 } 1299 1300 u16 1301 fc_rpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id, 1302 wwn_t port_name) 1303 { 1304 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1305 struct fcgs_rpnid_req_s *rpnid = (struct fcgs_rpnid_req_s *)(cthdr + 1); 1306 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1307 1308 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1309 fc_gs_cthdr_build(cthdr, s_id, GS_RPN_ID); 1310 1311 memset(rpnid, 0, sizeof(struct fcgs_rpnid_req_s)); 1312 rpnid->port_id = port_id; 1313 rpnid->port_name = port_name; 1314 1315 return sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s); 1316 } 1317 1318 u16 1319 fc_rnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id, 1320 wwn_t node_name) 1321 { 1322 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1323 struct fcgs_rnnid_req_s *rnnid = (struct fcgs_rnnid_req_s *)(cthdr + 1); 1324 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1325 1326 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1327 fc_gs_cthdr_build(cthdr, s_id, GS_RNN_ID); 1328 1329 memset(rnnid, 0, sizeof(struct fcgs_rnnid_req_s)); 1330 rnnid->port_id = port_id; 1331 rnnid->node_name = node_name; 1332 1333 return sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s); 1334 } 1335 1336 u16 1337 fc_rcsid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id, 1338 u32 cos) 1339 { 1340 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1341 struct fcgs_rcsid_req_s *rcsid = 1342 (struct fcgs_rcsid_req_s *) (cthdr + 1); 1343 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1344 1345 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1346 fc_gs_cthdr_build(cthdr, s_id, GS_RCS_ID); 1347 1348 memset(rcsid, 0, sizeof(struct fcgs_rcsid_req_s)); 1349 rcsid->port_id = port_id; 1350 rcsid->cos = cos; 1351 1352 return sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s); 1353 } 1354 1355 u16 1356 fc_rptid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id, 1357 u8 port_type) 1358 { 1359 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1360 struct fcgs_rptid_req_s *rptid = (struct fcgs_rptid_req_s *)(cthdr + 1); 1361 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1362 1363 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1364 fc_gs_cthdr_build(cthdr, s_id, GS_RPT_ID); 1365 1366 memset(rptid, 0, sizeof(struct fcgs_rptid_req_s)); 1367 rptid->port_id = port_id; 1368 rptid->port_type = port_type; 1369 1370 return sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s); 1371 } 1372 1373 u16 1374 fc_ganxt_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id) 1375 { 1376 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1377 struct fcgs_ganxt_req_s *ganxt = (struct fcgs_ganxt_req_s *)(cthdr + 1); 1378 u32 d_id = bfa_hton3b(FC_NAME_SERVER); 1379 1380 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1381 fc_gs_cthdr_build(cthdr, s_id, GS_GA_NXT); 1382 1383 memset(ganxt, 0, sizeof(struct fcgs_ganxt_req_s)); 1384 ganxt->port_id = port_id; 1385 1386 return sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s); 1387 } 1388 1389 /* 1390 * Builds fc hdr and ct hdr for FDMI requests. 1391 */ 1392 u16 1393 fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id, 1394 u16 cmd_code) 1395 { 1396 1397 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1398 u32 d_id = bfa_hton3b(FC_MGMT_SERVER); 1399 1400 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1401 fc_gs_fdmi_cthdr_build(cthdr, s_id, cmd_code); 1402 1403 return sizeof(struct ct_hdr_s); 1404 } 1405 1406 /* 1407 * Given a FC4 Type, this function returns a fc4 type bitmask 1408 */ 1409 void 1410 fc_get_fc4type_bitmask(u8 fc4_type, u8 *bit_mask) 1411 { 1412 u8 index; 1413 __be32 *ptr = (__be32 *) bit_mask; 1414 u32 type_value; 1415 1416 /* 1417 * @todo : Check for bitmask size 1418 */ 1419 1420 index = fc4_type >> 5; 1421 type_value = 1 << (fc4_type % 32); 1422 ptr[index] = cpu_to_be32(type_value); 1423 1424 } 1425 1426 /* 1427 * GMAL Request 1428 */ 1429 u16 1430 fc_gmal_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn) 1431 { 1432 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1433 fcgs_gmal_req_t *gmal = (fcgs_gmal_req_t *) (cthdr + 1); 1434 u32 d_id = bfa_hton3b(FC_MGMT_SERVER); 1435 1436 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1437 fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GMAL_CMD, 1438 CT_GSSUBTYPE_CFGSERVER); 1439 1440 memset(gmal, 0, sizeof(fcgs_gmal_req_t)); 1441 gmal->wwn = wwn; 1442 1443 return sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t); 1444 } 1445 1446 /* 1447 * GFN (Get Fabric Name) Request 1448 */ 1449 u16 1450 fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn) 1451 { 1452 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld; 1453 fcgs_gfn_req_t *gfn = (fcgs_gfn_req_t *) (cthdr + 1); 1454 u32 d_id = bfa_hton3b(FC_MGMT_SERVER); 1455 1456 fc_gs_fchdr_build(fchs, d_id, s_id, 0); 1457 fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GFN_CMD, 1458 CT_GSSUBTYPE_CFGSERVER); 1459 1460 memset(gfn, 0, sizeof(fcgs_gfn_req_t)); 1461 gfn->wwn = wwn; 1462 1463 return sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t); 1464 } 1465