[deliverable/linux.git] / drivers / ide / ide-cd_ioctl.c

/*
 * cdrom.c IOCTLs handling for ide-cd driver.
 *
 * Copyright (C) 1994-1996  Scott Snyder <snyder@fnald0.fnal.gov>
 * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
 * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
 */

#include <linux/kernel.h>
#include <linux/cdrom.h>
#include <linux/gfp.h>
#include <linux/ide.h>
#include <scsi/scsi.h>

#include "ide-cd.h"

/****************************************************************************
 * Other driver requests (open, close, check media change).
 */
int ide_cdrom_open_real(struct cdrom_device_info *cdi, int purpose)
{
	return 0;
}

/*
 * Close down the device.  Invalidate all cached blocks.
 */
void ide_cdrom_release_real(struct cdrom_device_info *cdi)
{
	ide_drive_t *drive = cdi->handle;

	if (!cdi->use_count)
		drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
}

/*
 * add logic to try GET_EVENT command first to check for media and tray
 * status. this should be supported by newer cd-r/w and all DVD etc
 * drives
 */
int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
{
	ide_drive_t *drive = cdi->handle;
	struct media_event_desc med;
	struct request_sense sense;
	int stat;

	if (slot_nr != CDSL_CURRENT)
		return -EINVAL;

	stat = cdrom_check_status(drive, &sense);
	if (!stat || sense.sense_key == UNIT_ATTENTION)
		return CDS_DISC_OK;

	if (!cdrom_get_media_event(cdi, &med)) {
		if (med.media_present)
			return CDS_DISC_OK;
		else if (med.door_open)
			return CDS_TRAY_OPEN;
		else
			return CDS_NO_DISC;
	}

	if (sense.sense_key == NOT_READY && sense.asc == 0x04
			&& sense.ascq == 0x04)
		return CDS_DISC_OK;

	/*
	 * If not using Mt Fuji extended media tray reports,
	 * just return TRAY_OPEN since ATAPI doesn't provide
	 * any other way to detect this...
	 */
	if (sense.sense_key == NOT_READY) {
		if (sense.asc == 0x3a && sense.ascq == 1)
			return CDS_NO_DISC;
		else
			return CDS_TRAY_OPEN;
	}
	return CDS_DRIVE_NOT_READY;
}

/*
 * ide-cd always generates media changed event if media is missing, which
 * makes it impossible to use for proper event reporting, so disk->events
 * is cleared to 0 and the following function is used only to trigger
 * revalidation and never propagated to userland.
 */
unsigned int ide_cdrom_check_events_real(struct cdrom_device_info *cdi,
					 unsigned int clearing, int slot_nr)
{
	ide_drive_t *drive = cdi->handle;
	int retval;

	if (slot_nr == CDSL_CURRENT) {
		(void) cdrom_check_status(drive, NULL);
		retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
		drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
		return retval ? DISK_EVENT_MEDIA_CHANGE : 0;
	} else {
		return 0;
	}
}

/* Eject the disk if EJECTFLAG is 0.
   If EJECTFLAG is 1, try to reload the disk. */
static
int cdrom_eject(ide_drive_t *drive, int ejectflag,
		struct request_sense *sense)
{
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
	char loej = 0x02;
	unsigned char cmd[BLK_MAX_CDB];

	if ((drive->atapi_flags & IDE_AFLAG_NO_EJECT) && !ejectflag)
		return -EDRIVE_CANT_DO_THIS;

	/* reload fails on some drives, if the tray is locked */
	if ((drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED) && ejectflag)
		return 0;

	/* only tell drive to close tray if open, if it can do that */
	if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
		loej = 0;

	memset(cmd, 0, BLK_MAX_CDB);

	cmd[0] = GPCMD_START_STOP_UNIT;
	cmd[4] = loej | (ejectflag != 0);

	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, 0);
}

/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
static
int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
		    struct request_sense *sense)
{
	struct request_sense my_sense;
	int stat;

	if (sense == NULL)
		sense = &my_sense;

	/* If the drive cannot lock the door, just pretend. */
	if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) {
		stat = 0;
	} else {
		unsigned char cmd[BLK_MAX_CDB];

		memset(cmd, 0, BLK_MAX_CDB);

		cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
		cmd[4] = lockflag ? 1 : 0;

		stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL,
				       sense, 0, 0);
	}

	/* If we got an illegal field error, the drive
	   probably cannot lock the door. */
	if (stat != 0 &&
	    sense->sense_key == ILLEGAL_REQUEST &&
	    (sense->asc == 0x24 || sense->asc == 0x20)) {
		printk(KERN_ERR "%s: door locking not supported\n",
			drive->name);
		drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
		stat = 0;
	}

	/* no medium, that's alright. */
	if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
		stat = 0;

	if (stat == 0) {
		if (lockflag)
			drive->atapi_flags |= IDE_AFLAG_DOOR_LOCKED;
		else
			drive->atapi_flags &= ~IDE_AFLAG_DOOR_LOCKED;
	}

	return stat;
}

int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
{
	ide_drive_t *drive = cdi->handle;
	struct request_sense sense;

	if (position) {
		int stat = ide_cd_lockdoor(drive, 0, &sense);

		if (stat)
			return stat;
	}

	return cdrom_eject(drive, !position, &sense);
}

int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
{
	ide_drive_t *drive = cdi->handle;

	return ide_cd_lockdoor(drive, lock, NULL);
}

/*
 * ATAPI devices are free to select the speed you request or any slower
 * rate. :-(  Requesting too fast a speed will _not_ produce an error.
 */
int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
{
	ide_drive_t *drive = cdi->handle;
	struct cdrom_info *cd = drive->driver_data;
	struct request_sense sense;
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	int stat;
	unsigned char cmd[BLK_MAX_CDB];

	if (speed == 0)
		speed = 0xffff; /* set to max */
	else
		speed *= 177;   /* Nx to kbytes/s */

	memset(cmd, 0, BLK_MAX_CDB);

	cmd[0] = GPCMD_SET_SPEED;
	/* Read Drive speed in kbytes/second MSB/LSB */
	cmd[2] = (speed >> 8) & 0xff;
	cmd[3] = speed & 0xff;
	if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
	    (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
		/* Write Drive speed in kbytes/second MSB/LSB */
		cmd[4] = (speed >> 8) & 0xff;
		cmd[5] = speed & 0xff;
	}

	stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);

	if (!ide_cdrom_get_capabilities(drive, buf)) {
		ide_cdrom_update_speed(drive, buf);
		cdi->speed = cd->current_speed;
	}

	return 0;
}

int ide_cdrom_get_last_session(struct cdrom_device_info *cdi,
			       struct cdrom_multisession *ms_info)
{
	struct atapi_toc *toc;
	ide_drive_t *drive = cdi->handle;
	struct cdrom_info *info = drive->driver_data;
	struct request_sense sense;
	int ret;

	if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0 || !info->toc) {
		ret = ide_cd_read_toc(drive, &sense);
		if (ret)
			return ret;
	}

	toc = info->toc;
	ms_info->addr.lba = toc->last_session_lba;
	ms_info->xa_flag = toc->xa_flag;

	return 0;
}

int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
		      struct cdrom_mcn *mcn_info)
{
	ide_drive_t *drive = cdi->handle;
	int stat, mcnlen;
	char buf[24];
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(buf);

	memset(cmd, 0, BLK_MAX_CDB);

	cmd[0] = GPCMD_READ_SUBCHANNEL;
	cmd[1] = 2;		/* MSF addressing */
	cmd[2] = 0x40;	/* request subQ data */
	cmd[3] = 2;		/* format */
	cmd[8] = len;

	stat = ide_cd_queue_pc(drive, cmd, 0, buf, &len, NULL, 0, 0);
	if (stat)
		return stat;

	mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
	memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
	mcn_info->medium_catalog_number[mcnlen] = '\0';

	return 0;
}

int ide_cdrom_reset(struct cdrom_device_info *cdi)
{
	ide_drive_t *drive = cdi->handle;
	struct cdrom_info *cd = drive->driver_data;
	struct request_sense sense;
	struct request *rq;
	int ret;

	rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
	rq->cmd_type = REQ_TYPE_DRV_PRIV;
	rq->cmd_flags = REQ_QUIET;
	ret = blk_execute_rq(drive->queue, cd->disk, rq, 0);
	blk_put_request(rq);
	/*
	 * A reset will unlock the door. If it was previously locked,
	 * lock it again.
	 */
	if (drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED)
		(void)ide_cd_lockdoor(drive, 1, &sense);

	return ret;
}

static int ide_cd_get_toc_entry(ide_drive_t *drive, int track,
				struct atapi_toc_entry **ent)
{
	struct cdrom_info *info = drive->driver_data;
	struct atapi_toc *toc = info->toc;
	int ntracks;

	/*
	 * don't serve cached data, if the toc isn't valid
	 */
	if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0)
		return -EINVAL;

	/* Check validity of requested track number. */
	ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;

	if (toc->hdr.first_track == CDROM_LEADOUT)
		ntracks = 0;

	if (track == CDROM_LEADOUT)
		*ent = &toc->ent[ntracks];
	else if (track < toc->hdr.first_track || track > toc->hdr.last_track)
		return -EINVAL;
	else
		*ent = &toc->ent[track - toc->hdr.first_track];

	return 0;
}

static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
{
	struct cdrom_ti *ti = arg;
	struct atapi_toc_entry *first_toc, *last_toc;
	unsigned long lba_start, lba_end;
	int stat;
	struct request_sense sense;
	unsigned char cmd[BLK_MAX_CDB];

	stat = ide_cd_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
	if (stat)
		return stat;

	stat = ide_cd_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
	if (stat)
		return stat;

	if (ti->cdti_trk1 != CDROM_LEADOUT)
		++last_toc;
	lba_start = first_toc->addr.lba;
	lba_end   = last_toc->addr.lba;

	if (lba_end <= lba_start)
		return -EINVAL;

	memset(cmd, 0, BLK_MAX_CDB);

	cmd[0] = GPCMD_PLAY_AUDIO_MSF;
	lba_to_msf(lba_start,   &cmd[3], &cmd[4], &cmd[5]);
	lba_to_msf(lba_end - 1, &cmd[6], &cmd[7], &cmd[8]);

	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);
}

static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
{
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_tochdr *tochdr = arg;
	struct atapi_toc *toc;
	int stat;

	/* Make sure our saved TOC is valid. */
	stat = ide_cd_read_toc(drive, NULL);
	if (stat)
		return stat;

	toc = cd->toc;
	tochdr->cdth_trk0 = toc->hdr.first_track;
	tochdr->cdth_trk1 = toc->hdr.last_track;

	return 0;
}

static int ide_cd_read_tocentry(ide_drive_t *drive, void *arg)
{
	struct cdrom_tocentry *tocentry = arg;
	struct atapi_toc_entry *toce;
	int stat;

	stat = ide_cd_get_toc_entry(drive, tocentry->cdte_track, &toce);
	if (stat)
		return stat;

	tocentry->cdte_ctrl = toce->control;
	tocentry->cdte_adr  = toce->adr;
	if (tocentry->cdte_format == CDROM_MSF) {
		lba_to_msf(toce->addr.lba,
			   &tocentry->cdte_addr.msf.minute,
			   &tocentry->cdte_addr.msf.second,
			   &tocentry->cdte_addr.msf.frame);
	} else
		tocentry->cdte_addr.lba = toce->addr.lba;

	return 0;
}

int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
			  unsigned int cmd, void *arg)
{
	ide_drive_t *drive = cdi->handle;

	switch (cmd) {
	/*
	 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
	 * atapi doesn't support it
	 */
	case CDROMPLAYTRKIND:
		return ide_cd_fake_play_trkind(drive, arg);
	case CDROMREADTOCHDR:
		return ide_cd_read_tochdr(drive, arg);
	case CDROMREADTOCENTRY:
		return ide_cd_read_tocentry(drive, arg);
	default:
		return -EINVAL;
	}
}

/* the generic packet interface to cdrom.c */
int ide_cdrom_packet(struct cdrom_device_info *cdi,
			    struct packet_command *cgc)
{
	ide_drive_t *drive = cdi->handle;
	unsigned int flags = 0;
	unsigned len = cgc->buflen;

	if (cgc->timeout <= 0)
		cgc->timeout = ATAPI_WAIT_PC;

	/* here we queue the commands from the uniform CD-ROM
	   layer. the packet must be complete, as we do not
	   touch it at all. */

	if (cgc->sense)
		memset(cgc->sense, 0, sizeof(struct request_sense));

	if (cgc->quiet)
		flags |= REQ_QUIET;

	cgc->stat = ide_cd_queue_pc(drive, cgc->cmd,
				    cgc->data_direction == CGC_DATA_WRITE,
				    cgc->buffer, &len,
				    cgc->sense, cgc->timeout, flags);
	if (!cgc->stat)
		cgc->buflen -= len;
	return cgc->stat;
}
Commit	Line	Data
17802998 BZ	1	/*
	2	* cdrom.c IOCTLs handling for ide-cd driver.
	3	*
	4	* Copyright (C) 1994-1996 Scott Snyder <snyder@fnald0.fnal.gov>
	5	* Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
	6	* Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/cdrom.h>
5a0e3ad6	11	#include <linux/gfp.h>
17802998	12	#include <linux/ide.h>
f9afd18b	13	#include <scsi/scsi.h>
17802998 BZ	14
	15	#include "ide-cd.h"
	16
f9afd18b BP	17	/****************************************************************************
	18	* Other driver requests (open, close, check media change).
	19	*/
	20	int ide_cdrom_open_real(struct cdrom_device_info *cdi, int purpose)
	21	{
	22	return 0;
	23	}
	24
	25	/*
	26	* Close down the device. Invalidate all cached blocks.
	27	*/
	28	void ide_cdrom_release_real(struct cdrom_device_info *cdi)
	29	{
	30	ide_drive_t *drive = cdi->handle;
f9afd18b BP	31
f9afd18b BP	32	if (!cdi->use_count)
570f89ea	33	drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
f9afd18b BP	34	}
	35
	36	/*
	37	* add logic to try GET_EVENT command first to check for media and tray
	38	* status. this should be supported by newer cd-r/w and all DVD etc
	39	* drives
	40	*/
	41	int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
	42	{
	43	ide_drive_t *drive = cdi->handle;
	44	struct media_event_desc med;
	45	struct request_sense sense;
	46	int stat;
	47
	48	if (slot_nr != CDSL_CURRENT)
	49	return -EINVAL;
	50
	51	stat = cdrom_check_status(drive, &sense);
	52	if (!stat \|\| sense.sense_key == UNIT_ATTENTION)
	53	return CDS_DISC_OK;
	54
	55	if (!cdrom_get_media_event(cdi, &med)) {
	56	if (med.media_present)
	57	return CDS_DISC_OK;
	58	else if (med.door_open)
	59	return CDS_TRAY_OPEN;
	60	else
	61	return CDS_NO_DISC;
	62	}
	63
	64	if (sense.sense_key == NOT_READY && sense.asc == 0x04
	65	&& sense.ascq == 0x04)
	66	return CDS_DISC_OK;
	67
	68	/*
	69	* If not using Mt Fuji extended media tray reports,
	70	* just return TRAY_OPEN since ATAPI doesn't provide
	71	* any other way to detect this...
	72	*/
	73	if (sense.sense_key == NOT_READY) {
	74	if (sense.asc == 0x3a && sense.ascq == 1)
	75	return CDS_NO_DISC;
	76	else
	77	return CDS_TRAY_OPEN;
	78	}
	79	return CDS_DRIVE_NOT_READY;
	80	}
	81
7eec77a1 TH	82	/*
	83	* ide-cd always generates media changed event if media is missing, which
	84	* makes it impossible to use for proper event reporting, so disk->events
	85	* is cleared to 0 and the following function is used only to trigger
	86	* revalidation and never propagated to userland.
	87	*/
5b03a1b1 TH	88	unsigned int ide_cdrom_check_events_real(struct cdrom_device_info *cdi,
5b03a1b1 TH	89	unsigned int clearing, int slot_nr)
f9afd18b BP	90	{
f9afd18b BP	91	ide_drive_t *drive = cdi->handle;
f9afd18b BP	92	int retval;
	93
	94	if (slot_nr == CDSL_CURRENT) {
	95	(void) cdrom_check_status(drive, NULL);
fe11edfa BZ	96	retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
fe11edfa BZ	97	drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
5b03a1b1	98	return retval ? DISK_EVENT_MEDIA_CHANGE : 0;
f9afd18b	99	} else {
5b03a1b1	100	return 0;
f9afd18b BP	101	}
	102	}
	103
	104	/* Eject the disk if EJECTFLAG is 0.
	105	If EJECTFLAG is 1, try to reload the disk. */
	106	static
	107	int cdrom_eject(ide_drive_t *drive, int ejectflag,
	108	struct request_sense *sense)
	109	{
	110	struct cdrom_info *cd = drive->driver_data;
	111	struct cdrom_device_info *cdi = &cd->devinfo;
f9afd18b	112	char loej = 0x02;
5f828546	113	unsigned char cmd[BLK_MAX_CDB];
f9afd18b	114
570f89ea	115	if ((drive->atapi_flags & IDE_AFLAG_NO_EJECT) && !ejectflag)
f9afd18b BP	116	return -EDRIVE_CANT_DO_THIS;
	117
	118	/* reload fails on some drives, if the tray is locked */
570f89ea	119	if ((drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED) && ejectflag)
f9afd18b BP	120	return 0;
f9afd18b BP	121
f9afd18b BP	122	/* only tell drive to close tray if open, if it can do that */
	123	if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
	124	loej = 0;
	125
5f828546 FT	126	memset(cmd, 0, BLK_MAX_CDB);
	127
	128	cmd[0] = GPCMD_START_STOP_UNIT;
	129	cmd[4] = loej \| (ejectflag != 0);
f9afd18b	130
1a677aba	131	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, 0);
f9afd18b BP	132	}
	133
	134	/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
	135	static
	136	int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
	137	struct request_sense *sense)
	138	{
f9afd18b	139	struct request_sense my_sense;
f9afd18b BP	140	int stat;
	141
	142	if (sense == NULL)
	143	sense = &my_sense;
	144
	145	/* If the drive cannot lock the door, just pretend. */
42619d35	146	if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) {
f9afd18b BP	147	stat = 0;
f9afd18b BP	148	} else {
5f828546 FT	149	unsigned char cmd[BLK_MAX_CDB];
	150
	151	memset(cmd, 0, BLK_MAX_CDB);
	152
	153	cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
	154	cmd[4] = lockflag ? 1 : 0;
	155
1a677aba	156	stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL,
5f828546	157	sense, 0, 0);
f9afd18b BP	158	}
	159
	160	/* If we got an illegal field error, the drive
	161	probably cannot lock the door. */
	162	if (stat != 0 &&
	163	sense->sense_key == ILLEGAL_REQUEST &&
	164	(sense->asc == 0x24 \|\| sense->asc == 0x20)) {
	165	printk(KERN_ERR "%s: door locking not supported\n",
	166	drive->name);
42619d35	167	drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
f9afd18b BP	168	stat = 0;
	169	}
	170
	171	/* no medium, that's alright. */
	172	if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
	173	stat = 0;
	174
	175	if (stat == 0) {
	176	if (lockflag)
570f89ea	177	drive->atapi_flags \|= IDE_AFLAG_DOOR_LOCKED;
f9afd18b	178	else
570f89ea	179	drive->atapi_flags &= ~IDE_AFLAG_DOOR_LOCKED;
f9afd18b BP	180	}
	181
	182	return stat;
	183	}
	184
	185	int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
	186	{
	187	ide_drive_t *drive = cdi->handle;
	188	struct request_sense sense;
	189
	190	if (position) {
	191	int stat = ide_cd_lockdoor(drive, 0, &sense);
	192
	193	if (stat)
	194	return stat;
	195	}
	196
	197	return cdrom_eject(drive, !position, &sense);
	198	}
	199
17802998 BZ	200	int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
	201	{
	202	ide_drive_t *drive = cdi->handle;
	203
	204	return ide_cd_lockdoor(drive, lock, NULL);
	205	}
	206
	207	/*
	208	* ATAPI devices are free to select the speed you request or any slower
	209	* rate. :-( Requesting too fast a speed will _not_ produce an error.
	210	*/
	211	int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
	212	{
	213	ide_drive_t *drive = cdi->handle;
	214	struct cdrom_info *cd = drive->driver_data;
17802998 BZ	215	struct request_sense sense;
	216	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	217	int stat;
5f828546	218	unsigned char cmd[BLK_MAX_CDB];
17802998 BZ	219
	220	if (speed == 0)
	221	speed = 0xffff; /* set to max */
	222	else
	223	speed = 177; / Nx to kbytes/s */
	224
5f828546 FT	225	memset(cmd, 0, BLK_MAX_CDB);
	226
	227	cmd[0] = GPCMD_SET_SPEED;
17802998	228	/* Read Drive speed in kbytes/second MSB/LSB */
5f828546 FT	229	cmd[2] = (speed >> 8) & 0xff;
5f828546 FT	230	cmd[3] = speed & 0xff;
17802998 BZ	231	if ((cdi->mask & (CDC_CD_R \| CDC_CD_RW \| CDC_DVD_R)) !=
	232	(CDC_CD_R \| CDC_CD_RW \| CDC_DVD_R)) {
	233	/* Write Drive speed in kbytes/second MSB/LSB */
5f828546 FT	234	cmd[4] = (speed >> 8) & 0xff;
5f828546 FT	235	cmd[5] = speed & 0xff;
17802998 BZ	236	}
17802998 BZ	237
1a677aba	238	stat = ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);
17802998 BZ	239
	240	if (!ide_cdrom_get_capabilities(drive, buf)) {
	241	ide_cdrom_update_speed(drive, buf);
	242	cdi->speed = cd->current_speed;
	243	}
	244
	245	return 0;
	246	}
	247
	248	int ide_cdrom_get_last_session(struct cdrom_device_info *cdi,
	249	struct cdrom_multisession *ms_info)
	250	{
	251	struct atapi_toc *toc;
	252	ide_drive_t *drive = cdi->handle;
	253	struct cdrom_info *info = drive->driver_data;
	254	struct request_sense sense;
	255	int ret;
	256
570f89ea	257	if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0 \|\| !info->toc) {
17802998 BZ	258	ret = ide_cd_read_toc(drive, &sense);
	259	if (ret)
	260	return ret;
	261	}
	262
	263	toc = info->toc;
	264	ms_info->addr.lba = toc->last_session_lba;
	265	ms_info->xa_flag = toc->xa_flag;
	266
	267	return 0;
	268	}
	269
	270	int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
	271	struct cdrom_mcn *mcn_info)
	272	{
	273	ide_drive_t *drive = cdi->handle;
	274	int stat, mcnlen;
17802998	275	char buf[24];
5f828546 FT	276	unsigned char cmd[BLK_MAX_CDB];
5f828546 FT	277	unsigned len = sizeof(buf);
17802998	278
5f828546	279	memset(cmd, 0, BLK_MAX_CDB);
17802998	280
5f828546 FT	281	cmd[0] = GPCMD_READ_SUBCHANNEL;
	282	cmd[1] = 2; /* MSF addressing */
	283	cmd[2] = 0x40; /* request subQ data */
	284	cmd[3] = 2; /* format */
	285	cmd[8] = len;
17802998	286
5f828546	287	stat = ide_cd_queue_pc(drive, cmd, 0, buf, &len, NULL, 0, 0);
17802998 BZ	288	if (stat)
	289	return stat;
	290
	291	mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
	292	memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
	293	mcn_info->medium_catalog_number[mcnlen] = '\0';
	294
	295	return 0;
	296	}
	297
	298	int ide_cdrom_reset(struct cdrom_device_info *cdi)
	299	{
	300	ide_drive_t *drive = cdi->handle;
	301	struct cdrom_info *cd = drive->driver_data;
	302	struct request_sense sense;
0ef4c4db	303	struct request *rq;
17802998 BZ	304	int ret;
17802998 BZ	305
71baba4b	306	rq = blk_get_request(drive->queue, READ, __GFP_RECLAIM);
4f8c9510	307	rq->cmd_type = REQ_TYPE_DRV_PRIV;
0ef4c4db FT	308	rq->cmd_flags = REQ_QUIET;
	309	ret = blk_execute_rq(drive->queue, cd->disk, rq, 0);
	310	blk_put_request(rq);
17802998 BZ	311	/*
	312	* A reset will unlock the door. If it was previously locked,
	313	* lock it again.
	314	*/
570f89ea	315	if (drive->atapi_flags & IDE_AFLAG_DOOR_LOCKED)
17802998 BZ	316	(void)ide_cd_lockdoor(drive, 1, &sense);
	317
	318	return ret;
	319	}
	320
	321	static int ide_cd_get_toc_entry(ide_drive_t *drive, int track,
	322	struct atapi_toc_entry **ent)
	323	{
	324	struct cdrom_info *info = drive->driver_data;
	325	struct atapi_toc *toc = info->toc;
	326	int ntracks;
	327
	328	/*
	329	* don't serve cached data, if the toc isn't valid
	330	*/
570f89ea	331	if ((drive->atapi_flags & IDE_AFLAG_TOC_VALID) == 0)
17802998 BZ	332	return -EINVAL;
	333
	334	/* Check validity of requested track number. */
	335	ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
	336
	337	if (toc->hdr.first_track == CDROM_LEADOUT)
	338	ntracks = 0;
	339
	340	if (track == CDROM_LEADOUT)
	341	*ent = &toc->ent[ntracks];
	342	else if (track < toc->hdr.first_track \|\| track > toc->hdr.last_track)
	343	return -EINVAL;
	344	else
	345	*ent = &toc->ent[track - toc->hdr.first_track];
	346
	347	return 0;
	348	}
	349
	350	static int ide_cd_fake_play_trkind(ide_drive_t drive, void arg)
	351	{
	352	struct cdrom_ti *ti = arg;
	353	struct atapi_toc_entry first_toc, last_toc;
	354	unsigned long lba_start, lba_end;
	355	int stat;
17802998	356	struct request_sense sense;
5f828546	357	unsigned char cmd[BLK_MAX_CDB];
17802998 BZ	358
	359	stat = ide_cd_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
	360	if (stat)
	361	return stat;
	362
	363	stat = ide_cd_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
	364	if (stat)
	365	return stat;
	366
	367	if (ti->cdti_trk1 != CDROM_LEADOUT)
	368	++last_toc;
	369	lba_start = first_toc->addr.lba;
	370	lba_end = last_toc->addr.lba;
	371
	372	if (lba_end <= lba_start)
	373	return -EINVAL;
	374
5f828546	375	memset(cmd, 0, BLK_MAX_CDB);
17802998	376
5f828546 FT	377	cmd[0] = GPCMD_PLAY_AUDIO_MSF;
	378	lba_to_msf(lba_start, &cmd[3], &cmd[4], &cmd[5]);
	379	lba_to_msf(lba_end - 1, &cmd[6], &cmd[7], &cmd[8]);
17802998	380
1a677aba	381	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, &sense, 0, 0);
17802998 BZ	382	}
	383
	384	static int ide_cd_read_tochdr(ide_drive_t drive, void arg)
	385	{
	386	struct cdrom_info *cd = drive->driver_data;
	387	struct cdrom_tochdr *tochdr = arg;
	388	struct atapi_toc *toc;
	389	int stat;
	390
	391	/* Make sure our saved TOC is valid. */
	392	stat = ide_cd_read_toc(drive, NULL);
	393	if (stat)
	394	return stat;
	395
	396	toc = cd->toc;
	397	tochdr->cdth_trk0 = toc->hdr.first_track;
	398	tochdr->cdth_trk1 = toc->hdr.last_track;
	399
	400	return 0;
	401	}
	402
	403	static int ide_cd_read_tocentry(ide_drive_t drive, void arg)
	404	{
	405	struct cdrom_tocentry *tocentry = arg;
	406	struct atapi_toc_entry *toce;
	407	int stat;
	408
	409	stat = ide_cd_get_toc_entry(drive, tocentry->cdte_track, &toce);
	410	if (stat)
	411	return stat;
	412
	413	tocentry->cdte_ctrl = toce->control;
	414	tocentry->cdte_adr = toce->adr;
	415	if (tocentry->cdte_format == CDROM_MSF) {
	416	lba_to_msf(toce->addr.lba,
	417	&tocentry->cdte_addr.msf.minute,
	418	&tocentry->cdte_addr.msf.second,
	419	&tocentry->cdte_addr.msf.frame);
	420	} else
	421	tocentry->cdte_addr.lba = toce->addr.lba;
	422
	423	return 0;
	424	}
	425
	426	int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
	427	unsigned int cmd, void *arg)
	428	{
	429	ide_drive_t *drive = cdi->handle;
	430
	431	switch (cmd) {
	432	/*
	433	* emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
	434	* atapi doesn't support it
	435	*/
	436	case CDROMPLAYTRKIND:
	437	return ide_cd_fake_play_trkind(drive, arg);
	438	case CDROMREADTOCHDR:
	439	return ide_cd_read_tochdr(drive, arg);
	440	case CDROMREADTOCENTRY:
	441	return ide_cd_read_tocentry(drive, arg);
	442	default:
	443	return -EINVAL;
	444	}
	445	}
f9afd18b BP	446
	447	/* the generic packet interface to cdrom.c */
	448	int ide_cdrom_packet(struct cdrom_device_info *cdi,
	449	struct packet_command *cgc)
	450	{
f9afd18b	451	ide_drive_t *drive = cdi->handle;
5f828546 FT	452	unsigned int flags = 0;
5f828546 FT	453	unsigned len = cgc->buflen;
f9afd18b BP	454
	455	if (cgc->timeout <= 0)
	456	cgc->timeout = ATAPI_WAIT_PC;
	457
	458	/* here we queue the commands from the uniform CD-ROM
	459	layer. the packet must be complete, as we do not
	460	touch it at all. */
b348487f	461
f9afd18b BP	462	if (cgc->sense)
f9afd18b BP	463	memset(cgc->sense, 0, sizeof(struct request_sense));
f9afd18b BP	464
f9afd18b BP	465	if (cgc->quiet)
5f828546	466	flags \|= REQ_QUIET;
f9afd18b	467
5f828546 FT	468	cgc->stat = ide_cd_queue_pc(drive, cgc->cmd,
	469	cgc->data_direction == CGC_DATA_WRITE,
	470	cgc->buffer, &len,
	471	cgc->sense, cgc->timeout, flags);
f9afd18b	472	if (!cgc->stat)
5f828546	473	cgc->buflen -= len;
f9afd18b BP	474	return cgc->stat;
f9afd18b BP	475	}