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