drivers/hwtracing/intel_th/pti.c

   1 /*
   2  * Intel(R) Trace Hub PTI output driver
   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 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  17
  18 #include <linux/types.h>
  19 #include <linux/module.h>
  20 #include <linux/device.h>
  21 #include <linux/sizes.h>
  22 #include <linux/printk.h>
  23 #include <linux/slab.h>
  24 #include <linux/mm.h>
  25 #include <linux/io.h>
  26
  27 #include "intel_th.h"
  28 #include "pti.h"
  29
  30 struct pti_device {
  31         void __iomem            *base;
  32         struct intel_th_device  *thdev;
  33         unsigned int            mode;
  34         unsigned int            freeclk;
  35         unsigned int            clkdiv;
  36         unsigned int            patgen;
  37 };
  38
  39 /* map PTI widths to MODE settings of PTI_CTL register */
  40 static const unsigned int pti_mode[] = {
  41         0, 4, 8, 0, 12, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0,
  42 };
  43
  44 static int pti_width_mode(unsigned int width)
  45 {
  46         int i;
  47
  48         for (i = 0; i < ARRAY_SIZE(pti_mode); i++)
  49                 if (pti_mode[i] == width)
  50                         return i;
  51
  52         return -EINVAL;
  53 }
  54
  55 static ssize_t mode_show(struct device *dev, struct device_attribute *attr,
  56                          char *buf)
  57 {
  58         struct pti_device *pti = dev_get_drvdata(dev);
  59
  60         return scnprintf(buf, PAGE_SIZE, "%d\n", pti_mode[pti->mode]);
  61 }
  62
  63 static ssize_t mode_store(struct device *dev, struct device_attribute *attr,
  64                           const char *buf, size_t size)
  65 {
  66         struct pti_device *pti = dev_get_drvdata(dev);
  67         unsigned long val;
  68         int ret;
  69
  70         ret = kstrtoul(buf, 10, &val);
  71         if (ret)
  72                 return ret;
  73
  74         ret = pti_width_mode(val);
  75         if (ret < 0)
  76                 return ret;
  77
  78         pti->mode = ret;
  79
  80         return size;
  81 }
  82
  83 static DEVICE_ATTR_RW(mode);
  84
  85 static ssize_t
  86 freerunning_clock_show(struct device *dev, struct device_attribute *attr,
  87                        char *buf)
  88 {
  89         struct pti_device *pti = dev_get_drvdata(dev);
  90
  91         return scnprintf(buf, PAGE_SIZE, "%d\n", pti->freeclk);
  92 }
  93
  94 static ssize_t
  95 freerunning_clock_store(struct device *dev, struct device_attribute *attr,
  96                         const char *buf, size_t size)
  97 {
  98         struct pti_device *pti = dev_get_drvdata(dev);
  99         unsigned long val;
 100         int ret;
 101
 102         ret = kstrtoul(buf, 10, &val);
 103         if (ret)
 104                 return ret;
 105
 106         pti->freeclk = !!val;
 107
 108         return size;
 109 }
 110
 111 static DEVICE_ATTR_RW(freerunning_clock);
 112
 113 static ssize_t
 114 clock_divider_show(struct device *dev, struct device_attribute *attr,
 115                    char *buf)
 116 {
 117         struct pti_device *pti = dev_get_drvdata(dev);
 118
 119         return scnprintf(buf, PAGE_SIZE, "%d\n", 1u << pti->clkdiv);
 120 }
 121
 122 static ssize_t
 123 clock_divider_store(struct device *dev, struct device_attribute *attr,
 124                     const char *buf, size_t size)
 125 {
 126         struct pti_device *pti = dev_get_drvdata(dev);
 127         unsigned long val;
 128         int ret;
 129
 130         ret = kstrtoul(buf, 10, &val);
 131         if (ret)
 132                 return ret;
 133
 134         if (!is_power_of_2(val) || val > 8 || !val)
 135                 return -EINVAL;
 136
 137         pti->clkdiv = val;
 138
 139         return size;
 140 }
 141
 142 static DEVICE_ATTR_RW(clock_divider);
 143
 144 static struct attribute *pti_output_attrs[] = {
 145         &dev_attr_mode.attr,
 146         &dev_attr_freerunning_clock.attr,
 147         &dev_attr_clock_divider.attr,
 148         NULL,
 149 };
 150
 151 static struct attribute_group pti_output_group = {
 152         .attrs  = pti_output_attrs,
 153 };
 154
 155 static int intel_th_pti_activate(struct intel_th_device *thdev)
 156 {
 157         struct pti_device *pti = dev_get_drvdata(&thdev->dev);
 158         u32 ctl = PTI_EN;
 159
 160         if (pti->patgen)
 161                 ctl |= pti->patgen << __ffs(PTI_PATGENMODE);
 162         if (pti->freeclk)
 163                 ctl |= PTI_FCEN;
 164         ctl |= pti->mode << __ffs(PTI_MODE);
 165         ctl |= pti->clkdiv << __ffs(PTI_CLKDIV);
 166
 167         iowrite32(ctl, pti->base + REG_PTI_CTL);
 168
 169         intel_th_trace_enable(thdev);
 170
 171         return 0;
 172 }
 173
 174 static void intel_th_pti_deactivate(struct intel_th_device *thdev)
 175 {
 176         struct pti_device *pti = dev_get_drvdata(&thdev->dev);
 177
 178         intel_th_trace_disable(thdev);
 179
 180         iowrite32(0, pti->base + REG_PTI_CTL);
 181 }
 182
 183 static void read_hw_config(struct pti_device *pti)
 184 {
 185         u32 ctl = ioread32(pti->base + REG_PTI_CTL);
 186
 187         pti->mode       = (ctl & PTI_MODE) >> __ffs(PTI_MODE);
 188         pti->clkdiv     = (ctl & PTI_CLKDIV) >> __ffs(PTI_CLKDIV);
 189         pti->freeclk    = !!(ctl & PTI_FCEN);
 190
 191         if (!pti_mode[pti->mode])
 192                 pti->mode = pti_width_mode(4);
 193         if (!pti->clkdiv)
 194                 pti->clkdiv = 1;
 195 }
 196
 197 static int intel_th_pti_probe(struct intel_th_device *thdev)
 198 {
 199         struct device *dev = &thdev->dev;
 200         struct resource *res;
 201         struct pti_device *pti;
 202         void __iomem *base;
 203
 204         res = intel_th_device_get_resource(thdev, IORESOURCE_MEM, 0);
 205         if (!res)
 206                 return -ENODEV;
 207
 208         base = devm_ioremap(dev, res->start, resource_size(res));
 209         if (!base)
 210                 return -ENOMEM;
 211
 212         pti = devm_kzalloc(dev, sizeof(*pti), GFP_KERNEL);
 213         if (!pti)
 214                 return -ENOMEM;
 215
 216         pti->thdev = thdev;
 217         pti->base = base;
 218
 219         read_hw_config(pti);
 220
 221         dev_set_drvdata(dev, pti);
 222
 223         return 0;
 224 }
 225
 226 static void intel_th_pti_remove(struct intel_th_device *thdev)
 227 {
 228 }
 229
 230 static struct intel_th_driver intel_th_pti_driver = {
 231         .probe  = intel_th_pti_probe,
 232         .remove = intel_th_pti_remove,
 233         .activate       = intel_th_pti_activate,
 234         .deactivate     = intel_th_pti_deactivate,
 235         .attr_group     = &pti_output_group,
 236         .driver = {
 237                 .name   = "pti",
 238                 .owner  = THIS_MODULE,
 239         },
 240 };
 241
 242 module_driver(intel_th_pti_driver,
 243               intel_th_driver_register,
 244               intel_th_driver_unregister);
 245
 246 MODULE_LICENSE("GPL v2");
 247 MODULE_DESCRIPTION("Intel(R) Trace Hub PTI output driver");
 248 MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");