本文深入剖析了IPU中Channel的定义与初始化过程，详细介绍了不同Channel如何与IPU内部模块如SMFC、IC等关联，并针对特定Channel的初始化函数进行了逐行分析。
在看这个函数之前，先对ipu内部的channel有所了解，先来看看ipu内部的flow的定义：
对于每个flow，代表数据从摄像头采集到显示（或者保存在内存中）的过程中的一个分步骤，每个flow都对应一个或几个channel，而每个channel的数据流通过程中，是通过DMA传输的，所以每个channel里面又包含一个或几个dma_channel。在这不太好理解，看看手册中的介绍（captureflow）：
其中上面和程序中所说的channel对应图中的Taskschain，对于这个channel的理解需要根据ipu内部架构图来理解，如下所示：
以上面CSI0-->SMFC-->MEM这个channel为例，它代表数据从CSI经过SMFC到达内存MEM中，因为数据是从CSI中获得的，所以physicalDMA channel中的videoinput为空，而数据从这个channel输出的话，就需要通过DMAchannel了，从图上可以看出来，physicalDMA channel中的videooutput可以为IDMAC_CH_0~ IDMAC_CH_3。
同样对于captureflow，还可以通过CSI0-->SMFC--->MEM和CSI0-->VDIC-->MEM这两种方式将摄像头采集到的数据存放到内存中。
再来看手册中的Processingflows的图：
以MEM-->IC-->MEM这个channel为例，根据IPU内部框架图可以看到，从内存中取出数据，经过IC处理以后再放入内存中，那么取出数据的时候，就使用到DMAchannel了，从这个图中可以看出来，使用的是IDMAC_CH12，再次放入内存中的时候就使用到IDMAC_CH20。
对于其他channel就暂时不一一分析了。再来看看程序中是怎样定义channel的。
内核中使用ipu_channel_t枚举来表示一个channel：
typedef enum {
CHAN_NONE = -1,
MEM_ROT_ENC_MEM = _MAKE_CHAN(1, 45, NO_DMA, NO_DMA, 48),
MEM_ROT_VF_MEM = _MAKE_CHAN(2, 46, NO_DMA, NO_DMA, 49),
MEM_ROT_PP_MEM = _MAKE_CHAN(3, 47, NO_DMA, NO_DMA, 50),
MEM_PRP_ENC_MEM = _MAKE_CHAN(4, 12, 14, 17, 20),
MEM_PRP_VF_MEM = _MAKE_CHAN(5, 12, 14, 17, 21),
MEM_PP_MEM = _MAKE_CHAN(6, 11, 15, 18, 22),
MEM_DC_SYNC = _MAKE_CHAN(7, 28, NO_DMA, NO_DMA, NO_DMA),
MEM_DC_ASYNC = _MAKE_CHAN(8, 41, NO_DMA, NO_DMA, NO_DMA),
MEM_BG_SYNC = _MAKE_CHAN(9, 23, NO_DMA, 51, NO_DMA),
MEM_FG_SYNC = _MAKE_CHAN(10, 27, NO_DMA, 31, NO_DMA),
MEM_BG_ASYNC0 = _MAKE_CHAN(11, 24, NO_DMA, 52, NO_DMA),
MEM_FG_ASYNC0 = _MAKE_CHAN(12, 29, NO_DMA, 33, NO_DMA),
MEM_BG_ASYNC1 = _MAKE_ALT_CHAN(MEM_BG_ASYNC0),
MEM_FG_ASYNC1 = _MAKE_ALT_CHAN(MEM_FG_ASYNC0),
DIRECT_ASYNC0 = _MAKE_CHAN(13, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
DIRECT_ASYNC1 = _MAKE_CHAN(14, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
CSI_MEM0 = _MAKE_CHAN(15, NO_DMA, NO_DMA, NO_DMA, 0),
CSI_MEM1 = _MAKE_CHAN(16, NO_DMA, NO_DMA, NO_DMA, 1),
CSI_MEM2 = _MAKE_CHAN(17, NO_DMA, NO_DMA, NO_DMA, 2),
CSI_MEM3 = _MAKE_CHAN(18, NO_DMA, NO_DMA, NO_DMA, 3),
CSI_MEM = CSI_MEM0,
CSI_PRP_ENC_MEM = _MAKE_CHAN(19, NO_DMA, NO_DMA, NO_DMA, 20),
CSI_PRP_VF_MEM = _MAKE_CHAN(20, NO_DMA, NO_DMA, NO_DMA, 21),
/* for vdi mem->vdi->ic->mem , add graphics plane and alpha*/
MEM_VDI_PRP_VF_MEM_P = _MAKE_CHAN(21, 8, 14, 17, 21),
MEM_VDI_PRP_VF_MEM = _MAKE_CHAN(22, 9, 14, 17, 21),
MEM_VDI_PRP_VF_MEM_N = _MAKE_CHAN(23, 10, 14, 17, 21),
/* for vdi mem->vdi->mem */
MEM_VDI_MEM_P = _MAKE_CHAN(24, 8, NO_DMA, NO_DMA, 5),
MEM_VDI_MEM = _MAKE_CHAN(25, 9, NO_DMA, NO_DMA, 5),
MEM_VDI_MEM_N = _MAKE_CHAN(26, 10, NO_DMA, NO_DMA, 5),
/* fake channel for vdoa to link with IPU */
MEM_VDOA_MEM = _MAKE_CHAN(27, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
MEM_PP_ADC = CHAN_NONE,
ADC_SYS2 = CHAN_NONE,
} ipu_channel_t;#define _MAKE_CHAN(num, v_in, g_in, a_in, out) \
((num << 24) | (v_in << 18) | (g_in << 12) | (a_in << 6) | out)这个枚举就包含了所有的channel，如果对于上面讲解的过程理解的话，很容易根据channel的过程在这个枚举中找到对应的channel名字。同时可以看到在channel通过_MAKE_CHAN宏的构造过程中，每个channel里面都包含了输入输出dmachannel号。
分析完对channel的理解过程以后，再来看看具体的函数实现：
ipu_init_channel函数
int32_t ipu_init_channel(struct ipu_soc *ipu, ipu_channel_t channel,
ipu_channel_params_t *params) /*这个函数有3个参数，第一个参数ipu代表正在使用的ipu。第二个参数是想要初始化的channel，它其实就是一个数字，可以理解为ID，第三个参数params是想要将这个channel初始化成什么样子，它里面包含channel的一些信息，会根据params参数来初始化这个channel。关于这个结构体的详细讲解可以看《ipu_channel_params_t结构体详解》*/
{
int ret = 0;
bool bad_pixfmt;
uint32_t ipu_conf, reg, in_g_pixel_fmt, sec_dma;
dev_dbg(ipu->dev, "init channel = %d\n", IPU_CHAN_ID(channel));
ret = pm_runtime_get_sync(ipu->dev);
if (ret < 0) {
dev_err(ipu->dev, "ch = %d, pm_runtime_get failed:%d!\n",
IPU_CHAN_ID(channel), ret);
dump_stack();
return ret;
}
/*
* Here, ret could be 1 if the device's runtime PM status was
* already 'active', so clear it to be 0.
*/ /*看注释，可以看出来，上面一个函数如果执行成功的话，它的返回值是1，所以在下面需要将这个ret清零。跟踪源码，确实是这样的。*/
ret = 0;
_ipu_get(ipu);
mutex_lock(&ipu->mutex_lock);
/* Re-enable error interrupts every time a channel is initialized */
ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(5));
ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(6));
ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(9));
ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(10)); /*在初始化每一个channel的时候都需要重新使能错误中断。*/
if (ipu->channel_init_mask & (1L << IPU_CHAN_ID(channel))) {
dev_warn(ipu->dev, "Warning: channel already initialized %d\n",
IPU_CHAN_ID(channel));
} /*这个ipu_soc结构体里面的channel_init_mask项是uint32_t类型的，每个channel对应这个数字里面的某一位，如果这个channel进行过初始化操作的话，就将它的那一位置1.通过这个来判断其中的某一个channel是否进行过初始化。所以在这个初始化函数中肯定有将它置位的操作，我们搜索源码可以发现，在这个函数的后面确实有这样的操作。先在这粘贴一下：
ipu->channel_init_mask|= 1L << IPU_CHAN_ID(channel);
*/
ipu_conf = ipu_cm_read(ipu, IPU_CONF); /*下面的switch判断语句就是根据channel的值来初始化不同的channel，所以这么多case就包括了所有的channel。*/
switch (channel) {
case CSI_MEM0:
case CSI_MEM1:
case CSI_MEM2:
case CSI_MEM3:
if (params->csi_mem.csi > 1) { //csi有2个，取值为0和1.
ret = -EINVAL;
goto err;
}
if (params->csi_mem.interlaced)
ipu->chan_is_interlaced[channel_2_dma(channel,
IPU_OUTPUT_BUFFER)] = true;
else
ipu->chan_is_interlaced[channel_2_dma(channel,
IPU_OUTPUT_BUFFER)] = false; /*ipu->chan_is_interlaced是一个bool型的数组，根据params里面的csi_mem.interlaced参数，来设置ipu->chan_is_interlaced数组的某一项。怎么确定是数组的第几项？根据channel的值通过channel_2_dma函数为它在数组中挑选一个位置，然后将这个位置设置为true或false。*/
ipu->smfc_use_count++; //增加smfc使用计数，这几个channel都会使用到smfc。
ipu->csi_channel[params->csi_mem.csi] = channel;/*根据params->csi_mem.csi来确定是ipu->csi_channel数组的第几项，然后将channel赋给它。这个ipu->csi_channel数组包含两项，意思就是每个ipu有两个csi接口，每个接口选择哪个channel，都在这里进行保存。*/
/*SMFC setting*/
if (params->csi_mem.mipi_en) {
ipu_conf |= (1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_mem.csi));
_ipu_smfc_init(ipu, channel, params->csi_mem.mipi_vc,
params->csi_mem.csi);
_ipu_csi_set_mipi_di(ipu, params->csi_mem.mipi_vc,
params->csi_mem.mipi_id, params->csi_mem.csi);
} else {
ipu_conf &= ~(1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_mem.csi));
_ipu_smfc_init(ipu, channel, 0, params->csi_mem.csi);
} /*params中csi_mem.mipi_en是个bool类型的值，如果它为1的话，表示使用的是mipi引脚。
下面来看看ipu_conf寄存器：
这里设置的是ipu_conf寄存器的28或者29位，看看这两位的介绍：
这两位的含义是选择CSI的数据来源，我们知道，CSI接口可以接并行接口或者MIPI接口，驱动会根据mipi_en的值来选择将这两位的数据来源设置为并口或者MIPI接口。如果是MIPI接口的话，需要通过_ipu_csi_set_mipi_di函数来设置MIPI相关的寄存器。
同时，不论是哪一种接口，都需要使用SMFC，就需要通过_ipu_smfc_init函数来初始化smfc的SMFC_MAP寄存器，在这个_ipu_smfc_init函数中根据不同的case选择不同的SMFC_MAP_CH；然后再调用_ipu_csi_set_mipi_di函数来初始化CSI_MIPI_DI寄存器。这个寄存器是mipidata identifier的意思。
*/
/*CSI data (include compander) dest*/
_ipu_csi_init(ipu, channel, params->csi_mem.csi);
break; /*最后通过_ipu_csi_init函数初始化csi。*/
/*上面的channel流程就是下图这种模式：数据从CSI中通过SMFC直接到达IDMAC，然后通过IDMAC来进行数据的存放等操作。
*/
case CSI_PRP_ENC_MEM:
if (params->csi_prp_enc_mem.csi > 1) {
ret = -EINVAL;
goto err;
}
if ((ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) ||
(ipu->using_ic_dirct_ch == MEM_VDI_MEM)) {
ret = -EINVAL;
goto err;
}
ipu->using_ic_dirct_ch = CSI_PRP_ENC_MEM; /*这个ipu->using_ic_dirct_ch是个ipu_channel_t类型的变量，usingic direct channel的意思，只能使用ICchannel而不能使用VDIchannel，所以是MEM_VDI_PRP_VF_MEM和MEM_VDI_MEM的话就会报错。最后再把这一位置位成CSI_PRP_ENC_MEM。*/
ipu->ic_use_count++; //增加ic的引用计数。
ipu->csi_channel[params->csi_prp_enc_mem.csi] = channel; /*这个ipu_soc结构体中有一项ipu_channel_tcsi_channel[2];因为每个ipu有两个csi，所以这个数组里面保存的是每个csi选用的channel通道。在每一个需要用到csi接口的channel中都需要设置这一项，可以看到在这个switch中前几个用到csi的case，里面都设置了这一项。*/
/*同时在params这个参数中，它是ipu_channel_params_t类型的联合，其中包含的两个关于csi的结构体csi_mem和csi_prp_enc_mem，这两个结构体里面都含有一个uint32_tcsi，就是通过它来确定想要使用的是哪一个csi设备。 */
if (params->csi_prp_enc_mem.mipi_en) {
ipu_conf |= (1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_prp_enc_mem.csi));
_ipu_csi_set_mipi_di(ipu,
params->csi_prp_enc_mem.mipi_vc,
params->csi_prp_enc_mem.mipi_id,
params->csi_prp_enc_mem.csi);
} else
ipu_conf &= ~(1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_prp_enc_mem.csi)); /*这个channel没有用到smfc，所以不用初始化它，其他跟上面那个channel一样。设置IPU_CONF寄存器中的28,29位。如果是MIPI接口的话，还需要通过_ipu_csi_set_mipi_di函数来初始化MIPI相关的寄存器。*/
/*CSI0/1 feed into IC*/
ipu_conf &= ~IPU_CONF_IC_INPUT;
if (params->csi_prp_enc_mem.csi)
ipu_conf |= IPU_CONF_CSI_SEL;
else
ipu_conf &= ~IPU_CONF_CSI_SEL; /*设置ipu_conf中的IPU_CONF_IC_INPUT位和CSI_SEL位。这两位的含义如下：
在初始化这个channel的时候，我们应该首先想到这个channel使用到了IPU内部的哪些模块，在上面一个channel中，使用到了CSI和SMFC这两个模块，所以需要设置ipu_conf寄存器中的28,29数据来源位，选择数据是从并口来的还是从MIPI接口来的，然后分别初始化CSI和SMFC即可。
对于本次这个channel，CSI-->IC(prpenc)-->MEM，同样的思想，首先想想这个channel使用了哪几个模块，使用了CSI和IC模块，然后同样设置ipu_conf寄存器中的28,29数据来源位，然后就是设置30和31位了，30位设置IC的输入数据是从哪里来的，从IPU内部框架中可以看出来，输入IC的数据只能是VDI和CSI，所以这里设置30位为0。但是CSI的话还有两个呢，这就需要设置31位来确定是哪一个CSI设备了。
*/
/*PRP skip buffer in memory, only valid when RWS_EN is true*/
reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1);
ipu_cm_write(ipu, reg & ~FS_ENC_IN_VALID, IPU_FS_PROC_FLOW1); /*将IPU_FS_PROC_FLOW1寄存器里面的FS_ENC_IN_VALID位清零。
这里设置的就是IPU_FS_PROC_FLOW1寄存器的30位，这一位的含义如上所示，它表示是否应该跳过内存中的buffer。这一位是根据RWS_EN来选择的。那么RWS_EN又是什么？在IC_CONF寄存器中找到了它，如下所示：
其中RWS是rawsensor的意思，一般sensor的输出数据可以为YUV，JPEG，RGB，RAW几种格式，其中这个RAW格式是未经处理、也未经压缩的格式，记录了数码相机传感器的原始信息，可以把RAW概念化为“原始图像编码数据”或更形象的称为“数字底片”。所以RWS_EN表示摄像头输出的数据是否是原始的RAW数据。
当RWS_EN为0时，数据直接从CSI输入到IC中，所以IPU_FS_PROC_FLOW1这个寄存器就需要设置跳过从内存中到达IC的数据，将IPU_FS_PROC_FLOW1寄存器的ENC_IN_VALID位清零。
*/
/*CSI data (include compander) dest*/
_ipu_csi_init(ipu, channel, params->csi_prp_enc_mem.csi);
_ipu_ic_init_prpenc(ipu, params, true);
break; /*最后通过_ipu_csi_init函数初始化csi，同时通过_ipu_ic_init_prpenc函数预处理编码，这个函数在ipu_ic.c中。*/
/*至此，这个CSI_PRP_ENC_MEMchannel简单分析完毕，它的流程如下图所示：
*/
case CSI_PRP_VF_MEM:
if (params->csi_prp_vf_mem.csi > 1) {
ret = -EINVAL;
goto err;
}
if ((ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) ||
(ipu->using_ic_dirct_ch == MEM_VDI_MEM)) {
ret = -EINVAL;
goto err;
}
ipu->using_ic_dirct_ch = CSI_PRP_VF_MEM; /*与上面那个CSI_PRP_ENC_MEMchannel一样，这个ipu->using_ic_dirct_ch只能置位成当前这个CSI_PRP_VF_MEMchannel。*/
ipu->ic_use_count++; //增加ic的引用计数。
ipu->csi_channel[params->csi_prp_vf_mem.csi] = channel;
if (params->csi_prp_vf_mem.mipi_en) {
ipu_conf |= (1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_prp_vf_mem.csi));
_ipu_csi_set_mipi_di(ipu,
params->csi_prp_vf_mem.mipi_vc,
params->csi_prp_vf_mem.mipi_id,
params->csi_prp_vf_mem.csi);
} else
ipu_conf &= ~(1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET +
params->csi_prp_vf_mem.csi));
/*CSI0/1 feed into IC*/
ipu_conf &= ~IPU_CONF_IC_INPUT;
if (params->csi_prp_vf_mem.csi)
ipu_conf |= IPU_CONF_CSI_SEL;
else
ipu_conf &= ~IPU_CONF_CSI_SEL;
/*PRP skip buffer in memory, only valid when RWS_EN is true*/
reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1);
ipu_cm_write(ipu, reg & ~FS_VF_IN_VALID, IPU_FS_PROC_FLOW1); /*与上一个函数不同的是，设置的IPU_FS_PROC_FLOW1寄存器的VF_IN_VALID位，原理是相同的。*/
/*CSI data (include compander) dest*/
_ipu_csi_init(ipu, channel, params->csi_prp_vf_mem.csi);
_ipu_ic_init_prpvf(ipu, params, true);
break; /*除了最后一个函数，其他都与上一个case一样，最后一个函数_ipu_ic_init_prpvf同样在ipu_ic.c中。*/
/*这个CSI_PRP_VF_MEMchannel的流程如下所示：
*/
case MEM_PRP_VF_MEM:
if (params->mem_prp_vf_mem.graphics_combine_en) {
sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER);
in_g_pixel_fmt = params->mem_prp_vf_mem.in_g_pixel_fmt;
bad_pixfmt =
_ipu_ch_param_bad_alpha_pos(in_g_pixel_fmt);
if (params->mem_prp_vf_mem.alpha_chan_en) {
if (bad_pixfmt) {
dev_err(ipu->dev, "bad pixel format "
"for graphics plane from "
"ch%d\n", sec_dma);
ret = -EINVAL;
goto err;
}
ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = true;
}
ipu->sec_chan_en[IPU_CHAN_ID(channel)] = true;
} /*bad_pixfmt的意思可以在查看_ipu_ch_param_bad_alpha_pos函数的时候大致了解，在IPUv3IDMAC中对于32bpp的格式有个bug，所以对于32bpp的都返回true，对于其他返回false。*/
/*下面这个涉及到alpha通道的一些知识，
《RGBA》里面有简单介绍。*/
/*上面的代码，会根据ipu_channel_params_t里面的mem_prp_vf_mem这一项的graphics_combine_en来决定是否使能secondchannel，根据mem_prp_vf_mem这一项的alpha_chan_en来决定是否使能thirdchannel。如果使能的话，就会设置ipu_soc中的sec_chan_en[]和thrd_chan_en[]这两项，根据channelID号来置位。*/
reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1);
ipu_cm_write(ipu, reg | FS_VF_IN_VALID, IPU_FS_PROC_FLOW1);
_ipu_ic_init_prpvf(ipu, params, false);
ipu->ic_use_count++;
break; /*其他函数大致都相似，就是细节不太相同，比如将IPU_FS_PROC_FLOW1寄存器的FS_VF_IN_VALID位设置为1；_ipu_ic_init_prpvf函数的第三个参数是false等等，_ipu_ic_init_prpvf函数的第三个参数是bool类型的变量，true代表IC的数据来源是CSI，false代表IC的数据来源不是CSI。*/
/*注意这个函数中设置了ipu_soc结构体中的sec_chan_en和thrd_chan_en，是两个bool型的数组，从名字上来看就是secondchannel enable和thirdchannelenable的意思，我认为MEM_PRP_VF_MEM这个channel是可以和其他某些channel一起启用的（在手册的CM模块对于IPUmainflows进行了详细的讲解，在后面具体分析）。根据params参数中mem_prp_vf_mem.graphics_combine_en置位的话，就会启用第二个channel，如果params参数中mem_prp_vf_mem.alpha_chan_en继续置位的话，就继续启用第三个channel。将启用了几个channel这些信息都保存在ipu_soc结构体中。*/
case MEM_VDI_PRP_VF_MEM:
if ((ipu->using_ic_dirct_ch == CSI_PRP_VF_MEM) ||
(ipu->using_ic_dirct_ch == MEM_VDI_MEM) ||
(ipu->using_ic_dirct_ch == CSI_PRP_ENC_MEM)) {
ret = -EINVAL;
goto err;
}
ipu->using_ic_dirct_ch = MEM_VDI_PRP_VF_MEM;
ipu->ic_use_count++;
ipu->vdi_use_count++;
reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1);
reg &= ~FS_VDI_SRC_SEL_MASK;
ipu_cm_write(ipu, reg , IPU_FS_PROC_FLOW1);
if (params->mem_prp_vf_mem.graphics_combine_en)
ipu->sec_chan_en[IPU_CHAN_ID(channel)] = true;
_ipu_ic_init_prpvf(ipu, params, false);
_ipu_vdi_init(ipu, channel, params);
break; /*大部分设置都是相似的，在这个channel中使用到了VDIC，所以需要设置IPU_FS_PROC_FLOW1寄存器中有关VDIC的位：VDI_SRC_SEL，手册中的解释如下：
从程序中可以看到，只是将这些位清空了，所以默认的VDIC的数据来源是ARM平台。
同样，设置IC初始化为prpvf模式，然后通过_ipu_vdi_init初始化VDIC，_ipu_vdi_init在ipu_ic.c中定义。*/
/*这个模式的流程是下面这张图：
*/
case MEM_VDI_PRP_VF_MEM_P:
case MEM_VDI_PRP_VF_MEM_N:
case MEM_VDI_MEM_P:
case MEM_VDI_MEM_N:
_ipu_vdi_init(ipu, channel, params);
break; /*这几个channel不再分析了。*/
case MEM_VDI_MEM:
if ((ipu->using_ic_dirct_ch == CSI_PRP_VF_MEM) ||
(ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) ||
(ipu->using_ic_dirct_ch == CSI_PRP_ENC_MEM)) {
ret = -EINVAL;
goto err;
}
ipu->using_ic_dirct_ch = MEM_VDI_MEM;
ipu->ic_use_count++;
ipu->vdi_use_count++;
_ipu_vdi_init(ipu, channel, params);
break; /*设置ipu_soc中的using_ic_dirct_ch，增加ic_use_count和vdi_use_count的引用计数，最终也是调用这个_ipu_vdi_init函数。这个函数中增加了vdi_use_count的引用计数，上面几个与这个channel相似的channel都没有增加这个引用计数。这个channel只使用了VDIC。*/
case MEM_ROT_VF_MEM:
ipu->ic_use_count++;
ipu->rot_use_count++;
_ipu_ic_init_rotate_vf(ipu, params);
break;
case MEM_PRP_ENC_MEM:
ipu->ic_use_count++;
reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1);
ipu_cm_write(ipu, reg | FS_ENC_IN_VALID, IPU_FS_PROC_FLOW1);
_ipu_ic_init_prpenc(ipu, params, false);
break;
case MEM_ROT_ENC_MEM:
ipu->ic_use_count++;
ipu->rot_use_count++;
_ipu_ic_init_rotate_enc(ipu, params);
break; /*上面几个channel程序比较简单，就暂时不分析。*/
case MEM_PP_MEM:
if (params->mem_pp_mem.graphics_combine_en) {
sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER);
in_g_pixel_fmt = params->mem_pp_mem.in_g_pixel_fmt;
bad_pixfmt =
_ipu_ch_param_bad_alpha_pos(in_g_pixel_fmt);
if (params->mem_pp_mem.alpha_chan_en) {
if (bad_pixfmt) {
dev_err(ipu->dev, "bad pixel format "
"for graphics plane from "
"ch%d\n", sec_dma);
ret = -EINVAL;
goto err;
}
ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = true;
}
ipu->sec_chan_en[IPU_CHAN_ID(channel)] = true;
}
_ipu_ic_init_pp(ipu, params);
ipu->ic_use_count++;
break; /*这个channel与MEM_PRP_VF_MEMchannel类似，它也是根据params参数启用了sec_chan_en和thrd_chan_en。*/
/*
*/
case MEM_ROT_PP_MEM:
_ipu_ic_init_rotate_pp(ipu, params);
ipu->ic_use_count++;
ipu->rot_use_count++;
break;
case MEM_DC_SYNC:
if (params->mem_dc_sync.di > 1) {
ret = -EINVAL;
goto err;
}
ipu->dc_di_assignment[1] = params->mem_dc_sync.di;
_ipu_dc_init(ipu, 1, params->mem_dc_sync.di,
params->mem_dc_sync.interlaced,
params->mem_dc_sync.out_pixel_fmt);
ipu->di_use_count[params->mem_dc_sync.di]++;
ipu->dc_use_count++;
ipu->dmfc_use_count++;
break;
case MEM_BG_SYNC:
if (params->mem_dp_bg_sync.di > 1) {
ret = -EINVAL;
goto err;
}
if (params->mem_dp_bg_sync.alpha_chan_en)
ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = true;
ipu->dc_di_assignment[5] = params->mem_dp_bg_sync.di;
_ipu_dp_init(ipu, channel, params->mem_dp_bg_sync.in_pixel_fmt,
params->mem_dp_bg_sync.out_pixel_fmt);
_ipu_dc_init(ipu, 5, params->mem_dp_bg_sync.di,
params->mem_dp_bg_sync.interlaced,
params->mem_dp_bg_sync.out_pixel_fmt);
ipu->di_use_count[params->mem_dp_bg_sync.di]++;
ipu->dc_use_count++;
ipu->dp_use_count++;
ipu->dmfc_use_count++;
break;
case MEM_FG_SYNC:
_ipu_dp_init(ipu, channel, params->mem_dp_fg_sync.in_pixel_fmt,
params->mem_dp_fg_sync.out_pixel_fmt);
if (params->mem_dp_fg_sync.alpha_chan_en)
ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = true;
ipu->dc_use_count++;
ipu->dp_use_count++;
ipu->dmfc_use_count++;
break;
case DIRECT_ASYNC0:
if (params->direct_async.di > 1) {
ret = -EINVAL;
goto err;
}
ipu->dc_di_assignment[8] = params->direct_async.di;
_ipu_dc_init(ipu, 8, params->direct_async.di, false, IPU_PIX_FMT_GENERIC);
ipu->di_use_count[params->direct_async.di]++;
ipu->dc_use_count++;
break;
case DIRECT_ASYNC1:
if (params->direct_async.di > 1) {
ret = -EINVAL;
goto err;
}
ipu->dc_di_assignment[9] = params->direct_async.di;
_ipu_dc_init(ipu, 9, params->direct_async.di, false, IPU_PIX_FMT_GENERIC);
ipu->di_use_count[params->direct_async.di]++;
ipu->dc_use_count++;
break;
default:
dev_err(ipu->dev, "Missing channel initialization\n");
break;
}
ipu->channel_init_mask |= 1L << IPU_CHAN_ID(channel);
ipu_cm_write(ipu, ipu_conf, IPU_CONF);
err:
mutex_unlock(&ipu->mutex_lock);
return ret;
}
EXPORT_SYMBOL(ipu_init_channel);/*后面几个channel是关于显示的channel，他们与前面几个case的步骤是相似的，暂时不分析，用到的时候再分析。*/
小总结：
可以看出来，在ipu_init_channel函数中，会根据对应的channel来决定使用哪个模块。
比如对于CSI_MEM0～CSI_MEM3，就会使用SMFC（_ipu_smfc_init函数），然后通过_ipu_csi_init函数来指定数据的目的地址。
对于CSI_PRP_ENC_MEMchannel，就会使用IC，使用的是IC的prpenc功能，就需要使用_ipu_ic_init_prpenc函数，同样需要使用通过_ipu_csi_init函数来指定数据的目的地址。
对于CSI_PRP_VF_MEMchannel，需要使用到IC，但是使用的是IC的prpvf功能，就需要使用_ipu_ic_init_prpvf函数。同样需要使用通过_ipu_csi_init函数来指定数据的目的地址。
上面几个函数都使用到了CSI设备，所以都使用了_ipu_csi_init函数来指定数据的目的地址。对于有些channel没有使用CSI设备，肯定就不用使用_ipu_csi_init这个函数了。
比如对于MEM_VDI_MEMchannel，它使用到VDI模块，只需要通过_ipu_vdi_init函数来设置即可。
比如MEM_ROT_VF_MEMchannel，它需要使用到IC的rotate和viewfinder功能，就需要通过_ipu_ic_init_rotate_vf函数来设置了。
扫一扫
3724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
