// SPDX-License-Identifier: GPL-2.0+/* * f_subset.c -- "CDC Subset" Ethernet link function driver * * Copyright (C) 2003-2005,2008 David Brownell * Copyright (C) 2008 Nokia Corporation */ #include <linux/cleanup.h>#include <linux/slab.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/device.h>#include <linux/etherdevice.h> #include "u_ether.h"#include "u_ether_configfs.h"#include "u_gether.h" /* * This function packages a simple "CDC Subset" Ethernet port with no real * control mechanisms; just raw data transfer over two bulk endpoints. * The data transfer model is exactly that of CDC Ethernet, which is * why we call it the "CDC Subset". * * Because it's not standardized, this has some interoperability issues. * They mostly relate to driver binding, since the data transfer model is * so simple (CDC Ethernet).  The original versions of this protocol used * specific product/vendor IDs:  byteswapped IDs for Digital Equipment's * SA-1100 "Itsy" board, which could run Linux 2.4 kernels and supported * daughtercards with USB peripheral connectors.  (It was used more often * with other boards, using the Itsy identifiers.)  Linux hosts recognized * this with CONFIG_USB_ARMLINUX; these devices have only one configuration * and one interface. * * At some point, MCCI defined a (nonconformant) CDC MDLM variant called * "SAFE", which happens to have a mode which is identical to the "CDC * Subset" in terms of data transfer and lack of control model.  This was * adopted by later Sharp Zaurus models, and by some other software which * Linux hosts recognize with CONFIG_USB_NET_ZAURUS. * * Because Microsoft's RNDIS drivers are far from robust, we added a few * descriptors to the CDC Subset code, making this code look like a SAFE * implementation.  This lets you use MCCI's host side MS-Windows drivers * if you get fed up with RNDIS.  It also makes it easier for composite * drivers to work, since they can use class based binding instead of * caring about specific product and vendor IDs. */ struct f_gether {	struct gether			port; 	char				ethaddr[14];}; static inline struct f_gether *func_to_geth(struct usb_function *f){	return container_of(f, struct f_gether, port.func);} /*-------------------------------------------------------------------------*/ /* * "Simple" CDC-subset option is a simple vendor-neutral model that most * full speed controllers can handle:  one interface, two bulk endpoints. * To assist host side drivers, we fancy it up a bit, and add descriptors so * some host side drivers will understand it as a "SAFE" variant. * * "SAFE" loosely follows CDC WMC MDLM, violating the spec in various ways. * Data endpoints live in the control interface, there's no data interface. * And it's not used to talk to a cell phone radio. */ /* interface descriptor: */ static struct usb_interface_descriptor subset_data_intf = {	.bLength =		sizeof subset_data_intf,	.bDescriptorType =	USB_DT_INTERFACE, 	/* .bInterfaceNumber = DYNAMIC */	.bAlternateSetting =	0,	.bNumEndpoints =	2,	.bInterfaceClass =      USB_CLASS_COMM,	.bInterfaceSubClass =	USB_CDC_SUBCLASS_MDLM,	.bInterfaceProtocol =	0,	/* .iInterface = DYNAMIC */}; static struct usb_cdc_header_desc mdlm_header_desc = {	.bLength =		sizeof mdlm_header_desc,	.bDescriptorType =	USB_DT_CS_INTERFACE,	.bDescriptorSubType =	USB_CDC_HEADER_TYPE, 	.bcdCDC =		cpu_to_le16(0x0110),}; static struct usb_cdc_mdlm_desc mdlm_desc = {	.bLength =		sizeof mdlm_desc,	.bDescriptorType =	USB_DT_CS_INTERFACE,	.bDescriptorSubType =	USB_CDC_MDLM_TYPE, 	.bcdVersion =		cpu_to_le16(0x0100),	.bGUID = {		0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,		0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,	},}; /* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we * can't really use its struct.  All we do here is say that we're using * the submode of "SAFE" which directly matches the CDC Subset. */static u8 mdlm_detail_desc[] = {	6,	USB_DT_CS_INTERFACE,	USB_CDC_MDLM_DETAIL_TYPE, 	0,	/* "SAFE" */	0,	/* network control capabilities (none) */	0,	/* network data capabilities ("raw" encapsulation) */}; static struct usb_cdc_ether_desc ether_desc = {	.bLength =		sizeof ether_desc,	.bDescriptorType =	USB_DT_CS_INTERFACE,	.bDescriptorSubType =	USB_CDC_ETHERNET_TYPE, 	/* this descriptor actually adds value, surprise! */	/* .iMACAddress = DYNAMIC */	.bmEthernetStatistics =	cpu_to_le32(0), /* no statistics */	.wMaxSegmentSize =	cpu_to_le16(ETH_FRAME_LEN),	.wNumberMCFilters =	cpu_to_le16(0),	.bNumberPowerFilters =	0,}; /* full speed support: */ static struct usb_endpoint_descriptor fs_subset_in_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bEndpointAddress =	USB_DIR_IN,	.bmAttributes =		USB_ENDPOINT_XFER_BULK,}; static struct usb_endpoint_descriptor fs_subset_out_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bEndpointAddress =	USB_DIR_OUT,	.bmAttributes =		USB_ENDPOINT_XFER_BULK,}; static struct usb_descriptor_header *fs_eth_function[] = {	(struct usb_descriptor_header *) &subset_data_intf,	(struct usb_descriptor_header *) &mdlm_header_desc,	(struct usb_descriptor_header *) &mdlm_desc,	(struct usb_descriptor_header *) &mdlm_detail_desc,	(struct usb_descriptor_header *) &ether_desc,	(struct usb_descriptor_header *) &fs_subset_in_desc,	(struct usb_descriptor_header *) &fs_subset_out_desc,	NULL,}; /* high speed support: */ static struct usb_endpoint_descriptor hs_subset_in_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,	.wMaxPacketSize =	cpu_to_le16(512),}; static struct usb_endpoint_descriptor hs_subset_out_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,	.wMaxPacketSize =	cpu_to_le16(512),}; static struct usb_descriptor_header *hs_eth_function[] = {	(struct usb_descriptor_header *) &subset_data_intf,	(struct usb_descriptor_header *) &mdlm_header_desc,	(struct usb_descriptor_header *) &mdlm_desc,	(struct usb_descriptor_header *) &mdlm_detail_desc,	(struct usb_descriptor_header *) &ether_desc,	(struct usb_descriptor_header *) &hs_subset_in_desc,	(struct usb_descriptor_header *) &hs_subset_out_desc,	NULL,}; /* super speed support: */ static struct usb_endpoint_descriptor ss_subset_in_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,	.wMaxPacketSize =	cpu_to_le16(1024),}; static struct usb_endpoint_descriptor ss_subset_out_desc = {	.bLength =		USB_DT_ENDPOINT_SIZE,	.bDescriptorType =	USB_DT_ENDPOINT, 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,	.wMaxPacketSize =	cpu_to_le16(1024),}; static struct usb_ss_ep_comp_descriptor ss_subset_bulk_comp_desc = {	.bLength =		sizeof ss_subset_bulk_comp_desc,	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP, 	/* the following 2 values can be tweaked if necessary */	/* .bMaxBurst =		0, */	/* .bmAttributes =	0, */}; static struct usb_descriptor_header *ss_eth_function[] = {	(struct usb_descriptor_header *) &subset_data_intf,	(struct usb_descriptor_header *) &mdlm_header_desc,	(struct usb_descriptor_header *) &mdlm_desc,	(struct usb_descriptor_header *) &mdlm_detail_desc,	(struct usb_descriptor_header *) &ether_desc,	(struct usb_descriptor_header *) &ss_subset_in_desc,	(struct usb_descriptor_header *) &ss_subset_bulk_comp_desc,	(struct usb_descriptor_header *) &ss_subset_out_desc,	(struct usb_descriptor_header *) &ss_subset_bulk_comp_desc,	NULL,}; /* string descriptors: */ static struct usb_string geth_string_defs[] = {	[0].s = "CDC Ethernet Subset/SAFE",	[1].s = "",	{  } /* end of list */}; static struct usb_gadget_strings geth_string_table = {	.language =		0x0409,	/* en-us */	.strings =		geth_string_defs,}; static struct usb_gadget_strings *geth_strings[] = {	&geth_string_table,	NULL,}; /*-------------------------------------------------------------------------*/ static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt){	struct f_gether		*geth = func_to_geth(f);	struct usb_composite_dev *cdev = f->config->cdev;	struct net_device	*net; 	/* we know alt == 0, so this is an activation or a reset */ 	if (geth->port.in_ep->enabled) {		DBG(cdev, "reset cdc subset\n");		gether_disconnect(&geth->port);	} 	DBG(cdev, "init + activate cdc subset\n");	if (config_ep_by_speed(cdev->gadget, f, geth->port.in_ep) ||	    config_ep_by_speed(cdev->gadget, f, geth->port.out_ep)) {		geth->port.in_ep->desc = NULL;		geth->port.out_ep->desc = NULL;		return -EINVAL;	} 	net = gether_connect(&geth->port);	return PTR_ERR_OR_ZERO(net);} static void geth_disable(struct usb_function *f){	struct f_gether	*geth = func_to_geth(f);	struct usb_composite_dev *cdev = f->config->cdev; 	DBG(cdev, "net deactivated\n");	gether_disconnect(&geth->port);} /*-------------------------------------------------------------------------*/ /* serial function driver setup/binding */ static intgeth_bind(struct usb_configuration *c, struct usb_function *f){	struct usb_composite_dev *cdev = c->cdev;	struct f_gether		*geth = func_to_geth(f);	struct usb_string	*us;	int			status;	struct usb_ep		*ep; 	struct f_gether_opts	*gether_opts;	struct net_device	*net __free(detach_gadget) = NULL; 	gether_opts = container_of(f->fi, struct f_gether_opts, func_inst); 	scoped_guard(mutex, &gether_opts->lock)		if (gether_opts->bind_count == 0 && !gether_opts->bound) {			if (!device_is_registered(&gether_opts->net->dev)) {				gether_set_gadget(gether_opts->net, cdev->gadget);				status = gether_register_netdev(gether_opts->net);			} else				status = gether_attach_gadget(gether_opts->net, cdev->gadget); 			if (status)				return status;			net = gether_opts->net;		} 	us = usb_gstrings_attach(cdev, geth_strings,				 ARRAY_SIZE(geth_string_defs));	if (IS_ERR(us))		return PTR_ERR(us); 	subset_data_intf.iInterface = us[0].id;	ether_desc.iMACAddress = us[1].id; 	/* allocate instance-specific interface IDs */	status = usb_interface_id(c, f);	if (status < 0)		return status;	subset_data_intf.bInterfaceNumber = status; 	/* allocate instance-specific endpoints */	ep = usb_ep_autoconfig(cdev->gadget, &fs_subset_in_desc);	if (!ep)		return -ENODEV;	geth->port.in_ep = ep; 	ep = usb_ep_autoconfig(cdev->gadget, &fs_subset_out_desc);	if (!ep)		return -ENODEV;	geth->port.out_ep = ep; 	/* support all relevant hardware speeds... we expect that when	 * hardware is dual speed, all bulk-capable endpoints work at	 * both speeds	 */	hs_subset_in_desc.bEndpointAddress = fs_subset_in_desc.bEndpointAddress;	hs_subset_out_desc.bEndpointAddress =		fs_subset_out_desc.bEndpointAddress; 	ss_subset_in_desc.bEndpointAddress = fs_subset_in_desc.bEndpointAddress;	ss_subset_out_desc.bEndpointAddress =		fs_subset_out_desc.bEndpointAddress; 	status = usb_assign_descriptors(f, fs_eth_function, hs_eth_function,			ss_eth_function, ss_eth_function);	if (status)		return status; 	/* NOTE:  all that is done without knowing or caring about	 * the network link ... which is unavailable to this code	 * until we're activated via set_alt().	 */ 	gether_opts->bind_count++;	retain_and_null_ptr(net); 	DBG(cdev, "CDC Subset: IN/%s OUT/%s\n",			geth->port.in_ep->name, geth->port.out_ep->name);	return 0;} static inline struct f_gether_opts *to_f_gether_opts(struct config_item *item){	return container_of(to_config_group(item), struct f_gether_opts,			    func_inst.group);} /* f_gether_item_ops */USB_ETHERNET_CONFIGFS_ITEM(gether); /* f_gether_opts_dev_addr */USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(gether); /* f_gether_opts_host_addr */USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(gether); /* f_gether_opts_qmult */USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(gether); /* f_gether_opts_ifname */USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(gether); static struct configfs_attribute *gether_attrs[] = {	&gether_opts_attr_dev_addr,	&gether_opts_attr_host_addr,	&gether_opts_attr_qmult,	&gether_opts_attr_ifname,	NULL,}; static const struct config_item_type gether_func_type = {	.ct_item_ops	= &gether_item_ops,	.ct_attrs	= gether_attrs,	.ct_owner	= THIS_MODULE,}; static void geth_free_inst(struct usb_function_instance *f){	struct f_gether_opts *opts; 	opts = container_of(f, struct f_gether_opts, func_inst);	if (device_is_registered(&opts->net->dev))		gether_cleanup(netdev_priv(opts->net));	else		free_netdev(opts->net);	kfree(opts);} static struct usb_function_instance *geth_alloc_inst(void){	struct f_gether_opts *opts; 	opts = kzalloc_obj(*opts);	if (!opts)		return ERR_PTR(-ENOMEM);	mutex_init(&opts->lock);	opts->func_inst.free_func_inst = geth_free_inst;	opts->net = gether_setup_default();	if (IS_ERR(opts->net)) {		struct net_device *net = opts->net;		kfree(opts);		return ERR_CAST(net);	} 	config_group_init_type_name(&opts->func_inst.group, "",				    &gether_func_type); 	return &opts->func_inst;} static void geth_free(struct usb_function *f){	struct f_gether *eth;	struct f_gether_opts *opts; 	opts = container_of(f->fi, struct f_gether_opts, func_inst); 	eth = func_to_geth(f);	scoped_guard(mutex, &opts->lock)		opts->refcnt--;	kfree(eth);} static void geth_unbind(struct usb_configuration *c, struct usb_function *f){	struct f_gether_opts *opts; 	opts = container_of(f->fi, struct f_gether_opts, func_inst); 	geth_string_defs[0].id = 0;	usb_free_all_descriptors(f); 	opts->bind_count--;	if (opts->bind_count == 0 && !opts->bound)		gether_detach_gadget(opts->net);} static struct usb_function *geth_alloc(struct usb_function_instance *fi){	struct f_gether	*geth;	struct f_gether_opts *opts;	int status; 	/* allocate and initialize one new instance */	geth = kzalloc_obj(*geth);	if (!geth)		return ERR_PTR(-ENOMEM); 	opts = container_of(fi, struct f_gether_opts, func_inst); 	mutex_lock(&opts->lock);	opts->refcnt++;	/* export host's Ethernet address in CDC format */	status = gether_get_host_addr_cdc(opts->net, geth->ethaddr,					  sizeof(geth->ethaddr));	if (status < 12) {		kfree(geth);		mutex_unlock(&opts->lock);		return ERR_PTR(-EINVAL);	}	geth_string_defs[1].s = geth->ethaddr; 	geth->port.ioport = netdev_priv(opts->net);	mutex_unlock(&opts->lock);	geth->port.cdc_filter = DEFAULT_FILTER; 	geth->port.func.name = "cdc_subset";	geth->port.func.bind = geth_bind;

Lines 1–500 of 512. Load more