Camera--V4L2驱动学习记录

Camera--V4L2驱动学习记录

Video for Linux Two

1.V4l2_device

1. struct v4l2_device{
   
2. /*->to.
   
3. :NULLifis
   
4. iscase.g..*/
   
5. *dev;
   
6. /*to*/
   
7. ;
   
8. /*;if
   
9. is.*/
   
10. ;
    
11. /*,+*/
    
12. [V4L2_DEVICE_NAME_SIZE];
    
13. /*sub-devices.*/
    
14. (*notify)(*sd,
    
15. int,*arg);
    
16. };

1. int(*dev,*v4l2_dev)
   
2. {
   
3. if(==NULL)
   
4. -EINVAL;
   
5. 
   
6. (&v4l2_dev->subdevs);
   
7. (&v4l2_dev->lock);
   
8. ->=;
   
9. if(==NULL){
   
10. /*If==NULL,thenin*/
    
11. (!v4l2_dev->name[0]);
    
12. ;
    
13. }
    
14. 
    
15. /*Setto+ifisempty.*/
    
16. if(!v4l2_dev->name[0])
    
17. (v4l2_dev->name,(v4l2_dev->name),"%s %s",
    
18. ->driver->name,(dev));
    
19. if(dev_get_drvdata(dev))
    
20. (v4l2_dev,"Non-NULL drvdata on register\n");
    
21. (dev,);
    
22. ;
    
23. }
    
24. EXPORT_SYMBOL_GPL(v4l2_device_register);

1. void v4l2_device_unregister(*v4l2_dev)
   
2. {
   
3. *sd,*next;
   
4. 
   
5. if(==NULL)
   
6. ;
   
7. (v4l2_dev);
   
8. 
   
9. /**/
   
10. (sd,next,&v4l2_dev->subdevs,){
    
11. (sd);
    
12. #if(CONFIG_I2C)||(defined(CONFIG_I2C_MODULE)&&(MODULE))
    
13. if(sd->&){
    
14. *=(sd);
    
15. 
    
16. /*to.
    
17. onto
    
18. for,if
    
19. is,thenis.*/
    
20. if(client)
    
21. (client);
    
22. }
    
23. #endif
    
24. }
    
25. }
    
26. EXPORT_SYMBOL_GPL(v4l2_device_unregister);

2.video_device

1. /*
   
2. *,.c
   
3. *to
   
4. *
   
5. */
   
6. 
   
7. struct video_device
   
8. {
   
9. /**/
   
10. const*fops;
    
11. 
    
12. /**/
    
13. ;/**/
    
14. *cdev;/**/
    
15. 
    
16. /*Setorif*/
    
17. *parent;/**/
    
18. *v4l2_dev;/**/
    
19. 
    
20. /**/
    
21. [32];
    
22. int;
    
23. /*'minor'issetto-if*/
    
24. int;
    
25. ;
    
26. /*toset/clear/*/
    
27. ;
    
28. /*toon*/
    
29. int;
    
30. 
    
31. int;/**/
    
32. 
    
33. /**/
    
34. ;/**/
    
35. ;/**/
    
36. 
    
37. /**/
    
38. (*release)(*vdev);
    
39. 
    
40. /**/
    
41. const*ioctl_ops;
    
42. };

1. /**
   
2. *-
   
3. *:to
   
4. *:to
   
5. *:(==/dev/video0,==/dev/video1,...
   
6. *-==)
   
7. *:if
   
8. *inand.
   
9. *
   
10. *and
    
11. *onand
    
12. *.
    
13. *errorisifor
    
14. *,orif.
    
15. *
    
16. *ison.
    
17. *
    
18. *
    
19. *
    
20. *%-
    
21. *
    
22. *%-
    
23. *
    
24. *%-(undecoded)
    
25. *
    
26. *%-
    
27. */
    
28. int(*vdev,int,int,
    
29. int)
    
30. {
    
31. int=;
    
32. int;
    
33. int=;
    
34. int=;
    
35. const*name_base;
    
36. *=(vdev);
    
37. 
    
38. /*-1 marks this video device as never
    
39. */
    
40. ->=-1;
    
41. 
    
42. /**/
    
43. (!vdev->release);
    
44. if(!vdev->release)
    
45. -EINVAL;
    
46. 
    
47. /*:*/
    
48. (type){
    
49. case:
    
50. ="video";
    
51. ;
    
52. case:
    
53. ="vtx";
    
54. ;
    
55. case:
    
56. ="vbi";
    
57. ;
    
58. case:
    
59. ="radio";
    
60. ;
    
61. :
    
62. ("%s called with unknown type: %d\n",
    
63. ,);
    
64. -EINVAL;
    
65. }
    
66. 
    
67. ->=;
    
68. ->=NULL;
    
69. if(vdev->&&->v4l2_dev->dev)
    
70. ->=->v4l2_dev->dev;
    
71. 
    
72. /*:,and.*/
    
73. #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
    
74. /*forfor
    
75. *.
    
76. *(notin)
    
77. *-and
    
78. *(new style).*/
    
79. (type){
    
80. case:
    
81. =;
    
82. =;
    
83. ;
    
84. case:
    
85. =;
    
86. =;
    
87. ;
    
88. case:
    
89. =;
    
90. =;
    
91. ;
    
92. case:
    
93. =;
    
94. =;
    
95. ;
    
96. :
    
97. =;
    
98. =;
    
99. ;
    
100. }
     
101. #endif
     
102. 
     
103. /**/
     
104. (&videodev_lock);
     
105. =(vdev,==-?:,);
     
106. if(==)
     
107. =(vdev,,);
     
108. if(==){
     
109. ("could not get a free device node number\n");
     
110. (&videodev_lock);
     
111. -ENFILE;
     
112. }
     
113. #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
     
114. /*-on-to*/
     
115. =;
     
116. #else
     
117. /*and,
     
118. .*/
     
119. for(=;<;++)
     
120. if(video_device[i]==NULL)
     
121. ;
     
122. if(==){
     
123. (&videodev_lock);
     
124. ("could not get a free minor\n");
     
125. -ENFILE;
     
126. }
     
127. #endif
     
128. ->=+;
     
129. ->=;
     
130. (vdev);
     
131. 
     
132. /*not*/
     
133. (video_device[vdev->minor]!=NULL);
     
134. ->=(vdev);
     
135. (&videodev_lock);
     
136. 
     
137. /*:*/
     
138. ->=();
     
139. if(vdev->==NULL){
     
140. =-ENOMEM;
     
141. ;
     
142. }
     
143. if(vdev->fops->unlocked_ioctl)
     
144. ->cdev->=&v4l2_unlocked_fops;
     
145. else
     
146. ->cdev->=&v4l2_fops;
     
147. ->cdev->=->fops->owner;
     
148. =(vdev->cdev,(VIDEO_MAJOR,->minor),);
     
149. if(<){
     
150. ("%s: cdev_add failed\n",);
     
151. (vdev->cdev);
     
152. ->=NULL;
     
153. ;
     
154. }
     
155. 
     
156. /*:*/
     
157. (&vdev->dev,,(vdev->dev));
     
158. /*'s drvdata,
     
159. .*/
     
160. (vdev,);
     
161. ->dev.class=&video_class;
     
162. ->dev.=(VIDEO_MAJOR,->minor);
     
163. if(vdev->parent)
     
164. ->dev.=->parent;
     
165. (&vdev->dev,"%s%d",,->num);
     
166. =(&vdev->dev);
     
167. if(<){
     
168. ("%s: device_register failed\n",);
     
169. ;
     
170. }
     
171. /*
     
172. to.*/
     
173. ->dev.=;
     
174. 
     
175. if(!=-&&!=->&&)
     
176. ("%s: requested %s%d, got %s%d\n",
     
177. ,,,,->num);
     
178. 
     
179. /*:.now.*/
     
180. (&videodev_lock);
     
181. [vdev->minor]=;
     
182. (&videodev_lock);
     
183. ;
     
184. 
     
185. cleanup:
     
186. (&videodev_lock);
     
187. if(vdev->cdev)
     
188. (vdev->cdev);
     
189. (vdev);
     
190. (&videodev_lock);
     
191. /*.*/
     
192. ->=-1;
     
193. ;
     
194. }
     
195. 
     
196. int(*vdev,int,int)
     
197. {
     
198. (vdev,,,);
     
199. }
     
200. EXPORT_SYMBOL(video_register_device);
201. 
     
202. /**
     
203. *-
     
204. *:to
     
205. *
     
206. *.
     
207. *.
     
208. */
     
209. void video_unregister_device(*vdev)
     
210. {
     
211. /*if*/
     
212. if(!||-><)
     
213. ;
     
214. 
     
215. (&videodev_lock);
     
216. (V4L2_FL_UNREGISTERED,&vdev->flags);
     
217. (&videodev_lock);
     
218. (&vdev->dev);
     
219. }
     
220. EXPORT_SYMBOL(video_unregister_device);

3.v4l2_subdev

1. /*Each,
   
2. -orin.
   
3. */
   
4. {
   
5. ;
   
6. *owner;
   
7. ;
   
8. *v4l2_dev;
   
9. const*ops;
   
10. /**/
    
11. [V4L2_SUBDEV_NAME_SIZE];
    
12. /*to,is-*/
    
13. ;
    
14. /*toprivate*/
    
15. *priv;
    
16. };

4.v4l2_buffer

1. {
   
2. ;
   
3. ;
   
4. ;
   
5. ;
   
6. ;
   
7. ;
   
8. ;
   
9. ;
   
10. 
    
11. /*location*/
    
12. ;
    
13. {
    
14. ;
    
15. ;
    
16. };
    
17. ;
    
18. ;
    
19. ;
    
20. };