gadget驱动框架（三）

浅浅的花香味﹌ 2022-10-23 00:51 413阅读 0赞

# gadget驱动框架（三） #

## usb\_udc与usb\_gadget\_driver的绑定 ##

usb\_udc与usb\_gadget\_driver，在注册的时候分别被添加到udc\_list和gadget\_driver\_pending\_list中，无论这两者先后顺序如何，都将会动态的去识别及匹配到具体设备中，绑定过程如下：

源码：drivers/usb/gadget/udc/core.c

/* ------------------------------------------------------------------------- */
    
    static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
    {
    	int ret;
    
    	dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
    			driver->function);
    
    	udc->driver = driver;
    	udc->dev.driver = &driver->driver;
    	udc->gadget->dev.driver = &driver->driver;
    
    	usb_gadget_udc_set_speed(udc, driver->max_speed);
        
        //调用usb_gadget_driver的bind函数，实体为：composite_driver_template.bind
        //具体实现在drivers/usb/gadget/composite.c的composite_bind
    	ret = driver->bind(udc->gadget, driver);
    	if (ret)
    		goto err1;
    		
    	//调用usb_gadget的udc_start函数，需要udc驱动者实现
    	//主要功能是启动udc等
    	//源码：drivers/usb/gadget/udc/s3c2410_udc.c的s3c2410_udc_start
    	ret = usb_gadget_udc_start(udc);
    	if (ret) {
    		driver->unbind(udc->gadget);
    		goto err1;
    	}
    	
    	//调用usb_gadget的pullup函数，上拉或者下拉DP
    	usb_udc_connect_control(udc);
    
    	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
    	return 0;
    err1:
    	if (ret != -EISNAM)
    		dev_err(&udc->dev, "failed to start %s: %d\n",
    			udc->driver->function, ret);
    	udc->driver = NULL;
    	udc->dev.driver = NULL;
    	udc->gadget->dev.driver = NULL;
    	return ret;
    }

### usb\_udc\_connect\_control ###

源码：drivers/usb/gadget/udc/core.c

static void usb_udc_connect_control(struct usb_udc *udc)
    {
        //该变量在usb_add_gadget_udc_release创建usb_udc时置为true，
    	if (udc->vbus)
    		usb_gadget_connect(udc->gadget);
    	else
    		usb_gadget_disconnect(udc->gadget);
    }

/**
     * usb_gadget_connect - software-controlled connect to USB host
     * @gadget:the peripheral being connected
     *
     * Enables the D+ (or potentially D-) pullup.  The host will start
     * enumerating this gadget when the pullup is active and a VBUS session
     * is active (the link is powered).  This pullup is always enabled unless
     * usb_gadget_disconnect() has been used to disable it.
     *
     * Returns zero on success, else negative errno.
     */
    int usb_gadget_connect(struct usb_gadget *gadget)
    {
    	int ret = 0;
    
    	if (!gadget->ops->pullup) {
    		ret = -EOPNOTSUPP;
    		goto out;
    	}
    
    	if (gadget->deactivated) {
    		/*
    		 * If gadget is deactivated we only save new state.
    		 * Gadget will be connected automatically after activation.
    		 */
    		gadget->connected = true;
    		goto out;
    	}
        
        //调用usb_gadget的udc_start函数，需要udc驱动者实现
        //功能：上拉DP，让host检测到设备的插入
        //源码：drivers/usb/gadget/udc/s3c2410_udc.c的s3c2410_udc_pullup
    	ret = gadget->ops->pullup(gadget, 1);
    	if (!ret)
    		gadget->connected = 1;
    
    out:
    	trace_usb_gadget_connect(gadget, ret);
    
    	return ret;
    }

/**
     * usb_gadget_disconnect - software-controlled disconnect from USB host
     * @gadget:the peripheral being disconnected
     *
     * Disables the D+ (or potentially D-) pullup, which the host may see
     * as a disconnect (when a VBUS session is active).  Not all systems
     * support software pullup controls.
     *
     * Returns zero on success, else negative errno.
     */
    int usb_gadget_disconnect(struct usb_gadget *gadget)
    {
    	int ret = 0;
    
    	if (!gadget->ops->pullup) {
    		ret = -EOPNOTSUPP;
    		goto out;
    	}
    
    	if (gadget->deactivated) {
    		/*
    		 * If gadget is deactivated we only save new state.
    		 * Gadget will stay disconnected after activation.
    		 */
    		gadget->connected = false;
    		goto out;
    	}
    
        //调用usb_gadget的udc_start函数，需要udc驱动者实现
        //功能：下拉DP，让host检测到设备的拔出
        //源码：drivers/usb/gadget/udc/s3c2410_udc.c的s3c2410_udc_pullup
    	ret = gadget->ops->pullup(gadget, 0);
    	if (!ret)
    		gadget->connected = 0;
    
    out:
    	trace_usb_gadget_disconnect(gadget, ret);
    
    	return ret;
    }

## usb\_gadget\_driver的bind与ubind ##

主要功能是创建usb\_composite\_dev，及调用usb\_composite\_driver->bind函数

源码：drivers/usb/gadget/composite.c

static int composite_bind(struct usb_gadget *gadget,
    		struct usb_gadget_driver *gdriver)
    {
    	struct usb_composite_dev	*cdev;
    	struct usb_composite_driver	*composite = to_cdriver(gdriver);
    	int				status = -ENOMEM;
    
        //创建usb_composite_dev
    	cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
    	if (!cdev)
    		return status;
    
    	spin_lock_init(&cdev->lock);
    	cdev->gadget = gadget;
    	set_gadget_data(gadget, cdev);
    	//初始化usb_composite_dev的configs链表
    	INIT_LIST_HEAD(&cdev->configs);
    	//初始化usb_composite_dev的gstrings链表
    	INIT_LIST_HEAD(&cdev->gstrings);
    
        //初始化usb_composite_dev.req等
    	status = composite_dev_prepare(composite, cdev);
    	if (status)
    		goto fail;
    
    	/* composite gadget needs to assign strings for whole device (like
    	 * serial number), register function drivers, potentially update
    	 * power state and consumption, etc
    	 */
    	//回调usb_composite_driver的bind函数，
    	//实例为gsrial_driver.gsbind，
    	//源码：drivers/usb/gadget/legacy/serial.c
    	//主要功能为：初始化设备描述符、字符串描述符等
    	status = composite->bind(cdev);
    	if (status < 0)
    		goto fail;
    
    	if (cdev->use_os_string) {
    		status = composite_os_desc_req_prepare(cdev, gadget->ep0);
    		if (status)
    			goto fail;
    	}
    
    	update_unchanged_dev_desc(&cdev->desc, composite->dev);
    
    	/* has userspace failed to provide a serial number? */
    	if (composite->needs_serial && !cdev->desc.iSerialNumber)
    		WARNING(cdev, "userspace failed to provide iSerialNumber\n");
    
    	INFO(cdev, "%s ready\n", composite->name);
    	return 0;
    
    fail:
    	__composite_unbind(gadget, false);
    	return status;
    }

static void composite_unbind(struct usb_gadget *gadget)
    {
    	__composite_unbind(gadget, true);
    }

static void __composite_unbind(struct usb_gadget *gadget, bool unbind_driver)
    {
    	struct usb_composite_dev	*cdev = get_gadget_data(gadget);
    	struct usb_gadget_strings	*gstr = cdev->driver->strings[0];
    	struct usb_string		*dev_str = gstr->strings;
    
    	/* composite_disconnect() must already have been called
    	 * by the underlying peripheral controller driver!
    	 * so there's no i/o concurrency that could affect the
    	 * state protected by cdev->lock.
    	 */
    	WARN_ON(cdev->config);
    
    	while (!list_empty(&cdev->configs)) {
    		struct usb_configuration	*c;
    		c = list_first_entry(&cdev->configs,
    				struct usb_configuration, list);
    		remove_config(cdev, c);
    	}
    	if (cdev->driver->unbind && unbind_driver)
    		cdev->driver->unbind(cdev);
    
    	composite_dev_cleanup(cdev);
    
    	if (dev_str[USB_GADGET_MANUFACTURER_IDX].s == cdev->def_manufacturer)
    		dev_str[USB_GADGET_MANUFACTURER_IDX].s = "";
    
    	kfree(cdev->def_manufacturer);
    	kfree(cdev);
    	set_gadget_data(gadget, NULL);
    }

## usb\_composite\_driver的bind与ubind ##

源码：

static int gs_bind(struct usb_composite_dev *cdev)
    {
    	int			status;
    
    	/* Allocate string descriptor numbers ... note that string
    	 * contents can be overridden by the composite_dev glue.
    	 */
    
    	status = usb_string_ids_tab(cdev, strings_dev);
    	if (status < 0)
    		goto fail;
    	device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
    	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
    	status = strings_dev[STRING_DESCRIPTION_IDX].id;
    	serial_config_driver.iConfiguration = status;
    
        //otg设备的话，则需要做otg描述符的初始化，本次使用的非otg，暂不分析
    	if (gadget_is_otg(cdev->gadget)) {
    		if (!otg_desc[0]) {
    			struct usb_descriptor_header *usb_desc;
    
    			usb_desc = usb_otg_descriptor_alloc(cdev->gadget);
    			if (!usb_desc) {
    				status = -ENOMEM;
    				goto fail;
    			}
    			usb_otg_descriptor_init(cdev->gadget, usb_desc);
    			otg_desc[0] = usb_desc;
    			otg_desc[1] = NULL;
    		}
    		serial_config_driver.descriptors = otg_desc;
    		serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
    	}
    
    	/* register our configuration */
    	if (use_acm) {//acm function，kernel默认将use_acm置为true
    		status  = serial_register_ports(cdev, &serial_config_driver,
    				"acm");
    		usb_ep_autoconfig_reset(cdev->gadget);
    	} else if (use_obex)//obex function，kernel默认将use_acm置为false
    		status = serial_register_ports(cdev, &serial_config_driver,
    				"obex");
    	else {//gser function
    		status = serial_register_ports(cdev, &serial_config_driver,
    				"gser");
    	}
    	if (status < 0)
    		goto fail1;
    
    	usb_composite_overwrite_options(cdev, &coverwrite);
    	INFO(cdev, "%s\n", GS_VERSION_NAME);
    
    	return 0;
    fail1:
    	kfree(otg_desc[0]);
    	otg_desc[0] = NULL;
    fail:
    	return status;
    }

static int gs_unbind(struct usb_composite_dev *cdev)
    {
    	int i;
    
    	for (i = 0; i < n_ports; i++) {
    		usb_put_function(f_serial[i]);
    		usb_put_function_instance(fi_serial[i]);
    	}
    
    	kfree(otg_desc[0]);
    	otg_desc[0] = NULL;
    
    	return 0;
    }

## serial\_register\_ports的function的bind ##

static int serial_register_ports(struct usb_composite_dev *cdev,
    		struct usb_configuration *c, const char *f_name)
    {
    	int i;
    	int ret;
    
        //通过bConfigurationValue判断当前config，是否在cdev->configs链表中
        //在，则报错；不在，则添加到链表中
    	ret = usb_add_config_only(cdev, c);
    	if (ret)
    		goto out;
    
    	for (i = 0; i < n_ports; i++) {
    
            //根据f_name匹配相关的usb_function_instance
            //源码：drivers/usb/gadget/functions.c
    		fi_serial[i] = usb_get_function_instance(f_name);
    		if (IS_ERR(fi_serial[i])) {
    			ret = PTR_ERR(fi_serial[i]);
    			goto fail;
    		}
    
            //调用usb_function_instance的alloc_func申请usb_function
            //源码：drivers/usb/gadget/function/f_acm.c
    		f_serial[i] = usb_get_function(fi_serial[i]);
    		if (IS_ERR(f_serial[i])) {
    			ret = PTR_ERR(f_serial[i]);
    			goto err_get_func;
    		}
    
            //将申请到的usb_function添加到config->functions链表中
            //源码：drivers/usb/gadget/composite.c
    		ret = usb_add_function(c, f_serial[i]);
    		if (ret)
    			goto err_add_func;
    	}
    
    	return 0;
    
    err_add_func:
    	usb_put_function(f_serial[i]);
    err_get_func:
    	usb_put_function_instance(fi_serial[i]);
    
    fail:
    	i--;
    	while (i >= 0) {
    		usb_remove_function(c, f_serial[i]);
    		usb_put_function(f_serial[i]);
    		usb_put_function_instance(fi_serial[i]);
    		i--;
    	}
    out:
    	return ret;
    }

static struct usb_function_instance *try_get_usb_function_instance(const char *name)
    {
    	struct usb_function_driver *fd;
    	struct usb_function_instance *fi;
    
    	fi = ERR_PTR(-ENOENT);
    	mutex_lock(&func_lock);
    	//name="acm"，遍历func_list，查找"acm"所对应的usb_function_driver
    	list_for_each_entry(fd, &func_list, list) {
    
    		if (strcmp(name, fd->name))
    			continue;
    
    		if (!try_module_get(fd->mod)) {
    			fi = ERR_PTR(-EBUSY);
    			break;
    		}
    		//调用usb_function_driver.alloc_inst申请usb_function_instance
    		fi = fd->alloc_inst();
    		if (IS_ERR(fi))
    			module_put(fd->mod);
    		else
    			fi->fd = fd;
    		break;
    	}
    	mutex_unlock(&func_lock);
    	return fi;
    }
    
    struct usb_function_instance *usb_get_function_instance(const char *name)
    {
    	struct usb_function_instance *fi;
    	int ret;
        //name="acm"，通过该name获取usb_function_instance
    	fi = try_get_usb_function_instance(name);
    	if (!IS_ERR(fi))
    		return fi;
    	ret = PTR_ERR(fi);
    	if (ret != -ENOENT)
    		return fi;
    	ret = request_module("usbfunc:%s", name);
    	if (ret < 0)
    		return ERR_PTR(ret);
    	return try_get_usb_function_instance(name);
    }

struct usb_function *usb_get_function(struct usb_function_instance *fi)
    {
    	struct usb_function *f;
        //调用usb_function_instance的alloc_func申请usb_function
    	f = fi->fd->alloc_func(fi);
    	if (IS_ERR(f))
    		return f;
    	f->fi = fi;
    	return f;
    }
    EXPORT_SYMBOL_GPL(usb_get_function);

## usb\_configuration与usb\_functionn的bind ##

/**
     * usb_add_function() - add a function to a configuration
     * @config: the configuration
     * @function: the function being added
     * Context: single threaded during gadget setup
     *
     * After initialization, each configuration must have one or more
     * functions added to it.  Adding a function involves calling its @bind()
     * method to allocate resources such as interface and string identifiers
     * and endpoints.
     *
     * This function returns the value of the function's bind(), which is
     * zero for success else a negative errno value.
     */
    int usb_add_function(struct usb_configuration *config,
    		struct usb_function *function)
    {
    	int	value = -EINVAL;
    
    	DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
    			function->name, function,
    			config->label, config);
    
    	if (!function->set_alt || !function->disable)
    		goto done;
    
    	function->config = config;
    	//将function添加到config->functions链表中
    	list_add_tail(&function->list, &config->functions);
    
    	if (function->bind_deactivated) {
    		value = usb_function_deactivate(function);
    		if (value)
    			goto done;
    	}
    
    	/* REVISIT *require* function->bind? */
    	if (function->bind) {
    		value = function->bind(config, function);
    		if (value < 0) {
    			list_del(&function->list);
    			function->config = NULL;
    		}
    	} else
    		value = 0;
    
    	/* We allow configurations that don't work at both speeds.
    	 * If we run into a lowspeed Linux system, treat it the same
    	 * as full speed ... it's the function drivers that will need
    	 * to avoid bulk and ISO transfers.
    	 */
    	if (!config->fullspeed && function->fs_descriptors)
    		config->fullspeed = true;
    	if (!config->highspeed && function->hs_descriptors)
    		config->highspeed = true;
    	if (!config->superspeed && function->ss_descriptors)
    		config->superspeed = true;
    	if (!config->superspeed_plus && function->ssp_descriptors)
    		config->superspeed_plus = true;
    
    done:
    	if (value)
    		DBG(config->cdev, "adding '%s'/%p --> %d\n",
    				function->name, function, value);
    	return value;
    }

## 小结 ##

到此已分析完usb\_udc、usb\_gadget\_driver的绑定过程，及usb\_function的匹配过程。。下一节将详细介绍usb\_function的注册过程及相关函数的分析。另外一个方面，udc控制器已将DP上拉，udc endpoint0已使能，静待插入host完成枚举