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

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