include/trace/events/hswadsp.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM hswadsp
   3
   4 #if !defined(_TRACE_HSWADSP_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_HSWADSP_H
   6
   7 #include <linux/types.h>
   8 #include <linux/ktime.h>
   9 #include <linux/tracepoint.h>
  10
  11 struct sst_hsw;
  12 struct sst_hsw_stream;
  13 struct sst_hsw_ipc_stream_free_req;
  14 struct sst_hsw_ipc_volume_req;
  15 struct sst_hsw_ipc_stream_alloc_req;
  16 struct sst_hsw_audio_data_format_ipc;
  17 struct sst_hsw_ipc_stream_info_reply;
  18 struct sst_hsw_ipc_device_config_req;
  19
  20 DECLARE_EVENT_CLASS(sst_irq,
  21
  22         TP_PROTO(uint32_t status, uint32_t mask),
  23
  24         TP_ARGS(status, mask),
  25
  26         TP_STRUCT__entry(
  27                 __field(        unsigned int,   status          )
  28                 __field(        unsigned int,   mask            )
  29         ),
  30
  31         TP_fast_assign(
  32                 __entry->status = status;
  33                 __entry->mask = mask;
  34         ),
  35
  36         TP_printk("status 0x%8.8x mask 0x%8.8x",
  37                 (unsigned int)__entry->status, (unsigned int)__entry->mask)
  38 );
  39
  40 DEFINE_EVENT(sst_irq, sst_irq_busy,
  41
  42         TP_PROTO(unsigned int status, unsigned int mask),
  43
  44         TP_ARGS(status, mask)
  45
  46 );
  47
  48 DEFINE_EVENT(sst_irq, sst_irq_done,
  49
  50         TP_PROTO(unsigned int status, unsigned int mask),
  51
  52         TP_ARGS(status, mask)
  53
  54 );
  55
  56 DECLARE_EVENT_CLASS(ipc,
  57
  58         TP_PROTO(const char *name, int val),
  59
  60         TP_ARGS(name, val),
  61
  62         TP_STRUCT__entry(
  63                 __string(       name,   name            )
  64                 __field(        unsigned int,   val     )
  65         ),
  66
  67         TP_fast_assign(
  68                 __assign_str(name, name);
  69                 __entry->val = val;
  70         ),
  71
  72         TP_printk("%s 0x%8.8x", __get_str(name), (unsigned int)__entry->val)
  73
  74 );
  75
  76 DEFINE_EVENT(ipc, ipc_request,
  77
  78         TP_PROTO(const char *name, int val),
  79
  80         TP_ARGS(name, val)
  81
  82 );
  83
  84 DEFINE_EVENT(ipc, ipc_reply,
  85
  86         TP_PROTO(const char *name, int val),
  87
  88         TP_ARGS(name, val)
  89
  90 );
  91
  92 DEFINE_EVENT(ipc, ipc_pending_reply,
  93
  94         TP_PROTO(const char *name, int val),
  95
  96         TP_ARGS(name, val)
  97
  98 );
  99
 100 DEFINE_EVENT(ipc, ipc_notification,
 101
 102         TP_PROTO(const char *name, int val),
 103
 104         TP_ARGS(name, val)
 105
 106 );
 107
 108 DEFINE_EVENT(ipc, ipc_error,
 109
 110         TP_PROTO(const char *name, int val),
 111
 112         TP_ARGS(name, val)
 113
 114 );
 115
 116 DECLARE_EVENT_CLASS(stream_position,
 117
 118         TP_PROTO(unsigned int id, unsigned int pos),
 119
 120         TP_ARGS(id, pos),
 121
 122         TP_STRUCT__entry(
 123                 __field(        unsigned int,   id              )
 124                 __field(        unsigned int,   pos             )
 125         ),
 126
 127         TP_fast_assign(
 128                 __entry->id = id;
 129                 __entry->pos = pos;
 130         ),
 131
 132         TP_printk("id %d position 0x%x",
 133                 (unsigned int)__entry->id, (unsigned int)__entry->pos)
 134 );
 135
 136 DEFINE_EVENT(stream_position, stream_read_position,
 137
 138         TP_PROTO(unsigned int id, unsigned int pos),
 139
 140         TP_ARGS(id, pos)
 141
 142 );
 143
 144 DEFINE_EVENT(stream_position, stream_write_position,
 145
 146         TP_PROTO(unsigned int id, unsigned int pos),
 147
 148         TP_ARGS(id, pos)
 149
 150 );
 151
 152 TRACE_EVENT(hsw_stream_buffer,
 153
 154         TP_PROTO(struct sst_hsw_stream *stream),
 155
 156         TP_ARGS(stream),
 157
 158         TP_STRUCT__entry(
 159                 __field(        int,    id      )
 160                 __field(        int,    pt_addr )
 161                 __field(        int,    num_pages       )
 162                 __field(        int,    ring_size       )
 163                 __field(        int,    ring_offset     )
 164                 __field(        int,    first_pfn       )
 165         ),
 166
 167         TP_fast_assign(
 168                 __entry->id = stream->host_id;
 169                 __entry->pt_addr = stream->request.ringinfo.ring_pt_address;
 170                 __entry->num_pages = stream->request.ringinfo.num_pages;
 171                 __entry->ring_size = stream->request.ringinfo.ring_size;
 172                 __entry->ring_offset = stream->request.ringinfo.ring_offset;
 173                 __entry->first_pfn = stream->request.ringinfo.ring_first_pfn;
 174         ),
 175
 176         TP_printk("stream %d ring addr 0x%x pages %d size 0x%x offset 0x%x PFN 0x%x",
 177                 (int) __entry->id,  (int)__entry->pt_addr,
 178                 (int)__entry->num_pages, (int)__entry->ring_size,
 179                 (int)__entry->ring_offset, (int)__entry->first_pfn)
 180 );
 181
 182 TRACE_EVENT(hsw_stream_alloc_reply,
 183
 184         TP_PROTO(struct sst_hsw_stream *stream),
 185
 186         TP_ARGS(stream),
 187
 188         TP_STRUCT__entry(
 189                 __field(        int,    id      )
 190                 __field(        int,    stream_id       )
 191                 __field(        int,    mixer_id        )
 192                 __field(        int,    peak0   )
 193                 __field(        int,    peak1   )
 194                 __field(        int,    vol0    )
 195                 __field(        int,    vol1    )
 196         ),
 197
 198         TP_fast_assign(
 199                 __entry->id = stream->host_id;
 200                 __entry->stream_id = stream->reply.stream_hw_id;
 201                 __entry->mixer_id = stream->reply.mixer_hw_id;
 202                 __entry->peak0 = stream->reply.peak_meter_register_address[0];
 203                 __entry->peak1 = stream->reply.peak_meter_register_address[1];
 204                 __entry->vol0 = stream->reply.volume_register_address[0];
 205                 __entry->vol1 = stream->reply.volume_register_address[1];
 206         ),
 207
 208         TP_printk("stream %d hw id %d mixer %d peak 0x%x:0x%x vol 0x%x,0x%x",
 209                 (int) __entry->id, (int) __entry->stream_id, (int)__entry->mixer_id,
 210                 (int)__entry->peak0, (int)__entry->peak1,
 211                 (int)__entry->vol0, (int)__entry->vol1)
 212 );
 213
 214 TRACE_EVENT(hsw_mixer_info_reply,
 215
 216         TP_PROTO(struct sst_hsw_ipc_stream_info_reply *reply),
 217
 218         TP_ARGS(reply),
 219
 220         TP_STRUCT__entry(
 221                 __field(        int,    mixer_id        )
 222                 __field(        int,    peak0   )
 223                 __field(        int,    peak1   )
 224                 __field(        int,    vol0    )
 225                 __field(        int,    vol1    )
 226         ),
 227
 228         TP_fast_assign(
 229                 __entry->mixer_id = reply->mixer_hw_id;
 230                 __entry->peak0 = reply->peak_meter_register_address[0];
 231                 __entry->peak1 = reply->peak_meter_register_address[1];
 232                 __entry->vol0 = reply->volume_register_address[0];
 233                 __entry->vol1 = reply->volume_register_address[1];
 234         ),
 235
 236         TP_printk("mixer id %d peak 0x%x:0x%x vol 0x%x,0x%x",
 237                 (int)__entry->mixer_id,
 238                 (int)__entry->peak0, (int)__entry->peak1,
 239                 (int)__entry->vol0, (int)__entry->vol1)
 240 );
 241
 242 TRACE_EVENT(hsw_stream_data_format,
 243
 244         TP_PROTO(struct sst_hsw_stream *stream,
 245                 struct sst_hsw_audio_data_format_ipc *req),
 246
 247         TP_ARGS(stream, req),
 248
 249         TP_STRUCT__entry(
 250                 __field(        uint32_t,       id      )
 251                 __field(        uint32_t,       frequency       )
 252                 __field(        uint32_t,       bitdepth        )
 253                 __field(        uint32_t,       map     )
 254                 __field(        uint32_t,       config  )
 255                 __field(        uint32_t,       style   )
 256                 __field(        uint8_t,        ch_num  )
 257                 __field(        uint8_t,        valid_bit       )
 258         ),
 259
 260         TP_fast_assign(
 261                 __entry->id = stream->host_id;
 262                 __entry->frequency = req->frequency;
 263                 __entry->bitdepth = req->bitdepth;
 264                 __entry->map = req->map;
 265                 __entry->config = req->config;
 266                 __entry->style = req->style;
 267                 __entry->ch_num = req->ch_num;
 268                 __entry->valid_bit = req->valid_bit;
 269         ),
 270
 271         TP_printk("stream %d freq %d depth %d map 0x%x config 0x%x style 0x%x ch %d bits %d",
 272                 (int) __entry->id, (uint32_t)__entry->frequency,
 273                 (uint32_t)__entry->bitdepth, (uint32_t)__entry->map,
 274                 (uint32_t)__entry->config, (uint32_t)__entry->style,
 275                 (uint8_t)__entry->ch_num, (uint8_t)__entry->valid_bit)
 276 );
 277
 278 TRACE_EVENT(hsw_stream_alloc_request,
 279
 280         TP_PROTO(struct sst_hsw_stream *stream,
 281                 struct sst_hsw_ipc_stream_alloc_req *req),
 282
 283         TP_ARGS(stream, req),
 284
 285         TP_STRUCT__entry(
 286                 __field(        uint32_t,       id      )
 287                 __field(        uint8_t,        path_id )
 288                 __field(        uint8_t,        stream_type     )
 289                 __field(        uint8_t,        format_id       )
 290         ),
 291
 292         TP_fast_assign(
 293                 __entry->id = stream->host_id;
 294                 __entry->path_id = req->path_id;
 295                 __entry->stream_type = req->stream_type;
 296                 __entry->format_id = req->format_id;
 297         ),
 298
 299         TP_printk("stream %d path %d type %d format %d",
 300                 (int) __entry->id, (uint8_t)__entry->path_id,
 301                 (uint8_t)__entry->stream_type, (uint8_t)__entry->format_id)
 302 );
 303
 304 TRACE_EVENT(hsw_stream_free_req,
 305
 306         TP_PROTO(struct sst_hsw_stream *stream,
 307                 struct sst_hsw_ipc_stream_free_req *req),
 308
 309         TP_ARGS(stream, req),
 310
 311         TP_STRUCT__entry(
 312                 __field(        int,    id      )
 313                 __field(        int,    stream_id       )
 314         ),
 315
 316         TP_fast_assign(
 317                 __entry->id = stream->host_id;
 318                 __entry->stream_id = req->stream_id;
 319         ),
 320
 321         TP_printk("stream %d hw id %d",
 322                 (int) __entry->id, (int) __entry->stream_id)
 323 );
 324
 325 TRACE_EVENT(hsw_volume_req,
 326
 327         TP_PROTO(struct sst_hsw_stream *stream,
 328                 struct sst_hsw_ipc_volume_req *req),
 329
 330         TP_ARGS(stream, req),
 331
 332         TP_STRUCT__entry(
 333                 __field(        int,    id      )
 334                 __field(        uint32_t,       channel )
 335                 __field(        uint32_t,       target_volume   )
 336                 __field(        uint64_t,       curve_duration  )
 337                 __field(        uint32_t,       curve_type      )
 338         ),
 339
 340         TP_fast_assign(
 341                 __entry->id = stream->host_id;
 342                 __entry->channel = req->channel;
 343                 __entry->target_volume = req->target_volume;
 344                 __entry->curve_duration = req->curve_duration;
 345                 __entry->curve_type = req->curve_type;
 346         ),
 347
 348         TP_printk("stream %d chan 0x%x vol %d duration %llu type %d",
 349                 (int) __entry->id, (uint32_t) __entry->channel,
 350                 (uint32_t)__entry->target_volume,
 351                 (uint64_t)__entry->curve_duration,
 352                 (uint32_t)__entry->curve_type)
 353 );
 354
 355 TRACE_EVENT(hsw_device_config_req,
 356
 357         TP_PROTO(struct sst_hsw_ipc_device_config_req *req),
 358
 359         TP_ARGS(req),
 360
 361         TP_STRUCT__entry(
 362                 __field(        uint32_t,       ssp     )
 363                 __field(        uint32_t,       clock_freq      )
 364                 __field(        uint32_t,       mode    )
 365                 __field(        uint16_t,       clock_divider   )
 366         ),
 367
 368         TP_fast_assign(
 369                 __entry->ssp = req->ssp_interface;
 370                 __entry->clock_freq = req->clock_frequency;
 371                 __entry->mode = req->mode;
 372                 __entry->clock_divider = req->clock_divider;
 373         ),
 374
 375         TP_printk("SSP %d Freq %d mode %d div %d",
 376                 (uint32_t)__entry->ssp,
 377                 (uint32_t)__entry->clock_freq, (uint32_t)__entry->mode,
 378                 (uint32_t)__entry->clock_divider)
 379 );
 380
 381 #endif /* _TRACE_HSWADSP_H */
 382
 383 /* This part must be outside protection */
 384 #include <trace/define_trace.h>