?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MFC numerous features from HEAD.
[dragonfly.git] / sys / dev / disk / nata / ata-usb.c
blob9c39fff4365c859af2df73e855b732837852889a
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.7 2007/07/02 23:52:04 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 static device_probe_t atausb_match;
146 static device_attach_t atausb_attach;
147 static device_detach_t atausb_detach;
148
149 static devclass_t atausb_devclass;
150
151 static kobj_method_t atausb_methods[] = {
152 DEVMETHOD(device_probe, atausb_match),
153 DEVMETHOD(device_attach, atausb_attach),
154 DEVMETHOD(device_detach, atausb_detach),
155 {0,0}
156 };
157
158 static driver_t atausb_driver = {
159 "atausb",
160 atausb_methods,
161 sizeof(struct atausb_softc)
162 };
163
164 MODULE_DEPEND(atausb, usb, 1, 1, 1);
165 DRIVER_MODULE(atausb, uhub, atausb_driver, atausb_devclass, 0, 0);
166 MODULE_VERSION(atausb, 1);
167
168 static int
169 atausb_match(device_t dev)
170 {
171 struct usb_attach_arg *uaa = device_get_ivars(dev);
172 usb_interface_descriptor_t *id;
173
174 if (uaa->iface == NULL)
175 return UMATCH_NONE;
176
177 id = usbd_get_interface_descriptor(uaa->iface);
178 if (!id || id->bInterfaceClass != UICLASS_MASS)
179 return UMATCH_NONE;
180
181 switch (id->bInterfaceSubClass) {
182 case UISUBCLASS_QIC157:
183 case UISUBCLASS_RBC:
184 case UISUBCLASS_SCSI:
185 case UISUBCLASS_SFF8020I:
186 case UISUBCLASS_SFF8070I:
187 case UISUBCLASS_UFI:
188 switch (id->bInterfaceProtocol) {
189 case UIPROTO_MASS_CBI:
190 case UIPROTO_MASS_CBI_I:
191 case UIPROTO_MASS_BBB:
192 case UIPROTO_MASS_BBB_OLD:
193 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
194 default:
195 return UMATCH_IFACECLASS_IFACESUBCLASS;
196 }
197 break;
198 default:
199 return UMATCH_IFACECLASS;
200 }
201 }
202
203 static int
204 atausb_attach(device_t dev)
205 {
206 struct atausb_softc *sc = device_get_softc(dev);
207 struct usb_attach_arg *uaa = device_get_ivars(dev);
208 usb_interface_descriptor_t *id;
209 usb_endpoint_descriptor_t *ed;
210 usbd_device_handle udev;
211 usb_device_request_t request;
212 char devinfo[1024], *proto, *subclass;
213 u_int8_t maxlun;
214 int err, i;
215
216 sc->dev = dev;
217 usbd_devinfo(uaa->device, 0, devinfo);
218 device_set_desc_copy(dev, devinfo);
219 sc->bulkin = sc->bulkout = sc->bulkirq = -1;
220 sc->bulkin_pipe = sc->bulkout_pipe= sc->bulkirq_pipe = NULL;
221 sc->iface = uaa->iface;
222 sc->ifaceno = uaa->ifaceno;
223 sc->maxlun = 0;
224 sc->timeout = 5000;
225 sc->locked_ch = NULL;
226 sc->restart_ch = NULL;
227 spin_init(&sc->locked_mtx);
228
229 id = usbd_get_interface_descriptor(sc->iface);
230 switch (id->bInterfaceProtocol) {
231 case UIPROTO_MASS_BBB:
232 case UIPROTO_MASS_BBB_OLD:
233 proto = "Bulk-Only";
234 break;
235 case UIPROTO_MASS_CBI:
236 proto = "CBI";
237 break;
238 case UIPROTO_MASS_CBI_I:
239 proto = "CBI with CCI";
240 break;
241 default:
242 proto = "Unknown";
243 }
244 switch (id->bInterfaceSubClass) {
245 case UISUBCLASS_RBC:
246 subclass = "RBC";
247 break;
248 case UISUBCLASS_QIC157:
249 case UISUBCLASS_SFF8020I:
250 case UISUBCLASS_SFF8070I:
251 subclass = "ATAPI";
252 break;
253 case UISUBCLASS_SCSI:
254 subclass = "SCSI";
255 break;
256 case UISUBCLASS_UFI:
257 subclass = "UFI";
258 break;
259 default:
260 subclass = "Unknown";
261 }
262 device_printf(dev, "using %s over %s\n", subclass, proto);
263 if (strcmp(proto, "Bulk-Only") ||
264 (strcmp(subclass, "ATAPI") && strcmp(subclass, "SCSI")))
265 return ENXIO;
266
267 for (i = 0 ; i < id->bNumEndpoints ; i++) {
268 if (!(ed = usbd_interface2endpoint_descriptor(sc->iface, i))) {
269 device_printf(sc->dev, "could not read endpoint descriptor\n");
270 return ENXIO;
271 }
272 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
273 (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
274 sc->bulkin = ed->bEndpointAddress;
275 }
276 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
277 (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
278 sc->bulkout = ed->bEndpointAddress;
279 }
280 if (id->bInterfaceProtocol == UIPROTO_MASS_CBI_I &&
281 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
282 (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
283 sc->bulkirq = ed->bEndpointAddress;
284 }
285 }
286
287 /* check whether we found at least the endpoints we need */
288 if (!sc->bulkin || !sc->bulkout) {
289 device_printf(sc->dev, "needed endpoints not found (%d,%d)\n",
290 sc->bulkin, sc->bulkout);
291 atausb_detach(dev);
292 return ENXIO;
293 }
294
295 /* open the pipes */
296 if (usbd_open_pipe(sc->iface, sc->bulkout,
297 USBD_EXCLUSIVE_USE, &sc->bulkout_pipe)) {
298 device_printf(sc->dev, "cannot open bulkout pipe (%d)\n", sc->bulkout);
299 atausb_detach(dev);
300 return ENXIO;
301 }
302 if (usbd_open_pipe(sc->iface, sc->bulkin,
303 USBD_EXCLUSIVE_USE, &sc->bulkin_pipe)) {
304 device_printf(sc->dev, "cannot open bulkin pipe (%d)\n", sc->bulkin);
305 atausb_detach(dev);
306 return ENXIO;
307 }
308 if (id->bInterfaceProtocol == UIPROTO_MASS_CBI_I) {
309 if (usbd_open_pipe(sc->iface, sc->bulkirq,
310 USBD_EXCLUSIVE_USE, &sc->bulkirq_pipe)) {
311 device_printf(sc->dev, "cannot open bulkirq pipe (%d)\n",
312 sc->bulkirq);
313 atausb_detach(dev);
314 return ENXIO;
315 }
316 }
317 sc->state = ATAUSB_S_ATTACH;
318
319 /* alloc needed number of transfer handles */
320 for (i = 0; i < ATAUSB_T_MAX; i++) {
321 sc->transfer[i] = usbd_alloc_xfer(uaa->device);
322 if (!sc->transfer[i]) {
323 device_printf(sc->dev, "out of memory\n");
324 atausb_detach(dev);
325 return ENXIO;
326 }
327 }
328
329 /* driver is ready to process requests here */
330 sc->state = ATAUSB_S_IDLE;
331
332 /* get number of devices so we can add matching channels */
333 usbd_interface2device_handle(sc->iface, &udev);
334 request.bmRequestType = UT_READ_CLASS_INTERFACE;
335 request.bRequest = 0xfe; /* GET_MAX_LUN; */
336 USETW(request.wValue, 0);
337 USETW(request.wIndex, sc->ifaceno);
338 USETW(request.wLength, sizeof(maxlun));
339 switch ((err = usbd_do_request(udev, &request, &maxlun))) {
340 case USBD_NORMAL_COMPLETION:
341 if (bootverbose)
342 device_printf(sc->dev, "maxlun=%d\n", maxlun);
343 sc->maxlun = maxlun;
344 break;
345 default:
346 if (bootverbose)
347 device_printf(sc->dev, "get maxlun not supported %s\n",
348 usbd_errstr(err));
349 }
350
351 /* ata channels are children to this USB control device */
352 for (i = 0; i <= sc->maxlun; i++) {
353 /* XXX TGEN devclass_find_free_unit() implementation */
354 int freeunit = 2;
355 while (freeunit < devclass_get_maxunit(ata_devclass) &&
356 devclass_get_device(ata_devclass, freeunit) != NULL)
357 freeunit++;
358 if (!device_add_child(sc->dev, "ata", freeunit)) {
359 device_printf(sc->dev, "failed to attach ata child device\n");
360 atausb_detach(dev);
361 return ENXIO;
362 }
363 }
364 bus_generic_attach(sc->dev);
365 return 0;
366 }
367
368 static int
369 atausb_detach(device_t dev)
370 {
371 struct atausb_softc *sc = device_get_softc(dev);
372 usbd_device_handle udev;
373 device_t *children;
374 int nchildren, i;
375
376 /* signal that device is going away */
377 sc->state = ATAUSB_S_DETACH;
378
379 /* abort all the pipes in case there are active transfers */
380 usbd_interface2device_handle(sc->iface, &udev);
381 usbd_abort_pipe(udev->default_pipe);
382 if (sc->bulkout_pipe)
383 usbd_abort_pipe(sc->bulkout_pipe);
384 if (sc->bulkin_pipe)
385 usbd_abort_pipe(sc->bulkin_pipe);
386 if (sc->bulkirq_pipe)
387 usbd_abort_pipe(sc->bulkirq_pipe);
388
389 /* detach & delete all children */
390 if (!device_get_children(dev, &children, &nchildren)) {
391 for (i = 0; i < nchildren; i++)
392 device_delete_child(dev, children[i]);
393 kfree(children, M_TEMP);
394 }
395
396 /* free the transfers */
397 for (i = 0; i < ATAUSB_T_MAX; i++)
398 if (sc->transfer[i])
399 usbd_free_xfer(sc->transfer[i]);
400
401 /* remove all the pipes */
402 if (sc->bulkout_pipe)
403 usbd_close_pipe(sc->bulkout_pipe);
404 if (sc->bulkin_pipe)
405 usbd_close_pipe(sc->bulkin_pipe);
406 if (sc->bulkirq_pipe)
407 usbd_close_pipe(sc->bulkirq_pipe);
408
409 spin_uninit(&sc->locked_mtx);
410 return 0;
411 }
412
413
414 /*
415 * Generic USB transfer routines
416 */
417 static usbd_status
418 atausb_start(struct atausb_softc *sc, usbd_pipe_handle pipe,
419 void *buffer, int buflen, int flags, usbd_xfer_handle xfer)
420 {
421 usbd_status err;
422
423 if (sc->state == ATAUSB_S_DETACH)
424 return USBD_NOT_STARTED;
425
426 usbd_setup_xfer(xfer, pipe, (void *)sc, buffer, buflen, flags,
427 sc->timeout, atausb_bbb_finish);
428 err = usbd_transfer(xfer);
429 if (err && (err != USBD_IN_PROGRESS)) {
430 if (atausbdebug)
431 device_printf(sc->dev, "failed to setup transfer, %s\n",
432 usbd_errstr(err));
433 return err;
434 }
435 return USBD_NORMAL_COMPLETION;
436 }
437
438 static usbd_status
439 atausb_ctl_start(struct atausb_softc *sc, usbd_device_handle udev,
440 usb_device_request_t *req, void *buffer, int buflen, int flags,
441 usbd_xfer_handle xfer)
442 {
443 usbd_status err;
444
445 if (sc->state == ATAUSB_S_DETACH)
446 return USBD_NOT_STARTED;
447
448 usbd_setup_default_xfer(xfer, udev, (void *)sc, sc->timeout, req,
449 buffer, buflen, flags, atausb_bbb_finish);
450 err = usbd_transfer(xfer);
451 if (err && (err != USBD_IN_PROGRESS)) {
452 if (atausbdebug)
453 device_printf(sc->dev, "failed to setup ctl transfer, %s\n",
454 usbd_errstr(err));
455 return err;
456 }
457 return USBD_NORMAL_COMPLETION;
458 }
459
460 static void
461 atausb_clear_stall(struct atausb_softc *sc, u_int8_t endpt,
462 usbd_pipe_handle pipe, int state, usbd_xfer_handle xfer)
463 {
464 usbd_device_handle udev;
465
466 if (atausbdebug)
467 device_printf(sc->dev, "clear endpoint 0x%02x stall\n", endpt);
468 usbd_interface2device_handle(sc->iface, &udev);
469 sc->state = state;
470 usbd_clear_endpoint_toggle(pipe);
471 sc->usb_request.bmRequestType = UT_WRITE_ENDPOINT;
472 sc->usb_request.bRequest = UR_CLEAR_FEATURE;
473 USETW(sc->usb_request.wValue, UF_ENDPOINT_HALT);
474 USETW(sc->usb_request.wIndex, endpt);
475 USETW(sc->usb_request.wLength, 0);
476 atausb_ctl_start(sc, udev, &sc->usb_request, NULL, 0, 0, xfer);
477 }
478
479
480 /*
481 * Bulk-Only transport part
482 */
483 static void
484 atausb_bbb_reset(struct atausb_softc *sc)
485 {
486 usbd_device_handle udev;
487
488 if (atausbdebug)
489 device_printf(sc->dev, "Bulk Reset\n");
490 sc->timeout = 5000;
491 sc->state = ATAUSB_S_BBB_RESET1;
492 usbd_interface2device_handle(sc->iface, &udev);
493 sc->usb_request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
494 sc->usb_request.bRequest = 0xff; /* bulk-only reset */
495 USETW(sc->usb_request.wValue, 0);
496 USETW(sc->usb_request.wIndex, sc->ifaceno);
497 USETW(sc->usb_request.wLength, 0);
498 atausb_ctl_start(sc, udev, &sc->usb_request, NULL,
499 0, 0, sc->transfer[ATAUSB_T_BBB_RESET1]);
500 }
501
502 static int
503 atausb_bbb_start(struct ata_request *request)
504 {
505 struct atausb_softc *sc =
506 device_get_softc(device_get_parent(request->parent));
507 struct ata_channel *ch = device_get_softc(request->parent);
508
509 sc->timeout = (request->timeout * 1000) + 5000;
510 USETDW(sc->cbw.signature, CBWSIGNATURE);
511 USETDW(sc->cbw.tag, UGETDW(sc->cbw.tag) + 1);
512 USETDW(sc->cbw.transfer_length, request->bytecount);
513 sc->cbw.flags = (request->flags & ATA_R_READ) ? CBWFLAGS_IN : CBWFLAGS_OUT;
514 sc->cbw.lun = ch->unit;
515 sc->cbw.length = 16;
516 bzero(sc->cbw.cdb, 16);
517 bcopy(request->u.atapi.ccb, sc->cbw.cdb, 12); /* XXX SOS */
518 sc->state = ATAUSB_S_BBB_COMMAND;
519 if (atausb_start(sc, sc->bulkout_pipe, &sc->cbw, sizeof(struct bbb_cbw),
520 0, sc->transfer[ATAUSB_T_BBB_CBW])) {
521 request->result = EIO;
522 if (atausbdebug)
523 device_printf(request->dev, "cannot setup USB transfer\n");
524 atausb_bbb_reset(sc);
525 return ATA_OP_FINISHED;
526 }
527 return ATA_OP_CONTINUES;
528 }
529
530 static void
531 atausb_bbb_finish(usbd_xfer_handle xfer, usbd_private_handle priv,
532 usbd_status err)
533 {
534 struct atausb_softc *sc = (struct atausb_softc *)priv;
535 struct ata_request *request = sc->ata_request;
536 usbd_xfer_handle next_xfer;
537
538 /* device_printf(sc->dev, "BBB state %d: %s\n", sc->state,
539 usbd_errstr(err)); */
540
541 if (sc->state == ATAUSB_S_DETACH) {
542 device_printf(sc->dev, "WARNING - device has been removed\n");
543 return;
544 }
545
546 switch (sc->state) {
547 case ATAUSB_S_BBB_COMMAND: /* command transport phase */
548 if (err) {
549 if (atausbdebug)
550 device_printf(sc->dev, "failed to send CBW\n");
551 request->result = EIO;
552 atausb_bbb_reset(sc);
553 return;
554 }
555
556 /* next is data transport phase, setup transfer */
557 sc->state = ATAUSB_S_BBB_DATA;
558 if (request->flags & ATA_R_READ) {
559 if (atausb_start(sc, sc->bulkin_pipe,
560 request->data, request->bytecount,
561 USBD_SHORT_XFER_OK,
562 sc->transfer[ATAUSB_T_BBB_DATA])) {
563 request->result = EIO;
564 atausb_bbb_reset(sc);
565 }
566 return;
567 }
568 if (request->flags & ATA_R_WRITE) {
569 if (atausb_start(sc, sc->bulkout_pipe,
570 request->data, request->bytecount,
571 0, sc->transfer[ATAUSB_T_BBB_DATA])) {
572 request->result = EIO;
573 atausb_bbb_reset(sc);
574 }
575 return;
576 }
577 /* FALLTHROUGH */
578
579 case ATAUSB_S_BBB_DATA: /* data transport phase */
580 if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
581 usbd_get_xfer_status(xfer, NULL, NULL, &request->donecount, NULL);
582 if (err) {
583 if (atausbdebug)
584 device_printf(sc->dev, "data %s count %d failed: %s\n",
585 (request->flags & ATA_R_READ?"read":"write"),
586 request->bytecount, usbd_errstr(err));
587 if (err == USBD_STALLED) {
588 atausb_clear_stall(sc,
589 (request->flags & ATA_R_READ ?
590 sc->bulkin : sc->bulkout),
591 (request->flags & ATA_R_READ ?
592 sc->bulkin_pipe : sc->bulkout_pipe),
593 ATAUSB_S_BBB_DCLEAR,
594 sc->transfer[ATAUSB_T_BBB_DCLEAR]);
595 }
596 else {
597 request->result = EIO;
598 atausb_bbb_reset(sc);
599 }
600 return;
601 }
602 }
603 /* FALLTHROUGH */
604
605 case ATAUSB_S_BBB_DCLEAR: /* stall clear after data phase */
606 case ATAUSB_S_BBB_SCLEAR: /* stall clear after status phase */
607 if (err) {
608 if (atausbdebug)
609 device_printf(sc->dev, "bulk%s stall clear failed %s\n",
610 (request->flags & ATA_R_READ ? "in" : "out"),
611 usbd_errstr(err));
612 request->result = EIO;
613 atausb_bbb_reset(sc);
614 return;
615 }
616
617 if (sc->state == ATAUSB_S_BBB_COMMAND ||
618 sc->state == ATAUSB_S_BBB_DATA ||
619 sc->state == ATAUSB_S_BBB_DCLEAR) {
620 /* first attempt on status transport phase setup transfer */
621 sc->state = ATAUSB_S_BBB_STATUS1;
622 next_xfer = sc->transfer[ATAUSB_T_BBB_CSW1];
623 }
624 else {
625 /* second attempt of fetching status */
626 sc->state = ATAUSB_S_BBB_STATUS2;
627 next_xfer = sc->transfer[ATAUSB_T_BBB_CSW2];
628 }
629 if (atausb_start(sc, sc->bulkin_pipe, &sc->csw, sizeof(struct bbb_csw),
630 USBD_SHORT_XFER_OK, next_xfer)) {
631 request->result = EIO;
632 atausb_bbb_reset(sc);
633 }
634 return;
635
636 case ATAUSB_S_BBB_STATUS1: /* status transfer first attempt */
637 case ATAUSB_S_BBB_STATUS2: /* status transfer second attempt */
638 if (err) {
639 if (atausbdebug)
640 device_printf(sc->dev, "cannot get CSW, %s%s\n",
641 usbd_errstr(err),
642 sc->state == ATAUSB_S_BBB_STATUS1 ? ", retry":"");
643 if (sc->state == ATAUSB_S_BBB_STATUS1) {
644 atausb_clear_stall(sc, sc->bulkin, sc->bulkin_pipe,
645 ATAUSB_S_BBB_SCLEAR,
646 sc->transfer[ATAUSB_T_BBB_SCLEAR]);
647 }
648 else {
649 request->result = EIO;
650 atausb_bbb_reset(sc);
651 }
652 return;
653 }
654
655 int residue = UGETDW(sc->csw.residue);
656
657 if (!residue &&
658 (request->bytecount - request->donecount))
659 residue = request->bytecount - request->donecount;
660
661 /* check CSW and handle eventual error */
662 if (UGETDW(sc->csw.signature) != CSWSIGNATURE) {
663 if (atausbdebug)
664 device_printf(sc->dev, "bad CSW signature 0x%08x != 0x%08x\n",
665 UGETDW(sc->csw.signature), CSWSIGNATURE);
666 request->result = EIO;
667 atausb_bbb_reset(sc);
668 return;
669 }
670 else if (UGETDW(sc->csw.tag) != UGETDW(sc->cbw.tag)) {
671 if (atausbdebug)
672 device_printf(sc->dev, "bad CSW tag %d != %d\n",
673 UGETDW(sc->csw.tag), UGETDW(sc->cbw.tag));
674 request->result = EIO;
675 atausb_bbb_reset(sc);
676 return;
677 }
678 else if (sc->csw.status > CSWSTATUS_PHASE) {
679 if (atausbdebug)
680 device_printf(sc->dev, "bad CSW status %d > %d\n",
681 sc->csw.status, CSWSTATUS_PHASE);
682 request->result = EIO;
683 atausb_bbb_reset(sc);
684 return;
685 }
686 else if (sc->csw.status == CSWSTATUS_PHASE) {
687 if (atausbdebug)
688 device_printf(sc->dev, "phase error residue = %d\n", residue);
689 request->result = EIO;
690 atausb_bbb_reset(sc);
691 return;
692 }
693 else if (request->donecount > request->bytecount) {
694 if (atausbdebug)
695 device_printf(sc->dev, "buffer overrun %d > %d",
696 request->donecount, request->bytecount);
697 request->result = EIO;
698 atausb_bbb_reset(sc);
699 return;
700 }
701 else if (sc->csw.status == CSWSTATUS_FAILED) {
702 if (atausbdebug)
703 device_printf(sc->dev, "CSWSTATUS_FAILED\n");
704 request->error = ATA_E_ATAPI_SENSE_MASK ;
705 sc->state = ATAUSB_S_IDLE;
706 ata_interrupt(device_get_softc(request->parent));
707 return;
708 }
709 else {
710 sc->state = ATAUSB_S_IDLE;
711 ata_interrupt(device_get_softc(request->parent));
712 return;
713 }
714 /* NOT REACHED */
715
716 case ATAUSB_S_BBB_RESET1:
717 if (err)
718 if (atausbdebug)
719 device_printf(sc->dev,
720 "BBB reset failure: %s\n", usbd_errstr(err));
721 atausb_clear_stall(sc, sc->bulkin, sc->bulkin_pipe,
722 ATAUSB_S_BBB_RESET2,
723 sc->transfer[ATAUSB_T_BBB_RESET2]);
724 return;
725
726 case ATAUSB_S_BBB_RESET2:
727 if (err)
728 if (atausbdebug)
729 device_printf(sc->dev, "BBB bulkin clear stall failure: %s\n",
730 usbd_errstr(err));
731 atausb_clear_stall(sc, sc->bulkout, sc->bulkout_pipe,
732 ATAUSB_S_BBB_RESET3,
733 sc->transfer[ATAUSB_T_BBB_RESET3]);
734 return;
735
736 case ATAUSB_S_BBB_RESET3:
737 if (err)
738 if (atausbdebug)
739 device_printf(sc->dev, "BBB bulk-out clear stall failure: %s\n",
740 usbd_errstr(err));
741 sc->state = ATAUSB_S_IDLE;
742 if (request) {
743 if (err)
744 request->result = ENXIO;
745 else
746 request->result = EIO;
747 ata_interrupt(device_get_softc(request->parent));
748 }
749 return;
750
751 default:
752 if (atausbdebug)
753 device_printf(sc->dev, "unknown state %d", sc->state);
754 }
755 }
756
757
758 /*
759 * ATA backend part
760 */
761 struct atapi_inquiry {
762 u_int8_t device_type;
763 u_int8_t device_modifier;
764 u_int8_t version;
765 u_int8_t response_format;
766 u_int8_t length;
767 u_int8_t reserved[2];
768 u_int8_t flags;
769 u_int8_t vendor[8];
770 u_int8_t product[16];
771 u_int8_t revision[4];
772 /* u_int8_t crap[60]; */
773 };
774
775 int
776 ata_usbchannel_begin_transaction(struct ata_request *request)
777 {
778 struct atausb_softc *sc =
779 device_get_softc(device_get_parent(request->parent));
780
781 if (atausbdebug > 1)
782 device_printf(request->dev, "begin_transaction %s\n",
783 ata_cmd2str(request));
784
785 /* sanity just in case */
786 if (sc->state != ATAUSB_S_IDLE) {
787 kprintf("begin is busy (%d)\n", sc->state);
788 request->result = EBUSY;
789 return ATA_OP_FINISHED;
790 }
791
792 /* XXX SOS convert the request into the format used, only BBB for now*/
793 sc->ata_request = request;
794
795 /* ATA/ATAPI IDENTIFY needs special treatment */
796 if (!(request->flags & ATA_R_ATAPI)) {
797 if (request->u.ata.command != ATA_ATAPI_IDENTIFY) {
798 device_printf(request->dev,"%s unsupported\n",ata_cmd2str(request));
799 request->result = EIO;
800 return ATA_OP_FINISHED;
801 }
802 request->flags |= ATA_R_ATAPI;
803 bzero(request->u.atapi.ccb, 16);
804 request->u.atapi.ccb[0] = ATAPI_INQUIRY;
805 request->u.atapi.ccb[4] = 255; /* sizeof(struct atapi_inquiry); */
806 request->data += 256; /* arbitrary offset into ata_param */
807 request->bytecount = 255; /* sizeof(struct atapi_inquiry); */
808 }
809 return atausb_bbb_start(request);
810 }
811
812 int
813 ata_usbchannel_end_transaction(struct ata_request *request)
814 {
815 if (atausbdebug > 1)
816 device_printf(request->dev, "end_transaction %s\n",
817 ata_cmd2str(request));
818
819 /* XXX SOS convert the request from the format used, only BBB for now*/
820
821 /* ATA/ATAPI IDENTIFY needs special treatment */
822 if ((request->flags & ATA_R_ATAPI) &&
823 (request->u.atapi.ccb[0] == ATAPI_INQUIRY)) {
824 struct ata_device *atadev = device_get_softc(request->dev);
825 struct atapi_inquiry *inquiry = (struct atapi_inquiry *)request->data;
826 u_int16_t *ptr;
827
828 /* convert inquiry data into simple ata_param like format */
829 atadev->param.config = ATA_PROTO_ATAPI | ATA_PROTO_ATAPI_12;
830 atadev->param.config |= (inquiry->device_type & 0x1f) << 8;
831 bzero(atadev->param.model, sizeof(atadev->param.model));
832 strncpy(atadev->param.model, inquiry->vendor, 8);
833 strcpy(atadev->param.model, " ");
834 strncpy(atadev->param.model, inquiry->product, 16);
835 ptr = (u_int16_t*)(atadev->param.model + sizeof(atadev->param.model));
836 while (--ptr >= (u_int16_t*)atadev->param.model)
837 *ptr = ntohs(*ptr);
838 strncpy(atadev->param.revision, inquiry->revision, 4);
839 ptr=(u_int16_t*)(atadev->param.revision+sizeof(atadev->param.revision));
840 while (--ptr >= (u_int16_t*)atadev->param.revision)
841 *ptr = ntohs(*ptr);
842 request->result = 0;
843 }
844 return ATA_OP_FINISHED;
845 }
846
847 static int
848 ata_usbchannel_probe(device_t dev)
849 {
850 struct ata_channel *ch = device_get_softc(dev);
851 device_t *children;
852 int count, i;
853 char buffer[32];
854
855 /* take care of green memory */
856 bzero(ch, sizeof(struct ata_channel));
857
858 /* find channel number on this controller */
859 device_get_children(device_get_parent(dev), &children, &count);
860 for (i = 0; i < count; i++) {
861 if (children[i] == dev)
862 ch->unit = i;
863 }
864 kfree(children, M_TEMP);
865
866 ksprintf(buffer, "USB lun %d", ch->unit);
867 device_set_desc_copy(dev, buffer);
868
869 return 0;
870 }
871
872 static int
873 ata_usbchannel_attach(device_t dev)
874 {
875 struct ata_channel *ch = device_get_softc(dev);
876
877 /* initialize the softc basics */
878 ch->dev = dev;
879 ch->state = ATA_IDLE;
880 ch->hw.begin_transaction = ata_usbchannel_begin_transaction;
881 ch->hw.end_transaction = ata_usbchannel_end_transaction;
882 ch->hw.status = NULL;
883 ch->hw.command = NULL;
884 spin_init(&ch->state_mtx);
885 spin_init(&ch->queue_mtx);
886 TAILQ_INIT(&ch->ata_queue);
887
888 /* XXX SOS reset the controller HW, the channel and device(s) */
889 /* ATA_RESET(dev); */
890
891 /* probe and attach device on this channel */
892 ch->devices = ATA_ATAPI_MASTER;
893 ata_identify(dev);
894 return 0;
895 }
896
897 static int
898 ata_usbchannel_detach(device_t dev)
899 {
900 struct ata_channel *ch = device_get_softc(dev);
901 device_t *children;
902 int nchildren, i;
903
904 /* detach & delete all children */
905 if (!device_get_children(dev, &children, &nchildren)) {
906 for (i = 0; i < nchildren; i++)
907 if (children[i])
908 device_delete_child(dev, children[i]);
909 kfree(children, M_TEMP);
910 }
911 spin_uninit(&ch->state_mtx);
912 spin_uninit(&ch->queue_mtx);
913 return 0;
914 }
915
916 static void
917 ata_usbchannel_setmode(device_t parent, device_t dev)
918 {
919 struct atausb_softc *sc = device_get_softc(GRANDPARENT(dev));
920 struct ata_device *atadev = device_get_softc(dev);
921 usbd_device_handle udev;
922
923 usbd_interface2device_handle(sc->iface, &udev);
924 if (usbd_get_speed(udev) == USB_SPEED_HIGH)
925 atadev->mode = ATA_USB2;
926 else
927 atadev->mode = ATA_USB1;
928 }
929
930 static int
931 ata_usbchannel_locking(device_t dev, int flags)
932 {
933 struct atausb_softc *sc = device_get_softc(device_get_parent(dev));
934 struct ata_channel *ch = device_get_softc(dev);
935 int res = -1;
936
937
938 spin_lock_wr(&sc->locked_mtx);
939 switch (flags) {
940 case ATA_LF_LOCK:
941 if (sc->locked_ch == NULL)
942 sc->locked_ch = ch;
943 if (sc->locked_ch != ch)
944 sc->restart_ch = ch;
945 break;
946
947 case ATA_LF_UNLOCK:
948 if (sc->locked_ch == ch) {
949 sc->locked_ch = NULL;
950 if (sc->restart_ch) {
951 ch = sc->restart_ch;
952 sc->restart_ch = NULL;
953 spin_unlock_wr(&sc->locked_mtx);
954 ata_start(ch->dev);
955 return res;
956 }
957 }
958 break;
959
960 case ATA_LF_WHICH:
961 break;
962 }
963 if (sc->locked_ch)
964 res = sc->locked_ch->unit;
965 spin_unlock_wr(&sc->locked_mtx);
966 return res;
967 }
968
969 static device_method_t ata_usbchannel_methods[] = {
970 /* device interface */
971 DEVMETHOD(device_probe, ata_usbchannel_probe),
972 DEVMETHOD(device_attach, ata_usbchannel_attach),
973 DEVMETHOD(device_detach, ata_usbchannel_detach),
974
975 /* ATA methods */
976 DEVMETHOD(ata_setmode, ata_usbchannel_setmode),
977 DEVMETHOD(ata_locking, ata_usbchannel_locking),
978 /* DEVMETHOD(ata_reset, ata_usbchannel_reset), */
979
980 { 0, 0 }
981 };
982
983 static driver_t ata_usbchannel_driver = {
984 "ata",
985 ata_usbchannel_methods,
986 sizeof(struct ata_channel),
987 };
988
989 DRIVER_MODULE(ata, atausb, ata_usbchannel_driver, ata_devclass, 0, 0);
990 MODULE_DEPEND(atausb, ata, 1, 1, 1);
DragonFly BSD