19ea393d8SAlexander Shishkin // SPDX-License-Identifier: GPL-2.0 27bd1d409SAlexander Shishkin /* 37bd1d409SAlexander Shishkin * System Trace Module (STM) infrastructure 47bd1d409SAlexander Shishkin * Copyright (c) 2014, Intel Corporation. 57bd1d409SAlexander Shishkin * 67bd1d409SAlexander Shishkin * STM class implements generic infrastructure for System Trace Module devices 77bd1d409SAlexander Shishkin * as defined in MIPI STPv2 specification. 87bd1d409SAlexander Shishkin */ 97bd1d409SAlexander Shishkin 108e0469a4SAlexander Shishkin #include <linux/pm_runtime.h> 117bd1d409SAlexander Shishkin #include <linux/uaccess.h> 127bd1d409SAlexander Shishkin #include <linux/kernel.h> 137bd1d409SAlexander Shishkin #include <linux/module.h> 147bd1d409SAlexander Shishkin #include <linux/device.h> 157bd1d409SAlexander Shishkin #include <linux/compat.h> 167bd1d409SAlexander Shishkin #include <linux/kdev_t.h> 177bd1d409SAlexander Shishkin #include <linux/srcu.h> 187bd1d409SAlexander Shishkin #include <linux/slab.h> 197bd1d409SAlexander Shishkin #include <linux/stm.h> 207bd1d409SAlexander Shishkin #include <linux/fs.h> 217bd1d409SAlexander Shishkin #include <linux/mm.h> 227bd1d409SAlexander Shishkin #include "stm.h" 237bd1d409SAlexander Shishkin 247bd1d409SAlexander Shishkin #include <uapi/linux/stm.h> 257bd1d409SAlexander Shishkin 267bd1d409SAlexander Shishkin static unsigned int stm_core_up; 277bd1d409SAlexander Shishkin 287bd1d409SAlexander Shishkin /* 297bd1d409SAlexander Shishkin * The SRCU here makes sure that STM device doesn't disappear from under a 307bd1d409SAlexander Shishkin * stm_source_write() caller, which may want to have as little overhead as 317bd1d409SAlexander Shishkin * possible. 327bd1d409SAlexander Shishkin */ 337bd1d409SAlexander Shishkin static struct srcu_struct stm_source_srcu; 347bd1d409SAlexander Shishkin 357bd1d409SAlexander Shishkin static ssize_t masters_show(struct device *dev, 367bd1d409SAlexander Shishkin struct device_attribute *attr, 377bd1d409SAlexander Shishkin char *buf) 387bd1d409SAlexander Shishkin { 397bd1d409SAlexander Shishkin struct stm_device *stm = to_stm_device(dev); 407bd1d409SAlexander Shishkin int ret; 417bd1d409SAlexander Shishkin 427bd1d409SAlexander Shishkin ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end); 437bd1d409SAlexander Shishkin 447bd1d409SAlexander Shishkin return ret; 457bd1d409SAlexander Shishkin } 467bd1d409SAlexander Shishkin 477bd1d409SAlexander Shishkin static DEVICE_ATTR_RO(masters); 487bd1d409SAlexander Shishkin 497bd1d409SAlexander Shishkin static ssize_t channels_show(struct device *dev, 507bd1d409SAlexander Shishkin struct device_attribute *attr, 517bd1d409SAlexander Shishkin char *buf) 527bd1d409SAlexander Shishkin { 537bd1d409SAlexander Shishkin struct stm_device *stm = to_stm_device(dev); 547bd1d409SAlexander Shishkin int ret; 557bd1d409SAlexander Shishkin 567bd1d409SAlexander Shishkin ret = sprintf(buf, "%u\n", stm->data->sw_nchannels); 577bd1d409SAlexander Shishkin 587bd1d409SAlexander Shishkin return ret; 597bd1d409SAlexander Shishkin } 607bd1d409SAlexander Shishkin 617bd1d409SAlexander Shishkin static DEVICE_ATTR_RO(channels); 627bd1d409SAlexander Shishkin 638e996a28SAlexander Shishkin static ssize_t hw_override_show(struct device *dev, 648e996a28SAlexander Shishkin struct device_attribute *attr, 658e996a28SAlexander Shishkin char *buf) 668e996a28SAlexander Shishkin { 678e996a28SAlexander Shishkin struct stm_device *stm = to_stm_device(dev); 688e996a28SAlexander Shishkin int ret; 698e996a28SAlexander Shishkin 708e996a28SAlexander Shishkin ret = sprintf(buf, "%u\n", stm->data->hw_override); 718e996a28SAlexander Shishkin 728e996a28SAlexander Shishkin return ret; 738e996a28SAlexander Shishkin } 748e996a28SAlexander Shishkin 758e996a28SAlexander Shishkin static DEVICE_ATTR_RO(hw_override); 768e996a28SAlexander Shishkin 777bd1d409SAlexander Shishkin static struct attribute *stm_attrs[] = { 787bd1d409SAlexander Shishkin &dev_attr_masters.attr, 797bd1d409SAlexander Shishkin &dev_attr_channels.attr, 808e996a28SAlexander Shishkin &dev_attr_hw_override.attr, 817bd1d409SAlexander Shishkin NULL, 827bd1d409SAlexander Shishkin }; 837bd1d409SAlexander Shishkin 847bd1d409SAlexander Shishkin ATTRIBUTE_GROUPS(stm); 857bd1d409SAlexander Shishkin 867bd1d409SAlexander Shishkin static struct class stm_class = { 877bd1d409SAlexander Shishkin .name = "stm", 887bd1d409SAlexander Shishkin .dev_groups = stm_groups, 897bd1d409SAlexander Shishkin }; 907bd1d409SAlexander Shishkin 917bd1d409SAlexander Shishkin static int stm_dev_match(struct device *dev, const void *data) 927bd1d409SAlexander Shishkin { 937bd1d409SAlexander Shishkin const char *name = data; 947bd1d409SAlexander Shishkin 957bd1d409SAlexander Shishkin return sysfs_streq(name, dev_name(dev)); 967bd1d409SAlexander Shishkin } 977bd1d409SAlexander Shishkin 987bd1d409SAlexander Shishkin /** 997bd1d409SAlexander Shishkin * stm_find_device() - find stm device by name 1007bd1d409SAlexander Shishkin * @buf: character buffer containing the name 1017bd1d409SAlexander Shishkin * 1027bd1d409SAlexander Shishkin * This is called when either policy gets assigned to an stm device or an 1037bd1d409SAlexander Shishkin * stm_source device gets linked to an stm device. 1047bd1d409SAlexander Shishkin * 1057bd1d409SAlexander Shishkin * This grabs device's reference (get_device()) and module reference, both 1067bd1d409SAlexander Shishkin * of which the calling path needs to make sure to drop with stm_put_device(). 1077bd1d409SAlexander Shishkin * 1087bd1d409SAlexander Shishkin * Return: stm device pointer or null if lookup failed. 1097bd1d409SAlexander Shishkin */ 1107bd1d409SAlexander Shishkin struct stm_device *stm_find_device(const char *buf) 1117bd1d409SAlexander Shishkin { 1127bd1d409SAlexander Shishkin struct stm_device *stm; 1137bd1d409SAlexander Shishkin struct device *dev; 1147bd1d409SAlexander Shishkin 1157bd1d409SAlexander Shishkin if (!stm_core_up) 1167bd1d409SAlexander Shishkin return NULL; 1177bd1d409SAlexander Shishkin 1187bd1d409SAlexander Shishkin dev = class_find_device(&stm_class, NULL, buf, stm_dev_match); 1197bd1d409SAlexander Shishkin if (!dev) 1207bd1d409SAlexander Shishkin return NULL; 1217bd1d409SAlexander Shishkin 1227bd1d409SAlexander Shishkin stm = to_stm_device(dev); 1237bd1d409SAlexander Shishkin if (!try_module_get(stm->owner)) { 124f7c81c71SAlexander Shishkin /* matches class_find_device() above */ 1257bd1d409SAlexander Shishkin put_device(dev); 1267bd1d409SAlexander Shishkin return NULL; 1277bd1d409SAlexander Shishkin } 1287bd1d409SAlexander Shishkin 1297bd1d409SAlexander Shishkin return stm; 1307bd1d409SAlexander Shishkin } 1317bd1d409SAlexander Shishkin 1327bd1d409SAlexander Shishkin /** 1337bd1d409SAlexander Shishkin * stm_put_device() - drop references on the stm device 1347bd1d409SAlexander Shishkin * @stm: stm device, previously acquired by stm_find_device() 1357bd1d409SAlexander Shishkin * 1367bd1d409SAlexander Shishkin * This drops the module reference and device reference taken by 137f7c81c71SAlexander Shishkin * stm_find_device() or stm_char_open(). 1387bd1d409SAlexander Shishkin */ 1397bd1d409SAlexander Shishkin void stm_put_device(struct stm_device *stm) 1407bd1d409SAlexander Shishkin { 1417bd1d409SAlexander Shishkin module_put(stm->owner); 1427bd1d409SAlexander Shishkin put_device(&stm->dev); 1437bd1d409SAlexander Shishkin } 1447bd1d409SAlexander Shishkin 1457bd1d409SAlexander Shishkin /* 1467bd1d409SAlexander Shishkin * Internally we only care about software-writable masters here, that is the 1477bd1d409SAlexander Shishkin * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need 1487bd1d409SAlexander Shishkin * original master numbers to be visible externally, since they are the ones 1497bd1d409SAlexander Shishkin * that will appear in the STP stream. Thus, the internal bookkeeping uses 1507bd1d409SAlexander Shishkin * $master - stm_data->sw_start to reference master descriptors and such. 1517bd1d409SAlexander Shishkin */ 1527bd1d409SAlexander Shishkin 1537bd1d409SAlexander Shishkin #define __stm_master(_s, _m) \ 1547bd1d409SAlexander Shishkin ((_s)->masters[(_m) - (_s)->data->sw_start]) 1557bd1d409SAlexander Shishkin 1567bd1d409SAlexander Shishkin static inline struct stp_master * 1577bd1d409SAlexander Shishkin stm_master(struct stm_device *stm, unsigned int idx) 1587bd1d409SAlexander Shishkin { 1597bd1d409SAlexander Shishkin if (idx < stm->data->sw_start || idx > stm->data->sw_end) 1607bd1d409SAlexander Shishkin return NULL; 1617bd1d409SAlexander Shishkin 1627bd1d409SAlexander Shishkin return __stm_master(stm, idx); 1637bd1d409SAlexander Shishkin } 1647bd1d409SAlexander Shishkin 1657bd1d409SAlexander Shishkin static int stp_master_alloc(struct stm_device *stm, unsigned int idx) 1667bd1d409SAlexander Shishkin { 1677bd1d409SAlexander Shishkin struct stp_master *master; 1687bd1d409SAlexander Shishkin size_t size; 1697bd1d409SAlexander Shishkin 1707bd1d409SAlexander Shishkin size = ALIGN(stm->data->sw_nchannels, 8) / 8; 1717bd1d409SAlexander Shishkin size += sizeof(struct stp_master); 1727bd1d409SAlexander Shishkin master = kzalloc(size, GFP_ATOMIC); 1737bd1d409SAlexander Shishkin if (!master) 1747bd1d409SAlexander Shishkin return -ENOMEM; 1757bd1d409SAlexander Shishkin 1767bd1d409SAlexander Shishkin master->nr_free = stm->data->sw_nchannels; 1777bd1d409SAlexander Shishkin __stm_master(stm, idx) = master; 1787bd1d409SAlexander Shishkin 1797bd1d409SAlexander Shishkin return 0; 1807bd1d409SAlexander Shishkin } 1817bd1d409SAlexander Shishkin 1827bd1d409SAlexander Shishkin static void stp_master_free(struct stm_device *stm, unsigned int idx) 1837bd1d409SAlexander Shishkin { 1847bd1d409SAlexander Shishkin struct stp_master *master = stm_master(stm, idx); 1857bd1d409SAlexander Shishkin 1867bd1d409SAlexander Shishkin if (!master) 1877bd1d409SAlexander Shishkin return; 1887bd1d409SAlexander Shishkin 1897bd1d409SAlexander Shishkin __stm_master(stm, idx) = NULL; 1907bd1d409SAlexander Shishkin kfree(master); 1917bd1d409SAlexander Shishkin } 1927bd1d409SAlexander Shishkin 1937bd1d409SAlexander Shishkin static void stm_output_claim(struct stm_device *stm, struct stm_output *output) 1947bd1d409SAlexander Shishkin { 1957bd1d409SAlexander Shishkin struct stp_master *master = stm_master(stm, output->master); 1967bd1d409SAlexander Shishkin 197cde4ad83SAlexander Shishkin lockdep_assert_held(&stm->mc_lock); 198cde4ad83SAlexander Shishkin lockdep_assert_held(&output->lock); 199cde4ad83SAlexander Shishkin 2007bd1d409SAlexander Shishkin if (WARN_ON_ONCE(master->nr_free < output->nr_chans)) 2017bd1d409SAlexander Shishkin return; 2027bd1d409SAlexander Shishkin 2037bd1d409SAlexander Shishkin bitmap_allocate_region(&master->chan_map[0], output->channel, 2047bd1d409SAlexander Shishkin ilog2(output->nr_chans)); 2057bd1d409SAlexander Shishkin 2067bd1d409SAlexander Shishkin master->nr_free -= output->nr_chans; 2077bd1d409SAlexander Shishkin } 2087bd1d409SAlexander Shishkin 2097bd1d409SAlexander Shishkin static void 2107bd1d409SAlexander Shishkin stm_output_disclaim(struct stm_device *stm, struct stm_output *output) 2117bd1d409SAlexander Shishkin { 2127bd1d409SAlexander Shishkin struct stp_master *master = stm_master(stm, output->master); 2137bd1d409SAlexander Shishkin 214cde4ad83SAlexander Shishkin lockdep_assert_held(&stm->mc_lock); 215cde4ad83SAlexander Shishkin lockdep_assert_held(&output->lock); 216cde4ad83SAlexander Shishkin 2177bd1d409SAlexander Shishkin bitmap_release_region(&master->chan_map[0], output->channel, 2187bd1d409SAlexander Shishkin ilog2(output->nr_chans)); 2197bd1d409SAlexander Shishkin 2207bd1d409SAlexander Shishkin output->nr_chans = 0; 2217bd1d409SAlexander Shishkin master->nr_free += output->nr_chans; 2227bd1d409SAlexander Shishkin } 2237bd1d409SAlexander Shishkin 2247bd1d409SAlexander Shishkin /* 2257bd1d409SAlexander Shishkin * This is like bitmap_find_free_region(), except it can ignore @start bits 2267bd1d409SAlexander Shishkin * at the beginning. 2277bd1d409SAlexander Shishkin */ 2287bd1d409SAlexander Shishkin static int find_free_channels(unsigned long *bitmap, unsigned int start, 2297bd1d409SAlexander Shishkin unsigned int end, unsigned int width) 2307bd1d409SAlexander Shishkin { 2317bd1d409SAlexander Shishkin unsigned int pos; 2327bd1d409SAlexander Shishkin int i; 2337bd1d409SAlexander Shishkin 2347bd1d409SAlexander Shishkin for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) { 2357bd1d409SAlexander Shishkin pos = find_next_zero_bit(bitmap, end + 1, pos); 2367bd1d409SAlexander Shishkin if (pos + width > end + 1) 2377bd1d409SAlexander Shishkin break; 2387bd1d409SAlexander Shishkin 2397bd1d409SAlexander Shishkin if (pos & (width - 1)) 2407bd1d409SAlexander Shishkin continue; 2417bd1d409SAlexander Shishkin 2427bd1d409SAlexander Shishkin for (i = 1; i < width && !test_bit(pos + i, bitmap); i++) 2437bd1d409SAlexander Shishkin ; 2447bd1d409SAlexander Shishkin if (i == width) 2457bd1d409SAlexander Shishkin return pos; 2467bd1d409SAlexander Shishkin } 2477bd1d409SAlexander Shishkin 2487bd1d409SAlexander Shishkin return -1; 2497bd1d409SAlexander Shishkin } 2507bd1d409SAlexander Shishkin 251f45f40adSLucas Tanure static int 2527bd1d409SAlexander Shishkin stm_find_master_chan(struct stm_device *stm, unsigned int width, 2537bd1d409SAlexander Shishkin unsigned int *mstart, unsigned int mend, 2547bd1d409SAlexander Shishkin unsigned int *cstart, unsigned int cend) 2557bd1d409SAlexander Shishkin { 2567bd1d409SAlexander Shishkin struct stp_master *master; 2577bd1d409SAlexander Shishkin unsigned int midx; 2587bd1d409SAlexander Shishkin int pos, err; 2597bd1d409SAlexander Shishkin 2607bd1d409SAlexander Shishkin for (midx = *mstart; midx <= mend; midx++) { 2617bd1d409SAlexander Shishkin if (!stm_master(stm, midx)) { 2627bd1d409SAlexander Shishkin err = stp_master_alloc(stm, midx); 2637bd1d409SAlexander Shishkin if (err) 2647bd1d409SAlexander Shishkin return err; 2657bd1d409SAlexander Shishkin } 2667bd1d409SAlexander Shishkin 2677bd1d409SAlexander Shishkin master = stm_master(stm, midx); 2687bd1d409SAlexander Shishkin 2697bd1d409SAlexander Shishkin if (!master->nr_free) 2707bd1d409SAlexander Shishkin continue; 2717bd1d409SAlexander Shishkin 2727bd1d409SAlexander Shishkin pos = find_free_channels(master->chan_map, *cstart, cend, 2737bd1d409SAlexander Shishkin width); 2747bd1d409SAlexander Shishkin if (pos < 0) 2757bd1d409SAlexander Shishkin continue; 2767bd1d409SAlexander Shishkin 2777bd1d409SAlexander Shishkin *mstart = midx; 2787bd1d409SAlexander Shishkin *cstart = pos; 2797bd1d409SAlexander Shishkin return 0; 2807bd1d409SAlexander Shishkin } 2817bd1d409SAlexander Shishkin 2827bd1d409SAlexander Shishkin return -ENOSPC; 2837bd1d409SAlexander Shishkin } 2847bd1d409SAlexander Shishkin 2857bd1d409SAlexander Shishkin static int stm_output_assign(struct stm_device *stm, unsigned int width, 2867bd1d409SAlexander Shishkin struct stp_policy_node *policy_node, 2877bd1d409SAlexander Shishkin struct stm_output *output) 2887bd1d409SAlexander Shishkin { 2897bd1d409SAlexander Shishkin unsigned int midx, cidx, mend, cend; 2907bd1d409SAlexander Shishkin int ret = -EINVAL; 2917bd1d409SAlexander Shishkin 2927bd1d409SAlexander Shishkin if (width > stm->data->sw_nchannels) 2937bd1d409SAlexander Shishkin return -EINVAL; 2947bd1d409SAlexander Shishkin 2957bd1d409SAlexander Shishkin if (policy_node) { 2967bd1d409SAlexander Shishkin stp_policy_node_get_ranges(policy_node, 2977bd1d409SAlexander Shishkin &midx, &mend, &cidx, &cend); 2987bd1d409SAlexander Shishkin } else { 2997bd1d409SAlexander Shishkin midx = stm->data->sw_start; 3007bd1d409SAlexander Shishkin cidx = 0; 3017bd1d409SAlexander Shishkin mend = stm->data->sw_end; 3027bd1d409SAlexander Shishkin cend = stm->data->sw_nchannels - 1; 3037bd1d409SAlexander Shishkin } 3047bd1d409SAlexander Shishkin 3057bd1d409SAlexander Shishkin spin_lock(&stm->mc_lock); 306cde4ad83SAlexander Shishkin spin_lock(&output->lock); 3077bd1d409SAlexander Shishkin /* output is already assigned -- shouldn't happen */ 3087bd1d409SAlexander Shishkin if (WARN_ON_ONCE(output->nr_chans)) 3097bd1d409SAlexander Shishkin goto unlock; 3107bd1d409SAlexander Shishkin 3117bd1d409SAlexander Shishkin ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend); 312f45f40adSLucas Tanure if (ret < 0) 3137bd1d409SAlexander Shishkin goto unlock; 3147bd1d409SAlexander Shishkin 3157bd1d409SAlexander Shishkin output->master = midx; 3167bd1d409SAlexander Shishkin output->channel = cidx; 3177bd1d409SAlexander Shishkin output->nr_chans = width; 3187bd1d409SAlexander Shishkin stm_output_claim(stm, output); 3197bd1d409SAlexander Shishkin dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width); 3207bd1d409SAlexander Shishkin 3217bd1d409SAlexander Shishkin ret = 0; 3227bd1d409SAlexander Shishkin unlock: 323cde4ad83SAlexander Shishkin spin_unlock(&output->lock); 3247bd1d409SAlexander Shishkin spin_unlock(&stm->mc_lock); 3257bd1d409SAlexander Shishkin 3267bd1d409SAlexander Shishkin return ret; 3277bd1d409SAlexander Shishkin } 3287bd1d409SAlexander Shishkin 3297bd1d409SAlexander Shishkin static void stm_output_free(struct stm_device *stm, struct stm_output *output) 3307bd1d409SAlexander Shishkin { 3317bd1d409SAlexander Shishkin spin_lock(&stm->mc_lock); 332cde4ad83SAlexander Shishkin spin_lock(&output->lock); 3337bd1d409SAlexander Shishkin if (output->nr_chans) 3347bd1d409SAlexander Shishkin stm_output_disclaim(stm, output); 335cde4ad83SAlexander Shishkin spin_unlock(&output->lock); 3367bd1d409SAlexander Shishkin spin_unlock(&stm->mc_lock); 3377bd1d409SAlexander Shishkin } 3387bd1d409SAlexander Shishkin 339cde4ad83SAlexander Shishkin static void stm_output_init(struct stm_output *output) 340cde4ad83SAlexander Shishkin { 341cde4ad83SAlexander Shishkin spin_lock_init(&output->lock); 342cde4ad83SAlexander Shishkin } 343cde4ad83SAlexander Shishkin 3447bd1d409SAlexander Shishkin static int major_match(struct device *dev, const void *data) 3457bd1d409SAlexander Shishkin { 3467bd1d409SAlexander Shishkin unsigned int major = *(unsigned int *)data; 3477bd1d409SAlexander Shishkin 3487bd1d409SAlexander Shishkin return MAJOR(dev->devt) == major; 3497bd1d409SAlexander Shishkin } 3507bd1d409SAlexander Shishkin 3517bd1d409SAlexander Shishkin static int stm_char_open(struct inode *inode, struct file *file) 3527bd1d409SAlexander Shishkin { 3537bd1d409SAlexander Shishkin struct stm_file *stmf; 3547bd1d409SAlexander Shishkin struct device *dev; 3557bd1d409SAlexander Shishkin unsigned int major = imajor(inode); 356a0ebf519SJohan Hovold int err = -ENOMEM; 3577bd1d409SAlexander Shishkin 3587bd1d409SAlexander Shishkin dev = class_find_device(&stm_class, NULL, &major, major_match); 3597bd1d409SAlexander Shishkin if (!dev) 3607bd1d409SAlexander Shishkin return -ENODEV; 3617bd1d409SAlexander Shishkin 3627bd1d409SAlexander Shishkin stmf = kzalloc(sizeof(*stmf), GFP_KERNEL); 3637bd1d409SAlexander Shishkin if (!stmf) 364a0ebf519SJohan Hovold goto err_put_device; 3657bd1d409SAlexander Shishkin 366a0ebf519SJohan Hovold err = -ENODEV; 367cde4ad83SAlexander Shishkin stm_output_init(&stmf->output); 3687bd1d409SAlexander Shishkin stmf->stm = to_stm_device(dev); 3697bd1d409SAlexander Shishkin 3707bd1d409SAlexander Shishkin if (!try_module_get(stmf->stm->owner)) 3717bd1d409SAlexander Shishkin goto err_free; 3727bd1d409SAlexander Shishkin 3737bd1d409SAlexander Shishkin file->private_data = stmf; 3747bd1d409SAlexander Shishkin 3757bd1d409SAlexander Shishkin return nonseekable_open(inode, file); 3767bd1d409SAlexander Shishkin 3777bd1d409SAlexander Shishkin err_free: 378a0ebf519SJohan Hovold kfree(stmf); 379a0ebf519SJohan Hovold err_put_device: 380f7c81c71SAlexander Shishkin /* matches class_find_device() above */ 381f7c81c71SAlexander Shishkin put_device(dev); 3827bd1d409SAlexander Shishkin 3837bd1d409SAlexander Shishkin return err; 3847bd1d409SAlexander Shishkin } 3857bd1d409SAlexander Shishkin 3867bd1d409SAlexander Shishkin static int stm_char_release(struct inode *inode, struct file *file) 3877bd1d409SAlexander Shishkin { 3887bd1d409SAlexander Shishkin struct stm_file *stmf = file->private_data; 389cc842407SAlexander Shishkin struct stm_device *stm = stmf->stm; 3907bd1d409SAlexander Shishkin 391cc842407SAlexander Shishkin if (stm->data->unlink) 392cc842407SAlexander Shishkin stm->data->unlink(stm->data, stmf->output.master, 393cc842407SAlexander Shishkin stmf->output.channel); 394cc842407SAlexander Shishkin 395cc842407SAlexander Shishkin stm_output_free(stm, &stmf->output); 396f7c81c71SAlexander Shishkin 397f7c81c71SAlexander Shishkin /* 398f7c81c71SAlexander Shishkin * matches the stm_char_open()'s 399f7c81c71SAlexander Shishkin * class_find_device() + try_module_get() 400f7c81c71SAlexander Shishkin */ 401cc842407SAlexander Shishkin stm_put_device(stm); 4027bd1d409SAlexander Shishkin kfree(stmf); 4037bd1d409SAlexander Shishkin 4047bd1d409SAlexander Shishkin return 0; 4057bd1d409SAlexander Shishkin } 4067bd1d409SAlexander Shishkin 4077bd1d409SAlexander Shishkin static int stm_file_assign(struct stm_file *stmf, char *id, unsigned int width) 4087bd1d409SAlexander Shishkin { 4097bd1d409SAlexander Shishkin struct stm_device *stm = stmf->stm; 4107bd1d409SAlexander Shishkin int ret; 4117bd1d409SAlexander Shishkin 4127bd1d409SAlexander Shishkin stmf->policy_node = stp_policy_node_lookup(stm, id); 4137bd1d409SAlexander Shishkin 4147bd1d409SAlexander Shishkin ret = stm_output_assign(stm, width, stmf->policy_node, &stmf->output); 4157bd1d409SAlexander Shishkin 4167bd1d409SAlexander Shishkin if (stmf->policy_node) 4177bd1d409SAlexander Shishkin stp_policy_node_put(stmf->policy_node); 4187bd1d409SAlexander Shishkin 4197bd1d409SAlexander Shishkin return ret; 4207bd1d409SAlexander Shishkin } 4217bd1d409SAlexander Shishkin 4229dfed80dSChunyan Zhang static ssize_t notrace stm_write(struct stm_data *data, unsigned int master, 4237bd1d409SAlexander Shishkin unsigned int channel, const char *buf, size_t count) 4247bd1d409SAlexander Shishkin { 4257bd1d409SAlexander Shishkin unsigned int flags = STP_PACKET_TIMESTAMPED; 4267bd1d409SAlexander Shishkin const unsigned char *p = buf, nil = 0; 4277bd1d409SAlexander Shishkin size_t pos; 4287bd1d409SAlexander Shishkin ssize_t sz; 4297bd1d409SAlexander Shishkin 4307bd1d409SAlexander Shishkin for (pos = 0, p = buf; count > pos; pos += sz, p += sz) { 4317bd1d409SAlexander Shishkin sz = min_t(unsigned int, count - pos, 8); 4327bd1d409SAlexander Shishkin sz = data->packet(data, master, channel, STP_PACKET_DATA, flags, 4337bd1d409SAlexander Shishkin sz, p); 4347bd1d409SAlexander Shishkin flags = 0; 435f8560a9bSAlexander Shishkin 436f8560a9bSAlexander Shishkin if (sz < 0) 437f8560a9bSAlexander Shishkin break; 4387bd1d409SAlexander Shishkin } 4397bd1d409SAlexander Shishkin 4407bd1d409SAlexander Shishkin data->packet(data, master, channel, STP_PACKET_FLAG, 0, 0, &nil); 441f8560a9bSAlexander Shishkin 442f8560a9bSAlexander Shishkin return pos; 4437bd1d409SAlexander Shishkin } 4447bd1d409SAlexander Shishkin 4457bd1d409SAlexander Shishkin static ssize_t stm_char_write(struct file *file, const char __user *buf, 4467bd1d409SAlexander Shishkin size_t count, loff_t *ppos) 4477bd1d409SAlexander Shishkin { 4487bd1d409SAlexander Shishkin struct stm_file *stmf = file->private_data; 4497bd1d409SAlexander Shishkin struct stm_device *stm = stmf->stm; 4507bd1d409SAlexander Shishkin char *kbuf; 4517bd1d409SAlexander Shishkin int err; 4527bd1d409SAlexander Shishkin 453f08b1826SAlexander Shishkin if (count + 1 > PAGE_SIZE) 454f08b1826SAlexander Shishkin count = PAGE_SIZE - 1; 455f08b1826SAlexander Shishkin 4567bd1d409SAlexander Shishkin /* 4577bd1d409SAlexander Shishkin * if no m/c have been assigned to this writer up to this 4587bd1d409SAlexander Shishkin * point, use "default" policy entry 4597bd1d409SAlexander Shishkin */ 4607bd1d409SAlexander Shishkin if (!stmf->output.nr_chans) { 4617bd1d409SAlexander Shishkin err = stm_file_assign(stmf, "default", 1); 4627bd1d409SAlexander Shishkin /* 4637bd1d409SAlexander Shishkin * EBUSY means that somebody else just assigned this 4647bd1d409SAlexander Shishkin * output, which is just fine for write() 4657bd1d409SAlexander Shishkin */ 4667bd1d409SAlexander Shishkin if (err && err != -EBUSY) 4677bd1d409SAlexander Shishkin return err; 4687bd1d409SAlexander Shishkin } 4697bd1d409SAlexander Shishkin 4707bd1d409SAlexander Shishkin kbuf = kmalloc(count + 1, GFP_KERNEL); 4717bd1d409SAlexander Shishkin if (!kbuf) 4727bd1d409SAlexander Shishkin return -ENOMEM; 4737bd1d409SAlexander Shishkin 4747bd1d409SAlexander Shishkin err = copy_from_user(kbuf, buf, count); 4757bd1d409SAlexander Shishkin if (err) { 4767bd1d409SAlexander Shishkin kfree(kbuf); 4777bd1d409SAlexander Shishkin return -EFAULT; 4787bd1d409SAlexander Shishkin } 4797bd1d409SAlexander Shishkin 4808e0469a4SAlexander Shishkin pm_runtime_get_sync(&stm->dev); 4818e0469a4SAlexander Shishkin 482f8560a9bSAlexander Shishkin count = stm_write(stm->data, stmf->output.master, stmf->output.channel, 483f8560a9bSAlexander Shishkin kbuf, count); 4847bd1d409SAlexander Shishkin 4858e0469a4SAlexander Shishkin pm_runtime_mark_last_busy(&stm->dev); 4868e0469a4SAlexander Shishkin pm_runtime_put_autosuspend(&stm->dev); 4877bd1d409SAlexander Shishkin kfree(kbuf); 4887bd1d409SAlexander Shishkin 4897bd1d409SAlexander Shishkin return count; 4907bd1d409SAlexander Shishkin } 4917bd1d409SAlexander Shishkin 4928e0469a4SAlexander Shishkin static void stm_mmap_open(struct vm_area_struct *vma) 4938e0469a4SAlexander Shishkin { 4948e0469a4SAlexander Shishkin struct stm_file *stmf = vma->vm_file->private_data; 4958e0469a4SAlexander Shishkin struct stm_device *stm = stmf->stm; 4968e0469a4SAlexander Shishkin 4978e0469a4SAlexander Shishkin pm_runtime_get(&stm->dev); 4988e0469a4SAlexander Shishkin } 4998e0469a4SAlexander Shishkin 5008e0469a4SAlexander Shishkin static void stm_mmap_close(struct vm_area_struct *vma) 5018e0469a4SAlexander Shishkin { 5028e0469a4SAlexander Shishkin struct stm_file *stmf = vma->vm_file->private_data; 5038e0469a4SAlexander Shishkin struct stm_device *stm = stmf->stm; 5048e0469a4SAlexander Shishkin 5058e0469a4SAlexander Shishkin pm_runtime_mark_last_busy(&stm->dev); 5068e0469a4SAlexander Shishkin pm_runtime_put_autosuspend(&stm->dev); 5078e0469a4SAlexander Shishkin } 5088e0469a4SAlexander Shishkin 5098e0469a4SAlexander Shishkin static const struct vm_operations_struct stm_mmap_vmops = { 5108e0469a4SAlexander Shishkin .open = stm_mmap_open, 5118e0469a4SAlexander Shishkin .close = stm_mmap_close, 5128e0469a4SAlexander Shishkin }; 5138e0469a4SAlexander Shishkin 5147bd1d409SAlexander Shishkin static int stm_char_mmap(struct file *file, struct vm_area_struct *vma) 5157bd1d409SAlexander Shishkin { 5167bd1d409SAlexander Shishkin struct stm_file *stmf = file->private_data; 5177bd1d409SAlexander Shishkin struct stm_device *stm = stmf->stm; 5187bd1d409SAlexander Shishkin unsigned long size, phys; 5197bd1d409SAlexander Shishkin 5207bd1d409SAlexander Shishkin if (!stm->data->mmio_addr) 5217bd1d409SAlexander Shishkin return -EOPNOTSUPP; 5227bd1d409SAlexander Shishkin 5237bd1d409SAlexander Shishkin if (vma->vm_pgoff) 5247bd1d409SAlexander Shishkin return -EINVAL; 5257bd1d409SAlexander Shishkin 5267bd1d409SAlexander Shishkin size = vma->vm_end - vma->vm_start; 5277bd1d409SAlexander Shishkin 5287bd1d409SAlexander Shishkin if (stmf->output.nr_chans * stm->data->sw_mmiosz != size) 5297bd1d409SAlexander Shishkin return -EINVAL; 5307bd1d409SAlexander Shishkin 5317bd1d409SAlexander Shishkin phys = stm->data->mmio_addr(stm->data, stmf->output.master, 5327bd1d409SAlexander Shishkin stmf->output.channel, 5337bd1d409SAlexander Shishkin stmf->output.nr_chans); 5347bd1d409SAlexander Shishkin 5357bd1d409SAlexander Shishkin if (!phys) 5367bd1d409SAlexander Shishkin return -EINVAL; 5377bd1d409SAlexander Shishkin 5388e0469a4SAlexander Shishkin pm_runtime_get_sync(&stm->dev); 5398e0469a4SAlexander Shishkin 5407bd1d409SAlexander Shishkin vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 5417bd1d409SAlexander Shishkin vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP; 5428e0469a4SAlexander Shishkin vma->vm_ops = &stm_mmap_vmops; 5437bd1d409SAlexander Shishkin vm_iomap_memory(vma, phys, size); 5447bd1d409SAlexander Shishkin 5457bd1d409SAlexander Shishkin return 0; 5467bd1d409SAlexander Shishkin } 5477bd1d409SAlexander Shishkin 5487bd1d409SAlexander Shishkin static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg) 5497bd1d409SAlexander Shishkin { 5507bd1d409SAlexander Shishkin struct stm_device *stm = stmf->stm; 5517bd1d409SAlexander Shishkin struct stp_policy_id *id; 5527bd1d409SAlexander Shishkin int ret = -EINVAL; 5537bd1d409SAlexander Shishkin u32 size; 5547bd1d409SAlexander Shishkin 5557bd1d409SAlexander Shishkin if (stmf->output.nr_chans) 5567bd1d409SAlexander Shishkin return -EBUSY; 5577bd1d409SAlexander Shishkin 5587bd1d409SAlexander Shishkin if (copy_from_user(&size, arg, sizeof(size))) 5597bd1d409SAlexander Shishkin return -EFAULT; 5607bd1d409SAlexander Shishkin 56171c488f3SDan Carpenter if (size < sizeof(*id) || size >= PATH_MAX + sizeof(*id)) 5627bd1d409SAlexander Shishkin return -EINVAL; 5637bd1d409SAlexander Shishkin 5647bd1d409SAlexander Shishkin /* 5657bd1d409SAlexander Shishkin * size + 1 to make sure the .id string at the bottom is terminated, 5667bd1d409SAlexander Shishkin * which is also why memdup_user() is not useful here 5677bd1d409SAlexander Shishkin */ 5687bd1d409SAlexander Shishkin id = kzalloc(size + 1, GFP_KERNEL); 5697bd1d409SAlexander Shishkin if (!id) 5707bd1d409SAlexander Shishkin return -ENOMEM; 5717bd1d409SAlexander Shishkin 5727bd1d409SAlexander Shishkin if (copy_from_user(id, arg, size)) { 5737bd1d409SAlexander Shishkin ret = -EFAULT; 5747bd1d409SAlexander Shishkin goto err_free; 5757bd1d409SAlexander Shishkin } 5767bd1d409SAlexander Shishkin 5777bd1d409SAlexander Shishkin if (id->__reserved_0 || id->__reserved_1) 5787bd1d409SAlexander Shishkin goto err_free; 5797bd1d409SAlexander Shishkin 5807bd1d409SAlexander Shishkin if (id->width < 1 || 5817bd1d409SAlexander Shishkin id->width > PAGE_SIZE / stm->data->sw_mmiosz) 5827bd1d409SAlexander Shishkin goto err_free; 5837bd1d409SAlexander Shishkin 5847bd1d409SAlexander Shishkin ret = stm_file_assign(stmf, id->id, id->width); 5857bd1d409SAlexander Shishkin if (ret) 5867bd1d409SAlexander Shishkin goto err_free; 5877bd1d409SAlexander Shishkin 5887bd1d409SAlexander Shishkin if (stm->data->link) 5897bd1d409SAlexander Shishkin ret = stm->data->link(stm->data, stmf->output.master, 5907bd1d409SAlexander Shishkin stmf->output.channel); 5917bd1d409SAlexander Shishkin 592f7c81c71SAlexander Shishkin if (ret) 5937bd1d409SAlexander Shishkin stm_output_free(stmf->stm, &stmf->output); 5947bd1d409SAlexander Shishkin 5957bd1d409SAlexander Shishkin err_free: 5967bd1d409SAlexander Shishkin kfree(id); 5977bd1d409SAlexander Shishkin 5987bd1d409SAlexander Shishkin return ret; 5997bd1d409SAlexander Shishkin } 6007bd1d409SAlexander Shishkin 6017bd1d409SAlexander Shishkin static int stm_char_policy_get_ioctl(struct stm_file *stmf, void __user *arg) 6027bd1d409SAlexander Shishkin { 6037bd1d409SAlexander Shishkin struct stp_policy_id id = { 6047bd1d409SAlexander Shishkin .size = sizeof(id), 6057bd1d409SAlexander Shishkin .master = stmf->output.master, 6067bd1d409SAlexander Shishkin .channel = stmf->output.channel, 6077bd1d409SAlexander Shishkin .width = stmf->output.nr_chans, 6087bd1d409SAlexander Shishkin .__reserved_0 = 0, 6097bd1d409SAlexander Shishkin .__reserved_1 = 0, 6107bd1d409SAlexander Shishkin }; 6117bd1d409SAlexander Shishkin 6127bd1d409SAlexander Shishkin return copy_to_user(arg, &id, id.size) ? -EFAULT : 0; 6137bd1d409SAlexander Shishkin } 6147bd1d409SAlexander Shishkin 6157bd1d409SAlexander Shishkin static long 6167bd1d409SAlexander Shishkin stm_char_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 6177bd1d409SAlexander Shishkin { 6187bd1d409SAlexander Shishkin struct stm_file *stmf = file->private_data; 6197bd1d409SAlexander Shishkin struct stm_data *stm_data = stmf->stm->data; 6207bd1d409SAlexander Shishkin int err = -ENOTTY; 6217bd1d409SAlexander Shishkin u64 options; 6227bd1d409SAlexander Shishkin 6237bd1d409SAlexander Shishkin switch (cmd) { 6247bd1d409SAlexander Shishkin case STP_POLICY_ID_SET: 6257bd1d409SAlexander Shishkin err = stm_char_policy_set_ioctl(stmf, (void __user *)arg); 6267bd1d409SAlexander Shishkin if (err) 6277bd1d409SAlexander Shishkin return err; 6287bd1d409SAlexander Shishkin 6297bd1d409SAlexander Shishkin return stm_char_policy_get_ioctl(stmf, (void __user *)arg); 6307bd1d409SAlexander Shishkin 6317bd1d409SAlexander Shishkin case STP_POLICY_ID_GET: 6327bd1d409SAlexander Shishkin return stm_char_policy_get_ioctl(stmf, (void __user *)arg); 6337bd1d409SAlexander Shishkin 6347bd1d409SAlexander Shishkin case STP_SET_OPTIONS: 6357bd1d409SAlexander Shishkin if (copy_from_user(&options, (u64 __user *)arg, sizeof(u64))) 6367bd1d409SAlexander Shishkin return -EFAULT; 6377bd1d409SAlexander Shishkin 6387bd1d409SAlexander Shishkin if (stm_data->set_options) 6397bd1d409SAlexander Shishkin err = stm_data->set_options(stm_data, 6407bd1d409SAlexander Shishkin stmf->output.master, 6417bd1d409SAlexander Shishkin stmf->output.channel, 6427bd1d409SAlexander Shishkin stmf->output.nr_chans, 6437bd1d409SAlexander Shishkin options); 6447bd1d409SAlexander Shishkin 6457bd1d409SAlexander Shishkin break; 6467bd1d409SAlexander Shishkin default: 6477bd1d409SAlexander Shishkin break; 6487bd1d409SAlexander Shishkin } 6497bd1d409SAlexander Shishkin 6507bd1d409SAlexander Shishkin return err; 6517bd1d409SAlexander Shishkin } 6527bd1d409SAlexander Shishkin 6537bd1d409SAlexander Shishkin #ifdef CONFIG_COMPAT 6547bd1d409SAlexander Shishkin static long 6557bd1d409SAlexander Shishkin stm_char_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 6567bd1d409SAlexander Shishkin { 6577bd1d409SAlexander Shishkin return stm_char_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 6587bd1d409SAlexander Shishkin } 6597bd1d409SAlexander Shishkin #else 6607bd1d409SAlexander Shishkin #define stm_char_compat_ioctl NULL 6617bd1d409SAlexander Shishkin #endif 6627bd1d409SAlexander Shishkin 6637bd1d409SAlexander Shishkin static const struct file_operations stm_fops = { 6647bd1d409SAlexander Shishkin .open = stm_char_open, 6657bd1d409SAlexander Shishkin .release = stm_char_release, 6667bd1d409SAlexander Shishkin .write = stm_char_write, 6677bd1d409SAlexander Shishkin .mmap = stm_char_mmap, 6687bd1d409SAlexander Shishkin .unlocked_ioctl = stm_char_ioctl, 6697bd1d409SAlexander Shishkin .compat_ioctl = stm_char_compat_ioctl, 6707bd1d409SAlexander Shishkin .llseek = no_llseek, 6717bd1d409SAlexander Shishkin }; 6727bd1d409SAlexander Shishkin 6737bd1d409SAlexander Shishkin static void stm_device_release(struct device *dev) 6747bd1d409SAlexander Shishkin { 6757bd1d409SAlexander Shishkin struct stm_device *stm = to_stm_device(dev); 6767bd1d409SAlexander Shishkin 6777bd1d409SAlexander Shishkin kfree(stm); 6787bd1d409SAlexander Shishkin } 6797bd1d409SAlexander Shishkin 6807bd1d409SAlexander Shishkin int stm_register_device(struct device *parent, struct stm_data *stm_data, 6817bd1d409SAlexander Shishkin struct module *owner) 6827bd1d409SAlexander Shishkin { 6837bd1d409SAlexander Shishkin struct stm_device *stm; 6847bd1d409SAlexander Shishkin unsigned int nmasters; 6857bd1d409SAlexander Shishkin int err = -ENOMEM; 6867bd1d409SAlexander Shishkin 6877bd1d409SAlexander Shishkin if (!stm_core_up) 6887bd1d409SAlexander Shishkin return -EPROBE_DEFER; 6897bd1d409SAlexander Shishkin 6907bd1d409SAlexander Shishkin if (!stm_data->packet || !stm_data->sw_nchannels) 6917bd1d409SAlexander Shishkin return -EINVAL; 6927bd1d409SAlexander Shishkin 6937b3bb0e7SChunyan Zhang nmasters = stm_data->sw_end - stm_data->sw_start + 1; 6947bd1d409SAlexander Shishkin stm = kzalloc(sizeof(*stm) + nmasters * sizeof(void *), GFP_KERNEL); 6957bd1d409SAlexander Shishkin if (!stm) 6967bd1d409SAlexander Shishkin return -ENOMEM; 6977bd1d409SAlexander Shishkin 6987bd1d409SAlexander Shishkin stm->major = register_chrdev(0, stm_data->name, &stm_fops); 6997bd1d409SAlexander Shishkin if (stm->major < 0) 7007bd1d409SAlexander Shishkin goto err_free; 7017bd1d409SAlexander Shishkin 7027bd1d409SAlexander Shishkin device_initialize(&stm->dev); 7037bd1d409SAlexander Shishkin stm->dev.devt = MKDEV(stm->major, 0); 7047bd1d409SAlexander Shishkin stm->dev.class = &stm_class; 7057bd1d409SAlexander Shishkin stm->dev.parent = parent; 7067bd1d409SAlexander Shishkin stm->dev.release = stm_device_release; 7077bd1d409SAlexander Shishkin 708389b6699SAlexander Shishkin mutex_init(&stm->link_mutex); 709389b6699SAlexander Shishkin spin_lock_init(&stm->link_lock); 710389b6699SAlexander Shishkin INIT_LIST_HEAD(&stm->link_list); 711389b6699SAlexander Shishkin 712389b6699SAlexander Shishkin /* initialize the object before it is accessible via sysfs */ 713389b6699SAlexander Shishkin spin_lock_init(&stm->mc_lock); 714389b6699SAlexander Shishkin mutex_init(&stm->policy_mutex); 715389b6699SAlexander Shishkin stm->sw_nmasters = nmasters; 716389b6699SAlexander Shishkin stm->owner = owner; 717389b6699SAlexander Shishkin stm->data = stm_data; 718389b6699SAlexander Shishkin stm_data->stm = stm; 719389b6699SAlexander Shishkin 7207bd1d409SAlexander Shishkin err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name); 7217bd1d409SAlexander Shishkin if (err) 7227bd1d409SAlexander Shishkin goto err_device; 7237bd1d409SAlexander Shishkin 7247bd1d409SAlexander Shishkin err = device_add(&stm->dev); 7257bd1d409SAlexander Shishkin if (err) 7267bd1d409SAlexander Shishkin goto err_device; 7277bd1d409SAlexander Shishkin 7288e0469a4SAlexander Shishkin /* 7298e0469a4SAlexander Shishkin * Use delayed autosuspend to avoid bouncing back and forth 7308e0469a4SAlexander Shishkin * on recurring character device writes, with the initial 7318e0469a4SAlexander Shishkin * delay time of 2 seconds. 7328e0469a4SAlexander Shishkin */ 7338e0469a4SAlexander Shishkin pm_runtime_no_callbacks(&stm->dev); 7348e0469a4SAlexander Shishkin pm_runtime_use_autosuspend(&stm->dev); 7358e0469a4SAlexander Shishkin pm_runtime_set_autosuspend_delay(&stm->dev, 2000); 7368e0469a4SAlexander Shishkin pm_runtime_set_suspended(&stm->dev); 7378e0469a4SAlexander Shishkin pm_runtime_enable(&stm->dev); 7388e0469a4SAlexander Shishkin 7397bd1d409SAlexander Shishkin return 0; 7407bd1d409SAlexander Shishkin 7417bd1d409SAlexander Shishkin err_device: 742cbe4a61dSAlexander Shishkin unregister_chrdev(stm->major, stm_data->name); 743cbe4a61dSAlexander Shishkin 744f7c81c71SAlexander Shishkin /* matches device_initialize() above */ 7457bd1d409SAlexander Shishkin put_device(&stm->dev); 7467bd1d409SAlexander Shishkin err_free: 7477bd1d409SAlexander Shishkin kfree(stm); 7487bd1d409SAlexander Shishkin 7497bd1d409SAlexander Shishkin return err; 7507bd1d409SAlexander Shishkin } 7517bd1d409SAlexander Shishkin EXPORT_SYMBOL_GPL(stm_register_device); 7527bd1d409SAlexander Shishkin 753b4ca34aaSAlexander Shishkin static int __stm_source_link_drop(struct stm_source_device *src, 7547bd1d409SAlexander Shishkin struct stm_device *stm); 7557bd1d409SAlexander Shishkin 7567bd1d409SAlexander Shishkin void stm_unregister_device(struct stm_data *stm_data) 7577bd1d409SAlexander Shishkin { 7587bd1d409SAlexander Shishkin struct stm_device *stm = stm_data->stm; 7597bd1d409SAlexander Shishkin struct stm_source_device *src, *iter; 760b4ca34aaSAlexander Shishkin int i, ret; 7617bd1d409SAlexander Shishkin 7628e0469a4SAlexander Shishkin pm_runtime_dont_use_autosuspend(&stm->dev); 7638e0469a4SAlexander Shishkin pm_runtime_disable(&stm->dev); 7648e0469a4SAlexander Shishkin 765c74f7e82SAlexander Shishkin mutex_lock(&stm->link_mutex); 7667bd1d409SAlexander Shishkin list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) { 767b4ca34aaSAlexander Shishkin ret = __stm_source_link_drop(src, stm); 768b4ca34aaSAlexander Shishkin /* 769b4ca34aaSAlexander Shishkin * src <-> stm link must not change under the same 770b4ca34aaSAlexander Shishkin * stm::link_mutex, so complain loudly if it has; 771b4ca34aaSAlexander Shishkin * also in this situation ret!=0 means this src is 772b4ca34aaSAlexander Shishkin * not connected to this stm and it should be otherwise 773b4ca34aaSAlexander Shishkin * safe to proceed with the tear-down of stm. 774b4ca34aaSAlexander Shishkin */ 775b4ca34aaSAlexander Shishkin WARN_ON_ONCE(ret); 7767bd1d409SAlexander Shishkin } 777c74f7e82SAlexander Shishkin mutex_unlock(&stm->link_mutex); 7787bd1d409SAlexander Shishkin 7797bd1d409SAlexander Shishkin synchronize_srcu(&stm_source_srcu); 7807bd1d409SAlexander Shishkin 7817bd1d409SAlexander Shishkin unregister_chrdev(stm->major, stm_data->name); 7827bd1d409SAlexander Shishkin 7837bd1d409SAlexander Shishkin mutex_lock(&stm->policy_mutex); 7847bd1d409SAlexander Shishkin if (stm->policy) 7857bd1d409SAlexander Shishkin stp_policy_unbind(stm->policy); 7867bd1d409SAlexander Shishkin mutex_unlock(&stm->policy_mutex); 7877bd1d409SAlexander Shishkin 78873a3ed19SChunyan Zhang for (i = stm->data->sw_start; i <= stm->data->sw_end; i++) 7897bd1d409SAlexander Shishkin stp_master_free(stm, i); 7907bd1d409SAlexander Shishkin 7917bd1d409SAlexander Shishkin device_unregister(&stm->dev); 7927bd1d409SAlexander Shishkin stm_data->stm = NULL; 7937bd1d409SAlexander Shishkin } 7947bd1d409SAlexander Shishkin EXPORT_SYMBOL_GPL(stm_unregister_device); 7957bd1d409SAlexander Shishkin 796c74f7e82SAlexander Shishkin /* 797c74f7e82SAlexander Shishkin * stm::link_list access serialization uses a spinlock and a mutex; holding 798c74f7e82SAlexander Shishkin * either of them guarantees that the list is stable; modification requires 799c74f7e82SAlexander Shishkin * holding both of them. 800c74f7e82SAlexander Shishkin * 801c74f7e82SAlexander Shishkin * Lock ordering is as follows: 802c74f7e82SAlexander Shishkin * stm::link_mutex 803c74f7e82SAlexander Shishkin * stm::link_lock 804c74f7e82SAlexander Shishkin * src::link_lock 805c74f7e82SAlexander Shishkin */ 806c74f7e82SAlexander Shishkin 8077bd1d409SAlexander Shishkin /** 8087bd1d409SAlexander Shishkin * stm_source_link_add() - connect an stm_source device to an stm device 8097bd1d409SAlexander Shishkin * @src: stm_source device 8107bd1d409SAlexander Shishkin * @stm: stm device 8117bd1d409SAlexander Shishkin * 8127bd1d409SAlexander Shishkin * This function establishes a link from stm_source to an stm device so that 8137bd1d409SAlexander Shishkin * the former can send out trace data to the latter. 8147bd1d409SAlexander Shishkin * 8157bd1d409SAlexander Shishkin * Return: 0 on success, -errno otherwise. 8167bd1d409SAlexander Shishkin */ 8177bd1d409SAlexander Shishkin static int stm_source_link_add(struct stm_source_device *src, 8187bd1d409SAlexander Shishkin struct stm_device *stm) 8197bd1d409SAlexander Shishkin { 8207bd1d409SAlexander Shishkin char *id; 8217bd1d409SAlexander Shishkin int err; 8227bd1d409SAlexander Shishkin 823c74f7e82SAlexander Shishkin mutex_lock(&stm->link_mutex); 8247bd1d409SAlexander Shishkin spin_lock(&stm->link_lock); 8257bd1d409SAlexander Shishkin spin_lock(&src->link_lock); 8267bd1d409SAlexander Shishkin 8277bd1d409SAlexander Shishkin /* src->link is dereferenced under stm_source_srcu but not the list */ 8287bd1d409SAlexander Shishkin rcu_assign_pointer(src->link, stm); 8297bd1d409SAlexander Shishkin list_add_tail(&src->link_entry, &stm->link_list); 8307bd1d409SAlexander Shishkin 8317bd1d409SAlexander Shishkin spin_unlock(&src->link_lock); 8327bd1d409SAlexander Shishkin spin_unlock(&stm->link_lock); 833c74f7e82SAlexander Shishkin mutex_unlock(&stm->link_mutex); 8347bd1d409SAlexander Shishkin 8357bd1d409SAlexander Shishkin id = kstrdup(src->data->name, GFP_KERNEL); 8367bd1d409SAlexander Shishkin if (id) { 8377bd1d409SAlexander Shishkin src->policy_node = 8387bd1d409SAlexander Shishkin stp_policy_node_lookup(stm, id); 8397bd1d409SAlexander Shishkin 8407bd1d409SAlexander Shishkin kfree(id); 8417bd1d409SAlexander Shishkin } 8427bd1d409SAlexander Shishkin 8437bd1d409SAlexander Shishkin err = stm_output_assign(stm, src->data->nr_chans, 8447bd1d409SAlexander Shishkin src->policy_node, &src->output); 8457bd1d409SAlexander Shishkin 8467bd1d409SAlexander Shishkin if (src->policy_node) 8477bd1d409SAlexander Shishkin stp_policy_node_put(src->policy_node); 8487bd1d409SAlexander Shishkin 8497bd1d409SAlexander Shishkin if (err) 8507bd1d409SAlexander Shishkin goto fail_detach; 8517bd1d409SAlexander Shishkin 8527bd1d409SAlexander Shishkin /* this is to notify the STM device that a new link has been made */ 8537bd1d409SAlexander Shishkin if (stm->data->link) 8547bd1d409SAlexander Shishkin err = stm->data->link(stm->data, src->output.master, 8557bd1d409SAlexander Shishkin src->output.channel); 8567bd1d409SAlexander Shishkin 8577bd1d409SAlexander Shishkin if (err) 8587bd1d409SAlexander Shishkin goto fail_free_output; 8597bd1d409SAlexander Shishkin 8607bd1d409SAlexander Shishkin /* this is to let the source carry out all necessary preparations */ 8617bd1d409SAlexander Shishkin if (src->data->link) 8627bd1d409SAlexander Shishkin src->data->link(src->data); 8637bd1d409SAlexander Shishkin 8647bd1d409SAlexander Shishkin return 0; 8657bd1d409SAlexander Shishkin 8667bd1d409SAlexander Shishkin fail_free_output: 8677bd1d409SAlexander Shishkin stm_output_free(stm, &src->output); 8687bd1d409SAlexander Shishkin 8697bd1d409SAlexander Shishkin fail_detach: 870c74f7e82SAlexander Shishkin mutex_lock(&stm->link_mutex); 8717bd1d409SAlexander Shishkin spin_lock(&stm->link_lock); 8727bd1d409SAlexander Shishkin spin_lock(&src->link_lock); 8737bd1d409SAlexander Shishkin 8747bd1d409SAlexander Shishkin rcu_assign_pointer(src->link, NULL); 8757bd1d409SAlexander Shishkin list_del_init(&src->link_entry); 8767bd1d409SAlexander Shishkin 8777bd1d409SAlexander Shishkin spin_unlock(&src->link_lock); 8787bd1d409SAlexander Shishkin spin_unlock(&stm->link_lock); 879c74f7e82SAlexander Shishkin mutex_unlock(&stm->link_mutex); 8807bd1d409SAlexander Shishkin 8817bd1d409SAlexander Shishkin return err; 8827bd1d409SAlexander Shishkin } 8837bd1d409SAlexander Shishkin 8847bd1d409SAlexander Shishkin /** 8857bd1d409SAlexander Shishkin * __stm_source_link_drop() - detach stm_source from an stm device 8867bd1d409SAlexander Shishkin * @src: stm_source device 8877bd1d409SAlexander Shishkin * @stm: stm device 8887bd1d409SAlexander Shishkin * 8897bd1d409SAlexander Shishkin * If @stm is @src::link, disconnect them from one another and put the 8907bd1d409SAlexander Shishkin * reference on the @stm device. 8917bd1d409SAlexander Shishkin * 892c74f7e82SAlexander Shishkin * Caller must hold stm::link_mutex. 8937bd1d409SAlexander Shishkin */ 894b4ca34aaSAlexander Shishkin static int __stm_source_link_drop(struct stm_source_device *src, 8957bd1d409SAlexander Shishkin struct stm_device *stm) 8967bd1d409SAlexander Shishkin { 8970df771deSAlexander Shishkin struct stm_device *link; 898b4ca34aaSAlexander Shishkin int ret = 0; 8990df771deSAlexander Shishkin 900c74f7e82SAlexander Shishkin lockdep_assert_held(&stm->link_mutex); 901c74f7e82SAlexander Shishkin 902c74f7e82SAlexander Shishkin /* for stm::link_list modification, we hold both mutex and spinlock */ 903c74f7e82SAlexander Shishkin spin_lock(&stm->link_lock); 9047bd1d409SAlexander Shishkin spin_lock(&src->link_lock); 9050df771deSAlexander Shishkin link = srcu_dereference_check(src->link, &stm_source_srcu, 1); 906b4ca34aaSAlexander Shishkin 907b4ca34aaSAlexander Shishkin /* 908b4ca34aaSAlexander Shishkin * The linked device may have changed since we last looked, because 909b4ca34aaSAlexander Shishkin * we weren't holding the src::link_lock back then; if this is the 910b4ca34aaSAlexander Shishkin * case, tell the caller to retry. 911b4ca34aaSAlexander Shishkin */ 912b4ca34aaSAlexander Shishkin if (link != stm) { 913b4ca34aaSAlexander Shishkin ret = -EAGAIN; 9141810f2c4SAlexander Shishkin goto unlock; 915b4ca34aaSAlexander Shishkin } 9167bd1d409SAlexander Shishkin 9170df771deSAlexander Shishkin stm_output_free(link, &src->output); 9187bd1d409SAlexander Shishkin list_del_init(&src->link_entry); 9198e0469a4SAlexander Shishkin pm_runtime_mark_last_busy(&link->dev); 9208e0469a4SAlexander Shishkin pm_runtime_put_autosuspend(&link->dev); 9217bd1d409SAlexander Shishkin /* matches stm_find_device() from stm_source_link_store() */ 9220df771deSAlexander Shishkin stm_put_device(link); 9237bd1d409SAlexander Shishkin rcu_assign_pointer(src->link, NULL); 9247bd1d409SAlexander Shishkin 9251810f2c4SAlexander Shishkin unlock: 9267bd1d409SAlexander Shishkin spin_unlock(&src->link_lock); 927c74f7e82SAlexander Shishkin spin_unlock(&stm->link_lock); 928b4ca34aaSAlexander Shishkin 929cc842407SAlexander Shishkin /* 930cc842407SAlexander Shishkin * Call the unlink callbacks for both source and stm, when we know 931cc842407SAlexander Shishkin * that we have actually performed the unlinking. 932cc842407SAlexander Shishkin */ 933cc842407SAlexander Shishkin if (!ret) { 934cc842407SAlexander Shishkin if (src->data->unlink) 935b4ca34aaSAlexander Shishkin src->data->unlink(src->data); 936b4ca34aaSAlexander Shishkin 937cc842407SAlexander Shishkin if (stm->data->unlink) 938cc842407SAlexander Shishkin stm->data->unlink(stm->data, src->output.master, 939cc842407SAlexander Shishkin src->output.channel); 940cc842407SAlexander Shishkin } 941cc842407SAlexander Shishkin 942b4ca34aaSAlexander Shishkin return ret; 9437bd1d409SAlexander Shishkin } 9447bd1d409SAlexander Shishkin 9457bd1d409SAlexander Shishkin /** 9467bd1d409SAlexander Shishkin * stm_source_link_drop() - detach stm_source from its stm device 9477bd1d409SAlexander Shishkin * @src: stm_source device 9487bd1d409SAlexander Shishkin * 9497bd1d409SAlexander Shishkin * Unlinking means disconnecting from source's STM device; after this 9507bd1d409SAlexander Shishkin * writes will be unsuccessful until it is linked to a new STM device. 9517bd1d409SAlexander Shishkin * 9527bd1d409SAlexander Shishkin * This will happen on "stm_source_link" sysfs attribute write to undo 9537bd1d409SAlexander Shishkin * the existing link (if any), or on linked STM device's de-registration. 9547bd1d409SAlexander Shishkin */ 9557bd1d409SAlexander Shishkin static void stm_source_link_drop(struct stm_source_device *src) 9567bd1d409SAlexander Shishkin { 9577bd1d409SAlexander Shishkin struct stm_device *stm; 958b4ca34aaSAlexander Shishkin int idx, ret; 9597bd1d409SAlexander Shishkin 960b4ca34aaSAlexander Shishkin retry: 9617bd1d409SAlexander Shishkin idx = srcu_read_lock(&stm_source_srcu); 962b4ca34aaSAlexander Shishkin /* 963b4ca34aaSAlexander Shishkin * The stm device will be valid for the duration of this 964b4ca34aaSAlexander Shishkin * read section, but the link may change before we grab 965b4ca34aaSAlexander Shishkin * the src::link_lock in __stm_source_link_drop(). 966b4ca34aaSAlexander Shishkin */ 9677bd1d409SAlexander Shishkin stm = srcu_dereference(src->link, &stm_source_srcu); 9687bd1d409SAlexander Shishkin 969b4ca34aaSAlexander Shishkin ret = 0; 9707bd1d409SAlexander Shishkin if (stm) { 971c74f7e82SAlexander Shishkin mutex_lock(&stm->link_mutex); 972b4ca34aaSAlexander Shishkin ret = __stm_source_link_drop(src, stm); 973c74f7e82SAlexander Shishkin mutex_unlock(&stm->link_mutex); 9747bd1d409SAlexander Shishkin } 9757bd1d409SAlexander Shishkin 9767bd1d409SAlexander Shishkin srcu_read_unlock(&stm_source_srcu, idx); 977b4ca34aaSAlexander Shishkin 978b4ca34aaSAlexander Shishkin /* if it did change, retry */ 979b4ca34aaSAlexander Shishkin if (ret == -EAGAIN) 980b4ca34aaSAlexander Shishkin goto retry; 9817bd1d409SAlexander Shishkin } 9827bd1d409SAlexander Shishkin 9837bd1d409SAlexander Shishkin static ssize_t stm_source_link_show(struct device *dev, 9847bd1d409SAlexander Shishkin struct device_attribute *attr, 9857bd1d409SAlexander Shishkin char *buf) 9867bd1d409SAlexander Shishkin { 9877bd1d409SAlexander Shishkin struct stm_source_device *src = to_stm_source_device(dev); 9887bd1d409SAlexander Shishkin struct stm_device *stm; 9897bd1d409SAlexander Shishkin int idx, ret; 9907bd1d409SAlexander Shishkin 9917bd1d409SAlexander Shishkin idx = srcu_read_lock(&stm_source_srcu); 9927bd1d409SAlexander Shishkin stm = srcu_dereference(src->link, &stm_source_srcu); 9937bd1d409SAlexander Shishkin ret = sprintf(buf, "%s\n", 9947bd1d409SAlexander Shishkin stm ? dev_name(&stm->dev) : "<none>"); 9957bd1d409SAlexander Shishkin srcu_read_unlock(&stm_source_srcu, idx); 9967bd1d409SAlexander Shishkin 9977bd1d409SAlexander Shishkin return ret; 9987bd1d409SAlexander Shishkin } 9997bd1d409SAlexander Shishkin 10007bd1d409SAlexander Shishkin static ssize_t stm_source_link_store(struct device *dev, 10017bd1d409SAlexander Shishkin struct device_attribute *attr, 10027bd1d409SAlexander Shishkin const char *buf, size_t count) 10037bd1d409SAlexander Shishkin { 10047bd1d409SAlexander Shishkin struct stm_source_device *src = to_stm_source_device(dev); 10057bd1d409SAlexander Shishkin struct stm_device *link; 10067bd1d409SAlexander Shishkin int err; 10077bd1d409SAlexander Shishkin 10087bd1d409SAlexander Shishkin stm_source_link_drop(src); 10097bd1d409SAlexander Shishkin 10107bd1d409SAlexander Shishkin link = stm_find_device(buf); 10117bd1d409SAlexander Shishkin if (!link) 10127bd1d409SAlexander Shishkin return -EINVAL; 10137bd1d409SAlexander Shishkin 10148e0469a4SAlexander Shishkin pm_runtime_get(&link->dev); 10158e0469a4SAlexander Shishkin 10167bd1d409SAlexander Shishkin err = stm_source_link_add(src, link); 1017f7c81c71SAlexander Shishkin if (err) { 10188e0469a4SAlexander Shishkin pm_runtime_put_autosuspend(&link->dev); 1019f7c81c71SAlexander Shishkin /* matches the stm_find_device() above */ 10207bd1d409SAlexander Shishkin stm_put_device(link); 1021f7c81c71SAlexander Shishkin } 10227bd1d409SAlexander Shishkin 10237bd1d409SAlexander Shishkin return err ? : count; 10247bd1d409SAlexander Shishkin } 10257bd1d409SAlexander Shishkin 10267bd1d409SAlexander Shishkin static DEVICE_ATTR_RW(stm_source_link); 10277bd1d409SAlexander Shishkin 10287bd1d409SAlexander Shishkin static struct attribute *stm_source_attrs[] = { 10297bd1d409SAlexander Shishkin &dev_attr_stm_source_link.attr, 10307bd1d409SAlexander Shishkin NULL, 10317bd1d409SAlexander Shishkin }; 10327bd1d409SAlexander Shishkin 10337bd1d409SAlexander Shishkin ATTRIBUTE_GROUPS(stm_source); 10347bd1d409SAlexander Shishkin 10357bd1d409SAlexander Shishkin static struct class stm_source_class = { 10367bd1d409SAlexander Shishkin .name = "stm_source", 10377bd1d409SAlexander Shishkin .dev_groups = stm_source_groups, 10387bd1d409SAlexander Shishkin }; 10397bd1d409SAlexander Shishkin 10407bd1d409SAlexander Shishkin static void stm_source_device_release(struct device *dev) 10417bd1d409SAlexander Shishkin { 10427bd1d409SAlexander Shishkin struct stm_source_device *src = to_stm_source_device(dev); 10437bd1d409SAlexander Shishkin 10447bd1d409SAlexander Shishkin kfree(src); 10457bd1d409SAlexander Shishkin } 10467bd1d409SAlexander Shishkin 10477bd1d409SAlexander Shishkin /** 10487bd1d409SAlexander Shishkin * stm_source_register_device() - register an stm_source device 10497bd1d409SAlexander Shishkin * @parent: parent device 10507bd1d409SAlexander Shishkin * @data: device description structure 10517bd1d409SAlexander Shishkin * 10527bd1d409SAlexander Shishkin * This will create a device of stm_source class that can write 10537bd1d409SAlexander Shishkin * data to an stm device once linked. 10547bd1d409SAlexander Shishkin * 10557bd1d409SAlexander Shishkin * Return: 0 on success, -errno otherwise. 10567bd1d409SAlexander Shishkin */ 10577bd1d409SAlexander Shishkin int stm_source_register_device(struct device *parent, 10587bd1d409SAlexander Shishkin struct stm_source_data *data) 10597bd1d409SAlexander Shishkin { 10607bd1d409SAlexander Shishkin struct stm_source_device *src; 10617bd1d409SAlexander Shishkin int err; 10627bd1d409SAlexander Shishkin 10637bd1d409SAlexander Shishkin if (!stm_core_up) 10647bd1d409SAlexander Shishkin return -EPROBE_DEFER; 10657bd1d409SAlexander Shishkin 10667bd1d409SAlexander Shishkin src = kzalloc(sizeof(*src), GFP_KERNEL); 10677bd1d409SAlexander Shishkin if (!src) 10687bd1d409SAlexander Shishkin return -ENOMEM; 10697bd1d409SAlexander Shishkin 10707bd1d409SAlexander Shishkin device_initialize(&src->dev); 10717bd1d409SAlexander Shishkin src->dev.class = &stm_source_class; 10727bd1d409SAlexander Shishkin src->dev.parent = parent; 10737bd1d409SAlexander Shishkin src->dev.release = stm_source_device_release; 10747bd1d409SAlexander Shishkin 10757bd1d409SAlexander Shishkin err = kobject_set_name(&src->dev.kobj, "%s", data->name); 10767bd1d409SAlexander Shishkin if (err) 10777bd1d409SAlexander Shishkin goto err; 10787bd1d409SAlexander Shishkin 10798e0469a4SAlexander Shishkin pm_runtime_no_callbacks(&src->dev); 10808e0469a4SAlexander Shishkin pm_runtime_forbid(&src->dev); 10818e0469a4SAlexander Shishkin 10827bd1d409SAlexander Shishkin err = device_add(&src->dev); 10837bd1d409SAlexander Shishkin if (err) 10847bd1d409SAlexander Shishkin goto err; 10857bd1d409SAlexander Shishkin 1086cde4ad83SAlexander Shishkin stm_output_init(&src->output); 10877bd1d409SAlexander Shishkin spin_lock_init(&src->link_lock); 10887bd1d409SAlexander Shishkin INIT_LIST_HEAD(&src->link_entry); 10897bd1d409SAlexander Shishkin src->data = data; 10907bd1d409SAlexander Shishkin data->src = src; 10917bd1d409SAlexander Shishkin 10927bd1d409SAlexander Shishkin return 0; 10937bd1d409SAlexander Shishkin 10947bd1d409SAlexander Shishkin err: 10957bd1d409SAlexander Shishkin put_device(&src->dev); 10967bd1d409SAlexander Shishkin kfree(src); 10977bd1d409SAlexander Shishkin 10987bd1d409SAlexander Shishkin return err; 10997bd1d409SAlexander Shishkin } 11007bd1d409SAlexander Shishkin EXPORT_SYMBOL_GPL(stm_source_register_device); 11017bd1d409SAlexander Shishkin 11027bd1d409SAlexander Shishkin /** 11037bd1d409SAlexander Shishkin * stm_source_unregister_device() - unregister an stm_source device 11047bd1d409SAlexander Shishkin * @data: device description that was used to register the device 11057bd1d409SAlexander Shishkin * 11067bd1d409SAlexander Shishkin * This will remove a previously created stm_source device from the system. 11077bd1d409SAlexander Shishkin */ 11087bd1d409SAlexander Shishkin void stm_source_unregister_device(struct stm_source_data *data) 11097bd1d409SAlexander Shishkin { 11107bd1d409SAlexander Shishkin struct stm_source_device *src = data->src; 11117bd1d409SAlexander Shishkin 11127bd1d409SAlexander Shishkin stm_source_link_drop(src); 11137bd1d409SAlexander Shishkin 1114fd085bb1SAlexander Shishkin device_unregister(&src->dev); 11157bd1d409SAlexander Shishkin } 11167bd1d409SAlexander Shishkin EXPORT_SYMBOL_GPL(stm_source_unregister_device); 11177bd1d409SAlexander Shishkin 11189dfed80dSChunyan Zhang int notrace stm_source_write(struct stm_source_data *data, 11199dfed80dSChunyan Zhang unsigned int chan, 11207bd1d409SAlexander Shishkin const char *buf, size_t count) 11217bd1d409SAlexander Shishkin { 11227bd1d409SAlexander Shishkin struct stm_source_device *src = data->src; 11237bd1d409SAlexander Shishkin struct stm_device *stm; 11247bd1d409SAlexander Shishkin int idx; 11257bd1d409SAlexander Shishkin 11267bd1d409SAlexander Shishkin if (!src->output.nr_chans) 11277bd1d409SAlexander Shishkin return -ENODEV; 11287bd1d409SAlexander Shishkin 11297bd1d409SAlexander Shishkin if (chan >= src->output.nr_chans) 11307bd1d409SAlexander Shishkin return -EINVAL; 11317bd1d409SAlexander Shishkin 11327bd1d409SAlexander Shishkin idx = srcu_read_lock(&stm_source_srcu); 11337bd1d409SAlexander Shishkin 11347bd1d409SAlexander Shishkin stm = srcu_dereference(src->link, &stm_source_srcu); 11357bd1d409SAlexander Shishkin if (stm) 1136f8560a9bSAlexander Shishkin count = stm_write(stm->data, src->output.master, 11377bd1d409SAlexander Shishkin src->output.channel + chan, 11387bd1d409SAlexander Shishkin buf, count); 11397bd1d409SAlexander Shishkin else 11407bd1d409SAlexander Shishkin count = -ENODEV; 11417bd1d409SAlexander Shishkin 11427bd1d409SAlexander Shishkin srcu_read_unlock(&stm_source_srcu, idx); 11437bd1d409SAlexander Shishkin 11447bd1d409SAlexander Shishkin return count; 11457bd1d409SAlexander Shishkin } 11467bd1d409SAlexander Shishkin EXPORT_SYMBOL_GPL(stm_source_write); 11477bd1d409SAlexander Shishkin 11487bd1d409SAlexander Shishkin static int __init stm_core_init(void) 11497bd1d409SAlexander Shishkin { 11507bd1d409SAlexander Shishkin int err; 11517bd1d409SAlexander Shishkin 11527bd1d409SAlexander Shishkin err = class_register(&stm_class); 11537bd1d409SAlexander Shishkin if (err) 11547bd1d409SAlexander Shishkin return err; 11557bd1d409SAlexander Shishkin 11567bd1d409SAlexander Shishkin err = class_register(&stm_source_class); 11577bd1d409SAlexander Shishkin if (err) 11587bd1d409SAlexander Shishkin goto err_stm; 11597bd1d409SAlexander Shishkin 11607bd1d409SAlexander Shishkin err = stp_configfs_init(); 11617bd1d409SAlexander Shishkin if (err) 11627bd1d409SAlexander Shishkin goto err_src; 11637bd1d409SAlexander Shishkin 11647bd1d409SAlexander Shishkin init_srcu_struct(&stm_source_srcu); 11657bd1d409SAlexander Shishkin 11667bd1d409SAlexander Shishkin stm_core_up++; 11677bd1d409SAlexander Shishkin 11687bd1d409SAlexander Shishkin return 0; 11697bd1d409SAlexander Shishkin 11707bd1d409SAlexander Shishkin err_src: 11717bd1d409SAlexander Shishkin class_unregister(&stm_source_class); 11727bd1d409SAlexander Shishkin err_stm: 11737bd1d409SAlexander Shishkin class_unregister(&stm_class); 11747bd1d409SAlexander Shishkin 11757bd1d409SAlexander Shishkin return err; 11767bd1d409SAlexander Shishkin } 11777bd1d409SAlexander Shishkin 11787bd1d409SAlexander Shishkin module_init(stm_core_init); 11797bd1d409SAlexander Shishkin 11807bd1d409SAlexander Shishkin static void __exit stm_core_exit(void) 11817bd1d409SAlexander Shishkin { 11827bd1d409SAlexander Shishkin cleanup_srcu_struct(&stm_source_srcu); 11837bd1d409SAlexander Shishkin class_unregister(&stm_source_class); 11847bd1d409SAlexander Shishkin class_unregister(&stm_class); 11857bd1d409SAlexander Shishkin stp_configfs_exit(); 11867bd1d409SAlexander Shishkin } 11877bd1d409SAlexander Shishkin 11887bd1d409SAlexander Shishkin module_exit(stm_core_exit); 11897bd1d409SAlexander Shishkin 11907bd1d409SAlexander Shishkin MODULE_LICENSE("GPL v2"); 11917bd1d409SAlexander Shishkin MODULE_DESCRIPTION("System Trace Module device class"); 11927bd1d409SAlexander Shishkin MODULE_AUTHOR("Alexander Shishkin <alexander.shishkin@linux.intel.com>"); 1193