4 * (c) 2006 Bob Copeland <me@bobcopeland.com>
5 * (c) 2006 Keith Bennett <keith@mcs.st-and.ac.uk>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/module.h>
23 #include <linux/slab.h>
25 #include <scsi/scsi.h>
26 #include <scsi/scsi_cmnd.h>
27 #include <scsi/scsi_device.h>
30 #include "transport.h"
34 #define DRV_NAME "ums-karma"
36 MODULE_DESCRIPTION("Driver for Rio Karma");
37 MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>, Keith Bennett <keith@mcs.st-and.ac.uk>");
38 MODULE_LICENSE("GPL");
40 #define RIO_PREFIX "RIOP\x00"
41 #define RIO_PREFIX_LEN 5
42 #define RIO_SEND_LEN 40
43 #define RIO_RECV_LEN 0x200
45 #define RIO_ENTER_STORAGE 0x1
46 #define RIO_LEAVE_STORAGE 0x2
54 static int rio_karma_init(struct us_data
*us
);
58 * The table of devices
60 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
61 vendorName, productName, useProtocol, useTransport, \
62 initFunction, flags) \
63 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
64 .driver_info = (flags) }
66 static struct usb_device_id karma_usb_ids
[] = {
67 # include "unusual_karma.h"
68 { } /* Terminating entry */
70 MODULE_DEVICE_TABLE(usb
, karma_usb_ids
);
77 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
78 vendor_name, product_name, use_protocol, use_transport, \
79 init_function, Flags) \
81 .vendorName = vendor_name, \
82 .productName = product_name, \
83 .useProtocol = use_protocol, \
84 .useTransport = use_transport, \
85 .initFunction = init_function, \
88 static struct us_unusual_dev karma_unusual_dev_list
[] = {
89 # include "unusual_karma.h"
90 { } /* Terminating entry */
97 * Send commands to Rio Karma.
99 * For each command we send 40 bytes starting 'RIOP\0' followed by
100 * the command number and a sequence number, which the device will ack
101 * with a 512-byte packet with the high four bits set and everything
102 * else null. Then we send 'RIOP\x80' followed by a zero and the
103 * sequence number, until byte 5 in the response repeats the sequence
106 static int rio_karma_send_command(char cmd
, struct us_data
*us
)
109 unsigned long timeout
;
110 static unsigned char seq
= 1;
111 struct karma_data
*data
= (struct karma_data
*) us
->extra
;
113 usb_stor_dbg(us
, "sending command %04x\n", cmd
);
114 memset(us
->iobuf
, 0, RIO_SEND_LEN
);
115 memcpy(us
->iobuf
, RIO_PREFIX
, RIO_PREFIX_LEN
);
119 timeout
= jiffies
+ msecs_to_jiffies(6000);
121 result
= usb_stor_bulk_transfer_buf(us
, us
->send_bulk_pipe
,
122 us
->iobuf
, RIO_SEND_LEN
, NULL
);
123 if (result
!= USB_STOR_XFER_GOOD
)
126 result
= usb_stor_bulk_transfer_buf(us
, us
->recv_bulk_pipe
,
127 data
->recv
, RIO_RECV_LEN
, NULL
);
128 if (result
!= USB_STOR_XFER_GOOD
)
131 if (data
->recv
[5] == seq
)
134 if (time_after(jiffies
, timeout
))
146 usb_stor_dbg(us
, "sent command %04x\n", cmd
);
149 usb_stor_dbg(us
, "command %04x failed\n", cmd
);
150 return USB_STOR_TRANSPORT_FAILED
;
154 * Trap START_STOP and READ_10 to leave/re-enter storage mode.
155 * Everything else is propagated to the normal bulk layer.
157 static int rio_karma_transport(struct scsi_cmnd
*srb
, struct us_data
*us
)
160 struct karma_data
*data
= (struct karma_data
*) us
->extra
;
162 if (srb
->cmnd
[0] == READ_10
&& !data
->in_storage
) {
163 ret
= rio_karma_send_command(RIO_ENTER_STORAGE
, us
);
167 data
->in_storage
= 1;
168 return usb_stor_Bulk_transport(srb
, us
);
169 } else if (srb
->cmnd
[0] == START_STOP
) {
170 ret
= rio_karma_send_command(RIO_LEAVE_STORAGE
, us
);
174 data
->in_storage
= 0;
175 return rio_karma_send_command(RIO_RESET
, us
);
177 return usb_stor_Bulk_transport(srb
, us
);
180 static void rio_karma_destructor(void *extra
)
182 struct karma_data
*data
= (struct karma_data
*) extra
;
186 static int rio_karma_init(struct us_data
*us
)
189 struct karma_data
*data
= kzalloc(sizeof(struct karma_data
), GFP_NOIO
);
193 data
->recv
= kmalloc(RIO_RECV_LEN
, GFP_NOIO
);
200 us
->extra_destructor
= rio_karma_destructor
;
201 ret
= rio_karma_send_command(RIO_ENTER_STORAGE
, us
);
202 data
->in_storage
= (ret
== 0);
207 static struct scsi_host_template karma_host_template
;
209 static int karma_probe(struct usb_interface
*intf
,
210 const struct usb_device_id
*id
)
215 result
= usb_stor_probe1(&us
, intf
, id
,
216 (id
- karma_usb_ids
) + karma_unusual_dev_list
,
217 &karma_host_template
);
221 us
->transport_name
= "Rio Karma/Bulk";
222 us
->transport
= rio_karma_transport
;
223 us
->transport_reset
= usb_stor_Bulk_reset
;
225 result
= usb_stor_probe2(us
);
229 static struct usb_driver karma_driver
= {
231 .probe
= karma_probe
,
232 .disconnect
= usb_stor_disconnect
,
233 .suspend
= usb_stor_suspend
,
234 .resume
= usb_stor_resume
,
235 .reset_resume
= usb_stor_reset_resume
,
236 .pre_reset
= usb_stor_pre_reset
,
237 .post_reset
= usb_stor_post_reset
,
238 .id_table
= karma_usb_ids
,
243 module_usb_stor_driver(karma_driver
, karma_host_template
, DRV_NAME
);