return 0;
}
static int __devexit cyttsp_spi_remove(struct spi_device *spi)
{
struct cyttsp *ts = spi_get_drvdata(spi);
cyttsp_remove(ts);
return 0;
}
static struct spi_driver cyttsp_spi_driver = {
.driver = {
.name = CY_SPI_NAME,
.owner = THIS_MODULE,
.pm = &cyttsp_pm_ops,
},
.probe = cyttsp_spi_probe,
.remove = __devexit_p(cyttsp_spi_remove),
};
module_spi_driver(cyttsp_spi_driver);
MODULE_ALIAS("spi:cyttsp");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard Product (TTSP) SPI driver");
MODULE_AUTHOR("Cypress");
MODULE_ALIAS("spi:cyttsp");
[0] = {
.start = SW_INT_IRQNO_ALARM,
.end = SW_INT_IRQNO_ALARM,
.flags = IORESOURCE_IRQ,
},
};
struct platform_device sunxi_device_rtc = {
.name = "sunxi-rtc",
.id = -1,
.num_resources = ARRAY_SIZE(sunxi_rtc_resource),
.resource = sunxi_rtc_resource,
};
static struct platform_driver sunxi_rtc_driver = {
.probe = sunxi_rtc_probe,
.remove = __devexit_p(sunxi_rtc_remove),
.driver = {
.name = "sunxi-rtc",
.owner = THIS_MODULE,
},
.suspend = sunxi_rtc_suspend,
.resume = sunxi_rtc_resume,
};
static int i2c_write_reg(struct i2c_adapter *adapter, u8 adr,
u8 reg, u8 data)
{
u8 m[2] = {reg, data};
struct i2c_msg msg = {.addr = adr, .flags = 0, .buf = m, .len = 2};
if (i2c_transfer(adapter, &msg, 1) != 1) {
head = adc->queue_head;
if (WARN_ON(adc->queue[head]))
dev_err(adc->pcf->dev,
"adc driver removed with request pending\n");
for (i = 0; i < PCF50633_MAX_ADC_FIFO_DEPTH; i++)
kfree(adc->queue[i]);
mutex_unlock(&adc->queue_mutex);
kfree(adc);
return 0;
}
static struct platform_driver pcf50633_adc_driver = {
.driver = {
.name = "pcf50633-adc",
},
.probe = pcf50633_adc_probe,
.remove = __devexit_p(pcf50633_adc_remove),
};
module_platform_driver(pcf50633_adc_driver);
MODULE_AUTHOR("Balaji Rao <*****@*****.**>");
MODULE_DESCRIPTION("PCF50633 adc driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:pcf50633-adc");
struct snd_card *card = pci_get_drvdata(pci);
struct snd_vx222 *vx = card->private_data;
pci_restore_state(pci);
pci_enable_device(pci);
pci_set_power_state(pci, PCI_D0);
pci_set_master(pci);
return snd_vx_resume(&vx->core);
}
#endif
static struct pci_driver driver = {
.name = "Digigram VX222",
.id_table = snd_vx222_ids,
.probe = snd_vx222_probe,
.remove = __devexit_p(snd_vx222_remove),
#ifdef CONFIG_PM
.suspend = snd_vx222_suspend,
.resume = snd_vx222_resume,
#endif
};
static int __init alsa_card_vx222_init(void)
{
return pci_register_driver(&driver);
}
static void __exit alsa_card_vx222_exit(void)
{
pci_unregister_driver(&driver);
}
platform_lcd_set_power(plcd->lcd, plcd->power);
return 0;
}
#else
#define platform_lcd_suspend NULL
#define platform_lcd_resume NULL
#endif
static struct platform_driver platform_lcd_driver = {
.driver = {
.name = "platform-lcd",
.owner = THIS_MODULE,
},
.probe = platform_lcd_probe,
.remove = __devexit_p(platform_lcd_remove),
.suspend = platform_lcd_suspend,
.resume = platform_lcd_resume,
};
static int __init platform_lcd_init(void)
{
return platform_driver_register(&platform_lcd_driver);
}
static void __exit platform_lcd_cleanup(void)
{
platform_driver_unregister(&platform_lcd_driver);
}
//module_init(platform_lcd_init);
gpio_free(data->gpio);
return 0;
}
#ifdef CONFIG_OF
static struct of_device_id usr_reset_warning_match_table[] = {
{ .compatible = "mmi,usr-reset-warning",
},
{}
};
#endif
static struct platform_driver usr_reset_warning_driver = {
.probe = usr_reset_warning_probe,
.remove = __devexit_p(usr_reset_warning_remove),
.driver = {
.name = "usr-reset-warning",
.of_match_table = of_match_ptr(usr_reset_warning_match_table),
.owner = THIS_MODULE,
},
};
static int __init usr_reset_warning_init(void)
{
return platform_driver_register(&usr_reset_warning_driver);
}
static void __exit usr_reset_warning_exit(void)
{
platform_driver_unregister(&usr_reset_warning_driver);
return -EINVAL;
}
cancel_work_sync(&sdev.work);
smart_gpio_free(pdata->modem_int_gpio1);
smart_gpio_free(pdata->modem_int_gpio2);
switch_usb_dev_unregister(&sdev);
free_irq(sdev.irq1, &sdev);
free_irq(sdev.irq2, &sdev);
return 0;
}
static struct platform_driver usb_switch_driver = {
.probe = usb_switch_probe,
.remove = __devexit_p(usb_switch_remove),
#ifdef CONFIG_PM
.suspend = usb_switch_suspend,
.resume = usb_switch_resume,
#endif
.driver = {
.name = "switch-usb",
.owner = THIS_MODULE,
},
};
static int __init usb_switch_init(void)
{
return platform_driver_register(&usb_switch_driver);
}
}
static int resume(struct platform_device *pdev)
{
/* Restart system timers */
DbgOut(KERN_DEBUG "tspdrv: %s.\n", __func__);
return 0;
}
static const struct of_device_id vib_motor_match[] = {
{.compatible = "vibrator"},
{}
};
static struct platform_driver tspdrv_driver = {
.probe = tspdrv_probe,
.remove = __devexit_p(tspdrv_remove),
.suspend = suspend,
.resume = resume,
.driver = {
.name = MODULE_NAME,
.owner = THIS_MODULE,
.of_match_table = vib_motor_match,
},
};
static int __init tspdrv_init(void)
{
return platform_driver_register(&tspdrv_driver);
}
static void __exit tspdrv_exit(void)
gpio_free(ext_spk_amp_gpio);
snd_soc_unregister_card(card);
mutex_destroy(&cdc_mclk_mutex);
iounmap(pcbcr);
iounmap(prcgr);
return 0;
}
static const struct of_device_id msm8x10_asoc_machine_of_match[] = {
{ .compatible = "qcom,msm8x10-audio-codec", },
{},
};
static struct platform_driver msm8x10_asoc_machine_driver = {
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
.pm = &snd_soc_pm_ops,
.of_match_table = msm8x10_asoc_machine_of_match,
},
.probe = msm8x10_asoc_machine_probe,
.remove = __devexit_p(msm8x10_asoc_machine_remove),
};
module_platform_driver(msm8x10_asoc_machine_driver);
MODULE_DESCRIPTION("ALSA SoC msm");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRV_NAME);
MODULE_DEVICE_TABLE(of, msm8x10_asoc_machine_of_match);
p54_free_common(priv->hw);
return 0;
}
static struct spi_driver p54spi_driver = {
.driver = {
.name = "p54spi",
.bus = &spi_bus_type,
.owner = THIS_MODULE,
},
.probe = p54spi_probe,
.remove = __devexit_p(p54spi_remove),
};
static int __init p54spi_init(void)
{
int ret;
ret = spi_register_driver(&p54spi_driver);
if (ret < 0) {
printk(KERN_ERR "failed to register SPI driver: %d", ret);
goto out;
}
out:
return ret;
}
pci_set_drvdata(pci, mgr);
dev++;
return 0;
}
static void __devexit snd_mixart_remove(struct pci_dev *pci)
{
snd_mixart_free(pci_get_drvdata(pci));
pci_set_drvdata(pci, NULL);
}
static struct pci_driver driver = {
.name = KBUILD_MODNAME,
.id_table = snd_mixart_ids,
.probe = snd_mixart_probe,
.remove = __devexit_p(snd_mixart_remove),
};
static int __init alsa_card_mixart_init(void)
{
return pci_register_driver(&driver);
}
static void __exit alsa_card_mixart_exit(void)
{
pci_unregister_driver(&driver);
}
module_init(alsa_card_mixart_init)
module_exit(alsa_card_mixart_exit)
//iVIZM
static char pro_buf[4]; //iVIZM
static char als_buf[4]; //iVIZM
static int ALS_ON;
// driver definition
static struct i2c_driver taos_driver = {
.driver = {
.owner = THIS_MODULE,
.name = TAOS_DEVICE_NAME,
},
.id_table = taos_idtable,
.probe = taos_probe,
.resume = taos_resume,//iVIZM
.suspend = taos_suspend,//iVIZM
.remove = __devexit_p(taos_remove),
};
// per-device data
//[ECID:000000] ZTEBSP wanghaifei 20111020, remove some variable unsless in struct taos_data
struct taos_data {
struct i2c_client *client;
struct cdev cdev;
struct input_polled_dev *input_poll_dev;
//struct input_dev *input_dev;//iVIZM
//struct work_struct work;//iVIZM
struct wake_lock taos_wake_lock;//iVIZM
char taos_name[TAOS_ID_NAME_SIZE];
// int working;
int open_num;
} *taos_datap;
soc_pcmcia_remove_one(&s->soc);
kfree(s);
}
release_mem_region(dev->res.start, 512);
sa1111_disable_device(dev);
return 0;
}
static struct sa1111_driver pcmcia_driver = {
.drv = {
.name = "sa1111-pcmcia",
},
.devid = SA1111_DEVID_PCMCIA,
.probe = pcmcia_probe,
.remove = __devexit_p(pcmcia_remove),
};
static int __init sa1111_drv_pcmcia_init(void)
{
return sa1111_driver_register(&pcmcia_driver);
}
static void __exit sa1111_drv_pcmcia_exit(void)
{
sa1111_driver_unregister(&pcmcia_driver);
}
fs_initcall(sa1111_drv_pcmcia_init);
module_exit(sa1111_drv_pcmcia_exit);
pci_set_drvdata(pci, card);
return 0;
}
static void __devexit snd_nm256_remove(struct pci_dev *pci)
{
snd_card_free(pci_get_drvdata(pci));
pci_set_drvdata(pci, NULL);
}
static struct pci_driver driver = {
.name = KBUILD_MODNAME,
.id_table = snd_nm256_ids,
.probe = snd_nm256_probe,
.remove = __devexit_p(snd_nm256_remove),
#ifdef CONFIG_PM
.suspend = nm256_suspend,
.resume = nm256_resume,
#endif
};
static int __init alsa_card_nm256_init(void)
{
return pci_register_driver(&driver);
}
static void __exit alsa_card_nm256_exit(void)
{
pci_unregister_driver(&driver);
fnic_free_vnic_resources(fnic);
fnic_clear_intr_mode(fnic);
vnic_dev_close(fnic->vdev);
vnic_dev_unregister(fnic->vdev);
fnic_iounmap(fnic);
pci_release_regions(pdev);
pci_disable_device(pdev);
pci_set_drvdata(pdev, NULL);
scsi_host_put(lp->host);
}
static struct pci_driver fnic_driver = {
.name = DRV_NAME,
.id_table = fnic_id_table,
.probe = fnic_probe,
.remove = __devexit_p(fnic_remove),
};
static int __init fnic_init_module(void)
{
size_t len;
int err = 0;
printk(KERN_INFO PFX "%s, ver %s\n", DRV_DESCRIPTION, DRV_VERSION);
/* Create a cache for allocation of default size sgls */
len = sizeof(struct fnic_dflt_sgl_list);
fnic_sgl_cache[FNIC_SGL_CACHE_DFLT] = kmem_cache_create
("fnic_sgl_dflt", len + FNIC_SG_DESC_ALIGN, FNIC_SG_DESC_ALIGN,
SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA,
NULL);
err:
return ret;
}
static int __devexit tegra_snd_trimslice_remove(struct platform_device *pdev)
{
struct snd_soc_card *card = platform_get_drvdata(pdev);
struct tegra_trimslice *trimslice = snd_soc_card_get_drvdata(card);
snd_soc_unregister_card(card);
tegra_asoc_utils_fini(&trimslice->util_data);
return 0;
}
static struct platform_driver tegra_snd_trimslice_driver = {
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
},
.probe = tegra_snd_trimslice_probe,
.remove = __devexit_p(tegra_snd_trimslice_remove),
};
module_platform_driver(tegra_snd_trimslice_driver);
MODULE_AUTHOR("Mike Rapoport <*****@*****.**>");
MODULE_DESCRIPTION("Trimslice machine ASoC driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" DRV_NAME);
}
static int __devexit stac9766_remove(struct platform_device *pdev)
{
snd_soc_unregister_codec(&pdev->dev);
return 0;
}
static struct platform_driver stac9766_codec_driver = {
.driver = {
.name = "stac9766-codec",
.owner = THIS_MODULE,
},
.probe = stac9766_probe,
.remove = __devexit_p(stac9766_remove),
};
static int __init stac9766_init(void)
{
return platform_driver_register(&stac9766_codec_driver);
}
module_init(stac9766_init);
static void __exit stac9766_exit(void)
{
platform_driver_unregister(&stac9766_codec_driver);
}
module_exit(stac9766_exit);
MODULE_DESCRIPTION("ASoC stac9766 driver");
b44_init_hw(bp);
netif_device_attach(bp->dev);
spin_unlock_irq(&bp->lock);
bp->timer.expires = jiffies + HZ;
add_timer(&bp->timer);
b44_enable_ints(bp);
return 0;
}
static struct pci_driver b44_driver = {
.name = DRV_MODULE_NAME,
.id_table = b44_pci_tbl,
.probe = b44_init_one,
.remove = __devexit_p(b44_remove_one),
.suspend = b44_suspend,
.resume = b44_resume,
};
static int __init b44_init(void)
{
return pci_module_init(&b44_driver);
}
static void __exit b44_cleanup(void)
{
pci_unregister_driver(&b44_driver);
}
module_init(b44_init);
static int s7pro_charger_resume(struct platform_device * pdev)
{
struct msm_hardware_charger *pchg = dev_get_drvdata(&pdev->dev);
pchg->chg_detection_config(1, pchg->gpio_num);
disable_irq_wake(pchg->irq);
return 0;
}
static struct platform_driver pm8058_charger_driver = {
.probe = pm8058_charger_probe,
.remove = __devexit_p(pm8058_charger_remove),
.id_table = charger_table,
.suspend = s7pro_charger_suspend,
.resume = s7pro_charger_resume,
.driver = {
.name = "pm8058-charger-s7pro",
.owner = THIS_MODULE,
},
};
static int __init pm8058_charger_init(void)
{
return platform_driver_register(&pm8058_charger_driver);
}
static void __exit pm8058_charger_exit(void)
#endif
static const struct i2c_device_id adp8860_id[] = {
{ "adp8860", adp8860 },
{ "adp8861", adp8861 },
{ "adp8863", adp8863 },
{ }
};
MODULE_DEVICE_TABLE(i2c, adp8860_id);
static struct i2c_driver adp8860_driver = {
.driver = {
.name = KBUILD_MODNAME,
},
.probe = adp8860_probe,
.remove = __devexit_p(adp8860_remove),
.suspend = adp8860_i2c_suspend,
.resume = adp8860_i2c_resume,
.id_table = adp8860_id,
};
static int __init adp8860_init(void)
{
return i2c_add_driver(&adp8860_driver);
}
module_init(adp8860_init);
static void __exit adp8860_exit(void)
{
i2c_del_driver(&adp8860_driver);
}
return ret;
}
static __devexit int wm8350_power_remove(struct platform_device *pdev)
{
struct wm8350 *wm8350 = platform_get_drvdata(pdev);
struct wm8350_power *power = &wm8350->power;
free_charger_irq(wm8350);
device_remove_file(&pdev->dev, &dev_attr_charger_state);
power_supply_unregister(&power->battery);
power_supply_unregister(&power->ac);
power_supply_unregister(&power->usb);
return 0;
}
static struct platform_driver wm8350_power_driver = {
.probe = wm8350_power_probe,
.remove = __devexit_p(wm8350_power_remove),
.driver = {
.name = "wm8350-power",
},
};
module_platform_driver(wm8350_power_driver);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Power supply driver for WM8350");
MODULE_ALIAS("platform:wm8350-power");
pmic = drvdata->pm_chip_data;
if (pmic)
mfd_remove_devices(pmic->dev);
if (pmic->irq_chip) {
pm8xxx_irq_exit(pmic->irq_chip);
pmic->irq_chip = NULL;
}
platform_set_drvdata(pdev, NULL);
kfree(pmic);
return 0;
}
static struct platform_driver pm8821_driver = {
.probe = pm8821_probe,
.remove = __devexit_p(pm8821_remove),
.driver = {
.name = "pm8821-core",
.owner = THIS_MODULE,
},
};
static int __init pm8821_init(void)
{
return platform_driver_register(&pm8821_driver);
}
postcore_initcall(pm8821_init);
static void __exit pm8821_exit(void)
{
platform_driver_unregister(&pm8821_driver);
struct net_device *dev = pci_get_drvdata(pdev);
BUG_ON(!dev);
unregister_netdev(dev);
release_region(dev->base_addr-0x10, ABYSS_IO_EXTENT);
free_irq(dev->irq, dev);
tmsdev_term(dev);
free_netdev(dev);
pci_set_drvdata(pdev, NULL);
}
static struct pci_driver abyss_driver = {
.name = "abyss",
.id_table = abyss_pci_tbl,
.probe = abyss_attach,
.remove = __devexit_p(abyss_detach),
};
static int __init abyss_init (void)
{
return pci_register_driver(&abyss_driver);
}
static void __exit abyss_rmmod (void)
{
pci_unregister_driver (&abyss_driver);
}
module_init(abyss_init);
module_exit(abyss_rmmod);
pm_runtime_disable(&pdev->dev);
arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_RISE, 0);
arizona_set_irq_wake(arizona, ARIZONA_IRQ_JD_FALL, 0);
arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
arizona_free_irq(arizona, ARIZONA_IRQ_JD_RISE, info);
arizona_free_irq(arizona, ARIZONA_IRQ_JD_FALL, info);
regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
ARIZONA_JD1_ENA, 0);
arizona_clk32k_disable(arizona);
extcon_dev_unregister(&info->edev);
return 0;
}
static struct platform_driver arizona_extcon_driver = {
.driver = {
.name = "arizona-extcon",
.owner = THIS_MODULE,
},
.probe = arizona_extcon_probe,
.remove = __devexit_p(arizona_extcon_remove),
};
module_platform_driver(arizona_extcon_driver);
MODULE_DESCRIPTION("Arizona Extcon driver");
MODULE_AUTHOR("Mark Brown <*****@*****.**>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:extcon-arizona");
}
#endif /* CONFIG_PM */
static struct pci_device_id chipsfb_pci_tbl[] = {
{ PCI_VENDOR_ID_CT, PCI_DEVICE_ID_CT_65550, PCI_ANY_ID, PCI_ANY_ID },
{ 0 }
};
MODULE_DEVICE_TABLE(pci, chipsfb_pci_tbl);
static struct pci_driver chipsfb_driver = {
.name = "chipsfb",
.id_table = chipsfb_pci_tbl,
.probe = chipsfb_pci_init,
.remove = __devexit_p(chipsfb_remove),
#ifdef CONFIG_PM
.suspend = chipsfb_pci_suspend,
.resume = chipsfb_pci_resume,
#endif
};
int __init chips_init(void)
{
if (fb_get_options("chipsfb", NULL))
return -ENODEV;
return pci_register_driver(&chipsfb_driver);
}
module_init(chips_init);
{
led_classdev_resume(&msm_kp_bl_led);
#if defined (CONFIG_LGE_UNIFIED_LED)
leds_pdata->resume_custom_leds();
#endif
return 0;
}
#else
#define msm_pmic_led_suspend NULL
#define msm_pmic_led_resume NULL
#endif
static struct platform_driver msm_pmic_led_driver = {
.probe = msm_pmic_led_probe,
.remove = __devexit_p(msm_pmic_led_remove),
.suspend = msm_pmic_led_suspend,
.resume = msm_pmic_led_resume,
.driver = {
.name = "pmic-leds",
.owner = THIS_MODULE,
},
};
static int __init msm_pmic_led_init(void)
{
return platform_driver_register(&msm_pmic_led_driver);
}
module_init(msm_pmic_led_init);
static void __exit msm_pmic_led_exit(void)
&msm_soc_platform);
}
static int msm_pcm_remove(struct platform_device *pdev)
{
snd_soc_unregister_platform(&pdev->dev);
return 0;
}
static struct platform_driver msm_pcm_driver = {
.driver = {
.name = "msm-pcm-voice",
.owner = THIS_MODULE,
},
.probe = msm_pcm_probe,
.remove = __devexit_p(msm_pcm_remove),
};
static int __init msm_soc_platform_init(void)
{
memset(&voice_info, 0, sizeof(voice_info));
mutex_init(&voice_info[VOICE_SESSION_INDEX].lock);
mutex_init(&voice_info[VOLTE_SESSION_INDEX].lock);
mutex_init(&voice_info[VOICE2_SESSION_INDEX].lock);
return platform_driver_register(&msm_pcm_driver);
}
module_init(msm_soc_platform_init);
static void __exit msm_soc_platform_exit(void)
{
struct usb_hcd *hcd = s5p_ehci->hcd;
if (hcd->driver->shutdown)
hcd->driver->shutdown(hcd);
}
static const struct dev_pm_ops s5p_ehci_pm_ops = {
.suspend = s5p_ehci_suspend,
.resume = s5p_ehci_resume,
#ifdef CONFIG_HIBERNATION
.freeze = s5p_ehci_suspend,
.thaw = s5p_ehci_resume,
.restore = s5p_ehci_resume,
#endif
.runtime_suspend = s5p_ehci_runtime_suspend,
.runtime_resume = s5p_ehci_runtime_resume,
};
static struct platform_driver s5p_ehci_driver = {
.probe = s5p_ehci_probe,
.remove = __devexit_p(s5p_ehci_remove),
.shutdown = s5p_ehci_shutdown,
.driver = {
.name = "s5p-ehci",
.owner = THIS_MODULE,
.pm = &s5p_ehci_pm_ops,
}
};
MODULE_ALIAS("platform:s5p-ehci");
}
static int __devexit cycapsense_prog_remove(struct platform_device *pdev)
{
return 0;
}
static const struct of_device_id cycapsense_dt_match[] = {
{.compatible = "cypress,cycapsense_prog",},
{}
};
MODULE_DEVICE_TABLE(of, cycapsense_dt_match);
static struct platform_driver cycapsense_prog_driver = {
.driver = {
.name = CYCAPSENSE_PROG_NAME,
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(cycapsense_dt_match),
},
.probe = cycapsense_prog_probe,
.remove = __devexit_p(cycapsense_prog_remove),
};
module_platform_driver(cycapsense_prog_driver);
MODULE_ALIAS("prog:cycapsense");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Cypress CapSense(R) programming driver");
MODULE_AUTHOR("Motorola Mobility LLC");
return 0;
}
static int mipid_spi_remove(struct spi_device *spi)
{
dev_dbg(&spi->dev, "mipid_spi_remove\n");
return 0;
}
static struct spi_driver mipid_spi_driver = {
.driver = {
.name = "lcd_mipid",
.owner = THIS_MODULE,
},
.probe = mipid_spi_probe,
.remove = __devexit_p(mipid_spi_remove),
};
static int __init n8x0_panel_drv_init(void)
{
int r;
r = spi_register_driver(&mipid_spi_driver);
if (r) {
pr_err("n8x0_panel: spi driver registration failed\n");
return r;
}
r = omap_dss_register_driver(&n8x0_panel_driver);
if (r) {
pr_err("n8x0_panel: dss driver registration failed\n");