/linux-4.4.14/drivers/usb/wusbcore/ |
H A D | pal.c | 19 #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 D | mmc.c | 42 #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 D | reservation.c | 21 #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 D | wusbhc.c | 24 * 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 D | rh.c | 26 * 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 D | devconnect.c | 40 * 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 D | wusbhc.h | 25 * 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 D | dev-sysfs.c | 29 #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 D | security.c | 30 #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 D | Makefile | 17 wusbhc.o
|
H A D | wa-hc.c | 27 #include "wusbhc.h"
|
H A D | wa-hc.h | 91 struct wusbhc; 182 * FIXME: this needs to be layered up: a wusbhc layer (for sharing 192 struct wusbhc *wusb;
|
H A D | wa-xfer.c | 90 #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 D | wa-nep.c | 57 #include "wusbhc.h"
|
H A D | wa-rpipe.c | 65 #include "wusbhc.h"
|
/linux-4.4.14/drivers/usb/host/whci/ |
H A D | hcd.c | 23 #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 D | wusb.c | 21 #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 D | int.c | 21 #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 D | whcd.h | 35 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 D | hw.c | 22 #include "../../wusbcore/wusbhc.h" 100 struct wusbhc *wusbhc = &whc->wusbhc; whc_hw_error() local 103 wusbhc_reset_all(wusbhc); whc_hw_error()
|
H A D | debug.c | 24 #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 D | asl.c | 24 #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 D | pzl.c | 24 #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 D | qset.c | 24 #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 D | init.c | 23 #include "../../wusbcore/wusbhc.h"
|
/linux-4.4.14/drivers/usb/host/ |
H A D | hwa-hc.c | 63 #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 D | wusb-wa.h | 276 * it. In case you need to access it, use wusbhc->ports_max
|
/linux-4.4.14/include/linux/ |
H A D | uwb.h | 426 * @name: descriptive name for this PAL (wusbhc, wlp, etc.).
|