blob: 685f061e69b2971484a9546de5f3e32cc7b32801 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * The low performance USB storage driver (ub).
3 *
4 * Copyright (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
5 * Copyright (C) 2004 Pete Zaitcev (zaitcev@yahoo.com)
6 *
7 * This work is a part of Linux kernel, is derived from it,
8 * and is not licensed separately. See file COPYING for details.
9 *
10 * TODO (sorted by decreasing priority)
Pete Zaitcevf4800072005-05-01 16:05:40 -070011 * -- Kill first_open (Al Viro fixed the block layer now)
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * -- Do resets with usb_device_reset (needs a thread context, use khubd)
13 * -- set readonly flag for CDs, set removable flag for CF readers
14 * -- do inquiry and verify we got a disk and not a tape (for LUN mismatch)
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * -- special case some senses, e.g. 3a/0 -> no media present, reduce retries
16 * -- verify the 13 conditions and do bulk resets
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * -- kill last_pipe and simply do two-state clearing on both pipes
18 * -- verify protocol (bulk) from USB descriptors (maybe...)
19 * -- highmem and sg
20 * -- move top_sense and work_bcs into separate allocations (if they survive)
21 * for cache purists and esoteric architectures.
22 * -- prune comments, they are too volumnous
23 * -- Exterminate P3 printks
24 * -- Resove XXX's
25 * -- Redo "benh's retries", perhaps have spin-up code to handle them. V:D=?
26 */
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/usb.h>
30#include <linux/blkdev.h>
31#include <linux/devfs_fs_kernel.h>
32#include <linux/timer.h>
33#include <scsi/scsi.h>
34
35#define DRV_NAME "ub"
36#define DEVFS_NAME DRV_NAME
37
38#define UB_MAJOR 180
39
40/*
41 * Definitions which have to be scattered once we understand the layout better.
42 */
43
44/* Transport (despite PR in the name) */
45#define US_PR_BULK 0x50 /* bulk only */
46
47/* Protocol */
48#define US_SC_SCSI 0x06 /* Transparent */
49
50/*
Pete Zaitcevf4800072005-05-01 16:05:40 -070051 * This many LUNs per USB device.
52 * Every one of them takes a host, see UB_MAX_HOSTS.
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 */
Pete Zaitcev9f793d22005-06-06 13:54:59 -070054#define UB_MAX_LUNS 9
Pete Zaitcevf4800072005-05-01 16:05:40 -070055
56/*
57 */
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#define UB_MINORS_PER_MAJOR 8
60
61#define UB_MAX_CDB_SIZE 16 /* Corresponds to Bulk */
62
63#define UB_SENSE_SIZE 18
64
65/*
66 */
67
68/* command block wrapper */
69struct bulk_cb_wrap {
70 __le32 Signature; /* contains 'USBC' */
71 u32 Tag; /* unique per command id */
72 __le32 DataTransferLength; /* size of data */
73 u8 Flags; /* direction in bit 0 */
Pete Zaitcevf4800072005-05-01 16:05:40 -070074 u8 Lun; /* LUN */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 u8 Length; /* of of the CDB */
76 u8 CDB[UB_MAX_CDB_SIZE]; /* max command */
77};
78
79#define US_BULK_CB_WRAP_LEN 31
80#define US_BULK_CB_SIGN 0x43425355 /*spells out USBC */
81#define US_BULK_FLAG_IN 1
82#define US_BULK_FLAG_OUT 0
83
84/* command status wrapper */
85struct bulk_cs_wrap {
86 __le32 Signature; /* should = 'USBS' */
87 u32 Tag; /* same as original command */
88 __le32 Residue; /* amount not transferred */
89 u8 Status; /* see below */
90};
91
92#define US_BULK_CS_WRAP_LEN 13
93#define US_BULK_CS_SIGN 0x53425355 /* spells out 'USBS' */
94/* This is for Olympus Camedia digital cameras */
95#define US_BULK_CS_OLYMPUS_SIGN 0x55425355 /* spells out 'USBU' */
96#define US_BULK_STAT_OK 0
97#define US_BULK_STAT_FAIL 1
98#define US_BULK_STAT_PHASE 2
99
100/* bulk-only class specific requests */
101#define US_BULK_RESET_REQUEST 0xff
102#define US_BULK_GET_MAX_LUN 0xfe
103
104/*
105 */
106struct ub_dev;
107
108#define UB_MAX_REQ_SG 1
109#define UB_MAX_SECTORS 64
110
111/*
112 * A second is more than enough for a 32K transfer (UB_MAX_SECTORS)
113 * even if a webcam hogs the bus, but some devices need time to spin up.
114 */
115#define UB_URB_TIMEOUT (HZ*2)
116#define UB_DATA_TIMEOUT (HZ*5) /* ZIP does spin-ups in the data phase */
117#define UB_STAT_TIMEOUT (HZ*5) /* Same spinups and eject for a dataless cmd. */
118#define UB_CTRL_TIMEOUT (HZ/2) /* 500ms ought to be enough to clear a stall */
119
120/*
121 * An instance of a SCSI command in transit.
122 */
123#define UB_DIR_NONE 0
124#define UB_DIR_READ 1
125#define UB_DIR_ILLEGAL2 2
126#define UB_DIR_WRITE 3
127
128#define UB_DIR_CHAR(c) (((c)==UB_DIR_WRITE)? 'w': \
129 (((c)==UB_DIR_READ)? 'r': 'n'))
130
131enum ub_scsi_cmd_state {
132 UB_CMDST_INIT, /* Initial state */
133 UB_CMDST_CMD, /* Command submitted */
134 UB_CMDST_DATA, /* Data phase */
135 UB_CMDST_CLR2STS, /* Clearing before requesting status */
136 UB_CMDST_STAT, /* Status phase */
137 UB_CMDST_CLEAR, /* Clearing a stall (halt, actually) */
138 UB_CMDST_SENSE, /* Sending Request Sense */
139 UB_CMDST_DONE /* Final state */
140};
141
142static char *ub_scsi_cmd_stname[] = {
143 ". ",
144 "Cmd",
145 "dat",
146 "c2s",
147 "sts",
148 "clr",
149 "Sen",
150 "fin"
151};
152
153struct ub_scsi_cmd {
154 unsigned char cdb[UB_MAX_CDB_SIZE];
155 unsigned char cdb_len;
156
157 unsigned char dir; /* 0 - none, 1 - read, 3 - write. */
158 unsigned char trace_index;
159 enum ub_scsi_cmd_state state;
160 unsigned int tag;
161 struct ub_scsi_cmd *next;
162
163 int error; /* Return code - valid upon done */
164 unsigned int act_len; /* Return size */
165 unsigned char key, asc, ascq; /* May be valid if error==-EIO */
166
167 int stat_count; /* Retries getting status. */
168
169 /*
170 * We do not support transfers from highmem pages
171 * because the underlying USB framework does not do what we need.
172 */
173 char *data; /* Requested buffer */
174 unsigned int len; /* Requested length */
175 // struct scatterlist sgv[UB_MAX_REQ_SG];
176
Pete Zaitcevf4800072005-05-01 16:05:40 -0700177 struct ub_lun *lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 void (*done)(struct ub_dev *, struct ub_scsi_cmd *);
179 void *back;
180};
181
182/*
183 */
184struct ub_capacity {
185 unsigned long nsec; /* Linux size - 512 byte sectors */
186 unsigned int bsize; /* Linux hardsect_size */
187 unsigned int bshift; /* Shift between 512 and hard sects */
188};
189
190/*
191 * The SCSI command tracing structure.
192 */
193
194#define SCMD_ST_HIST_SZ 8
195#define SCMD_TRACE_SZ 63 /* Less than 4KB of 61-byte lines */
196
197struct ub_scsi_cmd_trace {
198 int hcur;
199 unsigned int tag;
200 unsigned int req_size, act_size;
201 unsigned char op;
202 unsigned char dir;
203 unsigned char key, asc, ascq;
204 char st_hst[SCMD_ST_HIST_SZ];
205};
206
207struct ub_scsi_trace {
208 int cur;
209 struct ub_scsi_cmd_trace vec[SCMD_TRACE_SZ];
210};
211
212/*
213 * This is a direct take-off from linux/include/completion.h
214 * The difference is that I do not wait on this thing, just poll.
215 * When I want to wait (ub_probe), I just use the stock completion.
216 *
217 * Note that INIT_COMPLETION takes no lock. It is correct. But why
218 * in the bloody hell that thing takes struct instead of pointer to struct
219 * is quite beyond me. I just copied it from the stock completion.
220 */
221struct ub_completion {
222 unsigned int done;
223 spinlock_t lock;
224};
225
226static inline void ub_init_completion(struct ub_completion *x)
227{
228 x->done = 0;
229 spin_lock_init(&x->lock);
230}
231
232#define UB_INIT_COMPLETION(x) ((x).done = 0)
233
234static void ub_complete(struct ub_completion *x)
235{
236 unsigned long flags;
237
238 spin_lock_irqsave(&x->lock, flags);
239 x->done++;
240 spin_unlock_irqrestore(&x->lock, flags);
241}
242
243static int ub_is_completed(struct ub_completion *x)
244{
245 unsigned long flags;
246 int ret;
247
248 spin_lock_irqsave(&x->lock, flags);
249 ret = x->done;
250 spin_unlock_irqrestore(&x->lock, flags);
251 return ret;
252}
253
254/*
255 */
256struct ub_scsi_cmd_queue {
257 int qlen, qmax;
258 struct ub_scsi_cmd *head, *tail;
259};
260
261/*
Pete Zaitcevf4800072005-05-01 16:05:40 -0700262 * The block device instance (one per LUN).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 */
Pete Zaitcevf4800072005-05-01 16:05:40 -0700264struct ub_lun {
265 struct ub_dev *udev;
266 struct list_head link;
267 struct gendisk *disk;
268 int id; /* Host index */
269 int num; /* LUN number */
270 char name[16];
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 int changed; /* Media was changed */
273 int removable;
274 int readonly;
275 int first_open; /* Kludge. See ub_bd_open. */
Pete Zaitcevf4800072005-05-01 16:05:40 -0700276
277 /* Use Ingo's mempool if or when we have more than one command. */
278 /*
279 * Currently we never need more than one command for the whole device.
280 * However, giving every LUN a command is a cheap and automatic way
281 * to enforce fairness between them.
282 */
283 int cmda[1];
284 struct ub_scsi_cmd cmdv[1];
285
286 struct ub_capacity capacity;
287};
288
289/*
290 * The USB device instance.
291 */
292struct ub_dev {
293 spinlock_t lock;
294 atomic_t poison; /* The USB device is disconnected */
295 int openc; /* protected by ub_lock! */
296 /* kref is too implicit for our taste */
297 unsigned int tagcnt;
298 char name[12];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 struct usb_device *dev;
300 struct usb_interface *intf;
301
Pete Zaitcevf4800072005-05-01 16:05:40 -0700302 struct list_head luns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 unsigned int send_bulk_pipe; /* cached pipe values */
305 unsigned int recv_bulk_pipe;
306 unsigned int send_ctrl_pipe;
307 unsigned int recv_ctrl_pipe;
308
309 struct tasklet_struct tasklet;
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 struct ub_scsi_cmd_queue cmd_queue;
312 struct ub_scsi_cmd top_rqs_cmd; /* REQUEST SENSE */
313 unsigned char top_sense[UB_SENSE_SIZE];
314
315 struct ub_completion work_done;
316 struct urb work_urb;
317 struct timer_list work_timer;
318 int last_pipe; /* What might need clearing */
319 struct bulk_cb_wrap work_bcb;
320 struct bulk_cs_wrap work_bcs;
321 struct usb_ctrlrequest work_cr;
322
323 struct ub_scsi_trace tr;
324};
325
326/*
327 */
328static void ub_cleanup(struct ub_dev *sc);
Pete Zaitcevf4800072005-05-01 16:05:40 -0700329static int ub_bd_rq_fn_1(struct ub_lun *lun, struct request *rq);
330static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
331 struct ub_scsi_cmd *cmd, struct request *rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
333 struct request *rq);
334static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
335static void ub_end_rq(struct request *rq, int uptodate);
336static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
337static void ub_urb_complete(struct urb *urb, struct pt_regs *pt);
338static void ub_scsi_action(unsigned long _dev);
339static void ub_scsi_dispatch(struct ub_dev *sc);
340static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
341static void ub_state_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd, int rc);
342static void __ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
343static void ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
344static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
345static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
346 int stalled_pipe);
347static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd);
Pete Zaitcevf4800072005-05-01 16:05:40 -0700348static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun);
349static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
350 struct ub_capacity *ret);
351static int ub_probe_lun(struct ub_dev *sc, int lnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353/*
354 */
355static struct usb_device_id ub_usb_ids[] = {
356 // { USB_DEVICE_VER(0x0781, 0x0002, 0x0009, 0x0009) }, /* SDDR-31 */
357 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) },
358 { }
359};
360
361MODULE_DEVICE_TABLE(usb, ub_usb_ids);
362
363/*
364 * Find me a way to identify "next free minor" for add_disk(),
365 * and the array disappears the next day. However, the number of
366 * hosts has something to do with the naming and /proc/partitions.
367 * This has to be thought out in detail before changing.
368 * If UB_MAX_HOST was 1000, we'd use a bitmap. Or a better data structure.
369 */
370#define UB_MAX_HOSTS 26
371static char ub_hostv[UB_MAX_HOSTS];
Pete Zaitcevf4800072005-05-01 16:05:40 -0700372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373static DEFINE_SPINLOCK(ub_lock); /* Locks globals and ->openc */
374
375/*
376 * The SCSI command tracing procedures.
377 */
378
379static void ub_cmdtr_new(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
380{
381 int n;
382 struct ub_scsi_cmd_trace *t;
383
384 if ((n = sc->tr.cur + 1) == SCMD_TRACE_SZ) n = 0;
385 t = &sc->tr.vec[n];
386
387 memset(t, 0, sizeof(struct ub_scsi_cmd_trace));
388 t->tag = cmd->tag;
389 t->op = cmd->cdb[0];
390 t->dir = cmd->dir;
391 t->req_size = cmd->len;
392 t->st_hst[0] = cmd->state;
393
394 sc->tr.cur = n;
395 cmd->trace_index = n;
396}
397
398static void ub_cmdtr_state(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
399{
400 int n;
401 struct ub_scsi_cmd_trace *t;
402
403 t = &sc->tr.vec[cmd->trace_index];
404 if (t->tag == cmd->tag) {
405 if ((n = t->hcur + 1) == SCMD_ST_HIST_SZ) n = 0;
406 t->st_hst[n] = cmd->state;
407 t->hcur = n;
408 }
409}
410
411static void ub_cmdtr_act_len(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
412{
413 struct ub_scsi_cmd_trace *t;
414
415 t = &sc->tr.vec[cmd->trace_index];
416 if (t->tag == cmd->tag)
417 t->act_size = cmd->act_len;
418}
419
420static void ub_cmdtr_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
421 unsigned char *sense)
422{
423 struct ub_scsi_cmd_trace *t;
424
425 t = &sc->tr.vec[cmd->trace_index];
426 if (t->tag == cmd->tag) {
427 t->key = sense[2] & 0x0F;
428 t->asc = sense[12];
429 t->ascq = sense[13];
430 }
431}
432
Yani Ioannou74880c02005-05-17 06:41:12 -0400433static ssize_t ub_diag_show(struct device *dev, struct device_attribute *attr, char *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 struct usb_interface *intf;
436 struct ub_dev *sc;
Pete Zaitcevf4800072005-05-01 16:05:40 -0700437 struct list_head *p;
438 struct ub_lun *lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 int cnt;
440 unsigned long flags;
441 int nc, nh;
442 int i, j;
443 struct ub_scsi_cmd_trace *t;
444
445 intf = to_usb_interface(dev);
446 sc = usb_get_intfdata(intf);
447 if (sc == NULL)
448 return 0;
449
450 cnt = 0;
451 spin_lock_irqsave(&sc->lock, flags);
452
453 cnt += sprintf(page + cnt,
Pete Zaitcevf4800072005-05-01 16:05:40 -0700454 "qlen %d qmax %d\n",
455 sc->cmd_queue.qlen, sc->cmd_queue.qmax);
456
457 list_for_each (p, &sc->luns) {
458 lun = list_entry(p, struct ub_lun, link);
459 cnt += sprintf(page + cnt,
460 "lun %u changed %d removable %d readonly %d\n",
461 lun->num, lun->changed, lun->removable, lun->readonly);
462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 if ((nc = sc->tr.cur + 1) == SCMD_TRACE_SZ) nc = 0;
465 for (j = 0; j < SCMD_TRACE_SZ; j++) {
466 t = &sc->tr.vec[nc];
467
468 cnt += sprintf(page + cnt, "%08x %02x", t->tag, t->op);
469 if (t->op == REQUEST_SENSE) {
470 cnt += sprintf(page + cnt, " [sense %x %02x %02x]",
471 t->key, t->asc, t->ascq);
472 } else {
473 cnt += sprintf(page + cnt, " %c", UB_DIR_CHAR(t->dir));
474 cnt += sprintf(page + cnt, " [%5d %5d]",
475 t->req_size, t->act_size);
476 }
477 if ((nh = t->hcur + 1) == SCMD_ST_HIST_SZ) nh = 0;
478 for (i = 0; i < SCMD_ST_HIST_SZ; i++) {
479 cnt += sprintf(page + cnt, " %s",
480 ub_scsi_cmd_stname[(int)t->st_hst[nh]]);
481 if (++nh == SCMD_ST_HIST_SZ) nh = 0;
482 }
483 cnt += sprintf(page + cnt, "\n");
484
485 if (++nc == SCMD_TRACE_SZ) nc = 0;
486 }
487
488 spin_unlock_irqrestore(&sc->lock, flags);
489 return cnt;
490}
491
492static DEVICE_ATTR(diag, S_IRUGO, ub_diag_show, NULL); /* N.B. World readable */
493
494/*
495 * The id allocator.
496 *
497 * This also stores the host for indexing by minor, which is somewhat dirty.
498 */
499static int ub_id_get(void)
500{
501 unsigned long flags;
502 int i;
503
504 spin_lock_irqsave(&ub_lock, flags);
505 for (i = 0; i < UB_MAX_HOSTS; i++) {
506 if (ub_hostv[i] == 0) {
507 ub_hostv[i] = 1;
508 spin_unlock_irqrestore(&ub_lock, flags);
509 return i;
510 }
511 }
512 spin_unlock_irqrestore(&ub_lock, flags);
513 return -1;
514}
515
516static void ub_id_put(int id)
517{
518 unsigned long flags;
519
520 if (id < 0 || id >= UB_MAX_HOSTS) {
521 printk(KERN_ERR DRV_NAME ": bad host ID %d\n", id);
522 return;
523 }
524
525 spin_lock_irqsave(&ub_lock, flags);
526 if (ub_hostv[id] == 0) {
527 spin_unlock_irqrestore(&ub_lock, flags);
528 printk(KERN_ERR DRV_NAME ": freeing free host ID %d\n", id);
529 return;
530 }
531 ub_hostv[id] = 0;
532 spin_unlock_irqrestore(&ub_lock, flags);
533}
534
535/*
536 * Downcount for deallocation. This rides on two assumptions:
537 * - once something is poisoned, its refcount cannot grow
538 * - opens cannot happen at this time (del_gendisk was done)
539 * If the above is true, we can drop the lock, which we need for
540 * blk_cleanup_queue(): the silly thing may attempt to sleep.
541 * [Actually, it never needs to sleep for us, but it calls might_sleep()]
542 */
543static void ub_put(struct ub_dev *sc)
544{
545 unsigned long flags;
546
547 spin_lock_irqsave(&ub_lock, flags);
548 --sc->openc;
549 if (sc->openc == 0 && atomic_read(&sc->poison)) {
550 spin_unlock_irqrestore(&ub_lock, flags);
551 ub_cleanup(sc);
552 } else {
553 spin_unlock_irqrestore(&ub_lock, flags);
554 }
555}
556
557/*
558 * Final cleanup and deallocation.
559 */
560static void ub_cleanup(struct ub_dev *sc)
561{
Pete Zaitcevf4800072005-05-01 16:05:40 -0700562 struct list_head *p;
563 struct ub_lun *lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 request_queue_t *q;
565
Pete Zaitcevf4800072005-05-01 16:05:40 -0700566 while (!list_empty(&sc->luns)) {
567 p = sc->luns.next;
568 lun = list_entry(p, struct ub_lun, link);
569 list_del(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Pete Zaitcevf4800072005-05-01 16:05:40 -0700571 /* I don't think queue can be NULL. But... Stolen from sx8.c */
572 if ((q = lun->disk->queue) != NULL)
573 blk_cleanup_queue(q);
574 /*
575 * If we zero disk->private_data BEFORE put_disk, we have
576 * to check for NULL all over the place in open, release,
577 * check_media and revalidate, because the block level
578 * semaphore is well inside the put_disk.
579 * But we cannot zero after the call, because *disk is gone.
580 * The sd.c is blatantly racy in this area.
581 */
582 /* disk->private_data = NULL; */
583 put_disk(lun->disk);
584 lun->disk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Pete Zaitcevf4800072005-05-01 16:05:40 -0700586 ub_id_put(lun->id);
587 kfree(lun);
588 }
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 kfree(sc);
591}
592
593/*
594 * The "command allocator".
595 */
Pete Zaitcevf4800072005-05-01 16:05:40 -0700596static struct ub_scsi_cmd *ub_get_cmd(struct ub_lun *lun)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 struct ub_scsi_cmd *ret;
599
Pete Zaitcevf4800072005-05-01 16:05:40 -0700600 if (lun->cmda[0])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return NULL;
Pete Zaitcevf4800072005-05-01 16:05:40 -0700602 ret = &lun->cmdv[0];
603 lun->cmda[0] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 return ret;
605}
606
Pete Zaitcevf4800072005-05-01 16:05:40 -0700607static void ub_put_cmd(struct ub_lun *lun, struct ub_scsi_cmd *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Pete Zaitcevf4800072005-05-01 16:05:40 -0700609 if (cmd != &lun->cmdv[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 printk(KERN_WARNING "%s: releasing a foreign cmd %p\n",
Pete Zaitcevf4800072005-05-01 16:05:40 -0700611 lun->name, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 return;
613 }
Pete Zaitcevf4800072005-05-01 16:05:40 -0700614 if (!lun->cmda[0]) {
615 printk(KERN_WARNING "%s: releasing a free cmd\n", lun->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 return;
617 }
Pete Zaitcevf4800072005-05-01 16:05:40 -0700618 lun->cmda[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
620
621/*
622 * The command queue.
623 */
624static void ub_cmdq_add(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
625{
626 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
627
628 if (t->qlen++ == 0) {
629 t->head = cmd;
630 t->tail = cmd;
631 } else {
632 t->tail->next = cmd;
633 t->tail = cmd;
634 }
635
636 if (t->qlen > t->qmax)
637 t->qmax = t->qlen;
638}
639
640static void ub_cmdq_insert(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
641{
642 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
643
644 if (t->qlen++ == 0) {
645 t->head = cmd;
646 t->tail = cmd;
647 } else {
648 cmd->next = t->head;
649 t->head = cmd;
650 }
651
652 if (t->qlen > t->qmax)
653 t->qmax = t->qlen;
654}
655
656static struct ub_scsi_cmd *ub_cmdq_pop(struct ub_dev *sc)
657{
658 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
659 struct ub_scsi_cmd *cmd;
660
661 if (t->qlen == 0)
662 return NULL;
663 if (--t->qlen == 0)
664 t->tail = NULL;
665 cmd = t->head;
666 t->head = cmd->next;
667 cmd->next = NULL;
668 return cmd;
669}
670
671#define ub_cmdq_peek(sc) ((sc)->cmd_queue.head)
672
673/*
674 * The request function is our main entry point
675 */
676
677static void ub_bd_rq_fn(request_queue_t *q)
678{
Pete Zaitcevf4800072005-05-01 16:05:40 -0700679 struct ub_lun *lun = q->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 struct request *rq;
681
682 while ((rq = elv_next_request(q)) != NULL) {
Pete Zaitcevf4800072005-05-01 16:05:40 -0700683 if (ub_bd_rq_fn_1(lun, rq) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 blk_stop_queue(q);
685 break;
686 }
687 }
688}
689
Pete Zaitcevf4800072005-05-01 16:05:40 -0700690static int ub_bd_rq_fn_1(struct ub_lun *lun, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Pete Zaitcevf4800072005-05-01 16:05:40 -0700692 struct ub_dev *sc = lun->udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 struct ub_scsi_cmd *cmd;
694 int rc;
695
Pete Zaitcevf4800072005-05-01 16:05:40 -0700696 if (atomic_read(&sc->poison) || lun->changed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 blkdev_dequeue_request(rq);
698 ub_end_rq(rq, 0);
699 return 0;
700 }
701
Pete Zaitcevf4800072005-05-01 16:05:40 -0700702 if ((cmd = ub_get_cmd(lun)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 return -1;
704 memset(cmd, 0, sizeof(struct ub_scsi_cmd));
705
706 blkdev_dequeue_request(rq);
707
708 if (blk_pc_request(rq)) {
709 rc = ub_cmd_build_packet(sc, cmd, rq);
710 } else {
Pete Zaitcevf4800072005-05-01 16:05:40 -0700711 rc = ub_cmd_build_block(sc, lun, cmd, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 }
713 if (rc != 0) {
Pete Zaitcevf4800072005-05-01 16:05:40 -0700714 ub_put_cmd(lun, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 ub_end_rq(rq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 return 0;
717 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 cmd->state = UB_CMDST_INIT;
Pete Zaitcevf4800072005-05-01 16:05:40 -0700719 cmd->lun = lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 cmd->done = ub_rw_cmd_done;
721 cmd->back = rq;
722
723 cmd->tag = sc->tagcnt++;
724 if ((rc = ub_submit_scsi(sc, cmd)) != 0) {
Pete Zaitcevf4800072005-05-01 16:05:40 -0700725 ub_put_cmd(lun, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 ub_end_rq(rq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return 0;
728 }
729
730 return 0;
731}
732
Pete Zaitcevf4800072005-05-01 16:05:40 -0700733static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
734 struct ub_scsi_cmd *cmd, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735{
736 int ub_dir;
737#if 0 /* We use rq->buffer for now */
738 struct scatterlist *sg;
739 int n_elem;
740#endif
741 unsigned int block, nblks;
742
743 if (rq_data_dir(rq) == WRITE)
744 ub_dir = UB_DIR_WRITE;
745 else
746 ub_dir = UB_DIR_READ;
747
748 /*
749 * get scatterlist from block layer
750 */
751#if 0 /* We use rq->buffer for now */
752 sg = &cmd->sgv[0];
753 n_elem = blk_rq_map_sg(q, rq, sg);
754 if (n_elem <= 0) {
Pete Zaitcevf4800072005-05-01 16:05:40 -0700755 ub_put_cmd(lun, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 ub_end_rq(rq, 0);
757 blk_start_queue(q);
758 return 0; /* request with no s/g entries? */
759 }
760
761 if (n_elem != 1) { /* Paranoia */
762 printk(KERN_WARNING "%s: request with %d segments\n",
763 sc->name, n_elem);
Pete Zaitcevf4800072005-05-01 16:05:40 -0700764 ub_put_cmd(lun, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 ub_end_rq(rq, 0);
766 blk_start_queue(q);
767 return 0;
768 }
769#endif
770
771 /*
772 * XXX Unfortunately, this check does not work. It is quite possible
773 * to get bogus non-null rq->buffer if you allow sg by mistake.
774 */
775 if (rq->buffer == NULL) {
776 /*
777 * This must not happen if we set the queue right.
778 * The block level must create bounce buffers for us.
779 */
780 static int do_print = 1;
781 if (do_print) {
782 printk(KERN_WARNING "%s: unmapped block request"
783 " flags 0x%lx sectors %lu\n",
784 sc->name, rq->flags, rq->nr_sectors);
785 do_print = 0;
786 }
787 return -1;
788 }
789
790 /*
791 * build the command
792 *
793 * The call to blk_queue_hardsect_size() guarantees that request
794 * is aligned, but it is given in terms of 512 byte units, always.
795 */
Pete Zaitcevf4800072005-05-01 16:05:40 -0700796 block = rq->sector >> lun->capacity.bshift;
797 nblks = rq->nr_sectors >> lun->capacity.bshift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799 cmd->cdb[0] = (ub_dir == UB_DIR_READ)? READ_10: WRITE_10;
800 /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */
801 cmd->cdb[2] = block >> 24;
802 cmd->cdb[3] = block >> 16;
803 cmd->cdb[4] = block >> 8;
804 cmd->cdb[5] = block;
805 cmd->cdb[7] = nblks >> 8;
806 cmd->cdb[8] = nblks;
807 cmd->cdb_len = 10;
808
809 cmd->dir = ub_dir;
810 cmd->data = rq->buffer;
811 cmd->len = rq->nr_sectors * 512;
812
813 return 0;
814}
815
816static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
817 struct request *rq)
818{
819
820 if (rq->data_len != 0 && rq->data == NULL) {
821 static int do_print = 1;
822 if (do_print) {
823 printk(KERN_WARNING "%s: unmapped packet request"
824 " flags 0x%lx length %d\n",
825 sc->name, rq->flags, rq->data_len);
826 do_print = 0;
827 }
828 return -1;
829 }
830
831 memcpy(&cmd->cdb, rq->cmd, rq->cmd_len);
832 cmd->cdb_len = rq->cmd_len;
833
834 if (rq->data_len == 0) {
835 cmd->dir = UB_DIR_NONE;
836 } else {
837 if (rq_data_dir(rq) == WRITE)
838 cmd->dir = UB_DIR_WRITE;
839 else
840 cmd->dir = UB_DIR_READ;
841 }
842 cmd->data = rq->data;
843 cmd->len = rq->data_len;
844
845 return 0;
846}
847
848static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
849{
850 struct request *rq = cmd->back;
Pete Zaitcevf4800072005-05-01 16:05:40 -0700851 struct ub_lun *lun = cmd->lun;
852 struct gendisk *disk = lun->disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 request_queue_t *q = disk->queue;
854 int uptodate;
855
856 if (blk_pc_request(rq)) {
857 /* UB_SENSE_SIZE is smaller than SCSI_SENSE_BUFFERSIZE */
858 memcpy(rq->sense, sc->top_sense, UB_SENSE_SIZE);
859 rq->sense_len = UB_SENSE_SIZE;
860 }
861
862 if (cmd->error == 0)
863 uptodate = 1;
864 else
865 uptodate = 0;
866
Pete Zaitcevf4800072005-05-01 16:05:40 -0700867 ub_put_cmd(lun, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 ub_end_rq(rq, uptodate);
869 blk_start_queue(q);
870}
871
872static void ub_end_rq(struct request *rq, int uptodate)
873{
874 int rc;
875
876 rc = end_that_request_first(rq, uptodate, rq->hard_nr_sectors);
877 // assert(rc == 0);
878 end_that_request_last(rq);
879}
880
881/*
882 * Submit a regular SCSI operation (not an auto-sense).
883 *
884 * The Iron Law of Good Submit Routine is:
885 * Zero return - callback is done, Nonzero return - callback is not done.
886 * No exceptions.
887 *
888 * Host is assumed locked.
889 *
890 * XXX We only support Bulk for the moment.
891 */
892static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
893{
894
895 if (cmd->state != UB_CMDST_INIT ||
896 (cmd->dir != UB_DIR_NONE && cmd->len == 0)) {
897 return -EINVAL;
898 }
899
900 ub_cmdq_add(sc, cmd);
901 /*
902 * We can call ub_scsi_dispatch(sc) right away here, but it's a little
903 * safer to jump to a tasklet, in case upper layers do something silly.
904 */
905 tasklet_schedule(&sc->tasklet);
906 return 0;
907}
908
909/*
910 * Submit the first URB for the queued command.
911 * This function does not deal with queueing in any way.
912 */
913static int ub_scsi_cmd_start(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
914{
915 struct bulk_cb_wrap *bcb;
916 int rc;
917
918 bcb = &sc->work_bcb;
919
920 /*
921 * ``If the allocation length is eighteen or greater, and a device
922 * server returns less than eithteen bytes of data, the application
923 * client should assume that the bytes not transferred would have been
924 * zeroes had the device server returned those bytes.''
925 *
926 * We zero sense for all commands so that when a packet request
927 * fails it does not return a stale sense.
928 */
929 memset(&sc->top_sense, 0, UB_SENSE_SIZE);
930
931 /* set up the command wrapper */
932 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
933 bcb->Tag = cmd->tag; /* Endianness is not important */
934 bcb->DataTransferLength = cpu_to_le32(cmd->len);
935 bcb->Flags = (cmd->dir == UB_DIR_READ) ? 0x80 : 0;
Pete Zaitcevf4800072005-05-01 16:05:40 -0700936 bcb->Lun = (cmd->lun != NULL) ? cmd->lun->num : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 bcb->Length = cmd->cdb_len;
938
939 /* copy the command payload */
940 memcpy(bcb->CDB, cmd->cdb, UB_MAX_CDB_SIZE);
941
942 UB_INIT_COMPLETION(sc->work_done);
943
944 sc->last_pipe = sc->send_bulk_pipe;
945 usb_fill_bulk_urb(&sc->work_urb, sc->dev, sc->send_bulk_pipe,
946 bcb, US_BULK_CB_WRAP_LEN, ub_urb_complete, sc);
947 sc->work_urb.transfer_flags = URB_ASYNC_UNLINK;
948
949 /* Fill what we shouldn't be filling, because usb-storage did so. */
950 sc->work_urb.actual_length = 0;
951 sc->work_urb.error_count = 0;
952 sc->work_urb.status = 0;
953
954 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
955 /* XXX Clear stalls */
956 printk("ub: cmd #%d start failed (%d)\n", cmd->tag, rc); /* P3 */
957 ub_complete(&sc->work_done);
958 return rc;
959 }
960
961 sc->work_timer.expires = jiffies + UB_URB_TIMEOUT;
962 add_timer(&sc->work_timer);
963
964 cmd->state = UB_CMDST_CMD;
965 ub_cmdtr_state(sc, cmd);
966 return 0;
967}
968
969/*
970 * Timeout handler.
971 */
972static void ub_urb_timeout(unsigned long arg)
973{
974 struct ub_dev *sc = (struct ub_dev *) arg;
975 unsigned long flags;
976
977 spin_lock_irqsave(&sc->lock, flags);
978 usb_unlink_urb(&sc->work_urb);
979 spin_unlock_irqrestore(&sc->lock, flags);
980}
981
982/*
983 * Completion routine for the work URB.
984 *
985 * This can be called directly from usb_submit_urb (while we have
986 * the sc->lock taken) and from an interrupt (while we do NOT have
987 * the sc->lock taken). Therefore, bounce this off to a tasklet.
988 */
989static void ub_urb_complete(struct urb *urb, struct pt_regs *pt)
990{
991 struct ub_dev *sc = urb->context;
992
993 ub_complete(&sc->work_done);
994 tasklet_schedule(&sc->tasklet);
995}
996
997static void ub_scsi_action(unsigned long _dev)
998{
999 struct ub_dev *sc = (struct ub_dev *) _dev;
1000 unsigned long flags;
1001
1002 spin_lock_irqsave(&sc->lock, flags);
1003 del_timer(&sc->work_timer);
1004 ub_scsi_dispatch(sc);
1005 spin_unlock_irqrestore(&sc->lock, flags);
1006}
1007
1008static void ub_scsi_dispatch(struct ub_dev *sc)
1009{
1010 struct ub_scsi_cmd *cmd;
1011 int rc;
1012
1013 while ((cmd = ub_cmdq_peek(sc)) != NULL) {
1014 if (cmd->state == UB_CMDST_DONE) {
1015 ub_cmdq_pop(sc);
1016 (*cmd->done)(sc, cmd);
1017 } else if (cmd->state == UB_CMDST_INIT) {
1018 ub_cmdtr_new(sc, cmd);
1019 if ((rc = ub_scsi_cmd_start(sc, cmd)) == 0)
1020 break;
1021 cmd->error = rc;
1022 cmd->state = UB_CMDST_DONE;
1023 ub_cmdtr_state(sc, cmd);
1024 } else {
1025 if (!ub_is_completed(&sc->work_done))
1026 break;
1027 ub_scsi_urb_compl(sc, cmd);
1028 }
1029 }
1030}
1031
1032static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1033{
1034 struct urb *urb = &sc->work_urb;
1035 struct bulk_cs_wrap *bcs;
1036 int pipe;
1037 int rc;
1038
1039 if (atomic_read(&sc->poison)) {
1040 /* A little too simplistic, I feel... */
1041 goto Bad_End;
1042 }
1043
1044 if (cmd->state == UB_CMDST_CLEAR) {
1045 if (urb->status == -EPIPE) {
1046 /*
1047 * STALL while clearning STALL.
1048 * The control pipe clears itself - nothing to do.
1049 * XXX Might try to reset the device here and retry.
1050 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001051 printk(KERN_NOTICE "%s: stall on control pipe\n",
1052 sc->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 goto Bad_End;
1054 }
1055
1056 /*
1057 * We ignore the result for the halt clear.
1058 */
1059
1060 /* reset the endpoint toggle */
1061 usb_settoggle(sc->dev, usb_pipeendpoint(sc->last_pipe),
1062 usb_pipeout(sc->last_pipe), 0);
1063
1064 ub_state_sense(sc, cmd);
1065
1066 } else if (cmd->state == UB_CMDST_CLR2STS) {
1067 if (urb->status == -EPIPE) {
1068 /*
1069 * STALL while clearning STALL.
1070 * The control pipe clears itself - nothing to do.
1071 * XXX Might try to reset the device here and retry.
1072 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001073 printk(KERN_NOTICE "%s: stall on control pipe\n",
1074 sc->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 goto Bad_End;
1076 }
1077
1078 /*
1079 * We ignore the result for the halt clear.
1080 */
1081
1082 /* reset the endpoint toggle */
1083 usb_settoggle(sc->dev, usb_pipeendpoint(sc->last_pipe),
1084 usb_pipeout(sc->last_pipe), 0);
1085
1086 ub_state_stat(sc, cmd);
1087
1088 } else if (cmd->state == UB_CMDST_CMD) {
1089 if (urb->status == -EPIPE) {
1090 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1091 if (rc != 0) {
1092 printk(KERN_NOTICE "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001093 "unable to submit clear (%d)\n",
1094 sc->name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 /*
1096 * This is typically ENOMEM or some other such shit.
1097 * Retrying is pointless. Just do Bad End on it...
1098 */
1099 goto Bad_End;
1100 }
1101 cmd->state = UB_CMDST_CLEAR;
1102 ub_cmdtr_state(sc, cmd);
1103 return;
1104 }
1105 if (urb->status != 0) {
1106 printk("ub: cmd #%d cmd status (%d)\n", cmd->tag, urb->status); /* P3 */
1107 goto Bad_End;
1108 }
1109 if (urb->actual_length != US_BULK_CB_WRAP_LEN) {
1110 printk("ub: cmd #%d xferred %d\n", cmd->tag, urb->actual_length); /* P3 */
1111 /* XXX Must do reset here to unconfuse the device */
1112 goto Bad_End;
1113 }
1114
1115 if (cmd->dir == UB_DIR_NONE) {
1116 ub_state_stat(sc, cmd);
1117 return;
1118 }
1119
1120 UB_INIT_COMPLETION(sc->work_done);
1121
1122 if (cmd->dir == UB_DIR_READ)
1123 pipe = sc->recv_bulk_pipe;
1124 else
1125 pipe = sc->send_bulk_pipe;
1126 sc->last_pipe = pipe;
1127 usb_fill_bulk_urb(&sc->work_urb, sc->dev, pipe,
1128 cmd->data, cmd->len, ub_urb_complete, sc);
1129 sc->work_urb.transfer_flags = URB_ASYNC_UNLINK;
1130 sc->work_urb.actual_length = 0;
1131 sc->work_urb.error_count = 0;
1132 sc->work_urb.status = 0;
1133
1134 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1135 /* XXX Clear stalls */
1136 printk("ub: data #%d submit failed (%d)\n", cmd->tag, rc); /* P3 */
1137 ub_complete(&sc->work_done);
1138 ub_state_done(sc, cmd, rc);
1139 return;
1140 }
1141
1142 sc->work_timer.expires = jiffies + UB_DATA_TIMEOUT;
1143 add_timer(&sc->work_timer);
1144
1145 cmd->state = UB_CMDST_DATA;
1146 ub_cmdtr_state(sc, cmd);
1147
1148 } else if (cmd->state == UB_CMDST_DATA) {
1149 if (urb->status == -EPIPE) {
1150 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1151 if (rc != 0) {
1152 printk(KERN_NOTICE "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001153 "unable to submit clear (%d)\n",
1154 sc->name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 /*
1156 * This is typically ENOMEM or some other such shit.
1157 * Retrying is pointless. Just do Bad End on it...
1158 */
1159 goto Bad_End;
1160 }
1161 cmd->state = UB_CMDST_CLR2STS;
1162 ub_cmdtr_state(sc, cmd);
1163 return;
1164 }
1165 if (urb->status == -EOVERFLOW) {
1166 /*
1167 * A babble? Failure, but we must transfer CSW now.
1168 */
1169 cmd->error = -EOVERFLOW; /* A cheap trick... */
1170 } else {
1171 if (urb->status != 0)
1172 goto Bad_End;
1173 }
1174
1175 cmd->act_len = urb->actual_length;
1176 ub_cmdtr_act_len(sc, cmd);
1177
1178 ub_state_stat(sc, cmd);
1179
1180 } else if (cmd->state == UB_CMDST_STAT) {
1181 if (urb->status == -EPIPE) {
1182 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1183 if (rc != 0) {
1184 printk(KERN_NOTICE "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001185 "unable to submit clear (%d)\n",
1186 sc->name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 /*
1188 * This is typically ENOMEM or some other such shit.
1189 * Retrying is pointless. Just do Bad End on it...
1190 */
1191 goto Bad_End;
1192 }
1193 cmd->state = UB_CMDST_CLEAR;
1194 ub_cmdtr_state(sc, cmd);
1195 return;
1196 }
1197 if (urb->status != 0)
1198 goto Bad_End;
1199
1200 if (urb->actual_length == 0) {
1201 /*
1202 * Some broken devices add unnecessary zero-length
1203 * packets to the end of their data transfers.
1204 * Such packets show up as 0-length CSWs. If we
1205 * encounter such a thing, try to read the CSW again.
1206 */
1207 if (++cmd->stat_count >= 4) {
Pete Zaitcevf4800072005-05-01 16:05:40 -07001208 printk(KERN_NOTICE "%s: unable to get CSW\n",
1209 sc->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 goto Bad_End;
1211 }
1212 __ub_state_stat(sc, cmd);
1213 return;
1214 }
1215
1216 /*
1217 * Check the returned Bulk protocol status.
1218 */
1219
1220 bcs = &sc->work_bcs;
1221 rc = le32_to_cpu(bcs->Residue);
1222 if (rc != cmd->len - cmd->act_len) {
1223 /*
1224 * It is all right to transfer less, the caller has
1225 * to check. But it's not all right if the device
1226 * counts disagree with our counts.
1227 */
1228 /* P3 */ printk("%s: resid %d len %d act %d\n",
1229 sc->name, rc, cmd->len, cmd->act_len);
1230 goto Bad_End;
1231 }
1232
1233#if 0
1234 if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN) &&
1235 bcs->Signature != cpu_to_le32(US_BULK_CS_OLYMPUS_SIGN)) {
1236 /* Windows ignores signatures, so do we. */
1237 }
1238#endif
1239
1240 if (bcs->Tag != cmd->tag) {
1241 /*
1242 * This usually happens when we disagree with the
1243 * device's microcode about something. For instance,
1244 * a few of them throw this after timeouts. They buffer
1245 * commands and reply at commands we timed out before.
1246 * Without flushing these replies we loop forever.
1247 */
1248 if (++cmd->stat_count >= 4) {
1249 printk(KERN_NOTICE "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001250 "tag mismatch orig 0x%x reply 0x%x\n",
1251 sc->name, cmd->tag, bcs->Tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 goto Bad_End;
1253 }
1254 __ub_state_stat(sc, cmd);
1255 return;
1256 }
1257
1258 switch (bcs->Status) {
1259 case US_BULK_STAT_OK:
1260 break;
1261 case US_BULK_STAT_FAIL:
1262 ub_state_sense(sc, cmd);
1263 return;
1264 case US_BULK_STAT_PHASE:
1265 /* XXX We must reset the transport here */
1266 /* P3 */ printk("%s: status PHASE\n", sc->name);
1267 goto Bad_End;
1268 default:
1269 printk(KERN_INFO "%s: unknown CSW status 0x%x\n",
1270 sc->name, bcs->Status);
1271 goto Bad_End;
1272 }
1273
1274 /* Not zeroing error to preserve a babble indicator */
1275 cmd->state = UB_CMDST_DONE;
1276 ub_cmdtr_state(sc, cmd);
1277 ub_cmdq_pop(sc);
1278 (*cmd->done)(sc, cmd);
1279
1280 } else if (cmd->state == UB_CMDST_SENSE) {
1281 ub_state_done(sc, cmd, -EIO);
1282
1283 } else {
1284 printk(KERN_WARNING "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001285 "wrong command state %d\n",
1286 sc->name, cmd->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 goto Bad_End;
1288 }
1289 return;
1290
1291Bad_End: /* Little Excel is dead */
1292 ub_state_done(sc, cmd, -EIO);
1293}
1294
1295/*
1296 * Factorization helper for the command state machine:
1297 * Finish the command.
1298 */
1299static void ub_state_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd, int rc)
1300{
1301
1302 cmd->error = rc;
1303 cmd->state = UB_CMDST_DONE;
1304 ub_cmdtr_state(sc, cmd);
1305 ub_cmdq_pop(sc);
1306 (*cmd->done)(sc, cmd);
1307}
1308
1309/*
1310 * Factorization helper for the command state machine:
1311 * Submit a CSW read.
1312 */
1313static void __ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1314{
1315 int rc;
1316
1317 UB_INIT_COMPLETION(sc->work_done);
1318
1319 sc->last_pipe = sc->recv_bulk_pipe;
1320 usb_fill_bulk_urb(&sc->work_urb, sc->dev, sc->recv_bulk_pipe,
1321 &sc->work_bcs, US_BULK_CS_WRAP_LEN, ub_urb_complete, sc);
1322 sc->work_urb.transfer_flags = URB_ASYNC_UNLINK;
1323 sc->work_urb.actual_length = 0;
1324 sc->work_urb.error_count = 0;
1325 sc->work_urb.status = 0;
1326
1327 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1328 /* XXX Clear stalls */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 ub_complete(&sc->work_done);
1330 ub_state_done(sc, cmd, rc);
1331 return;
1332 }
1333
1334 sc->work_timer.expires = jiffies + UB_STAT_TIMEOUT;
1335 add_timer(&sc->work_timer);
1336}
1337
1338/*
1339 * Factorization helper for the command state machine:
1340 * Submit a CSW read and go to STAT state.
1341 */
1342static void ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1343{
1344 __ub_state_stat(sc, cmd);
1345
1346 cmd->stat_count = 0;
1347 cmd->state = UB_CMDST_STAT;
1348 ub_cmdtr_state(sc, cmd);
1349}
1350
1351/*
1352 * Factorization helper for the command state machine:
1353 * Submit a REQUEST SENSE and go to SENSE state.
1354 */
1355static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1356{
1357 struct ub_scsi_cmd *scmd;
1358 int rc;
1359
1360 if (cmd->cdb[0] == REQUEST_SENSE) {
1361 rc = -EPIPE;
1362 goto error;
1363 }
1364
1365 scmd = &sc->top_rqs_cmd;
1366 scmd->cdb[0] = REQUEST_SENSE;
1367 scmd->cdb[4] = UB_SENSE_SIZE;
1368 scmd->cdb_len = 6;
1369 scmd->dir = UB_DIR_READ;
1370 scmd->state = UB_CMDST_INIT;
1371 scmd->data = sc->top_sense;
1372 scmd->len = UB_SENSE_SIZE;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001373 scmd->lun = cmd->lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 scmd->done = ub_top_sense_done;
1375 scmd->back = cmd;
1376
1377 scmd->tag = sc->tagcnt++;
1378
1379 cmd->state = UB_CMDST_SENSE;
1380 ub_cmdtr_state(sc, cmd);
1381
1382 ub_cmdq_insert(sc, scmd);
1383 return;
1384
1385error:
1386 ub_state_done(sc, cmd, rc);
1387}
1388
1389/*
1390 * A helper for the command's state machine:
1391 * Submit a stall clear.
1392 */
1393static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
1394 int stalled_pipe)
1395{
1396 int endp;
1397 struct usb_ctrlrequest *cr;
1398 int rc;
1399
1400 endp = usb_pipeendpoint(stalled_pipe);
1401 if (usb_pipein (stalled_pipe))
1402 endp |= USB_DIR_IN;
1403
1404 cr = &sc->work_cr;
1405 cr->bRequestType = USB_RECIP_ENDPOINT;
1406 cr->bRequest = USB_REQ_CLEAR_FEATURE;
1407 cr->wValue = cpu_to_le16(USB_ENDPOINT_HALT);
1408 cr->wIndex = cpu_to_le16(endp);
1409 cr->wLength = cpu_to_le16(0);
1410
1411 UB_INIT_COMPLETION(sc->work_done);
1412
1413 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->send_ctrl_pipe,
1414 (unsigned char*) cr, NULL, 0, ub_urb_complete, sc);
1415 sc->work_urb.transfer_flags = URB_ASYNC_UNLINK;
1416 sc->work_urb.actual_length = 0;
1417 sc->work_urb.error_count = 0;
1418 sc->work_urb.status = 0;
1419
1420 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1421 ub_complete(&sc->work_done);
1422 return rc;
1423 }
1424
1425 sc->work_timer.expires = jiffies + UB_CTRL_TIMEOUT;
1426 add_timer(&sc->work_timer);
1427 return 0;
1428}
1429
1430/*
1431 */
1432static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd)
1433{
1434 unsigned char *sense = scmd->data;
1435 struct ub_scsi_cmd *cmd;
1436
1437 /*
1438 * Ignoring scmd->act_len, because the buffer was pre-zeroed.
1439 */
1440 ub_cmdtr_sense(sc, scmd, sense);
1441
1442 /*
1443 * Find the command which triggered the unit attention or a check,
1444 * save the sense into it, and advance its state machine.
1445 */
1446 if ((cmd = ub_cmdq_peek(sc)) == NULL) {
1447 printk(KERN_WARNING "%s: sense done while idle\n", sc->name);
1448 return;
1449 }
1450 if (cmd != scmd->back) {
1451 printk(KERN_WARNING "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001452 "sense done for wrong command 0x%x\n",
1453 sc->name, cmd->tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 return;
1455 }
1456 if (cmd->state != UB_CMDST_SENSE) {
1457 printk(KERN_WARNING "%s: "
Pete Zaitcevf4800072005-05-01 16:05:40 -07001458 "sense done with bad cmd state %d\n",
1459 sc->name, cmd->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 return;
1461 }
1462
1463 cmd->key = sense[2] & 0x0F;
1464 cmd->asc = sense[12];
1465 cmd->ascq = sense[13];
1466
1467 ub_scsi_urb_compl(sc, cmd);
1468}
1469
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470/*
1471 * This is called from a process context.
1472 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001473static void ub_revalidate(struct ub_dev *sc, struct ub_lun *lun)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474{
1475
Pete Zaitcevf4800072005-05-01 16:05:40 -07001476 lun->readonly = 0; /* XXX Query this from the device */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
Pete Zaitcevf4800072005-05-01 16:05:40 -07001478 lun->capacity.nsec = 0;
1479 lun->capacity.bsize = 512;
1480 lun->capacity.bshift = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Pete Zaitcevf4800072005-05-01 16:05:40 -07001482 if (ub_sync_tur(sc, lun) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 return; /* Not ready */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001484 lun->changed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
Pete Zaitcevf4800072005-05-01 16:05:40 -07001486 if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 /*
1488 * The retry here means something is wrong, either with the
1489 * device, with the transport, or with our code.
1490 * We keep this because sd.c has retries for capacity.
1491 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001492 if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
1493 lun->capacity.nsec = 0;
1494 lun->capacity.bsize = 512;
1495 lun->capacity.bshift = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 }
1497 }
1498}
1499
1500/*
1501 * The open funcion.
1502 * This is mostly needed to keep refcounting, but also to support
1503 * media checks on removable media drives.
1504 */
1505static int ub_bd_open(struct inode *inode, struct file *filp)
1506{
1507 struct gendisk *disk = inode->i_bdev->bd_disk;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001508 struct ub_lun *lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 struct ub_dev *sc;
1510 unsigned long flags;
1511 int rc;
1512
Pete Zaitcevf4800072005-05-01 16:05:40 -07001513 if ((lun = disk->private_data) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 return -ENXIO;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001515 sc = lun->udev;
1516
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 spin_lock_irqsave(&ub_lock, flags);
1518 if (atomic_read(&sc->poison)) {
1519 spin_unlock_irqrestore(&ub_lock, flags);
1520 return -ENXIO;
1521 }
1522 sc->openc++;
1523 spin_unlock_irqrestore(&ub_lock, flags);
1524
1525 /*
1526 * This is a workaround for a specific problem in our block layer.
1527 * In 2.6.9, register_disk duplicates the code from rescan_partitions.
1528 * However, if we do add_disk with a device which persistently reports
1529 * a changed media, add_disk calls register_disk, which does do_open,
1530 * which will call rescan_paritions for changed media. After that,
1531 * register_disk attempts to do it all again and causes double kobject
1532 * registration and a eventually an oops on module removal.
1533 *
1534 * The bottom line is, Al Viro says that we should not allow
1535 * bdev->bd_invalidated to be set when doing add_disk no matter what.
1536 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001537 if (lun->first_open) {
1538 lun->first_open = 0;
1539 if (lun->changed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 rc = -ENOMEDIUM;
1541 goto err_open;
1542 }
1543 }
1544
Pete Zaitcevf4800072005-05-01 16:05:40 -07001545 if (lun->removable || lun->readonly)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 check_disk_change(inode->i_bdev);
1547
1548 /*
1549 * The sd.c considers ->media_present and ->changed not equivalent,
1550 * under some pretty murky conditions (a failure of READ CAPACITY).
1551 * We may need it one day.
1552 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001553 if (lun->removable && lun->changed && !(filp->f_flags & O_NDELAY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 rc = -ENOMEDIUM;
1555 goto err_open;
1556 }
1557
Pete Zaitcevf4800072005-05-01 16:05:40 -07001558 if (lun->readonly && (filp->f_mode & FMODE_WRITE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 rc = -EROFS;
1560 goto err_open;
1561 }
1562
1563 return 0;
1564
1565err_open:
1566 ub_put(sc);
1567 return rc;
1568}
1569
1570/*
1571 */
1572static int ub_bd_release(struct inode *inode, struct file *filp)
1573{
1574 struct gendisk *disk = inode->i_bdev->bd_disk;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001575 struct ub_lun *lun = disk->private_data;
1576 struct ub_dev *sc = lun->udev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 ub_put(sc);
1579 return 0;
1580}
1581
1582/*
1583 * The ioctl interface.
1584 */
1585static int ub_bd_ioctl(struct inode *inode, struct file *filp,
1586 unsigned int cmd, unsigned long arg)
1587{
1588 struct gendisk *disk = inode->i_bdev->bd_disk;
1589 void __user *usermem = (void __user *) arg;
1590
1591 return scsi_cmd_ioctl(filp, disk, cmd, usermem);
1592}
1593
1594/*
1595 * This is called once a new disk was seen by the block layer or by ub_probe().
1596 * The main onjective here is to discover the features of the media such as
1597 * the capacity, read-only status, etc. USB storage generally does not
1598 * need to be spun up, but if we needed it, this would be the place.
1599 *
1600 * This call can sleep.
1601 *
1602 * The return code is not used.
1603 */
1604static int ub_bd_revalidate(struct gendisk *disk)
1605{
Pete Zaitcevf4800072005-05-01 16:05:40 -07001606 struct ub_lun *lun = disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
Pete Zaitcevf4800072005-05-01 16:05:40 -07001608 ub_revalidate(lun->udev, lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
1610 /* XXX Support sector size switching like in sr.c */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001611 blk_queue_hardsect_size(disk->queue, lun->capacity.bsize);
1612 set_capacity(disk, lun->capacity.nsec);
1613 // set_disk_ro(sdkp->disk, lun->readonly);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
1615 return 0;
1616}
1617
1618/*
1619 * The check is called by the block layer to verify if the media
1620 * is still available. It is supposed to be harmless, lightweight and
1621 * non-intrusive in case the media was not changed.
1622 *
1623 * This call can sleep.
1624 *
1625 * The return code is bool!
1626 */
1627static int ub_bd_media_changed(struct gendisk *disk)
1628{
Pete Zaitcevf4800072005-05-01 16:05:40 -07001629 struct ub_lun *lun = disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Pete Zaitcevf4800072005-05-01 16:05:40 -07001631 if (!lun->removable)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 return 0;
1633
1634 /*
1635 * We clean checks always after every command, so this is not
1636 * as dangerous as it looks. If the TEST_UNIT_READY fails here,
1637 * the device is actually not ready with operator or software
1638 * intervention required. One dangerous item might be a drive which
1639 * spins itself down, and come the time to write dirty pages, this
1640 * will fail, then block layer discards the data. Since we never
1641 * spin drives up, such devices simply cannot be used with ub anyway.
1642 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001643 if (ub_sync_tur(lun->udev, lun) != 0) {
1644 lun->changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 return 1;
1646 }
1647
Pete Zaitcevf4800072005-05-01 16:05:40 -07001648 return lun->changed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649}
1650
1651static struct block_device_operations ub_bd_fops = {
1652 .owner = THIS_MODULE,
1653 .open = ub_bd_open,
1654 .release = ub_bd_release,
1655 .ioctl = ub_bd_ioctl,
1656 .media_changed = ub_bd_media_changed,
1657 .revalidate_disk = ub_bd_revalidate,
1658};
1659
1660/*
1661 * Common ->done routine for commands executed synchronously.
1662 */
1663static void ub_probe_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1664{
1665 struct completion *cop = cmd->back;
1666 complete(cop);
1667}
1668
1669/*
1670 * Test if the device has a check condition on it, synchronously.
1671 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001672static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673{
1674 struct ub_scsi_cmd *cmd;
1675 enum { ALLOC_SIZE = sizeof(struct ub_scsi_cmd) };
1676 unsigned long flags;
1677 struct completion compl;
1678 int rc;
1679
1680 init_completion(&compl);
1681
1682 rc = -ENOMEM;
1683 if ((cmd = kmalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
1684 goto err_alloc;
1685 memset(cmd, 0, ALLOC_SIZE);
1686
1687 cmd->cdb[0] = TEST_UNIT_READY;
1688 cmd->cdb_len = 6;
1689 cmd->dir = UB_DIR_NONE;
1690 cmd->state = UB_CMDST_INIT;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001691 cmd->lun = lun; /* This may be NULL, but that's ok */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 cmd->done = ub_probe_done;
1693 cmd->back = &compl;
1694
1695 spin_lock_irqsave(&sc->lock, flags);
1696 cmd->tag = sc->tagcnt++;
1697
1698 rc = ub_submit_scsi(sc, cmd);
1699 spin_unlock_irqrestore(&sc->lock, flags);
1700
1701 if (rc != 0) {
1702 printk("ub: testing ready: submit error (%d)\n", rc); /* P3 */
1703 goto err_submit;
1704 }
1705
1706 wait_for_completion(&compl);
1707
1708 rc = cmd->error;
1709
1710 if (rc == -EIO && cmd->key != 0) /* Retries for benh's key */
1711 rc = cmd->key;
1712
1713err_submit:
1714 kfree(cmd);
1715err_alloc:
1716 return rc;
1717}
1718
1719/*
1720 * Read the SCSI capacity synchronously (for probing).
1721 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07001722static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
1723 struct ub_capacity *ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724{
1725 struct ub_scsi_cmd *cmd;
1726 char *p;
1727 enum { ALLOC_SIZE = sizeof(struct ub_scsi_cmd) + 8 };
1728 unsigned long flags;
1729 unsigned int bsize, shift;
1730 unsigned long nsec;
1731 struct completion compl;
1732 int rc;
1733
1734 init_completion(&compl);
1735
1736 rc = -ENOMEM;
1737 if ((cmd = kmalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
1738 goto err_alloc;
1739 memset(cmd, 0, ALLOC_SIZE);
1740 p = (char *)cmd + sizeof(struct ub_scsi_cmd);
1741
1742 cmd->cdb[0] = 0x25;
1743 cmd->cdb_len = 10;
1744 cmd->dir = UB_DIR_READ;
1745 cmd->state = UB_CMDST_INIT;
1746 cmd->data = p;
1747 cmd->len = 8;
Pete Zaitcevf4800072005-05-01 16:05:40 -07001748 cmd->lun = lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 cmd->done = ub_probe_done;
1750 cmd->back = &compl;
1751
1752 spin_lock_irqsave(&sc->lock, flags);
1753 cmd->tag = sc->tagcnt++;
1754
1755 rc = ub_submit_scsi(sc, cmd);
1756 spin_unlock_irqrestore(&sc->lock, flags);
1757
1758 if (rc != 0) {
1759 printk("ub: reading capacity: submit error (%d)\n", rc); /* P3 */
1760 goto err_submit;
1761 }
1762
1763 wait_for_completion(&compl);
1764
1765 if (cmd->error != 0) {
1766 printk("ub: reading capacity: error %d\n", cmd->error); /* P3 */
1767 rc = -EIO;
1768 goto err_read;
1769 }
1770 if (cmd->act_len != 8) {
1771 printk("ub: reading capacity: size %d\n", cmd->act_len); /* P3 */
1772 rc = -EIO;
1773 goto err_read;
1774 }
1775
1776 /* sd.c special-cases sector size of 0 to mean 512. Needed? Safe? */
1777 nsec = be32_to_cpu(*(__be32 *)p) + 1;
1778 bsize = be32_to_cpu(*(__be32 *)(p + 4));
1779 switch (bsize) {
1780 case 512: shift = 0; break;
1781 case 1024: shift = 1; break;
1782 case 2048: shift = 2; break;
1783 case 4096: shift = 3; break;
1784 default:
1785 printk("ub: Bad sector size %u\n", bsize); /* P3 */
1786 rc = -EDOM;
1787 goto err_inv_bsize;
1788 }
1789
1790 ret->bsize = bsize;
1791 ret->bshift = shift;
1792 ret->nsec = nsec << shift;
1793 rc = 0;
1794
1795err_inv_bsize:
1796err_read:
1797err_submit:
1798 kfree(cmd);
1799err_alloc:
1800 return rc;
1801}
1802
1803/*
1804 */
1805static void ub_probe_urb_complete(struct urb *urb, struct pt_regs *pt)
1806{
1807 struct completion *cop = urb->context;
1808 complete(cop);
1809}
1810
1811static void ub_probe_timeout(unsigned long arg)
1812{
1813 struct completion *cop = (struct completion *) arg;
1814 complete(cop);
1815}
1816
1817/*
Pete Zaitcevf4800072005-05-01 16:05:40 -07001818 * Get number of LUNs by the way of Bulk GetMaxLUN command.
1819 */
1820static int ub_sync_getmaxlun(struct ub_dev *sc)
1821{
1822 int ifnum = sc->intf->cur_altsetting->desc.bInterfaceNumber;
1823 unsigned char *p;
1824 enum { ALLOC_SIZE = 1 };
1825 struct usb_ctrlrequest *cr;
1826 struct completion compl;
1827 struct timer_list timer;
1828 int nluns;
1829 int rc;
1830
1831 init_completion(&compl);
1832
1833 rc = -ENOMEM;
1834 if ((p = kmalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
1835 goto err_alloc;
1836 *p = 55;
1837
1838 cr = &sc->work_cr;
1839 cr->bRequestType = USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
1840 cr->bRequest = US_BULK_GET_MAX_LUN;
1841 cr->wValue = cpu_to_le16(0);
1842 cr->wIndex = cpu_to_le16(ifnum);
1843 cr->wLength = cpu_to_le16(1);
1844
1845 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->recv_ctrl_pipe,
1846 (unsigned char*) cr, p, 1, ub_probe_urb_complete, &compl);
1847 sc->work_urb.transfer_flags = 0;
1848 sc->work_urb.actual_length = 0;
1849 sc->work_urb.error_count = 0;
1850 sc->work_urb.status = 0;
1851
1852 if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0) {
1853 if (rc == -EPIPE) {
1854 printk("%s: Stall at GetMaxLUN, using 1 LUN\n",
1855 sc->name); /* P3 */
1856 } else {
1857 printk(KERN_WARNING
1858 "%s: Unable to submit GetMaxLUN (%d)\n",
1859 sc->name, rc);
1860 }
1861 goto err_submit;
1862 }
1863
1864 init_timer(&timer);
1865 timer.function = ub_probe_timeout;
1866 timer.data = (unsigned long) &compl;
1867 timer.expires = jiffies + UB_CTRL_TIMEOUT;
1868 add_timer(&timer);
1869
1870 wait_for_completion(&compl);
1871
1872 del_timer_sync(&timer);
1873 usb_kill_urb(&sc->work_urb);
1874
1875 if (sc->work_urb.actual_length != 1) {
1876 printk("%s: GetMaxLUN returned %d bytes\n", sc->name,
1877 sc->work_urb.actual_length); /* P3 */
1878 nluns = 0;
1879 } else {
1880 if ((nluns = *p) == 55) {
1881 nluns = 0;
1882 } else {
1883 /* GetMaxLUN returns the maximum LUN number */
1884 nluns += 1;
1885 if (nluns > UB_MAX_LUNS)
1886 nluns = UB_MAX_LUNS;
1887 }
1888 printk("%s: GetMaxLUN returned %d, using %d LUNs\n", sc->name,
1889 *p, nluns); /* P3 */
1890 }
1891
1892 kfree(p);
1893 return nluns;
1894
1895err_submit:
1896 kfree(p);
1897err_alloc:
1898 return rc;
1899}
1900
1901/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 * Clear initial stalls.
1903 */
1904static int ub_probe_clear_stall(struct ub_dev *sc, int stalled_pipe)
1905{
1906 int endp;
1907 struct usb_ctrlrequest *cr;
1908 struct completion compl;
1909 struct timer_list timer;
1910 int rc;
1911
1912 init_completion(&compl);
1913
1914 endp = usb_pipeendpoint(stalled_pipe);
1915 if (usb_pipein (stalled_pipe))
1916 endp |= USB_DIR_IN;
1917
1918 cr = &sc->work_cr;
1919 cr->bRequestType = USB_RECIP_ENDPOINT;
1920 cr->bRequest = USB_REQ_CLEAR_FEATURE;
1921 cr->wValue = cpu_to_le16(USB_ENDPOINT_HALT);
1922 cr->wIndex = cpu_to_le16(endp);
1923 cr->wLength = cpu_to_le16(0);
1924
1925 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->send_ctrl_pipe,
1926 (unsigned char*) cr, NULL, 0, ub_probe_urb_complete, &compl);
1927 sc->work_urb.transfer_flags = 0;
1928 sc->work_urb.actual_length = 0;
1929 sc->work_urb.error_count = 0;
1930 sc->work_urb.status = 0;
1931
1932 if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0) {
1933 printk(KERN_WARNING
1934 "%s: Unable to submit a probe clear (%d)\n", sc->name, rc);
1935 return rc;
1936 }
1937
1938 init_timer(&timer);
1939 timer.function = ub_probe_timeout;
1940 timer.data = (unsigned long) &compl;
1941 timer.expires = jiffies + UB_CTRL_TIMEOUT;
1942 add_timer(&timer);
1943
1944 wait_for_completion(&compl);
1945
1946 del_timer_sync(&timer);
1947 usb_kill_urb(&sc->work_urb);
1948
1949 /* reset the endpoint toggle */
1950 usb_settoggle(sc->dev, endp, usb_pipeout(sc->last_pipe), 0);
1951
1952 return 0;
1953}
1954
1955/*
1956 * Get the pipe settings.
1957 */
1958static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev,
1959 struct usb_interface *intf)
1960{
1961 struct usb_host_interface *altsetting = intf->cur_altsetting;
1962 struct usb_endpoint_descriptor *ep_in = NULL;
1963 struct usb_endpoint_descriptor *ep_out = NULL;
1964 struct usb_endpoint_descriptor *ep;
1965 int i;
1966
1967 /*
1968 * Find the endpoints we need.
1969 * We are expecting a minimum of 2 endpoints - in and out (bulk).
1970 * We will ignore any others.
1971 */
1972 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
1973 ep = &altsetting->endpoint[i].desc;
1974
1975 /* Is it a BULK endpoint? */
1976 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1977 == USB_ENDPOINT_XFER_BULK) {
1978 /* BULK in or out? */
1979 if (ep->bEndpointAddress & USB_DIR_IN)
1980 ep_in = ep;
1981 else
1982 ep_out = ep;
1983 }
1984 }
1985
1986 if (ep_in == NULL || ep_out == NULL) {
Pete Zaitcevf4800072005-05-01 16:05:40 -07001987 printk(KERN_NOTICE "%s: failed endpoint check\n",
1988 sc->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 return -EIO;
1990 }
1991
1992 /* Calculate and store the pipe values */
1993 sc->send_ctrl_pipe = usb_sndctrlpipe(dev, 0);
1994 sc->recv_ctrl_pipe = usb_rcvctrlpipe(dev, 0);
1995 sc->send_bulk_pipe = usb_sndbulkpipe(dev,
1996 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
1997 sc->recv_bulk_pipe = usb_rcvbulkpipe(dev,
1998 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
1999
2000 return 0;
2001}
2002
2003/*
2004 * Probing is done in the process context, which allows us to cheat
2005 * and not to build a state machine for the discovery.
2006 */
2007static int ub_probe(struct usb_interface *intf,
2008 const struct usb_device_id *dev_id)
2009{
2010 struct ub_dev *sc;
Pete Zaitcevf4800072005-05-01 16:05:40 -07002011 int nluns;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 int rc;
2013 int i;
2014
2015 rc = -ENOMEM;
2016 if ((sc = kmalloc(sizeof(struct ub_dev), GFP_KERNEL)) == NULL)
2017 goto err_core;
2018 memset(sc, 0, sizeof(struct ub_dev));
2019 spin_lock_init(&sc->lock);
Pete Zaitcevf4800072005-05-01 16:05:40 -07002020 INIT_LIST_HEAD(&sc->luns);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 usb_init_urb(&sc->work_urb);
2022 tasklet_init(&sc->tasklet, ub_scsi_action, (unsigned long)sc);
2023 atomic_set(&sc->poison, 0);
2024
2025 init_timer(&sc->work_timer);
2026 sc->work_timer.data = (unsigned long) sc;
2027 sc->work_timer.function = ub_urb_timeout;
2028
2029 ub_init_completion(&sc->work_done);
2030 sc->work_done.done = 1; /* A little yuk, but oh well... */
2031
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 sc->dev = interface_to_usbdev(intf);
2033 sc->intf = intf;
2034 // sc->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 usb_set_intfdata(intf, sc);
2036 usb_get_dev(sc->dev);
2037 // usb_get_intf(sc->intf); /* Do we need this? */
2038
Pete Zaitcevf4800072005-05-01 16:05:40 -07002039 snprintf(sc->name, 12, DRV_NAME "(%d.%d)",
2040 sc->dev->bus->busnum, sc->dev->devnum);
2041
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 /* XXX Verify that we can handle the device (from descriptors) */
2043
2044 ub_get_pipes(sc, sc->dev, intf);
2045
2046 if (device_create_file(&sc->intf->dev, &dev_attr_diag) != 0)
2047 goto err_diag;
2048
2049 /*
2050 * At this point, all USB initialization is done, do upper layer.
2051 * We really hate halfway initialized structures, so from the
2052 * invariants perspective, this ub_dev is fully constructed at
2053 * this point.
2054 */
2055
2056 /*
2057 * This is needed to clear toggles. It is a problem only if we do
2058 * `rmmod ub && modprobe ub` without disconnects, but we like that.
2059 */
2060 ub_probe_clear_stall(sc, sc->recv_bulk_pipe);
2061 ub_probe_clear_stall(sc, sc->send_bulk_pipe);
2062
2063 /*
2064 * The way this is used by the startup code is a little specific.
2065 * A SCSI check causes a USB stall. Our common case code sees it
2066 * and clears the check, after which the device is ready for use.
2067 * But if a check was not present, any command other than
2068 * TEST_UNIT_READY ends with a lockup (including REQUEST_SENSE).
2069 *
2070 * If we neglect to clear the SCSI check, the first real command fails
2071 * (which is the capacity readout). We clear that and retry, but why
2072 * causing spurious retries for no reason.
2073 *
2074 * Revalidation may start with its own TEST_UNIT_READY, but that one
2075 * has to succeed, so we clear checks with an additional one here.
2076 * In any case it's not our business how revaliadation is implemented.
2077 */
2078 for (i = 0; i < 3; i++) { /* Retries for benh's key */
Pete Zaitcevf4800072005-05-01 16:05:40 -07002079 if ((rc = ub_sync_tur(sc, NULL)) <= 0) break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 if (rc != 0x6) break;
2081 msleep(10);
2082 }
2083
Pete Zaitcevf4800072005-05-01 16:05:40 -07002084 nluns = 1;
2085 for (i = 0; i < 3; i++) {
2086 if ((rc = ub_sync_getmaxlun(sc)) < 0) {
2087 /*
2088 * Some devices (i.e. Iomega Zip100) need this --
2089 * apparently the bulk pipes get STALLed when the
2090 * GetMaxLUN request is processed.
2091 * XXX I have a ZIP-100, verify it does this.
2092 */
2093 if (rc == -EPIPE) {
2094 ub_probe_clear_stall(sc, sc->recv_bulk_pipe);
2095 ub_probe_clear_stall(sc, sc->send_bulk_pipe);
2096 }
2097 break;
2098 }
2099 if (rc != 0) {
2100 nluns = rc;
2101 break;
2102 }
Pete Zaitcev9f793d22005-06-06 13:54:59 -07002103 msleep(100);
Pete Zaitcevf4800072005-05-01 16:05:40 -07002104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105
Pete Zaitcevf4800072005-05-01 16:05:40 -07002106 for (i = 0; i < nluns; i++) {
2107 ub_probe_lun(sc, i);
2108 }
2109 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110
Pete Zaitcevf4800072005-05-01 16:05:40 -07002111 /* device_remove_file(&sc->intf->dev, &dev_attr_diag); */
2112err_diag:
2113 usb_set_intfdata(intf, NULL);
2114 // usb_put_intf(sc->intf);
2115 usb_put_dev(sc->dev);
2116 kfree(sc);
2117err_core:
2118 return rc;
2119}
2120
2121static int ub_probe_lun(struct ub_dev *sc, int lnum)
2122{
2123 struct ub_lun *lun;
2124 request_queue_t *q;
2125 struct gendisk *disk;
2126 int rc;
2127
2128 rc = -ENOMEM;
2129 if ((lun = kmalloc(sizeof(struct ub_lun), GFP_KERNEL)) == NULL)
2130 goto err_alloc;
2131 memset(lun, 0, sizeof(struct ub_lun));
2132 lun->num = lnum;
2133
2134 rc = -ENOSR;
2135 if ((lun->id = ub_id_get()) == -1)
2136 goto err_id;
2137
2138 lun->udev = sc;
2139 list_add(&lun->link, &sc->luns);
2140
2141 snprintf(lun->name, 16, DRV_NAME "%c(%d.%d.%d)",
2142 lun->id + 'a', sc->dev->bus->busnum, sc->dev->devnum, lun->num);
2143
2144 lun->removable = 1; /* XXX Query this from the device */
2145 lun->changed = 1; /* ub_revalidate clears only */
2146 lun->first_open = 1;
2147 ub_revalidate(sc, lun);
2148
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 rc = -ENOMEM;
2150 if ((disk = alloc_disk(UB_MINORS_PER_MAJOR)) == NULL)
2151 goto err_diskalloc;
2152
Pete Zaitcevf4800072005-05-01 16:05:40 -07002153 lun->disk = disk;
2154 sprintf(disk->disk_name, DRV_NAME "%c", lun->id + 'a');
2155 sprintf(disk->devfs_name, DEVFS_NAME "/%c", lun->id + 'a');
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 disk->major = UB_MAJOR;
Pete Zaitcevf4800072005-05-01 16:05:40 -07002157 disk->first_minor = lun->id * UB_MINORS_PER_MAJOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 disk->fops = &ub_bd_fops;
Pete Zaitcevf4800072005-05-01 16:05:40 -07002159 disk->private_data = lun;
2160 disk->driverfs_dev = &sc->intf->dev; /* XXX Many to one ok? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161
2162 rc = -ENOMEM;
2163 if ((q = blk_init_queue(ub_bd_rq_fn, &sc->lock)) == NULL)
2164 goto err_blkqinit;
2165
2166 disk->queue = q;
2167
Pete Zaitcevf4800072005-05-01 16:05:40 -07002168 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 blk_queue_max_hw_segments(q, UB_MAX_REQ_SG);
2170 blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
Pete Zaitcevf4800072005-05-01 16:05:40 -07002171 blk_queue_segment_boundary(q, 0xffffffff); /* Dubious. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 blk_queue_max_sectors(q, UB_MAX_SECTORS);
Pete Zaitcevf4800072005-05-01 16:05:40 -07002173 blk_queue_hardsect_size(q, lun->capacity.bsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Pete Zaitcevf4800072005-05-01 16:05:40 -07002175 q->queuedata = lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176
Pete Zaitcevf4800072005-05-01 16:05:40 -07002177 set_capacity(disk, lun->capacity.nsec);
2178 if (lun->removable)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 disk->flags |= GENHD_FL_REMOVABLE;
2180
2181 add_disk(disk);
2182
2183 return 0;
2184
2185err_blkqinit:
2186 put_disk(disk);
2187err_diskalloc:
Pete Zaitcevf4800072005-05-01 16:05:40 -07002188 list_del(&lun->link);
2189 ub_id_put(lun->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190err_id:
Pete Zaitcevf4800072005-05-01 16:05:40 -07002191 kfree(lun);
2192err_alloc:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 return rc;
2194}
2195
2196static void ub_disconnect(struct usb_interface *intf)
2197{
2198 struct ub_dev *sc = usb_get_intfdata(intf);
Pete Zaitcevf4800072005-05-01 16:05:40 -07002199 struct list_head *p;
2200 struct ub_lun *lun;
2201 struct gendisk *disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 unsigned long flags;
2203
2204 /*
2205 * Prevent ub_bd_release from pulling the rug from under us.
2206 * XXX This is starting to look like a kref.
2207 * XXX Why not to take this ref at probe time?
2208 */
2209 spin_lock_irqsave(&ub_lock, flags);
2210 sc->openc++;
2211 spin_unlock_irqrestore(&ub_lock, flags);
2212
2213 /*
2214 * Fence stall clearnings, operations triggered by unlinkings and so on.
2215 * We do not attempt to unlink any URBs, because we do not trust the
2216 * unlink paths in HC drivers. Also, we get -84 upon disconnect anyway.
2217 */
2218 atomic_set(&sc->poison, 1);
2219
2220 /*
2221 * Blow away queued commands.
2222 *
2223 * Actually, this never works, because before we get here
2224 * the HCD terminates outstanding URB(s). It causes our
2225 * SCSI command queue to advance, commands fail to submit,
2226 * and the whole queue drains. So, we just use this code to
2227 * print warnings.
2228 */
2229 spin_lock_irqsave(&sc->lock, flags);
2230 {
2231 struct ub_scsi_cmd *cmd;
2232 int cnt = 0;
2233 while ((cmd = ub_cmdq_pop(sc)) != NULL) {
2234 cmd->error = -ENOTCONN;
2235 cmd->state = UB_CMDST_DONE;
2236 ub_cmdtr_state(sc, cmd);
2237 ub_cmdq_pop(sc);
2238 (*cmd->done)(sc, cmd);
2239 cnt++;
2240 }
2241 if (cnt != 0) {
2242 printk(KERN_WARNING "%s: "
2243 "%d was queued after shutdown\n", sc->name, cnt);
2244 }
2245 }
2246 spin_unlock_irqrestore(&sc->lock, flags);
2247
2248 /*
2249 * Unregister the upper layer.
2250 */
Pete Zaitcevf4800072005-05-01 16:05:40 -07002251 list_for_each (p, &sc->luns) {
2252 lun = list_entry(p, struct ub_lun, link);
2253 disk = lun->disk;
2254 if (disk->flags & GENHD_FL_UP)
2255 del_gendisk(disk);
2256 /*
2257 * I wish I could do:
2258 * set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
2259 * As it is, we rely on our internal poisoning and let
2260 * the upper levels to spin furiously failing all the I/O.
2261 */
2262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263
2264 /*
2265 * Taking a lock on a structure which is about to be freed
2266 * is very nonsensual. Here it is largely a way to do a debug freeze,
2267 * and a bracket which shows where the nonsensual code segment ends.
2268 *
2269 * Testing for -EINPROGRESS is always a bug, so we are bending
2270 * the rules a little.
2271 */
2272 spin_lock_irqsave(&sc->lock, flags);
2273 if (sc->work_urb.status == -EINPROGRESS) { /* janitors: ignore */
2274 printk(KERN_WARNING "%s: "
2275 "URB is active after disconnect\n", sc->name);
2276 }
2277 spin_unlock_irqrestore(&sc->lock, flags);
2278
2279 /*
2280 * There is virtually no chance that other CPU runs times so long
2281 * after ub_urb_complete should have called del_timer, but only if HCD
2282 * didn't forget to deliver a callback on unlink.
2283 */
2284 del_timer_sync(&sc->work_timer);
2285
2286 /*
2287 * At this point there must be no commands coming from anyone
2288 * and no URBs left in transit.
2289 */
2290
2291 device_remove_file(&sc->intf->dev, &dev_attr_diag);
2292 usb_set_intfdata(intf, NULL);
2293 // usb_put_intf(sc->intf);
2294 sc->intf = NULL;
2295 usb_put_dev(sc->dev);
2296 sc->dev = NULL;
2297
2298 ub_put(sc);
2299}
2300
2301static struct usb_driver ub_driver = {
2302 .owner = THIS_MODULE,
2303 .name = "ub",
2304 .probe = ub_probe,
2305 .disconnect = ub_disconnect,
2306 .id_table = ub_usb_ids,
2307};
2308
2309static int __init ub_init(void)
2310{
2311 int rc;
2312
Pete Zaitcevf4800072005-05-01 16:05:40 -07002313 /* P3 */ printk("ub: sizeof ub_scsi_cmd %zu ub_dev %zu ub_lun %zu\n",
2314 sizeof(struct ub_scsi_cmd), sizeof(struct ub_dev), sizeof(struct ub_lun));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315
2316 if ((rc = register_blkdev(UB_MAJOR, DRV_NAME)) != 0)
2317 goto err_regblkdev;
2318 devfs_mk_dir(DEVFS_NAME);
2319
2320 if ((rc = usb_register(&ub_driver)) != 0)
2321 goto err_register;
2322
2323 return 0;
2324
2325err_register:
2326 devfs_remove(DEVFS_NAME);
2327 unregister_blkdev(UB_MAJOR, DRV_NAME);
2328err_regblkdev:
2329 return rc;
2330}
2331
2332static void __exit ub_exit(void)
2333{
2334 usb_deregister(&ub_driver);
2335
2336 devfs_remove(DEVFS_NAME);
2337 unregister_blkdev(UB_MAJOR, DRV_NAME);
2338}
2339
2340module_init(ub_init);
2341module_exit(ub_exit);
2342
2343MODULE_LICENSE("GPL");