1/*
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
67static 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 */
85static int debug; /* = 0 */
86
87MODULE_PARM(debug, "i");
88MODULE_PARM_DESC(debug, "Debug level: 0=none, 1=no trace states, 2=trace states");
89
90/* global variables */
91
92struct list_head hpusbscsi_devices;
93//LIST_HEAD(hpusbscsi_devices);
94
95/* USB related parts */
96
97static void *
98hpusbscsi_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
204static void
205hpusbscsi_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
217static 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
231MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);
232MODULE_LICENSE("GPL");
233
234
235static 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
244int __init
245hpusbscsi_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
260void __exit
261hpusbscsi_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
280module_init (hpusbscsi_init);
281module_exit (hpusbscsi_exit);
282
283/* interface to the scsi layer */
284
285static int
286hpusbscsi_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
342static 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
440out:
441	up(&hpusbscsi->lock);
442out_nolock:
443	spin_lock_irq(&io_request_lock);
444	return 0;
445}
446
447static 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
459static 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
475static 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
484static 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
537static 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
556static 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
595static 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
623static 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
655static 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
682static 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
701