Lines Matching refs:dev
49 * - First, dev_config() is called when /dev/gadget/$CHIP is configured
55 * called when each /dev/gadget/ep* file is configured (by writing
83 /* /dev/gadget/$CHIP represents ep0 and the whole device */
88 /* Only one open() of /dev/gadget/$CHIP; only one file tracks
139 struct usb_device_descriptor *dev;
168 struct dev_data *dev;
170 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
171 if (!dev)
173 dev->state = STATE_DEV_DISABLED;
174 refcount_set (&dev->count, 1);
175 spin_lock_init (&dev->lock);
176 INIT_LIST_HEAD (&dev->epfiles);
177 init_waitqueue_head (&dev->wait);
178 return dev;
183 /* other /dev/gadget/$ENDPOINT files represent endpoints */
195 struct dev_data *dev;
196 /* must hold dev->lock before accessing ep or req */
216 put_dev (data->dev);
240 /* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */
245 #define DBG(dev,fmt,args...) \
246 xprintk(dev , KERN_DEBUG , fmt , ## args)
248 #define DBG(dev,fmt,args...) \
255 #define VDEBUG(dev,fmt,args...) \
259 #define ERROR(dev,fmt,args...) \
260 xprintk(dev , KERN_ERR , fmt , ## args)
261 #define INFO(dev,fmt,args...) \
262 xprintk(dev , KERN_INFO , fmt , ## args)
288 * still need dev->lock to use epdata->ep.
336 spin_lock_irq (&epdata->dev->lock);
347 spin_unlock_irq (&epdata->dev->lock);
352 spin_lock_irq (&epdata->dev->lock);
354 DBG (epdata->dev, "%s i/o interrupted\n",
357 spin_unlock_irq (&epdata->dev->lock);
363 spin_unlock_irq (&epdata->dev->lock);
365 DBG (epdata->dev, "endpoint gone\n");
405 spin_lock_irq (&data->dev->lock);
422 spin_unlock_irq (&data->dev->lock);
451 // spin_lock(&epdata->dev->lock);
456 // spin_unlock(&epdata->dev->lock);
490 spin_lock(&epdata->dev->lock);
508 DBG(epdata->dev, "%s fault %d len %d\n",
518 spin_unlock(&epdata->dev->lock);
543 spin_lock_irq(&epdata->dev->lock);
563 spin_unlock_irq(&epdata->dev->lock);
567 spin_unlock_irq(&epdata->dev->lock);
593 DBG (epdata->dev, "%s halt\n", epdata->name);
594 spin_lock_irq(&epdata->dev->lock);
597 spin_unlock_irq(&epdata->dev->lock);
655 DBG (epdata->dev, "%s halt\n", epdata->name);
656 spin_lock_irq(&epdata->dev->lock);
659 spin_unlock_irq(&epdata->dev->lock);
710 * fd = open ("/dev/gadget/$ENDPOINT", O_RDWR)
740 DBG(data->dev, "config %s, bad tag %d\n", data->name, tag);
763 DBG(data->dev, "config %s, bad hs length or type\n",
769 spin_lock_irq (&data->dev->lock);
770 if (data->dev->state == STATE_DEV_UNBOUND) {
780 switch (data->dev->gadget->speed) {
790 DBG(data->dev, "unconnected, %s init abandoned\n",
801 spin_unlock_irq (&data->dev->lock);
821 spin_lock_irq (&data->dev->lock);
822 if (data->dev->state == STATE_DEV_UNBOUND)
829 VDEBUG (data->dev, "%s ready\n", data->name);
831 DBG (data->dev, "%s state %d\n",
833 spin_unlock_irq (&data->dev->lock);
847 static inline void ep0_readable (struct dev_data *dev)
849 wake_up (&dev->wait);
850 kill_fasync (&dev->fasync, SIGIO, POLL_IN);
855 struct dev_data *dev = ep->driver_data;
857 if (req->buf != dev->rbuf) {
859 req->buf = dev->rbuf;
862 dev->setup_out_ready = 0;
867 struct dev_data *dev = ep->driver_data;
872 spin_lock_irqsave(&dev->lock, flags);
873 if (!dev->setup_in) {
874 dev->setup_out_error = (req->status != 0);
875 if (!dev->setup_out_error)
877 dev->setup_out_ready = 1;
878 ep0_readable (dev);
882 if (free && req->buf != &dev->rbuf)
885 spin_unlock_irqrestore(&dev->lock, flags);
890 struct dev_data *dev = ep->driver_data;
892 if (dev->setup_out_ready) {
893 DBG (dev, "ep0 request busy!\n");
896 if (len > sizeof (dev->rbuf))
899 req->buf = dev->rbuf;
911 struct dev_data *dev = fd->private_data;
915 spin_lock_irq (&dev->lock);
916 if (dev->state <= STATE_DEV_OPENED) {
922 if (dev->setup_abort) {
923 dev->setup_abort = 0;
929 if ((state = dev->state) == STATE_DEV_SETUP) {
931 if (dev->setup_in) { /* stall IN */
932 VDEBUG(dev, "ep0in stall\n");
933 (void) usb_ep_set_halt (dev->gadget->ep0);
935 dev->state = STATE_DEV_CONNECTED;
938 struct usb_ep *ep = dev->gadget->ep0;
939 struct usb_request *req = dev->req;
942 ++dev->udc_usage;
943 spin_unlock_irq (&dev->lock);
945 spin_lock_irq (&dev->lock);
946 --dev->udc_usage;
948 dev->state = STATE_DEV_CONNECTED;
951 if (dev->current_config) {
954 if (gadget_is_dualspeed(dev->gadget)
955 && (dev->gadget->speed
957 power = dev->hs_config->bMaxPower;
959 power = dev->config->bMaxPower;
960 usb_gadget_vbus_draw(dev->gadget, 2 * power);
965 && !dev->setup_out_ready) {
969 spin_unlock_irq (&dev->lock);
970 retval = wait_event_interruptible (dev->wait,
971 dev->setup_out_ready != 0);
974 spin_lock_irq (&dev->lock);
978 if (dev->state != STATE_DEV_SETUP) {
982 dev->state = STATE_DEV_CONNECTED;
984 if (dev->setup_out_error)
987 len = min (len, (size_t)dev->req->actual);
988 ++dev->udc_usage;
989 spin_unlock_irq(&dev->lock);
990 if (copy_to_user (buf, dev->req->buf, len))
994 spin_lock_irq(&dev->lock);
995 --dev->udc_usage;
996 clean_req (dev->gadget->ep0, dev->req);
1004 if (len < sizeof dev->event [0]) {
1009 dev->usermode_setup = 1;
1013 if (dev->ev_next != 0) {
1017 if (dev->ev_next < n)
1018 n = dev->ev_next;
1022 if (dev->event [i].type == GADGETFS_SETUP) {
1023 dev->state = STATE_DEV_SETUP;
1028 spin_unlock_irq (&dev->lock);
1030 if (copy_to_user (buf, &dev->event, len))
1038 spin_lock_irq (&dev->lock);
1039 if (dev->ev_next > n) {
1040 memmove(&dev->event[0], &dev->event[n],
1042 * (dev->ev_next - n));
1044 dev->ev_next -= n;
1045 spin_unlock_irq (&dev->lock);
1056 DBG (dev, "fail %s, state %d\n", __func__, state);
1061 spin_unlock_irq (&dev->lock);
1062 DBG (dev, "%s wait\n", __func__);
1065 retval = wait_event_interruptible (dev->wait,
1066 dev->ev_next != 0);
1069 spin_lock_irq (&dev->lock);
1074 spin_unlock_irq (&dev->lock);
1079 next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type)
1087 if (dev->state == STATE_DEV_SETUP)
1088 dev->setup_abort = 1;
1091 dev->ev_next = 0;
1096 for (i = 0; i != dev->ev_next; i++) {
1097 if (dev->event [i].type != type)
1099 DBG(dev, "discard old event[%d] %d\n", i, type);
1100 dev->ev_next--;
1101 if (i == dev->ev_next)
1104 memmove (&dev->event [i], &dev->event [i + 1],
1106 * (dev->ev_next - i));
1112 VDEBUG(dev, "event[%d] = %d\n", dev->ev_next, type);
1113 event = &dev->event [dev->ev_next++];
1114 BUG_ON (dev->ev_next > N_EVENT);
1123 struct dev_data *dev = fd->private_data;
1127 if (dev->setup_abort) {
1128 dev->setup_abort = 0;
1132 } else if (dev->state == STATE_DEV_SETUP) {
1134 len = min_t(size_t, len, dev->setup_wLength);
1135 if (dev->setup_in) {
1136 retval = setup_req (dev->gadget->ep0, dev->req, len);
1138 dev->state = STATE_DEV_CONNECTED;
1139 ++dev->udc_usage;
1140 spin_unlock_irq (&dev->lock);
1141 if (copy_from_user (dev->req->buf, buf, len))
1144 if (len < dev->setup_wLength)
1145 dev->req->zero = 1;
1147 dev->gadget->ep0, dev->req,
1150 spin_lock_irq(&dev->lock);
1151 --dev->udc_usage;
1153 clean_req (dev->gadget->ep0, dev->req);
1161 } else if (dev->setup_can_stall) {
1162 VDEBUG(dev, "ep0out stall\n");
1163 (void) usb_ep_set_halt (dev->gadget->ep0);
1165 dev->state = STATE_DEV_CONNECTED;
1167 DBG(dev, "bogus ep0out stall!\n");
1170 DBG (dev, "fail %s, state %d\n", __func__, dev->state);
1178 struct dev_data *dev = fd->private_data;
1180 VDEBUG (dev, "%s %s\n", __func__, on ? "on" : "off");
1181 return fasync_helper (f, fd, on, &dev->fasync);
1189 struct dev_data *dev = fd->private_data;
1193 if (dev->gadget_registered) {
1195 dev->gadget_registered = false;
1203 kfree (dev->buf);
1204 dev->buf = NULL;
1207 spin_lock_irq(&dev->lock);
1208 dev->state = STATE_DEV_DISABLED;
1209 spin_unlock_irq(&dev->lock);
1211 put_dev (dev);
1218 struct dev_data *dev = fd->private_data;
1221 if (dev->state <= STATE_DEV_OPENED)
1224 poll_wait(fd, &dev->wait, wait);
1226 spin_lock_irq(&dev->lock);
1229 if (dev->setup_abort) {
1230 dev->setup_abort = 0;
1235 if (dev->state == STATE_DEV_SETUP) {
1236 if (dev->setup_in || dev->setup_can_stall)
1239 if (dev->ev_next != 0)
1243 spin_unlock_irq(&dev->lock);
1249 struct dev_data *dev = fd->private_data;
1250 struct usb_gadget *gadget = dev->gadget;
1253 spin_lock_irq(&dev->lock);
1254 if (dev->state == STATE_DEV_OPENED ||
1255 dev->state == STATE_DEV_UNBOUND) {
1258 ++dev->udc_usage;
1259 spin_unlock_irq(&dev->lock);
1263 spin_lock_irq(&dev->lock);
1264 --dev->udc_usage;
1266 spin_unlock_irq(&dev->lock);
1279 static void make_qualifier (struct dev_data *dev)
1288 desc = dev->dev;
1294 qual.bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
1299 memcpy (dev->rbuf, &qual, sizeof qual);
1303 config_buf (struct dev_data *dev, u8 type, unsigned index)
1312 if (gadget_is_dualspeed(dev->gadget)) {
1313 hs = (dev->gadget->speed == USB_SPEED_HIGH);
1318 dev->req->buf = dev->hs_config;
1319 len = le16_to_cpu(dev->hs_config->wTotalLength);
1321 dev->req->buf = dev->config;
1322 len = le16_to_cpu(dev->config->wTotalLength);
1324 ((u8 *)dev->req->buf) [1] = type;
1331 struct dev_data *dev = get_gadget_data (gadget);
1332 struct usb_request *req = dev->req;
1350 spin_lock (&dev->lock);
1351 dev->setup_abort = 0;
1352 if (dev->state == STATE_DEV_UNCONNECTED) {
1355 && dev->hs_config == NULL) {
1356 spin_unlock(&dev->lock);
1357 ERROR (dev, "no high speed config??\n");
1361 dev->state = STATE_DEV_CONNECTED;
1363 INFO (dev, "connected\n");
1364 event = next_event (dev, GADGETFS_CONNECT);
1366 ep0_readable (dev);
1373 } else if (dev->state == STATE_DEV_SETUP)
1374 dev->setup_abort = 1;
1376 req->buf = dev->rbuf;
1386 value = min (w_length, (u16) sizeof *dev->dev);
1387 dev->dev->bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
1388 req->buf = dev->dev;
1391 if (!dev->hs_config)
1395 make_qualifier (dev);
1399 value = config_buf (dev,
1419 dev->current_config = 0;
1427 config = dev->hs_config->bConfigurationValue;
1428 power = dev->hs_config->bMaxPower;
1430 config = dev->config->bConfigurationValue;
1431 power = dev->config->bMaxPower;
1436 dev->current_config = config;
1451 INFO (dev, "configuration #%d\n", dev->current_config);
1453 if (dev->usermode_setup) {
1454 dev->setup_can_stall = 0;
1465 *(u8 *)req->buf = dev->current_config;
1472 VDEBUG (dev, "%s req%02x.%02x v%04x i%04x l%d\n",
1473 dev->usermode_setup ? "delegate" : "fail",
1478 if (dev->usermode_setup) {
1479 dev->setup_can_stall = 1;
1481 dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
1483 dev->setup_wLength = w_length;
1484 dev->setup_out_ready = 0;
1485 dev->setup_out_error = 0;
1488 if (unlikely (!dev->setup_in && w_length)) {
1489 value = setup_req (gadget->ep0, dev->req,
1494 ++dev->udc_usage;
1495 spin_unlock (&dev->lock);
1496 value = usb_ep_queue (gadget->ep0, dev->req,
1498 spin_lock (&dev->lock);
1499 --dev->udc_usage;
1501 clean_req (gadget->ep0, dev->req);
1506 dev->setup_can_stall = 0;
1510 event = next_event (dev, GADGETFS_SETUP);
1512 ep0_readable (dev);
1513 spin_unlock (&dev->lock);
1519 if (value >= 0 && dev->state != STATE_DEV_SETUP) {
1523 ++dev->udc_usage;
1524 spin_unlock (&dev->lock);
1526 spin_lock(&dev->lock);
1527 --dev->udc_usage;
1528 spin_unlock(&dev->lock);
1530 DBG (dev, "ep_queue --> %d\n", value);
1537 spin_unlock (&dev->lock);
1541 static void destroy_ep_files (struct dev_data *dev)
1543 DBG (dev, "%s %d\n", __func__, dev->state);
1545 /* dev->state must prevent interference */
1546 spin_lock_irq (&dev->lock);
1547 while (!list_empty(&dev->epfiles)) {
1553 ep = list_first_entry (&dev->epfiles, struct ep_data, epfiles);
1555 spin_unlock_irq (&dev->lock);
1579 spin_lock_irq (&dev->lock);
1581 spin_unlock_irq (&dev->lock);
1589 static int activate_ep_files (struct dev_data *dev)
1594 gadget_for_each_ep (ep, dev->gadget) {
1605 data->dev = dev;
1606 get_dev (dev);
1615 data->dentry = gadgetfs_create_file (dev->sb, data->name,
1619 list_add_tail (&data->epfiles, &dev->epfiles);
1626 put_dev (dev);
1629 DBG (dev, "%s enomem\n", __func__);
1630 destroy_ep_files (dev);
1637 struct dev_data *dev = get_gadget_data (gadget);
1639 DBG (dev, "%s\n", __func__);
1641 spin_lock_irq (&dev->lock);
1642 dev->state = STATE_DEV_UNBOUND;
1643 while (dev->udc_usage > 0) {
1644 spin_unlock_irq(&dev->lock);
1646 spin_lock_irq(&dev->lock);
1648 spin_unlock_irq (&dev->lock);
1650 destroy_ep_files (dev);
1655 if (dev->req)
1656 usb_ep_free_request (gadget->ep0, dev->req);
1657 DBG (dev, "%s done\n", __func__);
1658 put_dev (dev);
1666 struct dev_data *dev = the_device;
1668 if (!dev)
1676 set_gadget_data (gadget, dev);
1677 dev->gadget = gadget;
1678 gadget->ep0->driver_data = dev;
1681 dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
1682 if (!dev->req)
1684 dev->req->context = NULL;
1685 dev->req->complete = epio_complete;
1687 if (activate_ep_files (dev) < 0)
1690 INFO (dev, "bound to %s driver\n", gadget->name);
1691 spin_lock_irq(&dev->lock);
1692 dev->state = STATE_DEV_UNCONNECTED;
1693 spin_unlock_irq(&dev->lock);
1694 get_dev (dev);
1705 struct dev_data *dev = get_gadget_data (gadget);
1708 spin_lock_irqsave (&dev->lock, flags);
1709 if (dev->state == STATE_DEV_UNCONNECTED)
1711 dev->state = STATE_DEV_UNCONNECTED;
1713 INFO (dev, "disconnected\n");
1714 next_event (dev, GADGETFS_DISCONNECT);
1715 ep0_readable (dev);
1717 spin_unlock_irqrestore (&dev->lock, flags);
1723 struct dev_data *dev = get_gadget_data (gadget);
1726 INFO (dev, "suspended from state %d\n", dev->state);
1727 spin_lock_irqsave(&dev->lock, flags);
1728 switch (dev->state) {
1732 next_event (dev, GADGETFS_SUSPEND);
1733 ep0_readable (dev);
1738 spin_unlock_irqrestore(&dev->lock, flags);
1758 * fd = open ("/dev/gadget/$CHIP", O_RDWR)
1798 struct dev_data *dev = fd->private_data;
1804 spin_lock_irq(&dev->lock);
1805 if (dev->state > STATE_DEV_OPENED) {
1807 spin_unlock_irq(&dev->lock);
1810 spin_unlock_irq(&dev->lock);
1828 spin_lock_irq (&dev->lock);
1830 if (dev->buf) {
1831 spin_unlock_irq(&dev->lock);
1835 dev->buf = kbuf;
1838 dev->config = (void *) kbuf;
1839 total = le16_to_cpu(dev->config->wTotalLength);
1840 if (!is_valid_config(dev->config, total) ||
1848 dev->hs_config = (void *) kbuf;
1849 total = le16_to_cpu(dev->hs_config->wTotalLength);
1850 if (!is_valid_config(dev->hs_config, total) ||
1856 dev->hs_config = NULL;
1864 dev->dev = (void *)kbuf;
1865 if (dev->dev->bLength != USB_DT_DEVICE_SIZE
1866 || dev->dev->bDescriptorType != USB_DT_DEVICE
1867 || dev->dev->bNumConfigurations != 1)
1869 dev->dev->bcdUSB = cpu_to_le16 (0x0200);
1872 spin_unlock_irq (&dev->lock);
1873 if (dev->hs_config)
1880 spin_lock_irq(&dev->lock);
1893 dev->gadget_registered = true;
1898 dev->config = NULL;
1899 dev->hs_config = NULL;
1900 dev->dev = NULL;
1901 spin_unlock_irq (&dev->lock);
1902 pr_debug ("%s: %s fail %zd, %p\n", shortname, __func__, value, dev);
1903 kfree (dev->buf);
1904 dev->buf = NULL;
1911 struct dev_data *dev = inode->i_private;
1914 spin_lock_irq(&dev->lock);
1915 if (dev->state == STATE_DEV_DISABLED) {
1916 dev->ev_next = 0;
1917 dev->state = STATE_DEV_OPENED;
1918 fd->private_data = dev;
1919 get_dev (dev);
1922 spin_unlock_irq(&dev->lock);
2012 struct dev_data *dev;
2048 dev = dev_new ();
2049 if (!dev)
2052 dev->sb = sb;
2053 dev->dentry = gadgetfs_create_file(sb, CHIP, dev, &ep0_operations);
2054 if (!dev->dentry) {
2055 put_dev(dev);
2062 the_device = dev;
2076 /* "mount -t gadgetfs path /dev/gadget" ends up here */