高通平台android 8.1基线某款usb camera打开dev/video1出错

快来打我* 2022-10-25 14:21 511阅读 0赞

**故障现象：**  
某客户需要调试一款usb camera，包括黑白和彩色两个sensor：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nvcm5lcnN0b25lMQ_size_16_color_FFFFFF_t_70]

在调试中发现调用open函数去打开注册的 dev/video1节点时报错：  
USBCamera: Cannot open ‘/dev/video1’: 16, Device or resource busy

**分析：**  
1.首先排查硬件的问题。  
把该camera连接到PC，下载通用的camera驱动后，设备管理器中显示：  
![在这里插入图片描述][20210201110252233.png]  
使用网上下载的USB摄像头采集调试工具2020可以正常使用的，说明硬件是好的。

2.检查下camera的uvc驱动注册是正常的:  
\[ 6.406765\] usb 1-1: New USB device found, idVendor=15aa, idProduct=1555  
\[ 6.412464\] usb 1-1: New USB device strings: Mfr=3, Product=1, SerialNumber=2  
\[ 6.419546\] usb 1-1: Product: SIT USB2.0 Camera RGB  
\[ 6.424433\] usb 1-1: Manufacturer: Generic  
\[ 6.428487\] usb 1-1: SerialNumber: 200901010001  
\[ 6.439198\] uvcvideo: Found UVC 1.00 device SIT USB2.0 Camera RGB (15aa:1555)  
检查dev下成功注册了video1节点。

3.apk会通过ioctl调到uvc camera的open操作。（uvc\_v4l2.c）

const struct v4l2_file_operations uvc_fops = {
        
    	.owner		= THIS_MODULE,
    	.open		= uvc_v4l2_open,
    	.release	= uvc_v4l2_release,
    	.unlocked_ioctl	= uvc_v4l2_ioctl,
    #ifdef CONFIG_COMPAT
    	.compat_ioctl32	= uvc_v4l2_compat_ioctl32,
    #endif
    	.read		= uvc_v4l2_read,
    	.mmap		= uvc_v4l2_mmap,
    	.poll		= uvc_v4l2_poll,
    #ifndef CONFIG_MMU
    	.get_unmapped_area = uvc_v4l2_get_unmapped_area,
    #endif
    };

既然是上层open错误，那肯定是调用到驱动这里的open有错误。  
继续添加打印发现是uvc\_fops的.open函数uvc\_v4l2\_open -->ret = usb\_autopm\_get\_interface(stream->dev->intf);  
这里返回错误 -16。

4.usb\_autopm\_get\_interface分析。  
uvc\_v4l2\_open函数里会调用usb\_autopm\_get\_interface：

static int uvc_v4l2_open(struct file *file)
    {
        
    	struct uvc_streaming *stream;
    	struct uvc_fh *handle;
    	int ret = 0;
    
    	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
    	stream = video_drvdata(file);
    
    	if (stream->dev->state & UVC_DEV_DISCONNECTED)
    		return -ENODEV;
    
    	ret = usb_autopm_get_interface(stream->dev->intf);
    	if (ret < 0)
    		return ret;
    
    	/* Create the device handle. */
    	handle = kzalloc(sizeof *handle, GFP_KERNEL);
    	if (handle == NULL) {
        
    		usb_autopm_put_interface(stream->dev->intf);
    		return -ENOMEM;
    	}
    
    	mutex_lock(&stream->dev->lock);
    	if (stream->dev->users == 0) {
        
    		ret = uvc_status_start(stream->dev, GFP_KERNEL);
    		if (ret < 0) {
        
    			mutex_unlock(&stream->dev->lock);
    			usb_autopm_put_interface(stream->dev->intf);
    			kfree(handle);
    			return ret;
    		}
    	}
    
    	stream->dev->users++;
    	mutex_unlock(&stream->dev->lock);
    
    	v4l2_fh_init(&handle->vfh, stream->vdev);
    	v4l2_fh_add(&handle->vfh);
    	handle->chain = stream->chain;
    	handle->stream = stream;
    	handle->state = UVC_HANDLE_PASSIVE;
    	file->private_data = handle;
    
    	return 0;
    }

这里就得说一下设备驱动的休眠和唤醒。  
usb的驱动结构体中有一个flag：.supports\_autosuspend ，用来标识是否支持自动休眠。当USB某个接口繁忙或空闲时通知USB core。主要有如下6个函数来实现休眠、唤醒功能：  
int usb\_autopm\_get\_interface(struct usb\_interface \*intf);  
void usb\_autopm\_put\_interface(struct usb\_interface \*intf);  
int usb\_autopm\_get\_interface\_async(struct usb\_interface \*intf);  
void usb\_autopm\_put\_interface\_async(struct usb\_interface \*intf);  
void usb\_autopm\_get\_interface\_no\_resume(struct usb\_interface \*intf);  
void usb\_autopm\_put\_interface\_no\_suspend(struct usb\_interface \*intf);  
这些函数通过维护使用计数器来工作。当计数器大于0时，接口将被视为繁忙，内核不会进入autosuspend；当usage counter=0时，接口被认为是空闲的，内核将会进入autosuspend。

重点关注 usb\_autopm\_get\_interface和usb\_autopm\_put\_interface函数。

/**
     * usb_autopm_get_interface - increment a USB interface's PM-usage counter
     * @intf: the usb_interface whose counter should be incremented
     *
     * This routine should be called by an interface driver when it wants to
     * use @intf and needs to guarantee that it is not suspended.  In addition,
     * the routine prevents @intf from being autosuspended subsequently.  (Note
     * that this will not prevent suspend events originating in the PM core.)
     * This prevention will persist until usb_autopm_put_interface() is called
     * or @intf is unbound.  A typical example would be a character-device
     * driver when its device file is opened.
     *
     * @intf's usage counter is incremented to prevent subsequent autosuspends.
     * However if the autoresume fails then the counter is re-decremented.
     *
     * This routine can run only in process context.
     *
     * Return: 0 on success.
     */
    int usb_autopm_get_interface(struct usb_interface *intf)
    {
        
    	int	status;
    
    	status = pm_runtime_get_sync(&intf->dev);
    	if (status < 0)
    		pm_runtime_put_sync(&intf->dev);
    	else
    		atomic_inc(&intf->pm_usage_cnt);
    	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
    			__func__, atomic_read(&intf->dev.power.usage_count),
    			status);
    	if (status > 0)
    		status = 0;
    	return status;
    }

●usb\_autopm\_get\_interface将会让usage counter +1，并在设备已经进入suspend时执行autoresume；如果autoresume失败，计数器又会-1到初始值的。

/**
     * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
     * @intf: the usb_interface whose counter should be decremented
     *
     * This routine should be called by an interface driver when it is
     * finished using @intf and wants to allow it to autosuspend.  A typical
     * example would be a character-device driver when its device file is
     * closed.
     *
     * The routine decrements @intf's usage counter.  When the counter reaches
     * 0, a delayed autosuspend request for @intf's device is attempted.  The
     * attempt may fail (see autosuspend_check()).
     *
     * This routine can run only in process context.
     */
    void usb_autopm_put_interface(struct usb_interface *intf)
    {
        
    	struct usb_device	*udev = interface_to_usbdev(intf);
    	int			status;
    
    	usb_mark_last_busy(udev);
    	atomic_dec(&intf->pm_usage_cnt);
    	status = pm_runtime_put_sync(&intf->dev);
    	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
    			__func__, atomic_read(&intf->dev.power.usage_count),
    			status);
    }

●usb\_autopm\_put\_interface执行和usb\_autopm\_get\_interface相反的功能，让usage counter -1，如果usage counter =0，则进入autosuspend。  
简单说，就是在驱动的open里调用usb\_autopm\_get\_interface，在close里调用usb\_autopm\_put\_interface，以此来实现usb的休眠唤醒功能。

回到前面的问题，usb\_autopm\_get\_interface返回错误：-16，说明该usb camera的休眠唤醒有问题，camera无法被唤醒。根据网上的参考怀疑echi处于suspend状态导致camera无法正常open, 由于项目不需要考虑耗电,所以打算暂时去掉pm runtime的功能： \#CONFIG\_PM\_RUNTIME is not set  
尴尬的是，android 8.1上注掉CONFIG\_PM\_RUNTIME会导致kernel编译不过的，使用CONFIG\_PM\_RUNTIME宏控制的代码很多，这样修改的工作量很大。

继续检查代码，在usb\_enumerate\_device函数中注释掉port进入休眠就可以正常了：

static int usb_enumerate_device(struct usb_device *udev)
    {
        
    	int err;
    	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
    
    	if (udev->config == NULL) {
        
    		err = usb_get_configuration(udev);
    		if (err < 0) {
        
    			if (err != -ENODEV)
    				dev_err(&udev->dev, "can't read configurations, error %d\n",
    						err);
    			return err;
    		}
    	}
    
    	/* read the standard strings and cache them if present */
    	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
    	udev->manufacturer = usb_cache_string(udev,
    					      udev->descriptor.iManufacturer);
    	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
    
    	err = usb_enumerate_device_otg(udev);
    	if (err < 0)
    		return err;
    
    	if (IS_ENABLED(CONFIG_USB_OTG_WHITELIST) && hcd->tpl_support &&
    		!is_targeted(udev)) {
        
    		/* Maybe it can talk to us, though we can't talk to it.
    		 * (Includes HNP test device.)
    		 */
    		if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
    			|| udev->bus->is_b_host)) {
        
    			//stone：注释掉usb的休眠
    			//err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
    			if (err < 0)
    				dev_dbg(&udev->dev, "HNP fail, %d\n", err);
    		}
    		return -ENOTSUPP;
    	}
    
    	usb_detect_interface_quirks(udev);
    
    	return 0;
    }

如果还是打不开，还需要考虑下应用的尺寸设置是否合适。

可以参考：https://www.kernel.org/doc/html/v4.16/driver-api/usb/power-management.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nvcm5lcnN0b25lMQ_size_16_color_FFFFFF_t_70]: /images/20221024/dea85a6d4ea74dc9b840767e144825ed.png
[20210201110252233.png]: /images/20221024/409d4baf880c4f5e81acab41abf7fd9e.png