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