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