v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / drivers / usb / microtek.c
1 /* Driver for Microtek Scanmaker X6 USB scanner, and possibly others.
2  *
3  * (C) Copyright 2000 John Fremlin <vii@penguinpowered.com>
4  * (C) Copyright 2000 Oliver Neukum <Oliver.Neukum@lrz.uni-muenchen.de>
5  *
6  * Parts shamelessly stolen from usb-storage and copyright by their
7  * authors. Thanks to Matt Dharm for giving us permission!
8  *
9  * This driver implements a SCSI host controller driver and a USB
10  * device driver. To avoid confusion, all the USB related stuff is
11  * prefixed by mts_usb_ and all the SCSI stuff by mts_scsi_.
12  *
13  * Microtek (www.microtek.com) did not release the specifications for
14  * their USB protocol to us, so we had to reverse engineer them. We
15  * don't know for which models they are valid.
16  *
17  * The X6 USB has three bulk endpoints, one output (0x1) down which
18  * commands and outgoing data are sent, and two input: 0x82 from which
19  * normal data is read from the scanner (in packets of maximum 32
20  * bytes) and from which the status byte is read, and 0x83 from which
21  * the results of a scan (or preview) are read in up to 64 * 1024 byte
22  * chunks by the Windows driver. We don't know how much it is possible
23  * to read at a time from 0x83.
24  *
25  * It seems possible to read (with URB transfers) everything from 0x82
26  * in one go, without bothering to read in 32 byte chunks.
27  *
28  * There seems to be an optimisation of a further READ implicit if
29  * you simply read from 0x83.
30  *
31  * Guessed protocol:
32  *
33  *      Send raw SCSI command to EP 0x1
34  *
35  *      If there is data to receive:
36  *              If the command was READ datatype=image:
37  *                      Read a lot of data from EP 0x83
38  *              Else:
39  *                      Read data from EP 0x82
40  *      Else:
41  *              If there is data to transmit:
42  *                      Write it to EP 0x1
43  *
44  *      Read status byte from EP 0x82
45  *
46  * References:
47  *
48  * The SCSI command set for the scanner is available from
49  *      ftp://ftp.microtek.com/microtek/devpack/
50  *
51  * Microtek NV sent us a more up to date version of the document. If
52  * you want it, just send mail.
53  *
54  * Status:
55  *
56  *      Untested with multiple scanners.
57  *      Untested on SMP.
58  *      Untested on a bigendian machine.
59  *
60  * History:
61  *
62  *      20000417 starting history
63  *      20000417 fixed load oops
64  *      20000417 fixed unload oops
65  *      20000419 fixed READ IMAGE detection
66  *      20000424 started conversion to use URBs
67  *      20000502 handled short transfers as errors
68  *      20000513 rename and organisation of functions (john)
69  *      20000513 added IDs for all products supported by Windows driver (john)
70  *      20000514 Rewrote mts_scsi_queuecommand to use URBs (john)
71  *      20000514 Version 0.0.8j
72  *      20000514 Fix reporting of non-existant devices to SCSI layer (john)
73  *      20000514 Added MTS_DEBUG_INT (john)
74  *      20000514 Changed "usb-microtek" to "microtek" for consistency (john)
75  *      20000514 Stupid bug fixes (john)
76  *      20000514 Version 0.0.9j
77  *      20000515 Put transfer context and URB in mts_desc (john)
78  *      20000515 Added prelim turn off debugging support (john)
79  *      20000515 Version 0.0.10j
80  *      20000515 Fixed up URB allocation (clear URB on alloc) (john)
81  *      20000515 Version 0.0.11j
82  *      20000516 Removed unnecessary spinlock in mts_transfer_context (john)
83  *      20000516 Removed unnecessary up on instance lock in mts_remove_nolock (john)
84  *      20000516 Implemented (badly) scsi_abort (john)
85  *      20000516 Version 0.0.12j
86  *      20000517 Hopefully removed mts_remove_nolock quasideadlock (john)
87  *      20000517 Added mts_debug_dump to print ll USB info (john)
88  *      20000518 Tweaks and documentation updates (john)
89  *      20000518 Version 0.0.13j
90  *      20000518 Cleaned up abort handling (john)
91  *      20000523 Removed scsi_command and various scsi_..._resets (john)
92  *      20000523 Added unlink URB on scsi_abort, now OHCI supports it (john)
93  *      20000523 Fixed last tiresome compile warning (john)
94  *      20000523 Version 0.0.14j (though version 0.1 has come out?)
95  *      20000602 Added primitive reset
96  *      20000602 Version 0.2.0
97  *      20000603 various cosmetic changes
98  *      20000603 Version 0.2.1
99  *      20000620 minor cosmetic changes
100  *      20000620 Version 0.2.2
101  *      20000822 Hopefully fixed deadlock in mts_remove_nolock()
102  *      20000822 Fixed minor race in mts_transfer_cleanup()
103  *      20000822 Fixed deadlock on submission error in queuecommand
104  *      20000822 Version 0.2.3
105  *      20000913 Reduced module size if debugging is off
106  *      20000913 Version 0.2.4
107  *      20010210 New abort logic
108  *      20010210 Version 0.3.0
109  *      20010217 Merged scatter/gather
110  *      20010218 Version 0.4.0
111  *      20010218 Cosmetic fixes
112  *      20010218 Version 0.4.1
113  *      20010306 Abort while using scatter/gather
114  *      20010306 Version 0.4.2
115  *      20010311 Remove all timeouts and tidy up generally (john)
116  *      20010320 check return value of scsi_register()
117  *      20010320 Version 0.4.3
118  *      20010408 Identify version on module load.
119  */
120
121 #include <linux/module.h>
122 #include <linux/kernel.h>
123 #include <linux/sched.h>
124 #include <linux/signal.h>
125 #include <linux/errno.h>
126 #include <linux/random.h>
127 #include <linux/poll.h>
128 #include <linux/init.h>
129 #include <linux/slab.h>
130 #include <linux/spinlock.h>
131 #include <linux/smp_lock.h>
132 #include <linux/usb.h>
133 #include <linux/proc_fs.h>
134
135 #include <asm/atomic.h>
136 #include <linux/blk.h>
137 #include "../scsi/scsi.h"
138 #include "../scsi/hosts.h"
139 #include "../scsi/sd.h"
140
141 #include "microtek.h"
142
143 /*
144  * Version Information
145  */
146 #define DRIVER_VERSION "v0.4.3"
147 #define DRIVER_AUTHOR "John Fremlin <vii@penguinpowered.com>, Oliver Neukum <Oliver.Neukum@lrz.uni-muenchen.de>"
148 #define DRIVER_DESC "Microtek Scanmaker X6 USB scanner driver"
149
150 /* Should we do debugging? */
151
152 //#define MTS_DO_DEBUG
153
154 /* USB layer driver interface */
155
156 static void *mts_usb_probe(struct usb_device *dev, unsigned int interface,
157                          const struct usb_device_id *id);
158 static void mts_usb_disconnect(struct usb_device *dev, void *ptr);
159
160 static struct usb_device_id mts_usb_ids [];
161
162 static struct usb_driver mts_usb_driver = {
163         name:           "microtekX6",
164         probe:          mts_usb_probe,
165         disconnect:     mts_usb_disconnect,
166         id_table:       mts_usb_ids,
167 };
168
169
170 /* Internal driver stuff */
171
172 #define MTS_VERSION     "0.4.3"
173 #define MTS_NAME        "microtek usb (rev " MTS_VERSION "): "
174
175 #define MTS_WARNING(x...) \
176         printk( KERN_WARNING MTS_NAME x )
177 #define MTS_ERROR(x...) \
178         printk( KERN_ERR MTS_NAME x )
179 #define MTS_INT_ERROR(x...) \
180         MTS_ERROR(x)
181 #define MTS_MESSAGE(x...) \
182         printk( KERN_INFO MTS_NAME x )
183
184 #if defined MTS_DO_DEBUG
185
186 #define MTS_DEBUG(x...) \
187         printk( KERN_DEBUG MTS_NAME x )
188
189 #define MTS_DEBUG_GOT_HERE() \
190         MTS_DEBUG("got to %s:%d (%s)\n", __FILE__, (int)__LINE__, __PRETTY_FUNCTION__ )
191 #define MTS_DEBUG_INT() \
192         do { MTS_DEBUG_GOT_HERE(); \
193              MTS_DEBUG("transfer = 0x%x context = 0x%x\n",(int)transfer,(int)context ); \
194              MTS_DEBUG("status = 0x%x data-length = 0x%x sent = 0x%x\n",(int)transfer->status,(int)context->data_length, (int)transfer->actual_length ); \
195              mts_debug_dump(context->instance);\
196            } while(0)
197 #else
198
199 #define MTS_NUL_STATEMENT do { } while(0)
200
201 #define MTS_DEBUG(x...) MTS_NUL_STATEMENT
202 #define MTS_DEBUG_GOT_HERE() MTS_NUL_STATEMENT
203 #define MTS_DEBUG_INT() MTS_NUL_STATEMENT
204
205 #endif
206
207
208
209 #define MTS_INT_INIT()\
210         struct mts_transfer_context* context = (struct mts_transfer_context*)transfer->context; \
211         MTS_DEBUG_INT();\
212
213 #ifdef MTS_DO_DEBUG
214
215 static inline void mts_debug_dump(struct mts_desc* desc) {
216         MTS_DEBUG("desc at 0x%x: halted = %02x%02x, toggle = %02x%02x\n",
217                   (int)desc,(int)desc->usb_dev->halted[1],(int)desc->usb_dev->halted[0],
218                   (int)desc->usb_dev->toggle[1],(int)desc->usb_dev->toggle[0]
219                 );
220         MTS_DEBUG("ep_out=%x ep_response=%x ep_image=%x\n",
221                   usb_sndbulkpipe(desc->usb_dev,desc->ep_out),
222                   usb_rcvbulkpipe(desc->usb_dev,desc->ep_response),
223                   usb_rcvbulkpipe(desc->usb_dev,desc->ep_image)
224                 );
225 }
226
227
228 static inline void mts_show_command(Scsi_Cmnd *srb)
229 {
230         char *what = NULL;
231
232         switch (srb->cmnd[0]) {
233         case TEST_UNIT_READY: what = "TEST_UNIT_READY"; break;
234         case REZERO_UNIT: what = "REZERO_UNIT"; break;
235         case REQUEST_SENSE: what = "REQUEST_SENSE"; break;
236         case FORMAT_UNIT: what = "FORMAT_UNIT"; break;
237         case READ_BLOCK_LIMITS: what = "READ_BLOCK_LIMITS"; break;
238         case REASSIGN_BLOCKS: what = "REASSIGN_BLOCKS"; break;
239         case READ_6: what = "READ_6"; break;
240         case WRITE_6: what = "WRITE_6"; break;
241         case SEEK_6: what = "SEEK_6"; break;
242         case READ_REVERSE: what = "READ_REVERSE"; break;
243         case WRITE_FILEMARKS: what = "WRITE_FILEMARKS"; break;
244         case SPACE: what = "SPACE"; break;
245         case INQUIRY: what = "INQUIRY"; break;
246         case RECOVER_BUFFERED_DATA: what = "RECOVER_BUFFERED_DATA"; break;
247         case MODE_SELECT: what = "MODE_SELECT"; break;
248         case RESERVE: what = "RESERVE"; break;
249         case RELEASE: what = "RELEASE"; break;
250         case COPY: what = "COPY"; break;
251         case ERASE: what = "ERASE"; break;
252         case MODE_SENSE: what = "MODE_SENSE"; break;
253         case START_STOP: what = "START_STOP"; break;
254         case RECEIVE_DIAGNOSTIC: what = "RECEIVE_DIAGNOSTIC"; break;
255         case SEND_DIAGNOSTIC: what = "SEND_DIAGNOSTIC"; break;
256         case ALLOW_MEDIUM_REMOVAL: what = "ALLOW_MEDIUM_REMOVAL"; break;
257         case SET_WINDOW: what = "SET_WINDOW"; break;
258         case READ_CAPACITY: what = "READ_CAPACITY"; break;
259         case READ_10: what = "READ_10"; break;
260         case WRITE_10: what = "WRITE_10"; break;
261         case SEEK_10: what = "SEEK_10"; break;
262         case WRITE_VERIFY: what = "WRITE_VERIFY"; break;
263         case VERIFY: what = "VERIFY"; break;
264         case SEARCH_HIGH: what = "SEARCH_HIGH"; break;
265         case SEARCH_EQUAL: what = "SEARCH_EQUAL"; break;
266         case SEARCH_LOW: what = "SEARCH_LOW"; break;
267         case SET_LIMITS: what = "SET_LIMITS"; break;
268         case READ_POSITION: what = "READ_POSITION"; break;
269         case SYNCHRONIZE_CACHE: what = "SYNCHRONIZE_CACHE"; break;
270         case LOCK_UNLOCK_CACHE: what = "LOCK_UNLOCK_CACHE"; break;
271         case READ_DEFECT_DATA: what = "READ_DEFECT_DATA"; break;
272         case MEDIUM_SCAN: what = "MEDIUM_SCAN"; break;
273         case COMPARE: what = "COMPARE"; break;
274         case COPY_VERIFY: what = "COPY_VERIFY"; break;
275         case WRITE_BUFFER: what = "WRITE_BUFFER"; break;
276         case READ_BUFFER: what = "READ_BUFFER"; break;
277         case UPDATE_BLOCK: what = "UPDATE_BLOCK"; break;
278         case READ_LONG: what = "READ_LONG"; break;
279         case WRITE_LONG: what = "WRITE_LONG"; break;
280         case CHANGE_DEFINITION: what = "CHANGE_DEFINITION"; break;
281         case WRITE_SAME: what = "WRITE_SAME"; break;
282         case READ_TOC: what = "READ_TOC"; break;
283         case LOG_SELECT: what = "LOG_SELECT"; break;
284         case LOG_SENSE: what = "LOG_SENSE"; break;
285         case MODE_SELECT_10: what = "MODE_SELECT_10"; break;
286         case MODE_SENSE_10: what = "MODE_SENSE_10"; break;
287         case MOVE_MEDIUM: what = "MOVE_MEDIUM"; break;
288         case READ_12: what = "READ_12"; break;
289         case WRITE_12: what = "WRITE_12"; break;
290         case WRITE_VERIFY_12: what = "WRITE_VERIFY_12"; break;
291         case SEARCH_HIGH_12: what = "SEARCH_HIGH_12"; break;
292         case SEARCH_EQUAL_12: what = "SEARCH_EQUAL_12"; break;
293         case SEARCH_LOW_12: what = "SEARCH_LOW_12"; break;
294         case READ_ELEMENT_STATUS: what = "READ_ELEMENT_STATUS"; break;
295         case SEND_VOLUME_TAG: what = "SEND_VOLUME_TAG"; break;
296         case WRITE_LONG_2: what = "WRITE_LONG_2"; break;
297         default:
298                 MTS_DEBUG("can't decode command\n");
299                 goto out;
300                 break;
301         }
302         MTS_DEBUG( "Command %s (%d bytes)\n", what, srb->cmd_len);
303
304  out:
305         MTS_DEBUG( "  %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
306                srb->cmnd[0], srb->cmnd[1], srb->cmnd[2], srb->cmnd[3], srb->cmnd[4], srb->cmnd[5],
307                srb->cmnd[6], srb->cmnd[7], srb->cmnd[8], srb->cmnd[9]);
308 }
309
310 #else
311
312 static inline void mts_show_command(Scsi_Cmnd * dummy)
313 {
314 }
315
316 static inline void mts_debug_dump(struct mts_desc* dummy)
317 {
318 }
319
320 #endif
321
322
323 /* static inline int mts_is_aborting(struct mts_desc* desc) {
324         return (atomic_read(&desc->context.do_abort));
325 }  */
326
327 static inline void mts_urb_abort(struct mts_desc* desc) {
328         MTS_DEBUG_GOT_HERE();
329         mts_debug_dump(desc);
330
331         usb_unlink_urb( &desc->urb );
332 }
333
334 static struct mts_desc * mts_list; /* list of active scanners */
335 struct semaphore mts_list_semaphore;
336
337 /* Internal list operations */
338
339 static
340 void mts_remove_nolock( struct mts_desc* to_remove )
341 {
342         MTS_DEBUG( "removing 0x%x from list\n",
343                    (int)to_remove );
344
345         lock_kernel();
346         mts_urb_abort(to_remove);
347
348         MTS_DEBUG_GOT_HERE();
349
350         if ( to_remove != mts_list ) {
351                 MTS_DEBUG_GOT_HERE();
352                 if (to_remove->prev && to_remove->next)
353                         to_remove->prev->next = to_remove->next;
354         } else {
355                 MTS_DEBUG_GOT_HERE();
356                 mts_list = to_remove->next;
357                 if (mts_list) {
358                         MTS_DEBUG_GOT_HERE();
359                         mts_list->prev = 0;
360                 }
361         }
362
363         if ( to_remove->next ) {
364                 MTS_DEBUG_GOT_HERE();
365                 to_remove->next->prev = to_remove->prev;
366         }
367
368         MTS_DEBUG_GOT_HERE();
369         scsi_unregister_module(MODULE_SCSI_HA, &(to_remove->ctempl));
370         unlock_kernel();
371
372         kfree( to_remove );
373 }
374
375 static
376 void mts_add_nolock( struct mts_desc* to_add )
377 {
378         MTS_DEBUG( "adding 0x%x to list\n", (int)to_add );
379
380         to_add->prev = 0;
381         to_add->next = mts_list;
382         if ( mts_list ) {
383                 mts_list->prev = to_add;
384         }
385
386         mts_list = to_add;
387 }
388
389
390
391
392 /* SCSI driver interface */
393
394 /* scsi related functions - dummies for now mostly */
395
396 static int mts_scsi_release(struct Scsi_Host *psh)
397 {
398         MTS_DEBUG_GOT_HERE();
399
400         return 0;
401 }
402
403 static int mts_scsi_abort (Scsi_Cmnd *srb)
404 {
405         struct mts_desc* desc = (struct mts_desc*)(srb->host->hostdata[0]);
406
407         MTS_DEBUG_GOT_HERE();
408
409         mts_urb_abort(desc);
410
411         return SCSI_ABORT_PENDING;
412 }
413
414 static int mts_scsi_host_reset (Scsi_Cmnd *srb)
415 {
416         struct mts_desc* desc = (struct mts_desc*)(srb->host->hostdata[0]);
417
418         MTS_DEBUG_GOT_HERE();
419         mts_debug_dump(desc);
420
421         usb_reset_device(desc->usb_dev); /*FIXME: untested on new reset code */
422         return 0;  /* RANT why here 0 and not SUCCESS */
423 }
424
425 /* the core of the scsi part */
426
427 /* faking a detection - which can't fail :-) */
428
429 static int mts_scsi_detect (struct SHT * sht)
430 {
431         /* Whole function stolen from usb-storage */
432
433         struct mts_desc * desc = (struct mts_desc *)sht->proc_dir;
434         /* What a hideous hack! */
435
436         char local_name[48];
437
438         MTS_DEBUG_GOT_HERE();
439
440         /* set up the name of our subdirectory under /proc/scsi/ */
441         sprintf(local_name, "microtek-%d", desc->host_number);
442         sht->proc_name = kmalloc (strlen(local_name) + 1, GFP_KERNEL);
443         /* FIXME: where is this freed ? */
444
445         if (!sht->proc_name) {
446                 MTS_ERROR( "unable to allocate memory for proc interface!!\n" );
447                 return 0;
448         }
449
450         strcpy(sht->proc_name, local_name);
451
452         sht->proc_dir = NULL;
453
454         /* In host->hostdata we store a pointer to desc */
455         desc->host = scsi_register(sht, sizeof(desc));
456         if (desc->host == NULL) {
457                 MTS_ERROR("Cannot register due to low memory");
458                 kfree(sht->proc_name);
459                 return 0;
460         }
461         desc->host->hostdata[0] = (unsigned long)desc;
462 /* FIXME: what if sizeof(void*) != sizeof(unsigned long)? */
463
464         return 1;
465 }
466
467
468
469 /* Main entrypoint: SCSI commands are dispatched to here */
470
471
472
473 static
474 int mts_scsi_queuecommand (Scsi_Cmnd *srb, mts_scsi_cmnd_callback callback );
475
476 static void mts_transfer_cleanup( struct urb *transfer );
477 static void mts_do_sg(struct urb * transfer);
478
479
480 inline static
481 void mts_int_submit_urb (struct urb* transfer,
482                         int pipe,
483                         void* data,
484                         unsigned length,
485                         mts_usb_urb_callback callback )
486 /* Interrupt context! */
487
488 /* Holding transfer->context->lock! */
489 {
490         int res;
491
492         MTS_INT_INIT();
493
494         FILL_BULK_URB(transfer,
495                       context->instance->usb_dev,
496                       pipe,
497                       data,
498                       length,
499                       callback,
500                       context
501                 );
502
503         transfer->transfer_flags = USB_ASYNC_UNLINK;
504         transfer->status = 0;
505
506         res = usb_submit_urb( transfer );
507         if ( res ) {
508                 MTS_INT_ERROR( "could not submit URB! Error was %d\n",(int)res );
509                 context->srb->result = DID_ERROR << 16;
510                 mts_transfer_cleanup(transfer);
511         }
512         return;
513 }
514
515
516 static void mts_transfer_cleanup( struct urb *transfer )
517 /* Interrupt context! */
518 {
519         MTS_INT_INIT();
520
521         if ( context->final_callback )
522                 context->final_callback(context->srb);
523         up( &context->instance->lock );
524
525 }
526
527 static void mts_transfer_done( struct urb *transfer )
528 {
529         MTS_INT_INIT();
530
531         context->srb->result &= MTS_SCSI_ERR_MASK;
532         context->srb->result |= (unsigned)context->status<<1;
533
534         mts_transfer_cleanup(transfer);
535
536         return;
537 }
538
539
540 static void mts_get_status( struct urb *transfer )
541 /* Interrupt context! */
542 {
543         MTS_INT_INIT();
544
545         mts_int_submit_urb(transfer,
546                            usb_rcvbulkpipe(context->instance->usb_dev,
547                                            context->instance->ep_response),
548                            &context->status,
549                            1,
550                            mts_transfer_done );
551 }
552
553 static void mts_data_done( struct urb* transfer )
554 /* Interrupt context! */
555 {
556         MTS_INT_INIT();
557
558         if ( context->data_length != transfer->actual_length ) {
559                 context->srb->resid = context->data_length - transfer->actual_length;
560         } else if ( transfer->status ) {
561                 context->srb->result = (transfer->status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
562         }
563
564         mts_get_status(transfer);
565
566         return;
567 }
568
569
570 static void mts_command_done( struct urb *transfer )
571 /* Interrupt context! */
572 {
573         MTS_INT_INIT();
574
575         if ( transfer->status ) {
576                 if (transfer->status == -ENOENT) {
577                         /* We are being killed */
578                         MTS_DEBUG_GOT_HERE();
579                         context->srb->result = DID_ABORT<<16;
580                 } else {
581                         /* A genuine error has occured */
582                         MTS_DEBUG_GOT_HERE();
583
584                         context->srb->result = DID_ERROR<<16;
585                 }
586                 mts_transfer_cleanup(transfer);
587
588                 return;
589         }
590
591         if ( context->data ) {
592                 mts_int_submit_urb(transfer,
593                                    context->data_pipe,
594                                    context->data,
595                                    context->data_length,
596                                    context->srb->use_sg ? mts_do_sg : mts_data_done);
597         } else mts_get_status(transfer);
598
599         return;
600 }
601
602 static void mts_do_sg (struct urb* transfer)
603 {
604         struct scatterlist * sg;
605         MTS_INT_INIT();
606         
607         MTS_DEBUG("Processing fragment %d of %d\n", context->fragment,context->srb->use_sg);
608
609         if (transfer->status) {
610                 context->srb->result = (transfer->status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
611                 mts_transfer_cleanup(transfer);
612         }
613
614         sg = context->srb->buffer;
615         context->fragment++;
616         mts_int_submit_urb(transfer,
617                         context->data_pipe,
618                         sg[context->fragment].address,
619                         sg[context->fragment].length,
620                         context->fragment + 1 == context->srb->use_sg ? mts_data_done : mts_do_sg);
621         return;
622 }
623
624 static const u8 mts_read_image_sig[] = { 0x28, 00, 00, 00 };
625 static const u8 mts_read_image_sig_len = 4;
626 static const unsigned char mts_direction[256/8] = {
627         0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77,
628         0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
629         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
630         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
631 };
632
633
634 #define MTS_DIRECTION_IS_IN(x) ((mts_direction[x>>3] >> (x & 7)) & 1)
635
636 static void
637 mts_build_transfer_context( Scsi_Cmnd *srb, struct mts_desc* desc )
638 {
639         int pipe;
640         struct scatterlist * sg;
641         
642         MTS_DEBUG_GOT_HERE();
643
644         desc->context.instance = desc;
645         desc->context.srb = srb;
646         desc->context.fragment = 0;
647
648         if (!srb->use_sg) {
649                 if ( !srb->bufflen ){
650                         desc->context.data = 0;
651                         desc->context.data_length = 0;
652                         return;
653                 } else {
654                         desc->context.data = srb->buffer;
655                         desc->context.data_length = srb->bufflen;
656                         MTS_DEBUG("length = %d or %d\n",
657                                   srb->request_bufflen, srb->bufflen);
658                 }
659         } else {
660                 MTS_DEBUG("Using scatter/gather\n");
661                 sg = srb->buffer;
662                 desc->context.data = sg[0].address;
663                 desc->context.data_length = sg[0].length;
664         }
665
666
667         /* can't rely on srb->sc_data_direction */
668
669         /* Brutally ripped from usb-storage */
670
671         if ( !memcmp( srb->cmnd, mts_read_image_sig, mts_read_image_sig_len )
672 ) {             pipe = usb_rcvbulkpipe(desc->usb_dev,desc->ep_image);
673                 MTS_DEBUG( "transfering from desc->ep_image == %d\n",
674                            (int)desc->ep_image );
675         } else if ( MTS_DIRECTION_IS_IN(srb->cmnd[0]) ) {
676                         pipe = usb_rcvbulkpipe(desc->usb_dev,desc->ep_response);
677                         MTS_DEBUG( "transfering from desc->ep_response == %d\n",
678                                    (int)desc->ep_response);
679         } else {
680                 MTS_DEBUG("transfering to desc->ep_out == %d\n",
681                           (int)desc->ep_out);
682                 pipe = usb_sndbulkpipe(desc->usb_dev,desc->ep_out);
683         }
684         desc->context.data_pipe = pipe;
685 }
686
687
688 static
689 int mts_scsi_queuecommand( Scsi_Cmnd *srb, mts_scsi_cmnd_callback callback )
690 {
691         struct mts_desc* desc = (struct mts_desc*)(srb->host->hostdata[0]);
692         int err = 0;
693         int res;
694
695         MTS_DEBUG_GOT_HERE();
696         mts_show_command(srb);
697         mts_debug_dump(desc);
698
699         if ( srb->device->lun || srb->device->id || srb->device->channel ) {
700
701                 MTS_DEBUG("Command to LUN=%d ID=%d CHANNEL=%d from SCSI layer\n",(int)srb->device->lun,(int)srb->device->id, (int)srb->device->channel );
702
703                 MTS_DEBUG("this device doesn't exist\n");
704
705                 srb->result = DID_BAD_TARGET << 16;
706
707                 if(callback)
708                         callback(srb);
709
710                 goto out;
711         }
712
713         down(&desc->lock);
714         
715         FILL_BULK_URB(&desc->urb,
716                       desc->usb_dev,
717                       usb_sndbulkpipe(desc->usb_dev,desc->ep_out),
718                       srb->cmnd,
719                       srb->cmd_len,
720                       mts_command_done,
721                       &desc->context
722                       );
723
724
725         mts_build_transfer_context( srb, desc );
726         desc->context.final_callback = callback;
727         
728         res=usb_submit_urb(&desc->urb);
729
730         if(res){
731                 MTS_ERROR("error %d submitting URB\n",(int)res);
732                 srb->result = DID_ERROR << 16;
733
734                 if(callback)
735                         callback(srb);
736                 up(&desc->lock);
737
738         }
739
740 out:
741         return err;
742 }
743 /*
744  * this defines our 'host'
745  */
746
747 /* NOTE: This is taken from usb-storage, should be right. */
748
749
750 static Scsi_Host_Template mts_scsi_host_template = {
751         name:           "microtekX6",
752         detect:         mts_scsi_detect,
753         release:        mts_scsi_release,
754         queuecommand:   mts_scsi_queuecommand,
755
756         eh_abort_handler:       mts_scsi_abort,
757         eh_host_reset_handler:  mts_scsi_host_reset,
758
759         sg_tablesize:           SG_ALL,
760         can_queue:              1,
761         this_id:                -1,
762         cmd_per_lun:            1,
763         present:                0,
764         unchecked_isa_dma:      FALSE,
765         use_clustering:         TRUE,
766         use_new_eh_code:        TRUE,
767         emulated:               TRUE
768 };
769
770
771 /* USB layer driver interface implementation */
772
773 static void mts_usb_disconnect (struct usb_device *dev, void *ptr)
774 {
775         struct mts_desc* to_remove = (struct mts_desc*)ptr;
776
777         MTS_DEBUG_GOT_HERE();
778
779         /* leave the list - lock it */
780         down(&mts_list_semaphore);
781
782         mts_remove_nolock(to_remove);
783
784         up(&mts_list_semaphore);
785 }
786
787 struct vendor_product
788 {
789         char* name;
790         enum
791         {
792                 mts_sup_unknown=0,
793                 mts_sup_alpha,
794                 mts_sup_full
795         }
796         support_status;
797 } ;
798
799
800 /* These are taken from the msmUSB.inf file on the Windows driver CD */
801 const static struct vendor_product mts_supported_products[] =
802 {
803         { "Phantom 336CX",      mts_sup_unknown},
804         { "Phantom 336CX",      mts_sup_unknown},
805         { "Scanmaker X6",       mts_sup_alpha},
806         { "Phantom C6",         mts_sup_unknown},
807         { "Phantom 336CX",      mts_sup_unknown},
808         { "ScanMaker V6USL",    mts_sup_unknown},
809         { "ScanMaker V6USL",    mts_sup_unknown},
810         { "Scanmaker V6UL",     mts_sup_unknown},
811         { "Scanmaker V6UPL",    mts_sup_alpha},
812 };
813
814 /* The entries of microtek_table must correspond, line-by-line to
815    the entries of mts_supported_products[]. */
816
817 static struct usb_device_id mts_usb_ids [] =
818 {
819         { USB_DEVICE(0x4ce, 0x0300) },
820         { USB_DEVICE(0x5da, 0x0094) },
821         { USB_DEVICE(0x5da, 0x0099) },
822         { USB_DEVICE(0x5da, 0x009a) },
823         { USB_DEVICE(0x5da, 0x00a0) },
824         { USB_DEVICE(0x5da, 0x00a3) },
825         { USB_DEVICE(0x5da, 0x80a3) },
826         { USB_DEVICE(0x5da, 0x80ac) },
827         { USB_DEVICE(0x5da, 0x00b6) },
828         { }                                             /* Terminating entry */
829 };
830
831 MODULE_DEVICE_TABLE (usb, mts_usb_ids);
832
833
834 static void * mts_usb_probe (struct usb_device *dev, unsigned int interface,
835                              const struct usb_device_id *id)
836 {
837         int i;
838         int result;
839         int ep_out = -1;
840         int ep_in_set[3]; /* this will break if we have more than three endpoints
841                            which is why we check */
842         int *ep_in_current = ep_in_set;
843
844         struct mts_desc * new_desc;
845         struct vendor_product const* p;
846
847         /* the altsettting 0 on the interface we're probing */
848         struct usb_interface_descriptor *altsetting;
849
850         MTS_DEBUG_GOT_HERE();
851         MTS_DEBUG( "usb-device descriptor at %x\n", (int)dev );
852
853         MTS_DEBUG( "product id = 0x%x, vendor id = 0x%x\n",
854                    (int)dev->descriptor.idProduct,
855                    (int)dev->descriptor.idVendor );
856
857         MTS_DEBUG_GOT_HERE();
858
859         p = &mts_supported_products[id - mts_usb_ids];
860
861         MTS_DEBUG_GOT_HERE();
862
863         MTS_DEBUG( "found model %s\n", p->name );
864         if ( p->support_status != mts_sup_full )
865                 MTS_MESSAGE( "model %s is not known to be fully supported, reports welcome!\n",
866                              p->name );
867
868         /* the altsettting 0 on the interface we're probing */
869         altsetting =
870                 &(dev->actconfig->interface[interface].altsetting[0]);
871
872
873         /* Check if the config is sane */
874
875         if ( altsetting->bNumEndpoints != MTS_EP_TOTAL ) {
876                 MTS_WARNING( "expecting %d got %d endpoints! Bailing out.\n",
877                              (int)MTS_EP_TOTAL, (int)altsetting->bNumEndpoints );
878                 return NULL;
879         }
880
881         for( i = 0; i < altsetting->bNumEndpoints; i++ ) {
882                 if ((altsetting->endpoint[i].bmAttributes &
883                      USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_BULK) {
884
885                         MTS_WARNING( "can only deal with bulk endpoints; endpoint %d is not bulk.\n",
886                              (int)altsetting->endpoint[i].bEndpointAddress );
887                 } else {
888                         if (altsetting->endpoint[i].bEndpointAddress &
889                             USB_DIR_IN)
890                                 *ep_in_current++
891                                         = altsetting->endpoint[i].bEndpointAddress &
892                                         USB_ENDPOINT_NUMBER_MASK;
893                         else {
894                                 if ( ep_out != -1 ) {
895                                         MTS_WARNING( "can only deal with one output endpoints. Bailing out." );
896                                         return NULL;
897                                 }
898
899                                 ep_out = altsetting->endpoint[i].bEndpointAddress &
900                                         USB_ENDPOINT_NUMBER_MASK;
901                         }
902                 }
903
904         }
905
906
907         if ( ep_out == -1 ) {
908                 MTS_WARNING( "couldn't find an output bulk endpoint. Bailing out.\n" );
909                 return NULL;
910         }
911
912
913         /* I don't understand the following fully (it's from usb-storage) -- John */
914
915         /* set the interface -- STALL is an acceptable response here */
916         result = usb_set_interface(dev, altsetting->bInterfaceNumber, 0);
917
918         MTS_DEBUG("usb_set_interface returned %d.\n",result);
919         switch( result )
920         {
921         case 0: /* no error */
922                 break;
923                 
924         case -EPIPE:
925                 usb_clear_halt(dev, usb_sndctrlpipe(dev, 0));
926                 MTS_DEBUG( "clearing clearing stall on control interface\n" );
927                 break;
928                 
929         default:
930                 MTS_DEBUG( "unknown error %d from usb_set_interface\n",
931                         (int)result );
932                 return NULL;
933         }
934         
935         
936         /* allocating a new descriptor */
937         new_desc = (struct mts_desc *)kmalloc(sizeof(struct mts_desc), GFP_KERNEL);
938         if (new_desc == NULL)
939         {
940                 MTS_ERROR("couldn't allocate scanner desc, bailing out!\n");
941                 return NULL;
942         }
943
944         /* As done by usb_alloc_urb */
945         memset( new_desc, 0, sizeof(*new_desc) );
946         spin_lock_init(&new_desc->urb.lock);
947         
948                 
949         /* initialising that descriptor */
950         new_desc->usb_dev = dev;
951         new_desc->interface = interface;
952
953         init_MUTEX(&new_desc->lock);
954
955         if(mts_list){
956                 new_desc->host_number = mts_list->host_number+1;
957         } else {
958                 new_desc->host_number = 0;
959         }
960         
961         /* endpoints */
962         
963         new_desc->ep_out = ep_out;
964         new_desc->ep_response = ep_in_set[0];
965         new_desc->ep_image = ep_in_set[1];
966
967
968         if ( new_desc->ep_out != MTS_EP_OUT )
969                 MTS_WARNING( "will this work? Command EP is not usually %d\n",
970                              (int)new_desc->ep_out );
971
972         if ( new_desc->ep_response != MTS_EP_RESPONSE )
973                 MTS_WARNING( "will this work? Response EP is not usually %d\n",
974                              (int)new_desc->ep_response );
975
976         if ( new_desc->ep_image != MTS_EP_IMAGE )
977                 MTS_WARNING( "will this work? Image data EP is not usually %d\n",
978                              (int)new_desc->ep_image );
979
980
981         /* Initialize the host template based on the default one */
982         memcpy(&(new_desc->ctempl), &mts_scsi_host_template, sizeof(mts_scsi_host_template));
983         /* HACK from usb-storage - this is needed for scsi detection */
984         (struct mts_desc *)new_desc->ctempl.proc_dir = new_desc; /* FIXME */
985
986         MTS_DEBUG("registering SCSI module\n");
987
988         new_desc->ctempl.module = THIS_MODULE;
989         result = scsi_register_module(MODULE_SCSI_HA, &(new_desc->ctempl));
990         /* Will get hit back in microtek_detect by this func */
991         if ( result )
992         {
993                 MTS_ERROR( "error %d from scsi_register_module! Help!\n",
994                            (int)result );
995
996                 /* FIXME: need more cleanup? */
997                 kfree( new_desc );
998                 return NULL;
999         }
1000         MTS_DEBUG_GOT_HERE();
1001
1002         /* FIXME: the bomb is armed, must the host be registered under lock ? */
1003         /* join the list - lock it */
1004         down(&mts_list_semaphore);
1005
1006         mts_add_nolock( new_desc );
1007
1008         up(&mts_list_semaphore);
1009
1010
1011         MTS_DEBUG("completed probe and exiting happily\n");
1012
1013         return (void *)new_desc;
1014 }
1015
1016
1017
1018 /* get us noticed by the rest of the kernel */
1019
1020 int __init microtek_drv_init(void)
1021 {
1022         int result;
1023
1024         MTS_DEBUG_GOT_HERE();
1025         init_MUTEX(&mts_list_semaphore);
1026
1027         if ((result = usb_register(&mts_usb_driver)) < 0) {
1028                 MTS_DEBUG("usb_register returned %d\n", result );
1029                 return -1;
1030         } else {
1031                 MTS_DEBUG("driver registered.\n");
1032         }
1033
1034         info(DRIVER_VERSION ":" DRIVER_DESC);
1035
1036         return 0;
1037 }
1038
1039 void __exit microtek_drv_exit(void)
1040 {
1041         struct mts_desc* next;
1042
1043         MTS_DEBUG_GOT_HERE();
1044
1045         usb_deregister(&mts_usb_driver);
1046
1047         down(&mts_list_semaphore);
1048
1049         while (mts_list) {
1050                 /* keep track of where the next one is */
1051                 next = mts_list->next;
1052
1053                 mts_remove_nolock( mts_list );
1054
1055                 /* advance the list pointer */
1056                 mts_list = next;
1057         }
1058
1059         up(&mts_list_semaphore);
1060 }
1061
1062 module_init(microtek_drv_init);
1063 module_exit(microtek_drv_exit);
1064
1065 MODULE_AUTHOR( DRIVER_AUTHOR );
1066 MODULE_DESCRIPTION( DRIVER_DESC );
1067 MODULE_LICENSE("GPL");
1068