Deleted Added
sdiff udiff text old ( 6028 ) new ( 6604 )
full compact
mcd.c (6028) mcd.c (6604)
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
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 by Andrew A. Chernov
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

--- 168 unchanged lines hidden (view full) ---

182static int mcd_toc_entrys(int unit, struct ioc_read_toc_entry *te);
183static int mcd_stop(int unit);
184static int mcd_eject(int unit);
185static int mcd_playtracks(int unit, struct ioc_play_track *pt);
186static int mcd_play(int unit, struct mcd_read2 *pb);
187static int mcd_playmsf(int unit, struct ioc_play_msf *pt);
188static int mcd_pause(int unit);
189static int mcd_resume(int unit);
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

--- 168 unchanged lines hidden (view full) ---

182static int mcd_toc_entrys(int unit, struct ioc_read_toc_entry *te);
183static int mcd_stop(int unit);
184static int mcd_eject(int unit);
185static int mcd_playtracks(int unit, struct ioc_play_track *pt);
186static int mcd_play(int unit, struct mcd_read2 *pb);
187static int mcd_playmsf(int unit, struct ioc_play_msf *pt);
188static int mcd_pause(int unit);
189static int mcd_resume(int unit);
190static int mcd_lock_door(int unit, int lock);
191static int mcd_close_tray(int unit);
190
191extern int hz;
192extern int mcd_probe(struct isa_device *dev);
193extern int mcd_attach(struct isa_device *dev);
194struct isa_driver mcddriver = { mcd_probe, mcd_attach, "mcd" };
195
196#define mcd_put(port,byte) outb(port,byte)
197
198#define MCD_RETRYS 5
199#define MCD_RDRETRYS 8
200
192
193extern int hz;
194extern int mcd_probe(struct isa_device *dev);
195extern int mcd_attach(struct isa_device *dev);
196struct isa_driver mcddriver = { mcd_probe, mcd_attach, "mcd" };
197
198#define mcd_put(port,byte) outb(port,byte)
199
200#define MCD_RETRYS 5
201#define MCD_RDRETRYS 8
202
203#define CLOSE_TRAY_SECS 8
204#define DISK_SENSE_SECS 3
205#define WAIT_FRAC 4
206
201/* several delays */
202#define RDELAY_WAITSTAT 300
203#define RDELAY_WAITMODE 300
204#define RDELAY_WAITREAD 800
205
206#define MIN_DELAY 15
207/* several delays */
208#define RDELAY_WAITSTAT 300
209#define RDELAY_WAITMODE 300
210#define RDELAY_WAITREAD 800
211
212#define MIN_DELAY 15
207#define DELAY_GETREPLY 1300000
213#define DELAY_GETREPLY 1400000
208
209static struct kern_devconf kdc_mcd[NMCD] = { {
210 0, 0, 0, /* filled in by dev_attach */
211 "mcd", 0, { MDDT_ISA, 0, "bio" },
212 isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
213 &kdc_isa0, /* parent */
214 0, /* parentdata */
215 DC_IDLE, /* status */

--- 5 unchanged lines hidden (view full) ---

221{
222 if(id->id_unit)
223 kdc_mcd[id->id_unit] = kdc_mcd[0];
224 kdc_mcd[id->id_unit].kdc_unit = id->id_unit;
225 kdc_mcd[id->id_unit].kdc_isa = id;
226 dev_attach(&kdc_mcd[id->id_unit]);
227}
228
214
215static struct kern_devconf kdc_mcd[NMCD] = { {
216 0, 0, 0, /* filled in by dev_attach */
217 "mcd", 0, { MDDT_ISA, 0, "bio" },
218 isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
219 &kdc_isa0, /* parent */
220 0, /* parentdata */
221 DC_IDLE, /* status */

--- 5 unchanged lines hidden (view full) ---

227{
228 if(id->id_unit)
229 kdc_mcd[id->id_unit] = kdc_mcd[0];
230 kdc_mcd[id->id_unit].kdc_unit = id->id_unit;
231 kdc_mcd[id->id_unit].kdc_isa = id;
232 dev_attach(&kdc_mcd[id->id_unit]);
233}
234
229
230int mcd_attach(struct isa_device *dev)
231{
232 struct mcd_data *cd = mcd_data + dev->id_unit;
233 int i;
234
235 cd->iobase = dev->id_iobase;
236 cd->flags |= MCDINIT;
237 mcd_soft_reset(dev->id_unit);

--- 6 unchanged lines hidden (view full) ---

244 /* name filled in probe */
245 kdc_mcd[dev->id_unit].kdc_description = mcd_data[dev->id_unit].name;
246
247 return 1;
248}
249
250int mcdopen(dev_t dev)
251{
235int mcd_attach(struct isa_device *dev)
236{
237 struct mcd_data *cd = mcd_data + dev->id_unit;
238 int i;
239
240 cd->iobase = dev->id_iobase;
241 cd->flags |= MCDINIT;
242 mcd_soft_reset(dev->id_unit);

--- 6 unchanged lines hidden (view full) ---

249 /* name filled in probe */
250 kdc_mcd[dev->id_unit].kdc_description = mcd_data[dev->id_unit].name;
251
252 return 1;
253}
254
255int mcdopen(dev_t dev)
256{
252 int unit,part,phys;
257 int unit,part,phys,r,retry;
253 struct mcd_data *cd;
254
255 unit = mcd_unit(dev);
256 if (unit >= NMCD)
257 return ENXIO;
258
259 cd = mcd_data + unit;
260 part = mcd_part(dev);
261 phys = mcd_phys(dev);
262
263 /* not initialized*/
264 if (!(cd->flags & MCDINIT))
265 return ENXIO;
266
267 /* invalidated in the meantime? mark all open part's invalid */
268 if (!(cd->flags & MCDVALID) && cd->openflags)
269 return ENXIO;
270
258 struct mcd_data *cd;
259
260 unit = mcd_unit(dev);
261 if (unit >= NMCD)
262 return ENXIO;
263
264 cd = mcd_data + unit;
265 part = mcd_part(dev);
266 phys = mcd_phys(dev);
267
268 /* not initialized*/
269 if (!(cd->flags & MCDINIT))
270 return ENXIO;
271
272 /* invalidated in the meantime? mark all open part's invalid */
273 if (!(cd->flags & MCDVALID) && cd->openflags)
274 return ENXIO;
275
271 if (mcd_getstat(unit,1) == -1) /* detect disk change too */
272 return ENXIO;
276 if (mcd_close_tray(unit) == EIO) /* detect disk change too */
277 return EIO;
273
278
279 if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
280 || !(cd->status & MCDDSKIN))
281 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
282 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdsns", hz/WAIT_FRAC);
283 if ((r = mcd_getstat(unit,1)) == -1)
284 return EIO;
285 if (r != -2)
286 break;
287 }
288
274 if (cd->status & MCDDOOROPEN) {
275 printf("mcd%d: door is open\n");
276 return ENXIO;
277 }
278 if (!(cd->status & MCDDSKIN)) {
279 printf("mcd%d: no CD inside\n");
280 return ENXIO;
281 }
289 if (cd->status & MCDDOOROPEN) {
290 printf("mcd%d: door is open\n");
291 return ENXIO;
292 }
293 if (!(cd->status & MCDDSKIN)) {
294 printf("mcd%d: no CD inside\n");
295 return ENXIO;
296 }
297 if (cd->status & MCDDSKCHNG) {
298 printf("mcd%d: CD not sensed\n");
299 return ENXIO;
300 }
282
283 if (mcdsize(dev) < 0) {
284 printf("mcd%d: failed to get disk size\n",unit);
285 return ENXIO;
286 } else
287 cd->flags |= MCDVALID;
288
289 /* XXX get a default disklabel */

--- 5 unchanged lines hidden (view full) ---

295 if (part == RAW_PART ||
296 (part < cd->dlabel.d_npartitions &&
297 cd->dlabel.d_partitions[part].p_fstype != FS_UNUSED)) {
298 cd->partflags[part] |= MCDOPEN;
299 cd->openflags |= (1<<part);
300 if (part == RAW_PART && phys != 0)
301 cd->partflags[part] |= MCDREADRAW;
302 kdc_mcd[unit].kdc_state = DC_BUSY;
301
302 if (mcdsize(dev) < 0) {
303 printf("mcd%d: failed to get disk size\n",unit);
304 return ENXIO;
305 } else
306 cd->flags |= MCDVALID;
307
308 /* XXX get a default disklabel */

--- 5 unchanged lines hidden (view full) ---

314 if (part == RAW_PART ||
315 (part < cd->dlabel.d_npartitions &&
316 cd->dlabel.d_partitions[part].p_fstype != FS_UNUSED)) {
317 cd->partflags[part] |= MCDOPEN;
318 cd->openflags |= (1<<part);
319 if (part == RAW_PART && phys != 0)
320 cd->partflags[part] |= MCDREADRAW;
321 kdc_mcd[unit].kdc_state = DC_BUSY;
322 (void) mcd_lock_door(unit, MCD_LK_LOCK);
323 if (!(cd->flags & MCDVALID))
324 return ENXIO;
303 return 0;
304 }
305
306 return ENXIO;
307}
308
309int mcdclose(dev_t dev)
310{

--- 7 unchanged lines hidden (view full) ---

318 cd = mcd_data + unit;
319 part = mcd_part(dev);
320 phys = mcd_phys(dev);
321
322 if (!(cd->flags & MCDINIT))
323 return ENXIO;
324
325 kdc_mcd[unit].kdc_state = DC_IDLE;
325 return 0;
326 }
327
328 return ENXIO;
329}
330
331int mcdclose(dev_t dev)
332{

--- 7 unchanged lines hidden (view full) ---

340 cd = mcd_data + unit;
341 part = mcd_part(dev);
342 phys = mcd_phys(dev);
343
344 if (!(cd->flags & MCDINIT))
345 return ENXIO;
346
347 kdc_mcd[unit].kdc_state = DC_IDLE;
326 if (mcd_getstat(unit,1) == -2)
348 (void) mcd_lock_door(unit, MCD_LK_UNLOCK);
349
350 if (!(cd->flags & MCDVALID))
327 return 0;
328
329 /* close channel */
330 cd->partflags[part] &= ~(MCDOPEN|MCDREADRAW);
331 cd->openflags &= ~(1<<part);
332 MCD_TRACE("close: partition=%d\n",part,0,0,0);
333
334 return 0;

--- 123 unchanged lines hidden (view full) ---

458{
459 struct mcd_data *cd;
460 int unit,part;
461
462 unit = mcd_unit(dev);
463 part = mcd_part(dev);
464 cd = mcd_data + unit;
465
351 return 0;
352
353 /* close channel */
354 cd->partflags[part] &= ~(MCDOPEN|MCDREADRAW);
355 cd->openflags &= ~(1<<part);
356 MCD_TRACE("close: partition=%d\n",part,0,0,0);
357
358 return 0;

--- 123 unchanged lines hidden (view full) ---

482{
483 struct mcd_data *cd;
484 int unit,part;
485
486 unit = mcd_unit(dev);
487 part = mcd_part(dev);
488 cd = mcd_data + unit;
489
466 if (mcd_getstat(unit, 1) < 0) /* detect disk change too */
490 if (mcd_getstat(unit, 1) == -1) /* detect disk change too */
467 return EIO;
491 return EIO;
468 if (!(cd->flags & MCDVALID))
469 return EIO;
470MCD_TRACE("ioctl called 0x%x\n",cmd,0,0,0);
471
472 switch (cmd) {
473 case DIOCSBAD:
492MCD_TRACE("ioctl called 0x%x\n",cmd,0,0,0);
493
494 switch (cmd) {
495 case DIOCSBAD:
496 if (!(cd->flags & MCDVALID))
497 return ENXIO;
474 return EINVAL;
475 case DIOCGDINFO:
498 return EINVAL;
499 case DIOCGDINFO:
500 if (!(cd->flags & MCDVALID))
501 return ENXIO;
476 *(struct disklabel *) addr = cd->dlabel;
477 return 0;
478 case DIOCGPART:
502 *(struct disklabel *) addr = cd->dlabel;
503 return 0;
504 case DIOCGPART:
505 if (!(cd->flags & MCDVALID))
506 return ENXIO;
479 ((struct partinfo *) addr)->disklab = &cd->dlabel;
480 ((struct partinfo *) addr)->part =
481 &cd->dlabel.d_partitions[mcd_part(dev)];
482 return 0;
483
484 /*
485 * a bit silly, but someone might want to test something on a
486 * section of cdrom.
487 */
488 case DIOCWDINFO:
489 case DIOCSDINFO:
507 ((struct partinfo *) addr)->disklab = &cd->dlabel;
508 ((struct partinfo *) addr)->part =
509 &cd->dlabel.d_partitions[mcd_part(dev)];
510 return 0;
511
512 /*
513 * a bit silly, but someone might want to test something on a
514 * section of cdrom.
515 */
516 case DIOCWDINFO:
517 case DIOCSDINFO:
518 if (!(cd->flags & MCDVALID))
519 return ENXIO;
490 if ((flags & FWRITE) == 0)
491 return EBADF;
492 else {
493 return setdisklabel(&cd->dlabel,
494 (struct disklabel *) addr,
495 0);
496 }
497 case DIOCWLABEL:
520 if ((flags & FWRITE) == 0)
521 return EBADF;
522 else {
523 return setdisklabel(&cd->dlabel,
524 (struct disklabel *) addr,
525 0);
526 }
527 case DIOCWLABEL:
528 if (!(cd->flags & MCDVALID))
529 return ENXIO;
498 return EBADF;
499 case CDIOCPLAYTRACKS:
530 return EBADF;
531 case CDIOCPLAYTRACKS:
532 if (!(cd->flags & MCDVALID))
533 return ENXIO;
500 return mcd_playtracks(unit, (struct ioc_play_track *) addr);
501 case CDIOCPLAYBLOCKS:
534 return mcd_playtracks(unit, (struct ioc_play_track *) addr);
535 case CDIOCPLAYBLOCKS:
536 if (!(cd->flags & MCDVALID))
537 return ENXIO;
502 return EINVAL;
503 case CDIOCPLAYMSF:
538 return EINVAL;
539 case CDIOCPLAYMSF:
540 if (!(cd->flags & MCDVALID))
541 return ENXIO;
504 return mcd_playmsf(unit, (struct ioc_play_msf *) addr);
505 case CDIOCREADSUBCHANNEL:
542 return mcd_playmsf(unit, (struct ioc_play_msf *) addr);
543 case CDIOCREADSUBCHANNEL:
544 if (!(cd->flags & MCDVALID))
545 return ENXIO;
506 return mcd_subchan(unit, (struct ioc_read_subchannel *) addr);
507 case CDIOREADTOCHEADER:
546 return mcd_subchan(unit, (struct ioc_read_subchannel *) addr);
547 case CDIOREADTOCHEADER:
548 if (!(cd->flags & MCDVALID))
549 return ENXIO;
508 return mcd_toc_header(unit, (struct ioc_toc_header *) addr);
509 case CDIOREADTOCENTRYS:
550 return mcd_toc_header(unit, (struct ioc_toc_header *) addr);
551 case CDIOREADTOCENTRYS:
552 if (!(cd->flags & MCDVALID))
553 return ENXIO;
510 return mcd_toc_entrys(unit, (struct ioc_read_toc_entry *) addr);
511 case CDIOCSETPATCH:
512 case CDIOCGETVOL:
513 case CDIOCSETVOL:
514 case CDIOCSETMONO:
515 case CDIOCSETSTERIO:
516 case CDIOCSETMUTE:
517 case CDIOCSETLEFT:
518 case CDIOCSETRIGHT:
519 return EINVAL;
520 case CDIOCRESUME:
554 return mcd_toc_entrys(unit, (struct ioc_read_toc_entry *) addr);
555 case CDIOCSETPATCH:
556 case CDIOCGETVOL:
557 case CDIOCSETVOL:
558 case CDIOCSETMONO:
559 case CDIOCSETSTERIO:
560 case CDIOCSETMUTE:
561 case CDIOCSETLEFT:
562 case CDIOCSETRIGHT:
563 return EINVAL;
564 case CDIOCRESUME:
565 if (!(cd->flags & MCDVALID))
566 return ENXIO;
521 return mcd_resume(unit);
522 case CDIOCPAUSE:
567 return mcd_resume(unit);
568 case CDIOCPAUSE:
569 if (!(cd->flags & MCDVALID))
570 return ENXIO;
523 return mcd_pause(unit);
524 case CDIOCSTART:
571 return mcd_pause(unit);
572 case CDIOCSTART:
573 if (!(cd->flags & MCDVALID))
574 return ENXIO;
525 return EINVAL;
526 case CDIOCSTOP:
575 return EINVAL;
576 case CDIOCSTOP:
577 if (!(cd->flags & MCDVALID))
578 return ENXIO;
527 return mcd_stop(unit);
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:
579 return mcd_stop(unit);
580 case CDIOCEJECT:
581 return mcd_eject(unit);
582 case CDIOCSETDEBUG:
583 cd->debug = 1;
584 return 0;
585 case CDIOCCLRDEBUG:
586 cd->debug = 0;
587 return 0;
588 case CDIOCRESET:
589 return mcd_hard_reset(unit);
590 case CDIOCALLOW:
539 return 0;
591 return mcd_lock_door(unit, MCD_LK_UNLOCK);
540 default:
541 return ENOTTY;
542 }
543 /*NOTREACHED*/
544}
545
546/* this could have been taken from scsi/cd.c, but it is not clear
547 * whether the scsi cd driver is linked in

--- 202 unchanged lines hidden (view full) ---

750 int i;
751 struct mcd_data *cd = mcd_data + unit;
752 int port = cd->iobase;
753
754 /* get the status */
755 if (sflg)
756 outb(port+mcd_command, MCD_CMDGETSTAT);
757 i = mcd_getreply(unit,DELAY_GETREPLY);
592 default:
593 return ENOTTY;
594 }
595 /*NOTREACHED*/
596}
597
598/* this could have been taken from scsi/cd.c, but it is not clear
599 * whether the scsi cd driver is linked in

--- 202 unchanged lines hidden (view full) ---

802 int i;
803 struct mcd_data *cd = mcd_data + unit;
804 int port = cd->iobase;
805
806 /* get the status */
807 if (sflg)
808 outb(port+mcd_command, MCD_CMDGETSTAT);
809 i = mcd_getreply(unit,DELAY_GETREPLY);
758 if (i<0 || (i & MCD_ST_CMDCHECK)) return -1;
810 if (i<0 || (i & MCD_ST_CMDCHECK)) {
811 cd->curr_mode = MCD_MD_UNKNOWN;
812 return -1;
813 }
759
760 cd->status = i;
761
762 if (mcd_setflags(unit,cd) < 0)
763 return -2;
764 return cd->status;
765}
766

--- 102 unchanged lines hidden (view full) ---

869 return EIO;
870
871 /* get data */
872 if (mcd_get(unit,(char*) &cd->volinfo,sizeof(struct mcd_volinfo)) < 0) {
873 printf("mcd%d: mcd_volinfo: error read data\n",unit);
874 return EIO;
875 }
876
814
815 cd->status = i;
816
817 if (mcd_setflags(unit,cd) < 0)
818 return -2;
819 return cd->status;
820}
821

--- 102 unchanged lines hidden (view full) ---

924 return EIO;
925
926 /* get data */
927 if (mcd_get(unit,(char*) &cd->volinfo,sizeof(struct mcd_volinfo)) < 0) {
928 printf("mcd%d: mcd_volinfo: error read data\n",unit);
929 return EIO;
930 }
931
877 if (cd->volinfo.trk_low != 0 || cd->volinfo.trk_high != 0) {
932 if (cd->volinfo.trk_low > 0 &&
933 cd->volinfo.trk_high >= cd->volinfo.trk_low
934 ) {
878 cd->flags |= MCDVOLINFO; /* volinfo is OK */
879 return 0;
880 }
881
882 return EINVAL;
883}
884
885void

--- 28 unchanged lines hidden (view full) ---

914 caddr_t addr;
915
916loop:
917 switch (state) {
918 case MCD_S_BEGIN:
919 mbx = mbxsave = mbxin;
920
921 case MCD_S_BEGIN1:
935 cd->flags |= MCDVOLINFO; /* volinfo is OK */
936 return 0;
937 }
938
939 return EINVAL;
940}
941
942void

--- 28 unchanged lines hidden (view full) ---

971 caddr_t addr;
972
973loop:
974 switch (state) {
975 case MCD_S_BEGIN:
976 mbx = mbxsave = mbxin;
977
978 case MCD_S_BEGIN1:
922 /* get status */
923retry_status:
979retry_status:
980 /* get status */
924 outb(com_port, MCD_CMDGETSTAT);
925 mbx->count = RDELAY_WAITSTAT;
926 timeout((timeout_func_t)mcd_doread,
927 (caddr_t)MCD_S_WAITSTAT,hz/100); /* XXX */
928 return;
929 case MCD_S_WAITSTAT:
930 untimeout((timeout_func_t)mcd_doread,(caddr_t)MCD_S_WAITSTAT);
931 if (mbx->count-- >= 0) {

--- 9 unchanged lines hidden (view full) ---

941 goto changed;
942 MCD_TRACE("got WAITSTAT delay=%d\n",
943 RDELAY_WAITSTAT-mbx->count,0,0,0);
944 /* reject, if audio active */
945 if (cd->status & MCDAUDIOBSY) {
946 printf("mcd%d: audio is active\n",unit);
947 goto readerr;
948 }
981 outb(com_port, MCD_CMDGETSTAT);
982 mbx->count = RDELAY_WAITSTAT;
983 timeout((timeout_func_t)mcd_doread,
984 (caddr_t)MCD_S_WAITSTAT,hz/100); /* XXX */
985 return;
986 case MCD_S_WAITSTAT:
987 untimeout((timeout_func_t)mcd_doread,(caddr_t)MCD_S_WAITSTAT);
988 if (mbx->count-- >= 0) {

--- 9 unchanged lines hidden (view full) ---

998 goto changed;
999 MCD_TRACE("got WAITSTAT delay=%d\n",
1000 RDELAY_WAITSTAT-mbx->count,0,0,0);
1001 /* reject, if audio active */
1002 if (cd->status & MCDAUDIOBSY) {
1003 printf("mcd%d: audio is active\n",unit);
1004 goto readerr;
1005 }
1006
949retry_mode:
950 /* to check for raw/cooked mode */
951 if (cd->flags & MCDREADRAW) {
952 rm = MCD_MD_RAW;
953 mbx->sz = MCDRBLK;
954 } else {
955 rm = MCD_MD_COOKED;
956 mbx->sz = cd->blksize;

--- 24 unchanged lines hidden (view full) ---

981 goto readerr;
982 }
983 if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
984 timeout((timeout_func_t)mcd_doread,(caddr_t)MCD_S_WAITMODE,hz/100);
985 return;
986 }
987 cd->status = inb(port+mcd_status) & 0xFF;
988 if (cd->status & MCD_ST_CMDCHECK) {
1007retry_mode:
1008 /* to check for raw/cooked mode */
1009 if (cd->flags & MCDREADRAW) {
1010 rm = MCD_MD_RAW;
1011 mbx->sz = MCDRBLK;
1012 } else {
1013 rm = MCD_MD_COOKED;
1014 mbx->sz = cd->blksize;

--- 24 unchanged lines hidden (view full) ---

1039 goto readerr;
1040 }
1041 if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
1042 timeout((timeout_func_t)mcd_doread,(caddr_t)MCD_S_WAITMODE,hz/100);
1043 return;
1044 }
1045 cd->status = inb(port+mcd_status) & 0xFF;
1046 if (cd->status & MCD_ST_CMDCHECK) {
989 cd->curr_mode = MCD_MD_UNKNOWN;
1047 cd->curr_mode = MCD_MD_UNKNOWN;
990 goto retry_mode;
991 }
992 if (mcd_setflags(unit,cd) < 0)
993 goto changed;
994 cd->curr_mode = mbx->mode;
995 MCD_TRACE("got WAITMODE delay=%d\n",
996 RDELAY_WAITMODE-mbx->count,0,0,0);
997modedone:

--- 117 unchanged lines hidden (view full) ---

1115 /*cd->status &= ~MCDDSKCHNG; */
1116 cd->debug = 1; /* preventive set debug mode */
1117
1118#endif
1119
1120}
1121
1122static int
1048 goto retry_mode;
1049 }
1050 if (mcd_setflags(unit,cd) < 0)
1051 goto changed;
1052 cd->curr_mode = mbx->mode;
1053 MCD_TRACE("got WAITMODE delay=%d\n",
1054 RDELAY_WAITMODE-mbx->count,0,0,0);
1055modedone:

--- 117 unchanged lines hidden (view full) ---

1173 /*cd->status &= ~MCDDSKCHNG; */
1174 cd->debug = 1; /* preventive set debug mode */
1175
1176#endif
1177
1178}
1179
1180static int
1123mcd_eject(int unit)
1181mcd_lock_door(int unit, int lock)
1124{
1125 struct mcd_data *cd = mcd_data + unit;
1126 int port = cd->iobase;
1127
1182{
1183 struct mcd_data *cd = mcd_data + unit;
1184 int port = cd->iobase;
1185
1186 outb(port+mcd_command, MCD_CMDLOCKDRV);
1187 outb(port+mcd_command, lock);
1188 if (mcd_getstat(unit,0) == -1)
1189 return EIO;
1190 return 0;
1191}
1192
1193static int
1194mcd_close_tray(int unit)
1195{
1196 struct mcd_data *cd = mcd_data + unit;
1197 int port = cd->iobase;
1198 int retry, r;
1199
1200 if (mcd_getstat(unit,1) == -1)
1201 return EIO;
1202 if (cd->status & MCDDOOROPEN) {
1203 outb(port+mcd_command, MCD_CMDCLOSETRAY);
1204 for (retry = 0; retry < CLOSE_TRAY_SECS * WAIT_FRAC; retry++) {
1205 if (inb(port+MCD_FLAGS) & MFL_STATUS_NOT_AVAIL)
1206 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdcls", hz/WAIT_FRAC);
1207 else {
1208 if ((r = mcd_getstat(unit,0)) == -1)
1209 return EIO;
1210 return 0;
1211 }
1212 }
1213 return ENXIO;
1214 }
1215 return 0;
1216}
1217
1218static int
1219mcd_eject(int unit)
1220{
1221 struct mcd_data *cd = mcd_data + unit;
1222 int port = cd->iobase, r;
1223
1224 if (mcd_getstat(unit,1) == -1) /* detect disk change too */
1225 return EIO;
1226 if (cd->status & MCDDOOROPEN)
1227 return mcd_close_tray(unit);
1228 if ((r = mcd_stop(unit)) == EIO)
1229 return r;
1128 outb(port+mcd_command, MCD_CMDEJECTDISK);
1230 outb(port+mcd_command, MCD_CMDEJECTDISK);
1129 if (mcd_getstat(unit,0) == -1) return EIO;
1231 if (mcd_getstat(unit,0) == -1)
1232 return EIO;
1130 return 0;
1131}
1132
1133static int
1134mcd_hard_reset(int unit)
1135{
1136 struct mcd_data *cd = mcd_data + unit;
1137 int port = cd->iobase;

--- 189 unchanged lines hidden (view full) ---

1327 return 0;
1328}
1329
1330static int
1331mcd_stop(int unit)
1332{
1333 struct mcd_data *cd = mcd_data + unit;
1334
1233 return 0;
1234}
1235
1236static int
1237mcd_hard_reset(int unit)
1238{
1239 struct mcd_data *cd = mcd_data + unit;
1240 int port = cd->iobase;

--- 189 unchanged lines hidden (view full) ---

1430 return 0;
1431}
1432
1433static int
1434mcd_stop(int unit)
1435{
1436 struct mcd_data *cd = mcd_data + unit;
1437
1335 if (mcd_send(unit, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1336 return ENXIO;
1438 /* Verify current status */
1439 if (cd->audio_status != CD_AS_PLAY_IN_PROGRESS &&
1440 cd->audio_status != CD_AS_PLAY_PAUSED) {
1441 if (cd->debug)
1442 printf("mcd%d: stop attempted when not playing\n", unit);
1443 return EINVAL;
1444 }
1445 if (cd->audio_status == CD_AS_PLAY_IN_PROGRESS)
1446 if (mcd_send(unit, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1447 return EIO;
1337 cd->audio_status = CD_AS_PLAY_COMPLETED;
1338 return 0;
1339}
1340
1341static int
1342mcd_getqchan(int unit, struct mcd_qchninfo *q)
1343{
1344 struct mcd_data *cd = mcd_data + unit;

--- 189 unchanged lines hidden --- 		1448 cd->audio_status = CD_AS_PLAY_COMPLETED;
1449 return 0;
1450}
1451
1452static int
1453mcd_getqchan(int unit, struct mcd_qchninfo *q)
1454{
1455 struct mcd_data *cd = mcd_data + unit;

--- 189 unchanged lines hidden ---