diff options
Diffstat (limited to 'firmware/usbstack')
-rw-r--r-- | firmware/usbstack/usb_charging_only.c | 1 | ||||
-rw-r--r-- | firmware/usbstack/usb_core.c | 65 | ||||
-rw-r--r-- | firmware/usbstack/usb_serial.c | 17 | ||||
-rw-r--r-- | firmware/usbstack/usb_storage.c | 191 |
4 files changed, 128 insertions, 146 deletions
diff --git a/firmware/usbstack/usb_charging_only.c b/firmware/usbstack/usb_charging_only.c index 145d0f684c..3cbc4c3e96 100644 --- a/firmware/usbstack/usb_charging_only.c +++ b/firmware/usbstack/usb_charging_only.c | |||
@@ -46,7 +46,6 @@ static struct usb_interface_descriptor __attribute__((aligned(2))) | |||
46 | .iInterface = 0 | 46 | .iInterface = 0 |
47 | }; | 47 | }; |
48 | 48 | ||
49 | |||
50 | static int usb_interface; | 49 | static int usb_interface; |
51 | 50 | ||
52 | int usb_charging_only_request_endpoints(struct usb_class_driver *drv) | 51 | int usb_charging_only_request_endpoints(struct usb_class_driver *drv) |
diff --git a/firmware/usbstack/usb_core.c b/firmware/usbstack/usb_core.c index 3f67407c72..f6373b8945 100644 --- a/firmware/usbstack/usb_core.c +++ b/firmware/usbstack/usb_core.c | |||
@@ -88,7 +88,7 @@ static const struct usb_device_descriptor __attribute__((aligned(2))) | |||
88 | } ; | 88 | } ; |
89 | 89 | ||
90 | static struct usb_config_descriptor __attribute__((aligned(2))) | 90 | static struct usb_config_descriptor __attribute__((aligned(2))) |
91 | config_descriptor = | 91 | config_descriptor = |
92 | { | 92 | { |
93 | .bLength = sizeof(struct usb_config_descriptor), | 93 | .bLength = sizeof(struct usb_config_descriptor), |
94 | .bDescriptorType = USB_DT_CONFIG, | 94 | .bDescriptorType = USB_DT_CONFIG, |
@@ -100,7 +100,6 @@ static struct usb_config_descriptor __attribute__((aligned(2))) | |||
100 | .bMaxPower = (USB_MAX_CURRENT+1) / 2, /* In 2mA units */ | 100 | .bMaxPower = (USB_MAX_CURRENT+1) / 2, /* In 2mA units */ |
101 | }; | 101 | }; |
102 | 102 | ||
103 | |||
104 | static const struct usb_qualifier_descriptor __attribute__((aligned(2))) | 103 | static const struct usb_qualifier_descriptor __attribute__((aligned(2))) |
105 | qualifier_descriptor = | 104 | qualifier_descriptor = |
106 | { | 105 | { |
@@ -242,7 +241,6 @@ static void usb_core_control_request_handler(struct usb_ctrlrequest* req); | |||
242 | 241 | ||
243 | static unsigned char response_data[256] USB_DEVBSS_ATTR; | 242 | static unsigned char response_data[256] USB_DEVBSS_ATTR; |
244 | 243 | ||
245 | |||
246 | static short hex[16] = {'0','1','2','3','4','5','6','7', | 244 | static short hex[16] = {'0','1','2','3','4','5','6','7', |
247 | '8','9','A','B','C','D','E','F'}; | 245 | '8','9','A','B','C','D','E','F'}; |
248 | #ifdef IPOD_ARCH | 246 | #ifdef IPOD_ARCH |
@@ -357,15 +355,15 @@ void usb_core_exit(void) | |||
357 | for(i=0;i<USB_NUM_DRIVERS;i++) { | 355 | for(i=0;i<USB_NUM_DRIVERS;i++) { |
358 | if(drivers[i].enabled && drivers[i].disconnect != NULL) | 356 | if(drivers[i].enabled && drivers[i].disconnect != NULL) |
359 | { | 357 | { |
360 | drivers[i].disconnect (); | 358 | drivers[i].disconnect(); |
361 | drivers[i].enabled = false; | 359 | drivers[i].enabled = false; |
362 | } | 360 | } |
363 | } | 361 | } |
364 | 362 | ||
365 | if (initialized) { | 363 | if (initialized) { |
366 | usb_drv_exit(); | 364 | usb_drv_exit(); |
365 | initialized = false; | ||
367 | } | 366 | } |
368 | initialized = false; | ||
369 | usb_state = DEFAULT; | 367 | usb_state = DEFAULT; |
370 | logf("usb_core_exit() finished"); | 368 | logf("usb_core_exit() finished"); |
371 | } | 369 | } |
@@ -373,6 +371,7 @@ void usb_core_exit(void) | |||
373 | void usb_core_handle_transfer_completion( | 371 | void usb_core_handle_transfer_completion( |
374 | struct usb_transfer_completion_event_data* event) | 372 | struct usb_transfer_completion_event_data* event) |
375 | { | 373 | { |
374 | completion_handler_t handler; | ||
376 | int ep = event->endpoint; | 375 | int ep = event->endpoint; |
377 | 376 | ||
378 | switch(ep) { | 377 | switch(ep) { |
@@ -382,9 +381,9 @@ void usb_core_handle_transfer_completion( | |||
382 | (struct usb_ctrlrequest*)event->data); | 381 | (struct usb_ctrlrequest*)event->data); |
383 | break; | 382 | break; |
384 | default: | 383 | default: |
385 | if(ep_data[ep].completion_handler[event->dir>>7] != NULL) | 384 | handler = ep_data[ep].completion_handler[event->dir>>7]; |
386 | ep_data[ep].completion_handler[event->dir>>7](ep,event->dir, | 385 | if(handler != NULL) |
387 | event->status,event->length); | 386 | handler(ep,event->dir,event->status,event->length); |
388 | break; | 387 | break; |
389 | } | 388 | } |
390 | } | 389 | } |
@@ -403,8 +402,7 @@ bool usb_core_any_exclusive_storage(void) | |||
403 | { | 402 | { |
404 | int i; | 403 | int i; |
405 | for(i=0;i<USB_NUM_DRIVERS;i++) { | 404 | for(i=0;i<USB_NUM_DRIVERS;i++) { |
406 | if(drivers[i].enabled && | 405 | if(drivers[i].enabled && drivers[i].needs_exclusive_storage) |
407 | drivers[i].needs_exclusive_storage) | ||
408 | { | 406 | { |
409 | return true; | 407 | return true; |
410 | } | 408 | } |
@@ -418,8 +416,7 @@ void usb_core_hotswap_event(int volume,bool inserted) | |||
418 | { | 416 | { |
419 | int i; | 417 | int i; |
420 | for(i=0;i<USB_NUM_DRIVERS;i++) { | 418 | for(i=0;i<USB_NUM_DRIVERS;i++) { |
421 | if(drivers[i].enabled && | 419 | if(drivers[i].enabled && drivers[i].notify_hotswap!=NULL) |
422 | drivers[i].notify_hotswap!=NULL) | ||
423 | { | 420 | { |
424 | drivers[i].notify_hotswap(volume,inserted); | 421 | drivers[i].notify_hotswap(volume,inserted); |
425 | } | 422 | } |
@@ -481,7 +478,7 @@ static void allocate_interfaces_and_endpoints(void) | |||
481 | usb_drv_release_endpoint(i | USB_DIR_IN); | 478 | usb_drv_release_endpoint(i | USB_DIR_IN); |
482 | } | 479 | } |
483 | 480 | ||
484 | for(i=0; i < USB_NUM_DRIVERS; i++) { | 481 | for(i=0;i<USB_NUM_DRIVERS;i++) { |
485 | if(drivers[i].enabled) { | 482 | if(drivers[i].enabled) { |
486 | drivers[i].first_interface = interface; | 483 | drivers[i].first_interface = interface; |
487 | 484 | ||
@@ -762,19 +759,23 @@ void usb_core_bus_reset(void) | |||
762 | /* called by usb_drv_transfer_completed() */ | 759 | /* called by usb_drv_transfer_completed() */ |
763 | void usb_core_transfer_complete(int endpoint, int dir, int status,int length) | 760 | void usb_core_transfer_complete(int endpoint, int dir, int status,int length) |
764 | { | 761 | { |
762 | struct usb_transfer_completion_event_data *completion_event; | ||
763 | |||
765 | switch (endpoint) { | 764 | switch (endpoint) { |
766 | case EP_CONTROL: | 765 | case EP_CONTROL: |
767 | /* already handled */ | 766 | /* already handled */ |
768 | break; | 767 | break; |
769 | 768 | ||
770 | default: | 769 | default: |
771 | ep_data[endpoint].completion_event.endpoint=endpoint; | 770 | completion_event = &ep_data[endpoint].completion_event; |
772 | ep_data[endpoint].completion_event.dir=dir; | 771 | |
773 | ep_data[endpoint].completion_event.data=0; | 772 | completion_event->endpoint=endpoint; |
774 | ep_data[endpoint].completion_event.status=status; | 773 | completion_event->dir=dir; |
775 | ep_data[endpoint].completion_event.length=length; | 774 | completion_event->data=0; |
775 | completion_event->status=status; | ||
776 | completion_event->length=length; | ||
776 | /* All other endoints. Let the thread deal with it */ | 777 | /* All other endoints. Let the thread deal with it */ |
777 | usb_signal_transfer_completion(&ep_data[endpoint].completion_event); | 778 | usb_signal_transfer_completion(completion_event); |
778 | break; | 779 | break; |
779 | } | 780 | } |
780 | } | 781 | } |
@@ -782,18 +783,21 @@ void usb_core_transfer_complete(int endpoint, int dir, int status,int length) | |||
782 | /* called by usb_drv_int() */ | 783 | /* called by usb_drv_int() */ |
783 | void usb_core_control_request(struct usb_ctrlrequest* req) | 784 | void usb_core_control_request(struct usb_ctrlrequest* req) |
784 | { | 785 | { |
785 | ep_data[0].completion_event.endpoint=0; | 786 | struct usb_transfer_completion_event_data *completion_event = |
786 | ep_data[0].completion_event.dir=0; | 787 | &ep_data[0].completion_event; |
787 | ep_data[0].completion_event.data=(void *)req; | 788 | |
788 | ep_data[0].completion_event.status=0; | 789 | completion_event->endpoint=0; |
789 | ep_data[0].completion_event.length=0; | 790 | completion_event->dir=0; |
791 | completion_event->data=(void *)req; | ||
792 | completion_event->status=0; | ||
793 | completion_event->length=0; | ||
790 | logf("ctrl received %ld",current_tick); | 794 | logf("ctrl received %ld",current_tick); |
791 | usb_signal_transfer_completion(&ep_data[0].completion_event); | 795 | usb_signal_transfer_completion(completion_event); |
792 | } | 796 | } |
793 | 797 | ||
794 | int usb_core_ack_control(struct usb_ctrlrequest* req) | 798 | int usb_core_ack_control(struct usb_ctrlrequest* req) |
795 | { | 799 | { |
796 | if (req->bRequestType & 0x80) | 800 | if (req->bRequestType & USB_DIR_IN) |
797 | return usb_drv_recv(EP_CONTROL, NULL, 0); | 801 | return usb_drv_recv(EP_CONTROL, NULL, 0); |
798 | else | 802 | else |
799 | return usb_drv_send(EP_CONTROL, NULL, 0); | 803 | return usb_drv_send(EP_CONTROL, NULL, 0); |
@@ -802,13 +806,6 @@ int usb_core_ack_control(struct usb_ctrlrequest* req) | |||
802 | #ifdef HAVE_USB_POWER | 806 | #ifdef HAVE_USB_POWER |
803 | unsigned short usb_allowed_current() | 807 | unsigned short usb_allowed_current() |
804 | { | 808 | { |
805 | if (usb_state == CONFIGURED) | 809 | return (usb_state == CONFIGURED) ? MAX(USB_MAX_CURRENT, 100) : 100; |
806 | { | ||
807 | return MAX(USB_MAX_CURRENT, 100); | ||
808 | } | ||
809 | else | ||
810 | { | ||
811 | return 100; | ||
812 | } | ||
813 | } | 810 | } |
814 | #endif | 811 | #endif |
diff --git a/firmware/usbstack/usb_serial.c b/firmware/usbstack/usb_serial.c index 520a4b3370..50e4699b28 100644 --- a/firmware/usbstack/usb_serial.c +++ b/firmware/usbstack/usb_serial.c | |||
@@ -32,7 +32,7 @@ | |||
32 | 32 | ||
33 | /* serial interface */ | 33 | /* serial interface */ |
34 | static struct usb_interface_descriptor __attribute__((aligned(2))) | 34 | static struct usb_interface_descriptor __attribute__((aligned(2))) |
35 | interface_descriptor = | 35 | interface_descriptor = |
36 | { | 36 | { |
37 | .bLength = sizeof(struct usb_interface_descriptor), | 37 | .bLength = sizeof(struct usb_interface_descriptor), |
38 | .bDescriptorType = USB_DT_INTERFACE, | 38 | .bDescriptorType = USB_DT_INTERFACE, |
@@ -46,7 +46,8 @@ static struct usb_interface_descriptor __attribute__((aligned(2))) | |||
46 | }; | 46 | }; |
47 | 47 | ||
48 | 48 | ||
49 | static struct usb_endpoint_descriptor __attribute__((aligned(2))) endpoint_descriptor = | 49 | static struct usb_endpoint_descriptor __attribute__((aligned(2))) |
50 | endpoint_descriptor = | ||
50 | { | 51 | { |
51 | .bLength = sizeof(struct usb_endpoint_descriptor), | 52 | .bLength = sizeof(struct usb_endpoint_descriptor), |
52 | .bDescriptorType = USB_DT_ENDPOINT, | 53 | .bDescriptorType = USB_DT_ENDPOINT, |
@@ -77,12 +78,10 @@ static int usb_interface; | |||
77 | int usb_serial_request_endpoints(struct usb_class_driver *drv) | 78 | int usb_serial_request_endpoints(struct usb_class_driver *drv) |
78 | { | 79 | { |
79 | ep_in = usb_core_request_endpoint(USB_DIR_IN, drv); | 80 | ep_in = usb_core_request_endpoint(USB_DIR_IN, drv); |
80 | |||
81 | if (ep_in < 0) | 81 | if (ep_in < 0) |
82 | return -1; | 82 | return -1; |
83 | |||
84 | ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); | ||
85 | 83 | ||
84 | ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); | ||
86 | if (ep_out < 0) { | 85 | if (ep_out < 0) { |
87 | usb_core_release_endpoint(ep_in); | 86 | usb_core_release_endpoint(ep_in); |
88 | return -1; | 87 | return -1; |
@@ -97,8 +96,7 @@ int usb_serial_set_first_interface(int interface) | |||
97 | return interface + 1; | 96 | return interface + 1; |
98 | } | 97 | } |
99 | 98 | ||
100 | 99 | int usb_serial_get_config_descriptor(unsigned char *dest, int max_packet_size) | |
101 | int usb_serial_get_config_descriptor(unsigned char *dest,int max_packet_size) | ||
102 | { | 100 | { |
103 | unsigned char *orig_dest = dest; | 101 | unsigned char *orig_dest = dest; |
104 | 102 | ||
@@ -186,7 +184,7 @@ void usb_serial_send(unsigned char *data,int length) | |||
186 | return; | 184 | return; |
187 | int freestart=(buffer_start+buffer_length+buffer_transitlength)%BUFFER_SIZE; | 185 | int freestart=(buffer_start+buffer_length+buffer_transitlength)%BUFFER_SIZE; |
188 | if(buffer_start+buffer_transitlength+buffer_length >= BUFFER_SIZE) | 186 | if(buffer_start+buffer_transitlength+buffer_length >= BUFFER_SIZE) |
189 | { | 187 | { |
190 | /* current buffer wraps, so new data can't */ | 188 | /* current buffer wraps, so new data can't */ |
191 | int available_space = BUFFER_SIZE - buffer_length - buffer_transitlength; | 189 | int available_space = BUFFER_SIZE - buffer_length - buffer_transitlength; |
192 | length=MIN(length,available_space); | 190 | length=MIN(length,available_space); |
@@ -245,12 +243,9 @@ void usb_serial_transfer_complete(int ep,int dir, int status, int length) | |||
245 | } | 243 | } |
246 | 244 | ||
247 | if(buffer_length>0) | 245 | if(buffer_length>0) |
248 | { | ||
249 | sendout(); | 246 | sendout(); |
250 | } | ||
251 | break; | 247 | break; |
252 | } | 248 | } |
253 | } | 249 | } |
254 | 250 | ||
255 | |||
256 | #endif /*USB_SERIAL*/ | 251 | #endif /*USB_SERIAL*/ |
diff --git a/firmware/usbstack/usb_storage.c b/firmware/usbstack/usb_storage.c index be785da321..d7f542e64f 100644 --- a/firmware/usbstack/usb_storage.c +++ b/firmware/usbstack/usb_storage.c | |||
@@ -103,7 +103,7 @@ | |||
103 | #define USB_PROT_BULK 0x50 /* bulk only */ | 103 | #define USB_PROT_BULK 0x50 /* bulk only */ |
104 | 104 | ||
105 | static struct usb_interface_descriptor __attribute__((aligned(2))) | 105 | static struct usb_interface_descriptor __attribute__((aligned(2))) |
106 | interface_descriptor = | 106 | interface_descriptor = |
107 | { | 107 | { |
108 | .bLength = sizeof(struct usb_interface_descriptor), | 108 | .bLength = sizeof(struct usb_interface_descriptor), |
109 | .bDescriptorType = USB_DT_INTERFACE, | 109 | .bDescriptorType = USB_DT_INTERFACE, |
@@ -131,7 +131,7 @@ struct inquiry_data { | |||
131 | unsigned char DeviceType; | 131 | unsigned char DeviceType; |
132 | unsigned char DeviceTypeModifier; | 132 | unsigned char DeviceTypeModifier; |
133 | unsigned char Versions; | 133 | unsigned char Versions; |
134 | unsigned char Format; | 134 | unsigned char Format; |
135 | unsigned char AdditionalLength; | 135 | unsigned char AdditionalLength; |
136 | unsigned char Reserved[2]; | 136 | unsigned char Reserved[2]; |
137 | unsigned char Capability; | 137 | unsigned char Capability; |
@@ -309,12 +309,12 @@ static bool check_disk_present(IF_MV_NONVOID(int volume)) | |||
309 | 309 | ||
310 | void usb_storage_try_release_storage(void) | 310 | void usb_storage_try_release_storage(void) |
311 | { | 311 | { |
312 | /* Check if there is a connected drive left. If not, | 312 | /* Check if there is a connected drive left. If not, |
313 | release excusive access */ | 313 | release excusive access */ |
314 | bool canrelease=true; | 314 | bool canrelease=true; |
315 | int i; | 315 | int i; |
316 | for(i=0;i<NUM_VOLUMES;i++) { | 316 | for(i=0;i<NUM_VOLUMES;i++) { |
317 | if(ejected[i]==false && locked[i]==true){ | 317 | if(ejected[i]==false && locked[i]==true) { |
318 | canrelease=false; | 318 | canrelease=false; |
319 | break; | 319 | break; |
320 | } | 320 | } |
@@ -329,7 +329,7 @@ void usb_storage_try_release_storage(void) | |||
329 | void usb_storage_notify_hotswap(int volume,bool inserted) | 329 | void usb_storage_notify_hotswap(int volume,bool inserted) |
330 | { | 330 | { |
331 | logf("notify %d",inserted); | 331 | logf("notify %d",inserted); |
332 | if(inserted && check_disk_present(IF_MV(volume))) { | 332 | if(inserted && check_disk_present(IF_MV(volume))) { |
333 | ejected[volume] = false; | 333 | ejected[volume] = false; |
334 | } | 334 | } |
335 | else { | 335 | else { |
@@ -351,12 +351,12 @@ int usb_storage_request_endpoints(struct usb_class_driver *drv) | |||
351 | { | 351 | { |
352 | ep_in = usb_core_request_endpoint(USB_DIR_IN, drv); | 352 | ep_in = usb_core_request_endpoint(USB_DIR_IN, drv); |
353 | 353 | ||
354 | if (ep_in < 0) | 354 | if(ep_in<0) |
355 | return -1; | 355 | return -1; |
356 | 356 | ||
357 | ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); | 357 | ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); |
358 | 358 | ||
359 | if (ep_out < 0) { | 359 | if(ep_out<0) { |
360 | usb_core_release_endpoint(ep_in); | 360 | usb_core_release_endpoint(ep_in); |
361 | return -1; | 361 | return -1; |
362 | } | 362 | } |
@@ -410,7 +410,7 @@ void usb_storage_init_connection(void) | |||
410 | 410 | ||
411 | audio_buffer = audio_get_buffer(false,&bufsize); | 411 | audio_buffer = audio_get_buffer(false,&bufsize); |
412 | tb.transfer_buffer = | 412 | tb.transfer_buffer = |
413 | (void *)UNCACHED_ADDR((unsigned int)(audio_buffer + 31) & 0xffffffe0); | 413 | (void *)UNCACHED_ADDR((unsigned int)(audio_buffer+31) & 0xffffffe0); |
414 | cpucache_invalidate(); | 414 | cpucache_invalidate(); |
415 | #ifdef USB_USE_RAMDISK | 415 | #ifdef USB_USE_RAMDISK |
416 | ramdisk_buffer = tb.transfer_buffer + BUFFER_SIZE*2; | 416 | ramdisk_buffer = tb.transfer_buffer + BUFFER_SIZE*2; |
@@ -452,7 +452,7 @@ void usb_storage_transfer_complete(int ep,int dir,int status,int length) | |||
452 | } | 452 | } |
453 | logf("scsi write %d %d", cur_cmd.sector, cur_cmd.count); | 453 | logf("scsi write %d %d", cur_cmd.sector, cur_cmd.count); |
454 | if(status==0) { | 454 | if(status==0) { |
455 | if((unsigned int)length!=(SECTOR_SIZE*cur_cmd.count) | 455 | if((unsigned int)length!=(SECTOR_SIZE* cur_cmd.count) |
456 | && (unsigned int)length!=BUFFER_SIZE) { | 456 | && (unsigned int)length!=BUFFER_SIZE) { |
457 | logf("unexpected length :%d",length); | 457 | logf("unexpected length :%d",length); |
458 | } | 458 | } |
@@ -473,14 +473,13 @@ void usb_storage_transfer_complete(int ep,int dir,int status,int length) | |||
473 | sending the next bit */ | 473 | sending the next bit */ |
474 | #ifdef USB_USE_RAMDISK | 474 | #ifdef USB_USE_RAMDISK |
475 | memcpy(ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, | 475 | memcpy(ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, |
476 | cur_cmd.data[cur_cmd.data_select], | 476 | cur_cmd.data[cur_cmd.data_select], |
477 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); | 477 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); |
478 | #else | 478 | #else |
479 | int result = storage_write_sectors(cur_cmd.lun, | 479 | int result = storage_write_sectors(cur_cmd.lun, |
480 | cur_cmd.sector, | 480 | cur_cmd.sector, |
481 | MIN(BUFFER_SIZE/SECTOR_SIZE, | 481 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count), |
482 | cur_cmd.count), | 482 | cur_cmd.data[cur_cmd.data_select]); |
483 | cur_cmd.data[cur_cmd.data_select]); | ||
484 | if(result != 0) { | 483 | if(result != 0) { |
485 | send_csw(UMS_STATUS_FAIL); | 484 | send_csw(UMS_STATUS_FAIL); |
486 | cur_sense_data.sense_key=SENSE_MEDIUM_ERROR; | 485 | cur_sense_data.sense_key=SENSE_MEDIUM_ERROR; |
@@ -488,8 +487,7 @@ void usb_storage_transfer_complete(int ep,int dir,int status,int length) | |||
488 | cur_sense_data.ascq=0; | 487 | cur_sense_data.ascq=0; |
489 | break; | 488 | break; |
490 | } | 489 | } |
491 | #endif | 490 | #endif |
492 | |||
493 | if(next_count==0) { | 491 | if(next_count==0) { |
494 | send_csw(UMS_STATUS_GOOD); | 492 | send_csw(UMS_STATUS_GOOD); |
495 | } | 493 | } |
@@ -499,7 +497,6 @@ void usb_storage_transfer_complete(int ep,int dir,int status,int length) | |||
499 | 497 | ||
500 | cur_cmd.sector = next_sector; | 498 | cur_cmd.sector = next_sector; |
501 | cur_cmd.count = next_count; | 499 | cur_cmd.count = next_count; |
502 | |||
503 | } | 500 | } |
504 | else { | 501 | else { |
505 | logf("Transfer failed %X",status); | 502 | logf("Transfer failed %X",status); |
@@ -516,7 +513,7 @@ void usb_storage_transfer_complete(int ep,int dir,int status,int length) | |||
516 | logf("IN received in WAITING_FOR_COMMAND"); | 513 | logf("IN received in WAITING_FOR_COMMAND"); |
517 | } | 514 | } |
518 | //logf("command received"); | 515 | //logf("command received"); |
519 | if(letoh32(cbw->signature) == CBW_SIGNATURE){ | 516 | if(letoh32(cbw->signature) == CBW_SIGNATURE) { |
520 | handle_scsi(cbw); | 517 | handle_scsi(cbw); |
521 | } | 518 | } |
522 | else { | 519 | else { |
@@ -622,7 +619,6 @@ bool usb_storage_control_request(struct usb_ctrlrequest* req, unsigned char* des | |||
622 | usb_drv_reset_endpoint(ep_in, false); | 619 | usb_drv_reset_endpoint(ep_in, false); |
623 | usb_drv_reset_endpoint(ep_out, true); | 620 | usb_drv_reset_endpoint(ep_out, true); |
624 | #endif | 621 | #endif |
625 | |||
626 | usb_drv_send(EP_CONTROL, NULL, 0); /* ack */ | 622 | usb_drv_send(EP_CONTROL, NULL, 0); /* ack */ |
627 | handled = true; | 623 | handled = true; |
628 | break; | 624 | break; |
@@ -650,19 +646,18 @@ static void send_and_read_next(void) | |||
650 | cur_cmd.sector+=(BUFFER_SIZE/SECTOR_SIZE); | 646 | cur_cmd.sector+=(BUFFER_SIZE/SECTOR_SIZE); |
651 | cur_cmd.count-=MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE); | 647 | cur_cmd.count-=MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE); |
652 | 648 | ||
653 | if(cur_cmd.count!=0){ | 649 | if(cur_cmd.count!=0) { |
654 | /* already read the next bit, so we can send it out immediately when the | 650 | /* already read the next bit, so we can send it out immediately when the |
655 | * current transfer completes. */ | 651 | * current transfer completes. */ |
656 | #ifdef USB_USE_RAMDISK | 652 | #ifdef USB_USE_RAMDISK |
657 | memcpy(cur_cmd.data[cur_cmd.data_select], | 653 | memcpy(cur_cmd.data[cur_cmd.data_select], |
658 | ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, | 654 | ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, |
659 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); | 655 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); |
660 | #else | 656 | #else |
661 | cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, | 657 | cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, |
662 | cur_cmd.sector, | 658 | cur_cmd.sector, |
663 | MIN(BUFFER_SIZE/SECTOR_SIZE, | 659 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count), |
664 | cur_cmd.count), | 660 | cur_cmd.data[cur_cmd.data_select]); |
665 | cur_cmd.data[cur_cmd.data_select]); | ||
666 | #endif | 661 | #endif |
667 | } | 662 | } |
668 | } | 663 | } |
@@ -781,7 +776,7 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
781 | } | 776 | } |
782 | 777 | ||
783 | case SCSI_MODE_SENSE_10: { | 778 | case SCSI_MODE_SENSE_10: { |
784 | if(! lun_present) { | 779 | if(!lun_present) { |
785 | send_command_failed_result(); | 780 | send_command_failed_result(); |
786 | cur_sense_data.sense_key=SENSE_NOT_READY; | 781 | cur_sense_data.sense_key=SENSE_NOT_READY; |
787 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 782 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
@@ -794,7 +789,7 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
794 | switch(page_code) { | 789 | switch(page_code) { |
795 | case 0x3f: | 790 | case 0x3f: |
796 | tb.ms_data_10->mode_data_length = | 791 | tb.ms_data_10->mode_data_length = |
797 | htobe16(sizeof(struct mode_sense_data_10)-2); | 792 | htobe16(sizeof(struct mode_sense_data_10)-2); |
798 | tb.ms_data_10->medium_type = 0; | 793 | tb.ms_data_10->medium_type = 0; |
799 | tb.ms_data_10->device_specific = 0; | 794 | tb.ms_data_10->device_specific = 0; |
800 | tb.ms_data_10->reserved = 0; | 795 | tb.ms_data_10->reserved = 0; |
@@ -806,24 +801,24 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
806 | memset(tb.ms_data_10->block_descriptor.num_blocks,0,8); | 801 | memset(tb.ms_data_10->block_descriptor.num_blocks,0,8); |
807 | 802 | ||
808 | tb.ms_data_10->block_descriptor.num_blocks[4] = | 803 | tb.ms_data_10->block_descriptor.num_blocks[4] = |
809 | ((block_count/block_size_mult) & 0xff000000)>>24; | 804 | ((block_count/block_size_mult) & 0xff000000)>>24; |
810 | tb.ms_data_10->block_descriptor.num_blocks[5] = | 805 | tb.ms_data_10->block_descriptor.num_blocks[5] = |
811 | ((block_count/block_size_mult) & 0x00ff0000)>>16; | 806 | ((block_count/block_size_mult) & 0x00ff0000)>>16; |
812 | tb.ms_data_10->block_descriptor.num_blocks[6] = | 807 | tb.ms_data_10->block_descriptor.num_blocks[6] = |
813 | ((block_count/block_size_mult) & 0x0000ff00)>>8; | 808 | ((block_count/block_size_mult) & 0x0000ff00)>>8; |
814 | tb.ms_data_10->block_descriptor.num_blocks[7] = | 809 | tb.ms_data_10->block_descriptor.num_blocks[7] = |
815 | ((block_count/block_size_mult) & 0x000000ff); | 810 | ((block_count/block_size_mult) & 0x000000ff); |
816 | 811 | ||
817 | tb.ms_data_10->block_descriptor.block_size[0] = | 812 | tb.ms_data_10->block_descriptor.block_size[0] = |
818 | ((block_size*block_size_mult) & 0xff000000)>>24; | 813 | ((block_size*block_size_mult) & 0xff000000)>>24; |
819 | tb.ms_data_10->block_descriptor.block_size[1] = | 814 | tb.ms_data_10->block_descriptor.block_size[1] = |
820 | ((block_size*block_size_mult) & 0x00ff0000)>>16; | 815 | ((block_size*block_size_mult) & 0x00ff0000)>>16; |
821 | tb.ms_data_10->block_descriptor.block_size[2] = | 816 | tb.ms_data_10->block_descriptor.block_size[2] = |
822 | ((block_size*block_size_mult) & 0x0000ff00)>>8; | 817 | ((block_size*block_size_mult) & 0x0000ff00)>>8; |
823 | tb.ms_data_10->block_descriptor.block_size[3] = | 818 | tb.ms_data_10->block_descriptor.block_size[3] = |
824 | ((block_size*block_size_mult) & 0x000000ff); | 819 | ((block_size*block_size_mult) & 0x000000ff); |
825 | send_command_result(tb.ms_data_10, | 820 | send_command_result(tb.ms_data_10, |
826 | MIN(sizeof(struct mode_sense_data_10), length)); | 821 | MIN(sizeof(struct mode_sense_data_10), length)); |
827 | break; | 822 | break; |
828 | default: | 823 | default: |
829 | send_command_failed_result(); | 824 | send_command_failed_result(); |
@@ -831,11 +826,12 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
831 | cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD; | 826 | cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD; |
832 | cur_sense_data.ascq=0; | 827 | cur_sense_data.ascq=0; |
833 | break; | 828 | break; |
834 | } | 829 | } |
835 | break; | 830 | break; |
836 | } | 831 | } |
832 | |||
837 | case SCSI_MODE_SENSE_6: { | 833 | case SCSI_MODE_SENSE_6: { |
838 | if(! lun_present) { | 834 | if(!lun_present) { |
839 | send_command_failed_result(); | 835 | send_command_failed_result(); |
840 | cur_sense_data.sense_key=SENSE_NOT_READY; | 836 | cur_sense_data.sense_key=SENSE_NOT_READY; |
841 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 837 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
@@ -849,34 +845,34 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
849 | case 0x3f: | 845 | case 0x3f: |
850 | /* All supported pages. */ | 846 | /* All supported pages. */ |
851 | tb.ms_data_6->mode_data_length = | 847 | tb.ms_data_6->mode_data_length = |
852 | sizeof(struct mode_sense_data_6)-1; | 848 | sizeof(struct mode_sense_data_6)-1; |
853 | tb.ms_data_6->medium_type = 0; | 849 | tb.ms_data_6->medium_type = 0; |
854 | tb.ms_data_6->device_specific = 0; | 850 | tb.ms_data_6->device_specific = 0; |
855 | tb.ms_data_6->block_descriptor_length = | 851 | tb.ms_data_6->block_descriptor_length = |
856 | sizeof(struct mode_sense_bdesc_shortlba); | 852 | sizeof(struct mode_sense_bdesc_shortlba); |
857 | tb.ms_data_6->block_descriptor.density_code = 0; | 853 | tb.ms_data_6->block_descriptor.density_code = 0; |
858 | tb.ms_data_6->block_descriptor.reserved = 0; | 854 | tb.ms_data_6->block_descriptor.reserved = 0; |
859 | if(block_count/block_size_mult > 0xffffff){ | 855 | if(block_count/block_size_mult > 0xffffff) { |
860 | tb.ms_data_6->block_descriptor.num_blocks[0] = 0xff; | 856 | tb.ms_data_6->block_descriptor.num_blocks[0] = 0xff; |
861 | tb.ms_data_6->block_descriptor.num_blocks[1] = 0xff; | 857 | tb.ms_data_6->block_descriptor.num_blocks[1] = 0xff; |
862 | tb.ms_data_6->block_descriptor.num_blocks[2] = 0xff; | 858 | tb.ms_data_6->block_descriptor.num_blocks[2] = 0xff; |
863 | } | 859 | } |
864 | else { | 860 | else { |
865 | tb.ms_data_6->block_descriptor.num_blocks[0] = | 861 | tb.ms_data_6->block_descriptor.num_blocks[0] = |
866 | ((block_count/block_size_mult) & 0xff0000)>>16; | 862 | ((block_count/block_size_mult) & 0xff0000)>>16; |
867 | tb.ms_data_6->block_descriptor.num_blocks[1] = | 863 | tb.ms_data_6->block_descriptor.num_blocks[1] = |
868 | ((block_count/block_size_mult) & 0x00ff00)>>8; | 864 | ((block_count/block_size_mult) & 0x00ff00)>>8; |
869 | tb.ms_data_6->block_descriptor.num_blocks[2] = | 865 | tb.ms_data_6->block_descriptor.num_blocks[2] = |
870 | ((block_count/block_size_mult) & 0x0000ff); | 866 | ((block_count/block_size_mult) & 0x0000ff); |
871 | } | 867 | } |
872 | tb.ms_data_6->block_descriptor.block_size[0] = | 868 | tb.ms_data_6->block_descriptor.block_size[0] = |
873 | ((block_size*block_size_mult) & 0xff0000)>>16; | 869 | ((block_size*block_size_mult) & 0xff0000)>>16; |
874 | tb.ms_data_6->block_descriptor.block_size[1] = | 870 | tb.ms_data_6->block_descriptor.block_size[1] = |
875 | ((block_size*block_size_mult) & 0x00ff00)>>8; | 871 | ((block_size*block_size_mult) & 0x00ff00)>>8; |
876 | tb.ms_data_6->block_descriptor.block_size[2] = | 872 | tb.ms_data_6->block_descriptor.block_size[2] = |
877 | ((block_size*block_size_mult) & 0x0000ff); | 873 | ((block_size*block_size_mult) & 0x0000ff); |
878 | send_command_result(tb.ms_data_6, | 874 | send_command_result(tb.ms_data_6, |
879 | MIN(sizeof(struct mode_sense_data_6), length)); | 875 | MIN(sizeof(struct mode_sense_data_6), length)); |
880 | break; | 876 | break; |
881 | default: | 877 | default: |
882 | send_command_failed_result(); | 878 | send_command_failed_result(); |
@@ -907,57 +903,55 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
907 | 903 | ||
908 | case SCSI_ALLOW_MEDIUM_REMOVAL: | 904 | case SCSI_ALLOW_MEDIUM_REMOVAL: |
909 | logf("scsi allow_medium_removal %d",lun); | 905 | logf("scsi allow_medium_removal %d",lun); |
910 | if((cbw->command_block[4] & 0x03) == 0) | 906 | if((cbw->command_block[4] & 0x03) == 0) { |
911 | { | ||
912 | locked[lun]=false; | 907 | locked[lun]=false; |
913 | queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+0); | 908 | queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+0); |
914 | } | 909 | } |
915 | else | 910 | else { |
916 | { | ||
917 | locked[lun]=true; | 911 | locked[lun]=true; |
918 | queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+1); | 912 | queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+1); |
919 | } | 913 | } |
920 | send_csw(UMS_STATUS_GOOD); | 914 | send_csw(UMS_STATUS_GOOD); |
921 | break; | 915 | break; |
916 | |||
922 | case SCSI_READ_FORMAT_CAPACITY: { | 917 | case SCSI_READ_FORMAT_CAPACITY: { |
923 | logf("scsi read_format_capacity %d",lun); | 918 | logf("scsi read_format_capacity %d",lun); |
924 | if(lun_present) { | 919 | if(lun_present) { |
925 | tb.format_capacity_data->following_length=htobe32(8); | 920 | tb.format_capacity_data->following_length=htobe32(8); |
926 | /* "block count" actually means "number of last block" */ | 921 | /* "block count" actually means "number of last block" */ |
927 | tb.format_capacity_data->block_count = | 922 | tb.format_capacity_data->block_count = |
928 | htobe32(block_count/block_size_mult - 1); | 923 | htobe32(block_count/block_size_mult - 1); |
929 | tb.format_capacity_data->block_size = | 924 | tb.format_capacity_data->block_size = |
930 | htobe32(block_size*block_size_mult); | 925 | htobe32(block_size*block_size_mult); |
931 | tb.format_capacity_data->block_size |= | 926 | tb.format_capacity_data->block_size |= |
932 | htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA); | 927 | htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA); |
933 | 928 | ||
934 | send_command_result(tb.format_capacity_data, | 929 | send_command_result(tb.format_capacity_data, |
935 | MIN(sizeof(struct format_capacity), length)); | 930 | MIN(sizeof(struct format_capacity), length)); |
936 | } | 931 | } |
937 | else | 932 | else { |
938 | { | 933 | send_command_failed_result(); |
939 | send_command_failed_result(); | 934 | cur_sense_data.sense_key=SENSE_NOT_READY; |
940 | cur_sense_data.sense_key=SENSE_NOT_READY; | 935 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
941 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 936 | cur_sense_data.ascq=0; |
942 | cur_sense_data.ascq=0; | 937 | } |
943 | } | 938 | break; |
944 | break; | ||
945 | } | 939 | } |
940 | |||
946 | case SCSI_READ_CAPACITY: { | 941 | case SCSI_READ_CAPACITY: { |
947 | logf("scsi read_capacity %d",lun); | 942 | logf("scsi read_capacity %d",lun); |
948 | 943 | ||
949 | if(lun_present) { | 944 | if(lun_present) { |
950 | /* "block count" actually means "number of last block" */ | 945 | /* "block count" actually means "number of last block" */ |
951 | tb.capacity_data->block_count = | 946 | tb.capacity_data->block_count = |
952 | htobe32(block_count/block_size_mult - 1); | 947 | htobe32(block_count/block_size_mult - 1); |
953 | tb.capacity_data->block_size = | 948 | tb.capacity_data->block_size = |
954 | htobe32(block_size*block_size_mult); | 949 | htobe32(block_size*block_size_mult); |
955 | 950 | ||
956 | send_command_result(tb.capacity_data, | 951 | send_command_result(tb.capacity_data, |
957 | MIN(sizeof(struct capacity), length)); | 952 | MIN(sizeof(struct capacity), length)); |
958 | } | 953 | } |
959 | else | 954 | else { |
960 | { | ||
961 | send_command_failed_result(); | 955 | send_command_failed_result(); |
962 | cur_sense_data.sense_key=SENSE_NOT_READY; | 956 | cur_sense_data.sense_key=SENSE_NOT_READY; |
963 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 957 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
@@ -968,7 +962,7 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
968 | 962 | ||
969 | case SCSI_READ_10: | 963 | case SCSI_READ_10: |
970 | logf("scsi read10 %d",lun); | 964 | logf("scsi read10 %d",lun); |
971 | if(! lun_present) { | 965 | if(!lun_present) { |
972 | send_command_failed_result(); | 966 | send_command_failed_result(); |
973 | cur_sense_data.sense_key=SENSE_NOT_READY; | 967 | cur_sense_data.sense_key=SENSE_NOT_READY; |
974 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 968 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
@@ -979,13 +973,13 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
979 | cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; | 973 | cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; |
980 | cur_cmd.data_select=0; | 974 | cur_cmd.data_select=0; |
981 | cur_cmd.sector = block_size_mult * | 975 | cur_cmd.sector = block_size_mult * |
982 | (cbw->command_block[2] << 24 | | 976 | (cbw->command_block[2] << 24 | |
983 | cbw->command_block[3] << 16 | | 977 | cbw->command_block[3] << 16 | |
984 | cbw->command_block[4] << 8 | | 978 | cbw->command_block[4] << 8 | |
985 | cbw->command_block[5] ); | 979 | cbw->command_block[5] ); |
986 | cur_cmd.count = block_size_mult * | 980 | cur_cmd.count = block_size_mult * |
987 | (cbw->command_block[7] << 8 | | 981 | (cbw->command_block[7] << 8 | |
988 | cbw->command_block[8]); | 982 | cbw->command_block[8]); |
989 | cur_cmd.orig_count = cur_cmd.count; | 983 | cur_cmd.orig_count = cur_cmd.count; |
990 | 984 | ||
991 | //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count); | 985 | //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count); |
@@ -999,17 +993,16 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
999 | else { | 993 | else { |
1000 | #ifdef USB_USE_RAMDISK | 994 | #ifdef USB_USE_RAMDISK |
1001 | memcpy(cur_cmd.data[cur_cmd.data_select], | 995 | memcpy(cur_cmd.data[cur_cmd.data_select], |
1002 | ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, | 996 | ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, |
1003 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); | 997 | MIN(BUFFER_SIZE/SECTOR_SIZE,cur_cmd.count)*SECTOR_SIZE); |
1004 | #else | 998 | #else |
1005 | cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, | 999 | cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, |
1006 | cur_cmd.sector, | 1000 | cur_cmd.sector, |
1007 | MIN(BUFFER_SIZE/SECTOR_SIZE, | 1001 | MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count), |
1008 | cur_cmd.count), | 1002 | cur_cmd.data[cur_cmd.data_select]); |
1009 | cur_cmd.data[cur_cmd.data_select]); | ||
1010 | 1003 | ||
1011 | #ifdef TOSHIBA_GIGABEAT_S | 1004 | #ifdef TOSHIBA_GIGABEAT_S |
1012 | if (cur_cmd.sector == 0) { | 1005 | if(cur_cmd.sector == 0) { |
1013 | fix_mbr(cur_cmd.data[cur_cmd.data_select]); | 1006 | fix_mbr(cur_cmd.data[cur_cmd.data_select]); |
1014 | } | 1007 | } |
1015 | #endif | 1008 | #endif |
@@ -1020,7 +1013,7 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
1020 | 1013 | ||
1021 | case SCSI_WRITE_10: | 1014 | case SCSI_WRITE_10: |
1022 | logf("scsi write10 %d",lun); | 1015 | logf("scsi write10 %d",lun); |
1023 | if(! lun_present) { | 1016 | if(!lun_present) { |
1024 | send_csw(UMS_STATUS_FAIL); | 1017 | send_csw(UMS_STATUS_FAIL); |
1025 | cur_sense_data.sense_key=SENSE_NOT_READY; | 1018 | cur_sense_data.sense_key=SENSE_NOT_READY; |
1026 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; | 1019 | cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; |
@@ -1031,13 +1024,13 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
1031 | cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; | 1024 | cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; |
1032 | cur_cmd.data_select=0; | 1025 | cur_cmd.data_select=0; |
1033 | cur_cmd.sector = block_size_mult * | 1026 | cur_cmd.sector = block_size_mult * |
1034 | (cbw->command_block[2] << 24 | | 1027 | (cbw->command_block[2] << 24 | |
1035 | cbw->command_block[3] << 16 | | 1028 | cbw->command_block[3] << 16 | |
1036 | cbw->command_block[4] << 8 | | 1029 | cbw->command_block[4] << 8 | |
1037 | cbw->command_block[5] ); | 1030 | cbw->command_block[5] ); |
1038 | cur_cmd.count = block_size_mult * | 1031 | cur_cmd.count = block_size_mult * |
1039 | (cbw->command_block[7] << 8 | | 1032 | (cbw->command_block[7] << 8 | |
1040 | cbw->command_block[8]); | 1033 | cbw->command_block[8]); |
1041 | cur_cmd.orig_count = cur_cmd.count; | 1034 | cur_cmd.orig_count = cur_cmd.count; |
1042 | 1035 | ||
1043 | /* expect data */ | 1036 | /* expect data */ |
@@ -1049,10 +1042,8 @@ static void handle_scsi(struct command_block_wrapper* cbw) | |||
1049 | } | 1042 | } |
1050 | else { | 1043 | else { |
1051 | receive_block_data(cur_cmd.data[0], | 1044 | receive_block_data(cur_cmd.data[0], |
1052 | MIN(BUFFER_SIZE, | 1045 | MIN(BUFFER_SIZE, cur_cmd.count*SECTOR_SIZE)); |
1053 | cur_cmd.count*SECTOR_SIZE)); | ||
1054 | } | 1046 | } |
1055 | |||
1056 | break; | 1047 | break; |
1057 | 1048 | ||
1058 | default: | 1049 | default: |
@@ -1097,7 +1088,7 @@ static void send_csw(int status) | |||
1097 | tb.csw->status = status; | 1088 | tb.csw->status = status; |
1098 | 1089 | ||
1099 | usb_drv_send_nonblocking(ep_in, tb.csw, | 1090 | usb_drv_send_nonblocking(ep_in, tb.csw, |
1100 | sizeof(struct command_status_wrapper)); | 1091 | sizeof(struct command_status_wrapper)); |
1101 | state = SENDING_CSW; | 1092 | state = SENDING_CSW; |
1102 | //logf("CSW: %X",status); | 1093 | //logf("CSW: %X",status); |
1103 | 1094 | ||
@@ -1127,8 +1118,8 @@ static void copy_padded(char *dest, char *src, int len) | |||
1127 | /* build SCSI INQUIRY */ | 1118 | /* build SCSI INQUIRY */ |
1128 | static void fill_inquiry(IF_MV_NONVOID(int lun)) | 1119 | static void fill_inquiry(IF_MV_NONVOID(int lun)) |
1129 | { | 1120 | { |
1130 | memset(tb.inquiry, 0, sizeof(struct inquiry_data)); | ||
1131 | struct storage_info info; | 1121 | struct storage_info info; |
1122 | memset(tb.inquiry, 0, sizeof(struct inquiry_data)); | ||
1132 | storage_get_info(lun,&info); | 1123 | storage_get_info(lun,&info); |
1133 | copy_padded(tb.inquiry->VendorId,info.vendor,sizeof(tb.inquiry->VendorId)); | 1124 | copy_padded(tb.inquiry->VendorId,info.vendor,sizeof(tb.inquiry->VendorId)); |
1134 | copy_padded(tb.inquiry->ProductId,info.product,sizeof(tb.inquiry->ProductId)); | 1125 | copy_padded(tb.inquiry->ProductId,info.product,sizeof(tb.inquiry->ProductId)); |
@@ -1138,7 +1129,7 @@ static void fill_inquiry(IF_MV_NONVOID(int lun)) | |||
1138 | tb.inquiry->AdditionalLength = 0x1f; | 1129 | tb.inquiry->AdditionalLength = 0x1f; |
1139 | memset(tb.inquiry->Reserved, 0, 3); | 1130 | memset(tb.inquiry->Reserved, 0, 3); |
1140 | tb.inquiry->Versions = 4; /* SPC-2 */ | 1131 | tb.inquiry->Versions = 4; /* SPC-2 */ |
1141 | tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */ | 1132 | tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */ |
1142 | 1133 | ||
1143 | #ifdef TOSHIBA_GIGABEAT_S | 1134 | #ifdef TOSHIBA_GIGABEAT_S |
1144 | tb.inquiry->DeviceTypeModifier = 0; | 1135 | tb.inquiry->DeviceTypeModifier = 0; |