Annotation of sys/scsi/cd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cd.c,v 1.132 2007/06/20 18:15:47 deraadt Exp $ */
2: /* $NetBSD: cd.c,v 1.100 1997/04/02 02:29:30 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1994, 1995, 1997 Charles M. Hannum. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Charles M. Hannum.
18: * 4. The name of the author may not be used to endorse or promote products
19: * derived from this software without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31: */
32:
33: /*
34: * Originally written by Julian Elischer (julian@tfs.com)
35: * for TRW Financial Systems for use under the MACH(2.5) operating system.
36: *
37: * TRW Financial Systems, in accordance with their agreement with Carnegie
38: * Mellon University, makes this software available to CMU to distribute
39: * or use in any manner that they see fit as long as this message is kept with
40: * the software. For this reason TFS also grants any other persons or
41: * organisations permission to use or modify this software.
42: *
43: * TFS supplies this software to be publicly redistributed
44: * on the understanding that TFS is not responsible for the correct
45: * functioning of this software in any circumstances.
46: *
47: * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
48: */
49:
50: #include <sys/types.h>
51: #include <sys/param.h>
52: #include <sys/systm.h>
53: #include <sys/timeout.h>
54: #include <sys/file.h>
55: #include <sys/stat.h>
56: #include <sys/ioctl.h>
57: #include <sys/mtio.h>
58: #include <sys/buf.h>
59: #include <sys/uio.h>
60: #include <sys/malloc.h>
61: #include <sys/errno.h>
62: #include <sys/device.h>
63: #include <sys/disklabel.h>
64: #include <sys/disk.h>
65: #include <sys/cdio.h>
66: #include <sys/proc.h>
67: #include <sys/conf.h>
68: #include <sys/scsiio.h>
69: #include <sys/vnode.h>
70:
71: #include <scsi/scsi_all.h>
72: #include <scsi/cd.h>
73: #include <scsi/scsi_disk.h> /* rw_big and start_stop come from there */
74: #include <scsi/scsiconf.h>
75:
76:
77: #include <ufs/ffs/fs.h> /* for BBSIZE and SBSIZE */
78:
79: #define CDOUTSTANDING 4
80:
81: #define MAXTRACK 99
82: #define CD_BLOCK_OFFSET 150
83: #define CD_FRAMES 75
84: #define CD_SECS 60
85:
86: struct cd_toc {
87: struct ioc_toc_header header;
88: struct cd_toc_entry entries[MAXTRACK+1]; /* One extra for the */
89: /* leadout */
90: };
91:
92: int cdmatch(struct device *, void *, void *);
93: void cdattach(struct device *, struct device *, void *);
94: int cdactivate(struct device *, enum devact);
95: int cddetach(struct device *, int);
96:
97: void cdstart(void *);
98: void cdrestart(void *);
99: void cdminphys(struct buf *);
100: void cdgetdisklabel(dev_t, struct cd_softc *, struct disklabel *, int);
101: void cddone(struct scsi_xfer *);
102: u_long cd_size(struct cd_softc *, int);
103: void cd_kill_buffers(struct cd_softc *);
104: void lba2msf(u_long, u_char *, u_char *, u_char *);
105: u_long msf2lba(u_char, u_char, u_char);
106: int cd_setchan(struct cd_softc *, int, int, int, int, int);
107: int cd_getvol(struct cd_softc *cd, struct ioc_vol *, int);
108: int cd_setvol(struct cd_softc *, const struct ioc_vol *, int);
109: int cd_load_unload(struct cd_softc *, int, int);
110: int cd_set_pa_immed(struct cd_softc *, int);
111: int cd_play(struct cd_softc *, int, int);
112: int cd_play_tracks(struct cd_softc *, int, int, int, int);
113: int cd_play_msf(struct cd_softc *, int, int, int, int, int, int);
114: int cd_pause(struct cd_softc *, int);
115: int cd_reset(struct cd_softc *);
116: int cd_read_subchannel(struct cd_softc *, int, int, int,
117: struct cd_sub_channel_info *, int );
118: int cd_read_toc(struct cd_softc *, int, int, void *, int, int);
119: int cd_get_parms(struct cd_softc *, int);
120: int cd_load_toc(struct cd_softc *, struct cd_toc *, int);
121: int cd_interpret_sense(struct scsi_xfer *);
122:
123: int dvd_auth(struct cd_softc *, union dvd_authinfo *);
124: int dvd_read_physical(struct cd_softc *, union dvd_struct *);
125: int dvd_read_copyright(struct cd_softc *, union dvd_struct *);
126: int dvd_read_disckey(struct cd_softc *, union dvd_struct *);
127: int dvd_read_bca(struct cd_softc *, union dvd_struct *);
128: int dvd_read_manufact(struct cd_softc *, union dvd_struct *);
129: int dvd_read_struct(struct cd_softc *, union dvd_struct *);
130:
131: void cd_powerhook(int why, void *arg);
132:
133: struct cfattach cd_ca = {
134: sizeof(struct cd_softc), cdmatch, cdattach,
135: cddetach, cdactivate
136: };
137:
138: struct cfdriver cd_cd = {
139: NULL, "cd", DV_DISK
140: };
141:
142: struct dkdriver cddkdriver = { cdstrategy };
143:
144: struct scsi_device cd_switch = {
145: cd_interpret_sense,
146: cdstart, /* we have a queue, which is started by this */
147: NULL, /* we do not have an async handler */
148: cddone, /* deal with stats at interrupt time */
149: };
150:
151: const struct scsi_inquiry_pattern cd_patterns[] = {
152: {T_CDROM, T_REMOV,
153: "", "", ""},
154: {T_WORM, T_REMOV,
155: "", "", ""},
156: {T_DIRECT, T_REMOV,
157: "NEC CD-ROM DRIVE:260", "", ""},
158: #if 0
159: {T_CDROM, T_REMOV, /* more luns */
160: "PIONEER ", "CD-ROM DRM-600 ", ""},
161: #endif
162: };
163:
164: #define cdlock(softc) disk_lock(&(softc)->sc_dk)
165: #define cdunlock(softc) disk_unlock(&(softc)->sc_dk)
166: #define cdlookup(unit) (struct cd_softc *)device_lookup(&cd_cd, (unit))
167:
168: int
169: cdmatch(struct device *parent, void *match, void *aux)
170: {
171: struct scsi_attach_args *sa = aux;
172: int priority;
173:
174: scsi_inqmatch(sa->sa_inqbuf, cd_patterns,
175: sizeof(cd_patterns)/sizeof(cd_patterns[0]), sizeof(cd_patterns[0]),
176: &priority);
177: return (priority);
178: }
179:
180: /*
181: * The routine called by the low level scsi routine when it discovers
182: * A device suitable for this driver
183: */
184: void
185: cdattach(struct device *parent, struct device *self, void *aux)
186: {
187: struct scsi_attach_args *sa = aux;
188: struct scsi_link *sc_link = sa->sa_sc_link;
189: struct cd_softc *cd = (struct cd_softc *)self;
190:
191: SC_DEBUG(sc_link, SDEV_DB2, ("cdattach:\n"));
192:
193: /*
194: * Store information needed to contact our base driver
195: */
196: cd->sc_link = sc_link;
197: sc_link->device = &cd_switch;
198: sc_link->device_softc = cd;
199: if (sc_link->openings > CDOUTSTANDING)
200: sc_link->openings = CDOUTSTANDING;
201:
202: /*
203: * Initialize and attach the disk structure.
204: */
205: cd->sc_dk.dk_driver = &cddkdriver;
206: cd->sc_dk.dk_name = cd->sc_dev.dv_xname;
207: disk_attach(&cd->sc_dk);
208:
209: /*
210: * Note if this device is ancient. This is used in cdminphys().
211: */
212: if (!(sc_link->flags & SDEV_ATAPI) &&
213: SCSISPC(sa->sa_inqbuf->version) == 0)
214: cd->flags |= CDF_ANCIENT;
215:
216: printf("\n");
217:
218: timeout_set(&cd->sc_timeout, cdrestart, cd);
219:
220: if ((cd->sc_cdpwrhook = powerhook_establish(cd_powerhook, cd)) == NULL)
221: printf("%s: WARNING: unable to establish power hook\n",
222: cd->sc_dev.dv_xname);
223: }
224:
225:
226: int
227: cdactivate(struct device *self, enum devact act)
228: {
229: int rv = 0;
230:
231: switch (act) {
232: case DVACT_ACTIVATE:
233: break;
234:
235: case DVACT_DEACTIVATE:
236: /*
237: * Nothing to do; we key off the device's DVF_ACTIVATE.
238: */
239: break;
240: }
241: return (rv);
242: }
243:
244:
245: int
246: cddetach(struct device *self, int flags)
247: {
248: struct cd_softc *cd = (struct cd_softc *)self;
249: int bmaj, cmaj, mn;
250:
251: cd_kill_buffers(cd);
252:
253: /* Locate the lowest minor number to be detached. */
254: mn = DISKMINOR(self->dv_unit, 0);
255:
256: for (bmaj = 0; bmaj < nblkdev; bmaj++)
257: if (bdevsw[bmaj].d_open == cdopen)
258: vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
259: for (cmaj = 0; cmaj < nchrdev; cmaj++)
260: if (cdevsw[cmaj].d_open == cdopen)
261: vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
262:
263: /* Get rid of the power hook. */
264: if (cd->sc_cdpwrhook != NULL)
265: powerhook_disestablish(cd->sc_cdpwrhook);
266:
267: /* Detach disk. */
268: disk_detach(&cd->sc_dk);
269:
270: return (0);
271: }
272:
273: /*
274: * Open the device. Make sure the partition info is as up-to-date as can be.
275: */
276: int
277: cdopen(dev_t dev, int flag, int fmt, struct proc *p)
278: {
279: struct scsi_link *sc_link;
280: struct cd_softc *cd;
281: int error = 0, part, rawopen, unit;
282:
283: unit = DISKUNIT(dev);
284: part = DISKPART(dev);
285:
286: rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
287:
288: cd = cdlookup(unit);
289: if (cd == NULL)
290: return (ENXIO);
291:
292: sc_link = cd->sc_link;
293: SC_DEBUG(sc_link, SDEV_DB1,
294: ("cdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
295: cd_cd.cd_ndevs, part));
296:
297: if ((error = cdlock(cd)) != 0) {
298: device_unref(&cd->sc_dev);
299: return (error);
300: }
301:
302: if (cd->sc_dk.dk_openmask != 0) {
303: /*
304: * If any partition is open, but the disk has been invalidated,
305: * disallow further opens.
306: */
307: if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
308: if (rawopen)
309: goto out;
310: error = EIO;
311: goto bad;
312: }
313: } else {
314: /*
315: * Check that it is still responding and ok. Drive can be in
316: * progress of loading media so use increased retries number
317: * and don't ignore NOT_READY.
318: */
319:
320: /* Use cd_interpret_sense() now. */
321: sc_link->flags |= SDEV_OPEN;
322:
323: error = scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
324: (rawopen ? SCSI_SILENT : 0) | SCSI_IGNORE_ILLEGAL_REQUEST |
325: SCSI_IGNORE_MEDIA_CHANGE);
326:
327: /* Start the cd spinning if necessary. */
328: if (error == EIO)
329: error = scsi_start(sc_link, SSS_START,
330: SCSI_IGNORE_ILLEGAL_REQUEST |
331: SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
332:
333: if (error) {
334: if (rawopen) {
335: error = 0;
336: goto out;
337: } else
338: goto bad;
339: }
340:
341: /* Lock the cd in. */
342: error = scsi_prevent(sc_link, PR_PREVENT,
343: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
344: if (error)
345: goto bad;
346:
347: /* Load the physical device parameters. */
348: sc_link->flags |= SDEV_MEDIA_LOADED;
349: if (cd_get_parms(cd, 0) != 0) {
350: sc_link->flags &= ~SDEV_MEDIA_LOADED;
351: error = ENXIO;
352: goto bad;
353: }
354: SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
355:
356: /* Fabricate a disk label. */
357: cdgetdisklabel(dev, cd, cd->sc_dk.dk_label, 0);
358: SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel fabricated\n"));
359: }
360:
361: /* Check that the partition exists. */
362: if (part != RAW_PART && (part >= cd->sc_dk.dk_label->d_npartitions ||
363: cd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
364: error = ENXIO;
365: goto bad;
366: }
367:
368: out: /* Insure only one open at a time. */
369: switch (fmt) {
370: case S_IFCHR:
371: cd->sc_dk.dk_copenmask |= (1 << part);
372: break;
373: case S_IFBLK:
374: cd->sc_dk.dk_bopenmask |= (1 << part);
375: break;
376: }
377: cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
378: sc_link->flags |= SDEV_OPEN;
379: SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
380:
381: /* It's OK to fall through because dk_openmask is now non-zero. */
382: bad:
383: if (cd->sc_dk.dk_openmask == 0) {
384: scsi_prevent(sc_link, PR_ALLOW,
385: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
386: sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
387: }
388:
389: cdunlock(cd);
390: device_unref(&cd->sc_dev);
391: return (error);
392: }
393:
394: /*
395: * Close the device. Only called if we are the last occurrence of an open
396: * device.
397: */
398: int
399: cdclose(dev_t dev, int flag, int fmt, struct proc *p)
400: {
401: struct cd_softc *cd;
402: int part = DISKPART(dev);
403: int error;
404:
405: cd = cdlookup(DISKUNIT(dev));
406: if (cd == NULL)
407: return ENXIO;
408:
409: if ((error = cdlock(cd)) != 0) {
410: device_unref(&cd->sc_dev);
411: return error;
412: }
413:
414: switch (fmt) {
415: case S_IFCHR:
416: cd->sc_dk.dk_copenmask &= ~(1 << part);
417: break;
418: case S_IFBLK:
419: cd->sc_dk.dk_bopenmask &= ~(1 << part);
420: break;
421: }
422: cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
423:
424: if (cd->sc_dk.dk_openmask == 0) {
425: /* XXXX Must wait for I/O to complete! */
426:
427: scsi_prevent(cd->sc_link, PR_ALLOW,
428: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
429: cd->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
430:
431: if (cd->sc_link->flags & SDEV_EJECTING) {
432: scsi_start(cd->sc_link, SSS_STOP|SSS_LOEJ, 0);
433:
434: cd->sc_link->flags &= ~SDEV_EJECTING;
435: }
436:
437: timeout_del(&cd->sc_timeout);
438: }
439:
440: cdunlock(cd);
441:
442: device_unref(&cd->sc_dev);
443: return 0;
444: }
445:
446: /*
447: * Actually translate the requested transfer into one the physical driver can
448: * understand. The transfer is described by a buf and will include only one
449: * physical transfer.
450: */
451: void
452: cdstrategy(struct buf *bp)
453: {
454: struct cd_softc *cd;
455: int s;
456:
457: if ((cd = cdlookup(DISKUNIT(bp->b_dev))) == NULL) {
458: bp->b_error = ENXIO;
459: goto bad;
460: }
461:
462: SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdstrategy: %ld bytes @ blk %d\n",
463: bp->b_bcount, bp->b_blkno));
464: /*
465: * If the device has been made invalid, error out
466: * maybe the media changed, or no media loaded
467: */
468: if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
469: bp->b_error = EIO;
470: goto bad;
471: }
472: /*
473: * The transfer must be a whole number of blocks.
474: */
475: if ((bp->b_bcount % cd->sc_dk.dk_label->d_secsize) != 0) {
476: bp->b_error = EINVAL;
477: goto bad;
478: }
479: /*
480: * If it's a null transfer, return immediately
481: */
482: if (bp->b_bcount == 0)
483: goto done;
484:
485: /*
486: * Do bounds checking, adjust transfer. if error, process.
487: * If end of partition, just return.
488: */
489: if (DISKPART(bp->b_dev) != RAW_PART &&
490: bounds_check_with_label(bp, cd->sc_dk.dk_label,
491: (cd->flags & (CDF_WLABEL|CDF_LABELLING)) != 0) <= 0)
492: goto done;
493:
494: s = splbio();
495:
496: /*
497: * Place it in the queue of disk activities for this disk
498: */
499: disksort(&cd->buf_queue, bp);
500:
501: /*
502: * Tell the device to get going on the transfer if it's
503: * not doing anything, otherwise just wait for completion
504: */
505: cdstart(cd);
506:
507: device_unref(&cd->sc_dev);
508: splx(s);
509: return;
510:
511: bad:
512: bp->b_flags |= B_ERROR;
513: done:
514: /*
515: * Correctly set the buf to indicate a completed xfer
516: */
517: bp->b_resid = bp->b_bcount;
518: s = splbio();
519: biodone(bp);
520: splx(s);
521: if (cd != NULL)
522: device_unref(&cd->sc_dev);
523: }
524:
525: /*
526: * cdstart looks to see if there is a buf waiting for the device
527: * and that the device is not already busy. If both are true,
528: * It deques the buf and creates a scsi command to perform the
529: * transfer in the buf. The transfer request will call scsi_done
530: * on completion, which will in turn call this routine again
531: * so that the next queued transfer is performed.
532: * The bufs are queued by the strategy routine (cdstrategy)
533: *
534: * This routine is also called after other non-queued requests
535: * have been made of the scsi driver, to ensure that the queue
536: * continues to be drained.
537: *
538: * must be called at the correct (highish) spl level
539: * cdstart() is called at splbio from cdstrategy, cdrestart and scsi_done
540: */
541: void
542: cdstart(void *v)
543: {
544: struct cd_softc *cd = v;
545: struct scsi_link *sc_link = cd->sc_link;
546: struct buf *bp = 0;
547: struct buf *dp;
548: struct scsi_rw_big cmd_big;
549: struct scsi_rw cmd_small;
550: struct scsi_generic *cmdp;
551: int blkno, nblks, cmdlen, error;
552: struct partition *p;
553:
554: splassert(IPL_BIO);
555:
556: SC_DEBUG(sc_link, SDEV_DB2, ("cdstart\n"));
557: /*
558: * Check if the device has room for another command
559: */
560: while (sc_link->openings > 0) {
561: /*
562: * there is excess capacity, but a special waits
563: * It'll need the adapter as soon as we clear out of the
564: * way and let it run (user level wait).
565: */
566: if (sc_link->flags & SDEV_WAITING) {
567: sc_link->flags &= ~SDEV_WAITING;
568: wakeup((caddr_t)sc_link);
569: return;
570: }
571:
572: /*
573: * See if there is a buf with work for us to do..
574: */
575: dp = &cd->buf_queue;
576: if ((bp = dp->b_actf) == NULL) /* yes, an assign */
577: return;
578: dp->b_actf = bp->b_actf;
579:
580: /*
581: * If the deivce has become invalid, abort all the
582: * reads and writes until all files have been closed and
583: * re-opened
584: */
585: if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
586: bp->b_error = EIO;
587: bp->b_flags |= B_ERROR;
588: bp->b_resid = bp->b_bcount;
589: biodone(bp);
590: continue;
591: }
592:
593: /*
594: * We have a buf, now we should make a command
595: *
596: * First, translate the block to absolute and put it in terms
597: * of the logical blocksize of the device.
598: */
599: blkno =
600: bp->b_blkno / (cd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
601: p = &cd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
602: blkno += DL_GETPOFFSET(p);
603: nblks = howmany(bp->b_bcount, cd->sc_dk.dk_label->d_secsize);
604:
605: /*
606: * Fill out the scsi command. If the transfer will
607: * fit in a "small" cdb, use it.
608: */
609: if (!(sc_link->flags & SDEV_ATAPI) &&
610: !(sc_link->quirks & SDEV_ONLYBIG) &&
611: ((blkno & 0x1fffff) == blkno) &&
612: ((nblks & 0xff) == nblks)) {
613: /*
614: * We can fit in a small cdb.
615: */
616: bzero(&cmd_small, sizeof(cmd_small));
617: cmd_small.opcode = (bp->b_flags & B_READ) ?
618: READ_COMMAND : WRITE_COMMAND;
619: _lto3b(blkno, cmd_small.addr);
620: cmd_small.length = nblks & 0xff;
621: cmdlen = sizeof(cmd_small);
622: cmdp = (struct scsi_generic *)&cmd_small;
623: } else {
624: /*
625: * Need a large cdb.
626: */
627: bzero(&cmd_big, sizeof(cmd_big));
628: cmd_big.opcode = (bp->b_flags & B_READ) ?
629: READ_BIG : WRITE_BIG;
630: _lto4b(blkno, cmd_big.addr);
631: _lto2b(nblks, cmd_big.length);
632: cmdlen = sizeof(cmd_big);
633: cmdp = (struct scsi_generic *)&cmd_big;
634: }
635:
636: /* Instrumentation. */
637: disk_busy(&cd->sc_dk);
638:
639: /*
640: * Call the routine that chats with the adapter.
641: * Note: we cannot sleep as we may be an interrupt
642: */
643: error = scsi_scsi_cmd(sc_link, cmdp, cmdlen,
644: (u_char *) bp->b_data, bp->b_bcount, CDRETRIES, 30000, bp,
645: SCSI_NOSLEEP | ((bp->b_flags & B_READ) ? SCSI_DATA_IN :
646: SCSI_DATA_OUT));
647: switch (error) {
648: case 0:
649: timeout_del(&cd->sc_timeout);
650: break;
651: case EAGAIN:
652: /*
653: * The device can't start another i/o. Try again later.
654: */
655: dp->b_actf = bp;
656: disk_unbusy(&cd->sc_dk, 0, 0);
657: timeout_add(&cd->sc_timeout, 1);
658: return;
659: default:
660: disk_unbusy(&cd->sc_dk, 0, 0);
661: printf("%s: not queued, error %d\n",
662: cd->sc_dev.dv_xname, error);
663: break;
664: }
665: }
666: }
667:
668: void
669: cdrestart(void *v)
670: {
671: int s;
672:
673: s = splbio();
674: cdstart(v);
675: splx(s);
676: }
677:
678: void
679: cddone(struct scsi_xfer *xs)
680: {
681: struct cd_softc *cd = xs->sc_link->device_softc;
682:
683: if (xs->bp != NULL)
684: disk_unbusy(&cd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid,
685: (xs->bp->b_flags & B_READ));
686: }
687:
688: void
689: cdminphys(struct buf *bp)
690: {
691: struct cd_softc *cd;
692: long max;
693:
694: cd = cdlookup(DISKUNIT(bp->b_dev));
695: if (cd == NULL)
696: return;
697:
698: /*
699: * If the device is ancient, we want to make sure that
700: * the transfer fits into a 6-byte cdb.
701: *
702: * XXX Note that the SCSI-I spec says that 256-block transfers
703: * are allowed in a 6-byte read/write, and are specified
704: * by setting the "length" to 0. However, we're conservative
705: * here, allowing only 255-block transfers in case an
706: * ancient device gets confused by length == 0. A length of 0
707: * in a 10-byte read/write actually means 0 blocks.
708: */
709: if (cd->flags & CDF_ANCIENT) {
710: max = cd->sc_dk.dk_label->d_secsize * 0xff;
711:
712: if (bp->b_bcount > max)
713: bp->b_bcount = max;
714: }
715:
716: (*cd->sc_link->adapter->scsi_minphys)(bp);
717:
718: device_unref(&cd->sc_dev);
719: }
720:
721: int
722: cdread(dev_t dev, struct uio *uio, int ioflag)
723: {
724:
725: return (physio(cdstrategy, NULL, dev, B_READ, cdminphys, uio));
726: }
727:
728: int
729: cdwrite(dev_t dev, struct uio *uio, int ioflag)
730: {
731:
732: return (physio(cdstrategy, NULL, dev, B_WRITE, cdminphys, uio));
733: }
734:
735: /*
736: * conversion between minute-seconde-frame and logical block address
737: * addresses format
738: */
739: void
740: lba2msf (lba, m, s, f)
741: u_long lba;
742: u_char *m, *s, *f;
743: {
744: u_long tmp;
745:
746: tmp = lba + CD_BLOCK_OFFSET; /* offset of first logical frame */
747: tmp &= 0xffffff; /* negative lbas use only 24 bits */
748: *m = tmp / (CD_SECS * CD_FRAMES);
749: tmp %= (CD_SECS * CD_FRAMES);
750: *s = tmp / CD_FRAMES;
751: *f = tmp % CD_FRAMES;
752: }
753:
754: u_long
755: msf2lba (m, s, f)
756: u_char m, s, f;
757: {
758:
759: return ((((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET);
760: }
761:
762:
763: /*
764: * Perform special action on behalf of the user.
765: * Knows about the internals of this device
766: */
767: int
768: cdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
769: {
770: struct cd_softc *cd;
771: struct disklabel *lp;
772: int part = DISKPART(dev);
773: int error = 0;
774:
775: cd = cdlookup(DISKUNIT(dev));
776: if (cd == NULL)
777: return ENXIO;
778:
779: SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdioctl 0x%lx\n", cmd));
780:
781: /*
782: * If the device is not valid.. abandon ship
783: */
784: if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
785: switch (cmd) {
786: case DIOCWLABEL:
787: case DIOCLOCK:
788: case DIOCEJECT:
789: case SCIOCIDENTIFY:
790: case SCIOCCOMMAND:
791: case SCIOCDEBUG:
792: case CDIOCLOADUNLOAD:
793: case SCIOCRESET:
794: case CDIOCGETVOL:
795: case CDIOCSETVOL:
796: case CDIOCSETMONO:
797: case CDIOCSETSTEREO:
798: case CDIOCSETMUTE:
799: case CDIOCSETLEFT:
800: case CDIOCSETRIGHT:
801: case CDIOCCLOSE:
802: case CDIOCEJECT:
803: case CDIOCALLOW:
804: case CDIOCPREVENT:
805: case CDIOCSETDEBUG:
806: case CDIOCCLRDEBUG:
807: case CDIOCRESET:
808: case DVD_AUTH:
809: case DVD_READ_STRUCT:
810: case MTIOCTOP:
811: if (part == RAW_PART)
812: break;
813: /* FALLTHROUGH */
814: default:
815: if ((cd->sc_link->flags & SDEV_OPEN) == 0)
816: error = ENODEV;
817: else
818: error = EIO;
819: goto exit;
820: }
821: }
822:
823: switch (cmd) {
824: case DIOCRLDINFO:
825: lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
826: cdgetdisklabel(dev, cd, lp, 0);
827: bcopy(lp, cd->sc_dk.dk_label, sizeof(*lp));
828: free(lp, M_TEMP);
829: break;
830: case DIOCGDINFO:
831: case DIOCGPDINFO:
832: *(struct disklabel *)addr = *(cd->sc_dk.dk_label);
833: break;
834:
835: case DIOCGPART:
836: ((struct partinfo *)addr)->disklab = cd->sc_dk.dk_label;
837: ((struct partinfo *)addr)->part =
838: &cd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
839: break;
840:
841: case DIOCWDINFO:
842: case DIOCSDINFO:
843: if ((flag & FWRITE) == 0) {
844: error = EBADF;
845: break;
846: }
847:
848: if ((error = cdlock(cd)) != 0)
849: break;
850:
851: cd->flags |= CDF_LABELLING;
852:
853: error = setdisklabel(cd->sc_dk.dk_label,
854: (struct disklabel *)addr, /*cd->sc_dk.dk_openmask : */0);
855: if (error == 0) {
856: }
857:
858: cd->flags &= ~CDF_LABELLING;
859: cdunlock(cd);
860: break;
861:
862: case DIOCWLABEL:
863: error = EBADF;
864: break;
865:
866: case CDIOCPLAYTRACKS: {
867: struct ioc_play_track *args = (struct ioc_play_track *)addr;
868:
869: if ((error = cd_set_pa_immed(cd, 0)) != 0)
870: break;
871: error = cd_play_tracks(cd, args->start_track,
872: args->start_index, args->end_track, args->end_index);
873: break;
874: }
875: case CDIOCPLAYMSF: {
876: struct ioc_play_msf *args = (struct ioc_play_msf *)addr;
877:
878: if ((error = cd_set_pa_immed(cd, 0)) != 0)
879: break;
880: error = cd_play_msf(cd, args->start_m, args->start_s,
881: args->start_f, args->end_m, args->end_s, args->end_f);
882: break;
883: }
884: case CDIOCPLAYBLOCKS: {
885: struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr;
886:
887: if ((error = cd_set_pa_immed(cd, 0)) != 0)
888: break;
889: error = cd_play(cd, args->blk, args->len);
890: break;
891: }
892: case CDIOCREADSUBCHANNEL: {
893: struct ioc_read_subchannel *args
894: = (struct ioc_read_subchannel *)addr;
895: struct cd_sub_channel_info data;
896: int len = args->data_len;
897: if (len > sizeof(data) ||
898: len < sizeof(struct cd_sub_channel_header)) {
899: error = EINVAL;
900: break;
901: }
902: error = cd_read_subchannel(cd, args->address_format,
903: args->data_format, args->track,
904: &data, len);
905: if (error)
906: break;
907: len = min(len, _2btol(data.header.data_len) +
908: sizeof(struct cd_sub_channel_header));
909: error = copyout(&data, args->data, len);
910: break;
911: }
912: case CDIOREADTOCHEADER: {
913: struct ioc_toc_header th;
914:
915: if ((error = cd_read_toc(cd, 0, 0, &th, sizeof(th), 0)) != 0)
916: break;
917: if (cd->sc_link->quirks & ADEV_LITTLETOC)
918: th.len = letoh16(th.len);
919: else
920: th.len = betoh16(th.len);
921: bcopy(&th, addr, sizeof(th));
922: break;
923: }
924: case CDIOREADTOCENTRYS: {
925: struct cd_toc *toc;
926: struct ioc_read_toc_entry *te =
927: (struct ioc_read_toc_entry *)addr;
928: struct ioc_toc_header *th;
929: struct cd_toc_entry *cte;
930: int len = te->data_len;
931: int ntracks;
932:
933: MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP,
934: M_WAITOK);
935: bzero(toc, sizeof(*toc));
936:
937: th = &toc->header;
938:
939: if (len > sizeof(toc->entries) ||
940: len < sizeof(struct cd_toc_entry)) {
941: FREE(toc, M_TEMP);
942: error = EINVAL;
943: break;
944: }
945: error = cd_read_toc(cd, te->address_format, te->starting_track,
946: toc, len + sizeof(struct ioc_toc_header), 0);
947: if (error) {
948: FREE(toc, M_TEMP);
949: break;
950: }
951: if (te->address_format == CD_LBA_FORMAT)
952: for (ntracks =
953: th->ending_track - th->starting_track + 1;
954: ntracks >= 0; ntracks--) {
955: cte = &toc->entries[ntracks];
956: cte->addr_type = CD_LBA_FORMAT;
957: if (cd->sc_link->quirks & ADEV_LITTLETOC) {
958: #if BYTE_ORDER == BIG_ENDIAN
959: swap16_multi((u_int16_t *)&cte->addr,
960: sizeof(cte->addr) / 2);
961: #endif
962: } else
963: cte->addr.lba = betoh32(cte->addr.lba);
964: }
965: if (cd->sc_link->quirks & ADEV_LITTLETOC) {
966: th->len = letoh16(th->len);
967: } else
968: th->len = betoh16(th->len);
969: len = min(len, th->len - (sizeof(th->starting_track) +
970: sizeof(th->ending_track)));
971:
972: error = copyout(toc->entries, te->data, len);
973: FREE(toc, M_TEMP);
974: break;
975: }
976: case CDIOREADMSADDR: {
977: struct cd_toc *toc;
978: int sessno = *(int *)addr;
979: struct cd_toc_entry *cte;
980:
981: if (sessno != 0) {
982: error = EINVAL;
983: break;
984: }
985:
986: MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP,
987: M_WAITOK);
988: bzero(toc, sizeof(*toc));
989:
990: error = cd_read_toc(cd, 0, 0, toc,
991: sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry),
992: 0x40 /* control word for "get MS info" */);
993:
994: if (error) {
995: FREE(toc, M_TEMP);
996: break;
997: }
998:
999: cte = &toc->entries[0];
1000: if (cd->sc_link->quirks & ADEV_LITTLETOC) {
1001: #if BYTE_ORDER == BIG_ENDIAN
1002: swap16_multi((u_int16_t *)&cte->addr,
1003: sizeof(cte->addr) / 2);
1004: #endif
1005: } else
1006: cte->addr.lba = betoh32(cte->addr.lba);
1007: if (cd->sc_link->quirks & ADEV_LITTLETOC)
1008: toc->header.len = letoh16(toc->header.len);
1009: else
1010: toc->header.len = betoh16(toc->header.len);
1011:
1012: *(int *)addr = (toc->header.len >= 10 && cte->track > 1) ?
1013: cte->addr.lba : 0;
1014: FREE(toc, M_TEMP);
1015: break;
1016: }
1017: case CDIOCSETPATCH: {
1018: struct ioc_patch *arg = (struct ioc_patch *)addr;
1019:
1020: error = cd_setchan(cd, arg->patch[0], arg->patch[1],
1021: arg->patch[2], arg->patch[3], 0);
1022: break;
1023: }
1024: case CDIOCGETVOL: {
1025: struct ioc_vol *arg = (struct ioc_vol *)addr;
1026:
1027: error = cd_getvol(cd, arg, 0);
1028: break;
1029: }
1030: case CDIOCSETVOL: {
1031: struct ioc_vol *arg = (struct ioc_vol *)addr;
1032:
1033: error = cd_setvol(cd, arg, 0);
1034: break;
1035: }
1036:
1037: case CDIOCSETMONO:
1038: error = cd_setchan(cd, BOTH_CHANNEL, BOTH_CHANNEL, MUTE_CHANNEL,
1039: MUTE_CHANNEL, 0);
1040: break;
1041:
1042: case CDIOCSETSTEREO:
1043: error = cd_setchan(cd, LEFT_CHANNEL, RIGHT_CHANNEL,
1044: MUTE_CHANNEL, MUTE_CHANNEL, 0);
1045: break;
1046:
1047: case CDIOCSETMUTE:
1048: error = cd_setchan(cd, MUTE_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL,
1049: MUTE_CHANNEL, 0);
1050: break;
1051:
1052: case CDIOCSETLEFT:
1053: error = cd_setchan(cd, LEFT_CHANNEL, LEFT_CHANNEL, MUTE_CHANNEL,
1054: MUTE_CHANNEL, 0);
1055: break;
1056:
1057: case CDIOCSETRIGHT:
1058: error = cd_setchan(cd, RIGHT_CHANNEL, RIGHT_CHANNEL,
1059: MUTE_CHANNEL, MUTE_CHANNEL, 0);
1060: break;
1061:
1062: case CDIOCRESUME:
1063: error = cd_pause(cd, 1);
1064: break;
1065:
1066: case CDIOCPAUSE:
1067: error = cd_pause(cd, 0);
1068: break;
1069: case CDIOCSTART:
1070: error = scsi_start(cd->sc_link, SSS_START, 0);
1071: break;
1072:
1073: case CDIOCSTOP:
1074: error = scsi_start(cd->sc_link, SSS_STOP, 0);
1075: break;
1076:
1077: close_tray:
1078: case CDIOCCLOSE:
1079: error = scsi_start(cd->sc_link, SSS_START|SSS_LOEJ,
1080: SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE);
1081: break;
1082:
1083: case MTIOCTOP:
1084: if (((struct mtop *)addr)->mt_op == MTRETEN)
1085: goto close_tray;
1086: if (((struct mtop *)addr)->mt_op != MTOFFL) {
1087: error = EIO;
1088: break;
1089: }
1090: /* FALLTHROUGH */
1091: case CDIOCEJECT: /* FALLTHROUGH */
1092: case DIOCEJECT:
1093: cd->sc_link->flags |= SDEV_EJECTING;
1094: break;
1095: case CDIOCALLOW:
1096: error = scsi_prevent(cd->sc_link, PR_ALLOW, 0);
1097: break;
1098: case CDIOCPREVENT:
1099: error = scsi_prevent(cd->sc_link, PR_PREVENT, 0);
1100: break;
1101: case DIOCLOCK:
1102: error = scsi_prevent(cd->sc_link,
1103: (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
1104: break;
1105: case CDIOCSETDEBUG:
1106: cd->sc_link->flags |= (SDEV_DB1 | SDEV_DB2);
1107: break;
1108: case CDIOCCLRDEBUG:
1109: cd->sc_link->flags &= ~(SDEV_DB1 | SDEV_DB2);
1110: break;
1111: case CDIOCRESET:
1112: case SCIOCRESET:
1113: error = cd_reset(cd);
1114: break;
1115: case CDIOCLOADUNLOAD: {
1116: struct ioc_load_unload *args = (struct ioc_load_unload *)addr;
1117:
1118: error = cd_load_unload(cd, args->options, args->slot);
1119: break;
1120: }
1121:
1122: case DVD_AUTH:
1123: error = dvd_auth(cd, (union dvd_authinfo *)addr);
1124: break;
1125: case DVD_READ_STRUCT:
1126: error = dvd_read_struct(cd, (union dvd_struct *)addr);
1127: break;
1128: default:
1129: if (DISKPART(dev) != RAW_PART) {
1130: error = ENOTTY;
1131: break;
1132: }
1133: error = scsi_do_ioctl(cd->sc_link, dev, cmd, addr, flag, p);
1134: break;
1135: }
1136:
1137: exit:
1138:
1139: device_unref(&cd->sc_dev);
1140: return (error);
1141: }
1142:
1143: /*
1144: * Load the label information on the named device
1145: * Actually fabricate a disklabel
1146: *
1147: * EVENTUALLY take information about different
1148: * data tracks from the TOC and put it in the disklabel
1149: */
1150: void
1151: cdgetdisklabel(dev_t dev, struct cd_softc *cd, struct disklabel *lp,
1152: int spoofonly)
1153: {
1154: struct cd_toc *toc;
1155: char *errstring;
1156: int tocidx, n, audioonly = 1;
1157:
1158: bzero(lp, sizeof(struct disklabel));
1159:
1160: MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP, M_WAITOK);
1161: bzero(toc, sizeof(*toc));
1162:
1163: lp->d_secsize = cd->params.blksize;
1164: lp->d_ntracks = 1;
1165: lp->d_nsectors = 100;
1166: lp->d_secpercyl = 100;
1167: lp->d_ncylinders = (cd->params.disksize / 100) + 1;
1168:
1169: if (cd->sc_link->flags & SDEV_ATAPI) {
1170: strncpy(lp->d_typename, "ATAPI CD-ROM", sizeof(lp->d_typename));
1171: lp->d_type = DTYPE_ATAPI;
1172: } else {
1173: strncpy(lp->d_typename, "SCSI CD-ROM", sizeof(lp->d_typename));
1174: lp->d_type = DTYPE_SCSI;
1175: }
1176:
1177: strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
1178: DL_SETDSIZE(lp, cd->params.disksize);
1179: lp->d_rpm = 300;
1180: lp->d_interleave = 1;
1181: lp->d_version = 1;
1182:
1183: /* XXX - these values for BBSIZE and SBSIZE assume ffs */
1184: lp->d_bbsize = BBSIZE;
1185: lp->d_sbsize = SBSIZE;
1186:
1187: lp->d_magic = DISKMAGIC;
1188: lp->d_magic2 = DISKMAGIC;
1189: lp->d_checksum = dkcksum(lp);
1190:
1191: if (cd_load_toc(cd, toc, CD_LBA_FORMAT)) {
1192: audioonly = 0; /* No valid TOC found == not an audio CD. */
1193: goto done;
1194: }
1195:
1196: n = toc->header.ending_track - toc->header.starting_track + 1;
1197: for (tocidx = 0; tocidx < n; tocidx++)
1198: if (toc->entries[tocidx].control & 4) {
1199: audioonly = 0; /* Found a non-audio track. */
1200: goto done;
1201: }
1202:
1203: done:
1204: free(toc, M_TEMP);
1205:
1206: if (!audioonly) {
1207: errstring = readdisklabel(DISKLABELDEV(dev), cdstrategy, lp,
1208: spoofonly);
1209: /*if (errstring)
1210: printf("%s: %s\n", cd->sc_dev.dv_xname, errstring);*/
1211: }
1212: }
1213:
1214: /*
1215: * Find out from the device what its capacity is
1216: */
1217: u_long
1218: cd_size(struct cd_softc *cd, int flags)
1219: {
1220: struct scsi_read_cd_cap_data rdcap;
1221: struct scsi_read_cd_capacity scsi_cmd;
1222: u_long size;
1223: int blksize;
1224:
1225: /* Reasonable defaults for drives that don't support
1226: READ_CD_CAPACITY */
1227: cd->params.blksize = 2048;
1228: cd->params.disksize = 400000;
1229:
1230: if (cd->sc_link->quirks & ADEV_NOCAPACITY)
1231: goto exit;
1232:
1233: /*
1234: * make up a scsi command and ask the scsi driver to do
1235: * it for you.
1236: */
1237: bzero(&scsi_cmd, sizeof(scsi_cmd));
1238: scsi_cmd.opcode = READ_CD_CAPACITY;
1239:
1240: /*
1241: * If the command works, interpret the result as a 4 byte
1242: * number of blocks and a blocksize
1243: */
1244: if (scsi_scsi_cmd(cd->sc_link,
1245: (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
1246: (u_char *)&rdcap, sizeof(rdcap), CDRETRIES, 20000, NULL,
1247: flags | SCSI_DATA_IN) != 0)
1248: goto exit;
1249:
1250: blksize = _4btol(rdcap.length);
1251: if ((blksize < 512) || ((blksize & 511) != 0))
1252: blksize = 2048; /* some drives lie ! */
1253: cd->params.blksize = blksize;
1254:
1255: size = _4btol(rdcap.addr) + 1;
1256: if (size < 100)
1257: size = 400000; /* ditto */
1258: cd->params.disksize = size;
1259:
1260: exit:
1261: SC_DEBUG(cd->sc_link, SDEV_DB2, ("cd_size: %d %ld\n", blksize, size));
1262: return (cd->params.disksize);
1263: }
1264:
1265: int
1266: cd_setchan(struct cd_softc *cd, int p0, int p1, int p2, int p3, int flags)
1267: {
1268: union scsi_mode_sense_buf *data;
1269: struct cd_audio_page *audio = NULL;
1270: int error, big;
1271:
1272: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
1273: if (data == NULL)
1274: return (ENOMEM);
1275:
1276: error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
1277: (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
1278: if (error == 0 && audio == NULL)
1279: error = EIO;
1280:
1281: if (error == 0) {
1282: audio->port[LEFT_PORT].channels = p0;
1283: audio->port[RIGHT_PORT].channels = p1;
1284: audio->port[2].channels = p2;
1285: audio->port[3].channels = p3;
1286: if (big)
1287: error = scsi_mode_select_big(cd->sc_link, SMS_PF,
1288: &data->hdr_big, flags, 20000);
1289: else
1290: error = scsi_mode_select(cd->sc_link, SMS_PF,
1291: &data->hdr, flags, 20000);
1292: }
1293:
1294: free(data, M_TEMP);
1295: return (error);
1296: }
1297:
1298: int
1299: cd_getvol(struct cd_softc *cd, struct ioc_vol *arg, int flags)
1300: {
1301: union scsi_mode_sense_buf *data;
1302: struct cd_audio_page *audio = NULL;
1303: int error;
1304:
1305: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
1306: if (data == NULL)
1307: return (ENOMEM);
1308:
1309: error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
1310: (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, NULL);
1311: if (error == 0 && audio == NULL)
1312: error = EIO;
1313:
1314: if (error == 0) {
1315: arg->vol[0] = audio->port[0].volume;
1316: arg->vol[1] = audio->port[1].volume;
1317: arg->vol[2] = audio->port[2].volume;
1318: arg->vol[3] = audio->port[3].volume;
1319: }
1320:
1321: free(data, M_TEMP);
1322: return (0);
1323: }
1324:
1325: int
1326: cd_setvol(struct cd_softc *cd, const struct ioc_vol *arg, int flags)
1327: {
1328: union scsi_mode_sense_buf *data;
1329: struct cd_audio_page *audio = NULL;
1330: u_int8_t mask_volume[4];
1331: int error, big;
1332:
1333: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
1334: if (data == NULL)
1335: return (ENOMEM);
1336:
1337: error = scsi_do_mode_sense(cd->sc_link,
1338: AUDIO_PAGE | SMS_PAGE_CTRL_CHANGEABLE, data, (void **)&audio, NULL,
1339: NULL, NULL, sizeof(*audio), flags, NULL);
1340: if (error == 0 && audio == NULL)
1341: error = EIO;
1342: if (error != 0) {
1343: free(data, M_TEMP);
1344: return (error);
1345: }
1346:
1347: mask_volume[0] = audio->port[0].volume;
1348: mask_volume[1] = audio->port[1].volume;
1349: mask_volume[2] = audio->port[2].volume;
1350: mask_volume[3] = audio->port[3].volume;
1351:
1352: error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
1353: (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
1354: if (error == 0 && audio == NULL)
1355: error = EIO;
1356: if (error != 0) {
1357: free(data, M_TEMP);
1358: return (error);
1359: }
1360:
1361: audio->port[0].volume = arg->vol[0] & mask_volume[0];
1362: audio->port[1].volume = arg->vol[1] & mask_volume[1];
1363: audio->port[2].volume = arg->vol[2] & mask_volume[2];
1364: audio->port[3].volume = arg->vol[3] & mask_volume[3];
1365:
1366: if (big)
1367: error = scsi_mode_select_big(cd->sc_link, SMS_PF,
1368: &data->hdr_big, flags, 20000);
1369: else
1370: error = scsi_mode_select(cd->sc_link, SMS_PF,
1371: &data->hdr, flags, 20000);
1372:
1373: free(data, M_TEMP);
1374: return (error);
1375: }
1376:
1377: int
1378: cd_load_unload(struct cd_softc *cd, int options, int slot)
1379: {
1380: struct scsi_load_unload cmd;
1381:
1382: bzero(&cmd, sizeof(cmd));
1383: cmd.opcode = LOAD_UNLOAD;
1384: cmd.options = options; /* ioctl uses ATAPI values */
1385: cmd.slot = slot;
1386:
1387: return (scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
1388: sizeof(cmd), 0, 0, CDRETRIES, 200000, NULL, 0));
1389: }
1390:
1391: int
1392: cd_set_pa_immed(struct cd_softc *cd, int flags)
1393: {
1394: union scsi_mode_sense_buf *data;
1395: struct cd_audio_page *audio = NULL;
1396: int error, oflags, big;
1397:
1398: if (cd->sc_link->flags & SDEV_ATAPI)
1399: /* XXX Noop? */
1400: return (0);
1401:
1402: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
1403: if (data == NULL)
1404: return (ENOMEM);
1405:
1406: error = scsi_do_mode_sense(cd->sc_link, AUDIO_PAGE, data,
1407: (void **)&audio, NULL, NULL, NULL, sizeof(*audio), flags, &big);
1408: if (error == 0 && audio == NULL)
1409: error = EIO;
1410:
1411: if (error == 0) {
1412: oflags = audio->flags;
1413: audio->flags &= ~CD_PA_SOTC;
1414: audio->flags |= CD_PA_IMMED;
1415: if (audio->flags != oflags) {
1416: if (big)
1417: error = scsi_mode_select_big(cd->sc_link,
1418: SMS_PF, &data->hdr_big, flags,
1419: 20000);
1420: else
1421: error = scsi_mode_select(cd->sc_link, SMS_PF,
1422: &data->hdr, flags, 20000);
1423: }
1424: }
1425:
1426: free(data, M_TEMP);
1427: return (error);
1428: }
1429:
1430: /*
1431: * Get scsi driver to send a "start playing" command
1432: */
1433: int
1434: cd_play(struct cd_softc *cd, int blkno, int nblks)
1435: {
1436: struct scsi_play scsi_cmd;
1437:
1438: bzero(&scsi_cmd, sizeof(scsi_cmd));
1439: scsi_cmd.opcode = PLAY;
1440: _lto4b(blkno, scsi_cmd.blk_addr);
1441: _lto2b(nblks, scsi_cmd.xfer_len);
1442: return (scsi_scsi_cmd(cd->sc_link,
1443: (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
1444: 0, 0, CDRETRIES, 200000, NULL, 0));
1445: }
1446:
1447: /*
1448: * Get scsi driver to send a "start playing" command
1449: */
1450: int
1451: cd_play_tracks(struct cd_softc *cd, int strack, int sindex, int etrack,
1452: int eindex)
1453: {
1454: struct cd_toc *toc;
1455: u_char endf, ends, endm;
1456: int error;
1457:
1458: if (!etrack)
1459: return (EIO);
1460: if (strack > etrack)
1461: return (EINVAL);
1462:
1463: MALLOC(toc, struct cd_toc *, sizeof(struct cd_toc), M_TEMP, M_WAITOK);
1464: bzero(toc, sizeof(*toc));
1465:
1466: if ((error = cd_load_toc(cd, toc, CD_MSF_FORMAT)) != 0)
1467: goto done;
1468:
1469: if (++etrack > (toc->header.ending_track+1))
1470: etrack = toc->header.ending_track+1;
1471:
1472: strack -= toc->header.starting_track;
1473: etrack -= toc->header.starting_track;
1474: if (strack < 0) {
1475: error = EINVAL;
1476: goto done;
1477: }
1478:
1479: /*
1480: * The track ends one frame before the next begins. The last track
1481: * is taken care of by the leadoff track.
1482: */
1483: endm = toc->entries[etrack].addr.msf.minute;
1484: ends = toc->entries[etrack].addr.msf.second;
1485: endf = toc->entries[etrack].addr.msf.frame;
1486: if (endf-- == 0) {
1487: endf = CD_FRAMES - 1;
1488: if (ends-- == 0) {
1489: ends = CD_SECS - 1;
1490: if (endm-- == 0) {
1491: error = EINVAL;
1492: goto done;
1493: }
1494: }
1495: }
1496:
1497: error = cd_play_msf(cd, toc->entries[strack].addr.msf.minute,
1498: toc->entries[strack].addr.msf.second,
1499: toc->entries[strack].addr.msf.frame,
1500: endm, ends, endf);
1501:
1502: done:
1503: FREE(toc, M_TEMP);
1504: return (error);
1505: }
1506:
1507: /*
1508: * Get scsi driver to send a "play msf" command
1509: */
1510: int
1511: cd_play_msf(struct cd_softc *cd, int startm, int starts, int startf, int endm,
1512: int ends, int endf)
1513: {
1514: struct scsi_play_msf scsi_cmd;
1515:
1516: bzero(&scsi_cmd, sizeof(scsi_cmd));
1517: scsi_cmd.opcode = PLAY_MSF;
1518: scsi_cmd.start_m = startm;
1519: scsi_cmd.start_s = starts;
1520: scsi_cmd.start_f = startf;
1521: scsi_cmd.end_m = endm;
1522: scsi_cmd.end_s = ends;
1523: scsi_cmd.end_f = endf;
1524: return (scsi_scsi_cmd(cd->sc_link,
1525: (struct scsi_generic *)&scsi_cmd, sizeof(scsi_cmd),
1526: 0, 0, CDRETRIES, 20000, NULL, 0));
1527: }
1528:
1529: /*
1530: * Get scsi driver to send a "start up" command
1531: */
1532: int
1533: cd_pause(struct cd_softc *cd, int go)
1534: {
1535: struct scsi_pause scsi_cmd;
1536:
1537: bzero(&scsi_cmd, sizeof(scsi_cmd));
1538: scsi_cmd.opcode = PAUSE;
1539: scsi_cmd.resume = go;
1540: return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
1541: sizeof(scsi_cmd), 0, 0, CDRETRIES, 2000, NULL, 0);
1542: }
1543:
1544: /*
1545: * Get scsi driver to send a "RESET" command
1546: */
1547: int
1548: cd_reset(struct cd_softc *cd)
1549: {
1550: return scsi_scsi_cmd(cd->sc_link, 0, 0, 0, 0, CDRETRIES, 2000, NULL,
1551: SCSI_RESET);
1552: }
1553:
1554: /*
1555: * Read subchannel
1556: */
1557: int
1558: cd_read_subchannel(struct cd_softc *cd, int mode, int format, int track,
1559: struct cd_sub_channel_info *data, int len)
1560: {
1561: struct scsi_read_subchannel scsi_cmd;
1562:
1563: bzero(&scsi_cmd, sizeof(scsi_cmd));
1564: scsi_cmd.opcode = READ_SUBCHANNEL;
1565: if (mode == CD_MSF_FORMAT)
1566: scsi_cmd.byte2 |= CD_MSF;
1567: scsi_cmd.byte3 = SRS_SUBQ;
1568: scsi_cmd.subchan_format = format;
1569: scsi_cmd.track = track;
1570: _lto2b(len, scsi_cmd.data_len);
1571: return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
1572: sizeof(struct scsi_read_subchannel), (u_char *)data, len,
1573: CDRETRIES, 5000, NULL, SCSI_DATA_IN|SCSI_SILENT);
1574: }
1575:
1576: /*
1577: * Read table of contents
1578: */
1579: int
1580: cd_read_toc(struct cd_softc *cd, int mode, int start, void *data, int len,
1581: int control)
1582: {
1583: struct scsi_read_toc scsi_cmd;
1584:
1585: bzero(&scsi_cmd, sizeof(scsi_cmd));
1586: bzero(data, len);
1587:
1588: scsi_cmd.opcode = READ_TOC;
1589: if (mode == CD_MSF_FORMAT)
1590: scsi_cmd.byte2 |= CD_MSF;
1591: scsi_cmd.from_track = start;
1592: _lto2b(len, scsi_cmd.data_len);
1593: scsi_cmd.control = control;
1594:
1595: return scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&scsi_cmd,
1596: sizeof(struct scsi_read_toc), (u_char *)data, len, CDRETRIES,
1597: 5000, NULL, SCSI_DATA_IN | SCSI_IGNORE_ILLEGAL_REQUEST);
1598: }
1599:
1600: int
1601: cd_load_toc(struct cd_softc *cd, struct cd_toc *toc, int fmt)
1602: {
1603: int n, len, error;
1604:
1605: error = cd_read_toc(cd, 0, 0, toc, sizeof(toc->header), 0);
1606:
1607: if (error == 0) {
1608: if (toc->header.ending_track < toc->header.starting_track)
1609: return (EIO);
1610: /* +2 to account for leading out track. */
1611: n = toc->header.ending_track - toc->header.starting_track + 2;
1612: len = n * sizeof(struct cd_toc_entry) + sizeof(toc->header);
1613: error = cd_read_toc(cd, fmt, 0, toc, len, 0);
1614: }
1615:
1616: return (error);
1617: }
1618:
1619:
1620: /*
1621: * Get the scsi driver to send a full inquiry to the device and use the
1622: * results to fill out the disk parameter structure.
1623: */
1624: int
1625: cd_get_parms(struct cd_softc *cd, int flags)
1626: {
1627: /*
1628: * give a number of sectors so that sec * trks * cyls
1629: * is <= disk_size
1630: */
1631: if (cd_size(cd, flags) == 0)
1632: return (ENXIO);
1633: return (0);
1634: }
1635:
1636: daddr64_t
1637: cdsize(dev_t dev)
1638: {
1639:
1640: /* CD-ROMs are read-only. */
1641: return -1;
1642: }
1643:
1644: int
1645: cddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
1646: {
1647: /* Not implemented. */
1648: return ENXIO;
1649: }
1650:
1651: #define dvd_copy_key(dst, src) bcopy((src), (dst), DVD_KEY_SIZE)
1652: #define dvd_copy_challenge(dst, src) bcopy((src), (dst), DVD_CHALLENGE_SIZE)
1653:
1654: int
1655: dvd_auth(struct cd_softc *cd, union dvd_authinfo *a)
1656: {
1657: struct scsi_generic cmd;
1658: u_int8_t buf[20];
1659: int error;
1660:
1661: bzero(cmd.bytes, sizeof(cmd.bytes));
1662: bzero(buf, sizeof(buf));
1663:
1664: switch (a->type) {
1665: case DVD_LU_SEND_AGID:
1666: cmd.opcode = GPCMD_REPORT_KEY;
1667: cmd.bytes[8] = 8;
1668: cmd.bytes[9] = 0 | (0 << 6);
1669: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
1670: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1671: if (error)
1672: return (error);
1673: a->lsa.agid = buf[7] >> 6;
1674: return (0);
1675:
1676: case DVD_LU_SEND_CHALLENGE:
1677: cmd.opcode = GPCMD_REPORT_KEY;
1678: cmd.bytes[8] = 16;
1679: cmd.bytes[9] = 1 | (a->lsc.agid << 6);
1680: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
1681: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1682: if (error)
1683: return (error);
1684: dvd_copy_challenge(a->lsc.chal, &buf[4]);
1685: return (0);
1686:
1687: case DVD_LU_SEND_KEY1:
1688: cmd.opcode = GPCMD_REPORT_KEY;
1689: cmd.bytes[8] = 12;
1690: cmd.bytes[9] = 2 | (a->lsk.agid << 6);
1691: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
1692: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1693: if (error)
1694: return (error);
1695: dvd_copy_key(a->lsk.key, &buf[4]);
1696: return (0);
1697:
1698: case DVD_LU_SEND_TITLE_KEY:
1699: cmd.opcode = GPCMD_REPORT_KEY;
1700: _lto4b(a->lstk.lba, &cmd.bytes[1]);
1701: cmd.bytes[8] = 12;
1702: cmd.bytes[9] = 4 | (a->lstk.agid << 6);
1703: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
1704: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1705: if (error)
1706: return (error);
1707: a->lstk.cpm = (buf[4] >> 7) & 1;
1708: a->lstk.cp_sec = (buf[4] >> 6) & 1;
1709: a->lstk.cgms = (buf[4] >> 4) & 3;
1710: dvd_copy_key(a->lstk.title_key, &buf[5]);
1711: return (0);
1712:
1713: case DVD_LU_SEND_ASF:
1714: cmd.opcode = GPCMD_REPORT_KEY;
1715: cmd.bytes[8] = 8;
1716: cmd.bytes[9] = 5 | (a->lsasf.agid << 6);
1717: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
1718: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1719: if (error)
1720: return (error);
1721: a->lsasf.asf = buf[7] & 1;
1722: return (0);
1723:
1724: case DVD_HOST_SEND_CHALLENGE:
1725: cmd.opcode = GPCMD_SEND_KEY;
1726: cmd.bytes[8] = 16;
1727: cmd.bytes[9] = 1 | (a->hsc.agid << 6);
1728: buf[1] = 14;
1729: dvd_copy_challenge(&buf[4], a->hsc.chal);
1730: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
1731: CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
1732: if (error)
1733: return (error);
1734: a->type = DVD_LU_SEND_KEY1;
1735: return (0);
1736:
1737: case DVD_HOST_SEND_KEY2:
1738: cmd.opcode = GPCMD_SEND_KEY;
1739: cmd.bytes[8] = 12;
1740: cmd.bytes[9] = 3 | (a->hsk.agid << 6);
1741: buf[1] = 10;
1742: dvd_copy_key(&buf[4], a->hsk.key);
1743: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 12,
1744: CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
1745: if (error) {
1746: a->type = DVD_AUTH_FAILURE;
1747: return (error);
1748: }
1749: a->type = DVD_AUTH_ESTABLISHED;
1750: return (0);
1751:
1752: case DVD_INVALIDATE_AGID:
1753: cmd.opcode = GPCMD_REPORT_KEY;
1754: cmd.bytes[9] = 0x3f | (a->lsa.agid << 6);
1755: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 16,
1756: CDRETRIES, 30000, NULL, 0);
1757: if (error)
1758: return (error);
1759: return (0);
1760:
1761: case DVD_LU_SEND_RPC_STATE:
1762: cmd.opcode = GPCMD_REPORT_KEY;
1763: cmd.bytes[8] = 8;
1764: cmd.bytes[9] = 8 | (0 << 6);
1765: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
1766: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1767: if (error)
1768: return (error);
1769: a->lrpcs.type = (buf[4] >> 6) & 3;
1770: a->lrpcs.vra = (buf[4] >> 3) & 7;
1771: a->lrpcs.ucca = (buf[4]) & 7;
1772: a->lrpcs.region_mask = buf[5];
1773: a->lrpcs.rpc_scheme = buf[6];
1774: return (0);
1775:
1776: case DVD_HOST_SEND_RPC_STATE:
1777: cmd.opcode = GPCMD_SEND_KEY;
1778: cmd.bytes[8] = 8;
1779: cmd.bytes[9] = 6 | (0 << 6);
1780: buf[1] = 6;
1781: buf[4] = a->hrpcs.pdrc;
1782: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, 8,
1783: CDRETRIES, 30000, NULL, SCSI_DATA_OUT);
1784: if (error)
1785: return (error);
1786: return (0);
1787:
1788: default:
1789: return (ENOTTY);
1790: }
1791: }
1792:
1793: int
1794: dvd_read_physical(cd, s)
1795: struct cd_softc *cd;
1796: union dvd_struct *s;
1797: {
1798: struct scsi_generic cmd;
1799: u_int8_t buf[4 + 4 * 20], *bufp;
1800: int error;
1801: struct dvd_layer *layer;
1802: int i;
1803:
1804: bzero(cmd.bytes, sizeof(cmd.bytes));
1805: bzero(buf, sizeof(buf));
1806: cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
1807: cmd.bytes[6] = s->type;
1808: _lto2b(sizeof(buf), &cmd.bytes[7]);
1809:
1810: cmd.bytes[5] = s->physical.layer_num;
1811: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
1812: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1813: if (error)
1814: return (error);
1815: for (i = 0, bufp = &buf[4], layer = &s->physical.layer[0]; i < 4;
1816: i++, bufp += 20, layer++) {
1817: bzero(layer, sizeof(*layer));
1818: layer->book_version = bufp[0] & 0xf;
1819: layer->book_type = bufp[0] >> 4;
1820: layer->min_rate = bufp[1] & 0xf;
1821: layer->disc_size = bufp[1] >> 4;
1822: layer->layer_type = bufp[2] & 0xf;
1823: layer->track_path = (bufp[2] >> 4) & 1;
1824: layer->nlayers = (bufp[2] >> 5) & 3;
1825: layer->track_density = bufp[3] & 0xf;
1826: layer->linear_density = bufp[3] >> 4;
1827: layer->start_sector = _4btol(&bufp[4]);
1828: layer->end_sector = _4btol(&bufp[8]);
1829: layer->end_sector_l0 = _4btol(&bufp[12]);
1830: layer->bca = bufp[16] >> 7;
1831: }
1832: return (0);
1833: }
1834:
1835: int
1836: dvd_read_copyright(cd, s)
1837: struct cd_softc *cd;
1838: union dvd_struct *s;
1839: {
1840: struct scsi_generic cmd;
1841: u_int8_t buf[8];
1842: int error;
1843:
1844: bzero(cmd.bytes, sizeof(cmd.bytes));
1845: bzero(buf, sizeof(buf));
1846: cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
1847: cmd.bytes[6] = s->type;
1848: _lto2b(sizeof(buf), &cmd.bytes[7]);
1849:
1850: cmd.bytes[5] = s->copyright.layer_num;
1851: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
1852: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1853: if (error)
1854: return (error);
1855: s->copyright.cpst = buf[4];
1856: s->copyright.rmi = buf[5];
1857: return (0);
1858: }
1859:
1860: int
1861: dvd_read_disckey(cd, s)
1862: struct cd_softc *cd;
1863: union dvd_struct *s;
1864: {
1865: struct scsi_read_dvd_structure cmd;
1866: struct scsi_read_dvd_structure_data *buf;
1867: int error;
1868:
1869: buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
1870: if (buf == NULL)
1871: return (ENOMEM);
1872: bzero(buf, sizeof(*buf));
1873:
1874: bzero(&cmd, sizeof(cmd));
1875: cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
1876: cmd.format = s->type;
1877: cmd.agid = s->disckey.agid << 6;
1878: _lto2b(sizeof(*buf), cmd.length);
1879:
1880: error = scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
1881: sizeof(cmd), (u_char *)buf, sizeof(*buf), CDRETRIES, 30000, NULL,
1882: SCSI_DATA_IN);
1883: if (error == 0)
1884: bcopy(buf->data, s->disckey.value, sizeof(s->disckey.value));
1885:
1886: free(buf, M_TEMP);
1887: return (error);
1888: }
1889:
1890: int
1891: dvd_read_bca(cd, s)
1892: struct cd_softc *cd;
1893: union dvd_struct *s;
1894: {
1895: struct scsi_generic cmd;
1896: u_int8_t buf[4 + 188];
1897: int error;
1898:
1899: bzero(cmd.bytes, sizeof(cmd.bytes));
1900: bzero(buf, sizeof(buf));
1901: cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
1902: cmd.bytes[6] = s->type;
1903: _lto2b(sizeof(buf), &cmd.bytes[7]);
1904:
1905: error = scsi_scsi_cmd(cd->sc_link, &cmd, sizeof(cmd), buf, sizeof(buf),
1906: CDRETRIES, 30000, NULL, SCSI_DATA_IN);
1907: if (error)
1908: return (error);
1909: s->bca.len = _2btol(&buf[0]);
1910: if (s->bca.len < 12 || s->bca.len > 188)
1911: return (EIO);
1912: bcopy(&buf[4], s->bca.value, s->bca.len);
1913: return (0);
1914: }
1915:
1916: int
1917: dvd_read_manufact(cd, s)
1918: struct cd_softc *cd;
1919: union dvd_struct *s;
1920: {
1921: struct scsi_read_dvd_structure cmd;
1922: struct scsi_read_dvd_structure_data *buf;
1923: int error;
1924:
1925: buf = malloc(sizeof(*buf), M_TEMP, M_WAITOK);
1926: if (buf == NULL)
1927: return (ENOMEM);
1928: bzero(buf, sizeof(*buf));
1929:
1930: bzero(&cmd, sizeof(cmd));
1931: cmd.opcode = GPCMD_READ_DVD_STRUCTURE;
1932: cmd.format = s->type;
1933: _lto2b(sizeof(*buf), cmd.length);
1934:
1935: error = scsi_scsi_cmd(cd->sc_link, (struct scsi_generic *)&cmd,
1936: sizeof(cmd), (u_char *)buf, sizeof(*buf), CDRETRIES, 30000, NULL,
1937: SCSI_DATA_IN);
1938: if (error == 0) {
1939: s->manufact.len = _2btol(buf->len);
1940: if (s->manufact.len >= 0 && s->manufact.len <= 2048)
1941: bcopy(buf->data, s->manufact.value, s->manufact.len);
1942: else
1943: error = EIO;
1944: }
1945:
1946: free(buf, M_TEMP);
1947: return (error);
1948: }
1949:
1950: int
1951: dvd_read_struct(cd, s)
1952: struct cd_softc *cd;
1953: union dvd_struct *s;
1954: {
1955:
1956: switch (s->type) {
1957: case DVD_STRUCT_PHYSICAL:
1958: return (dvd_read_physical(cd, s));
1959: case DVD_STRUCT_COPYRIGHT:
1960: return (dvd_read_copyright(cd, s));
1961: case DVD_STRUCT_DISCKEY:
1962: return (dvd_read_disckey(cd, s));
1963: case DVD_STRUCT_BCA:
1964: return (dvd_read_bca(cd, s));
1965: case DVD_STRUCT_MANUFACT:
1966: return (dvd_read_manufact(cd, s));
1967: default:
1968: return (EINVAL);
1969: }
1970: }
1971:
1972: void
1973: cd_powerhook(int why, void *arg)
1974: {
1975: struct cd_softc *cd = arg;
1976:
1977: /*
1978: * When resuming, hardware may have forgotten we locked it. So if
1979: * there are any open partitions, lock the CD.
1980: */
1981: if (why == PWR_RESUME && cd->sc_dk.dk_openmask != 0)
1982: scsi_prevent(cd->sc_link, PR_PREVENT,
1983: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
1984: }
1985:
1986: int
1987: cd_interpret_sense(struct scsi_xfer *xs)
1988: {
1989: struct scsi_sense_data *sense = &xs->sense;
1990: struct scsi_link *sc_link = xs->sc_link;
1991: u_int8_t skey = sense->flags & SSD_KEY;
1992: u_int8_t serr = sense->error_code & SSD_ERRCODE;
1993:
1994: if (((sc_link->flags & SDEV_OPEN) == 0) ||
1995: (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED))
1996: return (EJUSTRETURN); /* let the generic code handle it */
1997:
1998: /*
1999: * We do custom processing in cd for the unit becoming ready
2000: * case. We do not allow xs->retries to be decremented on the
2001: * "Unit Becoming Ready" case. This is because CD drives
2002: * report "Unit Becoming Ready" when loading media and can
2003: * take a long time. Rather than having a massive timeout for
2004: * all operations (which would cause other problems), we allow
2005: * operations to wait (but be interruptable with Ctrl-C)
2006: * forever as long as the drive is reporting that it is
2007: * becoming ready. All other cases of not being ready are
2008: * handled by the default handler.
2009: */
2010: switch(skey) {
2011: case SKEY_NOT_READY:
2012: if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
2013: return (0);
2014: if (ASC_ASCQ(sense) == SENSE_NOT_READY_BECOMING_READY) {
2015: SC_DEBUG(sc_link, SDEV_DB1, ("not ready: busy (%#x)\n",
2016: sense->add_sense_code_qual));
2017: /* don't count this as a retry */
2018: xs->retries++;
2019: return (scsi_delay(xs, 1));
2020: }
2021: break;
2022: /* XXX more to come here for a few other cases */
2023: default:
2024: break;
2025: }
2026: return (EJUSTRETURN); /* use generic handler in scsi_base */
2027: }
2028:
2029: /*
2030: * Remove unprocessed buffers from queue.
2031: */
2032: void
2033: cd_kill_buffers(struct cd_softc *cd)
2034: {
2035: struct buf *dp, *bp;
2036: int s;
2037:
2038: s = splbio();
2039: for (dp = &cd->buf_queue; (bp = dp->b_actf) != NULL; ) {
2040: dp->b_actf = bp->b_actf;
2041:
2042: bp->b_error = ENXIO;
2043: bp->b_flags |= B_ERROR;
2044: biodone(bp);
2045: }
2046: splx(s);
2047: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi