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 *ois_ctrl_t = NULL;
struct msm_ois_vreg *vreg_cfg;
bool check_use_gpios;
CDBG_I("Enter\n");
if (client == NULL) {
pr_err("msm_ois_i2c_probe: client is null\n");
rc = -EINVAL;
goto probe_failure;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
if (!client->dev.of_node) {
ois_ctrl_t = (struct msm_ois_ctrl_t *)(id->driver_data);
} else {
ois_ctrl_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!ois_ctrl_t) {
pr_err("%s:%d no memory\n", __func__, __LINE__);
return -ENOMEM;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
CDBG("client = 0x%p\n", client);
rc = of_property_read_u32(client->dev.of_node, "cell-index",
&ois_ctrl_t->subdev_id);
CDBG("cell-index %d, rc %d\n", ois_ctrl_t->subdev_id, rc);
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
if (rc < 0) {
pr_err("failed rc %d\n", rc);
kfree(ois_ctrl_t);//prevent
return rc;
}
check_use_gpios = of_property_read_bool(client->dev.of_node, "unuse-gpios");
CDBG("%s: check unuse-gpio flag(%d)\n",
__FUNCTION__, check_use_gpios);
if (!check_use_gpios) {
rc = msm_ois_get_gpio_data(ois_ctrl_t,
client->dev.of_node);
}
}
if (of_find_property(client->dev.of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &ois_ctrl_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data(client->dev.of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(ois_ctrl_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->i2c_driver = &msm_ois_i2c_driver;
CDBG("client = %x\n", (unsigned int) client);
ois_ctrl_t->i2c_client.client = client;
ois_ctrl_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
/* Set device type as I2C */
ois_ctrl_t->ois_device_type = MSM_CAMERA_I2C_DEVICE;
ois_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
CDBG("ois_ctrl_t->cam_name: %d", ois_ctrl_t->cam_name);
/* Assign name for sub device */
snprintf(ois_ctrl_t->msm_sd.sd.name, sizeof(ois_ctrl_t->msm_sd.sd.name),
"%s", ois_ctrl_t->i2c_driver->driver.name);
/* Initialize sub device */
v4l2_i2c_subdev_init(&ois_ctrl_t->msm_sd.sd,
ois_ctrl_t->i2c_client.client,
ois_ctrl_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&ois_ctrl_t->msm_sd.sd, ois_ctrl_t);
ois_ctrl_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
ois_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&ois_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
ois_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ois_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
ois_ctrl_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
msm_sd_register(&ois_ctrl_t->msm_sd);
//g_ois_i2c_client.client = ois_ctrl_t->i2c_client.client;
CDBG("Succeded Exit\n");
return rc;
probe_failure:
if (ois_ctrl_t)
kfree(ois_ctrl_t);
return rc;
}
static int msm_eeprom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
CDBG("%s E\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s i2c_check_functionality failed\n", __func__);
goto probe_failure;
}
e_ctrl = kzalloc(sizeof(*e_ctrl), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
CDBG("%s client = %x\n", __func__, (unsigned int)client);
e_ctrl->eboard_info = (struct msm_eeprom_board_info *)(id->driver_data);
if (!e_ctrl->eboard_info) {
pr_err("%s:%d board info NULL\n", __func__, __LINE__);
rc = -EINVAL;
goto ectrl_free;
}
power_info = &e_ctrl->eboard_info->power_info;
e_ctrl->i2c_client.client = client;
/* Set device type as I2C */
e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_qup_func_tbl;
if (e_ctrl->eboard_info->i2c_slaveaddr != 0)
e_ctrl->i2c_client.client->addr =
e_ctrl->eboard_info->i2c_slaveaddr;
power_info->clk_info = cam_8960_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8960_clk_info);
power_info->dev = &client->dev;
/* Initialize sub device */
v4l2_i2c_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.client,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
CDBG("%s success result=%d X\n", __func__, rc);
return rc;
ectrl_free:
kfree(e_ctrl);
probe_failure:
pr_err("%s failed! rc = %d\n", __func__, rc);
return rc;
}
static int __devinit ispif_probe(struct platform_device *pdev)
{
int rc;
struct ispif_device *ispif;
ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL);
if (!ispif) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops);
ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops;
ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(ispif->msm_sd.sd.name,
ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME);
v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif);
platform_set_drvdata(pdev, &ispif->msm_sd.sd);
mutex_init(&ispif->mutex);
media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0);
ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF;
ispif->msm_sd.sd.entity.name = pdev->name;
ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1;
rc = msm_sd_register(&ispif->msm_sd);
if (rc) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto error_sd_register;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,num-isps", &ispif->hw_num_isps);
if (rc)
/* backward compatibility */
ispif->hw_num_isps = 1;
/* not an error condition */
rc = 0;
}
ispif->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ispif");
if (!ispif->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "ispif");
if (!ispif->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->io = request_mem_region(ispif->mem->start,
resource_size(ispif->mem), pdev->name);
if (!ispif->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto error;
}
ispif->clk_mux_mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csi_clk_mux");
if (ispif->clk_mux_mem) {
ispif->clk_mux_io = request_mem_region(
ispif->clk_mux_mem->start,
resource_size(ispif->clk_mux_mem),
ispif->clk_mux_mem->name);
if (!ispif->clk_mux_io)
pr_err("%s: no valid csi_mux region\n", __func__);
}
ispif->pdev = pdev;
ispif->ispif_state = ISPIF_POWER_DOWN;
ispif->open_cnt = 0;
return 0;
error:
msm_sd_unregister(&ispif->msm_sd);
error_sd_register:
mutex_destroy(&ispif->mutex);
kfree(ispif);
return rc;
}
static int mt9m032_setup_pll(struct mt9m032 *sensor)
{
static const struct aptina_pll_limits limits = {
.ext_clock_min = 8000000,
.ext_clock_max = 16500000,
.int_clock_min = 2000000,
.int_clock_max = 24000000,
.out_clock_min = 322000000,
.out_clock_max = 693000000,
.pix_clock_max = 99000000,
.n_min = 1,
.n_max = 64,
.m_min = 16,
.m_max = 255,
.p1_min = 1,
.p1_max = 128,
};
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
struct mt9m032_platform_data *pdata = sensor->pdata;
struct aptina_pll pll;
int ret;
pll.ext_clock = pdata->ext_clock;
pll.pix_clock = pdata->pix_clock;
ret = aptina_pll_calculate(&client->dev, &limits, &pll);
if (ret < 0)
return ret;
sensor->pix_clock = pdata->pix_clock;
ret = mt9m032_write(client, MT9M032_PLL_CONFIG1,
(pll.m << MT9M032_PLL_CONFIG1_MUL_SHIFT)
| (pll.p1 - 1));
if (!ret)
ret = mt9m032_write(client, MT9P031_PLL_CONFIG2, pll.n - 1);
if (!ret)
ret = mt9m032_write(client, MT9P031_PLL_CONTROL,
MT9P031_PLL_CONTROL_PWRON |
MT9P031_PLL_CONTROL_USEPLL);
if (!ret) /* more reserved, Continuous, Master Mode */
ret = mt9m032_write(client, MT9M032_READ_MODE1, 0x8006);
if (!ret) /* Set 14-bit mode, select 7 divider */
ret = mt9m032_write(client, MT9M032_FORMATTER1, 0x111e);
return ret;
}
/* -----------------------------------------------------------------------------
* Subdev pad operations
*/
static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_mbus_code_enum *code)
{
if (code->index != 0)
return -EINVAL;
code->code = V4L2_MBUS_FMT_Y8_1X8;
return 0;
}
static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_frame_size_enum *fse)
{
if (fse->index != 0 || fse->code != V4L2_MBUS_FMT_Y8_1X8)
return -EINVAL;
fse->min_width = MT9M032_COLUMN_SIZE_DEF;
fse->max_width = MT9M032_COLUMN_SIZE_DEF;
fse->min_height = MT9M032_ROW_SIZE_DEF;
fse->max_height = MT9M032_ROW_SIZE_DEF;
return 0;
}
/**
* __mt9m032_get_pad_crop() - get crop rect
* @sensor: pointer to the sensor struct
* @fh: file handle for getting the try crop rect from
* @which: select try or active crop rect
*
* Returns a pointer the current active or fh relative try crop rect
*/
static struct v4l2_rect *
__mt9m032_get_pad_crop(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
enum v4l2_subdev_format_whence which)
{
switch (which) {
case V4L2_SUBDEV_FORMAT_TRY:
return v4l2_subdev_get_try_crop(fh, 0);
case V4L2_SUBDEV_FORMAT_ACTIVE:
return &sensor->crop;
default:
return NULL;
}
}
/**
* __mt9m032_get_pad_format() - get format
* @sensor: pointer to the sensor struct
* @fh: file handle for getting the try format from
* @which: select try or active format
*
* Returns a pointer the current active or fh relative try format
*/
static struct v4l2_mbus_framefmt *
__mt9m032_get_pad_format(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
enum v4l2_subdev_format_whence which)
{
switch (which) {
case V4L2_SUBDEV_FORMAT_TRY:
return v4l2_subdev_get_try_format(fh, 0);
case V4L2_SUBDEV_FORMAT_ACTIVE:
return &sensor->format;
default:
return NULL;
}
}
static int mt9m032_get_pad_format(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_format *fmt)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_pad_format(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_format *fmt)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
if (sensor->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
ret = -EBUSY;
goto done;
}
/* Scaling is not supported, the format is thus fixed. */
fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
ret = 0;
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_get_pad_crop(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_crop *crop)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
crop->rect = *__mt9m032_get_pad_crop(sensor, fh, crop->which);
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_pad_crop(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_crop *crop)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
struct v4l2_mbus_framefmt *format;
struct v4l2_rect *__crop;
struct v4l2_rect rect;
int ret = 0;
mutex_lock(&sensor->lock);
if (sensor->streaming && crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
ret = -EBUSY;
goto done;
}
/* Clamp the crop rectangle boundaries and align them to a multiple of 2
* pixels to ensure a GRBG Bayer pattern.
*/
rect.left = clamp(ALIGN(crop->rect.left, 2), MT9M032_COLUMN_START_MIN,
MT9M032_COLUMN_START_MAX);
rect.top = clamp(ALIGN(crop->rect.top, 2), MT9M032_ROW_START_MIN,
MT9M032_ROW_START_MAX);
rect.width = clamp(ALIGN(crop->rect.width, 2), MT9M032_COLUMN_SIZE_MIN,
MT9M032_COLUMN_SIZE_MAX);
rect.height = clamp(ALIGN(crop->rect.height, 2), MT9M032_ROW_SIZE_MIN,
MT9M032_ROW_SIZE_MAX);
rect.width = min(rect.width, MT9M032_PIXEL_ARRAY_WIDTH - rect.left);
rect.height = min(rect.height, MT9M032_PIXEL_ARRAY_HEIGHT - rect.top);
__crop = __mt9m032_get_pad_crop(sensor, fh, crop->which);
if (rect.width != __crop->width || rect.height != __crop->height) {
/* Reset the output image size if the crop rectangle size has
* been modified.
*/
format = __mt9m032_get_pad_format(sensor, fh, crop->which);
format->width = rect.width;
format->height = rect.height;
}
*__crop = rect;
crop->rect = rect;
if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE)
ret = mt9m032_update_geom_timing(sensor);
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_get_frame_interval(struct v4l2_subdev *subdev,
struct v4l2_subdev_frame_interval *fi)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
memset(fi, 0, sizeof(*fi));
fi->interval = sensor->frame_interval;
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_frame_interval(struct v4l2_subdev *subdev,
struct v4l2_subdev_frame_interval *fi)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
if (sensor->streaming) {
ret = -EBUSY;
goto done;
}
/* Avoid divisions by 0. */
if (fi->interval.denominator == 0)
fi->interval.denominator = 1;
ret = mt9m032_update_timing(sensor, &fi->interval);
if (!ret)
sensor->frame_interval = fi->interval;
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_s_stream(struct v4l2_subdev *subdev, int streaming)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
ret = update_formatter2(sensor, streaming);
if (!ret)
sensor->streaming = streaming;
mutex_unlock(&sensor->lock);
return ret;
}
/* -----------------------------------------------------------------------------
* V4L2 subdev core operations
*/
#ifdef CONFIG_VIDEO_ADV_DEBUG
static int mt9m032_g_register(struct v4l2_subdev *sd,
struct v4l2_dbg_register *reg)
{
struct mt9m032 *sensor = to_mt9m032(sd);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int val;
if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
return -EINVAL;
if (reg->match.addr != client->addr)
return -ENODEV;
val = mt9m032_read(client, reg->reg);
if (val < 0)
return -EIO;
reg->size = 2;
reg->val = val;
return 0;
}
static int mt9m032_s_register(struct v4l2_subdev *sd,
struct v4l2_dbg_register *reg)
{
struct mt9m032 *sensor = to_mt9m032(sd);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
return -EINVAL;
if (reg->match.addr != client->addr)
return -ENODEV;
return mt9m032_write(client, reg->reg, reg->val);
}
#endif
/* -----------------------------------------------------------------------------
* V4L2 subdev control operations
*/
static int update_read_mode2(struct mt9m032 *sensor, bool vflip, bool hflip)
{
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int reg_val = (vflip << MT9M032_READ_MODE2_VFLIP_SHIFT)
| (hflip << MT9M032_READ_MODE2_HFLIP_SHIFT)
| MT9M032_READ_MODE2_ROW_BLC
| 0x0007;
return mt9m032_write(client, MT9M032_READ_MODE2, reg_val);
}
static int mt9m032_set_gain(struct mt9m032 *sensor, s32 val)
{
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int digital_gain_val; /* in 1/8th (0..127) */
int analog_mul; /* 0 or 1 */
int analog_gain_val; /* in 1/16th. (0..63) */
u16 reg_val;
digital_gain_val = 51; /* from setup example */
if (val < 63) {
analog_mul = 0;
analog_gain_val = val;
} else {
analog_mul = 1;
analog_gain_val = val / 2;
}
/* a_gain = (1 + analog_mul) + (analog_gain_val + 1) / 16 */
/* overall_gain = a_gain * (1 + digital_gain_val / 8) */
reg_val = ((digital_gain_val & MT9M032_GAIN_DIGITAL_MASK)
<< MT9M032_GAIN_DIGITAL_SHIFT)
| ((analog_mul & 1) << MT9M032_GAIN_AMUL_SHIFT)
| (analog_gain_val & MT9M032_GAIN_ANALOG_MASK);
return mt9m032_write(client, MT9M032_GAIN_ALL, reg_val);
}
static int mt9m032_try_ctrl(struct v4l2_ctrl *ctrl)
{
if (ctrl->id == V4L2_CID_GAIN && ctrl->val >= 63) {
/* round because of multiplier used for values >= 63 */
ctrl->val &= ~1;
}
return 0;
}
static int mt9m032_set_ctrl(struct v4l2_ctrl *ctrl)
{
struct mt9m032 *sensor =
container_of(ctrl->handler, struct mt9m032, ctrls);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int ret;
switch (ctrl->id) {
case V4L2_CID_GAIN:
return mt9m032_set_gain(sensor, ctrl->val);
case V4L2_CID_HFLIP:
/* case V4L2_CID_VFLIP: -- In the same cluster */
return update_read_mode2(sensor, sensor->vflip->val,
sensor->hflip->val);
case V4L2_CID_EXPOSURE:
ret = mt9m032_write(client, MT9M032_SHUTTER_WIDTH_HIGH,
(ctrl->val >> 16) & 0xffff);
if (ret < 0)
return ret;
return mt9m032_write(client, MT9M032_SHUTTER_WIDTH_LOW,
ctrl->val & 0xffff);
}
return 0;
}
static struct v4l2_ctrl_ops mt9m032_ctrl_ops = {
.s_ctrl = mt9m032_set_ctrl,
.try_ctrl = mt9m032_try_ctrl,
};
/* -------------------------------------------------------------------------- */
static const struct v4l2_subdev_core_ops mt9m032_core_ops = {
#ifdef CONFIG_VIDEO_ADV_DEBUG
.g_register = mt9m032_g_register,
.s_register = mt9m032_s_register,
#endif
};
static const struct v4l2_subdev_video_ops mt9m032_video_ops = {
.s_stream = mt9m032_s_stream,
.g_frame_interval = mt9m032_get_frame_interval,
.s_frame_interval = mt9m032_set_frame_interval,
};
static const struct v4l2_subdev_pad_ops mt9m032_pad_ops = {
.enum_mbus_code = mt9m032_enum_mbus_code,
.enum_frame_size = mt9m032_enum_frame_size,
.get_fmt = mt9m032_get_pad_format,
.set_fmt = mt9m032_set_pad_format,
.set_crop = mt9m032_set_pad_crop,
.get_crop = mt9m032_get_pad_crop,
};
static const struct v4l2_subdev_ops mt9m032_ops = {
.core = &mt9m032_core_ops,
.video = &mt9m032_video_ops,
.pad = &mt9m032_pad_ops,
};
/* -----------------------------------------------------------------------------
* Driver initialization and probing
*/
static int mt9m032_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct i2c_adapter *adapter = client->adapter;
struct mt9m032 *sensor;
int chip_version;
int ret;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
dev_warn(&client->dev,
"I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
return -EIO;
}
if (!client->dev.platform_data)
return -ENODEV;
sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
if (sensor == NULL)
return -ENOMEM;
mutex_init(&sensor->lock);
sensor->pdata = client->dev.platform_data;
v4l2_i2c_subdev_init(&sensor->subdev, client, &mt9m032_ops);
sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
chip_version = mt9m032_read(client, MT9M032_CHIP_VERSION);
if (chip_version != MT9M032_CHIP_VERSION_VALUE) {
dev_err(&client->dev, "MT9M032 not detected, wrong version "
"0x%04x\n", chip_version);
ret = -ENODEV;
goto error_sensor;
}
dev_info(&client->dev, "MT9M032 detected at address 0x%02x\n",
client->addr);
sensor->frame_interval.numerator = 1;
sensor->frame_interval.denominator = 30;
sensor->crop.left = MT9M032_COLUMN_START_DEF;
sensor->crop.top = MT9M032_ROW_START_DEF;
sensor->crop.width = MT9M032_COLUMN_SIZE_DEF;
sensor->crop.height = MT9M032_ROW_SIZE_DEF;
sensor->format.width = sensor->crop.width;
sensor->format.height = sensor->crop.height;
sensor->format.code = V4L2_MBUS_FMT_Y8_1X8;
sensor->format.field = V4L2_FIELD_NONE;
sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
v4l2_ctrl_handler_init(&sensor->ctrls, 4);
v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
V4L2_CID_GAIN, 0, 127, 1, 64);
sensor->hflip = v4l2_ctrl_new_std(&sensor->ctrls,
&mt9m032_ctrl_ops,
V4L2_CID_HFLIP, 0, 1, 1, 0);
sensor->vflip = v4l2_ctrl_new_std(&sensor->ctrls,
&mt9m032_ctrl_ops,
V4L2_CID_VFLIP, 0, 1, 1, 0);
v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,
MT9M032_SHUTTER_WIDTH_MAX, 1,
MT9M032_SHUTTER_WIDTH_DEF);
if (sensor->ctrls.error) {
ret = sensor->ctrls.error;
dev_err(&client->dev, "control initialization error %d\n", ret);
goto error_ctrl;
}
v4l2_ctrl_cluster(2, &sensor->hflip);
sensor->subdev.ctrl_handler = &sensor->ctrls;
sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);
if (ret < 0)
goto error_ctrl;
ret = mt9m032_write(client, MT9M032_RESET, 1); /* reset on */
if (ret < 0)
goto error_entity;
mt9m032_write(client, MT9M032_RESET, 0); /* reset off */
if (ret < 0)
goto error_entity;
ret = mt9m032_setup_pll(sensor);
if (ret < 0)
goto error_entity;
usleep_range(10000, 11000);
ret = v4l2_ctrl_handler_setup(&sensor->ctrls);
if (ret < 0)
goto error_entity;
/* SIZE */
ret = mt9m032_update_geom_timing(sensor);
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x41, 0x0000); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x42, 0x0003); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x43, 0x0003); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x7f, 0x0000); /* reserved !!! */
if (ret < 0)
goto error_entity;
if (sensor->pdata->invert_pixclock) {
ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,
MT9M032_PIX_CLK_CTRL_INV_PIXCLK);
if (ret < 0)
goto error_entity;
}
ret = mt9m032_write(client, MT9M032_RESTART, 1); /* Restart on */
if (ret < 0)
goto error_entity;
msleep(100);
ret = mt9m032_write(client, MT9M032_RESTART, 0); /* Restart off */
if (ret < 0)
goto error_entity;
msleep(100);
ret = update_formatter2(sensor, false);
if (ret < 0)
goto error_entity;
return ret;
error_entity:
media_entity_cleanup(&sensor->subdev.entity);
error_ctrl:
v4l2_ctrl_handler_free(&sensor->ctrls);
error_sensor:
mutex_destroy(&sensor->lock);
kfree(sensor);
return ret;
}
static int mt9m032_remove(struct i2c_client *client)
{
struct v4l2_subdev *subdev = i2c_get_clientdata(client);
struct mt9m032 *sensor = to_mt9m032(subdev);
v4l2_device_unregister_subdev(&sensor->subdev);
v4l2_ctrl_handler_free(&sensor->ctrls);
media_entity_cleanup(&sensor->subdev.entity);
mutex_destroy(&sensor->lock);
kfree(sensor);
return 0;
}
static const struct i2c_device_id mt9m032_id_table[] = {
{ MT9M032_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, mt9m032_id_table);
static struct i2c_driver mt9m032_i2c_driver = {
.driver = {
.name = MT9M032_NAME,
},
.probe = mt9m032_probe,
.remove = mt9m032_remove,
.id_table = mt9m032_id_table,
};
static int lm3554_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err;
struct lm3554 *flash;
#ifndef CONFIG_GMIN_INTEL_MID
if (client->dev.platform_data == NULL) {
dev_err(&client->dev, "no platform data\n");
return -ENODEV;
}
#endif
flash = kzalloc(sizeof(*flash), GFP_KERNEL);
if (!flash) {
dev_err(&client->dev, "out of memory\n");
return -ENOMEM;
}
flash->pdata = client->dev.platform_data;
#ifdef CONFIG_GMIN_INTEL_MID
if (!flash->pdata || ACPI_COMPANION(&client->dev))
flash->pdata = lm3554_platform_data_func(client);
#endif
v4l2_i2c_subdev_init(&flash->sd, client, &lm3554_ops);
flash->sd.internal_ops = &lm3554_internal_ops;
flash->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
flash->mode = ATOMISP_FLASH_MODE_OFF;
flash->timeout = LM3554_MAX_TIMEOUT / LM3554_TIMEOUT_STEPSIZE - 1;
err = media_entity_init(&flash->sd.entity, 0, NULL, 0);
if (err) {
dev_err(&client->dev, "error initialize a media entity.\n");
goto fail1;
}
flash->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
mutex_init(&flash->power_lock);
setup_timer(&flash->flash_off_delay, lm3554_flash_off_delay,
(unsigned long)client);
err = lm3554_gpio_init(client);
if (err) {
dev_err(&client->dev, "gpio request/direction_output fail");
goto fail2;
}
#ifdef CONFIG_GMIN_INTEL_MID
if (ACPI_HANDLE(&client->dev))
err = atomisp_register_i2c_module(&flash->sd, NULL, LED_FLASH);
#endif
return 0;
fail2:
media_entity_cleanup(&flash->sd.entity);
fail1:
v4l2_device_unregister_subdev(&flash->sd);
kfree(flash);
return err;
}
static int __devinit msm_vpe_probe(struct platform_device *pdev)
{
int rc = 0;
struct msm_cam_subdev_info sd_info;
D("%s: device id = %d\n", __func__, pdev->id);
vpe_ctrl = kzalloc(sizeof(struct vpe_ctrl_type), GFP_KERNEL);
if (!vpe_ctrl) {
pr_err("%s: not enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&vpe_ctrl->subdev, &msm_vpe_subdev_ops);
v4l2_set_subdevdata(&vpe_ctrl->subdev, vpe_ctrl);
vpe_ctrl->subdev.internal_ops = &msm_vpe_internal_ops;
vpe_ctrl->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(vpe_ctrl->subdev.name, sizeof(vpe_ctrl->subdev.name), "vpe");
platform_set_drvdata(pdev, &vpe_ctrl->subdev);
media_entity_init(&vpe_ctrl->subdev.entity, 0, NULL, 0);
vpe_ctrl->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
vpe_ctrl->subdev.entity.group_id = VPE_DEV;
vpe_ctrl->subdev.entity.name = vpe_ctrl->subdev.name;
vpe_ctrl->subdev.flags |= V4L2_SUBDEV_FL_HAS_EVENTS;
vpe_ctrl->vpemem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "vpe");
if (!vpe_ctrl->vpemem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto vpe_no_resource;
}
vpe_ctrl->vpeirq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "vpe");
if (!vpe_ctrl->vpeirq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto vpe_no_resource;
}
vpe_ctrl->vpeio = request_mem_region(vpe_ctrl->vpemem->start,
resource_size(vpe_ctrl->vpemem), pdev->name);
if (!vpe_ctrl->vpeio) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto vpe_no_resource;
}
rc = request_irq(vpe_ctrl->vpeirq->start, vpe_parse_irq,
IRQF_TRIGGER_RISING, "vpe", 0);
if (rc < 0) {
release_mem_region(vpe_ctrl->vpemem->start,
resource_size(vpe_ctrl->vpemem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto vpe_no_resource;
}
vpe_ctrl->fs_vpe = regulator_get(&pdev->dev, "vdd");
if (IS_ERR(vpe_ctrl->fs_vpe)) {
pr_err("%s: Regulator FS_VPE get failed %ld\n", __func__,
PTR_ERR(vpe_ctrl->fs_vpe));
vpe_ctrl->fs_vpe = NULL;
}
disable_irq(vpe_ctrl->vpeirq->start);
#ifdef CONFIG_MSM_IOMMU
/*get device context for IOMMU*/
vpe_ctrl->iommu_ctx_src = msm_iommu_get_ctx("vpe_src"); /*re-confirm*/
vpe_ctrl->iommu_ctx_dst = msm_iommu_get_ctx("vpe_dst"); /*re-confirm*/
if (!vpe_ctrl->iommu_ctx_src || !vpe_ctrl->iommu_ctx_dst) {
release_mem_region(vpe_ctrl->vpemem->start,
resource_size(vpe_ctrl->vpemem));
pr_err("%s: No iommu fw context found\n", __func__);
rc = -ENODEV;
goto vpe_no_resource;
}
#endif
atomic_set(&vpe_ctrl->active, 0);
vpe_ctrl->pdev = pdev;
sd_info.sdev_type = VPE_DEV;
sd_info.sd_index = pdev->id;
sd_info.irq_num = vpe_ctrl->vpeirq->start;
msm_cam_register_subdev_node(&vpe_ctrl->subdev, &sd_info);
vpe_ctrl->subdev.entity.revision = vpe_ctrl->subdev.devnode->num;
msm_queue_init(&vpe_ctrl->eventData_q, "ackevents");
return 0;
vpe_no_resource:
pr_err("%s: VPE Probe failed.\n", __func__);
kfree(vpe_ctrl);
return rc;
}
static int32_t msm_flash_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_flash_ctrl_t *flash_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
CDBG("Enter");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
flash_ctrl = kzalloc(sizeof(struct msm_flash_ctrl_t), GFP_KERNEL);
if (!flash_ctrl) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
memset(flash_ctrl, 0, sizeof(struct msm_flash_ctrl_t));
flash_ctrl->pdev = pdev;
rc = msm_flash_get_dt_data(pdev->dev.of_node, flash_ctrl);
if (rc < 0) {
pr_err("%s:%d msm_flash_get_dt_data failed\n",
__func__, __LINE__);
kfree(flash_ctrl);
return -EINVAL;
}
flash_ctrl->flash_state = MSM_CAMERA_FLASH_RELEASE;
flash_ctrl->power_info.dev = &flash_ctrl->pdev->dev;
flash_ctrl->flash_device_type = MSM_CAMERA_PLATFORM_DEVICE;
flash_ctrl->flash_mutex = &msm_flash_mutex;
flash_ctrl->flash_i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
flash_ctrl->flash_i2c_client.cci_client = kzalloc(
sizeof(struct msm_camera_cci_client), GFP_KERNEL);
if (!flash_ctrl->flash_i2c_client.cci_client) {
kfree(flash_ctrl);
pr_err("failed no memory\n");
return -ENOMEM;
}
cci_client = flash_ctrl->flash_i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = flash_ctrl->cci_i2c_master;
/* Initialize sub device */
v4l2_subdev_init(&flash_ctrl->msm_sd.sd, &msm_flash_subdev_ops);
v4l2_set_subdevdata(&flash_ctrl->msm_sd.sd, flash_ctrl);
flash_ctrl->msm_sd.sd.internal_ops = &msm_flash_internal_ops;
flash_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(flash_ctrl->msm_sd.sd.name,
ARRAY_SIZE(flash_ctrl->msm_sd.sd.name),
"msm_camera_flash");
media_entity_init(&flash_ctrl->msm_sd.sd.entity, 0, NULL, 0);
flash_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
flash_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_FLASH;
flash_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x1;
msm_sd_register(&flash_ctrl->msm_sd);
CDBG("%s:%d flash sd name = %s", __func__, __LINE__,
flash_ctrl->msm_sd.sd.entity.name);
msm_flash_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_flash_v4l2_subdev_fops.compat_ioctl32 =
msm_flash_subdev_fops_ioctl;
#endif
flash_ctrl->msm_sd.sd.devnode->fops = &msm_flash_v4l2_subdev_fops;
if (flash_ctrl->flash_driver_type == FLASH_DRIVER_PMIC)
rc = msm_torch_create_classdev(pdev, &flash_ctrl);
CDBG("probe success\n");
return rc;
}
static int32_t msm_tcs_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
CDBG("Enter\n");
if (!pdev->dev.of_node) {
CDBG("of_node NULL : %d\n", EINVAL);
return -EINVAL;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_tcs_t.cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_tcs_t.cci_master, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
msm_tcs_t.tcs_mutex = &msm_tcs_mutex;
msm_tcs_t.pdev = pdev;
msm_tcs_t.tcs_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_tcs_t.i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_tcs_t.i2c_client.cci_client = kzalloc(sizeof(struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_tcs_t.i2c_client.cci_client) {
pr_err("failed no memory\n");
return -ENOMEM;
}
msm_tcs_t.i2c_client.cci_client->sid = 0x39; //Slave address
msm_tcs_t.i2c_client.cci_client->retries = 3;
msm_tcs_t.i2c_client.cci_client->id_map = 0;
msm_tcs_t.i2c_client.cci_client->cci_i2c_master = MASTER_0;
msm_tcs_t.i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
cci_client = msm_tcs_t.i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
v4l2_subdev_init(&msm_tcs_t.msm_sd.sd,
msm_tcs_t.tcs_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_tcs_t.msm_sd.sd, &msm_tcs_t);
msm_tcs_t.msm_sd.sd.internal_ops = &msm_tcs_internal_ops;
msm_tcs_t.msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_tcs_t.msm_sd.sd.name,
ARRAY_SIZE(msm_tcs_t.msm_sd.sd.name), "msm_tcs");
media_entity_init(&msm_tcs_t.msm_sd.sd.entity, 0, NULL, 0);
msm_tcs_t.msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_tcs_t.msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_TCS;
msm_tcs_t.msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x2;
msm_sd_register(&msm_tcs_t.msm_sd);
msm_tcs_t.tcs_state = TCS_POWER_DOWN;
msm_tcs_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_tcs_v4l2_subdev_fops.compat_ioctl32 = msm_tcs_subdev_fops_ioctl;
#endif
msm_tcs_t.msm_sd.sd.devnode->fops = &msm_tcs_v4l2_subdev_fops;
msm_tcs_t.sid_tcs = msm_tcs_t.i2c_client.cci_client->sid;
msm_tcs_t.tcs_func_tbl = NULL;
msm_tcs_t.exit_workqueue = 1;
msm_tcs_t.pause_workqueue = 0;
msm_tcs_t.max_i2c_fail_thres = 5;
msm_tcs_t.i2c_fail_cnt = 0;
CDBG("Exit\n");
return rc;
}
static int vfe_probe(struct platform_device *pdev)
{
struct vfe_device *vfe_dev;
/*struct msm_cam_subdev_info sd_info;*/
const struct of_device_id *match_dev;
int rc = 0;
struct msm_iova_partition vfe_partition = {
.start = SZ_128K,
.size = SZ_2G - SZ_128K,
};
struct msm_iova_layout vfe_layout = {
.partitions = &vfe_partition,
.npartitions = 1,
.client_name = "vfe",
.domain_flags = 0,
};
vfe_dev = kzalloc(sizeof(struct vfe_device), GFP_KERNEL);
if (!vfe_dev) {
pr_err("%s: no enough memory\n", __func__);
rc = -ENOMEM;
goto end;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
match_dev = of_match_device(msm_vfe_dt_match, &pdev->dev);
if (!match_dev) {
pr_err("%s: No vfe hardware info\n", __func__);
rc = -EINVAL;
goto probe_fail;
}
vfe_dev->hw_info =
(struct msm_vfe_hardware_info *) match_dev->data;
} else {
vfe_dev->hw_info = (struct msm_vfe_hardware_info *)
platform_get_device_id(pdev)->driver_data;
}
if (!vfe_dev->hw_info) {
pr_err("%s: No vfe hardware info\n", __func__);
rc = -EINVAL;
goto probe_fail;
}
ISP_DBG("%s: device id = %d\n", __func__, pdev->id);
vfe_dev->pdev = pdev;
rc = vfe_dev->hw_info->vfe_ops.core_ops.get_platform_data(vfe_dev);
if (rc < 0) {
pr_err("%s: failed to get platform resources\n", __func__);
rc = -ENOMEM;
goto probe_fail;
}
INIT_LIST_HEAD(&vfe_dev->tasklet_q);
tasklet_init(&vfe_dev->vfe_tasklet,
msm_isp_do_tasklet, (unsigned long)vfe_dev);
v4l2_subdev_init(&vfe_dev->subdev.sd, vfe_dev->hw_info->subdev_ops);
vfe_dev->subdev.sd.internal_ops =
vfe_dev->hw_info->subdev_internal_ops;
snprintf(vfe_dev->subdev.sd.name,
ARRAY_SIZE(vfe_dev->subdev.sd.name),
"vfe");
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_EVENTS;
v4l2_set_subdevdata(&vfe_dev->subdev.sd, vfe_dev);
platform_set_drvdata(pdev, &vfe_dev->subdev.sd);
mutex_init(&vfe_dev->realtime_mutex);
mutex_init(&vfe_dev->core_mutex);
spin_lock_init(&vfe_dev->tasklet_lock);
spin_lock_init(&vfe_dev->shared_data_lock);
media_entity_init(&vfe_dev->subdev.sd.entity, 0, NULL, 0);
vfe_dev->subdev.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
vfe_dev->subdev.sd.entity.group_id = MSM_CAMERA_SUBDEV_VFE;
vfe_dev->subdev.sd.entity.name = pdev->name;
vfe_dev->subdev.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x2;
rc = msm_sd_register(&vfe_dev->subdev);
if (rc != 0) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto probe_fail;
}
vfe_dev->buf_mgr = &vfe_buf_mgr;
v4l2_subdev_notify(&vfe_dev->subdev.sd,
MSM_SD_NOTIFY_REQ_CB, &vfe_vb2_ops);
rc = msm_isp_create_isp_buf_mgr(vfe_dev->buf_mgr,
&vfe_vb2_ops, &vfe_layout);
if (rc < 0) {
pr_err("%s: Unable to create buffer manager\n", __func__);
rc = -EINVAL;
goto probe_fail;
}
/* create secure context banks*/
if (vfe_dev->hw_info->num_iommu_secure_ctx) {
/*secure vfe layout*/
struct msm_iova_layout vfe_secure_layout = {
.partitions = &vfe_partition,
.npartitions = 1,
.client_name = "vfe_secure",
.domain_flags = 0,
.is_secure = MSM_IOMMU_DOMAIN_SECURE,
};
rc = msm_isp_create_secure_domain(vfe_dev->buf_mgr,
&vfe_secure_layout);
if (rc < 0) {
pr_err("%s: fail to create secure domain\n", __func__);
msm_sd_unregister(&vfe_dev->subdev);
rc = -EINVAL;
goto probe_fail;
}
}
vfe_dev->buf_mgr->ops->register_ctx(vfe_dev->buf_mgr,
&vfe_dev->iommu_ctx[0], &vfe_dev->iommu_secure_ctx[0],
vfe_dev->hw_info->num_iommu_ctx,
vfe_dev->hw_info->num_iommu_secure_ctx);
vfe_dev->buf_mgr->init_done = 1;
vfe_dev->vfe_open_cnt = 0;
return rc;
probe_fail:
kfree(vfe_dev);
end:
return rc;
}
static struct platform_driver vfe_driver = {
.probe = vfe_probe,
.driver = {
.name = "msm_vfe",
.owner = THIS_MODULE,
.of_match_table = msm_vfe_dt_match,
},
.id_table = msm_vfe_dev_id,
};
static int __init msm_vfe_init_module(void)
{
return platform_driver_register(&vfe_driver);
}
static void __exit msm_vfe_exit_module(void)
{
platform_driver_unregister(&vfe_driver);
}
module_init(msm_vfe_init_module);
module_exit(msm_vfe_exit_module);
MODULE_DESCRIPTION("MSM VFE driver");
MODULE_LICENSE("GPL v2");
/*
* public functions
*/
struct nxp_video *create_nxp_video(char *name, u32 type,
struct v4l2_device *v4l2_dev, void *vb2_alloc_ctx)
{
int ret;
struct vb2_queue *vbq = NULL;
struct nxp_video *me = kzalloc(sizeof(struct nxp_video), GFP_KERNEL);
int pad_num = 0;
if (!me) {
pr_err("%s: failed to allocate me!!!\n", __func__);
return NULL;
}
snprintf(me->name, sizeof(me->name), "%s", name);
snprintf(me->vdev.name, sizeof(me->vdev.name), "%s", name);
me->type = type;
me->v4l2_dev = v4l2_dev;
me->vb2_alloc_ctx = vb2_alloc_ctx;
/* pad init */
/* TODO */
#if 0
switch (type) {
case NXP_VIDEO_TYPE_CAPTURE:
/**
* capture subdev -> capture ->
* m2m subdev or out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
break;
case NXP_VIDEO_TYPE_OUT:
/**
* out -> out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 1;
break;
case NXP_VIDEO_TYPE_M2M:
/**
* capture video -> m2m subdev ->
* m2m video -> out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
break;
default:
pr_err("%s: invalid type(%d)\n", __func__, type);
kfree(me);
return NULL;
}
#else
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
#endif
me->vdev.entity.ops = &nxp_media_entity_operations;
ret = media_entity_init(&me->vdev.entity, pad_num, me->pads, 0);
if (ret < 0) {
kfree(me);
return NULL;
}
mutex_init(&me->lock);
me->register_buffer_consumer = _register_buffer_consumer;
me->unregister_buffer_consumer = _unregister_buffer_consumer;
me->vdev.fops = &nxp_video_fops;
me->vdev.ioctl_ops = &nxp_video_ioctl_ops;
me->vdev.v4l2_dev = v4l2_dev;
me->vdev.minor = -1;
me->vdev.vfl_type = VFL_TYPE_GRABBER;
me->vdev.release = video_device_release;
me->vdev.lock = &me->lock;
if (type != NXP_VIDEO_TYPE_M2M) {
vbq = kzalloc(sizeof(*vbq), GFP_KERNEL);
if (!vbq) {
pr_err("%s: failed to allocate vbq\n", __func__);
ret = -ENOMEM;
goto error_vbq_alloc;
}
vbq->type = type == NXP_VIDEO_TYPE_CAPTURE ?
V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
vbq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
vbq->drv_priv = me;
vbq->ops = &nxp_vb2_ops;
vbq->mem_ops = &vb2_ion_memops;
ret = vb2_queue_init(vbq);
if (ret < 0) {
pr_err("%s: failed to vb2_queue_init()\n", __func__);
goto error_vbq_init;
}
me->vbq = vbq;
} else {
/* m2m */
me->m2m_dev = v4l2_m2m_init(&nxp_m2m_ops);
if (IS_ERR(me->m2m_dev)) {
pr_err("%s: failed to v4l2_m2m_init()\n", __func__);
ret = -ENOMEM;
goto error_vbq_alloc;
}
}
INIT_LIST_HEAD(&me->source_consumer_list);
INIT_LIST_HEAD(&me->sink_consumer_list);
spin_lock_init(&me->lock_consumer);
video_set_drvdata(&me->vdev, me);
pr_debug("%s: success!!!\n", __func__);
return me;
error_vbq_init:
if (vbq)
kfree(vbq);
error_vbq_alloc:
kfree(me);
return NULL;
}
static int32_t msm_tcs_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_tcs_ctrl_t *tcs_ctrl_t = NULL;
CDBG("Enter\n");
if (client == NULL) {
pr_err("msm_ois_i2c_probe: client is null\n");
rc = -EINVAL;
goto probe_failure;
}
tcs_ctrl_t = kzalloc(sizeof(struct msm_tcs_ctrl_t),
GFP_KERNEL);
if (!tcs_ctrl_t) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
CDBG("client = 0x%p\n", client);
rc = of_property_read_u32(client->dev.of_node, "cell-index",
&tcs_ctrl_t->subdev_id);
CDBG("cell-index %d, rc %d\n", tcs_ctrl_t->subdev_id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
tcs_ctrl_t->i2c_driver = &msm_tcs_i2c_driver;
tcs_ctrl_t->i2c_client.client = client;
tcs_ctrl_t->tcs_device_type = MSM_CAMERA_I2C_DEVICE;
tcs_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
tcs_ctrl_t->tcs_v4l2_subdev_ops = &msm_tcs_subdev_ops;
tcs_ctrl_t->tcs_mutex = &msm_tcs_mutex;
snprintf(tcs_ctrl_t->msm_sd.sd.name, sizeof(tcs_ctrl_t->msm_sd.sd.name),
"%s", tcs_ctrl_t->i2c_driver->driver.name);
v4l2_i2c_subdev_init(&tcs_ctrl_t->msm_sd.sd,
tcs_ctrl_t->i2c_client.client,
tcs_ctrl_t->tcs_v4l2_subdev_ops);
v4l2_set_subdevdata(&tcs_ctrl_t->msm_sd.sd, tcs_ctrl_t);
tcs_ctrl_t->msm_sd.sd.internal_ops = &msm_tcs_internal_ops;
tcs_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&tcs_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
tcs_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
tcs_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_TCS;
tcs_ctrl_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x2;
msm_sd_register(&tcs_ctrl_t->msm_sd);
tcs_ctrl_t->tcs_state = TCS_POWER_DOWN;
CDBG("succeeded\n");
CDBG("Exit\n");
probe_failure:
return rc;
}
static void dvb_register_media_device(struct dvb_device *dvbdev,
int type, int minor)
{
#if defined(CONFIG_MEDIA_CONTROLLER_DVB)
int ret = 0, npads;
if (!dvbdev->adapter->mdev)
return;
dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
if (!dvbdev->entity)
return;
dvbdev->entity->info.dev.major = DVB_MAJOR;
dvbdev->entity->info.dev.minor = minor;
dvbdev->entity->name = dvbdev->name;
switch (type) {
case DVB_DEVICE_CA:
case DVB_DEVICE_DEMUX:
case DVB_DEVICE_FRONTEND:
npads = 2;
break;
case DVB_DEVICE_NET:
npads = 0;
break;
default:
npads = 1;
}
if (npads) {
dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
GFP_KERNEL);
if (!dvbdev->pads) {
kfree(dvbdev->entity);
return;
}
}
switch (type) {
case DVB_DEVICE_FRONTEND:
dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_FE;
dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
break;
case DVB_DEVICE_DEMUX:
dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_DEMUX;
dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
break;
case DVB_DEVICE_DVR:
dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_DVR;
dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
break;
case DVB_DEVICE_CA:
dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_CA;
dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
break;
case DVB_DEVICE_NET:
dvbdev->entity->type = MEDIA_ENT_T_DEVNODE_DVB_NET;
break;
default:
kfree(dvbdev->entity);
dvbdev->entity = NULL;
return;
}
if (npads)
ret = media_entity_init(dvbdev->entity, npads, dvbdev->pads, 0);
if (!ret)
ret = media_device_register_entity(dvbdev->adapter->mdev,
dvbdev->entity);
if (ret < 0) {
printk(KERN_ERR
"%s: media_device_register_entity failed for %s\n",
__func__, dvbdev->entity->name);
kfree(dvbdev->pads);
kfree(dvbdev->entity);
dvbdev->entity = NULL;
return;
}
printk(KERN_DEBUG "%s: media device '%s' registered.\n",
__func__, dvbdev->entity->name);
#endif
}
static int ispif_probe(struct platform_device *pdev)
{
int rc;
struct ispif_device *ispif;
ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL);
if (!ispif) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,num-isps", &ispif->hw_num_isps);
if (rc)
/* backward compatibility */
ispif->hw_num_isps = 1;
/* not an error condition */
rc = 0;
}
rc = msm_ispif_get_clk_info(ispif, pdev,
ispif_ahb_clk_info, ispif_clk_info);
if (rc < 0) {
pr_err("%s: msm_isp_get_clk_info() failed", __func__);
return -EFAULT;
}
mutex_init(&ispif->mutex);
ispif->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ispif");
if (!ispif->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "ispif");
if (!ispif->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->io = request_mem_region(ispif->mem->start,
resource_size(ispif->mem), pdev->name);
if (!ispif->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto error;
}
ispif->clk_mux_mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csi_clk_mux");
if (ispif->clk_mux_mem) {
ispif->clk_mux_io = request_mem_region(
ispif->clk_mux_mem->start,
resource_size(ispif->clk_mux_mem),
ispif->clk_mux_mem->name);
if (!ispif->clk_mux_io)
pr_err("%s: no valid csi_mux region\n", __func__);
}
//LGE_CHANGE_S, vdd_vfe to check if vfe is up
ispif->fs_vfe = regulator_get(&pdev->dev, "vdd_vfe");
if (ispif->fs_vfe == NULL)
pr_err("%s: gdsc_vfe is null\n", __func__);
//LGE_CHANGE_E, vdd_vfe to check if vfe is up
v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops);
ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops;
ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(ispif->msm_sd.sd.name,
ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME);
v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif);
platform_set_drvdata(pdev, &ispif->msm_sd.sd);
media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0);
ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF;
ispif->msm_sd.sd.entity.name = pdev->name;
ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1;
rc = msm_sd_register(&ispif->msm_sd);
if (rc) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto error;
}
msm_ispif_v4l2_subdev_fops.owner = v4l2_subdev_fops.owner;
msm_ispif_v4l2_subdev_fops.open = v4l2_subdev_fops.open;
msm_ispif_v4l2_subdev_fops.unlocked_ioctl = msm_ispif_subdev_fops_ioctl;
msm_ispif_v4l2_subdev_fops.release = v4l2_subdev_fops.release;
msm_ispif_v4l2_subdev_fops.poll = v4l2_subdev_fops.poll;
#ifdef CONFIG_COMPAT
msm_ispif_v4l2_subdev_fops.compat_ioctl32 = msm_ispif_subdev_fops_ioctl;
#endif
ispif->msm_sd.sd.devnode->fops = &msm_ispif_v4l2_subdev_fops;
ispif->pdev = pdev;
ispif->ispif_state = ISPIF_POWER_DOWN;
ispif->open_cnt = 0;
return 0;
error:
mutex_destroy(&ispif->mutex);
kfree(ispif);
return rc;
}
static int32_t msm_ois_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_ois_ctrl_t *msm_ois_t = NULL;
struct msm_ois_vreg *vreg_cfg;
CDBG_I("Enter\n");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
msm_ois_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!msm_ois_t) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
msm_ois_t->subdev_id = pdev->id;
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_ois_t->cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_ois_t->cci_master, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
if (of_find_property((&pdev->dev)->of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &msm_ois_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data((&pdev->dev)->of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
msm_ois_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
msm_ois_t->ois_mutex = &msm_ois_mutex;
msm_ois_t->cam_name = pdev->id;
/* Set platform device handle */
msm_ois_t->pdev = pdev;
/* Set device type as platform device */
msm_ois_t->ois_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_ois_t->i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_ois_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
msm_ois_t->i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_ois_t->i2c_client.cci_client) {
kfree(msm_ois_t->vreg_cfg.cam_vreg);
kfree(msm_ois_t);
pr_err("failed no memory\n");
return -ENOMEM;
}
cci_client = msm_ois_t->i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = MASTER_MAX;
v4l2_subdev_init(&msm_ois_t->msm_sd.sd,
msm_ois_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_ois_t->msm_sd.sd, msm_ois_t);
msm_ois_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
msm_ois_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_ois_t->msm_sd.sd.name,
ARRAY_SIZE(msm_ois_t->msm_sd.sd.name), "msm_ois");
media_entity_init(&msm_ois_t->msm_sd.sd.entity, 0, NULL, 0);
msm_ois_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_ois_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
msm_ois_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
rc = msm_sd_register(&msm_ois_t->msm_sd);
//g_ois_i2c_client.cci_client = msm_ois_t->i2c_client.cci_client;
CDBG("Exit[rc::%d]\n", rc);
return rc;
}
static int __init msm_sensor_init_module(void)
{
int ret = 0;
struct device_node *of_node = NULL;
of_node = of_find_compatible_node(NULL, NULL, "qcom,hw-camera-board-id");
if (of_property_read_string(of_node, "qcom,product-name",
&dt_product_name) < 0) {
dt_product_name = NULL;
pr_err("%s: don't define support product name.\n",__func__);
}
else{
pr_info("%s product_name = %s\n", __func__, dt_product_name);
}
/* Allocate memory for msm_sensor_init control structure */
s_init = kzalloc(sizeof(struct msm_sensor_init_t), GFP_KERNEL);
if (!s_init) {
pr_err("failed: no memory s_init %p", NULL);
return -ENOMEM;
}
CDBG("MSM_SENSOR_INIT_MODULE %p", NULL);
/* Initialize mutex */
mutex_init(&s_init->imutex);
/* Create /dev/v4l-subdevX for msm_sensor_init */
v4l2_subdev_init(&s_init->msm_sd.sd, &msm_sensor_init_subdev_ops);
snprintf(s_init->msm_sd.sd.name, sizeof(s_init->msm_sd.sd.name), "%s",
"msm_sensor_init");
v4l2_set_subdevdata(&s_init->msm_sd.sd, s_init);
s_init->msm_sd.sd.internal_ops = &msm_sensor_init_internal_ops;
s_init->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_init->msm_sd.sd.entity, 0, NULL, 0);
s_init->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_init->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR_INIT;
s_init->msm_sd.sd.entity.name = s_init->msm_sd.sd.name;
s_init->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6;
ret = msm_sd_register(&s_init->msm_sd);
if (ret) {
CDBG("%s: msm_sd_register error = %d\n", __func__, ret);
goto error;
}
msm_sensor_init_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_sensor_init_v4l2_subdev_fops.compat_ioctl32 =
msm_sensor_init_subdev_fops_ioctl;
#endif
s_init->msm_sd.sd.devnode->fops =
&msm_sensor_init_v4l2_subdev_fops;
init_waitqueue_head(&s_init->state_wait);
return 0;
error:
mutex_destroy(&s_init->imutex);
kfree(s_init);
return ret;
}
int32_t msm_sensor_bayer_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s %s_i2c_probe called\n", __func__, client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->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_bayer_match_id(s_ctrl);
if (rc < 0)
goto probe_fail;
if (!s_ctrl->wait_num_frames)
s_ctrl->wait_num_frames = 1;
pr_err("%s %s probe succeeded\n", __func__, client->name);
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
s_ctrl->sensor_v4l2_subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->sensor_v4l2_subdev.entity, 0, NULL, 0);
s_ctrl->sensor_v4l2_subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->sensor_v4l2_subdev.entity.group_id = SENSOR_DEV;
s_ctrl->sensor_v4l2_subdev.entity.name =
s_ctrl->sensor_v4l2_subdev.name;
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
s_ctrl->sensor_v4l2_subdev.entity.revision =
s_ctrl->sensor_v4l2_subdev.devnode->num;
msm_sensor_bayer_eeprom_read(s_ctrl);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
static int flite_probe(struct platform_device *pdev)
{
struct resource *mem_res;
struct resource *regs_res;
struct flite_dev *flite;
int ret = -ENODEV;
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data is NULL\n");
return -EINVAL;
}
flite = kzalloc(sizeof(struct flite_dev), GFP_KERNEL);
if (!flite)
return -ENOMEM;
flite->pdev = pdev;
flite->pdata = pdev->dev.platform_data;
flite->id = pdev->id;
init_waitqueue_head(&flite->irq_queue);
spin_lock_init(&flite->slock);
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem_res) {
dev_err(&pdev->dev, "Failed to get io memory region\n");
goto p_err1;
}
regs_res = request_mem_region(mem_res->start, resource_size(mem_res),
pdev->name);
if (!regs_res) {
dev_err(&pdev->dev, "Failed to request io memory region\n");
goto p_err1;
}
flite->regs_res = regs_res;
flite->regs = ioremap(mem_res->start, resource_size(mem_res));
if (!flite->regs) {
dev_err(&pdev->dev, "Failed to remap io region\n");
goto p_err2;
}
flite->irq = platform_get_irq(pdev, 0);
if (flite->irq < 0) {
dev_err(&pdev->dev, "Failed to get irq\n");
goto p_err3;
}
ret = request_irq(flite->irq, flite_irq_handler, 0, dev_name(&pdev->dev), flite);
if (ret) {
dev_err(&pdev->dev, "request_irq failed\n");
goto p_err3;
}
v4l2_subdev_init(&flite->sd, &flite_subdev_ops);
flite->sd.owner = THIS_MODULE;
snprintf(flite->sd.name, sizeof(flite->sd.name), "%s.%d\n",
MODULE_NAME, flite->id);
#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_ARCH_EXYNOS5)
flite->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
flite->pads[FLITE_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
flite->pads[FLITE_PAD_SOURCE_PREVIEW].flags = MEDIA_PAD_FL_SOURCE;
flite->pads[FLITE_PAD_SOURCE_CAMCORDING].flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&flite->sd.entity, FLITE_PADS_NUM,
flite->pads, 0);
if (ret < 0)
goto p_err3;
flite_init_formats(&flite->sd, NULL);
flite->sd.internal_ops = &flite_v4l2_internal_ops;
flite->sd.entity.ops = &flite_media_ops;
flite->mdev = flite_get_capture_md(MDEV_CAPTURE);
if (IS_ERR_OR_NULL(flite->mdev))
goto p_err3;
ret = v4l2_device_register_subdev(&flite->mdev->v4l2_dev, &flite->sd);
if (ret)
goto p_err3;
#endif
/* This allows to retrieve the platform device id by the host driver */
v4l2_set_subdevdata(&flite->sd, pdev);
/* .. and a pointer to the subdev. */
platform_set_drvdata(pdev, &flite->sd);
pm_runtime_enable(&pdev->dev);
flite_info("fimc-lite%d probe success", pdev->id);
return 0;
p_err3:
iounmap(flite->regs);
p_err2:
release_mem_region(regs_res->start, resource_size(regs_res));
p_err1:
kfree(flite);
return ret;
}
static int csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
uint32_t csi_vdd_voltage = 0;
int rc = 0;
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
new_csid_dev->ctrl_reg = NULL;
new_csid_dev->ctrl_reg = kzalloc(sizeof(struct csid_ctrl_t),
GFP_KERNEL);
if (!new_csid_dev->ctrl_reg) {
kfree(new_csid_dev);
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->msm_sd.sd, &msm_csid_subdev_ops);
v4l2_set_subdevdata(&new_csid_dev->msm_sd.sd, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->msm_sd.sd);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node) {
rc = of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
if (rc < 0) {
pr_err("%s:%d failed to read cell-index\n", __func__,
__LINE__);
goto csid_no_resource;
}
CDBG("%s device id %d\n", __func__, pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,csi-vdd-voltage", &csi_vdd_voltage);
if (rc < 0) {
pr_err("%s:%d failed to read qcom,csi-vdd-voltage\n",
__func__, __LINE__);
goto csid_no_resource;
}
CDBG("%s:%d reading mipi_csi_vdd is %d\n", __func__, __LINE__,
csi_vdd_voltage);
csid_vreg_info[0].min_voltage = csi_vdd_voltage;
csid_vreg_info[0].max_voltage = csi_vdd_voltage;
}
rc = msm_csid_get_clk_info(new_csid_dev, pdev);
if (rc < 0) {
pr_err("%s: msm_csid_get_clk_info() failed", __func__);
return -EFAULT;
}
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
new_csid_dev->msm_sd.sd.internal_ops = &msm_csid_internal_ops;
new_csid_dev->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->msm_sd.sd.name,
ARRAY_SIZE(new_csid_dev->msm_sd.sd.name), "msm_csid");
media_entity_init(&new_csid_dev->msm_sd.sd.entity, 0, NULL, 0);
new_csid_dev->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_CSID;
new_csid_dev->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x5;
msm_sd_register(&new_csid_dev->msm_sd);
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s Error registering irq ", __func__);
goto csid_no_resource;
}
if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v2.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v2_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V20;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v2.2")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v2_2;
new_csid_dev->hw_dts_version = CSID_VERSION_V22;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V30;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v4.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V40;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.1")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_1;
new_csid_dev->hw_dts_version = CSID_VERSION_V31;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.2")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_2;
new_csid_dev->hw_dts_version = CSID_VERSION_V32;
} else {
pr_err("%s:%d, invalid hw version : 0x%x", __func__, __LINE__,
new_csid_dev->hw_dts_version);
return -EINVAL;
}
new_csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev->ctrl_reg);
kfree(new_csid_dev);
return 0;
}
static int m5mols_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
const struct m5mols_platform_data *pdata =
client->dev.platform_data;
struct m5mols_info *info;
struct v4l2_subdev *sd;
int ret = 0;
if (pdata == NULL) {
dev_err(&client->dev, "No platform data\n");
return -EINVAL;
}
if (!gpio_is_valid(pdata->gpio_rst)) {
dev_err(&client->dev, "No valid nRST gpio pin.\n");
return -EINVAL;
}
if (!pdata->irq) {
dev_err(&client->dev, "Interrupt not assigned.\n");
return -EINVAL;
}
info = kzalloc(sizeof(struct m5mols_info), GFP_KERNEL);
if (info == NULL) {
dev_err(&client->dev, "Failed to allocate info\n");
return -ENOMEM;
}
info->pdata = pdata;
if (info->pdata->set_power) /* for additional power if needed. */
info->set_power = pdata->set_power;
if (info->pdata->irq) {
INIT_WORK(&info->work, m5mols_irq_work);
ret = request_irq(info->pdata->irq, m5mols_irq_handler,
IRQF_TRIGGER_RISING, MOD_NAME, &info->sd);
if (ret) {
dev_err(&client->dev, "Failed to request irq: %d\n", ret);
return ret;
}
}
ret = gpio_request(info->pdata->gpio_rst, "M5MOLS nRST");
if (ret) {
dev_err(&client->dev, "Failed to set gpio, %d\n", ret);
goto out_gpio;
}
gpio_direction_output(info->pdata->gpio_rst, !info->pdata->enable_rst);
ret = regulator_bulk_get(&client->dev, ARRAY_SIZE(supplies), supplies);
if (ret) {
dev_err(&client->dev, "Failed to get regulators, %d\n", ret);
goto out_reg;
}
sd = &info->sd;
strlcpy(sd->name, MOD_NAME, sizeof(sd->name));
init_waitqueue_head(&info->cap_wait);
v4l2_i2c_subdev_init(sd, client, &m5mols_ops);
info->pad.flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
if (ret < 0)
goto out_reg;
m5mols_init_formats(sd, NULL);
sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
sd->flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
sd->internal_ops = &m5mols_v4l2_internal_ops;
sd->entity.ops = &m5mols_media_ops;
info->res_type = M5MOLS_RESTYPE_MONITOR;
v4l2_info(sd, "%s : m5mols driver probed success\n", __func__);
return 0;
out_reg:
regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
out_gpio:
gpio_free(info->pdata->gpio_rst);
kfree(info);
return ret;
}
static int __devinit csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
struct msm_cam_subdev_info sd_info;
struct intr_table_entry irq_req;
int rc = 0;
CDBG("%s:%d called\n", __func__, __LINE__);
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->subdev, &msm_csid_subdev_ops);
new_csid_dev->subdev.internal_ops = &msm_csid_internal_ops;
new_csid_dev->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->subdev.name,
ARRAY_SIZE(new_csid_dev->subdev.name), "msm_csid");
v4l2_set_subdevdata(&new_csid_dev->subdev, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->subdev);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node)
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
CDBG("%s device id %d\n", __func__, pdev->id);
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
sd_info.sdev_type = CSID_DEV;
sd_info.sd_index = pdev->id;
sd_info.irq_num = new_csid_dev->irq->start;
msm_cam_register_subdev_node(&new_csid_dev->subdev, &sd_info);
media_entity_init(&new_csid_dev->subdev.entity, 0, NULL, 0);
new_csid_dev->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->subdev.entity.group_id = CSID_DEV;
new_csid_dev->subdev.entity.name = pdev->name;
new_csid_dev->subdev.entity.revision =
new_csid_dev->subdev.devnode->num;
/* Request for this device irq from the camera server. If the
* IRQ Router is present on this target, the interrupt will be
* handled by the camera server and the interrupt service
* routine called. If the request_irq call returns ENXIO, then
* the IRQ Router hardware is not present on this target. We
* have to request for the irq ourselves and register the
* appropriate interrupt handler. */
irq_req.cam_hw_idx = MSM_CAM_HW_CSI0 + pdev->id;
irq_req.dev_name = "csid";
irq_req.irq_idx = CAMERA_SS_IRQ_2 + pdev->id;
irq_req.irq_num = new_csid_dev->irq->start;
irq_req.is_composite = 0;
irq_req.irq_trigger_type = IRQF_TRIGGER_RISING;
irq_req.num_hwcore = 1;
irq_req.subdev_list[0] = &new_csid_dev->subdev;
irq_req.data = (void *)new_csid_dev;
rc = msm_cam_server_request_irq(&irq_req);
if (rc == -ENXIO) {
/* IRQ Router hardware is not present on this hardware.
* Request for the IRQ and register the interrupt handler. */
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
} else if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s Error registering irq ", __func__);
goto csid_no_resource;
}
new_csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev);
return 0;
}
static int __devinit csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
uint32_t csi_vdd_voltage = 0;
int rc = 0;
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->msm_sd.sd, &msm_csid_subdev_ops);
v4l2_set_subdevdata(&new_csid_dev->msm_sd.sd, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->msm_sd.sd);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node) {
rc = of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
if (rc < 0) {
pr_err("%s:%d failed to read cell-index\n", __func__,
__LINE__);
goto csid_no_resource;
}
CDBG("%s device id %d\n", __func__, pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,csi-vdd-voltage", &csi_vdd_voltage);
if (rc < 0) {
pr_err("%s:%d failed to read qcom,csi-vdd-voltage\n",
__func__, __LINE__);
goto csid_no_resource;
}
CDBG("%s:%d reading mipi_csi_vdd is %d\n", __func__, __LINE__,
csi_vdd_voltage);
csid_vreg_info[0].min_voltage = csi_vdd_voltage;
csid_vreg_info[0].max_voltage = csi_vdd_voltage;
}
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
new_csid_dev->msm_sd.sd.internal_ops = &msm_csid_internal_ops;
new_csid_dev->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->msm_sd.sd.name,
ARRAY_SIZE(new_csid_dev->msm_sd.sd.name), "msm_csid");
media_entity_init(&new_csid_dev->msm_sd.sd.entity, 0, NULL, 0);
new_csid_dev->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_CSID;
new_csid_dev->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x5;
msm_sd_register(&new_csid_dev->msm_sd);
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s Error registering irq ", __func__);
goto csid_no_resource;
}
new_csid_dev->csid_state = CSID_POWER_DOWN;
/* LGE_CHANGE_S [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
wake_lock_init(&new_csid_dev->csid_wake_lock, WAKE_LOCK_SUSPEND, "csid_wake_lock");
/* LGE_CHANGE_E [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev);
return 0;
}
static int ap1302_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct ap1302_device *dev;
int ret;
unsigned int i;
dev_info(&client->dev, "ap1302 probe called.\n");
/* allocate device & init sub device */
dev = devm_kzalloc(&client->dev, sizeof(*dev), GFP_KERNEL);
if (!dev) {
dev_err(&client->dev, "%s: out of memory\n", __func__);
return -ENOMEM;
}
mutex_init(&dev->input_lock);
v4l2_i2c_subdev_init(&(dev->sd), client, &ap1302_ops);
ret = ap1302_request_firmware(&(dev->sd));
if (ret) {
dev_err(&client->dev, "Cannot request ap1302 firmware.\n");
goto out_free;
}
dev->regmap16 = devm_regmap_init_i2c(client, &ap1302_reg16_config);
if (IS_ERR(dev->regmap16)) {
ret = PTR_ERR(dev->regmap16);
dev_err(&client->dev,
"Failed to allocate 16bit register map: %d\n", ret);
return ret;
}
dev->regmap32 = devm_regmap_init_i2c(client, &ap1302_reg32_config);
if (IS_ERR(dev->regmap32)) {
ret = PTR_ERR(dev->regmap32);
dev_err(&client->dev,
"Failed to allocate 32bit register map: %d\n", ret);
return ret;
}
if (client->dev.platform_data) {
ret = ap1302_s_config(&dev->sd, 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->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
dev->cntx_res[CONTEXT_PREVIEW].res_num = ARRAY_SIZE(ap1302_preview_res);
dev->cntx_res[CONTEXT_PREVIEW].res_table = ap1302_preview_res;
dev->cntx_res[CONTEXT_SNAPSHOT].res_num =
ARRAY_SIZE(ap1302_snapshot_res);
dev->cntx_res[CONTEXT_SNAPSHOT].res_table = ap1302_snapshot_res;
dev->cntx_res[CONTEXT_VIDEO].res_num = ARRAY_SIZE(ap1302_video_res);
dev->cntx_res[CONTEXT_VIDEO].res_table = ap1302_video_res;
ret = v4l2_ctrl_handler_init(&dev->ctrl_handler, ARRAY_SIZE(ctrls));
if (ret) {
ap1302_remove(client);
return ret;
}
for (i = 0; i < ARRAY_SIZE(ctrls); i++)
v4l2_ctrl_new_custom(&dev->ctrl_handler, &ctrls[i], NULL);
if (dev->ctrl_handler.error) {
ap1302_remove(client);
return dev->ctrl_handler.error;
}
/* Use same lock for controls as for everything else. */
dev->ctrl_handler.lock = &dev->input_lock;
dev->sd.ctrl_handler = &dev->ctrl_handler;
v4l2_ctrl_handler_setup(&dev->ctrl_handler);
dev->run_mode = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_RUN_MODE);
v4l2_ctrl_s_ctrl(dev->run_mode, ATOMISP_RUN_MODE_PREVIEW);
ret = media_entity_init(&dev->sd.entity, 1, &dev->pad, 0);
if (ret)
ap1302_remove(client);
return ret;
out_free:
v4l2_device_unregister_subdev(&dev->sd);
return ret;
}
int camera_init_v4l2(struct device *dev, unsigned int *session)
{
struct msm_video_device *pvdev;
struct v4l2_device *v4l2_dev;
int rc = 0;
pvdev = kzalloc(sizeof(struct msm_video_device),
GFP_KERNEL);
if (WARN_ON(!pvdev)) {
rc = -ENOMEM;
goto init_end;
}
pvdev->vdev = video_device_alloc();
if (WARN_ON(!pvdev->vdev)) {
rc = -ENOMEM;
goto video_fail;
}
v4l2_dev = kzalloc(sizeof(struct v4l2_device), GFP_KERNEL);
if (WARN_ON(!v4l2_dev)) {
rc = -ENOMEM;
goto v4l2_fail;
}
#if defined(CONFIG_MEDIA_CONTROLLER)
v4l2_dev->mdev = kzalloc(sizeof(struct media_device),
GFP_KERNEL);
if (!v4l2_dev->mdev) {
rc = -ENOMEM;
goto mdev_fail;
}
strlcpy(v4l2_dev->mdev->model, MSM_CAMERA_NAME,
sizeof(v4l2_dev->mdev->model));
v4l2_dev->mdev->dev = dev;
rc = media_device_register(v4l2_dev->mdev);
if (WARN_ON(rc < 0))
goto media_fail;
rc = media_entity_init(&pvdev->vdev->entity, 0, NULL, 0);
if (WARN_ON(rc < 0))
goto entity_fail;
pvdev->vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
pvdev->vdev->entity.group_id = QCAMERA_VNODE_GROUP_ID;
#endif
v4l2_dev->notify = NULL;
pvdev->vdev->v4l2_dev = v4l2_dev;
rc = v4l2_device_register(dev, pvdev->vdev->v4l2_dev);
if (WARN_ON(rc < 0))
goto register_fail;
strlcpy(pvdev->vdev->name, "msm-sensor", sizeof(pvdev->vdev->name));
pvdev->vdev->release = video_device_release;
pvdev->vdev->fops = &camera_v4l2_fops;
pvdev->vdev->ioctl_ops = &camera_v4l2_ioctl_ops;
pvdev->vdev->minor = -1;
pvdev->vdev->vfl_type = VFL_TYPE_GRABBER;
rc = video_register_device(pvdev->vdev,
VFL_TYPE_GRABBER, -1);
if (WARN_ON(rc < 0))
goto video_register_fail;
#if defined(CONFIG_MEDIA_CONTROLLER)
/* FIXME: How to get rid of this messy? */
pvdev->vdev->entity.name = video_device_node_name(pvdev->vdev);
#endif
*session = pvdev->vdev->num;
atomic_set(&pvdev->opened, 0);
atomic_set(&pvdev->stream_cnt, 0);
video_set_drvdata(pvdev->vdev, pvdev);
goto init_end;
video_register_fail:
v4l2_device_unregister(pvdev->vdev->v4l2_dev);
register_fail:
#if defined(CONFIG_MEDIA_CONTROLLER)
media_entity_cleanup(&pvdev->vdev->entity);
entity_fail:
media_device_unregister(v4l2_dev->mdev);
media_fail:
kzfree(v4l2_dev->mdev);
mdev_fail:
#endif
kzfree(v4l2_dev);
v4l2_fail:
video_device_release(pvdev->vdev);
video_fail:
kzfree(pvdev);
init_end:
return rc;
}
static int32_t cam_dummy_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
const struct of_device_id *match;
struct msm_video_device *pvdev;
/* init_waitqueue_head(&cam_dummy_queue.state_wait);*/
pr_err("%s:%d\n", __func__, __LINE__);
match = of_match_device(cam_dummy_dt_match, &pdev->dev);
msm_v4l2_dev = kzalloc(sizeof(*msm_v4l2_dev),
GFP_KERNEL);
if (WARN_ON(!msm_v4l2_dev)) {
rc = -ENOMEM;
goto probe_end;
}
pvdev = kzalloc(sizeof(struct msm_video_device),
GFP_KERNEL);
if (WARN_ON(!pvdev)) {
rc = -ENOMEM;
goto pvdev_fail;
}
pvdev->vdev = video_device_alloc();
if (WARN_ON(!pvdev->vdev)) {
rc = -ENOMEM;
goto video_fail;
}
#if defined(CONFIG_MEDIA_CONTROLLER)
msm_v4l2_dev->mdev = kzalloc(sizeof(struct media_device),
GFP_KERNEL);
if (!msm_v4l2_dev->mdev) {
rc = -ENOMEM;
goto mdev_fail;
}
strlcpy(msm_v4l2_dev->mdev->model, MSM_CAMERA_DUMMY_NAME,
sizeof(msm_v4l2_dev->mdev->model));
msm_v4l2_dev->mdev->dev = &(pdev->dev);
rc = media_device_register(msm_v4l2_dev->mdev);
if (WARN_ON(rc < 0))
goto media_fail;
if (WARN_ON((rc == media_entity_init(&pvdev->vdev->entity,
0, NULL, 0)) < 0))
goto entity_fail;
pvdev->vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
pvdev->vdev->entity.group_id = QCAMERA_VNODE_GROUP_ID;
#endif
pvdev->vdev->v4l2_dev = msm_v4l2_dev;
rc = v4l2_device_register(&(pdev->dev), pvdev->vdev->v4l2_dev);
if (WARN_ON(rc < 0))
goto register_fail;
strlcpy(pvdev->vdev->name, "msm-camdummy", sizeof(pvdev->vdev->name));
pvdev->vdev->release = video_device_release;
pvdev->vdev->fops = &msm_fops_config;
#if defined CONFIG_SEC_CAMERA_TUNING
pvdev->vdev->ioctl_ops = &msm_v4l2_ioctl_ops;
#endif
pvdev->vdev->minor = -1;
pvdev->vdev->vfl_type = VFL_TYPE_GRABBER;
rc = video_register_device(pvdev->vdev,
VFL_TYPE_GRABBER, -1);
if (WARN_ON(rc < 0))
goto v4l2_fail;
#if defined(CONFIG_MEDIA_CONTROLLER)
/* FIXME: How to get rid of this messy? */
pvdev->vdev->entity.name = video_device_node_name(pvdev->vdev);
#endif
atomic_set(&pvdev->opened, 0);
video_set_drvdata(pvdev->vdev, pvdev);
goto probe_end;
v4l2_fail:
v4l2_device_unregister(pvdev->vdev->v4l2_dev);
register_fail:
#if defined(CONFIG_MEDIA_CONTROLLER)
media_entity_cleanup(&pvdev->vdev->entity);
entity_fail:
media_device_unregister(msm_v4l2_dev->mdev);
media_fail:
kzfree(msm_v4l2_dev->mdev);
mdev_fail:
#endif
video_device_release(pvdev->vdev);
video_fail:
kzfree(pvdev);
pvdev_fail:
kzfree(msm_v4l2_dev);
probe_end:
return rc;
}
static int msm_eeprom_platform_probe(struct platform_device *pdev)
{
int rc = 0;
int j = 0;
uint32_t temp;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_eeprom_board_info *eb_info = NULL;
struct device_node *of_node = pdev->dev.of_node;
struct msm_camera_power_ctrl_t *power_info = NULL;
CDBG("%s E\n", __func__);
e_ctrl = kzalloc(sizeof(*e_ctrl), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
e_ctrl->is_supported = 0;
if (!of_node) {
pr_err("%s dev.of_node NULL\n", __func__);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
e_ctrl->subdev_id = pdev->id;
rc = of_property_read_u32(of_node, "qcom,cci-master",
&e_ctrl->cci_master);
CDBG("qcom,cci-master %d, rc %d\n", e_ctrl->cci_master, rc);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
return rc;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr",
&temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
return rc;
}
/* Set platform device handle */
e_ctrl->pdev = pdev;
/* Set device type as platform device */
e_ctrl->eeprom_device_type = MSM_CAMERA_PLATFORM_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_cci_func_tbl;
e_ctrl->i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!e_ctrl->i2c_client.cci_client) {
pr_err("%s failed no memory\n", __func__);
return -ENOMEM;
}
e_ctrl->eboard_info = kzalloc(sizeof(
struct msm_eeprom_board_info), GFP_KERNEL);
if (!e_ctrl->eboard_info) {
pr_err("%s failed line %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto cciclient_free;
}
eb_info = e_ctrl->eboard_info;
power_info = &eb_info->power_info;
eb_info->i2c_slaveaddr = temp;
power_info->clk_info = cam_8974_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info);
power_info->dev = &pdev->dev;
CDBG("qcom,slave-addr = 0x%X\n", eb_info->i2c_slaveaddr);
cci_client = e_ctrl->i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = e_ctrl->cci_master;
cci_client->sid = eb_info->i2c_slaveaddr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
rc = of_property_read_string(of_node, "qcom,eeprom-name",
&eb_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
eb_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
rc = msm_eeprom_parse_memory_map(of_node, "cal", &e_ctrl->cal_data);
if (rc < 0)
goto board_free;
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memdata_free;
}
rc = read_eeprom_memory(e_ctrl, &e_ctrl->cal_data);
if (rc < 0) {
pr_err("%s read_eeprom_memory failed\n", __func__);
goto power_down;
}
for (j = 0; j < e_ctrl->cal_data.num_data; j++)
CDBG("memory_data[%d] = 0x%X\n", j,
e_ctrl->cal_data.mapdata[j]);
e_ctrl->is_supported |= msm_eeprom_match_crc(&e_ctrl->cal_data);
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memdata_free;
}
v4l2_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
platform_set_drvdata(pdev, &e_ctrl->msm_sd.sd);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(e_ctrl->msm_sd.sd.name,
ARRAY_SIZE(e_ctrl->msm_sd.sd.name), "msm_eeprom");
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = (e_ctrl->is_supported << 1) | 1;
CDBG("%s X\n", __func__);
return rc;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memdata_free:
kfree(e_ctrl->cal_data.mapdata);
kfree(e_ctrl->cal_data.map);
board_free:
kfree(e_ctrl->eboard_info);
cciclient_free:
kfree(e_ctrl->i2c_client.cci_client);
kfree(e_ctrl);
return rc;
}
int gsc_register_capture_device(struct gsc_dev *gsc)
{
struct video_device *vfd;
struct gsc_capture_device *gsc_cap;
struct gsc_ctx *ctx;
struct vb2_queue *q;
int ret = -ENOMEM;
ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
if (!ctx)
return -ENOMEM;
ctx->gsc_dev = gsc;
ctx->in_path = GSC_WRITEBACK;
ctx->out_path = GSC_DMA;
ctx->state = GSC_CTX_CAP;
vfd = video_device_alloc();
if (!vfd) {
printk("Failed to allocate video device\n");
goto err_ctx_alloc;
}
snprintf(vfd->name, sizeof(vfd->name), "%s.capture",
dev_name(&gsc->pdev->dev));
vfd->fops = &gsc_capture_fops;
vfd->ioctl_ops = &gsc_capture_ioctl_ops;
vfd->v4l2_dev = &gsc->mdev[MDEV_CAPTURE]->v4l2_dev;
vfd->minor = -1;
vfd->release = video_device_release;
vfd->lock = &gsc->lock;
vfd->vfl_dir = VFL_DIR_RX;
video_set_drvdata(vfd, gsc);
gsc_cap = &gsc->cap;
gsc_cap->vfd = vfd;
gsc_cap->refcnt = 0;
gsc_cap->active_buf_cnt = 0;
gsc_cap->reqbufs_cnt = 0;
INIT_LIST_HEAD(&gsc->cap.active_buf_q);
spin_lock_init(&ctx->slock);
gsc_cap->ctx = ctx;
q = &gsc->cap.vbq;
memset(q, 0, sizeof(*q));
q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
q->drv_priv = gsc->cap.ctx;
q->ops = &gsc_capture_qops;
q->mem_ops = gsc->vb2->ops;
q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;
ret = vb2_queue_init(q);
if (ret) {
gsc_err("failed to init vb2_queue");
goto err_ctx_alloc;
}
ret = video_register_device(vfd, VFL_TYPE_GRABBER,
EXYNOS_VIDEONODE_GSC_CAP(gsc->id));
if (ret) {
gsc_err("failed to register video device");
goto err_ctx_alloc;
}
gsc->cap.vd_pad.flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&vfd->entity, 1, &gsc->cap.vd_pad, 0);
if (ret) {
gsc_err("failed to initialize entity");
goto err_ent;
}
ret = gsc_capture_create_subdev(gsc);
if (ret) {
gsc_err("failed create subdev");
goto err_sd_reg;
}
ret = gsc_capture_create_link(gsc);
if (ret) {
gsc_err("failed create link");
goto err_sd_reg;
}
vfd->ctrl_handler = &ctx->ctrl_handler;
gsc_info("gsc capture driver registered as /dev/video%d", vfd->num);
return 0;
err_sd_reg:
media_entity_cleanup(&vfd->entity);
err_ent:
video_device_release(vfd);
err_ctx_alloc:
kfree(ctx);
return ret;
}
static int msm_eeprom_spi_setup(struct spi_device *spi)
{
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_i2c_client *client = NULL;
struct msm_camera_spi_client *spi_client;
struct msm_eeprom_board_info *eb_info;
struct msm_camera_power_ctrl_t *power_info = NULL;
int rc = 0;
e_ctrl = kzalloc(sizeof(*e_ctrl), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
client = &e_ctrl->i2c_client;
e_ctrl->is_supported = 0;
spi_client = kzalloc(sizeof(*spi_client), GFP_KERNEL);
if (!spi_client) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
kfree(e_ctrl);
return -ENOMEM;
}
rc = of_property_read_u32(spi->dev.of_node, "cell-index",
&e_ctrl->subdev_id);
CDBG("cell-index %d, rc %d\n", e_ctrl->subdev_id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
goto spi_free;
}
e_ctrl->eeprom_device_type = MSM_CAMERA_SPI_DEVICE;
client->spi_client = spi_client;
spi_client->spi_master = spi;
client->i2c_func_tbl = &msm_eeprom_spi_func_tbl;
client->addr_type = MSM_CAMERA_I2C_3B_ADDR;
eb_info = kzalloc(sizeof(*eb_info), GFP_KERNEL);
if (!eb_info) {
pr_err("%s : eb_info is NULL", __func__);
goto spi_free;
}
e_ctrl->eboard_info = eb_info;
rc = of_property_read_string(spi->dev.of_node, "qcom,eeprom-name",
&eb_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
eb_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
power_info = &eb_info->power_info;
power_info->clk_info = cam_8974_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info);
power_info->dev = &spi->dev;
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc < 0) {
pr_err("%s : msm_eeprom_get_dt_data", __func__);
goto board_free;
}
/* set spi instruction info */
spi_client->retry_delay = 1;
spi_client->retries = 0;
rc = msm_eeprom_spi_parse_of(spi_client);
if (rc < 0) {
dev_err(&spi->dev,
"%s: Error parsing device properties\n", __func__);
goto board_free;
}
/* prepare memory buffer */
rc = msm_eeprom_parse_memory_map(spi->dev.of_node, "cal",
&e_ctrl->cal_data);
if (rc < 0)
pr_warn("%s: no cal memory map\n", __func__);
/* power up eeprom for reading */
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
goto caldata_free;
}
/* check eeprom id */
rc = msm_eeprom_match_id(e_ctrl);
if (rc < 0) {
pr_err("%s: eeprom not matching %d\n", __func__, rc);
goto power_down;
}
/* read eeprom */
if (e_ctrl->cal_data.map) {
rc = read_eeprom_memory(e_ctrl, &e_ctrl->cal_data);
if (rc < 0) {
pr_err("%s: read cal data failed\n", __func__);
goto power_down;
}
e_ctrl->is_supported |= msm_eeprom_match_crc(
&e_ctrl->cal_data);
}
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
goto caldata_free;
}
/* initiazlie subdev */
v4l2_spi_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.spi_client->spi_master,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = (e_ctrl->is_supported << 1) | 1;
pr_warn("%s success result=%d supported=%x X\n", __func__, rc,
e_ctrl->is_supported);
return 0;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
caldata_free:
kfree(e_ctrl->cal_data.mapdata);
kfree(e_ctrl->cal_data.map);
board_free:
kfree(e_ctrl->eboard_info);
spi_free:
kfree(spi_client);
kfree(e_ctrl);
return rc;
}
static int __devinit ak7343_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = -1;
unsigned long vcmid;
int pwdn = 0;
struct ak7343 *vcm;
struct vcm_platform_data *pdata = client->dev.platform_data;
vcm = kzalloc(sizeof(struct ak7343), GFP_KERNEL);
if (!vcm) {
dev_err(&client->dev, "ak7343: failed to allocate ak7343 struct\n");
return -ENOMEM;
}
if (!pdata)
return -EIO;
if (pdata->power_domain) {
vcm->af_vcc = regulator_get(&client->dev,
pdata->power_domain);
if (IS_ERR(vcm->af_vcc))
goto out_af_vcc;
vcm_power(vcm, 1);
}
if (pdata->pwdn_gpio) {
vcm->pwdn_gpio = pdata->pwdn_gpio;
if (gpio_request(vcm->pwdn_gpio, "VCM_ENABLE_LOW")) {
printk(KERN_ERR "VCM:can't get the gpio resource!\n");
ret = -EIO;
goto out_gpio;
}
pwdn = gpio_get_value(vcm->pwdn_gpio);
gpio_direction_output(vcm->pwdn_gpio, pdata->pwdn_en);
}
mdelay(20);
if (ak7343_read(client, 0x00, &vcmid)) {
printk(KERN_ERR "VCM: ak7343 vcm detect failure!\n");
goto out_pwdn;
}
if (vcm->pwdn_gpio) {
gpio_direction_output(vcm->pwdn_gpio, pwdn);
gpio_free(vcm->pwdn_gpio);
}
if (vcm->af_vcc)
vcm_power(vcm, 0);
v4l2_i2c_subdev_init(&vcm->subdev, client, &ak7343_ops);
vcm->subdev.internal_ops = &ak7343_v4l2_internal_ops;
vcm->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
ret = ak7343_init_controls(vcm);
if (ret < 0)
goto out;
ret = media_entity_init(&vcm->subdev.entity, 0, NULL, 0);
if (ret < 0)
goto out;
v4l2_ctrl_handler_setup(&vcm->ctrls);
printk(KERN_INFO "ak7343 detected!\n");
return 0;
out:
v4l2_ctrl_handler_free(&vcm->ctrls);
out_pwdn:
if (vcm->pwdn_gpio) {
gpio_direction_output(vcm->pwdn_gpio, pwdn);
gpio_free(vcm->pwdn_gpio);
}
out_gpio:
if (vcm->af_vcc)
vcm_power(vcm, 0);
out_af_vcc:
regulator_put(vcm->af_vcc);
vcm->af_vcc = NULL;
kfree(vcm);
return ret;
}
int32_t msm_eeprom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id) {
int rc = 0;
int32_t j = 0;
uint32_t temp = 0;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
struct device_node *of_node = client->dev.of_node;
CDBG("%s E\n", __func__);
if (!of_node) {
pr_err("%s of_node NULL\n", __func__);
return -EINVAL;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s i2c_check_functionality failed\n", __func__);
goto probe_failure;
}
e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
CDBG("%s client = %x\n", __func__, (unsigned int)client);
e_ctrl->eboard_info = kzalloc(sizeof(
struct msm_eeprom_board_info), GFP_KERNEL);
if (!e_ctrl->eboard_info) {
pr_err("%s:%d board info NULL\n", __func__, __LINE__);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr", &temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
return rc;
}
power_info = &e_ctrl->eboard_info->power_info;
e_ctrl->eboard_info->i2c_slaveaddr = temp;
e_ctrl->i2c_client.client = client;
e_ctrl->is_supported = 0;
/* Set device type as I2C */
e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_qup_func_tbl;
if (e_ctrl->eboard_info->i2c_slaveaddr != 0)
e_ctrl->i2c_client.client->addr =
e_ctrl->eboard_info->i2c_slaveaddr;
power_info->clk_info = cam_8960_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8960_clk_info);
power_info->dev = &client->dev;
rc = of_property_read_string(of_node, "qcom,eeprom-name",
&e_ctrl->eboard_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
e_ctrl->eboard_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node);
if (rc)
goto board_free;
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("%s failed power up %d\n", __func__, __LINE__);
goto memdata_free;
}
rc = read_eeprom_memory(e_ctrl);
if (rc < 0) {
pr_err("%s read_eeprom_memory failed\n", __func__);
goto power_down;
}
for (j = 0; j < e_ctrl->num_bytes; j++)
CDBG("memory_data[%d] = 0x%X\n", j, e_ctrl->memory_data[j]);
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto power_down;
}
/*IMPLEMENT READING PART*/
/* Initialize sub device */
v4l2_i2c_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.client,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = 1;
CDBG("%s success result=%d X\n", __func__, rc);
return rc;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memdata_free:
kfree(e_ctrl->memory_data);
kfree(e_ctrl->eboard_info->eeprom_map);
board_free:
kfree(e_ctrl->eboard_info);
probe_failure:
pr_err("%s failed! rc = %d\n", __func__, rc);
return rc;
}
static int __devinit m5mols_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
const struct m5mols_platform_data *pdata = client->dev.platform_data;
struct m5mols_info *info;
struct v4l2_subdev *sd;
int ret;
if (pdata == NULL) {
dev_err(&client->dev, "No platform data\n");
return -EINVAL;
}
if (!gpio_is_valid(pdata->gpio_reset)) {
dev_err(&client->dev, "No valid RESET GPIO specified\n");
return -EINVAL;
}
if (!client->irq) {
dev_err(&client->dev, "Interrupt not assigned\n");
return -EINVAL;
}
info = kzalloc(sizeof(struct m5mols_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->pdata = pdata;
info->set_power = pdata->set_power;
ret = gpio_request(pdata->gpio_reset, "M5MOLS_NRST");
if (ret) {
dev_err(&client->dev, "Failed to request gpio: %d\n", ret);
goto out_free;
}
gpio_direction_output(pdata->gpio_reset, pdata->reset_polarity);
ret = regulator_bulk_get(&client->dev, ARRAY_SIZE(supplies), supplies);
if (ret) {
dev_err(&client->dev, "Failed to get regulators: %d\n", ret);
goto out_gpio;
}
sd = &info->sd;
v4l2_i2c_subdev_init(sd, client, &m5mols_ops);
strlcpy(sd->name, MODULE_NAME, sizeof(sd->name));
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
sd->internal_ops = &m5mols_subdev_internal_ops;
info->pad.flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
if (ret < 0)
goto out_reg;
sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
init_waitqueue_head(&info->irq_waitq);
ret = request_irq(client->irq, m5mols_irq_handler,
IRQF_TRIGGER_RISING, MODULE_NAME, sd);
if (ret) {
dev_err(&client->dev, "Interrupt request failed: %d\n", ret);
goto out_me;
}
info->res_type = M5MOLS_RESTYPE_MONITOR;
info->ffmt[0] = m5mols_default_ffmt[0];
info->ffmt[1] = m5mols_default_ffmt[1];
ret = m5mols_sensor_power(info, true);
if (ret)
goto out_me;
ret = m5mols_fw_start(sd);
if (!ret)
ret = m5mols_init_controls(info);
m5mols_sensor_power(info, false);
if (!ret)
return 0;
out_me:
media_entity_cleanup(&sd->entity);
out_reg:
regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
out_gpio:
gpio_free(pdata->gpio_reset);
out_free:
kfree(info);
return ret;
}
