Loading...
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 */
23TRACE_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 */
91TRACE_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 */
133TRACE_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 */
199TRACE_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>
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 */
27TRACE_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 */
95TRACE_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 */
137TRACE_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 */
203TRACE_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>