sys/dev/disk/ata/atapi-tape.c

   1 /*-
   2  * Copyright (c) 1998,1999,2000,2001,2002 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  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/dev/ata/atapi-tape.c,v 1.36.2.12 2002/07/31 11:19:26 sos Exp $
  29  * $DragonFly: src/sys/dev/disk/ata/atapi-tape.c,v 1.8 2003/11/30 20:14:18 dillon Exp $
  30  */
  31
  32 #include "opt_ata.h"
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/ata.h>
  36 #include <sys/kernel.h>
  37 #include <sys/conf.h>
  38 #include <sys/malloc.h>
  39 #include <sys/buf.h>
  40 #include <sys/bus.h>
  41 #include <sys/mtio.h>
  42 #include <sys/disklabel.h>
  43 #include <sys/devicestat.h>
  44 #include <sys/proc.h>
  45 #include <sys/buf2.h>
  46 #include "ata-all.h"
  47 #include "atapi-all.h"
  48 #include "atapi-tape.h"
  49
  50 /* device structures */
  51 static  d_open_t        astopen;
  52 static  d_close_t       astclose;
  53 static  d_ioctl_t       astioctl;
  54 static  d_strategy_t    aststrategy;
  55
  56 static struct cdevsw ast_cdevsw = {
  57         /* name */      "ast",
  58         /* maj */       119,
  59         /* flags */     D_TAPE | D_TRACKCLOSE,
  60         /* port */      NULL,
  61         /* autoq */     0,
  62
  63         /* open */      astopen,
  64         /* close */     astclose,
  65         /* read */      physread,
  66         /* write */     physwrite,
  67         /* ioctl */     astioctl,
  68         /* poll */      nopoll,
  69         /* mmap */      nommap,
  70         /* strategy */  aststrategy,
  71         /* dump */      nodump,
  72         /* psize */     nopsize
  73 };
  74
  75 /* prototypes */
  76 static int ast_sense(struct ast_softc *);
  77 static void ast_describe(struct ast_softc *);
  78 static int ast_done(struct atapi_request *);
  79 static int ast_mode_sense(struct ast_softc *, int, void *, int);
  80 static int ast_mode_select(struct ast_softc *, void *, int);
  81 static int ast_write_filemark(struct ast_softc *, u_int8_t);
  82 static int ast_read_position(struct ast_softc *, int, struct ast_readposition *);
  83 static int ast_space(struct ast_softc *, u_int8_t, int32_t);
  84 static int ast_locate(struct ast_softc *, int, u_int32_t);
  85 static int ast_prevent_allow(struct ast_softc *stp, int);
  86 static int ast_load_unload(struct ast_softc *, u_int8_t);
  87 static int ast_rewind(struct ast_softc *);
  88 static int ast_erase(struct ast_softc *);
  89
  90 /* internal vars */
  91 static u_int32_t ast_lun_map = 0;
  92 static u_int64_t ast_total = 0;
  93 static MALLOC_DEFINE(M_AST, "AST driver", "ATAPI tape driver buffers");
  94
  95 int
  96 astattach(struct ata_device *atadev)
  97 {
  98     struct ast_softc *stp;
  99     struct ast_readposition position;
 100     dev_t dev;
 101
 102     stp = malloc(sizeof(struct ast_softc), M_AST, M_WAITOK | M_ZERO);
 103     if (!stp) {
 104         ata_prtdev(atadev, "out of memory\n");
 105         return 0;
 106     }
 107
 108     stp->device = atadev;
 109     stp->lun = ata_get_lun(&ast_lun_map);
 110     ata_set_name(atadev, "ast", stp->lun);
 111     bufq_init(&stp->queue);
 112
 113     if (ast_sense(stp)) {
 114         free(stp, M_AST);
 115         return 0;
 116     }
 117
 118     if (!strcmp(atadev->param->model, "OnStream DI-30")) {
 119         struct ast_transferpage transfer;
 120         struct ast_identifypage identify;
 121
 122         stp->flags |= F_ONSTREAM;
 123         bzero(&transfer, sizeof(struct ast_transferpage));
 124         ast_mode_sense(stp, ATAPI_TAPE_TRANSFER_PAGE,
 125                        &transfer, sizeof(transfer));
 126         bzero(&identify, sizeof(struct ast_identifypage));
 127         ast_mode_sense(stp, ATAPI_TAPE_IDENTIFY_PAGE,
 128                        &identify, sizeof(identify));
 129         strncpy(identify.ident, "FBSD", 4);
 130         ast_mode_select(stp, &identify, sizeof(identify));
 131         ast_read_position(stp, 0, &position);
 132     }
 133
 134     devstat_add_entry(&stp->stats, "ast", stp->lun, DEV_BSIZE,
 135                       DEVSTAT_NO_ORDERED_TAGS,
 136                       DEVSTAT_TYPE_SEQUENTIAL | DEVSTAT_TYPE_IF_IDE,
 137                       DEVSTAT_PRIORITY_TAPE);
 138     dev = make_dev(&ast_cdevsw, dkmakeminor(stp->lun, 0, 0),
 139                    UID_ROOT, GID_OPERATOR, 0640, "ast%d", stp->lun);
 140     dev->si_drv1 = stp;
 141     dev->si_iosize_max = 256 * DEV_BSIZE;
 142     stp->dev1 = dev;
 143     dev = make_dev(&ast_cdevsw, dkmakeminor(stp->lun, 0, 1),
 144                    UID_ROOT, GID_OPERATOR, 0640, "nast%d", stp->lun);
 145     dev->si_drv1 = stp;
 146     dev->si_iosize_max = 256 * DEV_BSIZE;
 147     stp->dev2 = dev;
 148     stp->device->flags |= ATA_D_MEDIA_CHANGED;
 149     ast_describe(stp);
 150     atadev->driver = stp;
 151     return 1;
 152 }
 153
 154 void
 155 astdetach(struct ata_device *atadev)
 156 {
 157     struct ast_softc *stp = atadev->driver;
 158     struct buf *bp;
 159
 160     while ((bp = bufq_first(&stp->queue))) {
 161         bufq_remove(&stp->queue, bp);
 162         bp->b_flags |= B_ERROR;
 163         bp->b_error = ENXIO;
 164         biodone(bp);
 165     }
 166     destroy_dev(stp->dev1);
 167     destroy_dev(stp->dev2);
 168     devstat_remove_entry(&stp->stats);
 169     ata_free_name(atadev);
 170     ata_free_lun(&ast_lun_map, stp->lun);
 171     free(stp, M_AST);
 172     atadev->driver = NULL;
 173 }
 174
 175 static int
 176 ast_sense(struct ast_softc *stp)
 177 {
 178     int count, error = 0;
 179
 180     /* get drive capabilities, some drives needs this repeated */
 181     for (count = 0 ; count < 5 ; count++) {
 182         if (!(error = ast_mode_sense(stp, ATAPI_TAPE_CAP_PAGE,
 183                                      &stp->cap, sizeof(stp->cap)))) {
 184             if (stp->cap.blk32k)
 185                 stp->blksize = 32768;
 186             if (stp->cap.blk1024)
 187                 stp->blksize = 1024;
 188             if (stp->cap.blk512)
 189                 stp->blksize = 512;
 190             if (!stp->blksize)
 191                 continue;
 192             stp->cap.max_speed = ntohs(stp->cap.max_speed);
 193             stp->cap.max_defects = ntohs(stp->cap.max_defects);
 194             stp->cap.ctl = ntohs(stp->cap.ctl);
 195             stp->cap.speed = ntohs(stp->cap.speed);
 196             stp->cap.buffer_size = ntohs(stp->cap.buffer_size);
 197             return 0;
 198         }
 199     }
 200     return 1;
 201 }
 202
 203 static void
 204 ast_describe(struct ast_softc *stp)
 205 {
 206     if (bootverbose) {
 207         ata_prtdev(stp->device, "<%.40s/%.8s> tape drive at ata%d as %s\n",
 208                    stp->device->param->model, stp->device->param->revision,
 209                    device_get_unit(stp->device->channel->dev),
 210                    (stp->device->unit == ATA_MASTER) ? "master" : "slave");
 211         ata_prtdev(stp->device, "%dKB/s, ", stp->cap.max_speed);
 212         printf("transfer limit %d blk%s, ",
 213                stp->cap.ctl, (stp->cap.ctl > 1) ? "s" : "");
 214         printf("%dKB buffer, ", (stp->cap.buffer_size * DEV_BSIZE) / 1024);
 215         printf("%s\n", ata_mode2str(stp->device->mode));
 216         ata_prtdev(stp->device, "Medium: ");
 217         switch (stp->cap.medium_type) {
 218             case 0x00:
 219                 printf("none"); break;
 220             case 0x17:
 221                 printf("Travan 1 (400 Mbyte)"); break;
 222             case 0xb6:
 223                 printf("Travan 4 (4 Gbyte)"); break;
 224             case 0xda:
 225                 printf("OnStream ADR (15Gyte)"); break;
 226             default:
 227                 printf("unknown (0x%x)", stp->cap.medium_type);
 228         }
 229         if (stp->cap.readonly) printf(", readonly");
 230         if (stp->cap.reverse) printf(", reverse");
 231         if (stp->cap.eformat) printf(", eformat");
 232         if (stp->cap.qfa) printf(", qfa");
 233         if (stp->cap.lock) printf(", lock");
 234         if (stp->cap.locked) printf(", locked");
 235         if (stp->cap.prevent) printf(", prevent");
 236         if (stp->cap.eject) printf(", eject");
 237         if (stp->cap.disconnect) printf(", disconnect");
 238         if (stp->cap.ecc) printf(", ecc");
 239         if (stp->cap.compress) printf(", compress");
 240         if (stp->cap.blk512) printf(", 512b");
 241         if (stp->cap.blk1024) printf(", 1024b");
 242         if (stp->cap.blk32k) printf(", 32kb");
 243         printf("\n");
 244     }
 245     else {
 246         ata_prtdev(stp->device, "TAPE <%.40s> at ata%d-%s %s\n",
 247                    stp->device->param->model,
 248                    device_get_unit(stp->device->channel->dev),
 249                    (stp->device->unit == ATA_MASTER) ? "master" : "slave",
 250                    ata_mode2str(stp->device->mode));
 251     }
 252 }
 253
 254 static int
 255 astopen(dev_t dev, int flags, int fmt, struct thread *td)
 256 {
 257     struct ast_softc *stp = dev->si_drv1;
 258
 259     if (!stp)
 260         return ENXIO;
 261
 262     if (count_dev(dev) > 1)
 263         return EBUSY;
 264
 265     atapi_test_ready(stp->device);
 266
 267     if (stp->cap.lock)
 268         ast_prevent_allow(stp, 1);
 269
 270     if (ast_sense(stp))
 271         ata_prtdev(stp->device, "sense media type failed\n");
 272
 273     stp->device->flags &= ~ATA_D_MEDIA_CHANGED;
 274     stp->flags &= ~(F_DATA_WRITTEN | F_FM_WRITTEN);
 275     ast_total = 0;
 276     return 0;
 277 }
 278
 279 static int
 280 astclose(dev_t dev, int flags, int fmt, struct thread *td)
 281 {
 282     struct ast_softc *stp = dev->si_drv1;
 283
 284     /* flush buffers, some drives fail here, they should report ctl = 0 */
 285     if (stp->cap.ctl && (stp->flags & F_DATA_WRITTEN))
 286         ast_write_filemark(stp, 0);
 287
 288     /* write filemark if data written to tape */
 289     if (!(stp->flags & F_ONSTREAM) &&
 290         (stp->flags & (F_DATA_WRITTEN | F_FM_WRITTEN)) == F_DATA_WRITTEN)
 291         ast_write_filemark(stp, WF_WRITE);
 292
 293     /* if minor is even rewind on close */
 294     if (!(minor(dev) & 0x01))
 295         ast_rewind(stp);
 296
 297     if (stp->cap.lock && count_dev(dev) == 1)
 298         ast_prevent_allow(stp, 0);
 299
 300     stp->flags &= F_CTL_WARN;
 301 #ifdef AST_DEBUG
 302     ata_prtdev(stp->device, "%llu total bytes transferred\n", ast_total);
 303 #endif
 304     return 0;
 305 }
 306
 307 static int
 308 astioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
 309 {
 310     struct ast_softc *stp = dev->si_drv1;
 311     int error = 0;
 312
 313     switch (cmd) {
 314     case MTIOCGET:
 315         {
 316             struct mtget *g = (struct mtget *) addr;
 317
 318             bzero(g, sizeof(struct mtget));
 319             g->mt_type = 7;
 320             g->mt_density = 1;
 321             g->mt_blksiz = stp->blksize;
 322             g->mt_comp = stp->cap.compress;
 323             g->mt_density0 = 0; g->mt_density1 = 0;
 324             g->mt_density2 = 0; g->mt_density3 = 0;
 325             g->mt_blksiz0 = 0; g->mt_blksiz1 = 0;
 326             g->mt_blksiz2 = 0; g->mt_blksiz3 = 0;
 327             g->mt_comp0 = 0; g->mt_comp1 = 0;
 328             g->mt_comp2 = 0; g->mt_comp3 = 0;
 329             break;
 330         }
 331     case MTIOCTOP:
 332         {
 333             int i;
 334             struct mtop *mt = (struct mtop *)addr;
 335
 336             switch ((int16_t) (mt->mt_op)) {
 337
 338             case MTWEOF:
 339                 for (i=0; i < mt->mt_count && !error; i++)
 340                     error = ast_write_filemark(stp, WF_WRITE);
 341                 break;
 342
 343             case MTFSF:
 344                 if (mt->mt_count)
 345                     error = ast_space(stp, SP_FM, mt->mt_count);
 346                 break;
 347
 348             case MTBSF:
 349                 if (mt->mt_count)
 350                     error = ast_space(stp, SP_FM, -(mt->mt_count));
 351                 break;
 352
 353             case MTREW:
 354                 error = ast_rewind(stp);
 355                 break;
 356
 357             case MTOFFL:
 358                 error = ast_load_unload(stp, SS_EJECT);
 359                 break;
 360
 361             case MTNOP:
 362                 error = ast_write_filemark(stp, 0);
 363                 break;
 364
 365             case MTERASE:
 366                 error = ast_erase(stp);
 367                 break;
 368
 369             case MTEOD:
 370                 error = ast_space(stp, SP_EOD, 0);
 371                 break;
 372
 373             case MTRETENS:
 374                 error = ast_load_unload(stp, SS_RETENSION | SS_LOAD);
 375                 break;
 376
 377             case MTFSR:
 378             case MTBSR:
 379             case MTCACHE:
 380             case MTNOCACHE:
 381             case MTSETBSIZ:
 382             case MTSETDNSTY:
 383             case MTCOMP:
 384             default:
 385                 error = EINVAL;
 386             }
 387             break;
 388         }
 389     case MTIOCRDSPOS:
 390         {
 391             struct ast_readposition position;
 392
 393             if ((error = ast_read_position(stp, 0, &position)))
 394                 break;
 395             *(u_int32_t *)addr = position.tape;
 396             break;
 397         }
 398     case MTIOCRDHPOS:
 399         {
 400             struct ast_readposition position;
 401
 402             if ((error = ast_read_position(stp, 1, &position)))
 403                 break;
 404             *(u_int32_t *)addr = position.tape;
 405             break;
 406         }
 407     case MTIOCSLOCATE:
 408         error = ast_locate(stp, 0, *(u_int32_t *)addr);
 409         break;
 410     case MTIOCHLOCATE:
 411         error = ast_locate(stp, 1, *(u_int32_t *)addr);
 412         break;
 413     default:
 414         error = ENOTTY;
 415     }
 416     return error;
 417 }
 418
 419 static void
 420 aststrategy(struct buf *bp)
 421 {
 422     struct ast_softc *stp = bp->b_dev->si_drv1;
 423     int s;
 424
 425     if (stp->device->flags & ATA_D_DETACHING) {
 426         bp->b_flags |= B_ERROR;
 427         bp->b_error = ENXIO;
 428         biodone(bp);
 429         return;
 430     }
 431
 432     /* if it's a null transfer, return immediatly. */
 433     if (bp->b_bcount == 0) {
 434         bp->b_resid = 0;
 435         biodone(bp);
 436         return;
 437     }
 438     if (!(bp->b_flags & B_READ) && stp->flags & F_WRITEPROTECT) {
 439         bp->b_flags |= B_ERROR;
 440         bp->b_error = EPERM;
 441         biodone(bp);
 442         return;
 443     }
 444
 445     /* check for != blocksize requests */
 446     if (bp->b_bcount % stp->blksize) {
 447         ata_prtdev(stp->device, "transfers must be multiple of %d\n",
 448                    stp->blksize);
 449         bp->b_flags |= B_ERROR;
 450         bp->b_error = EIO;
 451         biodone(bp);
 452         return;
 453     }
 454
 455     /* warn about transfers bigger than the device suggests */
 456     if (bp->b_bcount > stp->blksize * stp->cap.ctl) {
 457         if ((stp->flags & F_CTL_WARN) == 0) {
 458             ata_prtdev(stp->device, "WARNING: CTL exceeded %ld>%d\n",
 459                        bp->b_bcount, stp->blksize * stp->cap.ctl);
 460             stp->flags |= F_CTL_WARN;
 461         }
 462     }
 463
 464     s = splbio();
 465     bufq_insert_tail(&stp->queue, bp);
 466     splx(s);
 467     ata_start(stp->device->channel);
 468 }
 469
 470 void
 471 ast_start(struct ata_device *atadev)
 472 {
 473     struct ast_softc *stp = atadev->driver;
 474     struct buf *bp = bufq_first(&stp->queue);
 475     u_int32_t blkcount;
 476     int8_t ccb[16];
 477
 478     if (!bp)
 479         return;
 480
 481     bzero(ccb, sizeof(ccb));
 482
 483     if (bp->b_flags & B_READ)
 484         ccb[0] = ATAPI_READ;
 485     else
 486         ccb[0] = ATAPI_WRITE;
 487
 488     bufq_remove(&stp->queue, bp);
 489     blkcount = bp->b_bcount / stp->blksize;
 490
 491     ccb[1] = 1;
 492     ccb[2] = blkcount>>16;
 493     ccb[3] = blkcount>>8;
 494     ccb[4] = blkcount;
 495
 496     devstat_start_transaction(&stp->stats);
 497
 498     atapi_queue_cmd(stp->device, ccb, bp->b_data, blkcount * stp->blksize,
 499                     (bp->b_flags & B_READ) ? ATPR_F_READ : 0,
 500                     120, ast_done, bp);
 501 }
 502
 503 static int
 504 ast_done(struct atapi_request *request)
 505 {
 506     struct buf *bp = request->driver;
 507     struct ast_softc *stp = request->device->driver;
 508
 509     if (request->error) {
 510         bp->b_error = request->error;
 511         bp->b_flags |= B_ERROR;
 512     }
 513     else {
 514         if (!(bp->b_flags & B_READ))
 515             stp->flags |= F_DATA_WRITTEN;
 516         bp->b_resid = bp->b_bcount - request->donecount;
 517         ast_total += (bp->b_bcount - bp->b_resid);
 518     }
 519     devstat_end_transaction_buf(&stp->stats, bp);
 520     biodone(bp);
 521     return 0;
 522 }
 523
 524 static int
 525 ast_mode_sense(struct ast_softc *stp, int page, void *pagebuf, int pagesize)
 526 {
 527     int8_t ccb[16] = { ATAPI_MODE_SENSE, 0x08, page, pagesize>>8, pagesize,
 528                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 529     int error;
 530
 531     error = atapi_queue_cmd(stp->device, ccb, pagebuf, pagesize, ATPR_F_READ,
 532                             10, NULL, NULL);
 533 #ifdef AST_DEBUG
 534     atapi_dump("ast: mode sense ", pagebuf, pagesize);
 535 #endif
 536     return error;
 537 }
 538
 539 static int
 540 ast_mode_select(struct ast_softc *stp, void *pagebuf, int pagesize)
 541 {
 542     int8_t ccb[16] = { ATAPI_MODE_SELECT, 0x10, 0, pagesize>>8, pagesize,
 543                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 544
 545 #ifdef AST_DEBUG
 546     ata_prtdev(stp->device, "modeselect pagesize=%d\n", pagesize);
 547     atapi_dump("mode select ", pagebuf, pagesize);
 548 #endif
 549     return atapi_queue_cmd(stp->device, ccb, pagebuf, pagesize, 0,
 550                            10, NULL, NULL);
 551 }
 552
 553 static int
 554 ast_write_filemark(struct ast_softc *stp, u_int8_t function)
 555 {
 556     int8_t ccb[16] = { ATAPI_WEOF, 0x01, 0, 0, function, 0, 0, 0,
 557                        0, 0, 0, 0, 0, 0, 0, 0 };
 558     int error;
 559
 560     if (stp->flags & F_ONSTREAM)
 561         ccb[4] = 0x00;          /* only flush buffers supported */
 562     else {
 563         if (function) {
 564             if (stp->flags & F_FM_WRITTEN)
 565                 stp->flags &= ~F_DATA_WRITTEN;
 566             else
 567                 stp->flags |= F_FM_WRITTEN;
 568         }
 569     }
 570     error = atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 10, NULL, NULL);
 571     if (error)
 572         return error;
 573     return atapi_wait_dsc(stp->device, 10*60);
 574 }
 575
 576 static int
 577 ast_read_position(struct ast_softc *stp, int hard,
 578                   struct ast_readposition *position)
 579 {
 580     int8_t ccb[16] = { ATAPI_READ_POSITION, (hard ? 0x01 : 0), 0, 0, 0, 0, 0, 0,
 581                        0, 0, 0, 0, 0, 0, 0, 0 };
 582     int error;
 583
 584     error = atapi_queue_cmd(stp->device, ccb, (caddr_t)position,
 585                             sizeof(struct ast_readposition), ATPR_F_READ, 10,
 586                             NULL, NULL);
 587     position->tape = ntohl(position->tape);
 588     position->host = ntohl(position->host);
 589     return error;
 590 }
 591
 592 static int
 593 ast_space(struct ast_softc *stp, u_int8_t function, int32_t count)
 594 {
 595     int8_t ccb[16] = { ATAPI_SPACE, function, count>>16, count>>8, count,
 596                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 597
 598     return atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 60*60, NULL, NULL);
 599 }
 600
 601 static int
 602 ast_locate(struct ast_softc *stp, int hard, u_int32_t pos)
 603 {
 604     int8_t ccb[16] = { ATAPI_LOCATE, 0x01 | (hard ? 0x4 : 0), 0,
 605                        pos>>24, pos>>16, pos>>8, pos,
 606                        0, 0, 0, 0, 0, 0, 0, 0, 0 };
 607     int error;
 608
 609     error = atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 10, NULL, NULL);
 610     if (error)
 611         return error;
 612     return atapi_wait_dsc(stp->device, 60*60);
 613 }
 614
 615 static int
 616 ast_prevent_allow(struct ast_softc *stp, int lock)
 617 {
 618     int8_t ccb[16] = { ATAPI_PREVENT_ALLOW, 0, 0, 0, lock,
 619                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 620
 621     return atapi_queue_cmd(stp->device, ccb, NULL, 0, 0,30, NULL, NULL);
 622 }
 623
 624 static int
 625 ast_load_unload(struct ast_softc *stp, u_int8_t function)
 626 {
 627     int8_t ccb[16] = { ATAPI_START_STOP, 0x01, 0, 0, function, 0, 0, 0,
 628                        0, 0, 0, 0, 0, 0, 0, 0 };
 629     int error;
 630
 631     if ((function & SS_EJECT) && !stp->cap.eject)
 632         return 0;
 633     error = atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 10, NULL, NULL);
 634     if (error)
 635         return error;
 636     tsleep((caddr_t)&error, 0, "astlu", 1 * hz);
 637     if (function == SS_EJECT)
 638         return 0;
 639     return atapi_wait_dsc(stp->device, 60*60);
 640 }
 641
 642 static int
 643 ast_rewind(struct ast_softc *stp)
 644 {
 645     int8_t ccb[16] = { ATAPI_REZERO, 0x01, 0, 0, 0, 0, 0, 0,
 646                        0, 0, 0, 0, 0, 0, 0, 0 };
 647     int error;
 648
 649     error = atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 10, NULL, NULL);
 650     if (error)
 651         return error;
 652     return atapi_wait_dsc(stp->device, 60*60);
 653 }
 654
 655 static int
 656 ast_erase(struct ast_softc *stp)
 657 {
 658     int8_t ccb[16] = { ATAPI_ERASE, 3, 0, 0, 0, 0, 0, 0,
 659                        0, 0, 0, 0, 0, 0, 0, 0 };
 660     int error;
 661
 662     if ((error = ast_rewind(stp)))
 663         return error;
 664
 665     return atapi_queue_cmd(stp->device, ccb, NULL, 0, 0, 60*60, NULL, NULL);
 666 }