Merge branch 'acpi-lpss' into linux-next (16b53e7e) · Commits · 戴 / test

Documentation/ABI/testing/sysfs-devices-lpss_ltr

0 → 100644

+44 −0

Original line number	Diff line number	Diff line
		What: /sys/devices/.../lpss_ltr/
		Date: March 2013
		Contact: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		Description:
		The /sys/devices/.../lpss_ltr/ directory is only present for
		devices included into the Intel Lynxpoint Low Power Subsystem
		(LPSS). If present, it contains attributes containing the LTR
		mode and the values of LTR registers of the device.

		What: /sys/devices/.../lpss_ltr/ltr_mode
		Date: March 2013
		Contact: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		Description:
		The /sys/devices/.../lpss_ltr/ltr_mode attribute contains an
		integer number (0 or 1) indicating whether or not the devices'
		LTR functionality is working in the software mode (1).

		This attribute is read-only. If the device's runtime PM status
		is not "active", attempts to read from this attribute cause
		-EAGAIN to be returned.

		What: /sys/devices/.../lpss_ltr/auto_ltr
		Date: March 2013
		Contact: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		Description:
		The /sys/devices/.../lpss_ltr/auto_ltr attribute contains the
		current value of the device's AUTO_LTR register (raw)
		represented as an 8-digit hexadecimal number.

		This attribute is read-only. If the device's runtime PM status
		is not "active", attempts to read from this attribute cause
		-EAGAIN to be returned.

		What: /sys/devices/.../lpss_ltr/sw_ltr
		Date: March 2013
		Contact: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		Description:
		The /sys/devices/.../lpss_ltr/auto_ltr attribute contains the
		current value of the device's SW_LTR register (raw) represented
		as an 8-digit hexadecimal number.

		This attribute is read-only. If the device's runtime PM status
		is not "active", attempts to read from this attribute cause
		-EAGAIN to be returned.

drivers/acpi/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,7 @@ acpi-y += ec.o
		acpi-$(CONFIG_ACPI_DOCK) += dock.o
		acpi-y += pci_root.o pci_link.o pci_irq.o
		acpi-y += csrt.o
		acpi-$(CONFIG_X86_INTEL_LPSS) += acpi_lpss.o
		acpi-y += acpi_platform.o
		acpi-y += power.o
		acpi-y += event.o

drivers/acpi/acpi_lpss.c

0 → 100644

+292 −0

Original line number	Diff line number	Diff line
		/*
		* ACPI support for Intel Lynxpoint LPSS.
		*
		* Copyright (C) 2013, Intel Corporation
		* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
		* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/

		#include <linux/acpi.h>
		#include <linux/clk.h>
		#include <linux/clkdev.h>
		#include <linux/clk-provider.h>
		#include <linux/err.h>
		#include <linux/io.h>
		#include <linux/platform_device.h>
		#include <linux/platform_data/clk-lpss.h>
		#include <linux/pm_runtime.h>

		#include "internal.h"

		ACPI_MODULE_NAME("acpi_lpss");

		#define LPSS_CLK_SIZE 0x04
		#define LPSS_LTR_SIZE 0x18

		/* Offsets relative to LPSS_PRIVATE_OFFSET */
		#define LPSS_GENERAL 0x08
		#define LPSS_GENERAL_LTR_MODE_SW BIT(2)
		#define LPSS_SW_LTR 0x10
		#define LPSS_AUTO_LTR 0x14

		struct lpss_device_desc {
		bool clk_required;
		const char *clk_parent;
		bool ltr_required;
		unsigned int prv_offset;
		};

		struct lpss_private_data {
		void __iomem *mmio_base;
		resource_size_t mmio_size;
		struct clk *clk;
		const struct lpss_device_desc *dev_desc;
		};

		static struct lpss_device_desc lpt_dev_desc = {
		.clk_required = true,
		.clk_parent = "lpss_clk",
		.prv_offset = 0x800,
		.ltr_required = true,
		};

		static struct lpss_device_desc lpt_sdio_dev_desc = {
		.prv_offset = 0x1000,
		.ltr_required = true,
		};

		static const struct acpi_device_id acpi_lpss_device_ids[] = {
		/* Lynxpoint LPSS devices */
		{ "INT33C0", (unsigned long)&lpt_dev_desc },
		{ "INT33C1", (unsigned long)&lpt_dev_desc },
		{ "INT33C2", (unsigned long)&lpt_dev_desc },
		{ "INT33C3", (unsigned long)&lpt_dev_desc },
		{ "INT33C4", (unsigned long)&lpt_dev_desc },
		{ "INT33C5", (unsigned long)&lpt_dev_desc },
		{ "INT33C6", (unsigned long)&lpt_sdio_dev_desc },
		{ "INT33C7", },

		{ }
		};

		static int is_memory(struct acpi_resource res, void not_used)
		{
		struct resource r;
		return !acpi_dev_resource_memory(res, &r);
		}

		/* LPSS main clock device. */
		static struct platform_device *lpss_clk_dev;

		static inline void lpt_register_clock_device(void)
		{
		lpss_clk_dev = platform_device_register_simple("clk-lpt", -1, NULL, 0);
		}

		static int register_device_clock(struct acpi_device *adev,
		struct lpss_private_data *pdata)
		{
		const struct lpss_device_desc *dev_desc = pdata->dev_desc;

		if (!lpss_clk_dev)
		lpt_register_clock_device();

		if (!dev_desc->clk_parent \|\| !pdata->mmio_base
		\|\| pdata->mmio_size < dev_desc->prv_offset + LPSS_CLK_SIZE)
		return -ENODATA;

		pdata->clk = clk_register_gate(NULL, dev_name(&adev->dev),
		dev_desc->clk_parent, 0,
		pdata->mmio_base + dev_desc->prv_offset,
		0, 0, NULL);
		if (IS_ERR(pdata->clk))
		return PTR_ERR(pdata->clk);

		clk_register_clkdev(pdata->clk, NULL, dev_name(&adev->dev));
		return 0;
		}

		static int acpi_lpss_create_device(struct acpi_device *adev,
		const struct acpi_device_id *id)
		{
		struct lpss_device_desc *dev_desc;
		struct lpss_private_data *pdata;
		struct resource_list_entry *rentry;
		struct list_head resource_list;
		int ret;

		dev_desc = (struct lpss_device_desc *)id->driver_data;
		if (!dev_desc)
		return acpi_create_platform_device(adev, id);

		pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
		if (!pdata)
		return -ENOMEM;

		INIT_LIST_HEAD(&resource_list);
		ret = acpi_dev_get_resources(adev, &resource_list, is_memory, NULL);
		if (ret < 0)
		goto err_out;

		list_for_each_entry(rentry, &resource_list, node)
		if (resource_type(&rentry->res) == IORESOURCE_MEM) {
		pdata->mmio_size = resource_size(&rentry->res);
		pdata->mmio_base = ioremap(rentry->res.start,
		pdata->mmio_size);
		pdata->dev_desc = dev_desc;
		break;
		}

		acpi_dev_free_resource_list(&resource_list);

		if (dev_desc->clk_required) {
		ret = register_device_clock(adev, pdata);
		if (ret) {
		/*
		* Skip the device, but don't terminate the namespace
		* scan.
		*/
		kfree(pdata);
		return 0;
		}
		}

		adev->driver_data = pdata;
		ret = acpi_create_platform_device(adev, id);
		if (ret > 0)
		return ret;

		adev->driver_data = NULL;

		err_out:
		kfree(pdata);
		return ret;
		}

		static int lpss_reg_read(struct device dev, unsigned int reg, u32 val)
		{
		struct acpi_device *adev;
		struct lpss_private_data *pdata;
		unsigned long flags;
		int ret;

		ret = acpi_bus_get_device(ACPI_HANDLE(dev), &adev);
		if (WARN_ON(ret))
		return ret;

		spin_lock_irqsave(&dev->power.lock, flags);
		if (pm_runtime_suspended(dev)) {
		ret = -EAGAIN;
		goto out;
		}
		pdata = acpi_driver_data(adev);
		if (WARN_ON(!pdata \|\| !pdata->mmio_base)) {
		ret = -ENODEV;
		goto out;
		}
		*val = readl(pdata->mmio_base + pdata->dev_desc->prv_offset + reg);

		out:
		spin_unlock_irqrestore(&dev->power.lock, flags);
		return ret;
		}

		static ssize_t lpss_ltr_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		u32 ltr_value = 0;
		unsigned int reg;
		int ret;

		reg = strcmp(attr->attr.name, "auto_ltr") ? LPSS_SW_LTR : LPSS_AUTO_LTR;
		ret = lpss_reg_read(dev, reg, &ltr_value);
		if (ret)
		return ret;

		return snprintf(buf, PAGE_SIZE, "%08x\n", ltr_value);
		}

		static ssize_t lpss_ltr_mode_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		u32 ltr_mode = 0;
		char *outstr;
		int ret;

		ret = lpss_reg_read(dev, LPSS_GENERAL, &ltr_mode);
		if (ret)
		return ret;

		outstr = (ltr_mode & LPSS_GENERAL_LTR_MODE_SW) ? "sw" : "auto";
		return sprintf(buf, "%s\n", outstr);
		}

		static DEVICE_ATTR(auto_ltr, S_IRUSR, lpss_ltr_show, NULL);
		static DEVICE_ATTR(sw_ltr, S_IRUSR, lpss_ltr_show, NULL);
		static DEVICE_ATTR(ltr_mode, S_IRUSR, lpss_ltr_mode_show, NULL);

		static struct attribute *lpss_attrs[] = {
		&dev_attr_auto_ltr.attr,
		&dev_attr_sw_ltr.attr,
		&dev_attr_ltr_mode.attr,
		NULL,
		};

		static struct attribute_group lpss_attr_group = {
		.attrs = lpss_attrs,
		.name = "lpss_ltr",
		};

		static int acpi_lpss_platform_notify(struct notifier_block *nb,
		unsigned long action, void *data)
		{
		struct platform_device *pdev = to_platform_device(data);
		struct lpss_private_data *pdata;
		struct acpi_device *adev;
		const struct acpi_device_id *id;
		int ret = 0;

		id = acpi_match_device(acpi_lpss_device_ids, &pdev->dev);
		if (!id \|\| !id->driver_data)
		return 0;

		if (acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev))
		return 0;

		pdata = acpi_driver_data(adev);
		if (!pdata \|\| !pdata->mmio_base \|\| !pdata->dev_desc->ltr_required)
		return 0;

		if (pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) {
		dev_err(&pdev->dev, "MMIO size insufficient to access LTR\n");
		return 0;
		}

		if (action == BUS_NOTIFY_ADD_DEVICE)
		ret = sysfs_create_group(&pdev->dev.kobj, &lpss_attr_group);
		else if (action == BUS_NOTIFY_DEL_DEVICE)
		sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group);

		return ret;
		}

		static struct notifier_block acpi_lpss_nb = {
		.notifier_call = acpi_lpss_platform_notify,
		};

		static struct acpi_scan_handler lpss_handler = {
		.ids = acpi_lpss_device_ids,
		.attach = acpi_lpss_create_device,
		};

		void __init acpi_lpss_init(void)
		{
		if (!lpt_clk_init()) {
		bus_register_notifier(&platform_bus_type, &acpi_lpss_nb);
		acpi_scan_add_handler(&lpss_handler);
		}
		}

drivers/acpi/acpi_platform.c

+2 −38

Original line number	Diff line number	Diff line
		@@ -22,9 +22,6 @@

		ACPI_MODULE_NAME("platform");

		/* Flags for acpi_create_platform_device */
		#define ACPI_PLATFORM_CLK BIT(0)

		/*
		* The following ACPI IDs are known to be suitable for representing as
		* platform devices.
		@@ -33,33 +30,9 @@ static const struct acpi_device_id acpi_platform_device_ids[] = {

		{ "PNP0D40" },

		/* Haswell LPSS devices */
		{ "INT33C0", ACPI_PLATFORM_CLK },
		{ "INT33C1", ACPI_PLATFORM_CLK },
		{ "INT33C2", ACPI_PLATFORM_CLK },
		{ "INT33C3", ACPI_PLATFORM_CLK },
		{ "INT33C4", ACPI_PLATFORM_CLK },
		{ "INT33C5", ACPI_PLATFORM_CLK },
		{ "INT33C6", ACPI_PLATFORM_CLK },
		{ "INT33C7", ACPI_PLATFORM_CLK },

		{ }
		};

		static int acpi_create_platform_clks(struct acpi_device *adev)
		{
		static struct platform_device *pdev;

		/* Create Lynxpoint LPSS clocks */
		if (!pdev && !strncmp(acpi_device_hid(adev), "INT33C", 6)) {
		pdev = platform_device_register_simple("clk-lpt", -1, NULL, 0);
		if (IS_ERR(pdev))
		return PTR_ERR(pdev);
		}

		return 0;
		}

		/**
		* acpi_create_platform_device - Create platform device for ACPI device node
		* @adev: ACPI device node to create a platform device for.
		@@ -71,10 +44,9 @@ static int acpi_create_platform_clks(struct acpi_device *adev)
		*
		* Name of the platform device will be the same as @adev's.
		*/
		static int acpi_create_platform_device(struct acpi_device *adev,
		int acpi_create_platform_device(struct acpi_device *adev,
		const struct acpi_device_id *id)
		{
		unsigned long flags = id->driver_data;
		struct platform_device *pdev = NULL;
		struct acpi_device *acpi_parent;
		struct platform_device_info pdevinfo;
		@@ -83,14 +55,6 @@ static int acpi_create_platform_device(struct acpi_device *adev,
		struct resource *resources;
		int count;

		if (flags & ACPI_PLATFORM_CLK) {
		int ret = acpi_create_platform_clks(adev);
		if (ret) {
		dev_err(&adev->dev, "failed to create clocks\n");
		return ret;
		}
		}

		/* If the ACPI node already has a physical device attached, skip it. */
		if (adev->physical_node_count)
		return 0;

drivers/acpi/internal.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,11 @@ int acpi_debugfs_init(void);
		#else
		static inline void acpi_debugfs_init(void) { return; }
		#endif
		#ifdef CONFIG_X86_INTEL_LPSS
		void acpi_lpss_init(void);
		#else
		static inline void acpi_lpss_init(void) {}
		#endif

		/* --------------------------------------------------------------------------
		Device Node Initialization / Removal
		@@ -142,4 +147,7 @@ static inline void suspend_nvs_restore(void) {}
		-------------------------------------------------------------------------- */
		struct platform_device;

		int acpi_create_platform_device(struct acpi_device *adev,
		const struct acpi_device_id *id);

		#endif /* _ACPI_INTERNAL_H_ */

Admin message