?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove .a files before running ar, to avoid problems with renamed files remaining...
[kugel-rb.git] / firmware / usbstack / usb_storage.c
blob5e97796db001287dadd8fb33e796b054ca006663
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2007 by Björn Stenberg
11 *
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.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21 #include "string.h"
22 #include "system.h"
23 #include "usb_core.h"
24 #include "usb_drv.h"
25 //#define LOGF_ENABLE
26 #include "logf.h"
27 #include "storage.h"
28 #include "hotswap.h"
29 #include "disk.h"
30 /* Needed to get at the audio buffer */
31 #include "audio.h"
32 #include "usb_storage.h"
33
34
35 #ifdef USB_STORAGE
36
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
41 */
42 #if (CONFIG_STORAGE & STORAGE_SD)
43 #define SERIALIZE_WRITES
44 #endif
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.
48 */
49 //#define ONLY_EXPOSE_CARD_SLOT
50
51 #ifdef USB_USE_RAMDISK
52 #define RAMDISK_SIZE 2048
53 #endif
54
55 #define SECTOR_SIZE 512
56
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.
60 */
61 #define BUFFER_SIZE 16384
62
63 /* bulk-only class specific requests */
64 #define USB_BULK_RESET_REQUEST 0xff
65 #define USB_BULK_GET_MAX_LUN 0xfe
66
67 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */
68 #define DEVICE_REMOVABLE 0x80
69
70 #define CBW_SIGNATURE 0x43425355
71 #define CSW_SIGNATURE 0x53425355
72
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
85
86 #define UMS_STATUS_GOOD 0x00
87 #define UMS_STATUS_FAIL 0x01
88
89 #define SENSE_NOT_READY 0x02
90 #define SENSE_MEDIUM_ERROR 0x03
91 #define SENSE_ILLEGAL_REQUEST 0x05
92 #define SENSE_UNIT_ATTENTION 0x06
93
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
101
102 #define SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA 0x02000000
103
104 /* storage interface */
105
106 #define USB_SC_SCSI 0x06 /* Transparent */
107 #define USB_PROT_BULK 0x50 /* bulk only */
108
109 static struct usb_interface_descriptor __attribute__((aligned(2)))
110 interface_descriptor =
111 {
112 .bLength = sizeof(struct usb_interface_descriptor),
113 .bDescriptorType = USB_DT_INTERFACE,
114 .bInterfaceNumber = 0,
115 .bAlternateSetting = 0,
116 .bNumEndpoints = 2,
117 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
118 .bInterfaceSubClass = USB_SC_SCSI,
119 .bInterfaceProtocol = USB_PROT_BULK,
120 .iInterface = 0
121 };
122
123 static struct usb_endpoint_descriptor __attribute__((aligned(2)))
124 endpoint_descriptor =
125 {
126 .bLength = sizeof(struct usb_endpoint_descriptor),
127 .bDescriptorType = USB_DT_ENDPOINT,
128 .bEndpointAddress = 0,
129 .bmAttributes = USB_ENDPOINT_XFER_BULK,
130 .wMaxPacketSize = 0,
131 .bInterval = 0
132 };
133
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));
146
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));
153
154 struct sense_data {
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;
164 unsigned char SKSV;
165 unsigned short SenseKeySpecific;
166 } __attribute__ ((packed));
167
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));
173
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));
180
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));
190
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));
198
199 struct command_block_wrapper {
200 unsigned int signature;
201 unsigned int tag;
202 unsigned int data_transfer_length;
203 unsigned char flags;
204 unsigned char lun;
205 unsigned char command_length;
206 unsigned char command_block[16];
207 } __attribute__ ((packed));
208
209 struct command_status_wrapper {
210 unsigned int signature;
211 unsigned int tag;
212 unsigned int data_residue;
213 unsigned char status;
214 } __attribute__ ((packed));
215
216 struct capacity {
217 unsigned int block_count;
218 unsigned int block_size;
219 } __attribute__ ((packed));
220
221 struct format_capacity {
222 unsigned int following_length;
223 unsigned int block_count;
224 unsigned int block_size;
225 } __attribute__ ((packed));
226
227
228 static union {
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;
238 char *max_lun;
239 } tb;
240
241 static struct {
242 unsigned int sector;
243 unsigned int count;
244 unsigned int tag;
245 unsigned int lun;
246 unsigned char *data[2];
247 unsigned char data_select;
248 unsigned int last_result;
249 } cur_cmd;
250
251 static struct {
252 unsigned char sense_key;
253 unsigned char information;
254 unsigned char asc;
255 unsigned char ascq;
256 } cur_sense_data;
257
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];
267
268 static int usb_interface;
269 static int ep_in, ep_out;
270
271 #ifdef USB_USE_RAMDISK
272 static unsigned char* ramdisk_buffer;
273 #endif
274
275 static enum {
276 WAITING_FOR_COMMAND,
277 SENDING_BLOCKS,
278 SENDING_RESULT,
279 SENDING_FAILED_RESULT,
280 RECEIVING_BLOCKS,
281 SENDING_CSW
282 } state = WAITING_FOR_COMMAND;
283
284 static bool check_disk_present(IF_MV_NONVOID(int volume))
285 {
286 #ifdef USB_USE_RAMDISK
287 return true;
288 #else
289 unsigned char sector[512];
290 return storage_read_sectors(volume,0,1,sector) == 0;
291 #endif
292 }
293
294 static void try_release_ata(void)
295 {
296 /* Check if there is a connected drive left. If not,
297 release excusive access */
298 bool canrelease=true;
299 int i;
300 for(i=0;i<NUM_VOLUMES;i++) {
301 if(ejected[i]==false){
302 canrelease=false;
303 break;
304 }
305 }
306 if(canrelease) {
307 logf("scsi release ata");
308 usb_release_exclusive_ata();
309 }
310 }
311
312 #ifdef HAVE_HOTSWAP
313 void usb_storage_notify_hotswap(int volume,bool inserted)
314 {
315 logf("notify %d",inserted);
316 if(inserted && check_disk_present(IF_MV(volume))) {
317 ejected[volume] = false;
318 }
319 else {
320 ejected[volume] = true;
321 try_release_ata();
322 }
323
324 }
325 #endif
326
327 void usb_storage_reconnect(void)
328 {
329 int i;
330 if(usb_core_driver_enabled(USB_DRIVER_MASS_STORAGE)
331 && usb_inserted()) {
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();
336 }
337 }
338
339 /* called by usb_code_init() */
340 void usb_storage_init(void)
341 {
342 int i;
343 for(i=0;i<NUM_VOLUMES;i++) {
344 ejected[i] = !check_disk_present(IF_MV(i));
345 }
346 logf("usb_storage_init done");
347 }
348
349 int usb_storage_request_endpoints(struct usb_class_driver *drv)
350 {
351 ep_in = usb_core_request_endpoint(USB_DIR_IN, drv);
352
353 if (ep_in < 0)
354 return -1;
355
356 ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv);
357
358 if (ep_out < 0) {
359 usb_core_release_endpoint(ep_in);
360 return -1;
361 }
362
363 return 0;
364 }
365
366 int usb_storage_set_first_interface(int interface)
367 {
368 usb_interface = interface;
369 return interface + 1;
370 }
371
372 int usb_storage_get_config_descriptor(unsigned char *dest,int max_packet_size)
373 {
374 endpoint_descriptor.wMaxPacketSize=max_packet_size;
375 interface_descriptor.bInterfaceNumber=usb_interface;
376
377 memcpy(dest,&interface_descriptor,
378 sizeof(struct usb_interface_descriptor));
379 dest+=sizeof(struct usb_interface_descriptor);
380
381 endpoint_descriptor.bEndpointAddress = ep_in;
382 memcpy(dest,&endpoint_descriptor,
383 sizeof(struct usb_endpoint_descriptor));
384 dest+=sizeof(struct usb_endpoint_descriptor);
385
386 endpoint_descriptor.bEndpointAddress = ep_out;
387 memcpy(dest,&endpoint_descriptor,
388 sizeof(struct usb_endpoint_descriptor));
389
390 return sizeof(struct usb_interface_descriptor) +
391 2*sizeof(struct usb_endpoint_descriptor);
392 }
393
394 void usb_storage_init_connection(void)
395 {
396 logf("ums: set config");
397 /* prime rx endpoint. We only need room for commands */
398 state = WAITING_FOR_COMMAND;
399
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;
405 #else
406 /* TODO : check if bufsize is at least 32K ? */
407 size_t bufsize;
408 unsigned char * audio_buffer;
409
410 audio_buffer = audio_get_buffer(false,&bufsize);
411 tb.transfer_buffer =
412 (void *)UNCACHED_ADDR((unsigned int)(audio_buffer + 31) & 0xffffffe0);
413 invalidate_icache();
414 #ifdef USB_USE_RAMDISK
415 ramdisk_buffer = tb.transfer_buffer + BUFFER_SIZE*2;
416 #endif
417 #endif
418 usb_drv_recv(ep_out, tb.transfer_buffer, 1024);
419 }
420
421 /* called by usb_core_transfer_complete() */
422 void usb_storage_transfer_complete(int ep,int dir,int status,int length)
423 {
424 (void)ep;
425 struct command_block_wrapper* cbw = (void*)tb.transfer_buffer;
426
427 //logf("transfer result %X %d", status, length);
428 switch(state) {
429 case RECEIVING_BLOCKS:
430 if(dir==USB_DIR_IN) {
431 logf("IN received in RECEIVING");
432 }
433 logf("scsi write %d %d", cur_cmd.sector, cur_cmd.count);
434 if(status==0) {
435 if((unsigned int)length!=(SECTOR_SIZE*cur_cmd.count)
436 && (unsigned int)length!=BUFFER_SIZE) {
437 logf("unexpected length :%d",length);
438 }
439
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;
445
446 #ifndef SERIALIZE_WRITES
447 if(next_count!=0) {
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));
451 }
452 #endif
453
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);
460 #else
461 int result = storage_write_sectors(cur_cmd.lun,
462 cur_cmd.sector,
463 MIN(BUFFER_SIZE/SECTOR_SIZE,
464 cur_cmd.count),
465 cur_cmd.data[cur_cmd.data_select]);
466 if(result != 0) {
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;
471 break;
472 }
473 #endif
474 #ifdef SERIALIZE_WRITES
475 if(next_count!=0) {
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));
479 }
480 #endif
481
482 if(next_count==0) {
483 send_csw(UMS_STATUS_GOOD);
484 }
485
486 /* Switch buffers for the next one */
487 cur_cmd.data_select=!cur_cmd.data_select;
488
489 cur_cmd.sector = next_sector;
490 cur_cmd.count = next_count;
491
492 }
493 else {
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;
501 }
502 break;
503 case WAITING_FOR_COMMAND:
504 if(dir==USB_DIR_IN) {
505 logf("IN received in WAITING_FOR_COMMAND");
506 }
507 //logf("command received");
508 if(letoh32(cbw->signature) == CBW_SIGNATURE){
509 handle_scsi(cbw);
510 }
511 else {
512 usb_drv_stall(ep_in, true,true);
513 usb_drv_stall(ep_out, true,false);
514 }
515 break;
516 case SENDING_CSW:
517 if(dir==USB_DIR_OUT) {
518 logf("OUT received in SENDING_CSW");
519 }
520 //logf("csw sent, now go back to idle");
521 state = WAITING_FOR_COMMAND;
522 usb_drv_recv(ep_out, tb.transfer_buffer, 1024);
523 break;
524 case SENDING_RESULT:
525 if(dir==USB_DIR_OUT) {
526 logf("OUT received in SENDING");
527 }
528 if(status==0) {
529 //logf("data sent, now send csw");
530 send_csw(UMS_STATUS_GOOD);
531 }
532 else {
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;
540 }
541 break;
542 case SENDING_FAILED_RESULT:
543 if(dir==USB_DIR_OUT) {
544 logf("OUT received in SENDING");
545 }
546 send_csw(UMS_STATUS_FAIL);
547 break;
548 case SENDING_BLOCKS:
549 if(dir==USB_DIR_OUT) {
550 logf("OUT received in SENDING");
551 }
552 if(status==0) {
553 if(cur_cmd.count==0) {
554 //logf("data sent, now send csw");
555 send_csw(UMS_STATUS_GOOD);
556 }
557 else {
558 send_and_read_next();
559 }
560 }
561 else {
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;
569 }
570 break;
571 }
572 }
573
574 /* called by usb_core_control_request() */
575 bool usb_storage_control_request(struct usb_ctrlrequest* req)
576 {
577 bool handled = false;
578
579
580 switch (req->bRequest) {
581 case USB_BULK_GET_MAX_LUN: {
582 #ifdef ONLY_EXPOSE_CARD_SLOT
583 *tb.max_lun = 0;
584 #else
585 *tb.max_lun = NUM_VOLUMES - 1;
586 #endif
587 logf("ums: getmaxlun");
588 usb_drv_send(EP_CONTROL, tb.max_lun, 1);
589 usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */
590 handled = true;
591 break;
592 }
593
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. */
600 #if 0
601 usb_drv_reset_endpoint(ep_in, false);
602 usb_drv_reset_endpoint(ep_out, true);
603 #endif
604
605 usb_drv_send(EP_CONTROL, NULL, 0); /* ack */
606 handled = true;
607 break;
608 }
609
610 return handled;
611 }
612
613 static void send_and_read_next(void)
614 {
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;
621 return;
622 }
623 send_block_data(cur_cmd.data[cur_cmd.data_select],
624 MIN(BUFFER_SIZE,cur_cmd.count*SECTOR_SIZE));
625
626 /* Switch buffers for the next one */
627 cur_cmd.data_select=!cur_cmd.data_select;
628
629 cur_cmd.sector+=(BUFFER_SIZE/SECTOR_SIZE);
630 cur_cmd.count-=MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE);
631
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);
639 #else
640 cur_cmd.last_result = storage_read_sectors(cur_cmd.lun,
641 cur_cmd.sector,
642 MIN(BUFFER_SIZE/SECTOR_SIZE,
643 cur_cmd.count),
644 cur_cmd.data[cur_cmd.data_select]);
645 #endif
646 }
647 }
648 /****************************************************************************/
649
650 static void handle_scsi(struct command_block_wrapper* cbw)
651 {
652 /* USB Mass Storage assumes LBA capability.
653 TODO: support 48-bit LBA */
654
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;
662 #else
663 unsigned char lun = cbw->lun;
664 #endif
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;
670 #else
671 block_size=info.sector_size;
672 block_count=info.num_sectors;
673 #endif
674
675 #ifdef HAVE_HOTSWAP
676 if(storage_removable(lun) && !storage_present(lun)) {
677 ejected[lun] = true;
678 try_release_ata();
679 }
680 #endif
681
682 if(ejected[lun])
683 lun_present = false;
684
685 #ifdef MAX_LOG_SECTOR_SIZE
686 block_size_mult = disk_sector_multiplier;
687 #endif
688
689 cur_cmd.tag = cbw->tag;
690 cur_cmd.lun = lun;
691
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;
700 break;
701 }
702 if(lun_present) {
703 send_csw(UMS_STATUS_GOOD);
704 }
705 else {
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;
710 }
711 break;
712
713 case SCSI_REPORT_LUNS: {
714 logf("scsi inquiry %d",lun);
715 int allocation_length=0;
716 int i;
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++)
724 {
725 #ifdef HAVE_HOTSWAP
726 if(storage_removable(i))
727 tb.lun_data->luns[i][1]=1;
728 else
729 #endif
730 tb.lun_data->luns[i][1]=0;
731 }
732 send_command_result(tb.lun_data,
733 MIN(sizeof(struct report_lun_data), length));
734 break;
735 }
736
737 case SCSI_INQUIRY:
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));
743 break;
744
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));
759 break;
760 }
761
762 case SCSI_MODE_SENSE_10: {
763 if(! lun_present) {
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;
768 break;
769 }
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);
773 switch(page_code) {
774 case 0x3f:
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));
783
784 memset(tb.ms_data_10->block_descriptor.reserved,0,4);
785 memset(tb.ms_data_10->block_descriptor.num_blocks,0,8);
786
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);
795
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));
806 break;
807 default:
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;
812 break;
813 }
814 break;
815 }
816 case SCSI_MODE_SENSE_6: {
817 if(! lun_present) {
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;
822 break;
823 }
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);
827 switch(page_code) {
828 case 0x3f:
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;
842 }
843 else {
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);
850 }
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));
859 break;
860 default:
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;
865 break;
866 }
867 break;
868 }
869
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 */
876 {
877 if((cbw->command_block[4] & 0x02) != 0) /* eject */
878 {
879 logf("scsi eject");
880 ejected[lun]=true;
881 try_release_ata();
882 }
883 }
884 }
885 send_csw(UMS_STATUS_GOOD);
886 break;
887
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);
892 break;
893 case SCSI_READ_FORMAT_CAPACITY: {
894 logf("scsi read_format_capacity %d",lun);
895 if(lun_present) {
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);
904
905 send_command_result(tb.format_capacity_data,
906 MIN(sizeof(struct format_capacity), length));
907 }
908 else
909 {
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;
914 }
915 break;
916 }
917 case SCSI_READ_CAPACITY: {
918 logf("scsi read_capacity %d",lun);
919
920 if(lun_present) {
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);
926
927 send_command_result(tb.capacity_data,
928 MIN(sizeof(struct capacity), length));
929 }
930 else
931 {
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;
936 }
937 break;
938 }
939
940 case SCSI_READ_10:
941 logf("scsi read10 %d",lun);
942 if(! lun_present) {
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;
947 break;
948 }
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]);
960
961 //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count);
962
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;
968 }
969 else {
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);
974 #else
975 cur_cmd.last_result = storage_read_sectors(cur_cmd.lun,
976 cur_cmd.sector,
977 MIN(BUFFER_SIZE/SECTOR_SIZE,
978 cur_cmd.count),
979 cur_cmd.data[cur_cmd.data_select]);
980 #endif
981 send_and_read_next();
982 }
983 break;
984
985 case SCSI_WRITE_10:
986 logf("scsi write10 %d",lun);
987 if(! lun_present) {
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;
992 break;
993 }
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]);
1005 /* expect data */
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;
1011 }
1012 else {
1013 receive_block_data(cur_cmd.data[0],
1014 MIN(BUFFER_SIZE,
1015 cur_cmd.count*SECTOR_SIZE));
1016 }
1017
1018 break;
1019
1020 default:
1021 logf("scsi unknown cmd %x",cbw->command_block[0x0]);
1022 usb_drv_stall(ep_in, true,true);
1023 send_csw(UMS_STATUS_FAIL);
1024 break;
1025 }
1026 }
1027
1028 static void send_block_data(void *data,int size)
1029 {
1030 usb_drv_send_nonblocking(ep_in, data,size);
1031 state = SENDING_BLOCKS;
1032 }
1033
1034 static void send_command_result(void *data,int size)
1035 {
1036 usb_drv_send_nonblocking(ep_in, data,size);
1037 state = SENDING_RESULT;
1038 }
1039
1040 static void send_command_failed_result(void)
1041 {
1042 usb_drv_send_nonblocking(ep_in, NULL, 0);
1043 state = SENDING_FAILED_RESULT;
1044 }
1045
1046 static void receive_block_data(void *data,int size)
1047 {
1048 usb_drv_recv(ep_out, data, size);
1049 state = RECEIVING_BLOCKS;
1050 }
1051
1052 static void send_csw(int status)
1053 {
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;
1058
1059 usb_drv_send_nonblocking(ep_in, tb.csw,
1060 sizeof(struct command_status_wrapper));
1061 state = SENDING_CSW;
1062 //logf("CSW: %X",status);
1063
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;
1069 }
1070 }
1071
1072 static void copy_padded(char *dest, char *src, int len)
1073 {
1074 int i=0;
1075 while(src[i]!=0 && i<len)
1076 {
1077 dest[i]=src[i];
1078 i++;
1079 }
1080 while(i<len)
1081 {
1082 dest[i]=' ';
1083 i++;
1084 }
1085 }
1086
1087 /* build SCSI INQUIRY */
1088 static void fill_inquiry(IF_MV_NONVOID(int lun))
1089 {
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));
1096
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 */
1102
1103 #ifdef TOSHIBA_GIGABEAT_S
1104 tb.inquiry->DeviceTypeModifier = 0;
1105 #else
1106 tb.inquiry->DeviceTypeModifier = DEVICE_REMOVABLE;
1107 #endif
1108 }
1109
1110 #endif /* USB_STORAGE */
My public Rockbox git repo