int32_t msm_eeprom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; struct msm_eeprom_ctrl_t *e_ctrl_t = NULL; CDBG("%s called\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("i2c_check_functionality failed\n"); goto probe_failure; } e_ctrl_t = (struct msm_eeprom_ctrl_t *)(id->driver_data); e_ctrl_t->i2c_client.client = client; if (e_ctrl_t->i2c_addr != 0) e_ctrl_t->i2c_client.client->addr = e_ctrl_t->i2c_addr; CDBG("%s client = %x\n", __func__, (unsigned int) client); /* Assign name for sub device */ snprintf(e_ctrl_t->sdev.name, sizeof(e_ctrl_t->sdev.name), "%s", e_ctrl_t->i2c_driver->driver.name); if (e_ctrl_t->func_tbl.eeprom_init != NULL) { rc = e_ctrl_t->func_tbl.eeprom_init(e_ctrl_t, e_ctrl_t->i2c_client.client->adapter); } msm_camera_eeprom_read_tbl(e_ctrl_t, e_ctrl_t->read_tbl, e_ctrl_t->read_tbl_size); if (e_ctrl_t->func_tbl.eeprom_format_data != NULL) e_ctrl_t->func_tbl.eeprom_format_data(); if (e_ctrl_t->func_tbl.eeprom_release != NULL) rc = e_ctrl_t->func_tbl.eeprom_release(e_ctrl_t); /* Initialize sub device */ v4l2_i2c_subdev_init(&e_ctrl_t->sdev, e_ctrl_t->i2c_client.client, e_ctrl_t->eeprom_v4l2_subdev_ops); CDBG("%s success resut=%d\n", __func__, rc); return rc; probe_failure: pr_err("%s failed! rc = %d\n", __func__, rc); return rc; }
static int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr, client->adapter->name); state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); if (state == NULL) return -ENOMEM; state->irq = client->irq; mutex_init(&state->mutex); state->autodetect = true; state->powered = true; state->input = 0; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); ret = adv7180_init_controls(state); if (ret) goto err_unreg_subdev; ret = init_device(client, state); if (ret) goto err_free_ctrl; ret = v4l2_async_register_subdev(sd); if (ret) goto err_free_irq; return 0; err_free_irq: if (state->irq > 0) free_irq(client->irq, state); err_free_ctrl: adv7180_exit_controls(state); err_unreg_subdev: mutex_destroy(&state->mutex); return ret; }
static int mt9v011_probe(struct i2c_client *c, const struct i2c_device_id *id) { u16 version; struct mt9v011 *core; struct v4l2_subdev *sd; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(c->adapter, I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) return -EIO; core = kzalloc(sizeof(struct mt9v011), GFP_KERNEL); if (!core) return -ENOMEM; sd = &core->sd; v4l2_i2c_subdev_init(sd, c, &mt9v011_ops); /* Check if the sensor is really a MT9V011 */ version = mt9v011_read(sd, R00_MT9V011_CHIP_VERSION); if ((version != MT9V011_VERSION) && (version != MT9V011_REV_B_VERSION)) { v4l2_info(sd, "*** unknown micron chip detected (0x%04x).\n", version); kfree(core); return -EINVAL; } core->global_gain = 0x0024; core->exposure = 0x01fc; core->width = 640; core->height = 480; core->xtal = 27000000; /* Hz */ if (c->dev.platform_data) { struct mt9v011_platform_data *pdata = c->dev.platform_data; core->xtal = pdata->xtal; v4l2_dbg(1, debug, sd, "xtal set to %d.%03d MHz\n", core->xtal / 1000000, (core->xtal / 1000) % 1000); } v4l_info(c, "chip found @ 0x%02x (%s - chip version 0x%04x)\n", c->addr << 1, c->adapter->name, version); return 0; }
int32_t msm_sensor_v4l2_probe(struct msm_sensor_ctrl_t *s_ctrl, const struct msm_camera_sensor_info *info, struct v4l2_subdev *sdev, struct msm_sensor_ctrl *s) { int32_t rc = 0; rc = s_ctrl->func_tbl->sensor_probe(s_ctrl, info, s); if (rc < 0) return rc; s_ctrl->sensor_v4l2_subdev = sdev; v4l2_i2c_subdev_init(s_ctrl->sensor_v4l2_subdev, s_ctrl->sensor_i2c_client->client, s_ctrl->sensor_v4l2_subdev_ops); s_ctrl->sensor_v4l2_subdev->dev_priv = (void *) s_ctrl; return rc; }
static int cs53l32a_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct v4l2_subdev *sd; int i; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; if (!id) strlcpy(client->name, "cs53l32a", sizeof(client->name)); v4l_info(client, "chip found @ 0x%x (%s)\n", client->addr << 1, client->adapter->name); sd = kmalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (sd == NULL) return -ENOMEM; v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops); for (i = 1; i <= 7; i++) { u8 v = cs53l32a_read(sd, i); v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v); } /* Set cs53l32a internal register for Adaptec 2010/2410 setup */ cs53l32a_write(sd, 0x01, (u8) 0x21); cs53l32a_write(sd, 0x02, (u8) 0x29); cs53l32a_write(sd, 0x03, (u8) 0x30); cs53l32a_write(sd, 0x04, (u8) 0x00); cs53l32a_write(sd, 0x05, (u8) 0x00); cs53l32a_write(sd, 0x06, (u8) 0x00); cs53l32a_write(sd, 0x07, (u8) 0x00); /* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */ for (i = 1; i <= 7; i++) { u8 v = cs53l32a_read(sd, i); v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v); } return 0; }
static int adp1653_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct adp1653_flash *flash; int ret; flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL); if (flash == NULL) return -ENOMEM; if (client->dev.of_node) { ret = adp1653_of_init(client, flash, client->dev.of_node); if (ret) return ret; } else { if (!client->dev.platform_data) { dev_err(&client->dev, "Neither DT not platform data provided\n"); return -EINVAL; } flash->platform_data = client->dev.platform_data; } mutex_init(&flash->power_lock); v4l2_i2c_subdev_init(&flash->subdev, client, &adp1653_ops); flash->subdev.internal_ops = &adp1653_internal_ops; flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; ret = adp1653_init_controls(flash); if (ret) goto free_and_quit; ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL); if (ret < 0) goto free_and_quit; flash->subdev.entity.function = MEDIA_ENT_F_FLASH; return 0; free_and_quit: dev_err(&client->dev, "adp1653: failed to register device\n"); v4l2_ctrl_handler_free(&flash->ctrls); return ret; }
/* this function is called by i2c_probe */ static int tea6415c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct v4l2_subdev *sd; /* let's see whether this adapter can support what we need */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE)) return 0; v4l_info(client, "chip found @ 0x%x (%s)\n", client->addr << 1, client->adapter->name); sd = kmalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (sd == NULL) return -ENOMEM; v4l2_i2c_subdev_init(sd, client, &tea6415c_ops); return 0; }
/* * i2c_driver function */ static int gc0329_probe(struct i2c_client *client, const struct i2c_device_id *did) { struct gc0329_priv *priv; struct soc_camera_device *icd = client->dev.platform_data; struct soc_camera_link *icl; int ret; if (!icd) { dev_err(&client->dev, "Missing soc-camera data!\n"); return -EINVAL; } icl = to_soc_camera_link(icd); if (!icl) { dev_err(&client->dev, "Missing platform_data for driver\n"); return -EINVAL; } priv = kzalloc(sizeof(struct gc0329_priv), GFP_KERNEL); if (!priv) { dev_err(&client->dev, "Failed to allocate private data!\n"); return -ENOMEM; } v4l2_i2c_subdev_init(&priv->subdev, client, &gc0329_subdev_ops); icd->ops = &gc0329_ops; ret = gc0329_video_probe(icd, client); if (ret < 0) { goto err_probe; } #ifdef DEBUG_EN sysfs_create_group(&client->dev.kobj, &dev_attr_group); #endif return 0; err_probe: icd->ops = NULL; kfree(priv); return ret; }
static int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr, client->adapter->name); state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); if (state == NULL) { ret = -ENOMEM; goto err; } state->irq = client->irq; INIT_WORK(&state->work, adv7180_work); mutex_init(&state->mutex); state->autodetect = true; state->input = 0; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); ret = adv7180_init_controls(state); if (ret) goto err_unreg_subdev; ret = init_device(client, state); if (ret) goto err_free_ctrl; return 0; err_free_ctrl: adv7180_exit_controls(state); err_unreg_subdev: mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(state); err: printk(KERN_ERR KBUILD_MODNAME ": Failed to probe: %d\n", ret); return ret; }
/* * i2c_driver function */ static int ov9640_probe(struct i2c_client *client, const struct i2c_device_id *did) { struct ov9640_priv *priv; struct soc_camera_link *icl = soc_camera_i2c_to_link(client); int ret; if (!icl) { dev_err(&client->dev, "Missing platform_data for driver\n"); return -EINVAL; } priv = kzalloc(sizeof(struct ov9640_priv), GFP_KERNEL); if (!priv) { dev_err(&client->dev, "Failed to allocate memory for private data!\n"); return -ENOMEM; } v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops); v4l2_ctrl_handler_init(&priv->hdl, 2); v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0); v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0); priv->subdev.ctrl_handler = &priv->hdl; if (priv->hdl.error) { int err = priv->hdl.error; kfree(priv); return err; } ret = ov9640_video_probe(client); if (ret) { v4l2_ctrl_handler_free(&priv->hdl); kfree(priv); } return ret; }
/* * i2c_driver function */ static int ov9640_probe(struct i2c_client *client, const struct i2c_device_id *did) { struct ov9640_priv *priv; struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); int ret; if (!ssdd) { dev_err(&client->dev, "Missing platform_data for driver\n"); return -EINVAL; } priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops); v4l2_ctrl_handler_init(&priv->hdl, 2); v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0); v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0); priv->subdev.ctrl_handler = &priv->hdl; if (priv->hdl.error) return priv->hdl.error; priv->clk = v4l2_clk_get(&client->dev, "mclk"); if (IS_ERR(priv->clk)) { ret = PTR_ERR(priv->clk); goto eclkget; } ret = ov9640_video_probe(client); if (ret) { v4l2_clk_put(priv->clk); eclkget: v4l2_ctrl_handler_free(&priv->hdl); } return ret; }
static int ths7303_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct v4l2_subdev *sd; v4l2_std_id std_id = V4L2_STD_NTSC; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -ENODEV; v4l_info(client, "chip found @ 0x%x (%s)\n", client->addr << 1, client->adapter->name); sd = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (sd == NULL) return -ENOMEM; v4l2_i2c_subdev_init(sd, client, &ths7303_ops); return ths7303_setvalue(sd, std_id); }
static int as3645a_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct as3645a *flash; int ret; if (client->dev.platform_data == NULL) return -ENODEV; flash = kzalloc(sizeof(*flash), GFP_KERNEL); if (flash == NULL) return -ENOMEM; flash->pdata = client->dev.platform_data; v4l2_i2c_subdev_init(&flash->subdev, client, &as3645a_ops); flash->subdev.internal_ops = &as3645a_internal_ops; flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; ret = as3645a_init_controls(flash); if (ret < 0) goto done; ret = media_entity_init(&flash->subdev.entity, 0, NULL, 0); if (ret < 0) goto done; flash->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH; mutex_init(&flash->power_lock); flash->led_mode = V4L2_FLASH_LED_MODE_NONE; done: if (ret < 0) { v4l2_ctrl_handler_free(&flash->ctrls); kfree(flash); } return ret; }
static int hm5040_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct hm5040_device *dev; int ret; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { dev_err(&client->dev, "out of memory\n"); return -ENOMEM; } pr_info("%s\n", __func__); mutex_init(&dev->input_lock); dev->fmt_idx = 0; v4l2_i2c_subdev_init(&(dev->sd), client, &hm5040_ops); if (client->dev.platform_data) { ret = hm5040_s_config(&dev->sd, client->irq, client->dev.platform_data); if (ret) goto out_free; } dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; dev->pad.flags = MEDIA_PAD_FL_SOURCE; dev->format.code = V4L2_MBUS_FMT_SGRBG10_1X10; dev->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR; dev->vcm_driver = &hm5040_vcm_ops; ret = media_entity_init(&dev->sd.entity, 1, &dev->pad, 0); if (ret) hm5040_remove(client); return ret; out_free: v4l2_device_unregister_subdev(&dev->sd); kfree(dev); return ret; }
int32_t msm_actuator_create_subdevice(struct msm_actuator_ctrl_t *a_ctrl, struct i2c_board_info const *board_info, struct v4l2_subdev *sdev) { int32_t rc = 0; LINFO("%s called\n", __func__); /* Store the sub device in actuator structure */ a_ctrl->sdev = sdev; /* Assign name for sub device */ snprintf(sdev->name, sizeof(sdev->name), "%s", board_info->type); /* Initialize sub device */ v4l2_i2c_subdev_init(sdev, a_ctrl->i2c_client.client, a_ctrl->act_v4l2_subdev_ops); return rc; }
static int lm3646_subdev_init(struct lm3646_flash *flash) { struct i2c_client *client = to_i2c_client(flash->dev); int rval; v4l2_i2c_subdev_init(&flash->subdev_led, client, &lm3646_ops); flash->subdev_led.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; strcpy(flash->subdev_led.name, LM3646_NAME); rval = lm3646_init_controls(flash); if (rval) goto err_out; rval = media_entity_init(&flash->subdev_led.entity, 0, NULL, 0); if (rval < 0) goto err_out; flash->subdev_led.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH; return rval; err_out: v4l2_ctrl_handler_free(&flash->ctrls_led); return rval; }
static int32_t msm_ois_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; struct msm_ois_ctrl_t *act_ctrl_t = NULL; pr_err("Enter\n"); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("i2c_check_functionality failed\n"); goto probe_failure; } act_ctrl_t = (struct msm_ois_ctrl_t *)(id->driver_data); CDBG("client = %x\n", (unsigned int) client); act_ctrl_t->i2c_client.client = client; /* Set device type as I2C */ act_ctrl_t->act_device_type = MSM_CAMERA_I2C_DEVICE; act_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl; /* Assign name for sub device */ snprintf(act_ctrl_t->msm_sd.sd.name, sizeof(act_ctrl_t->msm_sd.sd.name), "%s", act_ctrl_t->i2c_driver->driver.name); /* Initialize sub device */ v4l2_i2c_subdev_init(&act_ctrl_t->msm_sd.sd, act_ctrl_t->i2c_client.client, act_ctrl_t->act_v4l2_subdev_ops); v4l2_set_subdevdata(&act_ctrl_t->msm_sd.sd, act_ctrl_t); act_ctrl_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops; act_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; media_entity_init(&act_ctrl_t->msm_sd.sd.entity, 0, NULL, 0); act_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV; act_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS; msm_sd_register(&act_ctrl_t->msm_sd); CDBG("succeeded\n"); pr_err("Exit\n"); probe_failure: return rc; }
static int cs5345_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct v4l2_subdev *sd; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%x (%s)\n", client->addr << 1, client->adapter->name); sd = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (sd == NULL) return -ENOMEM; v4l2_i2c_subdev_init(sd, client, &cs5345_ops); cs5345_write(sd, 0x02, 0x00); cs5345_write(sd, 0x04, 0x01); cs5345_write(sd, 0x09, 0x01); return 0; }
/* * s5k6aafx_probe * Fetching platform data is being done with s_config subdev call. * In probe routine, we just register subdev device */ static int s5k6aafx_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct s5k6aafx_state *state; struct v4l2_subdev *sd; FUNC_ENTR(); state = kzalloc(sizeof(struct s5k6aafx_state), GFP_KERNEL); if (state == NULL) return -ENOMEM; sd = &state->sd; strcpy(sd->name, S5K6AAFX_DRIVER_NAME); /* Registering subdev */ v4l2_i2c_subdev_init(sd, client, &s5k6aafx_ops); dev_info(&client->dev, "s5k6aafx has been probed\n"); return 0; }
static int adp1653_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct adp1653_flash *flash; int ret; /* we couldn't work without platform data */ if (client->dev.platform_data == NULL) return -ENODEV; flash = kzalloc(sizeof(*flash), GFP_KERNEL); if (flash == NULL) return -ENOMEM; flash->platform_data = client->dev.platform_data; mutex_init(&flash->power_lock); v4l2_i2c_subdev_init(&flash->subdev, client, &adp1653_ops); flash->subdev.internal_ops = &adp1653_internal_ops; flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; ret = adp1653_init_controls(flash); if (ret) goto free_and_quit; ret = media_entity_init(&flash->subdev.entity, 0, NULL, 0); if (ret < 0) goto free_and_quit; flash->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH; return 0; free_and_quit: v4l2_ctrl_handler_free(&flash->ctrls); kfree(flash); return ret; }
/* * sr130pc10_probe * Fetching platform data is being done with s_config subdev call. * In probe routine, we just register subdev device */ static int sr130pc10_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct sr130pc10_state *state = NULL; struct v4l2_subdev *sd = NULL; cam_dbg("E\n"); state = kzalloc(sizeof(struct sr130pc10_state), GFP_KERNEL); if (state == NULL) return -ENOMEM; sd = &state->sd; strcpy(sd->name, SR130PC10_DRIVER_NAME); /* Registering subdev */ v4l2_i2c_subdev_init(sd, client, &sr130pc10_ops); cam_dbg("probed!!\n"); return 0; }
static int lm3560_subdev_init(struct lm3560_flash *flash, enum lm3560_led_id led_no, char *led_name) { struct i2c_client *client = to_i2c_client(flash->dev); int rval; v4l2_i2c_subdev_init(&flash->subdev_led[led_no], client, &lm3560_ops); flash->subdev_led[led_no].flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; strcpy(flash->subdev_led[led_no].name, led_name); rval = lm3560_init_controls(flash, led_no); if (rval) goto err_out; rval = media_entity_init(&flash->subdev_led[led_no].entity, 0, NULL, 0); if (rval < 0) goto err_out; flash->subdev_led[led_no].entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH; return rval; err_out: v4l2_ctrl_handler_free(&flash->ctrls_led[led_no]); return rval; }
static int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr << 1, client->adapter->name); state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); if (state == NULL) return -ENOMEM; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, ADV7180_INPUT_CONTROL_PAL_BG_NTSC_J_SECAM); if (ret > 0) ret = i2c_smbus_write_byte_data(client, ADV7180_AUTODETECT_ENABLE_REG, ADV7180_AUTODETECT_DEFAULT); if (ret < 0) { printk(KERN_ERR DRIVER_NAME ": Failed to communicate to chip: %d\n", ret); return ret; } return 0; }
int sensor_3h7_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct fimc_is_core *core; struct v4l2_subdev *subdev_module; struct fimc_is_module_enum *module; struct fimc_is_device_sensor *device; struct sensor_open_extended *ext; BUG_ON(!fimc_is_dev); core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev); if (!core) { err("core device is not yet probed"); return -EPROBE_DEFER; } device = &core->sensor[SENSOR_S5K3H7_INSTANCE]; subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (!subdev_module) { err("subdev_module is NULL"); ret = -ENOMEM; goto p_err; } module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)]; atomic_inc(&core->resourcemgr.rsccount_module); module->id = SENSOR_NAME_S5K3H7; module->subdev = subdev_module; module->device = SENSOR_S5K3H7_INSTANCE; module->client = client; module->active_width = 3248; module->active_height = 2438; module->pixel_width = module->active_width + 16; module->pixel_height = module->active_height + 10; module->max_framerate = 30; module->position = SENSOR_POSITION_REAR; module->setfile_name = "setfile_3h7.bin"; module->cfgs = ARRAY_SIZE(config_3h7); module->cfg = config_3h7; module->ops = NULL; module->private_data = NULL; ext = &module->ext; ext->mipi_lane_num = 4; ext->I2CSclk = I2C_L0; ext->sensor_con.product_name = 0; ext->sensor_con.peri_type = SE_I2C; ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0; ext->sensor_con.peri_setting.i2c.slave_address = 0x20; ext->sensor_con.peri_setting.i2c.speed = 400000; ext->actuator_con.product_name = ACTUATOR_NAME_AK7343; ext->actuator_con.peri_type = SE_I2C; ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0; ext->flash_con.product_name = FLADRV_NAME_KTD267; ext->flash_con.peri_type = SE_GPIO; ext->flash_con.peri_setting.gpio.first_gpio_port_no = 17; ext->flash_con.peri_setting.gpio.second_gpio_port_no = 16; ext->from_con.product_name = FROMDRV_NAME_NOTHING; ext->companion_con.product_name = COMPANION_NAME_NOTHING; #ifdef DEFAULT_S5K3H7_DRIVING v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops); #else v4l2_subdev_init(subdev_module, &subdev_ops); #endif v4l2_set_subdevdata(subdev_module, module); v4l2_set_subdev_hostdata(subdev_module, device); snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id); p_err: info("%s(%d)\n", __func__, ret); return ret; }
static __devinit int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr << 1, client->adapter->name); state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); if (state == NULL) { ret = -ENOMEM; goto err; } state->irq = client->irq; INIT_WORK(&state->work, adv7180_work); mutex_init(&state->mutex); state->autodetect = true; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); /* */ /* */ ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_AUTODETECT_ENABLE_REG, ADV7180_AUTODETECT_DEFAULT); if (ret < 0) goto err_unreg_subdev; /* */ ret = i2c_smbus_write_byte_data(client, ADV7180_EXTENDED_OUTPUT_CONTROL_REG, ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS); if (ret < 0) goto err_unreg_subdev; /* */ __adv7180_status(client, NULL, &state->curr_norm); /* */ if (state->irq > 0) { ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME, state); if (ret) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, ADV7180_ADI_CTRL_IRQ_SPACE); if (ret < 0) goto err_unreg_subdev; /* */ ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI, ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0); if (ret < 0) goto err_unreg_subdev; /* */ ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI, ADV7180_IRQ3_AD_CHANGE); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0); if (ret < 0) goto err_unreg_subdev; } return 0; err_unreg_subdev: mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(state); err: printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret); return ret; }
int sensor_4h5_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct fimc_is_core *core; struct v4l2_subdev *subdev_module; struct fimc_is_module_enum *module; struct fimc_is_device_sensor *device; struct sensor_open_extended *ext; BUG_ON(!fimc_is_dev); core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev); if (!core) { err("core device is not yet probed"); return -EPROBE_DEFER; } device = &core->sensor[SENSOR_S5K4H5_INSTANCE]; subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (!subdev_module) { err("subdev_module is NULL"); ret = -ENOMEM; goto p_err; } module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)]; atomic_inc(&core->resourcemgr.rsccount_module); clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state); module->sensor_id = SENSOR_NAME_S5K4H5; module->subdev = subdev_module; module->device = SENSOR_S5K4H5_INSTANCE; module->ops = NULL; module->client = client; module->active_width = 3264; module->active_height = 2448; module->pixel_width = module->active_width + 16; module->pixel_height = module->active_height + 10; module->max_framerate = 120; module->position = SENSOR_POSITION_REAR; module->mode = CSI_MODE_CH0_ONLY; module->lanes = CSI_DATA_LANES_4; module->bitwidth = 10; module->sensor_maker = "SLSI"; module->sensor_name = "S5K4H5"; module->setfile_name = "setfile_4h5.bin"; module->cfgs = ARRAY_SIZE(config_4h5); module->cfg = config_4h5; module->ops = NULL; module->private_data = NULL; ext = &module->ext; ext->mipi_lane_num = module->lanes; ext->I2CSclk = I2C_L0; ext->sensor_con.product_name = 0; ext->sensor_con.peri_type = SE_I2C; ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0; ext->sensor_con.peri_setting.i2c.slave_address = 0x6E; ext->sensor_con.peri_setting.i2c.speed = 400000; ext->actuator_con.product_name = ACTUATOR_NAME_DW9804; ext->actuator_con.peri_type = SE_I2C; ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0; ext->flash_con.product_name = FLADRV_NAME_RT5033; ext->flash_con.peri_type = SE_GPIO; ext->flash_con.peri_setting.gpio.first_gpio_port_no = 8; ext->flash_con.peri_setting.gpio.second_gpio_port_no = 6; /* ext->from_con.product_name = FROMDRV_NAME_W25Q80BW; */ ext->from_con.product_name = FROMDRV_NAME_NOTHING; ext->mclk = 0; ext->mipi_lane_num = 0; ext->mipi_speed = 0; ext->fast_open_sensor = 0; ext->self_calibration_mode = 0; ext->I2CSclk = I2C_L0; ext->preprocessor_con.product_name = PREPROCESSOR_NAME_NOTHING; if (client) { v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops); } else { v4l2_subdev_init(subdev_module, &subdev_ops); } v4l2_set_subdevdata(subdev_module, module); v4l2_set_subdev_hostdata(subdev_module, device); snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id); p_err: probe_info("%s(%d)\n", __func__, ret); return ret; }
/* * db8131m_probe * Fetching platform data is being done with s_config subdev call. * In probe routine, we just register subdev device */ static int db8131m_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct db8131m_state *state = NULL; struct v4l2_subdev *sd = NULL; struct db8131m_platform_data *pdata = NULL; cam_dbg("E\n"); state = kzalloc(sizeof(struct db8131m_state), GFP_KERNEL); if (state == NULL) return -ENOMEM; sd = &state->sd; strcpy(sd->name, DB8131M_DRIVER_NAME); state->initialized = 0; state->req_fps = state->set_fps = 8; state->sensor_mode = SENSOR_CAMERA; pdata = client->dev.platform_data; if (!pdata) { cam_err("no platform data\n"); return -ENODEV; } /* Registering subdev */ v4l2_i2c_subdev_init(sd, client, &db8131m_ops); /* * Assign default format and resolution * Use configured default information in platform data * or without them, use default information in driver */ if (!(pdata->default_width && pdata->default_height)) { state->preview_frmsizes.width = DEFAULT_PREVIEW_WIDTH; state->preview_frmsizes.height = DEFAULT_PREVIEW_HEIGHT; } else { state->preview_frmsizes.width = pdata->default_width; state->preview_frmsizes.height = pdata->default_height; } state->capture_frmsizes.width = DEFAULT_CAPTURE_WIDTH; state->capture_frmsizes.height = DEFAULT_CAPTURE_HEIGHT; cam_dbg("preview_width: %d , preview_height: %d, " "capture_width: %d, capture_height: %d", state->preview_frmsizes.width, state->preview_frmsizes.height, state->capture_frmsizes.width, state->capture_frmsizes.height); state->req_fmt.width = state->preview_frmsizes.width; state->req_fmt.height = state->preview_frmsizes.height; if (!pdata->pixelformat) state->req_fmt.pixelformat = VT_DEFAULT_FMT; else state->req_fmt.pixelformat = pdata->pixelformat; cam_dbg("probed!!\n"); return 0; }
int sensor_3l2_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct fimc_is_core *core; struct v4l2_subdev *subdev_module; struct fimc_is_module_enum *module; struct fimc_is_device_sensor *device; struct sensor_open_extended *ext; BUG_ON(!fimc_is_dev); core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev); if (!core) { err("core device is not yet probed"); return -EPROBE_DEFER; } device = &core->sensor[SENSOR_S5K3L2_INSTANCE]; subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (!subdev_module) { err("subdev_module is NULL"); ret = -ENOMEM; goto p_err; } module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)]; atomic_inc(&core->resourcemgr.rsccount_module); module->id = SENSOR_NAME_S5K3L2; module->subdev = subdev_module; module->device = SENSOR_S5K3L2_INSTANCE; module->client = client; module->active_width = 4128; module->active_height = 3096; module->margin_left = 8; module->margin_right = 8; module->margin_top = 6; module->margin_bottom = 4; module->pixel_width = module->active_width + 16; module->pixel_height = module->active_height + 10; module->max_framerate = 120; module->position = SENSOR_POSITION_REAR; module->mode = CSI_MODE_CH0_ONLY; module->lanes = CSI_DATA_LANES_4; module->sensor_maker = "SLSI"; module->sensor_name = "S5K3L2"; module->setfile_name = "setfile_3l2.bin"; module->cfgs = ARRAY_SIZE(config_3l2); module->cfg = config_3l2; module->ops = NULL; module->private_data = NULL; #ifdef CONFIG_OF module->power_setpin = sensor_3l2_power_setpin; #endif ext = &module->ext; ext->mipi_lane_num = module->lanes; ext->I2CSclk = I2C_L0; ext->sensor_con.product_name = SENSOR_NAME_S5K3L2; ext->sensor_con.peri_type = SE_I2C; ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0; ext->sensor_con.peri_setting.i2c.slave_address = 0x5A; ext->sensor_con.peri_setting.i2c.speed = 400000; ext->actuator_con.product_name = ACTUATOR_NAME_DW9804; ext->actuator_con.peri_type = SE_I2C; ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1; ext->actuator_con.peri_setting.i2c.slave_address = 0x18; ext->actuator_con.peri_setting.i2c.speed = 400000; /* Flash is not working now, it will define agian after solving kernel panic*/ ext->flash_con.product_name = FLADRV_NAME_RT5033; ext->flash_con.peri_type = SE_GPIO; ext->flash_con.peri_setting.gpio.first_gpio_port_no = 1; ext->flash_con.peri_setting.gpio.second_gpio_port_no = 2; ext->from_con.product_name = FROMDRV_NAME_NOTHING; ext->companion_con.product_name = COMPANION_NAME_NOTHING; if (client) v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops); else v4l2_subdev_init(subdev_module, &subdev_ops); v4l2_set_subdevdata(subdev_module, module); v4l2_set_subdev_hostdata(subdev_module, device); snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id); p_err: info("%s(%d)\n", __func__, ret); return ret; }
static int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr, client->adapter->name); state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); if (state == NULL) return -ENOMEM; state->client = client; state->field = V4L2_FIELD_INTERLACED; state->chip_info = (struct adv7180_chip_info *)id->driver_data; if (state->chip_info->flags & ADV7180_FLAG_MIPI_CSI2) { state->csi_client = i2c_new_dummy(client->adapter, ADV7180_DEFAULT_CSI_I2C_ADDR); if (!state->csi_client) return -ENOMEM; } if (state->chip_info->flags & ADV7180_FLAG_I2P) { state->vpp_client = i2c_new_dummy(client->adapter, ADV7180_DEFAULT_VPP_I2C_ADDR); if (!state->vpp_client) { ret = -ENOMEM; goto err_unregister_csi_client; } } state->irq = client->irq; mutex_init(&state->mutex); state->autodetect = true; if (state->chip_info->flags & ADV7180_FLAG_RESET_POWERED) state->powered = true; else state->powered = false; state->input = 0; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); sd->flags = V4L2_SUBDEV_FL_HAS_DEVNODE; ret = adv7180_init_controls(state); if (ret) goto err_unregister_vpp_client; state->pad.flags = MEDIA_PAD_FL_SOURCE; sd->entity.flags |= MEDIA_ENT_F_ATV_DECODER; ret = media_entity_pads_init(&sd->entity, 1, &state->pad); if (ret) goto err_free_ctrl; ret = init_device(state); if (ret) goto err_media_entity_cleanup; if (state->irq) { ret = request_threaded_irq(client->irq, NULL, adv7180_irq, IRQF_ONESHOT | IRQF_TRIGGER_FALLING, KBUILD_MODNAME, state); if (ret) goto err_media_entity_cleanup; } ret = v4l2_async_register_subdev(sd); if (ret) goto err_free_irq; return 0; err_free_irq: if (state->irq > 0) free_irq(client->irq, state); err_media_entity_cleanup: media_entity_cleanup(&sd->entity); err_free_ctrl: adv7180_exit_controls(state); err_unregister_vpp_client: if (state->chip_info->flags & ADV7180_FLAG_I2P) i2c_unregister_device(state->vpp_client); err_unregister_csi_client: if (state->chip_info->flags & ADV7180_FLAG_MIPI_CSI2) i2c_unregister_device(state->csi_client); mutex_destroy(&state->mutex); return ret; }
int sensor_4e5_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct fimc_is_core *core; struct v4l2_subdev *subdev_module; struct fimc_is_module_enum *module; struct fimc_is_device_sensor *device; struct sensor_open_extended *ext; BUG_ON(!fimc_is_dev); core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev); if (!core) { err("core device is not yet probed"); return -EPROBE_DEFER; } device = &core->sensor[SENSOR_S5K4E5_INSTANCE]; subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL); if (!subdev_module) { err("subdev_module is NULL"); ret = -ENOMEM; goto p_err; } module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)]; atomic_inc(&core->resourcemgr.rsccount_module); module->id = SENSOR_NAME_S5K4E5; module->subdev = subdev_module; module->device = SENSOR_S5K4E5_INSTANCE; module->client = client; module->pixel_width = 2560 + 16; module->pixel_height = 1920 + 10; module->active_width = 2560; module->active_height = 1920; module->max_framerate = 30; module->position = SENSOR_POSITION_REAR; module->mode = CSI_MODE_CH0_ONLY; module->lanes = CSI_DATA_LANES_4; module->sensor_maker = "SLSI"; module->sensor_name = "S5K4E5"; module->setfile_name = "setfile_4e5.bin"; module->cfgs = 0; module->cfg = NULL; module->ops = NULL; module->private_data = NULL; ext = &module->ext; ext->mipi_lane_num = module->lanes; ext->I2CSclk = I2C_L0; ext->sensor_con.product_name = 0; ext->actuator_con.product_name = ACTUATOR_NAME_DWXXXX; ext->actuator_con.peri_type = SE_I2C; ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1; ext->flash_con.product_name = FLADRV_NAME_KTD267; ext->flash_con.peri_type = SE_GPIO; ext->flash_con.peri_setting.gpio.first_gpio_port_no = 17; ext->flash_con.peri_setting.gpio.second_gpio_port_no = 16; ext->from_con.product_name = FROMDRV_NAME_NOTHING; ext->companion_con.product_name = COMPANION_NAME_NOTHING; if (client) v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops); else v4l2_subdev_init(subdev_module, &subdev_ops); v4l2_set_subdevdata(subdev_module, module); v4l2_set_subdev_hostdata(subdev_module, device); snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id); p_err: info("%s(%d)\n", __func__, ret); return ret; }