1/* 2 * drivers/net/ethernet/mellanox/mlxsw/item.h 3 * Copyright (c) 2015 Mellanox Technologies. All rights reserved. 4 * Copyright (c) 2015 Jiri Pirko <jiri@mellanox.com> 5 * Copyright (c) 2015 Ido Schimmel <idosch@mellanox.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the names of the copyright holders nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * Alternatively, this software may be distributed under the terms of the 20 * GNU General Public License ("GPL") version 2 as published by the Free 21 * Software Foundation. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36#ifndef _MLXSW_ITEM_H 37#define _MLXSW_ITEM_H 38 39#include <linux/types.h> 40#include <linux/string.h> 41#include <linux/bitops.h> 42 43struct mlxsw_item { 44 unsigned short offset; /* bytes in container */ 45 unsigned short step; /* step in bytes for indexed items */ 46 unsigned short in_step_offset; /* offset within one step */ 47 unsigned char shift; /* shift in bits */ 48 unsigned char element_size; /* size of element in bit array */ 49 bool no_real_shift; 50 union { 51 unsigned char bits; 52 unsigned short bytes; 53 } size; 54 const char *name; 55}; 56 57static inline unsigned int 58__mlxsw_item_offset(struct mlxsw_item *item, unsigned short index, 59 size_t typesize) 60{ 61 BUG_ON(index && !item->step); 62 if (item->offset % typesize != 0 || 63 item->step % typesize != 0 || 64 item->in_step_offset % typesize != 0) { 65 pr_err("mlxsw: item bug (name=%s,offset=%x,step=%x,in_step_offset=%x,typesize=%zx)\n", 66 item->name, item->offset, item->step, 67 item->in_step_offset, typesize); 68 BUG(); 69 } 70 71 return ((item->offset + item->step * index + item->in_step_offset) / 72 typesize); 73} 74 75static inline u16 __mlxsw_item_get16(char *buf, struct mlxsw_item *item, 76 unsigned short index) 77{ 78 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u16)); 79 __be16 *b = (__be16 *) buf; 80 u16 tmp; 81 82 tmp = be16_to_cpu(b[offset]); 83 tmp >>= item->shift; 84 tmp &= GENMASK(item->size.bits - 1, 0); 85 if (item->no_real_shift) 86 tmp <<= item->shift; 87 return tmp; 88} 89 90static inline void __mlxsw_item_set16(char *buf, struct mlxsw_item *item, 91 unsigned short index, u16 val) 92{ 93 unsigned int offset = __mlxsw_item_offset(item, index, 94 sizeof(u16)); 95 __be16 *b = (__be16 *) buf; 96 u16 mask = GENMASK(item->size.bits - 1, 0) << item->shift; 97 u16 tmp; 98 99 if (!item->no_real_shift) 100 val <<= item->shift; 101 val &= mask; 102 tmp = be16_to_cpu(b[offset]); 103 tmp &= ~mask; 104 tmp |= val; 105 b[offset] = cpu_to_be16(tmp); 106} 107 108static inline u32 __mlxsw_item_get32(char *buf, struct mlxsw_item *item, 109 unsigned short index) 110{ 111 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u32)); 112 __be32 *b = (__be32 *) buf; 113 u32 tmp; 114 115 tmp = be32_to_cpu(b[offset]); 116 tmp >>= item->shift; 117 tmp &= GENMASK(item->size.bits - 1, 0); 118 if (item->no_real_shift) 119 tmp <<= item->shift; 120 return tmp; 121} 122 123static inline void __mlxsw_item_set32(char *buf, struct mlxsw_item *item, 124 unsigned short index, u32 val) 125{ 126 unsigned int offset = __mlxsw_item_offset(item, index, 127 sizeof(u32)); 128 __be32 *b = (__be32 *) buf; 129 u32 mask = GENMASK(item->size.bits - 1, 0) << item->shift; 130 u32 tmp; 131 132 if (!item->no_real_shift) 133 val <<= item->shift; 134 val &= mask; 135 tmp = be32_to_cpu(b[offset]); 136 tmp &= ~mask; 137 tmp |= val; 138 b[offset] = cpu_to_be32(tmp); 139} 140 141static inline u64 __mlxsw_item_get64(char *buf, struct mlxsw_item *item, 142 unsigned short index) 143{ 144 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u64)); 145 __be64 *b = (__be64 *) buf; 146 u64 tmp; 147 148 tmp = be64_to_cpu(b[offset]); 149 tmp >>= item->shift; 150 tmp &= GENMASK_ULL(item->size.bits - 1, 0); 151 if (item->no_real_shift) 152 tmp <<= item->shift; 153 return tmp; 154} 155 156static inline void __mlxsw_item_set64(char *buf, struct mlxsw_item *item, 157 unsigned short index, u64 val) 158{ 159 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u64)); 160 __be64 *b = (__be64 *) buf; 161 u64 mask = GENMASK_ULL(item->size.bits - 1, 0) << item->shift; 162 u64 tmp; 163 164 if (!item->no_real_shift) 165 val <<= item->shift; 166 val &= mask; 167 tmp = be64_to_cpu(b[offset]); 168 tmp &= ~mask; 169 tmp |= val; 170 b[offset] = cpu_to_be64(tmp); 171} 172 173static inline void __mlxsw_item_memcpy_from(char *buf, char *dst, 174 struct mlxsw_item *item, 175 unsigned short index) 176{ 177 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(char)); 178 179 memcpy(dst, &buf[offset], item->size.bytes); 180} 181 182static inline void __mlxsw_item_memcpy_to(char *buf, const char *src, 183 struct mlxsw_item *item, 184 unsigned short index) 185{ 186 unsigned int offset = __mlxsw_item_offset(item, index, sizeof(char)); 187 188 memcpy(&buf[offset], src, item->size.bytes); 189} 190 191static inline u16 192__mlxsw_item_bit_array_offset(struct mlxsw_item *item, u16 index, u8 *shift) 193{ 194 u16 max_index, be_index; 195 u16 offset; /* byte offset inside the array */ 196 u8 in_byte_index; 197 198 BUG_ON(index && !item->element_size); 199 if (item->offset % sizeof(u32) != 0 || 200 BITS_PER_BYTE % item->element_size != 0) { 201 pr_err("mlxsw: item bug (name=%s,offset=%x,element_size=%x)\n", 202 item->name, item->offset, item->element_size); 203 BUG(); 204 } 205 206 max_index = (item->size.bytes << 3) / item->element_size - 1; 207 be_index = max_index - index; 208 offset = be_index * item->element_size >> 3; 209 in_byte_index = index % (BITS_PER_BYTE / item->element_size); 210 *shift = in_byte_index * item->element_size; 211 212 return item->offset + offset; 213} 214 215static inline u8 __mlxsw_item_bit_array_get(char *buf, struct mlxsw_item *item, 216 u16 index) 217{ 218 u8 shift, tmp; 219 u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift); 220 221 tmp = buf[offset]; 222 tmp >>= shift; 223 tmp &= GENMASK(item->element_size - 1, 0); 224 return tmp; 225} 226 227static inline void __mlxsw_item_bit_array_set(char *buf, struct mlxsw_item *item, 228 u16 index, u8 val) 229{ 230 u8 shift, tmp; 231 u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift); 232 u8 mask = GENMASK(item->element_size - 1, 0) << shift; 233 234 val <<= shift; 235 val &= mask; 236 tmp = buf[offset]; 237 tmp &= ~mask; 238 tmp |= val; 239 buf[offset] = tmp; 240} 241 242#define __ITEM_NAME(_type, _cname, _iname) \ 243 mlxsw_##_type##_##_cname##_##_iname##_item 244 245/* _type: cmd_mbox, reg, etc. 246 * _cname: containter name (e.g. command name, register name) 247 * _iname: item name within the container 248 */ 249 250#define MLXSW_ITEM16(_type, _cname, _iname, _offset, _shift, _sizebits) \ 251static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 252 .offset = _offset, \ 253 .shift = _shift, \ 254 .size = {.bits = _sizebits,}, \ 255 .name = #_type "_" #_cname "_" #_iname, \ 256}; \ 257static inline u16 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf) \ 258{ \ 259 return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \ 260} \ 261static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 val)\ 262{ \ 263 __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val); \ 264} 265 266#define MLXSW_ITEM16_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \ 267 _step, _instepoffset, _norealshift) \ 268static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 269 .offset = _offset, \ 270 .step = _step, \ 271 .in_step_offset = _instepoffset, \ 272 .shift = _shift, \ 273 .no_real_shift = _norealshift, \ 274 .size = {.bits = _sizebits,}, \ 275 .name = #_type "_" #_cname "_" #_iname, \ 276}; \ 277static inline u16 \ 278mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index) \ 279{ \ 280 return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname), \ 281 index); \ 282} \ 283static inline void \ 284mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index, \ 285 u16 val) \ 286{ \ 287 __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname), \ 288 index, val); \ 289} 290 291#define MLXSW_ITEM32(_type, _cname, _iname, _offset, _shift, _sizebits) \ 292static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 293 .offset = _offset, \ 294 .shift = _shift, \ 295 .size = {.bits = _sizebits,}, \ 296 .name = #_type "_" #_cname "_" #_iname, \ 297}; \ 298static inline u32 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf) \ 299{ \ 300 return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \ 301} \ 302static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u32 val)\ 303{ \ 304 __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val); \ 305} 306 307#define MLXSW_ITEM32_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \ 308 _step, _instepoffset, _norealshift) \ 309static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 310 .offset = _offset, \ 311 .step = _step, \ 312 .in_step_offset = _instepoffset, \ 313 .shift = _shift, \ 314 .no_real_shift = _norealshift, \ 315 .size = {.bits = _sizebits,}, \ 316 .name = #_type "_" #_cname "_" #_iname, \ 317}; \ 318static inline u32 \ 319mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index) \ 320{ \ 321 return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname), \ 322 index); \ 323} \ 324static inline void \ 325mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index, \ 326 u32 val) \ 327{ \ 328 __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname), \ 329 index, val); \ 330} 331 332#define MLXSW_ITEM64(_type, _cname, _iname, _offset, _shift, _sizebits) \ 333static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 334 .offset = _offset, \ 335 .shift = _shift, \ 336 .size = {.bits = _sizebits,}, \ 337 .name = #_type "_" #_cname "_" #_iname, \ 338}; \ 339static inline u64 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf) \ 340{ \ 341 return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \ 342} \ 343static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u64 val)\ 344{ \ 345 __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val); \ 346} 347 348#define MLXSW_ITEM64_INDEXED(_type, _cname, _iname, _offset, _shift, \ 349 _sizebits, _step, _instepoffset, _norealshift) \ 350static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 351 .offset = _offset, \ 352 .step = _step, \ 353 .in_step_offset = _instepoffset, \ 354 .shift = _shift, \ 355 .no_real_shift = _norealshift, \ 356 .size = {.bits = _sizebits,}, \ 357 .name = #_type "_" #_cname "_" #_iname, \ 358}; \ 359static inline u64 \ 360mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index) \ 361{ \ 362 return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname), \ 363 index); \ 364} \ 365static inline void \ 366mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index, \ 367 u64 val) \ 368{ \ 369 __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname), \ 370 index, val); \ 371} 372 373#define MLXSW_ITEM_BUF(_type, _cname, _iname, _offset, _sizebytes) \ 374static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 375 .offset = _offset, \ 376 .size = {.bytes = _sizebytes,}, \ 377 .name = #_type "_" #_cname "_" #_iname, \ 378}; \ 379static inline void \ 380mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(char *buf, char *dst) \ 381{ \ 382 __mlxsw_item_memcpy_from(buf, dst, \ 383 &__ITEM_NAME(_type, _cname, _iname), 0); \ 384} \ 385static inline void \ 386mlxsw_##_type##_##_cname##_##_iname##_memcpy_to(char *buf, const char *src) \ 387{ \ 388 __mlxsw_item_memcpy_to(buf, src, \ 389 &__ITEM_NAME(_type, _cname, _iname), 0); \ 390} 391 392#define MLXSW_ITEM_BUF_INDEXED(_type, _cname, _iname, _offset, _sizebytes, \ 393 _step, _instepoffset) \ 394static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 395 .offset = _offset, \ 396 .step = _step, \ 397 .in_step_offset = _instepoffset, \ 398 .size = {.bytes = _sizebytes,}, \ 399 .name = #_type "_" #_cname "_" #_iname, \ 400}; \ 401static inline void \ 402mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(char *buf, \ 403 unsigned short index, \ 404 char *dst) \ 405{ \ 406 __mlxsw_item_memcpy_from(buf, dst, \ 407 &__ITEM_NAME(_type, _cname, _iname), index); \ 408} \ 409static inline void \ 410mlxsw_##_type##_##_cname##_##_iname##_memcpy_to(char *buf, \ 411 unsigned short index, \ 412 const char *src) \ 413{ \ 414 __mlxsw_item_memcpy_to(buf, src, \ 415 &__ITEM_NAME(_type, _cname, _iname), index); \ 416} 417 418#define MLXSW_ITEM_BIT_ARRAY(_type, _cname, _iname, _offset, _sizebytes, \ 419 _element_size) \ 420static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = { \ 421 .offset = _offset, \ 422 .element_size = _element_size, \ 423 .size = {.bytes = _sizebytes,}, \ 424 .name = #_type "_" #_cname "_" #_iname, \ 425}; \ 426static inline u8 \ 427mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, u16 index) \ 428{ \ 429 return __mlxsw_item_bit_array_get(buf, \ 430 &__ITEM_NAME(_type, _cname, _iname), \ 431 index); \ 432} \ 433static inline void \ 434mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 index, u8 val) \ 435{ \ 436 return __mlxsw_item_bit_array_set(buf, \ 437 &__ITEM_NAME(_type, _cname, _iname), \ 438 index, val); \ 439} \ 440 441#endif 442