1/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */ 2/* 3 * Copyright (c) 2020, Mellanox Technologies inc. All rights reserved. 4 */ 5#ifndef _IBA_DEFS_H_ 6#define _IBA_DEFS_H_ 7 8#include <linux/kernel.h> 9#include <linux/bitfield.h> 10#include <asm/unaligned.h> 11 12static inline u32 _iba_get8(const u8 *ptr) 13{ 14 return *ptr; 15} 16 17static inline void _iba_set8(u8 *ptr, u32 mask, u32 prep_value) 18{ 19 *ptr = (*ptr & ~mask) | prep_value; 20} 21 22static inline u16 _iba_get16(const __be16 *ptr) 23{ 24 return be16_to_cpu(*ptr); 25} 26 27static inline void _iba_set16(__be16 *ptr, u16 mask, u16 prep_value) 28{ 29 *ptr = cpu_to_be16((be16_to_cpu(*ptr) & ~mask) | prep_value); 30} 31 32static inline u32 _iba_get32(const __be32 *ptr) 33{ 34 return be32_to_cpu(*ptr); 35} 36 37static inline void _iba_set32(__be32 *ptr, u32 mask, u32 prep_value) 38{ 39 *ptr = cpu_to_be32((be32_to_cpu(*ptr) & ~mask) | prep_value); 40} 41 42static inline u64 _iba_get64(const __be64 *ptr) 43{ 44 /* 45 * The mads are constructed so that 32 bit and smaller are naturally 46 * aligned, everything larger has a max alignment of 4 bytes. 47 */ 48 return be64_to_cpu(get_unaligned(ptr)); 49} 50 51static inline void _iba_set64(__be64 *ptr, u64 mask, u64 prep_value) 52{ 53 put_unaligned(cpu_to_be64((_iba_get64(ptr) & ~mask) | prep_value), ptr); 54} 55 56#define _IBA_SET(field_struct, field_offset, field_mask, num_bits, ptr, value) \ 57 ({ \ 58 field_struct *_ptr = ptr; \ 59 _iba_set##num_bits((void *)_ptr + (field_offset), field_mask, \ 60 FIELD_PREP(field_mask, value)); \ 61 }) 62#define IBA_SET(field, ptr, value) _IBA_SET(field, ptr, value) 63 64#define _IBA_GET_MEM_PTR(field_struct, field_offset, type, num_bits, ptr) \ 65 ({ \ 66 field_struct *_ptr = ptr; \ 67 (type *)((void *)_ptr + (field_offset)); \ 68 }) 69#define IBA_GET_MEM_PTR(field, ptr) _IBA_GET_MEM_PTR(field, ptr) 70 71/* FIXME: A set should always set the entire field, meaning we should zero the trailing bytes */ 72#define _IBA_SET_MEM(field_struct, field_offset, type, num_bits, ptr, in, \ 73 bytes) \ 74 ({ \ 75 const type *_in_ptr = in; \ 76 WARN_ON(bytes * 8 > num_bits); \ 77 if (in && bytes) \ 78 memcpy(_IBA_GET_MEM_PTR(field_struct, field_offset, \ 79 type, num_bits, ptr), \ 80 _in_ptr, bytes); \ 81 }) 82#define IBA_SET_MEM(field, ptr, in, bytes) _IBA_SET_MEM(field, ptr, in, bytes) 83 84#define _IBA_GET(field_struct, field_offset, field_mask, num_bits, ptr) \ 85 ({ \ 86 const field_struct *_ptr = ptr; \ 87 (u##num_bits) FIELD_GET( \ 88 field_mask, _iba_get##num_bits((const void *)_ptr + \ 89 (field_offset))); \ 90 }) 91#define IBA_GET(field, ptr) _IBA_GET(field, ptr) 92 93#define _IBA_GET_MEM(field_struct, field_offset, type, num_bits, ptr, out, \ 94 bytes) \ 95 ({ \ 96 type *_out_ptr = out; \ 97 WARN_ON(bytes * 8 > num_bits); \ 98 if (out && bytes) \ 99 memcpy(_out_ptr, \ 100 _IBA_GET_MEM_PTR(field_struct, field_offset, \ 101 type, num_bits, ptr), \ 102 bytes); \ 103 }) 104#define IBA_GET_MEM(field, ptr, out, bytes) _IBA_GET_MEM(field, ptr, out, bytes) 105 106/* 107 * The generated list becomes the parameters to the macros, the order is: 108 * - struct this applies to 109 * - starting offset of the max 110 * - GENMASK or GENMASK_ULL in CPU order 111 * - The width of data the mask operations should work on, in bits 112 */ 113 114/* 115 * Extraction using a tabular description like table 106. bit_offset is from 116 * the Byte[Bit] notation. 117 */ 118#define IBA_FIELD_BLOC(field_struct, byte_offset, bit_offset, num_bits) \ 119 field_struct, byte_offset, \ 120 GENMASK(7 - (bit_offset), 7 - (bit_offset) - (num_bits - 1)), \ 121 8 122#define IBA_FIELD8_LOC(field_struct, byte_offset, num_bits) \ 123 IBA_FIELD_BLOC(field_struct, byte_offset, 0, num_bits) 124 125#define IBA_FIELD16_LOC(field_struct, byte_offset, num_bits) \ 126 field_struct, (byte_offset)&0xFFFE, \ 127 GENMASK(15 - (((byte_offset) % 2) * 8), \ 128 15 - (((byte_offset) % 2) * 8) - (num_bits - 1)), \ 129 16 130 131#define IBA_FIELD32_LOC(field_struct, byte_offset, num_bits) \ 132 field_struct, (byte_offset)&0xFFFC, \ 133 GENMASK(31 - (((byte_offset) % 4) * 8), \ 134 31 - (((byte_offset) % 4) * 8) - (num_bits - 1)), \ 135 32 136 137#define IBA_FIELD64_LOC(field_struct, byte_offset) \ 138 field_struct, byte_offset, GENMASK_ULL(63, 0), 64 139/* 140 * In IBTA spec, everything that is more than 64bits is multiple 141 * of bytes without leftover bits. 142 */ 143#define IBA_FIELD_MLOC(field_struct, byte_offset, num_bits, type) \ 144 field_struct, byte_offset, type, num_bits 145 146#endif /* _IBA_DEFS_H_ */ 147