Searched refs:wusbhc (Results 1 - 28 of 28) sorted by relevance

/linux-4.4.14/drivers/usb/wusbcore/
H A Dpal.c19 #include "wusbhc.h"
23 struct wusbhc *wusbhc = container_of(pal, struct wusbhc, pal); wusbhc_channel_changed() local
25 dev_dbg(wusbhc->dev, "%s: channel = %d\n", __func__, channel); wusbhc_channel_changed()
27 wusbhc_stop(wusbhc); wusbhc_channel_changed()
29 wusbhc_start(wusbhc); wusbhc_channel_changed()
34 * @wusbhc: the WUSB HC
36 int wusbhc_pal_register(struct wusbhc *wusbhc) wusbhc_pal_register() argument
38 uwb_pal_init(&wusbhc->pal); wusbhc_pal_register()
40 wusbhc->pal.name = "wusbhc"; wusbhc_pal_register()
41 wusbhc->pal.device = wusbhc->usb_hcd.self.controller; wusbhc_pal_register()
42 wusbhc->pal.rc = wusbhc->uwb_rc; wusbhc_pal_register()
43 wusbhc->pal.channel_changed = wusbhc_channel_changed; wusbhc_pal_register()
45 return uwb_pal_register(&wusbhc->pal); wusbhc_pal_register()
50 * @wusbhc: the WUSB HC
52 void wusbhc_pal_unregister(struct wusbhc *wusbhc) wusbhc_pal_unregister() argument
54 if (wusbhc->uwb_rc) wusbhc_pal_unregister()
55 uwb_pal_unregister(&wusbhc->pal); wusbhc_pal_unregister()
H A Dmmc.c42 #include "wusbhc.h"
45 int wusbhc_mmcie_create(struct wusbhc *wusbhc) wusbhc_mmcie_create() argument
47 u8 mmcies = wusbhc->mmcies_max; wusbhc_mmcie_create()
48 wusbhc->mmcie = kcalloc(mmcies, sizeof(wusbhc->mmcie[0]), GFP_KERNEL); wusbhc_mmcie_create()
49 if (wusbhc->mmcie == NULL) wusbhc_mmcie_create()
51 mutex_init(&wusbhc->mmcie_mutex); wusbhc_mmcie_create()
56 void wusbhc_mmcie_destroy(struct wusbhc *wusbhc) wusbhc_mmcie_destroy() argument
58 kfree(wusbhc->mmcie); wusbhc_mmcie_destroy()
74 * Goes over the *whole* @wusbhc->mmcie array looking for (a) the
91 * NOTE: we can access wusbhc->wa_descr without locking because it is
94 int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt, wusbhc_mmcie_set() argument
101 mutex_lock(&wusbhc->mmcie_mutex); wusbhc_mmcie_set()
105 handle = wusbhc->mmcies_max - 1; wusbhc_mmcie_set()
108 dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x " wusbhc_mmcie_set()
115 for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) { wusbhc_mmcie_set()
116 if (wusbhc->mmcie[itr] == wuie) { wusbhc_mmcie_set()
120 if (wusbhc->mmcie[itr] == NULL) wusbhc_mmcie_set()
126 result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle, wusbhc_mmcie_set()
129 wusbhc->mmcie[handle] = wuie; wusbhc_mmcie_set()
131 mutex_unlock(&wusbhc->mmcie_mutex); wusbhc_mmcie_set()
141 void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie) wusbhc_mmcie_rm() argument
146 mutex_lock(&wusbhc->mmcie_mutex); wusbhc_mmcie_rm()
147 for (itr = 0; itr < wusbhc->mmcies_max; itr++) { wusbhc_mmcie_rm()
148 if (wusbhc->mmcie[itr] == wuie) { wusbhc_mmcie_rm()
153 mutex_unlock(&wusbhc->mmcie_mutex); wusbhc_mmcie_rm()
157 result = (wusbhc->mmcie_rm)(wusbhc, handle); wusbhc_mmcie_rm()
159 wusbhc->mmcie[itr] = NULL; wusbhc_mmcie_rm()
160 mutex_unlock(&wusbhc->mmcie_mutex); wusbhc_mmcie_rm()
164 static int wusbhc_mmc_start(struct wusbhc *wusbhc) wusbhc_mmc_start() argument
168 mutex_lock(&wusbhc->mutex); wusbhc_mmc_start()
169 ret = wusbhc->start(wusbhc); wusbhc_mmc_start()
171 wusbhc->active = 1; wusbhc_mmc_start()
172 mutex_unlock(&wusbhc->mutex); wusbhc_mmc_start()
177 static void wusbhc_mmc_stop(struct wusbhc *wusbhc) wusbhc_mmc_stop() argument
179 mutex_lock(&wusbhc->mutex); wusbhc_mmc_stop()
180 wusbhc->active = 0; wusbhc_mmc_stop()
181 wusbhc->stop(wusbhc, WUSB_CHANNEL_STOP_DELAY_MS); wusbhc_mmc_stop()
182 mutex_unlock(&wusbhc->mutex); wusbhc_mmc_stop()
187 * @wusbhc: the HC to start
192 int wusbhc_start(struct wusbhc *wusbhc) wusbhc_start() argument
195 struct device *dev = wusbhc->dev; wusbhc_start()
197 WARN_ON(wusbhc->wuie_host_info != NULL); wusbhc_start()
198 BUG_ON(wusbhc->uwb_rc == NULL); wusbhc_start()
200 result = wusbhc_rsv_establish(wusbhc); wusbhc_start()
207 result = wusbhc_devconnect_start(wusbhc); wusbhc_start()
214 result = wusbhc_sec_start(wusbhc); wusbhc_start()
221 result = wusbhc->set_num_dnts(wusbhc, wusbhc->dnts_interval, wusbhc_start()
222 wusbhc->dnts_num_slots); wusbhc_start()
227 result = wusbhc_mmc_start(wusbhc); wusbhc_start()
236 wusbhc_sec_stop(wusbhc); wusbhc_start()
239 wusbhc_devconnect_stop(wusbhc); wusbhc_start()
241 wusbhc_rsv_terminate(wusbhc); wusbhc_start()
248 * @wusbhc: the HC to stop
252 void wusbhc_stop(struct wusbhc *wusbhc) wusbhc_stop() argument
254 wusbhc_mmc_stop(wusbhc); wusbhc_stop()
255 wusbhc_sec_stop(wusbhc); wusbhc_stop()
256 wusbhc_devconnect_stop(wusbhc); wusbhc_stop()
257 wusbhc_rsv_terminate(wusbhc); wusbhc_stop()
267 int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid) wusbhc_chid_set() argument
274 mutex_lock(&wusbhc->mutex); wusbhc_chid_set()
276 if (wusbhc->active) { wusbhc_chid_set()
277 mutex_unlock(&wusbhc->mutex); wusbhc_chid_set()
280 wusbhc->chid = *chid; wusbhc_chid_set()
285 if ((chid) && (wusbhc->uwb_rc == NULL)) { wusbhc_chid_set()
286 wusbhc->uwb_rc = uwb_rc_get_by_grandpa(wusbhc->dev->parent); wusbhc_chid_set()
287 if (wusbhc->uwb_rc == NULL) { wusbhc_chid_set()
289 dev_err(wusbhc->dev, wusbhc_chid_set()
294 result = wusbhc_pal_register(wusbhc); wusbhc_chid_set()
296 dev_err(wusbhc->dev, "Cannot register as a UWB PAL\n"); wusbhc_chid_set()
300 mutex_unlock(&wusbhc->mutex); wusbhc_chid_set()
303 result = uwb_radio_start(&wusbhc->pal); wusbhc_chid_set()
304 else if (wusbhc->uwb_rc) wusbhc_chid_set()
305 uwb_radio_stop(&wusbhc->pal); wusbhc_chid_set()
310 uwb_rc_put(wusbhc->uwb_rc); wusbhc_chid_set()
311 wusbhc->uwb_rc = NULL; wusbhc_chid_set()
313 mutex_unlock(&wusbhc->mutex); wusbhc_chid_set()
H A Dreservation.c21 #include "wusbhc.h"
31 static int wusbhc_bwa_set(struct wusbhc *wusbhc, u8 stream, wusbhc_bwa_set() argument
36 return wusbhc->bwa_set(wusbhc, stream, mas); wusbhc_bwa_set()
49 struct wusbhc *wusbhc = rsv->pal_priv; wusbhc_rsv_complete_cb() local
50 struct device *dev = wusbhc->dev; wusbhc_rsv_complete_cb()
59 wusbhc_bwa_set(wusbhc, rsv->stream, &mas); wusbhc_rsv_complete_cb()
63 wusbhc_bwa_set(wusbhc, 0, NULL); wusbhc_rsv_complete_cb()
74 * @wusbhc: the WUSB HC requesting a bandwidth reservation
76 int wusbhc_rsv_establish(struct wusbhc *wusbhc) wusbhc_rsv_establish() argument
78 struct uwb_rc *rc = wusbhc->uwb_rc; wusbhc_rsv_establish()
86 rsv = uwb_rsv_create(rc, wusbhc_rsv_complete_cb, wusbhc); wusbhc_rsv_establish()
90 bcid.data[0] = wusbhc->cluster_id; wusbhc_rsv_establish()
103 wusbhc->rsv = rsv; wusbhc_rsv_establish()
112 * @wusbhc: the WUSB host whose reservation is to be terminated
114 void wusbhc_rsv_terminate(struct wusbhc *wusbhc) wusbhc_rsv_terminate() argument
116 if (wusbhc->rsv) { wusbhc_rsv_terminate()
117 uwb_rsv_terminate(wusbhc->rsv); wusbhc_rsv_terminate()
118 uwb_rsv_destroy(wusbhc->rsv); wusbhc_rsv_terminate()
119 wusbhc->rsv = NULL; wusbhc_rsv_terminate()
H A Dwusbhc.c24 * Creation/destruction of wusbhc is split in two parts; that that
34 #include "wusbhc.h"
37 * Extract the wusbhc that corresponds to a USB Host Controller class device
40 * wusbhc.usb_hcd.self->class_dev; otherwise, you loose.
42 static struct wusbhc *usbhc_dev_to_wusbhc(struct device *dev) usbhc_dev_to_wusbhc()
61 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_trust_timeout_show() local
63 return scnprintf(buf, PAGE_SIZE, "%u\n", wusbhc->trust_timeout); wusb_trust_timeout_show()
70 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_trust_timeout_store() local
79 wusbhc->trust_timeout = min_t(unsigned, trust_timeout, 500); wusb_trust_timeout_store()
80 cancel_delayed_work(&wusbhc->keep_alive_timer); wusb_trust_timeout_store()
82 queue_delayed_work(wusbd, &wusbhc->keep_alive_timer, wusb_trust_timeout_store()
83 msecs_to_jiffies(wusbhc->trust_timeout / 2)); wusb_trust_timeout_store()
96 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_chid_show() local
100 if (wusbhc->wuie_host_info != NULL) wusb_chid_show()
101 chid = &wusbhc->wuie_host_info->CHID; wusb_chid_show()
123 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_chid_store() local
145 result = wusbhc_chid_set(wusbhc, &chid); wusb_chid_store()
155 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_phy_rate_show() local
157 return sprintf(buf, "%d\n", wusbhc->phy_rate); wusb_phy_rate_show()
164 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_phy_rate_store() local
174 wusbhc->phy_rate = phy_rate; wusb_phy_rate_store()
184 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_dnts_show() local
187 wusbhc->dnts_num_slots, wusbhc->dnts_interval); wusb_dnts_show()
194 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_dnts_store() local
203 wusbhc->dnts_num_slots = num_slots; wusb_dnts_store()
204 wusbhc->dnts_interval = interval; wusb_dnts_store()
214 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_retry_count_show() local
216 return sprintf(buf, "%d\n", wusbhc->retry_count); wusb_retry_count_show()
223 struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev); wusb_retry_count_store() local
232 wusbhc->retry_count = max_t(uint8_t, retry_count, wusb_retry_count_store()
256 * Create a wusbhc instance
260 * - assumes *wusbhc has been zeroed and wusbhc->usb_hcd has been
265 * - fill out wusbhc->uwb_rc and refcount it before calling
266 * - fill out the wusbhc->sec_modes array
268 int wusbhc_create(struct wusbhc *wusbhc) wusbhc_create() argument
273 wusbhc->trust_timeout = WUSB_TRUST_TIMEOUT_MS; wusbhc_create()
274 wusbhc->phy_rate = UWB_PHY_RATE_INVALID - 1; wusbhc_create()
275 wusbhc->dnts_num_slots = 4; wusbhc_create()
276 wusbhc->dnts_interval = 2; wusbhc_create()
277 wusbhc->retry_count = WUSB_RETRY_COUNT_INFINITE; wusbhc_create()
279 mutex_init(&wusbhc->mutex); wusbhc_create()
280 result = wusbhc_mmcie_create(wusbhc); wusbhc_create()
283 result = wusbhc_devconnect_create(wusbhc); wusbhc_create()
286 result = wusbhc_rh_create(wusbhc); wusbhc_create()
289 result = wusbhc_sec_create(wusbhc); wusbhc_create()
295 wusbhc_rh_destroy(wusbhc); wusbhc_create()
297 wusbhc_devconnect_destroy(wusbhc); wusbhc_create()
299 wusbhc_mmcie_destroy(wusbhc); wusbhc_create()
305 static inline struct kobject *wusbhc_kobj(struct wusbhc *wusbhc) wusbhc_kobj() argument
307 return &wusbhc->usb_hcd.self.controller->kobj; wusbhc_kobj()
311 * Phase B of a wusbhc instance creation
313 * Creates fields that depend on wusbhc->usb_hcd having been
317 * NOTE: Assumes wusbhc->usb_hcd has been already added by the upper
320 int wusbhc_b_create(struct wusbhc *wusbhc) wusbhc_b_create() argument
323 struct device *dev = wusbhc->usb_hcd.self.controller; wusbhc_b_create()
325 result = sysfs_create_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group); wusbhc_b_create()
338 void wusbhc_b_destroy(struct wusbhc *wusbhc) wusbhc_b_destroy() argument
340 wusbhc_pal_unregister(wusbhc); wusbhc_b_destroy()
341 sysfs_remove_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group); wusbhc_b_destroy()
345 void wusbhc_destroy(struct wusbhc *wusbhc) wusbhc_destroy() argument
347 wusbhc_sec_destroy(wusbhc); wusbhc_destroy()
348 wusbhc_rh_destroy(wusbhc); wusbhc_destroy()
349 wusbhc_devconnect_destroy(wusbhc); wusbhc_destroy()
350 wusbhc_mmcie_destroy(wusbhc); wusbhc_destroy()
416 * @wusbhc: the host controller the URB is from.
430 void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb, int status) wusbhc_giveback_urb() argument
432 struct wusb_dev *wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, wusbhc_giveback_urb()
446 usb_hcd_giveback_urb(&wusbhc->usb_hcd, urb, status); wusbhc_giveback_urb()
452 * @wusbhc: the host controller to reset.
457 void wusbhc_reset_all(struct wusbhc *wusbhc) wusbhc_reset_all() argument
459 if (wusbhc->uwb_rc) wusbhc_reset_all()
460 uwb_rc_reset_all(wusbhc->uwb_rc); wusbhc_reset_all()
H A Drh.c26 * port we keep an state in @wusbhc->port[index] identical to the one
74 #include "wusbhc.h"
91 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
93 * Supposedly we are the only thread accesing @wusbhc->port; in any
97 * @port_idx refers to the wusbhc's port index, not the USB port number
99 static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx) wusbhc_rh_port_reset() argument
102 struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx); wusbhc_rh_port_reset()
114 result = wusb_dev_update_address(wusbhc, wusb_dev); wusbhc_rh_port_reset()
129 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
143 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); wusbhc_rh_status_data() local
148 size = DIV_ROUND_UP(wusbhc->ports_max + 1, 8); wusbhc_rh_status_data()
153 for (cnt = 0; cnt < wusbhc->ports_max; cnt++) { wusbhc_rh_status_data()
155 if (wusb_port_by_idx(wusbhc, cnt)->change) { wusbhc_rh_status_data()
172 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked
174 static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue, wusbhc_rh_get_hub_descr() argument
179 u16 temp = 1 + (wusbhc->ports_max / 8); wusbhc_rh_get_hub_descr()
186 descr->bNbrPorts = wusbhc->ports_max; wusbhc_rh_get_hub_descr()
204 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
208 static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature) wusbhc_rh_clear_hub_feat() argument
229 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
233 static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf, wusbhc_rh_get_hub_status() argument
244 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
246 static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature, wusbhc_rh_set_port_feat() argument
249 struct device *dev = wusbhc->dev; wusbhc_rh_set_port_feat()
251 if (port_idx > wusbhc->ports_max) wusbhc_rh_set_port_feat()
265 mutex_lock(&wusbhc->mutex); wusbhc_rh_set_port_feat()
266 wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER; wusbhc_rh_set_port_feat()
267 mutex_unlock(&wusbhc->mutex); wusbhc_rh_set_port_feat()
270 return wusbhc_rh_port_reset(wusbhc, port_idx); wusbhc_rh_set_port_feat()
288 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
290 static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature, wusbhc_rh_clear_port_feat() argument
294 struct device *dev = wusbhc->dev; wusbhc_rh_clear_port_feat()
296 if (port_idx > wusbhc->ports_max) wusbhc_rh_clear_port_feat()
299 mutex_lock(&wusbhc->mutex); wusbhc_rh_clear_port_feat()
306 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET; wusbhc_rh_clear_port_feat()
309 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION; wusbhc_rh_clear_port_feat()
312 __wusbhc_dev_disable(wusbhc, port_idx); wusbhc_rh_clear_port_feat()
315 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE; wusbhc_rh_clear_port_feat()
329 mutex_unlock(&wusbhc->mutex); wusbhc_rh_clear_port_feat()
337 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
339 static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx, wusbhc_rh_get_port_status() argument
344 if (port_idx > wusbhc->ports_max) wusbhc_rh_get_port_status()
347 mutex_lock(&wusbhc->mutex); wusbhc_rh_get_port_status()
348 buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status); wusbhc_rh_get_port_status()
349 buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change); wusbhc_rh_get_port_status()
350 mutex_unlock(&wusbhc->mutex); wusbhc_rh_get_port_status()
358 * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
364 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); wusbhc_rh_control() local
369 wusbhc, wValue, wIndex, wusbhc_rh_control()
373 result = wusbhc_rh_clear_hub_feat(wusbhc, wValue); wusbhc_rh_control()
376 result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength); wusbhc_rh_control()
380 result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8, wusbhc_rh_control()
384 result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8, wusbhc_rh_control()
388 result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1, wusbhc_rh_control()
394 dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) " wusbhc_rh_control()
395 "UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype, wusbhc_rh_control()
406 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); wusbhc_rh_start_port_reset() local
407 dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n", wusbhc_rh_start_port_reset()
408 __func__, usb_hcd, wusbhc, port_idx); wusbhc_rh_start_port_reset()
422 int wusbhc_rh_create(struct wusbhc *wusbhc) wusbhc_rh_create() argument
426 port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]); wusbhc_rh_create()
427 wusbhc->port = kzalloc(port_size, GFP_KERNEL); wusbhc_rh_create()
428 if (wusbhc->port == NULL) wusbhc_rh_create()
430 for (itr = 0; itr < wusbhc->ports_max; itr++) wusbhc_rh_create()
431 wusb_port_init(&wusbhc->port[itr]); wusbhc_rh_create()
437 void wusbhc_rh_destroy(struct wusbhc *wusbhc) wusbhc_rh_destroy() argument
439 kfree(wusbhc->port); wusbhc_rh_destroy()
H A Ddevconnect.c40 * wusbhc->port[port_number].wusb_dev), assigns an unauth address
80 * wusbhc->ca_list).
84 * Before the @wusbhc structure put()s the reference it owns for
86 * lock @wusbhc->mutex.
94 #include "wusbhc.h"
103 static struct wusb_dev *wusb_dev_alloc(struct wusbhc *wusbhc) wusb_dev_alloc() argument
111 wusb_dev->wusbhc = wusbhc; wusb_dev_alloc()
123 * Using the Connect-Ack list, fill out the @wusbhc Connect-Ack WUSB IE
126 * We just get the @wusbhc->ca_list and fill out the first four ones or
130 * @wusbhc->mutex must be taken
132 static void wusbhc_fill_cack_ie(struct wusbhc *wusbhc) wusbhc_fill_cack_ie() argument
138 cack_ie = &wusbhc->cack_ie; wusbhc_fill_cack_ie()
140 list_for_each_entry(dev_itr, &wusbhc->cack_list, cack_node) { wusbhc_fill_cack_ie()
160 * @wusbhc->mutex must be taken
162 static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc, wusbhc_cack_add() argument
166 struct device *dev = wusbhc->dev; wusbhc_cack_add()
173 list_for_each_entry(wusb_dev, &wusbhc->cack_list, cack_node) wusbhc_cack_add()
178 wusb_dev = wusb_dev_alloc(wusbhc); wusbhc_cack_add()
204 result = wusb_set_dev_addr(wusbhc, wusb_dev, dev_addr); wusbhc_cack_add()
209 list_add_tail(&wusb_dev->cack_node, &wusbhc->cack_list); wusbhc_cack_add()
210 wusbhc->cack_count++; wusbhc_cack_add()
211 wusbhc_fill_cack_ie(wusbhc); wusbhc_cack_add()
219 * @wusbhc->mutex must be taken
221 static void wusbhc_cack_rm(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) wusbhc_cack_rm() argument
224 wusbhc->cack_count--; wusbhc_cack_rm()
225 wusbhc_fill_cack_ie(wusbhc); wusbhc_cack_rm()
229 * @wusbhc->mutex must be taken */
231 void wusbhc_devconnect_acked(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) wusbhc_devconnect_acked() argument
233 wusbhc_cack_rm(wusbhc, wusb_dev); wusbhc_devconnect_acked()
234 if (wusbhc->cack_count) wusbhc_devconnect_acked()
235 wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->cack_ie.hdr); wusbhc_devconnect_acked()
237 wusbhc_mmcie_rm(wusbhc, &wusbhc->cack_ie.hdr); wusbhc_devconnect_acked()
244 struct wusbhc *wusbhc = wusb_dev->wusbhc; wusbhc_devconnect_acked_work() local
246 mutex_lock(&wusbhc->mutex); wusbhc_devconnect_acked_work()
247 wusbhc_devconnect_acked(wusbhc, wusb_dev); wusbhc_devconnect_acked_work()
248 mutex_unlock(&wusbhc->mutex); wusbhc_devconnect_acked_work()
277 * @wusbhc shall be referenced
280 void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc, wusbhc_devconnect_ack() argument
284 struct device *dev = wusbhc->dev; wusbhc_devconnect_ack()
289 mutex_lock(&wusbhc->mutex); wusbhc_devconnect_ack()
292 for (idx = 0; idx < wusbhc->ports_max; idx++) { wusbhc_devconnect_ack()
293 port = wusb_port_by_idx(wusbhc, idx); wusbhc_devconnect_ack()
299 for (idx = 0; idx < wusbhc->ports_max; idx++) { wusbhc_devconnect_ack()
300 port = wusb_port_by_idx(wusbhc, idx); wusbhc_devconnect_ack()
305 if (idx >= wusbhc->ports_max) { wusbhc_devconnect_ack()
308 wusbhc->ports_max, pr_cdid); wusbhc_devconnect_ack()
316 wusbhc->set_ptk(wusbhc, idx, 0, NULL, 0); wusbhc_devconnect_ack()
320 wusb_dev = wusbhc_cack_add(wusbhc, dnc, pr_cdid, idx); wusbhc_devconnect_ack()
323 result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->cack_ie.hdr); wusbhc_devconnect_ack()
338 mutex_unlock(&wusbhc->mutex); wusbhc_devconnect_ack()
353 * NOTE: @wusbhc->mutex is locked
358 static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc, __wusbhc_dev_disconnect() argument
368 dev_dbg(wusbhc->dev, "disconnecting device from port %d\n", wusb_dev->port_idx); __wusbhc_dev_disconnect()
378 if (wusbhc->active) __wusbhc_dev_disconnect()
379 wusbhc_gtk_rekey(wusbhc); __wusbhc_dev_disconnect()
401 * NOTE: @wusbhc->mutex is locked
403 static void __wusbhc_keep_alive(struct wusbhc *wusbhc) __wusbhc_keep_alive() argument
405 struct device *dev = wusbhc->dev; __wusbhc_keep_alive()
409 struct wuie_keep_alive *ie = &wusbhc->keep_alive_ie; __wusbhc_keep_alive()
415 keep_alives < WUIE_ELT_MAX && cnt < wusbhc->ports_max; __wusbhc_keep_alive()
417 unsigned tt = msecs_to_jiffies(wusbhc->trust_timeout); __wusbhc_keep_alive()
419 wusb_port = wusb_port_by_idx(wusbhc, cnt); __wusbhc_keep_alive()
430 __wusbhc_dev_disconnect(wusbhc, wusb_port); __wusbhc_keep_alive()
441 wusbhc_mmcie_set(wusbhc, 10, 5, &ie->hdr); __wusbhc_keep_alive()
443 wusbhc_mmcie_rm(wusbhc, &ie->hdr); __wusbhc_keep_alive()
452 struct wusbhc *wusbhc = container_of(dw, struct wusbhc, keep_alive_timer); wusbhc_keep_alive_run() local
454 mutex_lock(&wusbhc->mutex); wusbhc_keep_alive_run()
455 __wusbhc_keep_alive(wusbhc); wusbhc_keep_alive_run()
456 mutex_unlock(&wusbhc->mutex); wusbhc_keep_alive_run()
458 queue_delayed_work(wusbd, &wusbhc->keep_alive_timer, wusbhc_keep_alive_run()
459 msecs_to_jiffies(wusbhc->trust_timeout / 2)); wusbhc_keep_alive_run()
469 static struct wusb_dev *wusbhc_find_dev_by_addr(struct wusbhc *wusbhc, u8 addr) wusbhc_find_dev_by_addr() argument
478 if (port < 0 || port >= wusbhc->ports_max) wusbhc_find_dev_by_addr()
480 return wusb_port_by_idx(wusbhc, port)->wusb_dev; wusbhc_find_dev_by_addr()
484 for (p = 0; p < wusbhc->ports_max; p++) { wusbhc_find_dev_by_addr()
485 struct wusb_dev *wusb_dev = wusb_port_by_idx(wusbhc, p)->wusb_dev; wusbhc_find_dev_by_addr()
498 * @wusbhc shall be referenced and unlocked
500 static void wusbhc_handle_dn_alive(struct wusbhc *wusbhc, u8 srcaddr) wusbhc_handle_dn_alive() argument
504 mutex_lock(&wusbhc->mutex); wusbhc_handle_dn_alive()
505 wusb_dev = wusbhc_find_dev_by_addr(wusbhc, srcaddr); wusbhc_handle_dn_alive()
507 dev_dbg(wusbhc->dev, "ignoring DN_Alive from unconnected device %02x\n", wusbhc_handle_dn_alive()
511 __wusbhc_keep_alive(wusbhc); wusbhc_handle_dn_alive()
513 mutex_unlock(&wusbhc->mutex); wusbhc_handle_dn_alive()
519 * @wusbhc
526 * @wusbhc->mutex shall be held
528 static void wusbhc_handle_dn_connect(struct wusbhc *wusbhc, wusbhc_handle_dn_connect() argument
532 struct device *dev = wusbhc->dev; wusbhc_handle_dn_connect()
556 wusbhc_devconnect_ack(wusbhc, dnc, pr_cdid); wusbhc_handle_dn_connect()
564 * @wusbhc shall be referenced and unlocked
566 static void wusbhc_handle_dn_disconnect(struct wusbhc *wusbhc, u8 srcaddr) wusbhc_handle_dn_disconnect() argument
568 struct device *dev = wusbhc->dev; wusbhc_handle_dn_disconnect()
571 mutex_lock(&wusbhc->mutex); wusbhc_handle_dn_disconnect()
572 wusb_dev = wusbhc_find_dev_by_addr(wusbhc, srcaddr); wusbhc_handle_dn_disconnect()
579 __wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, wusbhc_handle_dn_disconnect()
582 mutex_unlock(&wusbhc->mutex); wusbhc_handle_dn_disconnect()
594 * @wusbhc shall be referenced
599 void wusbhc_handle_dn(struct wusbhc *wusbhc, u8 srcaddr, wusbhc_handle_dn() argument
602 struct device *dev = wusbhc->dev; wusbhc_handle_dn()
611 wusbhc_handle_dn_connect(wusbhc, dn_hdr, size); wusbhc_handle_dn()
614 wusbhc_handle_dn_alive(wusbhc, srcaddr); wusbhc_handle_dn()
617 wusbhc_handle_dn_disconnect(wusbhc, srcaddr); wusbhc_handle_dn()
637 * @wusbhc
638 * @port Fake port where the device is (wusbhc index, not USB port number).
651 * @wusbhc should be refcounted and locked
653 void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port_idx) __wusbhc_dev_disable() argument
656 struct device *dev = wusbhc->dev; __wusbhc_dev_disable()
660 wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev; __wusbhc_dev_disable()
667 __wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx)); __wusbhc_dev_disable()
675 result = wusbhc_mmcie_set(wusbhc, 0, 0, &ie->hdr); __wusbhc_dev_disable()
681 wusbhc_mmcie_rm(wusbhc, &ie->hdr); __wusbhc_dev_disable()
844 * Because all WUSB HCs are contained in a 'struct wusbhc', voila, we
845 * get the wusbhc for the device.
856 struct wusbhc *wusbhc; wusb_dev_add_ncb() local
865 wusbhc = wusbhc_get_by_usb_dev(usb_dev); wusb_dev_add_ncb()
866 if (wusbhc == NULL) wusb_dev_add_ncb()
868 mutex_lock(&wusbhc->mutex); wusb_dev_add_ncb()
869 wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev); wusb_dev_add_ncb()
871 mutex_unlock(&wusbhc->mutex); wusb_dev_add_ncb()
876 result = wusb_dev_sec_add(wusbhc, usb_dev, wusb_dev); wusb_dev_add_ncb()
887 result = wusb_dev_sysfs_add(wusbhc, usb_dev, wusb_dev); wusb_dev_add_ncb()
892 wusbhc_put(wusbhc); wusb_dev_add_ncb()
902 mutex_lock(&wusbhc->mutex); wusb_dev_add_ncb()
903 __wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx)); wusb_dev_add_ncb()
904 mutex_unlock(&wusbhc->mutex); wusb_dev_add_ncb()
961 * Return a referenced wusb_dev given a @wusbhc and @usb_dev
963 struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *wusbhc, __wusb_dev_get_by_usb_dev() argument
970 BUG_ON(port_idx > wusbhc->ports_max); __wusb_dev_get_by_usb_dev()
971 wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev; __wusb_dev_get_by_usb_dev()
993 int wusbhc_devconnect_create(struct wusbhc *wusbhc) wusbhc_devconnect_create() argument
995 wusbhc->keep_alive_ie.hdr.bIEIdentifier = WUIE_ID_KEEP_ALIVE; wusbhc_devconnect_create()
996 wusbhc->keep_alive_ie.hdr.bLength = sizeof(wusbhc->keep_alive_ie.hdr); wusbhc_devconnect_create()
997 INIT_DELAYED_WORK(&wusbhc->keep_alive_timer, wusbhc_keep_alive_run); wusbhc_devconnect_create()
999 wusbhc->cack_ie.hdr.bIEIdentifier = WUIE_ID_CONNECTACK; wusbhc_devconnect_create()
1000 wusbhc->cack_ie.hdr.bLength = sizeof(wusbhc->cack_ie.hdr); wusbhc_devconnect_create()
1001 INIT_LIST_HEAD(&wusbhc->cack_list); wusbhc_devconnect_create()
1009 void wusbhc_devconnect_destroy(struct wusbhc *wusbhc) wusbhc_devconnect_destroy() argument
1016 * @wusbhc: the WUSB HC
1023 int wusbhc_devconnect_start(struct wusbhc *wusbhc) wusbhc_devconnect_start() argument
1025 struct device *dev = wusbhc->dev; wusbhc_devconnect_start()
1035 hi->attributes = cpu_to_le16((wusbhc->rsv->stream << 3) | WUIE_HI_CAP_ALL); wusbhc_devconnect_start()
1036 hi->CHID = wusbhc->chid; wusbhc_devconnect_start()
1037 result = wusbhc_mmcie_set(wusbhc, 0, 0, &hi->hdr); wusbhc_devconnect_start()
1042 wusbhc->wuie_host_info = hi; wusbhc_devconnect_start()
1044 queue_delayed_work(wusbd, &wusbhc->keep_alive_timer, wusbhc_devconnect_start()
1045 msecs_to_jiffies(wusbhc->trust_timeout / 2)); wusbhc_devconnect_start()
1056 * @wusbhc: the WUSB HC
1061 void wusbhc_devconnect_stop(struct wusbhc *wusbhc) wusbhc_devconnect_stop() argument
1065 mutex_lock(&wusbhc->mutex); wusbhc_devconnect_stop()
1066 for (i = 0; i < wusbhc->ports_max; i++) { wusbhc_devconnect_stop()
1067 if (wusbhc->port[i].wusb_dev) wusbhc_devconnect_stop()
1068 __wusbhc_dev_disconnect(wusbhc, &wusbhc->port[i]); wusbhc_devconnect_stop()
1070 mutex_unlock(&wusbhc->mutex); wusbhc_devconnect_stop()
1072 cancel_delayed_work_sync(&wusbhc->keep_alive_timer); wusbhc_devconnect_stop()
1073 wusbhc_mmcie_rm(wusbhc, &wusbhc->wuie_host_info->hdr); wusbhc_devconnect_stop()
1074 kfree(wusbhc->wuie_host_info); wusbhc_devconnect_stop()
1075 wusbhc->wuie_host_info = NULL; wusbhc_devconnect_stop()
1080 * @wusbhc: the WUSB HC the device is connect to
1084 int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev, u8 addr) wusb_set_dev_addr() argument
1089 result = wusbhc->dev_info_set(wusbhc, wusb_dev); wusb_set_dev_addr()
1091 dev_err(wusbhc->dev, "device %d: failed to set device " wusb_set_dev_addr()
1094 dev_info(wusbhc->dev, "device %d: %s addr %u\n", wusb_set_dev_addr()
H A Dwusbhc.h25 * Controllers (struct wusbhc, embedding a struct usb_hcd) and is used
48 * that, creates a 'struct wusbhc' instance that handles all the
98 struct wusbhc *wusbhc; member in struct:wusb_dev
142 * caps), referred to in wusbhc->ports_max.
193 * both and make it easy. Call wusbhc->dev_info_set()
245 * calling usb_hcd_add(&wusbhc->usb_hcd).
247 struct wusbhc { struct
278 int (*start)(struct wusbhc *wusbhc);
279 void (*stop)(struct wusbhc *wusbhc, int delay);
280 int (*mmcie_add)(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
282 int (*mmcie_rm)(struct wusbhc *wusbhc, u8 handle);
283 int (*dev_info_set)(struct wusbhc *, struct wusb_dev *wusb_dev);
284 int (*bwa_set)(struct wusbhc *wusbhc, s8 stream_index,
286 int (*set_ptk)(struct wusbhc *wusbhc, u8 port_idx,
288 int (*set_gtk)(struct wusbhc *wusbhc,
290 int (*set_num_dnts)(struct wusbhc *wusbhc, u8 interval, u8 slots);
306 #define usb_hcd_to_wusbhc(u) container_of((u), struct wusbhc, usb_hcd)
309 extern int wusbhc_create(struct wusbhc *);
310 extern int wusbhc_b_create(struct wusbhc *);
311 extern void wusbhc_b_destroy(struct wusbhc *);
312 extern void wusbhc_destroy(struct wusbhc *);
313 extern int wusb_dev_sysfs_add(struct wusbhc *, struct usb_device *,
316 extern int wusbhc_sec_create(struct wusbhc *);
317 extern int wusbhc_sec_start(struct wusbhc *);
318 extern void wusbhc_sec_stop(struct wusbhc *);
319 extern void wusbhc_sec_destroy(struct wusbhc *);
320 extern void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb,
322 void wusbhc_reset_all(struct wusbhc *wusbhc);
324 int wusbhc_pal_register(struct wusbhc *wusbhc);
325 void wusbhc_pal_unregister(struct wusbhc *wusbhc);
344 * Increment the reference count on a wusbhc.
346 * @wusbhc's life cycle is identical to that of the underlying usb_hcd.
348 static inline struct wusbhc *wusbhc_get(struct wusbhc *wusbhc) wusbhc_get() argument
350 return usb_get_hcd(&wusbhc->usb_hcd) ? wusbhc : NULL; wusbhc_get()
354 * Return the wusbhc associated to a @usb_dev
358 * @returns: wusbhc for @usb_dev; NULL if the @usb_dev is being torn down.
363 static inline struct wusbhc *wusbhc_get_by_usb_dev(struct usb_device *usb_dev) wusbhc_get_by_usb_dev()
365 struct wusbhc *wusbhc = NULL; wusbhc_get_by_usb_dev() local
377 return wusbhc = usb_hcd_to_wusbhc(usb_hcd); wusbhc_get_by_usb_dev()
381 static inline void wusbhc_put(struct wusbhc *wusbhc) wusbhc_put() argument
383 usb_put_hcd(&wusbhc->usb_hcd); wusbhc_put()
386 int wusbhc_start(struct wusbhc *wusbhc);
387 void wusbhc_stop(struct wusbhc *wusbhc);
388 extern int wusbhc_chid_set(struct wusbhc *, const struct wusb_ckhdid *);
391 extern int wusbhc_devconnect_create(struct wusbhc *);
392 extern void wusbhc_devconnect_destroy(struct wusbhc *);
393 extern int wusbhc_devconnect_start(struct wusbhc *wusbhc);
394 extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
395 extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
397 extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port);
400 extern int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
404 extern int wusbhc_rh_create(struct wusbhc *);
405 extern void wusbhc_rh_destroy(struct wusbhc *);
412 extern int wusbhc_mmcie_create(struct wusbhc *);
413 extern void wusbhc_mmcie_destroy(struct wusbhc *);
414 extern int wusbhc_mmcie_set(struct wusbhc *, u8 interval, u8 repeat_cnt,
416 extern void wusbhc_mmcie_rm(struct wusbhc *, struct wuie_hdr *);
419 int wusbhc_rsv_establish(struct wusbhc *wusbhc);
420 void wusbhc_rsv_terminate(struct wusbhc *wusbhc);
434 extern int wusb_dev_sec_add(struct wusbhc *, struct usb_device *,
437 extern int wusb_dev_4way_handshake(struct wusbhc *, struct wusb_dev *,
439 void wusbhc_gtk_rekey(struct wusbhc *wusbhc);
440 int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev);
450 * NOTE: valid without locking as long as wusbhc is referenced (as the
454 static inline struct wusb_port *wusb_port_by_idx(struct wusbhc *wusbhc, wusb_port_by_idx() argument
457 return &wusbhc->port[port_idx]; wusb_port_by_idx()
473 extern struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *,
486 struct wusbhc *wusbhc; wusb_dev_get_by_usb_dev() local
488 wusbhc = wusbhc_get_by_usb_dev(usb_dev); wusb_dev_get_by_usb_dev()
489 if (wusbhc == NULL) wusb_dev_get_by_usb_dev()
491 mutex_lock(&wusbhc->mutex); wusb_dev_get_by_usb_dev()
492 wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev); wusb_dev_get_by_usb_dev()
493 mutex_unlock(&wusbhc->mutex); wusb_dev_get_by_usb_dev()
494 wusbhc_put(wusbhc); wusb_dev_get_by_usb_dev()
H A Ddev-sysfs.c29 #include "wusbhc.h"
36 struct wusbhc *wusbhc; wusb_disconnect_store() local
45 wusbhc = wusbhc_get_by_usb_dev(usb_dev); wusb_disconnect_store()
46 if (wusbhc == NULL) wusb_disconnect_store()
49 mutex_lock(&wusbhc->mutex); wusb_disconnect_store()
51 __wusbhc_dev_disable(wusbhc, port_idx); wusb_disconnect_store()
52 mutex_unlock(&wusbhc->mutex); wusb_disconnect_store()
53 wusbhc_put(wusbhc); wusb_disconnect_store()
80 struct wusbhc *wusbhc; wusb_ck_store() local
100 wusbhc = wusbhc_get_by_usb_dev(usb_dev); wusb_ck_store()
101 if (wusbhc == NULL) wusb_ck_store()
103 result = wusb_dev_4way_handshake(wusbhc, usb_dev->wusb_dev, &ck); wusb_ck_store()
105 wusbhc_put(wusbhc); wusb_ck_store()
122 int wusb_dev_sysfs_add(struct wusbhc *wusbhc, struct usb_device *usb_dev, wusb_dev_sysfs_add() argument
H A Dsecurity.c30 #include "wusbhc.h"
34 int wusbhc_sec_create(struct wusbhc *wusbhc) wusbhc_sec_create() argument
44 wusbhc->wq_security = create_singlethread_workqueue("wusbd_security"); wusbhc_sec_create()
45 if (wusbhc->wq_security == NULL) { wusbhc_sec_create()
50 wusbhc->gtk.descr.bLength = sizeof(wusbhc->gtk.descr) + wusbhc_sec_create()
51 sizeof(wusbhc->gtk.data); wusbhc_sec_create()
52 wusbhc->gtk.descr.bDescriptorType = USB_DT_KEY; wusbhc_sec_create()
53 wusbhc->gtk.descr.bReserved = 0; wusbhc_sec_create()
54 wusbhc->gtk_index = 0; wusbhc_sec_create()
56 INIT_WORK(&wusbhc->gtk_rekey_work, wusbhc_gtk_rekey_work); wusbhc_sec_create()
63 void wusbhc_sec_destroy(struct wusbhc *wusbhc) wusbhc_sec_destroy() argument
65 destroy_workqueue(wusbhc->wq_security); wusbhc_sec_destroy()
71 * @wusbhc: the WUSB host controller
81 static u32 wusbhc_next_tkid(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) wusbhc_next_tkid() argument
87 tkid = &wusbhc->gtk_tkid; wusbhc_next_tkid()
90 tkid = &wusb_port_by_idx(wusbhc, wusb_dev->port_idx)->ptk_tkid; wusbhc_next_tkid()
99 static void wusbhc_generate_gtk(struct wusbhc *wusbhc) wusbhc_generate_gtk() argument
101 const size_t key_size = sizeof(wusbhc->gtk.data); wusbhc_generate_gtk()
104 tkid = wusbhc_next_tkid(wusbhc, NULL); wusbhc_generate_gtk()
106 wusbhc->gtk.descr.tTKID[0] = (tkid >> 0) & 0xff; wusbhc_generate_gtk()
107 wusbhc->gtk.descr.tTKID[1] = (tkid >> 8) & 0xff; wusbhc_generate_gtk()
108 wusbhc->gtk.descr.tTKID[2] = (tkid >> 16) & 0xff; wusbhc_generate_gtk()
110 get_random_bytes(wusbhc->gtk.descr.bKeyData, key_size); wusbhc_generate_gtk()
115 * @wusbhc: the WUSB host controller
121 int wusbhc_sec_start(struct wusbhc *wusbhc) wusbhc_sec_start() argument
123 const size_t key_size = sizeof(wusbhc->gtk.data); wusbhc_sec_start()
126 wusbhc_generate_gtk(wusbhc); wusbhc_sec_start()
128 result = wusbhc->set_gtk(wusbhc, wusbhc->gtk_tkid, wusbhc_sec_start()
129 &wusbhc->gtk.descr.bKeyData, key_size); wusbhc_sec_start()
131 dev_err(wusbhc->dev, "cannot set GTK for the host: %d\n", wusbhc_sec_start()
139 * @wusbhc: the WUSB host controller
143 void wusbhc_sec_stop(struct wusbhc *wusbhc) wusbhc_sec_stop() argument
145 cancel_work_sync(&wusbhc->gtk_rekey_work); wusbhc_sec_stop()
198 static int wusb_dev_set_gtk(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) wusb_dev_set_gtk() argument
201 u8 key_index = wusb_key_index(wusbhc->gtk_index, wusb_dev_set_gtk()
209 &wusbhc->gtk.descr, wusbhc->gtk.descr.bLength, wusb_dev_set_gtk()
215 int wusb_dev_sec_add(struct wusbhc *wusbhc, wusb_dev_sec_add() argument
312 int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) wusb_dev_update_address() argument
329 result = wusb_set_dev_addr(wusbhc, wusb_dev, 0); wusb_dev_update_address()
346 result = wusb_set_dev_addr(wusbhc, wusb_dev, new_address); wusb_dev_update_address()
362 int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev, wusb_dev_4way_handshake() argument
388 tkid = wusbhc_next_tkid(wusbhc, wusb_dev); wusb_dev_4way_handshake()
446 ccm_n.src_addr = wusbhc->uwb_rc->uwb_dev.dev_addr; wusb_dev_4way_handshake()
497 result = wusbhc->set_ptk(wusbhc, wusb_dev->port_idx, tkid, wusb_dev_4way_handshake()
502 result = wusb_dev_set_gtk(wusbhc, wusb_dev); wusb_dev_4way_handshake()
511 result = wusb_dev_update_address(wusbhc, wusb_dev); wusb_dev_4way_handshake()
543 struct wusbhc *wusbhc = container_of(work, wusbhc_gtk_rekey_work() local
544 struct wusbhc, gtk_rekey_work); wusbhc_gtk_rekey_work()
545 size_t key_size = sizeof(wusbhc->gtk.data); wusbhc_gtk_rekey_work()
550 mutex_lock(&wusbhc->mutex); wusbhc_gtk_rekey_work()
552 wusbhc_generate_gtk(wusbhc); wusbhc_gtk_rekey_work()
554 wusbhc->gtk_index = (wusbhc->gtk_index + 1) % (WUSB_KEY_INDEX_MAX + 1); wusbhc_gtk_rekey_work()
556 * Save all connected devices on a list while holding wusbhc->mutex and wusbhc_gtk_rekey_work()
560 for (port_idx = 0; port_idx < wusbhc->ports_max; port_idx++) { wusbhc_gtk_rekey_work()
561 wusb_dev = wusbhc->port[port_idx].wusb_dev; wusbhc_gtk_rekey_work()
569 mutex_unlock(&wusbhc->mutex); wusbhc_gtk_rekey_work()
571 /* Submit the rekey requests without holding wusbhc->mutex. */ wusbhc_gtk_rekey_work()
579 if (wusb_dev_set_gtk(wusbhc, wusb_dev) < 0) { wusbhc_gtk_rekey_work()
588 mutex_lock(&wusbhc->mutex); wusbhc_gtk_rekey_work()
589 wusbhc->set_gtk(wusbhc, wusbhc->gtk_tkid, wusbhc_gtk_rekey_work()
590 &wusbhc->gtk.descr.bKeyData, key_size); wusbhc_gtk_rekey_work()
591 mutex_unlock(&wusbhc->mutex); wusbhc_gtk_rekey_work()
596 * @wusbhc: the WUSB host controller
605 void wusbhc_gtk_rekey(struct wusbhc *wusbhc) wusbhc_gtk_rekey() argument
610 * wusbhc->mutex since that is also taken in the urb_enqueue routine wusbhc_gtk_rekey()
614 queue_work(wusbhc->wq_security, &wusbhc->gtk_rekey_work); wusbhc_gtk_rekey()
H A DMakefile17 wusbhc.o
H A Dwa-hc.c27 #include "wusbhc.h"
H A Dwa-hc.h91 struct wusbhc;
182 * FIXME: this needs to be layered up: a wusbhc layer (for sharing
192 struct wusbhc *wusb;
H A Dwa-xfer.c90 #include "wusbhc.h"
1658 struct wusbhc *wusbhc = wa->wusb; wa_urb_enqueue_b() local
1669 mutex_lock(&wusbhc->mutex); /* get a WUSB dev */ wa_urb_enqueue_b()
1671 mutex_unlock(&wusbhc->mutex); wa_urb_enqueue_b()
1675 wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, urb->dev); wa_urb_enqueue_b()
1677 mutex_unlock(&wusbhc->mutex); wa_urb_enqueue_b()
1682 mutex_unlock(&wusbhc->mutex); wa_urb_enqueue_b()
H A Dwa-nep.c57 #include "wusbhc.h"
H A Dwa-rpipe.c65 #include "wusbhc.h"
/linux-4.4.14/drivers/usb/host/whci/
H A Dhcd.c23 #include "../../wusbcore/wusbhc.h"
46 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_start() local
47 struct whc *whc = wusbhc_to_whc(wusbhc); whc_start()
51 mutex_lock(&wusbhc->mutex); whc_start()
66 wusbhc->cluster_id = bcid; whc_start()
76 mutex_unlock(&wusbhc->mutex); whc_start()
90 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_stop() local
91 struct whc *whc = wusbhc_to_whc(wusbhc); whc_stop()
93 mutex_lock(&wusbhc->mutex); whc_stop()
102 wusb_cluster_id_put(wusbhc->cluster_id); whc_stop()
104 mutex_unlock(&wusbhc->mutex); whc_stop()
120 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_urb_enqueue() local
121 struct whc *whc = wusbhc_to_whc(wusbhc); whc_urb_enqueue()
147 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_urb_dequeue() local
148 struct whc *whc = wusbhc_to_whc(wusbhc); whc_urb_dequeue()
175 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_endpoint_disable() local
176 struct whc *whc = wusbhc_to_whc(wusbhc); whc_endpoint_disable()
193 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_endpoint_reset() local
194 struct whc *whc = wusbhc_to_whc(wusbhc); whc_endpoint_reset()
241 struct wusbhc *wusbhc; whc_probe() local
254 wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_probe()
255 whc = wusbhc_to_whc(wusbhc); whc_probe()
262 wusbhc->dev = dev; whc_probe()
263 wusbhc->uwb_rc = uwb_rc_get_by_grandpa(umc->dev.parent); whc_probe()
264 if (!wusbhc->uwb_rc) { whc_probe()
273 wusbhc->ports_max = USB_MAXCHILDREN; whc_probe()
275 wusbhc->ports_max = whc->n_devices; whc_probe()
276 wusbhc->mmcies_max = whc->n_mmc_ies; whc_probe()
277 wusbhc->start = whc_wusbhc_start; whc_probe()
278 wusbhc->stop = whc_wusbhc_stop; whc_probe()
279 wusbhc->mmcie_add = whc_mmcie_add; whc_probe()
280 wusbhc->mmcie_rm = whc_mmcie_rm; whc_probe()
281 wusbhc->dev_info_set = whc_dev_info_set; whc_probe()
282 wusbhc->bwa_set = whc_bwa_set; whc_probe()
283 wusbhc->set_num_dnts = whc_set_num_dnts; whc_probe()
284 wusbhc->set_ptk = whc_set_ptk; whc_probe()
285 wusbhc->set_gtk = whc_set_gtk; whc_probe()
287 ret = wusbhc_create(wusbhc); whc_probe()
298 ret = wusbhc_b_create(wusbhc); whc_probe()
311 wusbhc_destroy(wusbhc); whc_probe()
313 uwb_rc_put(wusbhc->uwb_rc); whc_probe()
324 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); whc_remove() local
325 struct whc *whc = wusbhc_to_whc(wusbhc); whc_remove()
329 wusbhc_b_destroy(wusbhc); whc_remove()
331 wusbhc_destroy(wusbhc); whc_remove()
332 uwb_rc_put(wusbhc->uwb_rc); whc_remove()
H A Dwusb.c21 #include "../../wusbcore/wusbhc.h"
43 int whc_wusbhc_start(struct wusbhc *wusbhc) whc_wusbhc_start() argument
45 struct whc *whc = wusbhc_to_whc(wusbhc); whc_wusbhc_start()
53 void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay) whc_wusbhc_stop() argument
55 struct whc *whc = wusbhc_to_whc(wusbhc); whc_wusbhc_stop()
69 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt, whc_mmcie_add() argument
72 struct whc *whc = wusbhc_to_whc(wusbhc); whc_mmcie_add()
83 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle) whc_mmcie_rm() argument
85 struct whc *whc = wusbhc_to_whc(wusbhc); whc_mmcie_rm()
93 int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm) whc_bwa_set() argument
95 struct whc *whc = wusbhc_to_whc(wusbhc); whc_bwa_set()
103 int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) whc_dev_info_set() argument
105 struct whc *whc = wusbhc_to_whc(wusbhc); whc_dev_info_set()
127 int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots) whc_set_num_dnts() argument
129 struct whc *whc = wusbhc_to_whc(wusbhc); whc_set_num_dnts()
171 int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, whc_set_ptk() argument
174 struct whc *whc = wusbhc_to_whc(wusbhc); whc_set_ptk()
202 int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid, whc_set_gtk() argument
205 struct whc *whc = wusbhc_to_whc(wusbhc); whc_set_gtk()
H A Dint.c21 #include "../../wusbcore/wusbhc.h"
33 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(hcd); whc_int_handler() local
34 struct whc *whc = wusbhc_to_whc(wusbhc); whc_int_handler()
69 struct wusbhc *wusbhc = &whc->wusbhc; process_dn_buf() local
75 wusbhc_handle_dn(wusbhc, dn->src_addr, process_dn_buf()
H A Dwhcd.h35 struct wusbhc wusbhc; member in struct:whc
78 #define wusbhc_to_whc(w) (container_of((w), struct whc, wusbhc))
152 int whc_wusbhc_start(struct wusbhc *wusbhc);
153 void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay);
154 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
156 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle);
157 int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm);
158 int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev);
159 int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots);
160 int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
162 int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid,
H A Dhw.c22 #include "../../wusbcore/wusbhc.h"
100 struct wusbhc *wusbhc = &whc->wusbhc; whc_hw_error() local
103 wusbhc_reset_all(wusbhc); whc_hw_error()
H A Ddebug.c24 #include "../../wusbcore/wusbhc.h"
174 if (whc->wusbhc.pal.debugfs_dir == NULL) whc_dbg_init()
182 whc->wusbhc.pal.debugfs_dir, whc, whc_dbg_init()
185 whc->wusbhc.pal.debugfs_dir, whc, whc_dbg_init()
188 whc->wusbhc.pal.debugfs_dir, whc, whc_dbg_init()
H A Dasl.c24 #include "../../wusbcore/wusbhc.h"
178 struct wusbhc *wusbhc = &whc->wusbhc; asl_update() local
181 mutex_lock(&wusbhc->mutex); asl_update()
182 if (wusbhc->active) { asl_update()
191 mutex_unlock(&wusbhc->mutex); asl_update()
273 err = usb_hcd_link_urb_to_ep(&whc->wusbhc.usb_hcd, urb); asl_urb_enqueue()
288 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb); asl_urb_enqueue()
319 ret = usb_hcd_check_unlink_urb(&whc->wusbhc.usb_hcd, urb, status); asl_urb_dequeue()
H A Dpzl.c24 #include "../../wusbcore/wusbhc.h"
191 struct wusbhc *wusbhc = &whc->wusbhc; pzl_update() local
194 mutex_lock(&wusbhc->mutex); pzl_update()
195 if (wusbhc->active) { pzl_update()
204 mutex_unlock(&wusbhc->mutex); pzl_update()
301 err = usb_hcd_link_urb_to_ep(&whc->wusbhc.usb_hcd, urb); pzl_urb_enqueue()
316 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb); pzl_urb_enqueue()
347 ret = usb_hcd_check_unlink_urb(&whc->wusbhc.usb_hcd, urb, status); pzl_urb_dequeue()
H A Dqset.c24 #include "../../wusbcore/wusbhc.h"
86 if (phy_rate > whc->wusbhc.phy_rate) qset_fill_qh()
87 phy_rate = whc->wusbhc.phy_rate; qset_fill_qh()
311 dma_unmap_single(whc->wusbhc.dev, dma_addr, qset_free_std()
319 dma_unmap_single(whc->wusbhc.dev, std->dma_addr, qset_free_std()
379 std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt, pl_len, DMA_TO_DEVICE); qset_fill_page_list()
380 if (dma_mapping_error(whc->wusbhc.dev, std->dma_addr)) { qset_fill_page_list()
540 std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt, qset_add_urb_sg()
710 struct wusbhc *wusbhc = &whc->wusbhc; qset_remove_urb() local
713 usb_hcd_unlink_urb_from_ep(&wusbhc->usb_hcd, urb); qset_remove_urb()
716 wusbhc_giveback_urb(wusbhc, urb, status); qset_remove_urb()
H A Dinit.c23 #include "../../wusbcore/wusbhc.h"
/linux-4.4.14/drivers/usb/host/
H A Dhwa-hc.c63 #include "../wusbcore/wusbhc.h"
66 struct wusbhc wusbhc; /* has to be 1st */ member in struct:hwahc
71 * FIXME should be wusbhc
79 struct wusbhc *wusbhc = &hwahc->wusbhc; __hwahc_set_cluster_id() local
93 wusbhc->cluster_id = cluster_id; __hwahc_set_cluster_id()
98 static int __hwahc_op_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots) __hwahc_op_set_num_dnts() argument
100 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_set_num_dnts()
120 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_reset() local
121 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_reset()
124 mutex_lock(&wusbhc->mutex); hwahc_op_reset()
137 mutex_unlock(&wusbhc->mutex); hwahc_op_reset()
148 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_start() local
149 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_start()
152 mutex_lock(&wusbhc->mutex); hwahc_op_start()
172 mutex_unlock(&wusbhc->mutex); hwahc_op_start()
176 wusb_cluster_id_put(wusbhc->cluster_id); hwahc_op_start()
190 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_stop() local
192 mutex_lock(&wusbhc->mutex); hwahc_op_stop()
193 wusb_cluster_id_put(wusbhc->cluster_id); hwahc_op_stop()
194 mutex_unlock(&wusbhc->mutex); hwahc_op_stop()
199 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_get_frame_number() local
200 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_get_frame_number()
214 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_urb_enqueue() local
215 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_urb_enqueue()
223 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_urb_dequeue() local
224 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_urb_dequeue()
237 struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_op_endpoint_disable() local
238 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_op_endpoint_disable()
243 static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc) __hwahc_op_wusbhc_start() argument
246 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_wusbhc_start()
307 static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc, int delay) __hwahc_op_wusbhc_stop() argument
309 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_wusbhc_stop()
333 static int __hwahc_op_bwa_set(struct wusbhc *wusbhc, s8 stream_index, __hwahc_op_bwa_set() argument
337 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_bwa_set()
380 static int __hwahc_op_mmcie_add(struct wusbhc *wusbhc, u8 interval, __hwahc_op_mmcie_add() argument
384 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_mmcie_add()
401 static int __hwahc_op_mmcie_rm(struct wusbhc *wusbhc, u8 handle) __hwahc_op_mmcie_rm() argument
403 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_mmcie_rm()
416 * @port_idx: Fake port to which device is connected (wusbhc index, not
419 static int __hwahc_op_dev_info_set(struct wusbhc *wusbhc, __hwahc_op_dev_info_set() argument
422 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_dev_info_set()
465 static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, __hwahc_dev_set_key() argument
470 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_dev_set_key()
506 static int __hwahc_op_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, __hwahc_op_set_ptk() argument
510 struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); __hwahc_op_set_ptk()
520 result = __hwahc_dev_set_key(wusbhc, port_idx, tkid, __hwahc_op_set_ptk()
524 encryption_value = wusbhc->ccm1_etd->bEncryptionValue; __hwahc_op_set_ptk()
526 /* FIXME: this should come from wusbhc->etd[UNSECURE].value */ __hwahc_op_set_ptk()
537 dev_err(wusbhc->dev, "Can't set host's WUSB encryption for " __hwahc_op_set_ptk()
539 wusb_et_name(wusbhc->ccm1_etd->bEncryptionType), __hwahc_op_set_ptk()
540 wusbhc->ccm1_etd->bEncryptionValue, result); __hwahc_op_set_ptk()
548 static int __hwahc_op_set_gtk(struct wusbhc *wusbhc, u32 tkid, __hwahc_op_set_gtk() argument
554 return __hwahc_dev_set_key(wusbhc, 0, tkid, key, key_size, key_idx); __hwahc_op_set_gtk()
639 struct wusbhc *wusbhc = &hwahc->wusbhc; hwahc_security_create() local
676 /* Walk over the sec descriptors and store CCM1's on wusbhc */ hwahc_security_create()
701 wusbhc->ccm1_etd = etd; hwahc_security_create()
704 if (wusbhc->ccm1_etd == NULL) { hwahc_security_create()
722 struct wusbhc *wusbhc = &hwahc->wusbhc; hwahc_create() local
728 wusbhc->dev = dev; hwahc_create()
731 wusbhc->uwb_rc = NULL; hwahc_create()
738 wusbhc->ports_max = USB_MAXCHILDREN; hwahc_create()
740 wusbhc->ports_max = wa->wa_descr->bNumPorts; hwahc_create()
742 wusbhc->mmcies_max = wa->wa_descr->bNumMMCIEs; hwahc_create()
743 wusbhc->start = __hwahc_op_wusbhc_start; hwahc_create()
744 wusbhc->stop = __hwahc_op_wusbhc_stop; hwahc_create()
745 wusbhc->mmcie_add = __hwahc_op_mmcie_add; hwahc_create()
746 wusbhc->mmcie_rm = __hwahc_op_mmcie_rm; hwahc_create()
747 wusbhc->dev_info_set = __hwahc_op_dev_info_set; hwahc_create()
748 wusbhc->bwa_set = __hwahc_op_bwa_set; hwahc_create()
749 wusbhc->set_num_dnts = __hwahc_op_set_num_dnts; hwahc_create()
750 wusbhc->set_ptk = __hwahc_op_set_ptk; hwahc_create()
751 wusbhc->set_gtk = __hwahc_op_set_gtk; hwahc_create()
757 wa->wusb = wusbhc; /* FIXME: ugly, need to fix */ hwahc_create()
758 result = wusbhc_create(&hwahc->wusbhc); hwahc_create()
769 wusbhc_destroy(&hwahc->wusbhc); hwahc_create()
781 struct wusbhc *wusbhc = &hwahc->wusbhc; hwahc_destroy() local
783 mutex_lock(&wusbhc->mutex); hwahc_destroy()
785 wusbhc_destroy(&hwahc->wusbhc); hwahc_destroy()
787 hwahc->wusbhc.dev = NULL; hwahc_destroy()
788 uwb_rc_put(wusbhc->uwb_rc); hwahc_destroy()
791 mutex_unlock(&wusbhc->mutex); hwahc_destroy()
804 struct wusbhc *wusbhc; hwahc_probe() local
816 wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_probe()
817 hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_probe()
830 result = wusbhc_b_create(&hwahc->wusbhc); hwahc_probe()
850 struct wusbhc *wusbhc; hwahc_disconnect() local
854 wusbhc = usb_hcd_to_wusbhc(usb_hcd); hwahc_disconnect()
855 hwahc = container_of(wusbhc, struct hwahc, wusbhc); hwahc_disconnect()
857 wusbhc_b_destroy(&hwahc->wusbhc); hwahc_disconnect()
/linux-4.4.14/include/linux/usb/
H A Dwusb-wa.h276 * it. In case you need to access it, use wusbhc->ports_max
/linux-4.4.14/include/linux/
H A Duwb.h426 * @name: descriptive name for this PAL (wusbhc, wlp, etc.).

Completed in 420 milliseconds