From 760c3b3a1774be4899d1e315f68e3ce93c31dceb Mon Sep 17 00:00:00 2001 From: Alan Stern Date: Fri, 16 Jan 2004 01:11:16 -0800 Subject: [PATCH] [PATCH] USB Storage: Remove non s-g pathway from subdriver READ/WRITE This patch does what you suggested. The read/write routines from the updated subdrivers are changed so they don't bother to differentiate between transfers that do or do not use scatter-gather. The low-level usb_stor_access_xfer_buf routine will Do The Right Thing regardless, and there probably won't ever be more than a few non s-g calls. (What about filesystem I/O requests to access metadata?) It turns out that in addition to removing some comments and a few tests, this change allowed me to remove the buffer and use_sg arguments passed to the read/write routines as well. So the simplification ended up being a bit bigger than I expected. While writing this patch, I noticed spots in several drivers that still need to be changed -- they slipped past me before. These drivers handle things like READ-CAPACITY or REQUEST-SENSE by copying the data directly to srb->request_buffer, which is obviously wrong if s-g is being used. I'll send in changes next week that convert them to use the usb_stor_set_xfer_buf function. Like you said, it's going to be handy in more places than originally intended! --- drivers/usb/storage/datafab.c | 80 ++++++++++---------------- drivers/usb/storage/jumpshot.c | 80 ++++++++++---------------- drivers/usb/storage/sddr09.c | 87 ++++++++++------------------- drivers/usb/storage/sddr55.c | 83 ++++++++++----------------- drivers/usb/storage/shuttle_usbat.c | 28 +++------- 5 files changed, 126 insertions(+), 232 deletions(-) diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c index 3ae9abbaabb12..ce006b2a198c1 100644 --- a/drivers/usb/storage/datafab.c +++ b/drivers/usb/storage/datafab.c @@ -89,11 +89,10 @@ datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) { static int datafab_read_data(struct us_data *us, struct datafab_info *info, u32 sector, - u32 sectors, - unsigned char *buffer, - int use_sg) + u32 sectors) { unsigned char *command = us->iobuf; + unsigned char *buffer; unsigned char thistime; unsigned int totallen, alloclen; int len, result; @@ -116,18 +115,13 @@ static int datafab_read_data(struct us_data *us, totallen = sectors * info->ssize; // Since we don't read more than 64 KB at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. alloclen = min(totallen, 65536u); - if (use_sg) { - buffer = kmalloc(alloclen, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; - } + buffer = kmalloc(alloclen, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; do { // loop, never allocate or transfer more than 64k at once @@ -157,24 +151,19 @@ static int datafab_read_data(struct us_data *us, if (result != USB_STOR_XFER_GOOD) goto leave; - // Store the data (s-g) or update the pointer (!s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &sg_idx, &sg_offset, TO_XFER_BUF); - else - buffer += len; + // Store the data in the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &sg_idx, &sg_offset, TO_XFER_BUF); sector += thistime; totallen -= len; } while (totallen > 0); - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_GOOD; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_ERROR; } @@ -182,12 +171,11 @@ static int datafab_read_data(struct us_data *us, static int datafab_write_data(struct us_data *us, struct datafab_info *info, u32 sector, - u32 sectors, - unsigned char *buffer, - int use_sg) + u32 sectors) { unsigned char *command = us->iobuf; unsigned char *reply = us->iobuf; + unsigned char *buffer; unsigned char thistime; unsigned int totallen, alloclen; int len, result; @@ -210,18 +198,13 @@ static int datafab_write_data(struct us_data *us, totallen = sectors * info->ssize; // Since we don't write more than 64 KB at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. alloclen = min(totallen, 65536u); - if (use_sg) { - buffer = kmalloc(alloclen, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; - } + buffer = kmalloc(alloclen, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; do { // loop, never allocate or transfer more than 64k at once @@ -230,10 +213,9 @@ static int datafab_write_data(struct us_data *us, len = min(totallen, alloclen); thistime = (len / info->ssize) & 0xff; - // Get the data from the transfer buffer (s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &sg_idx, &sg_offset, FROM_XFER_BUF); + // Get the data from the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &sg_idx, &sg_offset, FROM_XFER_BUF); command[0] = 0; command[1] = thistime; @@ -269,21 +251,15 @@ static int datafab_write_data(struct us_data *us, goto leave; } - // Update the transfer buffer pointer (!s-g) - if (!use_sg) - buffer += len; - sector += thistime; totallen -= len; } while (totallen > 0); - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_GOOD; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_ERROR; } @@ -615,7 +591,7 @@ int datafab_transport(Scsi_Cmnd * srb, struct us_data *us) blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); US_DEBUGP("datafab_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks); - return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg); + return datafab_read_data(us, info, block, blocks); } if (srb->cmnd[0] == READ_12) { @@ -628,7 +604,7 @@ int datafab_transport(Scsi_Cmnd * srb, struct us_data *us) ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); US_DEBUGP("datafab_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks); - return datafab_read_data(us, info, block, blocks, ptr, srb->use_sg); + return datafab_read_data(us, info, block, blocks); } if (srb->cmnd[0] == WRITE_10) { @@ -638,7 +614,7 @@ int datafab_transport(Scsi_Cmnd * srb, struct us_data *us) blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); US_DEBUGP("datafab_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks); - return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg); + return datafab_write_data(us, info, block, blocks); } if (srb->cmnd[0] == WRITE_12) { @@ -651,7 +627,7 @@ int datafab_transport(Scsi_Cmnd * srb, struct us_data *us) ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); US_DEBUGP("datafab_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks); - return datafab_write_data(us, info, block, blocks, ptr, srb->use_sg); + return datafab_write_data(us, info, block, blocks); } if (srb->cmnd[0] == TEST_UNIT_READY) { diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c index 0e142a37006cb..761bea206d680 100644 --- a/drivers/usb/storage/jumpshot.c +++ b/drivers/usb/storage/jumpshot.c @@ -109,11 +109,10 @@ static int jumpshot_get_status(struct us_data *us) static int jumpshot_read_data(struct us_data *us, struct jumpshot_info *info, u32 sector, - u32 sectors, - unsigned char *buffer, - int use_sg) + u32 sectors) { unsigned char *command = us->iobuf; + unsigned char *buffer; unsigned char thistime; unsigned int totallen, alloclen; int len, result; @@ -130,18 +129,13 @@ static int jumpshot_read_data(struct us_data *us, totallen = sectors * info->ssize; // Since we don't read more than 64 KB at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. alloclen = min(totallen, 65536u); - if (use_sg) { - buffer = kmalloc(alloclen, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; - } + buffer = kmalloc(alloclen, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; do { // loop, never allocate or transfer more than 64k at once @@ -171,24 +165,19 @@ static int jumpshot_read_data(struct us_data *us, US_DEBUGP("jumpshot_read_data: %d bytes\n", len); - // Store the data (s-g) or update the pointer (!s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &sg_idx, &sg_offset, TO_XFER_BUF); - else - buffer += len; + // Store the data in the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &sg_idx, &sg_offset, TO_XFER_BUF); sector += thistime; totallen -= len; } while (totallen > 0); - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_GOOD; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_ERROR; } @@ -196,11 +185,10 @@ static int jumpshot_read_data(struct us_data *us, static int jumpshot_write_data(struct us_data *us, struct jumpshot_info *info, u32 sector, - u32 sectors, - unsigned char *buffer, - int use_sg) + u32 sectors) { unsigned char *command = us->iobuf; + unsigned char *buffer; unsigned char thistime; unsigned int totallen, alloclen; int len, result, waitcount; @@ -217,18 +205,13 @@ static int jumpshot_write_data(struct us_data *us, totallen = sectors * info->ssize; // Since we don't write more than 64 KB at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. alloclen = min(totallen, 65536u); - if (use_sg) { - buffer = kmalloc(alloclen, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; - } + buffer = kmalloc(alloclen, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; do { // loop, never allocate or transfer more than 64k at once @@ -237,10 +220,9 @@ static int jumpshot_write_data(struct us_data *us, len = min(totallen, alloclen); thistime = (len / info->ssize) & 0xff; - // Get the data from the transfer buffer (s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &sg_idx, &sg_offset, FROM_XFER_BUF); + // Get the data from the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &sg_idx, &sg_offset, FROM_XFER_BUF); command[0] = 0; command[1] = thistime; @@ -278,21 +260,15 @@ static int jumpshot_write_data(struct us_data *us, if (result != USB_STOR_TRANSPORT_GOOD) US_DEBUGP("jumpshot_write_data: Gah! Waitcount = 10. Bad write!?\n"); - // Update the transfer buffer pointer (!s-g) - if (!use_sg) - buffer += len; - sector += thistime; totallen -= len; } while (totallen > 0); - if (use_sg) - kfree(buffer); + kfree(buffer); return result; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return USB_STOR_TRANSPORT_ERROR; } @@ -546,7 +522,7 @@ int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us) blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); US_DEBUGP("jumpshot_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks); - return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg); + return jumpshot_read_data(us, info, block, blocks); } if (srb->cmnd[0] == READ_12) { @@ -559,7 +535,7 @@ int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us) ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); US_DEBUGP("jumpshot_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks); - return jumpshot_read_data(us, info, block, blocks, ptr, srb->use_sg); + return jumpshot_read_data(us, info, block, blocks); } if (srb->cmnd[0] == WRITE_10) { @@ -569,7 +545,7 @@ int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us) blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); US_DEBUGP("jumpshot_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks); - return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg); + return jumpshot_write_data(us, info, block, blocks); } if (srb->cmnd[0] == WRITE_12) { @@ -582,7 +558,7 @@ int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us) ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); US_DEBUGP("jumpshot_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks); - return jumpshot_write_data(us, info, block, blocks, ptr, srb->use_sg); + return jumpshot_write_data(us, info, block, blocks); } diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c index eca4038f4d6c2..78c32732348a3 100644 --- a/drivers/usb/storage/sddr09.c +++ b/drivers/usb/storage/sddr09.c @@ -662,31 +662,24 @@ sddr09_read_status(struct us_data *us, unsigned char *status) { static int sddr09_read_data(struct us_data *us, unsigned long address, - unsigned int sectors, - unsigned char *buffer, - int use_sg) { + unsigned int sectors) { struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra; + unsigned char *buffer; unsigned int lba, maxlba, pba; unsigned int page, pages; unsigned int len, index, offset; int result; // Since we only read in one block at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. - - if (use_sg) { - len = min(sectors, (unsigned int) info->blocksize) * - info->pagesize; - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) { - printk("sddr09_read_data: Out of memory\n"); - return USB_STOR_TRANSPORT_ERROR; - } + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. + + len = min(sectors, (unsigned int) info->blocksize) * info->pagesize; + buffer = kmalloc(len, GFP_NOIO); + if (buffer == NULL) { + printk("sddr09_read_data: Out of memory\n"); + return USB_STOR_TRANSPORT_ERROR; } // Figure out the initial LBA and page @@ -743,21 +736,16 @@ sddr09_read_data(struct us_data *us, break; } - // Store the data (s-g) or update the pointer (!s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, TO_XFER_BUF); - else - buffer += len; + // Store the data in the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &index, &offset, TO_XFER_BUF); page = 0; lba++; sectors -= pages; } - if (use_sg) - kfree(buffer); - + kfree(buffer); return result; } @@ -897,14 +885,13 @@ sddr09_write_lba(struct us_data *us, unsigned int lba, static int sddr09_write_data(struct us_data *us, unsigned long address, - unsigned int sectors, - unsigned char *buffer, - int use_sg) { + unsigned int sectors) { struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra; unsigned int lba, page, pages; unsigned int pagelen, blocklen; unsigned char *blockbuffer; + unsigned char *buffer; unsigned int len, index, offset; int result; @@ -923,21 +910,15 @@ sddr09_write_data(struct us_data *us, } // Since we don't write the user data directly to the device, - // we have to create a bounce buffer if the transfer uses - // scatter-gather. We will move the data a piece at a time - // between the bounce buffer and the actual transfer buffer. - // If we're not using scatter-gather, we can simply update - // the transfer buffer pointer to get the same effect. - - if (use_sg) { - len = min(sectors, (unsigned int) info->blocksize) * - info->pagesize; - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) { - printk("sddr09_write_data: Out of memory\n"); - kfree(blockbuffer); - return USB_STOR_TRANSPORT_ERROR; - } + // we have to create a bounce buffer and move the data a piece + // at a time between the bounce buffer and the actual transfer buffer. + + len = min(sectors, (unsigned int) info->blocksize) * info->pagesize; + buffer = kmalloc(len, GFP_NOIO); + if (buffer == NULL) { + printk("sddr09_write_data: Out of memory\n"); + kfree(blockbuffer); + return USB_STOR_TRANSPORT_ERROR; } // Figure out the initial LBA and page @@ -954,27 +935,21 @@ sddr09_write_data(struct us_data *us, pages = min(sectors, info->blocksize - page); len = (pages << info->pageshift); - // Get the data from the transfer buffer (s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, FROM_XFER_BUF); + // Get the data from the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &index, &offset, FROM_XFER_BUF); result = sddr09_write_lba(us, lba, page, pages, buffer, blockbuffer); if (result != USB_STOR_TRANSPORT_GOOD) break; - // Update the transfer buffer pointer (!s-g) - if (!use_sg) - buffer += len; - page = 0; lba++; sectors -= pages; } - if (use_sg) - kfree(buffer); + kfree(buffer); kfree(blockbuffer); return result; @@ -1546,7 +1521,7 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us) US_DEBUGP("READ_10: read page %d pagect %d\n", page, pages); - return sddr09_read_data(us, page, pages, ptr, srb->use_sg); + return sddr09_read_data(us, page, pages); } if (srb->cmnd[0] == WRITE_10) { @@ -1559,7 +1534,7 @@ int sddr09_transport(Scsi_Cmnd *srb, struct us_data *us) US_DEBUGP("WRITE_10: write page %d pagect %d\n", page, pages); - return sddr09_write_data(us, page, pages, ptr, srb->use_sg); + return sddr09_write_data(us, page, pages); } // Pass TEST_UNIT_READY and REQUEST_SENSE through diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c index 0608bff93ff0b..65a9d53e41693 100644 --- a/drivers/usb/storage/sddr55.c +++ b/drivers/usb/storage/sddr55.c @@ -153,14 +153,13 @@ static int sddr55_status(struct us_data *us) static int sddr55_read_data(struct us_data *us, unsigned int lba, unsigned int page, - unsigned short sectors, - unsigned char *buffer, - int use_sg) { + unsigned short sectors) { int result = USB_STOR_TRANSPORT_GOOD; unsigned char *command = us->iobuf; unsigned char *status = us->iobuf; struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; + unsigned char *buffer; unsigned int pba; unsigned long address; @@ -169,20 +168,14 @@ static int sddr55_read_data(struct us_data *us, unsigned int len, index, offset; // Since we only read in one block at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. - - if (use_sg) { - len = min((unsigned int) sectors, - (unsigned int) info->blocksize >> - info->smallpageshift) * PAGESIZE; - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; /* out of memory */ - } + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. + + len = min((unsigned int) sectors, (unsigned int) info->blocksize >> + info->smallpageshift) * PAGESIZE; + buffer = kmalloc(len, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; /* out of memory */ index = offset = 0; while (sectors>0) { @@ -258,12 +251,9 @@ static int sddr55_read_data(struct us_data *us, } } - // Store the data (s-g) or update the pointer (!s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, TO_XFER_BUF); - else - buffer += len; + // Store the data in the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &index, &offset, TO_XFER_BUF); page = 0; lba++; @@ -273,8 +263,7 @@ static int sddr55_read_data(struct us_data *us, result = USB_STOR_TRANSPORT_GOOD; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return result; } @@ -282,14 +271,13 @@ leave: static int sddr55_write_data(struct us_data *us, unsigned int lba, unsigned int page, - unsigned short sectors, - unsigned char *buffer, - int use_sg) { + unsigned short sectors) { int result = USB_STOR_TRANSPORT_GOOD; unsigned char *command = us->iobuf; unsigned char *status = us->iobuf; struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; + unsigned char *buffer; unsigned int pba; unsigned int new_pba; @@ -306,20 +294,14 @@ static int sddr55_write_data(struct us_data *us, } // Since we only write one block at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. - - if (use_sg) { - len = min((unsigned int) sectors, - (unsigned int) info->blocksize >> - info->smallpageshift) * PAGESIZE; - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) - return USB_STOR_TRANSPORT_ERROR; - } + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. + + len = min((unsigned int) sectors, (unsigned int) info->blocksize >> + info->smallpageshift) * PAGESIZE; + buffer = kmalloc(len, GFP_NOIO); + if (buffer == NULL) + return USB_STOR_TRANSPORT_ERROR; index = offset = 0; while (sectors > 0) { @@ -336,10 +318,9 @@ static int sddr55_write_data(struct us_data *us, info->blocksize - page); len = pages << info->pageshift; - // Get the data from the transfer buffer (s-g) - if (use_sg) - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, FROM_XFER_BUF); + // Get the data from the transfer buffer + usb_stor_access_xfer_buf(buffer, len, us->srb, + &index, &offset, FROM_XFER_BUF); US_DEBUGP("Write %02X pages, to PBA %04X" " (LBA %04X) page %02X\n", @@ -480,9 +461,6 @@ static int sddr55_write_data(struct us_data *us, /* update the pba<->lba maps for new_pba */ info->pba_to_lba[new_pba] = lba % 1000; - // Update the transfer buffer pointer (!s-g) - if (!use_sg) - buffer += len; page = 0; lba++; sectors -= pages >> info->smallpageshift; @@ -490,8 +468,7 @@ static int sddr55_write_data(struct us_data *us, result = USB_STOR_TRANSPORT_GOOD; leave: - if (use_sg) - kfree(buffer); + kfree(buffer); return result; } @@ -963,13 +940,13 @@ int sddr55_transport(Scsi_Cmnd *srb, struct us_data *us) " pages %d\n", pba, lba, page, pages); - return sddr55_write_data(us, lba, page, pages, ptr, srb->use_sg); + return sddr55_write_data(us, lba, page, pages); } else { US_DEBUGP("READ_10: read block %04X (LBA %04X) page %01X" " pages %d\n", pba, lba, page, pages); - return sddr55_read_data(us, lba, page, pages, ptr, srb->use_sg); + return sddr55_read_data(us, lba, page, pages); } } diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c index 82ac6e4120e50..7dcbf6ee3989e 100644 --- a/drivers/usb/storage/shuttle_usbat.c +++ b/drivers/usb/storage/shuttle_usbat.c @@ -569,21 +569,15 @@ int usbat_handle_read10(struct us_data *us, } // Since we only read in one block at a time, we have to create - // a bounce buffer if the transfer uses scatter-gather. We will - // move the data a piece at a time between the bounce buffer and - // the actual transfer buffer. If we're not using scatter-gather, - // we can simply update the transfer buffer pointer to get the - // same effect. + // a bounce buffer and move the data a piece at a time between the + // bounce buffer and the actual transfer buffer. len = (65535/srb->transfersize) * srb->transfersize; US_DEBUGP("Max read is %d bytes\n", len); len = min(len, srb->request_bufflen); - if (srb->use_sg) { - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) // bloody hell! - return USB_STOR_TRANSPORT_FAILED; - } else - buffer = srb->request_buffer; + buffer = kmalloc(len, GFP_NOIO); + if (buffer == NULL) // bloody hell! + return USB_STOR_TRANSPORT_FAILED; sector = short_pack(data[7+3], data[7+2]); sector <<= 16; sector |= short_pack(data[7+5], data[7+4]); @@ -621,12 +615,9 @@ int usbat_handle_read10(struct us_data *us, if (result != USB_STOR_TRANSPORT_GOOD) break; - // Store the data (s-g) or update the pointer (!s-g) - if (srb->use_sg) - usb_stor_access_xfer_buf(buffer, len, srb, - &sg_segment, &sg_offset, TO_XFER_BUF); - else - buffer += len; + // Store the data in the transfer buffer + usb_stor_access_xfer_buf(buffer, len, srb, + &sg_segment, &sg_offset, TO_XFER_BUF); // Update the amount transferred and the sector number @@ -635,8 +626,7 @@ int usbat_handle_read10(struct us_data *us, } // while transferred != srb->request_bufflen - if (srb->use_sg) - kfree(buffer); + kfree(buffer); return result; } -- 2.53.0