GNU Linux-libre 4.19.286-gnu1
[releases.git] / drivers / usb / wusbcore / wusbhc.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Wireless USB Host Controller
4  * sysfs glue, wusbcore module support and life cycle management
5  *
6  *
7  * Copyright (C) 2005-2006 Intel Corporation
8  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9  *
10  * Creation/destruction of wusbhc is split in two parts; that that
11  * doesn't require the HCD to be added (wusbhc_{create,destroy}) and
12  * the one that requires (phase B, wusbhc_b_{create,destroy}).
13  *
14  * This is so because usb_add_hcd() will start the HC, and thus, all
15  * the HC specific stuff has to be already initialized (like sysfs
16  * thingies).
17  */
18 #include <linux/device.h>
19 #include <linux/module.h>
20 #include "wusbhc.h"
21
22 /**
23  * Extract the wusbhc that corresponds to a USB Host Controller class device
24  *
25  * WARNING! Apply only if @dev is that of a
26  *          wusbhc.usb_hcd.self->class_dev; otherwise, you loose.
27  */
28 static struct wusbhc *usbhc_dev_to_wusbhc(struct device *dev)
29 {
30         struct usb_bus *usb_bus = dev_get_drvdata(dev);
31         struct usb_hcd *usb_hcd = bus_to_hcd(usb_bus);
32         return usb_hcd_to_wusbhc(usb_hcd);
33 }
34
35 /*
36  * Show & store the current WUSB trust timeout
37  *
38  * We don't do locking--it is an 'atomic' value.
39  *
40  * The units that we store/show are always MILLISECONDS. However, the
41  * value of trust_timeout is jiffies.
42  */
43 static ssize_t wusb_trust_timeout_show(struct device *dev,
44                                         struct device_attribute *attr,
45                                         char *buf)
46 {
47         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
48
49         return scnprintf(buf, PAGE_SIZE, "%u\n", wusbhc->trust_timeout);
50 }
51
52 static ssize_t wusb_trust_timeout_store(struct device *dev,
53                                         struct device_attribute *attr,
54                                         const char *buf, size_t size)
55 {
56         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
57         ssize_t result = -ENOSYS;
58         unsigned trust_timeout;
59
60         result = sscanf(buf, "%u", &trust_timeout);
61         if (result != 1) {
62                 result = -EINVAL;
63                 goto out;
64         }
65         wusbhc->trust_timeout = min_t(unsigned, trust_timeout, 500);
66         cancel_delayed_work(&wusbhc->keep_alive_timer);
67         flush_workqueue(wusbd);
68         queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
69                            msecs_to_jiffies(wusbhc->trust_timeout / 2));
70 out:
71         return result < 0 ? result : size;
72 }
73 static DEVICE_ATTR_RW(wusb_trust_timeout);
74
75 /*
76  * Show the current WUSB CHID.
77  */
78 static ssize_t wusb_chid_show(struct device *dev,
79                               struct device_attribute *attr, char *buf)
80 {
81         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
82         const struct wusb_ckhdid *chid;
83         ssize_t result = 0;
84
85         if (wusbhc->wuie_host_info != NULL)
86                 chid = &wusbhc->wuie_host_info->CHID;
87         else
88                 chid = &wusb_ckhdid_zero;
89
90         result += ckhdid_printf(buf, PAGE_SIZE, chid);
91         result += sprintf(buf + result, "\n");
92
93         return result;
94 }
95
96 /*
97  * Store a new CHID.
98  *
99  * - Write an all zeros CHID and it will stop the controller
100  * - Write a non-zero CHID and it will start it.
101  *
102  * See wusbhc_chid_set() for more info.
103  */
104 static ssize_t wusb_chid_store(struct device *dev,
105                                struct device_attribute *attr,
106                                const char *buf, size_t size)
107 {
108         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
109         struct wusb_ckhdid chid;
110         ssize_t result;
111
112         result = sscanf(buf,
113                         "%02hhx %02hhx %02hhx %02hhx "
114                         "%02hhx %02hhx %02hhx %02hhx "
115                         "%02hhx %02hhx %02hhx %02hhx "
116                         "%02hhx %02hhx %02hhx %02hhx\n",
117                         &chid.data[0] , &chid.data[1] ,
118                         &chid.data[2] , &chid.data[3] ,
119                         &chid.data[4] , &chid.data[5] ,
120                         &chid.data[6] , &chid.data[7] ,
121                         &chid.data[8] , &chid.data[9] ,
122                         &chid.data[10], &chid.data[11],
123                         &chid.data[12], &chid.data[13],
124                         &chid.data[14], &chid.data[15]);
125         if (result != 16) {
126                 dev_err(dev, "Unrecognized CHID (need 16 8-bit hex digits): "
127                         "%d\n", (int)result);
128                 return -EINVAL;
129         }
130         result = wusbhc_chid_set(wusbhc, &chid);
131         return result < 0 ? result : size;
132 }
133 static DEVICE_ATTR_RW(wusb_chid);
134
135
136 static ssize_t wusb_phy_rate_show(struct device *dev,
137                                   struct device_attribute *attr,
138                                   char *buf)
139 {
140         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
141
142         return sprintf(buf, "%d\n", wusbhc->phy_rate);
143 }
144
145 static ssize_t wusb_phy_rate_store(struct device *dev,
146                                    struct device_attribute *attr,
147                                    const char *buf, size_t size)
148 {
149         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
150         uint8_t phy_rate;
151         ssize_t result;
152
153         result = sscanf(buf, "%hhu", &phy_rate);
154         if (result != 1)
155                 return -EINVAL;
156         if (phy_rate >= UWB_PHY_RATE_INVALID)
157                 return -EINVAL;
158
159         wusbhc->phy_rate = phy_rate;
160         return size;
161 }
162 static DEVICE_ATTR_RW(wusb_phy_rate);
163
164 static ssize_t wusb_dnts_show(struct device *dev,
165                                   struct device_attribute *attr,
166                                   char *buf)
167 {
168         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
169
170         return sprintf(buf, "num slots: %d\ninterval: %dms\n",
171                         wusbhc->dnts_num_slots, wusbhc->dnts_interval);
172 }
173
174 static ssize_t wusb_dnts_store(struct device *dev,
175                                    struct device_attribute *attr,
176                                    const char *buf, size_t size)
177 {
178         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
179         uint8_t num_slots, interval;
180         ssize_t result;
181
182         result = sscanf(buf, "%hhu %hhu", &num_slots, &interval);
183
184         if (result != 2)
185                 return -EINVAL;
186
187         wusbhc->dnts_num_slots = num_slots;
188         wusbhc->dnts_interval = interval;
189
190         return size;
191 }
192 static DEVICE_ATTR_RW(wusb_dnts);
193
194 static ssize_t wusb_retry_count_show(struct device *dev,
195                                   struct device_attribute *attr,
196                                   char *buf)
197 {
198         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
199
200         return sprintf(buf, "%d\n", wusbhc->retry_count);
201 }
202
203 static ssize_t wusb_retry_count_store(struct device *dev,
204                                    struct device_attribute *attr,
205                                    const char *buf, size_t size)
206 {
207         struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
208         uint8_t retry_count;
209         ssize_t result;
210
211         result = sscanf(buf, "%hhu", &retry_count);
212
213         if (result != 1)
214                 return -EINVAL;
215
216         wusbhc->retry_count = max_t(uint8_t, retry_count,
217                                         WUSB_RETRY_COUNT_MAX);
218
219         return size;
220 }
221 static DEVICE_ATTR_RW(wusb_retry_count);
222
223 /* Group all the WUSBHC attributes */
224 static struct attribute *wusbhc_attrs[] = {
225                 &dev_attr_wusb_trust_timeout.attr,
226                 &dev_attr_wusb_chid.attr,
227                 &dev_attr_wusb_phy_rate.attr,
228                 &dev_attr_wusb_dnts.attr,
229                 &dev_attr_wusb_retry_count.attr,
230                 NULL,
231 };
232
233 static const struct attribute_group wusbhc_attr_group = {
234         .name = NULL,   /* we want them in the same directory */
235         .attrs = wusbhc_attrs,
236 };
237
238 /*
239  * Create a wusbhc instance
240  *
241  * NOTEs:
242  *
243  *  - assumes *wusbhc has been zeroed and wusbhc->usb_hcd has been
244  *    initialized but not added.
245  *
246  *  - fill out ports_max, mmcies_max and mmcie_{add,rm} before calling.
247  *
248  *  - fill out wusbhc->uwb_rc and refcount it before calling
249  *  - fill out the wusbhc->sec_modes array
250  */
251 int wusbhc_create(struct wusbhc *wusbhc)
252 {
253         int result = 0;
254
255         /* set defaults.  These can be overwritten using sysfs attributes. */
256         wusbhc->trust_timeout = WUSB_TRUST_TIMEOUT_MS;
257         wusbhc->phy_rate = UWB_PHY_RATE_INVALID - 1;
258         wusbhc->dnts_num_slots = 4;
259         wusbhc->dnts_interval = 2;
260         wusbhc->retry_count = WUSB_RETRY_COUNT_INFINITE;
261
262         mutex_init(&wusbhc->mutex);
263         result = wusbhc_mmcie_create(wusbhc);
264         if (result < 0)
265                 goto error_mmcie_create;
266         result = wusbhc_devconnect_create(wusbhc);
267         if (result < 0)
268                 goto error_devconnect_create;
269         result = wusbhc_rh_create(wusbhc);
270         if (result < 0)
271                 goto error_rh_create;
272         result = wusbhc_sec_create(wusbhc);
273         if (result < 0)
274                 goto error_sec_create;
275         return 0;
276
277 error_sec_create:
278         wusbhc_rh_destroy(wusbhc);
279 error_rh_create:
280         wusbhc_devconnect_destroy(wusbhc);
281 error_devconnect_create:
282         wusbhc_mmcie_destroy(wusbhc);
283 error_mmcie_create:
284         return result;
285 }
286 EXPORT_SYMBOL_GPL(wusbhc_create);
287
288 static inline struct kobject *wusbhc_kobj(struct wusbhc *wusbhc)
289 {
290         return &wusbhc->usb_hcd.self.controller->kobj;
291 }
292
293 /*
294  * Phase B of a wusbhc instance creation
295  *
296  * Creates fields that depend on wusbhc->usb_hcd having been
297  * added. This is where we create the sysfs files in
298  * /sys/class/usb_host/usb_hostX/.
299  *
300  * NOTE: Assumes wusbhc->usb_hcd has been already added by the upper
301  *       layer (hwahc or whci)
302  */
303 int wusbhc_b_create(struct wusbhc *wusbhc)
304 {
305         int result = 0;
306         struct device *dev = wusbhc->usb_hcd.self.controller;
307
308         result = sysfs_create_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group);
309         if (result < 0) {
310                 dev_err(dev, "Cannot register WUSBHC attributes: %d\n",
311                         result);
312                 goto error_create_attr_group;
313         }
314
315         return 0;
316 error_create_attr_group:
317         return result;
318 }
319 EXPORT_SYMBOL_GPL(wusbhc_b_create);
320
321 void wusbhc_b_destroy(struct wusbhc *wusbhc)
322 {
323         wusbhc_pal_unregister(wusbhc);
324         sysfs_remove_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group);
325 }
326 EXPORT_SYMBOL_GPL(wusbhc_b_destroy);
327
328 void wusbhc_destroy(struct wusbhc *wusbhc)
329 {
330         wusbhc_sec_destroy(wusbhc);
331         wusbhc_rh_destroy(wusbhc);
332         wusbhc_devconnect_destroy(wusbhc);
333         wusbhc_mmcie_destroy(wusbhc);
334 }
335 EXPORT_SYMBOL_GPL(wusbhc_destroy);
336
337 struct workqueue_struct *wusbd;
338 EXPORT_SYMBOL_GPL(wusbd);
339
340 /*
341  * WUSB Cluster ID allocation map
342  *
343  * Each WUSB bus in a channel is identified with a Cluster Id in the
344  * unauth address pace (WUSB1.0[4.3]). We take the range 0xe0 to 0xff
345  * (that's space for 31 WUSB controllers, as 0xff can't be taken). We
346  * start taking from 0xff, 0xfe, 0xfd... (hence the += or -= 0xff).
347  *
348  * For each one we taken, we pin it in the bitap
349  */
350 #define CLUSTER_IDS 32
351 static DECLARE_BITMAP(wusb_cluster_id_table, CLUSTER_IDS);
352 static DEFINE_SPINLOCK(wusb_cluster_ids_lock);
353
354 /*
355  * Get a WUSB Cluster ID
356  *
357  * Need to release with wusb_cluster_id_put() when done w/ it.
358  */
359 /* FIXME: coordinate with the choose_addres() from the USB stack */
360 /* we want to leave the top of the 128 range for cluster addresses and
361  * the bottom for device addresses (as we map them one on one with
362  * ports). */
363 u8 wusb_cluster_id_get(void)
364 {
365         u8 id;
366         spin_lock(&wusb_cluster_ids_lock);
367         id = find_first_zero_bit(wusb_cluster_id_table, CLUSTER_IDS);
368         if (id >= CLUSTER_IDS) {
369                 id = 0;
370                 goto out;
371         }
372         set_bit(id, wusb_cluster_id_table);
373         id = (u8) 0xff - id;
374 out:
375         spin_unlock(&wusb_cluster_ids_lock);
376         return id;
377
378 }
379 EXPORT_SYMBOL_GPL(wusb_cluster_id_get);
380
381 /*
382  * Release a WUSB Cluster ID
383  *
384  * Obtained it with wusb_cluster_id_get()
385  */
386 void wusb_cluster_id_put(u8 id)
387 {
388         id = 0xff - id;
389         BUG_ON(id >= CLUSTER_IDS);
390         spin_lock(&wusb_cluster_ids_lock);
391         WARN_ON(!test_bit(id, wusb_cluster_id_table));
392         clear_bit(id, wusb_cluster_id_table);
393         spin_unlock(&wusb_cluster_ids_lock);
394 }
395 EXPORT_SYMBOL_GPL(wusb_cluster_id_put);
396
397 /**
398  * wusbhc_giveback_urb - return an URB to the USB core
399  * @wusbhc: the host controller the URB is from.
400  * @urb:    the URB.
401  * @status: the URB's status.
402  *
403  * Return an URB to the USB core doing some additional WUSB specific
404  * processing.
405  *
406  *  - After a successful transfer, update the trust timeout timestamp
407  *    for the WUSB device.
408  *
409  *  - [WUSB] sections 4.13 and 7.5.1 specify the stop retransmission
410  *    condition for the WCONNECTACK_IE is that the host has observed
411  *    the associated device responding to a control transfer.
412  */
413 void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb, int status)
414 {
415         struct wusb_dev *wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc,
416                                         urb->dev);
417
418         if (status == 0 && wusb_dev) {
419                 wusb_dev->entry_ts = jiffies;
420
421                 /* wusbhc_devconnect_acked() can't be called from
422                    atomic context so defer it to a work queue. */
423                 if (!list_empty(&wusb_dev->cack_node))
424                         queue_work(wusbd, &wusb_dev->devconnect_acked_work);
425                 else
426                         wusb_dev_put(wusb_dev);
427         }
428
429         usb_hcd_giveback_urb(&wusbhc->usb_hcd, urb, status);
430 }
431 EXPORT_SYMBOL_GPL(wusbhc_giveback_urb);
432
433 /**
434  * wusbhc_reset_all - reset the HC hardware
435  * @wusbhc: the host controller to reset.
436  *
437  * Request a full hardware reset of the chip.  This will also reset
438  * the radio controller and any other PALs.
439  */
440 void wusbhc_reset_all(struct wusbhc *wusbhc)
441 {
442         if (wusbhc->uwb_rc)
443                 uwb_rc_reset_all(wusbhc->uwb_rc);
444 }
445 EXPORT_SYMBOL_GPL(wusbhc_reset_all);
446
447 static struct notifier_block wusb_usb_notifier = {
448         .notifier_call = wusb_usb_ncb,
449         .priority = INT_MAX     /* Need to be called first of all */
450 };
451
452 static int __init wusbcore_init(void)
453 {
454         int result;
455         result = wusb_crypto_init();
456         if (result < 0)
457                 goto error_crypto_init;
458         /* WQ is singlethread because we need to serialize notifications */
459         wusbd = create_singlethread_workqueue("wusbd");
460         if (wusbd == NULL) {
461                 result = -ENOMEM;
462                 printk(KERN_ERR "WUSB-core: Cannot create wusbd workqueue\n");
463                 goto error_wusbd_create;
464         }
465         usb_register_notify(&wusb_usb_notifier);
466         bitmap_zero(wusb_cluster_id_table, CLUSTER_IDS);
467         set_bit(0, wusb_cluster_id_table);      /* reserve Cluster ID 0xff */
468         return 0;
469
470 error_wusbd_create:
471         wusb_crypto_exit();
472 error_crypto_init:
473         return result;
474
475 }
476 module_init(wusbcore_init);
477
478 static void __exit wusbcore_exit(void)
479 {
480         clear_bit(0, wusb_cluster_id_table);
481         if (!bitmap_empty(wusb_cluster_id_table, CLUSTER_IDS)) {
482                 printk(KERN_ERR "BUG: WUSB Cluster IDs not released on exit: %*pb\n",
483                        CLUSTER_IDS, wusb_cluster_id_table);
484                 WARN_ON(1);
485         }
486         usb_unregister_notify(&wusb_usb_notifier);
487         destroy_workqueue(wusbd);
488         wusb_crypto_exit();
489 }
490 module_exit(wusbcore_exit);
491
492 MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>");
493 MODULE_DESCRIPTION("Wireless USB core");
494 MODULE_LICENSE("GPL");