?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ipv4: fix ip_rt_update_pmtu()
[linux/fpc-iii.git] / drivers / scsi / bfa / bfa_fcbuild.c
blobb7e253451654774f89c48cd6d428a557690a222f
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 u16
811 fc_logo_rsp_parse(struct fchs_s *fchs, int len)
812 {
813 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
814
815 len = len;
816 if (els_cmd->els_code != FC_ELS_ACC)
817 return FC_PARSE_FAILURE;
818
819 return FC_PARSE_OK;
820 }
821
822 u16
823 fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
824 wwn_t port_name, wwn_t node_name, u16 pdu_size)
825 {
826 struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1);
827
828 memcpy(pdisc, &plogi_tmpl, sizeof(struct fc_logi_s));
829
830 pdisc->els_cmd.els_code = FC_ELS_PDISC;
831 fc_els_req_build(fchs, d_id, s_id, ox_id);
832
833 pdisc->csp.rxsz = pdisc->class3.rxsz = cpu_to_be16(pdu_size);
834 pdisc->port_name = port_name;
835 pdisc->node_name = node_name;
836
837 return sizeof(struct fc_logi_s);
838 }
839
840 u16
841 fc_pdisc_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name)
842 {
843 struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1);
844
845 if (len < sizeof(struct fc_logi_s))
846 return FC_PARSE_LEN_INVAL;
847
848 if (pdisc->els_cmd.els_code != FC_ELS_ACC)
849 return FC_PARSE_ACC_INVAL;
850
851 if (!wwn_is_equal(pdisc->port_name, port_name))
852 return FC_PARSE_PWWN_NOT_EQUAL;
853
854 if (!pdisc->class3.class_valid)
855 return FC_PARSE_NWWN_NOT_EQUAL;
856
857 if (be16_to_cpu(pdisc->class3.rxsz) < (FC_MIN_PDUSZ))
858 return FC_PARSE_RXSZ_INVAL;
859
860 return FC_PARSE_OK;
861 }
862
863 u16
864 fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
865 int num_pages)
866 {
867 struct fc_prlo_s *prlo = (struct fc_prlo_s *) (fchs + 1);
868 int page;
869
870 fc_els_req_build(fchs, d_id, s_id, ox_id);
871 memset(prlo, 0, (num_pages * 16) + 4);
872 prlo->command = FC_ELS_PRLO;
873 prlo->page_len = 0x10;
874 prlo->payload_len = cpu_to_be16((num_pages * 16) + 4);
875
876 for (page = 0; page < num_pages; page++) {
877 prlo->prlo_params[page].type = FC_TYPE_FCP;
878 prlo->prlo_params[page].opa_valid = 0;
879 prlo->prlo_params[page].rpa_valid = 0;
880 prlo->prlo_params[page].orig_process_assc = 0;
881 prlo->prlo_params[page].resp_process_assc = 0;
882 }
883
884 return be16_to_cpu(prlo->payload_len);
885 }
886
887 u16
888 fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
889 {
890 struct fc_prlo_acc_s *prlo = (struct fc_prlo_acc_s *) (fchs + 1);
891 int num_pages = 0;
892 int page = 0;
893
894 len = len;
895
896 if (prlo->command != FC_ELS_ACC)
897 return FC_PARSE_FAILURE;
898
899 num_pages = ((be16_to_cpu(prlo->payload_len)) - 4) / 16;
900
901 for (page = 0; page < num_pages; page++) {
902 if (prlo->prlo_acc_params[page].type != FC_TYPE_FCP)
903 return FC_PARSE_FAILURE;
904
905 if (prlo->prlo_acc_params[page].opa_valid != 0)
906 return FC_PARSE_FAILURE;
907
908 if (prlo->prlo_acc_params[page].rpa_valid != 0)
909 return FC_PARSE_FAILURE;
910
911 if (prlo->prlo_acc_params[page].orig_process_assc != 0)
912 return FC_PARSE_FAILURE;
913
914 if (prlo->prlo_acc_params[page].resp_process_assc != 0)
915 return FC_PARSE_FAILURE;
916 }
917 return FC_PARSE_OK;
918
919 }
920
921 u16
922 fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
923 int num_pages, enum fc_tprlo_type tprlo_type, u32 tpr_id)
924 {
925 struct fc_tprlo_s *tprlo = (struct fc_tprlo_s *) (fchs + 1);
926 int page;
927
928 fc_els_req_build(fchs, d_id, s_id, ox_id);
929 memset(tprlo, 0, (num_pages * 16) + 4);
930 tprlo->command = FC_ELS_TPRLO;
931 tprlo->page_len = 0x10;
932 tprlo->payload_len = cpu_to_be16((num_pages * 16) + 4);
933
934 for (page = 0; page < num_pages; page++) {
935 tprlo->tprlo_params[page].type = FC_TYPE_FCP;
936 tprlo->tprlo_params[page].opa_valid = 0;
937 tprlo->tprlo_params[page].rpa_valid = 0;
938 tprlo->tprlo_params[page].orig_process_assc = 0;
939 tprlo->tprlo_params[page].resp_process_assc = 0;
940 if (tprlo_type == FC_GLOBAL_LOGO) {
941 tprlo->tprlo_params[page].global_process_logout = 1;
942 } else if (tprlo_type == FC_TPR_LOGO) {
943 tprlo->tprlo_params[page].tpo_nport_valid = 1;
944 tprlo->tprlo_params[page].tpo_nport_id = (tpr_id);
945 }
946 }
947
948 return be16_to_cpu(tprlo->payload_len);
949 }
950
951 u16
952 fc_tprlo_rsp_parse(struct fchs_s *fchs, int len)
953 {
954 struct fc_tprlo_acc_s *tprlo = (struct fc_tprlo_acc_s *) (fchs + 1);
955 int num_pages = 0;
956 int page = 0;
957
958 len = len;
959
960 if (tprlo->command != FC_ELS_ACC)
961 return FC_PARSE_ACC_INVAL;
962
963 num_pages = (be16_to_cpu(tprlo->payload_len) - 4) / 16;
964
965 for (page = 0; page < num_pages; page++) {
966 if (tprlo->tprlo_acc_params[page].type != FC_TYPE_FCP)
967 return FC_PARSE_NOT_FCP;
968 if (tprlo->tprlo_acc_params[page].opa_valid != 0)
969 return FC_PARSE_OPAFLAG_INVAL;
970 if (tprlo->tprlo_acc_params[page].rpa_valid != 0)
971 return FC_PARSE_RPAFLAG_INVAL;
972 if (tprlo->tprlo_acc_params[page].orig_process_assc != 0)
973 return FC_PARSE_OPA_INVAL;
974 if (tprlo->tprlo_acc_params[page].resp_process_assc != 0)
975 return FC_PARSE_RPA_INVAL;
976 }
977 return FC_PARSE_OK;
978 }
979
980 enum fc_parse_status
981 fc_rrq_rsp_parse(struct fchs_s *fchs, int len)
982 {
983 struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
984
985 len = len;
986 if (els_cmd->els_code != FC_ELS_ACC)
987 return FC_PARSE_FAILURE;
988
989 return FC_PARSE_OK;
990 }
991
992 u16
993 fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id,
994 u32 reason_code, u32 reason_expl)
995 {
996 struct fc_ba_rjt_s *ba_rjt = (struct fc_ba_rjt_s *) (fchs + 1);
997
998 fc_bls_rsp_build(fchs, d_id, s_id, ox_id);
999
1000 fchs->cat_info = FC_CAT_BA_RJT;
1001 ba_rjt->reason_code = reason_code;
1002 ba_rjt->reason_expl = reason_expl;
1003 return sizeof(struct fc_ba_rjt_s);
1004 }
1005
1006 static void
1007 fc_gs_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code)
1008 {
1009 memset(cthdr, 0, sizeof(struct ct_hdr_s));
1010 cthdr->rev_id = CT_GS3_REVISION;
1011 cthdr->gs_type = CT_GSTYPE_DIRSERVICE;
1012 cthdr->gs_sub_type = CT_GSSUBTYPE_NAMESERVER;
1013 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code);
1014 }
1015
1016 static void
1017 fc_gs_fdmi_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code)
1018 {
1019 memset(cthdr, 0, sizeof(struct ct_hdr_s));
1020 cthdr->rev_id = CT_GS3_REVISION;
1021 cthdr->gs_type = CT_GSTYPE_MGMTSERVICE;
1022 cthdr->gs_sub_type = CT_GSSUBTYPE_HBA_MGMTSERVER;
1023 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code);
1024 }
1025
1026 static void
1027 fc_gs_ms_cthdr_build(struct ct_hdr_s *cthdr, u32 s_id, u16 cmd_code,
1028 u8 sub_type)
1029 {
1030 memset(cthdr, 0, sizeof(struct ct_hdr_s));
1031 cthdr->rev_id = CT_GS3_REVISION;
1032 cthdr->gs_type = CT_GSTYPE_MGMTSERVICE;
1033 cthdr->gs_sub_type = sub_type;
1034 cthdr->cmd_rsp_code = cpu_to_be16(cmd_code);
1035 }
1036
1037 u16
1038 fc_gidpn_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1039 wwn_t port_name)
1040 {
1041 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1042 struct fcgs_gidpn_req_s *gidpn = (struct fcgs_gidpn_req_s *)(cthdr + 1);
1043 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1044
1045 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1046 fc_gs_cthdr_build(cthdr, s_id, GS_GID_PN);
1047
1048 memset(gidpn, 0, sizeof(struct fcgs_gidpn_req_s));
1049 gidpn->port_name = port_name;
1050 return sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s);
1051 }
1052
1053 u16
1054 fc_gpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1055 u32 port_id)
1056 {
1057 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1058 fcgs_gpnid_req_t *gpnid = (fcgs_gpnid_req_t *) (cthdr + 1);
1059 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1060
1061 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1062 fc_gs_cthdr_build(cthdr, s_id, GS_GPN_ID);
1063
1064 memset(gpnid, 0, sizeof(fcgs_gpnid_req_t));
1065 gpnid->dap = port_id;
1066 return sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s);
1067 }
1068
1069 u16
1070 fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1071 u32 port_id)
1072 {
1073 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1074 fcgs_gnnid_req_t *gnnid = (fcgs_gnnid_req_t *) (cthdr + 1);
1075 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1076
1077 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1078 fc_gs_cthdr_build(cthdr, s_id, GS_GNN_ID);
1079
1080 memset(gnnid, 0, sizeof(fcgs_gnnid_req_t));
1081 gnnid->dap = port_id;
1082 return sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s);
1083 }
1084
1085 u16
1086 fc_ct_rsp_parse(struct ct_hdr_s *cthdr)
1087 {
1088 if (be16_to_cpu(cthdr->cmd_rsp_code) != CT_RSP_ACCEPT) {
1089 if (cthdr->reason_code == CT_RSN_LOGICAL_BUSY)
1090 return FC_PARSE_BUSY;
1091 else
1092 return FC_PARSE_FAILURE;
1093 }
1094
1095 return FC_PARSE_OK;
1096 }
1097
1098 u16
1099 fc_scr_build(struct fchs_s *fchs, struct fc_scr_s *scr,
1100 u8 set_br_reg, u32 s_id, u16 ox_id)
1101 {
1102 u32 d_id = bfa_hton3b(FC_FABRIC_CONTROLLER);
1103
1104 fc_els_req_build(fchs, d_id, s_id, ox_id);
1105
1106 memset(scr, 0, sizeof(struct fc_scr_s));
1107 scr->command = FC_ELS_SCR;
1108 scr->reg_func = FC_SCR_REG_FUNC_FULL;
1109 if (set_br_reg)
1110 scr->vu_reg_func = FC_VU_SCR_REG_FUNC_FABRIC_NAME_CHANGE;
1111
1112 return sizeof(struct fc_scr_s);
1113 }
1114
1115 u16
1116 fc_rscn_build(struct fchs_s *fchs, struct fc_rscn_pl_s *rscn,
1117 u32 s_id, u16 ox_id)
1118 {
1119 u32 d_id = bfa_hton3b(FC_FABRIC_CONTROLLER);
1120 u16 payldlen;
1121
1122 fc_els_req_build(fchs, d_id, s_id, ox_id);
1123 rscn->command = FC_ELS_RSCN;
1124 rscn->pagelen = sizeof(rscn->event[0]);
1125
1126 payldlen = sizeof(u32) + rscn->pagelen;
1127 rscn->payldlen = cpu_to_be16(payldlen);
1128
1129 rscn->event[0].format = FC_RSCN_FORMAT_PORTID;
1130 rscn->event[0].portid = s_id;
1131
1132 return sizeof(struct fc_rscn_pl_s);
1133 }
1134
1135 u16
1136 fc_rftid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1137 enum bfa_lport_role roles)
1138 {
1139 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1140 struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1);
1141 u32 type_value, d_id = bfa_hton3b(FC_NAME_SERVER);
1142 u8 index;
1143
1144 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1145 fc_gs_cthdr_build(cthdr, s_id, GS_RFT_ID);
1146
1147 memset(rftid, 0, sizeof(struct fcgs_rftid_req_s));
1148
1149 rftid->dap = s_id;
1150
1151 /* By default, FCP FC4 Type is registered */
1152 index = FC_TYPE_FCP >> 5;
1153 type_value = 1 << (FC_TYPE_FCP % 32);
1154 rftid->fc4_type[index] = cpu_to_be32(type_value);
1155
1156 return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
1157 }
1158
1159 u16
1160 fc_rftid_build_sol(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1161 u8 *fc4_bitmap, u32 bitmap_size)
1162 {
1163 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1164 struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1);
1165 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1166
1167 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1168 fc_gs_cthdr_build(cthdr, s_id, GS_RFT_ID);
1169
1170 memset(rftid, 0, sizeof(struct fcgs_rftid_req_s));
1171
1172 rftid->dap = s_id;
1173 memcpy((void *)rftid->fc4_type, (void *)fc4_bitmap,
1174 (bitmap_size < 32 ? bitmap_size : 32));
1175
1176 return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
1177 }
1178
1179 u16
1180 fc_rffid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1181 u8 fc4_type, u8 fc4_ftrs)
1182 {
1183 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1184 struct fcgs_rffid_req_s *rffid = (struct fcgs_rffid_req_s *)(cthdr + 1);
1185 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1186
1187 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1188 fc_gs_cthdr_build(cthdr, s_id, GS_RFF_ID);
1189
1190 memset(rffid, 0, sizeof(struct fcgs_rffid_req_s));
1191
1192 rffid->dap = s_id;
1193 rffid->fc4ftr_bits = fc4_ftrs;
1194 rffid->fc4_type = fc4_type;
1195
1196 return sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s);
1197 }
1198
1199 u16
1200 fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1201 u8 *name)
1202 {
1203
1204 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1205 struct fcgs_rspnid_req_s *rspnid =
1206 (struct fcgs_rspnid_req_s *)(cthdr + 1);
1207 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1208
1209 fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
1210 fc_gs_cthdr_build(cthdr, s_id, GS_RSPN_ID);
1211
1212 memset(rspnid, 0, sizeof(struct fcgs_rspnid_req_s));
1213
1214 rspnid->dap = s_id;
1215 rspnid->spn_len = (u8) strlen((char *)name);
1216 strncpy((char *)rspnid->spn, (char *)name, rspnid->spn_len);
1217
1218 return sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s);
1219 }
1220
1221 u16
1222 fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type)
1223 {
1224
1225 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1226 struct fcgs_gidft_req_s *gidft = (struct fcgs_gidft_req_s *)(cthdr + 1);
1227 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1228
1229 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1230
1231 fc_gs_cthdr_build(cthdr, s_id, GS_GID_FT);
1232
1233 memset(gidft, 0, sizeof(struct fcgs_gidft_req_s));
1234 gidft->fc4_type = fc4_type;
1235 gidft->domain_id = 0;
1236 gidft->area_id = 0;
1237
1238 return sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s);
1239 }
1240
1241 u16
1242 fc_rpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
1243 wwn_t port_name)
1244 {
1245 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1246 struct fcgs_rpnid_req_s *rpnid = (struct fcgs_rpnid_req_s *)(cthdr + 1);
1247 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1248
1249 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1250 fc_gs_cthdr_build(cthdr, s_id, GS_RPN_ID);
1251
1252 memset(rpnid, 0, sizeof(struct fcgs_rpnid_req_s));
1253 rpnid->port_id = port_id;
1254 rpnid->port_name = port_name;
1255
1256 return sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s);
1257 }
1258
1259 u16
1260 fc_rnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
1261 wwn_t node_name)
1262 {
1263 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1264 struct fcgs_rnnid_req_s *rnnid = (struct fcgs_rnnid_req_s *)(cthdr + 1);
1265 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1266
1267 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1268 fc_gs_cthdr_build(cthdr, s_id, GS_RNN_ID);
1269
1270 memset(rnnid, 0, sizeof(struct fcgs_rnnid_req_s));
1271 rnnid->port_id = port_id;
1272 rnnid->node_name = node_name;
1273
1274 return sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s);
1275 }
1276
1277 u16
1278 fc_rcsid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
1279 u32 cos)
1280 {
1281 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1282 struct fcgs_rcsid_req_s *rcsid =
1283 (struct fcgs_rcsid_req_s *) (cthdr + 1);
1284 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1285
1286 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1287 fc_gs_cthdr_build(cthdr, s_id, GS_RCS_ID);
1288
1289 memset(rcsid, 0, sizeof(struct fcgs_rcsid_req_s));
1290 rcsid->port_id = port_id;
1291 rcsid->cos = cos;
1292
1293 return sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s);
1294 }
1295
1296 u16
1297 fc_rptid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
1298 u8 port_type)
1299 {
1300 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1301 struct fcgs_rptid_req_s *rptid = (struct fcgs_rptid_req_s *)(cthdr + 1);
1302 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1303
1304 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1305 fc_gs_cthdr_build(cthdr, s_id, GS_RPT_ID);
1306
1307 memset(rptid, 0, sizeof(struct fcgs_rptid_req_s));
1308 rptid->port_id = port_id;
1309 rptid->port_type = port_type;
1310
1311 return sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s);
1312 }
1313
1314 u16
1315 fc_ganxt_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id)
1316 {
1317 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1318 struct fcgs_ganxt_req_s *ganxt = (struct fcgs_ganxt_req_s *)(cthdr + 1);
1319 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1320
1321 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1322 fc_gs_cthdr_build(cthdr, s_id, GS_GA_NXT);
1323
1324 memset(ganxt, 0, sizeof(struct fcgs_ganxt_req_s));
1325 ganxt->port_id = port_id;
1326
1327 return sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s);
1328 }
1329
1330 /*
1331 * Builds fc hdr and ct hdr for FDMI requests.
1332 */
1333 u16
1334 fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id,
1335 u16 cmd_code)
1336 {
1337
1338 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1339 u32 d_id = bfa_hton3b(FC_MGMT_SERVER);
1340
1341 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1342 fc_gs_fdmi_cthdr_build(cthdr, s_id, cmd_code);
1343
1344 return sizeof(struct ct_hdr_s);
1345 }
1346
1347 /*
1348 * Given a FC4 Type, this function returns a fc4 type bitmask
1349 */
1350 void
1351 fc_get_fc4type_bitmask(u8 fc4_type, u8 *bit_mask)
1352 {
1353 u8 index;
1354 __be32 *ptr = (__be32 *) bit_mask;
1355 u32 type_value;
1356
1357 /*
1358 * @todo : Check for bitmask size
1359 */
1360
1361 index = fc4_type >> 5;
1362 type_value = 1 << (fc4_type % 32);
1363 ptr[index] = cpu_to_be32(type_value);
1364
1365 }
1366
1367 /*
1368 * GMAL Request
1369 */
1370 u16
1371 fc_gmal_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
1372 {
1373 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1374 fcgs_gmal_req_t *gmal = (fcgs_gmal_req_t *) (cthdr + 1);
1375 u32 d_id = bfa_hton3b(FC_MGMT_SERVER);
1376
1377 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1378 fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GMAL_CMD,
1379 CT_GSSUBTYPE_CFGSERVER);
1380
1381 memset(gmal, 0, sizeof(fcgs_gmal_req_t));
1382 gmal->wwn = wwn;
1383
1384 return sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t);
1385 }
1386
1387 /*
1388 * GFN (Get Fabric Name) Request
1389 */
1390 u16
1391 fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
1392 {
1393 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1394 fcgs_gfn_req_t *gfn = (fcgs_gfn_req_t *) (cthdr + 1);
1395 u32 d_id = bfa_hton3b(FC_MGMT_SERVER);
1396
1397 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1398 fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GFN_CMD,
1399 CT_GSSUBTYPE_CFGSERVER);
1400
1401 memset(gfn, 0, sizeof(fcgs_gfn_req_t));
1402 gfn->wwn = wwn;
1403
1404 return sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t);
1405 }
Linux with added FPC-III support