platform/x86: intel_pmc_core: Convert to a platform_driver (6c96a78c) · Commits · 戴 / test

drivers/platform/x86/intel_pmc_core.c

+57 −8

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#include <linux/io.h>
		#include <linux/module.h>
		#include <linux/pci.h>
		#include <linux/platform_device.h>
		#include <linux/uaccess.h>

		#include <asm/cpu_device_id.h>
		@@ -854,13 +855,17 @@ static const struct dmi_system_id pmc_core_dmi_table[] = {
		{}
		};

		static int __init pmc_core_probe(void)
		static int pmc_core_probe(struct platform_device *pdev)
		{
		static bool device_initialized;
		struct pmc_dev *pmcdev = &pmc;
		const struct x86_cpu_id *cpu_id;
		u64 slp_s0_addr;
		int err;

		if (device_initialized)
		return -ENODEV;

		cpu_id = x86_match_cpu(intel_pmc_core_ids);
		if (!cpu_id)
		return -ENODEV;
		@@ -886,30 +891,74 @@ static int __init pmc_core_probe(void)
		return -ENOMEM;

		mutex_init(&pmcdev->lock);
		platform_set_drvdata(pdev, pmcdev);
		pmcdev->pmc_xram_read_bit = pmc_core_check_read_lock_bit();
		dmi_check_system(pmc_core_dmi_table);

		err = pmc_core_dbgfs_register(pmcdev);
		if (err < 0) {
		pr_warn(" debugfs register failed.\n");
		dev_warn(&pdev->dev, "debugfs register failed.\n");
		iounmap(pmcdev->regbase);
		return err;
		}

		dmi_check_system(pmc_core_dmi_table);
		pr_info(" initialized\n");
		device_initialized = true;
		dev_info(&pdev->dev, " initialized\n");

		return 0;
		}
		module_init(pmc_core_probe)

		static void __exit pmc_core_remove(void)
		static int pmc_core_remove(struct platform_device *pdev)
		{
		struct pmc_dev *pmcdev = &pmc;
		struct pmc_dev *pmcdev = platform_get_drvdata(pdev);

		pmc_core_dbgfs_unregister(pmcdev);
		platform_set_drvdata(pdev, NULL);
		mutex_destroy(&pmcdev->lock);
		iounmap(pmcdev->regbase);
		return 0;
		}

		static struct platform_driver pmc_core_driver = {
		.driver = {
		.name = "intel_pmc_core",
		},
		.probe = pmc_core_probe,
		.remove = pmc_core_remove,
		};

		static struct platform_device pmc_core_device = {
		.name = "intel_pmc_core",
		};

		static int __init pmc_core_init(void)
		{
		int ret;

		if (!x86_match_cpu(intel_pmc_core_ids))
		return -ENODEV;

		ret = platform_driver_register(&pmc_core_driver);
		if (ret)
		return ret;

		ret = platform_device_register(&pmc_core_device);
		if (ret) {
		platform_driver_unregister(&pmc_core_driver);
		return ret;
		}
		module_exit(pmc_core_remove)

		return 0;
		}

		static void __exit pmc_core_exit(void)
		{
		platform_device_unregister(&pmc_core_device);
		platform_driver_unregister(&pmc_core_driver);
		}

		module_init(pmc_core_init)
		module_exit(pmc_core_exit)

		MODULE_LICENSE("GPL v2");
		MODULE_DESCRIPTION("Intel PMC Core Driver");

Admin message