ide-io.c 32.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
 *	IDE I/O functions
 *
 *	Basic PIO and command management functionality.
 *
 * This code was split off from ide.c. See ide.c for history and original
 * copyrights.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * For the avoidance of doubt the "preferred form" of this code is one which
 * is in an open non patent encumbered format. Where cryptographic key signing
 * forms part of the process of creating an executable the information
 * including keys needed to generate an equivalently functional executable
 * are deemed to be part of the source code.
 */
 
 
#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/init.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/ide.h>
43
#include <linux/hdreg.h>
Linus Torvalds's avatar
Linus Torvalds committed
44
45
46
47
48
49
50
#include <linux/completion.h>
#include <linux/reboot.h>
#include <linux/cdrom.h>
#include <linux/seq_file.h>
#include <linux/device.h>
#include <linux/kmod.h>
#include <linux/scatterlist.h>
Jiri Slaby's avatar
Jiri Slaby committed
51
#include <linux/bitops.h>
Linus Torvalds's avatar
Linus Torvalds committed
52
53
54
55
56
57

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

58
static int __ide_end_request(ide_drive_t *drive, struct request *rq,
59
			     int uptodate, unsigned int nr_bytes, int dequeue)
Linus Torvalds's avatar
Linus Torvalds committed
60
61
{
	int ret = 1;
62
63
64
65
	int error = 0;

	if (uptodate <= 0)
		error = uptodate ? uptodate : -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
66
67
68
69
70

	/*
	 * if failfast is set on a request, override number of sectors and
	 * complete the whole request right now
	 */
71
	if (blk_noretry_request(rq) && error)
72
		nr_bytes = rq->hard_nr_sectors << 9;
Linus Torvalds's avatar
Linus Torvalds committed
73

74
	if (!blk_fs_request(rq) && error && !rq->errors)
Linus Torvalds's avatar
Linus Torvalds committed
75
76
77
78
79
80
		rq->errors = -EIO;

	/*
	 * decide whether to reenable DMA -- 3 is a random magic for now,
	 * if we DMA timeout more than 3 times, just stay in PIO
	 */
81
82
83
	if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) &&
	    drive->retry_pio <= 3) {
		drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY;
84
		ide_dma_on(drive);
Linus Torvalds's avatar
Linus Torvalds committed
85
86
	}

87
	if (!blk_end_request(rq, error, nr_bytes))
Linus Torvalds's avatar
Linus Torvalds committed
88
		ret = 0;
89
90

	if (ret == 0 && dequeue)
91
		drive->hwif->rq = NULL;
92

Linus Torvalds's avatar
Linus Torvalds committed
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
	return ret;
}

/**
 *	ide_end_request		-	complete an IDE I/O
 *	@drive: IDE device for the I/O
 *	@uptodate:
 *	@nr_sectors: number of sectors completed
 *
 *	This is our end_request wrapper function. We complete the I/O
 *	update random number input and dequeue the request, which if
 *	it was tagged may be out of order.
 */

int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors)
{
109
	unsigned int nr_bytes = nr_sectors << 9;
110
	struct request *rq = drive->hwif->rq;
Linus Torvalds's avatar
Linus Torvalds committed
111

112
113
114
115
116
117
	if (!nr_bytes) {
		if (blk_pc_request(rq))
			nr_bytes = rq->data_len;
		else
			nr_bytes = rq->hard_cur_sectors << 9;
	}
Linus Torvalds's avatar
Linus Torvalds committed
118

119
	return __ide_end_request(drive, rq, uptodate, nr_bytes, 1);
Linus Torvalds's avatar
Linus Torvalds committed
120
121
122
}
EXPORT_SYMBOL(ide_end_request);

123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/**
 *	ide_end_dequeued_request	-	complete an IDE I/O
 *	@drive: IDE device for the I/O
 *	@uptodate:
 *	@nr_sectors: number of sectors completed
 *
 *	Complete an I/O that is no longer on the request queue. This
 *	typically occurs when we pull the request and issue a REQUEST_SENSE.
 *	We must still finish the old request but we must not tamper with the
 *	queue in the meantime.
 *
 *	NOTE: This path does not handle barrier, but barrier is not supported
 *	on ide-cd anyway.
 */

int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
			     int uptodate, int nr_sectors)
{
141
	BUG_ON(!blk_rq_started(rq));
142

143
	return __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0);
144
145
146
}
EXPORT_SYMBOL_GPL(ide_end_dequeued_request);

Linus Torvalds's avatar
Linus Torvalds committed
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/**
 *	ide_end_drive_cmd	-	end an explicit drive command
 *	@drive: command 
 *	@stat: status bits
 *	@err: error bits
 *
 *	Clean up after success/failure of an explicit drive command.
 *	These get thrown onto the queue so they are synchronized with
 *	real I/O operations on the drive.
 *
 *	In LBA48 mode we have to read the register set twice to get
 *	all the extra information out.
 */
 
void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
{
163
164
	ide_hwif_t *hwif = drive->hwif;
	struct request *rq = hwif->rq;
Linus Torvalds's avatar
Linus Torvalds committed
165

166
	if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
167
168
169
170
		ide_task_t *task = (ide_task_t *)rq->special;

		if (task) {
			struct ide_taskfile *tf = &task->tf;
171
172
173

			tf->error = err;
			tf->status = stat;
Linus Torvalds's avatar
Linus Torvalds committed
174

175
			drive->hwif->tp_ops->tf_read(drive, task);
176
177
178

			if (task->tf_flags & IDE_TFLAG_DYN)
				kfree(task);
Linus Torvalds's avatar
Linus Torvalds committed
179
180
		}
	} else if (blk_pm_request(rq)) {
181
		struct request_pm_state *pm = rq->data;
182
183

		ide_complete_power_step(drive, rq);
184
		if (pm->pm_step == IDE_PM_COMPLETED)
Linus Torvalds's avatar
Linus Torvalds committed
185
186
187
188
			ide_complete_pm_request(drive, rq);
		return;
	}

189
	hwif->rq = NULL;
190

Linus Torvalds's avatar
Linus Torvalds committed
191
	rq->errors = err;
192

193
194
	if (unlikely(blk_end_request(rq, (rq->errors ? -EIO : 0),
				     blk_rq_bytes(rq))))
195
		BUG();
Linus Torvalds's avatar
Linus Torvalds committed
196
197
198
199
200
201
}
EXPORT_SYMBOL(ide_end_drive_cmd);

static void ide_kill_rq(ide_drive_t *drive, struct request *rq)
{
	if (rq->rq_disk) {
202
		struct ide_driver *drv;
Linus Torvalds's avatar
Linus Torvalds committed
203

204
		drv = *(struct ide_driver **)rq->rq_disk->private_data;
Linus Torvalds's avatar
Linus Torvalds committed
205
206
207
208
209
210
211
212
213
		drv->end_request(drive, 0, 0);
	} else
		ide_end_request(drive, 0, 0);
}

static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
{
	ide_hwif_t *hwif = drive->hwif;

214
215
	if ((stat & ATA_BUSY) ||
	    ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
Linus Torvalds's avatar
Linus Torvalds committed
216
217
		/* other bits are useless when BUSY */
		rq->errors |= ERROR_RESET;
218
	} else if (stat & ATA_ERR) {
Linus Torvalds's avatar
Linus Torvalds committed
219
		/* err has different meaning on cdrom and tape */
220
		if (err == ATA_ABORTED) {
221
			if ((drive->dev_flags & IDE_DFLAG_LBA) &&
222
223
			    /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */
			    hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS)
Linus Torvalds's avatar
Linus Torvalds committed
224
225
226
227
				return ide_stopped;
		} else if ((err & BAD_CRC) == BAD_CRC) {
			/* UDMA crc error, just retry the operation */
			drive->crc_count++;
228
		} else if (err & (ATA_BBK | ATA_UNC)) {
Linus Torvalds's avatar
Linus Torvalds committed
229
230
			/* retries won't help these */
			rq->errors = ERROR_MAX;
231
		} else if (err & ATA_TRK0NF) {
Linus Torvalds's avatar
Linus Torvalds committed
232
233
234
235
236
			/* help it find track zero */
			rq->errors |= ERROR_RECAL;
		}
	}

237
	if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ &&
238
239
240
241
242
	    (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) {
		int nsect = drive->mult_count ? drive->mult_count : 1;

		ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE);
	}
Linus Torvalds's avatar
Linus Torvalds committed
243

244
245
246
247
248
	if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) {
		ide_kill_rq(drive, rq);
		return ide_stopped;
	}

249
	if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
250
		rq->errors |= ERROR_RESET;
Linus Torvalds's avatar
Linus Torvalds committed
251

252
	if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
Linus Torvalds's avatar
Linus Torvalds committed
253
		++rq->errors;
254
		return ide_do_reset(drive);
Linus Torvalds's avatar
Linus Torvalds committed
255
	}
256
257
258
259
260
261

	if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
		drive->special.b.recalibrate = 1;

	++rq->errors;

Linus Torvalds's avatar
Linus Torvalds committed
262
263
264
265
266
267
268
	return ide_stopped;
}

static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
{
	ide_hwif_t *hwif = drive->hwif;

269
270
	if ((stat & ATA_BUSY) ||
	    ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274
275
276
		/* other bits are useless when BUSY */
		rq->errors |= ERROR_RESET;
	} else {
		/* add decoding error stuff */
	}

277
	if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
Linus Torvalds's avatar
Linus Torvalds committed
278
		/* force an abort */
279
		hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE);
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
283
284
285
286
287
288
289
290
291
292
293

	if (rq->errors >= ERROR_MAX) {
		ide_kill_rq(drive, rq);
	} else {
		if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
			++rq->errors;
			return ide_do_reset(drive);
		}
		++rq->errors;
	}

	return ide_stopped;
}

294
static ide_startstop_t
Linus Torvalds's avatar
Linus Torvalds committed
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
__ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
{
	if (drive->media == ide_disk)
		return ide_ata_error(drive, rq, stat, err);
	return ide_atapi_error(drive, rq, stat, err);
}

/**
 *	ide_error	-	handle an error on the IDE
 *	@drive: drive the error occurred on
 *	@msg: message to report
 *	@stat: status bits
 *
 *	ide_error() takes action based on the error returned by the drive.
 *	For normal I/O that may well include retries. We deal with
 *	both new-style (taskfile) and old style command handling here.
 *	In the case of taskfile command handling there is work left to
 *	do
 */
 
ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
{
	struct request *rq;
	u8 err;

	err = ide_dump_status(drive, msg, stat);

322
323
	rq = drive->hwif->rq;
	if (rq == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
324
325
326
		return ide_stopped;

	/* retry only "normal" I/O: */
327
	if (!blk_fs_request(rq)) {
Linus Torvalds's avatar
Linus Torvalds committed
328
329
330
331
332
		rq->errors = 1;
		ide_end_drive_cmd(drive, stat, err);
		return ide_stopped;
	}

333
	return __ide_error(drive, rq, stat, err);
Linus Torvalds's avatar
Linus Torvalds committed
334
335
336
}
EXPORT_SYMBOL_GPL(ide_error);

337
static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
Linus Torvalds's avatar
Linus Torvalds committed
338
{
339
340
341
342
	tf->nsect   = drive->sect;
	tf->lbal    = drive->sect;
	tf->lbam    = drive->cyl;
	tf->lbah    = drive->cyl >> 8;
343
	tf->device  = (drive->head - 1) | drive->select;
344
	tf->command = ATA_CMD_INIT_DEV_PARAMS;
Linus Torvalds's avatar
Linus Torvalds committed
345
346
}

347
static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
Linus Torvalds's avatar
Linus Torvalds committed
348
{
349
	tf->nsect   = drive->sect;
350
	tf->command = ATA_CMD_RESTORE;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
}

353
static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
Linus Torvalds's avatar
Linus Torvalds committed
354
{
355
	tf->nsect   = drive->mult_req;
356
	tf->command = ATA_CMD_SET_MULTI;
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
362
363
364
}

static ide_startstop_t ide_disk_special(ide_drive_t *drive)
{
	special_t *s = &drive->special;
	ide_task_t args;

	memset(&args, 0, sizeof(ide_task_t));
365
	args.data_phase = TASKFILE_NO_DATA;
Linus Torvalds's avatar
Linus Torvalds committed
366
367
368

	if (s->b.set_geometry) {
		s->b.set_geometry = 0;
369
		ide_tf_set_specify_cmd(drive, &args.tf);
Linus Torvalds's avatar
Linus Torvalds committed
370
371
	} else if (s->b.recalibrate) {
		s->b.recalibrate = 0;
372
		ide_tf_set_restore_cmd(drive, &args.tf);
Linus Torvalds's avatar
Linus Torvalds committed
373
374
	} else if (s->b.set_multmode) {
		s->b.set_multmode = 0;
375
		ide_tf_set_setmult_cmd(drive, &args.tf);
Linus Torvalds's avatar
Linus Torvalds committed
376
377
378
379
380
381
382
	} else if (s->all) {
		int special = s->all;
		s->all = 0;
		printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special);
		return ide_stopped;
	}

383
	args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE |
384
			IDE_TFLAG_CUSTOM_HANDLER;
385

Linus Torvalds's avatar
Linus Torvalds committed
386
387
388
389
390
391
392
393
394
	do_rw_taskfile(drive, &args);

	return ide_started;
}

/**
 *	do_special		-	issue some special commands
 *	@drive: drive the command is for
 *
395
396
397
398
 *	do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS,
 *	ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive.
 *
 *	It used to do much more, but has been scaled back.
Linus Torvalds's avatar
Linus Torvalds committed
399
400
401
402
403
404
405
406
407
 */

static ide_startstop_t do_special (ide_drive_t *drive)
{
	special_t *s = &drive->special;

#ifdef DEBUG
	printk("%s: do_special: 0x%02x\n", drive->name, s->all);
#endif
408
409
	if (drive->media == ide_disk)
		return ide_disk_special(drive);
Linus Torvalds's avatar
Linus Torvalds committed
410

411
412
413
	s->all = 0;
	drive->mult_req = 0;
	return ide_stopped;
Linus Torvalds's avatar
Linus Torvalds committed
414
415
416
417
418
419
420
}

void ide_map_sg(ide_drive_t *drive, struct request *rq)
{
	ide_hwif_t *hwif = drive->hwif;
	struct scatterlist *sg = hwif->sg_table;

421
	if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) {
Linus Torvalds's avatar
Linus Torvalds committed
422
423
424
425
426
427
428
429
430
431
432
433
434
435
		hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
	} else {
		sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE);
		hwif->sg_nents = 1;
	}
}

EXPORT_SYMBOL_GPL(ide_map_sg);

void ide_init_sg_cmd(ide_drive_t *drive, struct request *rq)
{
	ide_hwif_t *hwif = drive->hwif;

	hwif->nsect = hwif->nleft = rq->nr_sectors;
Jens Axboe's avatar
Jens Axboe committed
436
437
	hwif->cursg_ofs = 0;
	hwif->cursg = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
438
439
440
441
442
443
}

EXPORT_SYMBOL_GPL(ide_init_sg_cmd);

/**
 *	execute_drive_command	-	issue special drive command
444
 *	@drive: the drive to issue the command on
Linus Torvalds's avatar
Linus Torvalds committed
445
446
447
448
449
450
451
452
453
454
455
456
 *	@rq: the request structure holding the command
 *
 *	execute_drive_cmd() issues a special drive command,  usually 
 *	initiated by ioctl() from the external hdparm program. The
 *	command can be a drive command, drive task or taskfile 
 *	operation. Weirdly you can call it with NULL to wait for
 *	all commands to finish. Don't do this as that is due to change
 */

static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
		struct request *rq)
{
457
	ide_hwif_t *hwif = drive->hwif;
458
	ide_task_t *task = rq->special;
Linus Torvalds's avatar
Linus Torvalds committed
459

460
	if (task) {
461
		hwif->data_phase = task->data_phase;
Linus Torvalds's avatar
Linus Torvalds committed
462
463
464
465
466
467
468
469
470
471
472

		switch (hwif->data_phase) {
		case TASKFILE_MULTI_OUT:
		case TASKFILE_OUT:
		case TASKFILE_MULTI_IN:
		case TASKFILE_IN:
			ide_init_sg_cmd(drive, rq);
			ide_map_sg(drive, rq);
		default:
			break;
		}
473

474
475
476
		return do_rw_taskfile(drive, task);
	}

Linus Torvalds's avatar
Linus Torvalds committed
477
478
479
480
481
482
483
 	/*
 	 * NULL is actually a valid way of waiting for
 	 * all current requests to be flushed from the queue.
 	 */
#ifdef DEBUG
 	printk("%s: DRIVE_CMD (null)\n", drive->name);
#endif
484
	ide_end_drive_cmd(drive, hwif->tp_ops->read_status(hwif),
485
			  ide_read_error(drive));
486

Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
 	return ide_stopped;
}

490
491
492
493
494
495
496
497
498
499
int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
		       int arg)
{
	struct request_queue *q = drive->queue;
	struct request *rq;
	int ret = 0;

	if (!(setting->flags & DS_SYNC))
		return setting->set(drive, arg);

500
	rq = blk_get_request(q, READ, __GFP_WAIT);
501
502
503
504
505
506
507
508
509
510
511
512
513
514
	rq->cmd_type = REQ_TYPE_SPECIAL;
	rq->cmd_len = 5;
	rq->cmd[0] = REQ_DEVSET_EXEC;
	*(int *)&rq->cmd[1] = arg;
	rq->special = setting->set;

	if (blk_execute_rq(q, NULL, rq, 0))
		ret = rq->errors;
	blk_put_request(rq);

	return ret;
}
EXPORT_SYMBOL_GPL(ide_devset_execute);

515
516
static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
{
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
	u8 cmd = rq->cmd[0];

	if (cmd == REQ_PARK_HEADS || cmd == REQ_UNPARK_HEADS) {
		ide_task_t task;
		struct ide_taskfile *tf = &task.tf;

		memset(&task, 0, sizeof(task));
		if (cmd == REQ_PARK_HEADS) {
			drive->sleep = *(unsigned long *)rq->special;
			drive->dev_flags |= IDE_DFLAG_SLEEPING;
			tf->command = ATA_CMD_IDLEIMMEDIATE;
			tf->feature = 0x44;
			tf->lbal = 0x4c;
			tf->lbam = 0x4e;
			tf->lbah = 0x55;
			task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER;
		} else		/* cmd == REQ_UNPARK_HEADS */
			tf->command = ATA_CMD_CHK_POWER;

		task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
		task.rq = rq;
		drive->hwif->data_phase = task.data_phase = TASKFILE_NO_DATA;
		return do_rw_taskfile(drive, &task);
	}

	switch (cmd) {
543
544
545
546
547
548
549
550
551
552
553
554
	case REQ_DEVSET_EXEC:
	{
		int err, (*setfunc)(ide_drive_t *, int) = rq->special;

		err = setfunc(drive, *(int *)&rq->cmd[1]);
		if (err)
			rq->errors = err;
		else
			err = 1;
		ide_end_request(drive, err, 0);
		return ide_stopped;
	}
555
556
557
558
559
560
561
562
563
	case REQ_DRIVE_RESET:
		return ide_do_reset(drive);
	default:
		blk_dump_rq_flags(rq, "ide_special_rq - bad request");
		ide_end_request(drive, 0, 0);
		return ide_stopped;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
564
565
566
567
/**
 *	start_request	-	start of I/O and command issuing for IDE
 *
 *	start_request() initiates handling of a new I/O request. It
568
 *	accepts commands and I/O (read/write) requests.
Linus Torvalds's avatar
Linus Torvalds committed
569
570
571
572
573
574
575
576
 *
 *	FIXME: this function needs a rename
 */
 
static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
{
	ide_startstop_t startstop;

577
	BUG_ON(!blk_rq_started(rq));
Linus Torvalds's avatar
Linus Torvalds committed
578
579
580

#ifdef DEBUG
	printk("%s: start_request: current=0x%08lx\n",
581
		drive->hwif->name, (unsigned long) rq);
Linus Torvalds's avatar
Linus Torvalds committed
582
583
584
585
#endif

	/* bail early if we've exceeded max_failures */
	if (drive->max_failures && (drive->failures > drive->max_failures)) {
586
		rq->cmd_flags |= REQ_FAILED;
Linus Torvalds's avatar
Linus Torvalds committed
587
588
589
		goto kill_rq;
	}

590
591
	if (blk_pm_request(rq))
		ide_check_pm_state(drive, rq);
Linus Torvalds's avatar
Linus Torvalds committed
592
593

	SELECT_DRIVE(drive);
594
595
	if (ide_wait_stat(&startstop, drive, drive->ready_stat,
			  ATA_BUSY | ATA_DRQ, WAIT_READY)) {
Linus Torvalds's avatar
Linus Torvalds committed
596
597
598
599
		printk(KERN_ERR "%s: drive not ready for command\n", drive->name);
		return startstop;
	}
	if (!drive->special.all) {
600
		struct ide_driver *drv;
Linus Torvalds's avatar
Linus Torvalds committed
601

602
603
604
605
606
607
608
		/*
		 * We reset the drive so we need to issue a SETFEATURES.
		 * Do it _after_ do_special() restored device parameters.
		 */
		if (drive->current_speed == 0xff)
			ide_config_drive_speed(drive, drive->desired_speed);

609
		if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
Linus Torvalds's avatar
Linus Torvalds committed
610
611
			return execute_drive_cmd(drive, rq);
		else if (blk_pm_request(rq)) {
612
			struct request_pm_state *pm = rq->data;
Linus Torvalds's avatar
Linus Torvalds committed
613
614
#ifdef DEBUG_PM
			printk("%s: start_power_step(step: %d)\n",
615
				drive->name, pm->pm_step);
Linus Torvalds's avatar
Linus Torvalds committed
616
617
618
#endif
			startstop = ide_start_power_step(drive, rq);
			if (startstop == ide_stopped &&
619
			    pm->pm_step == IDE_PM_COMPLETED)
Linus Torvalds's avatar
Linus Torvalds committed
620
621
				ide_complete_pm_request(drive, rq);
			return startstop;
622
623
624
625
626
627
628
629
630
631
		} else if (!rq->rq_disk && blk_special_request(rq))
			/*
			 * TODO: Once all ULDs have been modified to
			 * check for specific op codes rather than
			 * blindly accepting any special request, the
			 * check for ->rq_disk above may be replaced
			 * by a more suitable mechanism or even
			 * dropped entirely.
			 */
			return ide_special_rq(drive, rq);
Linus Torvalds's avatar
Linus Torvalds committed
632

633
		drv = *(struct ide_driver **)rq->rq_disk->private_data;
634
635

		return drv->do_request(drive, rq, rq->sector);
Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
640
641
642
643
644
645
646
647
648
	}
	return do_special(drive);
kill_rq:
	ide_kill_rq(drive, rq);
	return ide_stopped;
}

/**
 *	ide_stall_queue		-	pause an IDE device
 *	@drive: drive to stall
 *	@timeout: time to stall for (jiffies)
 *
 *	ide_stall_queue() can be used by a drive to give excess bandwidth back
649
 *	to the port by sleeping for timeout jiffies.
Linus Torvalds's avatar
Linus Torvalds committed
650
651
652
653
654
655
656
 */
 
void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
{
	if (timeout > WAIT_WORSTCASE)
		timeout = WAIT_WORSTCASE;
	drive->sleep = timeout + jiffies;
657
	drive->dev_flags |= IDE_DFLAG_SLEEPING;
Linus Torvalds's avatar
Linus Torvalds committed
658
659
660
}
EXPORT_SYMBOL(ide_stall_queue);

661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
static inline int ide_lock_port(ide_hwif_t *hwif)
{
	if (hwif->busy)
		return 1;

	hwif->busy = 1;

	return 0;
}

static inline void ide_unlock_port(ide_hwif_t *hwif)
{
	hwif->busy = 0;
}

static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif)
{
	int rc = 0;

	if (host->host_flags & IDE_HFLAG_SERIALIZE) {
		rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy);
		if (rc == 0) {
			/* for atari only */
			ide_get_lock(ide_intr, hwif);
		}
	}
	return rc;
}

static inline void ide_unlock_host(struct ide_host *host)
{
	if (host->host_flags & IDE_HFLAG_SERIALIZE) {
		/* for atari only */
		ide_release_lock();
		clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
699
/*
700
 * Issue a new request to a device.
Linus Torvalds's avatar
Linus Torvalds committed
701
 */
702
void do_ide_request(struct request_queue *q)
Linus Torvalds's avatar
Linus Torvalds committed
703
{
704
705
	ide_drive_t	*drive = q->queuedata;
	ide_hwif_t	*hwif = drive->hwif;
706
707
	struct ide_host *host = hwif->host;
	struct request	*rq = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
708
709
	ide_startstop_t	startstop;

710
711
712
713
714
715
	/*
	 * drive is doing pre-flush, ordered write, post-flush sequence. even
	 * though that is 3 requests, it must be seen as a single transaction.
	 * we must not preempt this drive until that is complete
	 */
	if (blk_queue_flushing(q))
Linus Torvalds's avatar
Linus Torvalds committed
716
		/*
717
718
719
		 * small race where queue could get replugged during
		 * the 3-request flush cycle, just yank the plug since
		 * we want it to finish asap
Linus Torvalds's avatar
Linus Torvalds committed
720
		 */
721
		blk_remove_plug(q);
Linus Torvalds's avatar
Linus Torvalds committed
722

723
	spin_unlock_irq(q->queue_lock);
724
725
726
727

	if (ide_lock_host(host, hwif))
		goto plug_device_2;

728
	spin_lock_irq(&hwif->lock);
729

730
	if (!ide_lock_port(hwif)) {
731
		ide_hwif_t *prev_port;
732
repeat:
733
		prev_port = hwif->host->cur_port;
734
		hwif->rq = NULL;
735

736
737
		if (drive->dev_flags & IDE_DFLAG_SLEEPING) {
			if (time_before(drive->sleep, jiffies)) {
738
				ide_unlock_port(hwif);
739
740
741
				goto plug_device;
			}
		}
742

743
744
		if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) &&
		    hwif != prev_port) {
745
			/*
746
			 * set nIEN for previous port, drives in the
747
748
			 * quirk_list may not like intr setups/cleanups
			 */
749
			if (prev_port && prev_port->cur_dev->quirk_list == 0)
750
				prev_port->tp_ops->set_irq(prev_port, 0);
751
752

			hwif->host->cur_port = hwif;
Linus Torvalds's avatar
Linus Torvalds committed
753
		}
754
		hwif->cur_dev = drive;
755
		drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
Linus Torvalds's avatar
Linus Torvalds committed
756

757
		spin_unlock_irq(&hwif->lock);
758
		spin_lock_irq(q->queue_lock);
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
		/*
		 * we know that the queue isn't empty, but this can happen
		 * if the q->prep_rq_fn() decides to kill a request
		 */
		rq = elv_next_request(drive->queue);
764
		spin_unlock_irq(q->queue_lock);
765
		spin_lock_irq(&hwif->lock);
766

Linus Torvalds's avatar
Linus Torvalds committed
767
		if (!rq) {
768
			ide_unlock_port(hwif);
769
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
		}

		/*
		 * Sanity: don't accept a request that isn't a PM request
		 * if we are currently power managed. This is very important as
		 * blk_stop_queue() doesn't prevent the elv_next_request()
		 * above to return us whatever is in the queue. Since we call
		 * ide_do_request() ourselves, we end up taking requests while
		 * the queue is blocked...
		 * 
		 * We let requests forced at head of queue with ide-preempt
		 * though. I hope that doesn't happen too much, hopefully not
		 * unless the subdriver triggers such a thing in its own PM
		 * state machine.
		 */
785
786
787
		if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
		    blk_pm_request(rq) == 0 &&
		    (rq->cmd_flags & REQ_PREEMPT) == 0) {
788
			/* there should be no pending command at this point */
789
			ide_unlock_port(hwif);
790
			goto plug_device;
Linus Torvalds's avatar
Linus Torvalds committed
791
792
		}

793
		hwif->rq = rq;
Linus Torvalds's avatar
Linus Torvalds committed
794

795
		spin_unlock_irq(&hwif->lock);
Linus Torvalds's avatar
Linus Torvalds committed
796
		startstop = start_request(drive, rq);
797
		spin_lock_irq(&hwif->lock);
798

799
800
801
802
803
		if (startstop == ide_stopped)
			goto repeat;
	} else
		goto plug_device;
out:
804
	spin_unlock_irq(&hwif->lock);
805
806
	if (rq == NULL)
		ide_unlock_host(host);
807
	spin_lock_irq(q->queue_lock);
808
	return;
Linus Torvalds's avatar
Linus Torvalds committed
809

810
plug_device:
811
	spin_unlock_irq(&hwif->lock);
812
813
	ide_unlock_host(host);
plug_device_2:
814
815
816
817
	spin_lock_irq(q->queue_lock);

	if (!elv_queue_empty(q))
		blk_plug_device(q);
Linus Torvalds's avatar
Linus Torvalds committed
818
819
820
}

/*
821
 * un-busy the port etc, and clear any pending DMA status. we want to
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825
826
 * retry the current request in pio mode instead of risking tossing it
 * all away
 */
static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
{
827
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
831
832
833
834
835
836
	struct request *rq;
	ide_startstop_t ret = ide_stopped;

	/*
	 * end current dma transaction
	 */

	if (error < 0) {
		printk(KERN_WARNING "%s: DMA timeout error\n", drive->name);
837
		(void)hwif->dma_ops->dma_end(drive);
Linus Torvalds's avatar
Linus Torvalds committed
838
		ret = ide_error(drive, "dma timeout error",
839
				hwif->tp_ops->read_status(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
840
841
	} else {
		printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name);
842
		hwif->dma_ops->dma_timeout(drive);
Linus Torvalds's avatar
Linus Torvalds committed
843
844
845
846
847
848
849
	}

	/*
	 * disable dma for now, but remember that we did so because of
	 * a timeout -- we'll reenable after we finish this next request
	 * (or rather the first chunk of it) in pio.
	 */
850
	drive->dev_flags |= IDE_DFLAG_DMA_PIO_RETRY;
Linus Torvalds's avatar
Linus Torvalds committed
851
	drive->retry_pio++;
852
	ide_dma_off_quietly(drive);
Linus Torvalds's avatar
Linus Torvalds committed
853
854

	/*
855
	 * un-busy drive etc and make sure request is sane
Linus Torvalds's avatar
Linus Torvalds committed
856
	 */
857

858
	rq = hwif->rq;
Hua Zhong's avatar
Hua Zhong committed
859
860
861
	if (!rq)
		goto out;

862
	hwif->rq = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
863
864
865
866
867
868
869
870
871
872
873
874
875
876

	rq->errors = 0;

	if (!rq->bio)
		goto out;

	rq->sector = rq->bio->bi_sector;
	rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9;
	rq->hard_cur_sectors = rq->current_nr_sectors;
	rq->buffer = bio_data(rq->bio);
out:
	return ret;
}

877
878
879
880
881
882
883
884
885
886
887
static void ide_plug_device(ide_drive_t *drive)
{
	struct request_queue *q = drive->queue;
	unsigned long flags;

	spin_lock_irqsave(q->queue_lock, flags);
	if (!elv_queue_empty(q))
		blk_plug_device(q);
	spin_unlock_irqrestore(q->queue_lock, flags);
}

Linus Torvalds's avatar
Linus Torvalds committed
888
889
/**
 *	ide_timer_expiry	-	handle lack of an IDE interrupt
890
 *	@data: timer callback magic (hwif)
Linus Torvalds's avatar
Linus Torvalds committed
891
892
893
894
895
896
897
898
899
900
901
902
903
 *
 *	An IDE command has timed out before the expected drive return
 *	occurred. At this point we attempt to clean up the current
 *	mess. If the current handler includes an expiry handler then
 *	we invoke the expiry handler, and providing it is happy the
 *	work is done. If that fails we apply generic recovery rules
 *	invoking the handler and checking the drive DMA status. We
 *	have an excessively incestuous relationship with the DMA
 *	logic that wants cleaning up.
 */
 
void ide_timer_expiry (unsigned long data)
{
904
	ide_hwif_t	*hwif = (ide_hwif_t *)data;
905
	ide_drive_t	*uninitialized_var(drive);
Linus Torvalds's avatar
Linus Torvalds committed
906
907
908
	ide_handler_t	*handler;
	unsigned long	flags;
	unsigned long	wait = -1;
909
	int		plug_device = 0;
Linus Torvalds's avatar
Linus Torvalds committed
910

911
912
913
	spin_lock_irqsave(&hwif->lock, flags);

	handler = hwif->handler;
Linus Torvalds's avatar
Linus Torvalds committed
914

915
	if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) {
Linus Torvalds's avatar
Linus Torvalds committed
916
917
918
919
920
921
922
		/*
		 * Either a marginal timeout occurred
		 * (got the interrupt just as timer expired),
		 * or we were "sleeping" to give other devices a chance.
		 * Either way, we don't really want to complain about anything.
		 */
	} else {
923
		drive = hwif->cur_dev;
Linus Torvalds's avatar
Linus Torvalds committed
924
		if (!drive) {
925
			printk(KERN_ERR "%s: ->cur_dev was NULL\n", __func__);
926
			hwif->handler = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
927
		} else {
928
			ide_expiry_t *expiry = hwif->expiry;
Linus Torvalds's avatar
Linus Torvalds committed
929
			ide_startstop_t startstop = ide_stopped;
930

931
			if (expiry) {
Linus Torvalds's avatar
Linus Torvalds committed
932
933
934
				/* continue */
				if ((wait = expiry(drive)) > 0) {
					/* reset timer */
935
936
937
938
					hwif->timer.expires  = jiffies + wait;
					hwif->req_gen_timer = hwif->req_gen;
					add_timer(&hwif->timer);
					spin_unlock_irqrestore(&hwif->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
939
940
941
					return;
				}
			}
942
			hwif->handler = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
943
944
945
946
947
			/*
			 * We need to simulate a real interrupt when invoking
			 * the handler() function, which means we need to
			 * globally mask the specific IRQ:
			 */
948
			spin_unlock(&hwif->lock);
949
			hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
950
951
952
953
954
			/* disable_irq_nosync ?? */
			disable_irq(hwif->irq);
			/* local CPU only,
			 * as if we were handling an interrupt */
			local_irq_disable();
955
			if (hwif->polling) {
Linus Torvalds's avatar
Linus Torvalds committed
956
957
958
				startstop = handler(drive);
			} else if (drive_is_ready(drive)) {
				if (drive->waiting_for_dma)
959
					hwif->dma_ops->dma_lost_irq(drive);
Linus Torvalds's avatar
Linus Torvalds committed
960
961
962
963
964
965
966
967
				(void)ide_ack_intr(hwif);
				printk(KERN_WARNING "%s: lost interrupt\n", drive->name);
				startstop = handler(drive);
			} else {
				if (drive->waiting_for_dma) {
					startstop = ide_dma_timeout_retry(drive, wait);
				} else
					startstop =
968
					ide_error(drive, "irq timeout",
969
						  hwif->tp_ops->read_status(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
970
			}
971
			spin_lock_irq(&hwif->lock);
Linus Torvalds's avatar
Linus Torvalds committed
972
			enable_irq(hwif->irq);
973
			if (startstop == ide_stopped) {
974
				ide_unlock_port(hwif);
975
				plug_device = 1;
976
			}
Linus Torvalds's avatar
Linus Torvalds committed
977
978
		}
	}
979
	spin_unlock_irqrestore(&hwif->lock, flags);
980

981
982
	if (plug_device) {
		ide_unlock_host(hwif->host);
983
		ide_plug_device(drive);
984
	}
Linus Torvalds's avatar
Linus Torvalds committed
985
986
987
988
989
}

/**
 *	unexpected_intr		-	handle an unexpected IDE interrupt
 *	@irq: interrupt line
990
 *	@hwif: port being processed
Linus Torvalds's avatar
Linus Torvalds committed
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
 *
 *	There's nothing really useful we can do with an unexpected interrupt,
 *	other than reading the status register (to clear it), and logging it.
 *	There should be no way that an irq can happen before we're ready for it,
 *	so we needn't worry much about losing an "important" interrupt here.
 *
 *	On laptops (and "green" PCs), an unexpected interrupt occurs whenever
 *	the drive enters "idle", "standby", or "sleep" mode, so if the status
 *	looks "good", we just ignore the interrupt completely.
 *
 *	This routine assumes __cli() is in effect when called.
 *
 *	If an unexpected interrupt happens on irq15 while we are handling irq14
 *	and if the two interfaces are "serialized" (CMD640), then it looks like
 *	we could screw up by interfering with a new request being set up for 
 *	irq15.
 *
 *	In reality, this is a non-issue.  The new command is not sent unless 
 *	the drive is ready to accept one, in which case we know the drive is
 *	not trying to interrupt us.  And ide_set_handler() is always invoked
 *	before completing the issuance of any new drive command, so we will not
 *	be accidentally invoked as a result of any valid command completion
 *	interrupt.
 */
1015
1016

static void unexpected_intr(int irq, ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
1017
{
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
	u8 stat = hwif->tp_ops->read_status(hwif);

	if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) {
		/* Try to not flood the console with msgs */
		static unsigned long last_msgtime, count;
		++count;

		if (time_after(jiffies, last_msgtime + HZ)) {
			last_msgtime = jiffies;
			printk(KERN_ERR "%s: unexpected interrupt, "
				"status=0x%02x, count=%ld\n",
				hwif->name, stat, count);
Linus Torvalds's avatar
Linus Torvalds committed
1030
		}
1031
	}
Linus Torvalds's avatar
Linus Torvalds committed
1032
1033
1034
1035
1036
}

/**
 *	ide_intr	-	default IDE interrupt handler
 *	@irq: interrupt number
1037
 *	@dev_id: hwif
Linus Torvalds's avatar
Linus Torvalds committed
1038
1039
1040
1041
1042
1043
 *	@regs: unused weirdness from the kernel irq layer
 *
 *	This is the default IRQ handler for the IDE layer. You should
 *	not need to override it. If you do be aware it is subtle in
 *	places
 *
1044
 *	hwif is the interface in the group currently performing
1045
 *	a command. hwif->cur_dev is the drive and hwif->handler is
Linus Torvalds's avatar
Linus Torvalds committed
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
 *	the IRQ handler to call. As we issue a command the handlers
 *	step through multiple states, reassigning the handler to the
 *	next step in the process. Unlike a smart SCSI controller IDE
 *	expects the main processor to sequence the various transfer
 *	stages. We also manage a poll timer to catch up with most
 *	timeout situations. There are still a few where the handlers
 *	don't ever decide to give up.
 *
 *	The handler eventually returns ide_stopped to indicate the
 *	request completed. At this point we issue the next request
1056
 *	on the port and the process begins again.
Linus Torvalds's avatar
Linus Torvalds committed
1057
 */
1058

1059
irqreturn_t ide_intr (int irq, void *dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
1060
{
1061
	ide_hwif_t *hwif = (ide_hwif_t *)dev_id;
1062
	ide_drive_t *uninitialized_var(drive);
Linus Torvalds's avatar
Linus Torvalds committed
1063
	ide_handler_t *handler;
1064
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1065
	ide_startstop_t startstop;
1066
	irqreturn_t irq_ret = IRQ_NONE;
1067
	int plug_device = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1068

1069
1070
1071
1072
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE) {
		if (hwif != hwif->host->cur_port)
			goto out_early;
	}
1073

1074
	spin_lock_irqsave(&hwif->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1075

1076
1077
	if (!ide_ack_intr(hwif))
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1078

1079
1080
1081
	handler = hwif->handler;

	if (handler == NULL || hwif->polling) {
Linus Torvalds's avatar
Linus Torvalds committed
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
		/*
		 * Not expecting an interrupt from this drive.
		 * That means this could be:
		 *	(1) an interrupt from another PCI device
		 *	sharing the same PCI INT# as us.
		 * or	(2) a drive just entered sleep or standby mode,
		 *	and is interrupting to let us know.
		 * or	(3) a spurious interrupt of unknown origin.
		 *
		 * For PCI, we cannot tell the difference,
		 * so in that case we just ignore it and hope it goes away.
		 *
		 * FIXME: unexpected_intr should be hwif-> then we can
		 * remove all the ifdef PCI crap
		 */
#ifdef CONFIG_BLK_DEV_IDEPCI
1098
		if (hwif->chipset != ide_pci)
Linus Torvalds's avatar
Linus Torvalds committed
1099
1100
1101
1102
1103
1104
#endif	/* CONFIG_BLK_DEV_IDEPCI */
		{
			/*
			 * Probably not a shared PCI interrupt,
			 * so we can safely try to do something about it:
			 */
1105
			unexpected_intr(irq, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
1106
1107
1108
1109
1110
1111
#ifdef CONFIG_BLK_DEV_IDEPCI
		} else {
			/*
			 * Whack the status register, just in case
			 * we have a leftover pending IRQ.
			 */
1112
			(void)hwif->tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
1113
1114
#endif /* CONFIG_BLK_DEV_IDEPCI */
		}
1115
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1116
	}
1117

1118
	drive = hwif->cur_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1119
1120
1121
1122
1123
1124
1125
	if (!drive) {
		/*
		 * This should NEVER happen, and there isn't much
		 * we could do about it here.
		 *
		 * [Note - this can occur if the drive is hot unplugged]
		 */
1126
		goto out_handled;
Linus Torvalds's avatar
Linus Torvalds committed
1127
	}
1128
1129

	if (!drive_is_ready(drive))
Linus Torvalds's avatar
Linus Torvalds committed
1130
1131
1132
1133
1134
1135
1136
		/*
		 * This happens regularly when we share a PCI IRQ with
		 * another device.  Unfortunately, it can also happen
		 * with some buggy drives that trigger the IRQ before
		 * their status register is up to date.  Hopefully we have
		 * enough advance overhead that the latter isn't a problem.
		 */
1137
1138
		goto out;

1139
1140
1141
1142
	hwif->handler = NULL;
	hwif->req_gen++;
	del_timer(&hwif->timer);
	spin_unlock(&hwif->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1143

1144
1145
	if (hwif->port_ops && hwif->port_ops->clear_irq)
		hwif->port_ops->clear_irq(drive);
1146

1147
	if (drive->dev_flags & IDE_DFLAG_UNMASK)
1148
		local_irq_enable_in_hardirq();
1149

Linus Torvalds's avatar
Linus Torvalds committed
1150
1151
1152
	/* service this interrupt, may set handler for next interrupt */
	startstop = handler(drive);

1153
	spin_lock_irq(&hwif->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1154
1155
1156
1157
1158
1159
1160
1161
	/*
	 * Note that handler() may have set things up for another
	 * interrupt to occur soon, but it cannot happen until
	 * we exit from this routine, because it will be the
	 * same irq as is currently being serviced here, and Linux
	 * won't allow another of the same (on any CPU) until we return.
	 */
	if (startstop == ide_stopped) {
1162
		if (hwif->handler == NULL) {	/* paranoia */
1163
			ide_unlock_port(hwif);
1164
			plug_device = 1;
1165
1166
1167
		} else
			printk(KERN_ERR "%s: %s: huh? expected NULL handler "
					"on exit\n", __func__, drive->name);
Linus Torvalds's avatar
Linus Torvalds committed
1168
	}
1169
1170
1171
out_handled:
	irq_ret = IRQ_HANDLED;
out:
1172
	spin_unlock_irqrestore(&hwif->lock, flags);
1173
out_early:
1174
1175
	if (plug_device) {
		ide_unlock_host(hwif->host);
1176
		ide_plug_device(drive);
1177
	}
1178

1179
	return irq_ret;
Linus Torvalds's avatar
Linus Torvalds committed
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
}

/**
 *	ide_do_drive_cmd	-	issue IDE special command
 *	@drive: device to issue command
 *	@rq: request to issue
 *
 *	This function issues a special IDE device request
 *	onto the request queue.
 *
1190
1191
1192
1193
1194
 *	the rq is queued at the head of the request queue, displacing
 *	the currently-being-processed request and this function
 *	returns immediately without waiting for the new rq to be
 *	completed.  This is VERY DANGEROUS, and is intended for
 *	careful use by the ATAPI tape/cdrom driver code.
Linus Torvalds's avatar
Linus Torvalds committed
1195
 */
1196
1197

void ide_do_drive_cmd(ide_drive_t *drive, struct request