static int fimc_is_ischain_allocmem(struct fimc_is_core *this)
{
- int ret = 0;
- void *fw_cookie;
+ struct device *dev = &this->pdev->dev;
+ /* int ret = 0; */
+ /* void *fw_cookie; */
size_t fw_size =
#ifdef ENABLE_ODC
SIZE_ODC_INTERNAL_BUF * NUM_ODC_INTERNAL_BUF +
FIMC_IS_A5_MEM_SIZE;
fw_size = PAGE_ALIGN(fw_size);
+
dbg_core("Allocating memory for FIMC-IS firmware.\n");
-#warning NOT IMPLEMENTED
#if 0
fw_cookie = vb2_ion_private_alloc(this->mem.alloc_ctx, fw_size, 1, 0);
dbg_core("Device vaddr = %08x , size = %08x\n",
this->minfo.dvaddr, FIMC_IS_A5_MEM_SIZE);
- this->minfo.kvaddr = (u32)vb2_ion_private_vaddr(fw_cookie);
- if (IS_ERR((void *)this->minfo.kvaddr)) {
+ this->minfo.kvaddr = vb2_ion_private_vaddr(fw_cookie);
+ if (IS_ERR(this->minfo.kvaddr)) {
err("Bitprocessor memory remap failed");
vb2_ion_private_free(fw_cookie);
this->minfo.kvaddr = 0;
goto exit;
}
-#warning NOT IMPLEMENTED
-#if 0
vb2_ion_sync_for_device(fw_cookie, 0, fw_size, DMA_BIDIRECTIONAL);
-#endif
-#endif
+
exit:
info("[COR] Device virtual for internal: %08x\n", this->minfo.kvaddr);
this->minfo.fw_cookie = fw_cookie;
+#endif
+ this->minfo.kvaddr = dma_alloc_coherent(dev, fw_size,
+ &this->minfo.dvaddr,
+ GFP_KERNEL);
+ if (this->minfo.kvaddr == NULL)
+ return -ENOMEM;
- return ret;
+ /* memset((void *)this->minfo.kvaddr, 0, fw_size); */
+
+ dev_info(dev, "FIMC-IS CPU memory base: %pad\n", &this->minfo.dvaddr);
+
+ if (((u32)this->minfo.dvaddr) & FIMC_IS_FW_BASE_MASK) {
+ dev_err(dev, "invalid firmware memory alignment: %pad\n",
+ &this->minfo.dvaddr);
+ dma_free_coherent(dev, fw_size, this->minfo.kvaddr,
+ this->minfo.dvaddr);
+ return -EIO;
+ }
+
+ return 0;
}
static int fimc_is_ishcain_initmem(struct fimc_is_core *this)
return -ENODEV;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
dev_err(dev, "%s: core is NULL", __func__);
return -EINVAL;
}
fimc_is_interface_probe(&core->interface,
- (u32)core->regs,
+ core->regs,
core->irq,
core);
&core->mem,
core->pdev,
0,
- (u32)core->regs);
+ core->regs);
/* device entity - ischain1 */
fimc_is_ischain_probe(&core->ischain[1],
&core->mem,
core->pdev,
1,
- (u32)core->regs);
+ core->regs);
/* device entity - ischain2 */
fimc_is_ischain_probe(&core->ischain[2],
&core->mem,
core->pdev,
2,
- (u32)core->regs);
+ core->regs);
ret = v4l2_device_register(&pdev->dev, &core->v4l2_dev);
if (ret) {
if (!fimc_is_dev)
goto probe_defer;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core)
goto probe_defer;
dbg_core("%s\n", __func__);
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
pr_info("%s start\n",__func__);
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
#include "fimc-is-device-af.h"
#define FIMC_IS_AF_DEV_NAME "exynos-fimc-is-af"
-static int af_noise_count;
-
-static struct remove_af_noise af_sensor_interface = {
- .af_pdata = NULL,
- .af_func = NULL,
-};
static void fimc_is_af_i2c_config(struct i2c_client *client, bool onoff)
{
int fimc_is_af_ldo_enable(char *name, bool on)
{
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
struct regulator *regulator = NULL;
struct platform_device *pdev = NULL;
int ret = 0;
bool fimc_is_check_regulator_status(char *name)
{
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
struct regulator *regulator = NULL;
struct platform_device *pdev = NULL;
int ret = 0;
int16_t fimc_is_af_enable(void *device, bool onoff)
{
int ret = 0;
- struct fimc_is_device_af *af_device = (struct fimc_is_device_af *)device;
+ struct fimc_is_device_af *af_device = device;
struct fimc_is_core *core;
bool af_regulator = false, io_regulator = false;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -ENODEV;
err("i2c write fail\n");
goto power_off;
}
- af_noise_count++;
- pr_info("af_noise : count = %d\n", af_noise_count);
} else {
/* Check the Power Pins */
af_regulator = fimc_is_check_regulator_status("CAM_AF_2.8V_AP");
{
struct fimc_is_device_af *device;
struct fimc_is_core *core;
- int ret;
if (fimc_is_dev == NULL) {
warn("fimc_is_dev is not yet probed");
return -EPROBE_DEFER;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core)
return -EINVAL;
device->client = client;
device->core = core;
-#if 0
- af_noise_count = 0;
-
- af_sensor_interface.af_pdata = device;
- af_sensor_interface.af_func = &fimc_is_af_enable;
- ret = remove_af_noise_register(&af_sensor_interface);
- if (ret)
- err("reduce_af_noise_register failed: %d\n", ret);
-#endif
i2c_set_clientdata(client, device);
return 0;
static int fimc_is_af_remove(struct i2c_client *client)
{
-#if 0
- remove_af_noise_unregister(&af_sensor_interface);
-#endif
return 0;
}
pdata = device->pdata;
pin_ctrls = pdata->pin_ctrls;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (test_bit(FIMC_IS_COMPANION_GPIO_ON, &device->state)) {
err("%s : already gpio on", __func__);
{
int ret = 0;
struct exynos_platform_fimc_is_sensor *pdata;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
BUG_ON(!device);
BUG_ON(!device->pdev);
BUG_ON(!device);
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
spi_gpio = &core->spi_gpio;
if (test_bit(FIMC_IS_COMPANION_OPEN, &device->state)) {
int fimc_is_companion_close(struct fimc_is_device_companion *device)
{
int ret = 0;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
return -EPROBE_DEFER;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
info("%s\n", __func__);
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
}
- device = (struct fimc_is_device_companion *)platform_get_drvdata(pdev);
+ device = platform_get_drvdata(pdev);
if (!device) {
err("device is NULL");
ret = -EINVAL;
struct fimc_is_device_companion *device;
struct fimc_is_core *core;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
}
- device = (struct fimc_is_device_companion *)platform_get_drvdata(pdev);
+ device = platform_get_drvdata(pdev);
if (!device) {
err("device is NULL");
return -EINVAL;
}
/* value : module enum */
-static int csi_init(struct v4l2_subdev *subdev, u32 value)
+static int csi_init(struct v4l2_subdev *subdev, void *value)
{
int ret = 0;
struct fimc_is_device_csi *csi;
goto p_err;
}
- module = (struct fimc_is_module_enum *)value;
+ module = value;
csi->sensor_cfgs = module->cfgs;
csi->sensor_cfg = module->cfg;
csi->vcis = module->vcis;
BUG_ON(!subdev);
- csi = (struct fimc_is_device_csi *)v4l2_get_subdevdata(subdev);
+ csi = v4l2_get_subdevdata(subdev);
if (!csi) {
err("csi is NULL");
return -EINVAL;
BUG_ON(!subdev);
- csi = (struct fimc_is_device_csi *)v4l2_get_subdevdata(subdev);
+ csi = v4l2_get_subdevdata(subdev);
if (!csi) {
err("csi is NULL");
return -EINVAL;
cp = ¶m->parm.capture;
tpf = &cp->timeperframe;
- csi = (struct fimc_is_device_csi *)v4l2_get_subdevdata(subdev);
+ csi = v4l2_get_subdevdata(subdev);
if (!csi) {
err("csi is NULL");
return -EINVAL;
BUG_ON(!subdev);
BUG_ON(!fmt);
- csi = (struct fimc_is_device_csi *)v4l2_get_subdevdata(subdev);
+ csi = v4l2_get_subdevdata(subdev);
if (!csi) {
err("csi is NULL");
return -EINVAL;
struct fimc_is_device_flite *flite;
struct fimc_is_core *core;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
BUG_ON(!core);
BUG_ON(!subdev);
struct fimc_is_device_flite *flite;
struct fimc_is_core *core;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
BUG_ON(!core);
BUG_ON(!subdev);
}
/* value : csi ch */
-static int flite_init(struct v4l2_subdev *subdev, u32 value)
+static int flite_init(struct v4l2_subdev *subdev, void *value)
{
int ret = 0;
struct fimc_is_device_flite *flite;
goto p_err;
}
- flite->csi = value;
+ flite->csi = (long)value;
p_err:
return ret;
nowait = (enable & FLITE_NOWAIT_MASK) >> FLITE_NOWAIT_SHIFT;
enable = enable & FLITE_ENABLE_MASK;
- flite = (struct fimc_is_device_flite *)v4l2_get_subdevdata(subdev);
+ flite = v4l2_get_subdevdata(subdev);
if (!flite) {
err("flite is NULL");
ret = -EINVAL;
BUG_ON(!subdev);
BUG_ON(!fmt);
- flite = (struct fimc_is_device_flite *)v4l2_get_subdevdata(subdev);
+ flite = v4l2_get_subdevdata(subdev);
if (!flite) {
err("flite is NULL");
ret = -EINVAL;
BUG_ON(!subdev);
BUG_ON(!ctrl);
- flite = (struct fimc_is_device_flite *)v4l2_get_subdevdata(subdev);
+ flite = v4l2_get_subdevdata(subdev);
if (!flite) {
err("flite is NULL");
ret = -EINVAL;
return 0;
}
-static int isfw_debug_read(struct file *file, char __user *user_buf,
+static ssize_t isfw_debug_read(struct file *file, char __user *user_buf,
size_t buf_len, loff_t *ppos)
{
char *debug;
count2 = 0;
debug_cnt = 0;
imemory = &device->imemory;
- core = (struct fimc_is_core *)device->interface->core;
+ core = device->interface->core;
if (atomic_read(&core->video_isp.refcount) <= 0) {
err("isp video node is not open");
goto exit;
}
-#warning NOT IMPLEMENTED
#if 0
vb2_ion_sync_for_device(imemory->fw_cookie, DEBUG_OFFSET,
DEBUG_CNT, DMA_FROM_DEVICE);
core->debug_cnt = count2;
}
- info("FW_READ : Origin(%d), New(%d) - Length(%d)\n",
+ info("FW_READ : Origin(%zd), New(%d) - Length(%zd)\n",
backup_cnt,
core->debug_cnt,
(buf_len - buf_count));
static void fimc_is_ischain_cache_flush(struct fimc_is_device_ischain *this,
u32 offset, u32 size)
{
-#warning NOT IMPLEMENTED
#if 0
vb2_ion_sync_for_device(this->imemory.fw_cookie,
offset,
static void fimc_is_ischain_region_invalid(struct fimc_is_device_ischain *device)
{
-#warning NOT IMPLEMENTED
#if 0
vb2_ion_sync_for_device(
device->imemory.fw_cookie,
static void fimc_is_ischain_region_flush(struct fimc_is_device_ischain *device)
{
-#warning NOT IMPLEMENTED
#if 0
vb2_ion_sync_for_device(
device->imemory.fw_cookie,
void fimc_is_ischain_meta_flush(struct fimc_is_frame *frame)
{
-#warning NOT IMPLEMENTED
#if 0
#ifdef ENABLE_CACHE
vb2_ion_sync_for_device(
void fimc_is_ischain_meta_invalid(struct fimc_is_frame *frame)
{
-#warning NOT IMPLEMENTED
#if 0
#ifdef ENABLE_CACHE
vb2_ion_sync_for_device(
u8 *buf = NULL;
#ifdef USE_ION_ALLOC
struct ion_handle *handle = NULL;
- struct fimc_is_core *core = (struct fimc_is_core *)platform_get_drvdata(device->pdev);
+ struct fimc_is_core *core = platform_get_drvdata(device->pdev);
#endif
#ifdef SDCARD_FW
struct file *fp = NULL;
u8 *buf = NULL;
#ifdef USE_ION_ALLOC
struct ion_handle *handle = NULL;
- struct fimc_is_core *core = (struct fimc_is_core *)platform_get_drvdata(device->pdev);
+ struct fimc_is_core *core = platform_get_drvdata(device->pdev);
#endif
#ifdef SDCARD_FW
goto out;
}
- address = (void *)(device->imemory.kvaddr + load_addr);
- memcpy((void *)address, (void *)buf, fsize);
+ address = (device->imemory.kvaddr + load_addr);
+ memcpy(address, buf, fsize);
fimc_is_ischain_cache_flush(device, load_addr, fsize + 1);
fimc_is_ischain_version(device, setfile_name, buf, fsize);
goto out;
}
- address = (void *)(device->imemory.kvaddr + load_addr);
+ address = (device->imemory.kvaddr + load_addr);
memcpy(address, fw_blob->data, fw_blob->size);
fimc_is_ischain_cache_flush(device, load_addr, fw_blob->size + 1);
fimc_is_ischain_version(device, setfile_name, fw_blob->data,
struct fimc_is_from_info *sysfs_finfo;
char *cal_buf;
- struct fimc_is_core *core = (struct fimc_is_core *)platform_get_drvdata(device->pdev);
+ struct fimc_is_core *core = platform_get_drvdata(device->pdev);
mdbgd_ischain("%s\n", device, __func__);
cal_ptr = (char *)(device->imemory.kvaddr + FIMC_IS_CAL_START_ADDR);
BUG();
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
BUG();
char setf_name[100];
struct device *dev = &device->pdev->dev;
- struct fimc_is_core *core = (struct fimc_is_core *)platform_get_drvdata(device->pdev);
+ struct fimc_is_core *core = platform_get_drvdata(device->pdev);
struct fimc_is_from_info *sysfs_finfo;
if (on) {
writel(device->imemory.dvaddr, device->regs + BBOAR);
val = __raw_readl(device->regs + BBOAR);
if(device->imemory.dvaddr != val)
- err("dvaddr : %x , BBOAR : %x", device->imemory.dvaddr,val);
+ err("dvaddr : %pad , BBOAR : %x", &(device->imemory.dvaddr), val);
exynos_smc(SMC_CMD_REG, SMC_REG_ID_SFR_W(PA_FIMC_IS_GIC_C + 0x4), 0x000000FF, 0);
for (i = 0; i < 3; i++)
{
int ret = 0;
u32 flag, index;
- u32 dst_base, src_base;
+ void *dst_base, *src_base;
BUG_ON(!device);
BUG();
}
- dst_base = (u32)&device->is_region->parameter;
- src_base = (u32)frame->shot->ctl.entry.parameter;
+ dst_base = &device->is_region->parameter;
+ src_base = frame->shot->ctl.entry.parameter;
for (index = 0; lindex && (index < 32); index++) {
flag = 1 << index;
if (lindex & flag) {
- memcpy((u32 *)(dst_base + (index * PARAMETER_MAX_SIZE)),
- (u32 *)(src_base + (index * PARAMETER_MAX_SIZE)),
+ memcpy((dst_base + (index * PARAMETER_MAX_SIZE)),
+ (src_base + (index * PARAMETER_MAX_SIZE)),
PARAMETER_MAX_SIZE);
lindex &= ~flag;
}
for (index = 0; hindex && (index < 32); index++) {
flag = 1 << index;
if (hindex & flag) {
- memcpy((u32 *)(dst_base + ((32 + index) * PARAMETER_MAX_SIZE)),
- (u32 *)(src_base + ((32 + index) * PARAMETER_MAX_SIZE)),
+ memcpy((dst_base + ((32 + index) * PARAMETER_MAX_SIZE)),
+ (src_base + ((32 + index) * PARAMETER_MAX_SIZE)),
PARAMETER_MAX_SIZE);
hindex &= ~flag;
}
struct fimc_is_frame *frame,
u32 index)
{
- u32 dst_base, src_base, dst_param, src_param;
+ void *dst_base, *src_base, *dst_param, *src_param;
BUG_ON(!device);
BUG();
}
- dst_base = (u32)&frame->shot->ctl.entry.parameter[0];
+ dst_base = &frame->shot->ctl.entry.parameter[0];
dst_param = (dst_base + (index * PARAMETER_MAX_SIZE));
- src_base = (u32)&device->is_region->parameter;
+ src_base = &device->is_region->parameter;
src_param = (src_base + (index * PARAMETER_MAX_SIZE));
- memcpy((u32 *)dst_param, (u32 *)src_param, PARAMETER_MAX_SIZE);
+ memcpy(dst_param, src_param, PARAMETER_MAX_SIZE);
} else {
- dst_base = (u32)&device->is_region->parameter;
+ dst_base = &device->is_region->parameter;
dst_param = (dst_base + (index * PARAMETER_MAX_SIZE));
}
if (frame->shot->magicNumber != SHOT_MAGIC_NUMBER) {
merr("shot magic number error(0x%08X)\n", device, frame->shot->magicNumber);
- merr("shot_ext size : %d", device, sizeof(struct camera2_shot_ext));
+ merr("shot_ext size : %ld", device, sizeof(struct camera2_shot_ext));
ret = -EINVAL;
goto p_err;
}
struct fimc_is_mem *mem,
struct platform_device *pdev,
u32 instance,
- u32 regs)
+ void * regs)
{
int ret = 0;
struct fimc_is_subdev *scc, *dis, *scp;
imemory = &device->imemory;
imemory->base = minfo->base;
imemory->size = minfo->size;
- imemory->vaddr_base = minfo->vaddr_base;
- imemory->vaddr_curr = minfo->vaddr_curr;
imemory->fw_cookie = minfo->fw_cookie;
imemory->dvaddr = minfo->dvaddr;
imemory->kvaddr = minfo->kvaddr;
imemory->dvaddr_region = imemory->dvaddr + imemory->offset_region;
imemory->kvaddr_region = imemory->kvaddr + imemory->offset_region;
imemory->is_region = (struct is_region *)imemory->kvaddr_region;
- imemory->offset_shared = (u32)&imemory->is_region->shared[0] -
- imemory->kvaddr;
+ imemory->offset_shared = (void *)(&imemory->is_region->shared[0]) - imemory->kvaddr;
imemory->dvaddr_shared = imemory->dvaddr + imemory->offset_shared;
imemory->kvaddr_shared = imemory->kvaddr + imemory->offset_shared;
device->is_region = imemory->is_region;
group = &device->group_isp;
leader = &group->leader;
queue = GET_SRC_QUEUE(vctx);
- core = (struct fimc_is_core *)device->interface->core;
+ core = device->interface->core;
refcount = atomic_read(&vctx->video->refcount);
spi_gpio = &core->spi_gpio;
if (refcount < 0) {
mdbgd_ischain("%s(input : %08X)\n", device, __func__, input);
- core = (struct fimc_is_core *)platform_get_drvdata(device->pdev);
+ core = platform_get_drvdata(device->pdev);
module = input & MODULE_MASK;
ssx_vindex = (input & SSX_VINDEX_MASK) >> SSX_VINDEX_SHIFT;
/* check crop size */
if (test_bit(FIMC_IS_GROUP_OTF_INPUT, &device->group_3aa.state)) {
if (bns_width <= total_width) {
- merr("crop width(%d) is bigger than input width(%d)\n",
+ merr("crop width(%zd) is bigger than input width(%zd)\n",
device, total_width, bns_width);
goto p_err;
}
if (bns_height <= total_height) {
- merr("crop height(%d) is bigger than input height(%d)\n",
+ merr("crop height(%zd) is bigger than input height(%zd)\n",
device, total_height, bns_height);
goto p_err;
}
taa_dma_input->cmd = DMA_INPUT_COMMAND_DISABLE;
} else {
if (sensor_width <= total_width) {
- merr("crop width(%d) is bigger than input width(%d)\n",
+ merr("crop width(%zd) is bigger than input width(%zd)\n",
device, total_width, sensor_width);
goto p_err;
}
if (sensor_height <= total_height) {
- merr("crop height(%d) is bigger than input height(%d)\n",
+ merr("crop height(%zd) is bigger than input height(%zd)\n",
device, total_height, sensor_height);
goto p_err;
}
};
int fimc_is_ischain_g_capability(struct fimc_is_device_ischain *this,
- u32 user_ptr)
+ void *user_ptr)
{
int ret = 0;
- ret = copy_to_user((void *)user_ptr, &this->capability,
+ ret = copy_to_user(user_ptr, &this->capability,
sizeof(struct camera2_sm));
return ret;
}
if (unlikely(frame != check_frame)) {
- merr("frame checking is fail(%X != %X)", device,
- (u32)frame, (u32)check_frame);
+ merr("frame checking is fail(%p != %p)", device,
+ frame, check_frame);
ret = -EINVAL;
goto p_err;
}
}
if (unlikely(frame != check_frame)) {
- merr("frame checking is fail(%X != %X)", device,
- (u32)frame, (u32)check_frame);
+ merr("frame checking is fail(%p != %p)", device,
+ frame, check_frame);
ret = -EINVAL;
goto p_err;
}
#ifdef PRINT_PARAM
if (frame->fcount == 1) {
fimc_is_hw_memdump(device->interface,
- (u32) &device->is_region->parameter,
- (u32) &device->is_region->parameter + sizeof(device->is_region->parameter));
+ &device->is_region->parameter,
+ ((void *)&device->is_region->parameter) + sizeof(device->is_region->parameter));
}
#endif
fimc_is_frame_request_head(framemgr, &frame);
if (frame != check_frame) {
- merr("grp_frame is invalid(%X != %X)", device,
- (u32)frame, (u32)check_frame);
+ merr("grp_frame is invalid(%p != %p)", device,
+ frame, check_frame);
return -EINVAL;
}
dma_addr_t base;
/* total length */
size_t size;
- /* buffer base */
- dma_addr_t vaddr_base;
- /* current addr */
- dma_addr_t vaddr_curr;
void *fw_cookie;
/* fw memory base */
- u32 dvaddr;
- u32 kvaddr;
+ dma_addr_t dvaddr;
+ void * kvaddr;
/* debug part of fw memory */
- u32 dvaddr_debug;
- u32 kvaddr_debug;
+ dma_addr_t dvaddr_debug;
+ void * kvaddr_debug;
/* is region part of fw memory */
u32 offset_region;
- u32 dvaddr_region;
- u32 kvaddr_region;
+ dma_addr_t dvaddr_region;
+ void * kvaddr_region;
/* shared part of is region */
u32 offset_shared;
- u32 dvaddr_shared;
- u32 kvaddr_shared;
+ dma_addr_t dvaddr_shared;
+ void * kvaddr_shared;
/* internal memory for ODC */
- u32 dvaddr_odc;
- u32 kvaddr_odc;
+ dma_addr_t dvaddr_odc;
+ void * kvaddr_odc;
/* internal memory for DIS */
- u32 dvaddr_dis;
- u32 kvaddr_dis;
+ dma_addr_t dvaddr_dis;
+ void * kvaddr_dis;
/* internal memory for 3DNR */
- u32 dvaddr_3dnr;
- u32 kvaddr_3dnr;
+ dma_addr_t dvaddr_3dnr;
+ void * kvaddr_3dnr;
struct is_region *is_region;
};
u32 chain3_height;
struct fimc_is_subdev fd;
- u32 private_data;
+ void * private_data;
struct fimc_is_device_sensor *sensor;
};
struct fimc_is_mem *mem,
struct platform_device *pdev,
u32 instance,
- u32 regs);
+ void * regs);
int fimc_is_ischain_open(struct fimc_is_device_ischain *device,
struct fimc_is_video_ctx *vctx,
struct fimc_is_minfo *minfo);
int fimc_is_ischain_init_wrap(struct fimc_is_device_ischain *device,
u32 input);
int fimc_is_ischain_g_capability(struct fimc_is_device_ischain *this,
- u32 user_ptr);
+ void *user_ptr);
void fimc_is_ischain_meta_invalid(struct fimc_is_frame *frame);
/* 3AA subdev */
return -EPROBE_DEFER;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core)
return -EINVAL;
{
int ret = 0;
struct exynos_platform_fimc_is_sensor *pdata;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
BUG_ON(!device);
BUG_ON(!device->pdev);
{
int ret = 0;
struct exynos_platform_fimc_is_sensor *pdata;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
BUG_ON(!device);
BUG_ON(!device->pdev);
fimc_is_sensor_dtp((unsigned long)device);
#endif
- frame = (struct fimc_is_frame *)arg;
+ frame = arg;
if (frame) {
frame->has_fcount = false;
buffer_done(device->vctx, frame->index);
return -EPROBE_DEFER;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
struct fimc_is_video_ctx *vctx)
{
int ret = 0;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
struct exynos_platform_fimc_is_sensor *pdata;
BUG_ON(!device);
int ret = 0;
struct fimc_is_device_ischain *ischain;
struct fimc_is_group *group_3aa;
- struct fimc_is_core *core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ struct fimc_is_core *core = dev_get_drvdata(fimc_is_dev);
struct exynos_platform_fimc_is_sensor *pdata;
BUG_ON(!device);
goto p_err;
}
- ret = v4l2_subdev_call(subdev_flite, core, init, device->pdata->csi_ch);
+ ret = v4l2_subdev_call(subdev_flite, core, init, (void *)(long)device->pdata->csi_ch);
if (ret) {
merr("v4l2_flite_call(init) is fail(%d)", device, ret);
goto p_err;
}
- ret = v4l2_subdev_call(subdev_csi, core, init, (u32)module);
+ ret = v4l2_subdev_call(subdev_csi, core, init, module);
if (ret) {
merr("v4l2_csi_call(init) is fail(%d)", device, ret);
goto p_err;
subdev_csi = device->subdev_csi;
subdev_flite = device->subdev_flite;
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev_module);
+ module = v4l2_get_subdevdata(subdev_module);
if (!module) {
merr("module is NULL", device);
goto p_err;
goto p_err;
}
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev_module);
+ module = v4l2_get_subdevdata(subdev_module);
if (!module) {
merr("module is NULL", device);
ret = -EINVAL;
BUG_ON(!device);
BUG_ON(!device->subdev_module);
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(device->subdev_module);
+ module = v4l2_get_subdevdata(device->subdev_module);
if (!module) {
merr("module is NULL", device);
goto p_err;
BUG_ON(!device);
BUG_ON(!device->subdev_module);
- *module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(device->subdev_module);
+ *module = v4l2_get_subdevdata(device->subdev_module);
if (!*module) {
merr("module is NULL", device);
ret = -EINVAL;
goto p_err;
}
- flite = (struct fimc_is_device_flite *)v4l2_get_subdevdata(subdev_flite);
+ flite = v4l2_get_subdevdata(subdev_flite);
if (!flite) {
merr("flite is NULL", device);
ret = -EINVAL;
goto p_err;
}
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev_module);
+ module = v4l2_get_subdevdata(subdev_module);
if (!module) {
merr("module is NULL", device);
ret = -EINVAL;
BUG_ON(!pdev);
- device = (struct fimc_is_device_sensor *)platform_get_drvdata(pdev);
+ device = platform_get_drvdata(pdev);
if (!device) {
err("device is NULL");
return -EINVAL;
struct fimc_is_device_sensor *device;
struct v4l2_subdev *subdev_csi;
- device = (struct fimc_is_device_sensor *)platform_get_drvdata(pdev);
+ device = platform_get_drvdata(pdev);
if (!device) {
err("device is NULL");
return -EINVAL;
return -ENODEV;
}
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core is NULL");
return -EINVAL;
/* group leader use */
struct camera2_shot *shot;
struct camera2_shot_ext *shot_ext;
- u32 kvaddr_shot;
- u32 dvaddr_shot;
- u32 cookie_shot;
+ void * kvaddr_shot;
+ dma_addr_t dvaddr_shot;
+ void * cookie_shot;
u32 shot_size;
/* stream use */
/* common use */
u32 planes;
- u32 kvaddr_buffer[FIMC_IS_MAX_PLANES];
- u32 dvaddr_buffer[FIMC_IS_MAX_PLANES];
+ void * kvaddr_buffer[FIMC_IS_MAX_PLANES];
+ dma_addr_t dvaddr_buffer[FIMC_IS_MAX_PLANES];
/* internal use */
unsigned long memory;
leader = &group->leader;
framemgr = GET_SRC_FRAMEMGR(vctx);
- core = (struct fimc_is_core *)device->interface->core;
+ core = device->interface->core;
mdbgd_ischain("%s(id %d)\n", device, __func__, id);
if (frame->state == FIMC_IS_FRAME_STATE_FREE) {
if (frame->req_flag) {
- merr("req_flag of buffer%d is not clear(%08X)",
- group, frame->index, (u32)frame->req_flag);
+ merr("req_flag of buffer%d is not clear(%08lX)",
+ group, frame->index, frame->req_flag);
frame->req_flag = 0;
}
get_req_work(work_list, &work);
while (work) {
- core = (struct fimc_is_core *)itf->core;
+ core = itf->core;
instance = work->msg.instance;
group_id = work->msg.group;
device = &((struct fimc_is_core *)itf->core)->ischain[instance];
clear_bit(req_flag, &frame->req_flag);
if (frame->req_flag)
- merr("group(%d) req flag is not clear all(%X)",
- device, group->id, (u32)frame->req_flag);
+ merr("group(%d) req flag is not clear all(%lX)",
+ device, group->id, frame->req_flag);
wq_func_group(groupmgr, group, grp_framemgr, frame,
vctx, status1, status2, fcount);
struct fimc_is_work *work;
u32 status;
- itf = (struct fimc_is_interface *)data;
+ itf = data;
status = fimc_is_get_intr(itf);
if (status & (1<<INTR_SHOT_DONE)) {
#define VERSION_OF_NO_NEED_IFLAG 221
int fimc_is_interface_probe(struct fimc_is_interface *this,
- u32 regs,
+ void *regs,
u32 irq,
void *core_data)
{
int ret = 0;
- struct fimc_is_core *core = (struct fimc_is_core *)core_data;
+ struct fimc_is_core *core = core_data;
dbg_interface("%s\n", __func__);
INIT_WORK(&this->work_wq[INTR_SCP_FDONE], wq_func_scp);
INIT_WORK(&this->work_wq[INTR_SHOT_DONE], wq_func_shot);
- this->regs = (void *)regs;
- this->com_regs = (struct is_common_reg *)(regs + ISSR0);
+ this->regs = regs;
+ this->com_regs = (regs + ISSR0);
if (GET_FIMC_IS_VER_OF_SUBIP(core, mcuctl) < VERSION_OF_NO_NEED_IFLAG)
this->need_iflag = true;
pr_err("\n### firmware messsage dump ###\n");
- core = (struct fimc_is_core *)this->core;
+ core = this->core;
sentence_i = 0;
-#warning NOT IMPLEMENTED
#if 0
vb2_ion_sync_for_device(core->minfo.fw_cookie,
DEBUG_OFFSET, DEBUG_CNT, DMA_FROM_DEVICE);
}
int fimc_is_hw_memdump(struct fimc_is_interface *this,
- u32 start,
- u32 end)
+ void *start,
+ void *end)
{
int ret = 0;
u32 *cur;
goto p_err;
}
- cur = (u32 *)start;
+ cur = start;
items = 0;
offset = 0;
memset(sentence, 0, sizeof(sentence));
- printk(KERN_ERR "Memory Dump(0x%08X ~ 0x%08X)\n", start, end);
+ printk(KERN_ERR "Memory Dump(%p ~ %p)\n", start, end);
- while ((u32)cur <= end) {
+ while ((void *)cur <= end) {
if (!(items % 8)) {
printk(KERN_ERR "%s", sentence);
offset = 0;
items++;
}
- ret = (u32)cur - end;
+ ret = (void *)cur - end;
p_err:
return ret;
};
int fimc_is_interface_probe(struct fimc_is_interface *this,
- u32 regs,
+ void *regs,
u32 irq,
void *core_data);
int fimc_is_interface_open(struct fimc_is_interface *this);
int fimc_is_hw_logdump(struct fimc_is_interface *this);
int fimc_is_hw_regdump(struct fimc_is_interface *this);
int fimc_is_hw_memdump(struct fimc_is_interface *this,
- u32 start,
- u32 end);
+ void *start,
+ void *end);
int fimc_is_hw_enum(struct fimc_is_interface *this);
int fimc_is_hw_open(struct fimc_is_interface *this,
u32 instance, u32 module, u32 info, u32 group, u32 flag,
#include "fimc-is-regs.h"
#include "fimc-is-err.h"
-#ifdef IOC_ALLOC
-static void *fimc_is_ion_init(struct platform_device *pdev)
+static dma_addr_t plane_addr(struct vb2_buffer *vb, u32 plane_no)
{
- return vb2_ion_create_context(&pdev->dev, SZ_4K,
- VB2ION_CTX_IOMMU |
- VB2ION_CTX_VMCONTIG |
- VB2ION_CTX_KVA_ONDEMAND);
-}
-#endif
-
-static unsigned long plane_addr(struct vb2_buffer *vb, u32 plane_no)
-{
-#ifdef IOC_ALLOC
- void *cookie = vb2_plane_cookie(vb, plane_no);
- dma_addr_t dva = 0;
-
- WARN_ON(vb2_ion_dma_address(cookie, &dva) != 0);
-#else
return vb2_dma_contig_plane_dma_addr(vb, plane_no);
-#endif
}
-static unsigned long plane_kvaddr(struct vb2_buffer *vb, u32 plane_no)
+static void * plane_kvaddr(struct vb2_buffer *vb, u32 plane_no)
{
void *kvaddr = vb2_plane_vaddr(vb, plane_no);
- return (unsigned long)kvaddr;
+ return kvaddr;
}
}
-#ifdef IOC_ALLOC
-const struct fimc_is_vb2 fimc_is_vb2_ion = {
- .ops = &vb2_ion_memops,
- .init = fimc_is_ion_init,
- .cleanup = vb2_ion_destroy_context,
- .plane_addr = plane_addr,
- .plane_kvaddr = plane_kvaddr,
- .resume = vb2_ion_attach_iommu,
- .suspend = vb2_ion_detach_iommu,
- .set_cacheable = vb2_ion_set_cached,
-};
-#define fimc_is_vb2_allocator (&fimc_is_vb2_ion)
-#else
const struct fimc_is_vb2 fimc_is_vb2_dc = {
.ops = &vb2_dma_contig_memops,
.init = fimc_is_dma_contig_init,
.set_cacheable = vb2_null_set_cached,
};
#define fimc_is_vb2_allocator (&fimc_is_vb2_dc)
-#endif
int fimc_is_mem_probe(struct fimc_is_mem *this,
struct platform_device *pdev)
goto p_err;
}
-#ifdef IOC_ALLOC
- /* FIXME: should be different by device type */
- exynos_create_iovmm(&pdev->dev, 1, 4);
-#endif
p_err:
return ret;
}
#include <linux/platform_device.h>
#include <media/videobuf2-core.h>
-#if defined(CONFIG_VIDEOBUF2_CMA_PHYS)
-#include <media/videobuf2-cma-phys.h>
-#elif defined(CONFIG_VIDEOBUF2_ION)
-#include <media/videobuf2-ion.h>
-#endif
struct fimc_is_minfo {
dma_addr_t base; /* buffer base */
size_t size; /* total length */
- dma_addr_t vaddr_base; /* buffer base */
- dma_addr_t vaddr_curr; /* current addr */
void *bitproc_buf;
void *fw_cookie;
- u32 dvaddr;
- u32 kvaddr;
- u32 dvaddr_debug;
- u32 kvaddr_debug;
- u32 dvaddr_fshared;
- u32 kvaddr_fshared;
- u32 dvaddr_region;
- u32 kvaddr_region;
- u32 dvaddr_shared; /*shared region of is region*/
- u32 kvaddr_shared;
- u32 dvaddr_odc;
- u32 kvaddr_odc;
- u32 dvaddr_dis;
- u32 kvaddr_dis;
- u32 dvaddr_3dnr;
- u32 kvaddr_3dnr;
+ dma_addr_t dvaddr;
+ void * kvaddr;
+ dma_addr_t dvaddr_debug;
+ void * kvaddr_debug;
+ dma_addr_t dvaddr_fshared;
+ void * kvaddr_fshared;
+ dma_addr_t dvaddr_region;
+ void * kvaddr_region;
+ dma_addr_t dvaddr_shared; /*shared region of is region*/
+ void * kvaddr_shared;
+ dma_addr_t dvaddr_odc;
+ void * kvaddr_odc;
+ dma_addr_t dvaddr_dis;
+ void * kvaddr_dis;
+ dma_addr_t dvaddr_3dnr;
+ void * kvaddr_3dnr;
};
struct fimc_is_vb2 {
void *(*init)(struct platform_device *pdev);
void (*cleanup)(void *alloc_ctx);
- unsigned long (*plane_addr)(struct vb2_buffer *vb, u32 plane_no);
- unsigned long (*plane_kvaddr)(struct vb2_buffer *vb, u32 plane_no);
+ dma_addr_t (*plane_addr)(struct vb2_buffer *vb, u32 plane_no);
+ void * (*plane_kvaddr)(struct vb2_buffer *vb, u32 plane_no);
int (*resume)(void *alloc_ctx);
void (*suspend)(void *alloc_ctx);
\remarks
[X] kernel virtual address for this buffer
*/
- uint32_t address;
+ void * address;
/** \brief
this frame count is from FLITE through dm.request.fcount,
BUG_ON(rsc_type >= RESOURCE_TYPE_MAX);
resource = GET_RESOURCE(resourcemgr, rsc_type);
- core = (struct fimc_is_core *)resourcemgr->private_data;
+ core = resourcemgr->private_data;
rsccount = atomic_read(&core->rsccount);
if (rsccount >= 5) {
BUG_ON(rsc_type >= RESOURCE_TYPE_MAX);
resource = GET_RESOURCE(resourcemgr, rsc_type);
- core = (struct fimc_is_core *)resourcemgr->private_data;
+ core = resourcemgr->private_data;
rsccount = atomic_read(&core->rsccount);
if (rsccount == 0) {
struct platform_device *pdev;
void __iomem *regs;
atomic_t rsccount;
- u32 private_data;
+ void * private_data;
};
struct fimc_is_resourcemgr {
if (frame->state == FIMC_IS_FRAME_STATE_FREE) {
if (frame->req_flag) {
- warn("%d request flag is not clear(%08X)\n",
- frame->index, (u32)frame->req_flag);
+ warn("%d request flag is not clear(%08lX)\n",
+ frame->index, frame->req_flag);
frame->req_flag = 0;
}
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_3a0;
if (!core->pdev) {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_3a1;
if (!core->pdev) {
}
static int fimc_is_3aa_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *ischain;
return ret;
}
-static int fimc_is_3aa_stop_streaming(struct vb2_queue *vbq)
+static void fimc_is_3aa_stop_streaming(struct vb2_queue *vbq)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vbq->drv_priv;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
- return ret;
}
static void fimc_is_3aa_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_3aa_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_3aa_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
u32 index = vb->v4l2_buf.index;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *device = vctx->device;
queue = vctx->q_dst;
fimc_is_subdev_buffer_finish(subdev, index);
}
-
- return ret;
}
const struct vb2_ops fimc_is_3aa_qops = {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_3a0c;
if (!core->pdev) {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_3a1c;
if (!core->pdev) {
}
static int fimc_is_3aac_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
dbg("%s\n", __func__);
return 0;
return ret;
}
-static int fimc_is_3aac_stop_streaming(struct vb2_queue *vbq)
+static void fimc_is_3aac_stop_streaming(struct vb2_queue *vbq)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vbq->drv_priv;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
- return ret;
}
static void fimc_is_3aac_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_3aac_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_3aac_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *ischain = vctx->device;
struct fimc_is_subdev *subdev = &ischain->taac;
mdbgv_3aac("%s(%d)\n", vctx, __func__, vb->v4l2_buf.index);
#endif
- ret = fimc_is_subdev_buffer_finish(subdev, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_subdev_buffer_finish(subdev, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_3aac_qops = {
BUG_ON(!data);
- device = (struct fimc_is_device_companion *)data;
+ device = data;
video = &device->video;
snprintf(name, sizeof(name), "%s%d", FIMC_IS_VIDEO_SENSOR_NAME, 9);
number = FIMC_IS_VIDEO_SS0_NUM + 9;
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_isp;
if (!core->pdev) {
}
static int fimc_is_isp_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *ischain;
fimc_is_logsync(device->interface, ctrl->value, IS_MSG_TEST_SYNC_LOG);
break;
case V4L2_CID_IS_G_CAPABILITY:
- ret = fimc_is_ischain_g_capability(device, ctrl->value);
+ BUG();
+ ret = fimc_is_ischain_g_capability(device, NULL);
+// ret = fimc_is_ischain_g_capability(device, ctrl->value);
dbg_isp("V4L2_CID_IS_G_CAPABILITY : %X\n", ctrl->value);
break;
case V4L2_CID_IS_FORCE_DONE:
return ret;
}
-static int fimc_is_isp_stop_streaming(struct vb2_queue *q)
+static void fimc_is_isp_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
device = vctx->device;
if (!device) {
err("device is NULL");
- ret = -EINVAL;
- goto p_err;
+ return;
}
leader = &device->group_isp.leader;
ret = fimc_is_queue_stop_streaming(queue, device, leader, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
-p_err:
- return ret;
}
static void fimc_is_isp_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_isp_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_isp_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *device = vctx->device;
mdbgv_isp("%s(%d)\n", vctx, __func__, vb->v4l2_buf.index);
#endif
- ret = fimc_is_ischain_isp_buffer_finish(device, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_ischain_isp_buffer_finish(device, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_isp_qops = {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_scc;
if (!core->pdev) {
}
static int fimc_is_scc_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
dbg("%s\n", __func__);
return 0;
return ret;
}
-static int fimc_is_scc_stop_streaming(struct vb2_queue *q)
+static void fimc_is_scc_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
device = vctx->device;
if (!device) {
err("device is NULL");
- ret = -EINVAL;
- goto p_err;
+ return;
}
subdev = &device->scc;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
-p_err:
- return ret;
}
static void fimc_is_scc_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_scc_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_scc_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
device = vctx->device;
subdev = &device->scc;
- ret = fimc_is_subdev_buffer_finish(subdev, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_subdev_buffer_finish(subdev, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_scc_qops = {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_scp;
if (!core->pdev) {
}
static int fimc_is_scp_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
return ret;
}
-static int fimc_is_scp_stop_streaming(struct vb2_queue *q)
+static void fimc_is_scp_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
device = vctx->device;
if (!device) {
err("device is NULL");
- ret = -EINVAL;
- goto p_err;
+ return;
}
subdev = &device->scp;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
-p_err:
- return ret;
}
static void fimc_is_scp_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_scp_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_scp_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *ischain = vctx->device;
struct fimc_is_subdev *scp = &ischain->scp;
dbg_scp("%s(%d)\n", __func__, vb->v4l2_buf.index);
#endif
- ret = fimc_is_subdev_buffer_finish(scp, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_subdev_buffer_finish(scp, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_scp_qops = {
BUG_ON(!data);
- device = (struct fimc_is_device_sensor *)data;
+ device = data;
video = &device->video;
snprintf(name, sizeof(name), "%s%d", FIMC_IS_VIDEO_SENSOR_NAME, device->instance);
number = FIMC_IS_VIDEO_SS0_NUM + device->instance;
}
static int fimc_is_sen_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_sensor *sensor;
return 0;
}
-static int fimc_is_sen_stop_streaming(struct vb2_queue *q)
+static void fimc_is_sen_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
ret = fimc_is_sensor_back_stop(device);
} else {
err("already stream off");
- ret = -EINVAL;
}
-
- return ret;
}
static void fimc_is_sen_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_sen_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_sen_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
+ int ret;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_sensor *device;
ret = fimc_is_sensor_buffer_finish(
device,
vb->v4l2_buf.index);
- if (ret) {
+ if (ret)
merr("fimc_is_sensor_buffer_finish is fail(%d)", device, ret);
- goto p_err;
- }
-
-p_err:
- return ret;
}
const struct vb2_ops fimc_is_sen_qops = {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_vdc;
if (!core->pdev) {
}
static int fimc_is_vdc_video_set_crop(struct file *file, void *fh,
- struct v4l2_crop *crop)
+ const struct v4l2_crop *crop)
{
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *ischain;
return ret;
}
-static int fimc_is_vdc_stop_streaming(struct vb2_queue *q)
+static void fimc_is_vdc_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
device = vctx->device;
if (!device) {
err("device is NULL");
- ret = -EINVAL;
- goto p_err;
+ return;
}
subdev = &device->dis;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
-p_err:
- return ret;
}
static void fimc_is_vdc_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_vdc_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_vdc_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *ischain = vctx->device;
struct fimc_is_subdev *dis = &ischain->dis;
dbg_vdisc("%s(%d)\n", __func__, vb->v4l2_buf.index);
#endif
- ret = fimc_is_subdev_buffer_finish(dis, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_subdev_buffer_finish(dis, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_vdc_qops = {
BUG_ON(!data);
- core = (struct fimc_is_core *)data;
+ core = data;
video = &core->video_vdo;
if (!core->pdev) {
return ret;
}
-static int fimc_is_vdo_stop_streaming(struct vb2_queue *q)
+static void fimc_is_vdo_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
device = vctx->device;
if (!device) {
err("device is NULL");
- ret = -EINVAL;
- goto p_err;
+ return;
}
leader = &device->group_dis.leader;
ret = fimc_is_queue_stop_streaming(queue, device, leader, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
-
-p_err:
- return ret;
}
static void fimc_is_vdo_buffer_queue(struct vb2_buffer *vb)
}
}
-static int fimc_is_vdo_buffer_finish(struct vb2_buffer *vb)
+static void fimc_is_vdo_buffer_finish(struct vb2_buffer *vb)
{
- int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *device = vctx->device;
mdbgv_vdo("%s(%d)\n", vctx, __func__, vb->v4l2_buf.index);
#endif
- ret = fimc_is_ischain_vdo_buffer_finish(device, vb->v4l2_buf.index);
-
- return ret;
+ fimc_is_ischain_vdo_buffer_finish(device, vb->v4l2_buf.index);
}
const struct vb2_ops fimc_is_vdo_qops = {
BUG_ON(!sizes);
BUG_ON(!allocators);
- *num_planes = (unsigned int)(queue->framecfg.format.num_planes);
+ *num_planes = (queue->framecfg.format.num_planes);
fimc_is_set_plane_size(&queue->framecfg, sizes);
for (plane = 0; plane < *num_planes; plane++) {
/* plane address check */
for (i = 0; i < frame->planes; i++) {
if (frame->dvaddr_buffer[i] != queue->buf_dva[index][i]) {
- err("buffer %d plane %d is changed(%08X != %08X)",
+ err("buffer %d plane %d is changed(%pad != %pad)",
index, i,
- frame->dvaddr_buffer[i],
- queue->buf_dva[index][i]);
+ &frame->dvaddr_buffer[i],
+ &queue->buf_dva[index][i]);
ret = -EINVAL;
goto exit;
}
frame->dvaddr_shot = queue->buf_dva[index][spare] + ext_size;
frame->kvaddr_shot = queue->buf_kva[index][spare] + ext_size;
- frame->cookie_shot = (u32)vb2_plane_cookie(vb, spare);
- frame->shot = (struct camera2_shot *)frame->kvaddr_shot;
- frame->shot_ext = (struct camera2_shot_ext *)queue->buf_kva[index][spare];
+ frame->cookie_shot = vb2_plane_cookie(vb, spare);
+ frame->shot = frame->kvaddr_shot;
+ frame->shot_ext = queue->buf_kva[index][spare];
frame->shot_size = queue->framecfg.size[spare] - ext_size;
#ifdef MEASURE_TIME
+# warning POSSIBLE WARNING
frame->tzone = (struct timeval *)frame->shot_ext->timeZone;
#endif
} else {
goto exit;
}
- frame->stream = (struct camera2_stream *)queue->buf_kva[index][spare];
+ frame->stream = queue->buf_kva[index][spare];
frame->stream->address = queue->buf_kva[index][spare];
frame->stream_size = queue->framecfg.size[spare];
}
u32 buf_maxcount;
u32 buf_rdycount;
u32 buf_refcount;
- u32 buf_dva[FIMC_IS_MAX_BUFS][FIMC_IS_MAX_PLANES];
- u32 buf_kva[FIMC_IS_MAX_BUFS][FIMC_IS_MAX_PLANES];
+ dma_addr_t buf_dva[FIMC_IS_MAX_BUFS][FIMC_IS_MAX_PLANES];
+ void * buf_kva[FIMC_IS_MAX_BUFS][FIMC_IS_MAX_PLANES];
u32 id;
unsigned long state;
.unregistered = sensor_6d1_unregistered,
};
-static int sensor_6d1_init(struct v4l2_subdev *subdev, u32 val)
+static int sensor_6d1_init(struct v4l2_subdev *subdev, void *val)
{
int i, ret = 0;
struct fimc_is_module_enum *module;
BUG_ON(!subdev);
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ module = v4l2_get_subdevdata(subdev);
module_6d1 = module->private_data;
client = module->client;
(u8)setfile_vision_6d1[i][1]);
}
- pr_info("[MOD:D:%d] %s(%d)\n", module->id, __func__, val);
+ pr_info("[MOD:D:%d] %s(%ld)\n", module->id, __func__, (long)val);
return ret;
}
pr_info("%s\n", __func__);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (!sensor) {
err("sensor is NULL");
ret = -EINVAL;
duration = (u64)(tpf->numerator * 1000 * 1000 * 1000) /
(u64)(tpf->denominator);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (!sensor) {
err("sensor is NULL");
ret = -EINVAL;
BUG_ON(!subdev);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (unlikely(!sensor)) {
err("sensor is NULL");
ret = -EINVAL;
BUG_ON(!subdev);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (unlikely(!sensor)) {
err("sensor is NULL");
ret = -EINVAL;
pr_info("%s\n", __func__);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (unlikely(!sensor)) {
err("sensor is NULL");
ret = -EINVAL;
BUG_ON(!subdev);
- pr_info("%s(%d)\n", __func__, (u32)exposure);
+ pr_info("%s(%lld)\n", __func__, exposure);
- sensor = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ sensor = v4l2_get_subdevdata(subdev);
if (unlikely(!sensor)) {
err("sensor is NULL");
ret = -EINVAL;
if (!fimc_is_dev)
goto probe_defer;
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
//FIMC_IS_SENSOR_CFG(824, 496, 300, 13, 8),
};
-static int sensor_imx240_init(struct v4l2_subdev *subdev, u32 val)
+static int sensor_imx240_init(struct v4l2_subdev *subdev, void *val)
{
int ret = 0;
struct fimc_is_module_enum *module;
BUG_ON(!subdev);
- module = (struct fimc_is_module_enum *)v4l2_get_subdevdata(subdev);
+ module = v4l2_get_subdevdata(subdev);
- pr_info("[MOD:D:%d] %s(%d)\n", module->id, __func__, val);
+ pr_info("[MOD:D:%d] %s(%ld)\n", module->id, __func__, (long)val);
return ret;
}
BUG_ON(!fimc_is_dev);
- core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
+ core = dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
ext->companion_con.product_name = COMPANION_NAME_73C1;
ext->companion_con.peri_info0.valid = true;
ext->companion_con.peri_info0.peri_type = SE_SPI;
- ext->companion_con.peri_info0.peri_setting.spi.channel = (int) core->companion_spi_channel;
+ ext->companion_con.peri_info0.peri_setting.spi.channel = core->companion_spi_channel;
ext->companion_con.peri_info1.valid = true;
ext->companion_con.peri_info1.peri_type = SE_I2C;
ext->companion_con.peri_info1.peri_setting.i2c.channel = 0;
#ifndef __ASSEMBLY__
extern int exynos_smc(unsigned long cmd, unsigned long arg1, unsigned long arg2,
unsigned long arg3);
-extern int exynos_smc_readsfr(unsigned long addr, unsigned long* val);
+extern int exynos_smc_readsfr(unsigned long addr, u32 * val);
#endif
#endif
projects / platform / kernel / linux-exynos.git / commitdiff