File:
[DragonFly] /
src /
sys /
dev /
usbmisc /
umass /
umass.c
Revision
1.9:
download - view:
text,
annotated -
select for diffs
Mon Mar 15 01:10:45 2004 UTC (9 years, 2 months ago) by
dillon
Branches:
MAIN
CVS tags:
HEAD
The cam_sim structure was being deallocated unconditionally by device
driver detach routines. The problem with this is that part of the CAM
bus structure may still be active (for example, with pending timeout()'s),
and even though the bus, target, and device is freed, since the sim IS
freed any accesses through the sim will hit 0xdeadc0de. This case most often
occurs with USB UMASS devices.
The CAM_XPT and CAM_SIM layer has been revamped. CAM_DEV_UNCONFIGURED is now
accounted for in the device->refcount, and the cam_sim structure is now
ref-counted as well. Additionally, the cam_simq* code which handles the
device queues has been revamped to refcount as well, so shared device queues
(raid and multi-channel devices) are not free()'d before all references have
gone away.
scsi_low free'd its cam_sim twice. Fixed.
USB was improperly using M_NOWAIT. All M_NOWAIT instances have been renamed
to M_INTWAIT.
1: /*-
2: * Copyright (c) 1999 MAEKAWA Masahide <bishop@rr.iij4u.or.jp>,
3: * Nick Hibma <n_hibma@freebsd.org>
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: *
15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: * SUCH DAMAGE.
26: *
27: * $NetBSD: umass.c,v 1.28 2000/04/02 23:46:53 augustss Exp $
28: * $FreeBSD: src/sys/dev/usb/umass.c,v 1.96 2003/12/19 12:19:11 sanpei Exp $
29: * $DragonFly: src/sys/dev/usbmisc/umass/umass.c,v 1.9 2004/03/15 01:10:45 dillon Exp $
30: */
31:
32: /*
33: * Universal Serial Bus Mass Storage Class specs:
34: * http://www.usb.org/developers/data/devclass/usbmassover_11.pdf
35: * http://www.usb.org/developers/data/devclass/usbmassbulk_10.pdf
36: * http://www.usb.org/developers/data/devclass/usbmass-cbi10.pdf
37: * http://www.usb.org/developers/data/devclass/usbmass-ufi10.pdf
38: */
39:
40: /*
41: * Ported to NetBSD by Lennart Augustsson <augustss@netbsd.org>.
42: * Parts of the code written my Jason R. Thorpe <thorpej@shagadelic.org>.
43: */
44:
45: /*
46: * The driver handles 3 Wire Protocols
47: * - Command/Bulk/Interrupt (CBI)
48: * - Command/Bulk/Interrupt with Command Completion Interrupt (CBI with CCI)
49: * - Mass Storage Bulk-Only (BBB)
50: * (BBB refers Bulk/Bulk/Bulk for Command/Data/Status phases)
51: *
52: * Over these wire protocols it handles the following command protocols
53: * - SCSI
54: * - UFI (floppy command set)
55: * - 8070i (ATAPI)
56: *
57: * UFI and 8070i (ATAPI) are transformed versions of the SCSI command set. The
58: * sc->transform method is used to convert the commands into the appropriate
59: * format (if at all necessary). For example, UFI requires all commands to be
60: * 12 bytes in length amongst other things.
61: *
62: * The source code below is marked and can be split into a number of pieces
63: * (in this order):
64: *
65: * - probe/attach/detach
66: * - generic transfer routines
67: * - BBB
68: * - CBI
69: * - CBI_I (in addition to functions from CBI)
70: * - CAM (Common Access Method)
71: * - SCSI
72: * - UFI
73: * - 8070i (ATAPI)
74: *
75: * The protocols are implemented using a state machine, for the transfers as
76: * well as for the resets. The state machine is contained in umass_*_state.
77: * The state machine is started through either umass_*_transfer or
78: * umass_*_reset.
79: *
80: * The reason for doing this is a) CAM performs a lot better this way and b) it
81: * avoids using tsleep from interrupt context (for example after a failed
82: * transfer).
83: */
84:
85: /*
86: * The SCSI related part of this driver has been derived from the
87: * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org).
88: *
89: * The CAM layer uses so called actions which are messages sent to the host
90: * adapter for completion. The actions come in through umass_cam_action. The
91: * appropriate block of routines is called depending on the transport protocol
92: * in use. When the transfer has finished, these routines call
93: * umass_cam_cb again to complete the CAM command.
94: */
95:
96: /*
97: * XXX Currently CBI with CCI is not supported because it bombs the system
98: * when the device is detached (low frequency interrupts are detached
99: * too late.
100: */
101: #undef CBI_I
102:
103: #include <sys/param.h>
104: #include <sys/systm.h>
105: #include <sys/kernel.h>
106: #include <sys/module.h>
107: #include <sys/bus.h>
108: #include <sys/sysctl.h>
109:
110: #include <bus/usb/usb.h>
111: #include <bus/usb/usbdi.h>
112: #include <bus/usb/usbdi_util.h>
113: #include <bus/usb/usbdevs.h>
114:
115: #include <bus/cam/cam.h>
116: #include <bus/cam/cam_ccb.h>
117: #include <bus/cam/cam_sim.h>
118: #include <bus/cam/cam_xpt_sim.h>
119: #include <bus/cam/scsi/scsi_all.h>
120: #include <bus/cam/scsi/scsi_da.h>
121:
122: #include <bus/cam/cam_periph.h>
123:
124: #ifdef USB_DEBUG
125: #define DIF(m, x) if (umassdebug & (m)) do { x ; } while (0)
126: #define DPRINTF(m, x) if (umassdebug & (m)) logprintf x
127: #define UDMASS_GEN 0x00010000 /* general */
128: #define UDMASS_SCSI 0x00020000 /* scsi */
129: #define UDMASS_UFI 0x00040000 /* ufi command set */
130: #define UDMASS_ATAPI 0x00080000 /* 8070i command set */
131: #define UDMASS_CMD (UDMASS_SCSI|UDMASS_UFI|UDMASS_ATAPI)
132: #define UDMASS_USB 0x00100000 /* USB general */
133: #define UDMASS_BBB 0x00200000 /* Bulk-Only transfers */
134: #define UDMASS_CBI 0x00400000 /* CBI transfers */
135: #define UDMASS_WIRE (UDMASS_BBB|UDMASS_CBI)
136: #define UDMASS_ALL 0xffff0000 /* all of the above */
137: int umassdebug = 0;
138: SYSCTL_NODE(_hw_usb, OID_AUTO, umass, CTLFLAG_RW, 0, "USB umass");
139: SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RW,
140: &umassdebug, 0, "umass debug level");
141: #else
142: #define DIF(m, x) /* nop */
143: #define DPRINTF(m, x) /* nop */
144: #endif
145:
146:
147: /* Generic definitions */
148:
149: /* Direction for umass_*_transfer */
150: #define DIR_NONE 0
151: #define DIR_IN 1
152: #define DIR_OUT 2
153:
154: /* device name */
155: #define DEVNAME "umass"
156: #define DEVNAME_SIM "umass-sim"
157:
158: #define UMASS_MAX_TRANSFER_SIZE 65536
159: #define UMASS_DEFAULT_TRANSFER_SPEED 1000
160: #define UMASS_FLOPPY_TRANSFER_SPEED 20
161:
162: #define UMASS_TIMEOUT 5000 /* msecs */
163:
164: /* CAM specific definitions */
165:
166: #define UMASS_SCSIID_MAX 1 /* maximum number of drives expected */
167: #define UMASS_SCSIID_HOST UMASS_SCSIID_MAX
168:
169: #define MS_TO_TICKS(ms) ((ms) * hz / 1000)
170:
171:
172: /* Bulk-Only features */
173:
174: #define UR_BBB_RESET 0xff /* Bulk-Only reset */
175: #define UR_BBB_GET_MAX_LUN 0xfe /* Get maximum lun */
176:
177: /* Command Block Wrapper */
178: typedef struct {
179: uDWord dCBWSignature;
180: # define CBWSIGNATURE 0x43425355
181: uDWord dCBWTag;
182: uDWord dCBWDataTransferLength;
183: uByte bCBWFlags;
184: # define CBWFLAGS_OUT 0x00
185: # define CBWFLAGS_IN 0x80
186: uByte bCBWLUN;
187: uByte bCDBLength;
188: # define CBWCDBLENGTH 16
189: uByte CBWCDB[CBWCDBLENGTH];
190: } umass_bbb_cbw_t;
191: #define UMASS_BBB_CBW_SIZE 31
192:
193: /* Command Status Wrapper */
194: typedef struct {
195: uDWord dCSWSignature;
196: # define CSWSIGNATURE 0x53425355
197: # define CSWSIGNATURE_OLYMPUS_C1 0x55425355
198: uDWord dCSWTag;
199: uDWord dCSWDataResidue;
200: uByte bCSWStatus;
201: # define CSWSTATUS_GOOD 0x0
202: # define CSWSTATUS_FAILED 0x1
203: # define CSWSTATUS_PHASE 0x2
204: } umass_bbb_csw_t;
205: #define UMASS_BBB_CSW_SIZE 13
206:
207: /* CBI features */
208:
209: #define UR_CBI_ADSC 0x00
210:
211: typedef unsigned char umass_cbi_cbl_t[16]; /* Command block */
212:
213: typedef union {
214: struct {
215: unsigned char type;
216: #define IDB_TYPE_CCI 0x00
217: unsigned char value;
218: #define IDB_VALUE_PASS 0x00
219: #define IDB_VALUE_FAIL 0x01
220: #define IDB_VALUE_PHASE 0x02
221: #define IDB_VALUE_PERSISTENT 0x03
222: #define IDB_VALUE_STATUS_MASK 0x03
223: } common;
224:
225: struct {
226: unsigned char asc;
227: unsigned char ascq;
228: } ufi;
229: } umass_cbi_sbl_t;
230:
231:
232:
233: struct umass_softc; /* see below */
234:
235: typedef void (*transfer_cb_f) (struct umass_softc *sc, void *priv,
236: int residue, int status);
237: #define STATUS_CMD_OK 0 /* everything ok */
238: #define STATUS_CMD_UNKNOWN 1 /* will have to fetch sense */
239: #define STATUS_CMD_FAILED 2 /* transfer was ok, command failed */
240: #define STATUS_WIRE_FAILED 3 /* couldn't even get command across */
241:
242: typedef void (*wire_reset_f) (struct umass_softc *sc, int status);
243: typedef void (*wire_transfer_f) (struct umass_softc *sc, int lun,
244: void *cmd, int cmdlen, void *data, int datalen,
245: int dir, transfer_cb_f cb, void *priv);
246: typedef void (*wire_state_f) (usbd_xfer_handle xfer,
247: usbd_private_handle priv, usbd_status err);
248:
249: typedef int (*command_transform_f) (struct umass_softc *sc,
250: unsigned char *cmd, int cmdlen,
251: unsigned char **rcmd, int *rcmdlen);
252:
253:
254: struct umass_devdescr_t {
255: u_int32_t vid;
256: # define VID_WILDCARD 0xffffffff
257: # define VID_EOT 0xfffffffe
258: u_int32_t pid;
259: # define PID_WILDCARD 0xffffffff
260: # define PID_EOT 0xfffffffe
261: u_int32_t rid;
262: # define RID_WILDCARD 0xffffffff
263: # define RID_EOT 0xfffffffe
264:
265: /* wire and command protocol */
266: u_int16_t proto;
267: # define UMASS_PROTO_BBB 0x0001 /* USB wire protocol */
268: # define UMASS_PROTO_CBI 0x0002
269: # define UMASS_PROTO_CBI_I 0x0004
270: # define UMASS_PROTO_WIRE 0x00ff /* USB wire protocol mask */
271: # define UMASS_PROTO_SCSI 0x0100 /* command protocol */
272: # define UMASS_PROTO_ATAPI 0x0200
273: # define UMASS_PROTO_UFI 0x0400
274: # define UMASS_PROTO_RBC 0x0800
275: # define UMASS_PROTO_COMMAND 0xff00 /* command protocol mask */
276:
277: /* Device specific quirks */
278: u_int16_t quirks;
279: # define NO_QUIRKS 0x0000
280: /* The drive does not support Test Unit Ready. Convert to Start Unit
281: */
282: # define NO_TEST_UNIT_READY 0x0001
283: /* The drive does not reset the Unit Attention state after REQUEST
284: * SENSE has been sent. The INQUIRY command does not reset the UA
285: * either, and so CAM runs in circles trying to retrieve the initial
286: * INQUIRY data.
287: */
288: # define RS_NO_CLEAR_UA 0x0002
289: /* The drive does not support START STOP. */
290: # define NO_START_STOP 0x0004
291: /* Don't ask for full inquiry data (255b). */
292: # define FORCE_SHORT_INQUIRY 0x0008
293: /* Needs to be initialised the Shuttle way */
294: # define SHUTTLE_INIT 0x0010
295: /* Drive needs to be switched to alternate iface 1 */
296: # define ALT_IFACE_1 0x0020
297: /* Drive does not do 1Mb/s, but just floppy speeds (20kb/s) */
298: # define FLOPPY_SPEED 0x0040
299: /* The device can't count and gets the residue of transfers wrong */
300: # define IGNORE_RESIDUE 0x0080
301: /* No GetMaxLun call */
302: # define NO_GETMAXLUN 0x0100
303: /* The device uses a weird CSWSIGNATURE. */
304: # define WRONG_CSWSIG 0x0200
305: /* Device cannot handle INQUIRY so fake a generic response */
306: # define NO_INQUIRY 0x0400
307: /* Device cannot handle INQUIRY EVPD, return CHECK CONDITION */
308: # define NO_INQUIRY_EVPD 0x0800
309: };
310:
311: Static struct umass_devdescr_t umass_devdescrs[] = {
312: { USB_VENDOR_ASAHIOPTICAL, PID_WILDCARD, RID_WILDCARD,
313: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
314: RS_NO_CLEAR_UA
315: },
316: { USB_VENDOR_FUJIPHOTO, USB_PRODUCT_FUJIPHOTO_MASS0100, RID_WILDCARD,
317: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
318: RS_NO_CLEAR_UA
319: },
320: { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB2IDE, RID_WILDCARD,
321: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
322: FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
323: },
324: { USB_VENDOR_GENESYS, USB_PRODUCT_GENESYS_GL641USB, RID_WILDCARD,
325: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
326: FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
327: },
328: { USB_VENDOR_HITACHI, USB_PRODUCT_HITACHI_DVDCAM_USB, RID_WILDCARD,
329: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
330: NO_INQUIRY
331: },
332: { USB_VENDOR_HP, USB_PRODUCT_HP_CDW8200, RID_WILDCARD,
333: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
334: NO_TEST_UNIT_READY | NO_START_STOP
335: },
336: { USB_VENDOR_INSYSTEM, USB_PRODUCT_INSYSTEM_USBCABLE, RID_WILDCARD,
337: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI,
338: NO_TEST_UNIT_READY | NO_START_STOP | ALT_IFACE_1
339: },
340: { USB_VENDOR_IOMEGA, USB_PRODUCT_IOMEGA_ZIP100, RID_WILDCARD,
341: /* XXX This is not correct as there are Zip drives that use ATAPI.
342: */
343: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
344: NO_TEST_UNIT_READY
345: },
346: { USB_VENDOR_LOGITEC, USB_PRODUCT_LOGITEC_LDR_H443U2, RID_WILDCARD,
347: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
348: NO_QUIRKS
349: },
350: { USB_VENDOR_MELCO, USB_PRODUCT_MELCO_DUBPXXG, RID_WILDCARD,
351: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
352: FORCE_SHORT_INQUIRY | NO_START_STOP | IGNORE_RESIDUE
353: },
354: { USB_VENDOR_MICROTECH, USB_PRODUCT_MICROTECH_DPCM, RID_WILDCARD,
355: UMASS_PROTO_SCSI | UMASS_PROTO_CBI,
356: NO_TEST_UNIT_READY | NO_START_STOP
357: },
358: { USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY, RID_WILDCARD,
359: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
360: IGNORE_RESIDUE | NO_GETMAXLUN | RS_NO_CLEAR_UA
361: },
362: { USB_VENDOR_MSYSTEMS, USB_PRODUCT_MSYSTEMS_DISKONKEY2, RID_WILDCARD,
363: UMASS_PROTO_ATAPI | UMASS_PROTO_BBB,
364: NO_QUIRKS
365: },
366: { USB_VENDOR_OLYMPUS, USB_PRODUCT_OLYMPUS_C1, RID_WILDCARD,
367: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
368: WRONG_CSWSIG
369: },
370: { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB20AN, RID_WILDCARD,
371: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
372: NO_QUIRKS
373: },
374: { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_KXLCB35AN, RID_WILDCARD,
375: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
376: NO_QUIRKS
377: },
378: { USB_VENDOR_PNY, USB_PRODUCT_PNY_ATTACHE, RID_WILDCARD,
379: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
380: IGNORE_RESIDUE
381: },
382: { USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_SL11R, RID_WILDCARD,
383: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
384: NO_QUIRKS
385: },
386: { USB_VENDOR_SHUTTLE, USB_PRODUCT_SHUTTLE_EUSB, RID_WILDCARD,
387: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
388: NO_TEST_UNIT_READY | NO_START_STOP | SHUTTLE_INIT
389: },
390: { USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_I_BEAD100, RID_WILDCARD,
391: UMASS_PROTO_SCSI | UMASS_PROTO_BBB,
392: SHUTTLE_INIT
393: },
394: { USB_VENDOR_SONY, USB_PRODUCT_SONY_DSC, RID_WILDCARD,
395: UMASS_PROTO_RBC | UMASS_PROTO_CBI,
396: NO_QUIRKS
397: },
398: { USB_VENDOR_SONY, USB_PRODUCT_SONY_MSC, RID_WILDCARD,
399: UMASS_PROTO_RBC | UMASS_PROTO_CBI,
400: NO_QUIRKS
401: },
402: { USB_VENDOR_TREK, USB_PRODUCT_TREK_THUMBDRIVE_8MB, RID_WILDCARD,
403: UMASS_PROTO_ATAPI | UMASS_PROTO_BBB,
404: IGNORE_RESIDUE
405: },
406: { USB_VENDOR_YANO, USB_PRODUCT_YANO_U640MO, RID_WILDCARD,
407: UMASS_PROTO_ATAPI | UMASS_PROTO_CBI_I,
408: FORCE_SHORT_INQUIRY
409: },
410: { VID_EOT, PID_EOT, RID_EOT, 0, 0 }
411: };
412:
413:
414: /* the per device structure */
415: struct umass_softc {
416: USBBASEDEVICE sc_dev; /* base device */
417: usbd_device_handle sc_udev; /* USB device */
418:
419: struct cam_sim *umass_sim; /* SCSI Interface Module */
420:
421: unsigned char flags; /* various device flags */
422: # define UMASS_FLAGS_GONE 0x01 /* devices is no more */
423:
424: u_int16_t proto; /* wire and cmd protocol */
425: u_int16_t quirks; /* they got it almost right */
426:
427: usbd_interface_handle iface; /* Mass Storage interface */
428: int ifaceno; /* MS iface number */
429:
430: u_int8_t bulkin; /* bulk-in Endpoint Address */
431: u_int8_t bulkout; /* bulk-out Endpoint Address */
432: u_int8_t intrin; /* intr-in Endp. (CBI) */
433: usbd_pipe_handle bulkin_pipe;
434: usbd_pipe_handle bulkout_pipe;
435: usbd_pipe_handle intrin_pipe;
436:
437: /* Reset the device in a wire protocol specific way */
438: wire_reset_f reset;
439:
440: /* The start of a wire transfer. It prepares the whole transfer (cmd,
441: * data, and status stage) and initiates it. It is up to the state
442: * machine (below) to handle the various stages and errors in these
443: */
444: wire_transfer_f transfer;
445:
446: /* The state machine, handling the various states during a transfer */
447: wire_state_f state;
448:
449: /* The command transform function is used to conver the SCSI commands
450: * into their derivatives, like UFI, ATAPI, and friends.
451: */
452: command_transform_f transform; /* command transform */
453:
454: /* Bulk specific variables for transfers in progress */
455: umass_bbb_cbw_t cbw; /* command block wrapper */
456: umass_bbb_csw_t csw; /* command status wrapper*/
457: /* CBI specific variables for transfers in progress */
458: umass_cbi_cbl_t cbl; /* command block */
459: umass_cbi_sbl_t sbl; /* status block */
460:
461: /* generic variables for transfers in progress */
462: /* ctrl transfer requests */
463: usb_device_request_t request;
464:
465: /* xfer handles
466: * Most of our operations are initiated from interrupt context, so
467: * we need to avoid using the one that is in use. We want to avoid
468: * allocating them in the interrupt context as well.
469: */
470: /* indices into array below */
471: # define XFER_BBB_CBW 0 /* Bulk-Only */
472: # define XFER_BBB_DATA 1
473: # define XFER_BBB_DCLEAR 2
474: # define XFER_BBB_CSW1 3
475: # define XFER_BBB_CSW2 4
476: # define XFER_BBB_SCLEAR 5
477: # define XFER_BBB_RESET1 6
478: # define XFER_BBB_RESET2 7
479: # define XFER_BBB_RESET3 8
480:
481: # define XFER_CBI_CB 0 /* CBI */
482: # define XFER_CBI_DATA 1
483: # define XFER_CBI_STATUS 2
484: # define XFER_CBI_DCLEAR 3
485: # define XFER_CBI_SCLEAR 4
486: # define XFER_CBI_RESET1 5
487: # define XFER_CBI_RESET2 6
488: # define XFER_CBI_RESET3 7
489:
490: # define XFER_NR 9 /* maximum number */
491:
492: usbd_xfer_handle transfer_xfer[XFER_NR]; /* for ctrl xfers */
493:
494: int transfer_dir; /* data direction */
495: void *transfer_data; /* data buffer */
496: int transfer_datalen; /* (maximum) length */
497: int transfer_actlen; /* actual length */
498: transfer_cb_f transfer_cb; /* callback */
499: void *transfer_priv; /* for callback */
500: int transfer_status;
501:
502: int transfer_state;
503: # define TSTATE_ATTACH 0 /* in attach */
504: # define TSTATE_IDLE 1
505: # define TSTATE_BBB_COMMAND 2 /* CBW transfer */
506: # define TSTATE_BBB_DATA 3 /* Data transfer */
507: # define TSTATE_BBB_DCLEAR 4 /* clear endpt stall */
508: # define TSTATE_BBB_STATUS1 5 /* clear endpt stall */
509: # define TSTATE_BBB_SCLEAR 6 /* clear endpt stall */
510: # define TSTATE_BBB_STATUS2 7 /* CSW transfer */
511: # define TSTATE_BBB_RESET1 8 /* reset command */
512: # define TSTATE_BBB_RESET2 9 /* in clear stall */
513: # define TSTATE_BBB_RESET3 10 /* out clear stall */
514: # define TSTATE_CBI_COMMAND 11 /* command transfer */
515: # define TSTATE_CBI_DATA 12 /* data transfer */
516: # define TSTATE_CBI_STATUS 13 /* status transfer */
517: # define TSTATE_CBI_DCLEAR 14 /* clear ep stall */
518: # define TSTATE_CBI_SCLEAR 15 /* clear ep stall */
519: # define TSTATE_CBI_RESET1 16 /* reset command */
520: # define TSTATE_CBI_RESET2 17 /* in clear stall */
521: # define TSTATE_CBI_RESET3 18 /* out clear stall */
522: # define TSTATE_STATES 19 /* # of states above */
523:
524:
525: /* SCSI/CAM specific variables */
526: unsigned char cam_scsi_command[CAM_MAX_CDBLEN];
527: unsigned char cam_scsi_command2[CAM_MAX_CDBLEN];
528: struct scsi_sense cam_scsi_sense;
529: struct scsi_sense cam_scsi_test_unit_ready;
530:
531: int maxlun; /* maximum LUN number */
532: struct callout_handle rescan_timeout;
533: };
534:
535: #ifdef USB_DEBUG
536: char *states[TSTATE_STATES+1] = {
537: /* should be kept in sync with the list at transfer_state */
538: "Attach",
539: "Idle",
540: "BBB CBW",
541: "BBB Data",
542: "BBB Data bulk-in/-out clear stall",
543: "BBB CSW, 1st attempt",
544: "BBB CSW bulk-in clear stall",
545: "BBB CSW, 2nd attempt",
546: "BBB Reset",
547: "BBB bulk-in clear stall",
548: "BBB bulk-out clear stall",
549: "CBI Command",
550: "CBI Data",
551: "CBI Status",
552: "CBI Data bulk-in/-out clear stall",
553: "CBI Status intr-in clear stall",
554: "CBI Reset",
555: "CBI bulk-in clear stall",
556: "CBI bulk-out clear stall",
557: NULL
558: };
559: #endif
560:
561: /* If device cannot return valid inquiry data, fake it */
562: Static uint8_t fake_inq_data[SHORT_INQUIRY_LENGTH] = {
563: 0, /*removable*/ 0x80, SCSI_REV_2, SCSI_REV_2,
564: /*additional_length*/ 31, 0, 0, 0
565: };
566:
567: /* USB device probe/attach/detach functions */
568: USB_DECLARE_DRIVER(umass);
569: Static int umass_match_proto (struct umass_softc *sc,
570: usbd_interface_handle iface,
571: usbd_device_handle udev);
572:
573: /* quirk functions */
574: Static void umass_init_shuttle (struct umass_softc *sc);
575:
576: /* generic transfer functions */
577: Static usbd_status umass_setup_transfer (struct umass_softc *sc,
578: usbd_pipe_handle pipe,
579: void *buffer, int buflen, int flags,
580: usbd_xfer_handle xfer);
581: Static usbd_status umass_setup_ctrl_transfer (struct umass_softc *sc,
582: usbd_device_handle udev,
583: usb_device_request_t *req,
584: void *buffer, int buflen, int flags,
585: usbd_xfer_handle xfer);
586: Static void umass_clear_endpoint_stall (struct umass_softc *sc,
587: u_int8_t endpt, usbd_pipe_handle pipe,
588: int state, usbd_xfer_handle xfer);
589: Static void umass_reset (struct umass_softc *sc,
590: transfer_cb_f cb, void *priv);
591:
592: /* Bulk-Only related functions */
593: Static void umass_bbb_reset (struct umass_softc *sc, int status);
594: Static void umass_bbb_transfer (struct umass_softc *sc, int lun,
595: void *cmd, int cmdlen,
596: void *data, int datalen, int dir,
597: transfer_cb_f cb, void *priv);
598: Static void umass_bbb_state (usbd_xfer_handle xfer,
599: usbd_private_handle priv,
600: usbd_status err);
601: Static int umass_bbb_get_max_lun
602: (struct umass_softc *sc);
603:
604: /* CBI related functions */
605: Static int umass_cbi_adsc (struct umass_softc *sc,
606: char *buffer, int buflen,
607: usbd_xfer_handle xfer);
608: Static void umass_cbi_reset (struct umass_softc *sc, int status);
609: Static void umass_cbi_transfer (struct umass_softc *sc, int lun,
610: void *cmd, int cmdlen,
611: void *data, int datalen, int dir,
612: transfer_cb_f cb, void *priv);
613: Static void umass_cbi_state (usbd_xfer_handle xfer,
614: usbd_private_handle priv, usbd_status err);
615:
616: /* CAM related functions */
617: Static void umass_cam_action (struct cam_sim *sim, union ccb *ccb);
618: Static void umass_cam_poll (struct cam_sim *sim);
619:
620: Static void umass_cam_cb (struct umass_softc *sc, void *priv,
621: int residue, int status);
622: Static void umass_cam_sense_cb (struct umass_softc *sc, void *priv,
623: int residue, int status);
624: Static void umass_cam_quirk_cb (struct umass_softc *sc, void *priv,
625: int residue, int status);
626:
627: Static void umass_cam_rescan_callback
628: (struct cam_periph *periph,union ccb *ccb);
629: Static void umass_cam_rescan (void *addr);
630:
631: Static int umass_cam_attach_sim (struct umass_softc *sc);
632: Static int umass_cam_attach (struct umass_softc *sc);
633: Static int umass_cam_detach_sim (struct umass_softc *sc);
634:
635:
636: /* SCSI specific functions */
637: Static int umass_scsi_transform (struct umass_softc *sc,
638: unsigned char *cmd, int cmdlen,
639: unsigned char **rcmd, int *rcmdlen);
640:
641: /* UFI specific functions */
642: #define UFI_COMMAND_LENGTH 12 /* UFI commands are always 12 bytes */
643: Static int umass_ufi_transform (struct umass_softc *sc,
644: unsigned char *cmd, int cmdlen,
645: unsigned char **rcmd, int *rcmdlen);
646:
647: /* ATAPI (8070i) specific functions */
648: #define ATAPI_COMMAND_LENGTH 12 /* ATAPI commands are always 12 bytes */
649: Static int umass_atapi_transform (struct umass_softc *sc,
650: unsigned char *cmd, int cmdlen,
651: unsigned char **rcmd, int *rcmdlen);
652:
653: /* RBC specific functions */
654: Static int umass_rbc_transform (struct umass_softc *sc,
655: unsigned char *cmd, int cmdlen,
656: unsigned char **rcmd, int *rcmdlen);
657:
658: #ifdef USB_DEBUG
659: /* General debugging functions */
660: Static void umass_bbb_dump_cbw (struct umass_softc *sc, umass_bbb_cbw_t *cbw);
661: Static void umass_bbb_dump_csw (struct umass_softc *sc, umass_bbb_csw_t *csw);
662: Static void umass_cbi_dump_cmd (struct umass_softc *sc, void *cmd, int cmdlen);
663: Static void umass_dump_buffer (struct umass_softc *sc, u_int8_t *buffer,
664: int buflen, int printlen);
665: #endif
666:
667: #if defined(__FreeBSD__) || defined(__DragonFly__)
668: MODULE_DEPEND(umass, cam, 1,1,1);
669: #endif
670:
671: /*
672: * USB device probe/attach/detach
673: */
674:
675: /*
676: * Match the device we are seeing with the devices supported. Fill in the
677: * description in the softc accordingly. This function is called from both
678: * probe and attach.
679: */
680:
681: Static int
682: umass_match_proto(struct umass_softc *sc, usbd_interface_handle iface,
683: usbd_device_handle udev)
684: {
685: usb_device_descriptor_t *dd;
686: usb_interface_descriptor_t *id;
687: int i;
688: int found = 0;
689:
690: sc->sc_udev = udev;
691: sc->proto = 0;
692: sc->quirks = 0;
693:
694: dd = usbd_get_device_descriptor(udev);
695:
696: /* An entry specifically for Y-E Data devices as they don't fit in the
697: * device description table.
698: */
699: if (UGETW(dd->idVendor) == USB_VENDOR_YEDATA
700: && UGETW(dd->idProduct) == USB_PRODUCT_YEDATA_FLASHBUSTERU) {
701:
702: /* Revisions < 1.28 do not handle the inerrupt endpoint
703: * very well.
704: */
705: if (UGETW(dd->bcdDevice) < 0x128) {
706: sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI;
707: } else {
708: sc->proto = UMASS_PROTO_UFI | UMASS_PROTO_CBI_I;
709: }
710:
711: /*
712: * Revisions < 1.28 do not have the TEST UNIT READY command
713: * Revisions == 1.28 have a broken TEST UNIT READY
714: */
715: if (UGETW(dd->bcdDevice) <= 0x128)
716: sc->quirks |= NO_TEST_UNIT_READY;
717:
718: sc->quirks |= RS_NO_CLEAR_UA | FLOPPY_SPEED;
719: return(UMATCH_VENDOR_PRODUCT);
720: }
721:
722: /* Check the list of supported devices for a match. While looking,
723: * check for wildcarded and fully matched. First match wins.
724: */
725: for (i = 0; umass_devdescrs[i].vid != VID_EOT && !found; i++) {
726: if (umass_devdescrs[i].vid == VID_WILDCARD &&
727: umass_devdescrs[i].pid == PID_WILDCARD &&
728: umass_devdescrs[i].rid == RID_WILDCARD) {
729: printf("umass: ignoring invalid wildcard quirk\n");
730: continue;
731: }
732: if ((umass_devdescrs[i].vid == UGETW(dd->idVendor) ||
733: umass_devdescrs[i].vid == VID_WILDCARD)
734: && (umass_devdescrs[i].pid == UGETW(dd->idProduct) ||
735: umass_devdescrs[i].pid == PID_WILDCARD)) {
736: if (umass_devdescrs[i].rid == RID_WILDCARD) {
737: sc->proto = umass_devdescrs[i].proto;
738: sc->quirks = umass_devdescrs[i].quirks;
739: return (UMATCH_VENDOR_PRODUCT);
740: } else if (umass_devdescrs[i].rid ==
741: UGETW(dd->bcdDevice)) {
742: sc->proto = umass_devdescrs[i].proto;
743: sc->quirks = umass_devdescrs[i].quirks;
744: return (UMATCH_VENDOR_PRODUCT_REV);
745: } /* else RID does not match */
746: }
747: }
748:
749: /* Check for a standards compliant device */
750:
751: id = usbd_get_interface_descriptor(iface);
752: if (id == NULL || id->bInterfaceClass != UICLASS_MASS)
753: return(UMATCH_NONE);
754:
755: switch (id->bInterfaceSubClass) {
756: case UISUBCLASS_SCSI:
757: sc->proto |= UMASS_PROTO_SCSI;
758: break;
759: case UISUBCLASS_UFI:
760: sc->proto |= UMASS_PROTO_UFI;
761: break;
762: case UISUBCLASS_RBC:
763: sc->proto |= UMASS_PROTO_RBC;
764: break;
765: case UISUBCLASS_SFF8020I:
766: case UISUBCLASS_SFF8070I:
767: sc->proto |= UMASS_PROTO_ATAPI;
768: break;
769: default:
770: DPRINTF(UDMASS_GEN, ("%s: Unsupported command protocol %d\n",
771: USBDEVNAME(sc->sc_dev), id->bInterfaceSubClass));
772: return(UMATCH_NONE);
773: }
774:
775: switch (id->bInterfaceProtocol) {
776: case UIPROTO_MASS_CBI:
777: sc->proto |= UMASS_PROTO_CBI;
778: break;
779: case UIPROTO_MASS_CBI_I:
780: sc->proto |= UMASS_PROTO_CBI_I;
781: break;
782: case UIPROTO_MASS_BBB_OLD:
783: case UIPROTO_MASS_BBB:
784: sc->proto |= UMASS_PROTO_BBB;
785: break;
786: default:
787: DPRINTF(UDMASS_GEN, ("%s: Unsupported wire protocol %d\n",
788: USBDEVNAME(sc->sc_dev), id->bInterfaceProtocol));
789: return(UMATCH_NONE);
790: }
791:
792: return(UMATCH_DEVCLASS_DEVSUBCLASS_DEVPROTO);
793: }
794:
795: USB_MATCH(umass)
796: {
797: USB_MATCH_START(umass, uaa);
798: struct umass_softc *sc = device_get_softc(self);
799:
800: USB_MATCH_SETUP;
801:
802: if (uaa->iface == NULL)
803: return(UMATCH_NONE);
804:
805: return(umass_match_proto(sc, uaa->iface, uaa->device));
806: }
807:
808: USB_ATTACH(umass)
809: {
810: USB_ATTACH_START(umass, sc, uaa);
811: usb_interface_descriptor_t *id;
812: usb_endpoint_descriptor_t *ed;
813: char devinfo[1024];
814: int i;
815: int err;
816:
817: /*
818: * the softc struct is bzero-ed in device_set_driver. We can safely
819: * call umass_detach without specifically initialising the struct.
820: */
821:
822: usbd_devinfo(uaa->device, 0, devinfo);
823: USB_ATTACH_SETUP;
824:
825: sc->iface = uaa->iface;
826: sc->ifaceno = uaa->ifaceno;
827:
828: /* initialise the proto and drive values in the umass_softc (again) */
829: (void) umass_match_proto(sc, sc->iface, uaa->device);
830:
831: id = usbd_get_interface_descriptor(sc->iface);
832: printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo);
833: #ifdef USB_DEBUG
834: printf("%s: ", USBDEVNAME(sc->sc_dev));
835: switch (sc->proto&UMASS_PROTO_COMMAND) {
836: case UMASS_PROTO_SCSI:
837: printf("SCSI");
838: break;
839: case UMASS_PROTO_ATAPI:
840: printf("8070i (ATAPI)");
841: break;
842: case UMASS_PROTO_UFI:
843: printf("UFI");
844: break;
845: case UMASS_PROTO_RBC:
846: printf("RBC");
847: break;
848: default:
849: printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_COMMAND);
850: break;
851: }
852: printf(" over ");
853: switch (sc->proto&UMASS_PROTO_WIRE) {
854: case UMASS_PROTO_BBB:
855: printf("Bulk-Only");
856: break;
857: case UMASS_PROTO_CBI: /* uses Comand/Bulk pipes */
858: printf("CBI");
859: break;
860: case UMASS_PROTO_CBI_I: /* uses Comand/Bulk/Interrupt pipes */
861: printf("CBI with CCI");
862: #ifndef CBI_I
863: printf(" (using CBI)");
864: #endif
865: break;
866: default:
867: printf("(unknown 0x%02x)", sc->proto&UMASS_PROTO_WIRE);
868: }
869: printf("; quirks = 0x%04x\n", sc->quirks);
870: #endif
871:
872: #ifndef CBI_I
873: if (sc->proto & UMASS_PROTO_CBI_I) {
874: /* See beginning of file for comment on the use of CBI with CCI */
875: sc->proto = (sc->proto & ~UMASS_PROTO_CBI_I) | UMASS_PROTO_CBI;
876: }
877: #endif
878:
879: if (sc->quirks & ALT_IFACE_1) {
880: err = usbd_set_interface(0, 1);
881: if (err) {
882: DPRINTF(UDMASS_USB, ("%s: could not switch to "
883: "Alt Interface %d\n",
884: USBDEVNAME(sc->sc_dev), 1));
885: umass_detach(self);
886: USB_ATTACH_ERROR_RETURN;
887: }
888: }
889:
890: /*
891: * In addition to the Control endpoint the following endpoints
892: * are required:
893: * a) bulk-in endpoint.
894: * b) bulk-out endpoint.
895: * and for Control/Bulk/Interrupt with CCI (CBI_I)
896: * c) intr-in
897: *
898: * The endpoint addresses are not fixed, so we have to read them
899: * from the device descriptors of the current interface.
900: */
901: for (i = 0 ; i < id->bNumEndpoints ; i++) {
902: ed = usbd_interface2endpoint_descriptor(sc->iface, i);
903: if (!ed) {
904: printf("%s: could not read endpoint descriptor\n",
905: USBDEVNAME(sc->sc_dev));
906: USB_ATTACH_ERROR_RETURN;
907: }
908: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
909: && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
910: sc->bulkin = ed->bEndpointAddress;
911: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
912: && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
913: sc->bulkout = ed->bEndpointAddress;
914: } else if (sc->proto & UMASS_PROTO_CBI_I
915: && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
916: && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
917: sc->intrin = ed->bEndpointAddress;
918: #ifdef USB_DEBUG
919: if (UGETW(ed->wMaxPacketSize) > 2) {
920: DPRINTF(UDMASS_CBI, ("%s: intr size is %d\n",
921: USBDEVNAME(sc->sc_dev),
922: UGETW(ed->wMaxPacketSize)));
923: }
924: #endif
925: }
926: }
927:
928: /* check whether we found all the endpoints we need */
929: if (!sc->bulkin || !sc->bulkout
930: || (sc->proto & UMASS_PROTO_CBI_I && !sc->intrin) ) {
931: DPRINTF(UDMASS_USB, ("%s: endpoint not found %d/%d/%d\n",
932: USBDEVNAME(sc->sc_dev),
933: sc->bulkin, sc->bulkout, sc->intrin));
934: umass_detach(self);
935: USB_ATTACH_ERROR_RETURN;
936: }
937:
938: /* Open the bulk-in and -out pipe */
939: err = usbd_open_pipe(sc->iface, sc->bulkout,
940: USBD_EXCLUSIVE_USE, &sc->bulkout_pipe);
941: if (err) {
942: DPRINTF(UDMASS_USB, ("%s: cannot open %d-out pipe (bulk)\n",
943: USBDEVNAME(sc->sc_dev), sc->bulkout));
944: umass_detach(self);
945: USB_ATTACH_ERROR_RETURN;
946: }
947: err = usbd_open_pipe(sc->iface, sc->bulkin,
948: USBD_EXCLUSIVE_USE, &sc->bulkin_pipe);
949: if (err) {
950: DPRINTF(UDMASS_USB, ("%s: could not open %d-in pipe (bulk)\n",
951: USBDEVNAME(sc->sc_dev), sc->bulkin));
952: umass_detach(self);
953: USB_ATTACH_ERROR_RETURN;
954: }
955: /* Open the intr-in pipe if the protocol is CBI with CCI.
956: * Note: early versions of the Zip drive do have an interrupt pipe, but
957: * this pipe is unused
958: *
959: * We do not open the interrupt pipe as an interrupt pipe, but as a
960: * normal bulk endpoint. We send an IN transfer down the wire at the
961: * appropriate time, because we know exactly when to expect data on
962: * that endpoint. This saves bandwidth, but more important, makes the
963: * code for handling the data on that endpoint simpler. No data
964: * arriving concurently.
965: */
966: if (sc->proto & UMASS_PROTO_CBI_I) {
967: err = usbd_open_pipe(sc->iface, sc->intrin,
968: USBD_EXCLUSIVE_USE, &sc->intrin_pipe);
969: if (err) {
970: DPRINTF(UDMASS_USB, ("%s: couldn't open %d-in (intr)\n",
971: USBDEVNAME(sc->sc_dev), sc->intrin));
972: umass_detach(self);
973: USB_ATTACH_ERROR_RETURN;
974: }
975: }
976:
977: /* initialisation of generic part */
978: sc->transfer_state = TSTATE_ATTACH;
979:
980: /* request a sufficient number of xfer handles */
981: for (i = 0; i < XFER_NR; i++) {
982: sc->transfer_xfer[i] = usbd_alloc_xfer(uaa->device);
983: if (!sc->transfer_xfer[i]) {
984: DPRINTF(UDMASS_USB, ("%s: Out of memory\n",
985: USBDEVNAME(sc->sc_dev)));
986: umass_detach(self);
987: USB_ATTACH_ERROR_RETURN;
988: }
989: }
990:
991: /* Initialise the wire protocol specific methods */
992: if (sc->proto & UMASS_PROTO_BBB) {
993: sc->reset = umass_bbb_reset;
994: sc->transfer = umass_bbb_transfer;
995: sc->state = umass_bbb_state;
996: } else if (sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I)) {
997: sc->reset = umass_cbi_reset;
998: sc->transfer = umass_cbi_transfer;
999: sc->state = umass_cbi_state;
1000: #ifdef USB_DEBUG
1001: } else {
1002: panic("%s:%d: Unknown proto 0x%02x",
1003: __FILE__, __LINE__, sc->proto);
1004: #endif
1005: }
1006:
1007: if (sc->proto & UMASS_PROTO_SCSI)
1008: sc->transform = umass_scsi_transform;
1009: else if (sc->proto & UMASS_PROTO_UFI)
1010: sc->transform = umass_ufi_transform;
1011: else if (sc->proto & UMASS_PROTO_ATAPI)
1012: sc->transform = umass_atapi_transform;
1013: else if (sc->proto & UMASS_PROTO_RBC)
1014: sc->transform = umass_rbc_transform;
1015: #ifdef USB_DEBUG
1016: else
1017: panic("No transformation defined for command proto 0x%02x",
1018: sc->proto & UMASS_PROTO_COMMAND);
1019: #endif
1020:
1021: /* From here onwards the device can be used. */
1022:
1023: if (sc->quirks & SHUTTLE_INIT)
1024: umass_init_shuttle(sc);
1025:
1026: /* Get the maximum LUN supported by the device.
1027: */
1028: if ((sc->proto & UMASS_PROTO_WIRE) == UMASS_PROTO_BBB)
1029: sc->maxlun = umass_bbb_get_max_lun(sc);
1030: else
1031: sc->maxlun = 0;
1032:
1033: if ((sc->proto & UMASS_PROTO_SCSI) ||
1034: (sc->proto & UMASS_PROTO_ATAPI) ||
1035: (sc->proto & UMASS_PROTO_UFI) ||
1036: (sc->proto & UMASS_PROTO_RBC)) {
1037: /* Prepare the SCSI command block */
1038: sc->cam_scsi_sense.opcode = REQUEST_SENSE;
1039: sc->cam_scsi_test_unit_ready.opcode = TEST_UNIT_READY;
1040:
1041: /* register the SIM */
1042: err = umass_cam_attach_sim(sc);
1043: if (err) {
1044: umass_detach(self);
1045: USB_ATTACH_ERROR_RETURN;
1046: }
1047: /* scan the new sim */
1048: err = umass_cam_attach(sc);
1049: if (err) {
1050: umass_cam_detach_sim(sc);
1051: umass_detach(self);
1052: USB_ATTACH_ERROR_RETURN;
1053: }
1054: } else {
1055: panic("%s:%d: Unknown proto 0x%02x",
1056: __FILE__, __LINE__, sc->proto);
1057: }
1058:
1059: sc->transfer_state = TSTATE_IDLE;
1060: DPRINTF(UDMASS_GEN, ("%s: Attach finished\n", USBDEVNAME(sc->sc_dev)));
1061:
1062: USB_ATTACH_SUCCESS_RETURN;
1063: }
1064:
1065: USB_DETACH(umass)
1066: {
1067: USB_DETACH_START(umass, sc);
1068: int err = 0;
1069: int i;
1070:
1071: DPRINTF(UDMASS_USB, ("%s: detached\n", USBDEVNAME(sc->sc_dev)));
1072:
1073: sc->flags |= UMASS_FLAGS_GONE;
1074:
1075: if ((sc->proto & UMASS_PROTO_SCSI) ||
1076: (sc->proto & UMASS_PROTO_ATAPI) ||
1077: (sc->proto & UMASS_PROTO_UFI) ||
1078: (sc->proto & UMASS_PROTO_RBC))
1079: /* detach the SCSI host controller (SIM) */
1080: err = umass_cam_detach_sim(sc);
1081:
1082: for (i = 0; i < XFER_NR; i++)
1083: if (sc->transfer_xfer[i])
1084: usbd_free_xfer(sc->transfer_xfer[i]);
1085:
1086: /* remove all the pipes */
1087: if (sc->bulkout_pipe)
1088: usbd_close_pipe(sc->bulkout_pipe);
1089: if (sc->bulkin_pipe)
1090: usbd_close_pipe(sc->bulkin_pipe);
1091: if (sc->intrin_pipe)
1092: usbd_close_pipe(sc->intrin_pipe);
1093:
1094: return(err);
1095: }
1096:
1097: Static void
1098: umass_init_shuttle(struct umass_softc *sc)
1099: {
1100: usb_device_request_t req;
1101: u_char status[2];
1102:
1103: /* The Linux driver does this, but no one can tell us what the
1104: * command does.
1105: */
1106: req.bmRequestType = UT_READ_VENDOR_DEVICE;
1107: req.bRequest = 1; /* XXX unknown command */
1108: USETW(req.wValue, 0);
1109: USETW(req.wIndex, sc->ifaceno);
1110: USETW(req.wLength, sizeof status);
1111: (void) usbd_do_request(sc->sc_udev, &req, &status);
1112:
1113: DPRINTF(UDMASS_GEN, ("%s: Shuttle init returned 0x%02x%02x\n",
1114: USBDEVNAME(sc->sc_dev), status[0], status[1]));
1115: }
1116:
1117: /*
1118: * Generic functions to handle transfers
1119: */
1120:
1121: Static usbd_status
1122: umass_setup_transfer(struct umass_softc *sc, usbd_pipe_handle pipe,
1123: void *buffer, int buflen, int flags,
1124: usbd_xfer_handle xfer)
1125: {
1126: usbd_status err;
1127:
1128: /* Initialiase a USB transfer and then schedule it */
1129:
1130: (void) usbd_setup_xfer(xfer, pipe, (void *) sc, buffer, buflen, flags,
1131: UMASS_TIMEOUT, sc->state);
1132:
1133: err = usbd_transfer(xfer);
1134: if (err && err != USBD_IN_PROGRESS) {
1135: DPRINTF(UDMASS_BBB, ("%s: failed to setup transfer, %s\n",
1136: USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
1137: return(err);
1138: }
1139:
1140: return (USBD_NORMAL_COMPLETION);
1141: }
1142:
1143:
1144: Static usbd_status
1145: umass_setup_ctrl_transfer(struct umass_softc *sc, usbd_device_handle udev,
1146: usb_device_request_t *req,
1147: void *buffer, int buflen, int flags,
1148: usbd_xfer_handle xfer)
1149: {
1150: usbd_status err;
1151:
1152: /* Initialiase a USB control transfer and then schedule it */
1153:
1154: (void) usbd_setup_default_xfer(xfer, udev, (void *) sc,
1155: UMASS_TIMEOUT, req, buffer, buflen, flags, sc->state);
1156:
1157: err = usbd_transfer(xfer);
1158: if (err && err != USBD_IN_PROGRESS) {
1159: DPRINTF(UDMASS_BBB, ("%s: failed to setup ctrl transfer, %s\n",
1160: USBDEVNAME(sc->sc_dev), usbd_errstr(err)));
1161:
1162: /* do not reset, as this would make us loop */
1163: return(err);
1164: }
1165:
1166: return (USBD_NORMAL_COMPLETION);
1167: }
1168:
1169: Static void
1170: umass_clear_endpoint_stall(struct umass_softc *sc,
1171: u_int8_t endpt, usbd_pipe_handle pipe,
1172: int state, usbd_xfer_handle xfer)
1173: {
1174: usbd_device_handle udev;
1175:
1176: DPRINTF(UDMASS_BBB, ("%s: Clear endpoint 0x%02x stall\n",
1177: USBDEVNAME(sc->sc_dev), endpt));
1178:
1179: usbd_interface2device_handle(sc->iface, &udev);
1180:
1181: sc->transfer_state = state;
1182:
1183: usbd_clear_endpoint_toggle(pipe);
1184:
1185: sc->request.bmRequestType = UT_WRITE_ENDPOINT;
1186: sc->request.bRequest = UR_CLEAR_FEATURE;
1187: USETW(sc->request.wValue, UF_ENDPOINT_HALT);
1188: USETW(sc->request.wIndex, endpt);
1189: USETW(sc->request.wLength, 0);
1190: umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0, xfer);
1191: }
1192:
1193: Static void
1194: umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv)
1195: {
1196: sc->transfer_cb = cb;
1197: sc->transfer_priv = priv;
1198:
1199: /* The reset is a forced reset, so no error (yet) */
1200: sc->reset(sc, STATUS_CMD_OK);
1201: }
1202:
1203: /*
1204: * Bulk protocol specific functions
1205: */
1206:
1207: Static void
1208: umass_bbb_reset(struct umass_softc *sc, int status)
1209: {
1210: usbd_device_handle udev;
1211:
1212: KASSERT(sc->proto & UMASS_PROTO_BBB,
1213: ("%s: umass_bbb_reset: wrong sc->proto 0x%02x\n",
1214: USBDEVNAME(sc->sc_dev), sc->proto));
1215:
1216: /*
1217: * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
1218: *
1219: * For Reset Recovery the host shall issue in the following order:
1220: * a) a Bulk-Only Mass Storage Reset
1221: * b) a Clear Feature HALT to the Bulk-In endpoint
1222: * c) a Clear Feature HALT to the Bulk-Out endpoint
1223: *
1224: * This is done in 3 steps, states:
1225: * TSTATE_BBB_RESET1
1226: * TSTATE_BBB_RESET2
1227: * TSTATE_BBB_RESET3
1228: *
1229: * If the reset doesn't succeed, the device should be port reset.
1230: */
1231:
1232: DPRINTF(UDMASS_BBB, ("%s: Bulk Reset\n",
1233: USBDEVNAME(sc->sc_dev)));
1234:
1235: sc->transfer_state = TSTATE_BBB_RESET1;
1236: sc->transfer_status = status;
1237:
1238: usbd_interface2device_handle(sc->iface, &udev);
1239:
1240: /* reset is a class specific interface write */
1241: sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
1242: sc->request.bRequest = UR_BBB_RESET;
1243: USETW(sc->request.wValue, 0);
1244: USETW(sc->request.wIndex, sc->ifaceno);
1245: USETW(sc->request.wLength, 0);
1246: umass_setup_ctrl_transfer(sc, udev, &sc->request, NULL, 0, 0,
1247: sc->transfer_xfer[XFER_BBB_RESET1]);
1248: }
1249:
1250: Static void
1251: umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen,
1252: void *data, int datalen, int dir,
1253: transfer_cb_f cb, void *priv)
1254: {
1255: KASSERT(sc->proto & UMASS_PROTO_BBB,
1256: ("%s: umass_bbb_transfer: wrong sc->proto 0x%02x\n",
1257: USBDEVNAME(sc->sc_dev), sc->proto));
1258:
1259: /*
1260: * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly
1261: * a data phase of datalen bytes from/to the device and finally a
1262: * csw read phase.
1263: * If the data direction was inbound a maximum of datalen bytes
1264: * is stored in the buffer pointed to by data.
1265: *
1266: * umass_bbb_transfer initialises the transfer and lets the state
1267: * machine in umass_bbb_state handle the completion. It uses the
1268: * following states:
1269: * TSTATE_BBB_COMMAND
1270: * -> TSTATE_BBB_DATA
1271: * -> TSTATE_BBB_STATUS
1272: * -> TSTATE_BBB_STATUS2
1273: * -> TSTATE_BBB_IDLE
1274: *
1275: * An error in any of those states will invoke
1276: * umass_bbb_reset.
1277: */
1278:
1279: /* check the given arguments */
1280: KASSERT(datalen == 0 || data != NULL,
1281: ("%s: datalen > 0, but no buffer",USBDEVNAME(sc->sc_dev)));
1282: KASSERT(cmdlen <= CBWCDBLENGTH,
1283: ("%s: cmdlen exceeds CDB length in CBW (%d > %d)",
1284: USBDEVNAME(sc->sc_dev), cmdlen, CBWCDBLENGTH));
1285: KASSERT(dir == DIR_NONE || datalen > 0,
1286: ("%s: datalen == 0 while direction is not NONE\n",
1287: USBDEVNAME(sc->sc_dev)));
1288: KASSERT(datalen == 0 || dir != DIR_NONE,
1289: ("%s: direction is NONE while datalen is not zero\n",
1290: USBDEVNAME(sc->sc_dev)));
1291: KASSERT(sizeof(umass_bbb_cbw_t) == UMASS_BBB_CBW_SIZE,
1292: ("%s: CBW struct does not have the right size (%ld vs. %d)\n",
1293: USBDEVNAME(sc->sc_dev),
1294: (long)sizeof(umass_bbb_cbw_t), UMASS_BBB_CBW_SIZE));
1295: KASSERT(sizeof(umass_bbb_csw_t) == UMASS_BBB_CSW_SIZE,
1296: ("%s: CSW struct does not have the right size (%ld vs. %d)\n",
1297: USBDEVNAME(sc->sc_dev),
1298: (long)sizeof(umass_bbb_csw_t), UMASS_BBB_CSW_SIZE));
1299:
1300: /*
1301: * Determine the direction of the data transfer and the length.
1302: *
1303: * dCBWDataTransferLength (datalen) :
1304: * This field indicates the number of bytes of data that the host
1305: * intends to transfer on the IN or OUT Bulk endpoint(as indicated by
1306: * the Direction bit) during the execution of this command. If this
1307: * field is set to 0, the device will expect that no data will be
1308: * transferred IN or OUT during this command, regardless of the value
1309: * of the Direction bit defined in dCBWFlags.
1310: *
1311: * dCBWFlags (dir) :
1312: * The bits of the Flags field are defined as follows:
1313: * Bits 0-6 reserved
1314: * Bit 7 Direction - this bit shall be ignored if the
1315: * dCBWDataTransferLength field is zero.
1316: * 0 = data Out from host to device
1317: * 1 = data In from device to host
1318: */
1319:
1320: /* Fill in the Command Block Wrapper
1321: * We fill in all the fields, so there is no need to bzero it first.
1322: */
1323: USETDW(sc->cbw.dCBWSignature, CBWSIGNATURE);
1324: /* We don't care about the initial value, as long as the values are unique */
1325: USETDW(sc->cbw.dCBWTag, UGETDW(sc->cbw.dCBWTag) + 1);
1326: USETDW(sc->cbw.dCBWDataTransferLength, datalen);
1327: /* DIR_NONE is treated as DIR_OUT (0x00) */
1328: sc->cbw.bCBWFlags = (dir == DIR_IN? CBWFLAGS_IN:CBWFLAGS_OUT);
1329: sc->cbw.bCBWLUN = lun;
1330: sc->cbw.bCDBLength = cmdlen;
1331: bcopy(cmd, sc->cbw.CBWCDB, cmdlen);
1332:
1333: DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw));
1334:
1335: /* store the details for the data transfer phase */
1336: sc->transfer_dir = dir;
1337: sc->transfer_data = data;
1338: sc->transfer_datalen = datalen;
1339: sc->transfer_actlen = 0;
1340: sc->transfer_cb = cb;
1341: sc->transfer_priv = priv;
1342: sc->transfer_status = STATUS_CMD_OK;
1343:
1344: /* move from idle to the command state */
1345: sc->transfer_state = TSTATE_BBB_COMMAND;
1346:
1347: /* Send the CBW from host to device via bulk-out endpoint. */
1348: if (umass_setup_transfer(sc, sc->bulkout_pipe,
1349: &sc->cbw, UMASS_BBB_CBW_SIZE, 0,
1350: sc->transfer_xfer[XFER_BBB_CBW])) {
1351: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1352: }
1353: }
1354:
1355:
1356: Static void
1357: umass_bbb_state(usbd_xfer_handle xfer, usbd_private_handle priv,
1358: usbd_status err)
1359: {
1360: struct umass_softc *sc = (struct umass_softc *) priv;
1361: usbd_xfer_handle next_xfer;
1362:
1363: KASSERT(sc->proto & UMASS_PROTO_BBB,
1364: ("%s: umass_bbb_state: wrong sc->proto 0x%02x\n",
1365: USBDEVNAME(sc->sc_dev), sc->proto));
1366:
1367: /*
1368: * State handling for BBB transfers.
1369: *
1370: * The subroutine is rather long. It steps through the states given in
1371: * Annex A of the Bulk-Only specification.
1372: * Each state first does the error handling of the previous transfer
1373: * and then prepares the next transfer.
1374: * Each transfer is done asynchroneously so after the request/transfer
1375: * has been submitted you will find a 'return;'.
1376: */
1377:
1378: DPRINTF(UDMASS_BBB, ("%s: Handling BBB state %d (%s), xfer=%p, %s\n",
1379: USBDEVNAME(sc->sc_dev), sc->transfer_state,
1380: states[sc->transfer_state], xfer, usbd_errstr(err)));
1381:
1382: switch (sc->transfer_state) {
1383:
1384: /***** Bulk Transfer *****/
1385: case TSTATE_BBB_COMMAND:
1386: /* Command transport phase, error handling */
1387: if (err) {
1388: DPRINTF(UDMASS_BBB, ("%s: failed to send CBW\n",
1389: USBDEVNAME(sc->sc_dev)));
1390: /* If the device detects that the CBW is invalid, then
1391: * the device may STALL both bulk endpoints and require
1392: * a Bulk-Reset
1393: */
1394: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1395: return;
1396: }
1397:
1398: /* Data transport phase, setup transfer */
1399: sc->transfer_state = TSTATE_BBB_DATA;
1400: if (sc->transfer_dir == DIR_IN) {
1401: if (umass_setup_transfer(sc, sc->bulkin_pipe,
1402: sc->transfer_data, sc->transfer_datalen,
1403: USBD_SHORT_XFER_OK,
1404: sc->transfer_xfer[XFER_BBB_DATA]))
1405: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1406:
1407: return;
1408: } else if (sc->transfer_dir == DIR_OUT) {
1409: if (umass_setup_transfer(sc, sc->bulkout_pipe,
1410: sc->transfer_data, sc->transfer_datalen,
1411: 0, /* fixed length transfer */
1412: sc->transfer_xfer[XFER_BBB_DATA]))
1413: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1414:
1415: return;
1416: } else {
1417: DPRINTF(UDMASS_BBB, ("%s: no data phase\n",
1418: USBDEVNAME(sc->sc_dev)));
1419: }
1420:
1421: /* FALLTHROUGH if no data phase, err == 0 */
1422: case TSTATE_BBB_DATA:
1423: /* Command transport phase, error handling (ignored if no data
1424: * phase (fallthrough from previous state)) */
1425: if (sc->transfer_dir != DIR_NONE) {
1426: /* retrieve the length of the transfer that was done */
1427: usbd_get_xfer_status(xfer, NULL, NULL,
1428: &sc->transfer_actlen, NULL);
1429:
1430: if (err) {
1431: DPRINTF(UDMASS_BBB, ("%s: Data-%s %db failed, "
1432: "%s\n", USBDEVNAME(sc->sc_dev),
1433: (sc->transfer_dir == DIR_IN?"in":"out"),
1434: sc->transfer_datalen,usbd_errstr(err)));
1435:
1436: if (err == USBD_STALLED) {
1437: umass_clear_endpoint_stall(sc,
1438: (sc->transfer_dir == DIR_IN?
1439: sc->bulkin:sc->bulkout),
1440: (sc->transfer_dir == DIR_IN?
1441: sc->bulkin_pipe:sc->bulkout_pipe),
1442: TSTATE_BBB_DCLEAR,
1443: sc->transfer_xfer[XFER_BBB_DCLEAR]);
1444: return;
1445: } else {
1446: /* Unless the error is a pipe stall the
1447: * error is fatal.
1448: */
1449: umass_bbb_reset(sc,STATUS_WIRE_FAILED);
1450: return;
1451: }
1452: }
1453: }
1454:
1455: DIF(UDMASS_BBB, if (sc->transfer_dir == DIR_IN)
1456: umass_dump_buffer(sc, sc->transfer_data,
1457: sc->transfer_datalen, 48));
1458:
1459:
1460:
1461: /* FALLTHROUGH, err == 0 (no data phase or successfull) */
1462: case TSTATE_BBB_DCLEAR: /* stall clear after data phase */
1463: case TSTATE_BBB_SCLEAR: /* stall clear after status phase */
1464: /* Reading of CSW after bulk stall condition in data phase
1465: * (TSTATE_BBB_DATA2) or bulk-in stall condition after
1466: * reading CSW (TSTATE_BBB_SCLEAR).
1467: * In the case of no data phase or successfull data phase,
1468: * err == 0 and the following if block is passed.
1469: */
1470: if (err) { /* should not occur */
1471: /* try the transfer below, even if clear stall failed */
1472: DPRINTF(UDMASS_BBB, ("%s: bulk-%s stall clear failed"
1473: ", %s\n", USBDEVNAME(sc->sc_dev),
1474: (sc->transfer_dir == DIR_IN? "in":"out"),
1475: usbd_errstr(err)));
1476: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1477: return;
1478: }
1479:
1480: /* Status transport phase, setup transfer */
1481: if (sc->transfer_state == TSTATE_BBB_COMMAND ||
1482: sc->transfer_state == TSTATE_BBB_DATA ||
1483: sc->transfer_state == TSTATE_BBB_DCLEAR) {
1484: /* After no data phase, successfull data phase and
1485: * after clearing bulk-in/-out stall condition
1486: */
1487: sc->transfer_state = TSTATE_BBB_STATUS1;
1488: next_xfer = sc->transfer_xfer[XFER_BBB_CSW1];
1489: } else {
1490: /* After first attempt of fetching CSW */
1491: sc->transfer_state = TSTATE_BBB_STATUS2;
1492: next_xfer = sc->transfer_xfer[XFER_BBB_CSW2];
1493: }
1494:
1495: /* Read the Command Status Wrapper via bulk-in endpoint. */
1496: if (umass_setup_transfer(sc, sc->bulkin_pipe,
1497: &sc->csw, UMASS_BBB_CSW_SIZE, 0,
1498: next_xfer)) {
1499: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1500: return;
1501: }
1502:
1503: return;
1504: case TSTATE_BBB_STATUS1: /* first attempt */
1505: case TSTATE_BBB_STATUS2: /* second attempt */
1506: /* Status transfer, error handling */
1507: {
1508: int Residue;
1509: if (err) {
1510: DPRINTF(UDMASS_BBB, ("%s: Failed to read CSW, %s%s\n",
1511: USBDEVNAME(sc->sc_dev), usbd_errstr(err),
1512: (sc->transfer_state == TSTATE_BBB_STATUS1?
1513: ", retrying":"")));
1514:
1515: /* If this was the first attempt at fetching the CSW
1516: * retry it, otherwise fail.
1517: */
1518: if (sc->transfer_state == TSTATE_BBB_STATUS1) {
1519: umass_clear_endpoint_stall(sc,
1520: sc->bulkin, sc->bulkin_pipe,
1521: TSTATE_BBB_SCLEAR,
1522: sc->transfer_xfer[XFER_BBB_SCLEAR]);
1523: return;
1524: } else {
1525: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1526: return;
1527: }
1528: }
1529:
1530: DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw));
1531:
1532: /* Translate weird command-status signatures. */
1533: if ((sc->quirks & WRONG_CSWSIG) &&
1534: UGETDW(sc->csw.dCSWSignature) == CSWSIGNATURE_OLYMPUS_C1)
1535: USETDW(sc->csw.dCSWSignature, CSWSIGNATURE);
1536:
1537: Residue = UGETDW(sc->csw.dCSWDataResidue);
1538: if (Residue == 0 &&
1539: sc->transfer_datalen - sc->transfer_actlen != 0)
1540: Residue = sc->transfer_datalen - sc->transfer_actlen;
1541:
1542: /* Check CSW and handle any error */
1543: if (UGETDW(sc->csw.dCSWSignature) != CSWSIGNATURE) {
1544: /* Invalid CSW: Wrong signature or wrong tag might
1545: * indicate that the device is confused -> reset it.
1546: */
1547: printf("%s: Invalid CSW: sig 0x%08x should be 0x%08x\n",
1548: USBDEVNAME(sc->sc_dev),
1549: UGETDW(sc->csw.dCSWSignature),
1550: CSWSIGNATURE);
1551:
1552: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1553: return;
1554: } else if (UGETDW(sc->csw.dCSWTag)
1555: != UGETDW(sc->cbw.dCBWTag)) {
1556: printf("%s: Invalid CSW: tag %d should be %d\n",
1557: USBDEVNAME(sc->sc_dev),
1558: UGETDW(sc->csw.dCSWTag),
1559: UGETDW(sc->cbw.dCBWTag));
1560:
1561: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1562: return;
1563:
1564: /* CSW is valid here */
1565: } else if (sc->csw.bCSWStatus > CSWSTATUS_PHASE) {
1566: printf("%s: Invalid CSW: status %d > %d\n",
1567: USBDEVNAME(sc->sc_dev),
1568: sc->csw.bCSWStatus,
1569: CSWSTATUS_PHASE);
1570:
1571: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1572: return;
1573: } else if (sc->csw.bCSWStatus == CSWSTATUS_PHASE) {
1574: printf("%s: Phase Error, residue = %d\n",
1575: USBDEVNAME(sc->sc_dev), Residue);
1576:
1577: umass_bbb_reset(sc, STATUS_WIRE_FAILED);
1578: return;
1579:
1580: } else if (sc->transfer_actlen > sc->transfer_datalen) {
1581: /* Buffer overrun! Don't let this go by unnoticed */
1582: panic("%s: transferred %db instead of %db",
1583: USBDEVNAME(sc->sc_dev),
1584: sc->transfer_actlen, sc->transfer_datalen);
1585:
1586: } else if (sc->csw.bCSWStatus == CSWSTATUS_FAILED) {
1587: DPRINTF(UDMASS_BBB, ("%s: Command Failed, res = %d\n",
1588: USBDEVNAME(sc->sc_dev), Residue));
1589:
1590: /* SCSI command failed but transfer was succesful */
1591: sc->transfer_state = TSTATE_IDLE;
1592: sc->transfer_cb(sc, sc->transfer_priv, Residue,
1593: STATUS_CMD_FAILED);
1594: return;
1595:
1596: } else { /* success */
1597: sc->transfer_state = TSTATE_IDLE;
1598: sc->transfer_cb(sc, sc->transfer_priv, Residue,
1599: STATUS_CMD_OK);
1600:
1601: return;
1602: }
1603: }
1604:
1605: /***** Bulk Reset *****/
1606: case TSTATE_BBB_RESET1:
1607: if (err)
1608: printf("%s: BBB reset failed, %s\n",
1609: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1610:
1611: umass_clear_endpoint_stall(sc,
1612: sc->bulkin, sc->bulkin_pipe, TSTATE_BBB_RESET2,
1613: sc->transfer_xfer[XFER_BBB_RESET2]);
1614:
1615: return;
1616: case TSTATE_BBB_RESET2:
1617: if (err) /* should not occur */
1618: printf("%s: BBB bulk-in clear stall failed, %s\n",
1619: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1620: /* no error recovery, otherwise we end up in a loop */
1621:
1622: umass_clear_endpoint_stall(sc,
1623: sc->bulkout, sc->bulkout_pipe, TSTATE_BBB_RESET3,
1624: sc->transfer_xfer[XFER_BBB_RESET3]);
1625:
1626: return;
1627: case TSTATE_BBB_RESET3:
1628: if (err) /* should not occur */
1629: printf("%s: BBB bulk-out clear stall failed, %s\n",
1630: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1631: /* no error recovery, otherwise we end up in a loop */
1632:
1633: sc->transfer_state = TSTATE_IDLE;
1634: if (sc->transfer_priv) {
1635: sc->transfer_cb(sc, sc->transfer_priv,
1636: sc->transfer_datalen,
1637: sc->transfer_status);
1638: }
1639:
1640: return;
1641:
1642: /***** Default *****/
1643: default:
1644: panic("%s: Unknown state %d",
1645: USBDEVNAME(sc->sc_dev), sc->transfer_state);
1646: }
1647: }
1648:
1649: Static int
1650: umass_bbb_get_max_lun(struct umass_softc *sc)
1651: {
1652: usbd_device_handle udev;
1653: usb_device_request_t req;
1654: usbd_status err;
1655: usb_interface_descriptor_t *id;
1656: int maxlun = 0;
1657: u_int8_t buf = 0;
1658:
1659: usbd_interface2device_handle(sc->iface, &udev);
1660: id = usbd_get_interface_descriptor(sc->iface);
1661:
1662: /* The Get Max Lun command is a class-specific request. */
1663: req.bmRequestType = UT_READ_CLASS_INTERFACE;
1664: req.bRequest = UR_BBB_GET_MAX_LUN;
1665: USETW(req.wValue, 0);
1666: USETW(req.wIndex, id->bInterfaceNumber);
1667: USETW(req.wLength, 1);
1668:
1669: err = usbd_do_request(udev, &req, &buf);
1670: switch (err) {
1671: case USBD_NORMAL_COMPLETION:
1672: maxlun = buf;
1673: DPRINTF(UDMASS_BBB, ("%s: Max Lun is %d\n",
1674: USBDEVNAME(sc->sc_dev), maxlun));
1675: break;
1676: case USBD_STALLED:
1677: case USBD_SHORT_XFER:
1678: default:
1679: /* Device doesn't support Get Max Lun request. */
1680: printf("%s: Get Max Lun not supported (%s)\n",
1681: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1682: /* XXX Should we port_reset the device? */
1683: break;
1684: }
1685:
1686: return(maxlun);
1687: }
1688:
1689: /*
1690: * Command/Bulk/Interrupt (CBI) specific functions
1691: */
1692:
1693: Static int
1694: umass_cbi_adsc(struct umass_softc *sc, char *buffer, int buflen,
1695: usbd_xfer_handle xfer)
1696: {
1697: usbd_device_handle udev;
1698:
1699: KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
1700: ("%s: umass_cbi_adsc: wrong sc->proto 0x%02x\n",
1701: USBDEVNAME(sc->sc_dev), sc->proto));
1702:
1703: usbd_interface2device_handle(sc->iface, &udev);
1704:
1705: sc->request.bmRequestType = UT_WRITE_CLASS_INTERFACE;
1706: sc->request.bRequest = UR_CBI_ADSC;
1707: USETW(sc->request.wValue, 0);
1708: USETW(sc->request.wIndex, sc->ifaceno);
1709: USETW(sc->request.wLength, buflen);
1710: return umass_setup_ctrl_transfer(sc, udev, &sc->request, buffer,
1711: buflen, 0, xfer);
1712: }
1713:
1714:
1715: Static void
1716: umass_cbi_reset(struct umass_softc *sc, int status)
1717: {
1718: int i;
1719: # define SEND_DIAGNOSTIC_CMDLEN 12
1720:
1721: KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
1722: ("%s: umass_cbi_reset: wrong sc->proto 0x%02x\n",
1723: USBDEVNAME(sc->sc_dev), sc->proto));
1724:
1725: /*
1726: * Command Block Reset Protocol
1727: *
1728: * First send a reset request to the device. Then clear
1729: * any possibly stalled bulk endpoints.
1730:
1731: * This is done in 3 steps, states:
1732: * TSTATE_CBI_RESET1
1733: * TSTATE_CBI_RESET2
1734: * TSTATE_CBI_RESET3
1735: *
1736: * If the reset doesn't succeed, the device should be port reset.
1737: */
1738:
1739: DPRINTF(UDMASS_CBI, ("%s: CBI Reset\n",
1740: USBDEVNAME(sc->sc_dev)));
1741:
1742: KASSERT(sizeof(sc->cbl) >= SEND_DIAGNOSTIC_CMDLEN,
1743: ("%s: CBL struct is too small (%ld < %d)\n",
1744: USBDEVNAME(sc->sc_dev),
1745: (long)sizeof(sc->cbl), SEND_DIAGNOSTIC_CMDLEN));
1746:
1747: sc->transfer_state = TSTATE_CBI_RESET1;
1748: sc->transfer_status = status;
1749:
1750: /* The 0x1d code is the SEND DIAGNOSTIC command. To distingiush between
1751: * the two the last 10 bytes of the cbl is filled with 0xff (section
1752: * 2.2 of the CBI spec).
1753: */
1754: sc->cbl[0] = 0x1d; /* Command Block Reset */
1755: sc->cbl[1] = 0x04;
1756: for (i = 2; i < SEND_DIAGNOSTIC_CMDLEN; i++)
1757: sc->cbl[i] = 0xff;
1758:
1759: umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN,
1760: sc->transfer_xfer[XFER_CBI_RESET1]);
1761: /* XXX if the command fails we should reset the port on the bub */
1762: }
1763:
1764: Static void
1765: umass_cbi_transfer(struct umass_softc *sc, int lun,
1766: void *cmd, int cmdlen, void *data, int datalen, int dir,
1767: transfer_cb_f cb, void *priv)
1768: {
1769: KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
1770: ("%s: umass_cbi_transfer: wrong sc->proto 0x%02x\n",
1771: USBDEVNAME(sc->sc_dev), sc->proto));
1772:
1773: /*
1774: * Do a CBI transfer with cmdlen bytes from cmd, possibly
1775: * a data phase of datalen bytes from/to the device and finally a
1776: * csw read phase.
1777: * If the data direction was inbound a maximum of datalen bytes
1778: * is stored in the buffer pointed to by data.
1779: *
1780: * umass_cbi_transfer initialises the transfer and lets the state
1781: * machine in umass_cbi_state handle the completion. It uses the
1782: * following states:
1783: * TSTATE_CBI_COMMAND
1784: * -> XXX fill in
1785: *
1786: * An error in any of those states will invoke
1787: * umass_cbi_reset.
1788: */
1789:
1790: /* check the given arguments */
1791: KASSERT(datalen == 0 || data != NULL,
1792: ("%s: datalen > 0, but no buffer",USBDEVNAME(sc->sc_dev)));
1793: KASSERT(datalen == 0 || dir != DIR_NONE,
1794: ("%s: direction is NONE while datalen is not zero\n",
1795: USBDEVNAME(sc->sc_dev)));
1796:
1797: /* store the details for the data transfer phase */
1798: sc->transfer_dir = dir;
1799: sc->transfer_data = data;
1800: sc->transfer_datalen = datalen;
1801: sc->transfer_actlen = 0;
1802: sc->transfer_cb = cb;
1803: sc->transfer_priv = priv;
1804: sc->transfer_status = STATUS_CMD_OK;
1805:
1806: /* move from idle to the command state */
1807: sc->transfer_state = TSTATE_CBI_COMMAND;
1808:
1809: DIF(UDMASS_CBI, umass_cbi_dump_cmd(sc, cmd, cmdlen));
1810:
1811: /* Send the Command Block from host to device via control endpoint. */
1812: if (umass_cbi_adsc(sc, cmd, cmdlen, sc->transfer_xfer[XFER_CBI_CB]))
1813: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1814: }
1815:
1816: Static void
1817: umass_cbi_state(usbd_xfer_handle xfer, usbd_private_handle priv,
1818: usbd_status err)
1819: {
1820: struct umass_softc *sc = (struct umass_softc *) priv;
1821:
1822: KASSERT(sc->proto & (UMASS_PROTO_CBI|UMASS_PROTO_CBI_I),
1823: ("%s: umass_cbi_state: wrong sc->proto 0x%02x\n",
1824: USBDEVNAME(sc->sc_dev), sc->proto));
1825:
1826: /*
1827: * State handling for CBI transfers.
1828: */
1829:
1830: DPRINTF(UDMASS_CBI, ("%s: Handling CBI state %d (%s), xfer=%p, %s\n",
1831: USBDEVNAME(sc->sc_dev), sc->transfer_state,
1832: states[sc->transfer_state], xfer, usbd_errstr(err)));
1833:
1834: switch (sc->transfer_state) {
1835:
1836: /***** CBI Transfer *****/
1837: case TSTATE_CBI_COMMAND:
1838: if (err == USBD_STALLED) {
1839: DPRINTF(UDMASS_CBI, ("%s: Command Transport failed\n",
1840: USBDEVNAME(sc->sc_dev)));
1841: /* Status transport by control pipe (section 2.3.2.1).
1842: * The command contained in the command block failed.
1843: *
1844: * The control pipe has already been unstalled by the
1845: * USB stack.
1846: * Section 2.4.3.1.1 states that the bulk in endpoints
1847: * should not be stalled at this point.
1848: */
1849:
1850: sc->transfer_state = TSTATE_IDLE;
1851: sc->transfer_cb(sc, sc->transfer_priv,
1852: sc->transfer_datalen,
1853: STATUS_CMD_FAILED);
1854:
1855: return;
1856: } else if (err) {
1857: DPRINTF(UDMASS_CBI, ("%s: failed to send ADSC\n",
1858: USBDEVNAME(sc->sc_dev)));
1859: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1860:
1861: return;
1862: }
1863:
1864: sc->transfer_state = TSTATE_CBI_DATA;
1865: if (sc->transfer_dir == DIR_IN) {
1866: if (umass_setup_transfer(sc, sc->bulkin_pipe,
1867: sc->transfer_data, sc->transfer_datalen,
1868: USBD_SHORT_XFER_OK,
1869: sc->transfer_xfer[XFER_CBI_DATA]))
1870: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1871:
1872: } else if (sc->transfer_dir == DIR_OUT) {
1873: if (umass_setup_transfer(sc, sc->bulkout_pipe,
1874: sc->transfer_data, sc->transfer_datalen,
1875: 0, /* fixed length transfer */
1876: sc->transfer_xfer[XFER_CBI_DATA]))
1877: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1878:
1879: } else if (sc->proto & UMASS_PROTO_CBI_I) {
1880: DPRINTF(UDMASS_CBI, ("%s: no data phase\n",
1881: USBDEVNAME(sc->sc_dev)));
1882: sc->transfer_state = TSTATE_CBI_STATUS;
1883: if (umass_setup_transfer(sc, sc->intrin_pipe,
1884: &sc->sbl, sizeof(sc->sbl),
1885: 0, /* fixed length transfer */
1886: sc->transfer_xfer[XFER_CBI_STATUS])){
1887: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1888: }
1889: } else {
1890: DPRINTF(UDMASS_CBI, ("%s: no data phase\n",
1891: USBDEVNAME(sc->sc_dev)));
1892: /* No command completion interrupt. Request
1893: * sense data.
1894: */
1895: sc->transfer_state = TSTATE_IDLE;
1896: sc->transfer_cb(sc, sc->transfer_priv,
1897: 0, STATUS_CMD_UNKNOWN);
1898: }
1899:
1900: return;
1901:
1902: case TSTATE_CBI_DATA:
1903: /* retrieve the length of the transfer that was done */
1904: usbd_get_xfer_status(xfer,NULL,NULL,&sc->transfer_actlen,NULL);
1905:
1906: if (err) {
1907: DPRINTF(UDMASS_CBI, ("%s: Data-%s %db failed, "
1908: "%s\n", USBDEVNAME(sc->sc_dev),
1909: (sc->transfer_dir == DIR_IN?"in":"out"),
1910: sc->transfer_datalen,usbd_errstr(err)));
1911:
1912: if (err == USBD_STALLED) {
1913: umass_clear_endpoint_stall(sc,
1914: sc->bulkin, sc->bulkin_pipe,
1915: TSTATE_CBI_DCLEAR,
1916: sc->transfer_xfer[XFER_CBI_DCLEAR]);
1917: } else {
1918: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1919: }
1920: return;
1921: }
1922:
1923: DIF(UDMASS_CBI, if (sc->transfer_dir == DIR_IN)
1924: umass_dump_buffer(sc, sc->transfer_data,
1925: sc->transfer_actlen, 48));
1926:
1927: if (sc->proto & UMASS_PROTO_CBI_I) {
1928: sc->transfer_state = TSTATE_CBI_STATUS;
1929: if (umass_setup_transfer(sc, sc->intrin_pipe,
1930: &sc->sbl, sizeof(sc->sbl),
1931: 0, /* fixed length transfer */
1932: sc->transfer_xfer[XFER_CBI_STATUS])){
1933: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1934: }
1935: } else {
1936: /* No command completion interrupt. Request
1937: * sense to get status of command.
1938: */
1939: sc->transfer_state = TSTATE_IDLE;
1940: sc->transfer_cb(sc, sc->transfer_priv,
1941: sc->transfer_datalen - sc->transfer_actlen,
1942: STATUS_CMD_UNKNOWN);
1943: }
1944: return;
1945:
1946: case TSTATE_CBI_STATUS:
1947: if (err) {
1948: DPRINTF(UDMASS_CBI, ("%s: Status Transport failed\n",
1949: USBDEVNAME(sc->sc_dev)));
1950: /* Status transport by interrupt pipe (section 2.3.2.2).
1951: */
1952:
1953: if (err == USBD_STALLED) {
1954: umass_clear_endpoint_stall(sc,
1955: sc->intrin, sc->intrin_pipe,
1956: TSTATE_CBI_SCLEAR,
1957: sc->transfer_xfer[XFER_CBI_SCLEAR]);
1958: } else {
1959: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
1960: }
1961: return;
1962: }
1963:
1964: /* Dissect the information in the buffer */
1965:
1966: if (sc->proto & UMASS_PROTO_UFI) {
1967: int status;
1968:
1969: /* Section 3.4.3.1.3 specifies that the UFI command
1970: * protocol returns an ASC and ASCQ in the interrupt
1971: * data block.
1972: */
1973:
1974: DPRINTF(UDMASS_CBI, ("%s: UFI CCI, ASC = 0x%02x, "
1975: "ASCQ = 0x%02x\n",
1976: USBDEVNAME(sc->sc_dev),
1977: sc->sbl.ufi.asc, sc->sbl.ufi.ascq));
1978:
1979: if (sc->sbl.ufi.asc == 0 && sc->sbl.ufi.ascq == 0)
1980: status = STATUS_CMD_OK;
1981: else
1982: status = STATUS_CMD_FAILED;
1983:
1984: sc->transfer_state = TSTATE_IDLE;
1985: sc->transfer_cb(sc, sc->transfer_priv,
1986: sc->transfer_datalen - sc->transfer_actlen,
1987: status);
1988: } else {
1989: /* Command Interrupt Data Block */
1990: DPRINTF(UDMASS_CBI, ("%s: type=0x%02x, value=0x%02x\n",
1991: USBDEVNAME(sc->sc_dev),
1992: sc->sbl.common.type, sc->sbl.common.value));
1993:
1994: if (sc->sbl.common.type == IDB_TYPE_CCI) {
1995: int err;
1996:
1997: if ((sc->sbl.common.value&IDB_VALUE_STATUS_MASK)
1998: == IDB_VALUE_PASS) {
1999: err = STATUS_CMD_OK;
2000: } else if ((sc->sbl.common.value & IDB_VALUE_STATUS_MASK)
2001: == IDB_VALUE_FAIL ||
2002: (sc->sbl.common.value & IDB_VALUE_STATUS_MASK)
2003: == IDB_VALUE_PERSISTENT) {
2004: err = STATUS_CMD_FAILED;
2005: } else {
2006: err = STATUS_WIRE_FAILED;
2007: }
2008:
2009: sc->transfer_state = TSTATE_IDLE;
2010: sc->transfer_cb(sc, sc->transfer_priv,
2011: sc->transfer_datalen-sc->transfer_actlen,
2012: err);
2013: }
2014: }
2015: return;
2016:
2017: case TSTATE_CBI_DCLEAR:
2018: if (err) { /* should not occur */
2019: printf("%s: CBI bulk-in/out stall clear failed, %s\n",
2020: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
2021: umass_cbi_reset(sc, STATUS_WIRE_FAILED);
2022: }
2023:
2024: sc->transfer_state = TSTATE_IDLE;
2025: sc->transfer_cb(sc, sc->transfer_priv,
2026: sc->transfer_datalen,
2027: STATUS_CMD_FAILED);
2028: return;
2029:
2030: case TSTATE_CBI_SCLEAR:
2031: if (err) /* should not occur */
2032: printf("%s: CBI intr-in stall clear failed, %s\n",
2033: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
2034:
2035: /* Something really bad is going on. Reset the device */
2036: umass_cbi_reset(sc, STATUS_CMD_FAILED);
2037: return;
2038:
2039: /***** CBI Reset *****/
2040: case TSTATE_CBI_RESET1:
2041: if (err)
2042: printf("%s: CBI reset failed, %s\n",
2043: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
2044:
2045: umass_clear_endpoint_stall(sc,
2046: sc->bulkin, sc->bulkin_pipe, TSTATE_CBI_RESET2,
2047: sc->transfer_xfer[XFER_CBI_RESET2]);
2048:
2049: return;
2050: case TSTATE_CBI_RESET2:
2051: if (err) /* should not occur */
2052: printf("%s: CBI bulk-in stall clear failed, %s\n",
2053: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
2054: /* no error recovery, otherwise we end up in a loop */
2055:
2056: umass_clear_endpoint_stall(sc,
2057: sc->bulkout, sc->bulkout_pipe, TSTATE_CBI_RESET3,
2058: sc->transfer_xfer[XFER_CBI_RESET3]);
2059:
2060: return;
2061: case TSTATE_CBI_RESET3:
2062: if (err) /* should not occur */
2063: printf("%s: CBI bulk-out stall clear failed, %s\n",
2064: USBDEVNAME(sc->sc_dev), usbd_errstr(err));
2065: /* no error recovery, otherwise we end up in a loop */
2066:
2067: sc->transfer_state = TSTATE_IDLE;
2068: if (sc->transfer_priv) {
2069: sc->transfer_cb(sc, sc->transfer_priv,
2070: sc->transfer_datalen,
2071: sc->transfer_status);
2072: }
2073:
2074: return;
2075:
2076:
2077: /***** Default *****/
2078: default:
2079: panic("%s: Unknown state %d",
2080: USBDEVNAME(sc->sc_dev), sc->transfer_state);
2081: }
2082: }
2083:
2084:
2085:
2086:
2087: /*
2088: * CAM specific functions (used by SCSI, UFI, 8070i (ATAPI))
2089: */
2090:
2091: Static int
2092: umass_cam_attach_sim(struct umass_softc *sc)
2093: {
2094: struct cam_devq *devq; /* Per device Queue */
2095:
2096: /* A HBA is attached to the CAM layer.
2097: *
2098: * The CAM layer will then after a while start probing for
2099: * devices on the bus. The number of SIMs is limited to one.
2100: */
2101:
2102: devq = cam_simq_alloc(1 /*maximum openings*/);
2103: if (devq == NULL)
2104: return(ENOMEM);
2105:
2106: sc->umass_sim = cam_sim_alloc(umass_cam_action, umass_cam_poll,
2107: DEVNAME_SIM,
2108: sc /*priv*/,
2109: USBDEVUNIT(sc->sc_dev) /*unit number*/,
2110: 1 /*maximum device openings*/,
2111: 0 /*maximum tagged device openings*/,
2112: devq);
2113: cam_simq_release(devq);
2114: if (sc->umass_sim == NULL)
2115: return(ENOMEM);
2116:
2117: /*
2118: * If we could not register the bus we must immediately free the
2119: * sim so we do not attempt to deregister a bus later on that we
2120: * had not registered.
2121: */
2122: if (xpt_bus_register(sc->umass_sim, USBDEVUNIT(sc->sc_dev)) !=
2123: CAM_SUCCESS) {
2124: cam_sim_free(sc->umass_sim);
2125: sc->umass_sim = NULL;
2126: return(ENOMEM);
2127: }
2128:
2129: return(0);
2130: }
2131:
2132: Static void
2133: umass_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb)
2134: {
2135: #ifdef USB_DEBUG
2136: if (ccb->ccb_h.status != CAM_REQ_CMP) {
2137: DPRINTF(UDMASS_SCSI, ("%s:%d Rescan failed, 0x%04x\n",
2138: periph->periph_name, periph->unit_number,
2139: ccb->ccb_h.status));
2140: } else {
2141: DPRINTF(UDMASS_SCSI, ("%s%d: Rescan succeeded\n",
2142: periph->periph_name, periph->unit_number));
2143: }
2144: #endif
2145:
2146: xpt_free_path(ccb->ccb_h.path);
2147: free(ccb, M_USBDEV);
2148: }
2149:
2150: Static void
2151: umass_cam_rescan(void *addr)
2152: {
2153: struct umass_softc *sc = (struct umass_softc *) addr;
2154: struct cam_path *path;
2155: union ccb *ccb;
2156:
2157: sc->rescan_timeout.callout = NULL;
2158: ccb = malloc(sizeof(union ccb), M_USBDEV, M_WAITOK|M_ZERO);
2159:
2160: DPRINTF(UDMASS_SCSI, ("scbus%d: scanning for %s:%d:%d:%d\n",
2161: cam_sim_path(sc->umass_sim),
2162: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2163: USBDEVUNIT(sc->sc_dev), CAM_LUN_WILDCARD));
2164:
2165: if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->umass_sim),
2166: CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)
2167: != CAM_REQ_CMP)
2168: return;
2169:
2170: xpt_setup_ccb(&ccb->ccb_h, path, 5/*priority (low)*/);
2171: ccb->ccb_h.func_code = XPT_SCAN_BUS;
2172: ccb->ccb_h.cbfcnp = umass_cam_rescan_callback;
2173: ccb->crcn.flags = CAM_FLAG_NONE;
2174: xpt_action(ccb);
2175:
2176: /* The scan is in progress now. */
2177: }
2178:
2179: Static int
2180: umass_cam_attach(struct umass_softc *sc)
2181: {
2182: #ifndef USB_DEBUG
2183: if (bootverbose)
2184: #endif
2185: printf("%s:%d:%d:%d: Attached to scbus%d\n",
2186: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2187: USBDEVUNIT(sc->sc_dev), CAM_LUN_WILDCARD,
2188: cam_sim_path(sc->umass_sim));
2189:
2190: if (!cold) {
2191: /*
2192: * Notify CAM of the new device after 1 second delay. Any
2193: * failure is benign, as the user can still do it by hand
2194: * (camcontrol rescan <busno>). Only do this if we are not
2195: * booting, because CAM does a scan after booting has
2196: * completed, when interrupts have been enabled.
2197: */
2198: sc->rescan_timeout =
2199: timeout(umass_cam_rescan, sc, MS_TO_TICKS(200));
2200: }
2201:
2202: return(0); /* always succesfull */
2203: }
2204:
2205: /* umass_cam_detach
2206: * detach from the CAM layer
2207: */
2208:
2209: Static int
2210: umass_cam_detach_sim(struct umass_softc *sc)
2211: {
2212: if (sc->rescan_timeout.callout) {
2213: untimeout(umass_cam_rescan, sc, sc->rescan_timeout);
2214: sc->rescan_timeout.callout = NULL;
2215: }
2216: if (sc->umass_sim) {
2217: if (xpt_bus_deregister(cam_sim_path(sc->umass_sim)))
2218: cam_sim_free(sc->umass_sim);
2219: else
2220: return(EBUSY);
2221:
2222: sc->umass_sim = NULL;
2223: }
2224:
2225: return(0);
2226: }
2227:
2228: /* umass_cam_action
2229: * CAM requests for action come through here
2230: */
2231:
2232: Static void
2233: umass_cam_action(struct cam_sim *sim, union ccb *ccb)
2234: {
2235: struct umass_softc *sc = (struct umass_softc *)sim->softc;
2236:
2237: /* The softc is still there, but marked as going away. umass_cam_detach
2238: * has not yet notified CAM of the lost device however.
2239: */
2240: if (sc && (sc->flags & UMASS_FLAGS_GONE)) {
2241: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
2242: "Invalid target (gone)\n",
2243: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2244: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2245: ccb->ccb_h.func_code));
2246: ccb->ccb_h.status = CAM_TID_INVALID;
2247: xpt_done(ccb);
2248: return;
2249: }
2250:
2251: /* Verify, depending on the operation to perform, that we either got a
2252: * valid sc, because an existing target was referenced, or otherwise
2253: * the SIM is addressed.
2254: *
2255: * This avoids bombing out at a printf and does give the CAM layer some
2256: * sensible feedback on errors.
2257: */
2258: switch (ccb->ccb_h.func_code) {
2259: case XPT_SCSI_IO:
2260: case XPT_RESET_DEV:
2261: case XPT_GET_TRAN_SETTINGS:
2262: case XPT_SET_TRAN_SETTINGS:
2263: case XPT_CALC_GEOMETRY:
2264: /* the opcodes requiring a target. These should never occur. */
2265: if (sc == NULL) {
2266: printf("%s:%d:%d:%d:func_code 0x%04x: "
2267: "Invalid target (target needed)\n",
2268: DEVNAME_SIM, cam_sim_path(sc->umass_sim),
2269: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2270: ccb->ccb_h.func_code);
2271:
2272: ccb->ccb_h.status = CAM_TID_INVALID;
2273: xpt_done(ccb);
2274: return;
2275: }
2276: break;
2277: case XPT_PATH_INQ:
2278: case XPT_NOOP:
2279: /* The opcodes sometimes aimed at a target (sc is valid),
2280: * sometimes aimed at the SIM (sc is invalid and target is
2281: * CAM_TARGET_WILDCARD)
2282: */
2283: if (sc == NULL && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) {
2284: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
2285: "Invalid target (no wildcard)\n",
2286: DEVNAME_SIM, cam_sim_path(sc->umass_sim),
2287: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2288: ccb->ccb_h.func_code));
2289:
2290: ccb->ccb_h.status = CAM_TID_INVALID;
2291: xpt_done(ccb);
2292: return;
2293: }
2294: break;
2295: default:
2296: /* XXX Hm, we should check the input parameters */
2297: break;
2298: }
2299:
2300: /* Perform the requested action */
2301: switch (ccb->ccb_h.func_code) {
2302: case XPT_SCSI_IO:
2303: {
2304: struct ccb_scsiio *csio = &ccb->csio; /* deref union */
2305: int dir;
2306: unsigned char *cmd;
2307: int cmdlen;
2308: unsigned char *rcmd;
2309: int rcmdlen;
2310:
2311: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: "
2312: "cmd: 0x%02x, flags: 0x%02x, "
2313: "%db cmd/%db data/%db sense\n",
2314: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2315: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2316: csio->cdb_io.cdb_bytes[0],
2317: ccb->ccb_h.flags & CAM_DIR_MASK,
2318: csio->cdb_len, csio->dxfer_len,
2319: csio->sense_len));
2320:
2321: /* clear the end of the buffer to make sure we don't send out
2322: * garbage.
2323: */
2324: DIF(UDMASS_SCSI, if ((ccb->ccb_h.flags & CAM_DIR_MASK)
2325: == CAM_DIR_OUT)
2326: umass_dump_buffer(sc, csio->data_ptr,
2327: csio->dxfer_len, 48));
2328:
2329: if (sc->transfer_state != TSTATE_IDLE) {
2330: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SCSI_IO: "
2331: "I/O in progress, deferring (state %d, %s)\n",
2332: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2333: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2334: sc->transfer_state,states[sc->transfer_state]));
2335: ccb->ccb_h.status = CAM_SCSI_BUSY;
2336: xpt_done(ccb);
2337: return;
2338: }
2339:
2340: switch(ccb->ccb_h.flags&CAM_DIR_MASK) {
2341: case CAM_DIR_IN:
2342: dir = DIR_IN;
2343: break;
2344: case CAM_DIR_OUT:
2345: dir = DIR_OUT;
2346: break;
2347: default:
2348: dir = DIR_NONE;
2349: }
2350:
2351: ccb->ccb_h.status = CAM_REQ_INPROG | CAM_SIM_QUEUED;
2352:
2353:
2354: if (csio->ccb_h.flags & CAM_CDB_POINTER) {
2355: cmd = (unsigned char *) csio->cdb_io.cdb_ptr;
2356: } else {
2357: cmd = (unsigned char *) &csio->cdb_io.cdb_bytes;
2358: }
2359: cmdlen = csio->cdb_len;
2360: rcmd = (unsigned char *) &sc->cam_scsi_command;
2361: rcmdlen = sizeof(sc->cam_scsi_command);
2362:
2363: /* sc->transform will convert the command to the command
2364: * (format) needed by the specific command set and return
2365: * the converted command in a buffer pointed to be rcmd.
2366: * We pass in a buffer, but if the command does not
2367: * have to be transformed it returns a ptr to the original
2368: * buffer (see umass_scsi_transform).
2369: */
2370:
2371: if (sc->transform(sc, cmd, cmdlen, &rcmd, &rcmdlen)) {
2372: /*
2373: * Handle EVPD inquiry for broken devices first
2374: * NO_INQUIRY also implies NO_INQUIRY_EVPD
2375: */
2376: if ((sc->quirks & (NO_INQUIRY_EVPD | NO_INQUIRY)) &&
2377: rcmd[0] == INQUIRY && (rcmd[1] & SI_EVPD)) {
2378: struct scsi_sense_data *sense;
2379:
2380: sense = &ccb->csio.sense_data;
2381: bzero(sense, sizeof(*sense));
2382: sense->error_code = SSD_CURRENT_ERROR;
2383: sense->flags = SSD_KEY_ILLEGAL_REQUEST;
2384: sense->add_sense_code = 0x24;
2385: sense->extra_len = 10;
2386: ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
2387: ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR |
2388: CAM_AUTOSNS_VALID;
2389: xpt_done(ccb);
2390: return;
2391: }
2392: /* Return fake inquiry data for broken devices */
2393: if ((sc->quirks & NO_INQUIRY) && rcmd[0] == INQUIRY) {
2394: struct ccb_scsiio *csio = &ccb->csio;
2395:
2396: memcpy(csio->data_ptr, &fake_inq_data,
2397: sizeof(fake_inq_data));
2398: csio->scsi_status = SCSI_STATUS_OK;
2399: ccb->ccb_h.status = CAM_REQ_CMP;
2400: xpt_done(ccb);
2401: return;
2402: }
2403: if ((sc->quirks & FORCE_SHORT_INQUIRY) &&
2404: rcmd[0] == INQUIRY) {
2405: csio->dxfer_len = SHORT_INQUIRY_LENGTH;
2406: }
2407: sc->transfer(sc, ccb->ccb_h.target_lun, rcmd, rcmdlen,
2408: csio->data_ptr,
2409: csio->dxfer_len, dir,
2410: umass_cam_cb, (void *) ccb);
2411: } else {
2412: ccb->ccb_h.status = CAM_REQ_INVALID;
2413: xpt_done(ccb);
2414: }
2415:
2416: break;
2417: }
2418: case XPT_PATH_INQ:
2419: {
2420: struct ccb_pathinq *cpi = &ccb->cpi;
2421:
2422: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_PATH_INQ:.\n",
2423: (sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
2424: cam_sim_path(sc->umass_sim),
2425: ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
2426:
2427: /* host specific information */
2428: cpi->version_num = 1;
2429: cpi->hba_inquiry = 0;
2430: cpi->target_sprt = 0;
2431: cpi->hba_misc = PIM_NO_6_BYTE;
2432: cpi->hba_eng_cnt = 0;
2433: cpi->max_target = UMASS_SCSIID_MAX; /* one target */
2434: cpi->initiator_id = UMASS_SCSIID_HOST;
2435: strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
2436: strncpy(cpi->hba_vid, "USB SCSI", HBA_IDLEN);
2437: strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
2438: cpi->unit_number = cam_sim_unit(sim);
2439: cpi->bus_id = USBDEVUNIT(sc->sc_dev);
2440:
2441: if (sc == NULL) {
2442: cpi->base_transfer_speed = 0;
2443: cpi->max_lun = 0;
2444: } else {
2445: if (sc->quirks & FLOPPY_SPEED) {
2446: cpi->base_transfer_speed = UMASS_FLOPPY_TRANSFER_SPEED;
2447: } else {
2448: cpi->base_transfer_speed = UMASS_DEFAULT_TRANSFER_SPEED;
2449: }
2450: cpi->max_lun = sc->maxlun;
2451: }
2452:
2453: cpi->ccb_h.status = CAM_REQ_CMP;
2454: xpt_done(ccb);
2455: break;
2456: }
2457: case XPT_RESET_DEV:
2458: {
2459: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_RESET_DEV:.\n",
2460: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2461: ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
2462:
2463: ccb->ccb_h.status = CAM_REQ_INPROG;
2464: umass_reset(sc, umass_cam_cb, (void *) ccb);
2465: break;
2466: }
2467: case XPT_GET_TRAN_SETTINGS:
2468: {
2469: struct ccb_trans_settings *cts = &ccb->cts;
2470:
2471: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_GET_TRAN_SETTINGS:.\n",
2472: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2473: ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
2474:
2475: cts->valid = 0;
2476: cts->flags = 0; /* no disconnection, tagging */
2477:
2478: ccb->ccb_h.status = CAM_REQ_CMP;
2479: xpt_done(ccb);
2480: break;
2481: }
2482: case XPT_SET_TRAN_SETTINGS:
2483: {
2484: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_SET_TRAN_SETTINGS:.\n",
2485: USBDEVNAME(sc->sc_dev), cam_sim_path(sc->umass_sim),
2486: ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
2487:
2488: ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
2489: xpt_done(ccb);
2490: break;
2491: }
2492: case XPT_CALC_GEOMETRY:
2493: {
2494: cam_calc_geometry(&ccb->ccg, /*extended*/1);
2495: xpt_done(ccb);
2496: break;
2497: }
2498: case XPT_NOOP:
2499: {
2500: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:XPT_NOOP:.\n",
2501: (sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
2502: cam_sim_path(sc->umass_sim),
2503: ccb->ccb_h.target_id, ccb->ccb_h.target_lun));
2504:
2505: ccb->ccb_h.status = CAM_REQ_CMP;
2506: xpt_done(ccb);
2507: break;
2508: }
2509: default:
2510: DPRINTF(UDMASS_SCSI, ("%s:%d:%d:%d:func_code 0x%04x: "
2511: "Not implemented\n",
2512: (sc == NULL? DEVNAME_SIM:USBDEVNAME(sc->sc_dev)),
2513: cam_sim_path(sc->umass_sim),
2514: ccb->ccb_h.target_id, ccb->ccb_h.target_lun,
2515: ccb->ccb_h.func_code));
2516:
2517: ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
2518: xpt_done(ccb);
2519: break;
2520: }
2521: }
2522:
2523: /* umass_cam_poll
2524: * all requests are handled through umass_cam_action, requests
2525: * are never pending. So, nothing to do here.
2526: */
2527: Static void
2528: umass_cam_poll(struct cam_sim *sim)
2529: {
2530: #ifdef USB_DEBUG
2531: struct umass_softc *sc = (struct umass_softc *) sim->softc;
2532:
2533: DPRINTF(UDMASS_SCSI, ("%s: CAM poll\n",
2534: USBDEVNAME(sc->sc_dev)));
2535: #endif
2536:
2537: /* nop */
2538: }
2539:
2540:
2541: /* umass_cam_cb
2542: * finalise a completed CAM command
2543: */
2544:
2545: Static void
2546: umass_cam_cb(struct umass_softc *sc, void *priv, int residue, int status)
2547: {
2548: union ccb *ccb = (union ccb *) priv;
2549: struct ccb_scsiio *csio = &ccb->csio; /* deref union */
2550:
2551: csio->resid = residue;
2552:
2553: switch (status) {
2554: case STATUS_CMD_OK:
2555: ccb->ccb_h.status = CAM_REQ_CMP;
2556: xpt_done(ccb);
2557: break;
2558:
2559: case STATUS_CMD_UNKNOWN:
2560: case STATUS_CMD_FAILED:
2561: switch (ccb->ccb_h.func_code) {
2562: case XPT_SCSI_IO:
2563: {
2564: unsigned char *rcmd;
2565: int rcmdlen;
2566:
2567: /* fetch sense data */
2568: /* the rest of the command was filled in at attach */
2569: sc->cam_scsi_sense.length = csio->sense_len;
2570:
2571: DPRINTF(UDMASS_SCSI,("%s: Fetching %db sense data\n",
2572: USBDEVNAME(sc->sc_dev), csio->sense_len));
2573:
2574: rcmd = (unsigned char *) &sc->cam_scsi_command;
2575: rcmdlen = sizeof(sc->cam_scsi_command);
2576:
2577: if (sc->transform(sc,
2578: (unsigned char *) &sc->cam_scsi_sense,
2579: sizeof(sc->cam_scsi_sense),
2580: &rcmd, &rcmdlen)) {
2581: if ((sc->quirks & FORCE_SHORT_INQUIRY) && (rcmd[0] == INQUIRY)) {
2582: csio->sense_len = SHORT_INQUIRY_LENGTH;
2583: }
2584: sc->transfer(sc, ccb->ccb_h.target_lun,
2585: rcmd, rcmdlen,
2586: &csio->sense_data,
2587: csio->sense_len, DIR_IN,
2588: umass_cam_sense_cb, (void *) ccb);
2589: } else {
2590: panic("transform(REQUEST_SENSE) failed");
2591: }
2592: break;
2593: }
2594: case XPT_RESET_DEV: /* Reset failed */
2595: ccb->ccb_h.status = CAM_REQ_CMP_ERR;
2596: xpt_done(ccb);
2597: break;
2598: default:
2599: panic("umass_cam_cb called for func_code %d",
2600: ccb->ccb_h.func_code);
2601: }
2602: break;
2603:
2604: case STATUS_WIRE_FAILED:
2605: /* the wire protocol failed and will have recovered
2606: * (hopefully). We return an error to CAM and let CAM retry
2607: * the command if necessary.
2608: */
2609: ccb->ccb_h.status = CAM_REQ_CMP_ERR;
2610: xpt_done(ccb);
2611: break;
2612: default:
2613: panic("%s: Unknown status %d in umass_cam_cb",
2614: USBDEVNAME(sc->sc_dev), status);
2615: }
2616: }
2617:
2618: /* Finalise a completed autosense operation
2619: */
2620: Static void
2621: umass_cam_sense_cb(struct umass_softc *sc, void *priv, int residue, int status)
2622: {
2623: union ccb *ccb = (union ccb *) priv;
2624: struct ccb_scsiio *csio = &ccb->csio; /* deref union */
2625: unsigned char *rcmd;
2626: int rcmdlen;
2627:
2628: switch (status) {
2629: case STATUS_CMD_OK:
2630: case STATUS_CMD_UNKNOWN:
2631: case STATUS_CMD_FAILED:
2632: /* Getting sense data always succeeds (apart from wire
2633: * failures).
2634: */
2635: if ((sc->quirks & RS_NO_CLEAR_UA)
2636: && csio->cdb_io.cdb_bytes[0] == INQUIRY
2637: && (csio->sense_data.flags & SSD_KEY)
2638: == SSD_KEY_UNIT_ATTENTION) {
2639: /* Ignore unit attention errors in the case where
2640: * the Unit Attention state is not cleared on
2641: * REQUEST SENSE. They will appear again at the next
2642: * command.
2643: */
2644: ccb->ccb_h.status = CAM_REQ_CMP;
2645: } else if ((csio->sense_data.flags & SSD_KEY)
2646: == SSD_KEY_NO_SENSE) {
2647: /* No problem after all (in the case of CBI without
2648: * CCI)
2649: */
2650: ccb->ccb_h.status = CAM_REQ_CMP;
2651: } else if ((sc->quirks & RS_NO_CLEAR_UA) &&
2652: (csio->cdb_io.cdb_bytes[0] == READ_CAPACITY) &&
2653: ((csio->sense_data.flags & SSD_KEY)
2654: == SSD_KEY_UNIT_ATTENTION)) {
2655: /*
2656: * Some devices do not clear the unit attention error
2657: * on request sense. We insert a test unit ready
2658: * command to make sure we clear the unit attention
2659: * condition, then allow the retry to proceed as
2660: * usual.
2661: */
2662:
2663: ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
2664: | CAM_AUTOSNS_VALID;
2665: csio->scsi_status = SCSI_STATUS_CHECK_COND;
2666:
2667: #if 0
2668: DELAY(300000);
2669: #endif
2670:
2671: DPRINTF(UDMASS_SCSI,("%s: Doing a sneaky"
2672: "TEST_UNIT_READY\n",
2673: USBDEVNAME(sc->sc_dev)));
2674:
2675: /* the rest of the command was filled in at attach */
2676:
2677: rcmd = (unsigned char *) &sc->cam_scsi_command2;
2678: rcmdlen = sizeof(sc->cam_scsi_command2);
2679:
2680: if (sc->transform(sc,
2681: (unsigned char *)
2682: &sc->cam_scsi_test_unit_ready,
2683: sizeof(sc->cam_scsi_test_unit_ready),
2684: &rcmd, &rcmdlen)) {
2685: sc->transfer(sc, ccb->ccb_h.target_lun,
2686: rcmd, rcmdlen,
2687: NULL, 0, DIR_NONE,
2688: umass_cam_quirk_cb, (void *) ccb);
2689: } else {
2690: panic("transform(TEST_UNIT_READY) failed");
2691: }
2692: break;
2693: } else {
2694: ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
2695: | CAM_AUTOSNS_VALID;
2696: csio->scsi_status = SCSI_STATUS_CHECK_COND;
2697: }
2698: xpt_done(ccb);
2699: break;
2700:
2701: default:
2702: DPRINTF(UDMASS_SCSI, ("%s: Autosense failed, status %d\n",
2703: USBDEVNAME(sc->sc_dev), status));
2704: ccb->ccb_h.status = CAM_AUTOSENSE_FAIL;
2705: xpt_done(ccb);
2706: }
2707: }
2708:
2709: /*
2710: * This completion code just handles the fact that we sent a test-unit-ready
2711: * after having previously failed a READ CAPACITY with CHECK_COND. Even
2712: * though this command succeeded, we have to tell CAM to retry.
2713: */
2714: Static void
2715: umass_cam_quirk_cb(struct umass_softc *sc, void *priv, int residue, int status)
2716: {
2717: union ccb *ccb = (union ccb *) priv;
2718:
2719: DPRINTF(UDMASS_SCSI, ("%s: Test unit ready returned status %d\n",
2720: USBDEVNAME(sc->sc_dev), status));
2721: #if 0
2722: ccb->ccb_h.status = CAM_REQ_CMP;
2723: #endif
2724: ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR
2725: | CAM_AUTOSNS_VALID;
2726: ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
2727: xpt_done(ccb);
2728: }
2729:
2730: Static int
2731: umass_driver_load(module_t mod, int what, void *arg)
2732: {
2733: switch (what) {
2734: case MOD_UNLOAD:
2735: case MOD_LOAD:
2736: default:
2737: return(usbd_driver_load(mod, what, arg));
2738: }
2739: }
2740:
2741: /*
2742: * SCSI specific functions
2743: */
2744:
2745: Static int
2746: umass_scsi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
2747: unsigned char **rcmd, int *rcmdlen)
2748: {
2749: switch (cmd[0]) {
2750: case TEST_UNIT_READY:
2751: if (sc->quirks & NO_TEST_UNIT_READY) {
2752: KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit),
2753: ("rcmdlen = %d < %ld, buffer too small",
2754: *rcmdlen,
2755: (long)sizeof(struct scsi_start_stop_unit)));
2756: DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY "
2757: "to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
2758: memset(*rcmd, 0, *rcmdlen);
2759: (*rcmd)[0] = START_STOP_UNIT;
2760: (*rcmd)[4] = SSS_START;
2761: return 1;
2762: }
2763: /* fallthrough */
2764: case INQUIRY:
2765: /* some drives wedge when asked for full inquiry information. */
2766: if (sc->quirks & FORCE_SHORT_INQUIRY) {
2767: memcpy(*rcmd, cmd, cmdlen);
2768: *rcmdlen = cmdlen;
2769: (*rcmd)[4] = SHORT_INQUIRY_LENGTH;
2770: return 1;
2771: }
2772: /* fallthrough */
2773: default:
2774: *rcmd = cmd; /* We don't need to copy it */
2775: *rcmdlen = cmdlen;
2776: }
2777:
2778: return 1;
2779: }
2780: /* RBC specific functions */
2781: Static int
2782: umass_rbc_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
2783: unsigned char **rcmd, int *rcmdlen)
2784: {
2785: switch (cmd[0]) {
2786: /* these commands are defined in RBC: */
2787: case READ_10:
2788: case READ_CAPACITY:
2789: case START_STOP_UNIT:
2790: case SYNCHRONIZE_CACHE:
2791: case WRITE_10:
2792: case 0x2f: /* VERIFY_10 is absent from scsi_all.h??? */
2793: case INQUIRY:
2794: case MODE_SELECT_10:
2795: case MODE_SENSE_10:
2796: case TEST_UNIT_READY:
2797: case WRITE_BUFFER:
2798: /* The following commands are not listed in my copy of the RBC specs.
2799: * CAM however seems to want those, and at least the Sony DSC device
2800: * appears to support those as well */
2801: case REQUEST_SENSE:
2802: case PREVENT_ALLOW:
2803: *rcmd = cmd; /* We don't need to copy it */
2804: *rcmdlen = cmdlen;
2805: return 1;
2806: /* All other commands are not legal in RBC */
2807: default:
2808: printf("%s: Unsupported RBC command 0x%02x",
2809: USBDEVNAME(sc->sc_dev), cmd[0]);
2810: printf("\n");
2811: return 0; /* failure */
2812: }
2813: }
2814:
2815: /*
2816: * UFI specific functions
2817: */
2818: Static int
2819: umass_ufi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
2820: unsigned char **rcmd, int *rcmdlen)
2821: {
2822: /* A UFI command is always 12 bytes in length */
2823: KASSERT(*rcmdlen >= UFI_COMMAND_LENGTH,
2824: ("rcmdlen = %d < %d, buffer too small",
2825: *rcmdlen, UFI_COMMAND_LENGTH));
2826:
2827: *rcmdlen = UFI_COMMAND_LENGTH;
2828: memset(*rcmd, 0, UFI_COMMAND_LENGTH);
2829:
2830: switch (cmd[0]) {
2831: /* Commands of which the format has been verified. They should work.
2832: * Copy the command into the (zeroed out) destination buffer.
2833: */
2834: case TEST_UNIT_READY:
2835: if (sc->quirks & NO_TEST_UNIT_READY) {
2836: /* Some devices do not support this command.
2837: * Start Stop Unit should give the same results
2838: */
2839: DPRINTF(UDMASS_UFI, ("%s: Converted TEST_UNIT_READY "
2840: "to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
2841: (*rcmd)[0] = START_STOP_UNIT;
2842: (*rcmd)[4] = SSS_START;
2843: } else {
2844: memcpy(*rcmd, cmd, cmdlen);
2845: }
2846: return 1;
2847:
2848: case REZERO_UNIT:
2849: case REQUEST_SENSE:
2850: case INQUIRY:
2851: case START_STOP_UNIT:
2852: case SEND_DIAGNOSTIC:
2853: case PREVENT_ALLOW:
2854: case READ_CAPACITY:
2855: case READ_10:
2856: case WRITE_10:
2857: case POSITION_TO_ELEMENT: /* SEEK_10 */
2858: case MODE_SELECT_10:
2859: case MODE_SENSE_10:
2860: case READ_12:
2861: case WRITE_12:
2862: memcpy(*rcmd, cmd, cmdlen);
2863: return 1;
2864:
2865: /* Other UFI commands: FORMAT_UNIT, READ_FORMAT_CAPACITY,
2866: * VERIFY, WRITE_AND_VERIFY.
2867: * These should be checked whether they somehow can be made to fit.
2868: */
2869:
2870: default:
2871: printf("%s: Unsupported UFI command 0x%02x\n",
2872: USBDEVNAME(sc->sc_dev), cmd[0]);
2873: return 0; /* failure */
2874: }
2875: }
2876:
2877: /*
2878: * 8070i (ATAPI) specific functions
2879: */
2880: Static int
2881: umass_atapi_transform(struct umass_softc *sc, unsigned char *cmd, int cmdlen,
2882: unsigned char **rcmd, int *rcmdlen)
2883: {
2884: /* An ATAPI command is always 12 bytes in length. */
2885: KASSERT(*rcmdlen >= ATAPI_COMMAND_LENGTH,
2886: ("rcmdlen = %d < %d, buffer too small",
2887: *rcmdlen, ATAPI_COMMAND_LENGTH));
2888:
2889: *rcmdlen = ATAPI_COMMAND_LENGTH;
2890: memset(*rcmd, 0, ATAPI_COMMAND_LENGTH);
2891:
2892: switch (cmd[0]) {
2893: /* Commands of which the format has been verified. They should work.
2894: * Copy the command into the (zeroed out) destination buffer.
2895: */
2896: case INQUIRY:
2897: memcpy(*rcmd, cmd, cmdlen);
2898: /* some drives wedge when asked for full inquiry information. */
2899: if (sc->quirks & FORCE_SHORT_INQUIRY)
2900: (*rcmd)[4] = SHORT_INQUIRY_LENGTH;
2901: return 1;
2902:
2903: case TEST_UNIT_READY:
2904: if (sc->quirks & NO_TEST_UNIT_READY) {
2905: KASSERT(*rcmdlen >= sizeof(struct scsi_start_stop_unit),
2906: ("rcmdlen = %d < %ld, buffer too small",
2907: *rcmdlen,
2908: (long)sizeof(struct scsi_start_stop_unit)));
2909: DPRINTF(UDMASS_SCSI, ("%s: Converted TEST_UNIT_READY "
2910: "to START_UNIT\n", USBDEVNAME(sc->sc_dev)));
2911: memset(*rcmd, 0, *rcmdlen);
2912: (*rcmd)[0] = START_STOP_UNIT;
2913: (*rcmd)[4] = SSS_START;
2914: return 1;
2915: }
2916: /* fallthrough */
2917: case REZERO_UNIT:
2918: case REQUEST_SENSE:
2919: case START_STOP_UNIT:
2920: case SEND_DIAGNOSTIC:
2921: case PREVENT_ALLOW:
2922: case READ_CAPACITY:
2923: case READ_10:
2924: case WRITE_10:
2925: case POSITION_TO_ELEMENT: /* SEEK_10 */
2926: case SYNCHRONIZE_CACHE:
2927: case MODE_SELECT_10:
2928: case MODE_SENSE_10:
2929: memcpy(*rcmd, cmd, cmdlen);
2930: return 1;
2931:
2932: case READ_12:
2933: case WRITE_12:
2934: default:
2935: printf("%s: Unsupported ATAPI command 0x%02x\n",
2936: USBDEVNAME(sc->sc_dev), cmd[0]);
2937: return 0; /* failure */
2938: }
2939: }
2940:
2941:
2942: /* (even the comment is missing) */
2943:
2944: DRIVER_MODULE(umass, uhub, umass_driver, umass_devclass, umass_driver_load, 0);
2945:
2946:
2947:
2948: #ifdef USB_DEBUG
2949: Static void
2950: umass_bbb_dump_cbw(struct umass_softc *sc, umass_bbb_cbw_t *cbw)
2951: {
2952: int clen = cbw->bCDBLength;
2953: int dlen = UGETDW(cbw->dCBWDataTransferLength);
2954: u_int8_t *c = cbw->CBWCDB;
2955: int tag = UGETDW(cbw->dCBWTag);
2956: int flags = cbw->bCBWFlags;
2957:
2958: DPRINTF(UDMASS_BBB, ("%s: CBW %d: cmd = %db "
2959: "(0x%02x%02x%02x%02x%02x%02x%s), "
2960: "data = %db, dir = %s\n",
2961: USBDEVNAME(sc->sc_dev), tag, clen,
2962: c[0], c[1], c[2], c[3], c[4], c[5], (clen > 6? "...":""),
2963: dlen, (flags == CBWFLAGS_IN? "in":
2964: (flags == CBWFLAGS_OUT? "out":"<invalid>"))));
2965: }
2966:
2967: Static void
2968: umass_bbb_dump_csw(struct umass_softc *sc, umass_bbb_csw_t *csw)
2969: {
2970: int sig = UGETDW(csw->dCSWSignature);
2971: int tag = UGETW(csw->dCSWTag);
2972: int res = UGETDW(csw->dCSWDataResidue);
2973: int status = csw->bCSWStatus;
2974:
2975: DPRINTF(UDMASS_BBB, ("%s: CSW %d: sig = 0x%08x (%s), tag = %d, "
2976: "res = %d, status = 0x%02x (%s)\n", USBDEVNAME(sc->sc_dev),
2977: tag, sig, (sig == CSWSIGNATURE? "valid":"invalid"),
2978: tag, res,
2979: status, (status == CSWSTATUS_GOOD? "good":
2980: (status == CSWSTATUS_FAILED? "failed":
2981: (status == CSWSTATUS_PHASE? "phase":"<invalid>")))));
2982: }
2983:
2984: Static void
2985: umass_cbi_dump_cmd(struct umass_softc *sc, void *cmd, int cmdlen)
2986: {
2987: u_int8_t *c = cmd;
2988: int dir = sc->transfer_dir;
2989:
2990: DPRINTF(UDMASS_BBB, ("%s: cmd = %db "
2991: "(0x%02x%02x%02x%02x%02x%02x%s), "
2992: "data = %db, dir = %s\n",
2993: USBDEVNAME(sc->sc_dev), cmdlen,
2994: c[0], c[1], c[2], c[3], c[4], c[5], (cmdlen > 6? "...":""),
2995: sc->transfer_datalen,
2996: (dir == DIR_IN? "in":
2997: (dir == DIR_OUT? "out":
2998: (dir == DIR_NONE? "no data phase": "<invalid>")))));
2999: }
3000:
3001: Static void
3002: umass_dump_buffer(struct umass_softc *sc, u_int8_t *buffer, int buflen,
3003: int printlen)
3004: {
3005: int i, j;
3006: char s1[40];
3007: char s2[40];
3008: char s3[5];
3009:
3010: s1[0] = '\0';
3011: s3[0] = '\0';
3012:
3013: sprintf(s2, " buffer=%p, buflen=%d", buffer, buflen);
3014: for (i = 0; i < buflen && i < printlen; i++) {
3015: j = i % 16;
3016: if (j == 0 && i != 0) {
3017: DPRINTF(UDMASS_GEN, ("%s: 0x %s%s\n",
3018: USBDEVNAME(sc->sc_dev), s1, s2));
3019: s2[0] = '\0';
3020: }
3021: sprintf(&s1[j*2], "%02x", buffer[i] & 0xff);
3022: }
3023: if (buflen > printlen)
3024: sprintf(s3, " ...");
3025: DPRINTF(UDMASS_GEN, ("%s: 0x %s%s%s\n",
3026: USBDEVNAME(sc->sc_dev), s1, s2, s3));
3027: }
3028: #endif
![[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 [DragonFly] / src / sys / dev / usbmisc / umass