URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [hpusbscsi.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * hpusbscsi
 * (C) Copyright 2001 Oliver Neukum
 * Sponsored by the Linux Usb Project
 * Large parts based on or taken from code by John Fremlin and Matt Dharm
 *
 * This driver is known to work with the following scanners (VID, PID)
 *    (0x03f0, 0x0701)  HP 53xx
 *    (0x03f0, 0x0801)  HP 7400
 *    (0x0638, 0x026a)  Minolta Scan Dual II
 *    (0x0686, 0x4004)  Minolta Elite II
 * To load with full debugging load with "insmod hpusbscsi debug=2"
 *
 * 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 of the License, 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, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Contributors:
 *   Oliver Neukum
 *   John Fremlin
 *   Matt Dharm
 *   .
 *   .
 *   Timothy Jedlicka <bonzo@lucent.com>
 *
 * History
 *
 * 22-Apr-2002
 *
 * - Added Elite II scanner - bonzo
 * - Cleaned up the debug statements and made them optional at load time - bonzo
 *
 * 20020618
 *
 * - Confirm to stupid 2.4 rules on io_request_lock
 *
 */
 
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/smp_lock.h>
#include <linux/usb.h>
#include <asm/atomic.h>
#include <linux/blk.h>
#include "../scsi/scsi.h"
#include "../scsi/hosts.h"
#include "../scsi/sd.h"
 
#include "hpusbscsi.h"
 
static char *states[]={"FREE", "BEGINNING", "WORKING", "ERROR", "WAIT", "PREMATURE"};
 
/* DEBUG related parts */
#define HPUSBSCSI_DEBUG
 
#ifdef HPUSBSCSI_DEBUG
#  define PDEBUG(level, fmt, args...) \
          if (debug >= (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , \
                 ## args)
#else
#  define PDEBUG(level, fmt, args...) do {} while(0)
#endif
 
 
/* 0=no debug messages
 * 1=everything but trace states
 * 2=trace states
 */
static int debug; /* = 0 */
 
MODULE_PARM(debug, "i");
MODULE_PARM_DESC(debug, "Debug level: 0=none, 1=no trace states, 2=trace states");
 
/* global variables */
 
struct list_head hpusbscsi_devices;
//LIST_HEAD(hpusbscsi_devices);
 
/* USB related parts */
 
static void *
hpusbscsi_usb_probe (struct usb_device *dev, unsigned int interface,
                     const struct usb_device_id *id)
{
        struct hpusbscsi *new;
        struct usb_interface_descriptor *altsetting =
                &(dev->actconfig->interface[interface].altsetting[0]);
 
        int i, result;
 
        /* basic check */
 
        if (altsetting->bNumEndpoints != 3) {
                printk (KERN_ERR "Wrong number of endpoints\n");
                return NULL;
        }
 
        /* descriptor allocation */
 
        new =
                (struct hpusbscsi *) kmalloc (sizeof (struct hpusbscsi),
                                              GFP_KERNEL);
        if (new == NULL)
                return NULL;
        PDEBUG (1, "Allocated memory");
        memset (new, 0, sizeof (struct hpusbscsi));
        spin_lock_init (&new->dataurb.lock);
        spin_lock_init (&new->controlurb.lock);
        new->dev = dev;
        init_waitqueue_head (&new->pending);
        init_waitqueue_head (&new->deathrow);
        init_MUTEX(&new->lock);
        INIT_LIST_HEAD (&new->lh);
 
        if (id->idVendor == 0x0686 && id->idProduct == 0x4004)
                new->need_short_workaround = 1;
 
 
 
        /* finding endpoints */
 
        for (i = 0; i < altsetting->bNumEndpoints; i++) {
                if (
                    (altsetting->endpoint[i].
                     bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
                    USB_ENDPOINT_XFER_BULK) {
                        if (altsetting->endpoint[i].
                            bEndpointAddress & USB_DIR_IN) {
                                new->ep_in =
                                        altsetting->endpoint[i].
                                        bEndpointAddress &
                                        USB_ENDPOINT_NUMBER_MASK;
                        } else {
                                new->ep_out =
                                        altsetting->endpoint[i].
                                        bEndpointAddress &
                                        USB_ENDPOINT_NUMBER_MASK;
                        }
                } else {
                        new->ep_int =
                                altsetting->endpoint[i].
                                bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
                        new->interrupt_interval= altsetting->endpoint[i].bInterval;
                }
        }
 
        /* USB initialisation magic for the simple case */
 
        result = usb_set_interface (dev, altsetting->bInterfaceNumber, 0);
 
        switch (result) {
        case 0:          /* no error */
                break;
 
        case -EPIPE:
                usb_clear_halt (dev, usb_sndctrlpipe (dev, 0));
                break;
 
        default:
                printk (KERN_ERR "unknown error %d from usb_set_interface\n",
                         result);
                goto err_out;
        }
 
        /* making a template for the scsi layer to fake detection of a scsi device */
 
        memcpy (&(new->ctempl), &hpusbscsi_scsi_host_template,
                sizeof (hpusbscsi_scsi_host_template));
        (struct hpusbscsi *) new->ctempl.proc_dir = new;
        new->ctempl.module = THIS_MODULE;
 
        if (scsi_register_module (MODULE_SCSI_HA, &(new->ctempl)))
                goto err_out;
 
        new->sense_command[0] = REQUEST_SENSE;
        new->sense_command[4] = HPUSBSCSI_SENSE_LENGTH;
 
        /* adding to list for module unload */
        list_add (&hpusbscsi_devices, &new->lh);
 
        return new;
 
      err_out:
        kfree (new);
        return NULL;
}
 
static void
hpusbscsi_usb_disconnect (struct usb_device *dev, void *ptr)
{
        struct hpusbscsi *hp = (struct hpusbscsi *)ptr;
 
        down(&hp->lock);
        usb_unlink_urb(&hp->controlurb);
        usb_unlink_urb(&hp->dataurb);
 
        hp->dev = NULL;
        up(&hp->lock);
}
 
static struct usb_device_id hpusbscsi_usb_ids[] = {
        {USB_DEVICE (0x03f0, 0x0701)},  /* HP 53xx */
        {USB_DEVICE (0x03f0, 0x0801)},  /* HP 7400 */
        {USB_DEVICE (0x0638, 0x0268)},  /*iVina 1200U */
        {USB_DEVICE (0x0638, 0x026a)},  /*Scan Dual II */
        {USB_DEVICE (0x0638, 0x0A13)},  /*Avision AV600U */
        {USB_DEVICE (0x0638, 0x0A16)},  /*Avision DS610CU Scancopier */
        {USB_DEVICE (0x0638, 0x0A18)},  /*Avision AV600U Plus */
        {USB_DEVICE (0x0638, 0x0A23)},  /*Avision AV220 */
        {USB_DEVICE (0x0638, 0x0A24)},  /*Avision AV210 */
        {USB_DEVICE (0x0686, 0x4004)},  /*Minolta Elite II */
        {}                      /* Terminating entry */
};
 
MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);
MODULE_LICENSE("GPL");
 
 
static struct usb_driver hpusbscsi_usb_driver = {
        name:"hpusbscsi",
        probe:hpusbscsi_usb_probe,
        disconnect:hpusbscsi_usb_disconnect,
        id_table:hpusbscsi_usb_ids,
};
 
/* module initialisation */
 
int __init
hpusbscsi_init (void)
{
        int result;
 
        INIT_LIST_HEAD (&hpusbscsi_devices);
        PDEBUG(0, "driver loaded, DebugLvel=%d", debug);
 
        if ((result = usb_register (&hpusbscsi_usb_driver)) < 0) {
                printk (KERN_ERR "hpusbscsi: driver registration failed\n");
                return -1;
        } else {
                return 0;
        }
}
 
void __exit
hpusbscsi_exit (void)
{
        struct list_head *tmp;
        struct list_head *old;
        struct hpusbscsi * o;
 
        for (tmp = hpusbscsi_devices.next; tmp != &hpusbscsi_devices;/*nothing */) {
                old = tmp;
                tmp = tmp->next;
                o = (struct hpusbscsi *)old;
                usb_unlink_urb(&o->controlurb);
                if(scsi_unregister_module(MODULE_SCSI_HA,&o->ctempl)<0)
                        printk(KERN_CRIT"Deregistering failed!\n");
                kfree(old);
        }
 
        usb_deregister (&hpusbscsi_usb_driver);
}
 
module_init (hpusbscsi_init);
module_exit (hpusbscsi_exit);
 
/* interface to the scsi layer */
 
static int
hpusbscsi_scsi_detect (struct SHT *sht)
{
        /* Whole function stolen from usb-storage */
 
        struct hpusbscsi *desc = (struct hpusbscsi *) sht->proc_dir;
        /* What a hideous hack! */
 
        char local_name[48];
        spin_unlock_irq(&io_request_lock);
 
 
        /* set up the name of our subdirectory under /proc/scsi/ */
        sprintf (local_name, "hpusbscsi-%d", desc->number);
        sht->proc_name = kmalloc (strlen (local_name) + 1, GFP_KERNEL);
        /* FIXME: where is this freed ? */
 
        if (!sht->proc_name) {
                spin_lock_irq(&io_request_lock);
                return 0;
        }
 
        strcpy (sht->proc_name, local_name);
 
        sht->proc_dir = NULL;
 
        /* build and submit an interrupt URB for status byte handling */
        FILL_INT_URB(&desc->controlurb,
                        desc->dev,
                        usb_rcvintpipe(desc->dev,desc->ep_int),
                        &desc->scsi_state_byte,
                        1,
                        control_interrupt_callback,
                        desc,
                        desc->interrupt_interval
        );
 
        if ( 0  >  usb_submit_urb(&desc->controlurb)) {
                kfree(sht->proc_name);
                spin_lock_irq(&io_request_lock);
                return 0;
        }
 
        /* In host->hostdata we store a pointer to desc */
        desc->host = scsi_register (sht, sizeof (desc));
        if (desc->host == NULL) {
                kfree (sht->proc_name);
                usb_unlink_urb(&desc->controlurb);
                spin_lock_irq(&io_request_lock);
                return 0;
        }
        desc->host->hostdata[0] = (unsigned long) desc;
        spin_lock_irq(&io_request_lock);
 
        return 1;
}
 
static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)
{
        struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
        usb_urb_callback usb_callback;
        int res, passed_length;
 
        spin_unlock_irq(&io_request_lock);
 
        /* we don't answer for anything but our single device on any faked host controller */
        if ( srb->device->lun || srb->device->id || srb->device->channel ) {
                srb->result = DID_BAD_TARGET;
                callback(srb);
                goto out_nolock;
        }
 
        /* to prevent a race with removal */
        down(&hpusbscsi->lock);
 
        if (hpusbscsi->dev == NULL) {
                srb->result = DID_ERROR;
                callback(srb);
                goto out;
        }
 
        /* otto fix - the Scan Elite II has a 5 second
        * delay anytime the srb->cmd_len=6
        * This causes it to run very slowly unless we
        * pad the command length to 10 */
 
        if (hpusbscsi -> need_short_workaround && srb->cmd_len < 10) {
                memset(srb->cmnd + srb->cmd_len, 0, 10 - srb->cmd_len);
                passed_length = 10;
        } else {
                passed_length = srb->cmd_len;
        }
 
 
        /* Now we need to decide which callback to give to the urb we send the command with */
 
        if (!srb->bufflen) {
                if (srb->cmnd[0] == REQUEST_SENSE){
                        /* the usual buffer is not used, needs a special case */
                        hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
                        usb_callback = request_sense_callback;
                } else {
                        usb_callback = simple_command_callback;
                }
        } else {
                if (srb->use_sg) {
                        usb_callback = scatter_gather_callback;
                        hpusbscsi->fragment = 0;
                } else {
                        usb_callback = simple_payload_callback;
                }
                /* Now we find out which direction data is to be transfered in */
                hpusbscsi->current_data_pipe = DIRECTION_IS_IN(srb->cmnd[0]) ?
                        usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in)
                :
                        usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out)
                ;
        }
 
 
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        if (hpusbscsi->state != HP_STATE_FREE) {
                printk(KERN_CRIT"hpusbscsi - Ouch: queueing violation!\n");
                return 1; /* This must not happen */
        }
 
        /* We zero the sense buffer to avoid confusing user space */
        memset(srb->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
 
        hpusbscsi->state = HP_STATE_BEGINNING;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
 
        /* We prepare the urb for writing out the scsi command */
        FILL_BULK_URB(
                &hpusbscsi->dataurb,
                hpusbscsi->dev,
                usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),
                srb->cmnd,
                passed_length,
                usb_callback,
                hpusbscsi
        );
        hpusbscsi->scallback = callback;
        hpusbscsi->srb = srb;
 
 
        res = usb_submit_urb(&hpusbscsi->dataurb);
        if (res) {
                hpusbscsi->state = HP_STATE_FREE;
                PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                srb->result = DID_ERROR;
                callback(srb);
 
        }
 
out:
        up(&hpusbscsi->lock);
out_nolock:
        spin_lock_irq(&io_request_lock);
        return 0;
}
 
static int hpusbscsi_scsi_host_reset (Scsi_Cmnd *srb)
{
        struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
 
        PDEBUG(1, "SCSI reset requested");
        //usb_reset_device(hpusbscsi->dev);
        //PDEBUG(1, "SCSI reset completed");
        hpusbscsi->state = HP_STATE_FREE;
 
        return 0;
}
 
static int hpusbscsi_scsi_abort (Scsi_Cmnd *srb)
{
        struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
        PDEBUG(1, "Request is canceled");
 
        spin_unlock_irq(&io_request_lock);
        usb_unlink_urb(&hpusbscsi->dataurb);
        hpusbscsi->state = HP_STATE_FREE;
 
        spin_lock_irq(&io_request_lock);
 
        return SCSI_ABORT_PENDING;
}
 
/* usb interrupt handlers - they are all running IN INTERRUPT ! */
 
static void handle_usb_error (struct hpusbscsi *hpusbscsi)
{
        if (hpusbscsi->scallback != NULL) {
                hpusbscsi->srb->result = DID_ERROR;
                hpusbscsi->scallback(hpusbscsi->srb);
        }
        hpusbscsi->state = HP_STATE_FREE;
}
 
static void  control_interrupt_callback (struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
        u8 scsi_state;
 
        PDEBUG(1, "Getting status byte %d",hpusbscsi->scsi_state_byte);
        if(u->status < 0) {
                if (hpusbscsi->state != HP_STATE_FREE)
                        handle_usb_error(hpusbscsi);
                return;
        }
 
        scsi_state = hpusbscsi->scsi_state_byte;
        if (hpusbscsi->state != HP_STATE_ERROR) {
                hpusbscsi->srb->result &= SCSI_ERR_MASK;
                hpusbscsi->srb->result |= scsi_state;
        }
 
        if (scsi_state == CHECK_CONDITION << 1) {
                if (hpusbscsi->state == HP_STATE_WAIT) {
                        issue_request_sense(hpusbscsi);
                } else {
                        /* we request sense after an eventual data transfer */
                        hpusbscsi->state = HP_STATE_ERROR;
                }
        }
 
        if (hpusbscsi->scallback != NULL && hpusbscsi->state == HP_STATE_WAIT && scsi_state != CHECK_CONDITION <<1)
                /* we do a callback to the scsi layer if and only if all data has been transfered */
                hpusbscsi->scallback(hpusbscsi->srb);
 
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        switch (hpusbscsi->state) {
        case HP_STATE_WAIT:
                hpusbscsi->state = HP_STATE_FREE;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                break;
        case HP_STATE_WORKING:
        case HP_STATE_BEGINNING:
                hpusbscsi->state = HP_STATE_PREMATURE;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                break;
        case HP_STATE_ERROR:
                break;
        default:
                printk(KERN_ERR"hpusbscsi: Unexpected status report.\n");
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                hpusbscsi->state = HP_STATE_FREE;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                break;
        }
}
 
static void simple_command_callback(struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
        if (u->status<0) {
                handle_usb_error(hpusbscsi);
                return;
        }
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        if (hpusbscsi->state != HP_STATE_PREMATURE) {
                PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                hpusbscsi->state = HP_STATE_WAIT;
        } else {
                if (hpusbscsi->scallback != NULL)
                        hpusbscsi->scallback(hpusbscsi->srb);
                hpusbscsi->state = HP_STATE_FREE;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        }
}
 
static void scatter_gather_callback(struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
        struct scatterlist *sg = hpusbscsi->srb->buffer;
        usb_urb_callback callback;
        int res;
 
        PDEBUG(1, "Going through scatter/gather"); // bonzo - this gets hit a lot - maybe make it a 2
        if (u->status < 0) {
                handle_usb_error(hpusbscsi);
                return;
        }
 
        if (hpusbscsi->fragment + 1 != hpusbscsi->srb->use_sg)
                callback = scatter_gather_callback;
        else
                callback = simple_done;
 
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        if (hpusbscsi->state != HP_STATE_PREMATURE)
                hpusbscsi->state = HP_STATE_WORKING;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
 
        FILL_BULK_URB(
                u,
                hpusbscsi->dev,
                hpusbscsi->current_data_pipe,
                sg[hpusbscsi->fragment].address,
                sg[hpusbscsi->fragment++].length,
                callback,
                hpusbscsi
        );
 
        res = usb_submit_urb(u);
        if (res)
                handle_usb_error(hpusbscsi);
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
}
 
static void simple_done (struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
 
        if (u->status < 0) {
                handle_usb_error(hpusbscsi);
                return;
        }
        PDEBUG(1, "Data transfer done");
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        if (hpusbscsi->state != HP_STATE_PREMATURE) {
                if (u->status < 0) {
                        handle_usb_error(hpusbscsi);
                } else {
                        if (hpusbscsi->state != HP_STATE_ERROR) {
                                hpusbscsi->state = HP_STATE_WAIT;
                        } else {
                                issue_request_sense(hpusbscsi);
                        }
                PDEBUG(2, "state= %s", states[hpusbscsi->state]);
                }
        } else {
                if (hpusbscsi->scallback != NULL)
                        hpusbscsi->scallback(hpusbscsi->srb);
                hpusbscsi->state = HP_STATE_FREE;
        }
}
 
static void simple_payload_callback (struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
        int res;
 
        if (u->status<0) {
                handle_usb_error(hpusbscsi);
                return;
        }
 
        FILL_BULK_URB(
                u,
                hpusbscsi->dev,
                hpusbscsi->current_data_pipe,
                hpusbscsi->srb->buffer,
                hpusbscsi->srb->bufflen,
                simple_done,
                hpusbscsi
        );
 
        res = usb_submit_urb(u);
        if (res) {
                handle_usb_error(hpusbscsi);
                return;
        }
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        if (hpusbscsi->state != HP_STATE_PREMATURE) {
                hpusbscsi->state = HP_STATE_WORKING;
        PDEBUG(2, "state= %s", states[hpusbscsi->state]);
        }
}
 
static void request_sense_callback (struct urb *u)
{
        struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
 
        if (u->status<0) {
                handle_usb_error(hpusbscsi);
                return;
        }
 
        FILL_BULK_URB(
                u,
                hpusbscsi->dev,
                hpusbscsi->current_data_pipe,
                hpusbscsi->srb->sense_buffer,
                SCSI_SENSE_BUFFERSIZE,
                simple_done,
                hpusbscsi
        );
 
        if (0 > usb_submit_urb(u)) {
                handle_usb_error(hpusbscsi);
                return;
        }
        if (hpusbscsi->state != HP_STATE_PREMATURE && hpusbscsi->state != HP_STATE_ERROR)
                hpusbscsi->state = HP_STATE_WORKING;
}
 
static void issue_request_sense (struct hpusbscsi *hpusbscsi)
{
        FILL_BULK_URB(
                &hpusbscsi->dataurb,
                hpusbscsi->dev,
                usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out),
                &hpusbscsi->sense_command,
                SENSE_COMMAND_SIZE,
                request_sense_callback,
                hpusbscsi
        );
 
        hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
 
        if (0 > usb_submit_urb(&hpusbscsi->dataurb)) {
                handle_usb_error(hpusbscsi);
        }
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [hpusbscsi.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* hpusbscsi`
3			`* (C) Copyright 2001 Oliver Neukum`
4			`* Sponsored by the Linux Usb Project`
5			`* Large parts based on or taken from code by John Fremlin and Matt Dharm`
6			`*`
7			`* This driver is known to work with the following scanners (VID, PID)`
8			`* (0x03f0, 0x0701) HP 53xx`
9			`* (0x03f0, 0x0801) HP 7400`
10			`* (0x0638, 0x026a) Minolta Scan Dual II`
11			`* (0x0686, 0x4004) Minolta Elite II`
12			`* To load with full debugging load with "insmod hpusbscsi debug=2"`
13			`*`
14			`* This program is free software; you can redistribute it and/or modify it`
15			`* under the terms of the GNU General Public License as published by the`
16			`* Free Software Foundation; either version 2 of the License, or (at your`
17			`* option) any later version.`
18			`*`
19			`* This program is distributed in the hope that it will be useful, but`
20			`* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY`
21			`* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
22			`* for more details.`
23			`*`
24			`* You should have received a copy of the GNU General Public License`
25			`* along with this program; if not, write to the Free Software Foundation,`
26			`* Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
27			`*`
28			`* Contributors:`
29			`* Oliver Neukum`
30			`* John Fremlin`
31			`* Matt Dharm`
32			`* .`
33			`* .`
34			`* Timothy Jedlicka <bonzo@lucent.com>`
35			`*`
36			`* History`
37			`*`
38			`* 22-Apr-2002`
39			`*`
40			`* - Added Elite II scanner - bonzo`
41			`* - Cleaned up the debug statements and made them optional at load time - bonzo`
42			`*`
43			`* 20020618`
44			`*`
45			`* - Confirm to stupid 2.4 rules on io_request_lock`
46			`*`
47			`*/`
48
49			`#include <linux/module.h>`
50			`#include <linux/kernel.h>`
51			`#include <linux/sched.h>`
52			`#include <linux/signal.h>`
53			`#include <linux/errno.h>`
54			`#include <linux/init.h>`
55			`#include <linux/slab.h>`
56			`#include <linux/spinlock.h>`
57			`#include <linux/smp_lock.h>`
58			`#include <linux/usb.h>`
59			`#include <asm/atomic.h>`
60			`#include <linux/blk.h>`
61			`#include "../scsi/scsi.h"`
62			`#include "../scsi/hosts.h"`
63			`#include "../scsi/sd.h"`
64
65			`#include "hpusbscsi.h"`
66
67			`static char *states[]={"FREE", "BEGINNING", "WORKING", "ERROR", "WAIT", "PREMATURE"};`
68
69			`/* DEBUG related parts */`
70			`#define HPUSBSCSI_DEBUG`
71
72			`#ifdef HPUSBSCSI_DEBUG`
73			`# define PDEBUG(level, fmt, args...) \`
74			`if (debug >= (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , \`
75			`## args)`
76			`#else`
77			`# define PDEBUG(level, fmt, args...) do {} while(0)`
78			`#endif`
79
80
81			`/* 0=no debug messages`
82			`* 1=everything but trace states`
83			`* 2=trace states`
84			`*/`
85			`static int debug; /* = 0 */`
86
87			`MODULE_PARM(debug, "i");`
88			`MODULE_PARM_DESC(debug, "Debug level: 0=none, 1=no trace states, 2=trace states");`
89
90			`/* global variables */`
91
92			`struct list_head hpusbscsi_devices;`
93			`//LIST_HEAD(hpusbscsi_devices);`
94
95			`/* USB related parts */`
96
97			`static void *`
98			`hpusbscsi_usb_probe (struct usb_device *dev, unsigned int interface,`
99			`const struct usb_device_id *id)`
100			`{`
101			`struct hpusbscsi *new;`
102			`struct usb_interface_descriptor *altsetting =`
103			`&(dev->actconfig->interface[interface].altsetting[0]);`
104
105			`int i, result;`
106
107			`/* basic check */`
108
109			`if (altsetting->bNumEndpoints != 3) {`
110			`printk (KERN_ERR "Wrong number of endpoints\n");`
111			`return NULL;`
112			`}`
113
114			`/* descriptor allocation */`
115
116			`new =`
117			`(struct hpusbscsi *) kmalloc (sizeof (struct hpusbscsi),`
118			`GFP_KERNEL);`
119			`if (new == NULL)`
120			`return NULL;`
121			`PDEBUG (1, "Allocated memory");`
122			`memset (new, 0, sizeof (struct hpusbscsi));`
123			`spin_lock_init (&new->dataurb.lock);`
124			`spin_lock_init (&new->controlurb.lock);`
125			`new->dev = dev;`
126			`init_waitqueue_head (&new->pending);`
127			`init_waitqueue_head (&new->deathrow);`
128			`init_MUTEX(&new->lock);`
129			`INIT_LIST_HEAD (&new->lh);`
130
131			`if (id->idVendor == 0x0686 && id->idProduct == 0x4004)`
132			`new->need_short_workaround = 1;`
133
134
135
136			`/* finding endpoints */`
137
138			`for (i = 0; i < altsetting->bNumEndpoints; i++) {`
139			`if (`
140			`(altsetting->endpoint[i].`
141			`bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==`
142			`USB_ENDPOINT_XFER_BULK) {`
143			`if (altsetting->endpoint[i].`
144			`bEndpointAddress & USB_DIR_IN) {`
145			`new->ep_in =`
146			`altsetting->endpoint[i].`
147			`bEndpointAddress &`
148			`USB_ENDPOINT_NUMBER_MASK;`
149			`} else {`
150			`new->ep_out =`
151			`altsetting->endpoint[i].`
152			`bEndpointAddress &`
153			`USB_ENDPOINT_NUMBER_MASK;`
154			`}`
155			`} else {`
156			`new->ep_int =`
157			`altsetting->endpoint[i].`
158			`bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;`
159			`new->interrupt_interval= altsetting->endpoint[i].bInterval;`
160			`}`
161			`}`
162
163			`/* USB initialisation magic for the simple case */`
164
165			`result = usb_set_interface (dev, altsetting->bInterfaceNumber, 0);`
166
167			`switch (result) {`
168			`case 0: /* no error */`
169			`break;`
170
171			`case -EPIPE:`
172			`usb_clear_halt (dev, usb_sndctrlpipe (dev, 0));`
173			`break;`
174
175			`default:`
176			`printk (KERN_ERR "unknown error %d from usb_set_interface\n",`
177			`result);`
178			`goto err_out;`
179			`}`
180
181			`/* making a template for the scsi layer to fake detection of a scsi device */`
182
183			`memcpy (&(new->ctempl), &hpusbscsi_scsi_host_template,`
184			`sizeof (hpusbscsi_scsi_host_template));`
185			`(struct hpusbscsi *) new->ctempl.proc_dir = new;`
186			`new->ctempl.module = THIS_MODULE;`
187
188			`if (scsi_register_module (MODULE_SCSI_HA, &(new->ctempl)))`
189			`goto err_out;`
190
191			`new->sense_command[0] = REQUEST_SENSE;`
192			`new->sense_command[4] = HPUSBSCSI_SENSE_LENGTH;`
193
194			`/* adding to list for module unload */`
195			`list_add (&hpusbscsi_devices, &new->lh);`
196
197			`return new;`
198
199			`err_out:`
200			`kfree (new);`
201			`return NULL;`
202			`}`
203
204			`static void`
205			`hpusbscsi_usb_disconnect (struct usb_device dev, void ptr)`
206			`{`
207			`struct hpusbscsi hp = (struct hpusbscsi )ptr;`
208
209			`down(&hp->lock);`
210			`usb_unlink_urb(&hp->controlurb);`
211			`usb_unlink_urb(&hp->dataurb);`
212
213			`hp->dev = NULL;`
214			`up(&hp->lock);`
215			`}`
216
217			`static struct usb_device_id hpusbscsi_usb_ids[] = {`
218			`{USB_DEVICE (0x03f0, 0x0701)}, /* HP 53xx */`
219			`{USB_DEVICE (0x03f0, 0x0801)}, /* HP 7400 */`
220			`{USB_DEVICE (0x0638, 0x0268)}, /iVina 1200U /`
221			`{USB_DEVICE (0x0638, 0x026a)}, /Scan Dual II /`
222			`{USB_DEVICE (0x0638, 0x0A13)}, /Avision AV600U /`
223			`{USB_DEVICE (0x0638, 0x0A16)}, /Avision DS610CU Scancopier /`
224			`{USB_DEVICE (0x0638, 0x0A18)}, /Avision AV600U Plus /`
225			`{USB_DEVICE (0x0638, 0x0A23)}, /Avision AV220 /`
226			`{USB_DEVICE (0x0638, 0x0A24)}, /Avision AV210 /`
227			`{USB_DEVICE (0x0686, 0x4004)}, /Minolta Elite II /`
228			`{} /* Terminating entry */`
229			`};`
230
231			`MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);`
232			`MODULE_LICENSE("GPL");`
233
234
235			`static struct usb_driver hpusbscsi_usb_driver = {`
236			`name:"hpusbscsi",`
237			`probe:hpusbscsi_usb_probe,`
238			`disconnect:hpusbscsi_usb_disconnect,`
239			`id_table:hpusbscsi_usb_ids,`
240			`};`
241
242			`/* module initialisation */`
243
244			`int __init`
245			`hpusbscsi_init (void)`
246			`{`
247			`int result;`
248
249			`INIT_LIST_HEAD (&hpusbscsi_devices);`
250			`PDEBUG(0, "driver loaded, DebugLvel=%d", debug);`
251
252			`if ((result = usb_register (&hpusbscsi_usb_driver)) < 0) {`
253			`printk (KERN_ERR "hpusbscsi: driver registration failed\n");`
254			`return -1;`
255			`} else {`
256			`return 0;`
257			`}`
258			`}`
259
260			`void __exit`
261			`hpusbscsi_exit (void)`
262			`{`
263			`struct list_head *tmp;`
264			`struct list_head *old;`
265			`struct hpusbscsi * o;`
266
267			`for (tmp = hpusbscsi_devices.next; tmp != &hpusbscsi_devices;/nothing /) {`
268			`old = tmp;`
269			`tmp = tmp->next;`
270			`o = (struct hpusbscsi *)old;`
271			`usb_unlink_urb(&o->controlurb);`
272			`if(scsi_unregister_module(MODULE_SCSI_HA,&o->ctempl)<0)`
273			`printk(KERN_CRIT"Deregistering failed!\n");`
274			`kfree(old);`
275			`}`
276
277			`usb_deregister (&hpusbscsi_usb_driver);`
278			`}`
279
280			`module_init (hpusbscsi_init);`
281			`module_exit (hpusbscsi_exit);`
282
283			`/* interface to the scsi layer */`
284
285			`static int`
286			`hpusbscsi_scsi_detect (struct SHT *sht)`
287			`{`
288			`/* Whole function stolen from usb-storage */`
289
290			`struct hpusbscsi desc = (struct hpusbscsi ) sht->proc_dir;`
291			`/* What a hideous hack! */`
292
293			`char local_name[48];`
294			`spin_unlock_irq(&io_request_lock);`
295
296
297			`/* set up the name of our subdirectory under /proc/scsi/ */`
298			`sprintf (local_name, "hpusbscsi-%d", desc->number);`
299			`sht->proc_name = kmalloc (strlen (local_name) + 1, GFP_KERNEL);`
300			`/* FIXME: where is this freed ? */`
301
302			`if (!sht->proc_name) {`
303			`spin_lock_irq(&io_request_lock);`
304			`return 0;`
305			`}`
306
307			`strcpy (sht->proc_name, local_name);`
308
309			`sht->proc_dir = NULL;`
310
311			`/* build and submit an interrupt URB for status byte handling */`
312			`FILL_INT_URB(&desc->controlurb,`
313			`desc->dev,`
314			`usb_rcvintpipe(desc->dev,desc->ep_int),`
315			`&desc->scsi_state_byte,`
316			`1,`
317			`control_interrupt_callback,`
318			`desc,`
319			`desc->interrupt_interval`
320			`);`
321
322			`if ( 0 > usb_submit_urb(&desc->controlurb)) {`
323			`kfree(sht->proc_name);`
324			`spin_lock_irq(&io_request_lock);`
325			`return 0;`
326			`}`
327
328			`/* In host->hostdata we store a pointer to desc */`
329			`desc->host = scsi_register (sht, sizeof (desc));`
330			`if (desc->host == NULL) {`
331			`kfree (sht->proc_name);`
332			`usb_unlink_urb(&desc->controlurb);`
333			`spin_lock_irq(&io_request_lock);`
334			`return 0;`
335			`}`
336			`desc->host->hostdata[0] = (unsigned long) desc;`
337			`spin_lock_irq(&io_request_lock);`
338
339			`return 1;`
340			`}`
341
342			`static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)`
343			`{`
344			`struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);`
345			`usb_urb_callback usb_callback;`
346			`int res, passed_length;`
347
348			`spin_unlock_irq(&io_request_lock);`
349
350			`/* we don't answer for anything but our single device on any faked host controller */`
351			`if ( srb->device->lun \|\| srb->device->id \|\| srb->device->channel ) {`
352			`srb->result = DID_BAD_TARGET;`
353			`callback(srb);`
354			`goto out_nolock;`
355			`}`
356
357			`/* to prevent a race with removal */`
358			`down(&hpusbscsi->lock);`
359
360			`if (hpusbscsi->dev == NULL) {`
361			`srb->result = DID_ERROR;`
362			`callback(srb);`
363			`goto out;`
364			`}`
365
366			`/* otto fix - the Scan Elite II has a 5 second`
367			`* delay anytime the srb->cmd_len=6`
368			`* This causes it to run very slowly unless we`
369			`* pad the command length to 10 */`
370
371			`if (hpusbscsi -> need_short_workaround && srb->cmd_len < 10) {`
372			`memset(srb->cmnd + srb->cmd_len, 0, 10 - srb->cmd_len);`
373			`passed_length = 10;`
374			`} else {`
375			`passed_length = srb->cmd_len;`
376			`}`
377
378
379			`/* Now we need to decide which callback to give to the urb we send the command with */`
380
381			`if (!srb->bufflen) {`
382			`if (srb->cmnd[0] == REQUEST_SENSE){`
383			`/* the usual buffer is not used, needs a special case */`
384			`hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);`
385			`usb_callback = request_sense_callback;`
386			`} else {`
387			`usb_callback = simple_command_callback;`
388			`}`
389			`} else {`
390			`if (srb->use_sg) {`
391			`usb_callback = scatter_gather_callback;`
392			`hpusbscsi->fragment = 0;`
393			`} else {`
394			`usb_callback = simple_payload_callback;`
395			`}`
396			`/* Now we find out which direction data is to be transfered in */`
397			`hpusbscsi->current_data_pipe = DIRECTION_IS_IN(srb->cmnd[0]) ?`
398			`usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in)`
399			`:`
400			`usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out)`
401			`;`
402			`}`
403
404
405			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
406			`if (hpusbscsi->state != HP_STATE_FREE) {`
407			`printk(KERN_CRIT"hpusbscsi - Ouch: queueing violation!\n");`
408			`return 1; /* This must not happen */`
409			`}`
410
411			`/* We zero the sense buffer to avoid confusing user space */`
412			`memset(srb->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);`
413
414			`hpusbscsi->state = HP_STATE_BEGINNING;`
415			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
416
417			`/* We prepare the urb for writing out the scsi command */`
418			`FILL_BULK_URB(`
419			`&hpusbscsi->dataurb,`
420			`hpusbscsi->dev,`
421			`usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),`
422			`srb->cmnd,`
423			`passed_length,`
424			`usb_callback,`
425			`hpusbscsi`
426			`);`
427			`hpusbscsi->scallback = callback;`
428			`hpusbscsi->srb = srb;`
429
430
431			`res = usb_submit_urb(&hpusbscsi->dataurb);`
432			`if (res) {`
433			`hpusbscsi->state = HP_STATE_FREE;`
434			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
435			`srb->result = DID_ERROR;`
436			`callback(srb);`
437
438			`}`
439
440			`out:`
441			`up(&hpusbscsi->lock);`
442			`out_nolock:`
443			`spin_lock_irq(&io_request_lock);`
444			`return 0;`
445			`}`
446
447			`static int hpusbscsi_scsi_host_reset (Scsi_Cmnd *srb)`
448			`{`
449			`struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);`
450
451			`PDEBUG(1, "SCSI reset requested");`
452			`//usb_reset_device(hpusbscsi->dev);`
453			`//PDEBUG(1, "SCSI reset completed");`
454			`hpusbscsi->state = HP_STATE_FREE;`
455
456			`return 0;`
457			`}`
458
459			`static int hpusbscsi_scsi_abort (Scsi_Cmnd *srb)`
460			`{`
461			`struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);`
462			`PDEBUG(1, "Request is canceled");`
463
464			`spin_unlock_irq(&io_request_lock);`
465			`usb_unlink_urb(&hpusbscsi->dataurb);`
466			`hpusbscsi->state = HP_STATE_FREE;`
467
468			`spin_lock_irq(&io_request_lock);`
469
470			`return SCSI_ABORT_PENDING;`
471			`}`
472
473			`/* usb interrupt handlers - they are all running IN INTERRUPT ! */`
474
475			`static void handle_usb_error (struct hpusbscsi *hpusbscsi)`
476			`{`
477			`if (hpusbscsi->scallback != NULL) {`
478			`hpusbscsi->srb->result = DID_ERROR;`
479			`hpusbscsi->scallback(hpusbscsi->srb);`
480			`}`
481			`hpusbscsi->state = HP_STATE_FREE;`
482			`}`
483
484			`static void control_interrupt_callback (struct urb *u)`
485			`{`
486			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
487			`u8 scsi_state;`
488
489			`PDEBUG(1, "Getting status byte %d",hpusbscsi->scsi_state_byte);`
490			`if(u->status < 0) {`
491			`if (hpusbscsi->state != HP_STATE_FREE)`
492			`handle_usb_error(hpusbscsi);`
493			`return;`
494			`}`
495
496			`scsi_state = hpusbscsi->scsi_state_byte;`
497			`if (hpusbscsi->state != HP_STATE_ERROR) {`
498			`hpusbscsi->srb->result &= SCSI_ERR_MASK;`
499			`hpusbscsi->srb->result \|= scsi_state;`
500			`}`
501
502			`if (scsi_state == CHECK_CONDITION << 1) {`
503			`if (hpusbscsi->state == HP_STATE_WAIT) {`
504			`issue_request_sense(hpusbscsi);`
505			`} else {`
506			`/* we request sense after an eventual data transfer */`
507			`hpusbscsi->state = HP_STATE_ERROR;`
508			`}`
509			`}`
510
511			`if (hpusbscsi->scallback != NULL && hpusbscsi->state == HP_STATE_WAIT && scsi_state != CHECK_CONDITION <<1)`
512			`/* we do a callback to the scsi layer if and only if all data has been transfered */`
513			`hpusbscsi->scallback(hpusbscsi->srb);`
514
515			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
516			`switch (hpusbscsi->state) {`
517			`case HP_STATE_WAIT:`
518			`hpusbscsi->state = HP_STATE_FREE;`
519			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
520			`break;`
521			`case HP_STATE_WORKING:`
522			`case HP_STATE_BEGINNING:`
523			`hpusbscsi->state = HP_STATE_PREMATURE;`
524			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
525			`break;`
526			`case HP_STATE_ERROR:`
527			`break;`
528			`default:`
529			`printk(KERN_ERR"hpusbscsi: Unexpected status report.\n");`
530			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
531			`hpusbscsi->state = HP_STATE_FREE;`
532			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
533			`break;`
534			`}`
535			`}`
536
537			`static void simple_command_callback(struct urb *u)`
538			`{`
539			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
540			`if (u->status<0) {`
541			`handle_usb_error(hpusbscsi);`
542			`return;`
543			`}`
544			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
545			`if (hpusbscsi->state != HP_STATE_PREMATURE) {`
546			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
547			`hpusbscsi->state = HP_STATE_WAIT;`
548			`} else {`
549			`if (hpusbscsi->scallback != NULL)`
550			`hpusbscsi->scallback(hpusbscsi->srb);`
551			`hpusbscsi->state = HP_STATE_FREE;`
552			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
553			`}`
554			`}`
555
556			`static void scatter_gather_callback(struct urb *u)`
557			`{`
558			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
559			`struct scatterlist *sg = hpusbscsi->srb->buffer;`
560			`usb_urb_callback callback;`
561			`int res;`
562
563			`PDEBUG(1, "Going through scatter/gather"); // bonzo - this gets hit a lot - maybe make it a 2`
564			`if (u->status < 0) {`
565			`handle_usb_error(hpusbscsi);`
566			`return;`
567			`}`
568
569			`if (hpusbscsi->fragment + 1 != hpusbscsi->srb->use_sg)`
570			`callback = scatter_gather_callback;`
571			`else`
572			`callback = simple_done;`
573
574			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
575			`if (hpusbscsi->state != HP_STATE_PREMATURE)`
576			`hpusbscsi->state = HP_STATE_WORKING;`
577			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
578
579			`FILL_BULK_URB(`
580			`u,`
581			`hpusbscsi->dev,`
582			`hpusbscsi->current_data_pipe,`
583			`sg[hpusbscsi->fragment].address,`
584			`sg[hpusbscsi->fragment++].length,`
585			`callback,`
586			`hpusbscsi`
587			`);`
588
589			`res = usb_submit_urb(u);`
590			`if (res)`
591			`handle_usb_error(hpusbscsi);`
592			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
593			`}`
594
595			`static void simple_done (struct urb *u)`
596			`{`
597			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
598
599			`if (u->status < 0) {`
600			`handle_usb_error(hpusbscsi);`
601			`return;`
602			`}`
603			`PDEBUG(1, "Data transfer done");`
604			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
605			`if (hpusbscsi->state != HP_STATE_PREMATURE) {`
606			`if (u->status < 0) {`
607			`handle_usb_error(hpusbscsi);`
608			`} else {`
609			`if (hpusbscsi->state != HP_STATE_ERROR) {`
610			`hpusbscsi->state = HP_STATE_WAIT;`
611			`} else {`
612			`issue_request_sense(hpusbscsi);`
613			`}`
614			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
615			`}`
616			`} else {`
617			`if (hpusbscsi->scallback != NULL)`
618			`hpusbscsi->scallback(hpusbscsi->srb);`
619			`hpusbscsi->state = HP_STATE_FREE;`
620			`}`
621			`}`
622
623			`static void simple_payload_callback (struct urb *u)`
624			`{`
625			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
626			`int res;`
627
628			`if (u->status<0) {`
629			`handle_usb_error(hpusbscsi);`
630			`return;`
631			`}`
632
633			`FILL_BULK_URB(`
634			`u,`
635			`hpusbscsi->dev,`
636			`hpusbscsi->current_data_pipe,`
637			`hpusbscsi->srb->buffer,`
638			`hpusbscsi->srb->bufflen,`
639			`simple_done,`
640			`hpusbscsi`
641			`);`
642
643			`res = usb_submit_urb(u);`
644			`if (res) {`
645			`handle_usb_error(hpusbscsi);`
646			`return;`
647			`}`
648			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
649			`if (hpusbscsi->state != HP_STATE_PREMATURE) {`
650			`hpusbscsi->state = HP_STATE_WORKING;`
651			`PDEBUG(2, "state= %s", states[hpusbscsi->state]);`
652			`}`
653			`}`
654
655			`static void request_sense_callback (struct urb *u)`
656			`{`
657			`struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;`
658
659			`if (u->status<0) {`
660			`handle_usb_error(hpusbscsi);`
661			`return;`
662			`}`
663
664			`FILL_BULK_URB(`
665			`u,`
666			`hpusbscsi->dev,`
667			`hpusbscsi->current_data_pipe,`
668			`hpusbscsi->srb->sense_buffer,`
669			`SCSI_SENSE_BUFFERSIZE,`
670			`simple_done,`
671			`hpusbscsi`
672			`);`
673
674			`if (0 > usb_submit_urb(u)) {`
675			`handle_usb_error(hpusbscsi);`
676			`return;`
677			`}`
678			`if (hpusbscsi->state != HP_STATE_PREMATURE && hpusbscsi->state != HP_STATE_ERROR)`
679			`hpusbscsi->state = HP_STATE_WORKING;`
680			`}`
681
682			`static void issue_request_sense (struct hpusbscsi *hpusbscsi)`
683			`{`
684			`FILL_BULK_URB(`
685			`&hpusbscsi->dataurb,`
686			`hpusbscsi->dev,`
687			`usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out),`
688			`&hpusbscsi->sense_command,`
689			`SENSE_COMMAND_SIZE,`
690			`request_sense_callback,`
691			`hpusbscsi`
692			`);`
693
694			`hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);`
695
696			`if (0 > usb_submit_urb(&hpusbscsi->dataurb)) {`
697			`handle_usb_error(hpusbscsi);`
698			`}`
699			`}`
700