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