Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/cdio/mmc.c	Lines:	0	307	0.0 %
Date:	2017-11-07	Branches:	0	109	0.0 %


/*	$OpenBSD: mmc.c,v 1.30 2015/01/16 06:40:06 deraadt Exp $	*/
/*
 * Copyright (c) 2006 Michael Coulter <mjc@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/limits.h>
#include <sys/types.h>
#include <sys/scsiio.h>
#include <sys/param.h>	/* setbit, isset */
#include <scsi/cd.h>
#include <scsi/scsi_all.h>
#include <scsi/scsi_disk.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "extern.h"

extern int fd;
extern u_int8_t mediacap[];
extern char *cdname;
extern int verbose;

#define SCSI_GET_CONFIGURATION		0x46

#define MMC_FEATURE_HDR_LEN		8

static const struct {
	u_int16_t id;
	char *name;
} mmc_feature[] = {
	{ 0x0000, "Profile List" },
	{ 0x0001, "Core" },
	{ 0x0002, "Morphing" },
	{ 0x0003, "Removable Medium" },
	{ 0x0004, "Write Protect" },
	{ 0x0010, "Random Readable" },
	{ 0x001d, "Multi-Read" },
	{ 0x001e, "CD Read" },
	{ 0x001f, "DVD Read" },
	{ 0x0020, "Random Writable" },
	{ 0x0021, "Incremental Streaming Writable" },
	{ 0x0022, "Sector Erasable" },
	{ 0x0023, "Formattable" },
	{ 0x0024, "Hardware Defect Management" },
	{ 0x0025, "Write Once" },
	{ 0x0026, "Restricted Overwrite" },
	{ 0x0027, "CD-RW CAV Write" },
	{ 0x0028, "MRW" },
	{ 0x0029, "Enhanced Defect Reporting" },
	{ 0x002a, "DVD+RW" },
	{ 0x002b, "DVD+R" },
	{ 0x002c, "Rigid Restricted Overwrite" },
	{ 0x002d, "CD Track at Once (TAO)" },
	{ 0x002e, "CD Mastering (Session at Once)" },
	{ 0x002f, "DVD-RW Write" },
	{ 0x0030, "DDCD-ROM (Legacy)" },
	{ 0x0031, "DDCD-R (Legacy)" },
	{ 0x0032, "DDCD-RW (Legacy)" },
	{ 0x0033, "Layer Jump Recording" },
	{ 0x0037, "CD-RW Media Write Support" },
	{ 0x0038, "BD-R Pseudo-Overwrite (POW)" },
	{ 0x003a, "DVD+RW Dual Layer" },
	{ 0x003b, "DVD+R Dual Layer" },
	{ 0x0040, "BD Read" },
	{ 0x0041, "BD Write" },
	{ 0x0042, "Timely Safe Recording (TSR)" },
	{ 0x0050, "HD DVD Read" },
	{ 0x0051, "HD DVD Write" },
	{ 0x0080, "Hybrid Disc" },
	{ 0x0100, "Power Management" },
	{ 0x0101, "S.M.A.R.T." },
	{ 0x0102, "Embedded Changer" },
	{ 0x0103, "CD Audio External Play (Legacy)" },
	{ 0x0104, "Microcode Upgrade" },
	{ 0x0105, "Timeout" },
	{ 0x0106, "DVD CSS" },
	{ 0x0107, "Real Time Streaming" },
	{ 0x0108, "Drive Serial Number" },
	{ 0x0109, "Media Serial Number" },
	{ 0x010a, "Disc Control Blocks (DCBs)" },
	{ 0x010b, "DVD CPRM" },
	{ 0x010c, "Firmware Information" },
	{ 0x010d, "AACS" },
	{ 0x0110, "VCPS" },
	{ 0, NULL }
};

static const struct {
	u_int16_t id;
	char *name;
} mmc_profile[] = {
	{ 0x0001, "Re-writable disk, capable of changing behaviour" },
	{ 0x0002, "Re-writable, with removable media" },
	{ 0x0003, "Magneto-Optical disk with sector erase capability" },
	{ 0x0004, "Optical write once" },
	{ 0x0005, "Advance Storage -- Magneto-Optical" },
	{ 0x0008, "Read only Compact Disc" },
	{ 0x0009, "Write once Compact Disc" },
	{ 0x000a, "Re-writable Compact Disc" },
	{ 0x0010, "Read only DVD" },
	{ 0x0011, "Write once DVD using Sequential recording" },
	{ 0x0012, "Re-writable DVD" },
	{ 0x0013, "Re-recordable DVD using Restricted Overwrite" },
	{ 0x0014, "Re-recordable DVD using Sequential recording" },
	{ 0x0015, "Dual Layer DVD-R using Sequential recording" },
	{ 0x0016, "Dual Layer DVD-R using Layer Jump recording" },
	{ 0x001a, "DVD+ReWritable" },
	{ 0x001b, "DVD+Recordable" },
	{ 0x0020, "DDCD-ROM" },
	{ 0x0021, "DDCD-R" },
	{ 0x0022, "DDCD-RW" },
	{ 0x002a, "DVD+Rewritable Dual Layer" },
	{ 0x002b, "DVD+Recordable Dual Layer" },
	{ 0x003e, "Blu-ray Disc ROM" },
	{ 0x003f, "Blu-ray Disc Recordable -- Sequential Recording Mode" },
	{ 0x0040, "Blu-ray Disc Recordable -- Random Recording Mode" },
	{ 0x0041, "Blu-ray Disc Rewritable" },
	{ 0x004e, "Read-only HD DVD" },
	{ 0x004f, "Write-once HD DVD" },
	{ 0x0050, "Rewritable HD DVD" },
	{ 0, NULL }
};

int
get_media_type(void)
{
	scsireq_t scr;
	char buf[32];
	u_char disctype;
	int rv, error;

	rv = MEDIATYPE_UNKNOWN;
	memset(buf, 0, sizeof(buf));
	memset(&scr, 0, sizeof(scr));

	scr.cmd[0] = READ_TOC;
	scr.cmd[1] = 0x2;	/* MSF */
	scr.cmd[2] = 0x4;	/* ATIP */
	scr.cmd[8] = 0x20;

	scr.flags = SCCMD_ESCAPE | SCCMD_READ;
	scr.databuf = buf;
	scr.datalen = sizeof(buf);
	scr.cmdlen = 10;
	scr.timeout = 120000;
	scr.senselen = SENSEBUFLEN;

	error = ioctl(fd, SCIOCCOMMAND, &scr);
	if (error != -1 && scr.retsts == SCCMD_OK && scr.datalen_used > 7) {
		disctype = (buf[6] >> 6) & 0x1;
		if (disctype == 0)
			rv = MEDIATYPE_CDR;
		else if (disctype == 1)
			rv = MEDIATYPE_CDRW;
	}

	return (rv);
}

int
get_media_capabilities(u_int8_t *cap, int rt)
{
	scsireq_t scr;
	u_char buf[4096];
	u_int32_t i, dlen;
	u_int16_t feature, profile, tmp;
	u_int8_t feature_len;
	int current, error, j, k;

	memset(cap, 0, MMC_FEATURE_MAX / NBBY);
	memset(buf, 0, sizeof(buf));
	memset(&scr, 0, sizeof(scr));

	scr.cmd[0] = SCSI_GET_CONFIGURATION;
	scr.cmd[1] = rt;
	tmp = htobe16(sizeof(buf));
	memcpy(scr.cmd + 7, &tmp, sizeof(u_int16_t));

	scr.flags = SCCMD_ESCAPE | SCCMD_READ;
	scr.databuf = buf;
	scr.datalen = sizeof(buf);
	scr.cmdlen = 10;
	scr.timeout = 120000;
	scr.senselen = SENSEBUFLEN;

	error = ioctl(fd, SCIOCCOMMAND, &scr);
	if (error == -1 || scr.retsts != SCCMD_OK)
		return (-1);
	if (scr.datalen_used < MMC_FEATURE_HDR_LEN)
		return (-1);	/* Can't get the header. */

	/* Include the whole header in the length. */
	dlen = betoh32(*(u_int32_t *)buf) + 4;
	if (dlen > scr.datalen_used)
		dlen = scr.datalen_used;

	if (verbose > 1)
		printf("Features:\n");
	for (i = MMC_FEATURE_HDR_LEN; i + 3 < dlen; i += feature_len) {
		feature_len = buf[i + 3] + 4;
		if (feature_len + i > dlen)
			break;

		feature = betoh16(*(u_int16_t *)(buf + i));
		if (feature >= MMC_FEATURE_MAX)
			break;

		if (verbose > 1) {
			printf("0x%04x", feature);
			for (j = 0; mmc_feature[j].name != NULL; j++)
				if (feature == mmc_feature[j].id)
					break;
			if (mmc_feature[j].name == NULL)
				printf(" <Undocumented>");
			else
				printf(" %s", mmc_feature[j].name);
			if (feature_len > 4)
				printf(" (%d bytes of data)", feature_len - 4);
			printf("\n");
			if (verbose > 2) {
				printf("    ");
				for (j = i; j < i + feature_len; j++) {
					printf("%02x", buf[j]);
					if ((j + 1) == (i + feature_len))
						printf("\n");
					else if ((j > i) && ((j - i + 1) % 16
					    == 0))
						printf("\n    ");
					else if ((j - i) == 3)
						printf("|");
					else
						printf(" ");
				}
			}
		}
		if (feature == 0 && verbose > 1) {
			if (verbose > 2)
				printf("    Profiles:\n");
			for (j = i + 4; j < i + feature_len; j += 4) {
				profile = betoh16(*(u_int16_t *)(buf+j));
				current = buf[j+2] == 1;
				if (verbose < 3 && !current)
					continue;
				if (current)
					printf("  * ");
				else
					printf("    ");
				printf("0x%04x", profile);
				for (k = 0; mmc_profile[k].name != NULL; k++)
					if (profile == mmc_profile[k].id)
						break;
				if (mmc_profile[k].name == NULL)
					printf(" <Undocumented>");
				else
					printf(" %s", mmc_profile[k].name);
				printf(" %s\n", current ? "[Current Profile]" :
				    "" );
			}
		}
		setbit(cap, feature);
	}

	return (0);
}

static int
set_speed(int wspeed)
{
	scsireq_t scr;
	int r;

	memset(&scr, 0, sizeof(scr));
	scr.cmd[0] = SET_CD_SPEED;
	scr.cmd[1] = (isset(mediacap, MMC_FEATURE_CDRW_CAV)) != 0;
	*(u_int16_t *)(scr.cmd + 2) = htobe16(DRIVE_SPEED_OPTIMAL);
	*(u_int16_t *)(scr.cmd + 4) = htobe16(wspeed);

	scr.cmdlen = 12;
	scr.datalen = 0;
	scr.timeout = 120000;
	scr.flags = SCCMD_ESCAPE;
	scr.senselen = SENSEBUFLEN;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
blank(void)
{
	struct scsi_blank *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_blank *)scr.cmd;
	scb->opcode = BLANK;
	scb->byte2 |= BLANK_MINIMAL;
	scr.cmdlen = sizeof(*scb);
	scr.datalen = 0;
	scr.timeout = 120000;
	scr.flags = SCCMD_ESCAPE;
	scr.senselen = SENSEBUFLEN;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
unit_ready(void)
{
	struct scsi_test_unit_ready *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_test_unit_ready *)scr.cmd;
	scb->opcode = TEST_UNIT_READY;
	scr.cmdlen = sizeof(*scb);
	scr.datalen = 0;
	scr.timeout = 120000;
	scr.flags = SCCMD_ESCAPE;
	scr.senselen = SENSEBUFLEN;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
synchronize_cache(void)
{
	struct scsi_synchronize_cache *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_synchronize_cache *)scr.cmd;
	scb->opcode = SYNCHRONIZE_CACHE;
	scr.cmdlen = sizeof(*scb);
	scr.datalen = 0;
	scr.timeout = 120000;
	scr.flags = SCCMD_ESCAPE;
	scr.senselen = SENSEBUFLEN;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
close_session(void)
{
	struct scsi_close_track *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_close_track *)scr.cmd;
	scb->opcode = CLOSE_TRACK;
	scb->closefunc = CT_CLOSE_SESS;
	scr.cmdlen = sizeof(*scb);
	scr.datalen = 0;
	scr.timeout = 120000;
	scr.flags = SCCMD_ESCAPE;
	scr.senselen = SENSEBUFLEN;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
writetao(struct track_head *thp)
{
	u_char modebuf[70], bdlen;
	struct track_info *tr;
	int r, track = 0;

	if ((r = mode_sense_write(modebuf)) != SCCMD_OK) {
		warnx("mode sense failed: %d", r);
		return (r);
	}
	bdlen = modebuf[7];
	modebuf[2+8+bdlen] |= 0x40; /* Buffer Underrun Free Enable */
	modebuf[2+8+bdlen] |= 0x01; /* change write type to TAO */

	SLIST_FOREACH(tr, thp, track_list) {
		track++;
		switch (tr->type) {
		case 'd':
			modebuf[3+8+bdlen] = 0x04; /* track mode = data */
			modebuf[4+8+bdlen] = 0x08; /* 2048 block track mode */
			modebuf[8+8+bdlen] = 0x00; /* turn off XA */
			break;
		case 'a':
			modebuf[3+8+bdlen] = 0x00; /* track mode = audio */
			modebuf[4+8+bdlen] = 0x00; /* 2352 block track mode */
			modebuf[8+8+bdlen] = 0x00; /* turn off XA */
			break;
		default:
			warn("impossible tracktype detected");
			break;
		}
		while (unit_ready() != SCCMD_OK)
			continue;
		if ((r = mode_select_write(modebuf)) != SCCMD_OK) {
			warnx("mode select failed: %d", r);
			return (r);
		}

		set_speed(tr->speed);
		writetrack(tr, track);
		synchronize_cache();
	}
	fprintf(stderr, "Closing session.\n");
	close_session();
	return (0);
}

int
writetrack(struct track_info *tr, int track)
{
	struct timeval tv, otv, atv;
	u_char databuf[65536], nblk;
	u_int end_lba, lba, tmp;
	scsireq_t scr;
	int r;

	nblk = 65535/tr->blklen;
	bzero(&scr, sizeof(scr));
	scr.timeout = 300000;
	scr.cmd[0] = WRITE_BIG;
	scr.cmd[1] = 0x00;
	scr.cmd[8] = nblk; /* Transfer length in blocks (LSB) */
	scr.cmdlen = 10;
	scr.databuf = (caddr_t)databuf;
	scr.datalen = nblk * tr->blklen;
	scr.senselen = SENSEBUFLEN;
	scr.flags = SCCMD_ESCAPE|SCCMD_WRITE;

	timerclear(&otv);
	atv.tv_sec = 1;
	atv.tv_usec = 0;

	if (get_nwa(&lba) != SCCMD_OK) {
		warnx("cannot get next writable address");
		return (-1);
	}
	tmp = htobe32(lba); /* update lba in cdb */
	memcpy(&scr.cmd[2], &tmp, sizeof(tmp));

	if (tr->sz / tr->blklen + 1 > UINT_MAX || tr->sz < tr->blklen) {
		warnx("file %s has invalid size", tr->file);
		return (-1);
	}
	if (tr->sz % tr->blklen) {
		warnx("file %s is not multiple of block length %d",
		    tr->file, tr->blklen);
		end_lba = tr->sz / tr->blklen + lba + 1;
	} else {
		end_lba = tr->sz / tr->blklen + lba;
	}
	if (lseek(tr->fd, tr->off, SEEK_SET) == -1)
		err(1, "seek failed for file %s", tr->file);
	while (lba < end_lba && nblk != 0) {
		while (lba + nblk <= end_lba) {
			read(tr->fd, databuf, nblk * tr->blklen);
			scr.cmd[8] = nblk;
			scr.datalen = nblk * tr->blklen;
again:
			r = ioctl(fd, SCIOCCOMMAND, &scr);
			if (r != 0) {
				printf("\r%60s", "");
				warn("ioctl failed while attempting to write");
				return (-1);
			}
			if (scr.retsts == SCCMD_SENSE && scr.sense[2] == 0x2) {
				usleep(1000);
				goto again;
			}
			if (scr.retsts != SCCMD_OK) {
				printf("\r%60s", "");
				warnx("ioctl returned bad status while "
				    "attempting to write: %d",
				    scr.retsts);
				return (r);
			}
			lba += nblk;

			gettimeofday(&tv, NULL);
			if (lba == end_lba || timercmp(&tv, &otv, >)) {
				fprintf(stderr,
				    "\rtrack %02d '%c' %08u/%08u %3d%%",
				    track, tr->type,
				    lba, end_lba, 100 * lba / end_lba);
				timeradd(&tv, &atv, &otv);
			}
			tmp = htobe32(lba); /* update lba in cdb */
			memcpy(&scr.cmd[2], &tmp, sizeof(tmp));
		}
		nblk--;
	}
	printf("\n");
	close(tr->fd);
	return (0);
}

int
mode_sense_write(unsigned char buf[])
{
	struct scsi_mode_sense_big *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_mode_sense_big *)scr.cmd;
	scb->opcode = MODE_SENSE_BIG;
	/* XXX: need to set disable block descriptors and check SCSI drive */
	scb->page = WRITE_PARAM_PAGE;
	scb->length[1] = 0x46; /* 16 for the header + size from pg. 89 mmc-r10a.pdf */
	scr.cmdlen = sizeof(*scb);
	scr.timeout = 4000;
	scr.senselen = SENSEBUFLEN;
	scr.datalen= 0x46;
	scr.flags = SCCMD_ESCAPE|SCCMD_READ;
	scr.databuf = (caddr_t)buf;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
mode_select_write(unsigned char buf[])
{
	struct scsi_mode_select_big *scb;
	scsireq_t scr;
	int r;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_mode_select_big *)scr.cmd;
	scb->opcode = MODE_SELECT_BIG;

	/*
	 * INF-8020 says bit 4 in byte 2 is '1'
	 * INF-8090 refers to it as 'PF(1)' then doesn't
	 * describe it.
	 */
	scb->byte2 = 0x10;
	scb->length[1] = 2 + buf[1] + 256 * buf[0];
	scr.timeout = 4000;
	scr.senselen = SENSEBUFLEN;
	scr.cmdlen = sizeof(*scb);
	scr.datalen = 2 + buf[1] + 256 * buf[0];
	scr.flags = SCCMD_ESCAPE|SCCMD_WRITE;
	scr.databuf = (caddr_t)buf;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	return (r == 0 ? scr.retsts : -1);
}

int
get_disc_size(off_t *availblk)
{
	u_char databuf[28];
	struct scsi_read_track_info *scb;
	scsireq_t scr;
	int r, tmp;

	bzero(&scr, sizeof(scr));
	scb = (struct scsi_read_track_info *)scr.cmd;
	scr.timeout = 4000;
	scr.senselen = SENSEBUFLEN;
	scb->opcode = READ_TRACK_INFO;
	scb->addrtype = RTI_TRACK;
	scb->addr[3] = 1;
	scb->data_len[1] = 0x1c;
	scr.cmdlen = sizeof(*scb);
	scr.datalen= 0x1c;
	scr.flags = SCCMD_ESCAPE|SCCMD_READ;
	scr.databuf = (caddr_t)databuf;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	memcpy(&tmp, &databuf[16], sizeof(tmp));
	*availblk = betoh32(tmp);
	return (r == 0 ? scr.retsts : -1);
}

int
get_nwa(int *nwa)
{
	u_char databuf[28];
	scsireq_t scr;
	int r, tmp;

	bzero(&scr, sizeof(scr));
	scr.timeout = 4000;
	scr.senselen = SENSEBUFLEN;
	scr.cmd[0] = READ_TRACK_INFO;
	scr.cmd[1] = 0x01;
	scr.cmd[5] = 0xff; /* Invisible Track */
	scr.cmd[7] = 0x00;
	scr.cmd[8] = 0x1c;
	scr.cmdlen = 10;
	scr.datalen= 0x1c;
	scr.flags = SCCMD_ESCAPE|SCCMD_READ;
	scr.databuf = (caddr_t)databuf;

	r = ioctl(fd, SCIOCCOMMAND, &scr);
	memcpy(&tmp, &databuf[12], sizeof(tmp));
	*nwa = betoh32(tmp);
	return (r == 0 ? scr.retsts : -1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: mmc.c,v 1.30 2015/01/16 06:40:06 deraadt Exp $ */
2			/*
3			* Copyright (c) 2006 Michael Coulter <mjc@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/limits.h>
19			#include <sys/types.h>
20			#include <sys/scsiio.h>
21			#include <sys/param.h> /* setbit, isset */
22			#include <scsi/cd.h>
23			#include <scsi/scsi_all.h>
24			#include <scsi/scsi_disk.h>
25			#include <err.h>
26			#include <errno.h>
27			#include <fcntl.h>
28			#include <stdio.h>
29			#include <string.h>
30			#include <unistd.h>
31			#include "extern.h"
32
33			extern int fd;
34			extern u_int8_t mediacap[];
35			extern char *cdname;
36			extern int verbose;
37
38			#define SCSI_GET_CONFIGURATION 0x46
39
40			#define MMC_FEATURE_HDR_LEN 8
41
42			static const struct {
43			u_int16_t id;
44			char *name;
45			} mmc_feature[] = {
46			{ 0x0000, "Profile List" },
47			{ 0x0001, "Core" },
48			{ 0x0002, "Morphing" },
49			{ 0x0003, "Removable Medium" },
50			{ 0x0004, "Write Protect" },
51			{ 0x0010, "Random Readable" },
52			{ 0x001d, "Multi-Read" },
53			{ 0x001e, "CD Read" },
54			{ 0x001f, "DVD Read" },
55			{ 0x0020, "Random Writable" },
56			{ 0x0021, "Incremental Streaming Writable" },
57			{ 0x0022, "Sector Erasable" },
58			{ 0x0023, "Formattable" },
59			{ 0x0024, "Hardware Defect Management" },
60			{ 0x0025, "Write Once" },
61			{ 0x0026, "Restricted Overwrite" },
62			{ 0x0027, "CD-RW CAV Write" },
63			{ 0x0028, "MRW" },
64			{ 0x0029, "Enhanced Defect Reporting" },
65			{ 0x002a, "DVD+RW" },
66			{ 0x002b, "DVD+R" },
67			{ 0x002c, "Rigid Restricted Overwrite" },
68			{ 0x002d, "CD Track at Once (TAO)" },
69			{ 0x002e, "CD Mastering (Session at Once)" },
70			{ 0x002f, "DVD-RW Write" },
71			{ 0x0030, "DDCD-ROM (Legacy)" },
72			{ 0x0031, "DDCD-R (Legacy)" },
73			{ 0x0032, "DDCD-RW (Legacy)" },
74			{ 0x0033, "Layer Jump Recording" },
75			{ 0x0037, "CD-RW Media Write Support" },
76			{ 0x0038, "BD-R Pseudo-Overwrite (POW)" },
77			{ 0x003a, "DVD+RW Dual Layer" },
78			{ 0x003b, "DVD+R Dual Layer" },
79			{ 0x0040, "BD Read" },
80			{ 0x0041, "BD Write" },
81			{ 0x0042, "Timely Safe Recording (TSR)" },
82			{ 0x0050, "HD DVD Read" },
83			{ 0x0051, "HD DVD Write" },
84			{ 0x0080, "Hybrid Disc" },
85			{ 0x0100, "Power Management" },
86			{ 0x0101, "S.M.A.R.T." },
87			{ 0x0102, "Embedded Changer" },
88			{ 0x0103, "CD Audio External Play (Legacy)" },
89			{ 0x0104, "Microcode Upgrade" },
90			{ 0x0105, "Timeout" },
91			{ 0x0106, "DVD CSS" },
92			{ 0x0107, "Real Time Streaming" },
93			{ 0x0108, "Drive Serial Number" },
94			{ 0x0109, "Media Serial Number" },
95			{ 0x010a, "Disc Control Blocks (DCBs)" },
96			{ 0x010b, "DVD CPRM" },
97			{ 0x010c, "Firmware Information" },
98			{ 0x010d, "AACS" },
99			{ 0x0110, "VCPS" },
100			{ 0, NULL }
101			};
102
103			static const struct {
104			u_int16_t id;
105			char *name;
106			} mmc_profile[] = {
107			{ 0x0001, "Re-writable disk, capable of changing behaviour" },
108			{ 0x0002, "Re-writable, with removable media" },
109			{ 0x0003, "Magneto-Optical disk with sector erase capability" },
110			{ 0x0004, "Optical write once" },
111			{ 0x0005, "Advance Storage -- Magneto-Optical" },
112			{ 0x0008, "Read only Compact Disc" },
113			{ 0x0009, "Write once Compact Disc" },
114			{ 0x000a, "Re-writable Compact Disc" },
115			{ 0x0010, "Read only DVD" },
116			{ 0x0011, "Write once DVD using Sequential recording" },
117			{ 0x0012, "Re-writable DVD" },
118			{ 0x0013, "Re-recordable DVD using Restricted Overwrite" },
119			{ 0x0014, "Re-recordable DVD using Sequential recording" },
120			{ 0x0015, "Dual Layer DVD-R using Sequential recording" },
121			{ 0x0016, "Dual Layer DVD-R using Layer Jump recording" },
122			{ 0x001a, "DVD+ReWritable" },
123			{ 0x001b, "DVD+Recordable" },
124			{ 0x0020, "DDCD-ROM" },
125			{ 0x0021, "DDCD-R" },
126			{ 0x0022, "DDCD-RW" },
127			{ 0x002a, "DVD+Rewritable Dual Layer" },
128			{ 0x002b, "DVD+Recordable Dual Layer" },
129			{ 0x003e, "Blu-ray Disc ROM" },
130			{ 0x003f, "Blu-ray Disc Recordable -- Sequential Recording Mode" },
131			{ 0x0040, "Blu-ray Disc Recordable -- Random Recording Mode" },
132			{ 0x0041, "Blu-ray Disc Rewritable" },
133			{ 0x004e, "Read-only HD DVD" },
134			{ 0x004f, "Write-once HD DVD" },
135			{ 0x0050, "Rewritable HD DVD" },
136			{ 0, NULL }
137			};
138
139			int
140			get_media_type(void)
141			{
142			scsireq_t scr;
143			char buf[32];
144			u_char disctype;
145			int rv, error;
146
147			rv = MEDIATYPE_UNKNOWN;
148			memset(buf, 0, sizeof(buf));
149			memset(&scr, 0, sizeof(scr));
150
151			scr.cmd[0] = READ_TOC;
152			scr.cmd[1] = 0x2; /* MSF */
153			scr.cmd[2] = 0x4; /* ATIP */
154			scr.cmd[8] = 0x20;
155
156			scr.flags = SCCMD_ESCAPE \| SCCMD_READ;
157			scr.databuf = buf;
158			scr.datalen = sizeof(buf);
159			scr.cmdlen = 10;
160			scr.timeout = 120000;
161			scr.senselen = SENSEBUFLEN;
162
163			error = ioctl(fd, SCIOCCOMMAND, &scr);
164			if (error != -1 && scr.retsts == SCCMD_OK && scr.datalen_used > 7) {
165			disctype = (buf[6] >> 6) & 0x1;
166			if (disctype == 0)
167			rv = MEDIATYPE_CDR;
168			else if (disctype == 1)
169			rv = MEDIATYPE_CDRW;
170			}
171
172			return (rv);
173			}
174
175			int
176			get_media_capabilities(u_int8_t *cap, int rt)
177			{
178			scsireq_t scr;
179			u_char buf[4096];
180			u_int32_t i, dlen;
181			u_int16_t feature, profile, tmp;
182			u_int8_t feature_len;
183			int current, error, j, k;
184
185			memset(cap, 0, MMC_FEATURE_MAX / NBBY);
186			memset(buf, 0, sizeof(buf));
187			memset(&scr, 0, sizeof(scr));
188
189			scr.cmd[0] = SCSI_GET_CONFIGURATION;
190			scr.cmd[1] = rt;
191			tmp = htobe16(sizeof(buf));
192			memcpy(scr.cmd + 7, &tmp, sizeof(u_int16_t));
193
194			scr.flags = SCCMD_ESCAPE \| SCCMD_READ;
195			scr.databuf = buf;
196			scr.datalen = sizeof(buf);
197			scr.cmdlen = 10;
198			scr.timeout = 120000;
199			scr.senselen = SENSEBUFLEN;
200
201			error = ioctl(fd, SCIOCCOMMAND, &scr);
202			if (error == -1 \|\| scr.retsts != SCCMD_OK)
203			return (-1);
204			if (scr.datalen_used < MMC_FEATURE_HDR_LEN)
205			return (-1); /* Can't get the header. */
206
207			/* Include the whole header in the length. */
208			dlen = betoh32((u_int32_t )buf) + 4;
209			if (dlen > scr.datalen_used)
210			dlen = scr.datalen_used;
211
212			if (verbose > 1)
213			printf("Features:\n");
214			for (i = MMC_FEATURE_HDR_LEN; i + 3 < dlen; i += feature_len) {
215			feature_len = buf[i + 3] + 4;
216			if (feature_len + i > dlen)
217			break;
218
219			feature = betoh16((u_int16_t )(buf + i));
220			if (feature >= MMC_FEATURE_MAX)
221			break;
222
223			if (verbose > 1) {
224			printf("0x%04x", feature);
225			for (j = 0; mmc_feature[j].name != NULL; j++)
226			if (feature == mmc_feature[j].id)
227			break;
228			if (mmc_feature[j].name == NULL)
229			printf(" <Undocumented>");
230			else
231			printf(" %s", mmc_feature[j].name);
232			if (feature_len > 4)
233			printf(" (%d bytes of data)", feature_len - 4);
234			printf("\n");
235			if (verbose > 2) {
236			printf(" ");
237			for (j = i; j < i + feature_len; j++) {
238			printf("%02x", buf[j]);
239			if ((j + 1) == (i + feature_len))
240			printf("\n");
241			else if ((j > i) && ((j - i + 1) % 16
242			== 0))
243			printf("\n ");
244			else if ((j - i) == 3)
245			printf("\|");
246			else
247			printf(" ");
248			}
249			}
250			}
251			if (feature == 0 && verbose > 1) {
252			if (verbose > 2)
253			printf(" Profiles:\n");
254			for (j = i + 4; j < i + feature_len; j += 4) {
255			profile = betoh16((u_int16_t )(buf+j));
256			current = buf[j+2] == 1;
257			if (verbose < 3 && !current)
258			continue;
259			if (current)
260			printf(" * ");
261			else
262			printf(" ");
263			printf("0x%04x", profile);
264			for (k = 0; mmc_profile[k].name != NULL; k++)
265			if (profile == mmc_profile[k].id)
266			break;
267			if (mmc_profile[k].name == NULL)
268			printf(" <Undocumented>");
269			else
270			printf(" %s", mmc_profile[k].name);
271			printf(" %s\n", current ? "[Current Profile]" :
272			"" );
273			}
274			}
275			setbit(cap, feature);
276			}
277
278			return (0);
279			}
280
281			static int
282			set_speed(int wspeed)
283			{
284			scsireq_t scr;
285			int r;
286
287			memset(&scr, 0, sizeof(scr));
288			scr.cmd[0] = SET_CD_SPEED;
289			scr.cmd[1] = (isset(mediacap, MMC_FEATURE_CDRW_CAV)) != 0;
290			(u_int16_t )(scr.cmd + 2) = htobe16(DRIVE_SPEED_OPTIMAL);
291			(u_int16_t )(scr.cmd + 4) = htobe16(wspeed);
292
293			scr.cmdlen = 12;
294			scr.datalen = 0;
295			scr.timeout = 120000;
296			scr.flags = SCCMD_ESCAPE;
297			scr.senselen = SENSEBUFLEN;
298
299			r = ioctl(fd, SCIOCCOMMAND, &scr);
300			return (r == 0 ? scr.retsts : -1);
301			}
302
303			int
304			blank(void)
305			{
306			struct scsi_blank *scb;
307			scsireq_t scr;
308			int r;
309
310			bzero(&scr, sizeof(scr));
311			scb = (struct scsi_blank *)scr.cmd;
312			scb->opcode = BLANK;
313			scb->byte2 \|= BLANK_MINIMAL;
314			scr.cmdlen = sizeof(*scb);
315			scr.datalen = 0;
316			scr.timeout = 120000;
317			scr.flags = SCCMD_ESCAPE;
318			scr.senselen = SENSEBUFLEN;
319
320			r = ioctl(fd, SCIOCCOMMAND, &scr);
321			return (r == 0 ? scr.retsts : -1);
322			}
323
324			int
325			unit_ready(void)
326			{
327			struct scsi_test_unit_ready *scb;
328			scsireq_t scr;
329			int r;
330
331			bzero(&scr, sizeof(scr));
332			scb = (struct scsi_test_unit_ready *)scr.cmd;
333			scb->opcode = TEST_UNIT_READY;
334			scr.cmdlen = sizeof(*scb);
335			scr.datalen = 0;
336			scr.timeout = 120000;
337			scr.flags = SCCMD_ESCAPE;
338			scr.senselen = SENSEBUFLEN;
339
340			r = ioctl(fd, SCIOCCOMMAND, &scr);
341			return (r == 0 ? scr.retsts : -1);
342			}
343
344			int
345			synchronize_cache(void)
346			{
347			struct scsi_synchronize_cache *scb;
348			scsireq_t scr;
349			int r;
350
351			bzero(&scr, sizeof(scr));
352			scb = (struct scsi_synchronize_cache *)scr.cmd;
353			scb->opcode = SYNCHRONIZE_CACHE;
354			scr.cmdlen = sizeof(*scb);
355			scr.datalen = 0;
356			scr.timeout = 120000;
357			scr.flags = SCCMD_ESCAPE;
358			scr.senselen = SENSEBUFLEN;
359
360			r = ioctl(fd, SCIOCCOMMAND, &scr);
361			return (r == 0 ? scr.retsts : -1);
362			}
363
364			int
365			close_session(void)
366			{
367			struct scsi_close_track *scb;
368			scsireq_t scr;
369			int r;
370
371			bzero(&scr, sizeof(scr));
372			scb = (struct scsi_close_track *)scr.cmd;
373			scb->opcode = CLOSE_TRACK;
374			scb->closefunc = CT_CLOSE_SESS;
375			scr.cmdlen = sizeof(*scb);
376			scr.datalen = 0;
377			scr.timeout = 120000;
378			scr.flags = SCCMD_ESCAPE;
379			scr.senselen = SENSEBUFLEN;
380
381			r = ioctl(fd, SCIOCCOMMAND, &scr);
382			return (r == 0 ? scr.retsts : -1);
383			}
384
385			int
386			writetao(struct track_head *thp)
387			{
388			u_char modebuf[70], bdlen;
389			struct track_info *tr;
390			int r, track = 0;
391
392			if ((r = mode_sense_write(modebuf)) != SCCMD_OK) {
393			warnx("mode sense failed: %d", r);
394			return (r);
395			}
396			bdlen = modebuf[7];
397			modebuf[2+8+bdlen] \|= 0x40; /* Buffer Underrun Free Enable */
398			modebuf[2+8+bdlen] \|= 0x01; /* change write type to TAO */
399
400			SLIST_FOREACH(tr, thp, track_list) {
401			track++;
402			switch (tr->type) {
403			case 'd':
404			modebuf[3+8+bdlen] = 0x04; /* track mode = data */
405			modebuf[4+8+bdlen] = 0x08; /* 2048 block track mode */
406			modebuf[8+8+bdlen] = 0x00; /* turn off XA */
407			break;
408			case 'a':
409			modebuf[3+8+bdlen] = 0x00; /* track mode = audio */
410			modebuf[4+8+bdlen] = 0x00; /* 2352 block track mode */
411			modebuf[8+8+bdlen] = 0x00; /* turn off XA */
412			break;
413			default:
414			warn("impossible tracktype detected");
415			break;
416			}
417			while (unit_ready() != SCCMD_OK)
418			continue;
419			if ((r = mode_select_write(modebuf)) != SCCMD_OK) {
420			warnx("mode select failed: %d", r);
421			return (r);
422			}
423
424			set_speed(tr->speed);
425			writetrack(tr, track);
426			synchronize_cache();
427			}
428			fprintf(stderr, "Closing session.\n");
429			close_session();
430			return (0);
431			}
432
433			int
434			writetrack(struct track_info *tr, int track)
435			{
436			struct timeval tv, otv, atv;
437			u_char databuf[65536], nblk;
438			u_int end_lba, lba, tmp;
439			scsireq_t scr;
440			int r;
441
442			nblk = 65535/tr->blklen;
443			bzero(&scr, sizeof(scr));
444			scr.timeout = 300000;
445			scr.cmd[0] = WRITE_BIG;
446			scr.cmd[1] = 0x00;
447			scr.cmd[8] = nblk; /* Transfer length in blocks (LSB) */
448			scr.cmdlen = 10;
449			scr.databuf = (caddr_t)databuf;
450			scr.datalen = nblk * tr->blklen;
451			scr.senselen = SENSEBUFLEN;
452			scr.flags = SCCMD_ESCAPE\|SCCMD_WRITE;
453
454			timerclear(&otv);
455			atv.tv_sec = 1;
456			atv.tv_usec = 0;
457
458			if (get_nwa(&lba) != SCCMD_OK) {
459			warnx("cannot get next writable address");
460			return (-1);
461			}
462			tmp = htobe32(lba); /* update lba in cdb */
463			memcpy(&scr.cmd[2], &tmp, sizeof(tmp));
464
465			if (tr->sz / tr->blklen + 1 > UINT_MAX \|\| tr->sz < tr->blklen) {
466			warnx("file %s has invalid size", tr->file);
467			return (-1);
468			}
469			if (tr->sz % tr->blklen) {
470			warnx("file %s is not multiple of block length %d",
471			tr->file, tr->blklen);
472			end_lba = tr->sz / tr->blklen + lba + 1;
473			} else {
474			end_lba = tr->sz / tr->blklen + lba;
475			}
476			if (lseek(tr->fd, tr->off, SEEK_SET) == -1)
477			err(1, "seek failed for file %s", tr->file);
478			while (lba < end_lba && nblk != 0) {
479			while (lba + nblk <= end_lba) {
480			read(tr->fd, databuf, nblk * tr->blklen);
481			scr.cmd[8] = nblk;
482			scr.datalen = nblk * tr->blklen;
483			again:
484			r = ioctl(fd, SCIOCCOMMAND, &scr);
485			if (r != 0) {
486			printf("\r%60s", "");
487			warn("ioctl failed while attempting to write");
488			return (-1);
489			}
490			if (scr.retsts == SCCMD_SENSE && scr.sense[2] == 0x2) {
491			usleep(1000);
492			goto again;
493			}
494			if (scr.retsts != SCCMD_OK) {
495			printf("\r%60s", "");
496			warnx("ioctl returned bad status while "
497			"attempting to write: %d",
498			scr.retsts);
499			return (r);
500			}
501			lba += nblk;
502
503			gettimeofday(&tv, NULL);
504			if (lba == end_lba \|\| timercmp(&tv, &otv, >)) {
505			fprintf(stderr,
506			"\rtrack %02d '%c' %08u/%08u %3d%%",
507			track, tr->type,
508			lba, end_lba, 100 * lba / end_lba);
509			timeradd(&tv, &atv, &otv);
510			}
511			tmp = htobe32(lba); /* update lba in cdb */
512			memcpy(&scr.cmd[2], &tmp, sizeof(tmp));
513			}
514			nblk--;
515			}
516			printf("\n");
517			close(tr->fd);
518			return (0);
519			}
520
521			int
522			mode_sense_write(unsigned char buf[])
523			{
524			struct scsi_mode_sense_big *scb;
525			scsireq_t scr;
526			int r;
527
528			bzero(&scr, sizeof(scr));
529			scb = (struct scsi_mode_sense_big *)scr.cmd;
530			scb->opcode = MODE_SENSE_BIG;
531			/* XXX: need to set disable block descriptors and check SCSI drive */
532			scb->page = WRITE_PARAM_PAGE;
533			scb->length[1] = 0x46; /* 16 for the header + size from pg. 89 mmc-r10a.pdf */
534			scr.cmdlen = sizeof(*scb);
535			scr.timeout = 4000;
536			scr.senselen = SENSEBUFLEN;
537			scr.datalen= 0x46;
538			scr.flags = SCCMD_ESCAPE\|SCCMD_READ;
539			scr.databuf = (caddr_t)buf;
540
541			r = ioctl(fd, SCIOCCOMMAND, &scr);
542			return (r == 0 ? scr.retsts : -1);
543			}
544
545			int
546			mode_select_write(unsigned char buf[])
547			{
548			struct scsi_mode_select_big *scb;
549			scsireq_t scr;
550			int r;
551
552			bzero(&scr, sizeof(scr));
553			scb = (struct scsi_mode_select_big *)scr.cmd;
554			scb->opcode = MODE_SELECT_BIG;
555
556			/*
557			* INF-8020 says bit 4 in byte 2 is '1'
558			* INF-8090 refers to it as 'PF(1)' then doesn't
559			* describe it.
560			*/
561			scb->byte2 = 0x10;
562			scb->length[1] = 2 + buf[1] + 256 * buf[0];
563			scr.timeout = 4000;
564			scr.senselen = SENSEBUFLEN;
565			scr.cmdlen = sizeof(*scb);
566			scr.datalen = 2 + buf[1] + 256 * buf[0];
567			scr.flags = SCCMD_ESCAPE\|SCCMD_WRITE;
568			scr.databuf = (caddr_t)buf;
569
570			r = ioctl(fd, SCIOCCOMMAND, &scr);
571			return (r == 0 ? scr.retsts : -1);
572			}
573
574			int
575			get_disc_size(off_t *availblk)
576			{
577			u_char databuf[28];
578			struct scsi_read_track_info *scb;
579			scsireq_t scr;
580			int r, tmp;
581
582			bzero(&scr, sizeof(scr));
583			scb = (struct scsi_read_track_info *)scr.cmd;
584			scr.timeout = 4000;
585			scr.senselen = SENSEBUFLEN;
586			scb->opcode = READ_TRACK_INFO;
587			scb->addrtype = RTI_TRACK;
588			scb->addr[3] = 1;
589			scb->data_len[1] = 0x1c;
590			scr.cmdlen = sizeof(*scb);
591			scr.datalen= 0x1c;
592			scr.flags = SCCMD_ESCAPE\|SCCMD_READ;
593			scr.databuf = (caddr_t)databuf;
594
595			r = ioctl(fd, SCIOCCOMMAND, &scr);
596			memcpy(&tmp, &databuf[16], sizeof(tmp));
597			*availblk = betoh32(tmp);
598			return (r == 0 ? scr.retsts : -1);
599			}
600
601			int
602			get_nwa(int *nwa)
603			{
604			u_char databuf[28];
605			scsireq_t scr;
606			int r, tmp;
607
608			bzero(&scr, sizeof(scr));
609			scr.timeout = 4000;
610			scr.senselen = SENSEBUFLEN;
611			scr.cmd[0] = READ_TRACK_INFO;
612			scr.cmd[1] = 0x01;
613			scr.cmd[5] = 0xff; /* Invisible Track */
614			scr.cmd[7] = 0x00;
615			scr.cmd[8] = 0x1c;
616			scr.cmdlen = 10;
617			scr.datalen= 0x1c;
618			scr.flags = SCCMD_ESCAPE\|SCCMD_READ;
619			scr.databuf = (caddr_t)databuf;
620
621			r = ioctl(fd, SCIOCCOMMAND, &scr);
622			memcpy(&tmp, &databuf[12], sizeof(tmp));
623			*nwa = betoh32(tmp);
624			return (r == 0 ? scr.retsts : -1);
625			}