include/linux/stm.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Trace Module (STM) infrastructure apis
   4  * Copyright (C) 2014 Intel Corporation.
   5  */
   6
   7 #ifndef _STM_H_
   8 #define _STM_H_
   9
  10 #include <linux/device.h>
  11
  12 /**
  13  * enum stp_packet_type - STP packets that an STM driver sends
  14  */
  15 enum stp_packet_type {
  16         STP_PACKET_DATA = 0,
  17         STP_PACKET_FLAG,
  18         STP_PACKET_USER,
  19         STP_PACKET_MERR,
  20         STP_PACKET_GERR,
  21         STP_PACKET_TRIG,
  22         STP_PACKET_XSYNC,
  23 };
  24
  25 /**
  26  * enum stp_packet_flags - STP packet modifiers
  27  */
  28 enum stp_packet_flags {
  29         STP_PACKET_MARKED       = 0x1,
  30         STP_PACKET_TIMESTAMPED  = 0x2,
  31 };
  32
  33 /**
  34  * enum stm_source_type - STM source driver
  35  * @STM_USER: any STM trace source
  36  * @STM_FTRACE: ftrace STM source
  37  */
  38 enum stm_source_type {
  39         STM_USER,
  40         STM_FTRACE,
  41 };
  42
  43 struct stp_policy;
  44
  45 struct stm_device;
  46
  47 /**
  48  * struct stm_data - STM device description and callbacks
  49  * @name:               device name
  50  * @stm:                internal structure, only used by stm class code
  51  * @sw_start:           first STP master available to software
  52  * @sw_end:             last STP master available to software
  53  * @sw_nchannels:       number of STP channels per master
  54  * @sw_mmiosz:          size of one channel's IO space, for mmap, optional
  55  * @hw_override:        masters in the STP stream will not match the ones
  56  *                      assigned by software, but are up to the STM hardware
  57  * @packet:             callback that sends an STP packet
  58  * @mmio_addr:          mmap callback, optional
  59  * @link:               called when a new stm_source gets linked to us, optional
  60  * @unlink:             likewise for unlinking, again optional
  61  * @set_options:        set device-specific options on a channel
  62  *
  63  * Fill out this structure before calling stm_register_device() to create
  64  * an STM device and stm_unregister_device() to destroy it. It will also be
  65  * passed back to @packet(), @mmio_addr(), @link(), @unlink() and @set_options()
  66  * callbacks.
  67  *
  68  * Normally, an STM device will have a range of masters available to software
  69  * and the rest being statically assigned to various hardware trace sources.
  70  * The former is defined by the range [@sw_start..@sw_end] of the device
  71  * description. That is, the lowest master that can be allocated to software
  72  * writers is @sw_start and data from this writer will appear is @sw_start
  73  * master in the STP stream.
  74  *
  75  * The @packet callback should adhere to the following rules:
  76  *   1) it must return the number of bytes it consumed from the payload;
  77  *   2) therefore, if it sent a packet that does not have payload (like FLAG),
  78  *      it must return zero;
  79  *   3) if it does not support the requested packet type/flag combination,
  80  *      it must return -ENOTSUPP.
  81  *
  82  * The @unlink callback is called when there are no more active writers so
  83  * that the master/channel can be quiesced.
  84  */
  85 struct stm_data {
  86         const char              *name;
  87         struct stm_device       *stm;
  88         unsigned int            sw_start;
  89         unsigned int            sw_end;
  90         unsigned int            sw_nchannels;
  91         unsigned int            sw_mmiosz;
  92         unsigned int            hw_override;
  93         ssize_t                 (*packet)(struct stm_data *, unsigned int,
  94                                           unsigned int, unsigned int,
  95                                           unsigned int, unsigned int,
  96                                           const unsigned char *);
  97         phys_addr_t             (*mmio_addr)(struct stm_data *, unsigned int,
  98                                              unsigned int, unsigned int);
  99         int                     (*link)(struct stm_data *, unsigned int,
 100                                         unsigned int);
 101         void                    (*unlink)(struct stm_data *, unsigned int,
 102                                           unsigned int);
 103         long                    (*set_options)(struct stm_data *, unsigned int,
 104                                                unsigned int, unsigned int,
 105                                                unsigned long);
 106 };
 107
 108 int stm_register_device(struct device *parent, struct stm_data *stm_data,
 109                         struct module *owner);
 110 void stm_unregister_device(struct stm_data *stm_data);
 111
 112 struct stm_source_device;
 113
 114 /**
 115  * struct stm_source_data - STM source device description and callbacks
 116  * @name:       device name, will be used for policy lookup
 117  * @src:        internal structure, only used by stm class code
 118  * @nr_chans:   number of channels to allocate
 119  * @type:       type of STM source driver represented by stm_source_type
 120  * @link:       called when this source gets linked to an STM device
 121  * @unlink:     called when this source is about to get unlinked from its STM
 122  *
 123  * Fill in this structure before calling stm_source_register_device() to
 124  * register a source device. Also pass it to unregister and write calls.
 125  */
 126 struct stm_source_data {
 127         const char              *name;
 128         struct stm_source_device *src;
 129         unsigned int            percpu;
 130         unsigned int            nr_chans;
 131         unsigned int            type;
 132         int                     (*link)(struct stm_source_data *data);
 133         void                    (*unlink)(struct stm_source_data *data);
 134 };
 135
 136 int stm_source_register_device(struct device *parent,
 137                                struct stm_source_data *data);
 138 void stm_source_unregister_device(struct stm_source_data *data);
 139
 140 int notrace stm_source_write(struct stm_source_data *data, unsigned int chan,
 141                              const char *buf, size_t count);
 142
 143 #endif /* _STM_H_ */