Lines Matching refs:dum_hcd
366 * @dum_hcd: pointer to the dummy_hcd structure to update the link state for
371 static void set_link_state_by_speed(struct dummy_hcd *dum_hcd)
373 struct dummy *dum = dum_hcd->dum;
375 if (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3) {
376 if ((dum_hcd->port_status & USB_SS_PORT_STAT_POWER) == 0) {
377 dum_hcd->port_status = 0;
380 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
382 if ((dum_hcd->old_status &
384 dum_hcd->port_status |=
388 dum_hcd->port_status |= (USB_PORT_STAT_CONNECTION |
390 if ((dum_hcd->old_status &
392 dum_hcd->port_status |=
394 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) &&
395 (dum_hcd->port_status &
397 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
398 dum_hcd->active = 1;
401 if ((dum_hcd->port_status & USB_PORT_STAT_POWER) == 0) {
402 dum_hcd->port_status = 0;
405 dum_hcd->port_status &= ~(USB_PORT_STAT_CONNECTION |
410 if ((dum_hcd->old_status &
412 dum_hcd->port_status |=
415 dum_hcd->port_status |= USB_PORT_STAT_CONNECTION;
416 if ((dum_hcd->old_status &
418 dum_hcd->port_status |=
420 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0)
421 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
422 else if ((dum_hcd->port_status &
424 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
425 dum_hcd->active = 1;
431 static void set_link_state(struct dummy_hcd *dum_hcd)
434 struct dummy *dum = dum_hcd->dum;
437 dum_hcd->active = 0;
439 if ((dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 &&
441 (dummy_hcd_to_hcd(dum_hcd)->speed != HCD_USB3 &&
445 set_link_state_by_speed(dum_hcd);
446 power_bit = (dummy_hcd_to_hcd(dum_hcd)->speed == HCD_USB3 ?
449 if ((dum_hcd->port_status & USB_PORT_STAT_ENABLE) == 0 ||
450 dum_hcd->active)
451 dum_hcd->resuming = 0;
454 if ((dum_hcd->port_status & power_bit) == 0 ||
455 (dum_hcd->port_status & USB_PORT_STAT_RESET) != 0) {
457 dum_hcd->old_status & (~dum_hcd->port_status);
459 (~dum_hcd->old_status) & dum_hcd->port_status;
473 } else if (dum_hcd->active != dum_hcd->old_active &&
477 if (dum_hcd->old_active && dum->driver->suspend)
479 else if (!dum_hcd->old_active && dum->driver->resume)
485 dum_hcd->old_status = dum_hcd->port_status;
486 dum_hcd->old_active = dum_hcd->active;
505 struct dummy_hcd *dum_hcd;
518 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
519 if (!is_enabled(dum_hcd))
698 struct dummy_hcd *dum_hcd;
710 dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
711 if (!dum->driver || !is_enabled(dum_hcd))
855 struct dummy_hcd *dum_hcd;
857 dum_hcd = gadget_to_dummy_hcd(_gadget);
858 if (!(dum_hcd->dum->devstatus & ((1 << USB_DEVICE_B_HNP_ENABLE)
861 if ((dum_hcd->port_status & USB_PORT_STAT_CONNECTION) == 0)
863 if ((dum_hcd->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
864 dum_hcd->rh_state != DUMMY_RH_SUSPENDED)
870 dum_hcd->resuming = 1;
871 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
872 mod_timer(&dummy_hcd_to_hcd(dum_hcd)->rh_timer, dum_hcd->re_timeout);
899 struct dummy_hcd *dum_hcd;
904 dum_hcd = gadget_to_dummy_hcd(_gadget);
908 set_link_state(dum_hcd);
926 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
997 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
998 struct dummy *dum = dum_hcd->dum;
1008 dev_err(dummy_dev(dum_hcd), "Unsupported driver max speed %d\n",
1028 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g);
1029 struct dummy *dum = dum_hcd->dum;
1121 static void dummy_udc_pm(struct dummy *dum, struct dummy_hcd *dum_hcd,
1126 set_link_state(dum_hcd);
1133 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1136 dummy_udc_pm(dum, dum_hcd, 1);
1137 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1144 struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
1147 dummy_udc_pm(dum, dum_hcd, 0);
1148 usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
1186 static int dummy_ep_stream_en(struct dummy_hcd *dum_hcd, struct urb *urb)
1195 return (1 << index) & dum_hcd->stream_en_ep;
1205 static int get_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1210 max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1219 static void set_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
1225 max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
1233 dum_hcd->num_stream[usb_pipeendpoint(pipe)] = max_streams;
1236 static int dummy_validate_stream(struct dummy_hcd *dum_hcd, struct urb *urb)
1241 enabled = dummy_ep_stream_en(dum_hcd, urb);
1250 max_streams = get_max_streams_for_pipe(dum_hcd,
1253 dev_err(dummy_dev(dum_hcd), "Stream id %d is out of range.\n",
1266 struct dummy_hcd *dum_hcd;
1277 dum_hcd = hcd_to_dummy_hcd(hcd);
1278 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1280 rc = dummy_validate_stream(dum_hcd, urb);
1292 if (!dum_hcd->udev) {
1293 dum_hcd->udev = urb->dev;
1294 usb_get_dev(dum_hcd->udev);
1295 } else if (unlikely(dum_hcd->udev != urb->dev))
1296 dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n");
1298 list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
1300 if (!dum_hcd->next_frame_urbp)
1301 dum_hcd->next_frame_urbp = urbp;
1306 if (!hrtimer_active(&dum_hcd->timer))
1307 hrtimer_start(&dum_hcd->timer, ns_to_ktime(DUMMY_TIMER_INT_NSECS), HRTIMER_MODE_REL);
1310 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1316 struct dummy_hcd *dum_hcd;
1322 dum_hcd = hcd_to_dummy_hcd(hcd);
1323 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
1326 if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING &&
1327 !list_empty(&dum_hcd->urbp_list))
1328 hrtimer_start(&dum_hcd->timer, ns_to_ktime(0), HRTIMER_MODE_REL);
1330 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
1401 static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
1404 struct dummy *dum = dum_hcd->dum;
1415 if (dummy_ep_stream_en(dum_hcd, urb)) {
1565 #define is_active(dum_hcd) ((dum_hcd->port_status & \
1604 * @dum_hcd: pointer to dummy (the_controller)
1614 static int handle_control_request(struct dummy_hcd *dum_hcd, struct urb *urb,
1619 struct dummy *dum = dum_hcd->dum;
1652 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1659 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1666 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1699 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1706 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1713 if (dummy_hcd_to_hcd(dum_hcd)->speed ==
1784 struct dummy_hcd *dum_hcd = from_timer(dum_hcd, t, timer);
1785 struct dummy *dum = dum_hcd->dum;
1808 dev_err(dummy_dev(dum_hcd), "bogus device speed\n");
1816 if (!dum_hcd->udev) {
1817 dev_err(dummy_dev(dum_hcd),
1822 dum_hcd->next_frame_urbp = NULL;
1831 list_for_each_entry_safe(urbp, tmp, &dum_hcd->urbp_list, urbp_list) {
1839 if (urbp == dum_hcd->next_frame_urbp)
1845 else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
1859 dev_dbg(dummy_dev(dum_hcd),
1875 dev_dbg(dummy_dev(dum_hcd), "ep %s halted, urb %p\n",
1910 value = handle_control_request(dum_hcd, urb, &setup,
1971 total -= transfer(dum_hcd, urb, ep, limit, &status);
1985 usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
1987 usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
1993 if (list_empty(&dum_hcd->urbp_list)) {
1994 usb_put_dev(dum_hcd->udev);
1995 dum_hcd->udev = NULL;
1996 } else if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
1998 hrtimer_start(&dum_hcd->timer, ns_to_ktime(DUMMY_TIMER_INT_NSECS), HRTIMER_MODE_REL);
2017 struct dummy_hcd *dum_hcd;
2021 dum_hcd = hcd_to_dummy_hcd(hcd);
2023 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2027 if (dum_hcd->resuming && time_after_eq(jiffies, dum_hcd->re_timeout)) {
2028 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2029 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2030 set_link_state(dum_hcd);
2033 if ((dum_hcd->port_status & PORT_C_MASK) != 0) {
2035 dev_dbg(dummy_dev(dum_hcd), "port status 0x%08x has changes\n",
2036 dum_hcd->port_status);
2038 if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
2042 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2102 struct dummy_hcd *dum_hcd;
2109 dum_hcd = hcd_to_dummy_hcd(hcd);
2111 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2119 dev_dbg(dummy_dev(dum_hcd),
2124 if (dum_hcd->port_status & USB_PORT_STAT_SUSPEND) {
2126 dum_hcd->resuming = 1;
2127 dum_hcd->re_timeout = jiffies +
2132 dev_dbg(dummy_dev(dum_hcd), "power-off\n");
2134 dum_hcd->port_status &= ~USB_SS_PORT_STAT_POWER;
2136 dum_hcd->port_status &= ~USB_PORT_STAT_POWER;
2137 set_link_state(dum_hcd);
2148 dum_hcd->port_status &= ~(1 << wValue);
2149 set_link_state(dum_hcd);
2160 dev_dbg(dummy_dev(dum_hcd),
2192 if (dum_hcd->resuming &&
2193 time_after_eq(jiffies, dum_hcd->re_timeout)) {
2194 dum_hcd->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
2195 dum_hcd->port_status &= ~USB_PORT_STAT_SUSPEND;
2197 if ((dum_hcd->port_status & USB_PORT_STAT_RESET) != 0 &&
2198 time_after_eq(jiffies, dum_hcd->re_timeout)) {
2199 dum_hcd->port_status |= (USB_PORT_STAT_C_RESET << 16);
2200 dum_hcd->port_status &= ~USB_PORT_STAT_RESET;
2201 if (dum_hcd->dum->pullup) {
2202 dum_hcd->port_status |= USB_PORT_STAT_ENABLE;
2205 switch (dum_hcd->dum->gadget.speed) {
2207 dum_hcd->port_status |=
2211 dum_hcd->dum->gadget.ep0->
2213 dum_hcd->port_status |=
2222 set_link_state(dum_hcd);
2223 ((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
2224 ((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
2233 dev_dbg(dummy_dev(dum_hcd),
2247 dev_dbg(dummy_dev(dum_hcd),
2256 dev_dbg(dummy_dev(dum_hcd),
2261 if (dum_hcd->active) {
2262 dum_hcd->port_status |= USB_PORT_STAT_SUSPEND;
2267 set_link_state(dum_hcd);
2269 & dum_hcd->dum->devstatus) != 0)
2270 dev_dbg(dummy_dev(dum_hcd),
2276 dum_hcd->port_status |= USB_SS_PORT_STAT_POWER;
2278 dum_hcd->port_status |= USB_PORT_STAT_POWER;
2279 set_link_state(dum_hcd);
2284 dev_dbg(dummy_dev(dum_hcd),
2291 if (!(dum_hcd->port_status & USB_PORT_STAT_CONNECTION))
2295 dum_hcd->port_status =
2300 dum_hcd->port_status &= ~(USB_PORT_STAT_ENABLE
2303 dum_hcd->port_status |= USB_PORT_STAT_RESET;
2309 dum_hcd->dum->devstatus &=
2315 dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
2316 set_link_state(dum_hcd);
2333 dev_dbg(dummy_dev(dum_hcd),
2343 dev_dbg(dummy_dev(dum_hcd),
2350 dev_dbg(dummy_dev(dum_hcd),
2357 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2359 if ((dum_hcd->port_status & PORT_C_MASK) != 0)
2366 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2370 spin_lock_irq(&dum_hcd->dum->lock);
2371 dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
2372 set_link_state(dum_hcd);
2374 spin_unlock_irq(&dum_hcd->dum->lock);
2380 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2385 spin_lock_irq(&dum_hcd->dum->lock);
2389 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2390 set_link_state(dum_hcd);
2391 if (!list_empty(&dum_hcd->urbp_list))
2392 hrtimer_start(&dum_hcd->timer, ns_to_ktime(0), HRTIMER_MODE_REL);
2395 spin_unlock_irq(&dum_hcd->dum->lock);
2449 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2454 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2455 list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
2462 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2468 static int dummy_start_ss(struct dummy_hcd *dum_hcd)
2470 hrtimer_init(&dum_hcd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
2471 dum_hcd->timer.function = dummy_timer;
2472 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2473 dum_hcd->stream_en_ep = 0;
2474 INIT_LIST_HEAD(&dum_hcd->urbp_list);
2475 dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET_3;
2476 dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
2477 dummy_hcd_to_hcd(dum_hcd)->uses_new_polling = 1;
2479 dummy_hcd_to_hcd(dum_hcd)->self.otg_port = 1;
2484 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2489 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2497 return dummy_start_ss(dum_hcd);
2499 spin_lock_init(&dum_hcd->dum->lock);
2500 hrtimer_init(&dum_hcd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
2501 dum_hcd->timer.function = dummy_timer;
2502 dum_hcd->rh_state = DUMMY_RH_RUNNING;
2504 INIT_LIST_HEAD(&dum_hcd->urbp_list);
2515 return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2520 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2522 hrtimer_cancel(&dum_hcd->timer);
2523 device_remove_file(dummy_dev(dum_hcd), &dev_attr_urbs);
2524 dev_info(dummy_dev(dum_hcd), "stopped\n");
2564 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2574 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2577 if ((1 << index) & dum_hcd->stream_en_ep) {
2587 dev_dbg(dummy_dev(dum_hcd), "Ep 0x%x only supports %u "
2597 dum_hcd->stream_en_ep |= 1 << index;
2598 set_max_streams_for_pipe(dum_hcd,
2602 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2611 struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
2617 spin_lock_irqsave(&dum_hcd->dum->lock, flags);
2620 if (!((1 << index) & dum_hcd->stream_en_ep)) {
2628 dum_hcd->stream_en_ep &= ~(1 << index);
2629 set_max_streams_for_pipe(dum_hcd,
2634 spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
2731 struct dummy_hcd *dum_hcd;
2737 dum_hcd = hcd_to_dummy_hcd(hcd);
2738 if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {