1 /*
2  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
3  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33 
34 #include <linux/errno.h>
35 #include <linux/string.h>
36 
37 #include <rdma/ib_pack.h>
38 
39 #define STRUCT_FIELD(header, field) \
40 	.struct_offset_bytes = offsetof(struct ib_unpacked_ ## header, field),      \
41 	.struct_size_bytes   = sizeof ((struct ib_unpacked_ ## header *) 0)->field, \
42 	.field_name          = #header ":" #field
43 
44 static const struct ib_field lrh_table[]  = {
45 	{ STRUCT_FIELD(lrh, virtual_lane),
46 	  .offset_words = 0,
47 	  .offset_bits  = 0,
48 	  .size_bits    = 4 },
49 	{ STRUCT_FIELD(lrh, link_version),
50 	  .offset_words = 0,
51 	  .offset_bits  = 4,
52 	  .size_bits    = 4 },
53 	{ STRUCT_FIELD(lrh, service_level),
54 	  .offset_words = 0,
55 	  .offset_bits  = 8,
56 	  .size_bits    = 4 },
57 	{ RESERVED,
58 	  .offset_words = 0,
59 	  .offset_bits  = 12,
60 	  .size_bits    = 2 },
61 	{ STRUCT_FIELD(lrh, link_next_header),
62 	  .offset_words = 0,
63 	  .offset_bits  = 14,
64 	  .size_bits    = 2 },
65 	{ STRUCT_FIELD(lrh, destination_lid),
66 	  .offset_words = 0,
67 	  .offset_bits  = 16,
68 	  .size_bits    = 16 },
69 	{ RESERVED,
70 	  .offset_words = 1,
71 	  .offset_bits  = 0,
72 	  .size_bits    = 5 },
73 	{ STRUCT_FIELD(lrh, packet_length),
74 	  .offset_words = 1,
75 	  .offset_bits  = 5,
76 	  .size_bits    = 11 },
77 	{ STRUCT_FIELD(lrh, source_lid),
78 	  .offset_words = 1,
79 	  .offset_bits  = 16,
80 	  .size_bits    = 16 }
81 };
82 
83 static const struct ib_field grh_table[]  = {
84 	{ STRUCT_FIELD(grh, ip_version),
85 	  .offset_words = 0,
86 	  .offset_bits  = 0,
87 	  .size_bits    = 4 },
88 	{ STRUCT_FIELD(grh, traffic_class),
89 	  .offset_words = 0,
90 	  .offset_bits  = 4,
91 	  .size_bits    = 8 },
92 	{ STRUCT_FIELD(grh, flow_label),
93 	  .offset_words = 0,
94 	  .offset_bits  = 12,
95 	  .size_bits    = 20 },
96 	{ STRUCT_FIELD(grh, payload_length),
97 	  .offset_words = 1,
98 	  .offset_bits  = 0,
99 	  .size_bits    = 16 },
100 	{ STRUCT_FIELD(grh, next_header),
101 	  .offset_words = 1,
102 	  .offset_bits  = 16,
103 	  .size_bits    = 8 },
104 	{ STRUCT_FIELD(grh, hop_limit),
105 	  .offset_words = 1,
106 	  .offset_bits  = 24,
107 	  .size_bits    = 8 },
108 	{ STRUCT_FIELD(grh, source_gid),
109 	  .offset_words = 2,
110 	  .offset_bits  = 0,
111 	  .size_bits    = 128 },
112 	{ STRUCT_FIELD(grh, destination_gid),
113 	  .offset_words = 6,
114 	  .offset_bits  = 0,
115 	  .size_bits    = 128 }
116 };
117 
118 static const struct ib_field bth_table[]  = {
119 	{ STRUCT_FIELD(bth, opcode),
120 	  .offset_words = 0,
121 	  .offset_bits  = 0,
122 	  .size_bits    = 8 },
123 	{ STRUCT_FIELD(bth, solicited_event),
124 	  .offset_words = 0,
125 	  .offset_bits  = 8,
126 	  .size_bits    = 1 },
127 	{ STRUCT_FIELD(bth, mig_req),
128 	  .offset_words = 0,
129 	  .offset_bits  = 9,
130 	  .size_bits    = 1 },
131 	{ STRUCT_FIELD(bth, pad_count),
132 	  .offset_words = 0,
133 	  .offset_bits  = 10,
134 	  .size_bits    = 2 },
135 	{ STRUCT_FIELD(bth, transport_header_version),
136 	  .offset_words = 0,
137 	  .offset_bits  = 12,
138 	  .size_bits    = 4 },
139 	{ STRUCT_FIELD(bth, pkey),
140 	  .offset_words = 0,
141 	  .offset_bits  = 16,
142 	  .size_bits    = 16 },
143 	{ RESERVED,
144 	  .offset_words = 1,
145 	  .offset_bits  = 0,
146 	  .size_bits    = 8 },
147 	{ STRUCT_FIELD(bth, destination_qpn),
148 	  .offset_words = 1,
149 	  .offset_bits  = 8,
150 	  .size_bits    = 24 },
151 	{ STRUCT_FIELD(bth, ack_req),
152 	  .offset_words = 2,
153 	  .offset_bits  = 0,
154 	  .size_bits    = 1 },
155 	{ RESERVED,
156 	  .offset_words = 2,
157 	  .offset_bits  = 1,
158 	  .size_bits    = 7 },
159 	{ STRUCT_FIELD(bth, psn),
160 	  .offset_words = 2,
161 	  .offset_bits  = 8,
162 	  .size_bits    = 24 }
163 };
164 
165 static const struct ib_field deth_table[] = {
166 	{ STRUCT_FIELD(deth, qkey),
167 	  .offset_words = 0,
168 	  .offset_bits  = 0,
169 	  .size_bits    = 32 },
170 	{ RESERVED,
171 	  .offset_words = 1,
172 	  .offset_bits  = 0,
173 	  .size_bits    = 8 },
174 	{ STRUCT_FIELD(deth, source_qpn),
175 	  .offset_words = 1,
176 	  .offset_bits  = 8,
177 	  .size_bits    = 24 }
178 };
179 
180 /**
181  * ib_ud_header_init - Initialize UD header structure
182  * @payload_bytes:Length of packet payload
183  * @grh_present:GRH flag (if non-zero, GRH will be included)
184  * @header:Structure to initialize
185  *
186  * ib_ud_header_init() initializes the lrh.link_version, lrh.link_next_header,
187  * lrh.packet_length, grh.ip_version, grh.payload_length,
188  * grh.next_header, bth.opcode, bth.pad_count and
189  * bth.transport_header_version fields of a &struct ib_ud_header given
190  * the payload length and whether a GRH will be included.
191  */
192 void ib_ud_header_init(int     		    payload_bytes,
193 		       int    		    grh_present,
194 		       struct ib_ud_header *header)
195 {
196 	int header_len;
197 	u16 packet_length;
198 
199 	memset(header, 0, sizeof *header);
200 
201 	header_len =
202 		IB_LRH_BYTES  +
203 		IB_BTH_BYTES  +
204 		IB_DETH_BYTES;
205 	if (grh_present) {
206 		header_len += IB_GRH_BYTES;
207 	}
208 
209 	header->lrh.link_version     = 0;
210 	header->lrh.link_next_header =
211 		grh_present ? IB_LNH_IBA_GLOBAL : IB_LNH_IBA_LOCAL;
212 	packet_length		     = (IB_LRH_BYTES     +
213 					IB_BTH_BYTES     +
214 					IB_DETH_BYTES    +
215 					payload_bytes    +
216 					4                + /* ICRC     */
217 					3) / 4;            /* round up */
218 
219 	header->grh_present          = grh_present;
220 	if (grh_present) {
221 		packet_length		   += IB_GRH_BYTES / 4;
222 		header->grh.ip_version      = 6;
223 		header->grh.payload_length  =
224 			cpu_to_be16((IB_BTH_BYTES     +
225 				     IB_DETH_BYTES    +
226 				     payload_bytes    +
227 				     4                + /* ICRC     */
228 				     3) & ~3);          /* round up */
229 		header->grh.next_header     = 0x1b;
230 	}
231 
232 	header->lrh.packet_length = cpu_to_be16(packet_length);
233 
234 	if (header->immediate_present)
235 		header->bth.opcode           = IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE;
236 	else
237 		header->bth.opcode           = IB_OPCODE_UD_SEND_ONLY;
238 	header->bth.pad_count                = (4 - payload_bytes) & 3;
239 	header->bth.transport_header_version = 0;
240 }
241 EXPORT_SYMBOL(ib_ud_header_init);
242 
243 /**
244  * ib_ud_header_pack - Pack UD header struct into wire format
245  * @header:UD header struct
246  * @buf:Buffer to pack into
247  *
248  * ib_ud_header_pack() packs the UD header structure @header into wire
249  * format in the buffer @buf.
250  */
251 int ib_ud_header_pack(struct ib_ud_header *header,
252 		      void                *buf)
253 {
254 	int len = 0;
255 
256 	ib_pack(lrh_table, ARRAY_SIZE(lrh_table),
257 		&header->lrh, buf);
258 	len += IB_LRH_BYTES;
259 
260 	if (header->grh_present) {
261 		ib_pack(grh_table, ARRAY_SIZE(grh_table),
262 			&header->grh, buf + len);
263 		len += IB_GRH_BYTES;
264 	}
265 
266 	ib_pack(bth_table, ARRAY_SIZE(bth_table),
267 		&header->bth, buf + len);
268 	len += IB_BTH_BYTES;
269 
270 	ib_pack(deth_table, ARRAY_SIZE(deth_table),
271 		&header->deth, buf + len);
272 	len += IB_DETH_BYTES;
273 
274 	if (header->immediate_present) {
275 		memcpy(buf + len, &header->immediate_data, sizeof header->immediate_data);
276 		len += sizeof header->immediate_data;
277 	}
278 
279 	return len;
280 }
281 EXPORT_SYMBOL(ib_ud_header_pack);
282 
283 /**
284  * ib_ud_header_unpack - Unpack UD header struct from wire format
285  * @header:UD header struct
286  * @buf:Buffer to pack into
287  *
288  * ib_ud_header_pack() unpacks the UD header structure @header from wire
289  * format in the buffer @buf.
290  */
291 int ib_ud_header_unpack(void                *buf,
292 			struct ib_ud_header *header)
293 {
294 	ib_unpack(lrh_table, ARRAY_SIZE(lrh_table),
295 		  buf, &header->lrh);
296 	buf += IB_LRH_BYTES;
297 
298 	if (header->lrh.link_version != 0) {
299 		printk(KERN_WARNING "Invalid LRH.link_version %d\n",
300 		       header->lrh.link_version);
301 		return -EINVAL;
302 	}
303 
304 	switch (header->lrh.link_next_header) {
305 	case IB_LNH_IBA_LOCAL:
306 		header->grh_present = 0;
307 		break;
308 
309 	case IB_LNH_IBA_GLOBAL:
310 		header->grh_present = 1;
311 		ib_unpack(grh_table, ARRAY_SIZE(grh_table),
312 			  buf, &header->grh);
313 		buf += IB_GRH_BYTES;
314 
315 		if (header->grh.ip_version != 6) {
316 			printk(KERN_WARNING "Invalid GRH.ip_version %d\n",
317 			       header->grh.ip_version);
318 			return -EINVAL;
319 		}
320 		if (header->grh.next_header != 0x1b) {
321 			printk(KERN_WARNING "Invalid GRH.next_header 0x%02x\n",
322 			       header->grh.next_header);
323 			return -EINVAL;
324 		}
325 		break;
326 
327 	default:
328 		printk(KERN_WARNING "Invalid LRH.link_next_header %d\n",
329 		       header->lrh.link_next_header);
330 		return -EINVAL;
331 	}
332 
333 	ib_unpack(bth_table, ARRAY_SIZE(bth_table),
334 		  buf, &header->bth);
335 	buf += IB_BTH_BYTES;
336 
337 	switch (header->bth.opcode) {
338 	case IB_OPCODE_UD_SEND_ONLY:
339 		header->immediate_present = 0;
340 		break;
341 	case IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE:
342 		header->immediate_present = 1;
343 		break;
344 	default:
345 		printk(KERN_WARNING "Invalid BTH.opcode 0x%02x\n",
346 		       header->bth.opcode);
347 		return -EINVAL;
348 	}
349 
350 	if (header->bth.transport_header_version != 0) {
351 		printk(KERN_WARNING "Invalid BTH.transport_header_version %d\n",
352 		       header->bth.transport_header_version);
353 		return -EINVAL;
354 	}
355 
356 	ib_unpack(deth_table, ARRAY_SIZE(deth_table),
357 		  buf, &header->deth);
358 	buf += IB_DETH_BYTES;
359 
360 	if (header->immediate_present)
361 		memcpy(&header->immediate_data, buf, sizeof header->immediate_data);
362 
363 	return 0;
364 }
365 EXPORT_SYMBOL(ib_ud_header_unpack);
366