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 {
 176         memcpy(dst, &buf[item->offset], item->size.bytes);
 177 }
 178
 179 static inline void __mlxsw_item_memcpy_to(char *buf, char *src,
 180                                           struct mlxsw_item *item)
 181 {
 182         memcpy(&buf[item->offset], src, item->size.bytes);
 183 }
 184
 185 static inline u16
 186 __mlxsw_item_bit_array_offset(struct mlxsw_item *item, u16 index, u8 *shift)
 187 {
 188         u16 max_index, be_index;
 189         u16 offset;             /* byte offset inside the array */
 190
 191         BUG_ON(index && !item->element_size);
 192         if (item->offset % sizeof(u32) != 0 ||
 193             BITS_PER_BYTE % item->element_size != 0) {
 194                 pr_err("mlxsw: item bug (name=%s,offset=%x,element_size=%x)\n",
 195                        item->name, item->offset, item->element_size);
 196                 BUG();
 197         }
 198
 199         max_index = (item->size.bytes << 3) / item->element_size - 1;
 200         be_index = max_index - index;
 201         offset = be_index * item->element_size >> 3;
 202         *shift = index % (BITS_PER_BYTE / item->element_size) << 1;
 203
 204         return item->offset + offset;
 205 }
 206
 207 static inline u8 __mlxsw_item_bit_array_get(char *buf, struct mlxsw_item *item,
 208                                             u16 index)
 209 {
 210         u8 shift, tmp;
 211         u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift);
 212
 213         tmp = buf[offset];
 214         tmp >>= shift;
 215         tmp &= GENMASK(item->element_size - 1, 0);
 216         return tmp;
 217 }
 218
 219 static inline void __mlxsw_item_bit_array_set(char *buf, struct mlxsw_item *item,
 220                                               u16 index, u8 val)
 221 {
 222         u8 shift, tmp;
 223         u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift);
 224         u8 mask = GENMASK(item->element_size - 1, 0) << shift;
 225
 226         val <<= shift;
 227         val &= mask;
 228         tmp = buf[offset];
 229         tmp &= ~mask;
 230         tmp |= val;
 231         buf[offset] = tmp;
 232 }
 233
 234 #define __ITEM_NAME(_type, _cname, _iname)                                      \
 235         mlxsw_##_type##_##_cname##_##_iname##_item
 236
 237 /* _type: cmd_mbox, reg, etc.
 238  * _cname: containter name (e.g. command name, register name)
 239  * _iname: item name within the container
 240  */
 241
 242 #define MLXSW_ITEM16(_type, _cname, _iname, _offset, _shift, _sizebits)         \
 243 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 244         .offset = _offset,                                                      \
 245         .shift = _shift,                                                        \
 246         .size = {.bits = _sizebits,},                                           \
 247         .name = #_type "_" #_cname "_" #_iname,                                 \
 248 };                                                                              \
 249 static inline u16 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 250 {                                                                               \
 251         return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 252 }                                                                               \
 253 static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 val)\
 254 {                                                                               \
 255         __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
 256 }
 257
 258 #define MLXSW_ITEM16_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \
 259                              _step, _instepoffset, _norealshift)                \
 260 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 261         .offset = _offset,                                                      \
 262         .step = _step,                                                          \
 263         .in_step_offset = _instepoffset,                                        \
 264         .shift = _shift,                                                        \
 265         .no_real_shift = _norealshift,                                          \
 266         .size = {.bits = _sizebits,},                                           \
 267         .name = #_type "_" #_cname "_" #_iname,                                 \
 268 };                                                                              \
 269 static inline u16                                                               \
 270 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 271 {                                                                               \
 272         return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 273                                   index);                                       \
 274 }                                                                               \
 275 static inline void                                                              \
 276 mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
 277                                           u16 val)                              \
 278 {                                                                               \
 279         __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname),            \
 280                            index, val);                                         \
 281 }
 282
 283 #define MLXSW_ITEM32(_type, _cname, _iname, _offset, _shift, _sizebits)         \
 284 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 285         .offset = _offset,                                                      \
 286         .shift = _shift,                                                        \
 287         .size = {.bits = _sizebits,},                                           \
 288         .name = #_type "_" #_cname "_" #_iname,                                 \
 289 };                                                                              \
 290 static inline u32 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 291 {                                                                               \
 292         return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 293 }                                                                               \
 294 static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u32 val)\
 295 {                                                                               \
 296         __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
 297 }
 298
 299 #define MLXSW_ITEM32_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \
 300                              _step, _instepoffset, _norealshift)                \
 301 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 302         .offset = _offset,                                                      \
 303         .step = _step,                                                          \
 304         .in_step_offset = _instepoffset,                                        \
 305         .shift = _shift,                                                        \
 306         .no_real_shift = _norealshift,                                          \
 307         .size = {.bits = _sizebits,},                                           \
 308         .name = #_type "_" #_cname "_" #_iname,                                 \
 309 };                                                                              \
 310 static inline u32                                                               \
 311 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 312 {                                                                               \
 313         return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 314                                   index);                                       \
 315 }                                                                               \
 316 static inline void                                                              \
 317 mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
 318                                           u32 val)                              \
 319 {                                                                               \
 320         __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname),            \
 321                            index, val);                                         \
 322 }
 323
 324 #define MLXSW_ITEM64(_type, _cname, _iname, _offset, _shift, _sizebits)         \
 325 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 326         .offset = _offset,                                                      \
 327         .shift = _shift,                                                        \
 328         .size = {.bits = _sizebits,},                                           \
 329         .name = #_type "_" #_cname "_" #_iname,                                 \
 330 };                                                                              \
 331 static inline u64 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf)          \
 332 {                                                                               \
 333         return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
 334 }                                                                               \
 335 static inline void mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u64 val)\
 336 {                                                                               \
 337         __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
 338 }
 339
 340 #define MLXSW_ITEM64_INDEXED(_type, _cname, _iname, _offset, _shift,            \
 341                              _sizebits, _step, _instepoffset, _norealshift)     \
 342 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 343         .offset = _offset,                                                      \
 344         .step = _step,                                                          \
 345         .in_step_offset = _instepoffset,                                        \
 346         .shift = _shift,                                                        \
 347         .no_real_shift = _norealshift,                                          \
 348         .size = {.bits = _sizebits,},                                           \
 349         .name = #_type "_" #_cname "_" #_iname,                                 \
 350 };                                                                              \
 351 static inline u64                                                               \
 352 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, unsigned short index)      \
 353 {                                                                               \
 354         return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname),     \
 355                                   index);                                       \
 356 }                                                                               \
 357 static inline void                                                              \
 358 mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
 359                                           u64 val)                              \
 360 {                                                                               \
 361         __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname),            \
 362                            index, val);                                         \
 363 }
 364
 365 #define MLXSW_ITEM_BUF(_type, _cname, _iname, _offset, _sizebytes)              \
 366 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 367         .offset = _offset,                                                      \
 368         .size = {.bytes = _sizebytes,},                                         \
 369         .name = #_type "_" #_cname "_" #_iname,                                 \
 370 };                                                                              \
 371 static inline void                                                              \
 372 mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(char *buf, char *dst)         \
 373 {                                                                               \
 374         __mlxsw_item_memcpy_from(buf, dst, &__ITEM_NAME(_type, _cname, _iname));\
 375 }                                                                               \
 376 static inline void                                                              \
 377 mlxsw_##_type##_##_cname##_##_iname##_memcpy_to(char *buf, char *src)           \
 378 {                                                                               \
 379         __mlxsw_item_memcpy_to(buf, src, &__ITEM_NAME(_type, _cname, _iname));  \
 380 }
 381
 382 #define MLXSW_ITEM_BIT_ARRAY(_type, _cname, _iname, _offset, _sizebytes,        \
 383                              _element_size)                                     \
 384 static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
 385         .offset = _offset,                                                      \
 386         .element_size = _element_size,                                          \
 387         .size = {.bytes = _sizebytes,},                                         \
 388         .name = #_type "_" #_cname "_" #_iname,                                 \
 389 };                                                                              \
 390 static inline u8                                                                \
 391 mlxsw_##_type##_##_cname##_##_iname##_get(char *buf, u16 index)                 \
 392 {                                                                               \
 393         return __mlxsw_item_bit_array_get(buf,                                  \
 394                                           &__ITEM_NAME(_type, _cname, _iname),  \
 395                                           index);                               \
 396 }                                                                               \
 397 static inline void                                                              \
 398 mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 index, u8 val)         \
 399 {                                                                               \
 400         return __mlxsw_item_bit_array_set(buf,                                  \
 401                                           &__ITEM_NAME(_type, _cname, _iname),  \
 402                                           index, val);                          \
 403 }                                                                               \
 404
 405 #endif