1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright 2016-2018 NXP 3 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com> 4 */ 5 #include <linux/packing.h> 6 #include <linux/module.h> 7 #include <linux/bitops.h> 8 #include <linux/errno.h> 9 #include <linux/types.h> 10 #include <linux/bitrev.h> 11 12 static int get_le_offset(int offset) 13 { 14 int closest_multiple_of_4; 15 16 closest_multiple_of_4 = (offset / 4) * 4; 17 offset -= closest_multiple_of_4; 18 return closest_multiple_of_4 + (3 - offset); 19 } 20 21 static int get_reverse_lsw32_offset(int offset, size_t len) 22 { 23 int closest_multiple_of_4; 24 int word_index; 25 26 word_index = offset / 4; 27 closest_multiple_of_4 = word_index * 4; 28 offset -= closest_multiple_of_4; 29 word_index = (len / 4) - word_index - 1; 30 return word_index * 4 + offset; 31 } 32 33 static void adjust_for_msb_right_quirk(u64 *to_write, int *box_start_bit, 34 int *box_end_bit, u8 *box_mask) 35 { 36 int box_bit_width = *box_start_bit - *box_end_bit + 1; 37 int new_box_start_bit, new_box_end_bit; 38 39 *to_write >>= *box_end_bit; 40 *to_write = bitrev8(*to_write) >> (8 - box_bit_width); 41 *to_write <<= *box_end_bit; 42 43 new_box_end_bit = box_bit_width - *box_start_bit - 1; 44 new_box_start_bit = box_bit_width - *box_end_bit - 1; 45 *box_mask = GENMASK_ULL(new_box_start_bit, new_box_end_bit); 46 *box_start_bit = new_box_start_bit; 47 *box_end_bit = new_box_end_bit; 48 } 49 50 /** 51 * packing - Convert numbers (currently u64) between a packed and an unpacked 52 * format. Unpacked means laid out in memory in the CPU's native 53 * understanding of integers, while packed means anything else that 54 * requires translation. 55 * 56 * @pbuf: Pointer to a buffer holding the packed value. 57 * @uval: Pointer to an u64 holding the unpacked value. 58 * @startbit: The index (in logical notation, compensated for quirks) where 59 * the packed value starts within pbuf. Must be larger than, or 60 * equal to, endbit. 61 * @endbit: The index (in logical notation, compensated for quirks) where 62 * the packed value ends within pbuf. Must be smaller than, or equal 63 * to, startbit. 64 * @pbuflen: The length in bytes of the packed buffer pointed to by @pbuf. 65 * @op: If PACK, then uval will be treated as const pointer and copied (packed) 66 * into pbuf, between startbit and endbit. 67 * If UNPACK, then pbuf will be treated as const pointer and the logical 68 * value between startbit and endbit will be copied (unpacked) to uval. 69 * @quirks: A bit mask of QUIRK_LITTLE_ENDIAN, QUIRK_LSW32_IS_FIRST and 70 * QUIRK_MSB_ON_THE_RIGHT. 71 * 72 * Return: 0 on success, EINVAL or ERANGE if called incorrectly. Assuming 73 * correct usage, return code may be discarded. 74 * If op is PACK, pbuf is modified. 75 * If op is UNPACK, uval is modified. 76 */ 77 int packing(void *pbuf, u64 *uval, int startbit, int endbit, size_t pbuflen, 78 enum packing_op op, u8 quirks) 79 { 80 /* Number of bits for storing "uval" 81 * also width of the field to access in the pbuf 82 */ 83 u64 value_width; 84 /* Logical byte indices corresponding to the 85 * start and end of the field. 86 */ 87 int plogical_first_u8, plogical_last_u8, box; 88 89 /* startbit is expected to be larger than endbit */ 90 if (startbit < endbit) 91 /* Invalid function call */ 92 return -EINVAL; 93 94 value_width = startbit - endbit + 1; 95 if (value_width > 64) 96 return -ERANGE; 97 98 /* Check if "uval" fits in "value_width" bits. 99 * If value_width is 64, the check will fail, but any 100 * 64-bit uval will surely fit. 101 */ 102 if (op == PACK && value_width < 64 && (*uval >= (1ull << value_width))) 103 /* Cannot store "uval" inside "value_width" bits. 104 * Truncating "uval" is most certainly not desirable, 105 * so simply erroring out is appropriate. 106 */ 107 return -ERANGE; 108 109 /* Initialize parameter */ 110 if (op == UNPACK) 111 *uval = 0; 112 113 /* Iterate through an idealistic view of the pbuf as an u64 with 114 * no quirks, u8 by u8 (aligned at u8 boundaries), from high to low 115 * logical bit significance. "box" denotes the current logical u8. 116 */ 117 plogical_first_u8 = startbit / 8; 118 plogical_last_u8 = endbit / 8; 119 120 for (box = plogical_first_u8; box >= plogical_last_u8; box--) { 121 /* Bit indices into the currently accessed 8-bit box */ 122 int box_start_bit, box_end_bit, box_addr; 123 u8 box_mask; 124 /* Corresponding bits from the unpacked u64 parameter */ 125 int proj_start_bit, proj_end_bit; 126 u64 proj_mask; 127 128 /* This u8 may need to be accessed in its entirety 129 * (from bit 7 to bit 0), or not, depending on the 130 * input arguments startbit and endbit. 131 */ 132 if (box == plogical_first_u8) 133 box_start_bit = startbit % 8; 134 else 135 box_start_bit = 7; 136 if (box == plogical_last_u8) 137 box_end_bit = endbit % 8; 138 else 139 box_end_bit = 0; 140 141 /* We have determined the box bit start and end. 142 * Now we calculate where this (masked) u8 box would fit 143 * in the unpacked (CPU-readable) u64 - the u8 box's 144 * projection onto the unpacked u64. Though the 145 * box is u8, the projection is u64 because it may fall 146 * anywhere within the unpacked u64. 147 */ 148 proj_start_bit = ((box * 8) + box_start_bit) - endbit; 149 proj_end_bit = ((box * 8) + box_end_bit) - endbit; 150 proj_mask = GENMASK_ULL(proj_start_bit, proj_end_bit); 151 box_mask = GENMASK_ULL(box_start_bit, box_end_bit); 152 153 /* Determine the offset of the u8 box inside the pbuf, 154 * adjusted for quirks. The adjusted box_addr will be used for 155 * effective addressing inside the pbuf (so it's not 156 * logical any longer). 157 */ 158 box_addr = pbuflen - box - 1; 159 if (quirks & QUIRK_LITTLE_ENDIAN) 160 box_addr = get_le_offset(box_addr); 161 if (quirks & QUIRK_LSW32_IS_FIRST) 162 box_addr = get_reverse_lsw32_offset(box_addr, 163 pbuflen); 164 165 if (op == UNPACK) { 166 u64 pval; 167 168 /* Read from pbuf, write to uval */ 169 pval = ((u8 *)pbuf)[box_addr] & box_mask; 170 if (quirks & QUIRK_MSB_ON_THE_RIGHT) 171 adjust_for_msb_right_quirk(&pval, 172 &box_start_bit, 173 &box_end_bit, 174 &box_mask); 175 176 pval >>= box_end_bit; 177 pval <<= proj_end_bit; 178 *uval &= ~proj_mask; 179 *uval |= pval; 180 } else { 181 u64 pval; 182 183 /* Write to pbuf, read from uval */ 184 pval = (*uval) & proj_mask; 185 pval >>= proj_end_bit; 186 if (quirks & QUIRK_MSB_ON_THE_RIGHT) 187 adjust_for_msb_right_quirk(&pval, 188 &box_start_bit, 189 &box_end_bit, 190 &box_mask); 191 192 pval <<= box_end_bit; 193 ((u8 *)pbuf)[box_addr] &= ~box_mask; 194 ((u8 *)pbuf)[box_addr] |= pval; 195 } 196 } 197 return 0; 198 } 199 EXPORT_SYMBOL(packing); 200 201 MODULE_DESCRIPTION("Generic bitfield packing and unpacking"); 202