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
bige(void * p)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
biges(void * p)119 biges(void *p)
120 {
121 uchar *a;
122
123 a = p;
124 return (a[0]<<8) | a[1];
125 }
126
127 ulong
getnwa(Drive * drive)128 getnwa(Drive *drive)
129 {
130 Mmcaux *aux;
131
132 aux = drive->aux;
133 return aux->mmcnwa;
134 }
135
136 static void
hexdump(void * v,int n)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
initcdb(uchar * cdb,int len,int cmd)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
mmcgetpage10(Drive * drive,int page,void * v)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
mmcgetpage6(Drive * drive,int page,void * v)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
mmcsetpage10(Drive * drive,int page,void * v)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
mmcsetpage6(Drive * drive,int page,void * v)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
mmcgetpage(Drive * drive,int page,void * v)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
mmcsetpage(Drive * drive,int page,void * v)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
mmcstatus(Drive * drive)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
mmcgetspeed(Drive * drive)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
getdevtype(Drive * drive)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
start(Drive * drive,int code)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
setcaching(Drive * drive)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*
mmcprobe(Scsi * scsi)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
gettracknwa(Drive * drive,int t,ulong beg,uchar * resp)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
gettypebs(uchar tmode,int t,int i,int * typep,int * bsp)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
mmctrackinfo(Drive * drive,int t,int i)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
mmcreadtoc(Drive * drive,int type,int track,void * data,int nbytes)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
rdmsf(uchar * p)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
getdiscinfo(Drive * drive,uchar resp[],int resplen)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
isbitset(uint bit,uchar * map)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
seterrrecov(Drive * drive)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 *
featname(int feat)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
prof2mmctype(Drive * drive,ushort prof)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
notefeats(Drive * drive,uchar * p,ulong datalen)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
getconfcmd(Drive * drive,uchar * resp,int respsz)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
getconf(Drive * drive)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
getdvdstruct(Drive * drive)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
bdguess(Drive * drive)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
getbdstruct(Drive * drive)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
mmcinfertracks(Drive * drive,int first,int last)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
initdrive(Drive * drive)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
computenwa(Drive * drive,int first,int last)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
findntracks(Drive * drive,int * firstp,int * lastp)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
alltrackinfo(Drive * drive,int first,int last)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
findtracks(Drive * drive,int first,int last)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
finddisctype(Drive * drive,int first,int last)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
mmcgettoc(Drive * drive)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
settrkmode(uchar * p,int mode)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
mmcsetbs(Drive * drive,int bs)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
fillread12cdb(Drive * drive,uchar * cmd,long nblock,ulong off,int bs)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
mmcread(Buf * buf,void * v,long nblock,ulong off)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*
mmcopenrd(Drive * drive,int trackno)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
format(Drive * drive)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
dvdcanverify(Drive * drive)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
mmcxwrite(Otrack * o,void * v,long nblk)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
mmcwrite(Buf * buf,void * v,long nblk,ulong)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
reserve(Drive * drive,int track)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
getinvistrack(Drive * drive)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*
mmccreate(Drive * drive,int type)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
mmcxclose(Drive * drive,int clf,int trackno)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
mmcsynccache(Drive * drive)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
mmcclose(Otrack * o)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
setonesess(Drive * drive)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
mmcfixate(Drive * drive)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
mmcblank(Drive * drive,int quick)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*
e(int status)2041 e(int status)
2042 {
2043 if(status < 0)
2044 return geterrstr();
2045 return nil;
2046 }
2047
2048 static char*
mmcctl(Drive * drive,int argc,char ** argv)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*
mmcsetspeed(Drive * drive,int r,int w)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