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 Pagerrrecov = 1, /* error recovery */ 22 Pagwrparams = 5, /* (cd|dvd)-r(w) device write parameters */ 23 Pagcache = 8, 24 Pagcapmechsts = 0x2a, 25 26 Invistrack = 0xff, /* the invisible & incomplete track */ 27 Maxresptracks = 120, /* (1024-slop) / 8 */ 28 29 /* Pagerrrecov error control bits (buf[2]) */ 30 Erawre = 1<<7, /* recover from write errors */ 31 Erarre = 1<<6, /* recover from read errors */ 32 Ertb = 1<<5, /* transfer bad block to host */ 33 Errc = 1<<4, /* read continuous; no error recovery */ 34 Erper = 1<<2, /* post error: report recovered errors */ 35 Erdte = 1<<1, /* disable transfer on error */ 36 Erdcr = 1<<0, /* disable correction */ 37 38 Kilo = 1000LL, 39 GB = Kilo * Kilo * Kilo, 40 }; 41 42 typedef struct Intfeat Intfeat; 43 typedef struct Mmcaux Mmcaux; 44 45 static Dev mmcdev; 46 47 struct Mmcaux { 48 /* drive characteristics */ 49 uchar page05[Pagesz]; /* write parameters */ 50 int page05ok; 51 int pagecmdsz; 52 53 /* disc characteristics */ 54 long mmcnwa; /* next writable address (block #) */ 55 int nropen; 56 int nwopen; 57 vlong ntotby; 58 long ntotbk; 59 }; 60 61 struct Intfeat { 62 int numb; 63 char *name; 64 }; 65 66 enum { 67 Featrandwrite = 0x20, 68 Featdfctmgmt = 0x24, 69 Featwriteonce = 0x25, 70 Featedfctrpt = 0x29, 71 Featdvdrw = 0x2a, 72 }; 73 74 Intfeat intfeats[] = { 75 Featrandwrite, "random writable", /* for write-and-verify */ 76 // 0x21, "incr. streaming writable", 77 Featdfctmgmt, "hw defect mgmt.", 78 Featwriteonce, "write once", /* for write-and-verify */ 79 Featedfctrpt, "enhanced defect reporting", 80 Featdvdrw, "dvd+rw", /* for dvd write-and-verify */ 81 0x38, "pseudo-overwrite", 82 // 0x40, "bd read", 83 // 0x41, "bd write", 84 }; 85 86 /* these will be printed as user ids, so no spaces please */ 87 static char *dvdtype[] = { 88 "dvd-rom", 89 "dvd-ram", 90 "dvd-r", 91 "dvd-rw", 92 "hd-dvd-rom", 93 "hd-dvd-ram", 94 "hd-dvd-r", 95 "type-7-unknown", 96 "type-8-unknown", 97 "dvd+rw", 98 "dvd+r", 99 "type-11-unknown", 100 "type-12-unknown", 101 "dvd+rw-dl", 102 "dvd+r-dl", 103 "type-15-unknown", 104 }; 105 106 static int format(Drive *drive); 107 static int getinvistrack(Drive *drive); 108 109 static ulong 110 bige(void *p) 111 { 112 uchar *a; 113 114 a = p; 115 return (a[0]<<24)|(a[1]<<16)|(a[2]<<8)|(a[3]<<0); 116 } 117 118 static ushort 119 biges(void *p) 120 { 121 uchar *a; 122 123 a = p; 124 return (a[0]<<8) | a[1]; 125 } 126 127 ulong 128 getnwa(Drive *drive) 129 { 130 Mmcaux *aux; 131 132 aux = drive->aux; 133 return aux->mmcnwa; 134 } 135 136 static void 137 hexdump(void *v, int n) 138 { 139 int i; 140 uchar *p; 141 142 p = v; 143 for(i=0; i<n; i++){ 144 print("%.2ux ", p[i]); 145 if((i%8) == 7) 146 print("\n"); 147 } 148 if(i%8) 149 print("\n"); 150 } 151 152 static void 153 initcdb(uchar *cdb, int len, int cmd) 154 { 155 memset(cdb, 0, len); 156 cdb[0] = cmd; 157 } 158 159 /* 160 * SCSI CDBs (cmd arrays) are 6, 10, 12, 16 or 32 bytes long. 161 * The mode sense/select commands implicitly refer to 162 * a mode parameter list, which consists of an 8-byte 163 * mode parameter header, followed by zero or more block 164 * descriptors and zero or more mode pages (MMC-2 §5.5.2). 165 * We'll ignore mode sub-pages. 166 * Integers are stored big-endian. 167 * 168 * The format of the mode parameter (10) header is: 169 * ushort mode_data_length; // of following bytes 170 * uchar medium_type; 171 * uchar device_specific; 172 * uchar reserved[2]; 173 * ushort block_descriptor_length; // zero 174 * 175 * The format of the mode parameter (6) header is: 176 * uchar mode_data_length; // of following bytes 177 * uchar medium_type; 178 * uchar device_specific; 179 * uchar block_descriptor_length; // zero 180 * 181 * The format of the mode pages is: 182 * uchar page_code_and_PS; 183 * uchar page_len; // of following bytes 184 * uchar parameter[page_len]; 185 * 186 * see SPC-3 §4.3.4.6 for allocation length and §7.4 for mode parameter lists. 187 */ 188 189 enum { 190 Mode10parmhdrlen= 8, 191 Mode6parmhdrlen = 4, 192 Modepaghdrlen = 2, 193 }; 194 195 static int 196 mmcgetpage10(Drive *drive, int page, void *v) 197 { 198 uchar cmd[10], resp[512]; 199 int n, r; 200 201 initcdb(cmd, sizeof cmd, ScmdMsense10); 202 cmd[2] = page; 203 cmd[8] = 255; /* allocation length: buffer size */ 204 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread); 205 if(n < Mode10parmhdrlen) 206 return -1; 207 208 r = (resp[6]<<8) | resp[7]; /* block descriptor length */ 209 n -= Mode10parmhdrlen + r; 210 211 if(n < 0) 212 return -1; 213 if(n > Pagesz) 214 n = Pagesz; 215 216 memmove(v, &resp[Mode10parmhdrlen + r], n); 217 return n; 218 } 219 220 static int 221 mmcgetpage6(Drive *drive, int page, void *v) 222 { 223 uchar cmd[6], resp[512]; 224 int n; 225 226 initcdb(cmd, sizeof cmd, ScmdMsense6); 227 cmd[2] = page; 228 cmd[4] = 255; /* allocation length */ 229 230 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread); 231 if(n < Mode6parmhdrlen) 232 return -1; 233 234 n -= Mode6parmhdrlen + resp[3]; 235 if(n < 0) 236 return -1; 237 if(n > Pagesz) 238 n = Pagesz; 239 240 memmove(v, &resp[Mode6parmhdrlen + resp[3]], n); 241 return n; 242 } 243 244 static int 245 mmcsetpage10(Drive *drive, int page, void *v) 246 { 247 uchar cmd[10], *p, *pagedata; 248 int len, n; 249 250 /* allocate parameter list, copy in mode page, fill in header */ 251 pagedata = v; 252 assert(pagedata[0] == page); 253 len = Mode10parmhdrlen + Modepaghdrlen + pagedata[1]; 254 p = emalloc(len); 255 memmove(p + Mode10parmhdrlen, pagedata, pagedata[1]); 256 /* parameter list header */ 257 p[0] = 0; 258 p[1] = len - 2; 259 260 /* set up CDB */ 261 initcdb(cmd, sizeof cmd, ScmdMselect10); 262 cmd[1] = 0x10; /* format not vendor-specific */ 263 cmd[8] = len; 264 265 // print("set: sending cmd\n"); 266 // hexdump(cmd, 10); 267 // print("parameter list header\n"); 268 // hexdump(p, Mode10parmhdrlen); 269 // print("page\n"); 270 // hexdump(p + Mode10parmhdrlen, len - Mode10parmhdrlen); 271 272 n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite); 273 274 // print("set: got cmd\n"); 275 // hexdump(cmd, 10); 276 277 free(p); 278 if(n < len) 279 return -1; 280 return 0; 281 } 282 283 static int 284 mmcsetpage6(Drive *drive, int page, void *v) 285 { 286 uchar cmd[6], *p, *pagedata; 287 int len, n; 288 289 if (vflag) 290 print("mmcsetpage6 called!\n"); 291 pagedata = v; 292 assert(pagedata[0] == page); 293 len = Mode6parmhdrlen + Modepaghdrlen + pagedata[1]; 294 p = emalloc(len); 295 memmove(p + Mode6parmhdrlen, pagedata, pagedata[1]); 296 297 initcdb(cmd, sizeof cmd, ScmdMselect6); 298 cmd[1] = 0x10; /* format not vendor-specific */ 299 cmd[4] = len; 300 301 n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite); 302 free(p); 303 if(n < len) 304 return -1; 305 return 0; 306 } 307 308 static int 309 mmcgetpage(Drive *drive, int page, void *v) 310 { 311 Mmcaux *aux; 312 313 aux = drive->aux; 314 switch(aux->pagecmdsz) { 315 case 10: 316 return mmcgetpage10(drive, page, v); 317 case 6: 318 return mmcgetpage6(drive, page, v); 319 default: 320 assert(0); 321 } 322 return -1; 323 } 324 325 static int 326 mmcsetpage(Drive *drive, int page, void *v) 327 { 328 Mmcaux *aux; 329 330 aux = drive->aux; 331 switch(aux->pagecmdsz) { 332 case 10: 333 return mmcsetpage10(drive, page, v); 334 case 6: 335 return mmcsetpage6(drive, page, v); 336 default: 337 assert(0); 338 } 339 return -1; 340 } 341 342 int 343 mmcstatus(Drive *drive) 344 { 345 uchar cmd[12]; 346 347 initcdb(cmd, sizeof cmd, ScmdCDstatus); /* mechanism status */ 348 return scsi(drive, cmd, sizeof(cmd), nil, 0, Sread); 349 } 350 351 void 352 mmcgetspeed(Drive *drive) 353 { 354 int n, maxread, curread, maxwrite, curwrite; 355 uchar buf[Pagesz]; 356 357 memset(buf, 0, 22); 358 n = mmcgetpage(drive, Pagcapmechsts, buf); /* legacy page */ 359 if (n < 22) { 360 if (vflag) 361 fprint(2, "no Pagcapmechsts mode page!\n"); 362 return; 363 } 364 maxread = (buf[8]<<8)|buf[9]; 365 curread = (buf[14]<<8)|buf[15]; 366 maxwrite = (buf[18]<<8)|buf[19]; 367 curwrite = (buf[20]<<8)|buf[21]; 368 369 if(maxread && maxread < 170 || curread && curread < 170) 370 return; /* bogus data */ 371 372 drive->readspeed = curread; 373 drive->writespeed = curwrite; 374 drive->maxreadspeed = maxread; 375 drive->maxwritespeed = maxwrite; 376 } 377 378 static int 379 getdevtype(Drive *drive) 380 { 381 int n; 382 uchar cmd[6], resp[Pagesz]; 383 384 initcdb(cmd, sizeof cmd, ScmdInq); 385 cmd[3] = sizeof resp >> 8; 386 cmd[4] = sizeof resp; 387 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread); 388 if (n < 8) 389 return -1; 390 return resp[0] & 037; 391 } 392 393 static int 394 start(Drive *drive, int code) 395 { 396 uchar cmd[6]; 397 398 initcdb(cmd, sizeof cmd, ScmdStart); 399 cmd[4] = code; 400 return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone); 401 } 402 403 static int 404 setcaching(Drive *drive) 405 { 406 int n; 407 uchar buf[Pagesz]; 408 409 /* 410 * we can't actually control caching much. 411 * see SBC-2 §6.3.3 but also MMC-6 §7.6. 412 * 413 * should set read ahead, MMC-6 §6.37; seems to control caching. 414 */ 415 n = mmcgetpage(drive, Pagcache, buf); 416 if (n < 3) 417 return -1; 418 /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */ 419 buf[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */ 420 assert(buf[0] == Pagcache); 421 assert(buf[1] >= 10); 422 buf[2] = Ccwce; 423 if (mmcsetpage(drive, Pagcache, buf) < 0) { 424 if (vflag) 425 print("mmcprobe: cache control NOT set\n"); 426 return -1; 427 } 428 return 0; 429 } 430 431 Drive* 432 mmcprobe(Scsi *scsi) 433 { 434 Mmcaux *aux; 435 Drive *drive; 436 uchar buf[Pagesz]; 437 int cap; 438 439 if (vflag) 440 print("mmcprobe: inquiry: %s\n", scsi->inquire); 441 442 drive = emalloc(sizeof(Drive)); 443 drive->Scsi = *scsi; 444 drive->Dev = mmcdev; 445 drive->invistrack = -1; 446 getinvistrack(drive); 447 448 aux = emalloc(sizeof(Mmcaux)); 449 drive->aux = aux; 450 451 scsiready(drive); 452 drive->type = getdevtype(drive); 453 if (drive->type != TypeCD) { 454 werrstr("not an mmc device"); 455 free(aux); 456 free(drive); 457 return nil; 458 } 459 460 /* 461 * drive is an mmc device; learn what we can about it 462 * (as opposed to the disc in it). 463 */ 464 465 start(drive, 1); 466 /* attempt to read CD capabilities page, but it's now legacy */ 467 if(mmcgetpage10(drive, Pagcapmechsts, buf) >= 0) 468 aux->pagecmdsz = 10; 469 else if(mmcgetpage6(drive, Pagcapmechsts, buf) >= 0) 470 aux->pagecmdsz = 6; 471 else { 472 if (vflag) 473 fprint(2, "no Pagcapmechsts mode page!\n"); 474 werrstr("can't read mode page %d!", Pagcapmechsts); 475 free(aux); 476 free(drive); 477 return nil; 478 } 479 480 cap = 0; 481 if(buf[Capwrite] & (Capcdr|Capcdrw|Capdvdr|Capdvdram) || 482 buf[Capmisc] & Caprw) 483 cap |= Cwrite; 484 if(buf[Capmisc] & Capcdda) /* CD-DA commands supported? */ 485 cap |= Ccdda; /* not used anywhere else */ 486 487 // print("read %d max %d\n", biges(buf+14), biges(buf+8)); 488 // print("write %d max %d\n", biges(buf+20), biges(buf+18)); 489 490 /* cache optional page 05 (write parameter page) */ 491 if(/* (cap & Cwrite) && */ 492 mmcgetpage(drive, Pagwrparams, aux->page05) >= 0) { 493 aux->page05ok = 1; 494 cap |= Cwrite; 495 if (vflag) 496 fprint(2, "mmcprobe: got page 5, assuming drive can write\n"); 497 } else { 498 if (vflag) 499 fprint(2, "no Pagwrparams mode page!\n"); 500 cap &= ~Cwrite; 501 } 502 drive->cap = cap; 503 504 mmcgetspeed(drive); 505 setcaching(drive); 506 return drive; 507 } 508 509 static char *tracktype[] = { /* indices are track modes (Tm*) */ 510 "audio cdda", 511 "2 audio channels", 512 "2", 513 "3", 514 "data, recorded uninterrupted", 515 "data, recorded interrupted", 516 }; 517 518 /* 519 * figure out the first writable block, if we can, into drive->aux->mmcnwa. 520 * resp must be from ScmdRtrackinfo. 521 */ 522 static long 523 gettracknwa(Drive *drive, int t, ulong beg, uchar *resp) 524 { 525 long newnwa; 526 Mmcaux *aux; 527 528 aux = drive->aux; 529 if(resp[7] & 1) { /* nwa valid? */ 530 newnwa = bige(&resp[12]); 531 if (newnwa >= 0) 532 if (aux->mmcnwa < 0) 533 aux->mmcnwa = newnwa; 534 else if (aux->mmcnwa != newnwa) 535 fprint(2, "nwa is %ld but invis track starts blk %ld\n", 536 newnwa, aux->mmcnwa); 537 } 538 /* resp[6] & (1<<7) of zero: invisible track */ 539 if(t == Invistrack || t == drive->invistrack) 540 if (aux->mmcnwa < 0) 541 aux->mmcnwa = beg; 542 else if (aux->mmcnwa != beg) 543 fprint(2, "invis track starts blk %ld but nwa is %ld\n", 544 beg, aux->mmcnwa); 545 if (vflag && aux->mmcnwa >= 0) 546 print(" nwa %lud", aux->mmcnwa); 547 return 0; 548 } 549 550 /* 551 * map tmode to type & bs. 552 */ 553 static void 554 gettypebs(uchar tmode, int t, int i, int *typep, int *bsp) 555 { 556 int type, bs; 557 558 if(vflag) 559 print("track %d type %d (%s)", t, tmode, 560 (tmode < nelem(tracktype)? tracktype[tmode]: "**GOK**")); 561 type = TypeNone; 562 bs = BScdda; 563 switch(tmode){ 564 case Tmcdda: 565 type = TypeAudio; 566 bs = BScdda; 567 break; 568 case Tm2audio: /* 2 audio channels, with pre-emphasis 50/15 μs */ 569 if(vflag) 570 print("audio channels with preemphasis on track %d " 571 "(u%.3d)\n", t, i); 572 type = TypeNone; 573 break; 574 case Tmunintr: /* data track, recorded uninterrupted */ 575 case Tmintr: /* data track, recorded interrupted */ 576 /* treat Tmintr (5) as cdrom; it's probably dvd or bd */ 577 type = TypeData; 578 bs = BScdrom; 579 break; 580 default: 581 if(vflag) 582 print("unknown track type %d\n", tmode); 583 break; 584 } 585 *bsp = bs; 586 *typep = type; 587 } 588 589 /* t is a track number on disc, i is an index into drive->track[] for result */ 590 static int 591 mmctrackinfo(Drive *drive, int t, int i) 592 { 593 int n, type, bs; 594 ulong beg, size; 595 uchar tmode; 596 uchar cmd[10], resp[255]; 597 Track *track; 598 599 initcdb(cmd, sizeof cmd, ScmdRtrackinfo); 600 cmd[1] = 1; /* address below is logical track # */ 601 cmd[2] = t>>24; 602 cmd[3] = t>>16; 603 cmd[4] = t>>8; 604 cmd[5] = t; 605 cmd[7] = sizeof(resp)>>8; 606 cmd[8] = sizeof(resp); 607 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread); 608 if(n < 28) { 609 if(vflag) 610 print("trackinfo %d fails n=%d: %r\n", t, n); 611 return -1; 612 } 613 614 tmode = resp[5] & 0x0D; 615 // dmode = resp[6] & 0x0F; 616 617 gettypebs(tmode, t, i, &type, &bs); 618 619 beg = bige(&resp[8]); 620 size = bige(&resp[24]); 621 622 track = &drive->track[i]; 623 track->mtime = drive->changetime; 624 track->beg = beg; 625 track->end = beg + size; 626 track->type = type; 627 track->bs = bs; 628 track->size = (vlong)(size-2) * bs; /* -2: skip lead out */ 629 630 if(resp[6] & (1<<6)) { /* blank? */ 631 track->type = TypeBlank; 632 drive->writeok = Yes; 633 } 634 635 if(vflag) 636 print(" start %lud end %lud", beg, beg + size - 1); 637 gettracknwa(drive, t, beg, resp); 638 if (vflag) 639 print("\n"); 640 return 0; 641 } 642 643 /* this may fail for blank media */ 644 static int 645 mmcreadtoc(Drive *drive, int type, int track, void *data, int nbytes) 646 { 647 uchar cmd[10]; 648 649 initcdb(cmd, sizeof cmd, ScmdRTOC); 650 cmd[1] = type; /* msf bit & reserved */ 651 cmd[2] = Tocfmttoc; 652 cmd[6] = track; /* track/session */ 653 cmd[7] = nbytes>>8; 654 cmd[8] = nbytes; 655 656 /* 657 * printing iounit(drive->Scsi.rawfd) here yields 658 * iounit(3) = 0; # for local access 659 * iounit(3) = 65512; # for remote access via /mnt/term 660 */ 661 return scsi(drive, cmd, sizeof(cmd), data, nbytes, Sread); 662 } 663 664 static Msf 665 rdmsf(uchar *p) 666 { 667 Msf msf; 668 669 msf.m = p[0]; 670 msf.s = p[1]; 671 msf.f = p[2]; 672 return msf; 673 } 674 675 static int 676 getdiscinfo(Drive *drive, uchar resp[], int resplen) 677 { 678 int n; 679 uchar cmd[10]; 680 681 initcdb(cmd, sizeof cmd, ScmdRdiscinfo); 682 cmd[7] = resplen>>8; 683 cmd[8] = resplen; 684 n = scsi(drive, cmd, sizeof(cmd), resp, resplen, Sread); 685 if(n < 24) { 686 if(n >= 0) 687 werrstr("rdiscinfo returns %d", n); 688 else if (vflag) 689 fprint(2, "read disc info failed\n"); 690 return -1; 691 } 692 if (vflag) 693 fprint(2, "read disc info succeeded\n"); 694 assert((resp[2] & 0340) == 0); /* data type 0 */ 695 drive->erasable = ((resp[2] & 0x10) != 0); /* -RW? */ 696 return n; 697 } 698 699 int 700 isbitset(uint bit, uchar *map) 701 { 702 return map[bit/8] & (1 << (bit%8)); 703 } 704 705 /* 706 * set read-write error recovery mode page 1 (10 bytes), mmc-6 §7.3. 707 * 708 * requires defect management feature (0x24) mmc-6 §5.3.13 (mandatory on bd, 709 * but has to be enabled by allocating spares with FORMAT UNIT command) 710 * or enhanced defect reporting feature (0x29) mmc-6 §5.3.17, 711 * and they are mutually exclusive. 712 */ 713 static int 714 seterrrecov(Drive *drive) 715 { 716 int n; 717 uchar buf[Pagesz]; 718 719 if (!isbitset(Featdfctmgmt, drive->features) && 720 !isbitset(Featedfctrpt, drive->features)) { 721 fprint(2, "defect mgmt. and enhanced defect reporting disabled!\n"); 722 return -1; 723 } 724 n = mmcgetpage(drive, Pagerrrecov, buf); 725 if (n < 3) 726 return -1; 727 /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */ 728 /* 729 * error recovery page as read: 730 * 0: 01 (page: error recovery) 731 * 1: 0a (length: 10) 732 * 2: c0 (error control bits: 0300 == Erawre|Erarre) 733 * 3: 20 (read retry count: 32) 734 * 4: 00 735 * 5: 00 736 * 6: 00 737 * 7: 00 738 * 8: 01 (write retry count: 1) 739 * 9: 00 00 00 (error reporting window size) 740 */ 741 buf[0] &= ~(1<<6); /* clear reserved bit */ 742 assert((buf[0] & 077) == Pagerrrecov); 743 assert(buf[1] >= 10); 744 745 buf[2] = Erawre | Erarre; /* default: Erawre; can't set Ertb */ 746 if (isbitset(Featedfctrpt, drive->features)) 747 buf[7] = 1; /* emcdr: 1==recover, don't tell us; default 0 */ 748 749 // buf[3] = 32; /* rd retry count; default 32; arbitrary */ 750 // buf[8] = 1; /* wr retry count; default 1; arbitrary */ 751 // memset(buf+9, 0, 3); /* err reporting win siz: 0 == no tsr; default 0 */ 752 753 if (mmcsetpage(drive, Pagerrrecov, buf) < 0) { 754 if (vflag) 755 fprint(2, "error recovery NOT set\n"); 756 return -1; 757 } 758 if (vflag) 759 fprint(2, "error recovery set\n"); 760 return 0; 761 } 762 763 char * 764 featname(int feat) 765 { 766 Intfeat *ifp; 767 768 for (ifp = intfeats; ifp < intfeats + nelem(intfeats); ifp++) 769 if (feat == ifp->numb) 770 return ifp->name; 771 return nil; 772 } 773 774 static int 775 prof2mmctype(Drive *drive, ushort prof) 776 { 777 if(prof == 0 || prof == 0xffff) /* none or whacko? */ 778 return -1; 779 if(drive->mmctype != Mmcnone) 780 return -1; 781 switch (prof >> 4) { 782 case 0: 783 drive->mmctype = Mmccd; 784 break; 785 case 1: 786 if (prof == 0x1a || prof == 0x1b) 787 drive->mmctype = Mmcdvdplus; 788 else 789 drive->mmctype = Mmcdvdminus; 790 break; 791 case 2: 792 drive->mmctype = Mmcdvdplus; /* dual layer */ 793 break; 794 case 4: 795 drive->mmctype = Mmcbd; 796 if (vflag) 797 fprint(2, "getconf profile for bd = %#x\n", prof); 798 /* 799 * further decode prof to set writability flags. 800 * mostly for Pioneer BDR-206M. 801 */ 802 drive->erasable = drive->recordable = No; 803 switch (prof) { 804 case 0x40: 805 break; 806 case 0x41: 807 case 0x42: 808 drive->recordable = Yes; 809 break; 810 case 0x43: 811 drive->erasable = Yes; 812 break; 813 } 814 break; 815 case 5: 816 drive->mmctype = Mmcdvdminus; /* hd dvd, obs. */ 817 break; 818 } 819 return 0; 820 } 821 822 static void 823 notefeats(Drive *drive, uchar *p, ulong datalen) 824 { 825 int left, len; 826 uint feat; 827 char *ftnm; 828 829 if (vflag) 830 fprint(2, "features: "); 831 for (left = datalen; left > 0; left -= len, p += len) { 832 feat = p[0]<<8 | p[1]; 833 len = 4 + p[3]; 834 ftnm = featname(feat); 835 if (vflag && ftnm) 836 fprint(2, "%#ux (%s) curr %d\n", feat, ftnm, p[2] & 1); 837 if (feat >= Maxfeatures) { /* could be vendor-specific */ 838 if (vflag) 839 fprint(2, "feature %d too big for bit map\n", 840 feat); 841 } else if (p[2] & 1) 842 drive->features[feat/8] |= 1 << (feat%8); 843 } 844 } 845 846 static int 847 getconfcmd(Drive *drive, uchar *resp, int respsz) 848 { 849 int n; 850 ulong datalen; 851 uchar cmd[10]; 852 853 initcdb(cmd, sizeof cmd, Scmdgetconf); 854 cmd[3] = 0; /* start with profile list feature */ 855 cmd[7] = respsz >> 8; 856 cmd[8] = respsz; 857 n = scsi(drive, cmd, sizeof cmd, resp, respsz, Sread); 858 if (n < 0) { 859 if(vflag) 860 fprint(2, "get config cmd failed\n"); 861 return -1; 862 } 863 if (n < 4) 864 return -1; 865 datalen = GETBELONG(resp+0); 866 if (datalen < 8) 867 return -1; 868 return datalen; 869 } 870 871 static int 872 getconf(Drive *drive) 873 { 874 ushort prof; 875 long datalen; 876 uchar resp[64*1024 - 8]; /* 64k-8 max, 450 typical */ 877 878 memset(drive->features, 0, sizeof drive->features); 879 datalen = getconfcmd(drive, resp, sizeof resp); 880 if(datalen < 0) 881 return -1; 882 883 /* 884 * features start with an 8-byte header: 885 * ulong datalen, ushort reserved, ushort current profile. 886 * profile codes (table 92) are: 0 reserved, 1-7 legacy, 8-0xf cd, 887 * 0x10-0x1f 0x2a-0x2b dvd*, 0x40-0x4f bd, 0x50-0x5f hd dvd, 888 * 0xffff whacko. 889 * 890 * this is followed by multiple feature descriptors: 891 * ushort code, uchar bits, uchar addnl_len, addnl_len bytes. 892 */ 893 prof = resp[6]<<8 | resp[7]; 894 if (prof2mmctype(drive, prof) < 0) 895 return datalen; 896 897 /* 898 * for bd-r, establish non-default recording mode before first write, 899 * with FORMAT UNIT command to allocate spares (BD MMC set 900 * description, v1.1, §4.4.4). 901 */ 902 if (drive->mmctype == Mmcbd && drive->recordable == Yes && 903 drive->erasable == No) { 904 format(drive); /* no-op with error if already been done */ 905 /* read config again, now that bd-r has spares */ 906 datalen = getconfcmd(drive, resp, sizeof resp); 907 if(datalen < 0) 908 return -1; 909 } 910 911 /* skip header to find feature list */ 912 notefeats(drive, resp + 8, datalen - 8); 913 914 if (drive->mmctype == Mmcbd) 915 seterrrecov(drive); 916 return datalen; 917 } 918 919 static int 920 getdvdstruct(Drive *drive) 921 { 922 int n, cat; 923 uchar cmd[12], resp[Pagesz]; 924 925 initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */ 926 cmd[1] = 0; /* media type: dvd */ 927 cmd[7] = 0; /* format code: physical format */ 928 cmd[8] = sizeof resp >> 8; /* allocation length */ 929 cmd[9] = sizeof resp; 930 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread); 931 if (n < 7) { 932 if(vflag) 933 fprint(2, "read disc structure (dvd) cmd failed\n"); 934 return -1; 935 } 936 937 /* resp[0..1] is resp length */ 938 cat = (resp[4] & 0xf0) >> 4; /* disk category, MMC-6 §6.22.3.2.1 */ 939 if (vflag) 940 fprint(2, "dvd type is %s\n", dvdtype[cat]); 941 drive->dvdtype = dvdtype[cat]; 942 /* write parameters mode page may suffice to compute writeok for dvd */ 943 drive->erasable = drive->recordable = No; 944 /* 945 * the layer-type field is a *bit array*, 946 * though an enumeration of types would make more sense, 947 * since the types are exclusive, not orthogonal. 948 */ 949 if (resp[6] & (1<<2)) /* rewritable? */ 950 drive->erasable = Yes; 951 else if (resp[6] & (1<<1)) /* recordable once? */ 952 drive->recordable = Yes; 953 /* else it's a factory-pressed disk */ 954 drive->mmctype = (cat >= 8? Mmcdvdplus: Mmcdvdminus); 955 return 0; 956 } 957 958 /* 959 * ugly hack to divine device type from inquiry string as last resort. 960 * mostly for Pioneer BDR-206M. 961 */ 962 static int 963 bdguess(Drive *drive) 964 { 965 if (drive->mmctype == Mmcnone) { 966 if (strstr(drive->Scsi.inquire, "BD") == nil) 967 return -1; 968 if (vflag) 969 fprint(2, "drive probably a BD (from inquiry string)\n"); 970 drive->mmctype = Mmcbd; 971 } else if (drive->mmctype == Mmcbd) { 972 if (drive->erasable != Unset && drive->recordable != Unset) 973 return 0; 974 } else 975 return -1; 976 977 drive->recordable = drive->writeok = No; 978 if (strstr(drive->Scsi.inquire, "RW") != nil) { 979 if (vflag) 980 fprint(2, "drive probably a burner (from inquiry string)\n"); 981 drive->recordable = drive->writeok = Yes; 982 if (drive->erasable == Unset) { /* set by getdiscinfo perhaps */ 983 drive->erasable = No; /* no way to tell, alas */ 984 if (vflag) 985 fprint(2, "\tassuming -r not -re\n"); 986 } 987 } else { 988 if (drive->erasable == Unset) 989 drive->erasable = No; 990 } 991 if (drive->erasable == Yes) 992 drive->recordable = No; /* mutually exclusive */ 993 return 0; 994 } 995 996 static int 997 getbdstruct(Drive *drive) 998 { 999 int n; 1000 uchar cmd[12], resp[4+4096]; 1001 uchar *di, *body; 1002 1003 initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */ 1004 cmd[1] = 1; /* media type: bd */ 1005 /* cmd[6] is layer #, 0 is first */ 1006 cmd[7] = 0; /* format code: disc info */ 1007 cmd[8] = sizeof resp >> 8; /* allocation length */ 1008 cmd[9] = sizeof resp; 1009 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread); 1010 if(n < 0) { 1011 if(vflag) 1012 fprint(2, "read disc structure (bd) cmd failed\n"); 1013 return -1; 1014 } 1015 1016 /* 1017 * resp[0..1] is resp length (4100); 2 & 3 are reserved. 1018 * there may be multiple disc info structs of 112 bytes each. 1019 * disc info (di) starts at 4. di[0..7] are header, followed by body. 1020 * body[0..2] is bd type (disc type identifier): 1021 * BDO|BDW|BDR, MMC-6 §6.22.3.3.1. The above scsi command should 1022 * fail on DVD drives, but some seem to ignore media type 1023 * and return successfully, so verify that it's a BD drive. 1024 */ 1025 di = resp + 4; 1026 body = di + 8; 1027 n -= 4 + 8; 1028 if (n < 3 || di[0] != 'D' || di[1] != 'I' || 1029 body[0] != 'B' || body[1] != 'D') { 1030 if(vflag) 1031 fprint(2, "it's not a bd\n"); 1032 return -1; 1033 } 1034 if (vflag) 1035 fprint(2, "read disc structure (bd) succeeded; di format %d\n", 1036 di[2]); 1037 1038 drive->erasable = drive->recordable = No; 1039 switch (body[2]) { 1040 case 'O': /* read-Only */ 1041 break; 1042 case 'R': /* Recordable */ 1043 drive->recordable = Yes; 1044 break; 1045 case 'W': /* reWritable */ 1046 drive->erasable = Yes; 1047 break; 1048 default: 1049 fprint(2, "%s: unknown bd type BD%c\n", argv0, body[2]); 1050 return -1; 1051 } 1052 /* printed getbdstruct: di bytes 98 di units/layers 32 */ 1053 // fprint(2, "getbdstruct: di bytes %d di units/layers %d\n", di[6], di[3]); 1054 drive->mmctype = Mmcbd; 1055 return 0; 1056 } 1057 1058 /* 1059 * infer endings from the beginnings of other tracks. 1060 */ 1061 static int 1062 mmcinfertracks(Drive *drive, int first, int last) 1063 { 1064 int i; 1065 uchar resp[1024]; 1066 ulong tot; 1067 Track *t; 1068 1069 if (vflag) 1070 fprint(2, "inferring tracks from toc\n"); 1071 for(i = first; i <= last; i++) { 1072 memset(resp, 0, sizeof(resp)); 1073 if(mmcreadtoc(drive, 0, i, resp, sizeof(resp)) < 0) { 1074 last = i - 1; 1075 if (last < 1) 1076 last = 1; 1077 break; 1078 } 1079 t = &drive->track[i-first]; 1080 t->mtime = drive->changetime; 1081 t->type = TypeData; 1082 t->bs = BScdrom; 1083 t->beg = bige(resp+8); 1084 if(!(resp[5] & 4)) { 1085 t->type = TypeAudio; 1086 t->bs = BScdda; 1087 } 1088 } 1089 1090 if((long)drive->track[0].beg < 0) /* i've seen negative track 0's */ 1091 drive->track[0].beg = 0; 1092 1093 tot = 0; 1094 memset(resp, 0, sizeof(resp)); 1095 /* 0xAA is lead-out */ 1096 if(mmcreadtoc(drive, 0, 0xAA, resp, sizeof(resp)) < 0) 1097 print("bad mmcreadtoc\n"); 1098 if(resp[6]) 1099 tot = bige(resp+8); 1100 1101 t = nil; 1102 for(i=last; i>=first; i--) { 1103 t = &drive->track[i-first]; 1104 t->end = tot; 1105 tot = t->beg; 1106 if(t->end <= t->beg) 1107 t->beg = t->end = 0; 1108 /* -2: skip lead out */ 1109 t->size = (t->end - t->beg - 2) * (vlong)t->bs; 1110 } 1111 fprint(2, "infertracks: nwa should be %,lld; tot = %,ld\n", t->size, tot); 1112 return last; 1113 } 1114 1115 static void 1116 initdrive(Drive *drive) 1117 { 1118 int i; 1119 Mmcaux *aux; 1120 1121 drive->ntrack = 0; 1122 drive->nameok = 0; 1123 drive->nchange = drive->Scsi.nchange; 1124 drive->changetime = drive->Scsi.changetime; 1125 drive->writeok = No; 1126 drive->erasable = drive->recordable = Unset; 1127 drive->laysfx = nil; 1128 getinvistrack(drive); 1129 aux = drive->aux; 1130 aux->mmcnwa = -1; 1131 aux->nropen = aux->nwopen = 0; 1132 aux->ntotby = aux->ntotbk = 0; 1133 1134 for(i=0; i<nelem(drive->track); i++){ 1135 memset(&drive->track[i].mbeg, 0, sizeof(Msf)); 1136 memset(&drive->track[i].mend, 0, sizeof(Msf)); 1137 } 1138 } 1139 1140 static long 1141 computenwa(Drive *drive, int first, int last) 1142 { 1143 int i; 1144 ulong nwa; 1145 Track *t; 1146 1147 /* 1148 * work through the tracks in reverse order (last to first). 1149 * assume last is the to-be-written invisible track. 1150 */ 1151 nwa = 0; 1152 for(i=last-1; i>=first; i--) { 1153 t = &drive->track[i-first]; 1154 nwa += t->end - t->beg; 1155 } 1156 return nwa; 1157 } 1158 1159 static int 1160 findntracks(Drive *drive, int *firstp, int *lastp) 1161 { 1162 int i, n, first, last; 1163 uchar resp[1024]; 1164 1165 if((n = mmcreadtoc(drive, Msfbit, 0, resp, sizeof(resp))) < 4) { 1166 /* 1167 * it could be a blank disc. in case it's a blank disc in a 1168 * cd-rw drive, use readdiscinfo to try to find the track info. 1169 */ 1170 if(getdiscinfo(drive, resp, sizeof(resp)) < 7) 1171 return -1; 1172 assert((resp[2] & 0340) == 0); /* data type 0 */ 1173 if(resp[4] != 1) 1174 print("multi-session disc %d\n", resp[4]); 1175 drive->writeok = Yes; 1176 1177 /* 1178 * some drives (e.g., LG's BDs) report only 1 track on an 1179 * unfinalized disc, so probe every track. the nwa reported 1180 * by such drives may be wrong (e.g., 0), so compute that too. 1181 */ 1182 first = resp[3]; 1183 last = resp[6]; 1184 if(vflag) 1185 print("rdiscinfo tracks %d-%d (last==1 means TBD)\n", 1186 first, last); 1187 if(last == 1) 1188 last = Maxresptracks; /* probe the tracks */ 1189 } else { 1190 first = resp[2]; 1191 last = resp[3]; 1192 if(vflag) 1193 print("toc tracks %d-%d (last==1 means TBD)\n", 1194 first, last); 1195 if(last == 1) 1196 last = Maxresptracks; /* probe the tracks */ 1197 1198 if(n >= 4+8*(last-first+2)) { 1199 /* resp[4 + i*8 + 2] is track # */ 1200 /* <=: track[last-first+1] = end */ 1201 for(i=0; i<=last-first+1; i++) 1202 drive->track[i].mbeg = rdmsf(resp+4+i*8+5); 1203 for(i=0; i<last-first+1; i++) 1204 drive->track[i].mend = drive->track[i+1].mbeg; 1205 } 1206 } 1207 *firstp = first; 1208 *lastp = last; 1209 return 0; 1210 } 1211 1212 /* needs drive->mmctype to be already set */ 1213 static int 1214 alltrackinfo(Drive *drive, int first, int last) 1215 { 1216 int i; 1217 long nwa; 1218 vlong cap; 1219 char *osfx; 1220 Mmcaux *aux; 1221 Track *track; 1222 1223 for(i = first; i <= last; i++) 1224 if (mmctrackinfo(drive, i, i - first) < 0) { 1225 last = i - 1; 1226 if (last < 1) 1227 last = 1; 1228 break; 1229 } 1230 track = &drive->track[last - first]; 1231 drive->end = track->end; 1232 if (drive->mmctype == Mmcbd) { 1233 /* allow for lower apparent capacity due to reserved spares */ 1234 cap = (vlong)track->end * track->bs; 1235 osfx = drive->laysfx; 1236 if (cap >= 101*GB) 1237 drive->laysfx = "-ql"; /* 128GB nominal */ 1238 else if (cap >= 51*GB) 1239 drive->laysfx = "-tl"; /* 100GB nominal */ 1240 else if (cap >= 26*GB) 1241 drive->laysfx = "-dl"; /* 50GB nominal */ 1242 else 1243 drive->laysfx = ""; /* 25GB nominal */ 1244 if (vflag) 1245 fprint(2, "capacity %,lud sectors (%,lld bytes); bd%s\n", 1246 track->end, cap, drive->laysfx); 1247 if (osfx == nil || strcmp(osfx, drive->laysfx) != 0) 1248 drive->relearn = 1; 1249 } 1250 if (drive->mmctype == Mmcnone) 1251 return last; /* no disc */ 1252 nwa = computenwa(drive, first, last); 1253 aux = drive->aux; 1254 if (vflag) 1255 fprint(2, "nwa from drive %,ld; computed nwa %,ld\n", 1256 aux->mmcnwa, nwa); 1257 if (aux->mmcnwa == -1 && nwa == 0) 1258 return last; /* probably a blank disc */ 1259 if (aux->mmcnwa == -1) 1260 fprint(2, "%s: disc is full\n", argv0); 1261 /* reconcile differing nwas */ 1262 if (aux->mmcnwa != nwa) { 1263 fprint(2, "%s: nwa from drive %,ld != computed nwa %,ld\n", 1264 argv0, aux->mmcnwa, nwa); 1265 fprint(2, "\tbe careful! assuming computed nwa\n"); 1266 /* the invisible track may still start at the old nwa. */ 1267 // aux->mmcnwa = nwa; 1268 } 1269 return last; 1270 } 1271 1272 static int 1273 findtracks(Drive *drive, int first, int last) 1274 { 1275 if(first == 0 && last == 0) 1276 first = 1; 1277 1278 if(first <= 0 || first >= Maxtrack) { 1279 werrstr("first table %d not in range", first); 1280 return -1; 1281 } 1282 if(last <= 0 || last >= Maxtrack) { 1283 werrstr("last table %d not in range", last); 1284 return -1; 1285 } 1286 1287 if(!(drive->cap & Cwrite)) 1288 last = mmcinfertracks(drive, first, last); 1289 else 1290 last = alltrackinfo(drive, first, last); 1291 drive->firsttrack = first; 1292 drive->ntrack = last+1-first; 1293 if (vflag) 1294 fprint(2, "this time for sure: first %d last %d\n", first, last); 1295 return 0; 1296 } 1297 1298 static void 1299 finddisctype(Drive *drive, int first, int last) 1300 { 1301 char *ty; 1302 1303 /* deduce disc type */ 1304 drive->mmctype = Mmcnone; 1305 drive->dvdtype = nil; 1306 getdvdstruct(drive); 1307 getconf(drive); 1308 getbdstruct(drive); 1309 if (Desperate) 1310 bdguess(drive); 1311 if (drive->mmctype == Mmcnone) 1312 drive->mmctype = Mmccd; /* by default */ 1313 if (drive->recordable == Yes || drive->erasable == Yes) 1314 drive->writeok = Yes; 1315 1316 if (vflag) { 1317 fprint(2, "writeok %d", drive->writeok); 1318 if (drive->recordable != Unset) 1319 fprint(2, " recordable %d", drive->recordable); 1320 if (drive->erasable != Unset) 1321 fprint(2, " erasable %d", drive->erasable); 1322 fprint(2, "\n"); 1323 fprint(2, "first %d last ", first); 1324 if (last == Maxresptracks) 1325 print("TBD\n"); 1326 else 1327 print("%d\n", last); 1328 1329 ty = disctype(drive); 1330 fprint(2, "it's a %s disc.", ty); 1331 free(ty); 1332 if (drive->mmctype == Mmcbd && drive->laysfx == nil) 1333 fprint(2, " (number of layers isn't known yet.)"); 1334 fprint(2, "\n\n"); 1335 } 1336 } 1337 1338 /* this gets called a lot from main.c's 9P routines */ 1339 static int 1340 mmcgettoc(Drive *drive) 1341 { 1342 int first, last; 1343 uchar resp[1024]; 1344 1345 /* 1346 * if someone has swapped the cd, 1347 * mmcreadtoc will get ``medium changed'' and the scsi routines 1348 * will set nchange and changetime in the scsi device. 1349 */ 1350 mmcreadtoc(drive, 0, 0, resp, sizeof(resp)); 1351 if(drive->Scsi.changetime == 0) { /* no media present */ 1352 drive->mmctype = Mmcnone; 1353 drive->ntrack = 0; 1354 return 0; 1355 } 1356 /* 1357 * if the disc doesn't appear to be have been changed, and there 1358 * is a disc in this drive, there's nothing to do (the common case). 1359 */ 1360 if(drive->nchange == drive->Scsi.nchange && drive->changetime != 0 && 1361 !drive->relearn) 1362 return 0; 1363 drive->relearn = 0; 1364 1365 /* 1366 * the disc in the drive may have just been changed, 1367 * so rescan it and relearn all about it. 1368 */ 1369 if (vflag && 1370 (drive->nchange != drive->Scsi.nchange || drive->changetime == 0)) 1371 fprint(2, "\nnew disc in drive\n"); 1372 initdrive(drive); 1373 1374 if (findntracks(drive, &first, &last) < 0) 1375 return -1; 1376 /* 1377 * we would like to call findtracks before finddisctype so that 1378 * we can format bd-rs at the right capacity with explicit spares 1379 * ratio given, but findtracks needs the disc type to be already set. 1380 * format is called from getconf from finddisctype before getbdstruct. 1381 * luckily, FORMAT UNIT (thus format()) doesn't seem to care when we 1382 * don't provide an explicit spares ratio. 1383 */ 1384 /* calls getdvdstruct, getconf and getbdstruct, in that order */ 1385 finddisctype(drive, first, last); /* formats bds at first use */ 1386 return findtracks(drive, first, last); 1387 } 1388 1389 static void 1390 settrkmode(uchar *p, int mode) 1391 { 1392 p[Wptrkmode] &= ~0xf; 1393 p[Wptrkmode] |= mode; 1394 } 1395 1396 /* 1397 * this uses page 5, which is optional. 1398 */ 1399 static int 1400 mmcsetbs(Drive *drive, int bs) 1401 { 1402 uchar *p; 1403 Mmcaux *aux; 1404 1405 aux = drive->aux; 1406 if (!aux->page05ok) 1407 return 0; /* harmless; assume 2k */ 1408 1409 p = aux->page05; 1410 /* 1411 * establish defaults. 1412 */ 1413 p[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */ 1414 p[Wpwrtype] = Bufe | Wttrackonce; 1415 // if(testonlyflag) 1416 // p[Wpwrtype] |= 0x10; /* test-write */ 1417 /* assume dvd values as defaults */ 1418 settrkmode(p, Tmintr); 1419 p[Wptrkmode] |= Msnext; 1420 p[Wpdatblktype] = Db2kdata; 1421 p[Wpsessfmt] = Sfdata; 1422 1423 switch(drive->mmctype) { 1424 case Mmcdvdplus: 1425 case Mmcbd: 1426 break; 1427 case Mmcdvdminus: 1428 /* dvd-r can only do disc-at-once or incremental */ 1429 p[Wpwrtype] = Bufe | Wtsessonce; 1430 break; 1431 case Mmccd: 1432 settrkmode(p, Tmunintr); /* data track, uninterrupted */ 1433 switch(bs){ 1434 case BScdda: 1435 /* 2 audio channels without pre-emphasis */ 1436 settrkmode(p, Tmcdda); /* should be Tm2audio? */ 1437 p[Wpdatblktype] = Dbraw; 1438 break; 1439 case BScdrom: 1440 break; 1441 case BScdxa: 1442 p[Wpdatblktype] = Db2336; 1443 p[Wpsessfmt] = Sfcdxa; 1444 break; 1445 default: 1446 fprint(2, "%s: unknown CD type; bs %d\n", argv0, bs); 1447 assert(0); 1448 } 1449 break; 1450 default: 1451 fprint(2, "%s: unknown disc sub-type %d\n", 1452 argv0, drive->mmctype); 1453 break; 1454 } 1455 if(mmcsetpage(drive, Pagwrparams, p) < 0) { 1456 if (vflag) 1457 fprint(2, "mmcsetbs: could NOT set write parameters page\n"); 1458 return -1; 1459 } 1460 return 0; 1461 } 1462 1463 /* 1464 * `read cd' only works for CDs; for everybody else, 1465 * we'll try plain `read (12)'. only use read cd if it's 1466 * a cd drive with a cd in it and we're not reading data 1467 * (e.g., reading audio). 1468 */ 1469 static int 1470 fillread12cdb(Drive *drive, uchar *cmd, long nblock, ulong off, int bs) 1471 { 1472 if (drive->type == TypeCD && drive->mmctype == Mmccd && bs != BScdrom) { 1473 initcdb(cmd, 12, ScmdReadcd); 1474 cmd[6] = nblock>>16; 1475 cmd[7] = nblock>>8; 1476 cmd[8] = nblock>>0; 1477 cmd[9] = 0x10; 1478 switch(bs){ 1479 case BScdda: 1480 cmd[1] = 0x04; 1481 break; 1482 case BScdrom: 1483 cmd[1] = 0x08; 1484 break; 1485 case BScdxa: 1486 cmd[1] = 0x0C; 1487 break; 1488 default: 1489 werrstr("unknown bs %d", bs); 1490 return -1; 1491 } 1492 } else { /* e.g., TypeDA */ 1493 initcdb(cmd, 12, ScmdRead12); 1494 cmd[6] = nblock>>24; 1495 cmd[7] = nblock>>16; 1496 cmd[8] = nblock>>8; 1497 cmd[9] = nblock; 1498 // cmd[10] = 0x80; /* streaming */ 1499 } 1500 cmd[2] = off>>24; 1501 cmd[3] = off>>16; 1502 cmd[4] = off>>8; 1503 cmd[5] = off>>0; 1504 return 0; 1505 } 1506 1507 /* off is a block number */ 1508 static long 1509 mmcread(Buf *buf, void *v, long nblock, ulong off) 1510 { 1511 int bs; 1512 long n, nn; 1513 uchar cmd[12]; 1514 Drive *drive; 1515 Otrack *o; 1516 1517 o = buf->otrack; 1518 drive = o->drive; 1519 bs = o->track->bs; 1520 off += o->track->beg; 1521 1522 if(nblock >= (1<<10)) { 1523 werrstr("mmcread too big"); 1524 if(vflag) 1525 fprint(2, "mmcread too big\n"); 1526 return -1; 1527 } 1528 1529 /* truncate nblock modulo size of track */ 1530 if(off > o->track->end - 2) { 1531 werrstr("read past end of track"); 1532 if(vflag) 1533 fprint(2, "end of track (%ld->%ld off %ld)", 1534 o->track->beg, o->track->end - 2, off); 1535 return -1; 1536 } 1537 if(off == o->track->end - 2) 1538 return 0; 1539 1540 if(off+nblock > o->track->end - 2) 1541 nblock = o->track->end - 2 - off; 1542 1543 if (fillread12cdb(drive, cmd, nblock, off, bs) < 0) 1544 return -1; 1545 1546 n = nblock*bs; 1547 nn = scsi(drive, cmd, sizeof(cmd), v, n, Sread); 1548 if(nn != n) { 1549 if(nn != -1) 1550 werrstr("short read %ld/%ld", nn, n); 1551 if(vflag) 1552 print("read off %lud nblock %ld bs %d failed\n", 1553 off, nblock, bs); 1554 return -1; 1555 } 1556 return nblock; 1557 } 1558 1559 static Otrack* 1560 mmcopenrd(Drive *drive, int trackno) 1561 { 1562 Otrack *o; 1563 Mmcaux *aux; 1564 1565 if(trackno < 0 || trackno >= drive->ntrack) { 1566 werrstr("track number out of range"); 1567 return nil; 1568 } 1569 1570 aux = drive->aux; 1571 if(aux->nwopen) { 1572 werrstr("disk in use for writing"); 1573 return nil; 1574 } 1575 1576 o = emalloc(sizeof(Otrack)); 1577 o->drive = drive; 1578 o->track = &drive->track[trackno]; 1579 o->nchange = drive->nchange; 1580 o->omode = OREAD; 1581 o->buf = bopen(mmcread, OREAD, o->track->bs, Readblock); 1582 o->buf->otrack = o; 1583 1584 aux->nropen++; 1585 1586 return o; 1587 } 1588 1589 enum { 1590 Flhlen = 4, /* format list header length */ 1591 Fdlen = 8, /* format descriptor length */ 1592 1593 /* format unit cdb[1] */ 1594 Formatdata = 0x10, 1595 1596 /* format list header [1] */ 1597 Immed = 1<<1, /* immediate return, don't wait */ 1598 1599 /* format descriptor [4] */ 1600 Fmtfull = 0, 1601 Fullbdrsrm = 0, /* sequential */ 1602 Fullbdrsrmspares= 1, /* + spares for defect mgmt. */ 1603 Fullbdrrrm = 2, /* random */ 1604 Fmtbdrspares = 0x32 << 2, 1605 Bdrsparessrmplus= 0, /* srm+pow */ 1606 Bdrsparessrmminus=1, /* srm-pow */ 1607 Bdrsparesrrm = 2, /* random */ 1608 }; 1609 1610 static int 1611 format(Drive *drive) 1612 { 1613 int setblksz; 1614 ulong nblks, blksize; 1615 uchar *fmtdesc; 1616 uchar cmd[6], parms[Flhlen+Fdlen]; 1617 1618 if (drive->recordable == Yes && drive->mmctype != Mmcbd) { 1619 werrstr("don't format write-once cd or dvd media"); 1620 return -1; 1621 } 1622 initcdb(cmd, sizeof cmd, ScmdFormat); /* format unit */ 1623 cmd[1] = Formatdata | 1; /* mmc format code 1 */ 1624 1625 /* parms is format list header & format descriptor */ 1626 memset(parms, 0, sizeof parms); 1627 1628 /* format list header */ 1629 parms[1] = Immed; 1630 parms[3] = Fdlen; 1631 1632 fmtdesc = parms + Flhlen; 1633 fmtdesc[4] = Fmtfull; 1634 /* 0-3 are big-endian # of blocks, 5-7 format-dependent data */ 1635 1636 nblks = 0; 1637 blksize = BScdrom; 1638 setblksz = 1; 1639 switch (drive->mmctype) { 1640 case Mmccd: 1641 nblks = 0; 1642 break; 1643 case Mmcdvdplus: 1644 /* format type 0 is optional but equiv to format type 0x26 */ 1645 fmtdesc[4] = 0x26 << 2; 1646 nblks = ~0ul; 1647 blksize = 0; 1648 break; 1649 case Mmcbd: 1650 /* enable BD-R defect mgmt. */ 1651 if (drive->recordable == Yes && drive->erasable == No) { 1652 parms[1] &= ~Immed; 1653 fmtdesc[4] |= Fullbdrsrmspares; 1654 setblksz = 0; 1655 } 1656 break; 1657 } 1658 1659 PUTBELONG(fmtdesc, nblks); 1660 if (setblksz) 1661 PUTBE24(fmtdesc + 5, blksize); 1662 1663 // print("format parameters:\n"); 1664 // hexdump(parms, sizeof parms); 1665 1666 if(vflag) 1667 print("%lld ns: format\n", nsec()); 1668 return scsi(drive, cmd, sizeof(cmd), parms, sizeof parms, Swrite); 1669 } 1670 1671 static int 1672 dvdcanverify(Drive *drive) 1673 { 1674 return (drive->mmctype == Mmcdvdplus || 1675 drive->mmctype == Mmcdvdminus) && 1676 isbitset(Featrandwrite, drive->features) && 1677 isbitset(Featwriteonce, drive->features) && 1678 isbitset(Featdvdrw, drive->features); 1679 } 1680 1681 static long 1682 mmcxwrite(Otrack *o, void *v, long nblk) 1683 { 1684 int r; 1685 long bs; 1686 uchar cmd[10]; 1687 Drive *drive; 1688 Mmcaux *aux; 1689 1690 assert(o->omode == OWRITE); 1691 bs = o->track->bs; 1692 drive = o->drive; 1693 aux = drive->aux; 1694 if (aux->mmcnwa == -1 && scsiready(drive) < 0) { 1695 werrstr("device not ready to write"); 1696 return -1; 1697 } 1698 if (aux->mmcnwa == -1 || 1699 drive->end != 0 && aux->mmcnwa + nblk > drive->end) { 1700 werrstr("writing past last block"); 1701 return -1; 1702 } 1703 if (nblk <= 0) 1704 fprint(2, "mmcxwrite: nblk %ld <= 0\n", nblk); 1705 aux->ntotby += nblk * bs; 1706 aux->ntotbk += nblk; 1707 1708 /* 1709 * "write and verify" (ScmdExtwritever) only works on write-once media 1710 * and not on CDs (mmc-6 §6.48.1). 1711 */ 1712 if ((drive->mmctype == Mmcbd || dvdcanverify(drive)) && 1713 drive->recordable == Yes && drive->erasable == No) 1714 initcdb(cmd, sizeof cmd, ScmdExtwritever); 1715 else 1716 initcdb(cmd, sizeof cmd, ScmdExtwrite); /* write (10) */ 1717 cmd[2] = aux->mmcnwa>>24; 1718 cmd[3] = aux->mmcnwa>>16; 1719 cmd[4] = aux->mmcnwa>>8; 1720 cmd[5] = aux->mmcnwa; 1721 cmd[7] = nblk>>8; 1722 cmd[8] = nblk>>0; 1723 if(vflag > 1) 1724 print("%lld ns: write+verify %ld at %#lux\n", 1725 nsec(), nblk, aux->mmcnwa); 1726 /* 1727 * we are using a private copy of scsi.c that doesn't retry writes 1728 * to ensure that the write-verify command is issued exactly once. 1729 * the drive may perform internal defect management on write errors, 1730 * but explicit attempts to rewrite a given sector on write-once 1731 * media are guaranteed to fail. 1732 */ 1733 r = scsi(drive, cmd, sizeof(cmd), v, nblk * bs, Swrite); 1734 if (r < 0) 1735 fprint(2, "%s: write+verify error at blk offset %,ld = " 1736 "offset %,lld / bs %ld: %r\n", 1737 argv0, aux->mmcnwa, (vlong)aux->mmcnwa * bs, bs); 1738 else 1739 aux->mmcnwa += nblk; 1740 return r; 1741 } 1742 1743 static long 1744 mmcwrite(Buf *buf, void *v, long nblk, ulong) 1745 { 1746 return mmcxwrite(buf->otrack, v, nblk); 1747 } 1748 1749 enum { 1750 Eccblk = 128, /* sectors per ecc block */ 1751 Rsvslop = 0, 1752 }; 1753 1754 static int 1755 reserve(Drive *drive, int track) 1756 { 1757 ulong sz; 1758 uchar cmd[10]; 1759 1760 initcdb(cmd, sizeof cmd, ScmdReserve); 1761 track -= drive->firsttrack; /* switch to zero-origin */ 1762 if (track >= 0 && track < drive->ntrack) 1763 /* .end is next sector past sz */ 1764 sz = drive->track[track].end - drive->track[track].beg - Rsvslop; 1765 else { 1766 sz = Eccblk; 1767 fprint(2, "%s: reserve: track #%d out of range 0-%d\n", 1768 argv0, track, drive->ntrack); 1769 } 1770 sz -= sz % Eccblk; /* round down to ecc-block multiple */ 1771 if ((long)sz < 0) { 1772 fprint(2, "%s: reserve: bogus size %lud\n", argv0, sz); 1773 return -1; 1774 } 1775 cmd[1] = 0; /* no ASRV: allocate by size not lba */ 1776 PUTBELONG(cmd + 2 + 3, sz); 1777 if (vflag) 1778 fprint(2, "reserving %ld sectors\n", sz); 1779 return scsi(drive, cmd, sizeof cmd, cmd, 0, Snone); 1780 } 1781 1782 static int 1783 getinvistrack(Drive *drive) 1784 { 1785 int n; 1786 uchar cmd[10], resp[Pagesz]; 1787 1788 initcdb(cmd, sizeof(cmd), ScmdRtrackinfo); 1789 cmd[1] = 1<<2 | 1; /* open; address below is logical track # */ 1790 PUTBELONG(cmd + 2, 1); /* find first open track */ 1791 cmd[7] = sizeof(resp)>>8; 1792 cmd[8] = sizeof(resp); 1793 n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread); 1794 if(n < 4) { 1795 if(vflag) 1796 print("trackinfo for invis track fails n=%d: %r\n", n); 1797 return -1; 1798 } 1799 1800 if(vflag) 1801 print("getinvistrack: track #%d session #%d\n", 1802 resp[2], resp[3]); 1803 drive->invistrack = resp[2]; 1804 return resp[2]; 1805 } 1806 1807 static Otrack* 1808 mmccreate(Drive *drive, int type) 1809 { 1810 int bs; 1811 Mmcaux *aux; 1812 Track *t; 1813 Otrack *o; 1814 1815 aux = drive->aux; 1816 1817 if(aux->nropen || aux->nwopen) { 1818 werrstr("drive in use"); 1819 return nil; 1820 } 1821 1822 switch(type){ 1823 case TypeAudio: 1824 bs = BScdda; 1825 break; 1826 case TypeData: 1827 bs = BScdrom; 1828 break; 1829 default: 1830 werrstr("bad type %d", type); 1831 return nil; 1832 } 1833 1834 /* comment out the returns for now; it should be no big deal - geoff */ 1835 if(mmctrackinfo(drive, drive->invistrack, Maxtrack)) { 1836 if (vflag) 1837 fprint(2, "mmccreate: mmctrackinfo for invis track %d" 1838 " failed: %r\n", drive->invistrack); 1839 werrstr("disc not writable"); 1840 // return nil; 1841 } 1842 if(mmcsetbs(drive, bs) < 0) { 1843 werrstr("cannot set bs mode"); 1844 // return nil; 1845 } 1846 if(mmctrackinfo(drive, drive->invistrack, Maxtrack)) { 1847 if (vflag) 1848 fprint(2, "mmccreate: mmctrackinfo for invis track %d" 1849 " (2) failed: %r\n", drive->invistrack); 1850 werrstr("disc not writable 2"); 1851 // return nil; 1852 } 1853 1854 /* special hack for dvd-r: reserve the invisible track */ 1855 if (drive->mmctype == Mmcdvdminus && drive->writeok && 1856 drive->recordable == Yes && reserve(drive, drive->invistrack) < 0) { 1857 if (vflag) 1858 fprint(2, "mmcreate: reserving track %d for dvd-r " 1859 "failed: %r\n", drive->invistrack); 1860 return nil; 1861 } 1862 1863 aux->ntotby = 0; 1864 aux->ntotbk = 0; 1865 1866 t = &drive->track[drive->ntrack++]; 1867 t->size = 0; 1868 t->bs = bs; 1869 t->beg = aux->mmcnwa; 1870 t->end = 0; 1871 t->type = type; 1872 drive->nameok = 0; 1873 1874 o = emalloc(sizeof(Otrack)); 1875 o->drive = drive; 1876 o->nchange = drive->nchange; 1877 o->omode = OWRITE; 1878 o->track = t; 1879 o->buf = bopen(mmcwrite, OWRITE, bs, Readblock); 1880 o->buf->otrack = o; 1881 1882 aux->nwopen++; 1883 1884 if(vflag) 1885 print("mmcinit: nwa = %#luX\n", aux->mmcnwa); 1886 return o; 1887 } 1888 1889 /* 1890 * issue some form of close track, close session or finalize disc command. 1891 * see The Matrix, table 252 in MMC-6 §6.3.2.3. 1892 */ 1893 static int 1894 mmcxclose(Drive *drive, int clf, int trackno) 1895 { 1896 uchar cmd[10]; 1897 1898 initcdb(cmd, sizeof cmd, ScmdClosetracksess); 1899 /* cmd[1] & 1 is the immediate bit */ 1900 cmd[2] = clf; /* close function */ 1901 if(clf == Closetrack) 1902 cmd[5] = trackno; 1903 return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone); 1904 } 1905 1906 /* flush drive cache, close current track */ 1907 void 1908 mmcsynccache(Drive *drive) 1909 { 1910 uchar cmd[10]; 1911 Mmcaux *aux; 1912 1913 initcdb(cmd, sizeof cmd, ScmdSynccache); 1914 /* 1915 * this will take a long time to burn the remainder of a dvd-r 1916 * with a reserved track covering the whole disc. 1917 */ 1918 if (vflag) { 1919 fprint(2, "syncing cache"); 1920 if (drive->mmctype == Mmcdvdminus && drive->writeok && 1921 drive->recordable == Yes) 1922 fprint(2, "; dvd-r burning rest of track reservation, " 1923 "will be slow"); 1924 fprint(2, "\n"); 1925 } 1926 scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone); 1927 if(vflag) { 1928 aux = drive->aux; 1929 print("mmcsynccache: bytes = %lld blocks = %ld, mmcnwa %#luX\n", 1930 aux->ntotby, aux->ntotbk, aux->mmcnwa); 1931 } 1932 1933 /* 1934 * rsc: seems not to work on some drives. 1935 * so ignore return code & don't issue on dvd+rw. 1936 */ 1937 if(drive->mmctype != Mmcdvdplus || drive->erasable == No) { 1938 if (vflag) 1939 fprint(2, "closing invisible track %d (not dvd+rw)...\n", 1940 drive->invistrack); 1941 mmcxclose(drive, Closetrack, drive->invistrack); 1942 if (vflag) 1943 fprint(2, "... done.\n"); 1944 } 1945 getinvistrack(drive); /* track # has probably changed */ 1946 } 1947 1948 /* 1949 * close the open track `o'. 1950 */ 1951 static void 1952 mmcclose(Otrack *o) 1953 { 1954 Mmcaux *aux; 1955 static uchar zero[2*BSmax]; 1956 1957 aux = o->drive->aux; 1958 if(o->omode == OREAD) 1959 aux->nropen--; 1960 else if(o->omode == OWRITE) { 1961 aux->nwopen--; 1962 mmcxwrite(o, zero, 2); /* write lead out */ 1963 mmcsynccache(o->drive); 1964 o->drive->nchange = -1; /* force reread toc */ 1965 } 1966 free(o); 1967 } 1968 1969 static int 1970 setonesess(Drive *drive) 1971 { 1972 uchar *p; 1973 Mmcaux *aux; 1974 1975 /* page 5 is legacy and now read-only; see MMC-6 §7.5.4.1 */ 1976 aux = drive->aux; 1977 if (!aux->page05ok) 1978 return -1; 1979 p = aux->page05; 1980 p[Wptrkmode] &= ~Msbits; 1981 p[Wptrkmode] |= Msnonext; 1982 return mmcsetpage(drive, Pagwrparams, p); 1983 } 1984 1985 /* 1986 * close the current session, then finalize the disc. 1987 */ 1988 static int 1989 mmcfixate(Drive *drive) 1990 { 1991 int r; 1992 1993 if((drive->cap & Cwrite) == 0) { 1994 werrstr("not a writer"); 1995 return -1; 1996 } 1997 drive->nchange = -1; /* force reread toc */ 1998 1999 setonesess(drive); 2000 2001 /* skip explicit close session on bd-r */ 2002 if (drive->mmctype != Mmcbd || drive->erasable == Yes) { 2003 if (vflag) 2004 fprint(2, "closing session and maybe finalizing...\n"); 2005 r = mmcxclose(drive, Closesessfinal, 0); 2006 if (vflag) 2007 fprint(2, "... done.\n"); 2008 if (r < 0) 2009 return r; 2010 } 2011 /* 2012 * Closesessfinal only closes & doesn't finalize on dvd+r and bd-r. 2013 * Closedvdrbdfinal closes & finalizes dvd+r and bd-r. 2014 */ 2015 if ((drive->mmctype == Mmcdvdplus || drive->mmctype == Mmcbd) && 2016 drive->erasable == No) { 2017 if (vflag) 2018 fprint(2, "finalizing dvd+r or bd-r... " 2019 "(won't print `done').\n"); 2020 return mmcxclose(drive, Closedvdrbdfinal, 0); 2021 } 2022 return 0; 2023 } 2024 2025 static int 2026 mmcblank(Drive *drive, int quick) 2027 { 2028 uchar cmd[12]; 2029 2030 drive->nchange = -1; /* force reread toc */ 2031 2032 initcdb(cmd, sizeof cmd, ScmdBlank); /* blank cd-rw media */ 2033 /* immediate bit is 0x10 */ 2034 /* cmd[1] = 0 means blank the whole disc; = 1 just the header */ 2035 cmd[1] = quick ? 0x01 : 0x00; 2036 2037 return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone); 2038 } 2039 2040 static char* 2041 e(int status) 2042 { 2043 if(status < 0) 2044 return geterrstr(); 2045 return nil; 2046 } 2047 2048 static char* 2049 mmcctl(Drive *drive, int argc, char **argv) 2050 { 2051 char *cmd; 2052 2053 if(argc < 1) 2054 return nil; 2055 cmd = argv[0]; 2056 if(strcmp(cmd, "format") == 0) 2057 return e(format(drive)); 2058 if(strcmp(cmd, "blank") == 0) 2059 return e(mmcblank(drive, 0)); 2060 if(strcmp(cmd, "quickblank") == 0) 2061 return e(mmcblank(drive, 1)); 2062 if(strcmp(cmd, "eject") == 0) 2063 return e(start(drive, 2)); 2064 if(strcmp(cmd, "ingest") == 0) 2065 return e(start(drive, 3)); 2066 return "bad arg"; 2067 } 2068 2069 static char* 2070 mmcsetspeed(Drive *drive, int r, int w) 2071 { 2072 char *rv; 2073 uchar cmd[12]; 2074 2075 initcdb(cmd, sizeof cmd, ScmdSetcdspeed); 2076 cmd[2] = r>>8; 2077 cmd[3] = r; 2078 cmd[4] = w>>8; 2079 cmd[5] = w; 2080 rv = e(scsi(drive, cmd, sizeof(cmd), nil, 0, Snone)); 2081 mmcgetspeed(drive); 2082 return rv; 2083 } 2084 2085 static Dev mmcdev = { 2086 mmcopenrd, 2087 mmccreate, 2088 bufread, 2089 bufwrite, 2090 mmcclose, 2091 mmcgettoc, 2092 mmcfixate, 2093 mmcctl, 2094 mmcsetspeed, 2095 }; 2096