1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/usb.h>
26#include <linux/usb_usual.h>
27#include <linux/blkdev.h>
28#include <linux/timer.h>
29#include <linux/scatterlist.h>
30#include <linux/slab.h>
31#include <linux/mutex.h>
32#include <scsi/scsi.h>
33
34#define DRV_NAME "ub"
35
36#define UB_MAJOR 180
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109#define UB_MAX_LUNS 9
110
111
112
113
114#define UB_PARTS_PER_LUN 8
115
116#define UB_MAX_CDB_SIZE 16
117
118#define UB_SENSE_SIZE 18
119
120
121
122
123
124struct bulk_cb_wrap {
125 __le32 Signature;
126 u32 Tag;
127 __le32 DataTransferLength;
128 u8 Flags;
129 u8 Lun;
130 u8 Length;
131 u8 CDB[UB_MAX_CDB_SIZE];
132};
133
134#define US_BULK_CB_WRAP_LEN 31
135#define US_BULK_CB_SIGN 0x43425355
136#define US_BULK_FLAG_IN 1
137#define US_BULK_FLAG_OUT 0
138
139
140struct bulk_cs_wrap {
141 __le32 Signature;
142 u32 Tag;
143 __le32 Residue;
144 u8 Status;
145};
146
147#define US_BULK_CS_WRAP_LEN 13
148#define US_BULK_CS_SIGN 0x53425355
149#define US_BULK_STAT_OK 0
150#define US_BULK_STAT_FAIL 1
151#define US_BULK_STAT_PHASE 2
152
153
154#define US_BULK_RESET_REQUEST 0xff
155#define US_BULK_GET_MAX_LUN 0xfe
156
157
158
159struct ub_dev;
160
161#define UB_MAX_REQ_SG 9
162#define UB_MAX_SECTORS 64
163
164
165
166
167
168#define UB_URB_TIMEOUT (HZ*2)
169#define UB_DATA_TIMEOUT (HZ*5)
170#define UB_STAT_TIMEOUT (HZ*5)
171#define UB_CTRL_TIMEOUT (HZ/2)
172
173
174
175
176#define UB_DIR_NONE 0
177#define UB_DIR_READ 1
178#define UB_DIR_ILLEGAL2 2
179#define UB_DIR_WRITE 3
180
181#define UB_DIR_CHAR(c) (((c)==UB_DIR_WRITE)? 'w': \
182 (((c)==UB_DIR_READ)? 'r': 'n'))
183
184enum ub_scsi_cmd_state {
185 UB_CMDST_INIT,
186 UB_CMDST_CMD,
187 UB_CMDST_DATA,
188 UB_CMDST_CLR2STS,
189 UB_CMDST_STAT,
190 UB_CMDST_CLEAR,
191 UB_CMDST_CLRRS,
192 UB_CMDST_SENSE,
193 UB_CMDST_DONE
194};
195
196struct ub_scsi_cmd {
197 unsigned char cdb[UB_MAX_CDB_SIZE];
198 unsigned char cdb_len;
199
200 unsigned char dir;
201 enum ub_scsi_cmd_state state;
202 unsigned int tag;
203 struct ub_scsi_cmd *next;
204
205 int error;
206 unsigned int act_len;
207 unsigned char key, asc, ascq;
208
209 int stat_count;
210 unsigned int timeo;
211
212 unsigned int len;
213 unsigned int current_sg;
214 unsigned int nsg;
215 struct scatterlist sgv[UB_MAX_REQ_SG];
216
217 struct ub_lun *lun;
218 void (*done)(struct ub_dev *, struct ub_scsi_cmd *);
219 void *back;
220};
221
222struct ub_request {
223 struct request *rq;
224 unsigned int current_try;
225 unsigned int nsg;
226 struct scatterlist sgv[UB_MAX_REQ_SG];
227};
228
229
230
231struct ub_capacity {
232 unsigned long nsec;
233 unsigned int bsize;
234 unsigned int bshift;
235};
236
237
238
239
240
241
242
243
244
245
246struct ub_completion {
247 unsigned int done;
248 spinlock_t lock;
249};
250
251static DEFINE_MUTEX(ub_mutex);
252static inline void ub_init_completion(struct ub_completion *x)
253{
254 x->done = 0;
255 spin_lock_init(&x->lock);
256}
257
258#define UB_INIT_COMPLETION(x) ((x).done = 0)
259
260static void ub_complete(struct ub_completion *x)
261{
262 unsigned long flags;
263
264 spin_lock_irqsave(&x->lock, flags);
265 x->done++;
266 spin_unlock_irqrestore(&x->lock, flags);
267}
268
269static int ub_is_completed(struct ub_completion *x)
270{
271 unsigned long flags;
272 int ret;
273
274 spin_lock_irqsave(&x->lock, flags);
275 ret = x->done;
276 spin_unlock_irqrestore(&x->lock, flags);
277 return ret;
278}
279
280
281
282struct ub_scsi_cmd_queue {
283 int qlen, qmax;
284 struct ub_scsi_cmd *head, *tail;
285};
286
287
288
289
290struct ub_lun {
291 struct ub_dev *udev;
292 struct list_head link;
293 struct gendisk *disk;
294 int id;
295 int num;
296 char name[16];
297
298 int changed;
299 int removable;
300 int readonly;
301
302 struct ub_request urq;
303
304
305
306
307
308
309
310 int cmda[1];
311 struct ub_scsi_cmd cmdv[1];
312
313 struct ub_capacity capacity;
314};
315
316
317
318
319struct ub_dev {
320 spinlock_t *lock;
321 atomic_t poison;
322 int openc;
323
324 int reset;
325 int bad_resid;
326 unsigned int tagcnt;
327 char name[12];
328 struct usb_device *dev;
329 struct usb_interface *intf;
330
331 struct list_head luns;
332
333 unsigned int send_bulk_pipe;
334 unsigned int recv_bulk_pipe;
335 unsigned int send_ctrl_pipe;
336 unsigned int recv_ctrl_pipe;
337
338 struct tasklet_struct tasklet;
339
340 struct ub_scsi_cmd_queue cmd_queue;
341 struct ub_scsi_cmd top_rqs_cmd;
342 unsigned char top_sense[UB_SENSE_SIZE];
343
344 struct ub_completion work_done;
345 struct urb work_urb;
346 struct timer_list work_timer;
347 int last_pipe;
348 __le32 signature;
349 struct bulk_cb_wrap work_bcb;
350 struct bulk_cs_wrap work_bcs;
351 struct usb_ctrlrequest work_cr;
352
353 struct work_struct reset_work;
354 wait_queue_head_t reset_wait;
355};
356
357
358
359static void ub_cleanup(struct ub_dev *sc);
360static int ub_request_fn_1(struct ub_lun *lun, struct request *rq);
361static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
362 struct ub_scsi_cmd *cmd, struct ub_request *urq);
363static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
364 struct ub_scsi_cmd *cmd, struct ub_request *urq);
365static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
366static void ub_end_rq(struct request *rq, unsigned int status);
367static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
368 struct ub_request *urq, struct ub_scsi_cmd *cmd);
369static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
370static void ub_urb_complete(struct urb *urb);
371static void ub_scsi_action(unsigned long _dev);
372static void ub_scsi_dispatch(struct ub_dev *sc);
373static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
374static void ub_data_start(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
375static void ub_state_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd, int rc);
376static int __ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
377static void ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
378static void ub_state_stat_counted(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
379static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
380static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
381 int stalled_pipe);
382static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd);
383static void ub_reset_enter(struct ub_dev *sc, int try);
384static void ub_reset_task(struct work_struct *work);
385static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun);
386static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
387 struct ub_capacity *ret);
388static int ub_sync_reset(struct ub_dev *sc);
389static int ub_probe_clear_stall(struct ub_dev *sc, int stalled_pipe);
390static int ub_probe_lun(struct ub_dev *sc, int lnum);
391
392
393
394#ifdef CONFIG_USB_LIBUSUAL
395
396#define ub_usb_ids usb_storage_usb_ids
397#else
398
399static const struct usb_device_id ub_usb_ids[] = {
400 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
401 { }
402};
403
404MODULE_DEVICE_TABLE(usb, ub_usb_ids);
405#endif
406
407
408
409
410
411
412
413
414#define UB_MAX_HOSTS 26
415static char ub_hostv[UB_MAX_HOSTS];
416
417#define UB_QLOCK_NUM 5
418static spinlock_t ub_qlockv[UB_QLOCK_NUM];
419static int ub_qlock_next = 0;
420
421static DEFINE_SPINLOCK(ub_lock);
422
423
424
425
426
427
428static int ub_id_get(void)
429{
430 unsigned long flags;
431 int i;
432
433 spin_lock_irqsave(&ub_lock, flags);
434 for (i = 0; i < UB_MAX_HOSTS; i++) {
435 if (ub_hostv[i] == 0) {
436 ub_hostv[i] = 1;
437 spin_unlock_irqrestore(&ub_lock, flags);
438 return i;
439 }
440 }
441 spin_unlock_irqrestore(&ub_lock, flags);
442 return -1;
443}
444
445static void ub_id_put(int id)
446{
447 unsigned long flags;
448
449 if (id < 0 || id >= UB_MAX_HOSTS) {
450 printk(KERN_ERR DRV_NAME ": bad host ID %d\n", id);
451 return;
452 }
453
454 spin_lock_irqsave(&ub_lock, flags);
455 if (ub_hostv[id] == 0) {
456 spin_unlock_irqrestore(&ub_lock, flags);
457 printk(KERN_ERR DRV_NAME ": freeing free host ID %d\n", id);
458 return;
459 }
460 ub_hostv[id] = 0;
461 spin_unlock_irqrestore(&ub_lock, flags);
462}
463
464
465
466
467
468
469
470static spinlock_t *ub_next_lock(void)
471{
472 unsigned long flags;
473 spinlock_t *ret;
474
475 spin_lock_irqsave(&ub_lock, flags);
476 ret = &ub_qlockv[ub_qlock_next];
477 ub_qlock_next = (ub_qlock_next + 1) % UB_QLOCK_NUM;
478 spin_unlock_irqrestore(&ub_lock, flags);
479 return ret;
480}
481
482
483
484
485
486
487
488
489
490static void ub_put(struct ub_dev *sc)
491{
492 unsigned long flags;
493
494 spin_lock_irqsave(&ub_lock, flags);
495 --sc->openc;
496 if (sc->openc == 0 && atomic_read(&sc->poison)) {
497 spin_unlock_irqrestore(&ub_lock, flags);
498 ub_cleanup(sc);
499 } else {
500 spin_unlock_irqrestore(&ub_lock, flags);
501 }
502}
503
504
505
506
507static void ub_cleanup(struct ub_dev *sc)
508{
509 struct list_head *p;
510 struct ub_lun *lun;
511 struct request_queue *q;
512
513 while (!list_empty(&sc->luns)) {
514 p = sc->luns.next;
515 lun = list_entry(p, struct ub_lun, link);
516 list_del(p);
517
518
519 if ((q = lun->disk->queue) != NULL)
520 blk_cleanup_queue(q);
521
522
523
524
525
526
527
528
529
530 put_disk(lun->disk);
531 lun->disk = NULL;
532
533 ub_id_put(lun->id);
534 kfree(lun);
535 }
536
537 usb_set_intfdata(sc->intf, NULL);
538 usb_put_intf(sc->intf);
539 usb_put_dev(sc->dev);
540 kfree(sc);
541}
542
543
544
545
546static struct ub_scsi_cmd *ub_get_cmd(struct ub_lun *lun)
547{
548 struct ub_scsi_cmd *ret;
549
550 if (lun->cmda[0])
551 return NULL;
552 ret = &lun->cmdv[0];
553 lun->cmda[0] = 1;
554 return ret;
555}
556
557static void ub_put_cmd(struct ub_lun *lun, struct ub_scsi_cmd *cmd)
558{
559 if (cmd != &lun->cmdv[0]) {
560 printk(KERN_WARNING "%s: releasing a foreign cmd %p\n",
561 lun->name, cmd);
562 return;
563 }
564 if (!lun->cmda[0]) {
565 printk(KERN_WARNING "%s: releasing a free cmd\n", lun->name);
566 return;
567 }
568 lun->cmda[0] = 0;
569}
570
571
572
573
574static void ub_cmdq_add(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
575{
576 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
577
578 if (t->qlen++ == 0) {
579 t->head = cmd;
580 t->tail = cmd;
581 } else {
582 t->tail->next = cmd;
583 t->tail = cmd;
584 }
585
586 if (t->qlen > t->qmax)
587 t->qmax = t->qlen;
588}
589
590static void ub_cmdq_insert(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
591{
592 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
593
594 if (t->qlen++ == 0) {
595 t->head = cmd;
596 t->tail = cmd;
597 } else {
598 cmd->next = t->head;
599 t->head = cmd;
600 }
601
602 if (t->qlen > t->qmax)
603 t->qmax = t->qlen;
604}
605
606static struct ub_scsi_cmd *ub_cmdq_pop(struct ub_dev *sc)
607{
608 struct ub_scsi_cmd_queue *t = &sc->cmd_queue;
609 struct ub_scsi_cmd *cmd;
610
611 if (t->qlen == 0)
612 return NULL;
613 if (--t->qlen == 0)
614 t->tail = NULL;
615 cmd = t->head;
616 t->head = cmd->next;
617 cmd->next = NULL;
618 return cmd;
619}
620
621#define ub_cmdq_peek(sc) ((sc)->cmd_queue.head)
622
623
624
625
626
627static void ub_request_fn(struct request_queue *q)
628{
629 struct ub_lun *lun = q->queuedata;
630 struct request *rq;
631
632 while ((rq = blk_peek_request(q)) != NULL) {
633 if (ub_request_fn_1(lun, rq) != 0) {
634 blk_stop_queue(q);
635 break;
636 }
637 }
638}
639
640static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
641{
642 struct ub_dev *sc = lun->udev;
643 struct ub_scsi_cmd *cmd;
644 struct ub_request *urq;
645 int n_elem;
646
647 if (atomic_read(&sc->poison)) {
648 blk_start_request(rq);
649 ub_end_rq(rq, DID_NO_CONNECT << 16);
650 return 0;
651 }
652
653 if (lun->changed && rq->cmd_type != REQ_TYPE_BLOCK_PC) {
654 blk_start_request(rq);
655 ub_end_rq(rq, SAM_STAT_CHECK_CONDITION);
656 return 0;
657 }
658
659 if (lun->urq.rq != NULL)
660 return -1;
661 if ((cmd = ub_get_cmd(lun)) == NULL)
662 return -1;
663 memset(cmd, 0, sizeof(struct ub_scsi_cmd));
664
665 blk_start_request(rq);
666
667 urq = &lun->urq;
668 memset(urq, 0, sizeof(struct ub_request));
669 urq->rq = rq;
670
671
672
673
674 sg_init_table(&urq->sgv[0], UB_MAX_REQ_SG);
675 n_elem = blk_rq_map_sg(lun->disk->queue, rq, &urq->sgv[0]);
676 if (n_elem < 0) {
677
678 printk(KERN_INFO "%s: failed request map (%d)\n",
679 lun->name, n_elem);
680 goto drop;
681 }
682 if (n_elem > UB_MAX_REQ_SG) {
683 printk(KERN_WARNING "%s: request with %d segments\n",
684 lun->name, n_elem);
685 goto drop;
686 }
687 urq->nsg = n_elem;
688
689 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
690 ub_cmd_build_packet(sc, lun, cmd, urq);
691 } else {
692 ub_cmd_build_block(sc, lun, cmd, urq);
693 }
694 cmd->state = UB_CMDST_INIT;
695 cmd->lun = lun;
696 cmd->done = ub_rw_cmd_done;
697 cmd->back = urq;
698
699 cmd->tag = sc->tagcnt++;
700 if (ub_submit_scsi(sc, cmd) != 0)
701 goto drop;
702
703 return 0;
704
705drop:
706 ub_put_cmd(lun, cmd);
707 ub_end_rq(rq, DID_ERROR << 16);
708 return 0;
709}
710
711static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
712 struct ub_scsi_cmd *cmd, struct ub_request *urq)
713{
714 struct request *rq = urq->rq;
715 unsigned int block, nblks;
716
717 if (rq_data_dir(rq) == WRITE)
718 cmd->dir = UB_DIR_WRITE;
719 else
720 cmd->dir = UB_DIR_READ;
721
722 cmd->nsg = urq->nsg;
723 memcpy(cmd->sgv, urq->sgv, sizeof(struct scatterlist) * cmd->nsg);
724
725
726
727
728
729
730
731 block = blk_rq_pos(rq) >> lun->capacity.bshift;
732 nblks = blk_rq_sectors(rq) >> lun->capacity.bshift;
733
734 cmd->cdb[0] = (cmd->dir == UB_DIR_READ)? READ_10: WRITE_10;
735
736 cmd->cdb[2] = block >> 24;
737 cmd->cdb[3] = block >> 16;
738 cmd->cdb[4] = block >> 8;
739 cmd->cdb[5] = block;
740 cmd->cdb[7] = nblks >> 8;
741 cmd->cdb[8] = nblks;
742 cmd->cdb_len = 10;
743
744 cmd->len = blk_rq_bytes(rq);
745}
746
747static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
748 struct ub_scsi_cmd *cmd, struct ub_request *urq)
749{
750 struct request *rq = urq->rq;
751
752 if (blk_rq_bytes(rq) == 0) {
753 cmd->dir = UB_DIR_NONE;
754 } else {
755 if (rq_data_dir(rq) == WRITE)
756 cmd->dir = UB_DIR_WRITE;
757 else
758 cmd->dir = UB_DIR_READ;
759 }
760
761 cmd->nsg = urq->nsg;
762 memcpy(cmd->sgv, urq->sgv, sizeof(struct scatterlist) * cmd->nsg);
763
764 memcpy(&cmd->cdb, rq->cmd, rq->cmd_len);
765 cmd->cdb_len = rq->cmd_len;
766
767 cmd->len = blk_rq_bytes(rq);
768
769
770
771
772
773 cmd->timeo = rq->timeout;
774}
775
776static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
777{
778 struct ub_lun *lun = cmd->lun;
779 struct ub_request *urq = cmd->back;
780 struct request *rq;
781 unsigned int scsi_status;
782
783 rq = urq->rq;
784
785 if (cmd->error == 0) {
786 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
787 if (cmd->act_len >= rq->resid_len)
788 rq->resid_len = 0;
789 else
790 rq->resid_len -= cmd->act_len;
791 scsi_status = 0;
792 } else {
793 if (cmd->act_len != cmd->len) {
794 scsi_status = SAM_STAT_CHECK_CONDITION;
795 } else {
796 scsi_status = 0;
797 }
798 }
799 } else {
800 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
801
802 memcpy(rq->sense, sc->top_sense, UB_SENSE_SIZE);
803 rq->sense_len = UB_SENSE_SIZE;
804 if (sc->top_sense[0] != 0)
805 scsi_status = SAM_STAT_CHECK_CONDITION;
806 else
807 scsi_status = DID_ERROR << 16;
808 } else {
809 if (cmd->error == -EIO &&
810 (cmd->key == 0 ||
811 cmd->key == MEDIUM_ERROR ||
812 cmd->key == UNIT_ATTENTION)) {
813 if (ub_rw_cmd_retry(sc, lun, urq, cmd) == 0)
814 return;
815 }
816 scsi_status = SAM_STAT_CHECK_CONDITION;
817 }
818 }
819
820 urq->rq = NULL;
821
822 ub_put_cmd(lun, cmd);
823 ub_end_rq(rq, scsi_status);
824 blk_start_queue(lun->disk->queue);
825}
826
827static void ub_end_rq(struct request *rq, unsigned int scsi_status)
828{
829 int error;
830
831 if (scsi_status == 0) {
832 error = 0;
833 } else {
834 error = -EIO;
835 rq->errors = scsi_status;
836 }
837 __blk_end_request_all(rq, error);
838}
839
840static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
841 struct ub_request *urq, struct ub_scsi_cmd *cmd)
842{
843
844 if (atomic_read(&sc->poison))
845 return -ENXIO;
846
847 ub_reset_enter(sc, urq->current_try);
848
849 if (urq->current_try >= 3)
850 return -EIO;
851 urq->current_try++;
852
853
854 printk(KERN_DEBUG "%s: dir %c len/act %d/%d "
855 "[sense %x %02x %02x] retry %d\n",
856 sc->name, UB_DIR_CHAR(cmd->dir), cmd->len, cmd->act_len,
857 cmd->key, cmd->asc, cmd->ascq, urq->current_try);
858
859 memset(cmd, 0, sizeof(struct ub_scsi_cmd));
860 ub_cmd_build_block(sc, lun, cmd, urq);
861
862 cmd->state = UB_CMDST_INIT;
863 cmd->lun = lun;
864 cmd->done = ub_rw_cmd_done;
865 cmd->back = urq;
866
867 cmd->tag = sc->tagcnt++;
868
869#if 0
870 return ub_submit_scsi(sc, cmd);
871#else
872 ub_cmdq_add(sc, cmd);
873 return 0;
874#endif
875}
876
877
878
879
880
881
882
883
884
885
886static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
887{
888
889 if (cmd->state != UB_CMDST_INIT ||
890 (cmd->dir != UB_DIR_NONE && cmd->len == 0)) {
891 return -EINVAL;
892 }
893
894 ub_cmdq_add(sc, cmd);
895
896
897
898
899 tasklet_schedule(&sc->tasklet);
900 return 0;
901}
902
903
904
905
906
907static int ub_scsi_cmd_start(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
908{
909 struct bulk_cb_wrap *bcb;
910 int rc;
911
912 bcb = &sc->work_bcb;
913
914
915
916
917
918
919
920
921
922
923 memset(&sc->top_sense, 0, UB_SENSE_SIZE);
924
925
926 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
927 bcb->Tag = cmd->tag;
928 bcb->DataTransferLength = cpu_to_le32(cmd->len);
929 bcb->Flags = (cmd->dir == UB_DIR_READ) ? 0x80 : 0;
930 bcb->Lun = (cmd->lun != NULL) ? cmd->lun->num : 0;
931 bcb->Length = cmd->cdb_len;
932
933
934 memcpy(bcb->CDB, cmd->cdb, UB_MAX_CDB_SIZE);
935
936 UB_INIT_COMPLETION(sc->work_done);
937
938 sc->last_pipe = sc->send_bulk_pipe;
939 usb_fill_bulk_urb(&sc->work_urb, sc->dev, sc->send_bulk_pipe,
940 bcb, US_BULK_CB_WRAP_LEN, ub_urb_complete, sc);
941
942 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
943
944 ub_complete(&sc->work_done);
945 return rc;
946 }
947
948 sc->work_timer.expires = jiffies + UB_URB_TIMEOUT;
949 add_timer(&sc->work_timer);
950
951 cmd->state = UB_CMDST_CMD;
952 return 0;
953}
954
955
956
957
958static void ub_urb_timeout(unsigned long arg)
959{
960 struct ub_dev *sc = (struct ub_dev *) arg;
961 unsigned long flags;
962
963 spin_lock_irqsave(sc->lock, flags);
964 if (!ub_is_completed(&sc->work_done))
965 usb_unlink_urb(&sc->work_urb);
966 spin_unlock_irqrestore(sc->lock, flags);
967}
968
969
970
971
972
973
974
975
976static void ub_urb_complete(struct urb *urb)
977{
978 struct ub_dev *sc = urb->context;
979
980 ub_complete(&sc->work_done);
981 tasklet_schedule(&sc->tasklet);
982}
983
984static void ub_scsi_action(unsigned long _dev)
985{
986 struct ub_dev *sc = (struct ub_dev *) _dev;
987 unsigned long flags;
988
989 spin_lock_irqsave(sc->lock, flags);
990 ub_scsi_dispatch(sc);
991 spin_unlock_irqrestore(sc->lock, flags);
992}
993
994static void ub_scsi_dispatch(struct ub_dev *sc)
995{
996 struct ub_scsi_cmd *cmd;
997 int rc;
998
999 while (!sc->reset && (cmd = ub_cmdq_peek(sc)) != NULL) {
1000 if (cmd->state == UB_CMDST_DONE) {
1001 ub_cmdq_pop(sc);
1002 (*cmd->done)(sc, cmd);
1003 } else if (cmd->state == UB_CMDST_INIT) {
1004 if ((rc = ub_scsi_cmd_start(sc, cmd)) == 0)
1005 break;
1006 cmd->error = rc;
1007 cmd->state = UB_CMDST_DONE;
1008 } else {
1009 if (!ub_is_completed(&sc->work_done))
1010 break;
1011 del_timer(&sc->work_timer);
1012 ub_scsi_urb_compl(sc, cmd);
1013 }
1014 }
1015}
1016
1017static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1018{
1019 struct urb *urb = &sc->work_urb;
1020 struct bulk_cs_wrap *bcs;
1021 int endp;
1022 int len;
1023 int rc;
1024
1025 if (atomic_read(&sc->poison)) {
1026 ub_state_done(sc, cmd, -ENODEV);
1027 return;
1028 }
1029
1030 endp = usb_pipeendpoint(sc->last_pipe);
1031 if (usb_pipein(sc->last_pipe))
1032 endp |= USB_DIR_IN;
1033
1034 if (cmd->state == UB_CMDST_CLEAR) {
1035 if (urb->status == -EPIPE) {
1036
1037
1038
1039
1040 printk(KERN_NOTICE "%s: stall on control pipe\n",
1041 sc->name);
1042 goto Bad_End;
1043 }
1044
1045
1046
1047
1048
1049 usb_reset_endpoint(sc->dev, endp);
1050
1051 ub_state_sense(sc, cmd);
1052
1053 } else if (cmd->state == UB_CMDST_CLR2STS) {
1054 if (urb->status == -EPIPE) {
1055 printk(KERN_NOTICE "%s: stall on control pipe\n",
1056 sc->name);
1057 goto Bad_End;
1058 }
1059
1060
1061
1062
1063
1064 usb_reset_endpoint(sc->dev, endp);
1065
1066 ub_state_stat(sc, cmd);
1067
1068 } else if (cmd->state == UB_CMDST_CLRRS) {
1069 if (urb->status == -EPIPE) {
1070 printk(KERN_NOTICE "%s: stall on control pipe\n",
1071 sc->name);
1072 goto Bad_End;
1073 }
1074
1075
1076
1077
1078
1079 usb_reset_endpoint(sc->dev, endp);
1080
1081 ub_state_stat_counted(sc, cmd);
1082
1083 } else if (cmd->state == UB_CMDST_CMD) {
1084 switch (urb->status) {
1085 case 0:
1086 break;
1087 case -EOVERFLOW:
1088 goto Bad_End;
1089 case -EPIPE:
1090 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1091 if (rc != 0) {
1092 printk(KERN_NOTICE "%s: "
1093 "unable to submit clear (%d)\n",
1094 sc->name, rc);
1095
1096
1097
1098
1099 ub_state_done(sc, cmd, rc);
1100 return;
1101 }
1102 cmd->state = UB_CMDST_CLEAR;
1103 return;
1104 case -ESHUTDOWN:
1105 case -EILSEQ:
1106 ub_state_done(sc, cmd, -ENODEV);
1107 return;
1108 default:
1109 goto Bad_End;
1110 }
1111 if (urb->actual_length != US_BULK_CB_WRAP_LEN) {
1112 goto Bad_End;
1113 }
1114
1115 if (cmd->dir == UB_DIR_NONE || cmd->nsg < 1) {
1116 ub_state_stat(sc, cmd);
1117 return;
1118 }
1119
1120
1121 ub_data_start(sc, cmd);
1122
1123 } else if (cmd->state == UB_CMDST_DATA) {
1124 if (urb->status == -EPIPE) {
1125 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1126 if (rc != 0) {
1127 printk(KERN_NOTICE "%s: "
1128 "unable to submit clear (%d)\n",
1129 sc->name, rc);
1130 ub_state_done(sc, cmd, rc);
1131 return;
1132 }
1133 cmd->state = UB_CMDST_CLR2STS;
1134 return;
1135 }
1136 if (urb->status == -EOVERFLOW) {
1137
1138
1139
1140 cmd->error = -EOVERFLOW;
1141 ub_state_stat(sc, cmd);
1142 return;
1143 }
1144
1145 if (cmd->dir == UB_DIR_WRITE) {
1146
1147
1148
1149
1150
1151
1152
1153
1154 len = urb->actual_length;
1155 if (urb->status != 0 ||
1156 len != cmd->sgv[cmd->current_sg].length) {
1157 cmd->act_len += len;
1158
1159 cmd->error = -EIO;
1160 ub_state_stat(sc, cmd);
1161 return;
1162 }
1163
1164 } else {
1165
1166
1167
1168
1169
1170
1171
1172 if (urb->status != 0)
1173 cmd->error = -EIO;
1174
1175 len = urb->actual_length;
1176 if (urb->status != 0 ||
1177 len != cmd->sgv[cmd->current_sg].length) {
1178 if ((len & 0x1FF) == US_BULK_CS_WRAP_LEN)
1179 goto Bad_End;
1180 }
1181 }
1182
1183 cmd->act_len += urb->actual_length;
1184
1185 if (++cmd->current_sg < cmd->nsg) {
1186 ub_data_start(sc, cmd);
1187 return;
1188 }
1189 ub_state_stat(sc, cmd);
1190
1191 } else if (cmd->state == UB_CMDST_STAT) {
1192 if (urb->status == -EPIPE) {
1193 rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
1194 if (rc != 0) {
1195 printk(KERN_NOTICE "%s: "
1196 "unable to submit clear (%d)\n",
1197 sc->name, rc);
1198 ub_state_done(sc, cmd, rc);
1199 return;
1200 }
1201
1202
1203
1204
1205
1206 cmd->error = -EIO;
1207
1208 cmd->state = UB_CMDST_CLRRS;
1209 return;
1210 }
1211
1212
1213 if (urb->status != 0)
1214 goto Bad_End;
1215
1216 if (urb->actual_length == 0) {
1217 ub_state_stat_counted(sc, cmd);
1218 return;
1219 }
1220
1221
1222
1223
1224
1225
1226 bcs = &sc->work_bcs;
1227
1228 if (sc->signature == cpu_to_le32(0)) {
1229
1230
1231
1232
1233
1234 sc->signature = bcs->Signature;
1235 if (sc->signature == cpu_to_le32(0)) {
1236 ub_state_stat_counted(sc, cmd);
1237 return;
1238 }
1239 } else {
1240 if (bcs->Signature != sc->signature) {
1241 ub_state_stat_counted(sc, cmd);
1242 return;
1243 }
1244 }
1245
1246 if (bcs->Tag != cmd->tag) {
1247
1248
1249
1250
1251
1252
1253
1254 ub_state_stat_counted(sc, cmd);
1255 return;
1256 }
1257
1258 if (!sc->bad_resid) {
1259 len = le32_to_cpu(bcs->Residue);
1260 if (len != cmd->len - cmd->act_len) {
1261
1262
1263
1264 if (cmd->len == cmd->act_len) {
1265 printk(KERN_NOTICE "%s: "
1266 "bad residual %d of %d, ignoring\n",
1267 sc->name, len, cmd->len);
1268 sc->bad_resid = 1;
1269 }
1270 }
1271 }
1272
1273 switch (bcs->Status) {
1274 case US_BULK_STAT_OK:
1275 break;
1276 case US_BULK_STAT_FAIL:
1277 ub_state_sense(sc, cmd);
1278 return;
1279 case US_BULK_STAT_PHASE:
1280 goto Bad_End;
1281 default:
1282 printk(KERN_INFO "%s: unknown CSW status 0x%x\n",
1283 sc->name, bcs->Status);
1284 ub_state_done(sc, cmd, -EINVAL);
1285 return;
1286 }
1287
1288
1289 if (cmd->error != 0) {
1290 ub_state_sense(sc, cmd);
1291 return;
1292 }
1293 cmd->state = UB_CMDST_DONE;
1294 ub_cmdq_pop(sc);
1295 (*cmd->done)(sc, cmd);
1296
1297 } else if (cmd->state == UB_CMDST_SENSE) {
1298 ub_state_done(sc, cmd, -EIO);
1299
1300 } else {
1301 printk(KERN_WARNING "%s: wrong command state %d\n",
1302 sc->name, cmd->state);
1303 ub_state_done(sc, cmd, -EINVAL);
1304 return;
1305 }
1306 return;
1307
1308Bad_End:
1309 ub_state_done(sc, cmd, -EIO);
1310}
1311
1312
1313
1314
1315
1316static void ub_data_start(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1317{
1318 struct scatterlist *sg = &cmd->sgv[cmd->current_sg];
1319 int pipe;
1320 int rc;
1321
1322 UB_INIT_COMPLETION(sc->work_done);
1323
1324 if (cmd->dir == UB_DIR_READ)
1325 pipe = sc->recv_bulk_pipe;
1326 else
1327 pipe = sc->send_bulk_pipe;
1328 sc->last_pipe = pipe;
1329 usb_fill_bulk_urb(&sc->work_urb, sc->dev, pipe, sg_virt(sg),
1330 sg->length, ub_urb_complete, sc);
1331
1332 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1333
1334 ub_complete(&sc->work_done);
1335 ub_state_done(sc, cmd, rc);
1336 return;
1337 }
1338
1339 if (cmd->timeo)
1340 sc->work_timer.expires = jiffies + cmd->timeo;
1341 else
1342 sc->work_timer.expires = jiffies + UB_DATA_TIMEOUT;
1343 add_timer(&sc->work_timer);
1344
1345 cmd->state = UB_CMDST_DATA;
1346}
1347
1348
1349
1350
1351
1352static void ub_state_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd, int rc)
1353{
1354
1355 cmd->error = rc;
1356 cmd->state = UB_CMDST_DONE;
1357 ub_cmdq_pop(sc);
1358 (*cmd->done)(sc, cmd);
1359}
1360
1361
1362
1363
1364
1365static int __ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1366{
1367 int rc;
1368
1369 UB_INIT_COMPLETION(sc->work_done);
1370
1371 sc->last_pipe = sc->recv_bulk_pipe;
1372 usb_fill_bulk_urb(&sc->work_urb, sc->dev, sc->recv_bulk_pipe,
1373 &sc->work_bcs, US_BULK_CS_WRAP_LEN, ub_urb_complete, sc);
1374
1375 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1376
1377 ub_complete(&sc->work_done);
1378 ub_state_done(sc, cmd, rc);
1379 return -1;
1380 }
1381
1382 if (cmd->timeo)
1383 sc->work_timer.expires = jiffies + cmd->timeo;
1384 else
1385 sc->work_timer.expires = jiffies + UB_STAT_TIMEOUT;
1386 add_timer(&sc->work_timer);
1387 return 0;
1388}
1389
1390
1391
1392
1393
1394static void ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1395{
1396
1397 if (__ub_state_stat(sc, cmd) != 0)
1398 return;
1399
1400 cmd->stat_count = 0;
1401 cmd->state = UB_CMDST_STAT;
1402}
1403
1404
1405
1406
1407
1408static void ub_state_stat_counted(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1409{
1410
1411 if (++cmd->stat_count >= 4) {
1412 ub_state_sense(sc, cmd);
1413 return;
1414 }
1415
1416 if (__ub_state_stat(sc, cmd) != 0)
1417 return;
1418
1419 cmd->state = UB_CMDST_STAT;
1420}
1421
1422
1423
1424
1425
1426static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1427{
1428 struct ub_scsi_cmd *scmd;
1429 struct scatterlist *sg;
1430 int rc;
1431
1432 if (cmd->cdb[0] == REQUEST_SENSE) {
1433 rc = -EPIPE;
1434 goto error;
1435 }
1436
1437 scmd = &sc->top_rqs_cmd;
1438 memset(scmd, 0, sizeof(struct ub_scsi_cmd));
1439 scmd->cdb[0] = REQUEST_SENSE;
1440 scmd->cdb[4] = UB_SENSE_SIZE;
1441 scmd->cdb_len = 6;
1442 scmd->dir = UB_DIR_READ;
1443 scmd->state = UB_CMDST_INIT;
1444 scmd->nsg = 1;
1445 sg = &scmd->sgv[0];
1446 sg_init_table(sg, UB_MAX_REQ_SG);
1447 sg_set_page(sg, virt_to_page(sc->top_sense), UB_SENSE_SIZE,
1448 (unsigned long)sc->top_sense & (PAGE_SIZE-1));
1449 scmd->len = UB_SENSE_SIZE;
1450 scmd->lun = cmd->lun;
1451 scmd->done = ub_top_sense_done;
1452 scmd->back = cmd;
1453
1454 scmd->tag = sc->tagcnt++;
1455
1456 cmd->state = UB_CMDST_SENSE;
1457
1458 ub_cmdq_insert(sc, scmd);
1459 return;
1460
1461error:
1462 ub_state_done(sc, cmd, rc);
1463}
1464
1465
1466
1467
1468
1469static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
1470 int stalled_pipe)
1471{
1472 int endp;
1473 struct usb_ctrlrequest *cr;
1474 int rc;
1475
1476 endp = usb_pipeendpoint(stalled_pipe);
1477 if (usb_pipein (stalled_pipe))
1478 endp |= USB_DIR_IN;
1479
1480 cr = &sc->work_cr;
1481 cr->bRequestType = USB_RECIP_ENDPOINT;
1482 cr->bRequest = USB_REQ_CLEAR_FEATURE;
1483 cr->wValue = cpu_to_le16(USB_ENDPOINT_HALT);
1484 cr->wIndex = cpu_to_le16(endp);
1485 cr->wLength = cpu_to_le16(0);
1486
1487 UB_INIT_COMPLETION(sc->work_done);
1488
1489 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->send_ctrl_pipe,
1490 (unsigned char*) cr, NULL, 0, ub_urb_complete, sc);
1491
1492 if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
1493 ub_complete(&sc->work_done);
1494 return rc;
1495 }
1496
1497 sc->work_timer.expires = jiffies + UB_CTRL_TIMEOUT;
1498 add_timer(&sc->work_timer);
1499 return 0;
1500}
1501
1502
1503
1504static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd)
1505{
1506 unsigned char *sense = sc->top_sense;
1507 struct ub_scsi_cmd *cmd;
1508
1509
1510
1511
1512
1513 if ((cmd = ub_cmdq_peek(sc)) == NULL) {
1514 printk(KERN_WARNING "%s: sense done while idle\n", sc->name);
1515 return;
1516 }
1517 if (cmd != scmd->back) {
1518 printk(KERN_WARNING "%s: "
1519 "sense done for wrong command 0x%x\n",
1520 sc->name, cmd->tag);
1521 return;
1522 }
1523 if (cmd->state != UB_CMDST_SENSE) {
1524 printk(KERN_WARNING "%s: sense done with bad cmd state %d\n",
1525 sc->name, cmd->state);
1526 return;
1527 }
1528
1529
1530
1531
1532 cmd->key = sense[2] & 0x0F;
1533 cmd->asc = sense[12];
1534 cmd->ascq = sense[13];
1535
1536 ub_scsi_urb_compl(sc, cmd);
1537}
1538
1539
1540
1541
1542
1543static void ub_reset_enter(struct ub_dev *sc, int try)
1544{
1545
1546 if (sc->reset) {
1547
1548 return;
1549 }
1550 sc->reset = try + 1;
1551
1552#if 0
1553 unsigned long flags;
1554 spin_lock_irqsave(&ub_lock, flags);
1555 sc->openc++;
1556 spin_unlock_irqrestore(&ub_lock, flags);
1557#endif
1558
1559#if 0
1560 struct ub_lun *lun;
1561 list_for_each_entry(lun, &sc->luns, link) {
1562 blk_stop_queue(lun->disk->queue);
1563 }
1564#endif
1565
1566 schedule_work(&sc->reset_work);
1567}
1568
1569static void ub_reset_task(struct work_struct *work)
1570{
1571 struct ub_dev *sc = container_of(work, struct ub_dev, reset_work);
1572 unsigned long flags;
1573 struct ub_lun *lun;
1574 int rc;
1575
1576 if (!sc->reset) {
1577 printk(KERN_WARNING "%s: Running reset unrequested\n",
1578 sc->name);
1579 return;
1580 }
1581
1582 if (atomic_read(&sc->poison)) {
1583 ;
1584 } else if ((sc->reset & 1) == 0) {
1585 ub_sync_reset(sc);
1586 msleep(700);
1587 ub_probe_clear_stall(sc, sc->recv_bulk_pipe);
1588 ub_probe_clear_stall(sc, sc->send_bulk_pipe);
1589 } else if (sc->dev->actconfig->desc.bNumInterfaces != 1) {
1590 ;
1591 } else {
1592 rc = usb_lock_device_for_reset(sc->dev, sc->intf);
1593 if (rc < 0) {
1594 printk(KERN_NOTICE
1595 "%s: usb_lock_device_for_reset failed (%d)\n",
1596 sc->name, rc);
1597 } else {
1598 rc = usb_reset_device(sc->dev);
1599 if (rc < 0) {
1600 printk(KERN_NOTICE "%s: "
1601 "usb_lock_device_for_reset failed (%d)\n",
1602 sc->name, rc);
1603 }
1604 usb_unlock_device(sc->dev);
1605 }
1606 }
1607
1608
1609
1610
1611
1612
1613
1614 spin_lock_irqsave(sc->lock, flags);
1615 sc->reset = 0;
1616 tasklet_schedule(&sc->tasklet);
1617 list_for_each_entry(lun, &sc->luns, link) {
1618 blk_start_queue(lun->disk->queue);
1619 }
1620 wake_up(&sc->reset_wait);
1621 spin_unlock_irqrestore(sc->lock, flags);
1622}
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632static int ub_pre_reset(struct usb_interface *iface) {
1633 return 0;
1634}
1635
1636static int ub_post_reset(struct usb_interface *iface) {
1637 return 0;
1638}
1639
1640
1641
1642
1643static void ub_revalidate(struct ub_dev *sc, struct ub_lun *lun)
1644{
1645
1646 lun->readonly = 0;
1647
1648 lun->capacity.nsec = 0;
1649 lun->capacity.bsize = 512;
1650 lun->capacity.bshift = 0;
1651
1652 if (ub_sync_tur(sc, lun) != 0)
1653 return;
1654 lun->changed = 0;
1655
1656 if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
1657
1658
1659
1660
1661
1662 if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
1663 lun->capacity.nsec = 0;
1664 lun->capacity.bsize = 512;
1665 lun->capacity.bshift = 0;
1666 }
1667 }
1668}
1669
1670
1671
1672
1673
1674
1675static int ub_bd_open(struct block_device *bdev, fmode_t mode)
1676{
1677 struct ub_lun *lun = bdev->bd_disk->private_data;
1678 struct ub_dev *sc = lun->udev;
1679 unsigned long flags;
1680 int rc;
1681
1682 spin_lock_irqsave(&ub_lock, flags);
1683 if (atomic_read(&sc->poison)) {
1684 spin_unlock_irqrestore(&ub_lock, flags);
1685 return -ENXIO;
1686 }
1687 sc->openc++;
1688 spin_unlock_irqrestore(&ub_lock, flags);
1689
1690 if (lun->removable || lun->readonly)
1691 check_disk_change(bdev);
1692
1693
1694
1695
1696
1697
1698 if (lun->removable && lun->changed && !(mode & FMODE_NDELAY)) {
1699 rc = -ENOMEDIUM;
1700 goto err_open;
1701 }
1702
1703 if (lun->readonly && (mode & FMODE_WRITE)) {
1704 rc = -EROFS;
1705 goto err_open;
1706 }
1707
1708 return 0;
1709
1710err_open:
1711 ub_put(sc);
1712 return rc;
1713}
1714
1715static int ub_bd_unlocked_open(struct block_device *bdev, fmode_t mode)
1716{
1717 int ret;
1718
1719 mutex_lock(&ub_mutex);
1720 ret = ub_bd_open(bdev, mode);
1721 mutex_unlock(&ub_mutex);
1722
1723 return ret;
1724}
1725
1726
1727
1728
1729static int ub_bd_release(struct gendisk *disk, fmode_t mode)
1730{
1731 struct ub_lun *lun = disk->private_data;
1732 struct ub_dev *sc = lun->udev;
1733
1734 mutex_lock(&ub_mutex);
1735 ub_put(sc);
1736 mutex_unlock(&ub_mutex);
1737
1738 return 0;
1739}
1740
1741
1742
1743
1744static int ub_bd_ioctl(struct block_device *bdev, fmode_t mode,
1745 unsigned int cmd, unsigned long arg)
1746{
1747 struct gendisk *disk = bdev->bd_disk;
1748 void __user *usermem = (void __user *) arg;
1749 int ret;
1750
1751 mutex_lock(&ub_mutex);
1752 ret = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, usermem);
1753 mutex_unlock(&ub_mutex);
1754
1755 return ret;
1756}
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768static int ub_bd_revalidate(struct gendisk *disk)
1769{
1770 struct ub_lun *lun = disk->private_data;
1771
1772 ub_revalidate(lun->udev, lun);
1773
1774
1775 blk_queue_logical_block_size(disk->queue, lun->capacity.bsize);
1776 set_capacity(disk, lun->capacity.nsec);
1777
1778
1779 return 0;
1780}
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791static unsigned int ub_bd_check_events(struct gendisk *disk,
1792 unsigned int clearing)
1793{
1794 struct ub_lun *lun = disk->private_data;
1795
1796 if (!lun->removable)
1797 return 0;
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808 if (ub_sync_tur(lun->udev, lun) != 0) {
1809 lun->changed = 1;
1810 return DISK_EVENT_MEDIA_CHANGE;
1811 }
1812
1813 return lun->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
1814}
1815
1816static const struct block_device_operations ub_bd_fops = {
1817 .owner = THIS_MODULE,
1818 .open = ub_bd_unlocked_open,
1819 .release = ub_bd_release,
1820 .ioctl = ub_bd_ioctl,
1821 .check_events = ub_bd_check_events,
1822 .revalidate_disk = ub_bd_revalidate,
1823};
1824
1825
1826
1827
1828static void ub_probe_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
1829{
1830 struct completion *cop = cmd->back;
1831 complete(cop);
1832}
1833
1834
1835
1836
1837static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun)
1838{
1839 struct ub_scsi_cmd *cmd;
1840 enum { ALLOC_SIZE = sizeof(struct ub_scsi_cmd) };
1841 unsigned long flags;
1842 struct completion compl;
1843 int rc;
1844
1845 init_completion(&compl);
1846
1847 rc = -ENOMEM;
1848 if ((cmd = kzalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
1849 goto err_alloc;
1850
1851 cmd->cdb[0] = TEST_UNIT_READY;
1852 cmd->cdb_len = 6;
1853 cmd->dir = UB_DIR_NONE;
1854 cmd->state = UB_CMDST_INIT;
1855 cmd->lun = lun;
1856 cmd->done = ub_probe_done;
1857 cmd->back = &compl;
1858
1859 spin_lock_irqsave(sc->lock, flags);
1860 cmd->tag = sc->tagcnt++;
1861
1862 rc = ub_submit_scsi(sc, cmd);
1863 spin_unlock_irqrestore(sc->lock, flags);
1864
1865 if (rc != 0)
1866 goto err_submit;
1867
1868 wait_for_completion(&compl);
1869
1870 rc = cmd->error;
1871
1872 if (rc == -EIO && cmd->key != 0)
1873 rc = cmd->key;
1874
1875err_submit:
1876 kfree(cmd);
1877err_alloc:
1878 return rc;
1879}
1880
1881
1882
1883
1884static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
1885 struct ub_capacity *ret)
1886{
1887 struct ub_scsi_cmd *cmd;
1888 struct scatterlist *sg;
1889 char *p;
1890 enum { ALLOC_SIZE = sizeof(struct ub_scsi_cmd) + 8 };
1891 unsigned long flags;
1892 unsigned int bsize, shift;
1893 unsigned long nsec;
1894 struct completion compl;
1895 int rc;
1896
1897 init_completion(&compl);
1898
1899 rc = -ENOMEM;
1900 if ((cmd = kzalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
1901 goto err_alloc;
1902 p = (char *)cmd + sizeof(struct ub_scsi_cmd);
1903
1904 cmd->cdb[0] = 0x25;
1905 cmd->cdb_len = 10;
1906 cmd->dir = UB_DIR_READ;
1907 cmd->state = UB_CMDST_INIT;
1908 cmd->nsg = 1;
1909 sg = &cmd->sgv[0];
1910 sg_init_table(sg, UB_MAX_REQ_SG);
1911 sg_set_page(sg, virt_to_page(p), 8, (unsigned long)p & (PAGE_SIZE-1));
1912 cmd->len = 8;
1913 cmd->lun = lun;
1914 cmd->done = ub_probe_done;
1915 cmd->back = &compl;
1916
1917 spin_lock_irqsave(sc->lock, flags);
1918 cmd->tag = sc->tagcnt++;
1919
1920 rc = ub_submit_scsi(sc, cmd);
1921 spin_unlock_irqrestore(sc->lock, flags);
1922
1923 if (rc != 0)
1924 goto err_submit;
1925
1926 wait_for_completion(&compl);
1927
1928 if (cmd->error != 0) {
1929 rc = -EIO;
1930 goto err_read;
1931 }
1932 if (cmd->act_len != 8) {
1933 rc = -EIO;
1934 goto err_read;
1935 }
1936
1937
1938 nsec = be32_to_cpu(*(__be32 *)p) + 1;
1939 bsize = be32_to_cpu(*(__be32 *)(p + 4));
1940 switch (bsize) {
1941 case 512: shift = 0; break;
1942 case 1024: shift = 1; break;
1943 case 2048: shift = 2; break;
1944 case 4096: shift = 3; break;
1945 default:
1946 rc = -EDOM;
1947 goto err_inv_bsize;
1948 }
1949
1950 ret->bsize = bsize;
1951 ret->bshift = shift;
1952 ret->nsec = nsec << shift;
1953 rc = 0;
1954
1955err_inv_bsize:
1956err_read:
1957err_submit:
1958 kfree(cmd);
1959err_alloc:
1960 return rc;
1961}
1962
1963
1964
1965static void ub_probe_urb_complete(struct urb *urb)
1966{
1967 struct completion *cop = urb->context;
1968 complete(cop);
1969}
1970
1971static void ub_probe_timeout(unsigned long arg)
1972{
1973 struct completion *cop = (struct completion *) arg;
1974 complete(cop);
1975}
1976
1977
1978
1979
1980static int ub_sync_reset(struct ub_dev *sc)
1981{
1982 int ifnum = sc->intf->cur_altsetting->desc.bInterfaceNumber;
1983 struct usb_ctrlrequest *cr;
1984 struct completion compl;
1985 struct timer_list timer;
1986 int rc;
1987
1988 init_completion(&compl);
1989
1990 cr = &sc->work_cr;
1991 cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
1992 cr->bRequest = US_BULK_RESET_REQUEST;
1993 cr->wValue = cpu_to_le16(0);
1994 cr->wIndex = cpu_to_le16(ifnum);
1995 cr->wLength = cpu_to_le16(0);
1996
1997 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->send_ctrl_pipe,
1998 (unsigned char*) cr, NULL, 0, ub_probe_urb_complete, &compl);
1999
2000 if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0) {
2001 printk(KERN_WARNING
2002 "%s: Unable to submit a bulk reset (%d)\n", sc->name, rc);
2003 return rc;
2004 }
2005
2006 init_timer(&timer);
2007 timer.function = ub_probe_timeout;
2008 timer.data = (unsigned long) &compl;
2009 timer.expires = jiffies + UB_CTRL_TIMEOUT;
2010 add_timer(&timer);
2011
2012 wait_for_completion(&compl);
2013
2014 del_timer_sync(&timer);
2015 usb_kill_urb(&sc->work_urb);
2016
2017 return sc->work_urb.status;
2018}
2019
2020
2021
2022
2023static int ub_sync_getmaxlun(struct ub_dev *sc)
2024{
2025 int ifnum = sc->intf->cur_altsetting->desc.bInterfaceNumber;
2026 unsigned char *p;
2027 enum { ALLOC_SIZE = 1 };
2028 struct usb_ctrlrequest *cr;
2029 struct completion compl;
2030 struct timer_list timer;
2031 int nluns;
2032 int rc;
2033
2034 init_completion(&compl);
2035
2036 rc = -ENOMEM;
2037 if ((p = kmalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
2038 goto err_alloc;
2039 *p = 55;
2040
2041 cr = &sc->work_cr;
2042 cr->bRequestType = USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
2043 cr->bRequest = US_BULK_GET_MAX_LUN;
2044 cr->wValue = cpu_to_le16(0);
2045 cr->wIndex = cpu_to_le16(ifnum);
2046 cr->wLength = cpu_to_le16(1);
2047
2048 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->recv_ctrl_pipe,
2049 (unsigned char*) cr, p, 1, ub_probe_urb_complete, &compl);
2050
2051 if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0)
2052 goto err_submit;
2053
2054 init_timer(&timer);
2055 timer.function = ub_probe_timeout;
2056 timer.data = (unsigned long) &compl;
2057 timer.expires = jiffies + UB_CTRL_TIMEOUT;
2058 add_timer(&timer);
2059
2060 wait_for_completion(&compl);
2061
2062 del_timer_sync(&timer);
2063 usb_kill_urb(&sc->work_urb);
2064
2065 if ((rc = sc->work_urb.status) < 0)
2066 goto err_io;
2067
2068 if (sc->work_urb.actual_length != 1) {
2069 nluns = 0;
2070 } else {
2071 if ((nluns = *p) == 55) {
2072 nluns = 0;
2073 } else {
2074
2075 nluns += 1;
2076 if (nluns > UB_MAX_LUNS)
2077 nluns = UB_MAX_LUNS;
2078 }
2079 }
2080
2081 kfree(p);
2082 return nluns;
2083
2084err_io:
2085err_submit:
2086 kfree(p);
2087err_alloc:
2088 return rc;
2089}
2090
2091
2092
2093
2094static int ub_probe_clear_stall(struct ub_dev *sc, int stalled_pipe)
2095{
2096 int endp;
2097 struct usb_ctrlrequest *cr;
2098 struct completion compl;
2099 struct timer_list timer;
2100 int rc;
2101
2102 init_completion(&compl);
2103
2104 endp = usb_pipeendpoint(stalled_pipe);
2105 if (usb_pipein (stalled_pipe))
2106 endp |= USB_DIR_IN;
2107
2108 cr = &sc->work_cr;
2109 cr->bRequestType = USB_RECIP_ENDPOINT;
2110 cr->bRequest = USB_REQ_CLEAR_FEATURE;
2111 cr->wValue = cpu_to_le16(USB_ENDPOINT_HALT);
2112 cr->wIndex = cpu_to_le16(endp);
2113 cr->wLength = cpu_to_le16(0);
2114
2115 usb_fill_control_urb(&sc->work_urb, sc->dev, sc->send_ctrl_pipe,
2116 (unsigned char*) cr, NULL, 0, ub_probe_urb_complete, &compl);
2117
2118 if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0) {
2119 printk(KERN_WARNING
2120 "%s: Unable to submit a probe clear (%d)\n", sc->name, rc);
2121 return rc;
2122 }
2123
2124 init_timer(&timer);
2125 timer.function = ub_probe_timeout;
2126 timer.data = (unsigned long) &compl;
2127 timer.expires = jiffies + UB_CTRL_TIMEOUT;
2128 add_timer(&timer);
2129
2130 wait_for_completion(&compl);
2131
2132 del_timer_sync(&timer);
2133 usb_kill_urb(&sc->work_urb);
2134
2135 usb_reset_endpoint(sc->dev, endp);
2136
2137 return 0;
2138}
2139
2140
2141
2142
2143static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev,
2144 struct usb_interface *intf)
2145{
2146 struct usb_host_interface *altsetting = intf->cur_altsetting;
2147 struct usb_endpoint_descriptor *ep_in = NULL;
2148 struct usb_endpoint_descriptor *ep_out = NULL;
2149 struct usb_endpoint_descriptor *ep;
2150 int i;
2151
2152
2153
2154
2155
2156
2157 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
2158 ep = &altsetting->endpoint[i].desc;
2159
2160
2161 if (usb_endpoint_xfer_bulk(ep)) {
2162
2163 if (usb_endpoint_dir_in(ep)) {
2164 if (ep_in == NULL)
2165 ep_in = ep;
2166 } else {
2167 if (ep_out == NULL)
2168 ep_out = ep;
2169 }
2170 }
2171 }
2172
2173 if (ep_in == NULL || ep_out == NULL) {
2174 printk(KERN_NOTICE "%s: failed endpoint check\n", sc->name);
2175 return -ENODEV;
2176 }
2177
2178
2179 sc->send_ctrl_pipe = usb_sndctrlpipe(dev, 0);
2180 sc->recv_ctrl_pipe = usb_rcvctrlpipe(dev, 0);
2181 sc->send_bulk_pipe = usb_sndbulkpipe(dev,
2182 usb_endpoint_num(ep_out));
2183 sc->recv_bulk_pipe = usb_rcvbulkpipe(dev,
2184 usb_endpoint_num(ep_in));
2185
2186 return 0;
2187}
2188
2189
2190
2191
2192
2193static int ub_probe(struct usb_interface *intf,
2194 const struct usb_device_id *dev_id)
2195{
2196 struct ub_dev *sc;
2197 int nluns;
2198 int rc;
2199 int i;
2200
2201 if (usb_usual_check_type(dev_id, USB_US_TYPE_UB))
2202 return -ENXIO;
2203
2204 rc = -ENOMEM;
2205 if ((sc = kzalloc(sizeof(struct ub_dev), GFP_KERNEL)) == NULL)
2206 goto err_core;
2207 sc->lock = ub_next_lock();
2208 INIT_LIST_HEAD(&sc->luns);
2209 usb_init_urb(&sc->work_urb);
2210 tasklet_init(&sc->tasklet, ub_scsi_action, (unsigned long)sc);
2211 atomic_set(&sc->poison, 0);
2212 INIT_WORK(&sc->reset_work, ub_reset_task);
2213 init_waitqueue_head(&sc->reset_wait);
2214
2215 init_timer(&sc->work_timer);
2216 sc->work_timer.data = (unsigned long) sc;
2217 sc->work_timer.function = ub_urb_timeout;
2218
2219 ub_init_completion(&sc->work_done);
2220 sc->work_done.done = 1;
2221
2222 sc->dev = interface_to_usbdev(intf);
2223 sc->intf = intf;
2224
2225 usb_set_intfdata(intf, sc);
2226 usb_get_dev(sc->dev);
2227
2228
2229
2230
2231
2232 usb_get_intf(sc->intf);
2233
2234 snprintf(sc->name, 12, DRV_NAME "(%d.%d)",
2235 sc->dev->bus->busnum, sc->dev->devnum);
2236
2237
2238
2239 if (ub_get_pipes(sc, sc->dev, intf) != 0)
2240 goto err_dev_desc;
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253#if 0
2254 ub_probe_clear_stall(sc, sc->recv_bulk_pipe);
2255 ub_probe_clear_stall(sc, sc->send_bulk_pipe);
2256#endif
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273 for (i = 0; i < 3; i++) {
2274 if ((rc = ub_sync_tur(sc, NULL)) <= 0) break;
2275 if (rc != 0x6) break;
2276 msleep(10);
2277 }
2278
2279 nluns = 1;
2280 for (i = 0; i < 3; i++) {
2281 if ((rc = ub_sync_getmaxlun(sc)) < 0)
2282 break;
2283 if (rc != 0) {
2284 nluns = rc;
2285 break;
2286 }
2287 msleep(100);
2288 }
2289
2290 for (i = 0; i < nluns; i++) {
2291 ub_probe_lun(sc, i);
2292 }
2293 return 0;
2294
2295err_dev_desc:
2296 usb_set_intfdata(intf, NULL);
2297 usb_put_intf(sc->intf);
2298 usb_put_dev(sc->dev);
2299 kfree(sc);
2300err_core:
2301 return rc;
2302}
2303
2304static int ub_probe_lun(struct ub_dev *sc, int lnum)
2305{
2306 struct ub_lun *lun;
2307 struct request_queue *q;
2308 struct gendisk *disk;
2309 int rc;
2310
2311 rc = -ENOMEM;
2312 if ((lun = kzalloc(sizeof(struct ub_lun), GFP_KERNEL)) == NULL)
2313 goto err_alloc;
2314 lun->num = lnum;
2315
2316 rc = -ENOSR;
2317 if ((lun->id = ub_id_get()) == -1)
2318 goto err_id;
2319
2320 lun->udev = sc;
2321
2322 snprintf(lun->name, 16, DRV_NAME "%c(%d.%d.%d)",
2323 lun->id + 'a', sc->dev->bus->busnum, sc->dev->devnum, lun->num);
2324
2325 lun->removable = 1;
2326 lun->changed = 1;
2327 ub_revalidate(sc, lun);
2328
2329 rc = -ENOMEM;
2330 if ((disk = alloc_disk(UB_PARTS_PER_LUN)) == NULL)
2331 goto err_diskalloc;
2332
2333 sprintf(disk->disk_name, DRV_NAME "%c", lun->id + 'a');
2334 disk->major = UB_MAJOR;
2335 disk->first_minor = lun->id * UB_PARTS_PER_LUN;
2336 disk->fops = &ub_bd_fops;
2337 disk->private_data = lun;
2338 disk->driverfs_dev = &sc->intf->dev;
2339
2340 rc = -ENOMEM;
2341 if ((q = blk_init_queue(ub_request_fn, sc->lock)) == NULL)
2342 goto err_blkqinit;
2343
2344 disk->queue = q;
2345
2346 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
2347 blk_queue_max_segments(q, UB_MAX_REQ_SG);
2348 blk_queue_segment_boundary(q, 0xffffffff);
2349 blk_queue_max_hw_sectors(q, UB_MAX_SECTORS);
2350 blk_queue_logical_block_size(q, lun->capacity.bsize);
2351
2352 lun->disk = disk;
2353 q->queuedata = lun;
2354 list_add(&lun->link, &sc->luns);
2355
2356 set_capacity(disk, lun->capacity.nsec);
2357 if (lun->removable)
2358 disk->flags |= GENHD_FL_REMOVABLE;
2359
2360 add_disk(disk);
2361
2362 return 0;
2363
2364err_blkqinit:
2365 put_disk(disk);
2366err_diskalloc:
2367 ub_id_put(lun->id);
2368err_id:
2369 kfree(lun);
2370err_alloc:
2371 return rc;
2372}
2373
2374static void ub_disconnect(struct usb_interface *intf)
2375{
2376 struct ub_dev *sc = usb_get_intfdata(intf);
2377 struct ub_lun *lun;
2378 unsigned long flags;
2379
2380
2381
2382
2383
2384
2385 spin_lock_irqsave(&ub_lock, flags);
2386 sc->openc++;
2387 spin_unlock_irqrestore(&ub_lock, flags);
2388
2389
2390
2391
2392
2393
2394 atomic_set(&sc->poison, 1);
2395
2396
2397
2398
2399 wait_event(sc->reset_wait, !sc->reset);
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410 spin_lock_irqsave(sc->lock, flags);
2411 {
2412 struct ub_scsi_cmd *cmd;
2413 int cnt = 0;
2414 while ((cmd = ub_cmdq_peek(sc)) != NULL) {
2415 cmd->error = -ENOTCONN;
2416 cmd->state = UB_CMDST_DONE;
2417 ub_cmdq_pop(sc);
2418 (*cmd->done)(sc, cmd);
2419 cnt++;
2420 }
2421 if (cnt != 0) {
2422 printk(KERN_WARNING "%s: "
2423 "%d was queued after shutdown\n", sc->name, cnt);
2424 }
2425 }
2426 spin_unlock_irqrestore(sc->lock, flags);
2427
2428
2429
2430
2431 list_for_each_entry(lun, &sc->luns, link) {
2432 del_gendisk(lun->disk);
2433
2434
2435
2436
2437
2438
2439 }
2440
2441
2442
2443
2444
2445 spin_lock_irqsave(sc->lock, flags);
2446 if (sc->work_urb.status == -EINPROGRESS) {
2447 printk(KERN_WARNING "%s: "
2448 "URB is active after disconnect\n", sc->name);
2449 }
2450 spin_unlock_irqrestore(sc->lock, flags);
2451
2452
2453
2454
2455
2456
2457 del_timer_sync(&sc->work_timer);
2458
2459
2460
2461
2462
2463
2464 ub_put(sc);
2465}
2466
2467static struct usb_driver ub_driver = {
2468 .name = "ub",
2469 .probe = ub_probe,
2470 .disconnect = ub_disconnect,
2471 .id_table = ub_usb_ids,
2472 .pre_reset = ub_pre_reset,
2473 .post_reset = ub_post_reset,
2474};
2475
2476static int __init ub_init(void)
2477{
2478 int rc;
2479 int i;
2480
2481 for (i = 0; i < UB_QLOCK_NUM; i++)
2482 spin_lock_init(&ub_qlockv[i]);
2483
2484 if ((rc = register_blkdev(UB_MAJOR, DRV_NAME)) != 0)
2485 goto err_regblkdev;
2486
2487 if ((rc = usb_register(&ub_driver)) != 0)
2488 goto err_register;
2489
2490 usb_usual_set_present(USB_US_TYPE_UB);
2491 return 0;
2492
2493err_register:
2494 unregister_blkdev(UB_MAJOR, DRV_NAME);
2495err_regblkdev:
2496 return rc;
2497}
2498
2499static void __exit ub_exit(void)
2500{
2501 usb_deregister(&ub_driver);
2502
2503 unregister_blkdev(UB_MAJOR, DRV_NAME);
2504 usb_usual_clear_present(USB_US_TYPE_UB);
2505}
2506
2507module_init(ub_init);
2508module_exit(ub_exit);
2509
2510MODULE_LICENSE("GPL");
2511