1 /* 2 * Copyright (c) 2004 Topspin Corporation. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 * 32 * $Id: ud_header.c 1349 2004-12-16 21:09:43Z roland $ 33 */ 34 35 #include <linux/errno.h> 36 37 #include <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 198 memset(header, 0, sizeof *header); 199 200 header_len = 201 IB_LRH_BYTES + 202 IB_BTH_BYTES + 203 IB_DETH_BYTES; 204 if (grh_present) { 205 header_len += IB_GRH_BYTES; 206 } 207 208 header->lrh.link_version = 0; 209 header->lrh.link_next_header = 210 grh_present ? IB_LNH_IBA_GLOBAL : IB_LNH_IBA_LOCAL; 211 header->lrh.packet_length = (IB_LRH_BYTES + 212 IB_BTH_BYTES + 213 IB_DETH_BYTES + 214 payload_bytes + 215 4 + /* ICRC */ 216 3) / 4; /* round up */ 217 218 header->grh_present = grh_present; 219 if (grh_present) { 220 header->lrh.packet_length += IB_GRH_BYTES / 4; 221 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 cpu_to_be16s(&header->lrh.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