gadget驱动框架（二）

快来打我* 2022-10-23 00:50 11阅读 0赞

# gadget驱动框架（二） #

## usb\_composite\_driver的创建于注册 ##

源码：drivers/usb/legacy/serial.c

//创建usb_composite_driver
    static struct usb_composite_driver gserial_driver = {
    	.name		= "g_serial",
    	.dev		= &device_desc,
    	.strings	= dev_strings,
    	.max_speed	= USB_SPEED_SUPER,
    	.bind		= gs_bind,
    	.unbind		= gs_unbind,
    };
    
    static int __init init(void)
    {
    	/* We *could* export two configs; that'd be much cleaner...
    	 * but neither of these product IDs was defined that way.
    	 */bConfigurationValue、class、pid等
    	 //初始化
    	if (use_acm) {
    		serial_config_driver.label = "CDC ACM config";
    		serial_config_driver.bConfigurationValue = 2;
    		device_desc.bDeviceClass = USB_CLASS_COMM;
    		device_desc.idProduct =
    				cpu_to_le16(GS_CDC_PRODUCT_ID);
    	} else if (use_obex) {
    		serial_config_driver.label = "CDC OBEX config";
    		serial_config_driver.bConfigurationValue = 3;
    		device_desc.bDeviceClass = USB_CLASS_COMM;
    		device_desc.idProduct =
    			cpu_to_le16(GS_CDC_OBEX_PRODUCT_ID);
    	} else {
    		serial_config_driver.label = "Generic Serial config";
    		serial_config_driver.bConfigurationValue = 1;
    		device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
    		device_desc.idProduct =
    				cpu_to_le16(GS_PRODUCT_ID);
    	}
    	strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
    
        //注册usb_composite_driver与usb_composite_dev
    	return usb_composite_probe(&gserial_driver);
    }
    module_init(init);
    
    static void __exit cleanup(void)
    {
    	usb_composite_unregister(&gserial_driver);
    }
    module_exit(cleanup);

## usb\_gadget\_driver的创建与注册 ##

//创建usb_gadget_driver
    static const struct usb_gadget_driver composite_driver_template = {
    	.bind		= composite_bind,
    	.unbind		= composite_unbind,
    
    	.setup		= composite_setup,
    	.reset		= composite_disconnect,
    	.disconnect	= composite_disconnect,
    
    	.suspend	= composite_suspend,
    	.resume		= composite_resume,
    
    	.driver	= {
    		.owner		= THIS_MODULE,
    	},
    };
    
    int usb_composite_probe(struct usb_composite_driver *driver)
    {
    	struct usb_gadget_driver *gadget_driver;
    
    	if (!driver || !driver->dev || !driver->bind)
    		return -EINVAL;
    
    	if (!driver->name)
    		driver->name = "composite";
    
    	driver->gadget_driver = composite_driver_template;
    	gadget_driver = &driver->gadget_driver;
    
    	gadget_driver->function =  (char *) driver->name;
    	gadget_driver->driver.name = driver->name;
    	gadget_driver->max_speed = driver->max_speed;
    
        //注册usb_gadget_driver
    	return usb_gadget_probe_driver(gadget_driver);
    }
    EXPORT_SYMBOL_GPL(usb_composite_probe);

//注册usb_gadget_driver
    int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
    {
    	struct usb_udc		*udc = NULL;
    	int			ret = -ENODEV;
    
    	if (!driver || !driver->bind || !driver->setup)
    		return -EINVAL;
    
    	mutex_lock(&udc_lock);
    	if (driver->udc_name) {
    		list_for_each_entry(udc, &udc_list, list) {
    			ret = strcmp(driver->udc_name, dev_name(&udc->dev));
    			if (!ret)
    				break;
    		}
    		if (ret)
    			ret = -ENODEV;
    		else if (udc->driver)
    			ret = -EBUSY;
    		else
    			goto found;
    	} else {
    		list_for_each_entry(udc, &udc_list, list) {
    			/* For now we take the first one */
    			if (!udc->driver)
    				goto found;
    		}
    	}
    
        //无udc设备，则将usb_gadget_driver添加到gadget_driver_pending_list链表
    	if (!driver->match_existing_only) {
    		list_add_tail(&driver->pending, &gadget_driver_pending_list);
    		pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n",
    			driver->function);
    		ret = 0;
    	}
    
    	mutex_unlock(&udc_lock);
    	return ret;
    found:
        //udc设备与usb_gadget_driver绑定
    	ret = udc_bind_to_driver(udc, driver);
    	mutex_unlock(&udc_lock);
    	return ret;
    }

## usb\_gadget的创建及注册 ##

源码：linux4.19.123-drivers/usb/gadget/udc/s3c2410\_udc.c

static const struct usb_ep_ops s3c2410_ep_ops = {
    	.enable		= s3c2410_udc_ep_enable,
    	.disable	= s3c2410_udc_ep_disable,
    
    	.alloc_request	= s3c2410_udc_alloc_request,
    	.free_request	= s3c2410_udc_free_request,
    
    	.queue		= s3c2410_udc_queue,
    	.dequeue	= s3c2410_udc_dequeue,
    
    	.set_halt	= s3c2410_udc_set_halt,
    };
    
    static const struct usb_gadget_ops s3c2410_ops = {
    	.get_frame		= s3c2410_udc_get_frame,
    	.wakeup			= s3c2410_udc_wakeup,
    	.set_selfpowered	= s3c2410_udc_set_selfpowered,
    	.pullup			= s3c2410_udc_pullup,
    	.vbus_session		= s3c2410_udc_vbus_session,
    	.vbus_draw		= s3c2410_vbus_draw,
    	.udc_start		= s3c2410_udc_start,
    	.udc_stop		= s3c2410_udc_stop,
    };
    
    /*---------------------------------------------------------------------------*/
    static struct s3c2410_udc memory = {
        //usb_gadget初始化
    	.gadget = {
    		.ops		= &s3c2410_ops,
    		.ep0		= &memory.ep[0].ep,
    		.name		= gadget_name,
    		.dev = {
    			.init_name	= "gadget",
    		},
    	},
    
    	/* control endpoint */
    	.ep[0] = {
    		.num		= 0,
    		.ep = {
    			.name		= ep0name,
    			.ops		= &s3c2410_ep_ops,
    			.maxpacket	= EP0_FIFO_SIZE,
    			.caps		= USB_EP_CAPS(USB_EP_CAPS_TYPE_CONTROL,
    						USB_EP_CAPS_DIR_ALL),
    		},
    		.dev		= &memory,
    	},
    
    	/* first group of endpoints */
    	.ep[1] = {
    		.num		= 1,
    		.ep = {
    			.name		= "ep1-bulk",
    			.ops		= &s3c2410_ep_ops,
    			.maxpacket	= EP_FIFO_SIZE,
    			.caps		= USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK,
    						USB_EP_CAPS_DIR_ALL),
    		},
    		.dev		= &memory,
    		.fifo_size	= EP_FIFO_SIZE,
    		.bEndpointAddress = 1,
    		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
    	},
    	.ep[2] = {
    		.num		= 2,
    		.ep = {
    			.name		= "ep2-bulk",
    			.ops		= &s3c2410_ep_ops,
    			.maxpacket	= EP_FIFO_SIZE,
    			.caps		= USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK,
    						USB_EP_CAPS_DIR_ALL),
    		},
    		.dev		= &memory,
    		.fifo_size	= EP_FIFO_SIZE,
    		.bEndpointAddress = 2,
    		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
    	},
    	.ep[3] = {
    		.num		= 3,
    		.ep = {
    			.name		= "ep3-bulk",
    			.ops		= &s3c2410_ep_ops,
    			.maxpacket	= EP_FIFO_SIZE,
    			.caps		= USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK,
    						USB_EP_CAPS_DIR_ALL),
    		},
    		.dev		= &memory,
    		.fifo_size	= EP_FIFO_SIZE,
    		.bEndpointAddress = 3,
    		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
    	},
    	.ep[4] = {
    		.num		= 4,
    		.ep = {
    			.name		= "ep4-bulk",
    			.ops		= &s3c2410_ep_ops,
    			.maxpacket	= EP_FIFO_SIZE,
    			.caps		= USB_EP_CAPS(USB_EP_CAPS_TYPE_BULK,
    						USB_EP_CAPS_DIR_ALL),
    		},
    		.dev		= &memory,
    		.fifo_size	= EP_FIFO_SIZE,
    		.bEndpointAddress = 4,
    		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
    	}
    
    };
    /*
     *	probe - binds to the platform device
     */
    static int s3c2410_udc_probe(struct platform_device *pdev)
    {
    	struct s3c2410_udc *udc = &memory;
    	struct device *dev = &pdev->dev;
    	int retval;
    	int irq;
    
    	dev_dbg(dev, "%s()\n", __func__);
    
        ......
        
        //创建/注册udc，注册usb_gadget
    	retval = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
    	if (retval)
    		goto err_add_udc;
    
        ......
    
    	return 0;
    
    err_add_udc:
    	if (udc_info && !udc_info->udc_command &&
    			gpio_is_valid(udc_info->pullup_pin))
    		gpio_free(udc_info->pullup_pin);
    err_vbus_irq:
    	if (udc_info && udc_info->vbus_pin > 0)
    		free_irq(gpio_to_irq(udc_info->vbus_pin), udc);
    err_gpio_claim:
    	if (udc_info && udc_info->vbus_pin > 0)
    		gpio_free(udc_info->vbus_pin);
    err_int:
    	free_irq(IRQ_USBD, udc);
    err_map:
    	iounmap(base_addr);
    err_mem:
    	release_mem_region(rsrc_start, rsrc_len);
    
    	return retval;
    }

## usb\_udc的创建及注册 ##

源码：linux-4.19.123-drivers/usb/gadget/udc/core.c

int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
    {
    	return usb_add_gadget_udc_release(parent, gadget, NULL);
    }
    EXPORT_SYMBOL_GPL(usb_add_gadget_udc);

/**
     * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
     * @parent: the parent device to this udc. Usually the controller driver's
     * device.
     * @gadget: the gadget to be added to the list.
     * @release: a gadget release function.
     *
     * Returns zero on success, negative errno otherwise.
     * Calls the gadget release function in the latter case.
     */
    int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
    		void (*release)(struct device *dev))
    {
    	struct usb_udc		*udc;
    	int			ret = -ENOMEM;
    
    	dev_set_name(&gadget->dev, "gadget");
    	INIT_WORK(&gadget->work, usb_gadget_state_work);
    	gadget->dev.parent = parent;
    
    	if (release)
    		gadget->dev.release = release;
    	else
    		gadget->dev.release = usb_udc_nop_release;
    
    	device_initialize(&gadget->dev);
    
        //创建usb_udc
    	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
    	if (!udc)
    		goto err_put_gadget;
    
    	device_initialize(&udc->dev);
    	udc->dev.release = usb_udc_release;
    	udc->dev.class = udc_class;
    	udc->dev.groups = usb_udc_attr_groups;
    	udc->dev.parent = parent;
    	ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
    	if (ret)
    		goto err_put_udc;
    
    	ret = device_add(&gadget->dev);
    	if (ret)
    		goto err_put_udc;
    
    	udc->gadget = gadget;
    	gadget->udc = udc;
    
    	mutex_lock(&udc_lock);
    	//将新创建的usb_udc添加到udc_list链表中
    	list_add_tail(&udc->list, &udc_list);
    
    	ret = device_add(&udc->dev);
    	if (ret)
    		goto err_unlist_udc;
    
    	usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
    	udc->vbus = true;
    
    	/* pick up one of pending gadget drivers */
    	ret = check_pending_gadget_drivers(udc);
    	if (ret)
    		goto err_del_udc;
    
    	mutex_unlock(&udc_lock);
    
    	return 0;
    
     err_del_udc:
    	device_del(&udc->dev);
    
     err_unlist_udc:
    	list_del(&udc->list);
    	mutex_unlock(&udc_lock);
    
    	device_del(&gadget->dev);
    
     err_put_udc:
    	put_device(&udc->dev);
    
     err_put_gadget:
    	put_device(&gadget->dev);
    	return ret;
    }

## 小结 ##

至此，已完成usb\_gadget\_driver、usb\_composite\_driver、usb\_gadget、usb\_udc等几个核心结构体的创建及注册。后面将介绍usb\_composite\_dev等的创建及注册，以及usb\_gadget\_driver与usb\_udc的绑定过程。