| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Intel(R) Trace Hub PTI output driver |
| * |
| * Copyright (C) 2014-2016 Intel Corporation. |
| */ |
| |
| #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| |
| #include <linux/types.h> |
| #include <linux/module.h> |
| #include <linux/device.h> |
| #include <linux/sizes.h> |
| #include <linux/printk.h> |
| #include <linux/slab.h> |
| #include <linux/mm.h> |
| #include <linux/io.h> |
| |
| #include "intel_th.h" |
| #include "pti.h" |
| |
| struct pti_device { |
| void __iomem *base; |
| struct intel_th_device *thdev; |
| unsigned int mode; |
| unsigned int freeclk; |
| unsigned int clkdiv; |
| unsigned int patgen; |
| unsigned int lpp_dest_mask; |
| unsigned int lpp_dest; |
| }; |
| |
| /* map PTI widths to MODE settings of PTI_CTL register */ |
| static const unsigned int pti_mode[] = { |
| 0, 4, 8, 0, 12, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, |
| }; |
| |
| static int pti_width_mode(unsigned int width) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(pti_mode); i++) |
| if (pti_mode[i] == width) |
| return i; |
| |
| return -EINVAL; |
| } |
| |
| static ssize_t mode_show(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| |
| return scnprintf(buf, PAGE_SIZE, "%d\n", pti_mode[pti->mode]); |
| } |
| |
| static ssize_t mode_store(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t size) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| unsigned long val; |
| int ret; |
| |
| ret = kstrtoul(buf, 10, &val); |
| if (ret) |
| return ret; |
| |
| ret = pti_width_mode(val); |
| if (ret < 0) |
| return ret; |
| |
| pti->mode = ret; |
| |
| return size; |
| } |
| |
| static DEVICE_ATTR_RW(mode); |
| |
| static ssize_t |
| freerunning_clock_show(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| |
| return scnprintf(buf, PAGE_SIZE, "%d\n", pti->freeclk); |
| } |
| |
| static ssize_t |
| freerunning_clock_store(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t size) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| unsigned long val; |
| int ret; |
| |
| ret = kstrtoul(buf, 10, &val); |
| if (ret) |
| return ret; |
| |
| pti->freeclk = !!val; |
| |
| return size; |
| } |
| |
| static DEVICE_ATTR_RW(freerunning_clock); |
| |
| static ssize_t |
| clock_divider_show(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| |
| return scnprintf(buf, PAGE_SIZE, "%d\n", 1u << pti->clkdiv); |
| } |
| |
| static ssize_t |
| clock_divider_store(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t size) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| unsigned long val; |
| int ret; |
| |
| ret = kstrtoul(buf, 10, &val); |
| if (ret) |
| return ret; |
| |
| if (!is_power_of_2(val) || val > 8 || !val) |
| return -EINVAL; |
| |
| pti->clkdiv = val; |
| |
| return size; |
| } |
| |
| static DEVICE_ATTR_RW(clock_divider); |
| |
| static struct attribute *pti_output_attrs[] = { |
| &dev_attr_mode.attr, |
| &dev_attr_freerunning_clock.attr, |
| &dev_attr_clock_divider.attr, |
| NULL, |
| }; |
| |
| static const struct attribute_group pti_output_group = { |
| .attrs = pti_output_attrs, |
| }; |
| |
| static int intel_th_pti_activate(struct intel_th_device *thdev) |
| { |
| struct pti_device *pti = dev_get_drvdata(&thdev->dev); |
| u32 ctl = PTI_EN; |
| |
| if (pti->patgen) |
| ctl |= pti->patgen << __ffs(PTI_PATGENMODE); |
| if (pti->freeclk) |
| ctl |= PTI_FCEN; |
| ctl |= pti->mode << __ffs(PTI_MODE); |
| ctl |= pti->clkdiv << __ffs(PTI_CLKDIV); |
| ctl |= pti->lpp_dest << __ffs(LPP_DEST); |
| |
| iowrite32(ctl, pti->base + REG_PTI_CTL); |
| |
| intel_th_trace_enable(thdev); |
| |
| return 0; |
| } |
| |
| static void intel_th_pti_deactivate(struct intel_th_device *thdev) |
| { |
| struct pti_device *pti = dev_get_drvdata(&thdev->dev); |
| |
| intel_th_trace_disable(thdev); |
| |
| iowrite32(0, pti->base + REG_PTI_CTL); |
| } |
| |
| static void read_hw_config(struct pti_device *pti) |
| { |
| u32 ctl = ioread32(pti->base + REG_PTI_CTL); |
| |
| pti->mode = (ctl & PTI_MODE) >> __ffs(PTI_MODE); |
| pti->clkdiv = (ctl & PTI_CLKDIV) >> __ffs(PTI_CLKDIV); |
| pti->freeclk = !!(ctl & PTI_FCEN); |
| |
| if (!pti_mode[pti->mode]) |
| pti->mode = pti_width_mode(4); |
| if (!pti->clkdiv) |
| pti->clkdiv = 1; |
| |
| if (pti->thdev->output.type == GTH_LPP) { |
| if (ctl & LPP_PTIPRESENT) |
| pti->lpp_dest_mask |= LPP_DEST_PTI; |
| if (ctl & LPP_BSSBPRESENT) |
| pti->lpp_dest_mask |= LPP_DEST_EXI; |
| if (ctl & LPP_DEST) |
| pti->lpp_dest = 1; |
| } |
| } |
| |
| static int intel_th_pti_probe(struct intel_th_device *thdev) |
| { |
| struct device *dev = &thdev->dev; |
| struct resource *res; |
| struct pti_device *pti; |
| void __iomem *base; |
| |
| res = intel_th_device_get_resource(thdev, IORESOURCE_MEM, 0); |
| if (!res) |
| return -ENODEV; |
| |
| base = devm_ioremap(dev, res->start, resource_size(res)); |
| if (!base) |
| return -ENOMEM; |
| |
| pti = devm_kzalloc(dev, sizeof(*pti), GFP_KERNEL); |
| if (!pti) |
| return -ENOMEM; |
| |
| pti->thdev = thdev; |
| pti->base = base; |
| |
| read_hw_config(pti); |
| |
| dev_set_drvdata(dev, pti); |
| |
| return 0; |
| } |
| |
| static void intel_th_pti_remove(struct intel_th_device *thdev) |
| { |
| } |
| |
| static struct intel_th_driver intel_th_pti_driver = { |
| .probe = intel_th_pti_probe, |
| .remove = intel_th_pti_remove, |
| .activate = intel_th_pti_activate, |
| .deactivate = intel_th_pti_deactivate, |
| .attr_group = &pti_output_group, |
| .driver = { |
| .name = "pti", |
| .owner = THIS_MODULE, |
| }, |
| }; |
| |
| static const char * const lpp_dest_str[] = { "pti", "exi" }; |
| |
| static ssize_t lpp_dest_show(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| ssize_t ret = 0; |
| int i; |
| |
| for (i = ARRAY_SIZE(lpp_dest_str) - 1; i >= 0; i--) { |
| const char *fmt = pti->lpp_dest == i ? "[%s] " : "%s "; |
| |
| if (!(pti->lpp_dest_mask & BIT(i))) |
| continue; |
| |
| ret += scnprintf(buf + ret, PAGE_SIZE - ret, |
| fmt, lpp_dest_str[i]); |
| } |
| |
| if (ret) |
| buf[ret - 1] = '\n'; |
| |
| return ret; |
| } |
| |
| static ssize_t lpp_dest_store(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t size) |
| { |
| struct pti_device *pti = dev_get_drvdata(dev); |
| int i; |
| |
| i = sysfs_match_string(lpp_dest_str, buf); |
| if (i < 0) |
| return i; |
| |
| if (!(pti->lpp_dest_mask & BIT(i))) |
| return -EINVAL; |
| |
| pti->lpp_dest = i; |
| return size; |
| } |
| |
| static DEVICE_ATTR_RW(lpp_dest); |
| |
| static struct attribute *lpp_output_attrs[] = { |
| &dev_attr_mode.attr, |
| &dev_attr_freerunning_clock.attr, |
| &dev_attr_clock_divider.attr, |
| &dev_attr_lpp_dest.attr, |
| NULL, |
| }; |
| |
| static const struct attribute_group lpp_output_group = { |
| .attrs = lpp_output_attrs, |
| }; |
| |
| static struct intel_th_driver intel_th_lpp_driver = { |
| .probe = intel_th_pti_probe, |
| .remove = intel_th_pti_remove, |
| .activate = intel_th_pti_activate, |
| .deactivate = intel_th_pti_deactivate, |
| .attr_group = &lpp_output_group, |
| .driver = { |
| .name = "lpp", |
| .owner = THIS_MODULE, |
| }, |
| }; |
| |
| static int __init intel_th_pti_lpp_init(void) |
| { |
| int err; |
| |
| err = intel_th_driver_register(&intel_th_pti_driver); |
| if (err) |
| return err; |
| |
| err = intel_th_driver_register(&intel_th_lpp_driver); |
| if (err) { |
| intel_th_driver_unregister(&intel_th_pti_driver); |
| return err; |
| } |
| |
| return 0; |
| } |
| |
| module_init(intel_th_pti_lpp_init); |
| |
| static void __exit intel_th_pti_lpp_exit(void) |
| { |
| intel_th_driver_unregister(&intel_th_pti_driver); |
| intel_th_driver_unregister(&intel_th_lpp_driver); |
| } |
| |
| module_exit(intel_th_pti_lpp_exit); |
| |
| MODULE_LICENSE("GPL v2"); |
| MODULE_DESCRIPTION("Intel(R) Trace Hub PTI/LPP output driver"); |
| MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>"); |