[mirror_ubuntu-jammy-kernel.git] / include / trace / events / smbus.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/* SMBUS message transfer tracepoints
 *
 * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM smbus

#if !defined(_TRACE_SMBUS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SMBUS_H

#include <linux/i2c.h>
#include <linux/tracepoint.h>

/*
 * drivers/i2c/i2c-core-smbus.c
 */

/*
 * i2c_smbus_xfer() write data or procedure call request
 */
TRACE_EVENT_CONDITION(smbus_write,
	TP_PROTO(const struct i2c_adapter *adap,
		 u16 addr, unsigned short flags,
		 char read_write, u8 command, int protocol,
		 const union i2c_smbus_data *data),
	TP_ARGS(adap, addr, flags, read_write, command, protocol, data),
	TP_CONDITION(read_write == I2C_SMBUS_WRITE ||
		     protocol == I2C_SMBUS_PROC_CALL ||
		     protocol == I2C_SMBUS_BLOCK_PROC_CALL),
	TP_STRUCT__entry(
		__field(int,	adapter_nr		)
		__field(__u16,	addr			)
		__field(__u16,	flags			)
		__field(__u8,	command			)
		__field(__u8,	len			)
		__field(__u32,	protocol		)
		__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2)	),
	TP_fast_assign(
		__entry->adapter_nr = adap->nr;
		__entry->addr = addr;
		__entry->flags = flags;
		__entry->command = command;
		__entry->protocol = protocol;

		switch (protocol) {
		case I2C_SMBUS_BYTE_DATA:
			__entry->len = 1;
			goto copy;
		case I2C_SMBUS_WORD_DATA:
		case I2C_SMBUS_PROC_CALL:
			__entry->len = 2;
			goto copy;
		case I2C_SMBUS_BLOCK_DATA:
		case I2C_SMBUS_BLOCK_PROC_CALL:
		case I2C_SMBUS_I2C_BLOCK_DATA:
			__entry->len = data->block[0] + 1;
		copy:
			memcpy(__entry->buf, data->block, __entry->len);
			break;
		case I2C_SMBUS_QUICK:
		case I2C_SMBUS_BYTE:
		case I2C_SMBUS_I2C_BLOCK_BROKEN:
		default:
			__entry->len = 0;
		}
		       ),
	TP_printk("i2c-%d a=%03x f=%04x c=%x %s l=%u [%*phD]",
		  __entry->adapter_nr,
		  __entry->addr,
		  __entry->flags,
		  __entry->command,
		  __print_symbolic(__entry->protocol,
				   { I2C_SMBUS_QUICK,		"QUICK"	},
				   { I2C_SMBUS_BYTE,		"BYTE"	},
				   { I2C_SMBUS_BYTE_DATA,		"BYTE_DATA" },
				   { I2C_SMBUS_WORD_DATA,		"WORD_DATA" },
				   { I2C_SMBUS_PROC_CALL,		"PROC_CALL" },
				   { I2C_SMBUS_BLOCK_DATA,		"BLOCK_DATA" },
				   { I2C_SMBUS_I2C_BLOCK_BROKEN,	"I2C_BLOCK_BROKEN" },
				   { I2C_SMBUS_BLOCK_PROC_CALL,	"BLOCK_PROC_CALL" },
				   { I2C_SMBUS_I2C_BLOCK_DATA,	"I2C_BLOCK_DATA" }),
		  __entry->len,
		  __entry->len, __entry->buf
		  ));

/*
 * i2c_smbus_xfer() read data request
 */
TRACE_EVENT_CONDITION(smbus_read,
	TP_PROTO(const struct i2c_adapter *adap,
		 u16 addr, unsigned short flags,
		 char read_write, u8 command, int protocol),
	TP_ARGS(adap, addr, flags, read_write, command, protocol),
	TP_CONDITION(!(read_write == I2C_SMBUS_WRITE ||
		       protocol == I2C_SMBUS_PROC_CALL ||
		       protocol == I2C_SMBUS_BLOCK_PROC_CALL)),
	TP_STRUCT__entry(
		__field(int,	adapter_nr		)
		__field(__u16,	flags			)
		__field(__u16,	addr			)
		__field(__u8,	command			)
		__field(__u32,	protocol		)
		__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2)	),
	TP_fast_assign(
		__entry->adapter_nr = adap->nr;
		__entry->addr = addr;
		__entry->flags = flags;
		__entry->command = command;
		__entry->protocol = protocol;
		       ),
	TP_printk("i2c-%d a=%03x f=%04x c=%x %s",
		  __entry->adapter_nr,
		  __entry->addr,
		  __entry->flags,
		  __entry->command,
		  __print_symbolic(__entry->protocol,
				   { I2C_SMBUS_QUICK,		"QUICK"	},
				   { I2C_SMBUS_BYTE,		"BYTE"	},
				   { I2C_SMBUS_BYTE_DATA,		"BYTE_DATA" },
				   { I2C_SMBUS_WORD_DATA,		"WORD_DATA" },
				   { I2C_SMBUS_PROC_CALL,		"PROC_CALL" },
				   { I2C_SMBUS_BLOCK_DATA,		"BLOCK_DATA" },
				   { I2C_SMBUS_I2C_BLOCK_BROKEN,	"I2C_BLOCK_BROKEN" },
				   { I2C_SMBUS_BLOCK_PROC_CALL,	"BLOCK_PROC_CALL" },
				   { I2C_SMBUS_I2C_BLOCK_DATA,	"I2C_BLOCK_DATA" })
		  ));

/*
 * i2c_smbus_xfer() read data or procedure call reply
 */
TRACE_EVENT_CONDITION(smbus_reply,
	TP_PROTO(const struct i2c_adapter *adap,
		 u16 addr, unsigned short flags,
		 char read_write, u8 command, int protocol,
		 const union i2c_smbus_data *data, int res),
	TP_ARGS(adap, addr, flags, read_write, command, protocol, data, res),
	TP_CONDITION(res >= 0 && read_write == I2C_SMBUS_READ),
	TP_STRUCT__entry(
		__field(int,	adapter_nr		)
		__field(__u16,	addr			)
		__field(__u16,	flags			)
		__field(__u8,	command			)
		__field(__u8,	len			)
		__field(__u32,	protocol		)
		__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2)	),
	TP_fast_assign(
		__entry->adapter_nr = adap->nr;
		__entry->addr = addr;
		__entry->flags = flags;
		__entry->command = command;
		__entry->protocol = protocol;

		switch (protocol) {
		case I2C_SMBUS_BYTE:
		case I2C_SMBUS_BYTE_DATA:
			__entry->len = 1;
			goto copy;
		case I2C_SMBUS_WORD_DATA:
		case I2C_SMBUS_PROC_CALL:
			__entry->len = 2;
			goto copy;
		case I2C_SMBUS_BLOCK_DATA:
		case I2C_SMBUS_BLOCK_PROC_CALL:
		case I2C_SMBUS_I2C_BLOCK_DATA:
			__entry->len = data->block[0] + 1;
		copy:
			memcpy(__entry->buf, data->block, __entry->len);
			break;
		case I2C_SMBUS_QUICK:
		case I2C_SMBUS_I2C_BLOCK_BROKEN:
		default:
			__entry->len = 0;
		}
		       ),
	TP_printk("i2c-%d a=%03x f=%04x c=%x %s l=%u [%*phD]",
		  __entry->adapter_nr,
		  __entry->addr,
		  __entry->flags,
		  __entry->command,
		  __print_symbolic(__entry->protocol,
				   { I2C_SMBUS_QUICK,		"QUICK"	},
				   { I2C_SMBUS_BYTE,		"BYTE"	},
				   { I2C_SMBUS_BYTE_DATA,		"BYTE_DATA" },
				   { I2C_SMBUS_WORD_DATA,		"WORD_DATA" },
				   { I2C_SMBUS_PROC_CALL,		"PROC_CALL" },
				   { I2C_SMBUS_BLOCK_DATA,		"BLOCK_DATA" },
				   { I2C_SMBUS_I2C_BLOCK_BROKEN,	"I2C_BLOCK_BROKEN" },
				   { I2C_SMBUS_BLOCK_PROC_CALL,	"BLOCK_PROC_CALL" },
				   { I2C_SMBUS_I2C_BLOCK_DATA,	"I2C_BLOCK_DATA" }),
		  __entry->len,
		  __entry->len, __entry->buf
		  ));

/*
 * i2c_smbus_xfer() result
 */
TRACE_EVENT(smbus_result,
	    TP_PROTO(const struct i2c_adapter *adap,
		     u16 addr, unsigned short flags,
		     char read_write, u8 command, int protocol,
		     int res),
	    TP_ARGS(adap, addr, flags, read_write, command, protocol, res),
	    TP_STRUCT__entry(
		    __field(int,	adapter_nr		)
		    __field(__u16,	addr			)
		    __field(__u16,	flags			)
		    __field(__u8,	read_write		)
		    __field(__u8,	command			)
		    __field(__s16,	res			)
		    __field(__u32,	protocol		)
			     ),
	    TP_fast_assign(
		    __entry->adapter_nr = adap->nr;
		    __entry->addr = addr;
		    __entry->flags = flags;
		    __entry->read_write = read_write;
		    __entry->command = command;
		    __entry->protocol = protocol;
		    __entry->res = res;
			   ),
	    TP_printk("i2c-%d a=%03x f=%04x c=%x %s %s res=%d",
		      __entry->adapter_nr,
		      __entry->addr,
		      __entry->flags,
		      __entry->command,
		      __print_symbolic(__entry->protocol,
				       { I2C_SMBUS_QUICK,		"QUICK"	},
				       { I2C_SMBUS_BYTE,		"BYTE"	},
				       { I2C_SMBUS_BYTE_DATA,		"BYTE_DATA" },
				       { I2C_SMBUS_WORD_DATA,		"WORD_DATA" },
				       { I2C_SMBUS_PROC_CALL,		"PROC_CALL" },
				       { I2C_SMBUS_BLOCK_DATA,		"BLOCK_DATA" },
				       { I2C_SMBUS_I2C_BLOCK_BROKEN,	"I2C_BLOCK_BROKEN" },
				       { I2C_SMBUS_BLOCK_PROC_CALL,	"BLOCK_PROC_CALL" },
				       { I2C_SMBUS_I2C_BLOCK_DATA,	"I2C_BLOCK_DATA" }),
		      __entry->read_write == I2C_SMBUS_WRITE ? "wr" : "rd",
		      __entry->res
		      ));

#endif /* _TRACE_SMBUS_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
b4d0d230	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
22c78d1c WS	2	/* SMBUS message transfer tracepoints
	3	*
	4	* Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
22c78d1c WS	6	*/
	7	#undef TRACE_SYSTEM
	8	#define TRACE_SYSTEM smbus
	9
	10	#if !defined(_TRACE_SMBUS_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	11	#define _TRACE_SMBUS_H
	12
	13	#include <linux/i2c.h>
	14	#include <linux/tracepoint.h>
	15
	16	/*
	17	* drivers/i2c/i2c-core-smbus.c
	18	*/
	19
	20	/*
	21	* i2c_smbus_xfer() write data or procedure call request
	22	*/
	23	TRACE_EVENT_CONDITION(smbus_write,
	24	TP_PROTO(const struct i2c_adapter *adap,
	25	u16 addr, unsigned short flags,
	26	char read_write, u8 command, int protocol,
	27	const union i2c_smbus_data *data),
	28	TP_ARGS(adap, addr, flags, read_write, command, protocol, data),
	29	TP_CONDITION(read_write == I2C_SMBUS_WRITE \|\|
	30	protocol == I2C_SMBUS_PROC_CALL \|\|
	31	protocol == I2C_SMBUS_BLOCK_PROC_CALL),
	32	TP_STRUCT__entry(
	33	__field(int, adapter_nr )
	34	__field(__u16, addr )
	35	__field(__u16, flags )
	36	__field(__u8, command )
	37	__field(__u8, len )
	38	__field(__u32, protocol )
	39	__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2) ),
	40	TP_fast_assign(
	41	__entry->adapter_nr = adap->nr;
	42	__entry->addr = addr;
	43	__entry->flags = flags;
	44	__entry->command = command;
	45	__entry->protocol = protocol;
	46
	47	switch (protocol) {
	48	case I2C_SMBUS_BYTE_DATA:
	49	__entry->len = 1;
	50	goto copy;
	51	case I2C_SMBUS_WORD_DATA:
	52	case I2C_SMBUS_PROC_CALL:
	53	__entry->len = 2;
	54	goto copy;
	55	case I2C_SMBUS_BLOCK_DATA:
	56	case I2C_SMBUS_BLOCK_PROC_CALL:
	57	case I2C_SMBUS_I2C_BLOCK_DATA:
	58	__entry->len = data->block[0] + 1;
	59	copy:
	60	memcpy(__entry->buf, data->block, __entry->len);
	61	break;
	62	case I2C_SMBUS_QUICK:
	63	case I2C_SMBUS_BYTE:
	64	case I2C_SMBUS_I2C_BLOCK_BROKEN:
	65	default:
	66	__entry->len = 0;
	67	}
	68	),
	69	TP_printk("i2c-%d a=%03x f=%04x c=%x %s l=%u [%*phD]",
70	__entry->adapter_nr,
71	__entry->addr,
72	__entry->flags,
73	__entry->command,
74	__print_symbolic(__entry->protocol,
75	{ I2C_SMBUS_QUICK, "QUICK" },
76	{ I2C_SMBUS_BYTE, "BYTE" },
77	{ I2C_SMBUS_BYTE_DATA, "BYTE_DATA" },
78	{ I2C_SMBUS_WORD_DATA, "WORD_DATA" },
79	{ I2C_SMBUS_PROC_CALL, "PROC_CALL" },
80	{ I2C_SMBUS_BLOCK_DATA, "BLOCK_DATA" },
81	{ I2C_SMBUS_I2C_BLOCK_BROKEN, "I2C_BLOCK_BROKEN" },
82	{ I2C_SMBUS_BLOCK_PROC_CALL, "BLOCK_PROC_CALL" },
83	{ I2C_SMBUS_I2C_BLOCK_DATA, "I2C_BLOCK_DATA" }),
84	__entry->len,
85	__entry->len, __entry->buf
86	));
87
88	/*
89	* i2c_smbus_xfer() read data request
90	*/
91	TRACE_EVENT_CONDITION(smbus_read,
92	TP_PROTO(const struct i2c_adapter *adap,
93	u16 addr, unsigned short flags,
94	char read_write, u8 command, int protocol),
95	TP_ARGS(adap, addr, flags, read_write, command, protocol),
96	TP_CONDITION(!(read_write == I2C_SMBUS_WRITE \|\|
97	protocol == I2C_SMBUS_PROC_CALL \|\|
98	protocol == I2C_SMBUS_BLOCK_PROC_CALL)),
99	TP_STRUCT__entry(
100	__field(int, adapter_nr )
101	__field(__u16, flags )
102	__field(__u16, addr )
103	__field(__u8, command )
104	__field(__u32, protocol )
105	__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2) ),
106	TP_fast_assign(
107	__entry->adapter_nr = adap->nr;
108	__entry->addr = addr;
109	__entry->flags = flags;
110	__entry->command = command;
111	__entry->protocol = protocol;
112	),
113	TP_printk("i2c-%d a=%03x f=%04x c=%x %s",
114	__entry->adapter_nr,
115	__entry->addr,
116	__entry->flags,
117	__entry->command,
118	__print_symbolic(__entry->protocol,
119	{ I2C_SMBUS_QUICK, "QUICK" },
120	{ I2C_SMBUS_BYTE, "BYTE" },
121	{ I2C_SMBUS_BYTE_DATA, "BYTE_DATA" },
122	{ I2C_SMBUS_WORD_DATA, "WORD_DATA" },
123	{ I2C_SMBUS_PROC_CALL, "PROC_CALL" },
124	{ I2C_SMBUS_BLOCK_DATA, "BLOCK_DATA" },
125	{ I2C_SMBUS_I2C_BLOCK_BROKEN, "I2C_BLOCK_BROKEN" },
126	{ I2C_SMBUS_BLOCK_PROC_CALL, "BLOCK_PROC_CALL" },
127	{ I2C_SMBUS_I2C_BLOCK_DATA, "I2C_BLOCK_DATA" })
128	));
129
130	/*
131	* i2c_smbus_xfer() read data or procedure call reply
132	*/
133	TRACE_EVENT_CONDITION(smbus_reply,
134	TP_PROTO(const struct i2c_adapter *adap,
135	u16 addr, unsigned short flags,
136	char read_write, u8 command, int protocol,
d8434c31 JS	137	const union i2c_smbus_data *data, int res),
	138	TP_ARGS(adap, addr, flags, read_write, command, protocol, data, res),
	139	TP_CONDITION(res >= 0 && read_write == I2C_SMBUS_READ),
22c78d1c WS	140	TP_STRUCT__entry(
	141	__field(int, adapter_nr )
	142	__field(__u16, addr )
	143	__field(__u16, flags )
	144	__field(__u8, command )
	145	__field(__u8, len )
	146	__field(__u32, protocol )
	147	__array(__u8, buf, I2C_SMBUS_BLOCK_MAX + 2) ),
	148	TP_fast_assign(
	149	__entry->adapter_nr = adap->nr;
	150	__entry->addr = addr;
	151	__entry->flags = flags;
	152	__entry->command = command;
	153	__entry->protocol = protocol;
	154
	155	switch (protocol) {
	156	case I2C_SMBUS_BYTE:
	157	case I2C_SMBUS_BYTE_DATA:
	158	__entry->len = 1;
	159	goto copy;
	160	case I2C_SMBUS_WORD_DATA:
	161	case I2C_SMBUS_PROC_CALL:
	162	__entry->len = 2;
	163	goto copy;
	164	case I2C_SMBUS_BLOCK_DATA:
	165	case I2C_SMBUS_BLOCK_PROC_CALL:
	166	case I2C_SMBUS_I2C_BLOCK_DATA:
	167	__entry->len = data->block[0] + 1;
	168	copy:
	169	memcpy(__entry->buf, data->block, __entry->len);
	170	break;
	171	case I2C_SMBUS_QUICK:
	172	case I2C_SMBUS_I2C_BLOCK_BROKEN:
	173	default:
	174	__entry->len = 0;
	175	}
	176	),
	177	TP_printk("i2c-%d a=%03x f=%04x c=%x %s l=%u [%*phD]",
	178	__entry->adapter_nr,
	179	__entry->addr,
	180	__entry->flags,
	181	__entry->command,
	182	__print_symbolic(__entry->protocol,
	183	{ I2C_SMBUS_QUICK, "QUICK" },
	184	{ I2C_SMBUS_BYTE, "BYTE" },
	185	{ I2C_SMBUS_BYTE_DATA, "BYTE_DATA" },
	186	{ I2C_SMBUS_WORD_DATA, "WORD_DATA" },
	187	{ I2C_SMBUS_PROC_CALL, "PROC_CALL" },
	188	{ I2C_SMBUS_BLOCK_DATA, "BLOCK_DATA" },
	189	{ I2C_SMBUS_I2C_BLOCK_BROKEN, "I2C_BLOCK_BROKEN" },
	190	{ I2C_SMBUS_BLOCK_PROC_CALL, "BLOCK_PROC_CALL" },
	191	{ I2C_SMBUS_I2C_BLOCK_DATA, "I2C_BLOCK_DATA" }),
	192	__entry->len,
	193	__entry->len, __entry->buf
	194	));
	195
	196	/*
	197	* i2c_smbus_xfer() result
	198	*/
	199	TRACE_EVENT(smbus_result,
	200	TP_PROTO(const struct i2c_adapter *adap,
	201	u16 addr, unsigned short flags,
	202	char read_write, u8 command, int protocol,
	203	int res),
204	TP_ARGS(adap, addr, flags, read_write, command, protocol, res),
205	TP_STRUCT__entry(
206	__field(int, adapter_nr )
207	__field(__u16, addr )
208	__field(__u16, flags )
209	__field(__u8, read_write )
210	__field(__u8, command )
211	__field(__s16, res )
212	__field(__u32, protocol )
213	),
214	TP_fast_assign(
215	__entry->adapter_nr = adap->nr;
216	__entry->addr = addr;
217	__entry->flags = flags;
218	__entry->read_write = read_write;
219	__entry->command = command;
220	__entry->protocol = protocol;
221	__entry->res = res;
222	),
223	TP_printk("i2c-%d a=%03x f=%04x c=%x %s %s res=%d",
224	__entry->adapter_nr,
225	__entry->addr,
226	__entry->flags,
227	__entry->command,
228	__print_symbolic(__entry->protocol,
229	{ I2C_SMBUS_QUICK, "QUICK" },
230	{ I2C_SMBUS_BYTE, "BYTE" },
231	{ I2C_SMBUS_BYTE_DATA, "BYTE_DATA" },
232	{ I2C_SMBUS_WORD_DATA, "WORD_DATA" },
233	{ I2C_SMBUS_PROC_CALL, "PROC_CALL" },
234	{ I2C_SMBUS_BLOCK_DATA, "BLOCK_DATA" },
235	{ I2C_SMBUS_I2C_BLOCK_BROKEN, "I2C_BLOCK_BROKEN" },
236	{ I2C_SMBUS_BLOCK_PROC_CALL, "BLOCK_PROC_CALL" },
237	{ I2C_SMBUS_I2C_BLOCK_DATA, "I2C_BLOCK_DATA" }),
238	__entry->read_write == I2C_SMBUS_WRITE ? "wr" : "rd",
239	__entry->res
240	));
241
242	#endif /* _TRACE_SMBUS_H */
243
244	/* This part must be outside protection */
245	#include <trace/define_trace.h>