开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
hpusbscsi.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

hpusbscsi.c：源码内容
  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.  */
  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"
  65. #include "hpusbscsi.h"
  67. static char *states[]={"FREE", "BEGINNING", "WORKING", "ERROR", "WAIT", "PREMATURE"};
  69. /* DEBUG related parts */
  70. #define HPUSBSCSI_DEBUG
  72. #ifdef HPUSBSCSI_DEBUG
  73. #  define PDEBUG(level, fmt, args...) 
  74.           if (debug >= (level)) info("[" __PRETTY_FUNCTION__ ":%d] " fmt, __LINE__ , 
  75.                  ## args)
  76. #else
  77. #  define PDEBUG(level, fmt, args...) do {} while(0)
  78. #endif
  81. /* 0=no debug messages
  82.  * 1=everything but trace states
  83.  * 2=trace states
  84.  */
  85. static int debug; /* = 0 */
  87. MODULE_PARM(debug, "i");
  88. MODULE_PARM_DESC(debug, "Debug level: 0=none, 1=no trace states, 2=trace states");
  90. /* global variables */
  92. struct list_head hpusbscsi_devices;
  93. //LIST_HEAD(hpusbscsi_devices);
  95. /* USB related parts */
  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]);
  105. int i, result;
  107. /* basic check */
  109. if (altsetting->bNumEndpoints != 3) {
  110. printk (KERN_ERR "Wrong number of endpointsn");
  111. return NULL;
  112. }
  114. /* descriptor allocation */
  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_LIST_HEAD (&new->lh);
  132. /* finding endpoints */
  134. for (i = 0; i < altsetting->bNumEndpoints; i++) {
  135. if (
  136.     (altsetting->endpoint[i].
  137.      bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  138.     USB_ENDPOINT_XFER_BULK) {
  139. if (altsetting->endpoint[i].
  140.     bEndpointAddress & USB_DIR_IN) {
  141. new->ep_in =
  142. altsetting->endpoint[i].
  143. bEndpointAddress &
  144. USB_ENDPOINT_NUMBER_MASK;
  145. } else {
  146. new->ep_out =
  147. altsetting->endpoint[i].
  148. bEndpointAddress &
  149. USB_ENDPOINT_NUMBER_MASK;
  150. }
  151. } else {
  152. new->ep_int =
  153. altsetting->endpoint[i].
  154. bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
  155. new->interrupt_interval= altsetting->endpoint[i].bInterval;
  156. }
  157. }
  159. /* USB initialisation magic for the simple case */
  161. result = usb_set_interface (dev, altsetting->bInterfaceNumber, 0);
  163. switch (result) {
  164. case 0: /* no error */
  165. break;
  167. case -EPIPE:
  168. usb_clear_halt (dev, usb_sndctrlpipe (dev, 0));
  169. break;
  171. default:
  172. printk (KERN_ERR "unknown error %d from usb_set_interfacen",
  173.  result);
  174. goto err_out;
  175. }
  177. /* making a template for the scsi layer to fake detection of a scsi device */
  179. memcpy (&(new->ctempl), &hpusbscsi_scsi_host_template,
  180. sizeof (hpusbscsi_scsi_host_template));
  181. (struct hpusbscsi *) new->ctempl.proc_dir = new;
  182. new->ctempl.module = THIS_MODULE;
  184. if (scsi_register_module (MODULE_SCSI_HA, &(new->ctempl)))
  185. goto err_out;
  187. new->sense_command[0] = REQUEST_SENSE;
  188. new->sense_command[4] = HPUSBSCSI_SENSE_LENGTH;
  190. /* adding to list for module unload */
  191. list_add (&hpusbscsi_devices, &new->lh);
  193. return new;
  195.       err_out:
  196. kfree (new);
  197. return NULL;
  198. }
  200. static void
  201. hpusbscsi_usb_disconnect (struct usb_device *dev, void *ptr)
  202. {
  203. struct hpusbscsi *hp = (struct hpusbscsi *)ptr;
  205. usb_unlink_urb(&hp->controlurb);
  206. usb_unlink_urb(&hp->dataurb);
  208. spin_lock_irq(&io_request_lock);
  209. hp->dev = NULL;
  210. spin_unlock_irq(&io_request_lock);
  211. }
  213. static struct usb_device_id hpusbscsi_usb_ids[] = {
  214. {USB_DEVICE (0x03f0, 0x0701)}, /* HP 53xx */
  215. {USB_DEVICE (0x03f0, 0x0801)}, /* HP 7400 */
  216. {USB_DEVICE (0x0638, 0x0268)},  /*iVina 1200U */
  217. {USB_DEVICE (0x0638, 0x026a)}, /*Scan Dual II */
  218. {USB_DEVICE (0x0638, 0x0A13)},  /*Avision AV600U */
  219. {USB_DEVICE (0x0638, 0x0A16)},  /*Avision DS610CU Scancopier */
  220. {USB_DEVICE (0x0638, 0x0A18)},  /*Avision AV600U Plus */
  221. {USB_DEVICE (0x0638, 0x0A23)},  /*Avision AV220 */
  222. {USB_DEVICE (0x0638, 0x0A24)},  /*Avision AV210 */
  223. {USB_DEVICE (0x0686, 0x4004)},  /*Minolta Elite II */
  224. {} /* Terminating entry */
  225. };
  227. MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);
  228. MODULE_LICENSE("GPL");
  231. static struct usb_driver hpusbscsi_usb_driver = {
  232. name:"hpusbscsi",
  233. probe:hpusbscsi_usb_probe,
  234. disconnect:hpusbscsi_usb_disconnect,
  235. id_table:hpusbscsi_usb_ids,
  236. };
  238. /* module initialisation */
  240. int __init
  241. hpusbscsi_init (void)
  242. {
  243. int result;
  245. INIT_LIST_HEAD (&hpusbscsi_devices);
  246. PDEBUG(0, "driver loaded, DebugLvel=%d", debug);
  247.  
  248. if ((result = usb_register (&hpusbscsi_usb_driver)) < 0) {
  249. printk (KERN_ERR "hpusbscsi: driver registration failedn");
  250. return -1;
  251. } else {
  252. return 0;
  253. }
  254. }
  256. void __exit
  257. hpusbscsi_exit (void)
  258. {
  259. struct list_head *tmp;
  260. struct list_head *old;
  261. struct hpusbscsi * o;
  263. for (tmp = hpusbscsi_devices.next; tmp != &hpusbscsi_devices;/*nothing */) {
  264. old = tmp;
  265. tmp = tmp->next;
  266. o = (struct hpusbscsi *)old;
  267. usb_unlink_urb(&o->controlurb);
  268. if(scsi_unregister_module(MODULE_SCSI_HA,&o->ctempl)<0)
  269. printk(KERN_CRIT"Deregistering failed!n");
  270. kfree(old);
  271. }
  273. usb_deregister (&hpusbscsi_usb_driver);
  274. }
  276. module_init (hpusbscsi_init);
  277. module_exit (hpusbscsi_exit);
  279. /* interface to the scsi layer */
  281. static int
  282. hpusbscsi_scsi_detect (struct SHT *sht)
  283. {
  284. /* Whole function stolen from usb-storage */
  286. struct hpusbscsi *desc = (struct hpusbscsi *) sht->proc_dir;
  287. /* What a hideous hack! */
  289. char local_name[48];
  290. spin_unlock_irq(&io_request_lock);
  293. /* set up the name of our subdirectory under /proc/scsi/ */
  294. sprintf (local_name, "hpusbscsi-%d", desc->number);
  295. sht->proc_name = kmalloc (strlen (local_name) + 1, GFP_KERNEL);
  296. /* FIXME: where is this freed ? */
  298. if (!sht->proc_name) {
  299. spin_lock_irq(&io_request_lock);
  300. return 0;
  301. }
  303. strcpy (sht->proc_name, local_name);
  305. sht->proc_dir = NULL;
  307. /* build and submit an interrupt URB for status byte handling */
  308.   FILL_INT_URB(&desc->controlurb,
  309. desc->dev,
  310. usb_rcvintpipe(desc->dev,desc->ep_int),
  311. &desc->scsi_state_byte,
  312. 1,
  313. control_interrupt_callback,
  314. desc,
  315. desc->interrupt_interval
  316. );
  318. if ( 0  >  usb_submit_urb(&desc->controlurb)) {
  319. kfree(sht->proc_name);
  320. spin_lock_irq(&io_request_lock);
  321. return 0;
  322. }
  324. /* In host->hostdata we store a pointer to desc */
  325. desc->host = scsi_register (sht, sizeof (desc));
  326. if (desc->host == NULL) {
  327. kfree (sht->proc_name);
  328. usb_unlink_urb(&desc->controlurb);
  329. spin_lock_irq(&io_request_lock);
  330. return 0;
  331. }
  332. desc->host->hostdata[0] = (unsigned long) desc;
  333. spin_lock_irq(&io_request_lock);
  335. return 1;
  336. }
  338. static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)
  339. {
  340. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  341. usb_urb_callback usb_callback;
  342. int res;
  344. spin_unlock_irq(&io_request_lock);
  346. /* we don't answer for anything but our single device on any faked host controller */
  347. if ( srb->device->lun || srb->device->id || srb->device->channel ) {
  348. srb->result = DID_BAD_TARGET;
  349. callback(srb);
  350. goto out;
  351. }
  353. /* Now we need to decide which callback to give to the urb we send the command with */
  355. if (!srb->bufflen) {
  356. if (srb->cmnd[0] == REQUEST_SENSE){
  357. /* the usual buffer is not used, needs a special case */
  358. hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
  359. usb_callback = request_sense_callback;
  360. } else {
  361. usb_callback = simple_command_callback;
  362. }
  363. } else {
  364.          if (srb->use_sg) {
  365. usb_callback = scatter_gather_callback;
  366. hpusbscsi->fragment = 0;
  367. } else {
  368.                  usb_callback = simple_payload_callback;
  369. }
  370. /* Now we find out which direction data is to be transfered in */
  371. hpusbscsi->current_data_pipe = DIRECTION_IS_IN(srb->cmnd[0]) ?
  372. usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in)
  373. :
  374. usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out)
  375. ;
  376. }
  379. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  380. if (hpusbscsi->state != HP_STATE_FREE) {
  381. printk(KERN_CRIT"hpusbscsi - Ouch: queueing violation!n");
  382. return 1; /* This must not happen */
  383. }
  385.         /* We zero the sense buffer to avoid confusing user space */
  386.         memset(srb->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
  388. hpusbscsi->state = HP_STATE_BEGINNING;
  389. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  391. /* We prepare the urb for writing out the scsi command */
  392. FILL_BULK_URB(
  393. &hpusbscsi->dataurb,
  394. hpusbscsi->dev,
  395. usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),
  396. srb->cmnd,
  397. srb->cmd_len,
  398. usb_callback,
  399. hpusbscsi
  400. );
  401. hpusbscsi->scallback = callback;
  402. hpusbscsi->srb = srb;
  404. if (hpusbscsi->dev == NULL) {
  405. srb->result = DID_ERROR;
  406. callback(srb);
  407. goto out;
  408. }
  410. res = usb_submit_urb(&hpusbscsi->dataurb);
  411. if (res) {
  412. hpusbscsi->state = HP_STATE_FREE;
  413. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  414. srb->result = DID_ERROR;
  415. callback(srb);
  417. }
  419. out:
  420. spin_lock_irq(&io_request_lock);
  421. return 0;
  422. }
  424. static int hpusbscsi_scsi_host_reset (Scsi_Cmnd *srb)
  425. {
  426. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  428. PDEBUG(1, "SCSI reset requested");
  429. //usb_reset_device(hpusbscsi->dev);
  430. //PDEBUG(1, "SCSI reset completed");
  431. hpusbscsi->state = HP_STATE_FREE;
  433. return 0;
  434. }
  436. static int hpusbscsi_scsi_abort (Scsi_Cmnd *srb)
  437. {
  438. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  439. PDEBUG(1, "Request is canceled");
  441. spin_unlock_irq(&io_request_lock);
  442. usb_unlink_urb(&hpusbscsi->dataurb);
  443. hpusbscsi->state = HP_STATE_FREE;
  445. spin_lock_irq(&io_request_lock);
  447. return SCSI_ABORT_PENDING;
  448. }
  450. /* usb interrupt handlers - they are all running IN INTERRUPT ! */
  452. static void handle_usb_error (struct hpusbscsi *hpusbscsi)
  453. {
  454. if (hpusbscsi->scallback != NULL) {
  455. hpusbscsi->srb->result = DID_ERROR;
  456. hpusbscsi->scallback(hpusbscsi->srb);
  457. }
  458. hpusbscsi->state = HP_STATE_FREE;
  459. }
  461. static void  control_interrupt_callback (struct urb *u)
  462. {
  463. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  464. u8 scsi_state;
  466. PDEBUG(1, "Getting status byte %d",hpusbscsi->scsi_state_byte);
  467. if(u->status < 0) {
  468.                 if (hpusbscsi->state != HP_STATE_FREE)
  469.                         handle_usb_error(hpusbscsi);
  470. return;
  471. }
  473. scsi_state = hpusbscsi->scsi_state_byte;
  474.         if (hpusbscsi->state != HP_STATE_ERROR) {
  475.                 hpusbscsi->srb->result &= SCSI_ERR_MASK;
  476.                 hpusbscsi->srb->result |= scsi_state;
  477.         }
  479. if (scsi_state == CHECK_CONDITION << 1) {
  480. if (hpusbscsi->state == HP_STATE_WAIT) {
  481. issue_request_sense(hpusbscsi);
  482. } else {
  483. /* we request sense after an eventual data transfer */
  484. hpusbscsi->state = HP_STATE_ERROR;
  485. }
  486. }
  488. if (hpusbscsi->scallback != NULL && hpusbscsi->state == HP_STATE_WAIT && scsi_state != CHECK_CONDITION <<1)
  489. /* we do a callback to the scsi layer if and only if all data has been transfered */
  490. hpusbscsi->scallback(hpusbscsi->srb);
  492. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  493. switch (hpusbscsi->state) {
  494. case HP_STATE_WAIT:
  495. hpusbscsi->state = HP_STATE_FREE;
  496. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  497. break;
  498. case HP_STATE_WORKING:
  499. case HP_STATE_BEGINNING:
  500. hpusbscsi->state = HP_STATE_PREMATURE;
  501. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  502. break;
  503. case HP_STATE_ERROR:
  504. break;
  505. default:
  506. printk(KERN_ERR"hpusbscsi: Unexpected status report.n");
  507. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  508. hpusbscsi->state = HP_STATE_FREE;
  509. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  510. break;
  511. }
  512. }
  514. static void simple_command_callback(struct urb *u)
  515. {
  516. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  517. if (u->status<0) {
  518. handle_usb_error(hpusbscsi);
  519. return;
  520.         }
  521. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  522. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  523.         PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  524. hpusbscsi->state = HP_STATE_WAIT;
  525. } else {
  526. if (hpusbscsi->scallback != NULL)
  527. hpusbscsi->scallback(hpusbscsi->srb);
  528. hpusbscsi->state = HP_STATE_FREE;
  529. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  530. }
  531. }
  533. static void scatter_gather_callback(struct urb *u)
  534. {
  535. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  536.         struct scatterlist *sg = hpusbscsi->srb->buffer;
  537.         usb_urb_callback callback;
  538.         int res;
  540.         PDEBUG(1, "Going through scatter/gather"); // bonzo - this gets hit a lot - maybe make it a 2
  541.         if (u->status < 0) {
  542.                 handle_usb_error(hpusbscsi);
  543.                 return;
  544.         }
  546.         if (hpusbscsi->fragment + 1 != hpusbscsi->srb->use_sg)
  547.                 callback = scatter_gather_callback;
  548.         else
  549.                 callback = simple_done;
  551. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  552.         if (hpusbscsi->state != HP_STATE_PREMATURE)
  553. hpusbscsi->state = HP_STATE_WORKING;
  554. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  556.         FILL_BULK_URB(
  557.                 u,
  558.                 hpusbscsi->dev,
  559.                 hpusbscsi->current_data_pipe,
  560.                 sg[hpusbscsi->fragment].address,
  561.                 sg[hpusbscsi->fragment++].length,
  562.                 callback,
  563.                 hpusbscsi
  564.         );
  566.         res = usb_submit_urb(u);
  567.         if (res)
  568.          handle_usb_error(hpusbscsi);
  569. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  570. }
  572. static void simple_done (struct urb *u)
  573. {
  574. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  576.         if (u->status < 0) {
  577.                 handle_usb_error(hpusbscsi);
  578.                 return;
  579.         }
  580. PDEBUG(1, "Data transfer done");
  581. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  582. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  583. if (u->status < 0) {
  584. handle_usb_error(hpusbscsi);
  585. } else {
  586. if (hpusbscsi->state != HP_STATE_ERROR) {
  587. hpusbscsi->state = HP_STATE_WAIT;
  588. } else {
  589. issue_request_sense(hpusbscsi);
  590. }
  591. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  592. }
  593. } else {
  594. if (hpusbscsi->scallback != NULL)
  595. hpusbscsi->scallback(hpusbscsi->srb);
  596. hpusbscsi->state = HP_STATE_FREE;
  597. }
  598. }
  600. static void simple_payload_callback (struct urb *u)
  601. {
  602. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  603. int res;
  605. if (u->status<0) {
  606.                 handle_usb_error(hpusbscsi);
  607. return;
  608.         }
  610. FILL_BULK_URB(
  611. u,
  612. hpusbscsi->dev,
  613. hpusbscsi->current_data_pipe,
  614. hpusbscsi->srb->buffer,
  615. hpusbscsi->srb->bufflen,
  616. simple_done,
  617. hpusbscsi
  618. );
  620. res = usb_submit_urb(u);
  621. if (res) {
  622.                 handle_usb_error(hpusbscsi);
  623. return;
  624.         }
  625. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  626. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  627. hpusbscsi->state = HP_STATE_WORKING;
  628. PDEBUG(2, "state= %s", states[hpusbscsi->state]);
  629. }
  630. }
  632. static void request_sense_callback (struct urb *u)
  633. {
  634. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  636. if (u->status<0) {
  637.                 handle_usb_error(hpusbscsi);
  638. return;
  639.         }
  641. FILL_BULK_URB(
  642. u,
  643. hpusbscsi->dev,
  644. hpusbscsi->current_data_pipe,
  645. hpusbscsi->srb->sense_buffer,
  646. SCSI_SENSE_BUFFERSIZE,
  647. simple_done,
  648. hpusbscsi
  649. );
  651. if (0 > usb_submit_urb(u)) {
  652. handle_usb_error(hpusbscsi);
  653. return;
  654. }
  655. if (hpusbscsi->state != HP_STATE_PREMATURE && hpusbscsi->state != HP_STATE_ERROR)
  656. hpusbscsi->state = HP_STATE_WORKING;
  657. }
  659. static void issue_request_sense (struct hpusbscsi *hpusbscsi)
  660. {
  661. FILL_BULK_URB(
  662. &hpusbscsi->dataurb,
  663. hpusbscsi->dev,
  664. usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out),
  665. &hpusbscsi->sense_command,
  666. SENSE_COMMAND_SIZE,
  667. request_sense_callback,
  668. hpusbscsi
  669. );
  671. hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
  673. if (0 > usb_submit_urb(&hpusbscsi->dataurb)) {
  674. handle_usb_error(hpusbscsi);
  675. }
  676. }