1*5fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0+ 2f0183a33SFelipe Balbi /* 3f0183a33SFelipe Balbi * Driver for Datafab USB Compact Flash reader 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * datafab driver v0.1: 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * First release 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Current development and maintenance by: 101da177e4SLinus Torvalds * (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org) 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver 131da177e4SLinus Torvalds * which I used as a template for this driver. 141da177e4SLinus Torvalds * 151da177e4SLinus Torvalds * Some bugfixes and scatter-gather code by Gregory P. Smith 161da177e4SLinus Torvalds * (greg-usb@electricrain.com) 171da177e4SLinus Torvalds * 181da177e4SLinus Torvalds * Fix for media change by Joerg Schneider (js@joergschneider.com) 191da177e4SLinus Torvalds * 201da177e4SLinus Torvalds * Other contributors: 211da177e4SLinus Torvalds * (c) 2002 Alan Stern <stern@rowland.org> 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify it 241da177e4SLinus Torvalds * under the terms of the GNU General Public License as published by the 251da177e4SLinus Torvalds * Free Software Foundation; either version 2, or (at your option) any 261da177e4SLinus Torvalds * later version. 271da177e4SLinus Torvalds * 281da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, but 291da177e4SLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 301da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 311da177e4SLinus Torvalds * General Public License for more details. 321da177e4SLinus Torvalds * 331da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License along 341da177e4SLinus Torvalds * with this program; if not, write to the Free Software Foundation, Inc., 351da177e4SLinus Torvalds * 675 Mass Ave, Cambridge, MA 02139, USA. 361da177e4SLinus Torvalds */ 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds /* 391da177e4SLinus Torvalds * This driver attempts to support USB CompactFlash reader/writer devices 401da177e4SLinus Torvalds * based on Datafab USB-to-ATA chips. It was specifically developed for the 411da177e4SLinus Torvalds * Datafab MDCFE-B USB CompactFlash reader but has since been found to work 421da177e4SLinus Torvalds * with a variety of Datafab-based devices from a number of manufacturers. 431da177e4SLinus Torvalds * I've received a report of this driver working with a Datafab-based 441da177e4SLinus Torvalds * SmartMedia device though please be aware that I'm personally unable to 451da177e4SLinus Torvalds * test SmartMedia support. 461da177e4SLinus Torvalds * 471da177e4SLinus Torvalds * This driver supports reading and writing. If you're truly paranoid, 481da177e4SLinus Torvalds * however, you can force the driver into a write-protected state by setting 491da177e4SLinus Torvalds * the WP enable bits in datafab_handle_mode_sense(). See the comments 501da177e4SLinus Torvalds * in that routine. 511da177e4SLinus Torvalds */ 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #include <linux/errno.h> 542cbbf357SAlan Stern #include <linux/module.h> 551da177e4SLinus Torvalds #include <linux/slab.h> 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds #include <scsi/scsi.h> 581da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds #include "usb.h" 611da177e4SLinus Torvalds #include "transport.h" 621da177e4SLinus Torvalds #include "protocol.h" 631da177e4SLinus Torvalds #include "debug.h" 64aa519be3SAkinobu Mita #include "scsiglue.h" 65aa519be3SAkinobu Mita 66aa519be3SAkinobu Mita #define DRV_NAME "ums-datafab" 672cbbf357SAlan Stern 684246b06aSMaciej Grela MODULE_DESCRIPTION("Driver for Datafab USB Compact Flash reader"); 694246b06aSMaciej Grela MODULE_AUTHOR("Jimmie Mayfield <mayfield+datafab@sackheads.org>"); 704246b06aSMaciej Grela MODULE_LICENSE("GPL"); 714246b06aSMaciej Grela 722cbbf357SAlan Stern struct datafab_info { 732cbbf357SAlan Stern unsigned long sectors; /* total sector count */ 742cbbf357SAlan Stern unsigned long ssize; /* sector size in bytes */ 752cbbf357SAlan Stern signed char lun; /* used for dual-slot readers */ 762cbbf357SAlan Stern 772cbbf357SAlan Stern /* the following aren't used yet */ 782cbbf357SAlan Stern unsigned char sense_key; 792cbbf357SAlan Stern unsigned long sense_asc; /* additional sense code */ 802cbbf357SAlan Stern unsigned long sense_ascq; /* additional sense code qualifier */ 812cbbf357SAlan Stern }; 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds static int datafab_determine_lun(struct us_data *us, 841da177e4SLinus Torvalds struct datafab_info *info); 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds 872cbbf357SAlan Stern /* 882cbbf357SAlan Stern * The table of devices 892cbbf357SAlan Stern */ 902cbbf357SAlan Stern #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 912cbbf357SAlan Stern vendorName, productName, useProtocol, useTransport, \ 922cbbf357SAlan Stern initFunction, flags) \ 932cbbf357SAlan Stern { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 94f61870eeSSebastian Andrzej Siewior .driver_info = (flags) } 952cbbf357SAlan Stern 96b03379f7SFelipe Balbi static struct usb_device_id datafab_usb_ids[] = { 972cbbf357SAlan Stern # include "unusual_datafab.h" 982cbbf357SAlan Stern { } /* Terminating entry */ 992cbbf357SAlan Stern }; 1002cbbf357SAlan Stern MODULE_DEVICE_TABLE(usb, datafab_usb_ids); 1012cbbf357SAlan Stern 1022cbbf357SAlan Stern #undef UNUSUAL_DEV 1032cbbf357SAlan Stern 1042cbbf357SAlan Stern /* 1052cbbf357SAlan Stern * The flags table 1062cbbf357SAlan Stern */ 1072cbbf357SAlan Stern #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 1082cbbf357SAlan Stern vendor_name, product_name, use_protocol, use_transport, \ 1092cbbf357SAlan Stern init_function, Flags) \ 1102cbbf357SAlan Stern { \ 1112cbbf357SAlan Stern .vendorName = vendor_name, \ 1122cbbf357SAlan Stern .productName = product_name, \ 1132cbbf357SAlan Stern .useProtocol = use_protocol, \ 1142cbbf357SAlan Stern .useTransport = use_transport, \ 1152cbbf357SAlan Stern .initFunction = init_function, \ 1162cbbf357SAlan Stern } 1172cbbf357SAlan Stern 1182cbbf357SAlan Stern static struct us_unusual_dev datafab_unusual_dev_list[] = { 1192cbbf357SAlan Stern # include "unusual_datafab.h" 1202cbbf357SAlan Stern { } /* Terminating entry */ 1212cbbf357SAlan Stern }; 1222cbbf357SAlan Stern 1232cbbf357SAlan Stern #undef UNUSUAL_DEV 1242cbbf357SAlan Stern 1252cbbf357SAlan Stern 1261da177e4SLinus Torvalds static inline int 1271da177e4SLinus Torvalds datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) { 1281da177e4SLinus Torvalds if (len == 0) 1291da177e4SLinus Torvalds return USB_STOR_XFER_GOOD; 1301da177e4SLinus Torvalds 131191648d0SJoe Perches usb_stor_dbg(us, "len = %d\n", len); 1321da177e4SLinus Torvalds return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 1331da177e4SLinus Torvalds data, len, NULL); 1341da177e4SLinus Torvalds } 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds static inline int 1381da177e4SLinus Torvalds datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) { 1391da177e4SLinus Torvalds if (len == 0) 1401da177e4SLinus Torvalds return USB_STOR_XFER_GOOD; 1411da177e4SLinus Torvalds 142191648d0SJoe Perches usb_stor_dbg(us, "len = %d\n", len); 1431da177e4SLinus Torvalds return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 1441da177e4SLinus Torvalds data, len, NULL); 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds static int datafab_read_data(struct us_data *us, 1491da177e4SLinus Torvalds struct datafab_info *info, 1501da177e4SLinus Torvalds u32 sector, 1511da177e4SLinus Torvalds u32 sectors) 1521da177e4SLinus Torvalds { 1531da177e4SLinus Torvalds unsigned char *command = us->iobuf; 1541da177e4SLinus Torvalds unsigned char *buffer; 1551da177e4SLinus Torvalds unsigned char thistime; 1561da177e4SLinus Torvalds unsigned int totallen, alloclen; 1571da177e4SLinus Torvalds int len, result; 1581f6f31a0SJens Axboe unsigned int sg_offset = 0; 1591f6f31a0SJens Axboe struct scatterlist *sg = NULL; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds // we're working in LBA mode. according to the ATA spec, 1621da177e4SLinus Torvalds // we can support up to 28-bit addressing. I don't know if Datafab 1631da177e4SLinus Torvalds // supports beyond 24-bit addressing. It's kind of hard to test 1641da177e4SLinus Torvalds // since it requires > 8GB CF card. 1651da177e4SLinus Torvalds // 1661da177e4SLinus Torvalds if (sectors > 0x0FFFFFFF) 1671da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds if (info->lun == -1) { 1701da177e4SLinus Torvalds result = datafab_determine_lun(us, info); 1711da177e4SLinus Torvalds if (result != USB_STOR_TRANSPORT_GOOD) 1721da177e4SLinus Torvalds return result; 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds totallen = sectors * info->ssize; 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds // Since we don't read more than 64 KB at a time, we have to create 1781da177e4SLinus Torvalds // a bounce buffer and move the data a piece at a time between the 1791da177e4SLinus Torvalds // bounce buffer and the actual transfer buffer. 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds alloclen = min(totallen, 65536u); 1821da177e4SLinus Torvalds buffer = kmalloc(alloclen, GFP_NOIO); 1831da177e4SLinus Torvalds if (buffer == NULL) 1841da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds do { 1871da177e4SLinus Torvalds // loop, never allocate or transfer more than 64k at once 1881da177e4SLinus Torvalds // (min(128k, 255*info->ssize) is the real limit) 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds len = min(totallen, alloclen); 1911da177e4SLinus Torvalds thistime = (len / info->ssize) & 0xff; 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds command[0] = 0; 1941da177e4SLinus Torvalds command[1] = thistime; 1951da177e4SLinus Torvalds command[2] = sector & 0xFF; 1961da177e4SLinus Torvalds command[3] = (sector >> 8) & 0xFF; 1971da177e4SLinus Torvalds command[4] = (sector >> 16) & 0xFF; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds command[5] = 0xE0 + (info->lun << 4); 2001da177e4SLinus Torvalds command[5] |= (sector >> 24) & 0x0F; 2011da177e4SLinus Torvalds command[6] = 0x20; 2021da177e4SLinus Torvalds command[7] = 0x01; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds // send the read command 2051da177e4SLinus Torvalds result = datafab_bulk_write(us, command, 8); 2061da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 2071da177e4SLinus Torvalds goto leave; 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds // read the result 2101da177e4SLinus Torvalds result = datafab_bulk_read(us, buffer, len); 2111da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 2121da177e4SLinus Torvalds goto leave; 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds // Store the data in the transfer buffer 2151da177e4SLinus Torvalds usb_stor_access_xfer_buf(buffer, len, us->srb, 2161f6f31a0SJens Axboe &sg, &sg_offset, TO_XFER_BUF); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds sector += thistime; 2191da177e4SLinus Torvalds totallen -= len; 2201da177e4SLinus Torvalds } while (totallen > 0); 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds kfree(buffer); 2231da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds leave: 2261da177e4SLinus Torvalds kfree(buffer); 2271da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds static int datafab_write_data(struct us_data *us, 2321da177e4SLinus Torvalds struct datafab_info *info, 2331da177e4SLinus Torvalds u32 sector, 2341da177e4SLinus Torvalds u32 sectors) 2351da177e4SLinus Torvalds { 2361da177e4SLinus Torvalds unsigned char *command = us->iobuf; 2371da177e4SLinus Torvalds unsigned char *reply = us->iobuf; 2381da177e4SLinus Torvalds unsigned char *buffer; 2391da177e4SLinus Torvalds unsigned char thistime; 2401da177e4SLinus Torvalds unsigned int totallen, alloclen; 2411da177e4SLinus Torvalds int len, result; 2421f6f31a0SJens Axboe unsigned int sg_offset = 0; 2431f6f31a0SJens Axboe struct scatterlist *sg = NULL; 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds // we're working in LBA mode. according to the ATA spec, 2461da177e4SLinus Torvalds // we can support up to 28-bit addressing. I don't know if Datafab 2471da177e4SLinus Torvalds // supports beyond 24-bit addressing. It's kind of hard to test 2481da177e4SLinus Torvalds // since it requires > 8GB CF card. 2491da177e4SLinus Torvalds // 2501da177e4SLinus Torvalds if (sectors > 0x0FFFFFFF) 2511da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds if (info->lun == -1) { 2541da177e4SLinus Torvalds result = datafab_determine_lun(us, info); 2551da177e4SLinus Torvalds if (result != USB_STOR_TRANSPORT_GOOD) 2561da177e4SLinus Torvalds return result; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds totallen = sectors * info->ssize; 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds // Since we don't write more than 64 KB at a time, we have to create 2621da177e4SLinus Torvalds // a bounce buffer and move the data a piece at a time between the 2631da177e4SLinus Torvalds // bounce buffer and the actual transfer buffer. 2641da177e4SLinus Torvalds 2651da177e4SLinus Torvalds alloclen = min(totallen, 65536u); 2661da177e4SLinus Torvalds buffer = kmalloc(alloclen, GFP_NOIO); 2671da177e4SLinus Torvalds if (buffer == NULL) 2681da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds do { 2711da177e4SLinus Torvalds // loop, never allocate or transfer more than 64k at once 2721da177e4SLinus Torvalds // (min(128k, 255*info->ssize) is the real limit) 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds len = min(totallen, alloclen); 2751da177e4SLinus Torvalds thistime = (len / info->ssize) & 0xff; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds // Get the data from the transfer buffer 2781da177e4SLinus Torvalds usb_stor_access_xfer_buf(buffer, len, us->srb, 2791f6f31a0SJens Axboe &sg, &sg_offset, FROM_XFER_BUF); 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds command[0] = 0; 2821da177e4SLinus Torvalds command[1] = thistime; 2831da177e4SLinus Torvalds command[2] = sector & 0xFF; 2841da177e4SLinus Torvalds command[3] = (sector >> 8) & 0xFF; 2851da177e4SLinus Torvalds command[4] = (sector >> 16) & 0xFF; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds command[5] = 0xE0 + (info->lun << 4); 2881da177e4SLinus Torvalds command[5] |= (sector >> 24) & 0x0F; 2891da177e4SLinus Torvalds command[6] = 0x30; 2901da177e4SLinus Torvalds command[7] = 0x02; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds // send the command 2931da177e4SLinus Torvalds result = datafab_bulk_write(us, command, 8); 2941da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 2951da177e4SLinus Torvalds goto leave; 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds // send the data 2981da177e4SLinus Torvalds result = datafab_bulk_write(us, buffer, len); 2991da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 3001da177e4SLinus Torvalds goto leave; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds // read the result 3031da177e4SLinus Torvalds result = datafab_bulk_read(us, reply, 2); 3041da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 3051da177e4SLinus Torvalds goto leave; 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds if (reply[0] != 0x50 && reply[1] != 0) { 308191648d0SJoe Perches usb_stor_dbg(us, "Gah! write return code: %02x %02x\n", 3091da177e4SLinus Torvalds reply[0], reply[1]); 3101da177e4SLinus Torvalds result = USB_STOR_TRANSPORT_ERROR; 3111da177e4SLinus Torvalds goto leave; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds sector += thistime; 3151da177e4SLinus Torvalds totallen -= len; 3161da177e4SLinus Torvalds } while (totallen > 0); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds kfree(buffer); 3191da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds leave: 3221da177e4SLinus Torvalds kfree(buffer); 3231da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds static int datafab_determine_lun(struct us_data *us, 3281da177e4SLinus Torvalds struct datafab_info *info) 3291da177e4SLinus Torvalds { 3301da177e4SLinus Torvalds // Dual-slot readers can be thought of as dual-LUN devices. 3311da177e4SLinus Torvalds // We need to determine which card slot is being used. 3321da177e4SLinus Torvalds // We'll send an IDENTIFY DEVICE command and see which LUN responds... 3331da177e4SLinus Torvalds // 3341da177e4SLinus Torvalds // There might be a better way of doing this? 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 3371da177e4SLinus Torvalds unsigned char *command = us->iobuf; 3381da177e4SLinus Torvalds unsigned char *buf; 3391da177e4SLinus Torvalds int count = 0, rc; 3401da177e4SLinus Torvalds 34164aebe73SJulia Lawall if (!info) 3421da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds memcpy(command, scommand, 8); 3451da177e4SLinus Torvalds buf = kmalloc(512, GFP_NOIO); 3461da177e4SLinus Torvalds if (!buf) 3471da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 3481da177e4SLinus Torvalds 349191648d0SJoe Perches usb_stor_dbg(us, "locating...\n"); 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds // we'll try 3 times before giving up... 3521da177e4SLinus Torvalds // 3531da177e4SLinus Torvalds while (count++ < 3) { 3541da177e4SLinus Torvalds command[5] = 0xa0; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 3571da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 3581da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 3591da177e4SLinus Torvalds goto leave; 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds rc = datafab_bulk_read(us, buf, 512); 3631da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 3641da177e4SLinus Torvalds info->lun = 0; 3651da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 3661da177e4SLinus Torvalds goto leave; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds command[5] = 0xb0; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 3721da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 3731da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 3741da177e4SLinus Torvalds goto leave; 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds rc = datafab_bulk_read(us, buf, 512); 3781da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 3791da177e4SLinus Torvalds info->lun = 1; 3801da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 3811da177e4SLinus Torvalds goto leave; 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds msleep(20); 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds leave: 3901da177e4SLinus Torvalds kfree(buf); 3911da177e4SLinus Torvalds return rc; 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds static int datafab_id_device(struct us_data *us, 3951da177e4SLinus Torvalds struct datafab_info *info) 3961da177e4SLinus Torvalds { 3971da177e4SLinus Torvalds // this is a variation of the ATA "IDENTIFY DEVICE" command...according 3981da177e4SLinus Torvalds // to the ATA spec, 'Sector Count' isn't used but the Windows driver 3991da177e4SLinus Torvalds // sets this bit so we do too... 4001da177e4SLinus Torvalds // 4011da177e4SLinus Torvalds static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 4021da177e4SLinus Torvalds unsigned char *command = us->iobuf; 4031da177e4SLinus Torvalds unsigned char *reply; 4041da177e4SLinus Torvalds int rc; 4051da177e4SLinus Torvalds 40664aebe73SJulia Lawall if (!info) 4071da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds if (info->lun == -1) { 4101da177e4SLinus Torvalds rc = datafab_determine_lun(us, info); 4111da177e4SLinus Torvalds if (rc != USB_STOR_TRANSPORT_GOOD) 4121da177e4SLinus Torvalds return rc; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds memcpy(command, scommand, 8); 4161da177e4SLinus Torvalds reply = kmalloc(512, GFP_NOIO); 4171da177e4SLinus Torvalds if (!reply) 4181da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds command[5] += (info->lun << 4); 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 4231da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 4241da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 4251da177e4SLinus Torvalds goto leave; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds // we'll go ahead and extract the media capacity while we're here... 4291da177e4SLinus Torvalds // 4301da177e4SLinus Torvalds rc = datafab_bulk_read(us, reply, 512); 4311da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 4321da177e4SLinus Torvalds // capacity is at word offset 57-58 4331da177e4SLinus Torvalds // 4341da177e4SLinus Torvalds info->sectors = ((u32)(reply[117]) << 24) | 4351da177e4SLinus Torvalds ((u32)(reply[116]) << 16) | 4361da177e4SLinus Torvalds ((u32)(reply[115]) << 8) | 4371da177e4SLinus Torvalds ((u32)(reply[114]) ); 4381da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 4391da177e4SLinus Torvalds goto leave; 4401da177e4SLinus Torvalds } 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds leave: 4451da177e4SLinus Torvalds kfree(reply); 4461da177e4SLinus Torvalds return rc; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds static int datafab_handle_mode_sense(struct us_data *us, 4511da177e4SLinus Torvalds struct scsi_cmnd * srb, 4521da177e4SLinus Torvalds int sense_6) 4531da177e4SLinus Torvalds { 4541da177e4SLinus Torvalds static unsigned char rw_err_page[12] = { 4551da177e4SLinus Torvalds 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0 4561da177e4SLinus Torvalds }; 4571da177e4SLinus Torvalds static unsigned char cache_page[12] = { 4581da177e4SLinus Torvalds 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0 4591da177e4SLinus Torvalds }; 4601da177e4SLinus Torvalds static unsigned char rbac_page[12] = { 4611da177e4SLinus Torvalds 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0 4621da177e4SLinus Torvalds }; 4631da177e4SLinus Torvalds static unsigned char timer_page[8] = { 4641da177e4SLinus Torvalds 0x1C, 0x6, 0, 0, 0, 0 4651da177e4SLinus Torvalds }; 4661da177e4SLinus Torvalds unsigned char pc, page_code; 4671da177e4SLinus Torvalds unsigned int i = 0; 4681da177e4SLinus Torvalds struct datafab_info *info = (struct datafab_info *) (us->extra); 4691da177e4SLinus Torvalds unsigned char *ptr = us->iobuf; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds // most of this stuff is just a hack to get things working. the 4721da177e4SLinus Torvalds // datafab reader doesn't present a SCSI interface so we 4731da177e4SLinus Torvalds // fudge the SCSI commands... 4741da177e4SLinus Torvalds // 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds pc = srb->cmnd[2] >> 6; 4771da177e4SLinus Torvalds page_code = srb->cmnd[2] & 0x3F; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds switch (pc) { 4801da177e4SLinus Torvalds case 0x0: 481191648d0SJoe Perches usb_stor_dbg(us, "Current values\n"); 4821da177e4SLinus Torvalds break; 4831da177e4SLinus Torvalds case 0x1: 484191648d0SJoe Perches usb_stor_dbg(us, "Changeable values\n"); 4851da177e4SLinus Torvalds break; 4861da177e4SLinus Torvalds case 0x2: 487191648d0SJoe Perches usb_stor_dbg(us, "Default values\n"); 4881da177e4SLinus Torvalds break; 4891da177e4SLinus Torvalds case 0x3: 490191648d0SJoe Perches usb_stor_dbg(us, "Saves values\n"); 4911da177e4SLinus Torvalds break; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds memset(ptr, 0, 8); 4951da177e4SLinus Torvalds if (sense_6) { 4961da177e4SLinus Torvalds ptr[2] = 0x00; // WP enable: 0x80 4971da177e4SLinus Torvalds i = 4; 4981da177e4SLinus Torvalds } else { 4991da177e4SLinus Torvalds ptr[3] = 0x00; // WP enable: 0x80 5001da177e4SLinus Torvalds i = 8; 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds switch (page_code) { 5041da177e4SLinus Torvalds default: 5051da177e4SLinus Torvalds // vendor-specific mode 5061da177e4SLinus Torvalds info->sense_key = 0x05; 5071da177e4SLinus Torvalds info->sense_asc = 0x24; 5081da177e4SLinus Torvalds info->sense_ascq = 0x00; 5091da177e4SLinus Torvalds return USB_STOR_TRANSPORT_FAILED; 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds case 0x1: 5121da177e4SLinus Torvalds memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 5131da177e4SLinus Torvalds i += sizeof(rw_err_page); 5141da177e4SLinus Torvalds break; 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds case 0x8: 5171da177e4SLinus Torvalds memcpy(ptr + i, cache_page, sizeof(cache_page)); 5181da177e4SLinus Torvalds i += sizeof(cache_page); 5191da177e4SLinus Torvalds break; 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds case 0x1B: 5221da177e4SLinus Torvalds memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 5231da177e4SLinus Torvalds i += sizeof(rbac_page); 5241da177e4SLinus Torvalds break; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds case 0x1C: 5271da177e4SLinus Torvalds memcpy(ptr + i, timer_page, sizeof(timer_page)); 5281da177e4SLinus Torvalds i += sizeof(timer_page); 5291da177e4SLinus Torvalds break; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds case 0x3F: // retrieve all pages 5321da177e4SLinus Torvalds memcpy(ptr + i, timer_page, sizeof(timer_page)); 5331da177e4SLinus Torvalds i += sizeof(timer_page); 5341da177e4SLinus Torvalds memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 5351da177e4SLinus Torvalds i += sizeof(rbac_page); 5361da177e4SLinus Torvalds memcpy(ptr + i, cache_page, sizeof(cache_page)); 5371da177e4SLinus Torvalds i += sizeof(cache_page); 5381da177e4SLinus Torvalds memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 5391da177e4SLinus Torvalds i += sizeof(rw_err_page); 5401da177e4SLinus Torvalds break; 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds if (sense_6) 5441da177e4SLinus Torvalds ptr[0] = i - 1; 5451da177e4SLinus Torvalds else 5461da177e4SLinus Torvalds ((__be16 *) ptr)[0] = cpu_to_be16(i - 2); 5471da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, i, srb); 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 5501da177e4SLinus Torvalds } 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds static void datafab_info_destructor(void *extra) 5531da177e4SLinus Torvalds { 5541da177e4SLinus Torvalds // this routine is a placeholder... 5551da177e4SLinus Torvalds // currently, we don't allocate any extra memory so we're okay 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds // Transport for the Datafab MDCFE-B 5601da177e4SLinus Torvalds // 5612cbbf357SAlan Stern static int datafab_transport(struct scsi_cmnd *srb, struct us_data *us) 5621da177e4SLinus Torvalds { 5631da177e4SLinus Torvalds struct datafab_info *info; 5641da177e4SLinus Torvalds int rc; 5651da177e4SLinus Torvalds unsigned long block, blocks; 5661da177e4SLinus Torvalds unsigned char *ptr = us->iobuf; 5671da177e4SLinus Torvalds static unsigned char inquiry_reply[8] = { 5681da177e4SLinus Torvalds 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 5691da177e4SLinus Torvalds }; 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds if (!us->extra) { 572887c2560SOliver Neukum us->extra = kzalloc(sizeof(struct datafab_info), GFP_NOIO); 573191648d0SJoe Perches if (!us->extra) 5741da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 575191648d0SJoe Perches 5761da177e4SLinus Torvalds us->extra_destructor = datafab_info_destructor; 5771da177e4SLinus Torvalds ((struct datafab_info *)us->extra)->lun = -1; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds info = (struct datafab_info *) (us->extra); 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds if (srb->cmnd[0] == INQUIRY) { 583191648d0SJoe Perches usb_stor_dbg(us, "INQUIRY - Returning bogus response\n"); 5841da177e4SLinus Torvalds memcpy(ptr, inquiry_reply, sizeof(inquiry_reply)); 5851da177e4SLinus Torvalds fill_inquiry_response(us, ptr, 36); 5861da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds if (srb->cmnd[0] == READ_CAPACITY) { 5901da177e4SLinus Torvalds info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec 5911da177e4SLinus Torvalds rc = datafab_id_device(us, info); 5921da177e4SLinus Torvalds if (rc != USB_STOR_TRANSPORT_GOOD) 5931da177e4SLinus Torvalds return rc; 5941da177e4SLinus Torvalds 595191648d0SJoe Perches usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n", 5961da177e4SLinus Torvalds info->sectors, info->ssize); 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds // build the reply 5991da177e4SLinus Torvalds // we need the last sector, not the number of sectors 6001da177e4SLinus Torvalds ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1); 6011da177e4SLinus Torvalds ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize); 6021da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, 8, srb); 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 6051da177e4SLinus Torvalds } 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SELECT_10) { 608191648d0SJoe Perches usb_stor_dbg(us, "Gah! MODE_SELECT_10\n"); 6091da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds // don't bother implementing READ_6 or WRITE_6. 6131da177e4SLinus Torvalds // 6141da177e4SLinus Torvalds if (srb->cmnd[0] == READ_10) { 6151da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 6161da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 6191da177e4SLinus Torvalds 620191648d0SJoe Perches usb_stor_dbg(us, "READ_10: read block 0x%04lx count %ld\n", 621191648d0SJoe Perches block, blocks); 6221da177e4SLinus Torvalds return datafab_read_data(us, info, block, blocks); 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds if (srb->cmnd[0] == READ_12) { 6261da177e4SLinus Torvalds // we'll probably never see a READ_12 but we'll do it anyway... 6271da177e4SLinus Torvalds // 6281da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 6291da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 6321da177e4SLinus Torvalds ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 6331da177e4SLinus Torvalds 634191648d0SJoe Perches usb_stor_dbg(us, "READ_12: read block 0x%04lx count %ld\n", 635191648d0SJoe Perches block, blocks); 6361da177e4SLinus Torvalds return datafab_read_data(us, info, block, blocks); 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds if (srb->cmnd[0] == WRITE_10) { 6401da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 6411da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 6441da177e4SLinus Torvalds 645191648d0SJoe Perches usb_stor_dbg(us, "WRITE_10: write block 0x%04lx count %ld\n", 646191648d0SJoe Perches block, blocks); 6471da177e4SLinus Torvalds return datafab_write_data(us, info, block, blocks); 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds if (srb->cmnd[0] == WRITE_12) { 6511da177e4SLinus Torvalds // we'll probably never see a WRITE_12 but we'll do it anyway... 6521da177e4SLinus Torvalds // 6531da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 6541da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 6571da177e4SLinus Torvalds ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 6581da177e4SLinus Torvalds 659191648d0SJoe Perches usb_stor_dbg(us, "WRITE_12: write block 0x%04lx count %ld\n", 660191648d0SJoe Perches block, blocks); 6611da177e4SLinus Torvalds return datafab_write_data(us, info, block, blocks); 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds if (srb->cmnd[0] == TEST_UNIT_READY) { 665191648d0SJoe Perches usb_stor_dbg(us, "TEST_UNIT_READY\n"); 6661da177e4SLinus Torvalds return datafab_id_device(us, info); 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (srb->cmnd[0] == REQUEST_SENSE) { 670191648d0SJoe Perches usb_stor_dbg(us, "REQUEST_SENSE - Returning faked response\n"); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds // this response is pretty bogus right now. eventually if necessary 6731da177e4SLinus Torvalds // we can set the correct sense data. so far though it hasn't been 6741da177e4SLinus Torvalds // necessary 6751da177e4SLinus Torvalds // 6761da177e4SLinus Torvalds memset(ptr, 0, 18); 6771da177e4SLinus Torvalds ptr[0] = 0xF0; 6781da177e4SLinus Torvalds ptr[2] = info->sense_key; 6791da177e4SLinus Torvalds ptr[7] = 11; 6801da177e4SLinus Torvalds ptr[12] = info->sense_asc; 6811da177e4SLinus Torvalds ptr[13] = info->sense_ascq; 6821da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, 18, srb); 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SENSE) { 688191648d0SJoe Perches usb_stor_dbg(us, "MODE_SENSE_6 detected\n"); 6891da177e4SLinus Torvalds return datafab_handle_mode_sense(us, srb, 1); 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SENSE_10) { 693191648d0SJoe Perches usb_stor_dbg(us, "MODE_SENSE_10 detected\n"); 6941da177e4SLinus Torvalds return datafab_handle_mode_sense(us, srb, 0); 6951da177e4SLinus Torvalds } 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 698f0183a33SFelipe Balbi /* 699f0183a33SFelipe Balbi * sure. whatever. not like we can stop the user from 700f0183a33SFelipe Balbi * popping the media out of the device (no locking doors, etc) 701f0183a33SFelipe Balbi */ 7021da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds if (srb->cmnd[0] == START_STOP) { 706f0183a33SFelipe Balbi /* 707f0183a33SFelipe Balbi * this is used by sd.c'check_scsidisk_media_change to detect 708f0183a33SFelipe Balbi * media change 709f0183a33SFelipe Balbi */ 710191648d0SJoe Perches usb_stor_dbg(us, "START_STOP\n"); 711f0183a33SFelipe Balbi /* 712f0183a33SFelipe Balbi * the first datafab_id_device after a media change returns 713f0183a33SFelipe Balbi * an error (determined experimentally) 714f0183a33SFelipe Balbi */ 7151da177e4SLinus Torvalds rc = datafab_id_device(us, info); 7161da177e4SLinus Torvalds if (rc == USB_STOR_TRANSPORT_GOOD) { 7171da177e4SLinus Torvalds info->sense_key = NO_SENSE; 7181da177e4SLinus Torvalds srb->result = SUCCESS; 7191da177e4SLinus Torvalds } else { 7201da177e4SLinus Torvalds info->sense_key = UNIT_ATTENTION; 7211da177e4SLinus Torvalds srb->result = SAM_STAT_CHECK_CONDITION; 7221da177e4SLinus Torvalds } 7231da177e4SLinus Torvalds return rc; 7241da177e4SLinus Torvalds } 7251da177e4SLinus Torvalds 726191648d0SJoe Perches usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n", 7271da177e4SLinus Torvalds srb->cmnd[0], srb->cmnd[0]); 7281da177e4SLinus Torvalds info->sense_key = 0x05; 7291da177e4SLinus Torvalds info->sense_asc = 0x20; 7301da177e4SLinus Torvalds info->sense_ascq = 0x00; 7311da177e4SLinus Torvalds return USB_STOR_TRANSPORT_FAILED; 7321da177e4SLinus Torvalds } 7332cbbf357SAlan Stern 734aa519be3SAkinobu Mita static struct scsi_host_template datafab_host_template; 735aa519be3SAkinobu Mita 7362cbbf357SAlan Stern static int datafab_probe(struct usb_interface *intf, 7372cbbf357SAlan Stern const struct usb_device_id *id) 7382cbbf357SAlan Stern { 7392cbbf357SAlan Stern struct us_data *us; 7402cbbf357SAlan Stern int result; 7412cbbf357SAlan Stern 7422cbbf357SAlan Stern result = usb_stor_probe1(&us, intf, id, 743aa519be3SAkinobu Mita (id - datafab_usb_ids) + datafab_unusual_dev_list, 744aa519be3SAkinobu Mita &datafab_host_template); 7452cbbf357SAlan Stern if (result) 7462cbbf357SAlan Stern return result; 7472cbbf357SAlan Stern 7482cbbf357SAlan Stern us->transport_name = "Datafab Bulk-Only"; 7492cbbf357SAlan Stern us->transport = datafab_transport; 7502cbbf357SAlan Stern us->transport_reset = usb_stor_Bulk_reset; 7512cbbf357SAlan Stern us->max_lun = 1; 7522cbbf357SAlan Stern 7532cbbf357SAlan Stern result = usb_stor_probe2(us); 7542cbbf357SAlan Stern return result; 7552cbbf357SAlan Stern } 7562cbbf357SAlan Stern 7572cbbf357SAlan Stern static struct usb_driver datafab_driver = { 758aa519be3SAkinobu Mita .name = DRV_NAME, 7592cbbf357SAlan Stern .probe = datafab_probe, 7602cbbf357SAlan Stern .disconnect = usb_stor_disconnect, 7612cbbf357SAlan Stern .suspend = usb_stor_suspend, 7622cbbf357SAlan Stern .resume = usb_stor_resume, 7632cbbf357SAlan Stern .reset_resume = usb_stor_reset_resume, 7642cbbf357SAlan Stern .pre_reset = usb_stor_pre_reset, 7652cbbf357SAlan Stern .post_reset = usb_stor_post_reset, 7662cbbf357SAlan Stern .id_table = datafab_usb_ids, 7672cbbf357SAlan Stern .soft_unbind = 1, 768e73b2db6SHuajun Li .no_dynamic_id = 1, 7692cbbf357SAlan Stern }; 7702cbbf357SAlan Stern 771aa519be3SAkinobu Mita module_usb_stor_driver(datafab_driver, datafab_host_template, DRV_NAME); 772