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