devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

4.imx6 IPU代码详细分析

作者：正经夜光杯 | 2024-08-08 05:44:11

赞

踩

imx6 ipu


4.0 ipu_soc,ipu_channel_t ,ipu_channel_params_t结构体详解


1.ipu_soc结构体：

struct ipu_soc {

  1. unsigned int id; //ipu的ID号
  2. unsigned int devtype; //ipu的一些信息，包含cm,ic等模块的地址偏移值
  3. bool online; //表示这个ipu是否正在使用中
  5. /*clk*/
  6. struct clk *ipu_clk;
  7. struct clk *di_clk[2];
  8. struct clk *di_clk_sel[2];
  9. struct clk *pixel_clk[2];
  10. bool pixel_clk_en[ 2];
  11. struct clk *pixel_clk_sel[2];
  12. struct clk *csi_clk[2];
  13. struct clk *prg_clk;
  15. /*irq*/
  16. int irq_sync;
  17. int irq_err;
  18. struct ipu_irq_node irq_list[IPU_IRQ_COUNT]; //在request_irq函数中会根据传入的irq号在这个数组中选择对应的下标，来存取有关这个irq的
  19. //信息如irq服务函数，名字，flags等参数。
  21. /*reg*/ /* ipu内部模块经过ioremap后的地址 */
  22. void __iomem *cm_reg;
  23. void __iomem *idmac_reg;
  24. void __iomem *dp_reg;
  25. void __iomem *ic_reg;
  26. void __iomem *dc_reg;
  27. void __iomem *dc_tmpl_reg;
  28. void __iomem *dmfc_reg;
  29. void __iomem *di_reg[ 2];
  30. void __iomem *smfc_reg;
  31. void __iomem *csi_reg[ 2];
  32. void __iomem *cpmem_base;
  33. void __iomem *tpmem_base;
  34. void __iomem *vdi_reg;
  36. struct device *dev;
  38. ipu_channel_t csi_channel[ 2]; //每个ipu有两个csi设备，将此时csi设备对应的channel根据csi号保存在这个csi_channel[]数组中
  39. ipu_channel_t using_ic_dirct_ch; //表示那个channel直接使用IC设备
  40. unsigned char dc_di_assignment[ 10];
  41. bool sec_chan_en[ 24]; //对应的channel是否使能了second channel
  42. bool thrd_chan_en[ 24]; //对应的channel是否使能了third channel
  43. bool chan_is_interlaced[ 52]; //对应的channel中的数据是否是隔行的，每个channel对应其中的一位，每一位是一个bool类型的值
  44. uint32_t channel_init_mask; //这是一个32位的数，其中每一位代表一个channel号，如果初始化一个channel的话，就将这个channel对应的位置1
  45. uint32_t channel_enable_mask; //每一位对应一个channel号，如果使能了一个channel 的话，就将这个channel对应的位置1,与上面那个channel_init_mask类似。
  47. /*use count*/ /* 下面几个是IPU内部模块的引用计数 */
  48. int dc_use_count; //dc引用计数
  49. int dp_use_count; //dp引用计数
  50. int dmfc_use_count; //dmfc引用计数
  51. int smfc_use_count; //smfc引用计数
  52. int ic_use_count; //ic引用计数
  53. int rot_use_count; //rot引用计数
  54. int vdi_use_count; //vdi引用计数
  55. int di_use_count[ 2]; //di引用计数，每个ipu只有两个di
  56. int csi_use_count[ 2]; //csi引用计数，每个ipu只有两个csi
  58. struct mutex mutex_lock;
  59. spinlock_t int_reg_spin_lock;
  60. spinlock_t rdy_reg_spin_lock;
  62. int dmfc_size_28;
  63. int dmfc_size_29;
  64. int dmfc_size_24;
  65. int dmfc_size_27;
  66. int dmfc_size_23;
  68. enum csc_type_t fg_csc_type;
  69. enum csc_type_t bg_csc_type;
  70. bool color_key_4rgb;
  71. bool dc_swap;
  72. struct completion dc_comp;
  73. struct completion csi_comp;
  75. struct rot_mem {
  76. void *vaddr;
  77. dma_addr_t paddr;
  78. int size;
  79. } rot_dma[ 2];
  81. int vdoa_en; //是否使能VDOA
  82. struct task_struct *thread[2]; //两个内核线程
  84. /*
  85. * Bypass reset to avoid display channel being
  86. * stopped by probe since it may starts to work
  87. * in bootloader.
  88. */
  89. bool bypass_reset; /* 这个值是从dts文件中获得的bypass_reset，因为在开发板启动过程中，需要使能屏幕来显示，所以显示通道可能已经在bootloader中开启了，
  90. * 在这里设置这个值，使得显示通道在probe函数中不会关闭，也就是这个参数的含义（旁路）。*/
  92. /* AXI protocol id */
  93. unsigned int ch0123_axi;
  94. unsigned int ch23_axi;
  95. unsigned int ch27_axi;
  96. unsigned int ch28_axi;
  97. unsigned int normal_axi;
  98. /* 不同的channel可能会对应不同的 AXI protocol，在ipu_probe函数中对这些值进行了赋值，在ipu_platform_type结构体中指定的。 */
  100. bool smfc_idmac_12bit_3planar_bs_fixup; /* workaround little stripes */
  101. };



2.ipu_channel_t枚举：

typedef enum {

  1. CHAN_NONE = -1,
  2. MEM_ROT_ENC_MEM = _MAKE_CHAN( 1, 45, NO_DMA, NO_DMA, 48),
  3. MEM_ROT_VF_MEM = _MAKE_CHAN( 2, 46, NO_DMA, NO_DMA, 49),
  4. MEM_ROT_PP_MEM = _MAKE_CHAN( 3, 47, NO_DMA, NO_DMA, 50),
  6. MEM_PRP_ENC_MEM = _MAKE_CHAN( 4, 12, 14, 17, 20),
  7. MEM_PRP_VF_MEM = _MAKE_CHAN( 5, 12, 14, 17, 21),
  8. MEM_PP_MEM = _MAKE_CHAN( 6, 11, 15, 18, 22),
  10. MEM_DC_SYNC = _MAKE_CHAN( 7, 28, NO_DMA, NO_DMA, NO_DMA),
  11. MEM_DC_ASYNC = _MAKE_CHAN( 8, 41, NO_DMA, NO_DMA, NO_DMA),
  12. MEM_BG_SYNC = _MAKE_CHAN( 9, 23, NO_DMA, 51, NO_DMA),
  13. MEM_FG_SYNC = _MAKE_CHAN( 10, 27, NO_DMA, 31, NO_DMA),
  15. MEM_BG_ASYNC0 = _MAKE_CHAN( 11, 24, NO_DMA, 52, NO_DMA),
  16. MEM_FG_ASYNC0 = _MAKE_CHAN( 12, 29, NO_DMA, 33, NO_DMA),
  17. MEM_BG_ASYNC1 = _MAKE_ALT_CHAN(MEM_BG_ASYNC0),
  18. MEM_FG_ASYNC1 = _MAKE_ALT_CHAN(MEM_FG_ASYNC0),
  20. DIRECT_ASYNC0 = _MAKE_CHAN( 13, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
  21. DIRECT_ASYNC1 = _MAKE_CHAN( 14, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
  23. CSI_MEM0 = _MAKE_CHAN( 15, NO_DMA, NO_DMA, NO_DMA, 0),
  24. CSI_MEM1 = _MAKE_CHAN( 16, NO_DMA, NO_DMA, NO_DMA, 1),
  25. CSI_MEM2 = _MAKE_CHAN( 17, NO_DMA, NO_DMA, NO_DMA, 2),
  26. CSI_MEM3 = _MAKE_CHAN( 18, NO_DMA, NO_DMA, NO_DMA, 3),
  28. CSI_MEM = CSI_MEM0,
  30. CSI_PRP_ENC_MEM = _MAKE_CHAN( 19, NO_DMA, NO_DMA, NO_DMA, 20),
  31. CSI_PRP_VF_MEM = _MAKE_CHAN( 20, NO_DMA, NO_DMA, NO_DMA, 21),
  33. /* for vdi mem->vdi->ic->mem , add graphics plane and alpha*/
  34. MEM_VDI_PRP_VF_MEM_P = _MAKE_CHAN( 21, 8, 14, 17, 21),
  35. MEM_VDI_PRP_VF_MEM = _MAKE_CHAN( 22, 9, 14, 17, 21),
  36. MEM_VDI_PRP_VF_MEM_N = _MAKE_CHAN( 23, 10, 14, 17, 21),
  38. /* for vdi mem->vdi->mem */
  39. MEM_VDI_MEM_P = _MAKE_CHAN( 24, 8, NO_DMA, NO_DMA, 5),
  40. MEM_VDI_MEM = _MAKE_CHAN( 25, 9, NO_DMA, NO_DMA, 5),
  41. MEM_VDI_MEM_N = _MAKE_CHAN( 26, 10, NO_DMA, NO_DMA, 5),
  43. /* fake channel for vdoa to link with IPU */
  44. MEM_VDOA_MEM = _MAKE_CHAN( 27, NO_DMA, NO_DMA, NO_DMA, NO_DMA),
  46. MEM_PP_ADC = CHAN_NONE,
  47. ADC_SYS2 = CHAN_NONE,
  49. } ipu_channel_t;

再来看看这个_MAKE_CHAN宏：

#define _MAKE_CHAN(num, v_in, g_in, a_in, out) \

  1. ((num << 24) | (v_in << 18) | (g_in << 12) | (a_in << 6) | out)
  2. #define NO_DMA 0x3F

从这里就可以看出来，ipu_channel_t只是根据5个值左移形成的一个数字。

那么想要从channel中获取它的ID号怎么办？只需要将它右移24位即可，就能得到，就是下面一个宏：

#define IPU_CHAN_ID(ch)			(ch >> 24)

再来看看channel_2_dma函数：

static inline uint32_t channel_2_dma(ipu_channel_t ch, ipu_buffer_t type)

  1. {
  2. return (( uint32_t) ch >> ( 6 * type)) & 0x3F;
  3. };

这个函数能够根据不同的type类型从channel里面提取出所使用的dmachannel。

typedef enum {

  1. IPU_OUTPUT_BUFFER = 0, /*!< Buffer for output from IPU */
  2. IPU_ALPHA_IN_BUFFER = 1, /*!< Buffer for input to IPU */
  3. IPU_GRAPH_IN_BUFFER = 2, /*!< Buffer for input to IPU */
  4. IPU_VIDEO_IN_BUFFER = 3, /*!< Buffer for input to IPU */
  5. IPU_INPUT_BUFFER = IPU_VIDEO_IN_BUFFER,
  6. IPU_SEC_INPUT_BUFFER = IPU_GRAPH_IN_BUFFER,
  7. } ipu_buffer_t;

同时根据_MAKE_CHAN宏中几个变量的名字，就能够理解ipu_channel_t中各个位的含义：

0～5位：输出dmachannel号

6～11位：alpha通道号

12～17位：graph通道号

18～23位：video输入dmachannel号

24～ ：channel的序列号



3. ipu_channel_params_t联合：

typedef union {

  1. struct {
  2. uint32_t csi; //csi设备号，0或1
  3. uint32_t mipi_id; //mipi ID号
  4. uint32_t mipi_vc; //mipi虚拟通道号
  5. bool mipi_en; //是否使能mipi接口
  6. bool interlaced; //数据是否是隔行的
  7. } csi_mem;
  8. struct {
  9. uint32_t in_width; //输入数据的宽度
  10. uint32_t in_height; //输入数据的高度
  11. uint32_t in_pixel_fmt; //输入数据的像素格式
  12. uint32_t out_width; //输出数据的宽度
  13. uint32_t out_height; //输出数据的高度
  14. uint32_t out_pixel_fmt; //输出数据的像素格式
  15. uint32_t outh_resize_ratio; //输出水平方向上重定义大小系数
  16. uint32_t outv_resize_ratio; //输出垂直方向上重定义大小系数
  17. uint32_t csi; //csi 设备号
  18. uint32_t mipi_id; //mipi ID号
  19. uint32_t mipi_vc; //mipi 虚拟通道号
  20. bool mipi_en; //是否是能mipi接口
  21. } csi_prp_enc_mem;
  22. struct {
  23. uint32_t in_width;
  24. uint32_t in_height;
  25. uint32_t in_pixel_fmt;
  26. uint32_t out_width;
  27. uint32_t out_height;
  28. uint32_t out_pixel_fmt;
  29. uint32_t outh_resize_ratio;
  30. uint32_t outv_resize_ratio;
  31. } mem_prp_enc_mem;
  32. struct {
  33. uint32_t in_width;
  34. uint32_t in_height;
  35. uint32_t in_pixel_fmt;
  36. uint32_t out_width;
  37. uint32_t out_height;
  38. uint32_t out_pixel_fmt;
  39. } mem_rot_enc_mem;
  40. struct {
  41. uint32_t in_width;
  42. uint32_t in_height;
  43. uint32_t in_pixel_fmt;
  44. uint32_t out_width;
  45. uint32_t out_height;
  46. uint32_t out_pixel_fmt;
  47. uint32_t outh_resize_ratio;
  48. uint32_t outv_resize_ratio;
  49. bool graphics_combine_en;
  50. bool global_alpha_en;
  51. bool key_color_en;
  52. uint32_t in_g_pixel_fmt;
  53. uint8_t alpha;
  54. uint32_t key_color;
  55. bool alpha_chan_en;
  56. ipu_motion_sel motion_sel;
  57. enum v4l2_field field_fmt;
  58. uint32_t csi;
  59. uint32_t mipi_id;
  60. uint32_t mipi_vc;
  61. bool mipi_en;
  62. } csi_prp_vf_mem;
  63. struct {
  64. uint32_t in_width;
  65. uint32_t in_height;
  66. uint32_t in_pixel_fmt;
  67. uint32_t out_width;
  68. uint32_t out_height;
  69. uint32_t out_pixel_fmt;
  70. bool graphics_combine_en;
  71. bool global_alpha_en;
  72. bool key_color_en;
  73. display_port_t disp;
  74. uint32_t out_left;
  75. uint32_t out_top;
  76. } csi_prp_vf_adc;
  77. struct {
  78. uint32_t in_width; //输入宽度
  79. uint32_t in_height; //输入高度
  80. uint32_t in_pixel_fmt; //输入像素格式
  81. uint32_t out_width; //输出宽度
  82. uint32_t out_height; //输出高度
  83. uint32_t out_pixel_fmt; //输出像素格式
  84. uint32_t outh_resize_ratio; //输出水平方向上重定义大小的比例
  85. uint32_t outv_resize_ratio; //输出垂直方向上重定义大小的比例
  86. bool graphics_combine_en; //是否使能second channel的标志位
  87. bool global_alpha_en; //是否使能third channel的标志位
  88. bool key_color_en;
  89. uint32_t in_g_pixel_fmt;
  90. uint8_t alpha;
  91. uint32_t key_color;
  92. bool alpha_chan_en;
  93. ipu_motion_sel motion_sel;
  94. enum v4l2_field field_fmt;
  95. } mem_prp_vf_mem;
  96. struct {
  97. uint32_t temp;
  98. } mem_prp_vf_adc;
  99. struct {
  100. uint32_t temp;
  101. } mem_rot_vf_mem;
  102. struct {
  103. uint32_t in_width;
  104. uint32_t in_height;
  105. uint32_t in_pixel_fmt;
  106. uint32_t out_width;
  107. uint32_t out_height;
  108. uint32_t out_pixel_fmt;
  109. uint32_t outh_resize_ratio;
  110. uint32_t outv_resize_ratio;
  111. bool graphics_combine_en;
  112. bool global_alpha_en;
  113. bool key_color_en;
  114. uint32_t in_g_pixel_fmt;
  115. uint8_t alpha;
  116. uint32_t key_color;
  117. bool alpha_chan_en;
  118. } mem_pp_mem;
  119. struct {
  120. uint32_t temp;
  121. } mem_rot_mem;
  122. struct {
  123. uint32_t in_width;
  124. uint32_t in_height;
  125. uint32_t in_pixel_fmt;
  126. uint32_t out_width;
  127. uint32_t out_height;
  128. uint32_t out_pixel_fmt;
  129. bool graphics_combine_en;
  130. bool global_alpha_en;
  131. bool key_color_en;
  132. display_port_t disp;
  133. uint32_t out_left;
  134. uint32_t out_top;
  135. } mem_pp_adc;
  136. struct {
  137. uint32_t di;
  138. bool interlaced; //数据是否是隔行的
  139. uint32_t in_pixel_fmt;
  140. uint32_t out_pixel_fmt;
  141. } mem_dc_sync;
  142. struct {
  143. uint32_t temp;
  144. } mem_sdc_fg;
  145. struct {
  146. uint32_t di;
  147. bool interlaced; //数据是否是隔行的
  148. uint32_t in_pixel_fmt;
  149. uint32_t out_pixel_fmt;
  150. bool alpha_chan_en;
  151. } mem_dp_bg_sync;
  152. struct {
  153. uint32_t temp;
  154. } mem_sdc_bg;
  155. struct {
  156. uint32_t di;
  157. bool interlaced; //数据是否是隔行的
  158. uint32_t in_pixel_fmt;
  159. uint32_t out_pixel_fmt;
  160. bool alpha_chan_en;
  161. } mem_dp_fg_sync;
  162. struct {
  163. uint32_t di;
  164. } direct_async;
  165. struct {
  166. display_port_t disp;
  167. mcu_mode_t ch_mode;
  168. uint32_t out_left;
  169. uint32_t out_top;
  170. } adc_sys1;
  171. struct {
  172. display_port_t disp;
  173. mcu_mode_t ch_mode;
  174. uint32_t out_left;
  175. uint32_t out_top;
  176. } adc_sys2;
  177. } ipu_channel_params_t;

这个ipu_channel_params_t这个联合，在这个联合中对于每一种channel都有一个对应的结构体类型来保存channel的参数。如果想要获取哪一个channel的信息，就从这个联合中的对应channel里面找即可。同时，在initchannel的时候，也是通过对这个联合里面对应的channel参数赋值。


4.1 ipu_common.c分析---入口函数及probe函数分析

这个ipu_common.c函数提供ipu底层函数调用的一些关系和函数。

（一）分析这个文件从init函数入口，发现有这个subsys_initcall，说明ipu是作为一个子系统注册到内核中的：

  1. int32_t __ init ipu_gen_init(void)
  2. {
  3. int32_t ret;
  5. ret = platform_driver_register(&mxcipu_driver);
  6. return 0;
  7. }
  9. subsys_initcall(ipu_gen_init);

（二）这个mxcipu_driver结构体注册到平台以后，如果有匹配的设备的话，就会调用其中的probe函

static int ipu_probe(struct platform_device *pdev)

  1. {
  2. struct ipu_soc *ipu;
  3. struct resource *res;
  4. unsigned long ipu_base;
  5. const struct of_device_id *of_id =
  6. of_match_device( imx_ipuv3_dt_ids, & pdev-> dev);
  7. const struct ipu_platform_type *iputype = of_id->data;
  8. const struct ipu_devtype *devtype = &iputype->devtype;
  9. int ret = 0, id;
  10. u32 bypass_reset, reg;

/*以imx6qp为例（后面本文件中如果有涉及到板子的一些资源，都以imx6qp为例），

*iputype= of_id->data，这个of_id返回的是imx_ipuv3_dt_ids[]数组中的某一项，

static const struct of_device_id imx_ipuv3_dt_ids[] = {

  1. { .compatible = "fsl,imx51-ipu", .data = &ipu_type_imx51, },
  2. { .compatible = "fsl,imx53-ipu", .data = &ipu_type_imx53, },
  3. { .compatible = "fsl,imx6q-ipu", .data = &ipu_type_imx6q, },
  4. { .compatible = "fsl,imx6qp-ipu", .data = &ipu_type_imx6qp, },
  5. { /* sentinel */ }
  6. };
  7. MODULE_DEVICE_TABLE(of, imx_ipuv3_dt_ids);

在本文件中就是{.compatible = "fsl,imx6qp-ipu", .data = &ipu_type_imx6qp,}这一项。所以：

*iputype= &ipu_type_imx6qp，

*devtype= 下面标红的部分：

static struct ipu_platform_type ipu_type_imx6qp = {

  1. <span style="color:#FF0000;">.devtype = {
  2. .name = "IPUv3H",
  3. .cm_ofs = 0x00200000,
  4. .idmac_ofs = 0x00208000,
  5. .ic_ofs = 0x00220000,
  6. .csi0_ofs = 0x00230000,
  7. .csi1_ofs = 0x00238000,
  8. .di0_ofs = 0x00240000,
  9. .di1_ofs = 0x00248000,
  10. .smfc_ofs = 0x00250000,
  11. .dc_ofs = 0x00258000,
  12. .dmfc_ofs = 0x00260000,
  13. .vdi_ofs = 0x00268000,
  14. .cpmem_ofs = 0x00300000,
  15. .srm_ofs = 0x00340000,
  16. .tpm_ofs = 0x00360000,
  17. .dc_tmpl_ofs = 0x00380000,
  18. .type = IPUv3H,
  19. .idmac_used_bufs_present = true,
  20. }, </span>
  21. .ch0123_axi = 0,
  22. .ch23_axi = 0,
  23. .ch27_axi = 2,
  24. .ch28_axi = 3,
  25. .normal_axi = 1,
  26. .idmac_used_bufs_en_r = true,
  27. .idmac_used_bufs_en_w = true,
  28. .idmac_used_bufs_max_r = 0x3,
  29. .idmac_used_bufs_max_w = 0x3,
  30. .smfc_idmac_12bit_3planar_bs_fixup = true,
  31. };

*/

dev_dbg(&pdev->dev, "<%s>\n", __func__);

  2. ret = of_property_read_u32(pdev->dev.of_node,
  3. "bypass_reset", &bypass_reset);
  4. if (ret < 0) {
  5. dev_dbg(&pdev->dev, "can not get bypass_reset\n");
  6. return ret;
  7. }

/*从pdev->dev.of_node这个devicenode结构体里面读取“bypass_reset”这一项，将读出的结果存在&bypass_reset中。*/

id = of_alias_get_id(pdev->dev.of_node, "ipu");

  1. if (id < 0) {
  2. dev_dbg(&pdev->dev, "can not get alias id\n");
  3. return id;
  4. }

/*这个of_alias_get_id函数的大致意思是根据名字“ipu”获取到它的id，将这个id返回。但是有两个ipu呢，这个怎么选择？？如果根据名字的话，怎么区分这两个ipu？*/

ipu = &ipu_array[id];

  1. memset(ipu, 0, sizeof(struct ipu_soc));
  2. ipu->bypass_reset = ( bool)bypass_reset;
  3. ipu->dev = &pdev->dev;
  4. ipu->id = id;
  5. ipu->devtype = devtype->type;
  6. ipu->ch0123_axi = iputype->ch0123_axi;
  7. ipu->ch23_axi = iputype->ch23_axi;
  8. ipu->ch27_axi = iputype->ch27_axi;
  9. ipu->ch28_axi = iputype->ch28_axi;
  10. ipu->normal_axi = iputype->normal_axi;
  11. ipu->smfc_idmac_12bit_3planar_bs_fixup =
  12. iputype->smfc_idmac_12bit_3planar_bs_fixup;
  13. spin_lock_init(&ipu->int_reg_spin_lock);
  14. spin_lock_init(&ipu->rdy_reg_spin_lock);
  15. mutex_init(&ipu->mutex_lock);

/*这一些就是根据上面获取到的信息来填充这个structipu_soc *ipu结构体。*/

dev_dbg(&pdev->dev, "revision is %s\n", devtype->name);

  2. ipu->irq_sync = platform_get_irq(pdev, 0);
  3. ipu->irq_err = platform_get_irq(pdev, 1);
  4. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  6. if (!res || ipu->irq_sync < 0 || ipu->irq_err < 0) {
  7. dev_err(&pdev->dev, "can't get device resources\n");
  8. return -ENODEV;
  9. }

/*获取irq资源和内存资源。*/

if (!devm_request_mem_region(&pdev->dev, res->start,

  1. resource_size(res), pdev->name))
  2. return -EBUSY;

/*申请I/O内存资源，申请后还需要通过ioremap等函数映射后才能够使用。*/

ret = devm_request_irq(&pdev->dev, ipu->irq_sync,

  1. ipu_sync_irq_handler, 0, pdev->name, ipu);
  2. if (ret) {
  3. dev_err(ipu->dev, "request SYNC interrupt failed\n");
  4. return ret;
  5. }
  6. ret = devm_request_irq(&pdev->dev, ipu->irq_err,
  7. ipu_err_irq_handler, 0, pdev->name, ipu);
  8. if (ret) {
  9. dev_err(ipu->dev, "request ERR interrupt failed\n");
  10. return ret;
  11. }

/*为上面获取到的irq资源注册中断服务函数。*/

ipu_base = res->start; //ipu地址的初始值。

  2. ipu->cm_reg = devm_ioremap(&pdev->dev,
  3. ipu_base + devtype->cm_ofs, PAGE_SIZE);
  4. ipu->ic_reg = devm_ioremap(&pdev->dev,
  5. ipu_base + devtype->ic_ofs, PAGE_SIZE);
  6. ipu->idmac_reg = devm_ioremap(&pdev->dev,
  7. ipu_base + devtype->idmac_ofs, PAGE_SIZE);
  8. /* DP Registers are accessed thru the SRM */
  9. ipu->dp_reg = devm_ioremap(&pdev->dev,
  10. ipu_base + devtype->srm_ofs, PAGE_SIZE);
  11. ipu->dc_reg = devm_ioremap(&pdev->dev,
  12. ipu_base + devtype->dc_ofs, PAGE_SIZE);
  13. ipu->dmfc_reg = devm_ioremap(&pdev->dev,
  14. ipu_base + devtype->dmfc_ofs, PAGE_SIZE);
  15. ipu->di_reg[ 0] = devm_ioremap(&pdev->dev,
  16. ipu_base + devtype->di0_ofs, PAGE_SIZE);
  17. ipu->di_reg[ 1] = devm_ioremap(&pdev->dev,
  18. ipu_base + devtype->di1_ofs, PAGE_SIZE);
  19. ipu->smfc_reg = devm_ioremap(&pdev->dev,
  20. ipu_base + devtype->smfc_ofs, PAGE_SIZE);
  21. ipu->csi_reg[ 0] = devm_ioremap(&pdev->dev,
  22. ipu_base + devtype->csi0_ofs, PAGE_SIZE);
  23. ipu->csi_reg[ 1] = devm_ioremap(&pdev->dev,
  24. ipu_base + devtype->csi1_ofs, PAGE_SIZE);
  25. ipu->cpmem_base = devm_ioremap(&pdev->dev,
  26. ipu_base + devtype->cpmem_ofs, SZ_128K);
  27. ipu->tpmem_base = devm_ioremap(&pdev->dev,
  28. ipu_base + devtype->tpm_ofs, SZ_64K);
  29. ipu->dc_tmpl_reg = devm_ioremap(&pdev->dev,
  30. ipu_base + devtype->dc_tmpl_ofs, SZ_128K);
  31. ipu->vdi_reg = devm_ioremap(&pdev->dev,
  32. ipu_base + devtype->vdi_ofs, PAGE_SIZE);
  33. if (!ipu->cm_reg || !ipu->ic_reg || !ipu->idmac_reg ||
  34. !ipu->dp_reg || !ipu->dc_reg || !ipu->dmfc_reg ||
  35. !ipu->di_reg[ 0] || !ipu->di_reg[ 1] || !ipu->smfc_reg ||
  36. !ipu->csi_reg[ 0] || !ipu->csi_reg[ 1] || !ipu->cpmem_base ||
  37. !ipu->tpmem_base || !ipu->dc_tmpl_reg || !ipu->vdi_reg)
  38. return -ENOMEM;
  40. dev_dbg(ipu->dev, "IPU CM Regs = %p\n", ipu->cm_reg);
  41. dev_dbg(ipu->dev, "IPU IC Regs = %p\n", ipu->ic_reg);
  42. dev_dbg(ipu->dev, "IPU IDMAC Regs = %p\n", ipu->idmac_reg);
  43. dev_dbg(ipu->dev, "IPU DP Regs = %p\n", ipu->dp_reg);
  44. dev_dbg(ipu->dev, "IPU DC Regs = %p\n", ipu->dc_reg);
  45. dev_dbg(ipu->dev, "IPU DMFC Regs = %p\n", ipu->dmfc_reg);
  46. dev_dbg(ipu->dev, "IPU DI0 Regs = %p\n", ipu->di_reg[ 0]);
  47. dev_dbg(ipu->dev, "IPU DI1 Regs = %p\n", ipu->di_reg[ 1]);
  48. dev_dbg(ipu->dev, "IPU SMFC Regs = %p\n", ipu->smfc_reg);
  49. dev_dbg(ipu->dev, "IPU CSI0 Regs = %p\n", ipu->csi_reg[ 0]);
  50. dev_dbg(ipu->dev, "IPU CSI1 Regs = %p\n", ipu->csi_reg[ 1]);
  51. dev_dbg(ipu->dev, "IPU CPMem = %p\n", ipu->cpmem_base);
  52. dev_dbg(ipu->dev, "IPU TPMem = %p\n", ipu->tpmem_base);
  53. dev_dbg(ipu->dev, "IPU DC Template Mem = %p\n", ipu->dc_tmpl_reg);
  54. dev_dbg(ipu->dev, "IPU VDI Regs = %p\n", ipu->vdi_reg);

/*根据获取到的资源来为每个寄存器映射内存空间。*/

ipu->ipu_clk = devm_clk_get(ipu->dev, "bus");

  1. if (IS_ERR(ipu->ipu_clk)) {
  2. dev_err(ipu->dev, "clk_get ipu failed");
  3. return PTR_ERR(ipu->ipu_clk);
  4. }

/*获取"bus"的时钟。*/

/* ipu_clk is always prepared */

  1. ret = clk_prepare_enable(ipu->ipu_clk);
  2. if (ret < 0) {
  3. dev_err(ipu->dev, "ipu clk enable failed\n");
  4. return ret;
  5. }

/*这个函数是clk_prepare和clk_enable两个函数的集合，其中clk_prepare函数是个预定义的函数，需要定义CONFIG_HAVE_CLK_PREPARE这个宏，然后就是调用clk_enable函数来使能时钟。*/

ipu->prg_clk = devm_clk_get(ipu->dev, "prg");

  1. if (IS_ERR(ipu->prg_clk))
  2. ipu->prg_clk = NULL;

/*获取"prg"的时钟。*/

	ipu->online = true;

/*这个online是一个bool类型的变量，表示当前这个ipu是否正在使用中。*/

	platform_set_drvdata(pdev, ipu);

/*设置私有数据。*/

/*下面这个bypass_reset参数在前面通过of_property_read_u32函数获得了，从dts文件中可以看到它等于0.同时在structipu_soc中关于这个bypass_reset有这样的注释：Bypassreset to avoid display channel being stopped by probe since it maystarts to work inbootloader.这个值是从dts文件中获得的bypass_reset，因为在开发板启动过程中，需要使能屏幕来显示，所以显示通道可能已将在bootloader中开启了，在这里设置这个值，使得显示通道在probe函数中不会关闭，也就是这个参数的含义（旁路）。*/

if (!bypass_reset) {

  1. ret = device_reset(&pdev->dev);
  2. if (ret) {
  3. dev_err(&pdev->dev, "failed to reset: %d\n", ret);
  4. return ret;
  5. }
  7. ipu_mem_reset(ipu);
  9. ipu_disp_init(ipu);
  11. /* Set MCU_T to divide MCU access window into 2 */
  12. ipu_cm_write(ipu, 0x00400000L | (IPU_MCU_T_DEFAULT << 18),
  13. IPU_DISP_GEN);
  14. }

/*这个ipu_mem_reset函数同样在这个文件中，如下所示：

static int ipu_mem_reset(struct ipu_soc *ipu)

  1. {
  2. int timeout = 1000;
  4. ipu_cm_write(ipu, 0x807FFFFF, IPU_MEM_RST);
  6. while (ipu_cm_read(ipu, IPU_MEM_RST) & 0x80000000) {
  7. if (!timeout--)
  8. return -ETIME;
  9. msleep( 1);
  10. }
  12. return 0;
  13. }

这个ipu_disp_init函数同样在ipu_common.c文件中，如下所示：

void ipu_disp_init(struct ipu_soc *ipu)

  1. {
  2. ipu->fg_csc_type = ipu->bg_csc_type = CSC_NONE;
  3. ipu->color_key_4rgb = true;
  4. _ipu_init_dc_mappings(ipu);
  5. _ipu_dmfc_init(ipu, DMFC_NORMAL, 1);
  6. }

最后通过ipu_cm_write函数来设置有关显示的一些寄存器。

*/

/* setup ipu clk tree after ipu reset */

  1. ret = ipu_clk_setup_enable(ipu);
  2. if (ret < 0) {
  3. dev_err(ipu->dev, "ipu clk setup failed\n");
  4. ipu->online = false;
  5. return ret;
  6. }

/*然后调用ipu_clk_setup_enable函数设置时钟树，这个函数也在这个ipu_common.c文件中，在后面分析。*/

if (devtype->idmac_used_bufs_present) {

  1. /* devtype->idmac_used_bufs_present = true。 */
  2. reg = ipu_idmac_read(ipu, IDMAC_CONF);
  3. if (iputype->idmac_used_bufs_en_r) //idmac_used_bufs_en_r = true
  4. reg |= IDMAC_CONF_USED_BUFS_EN_R;
  5. else
  6. reg &= ~IDMAC_CONF_USED_BUFS_EN_R;
  7. if (iputype->idmac_used_bufs_en_w) //idmac_used_bufs_en_w = true
  8. reg |= IDMAC_CONF_USED_BUFS_EN_W;
  9. else
  10. reg &= ~IDMAC_CONF_USED_BUFS_EN_W;
  12. reg &= ~IDMAC_CONF_USED_BUFS_MAX_R_MASK;
  13. reg |= (iputype->idmac_used_bufs_max_r <<
  14. IDMAC_CONF_USED_BUFS_MAX_R_OFFSET);
  15. reg &= ~IDMAC_CONF_USED_BUFS_MAX_W_MASK;
  16. reg |= (iputype->idmac_used_bufs_max_w <<
  17. IDMAC_CONF_USED_BUFS_MAX_W_OFFSET);
  18. /* idmac_used_bufs_max_r = 0x3，
  19. idmac_used_bufs_max_w = 0x3。 */
  20. ipu_idmac_write(ipu, reg, IDMAC_CONF);
  21. }

/*上面这段代码先通过ipu_idmac_read函数来读取IDMAC_CONF寄存器的值，然后根据iputype的一些信息设置它们在寄存器中对应的值，最后将新值通过ipu_idmac_write函数重新写入寄存器中。这个函数用来配置IDMAC。*/

/* Set sync refresh channels and CSI->mem channel as high priority */

  1. ipu_idmac_write(ipu, 0x18800003L, IDMAC_CHA_PRI( 0));

/*通过设置IDMAC_CHA_PRI(0)寄存器，将syncrefresh channels 和CSI->memchannel的设为高优先级*/

/* Enable error interrupts by default */

  1. ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL( 5));
  2. ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL( 6));
  3. ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL( 9));
  4. ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL( 10));

/*将IPU_INT_CTRL(5)，IPU_INT_CTRL(6)，IPU_INT_CTRL(9)，IPU_INT_CTRL(10)这几个寄存器设置为默认值0xFFFFFFFF，这几个寄存器应该是错误中断使能的寄存器。*/

if (!bypass_reset)

  1. clk_disable(ipu->ipu_clk);

/*同样是这个bypass_reset参数，暂时不知道它是多少。*/

	register_ipu_device(ipu, id);

/*注册ipu_device设备，这个函数在ipu_device.c文件中*/

	pm_runtime_enable(&pdev->dev);

/*使能设备的电源管理*/

return ret;

  1. }<span style= "font-family:Courier 10 Pitch;"><span style= "font-size:12px;"></span></span>

4.2 ipu_init_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：


 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      typedef 
      enum { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       CHAN_NONE = 
      -1, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       MEM_ROT_ENC_MEM = _MAKE_CHAN( 
      1, 
      45, NO_DMA, NO_DMA, 
      48), 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       MEM_ROT_VF_MEM = _MAKE_CHAN( 
      2, 
      46, NO_DMA, NO_DMA, 
      49), 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       MEM_ROT_PP_MEM = _MAKE_CHAN( 
      3, 
      47, NO_DMA, NO_DMA, 
      50), 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       MEM_PRP_ENC_MEM = _MAKE_CHAN( 
      4, 
      12, 
      14, 
      17, 
      20), 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       MEM_PRP_VF_MEM = _MAKE_CHAN( 
      5, 
      12, 
      14, 
      17, 
      21), 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       MEM_PP_MEM = _MAKE_CHAN( 
      6, 
      11, 
      15, 
      18, 
      22), 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       MEM_DC_SYNC = _MAKE_CHAN( 
      7, 
      28, NO_DMA, NO_DMA, NO_DMA), 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       MEM_DC_ASYNC = _MAKE_CHAN( 
      8, 
      41, NO_DMA, NO_DMA, NO_DMA), 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       MEM_BG_SYNC = _MAKE_CHAN( 
      9, 
      23, NO_DMA, 
      51, NO_DMA), 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       MEM_FG_SYNC = _MAKE_CHAN( 
      10, 
      27, NO_DMA, 
      31, NO_DMA), 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       MEM_BG_ASYNC0 = _MAKE_CHAN( 
      11, 
      24, NO_DMA, 
      52, NO_DMA), 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       MEM_FG_ASYNC0 = _MAKE_CHAN( 
      12, 
      29, NO_DMA, 
      33, NO_DMA), 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       MEM_BG_ASYNC1 = _MAKE_ALT_CHAN(MEM_BG_ASYNC0), 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       MEM_FG_ASYNC1 = _MAKE_ALT_CHAN(MEM_FG_ASYNC0), 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
    
       DIRECT_ASYNC0 = _MAKE_CHAN( 
      13, NO_DMA, NO_DMA, NO_DMA, NO_DMA), 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       DIRECT_ASYNC1 = _MAKE_CHAN( 
      14, NO_DMA, NO_DMA, NO_DMA, NO_DMA), 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       CSI_MEM0 = _MAKE_CHAN( 
      15, NO_DMA, NO_DMA, NO_DMA, 
      0), 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
    
       CSI_MEM1 = _MAKE_CHAN( 
      16, NO_DMA, NO_DMA, NO_DMA, 
      1), 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
    
       CSI_MEM2 = _MAKE_CHAN( 
      17, NO_DMA, NO_DMA, NO_DMA, 
      2), 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
    
       CSI_MEM3 = _MAKE_CHAN( 
      18, NO_DMA, NO_DMA, NO_DMA, 
      3), 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
    
       CSI_MEM = CSI_MEM0, 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
    
       CSI_PRP_ENC_MEM = _MAKE_CHAN( 
      19, NO_DMA, NO_DMA, NO_DMA, 
      20), 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
    
       CSI_PRP_VF_MEM = _MAKE_CHAN( 
      20, NO_DMA, NO_DMA, NO_DMA, 
      21), 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
     
      /* for vdi mem->vdi->ic->mem , add graphics plane and alpha*/ 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_PRP_VF_MEM_P = _MAKE_CHAN( 
      21, 
      8, 
      14, 
      17, 
      21), 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_PRP_VF_MEM = _MAKE_CHAN( 
      22, 
      9, 
      14, 
      17, 
      21), 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_PRP_VF_MEM_N = _MAKE_CHAN( 
      23, 
      10, 
      14, 
      17, 
      21), 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      /* for vdi mem->vdi->mem */ 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_MEM_P = _MAKE_CHAN( 
      24, 
      8, NO_DMA, NO_DMA, 
      5), 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_MEM = _MAKE_CHAN( 
      25, 
      9, NO_DMA, NO_DMA, 
      5), 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDI_MEM_N = _MAKE_CHAN( 
      26, 
      10, NO_DMA, NO_DMA, 
      5), 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
      /* fake channel for vdoa to link with IPU */ 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       MEM_VDOA_MEM = _MAKE_CHAN( 
      27, NO_DMA, NO_DMA, NO_DMA, NO_DMA), 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
    
       MEM_PP_ADC = CHAN_NONE, 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
    
       ADC_SYS2 = CHAN_NONE, 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       } 
      ipu_channel_t; 
     
     
    
  50.  
    
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define _MAKE_CHAN(num, v_in, g_in, a_in, out) \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ((num << 
      24) | (v_in << 
      18) | (g_in << 
      12) | (a_in << 
      6) | out) 
     
     
    
 
  
这个枚举就包含了所有的channel，如果对于上面讲解的过程理解的话，很容易根据channel的过程在这个枚举中找到对应的channel名字。同时可以看到在channel通过_MAKE_CHAN宏的构造过程中，每个channel里面都包含了输入输出dmachannel号。
 
  

 
  
分析完对channel的理解过程以后，再来看看具体的函数实现：
 
  
ipu_init_channel函数
 
  

 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      int32_t ipu_init_channel(struct ipu_soc *ipu, 
      ipu_channel_t channel, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      ipu_channel_params_t *params) 
     
     
    
 
  
/*这个函数有3个参数，第一个参数ipu代表正在使用的ipu。第二个参数是想要初始化的channel，它其实就是一个数字，可以理解为ID，第三个参数params是想要将这个channel初始化成什么样子，它里面包含channel的一些信息，会根据params参数来初始化这个channel。关于这个结构体的详细讲解可以看《ipu_channel_params_t结构体详解》*/
 
  
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int ret = 
      0; 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      bool bad_pixfmt; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint32_t ipu_conf, reg, in_g_pixel_fmt, sec_dma; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       dev_dbg(ipu->dev, 
      "init channel = %d\n", IPU_CHAN_ID(channel)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ret = pm_runtime_get_sync(ipu->dev); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      if (ret < 
      0) { 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "ch = %d, pm_runtime_get failed:%d!\n", 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHAN_ID(channel), ret); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       dump_stack(); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      return ret; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      /*  
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
       * Here, ret could be 1 if the device's runtime PM status was  
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
       * already 'active', so clear it to be 0.  
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
       */ 
     
     
    
 
  
/*看注释，可以看出来，上面一个函数如果执行成功的话，它的返回值是1，所以在下面需要将这个ret清零。跟踪源码，确实是这样的。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ret = 0; 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_get(ipu); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       mutex_lock(&ipu->mutex_lock); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       /* Re-enable error interrupts every time a channel is initialized */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(5)); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(6)); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(9)); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, 0xFFFFFFFF, IPU_INT_CTRL(10)); 
     
     
    
 
  
/*在初始化每一个channel的时候都需要重新使能错误中断。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->channel_init_mask & ( 
      1L << IPU_CHAN_ID(channel))) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
      "Warning: channel already initialized %d\n", 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHAN_ID(channel)); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这个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。*/
 
  

 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      switch (channel) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      case CSI_MEM0: 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      case CSI_MEM1: 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      case CSI_MEM2: 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      case CSI_MEM3: 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_mem.csi > 
      1) { 
      //csi有2个，取值为0和1. 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_mem.interlaced) 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu->chan_is_interlaced[channel_2_dma(channel, 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       IPU_OUTPUT_BUFFER)] = 
      true; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu->chan_is_interlaced[channel_2_dma(channel, 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       IPU_OUTPUT_BUFFER)] = 
      false; 
     
     
    
 
  
/*ipu->chan_is_interlaced是一个bool型的数组，根据params里面的csi_mem.interlaced参数，来设置ipu->chan_is_interlaced数组的某一项。怎么确定是数组的第几项？根据channel的值通过channel_2_dma函数为它在数组中挑选一个位置，然后将这个位置设置为true或false。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu->smfc_use_count++; 
      //增加smfc使用计数，这几个channel都会使用到smfc。 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu->csi_channel[params->csi_mem.csi] = channel; 
     
     
    
 
  
/*根据params->csi_mem.csi来确定是ipu->csi_channel数组的第几项，然后将channel赋给它。这个ipu->csi_channel数组包含两项，意思就是每个ipu有两个csi接口，每个接口选择哪个channel，都在这里进行保存。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*SMFC setting*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_mem.mipi_en) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= ( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       params->csi_mem.csi)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       _ipu_smfc_init(ipu, channel, params->csi_mem.mipi_vc, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       params->csi_mem.csi); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_set_mipi_di(ipu, params->csi_mem.mipi_vc, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       params->csi_mem.mipi_id, params->csi_mem.csi); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       params->csi_mem.csi)); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       _ipu_smfc_init(ipu, channel, 
      0, params->csi_mem.csi); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*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的意思。
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*CSI data (include compander) dest*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_init(ipu, channel, params->csi_mem.csi); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
/*最后通过_ipu_csi_init函数初始化csi。*/
 
  
/*上面的channel流程就是下图这种模式：数据从CSI中通过SMFC直接到达IDMAC，然后通过IDMAC来进行数据的存放等操作。
 
   
  
 
  
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case CSI_PRP_ENC_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_enc_mem.csi > 
      1) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) || 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == MEM_VDI_MEM)) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       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。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
      //增加ic的引用计数。 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       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设备。 */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_enc_mem.mipi_en) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= ( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_enc_mem.csi)); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_set_mipi_di(ipu, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_enc_mem.mipi_vc, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_enc_mem.mipi_id, 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_enc_mem.csi); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       } 
      else 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_enc_mem.csi)); 
     
     
    
 
  
/*这个channel没有用到smfc，所以不用初始化它，其他跟上面那个channel一样。设置IPU_CONF寄存器中的28,29位。如果是MIPI接口的话，还需要通过_ipu_csi_set_mipi_di函数来初始化MIPI相关的寄存器。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*CSI0/1 feed into IC*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~IPU_CONF_IC_INPUT; 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_enc_mem.csi) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_CSI_SEL; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       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设备了。
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*PRP skip buffer in memory, only valid when RWS_EN is true*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       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位清零。
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*CSI data (include compander) dest*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_init(ipu, channel, params->csi_prp_enc_mem.csi); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_prpenc(ipu, params, 
      true); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
/*最后通过_ipu_csi_init函数初始化csi，同时通过_ipu_ic_init_prpenc函数预处理编码，这个函数在ipu_ic.c中。*/
 
  
/*至此，这个CSI_PRP_ENC_MEMchannel简单分析完毕，它的流程如下图所示：
 
   
  
 
  
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case CSI_PRP_VF_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_vf_mem.csi > 
      1) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) || 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == MEM_VDI_MEM)) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu->using_ic_dirct_ch = CSI_PRP_VF_MEM; 
     
     
    
 
  
 
  
/*与上面那个CSI_PRP_ENC_MEMchannel一样，这个ipu->using_ic_dirct_ch只能置位成当前这个CSI_PRP_VF_MEMchannel。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
      //增加ic的引用计数。 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu->csi_channel[params->csi_prp_vf_mem.csi] = channel; 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_vf_mem.mipi_en) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= ( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_vf_mem.csi)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_set_mipi_di(ipu, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_vf_mem.mipi_vc, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_vf_mem.mipi_id, 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_vf_mem.csi); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       } 
      else 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~( 
      1 << (IPU_CONF_CSI0_DATA_SOURCE_OFFSET + 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       params->csi_prp_vf_mem.csi)); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      /*CSI0/1 feed into IC*/ 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~IPU_CONF_IC_INPUT; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      if (params->csi_prp_vf_mem.csi) 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_CSI_SEL; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf &= ~IPU_CONF_CSI_SEL; 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
      /*PRP skip buffer in memory, only valid when RWS_EN is true*/ 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1); 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg & ~FS_VF_IN_VALID, IPU_FS_PROC_FLOW1); 
     
     
    
 
  
/*与上一个函数不同的是，设置的IPU_FS_PROC_FLOW1寄存器的VF_IN_VALID位，原理是相同的。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*CSI data (include compander) dest*/ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_csi_init(ipu, channel, params->csi_prp_vf_mem.csi); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_prpvf(ipu, params, 
      true); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
 
  
/*除了最后一个函数，其他都与上一个case一样，最后一个函数_ipu_ic_init_prpvf同样在ipu_ic.c中。*/
 
  
/*这个CSI_PRP_VF_MEMchannel的流程如下所示：
 
   
  
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       case MEM_PRP_VF_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       if (params->mem_prp_vf_mem.graphics_combine_en) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       in_g_pixel_fmt = params->mem_prp_vf_mem.in_g_pixel_fmt; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       bad_pixfmt = 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_bad_alpha_pos(in_g_pixel_fmt); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       if (params->mem_prp_vf_mem.alpha_chan_en) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       if (bad_pixfmt) { 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, "bad pixel format " 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       "for graphics plane from " 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       "ch%d\n", sec_dma); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       goto err; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = true; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       ipu->sec_chan_en[IPU_CHAN_ID(channel)] = true; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
/*bad_pixfmt的意思可以在查看_ipu_ch_param_bad_alpha_pos函数的时候大致了解，在IPUv3IDMAC中对于32bpp的格式有个bug，所以对于32bpp的都返回true，对于其他返回false。*/
 
  

 
  
/*下面这个涉及到alpha通道的一些知识，
 
  
http://baike.baidu.com/link?url=8p8Z8B2o_qOdahK5nfH-9ZiGfcubcPFWVxVCxCWn3XEItoG2KDmTLUpObjQMIp59VvTLBpJNzHYs4-9N4O_KOq
 
  
《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号来置位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg | FS_VF_IN_VALID, IPU_FS_PROC_FLOW1); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_prpvf(ipu, params, 
      false); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      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结构体中。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_PRP_VF_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->using_ic_dirct_ch == CSI_PRP_VF_MEM) || 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == MEM_VDI_MEM) || 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == CSI_PRP_ENC_MEM)) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu->using_ic_dirct_ch = MEM_VDI_PRP_VF_MEM; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu->vdi_use_count++; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       reg &= ~FS_VDI_SRC_SEL_MASK; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg , IPU_FS_PROC_FLOW1); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_prp_vf_mem.graphics_combine_en) 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu->sec_chan_en[IPU_CHAN_ID(channel)] = 
      true; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_prpvf(ipu, params, 
      false); 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       _ipu_vdi_init(ipu, channel, params); 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      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中定义。*/
 
  
/*这个模式的流程是下面这张图：
 
   
  
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_PRP_VF_MEM_P: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_PRP_VF_MEM_N: 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_MEM_P: 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_MEM_N: 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       _ipu_vdi_init(ipu, channel, params); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
 
  
/*这几个channel不再分析了。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_VDI_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->using_ic_dirct_ch == CSI_PRP_VF_MEM) || 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == MEM_VDI_PRP_VF_MEM) || 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       (ipu->using_ic_dirct_ch == CSI_PRP_ENC_MEM)) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu->using_ic_dirct_ch = MEM_VDI_MEM; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu->vdi_use_count++; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       _ipu_vdi_init(ipu, channel, params); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
 
  
/*设置ipu_soc中的using_ic_dirct_ch，增加ic_use_count和vdi_use_count的引用计数，最终也是调用这个_ipu_vdi_init函数。这个函数中增加了vdi_use_count的引用计数，上面几个与这个channel相似的channel都没有增加这个引用计数。这个channel只使用了VDIC。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_ROT_VF_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu->rot_use_count++; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_rotate_vf(ipu, params); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      case MEM_PRP_ENC_MEM: 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_FS_PROC_FLOW1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg | FS_ENC_IN_VALID, IPU_FS_PROC_FLOW1); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_prpenc(ipu, params, 
      false); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      case MEM_ROT_ENC_MEM: 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       ipu->rot_use_count++; 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_rotate_enc(ipu, params); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
/*上面几个channel程序比较简单，就暂时不分析。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_PP_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_pp_mem.graphics_combine_en) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       in_g_pixel_fmt = params->mem_pp_mem.in_g_pixel_fmt; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       bad_pixfmt = 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_bad_alpha_pos(in_g_pixel_fmt); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_pp_mem.alpha_chan_en) { 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      if (bad_pixfmt) { 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "bad pixel format " 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      "for graphics plane from " 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      "ch%d\n", sec_dma); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = 
      true; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       ipu->sec_chan_en[IPU_CHAN_ID(channel)] = 
      true; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_pp(ipu, params); 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
 
  
 
  
/*这个channel与MEM_PRP_VF_MEMchannel类似，它也是根据params参数启用了sec_chan_en和thrd_chan_en。*/
 
  
/*
 
   
  
 
  
*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      case MEM_ROT_PP_MEM: 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_init_rotate_pp(ipu, params); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu->ic_use_count++; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       ipu->rot_use_count++; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      case MEM_DC_SYNC: 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_dc_sync.di > 
      1) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_di_assignment[ 
      1] = params->mem_dc_sync.di; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dc_init(ipu, 
      1, params->mem_dc_sync.di, 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dc_sync.interlaced, 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dc_sync.out_pixel_fmt); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu->di_use_count[params->mem_dc_sync.di]++; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_use_count++; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ipu->dmfc_use_count++; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
      case MEM_BG_SYNC: 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_dp_bg_sync.di > 
      1) { 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_dp_bg_sync.alpha_chan_en) 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
    
       ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = 
      true; 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_di_assignment[ 
      5] = params->mem_dp_bg_sync.di; 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dp_init(ipu, channel, params->mem_dp_bg_sync.in_pixel_fmt, 
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dp_bg_sync.out_pixel_fmt); 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dc_init(ipu, 
      5, params->mem_dp_bg_sync.di, 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dp_bg_sync.interlaced, 
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dp_bg_sync.out_pixel_fmt); 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
    
       ipu->di_use_count[params->mem_dp_bg_sync.di]++; 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_use_count++; 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
    
       ipu->dp_use_count++; 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
    
       ipu->dmfc_use_count++; 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
     
      case MEM_FG_SYNC: 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dp_init(ipu, channel, params->mem_dp_fg_sync.in_pixel_fmt, 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
    
       params->mem_dp_fg_sync.out_pixel_fmt); 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
      if (params->mem_dp_fg_sync.alpha_chan_en) 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       ipu->thrd_chan_en[IPU_CHAN_ID(channel)] = 
      true; 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_use_count++; 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
    
       ipu->dp_use_count++; 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       ipu->dmfc_use_count++; 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
     
      case DIRECT_ASYNC0: 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
     
      if (params->direct_async.di > 
      1) { 
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  56.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  57.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_di_assignment[ 
      8] = params->direct_async.di; 
     
     
    
  58.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dc_init(ipu, 
      8, params->direct_async.di, 
      false, IPU_PIX_FMT_GENERIC); 
     
     
    
  59.  
    
     
     
     
    
     
    
     
     
    
       ipu->di_use_count[params->direct_async.di]++; 
     
     
    
  60.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_use_count++; 
     
     
    
  61.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  62.  
    
     
     
     
    
     
    
     
     
     
      case DIRECT_ASYNC1: 
     
     
    
  63.  
    
     
     
     
    
     
    
     
     
     
      if (params->direct_async.di > 
      1) { 
     
     
    
  64.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  65.  
    
     
     
     
    
     
    
     
     
     
      goto err; 
     
     
    
  66.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  67.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  68.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_di_assignment[ 
      9] = params->direct_async.di; 
     
     
    
  69.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dc_init(ipu, 
      9, params->direct_async.di, 
      false, IPU_PIX_FMT_GENERIC); 
     
     
    
  70.  
    
     
     
     
    
     
    
     
     
    
       ipu->di_use_count[params->direct_async.di]++; 
     
     
    
  71.  
    
     
     
     
    
     
    
     
     
    
       ipu->dc_use_count++; 
     
     
    
  72.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  73.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  74.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "Missing channel initialization\n"); 
     
     
    
  75.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  76.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  77.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  78.  
    
     
     
     
    
     
    
     
     
    
       ipu->channel_init_mask |= 
      1L << IPU_CHAN_ID(channel); 
     
     
    
  79.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  80.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, ipu_conf, IPU_CONF); 
     
     
    
  81.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  82.  
    
     
     
     
    
     
    
     
     
    
       err: 
     
     
    
  83.  
    
     
     
     
    
     
    
     
     
    
       mutex_unlock(&ipu->mutex_lock); 
     
     
    
  84.  
    
     
     
     
    
     
    
     
     
     
      return ret; 
     
     
    
  85.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  86.  
    
     
     
     
    
     
    
     
     
    
       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函数来设置了。
 
 
 
 
 
  
4.3 ipu_init_channel_buffer函数的详细分析
 
 
 
 
 
  
ipu_init_channel_buffer函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      int32_t ipu_init_channel_buffer(struct ipu_soc *ipu, 
      ipu_channel_t channel, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      ipu_buffer_t type, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t pixel_fmt, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint16_t width, 
      uint16_t height, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      uint32_t stride, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      ipu_rotate_mode_t rot_mode, 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      dma_addr_t phyaddr_0, 
      dma_addr_t phyaddr_1, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      dma_addr_t phyaddr_2, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u, 
      uint32_t v) 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      uint32_t reg; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      uint32_t dma_chan; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      uint32_t burst_size; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       dma_chan = channel_2_dma(channel, type); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      if (!idma_is_valid(dma_chan)) 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
 
  
 
  
/*通过channel_2_dma函数将channel根据type提取出使用了哪个dmachannel。对于这个channel_2_dma函数，因为每个channel需要使用到dmachannel，在输入的时候可能使用，在输出的时候也可能使用，所以需要传入一个type类型来从channel中提取出所需要的dmachannel号。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (stride < width * bytes_per_pixel(pixel_fmt)) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       stride = width * bytes_per_pixel(pixel_fmt); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (stride % 
      4) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      "Stride not 32-bit aligned, stride = %d\n", stride); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
/*对传入的stride参数进行判断。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* IC & IRT channels' width must be multiple of 8 pixels */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if ((_ipu_is_ic_chan(dma_chan) || _ipu_is_irt_chan(dma_chan)) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       && (width % 
      8)) { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "Width must be 8 pixel multiple\n"); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*如果是IC和IRTchannel的话，函数传入的width参数必须是8pixels的整数倍，否则就返回错误。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_vdi_out_chan(dma_chan) && 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ((width < 
      16) || (height < 
      16) || (width % 
      2) || (height % 
      4))) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "vdi width/height limited err\n"); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      /* IPUv3EX and IPUv3M support triple buffer */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if ((!_ipu_is_trb_chan(ipu, dma_chan)) && phyaddr_2) { 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "Chan%d doesn't support triple buffer " 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      "mode\n", dma_chan); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这个函数比较绕，首先来看函数传入的参数里面有三个dma_addr_t类型的变量phyaddr_0，phyaddr_1和phyaddr_2。这三个变量每一个都对应一个buffer的基地址。_ipu_is_trb_chan函数是判断dma_chan是否支持3buffers，如果支持的话，就肯定不会执行下面的dev_err语句；如果不支持3buffers的话，那传入的参数里面phyaddr_2就必须为0,否则就会执行dev_err语句（都不支持3buffers了，那么第三个buffer的地址肯定为0）。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (!phyaddr_1 && phyaddr_2) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "Chan%d's buf1 physical addr is NULL for " 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      "triple buffer mode\n", dma_chan); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这个判断语句是phyaddr_1存在的话就肯定不会执行dev_err语句，如果phyaddr_1和phyaddr_2都不存在的话，就会报错。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       mutex_lock(&ipu->mutex_lock); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      /* Build parameter memory data for DMA channel */ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_init(ipu, dma_chan, pixel_fmt, width, height, stride, u, v, 
      0, phyaddr_0, phyaddr_1, phyaddr_2); 
     
     
    
 
  
/*在_ipu_ch_param_init函数内部，首先根据传入的pixel_fmt,width, height, stride, u, v, 0, phyaddr_0, phyaddr_1,phyaddr_2的值来设置一个structipu_ch_param类型的params变量，然后将这个变量通过fill_cpmem函数写到通过ipu,dma_chan这两个参数确定的CPMEM中。如果phyaddr_2参数不为空的话，还需要通过fill_cpmem函数将params的值写入ipu和sub_ch确定的寄存器的基址中。这个_ipu_ch_param_init函数很重要。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* Set correlative channel parameter of local alpha channel */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if ((_ipu_is_ic_graphic_chan(dma_chan) || 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_is_dp_graphic_chan(dma_chan)) && 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       (ipu->thrd_chan_en[IPU_CHAN_ID(channel)] == 
      true)) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_alpha_use_separate_channel(ipu, dma_chan, 
      true); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_alpha_buffer_memory(ipu, dma_chan); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_alpha_condition_read(ipu, dma_chan); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      /* fix alpha width as 8 and burst size as 16*/ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_alpha_width(ipu, dma_chan, 
      8); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_burst_size(ipu, dma_chan, 
      16); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       } 
      else 
      if (_ipu_is_ic_graphic_chan(dma_chan) && 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_pixel_format_has_alpha(pixel_fmt)) 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_alpha_use_separate_channel(ipu, dma_chan, 
      false); 
     
     
    
 
  
/*设置alpha通道的一些信息，上面这些子函数都分析了，他们就是设置dma_chan对应的channel的某些位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (rot_mode) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_rotation(ipu, dma_chan, rot_mode); 
     
     
    
 
  
/*设置rot_mode参数在dma_chan中对应的某些位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* IC and ROT channels have restriction of 8 or 16 pix burst length */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_ic_chan(dma_chan) || _ipu_is_vdi_out_chan(dma_chan)) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      if ((width % 
      16) == 
      0) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_burst_size(ipu, dma_chan, 
      16); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_burst_size(ipu, dma_chan, 
      8); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
      else 
      if (_ipu_is_irt_chan(dma_chan)) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_burst_size(ipu, dma_chan, 
      8); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_block_mode(ipu, dma_chan); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       } 
      else 
      if (_ipu_is_dmfc_chan(dma_chan)) { 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       burst_size = _ipu_ch_param_get_burst_size(ipu, dma_chan); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dmfc_set_wait4eot(ipu, dma_chan, width); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dmfc_set_burst_size(ipu, dma_chan, burst_size); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*根据不同的channel设置burstlength的不同值。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_disp_chan_is_interlaced(ipu, channel) || 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu->chan_is_interlaced[dma_chan]) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_interlaced_scan(ipu, dma_chan); 
     
     
    
 
  
/*设置interlaced参数。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_ic_chan(dma_chan) || _ipu_is_irt_chan(dma_chan) || 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_is_vdi_out_chan(dma_chan)) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       burst_size = _ipu_ch_param_get_burst_size(ipu, dma_chan); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_idma_init(ipu, dma_chan, width, height, burst_size, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       rot_mode); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/* 如果是 ic， irt或者 vdi_out channel的话，就需要调用_ipu_ic_idma_init函数来初始化ic和idma，这个函数在ipu_ic.c中定义。 */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      else 
      if (_ipu_is_smfc_chan(dma_chan)) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       burst_size = _ipu_ch_param_get_burst_size(ipu, dma_chan); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      /*  
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
       * This is different from IPUv3 spec, but it is confirmed  
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
       * in IPUforum that SMFC burst size should be NPB[6:3]  
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
       * when IDMAC works in 16-bit generic data mode.  
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
       */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (pixel_fmt == IPU_PIX_FMT_GENERIC) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      /* 8 bits per pixel */ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       burst_size = burst_size >> 
      4; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      else 
      if (pixel_fmt == IPU_PIX_FMT_GENERIC_16) 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      /* 16 bits per pixel */ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       burst_size = burst_size >> 
      3; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       burst_size = burst_size >> 
      2; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       _ipu_smfc_set_burst_size(ipu, channel, burst_size 
      -1); 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*如果是smfcchannel的话，就直接根据channel参数的值设置(burst_size)即可，_ipu_smfc_set_burst_size这个函数在ipu_capture.c中定义。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      switch (dma_chan) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      case 
      0: 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      case 
      1: 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      case 
      2: 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      case 
      3: 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_axi_id(ipu, dma_chan, ipu->ch0123_axi); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      case 
      23: 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_axi_id(ipu, dma_chan, ipu->ch23_axi); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      case 
      27: 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_axi_id(ipu, dma_chan, ipu->ch27_axi); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      case 
      28: 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_axi_id(ipu, dma_chan, ipu->ch28_axi); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_set_axi_id(ipu, dma_chan, ipu->normal_axi); 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*设置AXIprotocol id，这些AXIid是在ipu_probe函数中，从ipu_platform_type中获取到的。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (idma_is_set(ipu, IDMAC_CHA_PRI(dma_chan), dma_chan) && 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu->devtype == IPUv3H) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t reg = IDMAC_CH_LOCK_EN_1(ipu->devtype); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint32_t value = 
      0; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      switch (dma_chan) { 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      case 
      5: 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      case 
      11: 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      2; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      case 
      12: 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      4; 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      case 
      14: 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      6; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      case 
      15: 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      8; 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
      case 
      20: 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      10; 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
      case 
      21: 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      12; 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
     
      case 
      22: 
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      14; 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
     
      case 
      23: 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      16; 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
     
      case 
      27: 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      18; 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
     
      case 
      28: 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      20; 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
     
      case 
      45: 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      0; 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
      case 
      46: 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      2; 
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
     
      case 
      47: 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      4; 
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
     
      case 
      48: 
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      6; 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  56.  
    
     
     
     
    
     
    
     
     
     
      case 
      49: 
     
     
    
  57.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  58.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      8; 
     
     
    
  59.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  60.  
    
     
     
     
    
     
    
     
     
     
      case 
      50: 
     
     
    
  61.  
    
     
     
     
    
     
    
     
     
    
       reg = IDMAC_CH_LOCK_EN_2(ipu->devtype); 
     
     
    
  62.  
    
     
     
     
    
     
    
     
     
    
       value = 
      0x3 << 
      10; 
     
     
    
  63.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  64.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  65.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  66.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  67.  
    
     
     
     
    
     
    
     
     
    
       value |= ipu_idmac_read(ipu, reg); 
     
     
    
  68.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, value, reg); 
     
     
    
  69.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*设置idmac寄存器的一些参数。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_param_dump(ipu, dma_chan); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      if (phyaddr_2 && ipu->devtype >= IPUv3EX) { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_CHA_DB_MODE_SEL(dma_chan)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       reg &= ~idma_mask(dma_chan); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg, IPU_CHA_DB_MODE_SEL(dma_chan)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_TRB_MODE_SEL(ipu->devtype, dma_chan)); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       reg |= idma_mask(dma_chan); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg, 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_TRB_MODE_SEL(ipu->devtype, dma_chan)); 
     
     
    
 
  
/*上面这些步骤的意思是：如果（phyaddr_2&& ipu->devtype >=IPUv3EX）这个条件满足的话，就意味着这个channel支持triplebuffer MODE，所以先将寄存器中doublebuffer MODE的位清零，然后将triplebuffer MODE的位置位。至于是哪个寄存器。。。。通过IPU_CHA_DB_MODE_SEL这个宏可以看出来应该是CM寄存器。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* Set IDMAC third buffer's cpmem number */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      /* See __ipu_ch_get_third_buf_cpmem_num() for mapping */ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, 
      0x00444047L, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       IDMAC_SUB_ADDR_4(ipu->devtype)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, 
      0x46004241L, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       IDMAC_SUB_ADDR_3(ipu->devtype)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, 
      0x00000045L, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       IDMAC_SUB_ADDR_1(ipu->devtype)); 
     
     
    
 
  
/*设置idmac寄存器中关于triplebuffer的某些位*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* Reset to buffer 0 */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, tri_cur_buf_mask(dma_chan), 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_TRIPLE_CUR_BUF(ipu->devtype, dma_chan)); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_TRB_MODE_SEL(ipu->devtype, dma_chan)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       reg &= ~idma_mask(dma_chan); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_TRB_MODE_SEL(ipu->devtype, dma_chan)); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPU_CHA_DB_MODE_SEL(dma_chan)); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      if (phyaddr_1) 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       reg |= idma_mask(dma_chan); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       reg &= ~idma_mask(dma_chan); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg, IPU_CHA_DB_MODE_SEL(dma_chan)); 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      /* Reset to buffer 0 */ 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, idma_mask(dma_chan), 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHA_CUR_BUF(ipu->devtype, dma_chan)); 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       mutex_unlock(&ipu->mutex_lock); 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
     
      return 
      0; 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
    
       EXPORT_SYMBOL(ipu_init_channel_buffer); 
     
     
    
 
  
在这个函数中，有很多有特殊含义的行参，比如说stride，u_offset,v_offset等等，在这里分析的话，也不太懂是什么含义，不如在分析应用程序的时候，每个函数都有传入的实参值，那时候再具体分析。同时这个函数中用到了很多ipu_param_mem.h头文件中的函数，来填充CPMEM中的某一位或者某几位，下面就来分析ipu_param_mem.h这个头文件。
 
  
 
   
 
  
 
  
4.4 ipu_param_mem.h头文件分析
 
  
1.下面这两个结构体是本文件的核心结构体。
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      struct ipu_ch_param_word { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t data[ 
      5]; 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t res[ 
      3]; 
     
     
    
  4.  
    
     
     
    
       };  
     
     
    
  5.  
    
     
     struct ipu_ch_param { 
    
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      struct ipu_ch_param_word word[2]; 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
 
  
因为CPMEM是两个160位的word，所以每个word使用5个uint32_t类型来表示，同时有两个word。
 
  

 
  
2.这个宏暂时不分析，在后面用到的时候再分析。
 
  
#define ipu_ch_param_addr(ipu, ch) (((struct ipu_ch_param *)ipu->cpmem_base) + (ch))
 
  
 
  
3._param_word宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define _param_word(base, w) \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       (((struct ipu_ch_param *)(base))->word[(w)].data) 
     
     
    
 
  
 
  
这个宏有两个参数，第一个参数是一个起始地址值，它一般是一个指针，在宏中会进行强制类型转化；第二个参数是第几个word，看ipu_ch_param结构体，它的取值为0和1。
 
  
这个宏的意思是根据base这个起始地址值取到里面的第w个word的data数据段。
 
  
 
  
4.ipu_ch_param_set_field宏
 
  
#define ipu_ch_param_set_field(base, w, bit, size, v) { \ 
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i] |= (v) << off; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i + 
      1] |= (v) >> (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
这个宏有5个参数，前两个参数与_param_word宏中的参数相同，它们也确实是给_param_word宏使用的。第三个参数bit表示某一个数据在通过_param_word宏所找到的data数据段中的准确起始bit位，因为data数据段是uint32_tdata[5]的，所以这个值的范围为0～160。size表示数据所占的位数。v表示传入的数据字面值。
 
  
这个宏的意思是首先通过(bit)/32来计算出这个数据的起始bit在data数组成员中的哪一个（因为data数组有5个成员）。然后off表示这个数据在data数组成员中的偏移值。然后通过_param_word(base,w)[i]来找到对应的data数组成员。同时这个宏中也给出了这个数据所占的位数：size，如果bit所在的data数组成员放不下这么多size数的话，就需要在data数组中的下一个数组成员中存储剩下的bit。
 
   
   
  
 
  
注意在数据的存储过程中涉及到大端小端的问题，对大端小端的解释：http://www.cnblogs.com/wuyuegb2312/archive/2013/06/08/3126510.html#《轻松记住大端小端的含义（附对大端和小端的解释）》
 
  

 
  
以下面这个函数中的各个数据为例来解释一下：
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_params_set_packing(struct ipu_ch_param *p, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int red_width, 
      int red_offset, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int green_width, 
      int green_offset, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int blue_width, 
      int blue_offset, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      int alpha_width, 
      int alpha_offset) 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      /* Setup red width and offset */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      116, 
      3, red_width - 
      1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      128, 
      5, red_offset); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      /* Setup green width and offset */ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      119, 
      3, green_width - 
      1); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      133, 
      5, green_offset); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      /* Setup blue width and offset */ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      122, 
      3, blue_width - 
      1); 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      138, 
      5, blue_offset); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      /* Setup alpha width and offset */ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      125, 
      3, alpha_width - 
      1); 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      143, 
      5, alpha_offset); 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
首先以ipu_ch_param_set_field( p, 1, 116, 3, red_width – 1)为例：
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_set_field( base, w, bit, size, v) { \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i] |= (v) << off; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i + 
      1] |= (v) >> (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
解释：
 
  
i= 116/32= 3；
 
  
off= 116%32 = 20；
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define _param_word(base, w) \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       (((struct ipu_ch_param *)(base))->word[(w)].data) 
     
     
    
 
  
_param_word(base,w)[i] |= (v) << off
 
  
     ==>p->word[w].data[i]|= (v) << off
 
  
         ==>p->word[1].data[3] |= (red_width – 1)<<20;
 
  
 
  
如下图所示：
 
   
  
 
  
然后继续往下执行：
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      119, 
      3, green_width – 
      1); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      122, 
      3, blue_width – 
      1); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      125, 
      3, alpha_width - 
      1); 
     
     
    
 
  
同样，它最终就会在119的位置存储（green_width– 1），在122的位置存储（blue_width– 1），在125的位置存储（alpha_width– 1）。
 
  
它们详细表示如下：
 
   
  
 
  
同样对于
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      128, 
      5, red_offset); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      133, 
      5, green_offset); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      138, 
      5, blue_offset); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      143, 
      5, alpha_offset); 
     
     
    
 
  
它们详细表示如下：
 
   
  
 
  
再分析一个ipu_ch_param_set_field函数中w=1, bit = 125, size = 13 的情况，对大端小端理解的更清楚。
 
  
i= 125/32 = 3；
 
  
off= 125%32 = 29；
 
  
_param_word(base,w)[i] |= (v) << off
 
  
     ==>p->word[w].data[i] |= (v) << off
 
  
         ==>p->word[1].data[3] |= (v)<<29;
 
  
if(((bit)+(size)-1)/32 > i) （125+12）/32= 4 > 3成立，所以会执行if下面的语句:
 
  
_param_word(base,w)[i + 1] |= (v) >> (off ? (32 - off) : 0);
 
  
     ==>_param_word(base,w)[4] |= (v) >> 3
 
  
         ==>p->word[1].data[4]|=(v) >> 3
 
  
重要的部分我用红色标出了，
 
   
  
 
  
从这里可以看出来，它的存储方式是将v的前10位存在了data[4]中，而v的后3位存在了data[3]中，从这里可以看出来，数据的存储方式是小端模式。
 
  
 
  
5.ipu_ch_param_set_field_io宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_set_field_io(base, w, bit, size, v) { \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      unsigned reg_offset; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       u32 temp; \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       reg_offset = 
      sizeof(struct ipu_ch_param_word) * w / 
      4; \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       reg_offset += i; \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       temp = readl((u32 *)base + reg_offset); \ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       temp |= (v) << off; \ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       writel(temp, (u32 *)base + reg_offset); \ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       reg_offset++; \ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       temp = readl((u32 *)base + reg_offset); \ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       temp |= (v) >> (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       writel(temp, (u32 *)base + reg_offset); \ 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个宏根据base，w，bit的值计算出寄存器的位置，然后将v的值写进去。
 
  

 
  
但是这个ipu_ch_param_set_field_io宏与上面那个ipu_ch_param_set_field宏有什么不同呢？
 
  
往下搜索源码可以发现，虽然这两个宏的第一个参数都是base，但是他们两个不相同：
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      125, 
      13, width – 
      1); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      113, 
      1, 
      1); 
     
     
    
 
  
而这个ipu_ch_param_addr宏就是本文件开始的那个宏
 
  
#defineipu_ch_param_addr(ipu, ch) (((struct ipu_ch_param *)ipu->cpmem_base)+ (ch))
 
  
这个宏根据ipu和ch两个参数来找到对应寄存器的基址，具体来说就是根据ipu_soc结构体里面存放的cpmem_base寄存器的地址，ch是一般是uint32_t类型的dmachannel，通过这两个参数来找到对应寄存器的基地址。所以这个cpmem_base寄存器是设置dmachannel的关键寄存器。
 
  
对比上面两条语句，可以发现ipu_ch_param_set_field宏用于设置structipu_ch_param结构体参数params中某些位的值。而ipu_ch_param_set_field_io宏根据传入的ipu和ch参数来找到某个寄存器的基址，然后修改这个寄存器中的某些位。
 
  
以下的几个宏都与这两种情况类似。
 
  
 
  
6.ipu_ch_param_mod_field宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_mod_field(base, w, bit, size, v) { \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       u32 mask = ( 
      1UL << size) - 
      1; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       u32 temp = _param_word(base, w)[i]; \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       temp &= ~(mask << off); \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i] = temp | (v) << off; \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       temp = _param_word(base, w)[i + 
      1]; \ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       temp &= ~(mask >> ( 
      32 - off)); \ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       _param_word(base, w)[i + 
      1] = \ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       temp | ((v) >> (off ? ( 
      32 - off) : 
      0)); \ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数首先为size大小设置掩码，比如size=7,这个mask就等于111111（二进制）,然后通过temp&= ~(mask << off)将这几位都清零，最后再通过temp| (v) << off将v的值写到这几位中。修改某些位值的时候，一定要先清零了再写。
 
  
 
  
7.ipu_ch_param_mod_field_io宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_mod_field_io(base, w, bit, size, v) { \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       u32 mask = ( 
      1UL << size) - 
      1; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      unsigned reg_offset; \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       u32 temp; \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       reg_offset = 
      sizeof(struct ipu_ch_param_word) * w / 
      4; \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       reg_offset += i; \ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       temp = readl((u32 *)base + reg_offset); \ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       temp &= ~(mask << off); \ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       temp |= (v) << off; \ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       writel(temp, (u32 *)base + reg_offset); \ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       reg_offset++; \ 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       temp = readl((u32 *)base + reg_offset); \ 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       temp &= ~(mask >> ( 
      32 - off)); \ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       temp |= ((v) >> (off ? ( 
      32 - off) : 
      0)); \ 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       writel(temp, (u32 *)base + reg_offset); \ 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个宏与上一个宏类似，修改寄存器中某些位的值。
 
  
 
  
8.ipu_ch_param_read_field宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_read_field(base, w, bit, size) ({ \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       u32 temp2; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       u32 mask = ( 
      1UL << size) - 
      1; \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       u32 temp1 = _param_word(base, w)[i]; \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       temp1 = mask & (temp1 >> off); \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       temp2 = _param_word(base, w)[i + 
      1]; \ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       temp2 &= mask >> (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       temp1 |= temp2 << (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       temp1; \ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       }) 
     
     
    
 
  
这个宏的意思是读取某些位的值，这个宏最后的结果是temp1的值。
 
  

 
  
9.ipu_ch_param_read_field_io宏
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      #define ipu_ch_param_read_field_io(base, w, bit, size) ({ \  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       u32 temp1, temp2; \ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int i = (bit) / 
      32; \ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int off = (bit) % 
      32; \ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       u32 mask = ( 
      1UL << size) - 
      1; \ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      unsigned reg_offset; \ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       reg_offset = 
      sizeof(struct ipu_ch_param_word) * w / 
      4; \ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       reg_offset += i; \ 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       temp1 = readl((u32 *)base + reg_offset); \ 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       temp1 = mask & (temp1 >> off); \ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      if (((bit)+(size) 
      -1)/ 
      32 > i) { \ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       reg_offset++; \ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       temp2 = readl((u32 *)base + reg_offset); \ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       temp2 &= mask >> (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       temp1 |= temp2 << (off ? ( 
      32 - off) : 
      0); \ 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       } \ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       temp1; \ 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       }) 
     
     
    
 
  
这个宏的意思是读取某个寄存器中某些位的值，最后的结果是temp1。
 
  
 
  
10.__ipu_ch_get_third_buf_cpmem_num函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      int __ipu_ch_get_third_buf_cpmem_num( 
      int ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      switch (ch) { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      case 
      8: 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      return 
      64; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      case 
      9: 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      return 
      65; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      case 
      10: 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      return 
      66; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      case 
      13: 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      return 
      67; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      case 
      21: 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      return 
      68; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      case 
      23: 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      return 
      69; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      case 
      27: 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      return 
      70; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      case 
      28: 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      return 
      71; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
      return 
      0; 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数的大致意思是从函数传入的参数ch中获取到第三个buffer的起始地址。
 
  

 
  
11._ipu_ch_params_set_packing函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_params_set_packing(struct ipu_ch_param *p, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int red_width, 
      int red_offset, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int green_width, 
      int green_offset, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int blue_width, 
      int blue_offset, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      int alpha_width, 
      int alpha_offset) 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      /* Setup red width and offset */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      116, 
      3, red_width - 
      1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      128, 
      5, red_offset); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      /* Setup green width and offset */ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      119, 
      3, green_width - 
      1); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      133, 
      5, green_offset); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      /* Setup blue width and offset */ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      122, 
      3, blue_width - 
      1); 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      138, 
      5, blue_offset); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      /* Setup alpha width and offset */ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      125, 
      3, alpha_width - 
      1); 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(p, 
      1, 
      143, 
      5, alpha_offset); 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数在前面分析了，它主要目的是设置第一个参数p里面的red_width，red_offset，green_width，green_offset等信息。这个函数在_ipu_ch_param_init函数中调用，比如下面这样：
 
  
_ipu_ch_params_set_packing(&params,5, 0, 6, 5, 5, 11, 8, 16);
 
  
通过这样调用，就分别设置了params中的RGB的信息，从上面可以看出来是RGB565格式的。
 
  
_ipu_ch_params_set_packing(&params,4, 4, 4, 8, 4, 12, 4, 0);
 
  
这样调用设置的是RGBA4444的格式。
 
  
 
  
12._ipu_ch_param_dump函数
 
  
这个函数是输出ipu_ch_param中的一些信息，就不分析了。
 
  
 
  
13.fill_cpmem函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static inline void fill_cpmem(struct ipu_soc *ipu, int ch, struct ipu_ch_param *params)  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int i, w; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      void *addr = ipu_ch_param_addr(ipu, ch); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      /* 2 words, 5 valid data */ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      for (w = 
      0; w < 
      2; w++) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      for (i = 
      0; i < 
      5; i++) { 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       writel(params->word[w].data[i], addr); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       addr += 
      4; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       addr += 
      12; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数首先通过ipu_ch_param_addr函数根据ipu和ch参数取得dmachannel的基址，然后将params参数里面两个word里面的data数据填充到获得的这个基址中。这个函数被_ipu_ch_param_init函数中调用。
 
  

 
  
14._ipu_ch_param_init函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_init(struct ipu_soc *ipu, 
      int ch, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t pixel_fmt, 
      uint32_t width, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t height, 
      uint32_t stride, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u, 
      uint32_t v, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      uint32_t uv_stride, 
      dma_addr_t addr0, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      dma_addr_t addr1, 
      dma_addr_t addr2) 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u_offset = 
      0; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      uint32_t v_offset = 
      0; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      uint32_t bs = 
      0; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      struct ipu_ch_param params; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      memset(&params<style type= 
      "text/css">p { margin-bottom: 
      0.25cm; line-height: 
      120%; }a:link { }&params</style>, 
      0, 
      sizeof(params)); 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>&params<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      0, 
      125, 
      13, width - 
      1); 
     
     
    
 
  
/*将params参数里面的word[0]里面的125位到138位设置为(width- 1) */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) && !ipu->vdoa_en) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>&params<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      0, 
      138, 
      12, (height / 
      2) - 
      1); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>&para<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>ms, 
      1, 
      102, 
      14, (stride * 
      2) – 
      1); 
     
     
    
 
  
/*将params参数里面的word[0]里面的138位到150位设置为((height/ 2) - 1) */
 
  
/*将params参数里面的word[1]里面的102位到116位设置为((stride* 2) - 1) */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      /* note: for vdoa+vdi- ch8/9/10, always use band mode */ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"></span>&para<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>ms, 
      0, 
      138, 
      12, height - 
      1); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       <span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span> ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>&para<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>ms<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      102, 
      14, stride - 
      1); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*将params参数里面的word[0]里面的138位到150位设置为(height- 1) */
 
  
/*将params参数里面的word[1]里面的102位到116位设置为(stride- 1) */
 
  
如果channel是8/9/10的话，从注释上来看是vdoa+vdichannel，用的是bandmode，会将params那几位设置成height/2和stride*2。
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* EBA is 8-byte aligned */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>&para<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>ms<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      0, 
      29, addr0 >> 
      3); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "font-family:Courier 10 Pitch;">&params</span>, 
      1, 
      29, 
      29, addr1 >> 
      3); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (addr0% 
      8) 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's EBA0 is not 8-byte aligned\n", ch); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      if (addr1% 
      8) 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's EBA1 is not 8-byte aligned\n", ch); 
     
     
    
 
  
/*将params参数里面的word[1]里面的0位到29位设置为(addr0>> 3)，29位到58位设置成addr1>> 3。原因是EBA是8字节对齐的，后面需要分析这里。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      switch (pixel_fmt) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC: 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      /*Represents 8-bit Generic data */ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      0, 
      107, 
      3, 
      5); 
      /* bits/pixel */ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      85, 
      4, 
      6); 
      /* pix format */ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      78, 
      7, 
      63); 
      /* burst size */ 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC_16: 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      /* Represents 16-bit generic data */ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<style type= 
      "text/css">p { margin-bottom: 
      0.25cm; line-height: 
      120%; }a:link { }&params</style><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      85, 
      4, 
      6); 
      /* pix format */ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(<span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span><span style= 
      "font-family:Courier 10 Pitch;">&params</span><span style= 
      "background: transparent"><span style= 
      "font-family:Courier 10 Pitch;"><span style= 
      "font-size:12px;"><span style= 
      "background: transparent"></span></span></span></span>, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC_32: 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      /*Represents 32-bit Generic data */ 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB565: 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      5, 
      0, 
      6, 
      5, 
      5, 
      11, 
      8, 
      16); 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGRA4444: 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      4, 
      4, 
      4, 
      8, 
      4, 
      12, 
      4, 
      0); 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGRA5551: 
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      5, 
      1, 
      5, 
      6, 
      5, 
      11, 
      1, 
      0); 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGR24: 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      1); 
      /* bits/pixel */ 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      19); 
      /* burst size */ 
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      0, 
      8, 
      8, 
      8, 
      16, 
      8, 
      24); 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB24: 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV444: 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      1); 
      /* bits/pixel */ 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      19); 
      /* burst size */ 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      16, 
      8, 
      8, 
      8, 
      0, 
      8, 
      24); 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_VYU444: 
     
     
    
  56.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      1); 
      /* bits/pixel */ 
     
     
    
  57.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  58.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      19); 
      /* burst size */ 
     
     
    
  59.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  60.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      8, 
      8, 
      0, 
      8, 
      16, 
      8, 
      24); 
     
     
    
  61.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  62.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_AYUV: 
     
     
    
  63.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      0); 
      /* bits/pixel */ 
     
     
    
  64.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  65.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  66.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  67.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      8, 
      8, 
      16, 
      8, 
      24, 
      8, 
      0); 
     
     
    
  68.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  69.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGRA32: 
     
     
    
  70.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGR32: 
     
     
    
  71.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      0); 
      /* bits/pixel */ 
     
     
    
  72.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  73.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  74.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  75.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      8, 
      8, 
      16, 
      8, 
      24, 
      8, 
      0); 
     
     
    
  76.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  77.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGBA32: 
     
     
    
  78.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB32: 
     
     
    
  79.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      0); 
      /* bits/pixel */ 
     
     
    
  80.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  81.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  82.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  83.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      24, 
      8, 
      16, 
      8, 
      8, 
      8, 
      0); 
     
     
    
  84.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  85.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_ABGR32: 
     
     
    
  86.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      0); 
      /* bits/pixel */ 
     
     
    
  87.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      7); 
      /* pix format */ 
     
     
    
  88.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  89.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  90.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ch_params_set_packing(¶ms, 
      8, 
      0, 
      8, 
      8, 
      8, 
      16, 
      8, 
      24); 
     
     
    
  91.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  92.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_UYVY: 
     
     
    
  93.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  94.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      0xA); 
      /* pix format */ 
     
     
    
  95.  
    
     
     
     
    
     
    
     
     
     
      if ((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) { 
     
     
    
  96.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  97.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  98.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  99.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  100.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  101.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUYV: 
     
     
    
  102.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      107, 
      3, 
      3); 
      /* bits/pixel */ 
     
     
    
  103.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      0x8); 
      /* pix format */ 
     
     
    
  104.  
    
     
     
     
    
     
    
     
     
     
      if ((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) { 
     
     
    
  105.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->vdoa_en) { 
     
     
    
  106.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
     
     
    
  107.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  108.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
     
     
    
  109.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  110.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  111.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  112.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  113.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  114.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV420P2: 
     
     
    
  115.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV420P: 
     
     
    
  116.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      2); 
      /* pix format */ 
     
     
    
  117.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  118.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  119.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  120.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  121.  
    
     
     
     
    
     
    
     
     
    
       u_offset = stride * height; 
     
     
    
  122.  
    
     
     
     
    
     
    
     
     
    
       v_offset = u_offset + (uv_stride * height / 
      2); 
     
     
    
  123.  
    
     
     
     
    
     
    
     
     
     
      if ((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) { 
     
     
    
  124.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  125.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = uv_stride* 
      2; 
     
     
    
  126.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  127.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_smfc_chan(ch) && 
     
     
    
  128.  
    
     
     
     
    
     
    
     
     
    
       ipu->smfc_idmac_12bit_3planar_bs_fixup) 
     
     
    
  129.  
    
     
     
     
    
     
    
     
     
    
       bs = 
      15; 
     
     
    
  130.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  131.  
    
     
     
     
    
     
    
     
     
    
       bs = 
      31; 
     
     
    
  132.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, bs); 
      /* burst size */ 
     
     
    
  133.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  134.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  135.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YVU420P: 
     
     
    
  136.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      2); 
      /* pix format */ 
     
     
    
  137.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  138.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  139.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  140.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  141.  
    
     
     
     
    
     
    
     
     
    
       v_offset = stride * height; 
     
     
    
  142.  
    
     
     
     
    
     
    
     
     
    
       u_offset = v_offset + (uv_stride * height / 
      2); 
     
     
    
  143.  
    
     
     
     
    
     
    
     
     
     
      if ((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) { 
     
     
    
  144.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
      /* burst size */ 
     
     
    
  145.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = uv_stride* 
      2; 
     
     
    
  146.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  147.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_smfc_chan(ch) && 
     
     
    
  148.  
    
     
     
     
    
     
    
     
     
    
       ipu->smfc_idmac_12bit_3planar_bs_fixup) 
     
     
    
  149.  
    
     
     
     
    
     
    
     
     
    
       bs = 
      15; 
     
     
    
  150.  
    
     
     
     
    
     
    
     
     
     
      else 
     
     
    
  151.  
    
     
     
     
    
     
    
     
     
    
       bs = 
      31; 
     
     
    
  152.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, bs); 
      /* burst size */ 
     
     
    
  153.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  154.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  155.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YVU422P: 
     
     
    
  156.  
    
     
     
     
    
     
    
     
     
     
      /* BPP & pixel format */ 
     
     
    
  157.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      1); 
      /* pix format */ 
     
     
    
  158.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  159.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  160.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  161.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  162.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  163.  
    
     
     
     
    
     
    
     
     
    
       v_offset = (v == 
      0) ? stride * height : v; 
     
     
    
  164.  
    
     
     
     
    
     
    
     
     
    
       u_offset = (u == 
      0) ? v_offset + v_offset / 
      2 : u; 
     
     
    
  165.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  166.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV422P: 
     
     
    
  167.  
    
     
     
     
    
     
    
     
     
     
      /* BPP & pixel format */ 
     
     
    
  168.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      1); 
      /* pix format */ 
     
     
    
  169.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  170.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  171.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  172.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  173.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  174.  
    
     
     
     
    
     
    
     
     
    
       u_offset = (u == 
      0) ? stride * height : u; 
     
     
    
  175.  
    
     
     
     
    
     
    
     
     
    
       v_offset = (v == 
      0) ? u_offset + u_offset / 
      2 : v; 
     
     
    
  176.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  177.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV444P: 
     
     
    
  178.  
    
     
     
     
    
     
    
     
     
     
      /* BPP & pixel format */ 
     
     
    
  179.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      0); 
      /* pix format */ 
     
     
    
  180.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  181.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride; 
     
     
    
  182.  
    
     
     
     
    
     
    
     
     
    
       u_offset = (u == 
      0) ? stride * height : u; 
     
     
    
  183.  
    
     
     
     
    
     
    
     
     
    
       v_offset = (v == 
      0) ? u_offset * 
      2 : v; 
     
     
    
  184.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  185.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_NV16: 
     
     
    
  186.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      1); 
      /* pix format */ 
     
     
    
  187.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  188.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride; 
     
     
    
  189.  
    
     
     
     
    
     
    
     
     
    
       u_offset = (u == 
      0) ? stride * height : u; 
     
     
    
  190.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  191.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_NV12: 
     
     
    
  192.  
    
     
     
     
    
     
    
     
     
     
      /* BPP & pixel format */ 
     
     
    
  193.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      85, 
      4, 
      4); 
      /* pix format */ 
     
     
    
  194.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride; 
     
     
    
  195.  
    
     
     
     
    
     
    
     
     
    
       u_offset = (u == 
      0) ? stride * height : u; 
     
     
    
  196.  
    
     
     
     
    
     
    
     
     
     
      if ((ch == 
      8) || (ch == 
      9) || (ch == 
      10)) { 
     
     
    
  197.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->vdoa_en) { 
     
     
    
  198.  
    
     
     
     
    
     
    
     
     
     
      /* one field buffer, memory width 64bits */ 
     
     
    
  199.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      63); 
     
     
    
  200.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  201.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      15); 
     
     
    
  202.  
    
     
     
     
    
     
    
     
     
     
      /* top/bottom field in one buffer*/ 
     
     
    
  203.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = uv_stride* 
      2; 
     
     
    
  204.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  205.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  206.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      78, 
      7, 
      31); 
      /* burst size */ 
     
     
    
  207.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  208.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  209.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  210.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "mxc ipu: unimplemented pixel format\n"); 
     
     
    
  211.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  212.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  213.  
    
     
     
     
    
     
    
     
     
     
      /*set burst size to 16*/ 
     
     
    
 
  
/*根据函数传入的pixel_fmt参数的至来决定设置params里面的哪些位。从这个switch语句中可以看出来params参数里面word[0]里面从107位开始的几位决定bits/pixel，word[1]里面从85位开始的几位决定pixformat，word[1]里面从78位开始的几位决定burstsize。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      128, 
      14, uv_stride - 
      1); 
     
     
    
 
  
/*如果uv_stride存在的话，就设置params参数里面的word[1]的128位到142位的值为(uv_stride- 1) */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* Get the uv offset from user when need cropping */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (u || v) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       u_offset = u; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       v_offset = v; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      /* UBO and VBO are 22-bit and 8-byte aligned */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (u_offset/ 
      8 > 
      0x3fffff) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's U offset exceeds IPU limitation\n", ch); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      if (v_offset/ 
      8 > 
      0x3fffff) 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's V offset exceeds IPU limitation\n", ch); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      if (u_offset% 
      8) 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's U offset is not 8-byte aligned\n", ch); 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      if (v_offset% 
      8) 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's V offset is not 8-byte aligned\n", ch); 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      46, 
      22, u_offset / 
      8); 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      0, 
      68, 
      22, v_offset / 
      8); 
     
     
    
 
  
/*上面这一段代码是设置u_offset和v_offset的值。他俩分别位于params->word[0]里面的46～68和68～90位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       dev_dbg(ipu->dev, 
      "initializing idma ch %d @ %p\n", ch, ipu_ch_param_addr(ipu, ch)); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       fill_cpmem(ipu, ch, ¶ms); 
     
     
    
 
  
/*辛辛苦苦设置好了params的值，肯定需要将它使用起来，就是通过这个函数来将params填充到根据ipu和ch参数找到的基址中。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (addr2) { 
      //在ipu_common.c中调用的_ipu_ch_param_init函数中有addr2这个值。 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
 
   
   
  
/*通过__ipu_ch_get_third_buf_cpmem_num函数来找到第三个buffer的基址。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      0, 
      29, addr2 >> 
      3); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field(¶ms, 
      1, 
      29, 
      29, 
      0); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      if (addr2% 
      8) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's sub-CPMEM entry%d EBA0 is not " 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      "8-byte aligned\n", ch, sub_ch); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       dev_dbg(ipu->dev, 
      "initializing idma ch %d @ %p sub cpmem\n", ch, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_addr(ipu, sub_ch)); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       fill_cpmem(ipu, sub_ch, ¶ms); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
最后这些设置是在某些情况下，比如之前分析过，可能会将几个channel一起启用。这个函数被ipu_common.c中的ipu_init_channel_buffer函数所调用。
 
  

 
  
15._ipu_ch_param_set_burst_size函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_burst_size(struct ipu_soc *ipu, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t ch, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint16_t burst_pixels) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      78, 
      7, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       burst_pixels - 
      1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      78, 
      7, 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       burst_pixels - 
      1); 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
这个函数用来设置或修改burst_size的值。因为在_ipu_ch_param_init初始化函数中，已经根据pixel_fmt的值设置了burst_size的初始值，在这里可以继续通过ipu和ch的值来修改他们的burst_size。这个函数被ipu_common.c中的ipu_init_channel_buffer函数所调用。
 
  
 
  
16._ipu_ch_param_get_burst_size函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      int _ipu_ch_param_get_burst_size(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      return ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      78, 
      7) + 
      1; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
通过ipu和ch参数找到对应的寄存器然后读取它的值。这个函数被ipu_common.c中的ipu_init_channel_buffer函数所调用。
 
  

 
  
17._ipu_ch_param_get_bpp函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      int _ipu_ch_param_get_bpp(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      return ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      107, 
      3); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
通过ipu和ch参数找到对应的寄存器然后读取它的值。
 
  
 
  
18._ipu_ch_param_set_buffer函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_buffer(struct ipu_soc *ipu, 
      uint32_t ch, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      int bufNum, 
      dma_addr_t phyaddr) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (bufNum == 
      2) { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      if (ch <= 
      0) 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       bufNum = 
      0; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      29 * bufNum, 
      29, 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       phyaddr / 
      8); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
首先根据ipu和ch来获取基址，然后根据传入的bufNum参数来决定修改基址中的哪些位。这个函数被ipu_common.c中的ipu_update_channel_buffer函数调用。根据手册上面可以看出来，关于buffer的设置是在word[1]中从0～28,59～57，而且根据后面的分析，对于双buffer模式，这个bufNum的取值是0或者1.
 
  

 
  
19._ipu_ch_param_set_rotation函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_rotation(struct ipu_soc *ipu, 
      uint32_t ch, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      ipu_rotate_mode_t rot) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       u32 temp_rot = bitrev8(rot) >> 
      5; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      119, 
      3, temp_rot); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      119, 
      3, temp_rot); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
 
  
 
  
设置rotation参数，这个函数首先根据rot的值通过bitrev8函数从byte_rev_table数组中取出对应的值，然后将那个值设置到word[0]的119～121位。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
  
 
  
20._ipu_ch_param_set_block_mode函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_block_mode(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      117, 
      2, 
      1); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      117, 
      2, 
      1); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
设置block_mode参数，这个block_mode参数应该是位于word[0]里面的117～119位。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
  

 
  
21._ipu_ch_param_set_alpha_use_separate_channel函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_alpha_use_separate_channel(struct ipu_soc *ipu, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t ch, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      bool option) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      if (option) { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      89, 
      1, 
      1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      89, 
      1, 
      0); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*根据option这个bool类型的值来设置ch对应的基址中word[1]的89位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      if (option) { 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      89, 
      1, 
      1); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
      else { 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      89, 
      1, 
      0); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
如果有第三个buffer的话，就设置sub_ch对应的基址中word[1]的89位。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
  

 
  
22._ipu_ch_param_set_alpha_condition_read函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_alpha_condition_read(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      149, 
      1, 
      1); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      149, 
      1, 
      1); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
这个函数的名字里面有read，但是里面调用的是ipu_ch_param_mod_field_io函数，他用来将ch对应的基址里面的word[1]的149位修改为1。如果有sub_ch的话，就同时修改sub_ch所对应的基址。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
  
 
  
23._ipu_ch_param_set_alpha_buffer_memory函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_alpha_buffer_memory(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int alp_mem_idx; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      switch (ch) { 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      case 
      14: 
      /* PRP graphic */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       alp_mem_idx = 
      0; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      case 
      15: 
      /* PP graphic */ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       alp_mem_idx = 
      1; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      case 
      23: 
      /* DP BG SYNC graphic */ 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       alp_mem_idx = 
      4; 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      case 
      27: 
      /* DP FG SYNC graphic */ 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       alp_mem_idx = 
      2; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "unsupported correlative channel of local " 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      "alpha channel\n"); 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*根据ch的值设置alp_mem_idx的值。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      90, 
      3, alp_mem_idx); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      90, 
      3, alp_mem_idx); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
   
   
  
这个函数首先根据ch的值来确定alp_mem_idx。然后调用ipu_ch_param_mod_field_io将ch对应基址里面的word[1]里面的90～93位修改成alp_mem_idx的值。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
   
   
  
 
  
24._ipu_ch_param_set_interlaced_scan函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_interlaced_scan(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       u32 stride; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      113, 
      1, 
      1); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch > 
      0) 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      113, 
      1, 
      1); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       stride = ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      102, 
      14) + 
      1; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      /* ILO is 20-bit and 8-byte aligned */ 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      if (stride/ 
      8 > 
      0xfffff) 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's ILO exceeds IPU limitation\n", ch); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      if (stride% 
      8) 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's ILO is not 8-byte aligned\n", ch); 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      58, 
      20, stride / 
      8); 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch > 
      0) 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      58, 
      20, 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       stride / 
      8); 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       stride *= 
      2; 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      102, 
      14, stride - 
      1); 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch > 
      0) 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      102, 
      14, 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
    
       stride - 
      1); 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
   
   
  
首先通过ipu_ch_param_set_field_io函数将ch对应基址里面word[0]的113位设为1。如果存在sub_ch的话，将sub_ch对应的基址里面word[0]的113位设为1。之后通过ipu_ch_param_read_field_io函数读取ch对应基址里面word[1]的102～116位的值来求出stride的值。之后通过ipu_ch_param_mod_field_io函数将ch对应基址里面的word[1]的58～78位设置为(stride/ 8)，将ch对应基址里面的word[1]的102～116位设置为(stride-1)，如果存在sub_ch的话需要做同样的操作。这个函数被ipu_common.c中的ipu_init_channel_buffer函数调用。
 
  

 
  
25._ipu_ch_param_set_axi_id函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_axi_id(struct ipu_soc *ipu, 
      uint32_t ch, 
      uint32_t id) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       id %= 
      4; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      93, 
      2, id); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      93, 
      2, id); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
根据传入的id参数来设置ch对应的基址里面word[1]的93～94位，这一位是关于axi_id的。
 
  
 
  
26._ipu_ch_param_get_axi_id函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      int _ipu_ch_param_get_axi_id(struct ipu_soc *ipu, 
      uint32_t ch) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      return ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      93, 
      2); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数就是读取ch对应的基址里面word[1]的93～94位。这个函数被ipu_common.c中的ipu_ch_param_get_axi_id函数调用。
 
  

 
  
27.__ipu_ch_offset_calc函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      int __ipu_ch_offset_calc( 
      uint32_t pixel_fmt, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t width, 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t height, 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint32_t stride, 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      uint32_t v, 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      uint32_t uv_stride, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      uint32_t vertical_offset, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      uint32_t horizontal_offset, 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      uint32_t *u_offset, 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      uint32_t *v_offset) 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u_fix = 
      0; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      uint32_t v_fix = 
      0; 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      switch (pixel_fmt) { 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC: 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC_16: 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GENERIC_32: 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB565: 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGR24: 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB24: 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV444: 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGRA32: 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGR32: 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGBA32: 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB32: 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_ABGR32: 
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_UYVY: 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUYV: 
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU32_SB_ST: 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU32_SB_SRT: 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU32_ST: 
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU32_SRT: 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU16_SB_ST: 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU16_SB_SRT: 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU16_ST: 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_GPU16_SRT: 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = 
      0; 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = 
      0; 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV420P2: 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV420P: 
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset / 
      2) + 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2; 
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = *u_offset + (uv_stride * height / 
      2); 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset / 
      2) + 
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset / 
      2) - 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  56.  
    
     
     
     
    
     
    
     
     
    
       v_fix = v ? (v + (uv_stride * vertical_offset / 
      2) + 
     
     
    
  57.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset / 
      2) - 
     
     
    
  58.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  59.  
    
     
     
     
    
     
    
     
     
    
       *v_offset; 
     
     
    
  60.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  61.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YVU420P: 
     
     
    
  62.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  63.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  64.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  65.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  66.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  67.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset / 
      2) + 
     
     
    
  68.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2; 
     
     
    
  69.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = *v_offset + (uv_stride * height / 
      2); 
     
     
    
  70.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset / 
      2) + 
     
     
    
  71.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset / 
      2) - 
     
     
    
  72.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  73.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  74.  
    
     
     
     
    
     
    
     
     
    
       v_fix = v ? (v + (uv_stride * vertical_offset / 
      2) + 
     
     
    
  75.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset / 
      2) - 
     
     
    
  76.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  77.  
    
     
     
     
    
     
    
     
     
    
       *v_offset; 
     
     
    
  78.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  79.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YVU422P: 
     
     
    
  80.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  81.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  82.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  83.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  84.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  85.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset) + 
     
     
    
  86.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2; 
     
     
    
  87.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = *v_offset + uv_stride * height; 
     
     
    
  88.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset) + 
     
     
    
  89.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2 - 
     
     
    
  90.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  91.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  92.  
    
     
     
     
    
     
    
     
     
    
       v_fix = v ? (v + (uv_stride * vertical_offset) + 
     
     
    
  93.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2 - 
     
     
    
  94.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  95.  
    
     
     
     
    
     
    
     
     
    
       *v_offset; 
     
     
    
  96.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  97.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV422P: 
     
     
    
  98.  
    
     
     
     
    
     
    
     
     
     
      if (uv_stride < stride / 
      2) 
     
     
    
  99.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride / 
      2; 
     
     
    
  100.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  101.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  102.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  103.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset) + 
     
     
    
  104.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2; 
     
     
    
  105.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = *u_offset + uv_stride * height; 
     
     
    
  106.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset) + 
     
     
    
  107.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2 - 
     
     
    
  108.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  109.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  110.  
    
     
     
     
    
     
    
     
     
    
       v_fix = v ? (v + (uv_stride * vertical_offset) + 
     
     
    
  111.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset / 
      2 - 
     
     
    
  112.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  113.  
    
     
     
     
    
     
    
     
     
    
       *v_offset; 
     
     
    
  114.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  115.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_YUV444P: 
     
     
    
  116.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride; 
     
     
    
  117.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  118.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  119.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset) + 
     
     
    
  120.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset; 
     
     
    
  121.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = *u_offset + uv_stride * height; 
     
     
    
  122.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset) + 
     
     
    
  123.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset - 
     
     
    
  124.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - 
     
     
    
  125.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset)) : 
     
     
    
  126.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  127.  
    
     
     
     
    
     
    
     
     
    
       v_fix = v ? (v + (uv_stride * vertical_offset) + 
     
     
    
  128.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset - 
     
     
    
  129.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - 
     
     
    
  130.  
    
     
     
     
    
     
    
     
     
    
       (horizontal_offset)) : 
     
     
    
  131.  
    
     
     
     
    
     
    
     
     
    
       *v_offset; 
     
     
    
  132.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  133.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_NV12: 
     
     
    
  134.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_NV16: 
     
     
    
  135.  
    
     
     
     
    
     
    
     
     
     
      case PRE_PIX_FMT_NV21: 
     
     
    
  136.  
    
     
     
     
    
     
    
     
     
     
      case PRE_PIX_FMT_NV61: 
     
     
    
  137.  
    
     
     
     
    
     
    
     
     
    
       uv_stride = stride; 
     
     
    
  138.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = stride * (height - vertical_offset - 
      1) + 
     
     
    
  139.  
    
     
     
     
    
     
    
     
     
    
       (stride - horizontal_offset) + 
     
     
    
  140.  
    
     
     
     
    
     
    
     
     
    
       (uv_stride * vertical_offset / 
      2) + 
     
     
    
  141.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset; 
     
     
    
  142.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = 
      0; 
     
     
    
  143.  
    
     
     
     
    
     
    
     
     
    
       u_fix = u ? (u + (uv_stride * vertical_offset / 
      2) + 
     
     
    
  144.  
    
     
     
     
    
     
    
     
     
    
       horizontal_offset - 
     
     
    
  145.  
    
     
     
     
    
     
    
     
     
    
       (stride * vertical_offset) - (horizontal_offset)) : 
     
     
    
  146.  
    
     
     
     
    
     
    
     
     
    
       *u_offset; 
     
     
    
  147.  
    
     
     
     
    
     
    
     
     
     
      break; 
     
     
    
  148.  
    
     
     
     
    
     
    
     
     
     
      default: 
     
     
    
  149.  
    
     
     
     
    
     
    
     
     
     
      return -EINVAL; 
     
     
    
  150.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  151.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  152.  
    
     
     
     
    
     
    
     
     
     
      if (u_fix > *u_offset) 
     
     
    
  153.  
    
     
     
     
    
     
    
     
     
    
       *u_offset = u_fix; 
     
     
    
  154.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  155.  
    
     
     
     
    
     
    
     
     
     
      if (v_fix > *v_offset) 
     
     
    
  156.  
    
     
     
     
    
     
    
     
     
    
       *v_offset = v_fix; 
     
     
    
  157.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  158.  
    
     
     
     
    
     
    
     
     
     
      return 
      0; 
     
     
    
  159.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数一共有11个参数，它的最终目的是根据前9个参数设置最后2个参数的值。这个函数被本文件中_ipu_ch_offset_update函数和ipu_common.c文件中ipu_get_channel_offset函数调用。
 
  
这个函数就是根据数据格式来算出u_offset和v_offset的值，以后根据各种格式来仔细算算。
 
  
 
  
28._ipu_ch_offset_update函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* IDMAC U/V offset changing support */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      /* U and V input is not affected, */ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      /* the update is done by new calculation according to */ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      /* vertical_offset and horizontal_offset */ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_offset_update(struct ipu_soc *ipu, 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      int ch, 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      uint32_t pixel_fmt, 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      uint32_t width, 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      uint32_t height, 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      uint32_t stride, 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u, 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      uint32_t v, 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      uint32_t uv_stride, 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      uint32_t vertical_offset, 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      uint32_t horizontal_offset) 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      uint32_t u_offset = 
      0; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      uint32_t v_offset = 
      0; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      uint32_t old_offset = 
      0; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      int ret; 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
    
       ret = __ipu_ch_offset_calc(pixel_fmt, width, height, stride, 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       u, v, uv_stride, 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
    
       vertical_offset, horizontal_offset, 
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
    
       &u_offset, &v_offset); 
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
     
      if (ret) { 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "mxc ipu: unimplemented pixel format\n"); 
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
     
      /* UBO and VBO are 22-bit and 8-byte aligned */ 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
      if (u_offset/ 
      8 > 
      0x3fffff) 
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's U offset exceeds IPU limitation\n", ch); 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
     
      if (v_offset/ 
      8 > 
      0x3fffff) 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's V offset exceeds IPU limitation\n", ch); 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      if (u_offset% 
      8) 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's U offset is not 8-byte aligned\n", ch); 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
     
      if (v_offset% 
      8) 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
    
       dev_warn(ipu->dev, 
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
     
      "IDMAC%d's V offset is not 8-byte aligned\n", ch); 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
    
       old_offset = ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      46, 
      22); 
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
     
      if (old_offset != u_offset / 
      8) 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      46, 
      22, u_offset / 
      8); 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       old_offset = ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      68, 
      22); 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
     
      if (old_offset != v_offset / 
      8) 
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      68, 
      22, v_offset / 
      8); 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  56.  
    
     
     
     
    
     
    
     
     
    
       old_offset = ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      46, 
      22); 
     
     
    
  57.  
    
     
     
     
    
     
    
     
     
     
      if (old_offset != u_offset / 
      8) 
     
     
    
  58.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      46, 
      22, u_offset / 
      8); 
     
     
    
  59.  
    
     
     
     
    
     
    
     
     
    
       old_offset = ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      68, 
      22); 
     
     
    
  60.  
    
     
     
     
    
     
    
     
     
     
      if (old_offset != v_offset / 
      8) 
     
     
    
  61.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_mod_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      0, 
      68, 
      22, v_offset / 
      8); 
     
     
    
  62.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
从这个函数的名字可以看出来，ipuchannel offset update：ipuchannel偏移更新，这个函数首先通过上一个__ipu_ch_offset_calc函数来计算出&u_offset和&v_offset，然后根据传入的ipu和ch参数来读取ch对应基址word[0]的46～68位中的老&u_offset偏移值和ch对应基址word[0]的68～90位中的老&v_offset偏移值，然后修改它们。重点还是u_offset和v_offset这两个值。
 
  

 
  
29._ipu_ch_params_set_alpha_width函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_params_set_alpha_width(struct ipu_soc *ipu, 
      uint32_t ch, 
      int alpha_width) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, ch), 
      1, 
      125, 
      3, alpha_width - 
      1); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, sub_ch), 
      1, 
      125, 
      3, alpha_width - 
      1); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
这个函数同样就是设置ch对应基址里面word[1]的125～128位，将它设置为(alpha_width– 1)，这一位应该就是关于alpha_width的。
 
  
 
  
30._ipu_ch_param_set_bandmode函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      void _ipu_ch_param_set_bandmode(struct ipu_soc *ipu, 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      uint32_t ch, 
      uint32_t band_height) 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      int32_t sub_ch = 
      0; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, ch), 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      0, 
      114, 
      3, band_height - 
      1); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       sub_ch = __ipu_ch_get_third_buf_cpmem_num(ch); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
      if (sub_ch <= 
      0) 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      return; 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_set_field_io(ipu_ch_param_addr(ipu, sub_ch), 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      0, 
      114, 
      3, band_height - 
      1); 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       dev_dbg(ipu->dev, 
      "BNDM 0x%x, ", 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu_ch_param_read_field_io(ipu_ch_param_addr(ipu, ch), 
      0, 
      114, 
      3)); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
这个函数同样就是设置ch对应基址里面word[0]的114～117位，将它设置为(band_height– 1)，这一位应该就是关于band_height的。
 
  

 
  
31._ipu_ch_param_bad_alpha_pos函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /*  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
       * The IPUv3 IDMAC has a bug to read 32bpp pixels from a graphics plane  
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
       * whose alpha component is at the most significant 8 bits. The bug only  
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
       * impacts on cases in which the relevant separate alpha channel is enabled.  
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
       *  
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
       * Return true on bad alpha component position, otherwise, return false.  
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
       */ 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      static 
      inline 
      bool _ipu_ch_param_bad_alpha_pos( 
      uint32_t pixel_fmt) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      switch (pixel_fmt) { 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGRA32: 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_BGR32: 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGBA32: 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      case IPU_PIX_FMT_RGB32: 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      return 
      true; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
     
      return 
      false; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
这个注释里面写的很清楚了，当IPUv3IDMAC 在从一个alpha组件位于最重要8位的图像位面读取32bpp像素的时候有一个bug，所以当pixel_fmt为32位的时候，就返回true，否则返回false。
 
  
 
    
  
 
  
4.5 ipu_request_irq函数详细分析
 
  
ipu_request_irq函数
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      int ipu_request_irq(struct ipu_soc *ipu, uint32_t irq,  
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
       irqreturn_t(*handler) 
      (int, void *), 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
       uint32_t irq_flags, const char *devname, void *dev_id)  
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      { 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      uint32_t reg; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      unsigned 
      long lock_flags; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      int ret = 
      0; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       BUG_ON(irq >= IPU_IRQ_COUNT); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      /* 如果要申请的中断号大于 IPU_IRQ_COUNT的话，就会报错。 */ 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       _ipu_get(ipu); 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       spin_lock_irqsave(&ipu->int_reg_spin_lock, lock_flags); 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->irq_list[irq].handler != 
      NULL) { 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
     
      "handler already installed on irq %d\n", irq); 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
     
      goto out; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      /* 如果这个irq中断号对应的数组中已经绑定了ISP的话，也会报错。 */ 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
      /*  
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
     
       * Check sync interrupt handler only, since we do nothing for  
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
     
       * error interrupts but than print out register values in the  
     
     
    
  26.  
    
     
     
     
    
     
    
     
     
     
       * error interrupt source handler.  
     
     
    
  27.  
    
     
     
     
    
     
    
     
     
     
       */ 
     
     
    
  28.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_sync_irq(irq) && (handler == 
      NULL)) { 
     
     
    
  29.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "handler is NULL for sync irq %d\n", irq); 
     
     
    
  30.  
    
     
     
     
    
     
    
     
     
    
       ret = -EINVAL; 
     
     
    
  31.  
    
     
     
     
    
     
    
     
     
     
      goto out; 
     
     
    
  32.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  33.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  34.  
    
     
     
     
    
     
    
     
     
    
       ipu->irq_list[irq].handler = handler; 
     
     
    
  35.  
    
     
     
     
    
     
    
     
     
    
       ipu->irq_list[irq].flags = irq_flags; 
     
     
    
  36.  
    
     
     
     
    
     
    
     
     
    
       ipu->irq_list[irq].dev_id = dev_id; 
     
     
    
  37.  
    
     
     
     
    
     
    
     
     
    
       ipu->irq_list[irq].name = devname; 
     
     
    
  38.  
    
     
     
     
    
     
    
     
     
     
      /* 将函数传入的参数保存咋数组中irq这个下标所对应的元素中。 */ 
     
     
    
  39.  
    
     
     
     
    
     
    
     
     
     
      /* clear irq stat for previous use */ 
     
     
    
  40.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, IPUIRQ_2_MASK(irq), 
     
     
    
  41.  
    
     
     
     
    
     
    
     
     
    
       IPUIRQ_2_STATREG(ipu->devtype, irq)); 
     
     
    
  42.  
    
     
     
     
    
     
    
     
     
     
      /* 清空之前的状态。 */ 
     
     
    
  43.  
    
     
     
     
    
     
    
     
     
     
      /* enable the interrupt */ 
     
     
    
  44.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_cm_read(ipu, IPUIRQ_2_CTRLREG(irq)); 
     
     
    
  45.  
    
     
     
     
    
     
    
     
     
    
       reg |= IPUIRQ_2_MASK(irq); 
     
     
    
  46.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, reg, IPUIRQ_2_CTRLREG(irq)); 
     
     
    
  47.  
    
     
     
     
    
     
    
     
     
     
      /* 使能中断。 */ 
     
     
    
  48.  
    
     
     
     
    
     
    
     
     
    
       out: 
     
     
    
  49.  
    
     
     
     
    
     
    
     
     
    
       spin_unlock_irqrestore(&ipu->int_reg_spin_lock, lock_flags); 
     
     
    
  50.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  51.  
    
     
     
     
    
     
    
     
     
    
       _ipu_put(ipu); 
     
     
    
  52.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  53.  
    
     
     
     
    
     
    
     
     
     
      return ret; 
     
     
    
  54.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  55.  
    
     
     
     
    
     
    
     
     
    
       EXPORT_SYMBOL(ipu_request_irq); 
     
     
    
 
  

 
  
这个函数被很多函数所调用，以ipu_device.c中do_task函数为例，这个do_task函数首先通过：
 
  
irq= get_irq(t);来获取到中断号，然后通过：
 
  
ret= ipu_request_irq(ipu, irq, task_irq_handler, 0, NULL, t);来将task_irq_handler这个中断服务程序（InterruptService Routines，ISR）与irq中断号绑定。那么再看查看这个ipu_request_irq中都做了哪些工作：
 
  
在structipu_soc中，有一项structipu_irq_node irq_list[IPU_IRQ_COUNT];
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      struct ipu_irq_node { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      irqreturn_t(*handler) ( 
      int, 
      void *); 
      /*!< the ISR */ 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      const 
      char *name; 
      /*!< device associated with the interrupt */ 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      void *dev_id; 
      /*!< some unique information for the ISR */ 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       __u32 flags; 
      /*!< not used */ 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       }; 
     
     
    
 
  
每一个中断号都在这个数组中对应一项，如果这个中断号没有被申请的话，这一项就会为空。通过这个ipu_request_irq函数来申请的时候，就会将数组中这一项根据函数传入的参数都填充进去。
 
  
 
    
  
 
  
4.6 ipu_enable_channel函数详细分析
 
  
 
  
  1.  
    
     
     
     
      int32_t ipu_enable_channel(struct ipu_soc *ipu, 
      ipu_channel_t channel) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
      uint32_t reg; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
     
      uint32_t ipu_conf; 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      uint32_t in_dma; 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      uint32_t out_dma; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
     
      uint32_t sec_dma; 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      uint32_t thrd_dma; 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       mutex_lock(&ipu->mutex_lock); 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->channel_enable_mask & ( 
      1L << IPU_CHAN_ID(channel))) { 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       dev_err(ipu->dev, 
      "Warning: channel already enabled %d\n", 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
    
       IPU_CHAN_ID(channel)); 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       mutex_unlock(&ipu->mutex_lock); 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      return -EACCES; 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
/*ipu->channel_enable_mask中每一位对应一个channel是否使能了。首先检查要使能的这个channel是否已经使能了，如果已经使能了的话就会报错。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      /* Get input and output dma channels */ 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       out_dma = channel_2_dma(channel, IPU_OUTPUT_BUFFER); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       in_dma = channel_2_dma(channel, IPU_VIDEO_IN_BUFFER); 
     
     
    
 
  
/*通过这两步将channel转化成dma_ch，在之前分析过这个函数，会根据type类型从channel中选取出输入或者输出的dmachannel. */
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf = ipu_cm_read(ipu, IPU_CONF); 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->di_use_count[ 
      0] > 
      0) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_DI0_EN; 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->di_use_count[ 
      1] > 
      0) { 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_DI1_EN; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->dp_use_count > 
      0) 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_DP_EN; 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->dc_use_count > 
      0) 
     
     
    
  11.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_DC_EN; 
     
     
    
  12.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->dmfc_use_count > 
      0) 
     
     
    
  13.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_DMFC_EN; 
     
     
    
  14.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->ic_use_count > 
      0) 
     
     
    
  15.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_IC_EN; 
     
     
    
  16.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->vdi_use_count > 
      0) { 
     
     
    
  17.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_ISP_EN; 
     
     
    
  18.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_VDI_EN; 
     
     
    
  19.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_IC_INPUT; 
     
     
    
  20.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  21.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->rot_use_count > 
      0) 
     
     
    
  22.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_ROT_EN; 
     
     
    
  23.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->smfc_use_count > 
      0) 
     
     
    
  24.  
    
     
     
     
    
     
    
     
     
    
       ipu_conf |= IPU_CONF_SMFC_EN; 
     
     
    
  25.  
    
     
     
     
    
     
    
     
     
    
       ipu_cm_write(ipu, ipu_conf, IPU_CONF); 
     
     
    
 
  
/*根据ipu参数里面的引用计数来决定将ipu_conf寄存器中的对应位置位。最终将这些值都写到这个ipu_conf寄存器中。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (idma_is_valid(in_dma)) { 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(in_dma)); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_CHA_EN(in_dma)); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
      if (idma_is_valid(out_dma)) { 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(out_dma)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(out_dma), IDMAC_CHA_EN(out_dma)); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*通过这几个函数来将in_dma和out_dma的值写到ipu里面的idmac寄存器中。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->sec_chan_en[IPU_CHAN_ID(channel)]) && 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ((channel == MEM_PP_MEM) || (channel == MEM_PRP_VF_MEM) || 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       (channel == MEM_VDI_PRP_VF_MEM))) { 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(sec_dma)); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(sec_dma), IDMAC_CHA_EN(sec_dma)); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
 
  
/*ipu_soc结构体中sec_chan_en是一个bool类型的数组，它会根据channel通过IPU_CHAN_ID转化成的数字来从这个数组中找到对应的一项，如果使能了secondchannel的话，就是true，否则就是false。同时channel的需要是PP，PRP_VF,VDI_PRP_VF的情况，如果条件都成立的话，同样会设置idmac寄存器里面的某些位。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if ((ipu->thrd_chan_en[IPU_CHAN_ID(channel)]) && 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ((channel == MEM_PP_MEM) || (channel == MEM_PRP_VF_MEM))) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       thrd_dma = channel_2_dma(channel, IPU_ALPHA_IN_BUFFER); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(thrd_dma)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(thrd_dma), IDMAC_CHA_EN(thrd_dma)); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_SEP_ALPHA); 
     
     
    
  9.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(sec_dma), IDMAC_SEP_ALPHA); 
     
     
    
  10.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这一段代码判断的是thirdchannel是否使能同时此时对应的channel是PP和PRP_VF。如果是使能了thirdchannel的话，肯定已经使能了secondchannel，所以需要同时在idmac中设置thrd_dma和sec_dma的值。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      else 
      if ((ipu->thrd_chan_en[IPU_CHAN_ID(channel)]) && 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       ((channel == MEM_BG_SYNC) || (channel == MEM_FG_SYNC))) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       thrd_dma = channel_2_dma(channel, IPU_ALPHA_IN_BUFFER); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(thrd_dma)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(thrd_dma), IDMAC_CHA_EN(thrd_dma)); 
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_SEP_ALPHA); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_SEP_ALPHA); 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这一段代码判断的是thirdchannel是否使能同时此时对应的channel是BG和FG。如果是使能了thirdchannel的话，肯定已经使能了secondchannel，所以需要同时在idmac中设置thrd_dma和sec_dma的值。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if ((channel == MEM_DC_SYNC) || (channel == MEM_BG_SYNC) || 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       (channel == MEM_FG_SYNC)) { 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       reg = ipu_idmac_read(ipu, IDMAC_WM_EN(in_dma)); 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_WM_EN(in_dma)); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
    
       _ipu_dp_dc_enable(ipu, channel); 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
 
  
/*这几个通道是关于输出显示的通道，个人理解是displaycontroll sync, background sync和foregroundsyncchannel，这时肯定不能仅仅设置idmac寄存器，同时需要调用_ipu_dp_dc_enable函数来使能显示设备，这个函数在ipu_disp.c中定义。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (_ipu_is_ic_chan(in_dma) || _ipu_is_ic_chan(out_dma) || 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       _ipu_is_irt_chan(in_dma) || _ipu_is_irt_chan(out_dma) || 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
    
       _ipu_is_vdi_out_chan(out_dma)) 
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       _ipu_ic_enable_task(ipu, channel); 
     
     
    
 
  
/*如果是in_dma和out_dma使用到了ic,irt,vdi_out的话，都需要通过_ipu_ic_enable_task函数来使能ic，这个函数在ipu_ic.c中定义。*/
 
  
	ipu->channel_enable_mask |= 1L << IPU_CHAN_ID(channel); 
 
  
/*这个channel_enable_mask是一个uint32_t类型的掩码，如果使能了哪个channel的话，就将这个channel对应的位置1。同时也会在这个函数开始的地方通过它来判断一个channel是否已经使能过了。*/
 
  
 
  
  1.  
    
     
     
     
    
     
    
     
     
     
      if (ipu->prg_clk) 
     
     
    
  2.  
    
     
     
     
    
     
    
     
     
    
       clk_prepare_enable(ipu->prg_clk); 
     
     
    
  3.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  4.  
    
     
     
     
    
     
    
     
     
    
       mutex_unlock(&ipu->mutex_lock); 
     
     
    
  5.  
    
     
     
     
    
     
    
     
     
     
     
     
    
  6.  
    
     
     
     
    
     
    
     
     
     
      return 
      0; 
     
     
    
  7.  
    
     
     
     
    
     
    
     
     
    
       } 
     
     
    
  8.  
    
     
     
     
    
     
    
     
     
    
       EXPORT_SYMBOL(ipu_enable_channel); 
     
     
    
 
  
 
  
总结一下，这个函数都做了哪些事情：
 
  
（1）既然是使能channel函数，设置的首要寄存器就是ipu_conf，会根据ipu_soc结构体里面的各个子模块的引用计数来将ipu_conf中对应的位使能。
 
   
  
 
  
（2）每一个channel都会使用到一个或者多个dmachannel，那么同样的，需要将这几个dmachannel所对应的寄存器的位使能，对应的寄存器是IPUx_IDMAC_CH_EN_1或者IPUx_IDMAC_CH_EN_2.
 
  
 
  
至此，ipu_common.c文件中的重要函数都分析完毕。
 
 
 

 

 
 
 
 
  1.  
   
     
    
     
     int32_t ipu_enable_channel(struct ipu_soc *ipu, 
     ipu_channel_t channel) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t reg; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     uint32_t ipu_conf; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     uint32_t in_dma; 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     uint32_t out_dma; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     uint32_t sec_dma; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     uint32_t thrd_dma; 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      mutex_lock(&ipu->mutex_lock); 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->channel_enable_mask & ( 
     1L << IPU_CHAN_ID(channel))) { 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      dev_err(ipu->dev, 
     "Warning: channel already enabled %d\n", 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      IPU_CHAN_ID(channel)); 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     return -EACCES; 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
/*ipu->channel_enable_mask中每一位对应一个channel是否使能了。首先检查要使能的这个channel是否已经使能了，如果已经使能了的话就会报错。*/
 
 
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     /* Get input and output dma channels */ 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      out_dma = channel_2_dma(channel, IPU_OUTPUT_BUFFER); 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      in_dma = channel_2_dma(channel, IPU_VIDEO_IN_BUFFER); 
    
     
   
 
 
/*通过这两步将channel转化成dma_ch，在之前分析过这个函数，会根据type类型从channel中选取出输入或者输出的dmachannel. */
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf = ipu_cm_read(ipu, IPU_CONF); 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->di_use_count[ 
     0] > 
     0) { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_DI0_EN; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->di_use_count[ 
     1] > 
     0) { 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_DI1_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->dp_use_count > 
     0) 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_DP_EN; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->dc_use_count > 
     0) 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_DC_EN; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->dmfc_use_count > 
     0) 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_DMFC_EN; 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->ic_use_count > 
     0) 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_IC_EN; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->vdi_use_count > 
     0) { 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_ISP_EN; 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_VDI_EN; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_IC_INPUT; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->rot_use_count > 
     0) 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_ROT_EN; 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->smfc_use_count > 
     0) 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
    
      ipu_conf |= IPU_CONF_SMFC_EN; 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
    
      ipu_cm_write(ipu, ipu_conf, IPU_CONF); 
    
     
   
 
 
/*根据ipu参数里面的引用计数来决定将ipu_conf寄存器中的对应位置位。最终将这些值都写到这个ipu_conf寄存器中。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if (idma_is_valid(in_dma)) { 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(in_dma)); 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_CHA_EN(in_dma)); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     if (idma_is_valid(out_dma)) { 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(out_dma)); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(out_dma), IDMAC_CHA_EN(out_dma)); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*通过这几个函数来将in_dma和out_dma的值写到ipu里面的idmac寄存器中。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if ((ipu->sec_chan_en[IPU_CHAN_ID(channel)]) && 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ((channel == MEM_PP_MEM) || (channel == MEM_PRP_VF_MEM) || 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      (channel == MEM_VDI_PRP_VF_MEM))) { 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(sec_dma)); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(sec_dma), IDMAC_CHA_EN(sec_dma)); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
/*ipu_soc结构体中sec_chan_en是一个bool类型的数组，它会根据channel通过IPU_CHAN_ID转化成的数字来从这个数组中找到对应的一项，如果使能了secondchannel的话，就是true，否则就是false。同时channel的需要是PP，PRP_VF,VDI_PRP_VF的情况，如果条件都成立的话，同样会设置idmac寄存器里面的某些位。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if ((ipu->thrd_chan_en[IPU_CHAN_ID(channel)]) && 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ((channel == MEM_PP_MEM) || (channel == MEM_PRP_VF_MEM))) { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      thrd_dma = channel_2_dma(channel, IPU_ALPHA_IN_BUFFER); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(thrd_dma)); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(thrd_dma), IDMAC_CHA_EN(thrd_dma)); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      sec_dma = channel_2_dma(channel, IPU_GRAPH_IN_BUFFER); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_SEP_ALPHA); 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(sec_dma), IDMAC_SEP_ALPHA); 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*这一段代码判断的是thirdchannel是否使能同时此时对应的channel是PP和PRP_VF。如果是使能了thirdchannel的话，肯定已经使能了secondchannel，所以需要同时在idmac中设置thrd_dma和sec_dma的值。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     else 
     if ((ipu->thrd_chan_en[IPU_CHAN_ID(channel)]) && 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ((channel == MEM_BG_SYNC) || (channel == MEM_FG_SYNC))) { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      thrd_dma = channel_2_dma(channel, IPU_ALPHA_IN_BUFFER); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_CHA_EN(thrd_dma)); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(thrd_dma), IDMAC_CHA_EN(thrd_dma)); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_SEP_ALPHA); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_SEP_ALPHA); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*这一段代码判断的是thirdchannel是否使能同时此时对应的channel是BG和FG。如果是使能了thirdchannel的话，肯定已经使能了secondchannel，所以需要同时在idmac中设置thrd_dma和sec_dma的值。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if ((channel == MEM_DC_SYNC) || (channel == MEM_BG_SYNC) || 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      (channel == MEM_FG_SYNC)) { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_idmac_read(ipu, IDMAC_WM_EN(in_dma)); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      ipu_idmac_write(ipu, reg | idma_mask(in_dma), IDMAC_WM_EN(in_dma)); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      _ipu_dp_dc_enable(ipu, channel); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*这几个通道是关于输出显示的通道，个人理解是displaycontroll sync, background sync和foregroundsyncchannel，这时肯定不能仅仅设置idmac寄存器，同时需要调用_ipu_dp_dc_enable函数来使能显示设备，这个函数在ipu_disp.c中定义。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if (_ipu_is_ic_chan(in_dma) || _ipu_is_ic_chan(out_dma) || 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      _ipu_is_irt_chan(in_dma) || _ipu_is_irt_chan(out_dma) || 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      _ipu_is_vdi_out_chan(out_dma)) 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      _ipu_ic_enable_task(ipu, channel); 
    
     
   
 
 
/*如果是in_dma和out_dma使用到了ic,irt,vdi_out的话，都需要通过_ipu_ic_enable_task函数来使能ic，这个函数在ipu_ic.c中定义。*/
 
 
	ipu->channel_enable_mask |= 1L << IPU_CHAN_ID(channel); 
 
 
/*这个channel_enable_mask是一个uint32_t类型的掩码，如果使能了哪个channel的话，就将这个channel对应的位置1。同时也会在这个函数开始的地方通过它来判断一个channel是否已经使能过了。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->prg_clk) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      clk_prepare_enable(ipu->prg_clk); 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     return 
     0; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_enable_channel); 
    
     
   
 
 
 
 
总结一下，这个函数都做了哪些事情：
 
 
（1）既然是使能channel函数，设置的首要寄存器就是ipu_conf，会根据ipu_soc结构体里面的各个子模块的引用计数来将ipu_conf中对应的位使能。
 
  
 
 
 
（2）每一个channel都会使用到一个或者多个dmachannel，那么同样的，需要将这几个dmachannel所对应的寄存器的位使能，对应的寄存器是IPUx_IDMAC_CH_EN_1或者IPUx_IDMAC_CH_EN_2.
 
 
 
 
至此，ipu_common.c文件中的重要函数都分析完毕。
 
 

 
 
 
 
4.7 ipu_capture.c分析
 
 
在ipu_common.c文件中，会调用到这个文件很多底层的函数，来设置视频捕获设备中底层的一些操作寄存器。这个文件就直接从头至尾开始分析：
 
 

 
 
1._ipu_csi_mclk_set函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int _ipu_csi_mclk_set(struct ipu_soc *ipu, 
     uint32_t pixel_clk, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     uint32_t div_ratio; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      div_ratio = (clk_get_rate(ipu->ipu_clk) / pixel_clk) - 
     1; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     if (div_ratio > 
     0xFF || div_ratio < 
     0) { 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      dev_dbg(ipu->dev, 
     "value of pixel_clk extends normal range\n"); 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
     return -EINVAL; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_SENS_CONF); 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_SENS_CONF_DIVRATIO_MASK; 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp | 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      (div_ratio << CSI_SENS_CONF_DIVRATIO_SHIFT), 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      CSI_SENS_CONF); 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     return 
     0; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
这个函数是设置csi设备的mclk时钟参数，首先根据想要设置的pixel_clk时钟参数计算出来需要设置的div_ratio值，然后通过ipu_csi_read函数读出原来的CSI_SENS_CONF寄存器的值，然后将div_ratio设置进去，再通过ipu_csi_write将值重新写到CSI_SENS_CONF寄存器中。
 
 

 
 
2.ipu_csi_init_interface函数，这个函数被mxc_v4l2_capture.c的mxc_v4l_open函数和mxc_v4l2_s_param函数调用。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int32_t 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_init_interface(struct ipu_soc *ipu, 
     uint16_t width, 
     uint16_t height, 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t pixel_fmt, 
     ipu_csi_signal_cfg_t cfg_param) 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     uint32_t data = 
     0; 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     uint32_t csi = cfg_param.csi; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     /* Set SENS_DATA_FORMAT bits (8, 9 and 10)  
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
      RGB or YUV444 is 0 which is current value in data so not set  
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
      explicitly  
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
      This is also the default value if attempts are made to set it to  
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
      something invalid. */ 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
     switch (pixel_fmt) { 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_YUYV: 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_YUYV; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_UYVY: 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_YUV422_UYVY; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_RGB24: 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_BGR24: 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_RGB_YUV444; 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_GENERIC: 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_GENERIC_16: 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_BAYER; 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_RGB565: 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_RGB565; 
    
     
   
  30.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  31.  
   
     
    
     
   
     
   
     
    
     
     case IPU_PIX_FMT_RGB555: 
    
     
   
  32.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt = CSI_SENS_CONF_DATA_FMT_RGB555; 
    
     
   
  33.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  34.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  35.  
   
     
    
     
   
     
   
     
    
     
     return -EINVAL; 
    
     
   
  36.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*首先根据传进来的不同pixel_fmt参数的值，设置cfg_param.data_fmt的值。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     /* Set the CSI_SENS_CONF register remaining fields */ 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      data |= cfg_param.data_width << CSI_SENS_CONF_DATA_WIDTH_SHIFT | 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_fmt << CSI_SENS_CONF_DATA_FMT_SHIFT | 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_pol << CSI_SENS_CONF_DATA_POL_SHIFT | 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.Vsync_pol << CSI_SENS_CONF_VSYNC_POL_SHIFT | 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.Hsync_pol << CSI_SENS_CONF_HSYNC_POL_SHIFT | 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.pixclk_pol << CSI_SENS_CONF_PIX_CLK_POL_SHIFT | 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.ext_vsync << CSI_SENS_CONF_EXT_VSYNC_SHIFT | 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.clk_mode << CSI_SENS_CONF_SENS_PRTCL_SHIFT | 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.pack_tight << CSI_SENS_CONF_PACK_TIGHT_SHIFT | 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.force_eof << CSI_SENS_CONF_FORCE_EOF_SHIFT | 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      cfg_param.data_en_pol << CSI_SENS_CONF_DATA_EN_POL_SHIFT; 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      _ipu_get(ipu); 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      mutex_lock(&ipu->mutex_lock); 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, data, CSI_SENS_CONF); 
    
     
   
 
 
/*设置CSI_SENS_CONF寄存器的值。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     /* Setup sensor frame size */ 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, (width - 
     1) | (height - 
     1) << 
     16, CSI_SENS_FRM_SIZE); 
    
     
   
 
 
/*根据传进来的width和height参数，设置CSI_SENS_FRM_SIZE寄存器的值。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     /* Set CCIR registers */ 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
     
     if (cfg_param.clk_mode == IPU_CSI_CLK_MODE_CCIR656_PROGRESSIVE) { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0x40030, CSI_CCIR_CODE_1); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xFF0000, CSI_CCIR_CODE_3); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      } 
     else 
     if (cfg_param.clk_mode == IPU_CSI_CLK_MODE_CCIR656_INTERLACED) { 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     if (width == 
     720 && height == 
     625) { 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     /* PAL case */ 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     /*  
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
      * Field0BlankEnd = 0x6, Field0BlankStart = 0x2,  
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
      * Field0ActiveEnd = 0x4, Field0ActiveStart = 0  
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
      */ 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0x40596, CSI_CCIR_CODE_1); 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
     /*  
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
      * Field1BlankEnd = 0x7, Field1BlankStart = 0x3,  
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
      * Field1ActiveEnd = 0x5, Field1ActiveStart = 0x1  
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
      */ 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xD07DF, CSI_CCIR_CODE_2); 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xFF0000, CSI_CCIR_CODE_3); 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      } 
     else 
     if (width == 
     720 && height == 
     525) { 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
     
     /* NTSC case */ 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     /*  
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
     
      * Field0BlankEnd = 0x7, Field0BlankStart = 0x3,  
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
      * Field0ActiveEnd = 0x5, Field0ActiveStart = 0x1  
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
     
      */ 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xD07DF, CSI_CCIR_CODE_1); 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
     
     /*  
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
     
      * Field1BlankEnd = 0x6, Field1BlankStart = 0x2,  
    
     
   
  30.  
   
     
    
     
   
     
   
     
    
     
      * Field1ActiveEnd = 0x4, Field1ActiveStart = 0  
    
     
   
  31.  
   
     
    
     
   
     
   
     
    
     
      */ 
    
     
   
  32.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0x40596, CSI_CCIR_CODE_2); 
    
     
   
  33.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xFF0000, CSI_CCIR_CODE_3); 
    
     
   
  34.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  35.  
   
     
    
     
   
     
   
     
    
    
      dev_err(ipu->dev, 
     "Unsupported CCIR656 interlaced " 
    
     
   
  36.  
   
     
    
     
   
     
   
     
    
     
     "video mode\n"); 
    
     
   
  37.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  38.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  39.  
   
     
    
     
   
     
   
     
    
     
     return -EINVAL; 
    
     
   
  40.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  41.  
   
     
    
     
   
     
   
     
    
    
      _ipu_csi_ccir_err_detection_enable(ipu, csi); 
    
     
   
  42.  
   
     
    
     
   
     
   
     
    
    
      } 
     else 
     if ((cfg_param.clk_mode == 
    
     
   
  43.  
   
     
    
     
   
     
   
     
    
    
      IPU_CSI_CLK_MODE_CCIR1120_PROGRESSIVE_DDR) || 
    
     
   
  44.  
   
     
    
     
   
     
   
     
    
    
      (cfg_param.clk_mode == 
    
     
   
  45.  
   
     
    
     
   
     
   
     
    
    
      IPU_CSI_CLK_MODE_CCIR1120_PROGRESSIVE_SDR) || 
    
     
   
  46.  
   
     
    
     
   
     
   
     
    
    
      (cfg_param.clk_mode == 
    
     
   
  47.  
   
     
    
     
   
     
   
     
    
    
      IPU_CSI_CLK_MODE_CCIR1120_INTERLACED_DDR) || 
    
     
   
  48.  
   
     
    
     
   
     
   
     
    
    
      (cfg_param.clk_mode == 
    
     
   
  49.  
   
     
    
     
   
     
   
     
    
    
      IPU_CSI_CLK_MODE_CCIR1120_INTERLACED_SDR)) { 
    
     
   
  50.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0x40030, CSI_CCIR_CODE_1); 
    
     
   
  51.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, 
     0xFF0000, CSI_CCIR_CODE_3); 
    
     
   
  52.  
   
     
    
     
   
     
   
     
    
    
      _ipu_csi_ccir_err_detection_enable(ipu, csi); 
    
     
   
  53.  
   
     
    
     
   
     
   
     
    
    
      } 
     else 
     if ((cfg_param.clk_mode == IPU_CSI_CLK_MODE_GATED_CLK) || 
    
     
   
  54.  
   
     
    
     
   
     
   
     
    
    
      (cfg_param.clk_mode == IPU_CSI_CLK_MODE_NONGATED_CLK)) { 
    
     
   
  55.  
   
     
    
     
   
     
   
     
    
    
      _ipu_csi_ccir_err_detection_disable(ipu, csi); 
    
     
   
  56.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
/*根据cfg_param.clk_mode参数的不同值来设置CSI_CCIR_CODE_1，CSI_CCIR_CODE_2和CSI_CCIR_CODE_3寄存器的值，同时在IPU_CSI_CLK_MODE_CCIR656_INTERLACED的情况下也会参考width和height的值进行设置。其中会调用到_ipu_csi_ccir_err_detection_enable函数，这个函数在后面分析。在下面13中分析。*/
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
    
      dev_dbg(ipu->dev, 
     "CSI_SENS_CONF = 0x%08X\n", 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_read(ipu, csi, CSI_SENS_CONF)); 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      dev_dbg(ipu->dev, 
     "CSI_ACT_FRM_SIZE = 0x%08X\n", 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_read(ipu, csi, CSI_ACT_FRM_SIZE)); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
     return 
     0; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_init_interface); 
    
     
   
 
 
 
 
3.ipu_csi_get_sensor_protocol函数,这个函数会在ipu_fg_overlay_sdc.c文件中的csi_enc_setup函数中调用：
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int32_t ipu_csi_get_sensor_protocol(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     int ret; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
    
      _ipu_get(ipu); 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      ret = (ipu_csi_read(ipu, csi, CSI_SENS_CONF) & 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      CSI_SENS_CONF_SENS_PRTCL_MASK) >> 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      CSI_SENS_CONF_SENS_PRTCL_SHIFT; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
     return ret; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_get_sensor_protocol); 
    
     
   
 
 
这个函数的大致意思就是通过指定的ipu的某一个csi，返回这个csi设备的CSI_SENS_CONF寄存器里面已经配置好的值。
 
 

 
 
4.ipu_csi_enable_mclk函数，在mxc_v4l2_capture.c文件中调用了ipu_csi_enable_mclk_if函数，这个函数其实就是ipu_csi_enable_mclk函数。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int ipu_csi_enable_mclk(struct ipu_soc *ipu, int csi, bool flag, bool wait)  
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     /* Return immediately if there is no csi_clk to manage */ 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     if (ipu->csi_clk[csi] == 
     NULL) 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     return 
     0; 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     if (flag) { 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      clk_enable(ipu->csi_clk[csi]); 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
     if (wait == 
     true) 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      msleep( 
     10); 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      clk_disable(ipu->csi_clk[csi]); 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
     return 
     0; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_enable_mclk); 
    
     
   
 
 
这个函数根据传入的flag参数来决定使能还是关闭时钟，如果flag为true的话，就调用clk_enable函数使能时钟，如果flag参数为false的话，就调用clk_disable函数来关闭时钟。
 
 

 
 
5.ipu_csi_get_window_size函数，这个函数在ipu_prp_vf_sdc_bg.c，ipu_prp_vf_sdc.c和ipu_prp_enc.c中都有调用。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void ipu_csi_get_window_size(struct ipu_soc *ipu, uint32_t *width, uint32_t *height, uint32_t csi)  
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t reg; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      _ipu_get(ipu); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      mutex_lock(&ipu->mutex_lock); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      reg = ipu_csi_read(ipu, csi, CSI_ACT_FRM_SIZE); 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      *width = (reg & 
     0xFFFF) + 
     1; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      *height = (reg >> 
     16 & 
     0xFFFF) + 
     1; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_get_window_size); 
    
     
   
 
 
这个函数就是从指定ipu的某个csi设备中，读取CSI_ACT_FRM_SIZE寄存器的值保存在*width和*height中返回。
 
 

 
 
6.ipu_csi_set_window_size函数，这个函数在mxc_v4l2_capture.c中的mxc_v4l2_s_param，mxc_v4l_open，init_camera_struct，和mxc_v4l_do_ioctl的VIDIOC_S_CROP函数中都有调用。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void ipu_csi_set_window_size(struct ipu_soc *ipu, uint32_t width, uint32_t height, uint32_t csi)  
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      _ipu_get(ipu); 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      mutex_lock(&ipu->mutex_lock); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, (width - 
     1) | (height - 
     1) << 
     16, CSI_ACT_FRM_SIZE); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_set_window_size); 
    
     
   
 
 
这个函数就是将传进来的width和height参数设置到CSI_ACT_FRM_SIZE寄存器中。
 
 

 
 
7.ipu_csi_set_window_pos函数，这个函数和上一个ipu_csi_set_window_size函数是一起使用的。想要确定一个窗口的大小，只需要知道它的左上角坐标和窗口的长度/宽度就可以设置了。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void ipu_csi_set_window_pos(struct ipu_soc *ipu, uint32_t left, uint32_t top, uint32_t csi)  
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      _ipu_get(ipu); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      mutex_lock(&ipu->mutex_lock); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_OUT_FRM_CTRL); 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~(CSI_HSC_MASK | CSI_VSC_MASK); 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      temp |= ((top << CSI_VSC_SHIFT) | (left << CSI_HSC_SHIFT)); 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_OUT_FRM_CTRL); 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      mutex_unlock(&ipu->mutex_lock); 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      _ipu_put(ipu); 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      EXPORT_SYMBOL(ipu_csi_set_window_pos); 
    
     
   
 
 
 
 
将传进来的left和top参数对应设置到CSI_OUT_FRM_CTRL寄存器中即可。
 
 

 
 
8._ipu_csi_horizontal_downsize_enable函数，这个函数暂时没人调用。。。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_horizontal_downsize_enable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_OUT_FRM_CTRL); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp |= CSI_HORI_DOWNSIZE_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_OUT_FRM_CTRL); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
函数的大致意思是设置csi设备允许水平方向上的小型化（缩放），这个概念不好理解，但是底层的操作很简单，就是将CSI_OUT_FRM_CTRL寄存器的CSI_HORI_DOWNSIZE_EN位置位即可。
 
 

 
 
9._ipu_csi_horizontal_downsize_disable函数，是上一个函数的反函数。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_horizontal_downsize_disable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_OUT_FRM_CTRL); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_HORI_DOWNSIZE_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_OUT_FRM_CTRL); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
同样的，想要关闭这个功能，只需要将SI_OUT_FRM_CTRL寄存器的CSI_HORI_DOWNSIZE_EN位清零即可。
 
 

 
 
10._ipu_csi_vertical_downsize_enable函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_vertical_downsize_enable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_OUT_FRM_CTRL); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp |= CSI_VERT_DOWNSIZE_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_OUT_FRM_CTRL); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数就是允许csi设备垂直方向上的小型化（缩放），同样，只需要将CSI_OUT_FRM_CTRL寄存器的CSI_VERT_DOWNSIZE_EN位置位即可。
 
 

 
 
11._ipu_csi_vertical_downsize_disable函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_vertical_downsize_disable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_OUT_FRM_CTRL); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_VERT_DOWNSIZE_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_OUT_FRM_CTRL); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数是第10个函数的反函数，想要关闭垂直方向上的小型化这个功能，只需要将CSI_OUT_FRM_CTRL寄存器的CSI_VERT_DOWNSIZE_EN位清零即可。
 
 

 
 
12._ipu_csi_set_test_generator函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_set_test_generator(struct ipu_soc *ipu, 
     bool active, 
     uint32_t r_value, 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
     
     uint32_t g_value, 
     uint32_t b_value, 
     uint32_t pix_clk, 
     uint32_t csi) 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_TST_CTRL); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     if (active == 
     false) { 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_TEST_GEN_MODE_EN; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_TST_CTRL); 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     /* Set sensb_mclk div_ratio*/ 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      _ipu_csi_mclk_set(ipu, pix_clk, csi); 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~(CSI_TEST_GEN_R_MASK | CSI_TEST_GEN_G_MASK | 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      CSI_TEST_GEN_B_MASK); 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      temp |= CSI_TEST_GEN_MODE_EN; 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      temp |= (r_value << CSI_TEST_GEN_R_SHIFT) | 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      (g_value << CSI_TEST_GEN_G_SHIFT) | 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      (b_value << CSI_TEST_GEN_B_SHIFT); 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_TST_CTRL); 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数根据active参数的值决定是否启动这个测试发生器的功能。如果active为false的话，就将CSI_TST_CTRL寄存器中的CSI_TEST_GEN_MODE_EN位清零，如果active为true的话，就根据传入的pix_clk参数设置时钟，然后将传入的R，G，B色彩写到CSI_TST_CTRL寄存器中。
 
 

 
 
这个函数不知道具体想要实现什么功能，也没有其他的函数调用它，所以先分析这些。
 
 

 
 
13._ipu_csi_ccir_err_detection_enable函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_ccir_err_detection_enable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_CCIR_CODE_1); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp |= CSI_CCIR_ERR_DET_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_CCIR_CODE_1); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数在ipu_csi_init_interface函数中使用了它，我们在这分析：
 
 
它只是将CSI_CCIR_CODE_1寄存器的CSI_CCIR_ERR_DET_EN位置位了。启用CCIR交错模式的错误校验和修正。
 
 

 
 
14._ipu_csi_ccir_err_detection_disable函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_ccir_err_detection_disable(struct ipu_soc *ipu, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_CCIR_CODE_1); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_CCIR_ERR_DET_EN; 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_CCIR_CODE_1); 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
这个函数是_ipu_csi_ccir_err_detection_enable函数的反函数。
 
 

 
 
15._ipu_csi_set_mipi_di函数，这个函数在ipu_common.c中的ipu_init_channel函数里调用.
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int _ipu_csi_set_mipi_di(struct ipu_soc *ipu, 
     uint32_t num, 
     uint32_t di_val, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     int retval = 
     0; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     if (di_val > 
     0xFFL) { 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      retval = -EINVAL; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     goto err; 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_MIPI_DI); 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
     switch (num) { 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
     case IPU_CSI_MIPI_DI0: 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_MIPI_DI0_MASK; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      temp |= (di_val << CSI_MIPI_DI0_SHIFT); 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_MIPI_DI); 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     case IPU_CSI_MIPI_DI1: 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_MIPI_DI1_MASK; 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      temp |= (di_val << CSI_MIPI_DI1_SHIFT); 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_MIPI_DI); 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
     
     case IPU_CSI_MIPI_DI2: 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_MIPI_DI2_MASK; 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      temp |= (di_val << CSI_MIPI_DI2_SHIFT); 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_MIPI_DI); 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
     
     case IPU_CSI_MIPI_DI3: 
    
     
   
  30.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~CSI_MIPI_DI3_MASK; 
    
     
   
  31.  
   
     
    
     
   
     
   
     
    
    
      temp |= (di_val << CSI_MIPI_DI3_SHIFT); 
    
     
   
  32.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_MIPI_DI); 
    
     
   
  33.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  34.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  35.  
   
     
    
     
   
     
   
     
    
    
      retval = -EINVAL; 
    
     
   
  36.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  37.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  38.  
   
     
    
     
   
     
   
     
    
    
      err: 
    
     
   
  39.  
   
     
    
     
   
     
   
     
    
     
     return retval; 
    
     
   
  40.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
它就是根据这个传入的num值来修改CSI_MIPI_DI寄存器中的值，我在用户手册中搜索到的寄存器的名字叫做CSI1Data Identifier Register （IPUx_CSI1_DI），它应该就是为了区分数据来源是哪个流。
 
 

 
 
16._ipu_csi_set_skip_isp函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int _ipu_csi_set_skip_isp(struct ipu_soc *ipu, 
     uint32_t skip, 
     uint32_t max_ratio, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     int retval = 
     0; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     if (max_ratio > 
     5) { 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      retval = -EINVAL; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     goto err; 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_SKIP); 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~(CSI_MAX_RATIO_SKIP_ISP_MASK | CSI_SKIP_ISP_MASK); 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp |= (max_ratio << CSI_MAX_RATIO_SKIP_ISP_SHIFT) | 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      (skip << CSI_SKIP_ISP_SHIFT); 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_SKIP); 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      err: 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
     return retval; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
它主要是用来设置CSI_SKIP寄存器的，根据传入的skip和max_ratio两个值来修改。查看用户数据手册可以发现，这个寄存器可以设置的地方有3个，这个函数可以修改skip和max_ratio，下面那个函数可以修改另外一个smfc。
 
 

 
 
17._ipu_csi_set_skip_smfc函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int _ipu_csi_set_skip_smfc(struct ipu_soc *ipu, 
     uint32_t skip, 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
     
     uint32_t max_ratio, 
     uint32_t id, 
     uint32_t csi) 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
     int retval = 
     0; 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     if (max_ratio > 
     5 || id > 
     3) { 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      retval = -EINVAL; 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
     goto err; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_csi_read(ipu, csi, CSI_SKIP); 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~(CSI_MAX_RATIO_SKIP_SMFC_MASK | CSI_ID_2_SKIP_MASK | 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      CSI_SKIP_SMFC_MASK); 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      temp |= (max_ratio << CSI_MAX_RATIO_SKIP_SMFC_SHIFT) | 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
    
      (id << CSI_ID_2_SKIP_SHIFT) | 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      (skip << CSI_SKIP_SMFC_SHIFT); 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, temp, CSI_SKIP); 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      err: 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
     
     return retval; 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数与上面那个类似，只是需要通过3个参数来确定修改CSI_SKIP中的哪些位。以后再具体查看这些位的含义。
 
 

 
 
18._ipu_smfc_init函数，它在ipu_common.c文件中的ipu_init_channel函数中调用了。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_smfc_init(struct ipu_soc *ipu, 
     ipu_channel_t channel, 
     uint32_t mipi_id, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_smfc_read(ipu, SMFC_MAP); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     switch (channel) { 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM0: 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_MAP_CH0_MASK; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      temp |= ((csi << 
     2) | mipi_id) << SMFC_MAP_CH0_SHIFT; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM1: 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_MAP_CH1_MASK; 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      temp |= ((csi << 
     2) | mipi_id) << SMFC_MAP_CH1_SHIFT; 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM2: 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_MAP_CH2_MASK; 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      temp |= ((csi << 
     2) | mipi_id) << SMFC_MAP_CH2_SHIFT; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM3: 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_MAP_CH3_MASK; 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      temp |= ((csi << 
     2) | mipi_id) << SMFC_MAP_CH3_SHIFT; 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
     return; 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
    
      ipu_smfc_write(ipu, temp, SMFC_MAP); 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
看函数的注释，MapCSI frames to IDMACchannels.这个SMFC位于csi设备与IDMAC之间的位置，意思应该就是映射csi的frame到IDMAC中。操作很简单，根据channel参数的值来设置SMFC_MAP寄存器中的值。
 
 

 
 
19._ipu_smfc_set_wmc函数
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_smfc_set_wmc(struct ipu_soc *ipu, 
     ipu_channel_t channel, 
     bool 
     set, 
     uint32_t level) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_smfc_read(ipu, SMFC_WMC); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     switch (channel) { 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM0: 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
     if ( 
     set == 
     true) { 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM0_SET_MASK; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM0_SET_SHIFT; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM0_CLR_MASK; 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM0_CLR_SHIFT; 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM1: 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
     if ( 
     set == 
     true) { 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM1_SET_MASK; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM1_SET_SHIFT; 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM1_CLR_MASK; 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM1_CLR_SHIFT; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM2: 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
     if ( 
     set == 
     true) { 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM2_SET_MASK; 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM2_SET_SHIFT; 
    
     
   
  30.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  31.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM2_CLR_MASK; 
    
     
   
  32.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM2_CLR_SHIFT; 
    
     
   
  33.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  34.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  35.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM3: 
    
     
   
  36.  
   
     
    
     
   
     
   
     
    
     
     if ( 
     set == 
     true) { 
    
     
   
  37.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM3_SET_MASK; 
    
     
   
  38.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM3_SET_SHIFT; 
    
     
   
  39.  
   
     
    
     
   
     
   
     
    
    
      } 
     else { 
    
     
   
  40.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_WM3_CLR_MASK; 
    
     
   
  41.  
   
     
    
     
   
     
   
     
    
    
      temp |= level << SMFC_WM3_CLR_SHIFT; 
    
     
   
  42.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  43.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  44.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  45.  
   
     
    
     
   
     
   
     
    
     
     return; 
    
     
   
  46.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  47.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  48.  
   
     
    
     
   
     
   
     
    
    
      ipu_smfc_write(ipu, temp, SMFC_WMC); 
    
     
   
  49.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
根据channel的值来设置SMFC_WMC寄存器中的不同位。函数意思不懂。
 
 

 
 
20._ipu_smfc_set_burst_size函数，在ipu_common.c中的ipu_init_channel_buffer中调用了。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_smfc_set_burst_size(struct ipu_soc *ipu, 
     ipu_channel_t channel, 
     uint32_t bs) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t temp; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
    
      temp = ipu_smfc_read(ipu, SMFC_BS); 
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     switch (channel) { 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM0: 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_BS0_MASK; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
    
      temp |= bs << SMFC_BS0_SHIFT; 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM1: 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_BS1_MASK; 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
    
      temp |= bs << SMFC_BS1_SHIFT; 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM2: 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_BS2_MASK; 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      temp |= bs << SMFC_BS2_SHIFT; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM3: 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      temp &= ~SMFC_BS3_MASK; 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      temp |= bs << SMFC_BS3_SHIFT; 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
     return; 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
    
      ipu_smfc_write(ipu, temp, SMFC_BS); 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
函数作用是设置IDMACchannel的burstsize（脉冲串？），根据传入的bs参数设置SMFC_BS寄存器即可。
 
 

 
 
21._ipu_csi_init函数，它在ipu_common.c中的ipu_init_channel函数中调用了。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     int _ipu_csi_init(struct ipu_soc *ipu, 
     ipu_channel_t channel, 
     uint32_t csi) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     uint32_t csi_sens_conf, csi_dest; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     int retval = 
     0; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     switch (channel) { 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM0: 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM1: 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM2: 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
     case CSI_MEM3: 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      csi_dest = CSI_DATA_DEST_IDMAC; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
     
     case CSI_PRP_ENC_MEM: 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
     case CSI_PRP_VF_MEM: 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      csi_dest = CSI_DATA_DEST_IC; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     break; 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
     
     default: 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
    
      retval = -EINVAL; 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
     
     goto err; 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
    
      csi_sens_conf = ipu_csi_read(ipu, csi, CSI_SENS_CONF); 
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
    
      csi_sens_conf &= ~CSI_SENS_CONF_DATA_DEST_MASK; 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
    
      ipu_csi_write(ipu, csi, csi_sens_conf | (csi_dest << 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
    
      CSI_SENS_CONF_DATA_DEST_SHIFT), CSI_SENS_CONF); 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      err: 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
     return retval; 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
这个函数初始化csi设备，它根据传入的channel的不同，设置不同的csi数据目的地，然后将这个目的地设置到CSI_SENS_CONF寄存器中。感觉这个channel在ipu内部的意思就是ipu内数据流通的过程，每个channle里面都含有目的地等信息。
 
 

 
 
22._ipu_csi_wait4eof函数，在ipu_common.c中的ipu_disable_csi函数中调用了。
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     void _ipu_csi_wait4eof(struct ipu_soc *ipu, 
     ipu_channel_t channel) 
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     int ret; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     int irq = 
     0; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
     
     if (channel == CSI_MEM0) 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_CSI0_OUT_EOF; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
     
     else 
     if (channel == CSI_MEM1) 
    
     
   
  9.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_CSI1_OUT_EOF; 
    
     
   
  10.  
   
     
    
     
   
     
   
     
    
     
     else 
     if (channel == CSI_MEM2) 
    
     
   
  11.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_CSI2_OUT_EOF; 
    
     
   
  12.  
   
     
    
     
   
     
   
     
    
     
     else 
     if (channel == CSI_MEM3) 
    
     
   
  13.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_CSI3_OUT_EOF; 
    
     
   
  14.  
   
     
    
     
   
     
   
     
    
     
     else 
     if (channel == CSI_PRP_ENC_MEM) 
    
     
   
  15.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_PRP_ENC_OUT_EOF; 
    
     
   
  16.  
   
     
    
     
   
     
   
     
    
     
     else 
     if (channel == CSI_PRP_VF_MEM) 
    
     
   
  17.  
   
     
    
     
   
     
   
     
    
    
      irq = IPU_IRQ_PRP_VF_OUT_EOF; 
    
     
   
  18.  
   
     
    
     
   
     
   
     
    
     
     else{ 
    
     
   
  19.  
   
     
    
     
   
     
   
     
    
    
      dev_err(ipu->dev, 
     "Not a CSI channel\n"); 
    
     
   
  20.  
   
     
    
     
   
     
   
     
    
     
     return; 
    
     
   
  21.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  22.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  23.  
   
     
    
     
   
     
   
     
    
    
      init_completion(&ipu->csi_comp); 
    
     
   
  24.  
   
     
    
     
   
     
   
     
    
    
      ret = ipu_request_irq(ipu, irq, csi_irq_handler, 
     0, 
     NULL, ipu); 
    
     
   
  25.  
   
     
    
     
   
     
   
     
    
     
     if (ret < 
     0) { 
    
     
   
  26.  
   
     
    
     
   
     
   
     
    
    
      dev_err(ipu->dev, 
     "CSI irq %d in use\n", irq); 
    
     
   
  27.  
   
     
    
     
   
     
   
     
    
     
     return; 
    
     
   
  28.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
  29.  
   
     
    
     
   
     
   
     
    
    
      ret = wait_for_completion_timeout(&ipu->csi_comp, msecs_to_jiffies( 
     500)); 
    
     
   
  30.  
   
     
    
     
   
     
   
     
    
    
      ipu_free_irq(ipu, irq, ipu); 
    
     
   
  31.  
   
     
    
     
   
     
   
     
    
    
      dev_dbg(ipu->dev, 
     "CSI stop timeout - %d * 10ms\n", 
     5 - ret); 
    
     
   
  32.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
它的中断处理函数如下：
 
 
 
 
  1.  
   
     
    
     
   
     
   
     
    
     
     static irqreturn_t csi_irq_handler(int irq, void *dev_id)  
    
     
   
  2.  
   
     
    
     
   
     
   
     
    
    
      { 
    
     
   
  3.  
   
     
    
     
   
     
   
     
    
     
     struct ipu_soc *ipu = dev_id; 
    
     
   
  4.  
   
     
    
     
   
     
   
     
    
     
     struct completion *comp = &ipu->csi_comp; 
    
     
   
  5.  
   
     
    
     
   
     
   
     
    
     
    
     
   
  6.  
   
     
    
     
   
     
   
     
    
    
      complete(comp); 
    
     
   
  7.  
   
     
    
     
   
     
   
     
    
     
     return IRQ_HANDLED; 
    
     
   
  8.  
   
     
    
     
   
     
   
     
    
    
      } 
    
     
   
 
 
 
 
这个函数中，首先根据channel的不同值设置不同的irq触发方式，然后初始化完成量，然后调用ipu_request_irq函数申请中断，这个函数在ipu_common.c中定义。如果发生中断后，就会调用到这个中断处理函数，在中断处理函数中通过complete（）函数来唤醒阻塞在ipu->csi_comp上的首个线程。wait_for_completion_timeout函数表示，如果超过一定时间没有发生这个中断，就直接结束等待。
 
 

 
 
关于这个完成量的解释和操作函数，可以看《Linux的completion机制.pdf》和《线程的约会completion.pdf》两个文件。
 
 

 
 
至此，这个文件简单分析完毕。
 
 
 
  
 
 
 
 
 


                

               本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/946329
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号