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