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