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