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> 250