[linux.git] / drivers / ide / ide-iops.c

/*
 *  Copyright (C) 2000-2002	Andre Hedrick <[email protected]>
 *  Copyright (C) 2003		Red Hat
 *
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/blkpg.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/bitops.h>
#include <linux/nmi.h>

#include <asm/byteorder.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>

void SELECT_MASK(ide_drive_t *drive, int mask)
{
	const struct ide_port_ops *port_ops = drive->hwif->port_ops;

	if (port_ops && port_ops->maskproc)
		port_ops->maskproc(drive, mask);
}

u8 ide_read_error(ide_drive_t *drive)
{
	struct ide_taskfile tf;

	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);

	return tf.error;
}
EXPORT_SYMBOL_GPL(ide_read_error);

void ide_fix_driveid(u16 *id)
{
#ifndef __LITTLE_ENDIAN
# ifdef __BIG_ENDIAN
	int i;

	for (i = 0; i < 256; i++)
		id[i] = __le16_to_cpu(id[i]);
# else
#  error "Please fix <asm/byteorder.h>"
# endif
#endif
}

/*
 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
 * removing leading/trailing blanks and compressing internal blanks.
 * It is primarily used to tidy up the model name/number fields as
 * returned by the ATA_CMD_ID_ATA[PI] commands.
 */

void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
{
	u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */

	if (byteswap) {
		/* convert from big-endian to host byte order */
		for (p = s ; p != end ; p += 2)
			be16_to_cpus((u16 *) p);
	}

	/* strip leading blanks */
	p = s;
	while (s != end && *s == ' ')
		++s;
	/* compress internal blanks and strip trailing blanks */
	while (s != end && *s) {
		if (*s++ != ' ' || (s != end && *s && *s != ' '))
			*p++ = *(s-1);
	}
	/* wipe out trailing garbage */
	while (p != end)
		*p++ = '\0';
}
EXPORT_SYMBOL(ide_fixstring);

/*
 * This routine busy-waits for the drive status to be not "busy".
 * It then checks the status for all of the "good" bits and none
 * of the "bad" bits, and if all is okay it returns 0.  All other
 * cases return error -- caller may then invoke ide_error().
 *
 * This routine should get fixed to not hog the cpu during extra long waits..
 * That could be done by busy-waiting for the first jiffy or two, and then
 * setting a timer to wake up at half second intervals thereafter,
 * until timeout is achieved, before timing out.
 */
int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
		    unsigned long timeout, u8 *rstat)
{
	ide_hwif_t *hwif = drive->hwif;
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
	unsigned long flags;
	int i;
	u8 stat;

	udelay(1);	/* spec allows drive 400ns to assert "BUSY" */
	stat = tp_ops->read_status(hwif);

	if (stat & ATA_BUSY) {
		local_save_flags(flags);
		local_irq_enable_in_hardirq();
		timeout += jiffies;
		while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
			if (time_after(jiffies, timeout)) {
				/*
				 * One last read after the timeout in case
				 * heavy interrupt load made us not make any
				 * progress during the timeout..
				 */
				stat = tp_ops->read_status(hwif);
				if ((stat & ATA_BUSY) == 0)
					break;

				local_irq_restore(flags);
				*rstat = stat;
				return -EBUSY;
			}
		}
		local_irq_restore(flags);
	}
	/*
	 * Allow status to settle, then read it again.
	 * A few rare drives vastly violate the 400ns spec here,
	 * so we'll wait up to 10usec for a "good" status
	 * rather than expensively fail things immediately.
	 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
	 */
	for (i = 0; i < 10; i++) {
		udelay(1);
		stat = tp_ops->read_status(hwif);

		if (OK_STAT(stat, good, bad)) {
			*rstat = stat;
			return 0;
		}
	}
	*rstat = stat;
	return -EFAULT;
}

/*
 * In case of error returns error value after doing "*startstop = ide_error()".
 * The caller should return the updated value of "startstop" in this case,
 * "startstop" is unchanged when the function returns 0.
 */
int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
		  u8 bad, unsigned long timeout)
{
	int err;
	u8 stat;

	/* bail early if we've exceeded max_failures */
	if (drive->max_failures && (drive->failures > drive->max_failures)) {
		*startstop = ide_stopped;
		return 1;
	}

	err = __ide_wait_stat(drive, good, bad, timeout, &stat);

	if (err) {
		char *s = (err == -EBUSY) ? "status timeout" : "status error";
		*startstop = ide_error(drive, s, stat);
	}

	return err;
}
EXPORT_SYMBOL(ide_wait_stat);

/**
 *	ide_in_drive_list	-	look for drive in black/white list
 *	@id: drive identifier
 *	@table: list to inspect
 *
 *	Look for a drive in the blacklist and the whitelist tables
 *	Returns 1 if the drive is found in the table.
 */

int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
{
	for ( ; table->id_model; table++)
		if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
		    (!table->id_firmware ||
		     strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
			return 1;
	return 0;
}
EXPORT_SYMBOL_GPL(ide_in_drive_list);

/*
 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
 * Some optical devices with the buggy firmwares have the same problem.
 */
static const struct drive_list_entry ivb_list[] = {
	{ "QUANTUM FIREBALLlct10 05"	, "A03.0900"	},
	{ "QUANTUM FIREBALLlct20 30"	, "APL.0900"	},
	{ "TSSTcorp CDDVDW SH-S202J"	, "SB00"	},
	{ "TSSTcorp CDDVDW SH-S202J"	, "SB01"	},
	{ "TSSTcorp CDDVDW SH-S202N"	, "SB00"	},
	{ "TSSTcorp CDDVDW SH-S202N"	, "SB01"	},
	{ "TSSTcorp CDDVDW SH-S202H"	, "SB00"	},
	{ "TSSTcorp CDDVDW SH-S202H"	, "SB01"	},
	{ "SAMSUNG SP0822N"		, "WA100-10"	},
	{ NULL				, NULL		}
};

/*
 *  All hosts that use the 80c ribbon must use!
 *  The name is derived from upper byte of word 93 and the 80c ribbon.
 */
u8 eighty_ninty_three(ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
	u16 *id = drive->id;
	int ivb = ide_in_drive_list(id, ivb_list);

	if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
		return 1;

	if (ivb)
		printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
				  drive->name);

	if (ata_id_is_sata(id) && !ivb)
		return 1;

	if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
		goto no_80w;

	/*
	 * FIXME:
	 * - change master/slave IDENTIFY order
	 * - force bit13 (80c cable present) check also for !ivb devices
	 *   (unless the slave device is pre-ATA3)
	 */
	if (id[ATA_ID_HW_CONFIG] & 0x4000)
		return 1;

	if (ivb) {
		const char *model = (char *)&id[ATA_ID_PROD];

		if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
			/*
			 * These ATAPI devices always report 80c cable
			 * so we have to depend on the host in this case.
			 */
			if (hwif->cbl == ATA_CBL_PATA80)
				return 1;
		} else {
			/* Depend on the device side cable detection. */
			if (id[ATA_ID_HW_CONFIG] & 0x2000)
				return 1;
		}
	}
no_80w:
	if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
		return 0;

	printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
			    "limiting max speed to UDMA33\n",
			    drive->name,
			    hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");

	drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;

	return 0;
}

static const char *nien_quirk_list[] = {
	"QUANTUM FIREBALLlct08 08",
	"QUANTUM FIREBALLP KA6.4",
	"QUANTUM FIREBALLP KA9.1",
	"QUANTUM FIREBALLP KX13.6",
	"QUANTUM FIREBALLP KX20.5",
	"QUANTUM FIREBALLP KX27.3",
	"QUANTUM FIREBALLP LM20.4",
	"QUANTUM FIREBALLP LM20.5",
	"FUJITSU MHZ2160BH G2",
	NULL
};

void ide_check_nien_quirk_list(ide_drive_t *drive)
{
	const char **list, *m = (char *)&drive->id[ATA_ID_PROD];

	for (list = nien_quirk_list; *list != NULL; list++)
		if (strstr(m, *list) != NULL) {
			drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
			return;
		}
}

int ide_driveid_update(ide_drive_t *drive)
{
	u16 *id;
	int rc;

	id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
	if (id == NULL)
		return 0;

	SELECT_MASK(drive, 1);
	rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
	SELECT_MASK(drive, 0);

	if (rc)
		goto out_err;

	drive->id[ATA_ID_UDMA_MODES]  = id[ATA_ID_UDMA_MODES];
	drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
	drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
	drive->id[ATA_ID_CFA_MODES]   = id[ATA_ID_CFA_MODES];
	/* anything more ? */

	kfree(id);

	return 1;
out_err:
	if (rc == 2)
		printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
	kfree(id);
	return 0;
}

int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
{
	ide_hwif_t *hwif = drive->hwif;
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
	struct ide_taskfile tf;
	u16 *id = drive->id, i;
	int error = 0;
	u8 stat;

#ifdef CONFIG_BLK_DEV_IDEDMA
	if (hwif->dma_ops)	/* check if host supports DMA */
		hwif->dma_ops->dma_host_set(drive, 0);
#endif

	/* Skip setting PIO flow-control modes on pre-EIDE drives */
	if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
		goto skip;

	/*
	 * Don't use ide_wait_cmd here - it will
	 * attempt to set_geometry and recalibrate,
	 * but for some reason these don't work at
	 * this point (lost interrupt).
	 */

	udelay(1);
	tp_ops->dev_select(drive);
	SELECT_MASK(drive, 1);
	udelay(1);
	tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);

	memset(&tf, 0, sizeof(tf));
	tf.feature = SETFEATURES_XFER;
	tf.nsect   = speed;

	tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);

	tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);

	if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
		tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);

	error = __ide_wait_stat(drive, drive->ready_stat,
				ATA_BUSY | ATA_DRQ | ATA_ERR,
				WAIT_CMD, &stat);

	SELECT_MASK(drive, 0);

	if (error) {
		(void) ide_dump_status(drive, "set_drive_speed_status", stat);
		return error;
	}

	if (speed >= XFER_SW_DMA_0) {
		id[ATA_ID_UDMA_MODES]  &= ~0xFF00;
		id[ATA_ID_MWDMA_MODES] &= ~0x0700;
		id[ATA_ID_SWDMA_MODES] &= ~0x0700;
		if (ata_id_is_cfa(id))
			id[ATA_ID_CFA_MODES] &= ~0x0E00;
	} else	if (ata_id_is_cfa(id))
		id[ATA_ID_CFA_MODES] &= ~0x01C0;

 skip:
#ifdef CONFIG_BLK_DEV_IDEDMA
	if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
		hwif->dma_ops->dma_host_set(drive, 1);
	else if (hwif->dma_ops)	/* check if host supports DMA */
		ide_dma_off_quietly(drive);
#endif

	if (speed >= XFER_UDMA_0) {
		i = 1 << (speed - XFER_UDMA_0);
		id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
	} else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
		i = speed - XFER_MW_DMA_2;
		id[ATA_ID_CFA_MODES] |= i << 9;
	} else if (speed >= XFER_MW_DMA_0) {
		i = 1 << (speed - XFER_MW_DMA_0);
		id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
	} else if (speed >= XFER_SW_DMA_0) {
		i = 1 << (speed - XFER_SW_DMA_0);
		id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
	} else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
		i = speed - XFER_PIO_4;
		id[ATA_ID_CFA_MODES] |= i << 6;
	}

	if (!drive->init_speed)
		drive->init_speed = speed;
	drive->current_speed = speed;
	return error;
}

/*
 * This should get invoked any time we exit the driver to
 * wait for an interrupt response from a drive.  handler() points
 * at the appropriate code to handle the next interrupt, and a
 * timer is started to prevent us from waiting forever in case
 * something goes wrong (see the ide_timer_expiry() handler later on).
 *
 * See also ide_execute_command
 */
void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
		       unsigned int timeout)
{
	ide_hwif_t *hwif = drive->hwif;

	BUG_ON(hwif->handler);
	hwif->handler		= handler;
	hwif->timer.expires	= jiffies + timeout;
	hwif->req_gen_timer	= hwif->req_gen;
	add_timer(&hwif->timer);
}

void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
		     unsigned int timeout)
{
	ide_hwif_t *hwif = drive->hwif;
	unsigned long flags;

	spin_lock_irqsave(&hwif->lock, flags);
	__ide_set_handler(drive, handler, timeout);
	spin_unlock_irqrestore(&hwif->lock, flags);
}
EXPORT_SYMBOL(ide_set_handler);

/**
 *	ide_execute_command	-	execute an IDE command
 *	@drive: IDE drive to issue the command against
 *	@cmd: command
 *	@handler: handler for next phase
 *	@timeout: timeout for command
 *
 *	Helper function to issue an IDE command. This handles the
 *	atomicity requirements, command timing and ensures that the
 *	handler and IRQ setup do not race. All IDE command kick off
 *	should go via this function or do equivalent locking.
 */

void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
			 ide_handler_t *handler, unsigned timeout)
{
	ide_hwif_t *hwif = drive->hwif;
	unsigned long flags;

	spin_lock_irqsave(&hwif->lock, flags);
	if ((cmd->protocol != ATAPI_PROT_DMA &&
	     cmd->protocol != ATAPI_PROT_PIO) ||
	    (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
		__ide_set_handler(drive, handler, timeout);
	hwif->tp_ops->exec_command(hwif, cmd->tf.command);
	/*
	 * Drive takes 400nS to respond, we must avoid the IRQ being
	 * serviced before that.
	 *
	 * FIXME: we could skip this delay with care on non shared devices
	 */
	ndelay(400);
	spin_unlock_irqrestore(&hwif->lock, flags);
}

/*
 * ide_wait_not_busy() waits for the currently selected device on the hwif
 * to report a non-busy status, see comments in ide_probe_port().
 */
int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
{
	u8 stat = 0;

	while (timeout--) {
		/*
		 * Turn this into a schedule() sleep once I'm sure
		 * about locking issues (2.5 work ?).
		 */
		mdelay(1);
		stat = hwif->tp_ops->read_status(hwif);
		if ((stat & ATA_BUSY) == 0)
			return 0;
		/*
		 * Assume a value of 0xff means nothing is connected to
		 * the interface and it doesn't implement the pull-down
		 * resistor on D7.
		 */
		if (stat == 0xff)
			return -ENODEV;
		touch_softlockup_watchdog();
		touch_nmi_watchdog();
	}
	return -EBUSY;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4	2	* Copyright (C) 2000-2002 Andre Hedrick <[email protected]>
ccd32e22	3	* Copyright (C) 2003 Red Hat
1da177e4 LT	4	*
	5	*/
	6
1da177e4 LT	7	#include <linux/module.h>
	8	#include <linux/types.h>
	9	#include <linux/string.h>
	10	#include <linux/kernel.h>
	11	#include <linux/timer.h>
	12	#include <linux/mm.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/major.h>
	15	#include <linux/errno.h>
	16	#include <linux/genhd.h>
	17	#include <linux/blkpg.h>
	18	#include <linux/slab.h>
	19	#include <linux/pci.h>
	20	#include <linux/delay.h>
1da177e4 LT	21	#include <linux/ide.h>
1da177e4 LT	22	#include <linux/bitops.h>
1e86240f	23	#include <linux/nmi.h>
1da177e4 LT	24
	25	#include <asm/byteorder.h>
	26	#include <asm/irq.h>
	27	#include <asm/uaccess.h>
	28	#include <asm/io.h>
	29
ed4af48f	30	void SELECT_MASK(ide_drive_t *drive, int mask)
1da177e4	31	{
ac95beed BZ	32	const struct ide_port_ops *port_ops = drive->hwif->port_ops;
	33
	34	if (port_ops && port_ops->maskproc)
	35	port_ops->maskproc(drive, mask);
1da177e4 LT	36	}
1da177e4 LT	37
92eb4380 BZ	38	u8 ide_read_error(ide_drive_t *drive)
92eb4380 BZ	39	{
3153c26b	40	struct ide_taskfile tf;
92eb4380	41
3153c26b	42	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
92eb4380	43
3153c26b	44	return tf.error;
92eb4380 BZ	45	}
	46	EXPORT_SYMBOL_GPL(ide_read_error);
	47
4dde4492	48	void ide_fix_driveid(u16 *id)
1da177e4 LT	49	{
	50	#ifndef __LITTLE_ENDIAN
	51	# ifdef __BIG_ENDIAN
	52	int i;
5b90e990	53
48fb2688	54	for (i = 0; i < 256; i++)
5b90e990	55	id[i] = __le16_to_cpu(id[i]);
1da177e4 LT	56	# else
	57	# error "Please fix <asm/byteorder.h>"
	58	# endif
	59	#endif
	60	}
	61
01745112 BZ	62	/*
	63	* ide_fixstring() cleans up and (optionally) byte-swaps a text string,
	64	* removing leading/trailing blanks and compressing internal blanks.
	65	* It is primarily used to tidy up the model name/number fields as
aaaade3f	66	* returned by the ATA_CMD_ID_ATA[PI] commands.
01745112 BZ	67	*/
01745112 BZ	68
122f06f8	69	void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
1da177e4	70	{
1a7809e3	71	u8 p, end = &s[bytecount & ~1]; /* bytecount must be even */
1da177e4 LT	72
	73	if (byteswap) {
	74	/* convert from big-endian to host byte order */
1a7809e3 LT	75	for (p = s ; p != end ; p += 2)
1a7809e3 LT	76	be16_to_cpus((u16 *) p);
1da177e4	77	}
1a7809e3	78
1da177e4	79	/* strip leading blanks */
1a7809e3	80	p = s;
1da177e4 LT	81	while (s != end && *s == ' ')
	82	++s;
	83	/* compress internal blanks and strip trailing blanks */
	84	while (s != end && *s) {
	85	if (s++ != ' ' \|\| (s != end && s && *s != ' '))
	86	p++ = (s-1);
	87	}
	88	/* wipe out trailing garbage */
	89	while (p != end)
	90	*p++ = '\0';
	91	}
1da177e4 LT	92	EXPORT_SYMBOL(ide_fixstring);
1da177e4 LT	93
1da177e4 LT	94	/*
	95	* This routine busy-waits for the drive status to be not "busy".
	96	* It then checks the status for all of the "good" bits and none
	97	* of the "bad" bits, and if all is okay it returns 0. All other
74af21cf	98	* cases return error -- caller may then invoke ide_error().
1da177e4 LT	99	*
	100	* This routine should get fixed to not hog the cpu during extra long waits..
	101	* That could be done by busy-waiting for the first jiffy or two, and then
	102	* setting a timer to wake up at half second intervals thereafter,
	103	* until timeout is achieved, before timing out.
	104	*/
fa56d4cb BZ	105	int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
fa56d4cb BZ	106	unsigned long timeout, u8 *rstat)
1da177e4	107	{
b73c7ee2	108	ide_hwif_t *hwif = drive->hwif;
374e042c	109	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
1da177e4	110	unsigned long flags;
74af21cf BZ	111	int i;
74af21cf BZ	112	u8 stat;
1da177e4 LT	113
1da177e4 LT	114	udelay(1); /* spec allows drive 400ns to assert "BUSY" */
374e042c	115	stat = tp_ops->read_status(hwif);
c47137a9	116
3a7d2484	117	if (stat & ATA_BUSY) {
9b896033	118	local_save_flags(flags);
54cc1428	119	local_irq_enable_in_hardirq();
1da177e4	120	timeout += jiffies;
3a7d2484	121	while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
1da177e4 LT	122	if (time_after(jiffies, timeout)) {
	123	/*
	124	* One last read after the timeout in case
	125	* heavy interrupt load made us not make any
	126	* progress during the timeout..
	127	*/
374e042c	128	stat = tp_ops->read_status(hwif);
3a7d2484	129	if ((stat & ATA_BUSY) == 0)
1da177e4 LT	130	break;
	131
	132	local_irq_restore(flags);
74af21cf BZ	133	*rstat = stat;
74af21cf BZ	134	return -EBUSY;
1da177e4 LT	135	}
	136	}
	137	local_irq_restore(flags);
	138	}
	139	/*
	140	* Allow status to settle, then read it again.
	141	* A few rare drives vastly violate the 400ns spec here,
	142	* so we'll wait up to 10usec for a "good" status
	143	* rather than expensively fail things immediately.
	144	* This fix courtesy of Matthew Faupel & Niccolo Rigacci.
	145	*/
	146	for (i = 0; i < 10; i++) {
	147	udelay(1);
374e042c	148	stat = tp_ops->read_status(hwif);
c47137a9 BZ	149
c47137a9 BZ	150	if (OK_STAT(stat, good, bad)) {
74af21cf	151	*rstat = stat;
1da177e4	152	return 0;
74af21cf	153	}
1da177e4	154	}
74af21cf BZ	155	*rstat = stat;
	156	return -EFAULT;
	157	}
	158
	159	/*
	160	* In case of error returns error value after doing "*startstop = ide_error()".
	161	* The caller should return the updated value of "startstop" in this case,
	162	* "startstop" is unchanged when the function returns 0.
	163	*/
122f06f8 BZ	164	int ide_wait_stat(ide_startstop_t startstop, ide_drive_t drive, u8 good,
122f06f8 BZ	165	u8 bad, unsigned long timeout)
74af21cf BZ	166	{
	167	int err;
	168	u8 stat;
	169
	170	/* bail early if we've exceeded max_failures */
	171	if (drive->max_failures && (drive->failures > drive->max_failures)) {
	172	*startstop = ide_stopped;
	173	return 1;
	174	}
	175
	176	err = __ide_wait_stat(drive, good, bad, timeout, &stat);
	177
	178	if (err) {
	179	char *s = (err == -EBUSY) ? "status timeout" : "status error";
	180	*startstop = ide_error(drive, s, stat);
	181	}
	182
	183	return err;
1da177e4	184	}
1da177e4 LT	185	EXPORT_SYMBOL(ide_wait_stat);
1da177e4 LT	186
a5b7e70d BZ	187	/**
	188	* ide_in_drive_list - look for drive in black/white list
	189	* @id: drive identifier
4dde4492	190	* @table: list to inspect
a5b7e70d BZ	191	*
	192	* Look for a drive in the blacklist and the whitelist tables
	193	* Returns 1 if the drive is found in the table.
	194	*/
	195
4dde4492	196	int ide_in_drive_list(u16 id, const struct drive_list_entry table)
a5b7e70d	197	{
4dde4492 BZ	198	for ( ; table->id_model; table++)
	199	if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
	200	(!table->id_firmware \|\|
	201	strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
a5b7e70d BZ	202	return 1;
	203	return 0;
	204	}
b0244a00 BZ	205	EXPORT_SYMBOL_GPL(ide_in_drive_list);
b0244a00 BZ	206
a5b7e70d BZ	207	/*
a5b7e70d BZ	208	* Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
8588a2b7	209	* Some optical devices with the buggy firmwares have the same problem.
a5b7e70d BZ	210	*/
	211	static const struct drive_list_entry ivb_list[] = {
	212	{ "QUANTUM FIREBALLlct10 05" , "A03.0900" },
ba9413bd	213	{ "QUANTUM FIREBALLlct20 30" , "APL.0900" },
8588a2b7	214	{ "TSSTcorp CDDVDW SH-S202J" , "SB00" },
e97564f3 PM	215	{ "TSSTcorp CDDVDW SH-S202J" , "SB01" },
	216	{ "TSSTcorp CDDVDW SH-S202N" , "SB00" },
	217	{ "TSSTcorp CDDVDW SH-S202N" , "SB01" },
3ced5c49 AS	218	{ "TSSTcorp CDDVDW SH-S202H" , "SB00" },
3ced5c49 AS	219	{ "TSSTcorp CDDVDW SH-S202H" , "SB01" },
c7b997b3	220	{ "SAMSUNG SP0822N" , "WA100-10" },
a5b7e70d BZ	221	{ NULL , NULL }
	222	};
	223
1da177e4 LT	224	/*
	225	* All hosts that use the 80c ribbon must use!
	226	* The name is derived from upper byte of word 93 and the 80c ribbon.
	227	*/
122f06f8	228	u8 eighty_ninty_three(ide_drive_t *drive)
1da177e4	229	{
7f8f48af	230	ide_hwif_t *hwif = drive->hwif;
4dde4492	231	u16 *id = drive->id;
a5b7e70d	232	int ivb = ide_in_drive_list(id, ivb_list);
7f8f48af	233
76937fa7	234	if (hwif->cbl == ATA_CBL_SATA \|\| hwif->cbl == ATA_CBL_PATA40_SHORT)
49521f97 BZ	235	return 1;
49521f97 BZ	236
a5b7e70d BZ	237	if (ivb)
	238	printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
	239	drive->name);
	240
367d7e78	241	if (ata_id_is_sata(id) && !ivb)
b98f8803 GK	242	return 1;
b98f8803 GK	243
a5b7e70d	244	if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
7f8f48af	245	goto no_80w;
1a1276e7	246
f68d9320 BZ	247	/*
f68d9320 BZ	248	* FIXME:
f367bed0	249	* - change master/slave IDENTIFY order
a5b7e70d	250	* - force bit13 (80c cable present) check also for !ivb devices
f68d9320 BZ	251	* (unless the slave device is pre-ATA3)
f68d9320 BZ	252	*/
8369d5fa	253	if (id[ATA_ID_HW_CONFIG] & 0x4000)
7f8f48af BZ	254	return 1;
7f8f48af BZ	255
8369d5fa BZ	256	if (ivb) {
	257	const char model = (char )&id[ATA_ID_PROD];
	258
	259	if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
	260	/*
	261	* These ATAPI devices always report 80c cable
	262	* so we have to depend on the host in this case.
	263	*/
	264	if (hwif->cbl == ATA_CBL_PATA80)
	265	return 1;
	266	} else {
	267	/* Depend on the device side cable detection. */
	268	if (id[ATA_ID_HW_CONFIG] & 0x2000)
	269	return 1;
	270	}
	271	}
7f8f48af	272	no_80w:
97100fc8	273	if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
7f8f48af BZ	274	return 0;
	275
	276	printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
	277	"limiting max speed to UDMA33\n",
49521f97 BZ	278	drive->name,
49521f97 BZ	279	hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
7f8f48af	280
97100fc8	281	drive->dev_flags \|= IDE_DFLAG_UDMA33_WARNED;
7f8f48af BZ	282
7f8f48af BZ	283	return 0;
1da177e4 LT	284	}
1da177e4 LT	285
8bc1e5aa BZ	286	static const char *nien_quirk_list[] = {
	287	"QUANTUM FIREBALLlct08 08",
	288	"QUANTUM FIREBALLP KA6.4",
	289	"QUANTUM FIREBALLP KA9.1",
	290	"QUANTUM FIREBALLP KX13.6",
	291	"QUANTUM FIREBALLP KX20.5",
	292	"QUANTUM FIREBALLP KX27.3",
	293	"QUANTUM FIREBALLP LM20.4",
	294	"QUANTUM FIREBALLP LM20.5",
a2d10568	295	"FUJITSU MHZ2160BH G2",
8bc1e5aa BZ	296	NULL
	297	};
	298
	299	void ide_check_nien_quirk_list(ide_drive_t *drive)
	300	{
	301	const char *list, m = (char *)&drive->id[ATA_ID_PROD];
	302
	303	for (list = nien_quirk_list; *list != NULL; list++)
	304	if (strstr(m, *list) != NULL) {
734affdc	305	drive->dev_flags \|= IDE_DFLAG_NIEN_QUIRK;
8bc1e5aa BZ	306	return;
8bc1e5aa BZ	307	}
8bc1e5aa BZ	308	}
8bc1e5aa BZ	309
8a455134	310	int ide_driveid_update(ide_drive_t *drive)
1da177e4	311	{
4dde4492	312	u16 *id;
2ebe1d9e	313	int rc;
2f40c9b0 BZ	314
	315	id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
	316	if (id == NULL)
	317	return 0;
1da177e4	318
1da177e4	319	SELECT_MASK(drive, 1);
fa56d4cb	320	rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
2ebe1d9e	321	SELECT_MASK(drive, 0);
2f40c9b0	322
2ebe1d9e	323	if (rc)
2f40c9b0	324	goto out_err;
f323b80d	325
4dde4492 BZ	326	drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
	327	drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
	328	drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
74638c84	329	drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
4dde4492 BZ	330	/* anything more ? */
	331
	332	kfree(id);
	333
1da177e4	334	return 1;
2f40c9b0	335	out_err:
2f40c9b0 BZ	336	if (rc == 2)
	337	printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
	338	kfree(id);
	339	return 0;
1da177e4 LT	340	}
1da177e4 LT	341
74af21cf	342	int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
1da177e4	343	{
74af21cf	344	ide_hwif_t *hwif = drive->hwif;
374e042c	345	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
c9ff9e7b	346	struct ide_taskfile tf;
4dde4492	347	u16 *id = drive->id, i;
89613e66	348	int error = 0;
1da177e4 LT	349	u8 stat;
1da177e4 LT	350
1da177e4	351	#ifdef CONFIG_BLK_DEV_IDEDMA
5e37bdc0 BZ	352	if (hwif->dma_ops) /* check if host supports DMA */
5e37bdc0 BZ	353	hwif->dma_ops->dma_host_set(drive, 0);
1da177e4 LT	354	#endif
1da177e4 LT	355
89613e66	356	/* Skip setting PIO flow-control modes on pre-EIDE drives */
48fb2688	357	if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
89613e66 SS	358	goto skip;
89613e66 SS	359
1da177e4 LT	360	/*
	361	* Don't use ide_wait_cmd here - it will
	362	* attempt to set_geometry and recalibrate,
	363	* but for some reason these don't work at
	364	* this point (lost interrupt).
	365	*/
ee1b1cc9	366
1da177e4	367	udelay(1);
fdd88f0a	368	tp_ops->dev_select(drive);
e5403bff	369	SELECT_MASK(drive, 1);
1da177e4	370	udelay(1);
ecf3a31d	371	tp_ops->write_devctl(hwif, ATA_NIEN \| ATA_DEVCTL_OBS);
59be2c80	372
c9ff9e7b SS	373	memset(&tf, 0, sizeof(tf));
	374	tf.feature = SETFEATURES_XFER;
	375	tf.nsect = speed;
59be2c80	376
c9ff9e7b	377	tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE \| IDE_VALID_NSECT);
59be2c80	378
aaaade3f	379	tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
59be2c80	380
734affdc	381	if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
ecf3a31d	382	tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
1da177e4	383
74af21cf	384	error = __ide_wait_stat(drive, drive->ready_stat,
3a7d2484	385	ATA_BUSY \| ATA_DRQ \| ATA_ERR,
74af21cf	386	WAIT_CMD, &stat);
1da177e4 LT	387
	388	SELECT_MASK(drive, 0);
	389
1da177e4 LT	390	if (error) {
	391	(void) ide_dump_status(drive, "set_drive_speed_status", stat);
	392	return error;
	393	}
	394
c4199930 SS	395	if (speed >= XFER_SW_DMA_0) {
	396	id[ATA_ID_UDMA_MODES] &= ~0xFF00;
	397	id[ATA_ID_MWDMA_MODES] &= ~0x0700;
	398	id[ATA_ID_SWDMA_MODES] &= ~0x0700;
74638c84 SS	399	if (ata_id_is_cfa(id))
	400	id[ATA_ID_CFA_MODES] &= ~0x0E00;
	401	} else if (ata_id_is_cfa(id))
	402	id[ATA_ID_CFA_MODES] &= ~0x01C0;
1da177e4	403
89613e66	404	skip:
1da177e4	405	#ifdef CONFIG_BLK_DEV_IDEDMA
97100fc8	406	if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
5e37bdc0 BZ	407	hwif->dma_ops->dma_host_set(drive, 1);
5e37bdc0 BZ	408	else if (hwif->dma_ops) /* check if host supports DMA */
4a546e04	409	ide_dma_off_quietly(drive);
1da177e4 LT	410	#endif
1da177e4 LT	411
4dde4492 BZ	412	if (speed >= XFER_UDMA_0) {
	413	i = 1 << (speed - XFER_UDMA_0);
	414	id[ATA_ID_UDMA_MODES] \|= (i << 8 \| i);
74638c84 SS	415	} else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
	416	i = speed - XFER_MW_DMA_2;
	417	id[ATA_ID_CFA_MODES] \|= i << 9;
4dde4492 BZ	418	} else if (speed >= XFER_MW_DMA_0) {
	419	i = 1 << (speed - XFER_MW_DMA_0);
	420	id[ATA_ID_MWDMA_MODES] \|= (i << 8 \| i);
	421	} else if (speed >= XFER_SW_DMA_0) {
	422	i = 1 << (speed - XFER_SW_DMA_0);
	423	id[ATA_ID_SWDMA_MODES] \|= (i << 8 \| i);
74638c84 SS	424	} else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
	425	i = speed - XFER_PIO_4;
	426	id[ATA_ID_CFA_MODES] \|= i << 6;
1da177e4	427	}
4dde4492	428
1da177e4 LT	429	if (!drive->init_speed)
	430	drive->init_speed = speed;
	431	drive->current_speed = speed;
	432	return error;
	433	}
	434
1da177e4 LT	435	/*
	436	* This should get invoked any time we exit the driver to
	437	* wait for an interrupt response from a drive. handler() points
	438	* at the appropriate code to handle the next interrupt, and a
	439	* timer is started to prevent us from waiting forever in case
	440	* something goes wrong (see the ide_timer_expiry() handler later on).
	441	*
	442	* See also ide_execute_command
	443	*/
327fa1c2	444	void __ide_set_handler(ide_drive_t drive, ide_handler_t handler,
60c0cd02	445	unsigned int timeout)
1da177e4	446	{
b65fac32 BZ	447	ide_hwif_t *hwif = drive->hwif;
	448
	449	BUG_ON(hwif->handler);
	450	hwif->handler = handler;
b65fac32 BZ	451	hwif->timer.expires = jiffies + timeout;
	452	hwif->req_gen_timer = hwif->req_gen;
	453	add_timer(&hwif->timer);
1da177e4 LT	454	}
1da177e4 LT	455
60c0cd02 BZ	456	void ide_set_handler(ide_drive_t drive, ide_handler_t handler,
60c0cd02 BZ	457	unsigned int timeout)
1da177e4	458	{
b65fac32	459	ide_hwif_t *hwif = drive->hwif;
1da177e4	460	unsigned long flags;
2a2ca6a9	461
b65fac32	462	spin_lock_irqsave(&hwif->lock, flags);
60c0cd02	463	__ide_set_handler(drive, handler, timeout);
b65fac32	464	spin_unlock_irqrestore(&hwif->lock, flags);
1da177e4	465	}
1da177e4	466	EXPORT_SYMBOL(ide_set_handler);
122f06f8	467
1da177e4 LT	468	/**
	469	* ide_execute_command - execute an IDE command
	470	* @drive: IDE drive to issue the command against
35b5d0be	471	* @cmd: command
1da177e4 LT	472	* @handler: handler for next phase
1da177e4 LT	473	* @timeout: timeout for command
1da177e4 LT	474	*
1da177e4 LT	475	* Helper function to issue an IDE command. This handles the
122f06f8	476	* atomicity requirements, command timing and ensures that the
1da177e4 LT	477	* handler and IRQ setup do not race. All IDE command kick off
	478	* should go via this function or do equivalent locking.
	479	*/
cd2a2d96	480
35b5d0be BZ	481	void ide_execute_command(ide_drive_t drive, struct ide_cmd cmd,
35b5d0be BZ	482	ide_handler_t *handler, unsigned timeout)
1da177e4	483	{
2a2ca6a9	484	ide_hwif_t *hwif = drive->hwif;
1da177e4	485	unsigned long flags;
629f944b	486
b65fac32	487	spin_lock_irqsave(&hwif->lock, flags);
35b5d0be BZ	488	if ((cmd->protocol != ATAPI_PROT_DMA &&
	489	cmd->protocol != ATAPI_PROT_PIO) \|\|
	490	(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
	491	__ide_set_handler(drive, handler, timeout);
	492	hwif->tp_ops->exec_command(hwif, cmd->tf.command);
629f944b BZ	493	/*
	494	* Drive takes 400nS to respond, we must avoid the IRQ being
	495	* serviced before that.
	496	*
	497	* FIXME: we could skip this delay with care on non shared devices
	498	*/
1da177e4	499	ndelay(400);
b65fac32	500	spin_unlock_irqrestore(&hwif->lock, flags);
1da177e4	501	}
1da177e4	502
1da177e4 LT	503	/*
1da177e4 LT	504	* ide_wait_not_busy() waits for the currently selected device on the hwif
9d501529	505	* to report a non-busy status, see comments in ide_probe_port().
1da177e4 LT	506	*/
	507	int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
	508	{
	509	u8 stat = 0;
	510
122f06f8	511	while (timeout--) {
1da177e4 LT	512	/*
	513	* Turn this into a schedule() sleep once I'm sure
	514	* about locking issues (2.5 work ?).
	515	*/
	516	mdelay(1);
374e042c	517	stat = hwif->tp_ops->read_status(hwif);
3a7d2484	518	if ((stat & ATA_BUSY) == 0)
1da177e4 LT	519	return 0;
	520	/*
	521	* Assume a value of 0xff means nothing is connected to
	522	* the interface and it doesn't implement the pull-down
	523	* resistor on D7.
	524	*/
	525	if (stat == 0xff)
	526	return -ENODEV;
6842f8c8	527	touch_softlockup_watchdog();
1e86240f	528	touch_nmi_watchdog();
1da177e4 LT	529	}
	530	return -EBUSY;
	531	}