drivers/net/ethernet/mellanox/mlxsw/item.h

   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
  43 struct 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
  57 static 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
  75 static 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
  90 static 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
 108 static 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
 123 static 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
 141 static 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
 156 static 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
 173 static 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
 182 static 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
 191 static 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
 215 static 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
 227 static 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)         \
 251 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 252         .offset = _offset,                                                      \
 253         .shift = _shift,                                                        \
 254         .size = {.bits = _sizebits,},                                           \
 255         .name = #_type "_" #_cname "_" #_iname,                                 \
 256 };                                                                              \
 257 static inline u16 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 258 {                                                                               \
 259         return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 260 }                                                                               \
 261 static 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)                \
 268 static 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 };                                                                              \
 277 static inline u16                                                               \
 278 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 279 {                                                                               \
 280         return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 281                                   index);                                       \
 282 }                                                                               \
 283 static inline void                                                              \
 284 mlxsw_##_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)         \
 292 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 293         .offset = _offset,                                                      \
 294         .shift = _shift,                                                        \
 295         .size = {.bits = _sizebits,},                                           \
 296         .name = #_type "_" #_cname "_" #_iname,                                 \
 297 };                                                                              \
 298 static inline u32 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 299 {                                                                               \
 300         return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 301 }                                                                               \
 302 static 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)                \
 309 static 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 };                                                                              \
 318 static inline u32                                                               \
 319 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 320 {                                                                               \
 321         return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 322                                   index);                                       \
 323 }                                                                               \
 324 static inline void                                                              \
 325 mlxsw_##_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)         \
 333 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 334         .offset = _offset,                                                      \
 335         .shift = _shift,                                                        \
 336         .size = {.bits = _sizebits,},                                           \
 337         .name = #_type "_" #_cname "_" #_iname,                                 \
 338 };                                                                              \
 339 static inline u64 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 340 {                                                                               \
 341         return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 342 }                                                                               \
 343 static 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)     \
 350 static 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 };                                                                              \
 359 static inline u64                                                               \
 360 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 361 {                                                                               \
 362         return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 363                                   index);                                       \
 364 }                                                                               \
 365 static inline void                                                              \
 366 mlxsw_##_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)              \
 374 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 375         .offset = _offset,                                                      \
 376         .size = {.bytes = _sizebytes,},                                         \
 377         .name = #_type "_" #_cname "_" #_iname,                                 \
 378 };                                                                              \
 379 static inline void                                                              \
 380 mlxsw_##_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 }                                                                               \
 385 static inline void                                                              \
 386 mlxsw_##_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)                            \
 394 static 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 };                                                                              \
 401 static inline void                                                              \
 402 mlxsw_##_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 }                                                                               \
 409 static inline void                                                              \
 410 mlxsw_##_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)                                     \
 420 static 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 };                                                                              \
 426 static inline u8                                                                \
 427 mlxsw_##_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 }                                                                               \
 433 static inline void                                                              \
 434 mlxsw_##_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