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