Merge tag 'stm-for-greg-20160420' of... (2fc5ddaa) · Commits · 戴 / test

MAINTAINERS

+1 −0

Original line number	Diff line number	Diff line
		@@ -9754,6 +9754,7 @@ F: drivers/mmc/host/dw_mmc*
		SYSTEM TRACE MODULE CLASS
		M: Alexander Shishkin <alexander.shishkin@linux.intel.com>
		S: Maintained
		T: git git://git.kernel.org/pub/scm/linux/kernel/git/ash/stm.git
		F: Documentation/trace/stm.txt
		F: drivers/hwtracing/stm/
		F: include/linux/stm.h

drivers/hwtracing/intel_th/core.c

+27 −2

Original line number	Diff line number	Diff line
		@@ -71,6 +71,15 @@ static int intel_th_probe(struct device *dev)
		if (ret)
		return ret;

		if (thdrv->attr_group) {
		ret = sysfs_create_group(&thdev->dev.kobj, thdrv->attr_group);
		if (ret) {
		thdrv->remove(thdev);

		return ret;
		}
		}

		if (thdev->type == INTEL_TH_OUTPUT &&
		!intel_th_output_assigned(thdev))
		ret = hubdrv->assign(hub, thdev);
		@@ -91,6 +100,9 @@ static int intel_th_remove(struct device *dev)
		return err;
		}

		if (thdrv->attr_group)
		sysfs_remove_group(&thdev->dev.kobj, thdrv->attr_group);

		thdrv->remove(thdev);

		if (intel_th_output_assigned(thdev)) {
		@@ -171,7 +183,14 @@ static DEVICE_ATTR_RO(port);

		static int intel_th_output_activate(struct intel_th_device *thdev)
		{
		struct intel_th_driver *thdrv = to_intel_th_driver(thdev->dev.driver);
		struct intel_th_driver *thdrv =
		to_intel_th_driver_or_null(thdev->dev.driver);

		if (!thdrv)
		return -ENODEV;

		if (!try_module_get(thdrv->driver.owner))
		return -ENODEV;

		if (thdrv->activate)
		return thdrv->activate(thdev);
		@@ -183,12 +202,18 @@ static int intel_th_output_activate(struct intel_th_device *thdev)

		static void intel_th_output_deactivate(struct intel_th_device *thdev)
		{
		struct intel_th_driver *thdrv = to_intel_th_driver(thdev->dev.driver);
		struct intel_th_driver *thdrv =
		to_intel_th_driver_or_null(thdev->dev.driver);

		if (!thdrv)
		return;

		if (thdrv->deactivate)
		thdrv->deactivate(thdev);
		else
		intel_th_trace_disable(thdev);

		module_put(thdrv->driver.owner);
		}

		static ssize_t active_show(struct device dev, struct device_attribute attr,

drivers/hwtracing/intel_th/intel_th.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -115,6 +115,7 @@ intel_th_output_assigned(struct intel_th_device *thdev)
		* @enable: enable tracing for a given output device
		* @disable: disable tracing for a given output device
		* @fops: file operations for device nodes
		* @attr_group: attributes provided by the driver
		*
		* Callbacks @probe and @remove are required for all device types.
		* Switch device driver needs to fill in @assign, @enable and @disable
		@@ -139,6 +140,8 @@ struct intel_th_driver {
		void (deactivate)(struct intel_th_device thdev);
		/* file_operations for those who want a device node */
		const struct file_operations *fops;
		/* optional attributes */
		struct attribute_group *attr_group;

		/* source ops */
		int (set_output)(struct intel_th_device thdev,
		@@ -148,6 +151,9 @@ struct intel_th_driver {
		#define to_intel_th_driver(_d) \
		container_of((_d), struct intel_th_driver, driver)

		#define to_intel_th_driver_or_null(_d) \
		((_d) ? to_intel_th_driver(_d) : NULL)

		static inline struct intel_th_device *
		to_intel_th_hub(struct intel_th_device *thdev)
		{

drivers/hwtracing/intel_th/msu.c

+68 −48

Original line number	Diff line number	Diff line
		@@ -122,7 +122,6 @@ struct msc {
		atomic_t mmap_count;
		struct mutex buf_mutex;

		struct mutex iter_mutex;
		struct list_head iter_list;

		/* config */
		@@ -257,23 +256,37 @@ static struct msc_iter msc_iter_install(struct msc msc)

		iter = kzalloc(sizeof(*iter), GFP_KERNEL);
		if (!iter)
		return NULL;
		return ERR_PTR(-ENOMEM);

		mutex_lock(&msc->buf_mutex);

		/*
		* Reading and tracing are mutually exclusive; if msc is
		* enabled, open() will fail; otherwise existing readers
		* will prevent enabling the msc and the rest of fops don't
		* need to worry about it.
		*/
		if (msc->enabled) {
		kfree(iter);
		iter = ERR_PTR(-EBUSY);
		goto unlock;
		}

		msc_iter_init(iter);
		iter->msc = msc;

		mutex_lock(&msc->iter_mutex);
		list_add_tail(&iter->entry, &msc->iter_list);
		mutex_unlock(&msc->iter_mutex);
		unlock:
		mutex_unlock(&msc->buf_mutex);

		return iter;
		}

		static void msc_iter_remove(struct msc_iter iter, struct msc msc)
		{
		mutex_lock(&msc->iter_mutex);
		mutex_lock(&msc->buf_mutex);
		list_del(&iter->entry);
		mutex_unlock(&msc->iter_mutex);
		mutex_unlock(&msc->buf_mutex);

		kfree(iter);
		}
		@@ -454,7 +467,6 @@ static void msc_buffer_clear_hw_header(struct msc *msc)
		{
		struct msc_window *win;

		mutex_lock(&msc->buf_mutex);
		list_for_each_entry(win, &msc->win_list, entry) {
		unsigned int blk;
		size_t hw_sz = sizeof(struct msc_block_desc) -
		@@ -466,7 +478,6 @@ static void msc_buffer_clear_hw_header(struct msc *msc)
		memset(&bdesc->hw_tag, 0, hw_sz);
		}
		}
		mutex_unlock(&msc->buf_mutex);
		}

		/**
		@@ -474,12 +485,15 @@ static void msc_buffer_clear_hw_header(struct msc *msc)
		* @msc: the MSC device to configure
		*
		* Program storage mode, wrapping, burst length and trace buffer address
		* into a given MSC. If msc::enabled is set, enable the trace, too.
		* into a given MSC. Then, enable tracing and set msc::enabled.
		* The latter is serialized on msc::buf_mutex, so make sure to hold it.
		*/
		static int msc_configure(struct msc *msc)
		{
		u32 reg;

		lockdep_assert_held(&msc->buf_mutex);

		if (msc->mode > MSC_MODE_MULTI)
		return -ENOTSUPP;

		@@ -497,21 +511,19 @@ static int msc_configure(struct msc *msc)
		reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);
		reg &= ~(MSC_MODE \| MSC_WRAPEN \| MSC_EN \| MSC_RD_HDR_OVRD);

		reg \|= MSC_EN;
		reg \|= msc->mode << __ffs(MSC_MODE);
		reg \|= msc->burst_len << __ffs(MSC_LEN);
		/*if (msc->mode == MSC_MODE_MULTI)
		reg \|= MSC_RD_HDR_OVRD; */

		if (msc->wrap)
		reg \|= MSC_WRAPEN;
		if (msc->enabled)
		reg \|= MSC_EN;

		iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);

		if (msc->enabled) {
		msc->thdev->output.multiblock = msc->mode == MSC_MODE_MULTI;
		intel_th_trace_enable(msc->thdev);
		}
		msc->enabled = 1;


		return 0;
		}
		@@ -521,15 +533,14 @@ static int msc_configure(struct msc *msc)
		* @msc: MSC device to disable
		*
		* If @msc is enabled, disable tracing on the switch and then disable MSC
		* storage.
		* storage. Caller must hold msc::buf_mutex.
		*/
		static void msc_disable(struct msc *msc)
		{
		unsigned long count;
		u32 reg;

		if (!msc->enabled)
		return;
		lockdep_assert_held(&msc->buf_mutex);

		intel_th_trace_disable(msc->thdev);

		@@ -569,34 +580,36 @@ static void msc_disable(struct msc *msc)
		static int intel_th_msc_activate(struct intel_th_device *thdev)
		{
		struct msc *msc = dev_get_drvdata(&thdev->dev);
		int ret = 0;
		int ret = -EBUSY;

		if (!atomic_inc_unless_negative(&msc->user_count))
		return -ENODEV;

		mutex_lock(&msc->iter_mutex);
		if (!list_empty(&msc->iter_list))
		ret = -EBUSY;
		mutex_unlock(&msc->iter_mutex);
		mutex_lock(&msc->buf_mutex);

		if (ret) {
		atomic_dec(&msc->user_count);
		return ret;
		}
		/* if there are readers, refuse */
		if (list_empty(&msc->iter_list))
		ret = msc_configure(msc);

		msc->enabled = 1;
		mutex_unlock(&msc->buf_mutex);

		return msc_configure(msc);
		if (ret)
		atomic_dec(&msc->user_count);

		return ret;
		}

		static void intel_th_msc_deactivate(struct intel_th_device *thdev)
		{
		struct msc *msc = dev_get_drvdata(&thdev->dev);

		mutex_lock(&msc->buf_mutex);
		if (msc->enabled) {
		msc_disable(msc);

		atomic_dec(&msc->user_count);
		}
		mutex_unlock(&msc->buf_mutex);
		}

		/**
		* msc_buffer_contig_alloc() - allocate a contiguous buffer for SINGLE mode
		@@ -1035,8 +1048,8 @@ static int intel_th_msc_open(struct inode inode, struct file file)
		return -EPERM;

		iter = msc_iter_install(msc);
		if (!iter)
		return -ENOMEM;
		if (IS_ERR(iter))
		return PTR_ERR(iter);

		file->private_data = iter;

		@@ -1101,11 +1114,6 @@ static ssize_t intel_th_msc_read(struct file file, char __user buf,
		if (!atomic_inc_unless_negative(&msc->user_count))
		return 0;

		if (msc->enabled) {
		ret = -EBUSY;
		goto put_count;
		}

		if (msc->mode == MSC_MODE_SINGLE && !msc->single_wrap)
		size = msc->single_sz;
		else
		@@ -1245,6 +1253,7 @@ static const struct file_operations intel_th_msc_fops = {
		.read = intel_th_msc_read,
		.mmap = intel_th_msc_mmap,
		.llseek = no_llseek,
		.owner = THIS_MODULE,
		};

		static int intel_th_msc_init(struct msc *msc)
		@@ -1254,8 +1263,6 @@ static int intel_th_msc_init(struct msc *msc)
		msc->mode = MSC_MODE_MULTI;
		mutex_init(&msc->buf_mutex);
		INIT_LIST_HEAD(&msc->win_list);

		mutex_init(&msc->iter_mutex);
		INIT_LIST_HEAD(&msc->iter_list);

		msc->burst_len =
		@@ -1393,6 +1400,11 @@ nr_pages_store(struct device dev, struct device_attribute attr,
		do {
		end = memchr(p, ',', len);
		s = kstrndup(p, end ? end - p : len, GFP_KERNEL);
		if (!s) {
		ret = -ENOMEM;
		goto free_win;
		}

		ret = kstrtoul(s, 10, &val);
		kfree(s);

		@@ -1473,10 +1485,6 @@ static int intel_th_msc_probe(struct intel_th_device *thdev)
		if (err)
		return err;

		err = sysfs_create_group(&dev->kobj, &msc_output_group);
		if (err)
		return err;

		dev_set_drvdata(dev, msc);

		return 0;
		@@ -1484,7 +1492,18 @@ static int intel_th_msc_probe(struct intel_th_device *thdev)

		static void intel_th_msc_remove(struct intel_th_device *thdev)
		{
		sysfs_remove_group(&thdev->dev.kobj, &msc_output_group);
		struct msc *msc = dev_get_drvdata(&thdev->dev);
		int ret;

		intel_th_msc_deactivate(thdev);

		/*
		* Buffers should not be used at this point except if the
		* output character device is still open and the parent
		* device gets detached from its bus, which is a FIXME.
		*/
		ret = msc_buffer_free_unless_used(msc);
		WARN_ON_ONCE(ret);
		}

		static struct intel_th_driver intel_th_msc_driver = {
		@@ -1493,6 +1512,7 @@ static struct intel_th_driver intel_th_msc_driver = {
		.activate = intel_th_msc_activate,
		.deactivate = intel_th_msc_deactivate,
		.fops = &intel_th_msc_fops,
		.attr_group = &msc_output_group,
		.driver = {
		.name = "msc",
		.owner = THIS_MODULE,

drivers/hwtracing/intel_th/pci.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -75,6 +75,11 @@ static const struct pci_device_id intel_th_pci_id_table[] = {
		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0a80),
		.driver_data = (kernel_ulong_t)0,
		},
		{
		/* Broxton B-step */
		PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x1a8e),
		.driver_data = (kernel_ulong_t)0,
		},
		{ 0 },
		};

Admin message