sys/dev/ata/atapi-tape.c

   1 /*-
   2  * Copyright (c) 1998 - 2008 Søren Schmidt <sos@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  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 ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_ata.h"
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/ata.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/malloc.h>
  37 #include <sys/conf.h>
  38 #include <sys/bio.h>
  39 #include <sys/bus.h>
  40 #include <sys/mtio.h>
  41 #include <sys/devicestat.h>
  42 #include <sys/sema.h>
  43 #include <sys/taskqueue.h>
  44 #include <vm/uma.h>
  45 #include <machine/bus.h>
  46 #include <dev/ata/ata-all.h>
  47 #include <dev/ata/atapi-tape.h>
  48 #include <ata_if.h>
  49
  50 /* device structure */
  51 static  d_open_t        ast_open;
  52 static  d_close_t       ast_close;
  53 static  d_ioctl_t       ast_ioctl;
  54 static  d_strategy_t    ast_strategy;
  55 static struct cdevsw ast_cdevsw = {
  56         .d_version =    D_VERSION,
  57         .d_open =       ast_open,
  58         .d_close =      ast_close,
  59         .d_read =       physread,
  60         .d_write =      physwrite,
  61         .d_ioctl =      ast_ioctl,
  62         .d_strategy =   ast_strategy,
  63         .d_name =       "ast",
  64         .d_flags =      D_TAPE | D_TRACKCLOSE,
  65 };
  66
  67 /* prototypes */
  68 static int ast_sense(device_t);
  69 static void ast_describe(device_t);
  70 static void ast_done(struct ata_request *);
  71 static int ast_mode_sense(device_t, int, void *, int);
  72 static int ast_mode_select(device_t, void *, int);
  73 static int ast_write_filemark(device_t, u_int8_t);
  74 static int ast_read_position(device_t, int, struct ast_readposition *);
  75 static int ast_space(device_t, u_int8_t, int32_t);
  76 static int ast_locate(device_t, int, u_int32_t);
  77 static int ast_prevent_allow(device_t, int);
  78 static int ast_load_unload(device_t, u_int8_t);
  79 static int ast_rewind(device_t);
  80 static int ast_erase(device_t);
  81 static int ast_test_ready(device_t);
  82 static int ast_wait_dsc(device_t, int);
  83
  84 /* internal vars */
  85 static u_int64_t ast_total = 0;
  86 static MALLOC_DEFINE(M_AST, "ast_driver", "ATAPI tape driver buffers");
  87
  88 static int
  89 ast_probe(device_t dev)
  90 {
  91     struct ata_device *atadev = device_get_softc(dev);
  92
  93     if ((atadev->param.config & ATA_PROTO_ATAPI) &&
  94         (atadev->param.config & ATA_ATAPI_TYPE_MASK) == ATA_ATAPI_TYPE_TAPE)
  95         return 0;
  96     else
  97         return ENXIO;
  98 }
  99
 100 static int
 101 ast_attach(device_t dev)
 102 {
 103     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
 104     struct ata_device *atadev = device_get_softc(dev);
 105     struct ast_softc *stp;
 106     struct ast_readposition position;
 107     struct cdev *device;
 108
 109     if (!(stp = malloc(sizeof(struct ast_softc), M_AST, M_NOWAIT | M_ZERO))) {
 110         device_printf(dev, "out of memory\n");
 111         return ENOMEM;
 112     }
 113     device_set_ivars(dev, stp);
 114     ata_setmode(dev);
 115
 116     if (ast_sense(dev)) {
 117         device_set_ivars(dev, NULL);
 118         free(stp, M_AST);
 119         return ENXIO;
 120     }
 121     if (!strcmp(atadev->param.model, "OnStream DI-30")) {
 122         struct ast_transferpage transfer;
 123         struct ast_identifypage identify;
 124
 125         stp->flags |= F_ONSTREAM;
 126         bzero(&transfer, sizeof(struct ast_transferpage));
 127         ast_mode_sense(dev, ATAPI_TAPE_TRANSFER_PAGE,
 128                        &transfer, sizeof(transfer));
 129         bzero(&identify, sizeof(struct ast_identifypage));
 130         ast_mode_sense(dev, ATAPI_TAPE_IDENTIFY_PAGE,
 131                        &identify, sizeof(identify));
 132         strncpy(identify.ident, "FBSD", 4);
 133         ast_mode_select(dev, &identify, sizeof(identify));
 134         ast_read_position(dev, 0, &position);
 135     }
 136
 137     stp->stats = devstat_new_entry("ast", device_get_unit(dev), DEV_BSIZE,
 138                       DEVSTAT_NO_ORDERED_TAGS,
 139                       DEVSTAT_TYPE_SEQUENTIAL | DEVSTAT_TYPE_IF_IDE,
 140                       DEVSTAT_PRIORITY_TAPE);
 141     device = make_dev(&ast_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0640,
 142                       "ast%d", device_get_unit(dev));
 143     device->si_drv1 = dev;
 144     device->si_iosize_max = ch->dma.max_iosize ? ch->dma.max_iosize : DFLTPHYS;
 145     stp->dev1 = device;
 146     device = make_dev(&ast_cdevsw, 1, UID_ROOT, GID_OPERATOR, 0640,
 147                       "nast%d", device_get_unit(dev));
 148     device->si_drv1 = dev;
 149     device->si_iosize_max = ch->dma.max_iosize;
 150     stp->dev2 = device;
 151
 152     /* announce we are here and ready */
 153     ast_describe(dev);
 154     return 0;
 155 }
 156
 157 static int
 158 ast_detach(device_t dev)
 159 {
 160     struct ast_softc *stp = device_get_ivars(dev);
 161
 162     /* detroy devices from the system so we dont get any further requests */
 163     destroy_dev(stp->dev1);
 164     destroy_dev(stp->dev2);
 165
 166     /* fail requests on the queue and any thats "in flight" for this device */
 167     ata_fail_requests(dev);
 168
 169     /* dont leave anything behind */
 170     devstat_remove_entry(stp->stats);
 171     device_set_ivars(dev, NULL);
 172     free(stp, M_AST);
 173     return 0;
 174 }
 175
 176 static int
 177 ast_shutdown(device_t dev)
 178 {
 179     struct ata_device *atadev = device_get_softc(dev);
 180
 181     if (atadev->param.support.command2 & ATA_SUPPORT_FLUSHCACHE)
 182         ata_controlcmd(dev, ATA_FLUSHCACHE, 0, 0, 0);
 183     return 0;
 184 }
 185
 186 static int
 187 ast_reinit(device_t dev)
 188 {
 189     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
 190     struct ata_device *atadev = device_get_softc(dev);
 191
 192     /* if detach pending, return error */
 193     if (!(ch->devices & (ATA_ATAPI_MASTER << atadev->unit)))
 194         return 1;
 195
 196     ata_setmode(dev);
 197     return 0;
 198 }
 199
 200 static int
 201 ast_open(struct cdev *cdev, int flags, int fmt, struct thread *td)
 202 {
 203     device_t dev = cdev->si_drv1;
 204     struct ata_device *atadev = device_get_softc(dev);
 205     struct ast_softc *stp = device_get_ivars(dev);
 206
 207     if (!stp)
 208         return ENXIO;
 209     if (!device_is_attached(dev))
 210         return EBUSY;
 211
 212     ast_test_ready(dev);
 213     if (stp->cap.lock)
 214         ast_prevent_allow(dev, 1);
 215     if (ast_sense(dev))
 216         device_printf(dev, "sense media type failed\n");
 217
 218     atadev->flags &= ~ATA_D_MEDIA_CHANGED;
 219     stp->flags &= ~(F_DATA_WRITTEN | F_FM_WRITTEN);
 220     ast_total = 0;
 221     return 0;
 222 }
 223
 224 static int
 225 ast_close(struct cdev *cdev, int flags, int fmt, struct thread *td)
 226 {
 227     device_t dev = cdev->si_drv1;
 228     struct ast_softc *stp = device_get_ivars(dev);
 229
 230     /* flush buffers, some drives fail here, they should report ctl = 0 */
 231     if (stp->cap.ctl && (stp->flags & F_DATA_WRITTEN))
 232         ast_write_filemark(dev, 0);
 233
 234     /* write filemark if data written to tape */
 235     if (!(stp->flags & F_ONSTREAM) &&
 236         (stp->flags & (F_DATA_WRITTEN | F_FM_WRITTEN)) == F_DATA_WRITTEN)
 237         ast_write_filemark(dev, ATAPI_WF_WRITE);
 238
 239     /* if unit is zero rewind on close */
 240     if (dev2unit(cdev) == 0)
 241         ast_rewind(dev);
 242
 243     if (stp->cap.lock && count_dev(cdev) == 1)
 244         ast_prevent_allow(dev, 0);
 245
 246     stp->flags &= ~F_CTL_WARN;
 247 #ifdef AST_DEBUG
 248     device_printf(dev, "%ju total bytes transferred\n", (uintmax_t)ast_total);
 249 #endif
 250     return 0;
 251 }
 252
 253 static int
 254 ast_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int flag, struct thread *td)
 255 {
 256     device_t dev = cdev->si_drv1;
 257     struct ast_softc *stp = device_get_ivars(dev);
 258     int error = 0;
 259
 260     switch (cmd) {
 261     case MTIOCGET:
 262         {
 263             struct mtget *g = (struct mtget *) data;
 264
 265             bzero(g, sizeof(struct mtget));
 266             g->mt_type = 7;
 267             g->mt_density = 1;
 268             g->mt_blksiz = stp->blksize;
 269             g->mt_comp = stp->cap.compress;
 270             g->mt_density0 = 0; g->mt_density1 = 0;
 271             g->mt_density2 = 0; g->mt_density3 = 0;
 272             g->mt_blksiz0 = 0; g->mt_blksiz1 = 0;
 273             g->mt_blksiz2 = 0; g->mt_blksiz3 = 0;
 274             g->mt_comp0 = 0; g->mt_comp1 = 0;
 275             g->mt_comp2 = 0; g->mt_comp3 = 0;
 276         }
 277         break;
 278
 279     case MTIOCTOP:
 280         {
 281             int i;
 282             struct mtop *mt = (struct mtop *)data;
 283
 284             switch ((int16_t) (mt->mt_op)) {
 285
 286             case MTWEOF:
 287                 for (i=0; i < mt->mt_count && !error; i++)
 288                     error = ast_write_filemark(dev, ATAPI_WF_WRITE);
 289                 break;
 290
 291             case MTFSF:
 292                 if (mt->mt_count)
 293                     error = ast_space(dev, ATAPI_SP_FM, mt->mt_count);
 294                 break;
 295
 296             case MTBSF:
 297                 if (mt->mt_count)
 298                     error = ast_space(dev, ATAPI_SP_FM, -(mt->mt_count));
 299                 break;
 300
 301             case MTREW:
 302                 error = ast_rewind(dev);
 303                 break;
 304
 305             case MTOFFL:
 306                 error = ast_load_unload(dev, ATAPI_SS_EJECT);
 307                 break;
 308
 309             case MTNOP:
 310                 error = ast_write_filemark(dev, 0);
 311                 break;
 312
 313             case MTERASE:
 314                 error = ast_erase(dev);
 315                 break;
 316
 317             case MTEOD:
 318                 error = ast_space(dev, ATAPI_SP_EOD, 0);
 319                 break;
 320
 321             case MTRETENS:
 322                 error = ast_load_unload(dev, ATAPI_SS_RETENSION|ATAPI_SS_LOAD);
 323                 break;
 324
 325             case MTFSR:
 326             case MTBSR:
 327             case MTCACHE:
 328             case MTNOCACHE:
 329             case MTSETBSIZ:
 330             case MTSETDNSTY:
 331             case MTCOMP:
 332             default:
 333                 error = EINVAL;
 334             }
 335         }
 336         break;
 337
 338     case MTIOCRDSPOS:
 339         {
 340             struct ast_readposition position;
 341
 342             if ((error = ast_read_position(dev, 0, &position)))
 343                 break;
 344             *(u_int32_t *)data = position.tape;
 345         }
 346         break;
 347
 348     case MTIOCRDHPOS:
 349         {
 350             struct ast_readposition position;
 351
 352             if ((error = ast_read_position(dev, 1, &position)))
 353                 break;
 354             *(u_int32_t *)data = position.tape;
 355         }
 356         break;
 357
 358     case MTIOCSLOCATE:
 359         error = ast_locate(dev, 0, *(u_int32_t *)data);
 360         break;
 361
 362     case MTIOCHLOCATE:
 363         error = ast_locate(dev, 1, *(u_int32_t *)data);
 364         break;
 365
 366     default:
 367         error = ata_device_ioctl(dev, cmd, data);
 368     }
 369     return error;
 370 }
 371
 372 static void
 373 ast_strategy(struct bio *bp)
 374 {
 375     device_t dev = bp->bio_dev->si_drv1;
 376     struct ast_softc *stp = device_get_ivars(dev);
 377     struct ata_request *request;
 378     u_int32_t blkcount;
 379     int8_t ccb[16];
 380
 381     /* if it's a null transfer, return immediatly. */
 382     if (bp->bio_bcount == 0) {
 383         bp->bio_resid = 0;
 384         biodone(bp);
 385         return;
 386     }
 387     if (!(bp->bio_cmd == BIO_READ) && stp->flags & F_WRITEPROTECT) {
 388         biofinish(bp, NULL, EPERM);
 389         return;
 390     }
 391
 392     /* check for != blocksize requests */
 393     if (bp->bio_bcount % stp->blksize) {
 394         device_printf(dev, "transfers must be multiple of %d\n", stp->blksize);
 395         biofinish(bp, NULL, EIO);
 396         return;
 397     }
 398
 399     /* warn about transfers bigger than the device suggests */
 400     if (bp->bio_bcount > stp->blksize * stp->cap.ctl) {
 401         if ((stp->flags & F_CTL_WARN) == 0) {
 402             device_printf(dev, "WARNING: CTL exceeded %ld>%d\n",
 403                           bp->bio_bcount, stp->blksize * stp->cap.ctl);
 404             stp->flags |= F_CTL_WARN;
 405         }
 406     }
 407
 408     bzero(ccb, sizeof(ccb));
 409
 410     if (bp->bio_cmd == BIO_READ)
 411         ccb[0] = ATAPI_READ;
 412     else
 413         ccb[0] = ATAPI_WRITE;
 414
 415     blkcount = bp->bio_bcount / stp->blksize;
 416
 417     ccb[1] = 1;
 418     ccb[2] = blkcount >> 16;
 419     ccb[3] = blkcount >> 8;
 420     ccb[4] = blkcount;
 421
 422     if (!(request = ata_alloc_request())) {
 423         biofinish(bp, NULL, ENOMEM);
 424         return;
 425     }
 426     request->dev = dev;
 427     request->driver = bp;
 428     bcopy(ccb, request->u.atapi.ccb, 16);
 429     request->data = bp->bio_data;
 430     request->bytecount = blkcount * stp->blksize;
 431     request->transfersize = min(request->bytecount, 65534);
 432     request->timeout = (ccb[0] == ATAPI_WRITE_BIG) ? 180 : 120;
 433     request->retries = 2;
 434     request->callback = ast_done;
 435     switch (bp->bio_cmd) {
 436     case BIO_READ:
 437         request->flags |= (ATA_R_ATAPI | ATA_R_READ);
 438         break;
 439     case BIO_WRITE:
 440         request->flags |= (ATA_R_ATAPI | ATA_R_WRITE);
 441         break;
 442     default:
 443         device_printf(dev, "unknown BIO operation\n");
 444         ata_free_request(request);
 445         biofinish(bp, NULL, EIO);
 446         return;
 447     }
 448     devstat_start_transaction_bio(stp->stats, bp);
 449     ata_queue_request(request);
 450 }
 451
 452 static void
 453 ast_done(struct ata_request *request)
 454 {
 455     struct ast_softc *stp = device_get_ivars(request->dev);
 456     struct bio *bp = request->driver;
 457
 458     /* finish up transfer */
 459     if ((bp->bio_error = request->result))
 460         bp->bio_flags |= BIO_ERROR;
 461     if (bp->bio_cmd == BIO_WRITE)
 462         stp->flags |= F_DATA_WRITTEN;
 463     bp->bio_resid = bp->bio_bcount - request->donecount;
 464     ast_total += (bp->bio_bcount - bp->bio_resid);
 465     biofinish(bp, stp->stats, 0);
 466     ata_free_request(request);
 467 }
 468
 469 static int
 470 ast_sense(device_t dev)
 471 {
 472     struct ast_softc *stp = device_get_ivars(dev);
 473     int count;
 474
 475     /* get drive capabilities, some bugridden drives needs this repeated */
 476     for (count = 0 ; count < 5 ; count++) {
 477         if (!ast_mode_sense(dev, ATAPI_TAPE_CAP_PAGE,
 478                             &stp->cap, sizeof(stp->cap)) &&
 479             stp->cap.page_code == ATAPI_TAPE_CAP_PAGE) {
 480             if (stp->cap.blk32k)
 481                 stp->blksize = 32768;
 482             if (stp->cap.blk1024)
 483                 stp->blksize = 1024;
 484             if (stp->cap.blk512)
 485                 stp->blksize = 512;
 486             if (!stp->blksize)
 487                 continue;
 488             stp->cap.max_speed = ntohs(stp->cap.max_speed);
 489             stp->cap.max_defects = ntohs(stp->cap.max_defects);
 490             stp->cap.ctl = ntohs(stp->cap.ctl);
 491             stp->cap.speed = ntohs(stp->cap.speed);
 492             stp->cap.buffer_size = ntohs(stp->cap.buffer_size);
 493             return 0;
 494         }
 495     }
 496     return 1;
 497 }
 498
 499 static int
 500 ast_mode_sense(device_t dev, int page, void *pagebuf, int pagesize)
 501 {
 502     int8_t ccb[16] = { ATAPI_MODE_SENSE, 0x08, page, pagesize>>8, pagesize,
 503                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 504     int error;
 505
 506     error = ata_atapicmd(dev, ccb, pagebuf, pagesize, ATA_R_READ, 10);
 507     return error;
 508 }
 509
 510 static int
 511 ast_mode_select(device_t dev, void *pagebuf, int pagesize)
 512 {
 513     int8_t ccb[16] = { ATAPI_MODE_SELECT, 0x10, 0, pagesize>>8, pagesize,
 514                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 515
 516     return ata_atapicmd(dev, ccb, pagebuf, pagesize, 0, 10);
 517 }
 518
 519 static int
 520 ast_write_filemark(device_t dev, u_int8_t function)
 521 {
 522     struct ast_softc *stp = device_get_ivars(dev);
 523     int8_t ccb[16] = { ATAPI_WEOF, 0x01, 0, 0, function, 0, 0, 0,
 524                        0, 0, 0, 0, 0, 0, 0, 0 };
 525     int error;
 526
 527     if (stp->flags & F_ONSTREAM)
 528         ccb[4] = 0x00;          /* only flush buffers supported */
 529     else {
 530         if (function) {
 531             if (stp->flags & F_FM_WRITTEN)
 532                 stp->flags &= ~F_DATA_WRITTEN;
 533             else
 534                 stp->flags |= F_FM_WRITTEN;
 535         }
 536     }
 537     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
 538     if (error)
 539         return error;
 540     return ast_wait_dsc(dev, 10*60);
 541 }
 542
 543 static int
 544 ast_read_position(device_t dev, int hard, struct ast_readposition *position)
 545 {
 546     int8_t ccb[16] = { ATAPI_READ_POSITION, (hard ? 0x01 : 0), 0, 0, 0, 0, 0, 0,
 547                        0, 0, 0, 0, 0, 0, 0, 0 };
 548     int error;
 549
 550     error = ata_atapicmd(dev, ccb, (caddr_t)position,
 551                          sizeof(struct ast_readposition), ATA_R_READ, 10);
 552     position->tape = ntohl(position->tape);
 553     position->host = ntohl(position->host);
 554     return error;
 555 }
 556
 557 static int
 558 ast_space(device_t dev, u_int8_t function, int32_t count)
 559 {
 560     int8_t ccb[16] = { ATAPI_SPACE, function, count>>16, count>>8, count,
 561                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 562
 563     return ata_atapicmd(dev, ccb, NULL, 0, 0, 60*60);
 564 }
 565
 566 static int
 567 ast_locate(device_t dev, int hard, u_int32_t pos)
 568 {
 569     int8_t ccb[16] = { ATAPI_LOCATE, 0x01 | (hard ? 0x4 : 0), 0,
 570                        pos>>24, pos>>16, pos>>8, pos,
 571                        0, 0, 0, 0, 0, 0, 0, 0, 0 };
 572     int error;
 573
 574     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
 575     if (error)
 576         return error;
 577     return ast_wait_dsc(dev, 60*60);
 578 }
 579
 580 static int
 581 ast_prevent_allow(device_t dev, int lock)
 582 {
 583     int8_t ccb[16] = { ATAPI_PREVENT_ALLOW, 0, 0, 0, lock,
 584                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 585
 586     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
 587 }
 588
 589 static int
 590 ast_load_unload(device_t dev, u_int8_t function)
 591 {
 592     struct ast_softc *stp = device_get_ivars(dev);
 593     int8_t ccb[16] = { ATAPI_START_STOP, 0x01, 0, 0, function, 0, 0, 0,
 594                        0, 0, 0, 0, 0, 0, 0, 0 };
 595     int error;
 596
 597     if ((function & ATAPI_SS_EJECT) && !stp->cap.eject)
 598         return 0;
 599     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
 600     if (error)
 601         return error;
 602     pause("astlu", 1 * hz);
 603     if (function == ATAPI_SS_EJECT)
 604         return 0;
 605     return ast_wait_dsc(dev, 60*60);
 606 }
 607
 608 static int
 609 ast_rewind(device_t dev)
 610 {
 611     int8_t ccb[16] = { ATAPI_REZERO, 0x01, 0, 0, 0, 0, 0, 0,
 612                        0, 0, 0, 0, 0, 0, 0, 0 };
 613     int error;
 614
 615     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
 616     if (error)
 617         return error;
 618     return ast_wait_dsc(dev, 60*60);
 619 }
 620
 621 static int
 622 ast_erase(device_t dev)
 623 {
 624     int8_t ccb[16] = { ATAPI_ERASE, 3, 0, 0, 0, 0, 0, 0,
 625                        0, 0, 0, 0, 0, 0, 0, 0 };
 626     int error;
 627
 628     if ((error = ast_rewind(dev)))
 629         return error;
 630
 631     return ata_atapicmd(dev, ccb, NULL, 0, 0, 60*60);
 632 }
 633
 634 static int
 635 ast_test_ready(device_t dev)
 636 {
 637     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
 638                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 639
 640     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
 641 }
 642
 643 static int
 644 ast_wait_dsc(device_t dev, int timeout)
 645 {
 646     int error = 0;
 647     int8_t ccb[16] = { ATAPI_POLL_DSC, 0, 0, 0, 0,
 648                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 649
 650     timeout *= hz;
 651     while (timeout > 0) {
 652         error = ata_atapicmd(dev, ccb, NULL, 0, 0, 0);
 653         if (error != EBUSY)
 654             break;
 655         pause("atpwt", hz / 2);
 656         timeout -= (hz / 2);
 657     }
 658     return error;
 659 }
 660
 661 static void
 662 ast_describe(device_t dev)
 663 {
 664     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
 665     struct ata_device *atadev = device_get_softc(dev);
 666     struct ast_softc *stp = device_get_ivars(dev);
 667
 668     if (bootverbose) {
 669         device_printf(dev, "<%.40s/%.8s> tape drive at ata%d as %s\n",
 670                       atadev->param.model, atadev->param.revision,
 671                       device_get_unit(ch->dev), ata_unit2str(atadev));
 672         device_printf(dev, "%dKB/s, ", stp->cap.max_speed);
 673         printf("transfer limit %d blk%s, ",
 674                stp->cap.ctl, (stp->cap.ctl > 1) ? "s" : "");
 675         printf("%dKB buffer, ", (stp->cap.buffer_size * DEV_BSIZE) / 1024);
 676         printf("%s %s\n", ata_mode2str(atadev->mode),
 677             ata_satarev2str(ATA_GETREV(device_get_parent(dev), atadev->unit)));
 678         device_printf(dev, "Medium: ");
 679         switch (stp->cap.medium_type) {
 680             case 0x00:
 681                 printf("none"); break;
 682             case 0x17:
 683                 printf("Travan 1 (400 Mbyte)"); break;
 684             case 0xb6:
 685                 printf("Travan 4 (4 Gbyte)"); break;
 686             case 0xda:
 687                 printf("OnStream ADR (15Gyte)"); break;
 688             default:
 689                 printf("unknown (0x%x)", stp->cap.medium_type);
 690         }
 691         if (stp->cap.readonly) printf(", readonly");
 692         if (stp->cap.reverse) printf(", reverse");
 693         if (stp->cap.eformat) printf(", eformat");
 694         if (stp->cap.qfa) printf(", qfa");
 695         if (stp->cap.lock) printf(", lock");
 696         if (stp->cap.locked) printf(", locked");
 697         if (stp->cap.prevent) printf(", prevent");
 698         if (stp->cap.eject) printf(", eject");
 699         if (stp->cap.disconnect) printf(", disconnect");
 700         if (stp->cap.ecc) printf(", ecc");
 701         if (stp->cap.compress) printf(", compress");
 702         if (stp->cap.blk512) printf(", 512b");
 703         if (stp->cap.blk1024) printf(", 1024b");
 704         if (stp->cap.blk32k) printf(", 32kb");
 705         printf("\n");
 706     }
 707     else {
 708         device_printf(dev, "TAPE <%.40s/%.8s> at ata%d-%s %s %s\n",
 709                       atadev->param.model, atadev->param.revision,
 710                       device_get_unit(ch->dev), ata_unit2str(atadev),
 711                       ata_mode2str(atadev->mode),
 712                       ata_satarev2str(ATA_GETREV(device_get_parent(dev), atadev->unit)));
 713     }
 714 }
 715
 716 static device_method_t ast_methods[] = {
 717     /* device interface */
 718     DEVMETHOD(device_probe,     ast_probe),
 719     DEVMETHOD(device_attach,    ast_attach),
 720     DEVMETHOD(device_detach,    ast_detach),
 721     DEVMETHOD(device_shutdown,  ast_shutdown),
 722
 723     /* ATA methods */
 724     DEVMETHOD(ata_reinit,       ast_reinit),
 725
 726     DEVMETHOD_END
 727 };
 728
 729 static driver_t ast_driver = {
 730     "ast",
 731     ast_methods,
 732     0,
 733 };
 734
 735 static devclass_t ast_devclass;
 736
 737 DRIVER_MODULE(ast, ata, ast_driver, ast_devclass, NULL, NULL);
 738 MODULE_VERSION(ast, 1);
 739 MODULE_DEPEND(ast, ata, 1, 1, 1);