Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 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 
};