1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/sched.h>
4 #include <linux/signal.h>
5 #include <linux/errno.h>
6 #include <linux/init.h>
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/smp_lock.h>
10 #include <linux/usb.h>
11 #include <asm/atomic.h>
12 #include <linux/blkdev.h>
13 #include "../../scsi/scsi.h"
14 #include <scsi/scsi_host.h>
16 #include "hpusbscsi.h"
19 printk( KERN_DEBUG x )
21 static char *states[]={"FREE", "BEGINNING", "WORKING", "ERROR", "WAIT", "PREMATURE"};
23 #define TRACE_STATE printk(KERN_DEBUG"hpusbscsi->state = %s at line %d\n", states[hpusbscsi->state], __LINE__)
25 static Scsi_Host_Template hpusbscsi_scsi_host_template = {
26 .module = THIS_MODULE,
28 .proc_name = "hpusbscsi",
29 .queuecommand = hpusbscsi_scsi_queuecommand,
30 .eh_abort_handler = hpusbscsi_scsi_abort,
31 .eh_host_reset_handler = hpusbscsi_scsi_host_reset,
32 .sg_tablesize = SG_ALL,
41 hpusbscsi_usb_probe(struct usb_interface *intf,
42 const struct usb_device_id *id)
44 struct usb_device *dev = interface_to_usbdev(intf);
45 struct usb_host_interface *altsetting = intf->cur_altsetting;
46 struct hpusbscsi *new;
50 if (altsetting->desc.bNumEndpoints != 3) {
51 printk (KERN_ERR "Wrong number of endpoints\n");
55 new = kmalloc(sizeof(struct hpusbscsi), GFP_KERNEL);
58 memset(new, 0, sizeof(struct hpusbscsi));
59 new->dataurb = usb_alloc_urb(0, GFP_KERNEL);
62 new->controlurb = usb_alloc_urb(0, GFP_KERNEL);
64 goto out_free_dataurb;
67 init_waitqueue_head(&new->pending);
68 init_waitqueue_head(&new->deathrow);
71 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
72 if ((altsetting->endpoint[i].desc.
73 bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
74 USB_ENDPOINT_XFER_BULK) {
75 if (altsetting->endpoint[i].desc.
76 bEndpointAddress & USB_DIR_IN) {
78 altsetting->endpoint[i].desc.
80 USB_ENDPOINT_NUMBER_MASK;
83 altsetting->endpoint[i].desc.
85 USB_ENDPOINT_NUMBER_MASK;
89 altsetting->endpoint[i].desc.
90 bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
91 new->interrupt_interval= altsetting->endpoint[i].desc.
96 /* build and submit an interrupt URB for status byte handling */
97 usb_fill_int_urb(new->controlurb, new->dev,
98 usb_rcvintpipe(new->dev, new->ep_int),
99 &new->scsi_state_byte, 1,
100 control_interrupt_callback,new,
101 new->interrupt_interval);
103 if (usb_submit_urb(new->controlurb, GFP_KERNEL) < 0)
104 goto out_free_controlurb;
106 /* In host->hostdata we store a pointer to desc */
107 new->host = scsi_host_alloc(&hpusbscsi_scsi_host_template, sizeof(new));
109 goto out_unlink_controlurb;
111 new->host->hostdata[0] = (unsigned long)new;
112 scsi_add_host(new->host, &intf->dev); /* XXX handle failure */
113 scsi_scan_host(new->host);
115 new->sense_command[0] = REQUEST_SENSE;
116 new->sense_command[4] = HPUSBSCSI_SENSE_LENGTH;
118 usb_set_intfdata(intf, new);
121 out_unlink_controlurb:
122 usb_unlink_urb(new->controlurb);
124 usb_free_urb(new->controlurb);
126 usb_free_urb(new->dataurb);
133 hpusbscsi_usb_disconnect(struct usb_interface *intf)
135 struct hpusbscsi *desc = usb_get_intfdata(intf);
137 usb_set_intfdata(intf, NULL);
139 scsi_remove_host(desc->host);
140 usb_unlink_urb(desc->controlurb);
141 scsi_host_put(desc->host);
143 usb_free_urb(desc->controlurb);
144 usb_free_urb(desc->dataurb);
148 static struct usb_device_id hpusbscsi_usb_ids[] = {
149 {USB_DEVICE (0x03f0, 0x0701)}, /* HP 53xx */
150 {USB_DEVICE (0x03f0, 0x0801)}, /* HP 7400 */
151 {USB_DEVICE (0x0638, 0x0268)}, /*iVina 1200U */
152 {USB_DEVICE (0x0638, 0x026a)}, /*Scan Dual II */
153 {USB_DEVICE (0x0638, 0x0A13)}, /*Avision AV600U */
154 {USB_DEVICE (0x0638, 0x0A16)}, /*Avision DS610CU Scancopier */
155 {USB_DEVICE (0x0638, 0x0A18)}, /*Avision AV600U Plus */
156 {USB_DEVICE (0x0638, 0x0A23)}, /*Avision AV220 */
157 {USB_DEVICE (0x0638, 0x0A24)}, /*Avision AV210 */
158 {USB_DEVICE (0x0686, 0x4004)}, /*Minolta Elite II */
159 {} /* Terminating entry */
162 MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);
163 MODULE_LICENSE("GPL");
166 static struct usb_driver hpusbscsi_usb_driver = {
167 .owner = THIS_MODULE,
169 .probe =hpusbscsi_usb_probe,
170 .disconnect =hpusbscsi_usb_disconnect,
171 .id_table =hpusbscsi_usb_ids,
174 /* module initialisation */
177 hpusbscsi_init (void)
179 return usb_register(&hpusbscsi_usb_driver);
183 hpusbscsi_exit (void)
185 usb_deregister(&hpusbscsi_usb_driver);
188 module_init (hpusbscsi_init);
189 module_exit (hpusbscsi_exit);
191 static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)
193 struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->device->host->hostdata[0]);
194 usb_complete_t usb_callback;
197 /* we don't answer for anything but our single device on any faked host controller */
198 if ( srb->device->lun || srb->device->id || srb->device->channel ) {
200 srb->result = DID_BAD_TARGET;
206 /* Now we need to decide which callback to give to the urb we send the command with */
209 if (srb->cmnd[0] == REQUEST_SENSE){
210 hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
211 usb_callback = request_sense_callback;
213 usb_callback = simple_command_callback;
216 if (likely(srb->use_sg)) {
217 usb_callback = scatter_gather_callback;
218 hpusbscsi->fragment = 0;
220 usb_callback = simple_payload_callback;
222 /* Now we find out which direction data is to be transferred in */
223 hpusbscsi->current_data_pipe = DIRECTION_IS_IN(srb->cmnd[0]) ?
224 usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in)
226 usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out)
233 /* We zero the sense buffer to avoid confusing user space */
234 memset(srb->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
236 hpusbscsi->state = HP_STATE_BEGINNING;
239 /* We prepare the urb for writing out the scsi command */
243 usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),
249 hpusbscsi->scallback = callback;
250 hpusbscsi->srb = srb;
252 res = usb_submit_urb(hpusbscsi->dataurb, GFP_ATOMIC);
254 hpusbscsi->state = HP_STATE_FREE;
256 if (likely(callback != NULL)) {
257 srb->result = DID_ERROR;
266 static int hpusbscsi_scsi_host_reset (Scsi_Cmnd *srb)
268 struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->device->host->hostdata[0]);
270 printk(KERN_DEBUG"SCSI reset requested.\n");
271 //usb_reset_device(hpusbscsi->dev);
272 //printk(KERN_DEBUG"SCSI reset completed.\n");
273 hpusbscsi->state = HP_STATE_FREE;
278 static int hpusbscsi_scsi_abort (Scsi_Cmnd *srb)
280 struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->device->host->hostdata[0]);
281 printk(KERN_DEBUG"Requested is canceled.\n");
283 usb_unlink_urb(hpusbscsi->dataurb);
284 usb_unlink_urb(hpusbscsi->controlurb);
285 hpusbscsi->state = HP_STATE_FREE;
287 return SCSI_ABORT_PENDING;
290 /* usb interrupt handlers - they are all running IN INTERRUPT ! */
292 static void handle_usb_error (struct hpusbscsi *hpusbscsi)
294 if (likely(hpusbscsi->scallback != NULL)) {
295 hpusbscsi->srb->result = DID_ERROR;
296 hpusbscsi->scallback(hpusbscsi->srb);
298 hpusbscsi->state = HP_STATE_FREE;
301 static void control_interrupt_callback (struct urb *u, struct pt_regs *regs)
303 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
306 DEBUG("Getting status byte %d \n",hpusbscsi->scsi_state_byte);
307 if(unlikely(u->status < 0)) {
308 if (likely(hpusbscsi->state != HP_STATE_FREE))
309 handle_usb_error(hpusbscsi);
310 if (u->status == -ECONNRESET || u->status == -ENOENT || u->status == -ESHUTDOWN)
316 scsi_state = hpusbscsi->scsi_state_byte;
317 if (hpusbscsi->state != HP_STATE_ERROR) {
318 hpusbscsi->srb->result &= SCSI_ERR_MASK;
319 hpusbscsi->srb->result |= scsi_state;
322 if (scsi_state == CHECK_CONDITION << 1) {
323 if (hpusbscsi->state == HP_STATE_WAIT) {
324 issue_request_sense(hpusbscsi);
326 /* we request sense after an eventual data transfer */
327 hpusbscsi->state = HP_STATE_ERROR;
331 if (hpusbscsi->scallback != NULL && hpusbscsi->state == HP_STATE_WAIT && scsi_state != CHECK_CONDITION <<1 )
332 /* we do a callback to the scsi layer if and only if all data has been transferred */
333 hpusbscsi->scallback(hpusbscsi->srb);
336 switch (hpusbscsi->state) {
338 hpusbscsi->state = HP_STATE_FREE;
341 case HP_STATE_WORKING:
342 case HP_STATE_BEGINNING:
343 hpusbscsi->state = HP_STATE_PREMATURE;
349 printk(KERN_ERR"hpusbscsi: Unexpected status report.\n");
351 hpusbscsi->state = HP_STATE_FREE;
356 usb_submit_urb(u, GFP_ATOMIC);
359 static void simple_command_callback(struct urb *u, struct pt_regs *regs)
361 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
362 if (unlikely(u->status<0)) {
363 handle_usb_error(hpusbscsi);
367 if (hpusbscsi->state != HP_STATE_PREMATURE) {
369 hpusbscsi->state = HP_STATE_WAIT;
371 if (likely(hpusbscsi->scallback != NULL))
372 hpusbscsi->scallback(hpusbscsi->srb);
373 hpusbscsi->state = HP_STATE_FREE;
378 static void scatter_gather_callback(struct urb *u, struct pt_regs *regs)
380 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
381 struct scatterlist *sg = hpusbscsi->srb->buffer;
382 usb_complete_t callback;
385 DEBUG("Going through scatter/gather\n");
386 if (unlikely(u->status < 0)) {
387 handle_usb_error(hpusbscsi);
391 if (hpusbscsi->fragment + 1 != hpusbscsi->srb->use_sg)
392 callback = scatter_gather_callback;
394 callback = simple_done;
397 if (hpusbscsi->state != HP_STATE_PREMATURE)
398 hpusbscsi->state = HP_STATE_WORKING;
404 hpusbscsi->current_data_pipe,
405 page_address(sg[hpusbscsi->fragment].page) +
406 sg[hpusbscsi->fragment].offset,
407 sg[hpusbscsi->fragment++].length,
412 res = usb_submit_urb(u, GFP_ATOMIC);
414 handle_usb_error(hpusbscsi);
418 static void simple_done (struct urb *u, struct pt_regs *regs)
420 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
422 if (unlikely(u->status < 0)) {
423 handle_usb_error(hpusbscsi);
426 DEBUG("Data transfer done\n");
428 if (hpusbscsi->state != HP_STATE_PREMATURE) {
429 if (unlikely(u->status < 0)) {
430 handle_usb_error(hpusbscsi);
432 if (hpusbscsi->state != HP_STATE_ERROR) {
433 hpusbscsi->state = HP_STATE_WAIT;
435 issue_request_sense(hpusbscsi);
439 if (likely(hpusbscsi->scallback != NULL))
440 hpusbscsi->scallback(hpusbscsi->srb);
441 hpusbscsi->state = HP_STATE_FREE;
445 static void simple_payload_callback (struct urb *u, struct pt_regs *regs)
447 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
450 if (unlikely(u->status<0)) {
451 handle_usb_error(hpusbscsi);
458 hpusbscsi->current_data_pipe,
459 hpusbscsi->srb->buffer,
460 hpusbscsi->srb->bufflen,
465 res = usb_submit_urb(u, GFP_ATOMIC);
467 handle_usb_error(hpusbscsi);
471 if (hpusbscsi->state != HP_STATE_PREMATURE) {
472 hpusbscsi->state = HP_STATE_WORKING;
477 static void request_sense_callback (struct urb *u, struct pt_regs *regs)
479 struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
482 handle_usb_error(hpusbscsi);
489 hpusbscsi->current_data_pipe,
490 hpusbscsi->srb->sense_buffer,
491 SCSI_SENSE_BUFFERSIZE,
496 if (0 > usb_submit_urb(u, GFP_ATOMIC)) {
497 handle_usb_error(hpusbscsi);
500 if (hpusbscsi->state != HP_STATE_PREMATURE && hpusbscsi->state != HP_STATE_ERROR)
501 hpusbscsi->state = HP_STATE_WORKING;
504 static void issue_request_sense (struct hpusbscsi *hpusbscsi)
509 usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out),
510 &hpusbscsi->sense_command,
512 request_sense_callback,
516 hpusbscsi->current_data_pipe = usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in);
518 if (0 > usb_submit_urb(hpusbscsi->dataurb, GFP_ATOMIC)) {
519 handle_usb_error(hpusbscsi);