x86, mrst: add platform support for MSIC MFD driver (360545c1) · Commits · e / devices / android_kernel_sony_msm8994

arch/x86/platform/mrst/mrst.c

+154 −15

Original line number	Original line	Diff line number	Diff line
	@@ -25,6 +25,7 @@
	#include <linux/irq.h>		#include <linux/irq.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/notifier.h>		#include <linux/notifier.h>
			#include <linux/mfd/intel_msic.h>

	#include <asm/setup.h>		#include <asm/setup.h>
	#include <asm/mpspec_def.h>		#include <asm/mpspec_def.h>
	@@ -481,6 +482,128 @@ static void __init no_platform_data(void info)
	return NULL;		return NULL;
	}		}

			static struct resource msic_resources[] = {
			{
			.start = INTEL_MSIC_IRQ_PHYS_BASE,
			.end = INTEL_MSIC_IRQ_PHYS_BASE + 64 - 1,
			.flags = IORESOURCE_MEM,
			},
			};

			static struct intel_msic_platform_data msic_pdata;

			static struct platform_device msic_device = {
			.name = "intel_msic",
			.id = -1,
			.dev = {
			.platform_data = &msic_pdata,
			},
			.num_resources = ARRAY_SIZE(msic_resources),
			.resource = msic_resources,
			};

			static inline bool mrst_has_msic(void)
			{
			return mrst_identify_cpu() == MRST_CPU_CHIP_PENWELL;
			}

			static int msic_scu_status_change(struct notifier_block *nb,
			unsigned long code, void *data)
			{
			if (code == SCU_DOWN) {
			platform_device_unregister(&msic_device);
			return 0;
			}

			return platform_device_register(&msic_device);
			}

			static int __init msic_init(void)
			{
			static struct notifier_block msic_scu_notifier = {
			.notifier_call = msic_scu_status_change,
			};

			/*
			* We need to be sure that the SCU IPC is ready before MSIC device
			* can be registered.
			*/
			if (mrst_has_msic())
			intel_scu_notifier_add(&msic_scu_notifier);

			return 0;
			}
			arch_initcall(msic_init);

			/*
			* msic_generic_platform_data - sets generic platform data for the block
			* @info: pointer to the SFI device table entry for this block
			* @block: MSIC block
			*
			* Function sets IRQ number from the SFI table entry for given device to
			* the MSIC platform data.
			*/
			static void msic_generic_platform_data(void info, enum intel_msic_block block)
			{
			struct sfi_device_table_entry *entry = info;

			BUG_ON(block < 0 \|\| block >= INTEL_MSIC_BLOCK_LAST);
			msic_pdata.irq[block] = entry->irq;

			return no_platform_data(info);
			}

			static void msic_battery_platform_data(void info)
			{
			return msic_generic_platform_data(info, INTEL_MSIC_BLOCK_BATTERY);
			}

			static void msic_gpio_platform_data(void info)
			{
			static struct intel_msic_gpio_pdata pdata;
			int gpio = get_gpio_by_name("msic_gpio_base");

			if (gpio < 0)
			return NULL;

			pdata.gpio_base = gpio;
			msic_pdata.gpio = &pdata;

			return msic_generic_platform_data(info, INTEL_MSIC_BLOCK_GPIO);
			}

			static void msic_audio_platform_data(void info)
			{
			struct platform_device *pdev;

			pdev = platform_device_register_simple("sst-platform", -1, NULL, 0);
			if (IS_ERR(pdev)) {
			pr_err("failed to create audio platform device\n");
			return NULL;
			}

			return msic_generic_platform_data(info, INTEL_MSIC_BLOCK_AUDIO);
			}

			static void msic_power_btn_platform_data(void info)
			{
			return msic_generic_platform_data(info, INTEL_MSIC_BLOCK_POWER_BTN);
			}

			static void msic_ocd_platform_data(void info)
			{
			static struct intel_msic_ocd_pdata pdata;
			int gpio = get_gpio_by_name("ocd_gpio");

			if (gpio < 0)
			return NULL;

			pdata.gpio = gpio;
			msic_pdata.ocd = &pdata;

			return msic_generic_platform_data(info, INTEL_MSIC_BLOCK_OCD);
			}

	static const struct devs_id __initconst device_ids[] = {		static const struct devs_id __initconst device_ids[] = {
	{"pmic_gpio", SFI_DEV_TYPE_SPI, 1, &pmic_gpio_platform_data},		{"pmic_gpio", SFI_DEV_TYPE_SPI, 1, &pmic_gpio_platform_data},
	{"spi_max3111", SFI_DEV_TYPE_SPI, 0, &max3111_platform_data},		{"spi_max3111", SFI_DEV_TYPE_SPI, 0, &max3111_platform_data},
	@@ -489,7 +612,14 @@ static const struct devs_id __initconst device_ids[] = {
	{"emc1403", SFI_DEV_TYPE_I2C, 1, &emc1403_platform_data},		{"emc1403", SFI_DEV_TYPE_I2C, 1, &emc1403_platform_data},
	{"i2c_accel", SFI_DEV_TYPE_I2C, 0, &lis331dl_platform_data},		{"i2c_accel", SFI_DEV_TYPE_I2C, 0, &lis331dl_platform_data},
	{"pmic_audio", SFI_DEV_TYPE_IPC, 1, &no_platform_data},		{"pmic_audio", SFI_DEV_TYPE_IPC, 1, &no_platform_data},
	{"msic_audio", SFI_DEV_TYPE_IPC, 1, &no_platform_data},
			/* MSIC subdevices */
			{"msic_battery", SFI_DEV_TYPE_IPC, 1, &msic_battery_platform_data},
			{"msic_gpio", SFI_DEV_TYPE_IPC, 1, &msic_gpio_platform_data},
			{"msic_audio", SFI_DEV_TYPE_IPC, 1, &msic_audio_platform_data},
			{"msic_power_btn", SFI_DEV_TYPE_IPC, 1, &msic_power_btn_platform_data},
			{"msic_ocd", SFI_DEV_TYPE_IPC, 1, &msic_ocd_platform_data},

	{},		{},
	};		};

	@@ -610,19 +740,37 @@ static void __init install_irq_resource(struct platform_device *pdev, int irq)
	platform_device_add_resources(pdev, &res, 1);		platform_device_add_resources(pdev, &res, 1);
	}		}

	static void __init sfi_handle_ipc_dev(struct platform_device *pdev)		static void __init sfi_handle_ipc_dev(struct sfi_device_table_entry *entry)
	{		{
	const struct devs_id *dev = device_ids;		const struct devs_id *dev = device_ids;
			struct platform_device *pdev;
	void *pdata = NULL;		void *pdata = NULL;

	while (dev->name[0]) {		while (dev->name[0]) {
	if (dev->type == SFI_DEV_TYPE_IPC &&		if (dev->type == SFI_DEV_TYPE_IPC &&
	!strncmp(dev->name, pdev->name, SFI_NAME_LEN)) {		!strncmp(dev->name, entry->name, SFI_NAME_LEN)) {
	pdata = dev->get_platform_data(pdev);		pdata = dev->get_platform_data(entry);
	break;		break;
	}		}
	dev++;		dev++;
	}		}

			/*
			* On Medfield the platform device creation is handled by the MSIC
			* MFD driver so we don't need to do it here.
			*/
			if (mrst_has_msic())
			return;

			/* ID as IRQ is a hack that will go away */
			pdev = platform_device_alloc(entry->name, entry->irq);
			if (pdev == NULL) {
			pr_err("out of memory for SFI platform device '%s'.\n",
			entry->name);
			return;
			}
			install_irq_resource(pdev, entry->irq);

	pdev->dev.platform_data = pdata;		pdev->dev.platform_data = pdata;
	intel_scu_device_register(pdev);		intel_scu_device_register(pdev);
	}		}
	@@ -675,7 +823,6 @@ static int __init sfi_parse_devs(struct sfi_table_header *table)
	struct sfi_device_table_entry *pentry;		struct sfi_device_table_entry *pentry;
	struct spi_board_info spi_info;		struct spi_board_info spi_info;
	struct i2c_board_info i2c_info;		struct i2c_board_info i2c_info;
	struct platform_device *pdev;
	int num, i, bus;		int num, i, bus;
	int ioapic;		int ioapic;
	struct io_apic_irq_attr irq_attr;		struct io_apic_irq_attr irq_attr;
	@@ -703,17 +850,9 @@ static int __init sfi_parse_devs(struct sfi_table_header *table)

	switch (pentry->type) {		switch (pentry->type) {
	case SFI_DEV_TYPE_IPC:		case SFI_DEV_TYPE_IPC:
	/* ID as IRQ is a hack that will go away */
	pdev = platform_device_alloc(pentry->name, irq);
	if (pdev == NULL) {
	pr_err("out of memory for SFI platform device '%s'.\n",
	pentry->name);
	continue;
	}
	install_irq_resource(pdev, irq);
	pr_debug("info[%2d]: IPC bus, name = %16.16s, "		pr_debug("info[%2d]: IPC bus, name = %16.16s, "
	"irq = 0x%2x\n", i, pentry->name, irq);		"irq = 0x%2x\n", i, pentry->name, pentry->irq);
	sfi_handle_ipc_dev(pdev);		sfi_handle_ipc_dev(pentry);
	break;		break;
	case SFI_DEV_TYPE_SPI:		case SFI_DEV_TYPE_SPI:
	memset(&spi_info, 0, sizeof(spi_info));		memset(&spi_info, 0, sizeof(spi_info));