sys/dev/ata/atapi-cd.c

   1 /*-
   2  * Copyright (c) 1998 - 2007 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/priv.h>
  38 #include <sys/proc.h>
  39 #include <sys/bio.h>
  40 #include <sys/bus.h>
  41 #include <sys/cdio.h>
  42 #include <sys/cdrio.h>
  43 #include <sys/dvdio.h>
  44 #include <sys/disk.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/conf.h>
  47 #include <sys/ctype.h>
  48 #include <sys/sema.h>
  49 #include <sys/taskqueue.h>
  50 #include <vm/uma.h>
  51 #include <machine/bus.h>
  52 #include <geom/geom.h>
  53 #include <dev/ata/ata-all.h>
  54 #include <dev/ata/atapi-cd.h>
  55 #include <ata_if.h>
  56
  57 /* prototypes */
  58 static void acd_geom_attach(void *, int);
  59 static void acd_geom_detach(void *, int);
  60 static void acd_set_ioparm(device_t);
  61 static void acd_describe(device_t);
  62 static void lba2msf(u_int32_t, u_int8_t *, u_int8_t *, u_int8_t *);
  63 static u_int32_t msf2lba(u_int8_t, u_int8_t, u_int8_t);
  64 static int acd_geom_access(struct g_provider *, int, int, int);
  65 static g_ioctl_t acd_geom_ioctl;
  66 static void acd_geom_start(struct bio *);
  67 static void acd_strategy(struct bio *);
  68 static void acd_done(struct ata_request *);
  69 static void acd_read_toc(device_t);
  70 static int acd_play(device_t, int, int);
  71 static int acd_setchan(device_t, u_int8_t, u_int8_t, u_int8_t, u_int8_t);
  72 static int acd_init_writer(device_t, int);
  73 static int acd_fixate(device_t, int);
  74 static int acd_init_track(device_t, struct cdr_track *);
  75 static int acd_flush(device_t);
  76 static int acd_read_track_info(device_t, int32_t, struct acd_track_info *);
  77 static int acd_get_progress(device_t, int *);
  78 static int acd_send_cue(device_t, struct cdr_cuesheet *);
  79 static int acd_report_key(device_t, struct dvd_authinfo *);
  80 static int acd_send_key(device_t, struct dvd_authinfo *);
  81 static int acd_read_structure(device_t, struct dvd_struct *);
  82 static int acd_tray(device_t, int);
  83 static int acd_blank(device_t, int);
  84 static int acd_prevent_allow(device_t, int);
  85 static int acd_start_stop(device_t, int);
  86 static int acd_pause_resume(device_t, int);
  87 static int acd_mode_sense(device_t, int, caddr_t, int);
  88 static int acd_mode_select(device_t, caddr_t, int);
  89 static int acd_set_speed(device_t, int, int);
  90 static void acd_get_cap(device_t);
  91 static int acd_read_format_caps(device_t, struct cdr_format_capacities *);
  92 static int acd_format(device_t, struct cdr_format_params *);
  93 static int acd_test_ready(device_t);
  94
  95 /* internal vars */
  96 static MALLOC_DEFINE(M_ACD, "acd_driver", "ATAPI CD driver buffers");
  97 static struct g_class acd_class = {
  98         .name = "ACD",
  99         .version = G_VERSION,
 100         .access = acd_geom_access,
 101         .ioctl = acd_geom_ioctl,
 102         .start = acd_geom_start,
 103 };
 104 //DECLARE_GEOM_CLASS(acd_class, acd);
 105
 106 static int
 107 acd_probe(device_t dev)
 108 {
 109     struct ata_device *atadev = device_get_softc(dev);
 110
 111     if ((atadev->param.config & ATA_PROTO_ATAPI) &&
 112         (atadev->param.config & ATA_ATAPI_TYPE_MASK) == ATA_ATAPI_TYPE_CDROM)
 113         return 0;
 114     else
 115         return ENXIO;
 116 }
 117
 118 static int
 119 acd_attach(device_t dev)
 120 {
 121     struct acd_softc *cdp;
 122
 123     if (!(cdp = malloc(sizeof(struct acd_softc), M_ACD, M_NOWAIT | M_ZERO))) {
 124         device_printf(dev, "out of memory\n");
 125         return ENOMEM;
 126     }
 127     cdp->block_size = 2048;
 128     device_set_ivars(dev, cdp);
 129     ATA_SETMODE(device_get_parent(dev), dev);
 130     ata_controlcmd(dev, ATA_DEVICE_RESET, 0, 0, 0);
 131     acd_get_cap(dev);
 132     g_post_event(acd_geom_attach, dev, M_WAITOK, NULL);
 133
 134     /* announce we are here */
 135     acd_describe(dev);
 136     return 0;
 137 }
 138
 139 static int
 140 acd_detach(device_t dev)
 141 {
 142     g_waitfor_event(acd_geom_detach, dev, M_WAITOK, NULL);
 143     return 0;
 144 }
 145
 146 static void
 147 acd_shutdown(device_t dev)
 148 {
 149     struct ata_device *atadev = device_get_softc(dev);
 150
 151     if (atadev->param.support.command2 & ATA_SUPPORT_FLUSHCACHE)
 152         ata_controlcmd(dev, ATA_FLUSHCACHE, 0, 0, 0);
 153 }
 154
 155 static int
 156 acd_reinit(device_t dev)
 157 {
 158     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
 159     struct ata_device *atadev = device_get_softc(dev);
 160
 161     if (((atadev->unit == ATA_MASTER) && !(ch->devices & ATA_ATAPI_MASTER)) ||
 162         ((atadev->unit == ATA_SLAVE) && !(ch->devices & ATA_ATAPI_SLAVE))) {
 163         return 1;
 164     }
 165     ATA_SETMODE(device_get_parent(dev), dev);
 166     return 0;
 167 }
 168
 169 static void
 170 acd_geom_attach(void *arg, int flag)
 171 {
 172     struct ata_device *atadev = device_get_softc(arg);
 173     struct acd_softc *cdp = device_get_ivars(arg);
 174     struct g_geom *gp;
 175     struct g_provider *pp;
 176
 177     g_topology_assert();
 178     gp = g_new_geomf(&acd_class, "acd%d", device_get_unit(arg));
 179     gp->softc = arg;
 180     cdp->gp = gp;
 181     pp = g_new_providerf(gp, "acd%d", device_get_unit(arg));
 182     pp->index = 0;
 183     cdp->pp[0] = pp;
 184     g_error_provider(pp, 0);
 185     atadev->flags |= ATA_D_MEDIA_CHANGED;
 186     acd_set_ioparm(arg);
 187 }
 188
 189 static void
 190 acd_geom_detach(void *arg, int flag)
 191 {
 192     struct acd_softc *cdp = device_get_ivars(arg);
 193
 194     /* signal geom so we dont get any further requests */
 195     g_wither_geom(cdp->gp, ENXIO);
 196
 197     /* fail requests on the queue and any thats "in flight" for this device */
 198     ata_fail_requests(arg);
 199
 200     /* dont leave anything behind */
 201     device_set_ivars(arg, NULL);
 202     free(cdp, M_ACD);
 203 }
 204
 205 static int
 206 acd_geom_ioctl(struct g_provider *pp, u_long cmd, void *addr, int fflag, struct thread *td)
 207 {
 208     device_t dev = pp->geom->softc;
 209     struct ata_device *atadev = device_get_softc(dev);
 210     struct acd_softc *cdp = device_get_ivars(dev);
 211     int error = 0, nocopyout = 0;
 212
 213     if (!cdp)
 214         return ENXIO;
 215
 216     if (atadev->flags & ATA_D_MEDIA_CHANGED) {
 217         switch (cmd) {
 218         case CDIOCRESET:
 219             acd_test_ready(dev);
 220             break;
 221
 222         case DIOCGPROVIDERALIAS:
 223             break;
 224
 225         default:
 226             acd_read_toc(dev);
 227             acd_prevent_allow(dev, 1);
 228             cdp->flags |= F_LOCKED;
 229             break;
 230         }
 231     }
 232
 233     switch (cmd) {
 234
 235     case CDIOCRESUME:
 236         error = acd_pause_resume(dev, 1);
 237         break;
 238
 239     case CDIOCPAUSE:
 240         error = acd_pause_resume(dev, 0);
 241         break;
 242
 243     case CDIOCSTART:
 244         error = acd_start_stop(dev, 1);
 245         break;
 246
 247     case CDIOCSTOP:
 248         error = acd_start_stop(dev, 0);
 249         break;
 250
 251     case CDIOCALLOW:
 252         error = acd_prevent_allow(dev, 0);
 253         cdp->flags &= ~F_LOCKED;
 254         break;
 255
 256     case CDIOCPREVENT:
 257         error = acd_prevent_allow(dev, 1);
 258         cdp->flags |= F_LOCKED;
 259         break;
 260
 261     /*
 262      * XXXRW: Why does this require privilege?
 263      */
 264     case CDIOCRESET:
 265         error = priv_check(td, PRIV_DRIVER);
 266         if (error)
 267             break;
 268         error = acd_test_ready(dev);
 269         break;
 270
 271     case CDIOCEJECT:
 272         if (pp->acr != 1) {
 273             error = EBUSY;
 274             break;
 275         }
 276         error = acd_tray(dev, 0);
 277         break;
 278
 279     case CDIOCCLOSE:
 280         if (pp->acr != 1)
 281             break;
 282         error = acd_tray(dev, 1);
 283         break;
 284
 285     case CDIOREADTOCHEADER:
 286         if (!cdp->toc.hdr.ending_track) {
 287             error = EIO;
 288             break;
 289         }
 290         bcopy(&cdp->toc.hdr, addr, sizeof(cdp->toc.hdr));
 291         break;
 292
 293     case CDIOREADTOCENTRYS:
 294         {
 295             struct ioc_read_toc_entry *te = (struct ioc_read_toc_entry *)addr;
 296             struct toc *toc = &cdp->toc;
 297             int starting_track = te->starting_track;
 298             int len;
 299
 300             if (!toc->hdr.ending_track) {
 301                 error = EIO;
 302                 break;
 303             }
 304
 305             if (te->data_len < sizeof(toc->tab[0]) ||
 306                 (te->data_len % sizeof(toc->tab[0])) != 0 ||
 307                 (te->address_format != CD_MSF_FORMAT &&
 308                 te->address_format != CD_LBA_FORMAT)) {
 309                 error = EINVAL;
 310                 break;
 311             }
 312
 313             if (!starting_track)
 314                 starting_track = toc->hdr.starting_track;
 315             else if (starting_track == 170)
 316                 starting_track = toc->hdr.ending_track + 1;
 317             else if (starting_track < toc->hdr.starting_track ||
 318                      starting_track > toc->hdr.ending_track + 1) {
 319                 error = EINVAL;
 320                 break;
 321             }
 322
 323             len = ((toc->hdr.ending_track + 1 - starting_track) + 1) *
 324                   sizeof(toc->tab[0]);
 325             if (te->data_len < len)
 326                 len = te->data_len;
 327             if (len > sizeof(toc->tab)) {
 328                 error = EINVAL;
 329                 break;
 330             }
 331
 332             if (te->address_format == CD_MSF_FORMAT) {
 333                 struct cd_toc_entry *entry;
 334
 335                 if (!(toc = malloc(sizeof(struct toc), M_ACD, M_NOWAIT))) {
 336                     error = ENOMEM;
 337                     break;
 338                 }
 339                 bcopy(&cdp->toc, toc, sizeof(struct toc));
 340                 entry = toc->tab + (toc->hdr.ending_track + 1 -
 341                         toc->hdr.starting_track) + 1;
 342                 while (--entry >= toc->tab) {
 343                     lba2msf(ntohl(entry->addr.lba), &entry->addr.msf.minute,
 344                             &entry->addr.msf.second, &entry->addr.msf.frame);
 345                     entry->addr_type = CD_MSF_FORMAT;
 346                 }
 347             }
 348             error = copyout(toc->tab + starting_track - toc->hdr.starting_track,
 349                             te->data, len);
 350             if (te->address_format == CD_MSF_FORMAT)
 351                 free(toc, M_ACD);
 352         }
 353         break;
 354
 355     case CDIOREADTOCENTRY:
 356         {
 357             struct ioc_read_toc_single_entry *te =
 358                 (struct ioc_read_toc_single_entry *)addr;
 359             struct toc *toc = &cdp->toc;
 360             u_char track = te->track;
 361
 362             if (!toc->hdr.ending_track) {
 363                 error = EIO;
 364                 break;
 365             }
 366
 367             if (te->address_format != CD_MSF_FORMAT &&
 368                 te->address_format != CD_LBA_FORMAT) {
 369                 error = EINVAL;
 370                 break;
 371             }
 372
 373             if (!track)
 374                 track = toc->hdr.starting_track;
 375             else if (track == 170)
 376                 track = toc->hdr.ending_track + 1;
 377             else if (track < toc->hdr.starting_track ||
 378                      track > toc->hdr.ending_track + 1) {
 379                 error = EINVAL;
 380                 break;
 381             }
 382
 383             if (te->address_format == CD_MSF_FORMAT) {
 384                 struct cd_toc_entry *entry;
 385
 386                 if (!(toc = malloc(sizeof(struct toc), M_ACD, M_NOWAIT))) {
 387                     error = ENOMEM;
 388                     break;
 389                 }
 390                 bcopy(&cdp->toc, toc, sizeof(struct toc));
 391                 entry = toc->tab + (track - toc->hdr.starting_track);
 392                 lba2msf(ntohl(entry->addr.lba), &entry->addr.msf.minute,
 393                         &entry->addr.msf.second, &entry->addr.msf.frame);
 394             }
 395             bcopy(toc->tab + track - toc->hdr.starting_track,
 396                   &te->entry, sizeof(struct cd_toc_entry));
 397             if (te->address_format == CD_MSF_FORMAT)
 398                 free(toc, M_ACD);
 399         }
 400         break;
 401
 402 #if __FreeBSD_version > 600008
 403     case CDIOCREADSUBCHANNEL_SYSSPACE:
 404         nocopyout = 1;
 405         /* FALLTHROUGH */
 406
 407 #endif
 408     case CDIOCREADSUBCHANNEL:
 409         {
 410             struct ioc_read_subchannel *args =
 411                 (struct ioc_read_subchannel *)addr;
 412             u_int8_t format;
 413             int8_t ccb[16] = { ATAPI_READ_SUBCHANNEL, 0, 0x40, 1, 0, 0, 0,
 414                                sizeof(cdp->subchan)>>8, sizeof(cdp->subchan),
 415                                0, 0, 0, 0, 0, 0, 0 };
 416
 417             if (args->data_len > sizeof(struct cd_sub_channel_info) ||
 418                 args->data_len < sizeof(struct cd_sub_channel_header)) {
 419                 error = EINVAL;
 420                 break;
 421             }
 422
 423             format = args->data_format;
 424             if ((format != CD_CURRENT_POSITION) &&
 425                 (format != CD_MEDIA_CATALOG) && (format != CD_TRACK_INFO)) {
 426                 error = EINVAL;
 427                 break;
 428             }
 429
 430             ccb[1] = args->address_format & CD_MSF_FORMAT;
 431
 432             if ((error = ata_atapicmd(dev, ccb, (caddr_t)&cdp->subchan,
 433                                       sizeof(cdp->subchan), ATA_R_READ, 10)))
 434                 break;
 435
 436             if ((format == CD_MEDIA_CATALOG) || (format == CD_TRACK_INFO)) {
 437                 if (cdp->subchan.header.audio_status == 0x11) {
 438                     error = EINVAL;
 439                     break;
 440                 }
 441
 442                 ccb[3] = format;
 443                 if (format == CD_TRACK_INFO)
 444                     ccb[6] = args->track;
 445
 446                 if ((error = ata_atapicmd(dev, ccb, (caddr_t)&cdp->subchan,
 447                                           sizeof(cdp->subchan),ATA_R_READ,10))){
 448                     break;
 449                 }
 450             }
 451             if (nocopyout == 0) {
 452                 error = copyout(&cdp->subchan, args->data, args->data_len);
 453             } else {
 454                 error = 0;
 455                 bcopy(&cdp->subchan, args->data, args->data_len);
 456             }
 457         }
 458         break;
 459
 460     case CDIOCPLAYMSF:
 461         {
 462             struct ioc_play_msf *args = (struct ioc_play_msf *)addr;
 463
 464             error =
 465                 acd_play(dev,
 466                          msf2lba(args->start_m, args->start_s, args->start_f),
 467                          msf2lba(args->end_m, args->end_s, args->end_f));
 468         }
 469         break;
 470
 471     case CDIOCPLAYBLOCKS:
 472         {
 473             struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr;
 474
 475             error = acd_play(dev, args->blk, args->blk + args->len);
 476         }
 477         break;
 478
 479     case CDIOCPLAYTRACKS:
 480         {
 481             struct ioc_play_track *args = (struct ioc_play_track *)addr;
 482             int t1, t2;
 483
 484             if (!cdp->toc.hdr.ending_track) {
 485                 error = EIO;
 486                 break;
 487             }
 488             if (args->end_track < cdp->toc.hdr.ending_track + 1)
 489                 ++args->end_track;
 490             if (args->end_track > cdp->toc.hdr.ending_track + 1)
 491                 args->end_track = cdp->toc.hdr.ending_track + 1;
 492             t1 = args->start_track - cdp->toc.hdr.starting_track;
 493             t2 = args->end_track - cdp->toc.hdr.starting_track;
 494             if (t1 < 0 || t2 < 0 ||
 495                 t1 > (cdp->toc.hdr.ending_track-cdp->toc.hdr.starting_track)) {
 496                 error = EINVAL;
 497                 break;
 498             }
 499             error = acd_play(dev, ntohl(cdp->toc.tab[t1].addr.lba),
 500                              ntohl(cdp->toc.tab[t2].addr.lba));
 501         }
 502         break;
 503
 504     case CDIOCGETVOL:
 505         {
 506             struct ioc_vol *arg = (struct ioc_vol *)addr;
 507
 508             if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE,
 509                                         (caddr_t)&cdp->au, sizeof(cdp->au))))
 510                 break;
 511
 512             if (cdp->au.page_code != ATAPI_CDROM_AUDIO_PAGE) {
 513                 error = EIO;
 514                 break;
 515             }
 516             arg->vol[0] = cdp->au.port[0].volume;
 517             arg->vol[1] = cdp->au.port[1].volume;
 518             arg->vol[2] = cdp->au.port[2].volume;
 519             arg->vol[3] = cdp->au.port[3].volume;
 520         }
 521         break;
 522
 523     case CDIOCSETVOL:
 524         {
 525             struct ioc_vol *arg = (struct ioc_vol *)addr;
 526
 527             if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE,
 528                                         (caddr_t)&cdp->au, sizeof(cdp->au))))
 529                 break;
 530             if (cdp->au.page_code != ATAPI_CDROM_AUDIO_PAGE) {
 531                 error = EIO;
 532                 break;
 533             }
 534             if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE_MASK,
 535                                         (caddr_t)&cdp->aumask,
 536                                         sizeof(cdp->aumask))))
 537                 break;
 538             cdp->au.data_length = 0;
 539             cdp->au.port[0].channels = CHANNEL_0;
 540             cdp->au.port[1].channels = CHANNEL_1;
 541             cdp->au.port[0].volume = arg->vol[0] & cdp->aumask.port[0].volume;
 542             cdp->au.port[1].volume = arg->vol[1] & cdp->aumask.port[1].volume;
 543             cdp->au.port[2].volume = arg->vol[2] & cdp->aumask.port[2].volume;
 544             cdp->au.port[3].volume = arg->vol[3] & cdp->aumask.port[3].volume;
 545             error =  acd_mode_select(dev, (caddr_t)&cdp->au, sizeof(cdp->au));
 546         }
 547         break;
 548
 549     case CDIOCSETPATCH:
 550         {
 551             struct ioc_patch *arg = (struct ioc_patch *)addr;
 552
 553             error = acd_setchan(dev, arg->patch[0], arg->patch[1],
 554                                 arg->patch[2], arg->patch[3]);
 555         }
 556         break;
 557
 558     case CDIOCSETMONO:
 559         error = acd_setchan(dev, CHANNEL_0|CHANNEL_1, CHANNEL_0|CHANNEL_1, 0,0);
 560         break;
 561
 562     case CDIOCSETSTEREO:
 563         error = acd_setchan(dev, CHANNEL_0, CHANNEL_1, 0, 0);
 564         break;
 565
 566     case CDIOCSETMUTE:
 567         error = acd_setchan(dev, 0, 0, 0, 0);
 568         break;
 569
 570     case CDIOCSETLEFT:
 571         error = acd_setchan(dev, CHANNEL_0, CHANNEL_0, 0, 0);
 572         break;
 573
 574     case CDIOCSETRIGHT:
 575         error = acd_setchan(dev, CHANNEL_1, CHANNEL_1, 0, 0);
 576         break;
 577
 578     case CDRIOCBLANK:
 579         error = acd_blank(dev, (*(int *)addr));
 580         break;
 581
 582     case CDRIOCNEXTWRITEABLEADDR:
 583         {
 584             struct acd_track_info track_info;
 585
 586             if ((error = acd_read_track_info(dev, 0xff, &track_info)))
 587                 break;
 588
 589             if (!track_info.nwa_valid) {
 590                 error = EINVAL;
 591                 break;
 592             }
 593             *(int*)addr = track_info.next_writeable_addr;
 594         }
 595         break;
 596
 597     case CDRIOCINITWRITER:
 598         error = acd_init_writer(dev, (*(int *)addr));
 599         break;
 600
 601     case CDRIOCINITTRACK:
 602         error = acd_init_track(dev, (struct cdr_track *)addr);
 603         break;
 604
 605     case CDRIOCFLUSH:
 606         error = acd_flush(dev);
 607         break;
 608
 609     case CDRIOCFIXATE:
 610         error = acd_fixate(dev, (*(int *)addr));
 611         break;
 612
 613     case CDRIOCREADSPEED:
 614         {
 615             int speed = *(int *)addr;
 616
 617             /* Preserve old behavior: units in multiples of CDROM speed */
 618             if (speed < 177)
 619                 speed *= 177;
 620             error = acd_set_speed(dev, speed, CDR_MAX_SPEED);
 621         }
 622         break;
 623
 624     case CDRIOCWRITESPEED:
 625         {
 626             int speed = *(int *)addr;
 627
 628             if (speed < 177)
 629                 speed *= 177;
 630             error = acd_set_speed(dev, CDR_MAX_SPEED, speed);
 631         }
 632         break;
 633
 634     case CDRIOCGETBLOCKSIZE:
 635         *(int *)addr = cdp->block_size;
 636         break;
 637
 638     case CDRIOCSETBLOCKSIZE:
 639         cdp->block_size = *(int *)addr;
 640         pp->sectorsize = cdp->block_size;       /* hack for GEOM SOS */
 641         acd_set_ioparm(dev);
 642         break;
 643
 644     case CDRIOCGETPROGRESS:
 645         error = acd_get_progress(dev, (int *)addr);
 646         break;
 647
 648     case CDRIOCSENDCUE:
 649         error = acd_send_cue(dev, (struct cdr_cuesheet *)addr);
 650         break;
 651
 652     case CDRIOCREADFORMATCAPS:
 653         error = acd_read_format_caps(dev, (struct cdr_format_capacities *)addr);
 654         break;
 655
 656     case CDRIOCFORMAT:
 657         error = acd_format(dev, (struct cdr_format_params *)addr);
 658         break;
 659
 660     case DVDIOCREPORTKEY:
 661         if (cdp->cap.media & MST_READ_DVDROM)
 662             error = acd_report_key(dev, (struct dvd_authinfo *)addr);
 663         else
 664             error = EINVAL;
 665         break;
 666
 667     case DVDIOCSENDKEY:
 668         if (cdp->cap.media & MST_READ_DVDROM)
 669             error = acd_send_key(dev, (struct dvd_authinfo *)addr);
 670         else
 671             error = EINVAL;
 672         break;
 673
 674     case DVDIOCREADSTRUCTURE:
 675         if (cdp->cap.media & MST_READ_DVDROM)
 676             error = acd_read_structure(dev, (struct dvd_struct *)addr);
 677         else
 678             error = EINVAL;
 679         break;
 680
 681     default:
 682         error = ata_device_ioctl(dev, cmd, addr);
 683     }
 684     return error;
 685 }
 686
 687 static int
 688 acd_geom_access(struct g_provider *pp, int dr, int dw, int de)
 689 {
 690     device_t dev = pp->geom->softc;
 691     struct acd_softc *cdp = device_get_ivars(dev);
 692     struct ata_request *request;
 693     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
 694                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 695     int timeout = 60, track;
 696
 697     if (!(request = ata_alloc_request()))
 698         return ENOMEM;
 699
 700     /* wait if drive is not finished loading the medium */
 701     while (timeout--) {
 702         bzero(request, sizeof(struct ata_request));
 703         request->dev = dev;
 704         bcopy(ccb, request->u.atapi.ccb, 16);
 705         request->flags = ATA_R_ATAPI;
 706         request->timeout = 5;
 707         ata_queue_request(request);
 708         if (!request->error &&
 709             (request->u.atapi.sense.key == 2 ||
 710              request->u.atapi.sense.key == 7) &&
 711             request->u.atapi.sense.asc == 4 &&
 712             request->u.atapi.sense.ascq == 1)
 713             pause("acdld", hz / 2);
 714         else
 715             break;
 716     }
 717     ata_free_request(request);
 718
 719     if (pp->acr == 0) {
 720         acd_prevent_allow(dev, 1);
 721         cdp->flags |= F_LOCKED;
 722         acd_read_toc(dev);
 723     }
 724
 725     if (dr + pp->acr == 0) {
 726         acd_prevent_allow(dev, 0);
 727         cdp->flags &= ~F_LOCKED;
 728     }
 729
 730     if ((track = pp->index)) {
 731         pp->sectorsize = (cdp->toc.tab[track - 1].control & 4) ? 2048 : 2352;
 732         pp->mediasize = ntohl(cdp->toc.tab[track].addr.lba) -
 733                         ntohl(cdp->toc.tab[track - 1].addr.lba);
 734     }
 735     else {
 736         pp->sectorsize = cdp->block_size;
 737         pp->mediasize = cdp->disk_size;
 738     }
 739     pp->mediasize *= pp->sectorsize;
 740
 741     return 0;
 742 }
 743
 744 static void
 745 acd_geom_start(struct bio *bp)
 746 {
 747     device_t dev = bp->bio_to->geom->softc;
 748     struct acd_softc *cdp = device_get_ivars(dev);
 749
 750     if (bp->bio_cmd != BIO_READ && bp->bio_cmd != BIO_WRITE) {
 751         g_io_deliver(bp, EOPNOTSUPP);
 752         return;
 753     }
 754
 755     if (bp->bio_cmd == BIO_READ && cdp->disk_size == -1) {
 756         g_io_deliver(bp, EIO);
 757         return;
 758     }
 759
 760     /* GEOM classes must do their own request limiting */
 761     if (bp->bio_length <= cdp->iomax) {
 762         bp->bio_pblkno = bp->bio_offset / bp->bio_to->sectorsize;
 763         acd_strategy(bp);
 764     }
 765     else {
 766         u_int pos, size = cdp->iomax - cdp->iomax % bp->bio_to->sectorsize;
 767         struct bio *bp2, *bp3;
 768
 769         if (!(bp2 = g_clone_bio(bp)))
 770             g_io_deliver(bp, EIO);
 771
 772         for (pos = 0; bp2; pos += size) {
 773             bp3 = NULL;
 774             bp2->bio_done = g_std_done;
 775             bp2->bio_to = bp->bio_to;
 776             bp2->bio_offset += pos;
 777             bp2->bio_data += pos;
 778             bp2->bio_length = bp->bio_length - pos;
 779             if (bp2->bio_length > size) {
 780                 bp2->bio_length = size;
 781                 if (!(bp3 = g_clone_bio(bp)))
 782                     bp->bio_error = ENOMEM;
 783             }
 784             bp2->bio_pblkno = bp2->bio_offset / bp2->bio_to->sectorsize;
 785             acd_strategy(bp2);
 786             bp2 = bp3;
 787         }
 788     }
 789 }
 790
 791 static void
 792 acd_strategy(struct bio *bp)
 793 {
 794     device_t dev = bp->bio_to->geom->softc;
 795     struct ata_device *atadev = device_get_softc(dev);
 796     struct acd_softc *cdp = device_get_ivars(dev);
 797     struct ata_request *request;
 798     u_int32_t lba, lastlba, count;
 799     int8_t ccb[16];
 800     int track, blocksize;
 801
 802     /* reject all queued entries if media changed */
 803     if (atadev->flags & ATA_D_MEDIA_CHANGED) {
 804         g_io_deliver(bp, EIO);
 805         return;
 806     }
 807
 808     bzero(ccb, sizeof(ccb));
 809
 810     track = bp->bio_to->index;
 811
 812     if (track) {
 813         blocksize = (cdp->toc.tab[track - 1].control & 4) ? 2048 : 2352;
 814         lastlba = ntohl(cdp->toc.tab[track].addr.lba);
 815         lba = bp->bio_offset / blocksize;
 816         lba += ntohl(cdp->toc.tab[track - 1].addr.lba);
 817     }
 818     else {
 819         blocksize = cdp->block_size;
 820         lastlba = cdp->disk_size;
 821         lba = bp->bio_offset / blocksize;
 822     }
 823
 824     count = bp->bio_length / blocksize;
 825
 826     if (bp->bio_cmd == BIO_READ) {
 827         /* if transfer goes beyond range adjust it to be within limits */
 828         if (lba + count > lastlba) {
 829             /* if we are entirely beyond EOM return EOF */
 830             if (lastlba <= lba) {
 831                 g_io_deliver(bp, 0);
 832                 return;
 833             }
 834             count = lastlba - lba;
 835         }
 836         switch (blocksize) {
 837         case 2048:
 838             ccb[0] = ATAPI_READ_BIG;
 839             break;
 840
 841         case 2352:
 842             ccb[0] = ATAPI_READ_CD;
 843             ccb[9] = 0xf8;
 844             break;
 845
 846         default:
 847             ccb[0] = ATAPI_READ_CD;
 848             ccb[9] = 0x10;
 849         }
 850     }
 851     else
 852         ccb[0] = ATAPI_WRITE_BIG;
 853
 854     ccb[1] = 0;
 855     ccb[2] = lba>>24;
 856     ccb[3] = lba>>16;
 857     ccb[4] = lba>>8;
 858     ccb[5] = lba;
 859     ccb[6] = count>>16;
 860     ccb[7] = count>>8;
 861     ccb[8] = count;
 862
 863     if (!(request = ata_alloc_request())) {
 864         g_io_deliver(bp, ENOMEM);
 865         return;
 866     }
 867     request->dev = dev;
 868     request->bio = bp;
 869     bcopy(ccb, request->u.atapi.ccb,
 870           (atadev->param.config & ATA_PROTO_MASK) ==
 871           ATA_PROTO_ATAPI_12 ? 16 : 12);
 872     request->data = bp->bio_data;
 873     request->bytecount = count * blocksize;
 874     request->transfersize = min(request->bytecount, 65534);
 875     request->timeout = (ccb[0] == ATAPI_WRITE_BIG) ? 60 : 30;
 876     request->retries = 2;
 877     request->callback = acd_done;
 878     request->flags = ATA_R_ATAPI;
 879     if (atadev->mode >= ATA_DMA)
 880         request->flags |= ATA_R_DMA;
 881     switch (bp->bio_cmd) {
 882     case BIO_READ:
 883         request->flags |= ATA_R_READ;
 884         break;
 885     case BIO_WRITE:
 886         request->flags |= ATA_R_WRITE;
 887         break;
 888     default:
 889         device_printf(dev, "unknown BIO operation\n");
 890         ata_free_request(request);
 891         g_io_deliver(bp, EIO);
 892         return;
 893     }
 894     ata_queue_request(request);
 895 }
 896
 897 static void
 898 acd_done(struct ata_request *request)
 899 {
 900     struct bio *bp = request->bio;
 901
 902     /* finish up transfer */
 903     bp->bio_completed = request->donecount;
 904     g_io_deliver(bp, request->result);
 905     ata_free_request(request);
 906 }
 907
 908 static void
 909 acd_set_ioparm(device_t dev)
 910 {
 911     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
 912     struct acd_softc *cdp = device_get_ivars(dev);
 913
 914     if (ch->dma)
 915         cdp->iomax = min(ch->dma->max_iosize, 65534);
 916     else
 917         cdp->iomax = min(DFLTPHYS, 65534);
 918 }
 919
 920 static void
 921 lba2msf(u_int32_t lba, u_int8_t *m, u_int8_t *s, u_int8_t *f)
 922 {
 923     lba += 150;
 924     lba &= 0xffffff;
 925     *m = lba / (60 * 75);
 926     lba %= (60 * 75);
 927     *s = lba / 75;
 928     *f = lba % 75;
 929 }
 930
 931 static u_int32_t
 932 msf2lba(u_int8_t m, u_int8_t s, u_int8_t f)
 933 {
 934     return (m * 60 + s) * 75 + f - 150;
 935 }
 936
 937 static void
 938 acd_read_toc(device_t dev)
 939 {
 940     struct ata_device *atadev = device_get_softc(dev);
 941     struct acd_softc *cdp = device_get_ivars(dev);
 942     struct g_provider *pp;
 943     u_int32_t sizes[2];
 944     int8_t ccb[16];
 945     int track, ntracks, len;
 946
 947     atadev->flags &= ~ATA_D_MEDIA_CHANGED;
 948     bzero(&cdp->toc, sizeof(cdp->toc));
 949     cdp->disk_size = -1;                        /* hack for GEOM SOS */
 950
 951     if (acd_test_ready(dev))
 952         return;
 953
 954     bzero(ccb, sizeof(ccb));
 955     len = sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry);
 956     ccb[0] = ATAPI_READ_TOC;
 957     ccb[7] = len>>8;
 958     ccb[8] = len;
 959     if (ata_atapicmd(dev, ccb, (caddr_t)&cdp->toc, len,
 960                      ATA_R_READ | ATA_R_QUIET, 30)) {
 961         bzero(&cdp->toc, sizeof(cdp->toc));
 962         return;
 963     }
 964     ntracks = cdp->toc.hdr.ending_track - cdp->toc.hdr.starting_track + 1;
 965     if (ntracks <= 0 || ntracks > MAXTRK) {
 966         bzero(&cdp->toc, sizeof(cdp->toc));
 967         return;
 968     }
 969
 970     len = sizeof(struct ioc_toc_header)+(ntracks+1)*sizeof(struct cd_toc_entry);
 971     bzero(ccb, sizeof(ccb));
 972     ccb[0] = ATAPI_READ_TOC;
 973     ccb[7] = len>>8;
 974     ccb[8] = len;
 975     if (ata_atapicmd(dev, ccb, (caddr_t)&cdp->toc, len,
 976                      ATA_R_READ | ATA_R_QUIET, 30)) {
 977         bzero(&cdp->toc, sizeof(cdp->toc));
 978         return;
 979     }
 980     cdp->toc.hdr.len = ntohs(cdp->toc.hdr.len);
 981
 982     cdp->block_size = (cdp->toc.tab[0].control & 4) ? 2048 : 2352;
 983     acd_set_ioparm(dev);
 984     bzero(ccb, sizeof(ccb));
 985     ccb[0] = ATAPI_READ_CAPACITY;
 986     if (ata_atapicmd(dev, ccb, (caddr_t)sizes, sizeof(sizes),
 987                      ATA_R_READ | ATA_R_QUIET, 30)) {
 988         bzero(&cdp->toc, sizeof(cdp->toc));
 989         return;
 990     }
 991     cdp->disk_size = ntohl(sizes[0]) + 1;
 992
 993     for (track = 1; track <= ntracks; track ++) {
 994         if (cdp->pp[track] != NULL)
 995             continue;
 996         pp = g_new_providerf(cdp->gp, "acd%dt%02d", device_get_unit(dev),track);
 997         pp->index = track;
 998         cdp->pp[track] = pp;
 999         g_error_provider(pp, 0);
1000     }
1001     for (; track < MAXTRK; track ++) {
1002         if (cdp->pp[track] == NULL)
1003             continue;
1004         cdp->pp[track]->flags |= G_PF_WITHER;
1005         g_orphan_provider(cdp->pp[track], ENXIO);
1006         cdp->pp[track] = NULL;
1007     }
1008
1009 #ifdef ACD_DEBUG
1010     if (cdp->disk_size && cdp->toc.hdr.ending_track) {
1011         device_printf(dev, "(%d sectors (%d bytes)), %d tracks ",
1012                       cdp->disk_size, cdp->block_size,
1013                       cdp->toc.hdr.ending_track-cdp->toc.hdr.starting_track+1);
1014         if (cdp->toc.tab[0].control & 4)
1015             printf("%dMB\n", cdp->disk_size * cdp->block_size / 1048576);
1016         else
1017             printf("%d:%d audio\n",
1018                    cdp->disk_size / 75 / 60, cdp->disk_size / 75 % 60);
1019     }
1020 #endif
1021 }
1022
1023 static int
1024 acd_play(device_t dev, int start, int end)
1025 {
1026     int8_t ccb[16];
1027
1028     bzero(ccb, sizeof(ccb));
1029     ccb[0] = ATAPI_PLAY_MSF;
1030     lba2msf(start, &ccb[3], &ccb[4], &ccb[5]);
1031     lba2msf(end, &ccb[6], &ccb[7], &ccb[8]);
1032     return ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
1033 }
1034
1035 static int
1036 acd_setchan(device_t dev, u_int8_t c0, u_int8_t c1, u_int8_t c2, u_int8_t c3)
1037 {
1038     struct acd_softc *cdp = device_get_ivars(dev);
1039     int error;
1040
1041     if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE, (caddr_t)&cdp->au,
1042                                 sizeof(cdp->au))))
1043         return error;
1044     if (cdp->au.page_code != ATAPI_CDROM_AUDIO_PAGE)
1045         return EIO;
1046     cdp->au.data_length = 0;
1047     cdp->au.port[0].channels = c0;
1048     cdp->au.port[1].channels = c1;
1049     cdp->au.port[2].channels = c2;
1050     cdp->au.port[3].channels = c3;
1051     return acd_mode_select(dev, (caddr_t)&cdp->au, sizeof(cdp->au));
1052 }
1053
1054 static int
1055 acd_init_writer(device_t dev, int test_write)
1056 {
1057     int8_t ccb[16];
1058
1059     bzero(ccb, sizeof(ccb));
1060     ccb[0] = ATAPI_REZERO;
1061     ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 60);
1062     ccb[0] = ATAPI_SEND_OPC_INFO;
1063     ccb[1] = 0x01;
1064     ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 30);
1065     return 0;
1066 }
1067
1068 static int
1069 acd_fixate(device_t dev, int multisession)
1070 {
1071     struct acd_softc *cdp = device_get_ivars(dev);
1072     int8_t ccb[16] = { ATAPI_CLOSE_TRACK, 0x01, 0x02, 0, 0, 0, 0, 0,
1073                        0, 0, 0, 0, 0, 0, 0, 0 };
1074     int timeout = 5*60*2;
1075     int error, dummy;
1076     struct write_param param;
1077
1078     if ((error = acd_mode_sense(dev, ATAPI_CDROM_WRITE_PARAMETERS_PAGE,
1079                                 (caddr_t)&param, sizeof(param))))
1080         return error;
1081
1082     param.data_length = 0;
1083     if (multisession)
1084         param.session_type = CDR_SESS_MULTI;
1085     else
1086         param.session_type = CDR_SESS_NONE;
1087
1088     if ((error = acd_mode_select(dev, (caddr_t)&param, param.page_length + 10)))
1089         return error;
1090
1091     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1092     if (error)
1093         return error;
1094
1095     /* some drives just return ready, wait for the expected fixate time */
1096     if ((error = acd_test_ready(dev)) != EBUSY) {
1097         timeout = timeout / (cdp->cap.cur_write_speed / 177);
1098         pause("acdfix", timeout * hz / 2);
1099         return acd_test_ready(dev);
1100     }
1101
1102     while (timeout-- > 0) {
1103         if ((error = acd_get_progress(dev, &dummy)))
1104             return error;
1105         if ((error = acd_test_ready(dev)) != EBUSY)
1106             return error;
1107         pause("acdcld", hz / 2);
1108     }
1109     return EIO;
1110 }
1111
1112 static int
1113 acd_init_track(device_t dev, struct cdr_track *track)
1114 {
1115     struct acd_softc *cdp = device_get_ivars(dev);
1116     struct write_param param;
1117     int error;
1118
1119     if ((error = acd_mode_sense(dev, ATAPI_CDROM_WRITE_PARAMETERS_PAGE,
1120                                 (caddr_t)&param, sizeof(param))))
1121         return error;
1122
1123     param.data_length = 0;
1124     param.page_code = ATAPI_CDROM_WRITE_PARAMETERS_PAGE;
1125     param.page_length = 0x32;
1126     param.test_write = track->test_write ? 1 : 0;
1127     param.write_type = CDR_WTYPE_TRACK;
1128     param.session_type = CDR_SESS_NONE;
1129     param.fp = 0;
1130     param.packet_size = 0;
1131
1132     if (cdp->cap.capabilities & MST_BURNPROOF)
1133         param.burnproof = 1;
1134
1135     switch (track->datablock_type) {
1136
1137     case CDR_DB_RAW:
1138         if (track->preemp)
1139             param.track_mode = CDR_TMODE_AUDIO_PREEMP;
1140         else
1141             param.track_mode = CDR_TMODE_AUDIO;
1142         cdp->block_size = 2352;
1143         param.datablock_type = CDR_DB_RAW;
1144         param.session_format = CDR_SESS_CDROM;
1145         break;
1146
1147     case CDR_DB_ROM_MODE1:
1148         cdp->block_size = 2048;
1149         param.track_mode = CDR_TMODE_DATA;
1150         param.datablock_type = CDR_DB_ROM_MODE1;
1151         param.session_format = CDR_SESS_CDROM;
1152         break;
1153
1154     case CDR_DB_ROM_MODE2:
1155         cdp->block_size = 2336;
1156         param.track_mode = CDR_TMODE_DATA;
1157         param.datablock_type = CDR_DB_ROM_MODE2;
1158         param.session_format = CDR_SESS_CDROM;
1159         break;
1160
1161     case CDR_DB_XA_MODE1:
1162         cdp->block_size = 2048;
1163         param.track_mode = CDR_TMODE_DATA;
1164         param.datablock_type = CDR_DB_XA_MODE1;
1165         param.session_format = CDR_SESS_CDROM_XA;
1166         break;
1167
1168     case CDR_DB_XA_MODE2_F1:
1169         cdp->block_size = 2056;
1170         param.track_mode = CDR_TMODE_DATA;
1171         param.datablock_type = CDR_DB_XA_MODE2_F1;
1172         param.session_format = CDR_SESS_CDROM_XA;
1173         break;
1174
1175     case CDR_DB_XA_MODE2_F2:
1176         cdp->block_size = 2324;
1177         param.track_mode = CDR_TMODE_DATA;
1178         param.datablock_type = CDR_DB_XA_MODE2_F2;
1179         param.session_format = CDR_SESS_CDROM_XA;
1180         break;
1181
1182     case CDR_DB_XA_MODE2_MIX:
1183         cdp->block_size = 2332;
1184         param.track_mode = CDR_TMODE_DATA;
1185         param.datablock_type = CDR_DB_XA_MODE2_MIX;
1186         param.session_format = CDR_SESS_CDROM_XA;
1187         break;
1188     }
1189     acd_set_ioparm(dev);
1190     return acd_mode_select(dev, (caddr_t)&param, param.page_length + 10);
1191 }
1192
1193 static int
1194 acd_flush(device_t dev)
1195 {
1196     int8_t ccb[16] = { ATAPI_SYNCHRONIZE_CACHE, 0, 0, 0, 0, 0, 0, 0,
1197                        0, 0, 0, 0, 0, 0, 0, 0 };
1198
1199     return ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 60);
1200 }
1201
1202 static int
1203 acd_read_track_info(device_t dev, int32_t lba, struct acd_track_info *info)
1204 {
1205     int8_t ccb[16] = { ATAPI_READ_TRACK_INFO, 1,
1206                        lba>>24, lba>>16, lba>>8, lba, 0,
1207                        sizeof(*info)>>8, sizeof(*info),
1208                        0, 0, 0, 0, 0, 0, 0 };
1209     int error;
1210
1211     if ((error = ata_atapicmd(dev, ccb, (caddr_t)info, sizeof(*info),
1212                               ATA_R_READ, 30)))
1213         return error;
1214     info->track_start_addr = ntohl(info->track_start_addr);
1215     info->next_writeable_addr = ntohl(info->next_writeable_addr);
1216     info->free_blocks = ntohl(info->free_blocks);
1217     info->fixed_packet_size = ntohl(info->fixed_packet_size);
1218     info->track_length = ntohl(info->track_length);
1219     return 0;
1220 }
1221
1222 static int
1223 acd_get_progress(device_t dev, int *finished)
1224 {
1225     int8_t ccb[16] = { ATAPI_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0,
1226                        0, 0, 0, 0, 0, 0, 0, 0 };
1227     struct ata_request *request;
1228     int8_t dummy[8];
1229
1230     if (!(request = ata_alloc_request()))
1231         return ENOMEM;
1232
1233     request->dev = dev;
1234     bcopy(ccb, request->u.atapi.ccb, 16);
1235     request->data = dummy;
1236     request->bytecount = sizeof(dummy);
1237     request->transfersize = min(request->bytecount, 65534);
1238     request->flags = ATA_R_ATAPI | ATA_R_READ;
1239     request->timeout = 30;
1240     ata_queue_request(request);
1241     if (!request->error &&
1242         request->u.atapi.sense.specific & ATA_SENSE_SPEC_VALID)
1243         *finished = ((request->u.atapi.sense.specific2 |
1244                      (request->u.atapi.sense.specific1 << 8)) * 100) / 65535;
1245     else
1246         *finished = 0;
1247     ata_free_request(request);
1248     return 0;
1249 }
1250
1251 static int
1252 acd_send_cue(device_t dev, struct cdr_cuesheet *cuesheet)
1253 {
1254     struct acd_softc *cdp = device_get_ivars(dev);
1255     struct write_param param;
1256     int8_t ccb[16] = { ATAPI_SEND_CUE_SHEET, 0, 0, 0, 0, 0,
1257                        cuesheet->len>>16, cuesheet->len>>8, cuesheet->len,
1258                        0, 0, 0, 0, 0, 0, 0 };
1259     int8_t *buffer;
1260     int32_t error;
1261
1262     if ((error = acd_mode_sense(dev, ATAPI_CDROM_WRITE_PARAMETERS_PAGE,
1263                                 (caddr_t)&param, sizeof(param))))
1264         return error;
1265
1266     param.data_length = 0;
1267     param.page_code = ATAPI_CDROM_WRITE_PARAMETERS_PAGE;
1268     param.page_length = 0x32;
1269     param.test_write = cuesheet->test_write ? 1 : 0;
1270     param.write_type = CDR_WTYPE_SESSION;
1271     param.session_type = cuesheet->session_type;
1272     param.fp = 0;
1273     param.packet_size = 0;
1274     param.track_mode = CDR_TMODE_AUDIO;
1275     param.datablock_type = CDR_DB_RAW;
1276     param.session_format = cuesheet->session_format;
1277     if (cdp->cap.capabilities & MST_BURNPROOF)
1278         param.burnproof = 1;
1279
1280     if ((error = acd_mode_select(dev, (caddr_t)&param, param.page_length + 10)))
1281         return error;
1282
1283     if (!(buffer = malloc(cuesheet->len, M_ACD, M_NOWAIT)))
1284         return ENOMEM;
1285
1286     if (!(error = copyin(cuesheet->entries, buffer, cuesheet->len)))
1287         error = ata_atapicmd(dev, ccb, buffer, cuesheet->len, 0, 30);
1288     free(buffer, M_ACD);
1289     return error;
1290 }
1291
1292 static int
1293 acd_report_key(device_t dev, struct dvd_authinfo *ai)
1294 {
1295     struct dvd_miscauth *d = NULL;
1296     u_int32_t lba = 0;
1297     int16_t length;
1298     int8_t ccb[16];
1299     int error;
1300
1301     switch (ai->format) {
1302     case DVD_REPORT_AGID:
1303     case DVD_REPORT_ASF:
1304     case DVD_REPORT_RPC:
1305         length = 8;
1306         break;
1307     case DVD_REPORT_KEY1:
1308         length = 12;
1309         break;
1310     case DVD_REPORT_TITLE_KEY:
1311         length = 12;
1312         lba = ai->lba;
1313         break;
1314     case DVD_REPORT_CHALLENGE:
1315         length = 16;
1316         break;
1317     case DVD_INVALIDATE_AGID:
1318         length = 0;
1319         break;
1320     default:
1321         return EINVAL;
1322     }
1323
1324     bzero(ccb, sizeof(ccb));
1325     ccb[0] = ATAPI_REPORT_KEY;
1326     ccb[2] = (lba >> 24) & 0xff;
1327     ccb[3] = (lba >> 16) & 0xff;
1328     ccb[4] = (lba >> 8) & 0xff;
1329     ccb[5] = lba & 0xff;
1330     ccb[8] = (length >> 8) & 0xff;
1331     ccb[9] = length & 0xff;
1332     ccb[10] = (ai->agid << 6) | ai->format;
1333
1334     if (length) {
1335         if (!(d = malloc(length, M_ACD, M_NOWAIT | M_ZERO)))
1336             return ENOMEM;
1337         d->length = htons(length - 2);
1338     }
1339
1340     error = ata_atapicmd(dev, ccb, (caddr_t)d, length,
1341                          ai->format == DVD_INVALIDATE_AGID ? 0 : ATA_R_READ,10);
1342     if (error) {
1343         if (length)
1344             free(d, M_ACD);
1345         return error;
1346     }
1347
1348     switch (ai->format) {
1349     case DVD_REPORT_AGID:
1350         ai->agid = d->data[3] >> 6;
1351         break;
1352
1353     case DVD_REPORT_CHALLENGE:
1354         bcopy(&d->data[0], &ai->keychal[0], 10);
1355         break;
1356
1357     case DVD_REPORT_KEY1:
1358         bcopy(&d->data[0], &ai->keychal[0], 5);
1359         break;
1360
1361     case DVD_REPORT_TITLE_KEY:
1362         ai->cpm = (d->data[0] >> 7);
1363         ai->cp_sec = (d->data[0] >> 6) & 0x1;
1364         ai->cgms = (d->data[0] >> 4) & 0x3;
1365         bcopy(&d->data[1], &ai->keychal[0], 5);
1366         break;
1367
1368     case DVD_REPORT_ASF:
1369         ai->asf = d->data[3] & 1;
1370         break;
1371
1372     case DVD_REPORT_RPC:
1373         ai->reg_type = (d->data[0] >> 6);
1374         ai->vend_rsts = (d->data[0] >> 3) & 0x7;
1375         ai->user_rsts = d->data[0] & 0x7;
1376         ai->region = d->data[1];
1377         ai->rpc_scheme = d->data[2];
1378         break;
1379
1380     case DVD_INVALIDATE_AGID:
1381         break;
1382
1383     default:
1384         error = EINVAL;
1385     }
1386     if (length)
1387         free(d, M_ACD);
1388     return error;
1389 }
1390
1391 static int
1392 acd_send_key(device_t dev, struct dvd_authinfo *ai)
1393 {
1394     struct dvd_miscauth *d;
1395     int16_t length;
1396     int8_t ccb[16];
1397     int error;
1398
1399     switch (ai->format) {
1400     case DVD_SEND_CHALLENGE:
1401         length = 16;
1402         if (!(d = malloc(length, M_ACD, M_NOWAIT | M_ZERO)))
1403             return ENOMEM;
1404         bcopy(ai->keychal, &d->data[0], 10);
1405         break;
1406
1407     case DVD_SEND_KEY2:
1408         length = 12;
1409         if (!(d = malloc(length, M_ACD, M_NOWAIT | M_ZERO)))
1410             return ENOMEM;
1411         bcopy(&ai->keychal[0], &d->data[0], 5);
1412         break;
1413
1414     case DVD_SEND_RPC:
1415         length = 8;
1416         if (!(d = malloc(length, M_ACD, M_NOWAIT | M_ZERO)))
1417             return ENOMEM;
1418         d->data[0] = ai->region;
1419         break;
1420
1421     default:
1422         return EINVAL;
1423     }
1424
1425     bzero(ccb, sizeof(ccb));
1426     ccb[0] = ATAPI_SEND_KEY;
1427     ccb[8] = (length >> 8) & 0xff;
1428     ccb[9] = length & 0xff;
1429     ccb[10] = (ai->agid << 6) | ai->format;
1430     d->length = htons(length - 2);
1431     error = ata_atapicmd(dev, ccb, (caddr_t)d, length, 0, 10);
1432     free(d, M_ACD);
1433     return error;
1434 }
1435
1436 static int
1437 acd_read_structure(device_t dev, struct dvd_struct *s)
1438 {
1439     struct dvd_miscauth *d;
1440     u_int16_t length;
1441     int8_t ccb[16];
1442     int error = 0;
1443
1444     switch(s->format) {
1445     case DVD_STRUCT_PHYSICAL:
1446         length = 21;
1447         break;
1448
1449     case DVD_STRUCT_COPYRIGHT:
1450         length = 8;
1451         break;
1452
1453     case DVD_STRUCT_DISCKEY:
1454         length = 2052;
1455         break;
1456
1457     case DVD_STRUCT_BCA:
1458         length = 192;
1459         break;
1460
1461     case DVD_STRUCT_MANUFACT:
1462         length = 2052;
1463         break;
1464
1465     case DVD_STRUCT_DDS:
1466     case DVD_STRUCT_PRERECORDED:
1467     case DVD_STRUCT_UNIQUEID:
1468     case DVD_STRUCT_LIST:
1469     case DVD_STRUCT_CMI:
1470     case DVD_STRUCT_RMD_LAST:
1471     case DVD_STRUCT_RMD_RMA:
1472     case DVD_STRUCT_DCB:
1473         return ENOSYS;
1474
1475     default:
1476         return EINVAL;
1477     }
1478
1479     if (!(d = malloc(length, M_ACD, M_NOWAIT | M_ZERO)))
1480         return ENOMEM;
1481     d->length = htons(length - 2);
1482
1483     bzero(ccb, sizeof(ccb));
1484     ccb[0] = ATAPI_READ_STRUCTURE;
1485     ccb[6] = s->layer_num;
1486     ccb[7] = s->format;
1487     ccb[8] = (length >> 8) & 0xff;
1488     ccb[9] = length & 0xff;
1489     ccb[10] = s->agid << 6;
1490     error = ata_atapicmd(dev, ccb, (caddr_t)d, length, ATA_R_READ, 30);
1491     if (error) {
1492         free(d, M_ACD);
1493         return error;
1494     }
1495
1496     switch (s->format) {
1497     case DVD_STRUCT_PHYSICAL: {
1498         struct dvd_layer *layer = (struct dvd_layer *)&s->data[0];
1499
1500         layer->book_type = d->data[0] >> 4;
1501         layer->book_version = d->data[0] & 0xf;
1502         layer->disc_size = d->data[1] >> 4;
1503         layer->max_rate = d->data[1] & 0xf;
1504         layer->nlayers = (d->data[2] >> 5) & 3;
1505         layer->track_path = (d->data[2] >> 4) & 1;
1506         layer->layer_type = d->data[2] & 0xf;
1507         layer->linear_density = d->data[3] >> 4;
1508         layer->track_density = d->data[3] & 0xf;
1509         layer->start_sector = d->data[5] << 16 | d->data[6] << 8 | d->data[7];
1510         layer->end_sector = d->data[9] << 16 | d->data[10] << 8 | d->data[11];
1511         layer->end_sector_l0 = d->data[13] << 16 | d->data[14] << 8|d->data[15];
1512         layer->bca = d->data[16] >> 7;
1513         break;
1514     }
1515
1516     case DVD_STRUCT_COPYRIGHT:
1517         s->cpst = d->data[0];
1518         s->rmi = d->data[1];
1519         break;
1520
1521     case DVD_STRUCT_DISCKEY:
1522         bcopy(&d->data[0], &s->data[0], 2048);
1523         break;
1524
1525     case DVD_STRUCT_BCA:
1526         s->length = ntohs(d->length);
1527         bcopy(&d->data[0], &s->data[0], s->length);
1528         break;
1529
1530     case DVD_STRUCT_MANUFACT:
1531         s->length = ntohs(d->length);
1532         bcopy(&d->data[0], &s->data[0], s->length);
1533         break;
1534
1535     default:
1536         error = EINVAL;
1537     }
1538     free(d, M_ACD);
1539     return error;
1540 }
1541
1542 static int
1543 acd_tray(device_t dev, int close)
1544 {
1545     struct ata_device *atadev = device_get_softc(dev);
1546     struct acd_softc *cdp = device_get_ivars(dev);
1547     int error = ENODEV;
1548
1549     if (cdp->cap.mechanism & MST_EJECT) {
1550         if (close) {
1551             if (!(error = acd_start_stop(dev, 3))) {
1552                 acd_read_toc(dev);
1553                 acd_prevent_allow(dev, 1);
1554                 cdp->flags |= F_LOCKED;
1555             }
1556         }
1557         else {
1558             acd_start_stop(dev, 0);
1559             acd_prevent_allow(dev, 0);
1560             cdp->flags &= ~F_LOCKED;
1561             atadev->flags |= ATA_D_MEDIA_CHANGED;
1562             error = acd_start_stop(dev, 2);
1563         }
1564     }
1565     return error;
1566 }
1567
1568 static int
1569 acd_blank(device_t dev, int blanktype)
1570 {
1571     struct ata_device *atadev = device_get_softc(dev);
1572     int8_t ccb[16] = { ATAPI_BLANK, 0x10 | (blanktype & 0x7), 0, 0, 0, 0, 0, 0,
1573                        0, 0, 0, 0, 0, 0, 0, 0 };
1574
1575     atadev->flags |= ATA_D_MEDIA_CHANGED;
1576     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1577 }
1578
1579 static int
1580 acd_prevent_allow(device_t dev, int lock)
1581 {
1582     int8_t ccb[16] = { ATAPI_PREVENT_ALLOW, 0, 0, 0, lock,
1583                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1584
1585     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1586 }
1587
1588 static int
1589 acd_start_stop(device_t dev, int start)
1590 {
1591     int8_t ccb[16] = { ATAPI_START_STOP, 0, 0, 0, start,
1592                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1593
1594     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1595 }
1596
1597 static int
1598 acd_pause_resume(device_t dev, int pause)
1599 {
1600     int8_t ccb[16] = { ATAPI_PAUSE, 0, 0, 0, 0, 0, 0, 0, pause,
1601                        0, 0, 0, 0, 0, 0, 0 };
1602
1603     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1604 }
1605
1606 static int
1607 acd_mode_sense(device_t dev, int page, caddr_t pagebuf, int pagesize)
1608 {
1609     int8_t ccb[16] = { ATAPI_MODE_SENSE_BIG, 0, page, 0, 0, 0, 0,
1610                        pagesize>>8, pagesize, 0, 0, 0, 0, 0, 0, 0 };
1611     int error;
1612
1613     error = ata_atapicmd(dev, ccb, pagebuf, pagesize, ATA_R_READ, 10);
1614     return error;
1615 }
1616
1617 static int
1618 acd_mode_select(device_t dev, caddr_t pagebuf, int pagesize)
1619 {
1620     int8_t ccb[16] = { ATAPI_MODE_SELECT_BIG, 0x10, 0, 0, 0, 0, 0,
1621                      pagesize>>8, pagesize, 0, 0, 0, 0, 0, 0, 0 };
1622
1623     return ata_atapicmd(dev, ccb, pagebuf, pagesize, 0, 30);
1624 }
1625
1626 static int
1627 acd_set_speed(device_t dev, int rdspeed, int wrspeed)
1628 {
1629     int8_t ccb[16] = { ATAPI_SET_SPEED, 0, rdspeed >> 8, rdspeed,
1630                        wrspeed >> 8, wrspeed, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1631     int error;
1632
1633     error = ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1634     if (!error)
1635         acd_get_cap(dev);
1636     return error;
1637 }
1638
1639 static void
1640 acd_get_cap(device_t dev)
1641 {
1642     struct acd_softc *cdp = device_get_ivars(dev);
1643     int8_t ccb[16] = { ATAPI_MODE_SENSE_BIG, 0, ATAPI_CDROM_CAP_PAGE,
1644                        0, 0, 0, 0, sizeof(cdp->cap)>>8, sizeof(cdp->cap),
1645                        0, 0, 0, 0, 0, 0, 0 };
1646     int count;
1647
1648     /* get drive capabilities, some bugridden drives needs this repeated */
1649     for (count = 0 ; count < 5 ; count++) {
1650         if (!ata_atapicmd(dev, ccb, (caddr_t)&cdp->cap, sizeof(cdp->cap),
1651                           ATA_R_READ | ATA_R_QUIET, 5)) {
1652             cdp->cap.max_read_speed = ntohs(cdp->cap.max_read_speed);
1653             cdp->cap.cur_read_speed = ntohs(cdp->cap.cur_read_speed);
1654             cdp->cap.max_write_speed = ntohs(cdp->cap.max_write_speed);
1655             cdp->cap.cur_write_speed = max(ntohs(cdp->cap.cur_write_speed),177);
1656             cdp->cap.max_vol_levels = ntohs(cdp->cap.max_vol_levels);
1657             cdp->cap.buf_size = ntohs(cdp->cap.buf_size);
1658         }
1659     }
1660 }
1661
1662 static int
1663 acd_read_format_caps(device_t dev, struct cdr_format_capacities *caps)
1664 {
1665     int8_t ccb[16] = { ATAPI_READ_FORMAT_CAPACITIES, 0, 0, 0, 0, 0, 0,
1666                        (sizeof(struct cdr_format_capacities) >> 8) & 0xff,
1667                        sizeof(struct cdr_format_capacities) & 0xff,
1668                        0, 0, 0, 0, 0, 0, 0 };
1669
1670     return ata_atapicmd(dev, ccb, (caddr_t)caps,
1671                         sizeof(struct cdr_format_capacities), ATA_R_READ, 30);
1672 }
1673
1674 static int
1675 acd_format(device_t dev, struct cdr_format_params* params)
1676 {
1677     int8_t ccb[16] = { ATAPI_FORMAT, 0x11, 0, 0, 0, 0, 0, 0, 0, 0,
1678                        0, 0, 0, 0, 0, 0 };
1679     int error;
1680
1681     error = ata_atapicmd(dev, ccb, (u_int8_t *)params,
1682                          sizeof(struct cdr_format_params), 0, 30);
1683     return error;
1684 }
1685
1686 static int
1687 acd_test_ready(device_t dev)
1688 {
1689     int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
1690                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1691
1692     return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
1693 }
1694
1695 static void
1696 acd_describe(device_t dev)
1697 {
1698     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1699     struct ata_device *atadev = device_get_softc(dev);
1700     struct acd_softc *cdp = device_get_ivars(dev);
1701     int comma = 0;
1702     char *mechanism;
1703
1704     if (bootverbose) {
1705         device_printf(dev, "<%.40s/%.8s> %s drive at ata%d as %s\n",
1706                       atadev->param.model, atadev->param.revision,
1707                       (cdp->cap.media & MST_WRITE_DVDR) ? "DVDR" :
1708                        (cdp->cap.media & MST_WRITE_DVDRAM) ? "DVDRAM" :
1709                         (cdp->cap.media & MST_WRITE_CDRW) ? "CDRW" :
1710                          (cdp->cap.media & MST_WRITE_CDR) ? "CDR" :
1711                           (cdp->cap.media & MST_READ_DVDROM) ? "DVDROM":"CDROM",
1712                       device_get_unit(ch->dev),
1713                       (atadev->unit == ATA_MASTER) ? "master" : "slave");
1714
1715         device_printf(dev, "%s", "");
1716         if (cdp->cap.cur_read_speed) {
1717             printf("read %dKB/s", cdp->cap.cur_read_speed * 1000 / 1024);
1718             if (cdp->cap.max_read_speed)
1719                 printf(" (%dKB/s)", cdp->cap.max_read_speed * 1000 / 1024);
1720             if ((cdp->cap.cur_write_speed) &&
1721                 (cdp->cap.media & (MST_WRITE_CDR | MST_WRITE_CDRW |
1722                                    MST_WRITE_DVDR | MST_WRITE_DVDRAM))) {
1723                 printf(" write %dKB/s", cdp->cap.cur_write_speed * 1000 / 1024);
1724                 if (cdp->cap.max_write_speed)
1725                     printf(" (%dKB/s)", cdp->cap.max_write_speed * 1000 / 1024);
1726             }
1727             comma = 1;
1728         }
1729         if (cdp->cap.buf_size) {
1730             printf("%s %dKB buffer", comma ? "," : "", cdp->cap.buf_size);
1731             comma = 1;
1732         }
1733         printf("%s %s\n", comma ? "," : "", ata_mode2str(atadev->mode));
1734
1735         device_printf(dev, "Reads:");
1736         comma = 0;
1737         if (cdp->cap.media & MST_READ_CDR) {
1738             printf(" CDR"); comma = 1;
1739         }
1740         if (cdp->cap.media & MST_READ_CDRW) {
1741             printf("%s CDRW", comma ? "," : ""); comma = 1;
1742         }
1743         if (cdp->cap.capabilities & MST_READ_CDDA) {
1744             if (cdp->cap.capabilities & MST_CDDA_STREAM)
1745                 printf("%s CDDA stream", comma ? "," : "");
1746             else
1747                 printf("%s CDDA", comma ? "," : "");
1748             comma = 1;
1749         }
1750         if (cdp->cap.media & MST_READ_DVDROM) {
1751             printf("%s DVDROM", comma ? "," : ""); comma = 1;
1752         }
1753         if (cdp->cap.media & MST_READ_DVDR) {
1754             printf("%s DVDR", comma ? "," : ""); comma = 1;
1755         }
1756         if (cdp->cap.media & MST_READ_DVDRAM) {
1757             printf("%s DVDRAM", comma ? "," : ""); comma = 1;
1758         }
1759         if (cdp->cap.media & MST_READ_PACKET)
1760             printf("%s packet", comma ? "," : "");
1761
1762         printf("\n");
1763         device_printf(dev, "Writes:");
1764         if (cdp->cap.media & (MST_WRITE_CDR | MST_WRITE_CDRW |
1765                               MST_WRITE_DVDR | MST_WRITE_DVDRAM)) {
1766             comma = 0;
1767             if (cdp->cap.media & MST_WRITE_CDR) {
1768                 printf(" CDR" ); comma = 1;
1769             }
1770             if (cdp->cap.media & MST_WRITE_CDRW) {
1771                 printf("%s CDRW", comma ? "," : ""); comma = 1;
1772             }
1773             if (cdp->cap.media & MST_WRITE_DVDR) {
1774                 printf("%s DVDR", comma ? "," : ""); comma = 1;
1775             }
1776             if (cdp->cap.media & MST_WRITE_DVDRAM) {
1777                 printf("%s DVDRAM", comma ? "," : ""); comma = 1;
1778             }
1779             if (cdp->cap.media & MST_WRITE_TEST) {
1780                 printf("%s test write", comma ? "," : ""); comma = 1;
1781             }
1782             if (cdp->cap.capabilities & MST_BURNPROOF)
1783                 printf("%s burnproof", comma ? "," : "");
1784         }
1785         printf("\n");
1786         if (cdp->cap.capabilities & MST_AUDIO_PLAY) {
1787             device_printf(dev, "Audio: ");
1788             if (cdp->cap.capabilities & MST_AUDIO_PLAY)
1789                 printf("play");
1790             if (cdp->cap.max_vol_levels)
1791                 printf(", %d volume levels", cdp->cap.max_vol_levels);
1792             printf("\n");
1793         }
1794         device_printf(dev, "Mechanism: ");
1795         switch (cdp->cap.mechanism & MST_MECH_MASK) {
1796         case MST_MECH_CADDY:
1797             mechanism = "caddy"; break;
1798         case MST_MECH_TRAY:
1799             mechanism = "tray"; break;
1800         case MST_MECH_POPUP:
1801             mechanism = "popup"; break;
1802         case MST_MECH_CHANGER:
1803             mechanism = "changer"; break;
1804         case MST_MECH_CARTRIDGE:
1805             mechanism = "cartridge"; break;
1806         default:
1807             mechanism = 0; break;
1808         }
1809         if (mechanism)
1810             printf("%s%s", (cdp->cap.mechanism & MST_EJECT) ?
1811                    "ejectable " : "", mechanism);
1812         else if (cdp->cap.mechanism & MST_EJECT)
1813             printf("ejectable");
1814
1815         if (cdp->cap.mechanism & MST_LOCKABLE)
1816             printf((cdp->cap.mechanism & MST_LOCKED) ? ", locked":", unlocked");
1817         if (cdp->cap.mechanism & MST_PREVENT)
1818             printf(", lock protected");
1819         printf("\n");
1820
1821         if ((cdp->cap.mechanism & MST_MECH_MASK) != MST_MECH_CHANGER) {
1822             device_printf(dev, "Medium: ");
1823             switch (cdp->cap.medium_type & MST_TYPE_MASK_HIGH) {
1824             case MST_CDROM:
1825                 printf("CD-ROM "); break;
1826             case MST_CDR:
1827                 printf("CD-R "); break;
1828             case MST_CDRW:
1829                 printf("CD-RW "); break;
1830             case MST_DVD:
1831                 printf("DVD "); break;
1832             case MST_DOOR_OPEN:
1833                 printf("door open"); break;
1834             case MST_NO_DISC:
1835                 printf("no/blank disc"); break;
1836             case MST_FMT_ERROR:
1837                 printf("medium format error"); break;
1838             }
1839             if ((cdp->cap.medium_type & MST_TYPE_MASK_HIGH)<MST_TYPE_MASK_HIGH){
1840                 switch (cdp->cap.medium_type & MST_TYPE_MASK_LOW) {
1841                 case MST_DATA_120:
1842                     printf("120mm data disc"); break;
1843                 case MST_AUDIO_120:
1844                     printf("120mm audio disc"); break;
1845                 case MST_COMB_120:
1846                     printf("120mm data/audio disc"); break;
1847                 case MST_PHOTO_120:
1848                     printf("120mm photo disc"); break;
1849                 case MST_DATA_80:
1850                     printf("80mm data disc"); break;
1851                 case MST_AUDIO_80:
1852                     printf("80mm audio disc"); break;
1853                 case MST_COMB_80:
1854                     printf("80mm data/audio disc"); break;
1855                 case MST_PHOTO_80:
1856                     printf("80mm photo disc"); break;
1857                 case MST_FMT_NONE:
1858                     switch (cdp->cap.medium_type & MST_TYPE_MASK_HIGH) {
1859                     case MST_CDROM:
1860                         printf("unknown"); break;
1861                     case MST_CDR:
1862                     case MST_CDRW:
1863                         printf("blank"); break;
1864                     }
1865                     break;
1866                 default:
1867                     printf("unknown (0x%x)", cdp->cap.medium_type); break;
1868                 }
1869             }
1870             printf("\n");
1871         }
1872     }
1873     else {
1874         device_printf(dev, "%s ",
1875                       (cdp->cap.media & MST_WRITE_DVDR) ? "DVDR" :
1876                        (cdp->cap.media & MST_WRITE_DVDRAM) ? "DVDRAM" :
1877                         (cdp->cap.media & MST_WRITE_CDRW) ? "CDRW" :
1878                          (cdp->cap.media & MST_WRITE_CDR) ? "CDR" :
1879                           (cdp->cap.media & MST_READ_DVDROM) ? "DVDROM" :
1880                           "CDROM");
1881         if (cdp->changer_info)
1882             printf("with %d CD changer ", cdp->changer_info->slots);
1883         printf("<%.40s/%.8s> at ata%d-%s %s\n",
1884                atadev->param.model, atadev->param.revision,
1885                device_get_unit(ch->dev),
1886                (atadev->unit == ATA_MASTER) ? "master" : "slave",
1887                ata_mode2str(atadev->mode) );
1888     }
1889 }
1890
1891 static device_method_t acd_methods[] = {
1892     /* device interface */
1893     DEVMETHOD(device_probe,     acd_probe),
1894     DEVMETHOD(device_attach,    acd_attach),
1895     DEVMETHOD(device_detach,    acd_detach),
1896     DEVMETHOD(device_shutdown,  acd_shutdown),
1897
1898     /* ATA methods */
1899     DEVMETHOD(ata_reinit,       acd_reinit),
1900
1901     { 0, 0 }
1902 };
1903
1904 static driver_t acd_driver = {
1905     "acd",
1906     acd_methods,
1907     0,
1908 };
1909
1910 static devclass_t acd_devclass;
1911
1912 static int
1913 acd_modevent(module_t mod, int what, void *arg)
1914 {
1915     g_modevent(0, what, &acd_class);
1916     return 0;
1917 }
1918
1919 DRIVER_MODULE(acd, ata, acd_driver, acd_devclass, acd_modevent, NULL);
1920 MODULE_VERSION(acd, 1);
1921 MODULE_DEPEND(acd, ata, 1, 1, 1);