Subversion Repositories shark

 /*

 * message.c - synchronous message handling

 */

#include <linuxcomp.h>

#include <linux/config.h>

#ifdef CONFIG_USB_DEBUG

        #define DEBUG

#else

        #undef DEBUG

#endif

#include <linux/pci.h>  /* for scatterlist macros */

#include <linux/usb.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/init.h>

#include <linux/mm.h>

#include <linux/timer.h>

#include <asm/byteorder.h>

#include "hcd.h"        /* for usbcore internals */

#include "usb.h"

static void usb_api_blocking_completion(struct urb *urb, struct pt_regs *regs)

{

        complete((struct completion *)urb->context);

}

static void timeout_kill(unsigned long data)

{

        struct urb      *urb = (struct urb *) data;

        dev_warn(&urb->dev->dev, "%s timeout on ep%d%s\n",

                usb_pipecontrol(urb->pipe) ? "control" : "bulk",

                usb_pipeendpoint(urb->pipe),

                usb_pipein(urb->pipe) ? "in" : "out");

        usb_unlink_urb(urb);

}                

// Starts urb and waits for completion or timeout

// note that this call is NOT interruptible, while

// many device driver i/o requests should be interruptible

static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)

{

        struct completion       done;

        struct timer_list       timer;

        int                     status;

        init_completion(&done);        

        urb->context = &done;

        urb->transfer_flags |= URB_ASYNC_UNLINK;

        urb->actual_length = 0;

        status = usb_submit_urb(urb, GFP_NOIO);

        if (status == 0) {

                if (timeout > 0) {

                        init_timer(&timer);

                        timer.expires = jiffies26 + timeout;

                        timer.data = (unsigned long)urb;

                        timer.function = timeout_kill;

                        /* grr.  timeout _should_ include submit delays. */

                        add_timer(&timer);

                }

                wait_for_completion(&done);

                status = urb->status;

                /* note:  HCDs return ETIMEDOUT for other reasons too */

                if (status == -ECONNRESET)

                        status = -ETIMEDOUT;

                if (timeout > 0)

                        del_timer_sync(&timer);

        }

        if (actual_length)

                *actual_length = urb->actual_length;

        usb_free_urb(urb);

        return status;

}

/*-------------------------------------------------------------------*/

// returns status (negative) or length (positive)

int usb_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,

                            struct usb_ctrlrequest *cmd,  void *data, int len, int timeout)

{

        struct urb *urb;

        int retv;

        int length;

        urb = usb_alloc_urb(0, GFP_NOIO);

        if (!urb)

                return -ENOMEM;

        usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char*)cmd, data, len,

                   usb_api_blocking_completion, 0);

        retv = usb_start_wait_urb(urb, timeout, &length);

        if (retv < 0)

                return retv;

        else

                return length;

}

/**

 *      usb_control_msg - Builds a control urb, sends it off and waits for completion

 *      @dev: pointer to the usb device to send the message to

 *      @pipe: endpoint "pipe" to send the message to

 *      @request: USB message request value

 *      @requesttype: USB message request type value

 *      @value: USB message value

 *      @index: USB message index value

 *      @data: pointer to the data to send

 *      @size: length in bytes of the data to send

 *      @timeout: time in jiffies26 to wait for the message to complete before

 *              timing out (if 0 the wait is forever)

 *      Context: !in_interrupt ()

 *

 *      This function sends a simple control message to a specified endpoint

 *      and waits for the message to complete, or timeout.

 *     

 *      If successful, it returns the number of bytes transferred, otherwise a negative error number.

 *

 *      Don't use this function from within an interrupt context, like a

 *      bottom half handler.  If you need an asynchronous message, or need to send

 *      a message from within interrupt context, use usb_submit_urb()

 *      If a thread in your driver uses this call, make sure your disconnect()

 *      method can wait for it to complete.  Since you don't have a handle on

 *      the URB used, you can't cancel the request.

 */

int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,

                         __u16 value, __u16 index, void *data, __u16 size, int timeout)

{

        struct usb_ctrlrequest *dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);

        int ret;

        if (!dr)

                return -ENOMEM;

        dr->bRequestType= requesttype;

        dr->bRequest = request;

        dr->wValue = cpu_to_le16p(&value);

        dr->wIndex = cpu_to_le16p(&index);

        dr->wLength = cpu_to_le16p(&size);

        //dbg("usb_control_msg");       

        ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);

        kfree(dr);

        return ret;

}

/**

 *      usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion

 *      @usb_dev: pointer to the usb device to send the message to

 *      @pipe: endpoint "pipe" to send the message to

 *      @data: pointer to the data to send

 *      @len: length in bytes of the data to send

 *      @actual_length: pointer to a location to put the actual length transferred in bytes

 *      @timeout: time in jiffies26 to wait for the message to complete before

 *              timing out (if 0 the wait is forever)

 *      Context: !in_interrupt ()

 *

 *      This function sends a simple bulk message to a specified endpoint

 *      and waits for the message to complete, or timeout.

 *     

 *      If successful, it returns 0, otherwise a negative error number.

 *      The number of actual bytes transferred will be stored in the

 *      actual_length paramater.

 *

 *      Don't use this function from within an interrupt context, like a

 *      bottom half handler.  If you need an asynchronous message, or need to

 *      send a message from within interrupt context, use usb_submit_urb()

 *      If a thread in your driver uses this call, make sure your disconnect()

 *      method can wait for it to complete.  Since you don't have a handle on

 *      the URB used, you can't cancel the request.

 */

int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,

                        void *data, int len, int *actual_length, int timeout)

{

        struct urb *urb;

        if (len < 0)

                return -EINVAL;

        urb=usb_alloc_urb(0, GFP_KERNEL);

        if (!urb)

                return -ENOMEM;

        usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,

                    usb_api_blocking_completion, 0);

        return usb_start_wait_urb(urb,timeout,actual_length);

}

/*-------------------------------------------------------------------*/

static void sg_clean (struct usb_sg_request *io)

{

        if (io->urbs) {

                while (io->entries--)

                        usb_free_urb (io->urbs [io->entries]);

                kfree (io->urbs);

                io->urbs = 0;

        }

        if (io->dev->dev.dma_mask != 0)

                usb_buffer_unmap_sg (io->dev, io->pipe, io->sg, io->nents);

        io->dev = 0;

}

static void sg_complete (struct urb *urb, struct pt_regs *regs)

{

        struct usb_sg_request   *io = (struct usb_sg_request *) urb->context;

        unsigned long           flags;

        spin_lock_irqsave (&io->lock, flags);

        /* In 2.5 we require hcds' endpoint queues not to progress after fault

         * reports, until the completion callback (this!) returns.  That lets

         * device driver code (like this routine) unlink queued urbs first,

         * if it needs to, since the HC won't work on them at all.  So it's

         * not possible for page N+1 to overwrite page N, and so on.

         *

         * That's only for "hard" faults; "soft" faults (unlinks) sometimes

         * complete before the HCD can get requests away from hardware,

         * though never during cleanup after a hard fault.

         */

        if (io->status

                        && (io->status != -ECONNRESET

                                || urb->status != -ECONNRESET)

                        && urb->actual_length) {

                dev_err (io->dev->bus->controller,

                        "dev %s ep%d%s scatterlist error %d/%d\n",

                        io->dev->devpath,

                        usb_pipeendpoint (urb->pipe),

                        usb_pipein (urb->pipe) ? "in" : "out",

                        urb->status, io->status);

                // BUG ();

        }

        if (urb->status && urb->status != -ECONNRESET) {

                int             i, found, status;

                io->status = urb->status;

                /* the previous urbs, and this one, completed already.

                 * unlink pending urbs so they won't rx/tx bad data.

                 */

                for (i = 0, found = 0; i < io->entries; i++) {

                        if (!io->urbs [i])

                                continue;

                        if (found) {

                                status = usb_unlink_urb (io->urbs [i]);

                                if (status != -EINPROGRESS && status != -EBUSY)

                                        dev_err (&io->dev->dev,

                                                "%s, unlink --> %d\n",

                                                __FUNCTION__, status);

                        } else if (urb == io->urbs [i])

                                found = 1;

                }

        }

        urb->dev = 0;

        /* on the last completion, signal usb_sg_wait() */

        io->bytes += urb->actual_length;

        io->count--;

        if (!io->count)

                complete (&io->complete);

        spin_unlock_irqrestore (&io->lock, flags);

}

/**

 * usb_sg_init - initializes scatterlist-based bulk/interrupt I/O request

 * @io: request block being initialized.  until usb_sg_wait() returns,

 *      treat this as a pointer to an opaque block of memory,

 * @dev: the usb device that will send or receive the data

 * @pipe: endpoint "pipe" used to transfer the data

 * @period: polling rate for interrupt endpoints, in frames or

 *      (for high speed endpoints) microframes; ignored for bulk

 * @sg: scatterlist entries

 * @nents: how many entries in the scatterlist

 * @length: how many bytes to send from the scatterlist, or zero to

 *      send every byte identified in the list.

 * @mem_flags: SLAB_* flags affecting memory allocations in this call

 *

 * Returns zero for success, else a negative errno value.  This initializes a

 * scatter/gather request, allocating resources such as I/O mappings and urb

 * memory (except maybe memory used by USB controller drivers).

 *

 * The request must be issued using usb_sg_wait(), which waits for the I/O to

 * complete (or to be canceled) and then cleans up all resources allocated by

 * usb_sg_init().

 *

 * The request may be canceled with usb_sg_cancel(), either before or after

 * usb_sg_wait() is called.

 */

int usb_sg_init (

        struct usb_sg_request   *io,

        struct usb_device       *dev,

        unsigned                pipe,

        unsigned                period,

        struct scatterlist      *sg,

        int                     nents,

        size_t                  length,

        int                     mem_flags

)

{

        int                     i;

        int                     urb_flags;

        int                     dma;

        if (!io || !dev || !sg

                        || usb_pipecontrol (pipe)

                        || usb_pipeisoc (pipe)

                        || nents <= 0)

                return -EINVAL;

        spin_lock_init (&io->lock);

        io->dev = dev;

        io->pipe = pipe;

        io->sg = sg;

        io->nents = nents;

        /* not all host controllers use DMA (like the mainstream pci ones);

         * they can use PIO (sl811) or be software over another transport.

         */

        dma = (dev->dev.dma_mask != 0);

        if (dma)

                io->entries = usb_buffer_map_sg (dev, pipe, sg, nents);

        else

                io->entries = nents;

        /* initialize all the urbs we'll use */

        if (io->entries <= 0)

                return io->entries;

        io->count = 0;

        io->urbs = kmalloc (io->entries * sizeof *io->urbs, mem_flags);

        if (!io->urbs)

                goto nomem;

        urb_flags = URB_ASYNC_UNLINK | URB_NO_TRANSFER_DMA_MAP

                        | URB_NO_INTERRUPT;

        if (usb_pipein (pipe))

                urb_flags |= URB_SHORT_NOT_OK;

        for (i = 0; i < io->entries; i++, io->count = i) {

                unsigned                len;

                io->urbs [i] = usb_alloc_urb (0, mem_flags);

                if (!io->urbs [i]) {

                        io->entries = i;

                        goto nomem;

                }

                io->urbs [i]->dev = 0;

                io->urbs [i]->pipe = pipe;

                io->urbs [i]->interval = period;

                io->urbs [i]->transfer_flags = urb_flags;

                io->urbs [i]->complete = sg_complete;

                io->urbs [i]->context = io;

                io->urbs [i]->status = -EINPROGRESS;

                io->urbs [i]->actual_length = 0;

                if (dma) {

                        /* hc may use _only_ transfer_dma */

                        io->urbs [i]->transfer_dma = sg_dma_address (sg + i);

                        len = sg_dma_len (sg + i);

                } else {

                        /* hc may use _only_ transfer_buffer */

                        io->urbs [i]->transfer_buffer =

                                page_address (sg [i].page) + sg [i].offset;

                        len = sg [i].length;

                }

                if (length) {

                        len = min_t (unsigned, len, length);

                        length -= len;

                        if (length == 0)

                                io->entries = i + 1;

                }

                io->urbs [i]->transfer_buffer_length = len;

        }

        io->urbs [--i]->transfer_flags &= ~URB_NO_INTERRUPT;

        /* transaction state */

        io->status = 0;

        io->bytes = 0;

        init_completion (&io->complete);

        return 0;

nomem:

        sg_clean (io);

        return -ENOMEM;

}

/**

 * usb_sg_wait - synchronously execute scatter/gather request

 * @io: request block handle, as initialized with usb_sg_init().

 *      some fields become accessible when this call returns.

 * Context: !in_interrupt ()

 *

 * This function blocks until the specified I/O operation completes.  It

 * leverages the grouping of the related I/O requests to get good transfer

 * rates, by queueing the requests.  At higher speeds, such queuing can

 * significantly improve USB throughput.

 *

 * There are three kinds of completion for this function.

 * (1) success, where io->status is zero.  The number of io->bytes

 *     transferred is as requested.

 * (2) error, where io->status is a negative errno value.  The number

 *     of io->bytes transferred before the error is usually less

 *     than requested, and can be nonzero.

 * (3) cancelation, a type of error with status -ECONNRESET that

 *     is initiated by usb_sg_cancel().

 *

 * When this function returns, all memory allocated through usb_sg_init() or

 * this call will have been freed.  The request block parameter may still be

 * passed to usb_sg_cancel(), or it may be freed.  It could also be

 * reinitialized and then reused.

 *

 * Data Transfer Rates:

 *

 * Bulk transfers are valid for full or high speed endpoints.

 * The best full speed data rate is 19 packets of 64 bytes each

 * per frame, or 1216 bytes per millisecond.

 * The best high speed data rate is 13 packets of 512 bytes each

 * per microframe, or 52 KBytes per millisecond.

 *

 * The reason to use interrupt transfers through this API would most likely

 * be to reserve high speed bandwidth, where up to 24 KBytes per millisecond

 * could be transferred.  That capability is less useful for low or full

 * speed interrupt endpoints, which allow at most one packet per millisecond,

 * of at most 8 or 64 bytes (respectively).

 */

void usb_sg_wait (struct usb_sg_request *io)

{

        int             i;

        unsigned long   flags;

        /* queue the urbs.  */

        spin_lock_irqsave (&io->lock, flags);

        for (i = 0; i < io->entries && !io->status; i++) {

                int     retval;

                io->urbs [i]->dev = io->dev;

                retval = usb_submit_urb (io->urbs [i], SLAB_ATOMIC);

                /* after we submit, let completions or cancelations fire;

                 * we handshake using io->status.

                 */

                spin_unlock_irqrestore (&io->lock, flags);

                switch (retval) {

                        /* maybe we retrying will recover */

                case -ENXIO:    // hc didn't queue this one

                case -EAGAIN:

                case -ENOMEM:

                        io->urbs [i]->dev = 0;

                        retval = 0;

                        i--;

                        yield ();

                        break;

                        /* no error? continue immediately.

                         *

                         * NOTE: to work better with UHCI (4K I/O buffer may

                         * need 3K of TDs) it may be good to limit how many

                         * URBs are queued at once; N milliseconds?

                         */

                case 0:

                        cpu_relax ();

                        break;

                        /* fail any uncompleted urbs */

                default:

                        io->urbs [i]->dev = 0;

                        io->urbs [i]->status = retval;

                        dev_dbg (&io->dev->dev, "%s, submit --> %d\n",

                                __FUNCTION__, retval);

                        usb_sg_cancel (io);

                }

                spin_lock_irqsave (&io->lock, flags);

                if (retval && io->status == -ECONNRESET)

                        io->status = retval;

        }

        spin_unlock_irqrestore (&io->lock, flags);

        /* OK, yes, this could be packaged as non-blocking.

         * So could the submit loop above ... but it's easier to

         * solve neither problem than to solve both!

         */

        wait_for_completion (&io->complete);

        sg_clean (io);

}

/**

 * usb_sg_cancel - stop scatter/gather i/o issued by usb_sg_wait()

 * @io: request block, initialized with usb_sg_init()

 *

 * This stops a request after it has been started by usb_sg_wait().

 * It can also prevents one initialized by usb_sg_init() from starting,

 * so that call just frees resources allocated to the request.

 */

void usb_sg_cancel (struct usb_sg_request *io)

{

        unsigned long   flags;

        spin_lock_irqsave (&io->lock, flags);

        /* shut everything down, if it didn't already */

        if (!io->status) {

                int     i;

                io->status = -ECONNRESET;

                for (i = 0; i < io->entries; i++) {

                        int     retval;

                        if (!io->urbs [i]->dev)

                                continue;

                        retval = usb_unlink_urb (io->urbs [i]);

                        if (retval != -EINPROGRESS && retval != -EBUSY)

                                dev_warn (&io->dev->dev, "%s, unlink --> %d\n",

                                        __FUNCTION__, retval);

                }

        }

        spin_unlock_irqrestore (&io->lock, flags);

}

/*-------------------------------------------------------------------*/

/**

 * usb_get_descriptor - issues a generic GET_DESCRIPTOR request

 * @dev: the device whose descriptor is being retrieved

 * @type: the descriptor type (USB_DT_*)

 * @index: the number of the descriptor

 * @buf: where to put the descriptor

 * @size: how big is "buf"?

 * Context: !in_interrupt ()

 *

 * Gets a USB descriptor.  Convenience functions exist to simplify

 * getting some types of descriptors.  Use

 * usb_get_device_descriptor() for USB_DT_DEVICE,

 * and usb_get_string() or usb_string() for USB_DT_STRING.

 * Configuration descriptors (USB_DT_CONFIG) are part of the device

 * structure, at least for the current configuration.

 * In addition to a number of USB-standard descriptors, some

 * devices also use class-specific or vendor-specific descriptors.

 *

 * This call is synchronous, and may not be used in an interrupt context.

 *

 * Returns the number of bytes received on success, or else the status code

 * returned by the underlying usb_control_msg() call.

 */

int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)

{

        int i = 5;

        int result = 0;

        memset(buf,0,size);     // Make sure we parse really received data

        while (i--) {

                /* retries if the returned length was 0; flakey device */

                if ((result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),

                                    USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,

                                    (type << 8) + index, 0, buf, size,

                                    HZ * USB_CTRL_GET_TIMEOUT)) > 0

                                || result == -EPIPE)

                        break;

        }

        return result;

}

/**

 * usb_get_string - gets a string descriptor

 * @dev: the device whose string descriptor is being retrieved

 * @langid: code for language chosen (from string descriptor zero)

 * @index: the number of the descriptor

 * @buf: where to put the string

 * @size: how big is "buf"?

 * Context: !in_interrupt ()

 *

 * Retrieves a string, encoded using UTF-16LE (Unicode, 16 bits per character,

 * in little-endian byte order).

 * The usb_string() function will often be a convenient way to turn

 * these strings into kernel-printable form.

 *

 * Strings may be referenced in device, configuration, interface, or other

 * descriptors, and could also be used in vendor-specific ways.

 *

 * This call is synchronous, and may not be used in an interrupt context.

 *

 * Returns the number of bytes received on success, or else the status code

 * returned by the underlying usb_control_msg() call.

 */

int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size)

{

        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),

                USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,

                (USB_DT_STRING << 8) + index, langid, buf, size,

                HZ * USB_CTRL_GET_TIMEOUT);

}

/**

 * usb_get_device_descriptor - (re)reads the device descriptor

 * @dev: the device whose device descriptor is being updated

 * Context: !in_interrupt ()

 *

 * Updates the copy of the device descriptor stored in the device structure,

 * which dedicates space for this purpose.  Note that several fields are

 * converted to the host CPU's byte order:  the USB version (bcdUSB), and

 * vendors product and version fields (idVendor, idProduct, and bcdDevice).

 * That lets device drivers compare against non-byteswapped constants.

 *

 * There's normally no need to use this call, although some devices

 * will change their descriptors after events like updating firmware.

 *

 * This call is synchronous, and may not be used in an interrupt context.

 *

 * Returns the number of bytes received on success, or else the status code

 * returned by the underlying usb_control_msg() call.

 */

int usb_get_device_descriptor(struct usb_device *dev)

{

        int ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor,

                                     sizeof(dev->descriptor));

        if (ret >= 0) {

                le16_to_cpus(&dev->descriptor.bcdUSB);

                le16_to_cpus(&dev->descriptor.idVendor);

                le16_to_cpus(&dev->descriptor.idProduct);

                le16_to_cpus(&dev->descriptor.bcdDevice);

        }

        return ret;

}

/**

 * usb_get_status - issues a GET_STATUS call

 * @dev: the device whose status is being checked

 * @type: USB_RECIP_*; for device, interface, or endpoint

 * @target: zero (for device), else interface or endpoint number

 * @data: pointer to two bytes of bitmap data

 * Context: !in_interrupt ()

 *

 * Returns device, interface, or endpoint status.  Normally only of

 * interest to see if the device is self powered, or has enabled the

 * remote wakeup facility; or whether a bulk or interrupt endpoint

 * is halted ("stalled").

 *

 * Bits in these status bitmaps are set using the SET_FEATURE request,

 * and cleared using the CLEAR_FEATURE request.  The usb_clear_halt()

 * function should be used to clear halt ("stall") status.

 *

 * This call is synchronous, and may not be used in an interrupt context.

 *

 * Returns the number of bytes received on success, or else the status code

 * returned by the underlying usb_control_msg() call.

 */

int usb_get_status(struct usb_device *dev, int type, int target, void *data)

{

        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),

                USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, data, 2,

                HZ * USB_CTRL_GET_TIMEOUT);

}

/**

 * usb_clear_halt - tells device to clear endpoint halt/stall condition

 * @dev: device whose endpoint is halted

 * @pipe: endpoint "pipe" being cleared

 * Context: !in_interrupt ()

 *

 * This is used to clear halt conditions for bulk and interrupt endpoints,

 * as reported by URB completion status.  Endpoints that are halted are

 * sometimes referred to as being "stalled".  Such endpoints are unable

 * to transmit or receive data until the halt status is cleared.  Any URBs

 * queued for such an endpoint should normally be unlinked by the driver

 * before clearing the halt condition, as described in sections 5.7.5

 * and 5.8.5 of the USB 2.0 spec.

 *

 * Note that control and isochronous endpoints don't halt, although control

 * endpoints report "protocol stall" (for unsupported requests) using the

 * same status code used to report a true stall.

 *

 * This call is synchronous, and may not be used in an interrupt context.

 *

 * Returns zero on success, or else the status code returned by the

 * underlying usb_control_msg() call.

 */

int usb_clear_halt(struct usb_device *dev, int pipe)

{

        int result;

        int endp = usb_pipeendpoint(pipe);

        if (usb_pipein (pipe))

                endp |= USB_DIR_IN;

        /* we don't care if it wasn't halted first. in fact some devices

         * (like some ibmcam model 1 units) seem to expect hosts to make

         * this request for iso endpoints, which can't halt!

         */

        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),

                USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0,

                HZ * USB_CTRL_SET_TIMEOUT);

        /* don't un-halt or force to DATA0 except on success */

        if (result < 0)

                return result;

        /* NOTE:  seems like Microsoft and Apple don't bother verifying

         * the clear "took", so some devices could lock up if you check...

         * such as the Hagiwara FlashGate DUAL.  So we won't bother.

         *

         * NOTE:  make sure the logic here doesn't diverge much from

         * the copy in usb-storage, for as long as we need two copies.

         */

        /* toggle was reset by the clear, then ep was reactivated */

        usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);

        usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));

        return 0;

}

/**

 * usb_disable_endpoint -- Disable an endpoint by address

 * @dev: the device whose endpoint is being disabled

 * @epaddr: the endpoint's address.  Endpoint number for output,

 *      endpoint number + USB_DIR_IN for input

 *

 * Deallocates hcd/hardware state for this endpoint ... and nukes all

 * pending urbs.

 *

 * If the HCD hasn't registered a disable() function, this marks the

 * endpoint as halted and sets its maxpacket size to 0 to prevent

 * further submissions.

 */

void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr)

{

        if (dev && dev->bus && dev->bus->op && dev->bus->op->disable)

                dev->bus->op->disable(dev, epaddr);

        else {

                unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;

                if (usb_endpoint_out(epaddr)) {

                        usb_endpoint_halt(dev, epnum, 1);

                        dev->epmaxpacketout[epnum] = 0;

                } else {

                        usb_endpoint_halt(dev, epnum, 0);

                        dev->epmaxpacketin[epnum] = 0;

                }

        }

}

/**

 * usb_disable_interface -- Disable all endpoints for an interface

 * @dev: the device whose interface is being disabled

 * @intf: pointer to the interface descriptor

 *

 * Disables all the endpoints for the interface's current altsetting.

 */

void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf)

{

        struct usb_host_interface *hintf =

                        &intf->altsetting[intf->act_altsetting];

        int i;

        for (i = 0; i < hintf->desc.bNumEndpoints; ++i) {

                usb_disable_endpoint(dev,

                                hintf->endpoint[i].desc.bEndpointAddress);

        }

}

/*

 * usb_disable_device - Disable all the endpoints for a USB device

 * @dev: the device whose endpoints are being disabled

 * @skip_ep0: 0 to disable endpoint 0, 1 to skip it.

 *

 * Disables all the device's endpoints, potentially including endpoint 0.

 * Deallocates hcd/hardware state for the endpoints (nuking all or most

 * pending urbs) and usbcore state for the interfaces, so that usbcore

 * must usb_set_configuration() before any interfaces could be used.

 */

void usb_disable_device(struct usb_device *dev, int skip_ep0)

{

        int i;

        dev_dbg(&dev->dev, "%s nuking %s URBs\n", __FUNCTION__,

                        skip_ep0 ? "non-ep0" : "all");

        for (i = skip_ep0; i < 16; ++i) {

                usb_disable_endpoint(dev, i);

                usb_disable_endpoint(dev, i + USB_DIR_IN);

        }

        dev->toggle[0] = dev->toggle[1] = 0;

        dev->halted[0] = dev->halted[1] = 0;

        /* getting rid of interfaces will disconnect

         * any drivers bound to them (a key side effect)

         */

        if (dev->actconfig) {

                for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {

                        struct usb_interface    *interface;

                        /* remove this interface */

                        interface = dev->actconfig->interface[i];

                        dev_dbg (&dev->dev, "unregistering interface %s\n",

                                interface->dev.bus_id);

                        device_del(&interface->dev);

                }

                dev->actconfig = 0;

                if (dev->state == USB_STATE_CONFIGURED)

                        dev->state = USB_STATE_ADDRESS;

        }

}

/*

 * usb_enable_endpoint - Enable an endpoint for USB communications

 * @dev: the device whose interface is being enabled

 * @epd: pointer to the endpoint descriptor

 *

 * Marks the endpoint as running, resets its toggle, and stores

 * its maxpacket value.  For control endpoints, both the input

 * and output sides are handled.

 */

void usb_enable_endpoint(struct usb_device *dev,

                struct usb_endpoint_descriptor *epd)

{