/**
* 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);
}
