ov5640_mipi.c分析

迈不过友情╰ 2022-07-14 06:15 357阅读 0赞

From:http://blog.csdn.net/yanbixing123?viewmode=contents

在ov5640芯片手册中看到这样一句话：

The OV5640 supports both a digital video parallel port and a serial MIPI port.

所以ov5640既支持数字并口视频传输，同样支持mipi接口规范。

摄像头插入到开发板上面的时候，如果有匹配的驱动程序，就会调用到probe函数，先从probe函数来分析。

（一）probe函数

1.1 获取设备ID

在probe函数中，首先通过几个of类函数来获取pwn-gpios，rst-gpios等的值。

然后就是设置sensor\_data结构体ov5640\_data。每个sensor\_data结构体都代表一个具体的设备，来看看这个结构体：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **struct** sensor\_data \{   
2.      **const** **struct** ov5642\_platform\_data \*platform\_data;   
3.      **struct** v4l2\_int\_device \*v4l2\_int\_device;   
4.      **struct** i2c\_client \*i2c\_client;   
5.      **struct** v4l2\_pix\_format pix;   
6.      **struct** v4l2\_captureparm streamcap;   
7.      **bool** on;  //设备是否上电  
8.    
9.      /\* control settings \*/   
10.     **int** brightness;   
11.     **int** hue;   
12.     **int** contrast;   
13.     **int** saturation;   
14.     **int** red;   
15.     **int** green;   
16.     **int** blue;   
17.     **int** ae\_mode;   
18.   
19.     u32 mclk;  //mclk时钟  
20.     u8 mclk\_source;  //mclk时钟源  
21.     **struct** clk \*sensor\_clk;   
22.     **int** csi;   
23.   
24.     **void** (\*io\_init)(**void**);  //初始化函数  
25. \};

然后就是填充这个结构体，重点是i2c\_client的填充，需要根据填充的这个client来找到对应的设备。那么怎么确定找到的设备就是我们想要的呢？就是通过读设备的设备ID。可以看到在probe函数中通过：

retval= ov5640\_read\_reg(OV5640\_CHIP\_ID\_HIGH\_BYTE, &chip\_id\_high); 和

retval= ov5640\_read\_reg(OV5640\_CHIP\_ID\_LOW\_BYTE, &chip\_id\_low);

来分别读取ov5640设备ID的高字节和低字节。我们可以看到，在ov5640\_mipi.c中是这样定义的：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#define OV5640\_CHIP\_ID\_HIGH\_BYTE    0x300A   
2.  \#define OV5640\_CHIP\_ID\_LOW\_BYTE 0x300B

我们将这两个地址去ov5640的芯片手册中搜索可以发现，

![SouthEast][]

这两个地址就是ov5640设备的ID所在的地址，通过这个设备ID就能确定我们找到的设备。

1.2 ov5640\_power\_on函数

ov5640\_power\_on(dev);

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov5640\_power\_on(dev);  
2.  **static** **int** ov5640\_power\_on(**struct** device \*dev)   
3.  \{   
4.      **int** ret = 0;   
5.    
6.      io\_regulator = devm\_regulator\_get(dev, "DOVDD");   
7.      **if** (!IS\_ERR(io\_regulator)) \{   
8.          regulator\_set\_voltage(io\_regulator,   
9.                        OV5640\_VOLTAGE\_DIGITAL\_IO,   
10.                       OV5640\_VOLTAGE\_DIGITAL\_IO);   
11.         ret = regulator\_enable(io\_regulator);   
12.         **if** (ret) \{   
13.             pr\_err("%s:io set voltage error\\n", \_\_func\_\_);   
14.             **return** ret;   
15.         \} **else** \{   
16.             dev\_dbg(dev,   
17.                 "%s:io set voltage ok\\n", \_\_func\_\_);   
18.         \}   
19.     \} **else** \{   
20.         pr\_err("%s: cannot get io voltage error\\n", \_\_func\_\_);   
21.         io\_regulator = NULL;   
22.     \}   
23.   
24.     core\_regulator = devm\_regulator\_get(dev, "DVDD");   
25.     **if** (!IS\_ERR(core\_regulator)) \{   
26.         regulator\_set\_voltage(core\_regulator,   
27.                       OV5640\_VOLTAGE\_DIGITAL\_CORE,   
28.                       OV5640\_VOLTAGE\_DIGITAL\_CORE);   
29.         ret = regulator\_enable(core\_regulator);   
30.         **if** (ret) \{   
31.             pr\_err("%s:core set voltage error\\n", \_\_func\_\_);   
32.             **return** ret;   
33.         \} **else** \{   
34.             dev\_dbg(dev,   
35.                 "%s:core set voltage ok\\n", \_\_func\_\_);   
36.         \}   
37.     \} **else** \{   
38.         core\_regulator = NULL;   
39.         pr\_err("%s: cannot get core voltage error\\n", \_\_func\_\_);   
40.     \}   
41.   
42.     analog\_regulator = devm\_regulator\_get(dev, "AVDD");   
43.     **if** (!IS\_ERR(analog\_regulator)) \{   
44.         regulator\_set\_voltage(analog\_regulator,   
45.                       OV5640\_VOLTAGE\_ANALOG,   
46.                       OV5640\_VOLTAGE\_ANALOG);   
47.         ret = regulator\_enable(analog\_regulator);   
48.         **if** (ret) \{   
49.             pr\_err("%s:analog set voltage error\\n",   
50.                 \_\_func\_\_);   
51.             **return** ret;   
52.         \} **else** \{   
53.             dev\_dbg(dev,   
54.                 "%s:analog set voltage ok\\n", \_\_func\_\_);   
55.         \}   
56.     \} **else** \{   
57.         analog\_regulator = NULL;   
58.         pr\_err("%s: cannot get analog voltage error\\n", \_\_func\_\_);   
59.     \}   
60.   
61.     **return** ret;   
62. \}

从上面的程序中可以看出来，它设置了三个regulator，中文翻译为”稳定器“，内核中有关于这个的模块的驱动框架，关于这个驱动框架的分析可以查看：

[http://www.wowotech.net/pm\_subsystem/regulator\_framework\_overview.html][http_www.wowotech.net_pm_subsystem_regulator_framework_overview.html]

我们这里只分析与我们相关的东西。

通过regulator\_set\_voltage函数来为这几个regulator设置电压，分别设置为OV5640\_VOLTAGE\_DIGITAL\_IO，OV5640\_VOLTAGE\_DIGITAL\_CORE和OV5640\_VOLTAGE\_ANALOG。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#define OV5640\_VOLTAGE\_ANALOG               2800000   
2.  \#define OV5640\_VOLTAGE\_DIGITAL\_CORE         1500000   
3.  \#define OV5640\_VOLTAGE\_DIGITAL\_IO           1800000

同时，在dts文件中，定义了它的电压为多少，

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov564x\_mipi: ov564x\_mipi@3c \{ /\* i2c2 driver \*/   
2.      compatible = "ovti,ov564x\_mipi";   
3.      reg = <0x3c>;   
4.      clocks = <&clks 201>;   
5.      clock-names = "csi\_mclk";   
6.      <span style="color:\#FF0000;">DOVDD-supply = <&vgen4\_reg>; /\* 1.8v \*/   
7.      AVDD-supply = <&vgen3\_reg>;  /\* 2.8v, rev C board is VGEN3  
8.                      rev B board is VGEN5 \*/   
9.      DVDD-supply = <&vgen2\_reg>;  /\* 1.5v\*/ </span>  
10.     pwn-gpios = <&gpio1 19 1>;   /\* active low: SD1\_CLK \*/   
11.     rst-gpios = <&gpio1 20 0>;   /\* active high: SD1\_DAT2 \*/   
12.     csi\_id = <1>;   
13.     mclk = <24000000>;   
14.     mclk\_source = <0>;   
15. \};

可以看出来，它们设置的一致。那么在dts文件中为啥这么设置呢？肯定是根据ov5640的芯片手册中设置的：

![SouthEast 1][]

1.3 ov5640\_reset函数

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov5640\_reset();

这个函数用来重置摄像头，如下所示：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** ov5640\_reset(**void**)   
2.  \{   
3.      /\* camera reset \*/   
4.      gpio\_set\_value(rst\_gpio, 1);   
5.    
6.      /\* camera power dowmn \*/   
7.      gpio\_set\_value(pwn\_gpio, 1);   
8.      msleep(5);   
9.    
10.     gpio\_set\_value(pwn\_gpio, 0);   
11.     msleep(5);   
12.   
13.     gpio\_set\_value(rst\_gpio, 0);   
14.     msleep(1);   
15.   
16.     gpio\_set\_value(rst\_gpio, 1);   
17.     msleep(5);   
18.   
19.     gpio\_set\_value(pwn\_gpio, 1);   
20. \}

这里面的rst\_gpio和pwn\_gpio是在probe函数中通过of类函数获取的，既然是通过of类函数获得的，那么在dts文件中肯定有对应的设置：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov564x\_mipi: ov564x\_mipi@3c \{ /\* i2c2 driver \*/   
2.      compatible = "ovti,ov564x\_mipi";   
3.      reg = <0x3c>;   
4.      clocks = <&clks 201>;   
5.      clock-names = "csi\_mclk";   
6.      DOVDD-supply = <&vgen4\_reg>; /\* 1.8v \*/   
7.      AVDD-supply = <&vgen3\_reg>;  /\* 2.8v, rev C board is VGEN3  
8.                      rev B board is VGEN5 \*/   
9.      DVDD-supply = <&vgen2\_reg>;  /\* 1.5v\*/   
10.     <span style="color:\#FF0000;">pwn-gpios = <&gpio1 19 1>;   /\* active low: SD1\_CLK \*/   
11.     rst-gpios = <&gpio1 20 0>;   /\* active high: SD1\_DAT2 \*/ </span>  
12.     csi\_id = <1>;   
13.     mclk = <24000000>;   
14.     mclk\_source = <0>;   
15. \};

这个函数操作的是gpio1的19和20位，关于这两位引脚的意义还需要继续深入。它一共包含3个参数，第一个参数表示gpio1，第二个参数是否表示gpio1的哪一位？？第三个参数表示默认值。比如说pwn-gpios的默认值是1,说明置0的时候是上电，置1的时候是关电。

同时，重置摄像头的时候，ov5640\_reset()函数设置pwn-gpios和rst-gpios的写入顺序是否是固定的？

1.3 ov5640\_standby函数

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov5640\_standby(0);  
2.  **static** **void** ov5640\_standby(s32 enable)   
3.  \{   
4.      **if** (enable)   
5.          gpio\_set\_value(pwn\_gpio, 1);   
6.      **else**   
7.          gpio\_set\_value(pwn\_gpio, 0);  
8.      msleep(2);   
9.  \}

这个函数就是根据函数的传入参数来向pwn\_gpio寄存器写值，向pwn\_gpio寄存器写1表示关电,写0代表关电。至于向寄存器中写1代表上电还是关电，这个需要查看对应寄存器在dts文件中写进去的值。

1.4

先上电，通过ov5640\_read\_reg函数来获取摄像头的设备ID以后，再次使用ov5640\_standby(1);来关电。

之后就是通过ov5640\_int\_device.priv= &ov5640\_data;来将ov5640\_int\_device结构体的priv指向设置好的sensor\_data结构体，然后通过

retval= v4l2\_int\_device\_register(&ov5640\_int\_device);来将ov5640\_int\_device作为一个slave设备注册到v4l2框架中，在这个函数中，会将slave设备添加到int\_list链表中，尝试使用v4l2\_int\_device\_try\_attach\_all函数来匹配master设备。

（二）在probe函数执行完毕以后，就可以操作这个摄像头了，之后我们继续按照mxc\_v4l2\_capture.c这个应用程序的执行过程来完善ov5640\_mipi的一些操作。首先是open函数。

2.1 vidioc\_int\_g\_ifparm函数

在open函数中，首先调用vidioc\_int\_g\_ifparm(cam->sensor,&ifparm);函数来从slave设备中获取ifparm的信息，最终会调用到ov5640\_mipi.c的ioctl\_g\_ifparm函数。先来看open函数中，它传入了两个参数：cam->sensor,ifparm；其实在ov5640\_mipi.c中，它并没有从cam->sensor里面获取ifparm的信息来填充到ifparm中，而是在ioctl\_g\_ifparm函数中直接为ifparm中的各个成员变量赋值。主要是为ifparm.u.bt656成员赋值，包括clock\_curr，mode，clock\_min，clock\_max等等。

2.2 vidioc\_int\_g\_fmt\_cap函数

在这个函数中，就直接用f->fmt.pix= sensor->pix;来将sensor\_data里面的pix结构体赋给了cam\_fmt里面的fmt.pix结构体。

2.3 vidioc\_int\_s\_power函数

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  vidioc\_int\_s\_power(cam->sensor, 1);  
2.    
3.  **static** **int** ioctl\_s\_power(**struct** v4l2\_int\_device \*s, **int** on)   
4.  \{   
5.      **struct** sensor\_data \*sensor = s->priv;   
6.      **if** (on && !sensor->on) \{   
7.          **if** (io\_regulator)   
8.              **if** (regulator\_enable(io\_regulator) != 0)   
9.                  **return** -EIO;   
10.         **if** (core\_regulator)   
11.             **if** (regulator\_enable(core\_regulator) != 0)   
12.                 **return** -EIO;   
13.         **if** (gpo\_regulator)   
14.             **if** (regulator\_enable(gpo\_regulator) != 0)   
15.                 **return** -EIO;   
16.         **if** (analog\_regulator)   
17.             **if** (regulator\_enable(analog\_regulator) != 0)   
18.                 **return** -EIO;   
19.         /\* Make sure power on \*/   
20.         ov5640\_standby(0);   
21.     \} **else** **if** (!on && sensor->on) \{   
22.         **if** (analog\_regulator)   
23.             regulator\_disable(analog\_regulator);   
24.         **if** (core\_regulator)   
25.             regulator\_disable(core\_regulator);   
26.         **if** (io\_regulator)   
27.             regulator\_disable(io\_regulator);   
28.         **if** (gpo\_regulator)   
29.             regulator\_disable(gpo\_regulator);   
30.         ov5640\_standby(1);   
31.     \}   
32.     sensor->on = on;   
33.     **return** 0;   
34. \}

在这个函数中，会根据vidioc\_int\_s\_power函数传入的第二个参数的值on来决定是否将设备上电。1表示上电，0表示关电。这里面的io\_regulator，core\_regulator和analog\_regulator是在ov5640\_power\_on函数中获取到的，gpo\_regulator应该没有设置。然后需要注意的一点是：在ioctl\_s\_power函数中的第二个参数如果为1的话代表上电，为0的话代表关电。但是在ov5640\_standby函数中，如果为0代表上电，为1代表关电。所以，在if(on &&!sensor->on)判断语句中，如果想要确定摄像头是上电的话，需要使用ov5640\_standby(0);。这一点比较拗口。

2.4 vidioc\_int\_dev\_init函数

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  vidioc\_int\_dev\_init(cam->sensor);  
2.    
3.  **static** **int** ioctl\_dev\_init(**struct** v4l2\_int\_device \*s)   
4.  \{   
5.      **struct** sensor\_data \*sensor = s->priv;   
6.      u32 tgt\_xclk;   /\* target xclk \*/   
7.      u32 tgt\_fps;    /\* target frames per secound \*/   
8.      **int** ret;   
9.      **enum** ov5640\_frame\_rate frame\_rate;   
10.     **void** \*mipi\_csi2\_info;   
11.   
12.     ov5640\_data.on = **true**;   
13.   
14.     /\* mclk \*/   
15.     tgt\_xclk = ov5640\_data.mclk;   
16.     tgt\_xclk = min(tgt\_xclk, (u32)OV5640\_XCLK\_MAX);   
17.     tgt\_xclk = max(tgt\_xclk, (u32)OV5640\_XCLK\_MIN);   
18.     ov5640\_data.mclk = tgt\_xclk;   
19.   
20.     pr\_debug("   Setting mclk to %d MHz\\n", tgt\_xclk / 1000000);   
21.   
22.     /\* Default camera frame rate is set in probe \*/   
23.     tgt\_fps = sensor->streamcap.timeperframe.denominator /   
24.           sensor->streamcap.timeperframe.numerator;   
25.   
26.     pr\_debug(" tft\_fps is %d.\\n", tgt\_fps);   
27.   
28.     **if** (tgt\_fps == 15)   
29.         frame\_rate = ov5640\_15\_fps;   
30.     **else** **if** (tgt\_fps == 30)   
31.         frame\_rate = ov5640\_30\_fps;   
32.     **else**   
33.         **return** -EINVAL; /\* Only support 15fps or 30fps now. \*/   
34.   
35.     mipi\_csi2\_info = mipi\_csi2\_get\_info();   
36.   
37.     /\* enable mipi csi2 \*/   
38.     **if** (mipi\_csi2\_info)   
39.         mipi\_csi2\_enable(mipi\_csi2\_info);   
40.     **else** \{   
41.         printk(KERN\_ERR "%s() in %s: Fail to get mipi\_csi2\_info!\\n",   
42.                \_\_func\_\_, \_\_FILE\_\_);   
43.         **return** -EPERM;   
44.     \}   
45.   
46.     ret = ov5640\_init\_mode(frame\_rate, ov5640\_mode\_INIT, ov5640\_mode\_INIT);   
47.   
48.     **return** ret;   
49. \}

2.4.1

在这个函数中，首先通过tgt\_xclk= ov5640\_data.mclk;来获取到mclk的值。这个ov5640\_data.mclk是在probe函数中设置的。然后对tgt\_xclk与摄像头允许的最大值最小值进行判断,

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#define OV5640\_XCLK\_MIN 6000000   
2.  \#define OV5640\_XCLK\_MAX 24000000

使得tgt\_xclk位于这个区间内。

然后计算tgt\_fps的值，它需要的两个值同样是在probe函数中设置的。

根据tgt\_fps的值来设置frame\_rate的值，这个frame\_rate用在后面的ov5640\_init\_mode函数中。

然后通过mipi\_csi2\_get\_info函数来获取到mxc\_mipi\_csi2.c文件中的gmipi\_csi2结构体，这个结构体是一个全局变量。获取到这个结构体以后通过mipi\_csi2\_enable函数来使能。具体操作是设置mipi\_csi2\_info结构体里面的mipi\_en位为true，然后通过clk\_prepare\_enable函数来使能mipi\_csi2\_info结构体里面的cfg\_clk和dphy\_clk。

之后就是调用ov5640\_init\_mode函数了。

2.4.2 ov5640\_init\_mode函数

这个函数在ioctl\_s\_parm函数和ioctl\_dev\_init函数中调用，这个函数用来设置ov5640的模式，有以下几种模式：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **enum** ov5640\_mode \{   
2.      ov5640\_mode\_MIN = 0,   
3.      ov5640\_mode\_VGA\_640\_480 = 0,   
4.      ov5640\_mode\_QVGA\_320\_240 = 1,   
5.      ov5640\_mode\_NTSC\_720\_480 = 2,   
6.      ov5640\_mode\_PAL\_720\_576 = 3,   
7.      ov5640\_mode\_720P\_1280\_720 = 4,   
8.      ov5640\_mode\_1080P\_1920\_1080 = 5,   
9.      ov5640\_mode\_QSXGA\_2592\_1944 = 6,   
10.     ov5640\_mode\_QCIF\_176\_144 = 7,   
11.     ov5640\_mode\_XGA\_1024\_768 = 8,   
12.     ov5640\_mode\_MAX = 8,   
13.     ov5640\_mode\_INIT = 0xff, /\*only for sensor init\*/   
14. \};

在mxc\_v4l2\_capture.c这个应用程序中，可以通过\-m选项来指定使用哪种模式，然后将\-m后面指定的模式保存在g\_capture\_mode中，然后通过parm.parm.capture.capturemode= g\_capture\_mode;再调用ioctl(fd\_v4l,VIDIOC\_S\_PARM, &parm)函数，最终就会调用这个ov5640\_init\_mode函数来修改ov5640的模式。

在ioctl\_dev\_init函数中已经设置了frame\_rate，然后设置ov5640\_init\_mode函数其他两个参数，第二个参数表示新设置的mode，第三个参数表示原来的mode。但是需要注意的是在mxc\_v4l2\_capture.c中的mxc\_v4l\_open函数，它调用ov5640\_init\_mode来初始化摄像头，这时候，摄像头的初始mode和新mode都没有指定，上面说了，它们是在VIDIOC\_S\_PARMioctl中指定的，这时候就需要指定ov5640\_init\_mode的第二个和第三个参数都为ov5640\_mode\_INIT。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** ov5640\_init\_mode(**enum** ov5640\_frame\_rate frame\_rate,   
2.                  **enum** ov5640\_mode mode, **enum** ov5640\_mode orig\_mode)   
3.  \{   
4.      **struct** reg\_value \*pModeSetting = NULL;   
5.      s32 ArySize = 0;   
6.      **int** retval = 0;   
7.      **void** \*mipi\_csi2\_info;   
8.      u32 mipi\_reg, msec\_wait4stable = 0;   
9.      **enum** ov5640\_downsize\_mode dn\_mode, orig\_dn\_mode;   
10.   
11.     **if** ((mode > ov5640\_mode\_MAX || mode < ov5640\_mode\_MIN)   
12.         && (mode != ov5640\_mode\_INIT)) \{   
13.         pr\_err("Wrong ov5640 mode detected!\\n");   
14.         **return** -1;   
15.     \}

/\*对mode进行判断，根据上面列举的enumov5640\_mode，它就是判断传入的mode是否合法。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  mipi\_csi2\_info = mipi\_csi2\_get\_info(); //获取 mipi\_csi2\_info  
2.    
3.  /\* initial mipi dphy \*/   
4.  **if** (!mipi\_csi2\_info) \{   
5.      printk(KERN\_ERR "%s() in %s: Fail to get mipi\_csi2\_info!\\n",   
6.             \_\_func\_\_, \_\_FILE\_\_);   
7.      **return** -1;   
8.  \}

/\*判断mipi\_csi2\_info是否获取成功\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **if** (!mipi\_csi2\_get\_status(mipi\_csi2\_info))   
2.      mipi\_csi2\_enable(mipi\_csi2\_info);   
3.    
4.  **if** (!mipi\_csi2\_get\_status(mipi\_csi2\_info)) \{   
5.      pr\_err("Can not enable mipi csi2 driver!\\n");   
6.      **return** -1;   
7.  \}

/\*首先判断mipi\_csi2\_info中mipi\_en是否置位，这一位表示是否使能了mipi摄像头。如果没有使能的话，就调用mipi\_csi2\_enable函数来使能mipi\_csi2\_info里面的cfg\_clk和dphy\_clk，然后将mipi\_en置位为true。设置好以后继续调用mipi\_csi2\_get\_status函数来确定是否使能成功。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  mipi\_csi2\_set\_lanes(mipi\_csi2\_info);

/\*在这个函数中将mipi\_csi2\_info里面的lanes的值写到MIPI\_CSI2\_N\_LANES寄存器中，

![SouthEast 2][]

而这个mipi\_csi2\_info里面的lanes的值是什么时候获取到的呢？在mxc\_mipi\_csi2.c文件中的mipi\_csi2\_probe函数中，通过of\_property\_read\_u32函数来保存到mipi\_csi2\_info中的。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\*Only reset MIPI CSI2 HW at sensor initialize\*/   
2.  **if** (mode == ov5640\_mode\_INIT)   
3.      mipi\_csi2\_reset(mipi\_csi2\_info);

/\*如果是mode等于ov5640\_mode\_INIT，就表示是在ioctl\_dev\_init函数中调用的，就调用mipi\_csi2\_reset函数来初始化MIPI\_CSI2相关的寄存器。这个函数在mxc\_mipi\_csi2.c文件中定义.

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **int** mipi\_csi2\_reset(**struct** mipi\_csi2\_info \*info)   
2.  \{   
3.      \_mipi\_csi2\_lock(info);   
4.    
5.      mipi\_csi2\_write(info, 0x0, MIPI\_CSI2\_PHY\_SHUTDOWNZ);   
6.      mipi\_csi2\_write(info, 0x0, MIPI\_CSI2\_DPHY\_RSTZ);   
7.      mipi\_csi2\_write(info, 0x0, MIPI\_CSI2\_CSI2\_RESETN);   
8.    
9.      mipi\_csi2\_write(info, 0x00000001, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
10.     mipi\_csi2\_write(info, 0x00000000, MIPI\_CSI2\_PHY\_TST\_CTRL1);   
11.     mipi\_csi2\_write(info, 0x00000000, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
12.     mipi\_csi2\_write(info, 0x00000002, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
13.     mipi\_csi2\_write(info, 0x00010044, MIPI\_CSI2\_PHY\_TST\_CTRL1);   
14.     mipi\_csi2\_write(info, 0x00000000, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
15.     mipi\_csi2\_write(info, 0x00000014, MIPI\_CSI2\_PHY\_TST\_CTRL1);   
16.     mipi\_csi2\_write(info, 0x00000002, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
17.     mipi\_csi2\_write(info, 0x00000000, MIPI\_CSI2\_PHY\_TST\_CTRL0);   
18.   
19.     mipi\_csi2\_write(info, 0xffffffff, MIPI\_CSI2\_PHY\_SHUTDOWNZ);   
20.     mipi\_csi2\_write(info, 0xffffffff, MIPI\_CSI2\_DPHY\_RSTZ);   
21.     mipi\_csi2\_write(info, 0xffffffff, MIPI\_CSI2\_CSI2\_RESETN);   
22.   
23.     \_mipi\_csi2\_unlock(info);   
24.   
25.     **return** 0;   
26. \}   
27. EXPORT\_SYMBOL(mipi\_csi2\_reset);

这个函数中反复向MIPI\_CSI2\_PHY\_TST\_CTRL0和MIPI\_CSI2\_PHY\_TST\_CTRL1寄存器中写不同的值，到底有什么目的？？明天来了把值写进去仔细看看。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **if** (ov5640\_data.pix.pixelformat == V4L2\_PIX\_FMT\_UYVY)   
2.      mipi\_csi2\_set\_datatype(mipi\_csi2\_info, MIPI\_DT\_YUV422);   
3.  **else** **if** (ov5640\_data.pix.pixelformat == V4L2\_PIX\_FMT\_RGB565)   
4.      mipi\_csi2\_set\_datatype(mipi\_csi2\_info, MIPI\_DT\_RGB565);   
5.  **else**   
6.      pr\_err("currently this sensor format can not be supported!\\n");

/\*根据ov5640\_data.pix.pixelformat的值来设置mipi\_csi2\_info里面的datatype的值。通过mipi\_csi2\_set\_datatype函数来设置。这个ov5640\_data.pix.pixelformat的值是在ov5640\_probe函数中设置的。从这两个判断语句中可以推断出来，在这个驱动中，指定摄像头只支持V4L2\_PIX\_FMT\_UYVY和V4L2\_PIX\_FMT\_RGB565两种格式。\*/

/\*看下面的代码前，需要对enumov5640\_downsize\_mode进行一个初步的了解：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* image size under 1280 \* 960 are SUBSAMPLING  
2.   \* image size upper 1280 \* 960 are SCALING  
3.   \*/   
4.  **enum** ov5640\_downsize\_mode \{   
5.      SUBSAMPLING,   
6.      SCALING,   
7.  \};

这个enum的注释写的很清楚了，当imagesize大于1280\* 960时，downsize\_mode为SCALING，当imagesize小于1280\* 960时，downsize\_mode为SUBSAMPLING。下面的代码主要是根据新mode的ov5640\_downsize\_mode类型和初始mode的ov5640\_downsize\_mode类型来决定使用哪个函数来切换mode模式。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  dn\_mode = ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].dn\_mode;   
2.  orig\_dn\_mode = ov5640\_mode\_info\_data\[frame\_rate\]\[orig\_mode\].dn\_mode;

/\*在这里有一个二维数组ov5640\_mode\_info\_data：

staticstruct ov5640\_mode\_info ov5640\_mode\_info\_data\[2\]\[ov5640\_mode\_MAX +1\]，再来看这个函数中，它会根据frame\_rate和mode两个下标来找到对应的元素。关于这个frame\_rate，它是enumov5640\_frame\_rate类型的，

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **enum** ov5640\_frame\_rate \{   
2.      ov5640\_15\_fps,   
3.      ov5640\_30\_fps   
4.  \};

这两个值默认为0和1.关于enum的默认值的分析可以看：《[C][][语言enum][C][枚举类型解析][C]》

[http://blog.csdn.net/skyflying2012/article/details/22736633][C]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **if** (mode == ov5640\_mode\_INIT) \{   
2.      pModeSetting = ov5640\_init\_setting\_30fps\_VGA;   
3.      ArySize = ARRAY\_SIZE(ov5640\_init\_setting\_30fps\_VGA);   
4.    
5.      ov5640\_data.pix.width = 640;   
6.      ov5640\_data.pix.height = 480;   
7.      retval = ov5640\_download\_firmware(pModeSetting, ArySize);   
8.      **if** (retval < 0)   
9.          **goto** err;   
10.   
11.     pModeSetting = ov5640\_setting\_30fps\_VGA\_640\_480;   
12.     ArySize = ARRAY\_SIZE(ov5640\_setting\_30fps\_VGA\_640\_480);   
13.     retval = ov5640\_download\_firmware(pModeSetting, ArySize);   
14. \}

/\*当mode为ov5640\_mode\_INIT时，代表第一次初始化摄像头设备，就直接设置pModeSetting和ArySize的值，然后调用ov5640\_download\_firmware函数来初始化摄像头。在这个文件中，可以看出来ov5640\_init\_setting\_30fps\_VGA数组是一堆寄存器的地址和值的组合，通过这个函数来设置摄像头内部寄存器的值，而不是设置开发板上面的控制寄存器。这些值可以对照ov5640摄像头的芯片手册来查看。但是不理解的是，在这里设置了两次，分别为ov5640\_init\_setting\_30fps\_VGA和ov5640\_setting\_30fps\_VGA\_640\_480。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **else** **if** ((dn\_mode == SUBSAMPLING && orig\_dn\_mode == SCALING) ||   
2.              (dn\_mode == SCALING && orig\_dn\_mode == SUBSAMPLING)) \{   
3.          /\* change between subsampling and scaling  
4.           \* go through exposure calucation \*/   
5.          retval = ov5640\_change\_mode\_exposure\_calc(frame\_rate, mode);   
6.      \}

/\*因为dn\_mode和orig\_dn\_mode都是enumov5640\_downsize\_mode类型的，它们都只有两种值，所以当两者不同时，就通过ov5640\_change\_mode\_exposure\_calc函数来改变摄像头的mode。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **else** \{   
2.          /\* change inside subsampling or scaling  
3.           \* download firmware directly \*/   
4.          retval = ov5640\_change\_mode\_direct(frame\_rate, mode);   
5.      \}

/\*当dn\_mode和orig\_dn\_mode这两者相同时，就直接调用ov5640\_change\_mode\_direct函数改变mode就行了。关于这三个函数的分析，在分析完这个函数后分析。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **if** (retval < 0)   
2.      **goto** err;

/\*总之，当调用ov5640\_init\_mode函数的时候，比如在ioctl\_dev\_init函数中调用，它就表示第一次使用摄像头，ov5640\_init\_mode函数的mode模式都为ov5640\_mode\_INIT，然后就会在ov5640\_init\_mode函数中调用ov5640\_download\_firmware函数来设置摄像头上面的寄存器。如果是在VIDIOC\_S\_PARMioctl调用的时候，这时候，就可能修改ov5640\_init\_mode函数里面的mode模式，这时候就需要根据mode模式里面的ov5640\_downsize\_mode来判断是否改变了，如果改变了的话，就会调用ov5640\_change\_mode\_exposure\_calc函数来设置摄像头上面的寄存器，如果没有改变的话，就直接调用ov5640\_change\_mode\_direct设置摄像头上面的寄存器即可。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  OV5640\_set\_AE\_target(AE\_Target);

/\*关于这一块的讲解查看ov5640芯片手册的《4.5AEC/AGC algorithms》这一节，主要是设置自动曝光控制（AutoExposure Control，AEC）和自动增益控制（AutoGain Control，AGC）。

![SouthEast 3][]

函数如下所示：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** OV5640\_set\_AE\_target(**int** target)   
2.  \{   
3.      /\* stable in high \*/   
4.      **int** fast\_high, fast\_low;   
5.      AE\_low = target \* 23 / 25;  /\* 0.92 \*/   
6.      AE\_high = target \* 27 / 25; /\* 1.08 \*/   
7.    
8.      fast\_high = AE\_high<<1;   
9.      **if** (fast\_high > 255)   
10.         fast\_high = 255;   
11.    
12.     fast\_low = AE\_low >> 1;   
13.   
14.     ov5640\_write\_reg(0x3a0f, AE\_high);   
15.     ov5640\_write\_reg(0x3a10, AE\_low);   
16.     ov5640\_write\_reg(0x3a1b, AE\_high);   
17.     ov5640\_write\_reg(0x3a1e, AE\_low);   
18.     ov5640\_write\_reg(0x3a11, fast\_high);   
19.     ov5640\_write\_reg(0x3a1f, fast\_low);   
20.   
21.     **return** 0;   
22. \}

这个计算过程是摄像头相关的算法，在芯片手册中详细介绍了。

ov5640芯片上面的0x3a0f存储的是曝光时间的最大值，0x3a10存储的是曝光时间的最小值。通过这个函数可以看出来它的计算过程。

0x3a1b存储的是图像从稳定状态切换到不稳定状态时曝光时间的最大值，0x3a1e存储的是图像从稳定状态切换到不稳定状态时曝光时间的最小值。

这时候需要理解另外一个寄存器：0x56a1，这个寄存器中保存的是目标图像的亮度平均值，这个寄存器是一个只读寄存器。

![SouthEast 4][]

当0x56a1寄存器的值不在\{0x3a1e,0x3a1b\}这个区间之内时，AEC就调整它们，并且使他们位于\{0x3a10,0x3a0f\}这个区间。所以这个\{0x3a1e,0x3a1b\}这个区间称为稳定状态区间。

当0x56a1寄存器的值位于\{0x3a1e,0x3a1b\}这个区间的时候，就是指图像处于稳定状态。反之，则称为不稳定状态。

上面的讲解是AEC处于auto状态时，AEC就会去自动调节这些参数，同时，这个AEC支持manual模式，关于这个模式的选择，是通过操作0x3503寄存器来完成的，我们在后面的OV5640\_turn\_on\_AE\_AG()函数分析中再具体分析。

当AEC处于manual模式的时候，还分为normal和fast选择。normal就是支持手工一点一点地调节曝光量，fast快速的调节曝光量。究竟有多快速呢。。。\{0x3a1f,0x3a11\}这个区间是fast情况下的曝光区间，当0x56a1寄存器里面的值小于0x3a1f时，AEC就直接将0x56a1寄存器里面的值乘2；当0x56a1寄存器里面的值大于0x3a11时，AEC就直接将0x56a1寄存器里面的值除以2。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  OV5640\_get\_light\_freq();

/\*这个函数如下所示，这个函数的目的是获得ov5640的频闪，关于摄像头频闪的讲解，可以查看《[Camera][][图像处理原理分析\-][Camera][抗噪变焦 频闪 等 ][Camera]》

[http://blog.csdn.net/colorant/article/details/1913334][Camera]：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** OV5640\_get\_light\_freq(**void**)   
2.  \{   
3.      /\* get banding filter value \*/   
4.      **int** temp, temp1, light\_freq = 0;   
5.      u8 tmp;   
6.    
7.      temp = ov5640\_read\_reg(0x3c01, &tmp);   
8.    
9.      **if** (temp & 0x80) \{   
10.         /\* manual \*/   
11.         temp1 = ov5640\_read\_reg(0x3c00, &tmp);   
12.         **if** (temp1 & 0x04) \{   
13.             /\* 50Hz \*/   
14.             light\_freq = 50;   
15.         \} **else** \{   
16.             /\* 60Hz \*/   
17.             light\_freq = 60;   
18.         \}   
19.     \} **else** \{   
20.         /\* auto \*/   
21.         temp1 = ov5640\_read\_reg(0x3c0c, &tmp);   
22.         **if** (temp1 & 0x01) \{   
23.             /\* 50Hz \*/   
24.             light\_freq = 50;   
25.         \} **else** \{   
26.             /\* 60Hz \*/   
27. /\* 这里是不是一个bug，应该写上：light\_freq = 60; \*/  
28.         \}   
29.     \}   
30.     **return** light\_freq;   
31. \}

![SouthEast 5][]

对比程序和芯片手册，可以看出来，首先会根据0x3c01的bit\[7\]来判断是auto还是manual模式，

如果为auto模式的话，就会去读取0x3c0c寄存器的bit\[0\]，为1的话就是50Hz的频闪，为0的话就是60Hz的频闪。

如果为manual模式的话，就会去读取0x3c00寄存器的bit\[2\]，为1的话就是50Hz的频闪，为0的话就是60Hz的频闪。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  OV5640\_set\_bandingfilter();

/\*这个函数是设置摄像头的工频干扰，CMOS是行曝光,也就是在每行曝光时间决定了画面的亮度,举例:一个50HZ的光源,电压曲线为正弦曲线,那能量曲线定性分析可以认为是取了绝对值的电压曲线。那就是能量做1/100秒的周期变化。那就要求曝光的时间必须是1/100秒的整数倍。如果没有把曝光时间调整到1/100秒的整数倍,就有可能会有每行的曝光值不一样,造成同一个image上有水波纹现象。CCD是整帧同时曝光,所以,工频干扰表现的就是图像有轻微的闪烁。产生的原理与CMOS sensor的原理相似。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** OV5640\_set\_bandingfilter(**void**)   
2.  \{   
3.      **int** prev\_VTS;   
4.      **int** band\_step60, max\_band60, band\_step50, max\_band50;   
5.    
6.      /\* read preview PCLK \*/   
7.      prev\_sysclk = OV5640\_get\_sysclk();   
8.      /\* read preview HTS \*/   
9.      prev\_HTS = OV5640\_get\_HTS();   
10.   
11.     /\* read preview VTS \*/   
12.     prev\_VTS = OV5640\_get\_VTS();   
13.   
14.     /\* calculate banding filter \*/   
15.     /\* 60Hz \*/   
16.     band\_step60 = prev\_sysclk \* 100/prev\_HTS \* 100/120;   
17.     ov5640\_write\_reg(0x3a0a, (band\_step60 >> 8));   
18.     ov5640\_write\_reg(0x3a0b, (band\_step60 & 0xff));   
19.   
20.     max\_band60 = (**int**)((prev\_VTS-4)/band\_step60);   
21.     ov5640\_write\_reg(0x3a0d, max\_band60);   
22.   
23.     /\* 50Hz \*/   
24.     band\_step50 = prev\_sysclk \* 100/prev\_HTS;   
25.     ov5640\_write\_reg(0x3a08, (band\_step50 >> 8));   
26.     ov5640\_write\_reg(0x3a09, (band\_step50 & 0xff));   
27.   
28.     max\_band50 = (**int**)((prev\_VTS-4)/band\_step50);   
29.     ov5640\_write\_reg(0x3a0e, max\_band50);   
30. \}

关于这个函数，它首先通过OV5640\_get\_sysclk函数来获取系统的时钟，然后OV5640\_get\_HTS和OV5640\_get\_VTS函数分别获取ov5640的Horizontaltotalsize 和verticaltotal size，对于50Hz和60Hz，有不同的计算方式，但是这个计算方法看半天都没有理解。。。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov5640\_set\_virtual\_channel(ov5640\_data.csi);

/\*这个函数设置虚拟通道，如下所示：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** ov5640\_set\_virtual\_channel(**int** channel)   
2.  \{   
3.      u8 channel\_id;   
4.    
5.      ov5640\_read\_reg(0x4814, &channel\_id);   
6.      channel\_id &= ~(3 << 6);   
7.      ov5640\_write\_reg(0x4814, channel\_id | (channel << 6));   
8.  \}

但是在ov5640的芯片手册中，这几位显示的是DEBUGMODE，如下所示

![SouthEast 6][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* add delay to wait for sensor stable \*/   
2.  **if** (mode == ov5640\_mode\_QSXGA\_2592\_1944) \{   
3.      /\* dump the first two frames: 1/7.5\*2  
4.       \* the frame rate of QSXGA is 7.5fps \*/   
5.      msec\_wait4stable = 267;   
6.  \} **else** **if** (frame\_rate == ov5640\_15\_fps) \{   
7.      /\* dump the first nine frames: 1/15\*9 \*/   
8.      msec\_wait4stable = 600;   
9.  \} **else** **if** (frame\_rate == ov5640\_30\_fps) \{   
10.     /\* dump the first nine frames: 1/30\*9 \*/   
11.     msec\_wait4stable = 300;   
12. \}   
13. msleep(msec\_wait4stable);

/\*根据不同的模式来选择等待sensor稳定的时间。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **if** (mipi\_csi2\_info) \{   
2.      unsigned **int** i;   
3.    
4.      i = 0;   
5.    
6.      /\* wait for mipi sensor ready \*/   
7.      mipi\_reg = mipi\_csi2\_dphy\_status(mipi\_csi2\_info);   
8.      **while** ((mipi\_reg == 0x200) && (i < 10)) \{   
9.          mipi\_reg = mipi\_csi2\_dphy\_status(mipi\_csi2\_info);   
10.         i++;   
11.         msleep(10);   
12.     \}   
13.   
14.     **if** (i >= 10) \{   
15.         pr\_err("mipi csi2 can not receive sensor clk!\\n");   
16.         **return** -1;   
17.     \}

/\* mipi\_csi2\_dphy\_status函数就是去读取MIPI\_CSI2\_PHY\_STATE寄存器的值，然后保存在mipi\_reg变量中。这个寄存器如下所示：

![SouthEast 7][] ![SouthEast 8][]

![52299519][]  
可以看出来，这个寄存器的bit\[9\]表示sensor的clocklane处于什么样的状态。注意：这一位是activelow，所以置0时表示使能。再来看这一段代码，它会一直等待这一位置0,一直等待10×10ms，如果过了这一段时间，MIPI\_CSI2\_PHY\_STATE寄存器的bit\[9\]还保持为1的状态时，就打印出“mipicsi2 can not receive sensor clk!”这句话报错。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.      i = 0;   
2.    
3.      /\* wait for mipi stable \*/   
4.      mipi\_reg = mipi\_csi2\_get\_error1(mipi\_csi2\_info);   
5.      **while** ((mipi\_reg != 0x0) && (i < 10)) \{   
6.          mipi\_reg = mipi\_csi2\_get\_error1(mipi\_csi2\_info);   
7.          i++;   
8.          msleep(10);   
9.      \}   
10.   
11.     **if** (i >= 10) \{   
12.         pr\_err("mipi csi2 can not reveive data correctly!\\n");   
13.         **return** -1;   
14.     \}   
15. \}   
16. rr:   
17. **return** retval;

/\*这一段代码就是通过mipi\_csi2\_get\_error1函数来读取MIPI\_CSI2\_ERR1寄存器的值。这个寄存器表示MIPI控制寄存器中是否有错误发生，如果都没有错误的话，这个寄存器里面的值都应该是0.关于这个寄存器中每一位的含义就不分析了。\*/

至此，ov5640\_init\_mode函数就大致分析完毕了，也就代表ioctl\_dev\_init函数分析完毕。这个ioctl\_dev\_init函数是mxc\_v4l2\_open函数中的最后一个函数。

对于应用程序中调用的其他ioctl函数，大致过程都是相似的，不会涉及到芯片上面寄存器的设置，大部分都是与ov5640\_probe函数中sensor\_data结构体相关，就不再分析他们了。

下面分析ov5640\_init\_mode函数中没有分析的三个函数：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  ov5640\_download\_firmware  
2.  ov5640\_change\_mode\_exposure\_calc  
3.  ov5640\_change\_mode\_direct

这三个函数是关于芯片设置最重要的函数。在ov5640\_init\_mode函数中，会根据第二个参数和第三个参数的不同来选择执行哪一路过程。当mode== ov5640\_mode\_INIT时，会直接执行ov5640\_download\_firmware函数来设置ov5640摄像头。

先来看ov5640\_download\_firmware函数：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* download ov5640 settings to sensor through i2c \*/   
2.  **static** **int** ov5640\_download\_firmware(**struct** reg\_value \*pModeSetting, s32 ArySize)   
3.  \{   
4.      **register** u32 Delay\_ms = 0;   
5.      **register** u16 RegAddr = 0;   
6.      **register** u8 Mask = 0;   
7.      **register** u8 Val = 0;   
8.      u8 RegVal = 0;   
9.      **int** i, retval = 0;   
10.   
11.     **for** (i = 0; i < ArySize; ++i, ++pModeSetting) \{   
12.         Delay\_ms = pModeSetting->u32Delay\_ms;   
13.         RegAddr = pModeSetting->u16RegAddr;   
14.         Val = pModeSetting->u8Val;   
15.         Mask = pModeSetting->u8Mask;   
16.   
17.         **if** (Mask) \{   
18.             retval = ov5640\_read\_reg(RegAddr, &RegVal);   
19.             **if** (retval < 0)   
20.                 **goto** err;   
21.   
22.             RegVal &= ~(u8)Mask;   
23.             Val &= Mask;   
24.             Val |= RegVal;   
25.         \}   
26.   
27.         retval = ov5640\_write\_reg(RegAddr, Val);   
28.         **if** (retval < 0)   
29.             **goto** err;   
30.   
31.         **if** (Delay\_ms)   
32.             msleep(Delay\_ms);   
33.     \}   
34. err:   
35.     **return** retval;   
36. \}

先看这个函数的注释：通过I2C总线下载设置到ov5640摄像头中。意思就是我们在驱动中写好ov5640摄像头上面寄存器的配置以后，通过这个函数设置进去。

再来看这个函数，这个函数设置的核心是reg\_value结构体，这个结构体如下所示：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **struct** reg\_value \{   
2.      u16 u16RegAddr;   
3.      u8 u8Val;   
4.      u8 u8Mask;   
5.      u32 u32Delay\_ms;   
6.  \};

它就包含了所要设置一个寄存器所需要的所有元素：地址，值，掩码，延迟时间。以ov5640\_init\_setting\_30fps\_VGA\[\]为例：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **struct** reg\_value ov5640\_init\_setting\_30fps\_VGA\[\] = \{   
2.      \{0x3103, 0x11, 0, 0\}, \{0x3008, 0x82, 0, 5\}, \{0x3008, 0x42, 0, 0\},   
3.      \{0x3103, 0x03, 0, 0\}, \{0x3017, 0x00, 0, 0\}, \{0x3018, 0x00, 0, 0\},   
4.      \{0x3034, 0x18, 0, 0\}, \{0x3035, 0x14, 0, 0\}, \{0x3036, 0x38, 0, 0\},  
5.  。。。。。。。。。。。。。。。。。。  
6.  \};

通过这个函数，就能够把这个结构体数组里面的值都设置到ov5640中去。而这个结构体数组中寄存器的值怎么来的就是关键了，理论上可以参考芯片手册一位一位地设置，但是厂家应该会提供这个初始化数组的。

下面来看第二个函数ov5640\_change\_mode\_exposure\_calc：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* sensor changes between scaling and subsampling  
2.   \* go through exposure calcualtion  
3.   \*/  
4.  **static** **int** ov5640\_change\_mode\_exposure\_calc(**enum** ov5640\_frame\_rate frame\_rate,   
5.                  **enum** ov5640\_mode mode)   
6.  \{   
7.      **struct** reg\_value \*pModeSetting = NULL;   
8.      s32 ArySize = 0;   
9.      u8 average;   
10.     **int** prev\_shutter, prev\_gain16;   
11.     **int** cap\_shutter, cap\_gain16;   
12.     **int** cap\_sysclk, cap\_HTS, cap\_VTS;   
13.     **int** light\_freq, cap\_bandfilt, cap\_maxband;   
14.     **long** cap\_gain16\_shutter;   
15.     **int** retval = 0;   
16.   
17.     /\* check if the input mode and frame rate is valid \*/   
18.     pModeSetting =   
19.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].init\_data\_ptr;   
20.     ArySize =   
21.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].init\_data\_size;   
22.   
23.     ov5640\_data.pix.width =   
24.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].width;   
25.     ov5640\_data.pix.height =   
26.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].height;   
27.   
28.     **if** (ov5640\_data.pix.width == 0 || ov5640\_data.pix.height == 0 ||   
29.         pModeSetting == NULL || ArySize == 0)   
30.         **return** -EINVAL;   
31.   
32.     /\* auto focus \*/   
33.     /\* OV5640\_auto\_focus();//if no af function, just skip it \*/   
34.   
35.     /\* turn off AE/AG \*/   
36.     OV5640\_turn\_on\_AE\_AG(0);

/\*这个函数的意思是根据传入的参数的值来决定打开还是关闭autoAE/AG。关于这个的寄存器地址是0x3503，可以看出来，想要关闭auto模式的话，只需要将bit\[1:0\]设置为0x03即可，打开auto的话，将bit\[1:0\]清空即可。OV5640\_turn\_on\_AE\_AG这个函数正是这么做的。

![SouthEast 9][]

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** OV5640\_turn\_on\_AE\_AG(**int** enable)   
2.  \{   
3.      u8 ae\_ag\_ctrl;   
4.    
5.      ov5640\_read\_reg(0x3503, &ae\_ag\_ctrl);   
6.      **if** (enable) \{   
7.          /\* turn on auto AE/AG \*/   
8.          ae\_ag\_ctrl = ae\_ag\_ctrl & ~(0x03);   
9.      \} **else** \{   
10.         /\* turn off AE/AG \*/   
11.         ae\_ag\_ctrl = ae\_ag\_ctrl | 0x03;   
12.     \}   
13.     ov5640\_write\_reg(0x3503, ae\_ag\_ctrl);   
14. \}

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* read preview shutter \*/   
2.  prev\_shutter = OV5640\_get\_shutter();   
3.  **if** ((binning\_on()) && (mode != ov5640\_mode\_720P\_1280\_720)   
4.          && (mode != ov5640\_mode\_1080P\_1920\_1080))   
5.      prev\_shutter \*= 2;

/\*这个OV5640\_get\_shutter()函数就是去读取ov5640芯片上面的0x3500~0x3502地址里面的值，然后根据图示构造出Exposure的值，返回保存到prev\_shutter中。在这里，shutter就是曝光时间的意思。

![SouthEast 10][]

在这里有一个函数：binning\_on()：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **bool** binning\_on(**void**)   
2.  \{   
3.      u8 temp;   
4.      ov5640\_read\_reg(0x3821, &temp);   
5.      temp &= 0xfe;   
6.      **if** (temp)   
7.          **return** **true**;   
8.      **else**   
9.          **return** **false**;   
10. \}

关于binning的概念和理解，可以查看《[sensor][][的skippingand binning ][sensor][模式][sensor]》

[http://blog.csdn.net/sloan6/article/details/8242713][sensor]

在ov5640的芯片手册中，可以看到，与这个概念有关的寄存器位于0x3821的bit\[0\]，但是个人感觉这个函数写的有问题，只涉及0x3821的bit\[0\]位，如果只打算比较bit\[0\]而不改变其他位的话，应该：

if(temp & 0x01)，根本不需要temp&= 0xfe操作，经过这一个操作的话，假如其他位有不为0的，那么这个temp的值就不为0.

![SouthEast 11][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* read preview gain \*/   
2.  prev\_gain16 = OV5640\_get\_gain16();

/\*看看OV5640\_get\_gain16()这个函数：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** OV5640\_get\_gain16(**void**)   
2.  \{   
3.       /\* read gain, 16 = 1x \*/   
4.      **int** gain16;   
5.      u8 temp;   
6.    
7.      gain16 = ov5640\_read\_reg(0x350a, &temp) & 0x03;   
8.      gain16 = (gain16<<8) + ov5640\_read\_reg(0x350b, &temp);   
9.    
10.     **return** gain16;   
11. \}

从这个函数中很显然就能猜出来这个previewgain保存在0x350a和0x350b这两个寄存器中，看看芯片手册：

![SouthEast 12][]

![52299519][]  
最终这个函数读取这两个寄存器的值，然后保存在prev\_gain16变量中。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* get average \*/   
2.  ov5640\_read\_reg(0x56a1, &average);

/\*这里直接使用ov5640\_read\_reg函数来读取0x56a1的值保存在&average中：

![SouthEast 13][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* turn off night mode for capture \*/   
2.  OV5640\_set\_night\_mode();

/\*这个函数如下所示，这个函数与上面的binning\_on()函数做比较的话，这个函数的设置是正确的，因为这个函数只想设置0x3a00的bit\[2\]为0,在不改变其他位的基础上面，通过mode&= 0xfb的形式是最好的。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **void** OV5640\_set\_night\_mode(**void**)   
2.  \{   
3.       /\* read HTS from register settings \*/   
4.      u8 mode;   
5.    
6.      ov5640\_read\_reg(0x3a00, &mode);   
7.      mode &= 0xfb;   
8.      ov5640\_write\_reg(0x3a00, mode);   
9.  \}

![SouthEast 14][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* turn off overlay \*/   
2.  /\* ov5640\_write\_reg(0x3022, 0x06);//if no af function, just skip it \*/   
3.    
4.  OV5640\_stream\_off();   
5.    
6.  /\* Write capture setting \*/   
7.  retval = ov5640\_download\_firmware(pModeSetting, ArySize);   
8.  **if** (retval < 0)   
9.      **goto** err;

/\*最终这个函数里面也是调用ov5640\_download\_firmware函数来将从ov5640\_mode\_info\_data数组中获取到的ov5640中寄存器的值写到对应的寄存器中。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* read capture VTS \*/   
2.  cap\_VTS = OV5640\_get\_VTS();   
3.  cap\_HTS = OV5640\_get\_HTS();   
4.  cap\_sysclk = OV5640\_get\_sysclk();

/\*先来看前两个函数，读取寄存器的值来获取verticalzise和horizontalsize的值。寄存器如下所示：

![SouthEast 15][]

这个OV5640\_get\_sysclk()函数有点复杂，以后再分析。

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\* calculate capture banding filter \*/   
2.  light\_freq = OV5640\_get\_light\_freq();   
3.  **if** (light\_freq == 60) \{   
4.      /\* 60Hz \*/   
5.      cap\_bandfilt = cap\_sysclk \* 100 / cap\_HTS \* 100 / 120;   
6.  \} **else** \{   
7.      /\* 50Hz \*/   
8.      cap\_bandfilt = cap\_sysclk \* 100 / cap\_HTS;   
9.  \}   
10. cap\_maxband = (**int**)((cap\_VTS - 4)/cap\_bandfilt);   
11.   
12. /\* calculate capture shutter/gain16 \*/   
13. **if** (average > AE\_low && average < AE\_high) \{   
14.     /\* in stable range \*/   
15.     cap\_gain16\_shutter =   
16.       prev\_gain16 \* prev\_shutter \* cap\_sysclk/prev\_sysclk   
17.       \* prev\_HTS/cap\_HTS \* AE\_Target / average;   
18. \} **else** \{   
19.     cap\_gain16\_shutter =   
20.       prev\_gain16 \* prev\_shutter \* cap\_sysclk/prev\_sysclk   
21.       \* prev\_HTS/cap\_HTS;   
22. \}   
23.   
24. /\* gain to shutter \*/   
25. **if** (cap\_gain16\_shutter < (cap\_bandfilt \* 16)) \{   
26.     /\* shutter < 1/100 \*/   
27.     cap\_shutter = cap\_gain16\_shutter/16;   
28.     **if** (cap\_shutter < 1)   
29.         cap\_shutter = 1;   
30.   
31.     cap\_gain16 = cap\_gain16\_shutter/cap\_shutter;   
32.     **if** (cap\_gain16 < 16)   
33.         cap\_gain16 = 16;   
34. \} **else** \{   
35.     **if** (cap\_gain16\_shutter >   
36.             (cap\_bandfilt \* cap\_maxband \* 16)) \{   
37.         /\* exposure reach max \*/   
38.         cap\_shutter = cap\_bandfilt \* cap\_maxband;   
39.         cap\_gain16 = cap\_gain16\_shutter / cap\_shutter;   
40.     \} **else** \{   
41.         /\* 1/100 < (cap\_shutter = n/100) =< max \*/   
42.         cap\_shutter =   
43.           ((**int**) (cap\_gain16\_shutter/16 / cap\_bandfilt))   
44.           \*cap\_bandfilt;   
45.         cap\_gain16 = cap\_gain16\_shutter / cap\_shutter;   
46.     \}   
47. \}   
48.   
49. /\* write capture gain \*/   
50. OV5640\_set\_gain16(cap\_gain16);   
51.   
52. /\* write capture shutter \*/   
53. **if** (cap\_shutter > (cap\_VTS - 4)) \{   
54.     cap\_VTS = cap\_shutter + 4;   
55.     OV5640\_set\_VTS(cap\_VTS);   
56. \}   
57. OV5640\_set\_shutter(cap\_shutter);   
58.   
59. OV5640\_stream\_on();   
60.   
61. rr:   
62. **return** retval;

/\*后面这些计算应该都是摄像头中定义的，有点看不懂，以后再分析吧\*/

最后看看ov5640\_change\_mode\_direct函数：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** ov5640\_change\_mode\_direct(**enum** ov5640\_frame\_rate frame\_rate,   
2.                  **enum** ov5640\_mode mode)   
3.  \{   
4.      **struct** reg\_value \*pModeSetting = NULL;   
5.      s32 ArySize = 0;   
6.      **int** retval = 0;   
7.    
8.      /\* check if the input mode and frame rate is valid \*/   
9.      pModeSetting =   
10.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].init\_data\_ptr;   
11.     ArySize =   
12.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].init\_data\_size;   
13.   
14.     ov5640\_data.pix.width =   
15.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].width;   
16.     ov5640\_data.pix.height =   
17.         ov5640\_mode\_info\_data\[frame\_rate\]\[mode\].height;   
18.   
19.     **if** (ov5640\_data.pix.width == 0 || ov5640\_data.pix.height == 0 ||   
20.         pModeSetting == NULL || ArySize == 0)   
21.         **return** -EINVAL;   
22.   
23.     /\* turn off AE/AG \*/   
24.     OV5640\_turn\_on\_AE\_AG(0);   
25.   
26.     OV5640\_stream\_off();   
27.   
28.     /\* Write capture setting \*/   
29.     retval = ov5640\_download\_firmware(pModeSetting, ArySize);   
30.     **if** (retval < 0)   
31.         **goto** err;   
32.   
33.     OV5640\_stream\_on();   
34.   
35.     OV5640\_turn\_on\_AE\_AG(1);   
36.   
37. err:   
38.     **return** retval;   
39. \}

经过上一个函数的分析，这个函数看起来就相当简单了。

3.OV5640\_get\_sysclk 函数分析

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static** **int** OV5640\_get\_sysclk(**void**)   
2.  \{   
3.       /\* calculate sysclk \*/   
4.      **int** xvclk = ov5640\_data.mclk / 10000;   
5.      **int** temp1, temp2;   
6.      **int** Multiplier, PreDiv, VCO, SysDiv, Pll\_rdiv;   
7.      **int** Bit\_div2x = 1, sclk\_rdiv, sysclk;   
8.      u8 temp;

/\*ov5640\_data.mclk的值是在ov5640\_probe函数中同dts文件中读取的，为24000000.\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **int** sclk\_rdiv\_map\[\] = \{1, 2, 4, 8\};   
2.    
3.  temp1 = ov5640\_read\_reg(0x3034, &temp);   
4.  temp2 = temp1 & 0x0f;   
5.  **if** (temp2 == 8 || temp2 == 10)   
6.      Bit\_div2x = temp2 / 2;

/\*读取0x3034寄存器的值，取低4位除以2后保存在Bit\_div2x中。从芯片手册中可以看出来，0x3034的低4位是MIPIbit mode，那么为什么还要除以2呢？在《ov5640\_PLL\_diagram.jpg》图片的左下角有这样一句话：note6：MIPISCLK= (4 or 5) \* PCLK if 2 lanes;= (8 or 10) \* PCLK if 1lane。再看Bit\_div2x在PLLdiagram中对应的模块是BITdivider，而现在使用的是2lanes模式，所以需要除以2.

![SouthEast 16][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  temp1 = ov5640\_read\_reg(0x3035, &temp);   
2.  SysDiv = temp1>>4;   
3.  **if** (SysDiv == 0)   
4.      SysDiv = 16;

/\*读取0x3035寄存器的高4位保存在SysDiv中，看芯片手册中的解释是系统时钟分频器。在《ov5640\_PLL\_diagram.jpg》图片中对应SYSdivider0模块。

![SouthEast 17][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  temp1 = ov5640\_read\_reg(0x3036, &temp);   
2.  Multiplier = temp1;

/\*读取0x3036寄存器的值保存在Multiplier中，看芯片手册中的解释是PLL倍频器。在《ov5640\_PLL\_diagram.jpg》图片中对应multiplier模块。

![SouthEast 18][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  temp1 = ov5640\_read\_reg(0x3037, &temp);   
2.  PreDiv = temp1 & 0x0f;   
3.  Pll\_rdiv = ((temp1 >> 4) & 0x01) + 1;

/\*读取0x3037寄存器的低4位保存在PreDiv中，读取0x3037寄存器的bit\[4\]保存在Pll\_rdiv中。

![SouthEast 19][]

PreDiv在《ov5640\_PLL\_diagram.jpg》图片中对应pre-divider模块，Pll\_rdiv在《ov5640\_PLL\_diagram.jpg》图片中对应PLLR divider模块，因为上图中的解释是：如果bit\[4\]为1的话，就分成2份，所以在代码中将从bit\[4\]中读取出来的值加1。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  temp1 = ov5640\_read\_reg(0x3108, &temp);   
2.  temp2 = temp1 & 0x03;   
3.  sclk\_rdiv = sclk\_rdiv\_map\[temp2\];

/\*读取0x3108寄存器的低2位保存在temp2中，然后将这个temp2作为下标来从这个数组里面取值：

intsclk\_rdiv\_map\[\] = \{1, 2, 4, 8\};

为什么要从这个数组里面取值呢？看芯片手册中，SCLK为pll\_clk的1/2,1/4, 1/8。没法用两位来表示8,所以选择这种方式来选取值。

![SouthEast 20][]

\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  VCO = xvclk \* Multiplier / PreDiv;

/\*这个VCO是压控振荡器（VoltageControlledOscillator），是PLL（锁相环）的组成部分，在PLL中，一般是先分频，然后再经过VCO增频，这里先计算的是VCO的输出。在《ov5640\_PLL\_diagram.jpg》中就是PLL1后的输出。\*/

**\[html\]**  [view plain][]   [copy][view plain]

1.  sysclk = VCO / SysDiv / Pll\_rdiv \* 2 / Bit\_div2x / sclk\_rdiv;

/\*剩下的就是计算过程，根据图《ov5640\_PLL\_diagram.jpg》就可以写出这个计算过程。\*/

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **return** sysclk;

《ov5640\_PLL\_diagram.jpg》是我们网上看到的一个有关ov5640的时钟控制图，我下载的芯片手册都没有这个图，所以一直对这个函数不理解，通过这个图，这个函数的设置过程就很清楚了，《ov5640\_PLL\_diagram.jpg》图片如下所示：

![SouthEast 21][]

经过上面的步骤就可以得出OV5640的系统时钟参数。

参考:

《[CMOSSensor][][的调试经验分享][CMOSSensor]》

[http://blog.csdn.net/yapingmcu/article/details/37817727][CMOSSensor]

[view plain]: /images/20220714/2826a0e10ad44e75bfad0c7e3771827d.png#
[SouthEast]: /images/20220714/0154616e01ba4bffa556d1c02e5c9dcf.png
[http_www.wowotech.net_pm_subsystem_regulator_framework_overview.html]: http://www.wowotech.net/pm_subsystem/regulator_framework_overview.html
[SouthEast 1]: /images/20220714/b58b9c809836461faebcfa780994b98b.png
[SouthEast 2]: /images/20220714/ac3c0aad956548f391ef25947ed1523a.png
[C]: http://blog.csdn.net/skyflying2012/article/details/22736633
[SouthEast 3]: /images/20220714/477e1ec79bb045148dafe586e23f9137.png
[SouthEast 4]: /images/20220714/48c894f46ecd45789e97506e799a26f5.png
[Camera]: http://blog.csdn.net/colorant/article/details/1913334
[SouthEast 5]: /images/20220714/7aa1b87def4a42a581949135335ff9e0.png
[SouthEast 6]: /images/20220714/a174115fb4e6432d951faa5cd5352f15.png
[SouthEast 7]: https://img-blog.csdn.net/20160824131945025?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 8]: /images/20220714/d8696fe3ee17403e9dc108ccd39d69f7.png
[52299519]: /images/20220714/2826a0e10ad44e75bfad0c7e3771827d.png
[SouthEast 9]: /images/20220714/c31a7df1f0754d2dbe12a3f64bc6480a.png
[SouthEast 10]: /images/20220714/3c5228ec285847949897638475409f77.png
[sensor]: http://blog.csdn.net/sloan6/article/details/8242713
[SouthEast 11]: /images/20220714/067e994ce7e742caa1d3d9cba0507fbe.png
[SouthEast 12]: /images/20220714/2fea8e7ba9654cc795cc8e5260e00457.png
[SouthEast 13]: /images/20220714/af20812d01364147bdfd6ccb656a1b8e.png
[SouthEast 14]: /images/20220714/dec70f3ecd164cf485d1845dfbd50d67.png
[SouthEast 15]: /images/20220714/8d9987331c8e46abae5cbc1ff21b7ca2.png
[SouthEast 16]: /images/20220714/bf0724dea4dc424da2a5f2346472532a.png
[SouthEast 17]: /images/20220714/e7a6379c9a704ebeabdcfba0686a614b.png
[SouthEast 18]: /images/20220714/088e9641033b40c4b3aaaffe9f7d554a.png
[SouthEast 19]: /images/20220714/258f5dd67e6b4dc7860ffb80ce1bab29.png
[SouthEast 20]: /images/20220714/9f28494760944909b6883c96d584c73d.png
[SouthEast 21]: /images/20220714/c36551ce615a4959a33672a98fcdda9c.png
[CMOSSensor]: http://blog.csdn.net/yapingmcu/article/details/37817727