Lines Matching refs:ps
58 /* Mutual exclusion for ps->list in resume vs. release and remove */
91 struct usb_dev_state *ps;
96 struct usb_dev_state *ps;
180 static int connected(struct usb_dev_state *ps)
182 return (!list_empty(&ps->list) &&
183 ps->dev->state != USB_STATE_NOTATTACHED);
188 struct usb_dev_state *ps = usbm->ps;
189 struct usb_hcd *hcd = bus_to_hcd(ps->dev->bus);
192 spin_lock_irqsave(&ps->lock, flags);
196 spin_unlock_irqrestore(&ps->lock, flags);
204 spin_unlock_irqrestore(&ps->lock, flags);
213 spin_lock_irqsave(&usbm->ps->lock, flags);
215 spin_unlock_irqrestore(&usbm->ps->lock, flags);
233 struct usb_dev_state *ps = file->private_data;
234 struct usb_hcd *hcd = bus_to_hcd(ps->dev->bus);
263 usbm->ps = ps;
294 spin_lock_irqsave(&ps->lock, flags);
295 list_add_tail(&usbm->memlist, &ps->memory_list);
296 spin_unlock_irqrestore(&ps->lock, flags);
311 struct usb_dev_state *ps = file->private_data;
312 struct usb_device *dev = ps->dev;
320 if (!connected(ps)) {
439 struct usb_dev_state *ps = as->ps;
442 spin_lock_irqsave(&ps->lock, flags);
443 list_add_tail(&as->asynclist, &ps->async_pending);
444 spin_unlock_irqrestore(&ps->lock, flags);
449 struct usb_dev_state *ps = as->ps;
452 spin_lock_irqsave(&ps->lock, flags);
454 spin_unlock_irqrestore(&ps->lock, flags);
457 static struct async *async_getcompleted(struct usb_dev_state *ps)
462 spin_lock_irqsave(&ps->lock, flags);
463 if (!list_empty(&ps->async_completed)) {
464 as = list_entry(ps->async_completed.next, struct async,
468 spin_unlock_irqrestore(&ps->lock, flags);
472 static struct async *async_getpending(struct usb_dev_state *ps,
477 list_for_each_entry(as, &ps->async_pending, asynclist)
582 static void cancel_bulk_urbs(struct usb_dev_state *ps, unsigned bulk_addr)
583 __releases(ps->lock)
584 __acquires(ps->lock)
594 list_for_each_entry(as, &ps->async_pending, asynclist) {
602 ps->disabled_bulk_eps |= (1 << bulk_addr);
606 list_for_each_entry_reverse(as, &ps->async_pending, asynclist) {
611 spin_unlock(&ps->lock); /* Allow completions */
614 spin_lock(&ps->lock);
623 struct usb_dev_state *ps = as->ps;
630 spin_lock_irqsave(&ps->lock, flags);
631 list_move_tail(&as->asynclist, &ps->async_completed);
648 cancel_bulk_urbs(ps, as->bulk_addr);
650 wake_up(&ps->wait);
651 spin_unlock_irqrestore(&ps->lock, flags);
660 static void destroy_async(struct usb_dev_state *ps, struct list_head *list)
666 spin_lock_irqsave(&ps->lock, flags);
674 spin_unlock_irqrestore(&ps->lock, flags);
677 spin_lock_irqsave(&ps->lock, flags);
679 spin_unlock_irqrestore(&ps->lock, flags);
682 static void destroy_async_on_interface(struct usb_dev_state *ps,
689 spin_lock_irqsave(&ps->lock, flags);
690 list_for_each_safe(p, q, &ps->async_pending)
693 spin_unlock_irqrestore(&ps->lock, flags);
694 destroy_async(ps, &hitlist);
697 static void destroy_all_async(struct usb_dev_state *ps)
699 destroy_async(ps, &ps->async_pending);
716 struct usb_dev_state *ps = usb_get_intfdata(intf);
719 if (!ps)
726 if (likely(ifnum < 8*sizeof(ps->ifclaimed)))
727 clear_bit(ifnum, &ps->ifclaimed);
735 destroy_async_on_interface(ps, ifnum);
758 struct usb_dev_state *ps;
762 list_for_each_entry(ps, &udev->filelist, list) {
763 WRITE_ONCE(ps->not_yet_resumed, 0);
764 wake_up_all(&ps->wait_for_resume);
779 static int claimintf(struct usb_dev_state *ps, unsigned int ifnum)
781 struct usb_device *dev = ps->dev;
785 if (ifnum >= 8*sizeof(ps->ifclaimed))
788 if (test_bit(ifnum, &ps->ifclaimed))
791 if (ps->privileges_dropped &&
792 !test_bit(ifnum, &ps->interface_allowed_mask))
804 err = usb_driver_claim_interface(&usbfs_driver, intf, ps);
808 set_bit(ifnum, &ps->ifclaimed);
812 static int releaseintf(struct usb_dev_state *ps, unsigned int ifnum)
819 if (ifnum >= 8*sizeof(ps->ifclaimed))
821 dev = ps->dev;
825 else if (test_and_clear_bit(ifnum, &ps->ifclaimed)) {
838 static int checkintf(struct usb_dev_state *ps, unsigned int ifnum)
840 if (ps->dev->state != USB_STATE_CONFIGURED)
842 if (ifnum >= 8*sizeof(ps->ifclaimed))
844 if (test_bit(ifnum, &ps->ifclaimed))
847 dev_warn(&ps->dev->dev, "usbfs: process %d (%s) did not claim "
850 return claimintf(ps, ifnum);
878 static int check_ctrlrecip(struct usb_dev_state *ps, unsigned int requesttype,
884 if (ps->dev->state != USB_STATE_UNAUTHENTICATED
885 && ps->dev->state != USB_STATE_ADDRESS
886 && ps->dev->state != USB_STATE_CONFIGURED)
897 alt_setting = usb_find_alt_setting(ps->dev->actconfig,
909 ret = findintfep(ps->dev, index);
919 ret = findintfep(ps->dev, index ^ 0x80);
921 dev_info(&ps->dev->dev,
927 ret = checkintf(ps, ret);
931 ret = checkintf(ps, index);
946 static int parse_usbdevfs_streams(struct usb_dev_state *ps,
979 eps[i] = ep_to_host_endpoint(ps->dev, ep);
986 ifnum = findintfep(ps->dev, ep);
993 ret = checkintf(ps, ifnum);
996 intf = usb_ifnum_to_if(ps->dev, ifnum);
1035 struct usb_dev_state *ps;
1039 ps = kzalloc(sizeof(struct usb_dev_state), GFP_KERNEL);
1040 if (!ps)
1059 ps->dev = dev;
1060 ps->file = file;
1061 ps->interface_allowed_mask = 0xFFFFFFFF; /* 32 bits */
1062 spin_lock_init(&ps->lock);
1063 INIT_LIST_HEAD(&ps->list);
1064 INIT_LIST_HEAD(&ps->async_pending);
1065 INIT_LIST_HEAD(&ps->async_completed);
1066 INIT_LIST_HEAD(&ps->memory_list);
1067 init_waitqueue_head(&ps->wait);
1068 init_waitqueue_head(&ps->wait_for_resume);
1069 ps->disc_pid = get_pid(task_pid(current));
1070 ps->cred = get_current_cred();
1074 list_add_tail(&ps->list, &dev->filelist);
1075 file->private_data = ps;
1085 kfree(ps);
1091 struct usb_dev_state *ps = file->private_data;
1092 struct usb_device *dev = ps->dev;
1097 usb_hub_release_all_ports(dev, ps);
1101 list_del_init(&ps->list);
1104 for (ifnum = 0; ps->ifclaimed && ifnum < 8*sizeof(ps->ifclaimed);
1106 if (test_bit(ifnum, &ps->ifclaimed))
1107 releaseintf(ps, ifnum);
1109 destroy_all_async(ps);
1110 if (!ps->suspend_allowed)
1114 put_pid(ps->disc_pid);
1115 put_cred(ps->cred);
1117 as = async_getcompleted(ps);
1120 as = async_getcompleted(ps);
1123 kfree(ps);
1166 static int do_proc_control(struct usb_dev_state *ps,
1169 struct usb_device *dev = ps->dev;
1177 ret = check_ctrlrecip(ps, ctrl->bRequestType, ctrl->bRequest,
1271 static int proc_control(struct usb_dev_state *ps, void __user *arg)
1277 return do_proc_control(ps, &ctrl);
1280 static int do_proc_bulk(struct usb_dev_state *ps,
1283 struct usb_device *dev = ps->dev;
1290 ret = findintfep(ps->dev, bulk->ep);
1293 ret = checkintf(ps, ret);
1370 static int proc_bulk(struct usb_dev_state *ps, void __user *arg)
1376 return do_proc_bulk(ps, &bulk);
1393 static int proc_resetep(struct usb_dev_state *ps, void __user *arg)
1400 ret = findintfep(ps->dev, ep);
1403 ret = checkintf(ps, ret);
1406 check_reset_of_active_ep(ps->dev, ep, "RESETEP");
1407 usb_reset_endpoint(ps->dev, ep);
1411 static int proc_clearhalt(struct usb_dev_state *ps, void __user *arg)
1419 ret = findintfep(ps->dev, ep);
1422 ret = checkintf(ps, ret);
1425 check_reset_of_active_ep(ps->dev, ep, "CLEAR_HALT");
1427 pipe = usb_rcvbulkpipe(ps->dev, ep & 0x7f);
1429 pipe = usb_sndbulkpipe(ps->dev, ep & 0x7f);
1431 return usb_clear_halt(ps->dev, pipe);
1434 static int proc_getdriver(struct usb_dev_state *ps, void __user *arg)
1442 intf = usb_ifnum_to_if(ps->dev, gd.interface);
1453 static int proc_connectinfo(struct usb_dev_state *ps, void __user *arg)
1458 ci.devnum = ps->dev->devnum;
1459 ci.slow = ps->dev->speed == USB_SPEED_LOW;
1466 static int proc_conninfo_ex(struct usb_dev_state *ps,
1470 struct usb_device *udev = ps->dev;
1499 static int proc_resetdevice(struct usb_dev_state *ps)
1501 struct usb_host_config *actconfig = ps->dev->actconfig;
1509 if (ps->privileges_dropped && actconfig) {
1514 !test_bit(number, &ps->ifclaimed)) {
1515 dev_warn(&ps->dev->dev,
1523 return usb_reset_device(ps->dev);
1526 static int proc_setintf(struct usb_dev_state *ps, void __user *arg)
1533 ret = checkintf(ps, setintf.interface);
1537 destroy_async_on_interface(ps, setintf.interface);
1539 return usb_set_interface(ps->dev, setintf.interface,
1543 static int proc_setconfig(struct usb_dev_state *ps, void __user *arg)
1552 actconfig = ps->dev->actconfig;
1563 dev_warn(&ps->dev->dev,
1583 status = usb_reset_configuration(ps->dev);
1585 status = usb_set_configuration(ps->dev, u);
1592 find_memory_area(struct usb_dev_state *ps, const struct usbdevfs_urb *uurb)
1598 spin_lock_irqsave(&ps->lock, flags);
1599 list_for_each_entry(iter, &ps->memory_list, memlist) {
1612 spin_unlock_irqrestore(&ps->lock, flags);
1616 static int proc_do_submiturb(struct usb_dev_state *ps, struct usbdevfs_urb *uurb,
1650 ifnum = findintfep(ps->dev, uurb->endpoint);
1653 ret = checkintf(ps, ifnum);
1657 ep = ep_to_host_endpoint(ps->dev, uurb->endpoint);
1681 ret = check_ctrlrecip(ps, dr->bRequestType, dr->bRequest,
1696 snoop(&ps->dev->dev, "control urb: bRequestType=%02x "
1721 if (num_sgs == 1 || num_sgs > ps->dev->bus->sg_tablesize)
1783 as->usbm = find_memory_area(ps, uurb);
1866 as->urb->dev = ps->dev;
1868 __create_pipe(ps->dev, uurb->endpoint & 0xf) |
1887 dev_warn(&ps->dev->dev, "Requested nonsensical USBDEVFS_URB_SHORT_NOT_OK.\n");
1889 dev_warn(&ps->dev->dev, "Requested nonsensical USBDEVFS_URB_ZERO_PACKET.\n");
1900 ps->dev->speed == USB_SPEED_HIGH ||
1901 ps->dev->speed >= USB_SPEED_SUPER)
1917 as->ps = ps;
1932 snoop_urb(ps->dev, as->userurb, as->urb->pipe,
1941 spin_lock_irq(&ps->lock);
1957 ps->disabled_bulk_eps &= ~(1 << as->bulk_addr);
1962 if (ps->disabled_bulk_eps & (1 << as->bulk_addr))
1966 spin_unlock_irq(&ps->lock);
1972 dev_printk(KERN_DEBUG, &ps->dev->dev,
1974 snoop_urb(ps->dev, as->userurb, as->urb->pipe,
1989 static int proc_submiturb(struct usb_dev_state *ps, void __user *arg)
2000 return proc_do_submiturb(ps, &uurb,
2005 static int proc_unlinkurb(struct usb_dev_state *ps, void __user *arg)
2011 spin_lock_irqsave(&ps->lock, flags);
2012 as = async_getpending(ps, arg);
2014 spin_unlock_irqrestore(&ps->lock, flags);
2020 spin_unlock_irqrestore(&ps->lock, flags);
2078 static struct async *reap_as(struct usb_dev_state *ps)
2082 struct usb_device *dev = ps->dev;
2084 add_wait_queue(&ps->wait, &wait);
2087 as = async_getcompleted(ps);
2088 if (as || !connected(ps))
2096 remove_wait_queue(&ps->wait, &wait);
2101 static int proc_reapurb(struct usb_dev_state *ps, void __user *arg)
2103 struct async *as = reap_as(ps);
2108 snoop(&ps->dev->dev, "reap %px\n", as->userurb);
2118 static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg)
2123 as = async_getcompleted(ps);
2125 snoop(&ps->dev->dev, "reap %px\n", as->userurb);
2129 retval = (connected(ps) ? -EAGAIN : -ENODEV);
2135 static int proc_control_compat(struct usb_dev_state *ps,
2145 return do_proc_control(ps, &ctrl);
2148 static int proc_bulk_compat(struct usb_dev_state *ps,
2160 return do_proc_bulk(ps, &bulk);
2163 static int proc_disconnectsignal_compat(struct usb_dev_state *ps, void __user *arg)
2169 ps->discsignr = ds.signr;
2170 ps->disccontext.sival_int = ds.context;
2195 static int proc_submiturb_compat(struct usb_dev_state *ps, void __user *arg)
2206 return proc_do_submiturb(ps, &uurb,
2246 static int proc_reapurb_compat(struct usb_dev_state *ps, void __user *arg)
2248 struct async *as = reap_as(ps);
2253 snoop(&ps->dev->dev, "reap %px\n", as->userurb);
2263 static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *arg)
2268 as = async_getcompleted(ps);
2270 snoop(&ps->dev->dev, "reap %px\n", as->userurb);
2274 retval = (connected(ps) ? -EAGAIN : -ENODEV);
2282 static int proc_disconnectsignal(struct usb_dev_state *ps, void __user *arg)
2288 ps->discsignr = ds.signr;
2289 ps->disccontext.sival_ptr = ds.context;
2293 static int proc_claiminterface(struct usb_dev_state *ps, void __user *arg)
2299 return claimintf(ps, ifnum);
2302 static int proc_releaseinterface(struct usb_dev_state *ps, void __user *arg)
2309 ret = releaseintf(ps, ifnum);
2312 destroy_async_on_interface(ps, ifnum);
2316 static int proc_ioctl(struct usb_dev_state *ps, struct usbdevfs_ioctl *ctl)
2324 if (ps->privileges_dropped)
2327 if (!connected(ps))
2346 if (ps->dev->state != USB_STATE_CONFIGURED)
2348 else if (!(intf = usb_ifnum_to_if(ps->dev, ctl->ifno)))
2394 static int proc_ioctl_default(struct usb_dev_state *ps, void __user *arg)
2400 return proc_ioctl(ps, &ctrl);
2404 static int proc_ioctl_compat(struct usb_dev_state *ps, compat_uptr_t arg)
2414 return proc_ioctl(ps, &ctrl);
2418 static int proc_claim_port(struct usb_dev_state *ps, void __user *arg)
2425 rc = usb_hub_claim_port(ps->dev, portnum, ps);
2427 snoop(&ps->dev->dev, "port %d claimed by process %d: %s\n",
2432 static int proc_release_port(struct usb_dev_state *ps, void __user *arg)
2438 return usb_hub_release_port(ps->dev, portnum, ps);
2441 static int proc_get_capabilities(struct usb_dev_state *ps, void __user *arg)
2449 if (!ps->dev->bus->no_stop_on_short)
2451 if (ps->dev->bus->sg_tablesize)
2460 static int proc_disconnect_claim(struct usb_dev_state *ps, void __user *arg)
2468 intf = usb_ifnum_to_if(ps->dev, dc.interface);
2475 if (ps->privileges_dropped)
2492 return claimintf(ps, dc.interface);
2495 static int proc_alloc_streams(struct usb_dev_state *ps, void __user *arg)
2502 r = parse_usbdevfs_streams(ps, arg, &num_streams, &num_eps,
2507 destroy_async_on_interface(ps,
2515 static int proc_free_streams(struct usb_dev_state *ps, void __user *arg)
2522 r = parse_usbdevfs_streams(ps, arg, NULL, &num_eps, &eps, &intf);
2526 destroy_async_on_interface(ps,
2534 static int proc_drop_privileges(struct usb_dev_state *ps, void __user *arg)
2545 ps->interface_allowed_mask &= data;
2546 ps->privileges_dropped = true;
2551 static int proc_forbid_suspend(struct usb_dev_state *ps)
2555 if (ps->suspend_allowed) {
2556 ret = usb_autoresume_device(ps->dev);
2558 ps->suspend_allowed = false;
2565 static int proc_allow_suspend(struct usb_dev_state *ps)
2567 if (!connected(ps))
2570 WRITE_ONCE(ps->not_yet_resumed, 1);
2571 if (!ps->suspend_allowed) {
2572 usb_autosuspend_device(ps->dev);
2573 ps->suspend_allowed = true;
2578 static int proc_wait_for_resume(struct usb_dev_state *ps)
2582 usb_unlock_device(ps->dev);
2583 ret = wait_event_interruptible(ps->wait_for_resume,
2584 READ_ONCE(ps->not_yet_resumed) == 0);
2585 usb_lock_device(ps->dev);
2589 return proc_forbid_suspend(ps);
2600 struct usb_dev_state *ps = file->private_data;
2602 struct usb_device *dev = ps->dev;
2614 ret = proc_reapurb(ps, p);
2619 ret = proc_reapurbnonblock(ps, p);
2625 ret = proc_reapurb_compat(ps, p);
2630 ret = proc_reapurbnonblock_compat(ps, p);
2635 if (!connected(ps)) {
2643 ret = proc_control(ps, p);
2651 ret = proc_bulk(ps, p);
2659 ret = proc_resetep(ps, p);
2667 ret = proc_resetdevice(ps);
2672 ret = proc_clearhalt(ps, p);
2680 ret = proc_getdriver(ps, p);
2685 ret = proc_connectinfo(ps, p);
2690 ret = proc_setintf(ps, p);
2695 ret = proc_setconfig(ps, p);
2700 ret = proc_submiturb(ps, p);
2709 ret = proc_control_compat(ps, p);
2717 ret = proc_bulk_compat(ps, p);
2725 ret = proc_disconnectsignal_compat(ps, p);
2730 ret = proc_submiturb_compat(ps, p);
2738 ret = proc_ioctl_compat(ps, ptr_to_compat(p));
2744 ret = proc_unlinkurb(ps, p);
2749 ret = proc_disconnectsignal(ps, p);
2754 ret = proc_claiminterface(ps, p);
2759 ret = proc_releaseinterface(ps, p);
2764 ret = proc_ioctl_default(ps, p);
2769 ret = proc_claim_port(ps, p);
2774 ret = proc_release_port(ps, p);
2777 ret = proc_get_capabilities(ps, p);
2780 ret = proc_disconnect_claim(ps, p);
2783 ret = proc_alloc_streams(ps, p);
2786 ret = proc_free_streams(ps, p);
2789 ret = proc_drop_privileges(ps, p);
2792 ret = ps->dev->speed;
2795 ret = proc_forbid_suspend(ps);
2798 ret = proc_allow_suspend(ps);
2801 ret = proc_wait_for_resume(ps);
2808 ret = proc_conninfo_ex(ps, p, _IOC_SIZE(cmd));
2833 struct usb_dev_state *ps = file->private_data;
2836 poll_wait(file, &ps->wait, wait);
2837 if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
2839 if (!connected(ps))
2841 if (list_empty(&ps->list))
2860 struct usb_dev_state *ps;
2865 ps = list_entry(udev->filelist.next, struct usb_dev_state, list);
2866 destroy_all_async(ps);
2867 wake_up_all(&ps->wait);
2868 WRITE_ONCE(ps->not_yet_resumed, 0);
2869 wake_up_all(&ps->wait_for_resume);
2870 list_del_init(&ps->list);
2871 if (ps->discsignr)
2872 kill_pid_usb_asyncio(ps->discsignr, EPIPE, ps->disccontext,
2873 ps->disc_pid, ps->cred);