/**
* ispresizer_config_size - Configures input and output image size.
* @pipe: Resizer data path parameters.
*
* Configures the appropriate values stored in the isp_res structure in the
* resizer registers.
*
* Returns 0 if successful, or -EINVAL if passed values haven't been verified
* with ispresizer_try_size() previously.
**/
int ispresizer_s_pipeline(struct isp_res_device *isp_res,
struct isp_node *pipe)
{
struct device *dev = to_device(isp_res);
int bpp = ISP_BYTES_PER_PIXEL;
ispresizer_set_source(isp_res, pipe->in.path);
ispresizer_set_intype(isp_res, pipe->in.path);
ispresizer_set_start_phase(dev, NULL);
ispresizer_set_luma_enhance(dev, NULL);
if (pipe->in.image.pixelformat == V4L2_PIX_FMT_YUYV)
ispresizer_config_ycpos(isp_res, 1);
else
ispresizer_config_ycpos(isp_res, 0);
ispresizer_try_pipeline(isp_res, pipe);
ispresizer_set_ratio(dev, isp_res->h_resz, isp_res->v_resz);
ispresizer_set_coeffs(dev, NULL, isp_res->h_resz, isp_res->v_resz);
/* Switch filter, releated to up/down scale */
if (ispresizer_is_upscale(pipe))
ispresizer_enable_cbilin(isp_res, 1);
else
ispresizer_enable_cbilin(isp_res, 0);
/* Set input and output size */
ispresizer_set_input_size(dev, isp_res->phy_rect.width,
isp_res->phy_rect.height);
ispresizer_set_output_size(dev, pipe->out.image.width,
pipe->out.image.height);
/* Set input address and line offset address */
if (pipe->in.path != RSZ_OTFLY_YUV) {
/* Set the input address, plus calculated crop offset */
ispresizer_set_inaddr(isp_res, isp_res->in_buff_addr, pipe);
/* Set the input line offset/length */
ispresizer_set_in_offset(isp_res, pipe->in.image.bytesperline);
} else {
/* Set the input address.*/
ispresizer_set_inaddr(isp_res, 0, NULL);
/* Set the starting pixel offset */
ispresizer_set_start(dev, isp_res->phy_rect.left * bpp,
isp_res->phy_rect.top);
ispresizer_set_in_offset(isp_res, 0);
}
/* Set output line offset */
ispresizer_set_out_offset(isp_res, pipe->out.image.bytesperline);
return 0;
}
/**
* ispresizer_config_datapath - Specifies which input to use in resizer module
* @input: Indicates the module that gives the image to resizer.
*
* Sets up the default resizer configuration according to the arguments.
*
* Returns 0 if successful, or -1 if an unsupported input was requested.
**/
int ispresizer_config_datapath(enum ispresizer_input input)
{
u32 cnt = 0;
DPRINTK_ISPRESZ("ispresizer_config_datapath()+\n");
ispres_obj.resinput = input;
switch (input) {
case RSZ_OTFLY_YUV:
cnt &= ~ISPRSZ_CNT_INPTYP;
cnt &= ~ISPRSZ_CNT_INPSRC;
ispresizer_set_inaddr(0);
ispresizer_config_inlineoffset(0);
break;
case RSZ_MEM_YUV:
cnt |= ISPRSZ_CNT_INPSRC;
cnt &= ~ISPRSZ_CNT_INPTYP;
break;
case RSZ_MEM_COL8:
cnt |= ISPRSZ_CNT_INPSRC;
cnt |= ISPRSZ_CNT_INPTYP;
break;
default:
DPRINTK_ISPRESZ( "ISP_ERR : Wrong Input\n");
return -1;
}
isp_reg_or(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, cnt);
//ispresizer_config_ycpos(0);
ispresizer_config_ycpos(1);
ispresizer_config_filter_coef(&ispreszdefcoef);
ispresizer_enable_cbilin(0);
ispresizer_config_luma_enhance(&ispreszdefaultyenh);
DPRINTK_ISPRESZ("ispresizer_config_datapath()-\n");
return 0;
}
/**
* ispresizer_applycrop - Apply crop to input image.
**/
void ispresizer_applycrop(struct isp_res_device *isp_res)
{
struct isp_device *isp = to_isp_device(isp_res);
struct isp_node *pipe = &isp->pipeline.rsz;
int bpp = ISP_BYTES_PER_PIXEL;
if (!isp_res->applycrop)
return;
ispresizer_set_ratio(isp->dev, isp_res->h_resz, isp_res->v_resz);
ispresizer_set_coeffs(isp->dev, NULL, isp_res->h_resz, isp_res->v_resz);
/* Switch filter, releated to up/down scale */
if (ispresizer_is_upscale(pipe))
ispresizer_enable_cbilin(isp_res, 1);
else
ispresizer_enable_cbilin(isp_res, 0);
/* Set input and output size */
ispresizer_set_input_size(isp->dev, isp_res->phy_rect.width,
isp_res->phy_rect.height);
ispresizer_set_output_size(isp->dev, pipe->out.image.width,
pipe->out.image.height);
/* Set input address and line offset address */
if (pipe->in.path != RSZ_OTFLY_YUV) {
/* Set the input address, plus calculated crop offset */
ispresizer_set_inaddr(isp_res, isp_res->in_buff_addr, pipe);
/* Set the input line offset/length */
ispresizer_set_in_offset(isp_res, pipe->in.image.bytesperline);
} else {
/* Set the input address.*/
ispresizer_set_inaddr(isp_res, 0, NULL);
/* Set the starting pixel offset */
ispresizer_set_start(isp->dev, isp_res->phy_rect.left * bpp,
isp_res->phy_rect.top);
ispresizer_set_in_offset(isp_res, 0);
}
/* Set output line offset */
ispresizer_set_out_offset(isp_res, pipe->out.image.bytesperline);
isp_res->applycrop = 0;
}
/**
* ispresizer_config_datapath - Specifies which input to use in resizer module
* @input: Indicates the module that gives the image to resizer.
*
* Sets up the default resizer configuration according to the arguments.
*
* Returns 0 if successful, or -EINVAL if an unsupported input was requested.
**/
int ispresizer_config_datapath(enum ispresizer_input input)
{
u32 cnt = 0;
DPRINTK_ISPRESZ("ispresizer_config_datapath()+\n");
ispres_obj.resinput = input;
switch (input) {
case RSZ_OTFLY_YUV:
cnt &= ~ISPRSZ_CNT_INPTYP;
cnt &= ~ISPRSZ_CNT_INPSRC;
ispresizer_set_inaddr(0);
ispresizer_config_inlineoffset(0);
break;
case RSZ_MEM_YUV:
cnt |= ISPRSZ_CNT_INPSRC;
cnt &= ~ISPRSZ_CNT_INPTYP;
break;
case RSZ_MEM_COL8:
cnt |= ISPRSZ_CNT_INPSRC;
cnt |= ISPRSZ_CNT_INPTYP;
break;
default:
printk(KERN_ERR "ISP_ERR : Wrong Input\n");
return -EINVAL;
}
isp_reg_or(OMAP3_ISP_IOMEM_RESZ, ISPRSZ_CNT, cnt);
/* Use bilinear interpolation for upsampling per TRM */
if (ispres_obj.outputwidth > ispres_obj.inputwidth)
ispresizer_enable_cbilin(1);
else
ispresizer_enable_cbilin(0);
ispresizer_config_ycpos(0);
ispresizer_config_filter_coef(&ispreszdefcoef);
ispresizer_config_luma_enhance(&ispreszdefaultyenh);
DPRINTK_ISPRESZ("ispresizer_config_datapath()-\n");
return 0;
}
/** ispdss_begin - Function to be called by DSS when resizing of the input
* image buffer is needed
* @slot: buffer index where the input image is stored
* @output_buffer_index: output buffer index where output of resizer will
* be stored
* @out_off: The line size in bytes for output buffer. as most probably
* this will be VRFB with YUV422 data, it should come 0x2000 as input
* @out_phy_add: physical address of the start of output memory area for this
* @in_phy_add: physical address of the start of input memory area for this
* @in_off:: The line size in bytes for output buffer.
* ispdss_begin() takes the input buffer index and output buffer index
* to start the process of resizing. after resizing is complete,
* the callback function will be called with the argument.
* Indexes of the input and output buffers are used so that it is faster
* and easier to configure the input and output address for the ISP resizer.
* As per the current implementation, DSS uses six VRFB contexts for rotation.
* for both input and output buffers index and physical address has been taken
* as argument. if this buffer is not already mapped to ISP address space we
* use physical address to map it, otherwise only the index is used.
**/
int ispdss_begin(struct isp_node *pipe, u32 input_buffer_index,
int output_buffer_index, u32 out_off, u32 out_phy_add,
u32 in_phy_add, u32 in_off)
{
unsigned int output_size;
struct isp_device *isp = dev_get_drvdata(dev_ctx.isp);
struct isp_res_device *isp_res = &isp->isp_res;
//LGE_CHANGE_S [[email protected]] 2011_04_22, for improve ISP to get 30fps (OMAPS00236923)
u32 speed_val = 0;
//LGE_CHANGE_E [[email protected]] 2011_04_22, for improve ISP to get 30fps (OMAPS00236923)
//LGE_CHANGE_S [[email protected]] 2011_07_19 Froyo_to_GB
struct device *dev = to_device(isp_res);
//LGE_CHANGE_E [[email protected]] 2011_07_19 Froyo_to_GB
if (output_buffer_index >= dev_ctx.num_video_buffers) {
dev_err(dev_ctx.isp,
"ouput buffer index is out of range %d", output_buffer_index);
return -EINVAL;
}
if (dev_ctx.config_state != STATE_CONFIGURED) {
dev_err(dev_ctx.isp, "State not configured \n");
return -EINVAL;
}
dev_ctx.tmp_buf_size = PAGE_ALIGN(pipe->out.image.bytesperline *
pipe->out.image.height);
ispdss_tmp_buf_alloc(dev_ctx.tmp_buf_size);
pipe->in.path = RSZ_MEM_YUV;
if (ispresizer_s_pipeline(isp_res, pipe) != 0)
return -EINVAL;
/* If this output buffer has not been mapped till now then map it */
if (!dev_ctx.out_buf_virt_addr[output_buffer_index]) {
output_size = pipe->out.image.height * out_off;
dev_ctx.out_buf_virt_addr[output_buffer_index] =
iommu_kmap(isp->iommu, 0, out_phy_add, output_size,
IOMMU_FLAG);
if (IS_ERR_VALUE(
dev_ctx.out_buf_virt_addr[output_buffer_index])) {
dev_err(dev_ctx.isp, "Mapping of output buffer failed"
"for index \n");
return -ENOMEM;
}
}
if (!dev_ctx.in_buf_virt_addr[input_buffer_index]) {
dev_ctx.in_buf_virt_addr[input_buffer_index] =
iommu_kmap(isp->iommu, 0, in_phy_add, in_off,
IOMMU_FLAG);
if (IS_ERR_VALUE(
dev_ctx.in_buf_virt_addr[input_buffer_index])) {
dev_err(dev_ctx.isp, "Mapping of input buffer failed"
"for index \n");
return -ENOMEM;
}
}
if (ispresizer_set_inaddr(isp_res,
dev_ctx.in_buf_virt_addr[input_buffer_index],
pipe) != 0)
return -EINVAL;
if (ispresizer_set_out_offset(isp_res, out_off) != 0)
return -EINVAL;
if (ispresizer_set_outaddr(isp_res,
(u32)dev_ctx.out_buf_virt_addr[output_buffer_index]) != 0)
return -EINVAL;
/* Set ISP callback for the resizing complete even */
if (isp_set_callback(dev_ctx.isp, CBK_RESZ_DONE, ispdss_isr,
(void *) NULL, (void *)NULL)) {
dev_err(dev_ctx.isp, "No callback for RSZR\n");
return -1;
}
/* All settings are done.Enable the resizer */
init_completion(&dev_ctx.compl_isr);
//LGE_CHANGE_S [[email protected]] 2011_04_22, for improve ISP to get 30fps (OMAPS00236923)
// isp_start(dev_ctx.isp);
/* Only for 720p case*/
if (use_isp_resizer_decoder){
/*decoder */
speed_val = 0;
}else{
/* encoder */
speed_val = 8;
}
//LGE_CHANGE_S [[email protected]] 2011_07_19 Froyo_to_GB
isp_reg_and_or(dev, OMAP3_ISP_IOMEM_SBL, ISPSBL_SDR_REQ_EXP,
~ISPSBL_SDR_REQ_RSZ_EXP_MASK,
speed_val << ISPSBL_SDR_REQ_RSZ_EXP_SHIFT);
isp_start(dev_ctx.isp);
//LGE_CHANGE_E [[email protected]] 2011_07_19 Froyo_to_GB
ispresizer_enable(isp_res, 1);
/* Wait for resizing complete event */
if (wait_for_completion_interruptible_timeout(
&dev_ctx.compl_isr, msecs_to_jiffies(500)) == 0)
dev_crit(dev_ctx.isp, "\nTimeout exit from "
"wait_for_completion\n");
/* Unset the ISP callback function */
isp_unset_callback(dev_ctx.isp, CBK_RESZ_DONE);
return 0;
}
int isp_resize_mem_data(struct isp_mem_resize_data *data)
{
int i;
int ret = -1;
struct isp_mem_resize_data *presizer_user = \
(struct isp_mem_resize_data *)data;
u32 input_buffer_size, output_buffer_size;
u32 input_nr_pages, output_nr_pages;
struct page **input_pages = NULL;
struct page **output_pages = NULL;
unsigned long isp_addr_in = 0;
unsigned long isp_addr_out = 0;
struct isp_mem_resize_data resizer_param;
unsigned long timeout;
if (presizer_user == NULL) {
printk(KERN_ERR "ISP_RESZ_ERR : Invalid user data\n");
return -EINVAL;
}
memcpy(&resizer_param, presizer_user, \
sizeof(struct isp_mem_resize_data));
DPRINTK_ISPPROC("\nRSZ input(%d-%d) - output(%d-%d)\n",
resizer_param.input_width,
resizer_param.input_height,
resizer_param.output_width,
resizer_param.output_height);
DPRINTK_ISPPROC("RSZ start(%d-%d) - end(%d-%d)\n",
resizer_param.left,
resizer_param.top,
resizer_param.crop_width,
resizer_param.crop_height);
if (presizer_user->datain == 0 || presizer_user->dataout == 0)
return -EINVAL;
ispresizer_enable(0);
timeout = jiffies + msecs_to_jiffies(200);
while (ispresizer_busy()) {
if (time_after(jiffies, timeout))
return -EINVAL;
msleep(1);
}
ispresizer_save_context();
ispresizer_free();
ispresizer_request();
/* set data path before configuring modules. */
ispresizer_config_datapath(RSZ_MEM_YUV, 0);
input_buffer_size = ALIGN_TO(presizer_user->input_width* \
presizer_user->input_height*2 , 0x100);
input_pages = map_user_memory_to_kernel(presizer_user->datain,
input_buffer_size, &input_nr_pages);
if (input_pages == NULL) {
ret = -EINVAL;
printk(KERN_ERR "ISP_RESZ_ERR: memory allocation failed\n");
goto exit_cleanup;
}
output_buffer_size = ALIGN_TO(presizer_user->output_width* \
presizer_user->output_height*2, 0x1000);
output_pages = map_user_memory_to_kernel(presizer_user->dataout,
output_buffer_size, &output_nr_pages);
if (output_pages == NULL) {
ret = -EINVAL;
printk(KERN_ERR "ISP_RESZ_ERR: memory allocation failed\n");
goto exit_cleanup;
}
for (i = 0; i < output_nr_pages; ++i)
flush_dcache_page(output_pages[i]);
isp_addr_in = ispmmu_vmap_pages(input_pages, input_nr_pages);
if (IS_ERR((void *)isp_addr_in)) {
isp_addr_in = 0;
ret = -EINVAL;
printk(KERN_ERR "ISP_RESZ_ERR: isp mmu map failed\n");
goto exit_cleanup;
}
isp_addr_out = ispmmu_vmap_pages(output_pages, output_nr_pages);
if (IS_ERR((void *)isp_addr_out)) {
isp_addr_out = 0;
ret = -EINVAL;
printk(KERN_ERR "ISP_RESZ_ERR: isp mmu map failed\n");
goto exit_cleanup;
}
if ((resizer_param.left == 0) && (resizer_param.top == 0)) {
ret = ispresizer_try_size(&resizer_param.input_width,
&resizer_param.input_height,
&resizer_param.output_width,
&resizer_param.output_height);
ret = ispresizer_config_size(resizer_param.input_width,
resizer_param.input_height,
resizer_param.output_width,
resizer_param.output_height);
ispresizer_set_inaddr(isp_addr_in);
} else {
ispresizer_trycrop(resizer_param.left,
resizer_param.top,
resizer_param.crop_width,
resizer_param.crop_height,
resizer_param.output_width,
resizer_param.output_height);
ispresizer_applycrop();
/*pixel alignment in 32bit space, vertical must be 0 per TRM */
isp_reg_writel(((resizer_param.left%16) <<
ISPRSZ_IN_START_HORZ_ST_SHIFT) |
(0 <<
ISPRSZ_IN_START_VERT_ST_SHIFT),
OMAP3_ISP_IOMEM_RESZ,
ISPRSZ_IN_START);
/* Align input address for cropping, per TRM */
ispresizer_set_inaddr(isp_addr_in +
(resizer_param.top*resizer_param.input_width*2)
+ ((resizer_param.left/16)*32));
}
ispresizer_set_inaddr(isp_addr_in);
ispresizer_set_outaddr(isp_addr_out);
ispresizer_config_ycpos(0);
ispresizer_config_inlineoffset(
ALIGN_TO(presizer_user->input_width*2, 32));
isp_set_callback(CBK_RESZ_DONE, rsz_isr, (void *) NULL, (void *)NULL);
isp_reg_writel(0xFFFFFFFF, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
isp_wfc.done = 0;
/* start resizer engine. */
ispresizer_enable(1);
ret = wait_for_completion_timeout(&isp_wfc, msecs_to_jiffies(1000));
if (!ret)
ispresizer_enable(0);
timeout = jiffies + msecs_to_jiffies(50);
while (ispresizer_busy()) {
msleep(5);
if (time_after(jiffies, timeout)) {
printk(KERN_ERR "ISP_RESZ_ERR: Resizer still busy");
break;
}
}
isp_reg_writel(0xFFFFFFFF, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
isp_unset_callback(CBK_RESZ_DONE);
ret = 0;
exit_cleanup:
ispresizer_restore_context();
if (isp_addr_in != 0)
ispmmu_vunmap(isp_addr_in);
if (isp_addr_out != 0)
ispmmu_vunmap(isp_addr_out);
if (input_pages != NULL) {
unmap_user_memory_from_kernel(input_pages, input_nr_pages);
kfree(input_pages);
}
if (output_pages != NULL) {
unmap_user_memory_from_kernel(output_pages, output_nr_pages);
kfree(output_pages);
}
DPRINTK_ISPPROC("resizer exit.\n");
return ret;
}
int isp_process_mem_data(struct isp_mem_data *data)
{
int i;
int ret = -1;
struct isp_mem_data *ppreview_user = \
(struct isp_mem_data *)data;
struct isp_mem_data preview_param;
u32 input_buffer_size, output_buffer_size;
u32 input_nr_pages, output_nr_pages;
struct page **input_pages = NULL;
struct page **output_pages = NULL;
unsigned long isp_addr_in = 0;
unsigned long isp_addr_out = 0;
unsigned long isp_addr_tmp = 0;
unsigned long timeout;
struct isp_mem_resize_data resizer_param;
u16 cropadjust = 0;
if (ppreview_user == NULL) {
printk(KERN_ERR "ISP_PROC_ERR: Invalid user data!\n");
return -EINVAL;
}
memcpy(&preview_param, ppreview_user, \
sizeof(struct isp_mem_data));
DPRINTK_ISPPROC("input(%d-%d) - output(%d-%d)\n",
preview_param.input_width,
preview_param.input_height,
preview_param.output_width,
preview_param.output_height);
DPRINTK_ISPPROC("start(%d-%d) - end(%d-%d)\n",
preview_param.left,
preview_param.top,
preview_param.crop_width,
preview_param.crop_height);
if (ppreview_user->datain == 0 || ppreview_user->dataout == 0)
return -EINVAL;
isppreview_enable(0);
ispresizer_enable(0);
timeout = jiffies + msecs_to_jiffies(200);
while (isppreview_busy() ||
ispresizer_busy()) {
if (time_after(jiffies, timeout))
return -EINVAL;
msleep(1);
}
isppreview_save_context();
ispresizer_save_context();
isppreview_free();
ispresizer_free();
isppreview_request();
ispresizer_request();
/* set data path before configuring modules. */
isppreview_update_datapath(PRV_RAW_MEM, PREVIEW_MEM);
ispresizer_config_datapath(RSZ_MEM_YUV, 0);
ret = isppreview_try_size(preview_param.input_width,
preview_param.input_height,
&preview_param.output_width,
&preview_param.output_height);
if (ret < 0)
goto exit_cleanup;
ret = isppreview_config_size(preview_param.input_width,
preview_param.input_height,
preview_param.output_width,
preview_param.output_height);
if (ret < 0)
goto exit_cleanup;
input_buffer_size = ALIGN_TO(ppreview_user->input_width* \
ppreview_user->input_height*2 , 0x100);
input_pages = map_user_memory_to_kernel(preview_param.datain,
input_buffer_size, &input_nr_pages);
if (input_pages == NULL) {
ret = -EINVAL;
printk(KERN_ERR "ISP_PROC_ERR: memory allocation failed\n");
goto exit_cleanup;
}
output_buffer_size = ALIGN_TO(ppreview_user->output_width* \
ppreview_user->output_height*2, 0x1000);
output_pages = map_user_memory_to_kernel(preview_param.dataout,
output_buffer_size, &output_nr_pages);
if (output_pages == NULL) {
ret = -EINVAL;
printk(KERN_ERR "ISP_PROC_ERR: memory allocation failed\n");
goto exit_cleanup;
}
for (i = 0; i < output_nr_pages; ++i)
flush_dcache_page(output_pages[i]);
isp_addr_in = ispmmu_vmap_pages(input_pages, input_nr_pages);
if (IS_ERR((void *)isp_addr_in)) {
isp_addr_in = 0;
ret = -EINVAL;
printk(KERN_ERR "ISP_PROC_ERR: isp mmu map failed\n");
goto exit_cleanup;
}
isp_addr_out = ispmmu_vmap_pages(output_pages, output_nr_pages);
if (IS_ERR((void *)isp_addr_out)) {
isp_addr_out = 0;
ret = -EINVAL;
printk(KERN_ERR "ISP_PROC_ERR: isp mmu map failed\n");
goto exit_cleanup;
}
/* This buffer must be allocated and mapped to
the ISP MMU previously. */
isp_addr_tmp = isp_tmp_buf_addr();
if (isp_addr_tmp == 0) {
printk(KERN_ERR "ISP_PROC_ERR: Invalid isp tmp buffer address!\n");
goto exit_cleanup;
}
isppreview_config_inlineoffset(ppreview_user->input_width * 2);
isppreview_set_inaddr(isp_addr_in);
isppreview_set_outaddr(isp_addr_tmp);
resizer_param.input_width = preview_param.output_width;
resizer_param.input_height = preview_param.output_height;
resizer_param.output_width = ppreview_user->output_width;
resizer_param.output_height = ppreview_user->output_height;
if ((preview_param.left == 0) && (preview_param.top == 0)) {
ret = ispresizer_try_size(&resizer_param.input_width,
&resizer_param.input_height,
&resizer_param.output_width,
&resizer_param.output_height);
if (ret < 0)
goto exit_cleanup;
ret = ispresizer_config_size(resizer_param.input_width,
resizer_param.input_height,
resizer_param.output_width,
resizer_param.output_height);
if (ret < 0)
goto exit_cleanup;
ispresizer_set_inaddr(isp_addr_tmp);
} else {
ispresizer_trycrop(preview_param.left,
preview_param.top,
preview_param.crop_width,
preview_param.crop_height,
resizer_param.output_width,
resizer_param.output_height);
ispresizer_applycrop();
/* account for pixel loss when using crop*/
if ((preview_param.input_height > preview_param.output_height)
&& (preview_param.top > 16))
cropadjust = 8;
else
cropadjust = 0;
/* pixel alignment in 32bit space, vertical must be 0 per TRM */
isp_reg_writel(((preview_param.left%16) <<
ISPRSZ_IN_START_HORZ_ST_SHIFT) |
(0 <<
ISPRSZ_IN_START_VERT_ST_SHIFT),
OMAP3_ISP_IOMEM_RESZ,
ISPRSZ_IN_START);
/* Align input address for cropping, per TRM */
ispresizer_set_inaddr(isp_addr_tmp -
(resizer_param.input_width*2*cropadjust) +
(preview_param.top*resizer_param.input_width*2)
+ ((preview_param.left/16)*32));
}
ispresizer_set_outaddr(isp_addr_out);
ispresizer_config_inlineoffset(
ALIGN_TO(resizer_param.input_width*2, 32));
if (isp_set_callback(CBK_PREV_DONE, prv_isr,
(void *) NULL, (void *)NULL) != 0) {
printk(KERN_ERR "ISP_PROC_ERR: Error setting PRV callback.\n");
goto exit_cleanup;
}
if (isp_set_callback(CBK_RESZ_DONE, rsz_isr,
(void *) NULL, (void *)NULL) != 0) {
printk(KERN_ERR "ISP_PROC_ERR: Error setting RSZ callback.\n");
goto exit_cleanup;
}
isp_reg_writel(0xFFFFFFFF, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
isp_wfc.done = 0;
/* start preview engine. */
isppreview_enable(1);
ret = wait_for_completion_timeout(&isp_wfc, msecs_to_jiffies(1000));
if (!ret) {
isppreview_enable(0);
ispresizer_enable(0);
}
timeout = jiffies + msecs_to_jiffies(50);
while (ispresizer_busy()) {
msleep(5);
if (time_after(jiffies, timeout)) {
printk(KERN_ERR "ISP_RESZ_ERR: Resizer still busy");
break;
}
}
isp_reg_writel(0xFFFFFFFF, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
isp_unset_callback(CBK_PREV_DONE);
isp_unset_callback(CBK_RESZ_DONE);
exit_cleanup:
isppreview_restore_context();
ispresizer_restore_context();
if (isp_addr_in != 0)
ispmmu_vunmap(isp_addr_in);
if (isp_addr_out != 0)
ispmmu_vunmap(isp_addr_out);
if (input_pages != NULL) {
unmap_user_memory_from_kernel(input_pages, input_nr_pages);
kfree(input_pages);
}
if (output_pages != NULL) {
unmap_user_memory_from_kernel(output_pages, output_nr_pages);
kfree(output_pages);
}
DPRINTK_ISPPROC("exit.\n");
return ret;
}
