extractedLnx/linux-2.5.9/drivers/cdrom/cdrom.c_cdrom_ioctl.c

int cdrom_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
		       unsigned long arg)
{
	kdev_t dev = ip->i_rdev;
	struct cdrom_device_info *cdi = cdrom_find_device(dev);
	struct cdrom_device_ops *cdo = cdi->ops;
	int ret;

	/* the first few commands do not deal with audio drive_info, but
	   only with routines in cdrom device operations. */
	switch (cmd) {
	case CDROMMULTISESSION: {
		struct cdrom_multisession ms_info;
		u_char requested_format;
		cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n"); 
                if (!(cdo->capability & CDC_MULTI_SESSION))
                        return -ENOSYS;
		IOCTL_IN(arg, struct cdrom_multisession, ms_info);
		requested_format = ms_info.addr_format;
		if (!((requested_format == CDROM_MSF) ||
			(requested_format == CDROM_LBA)))
				return -EINVAL;
		ms_info.addr_format = CDROM_LBA;
		if ((ret=cdo->get_last_session(cdi, &ms_info)))
			return ret;
		sanitize_format(&ms_info.addr, &ms_info.addr_format,
				requested_format);
		IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
		cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n"); 
		return 0;
		}

	case CDROMEJECT: {
		cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n"); 
		if (!CDROM_CAN(CDC_OPEN_TRAY))
			return -ENOSYS;
		if (cdi->use_count != 1 || keeplocked)
			return -EBUSY;
		if (CDROM_CAN(CDC_LOCK))
			if ((ret=cdo->lock_door(cdi, 0)))
				return ret;

		return cdo->tray_move(cdi, 1);
		}

	case CDROMCLOSETRAY: {
		cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n"); 
		if (!CDROM_CAN(CDC_CLOSE_TRAY))
			return -ENOSYS;
		return cdo->tray_move(cdi, 0);
		}

	case CDROMEJECT_SW: {
		cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n"); 
		if (!CDROM_CAN(CDC_OPEN_TRAY))
			return -ENOSYS;
		if (keeplocked)
			return -EBUSY;
		cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
		if (arg)
			cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
		return 0;
		}

	case CDROM_MEDIA_CHANGED: {
		struct cdrom_changer_info info;

		cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n"); 
		if (!CDROM_CAN(CDC_MEDIA_CHANGED))
			return -ENOSYS;

		/* cannot select disc or select current disc */
		if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
			return media_changed(cdi, 1);

		if ((unsigned int)arg >= cdi->capacity)
			return -EINVAL;

		if ((ret = cdrom_read_mech_status(cdi, &info)))
			return ret;

		return info.slots[arg].change;
		}

	case CDROM_SET_OPTIONS: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n"); 
		/* options need to be in sync with capability. too late for
		   that, so we have to check each one separately... */
		switch (arg) {
		case CDO_USE_FFLAGS:
		case CDO_CHECK_TYPE:
			break;
		case CDO_LOCK:
			if (!CDROM_CAN(CDC_LOCK))
				return -ENOSYS;
			break;
		case 0:
			return cdi->options;
		/* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
		default:
			if (!CDROM_CAN(arg))
				return -ENOSYS;
		}
		cdi->options |= (int) arg;
		return cdi->options;
		}

	case CDROM_CLEAR_OPTIONS: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n"); 
		cdi->options &= ~(int) arg;
		return cdi->options;
		}

	case CDROM_SELECT_SPEED: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n"); 
		if (!CDROM_CAN(CDC_SELECT_SPEED))
			return -ENOSYS;
		return cdo->select_speed(cdi, arg);
		}

	case CDROM_SELECT_DISC: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n"); 
		if (!CDROM_CAN(CDC_SELECT_DISC))
			return -ENOSYS;

                if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
			if ((int)arg >= cdi->capacity)
				return -EINVAL;

		/* cdo->select_disc is a hook to allow a driver-specific
		 * way of seleting disc.  However, since there is no
		 * equiv hook for cdrom_slot_status this may not 
		 * actually be useful...
		 */
		if (cdo->select_disc != NULL)
			return cdo->select_disc(cdi, arg);

		/* no driver specific select_disc(), call our own */
		cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n"); 
		return cdrom_select_disc(cdi, arg);
		}

	case CDROMRESET: {
		if (!capable(CAP_SYS_ADMIN))
			return -EACCES;
		cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
		if (!CDROM_CAN(CDC_RESET))
			return -ENOSYS;
		return cdo->reset(cdi);
		}

	case CDROM_LOCKDOOR: {
		cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
		if (!CDROM_CAN(CDC_LOCK))
			return -EDRIVE_CANT_DO_THIS;
		keeplocked = arg ? 1 : 0;
		/* don't unlock the door on multiple opens,but allow root
		 * to do so */
		if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
			return -EBUSY;
		return cdo->lock_door(cdi, arg);
		}

	case CDROM_DEBUG: {
		if (!capable(CAP_SYS_ADMIN))
			return -EACCES;
		cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
		debug = arg ? 1 : 0;
		return debug;
		}

	case CDROM_GET_CAPABILITY: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
		return (cdo->capability & ~cdi->mask);
		}

/* The following function is implemented, although very few audio
 * discs give Universal Product Code information, which should just be
 * the Medium Catalog Number on the box.  Note, that the way the code
 * is written on the CD is /not/ uniform across all discs!
 */
	case CDROM_GET_MCN: {
		struct cdrom_mcn mcn;
		cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n"); 
		if (!(cdo->capability & CDC_MCN))
			return -ENOSYS;
		if ((ret=cdo->get_mcn(cdi, &mcn)))
			return ret;
		IOCTL_OUT(arg, struct cdrom_mcn, mcn);
		cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n"); 
		return 0;
		}

	case CDROM_DRIVE_STATUS: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n"); 
		if (!(cdo->capability & CDC_DRIVE_STATUS))
			return -ENOSYS;
		if (!CDROM_CAN(CDC_SELECT_DISC))
			return cdo->drive_status(cdi, CDSL_CURRENT);
                if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE)) 
			return cdo->drive_status(cdi, CDSL_CURRENT);
		if (((int)arg >= cdi->capacity))
			return -EINVAL;
		return cdrom_slot_status(cdi, arg);
		}

	/* Ok, this is where problems start.  The current interface for the
	   CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption
	   that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly,
	   while this is often the case, it is also very common for CDs to
	   have some tracks with data, and some tracks with audio.  Just 
	   because I feel like it, I declare the following to be the best
	   way to cope.  If the CD has ANY data tracks on it, it will be
	   returned as a data CD.  If it has any XA tracks, I will return
	   it as that.  Now I could simplify this interface by combining these 
	   returns with the above, but this more clearly demonstrates
	   the problem with the current interface.  Too bad this wasn't 
	   designed to use bitmasks...         -Erik 

	   Well, now we have the option CDS_MIXED: a mixed-type CD. 
	   User level programmers might feel the ioctl is not very useful.
	   					---david
	*/
	case CDROM_DISC_STATUS: {
		tracktype tracks;
		cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n"); 
		cdrom_count_tracks(cdi, &tracks);
		if (tracks.error) 
			return(tracks.error);

		/* Policy mode on */
		if (tracks.audio > 0) {
			if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0) 
				return CDS_AUDIO;
			else
				return CDS_MIXED;
		}
		if (tracks.cdi > 0) return CDS_XA_2_2;
		if (tracks.xa > 0) return CDS_XA_2_1;
		if (tracks.data > 0) return CDS_DATA_1;
		/* Policy mode off */

		cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
		return CDS_NO_INFO;
		}

	case CDROM_CHANGER_NSLOTS: {
		cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n"); 
		return cdi->capacity;
		}
	}

	/* use the ioctls that are implemented through the generic_packet()
	   interface. this may look at bit funny, but if -ENOTTY is
	   returned that particular ioctl is not implemented and we
	   let it go through the device specific ones. */
	if (CDROM_CAN(CDC_GENERIC_PACKET)) {
		ret = mmc_ioctl(cdi, cmd, arg);
		if (ret != -ENOTTY) {
			return ret;
		}
	}

	/* note: most of the cdinfo() calls are commented out here,
	   because they fill up the sys log when CD players poll
	   the drive. */
	switch (cmd) {
	case BLKROSET:
	case BLKROGET:
	case BLKFLSBUF:
	case BLKSSZGET:
		return blk_ioctl(ip->i_bdev, cmd, arg);
	case CDROMSUBCHNL: {
		struct cdrom_subchnl q;
		u_char requested, back;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		/* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/ 
		IOCTL_IN(arg, struct cdrom_subchnl, q);
		requested = q.cdsc_format;
		if (!((requested == CDROM_MSF) ||
		      (requested == CDROM_LBA)))
			return -EINVAL;
		q.cdsc_format = CDROM_MSF;
		if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
			return ret;
		back = q.cdsc_format; /* local copy */
		sanitize_format(&q.cdsc_absaddr, &back, requested);
		sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
		IOCTL_OUT(arg, struct cdrom_subchnl, q);
		/* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
		return 0;
		}
	case CDROMREADTOCHDR: {
		struct cdrom_tochdr header;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */ 
		IOCTL_IN(arg, struct cdrom_tochdr, header);
		if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
			return ret;
		IOCTL_OUT(arg, struct cdrom_tochdr, header);
		/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */ 
		return 0;
		}
	case CDROMREADTOCENTRY: {
		struct cdrom_tocentry entry;
		u_char requested_format;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		/* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */ 
		IOCTL_IN(arg, struct cdrom_tocentry, entry);
		requested_format = entry.cdte_format;
		if (!((requested_format == CDROM_MSF) || 
			(requested_format == CDROM_LBA)))
				return -EINVAL;
		/* make interface to low-level uniform */
		entry.cdte_format = CDROM_MSF;
		if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
			return ret;
		sanitize_format(&entry.cdte_addr,
		&entry.cdte_format, requested_format);
		IOCTL_OUT(arg, struct cdrom_tocentry, entry);
		/* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */ 
		return 0;
		}
	case CDROMPLAYMSF: {
		struct cdrom_msf msf;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 
		IOCTL_IN(arg, struct cdrom_msf, msf);
		return cdo->audio_ioctl(cdi, cmd, &msf);
		}
	case CDROMPLAYTRKIND: {
		struct cdrom_ti ti;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n"); 
		IOCTL_IN(arg, struct cdrom_ti, ti);
		CHECKAUDIO;
		return cdo->audio_ioctl(cdi, cmd, &ti);
		}
	case CDROMVOLCTRL: {
		struct cdrom_volctrl volume;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n"); 
		IOCTL_IN(arg, struct cdrom_volctrl, volume);
		return cdo->audio_ioctl(cdi, cmd, &volume);
		}
	case CDROMVOLREAD: {
		struct cdrom_volctrl volume;
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n"); 
		if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
			return ret;
		IOCTL_OUT(arg, struct cdrom_volctrl, volume);
		return 0;
		}
	case CDROMSTART:
	case CDROMSTOP:
	case CDROMPAUSE:
	case CDROMRESUME: {
		if (!CDROM_CAN(CDC_PLAY_AUDIO))
			return -ENOSYS;
		cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n"); 
		CHECKAUDIO;
		return cdo->audio_ioctl(cdi, cmd, NULL);
		}
	} /* switch */

	/* do the device specific ioctls */
	if (CDROM_CAN(CDC_IOCTLS))
		return cdo->dev_ioctl(cdi, cmd, arg);
	
	return -ENOSYS;
}