ret = of_property_read_u32(dnode, "scenario", &pdata->scenario);
if (ret) {
- err("scenario read is fail(%d)", ret);
+ err("scenario read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "mclk_ch", &pdata->mclk_ch);
if (ret) {
- err("mclk_ch read is fail(%d)", ret);
+ err("mclk_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "csi_ch", &pdata->csi_ch);
if (ret) {
- err("csi_ch read is fail(%d)", ret);
+ err("csi_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "flite_ch", &pdata->flite_ch);
if (ret) {
- err("flite_ch read is fail(%d)", ret);
+ err("flite_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "i2c_ch", &pdata->i2c_ch);
if (ret) {
- err("i2c_ch read is fail(%d)", ret);
+ err("i2c_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "i2c_addr", &pdata->i2c_addr);
if (ret) {
- err("i2c_addr read is fail(%d)", ret);
+ err("i2c_addr read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "is_bns", &pdata->is_bns);
if (ret) {
- err("is_bns read is fail(%d)", ret);
+ err("is_bns read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "id", &id);
if (ret) {
- err("id read is fail(%d)", ret);
+ err("id read failed(%d)", ret);
goto p_err;
}
pdata->id = id;
ret = of_property_read_string(dnode, "sensor_name", &name);
if (ret) {
- err("sensor_name read is fail(%d)", ret);
+ err("sensor_name read failed(%d)", ret);
goto p_err;
}
strcpy(pdata->sensor_name, name);
ret = of_property_read_u32(dnode, "sensor_id", &pdata->sensor_id);
if (ret) {
- err("sensor_id read is fail(%d)", ret);
+ err("sensor_id read failed(%d)", ret);
goto p_err;
}
pdata->pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(pdata->pinctrl)) {
- err("devm_pinctrl_get is fail");
+ err("devm_pinctrl_get failed");
goto p_err;
} else {
ret = get_pin_lookup_state(dev, pdata);
if (ret < 0) {
- err("fimc_is_get_pin_lookup_state is fail");
+ err("fimc_is_get_pin_lookup_state failed");
goto p_err;
}
}
ret = of_property_read_u32(dnode, "scenario", &pdata->scenario);
if (ret) {
- err("scenario read is fail(%d)", ret);
+ err("scenario read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "mclk_ch", &pdata->mclk_ch);
if (ret) {
- err("mclk_ch read is fail(%d)", ret);
+ err("mclk_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "sensor_id", &pdata->sensor_id);
if (ret) {
- err("sensor_id read is fail(%d)", ret);
+ err("sensor_id read failed(%d)", ret);
goto p_err;
}
pdata->pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(pdata->pinctrl)) {
- err("devm_pinctrl_get is fail");
+ err("devm_pinctrl_get failed");
goto p_err;
} else {
ret = get_pin_lookup_state(dev, pdata);
if (ret < 0) {
- err("fimc_is_get_pin_lookup_state is fail");
+ err("fimc_is_get_pin_lookup_state failed");
goto p_err;
}
}
checksum = result_data << 16 | temp_data;
if (checksum != from_checksum) {
- err("[%s] CRC check is failed. Checksum = 0x%08x, FROM checksum = 0x%08x\n",
+ err("[%s] CRC check failed. Checksum = 0x%08x, FROM checksum = 0x%08x\n",
name, checksum, from_checksum);
return -EIO;
}
}
if (ret) {
- err("request_firmware is fail(ret:%d)", ret);
+ err("request_firmware failed: %d", ret);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_mem_probe(&core->mem, core->pdev);
if (ret) {
- err("fimc_is_mem_probe is fail(%d)", ret);
+ err("fimc_is_mem_probe failed(%d)", ret);
goto p_err3;
}
#if defined(CONFIG_CAMERA_SENSOR_6D1_OBJ)
ret = sensor_6d1_probe(NULL, NULL);
if (ret) {
- err("sensor_6d1_probe is fail(%d)", ret);
+ err("sensor_6d1_probe failed(%d)", ret);
goto p_err3;
}
#endif
#if defined(CONFIG_CAMERA_SENSOR_IMX240_OBJ)
ret = sensor_imx240_probe(NULL, NULL);
if (ret) {
- err("sensor_imx175_probe is fail(%d)", ret);
+ err("sensor_imx175_probe failed(%d)", ret);
goto p_err3;
}
#endif
ret = fimc_is_ishcain_initmem(core);
if (ret) {
- err("fimc_is_ishcain_initmem is fail(%d)", ret);
+ err("fimc_is_ishcain_initmem failed(%d)", ret);
goto p_err4;
}
ret = pdata->mclk_on(pdev, pdata->scenario, pdata->mclk_ch);
if (ret) {
- err("mclk_on is fail(%d)", ret);
+ err("mclk_on failed(%d)", ret);
goto p_err;
}
ret = pdata->mclk_off(pdev, pdata->scenario, pdata->mclk_ch);
if (ret) {
- err("mclk_off is fail(%d)", ret);
+ err("mclk_off failed(%d)", ret);
goto p_err;
}
ret = pdata->iclk_cfg(pdev, pdata->scenario, 0);
if (ret) {
- err("iclk_cfg is fail(%d)", ret);
+ err("iclk_cfg failed(%d)", ret);
goto p_err;
}
ret = pdata->iclk_on(pdev, pdata->scenario, 0);
if (ret) {
- err("iclk_on is fail(%d)", ret);
+ err("iclk_on failed(%d)", ret);
goto p_err;
}
ret = pdata->iclk_off(pdev, pdata->scenario, 0);
if (ret) {
- err("iclk_off is fail(%d)", ret);
+ err("iclk_off failed(%d)", ret);
goto p_err;
}
ret = pdata->gpio_cfg(device->pdev, pdata->scenario, GPIO_SCENARIO_ON);
if (ret) {
- err("gpio_cfg is fail(%d)", ret);
+ err("gpio_cfg failed(%d)", ret);
goto p_err;
}
ret = pdata->gpio_cfg(device->pdev, pdata->scenario, GPIO_SCENARIO_OFF);
if (ret) {
- err("gpio_cfg is fail(%d)", ret);
+ err("gpio_cfg failed(%d)", ret);
goto p_err;
}
ret = fimc_is_companion_parse_dt(pdev);
if (ret) {
- err("parsing device tree is fail(%d)", ret);
+ err("parsing device tree failed(%d)", ret);
goto p_err;
}
ret = v4l2_device_register(&pdev->dev, &device->v4l2_dev);
if (ret) {
- err("v4l2_device_register is fail(%d)", ret);
+ err("v4l2_device_register failed(%d)", ret);
goto p_err;
}
ret = fimc_is_comp_video_probe(device);
if (ret) {
- err("fimc_is_companion_video_probe is fail(%d)", ret);
+ err("fimc_is_companion_video_probe failed(%d)", ret);
goto p_err;
}
/* gpio uninit */
ret = fimc_is_companion_gpio_off(device);
if (ret) {
- err("fimc_is_companion_gpio_off is fail(%d)", ret);
+ err("fimc_is_companion_gpio_off failed(%d)", ret);
goto p_err;
}
/* periperal internal clock off */
ret = fimc_is_companion_iclk_off(device);
if (ret) {
- err("fimc_is_companion_iclk_off is fail(%d)", ret);
+ err("fimc_is_companion_iclk_off failed(%d)", ret);
goto p_err;
}
/* companion clock off */
ret = fimc_is_companion_mclk_off(device);
if (ret) {
- err("fimc_is_companion_mclk_off is fail(%d)", ret);
+ err("fimc_is_companion_mclk_off failed(%d)", ret);
goto p_err;
}
/* Sensor clock on */
ret = fimc_is_companion_mclk_on(device);
if (ret) {
- err("fimc_is_companion_mclk_on is fail(%d)", ret);
+ err("fimc_is_companion_mclk_on failed(%d)", ret);
goto p_err;
}
/* gpio init */
ret = fimc_is_companion_gpio_on(device);
if (ret) {
- err("fimc_is_companion_gpio_on is fail(%d)", ret);
+ err("fimc_is_companion_gpio_on failed(%d)", ret);
goto p_err;
}
/* periperal internal clock on */
ret = fimc_is_companion_iclk_on(device);
if (ret) {
- err("fimc_is_companion_iclk_on is fail(%d)", ret);
+ err("fimc_is_companion_iclk_on failed(%d)", ret);
goto p_err;
}
p_err:
#include "fimc-is-device-csi.h"
#include "fimc-is-device-sensor.h"
#include "fimc-is-core.h"
+
static u32 get_hsync_settle(struct fimc_is_sensor_cfg *cfg,
const u32 cfgs, u32 width, u32 height, u32 framerate)
{
if (enable) {
ret = csi_stream_on(csi);
if (ret) {
- err("csi_stream_on is fail(%d)", ret);
+ err("csi_stream_on failed(%d)", ret);
goto p_err;
}
} else {
ret = csi_stream_off(csi);
if (ret) {
- err("csi_stream_off is fail(%d)", ret);
+ err("csi_stream_off failed(%d)", ret);
goto p_err;
}
}
snprintf(subdev_csi->name, V4L2_SUBDEV_NAME_SIZE, "csi-subdev.%d", instance);
ret = v4l2_device_register_subdev(&device->v4l2_dev, subdev_csi);
if (ret) {
- merr("v4l2_device_register_subdev is fail(%d)", device, ret);
+ merr("v4l2_device_register_subdev failed(%d)", device, ret);
goto p_err_free2;
}
if (enable) {
ret = flite_stream_on(subdev, flite);
if (ret) {
- err("flite_stream_on is fail(%d)", ret);
+ err("flite_stream_on failed(%d)", ret);
goto p_err;
}
} else {
ret = flite_stream_off(subdev, flite, nowait);
if (ret) {
- err("flite_stream_off is fail(%d)", ret);
+ err("flite_stream_off failed(%d)", ret);
goto p_err;
}
}
snprintf(subdev_flite->name, V4L2_SUBDEV_NAME_SIZE, "flite-subdev.%d", instance);
ret = v4l2_device_register_subdev(&device->v4l2_dev, subdev_flite);
if (ret) {
- merr("v4l2_device_register_subdev is fail(%d)", device, ret);
+ merr("v4l2_device_register_subdev failed(%d)", device, ret);
goto err_reg_v4l2_subdev;
}
}
if (ret) {
- err("request_firmware is fail(%d)", ret);
+ err("request_firmware failed(%d)", ret);
ret = -EINVAL;
goto out;
}
}
}
if (ret)
- err("firmware loading is fail");
+ err("firmware loading failed");
else
info("Camera: the %s FW were applied successfully.\n",
((cam_id == CAMERA_SINGLE_REAR) &&
ret = request_firmware((const struct firmware **)&fw_blob,
setfile_name, &device->pdev->dev);
while (--retry && ret) {
- mwarn("request_firmware is fail(%d)", device, ret);
+ mwarn("request_firmware failed(%d)", device, ret);
ret = request_firmware((const struct firmware **)&fw_blob,
setfile_name, &device->pdev->dev);
}
if (!retry) {
- merr("request_firmware is fail(%d)", device, ret);
+ merr("request_firmware failed(%d)", device, ret);
ret = -EINVAL;
goto out;
}
}
if (ret)
- err("setfile loading is fail");
+ err("setfile loading failed");
else
info("Camera: the %s Setfile were applied successfully.\n",
((cam_id == CAMERA_SINGLE_REAR) &&
fimc_is_ischain_cache_flush(device, FIMC_IS_CAL_START_ADDR,
FIMC_IS_MAX_CAL_SIZE);
if (ret)
- mwarn("calibration loading is fail", device);
+ mwarn("calibration loading failed", device);
else
mwarn("calibration loading is success", device);
return ret;
exynos_smc_readsfr(PA_FIMC_IS_GIC_C + 0x4, &debug);
info("%s : PA_FIMC_IS_GIC_C : 0x%08x\n", __func__, debug);
if (debug == 0x00)
- merr("secure configuration is fail[0x131E0004:%08X]", device, debug);
+ merr("secure configuration failed[0x131E0004:%08X]", device, debug);
/* To guarantee FW restart */
regmap_read(core->pmu_regmap, PMUREG_ISP_ARM_STATUS, &val);
if (frame) {
if (!test_bit(FIMC_IS_ISHCAIN_START, &device->state)) {
- merr("s_param is fail, device already is stopped", device);
+ merr("s_param failed, device already is stopped", device);
BUG();
}
* this check code is commented until per-frame control is worked fully
*
* if ( test_bit(FIMC_IS_ISHCAIN_START, &device->state)) {
- * merr("s_param is fail, device already is started", device);
+ * merr("s_param failed, device already is started", device);
* BUG();
* }
*/
if (frame) {
if (!test_bit(FIMC_IS_ISHCAIN_START, &device->state)) {
- merr("s_param is fail, device already is stopped", device);
+ merr("s_param failed, device already is stopped", device);
BUG();
}
ret = fimc_is_hw_enum(device->interface);
if (ret) {
- merr("fimc_is_itf_enum is fail(%d)", device, ret);
+ merr("fimc_is_itf_enum failed(%d)", device, ret);
CALL_POPS(device, print_pwr, device->pdev);
CALL_POPS(device, print_clk, device->pdev);
}
&device->margin_width,
&device->margin_height);
if (ret) {
- merr("fimc_is_hw_open is fail", device);
+ merr("fimc_is_hw_open failed", device);
CALL_POPS(device, print_cfg, device->pdev,
fimc_is_sensor_g_instance(device->sensor));
ret = -EINVAL;
ret = fimc_is_hw_close(itf, device->instance);
if (ret) {
- merr("fimc_is_hw_close is fail", device);
+ merr("fimc_is_hw_close failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_hw_saddr(itf, device->instance, &setfile_addr);
if (ret) {
- merr("fimc_is_hw_saddr is fail(%d)", device, ret);
+ merr("fimc_is_hw_saddr failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_ischain_loadsetf(device, setfile_addr, setfile_name);
if (ret) {
- merr("fimc_is_ischain_loadsetf is fail(%d)", device, ret);
+ merr("fimc_is_ischain_loadsetf failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_hw_setfile(itf, device->instance);
if (ret) {
- merr("fimc_is_hw_setfile is fail(%d)", device, ret);
+ merr("fimc_is_hw_setfile failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_hw_map(device->interface, device->instance, group, shot_addr, shot_size);
if (ret)
- merr("fimc_is_hw_map is fail(%d)", device, ret);
+ merr("fimc_is_hw_map failed(%d)", device, ret);
return ret;
}
ret = fimc_is_hw_unmap(device->interface, device->instance, group);
if (ret)
- merr("fimc_is_hw_unmap is fail(%d)", device, ret);
+ merr("fimc_is_hw_unmap failed(%d)", device, ret);
return ret;
}
ret = fimc_is_hw_stream_on(device->interface, device->instance);
if (ret) {
- merr("fimc_is_hw_stream_on is fail(%d)", device, ret);
+ merr("fimc_is_hw_stream_on failed(%d)", device, ret);
CALL_POPS(device, print_clk, device->pdev);
}
/* 1. init memory */
ret = fimc_is_ishcain_initmem(device);
if (ret) {
- err("fimc_is_ishcain_initmem is fail(%d)\n", ret);
+ err("fimc_is_ishcain_initmem failed(%d)\n", ret);
goto p_err;
}
}
/* for mediaserver force close */
ret = fimc_is_resource_get(device->resourcemgr, RESOURCE_TYPE_ISCHAIN);
if (ret) {
- merr("fimc_is_resource_get is fail", device);
+ merr("fimc_is_resource_get failed", device);
goto p_err;
}
/* 1. Stop all request */
ret = fimc_is_ischain_isp_stop(device, leader, queue);
if (ret)
- merr("fimc_is_ischain_isp_stop is fail", device);
+ merr("fimc_is_ischain_isp_stop failed", device);
/* group close */
ret = fimc_is_group_close(groupmgr, group);
if (ret)
- merr("fimc_is_group_close is fail", device);
+ merr("fimc_is_group_close failed", device);
/* subdev close */
fimc_is_subdev_close(&device->drc);
if (test_bit(FIMC_IS_ISCHAIN_OPEN_SENSOR, &device->state)) {
ret = fimc_is_itf_close(device);
if (ret)
- merr("fimc_is_itf_close is fail", device);
+ merr("fimc_is_itf_close failed", device);
if(device->sensor->pdata->is_softlanding)
fimc_is_sensor_gpio_off_softlanding(device->sensor);
/* for mediaserver force close */
ret = fimc_is_resource_put(device->resourcemgr, RESOURCE_TYPE_ISCHAIN);
if (ret) {
- merr("fimc_is_resource_put is fail", device);
+ merr("fimc_is_resource_put failed", device);
goto exit;
}
ret = fimc_is_sensor_g_module(sensor, &module);
if (ret) {
- merr("fimc_is_sensor_g_module is fail(%d)", device, ret);
+ merr("fimc_is_sensor_g_module failed(%d)", device, ret);
goto p_err;
}
if (module->id != module_id) {
ret = fimc_is_itf_init_process_stop(device);
if (ret) {
- merr("fimc_is_itf_init_process_stop is fail", device);
+ merr("fimc_is_itf_init_process_stop failed", device);
goto p_err;
}
/* 5. init ischain */
ret = fimc_is_ischain_init(device, module, group_id, tax_vindex, flag);
if (ret)
- merr("fimc_is_device_init(%d, %d, %d) is fail", device, module, group_id, rep_stream);
+ merr("fimc_is_device_init(%d, %d, %d) failed", device, module, group_id, rep_stream);
p_err:
return ret;
group_isp = &device->group_isp;
if (group_isp->smp_shot.count < 1) {
- mwarn("group%d is working(%d), setfile change is fail",
+ mwarn("group%d is working(%d), setfile change failed",
device, group_isp->id, group_isp->smp_shot.count);
goto p_err;
}
ret = fimc_is_itf_a_param(device, group_id);
if (ret) {
- merr("fimc_is_itf_a_param is fail", device);
+ merr("fimc_is_itf_a_param failed", device);
device->setfile = save_setfile;
ret = -EINVAL;
goto p_err;
ret = fimc_is_itf_s_param(this, indexes, lindex, hindex);
if (ret) {
- err("fimc_is_itf_s_param is fail\n");
+ err("fimc_is_itf_s_param failed\n");
ret = -EINVAL;
goto exit;
}
ret = fimc_is_itf_process_stop(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", device);
+ merr("fimc_is_itf_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_s_param(device, NULL, lindex, hindex, indexes);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, frame, ret);
goto p_err;
}
ret = fimc_is_itf_a_param(device, group_id);
if (ret) {
- merr("fimc_is_itf_a_param is fail", device);
+ merr("fimc_is_itf_a_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_start(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_start is fail", device);
+ merr("fimc_is_itf_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, frame, lindex, hindex, indexes);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, frame, ret);
goto p_err;
}
ret = fimc_is_itf_process_stop(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", device);
+ merr("fimc_is_itf_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_s_param(device, NULL, lindex, hindex, indexes);
if (ret) {
- merr("fimc_is_itf_s_param is fail", device);
+ merr("fimc_is_itf_s_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_start(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_start is fail", device);
+ merr("fimc_is_itf_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
device,
fimc_is_ischain_3aa_callback);
if (ret)
- merr("fimc_is_group_open is fail", device);
+ merr("fimc_is_group_open failed", device);
return ret;
}
ret = fimc_is_ischain_3aa_stop(device, leader, queue);
if (ret)
- merr("fimc_is_ischain_3aa_stop is fail", device);
+ merr("fimc_is_ischain_3aa_stop failed", device);
ret = fimc_is_group_close(groupmgr, group);
if (ret)
- merr("fimc_is_group_close is fail", device);
+ merr("fimc_is_group_close failed", device);
return ret;
}
ret = fimc_is_group_process_start(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_start is fail", device);
+ merr("fimc_is_group_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_process_stop(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_stop is fail", device);
+ merr("fimc_is_group_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
if (!count) {
ret = fimc_is_itf_unmap(device, GROUP_ID(group->id));
if (ret)
- merr("fimc_is_itf_unmap is fail(%d)", device, ret);
+ merr("fimc_is_itf_unmap failed(%d)", device, ret);
}
return ret;
ret = fimc_is_group_init(groupmgr, group, otf_input, 0);
if (ret) {
- merr("fimc_is_group_init is fail", device);
+ merr("fimc_is_group_init failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_buffer_queue(groupmgr, group, queue, index);
if (ret)
- merr("fimc_is_group_buffer_queue is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_queue failed(%d)", device, ret);
return ret;
}
ret = fimc_is_group_buffer_finish(groupmgr, group, index);
if (ret)
- merr("fimc_is_group_buffer_finish is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_finish failed(%d)", device, ret);
return ret;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aa_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aa_size failed(%d)", device, ret);
goto p_err;
}
mrdbg("[3AA] in_crop[%d, %d, %d, %d]\n", device, ldr_frame,
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aa_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aa_size failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aap_start is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aap_start failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aap_stop is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aap_stop failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aac_start is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aac_start failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_3aac_stop is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aac_stop failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
ret = fimc_is_itf_s_param(device , NULL, lindex, hindex, indexes);
if (ret) {
- merr("fimc_is_itf_s_param is fail", device);
+ merr("fimc_is_itf_s_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_f_param(device);
if (ret) {
- merr("fimc_is_itf_f_param is fail", device);
+ merr("fimc_is_itf_f_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_sys_ctl(device, IS_SYS_CLOCK_GATE, sysfs_debug.clk_gate_mode);
if (ret) {
- merr("fimc_is_itf_sys_ctl is fail", device);
+ merr("fimc_is_itf_sys_ctl failed", device);
ret = -EINVAL;
goto p_err;
}
* this code is enabled when camera 2.0 feature is enabled
* ret = fimc_is_itf_g_capability(device);
* if (ret) {
- * err("fimc_is_itf_g_capability is fail\n");
+ * err("fimc_is_itf_g_capability failed\n");
* ret = -EINVAL;
* goto p_err;
*}
ret = fimc_is_itf_init_process_start(device);
if (ret) {
- merr("fimc_is_itf_init_process_start is fail", device);
+ merr("fimc_is_itf_init_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_process_start(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_start is fail", device);
+ merr("fimc_is_group_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_process_stop(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_stop is fail", device);
+ merr("fimc_is_group_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
if (!count) {
ret = fimc_is_itf_unmap(device, GROUP_ID(group->id));
if (ret)
- merr("fimc_is_itf_unmap is fail(%d)", device, ret);
+ merr("fimc_is_itf_unmap failed(%d)", device, ret);
}
return ret;
ret = fimc_is_group_init(groupmgr, group, false, tax_vindex);
if (ret) {
- merr("fimc_is_group_init is fail", device);
+ merr("fimc_is_group_init failed", device);
ret = -EINVAL;
}
ret = fimc_is_group_buffer_queue(groupmgr, group, queue, index);
if (ret) {
- merr("fimc_is_group_buffer_queue is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_queue failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_group_buffer_finish(groupmgr, group, index);
if (ret)
- merr("fimc_is_group_buffer_finish is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_finish failed(%d)", device, ret);
return ret;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_s_chain0_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_s_chain0_size failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_s_chain0_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_s_chain0_size failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_scc_start is fail(%d)", device, ret);
+ merr("fimc_is_ischain_scc_start failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_scc_stop is fail(%d)", device, ret);
+ merr("fimc_is_ischain_scc_stop failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_s_chain2_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_s_chain2_size failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_s_chain3_size is fail(%d)", device, ret);
+ merr("fimc_is_ischain_s_chain3_size failed(%d)", device, ret);
goto p_err;
}
mrinfo("[SCPX] xx_crop[%d, %d, %d, %d]\n", device, ldr_frame,
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_scp_start is fail(%d)", device, ret);
+ merr("fimc_is_ischain_scp_start failed(%d)", device, ret);
goto p_err;
}
&hindex,
&indexes);
if (ret) {
- merr("fimc_is_ischain_scp_stop is fail(%d)", device, ret);
+ merr("fimc_is_ischain_scp_stop failed(%d)", device, ret);
goto p_err;
}
ldr_frame->shot->ctl.entry.highIndexParam |= hindex;
ret = fimc_is_itf_s_param(device, ldr_frame, lindex, hindex, 0);
if (ret) {
- mrerr("fimc_is_itf_s_param is fail(%d)", device, ldr_frame, ret);
+ mrerr("fimc_is_itf_s_param failed(%d)", device, ldr_frame, ret);
goto p_err;
}
ret = fimc_is_group_init(groupmgr, group, false, 0);
if (ret) {
- merr("fimc_is_group_init is fail", device);
+ merr("fimc_is_group_init failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_stop(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", device);
+ merr("fimc_is_itf_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_s_param(device, NULL, lindex, hindex, indexes);
if (ret) {
- merr("fimc_is_itf_s_param is fail", device);
+ merr("fimc_is_itf_s_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_a_param(device, group_id);
if (ret) {
- merr("fimc_is_itf_a_param is fail", device);
+ merr("fimc_is_itf_a_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_start(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_start is fail", device);
+ merr("fimc_is_itf_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_stop(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", device);
+ merr("fimc_is_itf_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_s_param(device, NULL, lindex, hindex, indexes);
if (ret) {
- merr("fimc_is_itf_s_param is fail", device);
+ merr("fimc_is_itf_s_param failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_a_param(device, group_id);
if (ret) {
- merr("fimc_is_itf_a_param is fail", device);
+ merr("fimc_is_itf_a_param failed", device);
ret = -EINVAL;
goto p_err;
}
group_id = GROUP_ID(device->group_isp.id);
ret = fimc_is_itf_process_start(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_start is fail", device);
+ merr("fimc_is_itf_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_ischain_dis_start(device,
ldr_frame->shot_ext->dis_bypass);
if (ret) {
- merr("vdisc_start is fail", device);
+ merr("vdisc_start failed", device);
goto p_err;
}
}
if (test_bit(FIMC_IS_SUBDEV_START, &subdev->state)) {
ret = fimc_is_ischain_dis_stop(device);
if (ret) {
- merr("vdisc_stop is fail", device);
+ merr("vdisc_stop failed", device);
goto p_err;
}
}
ret = fimc_is_group_open(groupmgr, group, GROUP_ID_DIS,
device->instance, vctx, device, fimc_is_ischain_dis_callback);
if (ret)
- merr("fimc_is_group_open is fail", device);
+ merr("fimc_is_group_open failed", device);
return ret;
}
ret = fimc_is_ischain_vdo_stop(device, leader, queue);
if (ret)
- merr("fimc_is_ischain_vdo_stop is fail", device);
+ merr("fimc_is_ischain_vdo_stop failed", device);
ret = fimc_is_group_close(groupmgr, group);
if (ret)
- merr("fimc_is_group_close is fail", device);
+ merr("fimc_is_group_close failed", device);
return ret;
}
ret = fimc_is_group_process_start(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_start is fail", device);
+ merr("fimc_is_group_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_process_stop(groupmgr, group, queue);
if (ret) {
- merr("fimc_is_group_process_start is fail", device);
+ merr("fimc_is_group_process_start failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_itf_process_stop(device, GROUP_ID_DIS);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", device);
+ merr("fimc_is_itf_process_stop failed", device);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_group_buffer_queue(groupmgr, group, queue, index);
if (ret) {
- merr("fimc_is_group_buffer_queue is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_queue failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_group_buffer_finish(groupmgr, group, index);
if (ret)
- merr("fimc_is_group_buffer_finish is fail(%d)", device, ret);
+ merr("fimc_is_group_buffer_finish failed(%d)", device, ret);
return ret;
}
}
if (unlikely(frame != check_frame)) {
- merr("frame checking is fail(%p != %p)", device,
+ merr("frame checking failed(%p != %p)", device,
frame, check_frame);
ret = -EINVAL;
goto p_err;
unsigned int setfile = frame->shot_ext->setfile;
ret = fimc_is_ischain_chg_setfile(device, setfile);
if (ret) {
- err("fimc_is_ischain_chg_setfile is fail");
+ err("fimc_is_ischain_chg_setfile failed");
goto p_err;
}
}
ret = fimc_is_ischain_3aa_tag(device, leader, frame, leader_node);
if (ret) {
- merr("fimc_is_ischain_3aa_tag is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aa_tag failed(%d)", device, ret);
goto p_err;
}
if (taac) {
ret = fimc_is_ischain_3aac_tag(device, taac, frame, node);
if (ret) {
- merr("fimc_is_ischain_3aac_tag is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aac_tag failed(%d)", device, ret);
goto p_err;
}
}
if (taap) {
ret = fimc_is_ischain_3aap_tag(device, taap, frame, node);
if (ret) {
- merr("fimc_is_ischain_3aap_tag is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aap_tag failed(%d)", device, ret);
goto p_err;
}
}
}
if (unlikely(frame != check_frame)) {
- merr("frame checking is fail(%p != %p)", device,
+ merr("frame checking failed(%p != %p)", device,
frame, check_frame);
ret = -EINVAL;
goto p_err;
unsigned int setfile = frame->shot_ext->setfile;
ret = fimc_is_ischain_chg_setfile(device, setfile);
if (ret) {
- err("fimc_is_ischain_chg_setfile is fail");
+ err("fimc_is_ischain_chg_setfile failed");
goto p_err;
}
}
if (test_bit(FIMC_IS_SUBDEV_START, &device->drc.state)) {
ret = fimc_is_ischain_drc_bypass(device, frame, true);
if (ret) {
- err("fimc_is_ischain_drc_bypass(1) is fail");
+ err("fimc_is_ischain_drc_bypass(1) failed");
goto p_err;
}
}
if (!test_bit(FIMC_IS_SUBDEV_START, &device->drc.state)) {
ret = fimc_is_ischain_drc_bypass(device, frame, false);
if (ret) {
- err("fimc_is_ischain_drc_bypass(0) is fail");
+ err("fimc_is_ischain_drc_bypass(0) failed");
goto p_err;
}
}
if (test_bit(FIMC_IS_SUBDEV_START, &dnr->state)) {
ret = fimc_is_ischain_dnr_bypass(device, frame, true);
if (ret) {
- merr("dnr_bypass(1) is fail", device);
+ merr("dnr_bypass(1) failed", device);
goto p_err;
}
}
if (!test_bit(FIMC_IS_SUBDEV_START, &dnr->state)) {
ret = fimc_is_ischain_dnr_bypass(device, frame, false);
if (ret) {
- merr("dnr_bypass(0) is fail", device);
+ merr("dnr_bypass(0) failed", device);
goto p_err;
}
}
if (test_bit(FIMC_IS_SUBDEV_START, &fd->state)) {
ret = fimc_is_ischain_fd_bypass(device, true);
if (ret) {
- merr("fd_bypass(1) is fail", device);
+ merr("fd_bypass(1) failed", device);
goto p_err;
}
}
if (!test_bit(FIMC_IS_SUBDEV_START, &fd->state)) {
ret = fimc_is_ischain_fd_bypass(device, false);
if (ret) {
- merr("fd_bypass(0) is fail", device);
+ merr("fd_bypass(0) failed", device);
goto p_err;
}
}
frame->shot->ctl.scaler.cropRegion[1],
frame->shot->ctl.scaler.cropRegion[2]);
if (ret) {
- err("fimc_is_ischain_s_dzoom(%d, %d, %d) is fail",
+ err("fimc_is_ischain_s_dzoom(%d, %d, %d) failed",
frame->shot->ctl.scaler.cropRegion[0],
frame->shot->ctl.scaler.cropRegion[1],
frame->shot->ctl.scaler.cropRegion[2]);
if (!GET_FIMC_IS_NUM_OF_SUBIP2(device, 3a0)) {
ret = fimc_is_ischain_3aa_tag(device, leader, frame, leader_node);
if (ret) {
- merr("fimc_is_ischain_3aa_tag is fail(%d)", device, ret);
+ merr("fimc_is_ischain_3aa_tag failed(%d)", device, ret);
goto p_err;
}
}
ret = fimc_is_ischain_isp_tag(device, leader, frame, leader_node);
if (ret) {
- merr("fimc_is_ischain_isp_tag is fail(%d)", device, ret);
+ merr("fimc_is_ischain_isp_tag failed(%d)", device, ret);
goto p_err;
}
if (test_bit(FIMC_IS_SUBDEV_START, &dnr->state)) {
ret = fimc_is_ischain_dnr_bypass(device, frame, true);
if (ret) {
- merr("dnr_bypass(1) is fail", device);
+ merr("dnr_bypass(1) failed", device);
goto p_err;
}
}
if (!test_bit(FIMC_IS_SUBDEV_START, &dnr->state)) {
ret = fimc_is_ischain_dnr_bypass(device, frame, false);
if (ret) {
- merr("dnr_bypass(0) is fail", device);
+ merr("dnr_bypass(0) failed", device);
goto p_err;
}
}
if (test_bit(FIMC_IS_SUBDEV_START, &fd->state)) {
ret = fimc_is_ischain_fd_bypass(device, true);
if (ret) {
- merr("fd_bypass(1) is fail", device);
+ merr("fd_bypass(1) failed", device);
goto p_err;
}
}
if (!test_bit(FIMC_IS_SUBDEV_START, &fd->state)) {
ret = fimc_is_ischain_fd_bypass(device, false);
if (ret) {
- merr("fd_bypass(0) is fail", device);
+ merr("fd_bypass(0) failed", device);
goto p_err;
}
}
ret = pdata->gpio_cfg(device->pdev, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON);
if (ret) {
- err("gpio_cfg is fail(%d)", ret);
+ err("gpio_cfg failed(%d)", ret);
goto p_err;
}
ret = pdata->gpio_cfg(device->pdev, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF);
if (ret) {
- err("gpio_cfg is fail(%d)", ret);
+ err("gpio_cfg failed(%d)", ret);
goto p_err;
}
}
if (ret) {
- err("request_firmware is fail(ret:%d)", ret);
+ err("request_firmware failed(ret:%d)", ret);
ret = -EINVAL;
goto p_err;
}
ret = pdata->mclk_on(device->pdev, pdata->scenario, pdata->mclk_ch);
if (ret) {
- merr("mclk_on is fail(%d)", device, ret);
+ merr("mclk_on failed(%d)", device, ret);
goto p_err;
}
ret = pdata->mclk_off(device->pdev, pdata->scenario, pdata->mclk_ch);
if (ret) {
- merr("mclk_off is fail(%d)", device, ret);
+ merr("mclk_off failed(%d)", device, ret);
goto p_err;
}
ret = pdata->iclk_cfg(core->pdev, pdata->scenario, pdata->csi_ch);
if (ret) {
- merr("iclk_cfg is fail(%d)", device, ret);
+ merr("iclk_cfg failed(%d)", device, ret);
goto p_err;
}
ret = pdata->iclk_on(core->pdev, pdata->scenario, pdata->csi_ch);
if (ret) {
- merr("iclk_on is fail(%d)", device, ret);
+ merr("iclk_on failed(%d)", device, ret);
goto p_err;
}
ret = pdata->iclk_off(core->pdev, pdata->scenario, pdata->csi_ch);
if (ret) {
- merr("iclk_off is fail(%d)", device, ret);
+ merr("iclk_off failed(%d)", device, ret);
goto p_err;
}
ret = pdata->gpio_cfg(device->pdev, pdata->scenario, GPIO_SCENARIO_ON);
if (ret) {
- merr("gpio_cfg is fail(%d)", device, ret);
+ merr("gpio_cfg failed(%d)", device, ret);
goto p_err;
}
ret = pdata->gpio_cfg(device->pdev, pdata->scenario, GPIO_SCENARIO_OFF);
if (ret) {
- merr("gpio_cfg is fail(%d)", device, ret);
+ merr("gpio_cfg failed(%d)", device, ret);
goto p_err;
}
}
ret = v4l2_subdev_call(subdev, video, s_stream, true);
if (ret) {
- merr("v4l2_subdev_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_subdev_call(s_stream) failed(%d)", device, ret);
goto p_err;
}
} else {
ret = fimc_is_itf_stream_on(ischain);
if (ret) {
- merr("fimc_is_itf_stream_on is fail(%d)", device, ret);
+ merr("fimc_is_itf_stream_on failed(%d)", device, ret);
goto p_err;
}
}
}
ret = v4l2_subdev_call(subdev, video, s_stream, false);
if (ret) {
- merr("v4l2_subdev_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_subdev_call(s_stream) failed(%d)", device, ret);
goto p_err;
}
} else {
}
ret = fimc_is_itf_stream_off(ischain);
if (ret) {
- merr("fimc_is_itf_stream_off is fail(%d)", device, ret);
+ merr("fimc_is_itf_stream_off failed(%d)", device, ret);
goto p_err;
}
}
case FLITE_NOTIFY_FSTART:
ret = fimc_is_sensor_notify_by_fstr(device, arg);
if (ret)
- merr("fimc_is_sensor_notify_by_fstr is fail(%d)", device, ret);
+ merr("fimc_is_sensor_notify_by_fstr failed(%d)", device, ret);
break;
case FLITE_NOTIFY_FEND:
ret = fimc_is_sensor_notify_by_fend(device, arg);
if (ret)
- merr("fimc_is_sensor_notify_by_fend is fail(%d)", device, ret);
+ merr("fimc_is_sensor_notify_by_fend failed(%d)", device, ret);
break;
}
}
ret = fimc_is_sensor_start(device);
if (ret) {
- merr("fimc_is_sensor_start is fail(%d)\n", device, ret);
+ merr("fimc_is_sensor_start failed(%d)\n", device, ret);
goto p_err;
}
set_bit(FIMC_IS_SENSOR_FRONT_START, &device->state);
ret = fimc_is_sensor_parse_dt_with_companion(pdev);
if (ret) {
- err("parsing device tree is fail(%d)", ret);
+ err("parsing device tree failed(%d)", ret);
goto p_err;
}
ret = fimc_is_mem_probe(&device->mem, core->pdev);
if (ret) {
- merr("fimc_is_mem_probe is fail(%d)", device, ret);
+ merr("fimc_is_mem_probe failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_device_register(&pdev->dev, &device->v4l2_dev);
if (ret) {
- merr("v4l2_device_register is fail(%d)", device, ret);
+ merr("v4l2_device_register failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_csi_probe(device, device->pdata->csi_ch);
if (ret) {
- merr("fimc_is_csi_probe is fail(%d)", device, ret);
+ merr("fimc_is_csi_probe failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_flite_probe(device, device->pdata->flite_ch);
if (ret) {
- merr("fimc_is_flite_probe is fail(%d)", device, ret);
+ merr("fimc_is_flite_probe failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_sen_video_probe(device);
if (ret) {
- merr("fimc_is_sensor_video_probe is fail(%d)", device, ret);
+ merr("fimc_is_sensor_video_probe failed(%d)", device, ret);
goto p_err;
}
/* for mediaserver force close */
ret = fimc_is_resource_get(device->resourcemgr, device->instance);
if (ret) {
- merr("fimc_is_resource_get is fail", device);
+ merr("fimc_is_resource_get failed", device);
goto p_err;
}
ret = fimc_is_csi_open(device->subdev_csi);
if (ret) {
- merr("fimc_is_csi_open is fail(%d)", device, ret);
+ merr("fimc_is_csi_open failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_flite_open(device->subdev_flite, GET_DST_FRAMEMGR(vctx));
if (ret) {
- merr("fimc_is_flite_open is fail(%d)", device, ret);
+ merr("fimc_is_flite_open failed(%d)", device, ret);
goto p_err;
}
ret = fimc_is_sensor_back_stop(device);
if (ret)
- merr("fimc_is_sensor_back_stop is fail(%d)", device, ret);
+ merr("fimc_is_sensor_back_stop failed(%d)", device, ret);
ret = fimc_is_sensor_front_stop(device);
if (ret)
- merr("fimc_is_sensor_front_stop is fail(%d)", device, ret);
+ merr("fimc_is_sensor_front_stop failed(%d)", device, ret);
ret = fimc_is_csi_close(device->subdev_csi);
if (ret)
- merr("fimc_is_flite_close is fail(%d)", device, ret);
+ merr("fimc_is_flite_close failed(%d)", device, ret);
ret = fimc_is_flite_close(device->subdev_flite);
if (ret)
- merr("fimc_is_flite_close is fail(%d)", device, ret);
+ merr("fimc_is_flite_close failed(%d)", device, ret);
pm_runtime_put_sync(&device->pdev->dev);
/* for mediaserver force close */
ret = fimc_is_resource_put(device->resourcemgr, device->instance);
if (ret)
- merr("fimc_is_resource_put is fail", device);
+ merr("fimc_is_resource_put failed", device);
clear_bit(FIMC_IS_SENSOR_OPEN, &device->state);
set_bit(FIMC_IS_SENSOR_BACK_NOWAIT_STOP, &device->state);
ret = v4l2_device_register_subdev(&device->v4l2_dev, subdev_module);
if (ret) {
- merr("v4l2_device_register_subdev is fail(%d)", device, ret);
+ merr("v4l2_device_register_subdev failed(%d)", device, ret);
goto p_err;
} else {
device->subdev_module = subdev_module;
/* configuration clock control */
ret = fimc_is_sensor_iclk_on(device);
if (ret) {
- merr("fimc_is_sensor_iclk_on is fail(%d)", device, ret);
+ merr("fimc_is_sensor_iclk_on failed(%d)", device, ret);
goto p_err;
}
/* Sensor power on */
ret = fimc_is_sensor_gpio_on(device);
if (ret) {
- merr("fimc_is_sensor_gpio_on is fail(%d)", device, ret);
+ merr("fimc_is_sensor_gpio_on failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_flite, core, ioctl, 0,
(void *)(long)device->pdata->csi_ch);
if (ret) {
- merr("v4l2_flite_call(init) is fail(%d)", device, ret);
+ merr("v4l2_flite_call(init) failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_csi, core, ioctl, 0, module);
if (ret) {
- merr("v4l2_csi_call(init) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(init) failed(%d)", device, ret);
goto p_err;
}
if (test_bit(FIMC_IS_SENSOR_DRIVING, &device->state)) {
ret = v4l2_subdev_call(subdev_module, core, ioctl, 0, 0);
if (ret) {
- merr("v4l2_module_call(init) is fail(%d)", device, ret);
+ merr("v4l2_module_call(init) failed(%d)", device, ret);
goto p_err;
}
}
if (test_bit(FIMC_IS_SENSOR_DRIVING, &device->state)) {
ret = v4l2_subdev_call(subdev_module, video, s_mbus_fmt, &subdev_format);
if (ret) {
- merr("v4l2_module_call(s_format) is fail(%d)", device, ret);
+ merr("v4l2_module_call(s_format) failed(%d)", device, ret);
goto p_err;
}
}
ret = v4l2_subdev_call(subdev_csi, video, s_mbus_fmt, &subdev_format);
if (ret) {
- merr("v4l2_csi_call(s_format) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(s_format) failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_flite, video, s_mbus_fmt, &subdev_format);
if (ret) {
- merr("v4l2_flite_call(s_format) is fail(%d)", device, ret);
+ merr("v4l2_flite_call(s_format) failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_csi, video, s_parm, param);
if (ret) {
- merr("v4l2_csi_call(s_param) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(s_param) failed(%d)", device, ret);
goto p_err;
}
if (test_bit(FIMC_IS_SENSOR_DRIVING, &device->state)) {
ret = v4l2_subdev_call(subdev_module, video, s_parm, param);
if (ret) {
- merr("v4l2_module_call(s_param) is fail(%d)", device, ret);
+ merr("v4l2_module_call(s_param) failed(%d)", device, ret);
goto p_err;
}
}
ret = v4l2_subdev_call(subdev_module, core, s_ctrl, ctrl);
if (ret) {
- err("s_ctrl is fail(%d)", ret);
+ err("s_ctrl failed(%d)", ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_module, core, g_ctrl, ctrl);
if (ret) {
- err("g_ctrl is fail(%d)", ret);
+ err("g_ctrl failed(%d)", ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_flite, video, s_stream, enable);
if (ret) {
- merr("v4l2_flite_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_flite_call(s_stream) failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_flite, video, s_stream, enable);
if (ret) {
- merr("v4l2_flite_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_flite_call(s_stream) failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_csi, video, s_stream, IS_ENABLE_STREAM);
if (ret) {
- merr("v4l2_csi_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(s_stream) failed(%d)", device, ret);
goto p_err;
}
} else {
fimc_is_sensor_instanton(&device->instant_work);
if (device->instant_ret) {
- merr("fimc_is_sensor_instanton is fail(%d)", device, device->instant_ret);
+ merr("fimc_is_sensor_instanton failed(%d)", device, device->instant_ret);
ret = device->instant_ret;
goto p_err;
}
ret = fimc_is_sensor_stop(device);
if (ret)
- merr("sensor stream off is failed(%d)\n", device, ret);
+ merr("sensor stream off faileded(%d)\n", device, ret);
ret = v4l2_subdev_call(subdev_csi, video, s_stream, IS_DISABLE_STREAM);
if (ret)
- merr("v4l2_csi_call(s_stream) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(s_stream) failed(%d)", device, ret);
set_bit(FIMC_IS_SENSOR_BACK_NOWAIT_STOP, &device->state);
clear_bit(FIMC_IS_SENSOR_FRONT_START, &device->state);
ret = pdata->gpio_cfg(device->pdev, pdata->scenario, GPIO_SCENARIO_OFF);
if (ret) {
- merr("gpio_cfg is fail(%d)", device, ret);
+ merr("gpio_cfg failed(%d)", device, ret);
goto p_err;
}
if(device->pdata->is_softlanding == false) {
ret = fimc_is_sensor_gpio_off(device);
if (ret) {
- mwarn("fimc_is_sensor_gpio_off is fail(%d)", device, ret);
+ mwarn("fimc_is_sensor_gpio_off failed(%d)", device, ret);
}
}
/* GSCL internal clock off */
ret = fimc_is_sensor_iclk_off(device);
if (ret)
- mwarn("fimc_is_sensor_iclk_off is fail(%d)", device, ret);
+ mwarn("fimc_is_sensor_iclk_off failed(%d)", device, ret);
/* Sensor clock on */
ret = fimc_is_sensor_mclk_off(device);
if (ret)
- mwarn("fimc_is_sensor_mclk_off is fail(%d)", device, ret);
+ mwarn("fimc_is_sensor_mclk_off failed(%d)", device, ret);
ret = v4l2_subdev_call(subdev_csi, core, s_power, 0);
if (ret)
- mwarn("v4l2_csi_call(s_power) is fail(%d)", device, ret);
+ mwarn("v4l2_csi_call(s_power) failed(%d)", device, ret);
info("[SEN:D:%d] %s(%d)\n", device->instance, __func__, ret);
/* 1. Enable MIPI */
ret = v4l2_subdev_call(subdev_csi, core, s_power, 1);
if (ret) {
- merr("v4l2_csi_call(s_power) is fail(%d)", device, ret);
+ merr("v4l2_csi_call(s_power) failed(%d)", device, ret);
goto p_err;
}
/* 2. Sensor clock on */
ret = fimc_is_sensor_mclk_on(device);
if (ret) {
- merr("fimc_is_sensor_mclk_on is fail(%d)", device, ret);
+ merr("fimc_is_sensor_mclk_on failed(%d)", device, ret);
goto p_err;
}
pdata->csi_ch);
s = pinctrl_lookup_state(pdata->pinctrl, ch_name);
if (IS_ERR(s)) {
- err("cam %s, ch %d pinctrl_lookup_state is failed", ch_name, pdata->csi_ch);
+ err("cam %s, ch %d pinctrl_lookup_state failed", ch_name, pdata->csi_ch);
ret = -EINVAL;
goto p_err;
} else {
retVal = of_property_read_u32(np, "companion_spi_channel", &pdata->companion_spi_channel);
if (retVal) {
- err("spi_channel read is fail(%d)", retVal);
+ err("spi_channel read failed(%d)", retVal);
}
pdata->use_two_spi_line = of_property_read_bool(np, "use_two_spi_line");
retVal = of_property_read_u32(np, "use_sensor_dynamic_voltage_mode", &pdata->use_sensor_dynamic_voltage_mode);
if (retVal) {
- err("use_sensor_dynamic_voltage_mode read is fail(%d)", retVal);
+ err("use_sensor_dynamic_voltage_mode read failed(%d)", retVal);
pdata->use_sensor_dynamic_voltage_mode = 0;
}
pdata->use_ois = of_property_read_bool(np, "use_ois");
ret = of_property_read_u32(dnode, "scenario", &pdata->scenario);
if (ret) {
- err("scenario read is fail(%d)", ret);
+ err("scenario read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "mclk_ch", &pdata->mclk_ch);
if (ret) {
- err("mclk_ch read is fail(%d)", ret);
+ err("mclk_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "csi_ch", &pdata->csi_ch);
if (ret) {
- err("csi_ch read is fail(%d)", ret);
+ err("csi_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "flite_ch", &pdata->flite_ch);
if (ret) {
- err("flite_ch read is fail(%d)", ret);
+ err("flite_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "i2c_ch", &pdata->i2c_ch);
if (ret) {
- err("i2c_ch read is fail(%d)", ret);
+ err("i2c_ch read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "i2c_addr", &pdata->i2c_addr);
if (ret) {
- err("i2c_addr read is fail(%d)", ret);
+ err("i2c_addr read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "is_bns", &pdata->is_bns);
if (ret) {
- err("is_bns read is fail(%d)", ret);
+ err("is_bns read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_u32(dnode, "id", &id);
if (ret) {
- err("id read is fail(%d)", ret);
+ err("id read failed(%d)", ret);
goto p_err;
}
ret = of_property_read_string(dnode, "sensor_name", &name);
if (ret) {
- err("sensor_name read is fail(%d)", ret);
+ err("sensor_name read failed(%d)", ret);
goto p_err;
}
strcpy(pdata->sensor_name, name);
ret = of_property_read_u32(dnode, "sensor_id", &pdata->sensor_id);
if (ret) {
- err("sensor_id read is fail(%d)", ret);
+ err("sensor_id read failed(%d)", ret);
goto p_err;
}
pdata->pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(pdata->pinctrl)) {
- err("devm_pinctrl_get is fail");
+ err("devm_pinctrl_get failed");
goto p_err;
} else {
ret = get_pin_lookup_state(dev, pdata);
if (ret < 0) {
- err("fimc_is_get_pin_lookup_state is fail");
+ err("fimc_is_get_pin_lookup_state failed");
goto p_err;
}
}
ret = sched_setscheduler_nocheck(groupmgr->group_task[id], SCHED_FIFO, ¶m);
if (ret) {
- merr("sched_setscheduler_nocheck is fail(%d)", group, ret);
+ merr("sched_setscheduler_nocheck failed(%d)", group, ret);
goto p_err;
}
}
if (!retry) {
- merr("waiting(until request empty) is fail", group);
+ merr("waiting(until request empty) failed", group);
ret = -EINVAL;
}
}
if (!retry) {
- merr("waiting(until process empty) is fail", group);
+ merr("waiting(until process empty) failed", group);
ret = -EINVAL;
}
}
if (test_bit(FIMC_IS_GROUP_FORCE_STOP, &group->state)) {
ret = fimc_is_itf_force_stop(device, GROUP_ID(group->id));
if (ret) {
- merr("fimc_is_itf_force_stop is fail", group);
+ merr("fimc_is_itf_force_stop failed", group);
ret = -EINVAL;
}
} else {
ret = fimc_is_itf_process_stop(device, group_id);
if (ret) {
- merr("fimc_is_itf_process_stop is fail", group);
+ merr("fimc_is_itf_process_stop failed", group);
ret = -EINVAL;
}
}
}
if (!retry) {
- merr("waiting(until process empty) is fail", group);
+ merr("waiting(until process empty) failed", group);
ret = -EINVAL;
}
}
}
if (!retry) {
- mgerr(" waiting(until thread stop) is fail", device, group);
+ mgerr(" waiting(until thread stop) failed", device, group);
ret = -EINVAL;
}
PROGRAM_COUNT(1);
ret = down_interruptible(&group->smp_shot);
if (ret) {
- err("down is fail1(%d)", ret);
+ err("down failed1(%d)", ret);
goto p_err;
}
atomic_dec(&group->smp_shot_count);
PROGRAM_COUNT(2);
ret = down_interruptible(&groupmgr->group_smp_res[group->id]);
if (ret) {
- err("down is fail2(%d)", ret);
+ err("down failed2(%d)", ret);
goto p_err;
}
try_rdown = true;
PROGRAM_COUNT(3);
ret = down_interruptible(&group->smp_trigger);
if (ret) {
- err("down is fail3(%d)", ret);
+ err("down failed3(%d)", ret);
goto p_err;
}
} else {
PROGRAM_COUNT(4);
ret = down_interruptible(&group->smp_trigger);
if (ret) {
- err("down is fail4(%d)", ret);
+ err("down failed4(%d)", ret);
goto p_err;
}
} else {
PROGRAM_COUNT(6);
ret = group->start_callback(group->device, ldr_frame);
if (ret) {
- merr("start_callback is fail", group);
+ merr("start_callback failed", group);
fimc_is_group_cancel(group, ldr_frame);
fimc_is_group_done(groupmgr, group, ldr_frame, VB2_BUF_STATE_ERROR);
} else {
pr_info("FIMC_IS runtime suspend in\n");
if (CALL_POPS(core, clk_off, pdev) < 0)
- warn("clk_off is fail\n");
+ warn("clk_off failed\n");
pr_info("FIMC_IS runtime suspend out\n");
/* Low clock setting */
if (CALL_POPS(core, clk_cfg, core->pdev) < 0) {
- err("clk_cfg is fail\n");
+ err("clk_cfg failed\n");
ret = -EINVAL;
goto p_err;
}
/* Clock on */
if (CALL_POPS(core, clk_on, core->pdev) < 0) {
- err("clk_on is fail\n");
+ err("clk_on failed\n");
ret = -EINVAL;
goto p_err;
}
wait_lock = wait_lockstate(itf);
pr_info("itf UNLOCK, %d(%d) go\n", current->pid, msg->command);
if (wait_lock) {
- err("wait_lockstate is fail, lock reset");
+ err("wait_lockstate failed, lock reset");
atomic_set(&itf->lock_pid, 0);
}
}
if (ret) {
exit_request_barrier(itf);
exit_process_barrier(itf);
- err("waiting for ready is fail");
+ err("waiting for ready failed");
ret = -EBUSY;
goto exit;
}
ret = waiting_is_ready(this);
if (ret) {
exit_process_barrier(this);
- err("waiting for ready is fail");
+ err("waiting for ready failed");
ret = -EBUSY;
goto exit;
}
ret = waiting_is_ready(this);
if (ret) {
- err("waiting for ready is fail");
+ err("waiting for ready failed");
ret = -EBUSY;
goto exit;
}
retry--;
}
if (!retry)
- err("waiting idle is fail");
+ err("waiting idle failed");
del_timer_sync(&this->timer);
dbg_interface("%s\n", __func__);
warn("instance(%d): FW is not initialized, wait\n", instance);
ret = fimc_is_hw_enum(this);
if (ret)
- err("fimc_is_itf_enum is fail(%d)", ret);
+ err("fimc_is_itf_enum failed(%d)", ret);
}
msg.id = 0;
ret = fimc_is_interface_open(&core->interface);
if (ret) {
- err("fimc_is_interface_open is fail(%d)", ret);
+ err("fimc_is_interface_open failed(%d)", ret);
goto p_err;
}
ret = fimc_is_ischain_power(&core->ischain[0], 1);
if (ret) {
- err("fimc_is_ischain_power is fail (%d)", ret);
+ err("fimc_is_ischain_power failed (%d)", ret);
goto p_err;
}
case RESOURCE_TYPE_ISCHAIN:
ret = fimc_is_itf_power_down(&core->interface);
if (ret)
- err("power down cmd is fail(%d)", ret);
+ err("power down cmd failed(%d)", ret);
ret = fimc_is_ischain_power(&core->ischain[0], 0);
if (ret)
- err("fimc_is_ischain_power is fail(%d)", ret);
+ err("fimc_is_ischain_power failed(%d)", ret);
ret = fimc_is_interface_close(&core->interface);
if (ret)
- err("fimc_is_interface_close is fail(%d)", ret);
+ err("fimc_is_interface_close failed(%d)", ret);
#ifndef RESERVED_MEM
/* 5. Dealloc memroy */
ret = fimc_is_ishcain_deinitmem(&core->ischain[0]);
if (ret)
- err("fimc_is_ishcain_deinitmem is fail(%d)", ret);
+ err("fimc_is_ishcain_deinitmem failed(%d)", ret);
#endif
break;
if (atomic_read(&core->rsccount) == 1) {
ret = fimc_is_runtime_suspend_post(NULL);
if (ret)
- err("fimc_is_runtime_suspend_post is fail(%d)", ret);
+ err("fimc_is_runtime_suspend_post failed(%d)", ret);
}
atomic_dec(&resource->rsccount);
&fimc_is_3aa_video_fops,
&fimc_is_3aa_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
&fimc_is_3aa_video_fops,
&fimc_is_3aa_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_3AA_GRP, FRAMEMGR_ID_3AAP);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
&fimc_is_ischain_3aa_ops,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_ischain_3aa_open(device, vctx);
if (ret) {
- err("fimc_is_ischain_3aa_open is fail");
+ err("fimc_is_ischain_3aa_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_poll(file, vctx, wait);
if (ret)
- merr("fimc_is_video_poll is fail(%d)", vctx, ret);
+ merr("fimc_is_video_poll failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret) {
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
goto p_err;
}
if (V4L2_TYPE_IS_OUTPUT(buf->type)) {
ret = fimc_is_ischain_3aa_reqbufs(device, buf->count);
if (ret) {
- merr("3a0_reqbufs is fail(%d)", vctx, ret);
+ merr("3a0_reqbufs failed(%d)", vctx, ret);
goto p_err;
}
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf(type %d) is fail(%d)", vctx, buf->type, ret);
+ merr("fimc_is_video_qbuf(type %d) failed(%d)", vctx, buf->type, ret);
return ret;
}
ret = fimc_is_video_dqbuf(file, vctx, buf);
/* HACK : this log is commented until timeout issue fixed */
/* if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
*/
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_ischain_3aa_s_input(device, input);
if (ret) {
- merr("fimc_is_ischain_3aa_s_input is fail", vctx);
+ merr("fimc_is_ischain_3aa_s_input failed", vctx);
goto p_err;
}
ret = fimc_is_ischain_init_wrap(device, input);
if (ret) {
- merr("fimc_is_device_init(%d) is fail", vctx, input);
+ merr("fimc_is_device_init(%d) failed", vctx, input);
goto p_err;
}
size = sizeof(struct v4l2_buffer);
buf = kmalloc(size, GFP_KERNEL);
if (!buf) {
- merr("kmalloc is fail", vctx);
+ merr("kmalloc failed", vctx);
ret = -EINVAL;
goto p_err;
}
ret = copy_from_user(buf, (void __user *)ctrl->value, size);
if (ret) {
- merr("copy_from_user is fail(%d)", vctx, ret);
+ merr("copy_from_user failed(%d)", vctx, ret);
kfree(buf);
ret = -EINVAL;
goto p_err;
size = sizeof(struct v4l2_plane) * buf->length;
planes = kmalloc(size, GFP_KERNEL);
if (IS_ERR(planes)) {
- merr("kmalloc is fail(%p)", vctx, planes);
+ merr("kmalloc failed(%p)", vctx, planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
ret = copy_from_user(planes, (void __user *)buf->m.planes, size);
if (ret) {
- merr("copy_from_user is fail(%d)", vctx, ret);
+ merr("copy_from_user failed(%d)", vctx, ret);
kfree(planes);
kfree(buf);
ret = -EINVAL;
}
dmabuf = dma_buf_get(planes[plane].m.fd);
if (IS_ERR(dmabuf)) {
- merr("dma_buf_get is fail(%p)", vctx, dmabuf);
+ merr("dma_buf_get failed(%p)", vctx, dmabuf);
kfree(planes);
kfree(buf);
ret = -EINVAL;
attachment = dma_buf_attach(dmabuf, &device->pdev->dev);
if (IS_ERR(attachment)) {
- merr("dma_buf_attach is fail(%p)", vctx, attachment);
+ merr("dma_buf_attach failed(%p)", vctx, attachment);
kfree(planes);
kfree(buf);
dma_buf_put(dmabuf);
write = !V4L2_TYPE_IS_OUTPUT(buf->type);
dva = ion_iovmm_map(attachment, 0, dmabuf->size, write, plane);
if (IS_ERR_VALUE(dva)) {
- merr("ion_iovmm_map is fail(%X)", vctx, dva);
+ merr("ion_iovmm_map failed(%X)", vctx, dva);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
group_id = GROUP_ID(device->group_3aa.id);
ret = fimc_is_itf_map(device, group_id, dva, dmabuf->size);
if (ret) {
- merr("fimc_is_itf_map is fail(%d)", vctx, ret);
+ merr("fimc_is_itf_map failed(%d)", vctx, ret);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_3aa_buffer_queue(struct vb2_buffer *vb)
queue = GET_SRC_QUEUE(vctx);
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_ischain_3aa_buffer_queue(device, queue, index);
if (ret) {
- merr("fimc_is_ischain_3aa_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_3aa_buffer_queue failed(%d)", vctx, ret);
return;
}
} else {
queue = GET_DST_QUEUE(vctx);
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(leader, index);
if (ret) {
- merr("fimc_is_subdev_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_subdev_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_3aac_video_fops,
&fimc_is_3aac_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
&fimc_is_3aac_video_fops,
&fimc_is_3aac_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
info("[3AC1:V:1] %s(%d)\n", __func__, ret);
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_3AAC);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
NULL,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_subdev_open(&device->taac, vctx, NULL);
if (ret) {
- err("fimc_is_subdev_open is fail");
+ err("fimc_is_subdev_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_poll(file, vctx, wait);
if (ret)
- merr("fimc_is_video_poll is fail(%d)", vctx, ret);
+ merr("fimc_is_video_poll failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret) {
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
goto p_err;
}
ret = fimc_is_subdev_s_format(subdev, queue->framecfg.width, queue->framecfg.height);
if (ret) {
- merr("fimc_is_ischain_3aac_s_format is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_3aac_s_format failed(%d)", vctx, ret);
goto p_err;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_3aac_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(subdev, vb->v4l2_buf.index);
if (ret) {
- merr("fimc_is_subdev_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_subdev_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_comp_video_fops,
&fimc_is_comp_video_ioctl_ops);
if (ret)
- dev_err(&device->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&device->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
info("[CP%d:V:X] %s(%d)\n", number, __func__, ret);
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_INVALID);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
ret = fimc_is_companion_open(device);
if (ret) {
- merr("fimc_is_comp_open is fail(%d)", vctx, ret);
+ merr("fimc_is_comp_open failed(%d)", vctx, ret);
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_companion_close(device);
if (ret)
- err("fimc_is_companion_close is fail(%d)", ret);
+ err("fimc_is_companion_close failed(%d)", ret);
ret = close_vctx(file, video, vctx);
if (ret)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
core->fimc_is_companion_opened = 0;
&fimc_is_isp_video_fops,
&fimc_is_isp_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_ISP_GRP, FRAMEMGR_ID_INVALID);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
&fimc_is_ischain_isp_ops,
NULL);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_ischain_open(device, vctx, &core->minfo);
if (ret) {
- err("fimc_is_ischain_open is fail");
+ err("fimc_is_ischain_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_poll(file, vctx, wait);
if (ret)
- merr("fimc_is_video_poll is fail(%d)", vctx, ret);
+ merr("fimc_is_video_poll failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret)
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
fimc_is_ischain_isp_s_format(device,
queue->framecfg.width,
ret = fimc_is_ischain_isp_reqbufs(device, buf->count);
if (ret) {
- merr("isp_reqbufs is fail(%d)", vctx, ret);
+ merr("isp_reqbufs failed(%d)", vctx, ret);
goto p_err;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(error %d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(error %d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_ischain_isp_s_input(device, input);
if (ret) {
- merr("fimc_is_ischain_isp_s_input is fail", vctx);
+ merr("fimc_is_ischain_isp_s_input failed", vctx);
goto p_err;
}
ret = fimc_is_ischain_init_wrap(device, input);
if (ret) {
- merr("fimc_is_device_init(%d) is fail", vctx, input);
+ merr("fimc_is_device_init(%d) failed", vctx, input);
goto p_err;
}
size = sizeof(struct v4l2_buffer);
buf = kmalloc(size, GFP_KERNEL);
if (!buf) {
- merr("kmalloc is fail", vctx);
+ merr("kmalloc failed", vctx);
ret = -EINVAL;
goto p_err;
}
ret = copy_from_user(buf, (void __user *)ctrl->value, size);
if (ret) {
- merr("copy_from_user is fail(%d)", vctx, ret);
+ merr("copy_from_user failed(%d)", vctx, ret);
kfree(buf);
ret = -EINVAL;
goto p_err;
size = sizeof(struct v4l2_plane) * buf->length;
planes = kmalloc(size, GFP_KERNEL);
if (IS_ERR(planes)) {
- merr("kmalloc is fail(%p)", vctx, planes);
+ merr("kmalloc failed(%p)", vctx, planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
ret = copy_from_user(planes, (void __user *)buf->m.planes, size);
if (ret) {
- merr("copy_from_user is fail(%d)", vctx, ret);
+ merr("copy_from_user failed(%d)", vctx, ret);
kfree(planes);
kfree(buf);
ret = -EINVAL;
}
dmabuf = dma_buf_get(planes[plane].m.fd);
if (IS_ERR(dmabuf)) {
- merr("dma_buf_get is fail(%p)", vctx, dmabuf);
+ merr("dma_buf_get failed(%p)", vctx, dmabuf);
kfree(planes);
kfree(buf);
ret = -EINVAL;
attachment = dma_buf_attach(dmabuf, &device->pdev->dev);
if (IS_ERR(attachment)) {
- merr("dma_buf_attach is fail(%p)", vctx, attachment);
+ merr("dma_buf_attach failed(%p)", vctx, attachment);
kfree(planes);
kfree(buf);
dma_buf_put(dmabuf);
write = !V4L2_TYPE_IS_OUTPUT(buf->type);
dva = ion_iovmm_map(attachment, 0, dmabuf->size, write, plane);
if (IS_ERR_VALUE(dva)) {
- merr("ion_iovmm_map is fail(%X)", vctx, dva);
+ merr("ion_iovmm_map failed(%X)", vctx, dva);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
group_id = GROUP_ID(device->group_isp.id);
ret = fimc_is_itf_map(device, group_id, dva, dmabuf->size);
if (ret) {
- merr("fimc_is_itf_map is fail(%d)", vctx, ret);
+ merr("fimc_is_itf_map failed(%d)", vctx, ret);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, leader, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, leader, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_isp_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_ischain_isp_buffer_queue(device, queue, index);
if (ret) {
- merr("fimc_is_ischain_isp_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_isp_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_scc_video_fops,
&fimc_is_scc_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_SCC);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
NULL,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_subdev_open(&device->scc, vctx, NULL);
if (ret) {
- err("fimc_is_subdev_open is fail");
+ err("fimc_is_subdev_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret)
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_scc_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(scc, vb->v4l2_buf.index);
if (ret) {
- merr("fimc_is_subdev_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_subdev_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_scp_video_fops,
&fimc_is_scp_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_SCP);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
NULL,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_subdev_open(&device->scp, vctx, NULL);
if (ret) {
- err("fimc_is_subdev_open is fail");
+ err("fimc_is_subdev_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret) {
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
goto p_err;
}
queue->framecfg.width,
queue->framecfg.height);
if (ret)
- merr("fimc_is_ischain_scp_s_format is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_scp_s_format failed(%d)", vctx, ret);
p_err:
return ret;
crop->c.width,
crop->c.height);
if (ret)
- merr("fimc_is_ischain_scp_s_format is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_scp_s_format failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_scp_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(subdev, vb->v4l2_buf.index);
if (ret) {
- merr("fimc_is_subdev_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_subdev_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_sen_video_fops,
&fimc_is_sen_video_ioctl_ops);
if (ret)
- dev_err(&device->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&device->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_SENSOR);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
NULL,
NULL);
if (ret) {
- merr("fimc_is_video_open is fail(%d)", vctx, ret);
+ merr("fimc_is_video_open failed(%d)", vctx, ret);
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_sensor_open(device, vctx);
if (ret) {
- merr("fimc_is_sen_open is fail(%d)", vctx, ret);
+ merr("fimc_is_sen_open failed(%d)", vctx, ret);
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_sensor_close(device);
if (ret)
- err("fimc_is_sensor_close is fail(%d)", ret);
+ err("fimc_is_sensor_close failed(%d)", ret);
ret = fimc_is_video_close(vctx);
if (ret)
- err("fimc_is_video_close is fail(%d)", ret);
+ err("fimc_is_video_close failed(%d)", ret);
ret = close_vctx(file, video, vctx);
if (ret)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret) {
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
goto p_err;
}
queue->framecfg.width,
queue->framecfg.height);
if (ret) {
- merr("fimc_is_sensor_s_format is fail(%d)", vctx, ret);
+ merr("fimc_is_sensor_s_format failed(%d)", vctx, ret);
goto p_err;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(error %d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(error %d)", vctx, ret);
return ret;
}
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
return ret;
}
if (ret) {
blocking = file->f_flags & O_NONBLOCK;
if (!blocking || (ret != -EAGAIN))
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
}
return ret;
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_sensor_s_input(device, input, scenario);
if (ret) {
- merr("fimc_is_sensor_s_input is fail(%d)", device, ret);
+ merr("fimc_is_sensor_s_input failed(%d)", device, ret);
goto p_err;
}
if (sstream == IS_ENABLE_STREAM) {
ret = fimc_is_sensor_front_start(device, instant, noblock);
if (ret) {
- merr("fimc_is_sensor_front_start is fail(%d)", device, ret);
+ merr("fimc_is_sensor_front_start failed(%d)", device, ret);
goto p_err;
}
} else {
ret = fimc_is_sensor_front_stop(device);
if (ret) {
- merr("fimc_is_sensor_front_stop is fail(%d)", device, ret);
+ merr("fimc_is_sensor_front_stop failed(%d)", device, ret);
goto p_err;
}
}
ret = fimc_is_sensor_s_bns(device, ctrl->value);
if (ret) {
- merr("fimc_is_sensor_s_bns is fail(%d)", device, ret);
+ merr("fimc_is_sensor_s_bns failed(%d)", device, ret);
goto p_err;
}
ret = v4l2_subdev_call(subdev_flite, core, s_ctrl, ctrl);
if (ret) {
- merr("v4l2_flite_call(s_ctrl) is fail(%d)", device, ret);
+ merr("v4l2_flite_call(s_ctrl) failed(%d)", device, ret);
goto p_err;
}
break;
ret = fimc_is_sensor_s_framerate(device, parm);
if (ret) {
- merr("fimc_is_sen_s_framerate is fail(%d)", device, ret);
+ merr("fimc_is_sen_s_framerate failed(%d)", device, ret);
goto p_err;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", device, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", device, ret);
return;
}
ret = fimc_is_sensor_buffer_queue(device, vb->v4l2_buf.index);
if (ret) {
- merr("fimc_is_sensor_buffer_queue is fail(%d)", device, ret);
+ merr("fimc_is_sensor_buffer_queue failed(%d)", device, ret);
return;
}
}
device,
vb->v4l2_buf.index);
if (ret)
- merr("fimc_is_sensor_buffer_finish is fail(%d)", device, ret);
+ merr("fimc_is_sensor_buffer_finish failed(%d)", device, ret);
}
const struct vb2_ops fimc_is_sen_qops = {
&fimc_is_vdc_video_fops,
&fimc_is_vdc_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_INVALID, FRAMEMGR_ID_DIS);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
NULL,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_subdev_open(&device->dis, vctx, NULL);
if (ret) {
- err("fimc_is_subdev_open is fail");
+ err("fimc_is_subdev_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_poll(file, vctx, wait);
if (ret)
- merr("fimc_is_video_poll is fail(%d)", vctx, ret);
+ merr("fimc_is_video_poll failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret)
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
dbg_vdisc("req w : %d req h : %d\n",
queue->framecfg.width,
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_vdc_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(subdev, vb->v4l2_buf.index);
if (ret) {
- merr("fimc_is_subdev_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_subdev_buffer_queue failed(%d)", vctx, ret);
return;
}
}
&fimc_is_vdo_video_fops,
&fimc_is_vdo_video_ioctl_ops);
if (ret)
- dev_err(&core->pdev->dev, "%s is fail(%d)\n", __func__, ret);
+ dev_err(&core->pdev->dev, "%s failed(%d)\n", __func__, ret);
p_err:
return ret;
ret = open_vctx(file, video, &vctx, FRAMEMGR_ID_DIS_GRP, FRAMEMGR_ID_INVALID);
if (ret) {
- err("open_vctx is fail(%d)", ret);
+ err("open_vctx failed(%d)", ret);
goto p_err;
}
&fimc_is_ischain_vdo_ops,
&fimc_is_ischain_sub_ops);
if (ret) {
- err("fimc_is_video_open is fail");
+ err("fimc_is_video_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = fimc_is_ischain_vdo_open(device, vctx);
if (ret) {
- err("fimc_is_ischain_vdo_open is fail");
+ err("fimc_is_ischain_vdo_open failed");
close_vctx(file, video, vctx);
goto p_err;
}
ret = close_vctx(file, video, vctx);
if (ret < 0)
- err("close_vctx is fail(%d)", ret);
+ err("close_vctx failed(%d)", ret);
p_err:
return ret;
ret = fimc_is_video_poll(file, vctx, wait);
if (ret)
- merr("fimc_is_video_poll is fail(%d)", vctx, ret);
+ merr("fimc_is_video_poll failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_mmap(file, vctx, vma);
if (ret)
- merr("fimc_is_video_mmap is fail(%d)", vctx, ret);
+ merr("fimc_is_video_mmap failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret)
- merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
+ merr("fimc_is_video_set_format_mplane failed(%d)", vctx, ret);
dbg_vdiso("req w : %d req h : %d\n",
vctx->q_src->framecfg.width,
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
- merr("fimc_is_video_reqbufs is fail(error %d)", vctx, ret);
+ merr("fimc_is_video_reqbufs failed(error %d)", vctx, ret);
return ret;
}
ret = fimc_is_video_querybuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_querybuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_querybuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_qbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_qbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_qbuf failed(%d)", vctx, ret);
p_err:
return ret;
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
- merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
+ merr("fimc_is_video_dqbuf failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamon(file, vctx, type);
if (ret)
- merr("fimc_is_vdo_video_streamon is fail(%d)", vctx, ret);
+ merr("fimc_is_vdo_video_streamon failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
- merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
+ merr("fimc_is_video_streamoff failed(%d)", vctx, ret);
return ret;
}
sizes,
allocators);
if (ret)
- merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_setup failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_start_streaming(queue, device, leader, vctx);
if (ret)
- merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_start_streaming failed(%d)", vctx, ret);
return ret;
}
ret = fimc_is_queue_stop_streaming(queue, device, leader, vctx);
if (ret)
- merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_stop_streaming failed(%d)", vctx, ret);
}
static void fimc_is_vdo_buffer_queue(struct vb2_buffer *vb)
ret = fimc_is_queue_buffer_queue(queue, video->vb2, vb);
if (ret) {
- merr("fimc_is_queue_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_queue_buffer_queue failed(%d)", vctx, ret);
return;
}
ret = fimc_is_ischain_vdo_buffer_queue(device, queue, index);
if (ret) {
- merr("fimc_is_ischain_vdo_buffer_queue is fail(%d)", vctx, ret);
+ merr("fimc_is_ischain_vdo_buffer_queue failed(%d)", vctx, ret);
return;
}
}
*vctx = kzalloc(sizeof(struct fimc_is_video_ctx), GFP_KERNEL);
if (*vctx == NULL) {
- err("kzalloc is fail");
ret = -ENOMEM;
*vctx = NULL;
goto exit;
q_src = kzalloc(sizeof(struct fimc_is_queue), GFP_KERNEL);
if (q_src == NULL) {
- err("kzalloc is fail(q_src)");
ret = -ENOMEM;
kfree(*vctx);
*vctx = NULL;
q_dst = kzalloc(sizeof(struct fimc_is_queue), GFP_KERNEL);
if (q_dst == NULL) {
- err("kzalloc is fail(q_dst)");
ret = -ENOMEM;
kfree(*vctx);
kfree(q_src);
/* Create Kvaddr for Metadata */
queue->buf_kva[index][spare] = vb2->plane_kvaddr(vb, spare);
if (!queue->buf_kva[index][spare]) {
- err("plane_kvaddr is fail(%08X)", framemgr->id);
+ err("plane_kvaddr failed(%08X)", framemgr->id);
ret = -EINVAL;
goto exit;
}
/* Create Kvaddr for frame sync */
queue->buf_kva[index][spare] = vb2->plane_kvaddr(vb, spare);
if (!queue->buf_kva[index][spare]) {
- err("plane_kvaddr is fail(%08X)", framemgr->id);
+ err("plane_kvaddr failed(%08X)", framemgr->id);
ret = -EINVAL;
goto exit;
}
video = vctx->video;
ret = mutex_lock_interruptible(&video->lock);
if (ret)
- err("mutex_lock_interruptible is fail(%d)", ret);
+ err("mutex_lock_interruptible failed(%d)", ret);
}
int fimc_is_queue_start_streaming(struct fimc_is_queue *queue,
ret = CALL_QOPS(queue, start_streaming, device, subdev, queue);
if (ret) {
- merr("start_streaming is fail(%d)", vctx, ret);
+ merr("start_streaming failed(%d)", vctx, ret);
ret = -EINVAL;
goto p_err;
}
ret = CALL_QOPS(queue, stop_streaming, device, subdev, queue);
if (ret) {
- merr("stop_streaming is fail(%d)", vctx, ret);
+ merr("stop_streaming failed(%d)", vctx, ret);
ret = -EINVAL;
goto p_err;
}
q_src->vbq = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
if (!q_src->vbq) {
- err("kzalloc is fail");
ret = -ENOMEM;
goto p_err;
}
q_dst->vbq = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
if (!q_dst->vbq) {
- err("kzalloc is fail");
ret = -ENOMEM;
goto p_err;
}
q_src->vbq = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
if (!q_src->vbq) {
- err("kzalloc is fail");
+ err("kzalloc failed");
ret = -ENOMEM;
goto p_err;
}
q_dst->vbq = kzalloc(sizeof(struct vb2_queue), GFP_KERNEL);
if (!q_dst->vbq) {
- err("kzalloc is fail");
+ err("kzalloc failed");
kfree(q_src->vbq);
ret = -ENOMEM;
goto p_err;
ret = vb2_reqbufs(queue->vbq, request);
if (ret) {
- err("vb2_reqbufs is fail(%d)", ret);
+ err("vb2_reqbufs failed(%d)", ret);
goto p_err;
}
ret = vb2_qbuf(queue->vbq, buf);
if (ret) {
- merr("vb2_qbuf is fail(index : %d, %d)", vctx, buf->index, ret);
+ merr("vb2_qbuf failed(index : %d, %d)", vctx, buf->index, ret);
goto p_err;
}
if (enable) {
ret = CALL_MOPS(sensor, stream_on, subdev);
if (ret < 0) {
- err("s_duration is fail(%d)", ret);
+ err("s_duration failed(%d)", ret);
goto p_err;
}
} else {
ret = CALL_MOPS(sensor, stream_off, subdev);
if (ret < 0) {
- err("s_duration is fail(%d)", ret);
+ err("s_duration failed(%d)", ret);
goto p_err;
}
}
ret = CALL_MOPS(sensor, s_duration, subdev, duration);
if (ret) {
- err("s_duration is fail(%d)", ret);
+ err("s_duration failed(%d)", ret);
goto p_err;
}
ret = fimc_is_sensor_write8(client, 0x4100, 1);
if (ret < 0) {
- err("fimc_is_sensor_write8 is fail(%d)", ret);
+ err("fimc_is_sensor_write8 failed(%d)", ret);
goto p_err;
}
ret = fimc_is_sensor_write8(client, 0x4100, 0);
if (ret < 0) {
- err("fimc_is_sensor_write8 is fail(%d)", ret);
+ err("fimc_is_sensor_write8 failed(%d)", ret);
goto p_err;
}
s = (struct pinctrl_state *)pin_ctrls->pin;
ret = pinctrl_select_state(pinctrl, s);
if (ret < 0) {
- pr_err("%s: cam %s, state %p pinctrl_select_statee is failed\n", __func__, ch_name, s);
+ pr_err("%s: cam %s, state %p pinctrl_select_state failed\n", __func__, ch_name, s);
return ret;
}
regulator = regulator_get(&pdev->dev, name);
if (IS_ERR_OR_NULL(regulator)) {
- pr_err("%s : regulator_get(%s) fail\n", __func__, name);
+ pr_err("%s : regulator_get(%s) failed\n", __func__, name);
return PTR_ERR(regulator);
}
pr_info("%s : regulator_set_voltage(%d)\n",__func__, voltage);
ret = regulator_set_voltage(regulator, voltage, voltage);
if(ret) {
- pr_err("%s : regulator_set_voltage(%d) fail\n", __func__, ret);
+ pr_err("%s : regulator_set_voltage(%d) failed\n", __func__, ret);
}
}
ret = regulator_enable(regulator);
if (ret) {
- pr_err("%s : regulator_enable(%s) fail\n", __func__, name);
+ pr_err("%s : regulator_enable(%s) failed\n", __func__, name);
regulator_put(regulator);
return ret;
}
&pin_ctrls[scenario][enable][i],
pdata->csi_ch);
if (ret) {
- pr_err("exynos5_fimc_is_sensor_gpio(%lu, %s, %d, %d) is fail(%d)",
+ pr_err("exynos5_fimc_is_sensor_gpio(%lu, %s, %d, %d) failed(%d)",
pin_ctrls[scenario][enable][i].pin,
pin_ctrls[scenario][enable][i].name,
pin_ctrls[scenario][enable][i].act,
projects / platform / kernel / linux-exynos.git / commitdiff