From 886549010611e06b1589f9bc7b18895ad2e707be Mon Sep 17 00:00:00 2001 From: Frank Gevaerts Date: Fri, 29 Feb 2008 21:10:31 +0000 Subject: Move all pointers to the transfer buffer area into a union. This makes it clear that they are meant to point to the same data, and should make code and RAM usage slightly smaller git-svn-id: svn://svn.rockbox.org/rockbox/trunk@16458 a1c6a512-1295-4272-9138-f99709370657 --- firmware/usbstack/usb_storage.c | 215 +++++++++++++++++++--------------------- 1 file changed, 104 insertions(+), 111 deletions(-) (limited to 'firmware') diff --git a/firmware/usbstack/usb_storage.c b/firmware/usbstack/usb_storage.c index cee2f7700e..73464cf608 100644 --- a/firmware/usbstack/usb_storage.c +++ b/firmware/usbstack/usb_storage.c @@ -179,17 +179,19 @@ struct format_capacity { unsigned int block_size; } __attribute__ ((packed)); -static unsigned char* transfer_buffer; - -static struct inquiry_data* inquiry; -static struct capacity* capacity_data; -static struct format_capacity* format_capacity_data; -static struct sense_data *sense_data; -static struct mode_sense_data_6 *mode_sense_data_6; -static struct mode_sense_data_10 *mode_sense_data_10; -static struct report_lun_data *lun_data; -static struct command_status_wrapper* csw; -static char *max_lun; + +static union { + unsigned char* transfer_buffer; + struct inquiry_data* inquiry; + struct capacity* capacity_data; + struct format_capacity* format_capacity_data; + struct sense_data *sense_data; + struct mode_sense_data_6 *mode_sense_data_6; + struct mode_sense_data_10 *mode_sense_data_10; + struct report_lun_data *lun_data; + struct command_status_wrapper* csw; + char *max_lun; +} tb; static struct { unsigned int sector; @@ -229,23 +231,14 @@ void usb_storage_init(void) size_t bufsize; unsigned char * audio_buffer = audio_get_buffer(false,&bufsize); /* TODO : check if bufsize is at least 32K ? */ - transfer_buffer = (void *)UNCACHED_ADDR((unsigned int)(audio_buffer + 31) & 0xffffffe0); - inquiry = (void*)transfer_buffer; - capacity_data = (void*)transfer_buffer; - format_capacity_data = (void*)transfer_buffer; - sense_data = (void*)transfer_buffer; - mode_sense_data_6 = (void*)transfer_buffer; - mode_sense_data_10 = (void*)transfer_buffer; - lun_data = (void*)transfer_buffer; - max_lun = (void*)transfer_buffer; - csw = (void*)transfer_buffer; + tb.transfer_buffer = (void *)UNCACHED_ADDR((unsigned int)(audio_buffer + 31) & 0xffffffe0); logf("usb_storage_init done"); } /* called by usb_core_transfer_complete() */ void usb_storage_transfer_complete(bool in,int status,int length) { - struct command_block_wrapper* cbw = (void*)transfer_buffer; + struct command_block_wrapper* cbw = (void*)tb.transfer_buffer; //logf("transfer result %X %d", status, length); switch(state) { @@ -319,7 +312,7 @@ void usb_storage_transfer_complete(bool in,int status,int length) } //logf("csw sent, now go back to idle"); state = WAITING_FOR_COMMAND; - usb_drv_recv(EP_MASS_STORAGE, transfer_buffer, 1024); + usb_drv_recv(EP_MASS_STORAGE, tb.transfer_buffer, 1024); break; case SENDING_RESULT: if(in==false) { @@ -371,12 +364,12 @@ bool usb_storage_control_request(struct usb_ctrlrequest* req) switch (req->bRequest) { case USB_BULK_GET_MAX_LUN: { #ifdef ONLY_EXPOSE_CARD_SLOT - *max_lun = 0; + *tb.max_lun = 0; #else - *max_lun = NUM_VOLUMES - 1; + *tb.max_lun = NUM_VOLUMES - 1; #endif logf("ums: getmaxlun"); - usb_drv_send(EP_CONTROL, UNCACHED_ADDR(max_lun), 1); + usb_drv_send(EP_CONTROL, UNCACHED_ADDR(tb.max_lun), 1); usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */ handled = true; break; @@ -401,7 +394,7 @@ bool usb_storage_control_request(struct usb_ctrlrequest* req) logf("ums: set config"); /* prime rx endpoint. We only need room for commands */ state = WAITING_FOR_COMMAND; - usb_drv_recv(EP_MASS_STORAGE, transfer_buffer, 1024); + usb_drv_recv(EP_MASS_STORAGE, tb.transfer_buffer, 1024); handled = true; break; } @@ -496,16 +489,16 @@ static void handle_scsi(struct command_block_wrapper* cbw) allocation_length|=(cbw->command_block[7]<<16); allocation_length|=(cbw->command_block[8]<<8); allocation_length|=(cbw->command_block[9]); - memset(lun_data,0,sizeof(struct report_lun_data)); + memset(tb.lun_data,0,sizeof(struct report_lun_data)); #ifdef HAVE_HOTSWAP - lun_data->lun_list_length=htobe32(16); - lun_data->lun1[1]=1; + tb.lun_data->lun_list_length=htobe32(16); + tb.lun_data->lun1[1]=1; #else - lun_data->lun_list_length=htobe32(8); + tb.lun_data->lun_list_length=htobe32(8); #endif - lun_data->lun0[1]=0; + tb.lun_data->lun0[1]=0; - send_command_result(lun_data, MIN(sizeof(struct report_lun_data), length)); + send_command_result(tb.lun_data, MIN(sizeof(struct report_lun_data), length)); break; } @@ -513,22 +506,22 @@ static void handle_scsi(struct command_block_wrapper* cbw) logf("scsi inquiry %d",lun); identify2inquiry(lun); length = MIN(length, cbw->command_block[4]); - send_command_result(inquiry, MIN(sizeof(struct inquiry_data), length)); + send_command_result(tb.inquiry, MIN(sizeof(struct inquiry_data), length)); break; case SCSI_REQUEST_SENSE: { - sense_data->ResponseCode=0x70;/*current error*/ - sense_data->filemark_eom_ili_sensekey=cur_sense_data.sense_key&0x0f; - sense_data->Information=cur_sense_data.information; - sense_data->AdditionalSenseLength=10; - sense_data->CommandSpecificInformation=0; - sense_data->AdditionalSenseCode=cur_sense_data.asc; - sense_data->AdditionalSenseCodeQualifier=0; - sense_data->FieldReplaceableUnitCode=0; - sense_data->SKSV=0; - sense_data->SenseKeySpecific=0; + tb.sense_data->ResponseCode=0x70;/*current error*/ + tb.sense_data->filemark_eom_ili_sensekey=cur_sense_data.sense_key&0x0f; + tb.sense_data->Information=cur_sense_data.information; + tb.sense_data->AdditionalSenseLength=10; + tb.sense_data->CommandSpecificInformation=0; + tb.sense_data->AdditionalSenseCode=cur_sense_data.asc; + tb.sense_data->AdditionalSenseCodeQualifier=0; + tb.sense_data->FieldReplaceableUnitCode=0; + tb.sense_data->SKSV=0; + tb.sense_data->SenseKeySpecific=0; logf("scsi request_sense %d",lun); - send_command_result(sense_data, sizeof(struct sense_data)); + send_command_result(tb.sense_data, sizeof(struct sense_data)); break; } @@ -545,24 +538,24 @@ static void handle_scsi(struct command_block_wrapper* cbw) logf("scsi mode_sense_10 %d %X",lun,page_code); switch(page_code) { case 0x3f: - mode_sense_data_10->mode_data_length=sizeof(struct mode_sense_data_10); - mode_sense_data_10->medium_type=0; - mode_sense_data_10->device_specific=0; - mode_sense_data_10->reserved=0; - mode_sense_data_10->longlba=1; - mode_sense_data_10->block_descriptor_length=sizeof(struct mode_sense_block_descriptor_longlba); - memset(mode_sense_data_10->block_descriptor.reserved,0,4); - memset(mode_sense_data_10->block_descriptor.number_of_blocks,0,8); - mode_sense_data_10->block_descriptor.number_of_blocks[4]=((block_count/block_size_mult) & 0xff000000)>>24; - mode_sense_data_10->block_descriptor.number_of_blocks[5]=((block_count/block_size_mult) & 0x00ff0000)>>16; - mode_sense_data_10->block_descriptor.number_of_blocks[6]=((block_count/block_size_mult) & 0x0000ff00)>>8; - mode_sense_data_10->block_descriptor.number_of_blocks[7]=((block_count/block_size_mult) & 0x000000ff); - - mode_sense_data_10->block_descriptor.block_size[0]=((block_size*block_size_mult) & 0xff000000)>>24; - mode_sense_data_10->block_descriptor.block_size[1]=((block_size*block_size_mult) & 0x00ff0000)>>16; - mode_sense_data_10->block_descriptor.block_size[2]=((block_size*block_size_mult) & 0x0000ff00)>>8; - mode_sense_data_10->block_descriptor.block_size[3]=((block_size*block_size_mult) & 0x000000ff); - send_command_result(mode_sense_data_10, + tb.mode_sense_data_10->mode_data_length=sizeof(struct mode_sense_data_10); + tb.mode_sense_data_10->medium_type=0; + tb.mode_sense_data_10->device_specific=0; + tb.mode_sense_data_10->reserved=0; + tb.mode_sense_data_10->longlba=1; + tb.mode_sense_data_10->block_descriptor_length=sizeof(struct mode_sense_block_descriptor_longlba); + memset(tb.mode_sense_data_10->block_descriptor.reserved,0,4); + memset(tb.mode_sense_data_10->block_descriptor.number_of_blocks,0,8); + tb.mode_sense_data_10->block_descriptor.number_of_blocks[4]=((block_count/block_size_mult) & 0xff000000)>>24; + tb.mode_sense_data_10->block_descriptor.number_of_blocks[5]=((block_count/block_size_mult) & 0x00ff0000)>>16; + tb.mode_sense_data_10->block_descriptor.number_of_blocks[6]=((block_count/block_size_mult) & 0x0000ff00)>>8; + tb.mode_sense_data_10->block_descriptor.number_of_blocks[7]=((block_count/block_size_mult) & 0x000000ff); + + tb.mode_sense_data_10->block_descriptor.block_size[0]=((block_size*block_size_mult) & 0xff000000)>>24; + tb.mode_sense_data_10->block_descriptor.block_size[1]=((block_size*block_size_mult) & 0x00ff0000)>>16; + tb.mode_sense_data_10->block_descriptor.block_size[2]=((block_size*block_size_mult) & 0x0000ff00)>>8; + tb.mode_sense_data_10->block_descriptor.block_size[3]=((block_size*block_size_mult) & 0x000000ff); + send_command_result(tb.mode_sense_data_10, MIN(sizeof(struct mode_sense_data_10), length)); break; default: @@ -588,26 +581,26 @@ static void handle_scsi(struct command_block_wrapper* cbw) switch(page_code) { case 0x3f: /* All supported pages Since we support only one this is easy*/ - mode_sense_data_6->mode_data_length=sizeof(struct mode_sense_data_6); - mode_sense_data_6->medium_type=0; - mode_sense_data_6->device_specific=0; - mode_sense_data_6->block_descriptor_length=sizeof(struct mode_sense_block_descriptor_shortlba); - mode_sense_data_6->block_descriptor.density_code=0; - mode_sense_data_6->block_descriptor.reserved=0; + tb.mode_sense_data_6->mode_data_length=sizeof(struct mode_sense_data_6); + tb.mode_sense_data_6->medium_type=0; + tb.mode_sense_data_6->device_specific=0; + tb.mode_sense_data_6->block_descriptor_length=sizeof(struct mode_sense_block_descriptor_shortlba); + tb.mode_sense_data_6->block_descriptor.density_code=0; + tb.mode_sense_data_6->block_descriptor.reserved=0; if(block_count/block_size_mult > 0xffffff){ - mode_sense_data_6->block_descriptor.number_of_blocks[0]=0xff; - mode_sense_data_6->block_descriptor.number_of_blocks[1]=0xff; - mode_sense_data_6->block_descriptor.number_of_blocks[2]=0xff; + tb.mode_sense_data_6->block_descriptor.number_of_blocks[0]=0xff; + tb.mode_sense_data_6->block_descriptor.number_of_blocks[1]=0xff; + tb.mode_sense_data_6->block_descriptor.number_of_blocks[2]=0xff; } else { - mode_sense_data_6->block_descriptor.number_of_blocks[0]=((block_count/block_size_mult) & 0xff0000)>>16; - mode_sense_data_6->block_descriptor.number_of_blocks[1]=((block_count/block_size_mult) & 0x00ff00)>>8; - mode_sense_data_6->block_descriptor.number_of_blocks[2]=((block_count/block_size_mult) & 0x0000ff); + tb.mode_sense_data_6->block_descriptor.number_of_blocks[0]=((block_count/block_size_mult) & 0xff0000)>>16; + tb.mode_sense_data_6->block_descriptor.number_of_blocks[1]=((block_count/block_size_mult) & 0x00ff00)>>8; + tb.mode_sense_data_6->block_descriptor.number_of_blocks[2]=((block_count/block_size_mult) & 0x0000ff); } - mode_sense_data_6->block_descriptor.block_size[0]=((block_size*block_size_mult) & 0xff0000)>>16; - mode_sense_data_6->block_descriptor.block_size[1]=((block_size*block_size_mult) & 0x00ff00)>>8; - mode_sense_data_6->block_descriptor.block_size[2]=((block_size*block_size_mult) & 0x0000ff); - send_command_result(mode_sense_data_6, + tb.mode_sense_data_6->block_descriptor.block_size[0]=((block_size*block_size_mult) & 0xff0000)>>16; + tb.mode_sense_data_6->block_descriptor.block_size[1]=((block_size*block_size_mult) & 0x00ff00)>>8; + tb.mode_sense_data_6->block_descriptor.block_size[2]=((block_size*block_size_mult) & 0x0000ff); + send_command_result(tb.mode_sense_data_6, MIN(sizeof(struct mode_sense_data_6), length)); break; default: @@ -633,13 +626,13 @@ static void handle_scsi(struct command_block_wrapper* cbw) case SCSI_READ_FORMAT_CAPACITY: { logf("scsi read_format_capacity %d",lun); if(lun_present) { - format_capacity_data->following_length=htobe32(8); + tb.format_capacity_data->following_length=htobe32(8); /* Careful: "block count" actually means "number of last block" */ - format_capacity_data->block_count = htobe32(block_count/block_size_mult - 1); - format_capacity_data->block_size = htobe32(block_size*block_size_mult); - format_capacity_data->block_size |= SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA; + tb.format_capacity_data->block_count = htobe32(block_count/block_size_mult - 1); + tb.format_capacity_data->block_size = htobe32(block_size*block_size_mult); + tb.format_capacity_data->block_size |= SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA; - send_command_result(format_capacity_data, + send_command_result(tb.format_capacity_data, MIN(sizeof(struct format_capacity), length)); } else @@ -656,10 +649,10 @@ static void handle_scsi(struct command_block_wrapper* cbw) if(lun_present) { /* Careful: "block count" actually means "number of last block" */ - capacity_data->block_count = htobe32(block_count/block_size_mult - 1); - capacity_data->block_size = htobe32(block_size*block_size_mult); + tb.capacity_data->block_count = htobe32(block_count/block_size_mult - 1); + tb.capacity_data->block_size = htobe32(block_size*block_size_mult); - send_command_result(capacity_data, MIN(sizeof(struct capacity), length)); + send_command_result(tb.capacity_data, MIN(sizeof(struct capacity), length)); } else { @@ -680,8 +673,8 @@ static void handle_scsi(struct command_block_wrapper* cbw) cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; break; } - current_cmd.data[0] = transfer_buffer; - current_cmd.data[1] = &transfer_buffer[BUFFER_SIZE]; + current_cmd.data[0] = tb.transfer_buffer; + current_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; current_cmd.data_select=0; current_cmd.sector = block_size_mult * (cbw->command_block[2] << 24 | @@ -717,8 +710,8 @@ static void handle_scsi(struct command_block_wrapper* cbw) cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; break; } - current_cmd.data[0] = transfer_buffer; - current_cmd.data[1] = &transfer_buffer[BUFFER_SIZE]; + current_cmd.data[0] = tb.transfer_buffer; + current_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; current_cmd.data_select=0; current_cmd.sector = block_size_mult * (cbw->command_block[2] << 24 | @@ -770,12 +763,12 @@ static void receive_block_data(void *data,int size) static void send_csw(int status) { - csw->signature = htole32(CSW_SIGNATURE); - csw->tag = current_cmd.tag; - csw->data_residue = 0; - csw->status = status; + tb.csw->signature = htole32(CSW_SIGNATURE); + tb.csw->tag = current_cmd.tag; + tb.csw->data_residue = 0; + tb.csw->status = status; - usb_drv_send_nonblocking(EP_MASS_STORAGE, csw, sizeof(struct command_status_wrapper)); + usb_drv_send_nonblocking(EP_MASS_STORAGE, tb.csw, sizeof(struct command_status_wrapper)); state = SENDING_CSW; //logf("CSW: %X",status); @@ -791,14 +784,14 @@ static void identify2inquiry(int lun) { #ifdef HAVE_FLASH_STORAGE if(lun==0) { - memcpy(&inquiry->VendorId,"Rockbox ",8); - memcpy(&inquiry->ProductId,"Internal Storage",16); - memcpy(&inquiry->ProductRevisionLevel,"0.00",4); + memcpy(&tb.inquiry->VendorId,"Rockbox ",8); + memcpy(&tb.inquiry->ProductId,"Internal Storage",16); + memcpy(&tb.inquiry->ProductRevisionLevel,"0.00",4); } else { - memcpy(&inquiry->VendorId,"Rockbox ",8); - memcpy(&inquiry->ProductId,"SD Card Slot ",16); - memcpy(&inquiry->ProductRevisionLevel,"0.00",4); + memcpy(&tb.inquiry->VendorId,"Rockbox ",8); + memcpy(&tb.inquiry->ProductId,"SD Card Slot ",16); + memcpy(&tb.inquiry->ProductRevisionLevel,"0.00",4); } #else unsigned int i; @@ -806,33 +799,33 @@ static void identify2inquiry(int lun) unsigned short* src; unsigned short* identify = ata_get_identify(); (void)lun; - memset(inquiry, 0, sizeof(struct inquiry_data)); + memset(tb.inquiry, 0, sizeof(struct inquiry_data)); if (identify[82] & 4) - inquiry->DeviceTypeModifier = DEVICE_REMOVABLE; + tb.inquiry->DeviceTypeModifier = DEVICE_REMOVABLE; /* ATA only has a 'model' field, so we copy the first 8 bytes to 'vendor' and the rest to 'product' (they are consecutive in the inquiry struct) */ src = (unsigned short*)&identify[27]; - dest = (unsigned short*)&inquiry->VendorId; + dest = (unsigned short*)&tb.inquiry->VendorId; for (i=0;i<12;i++) dest[i] = htobe16(src[i]); src = (unsigned short*)&identify[23]; - dest = (unsigned short*)&inquiry->ProductRevisionLevel; + dest = (unsigned short*)&tb.inquiry->ProductRevisionLevel; for (i=0;i<2;i++) dest[i] = htobe16(src[i]); #endif - inquiry->DeviceType = DIRECT_ACCESS_DEVICE; - inquiry->AdditionalLength = 0x1f; - inquiry->Versions = 4; /* SPC-2 */ - inquiry->Format = 2; /* SPC-2/3 inquiry format */ + tb.inquiry->DeviceType = DIRECT_ACCESS_DEVICE; + tb.inquiry->AdditionalLength = 0x1f; + tb.inquiry->Versions = 4; /* SPC-2 */ + tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */ #ifdef HAVE_HOTSWAP if(lun>0) - inquiry->DeviceTypeModifier = DEVICE_REMOVABLE; + tb.inquiry->DeviceTypeModifier = DEVICE_REMOVABLE; #endif } -- cgit v1.2.3