OV9650驱动程序跟踪

学习了裸机OV9650的P通道LCD直接显示程序，作为这点基础开始分析OV9650在linux设备驱动程序。昨天看了点这个驱动程序，让我很郁闷的是写这个程序的人是有毛病还是怎么回事，简简单单的IO口功能引脚的定义，整出了一个套一个的定义，看的我晕乎乎的，也可能是哥根本没有入门，看别人牛逼的程序就看迷糊了。鉴于上面这种情况，我在程序跟踪时只能带一下了。

我们跟踪程序按照常规方法，跟着驱动的编写脉络去读程序。

1、在程序中找到程序入口函数——加载和卸载module_init和module_exit

 

[c-sharp]  view plain copy

1. module_init(camif_init);  
2. module_exit(camif_cleanup);  

通过这个入口函数我们找到了函数加载和卸载函数的定义，首先我们分析加载函数（由于函数的嵌套性，我们这里用序号来体现嵌套）

2、camif_init跟踪

[c-sharp]  view plain copy

1. static int __init camif_init(void)  
2. {  
3.     int ret;  
4.     struct tq2440_camif_dev * pdev;  
5.     struct clk * camif_upll_clk;  
6.   
7.     printk(KERN_ALERT"initializing s3c2440 camera interface....../n");  
8.   
9.     pdev = &camera;  
10.   
11.     /* set gpio-j to camera mode. */  
12.     s3c2410_gpio_cfgpin(S3C2440_GPJ0, S3C2440_GPJ0_CAMDATA0);  
13.     s3c2410_gpio_cfgpin(S3C2440_GPJ1, S3C2440_GPJ1_CAMDATA1);  
14.     s3c2410_gpio_cfgpin(S3C2440_GPJ2, S3C2440_GPJ2_CAMDATA2);  
15.     s3c2410_gpio_cfgpin(S3C2440_GPJ3, S3C2440_GPJ3_CAMDATA3);  
16.     s3c2410_gpio_cfgpin(S3C2440_GPJ4, S3C2440_GPJ4_CAMDATA4);  
17.     s3c2410_gpio_cfgpin(S3C2440_GPJ5, S3C2440_GPJ5_CAMDATA5);  
18.     s3c2410_gpio_cfgpin(S3C2440_GPJ6, S3C2440_GPJ6_CAMDATA6);  
19.     s3c2410_gpio_cfgpin(S3C2440_GPJ7, S3C2440_GPJ7_CAMDATA7);  
20.     s3c2410_gpio_cfgpin(S3C2440_GPJ8, S3C2440_GPJ8_CAMPCLK);  
21.     s3c2410_gpio_cfgpin(S3C2440_GPJ9, S3C2440_GPJ9_CAMVSYNC);  
22.     s3c2410_gpio_cfgpin(S3C2440_GPJ10, S3C2440_GPJ10_CAMHREF);  
23.     s3c2410_gpio_cfgpin(S3C2440_GPJ11, S3C2440_GPJ11_CAMCLKOUT);  
24.     s3c2410_gpio_cfgpin(S3C2440_GPJ12, S3C2440_GPJ12_CAMRESET);  
25.   
26.     /* init camera's virtual memory. */  
27.     if (!request_mem_region((unsigned long)S3C2440_PA_CAMIF, S3C2440_SZ_CAMIF, CARD_NAME))  
28.     {  
29.         ret = -EBUSY;  
30.         goto error1;  
31.     }  
32.   
33.     /* remap the virtual memory. */  
34.     camif_base_addr = (unsigned long)ioremap_nocache((unsigned long)S3C2440_PA_CAMIF, S3C2440_SZ_CAMIF);  
35.     if (camif_base_addr == (unsigned long)NULL)  
36.     {  
37.         ret = -EBUSY;  
38.         goto error2;  
39.     }  
40.   
41.     /* init camera clock. */  
42.     pdev->clk = clk_get(NULL, "camif");  
43.     if (IS_ERR(pdev->clk))  
44.     {  
45.         ret = -ENOENT;  
46.         goto error3;  
47.     }  
48.     clk_enable(pdev->clk);  
49.   
50.     camif_upll_clk = clk_get(NULL, "camif-upll");  
51.     clk_set_rate(camif_upll_clk, 24000000);  
52.     mdelay(100);  
53.   
54.     /* init reference counter and its mutex. */  
55.     mutex_init(&pdev->rcmutex);  
56.     pdev->rc = 0;  
57.   
58.     /* init image input source. */  
59.     pdev->input = 0;  
60.   
61.     /* init camif state and its lock. */  
62.     pdev->state = CAMIF_STATE_FREE;  
63.   
64.     /* init command code, command lock and the command wait queue. */  
65.     pdev->cmdcode = CAMIF_CMD_NONE;  
66.     init_waitqueue_head(&pdev->cmdqueue);  
67.   
68.     /* register to videodev layer. */  
69.     if (misc_register(&misc) < 0)  
70.     {  
71.         ret = -EBUSY;  
72.         goto error4;  
73.     }  
74.     printk(KERN_ALERT"s3c2440 camif init done/n");  
75.       
76. //  sccb_init();  
77.     CFG_WRITE(SIO_C);  
78.     CFG_WRITE(SIO_D);  
79.   
80.     High(SIO_C);  
81.     High(SIO_D);  
82.     WAIT_STABLE();  
83.   
84.     hw_reset_camif();  
85.     has_ov9650 = s3c2440_ov9650_init() >= 0;  
86.     s3c2410_gpio_setpin(S3C2410_GPG4, 1);  
87.     return 0;  
88.   
89. error4:  
90.     clk_put(pdev->clk);  
91. error3:  
92.     iounmap((void *)camif_base_addr);  
93. error2:  
94.     release_mem_region((unsigned long)S3C2440_PA_CAMIF, S3C2440_SZ_CAMIF);  
95.       
96. error1:  
97.     return ret;  
98. }  

①定义Camera Interface的硬件管脚功能(即设置GPJ为功能引脚）

②初始化Camera的虚拟内存地址

 request_mem_region() -- 将起始地址为[start, start+n-1]的资源插入根资源iomem_resource中。参数start是I/O内存资源的起始物理地址(是CPU的RAM物理地址空间中的物理地址)，参数n指定I/O内存资源的大小。
#define request_mem_region(start, n, name) /
        __request_region(&iomem_resource, (start), (n), (name))
 注: 调用request_mem_region()不是必须的，但是建议使用。该函数的任务是检查申请的资源是否可用，如果可用则申请成功，并标志为已经使用，其他驱动想再申请该资源时就会失败。
③映射为虚拟内存

ioremap_nocache - 把内存映射到CPU空间  

void __iomem * ioremap_nocache (unsigned long phys_addr, unsigned long size);   

phys_addr 要映射的物理地址  

size 要映射资源的大小  

ioremap_nocache进行一系列平台相关的操作使得CPU可以通过readb/readw/readl/writeb/writew/writel等IO函数进行访问。

返回的地址不保证可以作为虚拟地址直接访问。 

[译者按：在译者的使用过程种并没有出现不能作为虚拟地址直接访问的情况，可能是某些平台下的不可以吧。译者的使用平台是x86和ixp425]

这个版本的ioremap确保这些内存在CPU是不可缓冲的，如同PCI总线上现存的缓冲规则一样。注：此时在很多总线上仍有其他的缓冲和缓存。在某些特殊的驱动中，作者应当在PCI写的时候进行读取。
这对于一些控制寄存器在这种不希望复合写或者缓冲读的区域内时是非常有用的
返回的映射地址必须使用iounmap来释放。

④初始化Camera的时钟（这里通过一个例子说明函数）

如何获取FCLK, HLCK 和 PCLK的时针频率呢？

可先通过clk_get获取一个clk结构体

/* clk_get获取一个名为id的时针  * 输入参数dev:   可以为NULL  * 输入参数id:    时针名称,如fclk、hclk、pclk等  * 返回值:        返回该时钟的clk结构体  */ struct clk *clk_get(struct device *dev, const char *id) struct clk {     struct list_head list;     struct module *owner;     struct clk *parent;     const char *name; /* 该时针名称 */     int id;     int usage;     unsigned long rate; /* 时钟频率 */     unsigned long ctrlbit;     int (*enable)(struct clk *, int enable);     int (*set_rate)(struct clk *c, unsigned long rate);     unsigned long (*get_rate)(struct clk *c);     unsigned long (*round_rate)(struct clk *c, unsigned long rate);     int (*set_parent)(struct clk *c, struct clk *parent); };

再将clk_get返回的clk结构体传递给clk_get_rate，获取该时钟的频率

unsigned long clk_get_rate(struct clk *clk)

一个例子：

这里出现了另一个时针uclk，专门给usb供给时针信号。uclk是外部时针源，由s3c2410芯片的gph8/uclk管脚引入，给uart提供外部时针信号，以获取更精确地时针频率。

⑤初始化计数器和它的互斥

用互斥锁可以使线程顺序执行。互斥锁通常只允许一个线程执行一个关键部分的
代码，来同步线程。互斥锁也可以用来保护单线程代码。
⑥初始化输入的源图象

⑦初始化Camera 接口的状态

enum

{

CAMIF_STATE_FREE = 0, // not openned

CAMIF_STATE_READY = 1, // openned, but standby

CAMIF_STATE_PREVIEWING = 2, // in previewing

CAMIF_STATE_CODECING = 3 // in capturing

};

⑧初始化命令代码，和初始化等待队列头

enum

{

CAMIF_CMD_NONE = 0,

CAMIF_CMD_SFMT = 1<<0, // source image format changed.

CAMIF_CMD_WND = 1<<1, // window offset changed.

CAMIF_CMD_ZOOM = 1<<2, // zoom picture in/out

CAMIF_CMD_TFMT = 1<<3, // target image format changed.

CAMIF_CMD_P2C = 1<<4, // need camif switches from p-path to c-path

CAMIF_CMD_C2P = 1<<5, // neet camif switches from c-path to p-path

CAMIF_CMD_STOP = 1<<16 // stop capture

};

⑨注册到视频设备层

杂项设备（misc device）

杂项设备也是在嵌入式系统中用得比较多的一种设备驱动。在 Linux 内核的include/linux目录下有Miscdevice.h文件，要把自己定义的misc device从设备定义在这里。其实是因为这些字符设备不符合预先确定的字符设备范畴，所有这些设备采用主编号10 ，一起归于misc device，其实misc_register就是用主标号10调用register_chrdev()的。 

也就是说，misc设备其实也就是特殊的字符设备，可自动生成设备节点。 

字符设备(char device) 

使用register_chrdev(LED_MAJOR,DEVICE_NAME,&dev_fops)注册字符设备驱动程序时，如果有多个设备使用该函数注册驱动程序，LED_MAJOR不能相同，否则几个设备都无法注册(我已验证)。如果模块使用该方式注册并且 LED_MAJOR为0(自动分配主设备号 )，使用insmod命令加载模块时会在终端显示分配的主设备号和次设备号，在/dev目录下建立该节点，比如设备leds，如果加载该模块时分配的主设备号和次设备号为253和0，则建立节点:mknod leds c 253 0。使用register_chrdev (LED_MAJOR,DEVICE_NAME,&dev_fops)注册字符设备驱动程序时都要手动建立节点 ，否则在应用程序无法打开该设备。

这里有一个结构很关键，也是我们程序脉络的一个跟踪点if (misc_register(&misc) < 0)中的misc，我们先把整个加载程序跟踪完，在回过来跟踪这个入口点。

⑩初始化sccb传输协议，与IIC协议相似，并初始化外部摄相设备

首先将GPE14和GPE15设置成输入输出功能，将两个引脚都置成高电平，延迟

重起外部摄相硬件设备

初始化外部硬件设备：

打开电源（GPG11设置为输出模式，并给其数据为0）

检测设备的厂商ID

显示设备的产品ID

配置OV9650的内部各个寄存器，在配制寄存起开始时down(®s_mutex);在配置结束时up(®s_mutex);

将GPG4引脚数据设置为1（这个设置不知道为什么，是开启LCD电源？我把这个语句注释掉了，再编译驱动下载到开发板，用camera_test测试了一下，发现一切正常）

其他的一些出错处理，主要是对前面那些出现错误后的反操作（比如申请内存，如果出错，在出错处理中就要释放内存）。

2、misc的跟踪

[c-sharp]  view plain copy

1. static struct miscdevice misc = {  
2.         .minor = MISC_DYNAMIC_MINOR,  
3.         .name = CARD_NAME,  
4.         .fops = &camif_fops,  
5. };  

  

 

 

 

 

 

 

 

 

这里#define MISC_DYNAMIC_MINOR 255

#define CARD_NAME  "camera"

关键点是camif_fops,这个结构是字符设备驱动程序的核心，当应用程序操作设备文件时所调用的open，read，write等函数，最终会调用这个结构体中指定的对应函数

2、file_operations结构体camif_fops

 

[c-sharp]  view plain copy

1. static struct file_operations camif_fops =  
2. {  
3.     .owner      = THIS_MODULE,  
4.     .open       = camif_open,  
5.     .release        = camif_release,  
6.     .read       = camif_read,  
7. };  

由这个结构体我们知道，程序定义了三个接口函数open,release,read。因此接下来我们要具体的分跟踪这三个函数，这也是编写字符行设备驱动程序时我们主要完成的工作。

 

㈠ camif_open的实现

[c-sharp]  view plain copy

1. static int camif_open(struct inode *inode, struct file *file)  
2. {  
3.     struct tq2440_camif_dev *pdev;  
4.     struct tq2440_camif_fh *fh;  
5.   
6.     int ret;  
7.   
8.     if (!has_ov9650) {  
9.         return -ENODEV;  
10.     }  
11.     pdev = &camera;  
12.   
13.   
14.     fh = kzalloc(sizeof(*fh),GFP_KERNEL); // alloc memory for filehandle  
15.     if (NULL == fh)  
16.     {  
17.         return -ENOMEM;  
18.     }  
19.     fh->dev = pdev;  
20.   
21.     pdev->state = CAMIF_STATE_READY;  
22.   
23.     init_camif_config(fh);  
24.   
25.     ret = init_image_buffer();  // init image buffer.  
26.     if (ret < 0)  
27.     {  
28.         goto error1;  
29.     }  
30.   
31.     request_irq(IRQ_S3C2440_CAM_C, on_camif_irq_c, IRQF_DISABLED, "CAM_C", pdev);   // setup ISRs  
32.     if (ret < 0)  
33.     {  
34.         goto error2;  
35.     }  
36.   
37.     request_irq(IRQ_S3C2440_CAM_P, on_camif_irq_p, IRQF_DISABLED, "CAM_P", pdev);  
38.     if (ret < 0)  
39.     {  
40.         goto error3;  
41.     }  
42.   
43.     clk_enable(pdev->clk);       // and enable camif clock.  
44.   
45.     soft_reset_camif();  
46.   
47.     file->private_data = fh;  
48.     fh->dev  = pdev;  
49.     update_camif_config(fh, 0);  
50.     return 0;  
51.   
52. error3:  
53.     free_irq(IRQ_S3C2440_CAM_C, pdev);  
54. error2:  
55.     free_image_buffer();  
56. error1:  
57.     kfree(fh);  
58.     return ret;  
59. }  

①通过has_ov9650来判断是否检测到0v9650设备的厂商ID（这个变量在程序加载时被设置）

②给设备结构体tq2440_camif_dev在内存中分配区域

③将设备结构体中的状态变量设置为CAMIF_STATE_READY

④初始化camera接口，配置相关的寄存器

⑤初始化图像的缓存区（即4个DMA通道的缓存地址）

⑥设置请求C通道，P通道的的中断

 

⑦使能camif的时钟，软件重起camif,将设备指针赋值给文件指针的私有数据

⑧最后更新配置（这步在这里好像也是可有可无的）

（1）init_camif_config

[c-sharp]  view plain copy

1. static void init_camif_config(struct tq2440_camif_fh * fh)  
2. {  
3.     struct tq2440_camif_dev * pdev;  
4.   
5.     pdev = fh->dev;  
6.   
7.     pdev->input = 0; // FIXME, the default input image format, see inputs[] for detail.  
8.   
9.     /* the source image size (input from external camera). */  
10.     pdev->srcHsize = 1280;   // FIXME, the OV9650's horizontal output pixels.  
11.     pdev->srcVsize = 1024;   // FIXME, the OV9650's verical output pixels.  
12.   
13.     /* the windowed image size. */  
14.     pdev->wndHsize = 1280;             
15.     pdev->wndVsize = 1024;  
16.   
17.     /* codec-path target(output) image size. */  
18.     pdev->coTargetHsize = pdev->wndHsize;  
19.     pdev->coTargetVsize = pdev->wndVsize;  
20.   
21.     /* preview-path target(preview) image size. */  
22.     pdev->preTargetHsize = 320;  
23.     pdev->preTargetVsize = 240;  
24.   
25.     update_camif_config(fh, CAMIF_CMD_STOP);  
26. }  
27.   
28. 这里有个函数update_camif_config(fh,CMAIF_CMD_STOP),用于更新camera接口的配置  
29.   
30. static void update_camif_config (struct tq2440_camif_fh * fh, u32 cmdcode)  
31. {  
32.     struct tq2440_camif_dev * pdev;  
33.   
34.     pdev = fh->dev;  
35.   
36.     switch (pdev->state)  
37.     {  
38.     case CAMIF_STATE_READY:  
39.         update_camif_regs(fh->dev);  // config the regs directly.  
40.         break;  
41.   
42.     case CAMIF_STATE_PREVIEWING:  
43.   
44.         /* camif is previewing image. */  
45.   
46.              disable_irq(IRQ_S3C2440_CAM_P);  // disable cam-preview irq.  
47.   
48.         /* source image format. */  
49.         if (cmdcode & CAMIF_CMD_SFMT)  
50.         {  
51.             // ignore it, nothing to do now.  
52.         }  
53.   
54.         /* target image format. */  
55.         if (cmdcode & CAMIF_CMD_TFMT)  
56.         {  
57.                 /* change target image format only. */  
58.                 pdev->cmdcode |= CAMIF_CMD_TFMT;  
59.         }  
60.   
61.         /* target image window offset. */  
62.         if (cmdcode & CAMIF_CMD_WND)  
63.         {  
64.             pdev->cmdcode |= CAMIF_CMD_WND;  
65.         }  
66.   
67.         /* target image zoomi & zoomout. */  
68.         if (cmdcode & CAMIF_CMD_ZOOM)  
69.         {  
70.             pdev->cmdcode |= CAMIF_CMD_ZOOM;  
71.         }  
72.   
73.         /* stop previewing. */  
74.         if (cmdcode & CAMIF_CMD_STOP)  
75.         {  
76.             pdev->cmdcode |= CAMIF_CMD_STOP;  
77.         }  
78.         enable_irq(IRQ_S3C2440_CAM_P);  // enable cam-preview irq.  
79.   
80.         wait_event(pdev->cmdqueue, (pdev->cmdcode==CAMIF_CMD_NONE));  // wait until the ISR completes command.  
81.         break;  
82.   
83.     case CAMIF_STATE_CODECING:  
84.   
85.         /* camif is previewing image. */  
86.   
87.         disable_irq(IRQ_S3C2440_CAM_C);     // disable cam-codec irq.  
88.   
89.         /* source image format. */  
90.         if (cmdcode & CAMIF_CMD_SFMT)  
91.         {  
92.             // ignore it, nothing to do now.  
93.         }  
94.   
95.         /* target image format. */  
96.         if (cmdcode & CAMIF_CMD_TFMT)  
97.         {  
98.                 /* change target image format only. */  
99.                 pdev->cmdcode |= CAMIF_CMD_TFMT;  
100.         }  
101.   
102.         /* target image window offset. */  
103.         if (cmdcode & CAMIF_CMD_WND)  
104.         {  
105.             pdev->cmdcode |= CAMIF_CMD_WND;  
106.         }  
107.   
108.         /* target image zoomi & zoomout. */  
109.         if (cmdcode & CAMIF_CMD_ZOOM)  
110.         {  
111.             pdev->cmdcode |= CAMIF_CMD_ZOOM;  
112.         }  
113.   
114.         /* stop previewing. */  
115.         if (cmdcode & CAMIF_CMD_STOP)  
116.         {  
117.             pdev->cmdcode |= CAMIF_CMD_STOP;  
118.         }  
119.         enable_irq(IRQ_S3C2440_CAM_C);  // enable cam-codec irq.  
120.         wait_event(pdev->cmdqueue, (pdev->cmdcode==CAMIF_CMD_NONE));  // wait until the ISR completes command.  
121.         break;  
122.   
123.     default:  
124.         break;  
125.     }  
126. }  
127.   
128.   
129. update_camif_regs(fh->dev);表示如果为准备状态就直接配置寄存器  
130.   
131. static void __inline__ update_camif_regs(struct tq2440_camif_dev * pdev)  
132. {  
133.     if (!in_irq())  
134.     {  
135.         while(1)    // wait until VSYNC is 'L'  
136.         {  
137.             barrier();  
138.             if ((ioread32(S3C244X_CICOSTATUS)&(1<<28)) == 0)  
139.                 break;  
140.         }  
141.     }  
142.   
143.     /* WARNING: don't change the statement sort below!!! */  
144.     update_source_fmt_regs(pdev);  
145.     update_target_wnd_regs(pdev);  
146.     update_target_fmt_regs(pdev);  
147.     update_target_zoom_regs(pdev);  
148. }  
149.   
150. 这里最后4个函数是配置camera interface寄存器的函数，由于寄存器的配置过程跟裸机的配置大同小异，所以这里就不进入其中讲解了，但有一点要注意，如果要修改显示效果，我觉得可以到这里面来配置一下寄存器，修改一下参数  
151. init_camif_buffer  
152.   
153. /* init image buffer (only when the camif is first open). */  
154. static int __inline__ init_image_buffer(void)  
155. {  
156.     int size1, size2;  
157.     unsigned long size;  
158.     unsigned int order;  
159.   
160.     /* size1 is the max image size of codec path. */  
161.     size1 = MAX_C_WIDTH * MAX_C_HEIGHT * 16 / 8;  
162.   
163.     /* size2 is the max image size of preview path. */  
164.     size2 = MAX_P_WIDTH * MAX_P_HEIGHT * 16 / 8;  
165.   
166.     size = (size1 > size2)?size1:size2;  
167.   
168.     order = get_order(size);  
169.     img_buff[0].order = order;  
170.     img_buff[0].virt_base = __get_free_pages(GFP_KERNEL|GFP_DMA, img_buff[0].order);  
171.     if (img_buff[0].virt_base == (unsigned long)NULL)  
172.     {  
173.         goto error0;  
174.     }  
175.     img_buff[0].phy_base = img_buff[0].virt_base - PAGE_OFFSET + PHYS_OFFSET;   // the DMA address.  
176.   
177.     img_buff[1].order = order;  
178.     img_buff[1].virt_base = __get_free_pages(GFP_KERNEL|GFP_DMA, img_buff[1].order);  
179.     if (img_buff[1].virt_base == (unsigned long)NULL)  
180.     {  
181.         goto error1;  
182.     }  
183.     img_buff[1].phy_base = img_buff[1].virt_base - PAGE_OFFSET + PHYS_OFFSET;   // the DMA address.  
184.   
185.     img_buff[2].order = order;  
186.     img_buff[2].virt_base = __get_free_pages(GFP_KERNEL|GFP_DMA, img_buff[2].order);  
187.     if (img_buff[2].virt_base == (unsigned long)NULL)  
188.     {  
189.         goto error2;  
190.     }  
191.     img_buff[2].phy_base = img_buff[2].virt_base - PAGE_OFFSET + PHYS_OFFSET;   // the DMA address.  
192.   
193.     img_buff[3].order = order;  
194.     img_buff[3].virt_base = __get_free_pages(GFP_KERNEL|GFP_DMA, img_buff[3].order);  
195.     if (img_buff[3].virt_base == (unsigned long)NULL)  
196.     {  
197.         goto error3;  
198.     }  
199.     img_buff[3].phy_base = img_buff[3].virt_base - PAGE_OFFSET + PHYS_OFFSET;   // the DMA address.  
200.   
201.     invalid_image_buffer();  
202.   
203.     return 0;  
204. error3:  
205.     free_pages(img_buff[2].virt_base, order);  
206.     img_buff[2].phy_base = (unsigned long)NULL;  
207. error2:  
208.     free_pages(img_buff[1].virt_base, order);  
209.     img_buff[1].phy_base = (unsigned long)NULL;  
210. error1:  
211.     free_pages(img_buff[0].virt_base, order);  
212.     img_buff[0].phy_base = (unsigned long)NULL;  
213. error0:  
214.     return -ENOMEM;  
215. }  
216.   
217. (二) camif_read的实现  
218.   
219. static ssize_t camif_read(struct file *file, char __user *data, size_t count, loff_t *ppos)  
220. {  
221.     int i;  
222.     struct tq2440_camif_fh * fh;  
223.     struct tq2440_camif_dev * pdev;  
224.   
225.     fh = file->private_data;  
226.     pdev = fh->dev;  
227.   
228.   
229.     if (start_capture(pdev, 0) != 0)  
230.     {  
231.         return -ERESTARTSYS;  
232.     }  
233.   
234.     disable_irq(IRQ_S3C2440_CAM_C);  
235.     disable_irq(IRQ_S3C2440_CAM_P);  
236.     for (i = 0; i < 4; i++)  
237.     {  
238.         if (img_buff[i].state != CAMIF_BUFF_INVALID)  
239.         {  
240.             copy_to_user(data, (void *)img_buff[i].virt_base, count);  
241.             img_buff[i].state = CAMIF_BUFF_INVALID;  
242.         }  
243.     }  
244.     enable_irq(IRQ_S3C2440_CAM_P);  
245.     enable_irq(IRQ_S3C2440_CAM_C);  
246.   
247.   
248.     return count;  

 

①开始图像捕捉，参数表示是捕捉视频流还是仅仅捕捉一张图片

 

②关闭P通道和C通道的中断

③通过一个for循环语句判断数据存放地址的状态，标志为有效，则把数据从内核复制到用户空间，并将标志设置为无效

④使能P通道和C通道的中断

（1）start_capture

 

[c-sharp]  view plain copy

1. /* start image capture. 
2.  * 
3.  * param 'stream' means capture pictures streamly or capture only one picture. 
4.  */  
5.   
6. static int start_capture(struct tq2440_camif_dev * pdev, int stream)  
7. {  
8.     int ret;  
9.   
10.     u32 ciwdofst;  
11.     u32 ciprscctrl;  
12.     u32 ciimgcpt;  
13.   
14.     ciwdofst = ioread32(S3C244X_CIWDOFST);  
15.     ciwdofst    |= (1<<30)    // Clear the overflow indication flag of input CODEC FIFO Y  
16.         |(1<<15)      // Clear the overflow indication flag of input CODEC FIFO Cb  
17.         |(1<<14)      // Clear the overflow indication flag of input CODEC FIFO Cr  
18.         |(1<<13)      // Clear the overflow indication flag of input PREVIEW FIFO Cb  
19.         |(1<<12);     // Clear the overflow indication flag of input PREVIEW FIFO Cr  
20.     iowrite32(ciwdofst, S3C244X_CIWDOFST);  
21.   
22.     ciprscctrl = ioread32(S3C244X_CIPRSCCTRL);  
23.     ciprscctrl |= 1<<15;  // preview scaler start  
24.     iowrite32(ciprscctrl, S3C244X_CIPRSCCTRL);  
25.   
26.     pdev->state = CAMIF_STATE_PREVIEWING;  
27.   
28.     ciimgcpt = (1<<31)        // camera interface global capture enable  
29.          |(1<<29);        // capture enable for preview scaler.  
30.     iowrite32(ciimgcpt, S3C244X_CIIMGCPT);  
31.   
32.     ret = 0;  
33.     if (stream == 0)  
34.     {  
35.         pdev->cmdcode = CAMIF_CMD_STOP;  
36.   
37.         ret = wait_event_interruptible(pdev->cmdqueue, pdev->cmdcode == CAMIF_CMD_NONE);  
38.     }  
39.     return ret;  
40. }  
41.   
42. ⑴配置窗口移位寄存器，清空各个FIFO  
43. ⑵配置预览通道主框控制寄存器，预览模式开始  
44. ⑶将设备接口体的状态标志标识为CAMIF_STATE_PREVIEWING  
45. ⑷配置图像捕捉使能寄存器，图像捕捉全局使能，预览通道捕捉使能  
46. ⑸一个判断语句，如果stream为0，则设备结构体的命令变量变为CAMIF_CMD_STOP，并设置一个等待中断队列  
47. camif_release的实现  
48.   
49. static int camif_release(struct inode *inode, struct file *file)  
50. {  
51.     struct tq2440_camif_fh  * fh;  
52.     struct tq2440_camif_dev * pdev;  
53.   
54.     fh = file->private_data;  
55.     pdev = fh->dev;  
56.   
57.   
58.         clk_disable(pdev->clk);          // stop camif clock  
59.   
60.         free_irq(IRQ_S3C2440_CAM_P, pdev);  // free camif IRQs  
61.   
62.         free_irq(IRQ_S3C2440_CAM_C, pdev);  
63.   
64.         free_image_buffer();            // and free image buffer  
65.   
66.     return 0;  
67. }  
68.   
69. ①关闭时钟，释放P通道中断，释放C通道中断，释放4个DMA缓存  

5、卸载函数camif_cleanup

相对与所有的程序块，这部分应该是最简单的，基本就是释放一些资源，前面的一些反操作

/*

 * camif_cleanup()

 */

static void __exit camif_cleanup(void)

{

struct tq2440_camif_dev *pdev;

// sccb_cleanup();

CFG_READ(SIO_C);

CFG_READ(SIO_D);

pdev = &camera;

misc_deregister(&misc);

clk_put(pdev->clk);

iounmap((void *)camif_base_addr);

release_mem_region((unsigned long)S3C2440_PA_CAMIF, S3C2440_SZ_CAMIF);

printk(KERN_ALERT"tq2440_camif: module removed/n");

}

 

6、总结

由上面的程序跟踪我们发现字符设备程序的主体就是file_operation的填充，上面很多内嵌的函数都没有粘贴出来，我不敢说不重要，实际是很多程序嵌来嵌去的很容易把我整蒙，所以只是大致的读了一意思（能明白这块是做什么的以及如果我要修改程序我应该明白修改什么地方就行）。