sys/src/cmd/cdfs/mmc.c

   1 /*
   2  * multi-media commands
   3  *
   4  * as of mmc-6, mode page 0x2a (capabilities & mechanical status) is legacy
   5  * and read-only, last defined in mmc-3.  mode page 5 (write parameters)
   6  * applies only to cd-r(w) and dvd-r(w); *-rom, dvd+* and bd-* are right out.
   7  */
   8 #include <u.h>
   9 #include <libc.h>
  10 #include <disk.h>
  11 #include "../scuzz/scsireq.h"
  12 #include "dat.h"
  13 #include "fns.h"
  14
  15 enum
  16 {
  17         Pagesz          = 255,
  18
  19         Pagwrparams     = 5,    /* (cd|dvd)-r(w) device write parameters */
  20         Pagcache        = 8,
  21         Pagcapmechsts   = 0x2a,
  22
  23         Invistrack      = 0xff, /* the invisible & incomplete track */
  24 };
  25
  26 static Dev mmcdev;
  27
  28 typedef struct Mmcaux Mmcaux;
  29 struct Mmcaux {
  30         /* drive characteristics */
  31         uchar   page05[Pagesz];         /* write parameters */
  32         int     page05ok;
  33         int     pagecmdsz;
  34
  35         /* disc characteristics */
  36         ulong   mmcnwa;
  37         int     nropen;
  38         int     nwopen;
  39         vlong   ntotby;
  40         long    ntotbk;
  41 };
  42
  43 /* these will be printed as user ids, so no spaces please */
  44 static char *dvdtype[] = {
  45         "dvd-rom",
  46         "dvd-ram",
  47         "dvd-r",
  48         "dvd-rw",
  49         "hd-dvd-rom",
  50         "hd-dvd-ram",
  51         "hd-dvd-r",
  52         "type-7-unknown",
  53         "type-8-unknown",
  54         "dvd+rw",
  55         "dvd+r",
  56         "type-11-unknown",
  57         "type-12-unknown",
  58         "dvd+rw-dl",
  59         "dvd+r-dl",
  60         "type-15-unknown",
  61 };
  62
  63 static ulong
  64 bige(void *p)
  65 {
  66         uchar *a;
  67
  68         a = p;
  69         return (a[0]<<24)|(a[1]<<16)|(a[2]<<8)|(a[3]<<0);
  70 }
  71
  72 static ushort
  73 biges(void *p)
  74 {
  75         uchar *a;
  76
  77         a = p;
  78         return (a[0]<<8) | a[1];
  79 }
  80
  81 ulong
  82 getnwa(Drive *drive)
  83 {
  84         Mmcaux *aux;
  85
  86         aux = drive->aux;
  87         return aux->mmcnwa;
  88 }
  89
  90 static void
  91 hexdump(void *v, int n)
  92 {
  93         int i;
  94         uchar *p;
  95
  96         p = v;
  97         for(i=0; i<n; i++){
  98                 print("%.2ux ", p[i]);
  99                 if((i%8) == 7)
 100                         print("\n");
 101         }
 102         if(i%8)
 103                 print("\n");
 104 }
 105
 106 static void
 107 initcdb(uchar *cdb, int len, int cmd)
 108 {
 109         memset(cdb, 0, len);
 110         cdb[0] = cmd;
 111 }
 112
 113 //static uchar *
 114 //newcdb(int len, int cmd)
 115 //{
 116 //      uchar *cdb;
 117 //
 118 //      cdb = emalloc(len);
 119 //      cdb[0] = cmd;
 120 //      return cdb;
 121 //}
 122
 123 /*
 124  * SCSI CDBs (cmd arrays) are 6, 10, 12, 16 or 32 bytes long.
 125  * The mode sense/select commands implicitly refer to
 126  * a mode parameter list, which consists of an 8-byte
 127  * mode parameter header, followed by zero or more block
 128  * descriptors and zero or more mode pages (MMC-2 §5.5.2).
 129  * We'll ignore mode sub-pages.
 130  * Integers are stored big-endian.
 131  *
 132  * The format of the mode parameter (10) header is:
 133  *      ushort  mode_data_length;               // of following bytes
 134  *      uchar   medium_type;
 135  *      uchar   device_specific;
 136  *      uchar   reserved[2];
 137  *      ushort  block_descriptor_length;        // zero
 138  *
 139  * The format of the mode parameter (6) header is:
 140  *      uchar   mode_data_length;               // of following bytes
 141  *      uchar   medium_type;
 142  *      uchar   device_specific;
 143  *      uchar   block_descriptor_length;        // zero
 144  *
 145  * The format of the mode pages is:
 146  *      uchar   page_code_and_PS;
 147  *      uchar   page_len;                       // of following bytes
 148  *      uchar   parameter[page_len];
 149  *
 150  * see SPC-3 §4.3.4.6 for allocation length and §7.4 for mode parameter lists.
 151  */
 152
 153 enum {
 154         Mode10parmhdrlen= 8,
 155         Mode6parmhdrlen = 4,
 156         Modepaghdrlen   = 2,
 157 };
 158
 159 static int
 160 mmcgetpage10(Drive *drive, int page, void *v)
 161 {
 162         uchar cmd[10], resp[512];
 163         int n, r;
 164
 165         memset(cmd, 0, sizeof(cmd));
 166         cmd[0] = ScmdMsense10;
 167         cmd[2] = page;
 168         cmd[8] = 255;                   /* allocation length: buffer size */
 169
 170 //      print("get: sending cmd\n");
 171 //      hexdump(cmd, 10);
 172
 173         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
 174         if(n < Mode10parmhdrlen)
 175                 return -1;
 176
 177         r = (resp[6]<<8) | resp[7];     /* block descriptor length */
 178         n -= Mode10parmhdrlen + r;
 179
 180         if(n < 0)
 181                 return -1;
 182         if(n > Pagesz)
 183                 n = Pagesz;
 184
 185         memmove(v, &resp[Mode10parmhdrlen + r], n);
 186
 187 //      print("get: got cmd\n");
 188 //      hexdump(cmd, 10);
 189 //      print("page\n");
 190 //      hexdump(v, n);
 191
 192         return n;
 193 }
 194
 195 static int
 196 mmcgetpage6(Drive *drive, int page, void *v)
 197 {
 198         uchar cmd[6], resp[512];
 199         int n;
 200
 201         memset(cmd, 0, sizeof(cmd));
 202         cmd[0] = ScmdMsense6;
 203         cmd[2] = page;
 204         cmd[4] = 255;                   /* allocation length */
 205
 206         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
 207         if(n < Mode6parmhdrlen)
 208                 return -1;
 209
 210         n -= Mode6parmhdrlen + resp[3];
 211         if(n < 0)
 212                 return -1;
 213         if(n > Pagesz)
 214                 n = Pagesz;
 215
 216         memmove(v, &resp[Mode6parmhdrlen + resp[3]], n);
 217         return n;
 218 }
 219
 220 static int
 221 mmcsetpage10(Drive *drive, int page, void *v)
 222 {
 223         uchar cmd[10], *p, *pagedata;
 224         int len, n;
 225
 226         /* allocate parameter list, copy in mode page, fill in header */
 227         pagedata = v;
 228         assert(pagedata[0] == page);
 229         len = Mode10parmhdrlen + Modepaghdrlen + pagedata[1];
 230         p = emalloc(len);
 231         memmove(p + Mode10parmhdrlen, pagedata, pagedata[1]);
 232         /* parameter list header */
 233         p[0] = 0;
 234         p[1] = len - 2;
 235
 236         /* set up CDB */
 237         memset(cmd, 0, sizeof(cmd));
 238         cmd[0] = ScmdMselect10;
 239         cmd[1] = 0x10;                  /* format not vendor-specific */
 240         cmd[8] = len;
 241
 242 //      print("set: sending cmd\n");
 243 //      hexdump(cmd, 10);
 244 //      print("parameter list header\n");
 245 //      hexdump(p, Mode10parmhdrlen);
 246 //      print("page\n");
 247 //      hexdump(p + Mode10parmhdrlen, len - Mode10parmhdrlen);
 248
 249         n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite);
 250
 251 //      print("set: got cmd\n");
 252 //      hexdump(cmd, 10);
 253
 254         free(p);
 255         if(n < len)
 256                 return -1;
 257         return 0;
 258 }
 259
 260 static int
 261 mmcsetpage6(Drive *drive, int page, void *v)
 262 {
 263         uchar cmd[6], *p, *pagedata;
 264         int len, n;
 265
 266         if (vflag)
 267                 print("mmcsetpage6 called!\n");
 268         pagedata = v;
 269         assert(pagedata[0] == page);
 270         len = Mode6parmhdrlen + Modepaghdrlen + pagedata[1];
 271         p = emalloc(len);
 272         memmove(p + Mode6parmhdrlen, pagedata, pagedata[1]);
 273
 274         memset(cmd, 0, sizeof(cmd));
 275         cmd[0] = ScmdMselect6;
 276         cmd[1] = 0x10;                  /* format not vendor-specific */
 277         cmd[4] = len;
 278
 279         n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite);
 280         free(p);
 281         if(n < len)
 282                 return -1;
 283         return 0;
 284 }
 285
 286 static int
 287 mmcgetpage(Drive *drive, int page, void *v)
 288 {
 289         Mmcaux *aux;
 290
 291         aux = drive->aux;
 292         switch(aux->pagecmdsz) {
 293         case 10:
 294                 return mmcgetpage10(drive, page, v);
 295         case 6:
 296                 return mmcgetpage6(drive, page, v);
 297         default:
 298                 assert(0);
 299         }
 300         return -1;
 301 }
 302
 303 static int
 304 mmcsetpage(Drive *drive, int page, void *v)
 305 {
 306         Mmcaux *aux;
 307
 308         aux = drive->aux;
 309         switch(aux->pagecmdsz) {
 310         case 10:
 311                 return mmcsetpage10(drive, page, v);
 312         case 6:
 313                 return mmcsetpage6(drive, page, v);
 314         default:
 315                 assert(0);
 316         }
 317         return -1;
 318 }
 319
 320 int
 321 mmcstatus(Drive *drive)
 322 {
 323         uchar cmd[12];
 324
 325         initcdb(cmd, sizeof cmd, ScmdCDstatus);         /* mechanism status */
 326         return scsi(drive, cmd, sizeof(cmd), nil, 0, Sread);
 327 }
 328
 329 void
 330 mmcgetspeed(Drive *drive)
 331 {
 332         int n, maxread, curread, maxwrite, curwrite;
 333         uchar buf[Pagesz];
 334
 335         memset(buf, 0, 22);
 336         n = mmcgetpage(drive, Pagcapmechsts, buf);      /* legacy page */
 337         if (n < 22) {
 338                 if (vflag)
 339                         fprint(2, "no Pagcapmechsts mode page!\n");
 340                 return;
 341         }
 342         maxread =   (buf[8]<<8)|buf[9];
 343         curread =  (buf[14]<<8)|buf[15];
 344         maxwrite = (buf[18]<<8)|buf[19];
 345         curwrite = (buf[20]<<8)|buf[21];
 346
 347         if(maxread && maxread < 170 || curread && curread < 170)
 348                 return;                 /* bogus data */
 349
 350         drive->readspeed = curread;
 351         drive->writespeed = curwrite;
 352         drive->maxreadspeed = maxread;
 353         drive->maxwritespeed = maxwrite;
 354 }
 355
 356 static int
 357 getdevtype(Drive *drive)
 358 {
 359         int n;
 360         uchar cmd[6], resp[Pagesz];
 361
 362         initcdb(cmd, sizeof cmd, ScmdInq);
 363         cmd[3] = sizeof resp >> 8;
 364         cmd[4] = sizeof resp;
 365         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
 366         if (n < 8)
 367                 return -1;
 368         return resp[0] & 037;
 369 }
 370
 371 static int
 372 start(Drive *drive, int code)
 373 {
 374         uchar cmd[6];
 375
 376         initcdb(cmd, sizeof cmd, ScmdStart);
 377         cmd[4] = code;
 378         return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
 379 }
 380
 381 Drive*
 382 mmcprobe(Scsi *scsi)
 383 {
 384         Mmcaux *aux;
 385         Drive *drive;
 386         uchar buf[Pagesz];
 387         int cap, n;
 388
 389         if (vflag)
 390                 print("mmcprobe: inquiry: %s\n", scsi->inquire);
 391         drive = emalloc(sizeof(Drive));
 392         drive->Scsi = *scsi;
 393         drive->Dev = mmcdev;
 394         aux = emalloc(sizeof(Mmcaux));
 395         drive->aux = aux;
 396         scsiready(drive);
 397         drive->type = getdevtype(drive);
 398         if (drive->type != TypeCD) {
 399                 werrstr("not an mmc device");
 400                 free(aux);
 401                 free(drive);
 402                 return nil;
 403         }
 404
 405         /*
 406          * drive is an mmc device; learn what we can about it
 407          * (as opposed to the disc in it).
 408          */
 409
 410         start(drive, 1);
 411         /* attempt to read CD capabilities page, but it's now legacy */
 412         if(mmcgetpage10(drive, Pagcapmechsts, buf) >= 0)
 413                 aux->pagecmdsz = 10;
 414         else if(mmcgetpage6(drive, Pagcapmechsts, buf) >= 0)
 415                 aux->pagecmdsz = 6;
 416         else {
 417                 if (vflag)
 418                         fprint(2, "no Pagcapmechsts mode page!\n");
 419                 werrstr("can't read mode page %d!", Pagcapmechsts);
 420                 free(aux);
 421                 free(drive);
 422                 return nil;
 423         }
 424
 425         cap = 0;
 426         if(buf[Capwrite] & (Capcdr|Capcdrw|Capdvdr|Capdvdram) ||
 427             buf[Capmisc] & Caprw)
 428                 cap |= Cwrite;
 429         if(buf[Capmisc] & Capcdda)      /* CD-DA commands supported? */
 430                 cap |= Ccdda;           /* not used anywhere else */
 431
 432 //      print("read %d max %d\n", biges(buf+14), biges(buf+8));
 433 //      print("write %d max %d\n", biges(buf+20), biges(buf+18));
 434
 435         /* cache optional page 05 (write parameter page) */
 436         if(/* (cap & Cwrite) && */
 437             mmcgetpage(drive, Pagwrparams, aux->page05) >= 0) {
 438                 aux->page05ok = 1;
 439                 cap |= Cwrite;
 440                 if (vflag)
 441                         fprint(2, "mmcprobe: got page 5, assuming drive can write\n");
 442         } else {
 443                 if (vflag)
 444                         fprint(2, "no Pagwrparams mode page!\n");
 445                 cap &= ~Cwrite;
 446         }
 447         drive->cap = cap;
 448
 449         mmcgetspeed(drive);
 450
 451         /*
 452          * we can't actually control caching much.
 453          * see SBC-2 §6.3.3 but also MMC-6 §7.6.
 454          */
 455         n = mmcgetpage(drive, Pagcache, buf);
 456         if (n >= 3) {
 457                 /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */
 458                 buf[0] &= 077;          /* clear reserved bits, MMC-6 §7.2.3 */
 459                 assert(buf[0] == Pagcache);
 460                 assert(buf[1] >= 10);
 461                 buf[2] = Ccwce;
 462                 if (mmcsetpage(drive, Pagcache, buf) < 0)
 463                         if (vflag)
 464                                 print("mmcprobe: cache control NOT set\n");
 465         }
 466         return drive;
 467 }
 468
 469 static char *tracktype[] = {    /* indices are track modes (Tm*) */
 470         "audio cdda",
 471         "2 audio channels",
 472         "2",
 473         "3",
 474         "data, recorded uninterrupted",
 475         "data, recorded interrupted",
 476 };
 477
 478 /* t is a track number on disc, i is an index into drive->track[] for result */
 479 static int
 480 mmctrackinfo(Drive *drive, int t, int i)
 481 {
 482         int n, type, bs;
 483         ulong beg, size;
 484         uchar tmode;
 485         uchar cmd[10], resp[255];
 486         Mmcaux *aux;
 487
 488         aux = drive->aux;
 489         memset(cmd, 0, sizeof(cmd));
 490         cmd[0] = ScmdRtrackinfo;
 491         cmd[1] = 1;                     /* address below is logical track # */
 492         cmd[2] = t>>24;
 493         cmd[3] = t>>16;
 494         cmd[4] = t>>8;
 495         cmd[5] = t;
 496         cmd[7] = sizeof(resp)>>8;
 497         cmd[8] = sizeof(resp);
 498         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
 499         if(n < 28) {
 500                 if(vflag)
 501                         print("trackinfo %d fails n=%d: %r\n", t, n);
 502                 return -1;
 503         }
 504
 505         beg = bige(&resp[8]);
 506         size = bige(&resp[24]);
 507
 508         tmode = resp[5] & 0x0D;
 509 //      dmode = resp[6] & 0x0F;
 510
 511         if(vflag)
 512                 print("track %d type %d (%s)", t, tmode,
 513                         (tmode < nelem(tracktype)? tracktype[tmode]: "**GOK**"));
 514         type = TypeNone;
 515         bs = BScdda;
 516         switch(tmode){
 517         case Tmcdda:
 518                 type = TypeAudio;
 519                 bs = BScdda;
 520                 break;
 521         case Tm2audio:  /* 2 audio channels, with pre-emphasis 50/15 μs */
 522                 if(vflag)
 523                         print("audio channels with preemphasis on track %d "
 524                                 "(u%.3d)\n", t, i);
 525                 type = TypeNone;
 526                 break;
 527         case Tmunintr:          /* data track, recorded uninterrupted */
 528         case Tmintr:            /* data track, recorded interrupted */
 529                 /* treat Tmintr (5) as cdrom; it's probably dvd or bd */
 530                 type = TypeData;
 531                 bs = BScdrom;
 532                 break;
 533         default:
 534                 if(vflag)
 535                         print("unknown track type %d\n", tmode);
 536                 break;
 537         }
 538
 539         drive->track[i].mtime = drive->changetime;
 540         drive->track[i].beg = beg;
 541         drive->track[i].end = beg+size;
 542         drive->track[i].type = type;
 543         drive->track[i].bs = bs;
 544         drive->track[i].size = (vlong)(size-2) * bs;    /* -2: skip lead out */
 545
 546         if(resp[6] & (1<<6)) {                  /* blank? */
 547                 drive->track[i].type = TypeBlank;
 548                 drive->writeok = 1;
 549         }
 550
 551         if(vflag)
 552                 print(" start %lud end %lud", beg, beg + size - 1);
 553         /* resp[6] & (1<<7) of zero: invisible track */
 554         /* t == getinvistrack(): invisible track */
 555         if(t == Invistrack || resp[7] & 1) {    /* invis or nwa valid? */
 556                 aux->mmcnwa = bige(&resp[12]);
 557                 if ((long)aux->mmcnwa < 0)      /* implausible? */
 558                         aux->mmcnwa = 0;
 559                 if (vflag)
 560                         print(" nwa %lud", aux->mmcnwa);
 561         }
 562         if (vflag)
 563                 print("\n");
 564         return 0;
 565 }
 566
 567 /* this may fail for blank media */
 568 static int
 569 mmcreadtoc(Drive *drive, int type, int track, void *data, int nbytes)
 570 {
 571         uchar cmd[10];
 572
 573         memset(cmd, 0, sizeof(cmd));
 574         cmd[0] = ScmdRTOC;
 575         cmd[1] = type;                          /* msf bit & reserved */
 576         cmd[2] = Tocfmttoc;
 577         cmd[6] = track;                         /* track/session */
 578         cmd[7] = nbytes>>8;
 579         cmd[8] = nbytes;
 580
 581         /*
 582          * printing iounit(drive->Scsi.rawfd) here yields
 583          *      iounit(3) = 0;          # for local access
 584          *      iounit(3) = 65512;      # for remote access via /mnt/term
 585          */
 586         return scsi(drive, cmd, sizeof(cmd), data, nbytes, Sread);
 587 }
 588
 589 static int
 590 mmcreaddiscinfo(Drive *drive, void *data, int nbytes)
 591 {
 592         uchar cmd[10];
 593         int n;
 594
 595         memset(cmd, 0, sizeof(cmd));
 596         cmd[0] = ScmdRdiscinfo;
 597         cmd[7] = nbytes>>8;
 598         cmd[8] = nbytes;
 599         n = scsi(drive, cmd, sizeof(cmd), data, nbytes, Sread);
 600         if(n < 24) {
 601                 if(n >= 0)
 602                         werrstr("rdiscinfo returns %d", n);
 603                 return -1;
 604         }
 605
 606         return n;
 607 }
 608
 609 static Msf
 610 rdmsf(uchar *p)
 611 {
 612         Msf msf;
 613
 614         msf.m = p[0];
 615         msf.s = p[1];
 616         msf.f = p[2];
 617         return msf;
 618 }
 619
 620 static int
 621 getdiscinfo(Drive *drive, uchar resp[], int resplen)
 622 {
 623         int n;
 624
 625         n = mmcreaddiscinfo(drive, resp, resplen);
 626         if(n < 3) {
 627                 if (vflag)
 628                         fprint(2, "read disc info failed\n");
 629                 return n;
 630         }
 631         if (vflag)
 632                 fprint(2, "read disc info succeeded\n");
 633         assert((resp[2] & 0340) == 0);                  /* data type 0 */
 634         drive->erasable = ((resp[2] & 0x10) != 0);      /* -RW? */
 635         drive->erasableset = 1;
 636         return n;
 637 }
 638
 639 static int
 640 getdvdstruct(Drive *drive)
 641 {
 642         int n, cat;
 643         uchar cmd[12], resp[Pagesz];
 644
 645         initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
 646         cmd[1] = 0;                     /* media type: dvd */
 647         cmd[7] = 0;                     /* format code: physical format */
 648         cmd[8] = sizeof resp >> 8;      /* allocation length */
 649         cmd[9] = sizeof resp;
 650         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
 651         if (n < 7)
 652                 return -1;
 653
 654 //      print("dvd structure:\n");
 655 //      hexdump(resp, n);
 656
 657         /* resp[0..1] is resp length */
 658         cat = (resp[4] & 0xf0) >> 4;    /* disk category, MMC-6 §6.22.3.2.1 */
 659         if (vflag)
 660                 fprint(2, "dvd type is %s\n", dvdtype[cat]);
 661         drive->dvdtype = dvdtype[cat];
 662         /* write parameters mode page may suffice to compute writeok for dvd */
 663         drive->erasable = drive->recordable = 0;
 664         /*
 665          * the layer-type field is a *bit array*,
 666          * though an enumeration of types would make more sense,
 667          * since the types are exclusive, not orthogonal.
 668          */
 669         if (resp[6] & (1<<2))                   /* rewritable? */
 670                 drive->erasable = 1;
 671         else if (resp[6] & (1<<1))              /* recordable once? */
 672                 drive->recordable = 1;
 673         else {                                  /* factory-pressed disk */
 674                 drive->blank = 0;
 675                 drive->blankset = 1;
 676         }
 677         drive->erasableset = drive->recordableset = 1;
 678         drive->mmctype = (cat >= 8? Mmcdvdplus: Mmcdvdminus);
 679         return 0;
 680 }
 681
 682 static int
 683 getbdstruct(Drive *drive)
 684 {
 685         int n;
 686         uchar cmd[12], resp[4100];
 687
 688         initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
 689         cmd[1] = 1;                     /* media type: bd */
 690         cmd[7] = 0;                     /* format code: disc info */
 691         cmd[8] = sizeof resp >> 8;      /* allocation length */
 692         cmd[9] = sizeof resp;
 693         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
 694         /*
 695          * resp[0..1] is resp length.
 696          * resp[4+8..4+8+2] is bd type (disc type identifier):
 697          * BDO|BDW|BDR, MMC-6 §6.22.3.3.1.  The above command should
 698          * fail on DVD drives, but some seem to ignore media type
 699          * and return successfully, so verify that it's a BD drive.
 700          */
 701         if (n < 4+8+3 || resp[4+8] != 'B' || resp[4+8+1] != 'D')
 702                 return -1;
 703         if (vflag)
 704                 fprint(2, "read disc structure (bd) succeeded\n");
 705         drive->erasable = drive->recordable = 0;
 706         switch (resp[4+8+2]) {
 707         case 'O':
 708                 drive->blank = 0;
 709                 drive->blankset = 1;
 710                 break;
 711         case 'R':                               /* Recordable */
 712                 drive->recordable = 1;
 713                 break;
 714         case 'W':                               /* reWritable */
 715                 drive->erasable = 1;
 716                 break;
 717         default:
 718                 fprint(2, "%s: unknown bd type BD%c\n", argv0, resp[4+8+2]);
 719                 return -1;
 720         }
 721         drive->erasableset = drive->recordableset = 1;
 722         drive->mmctype = Mmcbd;
 723         return 0;
 724 }
 725
 726 /*
 727  * infer endings from the beginnings of other tracks.
 728  */
 729 static void
 730 mmcinfertracks(Drive *drive, int first, int last)
 731 {
 732         int i;
 733         uchar resp[1024];
 734         ulong tot;
 735         Track *t;
 736
 737         if (vflag)
 738                 fprint(2, "inferring tracks\n");
 739         for(i = first; i <= last; i++) {
 740                 memset(resp, 0, sizeof(resp));
 741                 if(mmcreadtoc(drive, 0, i, resp, sizeof(resp)) < 0)
 742                         break;
 743                 t = &drive->track[i-first];
 744                 t->mtime = drive->changetime;
 745                 t->type = TypeData;
 746                 t->bs = BScdrom;
 747                 t->beg = bige(resp+8);
 748                 if(!(resp[5] & 4)) {
 749                         t->type = TypeAudio;
 750                         t->bs = BScdda;
 751                 }
 752         }
 753
 754         if((long)drive->track[0].beg < 0)  /* i've seen negative track 0's */
 755                 drive->track[0].beg = 0;
 756
 757         tot = 0;
 758         memset(resp, 0, sizeof(resp));
 759         /* 0xAA is lead-out */
 760         if(mmcreadtoc(drive, 0, 0xAA, resp, sizeof(resp)) < 0)
 761                 print("bad\n");
 762         if(resp[6])
 763                 tot = bige(resp+8);
 764
 765         for(i=last; i>=first; i--) {
 766                 t = &drive->track[i-first];
 767                 t->end = tot;
 768                 tot = t->beg;
 769                 if(t->end <= t->beg)
 770                         t->beg = t->end = 0;
 771                 /* -2: skip lead out */
 772                 t->size = (t->end - t->beg - 2) * (vlong)t->bs;
 773         }
 774 }
 775
 776 /* this gets called a lot from main.c's 9P routines */
 777 static int
 778 mmcgettoc(Drive *drive)
 779 {
 780         int i, n, first, last;
 781         uchar resp[1024];
 782         Mmcaux *aux;
 783
 784         /*
 785          * if someone has swapped the cd,
 786          * mmcreadtoc will get ``medium changed'' and the
 787          * scsi routines will set nchange and changetime in the
 788          * scsi device.
 789          */
 790         mmcreadtoc(drive, 0, 0, resp, sizeof(resp));
 791         if(drive->Scsi.changetime == 0) {       /* no media present */
 792                 drive->mmctype = Mmcnone;
 793                 drive->ntrack = 0;
 794                 return 0;
 795         }
 796         /*
 797          * if the disc doesn't appear to be have been changed, and there
 798          * is a disc in this drive, there's nothing to do (the common case).
 799          */
 800         if(drive->nchange == drive->Scsi.nchange && drive->changetime != 0)
 801                 return 0;
 802
 803         /*
 804          * the disc in the drive may have just been changed,
 805          * so rescan it and relearn all about it.
 806          */
 807
 808         drive->ntrack = 0;
 809         drive->nameok = 0;
 810         drive->nchange = drive->Scsi.nchange;
 811         drive->changetime = drive->Scsi.changetime;
 812         drive->writeok = drive->erasable = drive->recordable = drive->blank = 0;
 813         drive->erasableset = drive->recordableset = drive->blankset = 0;
 814         aux = drive->aux;
 815         aux->mmcnwa = 0;
 816         aux->nropen = aux->nwopen = 0;
 817         aux->ntotby = aux->ntotbk = 0;
 818
 819         for(i=0; i<nelem(drive->track); i++){
 820                 memset(&drive->track[i].mbeg, 0, sizeof(Msf));
 821                 memset(&drive->track[i].mend, 0, sizeof(Msf));
 822         }
 823
 824         /*
 825          * TODO: set read ahead, MMC-6 §6.37, seems to control caching.
 826          */
 827
 828         /*
 829          * find number of tracks
 830          */
 831         if((n = mmcreadtoc(drive, Msfbit, 0, resp, sizeof(resp))) < 4) {
 832                 /*
 833                  * on a blank disc in a cd-rw, use readdiscinfo
 834                  * to find the track info.
 835                  */
 836                 if(getdiscinfo(drive, resp, sizeof(resp)) < 7)
 837                         return -1;
 838                 assert((resp[2] & 0340) == 0);  /* data type 0 */
 839                 if(resp[4] != 1)
 840                         print("multi-session disc %d\n", resp[4]);
 841                 first = resp[3];
 842                 last = resp[6];
 843                 if(vflag)
 844                         print("blank disc %d %d\n", first, last);
 845                 /* the assumption of blankness may be unwarranted */
 846                 drive->writeok = drive->blank = drive->blankset = 1;
 847         } else {
 848                 first = resp[2];
 849                 last = resp[3];
 850
 851                 if(n >= 4+8*(last-first+2)) {
 852                         /* resp[4 + i*8 + 2] is track # */
 853                         /* <=: track[last-first+1] = end */
 854                         for(i=0; i<=last-first+1; i++)
 855                                 drive->track[i].mbeg = rdmsf(resp+4+i*8+5);
 856                         for(i=0; i<last-first+1; i++)
 857                                 drive->track[i].mend = drive->track[i+1].mbeg;
 858                 }
 859         }
 860
 861         drive->mmctype = Mmcnone;
 862         drive->dvdtype = nil;
 863         getdvdstruct(drive);
 864         getbdstruct(drive);
 865         if (drive->mmctype == Mmcnone)
 866                 drive->mmctype = Mmccd;         /* by default */
 867         if (drive->recordable || drive->erasable)
 868                 drive->writeok = 1;
 869
 870         if (vflag) {
 871                 fprint(2, "writeok %d", drive->writeok);
 872                 /* drive->blank is never used and hard to figure out */
 873 //              if (drive->blankset)
 874 //                      fprint(2, " blank %d", drive->blank);
 875                 if (drive->recordableset)
 876                         fprint(2, " recordable %d", drive->recordable);
 877                 if (drive->erasableset)
 878                         fprint(2, " erasable %d", drive->erasable);
 879                 fprint(2, "\n");
 880                 print("first %d last %d\n", first, last);
 881         }
 882
 883         if(first == 0 && last == 0)
 884                 first = 1;
 885
 886         if(first <= 0 || first >= Maxtrack) {
 887                 werrstr("first table %d not in range", first);
 888                 return -1;
 889         }
 890         if(last <= 0 || last >= Maxtrack) {
 891                 werrstr("last table %d not in range", last);
 892                 return -1;
 893         }
 894
 895         if(drive->cap & Cwrite)                 /* CDR drives are easy */
 896                 for(i = first; i <= last; i++)
 897                         mmctrackinfo(drive, i, i - first);
 898         else
 899                 /*
 900                  * otherwise we need to infer endings from the
 901                  * beginnings of other tracks.
 902                  */
 903                 mmcinfertracks(drive, first, last);
 904
 905         drive->firsttrack = first;
 906         drive->ntrack = last+1-first;
 907         return 0;
 908 }
 909
 910 static void
 911 settrkmode(uchar *p, int mode)
 912 {
 913         p[Wptrkmode] &= ~0xf;
 914         p[Wptrkmode] |= mode;
 915 }
 916
 917 /*
 918  * this uses page 5, which is optional.
 919  */
 920 static int
 921 mmcsetbs(Drive *drive, int bs)
 922 {
 923         uchar *p;
 924         Mmcaux *aux;
 925
 926         aux = drive->aux;
 927         if (!aux->page05ok)
 928                 return 0;                       /* harmless; assume 2k */
 929
 930         p = aux->page05;
 931         /*
 932          * establish defaults.
 933          */
 934         p[0] &= 077;                    /* clear reserved bits, MMC-6 §7.2.3 */
 935         p[Wpwrtype] = Bufe | Wttrackonce;
 936 //      if(testonlyflag)
 937 //              p[Wpwrtype] |= 0x10;    /* test-write */
 938         /* assume dvd values as defaults */
 939         settrkmode(p, Tmintr);
 940         p[Wptrkmode] |= Msnext;
 941         p[Wpdatblktype] = Db2kdata;
 942         p[Wpsessfmt] = Sfdata;
 943
 944         switch(drive->mmctype) {
 945         case Mmcdvdplus:
 946         case Mmcbd:
 947                 break;
 948         case Mmcdvdminus:
 949                 /* dvd-r can only do disc-at-once or incremental */
 950                 p[Wpwrtype] = Bufe | Wtsessonce;
 951                 break;
 952         case Mmccd:
 953                 settrkmode(p, Tmunintr); /* data track, uninterrupted */
 954                 switch(bs){
 955                 case BScdda:
 956                         /* 2 audio channels without pre-emphasis */
 957                         settrkmode(p, Tmcdda);  /* TODO: should be Tm2audio? */
 958                         p[Wpdatblktype] = Dbraw;
 959                         break;
 960                 case BScdrom:
 961                         break;
 962                 case BScdxa:
 963                         p[Wpdatblktype] = Db2336;
 964                         p[Wpsessfmt] = Sfcdxa;
 965                         break;
 966                 default:
 967                         fprint(2, "%s: unknown CD type; bs %d\n", argv0, bs);
 968                         assert(0);
 969                 }
 970                 break;
 971         default:
 972                 fprint(2, "%s: unknown disc sub-type %d\n",
 973                         argv0, drive->mmctype);
 974                 break;
 975         }
 976         if(mmcsetpage(drive, Pagwrparams, p) < 0) {
 977                 if (vflag)
 978                         fprint(2, "mmcsetbs: could NOT set write parameters page\n");
 979                 return -1;
 980         }
 981         return 0;
 982 }
 983
 984 /* off is a block number */
 985 static long
 986 mmcread(Buf *buf, void *v, long nblock, ulong off)
 987 {
 988         int bs;
 989         long n, nn;
 990         uchar cmd[12];
 991         Drive *drive;
 992         Otrack *o;
 993
 994         o = buf->otrack;
 995         drive = o->drive;
 996         bs = o->track->bs;
 997         off += o->track->beg;
 998
 999         if(nblock >= (1<<10)) {
1000                 werrstr("mmcread too big");
1001                 if(vflag)
1002                         fprint(2, "mmcread too big\n");
1003                 return -1;
1004         }
1005
1006         /* truncate nblock modulo size of track */
1007         if(off > o->track->end - 2) {
1008                 werrstr("read past end of track");
1009                 if(vflag)
1010                         fprint(2, "end of track (%ld->%ld off %ld)",
1011                                 o->track->beg, o->track->end - 2, off);
1012                 return -1;
1013         }
1014         if(off == o->track->end - 2)
1015                 return 0;
1016
1017         if(off+nblock > o->track->end - 2)
1018                 nblock = o->track->end - 2 - off;
1019
1020         /*
1021          * `read cd' only works for CDs; for everybody else,
1022          * we'll try plain `read (12)'.  only use read cd if it's
1023          * a cd drive with a cd in it and we're not reading data
1024          * (e.g., reading audio).
1025          */
1026         memset(cmd, 0, sizeof(cmd));
1027         if (drive->type == TypeCD && drive->mmctype == Mmccd && bs != BScdrom) {
1028                 cmd[0] = ScmdReadcd;
1029                 cmd[2] = off>>24;
1030                 cmd[3] = off>>16;
1031                 cmd[4] = off>>8;
1032                 cmd[5] = off>>0;
1033                 cmd[6] = nblock>>16;
1034                 cmd[7] = nblock>>8;
1035                 cmd[8] = nblock>>0;
1036                 cmd[9] = 0x10;
1037                 switch(bs){
1038                 case BScdda:
1039                         cmd[1] = 0x04;
1040                         break;
1041                 case BScdrom:
1042                         cmd[1] = 0x08;
1043                         break;
1044                 case BScdxa:
1045                         cmd[1] = 0x0C;
1046                         break;
1047                 default:
1048                         werrstr("unknown bs %d", bs);
1049                         return -1;
1050                 }
1051         } else {                        /* e.g., TypeDA */
1052                 cmd[0] = ScmdRead12;
1053                 cmd[2] = off>>24;
1054                 cmd[3] = off>>16;
1055                 cmd[4] = off>>8;
1056                 cmd[5] = off>>0;
1057                 cmd[6] = nblock>>24;
1058                 cmd[7] = nblock>>16;
1059                 cmd[8] = nblock>>8;
1060                 cmd[9] = nblock;
1061                 // cmd[10] = 0x80;      /* streaming */
1062         }
1063         n = nblock*bs;
1064         nn = scsi(drive, cmd, sizeof(cmd), v, n, Sread);
1065         if(nn != n) {
1066                 if(nn != -1)
1067                         werrstr("short read %ld/%ld", nn, n);
1068                 if(vflag)
1069                         print("read off %lud nblock %ld bs %d failed\n",
1070                                 off, nblock, bs);
1071                 return -1;
1072         }
1073
1074         return nblock;
1075 }
1076
1077 static Otrack*
1078 mmcopenrd(Drive *drive, int trackno)
1079 {
1080         Otrack *o;
1081         Mmcaux *aux;
1082
1083         if(trackno < 0 || trackno >= drive->ntrack) {
1084                 werrstr("track number out of range");
1085                 return nil;
1086         }
1087
1088         aux = drive->aux;
1089         if(aux->nwopen) {
1090                 werrstr("disk in use for writing");
1091                 return nil;
1092         }
1093
1094         o = emalloc(sizeof(Otrack));
1095         o->drive = drive;
1096         o->track = &drive->track[trackno];
1097         o->nchange = drive->nchange;
1098         o->omode = OREAD;
1099         o->buf = bopen(mmcread, OREAD, o->track->bs, Readblock);
1100         o->buf->otrack = o;
1101
1102         aux->nropen++;
1103
1104         return o;
1105 }
1106
1107 static int
1108 format(Drive *drive)
1109 {
1110         ulong nblks, blksize;
1111         uchar *fmtdesc;
1112         uchar cmd[6], parms[4+8];
1113
1114         if (drive->recordable && drive->mmctype != Mmcbd) {
1115                 werrstr("don't format write-once cd or dvd media");
1116                 return -1;
1117         }
1118         initcdb(cmd, sizeof cmd, ScmdFormat);   /* format unit */
1119         cmd[1] = 0x10 | 1;              /* format data, mmc format code */
1120
1121         memset(parms, 0, sizeof parms);
1122         /* format list header */
1123         parms[1] = 2;                   /* immediate return; don't wait */
1124         parms[3] = 8;                   /* format descriptor length */
1125
1126         fmtdesc = parms + 4;
1127         fmtdesc[4] = 0;                 /* full format */
1128
1129         nblks = 0;
1130         blksize = BScdrom;
1131         switch (drive->mmctype) {
1132         case Mmccd:
1133                 nblks = 0;
1134                 break;
1135         case Mmcdvdplus:
1136                 /* format type 0 is optional but equiv to format type 0x26 */
1137                 fmtdesc[4] = 0x26 << 2;
1138                 nblks = ~0ul;
1139                 blksize = 0;
1140                 break;
1141         }
1142
1143         PUTBELONG(fmtdesc, nblks);
1144         PUTBE24(fmtdesc + 5, blksize);
1145
1146 //      print("format parameters:\n");
1147 //      hexdump(parms, sizeof parms);
1148
1149         if(vflag)
1150                 print("%lld ns: format\n", nsec());
1151         return scsi(drive, cmd, sizeof(cmd), parms, sizeof parms, Swrite);
1152 }
1153
1154 static long
1155 mmcxwrite(Otrack *o, void *v, long nblk)
1156 {
1157         uchar cmd[10];
1158         Mmcaux *aux;
1159
1160         assert(o->omode == OWRITE);
1161         aux = o->drive->aux;
1162         if (aux->mmcnwa == 0 && scsiready(o->drive) < 0) {
1163                 werrstr("device not ready to write");
1164                 return -1;
1165         }
1166         aux->ntotby += nblk*o->track->bs;
1167         aux->ntotbk += nblk;
1168
1169         memset(cmd, 0, sizeof(cmd));
1170         cmd[0] = ScmdExtwrite;          /* write (10) */
1171         cmd[2] = aux->mmcnwa>>24;
1172         cmd[3] = aux->mmcnwa>>16;
1173         cmd[4] = aux->mmcnwa>>8;
1174         cmd[5] = aux->mmcnwa;
1175         cmd[7] = nblk>>8;
1176         cmd[8] = nblk>>0;
1177         if(vflag)
1178                 print("%lld ns: write %ld at 0x%lux\n",
1179                         nsec(), nblk, aux->mmcnwa);
1180         aux->mmcnwa += nblk;
1181         return scsi(o->drive, cmd, sizeof(cmd), v, nblk*o->track->bs, Swrite);
1182 }
1183
1184 static long
1185 mmcwrite(Buf *buf, void *v, long nblk, ulong)
1186 {
1187         return mmcxwrite(buf->otrack, v, nblk);
1188 }
1189
1190 enum {
1191         Eccblk  = 128,          /* sectors per ecc block */
1192         Rsvslop = 0,
1193 };
1194
1195 static int
1196 reserve(Drive *drive, int track)
1197 {
1198         ulong sz;
1199         uchar cmd[10];
1200
1201         initcdb(cmd, sizeof cmd, ScmdReserve);
1202         track -= drive->firsttrack;             /* switch to zero-origin */
1203         if (track >= 0 && track < drive->ntrack)
1204                 /* .end is next sector past sz */
1205                 sz = drive->track[track].end - drive->track[track].beg - Rsvslop;
1206         else {
1207                 sz = Eccblk;
1208                 fprint(2, "%s: reserve: track #%d out of range 0-%d\n",
1209                         argv0, track, drive->ntrack);
1210         }
1211         sz -= sz % Eccblk;              /* round down to ecc-block multiple */
1212         if ((long)sz < 0) {
1213                 fprint(2, "%s: reserve: bogus size %lud\n", argv0, sz);
1214                 return -1;
1215         }
1216         cmd[1] = 0;                     /* no ASRV: allocate by size not lba */
1217         PUTBELONG(cmd + 2 + 3, sz);
1218         if (vflag)
1219                 fprint(2, "reserving %ld sectors\n", sz);
1220         return scsi(drive, cmd, sizeof cmd, cmd, 0, Snone);
1221 }
1222
1223 static int
1224 getinvistrack(Drive *drive)
1225 {
1226         int n;
1227         uchar cmd[10], resp[Pagesz];
1228
1229         initcdb(cmd, sizeof(cmd), ScmdRtrackinfo);
1230         cmd[1] = 1<<2 | 1;      /* open; address below is logical track # */
1231         PUTBELONG(cmd + 2, 1);          /* find first open track */
1232         cmd[7] = sizeof(resp)>>8;
1233         cmd[8] = sizeof(resp);
1234         n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
1235         if(n < 4) {
1236                 if(vflag)
1237                         print("trackinfo for invis track fails n=%d: %r\n", n);
1238                 return -1;
1239         }
1240
1241         if(vflag)
1242                 print("getinvistrack: track #%d session #%d\n",
1243                         resp[2], resp[3]);
1244         return resp[2];
1245 }
1246
1247 static Otrack*
1248 mmccreate(Drive *drive, int type)
1249 {
1250         int bs, invis;
1251         Mmcaux *aux;
1252         Track *t;
1253         Otrack *o;
1254
1255         aux = drive->aux;
1256
1257         if(aux->nropen || aux->nwopen) {
1258                 werrstr("drive in use");
1259                 return nil;
1260         }
1261
1262         switch(type){
1263         case TypeAudio:
1264                 bs = BScdda;
1265                 break;
1266         case TypeData:
1267                 bs = BScdrom;
1268                 break;
1269         default:
1270                 werrstr("bad type %d", type);
1271                 return nil;
1272         }
1273
1274         invis = getinvistrack(drive);
1275         if (invis < 0)
1276                 invis = Invistrack;
1277
1278         /* comment out the returns for now; it should be no big deal - geoff */
1279         if(mmctrackinfo(drive, invis, Maxtrack)) {
1280                 if (vflag)
1281                         fprint(2, "mmccreate: mmctrackinfo for invis track %d"
1282                                 " failed: %r\n", invis);
1283                 werrstr("disc not writable");
1284 //              return nil;
1285         }
1286         if(mmcsetbs(drive, bs) < 0) {
1287                 werrstr("cannot set bs mode");
1288 //              return nil;
1289         }
1290         if(mmctrackinfo(drive, invis, Maxtrack)) {
1291                 if (vflag)
1292                         fprint(2, "mmccreate: mmctrackinfo for invis track %d"
1293                                 " (2) failed: %r\n", invis);
1294                 werrstr("disc not writable 2");
1295 //              return nil;
1296         }
1297
1298         /* special hack for dvd-r: reserve the invisible track */
1299         if (drive->mmctype == Mmcdvdminus && drive->writeok &&
1300             drive->recordable && reserve(drive, invis) < 0) {
1301                 if (vflag)
1302                         fprint(2, "mmcreate: reserving track %d for dvd-r "
1303                                 "failed: %r\n", invis);
1304                 return nil;
1305         }
1306
1307         aux->ntotby = 0;
1308         aux->ntotbk = 0;
1309
1310         t = &drive->track[drive->ntrack++];
1311         t->size = 0;
1312         t->bs = bs;
1313         t->beg = aux->mmcnwa;
1314         t->end = 0;
1315         t->type = type;
1316         drive->nameok = 0;
1317
1318         o = emalloc(sizeof(Otrack));
1319         o->drive = drive;
1320         o->nchange = drive->nchange;
1321         o->omode = OWRITE;
1322         o->track = t;
1323         o->buf = bopen(mmcwrite, OWRITE, bs, Readblock);
1324         o->buf->otrack = o;
1325
1326         aux->nwopen++;
1327
1328         if(vflag)
1329                 print("mmcinit: nwa = 0x%luX\n", aux->mmcnwa);
1330         return o;
1331 }
1332
1333 /*
1334  * issue some form of close track, close session or finalize disc command.
1335  * see The Matrix, table 252 in MMC-6 §6.3.2.3.
1336  */
1337 static int
1338 mmcxclose(Drive *drive, int clf, int trackno)
1339 {
1340         uchar cmd[10];
1341
1342         memset(cmd, 0, sizeof(cmd));
1343         cmd[0] = ScmdClosetracksess;
1344         /* cmd[1] & 1 is the immediate bit */
1345         cmd[2] = clf;                           /* close function */
1346         if(clf == Closetrack)
1347                 cmd[5] = trackno;
1348         return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
1349 }
1350
1351 /* flush drive cache, close current track */
1352 void
1353 mmcsynccache(Drive *drive)
1354 {
1355         int invis;
1356         uchar cmd[10];
1357         Mmcaux *aux;
1358
1359         initcdb(cmd, sizeof cmd, ScmdSynccache);
1360         /*
1361          * this will take a long time to burn the remainder of a dvd-r
1362          * with a reserved track covering the whole disc.
1363          */
1364         if (vflag) {
1365                 fprint(2, "syncing cache");
1366                 if (drive->mmctype == Mmcdvdminus && drive->writeok &&
1367                     drive->recordable)
1368                         fprint(2, "; dvd-r burning rest of track reservation, "
1369                                 "will be slow");
1370                 fprint(2, "\n");
1371         }
1372         scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
1373         if(vflag) {
1374                 aux = drive->aux;
1375                 print("mmcsynccache: bytes = %lld blocks = %ld, mmcnwa 0x%luX\n",
1376                         aux->ntotby, aux->ntotbk, aux->mmcnwa);
1377         }
1378
1379         invis = getinvistrack(drive);
1380         if (invis < 0)
1381                 invis = Invistrack;
1382         /*
1383          * rsc: seems not to work on some drives.
1384          * so ignore return code & don't issue on dvd+rw.
1385          */
1386         if(drive->mmctype != Mmcdvdplus || !drive->erasable) {
1387                 if (vflag)
1388                         fprint(2, "closing invisible track %d (not dvd+rw)...\n",
1389                                 invis);
1390                 mmcxclose(drive, Closetrack, invis);
1391                 if (vflag)
1392                         fprint(2, "... done.\n");
1393         }
1394 }
1395
1396 /*
1397  * close the open track `o'.
1398  */
1399 static void
1400 mmcclose(Otrack *o)
1401 {
1402         Mmcaux *aux;
1403         static uchar zero[2*BSmax];
1404
1405         aux = o->drive->aux;
1406         if(o->omode == OREAD)
1407                 aux->nropen--;
1408         else if(o->omode == OWRITE) {
1409                 aux->nwopen--;
1410                 mmcxwrite(o, zero, 2);  /* write lead out */
1411                 mmcsynccache(o->drive);
1412                 o->drive->nchange = -1; /* force reread toc */
1413         }
1414         free(o);
1415 }
1416
1417 static int
1418 setonesess(Drive *drive)
1419 {
1420         uchar *p;
1421         Mmcaux *aux;
1422
1423         /* page 5 is legacy and now read-only; see MMC-6 §7.5.4.1 */
1424         aux = drive->aux;
1425         p = aux->page05;
1426         p[Wptrkmode] &= ~Msbits;
1427         p[Wptrkmode] |= Msnonext;
1428         return mmcsetpage(drive, Pagwrparams, p);
1429 }
1430
1431 /*
1432  * close the current session, then finalize the disc.
1433  */
1434 static int
1435 mmcfixate(Drive *drive)
1436 {
1437         int r;
1438
1439         if((drive->cap & Cwrite) == 0) {
1440                 werrstr("not a writer");
1441                 return -1;
1442         }
1443         drive->nchange = -1;            /* force reread toc */
1444
1445         setonesess(drive);
1446
1447         /* skip explicit close session on bd-r */
1448         if (drive->mmctype != Mmcbd || drive->erasable) {
1449                 if (vflag)
1450                         fprint(2, "closing session and maybe finalizing...\n");
1451                 r = mmcxclose(drive, Closesessfinal, 0);
1452                 if (vflag)
1453                         fprint(2, "... done.\n");
1454                 if (r < 0)
1455                         return r;
1456         }
1457         /*
1458          * Closesessfinal only closes & doesn't finalize on dvd+r and bd-r.
1459          * Closedvdrbdfinal closes & finalizes dvd+r and bd-r.
1460          */
1461         if ((drive->mmctype == Mmcdvdplus || drive->mmctype == Mmcbd) &&
1462             !drive->erasable) {
1463                 if (vflag)
1464                         fprint(2, "finalizing dvd+r or bd-r... "
1465                                 "(won't print `done').\n");
1466                 return mmcxclose(drive, Closedvdrbdfinal, 0);
1467         }
1468         return 0;
1469 }
1470
1471 static int
1472 mmcblank(Drive *drive, int quick)
1473 {
1474         uchar cmd[12];
1475
1476         drive->nchange = -1;            /* force reread toc */
1477
1478         memset(cmd, 0, sizeof(cmd));
1479         cmd[0] = ScmdBlank;             /* blank cd-rw media */
1480         /* immediate bit is 0x10 */
1481         /* cmd[1] = 0 means blank the whole disc; = 1 just the header */
1482         cmd[1] = quick ? 0x01 : 0x00;
1483
1484         return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
1485 }
1486
1487 static char*
1488 e(int status)
1489 {
1490         if(status < 0)
1491                 return geterrstr();
1492         return nil;
1493 }
1494
1495 static char*
1496 mmcctl(Drive *drive, int argc, char **argv)
1497 {
1498         char *cmd;
1499
1500         if(argc < 1)
1501                 return nil;
1502         cmd = argv[0];
1503         if(strcmp(cmd, "format") == 0)
1504                 return e(format(drive));
1505         if(strcmp(cmd, "blank") == 0)
1506                 return e(mmcblank(drive, 0));
1507         if(strcmp(cmd, "quickblank") == 0)
1508                 return e(mmcblank(drive, 1));
1509         if(strcmp(cmd, "eject") == 0)
1510                 return e(start(drive, 2));
1511         if(strcmp(cmd, "ingest") == 0)
1512                 return e(start(drive, 3));
1513         return "bad arg";
1514 }
1515
1516 static char*
1517 mmcsetspeed(Drive *drive, int r, int w)
1518 {
1519         char *rv;
1520         uchar cmd[12];
1521
1522         memset(cmd, 0, sizeof(cmd));
1523         cmd[0] = ScmdSetcdspeed;
1524         cmd[2] = r>>8;
1525         cmd[3] = r;
1526         cmd[4] = w>>8;
1527         cmd[5] = w;
1528         rv = e(scsi(drive, cmd, sizeof(cmd), nil, 0, Snone));
1529         mmcgetspeed(drive);
1530         return rv;
1531 }
1532
1533 static Dev mmcdev = {
1534         mmcopenrd,
1535         mmccreate,
1536         bufread,
1537         bufwrite,
1538         mmcclose,
1539         mmcgettoc,
1540         mmcfixate,
1541         mmcctl,
1542         mmcsetspeed,
1543 };