Searched refs:ep0 (Results 1 - 22 of 22) sorted by last modified time

/netgear-WNDR4500v2-V1.0.0.60_1.0.38/src/linux/linux-2.6/drivers/usb/serial/
H A Dxircom_pgs.S182 mov a,#0x01 ; enable SUDAV: setup data available (for ep0)
H A Dkeyspan_pda.S157 mov a,#0x01 ; enable SUDAV: setup data available (for ep0)
/netgear-WNDR4500v2-V1.0.0.60_1.0.38/src/linux/linux-2.6/drivers/usb/core/
H A Dhcd.c808 usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
H A Dhub.c2058 udev->ep_in[0] = udev->ep_out[0] = &udev->ep0;
2134 /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
2136 * For Wireless USB devices, ep0 max packet is always 512 (tho
2141 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(512);
2144 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
2147 /* to determine the ep0 maxpacket size, try to read
2151 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
2154 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8);
2195 * first 8 bytes of the device descriptor to get the ep0 maxpacket
2275 * - read ep0 maxpacke
[all...]
H A Dsysfs.c406 retval = usb_create_ep_files(dev, &udev->ep0, udev);
419 usb_remove_ep_files(&udev->ep0);
H A Dusb.c278 INIT_LIST_HEAD(&dev->ep0.urb_list);
279 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
280 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
281 /* ep0 maxpacket comes later, from device descriptor */
282 dev->ep_in[0] = dev->ep_out[0] = &dev->ep0;
/netgear-WNDR4500v2-V1.0.0.60_1.0.38/src/linux/linux-2.6/drivers/usb/gadget/
H A Dat91_udc.c79 static const char ep0name[] = "ep0";
287 /* ep0 is always ready; other endpoints need a non-empty queue */
691 PACKET("ep0 in/status\n");
842 INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
1261 PACKET("ep0 in/status\n");
1271 struct at91_ep *ep0 = &udc->ep[0]; local
1272 u32 __iomem *creg = ep0->creg;
1277 nuke(ep0, -EPROTO);
1282 VDBG("ep0 stalled\n");
1286 nuke(ep0,
[all...]
H A Ddummy_hcd.c108 * Every device has ep0 for control requests, plus up to 30 more endpoints,
121 static const char ep0name [] = "ep0";
124 ep0name, /* everyone has ep0 */
418 /* few chips support control except on ep0 */
802 dum->gadget.ep0 = &dum->ep [0].ep;
1667 dum->gadget.ep0->maxpacket = 64;
1674 dum->gadget.ep0->maxpacket = 8;
H A Dether.c402 * ep0 implementation: descriptors, config management, setup().
1324 * The setup() callback implements all the ep0 functionality that's not
1342 /* descriptors just go into the pre-allocated ep0 buffer,
1565 && (value % gadget->ep0->maxpacket) == 0;
1566 value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
1570 eth_setup_complete (gadget->ep0, req);
2186 eth_req_free (gadget->ep0, dev->req);
2387 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
2400 /* assumes ep0 uses the same value for both speeds ... */
2480 dev->req = eth_req_alloc (gadget->ep0, USB_BUFSI
[all...]
H A Dfile_storage.c49 * ep0 requests are handled at interrupt time, but SetInterface,
112 * One subtle point concerns sending status-stage responses for ep0
116 * the original ep0 request and issue a new one. When that happens the
119 * assigns to each ep0 request a unique tag, and it keeps track of the
123 * only if the current ep0 request tag is equal to the exception request
124 * tag. Thus only the most recently received ep0 request will get a
563 struct usb_ep *ep0; // Handy copy of gadget->ep0 member in struct:fsg_dev
1033 /* The disconnect callback and ep0 routines. These always run in_irq,
1051 rc = usb_ep_queue(fsg->ep0, fs
[all...]
H A Dfsl_usb2_udc.c422 /* Setup qh structure and ep register for ep0. */
446 * ep0 doesn't use this routine. It is always enabled.
534 * @ep : the ep being unconfigured. May not be ep0
859 /* Update ep0 state */
1169 /* Set protocol stall on ep0, protocol stall will automatically be cleared
1183 /* Prime a status phase for ep0 */
1211 ERR("Can't queue ep0 status request \n");
1403 /* Process request for Data or Status phase of ep0
1405 static void ep0_req_complete(struct fsl_udc *udc, struct fsl_ep *ep0, argument
1415 done(ep0, re
[all...]
H A Dgmidi.c658 * The setup() callback implements all the ep0 functionality that's
674 /* usually this stores reply data in the pre-allocated ep0 buffer,
791 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
795 gmidi_setup_complete(gadget->ep0, req);
838 free_ep_req(gadget->ep0, dev->req);
1230 dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1235 dev->req->buf = usb_ep_alloc_buffer(gadget->ep0, USB_BUFSIZ,
1244 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1246 gadget->ep0->driver_data = dev;
H A Dgoku_udc.c15 * This device has ep0 and three semi-configurable bulk/interrupt endpoints.
414 /* last packet often short (sometimes a zlp, especially on ep0) */
780 /* for ep0 IN without premature status, zlp is required and
1082 (mask & INT_ENDPOINT0) ? " ep0" : "",
1144 /* registers for (active) device and ep0 */
1204 case EPxSTATUS_EP_BUSY: /* ep0 only */
1265 static char *names [] = { "ep0", "ep1-bulk", "ep2-bulk", "ep3-bulk" };
1270 dev->gadget.ep0 = &dev->ep [0].ep;
1340 /* expect ep0 requests when the host drops reset */
1405 /* then enable host detection and ep0; an
[all...]
H A Dinode.c53 * are two types of files. One type is for the device, implementing ep0.
90 /* /dev/gadget/$CHIP represents ep0 and the whole device */
97 * ep0/device i/o modes and binding to the controller. Driver
103 /* From then on, ep0 fd is in either of two basic modes:
112 /* UNBOUND means the driver closed ep0, so the device won't be
130 /* drivers reading ep0 MUST handle control requests (SETUP)
152 /* except this scratch i/o buffer for ep0 */
241 * at the end of ep0 configuration, or after unbind.
960 DBG (dev, "ep0 request busy!\n");
996 (void) usb_ep_set_halt (dev->gadget->ep0);
[all...]
H A Dlh7a40x_udc.c54 static const char ep0name[] = "ep0-control";
297 /* device/ep0 records init */
299 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
451 /* ... then enable host detection and ep0; and we're ready
1608 struct lh7a40x_ep *ep0 = &dev->ep[0]; local
1674 lh7a40x_fifo_write(ep0, (u8 *) & val, sizeof(val));
1809 * handle ep0 interrupt
1980 .ep0 = &memory.ep[0].ep,
H A Dnet2280.c86 static const char ep0name [] = "ep0";
1295 if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
1680 } else /* ep0 should only have one transfer queued */
1681 t = scnprintf (next, size, "ep0 max 64 pio %s\n",
1776 /* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
1913 dev->gadget.ep0 = &dev->ep [0].ep;
1915 INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
1950 /* enable irqs so we can see ep0 and general operation */
2015 /* ... then enable host detection and ep0; and we're ready
2097 /* handle ep0, e
[all...]
H A Domap_udc.c1193 /* just use protocol stalls for ep0; real halts are annoying */
1512 struct omap_ep *ep0 = &udc->ep[0]; local
1515 ep0->irqs++;
1523 nuke(ep0, 0);
1531 * This driver uses only uses protocol stalls (ep0 never halts),
1538 if (!list_empty(&ep0->queue))
1539 req = container_of(ep0->queue.next, struct omap_req, queue);
1554 stat = write_fifo(ep0, req);
1567 done(ep0, req, 0);
1591 if (!req || (stat = read_fifo(ep0, re
[all...]
H A Dpxa2xx_udc.c67 * There are fifteen endpoints, in addition to ep0.
87 static const char ep0name [] = "ep0";
544 /* caller asserts req->pending (ep0 irq status nyet cleared); starts
545 * ep0 data stage. these chips want very simple state transitions.
681 * special ep0 version of the above. no UBCR0 or double buffering; status
953 if (ep->desc == 0 /* ep0 */) {
967 DBG(DBG_VERBOSE, "ep0 config ack%s\n",
988 DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
1120 /* ep0 needs special care */
1321 /* registers for device and ep0 */
[all...]
H A Dserial.c512 /* assumes ep0 uses the same value for both speeds ... */
1406 gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1411 /* assume ep0 uses the same packet size for both speeds */
1451 dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
1459 gadget->ep0->driver_data = dev;
1486 gs_free_req(gadget->ep0, dev->dev_ctrl_req);
1537 && (ret % gadget->ep0->maxpacket) == 0;
1538 ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1543 gs_setup_complete(gadget->ep0, req);
H A Dzero.c907 * The setup() callback implements all the ep0 functionality that's
923 /* usually this stores reply data in the pre-allocated ep0 buffer,
1070 value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
1074 zero_setup_complete (gadget->ep0, req);
1129 free_ep_req (gadget->ep0, dev->req);
1193 dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
1196 dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
1203 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1206 /* assume ep0 uses the same value for both speeds ... */
1230 gadget->ep0
[all...]
/netgear-WNDR4500v2-V1.0.0.60_1.0.38/src/linux/linux-2.6/include/linux/
H A Dusb.h345 struct usb_host_endpoint ep0; member in struct:usb_device
H A Dusb_gadget.h141 * gadget->ep_list. the control endpoint (gadget->ep0) is not in that list,
157 * @ep:the endpoint being configured. may not be the endpoint named "ep0".
168 * the ep0 implementation (which calls this routine) must ensure that the
186 * @ep:the endpoint being unconfigured. may not be the endpoint named "ep0".
289 * (except control endpoints like ep0) may have more than one transfer
322 * used on ep0 to trigger protocol stalls.
465 * @ep0: Endpoint zero, used when reading or writing responses to
507 struct usb_ep *ep0; member in struct:usb_gadget
707 * At that point, ep0 is fully initialized, and ep_list holds
710 * @setup: Invoked for ep0 contro
[all...]

Completed in 239 milliseconds