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