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
fcbuild_init(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
fc_gs_fchdr_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u32 ox_id)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
fc_gsresp_fchdr_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u16 ox_id)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
fc_els_req_build(struct fchs_s * fchs,u32 d_id,u32 s_id,__be16 ox_id)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
fc_els_rsp_build(struct fchs_s * fchs,u32 d_id,u32 s_id,__be16 ox_id)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
fc_bls_rsp_build(struct fchs_s * fchs,u32 d_id,u32 s_id,__be16 ox_id)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
fc_plogi_x_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,__be16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size,u16 bb_cr,u8 els_code)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
fc_flogi_build(struct fchs_s * fchs,struct fc_logi_s * flogi,u32 s_id,u16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size,u8 set_npiv,u8 set_auth,u16 local_bb_credits)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
fc_flogi_acc_build(struct fchs_s * fchs,struct fc_logi_s * flogi,u32 s_id,__be16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size,u16 local_bb_credits,u8 bb_scn)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
fc_fdisc_build(struct fchs_s * fchs,struct fc_logi_s * flogi,u32 s_id,u16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size)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
fc_plogi_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,u16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size,u16 bb_cr)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
fc_plogi_acc_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,u16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size,u16 bb_cr)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
fc_plogi_rsp_parse(struct fchs_s * fchs,int len,wwn_t port_name)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
fc_plogi_parse(struct fchs_s * fchs)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
fc_prli_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,u16 ox_id)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
fc_prli_acc_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,__be16 ox_id,enum bfa_lport_role role)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
fc_prli_rsp_parse(struct fc_prli_s * prli,int len)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
fc_prli_parse(struct fc_prli_s * prli)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
fc_logo_build(struct fchs_s * fchs,struct fc_logo_s * logo,u32 d_id,u32 s_id,u16 ox_id,wwn_t port_name)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
fc_adisc_x_build(struct fchs_s * fchs,struct fc_adisc_s * adisc,u32 d_id,u32 s_id,__be16 ox_id,wwn_t port_name,wwn_t node_name,u8 els_code)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
fc_adisc_build(struct fchs_s * fchs,struct fc_adisc_s * adisc,u32 d_id,u32 s_id,__be16 ox_id,wwn_t port_name,wwn_t node_name)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
fc_adisc_acc_build(struct fchs_s * fchs,struct fc_adisc_s * adisc,u32 d_id,u32 s_id,__be16 ox_id,wwn_t port_name,wwn_t node_name)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
fc_adisc_rsp_parse(struct fc_adisc_s * adisc,int len,wwn_t port_name,wwn_t node_name)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
fc_adisc_parse(struct fchs_s * fchs,void * pld,u32 host_dap,wwn_t node_name,wwn_t port_name)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
fc_pdisc_parse(struct fchs_s * fchs,wwn_t node_name,wwn_t port_name)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
fc_abts_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u16 ox_id)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
fc_abts_rsp_parse(struct fchs_s * fchs,int len)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
fc_rrq_build(struct fchs_s * fchs,struct fc_rrq_s * rrq,u32 d_id,u32 s_id,u16 ox_id,u16 rrq_oxid)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
fc_logo_acc_build(struct fchs_s * fchs,void * pld,u32 d_id,u32 s_id,__be16 ox_id)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
fc_ls_rjt_build(struct fchs_s * fchs,struct fc_ls_rjt_s * ls_rjt,u32 d_id,u32 s_id,__be16 ox_id,u8 reason_code,u8 reason_code_expl)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
fc_ba_acc_build(struct fchs_s * fchs,struct fc_ba_acc_s * ba_acc,u32 d_id,u32 s_id,__be16 ox_id,u16 rx_id)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
fc_ls_acc_build(struct fchs_s * fchs,struct fc_els_cmd_s * els_cmd,u32 d_id,u32 s_id,__be16 ox_id)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
fc_logout_params_pages(struct fchs_s * fc_frame,u8 els_code)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
fc_tprlo_acc_build(struct fchs_s * fchs,struct fc_tprlo_acc_s * tprlo_acc,u32 d_id,u32 s_id,__be16 ox_id,int num_pages)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
fc_prlo_acc_build(struct fchs_s * fchs,struct fc_prlo_acc_s * prlo_acc,u32 d_id,u32 s_id,__be16 ox_id,int num_pages)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
fc_rnid_build(struct fchs_s * fchs,struct fc_rnid_cmd_s * rnid,u32 d_id,u32 s_id,u16 ox_id,u32 data_format)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
fc_rnid_acc_build(struct fchs_s * fchs,struct fc_rnid_acc_s * rnid_acc,u32 d_id,u32 s_id,__be16 ox_id,u32 data_format,struct fc_rnid_common_id_data_s * common_id_data,struct fc_rnid_general_topology_data_s * gen_topo_data)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
fc_rpsc_build(struct fchs_s * fchs,struct fc_rpsc_cmd_s * rpsc,u32 d_id,u32 s_id,u16 ox_id)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
fc_rpsc2_build(struct fchs_s * fchs,struct fc_rpsc2_cmd_s * rpsc2,u32 d_id,u32 s_id,u32 * pid_list,u16 npids)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
fc_rpsc_acc_build(struct fchs_s * fchs,struct fc_rpsc_acc_s * rpsc_acc,u32 d_id,u32 s_id,__be16 ox_id,struct fc_rpsc_speed_info_s * oper_speed)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
fc_pdisc_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u16 ox_id,wwn_t port_name,wwn_t node_name,u16 pdu_size)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
fc_pdisc_rsp_parse(struct fchs_s * fchs,int len,wwn_t port_name)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
fc_prlo_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u16 ox_id,int num_pages)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
fc_tprlo_build(struct fchs_s * fchs,u32 d_id,u32 s_id,u16 ox_id,int num_pages,enum fc_tprlo_type tprlo_type,u32 tpr_id)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
fc_ba_rjt_build(struct fchs_s * fchs,u32 d_id,u32 s_id,__be16 ox_id,u32 reason_code,u32 reason_expl)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
fc_gs_cthdr_build(struct ct_hdr_s * cthdr,u32 s_id,u16 cmd_code)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
fc_gs_fdmi_cthdr_build(struct ct_hdr_s * cthdr,u32 s_id,u16 cmd_code)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
fc_gs_ms_cthdr_build(struct ct_hdr_s * cthdr,u32 s_id,u16 cmd_code,u8 sub_type)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
fc_gidpn_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,wwn_t port_name)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
fc_gpnid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,u32 port_id)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
fc_gnnid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,u32 port_id)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
fc_ct_rsp_parse(struct ct_hdr_s * cthdr)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
fc_gs_rjt_build(struct fchs_s * fchs,struct ct_hdr_s * cthdr,u32 d_id,u32 s_id,u16 ox_id,u8 reason_code,u8 reason_code_expl)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
fc_scr_build(struct fchs_s * fchs,struct fc_scr_s * scr,u8 set_br_reg,u32 s_id,u16 ox_id)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
fc_rscn_build(struct fchs_s * fchs,struct fc_rscn_pl_s * rscn,u32 s_id,u16 ox_id)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
fc_rftid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,enum bfa_lport_role roles)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
fc_rftid_build_sol(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,u8 * fc4_bitmap,u32 bitmap_size)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
fc_rffid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,u8 fc4_type,u8 fc4_ftrs)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
fc_rspnid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 ox_id,u8 * name)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
fc_rsnn_nn_build(struct fchs_s * fchs,void * pyld,u32 s_id,wwn_t node_name,u8 * name)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
fc_gid_ft_build(struct fchs_s * fchs,void * pyld,u32 s_id,u8 fc4_type)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
fc_rpnid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u32 port_id,wwn_t port_name)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
fc_rnnid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u32 port_id,wwn_t node_name)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
fc_rcsid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u32 port_id,u32 cos)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
fc_rptid_build(struct fchs_s * fchs,void * pyld,u32 s_id,u32 port_id,u8 port_type)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
fc_ganxt_build(struct fchs_s * fchs,void * pyld,u32 s_id,u32 port_id)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
fc_fdmi_reqhdr_build(struct fchs_s * fchs,void * pyld,u32 s_id,u16 cmd_code)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
fc_get_fc4type_bitmask(u8 fc4_type,u8 * bit_mask)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
fc_gmal_req_build(struct fchs_s * fchs,void * pyld,u32 s_id,wwn_t wwn)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
fc_gfn_req_build(struct fchs_s * fchs,void * pyld,u32 s_id,wwn_t wwn)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 }
1349