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