release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/usb/storage/karma.c

   1 /* Driver for Rio Karma
   2  *
   3  *   (c) 2006 Bob Copeland <me@bobcopeland.com>
   4  *   (c) 2006 Keith Bennett <keith@mcs.st-and.ac.uk>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23
  24 #include <scsi/scsi.h>
  25 #include <scsi/scsi_cmnd.h>
  26 #include <scsi/scsi_device.h>
  27
  28 #include "usb.h"
  29 #include "transport.h"
  30 #include "debug.h"
  31
  32 MODULE_DESCRIPTION("Driver for Rio Karma");
  33 MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>, Keith Bennett <keith@mcs.st-and.ac.uk>");
  34 MODULE_LICENSE("GPL");
  35
  36 #define RIO_PREFIX "RIOP\x00"
  37 #define RIO_PREFIX_LEN 5
  38 #define RIO_SEND_LEN 40
  39 #define RIO_RECV_LEN 0x200
  40
  41 #define RIO_ENTER_STORAGE 0x1
  42 #define RIO_LEAVE_STORAGE 0x2
  43 #define RIO_RESET 0xC
  44
  45 struct karma_data {
  46         int in_storage;
  47         char *recv;
  48 };
  49
  50 static int rio_karma_init(struct us_data *us);
  51
  52
  53 /*
  54  * The table of devices
  55  */
  56 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
  57                     vendorName, productName, useProtocol, useTransport, \
  58                     initFunction, flags) \
  59 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
  60   .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
  61
  62 struct usb_device_id karma_usb_ids[] = {
  63 #       include "unusual_karma.h"
  64         { }             /* Terminating entry */
  65 };
  66 MODULE_DEVICE_TABLE(usb, karma_usb_ids);
  67
  68 #undef UNUSUAL_DEV
  69
  70 /*
  71  * The flags table
  72  */
  73 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
  74                     vendor_name, product_name, use_protocol, use_transport, \
  75                     init_function, Flags) \
  76 { \
  77         .vendorName = vendor_name,      \
  78         .productName = product_name,    \
  79         .useProtocol = use_protocol,    \
  80         .useTransport = use_transport,  \
  81         .initFunction = init_function,  \
  82 }
  83
  84 static struct us_unusual_dev karma_unusual_dev_list[] = {
  85 #       include "unusual_karma.h"
  86         { }             /* Terminating entry */
  87 };
  88
  89 #undef UNUSUAL_DEV
  90
  91
  92 /*
  93  * Send commands to Rio Karma.
  94  *
  95  * For each command we send 40 bytes starting 'RIOP\0' followed by
  96  * the command number and a sequence number, which the device will ack
  97  * with a 512-byte packet with the high four bits set and everything
  98  * else null.  Then we send 'RIOP\x80' followed by a zero and the
  99  * sequence number, until byte 5 in the response repeats the sequence
 100  * number.
 101  */
 102 static int rio_karma_send_command(char cmd, struct us_data *us)
 103 {
 104         int result, partial;
 105         unsigned long timeout;
 106         static unsigned char seq = 1;
 107         struct karma_data *data = (struct karma_data *) us->extra;
 108
 109         US_DEBUGP("karma: sending command %04x\n", cmd);
 110         memset(us->iobuf, 0, RIO_SEND_LEN);
 111         memcpy(us->iobuf, RIO_PREFIX, RIO_PREFIX_LEN);
 112         us->iobuf[5] = cmd;
 113         us->iobuf[6] = seq;
 114
 115         timeout = jiffies + msecs_to_jiffies(6000);
 116         for (;;) {
 117                 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 118                         us->iobuf, RIO_SEND_LEN, &partial);
 119                 if (result != USB_STOR_XFER_GOOD)
 120                         goto err;
 121
 122                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 123                         data->recv, RIO_RECV_LEN, &partial);
 124                 if (result != USB_STOR_XFER_GOOD)
 125                         goto err;
 126
 127                 if (data->recv[5] == seq)
 128                         break;
 129
 130                 if (time_after(jiffies, timeout))
 131                         goto err;
 132
 133                 us->iobuf[4] = 0x80;
 134                 us->iobuf[5] = 0;
 135                 msleep(50);
 136         }
 137
 138         seq++;
 139         if (seq == 0)
 140                 seq = 1;
 141
 142         US_DEBUGP("karma: sent command %04x\n", cmd);
 143         return 0;
 144 err:
 145         US_DEBUGP("karma: command %04x failed\n", cmd);
 146         return USB_STOR_TRANSPORT_FAILED;
 147 }
 148
 149 /*
 150  * Trap START_STOP and READ_10 to leave/re-enter storage mode.
 151  * Everything else is propagated to the normal bulk layer.
 152  */
 153 static int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us)
 154 {
 155         int ret;
 156         struct karma_data *data = (struct karma_data *) us->extra;
 157
 158         if (srb->cmnd[0] == READ_10 && !data->in_storage) {
 159                 ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
 160                 if (ret)
 161                         return ret;
 162
 163                 data->in_storage = 1;
 164                 return usb_stor_Bulk_transport(srb, us);
 165         } else if (srb->cmnd[0] == START_STOP) {
 166                 ret = rio_karma_send_command(RIO_LEAVE_STORAGE, us);
 167                 if (ret)
 168                         return ret;
 169
 170                 data->in_storage = 0;
 171                 return rio_karma_send_command(RIO_RESET, us);
 172         }
 173         return usb_stor_Bulk_transport(srb, us);
 174 }
 175
 176 static void rio_karma_destructor(void *extra)
 177 {
 178         struct karma_data *data = (struct karma_data *) extra;
 179         kfree(data->recv);
 180 }
 181
 182 static int rio_karma_init(struct us_data *us)
 183 {
 184         int ret = 0;
 185         struct karma_data *data = kzalloc(sizeof(struct karma_data), GFP_NOIO);
 186         if (!data)
 187                 goto out;
 188
 189         data->recv = kmalloc(RIO_RECV_LEN, GFP_NOIO);
 190         if (!data->recv) {
 191                 kfree(data);
 192                 goto out;
 193         }
 194
 195         us->extra = data;
 196         us->extra_destructor = rio_karma_destructor;
 197         ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
 198         data->in_storage = (ret == 0);
 199 out:
 200         return ret;
 201 }
 202
 203 static int karma_probe(struct usb_interface *intf,
 204                          const struct usb_device_id *id)
 205 {
 206         struct us_data *us;
 207         int result;
 208
 209         result = usb_stor_probe1(&us, intf, id,
 210                         (id - karma_usb_ids) + karma_unusual_dev_list);
 211         if (result)
 212                 return result;
 213
 214         us->transport_name = "Rio Karma/Bulk";
 215         us->transport = rio_karma_transport;
 216         us->transport_reset = usb_stor_Bulk_reset;
 217
 218         result = usb_stor_probe2(us);
 219         return result;
 220 }
 221
 222 static struct usb_driver karma_driver = {
 223         .name =         "ums-karma",
 224         .probe =        karma_probe,
 225         .disconnect =   usb_stor_disconnect,
 226         .suspend =      usb_stor_suspend,
 227         .resume =       usb_stor_resume,
 228         .reset_resume = usb_stor_reset_resume,
 229         .pre_reset =    usb_stor_pre_reset,
 230         .post_reset =   usb_stor_post_reset,
 231         .id_table =     karma_usb_ids,
 232         .soft_unbind =  1,
 233 };
 234
 235 static int __init karma_init(void)
 236 {
 237         return usb_register(&karma_driver);
 238 }
 239
 240 static void __exit karma_exit(void)
 241 {
 242         usb_deregister(&karma_driver);
 243 }
 244
 245 module_init(karma_init);
 246 module_exit(karma_exit);