include/trace/events/smbus.h

   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>