Lines Matching refs:dum
192 static inline struct usb_hcd *dummy_to_hcd (struct dummy *dum)
194 return container_of((void *) dum, struct usb_hcd, hcd_priv);
197 static inline struct device *dummy_dev (struct dummy *dum)
199 return dummy_to_hcd(dum)->self.controller;
202 static inline struct device *udc_dev (struct dummy *dum)
204 return dum->gadget.dev.parent;
229 static void nuke (struct dummy *dum, struct dummy_ep *ep)
238 spin_unlock (&dum->lock);
240 spin_lock (&dum->lock);
246 stop_activity (struct dummy *dum)
251 dum->address = 0;
256 list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
257 nuke (dum, ep);
264 set_link_state (struct dummy *dum)
266 dum->active = 0;
267 if ((dum->port_status & USB_PORT_STAT_POWER) == 0)
268 dum->port_status = 0;
271 else if (!dum->pullup || dum->udc_suspended) {
272 dum->port_status &= ~(USB_PORT_STAT_CONNECTION |
277 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0)
278 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
280 dum->port_status |= USB_PORT_STAT_CONNECTION;
281 if ((dum->old_status & USB_PORT_STAT_CONNECTION) == 0)
282 dum->port_status |= (USB_PORT_STAT_C_CONNECTION << 16);
283 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0)
284 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
285 else if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
286 dum->rh_state != DUMMY_RH_SUSPENDED)
287 dum->active = 1;
290 if ((dum->port_status & USB_PORT_STAT_ENABLE) == 0 || dum->active)
291 dum->resuming = 0;
293 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0 ||
294 (dum->port_status & USB_PORT_STAT_RESET) != 0) {
295 if ((dum->old_status & USB_PORT_STAT_CONNECTION) != 0 &&
296 (dum->old_status & USB_PORT_STAT_RESET) == 0 &&
297 dum->driver) {
298 stop_activity (dum);
299 spin_unlock (&dum->lock);
300 dum->driver->disconnect (&dum->gadget);
301 spin_lock (&dum->lock);
303 } else if (dum->active != dum->old_active) {
304 if (dum->old_active && dum->driver->suspend) {
305 spin_unlock (&dum->lock);
306 dum->driver->suspend (&dum->gadget);
307 spin_lock (&dum->lock);
308 } else if (!dum->old_active && dum->driver->resume) {
309 spin_unlock (&dum->lock);
310 dum->driver->resume (&dum->gadget);
311 spin_lock (&dum->lock);
315 dum->old_status = dum->port_status;
316 dum->old_active = dum->active;
328 #define is_enabled(dum) \
329 (dum->port_status & USB_PORT_STAT_ENABLE)
334 struct dummy *dum;
343 dum = ep_to_dummy (ep);
344 if (!dum->driver || !is_enabled (dum))
363 switch (dum->gadget.speed) {
381 switch (dum->gadget.speed) {
401 switch (dum->gadget.speed) {
422 dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
447 struct dummy *dum;
454 dum = ep_to_dummy (ep);
456 spin_lock_irqsave (&dum->lock, flags);
459 nuke (dum, ep);
460 spin_unlock_irqrestore (&dum->lock, flags);
462 dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name);
509 struct dummy *dum;
520 dum = ep_to_dummy (ep);
521 if (!dum->driver || !is_enabled (dum))
527 spin_lock_irqsave (&dum->lock, flags);
531 list_empty (&dum->fifo_req.queue) &&
534 req = &dum->fifo_req;
536 req->req.buf = dum->fifo_buf;
537 memcpy (dum->fifo_buf, _req->buf, _req->length);
538 req->req.context = dum;
542 spin_unlock (&dum->lock);
546 spin_lock (&dum->lock);
549 spin_unlock_irqrestore (&dum->lock, flags);
560 struct dummy *dum;
568 dum = ep_to_dummy (ep);
570 if (!dum->driver)
574 spin_lock (&dum->lock);
583 spin_unlock (&dum->lock);
586 dev_dbg (udc_dev(dum),
599 struct dummy *dum;
604 dum = ep_to_dummy (ep);
605 if (!dum->driver)
660 struct dummy *dum;
662 dum = gadget_to_dummy (_gadget);
663 if (!(dum->devstatus & ( (1 << USB_DEVICE_B_HNP_ENABLE)
666 if ((dum->port_status & USB_PORT_STAT_CONNECTION) == 0)
668 if ((dum->port_status & USB_PORT_STAT_SUSPEND) == 0 &&
669 dum->rh_state != DUMMY_RH_SUSPENDED)
674 dum->resuming = 1;
675 dum->re_timeout = jiffies + msecs_to_jiffies(20);
676 mod_timer (&dummy_to_hcd (dum)->rh_timer, dum->re_timeout);
682 struct dummy *dum;
684 dum = gadget_to_dummy (_gadget);
686 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
688 dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
694 struct dummy *dum;
697 dum = gadget_to_dummy (_gadget);
698 spin_lock_irqsave (&dum->lock, flags);
699 dum->pullup = (value != 0);
700 set_link_state (dum);
701 spin_unlock_irqrestore (&dum->lock, flags);
703 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
720 struct dummy *dum = gadget_dev_to_dummy (dev);
722 if (!dum->driver || !dum->driver->function)
724 return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
747 struct dummy *dum = the_controller;
750 if (!dum)
752 if (dum->driver)
763 dum->devstatus = 0;
765 INIT_LIST_HEAD (&dum->gadget.ep_list);
767 struct dummy_ep *ep = &dum->ep [i];
773 list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
778 ep->gadget = &dum->gadget;
783 dum->gadget.ep0 = &dum->ep [0].ep;
784 dum->ep [0].ep.maxpacket = 64;
785 list_del_init (&dum->ep [0].ep.ep_list);
786 INIT_LIST_HEAD(&dum->fifo_req.queue);
789 dum->driver = driver;
790 dum->gadget.dev.driver = &driver->driver;
791 dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
793 retval = driver->bind(&dum->gadget);
795 dum->driver = NULL;
796 dum->gadget.dev.driver = NULL;
801 spin_lock_irq (&dum->lock);
802 dum->pullup = 1;
803 set_link_state (dum);
804 spin_unlock_irq (&dum->lock);
806 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
814 struct dummy *dum = the_controller;
817 if (!dum)
819 if (!driver || driver != dum->driver || !driver->unbind)
822 dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
825 spin_lock_irqsave (&dum->lock, flags);
826 dum->pullup = 0;
827 set_link_state (dum);
828 spin_unlock_irqrestore (&dum->lock, flags);
830 driver->unbind (&dum->gadget);
831 dum->gadget.dev.driver = NULL;
832 dum->driver = NULL;
834 spin_lock_irqsave (&dum->lock, flags);
835 dum->pullup = 0;
836 set_link_state (dum);
837 spin_unlock_irqrestore (&dum->lock, flags);
839 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
861 struct dummy *dum = gadget_dev_to_dummy (dev);
863 usb_put_hcd (dummy_to_hcd (dum));
868 struct dummy *dum = the_controller;
871 dum->gadget.name = gadget_name;
872 dum->gadget.ops = &dummy_ops;
873 dum->gadget.is_dualspeed = 1;
876 dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
878 dev_set_name(&dum->gadget.dev, "gadget");
879 dum->gadget.dev.parent = &pdev->dev;
880 dum->gadget.dev.release = dummy_gadget_release;
881 rc = device_register (&dum->gadget.dev);
885 usb_get_hcd (dummy_to_hcd (dum));
887 platform_set_drvdata (pdev, dum);
888 rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
890 device_unregister (&dum->gadget.dev);
896 struct dummy *dum = platform_get_drvdata (pdev);
899 device_remove_file (&dum->gadget.dev, &dev_attr_function);
900 device_unregister (&dum->gadget.dev);
906 struct dummy *dum = platform_get_drvdata(pdev);
909 spin_lock_irq (&dum->lock);
910 dum->udc_suspended = 1;
911 set_link_state (dum);
912 spin_unlock_irq (&dum->lock);
914 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
920 struct dummy *dum = platform_get_drvdata(pdev);
923 spin_lock_irq (&dum->lock);
924 dum->udc_suspended = 0;
925 set_link_state (dum);
926 spin_unlock_irq (&dum->lock);
928 usb_hcd_poll_rh_status (dummy_to_hcd (dum));
962 struct dummy *dum;
975 dum = hcd_to_dummy (hcd);
976 spin_lock_irqsave (&dum->lock, flags);
983 if (!dum->udev) {
984 dum->udev = urb->dev;
985 usb_get_dev (dum->udev);
986 } else if (unlikely (dum->udev != urb->dev))
987 dev_err (dummy_dev(dum), "usb_device address has changed!\n");
989 list_add_tail (&urbp->urbp_list, &dum->urbp_list);
995 if (!timer_pending (&dum->timer))
996 mod_timer (&dum->timer, jiffies + 1);
999 spin_unlock_irqrestore(&dum->lock, flags);
1005 struct dummy *dum;
1011 dum = hcd_to_dummy (hcd);
1012 spin_lock_irqsave (&dum->lock, flags);
1015 if (!rc && dum->rh_state != DUMMY_RH_RUNNING &&
1016 !list_empty(&dum->urbp_list))
1017 mod_timer (&dum->timer, jiffies);
1019 spin_unlock_irqrestore (&dum->lock, flags);
1025 transfer(struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit,
1123 spin_unlock (&dum->lock);
1125 spin_lock (&dum->lock);
1142 static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
1146 if (dum->gadget.speed == USB_SPEED_HIGH) {
1158 #define is_active(dum) ((dum->port_status & \
1163 static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
1167 if (!is_active (dum))
1170 return &dum->ep [0];
1172 struct dummy_ep *ep = &dum->ep [i];
1196 struct dummy *dum = (struct dummy *) _dum;
1203 switch (dum->gadget.speed) {
1214 dev_err (dummy_dev(dum), "bogus device speed\n");
1220 spin_lock_irqsave (&dum->lock, flags);
1222 if (!dum->udev) {
1223 dev_err (dummy_dev(dum),
1225 spin_unlock_irqrestore (&dum->lock, flags);
1232 dum->ep [i].already_seen = 0;
1236 list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) {
1247 else if (dum->rh_state != DUMMY_RH_RUNNING)
1258 ep = find_endpoint(dum, address);
1261 dev_dbg (dummy_dev(dum),
1271 if (ep == &dum->ep [0] && urb->error_count) {
1277 dev_dbg (dummy_dev(dum), "ep %s halted, urb %p\n",
1284 if (ep == &dum->ep [0] && ep->setup_stage) {
1299 dev_dbg (udc_dev(dum), "stale req = %p\n",
1302 spin_unlock (&dum->lock);
1304 spin_lock (&dum->lock);
1320 dum->address = w_value;
1322 dev_dbg (udc_dev(dum), "set_address = %d\n",
1333 dum->gadget.b_hnp_enable = 1;
1336 dum->gadget.a_hnp_support = 1;
1339 dum->gadget.a_alt_hnp_support
1346 dum->devstatus |=
1353 ep2 = find_endpoint (dum, w_index);
1367 dum->devstatus &= ~(1 <<
1378 ep2 = find_endpoint (dum, w_index);
1405 ep2 = find_endpoint (dum, w_index);
1414 dum->devstatus;
1432 spin_unlock (&dum->lock);
1433 value = dum->driver->setup (&dum->gadget,
1435 spin_lock (&dum->lock);
1447 dev_dbg (udc_dev(dum),
1461 limit = max (limit, periodic_bytes (dum, ep));
1466 limit = max (limit, periodic_bytes (dum, ep));
1473 total = transfer(dum, urb, ep, limit, &status);
1487 usb_hcd_unlink_urb_from_ep(dummy_to_hcd(dum), urb);
1488 spin_unlock (&dum->lock);
1489 usb_hcd_giveback_urb(dummy_to_hcd(dum), urb, status);
1490 spin_lock (&dum->lock);
1495 if (list_empty (&dum->urbp_list)) {
1496 usb_put_dev (dum->udev);
1497 dum->udev = NULL;
1498 } else if (dum->rh_state == DUMMY_RH_RUNNING) {
1500 mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1));
1503 spin_unlock_irqrestore (&dum->lock, flags);
1517 struct dummy *dum;
1521 dum = hcd_to_dummy (hcd);
1523 spin_lock_irqsave (&dum->lock, flags);
1527 if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) {
1528 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1529 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
1530 set_link_state (dum);
1533 if ((dum->port_status & PORT_C_MASK) != 0) {
1535 dev_dbg (dummy_dev(dum), "port status 0x%08x has changes\n",
1536 dum->port_status);
1538 if (dum->rh_state == DUMMY_RH_SUSPENDED)
1542 spin_unlock_irqrestore (&dum->lock, flags);
1566 struct dummy *dum;
1573 dum = hcd_to_dummy (hcd);
1574 spin_lock_irqsave (&dum->lock, flags);
1581 if (dum->port_status & USB_PORT_STAT_SUSPEND) {
1583 dum->resuming = 1;
1584 dum->re_timeout = jiffies +
1589 if (dum->port_status & USB_PORT_STAT_POWER)
1590 dev_dbg (dummy_dev(dum), "power-off\n");
1593 dum->port_status &= ~(1 << wValue);
1594 set_link_state (dum);
1610 if (dum->resuming &&
1611 time_after_eq (jiffies, dum->re_timeout)) {
1612 dum->port_status |= (USB_PORT_STAT_C_SUSPEND << 16);
1613 dum->port_status &= ~USB_PORT_STAT_SUSPEND;
1615 if ((dum->port_status & USB_PORT_STAT_RESET) != 0 &&
1616 time_after_eq (jiffies, dum->re_timeout)) {
1617 dum->port_status |= (USB_PORT_STAT_C_RESET << 16);
1618 dum->port_status &= ~USB_PORT_STAT_RESET;
1619 if (dum->pullup) {
1620 dum->port_status |= USB_PORT_STAT_ENABLE;
1622 dum->gadget.speed = dum->driver->speed;
1623 dum->gadget.ep0->maxpacket = 64;
1624 switch (dum->gadget.speed) {
1626 dum->port_status |=
1630 dum->gadget.ep0->maxpacket = 8;
1631 dum->port_status |=
1635 dum->gadget.speed = USB_SPEED_FULL;
1640 set_link_state (dum);
1641 ((__le16 *) buf)[0] = cpu_to_le16 (dum->port_status);
1642 ((__le16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16);
1650 if (dum->active) {
1651 dum->port_status |= USB_PORT_STAT_SUSPEND;
1656 set_link_state (dum);
1658 & dum->devstatus) != 0)
1659 dev_dbg (dummy_dev(dum),
1664 dum->port_status |= USB_PORT_STAT_POWER;
1665 set_link_state (dum);
1669 dum->port_status &= ~(USB_PORT_STAT_ENABLE
1672 dum->devstatus = 0;
1674 dum->re_timeout = jiffies + msecs_to_jiffies(50);
1677 if ((dum->port_status & USB_PORT_STAT_POWER) != 0) {
1678 dum->port_status |= (1 << wValue);
1679 set_link_state (dum);
1685 dev_dbg (dummy_dev(dum),
1692 spin_unlock_irqrestore (&dum->lock, flags);
1694 if ((dum->port_status & PORT_C_MASK) != 0)
1701 struct dummy *dum = hcd_to_dummy (hcd);
1705 spin_lock_irq (&dum->lock);
1706 dum->rh_state = DUMMY_RH_SUSPENDED;
1707 set_link_state (dum);
1709 spin_unlock_irq (&dum->lock);
1715 struct dummy *dum = hcd_to_dummy (hcd);
1720 spin_lock_irq (&dum->lock);
1724 dum->rh_state = DUMMY_RH_RUNNING;
1725 set_link_state (dum);
1726 if (!list_empty(&dum->urbp_list))
1727 mod_timer (&dum->timer, jiffies);
1730 spin_unlock_irq (&dum->lock);
1766 struct dummy *dum = hcd_to_dummy (hcd);
1771 spin_lock_irqsave (&dum->lock, flags);
1772 list_for_each_entry (urbp, &dum->urbp_list, urbp_list) {
1779 spin_unlock_irqrestore (&dum->lock, flags);
1787 struct dummy *dum;
1789 dum = hcd_to_dummy (hcd);
1796 spin_lock_init (&dum->lock);
1797 init_timer (&dum->timer);
1798 dum->timer.function = dummy_timer;
1799 dum->timer.data = (unsigned long) dum;
1800 dum->rh_state = DUMMY_RH_RUNNING;
1802 INIT_LIST_HEAD (&dum->urbp_list);
1812 return device_create_file (dummy_dev(dum), &dev_attr_urbs);
1817 struct dummy *dum;
1819 dum = hcd_to_dummy (hcd);
1821 device_remove_file (dummy_dev(dum), &dev_attr_urbs);
1822 usb_gadget_unregister_driver (dum->driver);
1823 dev_info (dummy_dev(dum), "stopped\n");
1888 struct dummy *dum;
1894 dum = hcd_to_dummy (hcd);
1895 if (dum->rh_state == DUMMY_RH_RUNNING) {