LXR linux/drivers/hwtracing/intel_th/intel

   1/*
   2 * Intel(R) Trace Hub data structures
   3 *
   4 * Copyright (C) 2014-2015 Intel Corporation.
   5 *
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms and conditions of the GNU General Public License,
   8 * version 2, as published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope it will be useful, but WITHOUT
  11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 * more details.
  14 */
  15
  16#ifndef __INTEL_TH_H__
  17#define __INTEL_TH_H__
  18
  19/* intel_th_device device types */
  20enum {
  21        /* Devices that generate trace data */
  22        INTEL_TH_SOURCE = 0,
  23        /* Output ports (MSC, PTI) */
  24        INTEL_TH_OUTPUT,
  25        /* Switch, the Global Trace Hub (GTH) */
  26        INTEL_TH_SWITCH,
  27};
  28
  29/**
  30 * struct intel_th_output - descriptor INTEL_TH_OUTPUT type devices
  31 * @port:       output port number, assigned by the switch
  32 * @type:       GTH_{MSU,CTP,PTI}
  33 * @scratchpad: scratchpad bits to flag when this output is enabled
  34 * @multiblock: true for multiblock output configuration
  35 * @active:     true when this output is enabled
  36 *
  37 * Output port descriptor, used by switch driver to tell which output
  38 * port this output device corresponds to. Filled in at output device's
  39 * probe time by switch::assign(). Passed from output device driver to
  40 * switch related code to enable/disable its port.
  41 */
  42struct intel_th_output {
  43        int             port;
  44        unsigned int    type;
  45        unsigned int    scratchpad;
  46        bool            multiblock;
  47        bool            active;
  48};
  49
  50/**
  51 * struct intel_th_device - device on the intel_th bus
  52 * @dev:                device
  53 * @resource:           array of resources available to this device
  54 * @num_resources:      number of resources in @resource array
  55 * @type:               INTEL_TH_{SOURCE,OUTPUT,SWITCH}
  56 * @id:                 device instance or -1
  57 * @output:             output descriptor for INTEL_TH_OUTPUT devices
  58 * @name:               device name to match the driver
  59 */
  60struct intel_th_device {
  61        struct device   dev;
  62        struct resource *resource;
  63        unsigned int    num_resources;
  64        unsigned int    type;
  65        int             id;
  66
  67        /* INTEL_TH_OUTPUT specific */
  68        struct intel_th_output  output;
  69
  70        char            name[];
  71};
  72
  73#define to_intel_th_device(_d)                          \
  74        container_of((_d), struct intel_th_device, dev)
  75
  76/**
  77 * intel_th_device_get_resource() - obtain @num'th resource of type @type
  78 * @thdev:      the device to search the resource for
  79 * @type:       resource type
  80 * @num:        number of the resource
  81 */
  82static inline struct resource *
  83intel_th_device_get_resource(struct intel_th_device *thdev, unsigned int type,
  84                             unsigned int num)
  85{
  86        int i;
  87
  88        for (i = 0; i < thdev->num_resources; i++)
  89                if (resource_type(&thdev->resource[i]) == type && !num--)
  90                        return &thdev->resource[i];
  91
  92        return NULL;
  93}
  94
  95/**
  96 * intel_th_output_assigned() - if an output device is assigned to a switch port
  97 * @thdev:      the output device
  98 *
  99 * Return:      true if the device is INTEL_TH_OUTPUT *and* is assigned a port
 100 */
 101static inline bool
 102intel_th_output_assigned(struct intel_th_device *thdev)
 103{
 104        return thdev->type == INTEL_TH_OUTPUT &&
 105                thdev->output.port >= 0;
 106}
 107
 108/**
 109 * struct intel_th_driver - driver for an intel_th_device device
 110 * @driver:     generic driver
 111 * @probe:      probe method
 112 * @remove:     remove method
 113 * @assign:     match a given output type device against available outputs
 114 * @unassign:   deassociate an output type device from an output port
 115 * @enable:     enable tracing for a given output device
 116 * @disable:    disable tracing for a given output device
 117 * @irq:        interrupt callback
 118 * @activate:   enable tracing on the output's side
 119 * @deactivate: disable tracing on the output's side
 120 * @fops:       file operations for device nodes
 121 * @attr_group: attributes provided by the driver
 122 *
 123 * Callbacks @probe and @remove are required for all device types.
 124 * Switch device driver needs to fill in @assign, @enable and @disable
 125 * callbacks.
 126 */
 127struct intel_th_driver {
 128        struct device_driver    driver;
 129        int                     (*probe)(struct intel_th_device *thdev);
 130        void                    (*remove)(struct intel_th_device *thdev);
 131        /* switch (GTH) ops */
 132        int                     (*assign)(struct intel_th_device *thdev,
 133                                          struct intel_th_device *othdev);
 134        void                    (*unassign)(struct intel_th_device *thdev,
 135                                            struct intel_th_device *othdev);
 136        void                    (*enable)(struct intel_th_device *thdev,
 137                                          struct intel_th_output *output);
 138        void                    (*disable)(struct intel_th_device *thdev,
 139                                           struct intel_th_output *output);
 140        /* output ops */
 141        void                    (*irq)(struct intel_th_device *thdev);
 142        int                     (*activate)(struct intel_th_device *thdev);
 143        void                    (*deactivate)(struct intel_th_device *thdev);
 144        /* file_operations for those who want a device node */
 145        const struct file_operations *fops;
 146        /* optional attributes */
 147        struct attribute_group  *attr_group;
 148
 149        /* source ops */
 150        int                     (*set_output)(struct intel_th_device *thdev,
 151                                              unsigned int master);
 152};
 153
 154#define to_intel_th_driver(_d)                                  \
 155        container_of((_d), struct intel_th_driver, driver)
 156
 157#define to_intel_th_driver_or_null(_d)          \
 158        ((_d) ? to_intel_th_driver(_d) : NULL)
 159
 160static inline struct intel_th_device *
 161to_intel_th_hub(struct intel_th_device *thdev)
 162{
 163        struct device *parent = thdev->dev.parent;
 164
 165        if (!parent)
 166                return NULL;
 167
 168        return to_intel_th_device(parent);
 169}
 170
 171struct intel_th *
 172intel_th_alloc(struct device *dev, struct resource *devres,
 173               unsigned int ndevres, int irq);
 174void intel_th_free(struct intel_th *th);
 175
 176int intel_th_driver_register(struct intel_th_driver *thdrv);
 177void intel_th_driver_unregister(struct intel_th_driver *thdrv);
 178
 179int intel_th_trace_enable(struct intel_th_device *thdev);
 180int intel_th_trace_disable(struct intel_th_device *thdev);
 181int intel_th_set_output(struct intel_th_device *thdev,
 182                        unsigned int master);
 183
 184enum {
 185        TH_MMIO_CONFIG = 0,
 186        TH_MMIO_SW = 2,
 187        TH_MMIO_END,
 188};
 189
 190#define TH_SUBDEVICE_MAX        6
 191#define TH_POSSIBLE_OUTPUTS     8
 192#define TH_CONFIGURABLE_MASTERS 256
 193#define TH_MSC_MAX              2
 194
 195/**
 196 * struct intel_th - Intel TH controller
 197 * @dev:        driver core's device
 198 * @thdev:      subdevices
 199 * @hub:        "switch" subdevice (GTH)
 200 * @id:         this Intel TH controller's device ID in the system
 201 * @major:      device node major for output devices
 202 */
 203struct intel_th {
 204        struct device           *dev;
 205
 206        struct intel_th_device  *thdev[TH_SUBDEVICE_MAX];
 207        struct intel_th_device  *hub;
 208
 209        int                     id;
 210        int                     major;
 211#ifdef CONFIG_MODULES
 212        struct work_struct      request_module_work;
 213#endif /* CONFIG_MODULES */
 214#ifdef CONFIG_INTEL_TH_DEBUG
 215        struct dentry           *dbg;
 216#endif
 217};
 218
 219/*
 220 * Register windows
 221 */
 222enum {
 223        /* Global Trace Hub (GTH) */
 224        REG_GTH_OFFSET          = 0x0000,
 225        REG_GTH_LENGTH          = 0x2000,
 226
 227        /* Software Trace Hub (STH) [0x4000..0x4fff] */
 228        REG_STH_OFFSET          = 0x4000,
 229        REG_STH_LENGTH          = 0x2000,
 230
 231        /* Memory Storage Unit (MSU) [0xa0000..0xa1fff] */
 232        REG_MSU_OFFSET          = 0xa0000,
 233        REG_MSU_LENGTH          = 0x02000,
 234
 235        /* Internal MSU trace buffer [0x80000..0x9ffff] */
 236        BUF_MSU_OFFSET          = 0x80000,
 237        BUF_MSU_LENGTH          = 0x20000,
 238
 239        /* PTI output == same window as GTH */
 240        REG_PTI_OFFSET          = REG_GTH_OFFSET,
 241        REG_PTI_LENGTH          = REG_GTH_LENGTH,
 242
 243        /* DCI Handler (DCIH) == some window as MSU */
 244        REG_DCIH_OFFSET         = REG_MSU_OFFSET,
 245        REG_DCIH_LENGTH         = REG_MSU_LENGTH,
 246};
 247
 248/*
 249 * GTH, output ports configuration
 250 */
 251enum {
 252        GTH_NONE = 0,
 253        GTH_MSU,        /* memory/usb */
 254        GTH_CTP,        /* Common Trace Port */
 255        GTH_PTI = 4,    /* MIPI-PTI */
 256};
 257
 258/*
 259 * Scratchpad bits: tell firmware and external debuggers
 260 * what we are up to.
 261 */
 262enum {
 263        /* Memory is the primary destination */
 264        SCRPD_MEM_IS_PRIM_DEST          = BIT(0),
 265        /* XHCI DbC is the primary destination */
 266        SCRPD_DBC_IS_PRIM_DEST          = BIT(1),
 267        /* PTI is the primary destination */
 268        SCRPD_PTI_IS_PRIM_DEST          = BIT(2),
 269        /* BSSB is the primary destination */
 270        SCRPD_BSSB_IS_PRIM_DEST         = BIT(3),
 271        /* PTI is the alternate destination */
 272        SCRPD_PTI_IS_ALT_DEST           = BIT(4),
 273        /* BSSB is the alternate destination */
 274        SCRPD_BSSB_IS_ALT_DEST          = BIT(5),
 275        /* DeepSx exit occurred */
 276        SCRPD_DEEPSX_EXIT               = BIT(6),
 277        /* S4 exit occurred */
 278        SCRPD_S4_EXIT                   = BIT(7),
 279        /* S5 exit occurred */
 280        SCRPD_S5_EXIT                   = BIT(8),
 281        /* MSU controller 0/1 is enabled */
 282        SCRPD_MSC0_IS_ENABLED           = BIT(9),
 283        SCRPD_MSC1_IS_ENABLED           = BIT(10),
 284        /* Sx exit occurred */
 285        SCRPD_SX_EXIT                   = BIT(11),
 286        /* Trigger Unit is enabled */
 287        SCRPD_TRIGGER_IS_ENABLED        = BIT(12),
 288        SCRPD_ODLA_IS_ENABLED           = BIT(13),
 289        SCRPD_SOCHAP_IS_ENABLED         = BIT(14),
 290        SCRPD_STH_IS_ENABLED            = BIT(15),
 291        SCRPD_DCIH_IS_ENABLED           = BIT(16),
 292        SCRPD_VER_IS_ENABLED            = BIT(17),
 293        /* External debugger is using Intel TH */
 294        SCRPD_DEBUGGER_IN_USE           = BIT(24),
 295};
 296
 297#endif
 298