* [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] <1436177344-16751-1-git-send-email-alexander.shishkin@linux.intel.com> @ 2015-07-06 10:08 ` Alexander Shishkin 2015-07-08 12:32 ` Chunyan Zhang [not found] ` <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> 0 siblings, 2 replies; 16+ messages in thread From: Alexander Shishkin @ 2015-07-06 10:08 UTC (permalink / raw) To: Greg Kroah-Hartman Cc: linux-kernel, mathieu.poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, Alexander Shishkin, linux-api A System Trace Module (STM) is a device exporting data in System Trace Protocol (STP) format as defined by MIPI STP standards. Examples of such devices are Intel Trace Hub and Coresight STM. This abstraction provides a unified interface for software trace sources to send their data over an STM device to a debug host. In order to do that, such a trace source needs to be assigned a pair of master/channel identifiers that all the data from this source will be tagged with. The STP decoder on the debug host side will use these master/channel tags to distinguish different trace streams from one another inside one STP stream. This abstraction provides a configfs-based policy management mechanism for dynamic allocation of these master/channel pairs based on trace source-supplied string identifier. It has the flexibility of being defined at runtime and at the same time (provided that the policy definition is aligned with the decoding end) consistency. For userspace trace sources, this abstraction provides write()-based and mmap()-based (if the underlying stm device allows this) output mechanism. For kernel-side trace sources, we provide "stm_source" device class that can be connected to an stm device at run time. Cc: linux-api@vger.kernel.org Cc: Mathieu Poirier <mathieu.poirier@linaro.org> Signed-off-by: Alexander Shishkin <alexander.shishkin@linux.intel.com> --- Documentation/ABI/testing/configfs-stp-policy | 48 + Documentation/ABI/testing/sysfs-class-stm | 14 + Documentation/ABI/testing/sysfs-class-stm_source | 11 + Documentation/ioctl/ioctl-number.txt | 3 + Documentation/trace/stm.txt | 80 ++ drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/hwtracing/stm/Kconfig | 8 + drivers/hwtracing/stm/Makefile | 3 + drivers/hwtracing/stm/core.c | 1029 ++++++++++++++++++++++ drivers/hwtracing/stm/policy.c | 529 +++++++++++ drivers/hwtracing/stm/stm.h | 87 ++ include/linux/stm.h | 126 +++ include/uapi/linux/stm.h | 50 ++ 14 files changed, 1991 insertions(+) create mode 100644 Documentation/ABI/testing/configfs-stp-policy create mode 100644 Documentation/ABI/testing/sysfs-class-stm create mode 100644 Documentation/ABI/testing/sysfs-class-stm_source create mode 100644 Documentation/trace/stm.txt create mode 100644 drivers/hwtracing/stm/Kconfig create mode 100644 drivers/hwtracing/stm/Makefile create mode 100644 drivers/hwtracing/stm/core.c create mode 100644 drivers/hwtracing/stm/policy.c create mode 100644 drivers/hwtracing/stm/stm.h create mode 100644 include/linux/stm.h create mode 100644 include/uapi/linux/stm.h diff --git a/Documentation/ABI/testing/configfs-stp-policy b/Documentation/ABI/testing/configfs-stp-policy new file mode 100644 index 0000000000..421ce6825c --- /dev/null +++ b/Documentation/ABI/testing/configfs-stp-policy @@ -0,0 +1,48 @@ +What: /config/stp-policy +Date: June 2015 +KernelVersion: 4.3 +Description: + This group contains policies mandating Master/Channel allocation + for software sources wishing to send trace data over an STM + device. + +What: /config/stp-policy/<device>.<policy> +Date: June 2015 +KernelVersion: 4.3 +Description: + This group is the root of a policy; its name is a concatenation + of an stm device name to which this policy applies and an + arbitrary string. If <device> part doesn't match an existing + stm device, mkdir will fail with ENODEV; if that device already + has a policy assigned to it, mkdir will fail with EBUSY. + +What: /config/stp-policy/<device>.<policy>/device +Date: June 2015 +KernelVersion: 4.3 +Description: + STM device to which this policy applies, read only. Same as the + <device> component of its parent directory. + +What: /config/stp-policy/<device>.<policy>/<node> +Date: June 2015 +KernelVersion: 4.3 +Description: + Policy node is a string identifier that software clients will + use to request a master/channel to be allocated and assigned to + them. + +What: /config/stp-policy/<device>.<policy>/<node>/masters +Date: June 2015 +KernelVersion: 4.3 +Description: + Range of masters from which to allocate for users of this node. + Write two numbers: the first master and the last master number. + +What: /config/stp-policy/<device>.<policy>/<node>/channels +Date: June 2015 +KernelVersion: 4.3 +Description: + Range of channels from which to allocate for users of this node. + Write two numbers: the first channel and the last channel + number. + diff --git a/Documentation/ABI/testing/sysfs-class-stm b/Documentation/ABI/testing/sysfs-class-stm new file mode 100644 index 0000000000..c9aa4f3fc9 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-class-stm @@ -0,0 +1,14 @@ +What: /sys/class/stm/<stm>/masters +Date: June 2015 +KernelVersion: 4.3 +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> +Description: + Shows first and last available to software master numbers on + this STM device. + +What: /sys/class/stm/<stm>/channels +Date: June 2015 +KernelVersion: 4.3 +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> +Description: + Shows the number of channels per master on this STM device. diff --git a/Documentation/ABI/testing/sysfs-class-stm_source b/Documentation/ABI/testing/sysfs-class-stm_source new file mode 100644 index 0000000000..57b8dd39bb --- /dev/null +++ b/Documentation/ABI/testing/sysfs-class-stm_source @@ -0,0 +1,11 @@ +What: /sys/class/stm_source/<stm_source>/stm_source_link +Date: June 2015 +KernelVersion: 4.3 +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> +Description: + stm_source device linkage to stm device, where its tracing data + is directed. Reads return an existing connection or "<none>" if + this stm_source is not connected to any stm device yet. + Write an existing (registered) stm device's name here to + connect that device. If a device is already connected to this + stm_source, it will first be disconnected. diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt index 611c52267d..7fa29b4ece 100644 --- a/Documentation/ioctl/ioctl-number.txt +++ b/Documentation/ioctl/ioctl-number.txt @@ -81,6 +81,9 @@ Code Seq#(hex) Include File Comments 0x22 all scsi/sg.h '#' 00-3F IEEE 1394 Subsystem Block for the entire subsystem '$' 00-0F linux/perf_counter.h, linux/perf_event.h +'%' 00-0F include/uapi/linux/stm.h + System Trace Module subsystem + <mailto:alexander.shishkin@linux.intel.com> '&' 00-07 drivers/firewire/nosy-user.h '1' 00-1F <linux/timepps.h> PPS kit from Ulrich Windl <ftp://ftp.de.kernel.org/pub/linux/daemons/ntp/PPS/> diff --git a/Documentation/trace/stm.txt b/Documentation/trace/stm.txt new file mode 100644 index 0000000000..e140f2e8d7 --- /dev/null +++ b/Documentation/trace/stm.txt @@ -0,0 +1,80 @@ +System Trace Module +=================== + +System Trace Module (STM) is a device described in MIPI STP specs as +STP trace stream generator. STP (System Trace Protocol) is a trace +protocol multiplexing data from multiple trace sources, each one of +which is assigned a unique pair of master and channel. While some of +these masters and channels are statically allocated to certain +hardware trace sources, others are available to software. Software +trace sources are usually free to pick for themselves any +master/channel combination from this pool. + +On the receiving end of this STP stream (the decoder side), trace +sources can only be identified by master/channel combination, so in +order for the decoder to be able to make sense of the trace that +involves multiple trace sources, it needs to be able to map those +master/channel pairs to the trace sources that it understands. + +For instance, it is helpful to know that syslog messages come on +master 7 channel 15, while arbitrary user applications can use masters +48 to 63 and channels 0 to 127. + +To solve this mapping problem, stm class provides a policy management +mechanism via configfs, that allows defining rules that map string +identifiers to ranges of masters and channels. If these rules (policy) +are consistent with what decoder expects, it will be able to properly +process the trace data. + +This policy is a tree structure containing rules (policy_node) that +have a name (string identifier) and a range of masters and channels +associated with it, located in "stp-policy" subsystem directory in +configfs. The topmost directory's name (the policy) is formatted as +the STM device name to which this policy applies and and arbitrary +string identifier separated by a stop. From the examle above, a rule +may look like this: + +$ ls /config/stp-policy/dummy_stm.my-policy/user +channels masters +$ cat /config/stp-policy/dummy_stm.my-policy/user/masters +48 63 +$ cat /config/stp-policy/dummy_stm.my-policy/user/channels +0 127 + +which means that the master allocation pool for this rule consists of +masters 48 through 63 and channel allocation pool has channels 0 +through 127 in it. Now, any producer (trace source) identifying itself +with "user" identification string will be allocated a master and +channel from within these ranges. + +These rules can be nested, for example, one can define a rule "dummy" +under "user" directory from the example above and this new rule will +be used for trace sources with the id string of "user/dummy". + +Trace sources have to open the stm class device's node and write their +trace data into its file descriptor. In order to identify themselves +to the policy, they need to do a STP_POLICY_ID_SET ioctl on this file +descriptor providing their id string. Otherwise, they will be +automatically allocated a master/channel pair upon first write to this +file descriptor according to the "default" rule of the policy, if such +exists. + +Some STM devices may allow direct mapping of the channel mmio regions +to userspace for zero-copy writing. One mappable page (in terms of +mmu) will usually contain multiple channels' mmios, so the user will +need to allocate that many channels to themselves (via the +aforementioned ioctl() call) to be able to do this. That is, if your +stm device's channel mmio region is 64 bytes and hardware page size is +4096 bytes, after a successful STP_POLICY_ID_SET ioctl() call with +width==64, you should be able to mmap() one page on this file +descriptor and obtain direct access to an mmio region for 64 channels. + +For kernel-based trace sources, there is "stm_source" device +class. Devices of this class can be connected and disconnected to/from +stm devices at runtime via a sysfs attribute. + +Examples of STM devices are Intel Trace Hub [1] and Coresight STM +[2]. + +[1] https://software.intel.com/sites/default/files/managed/d3/3c/intel-th-developer-manual.pdf +[2] http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0444b/index.html diff --git a/drivers/Kconfig b/drivers/Kconfig index 6e973b8e3a..96efe4522c 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -184,4 +184,6 @@ source "drivers/android/Kconfig" source "drivers/nvdimm/Kconfig" +source "drivers/hwtracing/stm/Kconfig" + endmenu diff --git a/drivers/Makefile b/drivers/Makefile index b64b49f6e0..6647bc923f 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -164,4 +164,5 @@ obj-$(CONFIG_MCB) += mcb/ obj-$(CONFIG_RAS) += ras/ obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ +obj-$(CONFIG_STM) += hwtracing/stm/ obj-$(CONFIG_ANDROID) += android/ diff --git a/drivers/hwtracing/stm/Kconfig b/drivers/hwtracing/stm/Kconfig new file mode 100644 index 0000000000..90ed327461 --- /dev/null +++ b/drivers/hwtracing/stm/Kconfig @@ -0,0 +1,8 @@ +config STM + tristate "System Trace Module devices" + help + A System Trace Module (STM) is a device exporting data in System + Trace Protocol (STP) format as defined by MIPI STP standards. + Examples of such devices are Intel Trace Hub and Coresight STM. + + Say Y here to enable System Trace Module device support. diff --git a/drivers/hwtracing/stm/Makefile b/drivers/hwtracing/stm/Makefile new file mode 100644 index 0000000000..adec701649 --- /dev/null +++ b/drivers/hwtracing/stm/Makefile @@ -0,0 +1,3 @@ +obj-$(CONFIG_STM) += stm_core.o + +stm_core-y := core.o policy.o diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c new file mode 100644 index 0000000000..b79c42c625 --- /dev/null +++ b/drivers/hwtracing/stm/core.c @@ -0,0 +1,1029 @@ +/* + * System Trace Module (STM) infrastructure + * Copyright (c) 2014, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * STM class implements generic infrastructure for System Trace Module devices + * as defined in MIPI STPv2 specification. + */ + +#include <linux/uaccess.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/compat.h> +#include <linux/kdev_t.h> +#include <linux/srcu.h> +#include <linux/slab.h> +#include <linux/stm.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include "stm.h" + +#include <uapi/linux/stm.h> + +static unsigned int stm_core_up; + +/* + * The SRCU here makes sure that STM device doesn't disappear from under a + * stm_source_write() caller, which may want to have as little overhead as + * possible. + */ +static struct srcu_struct stm_source_srcu; + +static ssize_t masters_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct stm_device *stm = to_stm_device(dev); + int ret; + + ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end); + + return ret; +} + +static DEVICE_ATTR_RO(masters); + +static ssize_t channels_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct stm_device *stm = to_stm_device(dev); + int ret; + + ret = sprintf(buf, "%u\n", stm->data->sw_nchannels); + + return ret; +} + +static DEVICE_ATTR_RO(channels); + +static struct attribute *stm_attrs[] = { + &dev_attr_masters.attr, + &dev_attr_channels.attr, + NULL, +}; + +ATTRIBUTE_GROUPS(stm); + +static struct class stm_class = { + .name = "stm", + .dev_groups = stm_groups, +}; + +static int stm_dev_match(struct device *dev, const void *data) +{ + const char *name = data; + + return sysfs_streq(name, dev_name(dev)); +} + +/** + * stm_find_device() - find stm device by name + * @buf: character buffer containing the name + * + * This is called when either policy gets assigned to an stm device or an + * stm_source device gets linked to an stm device. + * + * This grabs device's reference (get_device()) and module reference, both + * of which the calling path needs to make sure to drop with stm_put_device(). + * + * Return: stm device pointer or null if lookup failed. + */ +struct stm_device *stm_find_device(const char *buf) +{ + struct stm_device *stm; + struct device *dev; + + if (!stm_core_up) + return NULL; + + dev = class_find_device(&stm_class, NULL, buf, stm_dev_match); + if (!dev) + return NULL; + + stm = to_stm_device(dev); + if (!try_module_get(stm->owner)) { + put_device(dev); + return NULL; + } + + return stm; +} + +/** + * stm_put_device() - drop references on the stm device + * @stm: stm device, previously acquired by stm_find_device() + * + * This drops the module reference and device reference taken by + * stm_find_device(). + */ +void stm_put_device(struct stm_device *stm) +{ + module_put(stm->owner); + put_device(&stm->dev); +} + +/* + * Internally we only care about software-writable masters here, that is the + * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need + * original master numbers to be visible externally, since they are the ones + * that will appear in the STP stream. Thus, the internal bookkeeping uses + * $master - stm_data->sw_start to reference master descriptors and such. + */ + +#define __stm_master(_s, _m) \ + ((_s)->masters[(_m) - (_s)->data->sw_start]) + +static inline struct stp_master * +stm_master(struct stm_device *stm, unsigned int idx) +{ + if (idx < stm->data->sw_start || idx > stm->data->sw_end) + return NULL; + + return __stm_master(stm, idx); +} + +static int stp_master_alloc(struct stm_device *stm, unsigned int idx) +{ + struct stp_master *master; + size_t size; + + size = ALIGN(stm->data->sw_nchannels, 8) / 8; + size += sizeof(struct stp_master); + master = kzalloc(size, GFP_ATOMIC); + if (!master) + return -ENOMEM; + + master->nr_free = stm->data->sw_nchannels; + __stm_master(stm, idx) = master; + + return 0; +} + +static void stp_master_free(struct stm_device *stm, unsigned int idx) +{ + struct stp_master *master = stm_master(stm, idx); + + if (!master) + return; + + __stm_master(stm, idx) = NULL; + kfree(master); +} + +static void stm_output_claim(struct stm_device *stm, struct stm_output *output) +{ + struct stp_master *master = stm_master(stm, output->master); + + if (WARN_ON_ONCE(master->nr_free < output->nr_chans)) + return; + + bitmap_allocate_region(&master->chan_map[0], output->channel, + ilog2(output->nr_chans)); + + master->nr_free -= output->nr_chans; +} + +static void +stm_output_disclaim(struct stm_device *stm, struct stm_output *output) +{ + struct stp_master *master = stm_master(stm, output->master); + + bitmap_release_region(&master->chan_map[0], output->channel, + ilog2(output->nr_chans)); + + output->nr_chans = 0; + master->nr_free += output->nr_chans; +} + +/* + * This is like bitmap_find_free_region(), except it can ignore @start bits + * at the beginning. + */ +static int find_free_channels(unsigned long *bitmap, unsigned int start, + unsigned int end, unsigned int width) +{ + unsigned int pos; + int i; + + for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) { + pos = find_next_zero_bit(bitmap, end + 1, pos); + if (pos + width > end + 1) + break; + + if (pos & (width - 1)) + continue; + + for (i = 1; i < width && !test_bit(pos + i, bitmap); i++) + ; + if (i == width) + return pos; + } + + return -1; +} + +static unsigned int +stm_find_master_chan(struct stm_device *stm, unsigned int width, + unsigned int *mstart, unsigned int mend, + unsigned int *cstart, unsigned int cend) +{ + struct stp_master *master; + unsigned int midx; + int pos, err; + + for (midx = *mstart; midx <= mend; midx++) { + if (!stm_master(stm, midx)) { + err = stp_master_alloc(stm, midx); + if (err) + return err; + } + + master = stm_master(stm, midx); + + if (!master->nr_free) + continue; + + pos = find_free_channels(master->chan_map, *cstart, cend, + width); + if (pos < 0) + continue; + + *mstart = midx; + *cstart = pos; + return 0; + } + + return -ENOSPC; +} + +static int stm_output_assign(struct stm_device *stm, unsigned int width, + struct stp_policy_node *policy_node, + struct stm_output *output) +{ + unsigned int midx, cidx, mend, cend; + int ret = -EINVAL; + + if (width > stm->data->sw_nchannels) + return -EINVAL; + + if (policy_node) { + stp_policy_node_get_ranges(policy_node, + &midx, &mend, &cidx, &cend); + } else { + midx = stm->data->sw_start; + cidx = 0; + mend = stm->data->sw_end; + cend = stm->data->sw_nchannels - 1; + } + + spin_lock(&stm->mc_lock); + /* output is already assigned -- shouldn't happen */ + if (WARN_ON_ONCE(output->nr_chans)) + goto unlock; + + ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend); + if (ret) + goto unlock; + + output->master = midx; + output->channel = cidx; + output->nr_chans = width; + stm_output_claim(stm, output); + dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width); + + ret = 0; +unlock: + spin_unlock(&stm->mc_lock); + + return ret; +} + +static void stm_output_free(struct stm_device *stm, struct stm_output *output) +{ + spin_lock(&stm->mc_lock); + if (output->nr_chans) + stm_output_disclaim(stm, output); + spin_unlock(&stm->mc_lock); +} + +static int major_match(struct device *dev, const void *data) +{ + unsigned int major = *(unsigned int *)data; + + return MAJOR(dev->devt) == major; +} + +static int stm_char_open(struct inode *inode, struct file *file) +{ + struct stm_file *stmf; + struct device *dev; + unsigned int major = imajor(inode); + int err = -ENODEV; + + dev = class_find_device(&stm_class, NULL, &major, major_match); + if (!dev) + return -ENODEV; + + stmf = kzalloc(sizeof(*stmf), GFP_KERNEL); + if (!stmf) + return -ENOMEM; + + stmf->stm = to_stm_device(dev); + + if (!try_module_get(stmf->stm->owner)) + goto err_free; + + file->private_data = stmf; + + return nonseekable_open(inode, file); + +err_free: + kfree(stmf); + + return err; +} + +static int stm_char_release(struct inode *inode, struct file *file) +{ + struct stm_file *stmf = file->private_data; + + stm_output_free(stmf->stm, &stmf->output); + stm_put_device(stmf->stm); + kfree(stmf); + + return 0; +} + +static int stm_file_assign(struct stm_file *stmf, char *id, unsigned int width) +{ + struct stm_device *stm = stmf->stm; + int ret; + + stmf->policy_node = stp_policy_node_lookup(stm, id); + + ret = stm_output_assign(stm, width, stmf->policy_node, &stmf->output); + + if (stmf->policy_node) + stp_policy_node_put(stmf->policy_node); + + return ret; +} + +static void stm_write(struct stm_data *data, unsigned int master, + unsigned int channel, const char *buf, size_t count) +{ + unsigned int flags = STP_PACKET_TIMESTAMPED; + const unsigned char *p = buf, nil = 0; + size_t pos; + ssize_t sz; + + for (pos = 0, p = buf; count > pos; pos += sz, p += sz) { + sz = min_t(unsigned int, count - pos, 8); + sz = data->packet(data, master, channel, STP_PACKET_DATA, flags, + sz, p); + flags = 0; + } + + data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil); +} + +static ssize_t stm_char_write(struct file *file, const char __user *buf, + size_t count, loff_t *ppos) +{ + struct stm_file *stmf = file->private_data; + struct stm_device *stm = stmf->stm; + char *kbuf; + int err; + + /* + * if no m/c have been assigned to this writer up to this + * point, use "default" policy entry + */ + if (!stmf->output.nr_chans) { + err = stm_file_assign(stmf, "default", 1); + /* + * EBUSY means that somebody else just assigned this + * output, which is just fine for write() + */ + if (err && err != -EBUSY) + return err; + } + + kbuf = kmalloc(count + 1, GFP_KERNEL); + if (!kbuf) + return -ENOMEM; + + err = copy_from_user(kbuf, buf, count); + if (err) { + kfree(kbuf); + return -EFAULT; + } + + stm_write(stm->data, stmf->output.master, stmf->output.channel, kbuf, + count); + + kfree(kbuf); + + return count; +} + +static int stm_char_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct stm_file *stmf = file->private_data; + struct stm_device *stm = stmf->stm; + unsigned long size, phys; + + if (!stm->data->mmio_addr) + return -EOPNOTSUPP; + + if (vma->vm_pgoff) + return -EINVAL; + + size = vma->vm_end - vma->vm_start; + + if (stmf->output.nr_chans * stm->data->sw_mmiosz != size) + return -EINVAL; + + phys = stm->data->mmio_addr(stm->data, stmf->output.master, + stmf->output.channel, + stmf->output.nr_chans); + + if (!phys) + return -EINVAL; + + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); + vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP; + vm_iomap_memory(vma, phys, size); + + return 0; +} + +static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg) +{ + struct stm_device *stm = stmf->stm; + struct stp_policy_id *id; + int ret = -EINVAL; + u32 size; + + if (stmf->output.nr_chans) + return -EBUSY; + + if (copy_from_user(&size, arg, sizeof(size))) + return -EFAULT; + + if (size >= PATH_MAX + sizeof(*id)) + return -EINVAL; + + /* + * size + 1 to make sure the .id string at the bottom is terminated, + * which is also why memdup_user() is not useful here + */ + id = kzalloc(size + 1, GFP_KERNEL); + if (!id) + return -ENOMEM; + + if (copy_from_user(id, arg, size)) { + ret = -EFAULT; + goto err_free; + } + + if (id->__reserved_0 || id->__reserved_1) + goto err_free; + + if (id->width < 1 || + id->width > PAGE_SIZE / stm->data->sw_mmiosz) + goto err_free; + + ret = stm_file_assign(stmf, id->id, id->width); + if (ret) + goto err_free; + + ret = 0; + + if (stm->data->link) + ret = stm->data->link(stm->data, stmf->output.master, + stmf->output.channel); + + if (ret) { + stm_output_free(stmf->stm, &stmf->output); + stm_put_device(stmf->stm); + } + +err_free: + kfree(id); + + return ret; +} + +static int stm_char_policy_get_ioctl(struct stm_file *stmf, void __user *arg) +{ + struct stp_policy_id id = { + .size = sizeof(id), + .master = stmf->output.master, + .channel = stmf->output.channel, + .width = stmf->output.nr_chans, + .__reserved_0 = 0, + .__reserved_1 = 0, + }; + + return copy_to_user(arg, &id, id.size) ? -EFAULT : 0; +} + +static long +stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct stm_file *stmf = file->private_data; + struct stm_data *stm_data = stmf->stm->data; + int err = -ENOTTY; + u64 options; + + switch (cmd) { + case STP_POLICY_ID_SET: + err = stm_char_policy_set_ioctl(stmf, (void __user *)arg); + if (err) + return err; + + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); + + case STP_POLICY_ID_GET: + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); + + case STP_SET_OPTIONS: + if (copy_from_user(&options, (u64 __user *)arg, sizeof(u64))) + return -EFAULT; + + if (stm_data->set_options) + err = stm_data->set_options(stm_data, + stmf->output.master, + stmf->output.channel, + stmf->output.nr_chans, + options); + + break; + default: + break; + } + + return err; +} + +#ifdef CONFIG_COMPAT +static long +stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); +} +#else +#define stm_char_compat_ioctl NULL +#endif + +static const struct file_operations stm_fops = { + .open = stm_char_open, + .release = stm_char_release, + .write = stm_char_write, + .mmap = stm_char_mmap, + .unlocked_ioctl = stm_char_ioctl, + .compat_ioctl = stm_char_compat_ioctl, + .llseek = no_llseek, +}; + +static void stm_device_release(struct device *dev) +{ + struct stm_device *stm = to_stm_device(dev); + + kfree(stm); +} + +int stm_register_device(struct device *parent, struct stm_data *stm_data, + struct module *owner) +{ + struct stm_device *stm; + unsigned int nmasters; + int err = -ENOMEM; + + if (!stm_core_up) + return -EPROBE_DEFER; + + if (!stm_data->packet || !stm_data->sw_nchannels) + return -EINVAL; + + nmasters = stm_data->sw_end - stm_data->sw_start; + stm = kzalloc(sizeof(*stm) + nmasters * sizeof(void *), GFP_KERNEL); + if (!stm) + return -ENOMEM; + + stm->major = register_chrdev(0, stm_data->name, &stm_fops); + if (stm->major < 0) + goto err_free; + + device_initialize(&stm->dev); + stm->dev.devt = MKDEV(stm->major, 0); + stm->dev.class = &stm_class; + stm->dev.parent = parent; + stm->dev.release = stm_device_release; + + err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name); + if (err) + goto err_device; + + err = device_add(&stm->dev); + if (err) + goto err_device; + + spin_lock_init(&stm->link_lock); + INIT_LIST_HEAD(&stm->link_list); + + spin_lock_init(&stm->mc_lock); + mutex_init(&stm->policy_mutex); + stm->sw_nmasters = nmasters; + stm->owner = owner; + stm->data = stm_data; + stm_data->stm = stm; + + return 0; + +err_device: + put_device(&stm->dev); +err_free: + kfree(stm); + + return err; +} +EXPORT_SYMBOL_GPL(stm_register_device); + +static void __stm_source_link_drop(struct stm_source_device *src, + struct stm_device *stm); + +void stm_unregister_device(struct stm_data *stm_data) +{ + struct stm_device *stm = stm_data->stm; + struct stm_source_device *src, *iter; + int i; + + spin_lock(&stm->link_lock); + list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) { + __stm_source_link_drop(src, stm); + } + spin_unlock(&stm->link_lock); + + synchronize_srcu(&stm_source_srcu); + + unregister_chrdev(stm->major, stm_data->name); + + mutex_lock(&stm->policy_mutex); + if (stm->policy) + stp_policy_unbind(stm->policy); + mutex_unlock(&stm->policy_mutex); + + for (i = 0; i < stm->sw_nmasters; i++) + stp_master_free(stm, i); + + device_unregister(&stm->dev); + stm_data->stm = NULL; +} +EXPORT_SYMBOL_GPL(stm_unregister_device); + +/** + * stm_source_link_add() - connect an stm_source device to an stm device + * @src: stm_source device + * @stm: stm device + * + * This function establishes a link from stm_source to an stm device so that + * the former can send out trace data to the latter. + * + * Return: 0 on success, -errno otherwise. + */ +static int stm_source_link_add(struct stm_source_device *src, + struct stm_device *stm) +{ + char *id; + int err; + + spin_lock(&stm->link_lock); + spin_lock(&src->link_lock); + + /* src->link is dereferenced under stm_source_srcu but not the list */ + rcu_assign_pointer(src->link, stm); + list_add_tail(&src->link_entry, &stm->link_list); + + spin_unlock(&src->link_lock); + spin_unlock(&stm->link_lock); + + id = kstrdup(src->data->name, GFP_KERNEL); + if (id) { + src->policy_node = + stp_policy_node_lookup(stm, id); + + kfree(id); + } + + err = stm_output_assign(stm, src->data->nr_chans, + src->policy_node, &src->output); + + if (src->policy_node) + stp_policy_node_put(src->policy_node); + + if (err) + goto fail_detach; + + /* this is to notify the STM device that a new link has been made */ + if (stm->data->link) + err = stm->data->link(stm->data, src->output.master, + src->output.channel); + + if (err) + goto fail_free_output; + + /* this is to let the source carry out all necessary preparations */ + if (src->data->link) + src->data->link(src->data); + + return 0; + +fail_free_output: + stm_output_free(stm, &src->output); + stm_put_device(stm); + +fail_detach: + spin_lock(&stm->link_lock); + spin_lock(&src->link_lock); + + rcu_assign_pointer(src->link, NULL); + list_del_init(&src->link_entry); + + spin_unlock(&src->link_lock); + spin_unlock(&stm->link_lock); + + return err; +} + +/** + * __stm_source_link_drop() - detach stm_source from an stm device + * @src: stm_source device + * @stm: stm device + * + * If @stm is @src::link, disconnect them from one another and put the + * reference on the @stm device. + * + * Caller must hold stm::link_lock. + */ +static void __stm_source_link_drop(struct stm_source_device *src, + struct stm_device *stm) +{ + spin_lock(&src->link_lock); + if (WARN_ON_ONCE(src->link != stm)) { + spin_unlock(&src->link_lock); + return; + } + + stm_output_free(src->link, &src->output); + /* caller must hold stm::link_lock */ + list_del_init(&src->link_entry); + /* matches stm_find_device() from stm_source_link_store() */ + stm_put_device(src->link); + rcu_assign_pointer(src->link, NULL); + + spin_unlock(&src->link_lock); +} + +/** + * stm_source_link_drop() - detach stm_source from its stm device + * @src: stm_source device + * + * Unlinking means disconnecting from source's STM device; after this + * writes will be unsuccessful until it is linked to a new STM device. + * + * This will happen on "stm_source_link" sysfs attribute write to undo + * the existing link (if any), or on linked STM device's de-registration. + */ +static void stm_source_link_drop(struct stm_source_device *src) +{ + struct stm_device *stm; + int idx; + + idx = srcu_read_lock(&stm_source_srcu); + stm = srcu_dereference(src->link, &stm_source_srcu); + + if (stm) { + if (src->data->unlink) + src->data->unlink(src->data); + + spin_lock(&stm->link_lock); + __stm_source_link_drop(src, stm); + spin_unlock(&stm->link_lock); + } + + srcu_read_unlock(&stm_source_srcu, idx); +} + +static ssize_t stm_source_link_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct stm_source_device *src = to_stm_source_device(dev); + struct stm_device *stm; + int idx, ret; + + idx = srcu_read_lock(&stm_source_srcu); + stm = srcu_dereference(src->link, &stm_source_srcu); + ret = sprintf(buf, "%s\n", + stm ? dev_name(&stm->dev) : "<none>"); + srcu_read_unlock(&stm_source_srcu, idx); + + return ret; +} + +static ssize_t stm_source_link_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct stm_source_device *src = to_stm_source_device(dev); + struct stm_device *link; + int err; + + stm_source_link_drop(src); + + link = stm_find_device(buf); + if (!link) + return -EINVAL; + + err = stm_source_link_add(src, link); + if (err) + stm_put_device(link); + + return err ? : count; +} + +static DEVICE_ATTR_RW(stm_source_link); + +static struct attribute *stm_source_attrs[] = { + &dev_attr_stm_source_link.attr, + NULL, +}; + +ATTRIBUTE_GROUPS(stm_source); + +static struct class stm_source_class = { + .name = "stm_source", + .dev_groups = stm_source_groups, +}; + +static void stm_source_device_release(struct device *dev) +{ + struct stm_source_device *src = to_stm_source_device(dev); + + kfree(src); +} + +/** + * stm_source_register_device() - register an stm_source device + * @parent: parent device + * @data: device description structure + * + * This will create a device of stm_source class that can write + * data to an stm device once linked. + * + * Return: 0 on success, -errno otherwise. + */ +int stm_source_register_device(struct device *parent, + struct stm_source_data *data) +{ + struct stm_source_device *src; + int err; + + if (!stm_core_up) + return -EPROBE_DEFER; + + src = kzalloc(sizeof(*src), GFP_KERNEL); + if (!src) + return -ENOMEM; + + device_initialize(&src->dev); + src->dev.class = &stm_source_class; + src->dev.parent = parent; + src->dev.release = stm_source_device_release; + + err = kobject_set_name(&src->dev.kobj, "%s", data->name); + if (err) + goto err; + + err = device_add(&src->dev); + if (err) + goto err; + + spin_lock_init(&src->link_lock); + INIT_LIST_HEAD(&src->link_entry); + src->data = data; + data->src = src; + + return 0; + +err: + put_device(&src->dev); + kfree(src); + + return err; +} +EXPORT_SYMBOL_GPL(stm_source_register_device); + +/** + * stm_source_unregister_device() - unregister an stm_source device + * @data: device description that was used to register the device + * + * This will remove a previously created stm_source device from the system. + */ +void stm_source_unregister_device(struct stm_source_data *data) +{ + struct stm_source_device *src = data->src; + + stm_source_link_drop(src); + + device_destroy(&stm_source_class, src->dev.devt); +} +EXPORT_SYMBOL_GPL(stm_source_unregister_device); + +int stm_source_write(struct stm_source_data *data, unsigned int chan, + const char *buf, size_t count) +{ + struct stm_source_device *src = data->src; + struct stm_device *stm; + int idx; + + if (!src->output.nr_chans) + return -ENODEV; + + if (chan >= src->output.nr_chans) + return -EINVAL; + + idx = srcu_read_lock(&stm_source_srcu); + + stm = srcu_dereference(src->link, &stm_source_srcu); + if (stm) + stm_write(stm->data, src->output.master, + src->output.channel + chan, + buf, count); + else + count = -ENODEV; + + srcu_read_unlock(&stm_source_srcu, idx); + + return count; +} +EXPORT_SYMBOL_GPL(stm_source_write); + +static int __init stm_core_init(void) +{ + int err; + + err = class_register(&stm_class); + if (err) + return err; + + err = class_register(&stm_source_class); + if (err) + goto err_stm; + + err = stp_configfs_init(); + if (err) + goto err_src; + + init_srcu_struct(&stm_source_srcu); + + stm_core_up++; + + return 0; + +err_src: + class_unregister(&stm_source_class); +err_stm: + class_unregister(&stm_class); + + return err; +} + +module_init(stm_core_init); + +static void __exit stm_core_exit(void) +{ + cleanup_srcu_struct(&stm_source_srcu); + class_unregister(&stm_source_class); + class_unregister(&stm_class); + stp_configfs_exit(); +} + +module_exit(stm_core_exit); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("System Trace Module device class"); +MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>"); diff --git a/drivers/hwtracing/stm/policy.c b/drivers/hwtracing/stm/policy.c new file mode 100644 index 0000000000..6498a9dbb7 --- /dev/null +++ b/drivers/hwtracing/stm/policy.c @@ -0,0 +1,529 @@ +/* + * System Trace Module (STM) master/channel allocation policy management + * Copyright (c) 2014, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * A master/channel allocation policy allows mapping string identifiers to + * master and channel ranges, where allocation can be done. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/types.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/configfs.h> +#include <linux/slab.h> +#include <linux/stm.h> +#include "stm.h" + +/* + * STP Master/Channel allocation policy configfs layout. + */ + +struct stp_policy { + struct config_group group; + struct stm_device *stm; +}; + +struct stp_policy_node { + struct config_group group; + struct stp_policy *policy; + unsigned int first_master; + unsigned int last_master; + unsigned int first_channel; + unsigned int last_channel; +}; + +static struct configfs_subsystem stp_policy_subsys; + +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, + unsigned int *mstart, unsigned int *mend, + unsigned int *cstart, unsigned int *cend) +{ + *mstart = policy_node->first_master; + *mend = policy_node->last_master; + *cstart = policy_node->first_channel; + *cend = policy_node->last_channel; +} + +static inline char *stp_policy_node_name(struct stp_policy_node *policy_node) +{ + return policy_node->group.cg_item.ci_name ? : "<none>"; +} + +static inline struct stp_policy *to_stp_policy(struct config_item *item) +{ + return item ? + container_of(to_config_group(item), struct stp_policy, group) : + NULL; +} + +static inline struct stp_policy_node * +to_stp_policy_node(struct config_item *item) +{ + return item ? + container_of(to_config_group(item), struct stp_policy_node, + group) : + NULL; +} + +static ssize_t stp_policy_node_masters_show(struct stp_policy_node *policy_node, + char *page) +{ + ssize_t count; + + count = sprintf(page, "%u %u\n", policy_node->first_master, + policy_node->last_master); + + return count; +} + +static ssize_t +stp_policy_node_masters_store(struct stp_policy_node *policy_node, + const char *page, size_t count) +{ + unsigned int first, last; + struct stm_device *stm; + char *p = (char *)page; + ssize_t ret = -ENODEV; + + if (sscanf(p, "%u %u", &first, &last) != 2) + return -EINVAL; + + mutex_lock(&stp_policy_subsys.su_mutex); + stm = policy_node->policy->stm; + if (!stm) + goto unlock; + + /* must be within [sw_start..sw_end], which is an inclusive range */ + if (first > INT_MAX || last > INT_MAX || first > last || + first < stm->data->sw_start || + last > stm->data->sw_end) { + ret = -ERANGE; + goto unlock; + } + + ret = count; + policy_node->first_master = first; + policy_node->last_master = last; + +unlock: + mutex_unlock(&stp_policy_subsys.su_mutex); + + return ret; +} + +static ssize_t +stp_policy_node_channels_show(struct stp_policy_node *policy_node, char *page) +{ + ssize_t count; + + count = sprintf(page, "%u %u\n", policy_node->first_channel, + policy_node->last_channel); + + return count; +} + +static ssize_t +stp_policy_node_channels_store(struct stp_policy_node *policy_node, + const char *page, size_t count) +{ + unsigned int first, last; + struct stm_device *stm; + char *p = (char *)page; + ssize_t ret = -ENODEV; + + if (sscanf(p, "%u %u", &first, &last) != 2) + return -EINVAL; + + mutex_lock(&stp_policy_subsys.su_mutex); + stm = policy_node->policy->stm; + if (!stm) + goto unlock; + + if (first > INT_MAX || last > INT_MAX || first > last || + last >= stm->data->sw_nchannels) { + ret = -ERANGE; + goto unlock; + } + + ret = count; + policy_node->first_channel = first; + policy_node->last_channel = last; + +unlock: + mutex_unlock(&stp_policy_subsys.su_mutex); + + return ret; +} + +static void stp_policy_node_release(struct config_item *item) +{ + kfree(to_stp_policy_node(item)); +} + +struct stp_policy_node_attribute { + struct configfs_attribute attr; + ssize_t (*show)(struct stp_policy_node *, char *); + ssize_t (*store)(struct stp_policy_node *, const char *, size_t); +}; + +static ssize_t stp_policy_node_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + struct stp_policy_node *policy_node = to_stp_policy_node(item); + struct stp_policy_node_attribute *pn_attr = + container_of(attr, struct stp_policy_node_attribute, attr); + ssize_t count = 0; + + if (pn_attr->show) + count = pn_attr->show(policy_node, page); + + return count; +} + +static ssize_t stp_policy_node_attr_store(struct config_item *item, + struct configfs_attribute *attr, + const char *page, size_t len) +{ + struct stp_policy_node *policy_node = to_stp_policy_node(item); + struct stp_policy_node_attribute *pn_attr = + container_of(attr, struct stp_policy_node_attribute, attr); + ssize_t count = -EINVAL; + + if (pn_attr->store) + count = pn_attr->store(policy_node, page, len); + + return count; +} + +static struct configfs_item_operations stp_policy_node_item_ops = { + .release = stp_policy_node_release, + .show_attribute = stp_policy_node_attr_show, + .store_attribute = stp_policy_node_attr_store, +}; + +static struct stp_policy_node_attribute stp_policy_node_attr_range = { + .attr = { + .ca_owner = THIS_MODULE, + .ca_name = "masters", + .ca_mode = S_IRUGO | S_IWUSR, + }, + .show = stp_policy_node_masters_show, + .store = stp_policy_node_masters_store, +}; + +static struct stp_policy_node_attribute stp_policy_node_attr_channels = { + .attr = { + .ca_owner = THIS_MODULE, + .ca_name = "channels", + .ca_mode = S_IRUGO | S_IWUSR, + }, + .show = stp_policy_node_channels_show, + .store = stp_policy_node_channels_store, +}; + +static struct configfs_attribute *stp_policy_node_attrs[] = { + &stp_policy_node_attr_range.attr, + &stp_policy_node_attr_channels.attr, + NULL, +}; + +static struct config_item_type stp_policy_type; +static struct config_item_type stp_policy_node_type; + +static struct config_group * +stp_policy_node_make(struct config_group *group, const char *name) +{ + struct stp_policy_node *policy_node, *parent_node; + struct stp_policy *policy; + + if (group->cg_item.ci_type == &stp_policy_type) { + policy = container_of(group, struct stp_policy, group); + } else { + parent_node = container_of(group, struct stp_policy_node, + group); + policy = parent_node->policy; + } + + if (!policy->stm) + return ERR_PTR(-ENODEV); + + policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL); + if (!policy_node) + return ERR_PTR(-ENOMEM); + + config_group_init_type_name(&policy_node->group, name, + &stp_policy_node_type); + + policy_node->policy = policy; + + /* default values for the attributes */ + policy_node->first_master = policy->stm->data->sw_start; + policy_node->last_master = policy->stm->data->sw_end; + policy_node->first_channel = 0; + policy_node->last_channel = policy->stm->data->sw_nchannels - 1; + + return &policy_node->group; +} + +static void +stp_policy_node_drop(struct config_group *group, struct config_item *item) +{ + config_item_put(item); +} + +static struct configfs_group_operations stp_policy_node_group_ops = { + .make_group = stp_policy_node_make, + .drop_item = stp_policy_node_drop, +}; + +static struct config_item_type stp_policy_node_type = { + .ct_item_ops = &stp_policy_node_item_ops, + .ct_group_ops = &stp_policy_node_group_ops, + .ct_attrs = stp_policy_node_attrs, + .ct_owner = THIS_MODULE, +}; + +/* + * Root group: policies. + */ +static struct configfs_attribute stp_policy_attr_device = { + .ca_owner = THIS_MODULE, + .ca_name = "device", + .ca_mode = S_IRUGO, +}; + +static struct configfs_attribute *stp_policy_attrs[] = { + &stp_policy_attr_device, + NULL, +}; + +static ssize_t stp_policy_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + struct stp_policy *policy = to_stp_policy(item); + ssize_t count; + + count = sprintf(page, "%s\n", + (policy && policy->stm) ? + policy->stm->data->name : + "<none>"); + + return count; +} + +void stp_policy_unbind(struct stp_policy *policy) +{ + struct stm_device *stm = policy->stm; + + if (WARN_ON_ONCE(!policy->stm)) + return; + + mutex_lock(&stm->policy_mutex); + stm->policy = NULL; + mutex_unlock(&stm->policy_mutex); + + policy->stm = NULL; + + stm_put_device(stm); +} + +static void stp_policy_release(struct config_item *item) +{ + struct stp_policy *policy = to_stp_policy(item); + + stp_policy_unbind(policy); + kfree(policy); +} + +static struct configfs_item_operations stp_policy_item_ops = { + .release = stp_policy_release, + .show_attribute = stp_policy_attr_show, +}; + +static struct configfs_group_operations stp_policy_group_ops = { + .make_group = stp_policy_node_make, +}; + +static struct config_item_type stp_policy_type = { + .ct_item_ops = &stp_policy_item_ops, + .ct_group_ops = &stp_policy_group_ops, + .ct_attrs = stp_policy_attrs, + .ct_owner = THIS_MODULE, +}; + +static struct config_group * +stp_policies_make(struct config_group *group, const char *name) +{ + struct config_group *ret; + struct stm_device *stm; + char *devname, *p; + + devname = kasprintf(GFP_KERNEL, "%s", name); + if (!devname) + return ERR_PTR(-ENOMEM); + + /* + * node must look like <device_name>.<policy_name>, where + * <device_name> is the name of an existing stm device and + * <policy_name> is an arbitrary string + */ + p = strchr(devname, '.'); + if (!p) { + kfree(devname); + return ERR_PTR(-EINVAL); + } + + *p++ = '\0'; + + stm = stm_find_device(devname); + kfree(devname); + + if (!stm) + return ERR_PTR(-ENODEV); + + mutex_lock(&stm->policy_mutex); + if (stm->policy) { + ret = ERR_PTR(-EBUSY); + goto unlock_policy; + } + + stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); + if (!stm->policy) { + ret = ERR_PTR(-ENOMEM); + goto unlock_policy; + } + + config_group_init_type_name(&stm->policy->group, name, + &stp_policy_type); + stm->policy->stm = stm; + + ret = &stm->policy->group; + +unlock_policy: + mutex_unlock(&stm->policy_mutex); + + if (IS_ERR(ret)) + stm_put_device(stm); + + return ret; +} + +static struct configfs_group_operations stp_policies_group_ops = { + .make_group = stp_policies_make, +}; + +static struct config_item_type stp_policies_type = { + .ct_group_ops = &stp_policies_group_ops, + .ct_owner = THIS_MODULE, +}; + +static struct configfs_subsystem stp_policy_subsys = { + .su_group = { + .cg_item = { + .ci_namebuf = "stp-policy", + .ci_type = &stp_policies_type, + }, + }, +}; + +/* + * Lock the policy mutex from the outside + */ +static struct stp_policy_node * +__stp_policy_node_lookup(struct stp_policy *policy, char *s) +{ + struct stp_policy_node *policy_node, *ret; + struct list_head *head = &policy->group.cg_children; + struct config_item *item; + char *start, *end = s; + + if (list_empty(head)) + return NULL; + + /* return the first entry if everything else fails */ + item = list_entry(head->next, struct config_item, ci_entry); + ret = to_stp_policy_node(item); + +next: + for (;;) { + start = strsep(&end, "/"); + if (!start) + break; + + if (!*start) + continue; + + list_for_each_entry(item, head, ci_entry) { + policy_node = to_stp_policy_node(item); + + if (!strcmp(start, + policy_node->group.cg_item.ci_name)) { + ret = policy_node; + + if (!end) + goto out; + + head = &policy_node->group.cg_children; + goto next; + } + } + break; + } + +out: + return ret; +} + + +struct stp_policy_node * +stp_policy_node_lookup(struct stm_device *stm, char *s) +{ + struct stp_policy_node *policy_node = NULL; + + mutex_lock(&stp_policy_subsys.su_mutex); + + mutex_lock(&stm->policy_mutex); + if (stm->policy) + policy_node = __stp_policy_node_lookup(stm->policy, s); + mutex_unlock(&stm->policy_mutex); + + if (policy_node) + config_item_get(&policy_node->group.cg_item); + mutex_unlock(&stp_policy_subsys.su_mutex); + + return policy_node; +} + +void stp_policy_node_put(struct stp_policy_node *policy_node) +{ + config_item_put(&policy_node->group.cg_item); +} + +int __init stp_configfs_init(void) +{ + int err; + + config_group_init(&stp_policy_subsys.su_group); + mutex_init(&stp_policy_subsys.su_mutex); + err = configfs_register_subsystem(&stp_policy_subsys); + + return err; +} + +void __exit stp_configfs_exit(void) +{ + configfs_unregister_subsystem(&stp_policy_subsys); +} diff --git a/drivers/hwtracing/stm/stm.h b/drivers/hwtracing/stm/stm.h new file mode 100644 index 0000000000..cf33bf976a --- /dev/null +++ b/drivers/hwtracing/stm/stm.h @@ -0,0 +1,87 @@ +/* + * System Trace Module (STM) infrastructure + * Copyright (c) 2014, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * STM class implements generic infrastructure for System Trace Module devices + * as defined in MIPI STPv2 specification. + */ + +#ifndef _STM_STM_H_ +#define _STM_STM_H_ + +struct stp_policy; +struct stp_policy_node; + +struct stp_policy_node * +stp_policy_node_lookup(struct stm_device *stm, char *s); +void stp_policy_node_put(struct stp_policy_node *policy_node); +void stp_policy_unbind(struct stp_policy *policy); + +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, + unsigned int *mstart, unsigned int *mend, + unsigned int *cstart, unsigned int *cend); +int stp_configfs_init(void); +void stp_configfs_exit(void); + +struct stp_master { + unsigned int nr_free; + unsigned long chan_map[0]; +}; + +struct stm_device { + struct device dev; + struct module *owner; + struct stp_policy *policy; + struct mutex policy_mutex; + int major; + unsigned int sw_nmasters; + struct stm_data *data; + spinlock_t link_lock; + struct list_head link_list; + /* master allocation */ + spinlock_t mc_lock; + struct stp_master *masters[0]; +}; + +#define to_stm_device(_d) \ + container_of((_d), struct stm_device, dev) + +struct stm_output { + unsigned int master; + unsigned int channel; + unsigned int nr_chans; +}; + +struct stm_file { + struct stm_device *stm; + struct stp_policy_node *policy_node; + struct stm_output output; +}; + +struct stm_device *stm_find_device(const char *name); +void stm_put_device(struct stm_device *stm); + +struct stm_source_device { + struct device dev; + struct stm_source_data *data; + spinlock_t link_lock; + struct stm_device *link; + struct list_head link_entry; + /* one output per stm_source device */ + struct stp_policy_node *policy_node; + struct stm_output output; +}; + +#define to_stm_source_device(_d) \ + container_of((_d), struct stm_source_device, dev) + +#endif /* _STM_STM_H_ */ diff --git a/include/linux/stm.h b/include/linux/stm.h new file mode 100644 index 0000000000..9d0083d364 --- /dev/null +++ b/include/linux/stm.h @@ -0,0 +1,126 @@ +/* + * System Trace Module (STM) infrastructure apis + * Copyright (C) 2014 Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ + +#ifndef _STM_H_ +#define _STM_H_ + +#include <linux/device.h> + +/** + * enum stp_packet_type - STP packets that an STM driver sends + */ +enum stp_packet_type { + STP_PACKET_DATA = 0, + STP_PACKET_FLAG, + STP_PACKET_USER, + STP_PACKET_MERR, + STP_PACKET_GERR, + STP_PACKET_TRIG, + STP_PACKET_XSYNC, +}; + +/** + * enum stp_packet_flags - STP packet modifiers + */ +enum stp_packet_flags { + STP_PACKET_MARKED = 0x1, + STP_PACKET_TIMESTAMPED = 0x2, +}; + +struct stp_policy; + +struct stm_device; + +/** + * struct stm_data - STM device description and callbacks + * @name: device name + * @stm: internal structure, only used by stm class code + * @sw_start: first STP master available to software + * @sw_end: last STP master available to software + * @sw_nchannels: number of STP channels per master + * @sw_mmiosz: size of one channel's IO space, for mmap, optional + * @packet: callback that sends an STP packet + * @mmio_addr: mmap callback, optional + * @link: called when a new stm_source gets linked to us, optional + * @unlink: likewise for unlinking, again optional + * @set_options: set device-specific options on a channel + * + * Fill out this structure before calling stm_register_device() to create + * an STM device and stm_unregister_device() to destroy it. It will also be + * passed back to @packet(), @mmio_addr(), @link(), @unlink() and @set_options() + * callbacks. + * + * Normally, an STM device will have a range of masters available to software + * and the rest being statically assigned to various hardware trace sources. + * The former is defined by the the range [@sw_start..@sw_end] of the device + * description. That is, the lowest master that can be allocated to software + * writers is @sw_start and data from this writer will appear is @sw_start + * master in the STP stream. + */ +struct stm_data { + const char *name; + struct stm_device *stm; + unsigned int sw_start; + unsigned int sw_end; + unsigned int sw_nchannels; + unsigned int sw_mmiosz; + ssize_t (*packet)(struct stm_data *, unsigned int, + unsigned int, unsigned int, + unsigned int, unsigned int, + const unsigned char *); + phys_addr_t (*mmio_addr)(struct stm_data *, unsigned int, + unsigned int, unsigned int); + int (*link)(struct stm_data *, unsigned int, + unsigned int); + void (*unlink)(struct stm_data *, unsigned int, + unsigned int); + long (*set_options)(struct stm_data *, unsigned int, + unsigned int, unsigned int, + unsigned long); +}; + +int stm_register_device(struct device *parent, struct stm_data *stm_data, + struct module *owner); +void stm_unregister_device(struct stm_data *stm_data); + +struct stm_source_device; + +/** + * struct stm_source_data - STM source device description and callbacks + * @name: device name, will be used for policy lookup + * @src: internal structure, only used by stm class code + * @nr_chans: number of channels to allocate + * @link: called when this source gets linked to an STM device + * @unlink: called when this source is about to get unlinked from its STM + * + * Fill in this structure before calling stm_source_register_device() to + * register a source device. Also pass it to unregister and write calls. + */ +struct stm_source_data { + const char *name; + struct stm_source_device *src; + unsigned int percpu; + unsigned int nr_chans; + int (*link)(struct stm_source_data *data); + void (*unlink)(struct stm_source_data *data); +}; + +int stm_source_register_device(struct device *parent, + struct stm_source_data *data); +void stm_source_unregister_device(struct stm_source_data *data); + +int stm_source_write(struct stm_source_data *data, unsigned int chan, + const char *buf, size_t count); + +#endif /* _STM_H_ */ diff --git a/include/uapi/linux/stm.h b/include/uapi/linux/stm.h new file mode 100644 index 0000000000..626a8d3f63 --- /dev/null +++ b/include/uapi/linux/stm.h @@ -0,0 +1,50 @@ +/* + * System Trace Module (STM) userspace interfaces + * Copyright (c) 2014, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * STM class implements generic infrastructure for System Trace Module devices + * as defined in MIPI STPv2 specification. + */ + +#ifndef _UAPI_LINUX_STM_H +#define _UAPI_LINUX_STM_H + +#include <linux/types.h> + +/** + * struct stp_policy_id - identification for the STP policy + * @size: size of the structure including real id[] length + * @master: assigned master + * @channel: first assigned channel + * @width: number of requested channels + * @id: identification string + * + * User must calculate the total size of the structure and put it into + * @size field, fill out the @id and desired @width. In return, kernel + * fills out @master, @channel and @width. + */ +struct stp_policy_id { + __u32 size; + __u16 master; + __u16 channel; + __u16 width; + /* padding */ + __u16 __reserved_0; + __u32 __reserved_1; + char id[0]; +}; + +#define STP_POLICY_ID_SET _IOWR('%', 0, struct stp_policy_id) +#define STP_POLICY_ID_GET _IOR('%', 1, struct stp_policy_id) +#define STP_SET_OPTIONS _IOW('%', 2, __u64) + +#endif /* _UAPI_LINUX_STM_H */ -- 2.1.4 ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices 2015-07-06 10:08 ` [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices Alexander Shishkin @ 2015-07-08 12:32 ` Chunyan Zhang 2015-07-08 12:49 ` Alexander Shishkin [not found] ` <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> 1 sibling, 1 reply; 16+ messages in thread From: Chunyan Zhang @ 2015-07-08 12:32 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, mathieu.poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, linux-api@vger.kernel.org On Mon, Jul 6, 2015 at 6:08 PM, Alexander Shishkin <alexander.shishkin@linux.intel.com> wrote: > A System Trace Module (STM) is a device exporting data in System Trace > Protocol (STP) format as defined by MIPI STP standards. Examples of such > devices are Intel Trace Hub and Coresight STM. > > This abstraction provides a unified interface for software trace sources > to send their data over an STM device to a debug host. In order to do > that, such a trace source needs to be assigned a pair of master/channel > identifiers that all the data from this source will be tagged with. The > STP decoder on the debug host side will use these master/channel tags to > distinguish different trace streams from one another inside one STP > stream. > > This abstraction provides a configfs-based policy management mechanism > for dynamic allocation of these master/channel pairs based on trace > source-supplied string identifier. It has the flexibility of being > defined at runtime and at the same time (provided that the policy > definition is aligned with the decoding end) consistency. > > For userspace trace sources, this abstraction provides write()-based and > mmap()-based (if the underlying stm device allows this) output mechanism. > > For kernel-side trace sources, we provide "stm_source" device class that > can be connected to an stm device at run time. > > Cc: linux-api@vger.kernel.org > Cc: Mathieu Poirier <mathieu.poirier@linaro.org> > Signed-off-by: Alexander Shishkin <alexander.shishkin@linux.intel.com> > --- > Documentation/ABI/testing/configfs-stp-policy | 48 + > Documentation/ABI/testing/sysfs-class-stm | 14 + > Documentation/ABI/testing/sysfs-class-stm_source | 11 + > Documentation/ioctl/ioctl-number.txt | 3 + > Documentation/trace/stm.txt | 80 ++ > drivers/Kconfig | 2 + > drivers/Makefile | 1 + > drivers/hwtracing/stm/Kconfig | 8 + > drivers/hwtracing/stm/Makefile | 3 + > drivers/hwtracing/stm/core.c | 1029 ++++++++++++++++++++++ > drivers/hwtracing/stm/policy.c | 529 +++++++++++ > drivers/hwtracing/stm/stm.h | 87 ++ > include/linux/stm.h | 126 +++ > include/uapi/linux/stm.h | 50 ++ > 14 files changed, 1991 insertions(+) > create mode 100644 Documentation/ABI/testing/configfs-stp-policy > create mode 100644 Documentation/ABI/testing/sysfs-class-stm > create mode 100644 Documentation/ABI/testing/sysfs-class-stm_source > create mode 100644 Documentation/trace/stm.txt > create mode 100644 drivers/hwtracing/stm/Kconfig > create mode 100644 drivers/hwtracing/stm/Makefile > create mode 100644 drivers/hwtracing/stm/core.c > create mode 100644 drivers/hwtracing/stm/policy.c > create mode 100644 drivers/hwtracing/stm/stm.h > create mode 100644 include/linux/stm.h > create mode 100644 include/uapi/linux/stm.h > > diff --git a/Documentation/ABI/testing/configfs-stp-policy b/Documentation/ABI/testing/configfs-stp-policy > new file mode 100644 > index 0000000000..421ce6825c > --- /dev/null > +++ b/Documentation/ABI/testing/configfs-stp-policy > @@ -0,0 +1,48 @@ > +What: /config/stp-policy > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group contains policies mandating Master/Channel allocation > + for software sources wishing to send trace data over an STM > + device. > + > +What: /config/stp-policy/<device>.<policy> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group is the root of a policy; its name is a concatenation > + of an stm device name to which this policy applies and an > + arbitrary string. If <device> part doesn't match an existing > + stm device, mkdir will fail with ENODEV; if that device already > + has a policy assigned to it, mkdir will fail with EBUSY. > + > +What: /config/stp-policy/<device>.<policy>/device > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + STM device to which this policy applies, read only. Same as the > + <device> component of its parent directory. > + > +What: /config/stp-policy/<device>.<policy>/<node> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Policy node is a string identifier that software clients will > + use to request a master/channel to be allocated and assigned to > + them. > + > +What: /config/stp-policy/<device>.<policy>/<node>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of masters from which to allocate for users of this node. > + Write two numbers: the first master and the last master number. > + > +What: /config/stp-policy/<device>.<policy>/<node>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of channels from which to allocate for users of this node. > + Write two numbers: the first channel and the last channel > + number. > + > diff --git a/Documentation/ABI/testing/sysfs-class-stm b/Documentation/ABI/testing/sysfs-class-stm > new file mode 100644 > index 0000000000..c9aa4f3fc9 > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm > @@ -0,0 +1,14 @@ > +What: /sys/class/stm/<stm>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> > +Description: > + Shows first and last available to software master numbers on > + this STM device. > + > +What: /sys/class/stm/<stm>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> > +Description: > + Shows the number of channels per master on this STM device. > diff --git a/Documentation/ABI/testing/sysfs-class-stm_source b/Documentation/ABI/testing/sysfs-class-stm_source > new file mode 100644 > index 0000000000..57b8dd39bb > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm_source > @@ -0,0 +1,11 @@ > +What: /sys/class/stm_source/<stm_source>/stm_source_link > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin@linux.intel.com> > +Description: > + stm_source device linkage to stm device, where its tracing data > + is directed. Reads return an existing connection or "<none>" if > + this stm_source is not connected to any stm device yet. > + Write an existing (registered) stm device's name here to > + connect that device. If a device is already connected to this > + stm_source, it will first be disconnected. > diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt > index 611c52267d..7fa29b4ece 100644 > --- a/Documentation/ioctl/ioctl-number.txt > +++ b/Documentation/ioctl/ioctl-number.txt > @@ -81,6 +81,9 @@ Code Seq#(hex) Include File Comments > 0x22 all scsi/sg.h > '#' 00-3F IEEE 1394 Subsystem Block for the entire subsystem > '$' 00-0F linux/perf_counter.h, linux/perf_event.h > +'%' 00-0F include/uapi/linux/stm.h > + System Trace Module subsystem > + <mailto:alexander.shishkin@linux.intel.com> > '&' 00-07 drivers/firewire/nosy-user.h > '1' 00-1F <linux/timepps.h> PPS kit from Ulrich Windl > <ftp://ftp.de.kernel.org/pub/linux/daemons/ntp/PPS/> > diff --git a/Documentation/trace/stm.txt b/Documentation/trace/stm.txt > new file mode 100644 > index 0000000000..e140f2e8d7 > --- /dev/null > +++ b/Documentation/trace/stm.txt > @@ -0,0 +1,80 @@ > +System Trace Module > +=================== > + > +System Trace Module (STM) is a device described in MIPI STP specs as > +STP trace stream generator. STP (System Trace Protocol) is a trace > +protocol multiplexing data from multiple trace sources, each one of > +which is assigned a unique pair of master and channel. While some of > +these masters and channels are statically allocated to certain > +hardware trace sources, others are available to software. Software > +trace sources are usually free to pick for themselves any > +master/channel combination from this pool. > + > +On the receiving end of this STP stream (the decoder side), trace > +sources can only be identified by master/channel combination, so in > +order for the decoder to be able to make sense of the trace that > +involves multiple trace sources, it needs to be able to map those > +master/channel pairs to the trace sources that it understands. > + > +For instance, it is helpful to know that syslog messages come on > +master 7 channel 15, while arbitrary user applications can use masters > +48 to 63 and channels 0 to 127. > + > +To solve this mapping problem, stm class provides a policy management > +mechanism via configfs, that allows defining rules that map string > +identifiers to ranges of masters and channels. If these rules (policy) > +are consistent with what decoder expects, it will be able to properly > +process the trace data. > + > +This policy is a tree structure containing rules (policy_node) that > +have a name (string identifier) and a range of masters and channels > +associated with it, located in "stp-policy" subsystem directory in > +configfs. The topmost directory's name (the policy) is formatted as > +the STM device name to which this policy applies and and arbitrary > +string identifier separated by a stop. From the examle above, a rule > +may look like this: > + > +$ ls /config/stp-policy/dummy_stm.my-policy/user > +channels masters > +$ cat /config/stp-policy/dummy_stm.my-policy/user/masters > +48 63 > +$ cat /config/stp-policy/dummy_stm.my-policy/user/channels > +0 127 > + > +which means that the master allocation pool for this rule consists of > +masters 48 through 63 and channel allocation pool has channels 0 > +through 127 in it. Now, any producer (trace source) identifying itself > +with "user" identification string will be allocated a master and > +channel from within these ranges. > + > +These rules can be nested, for example, one can define a rule "dummy" > +under "user" directory from the example above and this new rule will > +be used for trace sources with the id string of "user/dummy". > + > +Trace sources have to open the stm class device's node and write their > +trace data into its file descriptor. In order to identify themselves > +to the policy, they need to do a STP_POLICY_ID_SET ioctl on this file > +descriptor providing their id string. Otherwise, they will be > +automatically allocated a master/channel pair upon first write to this > +file descriptor according to the "default" rule of the policy, if such > +exists. > + > +Some STM devices may allow direct mapping of the channel mmio regions > +to userspace for zero-copy writing. One mappable page (in terms of > +mmu) will usually contain multiple channels' mmios, so the user will > +need to allocate that many channels to themselves (via the > +aforementioned ioctl() call) to be able to do this. That is, if your > +stm device's channel mmio region is 64 bytes and hardware page size is > +4096 bytes, after a successful STP_POLICY_ID_SET ioctl() call with > +width==64, you should be able to mmap() one page on this file > +descriptor and obtain direct access to an mmio region for 64 channels. > + > +For kernel-based trace sources, there is "stm_source" device > +class. Devices of this class can be connected and disconnected to/from > +stm devices at runtime via a sysfs attribute. > + > +Examples of STM devices are Intel Trace Hub [1] and Coresight STM > +[2]. > + > +[1] https://software.intel.com/sites/default/files/managed/d3/3c/intel-th-developer-manual.pdf > +[2] http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0444b/index.html > diff --git a/drivers/Kconfig b/drivers/Kconfig > index 6e973b8e3a..96efe4522c 100644 > --- a/drivers/Kconfig > +++ b/drivers/Kconfig > @@ -184,4 +184,6 @@ source "drivers/android/Kconfig" > > source "drivers/nvdimm/Kconfig" > > +source "drivers/hwtracing/stm/Kconfig" > + > endmenu > diff --git a/drivers/Makefile b/drivers/Makefile > index b64b49f6e0..6647bc923f 100644 > --- a/drivers/Makefile > +++ b/drivers/Makefile > @@ -164,4 +164,5 @@ obj-$(CONFIG_MCB) += mcb/ > obj-$(CONFIG_RAS) += ras/ > obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ > obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ > +obj-$(CONFIG_STM) += hwtracing/stm/ > obj-$(CONFIG_ANDROID) += android/ > diff --git a/drivers/hwtracing/stm/Kconfig b/drivers/hwtracing/stm/Kconfig > new file mode 100644 > index 0000000000..90ed327461 > --- /dev/null > +++ b/drivers/hwtracing/stm/Kconfig > @@ -0,0 +1,8 @@ > +config STM > + tristate "System Trace Module devices" > + help > + A System Trace Module (STM) is a device exporting data in System > + Trace Protocol (STP) format as defined by MIPI STP standards. > + Examples of such devices are Intel Trace Hub and Coresight STM. > + > + Say Y here to enable System Trace Module device support. > diff --git a/drivers/hwtracing/stm/Makefile b/drivers/hwtracing/stm/Makefile > new file mode 100644 > index 0000000000..adec701649 > --- /dev/null > +++ b/drivers/hwtracing/stm/Makefile > @@ -0,0 +1,3 @@ > +obj-$(CONFIG_STM) += stm_core.o > + > +stm_core-y := core.o policy.o > diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c > new file mode 100644 > index 0000000000..b79c42c625 > --- /dev/null > +++ b/drivers/hwtracing/stm/core.c > @@ -0,0 +1,1029 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#include <linux/uaccess.h> > +#include <linux/kernel.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/compat.h> > +#include <linux/kdev_t.h> > +#include <linux/srcu.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include <linux/fs.h> > +#include <linux/mm.h> > +#include "stm.h" > + > +#include <uapi/linux/stm.h> > + > +static unsigned int stm_core_up; > + > +/* > + * The SRCU here makes sure that STM device doesn't disappear from under a > + * stm_source_write() caller, which may want to have as little overhead as > + * possible. > + */ > +static struct srcu_struct stm_source_srcu; > + > +static ssize_t masters_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(masters); > + > +static ssize_t channels_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u\n", stm->data->sw_nchannels); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(channels); > + > +static struct attribute *stm_attrs[] = { > + &dev_attr_masters.attr, > + &dev_attr_channels.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm); > + > +static struct class stm_class = { > + .name = "stm", > + .dev_groups = stm_groups, > +}; > + > +static int stm_dev_match(struct device *dev, const void *data) > +{ > + const char *name = data; > + > + return sysfs_streq(name, dev_name(dev)); > +} > + > +/** > + * stm_find_device() - find stm device by name > + * @buf: character buffer containing the name > + * > + * This is called when either policy gets assigned to an stm device or an > + * stm_source device gets linked to an stm device. > + * > + * This grabs device's reference (get_device()) and module reference, both > + * of which the calling path needs to make sure to drop with stm_put_device(). > + * > + * Return: stm device pointer or null if lookup failed. > + */ > +struct stm_device *stm_find_device(const char *buf) > +{ > + struct stm_device *stm; > + struct device *dev; > + > + if (!stm_core_up) > + return NULL; > + > + dev = class_find_device(&stm_class, NULL, buf, stm_dev_match); > + if (!dev) > + return NULL; > + > + stm = to_stm_device(dev); > + if (!try_module_get(stm->owner)) { > + put_device(dev); > + return NULL; > + } > + > + return stm; > +} > + > +/** > + * stm_put_device() - drop references on the stm device > + * @stm: stm device, previously acquired by stm_find_device() > + * > + * This drops the module reference and device reference taken by > + * stm_find_device(). > + */ > +void stm_put_device(struct stm_device *stm) > +{ > + module_put(stm->owner); > + put_device(&stm->dev); > +} > + > +/* > + * Internally we only care about software-writable masters here, that is the > + * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need > + * original master numbers to be visible externally, since they are the ones > + * that will appear in the STP stream. Thus, the internal bookkeeping uses > + * $master - stm_data->sw_start to reference master descriptors and such. > + */ > + > +#define __stm_master(_s, _m) \ > + ((_s)->masters[(_m) - (_s)->data->sw_start]) > + > +static inline struct stp_master * > +stm_master(struct stm_device *stm, unsigned int idx) > +{ > + if (idx < stm->data->sw_start || idx > stm->data->sw_end) > + return NULL; > + > + return __stm_master(stm, idx); > +} > + > +static int stp_master_alloc(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master; > + size_t size; > + > + size = ALIGN(stm->data->sw_nchannels, 8) / 8; > + size += sizeof(struct stp_master); > + master = kzalloc(size, GFP_ATOMIC); > + if (!master) > + return -ENOMEM; > + > + master->nr_free = stm->data->sw_nchannels; > + __stm_master(stm, idx) = master; > + > + return 0; > +} > + > +static void stp_master_free(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master = stm_master(stm, idx); > + > + if (!master) > + return; > + > + __stm_master(stm, idx) = NULL; > + kfree(master); > +} > + > +static void stm_output_claim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + if (WARN_ON_ONCE(master->nr_free < output->nr_chans)) > + return; > + > + bitmap_allocate_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + master->nr_free -= output->nr_chans; > +} > + > +static void > +stm_output_disclaim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + bitmap_release_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + output->nr_chans = 0; > + master->nr_free += output->nr_chans; > +} > + > +/* > + * This is like bitmap_find_free_region(), except it can ignore @start bits > + * at the beginning. > + */ > +static int find_free_channels(unsigned long *bitmap, unsigned int start, > + unsigned int end, unsigned int width) > +{ > + unsigned int pos; > + int i; > + > + for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) { > + pos = find_next_zero_bit(bitmap, end + 1, pos); > + if (pos + width > end + 1) > + break; > + > + if (pos & (width - 1)) > + continue; > + > + for (i = 1; i < width && !test_bit(pos + i, bitmap); i++) > + ; > + if (i == width) > + return pos; > + } > + > + return -1; > +} > + > +static unsigned int > +stm_find_master_chan(struct stm_device *stm, unsigned int width, > + unsigned int *mstart, unsigned int mend, > + unsigned int *cstart, unsigned int cend) > +{ > + struct stp_master *master; > + unsigned int midx; > + int pos, err; > + > + for (midx = *mstart; midx <= mend; midx++) { > + if (!stm_master(stm, midx)) { > + err = stp_master_alloc(stm, midx); > + if (err) > + return err; > + } > + > + master = stm_master(stm, midx); > + > + if (!master->nr_free) > + continue; > + > + pos = find_free_channels(master->chan_map, *cstart, cend, > + width); > + if (pos < 0) > + continue; > + > + *mstart = midx; > + *cstart = pos; > + return 0; > + } > + > + return -ENOSPC; > +} > + > +static int stm_output_assign(struct stm_device *stm, unsigned int width, > + struct stp_policy_node *policy_node, > + struct stm_output *output) > +{ > + unsigned int midx, cidx, mend, cend; > + int ret = -EINVAL; > + > + if (width > stm->data->sw_nchannels) > + return -EINVAL; > + > + if (policy_node) { > + stp_policy_node_get_ranges(policy_node, > + &midx, &mend, &cidx, &cend); > + } else { > + midx = stm->data->sw_start; > + cidx = 0; > + mend = stm->data->sw_end; > + cend = stm->data->sw_nchannels - 1; > + } > + > + spin_lock(&stm->mc_lock); > + /* output is already assigned -- shouldn't happen */ > + if (WARN_ON_ONCE(output->nr_chans)) > + goto unlock; > + > + ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend); > + if (ret) > + goto unlock; > + > + output->master = midx; > + output->channel = cidx; > + output->nr_chans = width; > + stm_output_claim(stm, output); > + dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width); > + > + ret = 0; > +unlock: > + spin_unlock(&stm->mc_lock); > + > + return ret; > +} > + > +static void stm_output_free(struct stm_device *stm, struct stm_output *output) > +{ > + spin_lock(&stm->mc_lock); > + if (output->nr_chans) > + stm_output_disclaim(stm, output); > + spin_unlock(&stm->mc_lock); > +} > + > +static int major_match(struct device *dev, const void *data) > +{ > + unsigned int major = *(unsigned int *)data; > + > + return MAJOR(dev->devt) == major; > +} > + > +static int stm_char_open(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf; > + struct device *dev; > + unsigned int major = imajor(inode); > + int err = -ENODEV; > + > + dev = class_find_device(&stm_class, NULL, &major, major_match); > + if (!dev) > + return -ENODEV; > + > + stmf = kzalloc(sizeof(*stmf), GFP_KERNEL); > + if (!stmf) > + return -ENOMEM; > + > + stmf->stm = to_stm_device(dev); > + > + if (!try_module_get(stmf->stm->owner)) > + goto err_free; > + > + file->private_data = stmf; > + > + return nonseekable_open(inode, file); > + > +err_free: > + kfree(stmf); > + > + return err; > +} > + > +static int stm_char_release(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf = file->private_data; > + > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + kfree(stmf); > + > + return 0; > +} > + > +static int stm_file_assign(struct stm_file *stmf, char *id, unsigned int width) > +{ > + struct stm_device *stm = stmf->stm; > + int ret; > + > + stmf->policy_node = stp_policy_node_lookup(stm, id); > + > + ret = stm_output_assign(stm, width, stmf->policy_node, &stmf->output); > + > + if (stmf->policy_node) > + stp_policy_node_put(stmf->policy_node); > + > + return ret; > +} > + > +static void stm_write(struct stm_data *data, unsigned int master, > + unsigned int channel, const char *buf, size_t count) > +{ > + unsigned int flags = STP_PACKET_TIMESTAMPED; > + const unsigned char *p = buf, nil = 0; > + size_t pos; > + ssize_t sz; > + > + for (pos = 0, p = buf; count > pos; pos += sz, p += sz) { > + sz = min_t(unsigned int, count - pos, 8); > + sz = data->packet(data, master, channel, STP_PACKET_DATA, flags, > + sz, p); > + flags = 0; > + } > + > + data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil); > +} > + > +static ssize_t stm_char_write(struct file *file, const char __user *buf, > + size_t count, loff_t *ppos) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + char *kbuf; > + int err; > + > + /* > + * if no m/c have been assigned to this writer up to this > + * point, use "default" policy entry > + */ > + if (!stmf->output.nr_chans) { > + err = stm_file_assign(stmf, "default", 1); > + /* > + * EBUSY means that somebody else just assigned this > + * output, which is just fine for write() > + */ > + if (err && err != -EBUSY) > + return err; > + } > + > + kbuf = kmalloc(count + 1, GFP_KERNEL); > + if (!kbuf) > + return -ENOMEM; > + > + err = copy_from_user(kbuf, buf, count); > + if (err) { > + kfree(kbuf); > + return -EFAULT; > + } > + > + stm_write(stm->data, stmf->output.master, stmf->output.channel, kbuf, > + count); > + > + kfree(kbuf); > + > + return count; > +} > + > +static int stm_char_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + unsigned long size, phys; > + > + if (!stm->data->mmio_addr) > + return -EOPNOTSUPP; > + > + if (vma->vm_pgoff) > + return -EINVAL; > + > + size = vma->vm_end - vma->vm_start; > + > + if (stmf->output.nr_chans * stm->data->sw_mmiosz != size) > + return -EINVAL; > + > + phys = stm->data->mmio_addr(stm->data, stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans); > + > + if (!phys) > + return -EINVAL; > + > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP; > + vm_iomap_memory(vma, phys, size); > + > + return 0; > +} > + > +static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stm_device *stm = stmf->stm; > + struct stp_policy_id *id; > + int ret = -EINVAL; > + u32 size; > + > + if (stmf->output.nr_chans) > + return -EBUSY; > + > + if (copy_from_user(&size, arg, sizeof(size))) > + return -EFAULT; > + > + if (size >= PATH_MAX + sizeof(*id)) > + return -EINVAL; > + > + /* > + * size + 1 to make sure the .id string at the bottom is terminated, > + * which is also why memdup_user() is not useful here > + */ > + id = kzalloc(size + 1, GFP_KERNEL); > + if (!id) > + return -ENOMEM; > + > + if (copy_from_user(id, arg, size)) { > + ret = -EFAULT; > + goto err_free; > + } > + > + if (id->__reserved_0 || id->__reserved_1) > + goto err_free; > + > + if (id->width < 1 || > + id->width > PAGE_SIZE / stm->data->sw_mmiosz) > + goto err_free; > + > + ret = stm_file_assign(stmf, id->id, id->width); > + if (ret) > + goto err_free; > + > + ret = 0; > + > + if (stm->data->link) > + ret = stm->data->link(stm->data, stmf->output.master, > + stmf->output.channel); > + > + if (ret) { > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + } > + > +err_free: > + kfree(id); > + > + return ret; > +} > + > +static int stm_char_policy_get_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stp_policy_id id = { > + .size = sizeof(id), > + .master = stmf->output.master, > + .channel = stmf->output.channel, > + .width = stmf->output.nr_chans, > + .__reserved_0 = 0, > + .__reserved_1 = 0, > + }; > + > + return copy_to_user(arg, &id, id.size) ? -EFAULT : 0; > +} > + > +static long > +stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_data *stm_data = stmf->stm->data; > + int err = -ENOTTY; > + u64 options; > + > + switch (cmd) { > + case STP_POLICY_ID_SET: > + err = stm_char_policy_set_ioctl(stmf, (void __user *)arg); > + if (err) > + return err; > + > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_POLICY_ID_GET: > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_SET_OPTIONS: > + if (copy_from_user(&options, (u64 __user *)arg, sizeof(u64))) > + return -EFAULT; > + > + if (stm_data->set_options) > + err = stm_data->set_options(stm_data, > + stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans, > + options); > + > + break; > + default: > + break; > + } > + > + return err; > +} > + > +#ifdef CONFIG_COMPAT > +static long > +stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); > +} > +#else > +#define stm_char_compat_ioctl NULL > +#endif > + > +static const struct file_operations stm_fops = { > + .open = stm_char_open, > + .release = stm_char_release, > + .write = stm_char_write, > + .mmap = stm_char_mmap, > + .unlocked_ioctl = stm_char_ioctl, > + .compat_ioctl = stm_char_compat_ioctl, > + .llseek = no_llseek, > +}; > + > +static void stm_device_release(struct device *dev) > +{ > + struct stm_device *stm = to_stm_device(dev); > + > + kfree(stm); > +} > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner) > +{ > + struct stm_device *stm; > + unsigned int nmasters; > + int err = -ENOMEM; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + > + if (!stm_data->packet || !stm_data->sw_nchannels) > + return -EINVAL; > + > + nmasters = stm_data->sw_end - stm_data->sw_start; > + stm = kzalloc(sizeof(*stm) + nmasters * sizeof(void *), GFP_KERNEL); > + if (!stm) > + return -ENOMEM; > + > + stm->major = register_chrdev(0, stm_data->name, &stm_fops); > + if (stm->major < 0) > + goto err_free; > + > + device_initialize(&stm->dev); > + stm->dev.devt = MKDEV(stm->major, 0); > + stm->dev.class = &stm_class; > + stm->dev.parent = parent; > + stm->dev.release = stm_device_release; > + > + err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name); > + if (err) > + goto err_device; > + > + err = device_add(&stm->dev); > + if (err) > + goto err_device; > + > + spin_lock_init(&stm->link_lock); > + INIT_LIST_HEAD(&stm->link_list); > + > + spin_lock_init(&stm->mc_lock); > + mutex_init(&stm->policy_mutex); > + stm->sw_nmasters = nmasters; > + stm->owner = owner; > + stm->data = stm_data; > + stm_data->stm = stm; > + > + return 0; > + > +err_device: > + put_device(&stm->dev); > +err_free: > + kfree(stm); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_register_device); > + > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm); > + > +void stm_unregister_device(struct stm_data *stm_data) > +{ > + struct stm_device *stm = stm_data->stm; > + struct stm_source_device *src, *iter; > + int i; > + > + spin_lock(&stm->link_lock); > + list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) { > + __stm_source_link_drop(src, stm); > + } > + spin_unlock(&stm->link_lock); > + > + synchronize_srcu(&stm_source_srcu); > + > + unregister_chrdev(stm->major, stm_data->name); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + stp_policy_unbind(stm->policy); > + mutex_unlock(&stm->policy_mutex); > + > + for (i = 0; i < stm->sw_nmasters; i++) > + stp_master_free(stm, i); > + > + device_unregister(&stm->dev); > + stm_data->stm = NULL; > +} > +EXPORT_SYMBOL_GPL(stm_unregister_device); > + > +/** > + * stm_source_link_add() - connect an stm_source device to an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * This function establishes a link from stm_source to an stm device so that > + * the former can send out trace data to the latter. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +static int stm_source_link_add(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + char *id; > + int err; > + > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + /* src->link is dereferenced under stm_source_srcu but not the list */ > + rcu_assign_pointer(src->link, stm); > + list_add_tail(&src->link_entry, &stm->link_list); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + id = kstrdup(src->data->name, GFP_KERNEL); > + if (id) { > + src->policy_node = > + stp_policy_node_lookup(stm, id); > + > + kfree(id); > + } > + > + err = stm_output_assign(stm, src->data->nr_chans, > + src->policy_node, &src->output); > + > + if (src->policy_node) > + stp_policy_node_put(src->policy_node); > + > + if (err) > + goto fail_detach; > + > + /* this is to notify the STM device that a new link has been made */ > + if (stm->data->link) > + err = stm->data->link(stm->data, src->output.master, > + src->output.channel); > + > + if (err) > + goto fail_free_output; > + > + /* this is to let the source carry out all necessary preparations */ > + if (src->data->link) > + src->data->link(src->data); > + > + return 0; > + > +fail_free_output: > + stm_output_free(stm, &src->output); > + stm_put_device(stm); > + > +fail_detach: > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + rcu_assign_pointer(src->link, NULL); > + list_del_init(&src->link_entry); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + return err; > +} > + > +/** > + * __stm_source_link_drop() - detach stm_source from an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * If @stm is @src::link, disconnect them from one another and put the > + * reference on the @stm device. > + * > + * Caller must hold stm::link_lock. > + */ > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + spin_lock(&src->link_lock); > + if (WARN_ON_ONCE(src->link != stm)) { > + spin_unlock(&src->link_lock); > + return; > + } > + > + stm_output_free(src->link, &src->output); > + /* caller must hold stm::link_lock */ > + list_del_init(&src->link_entry); > + /* matches stm_find_device() from stm_source_link_store() */ > + stm_put_device(src->link); > + rcu_assign_pointer(src->link, NULL); > + > + spin_unlock(&src->link_lock); > +} > + > +/** > + * stm_source_link_drop() - detach stm_source from its stm device > + * @src: stm_source device > + * > + * Unlinking means disconnecting from source's STM device; after this > + * writes will be unsuccessful until it is linked to a new STM device. > + * > + * This will happen on "stm_source_link" sysfs attribute write to undo > + * the existing link (if any), or on linked STM device's de-registration. > + */ > +static void stm_source_link_drop(struct stm_source_device *src) > +{ > + struct stm_device *stm; > + int idx; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + > + if (stm) { > + if (src->data->unlink) > + src->data->unlink(src->data); > + > + spin_lock(&stm->link_lock); > + __stm_source_link_drop(src, stm); > + spin_unlock(&stm->link_lock); > + } > + > + srcu_read_unlock(&stm_source_srcu, idx); > +} > + > +static ssize_t stm_source_link_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *stm; > + int idx, ret; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + ret = sprintf(buf, "%s\n", > + stm ? dev_name(&stm->dev) : "<none>"); > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return ret; > +} > + > +static ssize_t stm_source_link_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *link; > + int err; > + > + stm_source_link_drop(src); > + > + link = stm_find_device(buf); > + if (!link) > + return -EINVAL; > + > + err = stm_source_link_add(src, link); > + if (err) > + stm_put_device(link); > + > + return err ? : count; > +} > + > +static DEVICE_ATTR_RW(stm_source_link); > + > +static struct attribute *stm_source_attrs[] = { > + &dev_attr_stm_source_link.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm_source); > + > +static struct class stm_source_class = { > + .name = "stm_source", > + .dev_groups = stm_source_groups, > +}; > + > +static void stm_source_device_release(struct device *dev) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + > + kfree(src); > +} > + > +/** > + * stm_source_register_device() - register an stm_source device > + * @parent: parent device > + * @data: device description structure > + * > + * This will create a device of stm_source class that can write > + * data to an stm device once linked. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data) > +{ > + struct stm_source_device *src; > + int err; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + > + src = kzalloc(sizeof(*src), GFP_KERNEL); > + if (!src) > + return -ENOMEM; > + > + device_initialize(&src->dev); > + src->dev.class = &stm_source_class; > + src->dev.parent = parent; > + src->dev.release = stm_source_device_release; > + > + err = kobject_set_name(&src->dev.kobj, "%s", data->name); > + if (err) > + goto err; > + > + err = device_add(&src->dev); > + if (err) > + goto err; > + > + spin_lock_init(&src->link_lock); > + INIT_LIST_HEAD(&src->link_entry); > + src->data = data; > + data->src = src; > + > + return 0; > + > +err: > + put_device(&src->dev); > + kfree(src); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_source_register_device); > + > +/** > + * stm_source_unregister_device() - unregister an stm_source device > + * @data: device description that was used to register the device > + * > + * This will remove a previously created stm_source device from the system. > + */ > +void stm_source_unregister_device(struct stm_source_data *data) > +{ > + struct stm_source_device *src = data->src; > + > + stm_source_link_drop(src); > + > + device_destroy(&stm_source_class, src->dev.devt); > +} > +EXPORT_SYMBOL_GPL(stm_source_unregister_device); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = data->src; > + struct stm_device *stm; > + int idx; > + > + if (!src->output.nr_chans) > + return -ENODEV; > + > + if (chan >= src->output.nr_chans) > + return -EINVAL; > + > + idx = srcu_read_lock(&stm_source_srcu); > + > + stm = srcu_dereference(src->link, &stm_source_srcu); > + if (stm) > + stm_write(stm->data, src->output.master, > + src->output.channel + chan, > + buf, count); > + else > + count = -ENODEV; > + > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return count; > +} > +EXPORT_SYMBOL_GPL(stm_source_write); > + > +static int __init stm_core_init(void) > +{ > + int err; > + > + err = class_register(&stm_class); > + if (err) > + return err; > + > + err = class_register(&stm_source_class); > + if (err) > + goto err_stm; > + > + err = stp_configfs_init(); > + if (err) > + goto err_src; > + > + init_srcu_struct(&stm_source_srcu); > + > + stm_core_up++; > + > + return 0; > + > +err_src: > + class_unregister(&stm_source_class); > +err_stm: > + class_unregister(&stm_class); > + > + return err; > +} > + > +module_init(stm_core_init); > + > +static void __exit stm_core_exit(void) > +{ > + cleanup_srcu_struct(&stm_source_srcu); > + class_unregister(&stm_source_class); > + class_unregister(&stm_class); > + stp_configfs_exit(); > +} > + > +module_exit(stm_core_exit); > + > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("System Trace Module device class"); > +MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>"); > diff --git a/drivers/hwtracing/stm/policy.c b/drivers/hwtracing/stm/policy.c > new file mode 100644 > index 0000000000..6498a9dbb7 > --- /dev/null > +++ b/drivers/hwtracing/stm/policy.c > @@ -0,0 +1,529 @@ > +/* > + * System Trace Module (STM) master/channel allocation policy management > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * A master/channel allocation policy allows mapping string identifiers to > + * master and channel ranges, where allocation can be done. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/types.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/configfs.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include "stm.h" > + > +/* > + * STP Master/Channel allocation policy configfs layout. > + */ > + > +struct stp_policy { > + struct config_group group; > + struct stm_device *stm; > +}; > + > +struct stp_policy_node { > + struct config_group group; > + struct stp_policy *policy; > + unsigned int first_master; > + unsigned int last_master; > + unsigned int first_channel; > + unsigned int last_channel; > +}; > + > +static struct configfs_subsystem stp_policy_subsys; > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend) > +{ > + *mstart = policy_node->first_master; > + *mend = policy_node->last_master; > + *cstart = policy_node->first_channel; > + *cend = policy_node->last_channel; > +} > + > +static inline char *stp_policy_node_name(struct stp_policy_node *policy_node) > +{ > + return policy_node->group.cg_item.ci_name ? : "<none>"; > +} > + > +static inline struct stp_policy *to_stp_policy(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy, group) : > + NULL; > +} > + > +static inline struct stp_policy_node * > +to_stp_policy_node(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy_node, > + group) : > + NULL; > +} > + > +static ssize_t stp_policy_node_masters_show(struct stp_policy_node *policy_node, > + char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_master, > + policy_node->last_master); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_masters_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + /* must be within [sw_start..sw_end], which is an inclusive range */ > + if (first > INT_MAX || last > INT_MAX || first > last || > + first < stm->data->sw_start || > + last > stm->data->sw_end) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_master = first; > + policy_node->last_master = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static ssize_t > +stp_policy_node_channels_show(struct stp_policy_node *policy_node, char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_channel, > + policy_node->last_channel); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_channels_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + if (first > INT_MAX || last > INT_MAX || first > last || > + last >= stm->data->sw_nchannels) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_channel = first; > + policy_node->last_channel = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static void stp_policy_node_release(struct config_item *item) > +{ > + kfree(to_stp_policy_node(item)); > +} > + > +struct stp_policy_node_attribute { > + struct configfs_attribute attr; > + ssize_t (*show)(struct stp_policy_node *, char *); > + ssize_t (*store)(struct stp_policy_node *, const char *, size_t); > +}; > + > +static ssize_t stp_policy_node_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = 0; > + > + if (pn_attr->show) > + count = pn_attr->show(policy_node, page); > + > + return count; > +} > + > +static ssize_t stp_policy_node_attr_store(struct config_item *item, > + struct configfs_attribute *attr, > + const char *page, size_t len) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = -EINVAL; > + > + if (pn_attr->store) > + count = pn_attr->store(policy_node, page, len); > + > + return count; > +} > + > +static struct configfs_item_operations stp_policy_node_item_ops = { > + .release = stp_policy_node_release, > + .show_attribute = stp_policy_node_attr_show, > + .store_attribute = stp_policy_node_attr_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_range = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "masters", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_masters_show, > + .store = stp_policy_node_masters_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_channels = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "channels", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_channels_show, > + .store = stp_policy_node_channels_store, > +}; > + > +static struct configfs_attribute *stp_policy_node_attrs[] = { > + &stp_policy_node_attr_range.attr, > + &stp_policy_node_attr_channels.attr, > + NULL, > +}; > + > +static struct config_item_type stp_policy_type; > +static struct config_item_type stp_policy_node_type; > + > +static struct config_group * > +stp_policy_node_make(struct config_group *group, const char *name) > +{ > + struct stp_policy_node *policy_node, *parent_node; > + struct stp_policy *policy; > + > + if (group->cg_item.ci_type == &stp_policy_type) { > + policy = container_of(group, struct stp_policy, group); > + } else { > + parent_node = container_of(group, struct stp_policy_node, > + group); > + policy = parent_node->policy; > + } > + > + if (!policy->stm) > + return ERR_PTR(-ENODEV); > + > + policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL); > + if (!policy_node) > + return ERR_PTR(-ENOMEM); > + > + config_group_init_type_name(&policy_node->group, name, > + &stp_policy_node_type); > + > + policy_node->policy = policy; > + > + /* default values for the attributes */ > + policy_node->first_master = policy->stm->data->sw_start; > + policy_node->last_master = policy->stm->data->sw_end; > + policy_node->first_channel = 0; > + policy_node->last_channel = policy->stm->data->sw_nchannels - 1; > + > + return &policy_node->group; > +} > + > +static void > +stp_policy_node_drop(struct config_group *group, struct config_item *item) > +{ > + config_item_put(item); > +} > + > +static struct configfs_group_operations stp_policy_node_group_ops = { > + .make_group = stp_policy_node_make, > + .drop_item = stp_policy_node_drop, > +}; > + > +static struct config_item_type stp_policy_node_type = { > + .ct_item_ops = &stp_policy_node_item_ops, > + .ct_group_ops = &stp_policy_node_group_ops, > + .ct_attrs = stp_policy_node_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +/* > + * Root group: policies. > + */ > +static struct configfs_attribute stp_policy_attr_device = { > + .ca_owner = THIS_MODULE, > + .ca_name = "device", > + .ca_mode = S_IRUGO, > +}; > + > +static struct configfs_attribute *stp_policy_attrs[] = { > + &stp_policy_attr_device, > + NULL, > +}; > + > +static ssize_t stp_policy_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + ssize_t count; > + > + count = sprintf(page, "%s\n", > + (policy && policy->stm) ? > + policy->stm->data->name : > + "<none>"); > + > + return count; > +} > + > +void stp_policy_unbind(struct stp_policy *policy) > +{ > + struct stm_device *stm = policy->stm; > + > + if (WARN_ON_ONCE(!policy->stm)) > + return; > + > + mutex_lock(&stm->policy_mutex); > + stm->policy = NULL; > + mutex_unlock(&stm->policy_mutex); > + > + policy->stm = NULL; > + > + stm_put_device(stm); > +} > + > +static void stp_policy_release(struct config_item *item) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + > + stp_policy_unbind(policy); > + kfree(policy); > +} > + > +static struct configfs_item_operations stp_policy_item_ops = { > + .release = stp_policy_release, > + .show_attribute = stp_policy_attr_show, > +}; > + > +static struct configfs_group_operations stp_policy_group_ops = { > + .make_group = stp_policy_node_make, > +}; > + > +static struct config_item_type stp_policy_type = { > + .ct_item_ops = &stp_policy_item_ops, > + .ct_group_ops = &stp_policy_group_ops, > + .ct_attrs = stp_policy_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct config_group * > +stp_policies_make(struct config_group *group, const char *name) > +{ > + struct config_group *ret; > + struct stm_device *stm; > + char *devname, *p; > + > + devname = kasprintf(GFP_KERNEL, "%s", name); > + if (!devname) > + return ERR_PTR(-ENOMEM); > + > + /* > + * node must look like <device_name>.<policy_name>, where > + * <device_name> is the name of an existing stm device and > + * <policy_name> is an arbitrary string > + */ > + p = strchr(devname, '.'); > + if (!p) { > + kfree(devname); > + return ERR_PTR(-EINVAL); > + } > + > + *p++ = '\0'; > + > + stm = stm_find_device(devname); > + kfree(devname); > + > + if (!stm) > + return ERR_PTR(-ENODEV); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) { > + ret = ERR_PTR(-EBUSY); > + goto unlock_policy; > + } > + > + stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); > + if (!stm->policy) { > + ret = ERR_PTR(-ENOMEM); > + goto unlock_policy; > + } > + > + config_group_init_type_name(&stm->policy->group, name, > + &stp_policy_type); > + stm->policy->stm = stm; > + > + ret = &stm->policy->group; > + > +unlock_policy: > + mutex_unlock(&stm->policy_mutex); > + > + if (IS_ERR(ret)) > + stm_put_device(stm); > + > + return ret; > +} > + > +static struct configfs_group_operations stp_policies_group_ops = { > + .make_group = stp_policies_make, > +}; > + > +static struct config_item_type stp_policies_type = { > + .ct_group_ops = &stp_policies_group_ops, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct configfs_subsystem stp_policy_subsys = { > + .su_group = { > + .cg_item = { > + .ci_namebuf = "stp-policy", > + .ci_type = &stp_policies_type, > + }, > + }, > +}; > + > +/* > + * Lock the policy mutex from the outside > + */ > +static struct stp_policy_node * > +__stp_policy_node_lookup(struct stp_policy *policy, char *s) > +{ > + struct stp_policy_node *policy_node, *ret; > + struct list_head *head = &policy->group.cg_children; > + struct config_item *item; > + char *start, *end = s; > + > + if (list_empty(head)) > + return NULL; > + > + /* return the first entry if everything else fails */ > + item = list_entry(head->next, struct config_item, ci_entry); > + ret = to_stp_policy_node(item); > + > +next: > + for (;;) { > + start = strsep(&end, "/"); > + if (!start) > + break; > + > + if (!*start) > + continue; > + > + list_for_each_entry(item, head, ci_entry) { > + policy_node = to_stp_policy_node(item); > + > + if (!strcmp(start, > + policy_node->group.cg_item.ci_name)) { > + ret = policy_node; > + > + if (!end) > + goto out; > + > + head = &policy_node->group.cg_children; > + goto next; > + } > + } > + break; > + } > + > +out: > + return ret; > +} > + > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s) > +{ > + struct stp_policy_node *policy_node = NULL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + policy_node = __stp_policy_node_lookup(stm->policy, s); > + mutex_unlock(&stm->policy_mutex); > + > + if (policy_node) > + config_item_get(&policy_node->group.cg_item); > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return policy_node; > +} > + > +void stp_policy_node_put(struct stp_policy_node *policy_node) > +{ > + config_item_put(&policy_node->group.cg_item); > +} > + > +int __init stp_configfs_init(void) > +{ > + int err; > + > + config_group_init(&stp_policy_subsys.su_group); > + mutex_init(&stp_policy_subsys.su_mutex); > + err = configfs_register_subsystem(&stp_policy_subsys); > + > + return err; One small suggestion, is it better like this: return configfs_register_subsystem(&stp_policy_subsys); As such, we don't need the local variable "err" any more. > +} > + > +void __exit stp_configfs_exit(void) > +{ > + configfs_unregister_subsystem(&stp_policy_subsys); > +} > diff --git a/drivers/hwtracing/stm/stm.h b/drivers/hwtracing/stm/stm.h > new file mode 100644 > index 0000000000..cf33bf976a > --- /dev/null > +++ b/drivers/hwtracing/stm/stm.h > @@ -0,0 +1,87 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _STM_STM_H_ > +#define _STM_STM_H_ > + > +struct stp_policy; > +struct stp_policy_node; > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s); > +void stp_policy_node_put(struct stp_policy_node *policy_node); > +void stp_policy_unbind(struct stp_policy *policy); > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend); > +int stp_configfs_init(void); > +void stp_configfs_exit(void); > + > +struct stp_master { > + unsigned int nr_free; > + unsigned long chan_map[0]; > +}; > + > +struct stm_device { > + struct device dev; > + struct module *owner; > + struct stp_policy *policy; > + struct mutex policy_mutex; > + int major; > + unsigned int sw_nmasters; > + struct stm_data *data; > + spinlock_t link_lock; > + struct list_head link_list; > + /* master allocation */ > + spinlock_t mc_lock; > + struct stp_master *masters[0]; > +}; > + > +#define to_stm_device(_d) \ > + container_of((_d), struct stm_device, dev) > + > +struct stm_output { > + unsigned int master; > + unsigned int channel; > + unsigned int nr_chans; > +}; > + > +struct stm_file { > + struct stm_device *stm; > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +struct stm_device *stm_find_device(const char *name); > +void stm_put_device(struct stm_device *stm); > + > +struct stm_source_device { > + struct device dev; > + struct stm_source_data *data; > + spinlock_t link_lock; > + struct stm_device *link; > + struct list_head link_entry; > + /* one output per stm_source device */ > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +#define to_stm_source_device(_d) \ > + container_of((_d), struct stm_source_device, dev) > + > +#endif /* _STM_STM_H_ */ > diff --git a/include/linux/stm.h b/include/linux/stm.h > new file mode 100644 > index 0000000000..9d0083d364 > --- /dev/null > +++ b/include/linux/stm.h > @@ -0,0 +1,126 @@ > +/* > + * System Trace Module (STM) infrastructure apis > + * Copyright (C) 2014 Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + */ > + > +#ifndef _STM_H_ > +#define _STM_H_ > + > +#include <linux/device.h> > + > +/** > + * enum stp_packet_type - STP packets that an STM driver sends > + */ > +enum stp_packet_type { > + STP_PACKET_DATA = 0, > + STP_PACKET_FLAG, > + STP_PACKET_USER, > + STP_PACKET_MERR, > + STP_PACKET_GERR, > + STP_PACKET_TRIG, > + STP_PACKET_XSYNC, > +}; > + > +/** > + * enum stp_packet_flags - STP packet modifiers > + */ > +enum stp_packet_flags { > + STP_PACKET_MARKED = 0x1, > + STP_PACKET_TIMESTAMPED = 0x2, > +}; > + > +struct stp_policy; > + > +struct stm_device; > + > +/** > + * struct stm_data - STM device description and callbacks > + * @name: device name > + * @stm: internal structure, only used by stm class code > + * @sw_start: first STP master available to software > + * @sw_end: last STP master available to software > + * @sw_nchannels: number of STP channels per master > + * @sw_mmiosz: size of one channel's IO space, for mmap, optional > + * @packet: callback that sends an STP packet > + * @mmio_addr: mmap callback, optional > + * @link: called when a new stm_source gets linked to us, optional > + * @unlink: likewise for unlinking, again optional > + * @set_options: set device-specific options on a channel > + * > + * Fill out this structure before calling stm_register_device() to create > + * an STM device and stm_unregister_device() to destroy it. It will also be > + * passed back to @packet(), @mmio_addr(), @link(), @unlink() and @set_options() > + * callbacks. > + * > + * Normally, an STM device will have a range of masters available to software > + * and the rest being statically assigned to various hardware trace sources. > + * The former is defined by the the range [@sw_start..@sw_end] of the device > + * description. That is, the lowest master that can be allocated to software > + * writers is @sw_start and data from this writer will appear is @sw_start > + * master in the STP stream. > + */ > +struct stm_data { > + const char *name; > + struct stm_device *stm; > + unsigned int sw_start; > + unsigned int sw_end; > + unsigned int sw_nchannels; > + unsigned int sw_mmiosz; > + ssize_t (*packet)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned int, unsigned int, > + const unsigned char *); > + phys_addr_t (*mmio_addr)(struct stm_data *, unsigned int, > + unsigned int, unsigned int); > + int (*link)(struct stm_data *, unsigned int, > + unsigned int); > + void (*unlink)(struct stm_data *, unsigned int, > + unsigned int); > + long (*set_options)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned long); > +}; > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner); > +void stm_unregister_device(struct stm_data *stm_data); > + > +struct stm_source_device; > + > +/** > + * struct stm_source_data - STM source device description and callbacks > + * @name: device name, will be used for policy lookup > + * @src: internal structure, only used by stm class code > + * @nr_chans: number of channels to allocate > + * @link: called when this source gets linked to an STM device > + * @unlink: called when this source is about to get unlinked from its STM > + * > + * Fill in this structure before calling stm_source_register_device() to > + * register a source device. Also pass it to unregister and write calls. > + */ > +struct stm_source_data { > + const char *name; > + struct stm_source_device *src; > + unsigned int percpu; > + unsigned int nr_chans; > + int (*link)(struct stm_source_data *data); > + void (*unlink)(struct stm_source_data *data); > +}; > + > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data); > +void stm_source_unregister_device(struct stm_source_data *data); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count); > + > +#endif /* _STM_H_ */ > diff --git a/include/uapi/linux/stm.h b/include/uapi/linux/stm.h > new file mode 100644 > index 0000000000..626a8d3f63 > --- /dev/null > +++ b/include/uapi/linux/stm.h > @@ -0,0 +1,50 @@ > +/* > + * System Trace Module (STM) userspace interfaces > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _UAPI_LINUX_STM_H > +#define _UAPI_LINUX_STM_H > + > +#include <linux/types.h> > + > +/** > + * struct stp_policy_id - identification for the STP policy > + * @size: size of the structure including real id[] length > + * @master: assigned master > + * @channel: first assigned channel > + * @width: number of requested channels > + * @id: identification string > + * > + * User must calculate the total size of the structure and put it into > + * @size field, fill out the @id and desired @width. In return, kernel > + * fills out @master, @channel and @width. > + */ > +struct stp_policy_id { > + __u32 size; > + __u16 master; > + __u16 channel; > + __u16 width; > + /* padding */ > + __u16 __reserved_0; > + __u32 __reserved_1; > + char id[0]; > +}; > + > +#define STP_POLICY_ID_SET _IOWR('%', 0, struct stp_policy_id) > +#define STP_POLICY_ID_GET _IOR('%', 1, struct stp_policy_id) > +#define STP_SET_OPTIONS _IOW('%', 2, __u64) > + > +#endif /* _UAPI_LINUX_STM_H */ > -- > 2.1.4 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/ ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices 2015-07-08 12:32 ` Chunyan Zhang @ 2015-07-08 12:49 ` Alexander Shishkin 0 siblings, 0 replies; 16+ messages in thread From: Alexander Shishkin @ 2015-07-08 12:49 UTC (permalink / raw) To: Chunyan Zhang Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, mathieu.poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, linux-api@vger.kernel.org Chunyan Zhang <zhang.lyra@gmail.com> writes: >> +int __init stp_configfs_init(void) >> +{ >> + int err; >> + >> + config_group_init(&stp_policy_subsys.su_group); >> + mutex_init(&stp_policy_subsys.su_mutex); >> + err = configfs_register_subsystem(&stp_policy_subsys); >> + >> + return err; > > One small suggestion, is it better like this: > return configfs_register_subsystem(&stp_policy_subsys); > As such, we don't need the local variable "err" any more. You are right, err doesn't serve any purpose here. Thanks, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> @ 2015-07-29 4:21 ` Chunyan Zhang [not found] ` <CAAfSe-vOgnMXCy6fb8yuQ0O_5x1L1QtCmGjNjH+OtGAg6KJHrg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 2015-08-05 23:01 ` Mathieu Poirier 1 sibling, 1 reply; 16+ messages in thread From: Chunyan Zhang @ 2015-07-29 4:21 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Chunyan Zhang, Mark Brown On Mon, Jul 6, 2015 at 6:08 PM, Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> wrote: > A System Trace Module (STM) is a device exporting data in System Trace > Protocol (STP) format as defined by MIPI STP standards. Examples of such > devices are Intel Trace Hub and Coresight STM. > > This abstraction provides a unified interface for software trace sources > to send their data over an STM device to a debug host. In order to do > that, such a trace source needs to be assigned a pair of master/channel > identifiers that all the data from this source will be tagged with. The > STP decoder on the debug host side will use these master/channel tags to > distinguish different trace streams from one another inside one STP > stream. > > This abstraction provides a configfs-based policy management mechanism > for dynamic allocation of these master/channel pairs based on trace > source-supplied string identifier. It has the flexibility of being > defined at runtime and at the same time (provided that the policy > definition is aligned with the decoding end) consistency. > > For userspace trace sources, this abstraction provides write()-based and > mmap()-based (if the underlying stm device allows this) output mechanism. > > For kernel-side trace sources, we provide "stm_source" device class that > can be connected to an stm device at run time. > > Cc: linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org > Cc: Mathieu Poirier <mathieu.poirier-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org> > Signed-off-by: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > --- > Documentation/ABI/testing/configfs-stp-policy | 48 + > Documentation/ABI/testing/sysfs-class-stm | 14 + > Documentation/ABI/testing/sysfs-class-stm_source | 11 + > Documentation/ioctl/ioctl-number.txt | 3 + > Documentation/trace/stm.txt | 80 ++ > drivers/Kconfig | 2 + > drivers/Makefile | 1 + > drivers/hwtracing/stm/Kconfig | 8 + > drivers/hwtracing/stm/Makefile | 3 + > drivers/hwtracing/stm/core.c | 1029 ++++++++++++++++++++++ > drivers/hwtracing/stm/policy.c | 529 +++++++++++ > drivers/hwtracing/stm/stm.h | 87 ++ > include/linux/stm.h | 126 +++ > include/uapi/linux/stm.h | 50 ++ > 14 files changed, 1991 insertions(+) > create mode 100644 Documentation/ABI/testing/configfs-stp-policy > create mode 100644 Documentation/ABI/testing/sysfs-class-stm > create mode 100644 Documentation/ABI/testing/sysfs-class-stm_source > create mode 100644 Documentation/trace/stm.txt > create mode 100644 drivers/hwtracing/stm/Kconfig > create mode 100644 drivers/hwtracing/stm/Makefile > create mode 100644 drivers/hwtracing/stm/core.c > create mode 100644 drivers/hwtracing/stm/policy.c > create mode 100644 drivers/hwtracing/stm/stm.h > create mode 100644 include/linux/stm.h > create mode 100644 include/uapi/linux/stm.h > > diff --git a/Documentation/ABI/testing/configfs-stp-policy b/Documentation/ABI/testing/configfs-stp-policy > new file mode 100644 > index 0000000000..421ce6825c > --- /dev/null > +++ b/Documentation/ABI/testing/configfs-stp-policy > @@ -0,0 +1,48 @@ > +What: /config/stp-policy > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group contains policies mandating Master/Channel allocation > + for software sources wishing to send trace data over an STM > + device. > + > +What: /config/stp-policy/<device>.<policy> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group is the root of a policy; its name is a concatenation > + of an stm device name to which this policy applies and an > + arbitrary string. If <device> part doesn't match an existing > + stm device, mkdir will fail with ENODEV; if that device already > + has a policy assigned to it, mkdir will fail with EBUSY. > + > +What: /config/stp-policy/<device>.<policy>/device > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + STM device to which this policy applies, read only. Same as the > + <device> component of its parent directory. > + > +What: /config/stp-policy/<device>.<policy>/<node> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Policy node is a string identifier that software clients will > + use to request a master/channel to be allocated and assigned to > + them. > + > +What: /config/stp-policy/<device>.<policy>/<node>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of masters from which to allocate for users of this node. > + Write two numbers: the first master and the last master number. > + > +What: /config/stp-policy/<device>.<policy>/<node>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of channels from which to allocate for users of this node. > + Write two numbers: the first channel and the last channel > + number. > + > diff --git a/Documentation/ABI/testing/sysfs-class-stm b/Documentation/ABI/testing/sysfs-class-stm > new file mode 100644 > index 0000000000..c9aa4f3fc9 > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm > @@ -0,0 +1,14 @@ > +What: /sys/class/stm/<stm>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + Shows first and last available to software master numbers on > + this STM device. > + > +What: /sys/class/stm/<stm>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + Shows the number of channels per master on this STM device. > diff --git a/Documentation/ABI/testing/sysfs-class-stm_source b/Documentation/ABI/testing/sysfs-class-stm_source > new file mode 100644 > index 0000000000..57b8dd39bb > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm_source > @@ -0,0 +1,11 @@ > +What: /sys/class/stm_source/<stm_source>/stm_source_link > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + stm_source device linkage to stm device, where its tracing data > + is directed. Reads return an existing connection or "<none>" if > + this stm_source is not connected to any stm device yet. > + Write an existing (registered) stm device's name here to > + connect that device. If a device is already connected to this > + stm_source, it will first be disconnected. > diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt > index 611c52267d..7fa29b4ece 100644 > --- a/Documentation/ioctl/ioctl-number.txt > +++ b/Documentation/ioctl/ioctl-number.txt > @@ -81,6 +81,9 @@ Code Seq#(hex) Include File Comments > 0x22 all scsi/sg.h > '#' 00-3F IEEE 1394 Subsystem Block for the entire subsystem > '$' 00-0F linux/perf_counter.h, linux/perf_event.h > +'%' 00-0F include/uapi/linux/stm.h > + System Trace Module subsystem > + <mailto:alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > '&' 00-07 drivers/firewire/nosy-user.h > '1' 00-1F <linux/timepps.h> PPS kit from Ulrich Windl > <ftp://ftp.de.kernel.org/pub/linux/daemons/ntp/PPS/> > diff --git a/Documentation/trace/stm.txt b/Documentation/trace/stm.txt > new file mode 100644 > index 0000000000..e140f2e8d7 > --- /dev/null > +++ b/Documentation/trace/stm.txt > @@ -0,0 +1,80 @@ > +System Trace Module > +=================== > + > +System Trace Module (STM) is a device described in MIPI STP specs as > +STP trace stream generator. STP (System Trace Protocol) is a trace > +protocol multiplexing data from multiple trace sources, each one of > +which is assigned a unique pair of master and channel. While some of > +these masters and channels are statically allocated to certain > +hardware trace sources, others are available to software. Software > +trace sources are usually free to pick for themselves any > +master/channel combination from this pool. > + > +On the receiving end of this STP stream (the decoder side), trace > +sources can only be identified by master/channel combination, so in > +order for the decoder to be able to make sense of the trace that > +involves multiple trace sources, it needs to be able to map those > +master/channel pairs to the trace sources that it understands. > + > +For instance, it is helpful to know that syslog messages come on > +master 7 channel 15, while arbitrary user applications can use masters > +48 to 63 and channels 0 to 127. > + > +To solve this mapping problem, stm class provides a policy management > +mechanism via configfs, that allows defining rules that map string > +identifiers to ranges of masters and channels. If these rules (policy) > +are consistent with what decoder expects, it will be able to properly > +process the trace data. > + > +This policy is a tree structure containing rules (policy_node) that > +have a name (string identifier) and a range of masters and channels > +associated with it, located in "stp-policy" subsystem directory in > +configfs. The topmost directory's name (the policy) is formatted as > +the STM device name to which this policy applies and and arbitrary > +string identifier separated by a stop. From the examle above, a rule > +may look like this: > + > +$ ls /config/stp-policy/dummy_stm.my-policy/user > +channels masters > +$ cat /config/stp-policy/dummy_stm.my-policy/user/masters > +48 63 > +$ cat /config/stp-policy/dummy_stm.my-policy/user/channels > +0 127 > + > +which means that the master allocation pool for this rule consists of > +masters 48 through 63 and channel allocation pool has channels 0 > +through 127 in it. Now, any producer (trace source) identifying itself > +with "user" identification string will be allocated a master and > +channel from within these ranges. > + > +These rules can be nested, for example, one can define a rule "dummy" > +under "user" directory from the example above and this new rule will > +be used for trace sources with the id string of "user/dummy". > + > +Trace sources have to open the stm class device's node and write their > +trace data into its file descriptor. In order to identify themselves > +to the policy, they need to do a STP_POLICY_ID_SET ioctl on this file > +descriptor providing their id string. Otherwise, they will be > +automatically allocated a master/channel pair upon first write to this > +file descriptor according to the "default" rule of the policy, if such > +exists. > + > +Some STM devices may allow direct mapping of the channel mmio regions > +to userspace for zero-copy writing. One mappable page (in terms of > +mmu) will usually contain multiple channels' mmios, so the user will > +need to allocate that many channels to themselves (via the > +aforementioned ioctl() call) to be able to do this. That is, if your > +stm device's channel mmio region is 64 bytes and hardware page size is > +4096 bytes, after a successful STP_POLICY_ID_SET ioctl() call with > +width==64, you should be able to mmap() one page on this file > +descriptor and obtain direct access to an mmio region for 64 channels. > + > +For kernel-based trace sources, there is "stm_source" device > +class. Devices of this class can be connected and disconnected to/from > +stm devices at runtime via a sysfs attribute. > + > +Examples of STM devices are Intel Trace Hub [1] and Coresight STM > +[2]. > + > +[1] https://software.intel.com/sites/default/files/managed/d3/3c/intel-th-developer-manual.pdf > +[2] http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0444b/index.html > diff --git a/drivers/Kconfig b/drivers/Kconfig > index 6e973b8e3a..96efe4522c 100644 > --- a/drivers/Kconfig > +++ b/drivers/Kconfig > @@ -184,4 +184,6 @@ source "drivers/android/Kconfig" > > source "drivers/nvdimm/Kconfig" > > +source "drivers/hwtracing/stm/Kconfig" > + > endmenu > diff --git a/drivers/Makefile b/drivers/Makefile > index b64b49f6e0..6647bc923f 100644 > --- a/drivers/Makefile > +++ b/drivers/Makefile > @@ -164,4 +164,5 @@ obj-$(CONFIG_MCB) += mcb/ > obj-$(CONFIG_RAS) += ras/ > obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ > obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ > +obj-$(CONFIG_STM) += hwtracing/stm/ > obj-$(CONFIG_ANDROID) += android/ > diff --git a/drivers/hwtracing/stm/Kconfig b/drivers/hwtracing/stm/Kconfig > new file mode 100644 > index 0000000000..90ed327461 > --- /dev/null > +++ b/drivers/hwtracing/stm/Kconfig > @@ -0,0 +1,8 @@ > +config STM > + tristate "System Trace Module devices" > + help > + A System Trace Module (STM) is a device exporting data in System > + Trace Protocol (STP) format as defined by MIPI STP standards. > + Examples of such devices are Intel Trace Hub and Coresight STM. > + > + Say Y here to enable System Trace Module device support. > diff --git a/drivers/hwtracing/stm/Makefile b/drivers/hwtracing/stm/Makefile > new file mode 100644 > index 0000000000..adec701649 > --- /dev/null > +++ b/drivers/hwtracing/stm/Makefile > @@ -0,0 +1,3 @@ > +obj-$(CONFIG_STM) += stm_core.o > + > +stm_core-y := core.o policy.o > diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c > new file mode 100644 > index 0000000000..b79c42c625 > --- /dev/null > +++ b/drivers/hwtracing/stm/core.c > @@ -0,0 +1,1029 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#include <linux/uaccess.h> > +#include <linux/kernel.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/compat.h> > +#include <linux/kdev_t.h> > +#include <linux/srcu.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include <linux/fs.h> > +#include <linux/mm.h> > +#include "stm.h" > + > +#include <uapi/linux/stm.h> > + > +static unsigned int stm_core_up; > + > +/* > + * The SRCU here makes sure that STM device doesn't disappear from under a > + * stm_source_write() caller, which may want to have as little overhead as > + * possible. > + */ > +static struct srcu_struct stm_source_srcu; > + > +static ssize_t masters_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(masters); > + > +static ssize_t channels_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u\n", stm->data->sw_nchannels); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(channels); > + > +static struct attribute *stm_attrs[] = { > + &dev_attr_masters.attr, > + &dev_attr_channels.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm); > + > +static struct class stm_class = { > + .name = "stm", > + .dev_groups = stm_groups, > +}; > + > +static int stm_dev_match(struct device *dev, const void *data) > +{ > + const char *name = data; > + > + return sysfs_streq(name, dev_name(dev)); > +} > + > +/** > + * stm_find_device() - find stm device by name > + * @buf: character buffer containing the name > + * > + * This is called when either policy gets assigned to an stm device or an > + * stm_source device gets linked to an stm device. > + * > + * This grabs device's reference (get_device()) and module reference, both > + * of which the calling path needs to make sure to drop with stm_put_device(). > + * > + * Return: stm device pointer or null if lookup failed. > + */ > +struct stm_device *stm_find_device(const char *buf) > +{ > + struct stm_device *stm; > + struct device *dev; > + > + if (!stm_core_up) > + return NULL; > + > + dev = class_find_device(&stm_class, NULL, buf, stm_dev_match); > + if (!dev) > + return NULL; > + > + stm = to_stm_device(dev); > + if (!try_module_get(stm->owner)) { > + put_device(dev); > + return NULL; > + } > + > + return stm; > +} > + > +/** > + * stm_put_device() - drop references on the stm device > + * @stm: stm device, previously acquired by stm_find_device() > + * > + * This drops the module reference and device reference taken by > + * stm_find_device(). > + */ > +void stm_put_device(struct stm_device *stm) > +{ > + module_put(stm->owner); > + put_device(&stm->dev); > +} > + > +/* > + * Internally we only care about software-writable masters here, that is the > + * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need > + * original master numbers to be visible externally, since they are the ones > + * that will appear in the STP stream. Thus, the internal bookkeeping uses > + * $master - stm_data->sw_start to reference master descriptors and such. > + */ > + > +#define __stm_master(_s, _m) \ > + ((_s)->masters[(_m) - (_s)->data->sw_start]) > + > +static inline struct stp_master * > +stm_master(struct stm_device *stm, unsigned int idx) > +{ > + if (idx < stm->data->sw_start || idx > stm->data->sw_end) > + return NULL; > + > + return __stm_master(stm, idx); > +} > + > +static int stp_master_alloc(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master; > + size_t size; > + > + size = ALIGN(stm->data->sw_nchannels, 8) / 8; > + size += sizeof(struct stp_master); > + master = kzalloc(size, GFP_ATOMIC); > + if (!master) > + return -ENOMEM; > + > + master->nr_free = stm->data->sw_nchannels; > + __stm_master(stm, idx) = master; > + > + return 0; > +} > + > +static void stp_master_free(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master = stm_master(stm, idx); > + > + if (!master) > + return; > + > + __stm_master(stm, idx) = NULL; > + kfree(master); > +} > + > +static void stm_output_claim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + if (WARN_ON_ONCE(master->nr_free < output->nr_chans)) > + return; > + > + bitmap_allocate_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + master->nr_free -= output->nr_chans; > +} > + > +static void > +stm_output_disclaim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + bitmap_release_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + output->nr_chans = 0; > + master->nr_free += output->nr_chans; > +} > + > +/* > + * This is like bitmap_find_free_region(), except it can ignore @start bits > + * at the beginning. > + */ > +static int find_free_channels(unsigned long *bitmap, unsigned int start, > + unsigned int end, unsigned int width) > +{ > + unsigned int pos; > + int i; > + > + for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) { > + pos = find_next_zero_bit(bitmap, end + 1, pos); > + if (pos + width > end + 1) > + break; > + > + if (pos & (width - 1)) > + continue; > + > + for (i = 1; i < width && !test_bit(pos + i, bitmap); i++) > + ; > + if (i == width) > + return pos; > + } > + > + return -1; > +} > + > +static unsigned int > +stm_find_master_chan(struct stm_device *stm, unsigned int width, > + unsigned int *mstart, unsigned int mend, > + unsigned int *cstart, unsigned int cend) > +{ > + struct stp_master *master; > + unsigned int midx; > + int pos, err; > + > + for (midx = *mstart; midx <= mend; midx++) { > + if (!stm_master(stm, midx)) { > + err = stp_master_alloc(stm, midx); > + if (err) > + return err; > + } > + > + master = stm_master(stm, midx); > + > + if (!master->nr_free) > + continue; > + > + pos = find_free_channels(master->chan_map, *cstart, cend, > + width); > + if (pos < 0) > + continue; > + > + *mstart = midx; > + *cstart = pos; > + return 0; > + } > + > + return -ENOSPC; > +} > + > +static int stm_output_assign(struct stm_device *stm, unsigned int width, > + struct stp_policy_node *policy_node, > + struct stm_output *output) > +{ > + unsigned int midx, cidx, mend, cend; > + int ret = -EINVAL; > + > + if (width > stm->data->sw_nchannels) > + return -EINVAL; > + > + if (policy_node) { > + stp_policy_node_get_ranges(policy_node, > + &midx, &mend, &cidx, &cend); > + } else { > + midx = stm->data->sw_start; > + cidx = 0; > + mend = stm->data->sw_end; > + cend = stm->data->sw_nchannels - 1; > + } > + > + spin_lock(&stm->mc_lock); > + /* output is already assigned -- shouldn't happen */ > + if (WARN_ON_ONCE(output->nr_chans)) > + goto unlock; > + > + ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend); > + if (ret) > + goto unlock; > + > + output->master = midx; > + output->channel = cidx; > + output->nr_chans = width; > + stm_output_claim(stm, output); > + dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width); > + > + ret = 0; > +unlock: > + spin_unlock(&stm->mc_lock); > + > + return ret; > +} > + > +static void stm_output_free(struct stm_device *stm, struct stm_output *output) > +{ > + spin_lock(&stm->mc_lock); > + if (output->nr_chans) > + stm_output_disclaim(stm, output); > + spin_unlock(&stm->mc_lock); > +} > + > +static int major_match(struct device *dev, const void *data) > +{ > + unsigned int major = *(unsigned int *)data; > + > + return MAJOR(dev->devt) == major; > +} > + > +static int stm_char_open(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf; > + struct device *dev; > + unsigned int major = imajor(inode); > + int err = -ENODEV; > + > + dev = class_find_device(&stm_class, NULL, &major, major_match); > + if (!dev) > + return -ENODEV; > + > + stmf = kzalloc(sizeof(*stmf), GFP_KERNEL); > + if (!stmf) > + return -ENOMEM; > + > + stmf->stm = to_stm_device(dev); > + > + if (!try_module_get(stmf->stm->owner)) > + goto err_free; > + > + file->private_data = stmf; > + > + return nonseekable_open(inode, file); > + > +err_free: > + kfree(stmf); > + > + return err; > +} > + > +static int stm_char_release(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf = file->private_data; > + > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + kfree(stmf); > + > + return 0; > +} > + > +static int stm_file_assign(struct stm_file *stmf, char *id, unsigned int width) > +{ > + struct stm_device *stm = stmf->stm; > + int ret; > + > + stmf->policy_node = stp_policy_node_lookup(stm, id); > + > + ret = stm_output_assign(stm, width, stmf->policy_node, &stmf->output); > + > + if (stmf->policy_node) > + stp_policy_node_put(stmf->policy_node); > + > + return ret; > +} > + > +static void stm_write(struct stm_data *data, unsigned int master, > + unsigned int channel, const char *buf, size_t count) > +{ > + unsigned int flags = STP_PACKET_TIMESTAMPED; > + const unsigned char *p = buf, nil = 0; > + size_t pos; > + ssize_t sz; > + > + for (pos = 0, p = buf; count > pos; pos += sz, p += sz) { > + sz = min_t(unsigned int, count - pos, 8); > + sz = data->packet(data, master, channel, STP_PACKET_DATA, flags, > + sz, p); > + flags = 0; > + } > + > + data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil); > +} > + > +static ssize_t stm_char_write(struct file *file, const char __user *buf, > + size_t count, loff_t *ppos) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + char *kbuf; > + int err; > + > + /* > + * if no m/c have been assigned to this writer up to this > + * point, use "default" policy entry > + */ > + if (!stmf->output.nr_chans) { > + err = stm_file_assign(stmf, "default", 1); > + /* > + * EBUSY means that somebody else just assigned this > + * output, which is just fine for write() > + */ > + if (err && err != -EBUSY) > + return err; > + } > + > + kbuf = kmalloc(count + 1, GFP_KERNEL); > + if (!kbuf) > + return -ENOMEM; > + > + err = copy_from_user(kbuf, buf, count); > + if (err) { > + kfree(kbuf); > + return -EFAULT; > + } > + > + stm_write(stm->data, stmf->output.master, stmf->output.channel, kbuf, > + count); > + > + kfree(kbuf); > + > + return count; > +} > + > +static int stm_char_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + unsigned long size, phys; > + > + if (!stm->data->mmio_addr) > + return -EOPNOTSUPP; > + > + if (vma->vm_pgoff) > + return -EINVAL; > + > + size = vma->vm_end - vma->vm_start; > + > + if (stmf->output.nr_chans * stm->data->sw_mmiosz != size) > + return -EINVAL; > + > + phys = stm->data->mmio_addr(stm->data, stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans); > + > + if (!phys) > + return -EINVAL; > + > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP; > + vm_iomap_memory(vma, phys, size); > + > + return 0; > +} > + > +static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stm_device *stm = stmf->stm; > + struct stp_policy_id *id; > + int ret = -EINVAL; > + u32 size; > + > + if (stmf->output.nr_chans) > + return -EBUSY; > + > + if (copy_from_user(&size, arg, sizeof(size))) > + return -EFAULT; > + > + if (size >= PATH_MAX + sizeof(*id)) > + return -EINVAL; > + > + /* > + * size + 1 to make sure the .id string at the bottom is terminated, > + * which is also why memdup_user() is not useful here > + */ > + id = kzalloc(size + 1, GFP_KERNEL); > + if (!id) > + return -ENOMEM; > + > + if (copy_from_user(id, arg, size)) { > + ret = -EFAULT; > + goto err_free; > + } > + > + if (id->__reserved_0 || id->__reserved_1) > + goto err_free; > + > + if (id->width < 1 || > + id->width > PAGE_SIZE / stm->data->sw_mmiosz) > + goto err_free; > + > + ret = stm_file_assign(stmf, id->id, id->width); > + if (ret) > + goto err_free; > + > + ret = 0; > + > + if (stm->data->link) > + ret = stm->data->link(stm->data, stmf->output.master, > + stmf->output.channel); > + > + if (ret) { > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + } > + > +err_free: > + kfree(id); > + > + return ret; > +} > + > +static int stm_char_policy_get_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stp_policy_id id = { > + .size = sizeof(id), > + .master = stmf->output.master, > + .channel = stmf->output.channel, > + .width = stmf->output.nr_chans, > + .__reserved_0 = 0, > + .__reserved_1 = 0, > + }; > + > + return copy_to_user(arg, &id, id.size) ? -EFAULT : 0; > +} > + > +static long > +stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_data *stm_data = stmf->stm->data; > + int err = -ENOTTY; > + u64 options; > + > + switch (cmd) { > + case STP_POLICY_ID_SET: > + err = stm_char_policy_set_ioctl(stmf, (void __user *)arg); > + if (err) > + return err; > + > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_POLICY_ID_GET: > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_SET_OPTIONS: > + if (copy_from_user(&options, (u64 __user *)arg, sizeof(u64))) > + return -EFAULT; > + > + if (stm_data->set_options) > + err = stm_data->set_options(stm_data, > + stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans, > + options); > + > + break; > + default: > + break; > + } > + > + return err; > +} > + > +#ifdef CONFIG_COMPAT > +static long > +stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); > +} > +#else > +#define stm_char_compat_ioctl NULL > +#endif > + > +static const struct file_operations stm_fops = { > + .open = stm_char_open, > + .release = stm_char_release, > + .write = stm_char_write, > + .mmap = stm_char_mmap, > + .unlocked_ioctl = stm_char_ioctl, > + .compat_ioctl = stm_char_compat_ioctl, > + .llseek = no_llseek, > +}; > + > +static void stm_device_release(struct device *dev) > +{ > + struct stm_device *stm = to_stm_device(dev); > + > + kfree(stm); > +} > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner) > +{ > + struct stm_device *stm; > + unsigned int nmasters; > + int err = -ENOMEM; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + > + if (!stm_data->packet || !stm_data->sw_nchannels) > + return -EINVAL; > + > + nmasters = stm_data->sw_end - stm_data->sw_start; > + stm = kzalloc(sizeof(*stm) + nmasters * sizeof(void *), GFP_KERNEL); > + if (!stm) > + return -ENOMEM; > + > + stm->major = register_chrdev(0, stm_data->name, &stm_fops); > + if (stm->major < 0) > + goto err_free; > + > + device_initialize(&stm->dev); > + stm->dev.devt = MKDEV(stm->major, 0); > + stm->dev.class = &stm_class; > + stm->dev.parent = parent; > + stm->dev.release = stm_device_release; > + > + err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name); > + if (err) > + goto err_device; > + > + err = device_add(&stm->dev); > + if (err) > + goto err_device; > + > + spin_lock_init(&stm->link_lock); > + INIT_LIST_HEAD(&stm->link_list); > + > + spin_lock_init(&stm->mc_lock); > + mutex_init(&stm->policy_mutex); > + stm->sw_nmasters = nmasters; > + stm->owner = owner; > + stm->data = stm_data; > + stm_data->stm = stm; > + > + return 0; > + > +err_device: > + put_device(&stm->dev); > +err_free: > + kfree(stm); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_register_device); > + > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm); > + > +void stm_unregister_device(struct stm_data *stm_data) > +{ > + struct stm_device *stm = stm_data->stm; > + struct stm_source_device *src, *iter; > + int i; > + > + spin_lock(&stm->link_lock); > + list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) { > + __stm_source_link_drop(src, stm); > + } > + spin_unlock(&stm->link_lock); > + > + synchronize_srcu(&stm_source_srcu); > + > + unregister_chrdev(stm->major, stm_data->name); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + stp_policy_unbind(stm->policy); > + mutex_unlock(&stm->policy_mutex); > + > + for (i = 0; i < stm->sw_nmasters; i++) > + stp_master_free(stm, i); > + > + device_unregister(&stm->dev); > + stm_data->stm = NULL; > +} > +EXPORT_SYMBOL_GPL(stm_unregister_device); > + > +/** > + * stm_source_link_add() - connect an stm_source device to an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * This function establishes a link from stm_source to an stm device so that > + * the former can send out trace data to the latter. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +static int stm_source_link_add(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + char *id; > + int err; > + > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + /* src->link is dereferenced under stm_source_srcu but not the list */ > + rcu_assign_pointer(src->link, stm); > + list_add_tail(&src->link_entry, &stm->link_list); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + id = kstrdup(src->data->name, GFP_KERNEL); > + if (id) { > + src->policy_node = > + stp_policy_node_lookup(stm, id); > + > + kfree(id); > + } > + > + err = stm_output_assign(stm, src->data->nr_chans, > + src->policy_node, &src->output); > + > + if (src->policy_node) > + stp_policy_node_put(src->policy_node); > + > + if (err) > + goto fail_detach; > + > + /* this is to notify the STM device that a new link has been made */ > + if (stm->data->link) > + err = stm->data->link(stm->data, src->output.master, > + src->output.channel); > + > + if (err) > + goto fail_free_output; > + > + /* this is to let the source carry out all necessary preparations */ > + if (src->data->link) > + src->data->link(src->data); > + > + return 0; > + > +fail_free_output: > + stm_output_free(stm, &src->output); > + stm_put_device(stm); > + > +fail_detach: > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + rcu_assign_pointer(src->link, NULL); > + list_del_init(&src->link_entry); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + return err; > +} > + > +/** > + * __stm_source_link_drop() - detach stm_source from an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * If @stm is @src::link, disconnect them from one another and put the > + * reference on the @stm device. > + * > + * Caller must hold stm::link_lock. > + */ > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + spin_lock(&src->link_lock); > + if (WARN_ON_ONCE(src->link != stm)) { > + spin_unlock(&src->link_lock); > + return; > + } > + > + stm_output_free(src->link, &src->output); > + /* caller must hold stm::link_lock */ > + list_del_init(&src->link_entry); > + /* matches stm_find_device() from stm_source_link_store() */ > + stm_put_device(src->link); > + rcu_assign_pointer(src->link, NULL); > + > + spin_unlock(&src->link_lock); > +} > + > +/** > + * stm_source_link_drop() - detach stm_source from its stm device > + * @src: stm_source device > + * > + * Unlinking means disconnecting from source's STM device; after this > + * writes will be unsuccessful until it is linked to a new STM device. > + * > + * This will happen on "stm_source_link" sysfs attribute write to undo > + * the existing link (if any), or on linked STM device's de-registration. > + */ > +static void stm_source_link_drop(struct stm_source_device *src) > +{ > + struct stm_device *stm; > + int idx; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + > + if (stm) { > + if (src->data->unlink) > + src->data->unlink(src->data); > + > + spin_lock(&stm->link_lock); > + __stm_source_link_drop(src, stm); > + spin_unlock(&stm->link_lock); > + } > + > + srcu_read_unlock(&stm_source_srcu, idx); > +} > + > +static ssize_t stm_source_link_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *stm; > + int idx, ret; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + ret = sprintf(buf, "%s\n", > + stm ? dev_name(&stm->dev) : "<none>"); > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return ret; > +} > + > +static ssize_t stm_source_link_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *link; > + int err; > + > + stm_source_link_drop(src); > + > + link = stm_find_device(buf); > + if (!link) > + return -EINVAL; > + > + err = stm_source_link_add(src, link); > + if (err) > + stm_put_device(link); > + > + return err ? : count; > +} > + > +static DEVICE_ATTR_RW(stm_source_link); > + > +static struct attribute *stm_source_attrs[] = { > + &dev_attr_stm_source_link.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm_source); > + > +static struct class stm_source_class = { > + .name = "stm_source", > + .dev_groups = stm_source_groups, > +}; > + > +static void stm_source_device_release(struct device *dev) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + > + kfree(src); > +} > + > +/** > + * stm_source_register_device() - register an stm_source device > + * @parent: parent device > + * @data: device description structure > + * > + * This will create a device of stm_source class that can write > + * data to an stm device once linked. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data) > +{ > + struct stm_source_device *src; > + int err; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + I tried to update Coresight-stm driver[1] based on your this version patch, but the Coresight-stm driver probe() failed. the reason was: In the end of Coresight stm_probe(), we called this function, but "stm_core_up" was zero then, so the error returned value "-EPROBE_DEFER" was received. In fact, "stm_core_up" would increase itself until "stm_core_init" be called - it's the root of this problem, I'll explain this where the function "stm_core_init" defined. And redoing Coresight stm_probe() will incur a WARN_ON() like below: [ 1.075746] coresight-stm 10006000.stm: stm_register_device failed [ 1.082118] ------------[ cut here ]------------ [ 1.086819] WARNING: CPU: 1 PID: 1 at drivers/clk/clk.c:657 clk_core_disable+0x138/0x13c() [ 1.095353] Modules linked in: [ 1.098487] CPU: 1 PID: 1 Comm: swapper/0 Tainted: G S 4.2.0-rc1+ #107 [ 1.106398] Hardware name: Spreadtrum SC9836 Openphone Board (DT) [ 1.112678] Call trace: [ 1.115194] [<ffffffc00008a5b4>] dump_backtrace+0x0/0x138 [ 1.120761] [<ffffffc00008a708>] show_stack+0x1c/0x28 [ 1.125972] [<ffffffc0003320e0>] dump_stack+0x84/0xc8 [ 1.131179] [<ffffffc00009b580>] warn_slowpath_common+0xa4/0xdc [ 1.137285] [<ffffffc00009b700>] warn_slowpath_null+0x34/0x44 [ 1.143213] [<ffffffc000321eb4>] clk_core_disable+0x134/0x13c [ 1.149140] [<ffffffc000322154>] clk_disable+0x30/0x48 [ 1.154439] [<ffffffc0002b5e58>] amba_put_disable_pclk.isra.6+0x20/0x40 [ 1.161264] [<ffffffc0002b6134>] amba_probe+0x16c/0x19c [ 1.166653] [<ffffffc0002e664c>] driver_probe_device+0x1a4/0x2b4 [ 1.172849] [<ffffffc0002e6804>] __driver_attach+0xa8/0xb0 [ 1.178506] [<ffffffc0002e45fc>] bus_for_each_dev+0x68/0xac [ 1.184253] [<ffffffc0002e60b4>] driver_attach+0x28/0x34 [ 1.189731] [<ffffffc0002e5cd0>] bus_add_driver+0x1cc/0x234 [ 1.195479] [<ffffffc0002e73d8>] driver_register+0x64/0x124 [ 1.201226] [<ffffffc0002b58cc>] amba_driver_register+0x64/0x74 [ 1.207333] [<ffffffc00045591c>] stm_driver_init+0x10/0x1c [ 1.212990] [<ffffffc0000828e0>] do_one_initcall+0x90/0x1a8 [ 1.218739] [<ffffffc000431adc>] kernel_init_freeable+0x150/0x1f4 [ 1.225026] [<ffffffc00032fbe4>] kernel_init+0x1c/0xe0 [ 1.230321] ---[ end trace 487f4b7838ebf86a ]--- [ 1.235102] ------------[ cut here ]------------ > + src = kzalloc(sizeof(*src), GFP_KERNEL); > + if (!src) > + return -ENOMEM; > + > + device_initialize(&src->dev); > + src->dev.class = &stm_source_class; > + src->dev.parent = parent; > + src->dev.release = stm_source_device_release; > + > + err = kobject_set_name(&src->dev.kobj, "%s", data->name); > + if (err) > + goto err; > + > + err = device_add(&src->dev); > + if (err) > + goto err; > + > + spin_lock_init(&src->link_lock); > + INIT_LIST_HEAD(&src->link_entry); > + src->data = data; > + data->src = src; > + > + return 0; > + > +err: > + put_device(&src->dev); > + kfree(src); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_source_register_device); > + > +/** > + * stm_source_unregister_device() - unregister an stm_source device > + * @data: device description that was used to register the device > + * > + * This will remove a previously created stm_source device from the system. > + */ > +void stm_source_unregister_device(struct stm_source_data *data) > +{ > + struct stm_source_device *src = data->src; > + > + stm_source_link_drop(src); > + > + device_destroy(&stm_source_class, src->dev.devt); > +} > +EXPORT_SYMBOL_GPL(stm_source_unregister_device); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = data->src; > + struct stm_device *stm; > + int idx; > + > + if (!src->output.nr_chans) > + return -ENODEV; > + > + if (chan >= src->output.nr_chans) > + return -EINVAL; > + > + idx = srcu_read_lock(&stm_source_srcu); > + > + stm = srcu_dereference(src->link, &stm_source_srcu); > + if (stm) > + stm_write(stm->data, src->output.master, > + src->output.channel + chan, > + buf, count); > + else > + count = -ENODEV; > + > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return count; > +} > +EXPORT_SYMBOL_GPL(stm_source_write); > + > +static int __init stm_core_init(void) > +{ > + int err; > + > + err = class_register(&stm_class); > + if (err) > + return err; > + > + err = class_register(&stm_source_class); > + if (err) > + goto err_stm; > + > + err = stp_configfs_init(); > + if (err) > + goto err_src; > + > + init_srcu_struct(&stm_source_srcu); > + > + stm_core_up++; > + > + return 0; > + > +err_src: > + class_unregister(&stm_source_class); > +err_stm: > + class_unregister(&stm_class); > + > + return err; > +} > + > +module_init(stm_core_init); Since you are using module_init() instead of postcore_initcall() which was in the last version patch, as such, this function would be executed after Coresight "stm_probe" finished. So, we think there a few optional solutions: 1) Remove the "stm_register_device" out from Coresight "stm_probe", but we have to save another global variable: struct device *stm_dev; in the process of Coresight "stm_probe". 2) Change module_init() to other XYX_init() which would run prior to "amba_probe()" (i.e. the caller of Coresight stm_probe), this may be a better one. 3) stm_core_init() could be turned into a library call where initialisation of the internals is done when first called. Looking forward to your reply/comments. Thanks, Chunyan [1] https://lkml.org/lkml/2015/2/4/729 > + > +static void __exit stm_core_exit(void) > +{ > + cleanup_srcu_struct(&stm_source_srcu); > + class_unregister(&stm_source_class); > + class_unregister(&stm_class); > + stp_configfs_exit(); > +} > + > +module_exit(stm_core_exit); > + > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("System Trace Module device class"); > +MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org>"); > diff --git a/drivers/hwtracing/stm/policy.c b/drivers/hwtracing/stm/policy.c > new file mode 100644 > index 0000000000..6498a9dbb7 > --- /dev/null > +++ b/drivers/hwtracing/stm/policy.c > @@ -0,0 +1,529 @@ > +/* > + * System Trace Module (STM) master/channel allocation policy management > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * A master/channel allocation policy allows mapping string identifiers to > + * master and channel ranges, where allocation can be done. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/types.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/configfs.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include "stm.h" > + > +/* > + * STP Master/Channel allocation policy configfs layout. > + */ > + > +struct stp_policy { > + struct config_group group; > + struct stm_device *stm; > +}; > + > +struct stp_policy_node { > + struct config_group group; > + struct stp_policy *policy; > + unsigned int first_master; > + unsigned int last_master; > + unsigned int first_channel; > + unsigned int last_channel; > +}; > + > +static struct configfs_subsystem stp_policy_subsys; > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend) > +{ > + *mstart = policy_node->first_master; > + *mend = policy_node->last_master; > + *cstart = policy_node->first_channel; > + *cend = policy_node->last_channel; > +} > + > +static inline char *stp_policy_node_name(struct stp_policy_node *policy_node) > +{ > + return policy_node->group.cg_item.ci_name ? : "<none>"; > +} > + > +static inline struct stp_policy *to_stp_policy(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy, group) : > + NULL; > +} > + > +static inline struct stp_policy_node * > +to_stp_policy_node(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy_node, > + group) : > + NULL; > +} > + > +static ssize_t stp_policy_node_masters_show(struct stp_policy_node *policy_node, > + char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_master, > + policy_node->last_master); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_masters_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + /* must be within [sw_start..sw_end], which is an inclusive range */ > + if (first > INT_MAX || last > INT_MAX || first > last || > + first < stm->data->sw_start || > + last > stm->data->sw_end) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_master = first; > + policy_node->last_master = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static ssize_t > +stp_policy_node_channels_show(struct stp_policy_node *policy_node, char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_channel, > + policy_node->last_channel); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_channels_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + if (first > INT_MAX || last > INT_MAX || first > last || > + last >= stm->data->sw_nchannels) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_channel = first; > + policy_node->last_channel = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static void stp_policy_node_release(struct config_item *item) > +{ > + kfree(to_stp_policy_node(item)); > +} > + > +struct stp_policy_node_attribute { > + struct configfs_attribute attr; > + ssize_t (*show)(struct stp_policy_node *, char *); > + ssize_t (*store)(struct stp_policy_node *, const char *, size_t); > +}; > + > +static ssize_t stp_policy_node_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = 0; > + > + if (pn_attr->show) > + count = pn_attr->show(policy_node, page); > + > + return count; > +} > + > +static ssize_t stp_policy_node_attr_store(struct config_item *item, > + struct configfs_attribute *attr, > + const char *page, size_t len) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = -EINVAL; > + > + if (pn_attr->store) > + count = pn_attr->store(policy_node, page, len); > + > + return count; > +} > + > +static struct configfs_item_operations stp_policy_node_item_ops = { > + .release = stp_policy_node_release, > + .show_attribute = stp_policy_node_attr_show, > + .store_attribute = stp_policy_node_attr_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_range = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "masters", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_masters_show, > + .store = stp_policy_node_masters_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_channels = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "channels", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_channels_show, > + .store = stp_policy_node_channels_store, > +}; > + > +static struct configfs_attribute *stp_policy_node_attrs[] = { > + &stp_policy_node_attr_range.attr, > + &stp_policy_node_attr_channels.attr, > + NULL, > +}; > + > +static struct config_item_type stp_policy_type; > +static struct config_item_type stp_policy_node_type; > + > +static struct config_group * > +stp_policy_node_make(struct config_group *group, const char *name) > +{ > + struct stp_policy_node *policy_node, *parent_node; > + struct stp_policy *policy; > + > + if (group->cg_item.ci_type == &stp_policy_type) { > + policy = container_of(group, struct stp_policy, group); > + } else { > + parent_node = container_of(group, struct stp_policy_node, > + group); > + policy = parent_node->policy; > + } > + > + if (!policy->stm) > + return ERR_PTR(-ENODEV); > + > + policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL); > + if (!policy_node) > + return ERR_PTR(-ENOMEM); > + > + config_group_init_type_name(&policy_node->group, name, > + &stp_policy_node_type); > + > + policy_node->policy = policy; > + > + /* default values for the attributes */ > + policy_node->first_master = policy->stm->data->sw_start; > + policy_node->last_master = policy->stm->data->sw_end; > + policy_node->first_channel = 0; > + policy_node->last_channel = policy->stm->data->sw_nchannels - 1; > + > + return &policy_node->group; > +} > + > +static void > +stp_policy_node_drop(struct config_group *group, struct config_item *item) > +{ > + config_item_put(item); > +} > + > +static struct configfs_group_operations stp_policy_node_group_ops = { > + .make_group = stp_policy_node_make, > + .drop_item = stp_policy_node_drop, > +}; > + > +static struct config_item_type stp_policy_node_type = { > + .ct_item_ops = &stp_policy_node_item_ops, > + .ct_group_ops = &stp_policy_node_group_ops, > + .ct_attrs = stp_policy_node_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +/* > + * Root group: policies. > + */ > +static struct configfs_attribute stp_policy_attr_device = { > + .ca_owner = THIS_MODULE, > + .ca_name = "device", > + .ca_mode = S_IRUGO, > +}; > + > +static struct configfs_attribute *stp_policy_attrs[] = { > + &stp_policy_attr_device, > + NULL, > +}; > + > +static ssize_t stp_policy_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + ssize_t count; > + > + count = sprintf(page, "%s\n", > + (policy && policy->stm) ? > + policy->stm->data->name : > + "<none>"); > + > + return count; > +} > + > +void stp_policy_unbind(struct stp_policy *policy) > +{ > + struct stm_device *stm = policy->stm; > + > + if (WARN_ON_ONCE(!policy->stm)) > + return; > + > + mutex_lock(&stm->policy_mutex); > + stm->policy = NULL; > + mutex_unlock(&stm->policy_mutex); > + > + policy->stm = NULL; > + > + stm_put_device(stm); > +} > + > +static void stp_policy_release(struct config_item *item) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + > + stp_policy_unbind(policy); > + kfree(policy); > +} > + > +static struct configfs_item_operations stp_policy_item_ops = { > + .release = stp_policy_release, > + .show_attribute = stp_policy_attr_show, > +}; > + > +static struct configfs_group_operations stp_policy_group_ops = { > + .make_group = stp_policy_node_make, > +}; > + > +static struct config_item_type stp_policy_type = { > + .ct_item_ops = &stp_policy_item_ops, > + .ct_group_ops = &stp_policy_group_ops, > + .ct_attrs = stp_policy_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct config_group * > +stp_policies_make(struct config_group *group, const char *name) > +{ > + struct config_group *ret; > + struct stm_device *stm; > + char *devname, *p; > + > + devname = kasprintf(GFP_KERNEL, "%s", name); > + if (!devname) > + return ERR_PTR(-ENOMEM); > + > + /* > + * node must look like <device_name>.<policy_name>, where > + * <device_name> is the name of an existing stm device and > + * <policy_name> is an arbitrary string > + */ > + p = strchr(devname, '.'); > + if (!p) { > + kfree(devname); > + return ERR_PTR(-EINVAL); > + } > + > + *p++ = '\0'; > + > + stm = stm_find_device(devname); > + kfree(devname); > + > + if (!stm) > + return ERR_PTR(-ENODEV); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) { > + ret = ERR_PTR(-EBUSY); > + goto unlock_policy; > + } > + > + stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); > + if (!stm->policy) { > + ret = ERR_PTR(-ENOMEM); > + goto unlock_policy; > + } > + > + config_group_init_type_name(&stm->policy->group, name, > + &stp_policy_type); > + stm->policy->stm = stm; > + > + ret = &stm->policy->group; > + > +unlock_policy: > + mutex_unlock(&stm->policy_mutex); > + > + if (IS_ERR(ret)) > + stm_put_device(stm); > + > + return ret; > +} > + > +static struct configfs_group_operations stp_policies_group_ops = { > + .make_group = stp_policies_make, > +}; > + > +static struct config_item_type stp_policies_type = { > + .ct_group_ops = &stp_policies_group_ops, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct configfs_subsystem stp_policy_subsys = { > + .su_group = { > + .cg_item = { > + .ci_namebuf = "stp-policy", > + .ci_type = &stp_policies_type, > + }, > + }, > +}; > + > +/* > + * Lock the policy mutex from the outside > + */ > +static struct stp_policy_node * > +__stp_policy_node_lookup(struct stp_policy *policy, char *s) > +{ > + struct stp_policy_node *policy_node, *ret; > + struct list_head *head = &policy->group.cg_children; > + struct config_item *item; > + char *start, *end = s; > + > + if (list_empty(head)) > + return NULL; > + > + /* return the first entry if everything else fails */ > + item = list_entry(head->next, struct config_item, ci_entry); > + ret = to_stp_policy_node(item); > + > +next: > + for (;;) { > + start = strsep(&end, "/"); > + if (!start) > + break; > + > + if (!*start) > + continue; > + > + list_for_each_entry(item, head, ci_entry) { > + policy_node = to_stp_policy_node(item); > + > + if (!strcmp(start, > + policy_node->group.cg_item.ci_name)) { > + ret = policy_node; > + > + if (!end) > + goto out; > + > + head = &policy_node->group.cg_children; > + goto next; > + } > + } > + break; > + } > + > +out: > + return ret; > +} > + > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s) > +{ > + struct stp_policy_node *policy_node = NULL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + policy_node = __stp_policy_node_lookup(stm->policy, s); > + mutex_unlock(&stm->policy_mutex); > + > + if (policy_node) > + config_item_get(&policy_node->group.cg_item); > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return policy_node; > +} > + > +void stp_policy_node_put(struct stp_policy_node *policy_node) > +{ > + config_item_put(&policy_node->group.cg_item); > +} > + > +int __init stp_configfs_init(void) > +{ > + int err; > + > + config_group_init(&stp_policy_subsys.su_group); > + mutex_init(&stp_policy_subsys.su_mutex); > + err = configfs_register_subsystem(&stp_policy_subsys); > + > + return err; > +} > + > +void __exit stp_configfs_exit(void) > +{ > + configfs_unregister_subsystem(&stp_policy_subsys); > +} > diff --git a/drivers/hwtracing/stm/stm.h b/drivers/hwtracing/stm/stm.h > new file mode 100644 > index 0000000000..cf33bf976a > --- /dev/null > +++ b/drivers/hwtracing/stm/stm.h > @@ -0,0 +1,87 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _STM_STM_H_ > +#define _STM_STM_H_ > + > +struct stp_policy; > +struct stp_policy_node; > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s); > +void stp_policy_node_put(struct stp_policy_node *policy_node); > +void stp_policy_unbind(struct stp_policy *policy); > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend); > +int stp_configfs_init(void); > +void stp_configfs_exit(void); > + > +struct stp_master { > + unsigned int nr_free; > + unsigned long chan_map[0]; > +}; > + > +struct stm_device { > + struct device dev; > + struct module *owner; > + struct stp_policy *policy; > + struct mutex policy_mutex; > + int major; > + unsigned int sw_nmasters; > + struct stm_data *data; > + spinlock_t link_lock; > + struct list_head link_list; > + /* master allocation */ > + spinlock_t mc_lock; > + struct stp_master *masters[0]; > +}; > + > +#define to_stm_device(_d) \ > + container_of((_d), struct stm_device, dev) > + > +struct stm_output { > + unsigned int master; > + unsigned int channel; > + unsigned int nr_chans; > +}; > + > +struct stm_file { > + struct stm_device *stm; > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +struct stm_device *stm_find_device(const char *name); > +void stm_put_device(struct stm_device *stm); > + > +struct stm_source_device { > + struct device dev; > + struct stm_source_data *data; > + spinlock_t link_lock; > + struct stm_device *link; > + struct list_head link_entry; > + /* one output per stm_source device */ > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +#define to_stm_source_device(_d) \ > + container_of((_d), struct stm_source_device, dev) > + > +#endif /* _STM_STM_H_ */ > diff --git a/include/linux/stm.h b/include/linux/stm.h > new file mode 100644 > index 0000000000..9d0083d364 > --- /dev/null > +++ b/include/linux/stm.h > @@ -0,0 +1,126 @@ > +/* > + * System Trace Module (STM) infrastructure apis > + * Copyright (C) 2014 Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + */ > + > +#ifndef _STM_H_ > +#define _STM_H_ > + > +#include <linux/device.h> > + > +/** > + * enum stp_packet_type - STP packets that an STM driver sends > + */ > +enum stp_packet_type { > + STP_PACKET_DATA = 0, > + STP_PACKET_FLAG, > + STP_PACKET_USER, > + STP_PACKET_MERR, > + STP_PACKET_GERR, > + STP_PACKET_TRIG, > + STP_PACKET_XSYNC, > +}; > + > +/** > + * enum stp_packet_flags - STP packet modifiers > + */ > +enum stp_packet_flags { > + STP_PACKET_MARKED = 0x1, > + STP_PACKET_TIMESTAMPED = 0x2, > +}; > + > +struct stp_policy; > + > +struct stm_device; > + > +/** > + * struct stm_data - STM device description and callbacks > + * @name: device name > + * @stm: internal structure, only used by stm class code > + * @sw_start: first STP master available to software > + * @sw_end: last STP master available to software > + * @sw_nchannels: number of STP channels per master > + * @sw_mmiosz: size of one channel's IO space, for mmap, optional > + * @packet: callback that sends an STP packet > + * @mmio_addr: mmap callback, optional > + * @link: called when a new stm_source gets linked to us, optional > + * @unlink: likewise for unlinking, again optional > + * @set_options: set device-specific options on a channel > + * > + * Fill out this structure before calling stm_register_device() to create > + * an STM device and stm_unregister_device() to destroy it. It will also be > + * passed back to @packet(), @mmio_addr(), @link(), @unlink() and @set_options() > + * callbacks. > + * > + * Normally, an STM device will have a range of masters available to software > + * and the rest being statically assigned to various hardware trace sources. > + * The former is defined by the the range [@sw_start..@sw_end] of the device > + * description. That is, the lowest master that can be allocated to software > + * writers is @sw_start and data from this writer will appear is @sw_start > + * master in the STP stream. > + */ > +struct stm_data { > + const char *name; > + struct stm_device *stm; > + unsigned int sw_start; > + unsigned int sw_end; > + unsigned int sw_nchannels; > + unsigned int sw_mmiosz; > + ssize_t (*packet)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned int, unsigned int, > + const unsigned char *); > + phys_addr_t (*mmio_addr)(struct stm_data *, unsigned int, > + unsigned int, unsigned int); > + int (*link)(struct stm_data *, unsigned int, > + unsigned int); > + void (*unlink)(struct stm_data *, unsigned int, > + unsigned int); > + long (*set_options)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned long); > +}; > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner); > +void stm_unregister_device(struct stm_data *stm_data); > + > +struct stm_source_device; > + > +/** > + * struct stm_source_data - STM source device description and callbacks > + * @name: device name, will be used for policy lookup > + * @src: internal structure, only used by stm class code > + * @nr_chans: number of channels to allocate > + * @link: called when this source gets linked to an STM device > + * @unlink: called when this source is about to get unlinked from its STM > + * > + * Fill in this structure before calling stm_source_register_device() to > + * register a source device. Also pass it to unregister and write calls. > + */ > +struct stm_source_data { > + const char *name; > + struct stm_source_device *src; > + unsigned int percpu; > + unsigned int nr_chans; > + int (*link)(struct stm_source_data *data); > + void (*unlink)(struct stm_source_data *data); > +}; > + > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data); > +void stm_source_unregister_device(struct stm_source_data *data); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count); > + > +#endif /* _STM_H_ */ > diff --git a/include/uapi/linux/stm.h b/include/uapi/linux/stm.h > new file mode 100644 > index 0000000000..626a8d3f63 > --- /dev/null > +++ b/include/uapi/linux/stm.h > @@ -0,0 +1,50 @@ > +/* > + * System Trace Module (STM) userspace interfaces > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _UAPI_LINUX_STM_H > +#define _UAPI_LINUX_STM_H > + > +#include <linux/types.h> > + > +/** > + * struct stp_policy_id - identification for the STP policy > + * @size: size of the structure including real id[] length > + * @master: assigned master > + * @channel: first assigned channel > + * @width: number of requested channels > + * @id: identification string > + * > + * User must calculate the total size of the structure and put it into > + * @size field, fill out the @id and desired @width. In return, kernel > + * fills out @master, @channel and @width. > + */ > +struct stp_policy_id { > + __u32 size; > + __u16 master; > + __u16 channel; > + __u16 width; > + /* padding */ > + __u16 __reserved_0; > + __u32 __reserved_1; > + char id[0]; > +}; > + > +#define STP_POLICY_ID_SET _IOWR('%', 0, struct stp_policy_id) > +#define STP_POLICY_ID_GET _IOR('%', 1, struct stp_policy_id) > +#define STP_SET_OPTIONS _IOW('%', 2, __u64) > + > +#endif /* _UAPI_LINUX_STM_H */ > -- > 2.1.4 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in > the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > Please read the FAQ at http://www.tux.org/lkml/ ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <CAAfSe-vOgnMXCy6fb8yuQ0O_5x1L1QtCmGjNjH+OtGAg6KJHrg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <CAAfSe-vOgnMXCy6fb8yuQ0O_5x1L1QtCmGjNjH+OtGAg6KJHrg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> @ 2015-07-29 13:25 ` Alexander Shishkin [not found] ` <877fpjkseh.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> 2015-07-30 3:19 ` Chunyan Zhang 0 siblings, 2 replies; 16+ messages in thread From: Alexander Shishkin @ 2015-07-29 13:25 UTC (permalink / raw) To: Chunyan Zhang Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api@vger.kernel.org, Chunyan Zhang, Mark Brown Chunyan Zhang <zhang.lyra-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes: >> +/** >> + * stm_source_register_device() - register an stm_source device >> + * @parent: parent device >> + * @data: device description structure >> + * >> + * This will create a device of stm_source class that can write >> + * data to an stm device once linked. >> + * >> + * Return: 0 on success, -errno otherwise. >> + */ >> +int stm_source_register_device(struct device *parent, >> + struct stm_source_data *data) >> +{ >> + struct stm_source_device *src; >> + int err; >> + >> + if (!stm_core_up) >> + return -EPROBE_DEFER; >> + > > I tried to update Coresight-stm driver[1] based on your this version > patch, but the Coresight-stm driver probe() failed. > the reason was: > In the end of Coresight stm_probe(), we called this function, but > "stm_core_up" was zero then, so the error returned value > "-EPROBE_DEFER" was received. Yes, that is the intended behavior if stm core is not initialized yet. > In fact, "stm_core_up" would increase itself until "stm_core_init" be > called - it's the root of this problem, I'll explain this where the > function "stm_core_init" defined. I'm sorry, I didn't understand this, can you rephrase? > And redoing Coresight stm_probe() will incur a WARN_ON() like below: > > [ 1.075746] coresight-stm 10006000.stm: stm_register_device failed > [ 1.082118] ------------[ cut here ]------------ > [ 1.086819] WARNING: CPU: 1 PID: 1 at drivers/clk/clk.c:657 > clk_core_disable+0x138/0x13c() > [ 1.095353] Modules linked in: > [ 1.098487] CPU: 1 PID: 1 Comm: swapper/0 Tainted: G S > 4.2.0-rc1+ #107 > [ 1.106398] Hardware name: Spreadtrum SC9836 Openphone Board (DT) > [ 1.112678] Call trace: > [ 1.115194] [<ffffffc00008a5b4>] dump_backtrace+0x0/0x138 > [ 1.120761] [<ffffffc00008a708>] show_stack+0x1c/0x28 > [ 1.125972] [<ffffffc0003320e0>] dump_stack+0x84/0xc8 > [ 1.131179] [<ffffffc00009b580>] warn_slowpath_common+0xa4/0xdc > [ 1.137285] [<ffffffc00009b700>] warn_slowpath_null+0x34/0x44 > [ 1.143213] [<ffffffc000321eb4>] clk_core_disable+0x134/0x13c Well, like I said in the offline thread, this has to do with cleaning up in the error path of stm_probe(). What happens if stm_probe() fails for any other reason? I'm guessing the same warning. >> +static int __init stm_core_init(void) >> +{ >> + int err; >> + >> + err = class_register(&stm_class); >> + if (err) >> + return err; >> + >> + err = class_register(&stm_source_class); >> + if (err) >> + goto err_stm; >> + >> + err = stp_configfs_init(); >> + if (err) >> + goto err_src; >> + >> + init_srcu_struct(&stm_source_srcu); >> + >> + stm_core_up++; >> + >> + return 0; >> + >> +err_src: >> + class_unregister(&stm_source_class); >> +err_stm: >> + class_unregister(&stm_class); >> + >> + return err; >> +} >> + >> +module_init(stm_core_init); > > Since you are using module_init() instead of postcore_initcall() which > was in the last version patch, as such, this function would be > executed after Coresight "stm_probe" finished. Yes, iirc on arm the initcall order somehow forced postcore stm_core_init() before configfs, which it relies on, causing a crash. Now I see that somebody hacked configfs to start at core_initcall (f5b697700c8) instead. There has to be a way to defer stm_probe(), although a quick look at amba code suggests it's not implemented. > So, we think there a few optional solutions: > 1) Remove the "stm_register_device" out from Coresight "stm_probe", > but we have to save another global variable: > > struct device *stm_dev; > > in the process of Coresight "stm_probe". Sorry, didn't understand this one. Except for I can say that having a global variable like that is a bad idea, but that's not relevant to the problem at hand. > 2) Change module_init() to other XYX_init() which would run prior to > "amba_probe()" (i.e. the caller of Coresight stm_probe), this may be a > better one. I'm really not a big fan of the initcall games, to be honest, it will always be a problem on some architecture or other. Having said that, if stm_core_init() runs at postcore_initcall level, does that solve your problem? > 3) stm_core_init() could be turned into a library call where > initialisation of the internals is done when first called. Well, it's not that simple: stm is used by both stm and stm_source devices, in this case we'll need to make sure that the first call to either of the {stm,stm_source}_register_device() results in the actual initialization of the stm core. I think it's a cleaner solution than the initcall games, though. Regards, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <877fpjkseh.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <877fpjkseh.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> @ 2015-07-29 13:35 ` Mark Brown [not found] ` <20150729133529.GI20130-GFdadSzt00ze9xe1eoZjHA@public.gmane.org> 0 siblings, 1 reply; 16+ messages in thread From: Mark Brown @ 2015-07-29 13:35 UTC (permalink / raw) To: Alexander Shishkin Cc: Chunyan Zhang, Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Chunyan Zhang [-- Attachment #1: Type: text/plain, Size: 337 bytes --] On Wed, Jul 29, 2015 at 04:25:10PM +0300, Alexander Shishkin wrote: > There has to be a way to defer stm_probe(), although a quick look at > amba code suggests it's not implemented. What makes you say this? Probe deferral is implemented in the driver core rather than individual buses, the buses don't need to know anything about it. [-- Attachment #2: Digital signature --] [-- Type: application/pgp-signature, Size: 473 bytes --] ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <20150729133529.GI20130-GFdadSzt00ze9xe1eoZjHA@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <20150729133529.GI20130-GFdadSzt00ze9xe1eoZjHA@public.gmane.org> @ 2015-07-29 13:46 ` Alexander Shishkin [not found] ` <871tfrkree.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> 0 siblings, 1 reply; 16+ messages in thread From: Alexander Shishkin @ 2015-07-29 13:46 UTC (permalink / raw) To: Mark Brown Cc: Chunyan Zhang, Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api@vger.kernel.org, Chunyan Zhang Mark Brown <broonie-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> writes: > On Wed, Jul 29, 2015 at 04:25:10PM +0300, Alexander Shishkin wrote: > >> There has to be a way to defer stm_probe(), although a quick look at >> amba code suggests it's not implemented. > > What makes you say this? Probe deferral is implemented in the driver > core rather than individual buses, the buses don't need to know anything > about it. I stand corrected, it indeed is. So returning EPROBE_DEFER from stm_probe() should Just Work (provided stm_probe() handles its error paths correctly). Regards, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <871tfrkree.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <871tfrkree.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> @ 2015-07-30 3:38 ` Chunyan Zhang [not found] ` <CAAfSe-sQjPHQQ7-jh-Xq6nR3O0gtP3AM4m=gGJjUE26rsbQDMQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 0 siblings, 1 reply; 16+ messages in thread From: Chunyan Zhang @ 2015-07-30 3:38 UTC (permalink / raw) To: Alexander Shishkin Cc: Mark Brown, Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Chunyan Zhang On Wed, Jul 29, 2015 at 9:46 PM, Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> wrote: > Mark Brown <broonie-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> writes: > >> On Wed, Jul 29, 2015 at 04:25:10PM +0300, Alexander Shishkin wrote: >> >>> There has to be a way to defer stm_probe(), although a quick look at >>> amba code suggests it's not implemented. >> >> What makes you say this? Probe deferral is implemented in the driver >> core rather than individual buses, the buses don't need to know anything >> about it. > > I stand corrected, it indeed is. > > So returning EPROBE_DEFER from stm_probe() should Just Work (provided > stm_probe() handles its error paths correctly). If let stm_probe() implement probe deferral, it has to have a global variable for the later calling of "stm_register_device", because the first parameter of "stm_register_device" is " struct device * " which comes from amba_probe(), after finished amba_probe(), we may not get this structure by other means. This was a similar policy that we both thought was not good :) > > Regards, > -- > Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <CAAfSe-sQjPHQQ7-jh-Xq6nR3O0gtP3AM4m=gGJjUE26rsbQDMQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <CAAfSe-sQjPHQQ7-jh-Xq6nR3O0gtP3AM4m=gGJjUE26rsbQDMQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> @ 2015-07-30 5:45 ` Alexander Shishkin [not found] ` <87zj2e9p25.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> 0 siblings, 1 reply; 16+ messages in thread From: Alexander Shishkin @ 2015-07-30 5:45 UTC (permalink / raw) To: Chunyan Zhang Cc: Mark Brown, Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api@vger.kernel.org, Chunyan Zhang Chunyan Zhang <zhang.lyra-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes: > If let stm_probe() implement probe deferral, it has to have a global > variable for the later calling of "stm_register_device", because the No, it doesn't. Please read about probe deferral. Regards, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <87zj2e9p25.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <87zj2e9p25.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> @ 2015-07-30 6:15 ` Chunyan Zhang 0 siblings, 0 replies; 16+ messages in thread From: Chunyan Zhang @ 2015-07-30 6:15 UTC (permalink / raw) To: Alexander Shishkin Cc: Mark Brown, Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Chunyan Zhang On Thu, Jul 30, 2015 at 1:45 PM, Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> wrote: > Chunyan Zhang <zhang.lyra-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes: > >> If let stm_probe() implement probe deferral, it has to have a global >> variable for the later calling of "stm_register_device", because the > > No, it doesn't. Please read about probe deferral. Could you please read my another email sent out today, I explained more details in that email. Thanks, Chunyan > > Regards, > -- > Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices 2015-07-29 13:25 ` Alexander Shishkin [not found] ` <877fpjkseh.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> @ 2015-07-30 3:19 ` Chunyan Zhang [not found] ` <CAAfSe-vgFSxA7OX7DSOB4XXdsan_3PWne0-16kSKZv_8HkHjgg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> 1 sibling, 1 reply; 16+ messages in thread From: Chunyan Zhang @ 2015-07-30 3:19 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, linux-api@vger.kernel.org, Chunyan Zhang, Mark Brown On Wed, Jul 29, 2015 at 9:25 PM, Alexander Shishkin <alexander.shishkin@linux.intel.com> wrote: > Chunyan Zhang <zhang.lyra@gmail.com> writes: > >>> +/** >>> + * stm_source_register_device() - register an stm_source device >>> + * @parent: parent device >>> + * @data: device description structure >>> + * >>> + * This will create a device of stm_source class that can write >>> + * data to an stm device once linked. >>> + * >>> + * Return: 0 on success, -errno otherwise. >>> + */ >>> +int stm_source_register_device(struct device *parent, >>> + struct stm_source_data *data) >>> +{ >>> + struct stm_source_device *src; >>> + int err; >>> + >>> + if (!stm_core_up) >>> + return -EPROBE_DEFER; >>> + >> >> I tried to update Coresight-stm driver[1] based on your this version >> patch, but the Coresight-stm driver probe() failed. >> the reason was: >> In the end of Coresight stm_probe(), we called this function, but >> "stm_core_up" was zero then, so the error returned value >> "-EPROBE_DEFER" was received. > > Yes, that is the intended behavior if stm core is not initialized yet. > >> In fact, "stm_core_up" would increase itself until "stm_core_init" be >> called - it's the root of this problem, I'll explain this where the >> function "stm_core_init" defined. > > I'm sorry, I didn't understand this, can you rephrase? Sure, I mean, the root reason of this problem is here ( i.e. "stm_core_up" was zero then): if (!stm_core_up) return -EPROBE_DEFER; Why it was zero? Because the function (i.e. stm_core_init() ) in which "stm_core_up" would be added one hasn't been executed at this moment. It would be executed on module_init stage for you this version of patch. > >> And redoing Coresight stm_probe() will incur a WARN_ON() like below: >> >> [ 1.075746] coresight-stm 10006000.stm: stm_register_device failed >> [ 1.082118] ------------[ cut here ]------------ >> [ 1.086819] WARNING: CPU: 1 PID: 1 at drivers/clk/clk.c:657 >> clk_core_disable+0x138/0x13c() >> [ 1.095353] Modules linked in: >> [ 1.098487] CPU: 1 PID: 1 Comm: swapper/0 Tainted: G S >> 4.2.0-rc1+ #107 >> [ 1.106398] Hardware name: Spreadtrum SC9836 Openphone Board (DT) >> [ 1.112678] Call trace: >> [ 1.115194] [<ffffffc00008a5b4>] dump_backtrace+0x0/0x138 >> [ 1.120761] [<ffffffc00008a708>] show_stack+0x1c/0x28 >> [ 1.125972] [<ffffffc0003320e0>] dump_stack+0x84/0xc8 >> [ 1.131179] [<ffffffc00009b580>] warn_slowpath_common+0xa4/0xdc >> [ 1.137285] [<ffffffc00009b700>] warn_slowpath_null+0x34/0x44 >> [ 1.143213] [<ffffffc000321eb4>] clk_core_disable+0x134/0x13c > > Well, like I said in the offline thread, this has to do with cleaning up > in the error path of stm_probe(). What happens if stm_probe() fails for > any other reason? I'm guessing the same warning. The reason of this warning is: After stm_probe() failed, clk_core_disable() would be called from amba_put_disable_pclk(), then WARN_ON() happened: if (WARN_ON(core->enable_count == 0)) return; I'm guessing the reason why "core->enable_count" was 0 at this moment is: I don't know who created a thread to process the amba_pm_runtime_suspend(), in which clk_core_disable() was already called, "core->enable_count" was, of course, cleared to zero then. And this thread run before amba_put_disable_pclk(pcdev) which is just the one called from amba_probe() after "->probe"(i.e. stm_probe in this case) returning a non-zero value. In a word, if clk_core_disable() is called again after "core->enable_count" has already been cleared to zero in the first round of clk_core_disable()'s. As such, the WARN_ON occurred. > >>> +static int __init stm_core_init(void) >>> +{ >>> + int err; >>> + >>> + err = class_register(&stm_class); >>> + if (err) >>> + return err; >>> + >>> + err = class_register(&stm_source_class); >>> + if (err) >>> + goto err_stm; >>> + >>> + err = stp_configfs_init(); >>> + if (err) >>> + goto err_src; >>> + >>> + init_srcu_struct(&stm_source_srcu); >>> + >>> + stm_core_up++; >>> + >>> + return 0; >>> + >>> +err_src: >>> + class_unregister(&stm_source_class); >>> +err_stm: >>> + class_unregister(&stm_class); >>> + >>> + return err; >>> +} >>> + >>> +module_init(stm_core_init); >> >> Since you are using module_init() instead of postcore_initcall() which >> was in the last version patch, as such, this function would be >> executed after Coresight "stm_probe" finished. > > Yes, iirc on arm the initcall order somehow forced postcore > stm_core_init() before configfs, which it relies on, causing a > crash. Now I see that somebody hacked configfs to start at core_initcall > (f5b697700c8) instead. > > There has to be a way to defer stm_probe(), although a quick look at > amba code suggests it's not implemented. > >> So, we think there a few optional solutions: >> 1) Remove the "stm_register_device" out from Coresight "stm_probe", >> but we have to save another global variable: >> >> struct device *stm_dev; >> >> in the process of Coresight "stm_probe". > > Sorry, didn't understand this one. > > Except for I can say that having a global variable like that is a bad > idea, but that's not relevant to the problem at hand. Agree, it's not a good policy :) > >> 2) Change module_init() to other XYX_init() which would run prior to >> "amba_probe()" (i.e. the caller of Coresight stm_probe), this may be a >> better one. > > I'm really not a big fan of the initcall games, to be honest, it will > always be a problem on some architecture or other. Having said that, if > stm_core_init() runs at postcore_initcall level, does that solve your > problem? Yes of course, what you were using in your last version of patch was just postcore_initcall(), and it works. > >> 3) stm_core_init() could be turned into a library call where >> initialisation of the internals is done when first called. > > Well, it's not that simple: stm is used by both stm and stm_source > devices, in this case we'll need to make sure that the first call to > either of the {stm,stm_source}_register_device() results in the actual > initialization of the stm core. I think it's a cleaner solution than the > initcall games, though. Ok, I see. Thanks, Chunyan > > Regards, > -- > Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <CAAfSe-vgFSxA7OX7DSOB4XXdsan_3PWne0-16kSKZv_8HkHjgg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <CAAfSe-vgFSxA7OX7DSOB4XXdsan_3PWne0-16kSKZv_8HkHjgg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org> @ 2015-07-30 6:37 ` Alexander Shishkin [not found] ` <87vbd29mm6.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> 0 siblings, 1 reply; 16+ messages in thread From: Alexander Shishkin @ 2015-07-30 6:37 UTC (permalink / raw) To: Chunyan Zhang Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api@vger.kernel.org, Chunyan Zhang, Mark Brown Chunyan Zhang <zhang.lyra-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes: > Sure, I mean, the root reason of this problem is here ( i.e. > "stm_core_up" was zero then): > if (!stm_core_up) > return -EPROBE_DEFER; > > Why it was zero? > Because the function (i.e. stm_core_init() ) in which "stm_core_up" > would be added one hasn't been executed at this moment. It would be > executed on module_init stage for you this version of patch. Again, this is the indented behavior. > The reason of this warning is: > After stm_probe() failed, clk_core_disable() would be called from > amba_put_disable_pclk(), then WARN_ON() happened: > if (WARN_ON(core->enable_count == 0)) > return; > > I'm guessing the reason why "core->enable_count" was 0 at this moment is: > I don't know who created a thread to process the > amba_pm_runtime_suspend(), in which clk_core_disable() was already > called, "core->enable_count" was, of course, cleared to zero then. > And this thread run before amba_put_disable_pclk(pcdev) which is just > the one called from amba_probe() after > "->probe"(i.e. stm_probe in this case) returning a non-zero value. No, this is guesswork. In amba_probe(), clocks are enabled for the drv->probe() and then disabled afterwards and that's where the refcount ends up unbalanced, the probe is the culprit. I can debug your driver for you but you'll at least need to put the code up somewhere so I can see it. Regards, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
[parent not found: <87vbd29mm6.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>]
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <87vbd29mm6.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org> @ 2015-07-30 6:59 ` Chunyan Zhang 2015-07-30 7:11 ` Chunyan Zhang 2015-07-30 7:16 ` Alexander Shishkin 0 siblings, 2 replies; 16+ messages in thread From: Chunyan Zhang @ 2015-07-30 6:59 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mathieu Poirier, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Chunyan Zhang, Mark Brown On Thu, Jul 30, 2015 at 2:37 PM, Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> wrote: > Chunyan Zhang <zhang.lyra-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes: > >> Sure, I mean, the root reason of this problem is here ( i.e. >> "stm_core_up" was zero then): >> if (!stm_core_up) >> return -EPROBE_DEFER; >> >> Why it was zero? >> Because the function (i.e. stm_core_init() ) in which "stm_core_up" >> would be added one hasn't been executed at this moment. It would be >> executed on module_init stage for you this version of patch. > > Again, this is the indented behavior. > >> The reason of this warning is: >> After stm_probe() failed, clk_core_disable() would be called from >> amba_put_disable_pclk(), then WARN_ON() happened: >> if (WARN_ON(core->enable_count == 0)) >> return; >> >> I'm guessing the reason why "core->enable_count" was 0 at this moment is: >> I don't know who created a thread to process the >> amba_pm_runtime_suspend(), in which clk_core_disable() was already >> called, "core->enable_count" was, of course, cleared to zero then. >> And this thread run before amba_put_disable_pclk(pcdev) which is just >> the one called from amba_probe() after >> "->probe"(i.e. stm_probe in this case) returning a non-zero value. > > No, this is guesswork. In amba_probe(), clocks are enabled for the > drv->probe() and then disabled afterwards and that's where the refcount > ends up unbalanced, the probe is the culprit. > > I can debug your driver for you but you'll at least need to put the code > up somewhere so I can see it. The code has already been submitted like I said in the earlier emails, you may refer [1]. Thanks, Chunyan [1] https://lkml.org/lkml/2015/2/4/729 > > Regards, > -- > Alex > ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices 2015-07-30 6:59 ` Chunyan Zhang @ 2015-07-30 7:11 ` Chunyan Zhang 2015-07-30 7:16 ` Alexander Shishkin 1 sibling, 0 replies; 16+ messages in thread From: Chunyan Zhang @ 2015-07-30 7:11 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, linux-api@vger.kernel.org, Chunyan Zhang, Mark Brown On Thu, Jul 30, 2015 at 2:59 PM, Chunyan Zhang <zhang.lyra@gmail.com> wrote: > On Thu, Jul 30, 2015 at 2:37 PM, Alexander Shishkin > <alexander.shishkin@linux.intel.com> wrote: >> Chunyan Zhang <zhang.lyra@gmail.com> writes: >> >>> Sure, I mean, the root reason of this problem is here ( i.e. >>> "stm_core_up" was zero then): >>> if (!stm_core_up) >>> return -EPROBE_DEFER; >>> >>> Why it was zero? >>> Because the function (i.e. stm_core_init() ) in which "stm_core_up" >>> would be added one hasn't been executed at this moment. It would be >>> executed on module_init stage for you this version of patch. >> >> Again, this is the indented behavior. >> >>> The reason of this warning is: >>> After stm_probe() failed, clk_core_disable() would be called from >>> amba_put_disable_pclk(), then WARN_ON() happened: >>> if (WARN_ON(core->enable_count == 0)) >>> return; >>> >>> I'm guessing the reason why "core->enable_count" was 0 at this moment is: >>> I don't know who created a thread to process the >>> amba_pm_runtime_suspend(), in which clk_core_disable() was already >>> called, "core->enable_count" was, of course, cleared to zero then. >>> And this thread run before amba_put_disable_pclk(pcdev) which is just >>> the one called from amba_probe() after >>> "->probe"(i.e. stm_probe in this case) returning a non-zero value. >> >> No, this is guesswork. In amba_probe(), clocks are enabled for the >> drv->probe() and then disabled afterwards and that's where the refcount >> ends up unbalanced, the probe is the culprit. >> >> I can debug your driver for you but you'll at least need to put the code >> up somewhere so I can see it. > > The code has already been submitted like I said in the earlier emails, > you may refer [1]. > > Thanks, > Chunyan > > [1] https://lkml.org/lkml/2015/2/4/729 Er, sorry, it's too old, I'll send out an updated version soon. Thanks for your patience, Chunyan > >> >> Regards, >> -- >> Alex >> ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices 2015-07-30 6:59 ` Chunyan Zhang 2015-07-30 7:11 ` Chunyan Zhang @ 2015-07-30 7:16 ` Alexander Shishkin 1 sibling, 0 replies; 16+ messages in thread From: Alexander Shishkin @ 2015-07-30 7:16 UTC (permalink / raw) To: Chunyan Zhang Cc: Greg Kroah-Hartman, linux-kernel@vger.kernel.org, Mathieu Poirier, peter.lachner, norbert.schulz, keven.boell, yann.fouassier, laurent.fert, linux-api@vger.kernel.org, Chunyan Zhang, Mark Brown Chunyan Zhang <zhang.lyra@gmail.com> writes: > The code has already been submitted like I said in the earlier emails, > you may refer [1]. > > Thanks, > Chunyan > > [1] https://lkml.org/lkml/2015/2/4/729 This code does the following (pasting from that patch): in stm_probe(): drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); ... something irrelevant ... ret = clk_prepare_enable(drvdata->clk); ... something irrelevant ... clk_disable_unprepare(drvdata->clk); ... something irrelevant ... drvdata->clk = adev->pclk; How is this supposed to even work? Regards, -- Alex ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices [not found] ` <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> 2015-07-29 4:21 ` Chunyan Zhang @ 2015-08-05 23:01 ` Mathieu Poirier 1 sibling, 0 replies; 16+ messages in thread From: Mathieu Poirier @ 2015-08-05 23:01 UTC (permalink / raw) To: Alexander Shishkin Cc: Greg Kroah-Hartman, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, peter.lachner-ral2JQCrhuEAvxtiuMwx3w, norbert.schulz-ral2JQCrhuEAvxtiuMwx3w, keven.boell-ral2JQCrhuEAvxtiuMwx3w, yann.fouassier-ral2JQCrhuEAvxtiuMwx3w, laurent.fert-ral2JQCrhuEAvxtiuMwx3w, linux-api-u79uwXL29TY76Z2rM5mHXA On 6 July 2015 at 04:08, Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> wrote: > A System Trace Module (STM) is a device exporting data in System Trace > Protocol (STP) format as defined by MIPI STP standards. Examples of such > devices are Intel Trace Hub and Coresight STM. > > This abstraction provides a unified interface for software trace sources > to send their data over an STM device to a debug host. In order to do > that, such a trace source needs to be assigned a pair of master/channel > identifiers that all the data from this source will be tagged with. The > STP decoder on the debug host side will use these master/channel tags to > distinguish different trace streams from one another inside one STP > stream. > > This abstraction provides a configfs-based policy management mechanism > for dynamic allocation of these master/channel pairs based on trace > source-supplied string identifier. It has the flexibility of being > defined at runtime and at the same time (provided that the policy > definition is aligned with the decoding end) consistency. > > For userspace trace sources, this abstraction provides write()-based and > mmap()-based (if the underlying stm device allows this) output mechanism. > > For kernel-side trace sources, we provide "stm_source" device class that > can be connected to an stm device at run time. > > Cc: linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org > Cc: Mathieu Poirier <mathieu.poirier-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org> > Signed-off-by: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > --- > Documentation/ABI/testing/configfs-stp-policy | 48 + > Documentation/ABI/testing/sysfs-class-stm | 14 + > Documentation/ABI/testing/sysfs-class-stm_source | 11 + > Documentation/ioctl/ioctl-number.txt | 3 + > Documentation/trace/stm.txt | 80 ++ > drivers/Kconfig | 2 + > drivers/Makefile | 1 + > drivers/hwtracing/stm/Kconfig | 8 + > drivers/hwtracing/stm/Makefile | 3 + > drivers/hwtracing/stm/core.c | 1029 ++++++++++++++++++++++ > drivers/hwtracing/stm/policy.c | 529 +++++++++++ > drivers/hwtracing/stm/stm.h | 87 ++ > include/linux/stm.h | 126 +++ > include/uapi/linux/stm.h | 50 ++ > 14 files changed, 1991 insertions(+) > create mode 100644 Documentation/ABI/testing/configfs-stp-policy > create mode 100644 Documentation/ABI/testing/sysfs-class-stm > create mode 100644 Documentation/ABI/testing/sysfs-class-stm_source > create mode 100644 Documentation/trace/stm.txt > create mode 100644 drivers/hwtracing/stm/Kconfig > create mode 100644 drivers/hwtracing/stm/Makefile > create mode 100644 drivers/hwtracing/stm/core.c > create mode 100644 drivers/hwtracing/stm/policy.c > create mode 100644 drivers/hwtracing/stm/stm.h > create mode 100644 include/linux/stm.h > create mode 100644 include/uapi/linux/stm.h > > diff --git a/Documentation/ABI/testing/configfs-stp-policy b/Documentation/ABI/testing/configfs-stp-policy > new file mode 100644 > index 0000000000..421ce6825c > --- /dev/null > +++ b/Documentation/ABI/testing/configfs-stp-policy > @@ -0,0 +1,48 @@ > +What: /config/stp-policy > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group contains policies mandating Master/Channel allocation > + for software sources wishing to send trace data over an STM > + device. > + > +What: /config/stp-policy/<device>.<policy> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + This group is the root of a policy; its name is a concatenation > + of an stm device name to which this policy applies and an > + arbitrary string. If <device> part doesn't match an existing > + stm device, mkdir will fail with ENODEV; if that device already > + has a policy assigned to it, mkdir will fail with EBUSY. > + > +What: /config/stp-policy/<device>.<policy>/device > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + STM device to which this policy applies, read only. Same as the > + <device> component of its parent directory. > + > +What: /config/stp-policy/<device>.<policy>/<node> > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Policy node is a string identifier that software clients will > + use to request a master/channel to be allocated and assigned to > + them. > + > +What: /config/stp-policy/<device>.<policy>/<node>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of masters from which to allocate for users of this node. > + Write two numbers: the first master and the last master number. > + > +What: /config/stp-policy/<device>.<policy>/<node>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Description: > + Range of channels from which to allocate for users of this node. > + Write two numbers: the first channel and the last channel > + number. > + > diff --git a/Documentation/ABI/testing/sysfs-class-stm b/Documentation/ABI/testing/sysfs-class-stm > new file mode 100644 > index 0000000000..c9aa4f3fc9 > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm > @@ -0,0 +1,14 @@ > +What: /sys/class/stm/<stm>/masters > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + Shows first and last available to software master numbers on > + this STM device. > + > +What: /sys/class/stm/<stm>/channels > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + Shows the number of channels per master on this STM device. > diff --git a/Documentation/ABI/testing/sysfs-class-stm_source b/Documentation/ABI/testing/sysfs-class-stm_source > new file mode 100644 > index 0000000000..57b8dd39bb > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-stm_source > @@ -0,0 +1,11 @@ > +What: /sys/class/stm_source/<stm_source>/stm_source_link > +Date: June 2015 > +KernelVersion: 4.3 > +Contact: Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > +Description: > + stm_source device linkage to stm device, where its tracing data > + is directed. Reads return an existing connection or "<none>" if > + this stm_source is not connected to any stm device yet. > + Write an existing (registered) stm device's name here to > + connect that device. If a device is already connected to this > + stm_source, it will first be disconnected. > diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt > index 611c52267d..7fa29b4ece 100644 > --- a/Documentation/ioctl/ioctl-number.txt > +++ b/Documentation/ioctl/ioctl-number.txt > @@ -81,6 +81,9 @@ Code Seq#(hex) Include File Comments > 0x22 all scsi/sg.h > '#' 00-3F IEEE 1394 Subsystem Block for the entire subsystem > '$' 00-0F linux/perf_counter.h, linux/perf_event.h > +'%' 00-0F include/uapi/linux/stm.h > + System Trace Module subsystem > + <mailto:alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> > '&' 00-07 drivers/firewire/nosy-user.h > '1' 00-1F <linux/timepps.h> PPS kit from Ulrich Windl > <ftp://ftp.de.kernel.org/pub/linux/daemons/ntp/PPS/> > diff --git a/Documentation/trace/stm.txt b/Documentation/trace/stm.txt > new file mode 100644 > index 0000000000..e140f2e8d7 > --- /dev/null > +++ b/Documentation/trace/stm.txt > @@ -0,0 +1,80 @@ > +System Trace Module > +=================== > + > +System Trace Module (STM) is a device described in MIPI STP specs as > +STP trace stream generator. STP (System Trace Protocol) is a trace > +protocol multiplexing data from multiple trace sources, each one of > +which is assigned a unique pair of master and channel. While some of > +these masters and channels are statically allocated to certain > +hardware trace sources, others are available to software. Software > +trace sources are usually free to pick for themselves any > +master/channel combination from this pool. > + > +On the receiving end of this STP stream (the decoder side), trace > +sources can only be identified by master/channel combination, so in > +order for the decoder to be able to make sense of the trace that > +involves multiple trace sources, it needs to be able to map those > +master/channel pairs to the trace sources that it understands. > + > +For instance, it is helpful to know that syslog messages come on > +master 7 channel 15, while arbitrary user applications can use masters > +48 to 63 and channels 0 to 127. > + > +To solve this mapping problem, stm class provides a policy management > +mechanism via configfs, that allows defining rules that map string > +identifiers to ranges of masters and channels. If these rules (policy) > +are consistent with what decoder expects, it will be able to properly > +process the trace data. > + > +This policy is a tree structure containing rules (policy_node) that > +have a name (string identifier) and a range of masters and channels > +associated with it, located in "stp-policy" subsystem directory in > +configfs. The topmost directory's name (the policy) is formatted as > +the STM device name to which this policy applies and and arbitrary > +string identifier separated by a stop. From the examle above, a rule > +may look like this: > + > +$ ls /config/stp-policy/dummy_stm.my-policy/user > +channels masters > +$ cat /config/stp-policy/dummy_stm.my-policy/user/masters > +48 63 > +$ cat /config/stp-policy/dummy_stm.my-policy/user/channels > +0 127 > + > +which means that the master allocation pool for this rule consists of > +masters 48 through 63 and channel allocation pool has channels 0 > +through 127 in it. Now, any producer (trace source) identifying itself > +with "user" identification string will be allocated a master and > +channel from within these ranges. > + > +These rules can be nested, for example, one can define a rule "dummy" > +under "user" directory from the example above and this new rule will > +be used for trace sources with the id string of "user/dummy". > + > +Trace sources have to open the stm class device's node and write their > +trace data into its file descriptor. In order to identify themselves > +to the policy, they need to do a STP_POLICY_ID_SET ioctl on this file > +descriptor providing their id string. Otherwise, they will be > +automatically allocated a master/channel pair upon first write to this > +file descriptor according to the "default" rule of the policy, if such > +exists. > + > +Some STM devices may allow direct mapping of the channel mmio regions > +to userspace for zero-copy writing. One mappable page (in terms of > +mmu) will usually contain multiple channels' mmios, so the user will > +need to allocate that many channels to themselves (via the > +aforementioned ioctl() call) to be able to do this. That is, if your > +stm device's channel mmio region is 64 bytes and hardware page size is > +4096 bytes, after a successful STP_POLICY_ID_SET ioctl() call with > +width==64, you should be able to mmap() one page on this file > +descriptor and obtain direct access to an mmio region for 64 channels. > + > +For kernel-based trace sources, there is "stm_source" device > +class. Devices of this class can be connected and disconnected to/from > +stm devices at runtime via a sysfs attribute. > + > +Examples of STM devices are Intel Trace Hub [1] and Coresight STM > +[2]. > + > +[1] https://software.intel.com/sites/default/files/managed/d3/3c/intel-th-developer-manual.pdf > +[2] http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0444b/index.html > diff --git a/drivers/Kconfig b/drivers/Kconfig > index 6e973b8e3a..96efe4522c 100644 > --- a/drivers/Kconfig > +++ b/drivers/Kconfig > @@ -184,4 +184,6 @@ source "drivers/android/Kconfig" > > source "drivers/nvdimm/Kconfig" > > +source "drivers/hwtracing/stm/Kconfig" > + > endmenu > diff --git a/drivers/Makefile b/drivers/Makefile > index b64b49f6e0..6647bc923f 100644 > --- a/drivers/Makefile > +++ b/drivers/Makefile > @@ -164,4 +164,5 @@ obj-$(CONFIG_MCB) += mcb/ > obj-$(CONFIG_RAS) += ras/ > obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ > obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ > +obj-$(CONFIG_STM) += hwtracing/stm/ > obj-$(CONFIG_ANDROID) += android/ > diff --git a/drivers/hwtracing/stm/Kconfig b/drivers/hwtracing/stm/Kconfig > new file mode 100644 > index 0000000000..90ed327461 > --- /dev/null > +++ b/drivers/hwtracing/stm/Kconfig > @@ -0,0 +1,8 @@ > +config STM > + tristate "System Trace Module devices" > + help > + A System Trace Module (STM) is a device exporting data in System > + Trace Protocol (STP) format as defined by MIPI STP standards. > + Examples of such devices are Intel Trace Hub and Coresight STM. > + > + Say Y here to enable System Trace Module device support. > diff --git a/drivers/hwtracing/stm/Makefile b/drivers/hwtracing/stm/Makefile > new file mode 100644 > index 0000000000..adec701649 > --- /dev/null > +++ b/drivers/hwtracing/stm/Makefile > @@ -0,0 +1,3 @@ > +obj-$(CONFIG_STM) += stm_core.o > + > +stm_core-y := core.o policy.o > diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c > new file mode 100644 > index 0000000000..b79c42c625 > --- /dev/null > +++ b/drivers/hwtracing/stm/core.c > @@ -0,0 +1,1029 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#include <linux/uaccess.h> > +#include <linux/kernel.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/compat.h> > +#include <linux/kdev_t.h> > +#include <linux/srcu.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include <linux/fs.h> > +#include <linux/mm.h> > +#include "stm.h" > + > +#include <uapi/linux/stm.h> > + > +static unsigned int stm_core_up; > + > +/* > + * The SRCU here makes sure that STM device doesn't disappear from under a > + * stm_source_write() caller, which may want to have as little overhead as > + * possible. > + */ > +static struct srcu_struct stm_source_srcu; > + > +static ssize_t masters_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(masters); > + > +static ssize_t channels_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_device *stm = to_stm_device(dev); > + int ret; > + > + ret = sprintf(buf, "%u\n", stm->data->sw_nchannels); > + > + return ret; > +} > + > +static DEVICE_ATTR_RO(channels); > + > +static struct attribute *stm_attrs[] = { > + &dev_attr_masters.attr, > + &dev_attr_channels.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm); > + > +static struct class stm_class = { > + .name = "stm", > + .dev_groups = stm_groups, > +}; > + > +static int stm_dev_match(struct device *dev, const void *data) > +{ > + const char *name = data; > + > + return sysfs_streq(name, dev_name(dev)); > +} > + > +/** > + * stm_find_device() - find stm device by name > + * @buf: character buffer containing the name > + * > + * This is called when either policy gets assigned to an stm device or an > + * stm_source device gets linked to an stm device. > + * > + * This grabs device's reference (get_device()) and module reference, both > + * of which the calling path needs to make sure to drop with stm_put_device(). > + * > + * Return: stm device pointer or null if lookup failed. > + */ > +struct stm_device *stm_find_device(const char *buf) > +{ > + struct stm_device *stm; > + struct device *dev; > + > + if (!stm_core_up) > + return NULL; > + > + dev = class_find_device(&stm_class, NULL, buf, stm_dev_match); > + if (!dev) > + return NULL; > + > + stm = to_stm_device(dev); > + if (!try_module_get(stm->owner)) { > + put_device(dev); > + return NULL; > + } > + > + return stm; > +} > + > +/** > + * stm_put_device() - drop references on the stm device > + * @stm: stm device, previously acquired by stm_find_device() > + * > + * This drops the module reference and device reference taken by > + * stm_find_device(). > + */ > +void stm_put_device(struct stm_device *stm) > +{ > + module_put(stm->owner); > + put_device(&stm->dev); > +} > + > +/* > + * Internally we only care about software-writable masters here, that is the > + * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need > + * original master numbers to be visible externally, since they are the ones > + * that will appear in the STP stream. Thus, the internal bookkeeping uses > + * $master - stm_data->sw_start to reference master descriptors and such. > + */ > + > +#define __stm_master(_s, _m) \ > + ((_s)->masters[(_m) - (_s)->data->sw_start]) > + > +static inline struct stp_master * > +stm_master(struct stm_device *stm, unsigned int idx) > +{ > + if (idx < stm->data->sw_start || idx > stm->data->sw_end) > + return NULL; > + > + return __stm_master(stm, idx); > +} > + > +static int stp_master_alloc(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master; > + size_t size; > + > + size = ALIGN(stm->data->sw_nchannels, 8) / 8; > + size += sizeof(struct stp_master); > + master = kzalloc(size, GFP_ATOMIC); > + if (!master) > + return -ENOMEM; > + > + master->nr_free = stm->data->sw_nchannels; > + __stm_master(stm, idx) = master; > + > + return 0; > +} > + > +static void stp_master_free(struct stm_device *stm, unsigned int idx) > +{ > + struct stp_master *master = stm_master(stm, idx); > + > + if (!master) > + return; > + > + __stm_master(stm, idx) = NULL; > + kfree(master); > +} > + > +static void stm_output_claim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + if (WARN_ON_ONCE(master->nr_free < output->nr_chans)) > + return; > + > + bitmap_allocate_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + master->nr_free -= output->nr_chans; > +} > + > +static void > +stm_output_disclaim(struct stm_device *stm, struct stm_output *output) > +{ > + struct stp_master *master = stm_master(stm, output->master); > + > + bitmap_release_region(&master->chan_map[0], output->channel, > + ilog2(output->nr_chans)); > + > + output->nr_chans = 0; > + master->nr_free += output->nr_chans; > +} > + > +/* > + * This is like bitmap_find_free_region(), except it can ignore @start bits > + * at the beginning. > + */ > +static int find_free_channels(unsigned long *bitmap, unsigned int start, > + unsigned int end, unsigned int width) > +{ > + unsigned int pos; > + int i; > + > + for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) { > + pos = find_next_zero_bit(bitmap, end + 1, pos); > + if (pos + width > end + 1) > + break; > + > + if (pos & (width - 1)) > + continue; > + > + for (i = 1; i < width && !test_bit(pos + i, bitmap); i++) > + ; > + if (i == width) > + return pos; > + } > + > + return -1; > +} > + > +static unsigned int > +stm_find_master_chan(struct stm_device *stm, unsigned int width, > + unsigned int *mstart, unsigned int mend, > + unsigned int *cstart, unsigned int cend) > +{ > + struct stp_master *master; > + unsigned int midx; > + int pos, err; > + > + for (midx = *mstart; midx <= mend; midx++) { > + if (!stm_master(stm, midx)) { > + err = stp_master_alloc(stm, midx); > + if (err) > + return err; > + } > + > + master = stm_master(stm, midx); > + > + if (!master->nr_free) > + continue; > + > + pos = find_free_channels(master->chan_map, *cstart, cend, > + width); > + if (pos < 0) > + continue; > + > + *mstart = midx; > + *cstart = pos; > + return 0; > + } > + > + return -ENOSPC; > +} > + > +static int stm_output_assign(struct stm_device *stm, unsigned int width, > + struct stp_policy_node *policy_node, > + struct stm_output *output) > +{ > + unsigned int midx, cidx, mend, cend; > + int ret = -EINVAL; > + > + if (width > stm->data->sw_nchannels) > + return -EINVAL; > + > + if (policy_node) { > + stp_policy_node_get_ranges(policy_node, > + &midx, &mend, &cidx, &cend); > + } else { > + midx = stm->data->sw_start; > + cidx = 0; > + mend = stm->data->sw_end; > + cend = stm->data->sw_nchannels - 1; > + } > + > + spin_lock(&stm->mc_lock); > + /* output is already assigned -- shouldn't happen */ > + if (WARN_ON_ONCE(output->nr_chans)) > + goto unlock; > + > + ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend); > + if (ret) > + goto unlock; > + > + output->master = midx; > + output->channel = cidx; > + output->nr_chans = width; > + stm_output_claim(stm, output); > + dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width); > + > + ret = 0; > +unlock: > + spin_unlock(&stm->mc_lock); > + > + return ret; > +} > + > +static void stm_output_free(struct stm_device *stm, struct stm_output *output) > +{ > + spin_lock(&stm->mc_lock); > + if (output->nr_chans) > + stm_output_disclaim(stm, output); > + spin_unlock(&stm->mc_lock); > +} > + > +static int major_match(struct device *dev, const void *data) > +{ > + unsigned int major = *(unsigned int *)data; > + > + return MAJOR(dev->devt) == major; > +} > + > +static int stm_char_open(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf; > + struct device *dev; > + unsigned int major = imajor(inode); > + int err = -ENODEV; > + > + dev = class_find_device(&stm_class, NULL, &major, major_match); > + if (!dev) > + return -ENODEV; > + > + stmf = kzalloc(sizeof(*stmf), GFP_KERNEL); > + if (!stmf) > + return -ENOMEM; > + > + stmf->stm = to_stm_device(dev); > + > + if (!try_module_get(stmf->stm->owner)) > + goto err_free; > + > + file->private_data = stmf; > + > + return nonseekable_open(inode, file); > + > +err_free: > + kfree(stmf); > + > + return err; > +} > + > +static int stm_char_release(struct inode *inode, struct file *file) > +{ > + struct stm_file *stmf = file->private_data; > + > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + kfree(stmf); > + > + return 0; > +} > + > +static int stm_file_assign(struct stm_file *stmf, char *id, unsigned int width) > +{ > + struct stm_device *stm = stmf->stm; > + int ret; > + > + stmf->policy_node = stp_policy_node_lookup(stm, id); > + > + ret = stm_output_assign(stm, width, stmf->policy_node, &stmf->output); > + > + if (stmf->policy_node) > + stp_policy_node_put(stmf->policy_node); > + > + return ret; > +} > + > +static void stm_write(struct stm_data *data, unsigned int master, > + unsigned int channel, const char *buf, size_t count) > +{ > + unsigned int flags = STP_PACKET_TIMESTAMPED; > + const unsigned char *p = buf, nil = 0; > + size_t pos; > + ssize_t sz; > + > + for (pos = 0, p = buf; count > pos; pos += sz, p += sz) { > + sz = min_t(unsigned int, count - pos, 8); > + sz = data->packet(data, master, channel, STP_PACKET_DATA, flags, > + sz, p); > + flags = 0; > + } > + > + data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil); > +} > + > +static ssize_t stm_char_write(struct file *file, const char __user *buf, > + size_t count, loff_t *ppos) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + char *kbuf; > + int err; > + > + /* > + * if no m/c have been assigned to this writer up to this > + * point, use "default" policy entry > + */ > + if (!stmf->output.nr_chans) { > + err = stm_file_assign(stmf, "default", 1); > + /* > + * EBUSY means that somebody else just assigned this > + * output, which is just fine for write() > + */ > + if (err && err != -EBUSY) > + return err; > + } > + > + kbuf = kmalloc(count + 1, GFP_KERNEL); > + if (!kbuf) > + return -ENOMEM; > + > + err = copy_from_user(kbuf, buf, count); > + if (err) { > + kfree(kbuf); > + return -EFAULT; > + } > + > + stm_write(stm->data, stmf->output.master, stmf->output.channel, kbuf, > + count); > + > + kfree(kbuf); > + > + return count; > +} > + > +static int stm_char_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_device *stm = stmf->stm; > + unsigned long size, phys; > + > + if (!stm->data->mmio_addr) > + return -EOPNOTSUPP; > + > + if (vma->vm_pgoff) > + return -EINVAL; > + > + size = vma->vm_end - vma->vm_start; > + > + if (stmf->output.nr_chans * stm->data->sw_mmiosz != size) > + return -EINVAL; > + > + phys = stm->data->mmio_addr(stm->data, stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans); > + > + if (!phys) > + return -EINVAL; > + > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP; > + vm_iomap_memory(vma, phys, size); > + > + return 0; > +} > + > +static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stm_device *stm = stmf->stm; > + struct stp_policy_id *id; > + int ret = -EINVAL; > + u32 size; > + > + if (stmf->output.nr_chans) > + return -EBUSY; > + > + if (copy_from_user(&size, arg, sizeof(size))) > + return -EFAULT; > + > + if (size >= PATH_MAX + sizeof(*id)) > + return -EINVAL; > + > + /* > + * size + 1 to make sure the .id string at the bottom is terminated, > + * which is also why memdup_user() is not useful here > + */ > + id = kzalloc(size + 1, GFP_KERNEL); > + if (!id) > + return -ENOMEM; > + > + if (copy_from_user(id, arg, size)) { > + ret = -EFAULT; > + goto err_free; > + } > + > + if (id->__reserved_0 || id->__reserved_1) > + goto err_free; > + > + if (id->width < 1 || > + id->width > PAGE_SIZE / stm->data->sw_mmiosz) > + goto err_free; > + > + ret = stm_file_assign(stmf, id->id, id->width); > + if (ret) > + goto err_free; > + > + ret = 0; > + > + if (stm->data->link) > + ret = stm->data->link(stm->data, stmf->output.master, > + stmf->output.channel); > + > + if (ret) { > + stm_output_free(stmf->stm, &stmf->output); > + stm_put_device(stmf->stm); > + } > + > +err_free: > + kfree(id); > + > + return ret; > +} > + > +static int stm_char_policy_get_ioctl(struct stm_file *stmf, void __user *arg) > +{ > + struct stp_policy_id id = { > + .size = sizeof(id), > + .master = stmf->output.master, > + .channel = stmf->output.channel, > + .width = stmf->output.nr_chans, > + .__reserved_0 = 0, > + .__reserved_1 = 0, > + }; > + > + return copy_to_user(arg, &id, id.size) ? -EFAULT : 0; > +} > + > +static long > +stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + struct stm_file *stmf = file->private_data; > + struct stm_data *stm_data = stmf->stm->data; > + int err = -ENOTTY; > + u64 options; > + > + switch (cmd) { > + case STP_POLICY_ID_SET: > + err = stm_char_policy_set_ioctl(stmf, (void __user *)arg); > + if (err) > + return err; > + > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_POLICY_ID_GET: > + return stm_char_policy_get_ioctl(stmf, (void __user *)arg); > + > + case STP_SET_OPTIONS: > + if (copy_from_user(&options, (u64 __user *)arg, sizeof(u64))) > + return -EFAULT; > + > + if (stm_data->set_options) > + err = stm_data->set_options(stm_data, > + stmf->output.master, > + stmf->output.channel, > + stmf->output.nr_chans, > + options); > + > + break; > + default: > + break; > + } > + > + return err; > +} > + > +#ifdef CONFIG_COMPAT > +static long > +stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > +{ > + return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); > +} > +#else > +#define stm_char_compat_ioctl NULL > +#endif > + > +static const struct file_operations stm_fops = { > + .open = stm_char_open, > + .release = stm_char_release, > + .write = stm_char_write, > + .mmap = stm_char_mmap, > + .unlocked_ioctl = stm_char_ioctl, > + .compat_ioctl = stm_char_compat_ioctl, > + .llseek = no_llseek, > +}; > + > +static void stm_device_release(struct device *dev) > +{ > + struct stm_device *stm = to_stm_device(dev); > + > + kfree(stm); > +} > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner) > +{ > + struct stm_device *stm; > + unsigned int nmasters; > + int err = -ENOMEM; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + > + if (!stm_data->packet || !stm_data->sw_nchannels) > + return -EINVAL; > + > + nmasters = stm_data->sw_end - stm_data->sw_start; > + stm = kzalloc(sizeof(*stm) + nmasters * sizeof(void *), GFP_KERNEL); > + if (!stm) > + return -ENOMEM; > + > + stm->major = register_chrdev(0, stm_data->name, &stm_fops); > + if (stm->major < 0) > + goto err_free; > + > + device_initialize(&stm->dev); > + stm->dev.devt = MKDEV(stm->major, 0); > + stm->dev.class = &stm_class; > + stm->dev.parent = parent; > + stm->dev.release = stm_device_release; > + > + err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name); > + if (err) > + goto err_device; > + > + err = device_add(&stm->dev); > + if (err) > + goto err_device; > + > + spin_lock_init(&stm->link_lock); > + INIT_LIST_HEAD(&stm->link_list); > + > + spin_lock_init(&stm->mc_lock); > + mutex_init(&stm->policy_mutex); > + stm->sw_nmasters = nmasters; > + stm->owner = owner; > + stm->data = stm_data; > + stm_data->stm = stm; > + > + return 0; > + > +err_device: > + put_device(&stm->dev); > +err_free: > + kfree(stm); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_register_device); > + > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm); > + > +void stm_unregister_device(struct stm_data *stm_data) > +{ > + struct stm_device *stm = stm_data->stm; > + struct stm_source_device *src, *iter; > + int i; > + > + spin_lock(&stm->link_lock); > + list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) { > + __stm_source_link_drop(src, stm); > + } > + spin_unlock(&stm->link_lock); > + > + synchronize_srcu(&stm_source_srcu); > + > + unregister_chrdev(stm->major, stm_data->name); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + stp_policy_unbind(stm->policy); > + mutex_unlock(&stm->policy_mutex); > + > + for (i = 0; i < stm->sw_nmasters; i++) > + stp_master_free(stm, i); > + > + device_unregister(&stm->dev); > + stm_data->stm = NULL; > +} > +EXPORT_SYMBOL_GPL(stm_unregister_device); > + > +/** > + * stm_source_link_add() - connect an stm_source device to an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * This function establishes a link from stm_source to an stm device so that > + * the former can send out trace data to the latter. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +static int stm_source_link_add(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + char *id; > + int err; > + > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + /* src->link is dereferenced under stm_source_srcu but not the list */ > + rcu_assign_pointer(src->link, stm); > + list_add_tail(&src->link_entry, &stm->link_list); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + id = kstrdup(src->data->name, GFP_KERNEL); > + if (id) { > + src->policy_node = > + stp_policy_node_lookup(stm, id); > + > + kfree(id); > + } > + > + err = stm_output_assign(stm, src->data->nr_chans, > + src->policy_node, &src->output); > + > + if (src->policy_node) > + stp_policy_node_put(src->policy_node); > + > + if (err) > + goto fail_detach; > + > + /* this is to notify the STM device that a new link has been made */ > + if (stm->data->link) > + err = stm->data->link(stm->data, src->output.master, > + src->output.channel); > + > + if (err) > + goto fail_free_output; > + > + /* this is to let the source carry out all necessary preparations */ > + if (src->data->link) > + src->data->link(src->data); > + > + return 0; > + > +fail_free_output: > + stm_output_free(stm, &src->output); > + stm_put_device(stm); > + > +fail_detach: > + spin_lock(&stm->link_lock); > + spin_lock(&src->link_lock); > + > + rcu_assign_pointer(src->link, NULL); > + list_del_init(&src->link_entry); > + > + spin_unlock(&src->link_lock); > + spin_unlock(&stm->link_lock); > + > + return err; > +} > + > +/** > + * __stm_source_link_drop() - detach stm_source from an stm device > + * @src: stm_source device > + * @stm: stm device > + * > + * If @stm is @src::link, disconnect them from one another and put the > + * reference on the @stm device. > + * > + * Caller must hold stm::link_lock. > + */ > +static void __stm_source_link_drop(struct stm_source_device *src, > + struct stm_device *stm) > +{ > + spin_lock(&src->link_lock); > + if (WARN_ON_ONCE(src->link != stm)) { > + spin_unlock(&src->link_lock); > + return; > + } > + > + stm_output_free(src->link, &src->output); > + /* caller must hold stm::link_lock */ > + list_del_init(&src->link_entry); > + /* matches stm_find_device() from stm_source_link_store() */ > + stm_put_device(src->link); > + rcu_assign_pointer(src->link, NULL); > + > + spin_unlock(&src->link_lock); > +} > + > +/** > + * stm_source_link_drop() - detach stm_source from its stm device > + * @src: stm_source device > + * > + * Unlinking means disconnecting from source's STM device; after this > + * writes will be unsuccessful until it is linked to a new STM device. > + * > + * This will happen on "stm_source_link" sysfs attribute write to undo > + * the existing link (if any), or on linked STM device's de-registration. > + */ > +static void stm_source_link_drop(struct stm_source_device *src) > +{ > + struct stm_device *stm; > + int idx; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + > + if (stm) { > + if (src->data->unlink) > + src->data->unlink(src->data); > + > + spin_lock(&stm->link_lock); > + __stm_source_link_drop(src, stm); > + spin_unlock(&stm->link_lock); > + } > + > + srcu_read_unlock(&stm_source_srcu, idx); > +} > + > +static ssize_t stm_source_link_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *stm; > + int idx, ret; > + > + idx = srcu_read_lock(&stm_source_srcu); > + stm = srcu_dereference(src->link, &stm_source_srcu); > + ret = sprintf(buf, "%s\n", > + stm ? dev_name(&stm->dev) : "<none>"); > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return ret; > +} > + > +static ssize_t stm_source_link_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + struct stm_device *link; > + int err; > + > + stm_source_link_drop(src); > + > + link = stm_find_device(buf); > + if (!link) > + return -EINVAL; > + > + err = stm_source_link_add(src, link); > + if (err) > + stm_put_device(link); > + > + return err ? : count; > +} > + > +static DEVICE_ATTR_RW(stm_source_link); > + > +static struct attribute *stm_source_attrs[] = { > + &dev_attr_stm_source_link.attr, > + NULL, > +}; > + > +ATTRIBUTE_GROUPS(stm_source); > + > +static struct class stm_source_class = { > + .name = "stm_source", > + .dev_groups = stm_source_groups, > +}; > + > +static void stm_source_device_release(struct device *dev) > +{ > + struct stm_source_device *src = to_stm_source_device(dev); > + > + kfree(src); > +} > + > +/** > + * stm_source_register_device() - register an stm_source device > + * @parent: parent device > + * @data: device description structure > + * > + * This will create a device of stm_source class that can write > + * data to an stm device once linked. > + * > + * Return: 0 on success, -errno otherwise. > + */ > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data) > +{ > + struct stm_source_device *src; > + int err; > + > + if (!stm_core_up) > + return -EPROBE_DEFER; > + > + src = kzalloc(sizeof(*src), GFP_KERNEL); > + if (!src) > + return -ENOMEM; > + > + device_initialize(&src->dev); > + src->dev.class = &stm_source_class; > + src->dev.parent = parent; > + src->dev.release = stm_source_device_release; > + > + err = kobject_set_name(&src->dev.kobj, "%s", data->name); > + if (err) > + goto err; > + > + err = device_add(&src->dev); > + if (err) > + goto err; > + > + spin_lock_init(&src->link_lock); > + INIT_LIST_HEAD(&src->link_entry); > + src->data = data; > + data->src = src; > + > + return 0; > + > +err: > + put_device(&src->dev); > + kfree(src); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(stm_source_register_device); > + > +/** > + * stm_source_unregister_device() - unregister an stm_source device > + * @data: device description that was used to register the device > + * > + * This will remove a previously created stm_source device from the system. > + */ > +void stm_source_unregister_device(struct stm_source_data *data) > +{ > + struct stm_source_device *src = data->src; > + > + stm_source_link_drop(src); > + > + device_destroy(&stm_source_class, src->dev.devt); > +} > +EXPORT_SYMBOL_GPL(stm_source_unregister_device); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count) > +{ > + struct stm_source_device *src = data->src; > + struct stm_device *stm; > + int idx; > + > + if (!src->output.nr_chans) > + return -ENODEV; > + > + if (chan >= src->output.nr_chans) > + return -EINVAL; > + > + idx = srcu_read_lock(&stm_source_srcu); > + > + stm = srcu_dereference(src->link, &stm_source_srcu); > + if (stm) > + stm_write(stm->data, src->output.master, > + src->output.channel + chan, > + buf, count); > + else > + count = -ENODEV; > + > + srcu_read_unlock(&stm_source_srcu, idx); > + > + return count; > +} > +EXPORT_SYMBOL_GPL(stm_source_write); > + > +static int __init stm_core_init(void) > +{ > + int err; > + > + err = class_register(&stm_class); > + if (err) > + return err; > + > + err = class_register(&stm_source_class); > + if (err) > + goto err_stm; > + > + err = stp_configfs_init(); > + if (err) > + goto err_src; > + > + init_srcu_struct(&stm_source_srcu); > + > + stm_core_up++; > + > + return 0; > + > +err_src: > + class_unregister(&stm_source_class); > +err_stm: > + class_unregister(&stm_class); > + > + return err; > +} > + > +module_init(stm_core_init); > + > +static void __exit stm_core_exit(void) > +{ > + cleanup_srcu_struct(&stm_source_srcu); > + class_unregister(&stm_source_class); > + class_unregister(&stm_class); > + stp_configfs_exit(); > +} > + > +module_exit(stm_core_exit); > + > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("System Trace Module device class"); > +MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org>"); > diff --git a/drivers/hwtracing/stm/policy.c b/drivers/hwtracing/stm/policy.c > new file mode 100644 > index 0000000000..6498a9dbb7 > --- /dev/null > +++ b/drivers/hwtracing/stm/policy.c > @@ -0,0 +1,529 @@ > +/* > + * System Trace Module (STM) master/channel allocation policy management > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * A master/channel allocation policy allows mapping string identifiers to > + * master and channel ranges, where allocation can be done. > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt > + > +#include <linux/types.h> > +#include <linux/module.h> > +#include <linux/device.h> > +#include <linux/configfs.h> > +#include <linux/slab.h> > +#include <linux/stm.h> > +#include "stm.h" > + > +/* > + * STP Master/Channel allocation policy configfs layout. > + */ > + > +struct stp_policy { > + struct config_group group; > + struct stm_device *stm; > +}; > + > +struct stp_policy_node { > + struct config_group group; > + struct stp_policy *policy; > + unsigned int first_master; > + unsigned int last_master; > + unsigned int first_channel; > + unsigned int last_channel; > +}; > + > +static struct configfs_subsystem stp_policy_subsys; > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend) > +{ > + *mstart = policy_node->first_master; > + *mend = policy_node->last_master; > + *cstart = policy_node->first_channel; > + *cend = policy_node->last_channel; > +} > + > +static inline char *stp_policy_node_name(struct stp_policy_node *policy_node) > +{ > + return policy_node->group.cg_item.ci_name ? : "<none>"; > +} > + > +static inline struct stp_policy *to_stp_policy(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy, group) : > + NULL; > +} > + > +static inline struct stp_policy_node * > +to_stp_policy_node(struct config_item *item) > +{ > + return item ? > + container_of(to_config_group(item), struct stp_policy_node, > + group) : > + NULL; > +} > + > +static ssize_t stp_policy_node_masters_show(struct stp_policy_node *policy_node, > + char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_master, > + policy_node->last_master); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_masters_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + /* must be within [sw_start..sw_end], which is an inclusive range */ > + if (first > INT_MAX || last > INT_MAX || first > last || > + first < stm->data->sw_start || > + last > stm->data->sw_end) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_master = first; > + policy_node->last_master = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static ssize_t > +stp_policy_node_channels_show(struct stp_policy_node *policy_node, char *page) > +{ > + ssize_t count; > + > + count = sprintf(page, "%u %u\n", policy_node->first_channel, > + policy_node->last_channel); > + > + return count; > +} > + > +static ssize_t > +stp_policy_node_channels_store(struct stp_policy_node *policy_node, > + const char *page, size_t count) > +{ > + unsigned int first, last; > + struct stm_device *stm; > + char *p = (char *)page; > + ssize_t ret = -ENODEV; > + > + if (sscanf(p, "%u %u", &first, &last) != 2) > + return -EINVAL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + stm = policy_node->policy->stm; > + if (!stm) > + goto unlock; > + > + if (first > INT_MAX || last > INT_MAX || first > last || > + last >= stm->data->sw_nchannels) { > + ret = -ERANGE; > + goto unlock; > + } > + > + ret = count; > + policy_node->first_channel = first; > + policy_node->last_channel = last; > + > +unlock: > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return ret; > +} > + > +static void stp_policy_node_release(struct config_item *item) > +{ > + kfree(to_stp_policy_node(item)); > +} > + > +struct stp_policy_node_attribute { > + struct configfs_attribute attr; > + ssize_t (*show)(struct stp_policy_node *, char *); > + ssize_t (*store)(struct stp_policy_node *, const char *, size_t); > +}; > + > +static ssize_t stp_policy_node_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = 0; > + > + if (pn_attr->show) > + count = pn_attr->show(policy_node, page); > + > + return count; > +} > + > +static ssize_t stp_policy_node_attr_store(struct config_item *item, > + struct configfs_attribute *attr, > + const char *page, size_t len) > +{ > + struct stp_policy_node *policy_node = to_stp_policy_node(item); > + struct stp_policy_node_attribute *pn_attr = > + container_of(attr, struct stp_policy_node_attribute, attr); > + ssize_t count = -EINVAL; > + > + if (pn_attr->store) > + count = pn_attr->store(policy_node, page, len); > + > + return count; > +} > + > +static struct configfs_item_operations stp_policy_node_item_ops = { > + .release = stp_policy_node_release, > + .show_attribute = stp_policy_node_attr_show, > + .store_attribute = stp_policy_node_attr_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_range = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "masters", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_masters_show, > + .store = stp_policy_node_masters_store, > +}; > + > +static struct stp_policy_node_attribute stp_policy_node_attr_channels = { > + .attr = { > + .ca_owner = THIS_MODULE, > + .ca_name = "channels", > + .ca_mode = S_IRUGO | S_IWUSR, > + }, > + .show = stp_policy_node_channels_show, > + .store = stp_policy_node_channels_store, > +}; > + > +static struct configfs_attribute *stp_policy_node_attrs[] = { > + &stp_policy_node_attr_range.attr, > + &stp_policy_node_attr_channels.attr, > + NULL, > +}; > + > +static struct config_item_type stp_policy_type; > +static struct config_item_type stp_policy_node_type; > + > +static struct config_group * > +stp_policy_node_make(struct config_group *group, const char *name) > +{ > + struct stp_policy_node *policy_node, *parent_node; > + struct stp_policy *policy; > + > + if (group->cg_item.ci_type == &stp_policy_type) { > + policy = container_of(group, struct stp_policy, group); > + } else { > + parent_node = container_of(group, struct stp_policy_node, > + group); > + policy = parent_node->policy; > + } > + > + if (!policy->stm) > + return ERR_PTR(-ENODEV); > + > + policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL); > + if (!policy_node) > + return ERR_PTR(-ENOMEM); > + > + config_group_init_type_name(&policy_node->group, name, > + &stp_policy_node_type); > + > + policy_node->policy = policy; > + > + /* default values for the attributes */ > + policy_node->first_master = policy->stm->data->sw_start; > + policy_node->last_master = policy->stm->data->sw_end; > + policy_node->first_channel = 0; > + policy_node->last_channel = policy->stm->data->sw_nchannels - 1; > + > + return &policy_node->group; > +} > + > +static void > +stp_policy_node_drop(struct config_group *group, struct config_item *item) > +{ > + config_item_put(item); > +} > + > +static struct configfs_group_operations stp_policy_node_group_ops = { > + .make_group = stp_policy_node_make, > + .drop_item = stp_policy_node_drop, > +}; > + > +static struct config_item_type stp_policy_node_type = { > + .ct_item_ops = &stp_policy_node_item_ops, > + .ct_group_ops = &stp_policy_node_group_ops, > + .ct_attrs = stp_policy_node_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +/* > + * Root group: policies. > + */ > +static struct configfs_attribute stp_policy_attr_device = { > + .ca_owner = THIS_MODULE, > + .ca_name = "device", > + .ca_mode = S_IRUGO, > +}; > + > +static struct configfs_attribute *stp_policy_attrs[] = { > + &stp_policy_attr_device, > + NULL, > +}; > + > +static ssize_t stp_policy_attr_show(struct config_item *item, > + struct configfs_attribute *attr, > + char *page) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + ssize_t count; > + > + count = sprintf(page, "%s\n", > + (policy && policy->stm) ? > + policy->stm->data->name : > + "<none>"); > + > + return count; > +} > + > +void stp_policy_unbind(struct stp_policy *policy) > +{ > + struct stm_device *stm = policy->stm; > + > + if (WARN_ON_ONCE(!policy->stm)) > + return; > + > + mutex_lock(&stm->policy_mutex); > + stm->policy = NULL; > + mutex_unlock(&stm->policy_mutex); > + > + policy->stm = NULL; > + > + stm_put_device(stm); > +} > + > +static void stp_policy_release(struct config_item *item) > +{ > + struct stp_policy *policy = to_stp_policy(item); > + > + stp_policy_unbind(policy); > + kfree(policy); > +} > + > +static struct configfs_item_operations stp_policy_item_ops = { > + .release = stp_policy_release, > + .show_attribute = stp_policy_attr_show, > +}; > + > +static struct configfs_group_operations stp_policy_group_ops = { > + .make_group = stp_policy_node_make, > +}; > + > +static struct config_item_type stp_policy_type = { > + .ct_item_ops = &stp_policy_item_ops, > + .ct_group_ops = &stp_policy_group_ops, > + .ct_attrs = stp_policy_attrs, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct config_group * > +stp_policies_make(struct config_group *group, const char *name) > +{ > + struct config_group *ret; > + struct stm_device *stm; > + char *devname, *p; > + > + devname = kasprintf(GFP_KERNEL, "%s", name); > + if (!devname) > + return ERR_PTR(-ENOMEM); > + > + /* > + * node must look like <device_name>.<policy_name>, where > + * <device_name> is the name of an existing stm device and > + * <policy_name> is an arbitrary string > + */ > + p = strchr(devname, '.'); > + if (!p) { > + kfree(devname); > + return ERR_PTR(-EINVAL); > + } > + > + *p++ = '\0'; > + > + stm = stm_find_device(devname); > + kfree(devname); > + > + if (!stm) > + return ERR_PTR(-ENODEV); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) { > + ret = ERR_PTR(-EBUSY); > + goto unlock_policy; > + } > + > + stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); > + if (!stm->policy) { > + ret = ERR_PTR(-ENOMEM); > + goto unlock_policy; > + } > + > + config_group_init_type_name(&stm->policy->group, name, > + &stp_policy_type); > + stm->policy->stm = stm; > + > + ret = &stm->policy->group; > + > +unlock_policy: > + mutex_unlock(&stm->policy_mutex); > + > + if (IS_ERR(ret)) > + stm_put_device(stm); > + > + return ret; > +} > + > +static struct configfs_group_operations stp_policies_group_ops = { > + .make_group = stp_policies_make, > +}; > + > +static struct config_item_type stp_policies_type = { > + .ct_group_ops = &stp_policies_group_ops, > + .ct_owner = THIS_MODULE, > +}; > + > +static struct configfs_subsystem stp_policy_subsys = { > + .su_group = { > + .cg_item = { > + .ci_namebuf = "stp-policy", > + .ci_type = &stp_policies_type, > + }, > + }, > +}; > + > +/* > + * Lock the policy mutex from the outside > + */ > +static struct stp_policy_node * > +__stp_policy_node_lookup(struct stp_policy *policy, char *s) > +{ > + struct stp_policy_node *policy_node, *ret; > + struct list_head *head = &policy->group.cg_children; > + struct config_item *item; > + char *start, *end = s; > + > + if (list_empty(head)) > + return NULL; > + > + /* return the first entry if everything else fails */ > + item = list_entry(head->next, struct config_item, ci_entry); > + ret = to_stp_policy_node(item); > + > +next: > + for (;;) { > + start = strsep(&end, "/"); > + if (!start) > + break; > + > + if (!*start) > + continue; > + > + list_for_each_entry(item, head, ci_entry) { > + policy_node = to_stp_policy_node(item); > + > + if (!strcmp(start, > + policy_node->group.cg_item.ci_name)) { > + ret = policy_node; > + > + if (!end) > + goto out; > + > + head = &policy_node->group.cg_children; > + goto next; > + } > + } > + break; > + } > + > +out: > + return ret; > +} > + > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s) > +{ > + struct stp_policy_node *policy_node = NULL; > + > + mutex_lock(&stp_policy_subsys.su_mutex); > + > + mutex_lock(&stm->policy_mutex); > + if (stm->policy) > + policy_node = __stp_policy_node_lookup(stm->policy, s); > + mutex_unlock(&stm->policy_mutex); > + > + if (policy_node) > + config_item_get(&policy_node->group.cg_item); > + mutex_unlock(&stp_policy_subsys.su_mutex); > + > + return policy_node; > +} > + > +void stp_policy_node_put(struct stp_policy_node *policy_node) > +{ > + config_item_put(&policy_node->group.cg_item); > +} > + > +int __init stp_configfs_init(void) > +{ > + int err; > + > + config_group_init(&stp_policy_subsys.su_group); > + mutex_init(&stp_policy_subsys.su_mutex); > + err = configfs_register_subsystem(&stp_policy_subsys); > + > + return err; > +} > + > +void __exit stp_configfs_exit(void) > +{ > + configfs_unregister_subsystem(&stp_policy_subsys); > +} > diff --git a/drivers/hwtracing/stm/stm.h b/drivers/hwtracing/stm/stm.h > new file mode 100644 > index 0000000000..cf33bf976a > --- /dev/null > +++ b/drivers/hwtracing/stm/stm.h > @@ -0,0 +1,87 @@ > +/* > + * System Trace Module (STM) infrastructure > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _STM_STM_H_ > +#define _STM_STM_H_ > + > +struct stp_policy; > +struct stp_policy_node; > + > +struct stp_policy_node * > +stp_policy_node_lookup(struct stm_device *stm, char *s); > +void stp_policy_node_put(struct stp_policy_node *policy_node); > +void stp_policy_unbind(struct stp_policy *policy); > + > +void stp_policy_node_get_ranges(struct stp_policy_node *policy_node, > + unsigned int *mstart, unsigned int *mend, > + unsigned int *cstart, unsigned int *cend); > +int stp_configfs_init(void); > +void stp_configfs_exit(void); > + > +struct stp_master { > + unsigned int nr_free; > + unsigned long chan_map[0]; > +}; > + > +struct stm_device { > + struct device dev; > + struct module *owner; > + struct stp_policy *policy; > + struct mutex policy_mutex; > + int major; > + unsigned int sw_nmasters; > + struct stm_data *data; > + spinlock_t link_lock; > + struct list_head link_list; > + /* master allocation */ > + spinlock_t mc_lock; > + struct stp_master *masters[0]; > +}; > + > +#define to_stm_device(_d) \ > + container_of((_d), struct stm_device, dev) > + > +struct stm_output { > + unsigned int master; > + unsigned int channel; > + unsigned int nr_chans; > +}; > + > +struct stm_file { > + struct stm_device *stm; > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +struct stm_device *stm_find_device(const char *name); > +void stm_put_device(struct stm_device *stm); > + > +struct stm_source_device { > + struct device dev; > + struct stm_source_data *data; > + spinlock_t link_lock; > + struct stm_device *link; > + struct list_head link_entry; > + /* one output per stm_source device */ > + struct stp_policy_node *policy_node; > + struct stm_output output; > +}; > + > +#define to_stm_source_device(_d) \ > + container_of((_d), struct stm_source_device, dev) > + > +#endif /* _STM_STM_H_ */ > diff --git a/include/linux/stm.h b/include/linux/stm.h > new file mode 100644 > index 0000000000..9d0083d364 > --- /dev/null > +++ b/include/linux/stm.h > @@ -0,0 +1,126 @@ > +/* > + * System Trace Module (STM) infrastructure apis > + * Copyright (C) 2014 Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + */ > + > +#ifndef _STM_H_ > +#define _STM_H_ > + > +#include <linux/device.h> > + > +/** > + * enum stp_packet_type - STP packets that an STM driver sends > + */ > +enum stp_packet_type { > + STP_PACKET_DATA = 0, > + STP_PACKET_FLAG, > + STP_PACKET_USER, > + STP_PACKET_MERR, > + STP_PACKET_GERR, > + STP_PACKET_TRIG, > + STP_PACKET_XSYNC, > +}; > + > +/** > + * enum stp_packet_flags - STP packet modifiers > + */ > +enum stp_packet_flags { > + STP_PACKET_MARKED = 0x1, > + STP_PACKET_TIMESTAMPED = 0x2, > +}; > + > +struct stp_policy; > + > +struct stm_device; > + > +/** > + * struct stm_data - STM device description and callbacks > + * @name: device name > + * @stm: internal structure, only used by stm class code > + * @sw_start: first STP master available to software > + * @sw_end: last STP master available to software > + * @sw_nchannels: number of STP channels per master > + * @sw_mmiosz: size of one channel's IO space, for mmap, optional > + * @packet: callback that sends an STP packet > + * @mmio_addr: mmap callback, optional > + * @link: called when a new stm_source gets linked to us, optional > + * @unlink: likewise for unlinking, again optional > + * @set_options: set device-specific options on a channel > + * > + * Fill out this structure before calling stm_register_device() to create > + * an STM device and stm_unregister_device() to destroy it. It will also be > + * passed back to @packet(), @mmio_addr(), @link(), @unlink() and @set_options() > + * callbacks. > + * > + * Normally, an STM device will have a range of masters available to software > + * and the rest being statically assigned to various hardware trace sources. > + * The former is defined by the the range [@sw_start..@sw_end] of the device > + * description. That is, the lowest master that can be allocated to software > + * writers is @sw_start and data from this writer will appear is @sw_start > + * master in the STP stream. > + */ > +struct stm_data { > + const char *name; > + struct stm_device *stm; > + unsigned int sw_start; > + unsigned int sw_end; > + unsigned int sw_nchannels; > + unsigned int sw_mmiosz; > + ssize_t (*packet)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned int, unsigned int, > + const unsigned char *); > + phys_addr_t (*mmio_addr)(struct stm_data *, unsigned int, > + unsigned int, unsigned int); > + int (*link)(struct stm_data *, unsigned int, > + unsigned int); > + void (*unlink)(struct stm_data *, unsigned int, > + unsigned int); > + long (*set_options)(struct stm_data *, unsigned int, > + unsigned int, unsigned int, > + unsigned long); > +}; > + > +int stm_register_device(struct device *parent, struct stm_data *stm_data, > + struct module *owner); > +void stm_unregister_device(struct stm_data *stm_data); > + > +struct stm_source_device; > + > +/** > + * struct stm_source_data - STM source device description and callbacks > + * @name: device name, will be used for policy lookup > + * @src: internal structure, only used by stm class code > + * @nr_chans: number of channels to allocate > + * @link: called when this source gets linked to an STM device > + * @unlink: called when this source is about to get unlinked from its STM > + * > + * Fill in this structure before calling stm_source_register_device() to > + * register a source device. Also pass it to unregister and write calls. > + */ > +struct stm_source_data { > + const char *name; > + struct stm_source_device *src; > + unsigned int percpu; > + unsigned int nr_chans; > + int (*link)(struct stm_source_data *data); > + void (*unlink)(struct stm_source_data *data); > +}; > + > +int stm_source_register_device(struct device *parent, > + struct stm_source_data *data); > +void stm_source_unregister_device(struct stm_source_data *data); > + > +int stm_source_write(struct stm_source_data *data, unsigned int chan, > + const char *buf, size_t count); > + > +#endif /* _STM_H_ */ > diff --git a/include/uapi/linux/stm.h b/include/uapi/linux/stm.h > new file mode 100644 > index 0000000000..626a8d3f63 > --- /dev/null > +++ b/include/uapi/linux/stm.h > @@ -0,0 +1,50 @@ > +/* > + * System Trace Module (STM) userspace interfaces > + * Copyright (c) 2014, Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + * > + * STM class implements generic infrastructure for System Trace Module devices > + * as defined in MIPI STPv2 specification. > + */ > + > +#ifndef _UAPI_LINUX_STM_H > +#define _UAPI_LINUX_STM_H > + > +#include <linux/types.h> > + > +/** > + * struct stp_policy_id - identification for the STP policy > + * @size: size of the structure including real id[] length > + * @master: assigned master > + * @channel: first assigned channel > + * @width: number of requested channels > + * @id: identification string > + * > + * User must calculate the total size of the structure and put it into > + * @size field, fill out the @id and desired @width. In return, kernel > + * fills out @master, @channel and @width. > + */ > +struct stp_policy_id { > + __u32 size; > + __u16 master; > + __u16 channel; > + __u16 width; > + /* padding */ > + __u16 __reserved_0; > + __u32 __reserved_1; > + char id[0]; > +}; > + > +#define STP_POLICY_ID_SET _IOWR('%', 0, struct stp_policy_id) > +#define STP_POLICY_ID_GET _IOR('%', 1, struct stp_policy_id) > +#define STP_SET_OPTIONS _IOW('%', 2, __u64) > + > +#endif /* _UAPI_LINUX_STM_H */ > -- > 2.1.4 > Reviewed-by: Mathieu Poirier <mathieu.poirier-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org> ^ permalink raw reply [flat|nested] 16+ messages in thread
end of thread, other threads:[~2015-08-05 23:01 UTC | newest]
Thread overview: 16+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <1436177344-16751-1-git-send-email-alexander.shishkin@linux.intel.com>
2015-07-06 10:08 ` [PATCH v3 01/11] stm class: Introduce an abstraction for System Trace Module devices Alexander Shishkin
2015-07-08 12:32 ` Chunyan Zhang
2015-07-08 12:49 ` Alexander Shishkin
[not found] ` <1436177344-16751-2-git-send-email-alexander.shishkin-VuQAYsv1563Yd54FQh9/CA@public.gmane.org>
2015-07-29 4:21 ` Chunyan Zhang
[not found] ` <CAAfSe-vOgnMXCy6fb8yuQ0O_5x1L1QtCmGjNjH+OtGAg6KJHrg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2015-07-29 13:25 ` Alexander Shishkin
[not found] ` <877fpjkseh.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>
2015-07-29 13:35 ` Mark Brown
[not found] ` <20150729133529.GI20130-GFdadSzt00ze9xe1eoZjHA@public.gmane.org>
2015-07-29 13:46 ` Alexander Shishkin
[not found] ` <871tfrkree.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>
2015-07-30 3:38 ` Chunyan Zhang
[not found] ` <CAAfSe-sQjPHQQ7-jh-Xq6nR3O0gtP3AM4m=gGJjUE26rsbQDMQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2015-07-30 5:45 ` Alexander Shishkin
[not found] ` <87zj2e9p25.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>
2015-07-30 6:15 ` Chunyan Zhang
2015-07-30 3:19 ` Chunyan Zhang
[not found] ` <CAAfSe-vgFSxA7OX7DSOB4XXdsan_3PWne0-16kSKZv_8HkHjgg-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2015-07-30 6:37 ` Alexander Shishkin
[not found] ` <87vbd29mm6.fsf-qxRn5AmX6ZD9BXuAQUXR0fooFf0ArEBIu+b9c/7xato@public.gmane.org>
2015-07-30 6:59 ` Chunyan Zhang
2015-07-30 7:11 ` Chunyan Zhang
2015-07-30 7:16 ` Alexander Shishkin
2015-08-05 23:01 ` Mathieu Poirier
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).