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