sys/dev/ata/ata-usb.c

   1 /*-
   2  * Copyright (c) 2006 - 2008 Søren Schmidt <sos@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Copyright (c) 2006 Hans Petter Selasky
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer,
  13  *    without modification, immediately at the beginning of the file.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/stdint.h>
  34 #include <sys/stddef.h>
  35 #include <sys/param.h>
  36 #include <sys/queue.h>
  37 #include <sys/types.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/bus.h>
  41 #include <sys/linker_set.h>
  42 #include <sys/module.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/condvar.h>
  46 #include <sys/sysctl.h>
  47 #include <sys/sx.h>
  48 #include <sys/unistd.h>
  49 #include <sys/callout.h>
  50 #include <sys/malloc.h>
  51 #include <sys/priv.h>
  52 #include <machine/bus.h>
  53
  54 #include "usbdevs.h"
  55 #include <dev/usb/usb.h>
  56 #include <dev/usb/usbdi.h>
  57
  58 #include <sys/ata.h>
  59 #include <sys/bio.h>
  60 #include <sys/sema.h>
  61 #include <sys/taskqueue.h>
  62 #include <vm/uma.h>
  63
  64 #include <dev/ata/ata-all.h>
  65 #include <ata_if.h>
  66
  67 #define ATAUSB_BULK_SIZE (1<<17)
  68
  69 /* Command Block Wrapper */
  70 struct bbb_cbw {
  71         uint8_t signature[4];
  72 #define CBWSIGNATURE            0x43425355
  73
  74         uint8_t tag[4];
  75         uint8_t transfer_length[4];
  76         uint8_t flags;
  77 #define CBWFLAGS_OUT            0x00
  78 #define CBWFLAGS_IN             0x80
  79
  80         uint8_t lun;
  81         uint8_t length;
  82 #define CBWCDBLENGTH            16
  83
  84         uint8_t cdb[CBWCDBLENGTH];
  85 } __packed;
  86
  87 /* Command Status Wrapper */
  88 struct bbb_csw {
  89         uint8_t signature[4];
  90 #define CSWSIGNATURE            0x53425355
  91
  92         uint8_t tag[4];
  93         uint8_t residue[4];
  94         uint8_t status;
  95 #define CSWSTATUS_GOOD          0x0
  96 #define CSWSTATUS_FAILED        0x1
  97 #define CSWSTATUS_PHASE         0x2
  98 } __packed;
  99
 100 /* USB-ATA 'controller' softc */
 101 struct atausb2_softc {
 102         struct bbb_cbw cbw;
 103         struct bbb_csw csw;
 104         struct mtx locked_mtx;
 105
 106         struct ata_channel *locked_ch;
 107         struct ata_channel *restart_ch;
 108         struct ata_request *ata_request;
 109
 110 #define ATAUSB_T_BBB_RESET1        0
 111 #define ATAUSB_T_BBB_RESET2        1
 112 #define ATAUSB_T_BBB_RESET3        2
 113 #define ATAUSB_T_BBB_COMMAND       3
 114 #define ATAUSB_T_BBB_DATA_READ     4
 115 #define ATAUSB_T_BBB_DATA_RD_CS    5
 116 #define ATAUSB_T_BBB_DATA_WRITE    6
 117 #define ATAUSB_T_BBB_DATA_WR_CS    7
 118 #define ATAUSB_T_BBB_STATUS        8
 119 #define ATAUSB_T_BBB_MAX           9
 120
 121 #define ATAUSB_T_MAX ATAUSB_T_BBB_MAX
 122
 123         struct usb_xfer *xfer[ATAUSB_T_MAX];
 124         caddr_t ata_data;
 125         device_t dev;
 126
 127         uint32_t timeout;
 128         uint32_t ata_donecount;
 129         uint32_t ata_bytecount;
 130
 131         uint8_t last_xfer_no;
 132         uint8_t usb2_speed;
 133         uint8_t intr_stalled;
 134         uint8_t maxlun;
 135         uint8_t iface_no;
 136         uint8_t status_try;
 137 };
 138
 139 static const int atausbdebug = 0;
 140
 141 /* prototypes */
 142
 143 static device_probe_t atausb2_probe;
 144 static device_attach_t atausb2_attach;
 145 static device_detach_t atausb2_detach;
 146
 147 static usb_callback_t atausb2_t_bbb_reset1_callback;
 148 static usb_callback_t atausb2_t_bbb_reset2_callback;
 149 static usb_callback_t atausb2_t_bbb_reset3_callback;
 150 static usb_callback_t atausb2_t_bbb_command_callback;
 151 static usb_callback_t atausb2_t_bbb_data_read_callback;
 152 static usb_callback_t atausb2_t_bbb_data_rd_cs_callback;
 153 static usb_callback_t atausb2_t_bbb_data_write_callback;
 154 static usb_callback_t atausb2_t_bbb_data_wr_cs_callback;
 155 static usb_callback_t atausb2_t_bbb_status_callback;
 156 static usb_callback_t atausb2_tr_error;
 157
 158 static void atausb2_cancel_request(struct atausb2_softc *sc);
 159 static void atausb2_transfer_start(struct atausb2_softc *sc, uint8_t xfer_no);
 160 static void atausb2_t_bbb_data_clear_stall_callback(struct usb_xfer *xfer,
 161             uint8_t next_xfer, uint8_t stall_xfer, usb_error_t error);
 162 static int ata_usbchannel_begin_transaction(struct ata_request *request);
 163 static int ata_usbchannel_end_transaction(struct ata_request *request);
 164
 165 static device_probe_t ata_usbchannel_probe;
 166 static device_attach_t ata_usbchannel_attach;
 167 static device_detach_t ata_usbchannel_detach;
 168
 169 static ata_setmode_t ata_usbchannel_setmode;
 170 static ata_locking_t ata_usbchannel_locking;
 171
 172 /*
 173  * USB frontend part
 174  */
 175
 176 struct usb_config atausb2_config[ATAUSB_T_BBB_MAX] = {
 177
 178         [ATAUSB_T_BBB_RESET1] = {
 179                 .type = UE_CONTROL,
 180                 .endpoint = 0x00,       /* Control pipe */
 181                 .direction = UE_DIR_ANY,
 182                 .bufsize = sizeof(struct usb_device_request),
 183                 .flags = {},
 184                 .callback = &atausb2_t_bbb_reset1_callback,
 185                 .timeout = 5000,        /* 5 seconds */
 186                 .interval = 500,        /* 500 milliseconds */
 187         },
 188
 189         [ATAUSB_T_BBB_RESET2] = {
 190                 .type = UE_CONTROL,
 191                 .endpoint = 0x00,       /* Control pipe */
 192                 .direction = UE_DIR_ANY,
 193                 .bufsize = sizeof(struct usb_device_request),
 194                 .flags = {},
 195                 .callback = &atausb2_t_bbb_reset2_callback,
 196                 .timeout = 5000,        /* 5 seconds */
 197                 .interval = 50, /* 50 milliseconds */
 198         },
 199
 200         [ATAUSB_T_BBB_RESET3] = {
 201                 .type = UE_CONTROL,
 202                 .endpoint = 0x00,       /* Control pipe */
 203                 .direction = UE_DIR_ANY,
 204                 .bufsize = sizeof(struct usb_device_request),
 205                 .flags = {},
 206                 .callback = &atausb2_t_bbb_reset3_callback,
 207                 .timeout = 5000,        /* 5 seconds */
 208                 .interval = 50, /* 50 milliseconds */
 209         },
 210
 211         [ATAUSB_T_BBB_COMMAND] = {
 212                 .type = UE_BULK,
 213                 .endpoint = UE_ADDR_ANY,
 214                 .direction = UE_DIR_OUT,
 215                 .bufsize = sizeof(struct bbb_cbw),
 216                 .flags = {},
 217                 .callback = &atausb2_t_bbb_command_callback,
 218                 .timeout = 5000,        /* 5 seconds */
 219         },
 220
 221         [ATAUSB_T_BBB_DATA_READ] = {
 222                 .type = UE_BULK,
 223                 .endpoint = UE_ADDR_ANY,
 224                 .direction = UE_DIR_IN,
 225                 .bufsize = ATAUSB_BULK_SIZE,
 226                 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
 227                 .callback = &atausb2_t_bbb_data_read_callback,
 228                 .timeout = 0,   /* overwritten later */
 229         },
 230
 231         [ATAUSB_T_BBB_DATA_RD_CS] = {
 232                 .type = UE_CONTROL,
 233                 .endpoint = 0x00,       /* Control pipe */
 234                 .direction = UE_DIR_ANY,
 235                 .bufsize = sizeof(struct usb_device_request),
 236                 .flags = {},
 237                 .callback = &atausb2_t_bbb_data_rd_cs_callback,
 238                 .timeout = 5000,        /* 5 seconds */
 239         },
 240
 241         [ATAUSB_T_BBB_DATA_WRITE] = {
 242                 .type = UE_BULK,
 243                 .endpoint = UE_ADDR_ANY,
 244                 .direction = UE_DIR_OUT,
 245                 .bufsize = ATAUSB_BULK_SIZE,
 246                 .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,},
 247                 .callback = &atausb2_t_bbb_data_write_callback,
 248                 .timeout = 0,   /* overwritten later */
 249         },
 250
 251         [ATAUSB_T_BBB_DATA_WR_CS] = {
 252                 .type = UE_CONTROL,
 253                 .endpoint = 0x00,       /* Control pipe */
 254                 .direction = UE_DIR_ANY,
 255                 .bufsize = sizeof(struct usb_device_request),
 256                 .flags = {},
 257                 .callback = &atausb2_t_bbb_data_wr_cs_callback,
 258                 .timeout = 5000,        /* 5 seconds */
 259         },
 260
 261         [ATAUSB_T_BBB_STATUS] = {
 262                 .type = UE_BULK,
 263                 .endpoint = UE_ADDR_ANY,
 264                 .direction = UE_DIR_IN,
 265                 .bufsize = sizeof(struct bbb_csw),
 266                 .flags = {.short_xfer_ok = 1,},
 267                 .callback = &atausb2_t_bbb_status_callback,
 268                 .timeout = 5000,        /* ms */
 269         },
 270 };
 271
 272 static devclass_t atausb2_devclass;
 273
 274 static device_method_t atausb2_methods[] = {
 275         DEVMETHOD(device_probe, atausb2_probe),
 276         DEVMETHOD(device_attach, atausb2_attach),
 277         DEVMETHOD(device_detach, atausb2_detach),
 278         {0, 0}
 279 };
 280
 281 static driver_t atausb2_driver = {
 282         .name = "atausb",
 283         .methods = atausb2_methods,
 284         .size = sizeof(struct atausb2_softc),
 285 };
 286
 287 DRIVER_MODULE(atausb, uhub, atausb2_driver, atausb2_devclass, 0, 0);
 288 MODULE_DEPEND(atausb, usb, 1, 1, 1);
 289 MODULE_VERSION(atausb, 1);
 290
 291 static int
 292 atausb2_probe(device_t dev)
 293 {
 294         struct usb_attach_arg *uaa = device_get_ivars(dev);
 295         struct usb_interface_descriptor *id;
 296
 297         if (uaa->usb_mode != USB_MODE_HOST) {
 298                 return (ENXIO);
 299         }
 300         if (uaa->use_generic == 0) {
 301                 /* give other drivers a try first */
 302                 return (ENXIO);
 303         }
 304         id = usbd_get_interface_descriptor(uaa->iface);
 305         if ((!id) || (id->bInterfaceClass != UICLASS_MASS)) {
 306                 return (ENXIO);
 307         }
 308         switch (id->bInterfaceSubClass) {
 309         case UISUBCLASS_QIC157:
 310         case UISUBCLASS_RBC:
 311         case UISUBCLASS_SCSI:
 312         case UISUBCLASS_SFF8020I:
 313         case UISUBCLASS_SFF8070I:
 314         case UISUBCLASS_UFI:
 315                 switch (id->bInterfaceProtocol) {
 316                 case UIPROTO_MASS_CBI:
 317                 case UIPROTO_MASS_CBI_I:
 318                 case UIPROTO_MASS_BBB:
 319                 case UIPROTO_MASS_BBB_OLD:
 320                         return (0);
 321                 default:
 322                         return (0);
 323                 }
 324                 break;
 325         default:
 326                 return (0);
 327         }
 328 }
 329
 330 static int
 331 atausb2_attach(device_t dev)
 332 {
 333         struct atausb2_softc *sc = device_get_softc(dev);
 334         struct usb_attach_arg *uaa = device_get_ivars(dev);
 335         struct usb_interface_descriptor *id;
 336         const char *proto, *subclass;
 337         struct usb_device_request request;
 338         device_t child;
 339         uint16_t i;
 340         uint8_t maxlun;
 341         uint8_t has_intr;
 342         int err;
 343
 344         device_set_usb_desc(dev);
 345
 346         sc->dev = dev;
 347         sc->maxlun = 0;
 348         sc->locked_ch = NULL;
 349         sc->restart_ch = NULL;
 350         sc->usb2_speed = usbd_get_speed(uaa->device);
 351         mtx_init(&sc->locked_mtx, "ATAUSB lock", NULL, (MTX_DEF | MTX_RECURSE));
 352
 353         id = usbd_get_interface_descriptor(uaa->iface);
 354         switch (id->bInterfaceProtocol) {
 355         case UIPROTO_MASS_BBB:
 356         case UIPROTO_MASS_BBB_OLD:
 357                 proto = "Bulk-Only";
 358                 break;
 359         case UIPROTO_MASS_CBI:
 360                 proto = "CBI";
 361                 break;
 362         case UIPROTO_MASS_CBI_I:
 363                 proto = "CBI with CCI";
 364                 break;
 365         default:
 366                 proto = "Unknown";
 367         }
 368
 369         switch (id->bInterfaceSubClass) {
 370         case UISUBCLASS_RBC:
 371                 subclass = "RBC";
 372                 break;
 373         case UISUBCLASS_QIC157:
 374         case UISUBCLASS_SFF8020I:
 375         case UISUBCLASS_SFF8070I:
 376                 subclass = "ATAPI";
 377                 break;
 378         case UISUBCLASS_SCSI:
 379                 subclass = "SCSI";
 380                 break;
 381         case UISUBCLASS_UFI:
 382                 subclass = "UFI";
 383                 break;
 384         default:
 385                 subclass = "Unknown";
 386         }
 387
 388         has_intr = (id->bInterfaceProtocol == UIPROTO_MASS_CBI_I);
 389         sc->iface_no = id->bInterfaceNumber;
 390
 391         device_printf(dev, "using %s over %s\n", subclass, proto);
 392         if (strcmp(proto, "Bulk-Only") ||
 393             (strcmp(subclass, "ATAPI") && strcmp(subclass, "SCSI"))) {
 394                 goto detach;
 395         }
 396         err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
 397             sc->xfer, atausb2_config, ATAUSB_T_BBB_MAX, sc,
 398             &sc->locked_mtx);
 399
 400         /* skip reset first time */
 401         sc->last_xfer_no = ATAUSB_T_BBB_COMMAND;
 402
 403         if (err) {
 404                 device_printf(sc->dev, "could not setup required "
 405                     "transfers, %s\n", usbd_errstr(err));
 406                 goto detach;
 407         }
 408         /* get number of devices so we can add matching channels */
 409         request.bmRequestType = UT_READ_CLASS_INTERFACE;
 410         request.bRequest = 0xfe;        /* GET_MAX_LUN; */
 411         USETW(request.wValue, 0);
 412         USETW(request.wIndex, sc->iface_no);
 413         USETW(request.wLength, sizeof(maxlun));
 414         err = usbd_do_request(uaa->device, &Giant, &request, &maxlun);
 415
 416         if (err) {
 417                 if (bootverbose) {
 418                         device_printf(sc->dev, "get maxlun not supported %s\n",
 419                             usbd_errstr(err));
 420                 }
 421         } else {
 422                 sc->maxlun = maxlun;
 423                 if (bootverbose) {
 424                         device_printf(sc->dev, "maxlun=%d\n", sc->maxlun);
 425                 }
 426         }
 427
 428         /* ata channels are children to this USB control device */
 429         for (i = 0; i <= sc->maxlun; i++) {
 430                 if ((child = device_add_child(sc->dev, "ata",
 431                     devclass_find_free_unit(ata_devclass, 2))) == NULL) {
 432                         device_printf(sc->dev, "failed to add ata child device\n");
 433                 } else
 434                     device_set_ivars(child, (void *)(intptr_t)i);
 435         }
 436         bus_generic_attach(sc->dev);
 437
 438         return (0);
 439
 440 detach:
 441         atausb2_detach(dev);
 442         return (ENXIO);
 443 }
 444
 445 static int
 446 atausb2_detach(device_t dev)
 447 {
 448         struct atausb2_softc *sc = device_get_softc(dev);
 449         device_t *children;
 450         int nchildren, i;
 451
 452         /* teardown our statemachine */
 453
 454         usbd_transfer_unsetup(sc->xfer, ATAUSB_T_MAX);
 455
 456         /* detach & delete all children, if any */
 457
 458         if (!device_get_children(dev, &children, &nchildren)) {
 459                 for (i = 0; i < nchildren; i++) {
 460                         device_delete_child(dev, children[i]);
 461                 }
 462                 free(children, M_TEMP);
 463         }
 464         mtx_destroy(&sc->locked_mtx);
 465         return (0);
 466 }
 467
 468 static void
 469 atausb2_transfer_start(struct atausb2_softc *sc, uint8_t xfer_no)
 470 {
 471         if (atausbdebug) {
 472                 device_printf(sc->dev, "BBB transfer %d\n", xfer_no);
 473         }
 474         if (sc->xfer[xfer_no]) {
 475                 sc->last_xfer_no = xfer_no;
 476                 usbd_transfer_start(sc->xfer[xfer_no]);
 477         } else {
 478                 atausb2_cancel_request(sc);
 479         }
 480 }
 481
 482 static void
 483 atausb2_t_bbb_reset1_callback(struct usb_xfer *xfer, usb_error_t error)
 484 {
 485         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 486         struct usb_device_request req;
 487         struct usb_page_cache *pc;
 488
 489         switch (USB_GET_STATE(xfer)) {
 490         case USB_ST_TRANSFERRED:
 491                 atausb2_transfer_start(sc, ATAUSB_T_BBB_RESET2);
 492                 return;
 493
 494         case USB_ST_SETUP:
 495                 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 496                 req.bRequest = 0xff;    /* bulk-only reset */
 497                 USETW(req.wValue, 0);
 498                 req.wIndex[0] = sc->iface_no;
 499                 req.wIndex[1] = 0;
 500                 USETW(req.wLength, 0);
 501
 502                 pc = usbd_xfer_get_frame(xfer, 0);
 503                 usbd_copy_in(pc, 0, &req, sizeof(req));
 504
 505                 usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
 506                 usbd_xfer_set_frames(xfer, 1);
 507                 usbd_transfer_submit(xfer);
 508                 return;
 509
 510         default:                        /* Error */
 511                 atausb2_tr_error(xfer, error);
 512                 return;
 513
 514         }
 515 }
 516
 517 static void
 518 atausb2_t_bbb_reset2_callback(struct usb_xfer *xfer, usb_error_t error)
 519 {
 520         atausb2_t_bbb_data_clear_stall_callback(xfer, ATAUSB_T_BBB_RESET3,
 521             ATAUSB_T_BBB_DATA_READ, error);
 522 }
 523
 524 static void
 525 atausb2_t_bbb_reset3_callback(struct usb_xfer *xfer, usb_error_t error)
 526 {
 527         atausb2_t_bbb_data_clear_stall_callback(xfer, ATAUSB_T_BBB_COMMAND,
 528             ATAUSB_T_BBB_DATA_WRITE, error);
 529 }
 530
 531 static void
 532 atausb2_t_bbb_data_clear_stall_callback(struct usb_xfer *xfer,
 533     uint8_t next_xfer, uint8_t stall_xfer, usb_error_t error)
 534 {
 535         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 536
 537         switch (USB_GET_STATE(xfer)) {
 538         case USB_ST_TRANSFERRED:
 539 tr_transferred:
 540                 atausb2_transfer_start(sc, next_xfer);
 541                 return;
 542
 543         case USB_ST_SETUP:
 544                 if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) {
 545                         goto tr_transferred;
 546                 }
 547                 return;
 548
 549         default:                        /* Error */
 550                 atausb2_tr_error(xfer, error);
 551                 return;
 552
 553         }
 554 }
 555
 556 static void
 557 atausb2_t_bbb_command_callback(struct usb_xfer *xfer, usb_error_t error)
 558 {
 559         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 560         struct ata_request *request = sc->ata_request;
 561         struct ata_channel *ch;
 562         struct usb_page_cache *pc;
 563         uint32_t tag;
 564
 565         switch (USB_GET_STATE(xfer)) {
 566         case USB_ST_TRANSFERRED:
 567                 atausb2_transfer_start
 568                     (sc, ((request->flags & ATA_R_READ) ? ATAUSB_T_BBB_DATA_READ :
 569                     (request->flags & ATA_R_WRITE) ? ATAUSB_T_BBB_DATA_WRITE :
 570                     ATAUSB_T_BBB_STATUS));
 571                 return;
 572
 573         case USB_ST_SETUP:
 574
 575                 sc->status_try = 0;
 576
 577                 if (request) {
 578                         ch = device_get_softc(request->parent);
 579
 580                         sc->timeout = (request->timeout * 1000) + 5000;
 581
 582                         tag = UGETDW(sc->cbw.tag) + 1;
 583
 584                         USETDW(sc->cbw.signature, CBWSIGNATURE);
 585                         USETDW(sc->cbw.tag, tag);
 586                         USETDW(sc->cbw.transfer_length, request->bytecount);
 587                         sc->cbw.flags = (request->flags & ATA_R_READ) ? CBWFLAGS_IN : CBWFLAGS_OUT;
 588                         sc->cbw.lun = ch->unit;
 589                         sc->cbw.length = 16;
 590                         bzero(sc->cbw.cdb, 16);
 591                         bcopy(request->u.atapi.ccb, sc->cbw.cdb, 12);   /* XXX SOS */
 592
 593                         pc = usbd_xfer_get_frame(xfer, 0);
 594                         usbd_copy_in(pc, 0, &sc->cbw, sizeof(sc->cbw));
 595
 596                         usbd_xfer_set_frame_len(xfer, 0, sizeof(sc->cbw));
 597                         usbd_transfer_submit(xfer);
 598                 }
 599                 return;
 600
 601         default:                        /* Error */
 602                 atausb2_tr_error(xfer, error);
 603                 return;
 604
 605         }
 606 }
 607
 608 static void
 609 atausb2_t_bbb_data_read_callback(struct usb_xfer *xfer, usb_error_t error)
 610 {
 611         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 612         uint32_t max_bulk = usbd_xfer_max_len(xfer);
 613         struct usb_page_cache *pc;
 614         int actlen, sumlen;
 615
 616         usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
 617
 618         switch (USB_GET_STATE(xfer)) {
 619         case USB_ST_TRANSFERRED:
 620
 621                 pc = usbd_xfer_get_frame(xfer, 0);
 622                 usbd_copy_out(pc, 0, sc->ata_data, actlen);
 623
 624                 sc->ata_bytecount -= actlen;
 625                 sc->ata_data += actlen;
 626                 sc->ata_donecount += actlen;
 627
 628                 if (actlen < sumlen) {
 629                         /* short transfer */
 630                         sc->ata_bytecount = 0;
 631                 }
 632         case USB_ST_SETUP:
 633
 634                 if (atausbdebug > 1) {
 635                         device_printf(sc->dev, "%s: max_bulk=%d, ata_bytecount=%d\n",
 636                             __FUNCTION__, max_bulk, sc->ata_bytecount);
 637                 }
 638                 if (sc->ata_bytecount == 0) {
 639                         atausb2_transfer_start(sc, ATAUSB_T_BBB_STATUS);
 640                         return;
 641                 }
 642                 if (max_bulk > sc->ata_bytecount) {
 643                         max_bulk = sc->ata_bytecount;
 644                 }
 645                 usbd_xfer_set_timeout(xfer, sc->timeout);
 646                 usbd_xfer_set_frame_len(xfer, 0, max_bulk);
 647
 648                 usbd_transfer_submit(xfer);
 649                 return;
 650
 651         default:                        /* Error */
 652                 if (error == USB_ERR_CANCELLED) {
 653                         atausb2_tr_error(xfer, error);
 654                 } else {
 655                         atausb2_transfer_start(sc, ATAUSB_T_BBB_DATA_RD_CS);
 656                 }
 657                 return;
 658
 659         }
 660 }
 661
 662 static void
 663 atausb2_t_bbb_data_rd_cs_callback(struct usb_xfer *xfer, usb_error_t error)
 664 {
 665         atausb2_t_bbb_data_clear_stall_callback(xfer, ATAUSB_T_BBB_STATUS,
 666             ATAUSB_T_BBB_DATA_READ, error);
 667 }
 668
 669 static void
 670 atausb2_t_bbb_data_write_callback(struct usb_xfer *xfer, usb_error_t error)
 671 {
 672         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 673         struct usb_page_cache *pc;
 674         uint32_t max_bulk = usbd_xfer_max_len(xfer);
 675         int actlen;
 676
 677         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 678
 679         switch (USB_GET_STATE(xfer)) {
 680         case USB_ST_TRANSFERRED:
 681
 682                 sc->ata_bytecount -= actlen;
 683                 sc->ata_data += actlen;
 684                 sc->ata_donecount += actlen;
 685
 686         case USB_ST_SETUP:
 687
 688                 if (atausbdebug > 1) {
 689                         device_printf(sc->dev, "%s: max_bulk=%d, ata_bytecount=%d\n",
 690                             __FUNCTION__, max_bulk, sc->ata_bytecount);
 691                 }
 692                 if (sc->ata_bytecount == 0) {
 693                         atausb2_transfer_start(sc, ATAUSB_T_BBB_STATUS);
 694                         return;
 695                 }
 696                 if (max_bulk > sc->ata_bytecount) {
 697                         max_bulk = sc->ata_bytecount;
 698                 }
 699
 700                 pc = usbd_xfer_get_frame(xfer, 0);
 701                 usbd_copy_in(pc, 0, sc->ata_data, max_bulk);
 702                 usbd_xfer_set_frame_len(xfer, 0, max_bulk);
 703                 usbd_xfer_set_timeout(xfer, sc->timeout);
 704
 705                 usbd_transfer_submit(xfer);
 706                 return;
 707
 708         default:                        /* Error */
 709                 if (error == USB_ERR_CANCELLED) {
 710                         atausb2_tr_error(xfer, error);
 711                 } else {
 712                         atausb2_transfer_start(sc, ATAUSB_T_BBB_DATA_WR_CS);
 713                 }
 714                 return;
 715
 716         }
 717 }
 718
 719 static void
 720 atausb2_t_bbb_data_wr_cs_callback(struct usb_xfer *xfer, usb_error_t error)
 721 {
 722         atausb2_t_bbb_data_clear_stall_callback(xfer, ATAUSB_T_BBB_STATUS,
 723             ATAUSB_T_BBB_DATA_WRITE, error);
 724 }
 725
 726 static void
 727 atausb2_t_bbb_status_callback(struct usb_xfer *xfer, usb_error_t error)
 728 {
 729         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 730         struct ata_request *request = sc->ata_request;
 731         struct usb_page_cache *pc;
 732         uint32_t residue;
 733         int actlen;
 734
 735         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 736
 737         switch (USB_GET_STATE(xfer)) {
 738         case USB_ST_TRANSFERRED:
 739
 740                 if (actlen < sizeof(sc->csw)) {
 741                         bzero(&sc->csw, sizeof(sc->csw));
 742                 }
 743                 pc = usbd_xfer_get_frame(xfer, 0);
 744                 usbd_copy_out(pc, 0, &sc->csw, actlen);
 745
 746                 if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
 747                         request->donecount = sc->ata_donecount;
 748                 }
 749                 residue = UGETDW(sc->csw.residue);
 750
 751                 if (!residue) {
 752                         residue = (request->bytecount - request->donecount);
 753                 }
 754                 if (residue > request->bytecount) {
 755                         if (atausbdebug) {
 756                                 device_printf(sc->dev, "truncating residue from %d "
 757                                     "to %d bytes\n", residue,
 758                                     request->bytecount);
 759                         }
 760                         residue = request->bytecount;
 761                 }
 762                 /* check CSW and handle eventual error */
 763                 if (UGETDW(sc->csw.signature) != CSWSIGNATURE) {
 764                         if (atausbdebug) {
 765                                 device_printf(sc->dev, "bad CSW signature 0x%08x != 0x%08x\n",
 766                                     UGETDW(sc->csw.signature), CSWSIGNATURE);
 767                         }
 768                         goto tr_error;
 769                 } else if (UGETDW(sc->csw.tag) != UGETDW(sc->cbw.tag)) {
 770                         if (atausbdebug) {
 771                                 device_printf(sc->dev, "bad CSW tag %d != %d\n",
 772                                     UGETDW(sc->csw.tag), UGETDW(sc->cbw.tag));
 773                         }
 774                         goto tr_error;
 775                 } else if (sc->csw.status > CSWSTATUS_PHASE) {
 776                         if (atausbdebug) {
 777                                 device_printf(sc->dev, "bad CSW status %d > %d\n",
 778                                     sc->csw.status, CSWSTATUS_PHASE);
 779                         }
 780                         goto tr_error;
 781                 } else if (sc->csw.status == CSWSTATUS_PHASE) {
 782                         if (atausbdebug) {
 783                                 device_printf(sc->dev, "phase error residue = %d\n", residue);
 784                         }
 785                         goto tr_error;
 786                 } else if (request->donecount > request->bytecount) {
 787                         if (atausbdebug) {
 788                                 device_printf(sc->dev, "buffer overrun %d > %d\n",
 789                                     request->donecount, request->bytecount);
 790                         }
 791                         goto tr_error;
 792                 } else if (sc->csw.status == CSWSTATUS_FAILED) {
 793                         if (atausbdebug) {
 794                                 device_printf(sc->dev, "CSWSTATUS_FAILED\n");
 795                         }
 796                         request->error = ATA_E_ATAPI_SENSE_MASK;
 797                 }
 798                 sc->last_xfer_no = ATAUSB_T_BBB_COMMAND;
 799
 800                 sc->ata_request = NULL;
 801
 802                 /* drop the USB transfer lock while doing the ATA interrupt */
 803                 mtx_unlock(&sc->locked_mtx);
 804
 805                 ata_interrupt(device_get_softc(request->parent));
 806
 807                 mtx_lock(&sc->locked_mtx);
 808                 return;
 809
 810         case USB_ST_SETUP:
 811                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 812                 usbd_transfer_submit(xfer);
 813                 return;
 814
 815         default:
 816 tr_error:
 817                 if (error == USB_ERR_CANCELLED || sc->status_try) {
 818                         atausb2_tr_error(xfer, error);
 819                 } else {
 820                         sc->status_try = 1;
 821                         atausb2_transfer_start(sc, ATAUSB_T_BBB_DATA_RD_CS);
 822                 }
 823                 return;
 824
 825         }
 826 }
 827
 828 static void
 829 atausb2_cancel_request(struct atausb2_softc *sc)
 830 {
 831         struct ata_request *request;
 832
 833         mtx_assert(&sc->locked_mtx, MA_OWNED);
 834
 835         request = sc->ata_request;
 836         sc->ata_request = NULL;
 837         sc->last_xfer_no = ATAUSB_T_BBB_RESET1;
 838
 839         if (request) {
 840                 request->error = ATA_E_ATAPI_SENSE_MASK;
 841
 842                 mtx_unlock(&sc->locked_mtx);
 843
 844                 ata_interrupt(device_get_softc(request->parent));
 845
 846                 mtx_lock(&sc->locked_mtx);
 847         }
 848 }
 849
 850 static void
 851 atausb2_tr_error(struct usb_xfer *xfer, usb_error_t error)
 852 {
 853         struct atausb2_softc *sc = usbd_xfer_softc(xfer);
 854
 855         if (error != USB_ERR_CANCELLED) {
 856
 857                 if (atausbdebug) {
 858                         device_printf(sc->dev, "transfer failed, %s, in state %d "
 859                             "-> BULK reset\n", usbd_errstr(error),
 860                             sc->last_xfer_no);
 861                 }
 862         }
 863         atausb2_cancel_request(sc);
 864 }
 865
 866 /*
 867  * ATA backend part
 868  */
 869 struct atapi_inquiry {
 870         uint8_t device_type;
 871         uint8_t device_modifier;
 872         uint8_t version;
 873         uint8_t response_format;
 874         uint8_t length;
 875         uint8_t reserved[2];
 876         uint8_t flags;
 877         uint8_t vendor[8];
 878         uint8_t product[16];
 879         uint8_t revision[4];
 880         /* uint8_t    crap[60]; */
 881 } __packed;
 882
 883 static int
 884 ata_usbchannel_begin_transaction(struct ata_request *request)
 885 {
 886         struct atausb2_softc *sc =
 887         device_get_softc(device_get_parent(request->parent));
 888         int error;
 889
 890         if (atausbdebug > 1) {
 891                 device_printf(request->dev, "begin_transaction %s\n",
 892                     ata_cmd2str(request));
 893         }
 894         mtx_lock(&sc->locked_mtx);
 895
 896         /* sanity, just in case */
 897         if (sc->ata_request) {
 898                 device_printf(request->dev, "begin is busy, "
 899                     "state = %d\n", sc->last_xfer_no);
 900                 request->result = EBUSY;
 901                 error = ATA_OP_FINISHED;
 902                 goto done;
 903         }
 904         /*
 905          * XXX SOS convert the request into the format used, only BBB for
 906          * now
 907          */
 908
 909         /* ATA/ATAPI IDENTIFY needs special treatment */
 910         if (!(request->flags & ATA_R_ATAPI)) {
 911                 if (request->u.ata.command != ATA_ATAPI_IDENTIFY) {
 912                         device_printf(request->dev, "%s unsupported\n",
 913                             ata_cmd2str(request));
 914                         request->result = EIO;
 915                         error = ATA_OP_FINISHED;
 916                         goto done;
 917                 }
 918                 request->flags |= ATA_R_ATAPI;
 919                 bzero(request->u.atapi.ccb, 16);
 920                 request->u.atapi.ccb[0] = ATAPI_INQUIRY;
 921                 request->u.atapi.ccb[4] = 255;  /* sizeof(struct
 922                                                  * atapi_inquiry); */
 923                 request->data += 256;   /* arbitrary offset into ata_param */
 924                 request->bytecount = 255;       /* sizeof(struct
 925                                                  * atapi_inquiry); */
 926         }
 927         if (sc->xfer[sc->last_xfer_no]) {
 928
 929                 sc->ata_request = request;
 930                 sc->ata_bytecount = request->bytecount;
 931                 sc->ata_data = request->data;
 932                 sc->ata_donecount = 0;
 933
 934                 usbd_transfer_start(sc->xfer[sc->last_xfer_no]);
 935                 error = ATA_OP_CONTINUES;
 936         } else {
 937                 request->result = EIO;
 938                 error = ATA_OP_FINISHED;
 939         }
 940
 941 done:
 942         mtx_unlock(&sc->locked_mtx);
 943         return (error);
 944 }
 945
 946 static int
 947 ata_usbchannel_end_transaction(struct ata_request *request)
 948 {
 949         if (atausbdebug > 1) {
 950                 device_printf(request->dev, "end_transaction %s\n",
 951                     ata_cmd2str(request));
 952         }
 953         /*
 954          * XXX SOS convert the request from the format used, only BBB for
 955          * now
 956          */
 957
 958         /* ATA/ATAPI IDENTIFY needs special treatment */
 959         if ((request->flags & ATA_R_ATAPI) &&
 960             (request->u.atapi.ccb[0] == ATAPI_INQUIRY)) {
 961                 struct ata_device *atadev = device_get_softc(request->dev);
 962                 struct atapi_inquiry *inquiry = (struct atapi_inquiry *)request->data;
 963                 uint16_t *ptr;
 964
 965                 /* convert inquiry data into simple ata_param like format */
 966                 atadev->param.config = ATA_PROTO_ATAPI | ATA_PROTO_ATAPI_12;
 967                 atadev->param.config |= (inquiry->device_type & 0x1f) << 8;
 968                 bzero(atadev->param.model, sizeof(atadev->param.model));
 969                 strncpy(atadev->param.model, inquiry->vendor, 8);
 970                 strcpy(atadev->param.model, "  ");
 971                 strncpy(atadev->param.model, inquiry->product, 16);
 972                 ptr = (uint16_t *)(atadev->param.model + sizeof(atadev->param.model));
 973                 while (--ptr >= (uint16_t *)atadev->param.model) {
 974                         *ptr = ntohs(*ptr);
 975                 }
 976                 strncpy(atadev->param.revision, inquiry->revision, 4);
 977                 ptr = (uint16_t *)(atadev->param.revision + sizeof(atadev->param.revision));
 978                 while (--ptr >= (uint16_t *)atadev->param.revision) {
 979                         *ptr = ntohs(*ptr);
 980                 }
 981                 request->result = 0;
 982         }
 983         return (ATA_OP_FINISHED);
 984 }
 985
 986 static int
 987 ata_usbchannel_probe(device_t dev)
 988 {
 989         char buffer[32];
 990
 991         snprintf(buffer, sizeof(buffer), "USB lun %d",
 992             (int)(intptr_t)device_get_ivars(dev));
 993         device_set_desc_copy(dev, buffer);
 994
 995         return (0);
 996 }
 997
 998 static int
 999 ata_usbchannel_attach(device_t dev)
1000 {
1001         struct ata_channel *ch = device_get_softc(dev);
1002
1003         if (ch->attached)
1004                 return (0);
1005         ch->attached = 1;
1006
1007         /* initialize the softc basics */
1008         ch->dev = dev;
1009         ch->unit = (intptr_t)device_get_ivars(dev);
1010         ch->state = ATA_IDLE;
1011         ch->hw.begin_transaction = ata_usbchannel_begin_transaction;
1012         ch->hw.end_transaction = ata_usbchannel_end_transaction;
1013         ch->hw.status = NULL;
1014         ch->hw.command = NULL;
1015         bzero(&ch->state_mtx, sizeof(struct mtx));
1016         mtx_init(&ch->state_mtx, "ATA state lock", NULL, MTX_DEF);
1017         bzero(&ch->queue_mtx, sizeof(struct mtx));
1018         mtx_init(&ch->queue_mtx, "ATA queue lock", NULL, MTX_DEF);
1019         TAILQ_INIT(&ch->ata_queue);
1020
1021         /* XXX SOS reset the controller HW, the channel and device(s) */
1022         /* ATA_RESET(dev); */
1023
1024         /* probe and attach device on this channel */
1025         ch->devices = ATA_ATAPI_MASTER;
1026         if (!ata_delayed_attach) {
1027                 ata_identify(dev);
1028         }
1029         return (0);
1030 }
1031
1032 static int
1033 ata_usbchannel_detach(device_t dev)
1034 {
1035         struct ata_channel *ch = device_get_softc(dev);
1036         device_t *children;
1037         int nchildren, i;
1038
1039         if (!ch->attached)
1040                 return (0);
1041         ch->attached = 0;
1042
1043         /* detach & delete all children */
1044         if (!device_get_children(dev, &children, &nchildren)) {
1045                 for (i = 0; i < nchildren; i++)
1046                         if (children[i])
1047                                 device_delete_child(dev, children[i]);
1048                 free(children, M_TEMP);
1049         }
1050         mtx_destroy(&ch->state_mtx);
1051         mtx_destroy(&ch->queue_mtx);
1052         return (0);
1053 }
1054
1055 static void
1056 ata_usbchannel_setmode(device_t parent, device_t dev)
1057 {
1058         struct atausb2_softc *sc = device_get_softc(GRANDPARENT(dev));
1059         struct ata_device *atadev = device_get_softc(dev);
1060
1061         if (sc->usb2_speed == USB_SPEED_HIGH)
1062                 atadev->mode = ATA_USB2;
1063         else
1064                 atadev->mode = ATA_USB1;
1065 }
1066
1067 static int
1068 ata_usbchannel_locking(device_t dev, int flags)
1069 {
1070         struct atausb2_softc *sc = device_get_softc(device_get_parent(dev));
1071         struct ata_channel *ch = device_get_softc(dev);
1072         int res = -1;
1073
1074         mtx_lock(&sc->locked_mtx);
1075         switch (flags) {
1076         case ATA_LF_LOCK:
1077                 if (sc->locked_ch == NULL)
1078                         sc->locked_ch = ch;
1079                 if (sc->locked_ch != ch)
1080                         sc->restart_ch = ch;
1081                 break;
1082
1083         case ATA_LF_UNLOCK:
1084                 if (sc->locked_ch == ch) {
1085                         sc->locked_ch = NULL;
1086                         if (sc->restart_ch) {
1087                                 ch = sc->restart_ch;
1088                                 sc->restart_ch = NULL;
1089                                 mtx_unlock(&sc->locked_mtx);
1090                                 ata_start(ch->dev);
1091                                 return (res);
1092                         }
1093                 }
1094                 break;
1095
1096         case ATA_LF_WHICH:
1097                 break;
1098         }
1099         if (sc->locked_ch) {
1100                 res = sc->locked_ch->unit;
1101         }
1102         mtx_unlock(&sc->locked_mtx);
1103         return (res);
1104 }
1105
1106 static device_method_t ata_usbchannel_methods[] = {
1107         /* device interface */
1108         DEVMETHOD(device_probe, ata_usbchannel_probe),
1109         DEVMETHOD(device_attach, ata_usbchannel_attach),
1110         DEVMETHOD(device_detach, ata_usbchannel_detach),
1111
1112         /* ATA methods */
1113         DEVMETHOD(ata_setmode, ata_usbchannel_setmode),
1114         DEVMETHOD(ata_locking, ata_usbchannel_locking),
1115         /* DEVMETHOD(ata_reset,            ata_usbchannel_reset), */
1116
1117         {0, 0}
1118 };
1119
1120 static driver_t ata_usbchannel_driver = {
1121         "ata",
1122         ata_usbchannel_methods,
1123         sizeof(struct ata_channel),
1124 };
1125
1126 DRIVER_MODULE(ata, atausb, ata_usbchannel_driver, ata_devclass, 0, 0);
1127 MODULE_DEPEND(atausb, ata, 1, 1, 1);