gadget驱动框架（四）

偏执的太偏执、 2022-10-23 00:51 369阅读 0赞

# gadget驱动框架（四） #

本文基于linux5.4.23分析usb\_function\_driver、usb\_function\_instance、usn\_function的创建、注册过程。

## 创建/注册usb\_function\_driver ##

源码：drivers/usb/gadget/function/f\_acm.c

DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func);

## 创建usb\_function\_instance ##

源码：drivers/usb/gadget/function/f\_acm.c

static void acm_free_instance(struct usb_function_instance *fi)
    {
    	struct f_serial_opts *opts;
    
    	opts = container_of(fi, struct f_serial_opts, func_inst);
    	gserial_free_line(opts->port_num);
    	kfree(opts);
    }
    
    static struct usb_function_instance *acm_alloc_instance(void)
    {
    	struct f_serial_opts *opts;
    	int ret;
    
    	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
    	if (!opts)
    		return ERR_PTR(-ENOMEM);
    	
    	//初始化free_func_inst
    	opts->func_inst.free_func_inst = acm_free_instance;
    	//注册tty_driver，源码：drivers/usb/gadget/function/u_serial.c
    	ret = gserial_alloc_line(&opts->port_num);
    	if (ret) {
    		kfree(opts);
    		return ERR_PTR(ret);
    	}
    	config_group_init_type_name(&opts->func_inst.group, "",
    			&acm_func_type);
    	return &opts->func_inst;
    }

## 创建usb\_function ##

源码：drivers/usb/gadget/function/f\_acm.c

static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
    {
    	struct f_serial_opts *opts;
    	struct f_acm *acm;
    
    	acm = kzalloc(sizeof(*acm), GFP_KERNEL);
    	if (!acm)
    		return ERR_PTR(-ENOMEM);
    
    	spin_lock_init(&acm->lock);
    
    	acm->port.connect = acm_connect;
    	acm->port.disconnect = acm_disconnect;
    	acm->port.send_break = acm_send_break;
    
        //初始化usb_function
    	acm->port.func.name = "acm";
    	acm->port.func.strings = acm_strings;
    	/* descriptors are per-instance copies */
    	acm->port.func.bind = acm_bind;
    	acm->port.func.set_alt = acm_set_alt;
    	acm->port.func.setup = acm_setup;
    	acm->port.func.disable = acm_disable;
    
    	opts = container_of(fi, struct f_serial_opts, func_inst);
    	acm->port_num = opts->port_num;
    	acm->port.func.unbind = acm_unbind;
    	acm->port.func.free_func = acm_free_func;
    
    	return &acm->port.func;
    }

### usb\_function的bind与unbind ###

源码：drivers/usb/gadget/function/f\_acm.c

/*-------------------------------------------------------------------------*/
    
    /* ACM function driver setup/binding */
    static int
    acm_bind(struct usb_configuration *c, struct usb_function *f)
    {
    	struct usb_composite_dev *cdev = c->cdev;
    	struct f_acm		*acm = func_to_acm(f);
    	struct usb_string	*us;
    	int			status;
    	struct usb_ep		*ep;
    
    	/* REVISIT might want instance-specific strings to help
    	 * distinguish instances ...
    	 */
    
    	/* maybe allocate device-global string IDs, and patch descriptors */
    	us = usb_gstrings_attach(cdev, acm_strings,
    			ARRAY_SIZE(acm_string_defs));
    	if (IS_ERR(us))
    		return PTR_ERR(us);
    	acm_control_interface_desc.iInterface = us[ACM_CTRL_IDX].id;
    	acm_data_interface_desc.iInterface = us[ACM_DATA_IDX].id;
    	acm_iad_descriptor.iFunction = us[ACM_IAD_IDX].id;
    
    	/* allocate instance-specific interface IDs, and patch descriptors */
    	status = usb_interface_id(c, f);
    	if (status < 0)
    		goto fail;
    	acm->ctrl_id = status;
    	acm_iad_descriptor.bFirstInterface = status;
    
    	acm_control_interface_desc.bInterfaceNumber = status;
    	acm_union_desc .bMasterInterface0 = status;
    
    	status = usb_interface_id(c, f);
    	if (status < 0)
    		goto fail;
    	acm->data_id = status;
    
    	acm_data_interface_desc.bInterfaceNumber = status;
    	acm_union_desc.bSlaveInterface0 = status;
    	acm_call_mgmt_descriptor.bDataInterface = status;
    
    	status = -ENODEV;
    
    	/* allocate instance-specific endpoints */
    	//初始化in_desc
    	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_in_desc);
    	if (!ep)
    		goto fail;
    	acm->port.in = ep;
    
        //初始化out_desc
    	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_out_desc);
    	if (!ep)
    		goto fail;
    	acm->port.out = ep;
    
        //初始化notify_desc
    	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_notify_desc);
    	if (!ep)
    		goto fail;
    	acm->notify = ep;
    
    	/* allocate notification */
    	//初始化notify_req的节点
    	acm->notify_req = gs_alloc_req(ep,
    			sizeof(struct usb_cdc_notification) + 2,
    			GFP_KERNEL);
    	if (!acm->notify_req)
    		goto fail;
    
    	acm->notify_req->complete = acm_cdc_notify_complete;
    	acm->notify_req->context = acm;
    
    	/* support all relevant hardware speeds... we expect that when
    	 * hardware is dual speed, all bulk-capable endpoints work at
    	 * both speeds
    	 */
    	acm_hs_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
    	acm_hs_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
    	acm_hs_notify_desc.bEndpointAddress =
    		acm_fs_notify_desc.bEndpointAddress;
    
    	acm_ss_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
    	acm_ss_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
    
    	status = usb_assign_descriptors(f, acm_fs_function, acm_hs_function,
    			acm_ss_function, NULL);
    	if (status)
    		goto fail;
    
    	dev_dbg(&cdev->gadget->dev,
    		"acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
    		acm->port_num,
    		gadget_is_superspeed(c->cdev->gadget) ? "super" :
    		gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
    		acm->port.in->name, acm->port.out->name,
    		acm->notify->name);
    	return 0;
    
    fail:
    	if (acm->notify_req)
    		gs_free_req(acm->notify, acm->notify_req);
    
    	ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
    
    	return status;
    }

static void acm_unbind(struct usb_configuration *c, struct usb_function *f)
    {
    	struct f_acm		*acm = func_to_acm(f);
    
    	acm_string_defs[0].id = 0;
    	usb_free_all_descriptors(f);
    	if (acm->notify_req)
    		gs_free_req(acm->notify, acm->notify_req);
    }

### usb\_function的set\_alt ###

源码：drivers/usb/gadget/function/f\_acm.c

static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
    {
    	struct f_acm		*acm = func_to_acm(f);
    	struct usb_composite_dev *cdev = f->config->cdev;
    
    	/* we know alt == 0, so this is an activation or a reset */
    
    	if (intf == acm->ctrl_id) {
    		dev_vdbg(&cdev->gadget->dev,
    				"reset acm control interface %d\n", intf);
    		usb_ep_disable(acm->notify);
    
    		if (!acm->notify->desc)
    			if (config_ep_by_speed(cdev->gadget, f, acm->notify))
    				return -EINVAL;
    
            //使能notify endpoint
    		usb_ep_enable(acm->notify);
    
    	} else if (intf == acm->data_id) {
    		if (acm->notify->enabled) {
    			dev_dbg(&cdev->gadget->dev,
    				"reset acm ttyGS%d\n", acm->port_num);
    			gserial_disconnect(&acm->port);
    		}
    		if (!acm->port.in->desc || !acm->port.out->desc) {
    			dev_dbg(&cdev->gadget->dev,
    				"activate acm ttyGS%d\n", acm->port_num);
    			if (config_ep_by_speed(cdev->gadget, f,
    					       acm->port.in) ||
    			    config_ep_by_speed(cdev->gadget, f,
    					       acm->port.out)) {
    				acm->port.in->desc = NULL;
    				acm->port.out->desc = NULL;
    				return -EINVAL;
    			}
    		}
    		gserial_connect(&acm->port, acm->port_num);
    
    	} else
    		return -EINVAL;
    
    	return 0;
    }

### usb\_function的setup ###

该函数将会在枚举的过程中调用，具体在composite.c中的setup函数回调。

static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
    {
    	struct f_acm		*acm = func_to_acm(f);
    	struct usb_composite_dev *cdev = f->config->cdev;
    	struct usb_request	*req = cdev->req;
    	int			value = -EOPNOTSUPP;
    	u16			w_index = le16_to_cpu(ctrl->wIndex);
    	u16			w_value = le16_to_cpu(ctrl->wValue);
    	u16			w_length = le16_to_cpu(ctrl->wLength);
    
    	/* composite driver infrastructure handles everything except
    	 * CDC class messages; interface activation uses set_alt().
    	 *
    	 * Note CDC spec table 4 lists the ACM request profile.  It requires
    	 * encapsulated command support ... we don't handle any, and respond
    	 * to them by stalling.  Options include get/set/clear comm features
    	 * (not that useful) and SEND_BREAK.
    	 */
    	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
    
    	/* SET_LINE_CODING ... just read and save what the host sends */
    	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
    			| USB_CDC_REQ_SET_LINE_CODING:
    		if (w_length != sizeof(struct usb_cdc_line_coding)
    				|| w_index != acm->ctrl_id)
    			goto invalid;
    
    		value = w_length;
    		cdev->gadget->ep0->driver_data = acm;
    		req->complete = acm_complete_set_line_coding;
    		break;
    
    	/* GET_LINE_CODING ... return what host sent, or initial value */
    	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
    			| USB_CDC_REQ_GET_LINE_CODING:
    		if (w_index != acm->ctrl_id)
    			goto invalid;
    
    		value = min_t(unsigned, w_length,
    				sizeof(struct usb_cdc_line_coding));
    		memcpy(req->buf, &acm->port_line_coding, value);
    		break;
    
    	/* SET_CONTROL_LINE_STATE ... save what the host sent */
    	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
    			| USB_CDC_REQ_SET_CONTROL_LINE_STATE:
    		if (w_index != acm->ctrl_id)
    			goto invalid;
    
    		value = 0;
    
    		/* FIXME we should not allow data to flow until the
    		 * host sets the ACM_CTRL_DTR bit; and when it clears
    		 * that bit, we should return to that no-flow state.
    		 */
    		acm->port_handshake_bits = w_value;
    		break;
    
    	default:
    invalid:
    		dev_vdbg(&cdev->gadget->dev,
    			 "invalid control req%02x.%02x v%04x i%04x l%d\n",
    			 ctrl->bRequestType, ctrl->bRequest,
    			 w_value, w_index, w_length);
    	}
    
    	/* respond with data transfer or status phase? */
    	if (value >= 0) {
    		dev_dbg(&cdev->gadget->dev,
    			"acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
    			acm->port_num, ctrl->bRequestType, ctrl->bRequest,
    			w_value, w_index, w_length);
    		req->zero = 0;
    		req->length = value;
    		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
    		if (value < 0)
    			ERROR(cdev, "acm response on ttyGS%d, err %d\n",
    					acm->port_num, value);
    	}
    
    	/* device either stalls (value < 0) or reports success */
    	return value;
    }

## 小结 ##

本节主要介绍了usb\_function的注册、创建的过程，相关函数的调用过程需结合上一节的分析。到此整个gadget usb udc驱动前期初始化册过程已分析完成，后面将分析udc的枚举过程。