1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * hid.c -- HID Composite driver |
4 | * |
5 | * Based on multi.c |
6 | * |
7 | * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com> |
8 | */ |
9 | |
10 | |
11 | #include <linux/kernel.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/list.h> |
14 | #include <linux/module.h> |
15 | #include <linux/usb/composite.h> |
16 | #include <linux/usb/g_hid.h> |
17 | |
18 | #define DRIVER_DESC "HID Gadget" |
19 | #define DRIVER_VERSION "2010/03/16" |
20 | |
21 | #include "u_hid.h" |
22 | |
23 | /*-------------------------------------------------------------------------*/ |
24 | |
25 | #define HIDG_VENDOR_NUM 0x0525 /* XXX NetChip */ |
26 | #define HIDG_PRODUCT_NUM 0xa4ac /* Linux-USB HID gadget */ |
27 | |
28 | /*-------------------------------------------------------------------------*/ |
29 | |
30 | struct hidg_func_node { |
31 | struct usb_function_instance *fi; |
32 | struct usb_function *f; |
33 | struct list_head node; |
34 | struct hidg_func_descriptor *func; |
35 | }; |
36 | |
37 | static LIST_HEAD(hidg_func_list); |
38 | |
39 | /*-------------------------------------------------------------------------*/ |
40 | USB_GADGET_COMPOSITE_OPTIONS(); |
41 | |
42 | static struct usb_device_descriptor device_desc = { |
43 | .bLength = sizeof device_desc, |
44 | .bDescriptorType = USB_DT_DEVICE, |
45 | |
46 | /* .bcdUSB = DYNAMIC */ |
47 | |
48 | /* .bDeviceClass = USB_CLASS_COMM, */ |
49 | /* .bDeviceSubClass = 0, */ |
50 | /* .bDeviceProtocol = 0, */ |
51 | .bDeviceClass = USB_CLASS_PER_INTERFACE, |
52 | .bDeviceSubClass = 0, |
53 | .bDeviceProtocol = 0, |
54 | /* .bMaxPacketSize0 = f(hardware) */ |
55 | |
56 | /* Vendor and product id can be overridden by module parameters. */ |
57 | .idVendor = cpu_to_le16(HIDG_VENDOR_NUM), |
58 | .idProduct = cpu_to_le16(HIDG_PRODUCT_NUM), |
59 | /* .bcdDevice = f(hardware) */ |
60 | /* .iManufacturer = DYNAMIC */ |
61 | /* .iProduct = DYNAMIC */ |
62 | /* NO SERIAL NUMBER */ |
63 | .bNumConfigurations = 1, |
64 | }; |
65 | |
66 | static const struct usb_descriptor_header *otg_desc[2]; |
67 | |
68 | /* string IDs are assigned dynamically */ |
69 | static struct usb_string strings_dev[] = { |
70 | [USB_GADGET_MANUFACTURER_IDX].s = "" , |
71 | [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC, |
72 | [USB_GADGET_SERIAL_IDX].s = "" , |
73 | { } /* end of list */ |
74 | }; |
75 | |
76 | static struct usb_gadget_strings stringtab_dev = { |
77 | .language = 0x0409, /* en-us */ |
78 | .strings = strings_dev, |
79 | }; |
80 | |
81 | static struct usb_gadget_strings *dev_strings[] = { |
82 | &stringtab_dev, |
83 | NULL, |
84 | }; |
85 | |
86 | |
87 | |
88 | /****************************** Configurations ******************************/ |
89 | |
90 | static int do_config(struct usb_configuration *c) |
91 | { |
92 | struct hidg_func_node *e, *n; |
93 | int status = 0; |
94 | |
95 | if (gadget_is_otg(g: c->cdev->gadget)) { |
96 | c->descriptors = otg_desc; |
97 | c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; |
98 | } |
99 | |
100 | list_for_each_entry(e, &hidg_func_list, node) { |
101 | e->f = usb_get_function(fi: e->fi); |
102 | if (IS_ERR(ptr: e->f)) { |
103 | status = PTR_ERR(ptr: e->f); |
104 | goto put; |
105 | } |
106 | status = usb_add_function(c, e->f); |
107 | if (status < 0) { |
108 | usb_put_function(f: e->f); |
109 | goto put; |
110 | } |
111 | } |
112 | |
113 | return 0; |
114 | put: |
115 | list_for_each_entry(n, &hidg_func_list, node) { |
116 | if (n == e) |
117 | break; |
118 | usb_remove_function(c, f: n->f); |
119 | usb_put_function(f: n->f); |
120 | } |
121 | return status; |
122 | } |
123 | |
124 | static struct usb_configuration config_driver = { |
125 | .label = "HID Gadget" , |
126 | .bConfigurationValue = 1, |
127 | /* .iConfiguration = DYNAMIC */ |
128 | .bmAttributes = USB_CONFIG_ATT_SELFPOWER, |
129 | }; |
130 | |
131 | /****************************** Gadget Bind ******************************/ |
132 | |
133 | static int hid_bind(struct usb_composite_dev *cdev) |
134 | { |
135 | struct usb_gadget *gadget = cdev->gadget; |
136 | struct hidg_func_node *n = NULL, *m, *iter_n; |
137 | struct f_hid_opts *hid_opts; |
138 | int status, funcs; |
139 | |
140 | funcs = list_count_nodes(head: &hidg_func_list); |
141 | if (!funcs) |
142 | return -ENODEV; |
143 | |
144 | list_for_each_entry(iter_n, &hidg_func_list, node) { |
145 | iter_n->fi = usb_get_function_instance(name: "hid" ); |
146 | if (IS_ERR(ptr: iter_n->fi)) { |
147 | status = PTR_ERR(ptr: iter_n->fi); |
148 | n = iter_n; |
149 | goto put; |
150 | } |
151 | hid_opts = container_of(iter_n->fi, struct f_hid_opts, func_inst); |
152 | hid_opts->subclass = iter_n->func->subclass; |
153 | hid_opts->protocol = iter_n->func->protocol; |
154 | hid_opts->report_length = iter_n->func->report_length; |
155 | hid_opts->report_desc_length = iter_n->func->report_desc_length; |
156 | hid_opts->report_desc = iter_n->func->report_desc; |
157 | } |
158 | |
159 | |
160 | /* Allocate string descriptor numbers ... note that string |
161 | * contents can be overridden by the composite_dev glue. |
162 | */ |
163 | |
164 | status = usb_string_ids_tab(c: cdev, str: strings_dev); |
165 | if (status < 0) |
166 | goto put; |
167 | device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; |
168 | device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; |
169 | |
170 | if (gadget_is_otg(g: gadget) && !otg_desc[0]) { |
171 | struct usb_descriptor_header *usb_desc; |
172 | |
173 | usb_desc = usb_otg_descriptor_alloc(gadget); |
174 | if (!usb_desc) { |
175 | status = -ENOMEM; |
176 | goto put; |
177 | } |
178 | usb_otg_descriptor_init(gadget, otg_desc: usb_desc); |
179 | otg_desc[0] = usb_desc; |
180 | otg_desc[1] = NULL; |
181 | } |
182 | |
183 | /* register our configuration */ |
184 | status = usb_add_config(cdev, &config_driver, do_config); |
185 | if (status < 0) |
186 | goto free_otg_desc; |
187 | |
188 | usb_composite_overwrite_options(cdev, covr: &coverwrite); |
189 | dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n" ); |
190 | |
191 | return 0; |
192 | |
193 | free_otg_desc: |
194 | kfree(objp: otg_desc[0]); |
195 | otg_desc[0] = NULL; |
196 | put: |
197 | list_for_each_entry(m, &hidg_func_list, node) { |
198 | if (m == n) |
199 | break; |
200 | usb_put_function_instance(fi: m->fi); |
201 | } |
202 | return status; |
203 | } |
204 | |
205 | static int hid_unbind(struct usb_composite_dev *cdev) |
206 | { |
207 | struct hidg_func_node *n; |
208 | |
209 | list_for_each_entry(n, &hidg_func_list, node) { |
210 | usb_put_function(f: n->f); |
211 | usb_put_function_instance(fi: n->fi); |
212 | } |
213 | |
214 | kfree(objp: otg_desc[0]); |
215 | otg_desc[0] = NULL; |
216 | |
217 | return 0; |
218 | } |
219 | |
220 | static int hidg_plat_driver_probe(struct platform_device *pdev) |
221 | { |
222 | struct hidg_func_descriptor *func = dev_get_platdata(dev: &pdev->dev); |
223 | struct hidg_func_node *entry; |
224 | |
225 | if (!func) { |
226 | dev_err(&pdev->dev, "Platform data missing\n" ); |
227 | return -ENODEV; |
228 | } |
229 | |
230 | entry = kzalloc(size: sizeof(*entry), GFP_KERNEL); |
231 | if (!entry) |
232 | return -ENOMEM; |
233 | |
234 | entry->func = func; |
235 | list_add_tail(new: &entry->node, head: &hidg_func_list); |
236 | |
237 | return 0; |
238 | } |
239 | |
240 | static void hidg_plat_driver_remove(struct platform_device *pdev) |
241 | { |
242 | struct hidg_func_node *e, *n; |
243 | |
244 | list_for_each_entry_safe(e, n, &hidg_func_list, node) { |
245 | list_del(entry: &e->node); |
246 | kfree(objp: e); |
247 | } |
248 | } |
249 | |
250 | |
251 | /****************************** Some noise ******************************/ |
252 | |
253 | |
254 | static struct usb_composite_driver hidg_driver = { |
255 | .name = "g_hid" , |
256 | .dev = &device_desc, |
257 | .strings = dev_strings, |
258 | .max_speed = USB_SPEED_HIGH, |
259 | .bind = hid_bind, |
260 | .unbind = hid_unbind, |
261 | }; |
262 | |
263 | static struct platform_driver hidg_plat_driver = { |
264 | .remove_new = hidg_plat_driver_remove, |
265 | .driver = { |
266 | .name = "hidg" , |
267 | }, |
268 | }; |
269 | |
270 | |
271 | MODULE_DESCRIPTION(DRIVER_DESC); |
272 | MODULE_AUTHOR("Fabien Chouteau, Peter Korsgaard" ); |
273 | MODULE_LICENSE("GPL" ); |
274 | |
275 | static int __init hidg_init(void) |
276 | { |
277 | int status; |
278 | |
279 | status = platform_driver_probe(&hidg_plat_driver, |
280 | hidg_plat_driver_probe); |
281 | if (status < 0) |
282 | return status; |
283 | |
284 | status = usb_composite_probe(driver: &hidg_driver); |
285 | if (status < 0) |
286 | platform_driver_unregister(&hidg_plat_driver); |
287 | |
288 | return status; |
289 | } |
290 | module_init(hidg_init); |
291 | |
292 | static void __exit hidg_cleanup(void) |
293 | { |
294 | usb_composite_unregister(driver: &hidg_driver); |
295 | platform_driver_unregister(&hidg_plat_driver); |
296 | } |
297 | module_exit(hidg_cleanup); |
298 | |