/*
|
*************************************************************************
|
* Rockchip driver for CIF ISP 1.0
|
* (Based on Intel driver for sofiaxxx)
|
*
|
* Copyright (C) 2015 Intel Mobile Communications GmbH
|
* Copyright (C) 2016 Fuzhou Rockchip Electronics Co., Ltd.
|
*
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*************************************************************************
|
*/
|
|
#include <linux/kernel.h>
|
#include <linux/i2c.h>
|
#include <media/v4l2-subdev.h>
|
#include <media/v4l2-common.h>
|
#include <media/v4l2-ioctl.h>
|
#include "cif_isp10.h"
|
#include <linux/platform_data/rk_isp10_platform.h>
|
#include <media/v4l2-controls_rockchip.h>
|
#include <linux/slab.h>
|
/* ===================== */
|
/* Image Source */
|
/* ===================== */
|
void *cif_isp10_img_src_v4l2_i2c_subdev_to_img_src(
|
struct device *dev,
|
struct pltfrm_soc_cfg *soc_cfg)
|
{
|
int ret = 0;
|
struct i2c_client *client;
|
struct v4l2_subdev *subdev;
|
|
client = i2c_verify_client(dev);
|
if (IS_ERR_OR_NULL(client)) {
|
cif_isp10_pltfrm_pr_err(dev,
|
"not an I2C device\n");
|
ret = -EINVAL;
|
goto err;
|
}
|
|
subdev = i2c_get_clientdata(client);
|
if (IS_ERR_OR_NULL(subdev))
|
return subdev;
|
|
ret = v4l2_subdev_call(subdev,
|
core,
|
ioctl,
|
PLTFRM_CIFCAM_ATTACH,
|
(void *)soc_cfg);
|
if (ret != 0)
|
goto err;
|
|
return (void *)subdev;
|
err:
|
cif_isp10_pltfrm_pr_err(NULL, "failed with error %d\n", ret);
|
return ERR_PTR(ret);
|
}
|
|
static enum cif_isp10_pix_fmt img_src_v4l2_subdev_pix_fmt2cif_isp10_pix_fmt(
|
int img_src_pix_fmt)
|
{
|
switch (img_src_pix_fmt) {
|
case MEDIA_BUS_FMT_Y8_1X8:
|
return CIF_YUV400;
|
case MEDIA_BUS_FMT_Y10_1X10:
|
return CIF_Y10;
|
case MEDIA_BUS_FMT_Y12_1X12:
|
return CIF_Y12;
|
case MEDIA_BUS_FMT_YUYV8_1_5X8:
|
case MEDIA_BUS_FMT_YUYV8_2X8:
|
case MEDIA_BUS_FMT_YUYV10_2X10:
|
case MEDIA_BUS_FMT_YUYV8_1X16:
|
case MEDIA_BUS_FMT_YUYV10_1X20:
|
return CIF_YUV422I;
|
case MEDIA_BUS_FMT_YVYU8_1_5X8:
|
case MEDIA_BUS_FMT_YVYU8_2X8:
|
case MEDIA_BUS_FMT_YVYU10_2X10:
|
case MEDIA_BUS_FMT_YVYU8_1X16:
|
case MEDIA_BUS_FMT_YVYU10_1X20:
|
return CIF_YVU422I;
|
case MEDIA_BUS_FMT_UYVY8_1_5X8:
|
case MEDIA_BUS_FMT_UYVY8_2X8:
|
case MEDIA_BUS_FMT_UYVY8_1X16:
|
return CIF_UYV422I;
|
case MEDIA_BUS_FMT_RGB565_2X8_BE:
|
case MEDIA_BUS_FMT_RGB565_2X8_LE:
|
return CIF_RGB565;
|
case MEDIA_BUS_FMT_RGB666_1X18:
|
return CIF_RGB666;
|
case MEDIA_BUS_FMT_RGB888_1X24:
|
case MEDIA_BUS_FMT_RGB888_2X12_BE:
|
case MEDIA_BUS_FMT_RGB888_2X12_LE:
|
return CIF_RGB888;
|
case MEDIA_BUS_FMT_SBGGR8_1X8:
|
return CIF_BAYER_SBGGR8;
|
case MEDIA_BUS_FMT_SGBRG8_1X8:
|
return CIF_BAYER_SGBRG8;
|
case MEDIA_BUS_FMT_SGRBG8_1X8:
|
return CIF_BAYER_SGRBG8;
|
case MEDIA_BUS_FMT_SRGGB8_1X8:
|
return CIF_BAYER_SRGGB8;
|
case MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8:
|
case MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8:
|
case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE:
|
case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE:
|
case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE:
|
case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE:
|
case MEDIA_BUS_FMT_SBGGR10_1X10:
|
return CIF_BAYER_SBGGR10;
|
case MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8:
|
case MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8:
|
case MEDIA_BUS_FMT_SGBRG10_1X10:
|
return CIF_BAYER_SGBRG10;
|
case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8:
|
case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8:
|
case MEDIA_BUS_FMT_SGRBG10_1X10:
|
return CIF_BAYER_SGRBG10;
|
case MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8:
|
case MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8:
|
case MEDIA_BUS_FMT_SRGGB10_1X10:
|
return CIF_BAYER_SRGGB10;
|
case MEDIA_BUS_FMT_SBGGR12_1X12:
|
return CIF_BAYER_SBGGR12;
|
case MEDIA_BUS_FMT_SGBRG12_1X12:
|
return CIF_BAYER_SGBRG12;
|
case MEDIA_BUS_FMT_SGRBG12_1X12:
|
return CIF_BAYER_SGRBG12;
|
case MEDIA_BUS_FMT_SRGGB12_1X12:
|
return CIF_BAYER_SRGGB12;
|
case MEDIA_BUS_FMT_JPEG_1X8:
|
return CIF_JPEG;
|
default:
|
return CIF_UNKNOWN_FORMAT;
|
}
|
}
|
|
static int cif_isp10_pix_fmt2img_src_v4l2_subdev_pix_fmt(
|
enum cif_isp10_pix_fmt cif_isp10_pix_fmt)
|
{
|
switch (cif_isp10_pix_fmt) {
|
case CIF_Y10:
|
return MEDIA_BUS_FMT_Y10_1X10;
|
case CIF_Y12:
|
return MEDIA_BUS_FMT_Y12_1X12;
|
case CIF_YUV400:
|
return MEDIA_BUS_FMT_Y8_1X8;
|
case CIF_YUV422I:
|
return MEDIA_BUS_FMT_YUYV8_2X8;
|
case CIF_YVU422I:
|
return MEDIA_BUS_FMT_YVYU8_2X8;
|
case CIF_UYV422I:
|
return MEDIA_BUS_FMT_UYVY8_2X8;
|
case CIF_RGB565:
|
return MEDIA_BUS_FMT_RGB565_2X8_LE;
|
case CIF_RGB666:
|
return MEDIA_BUS_FMT_RGB666_1X18;
|
case CIF_RGB888:
|
return MEDIA_BUS_FMT_RGB888_1X24;
|
case CIF_BAYER_SBGGR8:
|
return MEDIA_BUS_FMT_SBGGR8_1X8;
|
case CIF_BAYER_SGBRG8:
|
return MEDIA_BUS_FMT_SGBRG8_1X8;
|
case CIF_BAYER_SGRBG8:
|
return MEDIA_BUS_FMT_SGRBG8_1X8;
|
case CIF_BAYER_SRGGB8:
|
return MEDIA_BUS_FMT_SRGGB8_1X8;
|
case CIF_BAYER_SBGGR10:
|
return MEDIA_BUS_FMT_SBGGR10_1X10;
|
case CIF_BAYER_SGBRG10:
|
return MEDIA_BUS_FMT_SGBRG10_1X10;
|
case CIF_BAYER_SGRBG10:
|
return MEDIA_BUS_FMT_SGRBG10_1X10;
|
case CIF_BAYER_SRGGB10:
|
return MEDIA_BUS_FMT_SRGGB10_1X10;
|
case CIF_BAYER_SBGGR12:
|
return MEDIA_BUS_FMT_SBGGR12_1X12;
|
case CIF_BAYER_SGBRG12:
|
return MEDIA_BUS_FMT_SGBRG12_1X12;
|
case CIF_BAYER_SGRBG12:
|
return MEDIA_BUS_FMT_SGRBG12_1X12;
|
case CIF_BAYER_SRGGB12:
|
return MEDIA_BUS_FMT_SRGGB12_1X12;
|
case CIF_JPEG:
|
return MEDIA_BUS_FMT_JPEG_1X8;
|
default:
|
return -EINVAL;
|
}
|
}
|
|
static int cif_isp10_v4l2_cid2v4l2_cid(u32 cif_isp10_cid)
|
{
|
switch (cif_isp10_cid) {
|
case CIF_ISP10_CID_FLASH_MODE:
|
return V4L2_CID_FLASH_LED_MODE;
|
case CIF_ISP10_CID_AUTO_GAIN:
|
return V4L2_CID_AUTOGAIN;
|
case CIF_ISP10_CID_AUTO_EXPOSURE:
|
return V4L2_EXPOSURE_AUTO;
|
case CIF_ISP10_CID_AUTO_WHITE_BALANCE:
|
return V4L2_CID_AUTO_WHITE_BALANCE;
|
case CIF_ISP10_CID_BLACK_LEVEL:
|
return V4L2_CID_BLACK_LEVEL;
|
case CIF_ISP10_CID_WB_TEMPERATURE:
|
return V4L2_CID_WHITE_BALANCE_TEMPERATURE;
|
case CIF_ISP10_CID_EXPOSURE_TIME:
|
return V4L2_CID_EXPOSURE;
|
case CIF_ISP10_CID_ANALOG_GAIN:
|
return V4L2_CID_GAIN;
|
case CIF_ISP10_CID_FOCUS_ABSOLUTE:
|
return V4L2_CID_FOCUS_ABSOLUTE;
|
case CIF_ISP10_CID_AUTO_N_PRESET_WHITE_BALANCE:
|
return V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE;
|
case CIF_ISP10_CID_SCENE_MODE:
|
return V4L2_CID_SCENE_MODE;
|
case CIF_ISP10_CID_ISO_SENSITIVITY:
|
return V4L2_CID_ISO_SENSITIVITY;
|
case CIF_ISP10_CID_AUTO_FPS:
|
return RK_V4L2_CID_AUTO_FPS;
|
case CIF_ISP10_CID_VBLANKING:
|
return RK_V4L2_CID_VBLANKING;
|
case CIF_ISP10_CID_HFLIP:
|
return V4L2_CID_HFLIP;
|
case CIF_ISP10_CID_VFLIP:
|
return V4L2_CID_VFLIP;
|
case CIF_ISP10_CID_MIN_BUFFER_FOR_CAPTURE:
|
return V4L2_CID_MIN_BUFFERS_FOR_CAPTURE;
|
case CIF_ISP10_CID_TEST_PATTERN:
|
return V4L2_CID_TEST_PATTERN;
|
default:
|
cif_isp10_pltfrm_pr_err(NULL,
|
"unknown/unsupported CIF ISP20 ID %d\n",
|
cif_isp10_cid);
|
break;
|
}
|
return -EINVAL;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_streaming(
|
void *img_src,
|
bool enable)
|
{
|
struct v4l2_subdev *subdev = img_src;
|
|
if (enable)
|
return v4l2_subdev_call(subdev, video, s_stream, 1);
|
else
|
return v4l2_subdev_call(subdev, video, s_stream, 0);
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_power(
|
void *img_src,
|
bool on)
|
{
|
struct v4l2_subdev *subdev = img_src;
|
|
if (on)
|
return v4l2_subdev_call(subdev, core, s_power, 1);
|
else
|
return v4l2_subdev_call(subdev, core, s_power, 0);
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_enum_strm_fmts(
|
void *img_src,
|
u32 index,
|
struct cif_isp10_strm_fmt_desc *strm_fmt_desc)
|
{
|
int ret;
|
struct v4l2_subdev *subdev = img_src;
|
struct v4l2_subdev_frame_interval_enum fie = {.index = index};
|
struct pltfrm_cam_defrect defrect;
|
v4l2_std_id std;
|
|
ret = v4l2_subdev_call(subdev, video, querystd, &std);
|
if (!IS_ERR_VALUE(ret))
|
strm_fmt_desc->std_id = std;
|
else
|
strm_fmt_desc->std_id = 0;
|
|
ret = v4l2_subdev_call(subdev, pad,
|
enum_frame_interval, NULL, &fie);
|
if (!IS_ERR_VALUE(ret)) {
|
strm_fmt_desc->discrete_intrvl = true;
|
strm_fmt_desc->min_intrvl.numerator =
|
fie.interval.numerator;
|
strm_fmt_desc->min_intrvl.denominator =
|
fie.interval.denominator;
|
strm_fmt_desc->discrete_frmsize = true;
|
strm_fmt_desc->min_frmsize.width = fie.width;
|
strm_fmt_desc->min_frmsize.height = fie.height;
|
strm_fmt_desc->pix_fmt =
|
img_src_v4l2_subdev_pix_fmt2cif_isp10_pix_fmt(
|
fie.code);
|
|
defrect.width = fie.width;
|
defrect.height = fie.height;
|
memset(&defrect.defrect, 0x00, sizeof(defrect.defrect));
|
v4l2_subdev_call(subdev,
|
core,
|
ioctl,
|
PLTFRM_CIFCAM_G_DEFRECT,
|
(void *)&defrect);
|
if ((defrect.defrect.width == 0) ||
|
(defrect.defrect.height == 0)) {
|
strm_fmt_desc->defrect.left = 0;
|
strm_fmt_desc->defrect.top = 0;
|
strm_fmt_desc->defrect.width = fie.width;
|
strm_fmt_desc->defrect.height = fie.height;
|
} else {
|
strm_fmt_desc->defrect = defrect.defrect;
|
}
|
}
|
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_strm_fmt(
|
void *img_src,
|
struct cif_isp10_strm_fmt *strm_fmt)
|
{
|
int ret = 0;
|
struct v4l2_subdev *subdev = img_src;
|
struct v4l2_subdev_format format;
|
struct v4l2_subdev_frame_interval intrvl;
|
|
format.which = V4L2_SUBDEV_FORMAT_ACTIVE;
|
format.format.code = cif_isp10_pix_fmt2img_src_v4l2_subdev_pix_fmt(
|
strm_fmt->frm_fmt.pix_fmt);
|
format.format.width = strm_fmt->frm_fmt.width;
|
format.format.height = strm_fmt->frm_fmt.height;
|
ret = v4l2_subdev_call(subdev, pad, set_fmt, NULL, &format);
|
if (IS_ERR_VALUE(ret))
|
goto err;
|
intrvl.interval.numerator = strm_fmt->frm_intrvl.numerator;
|
intrvl.interval.denominator = strm_fmt->frm_intrvl.denominator;
|
ret = v4l2_subdev_call(subdev, video, s_frame_interval, &intrvl);
|
if (IS_ERR_VALUE(ret))
|
goto err;
|
return 0;
|
err:
|
pr_err("img_src.%s ERR: failed with error %d\n", __func__, ret);
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_g_ctrl(
|
void *img_src,
|
int id,
|
int *val)
|
{
|
struct v4l2_control ctrl;
|
int ret;
|
struct v4l2_subdev *subdev = img_src;
|
|
ctrl.id = cif_isp10_v4l2_cid2v4l2_cid(id);
|
|
if (IS_ERR_VALUE(ctrl.id))
|
return (int)ctrl.id;
|
|
ret = v4l2_subdev_call(subdev, core, g_ctrl, &ctrl);
|
if (!IS_ERR_VALUE(ret)) {
|
if (id == CIF_ISP10_CID_FLASH_MODE) {
|
if (ctrl.value == V4L2_FLASH_LED_MODE_NONE) {
|
ctrl.value = CIF_ISP10_FLASH_MODE_OFF;
|
} else if (ctrl.value == V4L2_FLASH_LED_MODE_FLASH) {
|
ctrl.value = CIF_ISP10_FLASH_MODE_FLASH;
|
} else if (ctrl.value == V4L2_FLASH_LED_MODE_TORCH) {
|
ctrl.value = CIF_ISP10_FLASH_MODE_TORCH;
|
} else {
|
cif_isp10_pltfrm_pr_err(NULL,
|
"unknown/unsupported value %d for control ID 0x%x\n",
|
ctrl.value, id);
|
return -EINVAL;
|
}
|
}
|
*val = ctrl.value;
|
} else {
|
cif_isp10_pltfrm_pr_err(NULL,
|
"subdevcall got err: %d\n", ret);
|
}
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_ctrl(
|
void *img_src,
|
int id,
|
int val)
|
{
|
struct v4l2_control ctrl;
|
struct v4l2_subdev *subdev = img_src;
|
|
ctrl.value = val;
|
ctrl.id = cif_isp10_v4l2_cid2v4l2_cid(id);
|
|
if (IS_ERR_VALUE(ctrl.id)) {
|
return (int)ctrl.id;
|
} else if (id == CIF_ISP10_CID_FLASH_MODE) {
|
if (val == CIF_ISP10_FLASH_MODE_OFF) {
|
ctrl.value = V4L2_FLASH_LED_MODE_NONE;
|
} else if (val == CIF_ISP10_FLASH_MODE_FLASH) {
|
ctrl.value = V4L2_FLASH_LED_MODE_FLASH;
|
} else if (val == CIF_ISP10_FLASH_MODE_TORCH) {
|
ctrl.value = V4L2_FLASH_LED_MODE_TORCH;
|
} else {
|
cif_isp10_pltfrm_pr_err(NULL,
|
"unknown/unsupported value %d for control ID %d\n",
|
val, id);
|
return -EINVAL;
|
}
|
}
|
return v4l2_subdev_call(subdev, core, s_ctrl, &ctrl);
|
}
|
|
const char *cif_isp10_img_src_v4l2_subdev_g_name(
|
void *img_src)
|
{
|
struct v4l2_subdev *subdev = img_src;
|
|
return dev_driver_string(subdev->dev);
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_ext_ctrls(
|
void *img_src,
|
struct cif_isp10_img_src_ext_ctrl *ctrl)
|
{
|
struct v4l2_ext_controls ctrls;
|
struct v4l2_ext_control *controls;
|
int i;
|
int ret;
|
struct v4l2_subdev *subdev = img_src;
|
|
if (ctrl->cnt == 0)
|
return -EINVAL;
|
|
controls = kmalloc_array(ctrl->cnt, sizeof(struct v4l2_ext_control),
|
GFP_KERNEL);
|
|
if (!controls)
|
return -ENOMEM;
|
|
for (i = 0; i < ctrl->cnt; i++) {
|
controls[i].id = ctrl->ctrls[i].id;
|
controls[i].value = ctrl->ctrls[i].val;
|
}
|
|
ctrls.count = ctrl->cnt;
|
ctrls.controls = controls;
|
/*
|
* current kernel version don't define
|
* this member for struct v4l2_ext_control.
|
*/
|
/* ctrls.ctrl_class = ctrl->class; */
|
ctrls.reserved[0] = 0;
|
ctrls.reserved[1] = 0;
|
|
ret = v4l2_subdev_call(subdev,
|
core, s_ext_ctrls, &ctrls);
|
|
kfree(controls);
|
|
return ret;
|
}
|
|
long cif_isp10_img_src_v4l2_subdev_ioctl(
|
void *img_src,
|
unsigned int cmd,
|
void *arg)
|
{
|
struct v4l2_subdev *subdev = img_src;
|
long ret = -EINVAL;
|
|
switch (cmd) {
|
case RK_VIDIOC_SENSOR_MODE_DATA:
|
case RK_VIDIOC_CAMERA_MODULEINFO:
|
case RK_VIDIOC_SENSOR_CONFIGINFO:
|
case RK_VIDIOC_SENSOR_REG_ACCESS:
|
|
case PLTFRM_CIFCAM_G_ITF_CFG:
|
case PLTFRM_CIFCAM_G_DEFRECT:
|
case PLTFRM_CIFCAM_ATTACH:
|
case PLTFRM_CIFCAM_SET_VCM_POS:
|
case PLTFRM_CIFCAM_GET_VCM_POS:
|
case PLTFRM_CIFCAM_GET_VCM_MOVE_RES:
|
ret = v4l2_subdev_call(subdev,
|
core,
|
ioctl,
|
cmd,
|
arg);
|
|
break;
|
default:
|
break;
|
}
|
|
if (IS_ERR_VALUE(ret) && cmd != PLTFRM_CIFCAM_GET_VCM_MOVE_RES)
|
pr_err("img_src.%s subdev call(cmd: 0x%x) failed with error %ld\n",
|
__func__, cmd, ret);
|
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_s_frame_interval(
|
void *img_src,
|
struct cif_isp10_frm_intrvl *frm_intrvl)
|
{
|
int ret = 0;
|
struct v4l2_subdev *subdev = img_src;
|
struct v4l2_subdev_frame_interval interval;
|
|
interval.interval.numerator = frm_intrvl->numerator;
|
interval.interval.denominator = frm_intrvl->denominator;
|
|
ret = v4l2_subdev_call(subdev, video, s_frame_interval, &interval);
|
if (IS_ERR_VALUE(ret))
|
goto err;
|
|
return 0;
|
err:
|
pr_err("img_src.%s ERR: failed with error %d\n", __func__, ret);
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_g_frame_interval(
|
void *img_src,
|
struct cif_isp10_frm_intrvl *frm_intrvl)
|
{
|
int ret = 0;
|
struct v4l2_subdev *subdev = img_src;
|
struct v4l2_subdev_frame_interval interval;
|
|
interval.interval.numerator = 0;
|
interval.interval.denominator = 0;
|
|
ret = v4l2_subdev_call(subdev, video, g_frame_interval, &interval);
|
if (IS_ERR_VALUE(ret))
|
goto err;
|
|
frm_intrvl->denominator = interval.interval.denominator;
|
frm_intrvl->numerator = interval.interval.numerator;
|
|
return 0;
|
err:
|
pr_err("img_src.%s ERR: failed with error %d\n", __func__, ret);
|
return ret;
|
}
|
|
int cif_isp10_img_src_v4l2_subdev_enum_frame_size(
|
void *img_src,
|
struct v4l2_subdev_frame_size_enum *fse)
|
{
|
struct v4l2_subdev *subdev = img_src;
|
|
return v4l2_subdev_call(subdev, pad,
|
enum_frame_size, NULL, fse);
|
}
|
