e9743985979cc87a943b42bb3dcdfccf4b1f4ac5
[dragonfly.git] / sys / dev / disk / nata / ata-usb.c
1 /*-
2  * Copyright (c) 2006 Søren Schmidt <sos@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/ata/ata-usb.c,v 1.4 2006/03/31 08:09:05 sos Exp $
27  * $DragonFly: src/sys/dev/disk/nata/ata-usb.c,v 1.6 2007/06/28 06:32:31 hasso Exp $
28  */
29
30 #include "opt_ata.h"
31
32 #include <sys/param.h>
33 #include <sys/bus.h>
34 #include <sys/libkern.h>
35 #include <sys/malloc.h>
36 #include <sys/module.h>
37 #include <sys/nata.h>
38 #include <sys/spinlock.h>
39 #include <sys/spinlock2.h>
40
41 #include <bus/usb/usb.h>
42 #include <bus/usb/usbdi.h>
43 #include <bus/usb/usbdi_util.h>
44 #include <bus/usb/usbdivar.h>
45
46 #include "ata-all.h"
47 #include "ata_if.h"
48
49 /* Command Block Wrapper */
50 struct bbb_cbw {
51     u_int8_t    signature[4];
52 #define         CBWSIGNATURE            0x43425355
53
54     u_int8_t    tag[4];
55     u_int8_t    transfer_length[4];
56     u_int8_t    flags;
57 #define         CBWFLAGS_OUT            0x00
58 #define         CBWFLAGS_IN             0x80
59
60     u_int8_t    lun;
61     u_int8_t    length;
62 #define         CBWCDBLENGTH            16
63
64     u_int8_t    cdb[CBWCDBLENGTH];
65 };
66
67 /* Command Status Wrapper */
68 struct bbb_csw {
69     u_int8_t    signature[4];
70 #define         CSWSIGNATURE            0x53425355
71
72     u_int8_t    tag[4];
73     u_int8_t    residue[4];
74     u_int8_t    status;
75 #define         CSWSTATUS_GOOD          0x0
76 #define         CSWSTATUS_FAILED        0x1
77 #define         CSWSTATUS_PHASE         0x2
78 };
79
80 /* USB-ATA 'controller' softc */
81 struct atausb_softc {
82     device_t    dev;            /* base device */
83     usbd_interface_handle iface;        /* interface */
84     int                 ifaceno;        /* interface number */
85     u_int8_t            bulkin;         /* endpoint address's */
86     u_int8_t            bulkout;        
87     u_int8_t            bulkirq;        
88     usbd_pipe_handle    bulkin_pipe;    /* pipe handle's */
89     usbd_pipe_handle    bulkout_pipe;
90     usbd_pipe_handle    bulkirq_pipe;
91     int                 maxlun;
92     int                 timeout;
93     struct ata_request  *ata_request;
94     usb_device_request_t usb_request;
95     struct bbb_cbw      cbw;
96     struct bbb_csw      csw;
97
98 #define ATAUSB_T_BBB_CBW                0
99 #define ATAUSB_T_BBB_DATA               1
100 #define ATAUSB_T_BBB_DCLEAR             2
101 #define ATAUSB_T_BBB_CSW1               3
102 #define ATAUSB_T_BBB_CSW2               4
103 #define ATAUSB_T_BBB_SCLEAR             5
104 #define ATAUSB_T_BBB_RESET1             6
105 #define ATAUSB_T_BBB_RESET2             7
106 #define ATAUSB_T_BBB_RESET3             8
107 #define ATAUSB_T_MAX                    9
108     usbd_xfer_handle    transfer[ATAUSB_T_MAX];
109
110     int                 state;
111 #define ATAUSB_S_ATTACH                 0
112 #define ATAUSB_S_IDLE                   1
113 #define ATAUSB_S_BBB_COMMAND            2
114 #define ATAUSB_S_BBB_DATA               3
115 #define ATAUSB_S_BBB_DCLEAR             4
116 #define ATAUSB_S_BBB_STATUS1            5
117 #define ATAUSB_S_BBB_SCLEAR             6
118 #define ATAUSB_S_BBB_STATUS2            7
119 #define ATAUSB_S_BBB_RESET1             8
120 #define ATAUSB_S_BBB_RESET2             9
121 #define ATAUSB_S_BBB_RESET3             10
122 #define ATAUSB_S_DETACH                 11
123
124     struct spinlock     locked_mtx;
125     struct ata_channel  *locked_ch;
126     struct ata_channel  *restart_ch;
127 };
128
129 static int atausbdebug = 0;
130
131 /* prototypes*/
132 static usbd_status atausb_start(struct atausb_softc *sc, usbd_pipe_handle pipe, void *buffer, int buflen, int flags, usbd_xfer_handle xfer);
133 static usbd_status atausb_ctl_start(struct atausb_softc *sc, usbd_device_handle udev, usb_device_request_t *req, void *buffer, int buflen, int flags, usbd_xfer_handle xfer);
134 static void atausb_clear_stall(struct atausb_softc *sc, u_int8_t endpt, usbd_pipe_handle pipe, int state, usbd_xfer_handle xfer);
135 static void atausb_bbb_reset(struct atausb_softc *sc);
136 static int atausb_bbb_start(struct ata_request *request);
137 static void atausb_bbb_finish(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status err);
138 int ata_usbchannel_begin_transaction(struct ata_request *request);
139 int ata_usbchannel_end_transaction(struct ata_request *request);
140
141
142 /*
143  * USB frontend part
144  */
145 USB_DECLARE_DRIVER(atausb);
146 DRIVER_MODULE(atausb, uhub, atausb_driver, atausb_devclass, 0, 0);
147 MODULE_VERSION(atausb, 1);
148
149 static int
150 atausb_match(device_t dev)
151 {
152     struct usb_attach_arg *uaa = device_get_ivars(dev);
153     usb_interface_descriptor_t *id;
154
155     if (uaa->iface == NULL)
156         return UMATCH_NONE;
157
158     id = usbd_get_interface_descriptor(uaa->iface);
159     if (!id || id->bInterfaceClass != UICLASS_MASS)
160         return UMATCH_NONE;
161
162     switch (id->bInterfaceSubClass) {
163     case UISUBCLASS_QIC157:
164     case UISUBCLASS_RBC:
165     case UISUBCLASS_SCSI:
166     case UISUBCLASS_SFF8020I:
167     case UISUBCLASS_SFF8070I:
168     case UISUBCLASS_UFI:
169         switch (id->bInterfaceProtocol) {
170         case UIPROTO_MASS_CBI:
171         case UIPROTO_MASS_CBI_I:
172         case UIPROTO_MASS_BBB:
173         case UIPROTO_MASS_BBB_OLD:
174             return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
175         default:
176             return UMATCH_IFACECLASS_IFACESUBCLASS;
177         }
178         break;
179     default:
180         return UMATCH_IFACECLASS;
181     }
182 }
183
184 static int
185 atausb_attach(device_t dev)
186 {
187     struct atausb_softc *sc = device_get_softc(dev);
188     struct usb_attach_arg *uaa = device_get_ivars(dev);
189     usb_interface_descriptor_t *id;
190     usb_endpoint_descriptor_t *ed;
191     usbd_device_handle udev;
192     usb_device_request_t request;
193     char devinfo[1024], *proto, *subclass;
194     u_int8_t maxlun;
195     int err, i;
196
197     sc->dev = dev;
198     usbd_devinfo(uaa->device, 0, devinfo);
199     device_set_desc_copy(dev, devinfo);
200     sc->bulkin = sc->bulkout = sc->bulkirq = -1;
201     sc->bulkin_pipe = sc->bulkout_pipe= sc->bulkirq_pipe = NULL;
202     sc->iface = uaa->iface;
203     sc->ifaceno = uaa->ifaceno;
204     sc->maxlun = 0;
205     sc->timeout = 5000;
206     sc->locked_ch = NULL;
207     sc->restart_ch = NULL;
208     spin_init(&sc->locked_mtx); 
209
210     id = usbd_get_interface_descriptor(sc->iface);
211     switch (id->bInterfaceProtocol) {
212     case UIPROTO_MASS_BBB:
213     case UIPROTO_MASS_BBB_OLD:
214             proto = "Bulk-Only";
215             break;
216     case UIPROTO_MASS_CBI:
217             proto = "CBI";
218             break;
219     case UIPROTO_MASS_CBI_I:
220             proto = "CBI with CCI";
221             break;
222     default:
223             proto = "Unknown";
224     }
225     switch (id->bInterfaceSubClass) {
226     case UISUBCLASS_RBC:
227             subclass = "RBC";
228             break;
229     case UISUBCLASS_QIC157:
230     case UISUBCLASS_SFF8020I:
231     case UISUBCLASS_SFF8070I:
232             subclass = "ATAPI";
233             break;
234     case UISUBCLASS_SCSI:
235             subclass = "SCSI";
236             break;
237     case UISUBCLASS_UFI:
238             subclass = "UFI";
239             break;
240     default:
241             subclass = "Unknown";
242     }
243     device_printf(dev, "using %s over %s\n", subclass, proto);
244     if (strcmp(proto, "Bulk-Only") ||
245         (strcmp(subclass, "ATAPI") && strcmp(subclass, "SCSI")))
246         return ENXIO;
247
248     for (i = 0 ; i < id->bNumEndpoints ; i++) {
249         if (!(ed = usbd_interface2endpoint_descriptor(sc->iface, i))) {
250             device_printf(sc->dev, "could not read endpoint descriptor\n");
251             return ENXIO;
252         }
253         if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
254             (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
255             sc->bulkin = ed->bEndpointAddress;
256         }
257         if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
258                    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
259             sc->bulkout = ed->bEndpointAddress;
260         }
261         if (id->bInterfaceProtocol == UIPROTO_MASS_CBI_I &&
262                    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
263                    (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
264             sc->bulkirq = ed->bEndpointAddress;
265         }
266     }
267
268     /* check whether we found at least the endpoints we need */
269     if (!sc->bulkin || !sc->bulkout) {
270         device_printf(sc->dev, "needed endpoints not found (%d,%d)\n",
271                       sc->bulkin, sc->bulkout);
272         atausb_detach(dev);
273         return ENXIO;
274     }
275
276     /* open the pipes */
277     if (usbd_open_pipe(sc->iface, sc->bulkout,
278                        USBD_EXCLUSIVE_USE, &sc->bulkout_pipe)) {
279         device_printf(sc->dev, "cannot open bulkout pipe (%d)\n", sc->bulkout);
280         atausb_detach(dev);
281         return ENXIO;
282     }
283     if (usbd_open_pipe(sc->iface, sc->bulkin,
284                        USBD_EXCLUSIVE_USE, &sc->bulkin_pipe)) {
285         device_printf(sc->dev, "cannot open bulkin pipe (%d)\n", sc->bulkin);
286         atausb_detach(dev);
287         return ENXIO;
288     }
289     if (id->bInterfaceProtocol == UIPROTO_MASS_CBI_I) {
290         if (usbd_open_pipe(sc->iface, sc->bulkirq,
291                            USBD_EXCLUSIVE_USE, &sc->bulkirq_pipe)) {
292             device_printf(sc->dev, "cannot open bulkirq pipe (%d)\n",
293                           sc->bulkirq);
294             atausb_detach(dev);
295             return ENXIO;
296         }
297     }
298     sc->state = ATAUSB_S_ATTACH;
299
300     /* alloc needed number of transfer handles */
301     for (i = 0; i < ATAUSB_T_MAX; i++) {
302         sc->transfer[i] = usbd_alloc_xfer(uaa->device);
303         if (!sc->transfer[i]) {
304             device_printf(sc->dev, "out of memory\n");
305             atausb_detach(dev);
306             return ENXIO;
307         }
308     }
309
310     /* driver is ready to process requests here */
311     sc->state = ATAUSB_S_IDLE;
312
313     /* get number of devices so we can add matching channels */
314     usbd_interface2device_handle(sc->iface, &udev);
315     request.bmRequestType = UT_READ_CLASS_INTERFACE;
316     request.bRequest = 0xfe; /* GET_MAX_LUN; */
317     USETW(request.wValue, 0);
318     USETW(request.wIndex, sc->ifaceno);
319     USETW(request.wLength, sizeof(maxlun));
320     switch ((err = usbd_do_request(udev, &request, &maxlun))) {
321     case USBD_NORMAL_COMPLETION:
322         if (bootverbose)
323             device_printf(sc->dev, "maxlun=%d\n", maxlun);
324         sc->maxlun = maxlun;
325         break;
326     default:
327         if (bootverbose)
328             device_printf(sc->dev, "get maxlun not supported %s\n",
329         usbd_errstr(err));
330     }
331
332     /* ata channels are children to this USB control device */
333     for (i = 0; i <= sc->maxlun; i++) {
334         /* XXX TGEN devclass_find_free_unit() implementation */
335         int freeunit = 2;
336         while (freeunit < devclass_get_maxunit(ata_devclass) &&
337                devclass_get_device(ata_devclass, freeunit) != NULL)
338             freeunit++;
339         if (!device_add_child(sc->dev, "ata", freeunit)) {
340             device_printf(sc->dev, "failed to attach ata child device\n");
341             atausb_detach(dev);
342             return ENXIO;
343         }
344     }
345     bus_generic_attach(sc->dev);
346     return 0;
347 }
348
349 static int
350 atausb_detach(device_t dev)
351 {
352     struct atausb_softc *sc = device_get_softc(dev);
353     usbd_device_handle udev;
354     device_t *children;
355     int nchildren, i;
356
357     /* signal that device is going away */
358     sc->state = ATAUSB_S_DETACH;
359
360     /* abort all the pipes in case there are active transfers */
361     usbd_interface2device_handle(sc->iface, &udev);
362     usbd_abort_pipe(udev->default_pipe);
363     if (sc->bulkout_pipe)
364         usbd_abort_pipe(sc->bulkout_pipe);
365     if (sc->bulkin_pipe)
366         usbd_abort_pipe(sc->bulkin_pipe);
367     if (sc->bulkirq_pipe)
368         usbd_abort_pipe(sc->bulkirq_pipe);
369
370     /* detach & delete all children */
371     if (!device_get_children(dev, &children, &nchildren)) {
372         for (i = 0; i < nchildren; i++)
373             device_delete_child(dev, children[i]);
374         kfree(children, M_TEMP);
375     }
376
377     /* free the transfers */
378     for (i = 0; i < ATAUSB_T_MAX; i++)
379         if (sc->transfer[i])
380             usbd_free_xfer(sc->transfer[i]);
381
382     /* remove all the pipes */
383     if (sc->bulkout_pipe)
384         usbd_close_pipe(sc->bulkout_pipe);
385     if (sc->bulkin_pipe)
386         usbd_close_pipe(sc->bulkin_pipe);
387     if (sc->bulkirq_pipe)
388         usbd_close_pipe(sc->bulkirq_pipe);
389
390     spin_uninit(&sc->locked_mtx);
391     return 0;
392 }
393
394
395 /*
396  * Generic USB transfer routines 
397  */
398 static usbd_status
399 atausb_start(struct atausb_softc *sc, usbd_pipe_handle pipe,
400              void *buffer, int buflen, int flags, usbd_xfer_handle xfer)
401 {
402     usbd_status err;
403
404     if (sc->state == ATAUSB_S_DETACH)
405         return USBD_NOT_STARTED;
406
407     usbd_setup_xfer(xfer, pipe, (void *)sc, buffer, buflen, flags,
408                     sc->timeout, atausb_bbb_finish);
409     err = usbd_transfer(xfer);
410     if (err && (err != USBD_IN_PROGRESS)) {
411         if (atausbdebug)
412             device_printf(sc->dev, "failed to setup transfer, %s\n",
413                           usbd_errstr(err));
414         return err;
415     }
416     return USBD_NORMAL_COMPLETION;
417 }
418
419 static usbd_status
420 atausb_ctl_start(struct atausb_softc *sc, usbd_device_handle udev,
421                  usb_device_request_t *req, void *buffer, int buflen, int flags,
422                  usbd_xfer_handle xfer)
423 {
424     usbd_status err;
425
426     if (sc->state == ATAUSB_S_DETACH)
427         return USBD_NOT_STARTED;
428
429     usbd_setup_default_xfer(xfer, udev, (void *)sc, sc->timeout, req,
430                             buffer, buflen, flags, atausb_bbb_finish);
431     err = usbd_transfer(xfer);
432     if (err && (err != USBD_IN_PROGRESS)) {
433         if (atausbdebug)
434             device_printf(sc->dev, "failed to setup ctl transfer, %s\n",
435                           usbd_errstr(err));
436         return err;
437     }
438     return USBD_NORMAL_COMPLETION;
439 }
440
441 static void
442 atausb_clear_stall(struct atausb_softc *sc, u_int8_t endpt,
443                    usbd_pipe_handle pipe, int state, usbd_xfer_handle xfer)
444 {
445     usbd_device_handle udev;
446
447     if (atausbdebug)
448         device_printf(sc->dev, "clear endpoint 0x%02x stall\n", endpt);
449     usbd_interface2device_handle(sc->iface, &udev);
450     sc->state = state;
451     usbd_clear_endpoint_toggle(pipe);
452     sc->usb_request.bmRequestType = UT_WRITE_ENDPOINT;
453     sc->usb_request.bRequest = UR_CLEAR_FEATURE;
454     USETW(sc->usb_request.wValue, UF_ENDPOINT_HALT);
455     USETW(sc->usb_request.wIndex, endpt);
456     USETW(sc->usb_request.wLength, 0);
457     atausb_ctl_start(sc, udev, &sc->usb_request, NULL, 0, 0, xfer);
458 }
459
460
461 /*
462  * Bulk-Only transport part
463  */
464 static void
465 atausb_bbb_reset(struct atausb_softc *sc)
466 {
467     usbd_device_handle udev;
468
469     if (atausbdebug)
470         device_printf(sc->dev, "Bulk Reset\n");
471     sc->timeout = 5000;
472     sc->state = ATAUSB_S_BBB_RESET1;
473     usbd_interface2device_handle(sc->iface, &udev);
474     sc->usb_request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
475     sc->usb_request.bRequest = 0xff; /* bulk-only reset */
476     USETW(sc->usb_request.wValue, 0);
477     USETW(sc->usb_request.wIndex, sc->ifaceno);
478     USETW(sc->usb_request.wLength, 0);
479     atausb_ctl_start(sc, udev, &sc->usb_request, NULL,
480                      0, 0, sc->transfer[ATAUSB_T_BBB_RESET1]);
481 }
482
483 static int
484 atausb_bbb_start(struct ata_request *request)
485 {
486     struct atausb_softc *sc = 
487         device_get_softc(device_get_parent(request->parent));
488     struct ata_channel *ch = device_get_softc(request->parent);
489
490     sc->timeout = (request->timeout * 1000) + 5000;
491     USETDW(sc->cbw.signature, CBWSIGNATURE);
492     USETDW(sc->cbw.tag, UGETDW(sc->cbw.tag) + 1);
493     USETDW(sc->cbw.transfer_length, request->bytecount);
494     sc->cbw.flags = (request->flags & ATA_R_READ) ? CBWFLAGS_IN : CBWFLAGS_OUT;
495     sc->cbw.lun = ch->unit;
496     sc->cbw.length = 16;
497     bzero(sc->cbw.cdb, 16);
498     bcopy(request->u.atapi.ccb, sc->cbw.cdb, 12); /* XXX SOS */
499     sc->state = ATAUSB_S_BBB_COMMAND;
500     if (atausb_start(sc, sc->bulkout_pipe, &sc->cbw, sizeof(struct bbb_cbw),
501                      0, sc->transfer[ATAUSB_T_BBB_CBW])) {
502         request->result = EIO;
503         if (atausbdebug)
504             device_printf(request->dev, "cannot setup USB transfer\n");
505         atausb_bbb_reset(sc);
506         return ATA_OP_FINISHED;
507     }
508     return ATA_OP_CONTINUES;
509 }
510
511 static void
512 atausb_bbb_finish(usbd_xfer_handle xfer, usbd_private_handle priv,
513                  usbd_status err)
514 {
515     struct atausb_softc *sc = (struct atausb_softc *)priv;
516     struct ata_request *request = sc->ata_request;
517     usbd_xfer_handle next_xfer;
518
519     /* device_printf(sc->dev, "BBB state %d: %s\n", sc->state,
520        usbd_errstr(err)); */
521
522     if (sc->state == ATAUSB_S_DETACH) {
523         device_printf(sc->dev, "WARNING - device has been removed\n");
524         return;
525     }
526
527     switch (sc->state) {
528     case ATAUSB_S_BBB_COMMAND:  /* command transport phase */
529         if (err) {
530             if (atausbdebug)
531                 device_printf(sc->dev, "failed to send CBW\n");
532             request->result = EIO;
533             atausb_bbb_reset(sc);
534             return;
535         }
536
537         /* next is data transport phase, setup transfer */
538         sc->state = ATAUSB_S_BBB_DATA;
539         if (request->flags & ATA_R_READ) {
540             if (atausb_start(sc, sc->bulkin_pipe,
541                              request->data, request->bytecount,
542                              USBD_SHORT_XFER_OK,
543                              sc->transfer[ATAUSB_T_BBB_DATA])) {
544                 request->result = EIO;
545                 atausb_bbb_reset(sc);
546             }
547             return;
548         }
549         if (request->flags & ATA_R_WRITE) {
550             if (atausb_start(sc, sc->bulkout_pipe,
551                              request->data, request->bytecount,
552                              0, sc->transfer[ATAUSB_T_BBB_DATA])) {
553                 request->result = EIO;
554                 atausb_bbb_reset(sc);
555             }
556             return;
557         }
558         /* FALLTHROUGH */
559
560     case ATAUSB_S_BBB_DATA:     /* data transport phase */
561         if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
562             usbd_get_xfer_status(xfer, NULL, NULL, &request->donecount, NULL);
563             if (err) {
564                 if (atausbdebug)
565                     device_printf(sc->dev, "data %s count %d failed: %s\n",
566                                   (request->flags & ATA_R_READ?"read":"write"),
567                                   request->bytecount, usbd_errstr(err));
568                 if (err == USBD_STALLED) {
569                     atausb_clear_stall(sc,
570                                        (request->flags & ATA_R_READ ?
571                                         sc->bulkin : sc->bulkout),
572                                        (request->flags & ATA_R_READ ?
573                                         sc->bulkin_pipe : sc->bulkout_pipe),
574                                        ATAUSB_S_BBB_DCLEAR,
575                                        sc->transfer[ATAUSB_T_BBB_DCLEAR]);
576                 }
577                 else {
578                     request->result = EIO;
579                     atausb_bbb_reset(sc);
580                 }
581                 return;
582             }
583         }
584         /* FALLTHROUGH */
585
586     case ATAUSB_S_BBB_DCLEAR:   /* stall clear after data phase */
587     case ATAUSB_S_BBB_SCLEAR:   /* stall clear after status phase */
588         if (err) {
589             if (atausbdebug)
590                 device_printf(sc->dev, "bulk%s stall clear failed %s\n",
591                               (request->flags & ATA_R_READ ? "in" : "out"),
592                               usbd_errstr(err));
593             request->result = EIO;
594             atausb_bbb_reset(sc);
595             return;
596         }
597
598         if (sc->state == ATAUSB_S_BBB_COMMAND ||
599             sc->state == ATAUSB_S_BBB_DATA ||
600             sc->state == ATAUSB_S_BBB_DCLEAR) {
601             /* first attempt on status transport phase setup transfer */
602             sc->state = ATAUSB_S_BBB_STATUS1;
603             next_xfer = sc->transfer[ATAUSB_T_BBB_CSW1];
604         }
605         else {
606             /* second attempt of fetching status */
607             sc->state = ATAUSB_S_BBB_STATUS2;
608             next_xfer = sc->transfer[ATAUSB_T_BBB_CSW2];
609         }
610         if (atausb_start(sc, sc->bulkin_pipe, &sc->csw, sizeof(struct bbb_csw),
611                          USBD_SHORT_XFER_OK, next_xfer)) {
612             request->result = EIO;
613             atausb_bbb_reset(sc);
614         }
615         return;
616
617     case ATAUSB_S_BBB_STATUS1:  /* status transfer first attempt */
618     case ATAUSB_S_BBB_STATUS2:  /* status transfer second attempt */
619         if (err) {
620             if (atausbdebug)
621                 device_printf(sc->dev, "cannot get CSW, %s%s\n",
622                               usbd_errstr(err),
623                               sc->state == ATAUSB_S_BBB_STATUS1 ? ", retry":"");
624             if (sc->state == ATAUSB_S_BBB_STATUS1) {
625                 atausb_clear_stall(sc, sc->bulkin, sc->bulkin_pipe,
626                                    ATAUSB_S_BBB_SCLEAR,
627                                    sc->transfer[ATAUSB_T_BBB_SCLEAR]);
628             }
629             else {
630                 request->result = EIO;
631                 atausb_bbb_reset(sc);
632             }
633             return;
634         }
635
636         int residue = UGETDW(sc->csw.residue);
637
638         if (!residue &&
639             (request->bytecount - request->donecount))
640             residue = request->bytecount - request->donecount;
641
642         /* check CSW and handle eventual error */
643         if (UGETDW(sc->csw.signature) != CSWSIGNATURE) {
644             if (atausbdebug)
645                 device_printf(sc->dev, "bad CSW signature 0x%08x != 0x%08x\n",
646                               UGETDW(sc->csw.signature), CSWSIGNATURE);
647             request->result = EIO;
648             atausb_bbb_reset(sc);
649             return;
650         }
651         else if (UGETDW(sc->csw.tag) != UGETDW(sc->cbw.tag)) {
652             if (atausbdebug)
653                 device_printf(sc->dev, "bad CSW tag %d != %d\n",
654                               UGETDW(sc->csw.tag), UGETDW(sc->cbw.tag));
655             request->result = EIO;
656             atausb_bbb_reset(sc);
657             return;
658         }
659         else if (sc->csw.status > CSWSTATUS_PHASE) {
660             if (atausbdebug)
661                 device_printf(sc->dev, "bad CSW status %d > %d\n",
662                               sc->csw.status, CSWSTATUS_PHASE);
663             request->result = EIO;
664             atausb_bbb_reset(sc);
665             return;
666         }
667         else if (sc->csw.status == CSWSTATUS_PHASE) {
668             if (atausbdebug)
669                 device_printf(sc->dev, "phase error residue = %d\n", residue);
670             request->result = EIO;
671             atausb_bbb_reset(sc);
672             return;
673         }
674         else if (request->donecount > request->bytecount) {
675             if (atausbdebug)
676                 device_printf(sc->dev, "buffer overrun %d > %d",
677                              request->donecount, request->bytecount);
678             request->result = EIO;
679             atausb_bbb_reset(sc);
680             return;
681         }
682         else if (sc->csw.status == CSWSTATUS_FAILED) {
683             if (atausbdebug)
684                 device_printf(sc->dev, "CSWSTATUS_FAILED\n");
685             request->error = ATA_E_ATAPI_SENSE_MASK ;
686             sc->state = ATAUSB_S_IDLE;
687             ata_interrupt(device_get_softc(request->parent));
688             return;
689         }
690         else {
691             sc->state = ATAUSB_S_IDLE;
692             ata_interrupt(device_get_softc(request->parent));
693             return;
694         }
695         /* NOT REACHED */
696
697     case ATAUSB_S_BBB_RESET1:
698         if (err)
699             if (atausbdebug)
700                 device_printf(sc->dev,
701                               "BBB reset failure: %s\n", usbd_errstr(err));
702         atausb_clear_stall(sc, sc->bulkin, sc->bulkin_pipe,
703                            ATAUSB_S_BBB_RESET2,
704                            sc->transfer[ATAUSB_T_BBB_RESET2]);
705         return;
706
707     case ATAUSB_S_BBB_RESET2:
708         if (err)
709             if (atausbdebug)
710                 device_printf(sc->dev, "BBB bulkin clear stall failure: %s\n",
711                               usbd_errstr(err));
712         atausb_clear_stall(sc, sc->bulkout, sc->bulkout_pipe,
713                            ATAUSB_S_BBB_RESET3,
714                            sc->transfer[ATAUSB_T_BBB_RESET3]);
715         return;
716
717     case ATAUSB_S_BBB_RESET3:
718         if (err)
719             if (atausbdebug)
720                 device_printf(sc->dev, "BBB bulk-out clear stall failure: %s\n",
721                               usbd_errstr(err));
722         sc->state = ATAUSB_S_IDLE;
723         if (request) {
724             if (err)
725                 request->result = ENXIO;
726             else
727                 request->result = EIO;
728             ata_interrupt(device_get_softc(request->parent));
729         }
730         return;
731
732     default:
733         if (atausbdebug)
734             device_printf(sc->dev, "unknown state %d", sc->state);
735     }
736 }
737
738
739 /*
740  * ATA backend part
741  */
742 struct atapi_inquiry {
743     u_int8_t    device_type;
744     u_int8_t    device_modifier;
745     u_int8_t    version;
746     u_int8_t    response_format;
747     u_int8_t    length;
748     u_int8_t    reserved[2];
749     u_int8_t    flags;
750     u_int8_t    vendor[8];
751     u_int8_t    product[16];
752     u_int8_t    revision[4];
753     /* u_int8_t    crap[60]; */
754 };
755
756 int
757 ata_usbchannel_begin_transaction(struct ata_request *request)
758 {
759     struct atausb_softc *sc = 
760         device_get_softc(device_get_parent(request->parent));
761
762     if (atausbdebug > 1)
763         device_printf(request->dev, "begin_transaction %s\n",
764                       ata_cmd2str(request));
765
766     /* sanity just in case */
767     if (sc->state != ATAUSB_S_IDLE) {
768         kprintf("begin is busy (%d)\n", sc->state);
769         request->result = EBUSY;
770         return ATA_OP_FINISHED;
771     }
772
773     /* XXX SOS convert the request into the format used, only BBB for now*/
774     sc->ata_request = request;
775
776     /* ATA/ATAPI IDENTIFY needs special treatment */
777     if (!(request->flags & ATA_R_ATAPI)) {
778         if (request->u.ata.command != ATA_ATAPI_IDENTIFY) {
779             device_printf(request->dev,"%s unsupported\n",ata_cmd2str(request));
780             request->result = EIO;
781             return ATA_OP_FINISHED;
782         }
783         request->flags |= ATA_R_ATAPI;
784         bzero(request->u.atapi.ccb, 16);
785         request->u.atapi.ccb[0] = ATAPI_INQUIRY;
786         request->u.atapi.ccb[4] =  255; /* sizeof(struct atapi_inquiry); */
787         request->data += 256;   /* arbitrary offset into ata_param */
788         request->bytecount = 255; /* sizeof(struct atapi_inquiry); */
789     }
790     return atausb_bbb_start(request);
791 }
792
793 int
794 ata_usbchannel_end_transaction(struct ata_request *request)
795 {
796     if (atausbdebug > 1)
797         device_printf(request->dev, "end_transaction %s\n",
798                       ata_cmd2str(request));
799     
800     /* XXX SOS convert the request from the format used, only BBB for now*/
801
802     /* ATA/ATAPI IDENTIFY needs special treatment */
803     if ((request->flags & ATA_R_ATAPI) &&
804         (request->u.atapi.ccb[0] == ATAPI_INQUIRY)) {
805         struct ata_device *atadev = device_get_softc(request->dev);
806         struct atapi_inquiry *inquiry = (struct atapi_inquiry *)request->data;
807         u_int16_t *ptr;
808
809         /* convert inquiry data into simple ata_param like format */
810         atadev->param.config = ATA_PROTO_ATAPI | ATA_PROTO_ATAPI_12;
811         atadev->param.config |= (inquiry->device_type & 0x1f) << 8;
812         bzero(atadev->param.model, sizeof(atadev->param.model));
813         strncpy(atadev->param.model, inquiry->vendor, 8);
814         strcpy(atadev->param.model, "  ");
815         strncpy(atadev->param.model, inquiry->product, 16);
816         ptr = (u_int16_t*)(atadev->param.model + sizeof(atadev->param.model));
817         while (--ptr >= (u_int16_t*)atadev->param.model)
818             *ptr = ntohs(*ptr);
819         strncpy(atadev->param.revision, inquiry->revision, 4);
820         ptr=(u_int16_t*)(atadev->param.revision+sizeof(atadev->param.revision));
821         while (--ptr >= (u_int16_t*)atadev->param.revision)
822             *ptr = ntohs(*ptr);
823         request->result = 0;
824     }
825     return ATA_OP_FINISHED;
826 }
827
828 static int
829 ata_usbchannel_probe(device_t dev)
830 {
831     struct ata_channel *ch = device_get_softc(dev);
832     device_t *children;
833     int count, i;
834     char buffer[32];
835
836     /* take care of green memory */
837     bzero(ch, sizeof(struct ata_channel));
838
839     /* find channel number on this controller */
840     device_get_children(device_get_parent(dev), &children, &count);
841     for (i = 0; i < count; i++) {
842         if (children[i] == dev)
843             ch->unit = i;
844     }
845     kfree(children, M_TEMP);
846
847     ksprintf(buffer, "USB lun %d", ch->unit);
848     device_set_desc_copy(dev, buffer);
849
850     return 0;
851 }
852
853 static int
854 ata_usbchannel_attach(device_t dev)
855 {
856     struct ata_channel *ch = device_get_softc(dev);
857
858     /* initialize the softc basics */
859     ch->dev = dev;
860     ch->state = ATA_IDLE;
861     ch->hw.begin_transaction = ata_usbchannel_begin_transaction;
862     ch->hw.end_transaction = ata_usbchannel_end_transaction;
863     ch->hw.status = NULL;
864     ch->hw.command = NULL;
865     spin_init(&ch->state_mtx);
866     spin_init(&ch->queue_mtx);
867     TAILQ_INIT(&ch->ata_queue);
868
869     /* XXX SOS reset the controller HW, the channel and device(s) */
870     /* ATA_RESET(dev); */
871
872     /* probe and attach device on this channel */
873     ch->devices = ATA_ATAPI_MASTER;
874     ata_identify(dev);
875     return 0;
876 }
877
878 static int
879 ata_usbchannel_detach(device_t dev)
880 {
881     struct ata_channel *ch = device_get_softc(dev);
882     device_t *children;
883     int nchildren, i;
884
885     /* detach & delete all children */
886     if (!device_get_children(dev, &children, &nchildren)) {
887         for (i = 0; i < nchildren; i++)
888             if (children[i])
889                 device_delete_child(dev, children[i]);
890         kfree(children, M_TEMP);
891     }
892     spin_uninit(&ch->state_mtx);
893     spin_uninit(&ch->queue_mtx);
894     return 0;
895 }
896
897 static void
898 ata_usbchannel_setmode(device_t parent, device_t dev)
899 {
900     struct atausb_softc *sc = device_get_softc(GRANDPARENT(dev));
901     struct ata_device *atadev = device_get_softc(dev);
902     usbd_device_handle udev;
903
904     usbd_interface2device_handle(sc->iface, &udev);
905     if (usbd_get_speed(udev) == USB_SPEED_HIGH)
906         atadev->mode = ATA_USB2;
907     else
908         atadev->mode = ATA_USB1;
909 }
910
911 static int
912 ata_usbchannel_locking(device_t dev, int flags)
913 {
914     struct atausb_softc *sc = device_get_softc(device_get_parent(dev));
915     struct ata_channel *ch = device_get_softc(dev);
916     int res = -1;
917
918
919     spin_lock_wr(&sc->locked_mtx);
920     switch (flags) {
921     case ATA_LF_LOCK:
922         if (sc->locked_ch == NULL)
923             sc->locked_ch = ch;
924         if (sc->locked_ch != ch)
925             sc->restart_ch = ch;
926         break;
927
928     case ATA_LF_UNLOCK:
929         if (sc->locked_ch == ch) {
930             sc->locked_ch = NULL;
931             if (sc->restart_ch) {
932                 ch = sc->restart_ch;
933                 sc->restart_ch = NULL;
934                 spin_unlock_wr(&sc->locked_mtx);
935                 ata_start(ch->dev);
936                 return res;
937             }
938         }
939         break;
940
941     case ATA_LF_WHICH:
942         break;
943     }
944     if (sc->locked_ch)
945         res = sc->locked_ch->unit;
946     spin_unlock_wr(&sc->locked_mtx);
947     return res;
948 }
949
950 static device_method_t ata_usbchannel_methods[] = {
951     /* device interface */
952     DEVMETHOD(device_probe,         ata_usbchannel_probe),
953     DEVMETHOD(device_attach,        ata_usbchannel_attach),
954     DEVMETHOD(device_detach,        ata_usbchannel_detach),
955
956     /* ATA methods */
957     DEVMETHOD(ata_setmode,        ata_usbchannel_setmode),
958     DEVMETHOD(ata_locking,        ata_usbchannel_locking),
959     /* DEVMETHOD(ata_reset,        ata_usbchannel_reset), */
960
961     { 0, 0 }
962 };
963
964 static driver_t ata_usbchannel_driver = {
965     "ata",
966     ata_usbchannel_methods,
967     sizeof(struct ata_channel),
968 };
969
970 DRIVER_MODULE(ata, atausb, ata_usbchannel_driver, ata_devclass, 0, 0);
971 MODULE_DEPEND(atausb, ata, 1, 1, 1);