1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/slab.h>
11
12#include <scsi/scsi.h>
13#include <scsi/scsi_cmnd.h>
14#include <scsi/scsi_device.h>
15
16#include "usb.h"
17#include "transport.h"
18#include "debug.h"
19#include "scsiglue.h"
20
21#define DRV_NAME "ums-karma"
22
23MODULE_DESCRIPTION("Driver for Rio Karma");
24MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>, Keith Bennett <keith@mcs.st-and.ac.uk>");
25MODULE_LICENSE("GPL");
26
27#define RIO_PREFIX "RIOP\x00"
28#define RIO_PREFIX_LEN 5
29#define RIO_SEND_LEN 40
30#define RIO_RECV_LEN 0x200
31
32#define RIO_ENTER_STORAGE 0x1
33#define RIO_LEAVE_STORAGE 0x2
34#define RIO_RESET 0xC
35
36struct karma_data {
37 int in_storage;
38 char *recv;
39};
40
41static int rio_karma_init(struct us_data *us);
42
43
44
45
46
47#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
48 vendorName, productName, useProtocol, useTransport, \
49 initFunction, flags) \
50{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
51 .driver_info = (flags) }
52
53static struct usb_device_id karma_usb_ids[] = {
54# include "unusual_karma.h"
55 { }
56};
57MODULE_DEVICE_TABLE(usb, karma_usb_ids);
58
59#undef UNUSUAL_DEV
60
61
62
63
64#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
65 vendor_name, product_name, use_protocol, use_transport, \
66 init_function, Flags) \
67{ \
68 .vendorName = vendor_name, \
69 .productName = product_name, \
70 .useProtocol = use_protocol, \
71 .useTransport = use_transport, \
72 .initFunction = init_function, \
73}
74
75static struct us_unusual_dev karma_unusual_dev_list[] = {
76# include "unusual_karma.h"
77 { }
78};
79
80#undef UNUSUAL_DEV
81
82
83
84
85
86
87
88
89
90
91
92
93static int rio_karma_send_command(char cmd, struct us_data *us)
94{
95 int result;
96 unsigned long timeout;
97 static unsigned char seq = 1;
98 struct karma_data *data = (struct karma_data *) us->extra;
99
100 usb_stor_dbg(us, "sending command %04x\n", cmd);
101 memset(us->iobuf, 0, RIO_SEND_LEN);
102 memcpy(us->iobuf, RIO_PREFIX, RIO_PREFIX_LEN);
103 us->iobuf[5] = cmd;
104 us->iobuf[6] = seq;
105
106 timeout = jiffies + msecs_to_jiffies(6000);
107 for (;;) {
108 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
109 us->iobuf, RIO_SEND_LEN, NULL);
110 if (result != USB_STOR_XFER_GOOD)
111 goto err;
112
113 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
114 data->recv, RIO_RECV_LEN, NULL);
115 if (result != USB_STOR_XFER_GOOD)
116 goto err;
117
118 if (data->recv[5] == seq)
119 break;
120
121 if (time_after(jiffies, timeout))
122 goto err;
123
124 us->iobuf[4] = 0x80;
125 us->iobuf[5] = 0;
126 msleep(50);
127 }
128
129 seq++;
130 if (seq == 0)
131 seq = 1;
132
133 usb_stor_dbg(us, "sent command %04x\n", cmd);
134 return 0;
135err:
136 usb_stor_dbg(us, "command %04x failed\n", cmd);
137 return USB_STOR_TRANSPORT_FAILED;
138}
139
140
141
142
143
144static int rio_karma_transport(struct scsi_cmnd *srb, struct us_data *us)
145{
146 int ret;
147 struct karma_data *data = (struct karma_data *) us->extra;
148
149 if (srb->cmnd[0] == READ_10 && !data->in_storage) {
150 ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
151 if (ret)
152 return ret;
153
154 data->in_storage = 1;
155 return usb_stor_Bulk_transport(srb, us);
156 } else if (srb->cmnd[0] == START_STOP) {
157 ret = rio_karma_send_command(RIO_LEAVE_STORAGE, us);
158 if (ret)
159 return ret;
160
161 data->in_storage = 0;
162 return rio_karma_send_command(RIO_RESET, us);
163 }
164 return usb_stor_Bulk_transport(srb, us);
165}
166
167static void rio_karma_destructor(void *extra)
168{
169 struct karma_data *data = (struct karma_data *) extra;
170 kfree(data->recv);
171}
172
173static int rio_karma_init(struct us_data *us)
174{
175 int ret = 0;
176 struct karma_data *data = kzalloc(sizeof(struct karma_data), GFP_NOIO);
177 if (!data)
178 goto out;
179
180 data->recv = kmalloc(RIO_RECV_LEN, GFP_NOIO);
181 if (!data->recv) {
182 kfree(data);
183 goto out;
184 }
185
186 us->extra = data;
187 us->extra_destructor = rio_karma_destructor;
188 ret = rio_karma_send_command(RIO_ENTER_STORAGE, us);
189 data->in_storage = (ret == 0);
190out:
191 return ret;
192}
193
194static struct scsi_host_template karma_host_template;
195
196static int karma_probe(struct usb_interface *intf,
197 const struct usb_device_id *id)
198{
199 struct us_data *us;
200 int result;
201
202 result = usb_stor_probe1(&us, intf, id,
203 (id - karma_usb_ids) + karma_unusual_dev_list,
204 &karma_host_template);
205 if (result)
206 return result;
207
208 us->transport_name = "Rio Karma/Bulk";
209 us->transport = rio_karma_transport;
210 us->transport_reset = usb_stor_Bulk_reset;
211
212 result = usb_stor_probe2(us);
213 return result;
214}
215
216static struct usb_driver karma_driver = {
217 .name = DRV_NAME,
218 .probe = karma_probe,
219 .disconnect = usb_stor_disconnect,
220 .suspend = usb_stor_suspend,
221 .resume = usb_stor_resume,
222 .reset_resume = usb_stor_reset_resume,
223 .pre_reset = usb_stor_pre_reset,
224 .post_reset = usb_stor_post_reset,
225 .id_table = karma_usb_ids,
226 .soft_unbind = 1,
227 .no_dynamic_id = 1,
228};
229
230module_usb_stor_driver(karma_driver, karma_host_template, DRV_NAME);
231