drivers/hwtracing/intel_th/pti.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Intel(R) Trace Hub PTI output driver
   4  *
   5  * Copyright (C) 2014-2016 Intel Corporation.
   6  */
   7
   8 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/types.h>
  11 #include <linux/module.h>
  12 #include <linux/device.h>
  13 #include <linux/sizes.h>
  14 #include <linux/printk.h>
  15 #include <linux/slab.h>
  16 #include <linux/mm.h>
  17 #include <linux/io.h>
  18
  19 #include "intel_th.h"
  20 #include "pti.h"
  21
  22 struct pti_device {
  23         void __iomem            *base;
  24         struct intel_th_device  *thdev;
  25         unsigned int            mode;
  26         unsigned int            freeclk;
  27         unsigned int            clkdiv;
  28         unsigned int            patgen;
  29         unsigned int            lpp_dest_mask;
  30         unsigned int            lpp_dest;
  31 };
  32
  33 /* map PTI widths to MODE settings of PTI_CTL register */
  34 static const unsigned int pti_mode[] = {
  35         0, 4, 8, 0, 12, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0,
  36 };
  37
  38 static int pti_width_mode(unsigned int width)
  39 {
  40         int i;
  41
  42         for (i = 0; i < ARRAY_SIZE(pti_mode); i++)
  43                 if (pti_mode[i] == width)
  44                         return i;
  45
  46         return -EINVAL;
  47 }
  48
  49 static ssize_t mode_show(struct device *dev, struct device_attribute *attr,
  50                          char *buf)
  51 {
  52         struct pti_device *pti = dev_get_drvdata(dev);
  53
  54         return scnprintf(buf, PAGE_SIZE, "%d\n", pti_mode[pti->mode]);
  55 }
  56
  57 static ssize_t mode_store(struct device *dev, struct device_attribute *attr,
  58                           const char *buf, size_t size)
  59 {
  60         struct pti_device *pti = dev_get_drvdata(dev);
  61         unsigned long val;
  62         int ret;
  63
  64         ret = kstrtoul(buf, 10, &val);
  65         if (ret)
  66                 return ret;
  67
  68         ret = pti_width_mode(val);
  69         if (ret < 0)
  70                 return ret;
  71
  72         pti->mode = ret;
  73
  74         return size;
  75 }
  76
  77 static DEVICE_ATTR_RW(mode);
  78
  79 static ssize_t
  80 freerunning_clock_show(struct device *dev, struct device_attribute *attr,
  81                        char *buf)
  82 {
  83         struct pti_device *pti = dev_get_drvdata(dev);
  84
  85         return scnprintf(buf, PAGE_SIZE, "%d\n", pti->freeclk);
  86 }
  87
  88 static ssize_t
  89 freerunning_clock_store(struct device *dev, struct device_attribute *attr,
  90                         const char *buf, size_t size)
  91 {
  92         struct pti_device *pti = dev_get_drvdata(dev);
  93         unsigned long val;
  94         int ret;
  95
  96         ret = kstrtoul(buf, 10, &val);
  97         if (ret)
  98                 return ret;
  99
 100         pti->freeclk = !!val;
 101
 102         return size;
 103 }
 104
 105 static DEVICE_ATTR_RW(freerunning_clock);
 106
 107 static ssize_t
 108 clock_divider_show(struct device *dev, struct device_attribute *attr,
 109                    char *buf)
 110 {
 111         struct pti_device *pti = dev_get_drvdata(dev);
 112
 113         return scnprintf(buf, PAGE_SIZE, "%d\n", 1u << pti->clkdiv);
 114 }
 115
 116 static ssize_t
 117 clock_divider_store(struct device *dev, struct device_attribute *attr,
 118                     const char *buf, size_t size)
 119 {
 120         struct pti_device *pti = dev_get_drvdata(dev);
 121         unsigned long val;
 122         int ret;
 123
 124         ret = kstrtoul(buf, 10, &val);
 125         if (ret)
 126                 return ret;
 127
 128         if (!is_power_of_2(val) || val > 8 || !val)
 129                 return -EINVAL;
 130
 131         pti->clkdiv = val;
 132
 133         return size;
 134 }
 135
 136 static DEVICE_ATTR_RW(clock_divider);
 137
 138 static struct attribute *pti_output_attrs[] = {
 139         &dev_attr_mode.attr,
 140         &dev_attr_freerunning_clock.attr,
 141         &dev_attr_clock_divider.attr,
 142         NULL,
 143 };
 144
 145 static struct attribute_group pti_output_group = {
 146         .attrs  = pti_output_attrs,
 147 };
 148
 149 static int intel_th_pti_activate(struct intel_th_device *thdev)
 150 {
 151         struct pti_device *pti = dev_get_drvdata(&thdev->dev);
 152         u32 ctl = PTI_EN;
 153
 154         if (pti->patgen)
 155                 ctl |= pti->patgen << __ffs(PTI_PATGENMODE);
 156         if (pti->freeclk)
 157                 ctl |= PTI_FCEN;
 158         ctl |= pti->mode << __ffs(PTI_MODE);
 159         ctl |= pti->clkdiv << __ffs(PTI_CLKDIV);
 160         ctl |= pti->lpp_dest << __ffs(LPP_DEST);
 161
 162         iowrite32(ctl, pti->base + REG_PTI_CTL);
 163
 164         intel_th_trace_enable(thdev);
 165
 166         return 0;
 167 }
 168
 169 static void intel_th_pti_deactivate(struct intel_th_device *thdev)
 170 {
 171         struct pti_device *pti = dev_get_drvdata(&thdev->dev);
 172
 173         intel_th_trace_disable(thdev);
 174
 175         iowrite32(0, pti->base + REG_PTI_CTL);
 176 }
 177
 178 static void read_hw_config(struct pti_device *pti)
 179 {
 180         u32 ctl = ioread32(pti->base + REG_PTI_CTL);
 181
 182         pti->mode       = (ctl & PTI_MODE) >> __ffs(PTI_MODE);
 183         pti->clkdiv     = (ctl & PTI_CLKDIV) >> __ffs(PTI_CLKDIV);
 184         pti->freeclk    = !!(ctl & PTI_FCEN);
 185
 186         if (!pti_mode[pti->mode])
 187                 pti->mode = pti_width_mode(4);
 188         if (!pti->clkdiv)
 189                 pti->clkdiv = 1;
 190
 191         if (pti->thdev->output.type == GTH_LPP) {
 192                 if (ctl & LPP_PTIPRESENT)
 193                         pti->lpp_dest_mask |= LPP_DEST_PTI;
 194                 if (ctl & LPP_BSSBPRESENT)
 195                         pti->lpp_dest_mask |= LPP_DEST_EXI;
 196                 if (ctl & LPP_DEST)
 197                         pti->lpp_dest = 1;
 198         }
 199 }
 200
 201 static int intel_th_pti_probe(struct intel_th_device *thdev)
 202 {
 203         struct device *dev = &thdev->dev;
 204         struct resource *res;
 205         struct pti_device *pti;
 206         void __iomem *base;
 207
 208         res = intel_th_device_get_resource(thdev, IORESOURCE_MEM, 0);
 209         if (!res)
 210                 return -ENODEV;
 211
 212         base = devm_ioremap(dev, res->start, resource_size(res));
 213         if (!base)
 214                 return -ENOMEM;
 215
 216         pti = devm_kzalloc(dev, sizeof(*pti), GFP_KERNEL);
 217         if (!pti)
 218                 return -ENOMEM;
 219
 220         pti->thdev = thdev;
 221         pti->base = base;
 222
 223         read_hw_config(pti);
 224
 225         dev_set_drvdata(dev, pti);
 226
 227         return 0;
 228 }
 229
 230 static void intel_th_pti_remove(struct intel_th_device *thdev)
 231 {
 232 }
 233
 234 static struct intel_th_driver intel_th_pti_driver = {
 235         .probe  = intel_th_pti_probe,
 236         .remove = intel_th_pti_remove,
 237         .activate       = intel_th_pti_activate,
 238         .deactivate     = intel_th_pti_deactivate,
 239         .attr_group     = &pti_output_group,
 240         .driver = {
 241                 .name   = "pti",
 242                 .owner  = THIS_MODULE,
 243         },
 244 };
 245
 246 static const char * const lpp_dest_str[] = { "pti", "exi" };
 247
 248 static ssize_t lpp_dest_show(struct device *dev, struct device_attribute *attr,
 249                              char *buf)
 250 {
 251         struct pti_device *pti = dev_get_drvdata(dev);
 252         ssize_t ret = 0;
 253         int i;
 254
 255         for (i = ARRAY_SIZE(lpp_dest_str) - 1; i >= 0; i--) {
 256                 const char *fmt = pti->lpp_dest == i ? "[%s] " : "%s ";
 257
 258                 if (!(pti->lpp_dest_mask & BIT(i)))
 259                         continue;
 260
 261                 ret += scnprintf(buf + ret, PAGE_SIZE - ret,
 262                                  fmt, lpp_dest_str[i]);
 263         }
 264
 265         if (ret)
 266                 buf[ret - 1] = '\n';
 267
 268         return ret;
 269 }
 270
 271 static ssize_t lpp_dest_store(struct device *dev, struct device_attribute *attr,
 272                               const char *buf, size_t size)
 273 {
 274         struct pti_device *pti = dev_get_drvdata(dev);
 275         int i;
 276
 277         i = sysfs_match_string(lpp_dest_str, buf);
 278         if (i < 0)
 279                 return i;
 280
 281         if (!(pti->lpp_dest_mask & BIT(i)))
 282                 return -EINVAL;
 283
 284         pti->lpp_dest = i;
 285         return size;
 286 }
 287
 288 static DEVICE_ATTR_RW(lpp_dest);
 289
 290 static struct attribute *lpp_output_attrs[] = {
 291         &dev_attr_mode.attr,
 292         &dev_attr_freerunning_clock.attr,
 293         &dev_attr_clock_divider.attr,
 294         &dev_attr_lpp_dest.attr,
 295         NULL,
 296 };
 297
 298 static struct attribute_group lpp_output_group = {
 299         .attrs  = lpp_output_attrs,
 300 };
 301
 302 static struct intel_th_driver intel_th_lpp_driver = {
 303         .probe          = intel_th_pti_probe,
 304         .remove         = intel_th_pti_remove,
 305         .activate       = intel_th_pti_activate,
 306         .deactivate     = intel_th_pti_deactivate,
 307         .attr_group     = &lpp_output_group,
 308         .driver = {
 309                 .name   = "lpp",
 310                 .owner  = THIS_MODULE,
 311         },
 312 };
 313
 314 static int __init intel_th_pti_lpp_init(void)
 315 {
 316         int err;
 317
 318         err = intel_th_driver_register(&intel_th_pti_driver);
 319         if (err)
 320                 return err;
 321
 322         err = intel_th_driver_register(&intel_th_lpp_driver);
 323         if (err) {
 324                 intel_th_driver_unregister(&intel_th_pti_driver);
 325                 return err;
 326         }
 327
 328         return 0;
 329 }
 330
 331 module_init(intel_th_pti_lpp_init);
 332
 333 static void __exit intel_th_pti_lpp_exit(void)
 334 {
 335         intel_th_driver_unregister(&intel_th_pti_driver);
 336         intel_th_driver_unregister(&intel_th_lpp_driver);
 337 }
 338
 339 module_exit(intel_th_pti_lpp_exit);
 340
 341 MODULE_LICENSE("GPL v2");
 342 MODULE_DESCRIPTION("Intel(R) Trace Hub PTI/LPP output driver");
 343 MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>");