File:
[DragonFly] /
src /
sys /
dev /
disk /
mcd /
Attic /
mcd.c
Revision
1.8:
download - view:
text,
annotated -
select for diffs
Thu May 13 23:49:15 2004 UTC (9 years ago) by
dillon
Branches:
MAIN
CVS tags:
HEAD
device switch 1/many: Remove d_autoq, add d_clone (where d_autoq was).
d_autoq was used to allow the device port dispatch to mix old-style synchronous
calls with new style messaging calls within a particular device. It was never
used for that purpose.
d_clone will be more fully implemented as work continues. We are going to
install d_port in the dev_t (struct specinfo) structure itself and d_clone
will be needed to allow devices to 'revector' the port on a minor-number
by minor-number basis, in particular allowing minor numbers to be directly
dispatched to distinct threads. This is something we will be needing later
on.
1: /*
2: * Copyright 1993 by Holger Veit (data part)
3: * Copyright 1993 by Brian Moore (audio part)
4: * Changes Copyright 1993 by Gary Clark II
5: * Changes Copyright (C) 1994-1995 by Andrey A. Chernov, Moscow, Russia
6: *
7: * Rewrote probe routine to work on newer Mitsumi drives.
8: * Additional changes (C) 1994 by Jordan K. Hubbard
9: *
10: * All rights reserved.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This software was developed by Holger Veit and Brian Moore
23: * for use with "386BSD" and similar operating systems.
24: * "Similar operating systems" includes mainly non-profit oriented
25: * systems for research and education, including but not restricted to
26: * "NetBSD", "FreeBSD", "Mach" (by CMU).
27: * 4. Neither the name of the developer(s) nor the name "386BSD"
28: * may be used to endorse or promote products derived from this
29: * software without specific prior written permission.
30: *
31: * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER(S) ``AS IS'' AND ANY
32: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
34: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPER(S) BE
35: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
36: * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
37: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
38: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
40: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42: *
43: * $FreeBSD: src/sys/i386/isa/mcd.c,v 1.115 2000/01/29 16:17:34 peter Exp $
44: * $DragonFly: src/sys/dev/disk/mcd/mcd.c,v 1.8 2004/05/13 23:49:15 dillon Exp $
45: */
46: static const char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";
47:
48: #include "use_mcd.h"
49:
50: #include <sys/param.h>
51: #include <sys/systm.h>
52: #include <sys/bootmaj.h>
53: #include <sys/conf.h>
54: #include <sys/fcntl.h>
55: #include <sys/buf.h>
56: #include <sys/cdio.h>
57: #include <sys/disklabel.h>
58: #include <sys/kernel.h>
59: #include <sys/buf2.h>
60: #include <machine/clock.h>
61:
62: #include <bus/isa/i386/isa_device.h>
63: #include "mcdreg.h"
64:
65: #define MCD_TRACE(format, args...) \
66: { \
67: if (mcd_data[unit].debug) { \
68: printf("mcd%d: status=0x%02x: ", \
69: unit, mcd_data[unit].status); \
70: printf(format, ## args); \
71: } \
72: }
73:
74: #define mcd_part(dev) ((minor(dev)) & 7)
75: #define mcd_unit(dev) (((minor(dev)) & 0x38) >> 3)
76: #define mcd_phys(dev) (((minor(dev)) & 0x40) >> 6)
77: #define RAW_PART 2
78:
79: /* flags */
80: #define MCDVALID 0x0001 /* parameters loaded */
81: #define MCDINIT 0x0002 /* device is init'd */
82: #define MCDNEWMODEL 0x0004 /* device is new model */
83: #define MCDLABEL 0x0008 /* label is read */
84: #define MCDPROBING 0x0010 /* probing */
85: #define MCDREADRAW 0x0020 /* read raw mode (2352 bytes) */
86: #define MCDVOLINFO 0x0040 /* already read volinfo */
87: #define MCDTOC 0x0080 /* already read toc */
88: #define MCDMBXBSY 0x0100 /* local mbx is busy */
89:
90: /* status */
91: #define MCDAUDIOBSY MCD_ST_AUDIOBSY /* playing audio */
92: #define MCDDSKCHNG MCD_ST_DSKCHNG /* sensed change of disk */
93: #define MCDDSKIN MCD_ST_DSKIN /* sensed disk in drive */
94: #define MCDDOOROPEN MCD_ST_DOOROPEN /* sensed door open */
95:
96: /* These are apparently the different states a mitsumi can get up to */
97: #define MCDCDABSENT 0x0030
98: #define MCDCDPRESENT 0x0020
99: #define MCDSCLOSED 0x0080
100: #define MCDSOPEN 0x00a0
101:
102: #define MCD_MD_UNKNOWN (-1)
103:
104: /* toc */
105: #define MCD_MAXTOCS 104 /* from the Linux driver */
106: #define MCD_LASTPLUS1 170 /* special toc entry */
107:
108: #define MCD_TYPE_UNKNOWN 0
109: #define MCD_TYPE_LU002S 1
110: #define MCD_TYPE_LU005S 2
111: #define MCD_TYPE_LU006S 3
112: #define MCD_TYPE_FX001 4
113: #define MCD_TYPE_FX001D 5
114:
115: struct mcd_mbx {
116: short unit;
117: short port;
118: short retry;
119: short nblk;
120: int sz;
121: u_long skip;
122: struct buf *bp;
123: int p_offset;
124: short count;
125: short mode;
126: };
127:
128: static struct mcd_data {
129: short type;
130: char *name;
131: short config;
132: short flags;
133: u_char read_command;
134: short status;
135: int blksize;
136: u_long disksize;
137: int iobase;
138: struct disklabel dlabel;
139: int partflags[MAXPARTITIONS];
140: int openflags;
141: struct mcd_volinfo volinfo;
142: struct mcd_qchninfo toc[MCD_MAXTOCS];
143: short audio_status;
144: short curr_mode;
145: struct mcd_read2 lastpb;
146: short debug;
147: struct buf_queue_head head; /* head of buf queue */
148: struct mcd_mbx mbx;
149: } mcd_data[NMCD];
150:
151: /* reader state machine */
152: #define MCD_S_BEGIN 0
153: #define MCD_S_BEGIN1 1
154: #define MCD_S_WAITSTAT 2
155: #define MCD_S_WAITMODE 3
156: #define MCD_S_WAITREAD 4
157:
158: /* prototypes */
159: static void mcd_start(int unit);
160: static int mcd_getdisklabel(int unit);
161: #ifdef NOTYET
162: static void mcd_configure(struct mcd_data *cd);
163: #endif
164: static int mcd_get(int unit, char *buf, int nmax);
165: static int mcd_setflags(int unit,struct mcd_data *cd);
166: static int mcd_getstat(int unit,int sflg);
167: static int mcd_send(int unit, int cmd,int nretrys);
168: static void hsg2msf(int hsg, bcd_t *msf);
169: static int msf2hsg(bcd_t *msf, int relative);
170: static int mcd_volinfo(int unit);
171: static ointhand2_t mcdintr;
172: static int mcd_waitrdy(int port,int dly);
173: static timeout_t mcd_timeout;
174: static void mcd_doread(int state, struct mcd_mbx *mbxin);
175: static void mcd_soft_reset(int unit);
176: static int mcd_hard_reset(int unit);
177: static int mcd_setmode(int unit, int mode);
178: static int mcd_getqchan(int unit, struct mcd_qchninfo *q);
179: static int mcd_subchan(int unit, struct ioc_read_subchannel *sc);
180: static int mcd_toc_header(int unit, struct ioc_toc_header *th);
181: static int mcd_read_toc(int unit);
182: static int mcd_toc_entrys(int unit, struct ioc_read_toc_entry *te);
183: #if 0
184: static int mcd_toc_entry(int unit, struct ioc_read_toc_single_entry *te);
185: #endif
186: static int mcd_stop(int unit);
187: static int mcd_eject(int unit);
188: static int mcd_inject(int unit);
189: static int mcd_playtracks(int unit, struct ioc_play_track *pt);
190: static int mcd_play(int unit, struct mcd_read2 *pb);
191: static int mcd_playmsf(int unit, struct ioc_play_msf *pt);
192: static int mcd_playblocks(int unit, struct ioc_play_blocks *);
193: static int mcd_pause(int unit);
194: static int mcd_resume(int unit);
195: static int mcd_lock_door(int unit, int lock);
196: static int mcd_close_tray(int unit);
197:
198: static int mcd_probe(struct isa_device *dev);
199: static int mcd_attach(struct isa_device *dev);
200: struct isa_driver mcddriver = { mcd_probe, mcd_attach, "mcd" };
201:
202: static d_open_t mcdopen;
203: static d_close_t mcdclose;
204: static d_ioctl_t mcdioctl;
205: static d_psize_t mcdsize;
206: static d_strategy_t mcdstrategy;
207:
208: static struct cdevsw mcd_cdevsw = {
209: /* name */ "mcd",
210: /* maj */ MCD_CDEV_MAJOR,
211: /* flags */ D_DISK,
212: /* port */ NULL,
213: /* clone */ NULL,
214:
215: /* open */ mcdopen,
216: /* close */ mcdclose,
217: /* read */ physread,
218: /* write */ nowrite,
219: /* ioctl */ mcdioctl,
220: /* poll */ nopoll,
221: /* mmap */ nommap,
222: /* strategy */ mcdstrategy,
223: /* dump */ nodump,
224: /* psize */ nopsize
225: };
226:
227: #define mcd_put(port,byte) outb(port,byte)
228:
229: #define MCD_RETRYS 5
230: #define MCD_RDRETRYS 8
231:
232: #define CLOSE_TRAY_SECS 8
233: #define DISK_SENSE_SECS 3
234: #define WAIT_FRAC 4
235:
236: /* several delays */
237: #define RDELAY_WAITSTAT 300
238: #define RDELAY_WAITMODE 300
239: #define RDELAY_WAITREAD 800
240:
241: #define MIN_DELAY 15
242: #define DELAY_GETREPLY 5000000
243:
244: int mcd_attach(struct isa_device *dev)
245: {
246: int unit = dev->id_unit;
247: struct mcd_data *cd = mcd_data + unit;
248:
249: dev->id_ointr = mcdintr;
250: cd->iobase = dev->id_iobase;
251: cd->flags |= MCDINIT;
252: mcd_soft_reset(unit);
253: bufq_init(&cd->head);
254:
255: #ifdef NOTYET
256: /* wire controller for interrupts and dma */
257: mcd_configure(cd);
258: #endif
259: /* name filled in probe */
260: make_dev(&mcd_cdevsw, dkmakeminor(unit, 0, 0),
261: UID_ROOT, GID_OPERATOR, 0640, "rmcd%da", unit);
262: make_dev(&mcd_cdevsw, dkmakeminor(unit, 0, RAW_PART),
263: UID_ROOT, GID_OPERATOR, 0640, "rmcd%dc", unit);
264: make_dev(&mcd_cdevsw, dkmakeminor(unit, 0, 0),
265: UID_ROOT, GID_OPERATOR, 0640, "mcd%da", unit);
266: make_dev(&mcd_cdevsw, dkmakeminor(unit, 0, RAW_PART),
267: UID_ROOT, GID_OPERATOR, 0640, "mcd%dc", unit);
268: return 1;
269: }
270:
271: int mcdopen(dev_t dev, int flags, int fmt, struct thread *td)
272: {
273: int unit,part,phys,r,retry;
274: struct mcd_data *cd;
275:
276: unit = mcd_unit(dev);
277: if (unit >= NMCD)
278: return ENXIO;
279:
280: cd = mcd_data + unit;
281: part = mcd_part(dev);
282: phys = mcd_phys(dev);
283:
284: /* not initialized*/
285: if (!(cd->flags & MCDINIT))
286: return ENXIO;
287:
288: /* invalidated in the meantime? mark all open part's invalid */
289: if (!(cd->flags & MCDVALID) && cd->openflags)
290: return ENXIO;
291:
292: if (mcd_getstat(unit,1) == -1)
293: return EIO;
294:
295: if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
296: || !(cd->status & MCDDSKIN))
297: for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
298: (void) tsleep((caddr_t)cd, PCATCH, "mcdsn1", hz/WAIT_FRAC);
299: if ((r = mcd_getstat(unit,1)) == -1)
300: return EIO;
301: if (r != -2)
302: break;
303: }
304:
305: if (( (cd->status & (MCDDOOROPEN|MCDDSKCHNG))
306: || !(cd->status & MCDDSKIN)
307: )
308: && major(dev) == MCD_CDEV_MAJOR && part == RAW_PART
309: ) {
310: cd->openflags |= (1<<part);
311: if (phys)
312: cd->partflags[part] |= MCDREADRAW;
313: return 0;
314: }
315: if (cd->status & MCDDOOROPEN) {
316: printf("mcd%d: door is open\n", unit);
317: return ENXIO;
318: }
319: if (!(cd->status & MCDDSKIN)) {
320: printf("mcd%d: no CD inside\n", unit);
321: return ENXIO;
322: }
323: if (cd->status & MCDDSKCHNG) {
324: printf("mcd%d: CD not sensed\n", unit);
325: return ENXIO;
326: }
327:
328: if (mcdsize(dev) < 0) {
329: if (major(dev) == MCD_CDEV_MAJOR && part == RAW_PART) {
330: cd->openflags |= (1<<part);
331: if (phys)
332: cd->partflags[part] |= MCDREADRAW;
333: return 0;
334: }
335: printf("mcd%d: failed to get disk size\n",unit);
336: return ENXIO;
337: } else
338: cd->flags |= MCDVALID;
339:
340: /* XXX get a default disklabel */
341: mcd_getdisklabel(unit);
342:
343: MCD_TRACE("open: partition=%d, disksize = %ld, blksize=%d\n",
344: part, cd->disksize, cd->blksize);
345:
346: dev->si_bsize_phys = cd->blksize;
347:
348: if (part == RAW_PART ||
349: (part < cd->dlabel.d_npartitions &&
350: cd->dlabel.d_partitions[part].p_fstype != FS_UNUSED)) {
351: cd->openflags |= (1<<part);
352: if (part == RAW_PART && phys)
353: cd->partflags[part] |= MCDREADRAW;
354: (void) mcd_lock_door(unit, MCD_LK_LOCK);
355: if (!(cd->flags & MCDVALID))
356: return ENXIO;
357: return 0;
358: }
359:
360: return ENXIO;
361: }
362:
363: int mcdclose(dev_t dev, int flags, int fmt, struct thread *td)
364: {
365: int unit,part;
366: struct mcd_data *cd;
367:
368: unit = mcd_unit(dev);
369: if (unit >= NMCD)
370: return ENXIO;
371:
372: cd = mcd_data + unit;
373: part = mcd_part(dev);
374:
375: if (!(cd->flags & MCDINIT) || !(cd->openflags & (1<<part)))
376: return ENXIO;
377:
378: MCD_TRACE("close: partition=%d\n", part);
379:
380: (void) mcd_lock_door(unit, MCD_LK_UNLOCK);
381: cd->openflags &= ~(1<<part);
382: cd->partflags[part] &= ~MCDREADRAW;
383:
384: return 0;
385: }
386:
387: void
388: mcdstrategy(struct buf *bp)
389: {
390: struct mcd_data *cd;
391: int s;
392:
393: int unit = mcd_unit(bp->b_dev);
394:
395: cd = mcd_data + unit;
396:
397: /* test validity */
398: /*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n",
399: bp,unit,bp->b_blkno,bp->b_bcount);*/
400: if (unit >= NMCD || bp->b_blkno < 0) {
401: printf("mcdstrategy: unit = %d, blkno = %ld, bcount = %ld\n",
402: unit, (long)bp->b_blkno, bp->b_bcount);
403: printf("mcd: mcdstratregy failure");
404: bp->b_error = EINVAL;
405: bp->b_flags |= B_ERROR;
406: goto bad;
407: }
408:
409: /* if device invalidated (e.g. media change, door open), error */
410: if (!(cd->flags & MCDVALID)) {
411: MCD_TRACE("strategy: drive not valid\n");
412: bp->b_error = EIO;
413: goto bad;
414: }
415:
416: /* read only */
417: if (!(bp->b_flags & B_READ)) {
418: bp->b_error = EROFS;
419: goto bad;
420: }
421:
422: /* no data to read */
423: if (bp->b_bcount == 0)
424: goto done;
425:
426: /* for non raw access, check partition limits */
427: if (mcd_part(bp->b_dev) != RAW_PART) {
428: if (!(cd->flags & MCDLABEL)) {
429: bp->b_error = EIO;
430: goto bad;
431: }
432: /* adjust transfer if necessary */
433: if (bounds_check_with_label(bp,&cd->dlabel,1) <= 0) {
434: goto done;
435: }
436: } else {
437: bp->b_pblkno = bp->b_blkno;
438: bp->b_resid = 0;
439: }
440:
441: /* queue it */
442: s = splbio();
443: bufqdisksort(&cd->head, bp);
444: splx(s);
445:
446: /* now check whether we can perform processing */
447: mcd_start(unit);
448: return;
449:
450: bad:
451: bp->b_flags |= B_ERROR;
452: done:
453: bp->b_resid = bp->b_bcount;
454: biodone(bp);
455: return;
456: }
457:
458: static void mcd_start(int unit)
459: {
460: struct mcd_data *cd = mcd_data + unit;
461: struct partition *p;
462: struct buf *bp;
463: int s = splbio();
464:
465: if (cd->flags & MCDMBXBSY) {
466: splx(s);
467: return;
468: }
469:
470: bp = bufq_first(&cd->head);
471: if (bp != 0) {
472: /* block found to process, dequeue */
473: /*MCD_TRACE("mcd_start: found block bp=0x%x\n",bp,0,0,0);*/
474: bufq_remove(&cd->head, bp);
475: splx(s);
476: } else {
477: /* nothing to do */
478: splx(s);
479: return;
480: }
481:
482: /* changed media? */
483: if (!(cd->flags & MCDVALID)) {
484: MCD_TRACE("mcd_start: drive not valid\n");
485: return;
486: }
487:
488: p = cd->dlabel.d_partitions + mcd_part(bp->b_dev);
489:
490: cd->flags |= MCDMBXBSY;
491: if (cd->partflags[mcd_part(bp->b_dev)] & MCDREADRAW)
492: cd->flags |= MCDREADRAW;
493: cd->mbx.unit = unit;
494: cd->mbx.port = cd->iobase;
495: cd->mbx.retry = MCD_RETRYS;
496: cd->mbx.bp = bp;
497: cd->mbx.p_offset = p->p_offset;
498:
499: /* calling the read routine */
500: mcd_doread(MCD_S_BEGIN,&(cd->mbx));
501: /* triggers mcd_start, when successful finished */
502: return;
503: }
504:
505: int mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
506: {
507: struct mcd_data *cd;
508: int unit,part,retry,r;
509:
510: unit = mcd_unit(dev);
511: part = mcd_part(dev);
512: cd = mcd_data + unit;
513:
514: if (mcd_getstat(unit, 1) == -1) /* detect disk change too */
515: return EIO;
516: MCD_TRACE("ioctl called 0x%lx\n", cmd);
517:
518: switch (cmd) {
519: case CDIOCSETPATCH:
520: case CDIOCGETVOL:
521: case CDIOCSETVOL:
522: case CDIOCSETMONO:
523: case CDIOCSETSTERIO:
524: case CDIOCSETMUTE:
525: case CDIOCSETLEFT:
526: case CDIOCSETRIGHT:
527: return EINVAL;
528: case CDIOCEJECT:
529: return mcd_eject(unit);
530: case CDIOCSETDEBUG:
531: cd->debug = 1;
532: return 0;
533: case CDIOCCLRDEBUG:
534: cd->debug = 0;
535: return 0;
536: case CDIOCRESET:
537: return mcd_hard_reset(unit);
538: case CDIOCALLOW:
539: return mcd_lock_door(unit, MCD_LK_UNLOCK);
540: case CDIOCPREVENT:
541: return mcd_lock_door(unit, MCD_LK_LOCK);
542: case CDIOCCLOSE:
543: return mcd_inject(unit);
544: }
545:
546: if (!(cd->flags & MCDVALID)) {
547: if ( major(dev) != MCD_CDEV_MAJOR
548: || part != RAW_PART
549: || !(cd->openflags & (1<<RAW_PART))
550: )
551: return ENXIO;
552: if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
553: || !(cd->status & MCDDSKIN))
554: for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
555: (void) tsleep((caddr_t)cd, PCATCH, "mcdsn2", hz/WAIT_FRAC);
556: if ((r = mcd_getstat(unit,1)) == -1)
557: return EIO;
558: if (r != -2)
559: break;
560: }
561: if ( (cd->status & (MCDDOOROPEN|MCDDSKCHNG))
562: || !(cd->status & MCDDSKIN)
563: || mcdsize(dev) < 0
564: )
565: return ENXIO;
566: cd->flags |= MCDVALID;
567: mcd_getdisklabel(unit);
568: if (mcd_phys(dev))
569: cd->partflags[part] |= MCDREADRAW;
570: (void) mcd_lock_door(unit, MCD_LK_LOCK);
571: if (!(cd->flags & MCDVALID))
572: return ENXIO;
573: }
574:
575: switch (cmd) {
576: case DIOCGDINFO:
577: *(struct disklabel *) addr = cd->dlabel;
578: return 0;
579: case DIOCGPART:
580: ((struct partinfo *) addr)->disklab = &cd->dlabel;
581: ((struct partinfo *) addr)->part =
582: &cd->dlabel.d_partitions[mcd_part(dev)];
583: return 0;
584:
585: /*
586: * a bit silly, but someone might want to test something on a
587: * section of cdrom.
588: */
589: case DIOCWDINFO:
590: case DIOCSDINFO:
591: if ((flags & FWRITE) == 0)
592: return EBADF;
593: else {
594: return setdisklabel(&cd->dlabel,
595: (struct disklabel *) addr,
596: 0);
597: }
598: case DIOCWLABEL:
599: return EBADF;
600: case CDIOCPLAYTRACKS:
601: return mcd_playtracks(unit, (struct ioc_play_track *) addr);
602: case CDIOCPLAYBLOCKS:
603: return mcd_playblocks(unit, (struct ioc_play_blocks *) addr);
604: case CDIOCPLAYMSF:
605: return mcd_playmsf(unit, (struct ioc_play_msf *) addr);
606: case CDIOCREADSUBCHANNEL:
607: return mcd_subchan(unit, (struct ioc_read_subchannel *) addr);
608: case CDIOREADTOCHEADER:
609: return mcd_toc_header(unit, (struct ioc_toc_header *) addr);
610: case CDIOREADTOCENTRYS:
611: return mcd_toc_entrys(unit, (struct ioc_read_toc_entry *) addr);
612: case CDIOCRESUME:
613: return mcd_resume(unit);
614: case CDIOCPAUSE:
615: return mcd_pause(unit);
616: case CDIOCSTART:
617: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
618: return EIO;
619: return 0;
620: case CDIOCSTOP:
621: return mcd_stop(unit);
622: default:
623: return ENOTTY;
624: }
625: /*NOTREACHED*/
626: }
627:
628: /* this could have been taken from scsi/cd.c, but it is not clear
629: * whether the scsi cd driver is linked in
630: */
631: static int mcd_getdisklabel(int unit)
632: {
633: struct mcd_data *cd = mcd_data + unit;
634:
635: if (cd->flags & MCDLABEL)
636: return -1;
637:
638: bzero(&cd->dlabel,sizeof(struct disklabel));
639: /* filled with spaces first */
640: strncpy(cd->dlabel.d_typename," ",
641: sizeof(cd->dlabel.d_typename));
642: strncpy(cd->dlabel.d_typename, cd->name,
643: min(strlen(cd->name), sizeof(cd->dlabel.d_typename) - 1));
644: strncpy(cd->dlabel.d_packname,"unknown ",
645: sizeof(cd->dlabel.d_packname));
646: cd->dlabel.d_secsize = cd->blksize;
647: cd->dlabel.d_nsectors = 100;
648: cd->dlabel.d_ntracks = 1;
649: cd->dlabel.d_ncylinders = (cd->disksize/100)+1;
650: cd->dlabel.d_secpercyl = 100;
651: cd->dlabel.d_secperunit = cd->disksize;
652: cd->dlabel.d_rpm = 300;
653: cd->dlabel.d_interleave = 1;
654: cd->dlabel.d_flags = D_REMOVABLE;
655: cd->dlabel.d_npartitions= 1;
656: cd->dlabel.d_partitions[0].p_offset = 0;
657: cd->dlabel.d_partitions[0].p_size = cd->disksize;
658: cd->dlabel.d_partitions[0].p_fstype = 9;
659: cd->dlabel.d_magic = DISKMAGIC;
660: cd->dlabel.d_magic2 = DISKMAGIC;
661: cd->dlabel.d_checksum = dkcksum(&cd->dlabel);
662:
663: cd->flags |= MCDLABEL;
664: return 0;
665: }
666:
667: int mcdsize(dev_t dev)
668: {
669: int size;
670: int unit = mcd_unit(dev);
671: struct mcd_data *cd = mcd_data + unit;
672:
673: if (mcd_volinfo(unit) == 0) {
674: cd->blksize = MCDBLK;
675: size = msf2hsg(cd->volinfo.vol_msf, 0);
676: cd->disksize = size * (MCDBLK/DEV_BSIZE);
677: return 0;
678: }
679: return -1;
680: }
681:
682: /***************************************************************
683: * lower level of driver starts here
684: **************************************************************/
685:
686: #ifdef NOTDEF
687: static char
688: irqs[] = {
689: 0x00,0x00,0x10,0x20,0x00,0x30,0x00,0x00,
690: 0x00,0x10,0x40,0x50,0x00,0x00,0x00,0x00
691: };
692:
693: static char
694: drqs[] = {
695: 0x00,0x01,0x00,0x03,0x00,0x05,0x06,0x07,
696: };
697: #endif
698:
699: #ifdef NOT_YET
700: static void
701: mcd_configure(struct mcd_data *cd)
702: {
703: outb(cd->iobase+mcd_config,cd->config);
704: }
705: #endif
706:
707: /* Wait for non-busy - return 0 on timeout */
708: static int
709: twiddle_thumbs(int port, int unit, int count, char *whine)
710: {
711: int i;
712:
713: for (i = 0; i < count; i++) {
714: if (!(inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL))
715: return 1;
716: }
717: if (bootverbose)
718: printf("mcd%d: timeout %s\n", unit, whine);
719: return 0;
720: }
721:
722: /* check to see if a Mitsumi CD-ROM is attached to the ISA bus */
723:
724: int
725: mcd_probe(struct isa_device *dev)
726: {
727: int port = dev->id_iobase;
728: int unit = dev->id_unit;
729: int i, j;
730: unsigned char stbytes[3];
731: static int once;
732:
733: if (!once++)
734: cdevsw_add(&mcd_cdevsw);
735:
736: mcd_data[unit].flags = MCDPROBING;
737:
738: #ifdef NOTDEF
739: /* get irq/drq configuration word */
740: mcd_data[unit].config = irqs[dev->id_irq]; /* | drqs[dev->id_drq];*/
741: #else
742: mcd_data[unit].config = 0;
743: #endif
744:
745: /* send a reset */
746: outb(port+MCD_FLAGS, M_RESET);
747:
748: /*
749: * delay awhile by getting any pending garbage (old data) and
750: * throwing it away.
751: */
752: for (i = 1000000; i != 0; i--)
753: inb(port+MCD_FLAGS);
754:
755: /* Get status */
756: outb(port+MCD_DATA, MCD_CMDGETSTAT);
757: if (!twiddle_thumbs(port, unit, 1000000, "getting status"))
758: return 0; /* Timeout */
759: /* Get version information */
760: outb(port+MCD_DATA, MCD_CMDCONTINFO);
761: for (j = 0; j < 3; j++) {
762: if (!twiddle_thumbs(port, unit, 3000, "getting version info"))
763: return 0;
764: stbytes[j] = (inb(port+MCD_DATA) & 0xFF);
765: }
766: if (stbytes[1] == stbytes[2])
767: return 0;
768: if (stbytes[2] >= 4 || stbytes[1] != 'M') {
769: outb(port+MCD_CTRL, M_PICKLE);
770: mcd_data[unit].flags |= MCDNEWMODEL;
771: }
772: mcd_data[unit].read_command = MCD_CMDSINGLESPEEDREAD;
773: switch (stbytes[1]) {
774: case 'M':
775: if (stbytes[2] <= 2) {
776: mcd_data[unit].type = MCD_TYPE_LU002S;
777: mcd_data[unit].name = "Mitsumi LU002S";
778: } else if (stbytes[2] <= 5) {
779: mcd_data[unit].type = MCD_TYPE_LU005S;
780: mcd_data[unit].name = "Mitsumi LU005S";
781: } else {
782: mcd_data[unit].type = MCD_TYPE_LU006S;
783: mcd_data[unit].name = "Mitsumi LU006S";
784: }
785: break;
786: case 'F':
787: mcd_data[unit].type = MCD_TYPE_FX001;
788: mcd_data[unit].name = "Mitsumi FX001";
789: break;
790: case 'D':
791: mcd_data[unit].type = MCD_TYPE_FX001D;
792: mcd_data[unit].name = "Mitsumi FX001D";
793: mcd_data[unit].read_command = MCD_CMDDOUBLESPEEDREAD;
794: break;
795: default:
796: mcd_data[unit].type = MCD_TYPE_UNKNOWN;
797: mcd_data[unit].name = "Mitsumi ???";
798: break;
799: }
800: printf("mcd%d: type %s, version info: %c %x\n", unit, mcd_data[unit].name,
801: stbytes[1], stbytes[2]);
802:
803: return 4;
804: }
805:
806:
807: static int
808: mcd_waitrdy(int port,int dly)
809: {
810: int i;
811:
812: /* wait until flag port senses status ready */
813: for (i=0; i<dly; i+=MIN_DELAY) {
814: if (!(inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL))
815: return 0;
816: DELAY(MIN_DELAY);
817: }
818: return -1;
819: }
820:
821: static int
822: mcd_getreply(int unit,int dly)
823: {
824: struct mcd_data *cd = mcd_data + unit;
825: int port = cd->iobase;
826:
827: /* wait data to become ready */
828: if (mcd_waitrdy(port,dly)<0) {
829: printf("mcd%d: timeout getreply\n",unit);
830: return -1;
831: }
832:
833: /* get the data */
834: return inb(port+mcd_status) & 0xFF;
835: }
836:
837: static int
838: mcd_getstat(int unit,int sflg)
839: {
840: int i;
841: struct mcd_data *cd = mcd_data + unit;
842: int port = cd->iobase;
843:
844: /* get the status */
845: if (sflg)
846: outb(port+mcd_command, MCD_CMDGETSTAT);
847: i = mcd_getreply(unit,DELAY_GETREPLY);
848: if (i<0 || (i & MCD_ST_CMDCHECK)) {
849: cd->curr_mode = MCD_MD_UNKNOWN;
850: return -1;
851: }
852:
853: cd->status = i;
854:
855: if (mcd_setflags(unit,cd) < 0)
856: return -2;
857: return cd->status;
858: }
859:
860: static int
861: mcd_setflags(int unit, struct mcd_data *cd)
862: {
863: /* check flags */
864: if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
865: || !(cd->status & MCDDSKIN)) {
866: MCD_TRACE("setflags: sensed DSKCHNG or DOOROPEN or !DSKIN\n");
867: mcd_soft_reset(unit);
868: return -1;
869: }
870:
871: if (cd->status & MCDAUDIOBSY)
872: cd->audio_status = CD_AS_PLAY_IN_PROGRESS;
873: else if (cd->audio_status == CD_AS_PLAY_IN_PROGRESS)
874: cd->audio_status = CD_AS_PLAY_COMPLETED;
875: return 0;
876: }
877:
878: static int
879: mcd_get(int unit, char *buf, int nmax)
880: {
881: int i,k;
882:
883: for (i=0; i<nmax; i++) {
884: /* wait for data */
885: if ((k = mcd_getreply(unit,DELAY_GETREPLY)) < 0) {
886: printf("mcd%d: timeout mcd_get\n",unit);
887: return -1;
888: }
889: buf[i] = k;
890: }
891: return i;
892: }
893:
894: static int
895: mcd_send(int unit, int cmd,int nretrys)
896: {
897: int i,k=0;
898: int port = mcd_data[unit].iobase;
899:
900: /*MCD_TRACE("mcd_send: command = 0x%02x\n",cmd,0,0,0);*/
901: for (i=0; i<nretrys; i++) {
902: outb(port+mcd_command, cmd);
903: if ((k=mcd_getstat(unit,0)) != -1)
904: break;
905: }
906: if (k == -2) {
907: printf("mcd%d: media changed\n",unit);
908: return -1;
909: }
910: if (i == nretrys) {
911: printf("mcd%d: mcd_send retry cnt exceeded\n",unit);
912: return -1;
913: }
914: /*MCD_TRACE("mcd_send: done\n",0,0,0,0);*/
915: return 0;
916: }
917:
918: static void
919: hsg2msf(int hsg, bcd_t *msf)
920: {
921: hsg += 150;
922: F_msf(msf) = bin2bcd(hsg % 75);
923: hsg /= 75;
924: S_msf(msf) = bin2bcd(hsg % 60);
925: hsg /= 60;
926: M_msf(msf) = bin2bcd(hsg);
927: }
928:
929: static int
930: msf2hsg(bcd_t *msf, int relative)
931: {
932: return (bcd2bin(M_msf(msf)) * 60 + bcd2bin(S_msf(msf))) * 75 +
933: bcd2bin(F_msf(msf)) - (!relative) * 150;
934: }
935:
936: static int
937: mcd_volinfo(int unit)
938: {
939: struct mcd_data *cd = mcd_data + unit;
940:
941: /* Just return if we already have it */
942: if (cd->flags & MCDVOLINFO) return 0;
943:
944: /*MCD_TRACE("mcd_volinfo: enter\n",0,0,0,0);*/
945:
946: /* send volume info command */
947: if (mcd_send(unit,MCD_CMDGETVOLINFO,MCD_RETRYS) < 0)
948: return EIO;
949:
950: /* get data */
951: if (mcd_get(unit,(char*) &cd->volinfo,sizeof(struct mcd_volinfo)) < 0) {
952: printf("mcd%d: mcd_volinfo: error read data\n",unit);
953: return EIO;
954: }
955:
956: if (cd->volinfo.trk_low > 0 &&
957: cd->volinfo.trk_high >= cd->volinfo.trk_low
958: ) {
959: cd->flags |= MCDVOLINFO; /* volinfo is OK */
960: return 0;
961: }
962:
963: return EINVAL;
964: }
965:
966: static void
967: mcdintr(unit)
968: int unit;
969: {
970: MCD_TRACE("stray interrupt\n");
971: }
972:
973: /* state machine to process read requests
974: * initialize with MCD_S_BEGIN: calculate sizes, and read status
975: * MCD_S_WAITSTAT: wait for status reply, set mode
976: * MCD_S_WAITMODE: waits for status reply from set mode, set read command
977: * MCD_S_WAITREAD: wait for read ready, read data
978: */
979: static struct mcd_mbx *mbxsave;
980: static struct callout_handle tohandle = CALLOUT_HANDLE_INITIALIZER(&tohandle);
981:
982: static void
983: mcd_timeout(void *arg)
984: {
985: mcd_doread((int)arg, mbxsave);
986: }
987:
988: static void
989: mcd_doread(int state, struct mcd_mbx *mbxin)
990: {
991: struct mcd_mbx *mbx = (state!=MCD_S_BEGIN) ? mbxsave : mbxin;
992: int unit = mbx->unit;
993: int port = mbx->port;
994: int com_port = mbx->port + mcd_command;
995: int data_port = mbx->port + mcd_rdata;
996: struct buf *bp = mbx->bp;
997: struct mcd_data *cd = mcd_data + unit;
998:
999: int rm,i,k;
1000: struct mcd_read2 rbuf;
1001: int blknum;
1002: caddr_t addr;
1003:
1004: loop:
1005: switch (state) {
1006: case MCD_S_BEGIN:
1007: mbx = mbxsave = mbxin;
1008:
1009: case MCD_S_BEGIN1:
1010: retry_status:
1011: /* get status */
1012: outb(com_port, MCD_CMDGETSTAT);
1013: mbx->count = RDELAY_WAITSTAT;
1014: tohandle = timeout(mcd_timeout,
1015: (caddr_t)MCD_S_WAITSTAT,hz/100); /* XXX */
1016: return;
1017: case MCD_S_WAITSTAT:
1018: untimeout(mcd_timeout,(caddr_t)MCD_S_WAITSTAT, tohandle);
1019: if (mbx->count-- >= 0) {
1020: if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
1021: timeout(mcd_timeout,
1022: (caddr_t)MCD_S_WAITSTAT,hz/100); /* XXX */
1023: return;
1024: }
1025: cd->status = inb(port+mcd_status) & 0xFF;
1026: if (cd->status & MCD_ST_CMDCHECK)
1027: goto retry_status;
1028: if (mcd_setflags(unit,cd) < 0)
1029: goto changed;
1030: MCD_TRACE("got WAITSTAT delay=%d\n",
1031: RDELAY_WAITSTAT-mbx->count);
1032: /* reject, if audio active */
1033: if (cd->status & MCDAUDIOBSY) {
1034: printf("mcd%d: audio is active\n",unit);
1035: goto readerr;
1036: }
1037:
1038: retry_mode:
1039: /* to check for raw/cooked mode */
1040: if (cd->flags & MCDREADRAW) {
1041: rm = MCD_MD_RAW;
1042: mbx->sz = MCDRBLK;
1043: } else {
1044: rm = MCD_MD_COOKED;
1045: mbx->sz = cd->blksize;
1046: }
1047:
1048: if (rm == cd->curr_mode)
1049: goto modedone;
1050:
1051: mbx->count = RDELAY_WAITMODE;
1052:
1053: cd->curr_mode = MCD_MD_UNKNOWN;
1054: mbx->mode = rm;
1055: mcd_put(com_port, MCD_CMDSETMODE);
1056: mcd_put(com_port, rm);
1057:
1058: tohandle = timeout(mcd_timeout,
1059: (caddr_t)MCD_S_WAITMODE,hz/100); /* XXX */
1060: return;
1061: } else {
1062: printf("mcd%d: timeout getstatus\n",unit);
1063: goto readerr;
1064: }
1065:
1066: case MCD_S_WAITMODE:
1067: untimeout(mcd_timeout,(caddr_t)MCD_S_WAITMODE, tohandle);
1068: if (mbx->count-- < 0) {
1069: printf("mcd%d: timeout set mode\n",unit);
1070: goto readerr;
1071: }
1072: if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
1073: tohandle = timeout(mcd_timeout,
1074: (caddr_t)MCD_S_WAITMODE,hz/100);
1075: return;
1076: }
1077: cd->status = inb(port+mcd_status) & 0xFF;
1078: if (cd->status & MCD_ST_CMDCHECK) {
1079: cd->curr_mode = MCD_MD_UNKNOWN;
1080: goto retry_mode;
1081: }
1082: if (mcd_setflags(unit,cd) < 0)
1083: goto changed;
1084: cd->curr_mode = mbx->mode;
1085: MCD_TRACE("got WAITMODE delay=%d\n",
1086: RDELAY_WAITMODE-mbx->count);
1087: modedone:
1088: /* for first block */
1089: mbx->nblk = (bp->b_bcount + (mbx->sz-1)) / mbx->sz;
1090: mbx->skip = 0;
1091:
1092: nextblock:
1093: blknum = (bp->b_blkno / (mbx->sz/DEV_BSIZE))
1094: + mbx->p_offset + mbx->skip/mbx->sz;
1095:
1096: MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
1097: blknum, bp);
1098:
1099: /* build parameter block */
1100: hsg2msf(blknum,rbuf.start_msf);
1101: retry_read:
1102: /* send the read command */
1103: cpu_disable_intr();
1104: mcd_put(com_port,cd->read_command);
1105: mcd_put(com_port,rbuf.start_msf[0]);
1106: mcd_put(com_port,rbuf.start_msf[1]);
1107: mcd_put(com_port,rbuf.start_msf[2]);
1108: mcd_put(com_port,0);
1109: mcd_put(com_port,0);
1110: mcd_put(com_port,1);
1111: cpu_enable_intr();
1112:
1113: /* Spin briefly (<= 2ms) to avoid missing next block */
1114: for (i = 0; i < 20; i++) {
1115: k = inb(port+MCD_FLAGS);
1116: if (!(k & MFL_DATA_NOT_AVAIL))
1117: goto got_it;
1118: DELAY(100);
1119: }
1120:
1121: mbx->count = RDELAY_WAITREAD;
1122: tohandle = timeout(mcd_timeout,
1123: (caddr_t)MCD_S_WAITREAD,hz/100); /* XXX */
1124: return;
1125: case MCD_S_WAITREAD:
1126: untimeout(mcd_timeout,(caddr_t)MCD_S_WAITREAD, tohandle);
1127: if (mbx->count-- > 0) {
1128: k = inb(port+MCD_FLAGS);
1129: if (!(k & MFL_DATA_NOT_AVAIL)) { /* XXX */
1130: MCD_TRACE("got data delay=%d\n",
1131: RDELAY_WAITREAD-mbx->count);
1132: got_it:
1133: /* data is ready */
1134: addr = bp->b_data + mbx->skip;
1135:
1136: outb(port+mcd_ctl2,0x04); /* XXX */
1137: for (i=0; i<mbx->sz; i++)
1138: *addr++ = inb(data_port);
1139: outb(port+mcd_ctl2,0x0c); /* XXX */
1140:
1141: k = inb(port+MCD_FLAGS);
1142: /* If we still have some junk, read it too */
1143: if (!(k & MFL_DATA_NOT_AVAIL)) {
1144: outb(port+mcd_ctl2,0x04); /* XXX */
1145: (void)inb(data_port);
1146: (void)inb(data_port);
1147: outb(port+mcd_ctl2,0x0c); /* XXX */
1148: }
1149:
1150: if (--mbx->nblk > 0) {
1151: mbx->skip += mbx->sz;
1152: goto nextblock;
1153: }
1154:
1155: /* return buffer */
1156: bp->b_resid = 0;
1157: biodone(bp);
1158:
1159: cd->flags &= ~(MCDMBXBSY|MCDREADRAW);
1160: mcd_start(mbx->unit);
1161: return;
1162: }
1163: if (!(k & MFL_STATUS_NOT_AVAIL)) {
1164: cd->status = inb(port+mcd_status) & 0xFF;
1165: if (cd->status & MCD_ST_CMDCHECK)
1166: goto retry_read;
1167: if (mcd_setflags(unit,cd) < 0)
1168: goto changed;
1169: }
1170: tohandle = timeout(mcd_timeout,
1171: (caddr_t)MCD_S_WAITREAD,hz/100); /* XXX */
1172: return;
1173: } else {
1174: printf("mcd%d: timeout read data\n",unit);
1175: goto readerr;
1176: }
1177: }
1178:
1179: readerr:
1180: if (mbx->retry-- > 0) {
1181: printf("mcd%d: retrying\n",unit);
1182: state = MCD_S_BEGIN1;
1183: goto loop;
1184: }
1185: harderr:
1186: /* invalidate the buffer */
1187: bp->b_flags |= B_ERROR;
1188: bp->b_resid = bp->b_bcount;
1189: biodone(bp);
1190:
1191: cd->flags &= ~(MCDMBXBSY|MCDREADRAW);
1192: mcd_start(mbx->unit);
1193: return;
1194:
1195: changed:
1196: printf("mcd%d: media changed\n", unit);
1197: goto harderr;
1198:
1199: #ifdef NOTDEF
1200: printf("mcd%d: unit timeout, resetting\n",mbx->unit);
1201: outb(mbx->port+mcd_reset,MCD_CMDRESET);
1202: DELAY(300000);
1203: (void)mcd_getstat(mbx->unit,1);
1204: (void)mcd_getstat(mbx->unit,1);
1205: /*cd->status &= ~MCDDSKCHNG; */
1206: cd->debug = 1; /* preventive set debug mode */
1207:
1208: #endif
1209:
1210: }
1211:
1212: static int
1213: mcd_lock_door(int unit, int lock)
1214: {
1215: struct mcd_data *cd = mcd_data + unit;
1216: int port = cd->iobase;
1217:
1218: outb(port+mcd_command, MCD_CMDLOCKDRV);
1219: outb(port+mcd_command, lock);
1220: if (mcd_getstat(unit,0) == -1)
1221: return EIO;
1222: return 0;
1223: }
1224:
1225: static int
1226: mcd_close_tray(int unit)
1227: {
1228: struct mcd_data *cd = mcd_data + unit;
1229: int port = cd->iobase;
1230: int retry, r;
1231:
1232: if (mcd_getstat(unit,1) == -1)
1233: return EIO;
1234: if (cd->status & MCDDOOROPEN) {
1235: outb(port+mcd_command, MCD_CMDCLOSETRAY);
1236: for (retry = 0; retry < CLOSE_TRAY_SECS * WAIT_FRAC; retry++) {
1237: if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL)
1238: (void) tsleep((caddr_t)cd, PCATCH, "mcdcls", hz/WAIT_FRAC);
1239: else {
1240: if ((r = mcd_getstat(unit,0)) == -1)
1241: return EIO;
1242: return 0;
1243: }
1244: }
1245: return ENXIO;
1246: }
1247: return 0;
1248: }
1249:
1250: static int
1251: mcd_eject(int unit)
1252: {
1253: struct mcd_data *cd = mcd_data + unit;
1254: int port = cd->iobase, r;
1255:
1256: if (mcd_getstat(unit,1) == -1) /* detect disk change too */
1257: return EIO;
1258: if (cd->status & MCDDOOROPEN)
1259: return 0;
1260: if ((r = mcd_stop(unit)) == EIO)
1261: return r;
1262: outb(port+mcd_command, MCD_CMDEJECTDISK);
1263: if (mcd_getstat(unit,0) == -1)
1264: return EIO;
1265: return 0;
1266: }
1267:
1268: static int
1269: mcd_inject(int unit)
1270: {
1271: struct mcd_data *cd = mcd_data + unit;
1272:
1273: if (mcd_getstat(unit,1) == -1) /* detect disk change too */
1274: return EIO;
1275: if (cd->status & MCDDOOROPEN)
1276: return mcd_close_tray(unit);
1277: return 0;
1278: }
1279:
1280: static int
1281: mcd_hard_reset(int unit)
1282: {
1283: struct mcd_data *cd = mcd_data + unit;
1284: int port = cd->iobase;
1285:
1286: outb(port+mcd_reset,MCD_CMDRESET);
1287: cd->curr_mode = MCD_MD_UNKNOWN;
1288: cd->audio_status = CD_AS_AUDIO_INVALID;
1289: return 0;
1290: }
1291:
1292: static void
1293: mcd_soft_reset(int unit)
1294: {
1295: struct mcd_data *cd = mcd_data + unit;
1296: int i;
1297:
1298: cd->flags &= (MCDINIT|MCDPROBING|MCDNEWMODEL);
1299: cd->curr_mode = MCD_MD_UNKNOWN;
1300: for (i=0; i<MAXPARTITIONS; i++) cd->partflags[i] = 0;
1301: cd->audio_status = CD_AS_AUDIO_INVALID;
1302: }
1303:
1304: static int
1305: mcd_setmode(int unit, int mode)
1306: {
1307: struct mcd_data *cd = mcd_data + unit;
1308: int port = cd->iobase;
1309: int retry, st;
1310:
1311: if (cd->curr_mode == mode)
1312: return 0;
1313: if (cd->debug)
1314: printf("mcd%d: setting mode to %d\n", unit, mode);
1315: for(retry=0; retry<MCD_RETRYS; retry++)
1316: {
1317: cd->curr_mode = MCD_MD_UNKNOWN;
1318: outb(port+mcd_command, MCD_CMDSETMODE);
1319: outb(port+mcd_command, mode);
1320: if ((st = mcd_getstat(unit, 0)) >= 0) {
1321: cd->curr_mode = mode;
1322: return 0;
1323: }
1324: if (st == -2) {
1325: printf("mcd%d: media changed\n", unit);
1326: break;
1327: }
1328: }
1329:
1330: return -1;
1331: }
1332:
1333: static int
1334: mcd_toc_header(int unit, struct ioc_toc_header *th)
1335: {
1336: struct mcd_data *cd = mcd_data + unit;
1337: int r;
1338:
1339: if ((r = mcd_volinfo(unit)) != 0)
1340: return r;
1341:
1342: th->starting_track = bcd2bin(cd->volinfo.trk_low);
1343: th->ending_track = bcd2bin(cd->volinfo.trk_high);
1344: th->len = 2 * sizeof(u_char) /* start & end tracks */ +
1345: (th->ending_track + 1 - th->starting_track + 1) *
1346: sizeof(struct cd_toc_entry);
1347:
1348: return 0;
1349: }
1350:
1351: static int
1352: mcd_read_toc(int unit)
1353: {
1354: struct mcd_data *cd = mcd_data + unit;
1355: struct ioc_toc_header th;
1356: struct mcd_qchninfo q;
1357: int rc, trk, idx, retry;
1358:
1359: /* Only read TOC if needed */
1360: if (cd->flags & MCDTOC)
1361: return 0;
1362:
1363: if (cd->debug)
1364: printf("mcd%d: reading toc header\n", unit);
1365:
1366: if ((rc = mcd_toc_header(unit, &th)) != 0)
1367: return rc;
1368:
1369: if (mcd_send(unit, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1370: return EIO;
1371:
1372: if (mcd_setmode(unit, MCD_MD_TOC) != 0)
1373: return EIO;
1374:
1375: if (cd->debug)
1376: printf("mcd%d: get_toc reading qchannel info\n",unit);
1377:
1378: for(trk=th.starting_track; trk<=th.ending_track; trk++)
1379: cd->toc[trk].idx_no = 0;
1380: trk = th.ending_track - th.starting_track + 1;
1381: for(retry=0; retry<600 && trk>0; retry++)
1382: {
1383: if (mcd_getqchan(unit, &q) < 0) break;
1384: idx = bcd2bin(q.idx_no);
1385: if (idx>=th.starting_track && idx<=th.ending_track && q.trk_no==0) {
1386: if (cd->toc[idx].idx_no == 0) {
1387: cd->toc[idx] = q;
1388: trk--;
1389: }
1390: }
1391: }
1392:
1393: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
1394: return EIO;
1395:
1396: if (trk != 0)
1397: return ENXIO;
1398:
1399: /* add a fake last+1 */
1400: idx = th.ending_track + 1;
1401: cd->toc[idx].control = cd->toc[idx-1].control;
1402: cd->toc[idx].addr_type = cd->toc[idx-1].addr_type;
1403: cd->toc[idx].trk_no = 0;
1404: cd->toc[idx].idx_no = MCD_LASTPLUS1;
1405: cd->toc[idx].hd_pos_msf[0] = cd->volinfo.vol_msf[0];
1406: cd->toc[idx].hd_pos_msf[1] = cd->volinfo.vol_msf[1];
1407: cd->toc[idx].hd_pos_msf[2] = cd->volinfo.vol_msf[2];
1408:
1409: if (cd->debug)
1410: { int i;
1411: for (i = th.starting_track; i <= idx; i++)
1412: printf("mcd%d: trk %d idx %d pos %d %d %d\n",
1413: unit, i,
1414: cd->toc[i].idx_no > 0x99 ? cd->toc[i].idx_no :
1415: bcd2bin(cd->toc[i].idx_no),
1416: bcd2bin(cd->toc[i].hd_pos_msf[0]),
1417: bcd2bin(cd->toc[i].hd_pos_msf[1]),
1418: bcd2bin(cd->toc[i].hd_pos_msf[2]));
1419: }
1420:
1421: cd->flags |= MCDTOC;
1422:
1423: return 0;
1424: }
1425:
1426: #if 0
1427: static int
1428: mcd_toc_entry(int unit, struct ioc_read_toc_single_entry *te)
1429: {
1430: struct mcd_data *cd = mcd_data + unit;
1431: struct ioc_toc_header th;
1432: int rc, trk;
1433:
1434: if (te->address_format != CD_MSF_FORMAT
1435: && te->address_format != CD_LBA_FORMAT)
1436: return EINVAL;
1437:
1438: /* Copy the toc header */
1439: if ((rc = mcd_toc_header(unit, &th)) != 0)
1440: return rc;
1441:
1442: /* verify starting track */
1443: trk = te->track;
1444: if (trk == 0)
1445: trk = th.starting_track;
1446: else if (trk == MCD_LASTPLUS1)
1447: trk = th.ending_track + 1;
1448: else if (trk < th.starting_track || trk > th.ending_track + 1)
1449: return EINVAL;
1450:
1451: /* Make sure we have a valid toc */
1452: if ((rc=mcd_read_toc(unit)) != 0)
1453: return rc;
1454:
1455: /* Copy the TOC data. */
1456: if (cd->toc[trk].idx_no == 0)
1457: return EIO;
1458:
1459: te->entry.control = cd->toc[trk].control;
1460: te->entry.addr_type = cd->toc[trk].addr_type;
1461: te->entry.track =
1462: cd->toc[trk].idx_no > 0x99 ? cd->toc[trk].idx_no :
1463: bcd2bin(cd->toc[trk].idx_no);
1464: switch (te->address_format) {
1465: case CD_MSF_FORMAT:
1466: te->entry.addr.msf.unused = 0;
1467: te->entry.addr.msf.minute = bcd2bin(cd->toc[trk].hd_pos_msf[0]);
1468: te->entry.addr.msf.second = bcd2bin(cd->toc[trk].hd_pos_msf[1]);
1469: te->entry.addr.msf.frame = bcd2bin(cd->toc[trk].hd_pos_msf[2]);
1470: break;
1471: case CD_LBA_FORMAT:
1472: te->entry.addr.lba = htonl(msf2hsg(cd->toc[trk].hd_pos_msf, 0));
1473: break;
1474: }
1475: return 0;
1476: }
1477: #endif
1478:
1479: static int
1480: mcd_toc_entrys(int unit, struct ioc_read_toc_entry *te)
1481: {
1482: struct mcd_data *cd = mcd_data + unit;
1483: struct cd_toc_entry entries[MCD_MAXTOCS];
1484: struct ioc_toc_header th;
1485: int rc, n, trk, len;
1486:
1487: if ( te->data_len < sizeof(entries[0])
1488: || (te->data_len % sizeof(entries[0])) != 0
1489: || (te->address_format != CD_MSF_FORMAT
1490: && te->address_format != CD_LBA_FORMAT)
1491: )
1492: return EINVAL;
1493:
1494: /* Copy the toc header */
1495: if ((rc = mcd_toc_header(unit, &th)) != 0)
1496: return rc;
1497:
1498: /* verify starting track */
1499: trk = te->starting_track;
1500: if (trk == 0)
1501: trk = th.starting_track;
1502: else if (trk == MCD_LASTPLUS1)
1503: trk = th.ending_track + 1;
1504: else if (trk < th.starting_track || trk > th.ending_track + 1)
1505: return EINVAL;
1506:
1507: len = ((th.ending_track + 1 - trk) + 1) *
1508: sizeof(entries[0]);
1509: if (te->data_len < len)
1510: len = te->data_len;
1511: if (len > sizeof(entries))
1512: return EINVAL;
1513:
1514: /* Make sure we have a valid toc */
1515: if ((rc=mcd_read_toc(unit)) != 0)
1516: return rc;
1517:
1518: /* Copy the TOC data. */
1519: for (n = 0; len > 0 && trk <= th.ending_track + 1; trk++) {
1520: if (cd->toc[trk].idx_no == 0)
1521: continue;
1522: entries[n].control = cd->toc[trk].control;
1523: entries[n].addr_type = cd->toc[trk].addr_type;
1524: entries[n].track =
1525: cd->toc[trk].idx_no > 0x99 ? cd->toc[trk].idx_no :
1526: bcd2bin(cd->toc[trk].idx_no);
1527: switch (te->address_format) {
1528: case CD_MSF_FORMAT:
1529: entries[n].addr.msf.unused = 0;
1530: entries[n].addr.msf.minute = bcd2bin(cd->toc[trk].hd_pos_msf[0]);
1531: entries[n].addr.msf.second = bcd2bin(cd->toc[trk].hd_pos_msf[1]);
1532: entries[n].addr.msf.frame = bcd2bin(cd->toc[trk].hd_pos_msf[2]);
1533: break;
1534: case CD_LBA_FORMAT:
1535: entries[n].addr.lba = htonl(msf2hsg(cd->toc[trk].hd_pos_msf, 0));
1536: break;
1537: }
1538: len -= sizeof(struct cd_toc_entry);
1539: n++;
1540: }
1541:
1542: /* copy the data back */
1543: return copyout(entries, te->data, n * sizeof(struct cd_toc_entry));
1544: }
1545:
1546: static int
1547: mcd_stop(int unit)
1548: {
1549: struct mcd_data *cd = mcd_data + unit;
1550:
1551: /* Verify current status */
1552: if (cd->audio_status != CD_AS_PLAY_IN_PROGRESS &&
1553: cd->audio_status != CD_AS_PLAY_PAUSED &&
1554: cd->audio_status != CD_AS_PLAY_COMPLETED) {
1555: if (cd->debug)
1556: printf("mcd%d: stop attempted when not playing, audio status %d\n",
1557: unit, cd->audio_status);
1558: return EINVAL;
1559: }
1560: if (cd->audio_status == CD_AS_PLAY_IN_PROGRESS)
1561: if (mcd_send(unit, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1562: return EIO;
1563: cd->audio_status = CD_AS_PLAY_COMPLETED;
1564: return 0;
1565: }
1566:
1567: static int
1568: mcd_getqchan(int unit, struct mcd_qchninfo *q)
1569: {
1570: struct mcd_data *cd = mcd_data + unit;
1571:
1572: if (mcd_send(unit, MCD_CMDGETQCHN, MCD_RETRYS) < 0)
1573: return -1;
1574: if (mcd_get(unit, (char *) q, sizeof(struct mcd_qchninfo)) < 0)
1575: return -1;
1576: if (cd->debug) {
1577: printf("mcd%d: getqchan control=0x%x addr_type=0x%x trk=%d ind=%d ttm=%d:%d.%d dtm=%d:%d.%d\n",
1578: unit,
1579: q->control, q->addr_type, bcd2bin(q->trk_no),
1580: bcd2bin(q->idx_no),
1581: bcd2bin(q->trk_size_msf[0]), bcd2bin(q->trk_size_msf[1]),
1582: bcd2bin(q->trk_size_msf[2]),
1583: bcd2bin(q->hd_pos_msf[0]), bcd2bin(q->hd_pos_msf[1]),
1584: bcd2bin(q->hd_pos_msf[2]));
1585: }
1586: return 0;
1587: }
1588:
1589: static int
1590: mcd_subchan(int unit, struct ioc_read_subchannel *sc)
1591: {
1592: struct mcd_data *cd = mcd_data + unit;
1593: struct mcd_qchninfo q;
1594: struct cd_sub_channel_info data;
1595: int lba;
1596:
1597: if (cd->debug)
1598: printf("mcd%d: subchan af=%d, df=%d\n", unit,
1599: sc->address_format,
1600: sc->data_format);
1601:
1602: if (sc->address_format != CD_MSF_FORMAT &&
1603: sc->address_format != CD_LBA_FORMAT)
1604: return EINVAL;
1605:
1606: if (sc->data_format != CD_CURRENT_POSITION &&
1607: sc->data_format != CD_MEDIA_CATALOG)
1608: return EINVAL;
1609:
1610: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
1611: return EIO;
1612:
1613: if (mcd_getqchan(unit, &q) < 0)
1614: return EIO;
1615:
1616: data.header.audio_status = cd->audio_status;
1617: data.what.position.data_format = sc->data_format;
1618:
1619: switch (sc->data_format) {
1620: case CD_MEDIA_CATALOG:
1621: data.what.media_catalog.mc_valid = 1;
1622: data.what.media_catalog.mc_number[0] = '\0';
1623: break;
1624:
1625: case CD_CURRENT_POSITION:
1626: data.what.position.control = q.control;
1627: data.what.position.addr_type = q.addr_type;
1628: data.what.position.track_number = bcd2bin(q.trk_no);
1629: data.what.position.index_number = bcd2bin(q.idx_no);
1630: switch (sc->address_format) {
1631: case CD_MSF_FORMAT:
1632: data.what.position.reladdr.msf.unused = 0;
1633: data.what.position.reladdr.msf.minute = bcd2bin(q.trk_size_msf[0]);
1634: data.what.position.reladdr.msf.second = bcd2bin(q.trk_size_msf[1]);
1635: data.what.position.reladdr.msf.frame = bcd2bin(q.trk_size_msf[2]);
1636: data.what.position.absaddr.msf.unused = 0;
1637: data.what.position.absaddr.msf.minute = bcd2bin(q.hd_pos_msf[0]);
1638: data.what.position.absaddr.msf.second = bcd2bin(q.hd_pos_msf[1]);
1639: data.what.position.absaddr.msf.frame = bcd2bin(q.hd_pos_msf[2]);
1640: break;
1641: case CD_LBA_FORMAT:
1642: lba = msf2hsg(q.trk_size_msf, 1);
1643: /*
1644: * Pre-gap has index number of 0, and decreasing MSF
1645: * address. Must be converted to negative LBA, per
1646: * SCSI spec.
1647: */
1648: if (data.what.position.index_number == 0)
1649: lba = -lba;
1650: data.what.position.reladdr.lba = htonl(lba);
1651: data.what.position.absaddr.lba = htonl(msf2hsg(q.hd_pos_msf, 0));
1652: break;
1653: }
1654: break;
1655: }
1656:
1657: return copyout(&data, sc->data, min(sizeof(struct cd_sub_channel_info), sc->data_len));
1658: }
1659:
1660: static int
1661: mcd_playmsf(int unit, struct ioc_play_msf *p)
1662: {
1663: struct mcd_data *cd = mcd_data + unit;
1664: struct mcd_read2 pb;
1665:
1666: if (cd->debug)
1667: printf("mcd%d: playmsf: from %d:%d.%d to %d:%d.%d\n",
1668: unit,
1669: p->start_m, p->start_s, p->start_f,
1670: p->end_m, p->end_s, p->end_f);
1671:
1672: if ((p->start_m * 60 * 75 + p->start_s * 75 + p->start_f) >=
1673: (p->end_m * 60 * 75 + p->end_s * 75 + p->end_f) ||
1674: (p->end_m * 60 * 75 + p->end_s * 75 + p->end_f) >
1675: M_msf(cd->volinfo.vol_msf) * 60 * 75 +
1676: S_msf(cd->volinfo.vol_msf) * 75 +
1677: F_msf(cd->volinfo.vol_msf))
1678: return EINVAL;
1679:
1680: pb.start_msf[0] = bin2bcd(p->start_m);
1681: pb.start_msf[1] = bin2bcd(p->start_s);
1682: pb.start_msf[2] = bin2bcd(p->start_f);
1683: pb.end_msf[0] = bin2bcd(p->end_m);
1684: pb.end_msf[1] = bin2bcd(p->end_s);
1685: pb.end_msf[2] = bin2bcd(p->end_f);
1686:
1687: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
1688: return EIO;
1689:
1690: return mcd_play(unit, &pb);
1691: }
1692:
1693: static int
1694: mcd_playtracks(int unit, struct ioc_play_track *pt)
1695: {
1696: struct mcd_data *cd = mcd_data + unit;
1697: struct mcd_read2 pb;
1698: int a = pt->start_track;
1699: int z = pt->end_track;
1700: int rc, i;
1701:
1702: if ((rc = mcd_read_toc(unit)) != 0)
1703: return rc;
1704:
1705: if (cd->debug)
1706: printf("mcd%d: playtracks from %d:%d to %d:%d\n", unit,
1707: a, pt->start_index, z, pt->end_index);
1708:
1709: if ( a < bcd2bin(cd->volinfo.trk_low)
1710: || a > bcd2bin(cd->volinfo.trk_high)
1711: || a > z
1712: || z < bcd2bin(cd->volinfo.trk_low)
1713: || z > bcd2bin(cd->volinfo.trk_high))
1714: return EINVAL;
1715:
1716: for (i = 0; i < 3; i++) {
1717: pb.start_msf[i] = cd->toc[a].hd_pos_msf[i];
1718: pb.end_msf[i] = cd->toc[z+1].hd_pos_msf[i];
1719: }
1720:
1721: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
1722: return EIO;
1723:
1724: return mcd_play(unit, &pb);
1725: }
1726:
1727: static int
1728: mcd_playblocks(int unit, struct ioc_play_blocks *p)
1729: {
1730: struct mcd_data *cd = mcd_data + unit;
1731: struct mcd_read2 pb;
1732:
1733: if (cd->debug)
1734: printf("mcd%d: playblocks: blkno %d length %d\n",
1735: unit, p->blk, p->len);
1736:
1737: if (p->blk > cd->disksize || p->len > cd->disksize ||
1738: p->blk < 0 || p->len < 0 ||
1739: (p->blk + p->len) > cd->disksize)
1740: return EINVAL;
1741:
1742: hsg2msf(p->blk, pb.start_msf);
1743: hsg2msf(p->blk + p->len, pb.end_msf);
1744:
1745: if (mcd_setmode(unit, MCD_MD_COOKED) != 0)
1746: return EIO;
1747:
1748: return mcd_play(unit, &pb);
1749: }
1750:
1751: static int
1752: mcd_play(int unit, struct mcd_read2 *pb)
1753: {
1754: struct mcd_data *cd = mcd_data + unit;
1755: int com_port = cd->iobase + mcd_command;
1756: int retry, st = -1, status;
1757:
1758: cd->lastpb = *pb;
1759: for(retry=0; retry<MCD_RETRYS; retry++) {
1760:
1761: cpu_disable_intr();
1762: outb(com_port, MCD_CMDSINGLESPEEDREAD);
1763: outb(com_port, pb->start_msf[0]);
1764: outb(com_port, pb->start_msf[1]);
1765: outb(com_port, pb->start_msf[2]);
1766: outb(com_port, pb->end_msf[0]);
1767: outb(com_port, pb->end_msf[1]);
1768: outb(com_port, pb->end_msf[2]);
1769: cpu_enable_intr();
1770:
1771: status=mcd_getstat(unit, 0);
1772: if (status == -1)
1773: continue;
1774: else if (status != -2)
1775: st = 0;
1776: break;
1777: }
1778:
1779: if (status == -2) {
1780: printf("mcd%d: media changed\n", unit);
1781: return ENXIO;
1782: }
1783: if (cd->debug)
1784: printf("mcd%d: mcd_play retry=%d, status=0x%02x\n", unit, retry, status);
1785: if (st < 0)
1786: return ENXIO;
1787: cd->audio_status = CD_AS_PLAY_IN_PROGRESS;
1788: return 0;
1789: }
1790:
1791: static int
1792: mcd_pause(int unit)
1793: {
1794: struct mcd_data *cd = mcd_data + unit;
1795: struct mcd_qchninfo q;
1796: int rc;
1797:
1798: /* Verify current status */
1799: if (cd->audio_status != CD_AS_PLAY_IN_PROGRESS &&
1800: cd->audio_status != CD_AS_PLAY_PAUSED) {
1801: if (cd->debug)
1802: printf("mcd%d: pause attempted when not playing, audio status %d\n",
1803: unit, cd->audio_status);
1804: return EINVAL;
1805: }
1806:
1807: /* Get the current position */
1808: if (mcd_getqchan(unit, &q) < 0)
1809: return EIO;
1810:
1811: /* Copy it into lastpb */
1812: cd->lastpb.start_msf[0] = q.hd_pos_msf[0];
1813: cd->lastpb.start_msf[1] = q.hd_pos_msf[1];
1814: cd->lastpb.start_msf[2] = q.hd_pos_msf[2];
1815:
1816: /* Stop playing */
1817: if ((rc=mcd_stop(unit)) != 0)
1818: return rc;
1819:
1820: /* Set the proper status and exit */
1821: cd->audio_status = CD_AS_PLAY_PAUSED;
1822: return 0;
1823: }
1824:
1825: static int
1826: mcd_resume(int unit)
1827: {
1828: struct mcd_data *cd = mcd_data + unit;
1829:
1830: if (cd->audio_status != CD_AS_PLAY_PAUSED)
1831: return EINVAL;
1832: return mcd_play(unit, &cd->lastpb);
1833: }
![[BACK]](/icons//back.gif){kind=icon}
Return to mcd.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / dev / disk / mcd