1. deinterlace_3_field函数
static bool deinterlace_3_field(struct ipu_task_entry *t)
{
return ((t->set.mode & VDI_MODE) &&
(t->input.deinterlace.motion != HIGH_MOTION));
} 2. tiled_filed_size函数
u32 field_size;
static u32 tiled_filed_size(struct ipu_task_entry *t)
{
/* note: page_align is required by VPU hw ouput buffer */
field_size = TILED_NV12_FRAME_SIZE(t->input.width, t->input.height/2);
return field_size;
}3. MODE模式
关于这个VDOA模式，在下面这个task_set结构体里面的注释有说明：VDOA_MODE意味着这个task任务使用vdoa,并且VDOA有两种模式：BANDMODE和non-bandMODE模式。non-bandMODE模式将要转化数据到内存中。而BANDMODE模式需要IPU硬件的同步信号，这种模式是连上VDIC的默认模式。
先来看这个task_set结构体：
struct task_set {
#define <span style="color:#FF0000;">NULL_MODE</span> 0x0
#define <span style="color:#FF0000;">IC_MODE</span> 0x1
#define <span style="color:#FF0000;">ROT_MODE</span> 0x2
#define <span style="color:#FF0000;">VDI_MODE</span> 0x4
#define <span style="color:#FF0000;">IPU_PREPROCESS_MODE_MASK</span> (IC_MODE | ROT_MODE | VDI_MODE)
/* VDOA_MODE means this task use vdoa, and VDOA has two modes:
* BAND MODE and non-BAND MODE. Non-band mode will do transfer data
* to memory. BAND mode needs hareware sync with IPU, it is used default
* if connected to VDIC.
*/
#define <span style="color:#FF0000;">VDOA_MODE</span> 0x8
#define <span style="color:#FF0000;">VDOA_BAND_MODE</span> 0x10
u8 mode;
。。。。。。。。。
struct stripe_setting sp_setting;
};上面红色字体是有关MODE模式的变量，可以看到IC_MODE,ROT_MODE,VDA_MODE分别占用u8的一位：
下面就来看下面三个函数：
3.1 only_ic函数
static bool only_ic(u8 mode)
{
mode = mode & IPU_PREPROCESS_MODE_MASK;
return ((mode == IC_MODE) || (mode == VDI_MODE));
} 可以看出来，如果mode占用的如下红色字体所示的任意一位的话，都可以认为是only_ic模式。
3.2 only_rot函数
static bool only_rot(u8 mode)
{
mode = mode & IPU_PREPROCESS_MODE_MASK;
return (mode == ROT_MODE);
} 这个only_rot模式，则只有mode占用ROT位的话，才能够认为是only_rot。
3.3ic_and_rot函数
static bool ic_and_rot(u8 mode)
{
mode = mode & IPU_PREPROCESS_MODE_MASK;
return ((mode == (IC_MODE | ROT_MODE)) ||
(mode == (VDI_MODE | ROT_MODE)));
}这种模式如下所示：
4.need_split函数
static bool need_split(struct ipu_task_entry *t)
{
return ((t->set.split_mode != NO_SPLIT) || (t->task_no & SPLIT_MASK));
}
struct task_set {
。。。。。。。。。。
#define NO_SPLIT 0x0
#define RL_SPLIT 0x1
#define UD_SPLIT 0x2
#define LEFT_STRIPE 0x1
#define RIGHT_STRIPE 0x2
#define UP_STRIPE 0x4
#define DOWN_STRIPE 0x8
#define SPLIT_MASK 0xF
u8 split_mode;
。。。。。。。。。
struct stripe_setting sp_setting;
};这个函数判断的同样是ipu_task_entry结构体中的task_set里面的split_mode，如果这一位不等于0的话，就返回true。这个函数的意思应该是判断一个结构体是否需要拆分，do_task，get_res_do_task，ipu_task_thread，ipu_queue_task函数中都调用了这个函数。
5.fmt_to_bpp函数
unsigned int fmt_to_bpp(unsigned int pixelformat)
{
u32 bpp;
switch (pixelformat) {
case IPU_PIX_FMT_RGB565:
/*interleaved 422*/
case IPU_PIX_FMT_YUYV:
case IPU_PIX_FMT_UYVY:
/*non-interleaved 422*/
case IPU_PIX_FMT_YUV422P:
case IPU_PIX_FMT_YVU422P:
bpp = 16;
break;
case IPU_PIX_FMT_BGR24:
case IPU_PIX_FMT_RGB24:
case IPU_PIX_FMT_YUV444:
case IPU_PIX_FMT_YUV444P:
bpp = 24;
break;
case IPU_PIX_FMT_BGR32:
case IPU_PIX_FMT_BGRA32:
case IPU_PIX_FMT_RGB32:
case IPU_PIX_FMT_RGBA32:
case IPU_PIX_FMT_ABGR32:
bpp = 32;
break;
/*non-interleaved 420*/
case IPU_PIX_FMT_YUV420P:
case IPU_PIX_FMT_YVU420P:
case IPU_PIX_FMT_YUV420P2:
case IPU_PIX_FMT_NV12:
bpp = 12;
break;
default:
bpp = 8;
break;
}
return bpp;
}
EXPORT_SYMBOL_GPL(fmt_to_bpp);这个函数就很简单了，它根据pixelformat格式返回它所占用的bit数，bitsper pixel。
6.colorspaceofpixel函数
cs_t colorspaceofpixel(int fmt)
{
switch (fmt) {
case IPU_PIX_FMT_RGB565:
case IPU_PIX_FMT_RGB666:
case IPU_PIX_FMT_BGR24:
case IPU_PIX_FMT_RGB24:
case IPU_PIX_FMT_BGRA32:
case IPU_PIX_FMT_BGR32:
case IPU_PIX_FMT_RGBA32:
case IPU_PIX_FMT_RGB32:
case IPU_PIX_FMT_ABGR32:
return RGB_CS;
break;
case IPU_PIX_FMT_UYVY:
case IPU_PIX_FMT_YUYV:
case IPU_PIX_FMT_YUV420P2:
case IPU_PIX_FMT_YUV420P:
case IPU_PIX_FMT_YVU420P:
case IPU_PIX_FMT_YVU422P:
case IPU_PIX_FMT_YUV422P:
case IPU_PIX_FMT_YUV444:
case IPU_PIX_FMT_YUV444P:
case IPU_PIX_FMT_NV12:
case IPU_PIX_FMT_TILED_NV12:
case IPU_PIX_FMT_TILED_NV12F:
return YUV_CS;
break;
default:
return NULL_CS;
}
}
EXPORT_SYMBOL_GPL(colorspaceofpixel);这个函数根据format的值返回这个format的颜色空间colorspace。颜色空间在ipu.h中定义：
typedef enum {
RGB_CS,
YUV_CS,
NULL_CS
} cs_t;这个函数主要用在下面要介绍的need_csc函数。
7.need_csc函数
int need_csc(int ifmt, int ofmt)
{
cs_t ics, ocs;
ics = colorspaceofpixel(ifmt);
ocs = colorspaceofpixel(ofmt);
if ((ics == NULL_CS) || (ocs == NULL_CS))
return -1;
else if (ics != ocs)
return 1;
return 0;
}
EXPORT_SYMBOL_GPL(need_csc);这个函数通过colorspaceofpixel函数分别获取输入format和输出format的颜色空间，如果两者相同的话，就不需要csc转化了，如果不同的话就需要csc转化。这个函数在check_task中调用。
8.soc_max_in_width函数
static int soc_max_in_width(u32 is_vdoa)
{
return is_vdoa ? 8192 : 4096;
}这个函数返回soc最大的宽度，如果传入的参数为1的话，就返回8192，否则返回4096。这个函数在check_task函数中就是直接这样用的。参数为1的话代表是vdoa。
9.soc_max_vdi_in_width函数
static int soc_max_vdi_in_width(struct ipu_soc *ipu)
{
int i;
if (!ipu) {
for (i = 0; i < max_ipu_no; i++) {
ipu = ipu_get_soc(i);
if (!IS_ERR_OR_NULL(ipu))
break;
}
if (i == max_ipu_no)
return 720;
}
return IPU_MAX_VDI_IN_WIDTH(ipu->devtype);
}
#define IPU_MAX_VDI_IN_WIDTH(type) ({ (type) >= IPUv3M ? 968 : 720; })这个函数根据传入的ipu_soc结构体里面的devtype来返回vdi的最大宽度。
在ipu_common.c中的ipu_probe函数里面，以下代码是摘取出来的：（在ipu_common.c中详细分析）
const struct of_device_id *of_id =
of_match_device(imx_ipuv3_dt_ids, &pdev->dev);
const struct ipu_platform_type *iputype = of_id->data;
const struct ipu_devtype *devtype = &iputype->devtype;
ipu = &ipu_array[id];
ipu->devtype = devtype->type;最终ipu->devtype就调用到imx_ipuv3_dt_ids[x]里面的data数据段：
static const struct of_device_id imx_ipuv3_dt_ids[] = {
{ .compatible = "fsl,imx51-ipu", .data = &ipu_type_imx51, },
{ .compatible = "fsl,imx53-ipu", .data = &ipu_type_imx53, },
{ .compatible = "fsl,imx6q-ipu", .data = &ipu_type_imx6q, },
{ .compatible = "fsl,imx6qp-ipu", .data = &ipu_type_imx6qp, },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, imx_ipuv3_dt_ids);以ipu_type_imx6qp为例，如下所示：
static struct ipu_platform_type ipu_type_imx6qp = {
<span style="color:#FF0000;">.devtype = {
.name = "IPUv3H",
.cm_ofs = 0x00200000,
.idmac_ofs = 0x00208000,
.ic_ofs = 0x00220000,
.csi0_ofs = 0x00230000,
.csi1_ofs = 0x00238000,
.di0_ofs = 0x00240000,
.di1_ofs = 0x00248000,
.smfc_ofs = 0x00250000,
.dc_ofs = 0x00258000,
.dmfc_ofs = 0x00260000,
.vdi_ofs = 0x00268000,
.cpmem_ofs = 0x00300000,
.srm_ofs = 0x00340000,
.tpm_ofs = 0x00360000,
.dc_tmpl_ofs = 0x00380000,
.type = IPUv3H,
.idmac_used_bufs_present = true,
},</span>
.ch0123_axi = 0,
.ch23_axi = 0,
.ch27_axi = 2,
.ch28_axi = 3,
.normal_axi = 1,
.idmac_used_bufs_en_r = true,
.idmac_used_bufs_en_w = true,
.idmac_used_bufs_max_r = 0x3,
.idmac_used_bufs_max_w = 0x3,
.smfc_idmac_12bit_3planar_bs_fixup = true,
};这个soc_max_vdi_in_width函数就会比对ipu->devtype即上面标红的部分，将它于IPUv3M比较，大于就返回968，否则返回720。可以查看ipu_common.c中可以看出来ipu_type_imx51为"IPUv3EX"，ipu_type_imx53为"IPUv3M"，ipu_type_imx6q为"IPUv3H"，ipu_type_imx6qp为"IPUv3H"，所以对于imx51和imx53返回720，imx6q和imx6qp返回968。
这个函数在本文件中的update_split_setting，check_task，get_res_do_task函数中调用。
10.soc_max_in_height函数
static int soc_max_in_height(void)
{
return 4096;
}11.soc_max_out_width函数
static int soc_max_out_width(void)
{
/* mx51/mx53/mx6q is 1024*/
return 1024;
}12.soc_max_out_height函数
static int soc_max_out_height(void)
{
/* mx51/mx53/mx6q is 1024*/
return 1024;
}13.dump_task_info函数
static void dump_task_info(struct ipu_task_entry *t)
{
if (!debug)
return;
dev_dbg(t->dev, "[0x%p]input:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tformat = 0x%x\n", (void *)t, t->input.format);
dev_dbg(t->dev, "[0x%p]\twidth = %d\n", (void *)t, t->input.width);
dev_dbg(t->dev, "[0x%p]\theight = %d\n", (void *)t, t->input.height);
dev_dbg(t->dev, "[0x%p]\tcrop.w = %d\n", (void *)t, t->input.crop.w);
dev_dbg(t->dev, "[0x%p]\tcrop.h = %d\n", (void *)t, t->input.crop.h);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.x = %d\n",
(void *)t, t->input.crop.pos.x);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.y = %d\n",
(void *)t, t->input.crop.pos.y); /*打印ipu_task_entry->input的信息。*/
dev_dbg(t->dev, "[0x%p]input buffer:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tpaddr = 0x%x\n", (void *)t, t->input.paddr);
dev_dbg(t->dev, "[0x%p]\ti_off = 0x%x\n", (void *)t, t->set.i_off);
dev_dbg(t->dev, "[0x%p]\ti_uoff = 0x%x\n", (void *)t, t->set.i_uoff);
dev_dbg(t->dev, "[0x%p]\ti_voff = 0x%x\n", (void *)t, t->set.i_voff);
dev_dbg(t->dev, "[0x%p]\tistride = %d\n", (void *)t, t->set.istride);
if (t->input.deinterlace.enable) {
dev_dbg(t->dev, "[0x%p]deinterlace enabled with:\n", (void *)t);
if (t->input.deinterlace.motion != HIGH_MOTION) {
dev_dbg(t->dev, "[0x%p]\tlow/medium motion\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tpaddr_n = 0x%x\n",
(void *)t, t->input.paddr_n);
} else
dev_dbg(t->dev, "[0x%p]\thigh motion\n", (void *)t);
} /*打印ipu_task_entry->inputbuffer的一些信息。*/
dev_dbg(t->dev, "[0x%p]output:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tformat = 0x%x\n", (void *)t, t->output.format);
dev_dbg(t->dev, "[0x%p]\twidth = %d\n", (void *)t, t->output.width);
dev_dbg(t->dev, "[0x%p]\theight = %d\n", (void *)t, t->output.height);
dev_dbg(t->dev, "[0x%p]\tcrop.w = %d\n", (void *)t, t->output.crop.w);
dev_dbg(t->dev, "[0x%p]\tcrop.h = %d\n", (void *)t, t->output.crop.h);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.x = %d\n",
(void *)t, t->output.crop.pos.x);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.y = %d\n",
(void *)t, t->output.crop.pos.y);
dev_dbg(t->dev, "[0x%p]\trotate = %d\n", (void *)t, t->output.rotate); /*打印ipu_task_entry->output的信息。*/
dev_dbg(t->dev, "[0x%p]output buffer:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tpaddr = 0x%x\n", (void *)t, t->output.paddr);
dev_dbg(t->dev, "[0x%p]\to_off = 0x%x\n", (void *)t, t->set.o_off);
dev_dbg(t->dev, "[0x%p]\to_uoff = 0x%x\n", (void *)t, t->set.o_uoff);
dev_dbg(t->dev, "[0x%p]\to_voff = 0x%x\n", (void *)t, t->set.o_voff);
dev_dbg(t->dev, "[0x%p]\tostride = %d\n", (void *)t, t->set.ostride); /*打印ipu_task_entry->outputbuffer的一些信息。*/
if (t->overlay_en) {
dev_dbg(t->dev, "[0x%p]overlay:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tformat = 0x%x\n",
(void *)t, t->overlay.format);
dev_dbg(t->dev, "[0x%p]\twidth = %d\n",
(void *)t, t->overlay.width);
dev_dbg(t->dev, "[0x%p]\theight = %d\n",
(void *)t, t->overlay.height);
dev_dbg(t->dev, "[0x%p]\tcrop.w = %d\n",
(void *)t, t->overlay.crop.w);
dev_dbg(t->dev, "[0x%p]\tcrop.h = %d\n",
(void *)t, t->overlay.crop.h);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.x = %d\n",
(void *)t, t->overlay.crop.pos.x);
dev_dbg(t->dev, "[0x%p]\tcrop.pos.y = %d\n",
(void *)t, t->overlay.crop.pos.y); /*如果使能了overlay_en的话，打印overlay的一些信息。*/
dev_dbg(t->dev, "[0x%p]overlay buffer:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tpaddr = 0x%x\n",
(void *)t, t->overlay.paddr);
dev_dbg(t->dev, "[0x%p]\tov_off = 0x%x\n",
(void *)t, t->set.ov_off);
dev_dbg(t->dev, "[0x%p]\tov_uoff = 0x%x\n",
(void *)t, t->set.ov_uoff);
dev_dbg(t->dev, "[0x%p]\tov_voff = 0x%x\n",
(void *)t, t->set.ov_voff);
dev_dbg(t->dev, "[0x%p]\tovstride = %d\n",
(void *)t, t->set.ovstride); /*打印overlaybuffer的一些信息。*/
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL) {
dev_dbg(t->dev, "[0x%p]local alpha enabled with:\n",
(void *)t);
dev_dbg(t->dev, "[0x%p]\tpaddr = 0x%x\n",
(void *)t, t->overlay.alpha.loc_alp_paddr);
dev_dbg(t->dev, "[0x%p]\tov_alpha_off = 0x%x\n",
(void *)t, t->set.ov_alpha_off);
dev_dbg(t->dev, "[0x%p]\tov_alpha_stride = %d\n",
(void *)t, t->set.ov_alpha_stride);
} else
dev_dbg(t->dev, "[0x%p]globle alpha enabled with value 0x%x\n",
(void *)t, t->overlay.alpha.gvalue);
if (t->overlay.colorkey.enable)
dev_dbg(t->dev, "[0x%p]colorkey enabled with value 0x%x\n",
(void *)t, t->overlay.colorkey.value);
} /*打印alpha通道的一些信息。*/
dev_dbg(t->dev, "[0x%p]want task_id = %d\n", (void *)t, t->task_id);
dev_dbg(t->dev, "[0x%p]want task mode is 0x%x\n",
(void *)t, t->set.mode);
dev_dbg(t->dev, "[0x%p]\tIC_MODE = 0x%x\n", (void *)t, IC_MODE);
dev_dbg(t->dev, "[0x%p]\tROT_MODE = 0x%x\n", (void *)t, ROT_MODE);
dev_dbg(t->dev, "[0x%p]\tVDI_MODE = 0x%x\n", (void *)t, VDI_MODE);
dev_dbg(t->dev, "[0x%p]\tTask_no = 0x%x\n\n\n", (void *)t, t->task_no);
}/*打印这个task的一些信息。*/
这个函数里面就是一些打印信息，可以在合适的地方添加这些打印信息来辅助调试。
14.dump_check_err函数
static void dump_check_err(struct device *dev, int err)
{
switch (err) {
case IPU_CHECK_ERR_INPUT_CROP:
dev_err(dev, "input crop setting error\n");
break;
case IPU_CHECK_ERR_OUTPUT_CROP:
dev_err(dev, "output crop setting error\n");
break;
case IPU_CHECK_ERR_OVERLAY_CROP:
dev_err(dev, "overlay crop setting error\n");
break;
case IPU_CHECK_ERR_INPUT_OVER_LIMIT:
dev_err(dev, "input over limitation\n");
break;
case IPU_CHECK_ERR_OVERLAY_WITH_VDI:
dev_err(dev, "do not support overlay with deinterlace\n");
break;
case IPU_CHECK_ERR_OV_OUT_NO_FIT:
dev_err(dev,
"width/height of overlay and ic output should be same\n");
break;
case IPU_CHECK_ERR_PROC_NO_NEED:
dev_err(dev, "no ipu processing need\n");
break;
case IPU_CHECK_ERR_SPLIT_INPUTW_OVER:
dev_err(dev, "split mode input width overflow\n");
break;
case IPU_CHECK_ERR_SPLIT_INPUTH_OVER:
dev_err(dev, "split mode input height overflow\n");
break;
case IPU_CHECK_ERR_SPLIT_OUTPUTW_OVER:
dev_err(dev, "split mode output width overflow\n");
break;
case IPU_CHECK_ERR_SPLIT_OUTPUTH_OVER:
dev_err(dev, "split mode output height overflow\n");
break;
case IPU_CHECK_ERR_SPLIT_WITH_ROT:
dev_err(dev, "not support split mode with rotation\n");
break;
case IPU_CHECK_ERR_W_DOWNSIZE_OVER:
dev_err(dev, "horizontal downsizing ratio overflow\n");
break;
case IPU_CHECK_ERR_H_DOWNSIZE_OVER:
dev_err(dev, "vertical downsizing ratio overflow\n");
break;
default:
break;
}
}这个函数在check_task里面调用。在上一个ipu_device.c分析（一）中分析的框架中，
staticstruct file_operations mxc_ipu_fops = { 。。。
.unlocked_ioctl= mxc_ipu_ioctl,
};
在这个mxc_ipu_ioctl函数中，它为应用程序提供了这个IPU_CHECK_TASKioctl宏，这个宏的核心是ipu_check_task函数，在这个ipu_check_task函数中调用了check_task函数来检查task是否出错，这个函数会生成各个错误信息，然后就会调用这个dump_check_err函数将错误信息打印出来。同时也会调用dump_check_warn函数来打印警告信息，这个dump_check_warn函数在下面贴出来。
15.dump_check_warn函数
static void dump_check_warn(struct device *dev, int warn)
{
if (warn & IPU_CHECK_WARN_INPUT_OFFS_NOT8ALIGN)
dev_warn(dev, "input u/v offset not 8 align\n");
if (warn & IPU_CHECK_WARN_OUTPUT_OFFS_NOT8ALIGN)
dev_warn(dev, "output u/v offset not 8 align\n");
if (warn & IPU_CHECK_WARN_OVERLAY_OFFS_NOT8ALIGN)
dev_warn(dev, "overlay u/v offset not 8 align\n");
}16.set_crop函数
static int set_crop(struct ipu_crop *crop, int width, int height, int fmt)
{
if ((width == 0) || (height == 0)) {
pr_err("Invalid param: width=%d, height=%d\n", width, height);
return -EINVAL;
}
if ((IPU_PIX_FMT_TILED_NV12 == fmt) ||
(IPU_PIX_FMT_TILED_NV12F == fmt)) {
if (crop->w || crop->h) {
if (((crop->w + crop->pos.x) > width)
|| ((crop->h + crop->pos.y) > height)
|| (0 != (crop->w % IPU_PIX_FMT_TILED_NV12_MBALIGN))
|| (0 != (crop->h % IPU_PIX_FMT_TILED_NV12_MBALIGN))
|| (0 != (crop->pos.x % IPU_PIX_FMT_TILED_NV12_MBALIGN))
|| (0 != (crop->pos.y % IPU_PIX_FMT_TILED_NV12_MBALIGN))
) {
pr_err("set_crop error MB align.\n");
return -EINVAL;
}
} else {
crop->pos.x = 0;
crop->pos.y = 0;
crop->w = width;
crop->h = height;
if ((0 != (crop->w % IPU_PIX_FMT_TILED_NV12_MBALIGN))
|| (0 != (crop->h % IPU_PIX_FMT_TILED_NV12_MBALIGN))) {
pr_err("set_crop error w/h MB align.\n");
return -EINVAL;
}
}
} else {
if (crop->w || crop->h) {
if (((crop->w + crop->pos.x) > (width + 16))
|| ((crop->h + crop->pos.y) > height + 16)) {
pr_err("set_crop error exceeds width/height.\n");
return -EINVAL;
}
} else {
crop->pos.x = 0;
crop->pos.y = 0;
crop->w = width;
crop->h = height;
}
crop->w -= crop->w%8;
crop->h -= crop->h%8;
}
if ((crop->w == 0) || (crop->h == 0)) {
pr_err("Invalid crop param: crop.w=%d, crop.h=%d\n",
crop->w, crop->h);
return -EINVAL;
}
return 0;
}这个函数根据传入的width，height和fmt参数设置传入的structipu_crop*crop参数。它在文件中主要是用来设置ipu_task_entry结构体中的ipu_output结构体里面的structipu_crop crop。它在check_task，do_task_vdoa_vdi函数中都有调用。
17.update_offset函数
static void update_offset(unsigned int fmt,
unsigned int width, unsigned int height,
unsigned int pos_x, unsigned int pos_y,
int *off, int *uoff, int *voff, int *stride)
{
/* NOTE: u v offset should based on start point of off*/
switch (fmt) {
case IPU_PIX_FMT_YUV420P2:
case IPU_PIX_FMT_YUV420P:
*off = pos_y * width + pos_x;
*uoff = (width * (height - pos_y) - pos_x)
+ (width/2) * (pos_y/2) + pos_x/2;
/* In case height is odd, round up to even */
*voff = *uoff + (width/2) * ((height+1)/2);
break;
case IPU_PIX_FMT_YVU420P:
*off = pos_y * width + pos_x;
*voff = (width * (height - pos_y) - pos_x)
+ (width/2) * (pos_y/2) + pos_x/2;
/* In case height is odd, round up to even */
*uoff = *voff + (width/2) * ((height+1)/2);
break;
case IPU_PIX_FMT_YVU422P:
*off = pos_y * width + pos_x;
*voff = (width * (height - pos_y) - pos_x)
+ (width/2) * pos_y + pos_x/2;
*uoff = *voff + (width/2) * height;
break;
case IPU_PIX_FMT_YUV422P:
*off = pos_y * width + pos_x;
*uoff = (width * (height - pos_y) - pos_x)
+ (width/2) * pos_y + pos_x/2;
*voff = *uoff + (width/2) * height;
break;
case IPU_PIX_FMT_YUV444P:
*off = pos_y * width + pos_x;
*uoff = width * height;
*voff = width * height * 2;
break;
case IPU_PIX_FMT_NV12:
*off = pos_y * width + pos_x;
*uoff = (width * (height - pos_y) - pos_x)
+ width * (pos_y/2) + pos_x;
break;
case IPU_PIX_FMT_TILED_NV12:
/*
* tiled format, progressive:
* assuming that line is aligned with MB height (aligned to 16)
* offset = line * stride + (pixel / MB_width) * pixels_in_MB
* = line * stride + (pixel / 16) * 256
* = line * stride + pixel * 16
*/
*off = pos_y * width + (pos_x << 4);
*uoff = ALIGN(width * height, SZ_4K) + (*off >> 1) - *off;
break;
case IPU_PIX_FMT_TILED_NV12F:
/*
* tiled format, interlaced:
* same as above, only number of pixels in MB is 128,
* instead of 256
*/
*off = (pos_y >> 1) * width + (pos_x << 3);
*uoff = ALIGN(width * height/2, SZ_4K) + (*off >> 1) - *off;
break;
default:
*off = (pos_y * width + pos_x) * fmt_to_bpp(fmt)/8;
break;
}
*stride = width * bytes_per_pixel(fmt);
}这个函数根据传入的fmt，width和height参数，计算出来off，uoff，voff和stride参数，直接在这些变量的地址里面进行修改传回去。这个函数主要设置的是ipu_task_entry结构体里面的structtask_set set结构体里面的这些变量：
u32 i_off;
u32 i_uoff;
u32 i_voff;
u32 istride;
u32 ov_off;
u32 ov_uoff;
u32 ov_voff;
u32 ovstride;
u32 ov_alpha_off;
u32 ov_alpha_stride;
u32 o_off;
u32 o_uoff;
u32 o_voff;
u32 ostride;但是这里面的算法并不清楚（只知道off的算法），以及这个uoff和voff分别代表什么意思？这个函数都是和上一个set_crop函数绑定使用的，首先调用set_crop函数设置输入，输出或overlay里面的crop，然后调用这个update_offset函数更新偏移量。
18.update_split_setting 函数
static int update_split_setting(struct ipu_task_entry *t, bool vdi_split)
{
struct stripe_param left_stripe;
struct stripe_param right_stripe;
struct stripe_param up_stripe;
struct stripe_param down_stripe;
u32 iw, ih, ow, oh;
u32 max_width;
int ret;
if (t->output.rotate >= IPU_ROTATE_90_RIGHT)
return IPU_CHECK_ERR_SPLIT_WITH_ROT;
iw = t->input.crop.w;
ih = t->input.crop.h;
ow = t->output.crop.w;
oh = t->output.crop.h;
memset(&left_stripe, 0, sizeof(left_stripe));
memset(&right_stripe, 0, sizeof(right_stripe));
memset(&up_stripe, 0, sizeof(up_stripe));
memset(&down_stripe, 0, sizeof(down_stripe));
if (t->set.split_mode & RL_SPLIT) {
/*
* We do want equal strips: initialize stripes in case
* calc_stripes returns before actually doing the calculation
*/
left_stripe.input_width = iw / 2;
left_stripe.output_width = ow / 2;
right_stripe.input_column = iw / 2;
right_stripe.output_column = ow / 2;
if (vdi_split)
max_width = soc_max_vdi_in_width(t->ipu);
else
max_width = soc_max_out_width();
ret = ipu_calc_stripes_sizes(iw,
ow,
max_width,
(((unsigned long long)1) << 32), /* 32bit for fractional*/
1, /* equal stripes */
t->input.format,
t->output.format,
&left_stripe,
&right_stripe);
if (ret < 0)
return IPU_CHECK_ERR_W_DOWNSIZE_OVER;
else if (ret)
dev_dbg(t->dev, "Warn: no:0x%x,calc_stripes ret:%d\n",
t->task_no, ret);
t->set.sp_setting.iw = left_stripe.input_width;
t->set.sp_setting.ow = left_stripe.output_width;
t->set.sp_setting.outh_resize_ratio = left_stripe.irr;
t->set.sp_setting.i_left_pos = left_stripe.input_column;
t->set.sp_setting.o_left_pos = left_stripe.output_column;
t->set.sp_setting.i_right_pos = right_stripe.input_column;
t->set.sp_setting.o_right_pos = right_stripe.output_column;
} else {
t->set.sp_setting.iw = iw;
t->set.sp_setting.ow = ow;
t->set.sp_setting.outh_resize_ratio = 0;
t->set.sp_setting.i_left_pos = 0;
t->set.sp_setting.o_left_pos = 0;
t->set.sp_setting.i_right_pos = 0;
t->set.sp_setting.o_right_pos = 0;
}
if ((t->set.sp_setting.iw + t->set.sp_setting.i_right_pos) > (iw+16))
return IPU_CHECK_ERR_SPLIT_INPUTW_OVER;
if (((t->set.sp_setting.ow + t->set.sp_setting.o_right_pos) > ow)
|| (t->set.sp_setting.ow > soc_max_out_width()))
return IPU_CHECK_ERR_SPLIT_OUTPUTW_OVER;
if (rounddown(t->set.sp_setting.ow, 8) * 8 <=
rounddown(t->set.sp_setting.iw, 8))
return IPU_CHECK_ERR_W_DOWNSIZE_OVER;
if (t->set.split_mode & UD_SPLIT) {
/*
* We do want equal strips: initialize stripes in case
* calc_stripes returns before actually doing the calculation
*/
up_stripe.input_width = ih / 2;
up_stripe.output_width = oh / 2;
down_stripe.input_column = ih / 2;
down_stripe.output_column = oh / 2;
ret = ipu_calc_stripes_sizes(ih,
oh,
soc_max_out_height(),
(((unsigned long long)1) << 32), /* 32bit for fractional*/
0x1 | 0x2, /* equal stripes and vertical */
t->input.format,
t->output.format,
&up_stripe,
&down_stripe);
if (ret < 0)
return IPU_CHECK_ERR_H_DOWNSIZE_OVER;
else if (ret)
dev_err(t->dev, "Warn: no:0x%x,calc_stripes ret:%d\n",
t->task_no, ret);
t->set.sp_setting.ih = up_stripe.input_width;
t->set.sp_setting.oh = up_stripe.output_width;
t->set.sp_setting.outv_resize_ratio = up_stripe.irr;
t->set.sp_setting.i_top_pos = up_stripe.input_column;
t->set.sp_setting.o_top_pos = up_stripe.output_column;
t->set.sp_setting.i_bottom_pos = down_stripe.input_column;
t->set.sp_setting.o_bottom_pos = down_stripe.output_column;
} else {
t->set.sp_setting.ih = ih;
t->set.sp_setting.oh = oh;
t->set.sp_setting.outv_resize_ratio = 0;
t->set.sp_setting.i_top_pos = 0;
t->set.sp_setting.o_top_pos = 0;
t->set.sp_setting.i_bottom_pos = 0;
t->set.sp_setting.o_bottom_pos = 0;
}
/* downscale case: enforce limits */
if (((t->set.sp_setting.ih + t->set.sp_setting.i_bottom_pos) > (ih))
&& (t->set.sp_setting.ih >= t->set.sp_setting.oh))
return IPU_CHECK_ERR_SPLIT_INPUTH_OVER;
/* upscale case: relax limits because ipu_calc_stripes_sizes() may
create input stripe that falls just outside of the input window */
else if ((t->set.sp_setting.ih + t->set.sp_setting.i_bottom_pos)
> (ih+16))
return IPU_CHECK_ERR_SPLIT_INPUTH_OVER;
if (((t->set.sp_setting.oh + t->set.sp_setting.o_bottom_pos) > oh)
|| (t->set.sp_setting.oh > soc_max_out_height()))
return IPU_CHECK_ERR_SPLIT_OUTPUTH_OVER;
if (rounddown(t->set.sp_setting.oh, 8) * 8 <=
rounddown(t->set.sp_setting.ih, 8))
return IPU_CHECK_ERR_H_DOWNSIZE_OVER;
return IPU_CHECK_OK;
}这个函数里面调用了ipu_calc_stripes_sizes函数，这个函数在ipu_calc_stripes_sizes.c中定义，但是看不懂这几个函数，ipu_calc_stripes_sizes.c与ipu_ic.c都是有关ic的操作函数。先在这作标记，往下分析。
19.check_task函数
static int check_task(struct ipu_task_entry *t)
{
int tmp;
int ret = IPU_CHECK_OK;
int timeout;
bool vdi_split = false;
int ocw, och;
if ((IPU_PIX_FMT_TILED_NV12 == t->overlay.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->overlay.format) ||
(IPU_PIX_FMT_TILED_NV12 == t->output.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->output.format) ||
((IPU_PIX_FMT_TILED_NV12F == t->input.format) &&
!t->input.deinterlace.enable)) {
ret = IPU_CHECK_ERR_NOT_SUPPORT;
goto done;
} /*如果发生上述的情况，就说明发生了不支持的task，返回的错误信息是IPU_CHECK_ERR_NOT_SUPPORT，上述的IPU_PIX_FMT_TILED_NV12和IPU_PIX_FMT_TILED_NV12F是像素格式，它们在ipu.h中定义，同样是fourcc码：
/*two planes -- 12 tiled Y/CbCr 4:2:0 */
#defineIPU_PIX_FMT_TILED_NV12 fourcc('T', 'N', 'V', 'P')
#defineIPU_PIX_FMT_TILED_NV12F fourcc('T', 'N', 'V', 'F')
*/
/* check input */
ret = set_crop(&t->input.crop, t->input.width, t->input.height,
t->input.format);
if (ret < 0) {
ret = IPU_CHECK_ERR_INPUT_CROP;
goto done;
} else
update_offset(t->input.format, t->input.width, t->input.height,
t->input.crop.pos.x, t->input.crop.pos.y,
&t->set.i_off, &t->set.i_uoff,
&t->set.i_voff, &t->set.istride); /*检查输入参数，这两个函数在上面分析了，首先调用set_crop函数根据t->input.width，t->input.height，t->input.format来填充&t->input.crop，然后通过update_offset函数来更新&t->set.i_off，&t->set.i_uoff，&t->set.i_voff和&t->set.istride这些偏移值。*/
/* check output */
ret = set_crop(&t->output.crop, t->output.width, t->output.height,
t->output.format);
if (ret < 0) {
ret = IPU_CHECK_ERR_OUTPUT_CROP;
goto done;
} else
update_offset(t->output.format,
t->output.width, t->output.height,
t->output.crop.pos.x, t->output.crop.pos.y,
&t->set.o_off, &t->set.o_uoff,
&t->set.o_voff, &t->set.ostride); /*检查输出参数，首先调用set_crop函数根据t->output.width，t->output.height，t->output.format来填充&t->output.crop，然后通过update_offset函数来更新&t->set.o_off,&t->set.o_uoff, &t->set.o_voff和&t->set.ostride这些偏移值。*/
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
/*
* Cache output width and height and
* swap them so that we may check
* downsize overflow correctly.
*/
ocw = t->output.crop.h;
och = t->output.crop.w;
} else {
ocw = t->output.crop.w;
och = t->output.crop.h;
} /*ipu_task_entry结构体里面的structipu_output有一个rotate参数，它记录了输出的图像是否发生旋转，如果旋转的角度大于90度的话，就调换width和height。这里面的ocw应该是outputcache width，och应该是outputcache height的意思。*/
if (ocw * 8 <= t->input.crop.w) {
ret = IPU_CHECK_ERR_W_DOWNSIZE_OVER;
goto done;
}
if (och * 8 <= t->input.crop.h) {
ret = IPU_CHECK_ERR_H_DOWNSIZE_OVER;
goto done;
} /*因为这里面设置的是crop的值，所以它是一个缩放值。从这里可以看出来，它最多能够缩放成原来的1/8，如果比这个比例还小的话，就会报错。*/
if ((IPU_PIX_FMT_TILED_NV12 == t->input.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->input.format)) {
if ((t->input.crop.w > soc_max_in_width(1)) ||
(t->input.crop.h > soc_max_in_height())) {
ret = IPU_CHECK_ERR_INPUT_OVER_LIMIT;
goto done;
}
/* output fmt: NV12 and YUYV, now don't support resize */
if (((IPU_PIX_FMT_NV12 != t->output.format) &&
(IPU_PIX_FMT_YUYV != t->output.format)) ||
(t->input.crop.w != t->output.crop.w) ||
(t->input.crop.h != t->output.crop.h)) {
ret = IPU_CHECK_ERR_NOT_SUPPORT;
goto done;
}
} /*再次判断输入输出的参数以及t->input.crop.w和t->input.crop.h等参数。*/
/* check overlay if there is */
if (t->overlay_en) {
if (t->input.deinterlace.enable) {
ret = IPU_CHECK_ERR_OVERLAY_WITH_VDI;
goto done;
} /*如果使能了input中的deinterlace的话，再启用overlay就会报错：IPU_CHECK_ERR_OVERLAY_WITH_VDI，从这可以看出来overlay不能和VDI共存。*/
ret = set_crop(&t->overlay.crop, t->overlay.width,
t->overlay.height, t->overlay.format);
if (ret < 0) {
ret = IPU_CHECK_ERR_OVERLAY_CROP;
goto done;
} else {
ocw = t->output.crop.w;
och = t->output.crop.h;
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
ocw = t->output.crop.h;
och = t->output.crop.w;
}
if ((t->overlay.crop.w != ocw) ||
(t->overlay.crop.h != och)) {
ret = IPU_CHECK_ERR_OV_OUT_NO_FIT;
goto done;
}
update_offset(t->overlay.format,
t->overlay.width, t->overlay.height,
t->overlay.crop.pos.x, t->overlay.crop.pos.y,
&t->set.ov_off, &t->set.ov_uoff,
&t->set.ov_voff, &t->set.ovstride);
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL) {
t->set.ov_alpha_stride = t->overlay.width;
t->set.ov_alpha_off = t->overlay.crop.pos.y *
t->overlay.width + t->overlay.crop.pos.x;
}
}
} /*与上面检查输入输出类似，在这里检查overlay同样先调用set_crop函数设置&t->overlay.crop里面的值，然后设置ocw和och的值，之后调用update_offset函数更新&t->set.ov_off,&t->set.ov_uoff,&t->set.ov_voff和&t->set.ovstride的偏移值，然后根据t->overlay.alpha.mode的值设置t->set.ov_alpha_stride和t->set.ov_alpha_off的值。*/
/* input overflow? */
if (!((IPU_PIX_FMT_TILED_NV12 == t->input.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->input.format))) {
if ((t->input.crop.w > soc_max_in_width(0)) ||
(t->input.crop.h > soc_max_in_height())) {
ret = IPU_CHECK_ERR_INPUT_OVER_LIMIT;
goto done;
}
} /*检查t->input.crop.w和t->input.crop.h是否合乎规范。*/
/* check task mode */
t->set.mode = NULL_MODE;
t->set.split_mode = NO_SPLIT;
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
/*output swap*/
tmp = t->output.crop.w;
t->output.crop.w = t->output.crop.h;
t->output.crop.h = tmp;
}
if (t->output.rotate >= IPU_ROTATE_90_RIGHT)
t->set.mode |= ROT_MODE; /*如果t->output.rotate>= IPU_ROTATE_90_RIGHT的话，就调换width和height，同时将
t->set.mode中置位成ROT_MODE。*/
/*need resize or CSC?*/
if ((t->input.crop.w != t->output.crop.w) ||
(t->input.crop.h != t->output.crop.h) ||
need_csc(t->input.format, t->output.format))
t->set.mode |= IC_MODE; /*检查输入与输出里面crop参数是否相等，或者输入与输出里面的格式是否相同，如果不相等的话就需要将t->set.mode中置位成IC_MODE，意思是需要ImageConverte。*/
/*need cropping?*/
if ((t->input.crop.w != t->input.width) ||
(t->input.crop.h != t->input.height) ||
(t->output.crop.w != t->output.width) ||
(t->output.crop.h != t->output.height))
t->set.mode |= IC_MODE;
/*need flip?*/
if ((t->set.mode == NULL_MODE) && (t->output.rotate > IPU_ROTATE_NONE))
t->set.mode |= IC_MODE;
/*need IDMAC do format(same color space)?*/
if ((t->set.mode == NULL_MODE) && (t->input.format != t->output.format))
t->set.mode |= IC_MODE;
/*overlay support*/
if (t->overlay_en)
t->set.mode |= IC_MODE; /*对于上面几种情况，都需要将t->set.mode置位成IC_MODE模式。*/
/*deinterlace*/
if (t->input.deinterlace.enable) {
t->set.mode &= ~IC_MODE;
t->set.mode |= VDI_MODE;
} /*如果t->input.deinterlace.enable置位的话，意思是使能了输入数据去交错功能，就需要将t->set.mode中的IC_MODE位清零，同时置位成VDI_MODE模式。*/
if ((IPU_PIX_FMT_TILED_NV12 == t->input.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->input.format)) {
if (t->set.mode & ROT_MODE) {
ret = IPU_CHECK_ERR_NOT_SUPPORT;
goto done;
}
t->set.mode |= VDOA_MODE;
if (IPU_PIX_FMT_TILED_NV12F == t->input.format)
t->set.mode |= VDOA_BAND_MODE;
t->set.mode &= ~IC_MODE;
} /*如果t->input.format的格式为IPU_PIX_FMT_TILED_NV12或IPU_PIX_FMT_TILED_NV12F的话，根据情况置位或清零t->set.mode中的某些位。*/
if ((t->set.mode & (IC_MODE | VDI_MODE)) &&
(IPU_PIX_FMT_TILED_NV12F != t->input.format)) {
if (t->output.crop.w > soc_max_out_width())
t->set.split_mode |= RL_SPLIT;
if (t->output.crop.h > soc_max_out_height())
t->set.split_mode |= UD_SPLIT;
if (!t->set.split_mode && (t->set.mode & VDI_MODE) &&
(t->input.crop.w >
soc_max_vdi_in_width(t->ipu))) {
t->set.split_mode |= RL_SPLIT;
vdi_split = true;
} /*根据t->output.crop里面的参数来决定是否拆分图像，这个还是比较好理解的，如果t->output.crop.w大于soc_max_out_width()的最大宽度的话，就需要左右拆分图像，同样，如果t->output.crop.h大于soc_max_out_height()的话，就需要上下拆分图像。*/
if (t->set.split_mode) {
if ((t->set.split_mode == RL_SPLIT) ||
(t->set.split_mode == UD_SPLIT))
timeout = DEF_TIMEOUT_MS * 2 + DEF_DELAY_MS;
else
timeout = DEF_TIMEOUT_MS * 4 + DEF_DELAY_MS;
if (t->timeout < timeout)
t->timeout = timeout; /*根据不同的拆分模式来确定超时时间，每种拆分模式需要的时间应该是不同的。*/
ret = update_split_setting(t, vdi_split);
if (ret > IPU_CHECK_ERR_MIN)
goto done;
}
} /*调用update_split_setting函数来更新拆分设置。在这个函数中调用了ipu_calc_stripes_sizes函数，这时候再来看在ipu_calc_stripes_sizes函数的意义，应该就是如果设置了t->set.split_mode中的拆分模式的话（上下拆分还是左右拆分），通过这个函数来重新设置图像的大小等信息，不知道这样理解对不对。*/
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
/*output swap*/
tmp = t->output.crop.w;
t->output.crop.w = t->output.crop.h;
t->output.crop.h = tmp;
}
if (t->set.mode == NULL_MODE) {
ret = IPU_CHECK_ERR_PROC_NO_NEED;
goto done;
}
if ((t->set.i_uoff % 8) || (t->set.i_voff % 8))
ret |= IPU_CHECK_WARN_INPUT_OFFS_NOT8ALIGN;
if ((t->set.o_uoff % 8) || (t->set.o_voff % 8))
ret |= IPU_CHECK_WARN_OUTPUT_OFFS_NOT8ALIGN;
if (t->overlay_en && ((t->set.ov_uoff % 8) || (t->set.ov_voff % 8)))
ret |= IPU_CHECK_WARN_OVERLAY_OFFS_NOT8ALIGN;
done:
/* dump msg */
if (debug) {
if (ret > IPU_CHECK_ERR_MIN)
dump_check_err(t->dev, ret);
else if (ret != IPU_CHECK_OK)
dump_check_warn(t->dev, ret);
}
return ret;
}至此，这个check_task函数就简单分析完毕，总结一下：它的核心就是ipu_task_entry结构体，首先通过set_crop函数来设置&t->input.crop里面的参数，然后调用update_offset函数来更新&t->set里面的一些偏移值，然后重复这个操作来设置&t->output.crop的值等等，如果使能了overlay的话，就再重复一遍。然后设置t->set.mode和t->set.split_mode的值。它基本就是完成了这些操作。这个函数在prepare_task和ipu_check_task函数中会调用到。
20.prepare_task函数
static int prepare_task(struct ipu_task_entry *t)
{
int ret = 0;
ret = check_task(t);
if (ret > IPU_CHECK_ERR_MIN)
return -EINVAL; /*首先调用check_task函数来设置ipu_task_entry中的某些位等。*/
if (t->set.mode & VDI_MODE) {
t->task_id = IPU_TASK_ID_VF;
t->set.task = VDI_VF;
if (t->set.mode & ROT_MODE)
t->set.task |= ROT_VF;
} /*设置ipu_task_entry中的task_id和set.task。*/
if (VDOA_MODE == t->set.mode) {
if (t->set.task != 0) {
dev_err(t->dev, "ERR: vdoa only task:0x%x, [0x%p].\n",
t->set.task, t);
return -EINVAL;
}
t->set.task |= VDOA_ONLY;
}
if (VDOA_BAND_MODE & t->set.mode) {
/* to save band size: 1<<3 = 8 lines */
t->set.band_lines = 3;
} /*如果为VDOA_BAND_MODE模式的话，需要设置t->set.band_lines位为3.*/
dump_task_info(t);
return ret;
}可见这个prepare_task函数同样是设置ipu_task_entry结构体中的某些位。这个函数在create_split_child_task，ipu_queue_task中调用。
21.ic_vf_pp_is_busy函数
static uint32_t ic_vf_pp_is_busy(struct ipu_soc *ipu, bool is_vf)
{
uint32_t status;
uint32_t status_vf;
uint32_t status_rot;
if (is_vf) {
status = ipu_channel_status(ipu, MEM_VDI_PRP_VF_MEM);
status_vf = ipu_channel_status(ipu, MEM_PRP_VF_MEM);
status_rot = ipu_channel_status(ipu, MEM_ROT_VF_MEM);
return status || status_vf || status_rot;
} else {
status = ipu_channel_status(ipu, MEM_PP_MEM);
status_rot = ipu_channel_status(ipu, MEM_ROT_PP_MEM);
return status || status_rot;
}
}这个函数就是查看某一个channel是否被使能了，它调用了ipu_common.c中的ipu_channel_status函数，其中任意一个通道使能的话这个函数都会返回1.
22._get_vdoa_ipu_res函数
static int _get_vdoa_ipu_res(struct ipu_task_entry *t)
{
int i;
struct ipu_soc *ipu;
u8 *used;
uint32_t found_ipu = 0;
uint32_t found_vdoa = 0;
struct ipu_channel_tabel *tbl = &ipu_ch_tbl;
mutex_lock(&tbl->lock);
if (t->set.mode & VDOA_MODE) {
if (NULL != t->vdoa_handle)
found_vdoa = 1;
else {
found_vdoa = tbl->vdoa_used ? 0 : 1;
if (found_vdoa) {
tbl->vdoa_used = 1;
vdoa_get_handle(&t->vdoa_handle);
} else
/* first get vdoa->ipu resource sequence */
goto out;
if (t->set.task & VDOA_ONLY)
goto out;
}
}
for (i = 0; i < max_ipu_no; i++) {
ipu = ipu_get_soc(i);
if (IS_ERR(ipu))
dev_err(t->dev, "no:0x%x,found_vdoa:%d, ipu:%d\n",
t->task_no, found_vdoa, i);
used = &tbl->used[i][IPU_PP_CH_VF];
if (t->set.mode & VDI_MODE) {
if (0 == *used) {
*used = 1;
found_ipu = 1;
break;
}
} else if ((t->set.mode & IC_MODE) || only_rot(t->set.mode)) {
if (0 == *used) {
t->task_id = IPU_TASK_ID_VF;
if (t->set.mode & IC_MODE)
t->set.task |= IC_VF;
if (t->set.mode & ROT_MODE)
t->set.task |= ROT_VF;
*used = 1;
found_ipu = 1;
break;
}
} else
dev_err(t->dev, "no:0x%x,found_vdoa:%d, mode:0x%x\n",
t->task_no, found_vdoa, t->set.mode);
}
if (found_ipu)
goto next;
for (i = 0; i < max_ipu_no; i++) {
ipu = ipu_get_soc(i);
if (IS_ERR(ipu))
dev_err(t->dev, "no:0x%x,found_vdoa:%d, ipu:%d\n",
t->task_no, found_vdoa, i);
if ((t->set.mode & IC_MODE) || only_rot(t->set.mode)) {
used = &tbl->used[i][IPU_PP_CH_PP];
if (0 == *used) {
t->task_id = IPU_TASK_ID_PP;
if (t->set.mode & IC_MODE)
t->set.task |= IC_PP;
if (t->set.mode & ROT_MODE)
t->set.task |= ROT_PP;
*used = 1;
found_ipu = 1;
break;
}
}
}
next:
if (found_ipu) {
t->ipu = ipu;
t->ipu_id = i;
t->dev = ipu->dev;
if (atomic_inc_return(&t->res_get) == 2)
dev_err(t->dev,
"ERR no:0x%x,found_vdoa:%d,get ipu twice\n",
t->task_no, found_vdoa);
}
out:
dev_dbg(t->dev,
"%s:no:0x%x,found_vdoa:%d, found_ipu:%d\n",
__func__, t->task_no, found_vdoa, found_ipu);
mutex_unlock(&tbl->lock);
if (t->set.task & VDOA_ONLY)
return found_vdoa;
else if (t->set.mode & VDOA_MODE)
return found_vdoa && found_ipu;
else
return found_ipu;
}在看这个函数的时候， 它直接使用了if(NULL != t->vdoa_handle)，这个t->vdoa_handle是在哪初始化的？后来在搜索这个的时候发现，它是在init_tiled_buf函数中通过ret= vdoa_setup(t->vdoa_handle,¶m);函数初始化的。跟踪这个vdoa_setup--->init_tiled_buf--->init_tiled_ch_bufs--->do_task_vdoa_only--->get_res_do_task;
或者vdoa_setup--->init_tiled_buf--->init_tiled_ch_bufs--->init_ic--->do_task--->get_res_do_task；（这两个流程都是后面的函数调用前面的函数）
在这个get_res_do_task函数中，get_vdoa_ipu_res--->_get_vdoa_ipu_res这两个函数是最先执行的。所以在第一次执行_get_vdoa_ipu_res函数的时候，这个t->vdoa_handle还没有通过vdoa_setup函数进行初始化。所以第一次执行这个函数的时候，可能就会走到out:这个标号这里。
然后return到get_vdoa_ipu_res函数中，在get_vdoa_ipu_res函数中通过：
ret= wait_event_timeout(res_waitq, _get_vdoa_ipu_res(t),
msecs_to_jiffies(t->timeout - DEF_DELAY_MS));
等待队列获取到信息。
这的流程后面再分析分析，不清楚～～～
23.put_vdoa_ipu_res函数
这个函数是get_vdoa_ipu_res函数的反函数，就不分析了。
24.get_vdoa_ipu_res
static int get_vdoa_ipu_res(struct ipu_task_entry *t)
{
int ret;
uint32_t found = 0;
found = _get_vdoa_ipu_res(t);
if (!found) {
t->ipu_id = -1;
t->ipu = NULL;
/* blocking to get resource */
ret = atomic_inc_return(&req_cnt);
dev_dbg(t->dev,
"wait_res:no:0x%x,req_cnt:%d\n", t->task_no, ret);
ret = wait_event_timeout(res_waitq, _get_vdoa_ipu_res(t),
msecs_to_jiffies(t->timeout - DEF_DELAY_MS));
if (ret == 0) {
dev_err(t->dev, "ERR[0x%p,no-0x%x] wait_res timeout:%dms!\n",
t, t->task_no, t->timeout - DEF_DELAY_MS);
ret = -ETIMEDOUT;
t->state = STATE_RES_TIMEOUT;
goto out;
} else {
if (!(t->set.task & VDOA_ONLY) && (!t->ipu))
dev_err(t->dev,
"ERR[no-0x%x] can not get ipu!\n",
t->task_no);
ret = atomic_read(&req_cnt);
if (ret > 0)
ret = atomic_dec_return(&req_cnt);
else
dev_err(t->dev,
"ERR[no-0x%x] req_cnt:%d mismatch!\n",
t->task_no, ret);
dev_dbg(t->dev, "no-0x%x,[0x%p],req_cnt:%d, got_res!\n",
t->task_no, t, ret);
found = 1;
}
}
out:
return found;
}这个函数就是首先调用_get_vdoa_ipu_res函数来获取资源，如果没有获取到的话，就在等待队列中等待资源，这个函数的返回值是：如果成功获取到资源，返回1，否则返回0.它被get_res_do_task函数调用。
25.create_task_entry函数
static struct ipu_task_entry *create_task_entry(struct ipu_task *task)
{
struct ipu_task_entry *tsk;
tsk = kzalloc(sizeof(struct ipu_task_entry), GFP_KERNEL);
if (!tsk)
return ERR_PTR(-ENOMEM);
kref_init(&tsk->refcount);
tsk->state = -EINVAL;
tsk->ipu_id = -1;
tsk->dev = ipu_dev;
tsk->input = task->input;
tsk->output = task->output;
tsk->overlay_en = task->overlay_en;
if (tsk->overlay_en)
tsk->overlay = task->overlay;
if (task->timeout > DEF_TIMEOUT_MS)
tsk->timeout = task->timeout;
else
tsk->timeout = DEF_TIMEOUT_MS;
return tsk;
}这个函数就是根据传入的structipu_task *task参数来从新分配设置一个structipu_task_entry*tsk结构体，将里面的值初始化了。它被create_split_child_task，ipu_check_task和ipu_queue_task函数调用。
26.task_mem_free函数
static void task_mem_free(struct kref *ref)
{
struct ipu_task_entry *tsk =
container_of(ref, struct ipu_task_entry, refcount);
kfree(tsk);
}根据引用计数，然后调用container_of宏来获取它的容器ipu_task_entry，然后释放掉它的内存。
27.create_split_child_task函数
int create_split_child_task(struct ipu_split_task *sp_task)
{
int ret = 0;
struct ipu_task_entry *tsk;
tsk = create_task_entry(&sp_task->task);
if (IS_ERR(tsk))
return PTR_ERR(tsk);
sp_task->child_task = tsk;
tsk->task_no = sp_task->task_no;
ret = prepare_task(tsk);
if (ret < 0)
goto err;
tsk->parent = sp_task->parent_task;
tsk->set.sp_setting = sp_task->parent_task->set.sp_setting;
list_add(&tsk->node, &tsk->parent->split_list);
dev_dbg(tsk->dev, "[0x%p] sp_tsk Q list,no-0x%x\n", tsk, tsk->task_no);
tsk->state = STATE_QUEUE;
CHECK_PERF(&tsk->ts_queue);
err:
return ret;
}这个函数还是比较好理解的，首先通过create_task_entry来根据structipu_split_task *sp_task中的task参数分配设置一个ipu_task_entry*tsk结构体，然后分配的这个*tsk结构体作为子task，而函数的实参structipu_split_task*sp_task是父task，然后调用prepare_task函数设置其他的默认值，然后将&tsk->node加入&tsk->parent->split_list链表中，设置tsk->state为STATE_QUEUE。
28.sp_task_check_done函数
static inline int sp_task_check_done(struct ipu_split_task *sp_task,
struct ipu_task_entry *parent, int num, int *idx)
{
int i;
int ret = 0;
struct ipu_task_entry *tsk;
struct mutex *lock = &parent->split_lock;
*idx = -EINVAL;
mutex_lock(lock);
for (i = 0; i < num; i++) {
tsk = sp_task[i].child_task;
if (tsk && tsk->split_done) {
*idx = i;
ret = 1;
goto out;
}
}
out:
mutex_unlock(lock);
return ret;
}这个函数从tsk=sp_task[i].child_task;数组中找到已经完成的一项，返回它的下标。它在wait_split_task_complete函数中调用。
29.create_split_task函数
static int create_split_task(
int stripe,
struct ipu_split_task *sp_task)
{
struct ipu_task *task = &(sp_task->task);
struct ipu_task_entry *t = sp_task->parent_task;
int ret;
sp_task->task_no |= stripe;
task->input = t->input;
task->output = t->output;
task->overlay_en = t->overlay_en;
if (task->overlay_en)
task->overlay = t->overlay;
task->task_id = t->task_id;
if ((t->set.split_mode == RL_SPLIT) ||
(t->set.split_mode == UD_SPLIT))
task->timeout = t->timeout / 2;
else
task->timeout = t->timeout / 4; /*设置task中的input,output,overlay,timeout。*/
task->input.crop.w = t->set.sp_setting.iw;
task->input.crop.h = t->set.sp_setting.ih;
if (task->overlay_en) {
task->overlay.crop.w = t->set.sp_setting.ow;
task->overlay.crop.h = t->set.sp_setting.oh;
}
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
task->output.crop.w = t->set.sp_setting.oh;
task->output.crop.h = t->set.sp_setting.ow;
t->set.sp_setting.rl_split_line = t->set.sp_setting.o_bottom_pos;
t->set.sp_setting.ud_split_line = t->set.sp_setting.o_right_pos;
} else {
task->output.crop.w = t->set.sp_setting.ow;
task->output.crop.h = t->set.sp_setting.oh;
t->set.sp_setting.rl_split_line = t->set.sp_setting.o_right_pos;
t->set.sp_setting.ud_split_line = t->set.sp_setting.o_bottom_pos;
} /*设置task中input,output,overlay里面的crop参数。*/
if (stripe & LEFT_STRIPE)
task->input.crop.pos.x += t->set.sp_setting.i_left_pos;
else if (stripe & RIGHT_STRIPE)
task->input.crop.pos.x += t->set.sp_setting.i_right_pos;
if (stripe & UP_STRIPE)
task->input.crop.pos.y += t->set.sp_setting.i_top_pos;
else if (stripe & DOWN_STRIPE)
task->input.crop.pos.y += t->set.sp_setting.i_bottom_pos;
if (task->overlay_en) {
if (stripe & LEFT_STRIPE)
task->overlay.crop.pos.x += t->set.sp_setting.o_left_pos;
else if (stripe & RIGHT_STRIPE)
task->overlay.crop.pos.x += t->set.sp_setting.o_right_pos;
if (stripe & UP_STRIPE)
task->overlay.crop.pos.y += t->set.sp_setting.o_top_pos;
else if (stripe & DOWN_STRIPE)
task->overlay.crop.pos.y += t->set.sp_setting.o_bottom_pos;
}
switch (t->output.rotate) {
case IPU_ROTATE_NONE:
if (stripe & LEFT_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_left_pos;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_right_pos;
if (stripe & UP_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_top_pos;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_bottom_pos;
break;
case IPU_ROTATE_VERT_FLIP:
if (stripe & LEFT_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_left_pos;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_right_pos;
if (stripe & UP_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_top_pos - t->set.sp_setting.oh;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_bottom_pos - t->set.sp_setting.oh;
break;
case IPU_ROTATE_HORIZ_FLIP:
if (stripe & LEFT_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_left_pos - t->set.sp_setting.ow;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_right_pos - t->set.sp_setting.ow;
if (stripe & UP_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_top_pos;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_bottom_pos;
break;
case IPU_ROTATE_180:
if (stripe & LEFT_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_left_pos - t->set.sp_setting.ow;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_right_pos - t->set.sp_setting.ow;
if (stripe & UP_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_top_pos - t->set.sp_setting.oh;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_bottom_pos - t->set.sp_setting.oh;
break;
case IPU_ROTATE_90_RIGHT:
if (stripe & UP_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_top_pos - t->set.sp_setting.oh;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_bottom_pos - t->set.sp_setting.oh;
if (stripe & LEFT_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_left_pos;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_right_pos;
break;
case IPU_ROTATE_90_RIGHT_HFLIP:
if (stripe & UP_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_top_pos;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_bottom_pos;
if (stripe & LEFT_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_left_pos;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.y += t->set.sp_setting.o_right_pos;
break;
case IPU_ROTATE_90_RIGHT_VFLIP:
if (stripe & UP_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_top_pos - t->set.sp_setting.oh;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.x =
t->output.crop.pos.x + t->output.crop.w
- t->set.sp_setting.o_bottom_pos - t->set.sp_setting.oh;
if (stripe & LEFT_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_left_pos - t->set.sp_setting.ow;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_right_pos - t->set.sp_setting.ow;
break;
case IPU_ROTATE_90_LEFT:
if (stripe & UP_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_top_pos;
else if (stripe & DOWN_STRIPE)
task->output.crop.pos.x += t->set.sp_setting.o_bottom_pos;
if (stripe & LEFT_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_left_pos - t->set.sp_setting.ow;
else if (stripe & RIGHT_STRIPE)
task->output.crop.pos.y =
t->output.crop.pos.y + t->output.crop.h
- t->set.sp_setting.o_right_pos - t->set.sp_setting.ow;
break;
default:
dev_err(t->dev, "ERR:should not be here\n");
break;
} /*上面这个switch语句是根据t->output.rotate的值来设置task里面output的crop值。*/
ret = create_split_child_task(sp_task);
if (ret < 0)
dev_err(t->dev, "ERR:create_split_child_task() ret:%d\n", ret); /*上面设置好了sp_task中的task参数，就根据它来创建子task。*/
return ret;
}先来看这个structipu_split_task结构体：
struct ipu_split_task {
struct ipu_task task;
struct ipu_task_entry *parent_task;
struct ipu_task_entry *child_task;
u32 task_no;
};从这个函数的的开头：
structipu_task *task = &(sp_task->task);
structipu_task_entry *t = sp_task->parent_task;
而这个函数的主要操作就是设置这个task结构体。从这里就可以看出来，函数的目的就是根据传入的第二个structipu_split_task *sp_task参数里面的parent_task成员来填充第二个参数里面的task成员。设置完以后，在最后调用create_split_child_task函数（27.中讲解），根据sp_task->task来设置子task。
30.queue_split_task函数
static int queue_split_task(struct ipu_task_entry *t,
struct ipu_split_task *sp_task, uint32_t size)
{
int err[4];
int ret = 0;
int i, j;
struct ipu_task_entry *tsk = NULL;
struct mutex *lock = &t->split_lock;
struct mutex *vdic_lock = &t->vdic_lock;
dev_dbg(t->dev, "Split task 0x%p, no-0x%x, size:%d\n",
t, t->task_no, size);
mutex_init(lock);
mutex_init(vdic_lock);
init_waitqueue_head(&t->split_waitq);
INIT_LIST_HEAD(&t->split_list); /*初始化锁，等待队列，链表头等。*/
for (j = 0; j < size; j++) {
memset(&sp_task[j], 0, sizeof(*sp_task));
sp_task[j].parent_task = t;
sp_task[j].task_no = t->task_no;
} /*将&sp_task[j]中的每一项都置为0，然后将每一项的parent_task都指向函数的第一个参数t。*/
if (t->set.split_mode == RL_SPLIT) {
i = 0;
err[i] = create_split_task(RIGHT_STRIPE, &sp_task[i]);
if (err[i] < 0)
goto err_start;
i = 1;
err[i] = create_split_task(LEFT_STRIPE, &sp_task[i]);
} else if (t->set.split_mode == UD_SPLIT) {
i = 0;
err[i] = create_split_task(DOWN_STRIPE, &sp_task[i]);
if (err[i] < 0)
goto err_start;
i = 1;
err[i] = create_split_task(UP_STRIPE, &sp_task[i]);
} else {
i = 0;
err[i] = create_split_task(RIGHT_STRIPE | DOWN_STRIPE, &sp_task[i]);
if (err[i] < 0)
goto err_start;
i = 1;
err[i] = create_split_task(LEFT_STRIPE | DOWN_STRIPE, &sp_task[i]);
if (err[i] < 0)
goto err_start;
i = 2;
err[i] = create_split_task(RIGHT_STRIPE | UP_STRIPE, &sp_task[i]);
if (err[i] < 0)
goto err_start;
i = 3;
err[i] = create_split_task(LEFT_STRIPE | UP_STRIPE, &sp_task[i]);
} /*以上根据t->set.split_mode来选择创建什么样的子task。以RL_SPLIT为例，它分别创建了sp_task[0]，stripe为RIGHT_STRIPE的子task和sp_task[1]，stripe为LEFT_STRIPE的子task。如果tsk->set.split_mode明确表示等于RL_SPLIT或者UD_SPLIT的话，函数的第三个参数size就等于2,表示将创建2个子task，保存在sp_task数组中;除此之外的其他情况下将会创建4个子task，为什么呢？因为这个tsk->set.split_mode除了明确指明等于RL_SPLIT或者UD_SPLIT的话，第三种情况基本就能确定是RL_SPLIT|UD_SPLIT。*/
err_start:
for (j = 0; j < (i + 1); j++) {
if (err[j] < 0) {
if (sp_task[j].child_task)
dev_err(t->dev,
"sp_task[%d],no-0x%x fail state:%d, queue err:%d.\n",
j, sp_task[j].child_task->task_no,
sp_task[j].child_task->state, err[j]);
goto err_exit;
}
dev_dbg(t->dev, "[0x%p] sp_task[%d], no-0x%x state:%s, queue ret:%d.\n",
sp_task[j].child_task, j, sp_task[j].child_task->task_no,
state_msg[sp_task[j].child_task->state].msg, err[j]);
}
return ret;
err_exit:
for (j = 0; j < (i + 1); j++) {
if (err[j] < 0 && !ret)
ret = err[j];
tsk = sp_task[j].child_task;
if (!tsk)
continue;
kfree(tsk);
}
t->state = STATE_ERR;
return ret;
}这个函数直接在ipu_task_thread被调用。
31.init_tiled_buf函数
static int init_tiled_buf(struct ipu_soc *ipu, struct ipu_task_entry *t,
ipu_channel_t channel, uint32_t ch_type)
{
int ret = 0;
int i;
uint32_t ipu_fmt;
dma_addr_t inbuf_base = 0;
u32 field_size;
struct vdoa_params param;
struct vdoa_ipu_buf buf;
struct ipu_soc *ipu_idx;
u32 ipu_stride, obuf_size;
u32 height, width;
ipu_buffer_t type;
if ((IPU_PIX_FMT_YUYV != t->output.format) &&
(IPU_PIX_FMT_NV12 != t->output.format)) {
dev_err(t->dev, "ERR:[0x%d] output format\n", t->task_no);
return -EINVAL;
} /*如果t->output.format的格式不是IPU_PIX_FMT_YUYV或IPU_PIX_FMT_NV12的话就报错。*/
memset(¶m, 0, sizeof(param));
/* init channel tiled bufs */
if (deinterlace_3_field(t) &&
(IPU_PIX_FMT_TILED_NV12F == t->input.format)) {
field_size = tiled_filed_size(t);
if (INPUT_CHAN_VDI_P == ch_type) {
inbuf_base = t->input.paddr + field_size;
param.vfield_buf.prev_veba = inbuf_base + t->set.i_off;
} else if (INPUT_CHAN == ch_type) {
inbuf_base = t->input.paddr_n;
param.vfield_buf.cur_veba = inbuf_base + t->set.i_off;
} else if (INPUT_CHAN_VDI_N == ch_type) {
inbuf_base = t->input.paddr_n + field_size;
param.vfield_buf.next_veba = inbuf_base + t->set.i_off;
} else
return -EINVAL;
height = t->input.crop.h >> 1; /* field format for vdoa */
width = t->input.crop.w;
param.vfield_buf.vubo = t->set.i_uoff;
param.interlaced = 1;
param.scan_order = 1;
type = IPU_INPUT_BUFFER;
} /*如果IPU_PIX_FMT_TILED_NV12F==t->input.format的话就会执行上面的语句。首先根据函数的第四个参数ch_type来确定inbuf_base和param.vfield_buf.cur_veba的值。设置height，width,type和param的值。*/
else if ((IPU_PIX_FMT_TILED_NV12 == t->input.format) &&
(INPUT_CHAN == ch_type)) {
height = t->input.crop.h;
width = t->input.crop.w;
param.vframe_buf.veba = t->input.paddr + t->set.i_off;
param.vframe_buf.vubo = t->set.i_uoff;
type = IPU_INPUT_BUFFER;
} else
return -EINVAL; /*如果IPU_PIX_FMT_TILED_NV12== t->input.format的话就会执行这段代码。设置height，width,type和param的值。*/
param.band_mode = (t->set.mode & VDOA_BAND_MODE) ? 1 : 0;
if (param.band_mode && (t->set.band_lines != 3) &&
(t->set.band_lines != 4) && (t->set.band_lines != 5))
return -EINVAL;
else if (param.band_mode)
param.band_lines = (1 << t->set.band_lines);
for (i = 0; i < max_ipu_no; i++) {
ipu_idx = ipu_get_soc(i);
if (!IS_ERR(ipu_idx) && ipu_idx == ipu)
break;
}
if (t->set.task & VDOA_ONLY)
/* dummy, didn't need ipu res */
i = 0;
if (max_ipu_no == i) {
dev_err(t->dev, "ERR:[0x%p] get ipu num\n", t);
return -EINVAL;
}
param.ipu_num = i;
param.vpu_stride = t->input.width;
param.height = height;
param.width = width;
if (IPU_PIX_FMT_NV12 == t->output.format)
param.pfs = VDOA_PFS_NV12;
else
param.pfs = VDOA_PFS_YUYV;
ipu_fmt = (param.pfs == VDOA_PFS_YUYV) ? IPU_PIX_FMT_YUYV :
IPU_PIX_FMT_NV12;
ipu_stride = param.width * bytes_per_pixel(ipu_fmt);
obuf_size = PAGE_ALIGN(param.width * param.height *
fmt_to_bpp(ipu_fmt)/8);
dev_dbg(t->dev, "band_mode:%d, band_lines:%d\n",
param.band_mode, param.band_lines);
if (!param.band_mode) {
/* note: if only for tiled -> raster convert and
no other post-processing, we don't need alloc buf
and use output buffer directly.
*/
if (t->set.task & VDOA_ONLY)
param.ieba0 = t->output.paddr;
else {
dev_err(t->dev, "ERR:[0x%d] vdoa task\n", t->task_no);
return -EINVAL;
}
} else {
if (IPU_PIX_FMT_TILED_NV12F != t->input.format) {
dev_err(t->dev, "ERR [0x%d] vdoa task\n", t->task_no);
return -EINVAL;
}
} /*上面这些设置主要是设置param的值，最终目的是调用下面的vdoa_setup函数。*/
ret = vdoa_setup(t->vdoa_handle, ¶m);
if (ret)
goto done;
vdoa_get_output_buf(t->vdoa_handle, &buf);
if (t->set.task & VDOA_ONLY)
goto done; /*通过上面两个函数分别来设置vdoa和将vdoa中的数据读到buf中，然后为下面这个函数做准备。这两个函数在vdoa.c中，暂时没有分析。*/
ret = ipu_init_channel_buffer(ipu,
channel,
type,
ipu_fmt,
width,
height,
ipu_stride,
IPU_ROTATE_NONE,
buf.ieba0,
buf.ieba1,
0,
buf.iubo,
0);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
} /*然后调用ipu_init_channel_buffer函数来初始化channel的buffer。这个函数在ipu_common.c中。*/
if (param.band_mode) {
ret = ipu_set_channel_bandmode(ipu, channel,
type, t->set.band_lines);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BAND_FAIL;
goto done;
}
} /*如果MODE是VDOA_BAND_MODE的话，就会执行这个函数。*/
done:
return ret;
}
32.init_tiled_ch_bufs函数
static int init_tiled_ch_bufs(struct ipu_soc *ipu, struct ipu_task_entry *t)
{
int ret = 0;
if (IPU_PIX_FMT_TILED_NV12 == t->input.format) {
ret = init_tiled_buf(ipu, t, t->set.ic_chan, INPUT_CHAN);
CHECK_RETCODE(ret < 0, "init tiled_ch", t->state, done, ret);
} /*如果t->input.format== IPU_PIX_FMT_TILED_NV12的话，就根据t->set.ic_chan和INPUT_CHAN初始化一个channel的buffer。*/
else if (IPU_PIX_FMT_TILED_NV12F == t->input.format) {
ret = init_tiled_buf(ipu, t, t->set.ic_chan, INPUT_CHAN);
CHECK_RETCODE(ret < 0, "init tiled_ch-c", t->state, done, ret);
ret = init_tiled_buf(ipu, t, t->set.vdi_ic_p_chan,
INPUT_CHAN_VDI_P);
CHECK_RETCODE(ret < 0, "init tiled_ch-p", t->state, done, ret);
ret = init_tiled_buf(ipu, t, t->set.vdi_ic_n_chan,
INPUT_CHAN_VDI_N);
CHECK_RETCODE(ret < 0, "init tiled_ch-n", t->state, done, ret);
} /*如果t->input.format==IPU_PIX_FMT_TILED_NV12F的话，需要初始化t->set.ic_chan，t->set.vdi_ic_p_chan和t->set.vdi_ic_n_chan三个channel的buffer。看来这个t->input.format很重要啊～～～*/
else {
ret = -EINVAL;
dev_err(t->dev, "ERR[no-0x%x] invalid fmt:0x%x!\n",
t->task_no, t->input.format);
}
done:
return ret;
}这个函数是初始化channel的平铺buffer的，所以在init_ic和do_task_vdoa_only函数中调用它。
33.init_ic函数
static int init_ic(struct ipu_soc *ipu, struct ipu_task_entry *t)
{
int ret = 0;
ipu_channel_params_t params;
dma_addr_t inbuf = 0, ovbuf = 0, ov_alp_buf = 0;
dma_addr_t inbuf_p = 0, inbuf_n = 0;
dma_addr_t outbuf = 0;
int out_uoff = 0, out_voff = 0, out_rot;
int out_w = 0, out_h = 0, out_stride;
int out_fmt;
u32 vdi_frame_idx = 0;
memset(¶ms, 0, sizeof(params));
/* is it need link a rot channel */
if (ic_and_rot(t->set.mode)) {
outbuf = t->set.r_paddr;
out_w = t->set.r_width;
out_h = t->set.r_height;
out_stride = t->set.r_stride;
out_fmt = t->set.r_fmt;
out_uoff = 0;
out_voff = 0;
out_rot = IPU_ROTATE_NONE;
} else {
outbuf = t->output.paddr + t->set.o_off;
out_w = t->output.crop.w;
out_h = t->output.crop.h;
out_stride = t->set.ostride;
out_fmt = t->output.format;
out_uoff = t->set.o_uoff;
out_voff = t->set.o_voff;
out_rot = t->output.rotate;
} /*通过ic_and_rot函数来判断是否需要链接上一个rotchannel，如果需要的话，就将outbuf，out_w，out_h等等值都赋为t->set.r_xxxx的值，不需要的话就赋为t->set.o_xxxx的值。*/
/* settings */
params.mem_prp_vf_mem.in_width = t->input.crop.w;
params.mem_prp_vf_mem.out_width = out_w;
params.mem_prp_vf_mem.in_height = t->input.crop.h;
params.mem_prp_vf_mem.out_height = out_h;
params.mem_prp_vf_mem.in_pixel_fmt = t->input.format;
params.mem_prp_vf_mem.out_pixel_fmt = out_fmt;
params.mem_prp_vf_mem.motion_sel = t->input.deinterlace.motion;
params.mem_prp_vf_mem.outh_resize_ratio =
t->set.sp_setting.outh_resize_ratio;
params.mem_prp_vf_mem.outv_resize_ratio =
t->set.sp_setting.outv_resize_ratio;
if (t->overlay_en) {
params.mem_prp_vf_mem.in_g_pixel_fmt = t->overlay.format;
params.mem_prp_vf_mem.graphics_combine_en = 1;
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_GLOBAL)
params.mem_prp_vf_mem.global_alpha_en = 1;
else if (t->overlay.alpha.loc_alp_paddr)
params.mem_prp_vf_mem.alpha_chan_en = 1;
/* otherwise, alpha bending per pixel is used. */
params.mem_prp_vf_mem.alpha = t->overlay.alpha.gvalue;
if (t->overlay.colorkey.enable) {
params.mem_prp_vf_mem.key_color_en = 1;
params.mem_prp_vf_mem.key_color = t->overlay.colorkey.value;
}
}
if (t->input.deinterlace.enable) {
if (t->input.deinterlace.field_fmt & IPU_DEINTERLACE_FIELD_MASK)
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_BOTTOM;
else
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_TOP;
if (t->input.deinterlace.field_fmt & IPU_DEINTERLACE_RATE_EN)
vdi_frame_idx = t->input.deinterlace.field_fmt &
IPU_DEINTERLACE_RATE_FRAME1;
} /*以上的代码就是设置ipu_channel_params_tparams的各个值，然后这个params变量将要被ipu_init_channel函数所使用来初始化channel。*/
if (t->set.mode & VDOA_MODE)
ipu->vdoa_en = 1;
/* init channels */
if (!(t->set.task & VDOA_ONLY)) {
ret = ipu_init_channel(ipu, t->set.ic_chan, ¶ms);
if (ret < 0) {
t->state = STATE_INIT_CHAN_FAIL;
goto done;
}
} /*如果t->set.task不是VDOA_ONLY的话，就根据参数初始化t->set.ic_chan这个channel。为什么不能是VDOA_ONLY呢？因为在get_res_do_task函数中分流了，如果是VDOA_ONLY的话就会调用do_task_vdoa_only函数。*/
if (deinterlace_3_field(t)) {
ret = ipu_init_channel(ipu, t->set.vdi_ic_p_chan, ¶ms);
if (ret < 0) {
t->state = STATE_INIT_CHAN_FAIL;
goto done;
}
ret = ipu_init_channel(ipu, t->set.vdi_ic_n_chan, ¶ms);
if (ret < 0) {
t->state = STATE_INIT_CHAN_FAIL;
goto done;
}
} /*同时还需要初始化t->set.vdi_ic_p_chan和t->set.vdi_ic_n_chan这两个channel。*/
/* init channel bufs */
if ((IPU_PIX_FMT_TILED_NV12 == t->input.format) ||
(IPU_PIX_FMT_TILED_NV12F == t->input.format)) {
ret = init_tiled_ch_bufs(ipu, t);
if (ret < 0)
goto done;
} /*如果t->input.format为IPU_PIX_FMT_TILED_NV12或IPU_PIX_FMT_TILED_NV12F的话，就调用init_tiled_ch_bufs函数即可。这时候就有点理解了，对于输入的这两种格式，它们不能用普通的buffer来存储，所以这的buffer叫做tiledbuffer，而对于一般的输入格式，就直接调用下面的ipu_init_channel_buffer函数来初始化。看这两个格式的名字里面也带有TILED。*/
else {
if ((deinterlace_3_field(t)) &&
(IPU_PIX_FMT_TILED_NV12F != t->input.format)) {
if (params.mem_prp_vf_mem.field_fmt ==
IPU_DEINTERLACE_FIELD_TOP) {
if (vdi_frame_idx) {
inbuf_p = t->input.paddr + t->set.istride +
t->set.i_off;
inbuf = t->input.paddr_n + t->set.i_off;
inbuf_n = t->input.paddr_n + t->set.istride +
t->set.i_off;
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_BOTTOM;
} else {
inbuf_p = t->input.paddr + t->set.i_off;
inbuf = t->input.paddr + t->set.istride + t->set.i_off;
inbuf_n = t->input.paddr_n + t->set.i_off;
}
} else {
if (vdi_frame_idx) {
inbuf_p = t->input.paddr + t->set.i_off;
inbuf = t->input.paddr_n + t->set.istride + t->set.i_off;
inbuf_n = t->input.paddr_n + t->set.i_off;
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_TOP;
} else {
inbuf_p = t->input.paddr + t->set.istride +
t->set.i_off;
inbuf = t->input.paddr + t->set.i_off;
inbuf_n = t->input.paddr_n + t->set.istride +
t->set.i_off;
}
}
} else {
if (t->input.deinterlace.enable) {
if (params.mem_prp_vf_mem.field_fmt ==
IPU_DEINTERLACE_FIELD_TOP) {
if (vdi_frame_idx) {
inbuf = t->input.paddr + t->set.istride + t->set.i_off;
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_BOTTOM;
} else
inbuf = t->input.paddr + t->set.i_off;
} else {
if (vdi_frame_idx) {
inbuf = t->input.paddr + t->set.i_off;
params.mem_prp_vf_mem.field_fmt =
IPU_DEINTERLACE_FIELD_TOP;
} else
inbuf = t->input.paddr + t->set.istride + t->set.i_off;
}
} else
inbuf = t->input.paddr + t->set.i_off;
} /*上面就是设置inbuf_p，inbuf和inbuf_n的值。这几个值分别用在不同的ipu_init_channel_buffer函数里面，具体有什么不同以后再分析。*/
if (t->overlay_en)
ovbuf = t->overlay.paddr + t->set.ov_off; /*如果使能了overlay_en的话，设置ovbuf。*/
}
if (t->overlay_en && (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL))
ov_alp_buf = t->overlay.alpha.loc_alp_paddr
+ t->set.ov_alpha_off; /*如果使能overlay_en同时设置了alpha模式的话，设置ov_alp_buf。*/
if ((IPU_PIX_FMT_TILED_NV12 != t->input.format) &&
(IPU_PIX_FMT_TILED_NV12F != t->input.format)) {
ret = ipu_init_channel_buffer(ipu,
t->set.ic_chan,
IPU_INPUT_BUFFER,
t->input.format,
t->input.crop.w,
t->input.crop.h,
t->set.istride,
IPU_ROTATE_NONE,
inbuf,
0,
0,
t->set.i_uoff,
t->set.i_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
} /*上面通过ipu_init_channel函数初始化了3个channel，所以需要初始化3个对应的buffer。这里初始化的是t->set.ic_chanchannel的buffer。*/
if (deinterlace_3_field(t) &&
(IPU_PIX_FMT_TILED_NV12F != t->input.format)) {
ret = ipu_init_channel_buffer(ipu,
t->set.vdi_ic_p_chan,
IPU_INPUT_BUFFER,
t->input.format,
t->input.crop.w,
t->input.crop.h,
t->set.istride,
IPU_ROTATE_NONE,
inbuf_p,
0,
0,
t->set.i_uoff,
t->set.i_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
} /*这里初始化的是t->set.vdi_ic_p_chanchannel的buffer。*/
ret = ipu_init_channel_buffer(ipu,
t->set.vdi_ic_n_chan,
IPU_INPUT_BUFFER,
t->input.format,
t->input.crop.w,
t->input.crop.h,
t->set.istride,
IPU_ROTATE_NONE,
inbuf_n,
0,
0,
t->set.i_uoff,
t->set.i_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
} /*这里初始化的是t->set.vdi_ic_n_chanchannel的buffer。*/
if (t->overlay_en) {
ret = ipu_init_channel_buffer(ipu,
t->set.ic_chan,
IPU_GRAPH_IN_BUFFER,
t->overlay.format,
t->overlay.crop.w,
t->overlay.crop.h,
t->set.ovstride,
IPU_ROTATE_NONE,
ovbuf,
0,
0,
t->set.ov_uoff,
t->set.ov_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
} /*如果使能了overlay_en的话，同样需要为它初始化channelbuffer。*/
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL) {
ret = ipu_init_channel_buffer(ipu,
t->set.ic_chan,
IPU_ALPHA_IN_BUFFER,
IPU_PIX_FMT_GENERIC,
t->overlay.crop.w,
t->overlay.crop.h,
t->set.ov_alpha_stride,
IPU_ROTATE_NONE,
ov_alp_buf,
0,
0,
0, 0);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
} /*如果t->overlay.alpha.mode== IPU_ALPHA_MODE_LOCAL 的话，需要为它初始化channelbuffer。*/
if (!(t->set.task & VDOA_ONLY)) {
ret = ipu_init_channel_buffer(ipu,
t->set.ic_chan,
IPU_OUTPUT_BUFFER,
out_fmt,
out_w,
out_h,
out_stride,
out_rot,
outbuf,
0,
0,
out_uoff,
out_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
} /*初始化这个channelbuffer是为什么。。。。不理解*/
if ((t->set.mode & VDOA_BAND_MODE) && (t->set.task & VDI_VF)) {
ret = ipu_link_channels(ipu, MEM_VDOA_MEM, t->set.ic_chan);
CHECK_RETCODE(ret < 0, "ipu_link_ch vdoa_ic",
STATE_LINK_CHAN_FAIL, done, ret);
} /*链接两个channel。什么情况下需要链接channel？？是因为它们都是t->set.ic_chanchannel吗？？？这个函数在ipu_common.c中。*/
done:
return ret;
}
34.uninit_ic函数
static void uninit_ic(struct ipu_soc *ipu, struct ipu_task_entry *t)
{
int ret;
if ((t->set.mode & VDOA_BAND_MODE) && (t->set.task & VDI_VF)) {
ret = ipu_unlink_channels(ipu, MEM_VDOA_MEM, t->set.ic_chan);
CHECK_RETCODE_CONT(ret < 0, "ipu_unlink_ch vdoa_ic",
STATE_UNLINK_CHAN_FAIL, ret);
}
ipu_uninit_channel(ipu, t->set.ic_chan);
if (deinterlace_3_field(t)) {
ipu_uninit_channel(ipu, t->set.vdi_ic_p_chan);
ipu_uninit_channel(ipu, t->set.vdi_ic_n_chan);
}
}这个函数是上一个函数的反函数，就不分析了。
35.init_rot函数
static int init_rot(struct ipu_soc *ipu, struct ipu_task_entry *t)
{
int ret = 0;
dma_addr_t inbuf = 0, outbuf = 0;
int in_uoff = 0, in_voff = 0;
int in_fmt, in_width, in_height, in_stride;
/* init channel */
ret = ipu_init_channel(ipu, t->set.rot_chan, NULL);
if (ret < 0) {
t->state = STATE_INIT_CHAN_FAIL;
goto done;
}
/* init channel buf */
/* is it need link to a ic channel */
if (ic_and_rot(t->set.mode)) {
in_fmt = t->set.r_fmt;
in_width = t->set.r_width;
in_height = t->set.r_height;
in_stride = t->set.r_stride;
inbuf = t->set.r_paddr;
in_uoff = 0;
in_voff = 0;
} else {
in_fmt = t->input.format;
in_width = t->input.crop.w;
in_height = t->input.crop.h;
in_stride = t->set.istride;
inbuf = t->input.paddr + t->set.i_off;
in_uoff = t->set.i_uoff;
in_voff = t->set.i_voff;
}
outbuf = t->output.paddr + t->set.o_off; /*设置一些值用于ipu_init_channel_buffer函数。*/
ret = ipu_init_channel_buffer(ipu,
t->set.rot_chan,
IPU_INPUT_BUFFER,
in_fmt,
in_width,
in_height,
in_stride,
t->output.rotate,
inbuf,
0,
0,
in_uoff,
in_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
ret = ipu_init_channel_buffer(ipu,
t->set.rot_chan,
IPU_OUTPUT_BUFFER,
t->output.format,
t->output.crop.w,
t->output.crop.h,
t->set.ostride,
IPU_ROTATE_NONE,
outbuf,
0,
0,
t->set.o_uoff,
t->set.o_voff);
if (ret < 0) {
t->state = STATE_INIT_CHAN_BUF_FAIL;
goto done;
}
done:
return ret;
}这个函数初始化了两个channelbuffer，注释中有一句话：isit need link to a icchannel。但是第二个ipu_init_channel_buffer函数的第三个参数是IPU_OUTPUT_BUFFER，同样在init_ic函数中，它同样多初始化了一个channelbuffer，第三个参数同样是IPU_OUTPUT_BUFFER。所以是不是channel中必须包含输入输出呢？
这个函数被do_task函数所调用。
36.uninit_rot函数
static void uninit_rot(struct ipu_soc *ipu, struct ipu_task_entry *t)
{
ipu_uninit_channel(ipu, t->set.rot_chan);
}上一个函数的反函数，不分析了。
37.get_irq函数
static int get_irq(struct ipu_task_entry *t)
{
int irq;
ipu_channel_t chan;
if (only_ic(t->set.mode))
chan = t->set.ic_chan;
else
chan = t->set.rot_chan;
switch (chan) {
case MEM_ROT_VF_MEM:
irq = IPU_IRQ_PRP_VF_ROT_OUT_EOF;
break;
case MEM_ROT_PP_MEM:
irq = IPU_IRQ_PP_ROT_OUT_EOF;
break;
case MEM_VDI_PRP_VF_MEM:
case MEM_PRP_VF_MEM:
irq = IPU_IRQ_PRP_VF_OUT_EOF;
break;
case MEM_PP_MEM:
irq = IPU_IRQ_PP_OUT_EOF;
break;
case MEM_VDI_MEM:
irq = IPU_IRQ_VDIC_OUT_EOF;
break;
default:
irq = -EINVAL;
}
return irq;
}这个函数根据ipu_task_entry->set的channel来确定对应channel的中断号。
38.task_irq_handler函数
static irqreturn_t task_irq_handler(int irq, void *dev_id)
{
struct ipu_task_entry *prev_tsk = dev_id;
CHECK_PERF(&prev_tsk->ts_inirq);
complete(&prev_tsk->irq_comp);
dev_dbg(prev_tsk->dev, "[0x%p] no-0x%x in-irq!",
prev_tsk, prev_tsk->task_no);
return IRQ_HANDLED;
}看名字基本可以确定它是一个中断函数的处理函数，搜索源码可以找到：
ret= ipu_request_irq(ipu, irq, task_irq_handler, 0, NULL, t);
39.vdi_split_process函数（这个函数只在do_task_release函数中调用了，先不想分析呢。。）
40.do_task_release函数，do_task函数的反函数，先不分析。。。
41.do_task_vdoa_only函数
static void do_task_vdoa_only(struct ipu_task_entry *t)
{
int ret;
ret = init_tiled_ch_bufs(NULL, t);
CHECK_RETCODE(ret < 0, "do_vdoa_only", STATE_ERR, out, ret);
ret = vdoa_start(t->vdoa_handle, VDOA_DEF_TIMEOUT_MS);
vdoa_stop(t->vdoa_handle);
CHECK_RETCODE(ret < 0, "vdoa_wait4complete, do_vdoa_only",
STATE_VDOA_IRQ_TIMEOUT, out, ret);
t->state = STATE_OK;
out:
return;
}这个函数中调用了init_tiled_ch_bufs函数来初始化channelbuffer，就说明t->input.format只能是IPU_PIX_FMT_TILED_NV12或者IPU_PIX_FMT_TILED_NV12F，是不是VDOA就是用来处理这种输入格式的？
然后调用vdoa_start函数，在里面等待完成量，如果返回的话意味着完成量超时????，调用vdoa_stop函数来关闭vdoa。
42.do_task函数
static void do_task(struct ipu_task_entry *t)
{
int r_size;
int irq;
int ret;
uint32_t busy;
struct ipu_soc *ipu = t->ipu;
CHECK_PERF(&t->ts_dotask);
if (!ipu) {
t->state = STATE_NO_IPU;
return;
}
init_completion(&t->irq_comp); //初始化完成量
dev_dbg(ipu->dev, "[0x%p]Do task no:0x%x: id %d\n", (void *)t,
t->task_no, t->task_id);
dump_task_info(t);
if (t->set.task & IC_PP) {
t->set.ic_chan = MEM_PP_MEM;
dev_dbg(ipu->dev, "[0x%p]ic channel MEM_PP_MEM\n", (void *)t);
} else if (t->set.task & IC_VF) {
t->set.ic_chan = MEM_PRP_VF_MEM;
dev_dbg(ipu->dev, "[0x%p]ic channel MEM_PRP_VF_MEM\n", (void *)t);
} else if (t->set.task & VDI_VF) {
if (t->set.mode & VDOA_BAND_MODE) {
t->set.ic_chan = MEM_VDI_MEM;
if (deinterlace_3_field(t)) {
t->set.vdi_ic_p_chan = MEM_VDI_MEM_P;
t->set.vdi_ic_n_chan = MEM_VDI_MEM_N;
}
dev_dbg(ipu->dev, "[0x%p]ic ch MEM_VDI_MEM\n",
(void *)t);
} else {
t->set.ic_chan = MEM_VDI_PRP_VF_MEM;
if (deinterlace_3_field(t)) {
t->set.vdi_ic_p_chan = MEM_VDI_PRP_VF_MEM_P;
t->set.vdi_ic_n_chan = MEM_VDI_PRP_VF_MEM_N;
}
dev_dbg(ipu->dev,
"[0x%p]ic ch MEM_VDI_PRP_VF_MEM\n", t);
}
} /*根据t->set.task里面的值设置t->set.ic_chan。在t->set.task是VDI_VF的情况下，还要根据t->set.mode来设置t->set.vdi_ic_p_chan和t->set.vdi_ic_n_chan。*/
/*上面从整体来说是设置ICchannel的。*/
if (t->set.task & ROT_PP) {
t->set.rot_chan = MEM_ROT_PP_MEM;
dev_dbg(ipu->dev, "[0x%p]rot channel MEM_ROT_PP_MEM\n", (void *)t);
} else if (t->set.task & ROT_VF) {
t->set.rot_chan = MEM_ROT_VF_MEM;
dev_dbg(ipu->dev, "[0x%p]rot channel MEM_ROT_VF_MEM\n", (void *)t);
} /*设置t->set.rot_chan，从整体上来说是设置ROTchannel。*/
if (t->task_id == IPU_TASK_ID_VF)
busy = ic_vf_pp_is_busy(ipu, true);
else if (t->task_id == IPU_TASK_ID_PP)
busy = ic_vf_pp_is_busy(ipu, false);
else {
dev_err(ipu->dev, "ERR[no:0x%x]ipu task_id:%d invalid!\n",
t->task_no, t->task_id);
return;
}
if (busy) {
dev_err(ipu->dev, "ERR[0x%p-no:0x%x]ipu task_id:%d busy!\n",
(void *)t, t->task_no, t->task_id);
t->state = STATE_IPU_BUSY;
return;
} /*判断这两个通道是否正在占用。*/
irq = get_irq(t);
if (irq < 0) {
t->state = STATE_NO_IRQ;
return;
}
t->irq = irq; /*申请中断，这个get_irq函数是在前面讲过的。申请成功的话将t->irq指向这个irq。*/
/* channel setup */
if (only_ic(t->set.mode)) {
dev_dbg(t->dev, "[0x%p]only ic mode\n", (void *)t);
ret = init_ic(ipu, t);
CHECK_RETCODE(ret < 0, "init_ic only_ic",
t->state, chan_setup, ret);
} else if (only_rot(t->set.mode)) {
dev_dbg(t->dev, "[0x%p]only rot mode\n", (void *)t);
ret = init_rot(ipu, t);
CHECK_RETCODE(ret < 0, "init_rot only_rot",
t->state, chan_setup, ret);
} else if (ic_and_rot(t->set.mode)) {
int rot_idx = (t->task_id == IPU_TASK_ID_VF) ? 0 : 1;
dev_dbg(t->dev, "[0x%p]ic + rot mode\n", (void *)t);
t->set.r_fmt = t->output.format;
if (t->output.rotate >= IPU_ROTATE_90_RIGHT) {
t->set.r_width = t->output.crop.h;
t->set.r_height = t->output.crop.w;
} else {
t->set.r_width = t->output.crop.w;
t->set.r_height = t->output.crop.h;
}
t->set.r_stride = t->set.r_width *
bytes_per_pixel(t->set.r_fmt);
r_size = PAGE_ALIGN(t->set.r_width * t->set.r_height
* fmt_to_bpp(t->set.r_fmt)/8);
if (r_size > ipu->rot_dma[rot_idx].size) {
dev_dbg(t->dev, "[0x%p]realloc rot buffer\n", (void *)t);
if (ipu->rot_dma[rot_idx].vaddr)
dma_free_coherent(t->dev,
ipu->rot_dma[rot_idx].size,
ipu->rot_dma[rot_idx].vaddr,
ipu->rot_dma[rot_idx].paddr);
ipu->rot_dma[rot_idx].size = r_size;
ipu->rot_dma[rot_idx].vaddr = dma_alloc_coherent(t->dev,
r_size,
&ipu->rot_dma[rot_idx].paddr,
GFP_DMA | GFP_KERNEL);
CHECK_RETCODE(ipu->rot_dma[rot_idx].vaddr == NULL,
"ic_and_rot", STATE_SYS_NO_MEM,
chan_setup, -ENOMEM);
}
t->set.r_paddr = ipu->rot_dma[rot_idx].paddr;
dev_dbg(t->dev, "[0x%p]rotation:\n", (void *)t);
dev_dbg(t->dev, "[0x%p]\tformat = 0x%x\n", (void *)t, t->set.r_fmt);
dev_dbg(t->dev, "[0x%p]\twidth = %d\n", (void *)t, t->set.r_width);
dev_dbg(t->dev, "[0x%p]\theight = %d\n", (void *)t, t->set.r_height);
dev_dbg(t->dev, "[0x%p]\tpaddr = 0x%x\n", (void *)t, t->set.r_paddr);
dev_dbg(t->dev, "[0x%p]\trstride = %d\n", (void *)t, t->set.r_stride);
ret = init_ic(ipu, t);
CHECK_RETCODE(ret < 0, "init_ic ic_and_rot",
t->state, chan_setup, ret);
ret = init_rot(ipu, t);
CHECK_RETCODE(ret < 0, "init_rot ic_and_rot",
t->state, chan_setup, ret);
ret = ipu_link_channels(ipu, t->set.ic_chan,
t->set.rot_chan);
CHECK_RETCODE(ret < 0, "ipu_link_ch ic_and_rot",
STATE_LINK_CHAN_FAIL, chan_setup, ret);
} else {
dev_err(t->dev, "ERR [0x%p]do task: should not be here\n", t);
t->state = STATE_ERR;
return;
} /*上面这一段代码就是根据t->set.mode来决定执行哪个mode模式：如果只是ICMODE 模式的话，就调用init_ic函数即可，如果只是ROTMODE的话，就只调用init_rot函数即可。如果是ic_and_rot模式的话，就需要同时调用这两个函数，同时还需要调用ipu_link_channels函数将两个channel链接起来。*/
ret = ipu_request_irq(ipu, irq, task_irq_handler, 0, NULL, t);
CHECK_RETCODE(ret < 0, "ipu_req_irq",
STATE_IRQ_FAIL, chan_setup, ret); /*调用ipu_request_irq函数来为ipu申请中断，中断函数为task_irq_handler。这个ipu_request_irq函数在ipu_common.c中定义。*/
/* enable/start channel */
if (only_ic(t->set.mode)) {
ret = ipu_enable_channel(ipu, t->set.ic_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch only_ic",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
if (deinterlace_3_field(t)) {
ret = ipu_enable_channel(ipu, t->set.vdi_ic_p_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch only_ic_p",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
ret = ipu_enable_channel(ipu, t->set.vdi_ic_n_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch only_ic_n",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
}
ret = ipu_select_buffer(ipu, t->set.ic_chan, IPU_OUTPUT_BUFFER,
0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_ic",
STATE_SEL_BUF_FAIL, chan_buf, ret);
if (t->overlay_en) {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_GRAPH_IN_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_ic_g",
STATE_SEL_BUF_FAIL, chan_buf, ret);
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL) {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_ALPHA_IN_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_ic_a",
STATE_SEL_BUF_FAIL, chan_buf,
ret);
}
}
if (!(t->set.mode & VDOA_BAND_MODE)) {
if (deinterlace_3_field(t))
ipu_select_multi_vdi_buffer(ipu, 0);
else {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_INPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_ic_i",
STATE_SEL_BUF_FAIL, chan_buf, ret);
}
}
} /*使能/开启channel，同样分为3种情况，根据t->set.mode来判断，如果是only_ic模式，（1）就调用ipu_enable_channel函数来使能t->set.ic_chanchannel，然后如果有需要的话同时使能t->set.vdi_ic_p_chanchannel和t->set.vdi_ic_n_chanchannel。（2）调用ipu_select_buffer函数来为t->set.ic_chanchannel选择IPU_OUTPUT_BUFFERbuffer。如果使能ovverlay的话，还需要为t->set.ic_chanchannel选择IPU_GRAPH_IN_BUFFERbuffer；如果启用了alpha通道的话，也需要为t->set.ic_chanchannel选择IPU_ALPHA_IN_BUFFERbuffer。*/
else if (only_rot(t->set.mode)) {
ret = ipu_enable_channel(ipu, t->set.rot_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch only_rot",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
ret = ipu_select_buffer(ipu, t->set.rot_chan,
IPU_OUTPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_rot_o",
STATE_SEL_BUF_FAIL, chan_buf, ret);
ret = ipu_select_buffer(ipu, t->set.rot_chan,
IPU_INPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf only_rot_i",
STATE_SEL_BUF_FAIL, chan_buf, ret);
} /*如果是only_rot模式，调用ipu_enable_channel函数使能t->set.rot_chan通道，还需要为t->set.rot_chanchannel选择对应的buffer，这个channel需要同时选择IPU_OUTPUT_BUFFER和IPU_INPUT_BUFFER两个buffer。*/
else if (ic_and_rot(t->set.mode)) {
ret = ipu_enable_channel(ipu, t->set.rot_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch ic_and_rot-rot",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
ret = ipu_enable_channel(ipu, t->set.ic_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch ic_and_rot-ic",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
if (deinterlace_3_field(t)) {
ret = ipu_enable_channel(ipu, t->set.vdi_ic_p_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch ic_and_rot-p",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
ret = ipu_enable_channel(ipu, t->set.vdi_ic_n_chan);
CHECK_RETCODE(ret < 0, "ipu_enable_ch ic_and_rot-n",
STATE_ENABLE_CHAN_FAIL, chan_en, ret);
}
ret = ipu_select_buffer(ipu, t->set.rot_chan,
IPU_OUTPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf ic_and_rot-rot-o",
STATE_SEL_BUF_FAIL, chan_buf, ret);
if (t->overlay_en) {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_GRAPH_IN_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf ic_and_rot-ic-g",
STATE_SEL_BUF_FAIL, chan_buf, ret);
if (t->overlay.alpha.mode == IPU_ALPHA_MODE_LOCAL) {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_ALPHA_IN_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf icrot-ic-a",
STATE_SEL_BUF_FAIL,
chan_buf, ret);
}
}
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_OUTPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf ic_and_rot-ic-o",
STATE_SEL_BUF_FAIL, chan_buf, ret);
if (deinterlace_3_field(t))
ipu_select_multi_vdi_buffer(ipu, 0);
else {
ret = ipu_select_buffer(ipu, t->set.ic_chan,
IPU_INPUT_BUFFER, 0);
CHECK_RETCODE(ret < 0, "ipu_sel_buf ic_and_rot-ic-i",
STATE_SEL_BUF_FAIL, chan_buf, ret);
}
} /*在ic_and_rot模式下，很显然需要使能t->set.rot_chan和t->set.ic_chan两个channel，同时根据deinterlace_3_field(t)这个函数决定是否使能t->set.vdi_ic_p_chan和t->set.vdi_ic_n_chan这两个channel。之后调用ipu_select_buffer函数为t->set.rot_chanchannel选择IPU_OUTPUT_BUFFERbuffer，同样需要为t->set.ic_chanchannel选择IPU_OUTPUT_BUFFERbuffer，根据deinterlace_3_field(t)函数来决定是否调用ipu_select_multi_vdi_buffer函数。如果使能了channel的话，就需要为这个channel选择buffer。*/
if (need_split(t))
t->state = STATE_IN_PROGRESS; /*如果需要拆分的话，就将t->state置位。*/
if (t->set.mode & VDOA_BAND_MODE) {
ret = vdoa_start(t->vdoa_handle, VDOA_DEF_TIMEOUT_MS);
CHECK_RETCODE(ret < 0, "vdoa_wait4complete, do_vdoa_band",
STATE_VDOA_IRQ_TIMEOUT, chan_rel, ret);
} /*如果是VDOA_BAND_MODE模式的话，就需要调用vdoa_start函数来启用vdoa.*/
CHECK_PERF(&t->ts_waitirq);
ret = wait_for_completion_timeout(&t->irq_comp,
msecs_to_jiffies(t->timeout - DEF_DELAY_MS));
CHECK_PERF(&t->ts_wakeup);
CHECK_RETCODE(ret == 0, "wait_for_comp_timeout",
STATE_IRQ_TIMEOUT, chan_rel, ret);
dev_dbg(t->dev, "[0x%p] no-0x%x ipu irq done!", t, t->task_no); /*等待完成量超时。对完成量不清楚，以后再查查这一块。*/
chan_rel:
chan_buf:
chan_en:
chan_setup:
if (t->set.mode & VDOA_BAND_MODE)
vdoa_stop(t->vdoa_handle);
do_task_release(t, t->state >= STATE_ERR);
return;
}这个do_task函数是一个比较重要的函数，它在get_res_do_task和下一个do_task_vdoa_vdi函数中调用。
43.do_task_vdoa_vdi函数
static void do_task_vdoa_vdi(struct ipu_task_entry *t)
{
int i;
int ret;
u32 stripe_width;
/* FIXME: crop mode not support now */
stripe_width = t->input.width >> 1;
t->input.crop.pos.x = 0;
t->input.crop.pos.y = 0;
t->input.crop.w = stripe_width;
t->input.crop.h = t->input.height;
t->output.crop.w = stripe_width;
t->output.crop.h = t->input.height;
for (i = 0; i < 2; i++) {
t->input.crop.pos.x = t->input.crop.pos.x + i * stripe_width;
t->output.crop.pos.x = t->output.crop.pos.x + i * stripe_width;
/* check input */
ret = set_crop(&t->input.crop, t->input.width, t->input.height,
t->input.format);
if (ret < 0) {
ret = STATE_ERR;
goto done;
} else
update_offset(t->input.format,
t->input.width, t->input.height,
t->input.crop.pos.x,
t->input.crop.pos.y,
&t->set.i_off, &t->set.i_uoff,
&t->set.i_voff, &t->set.istride);
dev_dbg(t->dev, "i_off:0x%x, i_uoff:0x%x, istride:%d.\n",
t->set.i_off, t->set.i_uoff, t->set.istride);
/* check output */
ret = set_crop(&t->output.crop, t->input.width,
t->output.height, t->output.format);
if (ret < 0) {
ret = STATE_ERR;
goto done;
} else
update_offset(t->output.format,
t->output.width, t->output.height,
t->output.crop.pos.x,
t->output.crop.pos.y,
&t->set.o_off, &t->set.o_uoff,
&t->set.o_voff, &t->set.ostride);
dev_dbg(t->dev, "o_off:0x%x, o_uoff:0x%x, ostride:%d.\n",
t->set.o_off, t->set.o_uoff, t->set.ostride);
do_task(t);
}
return;
done:
dev_err(t->dev, "ERR %s set_crop.\n", __func__);
t->state = ret;
return;
}这个函数里面有一条注释：/*FIXME: crop mode not support now */，crop模式在这里不支持，所以这个函数需要重新设置crop里面的参数，为什么不支持？？这个函数中有个for循环，也不太理解。
首先设置inputcrop，调用set_crop函数，然后继续调用update_offset函数来更新偏移量，之后设置outputcrop，是同样的步骤。最后就会调用到上一个里面讲的do_task函数。这个函数只被get_res_do_task调用了。
44.get_res_do_task函数
static void get_res_do_task(struct ipu_task_entry *t)
{
uint32_t found;
uint32_t split_child;
struct mutex *lock;
found = get_vdoa_ipu_res(t);
if (!found) {
dev_err(t->dev, "ERR:[0x%p] no-0x%x can not get res\n",
t, t->task_no);
return;
} else {
if (t->set.task & VDOA_ONLY)
do_task_vdoa_only(t);
else if ((IPU_PIX_FMT_TILED_NV12F == t->input.format) &&
(t->set.mode & VDOA_BAND_MODE) &&
(t->input.crop.w >
soc_max_vdi_in_width(t->ipu)))
do_task_vdoa_vdi(t);
else
do_task(t);
put_vdoa_ipu_res(t, 0);
}
if (t->state != STATE_OK) {
dev_err(t->dev, "ERR:[0x%p] no-0x%x state: %s\n",
t, t->task_no, state_msg[t->state].msg);
}
split_child = need_split(t) && t->parent;
if (split_child) {
lock = &t->parent->split_lock;
mutex_lock(lock);
t->split_done = 1;
mutex_unlock(lock);
wake_up(&t->parent->split_waitq);
}
return;
}这个函数首先调用get_vdoa_ipu_res函数来获取资源，然后根据t->set.task中的task模式决定调用do_task_vdoa_only，do_task_vdoa_vdi和do_task函数中的哪一个。这个函数在ipu_task_thread函数中直接使用。
45.wait_split_task_complete函数
static void wait_split_task_complete(struct ipu_task_entry *parent,
struct ipu_split_task *sp_task, uint32_t size)
{
struct ipu_task_entry *tsk = NULL;
int ret = 0, rc;
int j, idx = -1;
unsigned long flags;
struct mutex *lock = &parent->split_lock;
int k, busy_vf, busy_pp;
struct ipu_soc *ipu;
DECLARE_PERF_VAR;
for (j = 0; j < size; j++) {
rc = wait_event_timeout(
parent->split_waitq,
<span style="color:#FF0000;">sp_task_check_done(sp_task, parent, size, &idx), </span>
msecs_to_jiffies(parent->timeout - DEF_DELAY_MS));
if (!rc) {
dev_err(parent->dev,
"ERR:[0x%p] no-0x%x, split_task timeout,j:%d,"
"size:%d.\n",
parent, parent->task_no, j, size);
ret = -ETIMEDOUT;
goto out;
} else {
if (idx < 0) {
dev_err(parent->dev,
"ERR:[0x%p] no-0x%x, invalid task idx:%d\n",
parent, parent->task_no, idx);
continue;
}
tsk = sp_task[idx].child_task;
mutex_lock(lock);
if (!tsk->split_done || !tsk->ipu)
dev_err(tsk->dev,
"ERR:no-0x%x,split not done:%d/null ipu:0x%p\n",
tsk->task_no, tsk->split_done, tsk->ipu);
tsk->split_done = 0;
mutex_unlock(lock);
dev_dbg(tsk->dev,
"[0x%p] no-0x%x sp_tsk[%d] done,state:%d.\n",
tsk, tsk->task_no, idx, tsk->state);
#ifdef DBG_IPU_PERF
CHECK_PERF(&tsk->ts_rel);
PRINT_TASK_STATISTICS;
#endif
}
}
out:
if (ret == -ETIMEDOUT) {
/* debug */
for (k = 0; k < max_ipu_no; k++) {
ipu = ipu_get_soc(k);
if (IS_ERR(ipu)) {
dev_err(parent->dev, "no:0x%x, null ipu:%d\n",
parent->task_no, k);
} else {
busy_vf = ic_vf_pp_is_busy(ipu, true);
busy_pp = ic_vf_pp_is_busy(ipu, false);
dev_err(parent->dev,
"ERR:ipu[%d] busy_vf:%d, busy_pp:%d.\n",
k, busy_vf, busy_pp);
}
}
for (k = 0; k < size; k++) {
tsk = sp_task[k].child_task;
if (!tsk)
continue;
dev_err(parent->dev,
"ERR: sp_task[%d][0x%p] no-0x%x done:%d,"
"state:%s,on_list:%d, ipu:0x%p,timeout!\n",
k, tsk, tsk->task_no, tsk->split_done,
state_msg[tsk->state].msg, tsk->task_in_list,
tsk->ipu);
}
}
for (j = 0; j < size; j++) {
tsk = sp_task[j].child_task;
if (!tsk)
continue;
spin_lock_irqsave(&ipu_task_list_lock, flags);
if (tsk->task_in_list) {
list_del(&tsk->node);
tsk->task_in_list = 0;
dev_dbg(tsk->dev,
"[0x%p] no-0x%x,id:%d sp_tsk timeout list_del.\n",
tsk, tsk->task_no, tsk->task_id);
}
spin_unlock_irqrestore(&ipu_task_list_lock, flags);
if (!tsk->ipu)
continue;
if (tsk->state != STATE_OK) {
dev_err(tsk->dev,
"ERR:[0x%p] no-0x%x,id:%d, sp_tsk state: %s\n",
tsk, tsk->task_no, tsk->task_id,
state_msg[tsk->state].msg);
}
kref_put(&tsk->refcount, task_mem_free);
}
kfree(parent->vditmpbuf[0]);
kfree(parent->vditmpbuf[1]);
if (ret < 0)
parent->state = STATE_TIMEOUT;
else
parent->state = STATE_OK;
return;
}这个函数的核心就是sp_task_check_done函数，我在里面标红了，它根据数组中的子task，检验每个子task是否执行完毕。
46.find_task函数
static inline int find_task(struct ipu_task_entry **t, int thread_id)
{
int found;
unsigned long flags;
struct ipu_task_entry *tsk;
struct list_head *task_list = &ipu_task_list; /*这个ipu_task_list是一个全局链表，在ipu_queue_task函数中调用list_add_tail(&tsk->node,&ipu_task_list)往这个链表中添加成员。*/
*t = NULL;
spin_lock_irqsave(&ipu_task_list_lock, flags);
found = !list_empty(task_list);
if (found) {
tsk = list_first_entry(task_list, struct ipu_task_entry, node);
if (tsk->task_in_list) {
list_del(&tsk->node);
tsk->task_in_list = 0;
*t = tsk;
kref_get(&tsk->refcount);
dev_dbg(tsk->dev,
"thread_id:%d,[0x%p] task_no:0x%x,mode:0x%x list_del\n",
thread_id, tsk, tsk->task_no, tsk->set.mode);
} else
dev_err(tsk->dev,
"thread_id:%d,task_no:0x%x,mode:0x%x not on list_del\n",
thread_id, tsk->task_no, tsk->set.mode);
}
spin_unlock_irqrestore(&ipu_task_list_lock, flags);
return found;
} 可以看出来，这个函数就是从ipu_task_list这个全局链表中取出第一项，如果不为空的话，就返回找到的这一项，将找到的这一项保存在函数的第一个参数t中。
47.ipu_task_thread函数
static int ipu_task_thread(void *argv)
{
struct ipu_task_entry *tsk;
struct ipu_task_entry *sp_tsk0;
struct ipu_split_task sp_task[4];
/* priority lower than irq_thread */
const struct sched_param param = {
.sched_priority = MAX_USER_RT_PRIO/2 - 1,
};
int ret;
int curr_thread_id;
uint32_t size;
unsigned long flags;
unsigned int cpu;
struct cpumask cpu_mask;
struct ipu_thread_data *data = (struct ipu_thread_data *)argv;
thread_id++;
curr_thread_id = thread_id;
sched_setscheduler(current, SCHED_FIFO, ¶m); /*这个函数的用法可以查看http://blog.csdn.net/allwtg/article/details/5254306里面的解释。它的目的是将current这个进程的policy设置成SCHED_FIFO，优先级设置成param->sched_priority。*/
if (!data->is_vdoa) {
cpu = cpumask_first(cpu_online_mask);
cpumask_set_cpu(cpu, &cpu_mask);
ret = sched_setaffinity(data->ipu->thread[data->id]->pid,
&cpu_mask);
if (ret < 0) {
pr_err("%s: sched_setaffinity fail:%d.\n", __func__, ret);
}
pr_debug("%s: sched_setaffinity cpu:%d.\n", __func__, cpu);
}
while (!kthread_should_stop()) {
int split_fail = 0;
int split_parent;
int split_child;
wait_event_interruptible(thread_waitq, find_task(&tsk, curr_thread_id)); /*如果找到当前的task的话，就让thread_waitq这个等待队列进入等待状态，会在本函数和ipu_queue_task函数中唤醒它的。*/
if (!tsk) {
pr_err("thread:%d can not find task.\n",
curr_thread_id);
continue;
}
/* note: other threads run split child task */
split_parent = need_split(tsk) && !tsk->parent;
split_child = need_split(tsk) && tsk->parent; /*找到split_parent和split_child的方法很简单，它就是根据tsk中set.split_mode和task_no来决定task是否需要拆分。如果需要拆分的话，同时这个ipu_task_entry结构体中的parent没有置位的话，就说明它本身就是parent。*/
if (split_parent) {
if ((tsk->set.split_mode == RL_SPLIT) ||
(tsk->set.split_mode == UD_SPLIT))
size = 2;
else
size = 4;
ret = queue_split_task(tsk, sp_task, size); /*设置queue_split_task函数中的size值，然后根据size的值调用queue_split_task函数来创建拆分的子task，并将它们都保存在sp_task数组中。*/
if (ret < 0) {
split_fail = 1;
} else {
struct list_head *pos;
spin_lock_irqsave(&ipu_task_list_lock, flags);
sp_tsk0 = list_first_entry(&tsk->split_list,
struct ipu_task_entry, node);
list_del(&sp_tsk0->node);
list_for_each(pos, &tsk->split_list) {
struct ipu_task_entry *tmp;
tmp = list_entry(pos,
struct ipu_task_entry, node);
tmp->task_in_list = 1;
dev_dbg(tmp->dev,
"[0x%p] no-0x%x,id:%d sp_tsk "
"add_to_list.\n", tmp,
tmp->task_no, tmp->task_id);
}
/* add to global list */
list_splice(&tsk->split_list, &ipu_task_list);
spin_unlock_irqrestore(&ipu_task_list_lock,
flags);
/* let the parent thread do the first sp_task */
/* FIXME: ensure the correct sequence for split
4size: 5/6->9/a*/
if (!sp_tsk0)
dev_err(tsk->dev,
"ERR: no-0x%x,can not get split_tsk0\n",
tsk->task_no);
wake_up_interruptible(&thread_waitq);
get_res_do_task(sp_tsk0);
dev_dbg(sp_tsk0->dev,
"thread:%d complete tsk no:0x%x.\n",
curr_thread_id, sp_tsk0->task_no);
ret = atomic_read(&req_cnt);
if (ret > 0) {
wake_up(&res_waitq);
dev_dbg(sp_tsk0->dev,
"sp_tsk0 sche thread:%d no:0x%x,"
"req_cnt:%d\n", curr_thread_id,
sp_tsk0->task_no, ret);
/* For other threads to get_res */
schedule();
}
}
} else
get_res_do_task(tsk); /*这一块的逻辑比较乱，但是整体可以理解的是无论哪种情况，最终都会调用到get_res_do_task函数。应该是如果创建了子task的话，每个子task都会执行一个get_res_do_task函数。看下面的注释。*/
/* wait for all 4 sp_task finished here or timeout
and then release all resources */
if (split_parent && !split_fail)
wait_split_task_complete(tsk, sp_task, size); /*等待子task都执行完。*/
if (!split_child) {
atomic_inc(&tsk->done);
wake_up(&tsk->task_waitq);
}
dev_dbg(tsk->dev, "thread:%d complete tsk no:0x%x-[0x%p].\n",
curr_thread_id, tsk->task_no, tsk);
ret = atomic_read(&req_cnt);
if (ret > 0) {
wake_up(&res_waitq);
dev_dbg(tsk->dev, "sche thread:%d no:0x%x,req_cnt:%d\n",
curr_thread_id, tsk->task_no, ret);
/* note: give cpu to other threads to get_res */
schedule();
}
kref_put(&tsk->refcount, task_mem_free);
48.ipu_check_task函数
int ipu_check_task(struct ipu_task *task)
{
struct ipu_task_entry *tsk;
int ret = 0;
tsk = create_task_entry(task);
if (IS_ERR(tsk))
return PTR_ERR(tsk);
ret = check_task(tsk);
task->input = tsk->input;
task->output = tsk->output;
task->overlay = tsk->overlay;
dump_task_info(tsk);
kref_put(&tsk->refcount, task_mem_free);
if (ret != 0)
pr_debug("%s ret:%d.\n", __func__, ret);
return ret;
}
EXPORT_SYMBOL_GPL(ipu_check_task);这个函数里面没做什么内容，只是调用create_task_entry创建了一个ipu_task_entry实体，然后调用check_task函数来检验这个结构体里面的设置是否正确。这个ipu_check_task函数在mxc_ipu_ioctl的IPU_CHECK_TASK中调用。
49.ipu_queue_task函数
int ipu_queue_task(struct ipu_task *task)
{
struct ipu_task_entry *tsk;
unsigned long flags;
int ret;
u32 tmp_task_no;
DECLARE_PERF_VAR;
tsk = create_task_entry(task);
if (IS_ERR(tsk))
return PTR_ERR(tsk);
CHECK_PERF(&tsk->ts_queue);
ret = prepare_task(tsk);
if (ret < 0)
goto done; /*首先调用create_task_entry函数来创建一个ipu_task_entry实体，然后调用prepare_task函数来继续设置这个结构体中的某些位。*/
if (need_split(tsk)) {
CHECK_PERF(&tsk->ts_dotask);
CHECK_PERF(&tsk->ts_waitirq);
CHECK_PERF(&tsk->ts_inirq);
CHECK_PERF(&tsk->ts_wakeup);
}
/* task_no last four bits for split task type*/
tmp_task_no = atomic_inc_return(&frame_no);
tsk->task_no = tmp_task_no << 4;
init_waitqueue_head(&tsk->task_waitq);
spin_lock_irqsave(&ipu_task_list_lock, flags);
list_add_tail(&tsk->node, &ipu_task_list);
tsk->task_in_list = 1;
dev_dbg(tsk->dev, "[0x%p,no-0x%x] list_add_tail\n", tsk, tsk->task_no);
spin_unlock_irqrestore(&ipu_task_list_lock, flags);
wake_up_interruptible(&thread_waitq);
ret = wait_event_timeout(tsk->task_waitq, atomic_read(&tsk->done),
msecs_to_jiffies(tsk->timeout));
if (0 == ret) {
/* note: the timeout should larger than the internal timeout!*/
ret = -ETIMEDOUT;
dev_err(tsk->dev, "ERR: [0x%p] no-0x%x, timeout:%dms!\n",
tsk, tsk->task_no, tsk->timeout);
} else {
if (STATE_OK != tsk->state) {
dev_err(tsk->dev, "ERR: [0x%p] no-0x%x,state %d: %s\n",
tsk, tsk->task_no, tsk->state,
state_msg[tsk->state].msg);
ret = -ECANCELED;
} else
ret = 0;
}
spin_lock_irqsave(&ipu_task_list_lock, flags);
if (tsk->task_in_list) {
list_del(&tsk->node);
tsk->task_in_list = 0;
dev_dbg(tsk->dev, "[0x%p] no:0x%x list_del\n",
tsk, tsk->task_no);
}
spin_unlock_irqrestore(&ipu_task_list_lock, flags);
#ifdef DBG_IPU_PERF
CHECK_PERF(&tsk->ts_rel);
PRINT_TASK_STATISTICS;
if (ts_frame_avg == 0)
ts_frame_avg = ts_frame.tv_nsec / NSEC_PER_USEC +
ts_frame.tv_sec * USEC_PER_SEC;
else
ts_frame_avg = (ts_frame_avg + ts_frame.tv_nsec / NSEC_PER_USEC
+ ts_frame.tv_sec * USEC_PER_SEC)/2;
if (timespec_compare(&ts_frame, &ts_frame_max) > 0)
ts_frame_max = ts_frame;
atomic_inc(&frame_cnt);
if ((atomic_read(&frame_cnt) % 1000) == 0)
pr_debug("ipu_dev: max frame time:%ldus, avg frame time:%dus,"
"frame_cnt:%d\n", ts_frame_max.tv_nsec / NSEC_PER_USEC
+ ts_frame_max.tv_sec * USEC_PER_SEC,
ts_frame_avg, atomic_read(&frame_cnt));
#endif
done:
if (ret < 0)
dev_err(tsk->dev, "ERR: no-0x%x,ipu_queue_task err:%d\n",
tsk->task_no, ret);
kref_put(&tsk->refcount, task_mem_free);
return ret;
}
EXPORT_SYMBOL_GPL(ipu_queue_task);对于这个函数后面的部分，个人感觉重要的就是wake_up_interruptible(&thread_waitq)函数，它唤醒在ipu_task_thread函数中睡眠的thread_waitq队列，让这个函数继续往下执行，就能执行到get_res_do_task函数来处理task了。所以在应用程序中，首先调用IPU_CHECK_TASKioctl宏以后还需要调用IPU_QUEUE_TASKtask宏，这样程序才能往下面执行下去。
后面的几个函数就是围绕file_operations结构体来构建的，以及register_ipu_device和unregister_ipu_device两个函数，这些都在（一）中分析过了，在这就不再分析。至此，这个文件分析完毕。
4319
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
