IB/core: Fix and clean up ib_ud_header_init()
[linux-2.6.git] / drivers / infiniband / core / ud_header.c
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  * @immediate_present: specify if immediate data should be used
185  * @header:Structure to initialize
186  *
187  * ib_ud_header_init() initializes the lrh.link_version, lrh.link_next_header,
188  * lrh.packet_length, grh.ip_version, grh.payload_length,
189  * grh.next_header, bth.opcode, bth.pad_count and
190  * bth.transport_header_version fields of a &struct ib_ud_header given
191  * the payload length and whether a GRH will be included.
192  */
193 void ib_ud_header_init(int                  payload_bytes,
194                        int                  grh_present,
195                        int                  immediate_present,
196                        struct ib_ud_header *header)
197 {
198         u16 packet_length;
199
200         memset(header, 0, sizeof *header);
201
202         header->lrh.link_version     = 0;
203         header->lrh.link_next_header =
204                 grh_present ? IB_LNH_IBA_GLOBAL : IB_LNH_IBA_LOCAL;
205         packet_length                = (IB_LRH_BYTES     +
206                                         IB_BTH_BYTES     +
207                                         IB_DETH_BYTES    +
208                                         payload_bytes    +
209                                         4                + /* ICRC     */
210                                         3) / 4;            /* round up */
211
212         header->grh_present          = grh_present;
213         if (grh_present) {
214                 packet_length              += IB_GRH_BYTES / 4;
215                 header->grh.ip_version      = 6;
216                 header->grh.payload_length  =
217                         cpu_to_be16((IB_BTH_BYTES     +
218                                      IB_DETH_BYTES    +
219                                      payload_bytes    +
220                                      4                + /* ICRC     */
221                                      3) & ~3);          /* round up */
222                 header->grh.next_header     = 0x1b;
223         }
224
225         header->lrh.packet_length = cpu_to_be16(packet_length);
226
227         header->immediate_present            = immediate_present;
228         if (immediate_present)
229                 header->bth.opcode           = IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE;
230         else
231                 header->bth.opcode           = IB_OPCODE_UD_SEND_ONLY;
232         header->bth.pad_count                = (4 - payload_bytes) & 3;
233         header->bth.transport_header_version = 0;
234 }
235 EXPORT_SYMBOL(ib_ud_header_init);
236
237 /**
238  * ib_ud_header_pack - Pack UD header struct into wire format
239  * @header:UD header struct
240  * @buf:Buffer to pack into
241  *
242  * ib_ud_header_pack() packs the UD header structure @header into wire
243  * format in the buffer @buf.
244  */
245 int ib_ud_header_pack(struct ib_ud_header *header,
246                       void                *buf)
247 {
248         int len = 0;
249
250         ib_pack(lrh_table, ARRAY_SIZE(lrh_table),
251                 &header->lrh, buf);
252         len += IB_LRH_BYTES;
253
254         if (header->grh_present) {
255                 ib_pack(grh_table, ARRAY_SIZE(grh_table),
256                         &header->grh, buf + len);
257                 len += IB_GRH_BYTES;
258         }
259
260         ib_pack(bth_table, ARRAY_SIZE(bth_table),
261                 &header->bth, buf + len);
262         len += IB_BTH_BYTES;
263
264         ib_pack(deth_table, ARRAY_SIZE(deth_table),
265                 &header->deth, buf + len);
266         len += IB_DETH_BYTES;
267
268         if (header->immediate_present) {
269                 memcpy(buf + len, &header->immediate_data, sizeof header->immediate_data);
270                 len += sizeof header->immediate_data;
271         }
272
273         return len;
274 }
275 EXPORT_SYMBOL(ib_ud_header_pack);
276
277 /**
278  * ib_ud_header_unpack - Unpack UD header struct from wire format
279  * @header:UD header struct
280  * @buf:Buffer to pack into
281  *
282  * ib_ud_header_pack() unpacks the UD header structure @header from wire
283  * format in the buffer @buf.
284  */
285 int ib_ud_header_unpack(void                *buf,
286                         struct ib_ud_header *header)
287 {
288         ib_unpack(lrh_table, ARRAY_SIZE(lrh_table),
289                   buf, &header->lrh);
290         buf += IB_LRH_BYTES;
291
292         if (header->lrh.link_version != 0) {
293                 printk(KERN_WARNING "Invalid LRH.link_version %d\n",
294                        header->lrh.link_version);
295                 return -EINVAL;
296         }
297
298         switch (header->lrh.link_next_header) {
299         case IB_LNH_IBA_LOCAL:
300                 header->grh_present = 0;
301                 break;
302
303         case IB_LNH_IBA_GLOBAL:
304                 header->grh_present = 1;
305                 ib_unpack(grh_table, ARRAY_SIZE(grh_table),
306                           buf, &header->grh);
307                 buf += IB_GRH_BYTES;
308
309                 if (header->grh.ip_version != 6) {
310                         printk(KERN_WARNING "Invalid GRH.ip_version %d\n",
311                                header->grh.ip_version);
312                         return -EINVAL;
313                 }
314                 if (header->grh.next_header != 0x1b) {
315                         printk(KERN_WARNING "Invalid GRH.next_header 0x%02x\n",
316                                header->grh.next_header);
317                         return -EINVAL;
318                 }
319                 break;
320
321         default:
322                 printk(KERN_WARNING "Invalid LRH.link_next_header %d\n",
323                        header->lrh.link_next_header);
324                 return -EINVAL;
325         }
326
327         ib_unpack(bth_table, ARRAY_SIZE(bth_table),
328                   buf, &header->bth);
329         buf += IB_BTH_BYTES;
330
331         switch (header->bth.opcode) {
332         case IB_OPCODE_UD_SEND_ONLY:
333                 header->immediate_present = 0;
334                 break;
335         case IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE:
336                 header->immediate_present = 1;
337                 break;
338         default:
339                 printk(KERN_WARNING "Invalid BTH.opcode 0x%02x\n",
340                        header->bth.opcode);
341                 return -EINVAL;
342         }
343
344         if (header->bth.transport_header_version != 0) {
345                 printk(KERN_WARNING "Invalid BTH.transport_header_version %d\n",
346                        header->bth.transport_header_version);
347                 return -EINVAL;
348         }
349
350         ib_unpack(deth_table, ARRAY_SIZE(deth_table),
351                   buf, &header->deth);
352         buf += IB_DETH_BYTES;
353
354         if (header->immediate_present)
355                 memcpy(&header->immediate_data, buf, sizeof header->immediate_data);
356
357         return 0;
358 }
359 EXPORT_SYMBOL(ib_ud_header_unpack);