1 /* Driver for SanDisk SDDR-55 SmartMedia reader
7 * Current development and maintenance by:
8 * (c) 2002 Simon Munton
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2, or (at your option) any
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/jiffies.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_cmnd.h>
33 #include "transport.h"
39 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
40 #define LSB_of(s) ((s)&0xFF)
41 #define MSB_of(s) ((s)>>8)
44 #define set_sense_info(sk, asc, ascq) \
46 info->sense_data[2] = sk; \
47 info->sense_data[12] = asc; \
48 info->sense_data[13] = ascq; \
52 struct sddr55_card_info
{
53 unsigned long capacity
; /* Size of card in bytes */
54 int max_log_blks
; /* maximum number of logical blocks */
55 int pageshift
; /* log2 of pagesize */
56 int smallpageshift
; /* 1 if pagesize == 256 */
57 int blocksize
; /* Size of block in pages */
58 int blockshift
; /* log2 of blocksize */
59 int blockmask
; /* 2^blockshift - 1 */
60 int read_only
; /* non zero if card is write protected */
61 int force_read_only
; /* non zero if we find a map error*/
62 int *lba_to_pba
; /* logical to physical map */
63 int *pba_to_lba
; /* physical to logical map */
64 int fatal_error
; /* set if we detect something nasty */
65 unsigned long last_access
; /* number of jiffies since we last talked to device */
66 unsigned char sense_data
[18];
70 #define NOT_ALLOCATED 0xffffffff
71 #define BAD_BLOCK 0xffff
72 #define CIS_BLOCK 0x400
73 #define UNUSED_BLOCK 0x3ff
76 sddr55_bulk_transport(struct us_data
*us
, int direction
,
77 unsigned char *data
, unsigned int len
) {
78 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)us
->extra
;
79 unsigned int pipe
= (direction
== DMA_FROM_DEVICE
) ?
80 us
->recv_bulk_pipe
: us
->send_bulk_pipe
;
83 return USB_STOR_XFER_GOOD
;
84 info
->last_access
= jiffies
;
85 return usb_stor_bulk_transfer_buf(us
, pipe
, data
, len
, NULL
);
88 /* check if card inserted, if there is, update read_only status
89 * return non zero if no card
92 static int sddr55_status(struct us_data
*us
)
95 unsigned char *command
= us
->iobuf
;
96 unsigned char *status
= us
->iobuf
;
97 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)us
->extra
;
100 memset(command
, 0, 8);
103 result
= sddr55_bulk_transport(us
,
104 DMA_TO_DEVICE
, command
, 8);
106 US_DEBUGP("Result for send_command in status %d\n",
109 if (result
!= USB_STOR_XFER_GOOD
) {
110 set_sense_info (4, 0, 0); /* hardware error */
111 return USB_STOR_TRANSPORT_ERROR
;
114 result
= sddr55_bulk_transport(us
,
115 DMA_FROM_DEVICE
, status
, 4);
117 /* expect to get short transfer if no card fitted */
118 if (result
== USB_STOR_XFER_SHORT
|| result
== USB_STOR_XFER_STALLED
) {
119 /* had a short transfer, no card inserted, free map memory */
120 kfree(info
->lba_to_pba
);
121 kfree(info
->pba_to_lba
);
122 info
->lba_to_pba
= NULL
;
123 info
->pba_to_lba
= NULL
;
125 info
->fatal_error
= 0;
126 info
->force_read_only
= 0;
128 set_sense_info (2, 0x3a, 0); /* not ready, medium not present */
129 return USB_STOR_TRANSPORT_FAILED
;
132 if (result
!= USB_STOR_XFER_GOOD
) {
133 set_sense_info (4, 0, 0); /* hardware error */
134 return USB_STOR_TRANSPORT_FAILED
;
137 /* check write protect status */
138 info
->read_only
= (status
[0] & 0x20);
140 /* now read status */
141 result
= sddr55_bulk_transport(us
,
142 DMA_FROM_DEVICE
, status
, 2);
144 if (result
!= USB_STOR_XFER_GOOD
) {
145 set_sense_info (4, 0, 0); /* hardware error */
148 return (result
== USB_STOR_XFER_GOOD
?
149 USB_STOR_TRANSPORT_GOOD
: USB_STOR_TRANSPORT_FAILED
);
153 static int sddr55_read_data(struct us_data
*us
,
156 unsigned short sectors
) {
158 int result
= USB_STOR_TRANSPORT_GOOD
;
159 unsigned char *command
= us
->iobuf
;
160 unsigned char *status
= us
->iobuf
;
161 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)us
->extra
;
162 unsigned char *buffer
;
165 unsigned long address
;
167 unsigned short pages
;
168 unsigned int len
, offset
;
169 struct scatterlist
*sg
;
171 // Since we only read in one block at a time, we have to create
172 // a bounce buffer and move the data a piece at a time between the
173 // bounce buffer and the actual transfer buffer.
175 len
= min((unsigned int) sectors
, (unsigned int) info
->blocksize
>>
176 info
->smallpageshift
) * PAGESIZE
;
177 buffer
= kmalloc(len
, GFP_NOIO
);
179 return USB_STOR_TRANSPORT_ERROR
; /* out of memory */
185 /* have we got to end? */
186 if (lba
>= info
->max_log_blks
)
189 pba
= info
->lba_to_pba
[lba
];
191 // Read as many sectors as possible in this block
193 pages
= min((unsigned int) sectors
<< info
->smallpageshift
,
194 info
->blocksize
- page
);
195 len
= pages
<< info
->pageshift
;
197 US_DEBUGP("Read %02X pages, from PBA %04X"
198 " (LBA %04X) page %02X\n",
199 pages
, pba
, lba
, page
);
201 if (pba
== NOT_ALLOCATED
) {
202 /* no pba for this lba, fill with zeroes */
203 memset (buffer
, 0, len
);
206 address
= (pba
<< info
->blockshift
) + page
;
209 command
[1] = LSB_of(address
>>16);
210 command
[2] = LSB_of(address
>>8);
211 command
[3] = LSB_of(address
);
215 command
[6] = LSB_of(pages
<< (1 - info
->smallpageshift
));
219 result
= sddr55_bulk_transport(us
,
220 DMA_TO_DEVICE
, command
, 8);
222 US_DEBUGP("Result for send_command in read_data %d\n",
225 if (result
!= USB_STOR_XFER_GOOD
) {
226 result
= USB_STOR_TRANSPORT_ERROR
;
231 result
= sddr55_bulk_transport(us
,
232 DMA_FROM_DEVICE
, buffer
, len
);
234 if (result
!= USB_STOR_XFER_GOOD
) {
235 result
= USB_STOR_TRANSPORT_ERROR
;
239 /* now read status */
240 result
= sddr55_bulk_transport(us
,
241 DMA_FROM_DEVICE
, status
, 2);
243 if (result
!= USB_STOR_XFER_GOOD
) {
244 result
= USB_STOR_TRANSPORT_ERROR
;
248 /* check status for error */
249 if (status
[0] == 0xff && status
[1] == 0x4) {
250 set_sense_info (3, 0x11, 0);
251 result
= USB_STOR_TRANSPORT_FAILED
;
256 // Store the data in the transfer buffer
257 usb_stor_access_xfer_buf(buffer
, len
, us
->srb
,
258 &sg
, &offset
, TO_XFER_BUF
);
262 sectors
-= pages
>> info
->smallpageshift
;
265 result
= USB_STOR_TRANSPORT_GOOD
;
273 static int sddr55_write_data(struct us_data
*us
,
276 unsigned short sectors
) {
278 int result
= USB_STOR_TRANSPORT_GOOD
;
279 unsigned char *command
= us
->iobuf
;
280 unsigned char *status
= us
->iobuf
;
281 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)us
->extra
;
282 unsigned char *buffer
;
285 unsigned int new_pba
;
286 unsigned long address
;
288 unsigned short pages
;
290 unsigned int len
, offset
;
291 struct scatterlist
*sg
;
293 /* check if we are allowed to write */
294 if (info
->read_only
|| info
->force_read_only
) {
295 set_sense_info (7, 0x27, 0); /* read only */
296 return USB_STOR_TRANSPORT_FAILED
;
299 // Since we only write one block at a time, we have to create
300 // a bounce buffer and move the data a piece at a time between the
301 // bounce buffer and the actual transfer buffer.
303 len
= min((unsigned int) sectors
, (unsigned int) info
->blocksize
>>
304 info
->smallpageshift
) * PAGESIZE
;
305 buffer
= kmalloc(len
, GFP_NOIO
);
307 return USB_STOR_TRANSPORT_ERROR
;
311 while (sectors
> 0) {
313 /* have we got to end? */
314 if (lba
>= info
->max_log_blks
)
317 pba
= info
->lba_to_pba
[lba
];
319 // Write as many sectors as possible in this block
321 pages
= min((unsigned int) sectors
<< info
->smallpageshift
,
322 info
->blocksize
- page
);
323 len
= pages
<< info
->pageshift
;
325 // Get the data from the transfer buffer
326 usb_stor_access_xfer_buf(buffer
, len
, us
->srb
,
327 &sg
, &offset
, FROM_XFER_BUF
);
329 US_DEBUGP("Write %02X pages, to PBA %04X"
330 " (LBA %04X) page %02X\n",
331 pages
, pba
, lba
, page
);
335 if (pba
== NOT_ALLOCATED
) {
336 /* no pba allocated for this lba, find a free pba to use */
338 int max_pba
= (info
->max_log_blks
/ 250 ) * 256;
342 /* set pba to first block in zone lba is in */
343 pba
= (lba
/ 1000) * 1024;
345 US_DEBUGP("No PBA for LBA %04X\n",lba
);
351 * Scan through the map looking for an unused block
352 * leave 16 unused blocks at start (or as many as
353 * possible) since the sddr55 seems to reuse a used
354 * block when it shouldn't if we don't leave space.
356 for (i
= 0; i
< max_pba
; i
++, pba
++) {
357 if (info
->pba_to_lba
[pba
] == UNUSED_BLOCK
) {
359 if (found_count
++ > 16)
368 US_DEBUGP("Couldn't find unallocated block\n");
370 set_sense_info (3, 0x31, 0); /* medium error */
371 result
= USB_STOR_TRANSPORT_FAILED
;
375 US_DEBUGP("Allocating PBA %04X for LBA %04X\n", pba
, lba
);
377 /* set writing to unallocated block flag */
381 address
= (pba
<< info
->blockshift
) + page
;
383 command
[1] = LSB_of(address
>>16);
384 command
[2] = LSB_of(address
>>8);
385 command
[3] = LSB_of(address
);
387 /* set the lba into the command, modulo 1000 */
388 command
[0] = LSB_of(lba
% 1000);
389 command
[6] = MSB_of(lba
% 1000);
391 command
[4] |= LSB_of(pages
>> info
->smallpageshift
);
396 result
= sddr55_bulk_transport(us
,
397 DMA_TO_DEVICE
, command
, 8);
399 if (result
!= USB_STOR_XFER_GOOD
) {
400 US_DEBUGP("Result for send_command in write_data %d\n",
403 /* set_sense_info is superfluous here? */
404 set_sense_info (3, 0x3, 0);/* peripheral write error */
405 result
= USB_STOR_TRANSPORT_FAILED
;
410 result
= sddr55_bulk_transport(us
,
411 DMA_TO_DEVICE
, buffer
, len
);
413 if (result
!= USB_STOR_XFER_GOOD
) {
414 US_DEBUGP("Result for send_data in write_data %d\n",
417 /* set_sense_info is superfluous here? */
418 set_sense_info (3, 0x3, 0);/* peripheral write error */
419 result
= USB_STOR_TRANSPORT_FAILED
;
423 /* now read status */
424 result
= sddr55_bulk_transport(us
, DMA_FROM_DEVICE
, status
, 6);
426 if (result
!= USB_STOR_XFER_GOOD
) {
427 US_DEBUGP("Result for get_status in write_data %d\n",
430 /* set_sense_info is superfluous here? */
431 set_sense_info (3, 0x3, 0);/* peripheral write error */
432 result
= USB_STOR_TRANSPORT_FAILED
;
436 new_pba
= (status
[3] + (status
[4] << 8) + (status
[5] << 16))
439 /* check status for error */
440 if (status
[0] == 0xff && status
[1] == 0x4) {
441 info
->pba_to_lba
[new_pba
] = BAD_BLOCK
;
443 set_sense_info (3, 0x0c, 0);
444 result
= USB_STOR_TRANSPORT_FAILED
;
448 US_DEBUGP("Updating maps for LBA %04X: old PBA %04X, new PBA %04X\n",
451 /* update the lba<->pba maps, note new_pba might be the same as pba */
452 info
->lba_to_pba
[lba
] = new_pba
;
453 info
->pba_to_lba
[pba
] = UNUSED_BLOCK
;
455 /* check that new_pba wasn't already being used */
456 if (info
->pba_to_lba
[new_pba
] != UNUSED_BLOCK
) {
457 printk(KERN_ERR
"sddr55 error: new PBA %04X already in use for LBA %04X\n",
458 new_pba
, info
->pba_to_lba
[new_pba
]);
459 info
->fatal_error
= 1;
460 set_sense_info (3, 0x31, 0);
461 result
= USB_STOR_TRANSPORT_FAILED
;
465 /* update the pba<->lba maps for new_pba */
466 info
->pba_to_lba
[new_pba
] = lba
% 1000;
470 sectors
-= pages
>> info
->smallpageshift
;
472 result
= USB_STOR_TRANSPORT_GOOD
;
479 static int sddr55_read_deviceID(struct us_data
*us
,
480 unsigned char *manufacturerID
,
481 unsigned char *deviceID
) {
484 unsigned char *command
= us
->iobuf
;
485 unsigned char *content
= us
->iobuf
;
487 memset(command
, 0, 8);
490 result
= sddr55_bulk_transport(us
, DMA_TO_DEVICE
, command
, 8);
492 US_DEBUGP("Result of send_control for device ID is %d\n",
495 if (result
!= USB_STOR_XFER_GOOD
)
496 return USB_STOR_TRANSPORT_ERROR
;
498 result
= sddr55_bulk_transport(us
,
499 DMA_FROM_DEVICE
, content
, 4);
501 if (result
!= USB_STOR_XFER_GOOD
)
502 return USB_STOR_TRANSPORT_ERROR
;
504 *manufacturerID
= content
[0];
505 *deviceID
= content
[1];
507 if (content
[0] != 0xff) {
508 result
= sddr55_bulk_transport(us
,
509 DMA_FROM_DEVICE
, content
, 2);
512 return USB_STOR_TRANSPORT_GOOD
;
516 int sddr55_reset(struct us_data
*us
) {
521 static unsigned long sddr55_get_capacity(struct us_data
*us
) {
523 unsigned char uninitialized_var(manufacturerID
);
524 unsigned char uninitialized_var(deviceID
);
526 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)us
->extra
;
528 US_DEBUGP("Reading capacity...\n");
530 result
= sddr55_read_deviceID(us
,
534 US_DEBUGP("Result of read_deviceID is %d\n",
537 if (result
!= USB_STOR_XFER_GOOD
)
540 US_DEBUGP("Device ID = %02X\n", deviceID
);
541 US_DEBUGP("Manuf ID = %02X\n", manufacturerID
);
544 info
->smallpageshift
= 0;
545 info
->blocksize
= 16;
546 info
->blockshift
= 4;
547 info
->blockmask
= 15;
555 info
->smallpageshift
= 1;
561 info
->smallpageshift
= 1;
562 case 0x5d: // 5d is a ROM card with pagesize 512.
576 info
->blocksize
= 32;
577 info
->blockshift
= 5;
578 info
->blockmask
= 31;
582 info
->blocksize
= 32;
583 info
->blockshift
= 5;
584 info
->blockmask
= 31;
588 info
->blocksize
= 32;
589 info
->blockshift
= 5;
590 info
->blockmask
= 31;
594 info
->blocksize
= 32;
595 info
->blockshift
= 5;
596 info
->blockmask
= 31;
605 static int sddr55_read_map(struct us_data
*us
) {
607 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)(us
->extra
);
609 unsigned char *buffer
;
610 unsigned char *command
= us
->iobuf
;
613 unsigned short max_lba
;
619 numblocks
= info
->capacity
>> (info
->blockshift
+ info
->pageshift
);
621 buffer
= kmalloc( numblocks
* 2, GFP_NOIO
);
626 memset(command
, 0, 8);
628 command
[6] = numblocks
* 2 / 256;
631 result
= sddr55_bulk_transport(us
, DMA_TO_DEVICE
, command
, 8);
633 if ( result
!= USB_STOR_XFER_GOOD
) {
638 result
= sddr55_bulk_transport(us
, DMA_FROM_DEVICE
, buffer
, numblocks
* 2);
640 if ( result
!= USB_STOR_XFER_GOOD
) {
645 result
= sddr55_bulk_transport(us
, DMA_FROM_DEVICE
, command
, 2);
647 if ( result
!= USB_STOR_XFER_GOOD
) {
652 kfree(info
->lba_to_pba
);
653 kfree(info
->pba_to_lba
);
654 info
->lba_to_pba
= kmalloc(numblocks
*sizeof(int), GFP_NOIO
);
655 info
->pba_to_lba
= kmalloc(numblocks
*sizeof(int), GFP_NOIO
);
657 if (info
->lba_to_pba
== NULL
|| info
->pba_to_lba
== NULL
) {
658 kfree(info
->lba_to_pba
);
659 kfree(info
->pba_to_lba
);
660 info
->lba_to_pba
= NULL
;
661 info
->pba_to_lba
= NULL
;
666 memset(info
->lba_to_pba
, 0xff, numblocks
*sizeof(int));
667 memset(info
->pba_to_lba
, 0xff, numblocks
*sizeof(int));
669 /* set maximum lba */
670 max_lba
= info
->max_log_blks
;
674 // Each block is 64 bytes of control data, so block i is located in
675 // scatterlist block i*64/128k = i*(2^6)*(2^-17) = i*(2^-11)
677 for (i
=0; i
<numblocks
; i
++) {
680 lba
= short_pack(buffer
[i
* 2], buffer
[i
* 2 + 1]);
682 /* Every 1024 physical blocks ("zone"), the LBA numbers
683 * go back to zero, but are within a higher
684 * block of LBA's. Also, there is a maximum of
685 * 1000 LBA's per zone. In other words, in PBA
686 * 1024-2047 you will find LBA 0-999 which are
687 * really LBA 1000-1999. Yes, this wastes 24
688 * physical blocks per zone. Go figure.
689 * These devices can have blocks go bad, so there
690 * are 24 spare blocks to use when blocks do go bad.
693 /* SDDR55 returns 0xffff for a bad block, and 0x400 for the
694 * CIS block. (Is this true for cards 8MB or less??)
695 * Record these in the physical to logical map
698 info
->pba_to_lba
[i
] = lba
;
700 if (lba
>= max_lba
) {
704 if (info
->lba_to_pba
[lba
+ zone
* 1000] != NOT_ALLOCATED
&&
705 !info
->force_read_only
) {
706 printk("sddr55: map inconsistency at LBA %04X\n", lba
+ zone
* 1000);
707 info
->force_read_only
= 1;
710 if (lba
<0x10 || (lba
>=0x3E0 && lba
<0x3EF))
711 US_DEBUGP("LBA %04X <-> PBA %04X\n", lba
, i
);
713 info
->lba_to_pba
[lba
+ zone
* 1000] = i
;
721 static void sddr55_card_info_destructor(void *extra
) {
722 struct sddr55_card_info
*info
= (struct sddr55_card_info
*)extra
;
727 kfree(info
->lba_to_pba
);
728 kfree(info
->pba_to_lba
);
733 * Transport for the Sandisk SDDR-55
735 int sddr55_transport(struct scsi_cmnd
*srb
, struct us_data
*us
)
738 static unsigned char inquiry_response
[8] = {
739 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00
741 // write-protected for now, no block descriptor support
742 static unsigned char mode_page_01
[20] = {
743 0x0, 0x12, 0x00, 0x80, 0x0, 0x0, 0x0, 0x0,
745 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
747 unsigned char *ptr
= us
->iobuf
;
748 unsigned long capacity
;
752 unsigned short pages
;
753 struct sddr55_card_info
*info
;
757 sizeof(struct sddr55_card_info
), GFP_NOIO
);
759 return USB_STOR_TRANSPORT_ERROR
;
760 us
->extra_destructor
= sddr55_card_info_destructor
;
763 info
= (struct sddr55_card_info
*)(us
->extra
);
765 if (srb
->cmnd
[0] == REQUEST_SENSE
) {
766 US_DEBUGP("SDDR55: request sense %02x/%02x/%02x\n", info
->sense_data
[2], info
->sense_data
[12], info
->sense_data
[13]);
768 memcpy (ptr
, info
->sense_data
, sizeof info
->sense_data
);
771 usb_stor_set_xfer_buf (ptr
, sizeof info
->sense_data
, srb
);
772 memset (info
->sense_data
, 0, sizeof info
->sense_data
);
774 return USB_STOR_TRANSPORT_GOOD
;
777 memset (info
->sense_data
, 0, sizeof info
->sense_data
);
779 /* Dummy up a response for INQUIRY since SDDR55 doesn't
780 respond to INQUIRY commands */
782 if (srb
->cmnd
[0] == INQUIRY
) {
783 memcpy(ptr
, inquiry_response
, 8);
784 fill_inquiry_response(us
, ptr
, 36);
785 return USB_STOR_TRANSPORT_GOOD
;
788 /* only check card status if the map isn't allocated, ie no card seen yet
789 * or if it's been over half a second since we last accessed it
791 if (info
->lba_to_pba
== NULL
|| time_after(jiffies
, info
->last_access
+ HZ
/2)) {
793 /* check to see if a card is fitted */
794 result
= sddr55_status (us
);
796 result
= sddr55_status (us
);
798 set_sense_info (6, 0x28, 0); /* new media, set unit attention, not ready to ready */
800 return USB_STOR_TRANSPORT_FAILED
;
804 /* if we detected a problem with the map when writing,
805 don't allow any more access */
806 if (info
->fatal_error
) {
808 set_sense_info (3, 0x31, 0);
809 return USB_STOR_TRANSPORT_FAILED
;
812 if (srb
->cmnd
[0] == READ_CAPACITY
) {
814 capacity
= sddr55_get_capacity(us
);
817 set_sense_info (3, 0x30, 0); /* incompatible medium */
818 return USB_STOR_TRANSPORT_FAILED
;
821 info
->capacity
= capacity
;
823 /* figure out the maximum logical block number, allowing for
824 * the fact that only 250 out of every 256 are used */
825 info
->max_log_blks
= ((info
->capacity
>> (info
->pageshift
+ info
->blockshift
)) / 256) * 250;
827 /* Last page in the card, adjust as we only use 250 out of
829 capacity
= (capacity
/ 256) * 250;
831 capacity
/= PAGESIZE
;
834 ((__be32
*) ptr
)[0] = cpu_to_be32(capacity
);
835 ((__be32
*) ptr
)[1] = cpu_to_be32(PAGESIZE
);
836 usb_stor_set_xfer_buf(ptr
, 8, srb
);
840 return USB_STOR_TRANSPORT_GOOD
;
843 if (srb
->cmnd
[0] == MODE_SENSE_10
) {
845 memcpy(ptr
, mode_page_01
, sizeof mode_page_01
);
846 ptr
[3] = (info
->read_only
|| info
->force_read_only
) ? 0x80 : 0;
847 usb_stor_set_xfer_buf(ptr
, sizeof(mode_page_01
), srb
);
849 if ( (srb
->cmnd
[2] & 0x3F) == 0x01 ) {
851 "SDDR55: Dummy up request for mode page 1\n");
852 return USB_STOR_TRANSPORT_GOOD
;
854 } else if ( (srb
->cmnd
[2] & 0x3F) == 0x3F ) {
856 "SDDR55: Dummy up request for all mode pages\n");
857 return USB_STOR_TRANSPORT_GOOD
;
860 set_sense_info (5, 0x24, 0); /* invalid field in command */
861 return USB_STOR_TRANSPORT_FAILED
;
864 if (srb
->cmnd
[0] == ALLOW_MEDIUM_REMOVAL
) {
867 "SDDR55: %s medium removal. Not that I can do"
868 " anything about it...\n",
869 (srb
->cmnd
[4]&0x03) ? "Prevent" : "Allow");
871 return USB_STOR_TRANSPORT_GOOD
;
875 if (srb
->cmnd
[0] == READ_10
|| srb
->cmnd
[0] == WRITE_10
) {
877 page
= short_pack(srb
->cmnd
[3], srb
->cmnd
[2]);
879 page
|= short_pack(srb
->cmnd
[5], srb
->cmnd
[4]);
880 pages
= short_pack(srb
->cmnd
[8], srb
->cmnd
[7]);
882 page
<<= info
->smallpageshift
;
884 // convert page to block and page-within-block
886 lba
= page
>> info
->blockshift
;
887 page
= page
& info
->blockmask
;
889 // locate physical block corresponding to logical block
891 if (lba
>= info
->max_log_blks
) {
893 US_DEBUGP("Error: Requested LBA %04X exceeds maximum "
894 "block %04X\n", lba
, info
->max_log_blks
-1);
896 set_sense_info (5, 0x24, 0); /* invalid field in command */
898 return USB_STOR_TRANSPORT_FAILED
;
901 pba
= info
->lba_to_pba
[lba
];
903 if (srb
->cmnd
[0] == WRITE_10
) {
904 US_DEBUGP("WRITE_10: write block %04X (LBA %04X) page %01X"
906 pba
, lba
, page
, pages
);
908 return sddr55_write_data(us
, lba
, page
, pages
);
910 US_DEBUGP("READ_10: read block %04X (LBA %04X) page %01X"
912 pba
, lba
, page
, pages
);
914 return sddr55_read_data(us
, lba
, page
, pages
);
919 if (srb
->cmnd
[0] == TEST_UNIT_READY
) {
920 return USB_STOR_TRANSPORT_GOOD
;
923 if (srb
->cmnd
[0] == START_STOP
) {
924 return USB_STOR_TRANSPORT_GOOD
;
927 set_sense_info (5, 0x20, 0); /* illegal command */
929 return USB_STOR_TRANSPORT_FAILED
; // FIXME: sense buffer?