include/trace/events/smbus.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  */
  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>