1*1da177e4SLinus Torvalds /* Driver for Datafab USB Compact Flash reader 2*1da177e4SLinus Torvalds * 3*1da177e4SLinus Torvalds * $Id: datafab.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $ 4*1da177e4SLinus Torvalds * 5*1da177e4SLinus Torvalds * datafab driver v0.1: 6*1da177e4SLinus Torvalds * 7*1da177e4SLinus Torvalds * First release 8*1da177e4SLinus Torvalds * 9*1da177e4SLinus Torvalds * Current development and maintenance by: 10*1da177e4SLinus Torvalds * (c) 2000 Jimmie Mayfield (mayfield+datafab@sackheads.org) 11*1da177e4SLinus Torvalds * 12*1da177e4SLinus Torvalds * Many thanks to Robert Baruch for the SanDisk SmartMedia reader driver 13*1da177e4SLinus Torvalds * which I used as a template for this driver. 14*1da177e4SLinus Torvalds * 15*1da177e4SLinus Torvalds * Some bugfixes and scatter-gather code by Gregory P. Smith 16*1da177e4SLinus Torvalds * (greg-usb@electricrain.com) 17*1da177e4SLinus Torvalds * 18*1da177e4SLinus Torvalds * Fix for media change by Joerg Schneider (js@joergschneider.com) 19*1da177e4SLinus Torvalds * 20*1da177e4SLinus Torvalds * Other contributors: 21*1da177e4SLinus Torvalds * (c) 2002 Alan Stern <stern@rowland.org> 22*1da177e4SLinus Torvalds * 23*1da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify it 24*1da177e4SLinus Torvalds * under the terms of the GNU General Public License as published by the 25*1da177e4SLinus Torvalds * Free Software Foundation; either version 2, or (at your option) any 26*1da177e4SLinus Torvalds * later version. 27*1da177e4SLinus Torvalds * 28*1da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, but 29*1da177e4SLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 30*1da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 31*1da177e4SLinus Torvalds * General Public License for more details. 32*1da177e4SLinus Torvalds * 33*1da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License along 34*1da177e4SLinus Torvalds * with this program; if not, write to the Free Software Foundation, Inc., 35*1da177e4SLinus Torvalds * 675 Mass Ave, Cambridge, MA 02139, USA. 36*1da177e4SLinus Torvalds */ 37*1da177e4SLinus Torvalds 38*1da177e4SLinus Torvalds /* 39*1da177e4SLinus Torvalds * This driver attempts to support USB CompactFlash reader/writer devices 40*1da177e4SLinus Torvalds * based on Datafab USB-to-ATA chips. It was specifically developed for the 41*1da177e4SLinus Torvalds * Datafab MDCFE-B USB CompactFlash reader but has since been found to work 42*1da177e4SLinus Torvalds * with a variety of Datafab-based devices from a number of manufacturers. 43*1da177e4SLinus Torvalds * I've received a report of this driver working with a Datafab-based 44*1da177e4SLinus Torvalds * SmartMedia device though please be aware that I'm personally unable to 45*1da177e4SLinus Torvalds * test SmartMedia support. 46*1da177e4SLinus Torvalds * 47*1da177e4SLinus Torvalds * This driver supports reading and writing. If you're truly paranoid, 48*1da177e4SLinus Torvalds * however, you can force the driver into a write-protected state by setting 49*1da177e4SLinus Torvalds * the WP enable bits in datafab_handle_mode_sense(). See the comments 50*1da177e4SLinus Torvalds * in that routine. 51*1da177e4SLinus Torvalds */ 52*1da177e4SLinus Torvalds 53*1da177e4SLinus Torvalds #include <linux/sched.h> 54*1da177e4SLinus Torvalds #include <linux/errno.h> 55*1da177e4SLinus Torvalds #include <linux/slab.h> 56*1da177e4SLinus Torvalds 57*1da177e4SLinus Torvalds #include <scsi/scsi.h> 58*1da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 59*1da177e4SLinus Torvalds 60*1da177e4SLinus Torvalds #include "usb.h" 61*1da177e4SLinus Torvalds #include "transport.h" 62*1da177e4SLinus Torvalds #include "protocol.h" 63*1da177e4SLinus Torvalds #include "debug.h" 64*1da177e4SLinus Torvalds #include "datafab.h" 65*1da177e4SLinus Torvalds 66*1da177e4SLinus Torvalds static int datafab_determine_lun(struct us_data *us, 67*1da177e4SLinus Torvalds struct datafab_info *info); 68*1da177e4SLinus Torvalds 69*1da177e4SLinus Torvalds 70*1da177e4SLinus Torvalds static inline int 71*1da177e4SLinus Torvalds datafab_bulk_read(struct us_data *us, unsigned char *data, unsigned int len) { 72*1da177e4SLinus Torvalds if (len == 0) 73*1da177e4SLinus Torvalds return USB_STOR_XFER_GOOD; 74*1da177e4SLinus Torvalds 75*1da177e4SLinus Torvalds US_DEBUGP("datafab_bulk_read: len = %d\n", len); 76*1da177e4SLinus Torvalds return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 77*1da177e4SLinus Torvalds data, len, NULL); 78*1da177e4SLinus Torvalds } 79*1da177e4SLinus Torvalds 80*1da177e4SLinus Torvalds 81*1da177e4SLinus Torvalds static inline int 82*1da177e4SLinus Torvalds datafab_bulk_write(struct us_data *us, unsigned char *data, unsigned int len) { 83*1da177e4SLinus Torvalds if (len == 0) 84*1da177e4SLinus Torvalds return USB_STOR_XFER_GOOD; 85*1da177e4SLinus Torvalds 86*1da177e4SLinus Torvalds US_DEBUGP("datafab_bulk_write: len = %d\n", len); 87*1da177e4SLinus Torvalds return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 88*1da177e4SLinus Torvalds data, len, NULL); 89*1da177e4SLinus Torvalds } 90*1da177e4SLinus Torvalds 91*1da177e4SLinus Torvalds 92*1da177e4SLinus Torvalds static int datafab_read_data(struct us_data *us, 93*1da177e4SLinus Torvalds struct datafab_info *info, 94*1da177e4SLinus Torvalds u32 sector, 95*1da177e4SLinus Torvalds u32 sectors) 96*1da177e4SLinus Torvalds { 97*1da177e4SLinus Torvalds unsigned char *command = us->iobuf; 98*1da177e4SLinus Torvalds unsigned char *buffer; 99*1da177e4SLinus Torvalds unsigned char thistime; 100*1da177e4SLinus Torvalds unsigned int totallen, alloclen; 101*1da177e4SLinus Torvalds int len, result; 102*1da177e4SLinus Torvalds unsigned int sg_idx = 0, sg_offset = 0; 103*1da177e4SLinus Torvalds 104*1da177e4SLinus Torvalds // we're working in LBA mode. according to the ATA spec, 105*1da177e4SLinus Torvalds // we can support up to 28-bit addressing. I don't know if Datafab 106*1da177e4SLinus Torvalds // supports beyond 24-bit addressing. It's kind of hard to test 107*1da177e4SLinus Torvalds // since it requires > 8GB CF card. 108*1da177e4SLinus Torvalds // 109*1da177e4SLinus Torvalds if (sectors > 0x0FFFFFFF) 110*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 111*1da177e4SLinus Torvalds 112*1da177e4SLinus Torvalds if (info->lun == -1) { 113*1da177e4SLinus Torvalds result = datafab_determine_lun(us, info); 114*1da177e4SLinus Torvalds if (result != USB_STOR_TRANSPORT_GOOD) 115*1da177e4SLinus Torvalds return result; 116*1da177e4SLinus Torvalds } 117*1da177e4SLinus Torvalds 118*1da177e4SLinus Torvalds totallen = sectors * info->ssize; 119*1da177e4SLinus Torvalds 120*1da177e4SLinus Torvalds // Since we don't read more than 64 KB at a time, we have to create 121*1da177e4SLinus Torvalds // a bounce buffer and move the data a piece at a time between the 122*1da177e4SLinus Torvalds // bounce buffer and the actual transfer buffer. 123*1da177e4SLinus Torvalds 124*1da177e4SLinus Torvalds alloclen = min(totallen, 65536u); 125*1da177e4SLinus Torvalds buffer = kmalloc(alloclen, GFP_NOIO); 126*1da177e4SLinus Torvalds if (buffer == NULL) 127*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 128*1da177e4SLinus Torvalds 129*1da177e4SLinus Torvalds do { 130*1da177e4SLinus Torvalds // loop, never allocate or transfer more than 64k at once 131*1da177e4SLinus Torvalds // (min(128k, 255*info->ssize) is the real limit) 132*1da177e4SLinus Torvalds 133*1da177e4SLinus Torvalds len = min(totallen, alloclen); 134*1da177e4SLinus Torvalds thistime = (len / info->ssize) & 0xff; 135*1da177e4SLinus Torvalds 136*1da177e4SLinus Torvalds command[0] = 0; 137*1da177e4SLinus Torvalds command[1] = thistime; 138*1da177e4SLinus Torvalds command[2] = sector & 0xFF; 139*1da177e4SLinus Torvalds command[3] = (sector >> 8) & 0xFF; 140*1da177e4SLinus Torvalds command[4] = (sector >> 16) & 0xFF; 141*1da177e4SLinus Torvalds 142*1da177e4SLinus Torvalds command[5] = 0xE0 + (info->lun << 4); 143*1da177e4SLinus Torvalds command[5] |= (sector >> 24) & 0x0F; 144*1da177e4SLinus Torvalds command[6] = 0x20; 145*1da177e4SLinus Torvalds command[7] = 0x01; 146*1da177e4SLinus Torvalds 147*1da177e4SLinus Torvalds // send the read command 148*1da177e4SLinus Torvalds result = datafab_bulk_write(us, command, 8); 149*1da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 150*1da177e4SLinus Torvalds goto leave; 151*1da177e4SLinus Torvalds 152*1da177e4SLinus Torvalds // read the result 153*1da177e4SLinus Torvalds result = datafab_bulk_read(us, buffer, len); 154*1da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 155*1da177e4SLinus Torvalds goto leave; 156*1da177e4SLinus Torvalds 157*1da177e4SLinus Torvalds // Store the data in the transfer buffer 158*1da177e4SLinus Torvalds usb_stor_access_xfer_buf(buffer, len, us->srb, 159*1da177e4SLinus Torvalds &sg_idx, &sg_offset, TO_XFER_BUF); 160*1da177e4SLinus Torvalds 161*1da177e4SLinus Torvalds sector += thistime; 162*1da177e4SLinus Torvalds totallen -= len; 163*1da177e4SLinus Torvalds } while (totallen > 0); 164*1da177e4SLinus Torvalds 165*1da177e4SLinus Torvalds kfree(buffer); 166*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 167*1da177e4SLinus Torvalds 168*1da177e4SLinus Torvalds leave: 169*1da177e4SLinus Torvalds kfree(buffer); 170*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 171*1da177e4SLinus Torvalds } 172*1da177e4SLinus Torvalds 173*1da177e4SLinus Torvalds 174*1da177e4SLinus Torvalds static int datafab_write_data(struct us_data *us, 175*1da177e4SLinus Torvalds struct datafab_info *info, 176*1da177e4SLinus Torvalds u32 sector, 177*1da177e4SLinus Torvalds u32 sectors) 178*1da177e4SLinus Torvalds { 179*1da177e4SLinus Torvalds unsigned char *command = us->iobuf; 180*1da177e4SLinus Torvalds unsigned char *reply = us->iobuf; 181*1da177e4SLinus Torvalds unsigned char *buffer; 182*1da177e4SLinus Torvalds unsigned char thistime; 183*1da177e4SLinus Torvalds unsigned int totallen, alloclen; 184*1da177e4SLinus Torvalds int len, result; 185*1da177e4SLinus Torvalds unsigned int sg_idx = 0, sg_offset = 0; 186*1da177e4SLinus Torvalds 187*1da177e4SLinus Torvalds // we're working in LBA mode. according to the ATA spec, 188*1da177e4SLinus Torvalds // we can support up to 28-bit addressing. I don't know if Datafab 189*1da177e4SLinus Torvalds // supports beyond 24-bit addressing. It's kind of hard to test 190*1da177e4SLinus Torvalds // since it requires > 8GB CF card. 191*1da177e4SLinus Torvalds // 192*1da177e4SLinus Torvalds if (sectors > 0x0FFFFFFF) 193*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 194*1da177e4SLinus Torvalds 195*1da177e4SLinus Torvalds if (info->lun == -1) { 196*1da177e4SLinus Torvalds result = datafab_determine_lun(us, info); 197*1da177e4SLinus Torvalds if (result != USB_STOR_TRANSPORT_GOOD) 198*1da177e4SLinus Torvalds return result; 199*1da177e4SLinus Torvalds } 200*1da177e4SLinus Torvalds 201*1da177e4SLinus Torvalds totallen = sectors * info->ssize; 202*1da177e4SLinus Torvalds 203*1da177e4SLinus Torvalds // Since we don't write more than 64 KB at a time, we have to create 204*1da177e4SLinus Torvalds // a bounce buffer and move the data a piece at a time between the 205*1da177e4SLinus Torvalds // bounce buffer and the actual transfer buffer. 206*1da177e4SLinus Torvalds 207*1da177e4SLinus Torvalds alloclen = min(totallen, 65536u); 208*1da177e4SLinus Torvalds buffer = kmalloc(alloclen, GFP_NOIO); 209*1da177e4SLinus Torvalds if (buffer == NULL) 210*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 211*1da177e4SLinus Torvalds 212*1da177e4SLinus Torvalds do { 213*1da177e4SLinus Torvalds // loop, never allocate or transfer more than 64k at once 214*1da177e4SLinus Torvalds // (min(128k, 255*info->ssize) is the real limit) 215*1da177e4SLinus Torvalds 216*1da177e4SLinus Torvalds len = min(totallen, alloclen); 217*1da177e4SLinus Torvalds thistime = (len / info->ssize) & 0xff; 218*1da177e4SLinus Torvalds 219*1da177e4SLinus Torvalds // Get the data from the transfer buffer 220*1da177e4SLinus Torvalds usb_stor_access_xfer_buf(buffer, len, us->srb, 221*1da177e4SLinus Torvalds &sg_idx, &sg_offset, FROM_XFER_BUF); 222*1da177e4SLinus Torvalds 223*1da177e4SLinus Torvalds command[0] = 0; 224*1da177e4SLinus Torvalds command[1] = thistime; 225*1da177e4SLinus Torvalds command[2] = sector & 0xFF; 226*1da177e4SLinus Torvalds command[3] = (sector >> 8) & 0xFF; 227*1da177e4SLinus Torvalds command[4] = (sector >> 16) & 0xFF; 228*1da177e4SLinus Torvalds 229*1da177e4SLinus Torvalds command[5] = 0xE0 + (info->lun << 4); 230*1da177e4SLinus Torvalds command[5] |= (sector >> 24) & 0x0F; 231*1da177e4SLinus Torvalds command[6] = 0x30; 232*1da177e4SLinus Torvalds command[7] = 0x02; 233*1da177e4SLinus Torvalds 234*1da177e4SLinus Torvalds // send the command 235*1da177e4SLinus Torvalds result = datafab_bulk_write(us, command, 8); 236*1da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 237*1da177e4SLinus Torvalds goto leave; 238*1da177e4SLinus Torvalds 239*1da177e4SLinus Torvalds // send the data 240*1da177e4SLinus Torvalds result = datafab_bulk_write(us, buffer, len); 241*1da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 242*1da177e4SLinus Torvalds goto leave; 243*1da177e4SLinus Torvalds 244*1da177e4SLinus Torvalds // read the result 245*1da177e4SLinus Torvalds result = datafab_bulk_read(us, reply, 2); 246*1da177e4SLinus Torvalds if (result != USB_STOR_XFER_GOOD) 247*1da177e4SLinus Torvalds goto leave; 248*1da177e4SLinus Torvalds 249*1da177e4SLinus Torvalds if (reply[0] != 0x50 && reply[1] != 0) { 250*1da177e4SLinus Torvalds US_DEBUGP("datafab_write_data: Gah! " 251*1da177e4SLinus Torvalds "write return code: %02x %02x\n", 252*1da177e4SLinus Torvalds reply[0], reply[1]); 253*1da177e4SLinus Torvalds result = USB_STOR_TRANSPORT_ERROR; 254*1da177e4SLinus Torvalds goto leave; 255*1da177e4SLinus Torvalds } 256*1da177e4SLinus Torvalds 257*1da177e4SLinus Torvalds sector += thistime; 258*1da177e4SLinus Torvalds totallen -= len; 259*1da177e4SLinus Torvalds } while (totallen > 0); 260*1da177e4SLinus Torvalds 261*1da177e4SLinus Torvalds kfree(buffer); 262*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 263*1da177e4SLinus Torvalds 264*1da177e4SLinus Torvalds leave: 265*1da177e4SLinus Torvalds kfree(buffer); 266*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 267*1da177e4SLinus Torvalds } 268*1da177e4SLinus Torvalds 269*1da177e4SLinus Torvalds 270*1da177e4SLinus Torvalds static int datafab_determine_lun(struct us_data *us, 271*1da177e4SLinus Torvalds struct datafab_info *info) 272*1da177e4SLinus Torvalds { 273*1da177e4SLinus Torvalds // Dual-slot readers can be thought of as dual-LUN devices. 274*1da177e4SLinus Torvalds // We need to determine which card slot is being used. 275*1da177e4SLinus Torvalds // We'll send an IDENTIFY DEVICE command and see which LUN responds... 276*1da177e4SLinus Torvalds // 277*1da177e4SLinus Torvalds // There might be a better way of doing this? 278*1da177e4SLinus Torvalds 279*1da177e4SLinus Torvalds static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 280*1da177e4SLinus Torvalds unsigned char *command = us->iobuf; 281*1da177e4SLinus Torvalds unsigned char *buf; 282*1da177e4SLinus Torvalds int count = 0, rc; 283*1da177e4SLinus Torvalds 284*1da177e4SLinus Torvalds if (!us || !info) 285*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 286*1da177e4SLinus Torvalds 287*1da177e4SLinus Torvalds memcpy(command, scommand, 8); 288*1da177e4SLinus Torvalds buf = kmalloc(512, GFP_NOIO); 289*1da177e4SLinus Torvalds if (!buf) 290*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 291*1da177e4SLinus Torvalds 292*1da177e4SLinus Torvalds US_DEBUGP("datafab_determine_lun: locating...\n"); 293*1da177e4SLinus Torvalds 294*1da177e4SLinus Torvalds // we'll try 3 times before giving up... 295*1da177e4SLinus Torvalds // 296*1da177e4SLinus Torvalds while (count++ < 3) { 297*1da177e4SLinus Torvalds command[5] = 0xa0; 298*1da177e4SLinus Torvalds 299*1da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 300*1da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 301*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 302*1da177e4SLinus Torvalds goto leave; 303*1da177e4SLinus Torvalds } 304*1da177e4SLinus Torvalds 305*1da177e4SLinus Torvalds rc = datafab_bulk_read(us, buf, 512); 306*1da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 307*1da177e4SLinus Torvalds info->lun = 0; 308*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 309*1da177e4SLinus Torvalds goto leave; 310*1da177e4SLinus Torvalds } 311*1da177e4SLinus Torvalds 312*1da177e4SLinus Torvalds command[5] = 0xb0; 313*1da177e4SLinus Torvalds 314*1da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 315*1da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 316*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 317*1da177e4SLinus Torvalds goto leave; 318*1da177e4SLinus Torvalds } 319*1da177e4SLinus Torvalds 320*1da177e4SLinus Torvalds rc = datafab_bulk_read(us, buf, 512); 321*1da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 322*1da177e4SLinus Torvalds info->lun = 1; 323*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 324*1da177e4SLinus Torvalds goto leave; 325*1da177e4SLinus Torvalds } 326*1da177e4SLinus Torvalds 327*1da177e4SLinus Torvalds msleep(20); 328*1da177e4SLinus Torvalds } 329*1da177e4SLinus Torvalds 330*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 331*1da177e4SLinus Torvalds 332*1da177e4SLinus Torvalds leave: 333*1da177e4SLinus Torvalds kfree(buf); 334*1da177e4SLinus Torvalds return rc; 335*1da177e4SLinus Torvalds } 336*1da177e4SLinus Torvalds 337*1da177e4SLinus Torvalds static int datafab_id_device(struct us_data *us, 338*1da177e4SLinus Torvalds struct datafab_info *info) 339*1da177e4SLinus Torvalds { 340*1da177e4SLinus Torvalds // this is a variation of the ATA "IDENTIFY DEVICE" command...according 341*1da177e4SLinus Torvalds // to the ATA spec, 'Sector Count' isn't used but the Windows driver 342*1da177e4SLinus Torvalds // sets this bit so we do too... 343*1da177e4SLinus Torvalds // 344*1da177e4SLinus Torvalds static unsigned char scommand[8] = { 0, 1, 0, 0, 0, 0xa0, 0xec, 1 }; 345*1da177e4SLinus Torvalds unsigned char *command = us->iobuf; 346*1da177e4SLinus Torvalds unsigned char *reply; 347*1da177e4SLinus Torvalds int rc; 348*1da177e4SLinus Torvalds 349*1da177e4SLinus Torvalds if (!us || !info) 350*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 351*1da177e4SLinus Torvalds 352*1da177e4SLinus Torvalds if (info->lun == -1) { 353*1da177e4SLinus Torvalds rc = datafab_determine_lun(us, info); 354*1da177e4SLinus Torvalds if (rc != USB_STOR_TRANSPORT_GOOD) 355*1da177e4SLinus Torvalds return rc; 356*1da177e4SLinus Torvalds } 357*1da177e4SLinus Torvalds 358*1da177e4SLinus Torvalds memcpy(command, scommand, 8); 359*1da177e4SLinus Torvalds reply = kmalloc(512, GFP_NOIO); 360*1da177e4SLinus Torvalds if (!reply) 361*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 362*1da177e4SLinus Torvalds 363*1da177e4SLinus Torvalds command[5] += (info->lun << 4); 364*1da177e4SLinus Torvalds 365*1da177e4SLinus Torvalds rc = datafab_bulk_write(us, command, 8); 366*1da177e4SLinus Torvalds if (rc != USB_STOR_XFER_GOOD) { 367*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 368*1da177e4SLinus Torvalds goto leave; 369*1da177e4SLinus Torvalds } 370*1da177e4SLinus Torvalds 371*1da177e4SLinus Torvalds // we'll go ahead and extract the media capacity while we're here... 372*1da177e4SLinus Torvalds // 373*1da177e4SLinus Torvalds rc = datafab_bulk_read(us, reply, 512); 374*1da177e4SLinus Torvalds if (rc == USB_STOR_XFER_GOOD) { 375*1da177e4SLinus Torvalds // capacity is at word offset 57-58 376*1da177e4SLinus Torvalds // 377*1da177e4SLinus Torvalds info->sectors = ((u32)(reply[117]) << 24) | 378*1da177e4SLinus Torvalds ((u32)(reply[116]) << 16) | 379*1da177e4SLinus Torvalds ((u32)(reply[115]) << 8) | 380*1da177e4SLinus Torvalds ((u32)(reply[114]) ); 381*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_GOOD; 382*1da177e4SLinus Torvalds goto leave; 383*1da177e4SLinus Torvalds } 384*1da177e4SLinus Torvalds 385*1da177e4SLinus Torvalds rc = USB_STOR_TRANSPORT_ERROR; 386*1da177e4SLinus Torvalds 387*1da177e4SLinus Torvalds leave: 388*1da177e4SLinus Torvalds kfree(reply); 389*1da177e4SLinus Torvalds return rc; 390*1da177e4SLinus Torvalds } 391*1da177e4SLinus Torvalds 392*1da177e4SLinus Torvalds 393*1da177e4SLinus Torvalds static int datafab_handle_mode_sense(struct us_data *us, 394*1da177e4SLinus Torvalds struct scsi_cmnd * srb, 395*1da177e4SLinus Torvalds int sense_6) 396*1da177e4SLinus Torvalds { 397*1da177e4SLinus Torvalds static unsigned char rw_err_page[12] = { 398*1da177e4SLinus Torvalds 0x1, 0xA, 0x21, 1, 0, 0, 0, 0, 1, 0, 0, 0 399*1da177e4SLinus Torvalds }; 400*1da177e4SLinus Torvalds static unsigned char cache_page[12] = { 401*1da177e4SLinus Torvalds 0x8, 0xA, 0x1, 0, 0, 0, 0, 0, 0, 0, 0, 0 402*1da177e4SLinus Torvalds }; 403*1da177e4SLinus Torvalds static unsigned char rbac_page[12] = { 404*1da177e4SLinus Torvalds 0x1B, 0xA, 0, 0x81, 0, 0, 0, 0, 0, 0, 0, 0 405*1da177e4SLinus Torvalds }; 406*1da177e4SLinus Torvalds static unsigned char timer_page[8] = { 407*1da177e4SLinus Torvalds 0x1C, 0x6, 0, 0, 0, 0 408*1da177e4SLinus Torvalds }; 409*1da177e4SLinus Torvalds unsigned char pc, page_code; 410*1da177e4SLinus Torvalds unsigned int i = 0; 411*1da177e4SLinus Torvalds struct datafab_info *info = (struct datafab_info *) (us->extra); 412*1da177e4SLinus Torvalds unsigned char *ptr = us->iobuf; 413*1da177e4SLinus Torvalds 414*1da177e4SLinus Torvalds // most of this stuff is just a hack to get things working. the 415*1da177e4SLinus Torvalds // datafab reader doesn't present a SCSI interface so we 416*1da177e4SLinus Torvalds // fudge the SCSI commands... 417*1da177e4SLinus Torvalds // 418*1da177e4SLinus Torvalds 419*1da177e4SLinus Torvalds pc = srb->cmnd[2] >> 6; 420*1da177e4SLinus Torvalds page_code = srb->cmnd[2] & 0x3F; 421*1da177e4SLinus Torvalds 422*1da177e4SLinus Torvalds switch (pc) { 423*1da177e4SLinus Torvalds case 0x0: 424*1da177e4SLinus Torvalds US_DEBUGP("datafab_handle_mode_sense: Current values\n"); 425*1da177e4SLinus Torvalds break; 426*1da177e4SLinus Torvalds case 0x1: 427*1da177e4SLinus Torvalds US_DEBUGP("datafab_handle_mode_sense: Changeable values\n"); 428*1da177e4SLinus Torvalds break; 429*1da177e4SLinus Torvalds case 0x2: 430*1da177e4SLinus Torvalds US_DEBUGP("datafab_handle_mode_sense: Default values\n"); 431*1da177e4SLinus Torvalds break; 432*1da177e4SLinus Torvalds case 0x3: 433*1da177e4SLinus Torvalds US_DEBUGP("datafab_handle_mode_sense: Saves values\n"); 434*1da177e4SLinus Torvalds break; 435*1da177e4SLinus Torvalds } 436*1da177e4SLinus Torvalds 437*1da177e4SLinus Torvalds memset(ptr, 0, 8); 438*1da177e4SLinus Torvalds if (sense_6) { 439*1da177e4SLinus Torvalds ptr[2] = 0x00; // WP enable: 0x80 440*1da177e4SLinus Torvalds i = 4; 441*1da177e4SLinus Torvalds } else { 442*1da177e4SLinus Torvalds ptr[3] = 0x00; // WP enable: 0x80 443*1da177e4SLinus Torvalds i = 8; 444*1da177e4SLinus Torvalds } 445*1da177e4SLinus Torvalds 446*1da177e4SLinus Torvalds switch (page_code) { 447*1da177e4SLinus Torvalds default: 448*1da177e4SLinus Torvalds // vendor-specific mode 449*1da177e4SLinus Torvalds info->sense_key = 0x05; 450*1da177e4SLinus Torvalds info->sense_asc = 0x24; 451*1da177e4SLinus Torvalds info->sense_ascq = 0x00; 452*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_FAILED; 453*1da177e4SLinus Torvalds 454*1da177e4SLinus Torvalds case 0x1: 455*1da177e4SLinus Torvalds memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 456*1da177e4SLinus Torvalds i += sizeof(rw_err_page); 457*1da177e4SLinus Torvalds break; 458*1da177e4SLinus Torvalds 459*1da177e4SLinus Torvalds case 0x8: 460*1da177e4SLinus Torvalds memcpy(ptr + i, cache_page, sizeof(cache_page)); 461*1da177e4SLinus Torvalds i += sizeof(cache_page); 462*1da177e4SLinus Torvalds break; 463*1da177e4SLinus Torvalds 464*1da177e4SLinus Torvalds case 0x1B: 465*1da177e4SLinus Torvalds memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 466*1da177e4SLinus Torvalds i += sizeof(rbac_page); 467*1da177e4SLinus Torvalds break; 468*1da177e4SLinus Torvalds 469*1da177e4SLinus Torvalds case 0x1C: 470*1da177e4SLinus Torvalds memcpy(ptr + i, timer_page, sizeof(timer_page)); 471*1da177e4SLinus Torvalds i += sizeof(timer_page); 472*1da177e4SLinus Torvalds break; 473*1da177e4SLinus Torvalds 474*1da177e4SLinus Torvalds case 0x3F: // retrieve all pages 475*1da177e4SLinus Torvalds memcpy(ptr + i, timer_page, sizeof(timer_page)); 476*1da177e4SLinus Torvalds i += sizeof(timer_page); 477*1da177e4SLinus Torvalds memcpy(ptr + i, rbac_page, sizeof(rbac_page)); 478*1da177e4SLinus Torvalds i += sizeof(rbac_page); 479*1da177e4SLinus Torvalds memcpy(ptr + i, cache_page, sizeof(cache_page)); 480*1da177e4SLinus Torvalds i += sizeof(cache_page); 481*1da177e4SLinus Torvalds memcpy(ptr + i, rw_err_page, sizeof(rw_err_page)); 482*1da177e4SLinus Torvalds i += sizeof(rw_err_page); 483*1da177e4SLinus Torvalds break; 484*1da177e4SLinus Torvalds } 485*1da177e4SLinus Torvalds 486*1da177e4SLinus Torvalds if (sense_6) 487*1da177e4SLinus Torvalds ptr[0] = i - 1; 488*1da177e4SLinus Torvalds else 489*1da177e4SLinus Torvalds ((__be16 *) ptr)[0] = cpu_to_be16(i - 2); 490*1da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, i, srb); 491*1da177e4SLinus Torvalds 492*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 493*1da177e4SLinus Torvalds } 494*1da177e4SLinus Torvalds 495*1da177e4SLinus Torvalds static void datafab_info_destructor(void *extra) 496*1da177e4SLinus Torvalds { 497*1da177e4SLinus Torvalds // this routine is a placeholder... 498*1da177e4SLinus Torvalds // currently, we don't allocate any extra memory so we're okay 499*1da177e4SLinus Torvalds } 500*1da177e4SLinus Torvalds 501*1da177e4SLinus Torvalds 502*1da177e4SLinus Torvalds // Transport for the Datafab MDCFE-B 503*1da177e4SLinus Torvalds // 504*1da177e4SLinus Torvalds int datafab_transport(struct scsi_cmnd * srb, struct us_data *us) 505*1da177e4SLinus Torvalds { 506*1da177e4SLinus Torvalds struct datafab_info *info; 507*1da177e4SLinus Torvalds int rc; 508*1da177e4SLinus Torvalds unsigned long block, blocks; 509*1da177e4SLinus Torvalds unsigned char *ptr = us->iobuf; 510*1da177e4SLinus Torvalds static unsigned char inquiry_reply[8] = { 511*1da177e4SLinus Torvalds 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 512*1da177e4SLinus Torvalds }; 513*1da177e4SLinus Torvalds 514*1da177e4SLinus Torvalds if (!us->extra) { 515*1da177e4SLinus Torvalds us->extra = kmalloc(sizeof(struct datafab_info), GFP_NOIO); 516*1da177e4SLinus Torvalds if (!us->extra) { 517*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: Gah! " 518*1da177e4SLinus Torvalds "Can't allocate storage for Datafab info struct!\n"); 519*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 520*1da177e4SLinus Torvalds } 521*1da177e4SLinus Torvalds memset(us->extra, 0, sizeof(struct datafab_info)); 522*1da177e4SLinus Torvalds us->extra_destructor = datafab_info_destructor; 523*1da177e4SLinus Torvalds ((struct datafab_info *)us->extra)->lun = -1; 524*1da177e4SLinus Torvalds } 525*1da177e4SLinus Torvalds 526*1da177e4SLinus Torvalds info = (struct datafab_info *) (us->extra); 527*1da177e4SLinus Torvalds 528*1da177e4SLinus Torvalds if (srb->cmnd[0] == INQUIRY) { 529*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: INQUIRY. Returning bogus response"); 530*1da177e4SLinus Torvalds memcpy(ptr, inquiry_reply, sizeof(inquiry_reply)); 531*1da177e4SLinus Torvalds fill_inquiry_response(us, ptr, 36); 532*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 533*1da177e4SLinus Torvalds } 534*1da177e4SLinus Torvalds 535*1da177e4SLinus Torvalds if (srb->cmnd[0] == READ_CAPACITY) { 536*1da177e4SLinus Torvalds info->ssize = 0x200; // hard coded 512 byte sectors as per ATA spec 537*1da177e4SLinus Torvalds rc = datafab_id_device(us, info); 538*1da177e4SLinus Torvalds if (rc != USB_STOR_TRANSPORT_GOOD) 539*1da177e4SLinus Torvalds return rc; 540*1da177e4SLinus Torvalds 541*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: READ_CAPACITY: %ld sectors, %ld bytes per sector\n", 542*1da177e4SLinus Torvalds info->sectors, info->ssize); 543*1da177e4SLinus Torvalds 544*1da177e4SLinus Torvalds // build the reply 545*1da177e4SLinus Torvalds // we need the last sector, not the number of sectors 546*1da177e4SLinus Torvalds ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1); 547*1da177e4SLinus Torvalds ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize); 548*1da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, 8, srb); 549*1da177e4SLinus Torvalds 550*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 551*1da177e4SLinus Torvalds } 552*1da177e4SLinus Torvalds 553*1da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SELECT_10) { 554*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: Gah! MODE_SELECT_10.\n"); 555*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_ERROR; 556*1da177e4SLinus Torvalds } 557*1da177e4SLinus Torvalds 558*1da177e4SLinus Torvalds // don't bother implementing READ_6 or WRITE_6. 559*1da177e4SLinus Torvalds // 560*1da177e4SLinus Torvalds if (srb->cmnd[0] == READ_10) { 561*1da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 562*1da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 563*1da177e4SLinus Torvalds 564*1da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 565*1da177e4SLinus Torvalds 566*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: READ_10: read block 0x%04lx count %ld\n", block, blocks); 567*1da177e4SLinus Torvalds return datafab_read_data(us, info, block, blocks); 568*1da177e4SLinus Torvalds } 569*1da177e4SLinus Torvalds 570*1da177e4SLinus Torvalds if (srb->cmnd[0] == READ_12) { 571*1da177e4SLinus Torvalds // we'll probably never see a READ_12 but we'll do it anyway... 572*1da177e4SLinus Torvalds // 573*1da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 574*1da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 575*1da177e4SLinus Torvalds 576*1da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 577*1da177e4SLinus Torvalds ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 578*1da177e4SLinus Torvalds 579*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: READ_12: read block 0x%04lx count %ld\n", block, blocks); 580*1da177e4SLinus Torvalds return datafab_read_data(us, info, block, blocks); 581*1da177e4SLinus Torvalds } 582*1da177e4SLinus Torvalds 583*1da177e4SLinus Torvalds if (srb->cmnd[0] == WRITE_10) { 584*1da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 585*1da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 586*1da177e4SLinus Torvalds 587*1da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8])); 588*1da177e4SLinus Torvalds 589*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: WRITE_10: write block 0x%04lx count %ld\n", block, blocks); 590*1da177e4SLinus Torvalds return datafab_write_data(us, info, block, blocks); 591*1da177e4SLinus Torvalds } 592*1da177e4SLinus Torvalds 593*1da177e4SLinus Torvalds if (srb->cmnd[0] == WRITE_12) { 594*1da177e4SLinus Torvalds // we'll probably never see a WRITE_12 but we'll do it anyway... 595*1da177e4SLinus Torvalds // 596*1da177e4SLinus Torvalds block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) | 597*1da177e4SLinus Torvalds ((u32)(srb->cmnd[4]) << 8) | ((u32)(srb->cmnd[5])); 598*1da177e4SLinus Torvalds 599*1da177e4SLinus Torvalds blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) | 600*1da177e4SLinus Torvalds ((u32)(srb->cmnd[8]) << 8) | ((u32)(srb->cmnd[9])); 601*1da177e4SLinus Torvalds 602*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: WRITE_12: write block 0x%04lx count %ld\n", block, blocks); 603*1da177e4SLinus Torvalds return datafab_write_data(us, info, block, blocks); 604*1da177e4SLinus Torvalds } 605*1da177e4SLinus Torvalds 606*1da177e4SLinus Torvalds if (srb->cmnd[0] == TEST_UNIT_READY) { 607*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: TEST_UNIT_READY.\n"); 608*1da177e4SLinus Torvalds return datafab_id_device(us, info); 609*1da177e4SLinus Torvalds } 610*1da177e4SLinus Torvalds 611*1da177e4SLinus Torvalds if (srb->cmnd[0] == REQUEST_SENSE) { 612*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: REQUEST_SENSE. Returning faked response\n"); 613*1da177e4SLinus Torvalds 614*1da177e4SLinus Torvalds // this response is pretty bogus right now. eventually if necessary 615*1da177e4SLinus Torvalds // we can set the correct sense data. so far though it hasn't been 616*1da177e4SLinus Torvalds // necessary 617*1da177e4SLinus Torvalds // 618*1da177e4SLinus Torvalds memset(ptr, 0, 18); 619*1da177e4SLinus Torvalds ptr[0] = 0xF0; 620*1da177e4SLinus Torvalds ptr[2] = info->sense_key; 621*1da177e4SLinus Torvalds ptr[7] = 11; 622*1da177e4SLinus Torvalds ptr[12] = info->sense_asc; 623*1da177e4SLinus Torvalds ptr[13] = info->sense_ascq; 624*1da177e4SLinus Torvalds usb_stor_set_xfer_buf(ptr, 18, srb); 625*1da177e4SLinus Torvalds 626*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 627*1da177e4SLinus Torvalds } 628*1da177e4SLinus Torvalds 629*1da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SENSE) { 630*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: MODE_SENSE_6 detected\n"); 631*1da177e4SLinus Torvalds return datafab_handle_mode_sense(us, srb, 1); 632*1da177e4SLinus Torvalds } 633*1da177e4SLinus Torvalds 634*1da177e4SLinus Torvalds if (srb->cmnd[0] == MODE_SENSE_10) { 635*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: MODE_SENSE_10 detected\n"); 636*1da177e4SLinus Torvalds return datafab_handle_mode_sense(us, srb, 0); 637*1da177e4SLinus Torvalds } 638*1da177e4SLinus Torvalds 639*1da177e4SLinus Torvalds if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 640*1da177e4SLinus Torvalds // sure. whatever. not like we can stop the user from 641*1da177e4SLinus Torvalds // popping the media out of the device (no locking doors, etc) 642*1da177e4SLinus Torvalds // 643*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_GOOD; 644*1da177e4SLinus Torvalds } 645*1da177e4SLinus Torvalds 646*1da177e4SLinus Torvalds if (srb->cmnd[0] == START_STOP) { 647*1da177e4SLinus Torvalds /* this is used by sd.c'check_scsidisk_media_change to detect 648*1da177e4SLinus Torvalds media change */ 649*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: START_STOP.\n"); 650*1da177e4SLinus Torvalds /* the first datafab_id_device after a media change returns 651*1da177e4SLinus Torvalds an error (determined experimentally) */ 652*1da177e4SLinus Torvalds rc = datafab_id_device(us, info); 653*1da177e4SLinus Torvalds if (rc == USB_STOR_TRANSPORT_GOOD) { 654*1da177e4SLinus Torvalds info->sense_key = NO_SENSE; 655*1da177e4SLinus Torvalds srb->result = SUCCESS; 656*1da177e4SLinus Torvalds } else { 657*1da177e4SLinus Torvalds info->sense_key = UNIT_ATTENTION; 658*1da177e4SLinus Torvalds srb->result = SAM_STAT_CHECK_CONDITION; 659*1da177e4SLinus Torvalds } 660*1da177e4SLinus Torvalds return rc; 661*1da177e4SLinus Torvalds } 662*1da177e4SLinus Torvalds 663*1da177e4SLinus Torvalds US_DEBUGP("datafab_transport: Gah! Unknown command: %d (0x%x)\n", 664*1da177e4SLinus Torvalds srb->cmnd[0], srb->cmnd[0]); 665*1da177e4SLinus Torvalds info->sense_key = 0x05; 666*1da177e4SLinus Torvalds info->sense_asc = 0x20; 667*1da177e4SLinus Torvalds info->sense_ascq = 0x00; 668*1da177e4SLinus Torvalds return USB_STOR_TRANSPORT_FAILED; 669*1da177e4SLinus Torvalds } 670