Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/shaggy...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / drivers / usb / gadget / serial.c
1 /*
2  * serial.c -- USB gadget serial driver
3  *
4  * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
5  * Copyright (C) 2008 by David Brownell
6  * Copyright (C) 2008 by Nokia Corporation
7  *
8  * This software is distributed under the terms of the GNU General
9  * Public License ("GPL") as published by the Free Software Foundation,
10  * either version 2 of that License or (at your option) any later version.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/utsname.h>
15 #include <linux/device.h>
16 #include <linux/tty.h>
17 #include <linux/tty_flip.h>
18
19 #include "u_serial.h"
20 #include "gadget_chips.h"
21
22
23 /* Defines */
24
25 #define GS_VERSION_STR                  "v2.4"
26 #define GS_VERSION_NUM                  0x2400
27
28 #define GS_LONG_NAME                    "Gadget Serial"
29 #define GS_VERSION_NAME                 GS_LONG_NAME " " GS_VERSION_STR
30
31 /*-------------------------------------------------------------------------*/
32
33 /*
34  * Kbuild is not very cooperative with respect to linking separately
35  * compiled library objects into one module.  So for now we won't use
36  * separate compilation ... ensuring init/exit sections work to shrink
37  * the runtime footprint, and giving us at least some parts of what
38  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
39  */
40 #include "composite.c"
41 #include "usbstring.c"
42 #include "config.c"
43 #include "epautoconf.c"
44
45 #include "f_acm.c"
46 #include "f_obex.c"
47 #include "f_serial.c"
48 #include "u_serial.c"
49
50 /*-------------------------------------------------------------------------*/
51
52 /* Thanks to NetChip Technologies for donating this product ID.
53 *
54 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
55 * Instead:  allocate your own, using normal USB-IF procedures.
56 */
57 #define GS_VENDOR_ID                    0x0525  /* NetChip */
58 #define GS_PRODUCT_ID                   0xa4a6  /* Linux-USB Serial Gadget */
59 #define GS_CDC_PRODUCT_ID               0xa4a7  /* ... as CDC-ACM */
60 #define GS_CDC_OBEX_PRODUCT_ID          0xa4a9  /* ... as CDC-OBEX */
61
62 /* string IDs are assigned dynamically */
63
64 #define STRING_MANUFACTURER_IDX         0
65 #define STRING_PRODUCT_IDX              1
66 #define STRING_DESCRIPTION_IDX          2
67
68 static char manufacturer[50];
69
70 static struct usb_string strings_dev[] = {
71         [STRING_MANUFACTURER_IDX].s = manufacturer,
72         [STRING_PRODUCT_IDX].s = GS_VERSION_NAME,
73         [STRING_DESCRIPTION_IDX].s = NULL /* updated; f(use_acm) */,
74         {  } /* end of list */
75 };
76
77 static struct usb_gadget_strings stringtab_dev = {
78         .language       = 0x0409,       /* en-us */
79         .strings        = strings_dev,
80 };
81
82 static struct usb_gadget_strings *dev_strings[] = {
83         &stringtab_dev,
84         NULL,
85 };
86
87 static struct usb_device_descriptor device_desc = {
88         .bLength =              USB_DT_DEVICE_SIZE,
89         .bDescriptorType =      USB_DT_DEVICE,
90         .bcdUSB =               cpu_to_le16(0x0200),
91         /* .bDeviceClass = f(use_acm) */
92         .bDeviceSubClass =      0,
93         .bDeviceProtocol =      0,
94         /* .bMaxPacketSize0 = f(hardware) */
95         .idVendor =             cpu_to_le16(GS_VENDOR_ID),
96         /* .idProduct = f(use_acm) */
97         /* .bcdDevice = f(hardware) */
98         /* .iManufacturer = DYNAMIC */
99         /* .iProduct = DYNAMIC */
100         .bNumConfigurations =   1,
101 };
102
103 static struct usb_otg_descriptor otg_descriptor = {
104         .bLength =              sizeof otg_descriptor,
105         .bDescriptorType =      USB_DT_OTG,
106
107         /* REVISIT SRP-only hardware is possible, although
108          * it would not be called "OTG" ...
109          */
110         .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
111 };
112
113 static const struct usb_descriptor_header *otg_desc[] = {
114         (struct usb_descriptor_header *) &otg_descriptor,
115         NULL,
116 };
117
118 /*-------------------------------------------------------------------------*/
119
120 /* Module */
121 MODULE_DESCRIPTION(GS_VERSION_NAME);
122 MODULE_AUTHOR("Al Borchers");
123 MODULE_AUTHOR("David Brownell");
124 MODULE_LICENSE("GPL");
125
126 static int use_acm = true;
127 module_param(use_acm, bool, 0);
128 MODULE_PARM_DESC(use_acm, "Use CDC ACM, default=yes");
129
130 static int use_obex = false;
131 module_param(use_obex, bool, 0);
132 MODULE_PARM_DESC(use_obex, "Use CDC OBEX, default=no");
133
134 static unsigned n_ports = 1;
135 module_param(n_ports, uint, 0);
136 MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
137
138 /*-------------------------------------------------------------------------*/
139
140 static int __init serial_bind_config(struct usb_configuration *c)
141 {
142         unsigned i;
143         int status = 0;
144
145         for (i = 0; i < n_ports && status == 0; i++) {
146                 if (use_acm)
147                         status = acm_bind_config(c, i);
148                 else if (use_obex)
149                         status = obex_bind_config(c, i);
150                 else
151                         status = gser_bind_config(c, i);
152         }
153         return status;
154 }
155
156 static struct usb_configuration serial_config_driver = {
157         /* .label = f(use_acm) */
158         .bind           = serial_bind_config,
159         /* .bConfigurationValue = f(use_acm) */
160         /* .iConfiguration = DYNAMIC */
161         .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
162 };
163
164 static int __init gs_bind(struct usb_composite_dev *cdev)
165 {
166         int                     gcnum;
167         struct usb_gadget       *gadget = cdev->gadget;
168         int                     status;
169
170         status = gserial_setup(cdev->gadget, n_ports);
171         if (status < 0)
172                 return status;
173
174         /* Allocate string descriptor numbers ... note that string
175          * contents can be overridden by the composite_dev glue.
176          */
177
178         /* device description: manufacturer, product */
179         snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
180                 init_utsname()->sysname, init_utsname()->release,
181                 gadget->name);
182         status = usb_string_id(cdev);
183         if (status < 0)
184                 goto fail;
185         strings_dev[STRING_MANUFACTURER_IDX].id = status;
186
187         device_desc.iManufacturer = status;
188
189         status = usb_string_id(cdev);
190         if (status < 0)
191                 goto fail;
192         strings_dev[STRING_PRODUCT_IDX].id = status;
193
194         device_desc.iProduct = status;
195
196         /* config description */
197         status = usb_string_id(cdev);
198         if (status < 0)
199                 goto fail;
200         strings_dev[STRING_DESCRIPTION_IDX].id = status;
201
202         serial_config_driver.iConfiguration = status;
203
204         /* set up other descriptors */
205         gcnum = usb_gadget_controller_number(gadget);
206         if (gcnum >= 0)
207                 device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum);
208         else {
209                 /* this is so simple (for now, no altsettings) that it
210                  * SHOULD NOT have problems with bulk-capable hardware.
211                  * so warn about unrcognized controllers -- don't panic.
212                  *
213                  * things like configuration and altsetting numbering
214                  * can need hardware-specific attention though.
215                  */
216                 pr_warning("gs_bind: controller '%s' not recognized\n",
217                         gadget->name);
218                 device_desc.bcdDevice =
219                         cpu_to_le16(GS_VERSION_NUM | 0x0099);
220         }
221
222         if (gadget_is_otg(cdev->gadget)) {
223                 serial_config_driver.descriptors = otg_desc;
224                 serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
225         }
226
227         /* register our configuration */
228         status = usb_add_config(cdev, &serial_config_driver);
229         if (status < 0)
230                 goto fail;
231
232         INFO(cdev, "%s\n", GS_VERSION_NAME);
233
234         return 0;
235
236 fail:
237         gserial_cleanup();
238         return status;
239 }
240
241 static struct usb_composite_driver gserial_driver = {
242         .name           = "g_serial",
243         .dev            = &device_desc,
244         .strings        = dev_strings,
245         .bind           = gs_bind,
246 };
247
248 static int __init init(void)
249 {
250         /* We *could* export two configs; that'd be much cleaner...
251          * but neither of these product IDs was defined that way.
252          */
253         if (use_acm) {
254                 serial_config_driver.label = "CDC ACM config";
255                 serial_config_driver.bConfigurationValue = 2;
256                 device_desc.bDeviceClass = USB_CLASS_COMM;
257                 device_desc.idProduct =
258                                 cpu_to_le16(GS_CDC_PRODUCT_ID);
259         } else if (use_obex) {
260                 serial_config_driver.label = "CDC OBEX config";
261                 serial_config_driver.bConfigurationValue = 3;
262                 device_desc.bDeviceClass = USB_CLASS_COMM;
263                 device_desc.idProduct =
264                         cpu_to_le16(GS_CDC_OBEX_PRODUCT_ID);
265         } else {
266                 serial_config_driver.label = "Generic Serial config";
267                 serial_config_driver.bConfigurationValue = 1;
268                 device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
269                 device_desc.idProduct =
270                                 cpu_to_le16(GS_PRODUCT_ID);
271         }
272         strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
273
274         return usb_composite_register(&gserial_driver);
275 }
276 module_init(init);
277
278 static void __exit cleanup(void)
279 {
280         usb_composite_unregister(&gserial_driver);
281         gserial_cleanup();
282 }
283 module_exit(cleanup);