1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2007 by Björn Stenberg
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
30 /* Needed to get at the audio buffer */
32 #include "usb_storage.h"
37 /* The SD card driver on Sansa c200 and e200 can cause write corruption,
38 * often triggered by simultaneous USB activity. This can be largely avoided
39 * by not overlapping storage_write_sector() with USB transfers. This does reduce
40 * write performance, so we only do it for the affected DAPs
42 #if (CONFIG_STORAGE & STORAGE_SD)
43 #define SERIALIZE_WRITES
45 /* Enable the following define to export only the SD card slot. This
46 * is useful for USBCV MSC tests, as those are destructive.
47 * This won't work right if the device doesn't have a card slot.
49 //#define ONLY_EXPOSE_CARD_SLOT
51 #ifdef USB_USE_RAMDISK
52 #define RAMDISK_SIZE 2048
55 #define SECTOR_SIZE 512
57 /* We can currently use up to 20k buffer size. More than that requires
58 * transfer chaining in the driver. Tests on sansa c200 show that the 16k
59 * limitation causes no more than 2% slowdown.
61 #define BUFFER_SIZE 16384
63 /* bulk-only class specific requests */
64 #define USB_BULK_RESET_REQUEST 0xff
65 #define USB_BULK_GET_MAX_LUN 0xfe
67 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */
68 #define DEVICE_REMOVABLE 0x80
70 #define CBW_SIGNATURE 0x43425355
71 #define CSW_SIGNATURE 0x53425355
73 #define SCSI_TEST_UNIT_READY 0x00
74 #define SCSI_INQUIRY 0x12
75 #define SCSI_MODE_SENSE_6 0x1a
76 #define SCSI_MODE_SENSE_10 0x5a
77 #define SCSI_REQUEST_SENSE 0x03
78 #define SCSI_ALLOW_MEDIUM_REMOVAL 0x1e
79 #define SCSI_READ_CAPACITY 0x25
80 #define SCSI_READ_FORMAT_CAPACITY 0x23
81 #define SCSI_READ_10 0x28
82 #define SCSI_WRITE_10 0x2a
83 #define SCSI_START_STOP_UNIT 0x1b
84 #define SCSI_REPORT_LUNS 0xa0
86 #define UMS_STATUS_GOOD 0x00
87 #define UMS_STATUS_FAIL 0x01
89 #define SENSE_NOT_READY 0x02
90 #define SENSE_MEDIUM_ERROR 0x03
91 #define SENSE_ILLEGAL_REQUEST 0x05
92 #define SENSE_UNIT_ATTENTION 0x06
94 #define ASC_MEDIUM_NOT_PRESENT 0x3a
95 #define ASC_INVALID_FIELD_IN_CBD 0x24
96 #define ASC_LBA_OUT_OF_RANGE 0x21
97 #define ASC_WRITE_ERROR 0x0C
98 #define ASC_READ_ERROR 0x11
99 #define ASC_NOT_READY 0x04
100 #define ASCQ_BECOMING_READY 0x01
102 #define SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA 0x02000000
104 /* storage interface */
106 #define USB_SC_SCSI 0x06 /* Transparent */
107 #define USB_PROT_BULK 0x50 /* bulk only */
109 static struct usb_interface_descriptor
__attribute__((aligned(2)))
110 interface_descriptor
=
112 .bLength
= sizeof(struct usb_interface_descriptor
),
113 .bDescriptorType
= USB_DT_INTERFACE
,
114 .bInterfaceNumber
= 0,
115 .bAlternateSetting
= 0,
117 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
118 .bInterfaceSubClass
= USB_SC_SCSI
,
119 .bInterfaceProtocol
= USB_PROT_BULK
,
123 static struct usb_endpoint_descriptor
__attribute__((aligned(2)))
124 endpoint_descriptor
=
126 .bLength
= sizeof(struct usb_endpoint_descriptor
),
127 .bDescriptorType
= USB_DT_ENDPOINT
,
128 .bEndpointAddress
= 0,
129 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
134 struct inquiry_data
{
135 unsigned char DeviceType
;
136 unsigned char DeviceTypeModifier
;
137 unsigned char Versions
;
138 unsigned char Format
;
139 unsigned char AdditionalLength
;
140 unsigned char Reserved
[2];
141 unsigned char Capability
;
142 unsigned char VendorId
[8];
143 unsigned char ProductId
[16];
144 unsigned char ProductRevisionLevel
[4];
145 } __attribute__ ((packed
));
147 struct report_lun_data
{
148 unsigned int lun_list_length
;
149 unsigned int reserved1
;
150 // TODO this should be cleaned up with the VOLUMES vs DRIVES mess
151 unsigned char luns
[NUM_VOLUMES
][8];
152 } __attribute__ ((packed
));
155 unsigned char ResponseCode
;
156 unsigned char Obsolete
;
157 unsigned char fei_sensekey
;
158 unsigned int Information
;
159 unsigned char AdditionalSenseLength
;
160 unsigned int CommandSpecificInformation
;
161 unsigned char AdditionalSenseCode
;
162 unsigned char AdditionalSenseCodeQualifier
;
163 unsigned char FieldReplaceableUnitCode
;
165 unsigned short SenseKeySpecific
;
166 } __attribute__ ((packed
));
168 struct mode_sense_bdesc_longlba
{
169 unsigned char num_blocks
[8];
170 unsigned char reserved
[4];
171 unsigned char block_size
[4];
172 } __attribute__ ((packed
));
174 struct mode_sense_bdesc_shortlba
{
175 unsigned char density_code
;
176 unsigned char num_blocks
[3];
177 unsigned char reserved
;
178 unsigned char block_size
[3];
179 } __attribute__ ((packed
));
181 struct mode_sense_data_10
{
182 unsigned short mode_data_length
;
183 unsigned char medium_type
;
184 unsigned char device_specific
;
185 unsigned char longlba
;
186 unsigned char reserved
;
187 unsigned short block_descriptor_length
;
188 struct mode_sense_bdesc_longlba block_descriptor
;
189 } __attribute__ ((packed
));
191 struct mode_sense_data_6
{
192 unsigned char mode_data_length
;
193 unsigned char medium_type
;
194 unsigned char device_specific
;
195 unsigned char block_descriptor_length
;
196 struct mode_sense_bdesc_shortlba block_descriptor
;
197 } __attribute__ ((packed
));
199 struct command_block_wrapper
{
200 unsigned int signature
;
202 unsigned int data_transfer_length
;
205 unsigned char command_length
;
206 unsigned char command_block
[16];
207 } __attribute__ ((packed
));
209 struct command_status_wrapper
{
210 unsigned int signature
;
212 unsigned int data_residue
;
213 unsigned char status
;
214 } __attribute__ ((packed
));
217 unsigned int block_count
;
218 unsigned int block_size
;
219 } __attribute__ ((packed
));
221 struct format_capacity
{
222 unsigned int following_length
;
223 unsigned int block_count
;
224 unsigned int block_size
;
225 } __attribute__ ((packed
));
229 unsigned char* transfer_buffer
;
230 struct inquiry_data
* inquiry
;
231 struct capacity
* capacity_data
;
232 struct format_capacity
* format_capacity_data
;
233 struct sense_data
*sense_data
;
234 struct mode_sense_data_6
*ms_data_6
;
235 struct mode_sense_data_10
*ms_data_10
;
236 struct report_lun_data
*lun_data
;
237 struct command_status_wrapper
* csw
;
246 unsigned char *data
[2];
247 unsigned char data_select
;
248 unsigned int last_result
;
252 unsigned char sense_key
;
253 unsigned char information
;
258 static void handle_scsi(struct command_block_wrapper
* cbw
);
259 static void send_csw(int status
);
260 static void send_command_result(void *data
,int size
);
261 static void send_command_failed_result(void);
262 static void send_block_data(void *data
,int size
);
263 static void receive_block_data(void *data
,int size
);
264 static void fill_inquiry(IF_MV_NONVOID(int lun
));
265 static void send_and_read_next(void);
266 static bool ejected
[NUM_VOLUMES
];
268 static int usb_interface
;
269 static int ep_in
, ep_out
;
271 #ifdef USB_USE_RAMDISK
272 static unsigned char* ramdisk_buffer
;
279 SENDING_FAILED_RESULT
,
282 } state
= WAITING_FOR_COMMAND
;
284 static bool check_disk_present(IF_MV_NONVOID(int volume
))
286 #ifdef USB_USE_RAMDISK
289 unsigned char sector
[512];
290 return storage_read_sectors(volume
,0,1,sector
) == 0;
294 static void try_release_ata(void)
296 /* Check if there is a connected drive left. If not,
297 release excusive access */
298 bool canrelease
=true;
300 for(i
=0;i
<NUM_VOLUMES
;i
++) {
301 if(ejected
[i
]==false){
307 logf("scsi release ata");
308 usb_release_exclusive_ata();
313 void usb_storage_notify_hotswap(int volume
,bool inserted
)
315 logf("notify %d",inserted
);
316 if(inserted
&& check_disk_present(IF_MV(volume
))) {
317 ejected
[volume
] = false;
320 ejected
[volume
] = true;
327 void usb_storage_reconnect(void)
330 if(usb_core_driver_enabled(USB_DRIVER_MASS_STORAGE
)
332 for(i
=0;i
<NUM_VOLUMES
;i
++)
333 ejected
[i
] = !check_disk_present(IF_MV(i
));
334 logf("%s", __func__
);
335 usb_request_exclusive_ata();
339 /* called by usb_code_init() */
340 void usb_storage_init(void)
343 for(i
=0;i
<NUM_VOLUMES
;i
++) {
344 ejected
[i
] = !check_disk_present(IF_MV(i
));
346 logf("usb_storage_init done");
349 int usb_storage_request_endpoints(struct usb_class_driver
*drv
)
351 ep_in
= usb_core_request_endpoint(USB_DIR_IN
, drv
);
356 ep_out
= usb_core_request_endpoint(USB_DIR_OUT
, drv
);
359 usb_core_release_endpoint(ep_in
);
366 int usb_storage_set_first_interface(int interface
)
368 usb_interface
= interface
;
369 return interface
+ 1;
372 int usb_storage_get_config_descriptor(unsigned char *dest
,int max_packet_size
)
374 endpoint_descriptor
.wMaxPacketSize
=max_packet_size
;
375 interface_descriptor
.bInterfaceNumber
=usb_interface
;
377 memcpy(dest
,&interface_descriptor
,
378 sizeof(struct usb_interface_descriptor
));
379 dest
+=sizeof(struct usb_interface_descriptor
);
381 endpoint_descriptor
.bEndpointAddress
= ep_in
;
382 memcpy(dest
,&endpoint_descriptor
,
383 sizeof(struct usb_endpoint_descriptor
));
384 dest
+=sizeof(struct usb_endpoint_descriptor
);
386 endpoint_descriptor
.bEndpointAddress
= ep_out
;
387 memcpy(dest
,&endpoint_descriptor
,
388 sizeof(struct usb_endpoint_descriptor
));
390 return sizeof(struct usb_interface_descriptor
) +
391 2*sizeof(struct usb_endpoint_descriptor
);
394 void usb_storage_init_connection(void)
396 logf("ums: set config");
397 /* prime rx endpoint. We only need room for commands */
398 state
= WAITING_FOR_COMMAND
;
400 #if CONFIG_CPU == IMX31L || CONFIG_USBOTG == USBOTG_ISP1583 || \
401 defined(CPU_TCC77X) || defined(CPU_TCC780X)
402 static unsigned char _transfer_buffer
[BUFFER_SIZE
*2]
403 USBDEVBSS_ATTR
__attribute__((aligned(32)));
404 tb
.transfer_buffer
= (void *)_transfer_buffer
;
406 /* TODO : check if bufsize is at least 32K ? */
408 unsigned char * audio_buffer
;
410 audio_buffer
= audio_get_buffer(false,&bufsize
);
412 (void *)UNCACHED_ADDR((unsigned int)(audio_buffer
+ 31) & 0xffffffe0);
414 #ifdef USB_USE_RAMDISK
415 ramdisk_buffer
= tb
.transfer_buffer
+ BUFFER_SIZE
*2;
418 usb_drv_recv(ep_out
, tb
.transfer_buffer
, 1024);
421 /* called by usb_core_transfer_complete() */
422 void usb_storage_transfer_complete(int ep
,int dir
,int status
,int length
)
425 struct command_block_wrapper
* cbw
= (void*)tb
.transfer_buffer
;
427 //logf("transfer result %X %d", status, length);
429 case RECEIVING_BLOCKS
:
430 if(dir
==USB_DIR_IN
) {
431 logf("IN received in RECEIVING");
433 logf("scsi write %d %d", cur_cmd
.sector
, cur_cmd
.count
);
435 if((unsigned int)length
!=(SECTOR_SIZE
*cur_cmd
.count
)
436 && (unsigned int)length
!=BUFFER_SIZE
) {
437 logf("unexpected length :%d",length
);
440 unsigned int next_sector
= cur_cmd
.sector
+
441 (BUFFER_SIZE
/SECTOR_SIZE
);
442 unsigned int next_count
= cur_cmd
.count
-
443 MIN(cur_cmd
.count
,BUFFER_SIZE
/SECTOR_SIZE
);
444 int next_select
= !cur_cmd
.data_select
;
446 #ifndef SERIALIZE_WRITES
448 /* Ask the host to send more, to the other buffer */
449 receive_block_data(cur_cmd
.data
[next_select
],
450 MIN(BUFFER_SIZE
,next_count
*SECTOR_SIZE
));
454 /* Now write the data that just came in, while the host is
455 sending the next bit */
456 #ifdef USB_USE_RAMDISK
457 memcpy(ramdisk_buffer
+ cur_cmd
.sector
*SECTOR_SIZE
,
458 cur_cmd
.data
[cur_cmd
.data_select
],
459 MIN(BUFFER_SIZE
/SECTOR_SIZE
, cur_cmd
.count
)*SECTOR_SIZE
);
461 int result
= storage_write_sectors(cur_cmd
.lun
,
463 MIN(BUFFER_SIZE
/SECTOR_SIZE
,
465 cur_cmd
.data
[cur_cmd
.data_select
]);
467 send_csw(UMS_STATUS_FAIL
);
468 cur_sense_data
.sense_key
=SENSE_MEDIUM_ERROR
;
469 cur_sense_data
.asc
=ASC_WRITE_ERROR
;
470 cur_sense_data
.ascq
=0;
474 #ifdef SERIALIZE_WRITES
476 /* Ask the host to send more, to the other buffer */
477 receive_block_data(cur_cmd
.data
[next_select
],
478 MIN(BUFFER_SIZE
,next_count
*SECTOR_SIZE
));
483 send_csw(UMS_STATUS_GOOD
);
486 /* Switch buffers for the next one */
487 cur_cmd
.data_select
=!cur_cmd
.data_select
;
489 cur_cmd
.sector
= next_sector
;
490 cur_cmd
.count
= next_count
;
494 logf("Transfer failed %X",status
);
495 send_csw(UMS_STATUS_FAIL
);
496 /* TODO fill in cur_sense_data */
497 cur_sense_data
.sense_key
=0;
498 cur_sense_data
.information
=0;
499 cur_sense_data
.asc
=0;
500 cur_sense_data
.ascq
=0;
503 case WAITING_FOR_COMMAND
:
504 if(dir
==USB_DIR_IN
) {
505 logf("IN received in WAITING_FOR_COMMAND");
507 //logf("command received");
508 if(letoh32(cbw
->signature
) == CBW_SIGNATURE
){
512 usb_drv_stall(ep_in
, true,true);
513 usb_drv_stall(ep_out
, true,false);
517 if(dir
==USB_DIR_OUT
) {
518 logf("OUT received in SENDING_CSW");
520 //logf("csw sent, now go back to idle");
521 state
= WAITING_FOR_COMMAND
;
522 usb_drv_recv(ep_out
, tb
.transfer_buffer
, 1024);
525 if(dir
==USB_DIR_OUT
) {
526 logf("OUT received in SENDING");
529 //logf("data sent, now send csw");
530 send_csw(UMS_STATUS_GOOD
);
533 logf("Transfer failed %X",status
);
534 send_csw(UMS_STATUS_FAIL
);
535 /* TODO fill in cur_sense_data */
536 cur_sense_data
.sense_key
=0;
537 cur_sense_data
.information
=0;
538 cur_sense_data
.asc
=0;
539 cur_sense_data
.ascq
=0;
542 case SENDING_FAILED_RESULT
:
543 if(dir
==USB_DIR_OUT
) {
544 logf("OUT received in SENDING");
546 send_csw(UMS_STATUS_FAIL
);
549 if(dir
==USB_DIR_OUT
) {
550 logf("OUT received in SENDING");
553 if(cur_cmd
.count
==0) {
554 //logf("data sent, now send csw");
555 send_csw(UMS_STATUS_GOOD
);
558 send_and_read_next();
562 logf("Transfer failed %X",status
);
563 send_csw(UMS_STATUS_FAIL
);
564 /* TODO fill in cur_sense_data */
565 cur_sense_data
.sense_key
=0;
566 cur_sense_data
.information
=0;
567 cur_sense_data
.asc
=0;
568 cur_sense_data
.ascq
=0;
574 /* called by usb_core_control_request() */
575 bool usb_storage_control_request(struct usb_ctrlrequest
* req
)
577 bool handled
= false;
580 switch (req
->bRequest
) {
581 case USB_BULK_GET_MAX_LUN
: {
582 #ifdef ONLY_EXPOSE_CARD_SLOT
585 *tb
.max_lun
= NUM_VOLUMES
- 1;
587 logf("ums: getmaxlun");
588 usb_drv_send(EP_CONTROL
, tb
.max_lun
, 1);
589 usb_drv_recv(EP_CONTROL
, NULL
, 0); /* ack */
594 case USB_BULK_RESET_REQUEST
:
595 logf("ums: bulk reset");
596 state
= WAITING_FOR_COMMAND
;
597 /* UMS BOT 3.1 says The device shall preserve the value of its bulk
598 data toggle bits and endpoint STALL conditions despite
599 the Bulk-Only Mass Storage Reset. */
601 usb_drv_reset_endpoint(ep_in
, false);
602 usb_drv_reset_endpoint(ep_out
, true);
605 usb_drv_send(EP_CONTROL
, NULL
, 0); /* ack */
613 static void send_and_read_next(void)
615 if(cur_cmd
.last_result
!=0) {
616 /* The last read failed. */
617 send_csw(UMS_STATUS_FAIL
);
618 cur_sense_data
.sense_key
=SENSE_MEDIUM_ERROR
;
619 cur_sense_data
.asc
=ASC_READ_ERROR
;
620 cur_sense_data
.ascq
=0;
623 send_block_data(cur_cmd
.data
[cur_cmd
.data_select
],
624 MIN(BUFFER_SIZE
,cur_cmd
.count
*SECTOR_SIZE
));
626 /* Switch buffers for the next one */
627 cur_cmd
.data_select
=!cur_cmd
.data_select
;
629 cur_cmd
.sector
+=(BUFFER_SIZE
/SECTOR_SIZE
);
630 cur_cmd
.count
-=MIN(cur_cmd
.count
,BUFFER_SIZE
/SECTOR_SIZE
);
632 if(cur_cmd
.count
!=0){
633 /* already read the next bit, so we can send it out immediately when the
634 * current transfer completes. */
635 #ifdef USB_USE_RAMDISK
636 memcpy(cur_cmd
.data
[cur_cmd
.data_select
],
637 ramdisk_buffer
+ cur_cmd
.sector
*SECTOR_SIZE
,
638 MIN(BUFFER_SIZE
/SECTOR_SIZE
, cur_cmd
.count
)*SECTOR_SIZE
);
640 cur_cmd
.last_result
= storage_read_sectors(cur_cmd
.lun
,
642 MIN(BUFFER_SIZE
/SECTOR_SIZE
,
644 cur_cmd
.data
[cur_cmd
.data_select
]);
648 /****************************************************************************/
650 static void handle_scsi(struct command_block_wrapper
* cbw
)
652 /* USB Mass Storage assumes LBA capability.
653 TODO: support 48-bit LBA */
655 struct storage_info info
;
656 unsigned int length
= cbw
->data_transfer_length
;
657 unsigned int block_size
= 0;
658 unsigned int block_count
= 0;
659 bool lun_present
=true;
660 #ifdef ONLY_EXPOSE_CARD_SLOT
661 unsigned char lun
= cbw
->lun
+1;
663 unsigned char lun
= cbw
->lun
;
665 unsigned int block_size_mult
= 1;
666 storage_get_info(lun
,&info
);
667 #ifdef USB_USE_RAMDISK
668 block_size
= SECTOR_SIZE
;
669 block_count
= RAMDISK_SIZE
;
671 block_size
=info
.sector_size
;
672 block_count
=info
.num_sectors
;
676 if(storage_removable(lun
) && !storage_present(lun
)) {
685 #ifdef MAX_LOG_SECTOR_SIZE
686 block_size_mult
= disk_sector_multiplier
;
689 cur_cmd
.tag
= cbw
->tag
;
692 switch (cbw
->command_block
[0]) {
693 case SCSI_TEST_UNIT_READY
:
694 logf("scsi test_unit_ready %d",lun
);
695 if(!usb_exclusive_ata()) {
696 send_csw(UMS_STATUS_FAIL
);
697 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
698 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
699 cur_sense_data
.ascq
=0;
703 send_csw(UMS_STATUS_GOOD
);
706 send_csw(UMS_STATUS_FAIL
);
707 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
708 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
709 cur_sense_data
.ascq
=0;
713 case SCSI_REPORT_LUNS
: {
714 logf("scsi inquiry %d",lun
);
715 int allocation_length
=0;
717 allocation_length
|=(cbw
->command_block
[6]<<24);
718 allocation_length
|=(cbw
->command_block
[7]<<16);
719 allocation_length
|=(cbw
->command_block
[8]<<8);
720 allocation_length
|=(cbw
->command_block
[9]);
721 memset(tb
.lun_data
,0,sizeof(struct report_lun_data
));
722 tb
.lun_data
->lun_list_length
=htobe32(8*NUM_VOLUMES
);
723 for(i
=0;i
<NUM_VOLUMES
;i
++)
726 if(storage_removable(i
))
727 tb
.lun_data
->luns
[i
][1]=1;
730 tb
.lun_data
->luns
[i
][1]=0;
732 send_command_result(tb
.lun_data
,
733 MIN(sizeof(struct report_lun_data
), length
));
738 logf("scsi inquiry %d",lun
);
739 fill_inquiry(IF_MV(lun
));
740 length
= MIN(length
, cbw
->command_block
[4]);
741 send_command_result(tb
.inquiry
,
742 MIN(sizeof(struct inquiry_data
), length
));
745 case SCSI_REQUEST_SENSE
: {
746 tb
.sense_data
->ResponseCode
=0x70;/*current error*/
747 tb
.sense_data
->Obsolete
=0;
748 tb
.sense_data
->fei_sensekey
=cur_sense_data
.sense_key
&0x0f;
749 tb
.sense_data
->Information
=cur_sense_data
.information
;
750 tb
.sense_data
->AdditionalSenseLength
=10;
751 tb
.sense_data
->CommandSpecificInformation
=0;
752 tb
.sense_data
->AdditionalSenseCode
=cur_sense_data
.asc
;
753 tb
.sense_data
->AdditionalSenseCodeQualifier
=cur_sense_data
.ascq
;
754 tb
.sense_data
->FieldReplaceableUnitCode
=0;
755 tb
.sense_data
->SKSV
=0;
756 tb
.sense_data
->SenseKeySpecific
=0;
757 logf("scsi request_sense %d",lun
);
758 send_command_result(tb
.sense_data
, sizeof(struct sense_data
));
762 case SCSI_MODE_SENSE_10
: {
764 send_command_failed_result();
765 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
766 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
767 cur_sense_data
.ascq
=0;
770 /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/
771 unsigned char page_code
= cbw
->command_block
[2] & 0x3f;
772 logf("scsi mode_sense_10 %d %X",lun
,page_code
);
775 tb
.ms_data_10
->mode_data_length
=
776 htobe16(sizeof(struct mode_sense_data_10
)-2);
777 tb
.ms_data_10
->medium_type
= 0;
778 tb
.ms_data_10
->device_specific
= 0;
779 tb
.ms_data_10
->reserved
= 0;
780 tb
.ms_data_10
->longlba
= 1;
781 tb
.ms_data_10
->block_descriptor_length
=
782 htobe16(sizeof(struct mode_sense_bdesc_longlba
));
784 memset(tb
.ms_data_10
->block_descriptor
.reserved
,0,4);
785 memset(tb
.ms_data_10
->block_descriptor
.num_blocks
,0,8);
787 tb
.ms_data_10
->block_descriptor
.num_blocks
[4] =
788 ((block_count
/block_size_mult
) & 0xff000000)>>24;
789 tb
.ms_data_10
->block_descriptor
.num_blocks
[5] =
790 ((block_count
/block_size_mult
) & 0x00ff0000)>>16;
791 tb
.ms_data_10
->block_descriptor
.num_blocks
[6] =
792 ((block_count
/block_size_mult
) & 0x0000ff00)>>8;
793 tb
.ms_data_10
->block_descriptor
.num_blocks
[7] =
794 ((block_count
/block_size_mult
) & 0x000000ff);
796 tb
.ms_data_10
->block_descriptor
.block_size
[0] =
797 ((block_size
*block_size_mult
) & 0xff000000)>>24;
798 tb
.ms_data_10
->block_descriptor
.block_size
[1] =
799 ((block_size
*block_size_mult
) & 0x00ff0000)>>16;
800 tb
.ms_data_10
->block_descriptor
.block_size
[2] =
801 ((block_size
*block_size_mult
) & 0x0000ff00)>>8;
802 tb
.ms_data_10
->block_descriptor
.block_size
[3] =
803 ((block_size
*block_size_mult
) & 0x000000ff);
804 send_command_result(tb
.ms_data_10
,
805 MIN(sizeof(struct mode_sense_data_10
), length
));
808 send_command_failed_result();
809 cur_sense_data
.sense_key
=SENSE_ILLEGAL_REQUEST
;
810 cur_sense_data
.asc
=ASC_INVALID_FIELD_IN_CBD
;
811 cur_sense_data
.ascq
=0;
816 case SCSI_MODE_SENSE_6
: {
818 send_command_failed_result();
819 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
820 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
821 cur_sense_data
.ascq
=0;
824 /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/
825 unsigned char page_code
= cbw
->command_block
[2] & 0x3f;
826 logf("scsi mode_sense_6 %d %X",lun
,page_code
);
829 /* All supported pages. */
830 tb
.ms_data_6
->mode_data_length
=
831 sizeof(struct mode_sense_data_6
)-1;
832 tb
.ms_data_6
->medium_type
= 0;
833 tb
.ms_data_6
->device_specific
= 0;
834 tb
.ms_data_6
->block_descriptor_length
=
835 sizeof(struct mode_sense_bdesc_shortlba
);
836 tb
.ms_data_6
->block_descriptor
.density_code
= 0;
837 tb
.ms_data_6
->block_descriptor
.reserved
= 0;
838 if(block_count
/block_size_mult
> 0xffffff){
839 tb
.ms_data_6
->block_descriptor
.num_blocks
[0] = 0xff;
840 tb
.ms_data_6
->block_descriptor
.num_blocks
[1] = 0xff;
841 tb
.ms_data_6
->block_descriptor
.num_blocks
[2] = 0xff;
844 tb
.ms_data_6
->block_descriptor
.num_blocks
[0] =
845 ((block_count
/block_size_mult
) & 0xff0000)>>16;
846 tb
.ms_data_6
->block_descriptor
.num_blocks
[1] =
847 ((block_count
/block_size_mult
) & 0x00ff00)>>8;
848 tb
.ms_data_6
->block_descriptor
.num_blocks
[2] =
849 ((block_count
/block_size_mult
) & 0x0000ff);
851 tb
.ms_data_6
->block_descriptor
.block_size
[0] =
852 ((block_size
*block_size_mult
) & 0xff0000)>>16;
853 tb
.ms_data_6
->block_descriptor
.block_size
[1] =
854 ((block_size
*block_size_mult
) & 0x00ff00)>>8;
855 tb
.ms_data_6
->block_descriptor
.block_size
[2] =
856 ((block_size
*block_size_mult
) & 0x0000ff);
857 send_command_result(tb
.ms_data_6
,
858 MIN(sizeof(struct mode_sense_data_6
), length
));
861 send_command_failed_result();
862 cur_sense_data
.sense_key
=SENSE_ILLEGAL_REQUEST
;
863 cur_sense_data
.asc
=ASC_INVALID_FIELD_IN_CBD
;
864 cur_sense_data
.ascq
=0;
870 case SCSI_START_STOP_UNIT
:
871 logf("scsi start_stop unit %d",lun
);
872 if((cbw
->command_block
[4] & 0xf0) == 0) /*load/eject bit is valid*/
873 { /* Process start and eject bits */
874 logf("scsi load/eject");
875 if((cbw
->command_block
[4] & 0x01) == 0) /* Don't start */
877 if((cbw
->command_block
[4] & 0x02) != 0) /* eject */
885 send_csw(UMS_STATUS_GOOD
);
888 case SCSI_ALLOW_MEDIUM_REMOVAL
:
889 logf("scsi allow_medium_removal %d",lun
);
890 /* TODO: use this to show the connect screen ? */
891 send_csw(UMS_STATUS_GOOD
);
893 case SCSI_READ_FORMAT_CAPACITY
: {
894 logf("scsi read_format_capacity %d",lun
);
896 tb
.format_capacity_data
->following_length
=htobe32(8);
897 /* "block count" actually means "number of last block" */
898 tb
.format_capacity_data
->block_count
=
899 htobe32(block_count
/block_size_mult
- 1);
900 tb
.format_capacity_data
->block_size
=
901 htobe32(block_size
*block_size_mult
);
902 tb
.format_capacity_data
->block_size
|=
903 htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA
);
905 send_command_result(tb
.format_capacity_data
,
906 MIN(sizeof(struct format_capacity
), length
));
910 send_command_failed_result();
911 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
912 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
913 cur_sense_data
.ascq
=0;
917 case SCSI_READ_CAPACITY
: {
918 logf("scsi read_capacity %d",lun
);
921 /* "block count" actually means "number of last block" */
922 tb
.capacity_data
->block_count
=
923 htobe32(block_count
/block_size_mult
- 1);
924 tb
.capacity_data
->block_size
=
925 htobe32(block_size
*block_size_mult
);
927 send_command_result(tb
.capacity_data
,
928 MIN(sizeof(struct capacity
), length
));
932 send_command_failed_result();
933 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
934 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
935 cur_sense_data
.ascq
=0;
941 logf("scsi read10 %d",lun
);
943 send_command_failed_result();
944 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
945 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
946 cur_sense_data
.ascq
=0;
949 cur_cmd
.data
[0] = tb
.transfer_buffer
;
950 cur_cmd
.data
[1] = &tb
.transfer_buffer
[BUFFER_SIZE
];
951 cur_cmd
.data_select
=0;
952 cur_cmd
.sector
= block_size_mult
*
953 (cbw
->command_block
[2] << 24 |
954 cbw
->command_block
[3] << 16 |
955 cbw
->command_block
[4] << 8 |
956 cbw
->command_block
[5] );
957 cur_cmd
.count
= block_size_mult
*
958 (cbw
->command_block
[7] << 8 |
959 cbw
->command_block
[8]);
961 //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count);
963 if((cur_cmd
.sector
+ cur_cmd
.count
) > block_count
) {
964 send_csw(UMS_STATUS_FAIL
);
965 cur_sense_data
.sense_key
=SENSE_ILLEGAL_REQUEST
;
966 cur_sense_data
.asc
=ASC_LBA_OUT_OF_RANGE
;
967 cur_sense_data
.ascq
=0;
970 #ifdef USB_USE_RAMDISK
971 memcpy(cur_cmd
.data
[cur_cmd
.data_select
],
972 ramdisk_buffer
+ cur_cmd
.sector
*SECTOR_SIZE
,
973 MIN(BUFFER_SIZE
/SECTOR_SIZE
, cur_cmd
.count
)*SECTOR_SIZE
);
975 cur_cmd
.last_result
= storage_read_sectors(cur_cmd
.lun
,
977 MIN(BUFFER_SIZE
/SECTOR_SIZE
,
979 cur_cmd
.data
[cur_cmd
.data_select
]);
981 send_and_read_next();
986 logf("scsi write10 %d",lun
);
988 send_csw(UMS_STATUS_FAIL
);
989 cur_sense_data
.sense_key
=SENSE_NOT_READY
;
990 cur_sense_data
.asc
=ASC_MEDIUM_NOT_PRESENT
;
991 cur_sense_data
.ascq
=0;
994 cur_cmd
.data
[0] = tb
.transfer_buffer
;
995 cur_cmd
.data
[1] = &tb
.transfer_buffer
[BUFFER_SIZE
];
996 cur_cmd
.data_select
=0;
997 cur_cmd
.sector
= block_size_mult
*
998 (cbw
->command_block
[2] << 24 |
999 cbw
->command_block
[3] << 16 |
1000 cbw
->command_block
[4] << 8 |
1001 cbw
->command_block
[5] );
1002 cur_cmd
.count
= block_size_mult
*
1003 (cbw
->command_block
[7] << 8 |
1004 cbw
->command_block
[8]);
1006 if((cur_cmd
.sector
+ cur_cmd
.count
) > block_count
) {
1007 send_csw(UMS_STATUS_FAIL
);
1008 cur_sense_data
.sense_key
=SENSE_ILLEGAL_REQUEST
;
1009 cur_sense_data
.asc
=ASC_LBA_OUT_OF_RANGE
;
1010 cur_sense_data
.ascq
=0;
1013 receive_block_data(cur_cmd
.data
[0],
1015 cur_cmd
.count
*SECTOR_SIZE
));
1021 logf("scsi unknown cmd %x",cbw
->command_block
[0x0]);
1022 usb_drv_stall(ep_in
, true,true);
1023 send_csw(UMS_STATUS_FAIL
);
1028 static void send_block_data(void *data
,int size
)
1030 usb_drv_send_nonblocking(ep_in
, data
,size
);
1031 state
= SENDING_BLOCKS
;
1034 static void send_command_result(void *data
,int size
)
1036 usb_drv_send_nonblocking(ep_in
, data
,size
);
1037 state
= SENDING_RESULT
;
1040 static void send_command_failed_result(void)
1042 usb_drv_send_nonblocking(ep_in
, NULL
, 0);
1043 state
= SENDING_FAILED_RESULT
;
1046 static void receive_block_data(void *data
,int size
)
1048 usb_drv_recv(ep_out
, data
, size
);
1049 state
= RECEIVING_BLOCKS
;
1052 static void send_csw(int status
)
1054 tb
.csw
->signature
= htole32(CSW_SIGNATURE
);
1055 tb
.csw
->tag
= cur_cmd
.tag
;
1056 tb
.csw
->data_residue
= 0;
1057 tb
.csw
->status
= status
;
1059 usb_drv_send_nonblocking(ep_in
, tb
.csw
,
1060 sizeof(struct command_status_wrapper
));
1061 state
= SENDING_CSW
;
1062 //logf("CSW: %X",status);
1064 if(status
== UMS_STATUS_GOOD
) {
1065 cur_sense_data
.sense_key
=0;
1066 cur_sense_data
.information
=0;
1067 cur_sense_data
.asc
=0;
1068 cur_sense_data
.ascq
=0;
1072 static void copy_padded(char *dest
, char *src
, int len
)
1075 while(src
[i
]!=0 && i
<len
)
1087 /* build SCSI INQUIRY */
1088 static void fill_inquiry(IF_MV_NONVOID(int lun
))
1090 memset(tb
.inquiry
, 0, sizeof(struct inquiry_data
));
1091 struct storage_info info
;
1092 storage_get_info(lun
,&info
);
1093 copy_padded(tb
.inquiry
->VendorId
,info
.vendor
,sizeof(tb
.inquiry
->VendorId
));
1094 copy_padded(tb
.inquiry
->ProductId
,info
.product
,sizeof(tb
.inquiry
->ProductId
));
1095 copy_padded(tb
.inquiry
->ProductRevisionLevel
,info
.revision
,sizeof(tb
.inquiry
->ProductRevisionLevel
));
1097 tb
.inquiry
->DeviceType
= DIRECT_ACCESS_DEVICE
;
1098 tb
.inquiry
->AdditionalLength
= 0x1f;
1099 memset(tb
.inquiry
->Reserved
, 0, 3);
1100 tb
.inquiry
->Versions
= 4; /* SPC-2 */
1101 tb
.inquiry
->Format
= 2; /* SPC-2/3 inquiry format */
1103 #ifdef TOSHIBA_GIGABEAT_S
1104 tb
.inquiry
->DeviceTypeModifier
= 0;
1106 tb
.inquiry
->DeviceTypeModifier
= DEVICE_REMOVABLE
;
1110 #endif /* USB_STORAGE */