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

linux设备驱动——UVC驱动程序_linux uvc驱动 c源码

作者：盐析白兔 | 2024-04-18 06:30:10

赞

踩

linux uvc驱动 c源码

1.uvc驱动框架

首先，因为要用USB传数据，入口函数中注册usb_driver结构体，出口函数反之

  1. static int myuvc_init(void)
  2. {
  3.     usb_register(&myuvc_driver);
  4.     return 0;
  5. }
  6.  
  7. static void myuvc_exit(void)
  8. {
  9.     usb_deregister(&myuvc_driver);
  10. }

usb_driver结构体中提供probe函数和id_table 

  1. static struct usb_driver myuvc_driver = {
  2.     .name       = "myuvc",
  3.     .probe      = myuvc_probe,
  4.     .disconnect = myuvc_disconnect,
  5.     .id_table   = myuvc_ids,
  6. };

id_table用来判断此驱动是否支持某USB设备 

  1. static struct usb_device_id myuvc_ids[] = {
  2. 	/* Generic USB Video Class */
  3. 	{ USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },  /* VideoControl Interface */
  4.     { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 2, 0) },  /* VideoStreaming Interface */
  5. 	{}
  6. };

如果插入一个USB设备，判断id_table通过则会调用此驱动的probe函数

UVC的probe函数主要做这几件事：

1.分配video_device结构体

video_device_alloc()

2. 设置video_device结构体

3. 注册video_device结构体

video_register_device(myuvc_vdev, VFL_TYPE_GRABBER, -1)

这里UVC驱动程序把video_device结构体注册给上一层的v4l2-dev.c文件，在v4l2-dev.c中会注册字符设备等一些操作，上一层的操作我们不关心，我们只需要在UVC设备驱动层提供一个video_device结构体就行了

我们来看看需要设置video_device结构体的哪些内容

  1. struct video_device
  2. {
  3. 	/* device ops */
  4. 	const struct v4l2_file_operations *fops;
  5.  
  6. 	/* sysfs */
  7. 	struct device dev;		/* v4l device */
  8. 	struct cdev *cdev;		/* character device */
  9.  
  10. 	/* Set either parent or v4l2_dev if your driver uses v4l2_device */
  11. 	struct device *parent;		/* device parent */
  12. 	struct v4l2_device *v4l2_dev;	/* v4l2_device parent */
  13.  
  14. 	/* device info */
  15. 	char name[32];
  16. 	int vfl_type;
  17. 	/* 'minor' is set to -1 if the registration failed */
  18. 	int minor;
  19. 	u16 num;
  20. 	/* use bitops to set/clear/test flags */
  21. 	unsigned long flags;
  22. 	/* attribute to differentiate multiple indices on one physical device */
  23. 	int index;
  24.  
  25. 	int debug;			/* Activates debug level*/
  26.  
  27. 	/* Video standard vars */
  28. 	v4l2_std_id tvnorms;		/* Supported tv norms */
  29. 	v4l2_std_id current_norm;	/* Current tvnorm */
  30.  
  31. 	/* callbacks */
  32. 	void (*release)(struct video_device *vdev);
  33.  
  34. 	/* ioctl callbacks */
  35. 	const struct v4l2_ioctl_ops *ioctl_ops;
  36. };

别惊讶video_device有这么多内容，其实只有设置其中几项就可以工作了

1.

void (*release)(struct video_device *vdev)

这项要设置，不然装载驱动的时候会报错，写个空函数就行了

2.

const struct v4l2_file_operations *fops;

应用程序open等，会直接调用fops中的open

3.

const struct v4l2_ioctl_ops *ioctl_ops

应用程序ioctl，会直接调用这里的ioctl


很明显，我们只要把fops和ioctl_ops这两个结构体设置好就OK了


2.ioctl_ops结构体

ioctl_ops的定义里有好多项，但是必须的只有以下11项

  1. static const struct v4l2_ioctl_ops myuvc_ioctl_ops = {
  2.         // 表示它是一个摄像头设备
  3.         .vidioc_querycap      = myuvc_vidioc_querycap,
  4.  
  5.         /* 用于列举、获得、测试、设置摄像头的数据的格式 */
  6.         .vidioc_enum_fmt_vid_cap  = myuvc_vidioc_enum_fmt_vid_cap,
  7.         .vidioc_g_fmt_vid_cap     = myuvc_vidioc_g_fmt_vid_cap,
  8.         .vidioc_try_fmt_vid_cap   = myuvc_vidioc_try_fmt_vid_cap,
  9.         .vidioc_s_fmt_vid_cap     = myuvc_vidioc_s_fmt_vid_cap,
  10.         
  11.         /* 缓冲区操作: 申请/查询/放入队列/取出队列 */
  12.         .vidioc_reqbufs       = myuvc_vidioc_reqbufs,
  13.         .vidioc_querybuf      = myuvc_vidioc_querybuf,
  14.         .vidioc_qbuf          = myuvc_vidioc_qbuf,
  15.         .vidioc_dqbuf         = myuvc_vidioc_dqbuf,
  16.         
  17.         // 启动/停止
  18.         .vidioc_streamon      = myuvc_vidioc_streamon,
  19.         .vidioc_streamoff     = myuvc_vidioc_streamoff,   
  20. };

2.1 vidioc_querycap

应用程序会调用它来判断此设备设否是一个摄像头设备

我们只要把传进来的v4l2_capability设置相应的参数就可以了

  1. static int myuvc_vidioc_querycap(struct file *file, void  *priv,
  2. 					struct v4l2_capability *cap)
  3. {    
  4.     memset(cap, 0, sizeof *cap);
  5.     strcpy(cap->driver, "myuvc");
  6.     strcpy(cap->card, "myuvc");
  7.     cap->version = 1;
  8.     
  9.     cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
  10.  
  11. 	return 0;
  12. }

2.2 vidioc_enum_fmt_vid_cap

应用程序会调用它来获取摄像头所支持的格式（数据格式），这里我们只返回一种格式

  1. static int myuvc_vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
  2. 					struct v4l2_fmtdesc *f)
  3. {
  4.     /* 人工查看描述符可知我们用的摄像头只支持1种格式 */
  5. 	if (f->index >= 1)
  6. 		return -EINVAL;
  7.  
  8.     /* 支持什么格式呢?
  9.      * 查看VideoStreaming Interface的描述符,
  10.      * 得到GUID为"59 55 59 32 00 00 10 00 80 00 00 aa 00 38 9b 71"
  11.      */
  12. 	strcpy(f->description, "4:2:2, packed, YUYV");
  13. 	f->pixelformat = V4L2_PIX_FMT_YUYV;    
  14.     
  15. 	return 0;
  16. }


2.3 vidioc_g_fmt_vid_cap

获取当前格式

驱动程序会把当前的格式存在一个内存的一个v4l2_format结构体中，应用程序要获取当前格式只需要把这个结构体返回给应用程序

  1. static int myuvc_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
  2. 					struct v4l2_format *f)
  3. {
  4.     memcpy(f, &myuvc_format, sizeof(myuvc_format));
  5. 	return (0);
  6. }

2.4 vidioc_try_fmt_vid_cap

测试是否支持此格式

应用程序有可能会设置某摄像头不支持的格式（分辨率等），所以在设置之前要先测试一下是否支持

此函数中会进行判断，如果某些参数不支持则返回错误，，支持的话会把一些其他参数强制设成摄像头所支持的

  1. static int myuvc_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
  2. 			struct v4l2_format *f)
  3. {
  4.     if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  5.     {
  6.         return -EINVAL;
  7.     }
  8.  
  9.     if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV)
  10.         return -EINVAL;
  11.     
  12.     /* 调整format的width, height, 
  13.      * 计算bytesperline, sizeimage
  14.      */
  15.  
  16.     /* 人工查看描述符, 确定支持哪几种分辨率 */
  17.     f->fmt.pix.width  = frames[frame_idx].width;
  18.     f->fmt.pix.height = frames[frame_idx].height;
  19.     
  20. 	f->fmt.pix.bytesperline =
  21. 		(f->fmt.pix.width * bBitsPerPixel) >> 3;
  22. 	f->fmt.pix.sizeimage =
  23. 		f->fmt.pix.height * f->fmt.pix.bytesperline;
  24.     
  25.     return 0;
  26. }

2.5 myuvc_vidioc_s_fmt_vid_cap

设置参数

应用程序设置参数，这里先要测试一下参数是否可用，然后把这些参数保存在内存中，留着以后用

  1. static int myuvc_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
  2. 					struct v4l2_format *f)
  3. {
  4. 	int ret = myuvc_vidioc_try_fmt_vid_cap(file, NULL, f);
  5. 	if (ret < 0)
  6. 		return ret;
  7.  
  8.     memcpy(&myuvc_format, f, sizeof(myuvc_format));
  9.     
  10.     return 0;
  11. }

2.6 vidioc_reqbufs

分配缓冲区，并放入队列

1.USB传来的数据会存到这些缓冲区里，应用程序读数据再从这些缓冲区里读

2.缓冲区会分配几个，但是会一次性分配，给出缓冲区的起始地址，不同的缓冲区会有不同的偏移值

3.这些缓冲区的描述在一个结构体中，在myuvc_queue中有结构体myuvc_buffer，是描述这些buffer用的

4.两个队列，队列mainqueue供APP读数据用，队列irqqueue供USB传输数据用，队列的定义也在myuvc_queue中


  1. struct myuvc_queue {
  2.     void *mem;
  3.     int count;
  4.     int buf_size;    
  5.     struct myuvc_buffer buffer[32];
  6.  
  7. 	struct urb *urb[32];
  8. 	char *urb_buffer[32];
  9. 	dma_addr_t urb_dma[32];
  10. 	unsigned int urb_size;
  11.  
  12. 	struct list_head mainqueue;   /* 供APP消费用 */
  13. 	struct list_head irqqueue;    /* 供底层驱动生产用 */
  14. };

  1. struct myuvc_buffer {    
  2.     struct v4l2_buffer buf;
  3.     int state;
  4.     int vma_use_count; /* 表示是否已经被mmap */
  5.     wait_queue_head_t wait;  /* APP要读某个缓冲区,如果无数据,在此休眠 */
  6. 	struct list_head stream;
  7. 	struct list_head irq;    
  8. };

下面是分配缓冲区的具体函数 

  1. static int myuvc_vidioc_reqbufs(struct file *file, void *priv,
  2. 			  struct v4l2_requestbuffers *p)
  3. {
  4.     int nbuffers = p->count;
  5.     int bufsize  = PAGE_ALIGN(myuvc_format.fmt.pix.sizeimage);
  6.     unsigned int i;
  7.     void *mem = NULL;
  8.     int ret;
  9.  
  10.     if ((ret = myuvc_free_buffers()) < 0)
  11.         goto done;
  12.  
  13.     /* Bail out if no buffers should be allocated. */
  14.     if (nbuffers == 0)
  15.         goto done;
  16.  
  17.     /* Decrement the number of buffers until allocation succeeds. */
  18.     for (; nbuffers > 0; --nbuffers) {
  19.         mem = vmalloc_32(nbuffers * bufsize);
  20.         if (mem != NULL)
  21.             break;
  22.     }
  23.  
  24.     if (mem == NULL) {
  25.         ret = -ENOMEM;
  26.         goto done;
  27.     }
  28.  
  29.     /* 这些缓存是一次性作为一个整体来分配的 */
  30.     memset(&myuvc_queue, 0, sizeof(myuvc_queue));
  31.  
  32. 	INIT_LIST_HEAD(&myuvc_queue.mainqueue);
  33. 	INIT_LIST_HEAD(&myuvc_queue.irqqueue);
  34.  
  35.     for (i = 0; i < nbuffers; ++i) {
  36.         myuvc_queue.buffer[i].buf.index = i;
  37.         myuvc_queue.buffer[i].buf.m.offset = i * bufsize;
  38.         myuvc_queue.buffer[i].buf.length = myuvc_format.fmt.pix.sizeimage;
  39.         myuvc_queue.buffer[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  40.         myuvc_queue.buffer[i].buf.sequence = 0;
  41.         myuvc_queue.buffer[i].buf.field = V4L2_FIELD_NONE;
  42.         myuvc_queue.buffer[i].buf.memory = V4L2_MEMORY_MMAP;
  43.         myuvc_queue.buffer[i].buf.flags = 0;
  44.         myuvc_queue.buffer[i].state     = VIDEOBUF_IDLE;
  45.         init_waitqueue_head(&myuvc_queue.buffer[i].wait);
  46.     }
  47.  
  48.     myuvc_queue.mem = mem;
  49.     myuvc_queue.count = nbuffers;
  50.     myuvc_queue.buf_size = bufsize;
  51.     ret = nbuffers;
  52.  
  53. done:
  54.     return ret;
  55. }

2.6 vidioc_querybuf

查询缓存的信息

这很简单只需要把myuvc_queue中相应的buffer中的buf赋给传入的参数就可以了，其余的操作是设置缓冲区状态

  1. static int myuvc_vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *v4l2_buf)
  2. {
  3.     int ret = 0;
  4.     
  5. 	if (v4l2_buf->index >= myuvc_queue.count) {
  6. 		ret = -EINVAL;
  7. 		goto done;
  8. 	}
  9.  
  10.     memcpy(v4l2_buf, &myuvc_queue.buffer[v4l2_buf->index].buf, sizeof(*v4l2_buf));
  11.  
  12.     /* 更新flags */
  13. 	if (myuvc_queue.buffer[v4l2_buf->index].vma_use_count)
  14. 		v4l2_buf->flags |= V4L2_BUF_FLAG_MAPPED;
  15.  
  16.  
  17. 	switch (myuvc_queue.buffer[v4l2_buf->index].state) {
  18.     	case VIDEOBUF_ERROR:
  19.     	case VIDEOBUF_DONE:
  20.     		v4l2_buf->flags |= V4L2_BUF_FLAG_DONE;
  21.     		break;
  22.     	case VIDEOBUF_QUEUED:
  23.     	case VIDEOBUF_ACTIVE:
  24.     		v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
  25.     		break;
  26.     	case VIDEOBUF_IDLE:
  27.     	default:
  28.     		break;
  29. 	}
  30.  
  31. done:    
  32. 	return ret;
  33. }

2.7 vidioc_qbuf

把缓冲区放入两个队列，主要是

list_add_tail(&buf->stream, &myuvc_queue.mainqueue);

list_add_tail(&buf->irq, &myuvc_queue.irqqueue);

这两个函数，其余的都是判断和修改缓冲区状态

  1. static int myuvc_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *v4l2_buf)
  2. {
  3.     struct myuvc_buffer *buf;
  4.     int ret;
  5.  
  6.     /* 0. APP传入的v4l2_buf可能有问题, 要做判断 */
  7.  
  8. 	if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
  9. 	    v4l2_buf->memory != V4L2_MEMORY_MMAP) {
  10. 		return -EINVAL;
  11. 	}
  12.  
  13. 	if (v4l2_buf->index >= myuvc_queue.count) {
  14. 		return -EINVAL;
  15. 	}
  16.  
  17.     buf = &myuvc_queue.buffer[v4l2_buf->index];
  18.  
  19. 	if (buf->state != VIDEOBUF_IDLE) {
  20. 		return -EINVAL;
  21. 	}
  22.  
  23.  
  24.     /* 1. 修改状态 */
  25. 	buf->state = VIDEOBUF_QUEUED;
  26. 	buf->buf.bytesused = 0;
  27.  
  28.     /* 2. 放入2个队列 */
  29.     /* 队列1: 供APP使用 
  30.      * 当缓冲区没有数据时,放入mainqueue队列
  31.      * 当缓冲区有数据时, APP从mainqueue队列中取出
  32.      */
  33. 	list_add_tail(&buf->stream, &myuvc_queue.mainqueue);
  34.  
  35.     /* 队列2: 供产生数据的函数使用
  36.      * 当采集到数据时,从irqqueue队列中取出第1个缓冲区,存入数据
  37.      */
  38. 	list_add_tail(&buf->irq, &myuvc_queue.irqqueue);
  39.     
  40. 	return 0;
  41. }

2.8 vidioc_dqbuf

取出队列，供APP使用，APP调用此函数把缓冲区从mainqueue队列中取出

  1. static int myuvc_vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *v4l2_buf)
  2. {
  3.     /* APP发现数据就绪后, 从mainqueue里取出这个buffer */
  4.  
  5.     struct myuvc_buffer *buf;
  6.     int ret = 0;
  7.  
  8. 	if (list_empty(&myuvc_queue.mainqueue)) {
  9. 		ret = -EINVAL;
  10. 		goto done;
  11. 	}
  12.     
  13. 	buf = list_first_entry(&myuvc_queue.mainqueue, struct myuvc_buffer, stream);
  14.  
  15. 	switch (buf->state) {
  16. 	case VIDEOBUF_ERROR:
  17. 		ret = -EIO;
  18. 	case VIDEOBUF_DONE:
  19. 		buf->state = VIDEOBUF_IDLE;
  20. 		break;
  21.  
  22. 	case VIDEOBUF_IDLE:
  23. 	case VIDEOBUF_QUEUED:
  24. 	case VIDEOBUF_ACTIVE:
  25. 	default:
  26. 		ret = -EINVAL;
  27. 		goto done;
  28. 	}
  29.  
  30. 	list_del(&buf->stream);
  31.  
  32. done:
  33. 	return ret;
  34. }

2.9 vidioc_streamon

启动摄像头传输

要做的工作有：

1. 向USB摄像头设置参数: 比如使用哪个format

2. 分配设置URB

3. 提交URB以接收数据


2.9.1 设置参数

设置streaming_control

参数存在intf->cur_altsetting->desc.bInterfaceNumber中，已被USB总线驱动读到内存，可以直接读取
streaming_control不是标准的USB描述符,USB总线驱动里没有定义结构体，我们要先参考uvcvideo.c定义streaming_control结构体

1.测试参数
设置参数前要先把参数发给摄像头，让摄像头判断这些参数可用否
把streaming_control结构体的数据赋值给数组data
用usb_control_msg发送数据测试

  1. static int myuvc_try_streaming_params(struct myuvc_streaming_control *ctrl)
  2. {
  3.     __u8 *data;
  4.     __u16 size;
  5.     int ret;
  6. 	__u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
  7. 	unsigned int pipe;
  8.     
  9. 	memset(ctrl, 0, sizeof *ctrl);
  10.     
  11. 	ctrl->bmHint = 1;	/* dwFrameInterval */
  12. 	ctrl->bFormatIndex = 1;
  13. 	ctrl->bFrameIndex  = frame_idx + 1;
  14. 	ctrl->dwFrameInterval = 333333;
  15.  
  16.  
  17.     size = uvc_version >= 0x0110 ? 34 : 26;
  18.     data = kzalloc(size, GFP_KERNEL);
  19.     if (data == NULL)
  20.         return -ENOMEM;
  21.  
  22.     *(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
  23.     data[2] = ctrl->bFormatIndex;
  24.     data[3] = ctrl->bFrameIndex;
  25.     *(__le32 *)&data[4] = cpu_to_le32(ctrl->dwFrameInterval);
  26.     *(__le16 *)&data[8] = cpu_to_le16(ctrl->wKeyFrameRate);
  27.     *(__le16 *)&data[10] = cpu_to_le16(ctrl->wPFrameRate);
  28.     *(__le16 *)&data[12] = cpu_to_le16(ctrl->wCompQuality);
  29.     *(__le16 *)&data[14] = cpu_to_le16(ctrl->wCompWindowSize);
  30.     *(__le16 *)&data[16] = cpu_to_le16(ctrl->wDelay);
  31.     put_unaligned_le32(ctrl->dwMaxVideoFrameSize, &data[18]);
  32.     put_unaligned_le32(ctrl->dwMaxPayloadTransferSize, &data[22]);
  33.  
  34.     if (size == 34) {
  35.         put_unaligned_le32(ctrl->dwClockFrequency, &data[26]);
  36.         data[30] = ctrl->bmFramingInfo;
  37.         data[31] = ctrl->bPreferedVersion;
  38.         data[32] = ctrl->bMinVersion;
  39.         data[33] = ctrl->bMaxVersion;
  40.     }
  41.  
  42.     pipe = (SET_CUR & 0x80) ? usb_rcvctrlpipe(myuvc_udev, 0)
  43.                   : usb_sndctrlpipe(myuvc_udev, 0);
  44.     type |= (SET_CUR & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
  45.  
  46.     ret = usb_control_msg(myuvc_udev, pipe, SET_CUR, type, VS_PROBE_CONTROL << 8,
  47.             0 << 8 | myuvc_streaming_intf, data, size, 5000);
  48.  
  49.     kfree(data);
  50.     
  51.     return (ret < 0) ? ret : 0;
  52.     
  53. }


2.读参数
如果测试成功，摄像头里的有些数据会更新，所以我们先把数据读到内存中我们定义的streaming_control结构体中
读出数据到数组data里，再赋值给streaming_control结构体
用usb_control_msg获得数据 
  1. static int myuvc_get_streaming_params(struct myuvc_streaming_control *ctrl)
  2. {
  3. 	__u8 *data;
  4. 	__u16 size;
  5. 	int ret;
  6. 	__u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
  7. 	unsigned int pipe;
  8.  
  9. 	size = uvc_version >= 0x0110 ? 34 : 26;
  10. 	data = kmalloc(size, GFP_KERNEL);
  11. 	if (data == NULL)
  12. 		return -ENOMEM;
  13.    
  14. 	pipe = (GET_CUR & 0x80) ? usb_rcvctrlpipe(myuvc_udev, 0)
  15. 			      : usb_sndctrlpipe(myuvc_udev, 0);
  16. 	type |= (GET_CUR & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
  17.  
  18. 	ret = usb_control_msg(myuvc_udev, pipe, GET_CUR, type, VS_PROBE_CONTROL << 8,
  19. 			0 << 8 | myuvc_streaming_intf, data, size, 5000);
  20.  
  21.     if (ret < 0)
  22.         goto done;
  23.  
  24. 	ctrl->bmHint = le16_to_cpup((__le16 *)&data[0]);
  25. 	ctrl->bFormatIndex = data[2];
  26. 	ctrl->bFrameIndex = data[3];
  27. 	ctrl->dwFrameInterval = le32_to_cpup((__le32 *)&data[4]);
  28. 	ctrl->wKeyFrameRate = le16_to_cpup((__le16 *)&data[8]);
  29. 	ctrl->wPFrameRate = le16_to_cpup((__le16 *)&data[10]);
  30. 	ctrl->wCompQuality = le16_to_cpup((__le16 *)&data[12]);
  31. 	ctrl->wCompWindowSize = le16_to_cpup((__le16 *)&data[14]);
  32. 	ctrl->wDelay = le16_to_cpup((__le16 *)&data[16]);
  33. 	ctrl->dwMaxVideoFrameSize = get_unaligned_le32(&data[18]);
  34. 	ctrl->dwMaxPayloadTransferSize = get_unaligned_le32(&data[22]);
  35.  
  36. 	if (size == 34) {
  37. 		ctrl->dwClockFrequency = get_unaligned_le32(&data[26]);
  38. 		ctrl->bmFramingInfo = data[30];
  39. 		ctrl->bPreferedVersion = data[31];
  40. 		ctrl->bMinVersion = data[32];
  41. 		ctrl->bMaxVersion = data[33];
  42. 	} else {
  43. 		//ctrl->dwClockFrequency = video->dev->clock_frequency;
  44. 		ctrl->bmFramingInfo = 0;
  45. 		ctrl->bPreferedVersion = 0;
  46. 		ctrl->bMinVersion = 0;
  47. 		ctrl->bMaxVersion = 0;
  48. 	}
  49.  
  50. done:
  51.     kfree(data);
  52.     
  53.     return (ret < 0) ? ret : 0;
  54. }


3.设置参数
设置参数的函数几乎与测试参数的函数相同，
区别是少了设置的部分和usb_control_msg的参数不同 

  1. static int myuvc_set_streaming_params(struct myuvc_streaming_control *ctrl)
  2. {
  3.     __u8 *data;
  4.     __u16 size;
  5.     int ret;
  6. 	__u8 type = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
  7. 	unsigned int pipe;
  8.     
  9.     size = uvc_version >= 0x0110 ? 34 : 26;
  10.     data = kzalloc(size, GFP_KERNEL);
  11.     if (data == NULL)
  12.         return -ENOMEM;
  13.  
  14.     *(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
  15.     data[2] = ctrl->bFormatIndex;
  16.     data[3] = ctrl->bFrameIndex;
  17.     *(__le32 *)&data[4] = cpu_to_le32(ctrl->dwFrameInterval);
  18.     *(__le16 *)&data[8] = cpu_to_le16(ctrl->wKeyFrameRate);
  19.     *(__le16 *)&data[10] = cpu_to_le16(ctrl->wPFrameRate);
  20.     *(__le16 *)&data[12] = cpu_to_le16(ctrl->wCompQuality);
  21.     *(__le16 *)&data[14] = cpu_to_le16(ctrl->wCompWindowSize);
  22.     *(__le16 *)&data[16] = cpu_to_le16(ctrl->wDelay);
  23.     put_unaligned_le32(ctrl->dwMaxVideoFrameSize, &data[18]);
  24.     put_unaligned_le32(ctrl->dwMaxPayloadTransferSize, &data[22]);
  25.  
  26.     if (size == 34) {
  27.         put_unaligned_le32(ctrl->dwClockFrequency, &data[26]);
  28.         data[30] = ctrl->bmFramingInfo;
  29.         data[31] = ctrl->bPreferedVersion;
  30.         data[32] = ctrl->bMinVersion;
  31.         data[33] = ctrl->bMaxVersion;
  32.     }
  33.  
  34.     pipe = (SET_CUR & 0x80) ? usb_rcvctrlpipe(myuvc_udev, 0)
  35.                   : usb_sndctrlpipe(myuvc_udev, 0);
  36.     type |= (SET_CUR & 0x80) ? USB_DIR_IN : USB_DIR_OUT;
  37.  
  38.     ret = usb_control_msg(myuvc_udev, pipe, SET_CUR, type, VS_COMMIT_CONTROL << 8,
  39.             0 << 8 | myuvc_streaming_intf, data, size, 5000);
  40.  
  41.     kfree(data);
  42.     
  43.     return (ret < 0) ? ret : 0;
  44.     
  45. }


2.9.2 URB

1. 分配usb_buffers

2. 分配urb

3. 设置urb

4. 提交urb

  1. static int myuvc_alloc_init_urbs(void)
  2. {
  3. 	u16 psize;
  4. 	u32 size;
  5. 	int npackets;
  6. 	int i;
  7. 	int j;
  8.  
  9. 	struct urb *urb;
  10.  
  11. 	psize = wMaxPacketSize; /* 实时传输端点一次能传输的最大字节数 */
  12. 	size  = myuvc_params.dwMaxVideoFrameSize;  /* 一帧数据的最大长度 */
  13.     	npackets = DIV_ROUND_UP(size, psize);
  14. 	if (npackets > 32)
  15. 	    npackets = 32;
  16.  
  17. 	size = myuvc_queue.urb_size = psize * npackets;
  18.  
  19. 	for (i = 0; i < MYUVC_URBS; ++i) {
  20. 	    /* 1. 分配usb_buffers */
  21. 	    
  22. 	    myuvc_queue.urb_buffer[i] = usb_buffer_alloc(
  23. 	        myuvc_udev, size,
  24. 	        GFP_KERNEL | __GFP_NOWARN, &myuvc_queue.urb_dma[i]);
  25.  
  26. 	    /* 2. 分配urb */
  27. 		myuvc_queue.urb[i] = usb_alloc_urb(npackets, GFP_KERNEL);
  28.  
  29. 	    if (!myuvc_queue.urb_buffer[i] || !myuvc_queue.urb[i])
  30. 	    {
  31. 	        myuvc_uninit_urbs();
  32. 	        return -ENOMEM;
  33. 	    }
  34.  
  35. 	}
  36.  
  37.  
  38. 	/* 3. 设置urb */
  39. 	for (i = 0; i < MYUVC_URBS; ++i) {
  40. 	    urb = myuvc_queue.urb[i];
  41. 	    
  42. 	    urb->dev = myuvc_udev;
  43. 	    urb->context = NULL;
  44. 	    urb->pipe = usb_rcvisocpipe(myuvc_udev,myuvc_bEndpointAddress);
  45. 	    urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
  46. 	    urb->interval = 1;
  47. 	    urb->transfer_buffer = myuvc_queue.urb_buffer[i];
  48. 	    urb->transfer_dma = myuvc_queue.urb_dma[i];
  49. 	    urb->complete = myuvc_video_complete;
  50. 	    urb->number_of_packets = npackets;
  51. 	    urb->transfer_buffer_length = size;
  52. 	    
  53. 	    for (j = 0; j < npackets; ++j) {
  54. 	        urb->iso_frame_desc[j].offset = j * psize;
  55. 	        urb->iso_frame_desc[j].length = psize;
  56. 	    }
  57.  
  58. 	}
  59.  
  60. 	   /* 4. 提交URB以接收数据 */
  61. 	for (i = 0; i < MYUVC_URBS; ++i) {
  62. 	   if ((ret = usb_submit_urb(myuvc_queue.urb[i], GFP_KERNEL)) < 0) {
  63. 		   printk("Failed to submit URB %u (%d).\n", i, ret);
  64. 		   myuvc_uninit_urbs();
  65. 		   return ret;
  66. 	   }
  67. 	}
  68. 	
  69.     return 0;
  70. }







声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/444484
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号