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