/* Driver for Realtek RTS51xx USB card reader
 *
 * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Author:
 *   wwang (wei_wang@realsil.com.cn)
 *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
 * Maintainer:
 *   Edwin Rong (edwin_rong@realsil.com.cn)
 *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
 */

#include <linux/blkdev.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/slab.h>

#include <scsi/scsi.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_device.h>

#include "debug.h"
#include "rts51x.h"
#include "rts51x_chip.h"
#include "rts51x_card.h"
#include "rts51x_scsi.h"
#include "rts51x_transport.h"
#include "trace.h"

/***********************************************************************
 * Scatter-gather transfer buffer access routines
 ***********************************************************************/

/* Copy a buffer of length buflen to/from the srb's transfer buffer.
 * Update the **sgptr and *offset variables so that the next copy will
 * pick up from where this one left off.
 */

unsigned int rts51x_access_sglist(unsigned char *buffer,
                                  unsigned int buflen, void *sglist,
                                  void **sgptr, unsigned int *offset,
                                  enum xfer_buf_dir dir)
{
        unsigned int cnt;
        struct scatterlist *sg = (struct scatterlist *)*sgptr;

        /* We have to go through the list one entry
         * at a time.  Each s-g entry contains some number of pages, and
         * each page has to be kmap()'ed separately.  If the page is already
         * in kernel-addressable memory then kmap() will return its address.
         * If the page is not directly accessible -- such as a user buffer
         * located in high memory -- then kmap() will map it to a temporary
         * position in the kernel's virtual address space.
         */

        if (!sg)
                sg = (struct scatterlist *)sglist;

        /* This loop handles a single s-g list entry, which may
         * include multiple pages.  Find the initial page structure
         * and the starting offset within the page, and update
         * the *offset and **sgptr values for the next loop.
         */
        cnt = 0;
        while (cnt < buflen && sg) {
                struct page *page = sg_page(sg) +
                    ((sg->offset + *offset) >> PAGE_SHIFT);
                unsigned int poff = (sg->offset + *offset) & (PAGE_SIZE - 1);
                unsigned int sglen = sg->length - *offset;

                if (sglen > buflen - cnt) {

                        /* Transfer ends within this s-g entry */
                        sglen = buflen - cnt;
                        *offset += sglen;
                } else {

                        /* Transfer continues to next s-g entry */
                        *offset = 0;
                        sg = sg_next(sg);
                }

                /* Transfer the data for all the pages in this
                 * s-g entry.  For each page: call kmap(), do the
                 * transfer, and call kunmap() immediately after. */
                while (sglen > 0) {
                        unsigned int plen = min(sglen, (unsigned int)
                                                PAGE_SIZE - poff);
                        unsigned char *ptr = kmap(page);

                        if (dir == TO_XFER_BUF)
                                memcpy(ptr + poff, buffer + cnt, plen);
                        else
                                memcpy(buffer + cnt, ptr + poff, plen);
                        kunmap(page);

                        /* Start at the beginning of the next page */
                        poff = 0;
                        ++page;
                        cnt += plen;
                        sglen -= plen;
                }
        }
        *sgptr = sg;

        /* Return the amount actually transferred */
        return cnt;
}

unsigned int rts51x_access_xfer_buf(unsigned char *buffer,
                                    unsigned int buflen, struct scsi_cmnd *srb,
                                    struct scatterlist **sgptr,
                                    unsigned int *offset, enum xfer_buf_dir dir)
{
        return rts51x_access_sglist(buffer, buflen, (void *)scsi_sglist(srb),
                                    (void **)sgptr, offset, dir);
}

/* Store the contents of buffer into srb's transfer buffer and set the
 * SCSI residue.
 */
void rts51x_set_xfer_buf(unsigned char *buffer,
                         unsigned int buflen, struct scsi_cmnd *srb)
{
        unsigned int offset = 0;
        struct scatterlist *sg = NULL;

        buflen = min(buflen, scsi_bufflen(srb));
        buflen = rts51x_access_xfer_buf(buffer, buflen, srb, &sg, &offset,
                                        TO_XFER_BUF);
        if (buflen < scsi_bufflen(srb))
                scsi_set_resid(srb, scsi_bufflen(srb) - buflen);
}

void rts51x_get_xfer_buf(unsigned char *buffer,
                         unsigned int buflen, struct scsi_cmnd *srb)
{
        unsigned int offset = 0;
        struct scatterlist *sg = NULL;

        buflen = min(buflen, scsi_bufflen(srb));
        buflen = rts51x_access_xfer_buf(buffer, buflen, srb, &sg, &offset,
                                        FROM_XFER_BUF);
        if (buflen < scsi_bufflen(srb))
                scsi_set_resid(srb, scsi_bufflen(srb) - buflen);
}

/* This is the completion handler which will wake us up when an URB
 * completes.
 */
static void urb_done_completion(struct urb *urb)
{
        struct completion *urb_done_ptr = urb->context;

        if (urb_done_ptr)
                complete(urb_done_ptr);
}

/* This is the common part of the URB message submission code
 *
 * All URBs from the driver involved in handling a queued scsi
 * command _must_ pass through this function (or something like it) for the
 * abort mechanisms to work properly.
 */
static int rts51x_msg_common(struct rts51x_chip *chip, struct urb *urb,
                             int timeout)
{
        struct rts51x_usb *rts51x = chip->usb;
        struct completion urb_done;
        long timeleft;
        int status;

        /* don't submit URBs during abort processing */
        if (test_bit(FLIDX_ABORTING, &rts51x->dflags))
                TRACE_RET(chip, -EIO);

        /* set up data structures for the wakeup system */
        init_completion(&urb_done);

        /* fill the common fields in the URB */
        urb->context = &urb_done;
        urb->actual_length = 0;
        urb->error_count = 0;
        urb->status = 0;

        /* we assume that if transfer_buffer isn't us->iobuf then it
         * hasn't been mapped for DMA.  Yes, this is clunky, but it's
         * easier than always having the caller tell us whether the
         * transfer buffer has already been mapped. */
        urb->transfer_flags = URB_NO_SETUP_DMA_MAP;
        if (urb->transfer_buffer == rts51x->iobuf) {
                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
                urb->transfer_dma = rts51x->iobuf_dma;
        }
        urb->setup_dma = rts51x->cr_dma;

        /* submit the URB */
        status = usb_submit_urb(urb, GFP_NOIO);
        if (status) {
                /* something went wrong */
                TRACE_RET(chip, status);
        }

        /* since the URB has been submitted successfully, it's now okay
         * to cancel it */
        set_bit(FLIDX_URB_ACTIVE, &rts51x->dflags);

        /* did an abort occur during the submission? */
        if (test_bit(FLIDX_ABORTING, &rts51x->dflags)) {

                /* cancel the URB, if it hasn't been cancelled already */
                if (test_and_clear_bit(FLIDX_URB_ACTIVE, &rts51x->dflags)) {
                        RTS51X_DEBUGP("-- cancelling URB\n");
                        usb_unlink_urb(urb);
                }
        }

        /* wait for the completion of the URB */
        timeleft =
            wait_for_completion_interruptible_timeout(&urb_done,
                                                      (timeout * HZ /
                                                       1000) ? :
                                                      MAX_SCHEDULE_TIMEOUT);

        clear_bit(FLIDX_URB_ACTIVE, &rts51x->dflags);

        if (timeleft <= 0) {
                RTS51X_DEBUGP("%s -- cancelling URB\n",
                               timeleft == 0 ? "Timeout" : "Signal");
                usb_kill_urb(urb);
                if (timeleft == 0)
                        status = -ETIMEDOUT;
                else
                        status = -EINTR;
        } else {
                status = urb->status;
        }

        return status;
}

/*
 * Interpret the results of a URB transfer
 */
static int interpret_urb_result(struct rts51x_chip *chip, unsigned int pipe,
                                unsigned int length, int result,
                                unsigned int partial)
{
        int retval = STATUS_SUCCESS;

        /* RTS51X_DEBUGP("Status code %d; transferred %u/%u\n",
                                result, partial, length); */
        switch (result) {
                /* no error code; did we send all the data? */
        case 0:
                if (partial != length) {
                        RTS51X_DEBUGP("-- short transfer\n");
                        TRACE_RET(chip, STATUS_TRANS_SHORT);
                }
                /* RTS51X_DEBUGP("-- transfer complete\n"); */
                return STATUS_SUCCESS;
                /* stalled */
        case -EPIPE:
                /* for control endpoints, (used by CB[I]) a stall indicates
                 * a failed command */
                if (usb_pipecontrol(pipe)) {
                        RTS51X_DEBUGP("-- stall on control pipe\n");
                        TRACE_RET(chip, STATUS_STALLED);
                }
                /* for other sorts of endpoint, clear the stall */
                RTS51X_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
                if (rts51x_clear_halt(chip, pipe) < 0)
                        TRACE_RET(chip, STATUS_ERROR);
                retval = STATUS_STALLED;
                TRACE_GOTO(chip, Exit);

                /* babble - the device tried to send more than
                 * we wanted to read */
        case -EOVERFLOW:
                RTS51X_DEBUGP("-- babble\n");
                retval = STATUS_TRANS_LONG;
                TRACE_GOTO(chip, Exit);

                /* the transfer was cancelled by abort,
                 * disconnect, or timeout */
        case -ECONNRESET:
                RTS51X_DEBUGP("-- transfer cancelled\n");
                retval = STATUS_ERROR;
                TRACE_GOTO(chip, Exit);

                /* short scatter-gather read transfer */
        case -EREMOTEIO:
                RTS51X_DEBUGP("-- short read transfer\n");
                retval = STATUS_TRANS_SHORT;
                TRACE_GOTO(chip, Exit);

                /* abort or disconnect in progress */
        case -EIO:
                RTS51X_DEBUGP("-- abort or disconnect in progress\n");
                retval = STATUS_ERROR;
                TRACE_GOTO(chip, Exit);

        case -ETIMEDOUT:
                RTS51X_DEBUGP("-- time out\n");
                retval = STATUS_TIMEDOUT;
                TRACE_GOTO(chip, Exit);

                /* the catch-all error case */
        default:
                RTS51X_DEBUGP("-- unknown error\n");
                retval = STATUS_ERROR;
                TRACE_GOTO(chip, Exit);
        }

Exit:
        if ((retval != STATUS_SUCCESS) && !usb_pipecontrol(pipe))
                rts51x_clear_hw_error(chip);

        return retval;
}

int rts51x_ctrl_transfer(struct rts51x_chip *chip, unsigned int pipe,
                         u8 request, u8 requesttype, u16 value, u16 index,
                         void *data, u16 size, int timeout)
{
        struct rts51x_usb *rts51x = chip->usb;
        int result;

        RTS51X_DEBUGP("%s: rq=%02x rqtype=%02x value=%04x index=%02x len=%u\n",
                       __func__, request, requesttype, value, index, size);

        /* fill in the devrequest structure */
        rts51x->cr->bRequestType = requesttype;
        rts51x->cr->bRequest = request;
        rts51x->cr->wValue = cpu_to_le16(value);
        rts51x->cr->wIndex = cpu_to_le16(index);
        rts51x->cr->wLength = cpu_to_le16(size);

        /* fill and submit the URB */
        usb_fill_control_urb(rts51x->current_urb, rts51x->pusb_dev, pipe,
                             (unsigned char *)rts51x->cr, data, size,
                             urb_done_completion, NULL);
        result = rts51x_msg_common(chip, rts51x->current_urb, timeout);

        return interpret_urb_result(chip, pipe, size, result,
                                    rts51x->current_urb->actual_length);
}

int rts51x_clear_halt(struct rts51x_chip *chip, unsigned int pipe)
{
        int result;
        int endp = usb_pipeendpoint(pipe);

        if (usb_pipein(pipe))
                endp |= USB_DIR_IN;

        result = rts51x_ctrl_transfer(chip, SND_CTRL_PIPE(chip),
                                      USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
                                      USB_ENDPOINT_HALT, endp, NULL, 0, 3000);
        if (result != STATUS_SUCCESS)
                TRACE_RET(chip, STATUS_FAIL);

        usb_reset_endpoint(chip->usb->pusb_dev, endp);

        return STATUS_SUCCESS;
}

int rts51x_reset_pipe(struct rts51x_chip *chip, char pipe)
{
        return rts51x_clear_halt(chip, pipe);
}

static void rts51x_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 = NULL;
        }
#if 0 /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35) */
        if (io->dev->dev.dma_mask != NULL)
                usb_buffer_unmap_sg(io->dev, usb_pipein(io->pipe),
                                    io->sg, io->nents);
#endif
        io->dev = NULL;
}
#if 0
static void rts51x_sg_complete(struct urb *urb)
{
        struct usb_sg_request *io = urb->context;
        int status = urb->status;

        spin_lock(&io->lock);

        /* 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
                || 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_endpoint_num(&urb->ep->desc),
                                usb_urb_dir_in(urb) ? "in" : "out",
                                status, io->status);
                        /* BUG (); */
        }

        if (io->status == 0 && status && status != -ECONNRESET) {
                int i, found, retval;

                io->status = status;

                /* the previous urbs, and this one, completed already.
                * unlink pending urbs so they won't rx/tx bad data.
                * careful: unlink can sometimes be synchronous...
                */
                spin_unlock(&io->lock);
                for (i = 0, found = 0; i < io->entries; i++) {
                        if (!io->urbs[i] || !io->urbs[i]->dev)
                                continue;
                        if (found) {
                                retval = usb_unlink_urb(io->urbs[i]);
                                if (retval != -EINPROGRESS &&
                                        retval != -ENODEV &&
                                        retval != -EBUSY)
                                        dev_err(&io->dev->dev,
                                                "%s, unlink --> %d\n",
                                                __func__, retval);
                        } else if (urb == io->urbs[i])
                                found = 1;
                }
                spin_lock(&io->lock);
        }
        urb->dev = NULL;

        /* on the last completion, signal usb_sg_wait() */
        io->bytes += urb->actual_length;
        io->count--;
        if (!io->count)
                complete(&io->complete);

        spin_unlock(&io->lock);
}

/* This function is ported from usb_sg_init, which can transfer
 * sg list partially */
int rts51x_sg_init_partial(struct usb_sg_request *io, struct usb_device *dev,
        unsigned pipe, unsigned period, void *buf, struct scatterlist **sgptr,
        unsigned int *offset, int nents, size_t length, gfp_t mem_flags)
{
        int i;
        int urb_flags;
        int dma;
        struct scatterlist *sg = *sgptr, *first_sg;

        first_sg = (struct scatterlist *)buf;
        if (!sg)
                sg = first_sg;

        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 = first_sg;  /* used by unmap */
        io->nents = nents;

        RTS51X_DEBUGP("Before map, sg address: 0x%x\n", (unsigned int)sg);
        RTS51X_DEBUGP("Before map, dev address: 0x%x\n", (unsigned int)dev);

        /* 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 != NULL);
        if (dma) {
                /* map the whole sg list, because here we only know the
                 * total nents */
                io->entries = usb_buffer_map_sg(dev, usb_pipein(pipe),
                first_sg, nents);
        } else {
                io->entries = nents;
        }

        /* initialize all the urbs we'll use */
        if (io->entries <= 0)
                return io->entries;

        io->urbs = kmalloc(io->entries * sizeof *io->urbs, mem_flags);
        if (!io->urbs)
                goto nomem;

        urb_flags = URB_NO_INTERRUPT;
        if (dma)
                urb_flags |= URB_NO_TRANSFER_DMA_MAP;
        if (usb_pipein(pipe))
                urb_flags |= URB_SHORT_NOT_OK;

        RTS51X_DEBUGP("io->entries = %d\n", io->entries);

        for (i = 0; (sg != NULL) && (length > 0); i++) {
                unsigned len;

                RTS51X_DEBUGP("sg address: 0x%x\n", (unsigned int)sg);
                RTS51X_DEBUGP("length = %d, *offset = %d\n", length, *offset);

                io->urbs[i] = usb_alloc_urb(0, mem_flags);
                if (!io->urbs[i]) {
                        io->entries = i;
                        goto nomem;
                }

                io->urbs[i]->dev = NULL;
                io->urbs[i]->pipe = pipe;
                io->urbs[i]->interval = period;
                io->urbs[i]->transfer_flags = urb_flags;

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

                if (dma) {
                        io->urbs[i]->transfer_dma =
                                sg_dma_address(sg) + *offset;
                        len = sg_dma_len(sg) - *offset;
                        io->urbs[i]->transfer_buffer = NULL;
                        RTS51X_DEBUGP(" -- sg entry dma length = %d\n",
                                                sg_dma_len(sg));
                } else {
                        /* hc may use _only_ transfer_buffer */
                        io->urbs[i]->transfer_buffer = sg_virt(sg) + *offset;
                        len = sg->length - *offset;
                        RTS51X_DEBUGP(" -- sg entry length = %d\n",
                                                sg->length);
                }

                if (length >= len) {
                        *offset = 0;
                        io->urbs[i]->transfer_buffer_length = len;
                        length -= len;
                        sg = sg_next(sg);
                } else {
                        *offset += length;
                        io->urbs[i]->transfer_buffer_length = length;
                        length = 0;
                }
                if (length == 0)
                        io->entries = i + 1;
#if 0
                if (length) {
                        len = min_t(unsigned, len, length);
                        length -= len;
                        if (length == 0) {
                                io->entries = i + 1;
                                *offset += len;
                        } else {
                                *offset = 0;
                        }
                }
#endif
        }
        RTS51X_DEBUGP("In %s, urb count: %d\n", __func__, i);
        io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT;

        RTS51X_DEBUGP("sg address stored in sgptr: 0x%x\n", (unsigned int)sg);
        *sgptr = sg;

        /* transaction state */
        io->count = io->entries;
        io->status = 0;
        io->bytes = 0;
        init_completion(&io->complete);
        return 0;

nomem:
        rts51x_sg_clean(io);
        return -ENOMEM;
}
#endif
int rts51x_sg_init(struct usb_sg_request *io, struct usb_device *dev,
                   unsigned pipe, unsigned period, struct scatterlist *sg,
                   int nents, size_t length, gfp_t mem_flags)
{
        return usb_sg_init(io, dev, pipe, period, sg, nents, length, mem_flags);
}

int rts51x_sg_wait(struct usb_sg_request *io, int timeout)
{
        long timeleft;
        int i;
        int entries = io->entries;

        /* queue the urbs.  */
        spin_lock_irq(&io->lock);
        i = 0;
        while (i < entries && !io->status) {
                int retval;

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

                /* after we submit, let completions or cancelations fire;
                 * we handshake using io->status.
                 */
                spin_unlock_irq(&io->lock);
                switch (retval) {
                        /* maybe we retrying will recover */
                case -ENXIO:    /* hc didn't queue this one */
                case -EAGAIN:
                case -ENOMEM:
                        io->urbs[i]->dev = NULL;
                        retval = 0;
                        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:
                        ++i;
                        cpu_relax();
                        break;

                        /* fail any uncompleted urbs */
                default:
                        io->urbs[i]->dev = NULL;
                        io->urbs[i]->status = retval;
                        dev_dbg(&io->dev->dev, "%s, submit --> %d\n",
                                __func__, retval);
                        usb_sg_cancel(io);
                }
                spin_lock_irq(&io->lock);
                if (retval && (io->status == 0 || io->status == -ECONNRESET))
                        io->status = retval;
        }
        io->count -= entries - i;
        if (io->count == 0)
                complete(&io->complete);
        spin_unlock_irq(&io->lock);

        timeleft =
            wait_for_completion_interruptible_timeout(&io->complete,
                                                      (timeout * HZ /
                                                       1000) ? :
                                                      MAX_SCHEDULE_TIMEOUT);
        if (timeleft <= 0) {
                RTS51X_DEBUGP("%s -- cancelling SG request\n",
                               timeleft == 0 ? "Timeout" : "Signal");
                usb_sg_cancel(io);
                if (timeleft == 0)
                        io->status = -ETIMEDOUT;
                else
                        io->status = -EINTR;
        }

        rts51x_sg_clean(io);
        return io->status;
}

/*
 * Transfer a scatter-gather list via bulk transfer
 *
 * This function does basically the same thing as usb_stor_bulk_transfer_buf()
 * above, but it uses the usbcore scatter-gather library.
 */
static int rts51x_bulk_transfer_sglist(struct rts51x_chip *chip,
                                       unsigned int pipe,
                                       struct scatterlist *sg, int num_sg,
                                       unsigned int length,
                                       unsigned int *act_len, int timeout)
{
        int result;

        /* don't submit s-g requests during abort processing */
        if (test_bit(FLIDX_ABORTING, &chip->usb->dflags))
                TRACE_RET(chip, STATUS_ERROR);

        /* initialize the scatter-gather request block */
        RTS51X_DEBUGP("%s: xfer %u bytes, %d entries\n", __func__,
                       length, num_sg);
        result =
            rts51x_sg_init(&chip->usb->current_sg, chip->usb->pusb_dev, pipe, 0,
                           sg, num_sg, length, GFP_NOIO);
        if (result) {
                RTS51X_DEBUGP("rts51x_sg_init returned %d\n", result);
                TRACE_RET(chip, STATUS_ERROR);
        }

        /* since the block has been initialized successfully, it's now
         * okay to cancel it */
        set_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags);

        /* did an abort occur during the submission? */
        if (test_bit(FLIDX_ABORTING, &chip->usb->dflags)) {

                /* cancel the request, if it hasn't been cancelled already */
                if (test_and_clear_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags)) {
                        RTS51X_DEBUGP("-- cancelling sg request\n");
                        usb_sg_cancel(&chip->usb->current_sg);
                }
        }

        /* wait for the completion of the transfer */
        result = rts51x_sg_wait(&chip->usb->current_sg, timeout);

        clear_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags);

        /* result = us->current_sg.status; */
        if (act_len)
                *act_len = chip->usb->current_sg.bytes;
        return interpret_urb_result(chip, pipe, length, result,
                                    chip->usb->current_sg.bytes);
}
#if 0
static int rts51x_bulk_transfer_sglist_partial(struct rts51x_chip *chip,
                unsigned int pipe, void *buf, struct scatterlist **sgptr,
                unsigned int *offset, int num_sg, unsigned int length,
                unsigned int *act_len, int timeout)
{
        int result;

        /* don't submit s-g requests during abort processing */
        if (test_bit(FLIDX_ABORTING, &chip->usb->dflags))
                TRACE_RET(chip, STATUS_ERROR);

        /* initialize the scatter-gather request block */
        RTS51X_DEBUGP("%s: xfer %u bytes, %d entries\n", __func__,
                        length, num_sg);
        result = rts51x_sg_init_partial(&chip->usb->current_sg,
                        chip->usb->pusb_dev, pipe, 0, buf, sgptr, offset,
                        num_sg, length, GFP_NOIO);
        if (result) {
                RTS51X_DEBUGP("rts51x_sg_init_partial returned %d\n", result);
                TRACE_RET(chip, STATUS_ERROR);
        }

        /* since the block has been initialized successfully, it's now
         * okay to cancel it */
        set_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags);

        /* did an abort occur during the submission? */
        if (test_bit(FLIDX_ABORTING, &chip->usb->dflags)) {

                /* cancel the request, if it hasn't been cancelled already */
                if (test_and_clear_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags)) {
                        RTS51X_DEBUGP("-- cancelling sg request\n");
                        usb_sg_cancel(&chip->usb->current_sg);
                }
        }

        /* wait for the completion of the transfer */
        result = rts51x_sg_wait(&chip->usb->current_sg, timeout);

        clear_bit(FLIDX_SG_ACTIVE, &chip->usb->dflags);

        /* result = us->current_sg.status; */
        if (act_len)
                *act_len = chip->usb->current_sg.bytes;
        return interpret_urb_result(chip, pipe, length, result,
                chip->usb->current_sg.bytes);
}
#endif
int rts51x_bulk_transfer_buf(struct rts51x_chip *chip, unsigned int pipe,
                             void *buf, unsigned int length,
                             unsigned int *act_len, int timeout)
{
        int result;

        /* fill and submit the URB */
        usb_fill_bulk_urb(chip->usb->current_urb, chip->usb->pusb_dev, pipe,
                          buf, length, urb_done_completion, NULL);
        result = rts51x_msg_common(chip, chip->usb->current_urb, timeout);

        /* store the actual length of the data transferred */
        if (act_len)
                *act_len = chip->usb->current_urb->actual_length;
        return interpret_urb_result(chip, pipe, length, result,
                                    chip->usb->current_urb->actual_length);
}

int rts51x_transfer_data(struct rts51x_chip *chip, unsigned int pipe,
                         void *buf, unsigned int len, int use_sg,
                         unsigned int *act_len, int timeout)
{
        int result;

        if (timeout < 600)
                timeout = 600;

        if (use_sg) {
                result =
                    rts51x_bulk_transfer_sglist(chip, pipe,
                                                (struct scatterlist *)buf,
                                                use_sg, len, act_len, timeout);
        } else {
                result =
                    rts51x_bulk_transfer_buf(chip, pipe, buf, len, act_len,
                                             timeout);
        }

        return result;
}

int rts51x_transfer_data_partial(struct rts51x_chip *chip, unsigned int pipe,
                                 void *buf, void **ptr, unsigned int *offset,
                                 unsigned int len, int use_sg,
                                 unsigned int *act_len, int timeout)
{
        int result;

        if (timeout < 600)
                timeout = 600;

        if (use_sg) {
                void *tmp_buf = kmalloc(len, GFP_KERNEL);
                if (!tmp_buf)
                        TRACE_RET(chip, STATUS_NOMEM);

                if (usb_pipeout(pipe)) {
                        rts51x_access_sglist(tmp_buf, len, buf, ptr, offset,
                                             FROM_XFER_BUF);
                }
                result =
                    rts51x_bulk_transfer_buf(chip, pipe, tmp_buf, len, act_len,
                                             timeout);
                if (result == STATUS_SUCCESS) {
                        if (usb_pipein(pipe)) {
                                rts51x_access_sglist(tmp_buf, len, buf, ptr,
                                                     offset, TO_XFER_BUF);
                        }
                }

                kfree(tmp_buf);
#if 0
                result = rts51x_bulk_transfer_sglist_partial(chip, pipe, buf,
                                        (struct scatterlist **)ptr, offset,
                                        use_sg, len, act_len, timeout);
#endif
        } else {
                unsigned int step = 0;
                if (offset)
                        step = *offset;
                result =
                    rts51x_bulk_transfer_buf(chip, pipe, buf + step, len,
                                             act_len, timeout);
                if (act_len)
                        step += *act_len;
                else
                        step += len;
                if (offset)
                        *offset = step;
        }

        return result;
}

int rts51x_get_epc_status(struct rts51x_chip *chip, u16 * status)
{
        unsigned int pipe = RCV_INTR_PIPE(chip);
        struct usb_host_endpoint *ep;
        struct completion urb_done;
        int result;

        if (!status)
                TRACE_RET(chip, STATUS_ERROR);

        /* set up data structures for the wakeup system */
        init_completion(&urb_done);

        ep = chip->usb->pusb_dev->ep_in[usb_pipeendpoint(pipe)];

        /* fill and submit the URB */
        /* We set interval to 1 here, so the polling interval is controlled
         * by our polling thread */
        usb_fill_int_urb(chip->usb->intr_urb, chip->usb->pusb_dev, pipe,
                         status, 2, urb_done_completion, &urb_done, 1);

        result = rts51x_msg_common(chip, chip->usb->intr_urb, 50);

        return interpret_urb_result(chip, pipe, 2, result,
                                    chip->usb->intr_urb->actual_length);
}

u8 media_not_present[] = {
        0x70, 0, 0x02, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0x3A, 0, 0, 0, 0, 0 };
u8 invalid_cmd_field[] = {
        0x70, 0, 0x05, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0x24, 0, 0, 0, 0, 0 };

void rts51x_invoke_transport(struct scsi_cmnd *srb, struct rts51x_chip *chip)
{
        int result;

#ifdef CONFIG_PM
        if (chip->option.ss_en) {
                if (srb->cmnd[0] == TEST_UNIT_READY) {
                        if (RTS51X_CHK_STAT(chip, STAT_SS)) {
                                if (check_fake_card_ready(chip,
                                                        SCSI_LUN(srb))) {
                                        srb->result = SAM_STAT_GOOD;
                                } else {
                                        srb->result = SAM_STAT_CHECK_CONDITION;
                                        memcpy(srb->sense_buffer,
                                               media_not_present, SENSE_SIZE);
                                }
                                return;
                        }
                } else if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
                        if (RTS51X_CHK_STAT(chip, STAT_SS)) {
                                int prevent = srb->cmnd[4] & 0x1;

                                if (prevent) {
                                        srb->result = SAM_STAT_CHECK_CONDITION;
                                        memcpy(srb->sense_buffer,
                                               invalid_cmd_field, SENSE_SIZE);
                                } else {
                                        srb->result = SAM_STAT_GOOD;
                                }
                                return;
                        }
                } else {
                        if (RTS51X_CHK_STAT(chip, STAT_SS)
                            || RTS51X_CHK_STAT(chip, STAT_SS_PRE)) {
                                /* Wake up device */
                                RTS51X_DEBUGP("Try to wake up device\n");
                                chip->resume_from_scsi = 1;

                                rts51x_try_to_exit_ss(chip);

                                if (RTS51X_CHK_STAT(chip, STAT_SS)) {
                                        wait_timeout(3000);

                                        rts51x_init_chip(chip);
                                        rts51x_init_cards(chip);
                                }
                        }
                }
        }
#endif

        result = rts51x_scsi_handler(srb, chip);

        /* if there is a transport error, reset and don't auto-sense */
        if (result == TRANSPORT_ERROR) {
                RTS51X_DEBUGP("-- transport indicates error, resetting\n");
                srb->result = DID_ERROR << 16;
                goto Handle_Errors;
        }

        srb->result = SAM_STAT_GOOD;

        /*
         * If we have a failure, we're going to do a REQUEST_SENSE
         * automatically.  Note that we differentiate between a command
         * "failure" and an "error" in the transport mechanism.
         */
        if (result == TRANSPORT_FAILED) {
                /* set the result so the higher layers expect this data */
                srb->result = SAM_STAT_CHECK_CONDITION;
                memcpy(srb->sense_buffer,
                       (unsigned char *)&(chip->sense_buffer[SCSI_LUN(srb)]),
                       sizeof(struct sense_data_t));
        }

        return;

        /* Error and abort processing: try to resynchronize with the device
         * by issuing a port reset.  If that fails, try a class-specific
         * device reset. */
Handle_Errors:
        return;
}