v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / drivers / usb / storage / jumpshot.c
1 /* Driver for Lexar "Jumpshot" Compact Flash reader
2  *
3  * jumpshot driver v0.1:
4  *
5  * First release
6  *
7  * Current development and maintenance by:
8  *   (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org)
9  *   many thanks to Robert Baruch for the SanDisk SmartMedia reader driver
10  *   which I used as a template for this driver.
11  *   Some bugfixes and scatter-gather code by Gregory P. Smith 
12  *   (greg-usb@electricrain.com)
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, or (at your option) any
17  * 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
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License along
25  * with this program; if not, write to the Free Software Foundation, Inc.,
26  * 675 Mass Ave, Cambridge, MA 02139, USA.
27  */
28  
29  /*
30   * This driver attempts to support the Lexar Jumpshot USB CompactFlash 
31   * reader.  Like many other USB CompactFlash readers, the Jumpshot contains
32   * a USB-to-ATA chip. 
33   *
34   * This driver supports reading and writing.  If you're truly paranoid,
35   * however, you can force the driver into a write-protected state by setting
36   * the WP enable bits in jumpshot_handle_mode_sense.  Basically this means
37   * setting mode_param_header[3] = 0x80.  
38   */
39
40 #include "transport.h"
41 #include "protocol.h"
42 #include "usb.h"
43 #include "debug.h"
44 #include "jumpshot.h"
45
46 #include <linux/sched.h>
47 #include <linux/errno.h>
48 #include <linux/slab.h>
49
50 extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
51                                 u8 request, u8 requesttype, u16 value,
52                                 u16 index, void *data, u16 size);
53 extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
54                              unsigned int len, unsigned int *act_len);
55
56 #if 0
57 static void jumpshot_dump_data(unsigned char *data, int len)
58 {
59         unsigned char buf[80];
60         int sofar = 0;
61
62         if (!data)
63                 return;
64
65         memset(buf, 0, sizeof(buf));
66
67         for (sofar = 0; sofar < len; sofar++) {
68                 sprintf(buf + strlen(buf), "%02x ",
69                         ((unsigned int) data[sofar]) & 0xFF);
70
71                 if (sofar % 16 == 15) {
72                         US_DEBUGP("jumpshot:  %s\n", buf);
73                         memset(buf, 0, sizeof(buf));
74                 }
75         }
76
77         if (strlen(buf) != 0)
78                 US_DEBUGP("jumpshot:  %s\n", buf);
79 }
80 #endif
81
82 /*
83  * Send a control message and wait for the response.
84  *
85  * us - the pointer to the us_data structure for the device to use
86  *
87  * request - the URB Setup Packet's first 6 bytes. The first byte always
88  *  corresponds to the request type, and the second byte always corresponds
89  *  to the request.  The other 4 bytes do not correspond to value and index,
90  *  since they are used in a custom way by the SCM protocol.
91  *
92  * xfer_data - a buffer from which to get, or to which to store, any data
93  *  that gets send or received, respectively, with the URB. Even though
94  *  it looks like we allocate a buffer in this code for the data, xfer_data
95  *  must contain enough allocated space.
96  *
97  * xfer_len - the number of bytes to send or receive with the URB.
98  *
99  * This routine snarfed from the SanDisk SDDR-09 driver
100  *
101  */
102 static int jumpshot_send_control(struct us_data  *us,
103                                  int pipe,
104                                  unsigned char request,
105                                  unsigned char requesttype,
106                                  unsigned short value,
107                                  unsigned short index,
108                                  unsigned char *xfer_data,
109                                  unsigned int xfer_len)
110 {
111         int result;
112
113         // Send the URB to the device and wait for a response.
114
115         /* Why are request and request type reversed in this call? */
116
117         result = usb_stor_control_msg(us, pipe,
118                                       request, requesttype,
119                                       value, index, xfer_data, xfer_len);
120
121         // Check the return code for the command.
122
123         if (result < 0) {
124                 /* if the command was aborted, indicate that */
125                 if (result == -ENOENT)
126                         return USB_STOR_TRANSPORT_ABORTED;
127
128                 /* a stall is a fatal condition from the device */
129                 if (result == -EPIPE) {
130                         US_DEBUGP("jumpshot_send_control:  -- Stall on control pipe. Clearing\n");
131                         result = usb_clear_halt(us->pusb_dev, pipe);
132                         US_DEBUGP("jumpshot_send_control:  -- usb_clear_halt() returns %d\n", result);
133                         return USB_STOR_TRANSPORT_FAILED;
134                 }
135
136                 /* Uh oh... serious problem here */
137                 return USB_STOR_TRANSPORT_ERROR;
138         }
139
140         return USB_STOR_TRANSPORT_GOOD;
141 }
142
143
144 static int jumpshot_raw_bulk(int direction,
145                              struct us_data *us,
146                              unsigned char *data, 
147                              unsigned int len)
148 {
149         int result;
150         int act_len;
151         int pipe;
152
153         if (direction == SCSI_DATA_READ)
154                 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
155         else
156                 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
157
158         result = usb_stor_bulk_msg(us, data, pipe, len, &act_len);
159
160         // if we stall, we need to clear it before we go on
161         if (result == -EPIPE) {
162                 US_DEBUGP("jumpshot_raw_bulk:  EPIPE. clearing endpoint halt for"
163                           " pipe 0x%x, stalled at %d bytes\n", pipe, act_len);
164                 usb_clear_halt(us->pusb_dev, pipe);
165         }
166
167         if (result) {
168                 // NAK - that means we've retried a few times already
169                 if (result == -ETIMEDOUT) {
170                         US_DEBUGP("jumpshot_raw_bulk:  device NAKed\n");
171                         return US_BULK_TRANSFER_FAILED;
172                 }
173
174                 // -ENOENT -- we canceled this transfer
175                 if (result == -ENOENT) {
176                         US_DEBUGP("jumpshot_raw_bulk:  transfer aborted\n");
177                         return US_BULK_TRANSFER_ABORTED;
178                 }
179
180                 if (result == -EPIPE) {
181                         US_DEBUGP("jumpshot_raw_bulk:  output pipe stalled\n");
182                         return USB_STOR_TRANSPORT_FAILED;
183                 }
184
185                 // the catch-all case
186                 US_DEBUGP("jumpshot_raw_bulk:  unknown error\n");
187                 return US_BULK_TRANSFER_FAILED;
188         }
189
190         if (act_len != len) {
191                 US_DEBUGP("jumpshot_raw_bulk:  Warning. Transferred only %d bytes\n", act_len);
192                 return US_BULK_TRANSFER_SHORT;
193         }
194
195         US_DEBUGP("jumpshot_raw_bulk:  Transfered %d of %d bytes\n", act_len, len);
196         return US_BULK_TRANSFER_GOOD;
197 }
198
199 static inline int jumpshot_bulk_read(struct us_data *us,
200                                      unsigned char *data, 
201                                      unsigned int len)
202 {
203         if (len == 0)
204                 return USB_STOR_TRANSPORT_GOOD;
205
206         US_DEBUGP("jumpshot_bulk_read:  len = %d\n", len);
207         return jumpshot_raw_bulk(SCSI_DATA_READ, us, data, len);
208 }
209
210
211 static inline int jumpshot_bulk_write(struct us_data *us,
212                                       unsigned char *data, 
213                                       unsigned int len)
214 {
215         if (len == 0)
216                 return USB_STOR_TRANSPORT_GOOD;
217
218         US_DEBUGP("jumpshot_bulk_write:  len = %d\n", len);
219         return jumpshot_raw_bulk(SCSI_DATA_WRITE, us, data, len);
220 }
221
222
223 static int jumpshot_get_status(struct us_data  *us)
224 {
225         unsigned char reply;
226         int rc;
227
228         if (!us)
229                 return USB_STOR_TRANSPORT_ERROR;
230
231         // send the setup
232         rc = jumpshot_send_control(us,
233                                    usb_rcvctrlpipe(us->pusb_dev, 0),
234                                    0, 0xA0, 0, 7, &reply, 1);
235
236         if (rc != USB_STOR_TRANSPORT_GOOD)
237                 return rc;
238
239         if (reply != 0x50) {
240                 US_DEBUGP("jumpshot_get_status:  0x%2x\n",
241                           (unsigned short) (reply));
242                 return USB_STOR_TRANSPORT_ERROR;
243         }
244
245         return USB_STOR_TRANSPORT_GOOD;
246 }
247
248 static int jumpshot_read_data(struct us_data *us,
249                               struct jumpshot_info *info,
250                               u32 sector,
251                               u32 sectors, 
252                               unsigned char *dest, 
253                               int use_sg)
254 {
255         unsigned char command[] = { 0, 0, 0, 0, 0, 0xe0, 0x20 };
256         unsigned char *buffer = NULL;
257         unsigned char *ptr;
258         unsigned char  thistime;
259         struct scatterlist *sg = NULL;
260         int totallen, len, result;
261         int sg_idx = 0, current_sg_offset = 0;
262         int transferred;
263
264         // we're working in LBA mode.  according to the ATA spec, 
265         // we can support up to 28-bit addressing.  I don't know if Jumpshot
266         // supports beyond 24-bit addressing.  It's kind of hard to test 
267         // since it requires > 8GB CF card.
268         //
269         if (sector > 0x0FFFFFFF)
270                 return USB_STOR_TRANSPORT_ERROR;
271
272         // If we're using scatter-gather, we have to create a new
273         // buffer to read all of the data in first, since a
274         // scatter-gather buffer could in theory start in the middle
275         // of a page, which would be bad. A developer who wants a
276         // challenge might want to write a limited-buffer
277         // version of this code.
278
279         totallen = sectors * info->ssize;
280
281         do {
282                // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
283                 len = min_t(int, totallen, 65536);
284
285                 if (use_sg) {
286                         sg = (struct scatterlist *) dest;
287                         buffer = kmalloc(len, GFP_KERNEL);
288                         if (buffer == NULL)
289                                 return USB_STOR_TRANSPORT_ERROR;
290                         ptr = buffer;
291                 } else {
292                         ptr = dest;
293                 }
294
295                 thistime = (len / info->ssize) & 0xff;
296
297                 command[0] = 0;
298                 command[1] = thistime;
299                 command[2] = sector & 0xFF;
300                 command[3] = (sector >>  8) & 0xFF;
301                 command[4] = (sector >> 16) & 0xFF;
302
303                 command[5] |= (sector >> 24) & 0x0F;
304
305                 // send the setup + command
306                 result = jumpshot_send_control(us,
307                                                usb_sndctrlpipe(us->pusb_dev, 0),
308                                                0, 0x20, 0, 1, command, 7);
309                 if (result != USB_STOR_TRANSPORT_GOOD) {
310                         if (use_sg)
311                                 kfree(buffer);
312                         return result;
313                 }
314
315                 // read the result
316                 result = jumpshot_bulk_read(us, ptr, len);
317                 if (result != USB_STOR_TRANSPORT_GOOD) {
318                         if (use_sg)
319                                 kfree(buffer);
320                         return result;
321                 }
322
323                 US_DEBUGP("jumpshot_read_data:  %d bytes\n", len);
324                 //jumpshot_dump_data(ptr, len);
325         
326                 sectors -= thistime;
327                 sector  += thistime;
328
329                 if (use_sg) {
330                         transferred = 0;
331                         while (sg_idx < use_sg && transferred < len) {
332                                 if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
333                                         US_DEBUGP("jumpshot_read_data:  adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
334                                         memcpy(sg[sg_idx].address + current_sg_offset,
335                                                buffer + transferred,
336                                                sg[sg_idx].length - current_sg_offset);
337                                         transferred += sg[sg_idx].length - current_sg_offset;
338                                         current_sg_offset = 0;
339                                         // on to the next sg buffer
340                                         ++sg_idx;
341                                 } else {
342                                         US_DEBUGP("jumpshot_read_data:  adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
343                                         memcpy(sg[sg_idx].address + current_sg_offset,
344                                                buffer + transferred,
345                                                len - transferred);
346                                         current_sg_offset += len - transferred;
347                                         // this sg buffer is only partially full and we're out of data to copy in
348                                         break;
349                                 }
350                         }
351                         kfree(buffer);
352                 } else {
353                         dest += len;
354                 }
355
356                 totallen -= len;
357         } while (totallen > 0);
358
359         return USB_STOR_TRANSPORT_GOOD;
360 }
361
362
363 static int jumpshot_write_data(struct us_data *us,
364                                struct jumpshot_info *info,
365                                u32 sector,
366                                u32 sectors, 
367                                unsigned char *src, 
368                                int use_sg)
369 {
370         unsigned char command[7] = { 0, 0, 0, 0, 0, 0xE0, 0x30 };
371         unsigned char *buffer = NULL;
372         unsigned char *ptr;
373         unsigned char  thistime;
374         struct scatterlist *sg = NULL;
375         int totallen, len, result, waitcount;
376         int sg_idx = 0, current_sg_offset = 0;
377         int transferred;
378
379         // we're working in LBA mode.  according to the ATA spec, 
380         // we can support up to 28-bit addressing.  I don't know if Jumpshot
381         // supports beyond 24-bit addressing.  It's kind of hard to test 
382         // since it requires > 8GB CF card.
383         //
384         if (sector > 0x0FFFFFFF)
385                 return USB_STOR_TRANSPORT_ERROR;
386
387         // If we're using scatter-gather, we have to create a new
388         // buffer to read all of the data in first, since a
389         // scatter-gather buffer could in theory start in the middle
390         // of a page, which would be bad. A developer who wants a
391         // challenge might want to write a limited-buffer
392         // version of this code.
393
394         totallen = sectors * info->ssize;
395
396         do {
397                 // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit)
398                 len = min_t(int, totallen, 65536);
399
400                 if (use_sg) {
401                         sg = (struct scatterlist *) src;
402                         buffer = kmalloc(len, GFP_KERNEL);
403                         if (buffer == NULL)
404                                 return USB_STOR_TRANSPORT_ERROR;
405                         ptr = buffer;
406
407                         memset(buffer, 0, len);
408
409                         // copy the data from the sg bufs into the big contiguous buf
410                         //
411                         transferred = 0;
412                         while (transferred < len) {
413                                 if (len - transferred >= sg[sg_idx].length - current_sg_offset) {
414                                         US_DEBUGP("jumpshot_write_data:  getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length);
415                                         memcpy(ptr + transferred,
416                                                sg[sg_idx].address + current_sg_offset,
417                                                sg[sg_idx].length - current_sg_offset);
418                                         transferred += sg[sg_idx].length - current_sg_offset;
419                                         current_sg_offset = 0;
420                                         // on to the next sg buffer
421                                         ++sg_idx;
422                                 } else {
423                                         US_DEBUGP("jumpshot_write_data:  getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length);
424                                         memcpy(ptr + transferred,
425                                                sg[sg_idx].address + current_sg_offset,
426                                                len - transferred);
427                                         current_sg_offset += len - transferred;
428                                         // we only copied part of this sg buffer
429                                         break;
430                                 }
431                         }
432                 } else {
433                         ptr = src;
434                 }
435
436                 thistime = (len / info->ssize) & 0xff;
437
438                 command[0] = 0;
439                 command[1] = thistime;
440                 command[2] = sector & 0xFF;
441                 command[3] = (sector >>  8) & 0xFF;
442                 command[4] = (sector >> 16) & 0xFF;
443
444                 command[5] |= (sector >> 24) & 0x0F;
445
446                 // send the setup + command
447                 result = jumpshot_send_control(us,
448                                                usb_sndctrlpipe(us->pusb_dev, 0),
449                                                0, 0x20, 0, 1, command, 7);
450
451                 // send the data
452                 result = jumpshot_bulk_write(us, ptr, len);
453                 if (result != USB_STOR_TRANSPORT_GOOD) {
454                         if (use_sg)
455                                 kfree(buffer);
456                         return result;
457                 }
458
459                 // read the result.  apparently the bulk write can complete before the
460                 // jumpshot drive is finished writing.  so we loop here until we
461                 // get a good return code
462                 waitcount = 0;
463                 do {
464                         result = jumpshot_get_status(us);
465                         if (result != USB_STOR_TRANSPORT_GOOD) {
466                                 // I have not experimented to find the smallest value.
467                                 //
468                                 wait_ms(50); 
469                         }
470                 } while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10));
471
472                 if (result != USB_STOR_TRANSPORT_GOOD)
473                         US_DEBUGP("jumpshot_write_data:  Gah!  Waitcount = 10.  Bad write!?\n");
474                 
475                 sectors -= thistime;
476                 sector  += thistime;
477
478                 if (use_sg) {
479                         kfree(buffer);
480                 } else {
481                         src += len;
482                 }
483
484                 totallen -= len;
485         } while (totallen > 0);
486
487         return result;
488 }
489
490 static int jumpshot_id_device(struct us_data *us,
491                               struct jumpshot_info *info)
492 {
493         unsigned char command[2] = { 0xe0, 0xec };
494         unsigned char reply[512];
495         int      rc;
496
497         if (!us || !info)
498                 return USB_STOR_TRANSPORT_ERROR;
499
500         // send the setup
501         rc = jumpshot_send_control(us,
502                                    usb_sndctrlpipe(us->pusb_dev, 0),
503                                    0, 0x20, 0, 6, command, 2);
504
505         if (rc != USB_STOR_TRANSPORT_GOOD) {
506                 US_DEBUGP("jumpshot_id_device:  Gah! send_control for read_capacity failed\n");
507                 return rc;
508         }
509
510         // read the reply
511         rc = jumpshot_bulk_read(us, reply, sizeof(reply));
512         if (rc != USB_STOR_TRANSPORT_GOOD)
513                 return rc;
514
515         info->sectors = ((u32)(reply[117]) << 24) |
516                         ((u32)(reply[116]) << 16) |
517                         ((u32)(reply[115]) <<  8) |
518                         ((u32)(reply[114])      );
519
520         return USB_STOR_TRANSPORT_GOOD;
521 }
522
523 static int jumpshot_handle_mode_sense(struct us_data *us,
524                                       Scsi_Cmnd * srb, 
525                                       unsigned char *ptr,
526                                       int sense_6)
527 {
528         unsigned char mode_param_header[8] = {
529                 0, 0, 0, 0, 0, 0, 0, 0
530         };
531         unsigned char rw_err_page[12] = {
532                 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0
533         };
534         unsigned char cache_page[12] = {
535                 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0
536         };
537         unsigned char rbac_page[12] = {
538                 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0
539         };
540         unsigned char timer_page[8] = {
541                 0x1C, 0x6, 0, 0, 0, 0
542         };
543         unsigned char pc, page_code;
544         unsigned short total_len = 0;
545         unsigned short param_len, i = 0;
546
547
548         if (sense_6)
549                 param_len = srb->cmnd[4];
550         else
551                 param_len = ((u32) (srb->cmnd[7]) >> 8) | ((u32) (srb->cmnd[8]));
552
553
554         pc = srb->cmnd[2] >> 6;
555         page_code = srb->cmnd[2] & 0x3F;
556
557         switch (pc) {
558            case 0x0:
559                 US_DEBUGP("jumpshot_handle_mode_sense:  Current values\n");
560                 break;
561            case 0x1:
562                 US_DEBUGP("jumpshot_handle_mode_sense:  Changeable values\n");
563                 break;
564            case 0x2:
565                 US_DEBUGP("jumpshot_handle_mode_sense:  Default values\n");
566                 break;
567            case 0x3:
568                 US_DEBUGP("jumpshot_handle_mode_sense:  Saves values\n");
569                 break;
570         }
571
572         mode_param_header[3] = 0x80;    // write enable
573
574         switch (page_code) {
575            case 0x0:
576                 // vendor-specific mode
577                 return USB_STOR_TRANSPORT_ERROR;
578
579            case 0x1:
580                 total_len = sizeof(rw_err_page);
581                 mode_param_header[0] = total_len >> 8;
582                 mode_param_header[1] = total_len & 0xFF;
583                 mode_param_header[3] = 0x00;    // WP enable: 0x80
584
585                 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
586                 i += sizeof(mode_param_header);
587                 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
588                 break;
589
590            case 0x8:
591                 total_len = sizeof(cache_page);
592                 mode_param_header[0] = total_len >> 8;
593                 mode_param_header[1] = total_len & 0xFF;
594                 mode_param_header[3] = 0x00;    // WP enable: 0x80
595
596                 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
597                 i += sizeof(mode_param_header);
598                 memcpy(ptr + i, cache_page, sizeof(cache_page));
599                 break;
600
601            case 0x1B:
602                 total_len = sizeof(rbac_page);
603                 mode_param_header[0] = total_len >> 8;
604                 mode_param_header[1] = total_len & 0xFF;
605                 mode_param_header[3] = 0x00;    // WP enable: 0x80
606
607                 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
608                 i += sizeof(mode_param_header);
609                 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
610                 break;
611
612            case 0x1C:
613                 total_len = sizeof(timer_page);
614                 mode_param_header[0] = total_len >> 8;
615                 mode_param_header[1] = total_len & 0xFF;
616                 mode_param_header[3] = 0x00;    // WP enable: 0x80
617
618                 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
619                 i += sizeof(mode_param_header);
620                 memcpy(ptr + i, timer_page, sizeof(timer_page));
621                 break;
622
623            case 0x3F:
624                 total_len = sizeof(timer_page) + sizeof(rbac_page) +
625                     sizeof(cache_page) + sizeof(rw_err_page);
626                 mode_param_header[0] = total_len >> 8;
627                 mode_param_header[1] = total_len & 0xFF;
628                 mode_param_header[3] = 0x00;    // WP enable: 0x80
629
630                 memcpy(ptr, mode_param_header, sizeof(mode_param_header));
631                 i += sizeof(mode_param_header);
632                 memcpy(ptr + i, timer_page, sizeof(timer_page));
633                 i += sizeof(timer_page);
634                 memcpy(ptr + i, rbac_page, sizeof(rbac_page));
635                 i += sizeof(rbac_page);
636                 memcpy(ptr + i, cache_page, sizeof(cache_page));
637                 i += sizeof(cache_page);
638                 memcpy(ptr + i, rw_err_page, sizeof(rw_err_page));
639                 break;
640         }
641
642         return USB_STOR_TRANSPORT_GOOD;
643 }
644
645
646 void jumpshot_info_destructor(void *extra)
647 {
648         // this routine is a placeholder...
649         // currently, we don't allocate any extra blocks so we're okay
650 }
651
652
653
654 // Transport for the Lexar 'Jumpshot'
655 //
656 int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us)
657 {
658         struct jumpshot_info *info;
659         int rc;
660         unsigned long block, blocks;
661         unsigned char *ptr = NULL;
662         unsigned char inquiry_response[36] = {
663                 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
664         };
665
666
667         if (!us->extra) {
668                 us->extra = kmalloc(sizeof(struct jumpshot_info), GFP_KERNEL);
669                 if (!us->extra) {
670                         US_DEBUGP("jumpshot_transport:  Gah! Can't allocate storage for jumpshot info struct!\n");
671                         return USB_STOR_TRANSPORT_ERROR;
672                 }
673                 memset(us->extra, 0, sizeof(struct jumpshot_info));
674                 us->extra_destructor = jumpshot_info_destructor;
675         }
676
677         info = (struct jumpshot_info *) (us->extra);
678         ptr = (unsigned char *) srb->request_buffer;
679
680         if (srb->cmnd[0] == INQUIRY) {
681                 US_DEBUGP("jumpshot_transport:  INQUIRY.  Returning bogus response.\n");
682                 memset(inquiry_response + 8, 0, 28);
683                 fill_inquiry_response(us, inquiry_response, 36);
684                 return USB_STOR_TRANSPORT_GOOD;
685         }
686
687         if (srb->cmnd[0] == READ_CAPACITY) {
688                 info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
689
690                 rc = jumpshot_get_status(us);
691                 if (rc != USB_STOR_TRANSPORT_GOOD)
692                         return rc;
693
694                 rc = jumpshot_id_device(us, info);
695                 if (rc != USB_STOR_TRANSPORT_GOOD)
696                         return rc;
697
698                 US_DEBUGP("jumpshot_transport:  READ_CAPACITY:  %ld sectors, %ld bytes per sector\n",
699                           info->sectors, info->ssize);
700
701                 // build the reply
702                 //
703                 ptr[0] = (info->sectors >> 24) & 0xFF;
704                 ptr[1] = (info->sectors >> 16) & 0xFF;
705                 ptr[2] = (info->sectors >> 8) & 0xFF;
706                 ptr[3] = (info->sectors) & 0xFF;
707
708                 ptr[4] = (info->ssize >> 24) & 0xFF;
709                 ptr[5] = (info->ssize >> 16) & 0xFF;
710                 ptr[6] = (info->ssize >> 8) & 0xFF;
711                 ptr[7] = (info->ssize) & 0xFF;
712
713                 return USB_STOR_TRANSPORT_GOOD;
714         }
715
716         if (srb->cmnd[0] == MODE_SELECT_10) {
717                 US_DEBUGP("jumpshot_transport:  Gah! MODE_SELECT_10.\n");
718                 return USB_STOR_TRANSPORT_ERROR;
719         }
720
721         if (srb->cmnd[0] == READ_10) {
722                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
723                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
724
725                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
726
727                 US_DEBUGP("jumpshot_transport:  READ_10: read block 0x%04lx  count %ld\n", block, blocks);
728                 return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg);
729         }
730
731         if (srb->cmnd[0] == READ_12) {
732                 // I don't think we'll ever see a READ_12 but support it anyway...
733                 //
734                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
735                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
736
737                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
738                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
739
740                 US_DEBUGP("jumpshot_transport:  READ_12: read block 0x%04lx  count %ld\n", block, blocks);
741                 return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg);
742         }
743
744         if (srb->cmnd[0] == WRITE_10) {
745                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
746                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
747
748                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
749
750                 US_DEBUGP("jumpshot_transport:  WRITE_10: write block 0x%04lx  count %ld\n", block, blocks);
751                 return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg);
752         }
753
754         if (srb->cmnd[0] == WRITE_12) {
755                 // I don't think we'll ever see a WRITE_12 but support it anyway...
756                 //
757                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
758                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
759
760                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
761                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
762
763                 US_DEBUGP("jumpshot_transport:  WRITE_12: write block 0x%04lx  count %ld\n", block, blocks);
764                 return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg);
765         }
766
767
768         if (srb->cmnd[0] == TEST_UNIT_READY) {
769                 US_DEBUGP("jumpshot_transport:  TEST_UNIT_READY.\n");
770                 return jumpshot_get_status(us);
771         }
772
773         if (srb->cmnd[0] == REQUEST_SENSE) {
774                 US_DEBUGP("jumpshot_transport:  REQUEST_SENSE.  Returning NO SENSE for now\n");
775
776                 ptr[0] = 0xF0;
777                 ptr[2] = info->sense_key;
778                 ptr[7] = 11;
779                 ptr[12] = info->sense_asc;
780                 ptr[13] = info->sense_ascq;
781
782                 return USB_STOR_TRANSPORT_GOOD;
783         }
784
785         if (srb->cmnd[0] == MODE_SENSE) {
786                 US_DEBUGP("jumpshot_transport:  MODE_SENSE_6 detected\n");
787                 return jumpshot_handle_mode_sense(us, srb, ptr, TRUE);
788         }
789
790         if (srb->cmnd[0] == MODE_SENSE_10) {
791                 US_DEBUGP("jumpshot_transport:  MODE_SENSE_10 detected\n");
792                 return jumpshot_handle_mode_sense(us, srb, ptr, FALSE);
793         }
794         
795         if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
796                 // sure.  whatever.  not like we can stop the user from popping
797                 // the media out of the device (no locking doors, etc)
798                 //
799                 return USB_STOR_TRANSPORT_GOOD;
800         }
801
802         US_DEBUGP("jumpshot_transport:  Gah! Unknown command: %d (0x%x)\n", srb->cmnd[0], srb->cmnd[0]);
803         return USB_STOR_TRANSPORT_ERROR;
804 }