static int __init da9052_spi_init(void)
{
int ret;
ret = spi_register_driver(&da9052_spi_driver);
if (ret != 0) {
pr_err("Failed to register DA9052 SPI driver, %d\n", ret);
return ret;
}
return 0;
}
static int __init ad1836_init(void)
{
int ret;
ret = spi_register_driver(&ad1836_spi_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register ad1836 SPI driver: %d\n",
ret);
}
return ret;
}
static int __init wm831x_spi_init(void)
{
int ret;
ret = spi_register_driver(&wm8310_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
ret = spi_register_driver(&wm8311_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
ret = spi_register_driver(&wm8312_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
ret = spi_register_driver(&wm8320_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
ret = spi_register_driver(&wm8321_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
ret = spi_register_driver(&wm8325_spi_driver);
if (ret != 0)
pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
return 0;
}
static int __init wm8770_modinit(void)
{
int ret = 0;
#if defined(CONFIG_SPI_MASTER)
ret = spi_register_driver(&wm8770_spi_driver);
if (ret) {
printk(KERN_ERR "Failed to register wm8770 SPI driver: %d\n",
ret);
}
#endif
return ret;
}
static int __init memlcd_spi_init(void)
{
int ret;
ret = spi_register_driver(&memlcd_spi_driver);
if (ret < 0) {
printk(KERN_ERR "Failed to register memlcdfb-spi driver: %d", ret);
goto out;
}
out:
return ret;
}
static
int __init s5c73m3_spi_init(void)
{
int ret;
pr_err("%s\n", __func__);
ret = spi_register_driver(&s5c73m3_spi_driver);
if (ret)
pr_err("failed to register s5c73mc fw - %x\n", ret);
return ret;
}
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;
}
static int __init wl1271_init(void)
{
int ret;
ret = spi_register_driver(&wl1271_spi_driver);
if (ret < 0) {
wl1271_error("failed to register spi driver: %d", ret);
goto out;
}
out:
return ret;
}
//----------------------------------------------------------------------
//sq_spi_download_init
//----------------------------------------------------------------------
int __init sq_spi_download_init(void)
{
int err=0,i;
//#if (USE_CDEV == 1)
dev_t dev_id;
int retval;
SPI_DOWNLOAD_DBG(" sq_spi_download_init\n");
err=spi_register_driver(&sq_spi_download_driver);
if(err)
printk("sq_spi_download_driver init fail\n");
/*
err = platform_driver_register(&sq_spi_download_driver);
if(err)
printk("sq_spi_download_driver init fail\n");
*/
//#else
if (major) {
dev_id = MKDEV(major, 0);
retval = register_chrdev_region(dev_id, sq_spi_download_COUNT,NAME);
} else {
retval = alloc_chrdev_region(&dev_id, 0, sq_spi_download_COUNT,NAME);
major = MAJOR(dev_id);
}
SPI_DOWNLOAD_DBG(": mask=%#lx major=%d\n", mask, major);
cdev_init(&sq_spi_download_cdev, &sq_spi_download_fops);
cdev_add(&sq_spi_download_cdev, dev_id, sq_spi_download_COUNT);
//#endif
SPI_DOWNLOAD_DBG(" sq_spi_download_init end\n");
/*
#define DL_PROGB (0x01 << 7)
#define DL_DONE (0x01 << 6)
#define DL_RST (0x01 << 5)
#define DL_INITB (0x01 << 4)
*/
i=10;
return err;
}
static int cam12mp_sensor_probe(const struct msm_camera_sensor_info *info,
struct msm_sensor_ctrl *s)
{
s->s_init = cam12mp_sensor_init;
s->s_release = cam12mp_sensor_release;
s->s_config = cam12mp_sensor_config;
pDlMem = kzalloc((896*1024), GFP_KERNEL);
LOGI("+%s Dlmem:0x%x\n", __func__,pDlMem);
if(!pDlMem)
LOGE(" -%s DlMem kzalloc() Failed!\n",__func__);
return spi_register_driver(&cam12mp_spi_driver);
}
int __init serial_m3110_init(void)
{
int ret = 0;
ret = uart_register_driver(&serial_m3110_reg);
if (ret)
return ret;
ret = spi_register_driver(&uart_max3110_driver);
if (ret)
uart_unregister_driver(&serial_m3110_reg);
return ret;
}
static int __init msm_eeprom_init_module(void)
{
int rc = 0, spi_rc = 0;
CDBG("%s E\n", __func__);
rc = platform_driver_probe(&msm_eeprom_platform_driver, msm_eeprom_platform_probe);
CDBG("%s:%d platform rc %d\n", __func__, __LINE__, rc);
spi_rc = spi_register_driver(&msm_eeprom_spi_driver);
rc = i2c_add_driver(&msm_eeprom_i2c_driver);
if (rc < 0 && spi_rc < 0)
pr_err("%s:%d probe failed\n", __func__, __LINE__);
return rc;
}
int bp_spi_add_driver(int (*callback)(void))
{
int status = 0;
callback_func = callback;
status = spi_register_driver(&bp_spi_driver);
if(status == SPI_OK)
{
DEBUGONDISPLAY(MODE_PHY_DEBUG,printk("[SPI] init success\n"));
}
else
{
printk("[SPI] init fail\n");
}
return status;
}
static int __init adav80x_init(void)
{
int ret = 0;
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
ret = i2c_add_driver(&adav80x_i2c_driver);
if (ret)
return ret;
#endif
#if defined(CONFIG_SPI_MASTER)
ret = spi_register_driver(&adav80x_spi_driver);
#endif
return ret;
}
/*
* Initialization function which allocates and set different parameters for TTY SPI driver. Registers the tty driver
* with TTY core and register SPI driver with the Kernel. It validates the GPIO pins for MRDY and then request an IRQ
* on SRDY GPIO pin for SRDY signal going HIGH. In case of failure of SPI driver register cases it unregister tty driver
* from tty core.
*/
static int __init ifx_spi_init(void)
{
int status = 0;
/* Allocate and Register a TTY device */
ifx_spi_tty_driver = alloc_tty_driver(IFX_N_SPI_MINORS);
if (!ifx_spi_tty_driver)
{
IFX_SPI_PRINTK("Fail to allocate TTY Driver");
return -ENOMEM;
}
/* initialize the tty driver */
ifx_spi_tty_driver->owner = THIS_MODULE;
ifx_spi_tty_driver->driver_name = "ifxn721";
ifx_spi_tty_driver->name = "ttyspi";
ifx_spi_tty_driver->major = IFX_SPI_MAJOR;
ifx_spi_tty_driver->minor_start = 0;
ifx_spi_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
ifx_spi_tty_driver->subtype = SERIAL_TYPE_NORMAL;
ifx_spi_tty_driver->flags = TTY_DRIVER_REAL_RAW;
ifx_spi_tty_driver->init_termios = tty_std_termios;
ifx_spi_tty_driver->init_termios.c_cflag = B38400/*B9600*/ | CS8 | CREAD | HUPCL | CLOCAL;
tty_set_operations(ifx_spi_tty_driver, &ifx_spi_ops);
status = tty_register_driver(ifx_spi_tty_driver);
if (status)
{
IFX_SPI_PRINTK("Failed to register IFX SPI tty driver");
put_tty_driver(ifx_spi_tty_driver);
return status;
}
/* Register SPI Driver */
status = spi_register_driver(&ifx_spi_driver);
if (status < 0)
{
IFX_SPI_PRINTK("Failed to register SPI device");
tty_unregister_driver(ifx_spi_tty_driver);
put_tty_driver(ifx_spi_tty_driver);
return status;
}
printk("**** %s \n",__FUNCTION__);
return status;
}
struct link_device *spi_create_link_device(struct platform_device *pdev)
{
int ret;
struct modem_data *pdata = pdev->dev.platform_data;
struct link_device *ld;
mif_err("&&** spi create link device \n");
if (!pdata) {
mif_err("modem_data is null\n");
return NULL;
}
spi_boot_id = kzalloc(sizeof(struct spi_boot_link_device), GFP_KERNEL);
if (!spi_boot_id) {
mif_err("allocation fail for spi_boot_id\n");
return NULL;
}
INIT_LIST_HEAD(&spi_boot_id->ld.list);
ld = &spi_boot_id->ld;
ld->name = "spi_boot";
ld->init_comm = spi_boot_init;
ld->terminate_comm = spi_boot_terminate;
ld->send = spi_boot_send;
//ld->com_state = COM_NONE;
ret = spi_register_driver(&spi_boot_driver);
if (ret) {
mif_err("spi_register_driver() fail(%d)\n", ret);
goto err;
}
skb_queue_head_init(&spi_boot_id->tx_q);
mif_info("success\n");
return ld;
err:
kfree(spi_boot_id);
return NULL;
}
static int __init spi_aic3254_init(void)
{
int ret = 0;
struct ecodec_aic3254_state *codec_drv = &codec_clk;
pr_aud_info("%s\n", __func__);
mutex_init(&lock);
ret = spi_register_driver(&spi_aic3254);
if (ret < 0) {
pr_aud_err("%s:failed to register spi driver(%d)\n", __func__, ret);
return ret;
}
ret = misc_register(&aic3254_misc);
if (ret < 0) {
pr_aud_err("%s:failed to register misc device\n", __func__);
spi_unregister_driver(&spi_aic3254);
return ret;
}
#if defined(CONFIG_ARCH_MSM7X30)
codec_drv->rx_mclk = clk_get(NULL, "mi2s_codec_rx_m_clk");
if (IS_ERR(codec_drv->rx_mclk)) {
pr_aud_err("%s:failed to get mi2s mclk\n", __func__);
misc_deregister(&aic3254_misc);
spi_unregister_driver(&spi_aic3254);
return -ENODEV;
}
codec_drv->rx_sclk = clk_get(NULL, "mi2s_codec_rx_s_clk");
if (IS_ERR(codec_drv->rx_sclk)) {
pr_aud_err("%s:failed to get mi2s sclk\n", __func__);
misc_deregister(&aic3254_misc);
spi_unregister_driver(&spi_aic3254);
clk_put(codec_drv->rx_mclk);
return -ENODEV;
}
#endif
pm_qos_add_request(&codec_drv->pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
wake_lock_init(&codec_drv->wakelock, WAKE_LOCK_SUSPEND,
"aic3254_suspend_lock");
return 0;
}
static int __init nxtts_init_spi(void)
{
int error;
nxtts_ctl.tx_buff = kzalloc(SPI_BUFF_SIZE, GFP_KERNEL | GFP_DMA);
if (!nxtts_ctl.tx_buff) {
error = -ENOMEM;
goto nxtts_init_error;
}
nxtts_ctl.rx_buff = kzalloc(SPI_BUFF_SIZE, GFP_KERNEL | GFP_DMA);
if (!nxtts_ctl.rx_buff) {
error = -ENOMEM;
goto nxtts_init_error;
}
error = spi_register_driver(&nxtts_driver);
if (error < 0) {
printk(KERN_ALERT "spi_register_driver() failed %d\n", error);
return error;
}
error = add_nxtts_device_to_bus();
if (error < 0) {
printk(KERN_ALERT "add_nxtts_to_bus() failed\n");
spi_unregister_driver(&nxtts_driver);
return error;
}
return 0;
nxtts_init_error:
if (nxtts_ctl.tx_buff) {
kfree(nxtts_ctl.tx_buff);
nxtts_ctl.tx_buff = 0;
}
if (nxtts_ctl.rx_buff) {
kfree(nxtts_ctl.rx_buff);
nxtts_ctl.rx_buff = 0;
}
return error;
}
int cc2520_plat_spi_init()
{
int result;
result = cc2520_spi_add_to_bus();
if (result < 0)
goto error;
result = spi_register_driver(&cc2520_spi_driver);
if (result < 0)
goto error;
return 0;
error:
spi_unregister_driver(&cc2520_spi_driver);
return result;
}
static int __init pcd8544_init_spi(void)
{
int error;
error = spi_register_driver(&pcd8544_driver);
if (error < 0) {
printk(KERN_ALERT "spi_register_driver() failed %d\n", error);
return error; }
error = add_pcd8544_device_to_bus();
if (error < 0) {
printk(KERN_ALERT "add_pcd8544_to_bus() failed\n");
spi_unregister_driver(&pcd8544_driver);
return error;
}
return 0;
}
int __init spi_eeprom_read(int busid, int chipid, int address,
unsigned char *buf, int len)
{
int ret;
struct read_param param = {
.busid = busid,
.chipid = chipid,
.address = address,
.buf = buf,
.len = len
};
read_param = ¶m;
ret = spi_register_driver(&early_seeprom_driver);
if (!ret)
spi_unregister_driver(&early_seeprom_driver);
return ret;
}
static int __init mcp3901_init(void)
{
int ret;
ret = spi_register_driver(&mcp3901_driver);
if(ret)
goto error;
ret = mcp3901_hotplug();
if(ret)
goto error;
return 0;
error:
return ret;
}
int linux_spi_init(void* vp){
int ret = 1;
static int called = 0;
if(called == 0){
called++;
if(&atwilc_bus == NULL){
PRINT_ER("atwilc_bus address is NULL\n");
}
ret = spi_register_driver(&atwilc_bus);
}
/* change return value to match ATWILC interface */
(ret<0)? (ret = 0):(ret = 1);
return ret;
}
static int __init adg739_init(void)
{
//выделение памяти для структуры состояния драйвера
adg739_status = kzalloc(sizeof(struct adg739_data), GFP_KERNEL);
if (!adg739_status)
{
return (-ENOMEM);
}
//получение идентификатора для устройства
if(alloc_chrdev_region(&dev_adg739, 0, 1, device_name))
{
printk(KERN_ALERT "The request_mem_region function failed\n");
return (1);
}
//регистрация символьного устройства
cdev_init(&cdev_adg739, &adg739_fops);
cdev_adg739.owner = THIS_MODULE;
if (cdev_add(&cdev_adg739, dev_adg739, 1))
{
unregister_chrdev_region(dev_adg739, 1);
printk(KERN_ERR "The cdev_add function failed\n");
return(1);
}
//регистрация класса устройств
devclass = class_create( THIS_MODULE, DEV_CLASS_MUL); //создание класса
if (IS_ERR(devclass))
{
printk(KERN_ERR "The class_create function failed\n");
unregister_chrdev_region(dev_adg739, 1);
return (PTR_ERR(devclass));
}
//регистрация spi драйвера
if (spi_register_driver(&spi_adg739_driver))
{
printk(KERN_ERR "The spi_register_driver function failed\n");
unregister_chrdev_region(dev_adg739, 1);
class_destroy(devclass);
return (1);
}
return (0);
}
static int __init spi_aic3254_init(void)
{
int ret = 0;
struct ecodec_aic3254_state *codec_drv = &codec_clk;
pr_aud_info("%s\n", __func__);
mutex_init(&lock);
ret = spi_register_driver(&spi_aic3254);
if (ret < 0) {
pr_aud_err("%s:failed to register spi driver(%d)\n", __func__, ret);
return ret;
}
ret = misc_register(&aic3254_misc);
if (ret < 0) {
pr_aud_err("%s:failed to register misc device\n", __func__);
spi_unregister_driver(&spi_aic3254);
return ret;
}
#if defined(CONFIG_ARCH_MSM7X30)
codec_drv->rx_mclk = clk_get(NULL, "mi2s_codec_rx_m_clk");
if (IS_ERR(codec_drv->rx_mclk)) {
pr_aud_err("%s:failed to get mi2s mclk\n", __func__);
misc_deregister(&aic3254_misc);
spi_unregister_driver(&spi_aic3254);
return -ENODEV;
}
codec_drv->rx_sclk = clk_get(NULL, "mi2s_codec_rx_s_clk");
if (IS_ERR(codec_drv->rx_sclk)) {
pr_aud_err("%s:failed to get mi2s sclk\n", __func__);
misc_deregister(&aic3254_misc);
spi_unregister_driver(&spi_aic3254);
clk_put(codec_drv->rx_mclk);
return -ENODEV;
}
#endif
wake_lock_init(&codec_drv->idlelock, WAKE_LOCK_IDLE,
"aic3254_lock");
return 0;
}
static int __init wm8711_modinit(void)
{
int ret;
#if IS_ENABLED(CONFIG_I2C)
ret = i2c_add_driver(&wm8711_i2c_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register WM8711 I2C driver: %d\n",
ret);
}
#endif
#if defined(CONFIG_SPI_MASTER)
ret = spi_register_driver(&wm8711_spi_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register WM8711 SPI driver: %d\n",
ret);
}
#endif
return 0;
}
static int __init wm8988_modinit(void)
{
int ret = 0;
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
ret = i2c_add_driver(&wm8988_i2c_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register WM8988 I2C driver: %d\n",
ret);
}
#endif
#if defined(CONFIG_SPI_MASTER)
ret = spi_register_driver(&wm8988_spi_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register WM8988 SPI driver: %d\n",
ret);
}
#endif
return ret;
}
static int __init es8328_modinit(void)
{
int ret = 0;
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
pr_debug("es8328: adding i2c driver\n");
ret = i2c_add_driver(&es8328_i2c_driver);
if (ret != 0) {
pr_err("failed to register es8328 I2C driver: %d\n", ret);
}
#endif
#if defined(CONFIG_SPI_MASTER)
pr_debug("es8328: adding spi driver\n");
ret = spi_register_driver(&es8328_spi_driver);
if (ret != 0) {
pr_err("Failed to register es8328 SPI driver: %d\n", ret);
}
#endif
return ret;
}
static int __init xpt2046_ts_init(void)
{
int ret = spi_register_driver(&xpt2046_ts_driver);
rk28printk("Touch panel drive XPT2046 driver init...\n");
if (ret == 0)
{
gADPoint.x = 0;
gADPoint.y = 0;
ret += driver_create_file(&xpt2046_ts_driver.driver, &driver_attr_calistatus);
ret += driver_create_file(&xpt2046_ts_driver.driver, &driver_attr_pressure);
}
return ret;
}
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");
spi_unregister_driver(&mipid_spi_driver);
return r;
}
return 0;
}
