f_eem.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * f_eem.c -- USB CDC Ethernet (EEM) link function driver
  4 *
  5 * Copyright (C) 2003-2005,2008 David Brownell
  6 * Copyright (C) 2008 Nokia Corporation
  7 * Copyright (C) 2009 EF Johnson Technologies
  8 */
  9
 10#include <linux/cleanup.h>
 11#include <linux/kernel.h>
 12#include <linux/module.h>
 13#include <linux/device.h>
 14#include <linux/etherdevice.h>
 15#include <linux/crc32.h>
 16#include <linux/slab.h>
 17
 18#include "u_ether.h"
 19#include "u_ether_configfs.h"
 20#include "u_eem.h"
 21
 22#define EEM_HLEN 2
 23
 24/*
 25 * This function is a "CDC Ethernet Emulation Model" (CDC EEM)
 26 * Ethernet link.
 27 */
 28
 29struct f_eem {
 30	struct gether			port;
 31	u8				ctrl_id;
 32};
 33
 34struct in_context {
 35	struct sk_buff	*skb;
 36	struct usb_ep	*ep;
 37};
 38
 39static inline struct f_eem *func_to_eem(struct usb_function *f)
 40{
 41	return container_of(f, struct f_eem, port.func);
 42}
 43
 44/*-------------------------------------------------------------------------*/
 45
 46/* interface descriptor: */
 47
 48static struct usb_interface_descriptor eem_intf = {
 49	.bLength =		sizeof eem_intf,
 50	.bDescriptorType =	USB_DT_INTERFACE,
 51
 52	/* .bInterfaceNumber = DYNAMIC */
 53	.bNumEndpoints =	2,
 54	.bInterfaceClass =	USB_CLASS_COMM,
 55	.bInterfaceSubClass =	USB_CDC_SUBCLASS_EEM,
 56	.bInterfaceProtocol =	USB_CDC_PROTO_EEM,
 57	/* .iInterface = DYNAMIC */
 58};
 59
 60/* full speed support: */
 61
 62static struct usb_endpoint_descriptor eem_fs_in_desc = {
 63	.bLength =		USB_DT_ENDPOINT_SIZE,
 64	.bDescriptorType =	USB_DT_ENDPOINT,
 65
 66	.bEndpointAddress =	USB_DIR_IN,
 67	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 68};
 69
 70static struct usb_endpoint_descriptor eem_fs_out_desc = {
 71	.bLength =		USB_DT_ENDPOINT_SIZE,
 72	.bDescriptorType =	USB_DT_ENDPOINT,
 73
 74	.bEndpointAddress =	USB_DIR_OUT,
 75	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 76};
 77
 78static struct usb_descriptor_header *eem_fs_function[] = {
 79	/* CDC EEM control descriptors */
 80	(struct usb_descriptor_header *) &eem_intf,
 81	(struct usb_descriptor_header *) &eem_fs_in_desc,
 82	(struct usb_descriptor_header *) &eem_fs_out_desc,
 83	NULL,
 84};
 85
 86/* high speed support: */
 87
 88static struct usb_endpoint_descriptor eem_hs_in_desc = {
 89	.bLength =		USB_DT_ENDPOINT_SIZE,
 90	.bDescriptorType =	USB_DT_ENDPOINT,
 91
 92	.bEndpointAddress =	USB_DIR_IN,
 93	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
 94	.wMaxPacketSize =	cpu_to_le16(512),
 95};
 96
 97static struct usb_endpoint_descriptor eem_hs_out_desc = {
 98	.bLength =		USB_DT_ENDPOINT_SIZE,
 99	.bDescriptorType =	USB_DT_ENDPOINT,
100
101	.bEndpointAddress =	USB_DIR_OUT,
102	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
103	.wMaxPacketSize =	cpu_to_le16(512),
104};
105
106static struct usb_descriptor_header *eem_hs_function[] = {
107	/* CDC EEM control descriptors */
108	(struct usb_descriptor_header *) &eem_intf,
109	(struct usb_descriptor_header *) &eem_hs_in_desc,
110	(struct usb_descriptor_header *) &eem_hs_out_desc,
111	NULL,
112};
113
114/* super speed support: */
115
116static struct usb_endpoint_descriptor eem_ss_in_desc = {
117	.bLength =		USB_DT_ENDPOINT_SIZE,
118	.bDescriptorType =	USB_DT_ENDPOINT,
119
120	.bEndpointAddress =	USB_DIR_IN,
121	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
122	.wMaxPacketSize =	cpu_to_le16(1024),
123};
124
125static struct usb_endpoint_descriptor eem_ss_out_desc = {
126	.bLength =		USB_DT_ENDPOINT_SIZE,
127	.bDescriptorType =	USB_DT_ENDPOINT,
128
129	.bEndpointAddress =	USB_DIR_OUT,
130	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
131	.wMaxPacketSize =	cpu_to_le16(1024),
132};
133
134static struct usb_ss_ep_comp_descriptor eem_ss_bulk_comp_desc = {
135	.bLength =		sizeof eem_ss_bulk_comp_desc,
136	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
137
138	/* the following 2 values can be tweaked if necessary */
139	/* .bMaxBurst =		0, */
140	/* .bmAttributes =	0, */
141};
142
143static struct usb_descriptor_header *eem_ss_function[] = {
144	/* CDC EEM control descriptors */
145	(struct usb_descriptor_header *) &eem_intf,
146	(struct usb_descriptor_header *) &eem_ss_in_desc,
147	(struct usb_descriptor_header *) &eem_ss_bulk_comp_desc,
148	(struct usb_descriptor_header *) &eem_ss_out_desc,
149	(struct usb_descriptor_header *) &eem_ss_bulk_comp_desc,
150	NULL,
151};
152
153/* string descriptors: */
154
155static struct usb_string eem_string_defs[] = {
156	[0].s = "CDC Ethernet Emulation Model (EEM)",
157	{  } /* end of list */
158};
159
160static struct usb_gadget_strings eem_string_table = {
161	.language =		0x0409,	/* en-us */
162	.strings =		eem_string_defs,
163};
164
165static struct usb_gadget_strings *eem_strings[] = {
166	&eem_string_table,
167	NULL,
168};
169
170/*-------------------------------------------------------------------------*/
171
172static int eem_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
173{
174	struct usb_composite_dev *cdev = f->config->cdev;
175	u16			w_index = le16_to_cpu(ctrl->wIndex);
176	u16			w_value = le16_to_cpu(ctrl->wValue);
177	u16			w_length = le16_to_cpu(ctrl->wLength);
178
179	DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
180		ctrl->bRequestType, ctrl->bRequest,
181		w_value, w_index, w_length);
182
183	/* device either stalls (value < 0) or reports success */
184	return -EOPNOTSUPP;
185}
186
187
188static int eem_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
189{
190	struct f_eem		*eem = func_to_eem(f);
191	struct usb_composite_dev *cdev = f->config->cdev;
192	struct net_device	*net;
193
194	/* we know alt == 0, so this is an activation or a reset */
195	if (alt != 0)
196		goto fail;
197
198	if (intf == eem->ctrl_id) {
199		DBG(cdev, "reset eem\n");
200		gether_disconnect(&eem->port);
201
202		if (!eem->port.in_ep->desc || !eem->port.out_ep->desc) {
203			DBG(cdev, "init eem\n");
204			if (config_ep_by_speed(cdev->gadget, f,
205					       eem->port.in_ep) ||
206			    config_ep_by_speed(cdev->gadget, f,
207					       eem->port.out_ep)) {
208				eem->port.in_ep->desc = NULL;
209				eem->port.out_ep->desc = NULL;
210				goto fail;
211			}
212		}
213
214		/* zlps should not occur because zero-length EEM packets
215		 * will be inserted in those cases where they would occur
216		 */
217		eem->port.is_zlp_ok = 1;
218		eem->port.cdc_filter = DEFAULT_FILTER;
219		DBG(cdev, "activate eem\n");
220		net = gether_connect(&eem->port);
221		if (IS_ERR(net))
222			return PTR_ERR(net);
223	} else
224		goto fail;
225
226	return 0;
227fail:
228	return -EINVAL;
229}
230
231static void eem_disable(struct usb_function *f)
232{
233	struct f_eem		*eem = func_to_eem(f);
234	struct usb_composite_dev *cdev = f->config->cdev;
235
236	DBG(cdev, "eem deactivated\n");
237
238	if (eem->port.in_ep->enabled)
239		gether_disconnect(&eem->port);
240}
241
242/*-------------------------------------------------------------------------*/
243
244/* EEM function driver setup/binding */
245
246static int eem_bind(struct usb_configuration *c, struct usb_function *f)
247{
248	struct usb_composite_dev *cdev = c->cdev;
249	struct f_eem		*eem = func_to_eem(f);
250	struct usb_string	*us;
251	int			status;
252	struct usb_ep		*ep;
253
254	struct f_eem_opts	*eem_opts;
255	struct net_device	*net __free(detach_gadget) = NULL;
256
257	eem_opts = container_of(f->fi, struct f_eem_opts, func_inst);
258
259	scoped_guard(mutex, &eem_opts->lock)
260		if (eem_opts->bind_count == 0 && !eem_opts->bound) {
261			if (!device_is_registered(&eem_opts->net->dev)) {
262				gether_set_gadget(eem_opts->net, cdev->gadget);
263				status = gether_register_netdev(eem_opts->net);
264			} else
265				status = gether_attach_gadget(eem_opts->net, cdev->gadget);
266
267			if (status)
268				return status;
269			net = eem_opts->net;
270		}
271
272	us = usb_gstrings_attach(cdev, eem_strings,
273				 ARRAY_SIZE(eem_string_defs));
274	if (IS_ERR(us))
275		return PTR_ERR(us);
276	eem_intf.iInterface = us[0].id;
277
278	/* allocate instance-specific interface IDs */
279	status = usb_interface_id(c, f);
280	if (status < 0)
281		return status;
282	eem->ctrl_id = status;
283	eem_intf.bInterfaceNumber = status;
284
285	/* allocate instance-specific endpoints */
286	ep = usb_ep_autoconfig(cdev->gadget, &eem_fs_in_desc);
287	if (!ep)
288		return -ENODEV;
289	eem->port.in_ep = ep;
290
291	ep = usb_ep_autoconfig(cdev->gadget, &eem_fs_out_desc);
292	if (!ep)
293		return -ENODEV;
294	eem->port.out_ep = ep;
295
296	/* support all relevant hardware speeds... we expect that when
297	 * hardware is dual speed, all bulk-capable endpoints work at
298	 * both speeds
299	 */
300	eem_hs_in_desc.bEndpointAddress = eem_fs_in_desc.bEndpointAddress;
301	eem_hs_out_desc.bEndpointAddress = eem_fs_out_desc.bEndpointAddress;
302
303	eem_ss_in_desc.bEndpointAddress = eem_fs_in_desc.bEndpointAddress;
304	eem_ss_out_desc.bEndpointAddress = eem_fs_out_desc.bEndpointAddress;
305
306	status = usb_assign_descriptors(f, eem_fs_function, eem_hs_function,
307			eem_ss_function, eem_ss_function);
308	if (status)
309		return status;
310
311	eem_opts->bind_count++;
312	retain_and_null_ptr(net);
313
314	DBG(cdev, "CDC Ethernet (EEM): IN/%s OUT/%s\n",
315			eem->port.in_ep->name, eem->port.out_ep->name);
316	return 0;
317}
318
319static void eem_cmd_complete(struct usb_ep *ep, struct usb_request *req)
320{
321	struct in_context *ctx = req->context;
322
323	dev_kfree_skb_any(ctx->skb);
324	kfree(req->buf);
325	usb_ep_free_request(ctx->ep, req);
326	kfree(ctx);
327}
328
329/*
330 * Add the EEM header and ethernet checksum.
331 * We currently do not attempt to put multiple ethernet frames
332 * into a single USB transfer
333 */
334static struct sk_buff *eem_wrap(struct gether *port, struct sk_buff *skb)
335{
336	struct sk_buff	*skb2 = NULL;
337	struct usb_ep	*in = port->in_ep;
338	int		headroom, tailroom, padlen = 0;
339	u16		len;
340
341	if (!skb)
342		return NULL;
343
344	len = skb->len;
345	headroom = skb_headroom(skb);
346	tailroom = skb_tailroom(skb);
347
348	/* When (len + EEM_HLEN + ETH_FCS_LEN) % in->maxpacket) is 0,
349	 * stick two bytes of zero-length EEM packet on the end.
350	 */
351	if (((len + EEM_HLEN + ETH_FCS_LEN) % in->maxpacket) == 0)
352		padlen += 2;
353
354	if ((tailroom >= (ETH_FCS_LEN + padlen)) &&
355			(headroom >= EEM_HLEN) && !skb_cloned(skb))
356		goto done;
357
358	skb2 = skb_copy_expand(skb, EEM_HLEN, ETH_FCS_LEN + padlen, GFP_ATOMIC);
359	dev_kfree_skb_any(skb);
360	skb = skb2;
361	if (!skb)
362		return skb;
363
364done:
365	/* use the "no CRC" option */
366	put_unaligned_be32(0xdeadbeef, skb_put(skb, 4));
367
368	/* EEM packet header format:
369	 * b0..13:	length of ethernet frame
370	 * b14:		bmCRC (0 == sentinel CRC)
371	 * b15:		bmType (0 == data)
372	 */
373	len = skb->len;
374	put_unaligned_le16(len & 0x3FFF, skb_push(skb, 2));
375
376	/* add a zero-length EEM packet, if needed */
377	if (padlen)
378		put_unaligned_le16(0, skb_put(skb, 2));
379
380	return skb;
381}
382
383/*
384 * Remove the EEM header.  Note that there can be many EEM packets in a single
385 * USB transfer, so we need to break them out and handle them independently.
386 */
387static int eem_unwrap(struct gether *port,
388			struct sk_buff *skb,
389			struct sk_buff_head *list)
390{
391	struct usb_composite_dev	*cdev = port->func.config->cdev;
392	int				status = 0;
393
394	do {
395		struct sk_buff	*skb2;
396		u16		header;
397		u16		len = 0;
398
399		if (skb->len < EEM_HLEN) {
400			status = -EINVAL;
401			DBG(cdev, "invalid EEM header\n");
402			goto error;
403		}
404
405		/* remove the EEM header */
406		header = get_unaligned_le16(skb->data);
407		skb_pull(skb, EEM_HLEN);
408
409		/* EEM packet header format:
410		 * b0..14:	EEM type dependent (data or command)
411		 * b15:		bmType (0 == data, 1 == command)
412		 */
413		if (header & BIT(15)) {
414			struct usb_request	*req;
415			struct in_context	*ctx;
416			struct usb_ep		*ep;
417			u16			bmEEMCmd;
418
419			/* EEM command packet format:
420			 * b0..10:	bmEEMCmdParam
421			 * b11..13:	bmEEMCmd
422			 * b14:		reserved (must be zero)
423			 * b15:		bmType (1 == command)
424			 */
425			if (header & BIT(14))
426				continue;
427
428			bmEEMCmd = (header >> 11) & 0x7;
429			switch (bmEEMCmd) {
430			case 0: /* echo */
431				len = header & 0x7FF;
432				if (skb->len < len) {
433					status = -EOVERFLOW;
434					goto error;
435				}
436
437				skb2 = skb_clone(skb, GFP_ATOMIC);
438				if (unlikely(!skb2)) {
439					DBG(cdev, "EEM echo response error\n");
440					goto next;
441				}
442				skb_trim(skb2, len);
443				put_unaligned_le16(BIT(15) | BIT(11) | len,
444							skb_push(skb2, 2));
445
446				ep = port->in_ep;
447				req = usb_ep_alloc_request(ep, GFP_ATOMIC);
448				if (!req) {
449					dev_kfree_skb_any(skb2);
450					goto next;
451				}
452
453				req->buf = kmalloc(skb2->len, GFP_KERNEL);
454				if (!req->buf) {
455					usb_ep_free_request(ep, req);
456					dev_kfree_skb_any(skb2);
457					goto next;
458				}
459
460				ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
461				if (!ctx) {
462					kfree(req->buf);
463					usb_ep_free_request(ep, req);
464					dev_kfree_skb_any(skb2);
465					goto next;
466				}
467				ctx->skb = skb2;
468				ctx->ep = ep;
469
470				skb_copy_bits(skb2, 0, req->buf, skb2->len);
471				req->length = skb2->len;
472				req->complete = eem_cmd_complete;
473				req->zero = 1;
474				req->context = ctx;
475				if (usb_ep_queue(port->in_ep, req, GFP_ATOMIC)) {
476					DBG(cdev, "echo response queue fail\n");
477					kfree(ctx);
478					kfree(req->buf);
479					usb_ep_free_request(ep, req);
480					dev_kfree_skb_any(skb2);
481				}
482				break;
483
484			case 1:  /* echo response */
485			case 2:  /* suspend hint */
486			case 3:  /* response hint */
487			case 4:  /* response complete hint */
488			case 5:  /* tickle */
489			default: /* reserved */
490				continue;
491			}
492		} else {
493			u32		crc, crc2;
494			struct sk_buff	*skb3;
495
496			/* check for zero-length EEM packet */
497			if (header == 0)
498				continue;
499
500			/* EEM data packet format:
501			 * b0..13:	length of ethernet frame
502			 * b14:		bmCRC (0 == sentinel, 1 == calculated)
503			 * b15:		bmType (0 == data)
504			 */
505			len = header & 0x3FFF;
506			if ((skb->len < len)
507					|| (len < (ETH_HLEN + ETH_FCS_LEN))) {
508				status = -EINVAL;
509				goto error;
510			}
511
512			/* validate CRC */
513			if (header & BIT(14)) {
514				crc = get_unaligned_le32(skb->data + len
515							- ETH_FCS_LEN);
516				crc2 = ~crc32_le(~0,
517						skb->data, len - ETH_FCS_LEN);
518			} else {
519				crc = get_unaligned_be32(skb->data + len
520							- ETH_FCS_LEN);
521				crc2 = 0xdeadbeef;
522			}
523			if (crc != crc2) {
524				DBG(cdev, "invalid EEM CRC\n");
525				goto next;
526			}
527
528			skb2 = skb_clone(skb, GFP_ATOMIC);
529			if (unlikely(!skb2)) {
530				DBG(cdev, "unable to unframe EEM packet\n");
531				goto next;
532			}
533			skb_trim(skb2, len - ETH_FCS_LEN);
534
535			skb3 = skb_copy_expand(skb2,
536						NET_IP_ALIGN,
537						0,
538						GFP_ATOMIC);
539			if (unlikely(!skb3)) {
540				dev_kfree_skb_any(skb2);
541				goto next;
542			}
543			dev_kfree_skb_any(skb2);
544			skb_queue_tail(list, skb3);
545		}
546next:
547		skb_pull(skb, len);
548	} while (skb->len);
549
550error:
551	dev_kfree_skb_any(skb);
552	return status;
553}
554
555static inline struct f_eem_opts *to_f_eem_opts(struct config_item *item)
556{
557	return container_of(to_config_group(item), struct f_eem_opts,
558			    func_inst.group);
559}
560
561/* f_eem_item_ops */
562USB_ETHERNET_CONFIGFS_ITEM(eem);
563
564/* f_eem_opts_dev_addr */
565USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(eem);
566
567/* f_eem_opts_host_addr */
568USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(eem);
569
570/* f_eem_opts_qmult */
571USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(eem);
572
573/* f_eem_opts_ifname */
574USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(eem);
575
576static struct configfs_attribute *eem_attrs[] = {
577	&eem_opts_attr_dev_addr,
578	&eem_opts_attr_host_addr,
579	&eem_opts_attr_qmult,
580	&eem_opts_attr_ifname,
581	NULL,
582};
583
584static const struct config_item_type eem_func_type = {
585	.ct_item_ops	= &eem_item_ops,
586	.ct_attrs	= eem_attrs,
587	.ct_owner	= THIS_MODULE,
588};
589
590static void eem_free_inst(struct usb_function_instance *f)
591{
592	struct f_eem_opts *opts;
593
594	opts = container_of(f, struct f_eem_opts, func_inst);
595	if (device_is_registered(&opts->net->dev))
596		gether_cleanup(netdev_priv(opts->net));
597	else
598		free_netdev(opts->net);
599	kfree(opts);
600}
601
602static struct usb_function_instance *eem_alloc_inst(void)
603{
604	struct f_eem_opts *opts;
605
606	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
607	if (!opts)
608		return ERR_PTR(-ENOMEM);
609	mutex_init(&opts->lock);
610	opts->func_inst.free_func_inst = eem_free_inst;
611	opts->net = gether_setup_default();
612	if (IS_ERR(opts->net)) {
613		struct net_device *net = opts->net;
614		kfree(opts);
615		return ERR_CAST(net);
616	}
617
618	config_group_init_type_name(&opts->func_inst.group, "", &eem_func_type);
619
620	return &opts->func_inst;
621}
622
623static void eem_free(struct usb_function *f)
624{
625	struct f_eem *eem;
626	struct f_eem_opts *opts;
627
628	eem = func_to_eem(f);
629	opts = container_of(f->fi, struct f_eem_opts, func_inst);
630	kfree(eem);
631	mutex_lock(&opts->lock);
632	opts->refcnt--;
633	mutex_unlock(&opts->lock);
634}
635
636static void eem_unbind(struct usb_configuration *c, struct usb_function *f)
637{
638	struct f_eem_opts *opts;
639
640	DBG(c->cdev, "eem unbind\n");
641
642	opts = container_of(f->fi, struct f_eem_opts, func_inst);
643
644	usb_free_all_descriptors(f);
645
646	opts->bind_count--;
647	if (opts->bind_count == 0 && !opts->bound)
648		gether_detach_gadget(opts->net);
649}
650
651static struct usb_function *eem_alloc(struct usb_function_instance *fi)
652{
653	struct f_eem	*eem;
654	struct f_eem_opts *opts;
655
656	/* allocate and initialize one new instance */
657	eem = kzalloc(sizeof(*eem), GFP_KERNEL);
658	if (!eem)
659		return ERR_PTR(-ENOMEM);
660
661	opts = container_of(fi, struct f_eem_opts, func_inst);
662	mutex_lock(&opts->lock);
663	opts->refcnt++;
664
665	eem->port.ioport = netdev_priv(opts->net);
666	mutex_unlock(&opts->lock);
667	eem->port.cdc_filter = DEFAULT_FILTER;
668
669	eem->port.func.name = "cdc_eem";
670	/* descriptors are per-instance copies */
671	eem->port.func.bind = eem_bind;
672	eem->port.func.unbind = eem_unbind;
673	eem->port.func.set_alt = eem_set_alt;
674	eem->port.func.setup = eem_setup;
675	eem->port.func.disable = eem_disable;
676	eem->port.func.free_func = eem_free;
677	eem->port.wrap = eem_wrap;
678	eem->port.unwrap = eem_unwrap;
679	eem->port.header_len = EEM_HLEN;
680
681	return &eem->port.func;
682}
683
684DECLARE_USB_FUNCTION_INIT(eem, eem_alloc_inst, eem_alloc);
685MODULE_DESCRIPTION("USB CDC Ethernet (EEM) link function driver");
686MODULE_LICENSE("GPL");
687MODULE_AUTHOR("David Brownell");