xref: /openbmc/linux/include/trace/events/smbus.h (revision b4d0d230)
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* SMBUS message transfer tracepoints
3  *
4  * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
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,
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),
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>
246