1/* $NetBSD: umass.c,v 1.157 2016/11/21 08:27:30 skrll Exp $ */
2
3/*
4 * Copyright (c) 2003 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*-
33 * Copyright (c) 1999 MAEKAWA Masahide <bishop@rr.iij4u.or.jp>,
34 * Nick Hibma <n_hibma@freebsd.org>
35 * All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 *
46 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 * SUCH DAMAGE.
57 *
58 * $FreeBSD: src/sys/dev/usb/umass.c,v 1.13 2000/03/26 01:39:12 n_hibma Exp $
59 */
60
61/*
62 * Universal Serial Bus Mass Storage Class specs:
63 * http://www.usb.org/developers/docs/devclass_docs/Mass_Storage_Specification_Overview_v1.4_2-19-2010.pdf
64 * http://www.usb.org/developers/docs/devclass_docs/usbmassbulk_10.pdf
65 * http://www.usb.org/developers/docs/devclass_docs/usb_msc_cbi_1.1.pdf
66 * http://www.usb.org/developers/docs/devclass_docs/usbmass-ufi10.pdf
67 */
68
69/*
70 * Ported to NetBSD by Lennart Augustsson <augustss@NetBSD.org>.
71 * Parts of the code written by Jason R. Thorpe <thorpej@shagadelic.org>.
72 */
73
74/*
75 * The driver handles 3 Wire Protocols
76 * - Command/Bulk/Interrupt (CBI)
77 * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI)
78 * - Mass Storage Bulk-Only (BBB)
79 * (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases)
80 *
81 * Over these wire protocols it handles the following command protocols
82 * - SCSI
83 * - 8070 (ATA/ATAPI for rewritable removable media)
84 * - UFI (USB Floppy Interface)
85 *
86 * 8070i is a transformed version of the SCSI command set. UFI is a transformed
87 * version of the 8070i command set. The sc->transform method is used to
88 * convert the commands into the appropriate format (if at all necessary).
89 * For example, ATAPI requires all commands to be 12 bytes in length amongst
90 * other things.
91 *
92 * The source code below is marked and can be split into a number of pieces
93 * (in this order):
94 *
95 * - probe/attach/detach
96 * - generic transfer routines
97 * - BBB
98 * - CBI
99 * - CBI_I (in addition to functions from CBI)
100 * - CAM (Common Access Method)
101 * - SCSI
102 * - UFI
103 * - 8070i
104 *
105 * The protocols are implemented using a state machine, for the transfers as
106 * well as for the resets. The state machine is contained in umass_*_state.
107 * The state machine is started through either umass_*_transfer or
108 * umass_*_reset.
109 *
110 * The reason for doing this is a) CAM performs a lot better this way and b) it
111 * avoids using tsleep from interrupt context (for example after a failed
112 * transfer).
113 */
114
115/*
116 * The SCSI related part of this driver has been derived from the
117 * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org).
118 *
119 * The CAM layer uses so called actions which are messages sent to the host
120 * adapter for completion. The actions come in through umass_cam_action. The
121 * appropriate block of routines is called depending on the transport protocol
122 * in use. When the transfer has finished, these routines call
123 * umass_cam_cb again to complete the CAM command.
124 */
125
126#include <sys/cdefs.h>
127__KERNEL_RCSID(0, "$NetBSD: umass.c,v 1.157 2016/11/21 08:27:30 skrll Exp $");
128
129#ifdef _KERNEL_OPT
130#include "opt_usb.h"
131#endif
132
133#include "atapibus.h"
134#include "scsibus.h"
135#include "wd.h"
136
137#include <sys/param.h>
138#include <sys/systm.h>
139#include <sys/kernel.h>
140#include <sys/conf.h>
141#include <sys/buf.h>
142#include <sys/device.h>
143#include <sys/malloc.h>
144#include <sys/sysctl.h>
145
146#include <dev/usb/usb.h>
147#include <dev/usb/usbdi.h>
148#include <dev/usb/usbdi_util.h>
149#include <dev/usb/usbdevs.h>
150#include <dev/usb/usbhist.h>
151
152#include <dev/usb/umassvar.h>
153#include <dev/usb/umass_quirks.h>
154#include <dev/usb/umass_scsipi.h>
155#include <dev/usb/umass_isdata.h>
156
157#include <dev/scsipi/scsipi_all.h>
158#include <dev/scsipi/scsipiconf.h>
159
160#ifdef USB_DEBUG
161#ifdef UMASS_DEBUG
162int umassdebug = 0;
163
164SYSCTL_SETUP(sysctl_hw_umass_setup, "sysctl hw.umass setup")
165{
166 int err;
167 const struct sysctlnode *rnode;
168 const struct sysctlnode *cnode;
169
170 err = sysctl_createv(clog, 0, NULL, &rnode,
171 CTLFLAG_PERMANENT, CTLTYPE_NODE, "umass",
172 SYSCTL_DESCR("umass global controls"),
173 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
174
175 if (err)
176 goto fail;
177
178 /* control debugging printfs */
179 err = sysctl_createv(clog, 0, &rnode, &cnode,
180 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
181 "debug", SYSCTL_DESCR("Enable debugging output"),
182 NULL, 0, &umassdebug, sizeof(umassdebug), CTL_CREATE, CTL_EOL);
183 if (err)
184 goto fail;
185
186 return;
187fail:
188 aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
189}
190
191const char *states[TSTATE_STATES+1] = {
192 /* should be kept in sync with the list at transfer_state */
193 "Idle",
194 "BBB CBW",
195 "BBB Data",
196 "BBB Data bulk-in/-out clear stall",
197 "BBB CSW, 1st attempt",
198 "BBB CSW bulk-in clear stall",
199 "BBB CSW, 2nd attempt",
200 "BBB Reset",
201 "BBB bulk-in clear stall",
202 "BBB bulk-out clear stall",
203 "CBI Command",
204 "CBI Data",
205 "CBI Status",
206 "CBI Data bulk-in/-out clear stall",
207 "CBI Status intr-in clear stall",
208 "CBI Reset",
209 "CBI bulk-in clear stall",
210 "CBI bulk-out clear stall",
211 NULL
212};
213#endif
214#endif
215
216/* USB device probe/attach/detach functions */
217int umass_match(device_t, cfdata_t, void *);
218void umass_attach(device_t, device_t, void *);
219int umass_detach(device_t, int);
220static void umass_childdet(device_t, device_t);
221int umass_activate(device_t, enum devact);
222extern struct cfdriver umass_cd;
223CFATTACH_DECL2_NEW(umass, sizeof(struct umass_softc), umass_match,
224 umass_attach, umass_detach, umass_activate, NULL, umass_childdet);
225
226Static void umass_disco(struct umass_softc *sc);
227
228/* generic transfer functions */
229Static usbd_status umass_setup_transfer(struct umass_softc *,
230 struct usbd_pipe *,
231 void *, int, int,
232 struct usbd_xfer *);
233Static usbd_status umass_setup_ctrl_transfer(struct umass_softc *,
234 usb_device_request_t *,
235 void *, int, int,
236 struct usbd_xfer *);
237Static void umass_clear_endpoint_stall(struct umass_softc *, int,
238 struct usbd_xfer *);
239#if 0
240Static void umass_reset(struct umass_softc *, transfer_cb_f, void *);
241#endif
242
243/* Bulk-Only related functions */
244Static void umass_bbb_transfer(struct umass_softc *, int, void *, int, void *,
245 int, int, u_int, int, umass_callback, void *);
246Static void umass_bbb_reset(struct umass_softc *, int);
247Static void umass_bbb_state(struct usbd_xfer *, void *, usbd_status);
248
249usbd_status umass_bbb_get_max_lun(struct umass_softc *, uint8_t *);
250
251/* CBI related functions */
252Static void umass_cbi_transfer(struct umass_softc *, int, void *, int, void *,
253 int, int, u_int, int, umass_callback, void *);
254Static void umass_cbi_reset(struct umass_softc *, int);
255Static void umass_cbi_state(struct usbd_xfer *, void *, usbd_status);
256
257Static int umass_cbi_adsc(struct umass_softc *, char *, int, int,
258 struct usbd_xfer *);
259
260const struct umass_wire_methods umass_bbb_methods = {
261 .wire_xfer = umass_bbb_transfer,
262 .wire_reset = umass_bbb_reset,
263 .wire_state = umass_bbb_state
264};
265
266const struct umass_wire_methods umass_cbi_methods = {
267 .wire_xfer = umass_cbi_transfer,
268 .wire_reset = umass_cbi_reset,
269 .wire_state = umass_cbi_state
270};
271
272#ifdef UMASS_DEBUG
273/* General debugging functions */
274Static void umass_bbb_dump_cbw(struct umass_softc *sc,
275 umass_bbb_cbw_t *cbw);
276Static void umass_bbb_dump_csw(struct umass_softc *sc,
277 umass_bbb_csw_t *csw);
278Static void umass_dump_buffer(struct umass_softc *sc, uint8_t *buffer,
279 int buflen, int printlen);
280#endif
281
282
283/*
284 * USB device probe/attach/detach
285 */
286
287int
288umass_match(device_t parent, cfdata_t match, void *aux)
289{
290 struct usbif_attach_arg *uiaa = aux;
291 const struct umass_quirk *quirk;
292
293 quirk = umass_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product);
294 if (quirk != NULL && quirk->uq_match != UMASS_QUIRK_USE_DEFAULTMATCH)
295 return quirk->uq_match;
296
297 if (uiaa->uiaa_class != UICLASS_MASS)
298 return UMATCH_NONE;
299
300 switch (uiaa->uiaa_subclass) {
301 case UISUBCLASS_RBC:
302 case UISUBCLASS_SFF8020I:
303 case UISUBCLASS_QIC157:
304 case UISUBCLASS_UFI:
305 case UISUBCLASS_SFF8070I:
306 case UISUBCLASS_SCSI:
307 break;
308 default:
309 return UMATCH_IFACECLASS;
310 }
311
312 switch (uiaa->uiaa_proto) {
313 case UIPROTO_MASS_CBI_I:
314 case UIPROTO_MASS_CBI:
315 case UIPROTO_MASS_BBB_OLD:
316 case UIPROTO_MASS_BBB:
317 break;
318 default:
319 return UMATCH_IFACECLASS_IFACESUBCLASS;
320 }
321
322 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
323}
324
325void
326umass_attach(device_t parent, device_t self, void *aux)
327{
328 UMASSHIST_FUNC(); UMASSHIST_CALLED();
329 struct umass_softc *sc = device_private(self);
330 struct usbif_attach_arg *uiaa = aux;
331 const struct umass_quirk *quirk;
332 usb_interface_descriptor_t *id;
333 usb_endpoint_descriptor_t *ed;
334 const char *sWire, *sCommand;
335 char *devinfop;
336 usbd_status err;
337 int i, error;
338
339 sc->sc_dev = self;
340
341 aprint_naive("\n");
342 aprint_normal("\n");
343
344 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
345 cv_init(&sc->sc_detach_cv, "umassdet");
346
347 devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
348 aprint_normal_dev(self, "%s\n", devinfop);
349 usbd_devinfo_free(devinfop);
350
351 sc->sc_udev = uiaa->uiaa_device;
352 sc->sc_iface = uiaa->uiaa_iface;
353 sc->sc_ifaceno = uiaa->uiaa_ifaceno;
354
355 quirk = umass_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product);
356 if (quirk != NULL) {
357 sc->sc_wire = quirk->uq_wire;
358 sc->sc_cmd = quirk->uq_cmd;
359 sc->sc_quirks = quirk->uq_flags;
360 sc->sc_busquirks = quirk->uq_busquirks;
361
362 if (quirk->uq_fixup != NULL)
363 (*quirk->uq_fixup)(sc);
364 } else {
365 sc->sc_wire = UMASS_WPROTO_UNSPEC;
366 sc->sc_cmd = UMASS_CPROTO_UNSPEC;
367 sc->sc_quirks = 0;
368 sc->sc_busquirks = 0;
369 }
370
371 if (sc->sc_wire == UMASS_WPROTO_UNSPEC) {
372 switch (uiaa->uiaa_proto) {
373 case UIPROTO_MASS_CBI:
374 sc->sc_wire = UMASS_WPROTO_CBI;
375 break;
376 case UIPROTO_MASS_CBI_I:
377 sc->sc_wire = UMASS_WPROTO_CBI_I;
378 break;
379 case UIPROTO_MASS_BBB:
380 case UIPROTO_MASS_BBB_OLD:
381 sc->sc_wire = UMASS_WPROTO_BBB;
382 break;
383 default:
384 DPRINTFM(UDMASS_GEN, "Unsupported wire protocol %u",
385 uiaa->uiaa_proto, 0, 0, 0);
386 return;
387 }
388 }
389
390 if (sc->sc_cmd == UMASS_CPROTO_UNSPEC) {
391 switch (uiaa->uiaa_subclass) {
392 case UISUBCLASS_SCSI:
393 sc->sc_cmd = UMASS_CPROTO_SCSI;
394 break;
395 case UISUBCLASS_UFI:
396 sc->sc_cmd = UMASS_CPROTO_UFI;
397 break;
398 case UISUBCLASS_SFF8020I:
399 case UISUBCLASS_SFF8070I:
400 case UISUBCLASS_QIC157:
401 sc->sc_cmd = UMASS_CPROTO_ATAPI;
402 break;
403 case UISUBCLASS_RBC:
404 sc->sc_cmd = UMASS_CPROTO_RBC;
405 break;
406 default:
407 DPRINTFM(UDMASS_GEN, "Unsupported command protocol %u",
408 uiaa->uiaa_subclass, 0, 0, 0);
409 return;
410 }
411 }
412
413 switch (sc->sc_wire) {
414 case UMASS_WPROTO_CBI:
415 sWire = "CBI";
416 break;
417 case UMASS_WPROTO_CBI_I:
418 sWire = "CBI with CCI";
419 break;
420 case UMASS_WPROTO_BBB:
421 sWire = "Bulk-Only";
422 break;
423 default:
424 sWire = "unknown";
425 break;
426 }
427
428 switch (sc->sc_cmd) {
429 case UMASS_CPROTO_RBC:
430 sCommand = "RBC";
431 break;
432 case UMASS_CPROTO_SCSI:
433 sCommand = "SCSI";
434 break;
435 case UMASS_CPROTO_UFI:
436 sCommand = "UFI";
437 break;
438 case UMASS_CPROTO_ATAPI:
439 sCommand = "ATAPI";
440 break;
441 case UMASS_CPROTO_ISD_ATA:
442 sCommand = "ISD-ATA";
443 break;
444 default:
445 sCommand = "unknown";
446 break;
447 }
448
449 aprint_verbose_dev(self, "using %s over %s\n", sCommand, sWire);
450
451 if (quirk != NULL && quirk->uq_init != NULL) {
452 err = (*quirk->uq_init)(sc);
453 if (err) {
454 aprint_error_dev(self, "quirk init failed\n");
455 umass_disco(sc);
456 return;
457 }
458 }
459
460 /*
461 * In addition to the Control endpoint the following endpoints
462 * are required:
463 * a) bulk-in endpoint.
464 * b) bulk-out endpoint.
465 * and for Control/Bulk/Interrupt with CCI (CBI_I)
466 * c) intr-in
467 *
468 * The endpoint addresses are not fixed, so we have to read them
469 * from the device descriptors of the current interface.
470 */
471 id = usbd_get_interface_descriptor(sc->sc_iface);
472 for (i = 0 ; i < id->bNumEndpoints ; i++) {
473 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
474 if (ed == NULL) {
475 aprint_error_dev(self,
476 "could not read endpoint descriptor\n");
477 return;
478 }
479 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
480 && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
481 sc->sc_epaddr[UMASS_BULKIN] = ed->bEndpointAddress;
482 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
483 && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
484 sc->sc_epaddr[UMASS_BULKOUT] = ed->bEndpointAddress;
485 } else if (sc->sc_wire == UMASS_WPROTO_CBI_I
486 && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
487 && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
488 sc->sc_epaddr[UMASS_INTRIN] = ed->bEndpointAddress;
489#ifdef UMASS_DEBUG
490 if (UGETW(ed->wMaxPacketSize) > 2) {
491 DPRINTFM(UDMASS_CBI, "sc %p intr size is %d",
492 sc, UGETW(ed->wMaxPacketSize), 0, 0);
493 }
494#endif
495 }
496 }
497
498 /* check whether we found all the endpoints we need */
499 if (!sc->sc_epaddr[UMASS_BULKIN] || !sc->sc_epaddr[UMASS_BULKOUT] ||
500 (sc->sc_wire == UMASS_WPROTO_CBI_I &&
501 !sc->sc_epaddr[UMASS_INTRIN])) {
502 aprint_error_dev(self, "endpoint not found %u/%u/%u\n",
503 sc->sc_epaddr[UMASS_BULKIN],
504 sc->sc_epaddr[UMASS_BULKOUT],
505 sc->sc_epaddr[UMASS_INTRIN]);
506 return;
507 }
508
509 /*
510 * Get the maximum LUN supported by the device.
511 */
512 if (sc->sc_wire == UMASS_WPROTO_BBB &&
513 (sc->sc_quirks & UMASS_QUIRK_NOGETMAXLUN) == 0) {
514 err = umass_bbb_get_max_lun(sc, &sc->maxlun);
515 if (err) {
516 aprint_error_dev(self, "unable to get Max Lun: %s\n",
517 usbd_errstr(err));
518 return;
519 }
520 if (sc->maxlun > 0)
521 sc->sc_busquirks |= PQUIRK_FORCELUNS;
522 } else {
523 sc->maxlun = 0;
524 }
525
526 /* Open the bulk-in and -out pipe */
527 DPRINTFM(UDMASS_USB, "sc %p: opening iface %p epaddr %d for BULKOUT",
528 sc, sc->sc_iface, sc->sc_epaddr[UMASS_BULKOUT], 0);
529 err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKOUT],
530 USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_BULKOUT]);
531 if (err) {
532 aprint_error_dev(self, "cannot open %u-out pipe (bulk)\n",
533 sc->sc_epaddr[UMASS_BULKOUT]);
534 umass_disco(sc);
535 return;
536 }
537 DPRINTFM(UDMASS_USB, "sc %p: opening iface %p epaddr %d for BULKIN",
538 sc, sc->sc_iface, sc->sc_epaddr[UMASS_BULKIN], 0);
539 err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKIN],
540 USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_BULKIN]);
541 if (err) {
542 aprint_error_dev(self, "could not open %u-in pipe (bulk)\n",
543 sc->sc_epaddr[UMASS_BULKIN]);
544 umass_disco(sc);
545 return;
546 }
547 /*
548 * Open the intr-in pipe if the protocol is CBI with CCI.
549 * Note: early versions of the Zip drive do have an interrupt pipe, but
550 * this pipe is unused
551 *
552 * We do not open the interrupt pipe as an interrupt pipe, but as a
553 * normal bulk endpoint. We send an IN transfer down the wire at the
554 * appropriate time, because we know exactly when to expect data on
555 * that endpoint. This saves bandwidth, but more important, makes the
556 * code for handling the data on that endpoint simpler. No data
557 * arriving concurrently.
558 */
559 if (sc->sc_wire == UMASS_WPROTO_CBI_I) {
560 DPRINTFM(UDMASS_USB,
561 "sc %p: opening iface %p epaddr %d for INTRIN",
562 sc, sc->sc_iface, sc->sc_epaddr[UMASS_INTRIN], 0);
563 err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_INTRIN],
564 USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_INTRIN]);
565 if (err) {
566 aprint_error_dev(self, "couldn't open %u-in (intr)\n",
567 sc->sc_epaddr[UMASS_INTRIN]);
568 umass_disco(sc);
569 return;
570 }
571 }
572
573 /* initialisation of generic part */
574 sc->transfer_state = TSTATE_IDLE;
575
576 for (i = 0; i < XFER_NR; i++) {
577 sc->transfer_xfer[i] = NULL;
578 }
579
580 /*
581 * Create the transfers
582 */
583 struct usbd_pipe *pipe0 = usbd_get_pipe0(sc->sc_udev);
584 switch (sc->sc_wire) {
585 case UMASS_WPROTO_BBB:
586 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKIN],
587 UMASS_MAX_TRANSFER_SIZE, USBD_SHORT_XFER_OK, 0,
588 &sc->transfer_xfer[XFER_BBB_DATAIN]);
589 if (err)
590 goto fail_create;
591 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKOUT],
592 UMASS_MAX_TRANSFER_SIZE, USBD_SHORT_XFER_OK, 0,
593 &sc->transfer_xfer[XFER_BBB_DATAOUT]);
594 if (err)
595 goto fail_create;
596 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKOUT],
597 UMASS_BBB_CBW_SIZE, USBD_SHORT_XFER_OK, 0,
598 &sc->transfer_xfer[XFER_BBB_CBW]);
599 if (err)
600 goto fail_create;
601 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKIN],
602 UMASS_BBB_CSW_SIZE, USBD_SHORT_XFER_OK, 0,
603 &sc->transfer_xfer[XFER_BBB_CSW1]);
604 if (err)
605 goto fail_create;
606 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKIN],
607 UMASS_BBB_CSW_SIZE, USBD_SHORT_XFER_OK, 0,
608 &sc->transfer_xfer[XFER_BBB_CSW2]);
609 if (err)
610 goto fail_create;
611 err = usbd_create_xfer(pipe0, 0, 0, 0,
612 &sc->transfer_xfer[XFER_BBB_SCLEAR]);
613 if (err)
614 goto fail_create;
615 err = usbd_create_xfer(pipe0, 0, 0, 0,
616 &sc->transfer_xfer[XFER_BBB_DCLEAR]);
617 if (err)
618 goto fail_create;
619 err = usbd_create_xfer(pipe0, 0, 0, 0,
620 &sc->transfer_xfer[XFER_BBB_RESET1]);
621 if (err)
622 goto fail_create;
623 err = usbd_create_xfer(pipe0, 0, 0, 0,
624 &sc->transfer_xfer[XFER_BBB_RESET2]);
625 if (err)
626 goto fail_create;
627 err = usbd_create_xfer(pipe0, 0, 0, 0,
628 &sc->transfer_xfer[XFER_BBB_RESET3]);
629 if (err)
630 goto fail_create;
631 break;
632 case UMASS_WPROTO_CBI:
633 case UMASS_WPROTO_CBI_I:
634 err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
635 &sc->transfer_xfer[XFER_CBI_CB]);
636 if (err)
637 goto fail_create;
638 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKIN],
639 UMASS_MAX_TRANSFER_SIZE, USBD_SHORT_XFER_OK, 0,
640 &sc->transfer_xfer[XFER_CBI_DATAIN]);
641 if (err)
642 goto fail_create;
643 err = usbd_create_xfer(sc->sc_pipe[UMASS_BULKOUT],
644 UMASS_MAX_TRANSFER_SIZE, 0, 0,
645 &sc->transfer_xfer[XFER_CBI_DATAOUT]);
646 if (err)
647 goto fail_create;
648 err = usbd_create_xfer(sc->sc_pipe[UMASS_INTRIN],
649 sizeof(sc->sbl), 0, 0,
650 &sc->transfer_xfer[XFER_CBI_STATUS]);
651 if (err)
652 goto fail_create;
653 err = usbd_create_xfer(pipe0, 0, 0, 0,
654 &sc->transfer_xfer[XFER_CBI_DCLEAR]);
655 if (err)
656 goto fail_create;
657 err = usbd_create_xfer(pipe0, 0, 0, 0,
658 &sc->transfer_xfer[XFER_CBI_SCLEAR]);
659 if (err)
660 goto fail_create;
661 err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
662 &sc->transfer_xfer[XFER_CBI_RESET1]);
663 if (err)
664 goto fail_create;
665 err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
666 &sc->transfer_xfer[XFER_CBI_RESET2]);
667 if (err)
668 goto fail_create;
669 err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
670 &sc->transfer_xfer[XFER_CBI_RESET3]);
671 if (err)
672 goto fail_create;
673 break;
674 default:
675 fail_create:
676 aprint_error_dev(self, "failed to create xfers\n");
677 umass_disco(sc);
678 return;
679 }
680
681 /*
682 * Record buffer pinters for data transfer (it's huge), command and
683 * status data here
684 */
685 switch (sc->sc_wire) {
686 case UMASS_WPROTO_BBB:
687 sc->datain_buffer =
688 usbd_get_buffer(sc->transfer_xfer[XFER_BBB_DATAIN]);
689 sc->dataout_buffer =
690 usbd_get_buffer(sc->transfer_xfer[XFER_BBB_DATAOUT]);
691 sc->cmd_buffer =
692 usbd_get_buffer(sc->transfer_xfer[XFER_BBB_CBW]);
693 sc->s1_buffer =
694 usbd_get_buffer(sc->transfer_xfer[XFER_BBB_CSW1]);
695 sc->s2_buffer =
696 usbd_get_buffer(sc->transfer_xfer[XFER_BBB_CSW2]);
697 break;
698 case UMASS_WPROTO_CBI:
699 case UMASS_WPROTO_CBI_I:
700 sc->datain_buffer =
701 usbd_get_buffer(sc->transfer_xfer[XFER_CBI_DATAIN]);
702 sc->dataout_buffer =
703 usbd_get_buffer(sc->transfer_xfer[XFER_CBI_DATAOUT]);
704 sc->cmd_buffer =
705 usbd_get_buffer(sc->transfer_xfer[XFER_CBI_CB]);
706 sc->s1_buffer =
707 usbd_get_buffer(sc->transfer_xfer[XFER_CBI_STATUS]);
708 sc->s2_buffer =
709 usbd_get_buffer(sc->transfer_xfer[XFER_CBI_RESET1]);
710 break;
711 default:
712 break;
713 }
714
715 /* Initialise the wire protocol specific methods */
716 switch (sc->sc_wire) {
717 case UMASS_WPROTO_BBB:
718 sc->sc_methods = &umass_bbb_methods;
719 break;
720 case UMASS_WPROTO_CBI:
721 case UMASS_WPROTO_CBI_I:
722 sc->sc_methods = &umass_cbi_methods;
723 break;
724 default:
725 umass_disco(sc);
726 return;
727 }
728
729 error = 0;
730 switch (sc->sc_cmd) {
731 case UMASS_CPROTO_RBC:
732 case UMASS_CPROTO_SCSI:
733#if NSCSIBUS > 0
734 error = umass_scsi_attach(sc);
735#else
736 aprint_error_dev(self, "scsibus not configured\n");
737#endif
738 break;
739
740 case UMASS_CPROTO_UFI:
741 case UMASS_CPROTO_ATAPI:
742#if NATAPIBUS > 0
743 error = umass_atapi_attach(sc);
744#else
745 aprint_error_dev(self, "atapibus not configured\n");
746#endif
747 break;
748
749 case UMASS_CPROTO_ISD_ATA:
750#if NWD > 0
751 error = umass_isdata_attach(sc);
752#else
753 aprint_error_dev(self, "isdata not configured\n");
754#endif
755 break;
756
757 default:
758 aprint_error_dev(self, "command protocol=0x%x not supported\n",
759 sc->sc_cmd);
760 umass_disco(sc);
761 return;
762 }
763 if (error) {
764 aprint_error_dev(self, "bus attach failed\n");
765 umass_disco(sc);
766 return;
767 }
768
769 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
770
771 if (!pmf_device_register(self, NULL, NULL))
772 aprint_error_dev(self, "couldn't establish power handler\n");
773
774 DPRINTFM(UDMASS_GEN, "sc %p: Attach finished", sc, 0, 0, 0);
775
776 return;
777}
778
779static void
780umass_childdet(device_t self, device_t child)
781{
782 struct umass_softc *sc = device_private(self);
783
784 KASSERTMSG(child == sc->bus->sc_child,
785 "assertion child == sc->bus->sc_child failed\n");
786 sc->bus->sc_child = NULL;
787}
788
789int
790umass_detach(device_t self, int flags)
791{
792 UMASSHIST_FUNC(); UMASSHIST_CALLED();
793 struct umass_softc *sc = device_private(self);
794 struct umassbus_softc *scbus;
795 int rv = 0, i;
796
797 DPRINTFM(UDMASS_USB, "sc %p detached", sc, 0, 0, 0);
798
799 pmf_device_deregister(self);
800
801 /* Abort the pipes to wake up any waiting processes. */
802 for (i = 0 ; i < UMASS_NEP ; i++) {
803 if (sc->sc_pipe[i] != NULL)
804 usbd_abort_pipe(sc->sc_pipe[i]);
805 }
806
807 /* Do we really need reference counting? Perhaps in ioctl() */
808 mutex_enter(&sc->sc_lock);
809 if (--sc->sc_refcnt >= 0) {
810#ifdef DIAGNOSTIC
811 aprint_normal_dev(self, "waiting for refcnt\n");
812#endif
813 /* Wait for processes to go away. */
814 usb_detach_wait(sc->sc_dev, &sc->sc_detach_cv, &sc->sc_lock);
815 }
816 mutex_exit(&sc->sc_lock);
817
818 scbus = sc->bus;
819 if (scbus != NULL) {
820 if (scbus->sc_child != NULL)
821 rv = config_detach(scbus->sc_child, flags);
822 free(scbus, M_DEVBUF);
823 sc->bus = NULL;
824 }
825
826 if (rv != 0)
827 return rv;
828
829 umass_disco(sc);
830
831 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
832
833 mutex_destroy(&sc->sc_lock);
834 cv_destroy(&sc->sc_detach_cv);
835
836 return rv;
837}
838
839int
840umass_activate(device_t dev, enum devact act)
841{
842 UMASSHIST_FUNC(); UMASSHIST_CALLED();
843 struct umass_softc *sc = device_private(dev);
844
845 DPRINTFM(UDMASS_USB, "sc %p act %d", sc, act, 0, 0);
846
847 switch (act) {
848 case DVACT_DEACTIVATE:
849 sc->sc_dying = 1;
850 return 0;
851 default:
852 return EOPNOTSUPP;
853 }
854}
855
856Static void
857umass_disco(struct umass_softc *sc)
858{
859 UMASSHIST_FUNC(); UMASSHIST_CALLED();
860 int i;
861
862 /* Remove all the pipes. */
863 for (i = 0 ; i < UMASS_NEP ; i++) {
864 if (sc->sc_pipe[i] != NULL) {
865 usbd_abort_pipe(sc->sc_pipe[i]);
866 }
867 }
868
869 /* Some xfers may be queued in the default pipe */
870 usbd_abort_default_pipe(sc->sc_udev);
871
872 /* Free the xfers. */
873 for (i = 0; i < XFER_NR; i++) {
874 if (sc->transfer_xfer[i] != NULL) {
875 usbd_destroy_xfer(sc->transfer_xfer[i]);
876 sc->transfer_xfer[i] = NULL;
877 }
878 }
879
880 for (i = 0 ; i < UMASS_NEP ; i++) {
881 if (sc->sc_pipe[i] != NULL) {
882 usbd_close_pipe(sc->sc_pipe[i]);
883 sc->sc_pipe[i] = NULL;
884 }
885 }
886
887}
888
889/*
890 * Generic functions to handle transfers
891 */
892
893Static usbd_status
894umass_setup_transfer(struct umass_softc *sc, struct usbd_pipe *pipe,
895 void *buffer, int buflen, int flags,
896 struct usbd_xfer *xfer)
897{
898 UMASSHIST_FUNC(); UMASSHIST_CALLED();
899 usbd_status err;
900
901 if (sc->sc_dying)
902 return USBD_IOERROR;
903
904 /* Initialiase a USB transfer and then schedule it */
905
906 usbd_setup_xfer(xfer, sc, buffer, buflen, flags, sc->timeout,
907 sc->sc_methods->wire_state);
908
909 err = usbd_transfer(xfer);
910 DPRINTFM(UDMASS_XFER, "start xfer buffer=%p buflen=%d flags=0x%x "
911 "timeout=%d", buffer, buflen, flags, sc->timeout);
912 if (err && err != USBD_IN_PROGRESS) {
913 DPRINTFM(UDMASS_BBB, "failed to setup transfer... err=%d",
914 err, 0, 0, 0);
915 return err;
916 }
917
918 return USBD_NORMAL_COMPLETION;
919}
920
921
922Static usbd_status
923umass_setup_ctrl_transfer(struct umass_softc *sc, usb_device_request_t *req,
924 void *buffer, int buflen, int flags, struct usbd_xfer *xfer)
925{
926 UMASSHIST_FUNC(); UMASSHIST_CALLED();
927 usbd_status err;
928
929 if (sc->sc_dying)
930 return USBD_IOERROR;
931
932 /* Initialiase a USB control transfer and then schedule it */
933
934 usbd_setup_default_xfer(xfer, sc->sc_udev, (void *) sc, sc->timeout,
935 req, buffer, buflen, flags, sc->sc_methods->wire_state);
936
937 err = usbd_transfer(xfer);
938 if (err && err != USBD_IN_PROGRESS) {
939 DPRINTFM(UDMASS_BBB, "failed to setup ctrl transfer... err=%d",
940 err, 0, 0, 0);
941
942 /* do not reset, as this would make us loop */
943 return err;
944 }
945
946 return USBD_NORMAL_COMPLETION;
947}
948
949Static void
950umass_clear_endpoint_stall(struct umass_softc *sc, int endpt,
951 struct usbd_xfer *xfer)
952{
953 UMASSHIST_FUNC(); UMASSHIST_CALLED();
954
955 if (sc->sc_dying)
956 return;
957
958 DPRINTFM(UDMASS_BBB, "Clear endpoint 0x%02x stall",
959 sc->sc_epaddr[endpt], 0, 0, 0);
960
961 usbd_clear_endpoint_toggle(sc->sc_pipe[endpt]);
962
963 sc->sc_req.bmRequestType = UT_WRITE_ENDPOINT;
964 sc->sc_req.bRequest = UR_CLEAR_FEATURE;
965 USETW(sc->sc_req.wValue, UF_ENDPOINT_HALT);
966 USETW(sc->sc_req.wIndex, sc->sc_epaddr[endpt]);
967 USETW(sc->sc_req.wLength, 0);
968 umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0, xfer);
969}
970
971#if 0
972Static void
973umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv)
974{
975 sc->transfer_cb = cb;
976 sc->transfer_priv = priv;
977
978 /* The reset is a forced reset, so no error (yet) */
979 sc->reset(sc, STATUS_CMD_OK);
980}
981#endif
982
983/*
984 * Bulk protocol specific functions
985 */
986
987Static void
988umass_bbb_reset(struct umass_softc *sc, int status)
989{
990 UMASSHIST_FUNC(); UMASSHIST_CALLED();
991 KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
992 "sc->sc_wire == 0x%02x wrong for umass_bbb_reset\n",
993 sc->sc_wire);
994
995 if (sc->sc_dying)
996 return;
997
998 /*
999 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
1000 *
1001 * For Reset Recovery the host shall issue in the following order:
1002 * a) a Bulk-Only Mass Storage Reset
1003 * b) a Clear Feature HALT to the Bulk-In endpoint
1004 * c) a Clear Feature HALT to the Bulk-Out endpoint
1005 *
1006 * This is done in 3 steps, states:
1007 * TSTATE_BBB_RESET1
1008 * TSTATE_BBB_RESET2
1009 * TSTATE_BBB_RESET3
1010 *
1011 * If the reset doesn't succeed, the device should be port reset.
1012 */
1013
1014 DPRINTFM(UDMASS_BBB, "Bulk Reset", 0, 0, 0, 0);
1015
1016 sc->transfer_state = TSTATE_BBB_RESET1;
1017 sc->transfer_status = status;
1018
1019 /* reset is a class specific interface write */
1020 sc->sc_req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
1021 sc->sc_req.bRequest = UR_BBB_RESET;
1022 USETW(sc->sc_req.wValue, 0);
1023 USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
1024 USETW(sc->sc_req.wLength, 0);
1025 umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0,
1026 sc->transfer_xfer[XFER_BBB_RESET1]);
1027}
1028
1029Static void
1030umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen,
1031 void *data, int datalen, int dir, u_int timeout,
1032 int flags, umass_callback cb, void *priv)
1033{
1034 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1035 static int dCBWtag = 42; /* unique for CBW of transfer */
1036
1037 DPRINTFM(UDMASS_BBB, "sc %p cmd=0x%02x", sc, *(u_char *)cmd, 0, 0);
1038
1039 KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
1040 "sc->sc_wire == 0x%02x wrong for umass_bbb_transfer\n",
1041 sc->sc_wire);
1042
1043 if (sc->sc_dying)
1044 return;
1045
1046 /* Be a little generous. */
1047 sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
1048
1049 /*
1050 * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly
1051 * a data phase of datalen bytes from/to the device and finally a
1052 * csw read phase.
1053 * If the data direction was inbound a maximum of datalen bytes
1054 * is stored in the buffer pointed to by data.
1055 *
1056 * umass_bbb_transfer initialises the transfer and lets the state
1057 * machine in umass_bbb_state handle the completion. It uses the
1058 * following states:
1059 * TSTATE_BBB_COMMAND
1060 * -> TSTATE_BBB_DATA
1061 * -> TSTATE_BBB_STATUS
1062 * -> TSTATE_BBB_STATUS2
1063 * -> TSTATE_BBB_IDLE
1064 *
1065 * An error in any of those states will invoke
1066 * umass_bbb_reset.
1067 */
1068
1069 /* check the given arguments */
1070 KASSERTMSG(datalen == 0 || data != NULL,
1071 "%s: datalen > 0, but no buffer",device_xname(sc->sc_dev));
1072 KASSERTMSG(cmdlen <= CBWCDBLENGTH,
1073 "%s: cmdlen exceeds CDB length in CBW (%d > %d)",
1074 device_xname(sc->sc_dev), cmdlen, CBWCDBLENGTH);
1075 KASSERTMSG(dir == DIR_NONE || datalen > 0,
1076 "%s: datalen == 0 while direction is not NONE\n",
1077 device_xname(sc->sc_dev));
1078 KASSERTMSG(datalen == 0 || dir != DIR_NONE,
1079 "%s: direction is NONE while datalen is not zero\n",
1080 device_xname(sc->sc_dev));
1081 /* CTASSERT */
1082 KASSERTMSG(sizeof(umass_bbb_cbw_t) == UMASS_BBB_CBW_SIZE,
1083 "%s: CBW struct does not have the right size (%zu vs. %u)\n",
1084 device_xname(sc->sc_dev),
1085 sizeof(umass_bbb_cbw_t), UMASS_BBB_CBW_SIZE);
1086 /* CTASSERT */
1087 KASSERTMSG(sizeof(umass_bbb_csw_t) == UMASS_BBB_CSW_SIZE,
1088 "%s: CSW struct does not have the right size (%zu vs. %u)\n",
1089 device_xname(sc->sc_dev),
1090 sizeof(umass_bbb_csw_t), UMASS_BBB_CSW_SIZE);
1091
1092 /*
1093 * Determine the direction of the data transfer and the length.
1094 *
1095 * dCBWDataTransferLength (datalen) :
1096 * This field indicates the number of bytes of data that the host
1097 * intends to transfer on the IN or OUT Bulk endpoint(as indicated by
1098 * the Direction bit) during the execution of this command. If this
1099 * field is set to 0, the device will expect that no data will be
1100 * transferred IN or OUT during this command, regardless of the value
1101 * of the Direction bit defined in dCBWFlags.
1102 *
1103 * dCBWFlags (dir) :
1104 * The bits of the Flags field are defined as follows:
1105 * Bits 0-6 reserved
1106 * Bit 7 Direction - this bit shall be ignored if the
1107 * dCBWDataTransferLength field is zero.
1108 * 0 = data Out from host to device
1109 * 1 = data In from device to host
1110 */
1111
1112 /* Fill in the Command Block Wrapper */
1113 USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE);
1114 USETDW(sc->cbw.dCBWTag, dCBWtag);
1115 dCBWtag++; /* cannot be done in macro (it will be done 4 times) */
1116 USETDW(sc->cbw.dCBWDataTransferLength, datalen);
1117 /* DIR_NONE is treated as DIR_OUT (0x00) */
1118 sc->cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT);
1119 sc->cbw.bCBWLUN = lun;
1120 sc->cbw.bCDBLength = cmdlen;
1121 memcpy(sc->cbw.CBWCDB, cmd, cmdlen);
1122
1123 DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw));
1124
1125 /* store the details for the data transfer phase */
1126 sc->transfer_dir = dir;
1127 sc->transfer_data = data;
1128 sc->transfer_datalen = datalen;
1129 sc->transfer_actlen = 0;
1130 sc->transfer_cb = cb;
1131 sc->transfer_priv = priv;
1132 sc->transfer_status = STATUS_CMD_OK;
1133
1134 /* move from idle to the command state */
1135 sc->transfer_state = TSTATE_BBB_COMMAND;
1136
1137 /* Send the CBW from host to device via bulk-out endpoint. */
1138 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKOUT],
1139 &sc->cbw, UMASS_BBB_CBW_SIZE, flags,
1140 sc->transfer_xfer[XFER_BBB_CBW])) {
1141 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1142 }
1143}
1144
1145
1146Static void
1147umass_bbb_state(struct usbd_xfer *xfer, void *priv,
1148 usbd_status err)
1149{
1150 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1151 struct umass_softc *sc = (struct umass_softc *) priv;
1152 struct usbd_xfer *next_xfer;
1153 int residue;
1154
1155 KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
1156 "sc->sc_wire == 0x%02x wrong for umass_bbb_state\n",
1157 sc->sc_wire);
1158
1159 if (sc->sc_dying)
1160 return;
1161
1162 /*
1163 * State handling for BBB transfers.
1164 *
1165 * The subroutine is rather long. It steps through the states given in
1166 * Annex A of the Bulk-Only specification.
1167 * Each state first does the error handling of the previous transfer
1168 * and then prepares the next transfer.
1169 * Each transfer is done asynchroneously so after the request/transfer
1170 * has been submitted you will find a 'return;'.
1171 */
1172
1173 DPRINTFM(UDMASS_BBB, "sc %p xfer %p, transfer_state %d dir %d", sc,
1174 xfer, sc->transfer_state, sc->transfer_dir);
1175
1176 switch (sc->transfer_state) {
1177
1178 /***** Bulk Transfer *****/
1179 case TSTATE_BBB_COMMAND:
1180 /* Command transport phase, error handling */
1181 if (err) {
1182 DPRINTFM(UDMASS_BBB, "sc %p failed to send CBW", sc,
1183 0, 0, 0);
1184 /* If the device detects that the CBW is invalid, then
1185 * the device may STALL both bulk endpoints and require
1186 * a Bulk-Reset
1187 */
1188 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1189 return;
1190 }
1191
1192 /* Data transport phase, setup transfer */
1193 sc->transfer_state = TSTATE_BBB_DATA;
1194 if (sc->transfer_dir == DIR_IN) {
1195 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
1196 sc->datain_buffer, sc->transfer_datalen,
1197 USBD_SHORT_XFER_OK,
1198 sc->transfer_xfer[XFER_BBB_DATAIN]))
1199 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1200
1201 return;
1202 } else if (sc->transfer_dir == DIR_OUT) {
1203 memcpy(sc->dataout_buffer, sc->transfer_data,
1204 sc->transfer_datalen);
1205 if (umass_setup_transfer(sc,
1206 sc->sc_pipe[UMASS_BULKOUT], sc->dataout_buffer,
1207 sc->transfer_datalen, 0,/* fixed length transfer */
1208 sc->transfer_xfer[XFER_BBB_DATAOUT]))
1209 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1210
1211 return;
1212 } else {
1213 DPRINTFM(UDMASS_BBB, "sc %p: no data phase", sc, 0, 0,
1214 0);
1215 }
1216
1217 /* FALLTHROUGH if no data phase, err == 0 */
1218 case TSTATE_BBB_DATA:
1219 /* Command transport phase error handling (ignored if no data
1220 * phase (fallthrough from previous state)) */
1221 if (sc->transfer_dir != DIR_NONE) {
1222 /* retrieve the length of the transfer that was done */
1223 usbd_get_xfer_status(xfer, NULL, NULL,
1224 &sc->transfer_actlen, NULL);
1225 DPRINTFM(UDMASS_BBB, "sc %p: BBB_DATA actlen=%d",
1226 sc, sc->transfer_actlen, 0, 0);
1227
1228 if (err) {
1229 DPRINTFM(UDMASS_BBB, "sc %p Data dir %d err %d"
1230 " failed, ", sc, sc->transfer_dir,
1231 sc->transfer_datalen, err);
1232
1233 if (err == USBD_STALLED) {
1234 sc->transfer_state = TSTATE_BBB_DCLEAR;
1235 umass_clear_endpoint_stall(sc,
1236 (sc->transfer_dir == DIR_IN?
1237 UMASS_BULKIN:UMASS_BULKOUT),
1238 sc->transfer_xfer[XFER_BBB_DCLEAR]);
1239 } else {
1240 /* Unless the error is a pipe stall the
1241 * error is fatal.
1242 */
1243 umass_bbb_reset(sc,STATUS_WIRE_FAILED);
1244 }
1245 return;
1246 }
1247 }
1248
1249 /* FALLTHROUGH, err == 0 (no data phase or successful) */
1250 case TSTATE_BBB_DCLEAR: /* stall clear after data phase */
1251 if (sc->transfer_dir == DIR_IN)
1252 memcpy(sc->transfer_data, sc->datain_buffer,
1253 sc->transfer_actlen);
1254
1255 DIF(UDMASS_BBB, if (sc->transfer_dir == DIR_IN)
1256 umass_dump_buffer(sc, sc->transfer_data,
1257 sc->transfer_datalen, 48));
1258
1259 /* FALLTHROUGH, err == 0 (no data phase or successful) */
1260 case TSTATE_BBB_SCLEAR: /* stall clear after status phase */
1261 /* Reading of CSW after bulk stall condition in data phase
1262 * (TSTATE_BBB_DATA2) or bulk-in stall condition after
1263 * reading CSW (TSTATE_BBB_SCLEAR).
1264 * In the case of no data phase or successful data phase,
1265 * err == 0 and the following if block is passed.
1266 */
1267 if (err) { /* should not occur */
1268 printf("%s: BBB bulk-%s stall clear failed, %s\n",
1269 device_xname(sc->sc_dev),
1270 (sc->transfer_dir == DIR_IN? "in":"out"),
1271 usbd_errstr(err));
1272 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1273 return;
1274 }
1275
1276 /* Status transport phase, setup transfer */
1277 if (sc->transfer_state == TSTATE_BBB_COMMAND ||
1278 sc->transfer_state == TSTATE_BBB_DATA ||
1279 sc->transfer_state == TSTATE_BBB_DCLEAR) {
1280 /* After no data phase, successful data phase and
1281 * after clearing bulk-in/-out stall condition
1282 */
1283 sc->transfer_state = TSTATE_BBB_STATUS1;
1284 next_xfer = sc->transfer_xfer[XFER_BBB_CSW1];
1285 } else {
1286 /* After first attempt of fetching CSW */
1287 sc->transfer_state = TSTATE_BBB_STATUS2;
1288 next_xfer = sc->transfer_xfer[XFER_BBB_CSW2];
1289 }
1290
1291 /* Read the Command Status Wrapper via bulk-in endpoint. */
1292 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
1293 &sc->csw, UMASS_BBB_CSW_SIZE, 0, next_xfer)) {
1294 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1295 return;
1296 }
1297
1298 return;
1299 case TSTATE_BBB_STATUS1: /* first attempt */
1300 case TSTATE_BBB_STATUS2: /* second attempt */
1301 /* Status transfer, error handling */
1302 if (err) {
1303 DPRINTFM(UDMASS_BBB, "sc %p Failed to read CSW err %d "
1304 "(state %d)", sc, err, sc->transfer_state, 0);
1305
1306 /* If this was the first attempt at fetching the CSW
1307 * retry it, otherwise fail.
1308 */
1309 if (sc->transfer_state == TSTATE_BBB_STATUS1) {
1310 sc->transfer_state = TSTATE_BBB_SCLEAR;
1311 umass_clear_endpoint_stall(sc, UMASS_BULKIN,
1312 sc->transfer_xfer[XFER_BBB_SCLEAR]);
1313 return;
1314 } else {
1315 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1316 return;
1317 }
1318 }
1319
1320 DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw));
1321
1322#ifdef UMASS_DEBUG
1323 residue = UGETDW(sc->csw.dCSWDataResidue);
1324 if (residue != sc->transfer_datalen - sc->transfer_actlen)
1325 printf("%s: dCSWDataResidue=%d req=%d act=%d\n",
1326 device_xname(sc->sc_dev), residue,
1327 sc->transfer_datalen, sc->transfer_actlen);
1328#endif
1329 residue = sc->transfer_datalen - sc->transfer_actlen;
1330
1331 /* Translate weird command-status signatures. */
1332 if ((sc->sc_quirks & UMASS_QUIRK_WRONG_CSWSIG) &&
1333 UGETDW(sc->csw.dCSWSignature) == CSWSIGNATURE_OLYMPUS_C1)
1334 USETDW(sc->csw.dCSWSignature, CSWSIGNATURE);
1335
1336 /* Translate invalid command-status tags */
1337 if (sc->sc_quirks & UMASS_QUIRK_WRONG_CSWTAG)
1338 USETDW(sc->csw.dCSWTag, UGETDW(sc->cbw.dCBWTag));
1339
1340 /* Check CSW and handle any error */
1341 if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) {
1342 /* Invalid CSW: Wrong signature or wrong tag might
1343 * indicate that the device is confused -> reset it.
1344 */
1345 printf("%s: Invalid CSW: sig 0x%08x should be 0x%08x\n",
1346 device_xname(sc->sc_dev),
1347 UGETDW(sc->csw.dCSWSignature),
1348 CSWSIGNATURE);
1349
1350 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1351 return;
1352 } else if (UGETDW(sc->csw.dCSWTag)
1353 != UGETDW(sc->cbw.dCBWTag)) {
1354 printf("%s: Invalid CSW: tag %d should be %d\n",
1355 device_xname(sc->sc_dev),
1356 UGETDW(sc->csw.dCSWTag),
1357 UGETDW(sc->cbw.dCBWTag));
1358
1359 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1360 return;
1361
1362 /* CSW is valid here */
1363 } else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) {
1364 printf("%s: Invalid CSW: status %d > %d\n",
1365 device_xname(sc->sc_dev),
1366 sc->csw.bCSWStatus,
1367 CSWSTATUS_PHASE);
1368
1369 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1370 return;
1371 } else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) {
1372 printf("%s: Phase Error, residue = %d\n",
1373 device_xname(sc->sc_dev), residue);
1374
1375 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1376 return;
1377
1378 } else if (sc->transfer_actlen > sc->transfer_datalen) {
1379 /* Buffer overrun! Don't let this go by unnoticed */
1380 panic("%s: transferred %s %d bytes instead of %d bytes",
1381 device_xname(sc->sc_dev),
1382 sc->transfer_dir == DIR_IN ? "IN" : "OUT",
1383 sc->transfer_actlen, sc->transfer_datalen);
1384#if 0
1385 } else if (sc->transfer_datalen - sc->transfer_actlen
1386 != residue) {
1387 DPRINTFM(UDMASS_BBB, "sc %p: actlen=%d != residue=%d\n",
1388 sc,
1389 sc->transfer_datalen - sc->transfer_actlen,
1390 residue));
1391
1392 umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1393 return;
1394#endif
1395 } else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) {
1396 DPRINTFM(UDMASS_BBB, "sc %p: Command Failed, res = %d",
1397 sc, residue, 0, 0);
1398
1399 /* SCSI command failed but transfer was succesful */
1400 sc->transfer_state = TSTATE_IDLE;
1401 sc->transfer_cb(sc, sc->transfer_priv, residue,
1402 STATUS_CMD_FAILED);
1403
1404 return;
1405
1406 } else { /* success */
1407 sc->transfer_state = TSTATE_IDLE;
1408 sc->transfer_cb(sc, sc->transfer_priv, residue,
1409 STATUS_CMD_OK);
1410
1411 return;
1412 }
1413
1414 /***** Bulk Reset *****/
1415 case TSTATE_BBB_RESET1:
1416 if (err)
1417 printf("%s: BBB reset failed, %s\n",
1418 device_xname(sc->sc_dev), usbd_errstr(err));
1419
1420 sc->transfer_state = TSTATE_BBB_RESET2;
1421 umass_clear_endpoint_stall(sc, UMASS_BULKIN,
1422 sc->transfer_xfer[XFER_BBB_RESET2]);
1423
1424 return;
1425 case TSTATE_BBB_RESET2:
1426 if (err) /* should not occur */
1427 printf("%s: BBB bulk-in clear stall failed, %s\n",
1428 device_xname(sc->sc_dev), usbd_errstr(err));
1429 /* no error recovery, otherwise we end up in a loop */
1430
1431 sc->transfer_state = TSTATE_BBB_RESET3;
1432 umass_clear_endpoint_stall(sc, UMASS_BULKOUT,
1433 sc->transfer_xfer[XFER_BBB_RESET3]);
1434
1435 return;
1436 case TSTATE_BBB_RESET3:
1437 if (err) /* should not occur */
1438 printf("%s: BBB bulk-out clear stall failed, %s\n",
1439 device_xname(sc->sc_dev), usbd_errstr(err));
1440 /* no error recovery, otherwise we end up in a loop */
1441
1442 sc->transfer_state = TSTATE_IDLE;
1443 if (sc->transfer_priv) {
1444 sc->transfer_cb(sc, sc->transfer_priv,
1445 sc->transfer_datalen,
1446 sc->transfer_status);
1447 }
1448
1449 return;
1450
1451 /***** Default *****/
1452 default:
1453 panic("%s: Unknown state %d",
1454 device_xname(sc->sc_dev), sc->transfer_state);
1455 }
1456}
1457
1458/*
1459 * Command/Bulk/Interrupt (CBI) specific functions
1460 */
1461
1462Static int
1463umass_cbi_adsc(struct umass_softc *sc, char *buffer, int buflen, int flags,
1464 struct usbd_xfer *xfer)
1465{
1466 KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
1467 "sc->sc_wire == 0x%02x wrong for umass_cbi_adsc\n",
1468 sc->sc_wire);
1469
1470 if ((sc->sc_cmd == UMASS_CPROTO_RBC) &&
1471 (sc->sc_quirks & UMASS_QUIRK_RBC_PAD_TO_12) != 0 && buflen < 12) {
1472 (void)memset(buffer + buflen, 0, 12 - buflen);
1473 buflen = 12;
1474 }
1475
1476 sc->sc_req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
1477 sc->sc_req.bRequest = UR_CBI_ADSC;
1478 USETW(sc->sc_req.wValue, 0);
1479 USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
1480 USETW(sc->sc_req.wLength, buflen);
1481 return umass_setup_ctrl_transfer(sc, &sc->sc_req, buffer,
1482 buflen, flags, xfer);
1483}
1484
1485
1486Static void
1487umass_cbi_reset(struct umass_softc *sc, int status)
1488{
1489 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1490 int i;
1491# define SEND_DIAGNOSTIC_CMDLEN 12
1492
1493 KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
1494 "sc->sc_wire == 0x%02x wrong for umass_cbi_reset\n",
1495 sc->sc_wire);
1496
1497 if (sc->sc_dying)
1498 return;
1499
1500 /*
1501 * Command Block Reset Protocol
1502 *
1503 * First send a reset request to the device. Then clear
1504 * any possibly stalled bulk endpoints.
1505
1506 * This is done in 3 steps, states:
1507 * TSTATE_CBI_RESET1
1508 * TSTATE_CBI_RESET2
1509 * TSTATE_CBI_RESET3
1510 *
1511 * If the reset doesn't succeed, the device should be port reset.
1512 */
1513
1514 DPRINTFM(UDMASS_CBI, "sc %p: CBI Reset", sc, 0, 0, 0);
1515
1516 /* CTASSERT */
1517 KASSERTMSG(sizeof(sc->cbl) >= SEND_DIAGNOSTIC_CMDLEN,
1518 "%s: CBL struct is too small (%zu < %u)\n",
1519 device_xname(sc->sc_dev),
1520 sizeof(sc->cbl), SEND_DIAGNOSTIC_CMDLEN);
1521
1522 sc->transfer_state = TSTATE_CBI_RESET1;
1523 sc->transfer_status = status;
1524
1525 /* The 0x1d code is the SEND DIAGNOSTIC command. To distingiush between
1526 * the two the last 10 bytes of the cbl is filled with 0xff (section
1527 * 2.2 of the CBI spec).
1528 */
1529 sc->cbl[0] = 0x1d; /* Command Block Reset */
1530 sc->cbl[1] = 0x04;
1531 for (i = 2; i < SEND_DIAGNOSTIC_CMDLEN; i++)
1532 sc->cbl[i] = 0xff;
1533
1534 umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN, 0,
1535 sc->transfer_xfer[XFER_CBI_RESET1]);
1536 /* XXX if the command fails we should reset the port on the bub */
1537}
1538
1539Static void
1540umass_cbi_transfer(struct umass_softc *sc, int lun,
1541 void *cmd, int cmdlen, void *data, int datalen, int dir,
1542 u_int timeout, int flags, umass_callback cb, void *priv)
1543{
1544 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1545
1546 DPRINTFM(UDMASS_CBI, "sc %p: cmd=0x%02x, len=%d", sc, *(u_char *)cmd,
1547 datalen, 0);
1548
1549 KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
1550 "sc->sc_wire == 0x%02x wrong for umass_cbi_transfer\n",
1551 sc->sc_wire);
1552
1553 if (sc->sc_dying)
1554 return;
1555
1556 /* Be a little generous. */
1557 sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
1558
1559 /*
1560 * Do a CBI transfer with cmdlen bytes from cmd, possibly
1561 * a data phase of datalen bytes from/to the device and finally a
1562 * csw read phase.
1563 * If the data direction was inbound a maximum of datalen bytes
1564 * is stored in the buffer pointed to by data.
1565 *
1566 * umass_cbi_transfer initialises the transfer and lets the state
1567 * machine in umass_cbi_state handle the completion. It uses the
1568 * following states:
1569 * TSTATE_CBI_COMMAND
1570 * -> XXX fill in
1571 *
1572 * An error in any of those states will invoke
1573 * umass_cbi_reset.
1574 */
1575
1576 /* check the given arguments */
1577 KASSERTMSG(datalen == 0 || data != NULL,
1578 "%s: datalen > 0, but no buffer",device_xname(sc->sc_dev));
1579 KASSERTMSG(datalen == 0 || dir != DIR_NONE,
1580 "%s: direction is NONE while datalen is not zero\n",
1581 device_xname(sc->sc_dev));
1582
1583 /* store the details for the data transfer phase */
1584 sc->transfer_dir = dir;
1585 sc->transfer_data = data;
1586 sc->transfer_datalen = datalen;
1587 sc->transfer_actlen = 0;
1588 sc->transfer_cb = cb;
1589 sc->transfer_priv = priv;
1590 sc->transfer_status = STATUS_CMD_OK;
1591
1592 /* move from idle to the command state */
1593 sc->transfer_state = TSTATE_CBI_COMMAND;
1594
1595 /* Send the Command Block from host to device via control endpoint. */
1596 if (umass_cbi_adsc(sc, cmd, cmdlen, flags,
1597 sc->transfer_xfer[XFER_CBI_CB]))
1598 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1599}
1600
1601Static void
1602umass_cbi_state(struct usbd_xfer *xfer, void *priv,
1603 usbd_status err)
1604{
1605 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1606 struct umass_softc *sc = (struct umass_softc *) priv;
1607
1608 KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
1609 "sc->sc_wire == 0x%02x wrong for umass_cbi_state\n",
1610 sc->sc_wire);
1611
1612 if (sc->sc_dying)
1613 return;
1614
1615 /*
1616 * State handling for CBI transfers.
1617 */
1618
1619 DPRINTFM(UDMASS_CBI, "sc %p: Handling CBI state %d, xfer=%p, ...",
1620 sc, sc->transfer_state, xfer, 0);
1621 DPRINTFM(UDMASS_CBI, "... err %d", err, 0, 0, 0);
1622
1623 switch (sc->transfer_state) {
1624
1625 /***** CBI Transfer *****/
1626 case TSTATE_CBI_COMMAND:
1627 if (err == USBD_STALLED) {
1628 DPRINTFM(UDMASS_CBI, "sc %p: Command Transport failed",
1629 sc, 0, 0, 0);
1630 /* Status transport by control pipe (section 2.3.2.1).
1631 * The command contained in the command block failed.
1632 *
1633 * The control pipe has already been unstalled by the
1634 * USB stack.
1635 * Section 2.4.3.1.1 states that the bulk in endpoints
1636 * should not stalled at this point.
1637 */
1638
1639 sc->transfer_state = TSTATE_IDLE;
1640 sc->transfer_cb(sc, sc->transfer_priv,
1641 sc->transfer_datalen,
1642 STATUS_CMD_FAILED);
1643
1644 return;
1645 } else if (err) {
1646 DPRINTFM(UDMASS_CBI, "sc %p: failed to send ADSC",
1647 sc, 0, 0, 0);
1648 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1649 return;
1650 }
1651
1652 /* Data transport phase, setup transfer */
1653 sc->transfer_state = TSTATE_CBI_DATA;
1654 if (sc->transfer_dir == DIR_IN) {
1655 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKIN],
1656 sc->datain_buffer, sc->transfer_datalen,
1657 USBD_SHORT_XFER_OK,
1658 sc->transfer_xfer[XFER_CBI_DATAIN]))
1659 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1660
1661 return;
1662 } else if (sc->transfer_dir == DIR_OUT) {
1663 memcpy(sc->dataout_buffer, sc->transfer_data,
1664 sc->transfer_datalen);
1665 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_BULKOUT],
1666 sc->dataout_buffer, sc->transfer_datalen,
1667 0, /* fixed length transfer */
1668 sc->transfer_xfer[XFER_CBI_DATAOUT]))
1669 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1670
1671 return;
1672 } else {
1673 DPRINTFM(UDMASS_CBI, "sc %p: no data phase", sc, 0, 0,
1674 0);
1675 }
1676
1677 /* FALLTHROUGH if no data phase, err == 0 */
1678 case TSTATE_CBI_DATA:
1679 /* Command transport phase error handling (ignored if no data
1680 * phase (fallthrough from previous state)) */
1681 if (sc->transfer_dir != DIR_NONE) {
1682 /* retrieve the length of the transfer that was done */
1683 usbd_get_xfer_status(xfer, NULL, NULL,
1684 &sc->transfer_actlen, NULL);
1685 DPRINTFM(UDMASS_CBI, "sc %p: CBI_DATA actlen=%d",
1686 sc, sc->transfer_actlen, 0, 0);
1687
1688 if (err) {
1689 DPRINTFM(UDMASS_CBI, "sc %p: Data dir %d "
1690 "err %d failed", sc, sc->transfer_dir,
1691 sc->transfer_datalen, err);
1692
1693 if (err == USBD_STALLED) {
1694 sc->transfer_state = TSTATE_CBI_DCLEAR;
1695 umass_clear_endpoint_stall(sc,
1696 (sc->transfer_dir == DIR_IN?
1697 UMASS_BULKIN:UMASS_BULKOUT),
1698 sc->transfer_xfer[XFER_CBI_DCLEAR]);
1699 } else {
1700 /* Unless the error is a pipe stall the
1701 * error is fatal.
1702 */
1703 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1704 }
1705 return;
1706 }
1707 }
1708
1709 if (sc->transfer_dir == DIR_IN)
1710 memcpy(sc->transfer_data, sc->datain_buffer,
1711 sc->transfer_actlen);
1712
1713 DIF(UDMASS_CBI, if (sc->transfer_dir == DIR_IN)
1714 umass_dump_buffer(sc, sc->transfer_data,
1715 sc->transfer_actlen, 48));
1716
1717 /* Status phase */
1718 if (sc->sc_wire == UMASS_WPROTO_CBI_I) {
1719 sc->transfer_state = TSTATE_CBI_STATUS;
1720 memset(&sc->sbl, 0, sizeof(sc->sbl));
1721 if (umass_setup_transfer(sc, sc->sc_pipe[UMASS_INTRIN],
1722 &sc->sbl, sizeof(sc->sbl),
1723 0, /* fixed length transfer */
1724 sc->transfer_xfer[XFER_CBI_STATUS]))
1725 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1726 } else {
1727 /* No command completion interrupt. Request
1728 * sense to get status of command.
1729 */
1730 sc->transfer_state = TSTATE_IDLE;
1731 sc->transfer_cb(sc, sc->transfer_priv,
1732 sc->transfer_datalen - sc->transfer_actlen,
1733 STATUS_CMD_UNKNOWN);
1734 }
1735 return;
1736
1737 case TSTATE_CBI_STATUS:
1738 if (err) {
1739 DPRINTFM(UDMASS_CBI, "sc %p: Status Transport failed",
1740 sc, 0, 0, 0);
1741 /* Status transport by interrupt pipe (section 2.3.2.2).
1742 */
1743
1744 if (err == USBD_STALLED) {
1745 sc->transfer_state = TSTATE_CBI_SCLEAR;
1746 umass_clear_endpoint_stall(sc, UMASS_INTRIN,
1747 sc->transfer_xfer[XFER_CBI_SCLEAR]);
1748 } else {
1749 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1750 }
1751 return;
1752 }
1753
1754 /* Dissect the information in the buffer */
1755
1756 {
1757 uint32_t actlen;
1758 usbd_get_xfer_status(xfer,NULL,NULL,&actlen,NULL);
1759 DPRINTFM(UDMASS_CBI, "sc %p: CBI_STATUS actlen=%d",
1760 sc, actlen, 0, 0);
1761 if (actlen != 2)
1762 break;
1763 }
1764
1765 if (sc->sc_cmd == UMASS_CPROTO_UFI) {
1766 int status;
1767
1768 /* Section 3.4.3.1.3 specifies that the UFI command
1769 * protocol returns an ASC and ASCQ in the interrupt
1770 * data block.
1771 */
1772
1773 DPRINTFM(UDMASS_CBI, "sc %p: UFI CCI, ASC = 0x%02x, "
1774 "ASCQ = 0x%02x", sc, sc->sbl.ufi.asc,
1775 sc->sbl.ufi.ascq, 0);
1776
1777 if ((sc->sbl.ufi.asc == 0 && sc->sbl.ufi.ascq == 0) ||
1778 sc->sc_sense)
1779 status = STATUS_CMD_OK;
1780 else
1781 status = STATUS_CMD_FAILED;
1782
1783 /* No autosense, command successful */
1784 sc->transfer_state = TSTATE_IDLE;
1785 sc->transfer_cb(sc, sc->transfer_priv,
1786 sc->transfer_datalen - sc->transfer_actlen, status);
1787 } else {
1788 int status;
1789
1790 /* Command Interrupt Data Block */
1791
1792 DPRINTFM(UDMASS_CBI, "sc %p: type=0x%02x, value=0x%02x",
1793 sc, sc->sbl.common.type, sc->sbl.common.value, 0);
1794
1795 if (sc->sbl.common.type == IDB_TYPE_CCI) {
1796 switch (sc->sbl.common.value & IDB_VALUE_STATUS_MASK) {
1797 case IDB_VALUE_PASS:
1798 status = STATUS_CMD_OK;
1799 break;
1800 case IDB_VALUE_FAIL:
1801 case IDB_VALUE_PERSISTENT:
1802 status = STATUS_CMD_FAILED;
1803 break;
1804 case IDB_VALUE_PHASE:
1805 default: /* XXX: gcc */
1806 status = STATUS_WIRE_FAILED;
1807 break;
1808 }
1809
1810 sc->transfer_state = TSTATE_IDLE;
1811 sc->transfer_cb(sc, sc->transfer_priv,
1812 sc->transfer_datalen - sc->transfer_actlen,
1813 status);
1814 }
1815 }
1816 return;
1817
1818 case TSTATE_CBI_DCLEAR:
1819 if (err) { /* should not occur */
1820 printf("%s: CBI bulk-%s stall clear failed, %s\n",
1821 device_xname(sc->sc_dev),
1822 (sc->transfer_dir == DIR_IN? "in":"out"),
1823 usbd_errstr(err));
1824 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1825 } else {
1826 sc->transfer_state = TSTATE_IDLE;
1827 sc->transfer_cb(sc, sc->transfer_priv,
1828 sc->transfer_datalen, STATUS_CMD_FAILED);
1829 }
1830 return;
1831
1832 case TSTATE_CBI_SCLEAR:
1833 if (err) { /* should not occur */
1834 printf("%s: CBI intr-in stall clear failed, %s\n",
1835 device_xname(sc->sc_dev), usbd_errstr(err));
1836 umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1837 } else {
1838 sc->transfer_state = TSTATE_IDLE;
1839 sc->transfer_cb(sc, sc->transfer_priv,
1840 sc->transfer_datalen, STATUS_CMD_FAILED);
1841 }
1842 return;
1843
1844 /***** CBI Reset *****/
1845 case TSTATE_CBI_RESET1:
1846 if (err)
1847 printf("%s: CBI reset failed, %s\n",
1848 device_xname(sc->sc_dev), usbd_errstr(err));
1849
1850 sc->transfer_state = TSTATE_CBI_RESET2;
1851 umass_clear_endpoint_stall(sc, UMASS_BULKIN,
1852 sc->transfer_xfer[XFER_CBI_RESET2]);
1853
1854 return;
1855 case TSTATE_CBI_RESET2:
1856 if (err) /* should not occur */
1857 printf("%s: CBI bulk-in stall clear failed, %s\n",
1858 device_xname(sc->sc_dev), usbd_errstr(err));
1859 /* no error recovery, otherwise we end up in a loop */
1860
1861 sc->transfer_state = TSTATE_CBI_RESET3;
1862 umass_clear_endpoint_stall(sc, UMASS_BULKOUT,
1863 sc->transfer_xfer[XFER_CBI_RESET3]);
1864
1865 return;
1866 case TSTATE_CBI_RESET3:
1867 if (err) /* should not occur */
1868 printf("%s: CBI bulk-out stall clear failed, %s\n",
1869 device_xname(sc->sc_dev), usbd_errstr(err));
1870 /* no error recovery, otherwise we end up in a loop */
1871
1872 sc->transfer_state = TSTATE_IDLE;
1873 if (sc->transfer_priv) {
1874 sc->transfer_cb(sc, sc->transfer_priv,
1875 sc->transfer_datalen,
1876 sc->transfer_status);
1877 }
1878
1879 return;
1880
1881
1882 /***** Default *****/
1883 default:
1884 panic("%s: Unknown state %d",
1885 device_xname(sc->sc_dev), sc->transfer_state);
1886 }
1887}
1888
1889usbd_status
1890umass_bbb_get_max_lun(struct umass_softc *sc, uint8_t *maxlun)
1891{
1892 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1893 usb_device_request_t req;
1894 usbd_status err;
1895
1896 *maxlun = 0; /* Default to 0. */
1897
1898 DPRINTFM(UDMASS_BBB, "sc %p: Get Max Lun", sc, 0, 0, 0);
1899
1900 /* The Get Max Lun command is a class-specific request. */
1901 req.bmRequestType = UT_READ_CLASS_INTERFACE;
1902 req.bRequest = UR_BBB_GET_MAX_LUN;
1903 USETW(req.wValue, 0);
1904 USETW(req.wIndex, sc->sc_ifaceno);
1905 USETW(req.wLength, 1);
1906
1907 err = usbd_do_request_flags(sc->sc_udev, &req, maxlun,
1908 USBD_SHORT_XFER_OK, 0, USBD_DEFAULT_TIMEOUT);
1909 switch (err) {
1910 case USBD_NORMAL_COMPLETION:
1911 DPRINTFM(UDMASS_BBB, "sc %p: Max Lun %d", sc, *maxlun , 0, 0);
1912 break;
1913
1914 case USBD_STALLED:
1915 /*
1916 * Device doesn't support Get Max Lun request.
1917 */
1918 err = USBD_NORMAL_COMPLETION;
1919 DPRINTFM(UDMASS_BBB, "sc %p: Get Max Lun not supported", sc,
1920 0, 0, 0);
1921 break;
1922
1923 case USBD_SHORT_XFER:
1924 /*
1925 * XXX This must mean Get Max Lun is not supported, too!
1926 */
1927 err = USBD_NORMAL_COMPLETION;
1928 DPRINTFM(UDMASS_BBB, "sc %p: Get Max Lun SHORT_XFER", sc, 0, 0,
1929 0);
1930 break;
1931
1932 default:
1933 printf("%s: Get Max Lun failed: %s\n",
1934 device_xname(sc->sc_dev), usbd_errstr(err));
1935 /* XXX Should we port_reset the device? */
1936 break;
1937 }
1938
1939 return err;
1940}
1941
1942
1943
1944
1945#ifdef UMASS_DEBUG
1946Static void
1947umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw)
1948{
1949 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1950 int clen = cbw->bCDBLength;
1951 int dlen = UGETDW(cbw->dCBWDataTransferLength);
1952 uint8_t *c = cbw->CBWCDB;
1953 int tag = UGETDW(cbw->dCBWTag);
1954 int flags = cbw->bCBWFlags;
1955
1956 DPRINTFM(UDMASS_BBB, "sc %p: CBW %d: cmdlen=%d", sc, tag, clen, 0);
1957 DPRINTFM(UDMASS_BBB, " 0x%02x%02x%02x%02x...", c[0], c[1], c[2], c[3]);
1958 DPRINTFM(UDMASS_BBB, " 0x%02x%02x%02x%02x...", c[4], c[5], c[6], c[7]);
1959 DPRINTFM(UDMASS_BBB, " 0x%02x%02x...", c[8], c[9], 0, 0);
1960 DPRINTFM(UDMASS_BBB, " data = %d bytes, flags = %x", dlen, flags, 0,
1961 0);
1962}
1963
1964Static void
1965umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw)
1966{
1967 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1968 int sig = UGETDW(csw->dCSWSignature);
1969 int tag = UGETDW(csw->dCSWTag);
1970 int res = UGETDW(csw->dCSWDataResidue);
1971 int status = csw->bCSWStatus;
1972
1973 DPRINTFM(UDMASS_BBB, "sc %p: CSW %d: sig = 0x%08x, tag = %d", sc, tag,
1974 sig, tag);
1975 DPRINTFM(UDMASS_BBB, " res = %d, status = 0x%02x", res, status, 0, 0);
1976}
1977
1978Static void
1979umass_dump_buffer(struct umass_softc *sc, uint8_t *buffer, int buflen,
1980 int printlen)
1981{
1982 UMASSHIST_FUNC(); UMASSHIST_CALLED();
1983 int i;
1984
1985 DPRINTFM(UDMASS_GEN, "sc %p: buffer %p", sc, buffer, 0, 0);
1986 for (i = 0; i < buflen && i < printlen;) {
1987 if (i + 3 < buflen && i + 3 < printlen) {
1988 DPRINTFM(UDMASS_GEN, " 0x%02x%02x%02x%02x",
1989 buffer[i], buffer[i + 1],
1990 buffer[i + 2], buffer[i + 3]);
1991 i += 4;
1992 } else if (i + 2 < buflen && i + 2 < printlen) {
1993 DPRINTFM(UDMASS_GEN, " 0x%02x%02x%02x",
1994 buffer[i], buffer[i + 1], buffer[i + 2], 0);
1995 i += 3;
1996 } else if (i + 1 < buflen && i + 2 < printlen) {
1997 DPRINTFM(UDMASS_GEN, " 0x%02x%02x",
1998 buffer[i], buffer[i + 1], 0, 0);
1999 i += 2;
2000 } else {
2001 DPRINTFM(UDMASS_GEN, " 0x%02x", buffer[i], 0, 0, 0);
2002 i += 1;
2003 }
2004 }
2005}
2006#endif
2007