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 <scsi/scsi.h>
  22 #include <scsi/scsi_cmnd.h>
  23 #include <scsi/scsi_device.h>
  24
  25 #include "usb.h"
  26 #include "transport.h"
  27 #include "debug.h"
  28 #include "karma.h"
  29
  30 #define RIO_PREFIX "RIOP\x00"
  31 #define RIO_PREFIX_LEN 5
  32 #define RIO_SEND_LEN 40
  33 #define RIO_RECV_LEN 0x200
  34
  35 #define RIO_ENTER_STORAGE 0x1
  36 #define RIO_LEAVE_STORAGE 0x2
  37 #define RIO_RESET 0xC
  38
  39 extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data *);
  40
  41 struct karma_data {
  42         int in_storage;
  43         char *recv;
  44 };
  45
  46 /*
  47  * Send commands to Rio Karma.
  48  *
  49  * For each command we send 40 bytes starting 'RIOP\0' followed by
  50  * the command number and a sequence number, which the device will ack
  51  * with a 512-byte packet with the high four bits set and everything
  52  * else null.  Then we send 'RIOP\x80' followed by a zero and the
  53  * sequence number, until byte 5 in the response repeats the sequence
  54  * number.
  55  */
  56 static int rio_karma_send_command(char cmd, struct us_data *us)
  57 {
  58         int result, partial;
  59         unsigned long timeout;
  60         static unsigned char seq = 1;
  61         struct karma_data *data = (struct karma_data *) us->extra;
  62
  63         US_DEBUGP("karma: sending command %04x\n", cmd);
  64         memset(us->iobuf, 0, RIO_SEND_LEN);
  65         memcpy(us->iobuf, RIO_PREFIX, RIO_PREFIX_LEN);
  66         us->iobuf[5] = cmd;
  67         us->iobuf[6] = seq;
  68
  69         timeout = jiffies + msecs_to_jiffies(6000);
  70         for (;;) {
  71                 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
  72                         us->iobuf, RIO_SEND_LEN, &partial);
  73                 if (result != USB_STOR_XFER_GOOD)
  74                         goto err;
  75
  76                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
  77                         data->recv, RIO_RECV_LEN, &partial);
  78                 if (result != USB_STOR_XFER_GOOD)
  79                         goto err;
  80
  81                 if (data->recv[5] == seq)
  82                         break;
  83
  84                 if (time_after(jiffies, timeout))
  85                         goto err;
  86
  87                 us->iobuf[4] = 0x80;
  88                 us->iobuf[5] = 0;
  89                 msleep(50);
  90         }
  91
  92         seq++;
  93         if (seq == 0)
  94                 seq = 1;
  95
  96         US_DEBUGP("karma: sent command %04x\n", cmd);
  97         return 0;
  98 err:
  99         US_DEBUGP("karma: command %04x failed\n", cmd);
 100         return USB_STOR_TRANSPORT_FAILED;
 101 }
 102
 103 /*
 104  * Trap START_STOP and READ_10 to leave/re-enter storage mode.
 105  * Everything else is propagated to the normal bulk layer.
 106  */
 107 int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us)
 108 {
 109         int ret;
 110         struct karma_data *data = (struct karma_data *) us->extra;
 111
 112         if (srb->cmnd[0] == READ_10 && !data->in_storage) {
 113                 ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
 114                 if (ret)
 115                         return ret;
 116
 117                 data->in_storage = 1;
 118                 return usb_stor_Bulk_transport(srb, us);
 119         } else if (srb->cmnd[0] == START_STOP) {
 120                 ret = rio_karma_send_command(RIO_LEAVE_STORAGE, us);
 121                 if (ret)
 122                         return ret;
 123
 124                 data->in_storage = 0;
 125                 return rio_karma_send_command(RIO_RESET, us);
 126         }
 127         return usb_stor_Bulk_transport(srb, us);
 128 }
 129
 130 static void rio_karma_destructor(void *extra)
 131 {
 132         struct karma_data *data = (struct karma_data *) extra;
 133         kfree(data->recv);
 134 }
 135
 136 int rio_karma_init(struct us_data *us)
 137 {
 138         int ret = 0;
 139         struct karma_data *data = kzalloc(sizeof(struct karma_data), GFP_NOIO);
 140         if (!data)
 141                 goto out;
 142
 143         data->recv = kmalloc(RIO_RECV_LEN, GFP_NOIO);
 144         if (!data->recv) {
 145                 kfree(data);
 146                 goto out;
 147         }
 148
 149         us->extra = data;
 150         us->extra_destructor = rio_karma_destructor;
 151         ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
 152         data->in_storage = (ret == 0);
 153 out:
 154         return ret;
 155 }