Deleted Added
sdiff udiff text old ( 104519 ) new ( 104545 )
full compact
mcd.c (104519) mcd.c (104545)
1#include "opt_geom.h"
2#ifndef NO_GEOM
3#warning "The mcd driver is currently not compatible with GEOM"
4#else
5/*
6 * Copyright 1993 by Holger Veit (data part)
7 * Copyright 1993 by Brian Moore (audio part)
8 * Changes Copyright 1993 by Gary Clark II
9 * Changes Copyright (C) 1994-1995 by Andrey A. Chernov, Moscow, Russia
10 *
11 * Rewrote probe routine to work on newer Mitsumi drives.
12 * Additional changes (C) 1994 by Jordan K. Hubbard

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

39 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
40 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
41 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
42 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
43 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
44 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
45 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
46 *
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

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

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 *
47 * $FreeBSD: head/sys/dev/mcd/mcd.c 104519 2002-10-05 16:35:33Z phk $
43 * $FreeBSD: head/sys/dev/mcd/mcd.c 104545 2002-10-06 00:19:38Z mdodd $
48 */
49static const char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";
50
51#include <sys/param.h>
52#include <sys/systm.h>
53#include <sys/kernel.h>
54#include <sys/conf.h>
55#include <sys/fcntl.h>
56#include <sys/bio.h>
57#include <sys/cdio.h>
44 */
45static const char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";
46
47#include <sys/param.h>
48#include <sys/systm.h>
49#include <sys/kernel.h>
50#include <sys/conf.h>
51#include <sys/fcntl.h>
52#include <sys/bio.h>
53#include <sys/cdio.h>
58#include <sys/disklabel.h>
54#include
59#include <sys/bus.h>
60
61#include <machine/bus_pio.h>
62#include <machine/bus.h>
63#include <machine/resource.h>
64#include <sys/rman.h>
65
66#include <isa/isavar.h>

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

72{ \
73 if (sc->debug) { \
74 device_printf(sc->dev, "status=0x%02x: ", \
75 sc->data.status); \
76 printf(format, ## args); \
77 } \
78}
79
55#include <sys/bus.h>
56
57#include <machine/bus_pio.h>
58#include <machine/bus.h>
59#include <machine/resource.h>
60#include <sys/rman.h>
61
62#include <isa/isavar.h>

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

68{ \
69 if (sc->debug) { \
70 device_printf(sc->dev, "status=0x%02x: ", \
71 sc->data.status); \
72 printf(format, ## args); \
73 } \
74}
75
80#define mcd_part(dev) ((minor(dev)) & 7)
81#define mcd_unit(dev) (((minor(dev)) & 0x38) >> 3)
82#define mcd_phys(dev) (((minor(dev)) & 0x40) >> 6)
83#define RAW_PART 2
84
85/* flags */
86#define MCDVALID 0x0001 /* parameters loaded */
87#define MCDINIT 0x0002 /* device is init'd */
88#define MCDNEWMODEL 0x0004 /* device is new model */
89#define MCDLABEL 0x0008 /* label is read */
90#define MCDPROBING 0x0010 /* probing */

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

118#define MCD_S_BEGIN 0
119#define MCD_S_BEGIN1 1
120#define MCD_S_WAITSTAT 2
121#define MCD_S_WAITMODE 3
122#define MCD_S_WAITREAD 4
123
124/* prototypes */
125static void mcd_start(struct mcd_softc *);
76#define RAW_PART 2
77
78/* flags */
79#define MCDVALID 0x0001 /* parameters loaded */
80#define MCDINIT 0x0002 /* device is init'd */
81#define MCDNEWMODEL 0x0004 /* device is new model */
82#define MCDLABEL 0x0008 /* label is read */
83#define MCDPROBING 0x0010 /* probing */

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

111#define MCD_S_BEGIN 0
112#define MCD_S_BEGIN1 1
113#define MCD_S_WAITSTAT 2
114#define MCD_S_WAITMODE 3
115#define MCD_S_WAITREAD 4
116
117/* prototypes */
118static void mcd_start(struct mcd_softc *);
126static int mcd_getdisklabel(struct mcd_softc *);
127#ifdef NOTYET
128static void mcd_configure(struct mcd_softc *sc);
129#endif
130static int mcd_get(struct mcd_softc *, char *buf, int nmax);
131static int mcd_setflags(struct mcd_softc *);
132static int mcd_getstat(struct mcd_softc *,int sflg);
133static int mcd_send(struct mcd_softc *, int cmd,int nretrys);
134static void hsg2msf(int hsg, bcd_t *msf);

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

212 mcd_soft_reset(sc);
213 bioq_init(&cd->head);
214
215#ifdef NOTYET
216 /* wire controller for interrupts and dma */
217 mcd_configure(sc);
218#endif
219 /* name filled in probe */
119#ifdef NOTYET
120static void mcd_configure(struct mcd_softc *sc);
121#endif
122static int mcd_get(struct mcd_softc *, char *buf, int nmax);
123static int mcd_setflags(struct mcd_softc *);
124static int mcd_getstat(struct mcd_softc *,int sflg);
125static int mcd_send(struct mcd_softc *, int cmd,int nretrys);
126static void hsg2msf(int hsg, bcd_t *msf);

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

204 mcd_soft_reset(sc);
205 bioq_init(&cd->head);
206
207#ifdef NOTYET
208 /* wire controller for interrupts and dma */
209 mcd_configure(sc);
210#endif
211 /* name filled in probe */
220 sc->mcd_dev_t[0] = make_dev(&mcd_cdevsw, 0,
212 sc->mcd_dev_t = make_dev(&mcd_cdevsw, 8 * unit,
221 UID_ROOT, GID_OPERATOR, 0640, "mcd%d", unit);
213 UID_ROOT, GID_OPERATOR, 0640, "mcd%d", unit);
222 sc->mcd_dev_t[1] = make_dev_alias(sc->mcd_dev_t[0], "mcd%da", unit);
223 sc->mcd_dev_t[2] = make_dev_alias(sc->mcd_dev_t[0], "mcd%dc", unit);
224
214
225 sc->mcd_dev_t[0]->si_drv1 = sc->mcd_dev_t[1]->si_drv1 =
226 sc->mcd_dev_t[2]->si_drv1 = (void *)sc;
215 sc->mcd_dev_t->si_drv1 = (void *)sc;
227
228 return 0;
229}
230
231static int
232mcdopen(dev_t dev, int flags, int fmt, struct thread *td)
233{
234 struct mcd_softc *sc;
235 struct mcd_data *cd;
216
217 return 0;
218}
219
220static int
221mcdopen(dev_t dev, int flags, int fmt, struct thread *td)
222{
223 struct mcd_softc *sc;
224 struct mcd_data *cd;
236 int part,phys,r,retry;
225 int r,retry;
237
238 sc = (struct mcd_softc *)dev->si_drv1;
239 cd = &sc->data;
226
227 sc = (struct mcd_softc *)dev->si_drv1;
228 cd = &sc->data;
240 part = mcd_part(dev);
241 phys = mcd_phys(dev);
242
243 /* not initialized*/
244 if (!(cd->flags & MCDINIT))
245 return ENXIO;
246
247 /* invalidated in the meantime? mark all open part's invalid */
248 if (!(cd->flags & MCDVALID) && cd->openflags)
249 return ENXIO;

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

256 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
257 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdsn1", hz/WAIT_FRAC);
258 if ((r = mcd_getstat(sc, 1)) == -1)
259 return EIO;
260 if (r != -2)
261 break;
262 }
263
229
230 /* not initialized*/
231 if (!(cd->flags & MCDINIT))
232 return ENXIO;
233
234 /* invalidated in the meantime? mark all open part's invalid */
235 if (!(cd->flags & MCDVALID) && cd->openflags)
236 return ENXIO;

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

243 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
244 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdsn1", hz/WAIT_FRAC);
245 if ((r = mcd_getstat(sc, 1)) == -1)
246 return EIO;
247 if (r != -2)
248 break;
249 }
250
264 if (( (cd->status & (MCDDOOROPEN|MCDDSKCHNG))
265 || !(cd->status & MCDDSKIN)
266 )
267 && major(dev) == CDEV_MAJOR && part == RAW_PART
268 ) {
269 cd->openflags |= (1<<part);
270 if (phys)
271 cd->partflags[part] |= MCDREADRAW;
272 return 0;
273 }
274 if (cd->status & MCDDOOROPEN) {
275 device_printf(sc->dev, "door is open\n");
276 return ENXIO;
277 }
278 if (!(cd->status & MCDDSKIN)) {
279 device_printf(sc->dev, "no CD inside\n");
280 return ENXIO;
281 }
282 if (cd->status & MCDDSKCHNG) {
283 device_printf(sc->dev, "CD not sensed\n");
284 return ENXIO;
285 }
286
287 if (mcdsize(dev) < 0) {
251 if (cd->status & MCDDOOROPEN) {
252 device_printf(sc->dev, "door is open\n");
253 return ENXIO;
254 }
255 if (!(cd->status & MCDDSKIN)) {
256 device_printf(sc->dev, "no CD inside\n");
257 return ENXIO;
258 }
259 if (cd->status & MCDDSKCHNG) {
260 device_printf(sc->dev, "CD not sensed\n");
261 return ENXIO;
262 }
263
264 if (mcdsize(dev) < 0) {
288 if (major(dev) == CDEV_MAJOR && part == RAW_PART) {
289 cd->openflags |= (1<<part);
290 if (phys)
291 cd->partflags[part] |= MCDREADRAW;
292 return 0;
293 }
294 device_printf(sc->dev, "failed to get disk size\n");
295 return ENXIO;
265 device_printf(sc->dev, "failed to get disk size\n");
266 return ENXIO;
296 } else
297 cd->flags |= MCDVALID;
267 }
298
268
299 /* XXX get a default disklabel */
300 mcd_getdisklabel(sc);
301
302MCD_TRACE("open: partition=%d, disksize = %ld, blksize=%d\n",
303 part, cd->disksize, cd->blksize);
304
305 dev->si_bsize_phys = cd->blksize;
306
269 dev->si_bsize_phys = cd->blksize;
270
307 if (part == RAW_PART ||
308 (part < cd->dlabel.d_npartitions &&
309 cd->dlabel.d_partitions[part].p_fstype != FS_UNUSED)) {
310 cd->openflags |= (1<<part);
311 if (part == RAW_PART && phys)
312 cd->partflags[part] |= MCDREADRAW;
313 (void) mcd_lock_door(sc, MCD_LK_LOCK);
314 if (!(cd->flags & MCDVALID))
315 return ENXIO;
316 return 0;
317 }
271 cd->openflags = 1;
272 cd->partflags |= MCDREADRAW;
273 cd->flags |= MCDVALID;
318
274
319 return ENXIO;
275 (void) mcd_lock_door(sc, MCD_LK_LOCK);
276 if (!(cd->flags & MCDVALID))
277 return ENXIO;
278
279 return (mcd_read_toc(sc));
320}
321
322static int
323mcdclose(dev_t dev, int flags, int fmt, struct thread *td)
324{
325 struct mcd_softc *sc;
326 struct mcd_data *cd;
280}
281
282static int
283mcdclose(dev_t dev, int flags, int fmt, struct thread *td)
284{
285 struct mcd_softc *sc;
286 struct mcd_data *cd;
327 int part;
328
329 sc = (struct mcd_softc *)dev->si_drv1;
330 cd = &sc->data;
287
288 sc = (struct mcd_softc *)dev->si_drv1;
289 cd = &sc->data;
331 part = mcd_part(dev);
332
290
333 if (!(cd->flags & MCDINIT) || !(cd->openflags & (1<<part)))
291 if (!(cd->flags & MCDINIT) || !cd->openflags)
334 return ENXIO;
335
292 return ENXIO;
293
336 MCD_TRACE("close: partition=%d\n", part);
337
338 (void) mcd_lock_door(sc, MCD_LK_UNLOCK);
294 (void) mcd_lock_door(sc, MCD_LK_UNLOCK);
339 cd->openflags &= ~(1<<part);
340 cd->partflags[part] &= ~MCDREADRAW;
295 cd->openflags = 0;
296 cd->partflags &= ~MCDREADRAW;
341
342 return 0;
343}
344
345static void
346mcdstrategy(struct bio *bp)
347{
348 struct mcd_softc *sc;
349 struct mcd_data *cd;
350 int s;
351
297
298 return 0;
299}
300
301static void
302mcdstrategy(struct bio *bp)
303{
304 struct mcd_softc *sc;
305 struct mcd_data *cd;
306 int s;
307
352 int unit = mcd_unit(bp->bio_dev);
353
354 sc = (struct mcd_softc *)bp->bio_dev->si_drv1;
355 cd = &sc->data;
356
357 /* test validity */
358/*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n",
359 bp,unit,bp->bio_blkno,bp->bio_bcount);*/
308 sc = (struct mcd_softc *)bp->bio_dev->si_drv1;
309 cd = &sc->data;
310
311 /* test validity */
312/*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n",
313 bp,unit,bp->bio_blkno,bp->bio_bcount);*/
314
360 if (bp->bio_blkno < 0) {
315 if (bp->bio_blkno < 0) {
361 printf("mcdstrategy: unit = %d, blkno = %ld, bcount = %ld\n",
362 unit, (long)bp->bio_blkno, bp->bio_bcount);
363 printf("mcd: mcdstratregy failure");
316 device_printf(sc->dev, "strategy failure: blkno = %ld, bcount = %ld\n",
317 (long)bp->bio_blkno, bp->bio_bcount);
364 bp->bio_error = EINVAL;
365 bp->bio_flags |= BIO_ERROR;
366 goto bad;
367 }
368
369 /* if device invalidated (e.g. media change, door open), error */
370 if (!(cd->flags & MCDVALID)) {
318 bp->bio_error = EINVAL;
319 bp->bio_flags |= BIO_ERROR;
320 goto bad;
321 }
322
323 /* if device invalidated (e.g. media change, door open), error */
324 if (!(cd->flags & MCDVALID)) {
371MCD_TRACE("strategy: drive not valid\n");
325 device_printf(sc->dev, "media changed\n");
372 bp->bio_error = EIO;
373 goto bad;
374 }
375
376 /* read only */
377 if (!(bp->bio_cmd == BIO_READ)) {
378 bp->bio_error = EROFS;
379 goto bad;
380 }
381
382 /* no data to read */
383 if (bp->bio_bcount == 0)
384 goto done;
385
326 bp->bio_error = EIO;
327 goto bad;
328 }
329
330 /* read only */
331 if (!(bp->bio_cmd == BIO_READ)) {
332 bp->bio_error = EROFS;
333 goto bad;
334 }
335
336 /* no data to read */
337 if (bp->bio_bcount == 0)
338 goto done;
339
386 /* for non raw access, check partition limits */
387 if (mcd_part(bp->bio_dev) != RAW_PART) {
388 if (!(cd->flags & MCDLABEL)) {
389 bp->bio_error = EIO;
390 goto bad;
391 }
392 /* adjust transfer if necessary */
393 if (bounds_check_with_label(bp,&cd->dlabel,1) <= 0) {
394 goto done;
395 }
396 } else {
397 bp->bio_pblkno = bp->bio_blkno;
398 bp->bio_resid = 0;
340 if (!(cd->flags & MCDTOC)) {
341 bp->bio_error = EIO;
342 goto bad;
399 }
400
343 }
344
345 bp->bio_pblkno = bp->bio_blkno;
346 bp->bio_resid = 0;
347
401 /* queue it */
402 s = splbio();
403 bioqdisksort(&cd->head, bp);
404 splx(s);
405
406 /* now check whether we can perform processing */
407 mcd_start(sc);
408 return;

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

414 biodone(bp);
415 return;
416}
417
418static void
419mcd_start(struct mcd_softc *sc)
420{
421 struct mcd_data *cd = &sc->data;
348 /* queue it */
349 s = splbio();
350 bioqdisksort(&cd->head, bp);
351 splx(s);
352
353 /* now check whether we can perform processing */
354 mcd_start(sc);
355 return;

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

361 biodone(bp);
362 return;
363}
364
365static void
366mcd_start(struct mcd_softc *sc)
367{
368 struct mcd_data *cd = &sc->data;
422 struct partition *p;
423 struct bio *bp;
424 int s = splbio();
425
426 if (cd->flags & MCDMBXBSY) {
427 splx(s);
428 return;
429 }
430
431 bp = bioq_first(&cd->head);
432 if (bp != 0) {
433 /* block found to process, dequeue */
434 /*MCD_TRACE("mcd_start: found block bp=0x%x\n",bp,0,0,0);*/
435 bioq_remove(&cd->head, bp);
369 struct bio *bp;
370 int s = splbio();
371
372 if (cd->flags & MCDMBXBSY) {
373 splx(s);
374 return;
375 }
376
377 bp = bioq_first(&cd->head);
378 if (bp != 0) {
379 /* block found to process, dequeue */
380 /*MCD_TRACE("mcd_start: found block bp=0x%x\n",bp,0,0,0);*/
381 bioq_remove(&cd->head, bp);
382 cd->flags |= MCDMBXBSY;
436 splx(s);
437 } else {
438 /* nothing to do */
439 splx(s);
440 return;
441 }
442
383 splx(s);
384 } else {
385 /* nothing to do */
386 splx(s);
387 return;
388 }
389
443 /* changed media? */
444 if (!(cd->flags & MCDVALID)) {
445 MCD_TRACE("mcd_start: drive not valid\n");
446 return;
447 }
448
449 p = cd->dlabel.d_partitions + mcd_part(bp->bio_dev);
450
451 cd->flags |= MCDMBXBSY;
452 if (cd->partflags[mcd_part(bp->bio_dev)] & MCDREADRAW)
453 cd->flags |= MCDREADRAW;
454 cd->mbx.unit = device_get_unit(sc->dev);
455 cd->mbx.retry = MCD_RETRYS;
456 cd->mbx.bp = bp;
390 cd->mbx.retry = MCD_RETRYS;
391 cd->mbx.bp = bp;
457 cd->mbx.p_offset = p->p_offset;
458
392
459 /* calling the read routine */
460 mcd_doread(sc, MCD_S_BEGIN,&(cd->mbx));
393 mcd_doread(sc, MCD_S_BEGIN,&(cd->mbx));
461 /* triggers mcd_start, when successful finished */
462 return;
463}
464
465static int
466mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
467{
468 struct mcd_softc *sc;
469 struct mcd_data *cd;
394 return;
395}
396
397static int
398mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
399{
400 struct mcd_softc *sc;
401 struct mcd_data *cd;
470 int unit,part,retry,r;
402 int retry,r;
471
403
472 unit = mcd_unit(dev);
473 part = mcd_part(dev);
474 sc = (struct mcd_softc *)dev->si_drv1;
475 cd = &sc->data;
476
477 if (mcd_getstat(sc, 1) == -1) /* detect disk change too */
478 return EIO;
479MCD_TRACE("ioctl called 0x%lx\n", cmd);
480
481 switch (cmd) {

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

502 return mcd_lock_door(sc, MCD_LK_UNLOCK);
503 case CDIOCPREVENT:
504 return mcd_lock_door(sc, MCD_LK_LOCK);
505 case CDIOCCLOSE:
506 return mcd_inject(sc);
507 }
508
509 if (!(cd->flags & MCDVALID)) {
404 sc = (struct mcd_softc *)dev->si_drv1;
405 cd = &sc->data;
406
407 if (mcd_getstat(sc, 1) == -1) /* detect disk change too */
408 return EIO;
409MCD_TRACE("ioctl called 0x%lx\n", cmd);
410
411 switch (cmd) {

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

432 return mcd_lock_door(sc, MCD_LK_UNLOCK);
433 case CDIOCPREVENT:
434 return mcd_lock_door(sc, MCD_LK_LOCK);
435 case CDIOCCLOSE:
436 return mcd_inject(sc);
437 }
438
439 if (!(cd->flags & MCDVALID)) {
510 if ( major(dev) != CDEV_MAJOR
511 || part != RAW_PART
512 || !(cd->openflags & (1<<RAW_PART))
513 )
514 return ENXIO;
515 if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
516 || !(cd->status & MCDDSKIN))
517 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
518 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdsn2", hz/WAIT_FRAC);
519 if ((r = mcd_getstat(sc, 1)) == -1)
520 return EIO;
521 if (r != -2)
522 break;
523 }
524 if ( (cd->status & (MCDDOOROPEN|MCDDSKCHNG))
525 || !(cd->status & MCDDSKIN)
526 || mcdsize(dev) < 0
527 )
528 return ENXIO;
529 cd->flags |= MCDVALID;
440 if ( (cd->status & (MCDDSKCHNG|MCDDOOROPEN))
441 || !(cd->status & MCDDSKIN))
442 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
443 (void) tsleep((caddr_t)cd, PSOCK | PCATCH, "mcdsn2", hz/WAIT_FRAC);
444 if ((r = mcd_getstat(sc, 1)) == -1)
445 return EIO;
446 if (r != -2)
447 break;
448 }
449 if ( (cd->status & (MCDDOOROPEN|MCDDSKCHNG))
450 || !(cd->status & MCDDSKIN)
451 || mcdsize(dev) < 0
452 )
453 return ENXIO;
454 cd->flags |= MCDVALID;
530 mcd_getdisklabel(sc);
531 if (mcd_phys(dev))
532 cd->partflags[part] |= MCDREADRAW;
455 cd->partflags |= MCDREADRAW;
533 (void) mcd_lock_door(sc, MCD_LK_LOCK);
534 if (!(cd->flags & MCDVALID))
535 return ENXIO;
536 }
537
538 switch (cmd) {
456 (void) mcd_lock_door(sc, MCD_LK_LOCK);
457 if (!(cd->flags & MCDVALID))
458 return ENXIO;
459 }
460
461 switch (cmd) {
539 case DIOCGDINFO:
540 *(struct disklabel *) addr = cd->dlabel;
541 return 0;
542 /*
543 * a bit silly, but someone might want to test something on a
544 * section of cdrom.
545 */
546 case DIOCWDINFO:
547 case DIOCSDINFO:
548 if ((flags & FWRITE) == 0)
549 return EBADF;
550 else {
551 return setdisklabel(&cd->dlabel,
552 (struct disklabel *) addr,
553 0);
554 }
555 case DIOCWLABEL:
556 return EBADF;
462 case DIOCGMEDIASIZE:
463 *(off_t *)addr = (off_t)cd->disksize * cd->blksize;
464 return (0);
465 break;
466 case DIOCGSECTORSIZE:
467 *(u_int *)addr = cd->blksize;
468 return (0);
469 break;
470
557 case CDIOCPLAYTRACKS:
558 return mcd_playtracks(sc, (struct ioc_play_track *) addr);
559 case CDIOCPLAYBLOCKS:
560 return mcd_playblocks(sc, (struct ioc_play_blocks *) addr);
561 case CDIOCPLAYMSF:
562 return mcd_playmsf(sc, (struct ioc_play_msf *) addr);
563 case CDIOCREADSUBCHANNEL:
564 return mcd_subchan(sc, (struct ioc_read_subchannel *) addr);

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

577 case CDIOCSTOP:
578 return mcd_stop(sc);
579 default:
580 return ENOTTY;
581 }
582 /*NOTREACHED*/
583}
584
471 case CDIOCPLAYTRACKS:
472 return mcd_playtracks(sc, (struct ioc_play_track *) addr);
473 case CDIOCPLAYBLOCKS:
474 return mcd_playblocks(sc, (struct ioc_play_blocks *) addr);
475 case CDIOCPLAYMSF:
476 return mcd_playmsf(sc, (struct ioc_play_msf *) addr);
477 case CDIOCREADSUBCHANNEL:
478 return mcd_subchan(sc, (struct ioc_read_subchannel *) addr);

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

491 case CDIOCSTOP:
492 return mcd_stop(sc);
493 default:
494 return ENOTTY;
495 }
496 /*NOTREACHED*/
497}
498
585/* this could have been taken from scsi/cd.c, but it is not clear
586 * whether the scsi cd driver is linked in
587 */
588static int
499static int
589mcd_getdisklabel(struct mcd_softc *sc)
590{
591 struct mcd_data *cd = &sc->data;
592
593 if (cd->flags & MCDLABEL)
594 return -1;
595
596 bzero(&cd->dlabel,sizeof(struct disklabel));
597 /* filled with spaces first */
598 strncpy(cd->dlabel.d_typename," ",
599 sizeof(cd->dlabel.d_typename));
600 strncpy(cd->dlabel.d_typename, cd->name,
601 min(strlen(cd->name), sizeof(cd->dlabel.d_typename) - 1));
602 strncpy(cd->dlabel.d_packname,"unknown ",
603 sizeof(cd->dlabel.d_packname));
604 cd->dlabel.d_secsize = cd->blksize;
605 cd->dlabel.d_nsectors = 100;
606 cd->dlabel.d_ntracks = 1;
607 cd->dlabel.d_ncylinders = (cd->disksize/100)+1;
608 cd->dlabel.d_secpercyl = 100;
609 cd->dlabel.d_secperunit = cd->disksize;
610 cd->dlabel.d_rpm = 300;
611 cd->dlabel.d_interleave = 1;
612 cd->dlabel.d_flags = D_REMOVABLE;
613 cd->dlabel.d_npartitions= 1;
614 cd->dlabel.d_partitions[0].p_offset = 0;
615 cd->dlabel.d_partitions[0].p_size = cd->disksize;
616 cd->dlabel.d_partitions[0].p_fstype = 9;
617 cd->dlabel.d_magic = DISKMAGIC;
618 cd->dlabel.d_magic2 = DISKMAGIC;
619 cd->dlabel.d_checksum = dkcksum(&cd->dlabel);
620
621 cd->flags |= MCDLABEL;
622 return 0;
623}
624
625static int
626mcdsize(dev_t dev)
627{
628 struct mcd_softc *sc;
629 struct mcd_data *cd;
630 int size;
500mcdsize(dev_t dev)
501{
502 struct mcd_softc *sc;
503 struct mcd_data *cd;
504 int size;
631 int unit;
632
505
633 unit = mcd_unit(dev);
634 sc = (struct mcd_softc *)dev->si_drv1;
635 cd = &sc->data;
636
637 if (mcd_volinfo(sc) == 0) {
638 cd->blksize = MCDBLK;
639 size = msf2hsg(cd->volinfo.vol_msf, 0);
640 cd->disksize = size * (MCDBLK/DEV_BSIZE);
641 return 0;

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

1041 RDELAY_WAITMODE-mbx->count);
1042modedone:
1043 /* for first block */
1044 mbx->nblk = (bp->bio_bcount + (mbx->sz-1)) / mbx->sz;
1045 mbx->skip = 0;
1046
1047nextblock:
1048 blknum = (bp->bio_blkno / (mbx->sz/DEV_BSIZE))
506 sc = (struct mcd_softc *)dev->si_drv1;
507 cd = &sc->data;
508
509 if (mcd_volinfo(sc) == 0) {
510 cd->blksize = MCDBLK;
511 size = msf2hsg(cd->volinfo.vol_msf, 0);
512 cd->disksize = size * (MCDBLK/DEV_BSIZE);
513 return 0;

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

913 RDELAY_WAITMODE-mbx->count);
914modedone:
915 /* for first block */
916 mbx->nblk = (bp->bio_bcount + (mbx->sz-1)) / mbx->sz;
917 mbx->skip = 0;
918
919nextblock:
920 blknum = (bp->bio_blkno / (mbx->sz/DEV_BSIZE))
1049 + mbx->p_offset + mbx->skip/mbx->sz;
921 + mbx->skip/mbx->sz;
1050
1051 MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
1052 blknum, bp);
1053
1054 /* build parameter block */
1055 hsg2msf(blknum,rbuf.start_msf);
1056retry_read:
1057 /* send the read command */

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

1240 cd->audio_status = CD_AS_AUDIO_INVALID;
1241 return 0;
1242}
1243
1244static void
1245mcd_soft_reset(struct mcd_softc *sc)
1246{
1247 struct mcd_data *cd = &sc->data;
922
923 MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
924 blknum, bp);
925
926 /* build parameter block */
927 hsg2msf(blknum,rbuf.start_msf);
928retry_read:
929 /* send the read command */

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

1112 cd->audio_status = CD_AS_AUDIO_INVALID;
1113 return 0;
1114}
1115
1116static void
1117mcd_soft_reset(struct mcd_softc *sc)
1118{
1119 struct mcd_data *cd = &sc->data;
1248 int i;
1249
1250 cd->flags &= (MCDINIT|MCDPROBING|MCDNEWMODEL);
1251 cd->curr_mode = MCD_MD_UNKNOWN;
1120
1121 cd->flags &= (MCDINIT|MCDPROBING|MCDNEWMODEL);
1122 cd->curr_mode = MCD_MD_UNKNOWN;
1252 for (i=0; i<MAXPARTITIONS; i++) cd->partflags[i] = 0;
1123 cd->partflags = 0;
1253 cd->audio_status = CD_AS_AUDIO_INVALID;
1254}
1255
1256static int
1257mcd_setmode(struct mcd_softc *sc, int mode)
1258{
1259 struct mcd_data *cd = &sc->data;
1260 int retry, st;

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

1781mcd_resume(struct mcd_softc *sc)
1782{
1783 struct mcd_data *cd = &sc->data;
1784
1785 if (cd->audio_status != CD_AS_PLAY_PAUSED)
1786 return EINVAL;
1787 return mcd_play(sc, &cd->lastpb);
1788}
1124 cd->audio_status = CD_AS_AUDIO_INVALID;
1125}
1126
1127static int
1128mcd_setmode(struct mcd_softc *sc, int mode)
1129{
1130 struct mcd_data *cd = &sc->data;
1131 int retry, st;

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

1652mcd_resume(struct mcd_softc *sc)
1653{
1654 struct mcd_data *cd = &sc->data;
1655
1656 if (cd->audio_status != CD_AS_PLAY_PAUSED)
1657 return EINVAL;
1658 return mcd_play(sc, &cd->lastpb);
1659}
1789#endif /* GEOM */