mx53 camera s5k5bbgx驱动分析

一： linux驱动层

1. 通讯方式I2C驱动注册：

a： arch/arm/mach-mx5/mx53_xx.c

/*

声明s5k5bbgx的IIC 资源

*/

[cpp] view plain copy

1. <spanstyle="font-size:16px;">staticintmxc_camera2_pwdn(intpwdn)
2. {
3. if(pwdn)
4. gpio_direction_output(MX53_HMS_CAMERA2_PWN,1);
5. else
6. gpio_direction_output(MX53_HMS_CAMERA2_PWN,0);
7. return0;
8. }
10. staticstructmxc_camera_platform_datacamera2_data={
11. .mclk=24000000,
12. .csi=0,
13. .pwdn=mxc_camera2_pwdn,
14. };
16. staticstructi2c_board_infomxc_i2c0_board_info[]__initdata={
18. {
19. .type="s5k5bbgx",
20. .addr=0x2d,
21. //IIC地址为7位，最后一位是读写位，mx53的驱动内部会把地址左移一位，所以这里要右移一位
22. .platform_data=(void*)&camera2_data,
23. },
25. }
27. </span>

[cpp] view plain copy

1. <spanstyle="font-size:16px;">/*!
2. *Boardspecificinitialization.
3. */
4. staticvoid__initmxc_board_init(void)
5. {
6. i2c_register_board_info(0,mxc_i2c0_board_info,
7. ARRAY_SIZE(mxc_i2c0_board_info));
8. }</span>

b： driver/media/video/capture/xx_cam_2M.c

/*

* 注册IIC驱动

*/

[cpp] view plain copy

1. <spanstyle="font-size:16px;">staticstructi2c_client*s5k5bbgx_i2c_client=NULL;
4. staticconststructi2c_device_ids5k5bbgx_id[]={
5. {"s5k5bbgx",0},
6. {},
7. };
9. MODULE_DEVICE_TABLE(i2c,s5k5bbgx_id);
11. staticstruct2055_i2c_drvier{
12. .driver={
13. .owner=THIS_MODULE,
14. .name="s5k5bbgx",
15. },
16. .probe=s5k5bbgx_probe,
17. .remove=s5k5bbgx_remove,
18. .id_table=s5k5bbgx_id,
21. };
22. /*!
23. *s5k5bbgxinitfunction
24. *Calledbyinsmods5k5bbgx_camera.ko.
25. *
26. *@returnErrorcodeindicatingsuccessorfailure
27. */
28. static__initints5k5bbgx_init(void)
29. {
30. U8err;
31. err=i2c_add_driver(s5k5bbgx_i2c_driver);
32. returnerr;
33. }
34. staticints5k5bbgx_probe(structi2c_client*client,
35. conststructi2c_device_id*id)
36. {
37. s5k5bbgx_i2c_client=client;
39. return0;
40. }
41. /*
42. IIC读写
43. */
44. statics32s5k5bbgx_read_reg(u16reg,u16*val)
45. {
46. u8au8RegBuf[2]={0};
47. u8data[2]={0};
49. au8RegBuf[0]=reg>>8;
50. au8RegBuf[1]=reg&0xff;
52. if(2!=i2c_master_send(s5k5bbgx_i2c_client,au8RegBuf,2)){
53. pr_err("%s:writeregerror:reg=%x\n",
54. __func__,reg);
55. return-1;
56. }
58. if(2!=i2c_master_recv(s5k5bbgx_i2c_client,data,2)){
59. pr_err("%s:readregerror:reg=0x%04x\n",
60. __func__,reg);
61. return-2;
62. }
64. *val=(data[0]<<8)|data[1];
66. return0;
67. }
70. statics32s5k5bbgx_write_reg(u16cammand,u16val)
71. {
72. u8au8Buf[4]={0};
74. au8Buf[0]=cammand>>8;
75. au8Buf[1]=cammand&0xff;
76. au8Buf[2]=val>>8;
77. au8Buf[3]=val&0xff;
79. if(4!=i2c_master_send(s5k5bbgx_i2c_client,au8Buf,4)){
80. pr_err("%s:writecammanderror:cammand=0x%04x,val=0x%04x\n",
81. __func__,cammand,val);
82. return-1;
83. }
85. return0;
86. }
87. <strong>
88. </strong></span>

至此IIC注册完毕

b： 注册 v4l2 slave device:

[cpp] view plain copy

1. <spanstyle="font-size:16px;">/*!
2. *Maintainstheinformationonthecurrentstateofthesesor.
3. */
4. structsensor{
5. conststructmxc_camera_platform_data*platform_data;
6. structv4l2_int_device*v4l2_int_device;
7. structi2c_client*i2c_client;
8. structv4l2_pix_formatpix;
9. structv4l2_captureparmstreamcap;
10. boolon;
12. /*controlsettings*/
13. intbrightness;
14. inthue;
15. intcontrast;
16. intsaturation;
17. intred;
18. intgreen;
19. intblue;
20. intae_mode;
22. u32mclk;
23. intcsi;
24. }s5k5bbgx_data;
25. /*!
26. *Thisstructuredefinesalltheioctlsforthismoduleandlinksthemtothe
27. *enumeration.
28. */
29. staticstructv4l2_int_ioctl_descs5k5bbgx_ioctl_desc[]={
31. {vidioc_int_s_parm_num,(v4l2_int_ioctl_func*)ioctl_s_parm},
32. {vidioc_int_s_ctrl_num,(v4l2_int_ioctl_func*)ioctl_s_ctrl},
34. };
37. staticstructv4l2_int_slaves5k5bbgx_slave={
38. .ioctls=s5k5bbgx_ioctl_desc,
39. .num_ioctls=ARRAY_SIZE(s5k5bbgx_ioctl_desc),
40. };
43. staticstructv4l2_int_devices5k5bbgx_int_device={
44. .module=THIS_MODULE,
45. .name="s5k5bbgx",
46. .type=v4l2_int_type_slave,
47. .u={
48. .slave=&s5k5bbgx_slave,
49. },
50. };
51. /*!
52. *ioctl_s_parm-V4L2sensorinterfacehandlerforVIDIOC_S_PARMioctl
53. *@s:pointertostandardV4L2devicestructure
54. *@a:pointertostandardV4L2VIDIOC_S_PARMioctlstructure
55. *
56. *Configuresthesensortousetheinputparameters,ifpossible.If
57. *notpossible,revertstotheoldparametersandreturnsthe
58. *appropriateerrorcode.
59. */
60. staticintioctl_s_parm(structv4l2_int_device*s,structv4l2_streamparm*a)
61. {
62. structsensor*sensor=s->priv;
63. structv4l2_fract*timeperframe=&a->parm.capture.timeperframe;
64. u32tgt_fps;/*targetframespersecound*/
65. enums5k5bbgx_frame_rateframe_rate;
66. intret=0;
68. /*Makesurepoweron*/
69. if(camera_plat->pwdn)
70. camera_plat->pwdn(0);
72. switch(a->type){
73. /*Thisistheonlycasecurrentlyhandled.*/
74. caseV4L2_BUF_TYPE_VIDEO_CAPTURE:
77. /*Theseareallthepossiblecases.*/
78. caseV4L2_BUF_TYPE_VIDEO_OUTPUT:
79. caseV4L2_BUF_TYPE_VIDEO_OVERLAY:
80. caseV4L2_BUF_TYPE_VBI_CAPTURE:
81. caseV4L2_BUF_TYPE_VBI_OUTPUT:
82. caseV4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
83. caseV4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
84. pr_debug("typeisnot"\
85. "V4L2_BUF_TYPE_VIDEO_CAPTUREbut%d\n",
86. a->type);
87. ret=-EINVAL;
88. break;
90. default:
91. pr_debug("typeisunknown-%d\n",a->type);
92. ret=-EINVAL;
93. break;
94. }
96. returnret;
97. }
98. /*!
99. *ioctl_s_ctrl-V4L2sensorinterfacehandlerforVIDIOC_S_CTRLioctl
100. *@s:pointertostandardV4L2devicestructure
101. *@vc:standardV4L2VIDIOC_S_CTRLioctlstructure
102. *
103. *Iftherequestedcontrolissupported,setsthecontrol'scurrent
104. *valueinHW(andupdatesthevideo_control[]array).Otherwise,
105. *returns-EINVALifthecontrolisnotsupported.
106. */
107. staticintioctl_s_ctrl(structv4l2_int_device*s,structv4l2_control*vc)
108. {
109. intretval=0;
111. pr_debug("Ins5k5bbgx:ioctl_s_ctrl%d\n",
112. vc->id);
114. switch(vc->id){
115. caseV4L2_CID_BRIGHTNESS:
116. break;
117. caseV4L2_CID_CONTRAST:
118. break;
119. caseV4L2_CID_SATURATION:
120. break;
121. caseV4L2_CID_HUE:
122. break;
123. caseV4L2_CID_AUTO_WHITE_BALANCE:
124. break;
125. caseV4L2_CID_DO_WHITE_BALANCE:
126. break;
127. default:
128. retval=-EPERM;
129. break;
130. }
132. returnretval;
133. }
137. staticints5k5bbgx_probe(strcti2c_client*client,conststructi2c_device_id*id)
138. {
139. s5k5bbgx_int_device.priv=&s5k5bbgx_data;
140. retval=v4l2_int_device_register(&s5k5bbgx_int_device);
141. }
142. </span>

v4l2 slave device 注册完毕

c: s5k5bbgx 初始化和操作

[cpp] view plain copy

1. <spanstyle="font-size:16px;">staticints5k5bbgx_probe(structi2c_client*client,
2. conststructi2c_device_id*id)
3. {
5. /*
6. *默认的参数：yuv模式，像素，帧速等。这些参数会在s_paramioctl中重新设置
7. */
8. s5k5bbgx_data.pix.pixelformat=V4L2_PIX_FMT_YUYV;
10. s5k5bbgx_data.pix.width=800;
11. s5k5bbgx_data.pix.height=600;
12. s5k5bbgx_data.streamcap.capability=V4L2_MODE_HIGHQUALITY|
13. V4L2_CAP_TIMEPERFRAME;
14. s5k5bbgx.streamcap.capturemode=0;
15. s5k5bbgx_data.streamcap.timeperframe.denominator=DEFAULT_FPS;
16. s5k5bbgx_data.streamcap.timeperframe.numerator=1;
18. }
19. staticints5k5bbgx_init_mode(enums5k5bbgx_frame_rateframe_rate,
20. enums5k5bbgx_modemode)
21. {
22. structreg_value*pModeSetting=NULL;
23. s32i=0;
24. s32iModeSettingArySize=0;
25. registeru32Delay_ms=0;
26. registeru16RegAddr=0;
27. registeru8Mask=0;
28. registeru16Val=0;
29. registeru8u8Val=0;
30. u8RegVal=0;
31. intretval=0;
34. pModeSetting=s5k5bbgx_mode_info_data[frame_rate][mode].init_data_ptr;
35. iModeSettingArySize=s5k5bbgx_mode_info_data[frame_rate][mode].init_data_size;
36. s5k5bbgx_data.pix.width=s5k5bbgx_mode_info_data[frame_rate][mode].width;
37. s5k5bbgx_data.pix.height=s5k5bbgx_mode_info_data[frame_rate][mode].height;
38. /*
39. *设置camera的参数，如fps，像素等
40. */
41. for(i=0;i<iModeSettingArySize;++i,++pModeSetting){
42. Delay_ms=pModeSetting->u32Delay_ms;
43. RegAddr=pModeSetting->u16RegAddr;
44. Val=pModeSetting->u16Val;
45. Mask=pModeSetting->u8Mask;
46. if(Mask){
47. RegVal&=~(u8)Mask;
48. Val&=Mask;
49. Val|=RegVal;
50. }
51. retval=s5k5bbgx_write_reg(RegAddr,Val);
52. if(retval<0)
53. gotoerr;
55. if(Delay_ms)
56. msleep(Delay_ms);
57. }
58. }
60. structs5k5ggbx_sets5k5ggbx_set_data[12]={
61. {preview,ARRAY_SIZE(preview)},//screenmode:auto
62. {record,ARRAY_SIZE(record)},
63. {night,ARRAY_SIZE(night)},
64. {capture,ARRAY_SIZE(capture)},//capture
65. {normal,ARRAY_SIZE(normal)},//coloreffect
66. {mono,ARRAY_SIZE(mono)},
67. {negative,ARRAY_SIZE(negative)},
68. {sepia,ARRAY_SIZE(sepia)},
69. {Auto,ARRAY_SIZE(Auto)},//whitebalance
70. {incandescent,ARRAY_SIZE(incandescent)},
71. {daylight,ARRAY_SIZE(daylight)},
72. {flourescent,ARRAY_SIZE(flourescent)}
73. };
75. /*
76. 设置白平衡等参数
77. */
78. staticints5k5ggbx_set_code(intindex)
79. {
80. structreg_value*p=NULL;
81. s32i=0;
82. s32size=0;
83. intretval;
84. registeru32Delay_ms=0;
85. registeru16RegAddr=0;
86. registeru16Val=0;
88. p=s5k5ggbx_set_data[index].init_data_ptr;
89. size=s5k5ggbx_set_data[index].init_data_size;
91. for(i=0;i<size;++i,++p){
92. Delay_ms=p->u32Delay_ms;
93. RegAddr=p->u16RegAddr;
94. Val=p->u16Val;
96. retval=s5k5bbgx_write_reg(RegAddr,Val);
97. if(retval<0)
98. returnretval;
100. if(Delay_ms)
101. msleep(Delay_ms);
103. }
105. return0;
106. }
109. staticintioctl_s_parm(structv4l2_int_device*s,structv4l2_streamparm*a)
110. {
111. switch(a->type){
112. /*Thisistheonlycasecurrentlyhandled.*/
113. caseV4L2_BUF_TYPE_VIDEO_CAPTURE:
114. /*Checkthatthenewframerateisallowed.*/
115. if((timeperframe->numerator==0)||
116. (timeperframe->denominator==0)){
117. timeperframe->denominator=DEFAULT_FPS;
118. timeperframe->numerator=1;
119. }
121. tgt_fps=timeperframe->denominator/
122. timeperframe->numerator;
124. if(tgt_fps>MAX_FPS){
125. timeperframe->denominator=MAX_FPS;
126. timeperframe->numerator=1;
127. }elseif(tgt_fps<MIN_FPS){
128. timeperframe->denominator=MIN_FPS;
129. timeperframe->numerator=1;
130. }
132. /*Actualframerateweuse*/
133. tgt_fps=timeperframe->denominator/
134. timeperframe->numerator;
136. /*Actualframerateweuse*/
137. tgt_fps=timeperframe->denominator/
138. timeperframe->numerator;
140. if(tgt_fps==15)
141. frame_rate=ov2655_15_fps;
142. elseif(tgt_fps==30)
143. frame_rate=ov2655_30_fps;
144. elseif(tgt_fps==7)
145. frame_rate=ov2655_7p5_fps;
146. else{
147. pr_err("Thecameraframerateisnotsupported!\n");
148. return-EINVAL;
149. }
151. sensor->streamcap.timeperframe=*timeperframe;
152. sensor->streamcap.capturemode=(u32)a->parm.capture.capturemode;
153. printk("\n%s,frame_rate=%d,sensor->streamcap.capturemode=%d\n",__func__,frame_rate,sensor->streamcap.capturemode);
154. if(sensor->streamcap.capturemode==2)//preview:normal
155. {
156. s5k5ggbx_init_mode(frame_rate,sensor->streamcap.capturemode);
157. s5k5ggbx_set_code(0);
158. }
159. elseif(sensor->streamcap.capturemode==4)//capture
160. {
161. s5k5ggbx_init_mode(frame_rate,sensor->streamcap.capturemode);
162. s5k5ggbx_set_code(3);
163. }
164. elseif(sensor->streamcap.capturemode==1)//preview:recording
165. {
166. s5k5ggbx_init_mode(frame_rate,sensor->streamcap.capturemode);
167. s5k5ggbx_set_code(1);
168. }
171. break;
173. }
175. }
178. </span>

二，V4L2 capture应用

1.接口

[cpp] view plain copy

1. <spanstyle="font-size:16px;">namespaceandroid{
3. classV4l2CapDeviceBase:publicCaptureDeviceInterface{
4. public:
6. virtualCAPTURE_DEVICE_ERR_RETSetDevName(char*deviceName);
7. virtualCAPTURE_DEVICE_ERR_RETGetDevName(char*deviceName);
8. virtualCAPTURE_DEVICE_ERR_RETDevOpen();
9. virtualCAPTURE_DEVICE_ERR_RETEnumDevParam(DevParamTypedevParamType,void*retParam);
10. virtualCAPTURE_DEVICE_ERR_RETDevSetCtrl(intid,intvalue);
11. virtualCAPTURE_DEVICE_ERR_RETDevSetConfig(structcapture_config_t*pCapcfg);
12. virtualCAPTURE_DEVICE_ERR_RETDevAllocateBuf(DMA_BUFFER*DevBufQue,unsignedint*pBufQueNum);
13. virtualCAPTURE_DEVICE_ERR_RETDevPrepare();
14. virtualCAPTURE_DEVICE_ERR_RETDevStart();
15. virtualCAPTURE_DEVICE_ERR_RETDevDequeue(unsignedint*pBufQueIdx);
16. virtualCAPTURE_DEVICE_ERR_RETDevStop();
17. virtualCAPTURE_DEVICE_ERR_RETDevDeAllocate();
18. virtualCAPTURE_DEVICE_ERR_RETDevClose();
20. protected:
22. V4l2CapDeviceBase();
23. virtual~V4l2CapDeviceBase();
24. virtualCAPTURE_DEVICE_ERR_RETV4l2Open();
25. virtualCAPTURE_DEVICE_ERR_RETV4l2EnumParam(DevParamTypedevParamType,void*retParam);
26. virtualCAPTURE_DEVICE_ERR_RETV4l2EnumFmt(void*retParam);
27. virtualCAPTURE_DEVICE_ERR_RETV4l2EnumSizeFps(void*retParam);
28. virtualCAPTURE_DEVICE_ERR_RETV4l2SetConfig(structcapture_config_t*pCapcfg);
29. virtualCAPTURE_DEVICE_ERR_RETV4l2AllocateBuf(DMA_BUFFER*DevBufQue,unsignedint*pBufQueNum);
30. virtualCAPTURE_DEVICE_ERR_RETV4l2Prepare();
31. virtualCAPTURE_DEVICE_ERR_RETV4l2Start();
32. virtualCAPTURE_DEVICE_ERR_RETV4l2Dequeue(unsignedint*pBufQueIdx);
33. virtualCAPTURE_DEVICE_ERR_RETV4l2Queue(unsignedintBufQueIdx);
34. virtualCAPTURE_DEVICE_ERR_RETV4l2Stop();
35. virtualCAPTURE_DEVICE_ERR_RETV4l2DeAlloc();
36. virtualCAPTURE_DEVICE_ERR_RETV4l2Close();
37. virtualCAPTURE_DEVICE_ERR_RETV4l2ConfigInput(structcapture_config_t*pCapcfg);
38. virtualCAPTURE_DEVICE_ERR_RETV4l2GetCaptureMode(structcapture_config_t*pCapcfg,unsignedint*pMode);
39. virtualCAPTURE_DEVICE_ERR_RETV4l2SetRot(structcapture_config_t*pCapcfg);
41. charmCaptureDeviceName[CAMAERA_FILENAME_LENGTH];
42. charmInitalDeviceName[CAMAERA_SENSOR_LENGTH];
43. intmCameraDevice;
44. unsignedintmFmtParamIdx;
45. unsignedintmSizeFPSParamIdx;
46. unsignedintmRequiredFmt;
47. unsignedintmBufQueNum;
48. intmQueuedBufNum;
49. DMA_BUFFERmCaptureBuffers[MAX_CAPTURE_BUF_QUE_NUM];
50. structcapture_config_tmCapCfg;
52. };
53. };
54. </span>

2. 经典的调用流程。

具体解析可以看 http://www.linuxidc.com/Linux/2011-03/33022.htm

a. open device /dev/video16

b . VIDIOC_ENUM_FMT : get video capture supported format

struct v4l2_fmtdesc fmt;

ioctl(dev, VIDIOC_ENUM_FMT, &fmt))

c. VIDIOC_QUERYCAP , get the capture ability

struct v4l2_capability cap;

iret = ioctl(fd_usbcam, VIDIOC_QUERYCAP, &cap);

d. VIDIOC_S_FMT , set parameter

struct v4l2_format tv4l2_format;

tv4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tv4l2_format.fmt.pix.width = img_width;

tv4l2_format.fmt.pix.height = img_height;

tv4l2_format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

tv4l2_format.fmt.pix.field = V4L2_FIELD_INTERLACED;

iret = ioctl(fd_usbcam, VIDIOC_S_FMT, &tv4l2_format);

e. VIDIOC_REQBUFS : get buffer

// Request buffers
struct v4l2_requestbuffers reqbuf;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_MMAP;
reqbuf.count = BUFFER_COUNT;
ret = ioctl(fd , VIDIOC_REQBUFS, &reqbuf);
if(ret < 0) {
LOG("VIDIOC_REQBUFS failed (%d)\n", ret);
return ret;
}

f. VIDIOC_QUERYBUF

struct v4l2_buffer buf;
for(i=0; i // Query buffer
buf.index = i;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_QUERYBUF, &buf);
if(ret < 0) {
LOG("VIDIOC_QUERYBUF (%d) failed (%d)\n", i, ret);
return ret;
}

// mmap buffer
framebuf[i].length = buf.length;
framebuf[i].start = (char *) mmap(0, buf.length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
if (framebuf[i].start == MAP_FAILED) {
LOG("mmap (%d) failed: %s\n", i, strerror(errno));
return -1;
}

g. VIDIOC_QBUF

struct v4l2_buffer tV4L2buf;

memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));

tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2buf.memory = V4L2_MEMORY_MMAP;

tV4L2buf.index = i; //（指定）要投放到视频输入队列中的内核空间视频缓冲区的编号；

iret = ioctl(fd_usbcam, VIDIOC_QBUF, &tV4L2buf);

H. VIDIOC_STREAMON

enum v4l2_buf_type v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fd_set fds ;

struct timeval tv;

iret = ioctl(fd_usbcam, VIDIOC_STREAMON, &v4l2type);

i. VIDIOC_DQBUF

struct v4l2_buffer tV4L2buf;

memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));

tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2buf.memory = V4L2_MEMORY_MMAP;

iret = ioctl(fd_usbcam, VIDIOC_DQBUF, &tV4L2buf);

j. VIDIOC_QBUF VIDIOC_DQBUF VIDIOC_QBUF ...... (read data)
k. VIDIOC_STREAMOFF

enum v4l2_buf_type v4l2type;

v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

iret = ioctl(fd_usbcam, VIDIOC_STREAMOFF, &v4l2type);

3. android 上的实际实现：

与上面的大同小异，贴出两个函数

[cpp] view plain copy

1. CAPTURE_DEVICE_ERR_RETV4l2CapDeviceBase::V4l2Open(){
2. CAMERA_HAL_LOG_FUNC;
3. intfd=0,i,j,is_found=0;
4. constchar*flags[]={"uncompressed","compressed"};
6. chardev_node[CAMAERA_FILENAME_LENGTH];
7. DIR*v4l_dir=NULL;
8. structdirent*dir_entry;
9. structv4l2_capabilityv4l2_cap;
10. structv4l2_fmtdescvid_fmtdesc;
11. structv4l2_frmsizeenumvid_frmsize;
12. CAPTURE_DEVICE_ERR_RETret=CAPTURE_DEVICE_ERR_NONE;
14. if(mCameraDevice>0)
15. returnCAPTURE_DEVICE_ERR_ALRADY_OPENED;
16. elseif(mCaptureDeviceName[0]!='#'){
17. CAMERA_HAL_LOG_RUNTIME("alreadygetthedevicename%s",mCaptureDeviceName);
18. mCameraDevice=open(mCaptureDeviceName,O_RDWR,O_NONBLOCK);
19. if(mCameraDevice<0)
20. returnCAPTURE_DEVICE_ERR_OPEN;
21. }
22. else{
23. CAMERA_HAL_LOG_RUNTIME("deviceNameis%s",mInitalDeviceName);
24. v4l_dir=opendir("/sys/class/video4linux");
25. if(v4l_dir){
26. while((dir_entry=readdir(v4l_dir))){
27. memset((void*)dev_node,0,CAMAERA_FILENAME_LENGTH);
28. if(strncmp(dir_entry->d_name,"video",5))
29. continue;
30. sprintf(dev_node,"/dev/%s",dir_entry->d_name);
31. if((fd=open(dev_node,O_RDWR,O_NONBLOCK))<0)
32. continue;
33. CAMERA_HAL_LOG_RUNTIME("dev_nodeis%s",dev_node);
34. if(ioctl(fd,VIDIOC_QUERYCAP,&v4l2_cap)<0){
35. close(fd);
36. continue;
37. }elseif((strstr((char*)v4l2_cap.driver,mInitalDeviceName)!=0)&&
38. (v4l2_cap.capabilities&V4L2_CAP_VIDEO_CAPTURE)){
39. is_found=1;
40. strcpy(mCaptureDeviceName,dev_node);
41. CAMERA_HAL_LOG_RUNTIME("devicenameis%s",mCaptureDeviceName);
42. break;
43. }else
44. close(fd);
45. }
46. }
47. if(fd>0)
48. mCameraDevice=fd;
49. else{
50. CAMERA_HAL_ERR("Thedevicenameisnotcorrectorthedeviceiserror");
51. returnCAPTURE_DEVICE_ERR_OPEN;
52. }
53. }
54. returnret;
55. }

[cpp] view plain copy

1. CAPTURE_DEVICE_ERR_RETV4l2CapDeviceBase::V4l2AllocateBuf(DMA_BUFFER*DevBufQue,unsignedint*pBufQueNum){
2. unsignedinti;
3. structv4l2_bufferbuf;
4. enumv4l2_buf_typetype;
5. structv4l2_requestbuffersreq;
6. intBufQueNum;
8. CAMERA_HAL_LOG_FUNC;
9. if(mCameraDevice<=0||DevBufQue==NULL||pBufQueNum==NULL||*pBufQueNum==0){
10. returnCAPTURE_DEVICE_ERR_BAD_PARAM;
11. }
13. mBufQueNum=*pBufQueNum;
15. memset(&req,0,sizeof(req));
16. req.count=mBufQueNum;
17. req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
18. req.memory=V4L2_MEMORY_MMAP;
19. if(ioctl(mCameraDevice,VIDIOC_REQBUFS,&req)<0){
20. CAMERA_HAL_ERR("v4l_capture_setup:VIDIOC_REQBUFSfailed\n");
21. returnCAPTURE_DEVICE_ERR_SYS_CALL;
22. }
23. /*thedrivermaycan'tmeettherequest,andreturnthebufnumitcanhandle*/
24. *pBufQueNum=mBufQueNum=req.count;
26. for(i=0;i<mBufQueNum;i++){
27. memset(&buf,0,sizeof(buf));
28. buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
29. buf.index=i;
30. if(ioctl(mCameraDevice,VIDIOC_QUERYBUF,&buf)<0){
31. CAMERA_HAL_ERR("VIDIOC_QUERYBUFerror\n");
32. returnCAPTURE_DEVICE_ERR_SYS_CALL;
33. }else{
34. CAMERA_HAL_LOG_RUNTIME("VIDIOC_QUERYBUFok\n");
35. }
37. mCaptureBuffers[i].length=DevBufQue[i].length=buf.length;
38. mCaptureBuffers[i].phy_offset=DevBufQue[i].phy_offset=(size_t)buf.m.offset;
39. mCaptureBuffers[i].virt_start=DevBufQue[i].virt_start=(unsignedchar*)mmap(NULL,mCaptureBuffers[i].length,
40. PROT_READ|PROT_WRITE,MAP_SHARED,mCameraDevice,mCaptureBuffers[i].phy_offset);
41. memset(mCaptureBuffers[i].virt_start,0xFF,mCaptureBuffers[i].length);
42. CAMERA_HAL_LOG_RUNTIME("capturebuffers[%d].length=%d\n",i,mCaptureBuffers[i].length);
43. CAMERA_HAL_LOG_RUNTIME("capturebuffers[%d].phy_offset=0x%x\n",i,mCaptureBuffers[i].phy_offset);
44. CAMERA_HAL_LOG_RUNTIME("capturebuffers[%d].virt_start=0x%x\n",i,(unsignedint)(mCaptureBuffers[i].virt_start));
45. }
47. returnCAPTURE_DEVICE_ERR_NONE;
48. }