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);
510 DBG(epdata->dev, "%s fault %d len %d\n",
520 spin_unlock(&epdata->dev->lock);
545 spin_lock_irq(&epdata->dev->lock);
565 spin_unlock_irq(&epdata->dev->lock);
569 spin_unlock_irq(&epdata->dev->lock);
595 DBG (epdata->dev, "%s halt\n", epdata->name);
596 spin_lock_irq(&epdata->dev->lock);
599 spin_unlock_irq(&epdata->dev->lock);
657 DBG (epdata->dev, "%s halt\n", epdata->name);
658 spin_lock_irq(&epdata->dev->lock);
661 spin_unlock_irq(&epdata->dev->lock);
712 * fd = open ("/dev/gadget/$ENDPOINT", O_RDWR)
742 DBG(data->dev, "config %s, bad tag %d\n", data->name, tag);
765 DBG(data->dev, "config %s, bad hs length or type\n",
771 spin_lock_irq (&data->dev->lock);
772 if (data->dev->state == STATE_DEV_UNBOUND) {
782 switch (data->dev->gadget->speed) {
792 DBG(data->dev, "unconnected, %s init abandoned\n",
803 spin_unlock_irq (&data->dev->lock);
823 spin_lock_irq (&data->dev->lock);
824 if (data->dev->state == STATE_DEV_UNBOUND)
831 VDEBUG (data->dev, "%s ready\n", data->name);
833 DBG (data->dev, "%s state %d\n",
835 spin_unlock_irq (&data->dev->lock);
849 static inline void ep0_readable (struct dev_data *dev)
851 wake_up (&dev->wait);
852 kill_fasync (&dev->fasync, SIGIO, POLL_IN);
857 struct dev_data *dev = ep->driver_data;
859 if (req->buf != dev->rbuf) {
861 req->buf = dev->rbuf;
864 dev->setup_out_ready = 0;
869 struct dev_data *dev = ep->driver_data;
874 spin_lock_irqsave(&dev->lock, flags);
875 if (!dev->setup_in) {
876 dev->setup_out_error = (req->status != 0);
877 if (!dev->setup_out_error)
879 dev->setup_out_ready = 1;
880 ep0_readable (dev);
884 if (free && req->buf != &dev->rbuf)
887 spin_unlock_irqrestore(&dev->lock, flags);
892 struct dev_data *dev = ep->driver_data;
894 if (dev->setup_out_ready) {
895 DBG (dev, "ep0 request busy!\n");
898 if (len > sizeof (dev->rbuf))
901 req->buf = dev->rbuf;
913 struct dev_data *dev = fd->private_data;
917 spin_lock_irq (&dev->lock);
918 if (dev->state <= STATE_DEV_OPENED) {
924 if (dev->setup_abort) {
925 dev->setup_abort = 0;
931 if ((state = dev->state) == STATE_DEV_SETUP) {
933 if (dev->setup_in) { /* stall IN */
934 VDEBUG(dev, "ep0in stall\n");
935 (void) usb_ep_set_halt (dev->gadget->ep0);
937 dev->state = STATE_DEV_CONNECTED;
940 struct usb_ep *ep = dev->gadget->ep0;
941 struct usb_request *req = dev->req;
944 ++dev->udc_usage;
945 spin_unlock_irq (&dev->lock);
947 spin_lock_irq (&dev->lock);
948 --dev->udc_usage;
950 dev->state = STATE_DEV_CONNECTED;
953 if (dev->current_config) {
956 if (gadget_is_dualspeed(dev->gadget)
957 && (dev->gadget->speed
959 power = dev->hs_config->bMaxPower;
961 power = dev->config->bMaxPower;
962 usb_gadget_vbus_draw(dev->gadget, 2 * power);
967 && !dev->setup_out_ready) {
971 spin_unlock_irq (&dev->lock);
972 retval = wait_event_interruptible (dev->wait,
973 dev->setup_out_ready != 0);
976 spin_lock_irq (&dev->lock);
980 if (dev->state != STATE_DEV_SETUP) {
984 dev->state = STATE_DEV_CONNECTED;
986 if (dev->setup_out_error)
989 len = min (len, (size_t)dev->req->actual);
990 ++dev->udc_usage;
991 spin_unlock_irq(&dev->lock);
992 if (copy_to_user (buf, dev->req->buf, len))
996 spin_lock_irq(&dev->lock);
997 --dev->udc_usage;
998 clean_req (dev->gadget->ep0, dev->req);
1006 if (len < sizeof dev->event [0]) {
1011 dev->usermode_setup = 1;
1015 if (dev->ev_next != 0) {
1019 if (dev->ev_next < n)
1020 n = dev->ev_next;
1024 if (dev->event [i].type == GADGETFS_SETUP) {
1025 dev->state = STATE_DEV_SETUP;
1030 spin_unlock_irq (&dev->lock);
1032 if (copy_to_user (buf, &dev->event, len))
1040 spin_lock_irq (&dev->lock);
1041 if (dev->ev_next > n) {
1042 memmove(&dev->event[0], &dev->event[n],
1044 * (dev->ev_next - n));
1046 dev->ev_next -= n;
1047 spin_unlock_irq (&dev->lock);
1058 DBG (dev, "fail %s, state %d\n", __func__, state);
1063 spin_unlock_irq (&dev->lock);
1064 DBG (dev, "%s wait\n", __func__);
1067 retval = wait_event_interruptible (dev->wait,
1068 dev->ev_next != 0);
1071 spin_lock_irq (&dev->lock);
1076 spin_unlock_irq (&dev->lock);
1081 next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type)
1089 if (dev->state == STATE_DEV_SETUP)
1090 dev->setup_abort = 1;
1093 dev->ev_next = 0;
1098 for (i = 0; i != dev->ev_next; i++) {
1099 if (dev->event [i].type != type)
1101 DBG(dev, "discard old event[%d] %d\n", i, type);
1102 dev->ev_next--;
1103 if (i == dev->ev_next)
1106 memmove (&dev->event [i], &dev->event [i + 1],
1108 * (dev->ev_next - i));
1114 VDEBUG(dev, "event[%d] = %d\n", dev->ev_next, type);
1115 event = &dev->event [dev->ev_next++];
1116 BUG_ON (dev->ev_next > N_EVENT);
1125 struct dev_data *dev = fd->private_data;
1129 if (dev->setup_abort) {
1130 dev->setup_abort = 0;
1134 } else if (dev->state == STATE_DEV_SETUP) {
1136 len = min_t(size_t, len, dev->setup_wLength);
1137 if (dev->setup_in) {
1138 retval = setup_req (dev->gadget->ep0, dev->req, len);
1140 dev->state = STATE_DEV_CONNECTED;
1141 ++dev->udc_usage;
1142 spin_unlock_irq (&dev->lock);
1143 if (copy_from_user (dev->req->buf, buf, len))
1146 if (len < dev->setup_wLength)
1147 dev->req->zero = 1;
1149 dev->gadget->ep0, dev->req,
1152 spin_lock_irq(&dev->lock);
1153 --dev->udc_usage;
1155 clean_req (dev->gadget->ep0, dev->req);
1163 } else if (dev->setup_can_stall) {
1164 VDEBUG(dev, "ep0out stall\n");
1165 (void) usb_ep_set_halt (dev->gadget->ep0);
1167 dev->state = STATE_DEV_CONNECTED;
1169 DBG(dev, "bogus ep0out stall!\n");
1172 DBG (dev, "fail %s, state %d\n", __func__, dev->state);
1180 struct dev_data *dev = fd->private_data;
1182 VDEBUG (dev, "%s %s\n", __func__, on ? "on" : "off");
1183 return fasync_helper (f, fd, on, &dev->fasync);
1191 struct dev_data *dev = fd->private_data;
1195 if (dev->gadget_registered) {
1197 dev->gadget_registered = false;
1205 kfree (dev->buf);
1206 dev->buf = NULL;
1209 spin_lock_irq(&dev->lock);
1210 dev->state = STATE_DEV_DISABLED;
1211 spin_unlock_irq(&dev->lock);
1213 put_dev (dev);
1220 struct dev_data *dev = fd->private_data;
1223 if (dev->state <= STATE_DEV_OPENED)
1226 poll_wait(fd, &dev->wait, wait);
1228 spin_lock_irq(&dev->lock);
1231 if (dev->setup_abort) {
1232 dev->setup_abort = 0;
1237 if (dev->state == STATE_DEV_SETUP) {
1238 if (dev->setup_in || dev->setup_can_stall)
1241 if (dev->ev_next != 0)
1245 spin_unlock_irq(&dev->lock);
1251 struct dev_data *dev = fd->private_data;
1252 struct usb_gadget *gadget = dev->gadget;
1255 spin_lock_irq(&dev->lock);
1256 if (dev->state == STATE_DEV_OPENED ||
1257 dev->state == STATE_DEV_UNBOUND) {
1260 ++dev->udc_usage;
1261 spin_unlock_irq(&dev->lock);
1265 spin_lock_irq(&dev->lock);
1266 --dev->udc_usage;
1268 spin_unlock_irq(&dev->lock);
1281 static void make_qualifier (struct dev_data *dev)
1290 desc = dev->dev;
1296 qual.bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
1301 memcpy (dev->rbuf, &qual, sizeof qual);
1305 config_buf (struct dev_data *dev, u8 type, unsigned index)
1314 if (gadget_is_dualspeed(dev->gadget)) {
1315 hs = (dev->gadget->speed == USB_SPEED_HIGH);
1320 dev->req->buf = dev->hs_config;
1321 len = le16_to_cpu(dev->hs_config->wTotalLength);
1323 dev->req->buf = dev->config;
1324 len = le16_to_cpu(dev->config->wTotalLength);
1326 ((u8 *)dev->req->buf) [1] = type;
1333 struct dev_data *dev = get_gadget_data (gadget);
1334 struct usb_request *req = dev->req;
1352 spin_lock (&dev->lock);
1353 dev->setup_abort = 0;
1354 if (dev->state == STATE_DEV_UNCONNECTED) {
1357 && dev->hs_config == NULL) {
1358 spin_unlock(&dev->lock);
1359 ERROR (dev, "no high speed config??\n");
1363 dev->state = STATE_DEV_CONNECTED;
1365 INFO (dev, "connected\n");
1366 event = next_event (dev, GADGETFS_CONNECT);
1368 ep0_readable (dev);
1375 } else if (dev->state == STATE_DEV_SETUP)
1376 dev->setup_abort = 1;
1378 req->buf = dev->rbuf;
1388 value = min (w_length, (u16) sizeof *dev->dev);
1389 dev->dev->bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
1390 req->buf = dev->dev;
1393 if (!dev->hs_config)
1397 make_qualifier (dev);
1401 value = config_buf (dev,
1421 dev->current_config = 0;
1429 config = dev->hs_config->bConfigurationValue;
1430 power = dev->hs_config->bMaxPower;
1432 config = dev->config->bConfigurationValue;
1433 power = dev->config->bMaxPower;
1438 dev->current_config = config;
1453 INFO (dev, "configuration #%d\n", dev->current_config);
1455 if (dev->usermode_setup) {
1456 dev->setup_can_stall = 0;
1467 *(u8 *)req->buf = dev->current_config;
1474 VDEBUG (dev, "%s req%02x.%02x v%04x i%04x l%d\n",
1475 dev->usermode_setup ? "delegate" : "fail",
1480 if (dev->usermode_setup) {
1481 dev->setup_can_stall = 1;
1483 dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
1485 dev->setup_wLength = w_length;
1486 dev->setup_out_ready = 0;
1487 dev->setup_out_error = 0;
1490 if (unlikely (!dev->setup_in && w_length)) {
1491 value = setup_req (gadget->ep0, dev->req,
1496 ++dev->udc_usage;
1497 spin_unlock (&dev->lock);
1498 value = usb_ep_queue (gadget->ep0, dev->req,
1500 spin_lock (&dev->lock);
1501 --dev->udc_usage;
1503 clean_req (gadget->ep0, dev->req);
1508 dev->setup_can_stall = 0;
1512 event = next_event (dev, GADGETFS_SETUP);
1514 ep0_readable (dev);
1515 spin_unlock (&dev->lock);
1521 if (value >= 0 && dev->state != STATE_DEV_SETUP) {
1525 ++dev->udc_usage;
1526 spin_unlock (&dev->lock);
1528 spin_lock(&dev->lock);
1529 --dev->udc_usage;
1530 spin_unlock(&dev->lock);
1532 DBG (dev, "ep_queue --> %d\n", value);
1539 spin_unlock (&dev->lock);
1543 static void destroy_ep_files (struct dev_data *dev)
1545 DBG (dev, "%s %d\n", __func__, dev->state);
1547 /* dev->state must prevent interference */
1548 spin_lock_irq (&dev->lock);
1549 while (!list_empty(&dev->epfiles)) {
1555 ep = list_first_entry (&dev->epfiles, struct ep_data, epfiles);
1557 spin_unlock_irq (&dev->lock);
1581 spin_lock_irq (&dev->lock);
1583 spin_unlock_irq (&dev->lock);
1591 static int activate_ep_files (struct dev_data *dev)
1596 gadget_for_each_ep (ep, dev->gadget) {
1607 data->dev = dev;
1608 get_dev (dev);
1617 data->dentry = gadgetfs_create_file (dev->sb, data->name,
1621 list_add_tail (&data->epfiles, &dev->epfiles);
1628 put_dev (dev);
1631 DBG (dev, "%s enomem\n", __func__);
1632 destroy_ep_files (dev);
1639 struct dev_data *dev = get_gadget_data (gadget);
1641 DBG (dev, "%s\n", __func__);
1643 spin_lock_irq (&dev->lock);
1644 dev->state = STATE_DEV_UNBOUND;
1645 while (dev->udc_usage > 0) {
1646 spin_unlock_irq(&dev->lock);
1648 spin_lock_irq(&dev->lock);
1650 spin_unlock_irq (&dev->lock);
1652 destroy_ep_files (dev);
1657 if (dev->req)
1658 usb_ep_free_request (gadget->ep0, dev->req);
1659 DBG (dev, "%s done\n", __func__);
1660 put_dev (dev);
1668 struct dev_data *dev = the_device;
1670 if (!dev)
1678 set_gadget_data (gadget, dev);
1679 dev->gadget = gadget;
1680 gadget->ep0->driver_data = dev;
1683 dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
1684 if (!dev->req)
1686 dev->req->context = NULL;
1687 dev->req->complete = epio_complete;
1689 if (activate_ep_files (dev) < 0)
1692 INFO (dev, "bound to %s driver\n", gadget->name);
1693 spin_lock_irq(&dev->lock);
1694 dev->state = STATE_DEV_UNCONNECTED;
1695 spin_unlock_irq(&dev->lock);
1696 get_dev (dev);
1707 struct dev_data *dev = get_gadget_data (gadget);
1710 spin_lock_irqsave (&dev->lock, flags);
1711 if (dev->state == STATE_DEV_UNCONNECTED)
1713 dev->state = STATE_DEV_UNCONNECTED;
1715 INFO (dev, "disconnected\n");
1716 next_event (dev, GADGETFS_DISCONNECT);
1717 ep0_readable (dev);
1719 spin_unlock_irqrestore (&dev->lock, flags);
1725 struct dev_data *dev = get_gadget_data (gadget);
1728 INFO (dev, "suspended from state %d\n", dev->state);
1729 spin_lock_irqsave(&dev->lock, flags);
1730 switch (dev->state) {
1734 next_event (dev, GADGETFS_SUSPEND);
1735 ep0_readable (dev);
1740 spin_unlock_irqrestore(&dev->lock, flags);
1760 * fd = open ("/dev/gadget/$CHIP", O_RDWR)
1800 struct dev_data *dev = fd->private_data;
1806 spin_lock_irq(&dev->lock);
1807 if (dev->state > STATE_DEV_OPENED) {
1809 spin_unlock_irq(&dev->lock);
1812 spin_unlock_irq(&dev->lock);
1830 spin_lock_irq (&dev->lock);
1832 if (dev->buf) {
1833 spin_unlock_irq(&dev->lock);
1837 dev->buf = kbuf;
1840 dev->config = (void *) kbuf;
1841 total = le16_to_cpu(dev->config->wTotalLength);
1842 if (!is_valid_config(dev->config, total) ||
1850 dev->hs_config = (void *) kbuf;
1851 total = le16_to_cpu(dev->hs_config->wTotalLength);
1852 if (!is_valid_config(dev->hs_config, total) ||
1858 dev->hs_config = NULL;
1866 dev->dev = (void *)kbuf;
1867 if (dev->dev->bLength != USB_DT_DEVICE_SIZE
1868 || dev->dev->bDescriptorType != USB_DT_DEVICE
1869 || dev->dev->bNumConfigurations != 1)
1871 dev->dev->bcdUSB = cpu_to_le16 (0x0200);
1874 spin_unlock_irq (&dev->lock);
1875 if (dev->hs_config)
1882 spin_lock_irq(&dev->lock);
1895 dev->gadget_registered = true;
1900 dev->config = NULL;
1901 dev->hs_config = NULL;
1902 dev->dev = NULL;
1903 spin_unlock_irq (&dev->lock);
1904 pr_debug ("%s: %s fail %zd, %p\n", shortname, __func__, value, dev);
1905 kfree (dev->buf);
1906 dev->buf = NULL;
1913 struct dev_data *dev = inode->i_private;
1916 spin_lock_irq(&dev->lock);
1917 if (dev->state == STATE_DEV_DISABLED) {
1918 dev->ev_next = 0;
1919 dev->state = STATE_DEV_OPENED;
1920 fd->private_data = dev;
1921 get_dev (dev);
1924 spin_unlock_irq(&dev->lock);
2015 struct dev_data *dev;
2051 dev = dev_new ();
2052 if (!dev)
2055 dev->sb = sb;
2056 dev->dentry = gadgetfs_create_file(sb, CHIP, dev, &ep0_operations);
2057 if (!dev->dentry) {
2058 put_dev(dev);
2065 the_device = dev;
2079 /* "mount -t gadgetfs path /dev/gadget" ends up here */