?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use a struct for the necessary status variables for rockblox. Will make dumping the...
[kugel-rb.git] / firmware / usbstack / usb_storage.c
blob73176ee93e495af4397320037d1d141d4a9aff09
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 #include "usb_class_driver.h"
26 //#define LOGF_ENABLE
27 #include "logf.h"
28 #include "storage.h"
29 #include "hotswap.h"
30 #include "disk.h"
31 /* Needed to get at the audio buffer */
32 #include "audio.h"
33 #include "usb_storage.h"
34
35
36 #ifdef USB_STORAGE
37
38 /* Enable the following define to export only the SD card slot. This
39 * is useful for USBCV MSC tests, as those are destructive.
40 * This won't work right if the device doesn't have a card slot.
41 */
42 //#define ONLY_EXPOSE_CARD_SLOT
43
44 #ifdef USB_USE_RAMDISK
45 #define RAMDISK_SIZE 2048
46 #endif
47
48 #define SECTOR_SIZE 512
49
50 /* the ARC driver currently supports up to 64k USB transfers. This is
51 * enough for efficient mass storage support, as commonly host OSes
52 * don't do larger SCSI transfers anyway, so larger USB transfers
53 * wouldn't buy us anything.
54 */
55 #define BUFFER_SIZE 65536
56
57 /* bulk-only class specific requests */
58 #define USB_BULK_RESET_REQUEST 0xff
59 #define USB_BULK_GET_MAX_LUN 0xfe
60
61 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */
62 #define DEVICE_REMOVABLE 0x80
63
64 #define CBW_SIGNATURE 0x43425355
65 #define CSW_SIGNATURE 0x53425355
66
67 #define SCSI_TEST_UNIT_READY 0x00
68 #define SCSI_INQUIRY 0x12
69 #define SCSI_MODE_SENSE_6 0x1a
70 #define SCSI_MODE_SENSE_10 0x5a
71 #define SCSI_REQUEST_SENSE 0x03
72 #define SCSI_ALLOW_MEDIUM_REMOVAL 0x1e
73 #define SCSI_READ_CAPACITY 0x25
74 #define SCSI_READ_FORMAT_CAPACITY 0x23
75 #define SCSI_READ_10 0x28
76 #define SCSI_WRITE_10 0x2a
77 #define SCSI_START_STOP_UNIT 0x1b
78 #define SCSI_REPORT_LUNS 0xa0
79
80 #define UMS_STATUS_GOOD 0x00
81 #define UMS_STATUS_FAIL 0x01
82
83 #define SENSE_NOT_READY 0x02
84 #define SENSE_MEDIUM_ERROR 0x03
85 #define SENSE_ILLEGAL_REQUEST 0x05
86 #define SENSE_UNIT_ATTENTION 0x06
87
88 #define ASC_MEDIUM_NOT_PRESENT 0x3a
89 #define ASC_INVALID_FIELD_IN_CBD 0x24
90 #define ASC_LBA_OUT_OF_RANGE 0x21
91 #define ASC_WRITE_ERROR 0x0C
92 #define ASC_READ_ERROR 0x11
93 #define ASC_NOT_READY 0x04
94 #define ASC_INVALID_COMMAND 0x20
95
96 #define ASCQ_BECOMING_READY 0x01
97
98 #define SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA 0x02000000
99
100 /* storage interface */
101
102 #define USB_SC_SCSI 0x06 /* Transparent */
103 #define USB_PROT_BULK 0x50 /* bulk only */
104
105 static struct usb_interface_descriptor __attribute__((aligned(2)))
106 interface_descriptor =
107 {
108 .bLength = sizeof(struct usb_interface_descriptor),
109 .bDescriptorType = USB_DT_INTERFACE,
110 .bInterfaceNumber = 0,
111 .bAlternateSetting = 0,
112 .bNumEndpoints = 2,
113 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
114 .bInterfaceSubClass = USB_SC_SCSI,
115 .bInterfaceProtocol = USB_PROT_BULK,
116 .iInterface = 0
117 };
118
119 static struct usb_endpoint_descriptor __attribute__((aligned(2)))
120 endpoint_descriptor =
121 {
122 .bLength = sizeof(struct usb_endpoint_descriptor),
123 .bDescriptorType = USB_DT_ENDPOINT,
124 .bEndpointAddress = 0,
125 .bmAttributes = USB_ENDPOINT_XFER_BULK,
126 .wMaxPacketSize = 0,
127 .bInterval = 0
128 };
129
130 struct inquiry_data {
131 unsigned char DeviceType;
132 unsigned char DeviceTypeModifier;
133 unsigned char Versions;
134 unsigned char Format;
135 unsigned char AdditionalLength;
136 unsigned char Reserved[2];
137 unsigned char Capability;
138 unsigned char VendorId[8];
139 unsigned char ProductId[16];
140 unsigned char ProductRevisionLevel[4];
141 } __attribute__ ((packed));
142
143 struct report_lun_data {
144 unsigned int lun_list_length;
145 unsigned int reserved1;
146 // TODO this should be cleaned up with the VOLUMES vs DRIVES mess
147 unsigned char luns[NUM_VOLUMES][8];
148 } __attribute__ ((packed));
149
150 struct sense_data {
151 unsigned char ResponseCode;
152 unsigned char Obsolete;
153 unsigned char fei_sensekey;
154 unsigned int Information;
155 unsigned char AdditionalSenseLength;
156 unsigned int CommandSpecificInformation;
157 unsigned char AdditionalSenseCode;
158 unsigned char AdditionalSenseCodeQualifier;
159 unsigned char FieldReplaceableUnitCode;
160 unsigned char SKSV;
161 unsigned short SenseKeySpecific;
162 } __attribute__ ((packed));
163
164 struct mode_sense_bdesc_longlba {
165 unsigned char num_blocks[8];
166 unsigned char reserved[4];
167 unsigned char block_size[4];
168 } __attribute__ ((packed));
169
170 struct mode_sense_bdesc_shortlba {
171 unsigned char density_code;
172 unsigned char num_blocks[3];
173 unsigned char reserved;
174 unsigned char block_size[3];
175 } __attribute__ ((packed));
176
177 struct mode_sense_data_10 {
178 unsigned short mode_data_length;
179 unsigned char medium_type;
180 unsigned char device_specific;
181 unsigned char longlba;
182 unsigned char reserved;
183 unsigned short block_descriptor_length;
184 struct mode_sense_bdesc_longlba block_descriptor;
185 } __attribute__ ((packed));
186
187 struct mode_sense_data_6 {
188 unsigned char mode_data_length;
189 unsigned char medium_type;
190 unsigned char device_specific;
191 unsigned char block_descriptor_length;
192 struct mode_sense_bdesc_shortlba block_descriptor;
193 } __attribute__ ((packed));
194
195 struct command_block_wrapper {
196 unsigned int signature;
197 unsigned int tag;
198 unsigned int data_transfer_length;
199 unsigned char flags;
200 unsigned char lun;
201 unsigned char command_length;
202 unsigned char command_block[16];
203 } __attribute__ ((packed));
204
205 struct command_status_wrapper {
206 unsigned int signature;
207 unsigned int tag;
208 unsigned int data_residue;
209 unsigned char status;
210 } __attribute__ ((packed));
211
212 struct capacity {
213 unsigned int block_count;
214 unsigned int block_size;
215 } __attribute__ ((packed));
216
217 struct format_capacity {
218 unsigned int following_length;
219 unsigned int block_count;
220 unsigned int block_size;
221 } __attribute__ ((packed));
222
223
224 static union {
225 unsigned char* transfer_buffer;
226 struct inquiry_data* inquiry;
227 struct capacity* capacity_data;
228 struct format_capacity* format_capacity_data;
229 struct sense_data *sense_data;
230 struct mode_sense_data_6 *ms_data_6;
231 struct mode_sense_data_10 *ms_data_10;
232 struct report_lun_data *lun_data;
233 struct command_status_wrapper* csw;
234 char *max_lun;
235 } tb;
236
237 static struct {
238 unsigned int sector;
239 unsigned int count;
240 unsigned int orig_count;
241 unsigned int cur_cmd;
242 unsigned int tag;
243 unsigned int lun;
244 unsigned char *data[2];
245 unsigned char data_select;
246 unsigned int last_result;
247 } cur_cmd;
248
249 static struct {
250 unsigned char sense_key;
251 unsigned char information;
252 unsigned char asc;
253 unsigned char ascq;
254 } cur_sense_data;
255
256 static void handle_scsi(struct command_block_wrapper* cbw);
257 static void send_csw(int status);
258 static void send_command_result(void *data,int size);
259 static void send_command_failed_result(void);
260 static void send_block_data(void *data,int size);
261 static void receive_block_data(void *data,int size);
262 static void fill_inquiry(IF_MV_NONVOID(int lun));
263 static void send_and_read_next(void);
264 static bool ejected[NUM_VOLUMES];
265 static bool locked[NUM_VOLUMES];
266
267 static int usb_interface;
268 static int ep_in, ep_out;
269
270 #ifdef USB_USE_RAMDISK
271 static unsigned char* ramdisk_buffer;
272 #endif
273
274 static enum {
275 WAITING_FOR_COMMAND,
276 SENDING_BLOCKS,
277 SENDING_RESULT,
278 SENDING_FAILED_RESULT,
279 RECEIVING_BLOCKS,
280 SENDING_CSW
281 } state = WAITING_FOR_COMMAND;
282
283 #ifdef TOSHIBA_GIGABEAT_S
284
285 /* The Gigabeat S factory partition table contains invalid values for the
286 "active" flag in the MBR. This prevents at least the Linux kernel from
287 accepting the partition table, so we fix it on-the-fly. */
288
289 static void fix_mbr(unsigned char* mbr)
290 {
291 unsigned char* p = mbr + 0x1be;
292
293 p[0x00] &= 0x80;
294 p[0x10] &= 0x80;
295 p[0x20] &= 0x80;
296 p[0x30] &= 0x80;
297 }
298 #endif
299
300 static bool check_disk_present(IF_MV_NONVOID(int volume))
301 {
302 #ifdef USB_USE_RAMDISK
303 return true;
304 #else
305 unsigned char sector[512];
306 return storage_read_sectors(volume,0,1,sector) == 0;
307 #endif
308 }
309
310 void usb_storage_try_release_storage(void)
311 {
312 /* Check if there is a connected drive left. If not,
313 release excusive access */
314 bool canrelease=true;
315 int i;
316 for(i=0;i<NUM_VOLUMES;i++) {
317 if(ejected[i]==false && locked[i]==true) {
318 canrelease=false;
319 break;
320 }
321 }
322 if(canrelease) {
323 logf("scsi release ata");
324 usb_release_exclusive_storage();
325 }
326 }
327
328 #ifdef HAVE_HOTSWAP
329 void usb_storage_notify_hotswap(int volume,bool inserted)
330 {
331 logf("notify %d",inserted);
332 if(inserted && check_disk_present(IF_MV(volume))) {
333 ejected[volume] = false;
334 }
335 else {
336 ejected[volume] = true;
337 /* If this happens while the device is locked, weird things may happen.
338 At least try to keep our state consistent */
339 locked[volume]=false;
340 }
341 }
342 #endif
343
344 /* called by usb_core_init() */
345 void usb_storage_init(void)
346 {
347 logf("usb_storage_init done");
348 }
349
350 int usb_storage_request_endpoints(struct usb_class_driver *drv)
351 {
352 ep_in = usb_core_request_endpoint(USB_ENDPOINT_XFER_BULK, USB_DIR_IN, drv);
353
354 if(ep_in<0)
355 return -1;
356
357 ep_out = usb_core_request_endpoint(USB_ENDPOINT_XFER_BULK, USB_DIR_OUT,
358 drv);
359
360 if(ep_out<0) {
361 usb_core_release_endpoint(ep_in);
362 return -1;
363 }
364
365 return 0;
366 }
367
368 int usb_storage_set_first_interface(int interface)
369 {
370 usb_interface = interface;
371 return interface + 1;
372 }
373
374 int usb_storage_get_config_descriptor(unsigned char *dest,int max_packet_size)
375 {
376 unsigned char *orig_dest = dest;
377
378 interface_descriptor.bInterfaceNumber = usb_interface;
379 PACK_DATA(dest, interface_descriptor);
380
381 endpoint_descriptor.wMaxPacketSize = max_packet_size;
382
383 endpoint_descriptor.bEndpointAddress = ep_in;
384 PACK_DATA(dest, endpoint_descriptor);
385
386 endpoint_descriptor.bEndpointAddress = ep_out;
387 PACK_DATA(dest, endpoint_descriptor);
388
389 return (dest - orig_dest);
390 }
391
392 void usb_storage_init_connection(void)
393 {
394 logf("ums: set config");
395 /* prime rx endpoint. We only need room for commands */
396 state = WAITING_FOR_COMMAND;
397
398 #if CONFIG_CPU == IMX31L || defined(CPU_TCC77X) || defined(CPU_TCC780X) || \
399 defined(BOOTLOADER) || CONFIG_CPU == DM320
400 static unsigned char _transfer_buffer[BUFFER_SIZE*2]
401 USB_DEVBSS_ATTR __attribute__((aligned(32)));
402 tb.transfer_buffer = (void *)_transfer_buffer;
403 #ifdef USB_USE_RAMDISK
404 static unsigned char _ramdisk_buffer[RAMDISK_SIZE*SECTOR_SIZE];
405 ramdisk_buffer = _ramdisk_buffer;
406 #endif
407 #else
408 /* TODO : check if bufsize is at least 32K ? */
409 size_t bufsize;
410 unsigned char * audio_buffer;
411
412 audio_buffer = audio_get_buffer(false,&bufsize);
413 tb.transfer_buffer =
414 (void *)UNCACHED_ADDR((unsigned int)(audio_buffer+31) & 0xffffffe0);
415 cpucache_invalidate();
416 #ifdef USB_USE_RAMDISK
417 ramdisk_buffer = tb.transfer_buffer + BUFFER_SIZE*2;
418 #endif
419 #endif
420 usb_drv_recv(ep_out, tb.transfer_buffer, 1024);
421
422 int i;
423 for(i=0;i<NUM_VOLUMES;i++) {
424 #ifdef TOSHIBA_GIGABEAT_S
425 /* As long as the Gigabeat S is a non-removable device, we need
426 to mark the device as locked to avoid usb_storage_try_release_ata()
427 to leave MSC mode while the device is in use */
428 locked[i] = true;
429 #else
430 locked[i] = false;
431 #endif
432 ejected[i] = !check_disk_present(IF_MV(i));
433 queue_broadcast(SYS_USB_LUN_LOCKED, (i<<16)+0);
434 }
435 }
436
437 void usb_storage_disconnect(void)
438 {
439 /* Empty for now */
440 }
441
442 /* called by usb_core_transfer_complete() */
443 void usb_storage_transfer_complete(int ep,int dir,int status,int length)
444 {
445 (void)ep;
446 struct command_block_wrapper* cbw = (void*)tb.transfer_buffer;
447
448 //logf("transfer result %X %d", status, length);
449 switch(state) {
450 case RECEIVING_BLOCKS:
451 if(dir==USB_DIR_IN) {
452 logf("IN received in RECEIVING");
453 }
454 logf("scsi write %d %d", cur_cmd.sector, cur_cmd.count);
455 if(status==0) {
456 if((unsigned int)length!=(SECTOR_SIZE* cur_cmd.count)
457 && (unsigned int)length!=BUFFER_SIZE) {
458 logf("unexpected length :%d",length);
459 }
460
461 unsigned int next_sector = cur_cmd.sector +
462 (BUFFER_SIZE/SECTOR_SIZE);
463 unsigned int next_count = cur_cmd.count -
464 MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE);
465 int next_select = !cur_cmd.data_select;
466
467 if(next_count!=0) {
468 /* Ask the host to send more, to the other buffer */
469 receive_block_data(cur_cmd.data[next_select],
470 MIN(BUFFER_SIZE,next_count*SECTOR_SIZE));
471 }
472
473 /* Now write the data that just came in, while the host is
474 sending the next bit */
475 #ifdef USB_USE_RAMDISK
476 memcpy(ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE,
477 cur_cmd.data[cur_cmd.data_select],
478 MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE);
479 #else
480 int result = storage_write_sectors(cur_cmd.lun,
481 cur_cmd.sector,
482 MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count),
483 cur_cmd.data[cur_cmd.data_select]);
484 if(result != 0) {
485 send_csw(UMS_STATUS_FAIL);
486 cur_sense_data.sense_key=SENSE_MEDIUM_ERROR;
487 cur_sense_data.asc=ASC_WRITE_ERROR;
488 cur_sense_data.ascq=0;
489 break;
490 }
491 #endif
492 if(next_count==0) {
493 send_csw(UMS_STATUS_GOOD);
494 }
495
496 /* Switch buffers for the next one */
497 cur_cmd.data_select=!cur_cmd.data_select;
498
499 cur_cmd.sector = next_sector;
500 cur_cmd.count = next_count;
501 }
502 else {
503 logf("Transfer failed %X",status);
504 send_csw(UMS_STATUS_FAIL);
505 /* TODO fill in cur_sense_data */
506 cur_sense_data.sense_key=0;
507 cur_sense_data.information=0;
508 cur_sense_data.asc=0;
509 cur_sense_data.ascq=0;
510 }
511 break;
512 case WAITING_FOR_COMMAND:
513 if(dir==USB_DIR_IN) {
514 logf("IN received in WAITING_FOR_COMMAND");
515 }
516 //logf("command received");
517 if(letoh32(cbw->signature) == CBW_SIGNATURE) {
518 handle_scsi(cbw);
519 }
520 else {
521 usb_drv_stall(ep_in, true,true);
522 usb_drv_stall(ep_out, true,false);
523 }
524 break;
525 case SENDING_CSW:
526 if(dir==USB_DIR_OUT) {
527 logf("OUT received in SENDING_CSW");
528 }
529 //logf("csw sent, now go back to idle");
530 state = WAITING_FOR_COMMAND;
531 #if 0
532 if(cur_cmd.cur_cmd == SCSI_WRITE_10)
533 {
534 queue_broadcast(SYS_USB_WRITE_DATA, (cur_cmd.lun<<16)+cur_cmd.orig_count);
535 }
536 else if(cur_cmd.cur_cmd == SCSI_READ_10)
537 {
538 queue_broadcast(SYS_USB_READ_DATA, (cur_cmd.lun<<16)+cur_cmd.orig_count);
539 }
540 #endif
541 usb_drv_recv(ep_out, tb.transfer_buffer, 1024);
542 break;
543 case SENDING_RESULT:
544 if(dir==USB_DIR_OUT) {
545 logf("OUT received in SENDING");
546 }
547 if(status==0) {
548 //logf("data sent, now send csw");
549 send_csw(UMS_STATUS_GOOD);
550 }
551 else {
552 logf("Transfer failed %X",status);
553 send_csw(UMS_STATUS_FAIL);
554 /* TODO fill in cur_sense_data */
555 cur_sense_data.sense_key=0;
556 cur_sense_data.information=0;
557 cur_sense_data.asc=0;
558 cur_sense_data.ascq=0;
559 }
560 break;
561 case SENDING_FAILED_RESULT:
562 if(dir==USB_DIR_OUT) {
563 logf("OUT received in SENDING");
564 }
565 send_csw(UMS_STATUS_FAIL);
566 break;
567 case SENDING_BLOCKS:
568 if(dir==USB_DIR_OUT) {
569 logf("OUT received in SENDING");
570 }
571 if(status==0) {
572 if(cur_cmd.count==0) {
573 //logf("data sent, now send csw");
574 send_csw(UMS_STATUS_GOOD);
575 }
576 else {
577 send_and_read_next();
578 }
579 }
580 else {
581 logf("Transfer failed %X",status);
582 send_csw(UMS_STATUS_FAIL);
583 /* TODO fill in cur_sense_data */
584 cur_sense_data.sense_key=0;
585 cur_sense_data.information=0;
586 cur_sense_data.asc=0;
587 cur_sense_data.ascq=0;
588 }
589 break;
590 }
591 }
592
593 /* called by usb_core_control_request() */
594 bool usb_storage_control_request(struct usb_ctrlrequest* req, unsigned char* dest)
595 {
596 bool handled = false;
597
598 (void)dest;
599 switch (req->bRequest) {
600 case USB_BULK_GET_MAX_LUN: {
601 #ifdef ONLY_EXPOSE_CARD_SLOT
602 *tb.max_lun = 0;
603 #else
604 *tb.max_lun = NUM_VOLUMES - 1;
605 #endif
606 logf("ums: getmaxlun");
607 usb_drv_send(EP_CONTROL, tb.max_lun, 1);
608 usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */
609 handled = true;
610 break;
611 }
612
613 case USB_BULK_RESET_REQUEST:
614 logf("ums: bulk reset");
615 state = WAITING_FOR_COMMAND;
616 /* UMS BOT 3.1 says The device shall preserve the value of its bulk
617 data toggle bits and endpoint STALL conditions despite
618 the Bulk-Only Mass Storage Reset. */
619 #if 0
620 usb_drv_reset_endpoint(ep_in, false);
621 usb_drv_reset_endpoint(ep_out, true);
622 #endif
623 usb_drv_send(EP_CONTROL, NULL, 0); /* ack */
624 handled = true;
625 break;
626 }
627
628 return handled;
629 }
630
631 static void send_and_read_next(void)
632 {
633 if(cur_cmd.last_result!=0) {
634 /* The last read failed. */
635 send_csw(UMS_STATUS_FAIL);
636 cur_sense_data.sense_key=SENSE_MEDIUM_ERROR;
637 cur_sense_data.asc=ASC_READ_ERROR;
638 cur_sense_data.ascq=0;
639 return;
640 }
641 send_block_data(cur_cmd.data[cur_cmd.data_select],
642 MIN(BUFFER_SIZE,cur_cmd.count*SECTOR_SIZE));
643
644 /* Switch buffers for the next one */
645 cur_cmd.data_select=!cur_cmd.data_select;
646
647 cur_cmd.sector+=(BUFFER_SIZE/SECTOR_SIZE);
648 cur_cmd.count-=MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE);
649
650 if(cur_cmd.count!=0) {
651 /* already read the next bit, so we can send it out immediately when the
652 * current transfer completes. */
653 #ifdef USB_USE_RAMDISK
654 memcpy(cur_cmd.data[cur_cmd.data_select],
655 ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE,
656 MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE);
657 #else
658 cur_cmd.last_result = storage_read_sectors(cur_cmd.lun,
659 cur_cmd.sector,
660 MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count),
661 cur_cmd.data[cur_cmd.data_select]);
662 #endif
663 }
664 }
665 /****************************************************************************/
666
667 static void handle_scsi(struct command_block_wrapper* cbw)
668 {
669 /* USB Mass Storage assumes LBA capability.
670 TODO: support 48-bit LBA */
671
672 struct storage_info info;
673 unsigned int length = cbw->data_transfer_length;
674 unsigned int block_size = 0;
675 unsigned int block_count = 0;
676 bool lun_present=true;
677 #ifdef ONLY_EXPOSE_CARD_SLOT
678 unsigned char lun = cbw->lun+1;
679 #else
680 unsigned char lun = cbw->lun;
681 #endif
682 unsigned int block_size_mult = 1;
683 storage_get_info(lun,&info);
684 #ifdef USB_USE_RAMDISK
685 block_size = SECTOR_SIZE;
686 block_count = RAMDISK_SIZE;
687 #else
688 block_size=info.sector_size;
689 block_count=info.num_sectors;
690 #endif
691
692 #ifdef HAVE_HOTSWAP
693 if(storage_removable(lun) && !storage_present(lun)) {
694 ejected[lun] = true;
695 }
696 #endif
697
698 if(ejected[lun])
699 lun_present = false;
700
701 #ifdef MAX_LOG_SECTOR_SIZE
702 block_size_mult = disk_sector_multiplier;
703 #endif
704
705 cur_cmd.tag = cbw->tag;
706 cur_cmd.lun = lun;
707 cur_cmd.cur_cmd = cbw->command_block[0];
708
709 switch (cbw->command_block[0]) {
710 case SCSI_TEST_UNIT_READY:
711 logf("scsi test_unit_ready %d",lun);
712 if(!usb_exclusive_storage()) {
713 send_csw(UMS_STATUS_FAIL);
714 cur_sense_data.sense_key=SENSE_NOT_READY;
715 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
716 cur_sense_data.ascq=0;
717 break;
718 }
719 if(lun_present) {
720 send_csw(UMS_STATUS_GOOD);
721 }
722 else {
723 send_csw(UMS_STATUS_FAIL);
724 cur_sense_data.sense_key=SENSE_NOT_READY;
725 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
726 cur_sense_data.ascq=0;
727 }
728 break;
729
730 case SCSI_REPORT_LUNS: {
731 logf("scsi report luns %d",lun);
732 int allocation_length=0;
733 int i;
734 allocation_length|=(cbw->command_block[6]<<24);
735 allocation_length|=(cbw->command_block[7]<<16);
736 allocation_length|=(cbw->command_block[8]<<8);
737 allocation_length|=(cbw->command_block[9]);
738 memset(tb.lun_data,0,sizeof(struct report_lun_data));
739 tb.lun_data->lun_list_length=htobe32(8*NUM_VOLUMES);
740 for(i=0;i<NUM_VOLUMES;i++)
741 {
742 #ifdef HAVE_HOTSWAP
743 if(storage_removable(i))
744 tb.lun_data->luns[i][1]=1;
745 else
746 #endif
747 tb.lun_data->luns[i][1]=0;
748 }
749 send_command_result(tb.lun_data,
750 MIN(sizeof(struct report_lun_data), length));
751 break;
752 }
753
754 case SCSI_INQUIRY:
755 logf("scsi inquiry %d",lun);
756 fill_inquiry(IF_MV(lun));
757 length = MIN(length, cbw->command_block[4]);
758 send_command_result(tb.inquiry,
759 MIN(sizeof(struct inquiry_data), length));
760 break;
761
762 case SCSI_REQUEST_SENSE: {
763 tb.sense_data->ResponseCode=0x70;/*current error*/
764 tb.sense_data->Obsolete=0;
765 tb.sense_data->fei_sensekey=cur_sense_data.sense_key&0x0f;
766 tb.sense_data->Information=cur_sense_data.information;
767 tb.sense_data->AdditionalSenseLength=10;
768 tb.sense_data->CommandSpecificInformation=0;
769 tb.sense_data->AdditionalSenseCode=cur_sense_data.asc;
770 tb.sense_data->AdditionalSenseCodeQualifier=cur_sense_data.ascq;
771 tb.sense_data->FieldReplaceableUnitCode=0;
772 tb.sense_data->SKSV=0;
773 tb.sense_data->SenseKeySpecific=0;
774 logf("scsi request_sense %d",lun);
775 send_command_result(tb.sense_data,
776 MIN(sizeof(struct sense_data), length));
777 break;
778 }
779
780 case SCSI_MODE_SENSE_10: {
781 if(!lun_present) {
782 send_command_failed_result();
783 cur_sense_data.sense_key=SENSE_NOT_READY;
784 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
785 cur_sense_data.ascq=0;
786 break;
787 }
788 /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/
789 unsigned char page_code = cbw->command_block[2] & 0x3f;
790 logf("scsi mode_sense_10 %d %X",lun,page_code);
791 switch(page_code) {
792 case 0x3f:
793 tb.ms_data_10->mode_data_length =
794 htobe16(sizeof(struct mode_sense_data_10)-2);
795 tb.ms_data_10->medium_type = 0;
796 tb.ms_data_10->device_specific = 0;
797 tb.ms_data_10->reserved = 0;
798 tb.ms_data_10->longlba = 1;
799 tb.ms_data_10->block_descriptor_length =
800 htobe16(sizeof(struct mode_sense_bdesc_longlba));
801
802 memset(tb.ms_data_10->block_descriptor.reserved,0,4);
803 memset(tb.ms_data_10->block_descriptor.num_blocks,0,8);
804
805 tb.ms_data_10->block_descriptor.num_blocks[4] =
806 ((block_count/block_size_mult) & 0xff000000)>>24;
807 tb.ms_data_10->block_descriptor.num_blocks[5] =
808 ((block_count/block_size_mult) & 0x00ff0000)>>16;
809 tb.ms_data_10->block_descriptor.num_blocks[6] =
810 ((block_count/block_size_mult) & 0x0000ff00)>>8;
811 tb.ms_data_10->block_descriptor.num_blocks[7] =
812 ((block_count/block_size_mult) & 0x000000ff);
813
814 tb.ms_data_10->block_descriptor.block_size[0] =
815 ((block_size*block_size_mult) & 0xff000000)>>24;
816 tb.ms_data_10->block_descriptor.block_size[1] =
817 ((block_size*block_size_mult) & 0x00ff0000)>>16;
818 tb.ms_data_10->block_descriptor.block_size[2] =
819 ((block_size*block_size_mult) & 0x0000ff00)>>8;
820 tb.ms_data_10->block_descriptor.block_size[3] =
821 ((block_size*block_size_mult) & 0x000000ff);
822 send_command_result(tb.ms_data_10,
823 MIN(sizeof(struct mode_sense_data_10), length));
824 break;
825 default:
826 send_command_failed_result();
827 cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST;
828 cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD;
829 cur_sense_data.ascq=0;
830 break;
831 }
832 break;
833 }
834
835 case SCSI_MODE_SENSE_6: {
836 if(!lun_present) {
837 send_command_failed_result();
838 cur_sense_data.sense_key=SENSE_NOT_READY;
839 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
840 cur_sense_data.ascq=0;
841 break;
842 }
843 /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/
844 unsigned char page_code = cbw->command_block[2] & 0x3f;
845 logf("scsi mode_sense_6 %d %X",lun,page_code);
846 switch(page_code) {
847 case 0x3f:
848 /* All supported pages. */
849 tb.ms_data_6->mode_data_length =
850 sizeof(struct mode_sense_data_6)-1;
851 tb.ms_data_6->medium_type = 0;
852 tb.ms_data_6->device_specific = 0;
853 tb.ms_data_6->block_descriptor_length =
854 sizeof(struct mode_sense_bdesc_shortlba);
855 tb.ms_data_6->block_descriptor.density_code = 0;
856 tb.ms_data_6->block_descriptor.reserved = 0;
857 if(block_count/block_size_mult > 0xffffff) {
858 tb.ms_data_6->block_descriptor.num_blocks[0] = 0xff;
859 tb.ms_data_6->block_descriptor.num_blocks[1] = 0xff;
860 tb.ms_data_6->block_descriptor.num_blocks[2] = 0xff;
861 }
862 else {
863 tb.ms_data_6->block_descriptor.num_blocks[0] =
864 ((block_count/block_size_mult) & 0xff0000)>>16;
865 tb.ms_data_6->block_descriptor.num_blocks[1] =
866 ((block_count/block_size_mult) & 0x00ff00)>>8;
867 tb.ms_data_6->block_descriptor.num_blocks[2] =
868 ((block_count/block_size_mult) & 0x0000ff);
869 }
870 tb.ms_data_6->block_descriptor.block_size[0] =
871 ((block_size*block_size_mult) & 0xff0000)>>16;
872 tb.ms_data_6->block_descriptor.block_size[1] =
873 ((block_size*block_size_mult) & 0x00ff00)>>8;
874 tb.ms_data_6->block_descriptor.block_size[2] =
875 ((block_size*block_size_mult) & 0x0000ff);
876 send_command_result(tb.ms_data_6,
877 MIN(sizeof(struct mode_sense_data_6), length));
878 break;
879 default:
880 send_command_failed_result();
881 cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST;
882 cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD;
883 cur_sense_data.ascq=0;
884 break;
885 }
886 break;
887 }
888
889 case SCSI_START_STOP_UNIT:
890 logf("scsi start_stop unit %d",lun);
891 if((cbw->command_block[4] & 0xf0) == 0) /*load/eject bit is valid*/
892 { /* Process start and eject bits */
893 logf("scsi load/eject");
894 if((cbw->command_block[4] & 0x01) == 0) /* Don't start */
895 {
896 if((cbw->command_block[4] & 0x02) != 0) /* eject */
897 {
898 logf("scsi eject");
899 ejected[lun]=true;
900 }
901 }
902 }
903 send_csw(UMS_STATUS_GOOD);
904 break;
905
906 case SCSI_ALLOW_MEDIUM_REMOVAL:
907 logf("scsi allow_medium_removal %d",lun);
908 if((cbw->command_block[4] & 0x03) == 0) {
909 locked[lun]=false;
910 queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+0);
911 }
912 else {
913 locked[lun]=true;
914 queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+1);
915 }
916 send_csw(UMS_STATUS_GOOD);
917 break;
918
919 case SCSI_READ_FORMAT_CAPACITY: {
920 logf("scsi read_format_capacity %d",lun);
921 if(lun_present) {
922 tb.format_capacity_data->following_length=htobe32(8);
923 /* "block count" actually means "number of last block" */
924 tb.format_capacity_data->block_count =
925 htobe32(block_count/block_size_mult - 1);
926 tb.format_capacity_data->block_size =
927 htobe32(block_size*block_size_mult);
928 tb.format_capacity_data->block_size |=
929 htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA);
930
931 send_command_result(tb.format_capacity_data,
932 MIN(sizeof(struct format_capacity), length));
933 }
934 else {
935 send_command_failed_result();
936 cur_sense_data.sense_key=SENSE_NOT_READY;
937 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
938 cur_sense_data.ascq=0;
939 }
940 break;
941 }
942
943 case SCSI_READ_CAPACITY: {
944 logf("scsi read_capacity %d",lun);
945
946 if(lun_present) {
947 /* "block count" actually means "number of last block" */
948 tb.capacity_data->block_count =
949 htobe32(block_count/block_size_mult - 1);
950 tb.capacity_data->block_size =
951 htobe32(block_size*block_size_mult);
952
953 send_command_result(tb.capacity_data,
954 MIN(sizeof(struct capacity), length));
955 }
956 else {
957 send_command_failed_result();
958 cur_sense_data.sense_key=SENSE_NOT_READY;
959 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
960 cur_sense_data.ascq=0;
961 }
962 break;
963 }
964
965 case SCSI_READ_10:
966 logf("scsi read10 %d",lun);
967 if(!lun_present) {
968 send_command_failed_result();
969 cur_sense_data.sense_key=SENSE_NOT_READY;
970 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
971 cur_sense_data.ascq=0;
972 break;
973 }
974 cur_cmd.data[0] = tb.transfer_buffer;
975 cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE];
976 cur_cmd.data_select=0;
977 cur_cmd.sector = block_size_mult *
978 (cbw->command_block[2] << 24 |
979 cbw->command_block[3] << 16 |
980 cbw->command_block[4] << 8 |
981 cbw->command_block[5] );
982 cur_cmd.count = block_size_mult *
983 (cbw->command_block[7] << 8 |
984 cbw->command_block[8]);
985 cur_cmd.orig_count = cur_cmd.count;
986
987 //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count);
988
989 if((cur_cmd.sector + cur_cmd.count) > block_count) {
990 send_csw(UMS_STATUS_FAIL);
991 cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST;
992 cur_sense_data.asc=ASC_LBA_OUT_OF_RANGE;
993 cur_sense_data.ascq=0;
994 }
995 else {
996 #ifdef USB_USE_RAMDISK
997 memcpy(cur_cmd.data[cur_cmd.data_select],
998 ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE,
999 MIN(BUFFER_SIZE/SECTOR_SIZE,cur_cmd.count)*SECTOR_SIZE);
1000 #else
1001 cur_cmd.last_result = storage_read_sectors(cur_cmd.lun,
1002 cur_cmd.sector,
1003 MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count),
1004 cur_cmd.data[cur_cmd.data_select]);
1005
1006 #ifdef TOSHIBA_GIGABEAT_S
1007 if(cur_cmd.sector == 0) {
1008 fix_mbr(cur_cmd.data[cur_cmd.data_select]);
1009 }
1010 #endif
1011 #endif
1012 send_and_read_next();
1013 }
1014 break;
1015
1016 case SCSI_WRITE_10:
1017 logf("scsi write10 %d",lun);
1018 if(!lun_present) {
1019 send_csw(UMS_STATUS_FAIL);
1020 cur_sense_data.sense_key=SENSE_NOT_READY;
1021 cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT;
1022 cur_sense_data.ascq=0;
1023 break;
1024 }
1025 cur_cmd.data[0] = tb.transfer_buffer;
1026 cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE];
1027 cur_cmd.data_select=0;
1028 cur_cmd.sector = block_size_mult *
1029 (cbw->command_block[2] << 24 |
1030 cbw->command_block[3] << 16 |
1031 cbw->command_block[4] << 8 |
1032 cbw->command_block[5] );
1033 cur_cmd.count = block_size_mult *
1034 (cbw->command_block[7] << 8 |
1035 cbw->command_block[8]);
1036 cur_cmd.orig_count = cur_cmd.count;
1037
1038 /* expect data */
1039 if((cur_cmd.sector + cur_cmd.count) > block_count) {
1040 send_csw(UMS_STATUS_FAIL);
1041 cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST;
1042 cur_sense_data.asc=ASC_LBA_OUT_OF_RANGE;
1043 cur_sense_data.ascq=0;
1044 }
1045 else {
1046 receive_block_data(cur_cmd.data[0],
1047 MIN(BUFFER_SIZE, cur_cmd.count*SECTOR_SIZE));
1048 }
1049 break;
1050
1051 default:
1052 logf("scsi unknown cmd %x",cbw->command_block[0x0]);
1053 send_csw(UMS_STATUS_FAIL);
1054 cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST;
1055 cur_sense_data.asc=ASC_INVALID_COMMAND;
1056 cur_sense_data.ascq=0;
1057 break;
1058 }
1059 }
1060
1061 static void send_block_data(void *data,int size)
1062 {
1063 usb_drv_send_nonblocking(ep_in, data,size);
1064 state = SENDING_BLOCKS;
1065 }
1066
1067 static void send_command_result(void *data,int size)
1068 {
1069 usb_drv_send_nonblocking(ep_in, data,size);
1070 state = SENDING_RESULT;
1071 }
1072
1073 static void send_command_failed_result(void)
1074 {
1075 usb_drv_send_nonblocking(ep_in, NULL, 0);
1076 state = SENDING_FAILED_RESULT;
1077 }
1078
1079 static void receive_block_data(void *data,int size)
1080 {
1081 usb_drv_recv(ep_out, data, size);
1082 state = RECEIVING_BLOCKS;
1083 }
1084
1085 static void send_csw(int status)
1086 {
1087 tb.csw->signature = htole32(CSW_SIGNATURE);
1088 tb.csw->tag = cur_cmd.tag;
1089 tb.csw->data_residue = 0;
1090 tb.csw->status = status;
1091
1092 usb_drv_send_nonblocking(ep_in, tb.csw,
1093 sizeof(struct command_status_wrapper));
1094 state = SENDING_CSW;
1095 //logf("CSW: %X",status);
1096
1097 if(status == UMS_STATUS_GOOD) {
1098 cur_sense_data.sense_key=0;
1099 cur_sense_data.information=0;
1100 cur_sense_data.asc=0;
1101 cur_sense_data.ascq=0;
1102 }
1103 }
1104
1105 static void copy_padded(char *dest, char *src, int len)
1106 {
1107 int i=0;
1108 while(src[i]!=0 && i<len)
1109 {
1110 dest[i]=src[i];
1111 i++;
1112 }
1113 while(i<len)
1114 {
1115 dest[i]=' ';
1116 i++;
1117 }
1118 }
1119
1120 /* build SCSI INQUIRY */
1121 static void fill_inquiry(IF_MV_NONVOID(int lun))
1122 {
1123 struct storage_info info;
1124 memset(tb.inquiry, 0, sizeof(struct inquiry_data));
1125 storage_get_info(lun,&info);
1126 copy_padded(tb.inquiry->VendorId,info.vendor,sizeof(tb.inquiry->VendorId));
1127 copy_padded(tb.inquiry->ProductId,info.product,sizeof(tb.inquiry->ProductId));
1128 copy_padded(tb.inquiry->ProductRevisionLevel,info.revision,sizeof(tb.inquiry->ProductRevisionLevel));
1129
1130 tb.inquiry->DeviceType = DIRECT_ACCESS_DEVICE;
1131 tb.inquiry->AdditionalLength = 0x1f;
1132 memset(tb.inquiry->Reserved, 0, 3);
1133 tb.inquiry->Versions = 4; /* SPC-2 */
1134 tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */
1135
1136 #ifdef TOSHIBA_GIGABEAT_S
1137 tb.inquiry->DeviceTypeModifier = 0;
1138 #else
1139 tb.inquiry->DeviceTypeModifier = DEVICE_REMOVABLE;
1140 #endif
1141 }
1142
1143 #endif /* USB_STORAGE */
My public Rockbox git repo