source: rtems-libbsd/freebsd/sys/dev/usb/usb_msctest.c @ 3d1e767

55-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since 3d1e767 was 3d1e767, checked in by Sebastian Huber <sebastian.huber@…>, on 04/27/16 at 08:25:22

Directly use <sys/types.h> provided by Newlib
  • Property mode set to 100644
File size: 27.1 KB
Line 
1#include <machine/rtems-bsd-kernel-space.h>
2
3/* $FreeBSD$ */
4/*-
5 * Copyright (c) 2008,2011 Hans Petter Selasky. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29/*
30 * The following file contains code that will detect USB autoinstall
31 * disks.
32 *
33 * TODO: Potentially we could add code to automatically detect USB
34 * mass storage quirks for not supported SCSI commands!
35 */
36
37#ifdef USB_GLOBAL_INCLUDE_FILE
38#include USB_GLOBAL_INCLUDE_FILE
39#else
40#include <sys/stdint.h>
41#include <sys/stddef.h>
42#include <rtems/bsd/sys/param.h>
43#include <sys/queue.h>
44#include <sys/types.h>
45#include <sys/systm.h>
46#include <sys/kernel.h>
47#include <sys/bus.h>
48#include <sys/module.h>
49#include <rtems/bsd/sys/lock.h>
50#include <sys/mutex.h>
51#include <sys/condvar.h>
52#include <sys/sysctl.h>
53#include <sys/sx.h>
54#include <rtems/bsd/sys/unistd.h>
55#include <sys/callout.h>
56#include <sys/malloc.h>
57#include <sys/priv.h>
58
59#include <dev/usb/usb.h>
60#include <dev/usb/usbdi.h>
61#include <dev/usb/usbdi_util.h>
62
63#define USB_DEBUG_VAR usb_debug
64
65#include <dev/usb/usb_busdma.h>
66#include <dev/usb/usb_process.h>
67#include <dev/usb/usb_transfer.h>
68#include <dev/usb/usb_msctest.h>
69#include <dev/usb/usb_debug.h>
70#include <dev/usb/usb_device.h>
71#include <dev/usb/usb_request.h>
72#include <dev/usb/usb_util.h>
73#include <dev/usb/quirk/usb_quirk.h>
74#endif                  /* USB_GLOBAL_INCLUDE_FILE */
75
76enum {
77        ST_COMMAND,
78        ST_DATA_RD,
79        ST_DATA_RD_CS,
80        ST_DATA_WR,
81        ST_DATA_WR_CS,
82        ST_STATUS,
83        ST_MAX,
84};
85
86enum {
87        DIR_IN,
88        DIR_OUT,
89        DIR_NONE,
90};
91
92#define SCSI_MAX_LEN    MAX(SCSI_FIXED_BLOCK_SIZE, USB_MSCTEST_BULK_SIZE)
93#define SCSI_INQ_LEN    0x24
94#define SCSI_SENSE_LEN  0xFF
95#define SCSI_FIXED_BLOCK_SIZE 512       /* bytes */
96
97static uint8_t scsi_test_unit_ready[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
98static uint8_t scsi_inquiry[] = { 0x12, 0x00, 0x00, 0x00, SCSI_INQ_LEN, 0x00 };
99static uint8_t scsi_rezero_init[] =     { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
100static uint8_t scsi_start_stop_unit[] = { 0x1b, 0x00, 0x00, 0x00, 0x02, 0x00 };
101static uint8_t scsi_ztestor_eject[] =   { 0x85, 0x01, 0x01, 0x01, 0x18, 0x01,
102                                          0x01, 0x01, 0x01, 0x01, 0x00, 0x00 };
103static uint8_t scsi_cmotech_eject[] =   { 0xff, 0x52, 0x44, 0x45, 0x56, 0x43,
104                                          0x48, 0x47 };
105static uint8_t scsi_huawei_eject[] =    { 0x11, 0x06, 0x00, 0x00, 0x00, 0x00,
106                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107                                          0x00, 0x00, 0x00, 0x00 };
108static uint8_t scsi_huawei_eject2[] =   { 0x11, 0x06, 0x20, 0x00, 0x00, 0x01,
109                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
110                                          0x00, 0x00, 0x00, 0x00 };
111static uint8_t scsi_tct_eject[] =       { 0x06, 0xf5, 0x04, 0x02, 0x52, 0x70 };
112static uint8_t scsi_sync_cache[] =      { 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
113                                          0x00, 0x00, 0x00, 0x00 };
114static uint8_t scsi_request_sense[] =   { 0x03, 0x00, 0x00, 0x00, 0x12, 0x00,
115                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
116static uint8_t scsi_read_capacity[] =   { 0x25, 0x00, 0x00, 0x00, 0x00, 0x00,
117                                          0x00, 0x00, 0x00, 0x00 };
118static uint8_t scsi_prevent_removal[] = { 0x1e, 0, 0, 0, 1, 0 };
119static uint8_t scsi_allow_removal[] =   { 0x1e, 0, 0, 0, 0, 0 };
120
121#ifndef USB_MSCTEST_BULK_SIZE
122#define USB_MSCTEST_BULK_SIZE   64      /* dummy */
123#endif
124
125#define ERR_CSW_FAILED          -1
126
127/* Command Block Wrapper */
128struct bbb_cbw {
129        uDWord  dCBWSignature;
130#define CBWSIGNATURE    0x43425355
131        uDWord  dCBWTag;
132        uDWord  dCBWDataTransferLength;
133        uByte   bCBWFlags;
134#define CBWFLAGS_OUT    0x00
135#define CBWFLAGS_IN     0x80
136        uByte   bCBWLUN;
137        uByte   bCDBLength;
138#define CBWCDBLENGTH    16
139        uByte   CBWCDB[CBWCDBLENGTH];
140} __packed;
141
142/* Command Status Wrapper */
143struct bbb_csw {
144        uDWord  dCSWSignature;
145#define CSWSIGNATURE    0x53425355
146        uDWord  dCSWTag;
147        uDWord  dCSWDataResidue;
148        uByte   bCSWStatus;
149#define CSWSTATUS_GOOD  0x0
150#define CSWSTATUS_FAILED        0x1
151#define CSWSTATUS_PHASE 0x2
152} __packed;
153
154struct bbb_transfer {
155        struct mtx mtx;
156        struct cv cv;
157        struct bbb_cbw *cbw;
158        struct bbb_csw *csw;
159
160        struct usb_xfer *xfer[ST_MAX];
161
162        uint8_t *data_ptr;
163
164        usb_size_t data_len;            /* bytes */
165        usb_size_t data_rem;            /* bytes */
166        usb_timeout_t data_timeout;     /* ms */
167        usb_frlength_t actlen;          /* bytes */
168        usb_frlength_t buffer_size;     /* bytes */
169
170        uint8_t cmd_len;                /* bytes */
171        uint8_t dir;
172        uint8_t lun;
173        uint8_t state;
174        uint8_t status_try;
175        int     error;
176
177        uint8_t *buffer;
178};
179
180static usb_callback_t bbb_command_callback;
181static usb_callback_t bbb_data_read_callback;
182static usb_callback_t bbb_data_rd_cs_callback;
183static usb_callback_t bbb_data_write_callback;
184static usb_callback_t bbb_data_wr_cs_callback;
185static usb_callback_t bbb_status_callback;
186static usb_callback_t bbb_raw_write_callback;
187
188static void     bbb_done(struct bbb_transfer *, int);
189static void     bbb_transfer_start(struct bbb_transfer *, uint8_t);
190static void     bbb_data_clear_stall_callback(struct usb_xfer *, uint8_t,
191                    uint8_t);
192static int      bbb_command_start(struct bbb_transfer *, uint8_t, uint8_t,
193                    void *, size_t, void *, size_t, usb_timeout_t);
194static struct bbb_transfer *bbb_attach(struct usb_device *, uint8_t, uint8_t);
195static void     bbb_detach(struct bbb_transfer *);
196
197static const struct usb_config bbb_config[ST_MAX] = {
198
199        [ST_COMMAND] = {
200                .type = UE_BULK,
201                .endpoint = UE_ADDR_ANY,
202                .direction = UE_DIR_OUT,
203                .bufsize = sizeof(struct bbb_cbw),
204                .callback = &bbb_command_callback,
205                .timeout = 4 * USB_MS_HZ,       /* 4 seconds */
206        },
207
208        [ST_DATA_RD] = {
209                .type = UE_BULK,
210                .endpoint = UE_ADDR_ANY,
211                .direction = UE_DIR_IN,
212                .bufsize = SCSI_MAX_LEN,
213                .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
214                .callback = &bbb_data_read_callback,
215                .timeout = 4 * USB_MS_HZ,       /* 4 seconds */
216        },
217
218        [ST_DATA_RD_CS] = {
219                .type = UE_CONTROL,
220                .endpoint = 0x00,       /* Control pipe */
221                .direction = UE_DIR_ANY,
222                .bufsize = sizeof(struct usb_device_request),
223                .callback = &bbb_data_rd_cs_callback,
224                .timeout = 1 * USB_MS_HZ,       /* 1 second  */
225        },
226
227        [ST_DATA_WR] = {
228                .type = UE_BULK,
229                .endpoint = UE_ADDR_ANY,
230                .direction = UE_DIR_OUT,
231                .bufsize = SCSI_MAX_LEN,
232                .flags = {.ext_buffer = 1,.proxy_buffer = 1,},
233                .callback = &bbb_data_write_callback,
234                .timeout = 4 * USB_MS_HZ,       /* 4 seconds */
235        },
236
237        [ST_DATA_WR_CS] = {
238                .type = UE_CONTROL,
239                .endpoint = 0x00,       /* Control pipe */
240                .direction = UE_DIR_ANY,
241                .bufsize = sizeof(struct usb_device_request),
242                .callback = &bbb_data_wr_cs_callback,
243                .timeout = 1 * USB_MS_HZ,       /* 1 second  */
244        },
245
246        [ST_STATUS] = {
247                .type = UE_BULK,
248                .endpoint = UE_ADDR_ANY,
249                .direction = UE_DIR_IN,
250                .bufsize = sizeof(struct bbb_csw),
251                .flags = {.short_xfer_ok = 1,},
252                .callback = &bbb_status_callback,
253                .timeout = 1 * USB_MS_HZ,       /* 1 second  */
254        },
255};
256
257static const struct usb_config bbb_raw_config[1] = {
258
259        [0] = {
260                .type = UE_BULK_INTR,
261                .endpoint = UE_ADDR_ANY,
262                .direction = UE_DIR_OUT,
263                .bufsize = SCSI_MAX_LEN,
264                .flags = {.ext_buffer = 1,.proxy_buffer = 1,},
265                .callback = &bbb_raw_write_callback,
266                .timeout = 1 * USB_MS_HZ,       /* 1 second */
267        },
268};
269
270static void
271bbb_done(struct bbb_transfer *sc, int error)
272{
273        sc->error = error;
274        sc->state = ST_COMMAND;
275        sc->status_try = 1;
276        cv_signal(&sc->cv);
277}
278
279static void
280bbb_transfer_start(struct bbb_transfer *sc, uint8_t xfer_index)
281{
282        sc->state = xfer_index;
283        usbd_transfer_start(sc->xfer[xfer_index]);
284}
285
286static void
287bbb_data_clear_stall_callback(struct usb_xfer *xfer,
288    uint8_t next_xfer, uint8_t stall_xfer)
289{
290        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
291
292        if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
293                switch (USB_GET_STATE(xfer)) {
294                case USB_ST_SETUP:
295                case USB_ST_TRANSFERRED:
296                        bbb_transfer_start(sc, next_xfer);
297                        break;
298                default:
299                        bbb_done(sc, USB_ERR_STALLED);
300                        break;
301                }
302        }
303}
304
305static void
306bbb_command_callback(struct usb_xfer *xfer, usb_error_t error)
307{
308        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
309        uint32_t tag;
310
311        switch (USB_GET_STATE(xfer)) {
312        case USB_ST_TRANSFERRED:
313                bbb_transfer_start
314                    (sc, ((sc->dir == DIR_IN) ? ST_DATA_RD :
315                    (sc->dir == DIR_OUT) ? ST_DATA_WR :
316                    ST_STATUS));
317                break;
318
319        case USB_ST_SETUP:
320                sc->status_try = 0;
321                tag = UGETDW(sc->cbw->dCBWTag) + 1;
322                USETDW(sc->cbw->dCBWSignature, CBWSIGNATURE);
323                USETDW(sc->cbw->dCBWTag, tag);
324                USETDW(sc->cbw->dCBWDataTransferLength, (uint32_t)sc->data_len);
325                sc->cbw->bCBWFlags = ((sc->dir == DIR_IN) ? CBWFLAGS_IN : CBWFLAGS_OUT);
326                sc->cbw->bCBWLUN = sc->lun;
327                sc->cbw->bCDBLength = sc->cmd_len;
328                if (sc->cbw->bCDBLength > sizeof(sc->cbw->CBWCDB)) {
329                        sc->cbw->bCDBLength = sizeof(sc->cbw->CBWCDB);
330                        DPRINTFN(0, "Truncating long command\n");
331                }
332                usbd_xfer_set_frame_len(xfer, 0,
333                    sizeof(struct bbb_cbw));
334                usbd_transfer_submit(xfer);
335                break;
336
337        default:                        /* Error */
338                bbb_done(sc, error);
339                break;
340        }
341}
342
343static void
344bbb_data_read_callback(struct usb_xfer *xfer, usb_error_t error)
345{
346        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
347        usb_frlength_t max_bulk = usbd_xfer_max_len(xfer);
348        int actlen, sumlen;
349
350        usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
351
352        switch (USB_GET_STATE(xfer)) {
353        case USB_ST_TRANSFERRED:
354                sc->data_rem -= actlen;
355                sc->data_ptr += actlen;
356                sc->actlen += actlen;
357
358                if (actlen < sumlen) {
359                        /* short transfer */
360                        sc->data_rem = 0;
361                }
362        case USB_ST_SETUP:
363                DPRINTF("max_bulk=%d, data_rem=%d\n",
364                    max_bulk, sc->data_rem);
365
366                if (sc->data_rem == 0) {
367                        bbb_transfer_start(sc, ST_STATUS);
368                        break;
369                }
370                if (max_bulk > sc->data_rem) {
371                        max_bulk = sc->data_rem;
372                }
373                usbd_xfer_set_timeout(xfer, sc->data_timeout);
374                usbd_xfer_set_frame_data(xfer, 0, sc->data_ptr, max_bulk);
375                usbd_transfer_submit(xfer);
376                break;
377
378        default:                        /* Error */
379                if (error == USB_ERR_CANCELLED) {
380                        bbb_done(sc, error);
381                } else {
382                        bbb_transfer_start(sc, ST_DATA_RD_CS);
383                }
384                break;
385        }
386}
387
388static void
389bbb_data_rd_cs_callback(struct usb_xfer *xfer, usb_error_t error)
390{
391        bbb_data_clear_stall_callback(xfer, ST_STATUS,
392            ST_DATA_RD);
393}
394
395static void
396bbb_data_write_callback(struct usb_xfer *xfer, usb_error_t error)
397{
398        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
399        usb_frlength_t max_bulk = usbd_xfer_max_len(xfer);
400        int actlen, sumlen;
401
402        usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
403
404        switch (USB_GET_STATE(xfer)) {
405        case USB_ST_TRANSFERRED:
406                sc->data_rem -= actlen;
407                sc->data_ptr += actlen;
408                sc->actlen += actlen;
409
410                if (actlen < sumlen) {
411                        /* short transfer */
412                        sc->data_rem = 0;
413                }
414        case USB_ST_SETUP:
415                DPRINTF("max_bulk=%d, data_rem=%d\n",
416                    max_bulk, sc->data_rem);
417
418                if (sc->data_rem == 0) {
419                        bbb_transfer_start(sc, ST_STATUS);
420                        break;
421                }
422                if (max_bulk > sc->data_rem) {
423                        max_bulk = sc->data_rem;
424                }
425                usbd_xfer_set_timeout(xfer, sc->data_timeout);
426                usbd_xfer_set_frame_data(xfer, 0, sc->data_ptr, max_bulk);
427                usbd_transfer_submit(xfer);
428                break;
429
430        default:                        /* Error */
431                if (error == USB_ERR_CANCELLED) {
432                        bbb_done(sc, error);
433                } else {
434                        bbb_transfer_start(sc, ST_DATA_WR_CS);
435                }
436                break;
437        }
438}
439
440static void
441bbb_data_wr_cs_callback(struct usb_xfer *xfer, usb_error_t error)
442{
443        bbb_data_clear_stall_callback(xfer, ST_STATUS,
444            ST_DATA_WR);
445}
446
447static void
448bbb_status_callback(struct usb_xfer *xfer, usb_error_t error)
449{
450        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
451        int actlen;
452        int sumlen;
453
454        usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
455
456        switch (USB_GET_STATE(xfer)) {
457        case USB_ST_TRANSFERRED:
458
459                /* very simple status check */
460
461                if (actlen < (int)sizeof(struct bbb_csw)) {
462                        bbb_done(sc, USB_ERR_SHORT_XFER);
463                } else if (sc->csw->bCSWStatus == CSWSTATUS_GOOD) {
464                        bbb_done(sc, 0);        /* success */
465                } else {
466                        bbb_done(sc, ERR_CSW_FAILED);   /* error */
467                }
468                break;
469
470        case USB_ST_SETUP:
471                usbd_xfer_set_frame_len(xfer, 0,
472                    sizeof(struct bbb_csw));
473                usbd_transfer_submit(xfer);
474                break;
475
476        default:
477                DPRINTF("Failed to read CSW: %s, try %d\n",
478                    usbd_errstr(error), sc->status_try);
479
480                if (error == USB_ERR_CANCELLED || sc->status_try) {
481                        bbb_done(sc, error);
482                } else {
483                        sc->status_try = 1;
484                        bbb_transfer_start(sc, ST_DATA_RD_CS);
485                }
486                break;
487        }
488}
489
490static void
491bbb_raw_write_callback(struct usb_xfer *xfer, usb_error_t error)
492{
493        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
494        usb_frlength_t max_bulk = usbd_xfer_max_len(xfer);
495        int actlen, sumlen;
496
497        usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
498
499        switch (USB_GET_STATE(xfer)) {
500        case USB_ST_TRANSFERRED:
501                sc->data_rem -= actlen;
502                sc->data_ptr += actlen;
503                sc->actlen += actlen;
504
505                if (actlen < sumlen) {
506                        /* short transfer */
507                        sc->data_rem = 0;
508                }
509        case USB_ST_SETUP:
510                DPRINTF("max_bulk=%d, data_rem=%d\n",
511                    max_bulk, sc->data_rem);
512
513                if (sc->data_rem == 0) {
514                        bbb_done(sc, 0);
515                        break;
516                }
517                if (max_bulk > sc->data_rem) {
518                        max_bulk = sc->data_rem;
519                }
520                usbd_xfer_set_timeout(xfer, sc->data_timeout);
521                usbd_xfer_set_frame_data(xfer, 0, sc->data_ptr, max_bulk);
522                usbd_transfer_submit(xfer);
523                break;
524
525        default:                        /* Error */
526                bbb_done(sc, error);
527                break;
528        }
529}
530
531/*------------------------------------------------------------------------*
532 *      bbb_command_start - execute a SCSI command synchronously
533 *
534 * Return values
535 * 0: Success
536 * Else: Failure
537 *------------------------------------------------------------------------*/
538static int
539bbb_command_start(struct bbb_transfer *sc, uint8_t dir, uint8_t lun,
540    void *data_ptr, size_t data_len, void *cmd_ptr, size_t cmd_len,
541    usb_timeout_t data_timeout)
542{
543        sc->lun = lun;
544        sc->dir = data_len ? dir : DIR_NONE;
545        sc->data_ptr = data_ptr;
546        sc->data_len = data_len;
547        sc->data_rem = data_len;
548        sc->data_timeout = (data_timeout + USB_MS_HZ);
549        sc->actlen = 0;
550        sc->error = 0;
551        sc->cmd_len = cmd_len;
552        memset(&sc->cbw->CBWCDB, 0, sizeof(sc->cbw->CBWCDB));
553        memcpy(&sc->cbw->CBWCDB, cmd_ptr, cmd_len);
554        DPRINTFN(1, "SCSI cmd = %*D\n", (int)cmd_len, (char *)sc->cbw->CBWCDB, ":");
555
556        mtx_lock(&sc->mtx);
557        usbd_transfer_start(sc->xfer[sc->state]);
558
559        while (usbd_transfer_pending(sc->xfer[sc->state])) {
560                cv_wait(&sc->cv, &sc->mtx);
561        }
562        mtx_unlock(&sc->mtx);
563        return (sc->error);
564}
565
566/*------------------------------------------------------------------------*
567 *      bbb_raw_write - write a raw BULK message synchronously
568 *
569 * Return values
570 * 0: Success
571 * Else: Failure
572 *------------------------------------------------------------------------*/
573static int
574bbb_raw_write(struct bbb_transfer *sc, const void *data_ptr, size_t data_len,
575    usb_timeout_t data_timeout)
576{
577        sc->data_ptr = __DECONST(void *, data_ptr);
578        sc->data_len = data_len;
579        sc->data_rem = data_len;
580        sc->data_timeout = (data_timeout + USB_MS_HZ);
581        sc->actlen = 0;
582        sc->error = 0;
583
584        DPRINTFN(1, "BULK DATA = %*D\n", (int)data_len,
585            (const char *)data_ptr, ":");
586
587        mtx_lock(&sc->mtx);
588        usbd_transfer_start(sc->xfer[0]);
589        while (usbd_transfer_pending(sc->xfer[0]))
590                cv_wait(&sc->cv, &sc->mtx);
591        mtx_unlock(&sc->mtx);
592        return (sc->error);
593}
594
595static struct bbb_transfer *
596bbb_attach(struct usb_device *udev, uint8_t iface_index,
597    uint8_t bInterfaceClass)
598{
599        struct usb_interface *iface;
600        struct usb_interface_descriptor *id;
601        const struct usb_config *pconfig;
602        struct bbb_transfer *sc;
603        usb_error_t err;
604        int nconfig;
605
606#if USB_HAVE_MSCTEST_DETACH
607        uint8_t do_unlock;
608
609        /* Prevent re-enumeration */
610        do_unlock = usbd_enum_lock(udev);
611
612        /*
613         * Make sure any driver which is hooked up to this interface,
614         * like umass is gone:
615         */
616        usb_detach_device(udev, iface_index, 0);
617
618        if (do_unlock)
619                usbd_enum_unlock(udev);
620#endif
621
622        iface = usbd_get_iface(udev, iface_index);
623        if (iface == NULL)
624                return (NULL);
625
626        id = iface->idesc;
627        if (id == NULL || id->bInterfaceClass != bInterfaceClass)
628                return (NULL);
629
630        switch (id->bInterfaceClass) {
631        case UICLASS_MASS:
632                switch (id->bInterfaceSubClass) {
633                case UISUBCLASS_SCSI:
634                case UISUBCLASS_UFI:
635                case UISUBCLASS_SFF8020I:
636                case UISUBCLASS_SFF8070I:
637                        break;
638                default:
639                        return (NULL);
640                }
641                switch (id->bInterfaceProtocol) {
642                case UIPROTO_MASS_BBB_OLD:
643                case UIPROTO_MASS_BBB:
644                        break;
645                default:
646                        return (NULL);
647                }
648                pconfig = bbb_config;
649                nconfig = ST_MAX;
650                break;
651        case UICLASS_HID:
652                switch (id->bInterfaceSubClass) {
653                case 0:
654                        break;
655                default:
656                        return (NULL);
657                }
658                pconfig = bbb_raw_config;
659                nconfig = 1;
660                break;
661        default:
662                return (NULL);
663        }
664
665        sc = malloc(sizeof(*sc), M_USB, M_WAITOK | M_ZERO);
666        mtx_init(&sc->mtx, "USB autoinstall", NULL, MTX_DEF);
667        cv_init(&sc->cv, "WBBB");
668
669        err = usbd_transfer_setup(udev, &iface_index, sc->xfer, pconfig,
670            nconfig, sc, &sc->mtx);
671        if (err) {
672                bbb_detach(sc);
673                return (NULL);
674        }
675        switch (id->bInterfaceClass) {
676        case UICLASS_MASS:
677                /* store pointer to DMA buffers */
678                sc->buffer = usbd_xfer_get_frame_buffer(
679                    sc->xfer[ST_DATA_RD], 0);
680                sc->buffer_size =
681                    usbd_xfer_max_len(sc->xfer[ST_DATA_RD]);
682                sc->cbw = usbd_xfer_get_frame_buffer(
683                    sc->xfer[ST_COMMAND], 0);
684                sc->csw = usbd_xfer_get_frame_buffer(
685                    sc->xfer[ST_STATUS], 0);
686                break;
687        default:
688                break;
689        }
690        return (sc);
691}
692
693static void
694bbb_detach(struct bbb_transfer *sc)
695{
696        usbd_transfer_unsetup(sc->xfer, ST_MAX);
697        mtx_destroy(&sc->mtx);
698        cv_destroy(&sc->cv);
699        free(sc, M_USB);
700}
701
702/*------------------------------------------------------------------------*
703 *      usb_iface_is_cdrom
704 *
705 * Return values:
706 * 1: This interface is an auto install disk (CD-ROM)
707 * 0: Not an auto install disk.
708 *------------------------------------------------------------------------*/
709int
710usb_iface_is_cdrom(struct usb_device *udev, uint8_t iface_index)
711{
712        struct bbb_transfer *sc;
713        uint8_t timeout;
714        uint8_t is_cdrom;
715        uint8_t sid_type;
716        int err;
717
718        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
719        if (sc == NULL)
720                return (0);
721
722        is_cdrom = 0;
723        timeout = 4;    /* tries */
724        while (--timeout) {
725                err = bbb_command_start(sc, DIR_IN, 0, sc->buffer,
726                    SCSI_INQ_LEN, &scsi_inquiry, sizeof(scsi_inquiry),
727                    USB_MS_HZ);
728
729                if (err == 0 && sc->actlen > 0) {
730                        sid_type = sc->buffer[0] & 0x1F;
731                        if (sid_type == 0x05)
732                                is_cdrom = 1;
733                        break;
734                } else if (err != ERR_CSW_FAILED)
735                        break;  /* non retryable error */
736                usb_pause_mtx(NULL, hz);
737        }
738        bbb_detach(sc);
739        return (is_cdrom);
740}
741
742static uint8_t
743usb_msc_get_max_lun(struct usb_device *udev, uint8_t iface_index)
744{
745        struct usb_device_request req;
746        usb_error_t err;
747        uint8_t buf = 0;
748
749
750        /* The Get Max Lun command is a class-specific request. */
751        req.bmRequestType = UT_READ_CLASS_INTERFACE;
752        req.bRequest = 0xFE;            /* GET_MAX_LUN */
753        USETW(req.wValue, 0);
754        req.wIndex[0] = iface_index;
755        req.wIndex[1] = 0;
756        USETW(req.wLength, 1);
757
758        err = usbd_do_request(udev, NULL, &req, &buf);
759        if (err)
760                buf = 0;
761
762        return (buf);
763}
764
765usb_error_t
766usb_msc_auto_quirk(struct usb_device *udev, uint8_t iface_index)
767{
768        struct bbb_transfer *sc;
769        uint8_t timeout;
770        uint8_t is_no_direct;
771        uint8_t sid_type;
772        int err;
773
774        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
775        if (sc == NULL)
776                return (0);
777
778        /*
779         * Some devices need a delay after that the configuration
780         * value is set to function properly:
781         */
782        usb_pause_mtx(NULL, hz);
783
784        if (usb_msc_get_max_lun(udev, iface_index) == 0) {
785                DPRINTF("Device has only got one LUN.\n");
786                usbd_add_dynamic_quirk(udev, UQ_MSC_NO_GETMAXLUN);
787        }
788
789        is_no_direct = 1;
790        for (timeout = 4; timeout != 0; timeout--) {
791                err = bbb_command_start(sc, DIR_IN, 0, sc->buffer,
792                    SCSI_INQ_LEN, &scsi_inquiry, sizeof(scsi_inquiry),
793                    USB_MS_HZ);
794
795                if (err == 0 && sc->actlen > 0) {
796                        sid_type = sc->buffer[0] & 0x1F;
797                        if (sid_type == 0x00)
798                                is_no_direct = 0;
799                        break;
800                } else if (err != ERR_CSW_FAILED) {
801                        DPRINTF("Device is not responding "
802                            "properly to SCSI INQUIRY command.\n");
803                        goto error;     /* non retryable error */
804                }
805                usb_pause_mtx(NULL, hz);
806        }
807
808        if (is_no_direct) {
809                DPRINTF("Device is not direct access.\n");
810                goto done;
811        }
812
813        err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
814            &scsi_test_unit_ready, sizeof(scsi_test_unit_ready),
815            USB_MS_HZ);
816
817        if (err != 0) {
818                if (err != ERR_CSW_FAILED)
819                        goto error;
820                DPRINTF("Test unit ready failed\n");
821        }
822
823        err = bbb_command_start(sc, DIR_OUT, 0, NULL, 0,
824            &scsi_prevent_removal, sizeof(scsi_prevent_removal),
825            USB_MS_HZ);
826
827        if (err == 0) {
828                err = bbb_command_start(sc, DIR_OUT, 0, NULL, 0,
829                    &scsi_allow_removal, sizeof(scsi_allow_removal),
830                    USB_MS_HZ);
831        }
832
833        if (err != 0) {
834                if (err != ERR_CSW_FAILED)
835                        goto error;
836                DPRINTF("Device doesn't handle prevent and allow removal\n");
837                usbd_add_dynamic_quirk(udev, UQ_MSC_NO_PREVENT_ALLOW);
838        }
839
840        timeout = 1;
841
842retry_sync_cache:
843        err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
844            &scsi_sync_cache, sizeof(scsi_sync_cache),
845            USB_MS_HZ);
846
847        if (err != 0) {
848
849                if (err != ERR_CSW_FAILED)
850                        goto error;
851
852                DPRINTF("Device doesn't handle synchronize cache\n");
853
854                usbd_add_dynamic_quirk(udev, UQ_MSC_NO_SYNC_CACHE);
855        } else {
856
857                /*
858                 * Certain Kingston memory sticks fail the first
859                 * read capacity after a synchronize cache command
860                 * has been issued. Disable the synchronize cache
861                 * command for such devices.
862                 */
863
864                err = bbb_command_start(sc, DIR_IN, 0, sc->buffer, 8,
865                    &scsi_read_capacity, sizeof(scsi_read_capacity),
866                    USB_MS_HZ);
867
868                if (err != 0) {
869                        if (err != ERR_CSW_FAILED)
870                                goto error;
871
872                        err = bbb_command_start(sc, DIR_IN, 0, sc->buffer, 8,
873                            &scsi_read_capacity, sizeof(scsi_read_capacity),
874                            USB_MS_HZ);
875
876                        if (err == 0) {
877                                if (timeout--)
878                                        goto retry_sync_cache;
879
880                                DPRINTF("Device most likely doesn't "
881                                    "handle synchronize cache\n");
882
883                                usbd_add_dynamic_quirk(udev,
884                                    UQ_MSC_NO_SYNC_CACHE);
885                        } else {
886                                if (err != ERR_CSW_FAILED)
887                                        goto error;
888                        }
889                }
890        }
891
892        /* clear sense status of any failed commands on the device */
893
894        err = bbb_command_start(sc, DIR_IN, 0, sc->buffer,
895            SCSI_INQ_LEN, &scsi_inquiry, sizeof(scsi_inquiry),
896            USB_MS_HZ);
897
898        DPRINTF("Inquiry = %d\n", err);
899
900        if (err != 0) {
901
902                if (err != ERR_CSW_FAILED)
903                        goto error;
904        }
905
906        err = bbb_command_start(sc, DIR_IN, 0, sc->buffer,
907            SCSI_SENSE_LEN, &scsi_request_sense,
908            sizeof(scsi_request_sense), USB_MS_HZ);
909
910        DPRINTF("Request sense = %d\n", err);
911
912        if (err != 0) {
913
914                if (err != ERR_CSW_FAILED)
915                        goto error;
916        }
917
918done:
919        bbb_detach(sc);
920        return (0);
921
922error:
923        bbb_detach(sc);
924
925        DPRINTF("Device did not respond, enabling all quirks\n");
926
927        usbd_add_dynamic_quirk(udev, UQ_MSC_NO_SYNC_CACHE);
928        usbd_add_dynamic_quirk(udev, UQ_MSC_NO_PREVENT_ALLOW);
929        usbd_add_dynamic_quirk(udev, UQ_MSC_NO_TEST_UNIT_READY);
930
931        /* Need to re-enumerate the device */
932        usbd_req_re_enumerate(udev, NULL);
933
934        return (USB_ERR_STALLED);
935}
936
937usb_error_t
938usb_msc_eject(struct usb_device *udev, uint8_t iface_index, int method)
939{
940        struct bbb_transfer *sc;
941        usb_error_t err;
942
943        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
944        if (sc == NULL)
945                return (USB_ERR_INVAL);
946
947        switch (method) {
948        case MSC_EJECT_STOPUNIT:
949                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
950                    &scsi_test_unit_ready, sizeof(scsi_test_unit_ready),
951                    USB_MS_HZ);
952                DPRINTF("Test unit ready status: %s\n", usbd_errstr(err));
953                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
954                    &scsi_start_stop_unit, sizeof(scsi_start_stop_unit),
955                    USB_MS_HZ);
956                break;
957        case MSC_EJECT_REZERO:
958                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
959                    &scsi_rezero_init, sizeof(scsi_rezero_init),
960                    USB_MS_HZ);
961                break;
962        case MSC_EJECT_ZTESTOR:
963                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
964                    &scsi_ztestor_eject, sizeof(scsi_ztestor_eject),
965                    USB_MS_HZ);
966                break;
967        case MSC_EJECT_CMOTECH:
968                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
969                    &scsi_cmotech_eject, sizeof(scsi_cmotech_eject),
970                    USB_MS_HZ);
971                break;
972        case MSC_EJECT_HUAWEI:
973                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
974                    &scsi_huawei_eject, sizeof(scsi_huawei_eject),
975                    USB_MS_HZ);
976                break;
977        case MSC_EJECT_HUAWEI2:
978                err = bbb_command_start(sc, DIR_IN, 0, NULL, 0,
979                    &scsi_huawei_eject2, sizeof(scsi_huawei_eject2),
980                    USB_MS_HZ);
981                break;
982        case MSC_EJECT_TCT:
983                /*
984                 * TCTMobile needs DIR_IN flag. To get it, we
985                 * supply a dummy data with the command.
986                 */
987                err = bbb_command_start(sc, DIR_IN, 0, sc->buffer,
988                    sc->buffer_size, &scsi_tct_eject,
989                    sizeof(scsi_tct_eject), USB_MS_HZ);
990                break;
991        default:
992                DPRINTF("Unknown eject method (%d)\n", method);
993                bbb_detach(sc);
994                return (USB_ERR_INVAL);
995        }
996
997        DPRINTF("Eject CD command status: %s\n", usbd_errstr(err));
998
999        bbb_detach(sc);
1000        return (0);
1001}
1002
1003usb_error_t
1004usb_dymo_eject(struct usb_device *udev, uint8_t iface_index)
1005{
1006        static const uint8_t data[3] = { 0x1b, 0x5a, 0x01 };
1007        struct bbb_transfer *sc;
1008        usb_error_t err;
1009
1010        sc = bbb_attach(udev, iface_index, UICLASS_HID);
1011        if (sc == NULL)
1012                return (USB_ERR_INVAL);
1013        err = bbb_raw_write(sc, data, sizeof(data), USB_MS_HZ);
1014        bbb_detach(sc);
1015        return (err);
1016}
1017
1018usb_error_t
1019usb_msc_read_10(struct usb_device *udev, uint8_t iface_index,
1020    uint32_t lba, uint32_t blocks, void *buffer)
1021{
1022        struct bbb_transfer *sc;
1023        uint8_t cmd[10];
1024        usb_error_t err;
1025
1026        cmd[0] = 0x28;          /* READ_10 */
1027        cmd[1] = 0;
1028        cmd[2] = lba >> 24;
1029        cmd[3] = lba >> 16;
1030        cmd[4] = lba >> 8;
1031        cmd[5] = lba >> 0;
1032        cmd[6] = 0;
1033        cmd[7] = blocks >> 8;
1034        cmd[8] = blocks;
1035        cmd[9] = 0;
1036
1037        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
1038        if (sc == NULL)
1039                return (USB_ERR_INVAL);
1040
1041        err = bbb_command_start(sc, DIR_IN, 0, buffer,
1042            blocks * SCSI_FIXED_BLOCK_SIZE, cmd, 10, USB_MS_HZ);
1043
1044        bbb_detach(sc);
1045
1046        return (err);
1047}
1048
1049usb_error_t
1050usb_msc_write_10(struct usb_device *udev, uint8_t iface_index,
1051    uint32_t lba, uint32_t blocks, void *buffer)
1052{
1053        struct bbb_transfer *sc;
1054        uint8_t cmd[10];
1055        usb_error_t err;
1056
1057        cmd[0] = 0x2a;          /* WRITE_10 */
1058        cmd[1] = 0;
1059        cmd[2] = lba >> 24;
1060        cmd[3] = lba >> 16;
1061        cmd[4] = lba >> 8;
1062        cmd[5] = lba >> 0;
1063        cmd[6] = 0;
1064        cmd[7] = blocks >> 8;
1065        cmd[8] = blocks;
1066        cmd[9] = 0;
1067
1068        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
1069        if (sc == NULL)
1070                return (USB_ERR_INVAL);
1071
1072        err = bbb_command_start(sc, DIR_OUT, 0, buffer,
1073            blocks * SCSI_FIXED_BLOCK_SIZE, cmd, 10, USB_MS_HZ);
1074
1075        bbb_detach(sc);
1076
1077        return (err);
1078}
1079
1080usb_error_t
1081usb_msc_read_capacity(struct usb_device *udev, uint8_t iface_index,
1082    uint32_t *lba_last, uint32_t *block_size)
1083{
1084        struct bbb_transfer *sc;
1085        usb_error_t err;
1086
1087        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
1088        if (sc == NULL)
1089                return (USB_ERR_INVAL);
1090
1091        err = bbb_command_start(sc, DIR_IN, 0, sc->buffer, 8,
1092            &scsi_read_capacity, sizeof(scsi_read_capacity),
1093            USB_MS_HZ);
1094
1095        *lba_last =
1096            (sc->buffer[0] << 24) |
1097            (sc->buffer[1] << 16) |
1098            (sc->buffer[2] << 8) |
1099            (sc->buffer[3]);
1100
1101        *block_size =
1102            (sc->buffer[4] << 24) |
1103            (sc->buffer[5] << 16) |
1104            (sc->buffer[6] << 8) |
1105            (sc->buffer[7]);
1106
1107        /* we currently only support one block size */
1108        if (*block_size != SCSI_FIXED_BLOCK_SIZE)
1109                err = USB_ERR_INVAL;
1110
1111        bbb_detach(sc);
1112
1113        return (err);
1114}
Note: See TracBrowser for help on using the repository browser.