2 * Copyright(c) 2008 Intel Corporation. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 * Maintained at www.Open-FCoE.org
22 #include <asm/unaligned.h>
25 struct fc_ns_fid fid
; /* port ID object */
26 struct fc_ns_fts fts
; /* FC4-types object */
32 struct fc_ns_gid_ft gid
;
33 struct fc_ns_rn_id rn
;
40 * fill FC header fields in specified fc_frame
42 static inline void fc_fill_fc_hdr(struct fc_frame
*fp
, enum fc_rctl r_ctl
,
43 u32 did
, u32 sid
, enum fc_fh_type type
,
44 u32 f_ctl
, u32 parm_offset
)
46 struct fc_frame_header
*fh
;
48 fh
= fc_frame_header_get(fp
);
51 hton24(fh
->fh_d_id
, did
);
52 hton24(fh
->fh_s_id
, sid
);
54 hton24(fh
->fh_f_ctl
, f_ctl
);
57 fh
->fh_parm_offset
= htonl(parm_offset
);
61 * fc_adisc_fill() - Fill in adisc request frame
63 * @fp: fc frame where payload will be placed.
65 static inline void fc_adisc_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
67 struct fc_els_adisc
*adisc
;
69 adisc
= fc_frame_payload_get(fp
, sizeof(*adisc
));
70 memset(adisc
, 0, sizeof(*adisc
));
71 adisc
->adisc_cmd
= ELS_ADISC
;
72 put_unaligned_be64(lport
->wwpn
, &adisc
->adisc_wwpn
);
73 put_unaligned_be64(lport
->wwnn
, &adisc
->adisc_wwnn
);
74 hton24(adisc
->adisc_port_id
, fc_host_port_id(lport
->host
));
78 * fc_ct_hdr_fill- fills ct header and reset ct payload
79 * returns pointer to ct request.
81 static inline struct fc_ct_req
*fc_ct_hdr_fill(const struct fc_frame
*fp
,
82 unsigned int op
, size_t req_size
)
87 ct_plen
= sizeof(struct fc_ct_hdr
) + req_size
;
88 ct
= fc_frame_payload_get(fp
, ct_plen
);
89 memset(ct
, 0, ct_plen
);
90 ct
->hdr
.ct_rev
= FC_CT_REV
;
91 ct
->hdr
.ct_fs_type
= FC_FST_DIR
;
92 ct
->hdr
.ct_fs_subtype
= FC_NS_SUBTYPE
;
93 ct
->hdr
.ct_cmd
= htons((u16
) op
);
98 * fc_ct_fill() - Fill in a name service request frame
100 * @fc_id: FC_ID of non-destination rport for GPN_ID and similar inquiries.
101 * @fp: frame to contain payload.
103 * @r_ctl: pointer to FC header R_CTL.
104 * @fh_type: pointer to FC-4 type.
106 static inline int fc_ct_fill(struct fc_lport
*lport
,
107 u32 fc_id
, struct fc_frame
*fp
,
108 unsigned int op
, enum fc_rctl
*r_ctl
,
109 enum fc_fh_type
*fh_type
)
111 struct fc_ct_req
*ct
;
115 ct
= fc_ct_hdr_fill(fp
, op
, sizeof(struct fc_ns_gid_ft
));
116 ct
->payload
.gid
.fn_fc4_type
= FC_TYPE_FCP
;
120 ct
= fc_ct_hdr_fill(fp
, op
, sizeof(struct fc_ns_fid
));
121 hton24(ct
->payload
.fid
.fp_fid
, fc_id
);
125 ct
= fc_ct_hdr_fill(fp
, op
, sizeof(struct fc_ns_rft
));
126 hton24(ct
->payload
.rft
.fid
.fp_fid
,
127 fc_host_port_id(lport
->host
));
128 ct
->payload
.rft
.fts
= lport
->fcts
;
132 ct
= fc_ct_hdr_fill(fp
, op
, sizeof(struct fc_ns_rn_id
));
133 hton24(ct
->payload
.rn
.fr_fid
.fp_fid
,
134 fc_host_port_id(lport
->host
));
135 ct
->payload
.rft
.fts
= lport
->fcts
;
136 put_unaligned_be64(lport
->wwpn
, &ct
->payload
.rn
.fr_wwn
);
142 *r_ctl
= FC_RCTL_DD_UNSOL_CTL
;
143 *fh_type
= FC_TYPE_CT
;
148 * fc_plogi_fill - Fill in plogi request frame
150 static inline void fc_plogi_fill(struct fc_lport
*lport
, struct fc_frame
*fp
,
153 struct fc_els_flogi
*plogi
;
154 struct fc_els_csp
*csp
;
155 struct fc_els_cssp
*cp
;
157 plogi
= fc_frame_payload_get(fp
, sizeof(*plogi
));
158 memset(plogi
, 0, sizeof(*plogi
));
159 plogi
->fl_cmd
= (u8
) op
;
160 put_unaligned_be64(lport
->wwpn
, &plogi
->fl_wwpn
);
161 put_unaligned_be64(lport
->wwnn
, &plogi
->fl_wwnn
);
163 csp
= &plogi
->fl_csp
;
164 csp
->sp_hi_ver
= 0x20;
165 csp
->sp_lo_ver
= 0x20;
166 csp
->sp_bb_cred
= htons(10); /* this gets set by gateway */
167 csp
->sp_bb_data
= htons((u16
) lport
->mfs
);
168 cp
= &plogi
->fl_cssp
[3 - 1]; /* class 3 parameters */
169 cp
->cp_class
= htons(FC_CPC_VALID
| FC_CPC_SEQ
);
170 csp
->sp_features
= htons(FC_SP_FT_CIRO
);
171 csp
->sp_tot_seq
= htons(255); /* seq. we accept */
172 csp
->sp_rel_off
= htons(0x1f);
173 csp
->sp_e_d_tov
= htonl(lport
->e_d_tov
);
175 cp
->cp_rdfs
= htons((u16
) lport
->mfs
);
176 cp
->cp_con_seq
= htons(255);
181 * fc_flogi_fill - Fill in a flogi request frame.
183 static inline void fc_flogi_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
185 struct fc_els_csp
*sp
;
186 struct fc_els_cssp
*cp
;
187 struct fc_els_flogi
*flogi
;
189 flogi
= fc_frame_payload_get(fp
, sizeof(*flogi
));
190 memset(flogi
, 0, sizeof(*flogi
));
191 flogi
->fl_cmd
= (u8
) ELS_FLOGI
;
192 put_unaligned_be64(lport
->wwpn
, &flogi
->fl_wwpn
);
193 put_unaligned_be64(lport
->wwnn
, &flogi
->fl_wwnn
);
195 sp
->sp_hi_ver
= 0x20;
196 sp
->sp_lo_ver
= 0x20;
197 sp
->sp_bb_cred
= htons(10); /* this gets set by gateway */
198 sp
->sp_bb_data
= htons((u16
) lport
->mfs
);
199 cp
= &flogi
->fl_cssp
[3 - 1]; /* class 3 parameters */
200 cp
->cp_class
= htons(FC_CPC_VALID
| FC_CPC_SEQ
);
204 * fc_logo_fill - Fill in a logo request frame.
206 static inline void fc_logo_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
208 struct fc_els_logo
*logo
;
210 logo
= fc_frame_payload_get(fp
, sizeof(*logo
));
211 memset(logo
, 0, sizeof(*logo
));
212 logo
->fl_cmd
= ELS_LOGO
;
213 hton24(logo
->fl_n_port_id
, fc_host_port_id(lport
->host
));
214 logo
->fl_n_port_wwn
= htonll(lport
->wwpn
);
218 * fc_rtv_fill - Fill in RTV (read timeout value) request frame.
220 static inline void fc_rtv_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
222 struct fc_els_rtv
*rtv
;
224 rtv
= fc_frame_payload_get(fp
, sizeof(*rtv
));
225 memset(rtv
, 0, sizeof(*rtv
));
226 rtv
->rtv_cmd
= ELS_RTV
;
230 * fc_rec_fill - Fill in rec request frame
232 static inline void fc_rec_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
234 struct fc_els_rec
*rec
;
235 struct fc_exch
*ep
= fc_seq_exch(fr_seq(fp
));
237 rec
= fc_frame_payload_get(fp
, sizeof(*rec
));
238 memset(rec
, 0, sizeof(*rec
));
239 rec
->rec_cmd
= ELS_REC
;
240 hton24(rec
->rec_s_id
, fc_host_port_id(lport
->host
));
241 rec
->rec_ox_id
= htons(ep
->oxid
);
242 rec
->rec_rx_id
= htons(ep
->rxid
);
246 * fc_prli_fill - Fill in prli request frame
248 static inline void fc_prli_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
251 struct fc_els_prli prli
;
252 struct fc_els_spp spp
;
255 pp
= fc_frame_payload_get(fp
, sizeof(*pp
));
256 memset(pp
, 0, sizeof(*pp
));
257 pp
->prli
.prli_cmd
= ELS_PRLI
;
258 pp
->prli
.prli_spp_len
= sizeof(struct fc_els_spp
);
259 pp
->prli
.prli_len
= htons(sizeof(*pp
));
260 pp
->spp
.spp_type
= FC_TYPE_FCP
;
261 pp
->spp
.spp_flags
= FC_SPP_EST_IMG_PAIR
;
262 pp
->spp
.spp_params
= htonl(lport
->service_params
);
266 * fc_scr_fill - Fill in a scr request frame.
268 static inline void fc_scr_fill(struct fc_lport
*lport
, struct fc_frame
*fp
)
270 struct fc_els_scr
*scr
;
272 scr
= fc_frame_payload_get(fp
, sizeof(*scr
));
273 memset(scr
, 0, sizeof(*scr
));
274 scr
->scr_cmd
= ELS_SCR
;
275 scr
->scr_reg_func
= ELS_SCRF_FULL
;
279 * fc_els_fill - Fill in an ELS request frame
281 static inline int fc_els_fill(struct fc_lport
*lport
,
283 struct fc_frame
*fp
, unsigned int op
,
284 enum fc_rctl
*r_ctl
, enum fc_fh_type
*fh_type
)
288 fc_adisc_fill(lport
, fp
);
292 fc_plogi_fill(lport
, fp
, ELS_PLOGI
);
296 fc_flogi_fill(lport
, fp
);
300 fc_logo_fill(lport
, fp
);
304 fc_rtv_fill(lport
, fp
);
308 fc_rec_fill(lport
, fp
);
312 fc_prli_fill(lport
, fp
);
316 fc_scr_fill(lport
, fp
);
323 *r_ctl
= FC_RCTL_ELS_REQ
;
324 *fh_type
= FC_TYPE_ELS
;
327 #endif /* _FC_ENCODE_H_ */
This page took 0.03906 seconds and 6 git commands to generate.