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