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, els_code: 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, els_code: 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, els_code: 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, els_code: 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, ox_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, cmd_code: 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, cmd_code: 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, cmd_code: 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 struct_size(rscn, event, 1); |
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, cmd_code: 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, cmd_code: 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, cmd_code: 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, cmd_code: GS_RSPN_ID); |
1133 | |
1134 | memset(rspnid, 0, sizeof(struct fcgs_rspnid_req_s)); |
1135 | |
1136 | rspnid->dap = s_id; |
1137 | strscpy(p: rspnid->spn, q: name, size: 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, ox_id: 0); |
1153 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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 | strscpy(p: rsnn_nn->snn, q: name, size: 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, ox_id: 0); |
1173 | |
1174 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_id: 0); |
1193 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_id: 0); |
1211 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_id: 0); |
1230 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_id: 0); |
1248 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_id: 0); |
1265 | fc_gs_cthdr_build(cthdr, s_id, cmd_code: 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, ox_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, ox_id: 0); |
1321 | fc_gs_ms_cthdr_build(cthdr, s_id, cmd_code: GS_FC_GMAL_CMD, |
1322 | sub_type: 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, ox_id: 0); |
1341 | fc_gs_ms_cthdr_build(cthdr, s_id, cmd_code: GS_FC_GFN_CMD, |
1342 | sub_type: 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 | } |
1349 | |