1/*	$NetBSD: cd.c,v 1.355 2024/06/22 10:07:46 palle Exp $	*/
2
3/*-
4 * Copyright (c) 1998, 2001, 2003, 2004, 2005, 2008 The NetBSD Foundation,
5 * Inc.  All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum.
9 *
10 * MMC framework implemented and contributed to the NetBSD Foundation by
11 * Reinoud Zandijk.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*
36 * Originally written by Julian Elischer (julian@tfs.com)
37 * for TRW Financial Systems for use under the MACH(2.5) operating system.
38 *
39 * TRW Financial Systems, in accordance with their agreement with Carnegie
40 * Mellon University, makes this software available to CMU to distribute
41 * or use in any manner that they see fit as long as this message is kept with
42 * the software. For this reason TFS also grants any other persons or
43 * organisations permission to use or modify this software.
44 *
45 * TFS supplies this software to be publicly redistributed
46 * on the understanding that TFS is not responsible for the correct
47 * functioning of this software in any circumstances.
48 *
49 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
50 */
51
52#include <sys/cdefs.h>
53__KERNEL_RCSID(0, "$NetBSD: cd.c,v 1.355 2024/06/22 10:07:46 palle Exp $");
54
55#include <sys/param.h>
56#include <sys/systm.h>
57#include <sys/kernel.h>
58#include <sys/file.h>
59#include <sys/stat.h>
60#include <sys/ioctl.h>
61#include <sys/buf.h>
62#include <sys/bufq.h>
63#include <sys/uio.h>
64#include <sys/malloc.h>
65#include <sys/errno.h>
66#include <sys/device.h>
67#include <sys/disklabel.h>
68#include <sys/disk.h>
69#include <sys/cdio.h>
70#include <sys/dvdio.h>
71#include <sys/scsiio.h>
72#include <sys/proc.h>
73#include <sys/conf.h>
74#include <sys/vnode.h>
75#include <sys/rndsource.h>
76
77#include <dev/scsipi/scsi_spc.h>
78#include <dev/scsipi/scsipi_all.h>
79#include <dev/scsipi/scsipi_cd.h>
80#include <dev/scsipi/scsipi_disk.h>	/* rw_big and start_stop come */
81#include <dev/scsipi/scsi_all.h>
82					/* from there */
83#include <dev/scsipi/scsi_disk.h>	/* rw comes from there */
84#include <dev/scsipi/scsipiconf.h>
85#include <dev/scsipi/scsipi_base.h>
86#include <dev/scsipi/cdvar.h>
87
88#include <prop/proplib.h>
89
90#define	CDUNIT(z)			DISKUNIT(z)
91#define	CDPART(z)			DISKPART(z)
92#define	CDMINOR(unit, part)		DISKMINOR(unit, part)
93#define	MAKECDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)
94
95#define MAXTRACK	99
96#define CD_BLOCK_OFFSET	150
97#define CD_FRAMES	75
98#define CD_SECS		60
99
100#define CD_TOC_FORM	0	/* formatted TOC, exposed to userland     */
101#define CD_TOC_MSINFO	1	/* multi-session info			  */
102#define CD_TOC_RAW	2	/* raw TOC as on disc, unprocessed	  */
103#define CD_TOC_PMA	3	/* PMA, used as intermediate (rare use)   */
104#define CD_TOC_ATIP	4	/* pressed space of recordable		  */
105#define CD_TOC_CDTEXT	5	/* special CD-TEXT, rarely used		  */
106
107#define P5LEN	0x32
108#define MS5LEN	(P5LEN + 8 + 2)
109
110struct cd_formatted_toc {
111	struct ioc_toc_header header;
112	struct cd_toc_entry entries[MAXTRACK+1]; /* One extra for the */
113						 /* leadout */
114};
115
116struct cdbounce {
117	struct buf *obp;	/* original buf */
118	struct buf *lbp;	/* first buffer */
119	struct buf *rbp;	/* second buffer */
120	int lerr;		/* error returned for first buffer */
121	int rerr;		/* error returned for second buffer */
122	int head;		/* bytes skipped at the start */
123	int lcount;		/* bytes copied to first buffer */
124	int rcount;		/* bytes copied to second buffer */
125};
126
127static void	cdstart(struct scsipi_periph *);
128static void	cdrestart(void *);
129static void	cdminphys(struct buf *);
130static void	cddone(struct scsipi_xfer *, int);
131static int	cd_interpret_sense(struct scsipi_xfer *);
132static int	cd_diskstart(device_t, struct buf *);
133static void	cd_iosize(device_t, int *);
134static int	cd_lastclose(device_t);
135static int      cd_firstopen(device_t, dev_t, int, int);
136static void	cd_label(device_t, struct disklabel *);
137static u_long	cd_size(struct cd_softc *, int);
138static int	cd_play(struct cd_softc *, int, int);
139static int	cd_play_tracks(struct cd_softc *, struct cd_formatted_toc *,
140		    int, int, int, int);
141static int	cd_play_msf(struct cd_softc *, int, int, int, int, int, int);
142static int	cd_pause(struct cd_softc *, int);
143static int	cd_reset(struct cd_softc *);
144static int	cd_read_subchannel(struct cd_softc *, int, int, int,
145		    struct cd_sub_channel_info *, int, int);
146static int	cd_read_toc(struct cd_softc *, int, int, int,
147		    struct cd_formatted_toc *, int, int, int);
148static int	cd_get_parms(struct cd_softc *, int);
149static int	cd_load_toc(struct cd_softc *, int, struct cd_formatted_toc *, int);
150static int	cdreadmsaddr(struct cd_softc *, struct cd_formatted_toc *,int *);
151static int	cdcachesync(struct scsipi_periph *periph, int flags);
152
153static int	dvd_auth(struct cd_softc *, dvd_authinfo *);
154static int	dvd_read_physical(struct cd_softc *, dvd_struct *);
155static int	dvd_read_copyright(struct cd_softc *, dvd_struct *);
156static int	dvd_read_disckey(struct cd_softc *, dvd_struct *);
157static int	dvd_read_bca(struct cd_softc *, dvd_struct *);
158static int	dvd_read_manufact(struct cd_softc *, dvd_struct *);
159static int	dvd_read_struct(struct cd_softc *, dvd_struct *);
160
161static int	cd_mode_sense(struct cd_softc *, u_int8_t, void *, size_t, int,
162		    int, int *);
163static int	cd_mode_select(struct cd_softc *, u_int8_t, void *, size_t,
164		    int, int);
165static int	cd_setchan(struct cd_softc *, int, int, int, int, int);
166static int	cd_getvol(struct cd_softc *, struct ioc_vol *, int);
167static int	cd_setvol(struct cd_softc *, const struct ioc_vol *, int);
168static int	cd_set_pa_immed(struct cd_softc *, int);
169static int	cd_load_unload(struct cd_softc *, struct ioc_load_unload *);
170static int	cd_setblksize(struct cd_softc *);
171
172static int	cdmatch(device_t, cfdata_t, void *);
173static void	cdattach(device_t, device_t, void *);
174static int	cddetach(device_t, int);
175
176static int	mmc_getdiscinfo(struct scsipi_periph *, struct mmc_discinfo *);
177static int	mmc_gettrackinfo(struct scsipi_periph *, struct mmc_trackinfo *);
178static int	mmc_do_op(struct scsipi_periph *, struct mmc_op *);
179static int	mmc_setup_writeparams(struct scsipi_periph *, struct mmc_writeparams *);
180
181static void	cd_set_geometry(struct cd_softc *);
182
183CFATTACH_DECL3_NEW(cd, sizeof(struct cd_softc), cdmatch, cdattach, cddetach,
184    NULL, NULL, NULL, DVF_DETACH_SHUTDOWN);
185
186extern struct cfdriver cd_cd;
187
188static const struct scsipi_inquiry_pattern cd_patterns[] = {
189	{T_CDROM, T_REMOV,
190	 "",         "",                 ""},
191	{T_WORM, T_REMOV,
192	 "",         "",                 ""},
193#if 0
194	{T_CDROM, T_REMOV, /* more luns */
195	 "PIONEER ", "CD-ROM DRM-600  ", ""},
196#endif
197	{T_DIRECT, T_REMOV,
198	 "NEC                 CD-ROM DRIVE:260", "", ""},
199};
200
201static dev_type_open(cdopen);
202static dev_type_close(cdclose);
203static dev_type_read(cdread);
204static dev_type_write(cdwrite);
205static dev_type_ioctl(cdioctl);
206static dev_type_strategy(cdstrategy);
207static dev_type_dump(cddump);
208static dev_type_size(cdsize);
209
210const struct bdevsw cd_bdevsw = {
211	.d_open = cdopen,
212	.d_close = cdclose,
213	.d_strategy = cdstrategy,
214	.d_ioctl = cdioctl,
215	.d_dump = cddump,
216	.d_psize = cdsize,
217	.d_discard = nodiscard,
218	.d_flag = D_DISK | D_MPSAFE
219};
220
221const struct cdevsw cd_cdevsw = {
222	.d_open = cdopen,
223	.d_close = cdclose,
224	.d_read = cdread,
225	.d_write = cdwrite,
226	.d_ioctl = cdioctl,
227	.d_stop = nostop,
228	.d_tty = notty,
229	.d_poll = nopoll,
230	.d_mmap = nommap,
231	.d_kqfilter = nokqfilter,
232	.d_discard = nodiscard,
233	.d_flag = D_DISK | D_MPSAFE
234};
235
236static const struct dkdriver cddkdriver = {
237	.d_open = cdopen,
238	.d_close = cdclose,
239	.d_strategy = cdstrategy,
240	.d_minphys = cdminphys,
241	.d_diskstart = cd_diskstart,
242	.d_firstopen = cd_firstopen,
243	.d_lastclose = cd_lastclose,
244	.d_label = cd_label,
245};
246
247static const struct scsipi_periphsw cd_switch = {
248	cd_interpret_sense,	/* use our error handler first */
249	cdstart,		/* we have a queue, which is started by this */
250	NULL,			/* we do not have an async handler */
251	cddone,			/* deal with stats at interrupt time */
252};
253
254/*
255 * The routine called by the low level scsi routine when it discovers
256 * A device suitable for this driver
257 */
258static int
259cdmatch(device_t parent, cfdata_t match, void *aux)
260{
261	struct scsipibus_attach_args *sa = aux;
262	int priority;
263
264	(void)scsipi_inqmatch(&sa->sa_inqbuf,
265	    cd_patterns, sizeof(cd_patterns) / sizeof(cd_patterns[0]),
266	    sizeof(cd_patterns[0]), &priority);
267
268	return (priority);
269}
270
271static void
272cdattach(device_t parent, device_t self, void *aux)
273{
274	struct cd_softc *cd = device_private(self);
275	struct dk_softc *dksc = &cd->sc_dksc;
276	struct scsipibus_attach_args *sa = aux;
277	struct scsipi_periph *periph = sa->sa_periph;
278	int dtype;
279
280	SC_DEBUG(periph, SCSIPI_DB2, ("cdattach: "));
281
282	switch (SCSIPI_BUSTYPE_TYPE(scsipi_periph_bustype(sa->sa_periph))) {
283	case SCSIPI_BUSTYPE_SCSI:
284		dtype = DKTYPE_SCSI;
285		if (periph->periph_version == 0)
286			cd->flags |= CDF_ANCIENT;
287		break;
288	case SCSIPI_BUSTYPE_ATAPI:
289		dtype = DKTYPE_ATAPI;
290		break;
291	default:
292		dtype = DKTYPE_UNKNOWN;
293		break;
294	}
295
296	/*
297	 * Initialize and attach the disk structure.
298	 */
299	dk_init(dksc, self, dtype);
300	disk_init(&dksc->sc_dkdev, dksc->sc_xname, &cddkdriver);
301
302	dk_attach(dksc);
303	disk_attach(&dksc->sc_dkdev);
304
305	bufq_alloc(&dksc->sc_bufq, "disksort", BUFQ_SORT_RAWBLOCK);
306
307	callout_init(&cd->sc_callout, 0);
308
309	/*
310	 * Store information needed to contact our base driver
311	 */
312	cd->sc_periph = periph;
313
314	periph->periph_dev = dksc->sc_dev;
315	periph->periph_switch = &cd_switch;
316
317	/*
318	 * Increase our openings to the maximum-per-periph
319	 * supported by the adapter.  This will either be
320	 * clamped down or grown by the adapter if necessary.
321	 */
322	periph->periph_openings =
323	    SCSIPI_CHAN_MAX_PERIPH(periph->periph_channel);
324	periph->periph_flags |= PERIPH_GROW_OPENINGS;
325
326	aprint_naive("\n");
327	aprint_normal("\n");
328
329	if (!pmf_device_register(self, NULL, NULL))
330		aprint_error_dev(self, "couldn't establish power handler\n");
331}
332
333static int
334cddetach(device_t self, int flags)
335{
336	struct cd_softc *cd = device_private(self);
337	struct dk_softc *dksc = &cd->sc_dksc;
338	struct scsipi_periph *periph = cd->sc_periph;
339	struct scsipi_channel *chan = periph->periph_channel;
340	int bmaj, cmaj, i, mn, rc;
341
342	if ((rc = disk_begindetach(&dksc->sc_dkdev, cd_lastclose, self, flags)) != 0)
343		return rc;
344
345	/* locate the major number */
346	bmaj = bdevsw_lookup_major(&cd_bdevsw);
347	cmaj = cdevsw_lookup_major(&cd_cdevsw);
348
349	/* Nuke the vnodes for any open instances */
350	for (i = 0; i < MAXPARTITIONS; i++) {
351		mn = CDMINOR(device_unit(self), i);
352		vdevgone(bmaj, mn, mn, VBLK);
353		vdevgone(cmaj, mn, mn, VCHR);
354	}
355
356	/* kill any pending restart */
357	callout_halt(&cd->sc_callout, NULL);
358
359	dk_drain(dksc);
360
361	/* Kill off any pending commands. */
362	mutex_enter(chan_mtx(chan));
363	scsipi_kill_pending(cd->sc_periph);
364	mutex_exit(chan_mtx(chan));
365
366	bufq_free(dksc->sc_bufq);
367
368	/* Detach from the disk list. */
369	disk_detach(&dksc->sc_dkdev);
370	disk_destroy(&dksc->sc_dkdev);
371
372	dk_detach(dksc);
373
374	callout_destroy(&cd->sc_callout);
375
376	pmf_device_deregister(self);
377
378	return (0);
379}
380
381/*
382 * Serialized by caller
383 */
384static int
385cd_firstopen(device_t self, dev_t dev, int flag, int fmt)
386{
387        struct cd_softc *cd = device_private(self);
388        struct scsipi_periph *periph = cd->sc_periph;
389        struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
390        int error, silent;
391        int part;
392
393	part = CDPART(dev);
394
395        error = scsipi_adapter_addref(adapt);
396        if (error)
397                return error;
398
399        if ((part == RAW_PART && fmt == S_IFCHR) || (flag & FSILENT))
400                silent = XS_CTL_SILENT;
401        else
402                silent = 0;
403
404	/* make cdclose() silent */
405	cd->flags |= CDF_EJECTED;
406
407	/* Check that it is still responding and ok. */
408	error = scsipi_test_unit_ready(periph,
409	    XS_CTL_IGNORE_ILLEGAL_REQUEST | XS_CTL_IGNORE_MEDIA_CHANGE |
410	    XS_CTL_SILENT);
411
412	/*
413	 * Start the pack spinning if necessary. Always allow the
414	 * raw partition to be opened, for raw IOCTLs. Data transfers
415	 * will check for SDEV_MEDIA_LOADED.
416	 */
417	if (error == EIO) {
418		error = scsipi_start(periph, SSS_START, silent);
419		if (error == EINVAL)
420			error = EIO;
421	}
422	if (error) {
423		if (part == RAW_PART)
424			goto out;
425		goto bad;
426	}
427
428	/* Lock the pack in. */
429	error = scsipi_prevent(periph, SPAMR_PREVENT_DT,
430	    XS_CTL_IGNORE_ILLEGAL_REQUEST |
431	    XS_CTL_IGNORE_MEDIA_CHANGE);
432	SC_DEBUG(periph, SCSIPI_DB1,
433	    ("cdopen: scsipi_prevent, error=%d\n", error));
434	if (error) {
435		if (part == RAW_PART)
436			goto out;
437		goto bad;
438	}
439
440	if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0) {
441		int param_error;
442
443		/* Load the physical device parameters. */
444		param_error = cd_get_parms(cd, 0);
445		if (param_error == CDGP_RESULT_OFFLINE) {
446			error = ENXIO;
447			goto bad2;
448		}
449		periph->periph_flags |= PERIPH_MEDIA_LOADED;
450
451		SC_DEBUG(periph, SCSIPI_DB3, ("Params loaded "));
452
453		cd_set_geometry(cd);
454
455		/* make cdclose() loud again */
456		cd->flags &= ~CDF_EJECTED;
457	}
458
459	periph->periph_flags |= PERIPH_OPEN;
460
461out:
462	return 0;
463
464bad2:
465	scsipi_prevent(periph, SPAMR_ALLOW,
466	    XS_CTL_IGNORE_ILLEGAL_REQUEST |
467	    XS_CTL_IGNORE_MEDIA_CHANGE |
468	    XS_CTL_SILENT);
469
470bad:
471	scsipi_adapter_delref(adapt);
472	return error;
473}
474
475/*
476 * open the device. Make sure the partition info is a up-to-date as can be.
477 */
478static int
479cdopen(dev_t dev, int flag, int fmt, struct lwp *l)
480{
481	struct cd_softc *cd;
482	struct dk_softc *dksc;
483	struct scsipi_periph *periph;
484	int unit, part;
485	int error;
486
487	unit = CDUNIT(dev);
488	cd = device_lookup_private(&cd_cd, unit);
489	if (cd == NULL)
490		return (ENXIO);
491	dksc = &cd->sc_dksc;
492
493	periph = cd->sc_periph;
494	part = CDPART(dev);
495
496	SC_DEBUG(periph, SCSIPI_DB1,
497	    ("cdopen: dev=0x%"PRIu64" (unit %"PRIu32" (of %d), partition %d)\n",
498	    dev, unit, cd_cd.cd_ndevs, CDPART(dev)));
499
500	/*
501	 * If any partition is open, but the disk has been invalidated,
502	 * disallow further opens of non-raw partition
503	 */
504	if ((periph->periph_flags & (PERIPH_OPEN | PERIPH_MEDIA_LOADED)) ==
505	    PERIPH_OPEN) {
506		if (part != RAW_PART || fmt != S_IFCHR)
507			return EIO;
508	}
509
510	error = dk_open(dksc, dev, flag, fmt, l);
511
512	SC_DEBUG(periph, SCSIPI_DB3, ("open complete\n"));
513
514	return error;
515}
516
517/*
518 * Serialized by caller
519 */
520static int
521cd_lastclose(device_t self)
522{
523	struct cd_softc *cd = device_private(self);
524	struct scsipi_periph *periph = cd->sc_periph;
525	struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
526	int silent;
527
528	if ((cd->flags & CDF_EJECTED) != 0 ||
529	    (periph->periph_flags & PERIPH_MEDIA_LOADED) == 0)
530		silent = XS_CTL_SILENT;
531	else
532		silent = 0;
533
534	cdcachesync(periph, silent);
535
536	scsipi_wait_drain(periph);
537
538	scsipi_prevent(periph, SPAMR_ALLOW,
539	    XS_CTL_IGNORE_ILLEGAL_REQUEST |
540	    XS_CTL_IGNORE_NOT_READY |
541	    XS_CTL_SILENT);
542	periph->periph_flags &= ~PERIPH_OPEN;
543
544	scsipi_wait_drain(periph);
545
546	scsipi_adapter_delref(adapt);
547
548	return 0;
549}
550
551/*
552 * close the device.. only called if we are the LAST
553 * occurrence of an open device
554 */
555static int
556cdclose(dev_t dev, int flag, int fmt, struct lwp *l)
557{
558	struct cd_softc *cd;
559	struct dk_softc *dksc;
560	int unit;
561
562	unit = CDUNIT(dev);
563	cd = device_lookup_private(&cd_cd, unit);
564	dksc = &cd->sc_dksc;
565
566	return dk_close(dksc, dev, flag, fmt, l);
567}
568
569static void
570cd_bounce_buffer_done(struct buf *bp)
571{
572	struct cdbounce *bounce = bp->b_private;
573	struct buf *obp = bounce->obp;
574
575	if (bp == bounce->lbp) {
576		if ((bounce->lerr = bp->b_error) == 0)
577			memcpy(obp->b_data, (char *)bp->b_data + bounce->head, bounce->lcount);
578		bounce->lbp = NULL;
579	}
580
581	if (bp == bounce->rbp) {
582		if ((bounce->rerr = bp->b_error) == 0)
583			memcpy((char *)obp->b_data + bounce->lcount, bp->b_data, bounce->rcount);
584		bounce->rbp = NULL;
585	}
586
587	free(bp->b_data, M_DEVBUF);
588	putiobuf(bp);
589
590	if (bounce->lbp != NULL || bounce->rbp != NULL)
591		return;
592
593	obp->b_error = bounce->rerr;
594	if (bounce->lerr)
595		obp->b_error = bounce->lerr;
596
597	obp->b_resid = 0;
598	if (obp->b_error)
599		obp->b_resid = obp->b_bcount;
600
601	free(bounce, M_DEVBUF);
602	biodone(obp);
603}
604
605static int
606cd_make_bounce_buffer(struct cd_softc *cd, struct buf *bp, daddr_t blkno, int count, struct buf **nbpp, void *priv)
607{
608	struct buf *nbp;
609
610	/* We don't support bouncing writes */
611	if ((bp->b_flags & B_READ) == 0)
612		return EACCES; /* XXX */
613
614	nbp = getiobuf(NULL, false);
615	if (nbp == NULL)
616		return ENOMEM;
617
618	nbp->b_data = malloc(count, M_DEVBUF, M_NOWAIT);
619	if (nbp->b_data == NULL) {
620		putiobuf(nbp);
621		return ENOMEM;
622	}
623
624	/* Set up the IOP to the bounce buffer */
625	nbp->b_error = 0;
626	nbp->b_dev = bp->b_dev;
627	nbp->b_proc = bp->b_proc;
628	nbp->b_bcount = count;
629	nbp->b_bufsize = count;
630	nbp->b_blkno = blkno;
631	nbp->b_flags = bp->b_flags | B_READ;
632	nbp->b_oflags = bp->b_oflags;
633	nbp->b_cflags = bp->b_cflags;
634	nbp->b_iodone = cd_bounce_buffer_done;
635	nbp->b_private = priv;
636
637	BIO_COPYPRIO(nbp, bp);
638
639	*nbpp = nbp;
640	return 0;
641}
642
643static int
644cd_make_bounce(struct cd_softc *cd, struct buf *bp, struct cdbounce **bouncep)
645{
646	struct dk_softc *dksc = &cd->sc_dksc;
647	unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize;
648	struct cdbounce *bounce;
649	int bps, nblks, skip, total, count;
650	daddr_t blkno;
651	struct buf *lbp, *rbp;
652	int error;
653
654	bounce = malloc(sizeof(struct cdbounce), M_DEVBUF, M_NOWAIT|M_ZERO);
655	if (bounce == NULL)
656		return ENOMEM;
657
658	bps = howmany(secsize, DEV_BSIZE);
659	nblks = howmany(bp->b_bcount, DEV_BSIZE);
660
661	skip = bp->b_blkno % bps;
662
663	blkno = bp->b_blkno - skip;
664	total = roundup(nblks + skip, bps) * DEV_BSIZE;
665
666	count = total;
667	cd_iosize(dksc->sc_dev, &count);
668
669	bounce->head = skip * DEV_BSIZE;
670	bounce->lcount = imin(count - bounce->head, bp->b_bcount);
671	bounce->rcount = bp->b_bcount - bounce->lcount;
672
673	error = cd_make_bounce_buffer(cd, bp, blkno, count, &lbp, bounce);
674	if (error)
675		goto bad;
676
677	blkno += howmany(count, DEV_BSIZE);
678	count = total - count;
679
680	if (count > 0) {
681		error = cd_make_bounce_buffer(cd, bp, blkno, count, &rbp, bounce);
682		if (error) {
683			free(lbp->b_data, M_DEVBUF);
684			putiobuf(lbp);
685			goto bad;
686		}
687	} else
688		rbp = NULL;
689
690	bounce->obp = bp;
691	bounce->lbp = lbp;
692	bounce->rbp = rbp;
693
694	*bouncep = bounce;
695
696	return 0;
697
698bad:
699	free(bounce, M_DEVBUF);
700	return error;
701}
702
703/*
704 * Actually translate the requested transfer into one the physical driver can
705 * understand.  The transfer is described by a buf and will include only one
706 * physical transfer.
707 */
708static void
709cdstrategy(struct buf *bp)
710{
711	struct cd_softc *cd = device_lookup_private(&cd_cd,CDUNIT(bp->b_dev));
712	struct dk_softc *dksc = &cd->sc_dksc;
713	struct scsipi_periph *periph = cd->sc_periph;
714	int error;
715
716	SC_DEBUG(cd->sc_periph, SCSIPI_DB2, ("cdstrategy "));
717	SC_DEBUG(cd->sc_periph, SCSIPI_DB1,
718	    ("%d bytes @ blk %" PRId64 "\n", bp->b_bcount, bp->b_blkno));
719
720	/*
721	 * If the device has been made invalid, error out
722	 * maybe the media changed
723	 */
724	if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0) {
725		if (periph->periph_flags & PERIPH_OPEN)
726			error = EIO;
727		else
728			error = ENODEV;
729		goto bad;
730	}
731
732	/*
733	 * If label and device don't agree in sector size use a bounce buffer
734	 */
735	if (dksc->sc_dkdev.dk_label->d_secsize != dksc->sc_dkdev.dk_geom.dg_secsize) {
736		struct cdbounce *bounce = NULL;
737
738		error = cd_make_bounce(cd, bp, &bounce);
739		if (error)
740			goto bad;
741
742		dk_strategy(dksc, bounce->lbp);
743		if (bounce->rbp != NULL)
744			dk_strategy(dksc, bounce->rbp);
745
746		return;
747	}
748
749	dk_strategy(dksc, bp);
750	return;
751
752bad:
753	bp->b_error = error;
754	bp->b_resid = bp->b_bcount;
755	biodone(bp);
756}
757
758/*
759 * Issue single I/O command
760 *
761 * Called from dk_start and implicitly from dk_strategy
762 */
763static int
764cd_diskstart(device_t dev, struct buf *bp)
765{
766	struct cd_softc *cd = device_private(dev);
767        struct scsipi_periph *periph = cd->sc_periph;
768        struct scsipi_channel *chan = periph->periph_channel;
769	struct scsipi_rw_10 cmd_big;
770	struct scsi_rw_6 cmd_small;
771	struct scsipi_generic *cmdp;
772	struct scsipi_xfer *xs;
773	int error, flags, nblks, cmdlen;
774
775	SC_DEBUG(periph, SCSIPI_DB2, ("cdstart "));
776
777	mutex_enter(chan_mtx(chan));
778
779	if (periph->periph_active >= periph->periph_openings) {
780		error = EAGAIN;
781		goto out;
782	}
783
784	/*
785	 * there is excess capacity, but a special waits
786	 * It'll need the adapter as soon as we clear out of the
787	 * way and let it run (user level wait).
788	 */
789	if (periph->periph_flags & PERIPH_WAITING) {
790		periph->periph_flags &= ~PERIPH_WAITING;
791		cv_broadcast(periph_cv_periph(periph));
792		error = EAGAIN;
793		goto out;
794	}
795
796	/*
797	 * If the device has become invalid, abort all the
798	 * reads and writes until all files have been closed and
799	 * re-opened
800	 */
801	if (__predict_false(
802	    (periph->periph_flags & PERIPH_MEDIA_LOADED) == 0)) {
803		error = EIO;
804		goto out;
805	}
806
807	nblks = howmany(bp->b_bcount, cd->params.blksize);
808
809	/*
810	 *  Fill out the scsi command.  If the transfer will
811	 *  fit in a "small" cdb, use it.
812	 */
813	if (((bp->b_rawblkno & 0x1fffff) == bp->b_rawblkno) &&
814	    ((nblks & 0xff) == nblks) &&
815	    !(periph->periph_quirks & PQUIRK_ONLYBIG)) {
816		/*
817		 * We can fit in a small cdb.
818		 */
819		memset(&cmd_small, 0, sizeof(cmd_small));
820		cmd_small.opcode = (bp->b_flags & B_READ) ?
821		    SCSI_READ_6_COMMAND : SCSI_WRITE_6_COMMAND;
822		_lto3b(bp->b_rawblkno, cmd_small.addr);
823		cmd_small.length = nblks & 0xff;
824		cmdlen = sizeof(cmd_small);
825		cmdp = (struct scsipi_generic *)&cmd_small;
826	} else {
827		/*
828		 * Need a large cdb.
829		 */
830		memset(&cmd_big, 0, sizeof(cmd_big));
831		cmd_big.opcode = (bp->b_flags & B_READ) ?
832		    READ_10 : WRITE_10;
833		_lto4b(bp->b_rawblkno, cmd_big.addr);
834		_lto2b(nblks, cmd_big.length);
835		cmdlen = sizeof(cmd_big);
836		cmdp = (struct scsipi_generic *)&cmd_big;
837	}
838
839	/*
840	 * Figure out what flags to use.
841	 */
842	flags = XS_CTL_NOSLEEP|XS_CTL_ASYNC|XS_CTL_SIMPLE_TAG;
843	if (bp->b_flags & B_READ)
844		flags |= XS_CTL_DATA_IN;
845	else
846		flags |= XS_CTL_DATA_OUT;
847
848	/*
849	 * Call the routine that chats with the adapter.
850	 * Note: we cannot sleep as we may be an interrupt
851	 */
852	xs = scsipi_make_xs_locked(periph, cmdp, cmdlen,
853	    (u_char *)bp->b_data, bp->b_bcount,
854	    CDRETRIES, 30000, bp, flags);
855	if (__predict_false(xs == NULL)) {
856		/*
857		 * out of memory. Keep this buffer in the queue, and
858		 * retry later.
859		 */
860		callout_reset(&cd->sc_callout, hz / 2, cdrestart, cd);
861		error = EAGAIN;
862		goto out;
863	}
864
865	error = scsipi_execute_xs(xs);
866	/* with a scsipi_xfer preallocated, scsipi_command can't fail */
867	KASSERT(error == 0);
868
869out:
870	mutex_exit(chan_mtx(chan));
871
872	return error;
873}
874
875/*
876 * Recover I/O request after memory shortage
877 *
878 * Called from callout
879 */
880static void
881cdrestart(void *v)
882{
883	struct cd_softc *cd = v;
884	struct dk_softc *dksc = &cd->sc_dksc;
885
886	dk_start(dksc, NULL);
887}
888
889/*
890 * Recover I/O request after memory shortage
891 *
892 * Called from scsipi midlayer when resources have been freed
893 * with channel lock held
894 */
895static void
896cdstart(struct scsipi_periph *periph)
897{
898	struct cd_softc *cd = device_private(periph->periph_dev);
899	struct dk_softc *dksc = &cd->sc_dksc;
900	struct scsipi_channel *chan = periph->periph_channel;
901
902	/*
903	 * release channel lock as dk_start may need to acquire
904	 * other locks
905	 *
906	 * cdstart is called from scsipi_put_xs and all its callers
907	 * release the lock afterwards. So releasing it here
908	 * doesn't matter.
909	 */
910	mutex_exit(chan_mtx(chan));
911
912	dk_start(dksc, NULL);
913
914	mutex_enter(chan_mtx(chan));
915}
916
917static void
918cddone(struct scsipi_xfer *xs, int error)
919{
920	struct cd_softc *cd = device_private(xs->xs_periph->periph_dev);
921	struct dk_softc *dksc = &cd->sc_dksc;
922	struct buf *bp = xs->bp;
923
924	if (bp) {
925		bp->b_error = error;
926		bp->b_resid = xs->resid;
927		if (error) {
928			/* on a read/write error bp->b_resid is zero, so fix */
929			bp->b_resid = bp->b_bcount;
930		}
931
932		dk_done(dksc, bp);
933		/* dk_start is called from scsipi_complete */
934	}
935}
936
937static int
938cd_interpret_sense(struct scsipi_xfer *xs)
939{
940	struct scsipi_periph *periph = xs->xs_periph;
941	struct scsi_sense_data *sense = &xs->sense.scsi_sense;
942	int retval = EJUSTRETURN;
943
944	/*
945	 * If it isn't an extended or extended/deferred error, let
946	 * the generic code handle it.
947	 */
948	if (SSD_RCODE(sense->response_code) != SSD_RCODE_CURRENT &&
949	    SSD_RCODE(sense->response_code) != SSD_RCODE_DEFERRED)
950		return (retval);
951
952	/*
953	 * If we got a "Unit not ready" (SKEY_NOT_READY) and "Logical Unit
954	 * Is In The Process of Becoming Ready" (Sense code 0x04,0x01), then
955	 * wait a bit for the drive to spin up
956	 */
957
958	if ((SSD_SENSE_KEY(sense->flags) == SKEY_NOT_READY) &&
959	    (sense->asc == 0x04) && (sense->ascq == 0x01)) {
960		/*
961		 * Sleep for 5 seconds to wait for the drive to spin up
962		 */
963
964		SC_DEBUG(periph, SCSIPI_DB1, ("Waiting 5 sec for CD "
965						"spinup\n"));
966		if (!callout_pending(&periph->periph_callout))
967			scsipi_periph_freeze(periph, 1);
968		callout_reset(&periph->periph_callout,
969		    5 * hz, scsipi_periph_timed_thaw, periph);
970		retval = ERESTART;
971	}
972
973	/*
974	 * If we got a "Unit not ready" (SKEY_NOT_READY) and "Logical Unit Not
975	 * Ready, Operation In Progress" (Sense code 0x04, 0x07),
976	 * then wait for the specified time
977	 */
978
979	if ((SSD_SENSE_KEY(sense->flags) == SKEY_NOT_READY) &&
980	    (sense->asc == 0x04) && (sense->ascq == 0x07)) {
981		/*
982		 * we could listen to the delay; but it looks like the skey
983		 * data is not always returned.
984		 */
985		/* cd_delay = _2btol(sense->sks.sks_bytes); */
986
987		/* wait for a half second and get going again */
988		if (!callout_pending(&periph->periph_callout))
989			scsipi_periph_freeze(periph, 1);
990		callout_reset(&periph->periph_callout,
991		    hz/2, scsipi_periph_timed_thaw, periph);
992		retval = ERESTART;
993	}
994
995	/*
996	 * If we got a "Unit not ready" (SKEY_NOT_READY) and "Long write in
997	 * progress" (Sense code 0x04, 0x08), then wait for the specified
998	 * time
999	 */
1000
1001	if ((SSD_SENSE_KEY(sense->flags) == SKEY_NOT_READY) &&
1002	    (sense->asc == 0x04) && (sense->ascq == 0x08)) {
1003		/*
1004		 * long write in process; we could listen to the delay; but it
1005		 * looks like the skey data is not always returned.
1006		 */
1007		/* cd_delay = _2btol(sense->sks.sks_bytes); */
1008
1009		/* wait for a half second and get going again */
1010		if (!callout_pending(&periph->periph_callout))
1011			scsipi_periph_freeze(periph, 1);
1012		callout_reset(&periph->periph_callout,
1013		    hz/2, scsipi_periph_timed_thaw, periph);
1014		retval = ERESTART;
1015	}
1016
1017	return (retval);
1018}
1019
1020static void
1021cdminphys(struct buf *bp)
1022{
1023	struct cd_softc *cd = device_lookup_private(&cd_cd, CDUNIT(bp->b_dev));
1024	struct dk_softc *dksc = &cd->sc_dksc;
1025	long xmax;
1026
1027	/*
1028	 * If the device is ancient, we want to make sure that
1029	 * the transfer fits into a 6-byte cdb.
1030	 *
1031	 * XXX Note that the SCSI-I spec says that 256-block transfers
1032	 * are allowed in a 6-byte read/write, and are specified
1033	 * by setting the "length" to 0.  However, we're conservative
1034	 * here, allowing only 255-block transfers in case an
1035	 * ancient device gets confused by length == 0.  A length of 0
1036	 * in a 10-byte read/write actually means 0 blocks.
1037	 */
1038	if (cd->flags & CDF_ANCIENT) {
1039		xmax = dksc->sc_dkdev.dk_geom.dg_secsize * 0xff;
1040
1041		if (bp->b_bcount > xmax)
1042			bp->b_bcount = xmax;
1043	}
1044
1045	scsipi_adapter_minphys(cd->sc_periph->periph_channel, bp);
1046}
1047
1048static void
1049cd_iosize(device_t dev, int *count)
1050{
1051	struct buf B;
1052	int bmaj;
1053
1054	bmaj       = bdevsw_lookup_major(&cd_bdevsw);
1055	B.b_dev    = MAKECDDEV(bmaj,device_unit(dev),RAW_PART);
1056	B.b_bcount = *count;
1057
1058	cdminphys(&B);
1059
1060	*count = B.b_bcount;
1061}
1062
1063static int
1064cdread(dev_t dev, struct uio *uio, int ioflag)
1065{
1066	return (physio(cdstrategy, NULL, dev, B_READ, cdminphys, uio));
1067}
1068
1069static int
1070cdwrite(dev_t dev, struct uio *uio, int ioflag)
1071{
1072	return (physio(cdstrategy, NULL, dev, B_WRITE, cdminphys, uio));
1073}
1074
1075#if 0	/* XXX Not used */
1076/*
1077 * conversion between minute-seconde-frame and logical block address
1078 * addresses format
1079 */
1080static void
1081lba2msf(u_long lba, u_char *m, u_char *s, u_char *f)
1082{
1083	u_long tmp;
1084
1085	tmp = lba + CD_BLOCK_OFFSET;	/* offset of first logical frame */
1086	tmp &= 0xffffff;		/* negative lbas use only 24 bits */
1087	*m = tmp / (CD_SECS * CD_FRAMES);
1088	tmp %= (CD_SECS * CD_FRAMES);
1089	*s = tmp / CD_FRAMES;
1090	*f = tmp % CD_FRAMES;
1091}
1092#endif /* XXX Not used */
1093
1094/*
1095 * Convert an hour:minute:second:frame address to a logical block address. In
1096 * theory the number of secs/minute and number of frames/second could be
1097 * configured differently in the device  as could the block offset but in
1098 * practice these values are rock solid and most drives don't even allow
1099 * theses values to be changed.
1100 */
1101static uint32_t
1102hmsf2lba(uint8_t h, uint8_t m, uint8_t s, uint8_t f)
1103{
1104	return (((((uint32_t) h * 60 + m) * CD_SECS) + s) * CD_FRAMES + f)
1105		- CD_BLOCK_OFFSET;
1106}
1107
1108static int
1109cdreadmsaddr(struct cd_softc *cd, struct cd_formatted_toc *toc, int *addr)
1110{
1111	struct scsipi_periph *periph = cd->sc_periph;
1112	int error;
1113	struct cd_toc_entry *cte;
1114
1115	error = cd_read_toc(cd, CD_TOC_FORM, 0, 0, toc,
1116	    sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry),
1117	    0, 0x40 /* control word for "get MS info" */);
1118
1119	if (error)
1120		return (error);
1121
1122	cte = &toc->entries[0];
1123	if (periph->periph_quirks & PQUIRK_LITTLETOC) {
1124		cte->addr.lba = le32toh(cte->addr.lba);
1125		toc->header.len = le16toh(toc->header.len);
1126	} else {
1127		cte->addr.lba = be32toh(cte->addr.lba);
1128		toc->header.len = be16toh(toc->header.len);
1129	}
1130
1131	*addr = (toc->header.len >= 10 && cte->track > 1) ?
1132		cte->addr.lba : 0;
1133	return 0;
1134}
1135
1136/* synchronise caches code from cd.c, move to scsipi_ioctl.c ? */
1137static int
1138cdcachesync(struct scsipi_periph *periph, int flags) {
1139	struct scsi_synchronize_cache_10 cmd;
1140
1141	/*
1142	 * Issue a SYNCHRONIZE CACHE. MMC devices have to issue with address 0
1143	 * and length 0 as it can't synchronise parts of the disc per spec.
1144	 * We ignore ILLEGAL REQUEST in the event that the command is not
1145	 * supported by the device, and poll for completion so that we know
1146	 * that the cache has actually been flushed.
1147	 *
1148	 * XXX should we handle the PQUIRK_NOSYNCCACHE ?
1149	 */
1150
1151	memset(&cmd, 0, sizeof(cmd));
1152	cmd.opcode = SCSI_SYNCHRONIZE_CACHE_10;
1153
1154	return (scsipi_command(periph, (void *)&cmd, sizeof(cmd), 0, 0,
1155	    CDRETRIES, 30000, NULL, flags | XS_CTL_IGNORE_ILLEGAL_REQUEST));
1156}
1157
1158static int
1159do_cdioreadentries(struct cd_softc *cd, struct ioc_read_toc_entry *te,
1160    struct cd_formatted_toc *toc)
1161{
1162	/* READ TOC format 0 command, entries */
1163	struct ioc_toc_header *th;
1164	struct cd_toc_entry *cte;
1165	u_int len = te->data_len;
1166	int ntracks;
1167	int error;
1168
1169	th = &toc->header;
1170
1171	if (len > sizeof(toc->entries) ||
1172	    len < sizeof(toc->entries[0]))
1173		return (EINVAL);
1174	error = cd_read_toc(cd, CD_TOC_FORM, te->address_format,
1175	    te->starting_track, toc,
1176	    sizeof(toc->header) + len,
1177	    0, 0);
1178	if (error)
1179		return (error);
1180	if (te->address_format == CD_LBA_FORMAT)
1181		for (ntracks =
1182		    th->ending_track - th->starting_track + 1;
1183		    ntracks >= 0; ntracks--) {
1184			cte = &toc->entries[ntracks];
1185			cte->addr_type = CD_LBA_FORMAT;
1186			if (cd->sc_periph->periph_quirks & PQUIRK_LITTLETOC)
1187				cte->addr.lba = le32toh(cte->addr.lba);
1188			else
1189				cte->addr.lba = be32toh(cte->addr.lba);
1190		}
1191	if (cd->sc_periph->periph_quirks & PQUIRK_LITTLETOC)
1192		th->len = le16toh(th->len);
1193	else
1194		th->len = be16toh(th->len);
1195	return 0;
1196}
1197
1198/*
1199 * Perform special action on behalf of the user.
1200 * Knows about the internals of this device
1201 */
1202static int
1203cdioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
1204{
1205	struct cd_softc *cd = device_lookup_private(&cd_cd, CDUNIT(dev));
1206	struct dk_softc *dksc = &cd->sc_dksc;
1207	struct scsipi_periph *periph = cd->sc_periph;
1208	struct cd_formatted_toc toc;
1209	int part = CDPART(dev);
1210	int error;
1211
1212	SC_DEBUG(cd->sc_periph, SCSIPI_DB2, ("cdioctl 0x%lx ", cmd));
1213
1214	/*
1215	 * If the device is not valid, some IOCTLs can still be
1216	 * handled on the raw partition. Check this here.
1217	 */
1218	if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0 &&
1219	    part != RAW_PART)
1220		return (EIO);
1221
1222	switch (cmd) {
1223	case DIOCTUR: {
1224		/* test unit ready */
1225		error = scsipi_test_unit_ready(cd->sc_periph, XS_CTL_SILENT);
1226		*((int*)addr) = (error == 0);
1227		if (error == ENODEV || error == EIO || error == 0)
1228			return 0;
1229		return error;
1230	}
1231	case CDIOCPLAYTRACKS: {
1232		/* PLAY_MSF command */
1233		struct ioc_play_track *args = addr;
1234
1235		if ((error = cd_set_pa_immed(cd, 0)) != 0)
1236			return (error);
1237		return (cd_play_tracks(cd, &toc, args->start_track,
1238		    args->start_index, args->end_track, args->end_index));
1239	}
1240	case CDIOCPLAYMSF: {
1241		/* PLAY_MSF command */
1242		struct ioc_play_msf *args = addr;
1243
1244		if ((error = cd_set_pa_immed(cd, 0)) != 0)
1245			return (error);
1246		return (cd_play_msf(cd, args->start_m, args->start_s,
1247		    args->start_f, args->end_m, args->end_s, args->end_f));
1248	}
1249	case CDIOCPLAYBLOCKS: {
1250		/* PLAY command */
1251		struct ioc_play_blocks *args = addr;
1252
1253		if ((error = cd_set_pa_immed(cd, 0)) != 0)
1254			return (error);
1255		return (cd_play(cd, args->blk, args->len));
1256	}
1257	case CDIOCREADSUBCHANNEL: {
1258		/* READ_SUBCHANNEL command */
1259		struct ioc_read_subchannel *args = addr;
1260		struct cd_sub_channel_info data;
1261		u_int len = args->data_len;
1262
1263		if (len > sizeof(data) ||
1264		    len < sizeof(struct cd_sub_channel_header))
1265			return (EINVAL);
1266		error = cd_read_subchannel(cd, args->address_format,
1267		    args->data_format, args->track, &data, len, 0);
1268		if (error)
1269			return (error);
1270		len = uimin(len, _2btol(data.header.data_len) +
1271		    sizeof(struct cd_sub_channel_header));
1272		return (copyout(&data, args->data, len));
1273	}
1274	case CDIOCREADSUBCHANNEL_BUF: {
1275		/* As CDIOCREADSUBCHANNEL, but without a 2nd buffer area */
1276		struct ioc_read_subchannel_buf *args = addr;
1277		if (args->req.data_len != sizeof args->info)
1278			return EINVAL;
1279		return cd_read_subchannel(cd, args->req.address_format,
1280		    args->req.data_format, args->req.track, &args->info,
1281		    sizeof(args->info), 0);
1282	}
1283	case CDIOREADTOCHEADER: {
1284		/* READ TOC format 0 command, static header */
1285		if ((error = cd_read_toc(cd, CD_TOC_FORM, 0, 0,
1286		    &toc, sizeof(toc.header), 0, 0)) != 0)
1287			return (error);
1288		if (cd->sc_periph->periph_quirks & PQUIRK_LITTLETOC)
1289			toc.header.len = le16toh(toc.header.len);
1290		else
1291			toc.header.len = be16toh(toc.header.len);
1292		memcpy(addr, &toc.header, sizeof(toc.header));
1293		return (0);
1294	}
1295	case CDIOREADTOCENTRYS: {
1296		struct ioc_read_toc_entry *te = addr;
1297		error = do_cdioreadentries(cd, te, &toc);
1298		if (error != 0)
1299			return error;
1300		return copyout(toc.entries, te->data, uimin(te->data_len,
1301		    toc.header.len - (sizeof(toc.header.starting_track)
1302			+ sizeof(toc.header.ending_track))));
1303	}
1304	case CDIOREADTOCENTRIES_BUF: {
1305		struct ioc_read_toc_entry_buf *te = addr;
1306		error = do_cdioreadentries(cd, &te->req, &toc);
1307		if (error != 0)
1308			return error;
1309		memcpy(te->entry, toc.entries, uimin(te->req.data_len,
1310		    toc.header.len - (sizeof(toc.header.starting_track)
1311			+ sizeof(toc.header.ending_track))));
1312		return 0;
1313	}
1314	case CDIOREADMSADDR: {
1315		/* READ TOC format 0 command, length of first track only */
1316		int sessno = *(int*)addr;
1317
1318		if (sessno != 0)
1319			return (EINVAL);
1320
1321		return (cdreadmsaddr(cd, &toc, addr));
1322	}
1323	case CDIOCSETPATCH: {
1324		struct ioc_patch *arg = addr;
1325
1326		return (cd_setchan(cd, arg->patch[0], arg->patch[1],
1327		    arg->patch[2], arg->patch[3], 0));
1328	}
1329	case CDIOCGETVOL: {
1330		/* MODE SENSE command (AUDIO page) */
1331		struct ioc_vol *arg = addr;
1332
1333		return (cd_getvol(cd, arg, 0));
1334	}
1335	case CDIOCSETVOL: {
1336		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1337		struct ioc_vol *arg = addr;
1338
1339		return (cd_setvol(cd, arg, 0));
1340	}
1341	case CDIOCSETMONO:
1342		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1343		return (cd_setchan(cd, BOTH_CHANNEL, BOTH_CHANNEL,
1344		    MUTE_CHANNEL, MUTE_CHANNEL, 0));
1345
1346	case CDIOCSETSTEREO:
1347		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1348		return (cd_setchan(cd, LEFT_CHANNEL, RIGHT_CHANNEL,
1349		    MUTE_CHANNEL, MUTE_CHANNEL, 0));
1350
1351	case CDIOCSETMUTE:
1352		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1353		return (cd_setchan(cd, MUTE_CHANNEL, MUTE_CHANNEL,
1354		    MUTE_CHANNEL, MUTE_CHANNEL, 0));
1355
1356	case CDIOCSETLEFT:
1357		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1358		return (cd_setchan(cd, LEFT_CHANNEL, LEFT_CHANNEL,
1359		    MUTE_CHANNEL, MUTE_CHANNEL, 0));
1360
1361	case CDIOCSETRIGHT:
1362		/* MODE SENSE/MODE SELECT commands (AUDIO page) */
1363		return (cd_setchan(cd, RIGHT_CHANNEL, RIGHT_CHANNEL,
1364		    MUTE_CHANNEL, MUTE_CHANNEL, 0));
1365
1366	case CDIOCRESUME:
1367		/* PAUSE command */
1368		return (cd_pause(cd, PA_RESUME));
1369	case CDIOCPAUSE:
1370		/* PAUSE command */
1371		return (cd_pause(cd, PA_PAUSE));
1372	case CDIOCSTART:
1373		return (scsipi_start(periph, SSS_START, 0));
1374	case CDIOCSTOP:
1375		return (scsipi_start(periph, SSS_STOP, 0));
1376	case CDIOCCLOSE:
1377		return (scsipi_start(periph, SSS_START|SSS_LOEJ,
1378		    XS_CTL_IGNORE_NOT_READY | XS_CTL_IGNORE_MEDIA_CHANGE));
1379	case DIOCEJECT:
1380		if (*(int *)addr == 0) {
1381			int pmask = __BIT(part);
1382			/*
1383			 * Don't force eject: check that we are the only
1384			 * partition open. If so, unlock it.
1385			 */
1386			if (DK_BUSY(dksc, pmask) == 0) {
1387				error = scsipi_prevent(periph, SPAMR_ALLOW,
1388				    XS_CTL_IGNORE_NOT_READY);
1389				if (error)
1390					return (error);
1391			} else {
1392				return (EBUSY);
1393			}
1394		}
1395		/* FALLTHROUGH */
1396	case CDIOCEJECT: /* FALLTHROUGH */
1397	case ODIOCEJECT:
1398		error = scsipi_start(periph, SSS_STOP|SSS_LOEJ, 0);
1399		if (error == 0)
1400			/* Make sure cdclose() will do silent operations */
1401			cd->flags |= CDF_EJECTED;
1402		return error;
1403	case DIOCCACHESYNC:
1404		/* SYNCHRONISE CACHES command */
1405		return (cdcachesync(periph, 0));
1406	case CDIOCALLOW:
1407		return (scsipi_prevent(periph, SPAMR_ALLOW, 0));
1408	case CDIOCPREVENT:
1409		return (scsipi_prevent(periph, SPAMR_PREVENT_DT, 0));
1410	case DIOCLOCK:
1411		return (scsipi_prevent(periph,
1412		    (*(int *)addr) ? SPAMR_PREVENT_DT : SPAMR_ALLOW, 0));
1413	case CDIOCSETDEBUG:
1414		cd->sc_periph->periph_dbflags |= (SCSIPI_DB1 | SCSIPI_DB2);
1415		return (0);
1416	case CDIOCCLRDEBUG:
1417		cd->sc_periph->periph_dbflags &= ~(SCSIPI_DB1 | SCSIPI_DB2);
1418		return (0);
1419	case CDIOCRESET:
1420	case SCIOCRESET:
1421		return (cd_reset(cd));
1422	case CDIOCLOADUNLOAD:
1423		/* LOAD_UNLOAD command */
1424		return (cd_load_unload(cd, addr));
1425	case DVD_AUTH:
1426		/* GPCMD_REPORT_KEY or GPCMD_SEND_KEY command */
1427		return (dvd_auth(cd, addr));
1428	case DVD_READ_STRUCT:
1429		/* GPCMD_READ_DVD_STRUCTURE command */
1430		return (dvd_read_struct(cd, addr));
1431	case MMCGETDISCINFO:
1432		/*
1433		 * GET_CONFIGURATION, READ_DISCINFO, READ_TRACKINFO,
1434		 * (READ_TOCf2, READ_CD_CAPACITY and GET_CONFIGURATION) commands
1435		 */
1436		return mmc_getdiscinfo(periph, (struct mmc_discinfo *) addr);
1437	case MMCGETTRACKINFO:
1438		/* READ TOCf2, READ_CD_CAPACITY and READ_TRACKINFO commands */
1439		return mmc_gettrackinfo(periph, (struct mmc_trackinfo *) addr);
1440	case MMCOP:
1441		/*
1442		 * CLOSE TRACK/SESSION, RESERVE_TRACK, REPAIR_TRACK,
1443		 * SYNCHRONISE_CACHE commands
1444		 */
1445		return mmc_do_op(periph, (struct mmc_op *) addr);
1446	case MMCSETUPWRITEPARAMS :
1447		/* MODE SENSE page 5, MODE_SELECT page 5 commands */
1448		return mmc_setup_writeparams(periph, (struct mmc_writeparams *) addr);
1449	default:
1450		error = dk_ioctl(dksc, dev, cmd, addr, flag, l);
1451		if (error == ENOTTY)
1452			error = scsipi_do_ioctl(periph, dev, cmd, addr, flag, l);
1453		return (error);
1454	}
1455
1456#ifdef DIAGNOSTIC
1457	panic("cdioctl: impossible");
1458#endif
1459}
1460
1461static void
1462cd_label(device_t self, struct disklabel *lp)
1463{
1464	struct cd_softc *cd = device_private(self);
1465	struct scsipi_periph *periph = cd->sc_periph;
1466	struct cd_formatted_toc toc;
1467	int lastsession = 0;
1468
1469	strncpy(lp->d_typename, "optical media", 16);
1470	lp->d_rpm = 300;
1471	lp->d_flags |= D_REMOVABLE;
1472
1473	if ((periph->periph_flags & PERIPH_MEDIA_LOADED) != 0) {
1474		lp->d_flags |= D_SCSI_MMC;
1475		(void) cdreadmsaddr(cd, &toc, &lastsession);
1476	}
1477
1478	lp->d_partitions[0].p_offset = 0;
1479	lp->d_partitions[0].p_size = lp->d_secperunit;
1480	lp->d_partitions[0].p_cdsession = lastsession;
1481	lp->d_partitions[0].p_fstype = FS_ISO9660;
1482
1483	lp->d_partitions[RAW_PART].p_offset = 0;
1484	lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
1485	lp->d_partitions[RAW_PART].p_fstype = FS_UDF;
1486}
1487
1488/*
1489 * Reading a disc's total capacity is apparently a very difficult issue for the
1490 * SCSI standardisation group. Every disc type seems to have its own
1491 * (re)invented size request method and modifiers. The failsafe way of
1492 * determining the total (max) capacity i.e. not the recorded capacity but the
1493 * total maximum capacity is to request the info on the last track and
1494 * calculate the last lba.
1495 *
1496 * For ROM drives, we go for the CD recorded capacity. For recordable devices
1497 * we count.
1498 */
1499static int
1500read_cd_capacity(struct scsipi_periph *periph, uint32_t *blksize, u_long *last_lba)
1501{
1502	struct scsipi_read_cd_capacity    cap_cmd;
1503	/*
1504	 * XXX: see PR 48550 and PR 48754:
1505	 * the ahcisata(4) driver can not deal with unaligned
1506	 * data, so align this "a bit"
1507	 */
1508	struct scsipi_read_cd_cap_data    cap __aligned(2);
1509	struct scsipi_read_discinfo       di_cmd;
1510	struct scsipi_read_discinfo_data  di __aligned(2);
1511	struct scsipi_read_trackinfo      ti_cmd;
1512	struct scsipi_read_trackinfo_data ti __aligned(2);
1513	uint32_t track_start, track_size;
1514	int error, flags, msb, lsb, last_track;
1515
1516	/* if the device doesn't grok capacity, return the dummies */
1517	if (periph->periph_quirks & PQUIRK_NOCAPACITY)
1518		return 0;
1519
1520	/* first try read CD capacity for blksize and last recorded lba */
1521	/* issue the cd capacity request */
1522	flags = XS_CTL_DATA_IN;
1523	memset(&cap_cmd, 0, sizeof(cap_cmd));
1524	memset(&cap, 0, sizeof(cap));
1525	cap_cmd.opcode = READ_CD_CAPACITY;
1526
1527	error = scsipi_command(periph,
1528	    (void *) &cap_cmd, sizeof(cap_cmd),
1529	    (void *) &cap,     sizeof(cap),
1530	    CDRETRIES, 30000, NULL, flags);
1531	if (error)
1532		return error;
1533
1534	/* retrieve values and sanity check them */
1535	*blksize  = _4btol(cap.length);
1536	*last_lba = _4btol(cap.addr);
1537
1538	/* blksize is 2048 for CD, but some drives give gibberish */
1539	if ((*blksize < 512) || ((*blksize & 511) != 0)
1540	    || (*blksize > 16*1024)) {
1541		if (*blksize > 16*1024)
1542			aprint_error("read_cd_capacity: extra large block "
1543			    "size %u found - limiting to 2kByte\n",
1544			    *blksize);
1545		*blksize = 2048;	/* some drives lie ! */
1546	}
1547
1548	/* If the device doesn't handle READ_DISCINFO properly, */
1549	/* return the dummies */
1550	if (periph->periph_quirks & PQUIRK_NOREADDISCINFO)
1551		return 0;
1552
1553	/* recordables have READ_DISCINFO implemented */
1554	flags = XS_CTL_DATA_IN | XS_CTL_SILENT;
1555	memset(&di_cmd, 0, sizeof(di_cmd));
1556	di_cmd.opcode = READ_DISCINFO;
1557	_lto2b(READ_DISCINFO_BIGSIZE, di_cmd.data_len);
1558
1559	error = scsipi_command(periph,
1560	    (void *) &di_cmd,  sizeof(di_cmd),
1561	    (void *) &di,      READ_DISCINFO_BIGSIZE,
1562	    CDRETRIES, 30000, NULL, flags);
1563	if (error == 0) {
1564		msb = di.last_track_last_session_msb;
1565		lsb = di.last_track_last_session_lsb;
1566		last_track = (msb << 8) | lsb;
1567
1568		/* request info on last track */
1569		memset(&ti_cmd, 0, sizeof(ti_cmd));
1570		ti_cmd.opcode = READ_TRACKINFO;
1571		ti_cmd.addr_type = 1;			/* on tracknr */
1572		_lto4b(last_track, ti_cmd.address);	/* tracknr    */
1573		_lto2b(sizeof(ti), ti_cmd.data_len);
1574
1575		error = scsipi_command(periph,
1576		    (void *) &ti_cmd,  sizeof(ti_cmd),
1577		    (void *) &ti,      sizeof(ti),
1578		    CDRETRIES, 30000, NULL, flags);
1579		if (error == 0) {
1580			track_start = _4btol(ti.track_start);
1581			track_size  = _4btol(ti.track_size);
1582
1583			/* overwrite only with a sane value */
1584			if (track_start + track_size >= 100)
1585				*last_lba = (u_long) track_start + track_size -1;
1586		}
1587	}
1588
1589	/* sanity check for lba_size */
1590	if (*last_lba < 100)
1591		*last_lba = 400000-1;
1592
1593	return 0;
1594}
1595
1596/*
1597 * Find out from the device what its capacity is
1598 */
1599static u_long
1600cd_size(struct cd_softc *cd, int flags)
1601{
1602	uint32_t blksize = 2048;
1603	u_long last_lba = 0, size;
1604	int error;
1605
1606	error = read_cd_capacity(cd->sc_periph, &blksize, &last_lba);
1607	if (error)
1608		goto error;
1609
1610	if (blksize != 2048) {
1611		if (cd_setblksize(cd) == 0) {
1612			blksize = 2048;
1613			error = read_cd_capacity(cd->sc_periph,
1614			    &blksize, &last_lba);
1615			if (error)
1616				goto error;
1617		}
1618	}
1619
1620	size = last_lba + 1;
1621	cd->params.blksize     = blksize;
1622	cd->params.disksize    = size;
1623	cd->params.disksize512 = ((u_int64_t)cd->params.disksize * blksize) / DEV_BSIZE;
1624
1625	SC_DEBUG(cd->sc_periph, SCSIPI_DB2,
1626	    ("cd_size: %u %lu\n", blksize, size));
1627
1628	return size;
1629
1630error:
1631	/* something went wrong */
1632	cd->params.blksize     = 2048;
1633	cd->params.disksize    = 0;
1634	cd->params.disksize512 = 0;
1635
1636	SC_DEBUG(cd->sc_periph, SCSIPI_DB2, ("cd_size: failed\n"));
1637
1638	return 0;
1639}
1640
1641/*
1642 * Get scsi driver to send a "start playing" command
1643 */
1644static int
1645cd_play(struct cd_softc *cd, int blkno, int nblks)
1646{
1647	struct scsipi_play cmd;
1648
1649	memset(&cmd, 0, sizeof(cmd));
1650	cmd.opcode = PLAY;
1651	_lto4b(blkno, cmd.blk_addr);
1652	_lto2b(nblks, cmd.xfer_len);
1653
1654	return (scsipi_command(cd->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
1655	    CDRETRIES, 30000, NULL, 0));
1656}
1657
1658/*
1659 * Get scsi driver to send a "start playing" command
1660 */
1661static int
1662cd_play_tracks(struct cd_softc *cd, struct cd_formatted_toc *toc, int strack,
1663    int sindex, int etrack, int eindex)
1664{
1665	int error;
1666
1667	if (!etrack)
1668		return (EIO);
1669	if (strack > etrack)
1670		return (EINVAL);
1671
1672	error = cd_load_toc(cd, CD_TOC_FORM, toc, 0);
1673	if (error)
1674		return (error);
1675
1676	if (++etrack > (toc->header.ending_track+1))
1677		etrack = toc->header.ending_track+1;
1678
1679	strack -= toc->header.starting_track;
1680	etrack -= toc->header.starting_track;
1681	if (strack < 0)
1682		return (EINVAL);
1683
1684	return (cd_play_msf(cd, toc->entries[strack].addr.msf.minute,
1685	    toc->entries[strack].addr.msf.second,
1686	    toc->entries[strack].addr.msf.frame,
1687	    toc->entries[etrack].addr.msf.minute,
1688	    toc->entries[etrack].addr.msf.second,
1689	    toc->entries[etrack].addr.msf.frame));
1690}
1691
1692/*
1693 * Get scsi driver to send a "play msf" command
1694 */
1695static int
1696cd_play_msf(struct cd_softc *cd, int startm, int starts, int startf, int endm,
1697    int ends, int endf)
1698{
1699	struct scsipi_play_msf cmd;
1700
1701	memset(&cmd, 0, sizeof(cmd));
1702	cmd.opcode = PLAY_MSF;
1703	cmd.start_m = startm;
1704	cmd.start_s = starts;
1705	cmd.start_f = startf;
1706	cmd.end_m = endm;
1707	cmd.end_s = ends;
1708	cmd.end_f = endf;
1709
1710	return (scsipi_command(cd->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
1711	    CDRETRIES, 30000, NULL, 0));
1712}
1713
1714/*
1715 * Get scsi driver to send a "start up" command
1716 */
1717static int
1718cd_pause(struct cd_softc *cd, int go)
1719{
1720	struct scsipi_pause cmd;
1721
1722	memset(&cmd, 0, sizeof(cmd));
1723	cmd.opcode = PAUSE;
1724	cmd.resume = go & 0xff;
1725
1726	return (scsipi_command(cd->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
1727	    CDRETRIES, 30000, NULL, 0));
1728}
1729
1730/*
1731 * Get scsi driver to send a "RESET" command
1732 */
1733static int
1734cd_reset(struct cd_softc *cd)
1735{
1736
1737	return (scsipi_command(cd->sc_periph, 0, 0, 0, 0,
1738	    CDRETRIES, 30000, NULL, XS_CTL_RESET));
1739}
1740
1741/*
1742 * Read subchannel
1743 */
1744static int
1745cd_read_subchannel(struct cd_softc *cd, int mode, int format, int track,
1746    struct cd_sub_channel_info *data, int len, int flags)
1747{
1748	struct scsipi_read_subchannel cmd;
1749
1750	memset(&cmd, 0, sizeof(cmd));
1751	cmd.opcode = READ_SUBCHANNEL;
1752	if (mode == CD_MSF_FORMAT)
1753		cmd.byte2 |= CD_MSF;
1754	cmd.byte3 = SRS_SUBQ;
1755	cmd.subchan_format = format;
1756	cmd.track = track;
1757	_lto2b(len, cmd.data_len);
1758
1759	return (scsipi_command(cd->sc_periph,
1760	    (void *)&cmd, sizeof(struct scsipi_read_subchannel),
1761	    (void *)data, len,
1762	    CDRETRIES, 30000, NULL, flags | XS_CTL_DATA_IN | XS_CTL_SILENT));
1763}
1764
1765/*
1766 * Read table of contents
1767 */
1768static int
1769cd_read_toc(struct cd_softc *cd, int respf, int mode, int start,
1770    struct cd_formatted_toc *toc, int len, int flags, int control)
1771{
1772	struct scsipi_read_toc cmd;
1773	int ntoc;
1774
1775	memset(&cmd, 0, sizeof(cmd));
1776#if 0
1777	if (len != sizeof(struct ioc_toc_header))
1778		ntoc = ((len) - sizeof(struct ioc_toc_header)) /
1779		    sizeof(struct cd_toc_entry);
1780	else
1781#endif
1782	ntoc = len;
1783	cmd.opcode = READ_TOC;
1784	if (mode == CD_MSF_FORMAT)
1785		cmd.addr_mode |= CD_MSF;
1786	cmd.resp_format = respf;
1787	cmd.from_track = start;
1788	_lto2b(ntoc, cmd.data_len);
1789	cmd.control = control;
1790
1791	return (scsipi_command(cd->sc_periph,
1792	    (void *)&cmd, sizeof(cmd), (void *)toc, len, CDRETRIES,
1793	    30000, NULL, flags | XS_CTL_DATA_IN));
1794}
1795
1796static int
1797cd_load_toc(struct cd_softc *cd, int respf, struct cd_formatted_toc *toc, int flags)
1798{
1799	int ntracks, len, error;
1800
1801	if ((error = cd_read_toc(cd, respf, 0, 0, toc, sizeof(toc->header),
1802	    flags, 0)) != 0)
1803		return (error);
1804
1805	ntracks = toc->header.ending_track - toc->header.starting_track + 1;
1806	len = (ntracks + 1) * sizeof(struct cd_toc_entry) +
1807	    sizeof(toc->header);
1808	if ((error = cd_read_toc(cd, respf, CD_MSF_FORMAT, 0, toc, len,
1809	    flags, 0)) != 0)
1810		return (error);
1811	return (0);
1812}
1813
1814/*
1815 * Get the scsi driver to send a full inquiry to the device and use the
1816 * results to fill out the disk parameter structure.
1817 */
1818static int
1819cd_get_parms(struct cd_softc *cd, int flags)
1820{
1821
1822	/*
1823	 * give a number of sectors so that sec * trks * cyls
1824	 * is <= disk_size
1825	 */
1826	if (cd_size(cd, flags) == 0)
1827		return (ENXIO);
1828	return (0);
1829}
1830
1831static int
1832cdsize(dev_t dev)
1833{
1834
1835	/* CD-ROMs are read-only. */
1836	return (-1);
1837}
1838
1839static int
1840cddump(dev_t dev, daddr_t blkno, void *va, size_t size)
1841{
1842
1843	/* Not implemented. */
1844	return (ENXIO);
1845}
1846
1847#define	dvd_copy_key(dst, src)		memcpy((dst), (src), sizeof(dvd_key))
1848#define	dvd_copy_challenge(dst, src)	memcpy((dst), (src), sizeof(dvd_challenge))
1849
1850static int
1851dvd_auth(struct cd_softc *cd, dvd_authinfo *a)
1852{
1853	struct scsipi_generic cmd;
1854	u_int8_t bf[20];
1855	int error;
1856
1857	memset(cmd.bytes, 0, 15);
1858	memset(bf, 0, sizeof(bf));
1859
1860	switch (a->type) {
1861	case DVD_LU_SEND_AGID:
1862		cmd.opcode = GPCMD_REPORT_KEY;
1863		cmd.bytes[8] = 8;
1864		cmd.bytes[9] = 0 | (0 << 6);
1865		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 8,
1866		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1867		if (error)
1868			return (error);
1869		a->lsa.agid = bf[7] >> 6;
1870		return (0);
1871
1872	case DVD_LU_SEND_CHALLENGE:
1873		cmd.opcode = GPCMD_REPORT_KEY;
1874		cmd.bytes[8] = 16;
1875		cmd.bytes[9] = 1 | (a->lsc.agid << 6);
1876		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 16,
1877		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1878		if (error)
1879			return (error);
1880		dvd_copy_challenge(a->lsc.chal, &bf[4]);
1881		return (0);
1882
1883	case DVD_LU_SEND_KEY1:
1884		cmd.opcode = GPCMD_REPORT_KEY;
1885		cmd.bytes[8] = 12;
1886		cmd.bytes[9] = 2 | (a->lsk.agid << 6);
1887		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 12,
1888		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1889		if (error)
1890			return (error);
1891		dvd_copy_key(a->lsk.key, &bf[4]);
1892		return (0);
1893
1894	case DVD_LU_SEND_TITLE_KEY:
1895		cmd.opcode = GPCMD_REPORT_KEY;
1896		_lto4b(a->lstk.lba, &cmd.bytes[1]);
1897		cmd.bytes[8] = 12;
1898		cmd.bytes[9] = 4 | (a->lstk.agid << 6);
1899		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 12,
1900		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1901		if (error)
1902			return (error);
1903		a->lstk.cpm = (bf[4] >> 7) & 1;
1904		a->lstk.cp_sec = (bf[4] >> 6) & 1;
1905		a->lstk.cgms = (bf[4] >> 4) & 3;
1906		dvd_copy_key(a->lstk.title_key, &bf[5]);
1907		return (0);
1908
1909	case DVD_LU_SEND_ASF:
1910		cmd.opcode = GPCMD_REPORT_KEY;
1911		cmd.bytes[8] = 8;
1912		cmd.bytes[9] = 5 | (a->lsasf.agid << 6);
1913		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 8,
1914		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1915		if (error)
1916			return (error);
1917		a->lsasf.asf = bf[7] & 1;
1918		return (0);
1919
1920	case DVD_HOST_SEND_CHALLENGE:
1921		cmd.opcode = GPCMD_SEND_KEY;
1922		cmd.bytes[8] = 16;
1923		cmd.bytes[9] = 1 | (a->hsc.agid << 6);
1924		bf[1] = 14;
1925		dvd_copy_challenge(&bf[4], a->hsc.chal);
1926		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 16,
1927		    CDRETRIES, 30000, NULL, XS_CTL_DATA_OUT);
1928		if (error)
1929			return (error);
1930		a->type = DVD_LU_SEND_KEY1;
1931		return (0);
1932
1933	case DVD_HOST_SEND_KEY2:
1934		cmd.opcode = GPCMD_SEND_KEY;
1935		cmd.bytes[8] = 12;
1936		cmd.bytes[9] = 3 | (a->hsk.agid << 6);
1937		bf[1] = 10;
1938		dvd_copy_key(&bf[4], a->hsk.key);
1939		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 12,
1940		    CDRETRIES, 30000, NULL, XS_CTL_DATA_OUT);
1941		if (error) {
1942			a->type = DVD_AUTH_FAILURE;
1943			return (error);
1944		}
1945		a->type = DVD_AUTH_ESTABLISHED;
1946		return (0);
1947
1948	case DVD_INVALIDATE_AGID:
1949		cmd.opcode = GPCMD_REPORT_KEY;
1950		cmd.bytes[9] = 0x3f | (a->lsa.agid << 6);
1951		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 16,
1952		    CDRETRIES, 30000, NULL, 0);
1953		if (error)
1954			return (error);
1955		return (0);
1956
1957	case DVD_LU_SEND_RPC_STATE:
1958		cmd.opcode = GPCMD_REPORT_KEY;
1959		cmd.bytes[8] = 8;
1960		cmd.bytes[9] = 8 | (0 << 6);
1961		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 8,
1962		    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
1963		if (error)
1964			return (error);
1965		a->lrpcs.type = (bf[4] >> 6) & 3;
1966		a->lrpcs.vra = (bf[4] >> 3) & 7;
1967		a->lrpcs.ucca = (bf[4]) & 7;
1968		a->lrpcs.region_mask = bf[5];
1969		a->lrpcs.rpc_scheme = bf[6];
1970		return (0);
1971
1972	case DVD_HOST_SEND_RPC_STATE:
1973		cmd.opcode = GPCMD_SEND_KEY;
1974		cmd.bytes[8] = 8;
1975		cmd.bytes[9] = 6 | (0 << 6);
1976		bf[1] = 6;
1977		bf[4] = a->hrpcs.pdrc;
1978		error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 8,
1979		    CDRETRIES, 30000, NULL, XS_CTL_DATA_OUT);
1980		if (error)
1981			return (error);
1982		return (0);
1983
1984	default:
1985		return (ENOTTY);
1986	}
1987}
1988
1989static int
1990dvd_read_physical(struct cd_softc *cd, dvd_struct *s)
1991{
1992	struct scsipi_generic cmd;
1993	u_int8_t bf[4 + 4 * 20], *bufp;
1994	int error;
1995	struct dvd_layer *layer;
1996	int i;
1997
1998	memset(cmd.bytes, 0, 15);
1999	memset(bf, 0, sizeof(bf));
2000	cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
2001	cmd.bytes[6] = s->type;
2002	_lto2b(sizeof(bf), &cmd.bytes[7]);
2003
2004	cmd.bytes[5] = s->physical.layer_num;
2005	error = scsipi_command(cd->sc_periph, &cmd, 12, bf, sizeof(bf),
2006	    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
2007	if (error)
2008		return (error);
2009	for (i = 0, bufp = &bf[4], layer = &s->physical.layer[0]; i < 4;
2010	     i++, bufp += 20, layer++) {
2011		memset(layer, 0, sizeof(*layer));
2012                layer->book_version = bufp[0] & 0xf;
2013                layer->book_type = bufp[0] >> 4;
2014                layer->min_rate = bufp[1] & 0xf;
2015                layer->disc_size = bufp[1] >> 4;
2016                layer->layer_type = bufp[2] & 0xf;
2017                layer->track_path = (bufp[2] >> 4) & 1;
2018                layer->nlayers = (bufp[2] >> 5) & 3;
2019                layer->track_density = bufp[3] & 0xf;
2020                layer->linear_density = bufp[3] >> 4;
2021                layer->start_sector = _4btol(&bufp[4]);
2022                layer->end_sector = _4btol(&bufp[8]);
2023                layer->end_sector_l0 = _4btol(&bufp[12]);
2024                layer->bca = bufp[16] >> 7;
2025	}
2026	return (0);
2027}
2028
2029static int
2030dvd_read_copyright(struct cd_softc *cd, dvd_struct *s)
2031{
2032	struct scsipi_generic cmd;
2033	u_int8_t bf[8];
2034	int error;
2035
2036	memset(cmd.bytes, 0, 15);
2037	memset(bf, 0, sizeof(bf));
2038	cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
2039	cmd.bytes[6] = s->type;
2040	_lto2b(sizeof(bf), &cmd.bytes[7]);
2041
2042	cmd.bytes[5] = s->copyright.layer_num;
2043	error = scsipi_command(cd->sc_periph, &cmd, 12, bf, sizeof(bf),
2044	    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
2045	if (error)
2046		return (error);
2047	s->copyright.cpst = bf[4];
2048	s->copyright.rmi = bf[5];
2049	return (0);
2050}
2051
2052static int
2053dvd_read_disckey(struct cd_softc *cd, dvd_struct *s)
2054{
2055	struct scsipi_generic cmd;
2056	u_int8_t *bf;
2057	int error;
2058
2059	bf = malloc(4 + 2048, M_TEMP, M_WAITOK|M_ZERO);
2060	if (bf == NULL)
2061		return EIO;
2062	memset(cmd.bytes, 0, 15);
2063	cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
2064	cmd.bytes[6] = s->type;
2065	_lto2b(4 + 2048, &cmd.bytes[7]);
2066
2067	cmd.bytes[9] = s->disckey.agid << 6;
2068	error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 4 + 2048,
2069	    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
2070	if (error == 0)
2071		memcpy(s->disckey.value, &bf[4], 2048);
2072	free(bf, M_TEMP);
2073	return error;
2074}
2075
2076static int
2077dvd_read_bca(struct cd_softc *cd, dvd_struct *s)
2078{
2079	struct scsipi_generic cmd;
2080	u_int8_t bf[4 + 188];
2081	int error;
2082
2083	memset(cmd.bytes, 0, 15);
2084	memset(bf, 0, sizeof(bf));
2085	cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
2086	cmd.bytes[6] = s->type;
2087	_lto2b(sizeof(bf), &cmd.bytes[7]);
2088
2089	error = scsipi_command(cd->sc_periph, &cmd, 12, bf, sizeof(bf),
2090	    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
2091	if (error)
2092		return (error);
2093	s->bca.len = _2btol(&bf[0]);
2094	if (s->bca.len < 12 || s->bca.len > 188)
2095		return (EIO);
2096	memcpy(s->bca.value, &bf[4], s->bca.len);
2097	return (0);
2098}
2099
2100static int
2101dvd_read_manufact(struct cd_softc *cd, dvd_struct *s)
2102{
2103	struct scsipi_generic cmd;
2104	u_int8_t *bf;
2105	int error;
2106
2107	bf = malloc(4 + 2048, M_TEMP, M_WAITOK|M_ZERO);
2108	if (bf == NULL)
2109		return (EIO);
2110	memset(cmd.bytes, 0, 15);
2111	cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
2112	cmd.bytes[6] = s->type;
2113	_lto2b(4 + 2048, &cmd.bytes[7]);
2114
2115	error = scsipi_command(cd->sc_periph, &cmd, 12, bf, 4 + 2048,
2116	    CDRETRIES, 30000, NULL, XS_CTL_DATA_IN);
2117	if (error == 0) {
2118		s->manufact.len = _2btol(&bf[0]);
2119		if (s->manufact.len >= 0 && s->manufact.len <= 2048)
2120			memcpy(s->manufact.value, &bf[4], s->manufact.len);
2121		else
2122			error = EIO;
2123	}
2124	free(bf, M_TEMP);
2125	return error;
2126}
2127
2128static int
2129dvd_read_struct(struct cd_softc *cd, dvd_struct *s)
2130{
2131
2132	switch (s->type) {
2133	case DVD_STRUCT_PHYSICAL:
2134		return (dvd_read_physical(cd, s));
2135	case DVD_STRUCT_COPYRIGHT:
2136		return (dvd_read_copyright(cd, s));
2137	case DVD_STRUCT_DISCKEY:
2138		return (dvd_read_disckey(cd, s));
2139	case DVD_STRUCT_BCA:
2140		return (dvd_read_bca(cd, s));
2141	case DVD_STRUCT_MANUFACT:
2142		return (dvd_read_manufact(cd, s));
2143	default:
2144		return (EINVAL);
2145	}
2146}
2147
2148static int
2149cd_mode_sense(struct cd_softc *cd, u_int8_t byte2, void *sense, size_t size,
2150    int page, int flags, int *big)
2151{
2152
2153	if (cd->sc_periph->periph_quirks & PQUIRK_ONLYBIG) {
2154		*big = 1;
2155		return scsipi_mode_sense_big(cd->sc_periph, byte2, page, sense,
2156		    size + sizeof(struct scsi_mode_parameter_header_10),
2157		    flags, CDRETRIES, 20000);
2158	} else {
2159		*big = 0;
2160		return scsipi_mode_sense(cd->sc_periph, byte2, page, sense,
2161		    size + sizeof(struct scsi_mode_parameter_header_6),
2162		    flags, CDRETRIES, 20000);
2163	}
2164}
2165
2166static int
2167cd_mode_select(struct cd_softc *cd, u_int8_t byte2, void *sense, size_t size,
2168    int flags, int big)
2169{
2170
2171	if (big) {
2172		struct scsi_mode_parameter_header_10 *header = sense;
2173
2174		_lto2b(0, header->data_length);
2175		return scsipi_mode_select_big(cd->sc_periph, byte2, sense,
2176		    size + sizeof(struct scsi_mode_parameter_header_10),
2177		    flags, CDRETRIES, 20000);
2178	} else {
2179		struct scsi_mode_parameter_header_6 *header = sense;
2180
2181		header->data_length = 0;
2182		return scsipi_mode_select(cd->sc_periph, byte2, sense,
2183		    size + sizeof(struct scsi_mode_parameter_header_6),
2184		    flags, CDRETRIES, 20000);
2185	}
2186}
2187
2188static int
2189cd_set_pa_immed(struct cd_softc *cd, int flags)
2190{
2191	struct {
2192		union {
2193			struct scsi_mode_parameter_header_6 small;
2194			struct scsi_mode_parameter_header_10 big;
2195		} header;
2196		struct cd_audio_page page;
2197	} data;
2198	int error;
2199	uint8_t oflags;
2200	int big, byte2;
2201	struct cd_audio_page *page;
2202
2203	byte2 = SMS_DBD;
2204try_again:
2205	if ((error = cd_mode_sense(cd, byte2, &data, sizeof(data.page),
2206	    AUDIO_PAGE, flags, &big)) != 0) {
2207		if (byte2 == SMS_DBD) {
2208			/* Device may not understand DBD; retry without */
2209			byte2 = 0;
2210			goto try_again;
2211		}
2212		return (error);
2213	}
2214
2215	if (big)
2216		page = (void *)((u_long)&data.header.big +
2217				sizeof data.header.big +
2218				_2btol(data.header.big.blk_desc_len));
2219	else
2220		page = (void *)((u_long)&data.header.small +
2221				sizeof data.header.small +
2222				data.header.small.blk_desc_len);
2223
2224	oflags = page->flags;
2225	page->flags &= ~CD_PA_SOTC;
2226	page->flags |= CD_PA_IMMED;
2227	if (oflags == page->flags)
2228		return (0);
2229
2230	return (cd_mode_select(cd, SMS_PF, &data,
2231	    sizeof(struct scsi_mode_page_header) + page->pg_length,
2232	    flags, big));
2233}
2234
2235static int
2236cd_setchan(struct cd_softc *cd, int p0, int p1, int p2, int p3, int flags)
2237{
2238	struct {
2239		union {
2240			struct scsi_mode_parameter_header_6 small;
2241			struct scsi_mode_parameter_header_10 big;
2242		} header;
2243		struct cd_audio_page page;
2244	} data;
2245	int error;
2246	int big, byte2;
2247	struct cd_audio_page *page;
2248
2249	byte2 = SMS_DBD;
2250try_again:
2251	if ((error = cd_mode_sense(cd, byte2, &data, sizeof(data.page),
2252	    AUDIO_PAGE, flags, &big)) != 0) {
2253		if (byte2 == SMS_DBD) {
2254			/* Device may not understand DBD; retry without */
2255			byte2 = 0;
2256			goto try_again;
2257		}
2258		return (error);
2259	}
2260
2261	if (big)
2262		page = (void *)((u_long)&data.header.big +
2263				sizeof data.header.big +
2264				_2btol(data.header.big.blk_desc_len));
2265	else
2266		page = (void *)((u_long)&data.header.small +
2267				sizeof data.header.small +
2268				data.header.small.blk_desc_len);
2269
2270	page->port[0].channels = p0;
2271	page->port[1].channels = p1;
2272	page->port[2].channels = p2;
2273	page->port[3].channels = p3;
2274
2275	return (cd_mode_select(cd, SMS_PF, &data,
2276	    sizeof(struct scsi_mode_page_header) + page->pg_length,
2277	    flags, big));
2278}
2279
2280static int
2281cd_getvol(struct cd_softc *cd, struct ioc_vol *arg, int flags)
2282{
2283	struct {
2284		union {
2285			struct scsi_mode_parameter_header_6 small;
2286			struct scsi_mode_parameter_header_10 big;
2287		} header;
2288		struct cd_audio_page page;
2289	} data;
2290	int error;
2291	int big, byte2;
2292	struct cd_audio_page *page;
2293
2294	byte2 = SMS_DBD;
2295try_again:
2296	if ((error = cd_mode_sense(cd, byte2, &data, sizeof(data.page),
2297	    AUDIO_PAGE, flags, &big)) != 0) {
2298		if (byte2 == SMS_DBD) {
2299			/* Device may not understand DBD; retry without */
2300			byte2 = 0;
2301			goto try_again;
2302		}
2303		return (error);
2304	}
2305
2306	if (big)
2307		page = (void *)((u_long)&data.header.big +
2308				sizeof data.header.big +
2309				_2btol(data.header.big.blk_desc_len));
2310	else
2311		page = (void *)((u_long)&data.header.small +
2312				sizeof data.header.small +
2313				data.header.small.blk_desc_len);
2314
2315	arg->vol[0] = page->port[0].volume;
2316	arg->vol[1] = page->port[1].volume;
2317	arg->vol[2] = page->port[2].volume;
2318	arg->vol[3] = page->port[3].volume;
2319
2320	return (0);
2321}
2322
2323static int
2324cd_setvol(struct cd_softc *cd, const struct ioc_vol *arg, int flags)
2325{
2326	struct {
2327		union {
2328			struct scsi_mode_parameter_header_6 small;
2329			struct scsi_mode_parameter_header_10 big;
2330		} header;
2331		struct cd_audio_page page;
2332	} data, mask;
2333	int error;
2334	int big, byte2;
2335	struct cd_audio_page *page, *page2;
2336
2337	byte2 = SMS_DBD;
2338try_again:
2339	if ((error = cd_mode_sense(cd, byte2, &data, sizeof(data.page),
2340	    AUDIO_PAGE, flags, &big)) != 0) {
2341		if (byte2 == SMS_DBD) {
2342			/* Device may not understand DBD; retry without */
2343			byte2 = 0;
2344			goto try_again;
2345		}
2346		return (error);
2347	}
2348	if ((error = cd_mode_sense(cd, byte2, &mask, sizeof(mask.page),
2349	    AUDIO_PAGE|SMS_PCTRL_CHANGEABLE, flags, &big)) != 0)
2350		return (error);
2351
2352	if (big) {
2353		page = (void *)((u_long)&data.header.big +
2354				sizeof data.header.big +
2355				_2btol(data.header.big.blk_desc_len));
2356		page2 = (void *)((u_long)&mask.header.big +
2357				sizeof mask.header.big +
2358				_2btol(mask.header.big.blk_desc_len));
2359	} else {
2360		page = (void *)((u_long)&data.header.small +
2361				sizeof data.header.small +
2362				data.header.small.blk_desc_len);
2363		page2 = (void *)((u_long)&mask.header.small +
2364				sizeof mask.header.small +
2365				mask.header.small.blk_desc_len);
2366	}
2367
2368	page->port[0].volume = arg->vol[0] & page2->port[0].volume;
2369	page->port[1].volume = arg->vol[1] & page2->port[1].volume;
2370	page->port[2].volume = arg->vol[2] & page2->port[2].volume;
2371	page->port[3].volume = arg->vol[3] & page2->port[3].volume;
2372
2373	page->port[0].channels = CHANNEL_0;
2374	page->port[1].channels = CHANNEL_1;
2375
2376	return (cd_mode_select(cd, SMS_PF, &data,
2377	    sizeof(struct scsi_mode_page_header) + page->pg_length,
2378	    flags, big));
2379}
2380
2381static int
2382cd_load_unload(struct cd_softc *cd, struct ioc_load_unload *args)
2383{
2384	struct scsipi_load_unload cmd;
2385
2386	memset(&cmd, 0, sizeof(cmd));
2387	cmd.opcode = LOAD_UNLOAD;
2388	cmd.options = args->options;    /* ioctl uses MMC values */
2389	cmd.slot = args->slot;
2390
2391	return (scsipi_command(cd->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
2392	    CDRETRIES, 200000, NULL, 0));
2393}
2394
2395static int
2396cd_setblksize(struct cd_softc *cd)
2397{
2398	struct {
2399		union {
2400			struct scsi_mode_parameter_header_6 small;
2401			struct scsi_mode_parameter_header_10 big;
2402		} header;
2403		struct scsi_general_block_descriptor blk_desc;
2404	} data;
2405	int error;
2406	int big, bsize;
2407	struct scsi_general_block_descriptor *bdesc;
2408
2409	if ((error = cd_mode_sense(cd, 0, &data, sizeof(data.blk_desc), 0, 0,
2410	    &big)) != 0)
2411		return (error);
2412
2413	if (big) {
2414		bdesc = (void *)(&data.header.big + 1);
2415		bsize = _2btol(data.header.big.blk_desc_len);
2416	} else {
2417		bdesc = (void *)(&data.header.small + 1);
2418		bsize = data.header.small.blk_desc_len;
2419	}
2420
2421	if (bsize == 0) {
2422		printf("cd_setblksize: trying to change bsize, but no blk_desc\n");
2423
2424		return (EINVAL);
2425	}
2426	if (_3btol(bdesc->blklen) == 2048) {
2427		printf("cd_setblksize: trying to change bsize, but blk_desc is correct\n");
2428		return (EINVAL);
2429	}
2430
2431	_lto3b(2048, bdesc->blklen);
2432
2433	return (cd_mode_select(cd, SMS_PF, &data, sizeof(data.blk_desc), 0,
2434	    big));
2435}
2436
2437
2438static int
2439mmc_profile2class(uint16_t mmc_profile)
2440{
2441	switch (mmc_profile) {
2442	case 0x01 : /* SCSI discs */
2443	case 0x02 :
2444		/* this can't happen really, cd.c wouldn't have matched */
2445		return MMC_CLASS_DISC;
2446	case 0x03 : /* Magneto Optical with sector erase */
2447	case 0x04 : /* Magneto Optical write once        */
2448	case 0x05 : /* Advance Storage Magneto Optical   */
2449		return MMC_CLASS_MO;
2450	case 0x00 : /* Unknown MMC profile, can also be CD-ROM */
2451	case 0x08 : /* CD-ROM  */
2452	case 0x09 : /* CD-R    */
2453	case 0x0a : /* CD-RW   */
2454		return MMC_CLASS_CD;
2455	case 0x10 : /* DVD-ROM */
2456	case 0x11 : /* DVD-R   */
2457	case 0x12 : /* DVD-RAM */
2458	case 0x13 : /* DVD-RW restricted overwrite */
2459	case 0x14 : /* DVD-RW sequential */
2460	case 0x1a : /* DVD+RW  */
2461	case 0x1b : /* DVD+R   */
2462	case 0x2a : /* DVD+RW Dual layer */
2463	case 0x2b : /* DVD+R Dual layer */
2464	case 0x50 : /* HD DVD-ROM */
2465	case 0x51 : /* HD DVD-R   */
2466	case 0x52 : /* HD DVD-RW; DVD-RAM like */
2467		return MMC_CLASS_DVD;
2468	case 0x40 : /* BD-ROM  */
2469	case 0x41 : /* BD-R Sequential recording (SRM) */
2470	case 0x42 : /* BD-R Random Recording (RRM) */
2471	case 0x43 : /* BD-RE */
2472		return MMC_CLASS_BD;
2473	}
2474	return MMC_CLASS_UNKN;
2475}
2476
2477
2478/*
2479 * Drive/media combination is reflected in a series of features that can
2480 * either be current or dormant. We try to make sense out of them to create a
2481 * set of easy to use flags that abstract the device/media capabilities.
2482 */
2483
2484static void
2485mmc_process_feature(struct mmc_discinfo *mmc_discinfo,
2486		    uint16_t feature, int cur, uint8_t *rpos)
2487{
2488	uint32_t blockingnr;
2489	uint64_t flags;
2490
2491	if (cur == 1) {
2492		flags = mmc_discinfo->mmc_cur;
2493	} else {
2494		flags = mmc_discinfo->mmc_cap;
2495	}
2496
2497	switch (feature) {
2498	case 0x0010 :	/* random readable feature */
2499		blockingnr  =  rpos[5] | (rpos[4] << 8);
2500		if (blockingnr > 1)
2501			flags |= MMC_CAP_PACKET;
2502
2503		/* RW error page */
2504		break;
2505	case 0x0020 :	/* random writable feature */
2506		flags |= MMC_CAP_RECORDABLE;
2507		flags |= MMC_CAP_REWRITABLE;
2508		blockingnr  =  rpos[9] | (rpos[8] << 8);
2509		if (blockingnr > 1)
2510			flags |= MMC_CAP_PACKET;
2511		break;
2512	case 0x0021 :	/* incremental streaming write feature */
2513		flags |= MMC_CAP_RECORDABLE;
2514		flags |= MMC_CAP_SEQUENTIAL;
2515		if (cur)
2516			mmc_discinfo->link_block_penalty = rpos[4];
2517		if (rpos[2] & 1)
2518			flags |= MMC_CAP_ZEROLINKBLK;
2519		break;
2520	case 0x0022 : 	/* (obsolete) erase support feature */
2521		flags |= MMC_CAP_RECORDABLE;
2522		flags |= MMC_CAP_ERASABLE;
2523		break;
2524	case 0x0023 :	/* formatting media support feature */
2525		flags |= MMC_CAP_RECORDABLE;
2526		flags |= MMC_CAP_FORMATTABLE;
2527		break;
2528	case 0x0024 :	/* hardware assised defect management feature */
2529		flags |= MMC_CAP_HW_DEFECTFREE;
2530		break;
2531	case 0x0025 : 	/* write once */
2532		flags |= MMC_CAP_RECORDABLE;
2533		break;
2534	case 0x0026 :	/* restricted overwrite feature */
2535		flags |= MMC_CAP_RECORDABLE;
2536		flags |= MMC_CAP_REWRITABLE;
2537		flags |= MMC_CAP_STRICTOVERWRITE;
2538		break;
2539	case 0x0028 :	/* MRW formatted media support feature */
2540		flags |= MMC_CAP_MRW;
2541		break;
2542	case 0x002b :	/* DVD+R read (and opt. write) support */
2543		flags |= MMC_CAP_SEQUENTIAL;
2544		if (rpos[0] & 1) /* write support */
2545			flags |= MMC_CAP_RECORDABLE;
2546		break;
2547	case 0x002c :	/* rigid restricted overwrite feature */
2548		flags |= MMC_CAP_RECORDABLE;
2549		flags |= MMC_CAP_REWRITABLE;
2550		flags |= MMC_CAP_STRICTOVERWRITE;
2551		if (rpos[0] & 1) /* blank bit */
2552			flags |= MMC_CAP_BLANKABLE;
2553		break;
2554	case 0x002d :	/* track at once recording feature */
2555		flags |= MMC_CAP_RECORDABLE;
2556		flags |= MMC_CAP_SEQUENTIAL;
2557		break;
2558	case 0x002f :	/* DVD-R/-RW write feature */
2559		flags |= MMC_CAP_RECORDABLE;
2560		if (rpos[0] & 2) /* DVD-RW bit */
2561			flags |= MMC_CAP_BLANKABLE;
2562		break;
2563	case 0x0038 :	/* BD-R SRM with pseudo overwrite */
2564		flags |= MMC_CAP_PSEUDOOVERWRITE;
2565		break;
2566	default :
2567		/* ignore */
2568		break;
2569	}
2570
2571	if (cur == 1) {
2572		mmc_discinfo->mmc_cur = flags;
2573	} else {
2574		mmc_discinfo->mmc_cap = flags;
2575	}
2576}
2577
2578static int
2579mmc_getdiscinfo_cdrom(struct scsipi_periph *periph,
2580		      struct mmc_discinfo *mmc_discinfo)
2581{
2582	struct scsipi_read_toc      gtoc_cmd;
2583	struct scsipi_toc_header   *toc_hdr;
2584	struct scsipi_toc_msinfo   *toc_msinfo;
2585	const uint32_t buffer_size = 1024;
2586	uint32_t req_size;
2587	uint8_t  *buffer;
2588	int error, flags;
2589
2590	buffer = malloc(buffer_size, M_TEMP, M_WAITOK);
2591	/*
2592	 * Fabricate mmc_discinfo for CD-ROM. Some values are really `dont
2593	 * care' but others might be of interest to programs.
2594	 */
2595
2596	mmc_discinfo->disc_state	 = MMC_STATE_FULL;
2597	mmc_discinfo->last_session_state = MMC_STATE_FULL;
2598	mmc_discinfo->bg_format_state    = MMC_BGFSTATE_COMPLETED;
2599	mmc_discinfo->link_block_penalty = 7;	/* not relevant */
2600
2601	/* get number of sessions and first tracknr in last session */
2602	flags = XS_CTL_DATA_IN;
2603	memset(&gtoc_cmd, 0, sizeof(gtoc_cmd));
2604	gtoc_cmd.opcode      = READ_TOC;
2605	gtoc_cmd.addr_mode   = CD_MSF;		/* not relevant        */
2606	gtoc_cmd.resp_format = CD_TOC_MSINFO;	/* multisession info   */
2607	gtoc_cmd.from_track  = 0;		/* reserved, must be 0 */
2608	req_size = sizeof(*toc_hdr) + sizeof(*toc_msinfo);
2609	_lto2b(req_size, gtoc_cmd.data_len);
2610
2611	error = scsipi_command(periph,
2612		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
2613		(void *)buffer,    req_size,
2614		CDRETRIES, 30000, NULL, flags);
2615	if (error)
2616		goto out;
2617	toc_hdr    = (struct scsipi_toc_header *)  buffer;
2618	toc_msinfo = (struct scsipi_toc_msinfo *) (buffer + 4);
2619	mmc_discinfo->num_sessions = toc_hdr->last - toc_hdr->first + 1;
2620	mmc_discinfo->first_track  = toc_hdr->first;
2621	mmc_discinfo->first_track_last_session = toc_msinfo->tracknr;
2622
2623	/* get last track of last session */
2624	flags = XS_CTL_DATA_IN;
2625	gtoc_cmd.resp_format  = CD_TOC_FORM;	/* formatted toc */
2626	req_size = sizeof(*toc_hdr);
2627	_lto2b(req_size, gtoc_cmd.data_len);
2628
2629	error = scsipi_command(periph,
2630		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
2631		(void *)buffer,    req_size,
2632		CDRETRIES, 30000, NULL, flags);
2633	if (error)
2634		goto out;
2635	toc_hdr    = (struct scsipi_toc_header *) buffer;
2636	mmc_discinfo->last_track_last_session = toc_hdr->last;
2637	mmc_discinfo->num_tracks = toc_hdr->last - toc_hdr->first + 1;
2638
2639	/* TODO how to handle disc_barcode and disc_id */
2640	/* done */
2641
2642out:
2643	free(buffer, M_TEMP);
2644	return error;
2645}
2646
2647static int
2648mmc_getdiscinfo_dvdrom(struct scsipi_periph *periph,
2649		       struct mmc_discinfo *mmc_discinfo)
2650{
2651	struct scsipi_read_toc   gtoc_cmd;
2652	struct scsipi_toc_header toc_hdr;
2653	uint32_t req_size;
2654	int error, flags;
2655
2656	/*
2657	 * Fabricate mmc_discinfo for DVD-ROM. Some values are really `dont
2658	 * care' but others might be of interest to programs.
2659	 */
2660
2661	mmc_discinfo->disc_state	 = MMC_STATE_FULL;
2662	mmc_discinfo->last_session_state = MMC_STATE_FULL;
2663	mmc_discinfo->bg_format_state    = MMC_BGFSTATE_COMPLETED;
2664	mmc_discinfo->link_block_penalty = 16;	/* not relevant */
2665
2666	/* get number of sessions and first tracknr in last session */
2667	flags = XS_CTL_DATA_IN;
2668	memset(&gtoc_cmd, 0, sizeof(gtoc_cmd));
2669	gtoc_cmd.opcode      = READ_TOC;
2670	gtoc_cmd.addr_mode   = 0;		/* LBA                 */
2671	gtoc_cmd.resp_format = CD_TOC_FORM;	/* multisession info   */
2672	gtoc_cmd.from_track  = 1;		/* first track         */
2673	req_size = sizeof(toc_hdr);
2674	_lto2b(req_size, gtoc_cmd.data_len);
2675
2676	error = scsipi_command(periph,
2677		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
2678		(void *)&toc_hdr,  req_size,
2679		CDRETRIES, 30000, NULL, flags);
2680	if (error)
2681		return error;
2682
2683	/* DVD-ROM squashes the track/session space */
2684	mmc_discinfo->num_sessions = toc_hdr.last - toc_hdr.first + 1;
2685	mmc_discinfo->num_tracks   = mmc_discinfo->num_sessions;
2686	mmc_discinfo->first_track  = toc_hdr.first;
2687	mmc_discinfo->first_track_last_session = toc_hdr.last;
2688	mmc_discinfo->last_track_last_session  = toc_hdr.last;
2689
2690	/* TODO how to handle disc_barcode and disc_id */
2691	/* done */
2692	return 0;
2693}
2694
2695static int
2696mmc_getdiscinfo(struct scsipi_periph *periph,
2697		struct mmc_discinfo *mmc_discinfo)
2698{
2699	struct scsipi_get_configuration   gc_cmd;
2700	struct scsipi_get_conf_data      *gc;
2701	struct scsipi_get_conf_feature   *gcf;
2702	struct scsipi_read_discinfo       di_cmd;
2703	struct scsipi_read_discinfo_data  di __aligned(2);
2704	const uint32_t buffer_size = 0x200; /* XXX RPZ USB3 SCSI size issue */
2705	uint32_t pos;
2706	u_long   last_lba = 0;
2707	uint8_t  *buffer, *fpos;
2708	int feature, last_feature, features_len, feature_cur, feature_len;
2709	int lsb, msb, error, flags;
2710
2711	buffer = malloc(buffer_size, M_TEMP, M_WAITOK);
2712
2713	/* initialise structure */
2714	memset(mmc_discinfo, 0, sizeof(struct mmc_discinfo));
2715	mmc_discinfo->mmc_profile = 0x00;	/* unknown */
2716	mmc_discinfo->mmc_class   = MMC_CLASS_UNKN;
2717	mmc_discinfo->mmc_cur     = 0;
2718	mmc_discinfo->mmc_cap     = 0;
2719	mmc_discinfo->link_block_penalty = 0;
2720
2721	/* determine mmc profile and class */
2722	flags = XS_CTL_DATA_IN;
2723	memset(&gc_cmd, 0, sizeof(gc_cmd));
2724	gc_cmd.opcode = GET_CONFIGURATION;
2725	_lto2b(GET_CONF_NO_FEATURES_LEN, gc_cmd.data_len);
2726
2727	gc = (struct scsipi_get_conf_data *) buffer;
2728
2729	error = scsipi_command(periph,
2730		(void *)&gc_cmd, sizeof(gc_cmd),
2731		(void *) gc,     GET_CONF_NO_FEATURES_LEN,
2732		CDRETRIES, 30000, NULL, flags);
2733	if (error)
2734		goto out;
2735
2736	mmc_discinfo->mmc_profile = _2btol(gc->mmc_profile);
2737	mmc_discinfo->mmc_class = mmc_profile2class(mmc_discinfo->mmc_profile);
2738
2739	/* assume 2048 sector size unless told otherwise */
2740	mmc_discinfo->sector_size = 2048;
2741	error = read_cd_capacity(periph, &mmc_discinfo->sector_size, &last_lba);
2742	if (error)
2743		goto out;
2744
2745	mmc_discinfo->last_possible_lba = (uint32_t) last_lba;
2746
2747	/* Read in all features to determine device capabilities */
2748	last_feature = feature = 0;
2749	do {
2750		/* determine mmc profile and class */
2751		flags = XS_CTL_DATA_IN;
2752		memset(&gc_cmd, 0, sizeof(gc_cmd));
2753		gc_cmd.opcode = GET_CONFIGURATION;
2754		_lto2b(last_feature, gc_cmd.start_at_feature);
2755		_lto2b(buffer_size, gc_cmd.data_len);
2756		memset(gc, 0, buffer_size);
2757
2758		error = scsipi_command(periph,
2759			(void *)&gc_cmd, sizeof(gc_cmd),
2760			(void *) gc,     buffer_size,
2761			CDRETRIES, 30000, NULL, flags);
2762		if (error) {
2763			/* ieeek... break out of loop... i dunno what to do */
2764			break;
2765		}
2766
2767		features_len = _4btol(gc->data_len);
2768		if (features_len < 4 || features_len > buffer_size)
2769			break;
2770
2771		pos  = 0;
2772		fpos = &gc->feature_desc[0];
2773		while (pos < features_len - 4) {
2774			gcf = (struct scsipi_get_conf_feature *) fpos;
2775
2776			feature     = _2btol(gcf->featurecode);
2777			feature_cur = gcf->flags & 1;
2778			feature_len = gcf->additional_length;
2779
2780			mmc_process_feature(mmc_discinfo,
2781					    feature, feature_cur,
2782					    gcf->feature_dependent);
2783
2784			last_feature = MAX(last_feature, feature);
2785#ifdef DIAGNOSTIC
2786			/* assert((feature_len & 3) == 0); */
2787			if ((feature_len & 3) != 0) {
2788				printf("feature %d having length %d\n",
2789					feature, feature_len);
2790			}
2791#endif
2792
2793			pos  += 4 + feature_len;
2794			fpos += 4 + feature_len;
2795		}
2796		/* unlikely to ever grow past our 1kb buffer */
2797	} while (features_len >= 0xffff);
2798
2799	/*
2800	 * Fixup CD-RW drives that are on crack.
2801	 *
2802	 * Some drives report the capability to incrementally write
2803	 * sequentially on CD-R(W) media...  nice, but this should not be
2804	 * active for a fixed packet formatted CD-RW media. Other report the
2805	 * ability of HW_DEFECTFREE even when the media is NOT MRW
2806	 * formatted....
2807	 */
2808	if (mmc_discinfo->mmc_profile == 0x0a) {
2809		if ((mmc_discinfo->mmc_cur & MMC_CAP_SEQUENTIAL) == 0)
2810			mmc_discinfo->mmc_cur |= MMC_CAP_STRICTOVERWRITE;
2811		if (mmc_discinfo->mmc_cur & MMC_CAP_STRICTOVERWRITE)
2812			mmc_discinfo->mmc_cur &= ~MMC_CAP_SEQUENTIAL;
2813		if (mmc_discinfo->mmc_cur & MMC_CAP_MRW) {
2814			mmc_discinfo->mmc_cur &= ~MMC_CAP_SEQUENTIAL;
2815			mmc_discinfo->mmc_cur &= ~MMC_CAP_STRICTOVERWRITE;
2816		} else {
2817			mmc_discinfo->mmc_cur &= ~MMC_CAP_HW_DEFECTFREE;
2818		}
2819	}
2820	if (mmc_discinfo->mmc_profile == 0x09) {
2821		mmc_discinfo->mmc_cur &= ~MMC_CAP_REWRITABLE;
2822	}
2823
2824#ifdef DEBUG
2825	printf("CD mmc %d, mmc_cur 0x%"PRIx64", mmc_cap 0x%"PRIx64"\n",
2826		mmc_discinfo->mmc_profile,
2827	 	mmc_discinfo->mmc_cur, mmc_discinfo->mmc_cap);
2828#endif
2829
2830	/* read in disc state and number of sessions and tracks */
2831	flags = XS_CTL_DATA_IN | XS_CTL_SILENT;
2832	memset(&di_cmd, 0, sizeof(di_cmd));
2833	di_cmd.opcode = READ_DISCINFO;
2834	di_cmd.data_len[1] = READ_DISCINFO_BIGSIZE;
2835
2836	error = scsipi_command(periph,
2837		(void *)&di_cmd, sizeof(di_cmd),
2838		(void *)&di,     READ_DISCINFO_BIGSIZE,
2839		CDRETRIES, 30000, NULL, flags);
2840
2841	if (error) {
2842		/* discinfo call failed, emulate for cd-rom/dvd-rom */
2843		if (mmc_discinfo->mmc_profile == 0x08) /* CD-ROM */
2844			error = mmc_getdiscinfo_cdrom(periph, mmc_discinfo);
2845		else if (mmc_discinfo->mmc_profile == 0x10) /* DVD-ROM */
2846			error = mmc_getdiscinfo_dvdrom(periph, mmc_discinfo);
2847		else /* CD/DVD drive is violating specs */
2848			error = EIO;
2849		goto out;
2850	}
2851
2852	/* call went OK */
2853	mmc_discinfo->disc_state         =  di.disc_state & 3;
2854	mmc_discinfo->last_session_state = (di.disc_state >> 2) & 3;
2855	mmc_discinfo->bg_format_state    = (di.disc_state2 & 3);
2856
2857	lsb = di.num_sessions_lsb;
2858	msb = di.num_sessions_msb;
2859	mmc_discinfo->num_sessions = lsb | (msb << 8);
2860
2861	mmc_discinfo->first_track = di.first_track;
2862	lsb = di.first_track_last_session_lsb;
2863	msb = di.first_track_last_session_msb;
2864	mmc_discinfo->first_track_last_session = lsb | (msb << 8);
2865	lsb = di.last_track_last_session_lsb;
2866	msb = di.last_track_last_session_msb;
2867	mmc_discinfo->last_track_last_session  = lsb | (msb << 8);
2868
2869	mmc_discinfo->num_tracks = mmc_discinfo->last_track_last_session -
2870		mmc_discinfo->first_track + 1;
2871
2872	/* set misc. flags and parameters from this disc info */
2873	if (di.disc_state  &  16)
2874		mmc_discinfo->mmc_cur |= MMC_CAP_BLANKABLE;
2875
2876	if (di.disc_state2 & 128) {
2877		mmc_discinfo->disc_id = _4btol(di.discid);
2878		mmc_discinfo->disc_flags |= MMC_DFLAGS_DISCIDVALID;
2879	}
2880	if (di.disc_state2 &  64) {
2881		mmc_discinfo->disc_barcode = _8btol(di.disc_bar_code);
2882		mmc_discinfo->disc_flags |= MMC_DFLAGS_BARCODEVALID;
2883	}
2884	if (di.disc_state2 &  32)
2885		mmc_discinfo->disc_flags |= MMC_DFLAGS_UNRESTRICTED;
2886
2887	if (di.disc_state2 &  16) {
2888		mmc_discinfo->application_code = di.application_code;
2889		mmc_discinfo->disc_flags |= MMC_DFLAGS_APPCODEVALID;
2890	}
2891
2892	/* done */
2893
2894out:
2895	free(buffer, M_TEMP);
2896	return error;
2897}
2898
2899static int
2900mmc_gettrackinfo_cdrom(struct scsipi_periph *periph,
2901		       struct mmc_trackinfo *trackinfo)
2902{
2903	struct scsipi_read_toc            gtoc_cmd;
2904	struct scsipi_toc_header         *toc_hdr;
2905	struct scsipi_toc_rawtoc         *rawtoc;
2906	uint32_t track_start, track_size;
2907	uint32_t last_recorded, next_writable;
2908	uint32_t lba, next_track_start, lead_out;
2909	const uint32_t buffer_size = 4 * 1024;	/* worst case TOC estimate */
2910	uint8_t *buffer;
2911	uint8_t track_sessionnr, sessionnr, adr, tno, point;
2912	uint8_t control, tmin, tsec, tframe, pmin, psec, pframe;
2913	int size, req_size;
2914	int error, flags;
2915
2916	buffer = malloc(buffer_size, M_TEMP, M_WAITOK);
2917
2918	/*
2919	 * Emulate read trackinfo for CD-ROM using the raw-TOC.
2920	 *
2921	 * Not all information is present and this presents a problem.  Track
2922	 * starts are known for each track but other values are deducted.
2923	 *
2924	 * For a complete overview of `magic' values used here, see the
2925	 * SCSI/ATAPI MMC documentation. Note that the `magic' values have no
2926	 * names, they are specified as numbers.
2927	 */
2928
2929	/* get raw toc to process, first header to check size */
2930	flags = XS_CTL_DATA_IN | XS_CTL_SILENT;
2931	memset(&gtoc_cmd, 0, sizeof(gtoc_cmd));
2932	gtoc_cmd.opcode      = READ_TOC;
2933	gtoc_cmd.addr_mode   = CD_MSF;		/* not relevant     */
2934	gtoc_cmd.resp_format = CD_TOC_RAW;	/* raw toc          */
2935	gtoc_cmd.from_track  = 1;		/* first session    */
2936	req_size = sizeof(*toc_hdr);
2937	_lto2b(req_size, gtoc_cmd.data_len);
2938
2939	error = scsipi_command(periph,
2940		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
2941		(void *)buffer,    req_size,
2942		CDRETRIES, 30000, NULL, flags);
2943	if (error)
2944		goto out;
2945	toc_hdr = (struct scsipi_toc_header *) buffer;
2946	if (_2btol(toc_hdr->length) > buffer_size - 2) {
2947#ifdef DIAGNOSTIC
2948		printf("increase buffersize in mmc_readtrackinfo_cdrom\n");
2949#endif
2950		error = ENOBUFS;
2951		goto out;
2952	}
2953
2954	/* read in complete raw toc */
2955	req_size = _2btol(toc_hdr->length);
2956	req_size = 2*((req_size + 1) / 2);	/* for ATAPI */
2957	_lto2b(req_size, gtoc_cmd.data_len);
2958
2959	error = scsipi_command(periph,
2960		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
2961		(void *)buffer,    req_size,
2962		CDRETRIES, 30000, NULL, flags);
2963	if (error)
2964		goto out;
2965
2966	toc_hdr = (struct scsipi_toc_header *) buffer;
2967	rawtoc  = (struct scsipi_toc_rawtoc *) (buffer + 4);
2968
2969	track_start      = 0;
2970	track_size       = 0;
2971	last_recorded    = 0;
2972	next_writable    = 0;
2973	flags            = 0;
2974
2975	next_track_start = 0;
2976	track_sessionnr  = MAXTRACK;	/* by definition */
2977	lead_out         = 0;
2978
2979	size = req_size - sizeof(struct scsipi_toc_header) + 1;
2980	while (size > 0) {
2981		/* get track start and session end */
2982		tno       = rawtoc->tno;
2983		sessionnr = rawtoc->sessionnr;
2984		adr       = rawtoc->adrcontrol >> 4;
2985		control   = rawtoc->adrcontrol & 0xf;
2986		point     = rawtoc->point;
2987		tmin      = rawtoc->min;
2988		tsec      = rawtoc->sec;
2989		tframe    = rawtoc->frame;
2990		pmin      = rawtoc->pmin;
2991		psec      = rawtoc->psec;
2992		pframe    = rawtoc->pframe;
2993
2994		if (tno == 0 && sessionnr && adr == 1) {
2995			lba = hmsf2lba(0, pmin, psec, pframe);
2996			if (point == trackinfo->tracknr) {
2997				track_start = lba;
2998				track_sessionnr = sessionnr;
2999			}
3000			if (point == trackinfo->tracknr + 1) {
3001				/* estimate size */
3002				track_size = lba - track_start;
3003				next_track_start = lba;
3004			}
3005			if (point == 0xa2) {
3006				lead_out = lba;
3007			}
3008			if (point <= 0x63) {
3009				/* CD's ok, DVD are glued */
3010				/* last_tracknr = point; */
3011			}
3012			if (sessionnr == track_sessionnr) {
3013				last_recorded = lead_out;
3014			}
3015		}
3016		if (tno == 0 && sessionnr && adr == 5) {
3017			lba = hmsf2lba(0, tmin, tsec, tframe);
3018			if (sessionnr == track_sessionnr) {
3019				next_writable = lba;
3020			}
3021		}
3022
3023		if ((control & (3<<2)) == 4)		/* 01xxb */
3024			flags |= MMC_TRACKINFO_DATA;
3025		if ((control & (1<<2)) == 0) {		/* x0xxb */
3026			flags |= MMC_TRACKINFO_AUDIO;
3027			if (control & 1)		/* xxx1b */
3028				flags |= MMC_TRACKINFO_PRE_EMPH;
3029		}
3030
3031		rawtoc++;
3032		size -= sizeof(struct scsipi_toc_rawtoc);
3033	}
3034
3035	/* process found values; some voodoo */
3036	/* if no tracksize tracknr is the last of the disc */
3037	if ((track_size == 0) && last_recorded) {
3038		track_size = last_recorded - track_start;
3039	}
3040	/* if last_recorded < tracksize, tracksize is overestimated */
3041	if (last_recorded) {
3042		if (last_recorded - track_start <= track_size) {
3043			track_size = last_recorded - track_start;
3044			flags |= MMC_TRACKINFO_LRA_VALID;
3045		}
3046	}
3047	/* check if its a the last track of the sector */
3048	if (next_writable) {
3049		if (next_track_start > next_writable)
3050			flags |= MMC_TRACKINFO_NWA_VALID;
3051	}
3052
3053	/* no flag set -> no values */
3054	if ((flags & MMC_TRACKINFO_LRA_VALID) == 0)
3055		last_recorded = 0;
3056	if ((flags & MMC_TRACKINFO_NWA_VALID) == 0)
3057		next_writable = 0;
3058
3059	/* fill in */
3060	/* trackinfo->tracknr preserved */
3061	trackinfo->sessionnr  = track_sessionnr;
3062	trackinfo->track_mode = 7;	/* data, incremental  */
3063	trackinfo->data_mode  = 8;	/* 2048 bytes mode1   */
3064
3065	trackinfo->flags = flags;
3066	trackinfo->track_start   = track_start;
3067	trackinfo->next_writable = next_writable;
3068	trackinfo->free_blocks   = 0;
3069	trackinfo->packet_size   = 1;
3070	trackinfo->track_size    = track_size;
3071	trackinfo->last_recorded = last_recorded;
3072
3073out:
3074	free(buffer, M_TEMP);
3075	return error;
3076
3077}
3078
3079static int
3080mmc_gettrackinfo_dvdrom(struct scsipi_periph *periph,
3081			struct mmc_trackinfo *trackinfo)
3082{
3083	struct scsipi_read_toc            gtoc_cmd;
3084	struct scsipi_toc_header         *toc_hdr;
3085	struct scsipi_toc_formatted      *toc;
3086	uint32_t tracknr, track_start, track_size;
3087	uint32_t lba, lead_out;
3088	const uint32_t buffer_size = 4 * 1024;	/* worst case TOC estimate */
3089	uint8_t *buffer;
3090	uint8_t control, last_tracknr;
3091	int size, req_size;
3092	int error, flags;
3093
3094
3095	buffer = malloc(buffer_size, M_TEMP, M_WAITOK);
3096	/*
3097	 * Emulate read trackinfo for DVD-ROM. We can't use the raw-TOC as the
3098	 * CD-ROM emulation uses since the specification tells us that no such
3099	 * thing is defined for DVD's. The reason for this is due to the large
3100	 * number of tracks and that would clash with the `magic' values. This
3101	 * suxs.
3102	 *
3103	 * Not all information is present and this presents a problem.
3104	 * Track starts are known for each track but other values are
3105	 * deducted.
3106	 */
3107
3108	/* get formatted toc to process, first header to check size */
3109	flags = XS_CTL_DATA_IN | XS_CTL_SILENT;
3110	memset(&gtoc_cmd, 0, sizeof(gtoc_cmd));
3111	gtoc_cmd.opcode      = READ_TOC;
3112	gtoc_cmd.addr_mode   = 0;		/* lba's please     */
3113	gtoc_cmd.resp_format = CD_TOC_FORM;	/* formatted toc    */
3114	gtoc_cmd.from_track  = 1;		/* first track      */
3115	req_size = sizeof(*toc_hdr);
3116	_lto2b(req_size, gtoc_cmd.data_len);
3117
3118	error = scsipi_command(periph,
3119		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
3120		(void *)buffer,    req_size,
3121		CDRETRIES, 30000, NULL, flags);
3122	if (error)
3123		goto out;
3124	toc_hdr = (struct scsipi_toc_header *) buffer;
3125	if (_2btol(toc_hdr->length) > buffer_size - 2) {
3126#ifdef DIAGNOSTIC
3127		printf("increase buffersize in mmc_readtrackinfo_dvdrom\n");
3128#endif
3129		error = ENOBUFS;
3130		goto out;
3131	}
3132
3133	/* read in complete formatted toc */
3134	req_size = _2btol(toc_hdr->length);
3135	_lto2b(req_size, gtoc_cmd.data_len);
3136
3137	error = scsipi_command(periph,
3138		(void *)&gtoc_cmd, sizeof(gtoc_cmd),
3139		(void *)buffer,    req_size,
3140		CDRETRIES, 30000, NULL, flags);
3141	if (error)
3142		goto out;
3143
3144	toc_hdr = (struct scsipi_toc_header *)     buffer;
3145	toc     = (struct scsipi_toc_formatted *) (buffer + 4);
3146
3147	/* as in read disc info, all sessions are converted to tracks      */
3148	/* track 1..  -> offsets, sizes can be (roughly) estimated (16 ECC) */
3149	/* last track -> we got the size from the lead-out                 */
3150
3151	tracknr      = 0;
3152	last_tracknr = toc_hdr->last;
3153	track_start  = 0;
3154	track_size   = 0;
3155	lead_out     = 0;
3156	flags        = 0;
3157
3158	size = req_size - sizeof(struct scsipi_toc_header) + 1;
3159	while (size > 0) {
3160		/* remember, DVD-ROM: tracknr == sessionnr */
3161		lba     = _4btol(toc->msf_lba);
3162		tracknr = toc->tracknr;
3163		control = toc->adrcontrol & 0xf;
3164
3165		if (trackinfo->tracknr == tracknr) {
3166			track_start = lba;
3167		}
3168		if (trackinfo->tracknr == tracknr+1) {
3169			track_size  = lba - track_start;
3170			track_size -= 16;	/* link block ? */
3171		}
3172		if (tracknr == 0xAA) {
3173			lead_out = lba;
3174		}
3175
3176		if ((control & (3<<2)) == 4)		/* 01xxb */
3177			flags |= MMC_TRACKINFO_DATA;
3178		if ((control & (1<<2)) == 0) {		/* x0xxb */
3179			flags |= MMC_TRACKINFO_AUDIO;
3180			if (control & (1<<3))		/* 10xxb */
3181				flags |= MMC_TRACKINFO_AUDIO_4CHAN;
3182			if (control & 1)		/* xxx1b */
3183				flags |= MMC_TRACKINFO_PRE_EMPH;
3184		}
3185
3186		toc++;
3187		size -= sizeof(struct scsipi_toc_formatted);
3188	}
3189	if (trackinfo->tracknr == last_tracknr) {
3190		track_size = lead_out - track_start;
3191	}
3192
3193	/* fill in */
3194	/* trackinfo->tracknr preserved */
3195	trackinfo->sessionnr  = trackinfo->tracknr;
3196	trackinfo->track_mode = 0;	/* unknown */
3197	trackinfo->data_mode  = 8;	/* 2048 bytes mode1   */
3198
3199	trackinfo->flags         = flags;
3200	trackinfo->track_start   = track_start;
3201	trackinfo->next_writable = 0;
3202	trackinfo->free_blocks   = 0;
3203	trackinfo->packet_size   = 16;	/* standard length 16 blocks ECC */
3204	trackinfo->track_size    = track_size;
3205	trackinfo->last_recorded = 0;
3206
3207out:
3208	free(buffer, M_TEMP);
3209	return error;
3210}
3211
3212static int
3213mmc_gettrackinfo(struct scsipi_periph *periph,
3214		 struct mmc_trackinfo *trackinfo)
3215{
3216	struct scsipi_read_trackinfo      ti_cmd;
3217	struct scsipi_read_trackinfo_data ti __aligned(2);
3218	struct scsipi_get_configuration   gc_cmd;
3219	struct scsipi_get_conf_data       gc __aligned(2);
3220	int error, flags;
3221	int mmc_profile;
3222
3223	/* set up SCSI call with track number from trackinfo.tracknr */
3224	flags = XS_CTL_DATA_IN | XS_CTL_SILENT;
3225	memset(&ti_cmd, 0, sizeof(ti_cmd));
3226	ti_cmd.opcode    = READ_TRACKINFO;
3227	ti_cmd.addr_type = READ_TRACKINFO_ADDR_TRACK;
3228	ti_cmd.data_len[1] = READ_TRACKINFO_RETURNSIZE;
3229
3230	/* trackinfo.tracknr contains number of tracks to query */
3231	_lto4b(trackinfo->tracknr, ti_cmd.address);
3232	error = scsipi_command(periph,
3233		(void *)&ti_cmd, sizeof(ti_cmd),
3234		(void *)&ti,     READ_TRACKINFO_RETURNSIZE,
3235		CDRETRIES, 30000, NULL, flags);
3236
3237	if (error) {
3238		/* trackinfo call failed, emulate for cd-rom/dvd-rom */
3239		/* first determine mmc profile */
3240		flags = XS_CTL_DATA_IN;
3241		memset(&gc_cmd, 0, sizeof(gc_cmd));
3242		gc_cmd.opcode = GET_CONFIGURATION;
3243		_lto2b(GET_CONF_NO_FEATURES_LEN, gc_cmd.data_len);
3244
3245		error = scsipi_command(periph,
3246			(void *)&gc_cmd, sizeof(gc_cmd),
3247			(void *)&gc,     GET_CONF_NO_FEATURES_LEN,
3248			CDRETRIES, 30000, NULL, flags);
3249		if (error)
3250			return error;
3251		mmc_profile = _2btol(gc.mmc_profile);
3252
3253		/* choose emulation */
3254		if (mmc_profile == 0x08) /* CD-ROM */
3255			return mmc_gettrackinfo_cdrom(periph, trackinfo);
3256		if (mmc_profile == 0x10) /* DVD-ROM */
3257			return mmc_gettrackinfo_dvdrom(periph, trackinfo);
3258		/* CD/DVD drive is violating specs */
3259		return EIO;
3260	}
3261
3262	/* (re)initialise structure */
3263	memset(trackinfo, 0, sizeof(struct mmc_trackinfo));
3264
3265	/* account for short returns screwing up track and session msb */
3266	if ((ti.data_len[1] | (ti.data_len[0] << 8)) <= 32) {
3267		ti.track_msb   = 0;
3268		ti.session_msb = 0;
3269	}
3270
3271	trackinfo->tracknr    = ti.track_lsb   | (ti.track_msb   << 8);
3272	trackinfo->sessionnr  = ti.session_lsb | (ti.session_msb << 8);
3273	trackinfo->track_mode = ti.track_info_1 & 0xf;
3274	trackinfo->data_mode  = ti.track_info_2 & 0xf;
3275
3276	flags = 0;
3277	if (ti.track_info_1 & 0x10)
3278		flags |= MMC_TRACKINFO_COPY;
3279	if (ti.track_info_1 & 0x20)
3280		flags |= MMC_TRACKINFO_DAMAGED;
3281	if (ti.track_info_2 & 0x10)
3282		flags |= MMC_TRACKINFO_FIXED_PACKET;
3283	if (ti.track_info_2 & 0x20)
3284		flags |= MMC_TRACKINFO_INCREMENTAL;
3285	if (ti.track_info_2 & 0x40)
3286		flags |= MMC_TRACKINFO_BLANK;
3287	if (ti.track_info_2 & 0x80)
3288		flags |= MMC_TRACKINFO_RESERVED;
3289	if (ti.data_valid   & 0x01)
3290		flags |= MMC_TRACKINFO_NWA_VALID;
3291	if (ti.data_valid   & 0x02)
3292		flags |= MMC_TRACKINFO_LRA_VALID;
3293	if ((trackinfo->track_mode & (3<<2)) == 4)		/* 01xxb */
3294		flags |= MMC_TRACKINFO_DATA;
3295	if ((trackinfo->track_mode & (1<<2)) == 0) {		/* x0xxb */
3296		flags |= MMC_TRACKINFO_AUDIO;
3297		if (trackinfo->track_mode & (1<<3))		/* 10xxb */
3298			flags |= MMC_TRACKINFO_AUDIO_4CHAN;
3299		if (trackinfo->track_mode & 1)			/* xxx1b */
3300			flags |= MMC_TRACKINFO_PRE_EMPH;
3301	}
3302
3303	trackinfo->flags = flags;
3304	trackinfo->track_start    = _4btol(ti.track_start);
3305	trackinfo->next_writable  = _4btol(ti.next_writable);
3306	trackinfo->free_blocks    = _4btol(ti.free_blocks);
3307	trackinfo->packet_size    = _4btol(ti.packet_size);
3308	trackinfo->track_size     = _4btol(ti.track_size);
3309	trackinfo->last_recorded  = _4btol(ti.last_recorded);
3310
3311	return 0;
3312}
3313
3314static int
3315mmc_doclose(struct scsipi_periph *periph, int param, int func) {
3316	struct scsipi_close_tracksession close_cmd;
3317	int error, flags;
3318
3319	/* set up SCSI call with track number */
3320	flags = XS_CTL_DATA_OUT;
3321	memset(&close_cmd, 0, sizeof(close_cmd));
3322	close_cmd.opcode    = CLOSE_TRACKSESSION;
3323	close_cmd.function  = func;
3324	_lto2b(param, close_cmd.tracksessionnr);
3325
3326	error = scsipi_command(periph,
3327		(void *) &close_cmd, sizeof(close_cmd),
3328		NULL, 0,
3329		CDRETRIES, 120000, NULL, flags);
3330
3331	return error;
3332}
3333
3334static int
3335mmc_do_closetrack(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3336{
3337	int mmc_profile = mmc_op->mmc_profile;
3338
3339	switch (mmc_profile) {
3340	case 0x12 : /* DVD-RAM */
3341	case 0x1a : /* DVD+RW  */
3342	case 0x2a : /* DVD+RW Dual layer */
3343	case 0x42 : /* BD-R Random Recording (RRM) */
3344	case 0x43 : /* BD-RE */
3345	case 0x52 : /* HD DVD-RW ; DVD-RAM like */
3346		return EINVAL;
3347	}
3348
3349	return mmc_doclose(periph, mmc_op->tracknr, 1);
3350}
3351
3352static int
3353mmc_do_close_or_finalise(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3354{
3355	uint8_t blob[MS5LEN], *page5;
3356	int mmc_profile = mmc_op->mmc_profile;
3357	int func, close, flags;
3358	int error;
3359
3360	close = (mmc_op->operation == MMC_OP_CLOSESESSION);
3361
3362	switch (mmc_profile) {
3363	case 0x09 : /* CD-R       */
3364	case 0x0a : /* CD-RW      */
3365		/* Special case : need to update MS field in mode page 5 */
3366		memset(blob, 0, sizeof(blob));
3367		page5 = blob+8;
3368
3369		flags = XS_CTL_DATA_IN;
3370		error = scsipi_mode_sense_big(periph, SMS_PF, 5,
3371		    (void *)blob, sizeof(blob), flags, CDRETRIES, 20000);
3372		if (error)
3373			return error;
3374
3375		/* set multi session field when closing a session only */
3376		page5[3] &= 63;
3377		if (close)
3378			page5[3] |= 3 << 6;
3379
3380		flags = XS_CTL_DATA_OUT;
3381		error = scsipi_mode_select_big(periph, SMS_PF,
3382		    (void *)blob, sizeof(blob), flags, CDRETRIES, 20000);
3383		if (error)
3384			return error;
3385		/* and use function 2 */
3386		func = 2;
3387		break;
3388	case 0x11 : /* DVD-R (DL) */
3389	case 0x13 : /* DVD-RW restricted overwrite */
3390	case 0x14 : /* DVD-RW sequential */
3391		func = close ? 2 : 3;
3392		break;
3393	case 0x1b : /* DVD+R   */
3394	case 0x2b : /* DVD+R Dual layer */
3395	case 0x51 : /* HD DVD-R   */
3396	case 0x41 : /* BD-R Sequential recording (SRM) */
3397		func = close ? 2 : 6;
3398		break;
3399	case 0x12 : /* DVD-RAM */
3400	case 0x1a : /* DVD+RW  */
3401	case 0x2a : /* DVD+RW Dual layer */
3402	case 0x42 : /* BD-R Random Recording (RRM) */
3403	case 0x43 : /* BD-RE */
3404	case 0x52 : /* HD DVD-RW; DVD-RAM like */
3405		return EINVAL;
3406	default:
3407		printf("MMC close/finalise passed wrong device type! (%d)\n",
3408		    mmc_profile);
3409		return EINVAL;
3410	}
3411
3412	return mmc_doclose(periph, mmc_op->sessionnr, func);
3413}
3414
3415static int
3416mmc_do_reserve_track(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3417{
3418	struct scsipi_reserve_track reserve_cmd;
3419	uint32_t extent;
3420	int error, flags;
3421
3422	/* TODO make mmc safeguards? */
3423	extent = mmc_op->extent;
3424	/* TODO min/max support? */
3425
3426	/* set up SCSI call with requested space */
3427	flags = XS_CTL_DATA_OUT;
3428	memset(&reserve_cmd, 0, sizeof(reserve_cmd));
3429	reserve_cmd.opcode = RESERVE_TRACK;
3430	_lto4b(extent, reserve_cmd.reservation_size);
3431
3432	error = scsipi_command(periph,
3433		(void *) &reserve_cmd, sizeof(reserve_cmd),
3434		NULL, 0,
3435		CDRETRIES, 30000, NULL, flags);
3436
3437	return error;
3438}
3439
3440static int
3441mmc_do_reserve_track_nwa(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3442{
3443	/* XXX assumes that NWA given is valid */
3444	switch (mmc_op->mmc_profile) {
3445	case 0x09 : /* CD-R       */
3446		/* XXX unknown boundary checks XXX */
3447		if (mmc_op->extent <= 152)
3448			return EINVAL;
3449		/* CD-R takes 152 sectors to close track */
3450		mmc_op->extent -= 152;
3451		return mmc_do_reserve_track(periph, mmc_op);
3452	case 0x11 : /* DVD-R (DL) */
3453	case 0x1b : /* DVD+R   */
3454	case 0x2b : /* DVD+R Dual layer */
3455		if (mmc_op->extent % 16)
3456			return EINVAL;
3457		/* upto one ECC block of 16 sectors lost */
3458		mmc_op->extent -= 16;
3459		return mmc_do_reserve_track(periph, mmc_op);
3460	case 0x41 : /* BD-R Sequential recording (SRM) */
3461	case 0x51 : /* HD DVD-R   */
3462		if (mmc_op->extent % 32)
3463			return EINVAL;
3464		/* one ECC block of 32 sectors lost (AFAIK) */
3465		mmc_op->extent -= 32;
3466		return mmc_do_reserve_track(periph, mmc_op);
3467	}
3468
3469	/* unknown behaviour or invalid disc type */
3470	return EINVAL;
3471}
3472
3473static int
3474mmc_do_repair_track(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3475{
3476	struct scsipi_repair_track repair_cmd;
3477	int error, flags;
3478
3479	/* TODO make mmc safeguards? */
3480
3481	/* set up SCSI call with track number */
3482	flags = XS_CTL_DATA_OUT;
3483	memset(&repair_cmd, 0, sizeof(repair_cmd));
3484	repair_cmd.opcode = REPAIR_TRACK;
3485	_lto2b(mmc_op->tracknr, repair_cmd.tracknr);
3486
3487	error = scsipi_command(periph,
3488		(void *) &repair_cmd, sizeof(repair_cmd),
3489		NULL, 0,
3490		CDRETRIES, 30000, NULL, flags);
3491
3492	return error;
3493}
3494
3495static int
3496mmc_do_op(struct scsipi_periph *periph, struct mmc_op *mmc_op)
3497{
3498	/* guard operation value */
3499	if (mmc_op->operation < 1 || mmc_op->operation > MMC_OP_MAX)
3500		return EINVAL;
3501
3502	/* synchronise cache is special since it doesn't rely on mmc_profile */
3503	if (mmc_op->operation == MMC_OP_SYNCHRONISECACHE)
3504		return cdcachesync(periph, 0);
3505
3506	/* zero mmc_profile means unknown disc so operations are not defined */
3507	if (mmc_op->mmc_profile == 0) {
3508#ifdef DEBUG
3509		printf("mmc_do_op called with mmc_profile = 0\n");
3510#endif
3511		return EINVAL;
3512	}
3513
3514	/* do the operations */
3515	switch (mmc_op->operation) {
3516	case MMC_OP_CLOSETRACK   :
3517		return mmc_do_closetrack(periph, mmc_op);
3518	case MMC_OP_CLOSESESSION :
3519	case MMC_OP_FINALISEDISC :
3520		return mmc_do_close_or_finalise(periph, mmc_op);
3521	case MMC_OP_RESERVETRACK :
3522		return mmc_do_reserve_track(periph, mmc_op);
3523	case MMC_OP_RESERVETRACK_NWA :
3524		return mmc_do_reserve_track_nwa(periph, mmc_op);
3525	case MMC_OP_REPAIRTRACK  :
3526		return mmc_do_repair_track(periph, mmc_op);
3527	case MMC_OP_UNCLOSELASTSESSION :
3528		/* TODO unclose last session support */
3529		return EINVAL;
3530	default :
3531		printf("mmc_do_op: unhandled operation %d\n", mmc_op->operation);
3532	}
3533
3534	return EINVAL;
3535}
3536
3537static int
3538mmc_setup_writeparams(struct scsipi_periph *periph,
3539		      struct mmc_writeparams *mmc_writeparams)
3540{
3541	struct mmc_trackinfo trackinfo;
3542	uint8_t blob[MS5LEN];
3543	uint8_t *page5;
3544	int flags, error;
3545	int track_mode, data_mode;
3546
3547	/* setup mode page 5 for CD only */
3548	if (mmc_writeparams->mmc_class != MMC_CLASS_CD)
3549		return 0;
3550
3551	memset(blob, 0, sizeof(blob));
3552	page5 = blob+8;
3553
3554	/* read mode page 5 (with header) */
3555	flags = XS_CTL_DATA_IN;
3556	error = scsipi_mode_sense_big(periph, SMS_PF, 5, (void *)blob,
3557	    sizeof(blob), flags, CDRETRIES, 20000);
3558	if (error)
3559		return error;
3560
3561	/* set page length for reassurance */
3562	page5[1] = P5LEN;	/* page length */
3563
3564	/* write type packet/incremental */
3565	page5[2] &= 0xf0;
3566
3567	/* set specified mode parameters */
3568	track_mode = mmc_writeparams->track_mode;
3569	data_mode  = mmc_writeparams->data_mode;
3570	if (track_mode <= 0 || track_mode > 15)
3571		return EINVAL;
3572	if (data_mode < 1 || data_mode > 2)
3573		return EINVAL;
3574
3575	/* if a tracknr is passed, setup according to the track */
3576	if (mmc_writeparams->tracknr > 0) {
3577		trackinfo.tracknr = mmc_writeparams->tracknr;
3578		error = mmc_gettrackinfo(periph, &trackinfo);
3579		if (error)
3580			return error;
3581		if ((trackinfo.flags & MMC_TRACKINFO_BLANK) == 0) {
3582			track_mode = trackinfo.track_mode;
3583			data_mode  = trackinfo.data_mode;
3584		}
3585		mmc_writeparams->blockingnr = trackinfo.packet_size;
3586	}
3587
3588	/* copy track mode and data mode from trackinfo */
3589	page5[3] &= 16;		/* keep only `Copy' bit */
3590	page5[3] |= (3 << 6) | track_mode;
3591	page5[4] &= 0xf0;	/* wipe data block type */
3592	if (data_mode == 1) {
3593		/* select ISO mode 1 (CD only) */
3594		page5[4] |= 8;
3595		/* select session format normal disc (CD only) */
3596		page5[8] = 0;
3597	} else {
3598		/* select ISO mode 2; XA form 1 (CD only) */
3599		page5[4] |= 10;
3600		/* select session format CD-ROM XA disc (CD only) */
3601		page5[8] = 0x20;
3602	}
3603	if (mmc_writeparams->mmc_cur & MMC_CAP_SEQUENTIAL) {
3604		if (mmc_writeparams->mmc_cur & MMC_CAP_ZEROLINKBLK) {
3605			/* set BUFE buffer underrun protection */
3606			page5[2] |= 1<<6;
3607		}
3608		/* allow for multi session */
3609		page5[3] |= 3 << 6;
3610	} else {
3611		/* select fixed packets */
3612		page5[3] |= 1<<5;
3613		_lto4b(mmc_writeparams->blockingnr, &(page5[10]));
3614	}
3615
3616	/* write out updated mode page 5 (with header) */
3617	flags = XS_CTL_DATA_OUT;
3618	error = scsipi_mode_select_big(periph, SMS_PF, (void *)blob,
3619	    sizeof(blob), flags, CDRETRIES, 20000);
3620	if (error)
3621		return error;
3622
3623	return 0;
3624}
3625
3626static void
3627cd_set_geometry(struct cd_softc *cd)
3628{
3629	struct dk_softc *dksc = &cd->sc_dksc;
3630	struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
3631
3632	memset(dg, 0, sizeof(*dg));
3633
3634	dg->dg_secperunit = cd->params.disksize;
3635	dg->dg_secsize = cd->params.blksize;
3636	dg->dg_nsectors = 100;
3637	dg->dg_ntracks = 1;
3638
3639	disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, NULL);
3640}
3641