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