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