/* Driver for Lexar "Jumpshot" Compact Flash reader * * $Id: jumpshot.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $ * * jumpshot driver v0.1: * * First release * * Current development and maintenance by: * (c) 2000 Jimmie Mayfield (mayfield+usb@sackheads.org) * * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver * which I used as a template for this driver. * * Some bugfixes and scatter-gather code by Gregory P. Smith * (greg-usb@electricrain.com) * * Fix for media change by Joerg Schneider (js@joergschneider.com) * * Developed with the assistance of: * * (C) 2002 Alan Stern * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2, or (at your option) any * later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * This driver attempts to support the Lexar Jumpshot USB CompactFlash * reader. Like many other USB CompactFlash readers, the Jumpshot contains * a USB-to-ATA chip. * * This driver supports reading and writing. If you're truly paranoid, * however, you can force the driver into a write-protected state by setting * the WP enable bits in jumpshot_handle_mode_sense. Basically this means * setting mode_param_header[3] = 0x80. */ #include "transport.h" #include "protocol.h" #include "usb.h" #include "debug.h" #include "jumpshot.h" #include #include #include extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe, u8 request, u8 requesttype, u16 value, u16 index, void *data, u16 size); extern int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe, unsigned int len, unsigned int *act_len); #if 0 static void jumpshot_dump_data(unsigned char *data, int len) { unsigned char buf[80]; int sofar = 0; if (!data) return; memset(buf, 0, sizeof(buf)); for (sofar = 0; sofar < len; sofar++) { sprintf(buf + strlen(buf), "%02x ", ((unsigned int) data[sofar]) & 0xFF); if (sofar % 16 == 15) { US_DEBUGP("jumpshot: %s\n", buf); memset(buf, 0, sizeof(buf)); } } if (strlen(buf) != 0) US_DEBUGP("jumpshot: %s\n", buf); } #endif /* * Send a control message and wait for the response. * * us - the pointer to the us_data structure for the device to use * * request - the URB Setup Packet's first 6 bytes. The first byte always * corresponds to the request type, and the second byte always corresponds * to the request. The other 4 bytes do not correspond to value and index, * since they are used in a custom way by the SCM protocol. * * xfer_data - a buffer from which to get, or to which to store, any data * that gets send or received, respectively, with the URB. Even though * it looks like we allocate a buffer in this code for the data, xfer_data * must contain enough allocated space. * * xfer_len - the number of bytes to send or receive with the URB. * * This routine snarfed from the SanDisk SDDR-09 driver * */ static int jumpshot_send_control(struct us_data *us, int pipe, unsigned char request, unsigned char requesttype, unsigned short value, unsigned short index, unsigned char *xfer_data, unsigned int xfer_len) { int result; // Send the URB to the device and wait for a response. /* Why are request and request type reversed in this call? */ result = usb_stor_control_msg(us, pipe, request, requesttype, value, index, xfer_data, xfer_len); // Check the return code for the command. if (result < 0) { /* if the command was aborted, indicate that */ if (result == -ECONNRESET) return USB_STOR_TRANSPORT_ABORTED; /* a stall is a fatal condition from the device */ if (result == -EPIPE) { US_DEBUGP("jumpshot_send_control: -- Stall on control pipe. Clearing\n"); result = usb_stor_clear_halt(us, pipe); US_DEBUGP("jumpshot_send_control: -- usb_stor_clear_halt() returns %d\n", result); return USB_STOR_TRANSPORT_FAILED; } /* Uh oh... serious problem here */ return USB_STOR_TRANSPORT_ERROR; } return USB_STOR_TRANSPORT_GOOD; } static int jumpshot_raw_bulk(int direction, struct us_data *us, unsigned char *data, unsigned int len) { int result; int act_len; int pipe; if (direction == SCSI_DATA_READ) pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); else pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); result = usb_stor_bulk_msg(us, data, pipe, len, &act_len); // if we stall, we need to clear it before we go on if (result == -EPIPE) { US_DEBUGP("jumpshot_raw_bulk: EPIPE. clearing endpoint halt for" " pipe 0x%x, stalled at %d bytes\n", pipe, act_len); usb_stor_clear_halt(us, pipe); } if (result) { // NAK - that means we've retried a few times already if (result == -ETIMEDOUT) { US_DEBUGP("jumpshot_raw_bulk: device NAKed\n"); return US_BULK_TRANSFER_FAILED; } // -ECONNRESET -- we canceled this transfer if (result == -ECONNRESET) { US_DEBUGP("jumpshot_raw_bulk: transfer aborted\n"); return US_BULK_TRANSFER_ABORTED; } if (result == -EPIPE) { US_DEBUGP("jumpshot_raw_bulk: output pipe stalled\n"); return USB_STOR_TRANSPORT_FAILED; } // the catch-all case US_DEBUGP("jumpshot_raw_bulk: unknown error\n"); return US_BULK_TRANSFER_FAILED; } if (act_len != len) { US_DEBUGP("jumpshot_raw_bulk: Warning. Transferred only %d bytes\n", act_len); return US_BULK_TRANSFER_SHORT; } US_DEBUGP("jumpshot_raw_bulk: Transfered %d of %d bytes\n", act_len, len); return US_BULK_TRANSFER_GOOD; } static inline int jumpshot_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) { if (len == 0) return USB_STOR_TRANSPORT_GOOD; US_DEBUGP("jumpshot_bulk_read: len = %d\n", len); return jumpshot_raw_bulk(SCSI_DATA_READ, us, data, len); } static inline int jumpshot_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) { if (len == 0) return USB_STOR_TRANSPORT_GOOD; US_DEBUGP("jumpshot_bulk_write: len = %d\n", len); return jumpshot_raw_bulk(SCSI_DATA_WRITE, us, data, len); } static int jumpshot_get_status(struct us_data *us) { unsigned char reply; int rc; if (!us) return USB_STOR_TRANSPORT_ERROR; // send the setup rc = jumpshot_send_control(us, usb_rcvctrlpipe(us->pusb_dev, 0), 0, 0xA0, 0, 7, &reply, 1); if (rc != USB_STOR_TRANSPORT_GOOD) return rc; if (reply != 0x50) { US_DEBUGP("jumpshot_get_status: 0x%2x\n", (unsigned short) (reply)); return USB_STOR_TRANSPORT_ERROR; } return USB_STOR_TRANSPORT_GOOD; } static int jumpshot_read_data(struct us_data *us, struct jumpshot_info *info, u32 sector, u32 sectors, unsigned char *dest, int use_sg) { unsigned char command[] = { 0, 0, 0, 0, 0, 0xe0, 0x20 }; unsigned char *buffer = NULL; unsigned char *ptr; unsigned char thistime; struct scatterlist *sg = NULL; int totallen, len, result; int sg_idx = 0, current_sg_offset = 0; int transferred; // we're working in LBA mode. according to the ATA spec, // we can support up to 28-bit addressing. I don't know if Jumpshot // supports beyond 24-bit addressing. It's kind of hard to test // since it requires > 8GB CF card. // if (sector > 0x0FFFFFFF) return USB_STOR_TRANSPORT_ERROR; // If we're using scatter-gather, we have to create a new // buffer to read all of the data in first, since a // scatter-gather buffer could in theory start in the middle // of a page, which would be bad. A developer who wants a // challenge might want to write a limited-buffer // version of this code. totallen = sectors * info->ssize; do { // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit) len = min_t(int, totallen, 65536); if (use_sg) { sg = (struct scatterlist *) dest; buffer = kmalloc(len, GFP_NOIO); if (buffer == NULL) return USB_STOR_TRANSPORT_ERROR; ptr = buffer; } else { ptr = dest; } thistime = (len / info->ssize) & 0xff; command[0] = 0; command[1] = thistime; command[2] = sector & 0xFF; command[3] = (sector >> 8) & 0xFF; command[4] = (sector >> 16) & 0xFF; command[5] |= (sector >> 24) & 0x0F; // send the setup + command result = jumpshot_send_control(us, usb_sndctrlpipe(us->pusb_dev, 0), 0, 0x20, 0, 1, command, 7); if (result != USB_STOR_TRANSPORT_GOOD) { if (use_sg) kfree(buffer); return result; } // read the result result = jumpshot_bulk_read(us, ptr, len); if (result != USB_STOR_TRANSPORT_GOOD) { if (use_sg) kfree(buffer); return result; } US_DEBUGP("jumpshot_read_data: %d bytes\n", len); //jumpshot_dump_data(ptr, len); sectors -= thistime; sector += thistime; if (use_sg) { transferred = 0; while (sg_idx < use_sg && transferred < len) { if (len - transferred >= sg[sg_idx].length - current_sg_offset) { US_DEBUGP("jumpshot_read_data: adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); memcpy(sg[sg_idx].address + current_sg_offset, buffer + transferred, sg[sg_idx].length - current_sg_offset); transferred += sg[sg_idx].length - current_sg_offset; current_sg_offset = 0; // on to the next sg buffer ++sg_idx; } else { US_DEBUGP("jumpshot_read_data: adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length); memcpy(sg[sg_idx].address + current_sg_offset, buffer + transferred, len - transferred); current_sg_offset += len - transferred; // this sg buffer is only partially full and we're out of data to copy in break; } } kfree(buffer); } else { dest += len; } totallen -= len; } while (totallen > 0); return USB_STOR_TRANSPORT_GOOD; } static int jumpshot_write_data(struct us_data *us, struct jumpshot_info *info, u32 sector, u32 sectors, unsigned char *src, int use_sg) { unsigned char command[7] = { 0, 0, 0, 0, 0, 0xE0, 0x30 }; unsigned char *buffer = NULL; unsigned char *ptr; unsigned char thistime; struct scatterlist *sg = NULL; int totallen, len, result, waitcount; int sg_idx = 0, current_sg_offset = 0; int transferred; // we're working in LBA mode. according to the ATA spec, // we can support up to 28-bit addressing. I don't know if Jumpshot // supports beyond 24-bit addressing. It's kind of hard to test // since it requires > 8GB CF card. // if (sector > 0x0FFFFFFF) return USB_STOR_TRANSPORT_ERROR; // If we're using scatter-gather, we have to create a new // buffer to read all of the data in first, since a // scatter-gather buffer could in theory start in the middle // of a page, which would be bad. A developer who wants a // challenge might want to write a limited-buffer // version of this code. totallen = sectors * info->ssize; do { // loop, never allocate or transfer more than 64k at once (min(128k, 255*info->ssize) is the real limit) len = min_t(int, totallen, 65536); if (use_sg) { sg = (struct scatterlist *) src; buffer = kmalloc(len, GFP_NOIO); if (buffer == NULL) return USB_STOR_TRANSPORT_ERROR; ptr = buffer; memset(buffer, 0, len); // copy the data from the sg bufs into the big contiguous buf // transferred = 0; while (transferred < len) { if (len - transferred >= sg[sg_idx].length - current_sg_offset) { US_DEBUGP("jumpshot_write_data: getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); memcpy(ptr + transferred, sg[sg_idx].address + current_sg_offset, sg[sg_idx].length - current_sg_offset); transferred += sg[sg_idx].length - current_sg_offset; current_sg_offset = 0; // on to the next sg buffer ++sg_idx; } else { US_DEBUGP("jumpshot_write_data: getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length); memcpy(ptr + transferred, sg[sg_idx].address + current_sg_offset, len - transferred); current_sg_offset += len - transferred; // we only copied part of this sg buffer break; } } } else { ptr = src; } thistime = (len / info->ssize) & 0xff; command[0] = 0; command[1] = thistime; command[2] = sector & 0xFF; command[3] = (sector >> 8) & 0xFF; command[4] = (sector >> 16) & 0xFF; command[5] |= (sector >> 24) & 0x0F; // send the setup + command result = jumpshot_send_control(us, usb_sndctrlpipe(us->pusb_dev, 0), 0, 0x20, 0, 1, command, 7); // send the data result = jumpshot_bulk_write(us, ptr, len); if (result != USB_STOR_TRANSPORT_GOOD) { if (use_sg) kfree(buffer); return result; } // read the result. apparently the bulk write can complete before the // jumpshot drive is finished writing. so we loop here until we // get a good return code waitcount = 0; do { result = jumpshot_get_status(us); if (result != USB_STOR_TRANSPORT_GOOD) { // I have not experimented to find the smallest value. // wait_ms(50); } } while ((result != USB_STOR_TRANSPORT_GOOD) && (waitcount < 10)); if (result != USB_STOR_TRANSPORT_GOOD) US_DEBUGP("jumpshot_write_data: Gah! Waitcount = 10. Bad write!?\n"); sectors -= thistime; sector += thistime; if (use_sg) { kfree(buffer); } else { src += len; } totallen -= len; } while (totallen > 0); return result; } static int jumpshot_id_device(struct us_data *us, struct jumpshot_info *info) { unsigned char command[2] = { 0xe0, 0xec }; unsigned char reply[512]; int rc; if (!us || !info) return USB_STOR_TRANSPORT_ERROR; // send the setup rc = jumpshot_send_control(us, usb_sndctrlpipe(us->pusb_dev, 0), 0, 0x20, 0, 6, command, 2); if (rc != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("jumpshot_id_device: Gah! send_control for read_capacity failed\n"); return rc; } // read the reply rc = jumpshot_bulk_read(us, reply, sizeof(reply)); if (rc != USB_STOR_TRANSPORT_GOOD) return rc; info->sectors = ((u32)(reply[117]) << 24) | ((u32)(reply[116]) << 16) | ((u32)(reply[115]) << 8) | ((u32)(reply[114]) ); return USB_STOR_TRANSPORT_GOOD; } static int jumpshot_handle_mode_sense(struct us_data *us, Scsi_Cmnd * srb, unsigned char *ptr, int sense_6) { unsigned char mode_param_header[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; unsigned char rw_err_page[12] = { 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0 }; unsigned char cache_page[12] = { 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; unsigned char rbac_page[12] = { 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0 }; unsigned char timer_page[8] = { 0x1C, 0x6, 0, 0, 0, 0 }; unsigned char pc, page_code; unsigned short total_len = 0; unsigned short param_len, i = 0; if (sense_6) param_len = srb->cmnd[4]; else param_len = ((u32) (srb->cmnd[7]) >> 8) | ((u32) (srb->cmnd[8])); pc = srb->cmnd[2] >> 6; page_code = srb->cmnd[2] & 0x3F; switch (pc) { case 0x0: US_DEBUGP("jumpshot_handle_mode_sense: Current values\n"); break; case 0x1: US_DEBUGP("jumpshot_handle_mode_sense: Changeable values\n"); break; case 0x2: US_DEBUGP("jumpshot_handle_mode_sense: Default values\n"); break; case 0x3: US_DEBUGP("jumpshot_handle_mode_sense: Saves values\n"); break; } mode_param_header[3] = 0x80; // write enable switch (page_code) { case 0x0: // vendor-specific mode return USB_STOR_TRANSPORT_ERROR; case 0x1: total_len = sizeof(rw_err_page); mode_param_header[0] = total_len >> 8; mode_param_header[1] = total_len & 0xFF; mode_param_header[3] = 0x00; // WP enable: 0x80 memcpy(ptr, mode_param_header, sizeof(mode_param_header)); i += sizeof(mode_param_header); memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); break; case 0x8: total_len = sizeof(cache_page); mode_param_header[0] = total_len >> 8; mode_param_header[1] = total_len & 0xFF; mode_param_header[3] = 0x00; // WP enable: 0x80 memcpy(ptr, mode_param_header, sizeof(mode_param_header)); i += sizeof(mode_param_header); memcpy(ptr + i, cache_page, sizeof(cache_page)); break; case 0x1B: total_len = sizeof(rbac_page); mode_param_header[0] = total_len >> 8; mode_param_header[1] = total_len & 0xFF; mode_param_header[3] = 0x00; // WP enable: 0x80 memcpy(ptr, mode_param_header, sizeof(mode_param_header)); i += sizeof(mode_param_header); memcpy(ptr + i, rbac_page, sizeof(rbac_page)); break; case 0x1C: total_len = sizeof(timer_page); mode_param_header[0] = total_len >> 8; mode_param_header[1] = total_len & 0xFF; mode_param_header[3] = 0x00; // WP enable: 0x80 memcpy(ptr, mode_param_header, sizeof(mode_param_header)); i += sizeof(mode_param_header); memcpy(ptr + i, timer_page, sizeof(timer_page)); break; case 0x3F: total_len = sizeof(timer_page) + sizeof(rbac_page) + sizeof(cache_page) + sizeof(rw_err_page); mode_param_header[0] = total_len >> 8; mode_param_header[1] = total_len & 0xFF; mode_param_header[3] = 0x00; // WP enable: 0x80 memcpy(ptr, mode_param_header, sizeof(mode_param_header)); i += sizeof(mode_param_header); memcpy(ptr + i, timer_page, sizeof(timer_page)); i += sizeof(timer_page); memcpy(ptr + i, rbac_page, sizeof(rbac_page)); i += sizeof(rbac_page); memcpy(ptr + i, cache_page, sizeof(cache_page)); i += sizeof(cache_page); memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); break; } return USB_STOR_TRANSPORT_GOOD; } void jumpshot_info_destructor(void *extra) { // this routine is a placeholder... // currently, we don't allocate any extra blocks so we're okay } // Transport for the Lexar 'Jumpshot' // int jumpshot_transport(Scsi_Cmnd * srb, struct us_data *us) { struct jumpshot_info *info; int rc; unsigned long block, blocks; unsigned char *ptr = NULL; unsigned char inquiry_response[36] = { 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 }; if (!us->extra) { us->extra = kmalloc(sizeof(struct jumpshot_info), GFP_NOIO); if (!us->extra) { US_DEBUGP("jumpshot_transport: Gah! Can't allocate storage for jumpshot info struct!\n"); return USB_STOR_TRANSPORT_ERROR; } memset(us->extra, 0, sizeof(struct jumpshot_info)); us->extra_destructor = jumpshot_info_destructor; } info = (struct jumpshot_info *) (us->extra); ptr = (unsigned char *) srb->request_buffer; if (srb->cmnd[0] == INQUIRY) { US_DEBUGP("jumpshot_transport: INQUIRY. Returning bogus response.\n"); memset(inquiry_response + 8, 0, 28); fill_inquiry_response(us, inquiry_response, 36); return USB_STOR_TRANSPORT_GOOD; } if (srb->cmnd[0] == READ_CAPACITY) { info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec rc = jumpshot_get_status(us); if (rc != USB_STOR_TRANSPORT_GOOD) return rc; rc = jumpshot_id_device(us, info); if (rc != USB_STOR_TRANSPORT_GOOD) return rc; US_DEBUGP("jumpshot_transport: READ_CAPACITY: %ld sectors, %ld bytes per sector\n", info->sectors, info->ssize); // build the reply // ((u32 *) ptr)[0] = cpu_to_be32(info->sectors - 1); ((u32 *) ptr)[1] = cpu_to_be32(info->ssize); return USB_STOR_TRANSPORT_GOOD; } if (srb->cmnd[0] == MODE_SELECT_10) { US_DEBUGP("jumpshot_transport: Gah! MODE_SELECT_10.\n"); return USB_STOR_TRANSPORT_ERROR; } if (srb->cmnd[0] == READ_10) { block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 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); } if (srb->cmnd[0] == READ_12) { // I don't think we'll ever see a READ_12 but support it anyway... // block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | ((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); } if (srb->cmnd[0] == WRITE_10) { block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 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); } if (srb->cmnd[0] == WRITE_12) { // I don't think we'll ever see a WRITE_12 but support it anyway... // block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | ((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); } if (srb->cmnd[0] == TEST_UNIT_READY) { US_DEBUGP("jumpshot_transport: TEST_UNIT_READY.\n"); return jumpshot_get_status(us); } if (srb->cmnd[0] == REQUEST_SENSE) { US_DEBUGP("jumpshot_transport: REQUEST_SENSE. Returning NO SENSE for now\n"); ptr[0] = 0xF0; ptr[2] = info->sense_key; ptr[7] = 11; ptr[12] = info->sense_asc; ptr[13] = info->sense_ascq; return USB_STOR_TRANSPORT_GOOD; } if (srb->cmnd[0] == MODE_SENSE) { US_DEBUGP("jumpshot_transport: MODE_SENSE_6 detected\n"); return jumpshot_handle_mode_sense(us, srb, ptr, TRUE); } if (srb->cmnd[0] == MODE_SENSE_10) { US_DEBUGP("jumpshot_transport: MODE_SENSE_10 detected\n"); return jumpshot_handle_mode_sense(us, srb, ptr, FALSE); } if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { // sure. whatever. not like we can stop the user from popping // the media out of the device (no locking doors, etc) // return USB_STOR_TRANSPORT_GOOD; } if (srb->cmnd[0] == START_STOP) { /* this is used by sd.c'check_scsidisk_media_change to detect media change */ US_DEBUGP("jumpshot_transport: START_STOP.\n"); /* the first jumpshot_id_device after a media change returns an error (determined experimentally) */ rc = jumpshot_id_device(us, info); if (rc == USB_STOR_TRANSPORT_GOOD) { info->sense_key = NO_SENSE; srb->result = SUCCESS; } else { info->sense_key = UNIT_ATTENTION; srb->result = CHECK_CONDITION; } return rc; } US_DEBUGP("jumpshot_transport: Gah! Unknown command: %d (0x%x)\n", srb->cmnd[0], srb->cmnd[0]); return USB_STOR_TRANSPORT_ERROR; }