static int adp1653_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct adp1653_flash *flash = &adp1653;
int rval;
if (i2c_get_clientdata(client))
return -EBUSY;
flash->platform_data = client->dev.platform_data;
if (flash->platform_data == NULL)
return -ENODEV;
flash->v4l2_int_device = &adp1653_int_device;
flash->i2c_client = client;
i2c_set_clientdata(client, flash);
rval = v4l2_int_device_register(flash->v4l2_int_device);
if (rval)
i2c_set_clientdata(client, NULL);
return rval;
}
static int rt8515_probe(struct platform_device *pdev)
{
struct rt8515_platform_data *pdata = pdev->dev.platform_data;
if (!pdata) {
printk(KERN_ERR "rt8515 platform data not supplied\n");
return -ENOENT;
}
rt8515_dev.pdata = pdata;
if (v4l2_int_device_register(&rt8515_int_device)) {
printk(KERN_ERR "Could not register "
" rt8515 as v4l2_int_device\n");
return -ENOENT;
}
printk(KERN_ERR "rt8515_probe success\n");
return pdata->init();
}
static int omap24xxcam_probe(struct platform_device *pdev)
{
struct omap24xxcam_device *cam;
struct resource *mem;
int irq;
cam = kzalloc(sizeof(*cam), GFP_KERNEL);
if (!cam) {
dev_err(&pdev->dev, "could not allocate memory\n");
goto err;
}
platform_set_drvdata(pdev, cam);
cam->dev = &pdev->dev;
if (v4l2_device_register(&pdev->dev, &cam->v4l2_dev)) {
dev_err(&pdev->dev, "v4l2_device_register failed\n");
goto err;
}
/*
* Impose a lower limit on the amount of memory allocated for
* capture. We require at least enough memory to double-buffer
* QVGA (300KB).
*/
if (capture_mem < 320 * 240 * 2 * 2)
capture_mem = 320 * 240 * 2 * 2;
cam->capture_mem = capture_mem;
/* request the mem region for the camera registers */
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(cam->dev, "no mem resource?\n");
goto err;
}
if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
dev_err(cam->dev,
"cannot reserve camera register I/O region\n");
goto err;
}
cam->mmio_base_phys = mem->start;
cam->mmio_size = resource_size(mem);
/* map the region */
cam->mmio_base = ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
if (!cam->mmio_base) {
dev_err(cam->dev, "cannot map camera register I/O region\n");
goto err;
}
irq = platform_get_irq(pdev, 0);
if (irq <= 0) {
dev_err(cam->dev, "no irq for camera?\n");
goto err;
}
/* install the interrupt service routine */
if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
dev_err(cam->dev,
"could not install interrupt service routine\n");
goto err;
}
cam->irq = irq;
if (omap24xxcam_clock_get(cam))
goto err;
INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
mutex_init(&cam->mutex);
spin_lock_init(&cam->core_enable_disable_lock);
omap24xxcam_sgdma_init(&cam->sgdma,
cam->mmio_base + CAMDMA_REG_OFFSET,
omap24xxcam_stalled_dma_reset,
(unsigned long)cam);
omap24xxcam.priv = cam;
if (v4l2_int_device_register(&omap24xxcam))
goto err;
return 0;
err:
omap24xxcam_remove(pdev);
return -ENODEV;
}
static int adv7610_video_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct sensor *sens = &adv7610_data;
struct device *dev = &client->dev;
int ret;
dev_dbg(dev, "%s\n", __func__);
init_waitqueue_head(&i2c_wait);
/* Set initial values for the sensor struct. */
memset(sens, 0, sizeof(adv7610_data));
sens->sen.streamcap.timeperframe.denominator = 0;
sens->sen.streamcap.timeperframe.numerator = 0;
sens->sen.pix.width = 0;
sens->sen.pix.height = 0;
#ifdef USE_16BIT
sens->sen.pix.pixelformat = V4L2_PIX_FMT_YUYV;
#else
sens->sen.pix.pixelformat = V4L2_PIX_FMT_UYVY; /* YUV422 */
#endif
pr_err("******** pixelformat=%d ************\n",sens->sen.pix.pixelformat);
sens->sen.on = true;
/* request reset pin */
rst_gpio = of_get_named_gpio(dev->of_node, "reset-gpio", 0);
if (!gpio_is_valid(rst_gpio)) {
dev_warn(dev, "no sensor reset pin available");
return -EINVAL;
}
ret = devm_gpio_request_one(dev, rst_gpio, GPIOF_OUT_INIT_HIGH,
"adv7610_reset");
if (ret < 0)
return ret;
ret = of_property_read_u32(dev->of_node, "csi_id",
&(sens->sen.csi));
if (ret) {
dev_err(dev, "csi_id invalid\n");
return ret;
}
dev_dbg(dev, "IPU1_CSI%d\n", sens->sen.csi);
dev_dbg(dev, "type is %d (expect %d)\n",
adv7610_int_device.type, v4l2_int_type_slave);
dev_dbg(dev, "num ioctls is %d\n",
adv7610_int_device.u.slave->num_ioctls);
//Attempt to connect to the device
ret = adv7610_hw_init(client);
if(ret == -ENODEV)
return ret;
/* This function attaches this structure to the /dev/video<n> device */
adv7610_int_device.priv = sens;
ret = v4l2_int_device_register(&adv7610_int_device);
return ret;
}
