ide-iops.c 33.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *  Copyright (C) 2000-2002	Andre Hedrick <andre@linux-ide.org>
 *  Copyright (C) 2003		Red Hat <alan@redhat.com>
 *
 */

#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/hdreg.h>
#include <linux/ide.h>
#include <linux/bitops.h>
24
#include <linux/nmi.h>
L
Linus Torvalds 已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

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

/*
 *	Conventional PIO operations for ATA devices
 */

static u8 ide_inb (unsigned long port)
{
	return (u8) inb(port);
}

static void ide_outb (u8 val, unsigned long port)
{
	outb(val, port);
}

static void ide_outbsync (ide_drive_t *drive, u8 addr, unsigned long port)
{
	outb(addr, port);
}

void default_hwif_iops (ide_hwif_t *hwif)
{
	hwif->OUTB	= ide_outb;
	hwif->OUTBSYNC	= ide_outbsync;
	hwif->INB	= ide_inb;
}

/*
 *	MMIO operations, typically used for SATA controllers
 */

static u8 ide_mm_inb (unsigned long port)
{
	return (u8) readb((void __iomem *) port);
}

static void ide_mm_outb (u8 value, unsigned long port)
{
	writeb(value, (void __iomem *) port);
}

static void ide_mm_outbsync (ide_drive_t *drive, u8 value, unsigned long port)
{
	writeb(value, (void __iomem *) port);
}

void default_hwif_mmiops (ide_hwif_t *hwif)
{
	hwif->OUTB	= ide_mm_outb;
	/* Most systems will need to override OUTBSYNC, alas however
	   this one is controller specific! */
	hwif->OUTBSYNC	= ide_mm_outbsync;
	hwif->INB	= ide_mm_inb;
}

EXPORT_SYMBOL(default_hwif_mmiops);

void SELECT_DRIVE (ide_drive_t *drive)
{
89
	ide_hwif_t *hwif = drive->hwif;
90
	const struct ide_port_ops *port_ops = hwif->port_ops;
91

92 93
	if (port_ops && port_ops->selectproc)
		port_ops->selectproc(drive);
94

95
	hwif->OUTB(drive->select.all, hwif->io_ports.device_addr);
L
Linus Torvalds 已提交
96 97
}

98
static void SELECT_MASK(ide_drive_t *drive, int mask)
L
Linus Torvalds 已提交
99
{
100 101 102 103
	const struct ide_port_ops *port_ops = drive->hwif->port_ops;

	if (port_ops && port_ops->maskproc)
		port_ops->maskproc(drive, mask);
L
Linus Torvalds 已提交
104 105
}

106
static void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
107 108 109 110
{
	ide_hwif_t *hwif = drive->hwif;
	struct ide_io_ports *io_ports = &hwif->io_ports;
	struct ide_taskfile *tf = &task->tf;
111 112
	void (*tf_outb)(u8 addr, unsigned long port);
	u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
113 114
	u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;

115 116 117 118 119
	if (mmio)
		tf_outb = ide_mm_outb;
	else
		tf_outb = ide_outb;

120 121 122 123 124 125 126 127
	if (task->tf_flags & IDE_TFLAG_FLAGGED)
		HIHI = 0xFF;

	ide_set_irq(drive, 1);

	if ((task->tf_flags & IDE_TFLAG_NO_SELECT_MASK) == 0)
		SELECT_MASK(drive, 0);

128 129 130 131 132 133 134 135
	if (task->tf_flags & IDE_TFLAG_OUT_DATA) {
		u16 data = (tf->hob_data << 8) | tf->data;

		if (mmio)
			writew(data, (void __iomem *)io_ports->data_addr);
		else
			outw(data, io_ports->data_addr);
	}
136 137

	if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)
138
		tf_outb(tf->hob_feature, io_ports->feature_addr);
139
	if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)
140
		tf_outb(tf->hob_nsect, io_ports->nsect_addr);
141
	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)
142
		tf_outb(tf->hob_lbal, io_ports->lbal_addr);
143
	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)
144
		tf_outb(tf->hob_lbam, io_ports->lbam_addr);
145
	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)
146
		tf_outb(tf->hob_lbah, io_ports->lbah_addr);
147 148

	if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)
149
		tf_outb(tf->feature, io_ports->feature_addr);
150
	if (task->tf_flags & IDE_TFLAG_OUT_NSECT)
151
		tf_outb(tf->nsect, io_ports->nsect_addr);
152
	if (task->tf_flags & IDE_TFLAG_OUT_LBAL)
153
		tf_outb(tf->lbal, io_ports->lbal_addr);
154
	if (task->tf_flags & IDE_TFLAG_OUT_LBAM)
155
		tf_outb(tf->lbam, io_ports->lbam_addr);
156
	if (task->tf_flags & IDE_TFLAG_OUT_LBAH)
157
		tf_outb(tf->lbah, io_ports->lbah_addr);
158 159

	if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
160 161
		tf_outb((tf->device & HIHI) | drive->select.all,
			 io_ports->device_addr);
162 163
}

164
static void ide_tf_read(ide_drive_t *drive, ide_task_t *task)
165 166 167 168
{
	ide_hwif_t *hwif = drive->hwif;
	struct ide_io_ports *io_ports = &hwif->io_ports;
	struct ide_taskfile *tf = &task->tf;
169 170 171 172 173 174 175 176 177 178 179
	void (*tf_outb)(u8 addr, unsigned long port);
	u8 (*tf_inb)(unsigned long port);
	u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;

	if (mmio) {
		tf_outb = ide_mm_outb;
		tf_inb  = ide_mm_inb;
	} else {
		tf_outb = ide_outb;
		tf_inb  = ide_inb;
	}
180 181

	if (task->tf_flags & IDE_TFLAG_IN_DATA) {
182 183 184 185 186 187
		u16 data;

		if (mmio)
			data = readw((void __iomem *)io_ports->data_addr);
		else
			data = inw(io_ports->data_addr);
188 189 190 191 192 193

		tf->data = data & 0xff;
		tf->hob_data = (data >> 8) & 0xff;
	}

	/* be sure we're looking at the low order bits */
194
	tf_outb(drive->ctl & ~0x80, io_ports->ctl_addr);
195 196

	if (task->tf_flags & IDE_TFLAG_IN_NSECT)
197
		tf->nsect  = tf_inb(io_ports->nsect_addr);
198
	if (task->tf_flags & IDE_TFLAG_IN_LBAL)
199
		tf->lbal   = tf_inb(io_ports->lbal_addr);
200
	if (task->tf_flags & IDE_TFLAG_IN_LBAM)
201
		tf->lbam   = tf_inb(io_ports->lbam_addr);
202
	if (task->tf_flags & IDE_TFLAG_IN_LBAH)
203
		tf->lbah   = tf_inb(io_ports->lbah_addr);
204
	if (task->tf_flags & IDE_TFLAG_IN_DEVICE)
205
		tf->device = tf_inb(io_ports->device_addr);
206 207

	if (task->tf_flags & IDE_TFLAG_LBA48) {
208
		tf_outb(drive->ctl | 0x80, io_ports->ctl_addr);
209 210

		if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)
211
			tf->hob_feature = tf_inb(io_ports->feature_addr);
212
		if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)
213
			tf->hob_nsect   = tf_inb(io_ports->nsect_addr);
214
		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)
215
			tf->hob_lbal    = tf_inb(io_ports->lbal_addr);
216
		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)
217
			tf->hob_lbam    = tf_inb(io_ports->lbam_addr);
218
		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)
219
			tf->hob_lbah    = tf_inb(io_ports->lbah_addr);
220 221 222
	}
}

L
Linus Torvalds 已提交
223 224 225 226 227 228 229
/*
 * Some localbus EIDE interfaces require a special access sequence
 * when using 32-bit I/O instructions to transfer data.  We call this
 * the "vlb_sync" sequence, which consists of three successive reads
 * of the sector count register location, with interrupts disabled
 * to ensure that the reads all happen together.
 */
230
static void ata_vlb_sync(unsigned long port)
L
Linus Torvalds 已提交
231
{
232 233 234
	(void)inb(port);
	(void)inb(port);
	(void)inb(port);
L
Linus Torvalds 已提交
235 236 237 238
}

/*
 * This is used for most PIO data transfers *from* the IDE interface
239 240 241 242
 *
 * These routines will round up any request for an odd number of bytes,
 * so if an odd len is specified, be sure that there's at least one
 * extra byte allocated for the buffer.
L
Linus Torvalds 已提交
243
 */
244
static void ata_input_data(ide_drive_t *drive, struct request *rq,
245
			   void *buf, unsigned int len)
L
Linus Torvalds 已提交
246
{
247 248
	ide_hwif_t *hwif = drive->hwif;
	struct ide_io_ports *io_ports = &hwif->io_ports;
249
	unsigned long data_addr = io_ports->data_addr;
250
	u8 io_32bit = drive->io_32bit;
251
	u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
L
Linus Torvalds 已提交
252

253 254
	len++;

L
Linus Torvalds 已提交
255
	if (io_32bit) {
256
		unsigned long uninitialized_var(flags);
257

258
		if ((io_32bit & 2) && !mmio) {
L
Linus Torvalds 已提交
259
			local_irq_save(flags);
260
			ata_vlb_sync(io_ports->nsect_addr);
261 262 263 264 265 266 267
		}

		if (mmio)
			__ide_mm_insl((void __iomem *)data_addr, buf, len / 4);
		else
			insl(data_addr, buf, len / 4);

268
		if ((io_32bit & 2) && !mmio)
L
Linus Torvalds 已提交
269
			local_irq_restore(flags);
270

271 272 273 274 275 276 277 278 279 280 281 282 283
		if ((len & 3) >= 2) {
			if (mmio)
				__ide_mm_insw((void __iomem *)data_addr,
						(u8 *)buf + (len & ~3), 1);
			else
				insw(data_addr, (u8 *)buf + (len & ~3), 1);
		}
	} else {
		if (mmio)
			__ide_mm_insw((void __iomem *)data_addr, buf, len / 2);
		else
			insw(data_addr, buf, len / 2);
	}
L
Linus Torvalds 已提交
284 285 286 287 288
}

/*
 * This is used for most PIO data transfers *to* the IDE interface
 */
289
static void ata_output_data(ide_drive_t *drive, struct request *rq,
290
			    void *buf, unsigned int len)
L
Linus Torvalds 已提交
291
{
292 293
	ide_hwif_t *hwif = drive->hwif;
	struct ide_io_ports *io_ports = &hwif->io_ports;
294
	unsigned long data_addr = io_ports->data_addr;
295
	u8 io_32bit = drive->io_32bit;
296
	u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
L
Linus Torvalds 已提交
297 298

	if (io_32bit) {
299
		unsigned long uninitialized_var(flags);
300

301
		if ((io_32bit & 2) && !mmio) {
L
Linus Torvalds 已提交
302
			local_irq_save(flags);
303
			ata_vlb_sync(io_ports->nsect_addr);
304 305 306 307 308 309 310
		}

		if (mmio)
			__ide_mm_outsl((void __iomem *)data_addr, buf, len / 4);
		else
			outsl(data_addr, buf, len / 4);

311
		if ((io_32bit & 2) && !mmio)
L
Linus Torvalds 已提交
312 313
			local_irq_restore(flags);

314 315 316 317 318 319 320 321 322 323 324 325 326
		if ((len & 3) >= 2) {
			if (mmio)
				__ide_mm_outsw((void __iomem *)data_addr,
						 (u8 *)buf + (len & ~3), 1);
			else
				outsw(data_addr, (u8 *)buf + (len & ~3), 1);
		}
	} else {
		if (mmio)
			__ide_mm_outsw((void __iomem *)data_addr, buf, len / 2);
		else
			outsw(data_addr, buf, len / 2);
	}
L
Linus Torvalds 已提交
327 328 329 330
}

void default_hwif_transport(ide_hwif_t *hwif)
{
331 332 333
	hwif->tf_load	  = ide_tf_load;
	hwif->tf_read	  = ide_tf_read;

334 335
	hwif->input_data  = ata_input_data;
	hwif->output_data = ata_output_data;
L
Linus Torvalds 已提交
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
}

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

	id->config         = __le16_to_cpu(id->config);
	id->cyls           = __le16_to_cpu(id->cyls);
	id->reserved2      = __le16_to_cpu(id->reserved2);
	id->heads          = __le16_to_cpu(id->heads);
	id->track_bytes    = __le16_to_cpu(id->track_bytes);
	id->sector_bytes   = __le16_to_cpu(id->sector_bytes);
	id->sectors        = __le16_to_cpu(id->sectors);
	id->vendor0        = __le16_to_cpu(id->vendor0);
	id->vendor1        = __le16_to_cpu(id->vendor1);
	id->vendor2        = __le16_to_cpu(id->vendor2);
	stringcast = (u16 *)&id->serial_no[0];
	for (i = 0; i < (20/2); i++)
		stringcast[i] = __le16_to_cpu(stringcast[i]);
	id->buf_type       = __le16_to_cpu(id->buf_type);
	id->buf_size       = __le16_to_cpu(id->buf_size);
	id->ecc_bytes      = __le16_to_cpu(id->ecc_bytes);
	stringcast = (u16 *)&id->fw_rev[0];
	for (i = 0; i < (8/2); i++)
		stringcast[i] = __le16_to_cpu(stringcast[i]);
	stringcast = (u16 *)&id->model[0];
	for (i = 0; i < (40/2); i++)
		stringcast[i] = __le16_to_cpu(stringcast[i]);
	id->dword_io       = __le16_to_cpu(id->dword_io);
	id->reserved50     = __le16_to_cpu(id->reserved50);
	id->field_valid    = __le16_to_cpu(id->field_valid);
	id->cur_cyls       = __le16_to_cpu(id->cur_cyls);
	id->cur_heads      = __le16_to_cpu(id->cur_heads);
	id->cur_sectors    = __le16_to_cpu(id->cur_sectors);
	id->cur_capacity0  = __le16_to_cpu(id->cur_capacity0);
	id->cur_capacity1  = __le16_to_cpu(id->cur_capacity1);
	id->lba_capacity   = __le32_to_cpu(id->lba_capacity);
	id->dma_1word      = __le16_to_cpu(id->dma_1word);
	id->dma_mword      = __le16_to_cpu(id->dma_mword);
	id->eide_pio_modes = __le16_to_cpu(id->eide_pio_modes);
	id->eide_dma_min   = __le16_to_cpu(id->eide_dma_min);
	id->eide_dma_time  = __le16_to_cpu(id->eide_dma_time);
	id->eide_pio       = __le16_to_cpu(id->eide_pio);
	id->eide_pio_iordy = __le16_to_cpu(id->eide_pio_iordy);
	for (i = 0; i < 2; ++i)
		id->words69_70[i] = __le16_to_cpu(id->words69_70[i]);
	for (i = 0; i < 4; ++i)
		id->words71_74[i] = __le16_to_cpu(id->words71_74[i]);
	id->queue_depth    = __le16_to_cpu(id->queue_depth);
	for (i = 0; i < 4; ++i)
		id->words76_79[i] = __le16_to_cpu(id->words76_79[i]);
	id->major_rev_num  = __le16_to_cpu(id->major_rev_num);
	id->minor_rev_num  = __le16_to_cpu(id->minor_rev_num);
	id->command_set_1  = __le16_to_cpu(id->command_set_1);
	id->command_set_2  = __le16_to_cpu(id->command_set_2);
	id->cfsse          = __le16_to_cpu(id->cfsse);
	id->cfs_enable_1   = __le16_to_cpu(id->cfs_enable_1);
	id->cfs_enable_2   = __le16_to_cpu(id->cfs_enable_2);
	id->csf_default    = __le16_to_cpu(id->csf_default);
	id->dma_ultra      = __le16_to_cpu(id->dma_ultra);
	id->trseuc         = __le16_to_cpu(id->trseuc);
	id->trsEuc         = __le16_to_cpu(id->trsEuc);
	id->CurAPMvalues   = __le16_to_cpu(id->CurAPMvalues);
	id->mprc           = __le16_to_cpu(id->mprc);
	id->hw_config      = __le16_to_cpu(id->hw_config);
	id->acoustic       = __le16_to_cpu(id->acoustic);
	id->msrqs          = __le16_to_cpu(id->msrqs);
	id->sxfert         = __le16_to_cpu(id->sxfert);
	id->sal            = __le16_to_cpu(id->sal);
	id->spg            = __le32_to_cpu(id->spg);
	id->lba_capacity_2 = __le64_to_cpu(id->lba_capacity_2);
	for (i = 0; i < 22; i++)
		id->words104_125[i]   = __le16_to_cpu(id->words104_125[i]);
	id->last_lun       = __le16_to_cpu(id->last_lun);
	id->word127        = __le16_to_cpu(id->word127);
	id->dlf            = __le16_to_cpu(id->dlf);
	id->csfo           = __le16_to_cpu(id->csfo);
	for (i = 0; i < 26; i++)
		id->words130_155[i] = __le16_to_cpu(id->words130_155[i]);
	id->word156        = __le16_to_cpu(id->word156);
	for (i = 0; i < 3; i++)
		id->words157_159[i] = __le16_to_cpu(id->words157_159[i]);
	id->cfa_power      = __le16_to_cpu(id->cfa_power);
	for (i = 0; i < 14; i++)
		id->words161_175[i] = __le16_to_cpu(id->words161_175[i]);
	for (i = 0; i < 31; i++)
		id->words176_205[i] = __le16_to_cpu(id->words176_205[i]);
	for (i = 0; i < 48; i++)
		id->words206_254[i] = __le16_to_cpu(id->words206_254[i]);
	id->integrity_word  = __le16_to_cpu(id->integrity_word);
# else
#  error "Please fix <asm/byteorder.h>"
# endif
#endif
}

435 436 437 438 439 440 441
/*
 * 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 WIN_[P]IDENTIFY commands.
 */

L
Linus Torvalds 已提交
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
{
	u8 *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */

	if (byteswap) {
		/* convert from big-endian to host byte order */
		for (p = end ; p != s;) {
			unsigned short *pp = (unsigned short *) (p -= 2);
			*pp = ntohs(*pp);
		}
	}
	/* strip leading blanks */
	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);

/*
 * Needed for PCI irq sharing
 */
int drive_is_ready (ide_drive_t *drive)
{
	ide_hwif_t *hwif	= HWIF(drive);
	u8 stat			= 0;

	if (drive->waiting_for_dma)
477
		return hwif->dma_ops->dma_test_irq(drive);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486 487 488 489

#if 0
	/* need to guarantee 400ns since last command was issued */
	udelay(1);
#endif

	/*
	 * We do a passive status test under shared PCI interrupts on
	 * cards that truly share the ATA side interrupt, but may also share
	 * an interrupt with another pci card/device.  We make no assumptions
	 * about possible isa-pnp and pci-pnp issues yet.
	 */
490
	if (hwif->io_ports.ctl_addr)
491
		stat = ide_read_altstatus(drive);
L
Linus Torvalds 已提交
492 493
	else
		/* Note: this may clear a pending IRQ!! */
494
		stat = ide_read_status(drive);
L
Linus Torvalds 已提交
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509

	if (stat & BUSY_STAT)
		/* drive busy:  definitely not interrupting */
		return 0;

	/* drive ready: *might* be interrupting */
	return 1;
}

EXPORT_SYMBOL(drive_is_ready);

/*
 * 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
510
 * cases return error -- caller may then invoke ide_error().
L
Linus Torvalds 已提交
511 512 513 514 515 516
 *
 * 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.
 */
517
static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long timeout, u8 *rstat)
L
Linus Torvalds 已提交
518 519
{
	unsigned long flags;
520 521
	int i;
	u8 stat;
L
Linus Torvalds 已提交
522 523

	udelay(1);	/* spec allows drive 400ns to assert "BUSY" */
524 525 526
	stat = ide_read_status(drive);

	if (stat & BUSY_STAT) {
L
Linus Torvalds 已提交
527 528
		local_irq_set(flags);
		timeout += jiffies;
529
		while ((stat = ide_read_status(drive)) & BUSY_STAT) {
L
Linus Torvalds 已提交
530 531 532 533 534 535
			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..
				 */
536
				stat = ide_read_status(drive);
L
Linus Torvalds 已提交
537 538 539 540
				if (!(stat & BUSY_STAT))
					break;

				local_irq_restore(flags);
541 542
				*rstat = stat;
				return -EBUSY;
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555
			}
		}
		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);
556 557 558
		stat = ide_read_status(drive);

		if (OK_STAT(stat, good, bad)) {
559
			*rstat = stat;
L
Linus Torvalds 已提交
560
			return 0;
561
		}
L
Linus Torvalds 已提交
562
	}
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	*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;
L
Linus Torvalds 已提交
591 592 593 594
}

EXPORT_SYMBOL(ide_wait_stat);

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
/**
 *	ide_in_drive_list	-	look for drive in black/white list
 *	@id: drive identifier
 *	@drive_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(struct hd_driveid *id, const struct drive_list_entry *drive_table)
{
	for ( ; drive_table->id_model; drive_table++)
		if ((!strcmp(drive_table->id_model, id->model)) &&
		    (!drive_table->id_firmware ||
		     strstr(id->fw_rev, drive_table->id_firmware)))
			return 1;
	return 0;
}

614 615
EXPORT_SYMBOL_GPL(ide_in_drive_list);

616 617 618
/*
 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
 * We list them here and depend on the device side cable detection for them.
619 620
 *
 * Some optical devices with the buggy firmwares have the same problem.
621 622 623
 */
static const struct drive_list_entry ivb_list[] = {
	{ "QUANTUM FIREBALLlct10 05"	, "A03.0900"	},
624
	{ "TSSTcorp CDDVDW SH-S202J"	, "SB00"	},
625 626 627
	{ "TSSTcorp CDDVDW SH-S202J"	, "SB01"	},
	{ "TSSTcorp CDDVDW SH-S202N"	, "SB00"	},
	{ "TSSTcorp CDDVDW SH-S202N"	, "SB01"	},
628 629
	{ "TSSTcorp CDDVDW SH-S202H"	, "SB00"	},
	{ "TSSTcorp CDDVDW SH-S202H"	, "SB01"	},
630 631 632
	{ NULL				, NULL		}
};

L
Linus Torvalds 已提交
633 634 635 636 637 638
/*
 *  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)
{
639 640
	ide_hwif_t *hwif = drive->hwif;
	struct hd_driveid *id = drive->id;
641
	int ivb = ide_in_drive_list(id, ivb_list);
642

643 644 645
	if (hwif->cbl == ATA_CBL_PATA40_SHORT)
		return 1;

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

650 651 652
	if (ide_dev_is_sata(id) && !ivb)
		return 1;

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

656 657
	/*
	 * FIXME:
658
	 * - change master/slave IDENTIFY order
659
	 * - force bit13 (80c cable present) check also for !ivb devices
660 661
	 *   (unless the slave device is pre-ATA3)
	 */
662
	if ((id->hw_config & 0x4000) || (ivb && (id->hw_config & 0x2000)))
663 664 665 666 667 668 669 670
		return 1;

no_80w:
	if (drive->udma33_warned == 1)
		return 0;

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

	drive->udma33_warned = 1;

	return 0;
L
Linus Torvalds 已提交
677 678
}

679
int ide_driveid_update(ide_drive_t *drive)
L
Linus Torvalds 已提交
680
{
681
	ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
682
	struct hd_driveid *id;
683
	unsigned long timeout, flags;
684
	u8 stat;
L
Linus Torvalds 已提交
685 686 687 688 689 690 691

	/*
	 * Re-read drive->id for possible DMA mode
	 * change (copied from ide-probe.c)
	 */

	SELECT_MASK(drive, 1);
692
	ide_set_irq(drive, 1);
L
Linus Torvalds 已提交
693
	msleep(50);
694
	hwif->OUTBSYNC(drive, WIN_IDENTIFY, hwif->io_ports.command_addr);
L
Linus Torvalds 已提交
695 696 697 698 699 700
	timeout = jiffies + WAIT_WORSTCASE;
	do {
		if (time_after(jiffies, timeout)) {
			SELECT_MASK(drive, 0);
			return 0;	/* drive timed-out */
		}
701

L
Linus Torvalds 已提交
702
		msleep(50);	/* give drive a breather */
703 704 705
		stat = ide_read_altstatus(drive);
	} while (stat & BUSY_STAT);

L
Linus Torvalds 已提交
706
	msleep(50);	/* wait for IRQ and DRQ_STAT */
707 708 709
	stat = ide_read_status(drive);

	if (!OK_STAT(stat, DRQ_STAT, BAD_R_STAT)) {
L
Linus Torvalds 已提交
710 711 712 713 714 715 716 717 718 719 720
		SELECT_MASK(drive, 0);
		printk("%s: CHECK for good STATUS\n", drive->name);
		return 0;
	}
	local_irq_save(flags);
	SELECT_MASK(drive, 0);
	id = kmalloc(SECTOR_WORDS*4, GFP_ATOMIC);
	if (!id) {
		local_irq_restore(flags);
		return 0;
	}
721
	hwif->input_data(drive, NULL, id, SECTOR_SIZE);
722
	(void)ide_read_status(drive);	/* clear drive IRQ */
L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730 731
	local_irq_enable();
	local_irq_restore(flags);
	ide_fix_driveid(id);
	if (id) {
		drive->id->dma_ultra = id->dma_ultra;
		drive->id->dma_mword = id->dma_mword;
		drive->id->dma_1word = id->dma_1word;
		/* anything more ? */
		kfree(id);
732 733 734

		if (drive->using_dma && ide_id_dma_bug(drive))
			ide_dma_off(drive);
L
Linus Torvalds 已提交
735 736 737 738 739
	}

	return 1;
}

740
int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
L
Linus Torvalds 已提交
741
{
742
	ide_hwif_t *hwif = drive->hwif;
743
	struct ide_io_ports *io_ports = &hwif->io_ports;
744
	int error = 0;
L
Linus Torvalds 已提交
745 746 747 748 749 750
	u8 stat;

//	while (HWGROUP(drive)->busy)
//		msleep(50);

#ifdef CONFIG_BLK_DEV_IDEDMA
751 752
	if (hwif->dma_ops)	/* check if host supports DMA */
		hwif->dma_ops->dma_host_set(drive, 0);
L
Linus Torvalds 已提交
753 754
#endif

755 756 757 758
	/* Skip setting PIO flow-control modes on pre-EIDE drives */
	if ((speed & 0xf8) == XFER_PIO_0 && !(drive->id->capability & 0x08))
		goto skip;

L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
	/*
	 * 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).
	 */
        /*
         * Select the drive, and issue the SETFEATURES command
         */
	disable_irq_nosync(hwif->irq);
	
	/*
	 *	FIXME: we race against the running IRQ here if
	 *	this is called from non IRQ context. If we use
	 *	disable_irq() we hang on the error path. Work
	 *	is needed.
	 */
	 
	udelay(1);
	SELECT_DRIVE(drive);
	SELECT_MASK(drive, 0);
	udelay(1);
781
	ide_set_irq(drive, 0);
782 783 784
	hwif->OUTB(speed, io_ports->nsect_addr);
	hwif->OUTB(SETFEATURES_XFER, io_ports->feature_addr);
	hwif->OUTBSYNC(drive, WIN_SETFEATURES, io_ports->command_addr);
785 786
	if (drive->quirk_list == 2)
		ide_set_irq(drive, 1);
L
Linus Torvalds 已提交
787

788 789 790
	error = __ide_wait_stat(drive, drive->ready_stat,
				BUSY_STAT|DRQ_STAT|ERR_STAT,
				WAIT_CMD, &stat);
L
Linus Torvalds 已提交
791 792 793 794 795 796 797 798 799 800 801 802 803 804

	SELECT_MASK(drive, 0);

	enable_irq(hwif->irq);

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

	drive->id->dma_ultra &= ~0xFF00;
	drive->id->dma_mword &= ~0x0F00;
	drive->id->dma_1word &= ~0x0F00;

805
 skip:
L
Linus Torvalds 已提交
806
#ifdef CONFIG_BLK_DEV_IDEDMA
807 808
	if ((speed >= XFER_SW_DMA_0 || (hwif->host_flags & IDE_HFLAG_VDMA)) &&
	    drive->using_dma)
809 810
		hwif->dma_ops->dma_host_set(drive, 1);
	else if (hwif->dma_ops)	/* check if host supports DMA */
811
		ide_dma_off_quietly(drive);
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
#endif

	switch(speed) {
		case XFER_UDMA_7:   drive->id->dma_ultra |= 0x8080; break;
		case XFER_UDMA_6:   drive->id->dma_ultra |= 0x4040; break;
		case XFER_UDMA_5:   drive->id->dma_ultra |= 0x2020; break;
		case XFER_UDMA_4:   drive->id->dma_ultra |= 0x1010; break;
		case XFER_UDMA_3:   drive->id->dma_ultra |= 0x0808; break;
		case XFER_UDMA_2:   drive->id->dma_ultra |= 0x0404; break;
		case XFER_UDMA_1:   drive->id->dma_ultra |= 0x0202; break;
		case XFER_UDMA_0:   drive->id->dma_ultra |= 0x0101; break;
		case XFER_MW_DMA_2: drive->id->dma_mword |= 0x0404; break;
		case XFER_MW_DMA_1: drive->id->dma_mword |= 0x0202; break;
		case XFER_MW_DMA_0: drive->id->dma_mword |= 0x0101; break;
		case XFER_SW_DMA_2: drive->id->dma_1word |= 0x0404; break;
		case XFER_SW_DMA_1: drive->id->dma_1word |= 0x0202; break;
		case XFER_SW_DMA_0: drive->id->dma_1word |= 0x0101; break;
		default: break;
	}
	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
 */
static void __ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
		      unsigned int timeout, ide_expiry_t *expiry)
{
	ide_hwgroup_t *hwgroup = HWGROUP(drive);

851
	BUG_ON(hwgroup->handler);
L
Linus Torvalds 已提交
852 853 854
	hwgroup->handler	= handler;
	hwgroup->expiry		= expiry;
	hwgroup->timer.expires	= jiffies + timeout;
855
	hwgroup->req_gen_timer	= hwgroup->req_gen;
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	add_timer(&hwgroup->timer);
}

void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
		      unsigned int timeout, ide_expiry_t *expiry)
{
	unsigned long flags;
	spin_lock_irqsave(&ide_lock, flags);
	__ide_set_handler(drive, handler, timeout, expiry);
	spin_unlock_irqrestore(&ide_lock, flags);
}

EXPORT_SYMBOL(ide_set_handler);
 
/**
 *	ide_execute_command	-	execute an IDE command
 *	@drive: IDE drive to issue the command against
 *	@command: command byte to write
 *	@handler: handler for next phase
 *	@timeout: timeout for command
 *	@expiry:  handler to run on timeout
 *
 *	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.
 */
883 884 885

void ide_execute_command(ide_drive_t *drive, u8 cmd, ide_handler_t *handler,
			 unsigned timeout, ide_expiry_t *expiry)
L
Linus Torvalds 已提交
886 887 888
{
	unsigned long flags;
	ide_hwif_t *hwif = HWIF(drive);
889

L
Linus Torvalds 已提交
890
	spin_lock_irqsave(&ide_lock, flags);
891
	__ide_set_handler(drive, handler, timeout, expiry);
892
	hwif->OUTBSYNC(drive, cmd, hwif->io_ports.command_addr);
893 894 895 896 897 898
	/*
	 * 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
	 */
L
Linus Torvalds 已提交
899 900 901 902 903
	ndelay(400);
	spin_unlock_irqrestore(&ide_lock, flags);
}
EXPORT_SYMBOL(ide_execute_command);

904 905 906 907 908 909 910 911 912 913 914
void ide_execute_pkt_cmd(ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
	unsigned long flags;

	spin_lock_irqsave(&ide_lock, flags);
	hwif->OUTBSYNC(drive, WIN_PACKETCMD, hwif->io_ports.command_addr);
	ndelay(400);
	spin_unlock_irqrestore(&ide_lock, flags);
}
EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd);
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931

/* needed below */
static ide_startstop_t do_reset1 (ide_drive_t *, int);

/*
 * atapi_reset_pollfunc() gets invoked to poll the interface for completion every 50ms
 * during an atapi drive reset operation. If the drive has not yet responded,
 * and we have not yet hit our maximum waiting time, then the timer is restarted
 * for another 50ms.
 */
static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup	= HWGROUP(drive);
	u8 stat;

	SELECT_DRIVE(drive);
	udelay (10);
932
	stat = ide_read_status(drive);
L
Linus Torvalds 已提交
933

934
	if (OK_STAT(stat, 0, BUSY_STAT))
L
Linus Torvalds 已提交
935
		printk("%s: ATAPI reset complete\n", drive->name);
936
	else {
L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950
		if (time_before(jiffies, hwgroup->poll_timeout)) {
			ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
			/* continue polling */
			return ide_started;
		}
		/* end of polling */
		hwgroup->polling = 0;
		printk("%s: ATAPI reset timed-out, status=0x%02x\n",
				drive->name, stat);
		/* do it the old fashioned way */
		return do_reset1(drive, 1);
	}
	/* done polling */
	hwgroup->polling = 0;
951
	hwgroup->resetting = 0;
L
Linus Torvalds 已提交
952 953 954 955 956 957 958 959 960 961 962 963 964
	return ide_stopped;
}

/*
 * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
 * during an ide reset operation. If the drives have not yet responded,
 * and we have not yet hit our maximum waiting time, then the timer is restarted
 * for another 50ms.
 */
static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup	= HWGROUP(drive);
	ide_hwif_t *hwif	= HWIF(drive);
965
	const struct ide_port_ops *port_ops = hwif->port_ops;
L
Linus Torvalds 已提交
966 967
	u8 tmp;

968 969
	if (port_ops && port_ops->reset_poll) {
		if (port_ops->reset_poll(drive)) {
L
Linus Torvalds 已提交
970 971 972 973 974 975
			printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
				hwif->name, drive->name);
			return ide_stopped;
		}
	}

976 977 978
	tmp = ide_read_status(drive);

	if (!OK_STAT(tmp, 0, BUSY_STAT)) {
L
Linus Torvalds 已提交
979 980 981 982 983 984 985 986 987
		if (time_before(jiffies, hwgroup->poll_timeout)) {
			ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
			/* continue polling */
			return ide_started;
		}
		printk("%s: reset timed-out, status=0x%02x\n", hwif->name, tmp);
		drive->failures++;
	} else  {
		printk("%s: reset: ", hwif->name);
988 989 990
		tmp = ide_read_error(drive);

		if (tmp == 1) {
L
Linus Torvalds 已提交
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
			printk("success\n");
			drive->failures = 0;
		} else {
			drive->failures++;
			printk("master: ");
			switch (tmp & 0x7f) {
				case 1: printk("passed");
					break;
				case 2: printk("formatter device error");
					break;
				case 3: printk("sector buffer error");
					break;
				case 4: printk("ECC circuitry error");
					break;
				case 5: printk("controlling MPU error");
					break;
				default:printk("error (0x%02x?)", tmp);
			}
			if (tmp & 0x80)
				printk("; slave: failed");
			printk("\n");
		}
	}
	hwgroup->polling = 0;	/* done polling */
1015
	hwgroup->resetting = 0; /* done reset attempt */
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	return ide_stopped;
}

static void ide_disk_pre_reset(ide_drive_t *drive)
{
	int legacy = (drive->id->cfs_enable_2 & 0x0400) ? 0 : 1;

	drive->special.all = 0;
	drive->special.b.set_geometry = legacy;
	drive->special.b.recalibrate  = legacy;
1026
	drive->mult_count = 0;
L
Linus Torvalds 已提交
1027 1028 1029 1030 1031 1032 1033 1034
	if (!drive->keep_settings && !drive->using_dma)
		drive->mult_req = 0;
	if (drive->mult_req != drive->mult_count)
		drive->special.b.set_multmode = 1;
}

static void pre_reset(ide_drive_t *drive)
{
1035 1036
	const struct ide_port_ops *port_ops = drive->hwif->port_ops;

L
Linus Torvalds 已提交
1037 1038 1039 1040 1041
	if (drive->media == ide_disk)
		ide_disk_pre_reset(drive);
	else
		drive->post_reset = 1;

1042 1043
	if (drive->using_dma) {
		if (drive->crc_count)
1044
			ide_check_dma_crc(drive);
1045 1046 1047 1048 1049 1050
		else
			ide_dma_off(drive);
	}

	if (!drive->keep_settings) {
		if (!drive->using_dma) {
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055 1056
			drive->unmask = 0;
			drive->io_32bit = 0;
		}
		return;
	}

1057 1058
	if (port_ops && port_ops->pre_reset)
		port_ops->pre_reset(drive);
L
Linus Torvalds 已提交
1059

1060 1061 1062
	if (drive->current_speed != 0xff)
		drive->desired_speed = drive->current_speed;
	drive->current_speed = 0xff;
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
}

/*
 * do_reset1() attempts to recover a confused drive by resetting it.
 * Unfortunately, resetting a disk drive actually resets all devices on
 * the same interface, so it can really be thought of as resetting the
 * interface rather than resetting the drive.
 *
 * ATAPI devices have their own reset mechanism which allows them to be
 * individually reset without clobbering other devices on the same interface.
 *
 * Unfortunately, the IDE interface does not generate an interrupt to let
 * us know when the reset operation has finished, so we must poll for this.
 * Equally poor, though, is the fact that this may a very long time to complete,
 * (up to 30 seconds worstcase).  So, instead of busy-waiting here for it,
 * we set a timer to poll at 50ms intervals.
 */
static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
{
	unsigned int unit;
	unsigned long flags;
	ide_hwif_t *hwif;
	ide_hwgroup_t *hwgroup;
1086
	struct ide_io_ports *io_ports;
1087
	const struct ide_port_ops *port_ops;
1088 1089
	u8 ctl;

L
Linus Torvalds 已提交
1090 1091 1092 1093
	spin_lock_irqsave(&ide_lock, flags);
	hwif = HWIF(drive);
	hwgroup = HWGROUP(drive);

1094 1095
	io_ports = &hwif->io_ports;

L
Linus Torvalds 已提交
1096
	/* We must not reset with running handlers */
E
Eric Sesterhenn 已提交
1097
	BUG_ON(hwgroup->handler != NULL);
L
Linus Torvalds 已提交
1098 1099 1100

	/* For an ATAPI device, first try an ATAPI SRST. */
	if (drive->media != ide_disk && !do_not_try_atapi) {
1101
		hwgroup->resetting = 1;
L
Linus Torvalds 已提交
1102 1103 1104
		pre_reset(drive);
		SELECT_DRIVE(drive);
		udelay (20);
1105
		hwif->OUTBSYNC(drive, WIN_SRST, io_ports->command_addr);
1106
		ndelay(400);
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
		hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
		hwgroup->polling = 1;
		__ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
		spin_unlock_irqrestore(&ide_lock, flags);
		return ide_started;
	}

	/*
	 * First, reset any device state data we were maintaining
	 * for any of the drives on this interface.
	 */
	for (unit = 0; unit < MAX_DRIVES; ++unit)
		pre_reset(&hwif->drives[unit]);

1121
	if (io_ports->ctl_addr == 0) {
L
Linus Torvalds 已提交
1122 1123 1124 1125
		spin_unlock_irqrestore(&ide_lock, flags);
		return ide_stopped;
	}

1126
	hwgroup->resetting = 1;
L
Linus Torvalds 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135
	/*
	 * Note that we also set nIEN while resetting the device,
	 * to mask unwanted interrupts from the interface during the reset.
	 * However, due to the design of PC hardware, this will cause an
	 * immediate interrupt due to the edge transition it produces.
	 * This single interrupt gives us a "fast poll" for drives that
	 * recover from reset very quickly, saving us the first 50ms wait time.
	 */
	/* set SRST and nIEN */
1136
	hwif->OUTBSYNC(drive, drive->ctl|6, io_ports->ctl_addr);
L
Linus Torvalds 已提交
1137 1138
	/* more than enough time */
	udelay(10);
1139 1140 1141 1142
	if (drive->quirk_list == 2)
		ctl = drive->ctl;	/* clear SRST and nIEN */
	else
		ctl = drive->ctl | 2;	/* clear SRST, leave nIEN */
1143
	hwif->OUTBSYNC(drive, ctl, io_ports->ctl_addr);
L
Linus Torvalds 已提交
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
	/* more than enough time */
	udelay(10);
	hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
	hwgroup->polling = 1;
	__ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);

	/*
	 * Some weird controller like resetting themselves to a strange
	 * state when the disks are reset this way. At least, the Winbond
	 * 553 documentation says that
	 */
1155 1156 1157
	port_ops = hwif->port_ops;
	if (port_ops && port_ops->resetproc)
		port_ops->resetproc(drive);
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175

	spin_unlock_irqrestore(&ide_lock, flags);
	return ide_started;
}

/*
 * ide_do_reset() is the entry point to the drive/interface reset code.
 */

ide_startstop_t ide_do_reset (ide_drive_t *drive)
{
	return do_reset1(drive, 0);
}

EXPORT_SYMBOL(ide_do_reset);

/*
 * ide_wait_not_busy() waits for the currently selected device on the hwif
1176
 * to report a non-busy status, see comments in ide_probe_port().
L
Linus Torvalds 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
 */
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);
1188
		stat = hwif->INB(hwif->io_ports.status_addr);
L
Linus Torvalds 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197
		if ((stat & BUSY_STAT) == 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;
1198
		touch_softlockup_watchdog();
1199
		touch_nmi_watchdog();
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204 1205
	}
	return -EBUSY;
}

EXPORT_SYMBOL_GPL(ide_wait_not_busy);