[mirror_ubuntu-hirsute-kernel.git] / drivers / mfd / intel-lpss-acpi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Intel LPSS ACPI support.
 *
 * Copyright (C) 2015, Intel Corporation
 *
 * Authors: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
 *          Mika Westerberg <mika.westerberg@linux.intel.com>
 */

#include <linux/acpi.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/platform_device.h>
#include <linux/property.h>

#include "intel-lpss.h"

static const struct intel_lpss_platform_info spt_info = {
	.clk_rate = 120000000,
};

static struct property_entry spt_i2c_properties[] = {
	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 230),
	{ },
};

static const struct intel_lpss_platform_info spt_i2c_info = {
	.clk_rate = 120000000,
	.properties = spt_i2c_properties,
};

static struct property_entry uart_properties[] = {
	PROPERTY_ENTRY_U32("reg-io-width", 4),
	PROPERTY_ENTRY_U32("reg-shift", 2),
	PROPERTY_ENTRY_BOOL("snps,uart-16550-compatible"),
	{ },
};

static const struct intel_lpss_platform_info spt_uart_info = {
	.clk_rate = 120000000,
	.clk_con_id = "baudclk",
	.properties = uart_properties,
};

static const struct intel_lpss_platform_info bxt_info = {
	.clk_rate = 100000000,
};

static struct property_entry bxt_i2c_properties[] = {
	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 42),
	PROPERTY_ENTRY_U32("i2c-sda-falling-time-ns", 171),
	PROPERTY_ENTRY_U32("i2c-scl-falling-time-ns", 208),
	{ },
};

static const struct intel_lpss_platform_info bxt_i2c_info = {
	.clk_rate = 133000000,
	.properties = bxt_i2c_properties,
};

static struct property_entry apl_i2c_properties[] = {
	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 207),
	PROPERTY_ENTRY_U32("i2c-sda-falling-time-ns", 171),
	PROPERTY_ENTRY_U32("i2c-scl-falling-time-ns", 208),
	{ },
};

static const struct intel_lpss_platform_info apl_i2c_info = {
	.clk_rate = 133000000,
	.properties = apl_i2c_properties,
};

static const struct acpi_device_id intel_lpss_acpi_ids[] = {
	/* SPT */
	{ "INT3440", (kernel_ulong_t)&spt_info },
	{ "INT3441", (kernel_ulong_t)&spt_info },
	{ "INT3442", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3443", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3444", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3445", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3446", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3447", (kernel_ulong_t)&spt_i2c_info },
	{ "INT3448", (kernel_ulong_t)&spt_uart_info },
	{ "INT3449", (kernel_ulong_t)&spt_uart_info },
	{ "INT344A", (kernel_ulong_t)&spt_uart_info },
	/* BXT */
	{ "80860AAC", (kernel_ulong_t)&bxt_i2c_info },
	{ "80860ABC", (kernel_ulong_t)&bxt_info },
	{ "80860AC2", (kernel_ulong_t)&bxt_info },
	/* APL */
	{ "80865AAC", (kernel_ulong_t)&apl_i2c_info },
	{ "80865ABC", (kernel_ulong_t)&bxt_info },
	{ "80865AC2", (kernel_ulong_t)&bxt_info },
	{ }
};
MODULE_DEVICE_TABLE(acpi, intel_lpss_acpi_ids);

static int intel_lpss_acpi_probe(struct platform_device *pdev)
{
	struct intel_lpss_platform_info *info;
	const struct acpi_device_id *id;

	id = acpi_match_device(intel_lpss_acpi_ids, &pdev->dev);
	if (!id)
		return -ENODEV;

	info = devm_kmemdup(&pdev->dev, (void *)id->driver_data, sizeof(*info),
			    GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	info->irq = platform_get_irq(pdev, 0);

	pm_runtime_set_active(&pdev->dev);
	pm_runtime_enable(&pdev->dev);

	return intel_lpss_probe(&pdev->dev, info);
}

static int intel_lpss_acpi_remove(struct platform_device *pdev)
{
	intel_lpss_remove(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return 0;
}

static INTEL_LPSS_PM_OPS(intel_lpss_acpi_pm_ops);

static struct platform_driver intel_lpss_acpi_driver = {
	.probe = intel_lpss_acpi_probe,
	.remove = intel_lpss_acpi_remove,
	.driver = {
		.name = "intel-lpss",
		.acpi_match_table = intel_lpss_acpi_ids,
		.pm = &intel_lpss_acpi_pm_ops,
	},
};

module_platform_driver(intel_lpss_acpi_driver);

MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
MODULE_DESCRIPTION("Intel LPSS ACPI driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
4b45efe8 AS	2	/*
	3	* Intel LPSS ACPI support.
	4	*
	5	* Copyright (C) 2015, Intel Corporation
	6	*
	7	* Authors: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
	8	* Mika Westerberg <mika.westerberg@linux.intel.com>
4b45efe8 AS	9	*/
	10
	11	#include <linux/acpi.h>
	12	#include <linux/ioport.h>
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
4b45efe8 AS	15	#include <linux/pm_runtime.h>
4b45efe8 AS	16	#include <linux/platform_device.h>
028af594	17	#include <linux/property.h>
4b45efe8 AS	18
	19	#include "intel-lpss.h"
	20
c5b90cb2 AS	21	static const struct intel_lpss_platform_info spt_info = {
	22	.clk_rate = 120000000,
	23	};
	24
028af594 MW	25	static struct property_entry spt_i2c_properties[] = {
	26	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 230),
	27	{ },
	28	};
	29
028af594 MW	30	static const struct intel_lpss_platform_info spt_i2c_info = {
028af594 MW	31	.clk_rate = 120000000,
f4d05266	32	.properties = spt_i2c_properties,
028af594 MW	33	};
028af594 MW	34
c5b90cb2 AS	35	static struct property_entry uart_properties[] = {
	36	PROPERTY_ENTRY_U32("reg-io-width", 4),
	37	PROPERTY_ENTRY_U32("reg-shift", 2),
	38	PROPERTY_ENTRY_BOOL("snps,uart-16550-compatible"),
	39	{ },
	40	};
	41
	42	static const struct intel_lpss_platform_info spt_uart_info = {
	43	.clk_rate = 120000000,
	44	.clk_con_id = "baudclk",
	45	.properties = uart_properties,
	46	};
	47
6a636ec0 MW	48	static const struct intel_lpss_platform_info bxt_info = {
	49	.clk_rate = 100000000,
	50	};
	51
0343b2f4 MW	52	static struct property_entry bxt_i2c_properties[] = {
	53	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 42),
	54	PROPERTY_ENTRY_U32("i2c-sda-falling-time-ns", 171),
	55	PROPERTY_ENTRY_U32("i2c-scl-falling-time-ns", 208),
	56	{ },
	57	};
	58
6a636ec0 MW	59	static const struct intel_lpss_platform_info bxt_i2c_info = {
6a636ec0 MW	60	.clk_rate = 133000000,
f4d05266	61	.properties = bxt_i2c_properties,
6a636ec0 MW	62	};
6a636ec0 MW	63
c50cdd62 JN	64	static struct property_entry apl_i2c_properties[] = {
	65	PROPERTY_ENTRY_U32("i2c-sda-hold-time-ns", 207),
	66	PROPERTY_ENTRY_U32("i2c-sda-falling-time-ns", 171),
	67	PROPERTY_ENTRY_U32("i2c-scl-falling-time-ns", 208),
	68	{ },
	69	};
	70
	71	static const struct intel_lpss_platform_info apl_i2c_info = {
	72	.clk_rate = 133000000,
	73	.properties = apl_i2c_properties,
	74	};
	75
4b45efe8 AS	76	static const struct acpi_device_id intel_lpss_acpi_ids[] = {
4b45efe8 AS	77	/* SPT */
c5b90cb2 AS	78	{ "INT3440", (kernel_ulong_t)&spt_info },
	79	{ "INT3441", (kernel_ulong_t)&spt_info },
	80	{ "INT3442", (kernel_ulong_t)&spt_i2c_info },
	81	{ "INT3443", (kernel_ulong_t)&spt_i2c_info },
	82	{ "INT3444", (kernel_ulong_t)&spt_i2c_info },
	83	{ "INT3445", (kernel_ulong_t)&spt_i2c_info },
028af594 MW	84	{ "INT3446", (kernel_ulong_t)&spt_i2c_info },
028af594 MW	85	{ "INT3447", (kernel_ulong_t)&spt_i2c_info },
c5b90cb2 AS	86	{ "INT3448", (kernel_ulong_t)&spt_uart_info },
	87	{ "INT3449", (kernel_ulong_t)&spt_uart_info },
	88	{ "INT344A", (kernel_ulong_t)&spt_uart_info },
6a636ec0 MW	89	/* BXT */
	90	{ "80860AAC", (kernel_ulong_t)&bxt_i2c_info },
	91	{ "80860ABC", (kernel_ulong_t)&bxt_info },
	92	{ "80860AC2", (kernel_ulong_t)&bxt_info },
	93	/* APL */
c50cdd62	94	{ "80865AAC", (kernel_ulong_t)&apl_i2c_info },
6a636ec0 MW	95	{ "80865ABC", (kernel_ulong_t)&bxt_info },
6a636ec0 MW	96	{ "80865AC2", (kernel_ulong_t)&bxt_info },
4b45efe8 AS	97	{ }
	98	};
	99	MODULE_DEVICE_TABLE(acpi, intel_lpss_acpi_ids);
	100
	101	static int intel_lpss_acpi_probe(struct platform_device *pdev)
	102	{
	103	struct intel_lpss_platform_info *info;
	104	const struct acpi_device_id *id;
	105
	106	id = acpi_match_device(intel_lpss_acpi_ids, &pdev->dev);
	107	if (!id)
	108	return -ENODEV;
	109
	110	info = devm_kmemdup(&pdev->dev, (void )id->driver_data, sizeof(info),
	111	GFP_KERNEL);
	112	if (!info)
	113	return -ENOMEM;
	114
	115	info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	116	info->irq = platform_get_irq(pdev, 0);
	117
	118	pm_runtime_set_active(&pdev->dev);
	119	pm_runtime_enable(&pdev->dev);
	120
	121	return intel_lpss_probe(&pdev->dev, info);
	122	}
	123
	124	static int intel_lpss_acpi_remove(struct platform_device *pdev)
	125	{
	126	intel_lpss_remove(&pdev->dev);
	127	pm_runtime_disable(&pdev->dev);
	128
	129	return 0;
	130	}
	131
	132	static INTEL_LPSS_PM_OPS(intel_lpss_acpi_pm_ops);
	133
	134	static struct platform_driver intel_lpss_acpi_driver = {
	135	.probe = intel_lpss_acpi_probe,
	136	.remove = intel_lpss_acpi_remove,
	137	.driver = {
	138	.name = "intel-lpss",
	139	.acpi_match_table = intel_lpss_acpi_ids,
	140	.pm = &intel_lpss_acpi_pm_ops,
	141	},
	142	};
	143
	144	module_platform_driver(intel_lpss_acpi_driver);
	145
	146	MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
	147	MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
	148	MODULE_DESCRIPTION("Intel LPSS ACPI driver");
	149	MODULE_LICENSE("GPL v2");