{ .compatible = "hisilicon,mbigen-v2" }, { /* END */ } }; MODULE_DEVICE_TABLE(of, mbigen_of_match); static const struct acpi_device_id mbigen_acpi_match[] = { { "HISI0152", 0 }, {} }; MODULE_DEVICE_TABLE(acpi, mbigen_acpi_match); static struct platform_driver mbigen_platform_driver = { .driver = { .name = "Hisilicon MBIGEN-V2", .of_match_table = mbigen_of_match, .acpi_match_table = ACPI_PTR(mbigen_acpi_match), }, .probe = mbigen_device_probe, }; static __init int mbigen_init(void) { return platform_driver_register(&mbigen_platform_driver); } arch_initcall(mbigen_init); MODULE_AUTHOR("Jun Ma <*****@*****.**>"); MODULE_AUTHOR("Yun Wu <*****@*****.**>");
} static const struct of_device_id xgene_gpio_sb_of_match[] = { {.compatible = "apm,xgene-gpio-sb", }, {}, }; MODULE_DEVICE_TABLE(of, xgene_gpio_sb_of_match); #ifdef CONFIG_ACPI static const struct acpi_device_id xgene_gpio_sb_acpi_match[] = { {"APMC0D15", 0}, {}, }; MODULE_DEVICE_TABLE(acpi, xgene_gpio_sb_acpi_match); #endif static struct platform_driver xgene_gpio_sb_driver = { .driver = { .name = "xgene-gpio-sb", .of_match_table = xgene_gpio_sb_of_match, .acpi_match_table = ACPI_PTR(xgene_gpio_sb_acpi_match), }, .probe = xgene_gpio_sb_probe, .remove = xgene_gpio_sb_remove, }; module_platform_driver(xgene_gpio_sb_driver); MODULE_AUTHOR("AppliedMicro"); MODULE_DESCRIPTION("APM X-Gene GPIO Standby driver"); MODULE_LICENSE("GPL");
static int pt_gpio_remove(struct platform_device *pdev) { struct pt_gpio_chip *pt_gpio = platform_get_drvdata(pdev); gpiochip_remove(&pt_gpio->gc); return 0; } static const struct acpi_device_id pt_gpio_acpi_match[] = { { "AMDF030", 0 }, { "AMDIF030", 0 }, { }, }; MODULE_DEVICE_TABLE(acpi, pt_gpio_acpi_match); static struct platform_driver pt_gpio_driver = { .driver = { .name = "pt-gpio", .acpi_match_table = ACPI_PTR(pt_gpio_acpi_match), }, .probe = pt_gpio_probe, .remove = pt_gpio_remove, }; module_platform_driver(pt_gpio_driver); MODULE_LICENSE("GPL"); MODULE_AUTHOR("YD Tseng <*****@*****.**>"); MODULE_DESCRIPTION("AMD Promontory GPIO Driver");
#ifdef CONFIG_ACPI static const struct acpi_device_id adc108s102_acpi_ids[] = { { "INT3495", 0 }, { } }; MODULE_DEVICE_TABLE(acpi, adc108s102_acpi_ids); #endif static const struct spi_device_id adc108s102_id[] = { { "adc108s102", 0 }, { } }; MODULE_DEVICE_TABLE(spi, adc108s102_id); static struct spi_driver adc108s102_driver = { .driver = { .name = "adc108s102", .of_match_table = of_match_ptr(adc108s102_of_match), .acpi_match_table = ACPI_PTR(adc108s102_acpi_ids), }, .probe = adc108s102_probe, .remove = adc108s102_remove, .id_table = adc108s102_id, }; module_spi_driver(adc108s102_driver); MODULE_AUTHOR("Bogdan Pricop <*****@*****.**>"); MODULE_DESCRIPTION("Texas Instruments ADC108S102 and ADC128S102 driver"); MODULE_LICENSE("GPL v2");
static const struct acpi_device_id bmc150_magn_acpi_match[] = { {"BMC150B", 0}, {"BMC156B", 0}, {}, }; MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match); static const struct i2c_device_id bmc150_magn_i2c_id[] = { {"bmc150_magn", 0}, {"bmc156_magn", 0}, {} }; MODULE_DEVICE_TABLE(i2c, bmc150_magn_i2c_id); static struct i2c_driver bmc150_magn_driver = { .driver = { .name = "bmc150_magn_i2c", .acpi_match_table = ACPI_PTR(bmc150_magn_acpi_match), .pm = &bmc150_magn_pm_ops, }, .probe = bmc150_magn_i2c_probe, .remove = bmc150_magn_i2c_remove, .id_table = bmc150_magn_i2c_id, }; module_i2c_driver(bmc150_magn_driver); MODULE_AUTHOR("Daniel Baluta <*****@*****.**"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("BMC150 I2C magnetometer driver");
}; MODULE_DEVICE_TABLE(of, dw8250_of_match); static const struct acpi_device_id dw8250_acpi_match[] = { { "INT33C4", 0 }, { "INT33C5", 0 }, { "INT3434", 0 }, { "INT3435", 0 }, { "80860F0A", 0 }, { "8086228A", 0 }, { }, }; MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match); static struct platform_driver dw8250_platform_driver = { .driver = { .name = "dw-apb-uart", .pm = &dw8250_pm_ops, .of_match_table = dw8250_of_match, .acpi_match_table = ACPI_PTR(dw8250_acpi_match), }, .probe = dw8250_probe, .remove = dw8250_remove, }; module_platform_driver(dw8250_platform_driver); MODULE_AUTHOR("Jamie Iles"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");
{"mpu9150", INV_MPU9150}, {"icm20608", INV_ICM20608}, {} }; MODULE_DEVICE_TABLE(i2c, inv_mpu_id); static const struct acpi_device_id inv_acpi_match[] = { {"INVN6500", INV_MPU6500}, { }, }; MODULE_DEVICE_TABLE(acpi, inv_acpi_match); static struct i2c_driver inv_mpu_driver = { .probe = inv_mpu_probe, .remove = inv_mpu_remove, .id_table = inv_mpu_id, .driver = { .acpi_match_table = ACPI_PTR(inv_acpi_match), .name = "inv-mpu6050-i2c", .pm = &inv_mpu_pmops, }, }; module_i2c_driver(inv_mpu_driver); MODULE_AUTHOR("Invensense Corporation"); MODULE_DESCRIPTION("Invensense device MPU6050 driver"); MODULE_LICENSE("GPL");
rc = device_init_wakeup(&pdev->dev, 0); if (rc) dev_err(&pdev->dev, "RNG init wakeup failed error %d\n", rc); if (!IS_ERR(ctx->clk)) clk_disable_unprepare(ctx->clk); hwrng_unregister(&xgene_rng_func); return rc; } static const struct of_device_id xgene_rng_of_match[] = { { .compatible = "apm,xgene-rng" }, { } }; MODULE_DEVICE_TABLE(of, xgene_rng_of_match); static struct platform_driver xgene_rng_driver = { .probe = xgene_rng_probe, .remove = xgene_rng_remove, .driver = { .name = "xgene-rng", .of_match_table = xgene_rng_of_match, .acpi_match_table = ACPI_PTR(xgene_rng_acpi_match), }, }; module_platform_driver(xgene_rng_driver); MODULE_DESCRIPTION("APM X-Gene RNG driver"); MODULE_LICENSE("GPL");
}; MODULE_DEVICE_TABLE(acpi, bcm_acpi_id); #endif static struct platform_driver wifi_platform_dev_driver = { #ifdef CONFIG_ACPI .probe = wifi_plat_dev_drv_probe_acpi, #else .probe = wifi_plat_dev_drv_probe, #endif .remove = wifi_plat_dev_drv_remove, .suspend = wifi_plat_dev_drv_suspend, .resume = wifi_plat_dev_drv_resume, .driver = { #ifdef CONFIG_ACPI .acpi_match_table = ACPI_PTR(bcm_acpi_id), #endif .name = WIFI_PLAT_NAME, } }; static struct platform_driver wifi_platform_dev_driver_legacy = { .probe = wifi_plat_dev_drv_probe, .remove = wifi_plat_dev_drv_remove, .suspend = wifi_plat_dev_drv_suspend, .resume = wifi_plat_dev_drv_resume, .driver = { .name = WIFI_PLAT_NAME2, } };
static const struct of_device_id xlp9xx_i2c_of_match[] = { { .compatible = "netlogic,xlp980-i2c", }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(of, xlp9xx_i2c_of_match); #ifdef CONFIG_ACPI static const struct acpi_device_id xlp9xx_i2c_acpi_ids[] = { {"BRCM9007", 0}, {} }; MODULE_DEVICE_TABLE(acpi, xlp9xx_i2c_acpi_ids); #endif static struct platform_driver xlp9xx_i2c_driver = { .probe = xlp9xx_i2c_probe, .remove = xlp9xx_i2c_remove, .driver = { .name = "xlp9xx-i2c", .of_match_table = xlp9xx_i2c_of_match, .acpi_match_table = ACPI_PTR(xlp9xx_i2c_acpi_ids), }, }; module_platform_driver(xlp9xx_i2c_driver); MODULE_AUTHOR("Subhendu Sekhar Behera <*****@*****.**>"); MODULE_DESCRIPTION("XLP9XX/5XX I2C Bus Controller Driver"); MODULE_LICENSE("GPL v2");
static int intel_punit_ipc_remove(struct platform_device *pdev) { return 0; } static const struct acpi_device_id punit_ipc_acpi_ids[] = { { "INT34D4", 0 }, { } }; static struct platform_driver intel_punit_ipc_driver = { .probe = intel_punit_ipc_probe, .remove = intel_punit_ipc_remove, .driver = { .name = "intel_punit_ipc", .acpi_match_table = ACPI_PTR(punit_ipc_acpi_ids), }, }; static int __init intel_punit_ipc_init(void) { return platform_driver_register(&intel_punit_ipc_driver); } static void __exit intel_punit_ipc_exit(void) { platform_driver_unregister(&intel_punit_ipc_driver); } MODULE_AUTHOR("Zha Qipeng <*****@*****.**>"); MODULE_DESCRIPTION("Intel P-Unit IPC driver");
/* Make sure there are no events in the middle of being processed */ if (wait_on_bit_timeout(&ucsi->flags, EVENT_PENDING, TASK_UNINTERRUPTIBLE, msecs_to_jiffies(UCSI_TIMEOUT_MS))) dev_WARN(ucsi->dev, "%s: Events still pending\n", __func__); ucsi_reset_ppm(ucsi); return 0; } static const struct acpi_device_id ucsi_acpi_match[] = { { "PNP0CA0", 0 }, { }, }; MODULE_DEVICE_TABLE(acpi, ucsi_acpi_match); static struct platform_driver ucsi_acpi_platform_driver = { .driver = { .name = "ucsi_acpi", .acpi_match_table = ACPI_PTR(ucsi_acpi_match), }, .probe = ucsi_acpi_probe, .remove = ucsi_acpi_remove, }; module_platform_driver(ucsi_acpi_platform_driver); MODULE_AUTHOR("Heikki Krogerus <*****@*****.**>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("USB Type-C System Software Interface (UCSI) driver");
}; MODULE_DEVICE_TABLE(platform, ehci_platform_table); static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend, ehci_platform_resume); static struct platform_driver ehci_platform_driver = { .id_table = ehci_platform_table, .probe = ehci_platform_probe, .remove = ehci_platform_remove, .shutdown = usb_hcd_platform_shutdown, .driver = { .name = "ehci-platform", .pm = &ehci_platform_pm_ops, .of_match_table = vt8500_ehci_ids, .acpi_match_table = ACPI_PTR(ehci_acpi_match), } }; static int __init ehci_platform_init(void) { if (usb_disabled()) return -ENODEV; pr_info("%s: " DRIVER_DESC "\n", hcd_name); ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides); return platform_driver_register(&ehci_platform_driver); } module_init(ehci_platform_init);
#endif #ifdef CONFIG_ACPI #define ACPI_ID_INTEL_BSW "808622B7" static const struct acpi_device_id dwc3_acpi_match[] = { { ACPI_ID_INTEL_BSW, 0 }, { }, }; MODULE_DEVICE_TABLE(acpi, dwc3_acpi_match); #endif static struct platform_driver dwc3_driver = { .probe = dwc3_probe, .remove = dwc3_remove, .driver = { .name = "dwc3", .of_match_table = of_match_ptr(of_dwc3_match), .acpi_match_table = ACPI_PTR(dwc3_acpi_match), .pm = &dwc3_dev_pm_ops, }, }; module_platform_driver(dwc3_driver); MODULE_ALIAS("platform:dwc3"); MODULE_AUTHOR("Felipe Balbi <*****@*****.**>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("DesignWare USB3 DRD Controller Driver");
} static const struct acpi_device_id acpi_ac_match[] = { { "ACPI0003", 0 }, { } }; MODULE_DEVICE_TABLE(acpi, acpi_ac_match); static struct platform_driver acpi_ac_driver = { .probe = acpi_ac_probe, .remove = acpi_ac_remove, .driver = { .name = "acpi-ac", .owner = THIS_MODULE, .pm = &acpi_ac_pm_ops, .acpi_match_table = ACPI_PTR(acpi_ac_match), }, }; static int __init acpi_ac_init(void) { int result; if (acpi_disabled) return -ENODEV; result = platform_driver_register(&acpi_ac_driver); if (result < 0) return -ENODEV; return 0;
{ .compatible = "maxim,max98373", }, { } }; MODULE_DEVICE_TABLE(of, max98373_of_match); #endif #ifdef CONFIG_ACPI static const struct acpi_device_id max98373_acpi_match[] = { { "MX98373", 0 }, {}, }; MODULE_DEVICE_TABLE(acpi, max98373_acpi_match); #endif static struct i2c_driver max98373_i2c_driver = { .driver = { .name = "max98373", .of_match_table = of_match_ptr(max98373_of_match), .acpi_match_table = ACPI_PTR(max98373_acpi_match), .pm = &max98373_pm, }, .probe = max98373_i2c_probe, .id_table = max98373_i2c_id, }; module_i2c_driver(max98373_i2c_driver) MODULE_DESCRIPTION("ALSA SoC MAX98373 driver"); MODULE_AUTHOR("Ryan Lee <*****@*****.**>"); MODULE_LICENSE("GPL");
}; MODULE_DEVICE_TABLE(i2c, silead_ts_id); #ifdef CONFIG_ACPI static const struct acpi_device_id silead_ts_acpi_match[] = { { "GSL1680", 0 }, { "GSL1688", 0 }, { "GSL3670", 0 }, { "GSL3675", 0 }, { "GSL3692", 0 }, { "MSSL1680", 0 }, { } }; MODULE_DEVICE_TABLE(acpi, silead_ts_acpi_match); #endif static struct i2c_driver silead_ts_driver = { .probe = silead_ts_probe, .id_table = silead_ts_id, .driver = { .name = SILEAD_TS_NAME, .acpi_match_table = ACPI_PTR(silead_ts_acpi_match), .pm = &silead_ts_pm, }, }; module_i2c_driver(silead_ts_driver); MODULE_AUTHOR("Robert Dolca <*****@*****.**>"); MODULE_DESCRIPTION("Silead I2C touchscreen driver"); MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(i2c, bmi160_i2c_id); static const struct acpi_device_id bmi160_acpi_match[] = { {"BMI0160", 0}, { }, }; MODULE_DEVICE_TABLE(acpi, bmi160_acpi_match); #ifdef CONFIG_OF static const struct of_device_id bmi160_of_match[] = { { .compatible = "bosch,bmi160" }, { }, }; MODULE_DEVICE_TABLE(of, bmi160_of_match); #endif static struct i2c_driver bmi160_i2c_driver = { .driver = { .name = "bmi160_i2c", .acpi_match_table = ACPI_PTR(bmi160_acpi_match), .of_match_table = of_match_ptr(bmi160_of_match), }, .probe = bmi160_i2c_probe, .id_table = bmi160_i2c_id, }; module_i2c_driver(bmi160_i2c_driver); MODULE_AUTHOR("Daniel Baluta <*****@*****.**>"); MODULE_DESCRIPTION("BMI160 I2C driver"); MODULE_LICENSE("GPL v2");
struct axp20x_dev *axp20x = i2c_get_clientdata(i2c); if (axp20x == axp20x_pm_power_off) { axp20x_pm_power_off = NULL; pm_power_off = NULL; } mfd_remove_devices(axp20x->dev); regmap_del_irq_chip(axp20x->i2c_client->irq, axp20x->regmap_irqc); return 0; } static struct i2c_driver axp20x_i2c_driver = { .driver = { .name = "axp20x", .owner = THIS_MODULE, .of_match_table = of_match_ptr(axp20x_of_match), .acpi_match_table = ACPI_PTR(axp20x_acpi_match), }, .probe = axp20x_i2c_probe, .remove = axp20x_i2c_remove, .id_table = axp20x_i2c_id, }; module_i2c_driver(axp20x_i2c_driver); MODULE_DESCRIPTION("PMIC MFD core driver for AXP20X"); MODULE_AUTHOR("Carlo Caione <*****@*****.**>"); MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(acpi, virtual_gpio_acpi_ids); static int virtual_gpio_remove(struct platform_device *pdev) { platform_set_drvdata(pdev, NULL); return 0; } static void virtual_gpio_shutdown(struct platform_device *pdev) { } static struct platform_driver virtual_gpio_driver = { .driver = { .name = VIRTUAL_GPIO_DRIVER_NAME, .owner = THIS_MODULE, .pm = &virtual_gpio_pm_ops, .acpi_match_table = ACPI_PTR(virtual_gpio_acpi_ids), }, .probe = virtual_gpio_probe, .remove = virtual_gpio_remove, .shutdown = virtual_gpio_shutdown, }; module_platform_driver(virtual_gpio_driver); MODULE_AUTHOR("Dyut Kumar Sil <*****@*****.**>"); MODULE_DESCRIPTION("Intel (R) Virtual GPIO Controller Driver"); MODULE_LICENSE("GPL v2"); MODULE_VERSION(VIRTUAL_GPIO_DRIVER_VERSION);
}; MODULE_DEVICE_TABLE(acpi, bmc150_accel_acpi_match); static const struct i2c_device_id bmc150_accel_id[] = { {"bmc150_accel", bmc150}, {"bmi055_accel", bmi055}, {"bma255", bma255}, {"bma250e", bma250e}, {"bma222e", bma222e}, {"bma280", bma280}, {} }; MODULE_DEVICE_TABLE(i2c, bmc150_accel_id); static struct i2c_driver bmc150_accel_driver = { .driver = { .name = "bmc150_accel_i2c", .acpi_match_table = ACPI_PTR(bmc150_accel_acpi_match), .pm = &bmc150_accel_pm_ops, }, .probe = bmc150_accel_probe, .remove = bmc150_accel_remove, .id_table = bmc150_accel_id, }; module_i2c_driver(bmc150_accel_driver); MODULE_AUTHOR("Srinivas Pandruvada <*****@*****.**>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("BMC150 I2C accelerometer driver");
return 0; } static struct i2c_device_id fdp_nci_i2c_id_table[] = { {"int339a", 0}, {} }; MODULE_DEVICE_TABLE(i2c, fdp_nci_i2c_id_table); static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = { {"INT339A", 0}, {} }; MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match); static struct i2c_driver fdp_nci_i2c_driver = { .driver = { .name = FDP_I2C_DRIVER_NAME, .acpi_match_table = ACPI_PTR(fdp_nci_i2c_acpi_match), }, .id_table = fdp_nci_i2c_id_table, .probe = fdp_nci_i2c_probe, .remove = fdp_nci_i2c_remove, }; module_i2c_driver(fdp_nci_i2c_driver); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("I2C driver for Intel Fields Peak NFC controller"); MODULE_AUTHOR("Robert Dolca <*****@*****.**>");
SET_SYSTEM_SLEEP_PM_OPS(ov13858_suspend, ov13858_resume) }; #ifdef CONFIG_ACPI static const struct acpi_device_id ov13858_acpi_ids[] = { {"OVTID858"}, { /* sentinel */ } }; MODULE_DEVICE_TABLE(acpi, ov13858_acpi_ids); #endif static struct i2c_driver ov13858_i2c_driver = { .driver = { .name = "ov13858", .pm = &ov13858_pm_ops, .acpi_match_table = ACPI_PTR(ov13858_acpi_ids), }, .probe = ov13858_probe, .remove = ov13858_remove, .id_table = ov13858_id_table, }; module_i2c_driver(ov13858_i2c_driver); MODULE_AUTHOR("Kan, Chris <*****@*****.**>"); MODULE_AUTHOR("Rapolu, Chiranjeevi <*****@*****.**>"); MODULE_AUTHOR("Yang, Hyungwoo <*****@*****.**>"); MODULE_DESCRIPTION("Omnivision ov13858 sensor driver"); MODULE_LICENSE("GPL v2");
static int xgene_mdio_remove(struct platform_device *pdev) { struct xgene_mdio_pdata *pdata = platform_get_drvdata(pdev); struct mii_bus *mdio_bus = pdata->mdio_bus; struct device *dev = &pdev->dev; mdiobus_unregister(mdio_bus); mdiobus_free(mdio_bus); if (dev->of_node) clk_disable_unprepare(pdata->clk); return 0; } static struct platform_driver xgene_mdio_driver = { .driver = { .name = "xgene-mdio", .of_match_table = of_match_ptr(xgene_mdio_of_match), .acpi_match_table = ACPI_PTR(xgene_mdio_acpi_match), }, .probe = xgene_mdio_probe, .remove = xgene_mdio_remove, }; module_platform_driver(xgene_mdio_driver); MODULE_DESCRIPTION("APM X-Gene SoC MDIO driver"); MODULE_AUTHOR("Iyappan Subramanian <*****@*****.**>"); MODULE_LICENSE("GPL");
return 0; } #ifdef CONFIG_ACPI static const struct acpi_device_id xlp_spi_acpi_match[] = { { "BRCM900D", 0 }, { }, }; MODULE_DEVICE_TABLE(acpi, xlp_spi_acpi_match); #endif static const struct of_device_id xlp_spi_dt_id[] = { { .compatible = "netlogic,xlp832-spi" }, { }, }; MODULE_DEVICE_TABLE(of, xlp_spi_dt_id); static struct platform_driver xlp_spi_driver = { .probe = xlp_spi_probe, .driver = { .name = "xlp-spi", .of_match_table = xlp_spi_dt_id, .acpi_match_table = ACPI_PTR(xlp_spi_acpi_match), }, }; module_platform_driver(xlp_spi_driver); MODULE_AUTHOR("Kamlakant Patel <*****@*****.**>"); MODULE_DESCRIPTION("Netlogic XLP SPI controller driver"); MODULE_LICENSE("GPL v2");
{ } }; MODULE_DEVICE_TABLE(of, gsl_ts_of_match); #endif static struct i2c_driver gslx680_ts_driver = { .probe = gsl_ts_probe, .remove = gsl_ts_remove, .id_table = gsl_ts_i2c_id, .driver = { .name = DEVICE_NAME, .owner = THIS_MODULE, #ifdef CONFIG_PM .pm = &gsl_ts_pm_ops, #endif #ifdef CONFIG_ACPI .acpi_match_table = ACPI_PTR(gsl_ts_acpi_match), #endif #ifdef CONFIG_OF .of_match_table = of_match_ptr(gsl_ts_of_match), #endif }, }; module_i2c_driver(gslx680_ts_driver); MODULE_DESCRIPTION("GSLX680 touchscreen controller driver"); MODULE_AUTHOR("Gregor Riepl <*****@*****.**>"); MODULE_PARM_DESC(fw_name, "firmware file name (default: " GSL_FW_NAME_DEFAULT ")"); MODULE_VERSION(DRIVER_VERSION); MODULE_LICENSE("GPL");
{} }; MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table); static const struct acpi_device_id st_nci_spi_acpi_match[] = { {"SMO2101", 0}, {} }; MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match); static const struct of_device_id of_st_nci_spi_match[] = { { .compatible = "st,st21nfcb-spi", }, {} }; MODULE_DEVICE_TABLE(of, of_st_nci_spi_match); static struct spi_driver st_nci_spi_driver = { .driver = { .name = ST_NCI_SPI_DRIVER_NAME, .of_match_table = of_match_ptr(of_st_nci_spi_match), .acpi_match_table = ACPI_PTR(st_nci_spi_acpi_match), }, .probe = st_nci_spi_probe, .id_table = st_nci_spi_id_table, .remove = st_nci_spi_remove, }; module_spi_driver(st_nci_spi_driver); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION(DRIVER_DESC);
}; MODULE_DEVICE_TABLE(of, of_st33zp24_spi_match); static const struct acpi_device_id st33zp24_spi_acpi_match[] = { {"SMO3324"}, {} }; MODULE_DEVICE_TABLE(acpi, st33zp24_spi_acpi_match); static SIMPLE_DEV_PM_OPS(st33zp24_spi_ops, st33zp24_pm_suspend, st33zp24_pm_resume); static struct spi_driver st33zp24_spi_driver = { .driver = { .name = TPM_ST33_SPI, .pm = &st33zp24_spi_ops, .of_match_table = of_match_ptr(of_st33zp24_spi_match), .acpi_match_table = ACPI_PTR(st33zp24_spi_acpi_match), }, .probe = st33zp24_spi_probe, .remove = st33zp24_spi_remove, .id_table = st33zp24_spi_id, }; module_spi_driver(st33zp24_spi_driver); MODULE_AUTHOR("TPM support ([email protected])"); MODULE_DESCRIPTION("STM TPM 1.2 SPI ST33 Driver"); MODULE_VERSION("1.3.0"); MODULE_LICENSE("GPL");
static const struct acpi_device_id usb_xhci_acpi_match[] = { /* XHCI-compliant USB Controller */ { "PNP0D10", }, { } }; MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match); static struct platform_driver usb_xhci_driver = { .probe = xhci_plat_probe, .remove = xhci_plat_remove, .shutdown = usb_hcd_platform_shutdown, .driver = { .name = "xhci-hcd", .pm = &xhci_plat_pm_ops, .of_match_table = of_match_ptr(usb_xhci_of_match), .acpi_match_table = ACPI_PTR(usb_xhci_acpi_match), }, }; MODULE_ALIAS("platform:xhci-hcd"); static int __init xhci_plat_init(void) { xhci_init_driver(&xhci_plat_hc_driver, &xhci_plat_overrides); return platform_driver_register(&usb_xhci_driver); } module_init(xhci_plat_init); static void __exit xhci_plat_exit(void) { platform_driver_unregister(&usb_xhci_driver); }
{ } }; MODULE_DEVICE_TABLE(i2c, intel_soc_pmic_i2c_id); #if defined(CONFIG_ACPI) static const struct acpi_device_id intel_soc_pmic_acpi_match[] = { { "INT33FD" }, { }, }; MODULE_DEVICE_TABLE(acpi, intel_soc_pmic_acpi_match); #endif static struct i2c_driver intel_soc_pmic_i2c_driver = { .driver = { .name = "intel_soc_pmic_i2c", .pm = &intel_soc_pmic_pm_ops, .acpi_match_table = ACPI_PTR(intel_soc_pmic_acpi_match), }, .probe = intel_soc_pmic_i2c_probe, .remove = intel_soc_pmic_i2c_remove, .id_table = intel_soc_pmic_i2c_id, .shutdown = intel_soc_pmic_shutdown, }; module_i2c_driver(intel_soc_pmic_i2c_driver); MODULE_DESCRIPTION("I2C driver for Intel SoC PMIC"); MODULE_LICENSE("GPL v2"); MODULE_AUTHOR("Yang, Bin <*****@*****.**>"); MODULE_AUTHOR("Zhu, Lejun <*****@*****.**>");