/** * fimc_md_register_platform_entities - register FIMC and CSIS media entities */ static int fimc_md_register_platform_entities(struct fimc_md *fmd) { struct s5p_platform_fimc *pdata = fmd->pdev->dev.platform_data; struct device_driver *driver; int ret, i; driver = driver_find(FIMC_MODULE_NAME, &platform_bus_type); if (!driver) { v4l2_warn(&fmd->v4l2_dev, "%s driver not found, deffering probe\n", FIMC_MODULE_NAME); return -EPROBE_DEFER; } ret = driver_for_each_device(driver, NULL, fmd, fimc_register_callback); if (ret) return ret; driver = driver_find(FIMC_LITE_DRV_NAME, &platform_bus_type); if (driver && try_module_get(driver->owner)) { ret = driver_for_each_device(driver, NULL, fmd, flite_register_callback); if (ret) return ret; module_put(driver->owner); } fmd->fimc_is_subdev=fimc_is_get_subdev(); /* * Check if there is any sensor on the MIPI-CSI2 bus and * if not skip the s5p-csis module loading. */ if (pdata == NULL) return 0; for (i = 0; i < pdata->num_clients; i++) { if (pdata->isp_info[i].bus_type == FIMC_MIPI_CSI2) { ret = 1; break; } } if (!ret) return 0; driver = driver_find(CSIS_DRIVER_NAME, &platform_bus_type); if (!driver || !try_module_get(driver->owner)) { v4l2_warn(&fmd->v4l2_dev, "%s driver not found, deffering probe\n", CSIS_DRIVER_NAME); return -EPROBE_DEFER; } return driver_for_each_device(driver, NULL, fmd, csis_register_callback); }
/** * driver_register - register driver with bus * @drv: driver to register * * We pass off most of the work to the bus_add_driver() call, * since most of the things we have to do deal with the bus * structures. */ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; BUG_ON(!drv->bus->p); if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) #ifdef CONFIG_DEBUG_PRINTK printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); #else ; #endif other = driver_find(drv->name, drv->bus); if (other) { printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EBUSY; } ret = bus_add_driver(drv); if (ret) return ret; ret = driver_add_groups(drv, drv->groups); if (ret) bus_remove_driver(drv); return ret; }
/** * driver_register - register driver with bus * @drv: driver to register * * We pass off most of the work to the bus_add_driver() call, * since most of the things we have to do deal with the bus * structures. */ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; BUG_ON(!drv->bus->p); if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); other = driver_find(drv->name, drv->bus); if (other) { printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EBUSY; } ret = bus_add_driver(drv); if (ret) return ret; ret = driver_add_groups(drv, drv->groups); if (ret) { bus_remove_driver(drv); return ret; } kobject_uevent(&drv->p->kobj, KOBJ_ADD); return ret; }
/** * driver_register - register driver with bus * @drv: driver to register * * We pass off most of the work to the bus_add_driver() call, * since most of the things we have to do deal with the bus * structures. */ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; /* 在注册驱动前,必须为驱动指定了总线类型,并且该总线类型已经注册到Linux驱动模型 */ BUG_ON(!drv->bus->p); /* 如果总线类型和驱动都定义了相同名字的函数,将给出一条警告消息 */ if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); /* 在总线类型的驱动链表中查找该驱动名,如果找到,表明该驱动名已经在使用中,返回错误 */ other = driver_find(drv->name, drv->bus); if (other) { put_driver(other); printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EBUSY; } ret = bus_add_driver(drv); /* Add a driver to the bus. */ if (ret) return ret; ret = driver_add_groups(drv, drv->groups); if (ret) bus_remove_driver(drv); return ret; }
/*函数用来向系统注册一个驱动*/ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; BUG_ON(!drv->bus->p); if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); /*在drv->bus上查找当前要注册的drv,这主要是防止向系统重复注册同一个驱动*/ other = driver_find(drv->name, drv->bus); if (other) { put_driver(other); printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EBUSY; } /*进行实际的注册*/ ret = bus_add_driver(drv); if (ret) return ret; ret = driver_add_groups(drv, drv->groups); if (ret) bus_remove_driver(drv); return ret; }
/** * driver_register - register driver with bus * @drv: driver to register * * We pass off most of the work to the bus_add_driver() call, * since most of the things we have to do deal with the bus * structures. */ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); other = driver_find(drv->name, drv->bus); if (other) { put_driver(other); printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EEXIST; } ret = bus_add_driver(drv); if (ret) return ret; ret = driver_add_groups(drv, drv->groups); if (ret) bus_remove_driver(drv); return ret; }
/** * fimc_md_register_platform_entities - register FIMC and CSIS media entities */ static int fimc_md_register_platform_entities(struct fimc_md *fmd) { struct device_driver *driver; int ret; driver = driver_find(FIMC_MODULE_NAME, &platform_bus_type); if (!driver) return -ENODEV; ret = driver_for_each_device(driver, NULL, fmd, fimc_register_callback); if (ret) return ret; driver = driver_find(CSIS_DRIVER_NAME, &platform_bus_type); if (driver) ret = driver_for_each_device(driver, NULL, fmd, csis_register_callback); return ret; }
static struct platform_device *get_mipi_csis_pdev(int id) { const char *module_name = "s5p-mipi-csis"; struct device_driver *drv; struct platform_device *pdev[FLITE_ID_END]; int ret; drv = driver_find(module_name, &platform_bus_type); if (!drv) { request_module(module_name); drv = driver_find(module_name, &platform_bus_type); } if (!drv) return ERR_PTR(-ENODEV); ret = driver_for_each_device(drv, NULL, &pdev[0], mipi_csis_callback); return ret ? NULL : pdev[id]; }
static int initFFU(void) { drv = driver_find(MMC_DEVNAME,&platform_bus_type); if( drv ) { plat_drv = container_of(drv,struct platform_driver, driver); printk(KERN_ALERT "Found platform driver %s : %x\n", MMC_DEVNAME, (unsigned int)plat_drv); } else {
static void __exit cx18_alsa_exit(void) { struct device_driver *drv; int ret; printk(KERN_INFO "cx18-alsa: module unloading...\n"); drv = driver_find("cx18", &pci_bus_type); ret = driver_for_each_device(drv, NULL, NULL, cx18_alsa_exit_callback); cx18_ext_init = NULL; printk(KERN_INFO "cx18-alsa: module unload complete\n"); }
static void __exit ivtv_alsa_exit(void) { struct device_driver *drv; int ret; pr_info("ivtv-alsa: module unloading...\n"); drv = driver_find("ivtv", &pci_bus_type); ret = driver_for_each_device(drv, NULL, NULL, ivtv_alsa_exit_callback); (void)ret; /* suppress compiler warning */ ivtv_ext_init = NULL; pr_info("ivtv-alsa: module unload complete\n"); }
static void adcfg_work_handler(struct work_struct *work) { static int twl4030_adc_found = false; /* twl4030_madc is a drvier for ADC in TWL4030 PMIC */ /* It is loaded after adc fuelgauge driver. So we have to wait */ if (true == twl4030_adc_found || NULL != driver_find("twl4030_madc", &platform_bus_type)) { twl4030_adc_found = true; get_batt_info(5, false); adcfg_lowbat_detect(); } queue_delayed_work(adcfg_workq, &adcfg_work, msecs_to_jiffies(BATT_ADC_CHK_INTERVAL)); }
static struct exynos_md *flite_get_capture_md(enum mdev_node node) { struct device_driver *drv; struct exynos_md *md[MDEV_MAX_NUM] = {NULL,}; int ret; drv = driver_find(MDEV_MODULE_NAME, &platform_bus_type); if (!drv) return ERR_PTR(-ENODEV); ret = driver_for_each_device(drv, NULL, &md[0], flite_get_md_callback); put_driver(drv); return ret ? NULL : md[node]; }
static struct v4l2_subdev *fimc_is_get_subdev() { const char *module_name = "exynos4-fimc-is"; struct device_driver *drv; struct v4l2_subdev *sd = NULL; int ret; drv = driver_find(module_name, &platform_bus_type); if (!drv) { printk("%s driver not found, deffering probe\n", module_name); return -EPROBE_DEFER; } if (drv && try_module_get(drv->owner)) { ret = driver_for_each_device(drv, NULL, &sd, fimc_is_register_callback); if (ret) return ret; module_put(drv->owner); } gfmd->fimc[0]->vid_cap.isp_subdev=sd; return ret ? NULL : sd; }
int32_t msm_sensor_platform_probe(struct platform_device *pdev, void *data) { int32_t rc = 0; struct msm_sensor_ctrl_t *s_ctrl = (struct msm_sensor_ctrl_t *)data; struct device_driver *driver; struct device *dev; s_ctrl->pdev = pdev; CDBG("%s called data %p\n", __func__, data); if (pdev->dev.of_node) { rc = msm_sensor_init_sensor_data(pdev, s_ctrl); if (rc < 0) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } } s_ctrl->sensor_i2c_client->cci_client = kzalloc(sizeof( struct msm_camera_cci_client), GFP_KERNEL); if (!s_ctrl->sensor_i2c_client->cci_client) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } driver = driver_find(MSM_CCI_DRV_NAME, &platform_bus_type); if (!driver) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } dev = driver_find_device(driver, NULL, 0, msm_sensor_subdev_match_core); if (!dev) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } s_ctrl->sensor_i2c_client->cci_client->cci_subdev = dev_get_drvdata(dev); CDBG("%s sd %p\n", __func__, s_ctrl->sensor_i2c_client->cci_client->cci_subdev); s_ctrl->sensor_i2c_client->cci_client->cci_i2c_master = MASTER_0; s_ctrl->sensor_i2c_client->cci_client->sid = s_ctrl->sensor_i2c_addr >> 1; s_ctrl->sensor_i2c_client->cci_client->retries = 0; s_ctrl->sensor_i2c_client->cci_client->id_map = 0; rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl); if (rc < 0) { pr_err("%s %s power up failed\n", __func__, pdev->id_entry->name); return rc; } if (s_ctrl->func_tbl->sensor_match_id) rc = s_ctrl->func_tbl->sensor_match_id(s_ctrl); else rc = msm_sensor_match_id(s_ctrl); if (rc < 0) goto probe_fail; v4l2_subdev_init(&s_ctrl->sensor_v4l2_subdev, s_ctrl->sensor_v4l2_subdev_ops); snprintf(s_ctrl->sensor_v4l2_subdev.name, sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", s_ctrl->sensordata->sensor_name); v4l2_set_subdevdata(&s_ctrl->sensor_v4l2_subdev, pdev); msm_sensor_register(&s_ctrl->sensor_v4l2_subdev); goto power_down; probe_fail: pr_err("%s %s probe failed\n", __func__, pdev->id_entry->name); power_down: s_ctrl->func_tbl->sensor_power_down(s_ctrl); return rc; }
static int msm_mctl_register_subdevs(struct msm_cam_media_controller *p_mctl, int core_index) { struct device_driver *driver; struct device *dev; int rc = -ENODEV; /* register csiphy subdev */ driver = driver_find(MSM_CSIPHY_DRV_NAME, &platform_bus_type); if (!driver) goto out; dev = driver_find_device(driver, NULL, (void *)core_index, msm_mctl_subdev_match_core); if (!dev) goto out_put_driver; p_mctl->csiphy_sdev = dev_get_drvdata(dev); // put_driver(driver); /* register csid subdev */ driver = driver_find(MSM_CSID_DRV_NAME, &platform_bus_type); if (!driver) goto out; dev = driver_find_device(driver, NULL, (void *)core_index, msm_mctl_subdev_match_core); if (!dev) goto out_put_driver; p_mctl->csid_sdev = dev_get_drvdata(dev); // put_driver(driver); /* register ispif subdev */ driver = driver_find(MSM_ISPIF_DRV_NAME, &platform_bus_type); if (!driver) goto out; dev = driver_find_device(driver, NULL, 0, msm_mctl_subdev_match_core); if (!dev) goto out_put_driver; p_mctl->ispif_sdev = dev_get_drvdata(dev); // put_driver(driver); /* register vfe subdev */ driver = driver_find(MSM_VFE_DRV_NAME, &platform_bus_type); if (!driver) goto out; dev = driver_find_device(driver, NULL, 0, msm_mctl_subdev_match_core); if (!dev) goto out_put_driver; p_mctl->isp_sdev->sd = dev_get_drvdata(dev); // put_driver(driver); /* register vfe subdev */ driver = driver_find(MSM_VPE_DRV_NAME, &platform_bus_type); if (!driver) goto out; dev = driver_find_device(driver, NULL, 0, msm_mctl_subdev_match_core); if (!dev) goto out_put_driver; p_mctl->isp_sdev->sd_vpe = dev_get_drvdata(dev); // put_driver(driver); rc = 0; return rc; out_put_driver: // put_driver(driver); out: return rc; }
int __init bcm_mpi_init(bcm_mpi_t *t, const bcm_mpi_params_t *params) { int ret = -1; #ifdef BCMPH_USE_SPI_DRIVER # ifndef BCMPH_NOHW struct spi_master *master; struct spi_board_info board_info; # endif // !BCMPH_NOHW #endif // BCMPH_USE_SPI_DRIVER bcm_pr_debug("%s()\n", __func__); bcm_assert(NULL != params); #ifndef BCMPH_NOHW t->trx_opts.fill_byte = params->fill_byte; t->trx_opts.wait_completion_with_irq = params->wait_completion_with_irq; t->trx_opts.drop_cs_after_each_byte = params->drop_cs_after_each_byte; t->trx_opts.cs_off_clk_cycles = params->cs_off_clk_cycles; #endif // !BCMPH_NOHW #ifdef BCMPH_USE_SPI_DRIVER t->mpi_clk = params->clk; # ifndef BCMPH_NOHW master = spi_busnum_to_master(params->bus_num); if (NULL == master) { bcm_pr_err("No SPI master found for bus num %d. Module bcm63xx-spi not loaded ?\n", (int)(params->bus_num)); ret = -EINVAL; goto fail_master; } memset(&(board_info), 0, sizeof(board_info)); strcpy(board_info.modalias, driver_name); board_info.max_speed_hz = params->clk; board_info.bus_num = params->bus_num; board_info.chip_select = params->cs; board_info.mode = SPI_MODE_3; t->dev = spi_new_device(master, &(board_info)); if (NULL == t->dev) { bcm_pr_err("Failed to add SPI device (busnum = %d, chip select = %d, clock = %lu)\n", (int)(params->bus_num), (int)(params->cs), (unsigned long)(params->clk)); ret = -ENOMEM; goto fail_new_dev; } put_device(&(master->dev)); /* Lock the bus */ if ((params->has_exclusive_bus_access) && (!bcm_drv_param_mpi_no_exclusive_bus_access)) { spi_bus_lock(t->dev->master); t->bus_is_locked = true; } bcm_mpi_enable_extra_CSs(params->cs); # ifdef BCMPH_DEBUG_MPI t->trace_len = 0; # endif // BCMPH_DEBUG_MPI return (0); spi_unregister_device(t->dev); fail_new_dev: put_device(&(master->dev)); fail_master: # else // BCMPH_NOHW ret = 0; # endif // BCMPH_NOHW #else // !BCMPH_USE_SPI_DRIVER # ifndef BCMPH_NOHW t->mpi_cs = params->cs; t->clk_cfg = bcm_mpi_get_clk_cfg(params->clk, params->cs_off_clk_cycles); bcm_mpi_enable_extra_CSs(params->cs); if (bcm_mpi_dev_data.ref_count <= 0) { struct device_driver *spi_driver = driver_find(bcm63xx_spi_driver.driver.name, &platform_bus_type); if (NULL != spi_driver) { bcm_pr_err("Error: Driver '%s' is already registered, aborting...\n", bcm63xx_spi_driver.driver.name); ret = -EBUSY; } else { ret = platform_driver_register(&(bcm63xx_spi_driver)); } bcm_assert(((ret) && (0 == bcm_mpi_dev_data.ref_count)) || ((!ret) && (1 == bcm_mpi_dev_data.ref_count))); } else { bcm_mpi_dev_data.ref_count += 1; ret = 0; } if (!ret) { bcm_assert(bcm_mpi_dev_data.ref_count > 0); if (params->cs > bcm_mpi_dev_data.num_chipselect) { dev_err(&(bcm_mpi_dev_data.pdev->dev), "%s, unsupported slave %d\n", __func__, params->cs); if (1 == bcm_mpi_dev_data.ref_count) { platform_driver_unregister(&(bcm63xx_spi_driver)); } bcm_mpi_dev_data.ref_count -= 1; ret = -EINVAL; } else { t->dev_data = &(bcm_mpi_dev_data); } } # else // BCMPH_NOHW ret = 0; # endif // BCMPH_NOHW #endif // !BCMPH_USE_SPI_DRIVER return (ret); }