xref: /openbmc/linux/include/trace/events/smbus.h (revision 62e59c4e)
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, int res),
142 	TP_ARGS(adap, addr, flags, read_write, command, protocol, data, res),
143 	TP_CONDITION(res >= 0 && 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>
250