2 * Wireless USB Host Controller
3 * sysfs glue, wusbcore module support and life cycle management
6 * Copyright (C) 2005-2006 Intel Corporation
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
24 * Creation/destruction of wusbhc is split in two parts; that that
25 * doesn't require the HCD to be added (wusbhc_{create,destroy}) and
26 * the one that requires (phase B, wusbhc_b_{create,destroy}).
28 * This is so because usb_add_hcd() will start the HC, and thus, all
29 * the HC specific stuff has to be already initialized (like sysfs
32 #include <linux/device.h>
33 #include <linux/module.h>
37 * Extract the wusbhc that corresponds to a USB Host Controller class device
39 * WARNING! Apply only if @dev is that of a
40 * wusbhc.usb_hcd.self->class_dev; otherwise, you loose.
42 static struct wusbhc
*usbhc_dev_to_wusbhc(struct device
*dev
)
44 struct usb_bus
*usb_bus
= dev_get_drvdata(dev
);
45 struct usb_hcd
*usb_hcd
= bus_to_hcd(usb_bus
);
46 return usb_hcd_to_wusbhc(usb_hcd
);
50 * Show & store the current WUSB trust timeout
52 * We don't do locking--it is an 'atomic' value.
54 * The units that we store/show are always MILLISECONDS. However, the
55 * value of trust_timeout is jiffies.
57 static ssize_t
wusb_trust_timeout_show(struct device
*dev
,
58 struct device_attribute
*attr
, char *buf
)
60 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
62 return scnprintf(buf
, PAGE_SIZE
, "%u\n", wusbhc
->trust_timeout
);
65 static ssize_t
wusb_trust_timeout_store(struct device
*dev
,
66 struct device_attribute
*attr
,
67 const char *buf
, size_t size
)
69 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
70 ssize_t result
= -ENOSYS
;
71 unsigned trust_timeout
;
73 result
= sscanf(buf
, "%u", &trust_timeout
);
78 wusbhc
->trust_timeout
= trust_timeout
;
79 cancel_delayed_work(&wusbhc
->keep_alive_timer
);
80 flush_workqueue(wusbd
);
81 queue_delayed_work(wusbd
, &wusbhc
->keep_alive_timer
,
82 (trust_timeout
* CONFIG_HZ
)/1000/2);
84 return result
< 0 ? result
: size
;
86 static DEVICE_ATTR(wusb_trust_timeout
, 0644, wusb_trust_timeout_show
,
87 wusb_trust_timeout_store
);
90 * Show the current WUSB CHID.
92 static ssize_t
wusb_chid_show(struct device
*dev
,
93 struct device_attribute
*attr
, char *buf
)
95 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
96 const struct wusb_ckhdid
*chid
;
99 if (wusbhc
->wuie_host_info
!= NULL
)
100 chid
= &wusbhc
->wuie_host_info
->CHID
;
102 chid
= &wusb_ckhdid_zero
;
104 result
+= ckhdid_printf(buf
, PAGE_SIZE
, chid
);
105 result
+= sprintf(buf
+ result
, "\n");
113 * - Write an all zeros CHID and it will stop the controller
114 * - Write a non-zero CHID and it will start it.
116 * See wusbhc_chid_set() for more info.
118 static ssize_t
wusb_chid_store(struct device
*dev
,
119 struct device_attribute
*attr
,
120 const char *buf
, size_t size
)
122 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
123 struct wusb_ckhdid chid
;
127 "%02hhx %02hhx %02hhx %02hhx "
128 "%02hhx %02hhx %02hhx %02hhx "
129 "%02hhx %02hhx %02hhx %02hhx "
130 "%02hhx %02hhx %02hhx %02hhx\n",
131 &chid
.data
[0] , &chid
.data
[1] ,
132 &chid
.data
[2] , &chid
.data
[3] ,
133 &chid
.data
[4] , &chid
.data
[5] ,
134 &chid
.data
[6] , &chid
.data
[7] ,
135 &chid
.data
[8] , &chid
.data
[9] ,
136 &chid
.data
[10], &chid
.data
[11],
137 &chid
.data
[12], &chid
.data
[13],
138 &chid
.data
[14], &chid
.data
[15]);
140 dev_err(dev
, "Unrecognized CHID (need 16 8-bit hex digits): "
141 "%d\n", (int)result
);
144 result
= wusbhc_chid_set(wusbhc
, &chid
);
145 return result
< 0 ? result
: size
;
147 static DEVICE_ATTR(wusb_chid
, 0644, wusb_chid_show
, wusb_chid_store
);
150 static ssize_t
wusb_phy_rate_show(struct device
*dev
,
151 struct device_attribute
*attr
,
154 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
156 return sprintf(buf
, "%d\n", wusbhc
->phy_rate
);
159 static ssize_t
wusb_phy_rate_store(struct device
*dev
,
160 struct device_attribute
*attr
,
161 const char *buf
, size_t size
)
163 struct wusbhc
*wusbhc
= usbhc_dev_to_wusbhc(dev
);
167 result
= sscanf(buf
, "%hhu", &phy_rate
);
170 if (phy_rate
>= UWB_PHY_RATE_INVALID
)
173 wusbhc
->phy_rate
= phy_rate
;
176 static DEVICE_ATTR(wusb_phy_rate
, 0644, wusb_phy_rate_show
, wusb_phy_rate_store
);
178 /* Group all the WUSBHC attributes */
179 static struct attribute
*wusbhc_attrs
[] = {
180 &dev_attr_wusb_trust_timeout
.attr
,
181 &dev_attr_wusb_chid
.attr
,
182 &dev_attr_wusb_phy_rate
.attr
,
186 static struct attribute_group wusbhc_attr_group
= {
187 .name
= NULL
, /* we want them in the same directory */
188 .attrs
= wusbhc_attrs
,
192 * Create a wusbhc instance
196 * - assumes *wusbhc has been zeroed and wusbhc->usb_hcd has been
197 * initialized but not added.
199 * - fill out ports_max, mmcies_max and mmcie_{add,rm} before calling.
201 * - fill out wusbhc->uwb_rc and refcount it before calling
202 * - fill out the wusbhc->sec_modes array
204 int wusbhc_create(struct wusbhc
*wusbhc
)
208 wusbhc
->trust_timeout
= WUSB_TRUST_TIMEOUT_MS
;
209 wusbhc
->phy_rate
= UWB_PHY_RATE_INVALID
- 1;
211 mutex_init(&wusbhc
->mutex
);
212 result
= wusbhc_mmcie_create(wusbhc
);
214 goto error_mmcie_create
;
215 result
= wusbhc_devconnect_create(wusbhc
);
217 goto error_devconnect_create
;
218 result
= wusbhc_rh_create(wusbhc
);
220 goto error_rh_create
;
221 result
= wusbhc_sec_create(wusbhc
);
223 goto error_sec_create
;
227 wusbhc_rh_destroy(wusbhc
);
229 wusbhc_devconnect_destroy(wusbhc
);
230 error_devconnect_create
:
231 wusbhc_mmcie_destroy(wusbhc
);
235 EXPORT_SYMBOL_GPL(wusbhc_create
);
237 static inline struct kobject
*wusbhc_kobj(struct wusbhc
*wusbhc
)
239 return &wusbhc
->usb_hcd
.self
.controller
->kobj
;
243 * Phase B of a wusbhc instance creation
245 * Creates fields that depend on wusbhc->usb_hcd having been
246 * added. This is where we create the sysfs files in
247 * /sys/class/usb_host/usb_hostX/.
249 * NOTE: Assumes wusbhc->usb_hcd has been already added by the upper
250 * layer (hwahc or whci)
252 int wusbhc_b_create(struct wusbhc
*wusbhc
)
255 struct device
*dev
= wusbhc
->usb_hcd
.self
.controller
;
257 result
= sysfs_create_group(wusbhc_kobj(wusbhc
), &wusbhc_attr_group
);
259 dev_err(dev
, "Cannot register WUSBHC attributes: %d\n", result
);
260 goto error_create_attr_group
;
263 result
= wusbhc_pal_register(wusbhc
);
265 goto error_pal_register
;
269 sysfs_remove_group(wusbhc_kobj(wusbhc
), &wusbhc_attr_group
);
270 error_create_attr_group
:
273 EXPORT_SYMBOL_GPL(wusbhc_b_create
);
275 void wusbhc_b_destroy(struct wusbhc
*wusbhc
)
277 wusbhc_pal_unregister(wusbhc
);
278 sysfs_remove_group(wusbhc_kobj(wusbhc
), &wusbhc_attr_group
);
280 EXPORT_SYMBOL_GPL(wusbhc_b_destroy
);
282 void wusbhc_destroy(struct wusbhc
*wusbhc
)
284 wusbhc_sec_destroy(wusbhc
);
285 wusbhc_rh_destroy(wusbhc
);
286 wusbhc_devconnect_destroy(wusbhc
);
287 wusbhc_mmcie_destroy(wusbhc
);
289 EXPORT_SYMBOL_GPL(wusbhc_destroy
);
291 struct workqueue_struct
*wusbd
;
292 EXPORT_SYMBOL_GPL(wusbd
);
295 * WUSB Cluster ID allocation map
297 * Each WUSB bus in a channel is identified with a Cluster Id in the
298 * unauth address pace (WUSB1.0[4.3]). We take the range 0xe0 to 0xff
299 * (that's space for 31 WUSB controllers, as 0xff can't be taken). We
300 * start taking from 0xff, 0xfe, 0xfd... (hence the += or -= 0xff).
302 * For each one we taken, we pin it in the bitap
304 #define CLUSTER_IDS 32
305 static DECLARE_BITMAP(wusb_cluster_id_table
, CLUSTER_IDS
);
306 static DEFINE_SPINLOCK(wusb_cluster_ids_lock
);
309 * Get a WUSB Cluster ID
311 * Need to release with wusb_cluster_id_put() when done w/ it.
313 /* we want to leave the top of the 128 range for cluster addresses and
314 * the bottom for device addresses (as we map them one on one with
316 u8
wusb_cluster_id_get(void)
319 spin_lock(&wusb_cluster_ids_lock
);
320 id
= find_first_zero_bit(wusb_cluster_id_table
, CLUSTER_IDS
);
321 if (id
> CLUSTER_IDS
) {
325 set_bit(id
, wusb_cluster_id_table
);
328 spin_unlock(&wusb_cluster_ids_lock
);
332 EXPORT_SYMBOL_GPL(wusb_cluster_id_get
);
335 * Release a WUSB Cluster ID
337 * Obtained it with wusb_cluster_id_get()
339 void wusb_cluster_id_put(u8 id
)
342 BUG_ON(id
>= CLUSTER_IDS
);
343 spin_lock(&wusb_cluster_ids_lock
);
344 WARN_ON(!test_bit(id
, wusb_cluster_id_table
));
345 clear_bit(id
, wusb_cluster_id_table
);
346 spin_unlock(&wusb_cluster_ids_lock
);
348 EXPORT_SYMBOL_GPL(wusb_cluster_id_put
);
351 * wusbhc_giveback_urb - return an URB to the USB core
352 * @wusbhc: the host controller the URB is from.
354 * @status: the URB's status.
356 * Return an URB to the USB core doing some additional WUSB specific
359 * - After a successful transfer, update the trust timeout timestamp
360 * for the WUSB device.
362 * - [WUSB] sections 4.13 and 7.5.1 specifies the stop retrasmittion
363 * condition for the WCONNECTACK_IE is that the host has observed
364 * the associated device responding to a control transfer.
366 void wusbhc_giveback_urb(struct wusbhc
*wusbhc
, struct urb
*urb
, int status
)
368 struct wusb_dev
*wusb_dev
= __wusb_dev_get_by_usb_dev(wusbhc
, urb
->dev
);
370 if (status
== 0 && wusb_dev
) {
371 wusb_dev
->entry_ts
= jiffies
;
373 /* wusbhc_devconnect_acked() can't be called from
374 atomic context so defer it to a work queue. */
375 if (!list_empty(&wusb_dev
->cack_node
))
376 queue_work(wusbd
, &wusb_dev
->devconnect_acked_work
);
378 wusb_dev_put(wusb_dev
);
381 usb_hcd_giveback_urb(&wusbhc
->usb_hcd
, urb
, status
);
383 EXPORT_SYMBOL_GPL(wusbhc_giveback_urb
);
386 * wusbhc_reset_all - reset the HC hardware
387 * @wusbhc: the host controller to reset.
389 * Request a full hardware reset of the chip. This will also reset
390 * the radio controller and any other PALs.
392 void wusbhc_reset_all(struct wusbhc
*wusbhc
)
394 uwb_rc_reset_all(wusbhc
->uwb_rc
);
396 EXPORT_SYMBOL_GPL(wusbhc_reset_all
);
398 static struct notifier_block wusb_usb_notifier
= {
399 .notifier_call
= wusb_usb_ncb
,
400 .priority
= INT_MAX
/* Need to be called first of all */
403 static int __init
wusbcore_init(void)
406 result
= wusb_crypto_init();
408 goto error_crypto_init
;
409 /* WQ is singlethread because we need to serialize notifications */
410 wusbd
= create_singlethread_workqueue("wusbd");
413 printk(KERN_ERR
"WUSB-core: Cannot create wusbd workqueue\n");
414 goto error_wusbd_create
;
416 usb_register_notify(&wusb_usb_notifier
);
417 bitmap_zero(wusb_cluster_id_table
, CLUSTER_IDS
);
418 set_bit(0, wusb_cluster_id_table
); /* reserve Cluster ID 0xff */
427 module_init(wusbcore_init
);
429 static void __exit
wusbcore_exit(void)
431 clear_bit(0, wusb_cluster_id_table
);
432 if (!bitmap_empty(wusb_cluster_id_table
, CLUSTER_IDS
)) {
434 bitmap_scnprintf(buf
, sizeof(buf
), wusb_cluster_id_table
,
436 printk(KERN_ERR
"BUG: WUSB Cluster IDs not released "
437 "on exit: %s\n", buf
);
440 usb_unregister_notify(&wusb_usb_notifier
);
441 destroy_workqueue(wusbd
);
444 module_exit(wusbcore_exit
);
446 MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>");
447 MODULE_DESCRIPTION("Wireless USB core");
448 MODULE_LICENSE("GPL");