1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * cdc2.c -- CDC Composite driver, with ECM and ACM support
4 *
5 * Copyright (C) 2008 David Brownell
6 * Copyright (C) 2008 Nokia Corporation
7 */
8
9#include <linux/kernel.h>
10#include <linux/module.h>
11
12#include "u_ether.h"
13#include "u_serial.h"
14#include "u_ecm.h"
15
16
17#define DRIVER_DESC "CDC Composite Gadget"
18#define DRIVER_VERSION "King Kamehameha Day 2008"
19
20/*-------------------------------------------------------------------------*/
21
22/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
23 * Instead: allocate your own, using normal USB-IF procedures.
24 */
25
26/* Thanks to NetChip Technologies for donating this product ID.
27 * It's for devices with only this composite CDC configuration.
28 */
29#define CDC_VENDOR_NUM 0x0525 /* NetChip */
30#define CDC_PRODUCT_NUM 0xa4aa /* CDC Composite: ECM + ACM */
31
32USB_GADGET_COMPOSITE_OPTIONS();
33
34USB_ETHERNET_MODULE_PARAMETERS();
35
36/*-------------------------------------------------------------------------*/
37
38static struct usb_device_descriptor device_desc = {
39 .bLength = sizeof device_desc,
40 .bDescriptorType = USB_DT_DEVICE,
41
42 /* .bcdUSB = DYNAMIC */
43
44 .bDeviceClass = USB_CLASS_COMM,
45 .bDeviceSubClass = 0,
46 .bDeviceProtocol = 0,
47 /* .bMaxPacketSize0 = f(hardware) */
48
49 /* Vendor and product id can be overridden by module parameters. */
50 .idVendor = cpu_to_le16(CDC_VENDOR_NUM),
51 .idProduct = cpu_to_le16(CDC_PRODUCT_NUM),
52 /* .bcdDevice = f(hardware) */
53 /* .iManufacturer = DYNAMIC */
54 /* .iProduct = DYNAMIC */
55 /* NO SERIAL NUMBER */
56 .bNumConfigurations = 1,
57};
58
59static const struct usb_descriptor_header *otg_desc[2];
60
61/* string IDs are assigned dynamically */
62static struct usb_string strings_dev[] = {
63 [USB_GADGET_MANUFACTURER_IDX].s = "",
64 [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
65 [USB_GADGET_SERIAL_IDX].s = "",
66 { } /* end of list */
67};
68
69static struct usb_gadget_strings stringtab_dev = {
70 .language = 0x0409, /* en-us */
71 .strings = strings_dev,
72};
73
74static struct usb_gadget_strings *dev_strings[] = {
75 &stringtab_dev,
76 NULL,
77};
78
79/*-------------------------------------------------------------------------*/
80static struct usb_function *f_acm;
81static struct usb_function_instance *fi_serial;
82
83static struct usb_function *f_ecm;
84static struct usb_function_instance *fi_ecm;
85
86/*
87 * We _always_ have both CDC ECM and CDC ACM functions.
88 */
89static int cdc_do_config(struct usb_configuration *c)
90{
91 int status;
92
93 if (gadget_is_otg(g: c->cdev->gadget)) {
94 c->descriptors = otg_desc;
95 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
96 }
97
98 f_ecm = usb_get_function(fi: fi_ecm);
99 if (IS_ERR(ptr: f_ecm)) {
100 status = PTR_ERR(ptr: f_ecm);
101 goto err_get_ecm;
102 }
103
104 status = usb_add_function(c, f_ecm);
105 if (status)
106 goto err_add_ecm;
107
108 f_acm = usb_get_function(fi: fi_serial);
109 if (IS_ERR(ptr: f_acm)) {
110 status = PTR_ERR(ptr: f_acm);
111 goto err_get_acm;
112 }
113
114 status = usb_add_function(c, f_acm);
115 if (status)
116 goto err_add_acm;
117 return 0;
118
119err_add_acm:
120 usb_put_function(f: f_acm);
121err_get_acm:
122 usb_remove_function(c, f: f_ecm);
123err_add_ecm:
124 usb_put_function(f: f_ecm);
125err_get_ecm:
126 return status;
127}
128
129static struct usb_configuration cdc_config_driver = {
130 .label = "CDC Composite (ECM + ACM)",
131 .bConfigurationValue = 1,
132 /* .iConfiguration = DYNAMIC */
133 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
134};
135
136/*-------------------------------------------------------------------------*/
137
138static int cdc_bind(struct usb_composite_dev *cdev)
139{
140 struct usb_gadget *gadget = cdev->gadget;
141 struct f_ecm_opts *ecm_opts;
142 int status;
143
144 if (!can_support_ecm(gadget: cdev->gadget)) {
145 dev_err(&gadget->dev, "controller '%s' not usable\n",
146 gadget->name);
147 return -EINVAL;
148 }
149
150 fi_ecm = usb_get_function_instance(name: "ecm");
151 if (IS_ERR(ptr: fi_ecm))
152 return PTR_ERR(ptr: fi_ecm);
153
154 ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
155
156 gether_set_qmult(net: ecm_opts->net, qmult);
157 if (!gether_set_host_addr(net: ecm_opts->net, host_addr))
158 pr_info("using host ethernet address: %s", host_addr);
159 if (!gether_set_dev_addr(net: ecm_opts->net, dev_addr))
160 pr_info("using self ethernet address: %s", dev_addr);
161
162 fi_serial = usb_get_function_instance(name: "acm");
163 if (IS_ERR(ptr: fi_serial)) {
164 status = PTR_ERR(ptr: fi_serial);
165 goto fail;
166 }
167
168 /* Allocate string descriptor numbers ... note that string
169 * contents can be overridden by the composite_dev glue.
170 */
171
172 status = usb_string_ids_tab(c: cdev, str: strings_dev);
173 if (status < 0)
174 goto fail1;
175 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
176 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
177
178 if (gadget_is_otg(g: gadget) && !otg_desc[0]) {
179 struct usb_descriptor_header *usb_desc;
180
181 usb_desc = usb_otg_descriptor_alloc(gadget);
182 if (!usb_desc) {
183 status = -ENOMEM;
184 goto fail1;
185 }
186 usb_otg_descriptor_init(gadget, otg_desc: usb_desc);
187 otg_desc[0] = usb_desc;
188 otg_desc[1] = NULL;
189 }
190
191 /* register our configuration */
192 status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config);
193 if (status < 0)
194 goto fail2;
195
196 usb_composite_overwrite_options(cdev, covr: &coverwrite);
197 dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
198 DRIVER_DESC);
199
200 return 0;
201
202fail2:
203 kfree(objp: otg_desc[0]);
204 otg_desc[0] = NULL;
205fail1:
206 usb_put_function_instance(fi: fi_serial);
207fail:
208 usb_put_function_instance(fi: fi_ecm);
209 return status;
210}
211
212static int cdc_unbind(struct usb_composite_dev *cdev)
213{
214 usb_put_function(f: f_acm);
215 usb_put_function_instance(fi: fi_serial);
216 if (!IS_ERR_OR_NULL(ptr: f_ecm))
217 usb_put_function(f: f_ecm);
218 if (!IS_ERR_OR_NULL(ptr: fi_ecm))
219 usb_put_function_instance(fi: fi_ecm);
220 kfree(objp: otg_desc[0]);
221 otg_desc[0] = NULL;
222
223 return 0;
224}
225
226static struct usb_composite_driver cdc_driver = {
227 .name = "g_cdc",
228 .dev = &device_desc,
229 .strings = dev_strings,
230 .max_speed = USB_SPEED_SUPER,
231 .bind = cdc_bind,
232 .unbind = cdc_unbind,
233};
234
235module_usb_composite_driver(cdc_driver);
236
237MODULE_DESCRIPTION(DRIVER_DESC);
238MODULE_AUTHOR("David Brownell");
239MODULE_LICENSE("GPL");
240

source code of linux/drivers/usb/gadget/legacy/cdc2.c