2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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>
|
|
|
|
#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>
|
2007-10-19 13:40:25 +07:00
|
|
|
#include <linux/bitops.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
2009-03-27 18:46:43 +07:00
|
|
|
int ide_end_rq(ide_drive_t *drive, struct request *rq, int error,
|
2009-03-27 18:46:42 +07:00
|
|
|
unsigned int nr_bytes)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* decide whether to reenable DMA -- 3 is a random magic for now,
|
|
|
|
* if we DMA timeout more than 3 times, just stay in PIO
|
|
|
|
*/
|
2008-10-14 02:39:37 +07:00
|
|
|
if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) &&
|
|
|
|
drive->retry_pio <= 3) {
|
|
|
|
drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY;
|
2008-01-27 02:13:01 +07:00
|
|
|
ide_dma_on(drive);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-03-27 18:46:42 +07:00
|
|
|
return blk_end_request(rq, error, nr_bytes);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-03-27 18:46:42 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ide_end_rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-27 18:46:37 +07:00
|
|
|
void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
|
2009-03-27 18:46:29 +07:00
|
|
|
{
|
2009-04-01 01:15:31 +07:00
|
|
|
const struct ide_tp_ops *tp_ops = drive->hwif->tp_ops;
|
2009-03-27 18:46:37 +07:00
|
|
|
struct ide_taskfile *tf = &cmd->tf;
|
|
|
|
struct request *rq = cmd->rq;
|
2009-03-27 18:46:41 +07:00
|
|
|
u8 tf_cmd = tf->command;
|
2009-03-27 18:46:29 +07:00
|
|
|
|
|
|
|
tf->error = err;
|
|
|
|
tf->status = stat;
|
|
|
|
|
2009-04-01 01:15:31 +07:00
|
|
|
if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) {
|
|
|
|
u8 data[2];
|
|
|
|
|
|
|
|
tp_ops->input_data(drive, cmd, data, 2);
|
|
|
|
|
2009-04-08 19:13:02 +07:00
|
|
|
cmd->tf.data = data[0];
|
|
|
|
cmd->hob.data = data[1];
|
2009-04-01 01:15:31 +07:00
|
|
|
}
|
|
|
|
|
2009-04-08 19:13:03 +07:00
|
|
|
ide_tf_readback(drive, cmd);
|
2009-03-27 18:46:29 +07:00
|
|
|
|
2009-03-27 18:46:41 +07:00
|
|
|
if ((cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) &&
|
|
|
|
tf_cmd == ATA_CMD_IDLEIMMEDIATE) {
|
|
|
|
if (tf->lbal != 0xc4) {
|
|
|
|
printk(KERN_ERR "%s: head unload failed!\n",
|
|
|
|
drive->name);
|
2009-04-08 19:13:02 +07:00
|
|
|
ide_tf_dump(drive->name, cmd);
|
2009-03-27 18:46:41 +07:00
|
|
|
} else
|
|
|
|
drive->dev_flags |= IDE_DFLAG_PARKED;
|
|
|
|
}
|
|
|
|
|
2009-04-18 22:42:20 +07:00
|
|
|
if (rq && rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
|
|
|
|
struct ide_cmd *orig_cmd = rq->special;
|
2009-03-27 18:46:31 +07:00
|
|
|
|
2009-04-18 22:42:20 +07:00
|
|
|
if (cmd->tf_flags & IDE_TFLAG_DYN)
|
|
|
|
kfree(orig_cmd);
|
|
|
|
else
|
|
|
|
memcpy(orig_cmd, cmd, sizeof(*cmd));
|
|
|
|
}
|
2009-03-27 18:46:29 +07:00
|
|
|
}
|
|
|
|
|
2009-03-27 18:46:44 +07:00
|
|
|
int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-01-06 23:20:50 +07:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
|
|
|
struct request *rq = hwif->rq;
|
2009-03-27 18:46:44 +07:00
|
|
|
int rc;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-27 18:46:45 +07:00
|
|
|
/*
|
|
|
|
* if failfast is set on a request, override number of sectors
|
|
|
|
* and complete the whole request right now
|
|
|
|
*/
|
|
|
|
if (blk_noretry_request(rq) && error <= 0)
|
2009-05-07 20:24:38 +07:00
|
|
|
nr_bytes = blk_rq_sectors(rq) << 9;
|
2009-03-27 18:46:45 +07:00
|
|
|
|
2009-03-27 18:46:44 +07:00
|
|
|
rc = ide_end_rq(drive, rq, error, nr_bytes);
|
2009-03-27 18:46:44 +07:00
|
|
|
if (rc == 0)
|
|
|
|
hwif->rq = NULL;
|
2008-12-30 02:27:30 +07:00
|
|
|
|
2009-03-27 18:46:44 +07:00
|
|
|
return rc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-03-27 18:46:31 +07:00
|
|
|
EXPORT_SYMBOL(ide_complete_rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-25 05:22:47 +07:00
|
|
|
void ide_kill_rq(ide_drive_t *drive, struct request *rq)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2015-04-18 03:37:16 +07:00
|
|
|
u8 drv_req = (rq->cmd_type == REQ_TYPE_DRV_PRIV) && rq->rq_disk;
|
2009-03-27 18:46:36 +07:00
|
|
|
u8 media = drive->media;
|
|
|
|
|
2009-03-27 18:46:34 +07:00
|
|
|
drive->failed_pc = NULL;
|
|
|
|
|
2009-03-27 18:46:43 +07:00
|
|
|
if ((media == ide_floppy || media == ide_tape) && drv_req) {
|
|
|
|
rq->errors = 0;
|
|
|
|
} else {
|
|
|
|
if (media == ide_tape)
|
|
|
|
rq->errors = IDE_DRV_ERROR_GENERAL;
|
2010-08-07 23:17:56 +07:00
|
|
|
else if (rq->cmd_type != REQ_TYPE_FS && rq->errors == 0)
|
2009-03-27 18:46:43 +07:00
|
|
|
rq->errors = -EIO;
|
2009-03-27 18:46:43 +07:00
|
|
|
}
|
2009-06-23 18:27:27 +07:00
|
|
|
|
|
|
|
ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 04:17:16 +07:00
|
|
|
static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-01-26 04:17:16 +07:00
|
|
|
tf->nsect = drive->sect;
|
|
|
|
tf->lbal = drive->sect;
|
|
|
|
tf->lbam = drive->cyl;
|
|
|
|
tf->lbah = drive->cyl >> 8;
|
2008-10-14 02:39:40 +07:00
|
|
|
tf->device = (drive->head - 1) | drive->select;
|
2008-10-11 03:39:21 +07:00
|
|
|
tf->command = ATA_CMD_INIT_DEV_PARAMS;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 04:17:16 +07:00
|
|
|
static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-01-26 04:17:16 +07:00
|
|
|
tf->nsect = drive->sect;
|
2008-10-11 03:39:21 +07:00
|
|
|
tf->command = ATA_CMD_RESTORE;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 04:17:16 +07:00
|
|
|
static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-01-26 04:17:16 +07:00
|
|
|
tf->nsect = drive->mult_req;
|
2008-10-11 03:39:21 +07:00
|
|
|
tf->command = ATA_CMD_SET_MULTI;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-05-18 00:12:18 +07:00
|
|
|
/**
|
|
|
|
* do_special - issue some special commands
|
|
|
|
* @drive: drive the command is for
|
|
|
|
*
|
|
|
|
* do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS,
|
|
|
|
* ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static ide_startstop_t do_special(ide_drive_t *drive)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-03-27 18:46:37 +07:00
|
|
|
struct ide_cmd cmd;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-05-18 00:12:18 +07:00
|
|
|
#ifdef DEBUG
|
2009-05-18 00:12:21 +07:00
|
|
|
printk(KERN_DEBUG "%s: %s: 0x%02x\n", drive->name, __func__,
|
|
|
|
drive->special_flags);
|
2009-05-18 00:12:18 +07:00
|
|
|
#endif
|
|
|
|
if (drive->media != ide_disk) {
|
2009-05-18 00:12:21 +07:00
|
|
|
drive->special_flags = 0;
|
2009-05-18 00:12:18 +07:00
|
|
|
drive->mult_req = 0;
|
|
|
|
return ide_stopped;
|
|
|
|
}
|
|
|
|
|
2009-03-27 18:46:37 +07:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
2009-03-27 18:46:39 +07:00
|
|
|
cmd.protocol = ATA_PROT_NODATA;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-05-18 00:12:21 +07:00
|
|
|
if (drive->special_flags & IDE_SFLAG_SET_GEOMETRY) {
|
|
|
|
drive->special_flags &= ~IDE_SFLAG_SET_GEOMETRY;
|
2009-03-27 18:46:37 +07:00
|
|
|
ide_tf_set_specify_cmd(drive, &cmd.tf);
|
2009-05-18 00:12:21 +07:00
|
|
|
} else if (drive->special_flags & IDE_SFLAG_RECALIBRATE) {
|
|
|
|
drive->special_flags &= ~IDE_SFLAG_RECALIBRATE;
|
2009-03-27 18:46:37 +07:00
|
|
|
ide_tf_set_restore_cmd(drive, &cmd.tf);
|
2009-05-18 00:12:21 +07:00
|
|
|
} else if (drive->special_flags & IDE_SFLAG_SET_MULTMODE) {
|
|
|
|
drive->special_flags &= ~IDE_SFLAG_SET_MULTMODE;
|
2009-03-27 18:46:37 +07:00
|
|
|
ide_tf_set_setmult_cmd(drive, &cmd.tf);
|
2009-05-18 00:12:18 +07:00
|
|
|
} else
|
|
|
|
BUG();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-08 19:13:01 +07:00
|
|
|
cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
|
|
|
|
cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE;
|
|
|
|
cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER;
|
2008-01-26 04:17:07 +07:00
|
|
|
|
2009-03-27 18:46:37 +07:00
|
|
|
do_rw_taskfile(drive, &cmd);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return ide_started;
|
|
|
|
}
|
|
|
|
|
2009-03-27 18:46:46 +07:00
|
|
|
void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
|
|
|
struct scatterlist *sg = hwif->sg_table;
|
2009-03-27 18:46:46 +07:00
|
|
|
struct request *rq = cmd->rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-19 06:46:03 +07:00
|
|
|
cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_map_sg);
|
|
|
|
|
2009-03-27 18:46:47 +07:00
|
|
|
void ide_init_sg_cmd(struct ide_cmd *cmd, unsigned int nr_bytes)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-03-27 18:46:47 +07:00
|
|
|
cmd->nbytes = cmd->nleft = nr_bytes;
|
2009-03-27 18:46:38 +07:00
|
|
|
cmd->cursg_ofs = 0;
|
|
|
|
cmd->cursg = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_init_sg_cmd);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* execute_drive_command - issue special drive command
|
2005-09-10 14:26:54 +07:00
|
|
|
* @drive: the drive to issue the command on
|
2005-04-17 05:20:36 +07:00
|
|
|
* @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)
|
|
|
|
{
|
2009-03-27 18:46:37 +07:00
|
|
|
struct ide_cmd *cmd = rq->special;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-27 18:46:37 +07:00
|
|
|
if (cmd) {
|
2009-03-27 18:46:39 +07:00
|
|
|
if (cmd->protocol == ATA_PROT_PIO) {
|
2009-05-07 20:24:40 +07:00
|
|
|
ide_init_sg_cmd(cmd, blk_rq_sectors(rq) << 9);
|
2009-03-27 18:46:46 +07:00
|
|
|
ide_map_sg(drive, cmd);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-01-26 04:17:07 +07:00
|
|
|
|
2009-03-27 18:46:37 +07:00
|
|
|
return do_rw_taskfile(drive, cmd);
|
2008-01-26 04:17:09 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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
|
2009-03-27 18:46:43 +07:00
|
|
|
rq->errors = 0;
|
2009-03-27 18:46:44 +07:00
|
|
|
ide_complete_rq(drive, 0, blk_rq_bytes(rq));
|
2008-02-06 08:57:51 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return ide_stopped;
|
2009-03-25 05:22:44 +07:00
|
|
|
}
|
|
|
|
|
2008-07-17 01:33:48 +07:00
|
|
|
static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
|
|
|
|
{
|
2008-10-14 02:39:50 +07:00
|
|
|
u8 cmd = rq->cmd[0];
|
|
|
|
|
|
|
|
switch (cmd) {
|
2009-03-25 05:22:44 +07:00
|
|
|
case REQ_PARK_HEADS:
|
|
|
|
case REQ_UNPARK_HEADS:
|
|
|
|
return ide_do_park_unpark(drive, rq);
|
2008-10-11 03:39:40 +07:00
|
|
|
case REQ_DEVSET_EXEC:
|
2009-03-25 05:22:44 +07:00
|
|
|
return ide_do_devset(drive, rq);
|
2008-07-17 01:33:48 +07:00
|
|
|
case REQ_DRIVE_RESET:
|
|
|
|
return ide_do_reset(drive);
|
|
|
|
default:
|
2009-03-27 18:46:42 +07:00
|
|
|
BUG();
|
2008-07-17 01:33:48 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* start_request - start of I/O and command issuing for IDE
|
|
|
|
*
|
|
|
|
* start_request() initiates handling of a new I/O request. It
|
2008-10-11 03:39:22 +07:00
|
|
|
* accepts commands and I/O (read/write) requests.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* FIXME: this function needs a rename
|
|
|
|
*/
|
|
|
|
|
|
|
|
static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
|
|
|
|
{
|
|
|
|
ide_startstop_t startstop;
|
|
|
|
|
2010-08-07 23:17:56 +07:00
|
|
|
BUG_ON(!(rq->cmd_flags & REQ_STARTED));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
printk("%s: start_request: current=0x%08lx\n",
|
2009-01-06 23:20:52 +07:00
|
|
|
drive->hwif->name, (unsigned long) rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* bail early if we've exceeded max_failures */
|
|
|
|
if (drive->max_failures && (drive->failures > drive->max_failures)) {
|
ide-io: set REQ_FAILED when drive is dead
Currently it's possible to ide-cd to set an incorrect blocksize by
reading garbage if the drive is dead:
ide_cd_probe()
-> cdrom_read_toc()
-> cdrom_read_capacity()
-> cdrom_queue_packet_command()
-> ide_do_drive_cmd()
-> ide_do_request()
-> start_request()
on start_request():
/* bail early if we've exceeded max_failures */
if (drive->max_failures && (drive->failures > drive->max_failures)) {
goto kill_rq;
}
(...)
kill_rq:
ide_kill_rq(drive, rq);
return ide_stopped;
ide_kill_rq() and the next calls won't set REQ_FAILED on rq->cmd_flags and thus
cdrom_queue_packet_command() won't return an error. then:
stat = cdrom_queue_packet_command(drive, &req);
if (stat == 0) {
*capacity = 1 + be32_to_cpu(capbuf.lba);
*sectors_per_frame =
be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
}
cdrom_read_capacity() ends believing capbuf is valid but in fact it's just
uninitialized data. back to cdrom_read_toc():
/* Try to get the total cdrom capacity and sector size. */
stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
sense);
if (stat)
toc->capacity = 0x1fffff;
set_capacity(info->disk, toc->capacity * sectors_per_frame);
/* Save a private copy of te TOC capacity for error handling */
drive->probed_capacity = toc->capacity * sectors_per_frame;
blk_queue_hardsect_size(drive->queue,
sectors_per_frame << SECTOR_BITS);
that will set drive->queue->hardsect_size to be the random value.
hardsect_size is used to calculate inode->i_blkbits. later on, on a read
path:
void create_empty_buffers(struct page *page,
unsigned long blocksize, unsigned long b_state)
{
struct buffer_head *bh, *head, *tail;
head = alloc_page_buffers(page, blocksize, 1);
bh = head;
do {
bh->b_state |= b_state;
tail = bh;
bh = bh->b_this_page;
} while (bh);
tail->b_this_page = head;
alloc_page_buffers() will return NULL if blocksize > 4096. blocksize is
calculed based on inode->i_blkbits. that will trigger a null
dereference on create_empty_buffers().
Signed-off-by: Aristeu Rozanski <arozansk@redhat.com>
Cc: Borislav Petkov <bbpetkov@yahoo.de>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-01-26 04:17:04 +07:00
|
|
|
rq->cmd_flags |= REQ_FAILED;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto kill_rq;
|
|
|
|
}
|
|
|
|
|
2015-04-18 03:37:20 +07:00
|
|
|
if (ata_pm_request(rq))
|
2006-06-13 13:46:57 +07:00
|
|
|
ide_check_pm_state(drive, rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-01 01:15:33 +07:00
|
|
|
drive->hwif->tp_ops->dev_select(drive);
|
2008-10-11 03:39:21 +07:00
|
|
|
if (ide_wait_stat(&startstop, drive, drive->ready_stat,
|
|
|
|
ATA_BUSY | ATA_DRQ, WAIT_READY)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
printk(KERN_ERR "%s: drive not ready for command\n", drive->name);
|
|
|
|
return startstop;
|
|
|
|
}
|
2009-05-18 00:12:21 +07:00
|
|
|
|
|
|
|
if (drive->special_flags == 0) {
|
2009-01-06 23:20:53 +07:00
|
|
|
struct ide_driver *drv;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-03-27 04:03:20 +07:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2008-01-27 02:13:13 +07:00
|
|
|
if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
|
2005-04-17 05:20:36 +07:00
|
|
|
return execute_drive_cmd(drive, rq);
|
2015-04-18 03:37:20 +07:00
|
|
|
else if (ata_pm_request(rq)) {
|
|
|
|
struct ide_pm_state *pm = rq->special;
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef DEBUG_PM
|
|
|
|
printk("%s: start_power_step(step: %d)\n",
|
2008-12-03 02:40:03 +07:00
|
|
|
drive->name, pm->pm_step);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
startstop = ide_start_power_step(drive, rq);
|
|
|
|
if (startstop == ide_stopped &&
|
2008-10-14 02:39:38 +07:00
|
|
|
pm->pm_step == IDE_PM_COMPLETED)
|
2009-03-27 18:46:29 +07:00
|
|
|
ide_complete_pm_rq(drive, rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
return startstop;
|
2015-04-18 03:37:16 +07:00
|
|
|
} else if (!rq->rq_disk && rq->cmd_type == REQ_TYPE_DRV_PRIV)
|
2008-07-17 01:33:48 +07:00
|
|
|
/*
|
|
|
|
* 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);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:53 +07:00
|
|
|
drv = *(struct ide_driver **)rq->rq_disk->private_data;
|
2008-10-11 03:39:22 +07:00
|
|
|
|
2009-05-07 20:24:40 +07:00
|
|
|
return drv->do_request(drive, rq, blk_rq_pos(rq));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
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
|
2009-01-06 23:20:50 +07:00
|
|
|
* to the port by sleeping for timeout jiffies.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
|
|
|
|
{
|
|
|
|
if (timeout > WAIT_WORSTCASE)
|
|
|
|
timeout = WAIT_WORSTCASE;
|
|
|
|
drive->sleep = timeout + jiffies;
|
2008-10-14 02:39:36 +07:00
|
|
|
drive->dev_flags |= IDE_DFLAG_SLEEPING;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ide_stall_queue);
|
|
|
|
|
2009-01-06 23:20:49 +07:00
|
|
|
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) {
|
2009-03-27 18:46:22 +07:00
|
|
|
if (host->get_lock)
|
|
|
|
host->get_lock(ide_intr, hwif);
|
2009-01-06 23:20:49 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ide_unlock_host(struct ide_host *host)
|
|
|
|
{
|
|
|
|
if (host->host_flags & IDE_HFLAG_SERIALIZE) {
|
2009-03-27 18:46:22 +07:00
|
|
|
if (host->release_lock)
|
|
|
|
host->release_lock();
|
2009-01-06 23:20:49 +07:00
|
|
|
clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-05 08:29:57 +07:00
|
|
|
static void __ide_requeue_and_plug(struct request_queue *q, struct request *rq)
|
|
|
|
{
|
|
|
|
if (rq)
|
|
|
|
blk_requeue_request(q, rq);
|
|
|
|
if (rq || blk_peek_request(q)) {
|
|
|
|
/* Use 3ms as that was the old plug delay */
|
|
|
|
blk_delay_queue(q, 3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq)
|
|
|
|
{
|
|
|
|
struct request_queue *q = drive->queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
__ide_requeue_and_plug(q, rq);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2009-01-06 23:20:50 +07:00
|
|
|
* Issue a new request to a device.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-01-02 22:12:48 +07:00
|
|
|
void do_ide_request(struct request_queue *q)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-01-02 22:12:50 +07:00
|
|
|
ide_drive_t *drive = q->queuedata;
|
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2009-01-06 23:20:49 +07:00
|
|
|
struct ide_host *host = hwif->host;
|
|
|
|
struct request *rq = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
ide_startstop_t startstop;
|
2011-03-27 01:49:54 +07:00
|
|
|
unsigned long queue_run_ms = 3; /* old plug delay */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-02 22:12:50 +07:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
2009-01-06 23:20:49 +07:00
|
|
|
|
2009-04-19 05:00:42 +07:00
|
|
|
/* HLD do_request() callback might sleep, make sure it's okay */
|
|
|
|
might_sleep();
|
|
|
|
|
2009-01-06 23:20:49 +07:00
|
|
|
if (ide_lock_host(host, hwif))
|
|
|
|
goto plug_device_2;
|
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_lock_irq(&hwif->lock);
|
2009-01-02 22:12:48 +07:00
|
|
|
|
2009-01-06 23:20:49 +07:00
|
|
|
if (!ide_lock_port(hwif)) {
|
2009-01-06 23:20:47 +07:00
|
|
|
ide_hwif_t *prev_port;
|
2009-07-07 02:39:27 +07:00
|
|
|
|
|
|
|
WARN_ON_ONCE(hwif->rq);
|
2009-01-02 22:12:50 +07:00
|
|
|
repeat:
|
2009-01-06 23:20:48 +07:00
|
|
|
prev_port = hwif->host->cur_port;
|
2009-04-01 01:14:56 +07:00
|
|
|
if (drive->dev_flags & IDE_DFLAG_SLEEPING &&
|
|
|
|
time_after(drive->sleep, jiffies)) {
|
2011-03-27 01:49:54 +07:00
|
|
|
unsigned long left = jiffies - drive->sleep;
|
|
|
|
|
|
|
|
queue_run_ms = jiffies_to_msecs(left + 1);
|
2009-04-01 01:14:56 +07:00
|
|
|
ide_unlock_port(hwif);
|
|
|
|
goto plug_device;
|
2009-01-02 22:12:50 +07:00
|
|
|
}
|
2009-01-02 22:12:48 +07:00
|
|
|
|
2009-01-06 23:20:48 +07:00
|
|
|
if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) &&
|
|
|
|
hwif != prev_port) {
|
2009-06-07 20:37:10 +07:00
|
|
|
ide_drive_t *cur_dev =
|
|
|
|
prev_port ? prev_port->cur_dev : NULL;
|
|
|
|
|
2008-01-26 04:17:14 +07:00
|
|
|
/*
|
2009-01-06 23:20:47 +07:00
|
|
|
* set nIEN for previous port, drives in the
|
2009-06-07 20:37:10 +07:00
|
|
|
* quirk list may not like intr setups/cleanups
|
2008-01-26 04:17:14 +07:00
|
|
|
*/
|
2009-06-07 20:37:10 +07:00
|
|
|
if (cur_dev &&
|
|
|
|
(cur_dev->dev_flags & IDE_DFLAG_NIEN_QUIRK) == 0)
|
2009-04-01 01:15:30 +07:00
|
|
|
prev_port->tp_ops->write_devctl(prev_port,
|
|
|
|
ATA_NIEN |
|
|
|
|
ATA_DEVCTL_OBS);
|
2009-01-06 23:20:48 +07:00
|
|
|
|
|
|
|
hwif->host->cur_port = hwif;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-01-06 23:20:50 +07:00
|
|
|
hwif->cur_dev = drive;
|
2008-10-14 02:39:50 +07:00
|
|
|
drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-07-07 02:39:27 +07:00
|
|
|
spin_unlock_irq(&hwif->lock);
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
/*
|
|
|
|
* we know that the queue isn't empty, but this can happen
|
|
|
|
* if the q->prep_rq_fn() decides to kill a request
|
|
|
|
*/
|
|
|
|
if (!rq)
|
2009-05-08 09:54:16 +07:00
|
|
|
rq = blk_fetch_request(drive->queue);
|
2009-05-08 09:53:59 +07:00
|
|
|
|
2009-07-07 02:39:27 +07:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
spin_lock_irq(&hwif->lock);
|
|
|
|
|
|
|
|
if (!rq) {
|
|
|
|
ide_unlock_port(hwif);
|
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sanity: don't accept a request that isn't a PM request
|
2009-07-07 02:39:27 +07:00
|
|
|
* if we are currently power managed. This is very important as
|
|
|
|
* blk_stop_queue() doesn't prevent the blk_fetch_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.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-07-07 02:39:27 +07:00
|
|
|
if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
|
2015-04-18 03:37:20 +07:00
|
|
|
ata_pm_request(rq) == 0 &&
|
2009-07-07 02:39:27 +07:00
|
|
|
(rq->cmd_flags & REQ_PREEMPT) == 0) {
|
|
|
|
/* there should be no pending command at this point */
|
|
|
|
ide_unlock_port(hwif);
|
|
|
|
goto plug_device;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
hwif->rq = rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_unlock_irq(&hwif->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
startstop = start_request(drive, rq);
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_lock_irq(&hwif->lock);
|
2009-01-02 22:12:48 +07:00
|
|
|
|
2009-05-08 09:53:59 +07:00
|
|
|
if (startstop == ide_stopped) {
|
|
|
|
rq = hwif->rq;
|
|
|
|
hwif->rq = NULL;
|
2009-01-02 22:12:50 +07:00
|
|
|
goto repeat;
|
2009-05-08 09:53:59 +07:00
|
|
|
}
|
2009-01-02 22:12:50 +07:00
|
|
|
} else
|
|
|
|
goto plug_device;
|
|
|
|
out:
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_unlock_irq(&hwif->lock);
|
2009-01-06 23:20:49 +07:00
|
|
|
if (rq == NULL)
|
|
|
|
ide_unlock_host(host);
|
2009-01-02 22:12:50 +07:00
|
|
|
spin_lock_irq(q->queue_lock);
|
2009-01-02 22:12:48 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-02 22:12:48 +07:00
|
|
|
plug_device:
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_unlock_irq(&hwif->lock);
|
2009-01-06 23:20:49 +07:00
|
|
|
ide_unlock_host(host);
|
|
|
|
plug_device_2:
|
2009-01-02 22:12:50 +07:00
|
|
|
spin_lock_irq(q->queue_lock);
|
2011-04-05 08:29:57 +07:00
|
|
|
__ide_requeue_and_plug(q, rq);
|
2009-01-02 22:12:50 +07:00
|
|
|
}
|
|
|
|
|
2009-03-25 05:22:43 +07:00
|
|
|
static int drive_is_ready(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
|
|
|
u8 stat = 0;
|
|
|
|
|
|
|
|
if (drive->waiting_for_dma)
|
|
|
|
return hwif->dma_ops->dma_test_irq(drive);
|
|
|
|
|
|
|
|
if (hwif->io_ports.ctl_addr &&
|
|
|
|
(hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0)
|
|
|
|
stat = hwif->tp_ops->read_altstatus(hwif);
|
|
|
|
else
|
|
|
|
/* Note: this may clear a pending IRQ!! */
|
|
|
|
stat = hwif->tp_ops->read_status(hwif);
|
|
|
|
|
|
|
|
if (stat & ATA_BUSY)
|
|
|
|
/* drive busy: definitely not interrupting */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* drive ready: *might* be interrupting */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* ide_timer_expiry - handle lack of an IDE interrupt
|
2009-01-06 23:20:50 +07:00
|
|
|
* @data: timer callback magic (hwif)
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* 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)
|
|
|
|
{
|
2009-01-06 23:20:50 +07:00
|
|
|
ide_hwif_t *hwif = (ide_hwif_t *)data;
|
2009-01-02 22:12:50 +07:00
|
|
|
ide_drive_t *uninitialized_var(drive);
|
2005-04-17 05:20:36 +07:00
|
|
|
ide_handler_t *handler;
|
|
|
|
unsigned long flags;
|
2009-03-05 22:10:55 +07:00
|
|
|
int wait = -1;
|
2009-01-02 22:12:50 +07:00
|
|
|
int plug_device = 0;
|
2009-05-08 09:53:59 +07:00
|
|
|
struct request *uninitialized_var(rq_in_flight);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_lock_irqsave(&hwif->lock, flags);
|
|
|
|
|
|
|
|
handler = hwif->handler;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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 {
|
2009-01-06 23:20:59 +07:00
|
|
|
ide_expiry_t *expiry = hwif->expiry;
|
|
|
|
ide_startstop_t startstop = ide_stopped;
|
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
drive = hwif->cur_dev;
|
2009-01-06 23:20:59 +07:00
|
|
|
|
|
|
|
if (expiry) {
|
|
|
|
wait = expiry(drive);
|
|
|
|
if (wait > 0) { /* continue */
|
|
|
|
/* reset timer */
|
|
|
|
hwif->timer.expires = jiffies + wait;
|
|
|
|
hwif->req_gen_timer = hwif->req_gen;
|
|
|
|
add_timer(&hwif->timer);
|
|
|
|
spin_unlock_irqrestore(&hwif->lock, flags);
|
|
|
|
return;
|
2009-01-02 22:12:48 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-01-06 23:20:59 +07:00
|
|
|
hwif->handler = NULL;
|
2009-03-27 18:46:46 +07:00
|
|
|
hwif->expiry = NULL;
|
2009-01-06 23:20:59 +07:00
|
|
|
/*
|
|
|
|
* We need to simulate a real interrupt when invoking
|
|
|
|
* the handler() function, which means we need to
|
|
|
|
* globally mask the specific IRQ:
|
|
|
|
*/
|
|
|
|
spin_unlock(&hwif->lock);
|
|
|
|
/* disable_irq_nosync ?? */
|
|
|
|
disable_irq(hwif->irq);
|
|
|
|
/* local CPU only, as if we were handling an interrupt */
|
|
|
|
local_irq_disable();
|
|
|
|
if (hwif->polling) {
|
|
|
|
startstop = handler(drive);
|
|
|
|
} else if (drive_is_ready(drive)) {
|
|
|
|
if (drive->waiting_for_dma)
|
|
|
|
hwif->dma_ops->dma_lost_irq(drive);
|
2009-06-15 23:52:55 +07:00
|
|
|
if (hwif->port_ops && hwif->port_ops->clear_irq)
|
|
|
|
hwif->port_ops->clear_irq(drive);
|
|
|
|
|
2009-01-06 23:20:59 +07:00
|
|
|
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 = ide_error(drive, "irq timeout",
|
|
|
|
hwif->tp_ops->read_status(hwif));
|
|
|
|
}
|
|
|
|
spin_lock_irq(&hwif->lock);
|
|
|
|
enable_irq(hwif->irq);
|
2009-05-22 21:23:37 +07:00
|
|
|
if (startstop == ide_stopped && hwif->polling == 0) {
|
2009-05-08 09:53:59 +07:00
|
|
|
rq_in_flight = hwif->rq;
|
|
|
|
hwif->rq = NULL;
|
2009-01-06 23:20:59 +07:00
|
|
|
ide_unlock_port(hwif);
|
|
|
|
plug_device = 1;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_unlock_irqrestore(&hwif->lock, flags);
|
2009-01-02 22:12:50 +07:00
|
|
|
|
2009-01-06 23:20:49 +07:00
|
|
|
if (plug_device) {
|
|
|
|
ide_unlock_host(hwif->host);
|
2009-05-08 09:53:59 +07:00
|
|
|
ide_requeue_and_plug(drive, rq_in_flight);
|
2009-01-06 23:20:49 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* unexpected_intr - handle an unexpected IDE interrupt
|
|
|
|
* @irq: interrupt line
|
2009-01-06 23:20:48 +07:00
|
|
|
* @hwif: port being processed
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-01-06 23:20:48 +07:00
|
|
|
|
|
|
|
static void unexpected_intr(int irq, ide_hwif_t *hwif)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-01-06 23:20:48 +07:00
|
|
|
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);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-01-06 23:20:48 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ide_intr - default IDE interrupt handler
|
|
|
|
* @irq: interrupt number
|
2009-01-06 23:20:48 +07:00
|
|
|
* @dev_id: hwif
|
2005-04-17 05:20:36 +07:00
|
|
|
* @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
|
|
|
|
*
|
2009-01-06 23:20:48 +07:00
|
|
|
* hwif is the interface in the group currently performing
|
2009-01-06 23:20:50 +07:00
|
|
|
* a command. hwif->cur_dev is the drive and hwif->handler is
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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
|
2009-01-06 23:20:50 +07:00
|
|
|
* on the port and the process begins again.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-01-06 23:20:50 +07:00
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
irqreturn_t ide_intr (int irq, void *dev_id)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-01-06 23:20:48 +07:00
|
|
|
ide_hwif_t *hwif = (ide_hwif_t *)dev_id;
|
2009-03-27 18:46:27 +07:00
|
|
|
struct ide_host *host = hwif->host;
|
2009-01-02 22:12:50 +07:00
|
|
|
ide_drive_t *uninitialized_var(drive);
|
2005-04-17 05:20:36 +07:00
|
|
|
ide_handler_t *handler;
|
2009-01-06 23:20:48 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
ide_startstop_t startstop;
|
2008-12-30 02:27:29 +07:00
|
|
|
irqreturn_t irq_ret = IRQ_NONE;
|
2009-01-02 22:12:50 +07:00
|
|
|
int plug_device = 0;
|
2009-05-08 09:53:59 +07:00
|
|
|
struct request *uninitialized_var(rq_in_flight);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-27 18:46:27 +07:00
|
|
|
if (host->host_flags & IDE_HFLAG_SERIALIZE) {
|
|
|
|
if (hwif != host->cur_port)
|
2009-01-06 23:20:48 +07:00
|
|
|
goto out_early;
|
|
|
|
}
|
2009-01-06 23:20:48 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_lock_irqsave(&hwif->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-06-15 23:52:58 +07:00
|
|
|
if (hwif->port_ops && hwif->port_ops->test_irq &&
|
|
|
|
hwif->port_ops->test_irq(hwif) == 0)
|
2008-12-30 02:27:29 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
handler = hwif->handler;
|
|
|
|
|
|
|
|
if (handler == NULL || hwif->polling) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-03-27 18:46:27 +07:00
|
|
|
if ((host->irq_flags & IRQF_SHARED) == 0) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Probably not a shared PCI interrupt,
|
|
|
|
* so we can safely try to do something about it:
|
|
|
|
*/
|
2009-01-06 23:20:48 +07:00
|
|
|
unexpected_intr(irq, hwif);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Whack the status register, just in case
|
|
|
|
* we have a leftover pending IRQ.
|
|
|
|
*/
|
2008-07-24 00:55:56 +07:00
|
|
|
(void)hwif->tp_ops->read_status(hwif);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-12-30 02:27:29 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-12-30 02:27:29 +07:00
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
drive = hwif->cur_dev;
|
2008-12-30 02:27:29 +07:00
|
|
|
|
|
|
|
if (!drive_is_ready(drive))
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-12-30 02:27:29 +07:00
|
|
|
goto out;
|
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
hwif->handler = NULL;
|
2009-03-27 18:46:46 +07:00
|
|
|
hwif->expiry = NULL;
|
2009-01-06 23:20:50 +07:00
|
|
|
hwif->req_gen++;
|
|
|
|
del_timer(&hwif->timer);
|
|
|
|
spin_unlock(&hwif->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-10-14 02:39:42 +07:00
|
|
|
if (hwif->port_ops && hwif->port_ops->clear_irq)
|
|
|
|
hwif->port_ops->clear_irq(drive);
|
2007-02-17 08:40:21 +07:00
|
|
|
|
2008-10-14 02:39:36 +07:00
|
|
|
if (drive->dev_flags & IDE_DFLAG_UNMASK)
|
2006-07-03 14:25:25 +07:00
|
|
|
local_irq_enable_in_hardirq();
|
2008-10-14 02:39:42 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* service this interrupt, may set handler for next interrupt */
|
|
|
|
startstop = handler(drive);
|
|
|
|
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_lock_irq(&hwif->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-05-22 21:23:37 +07:00
|
|
|
if (startstop == ide_stopped && hwif->polling == 0) {
|
2009-01-06 23:20:58 +07:00
|
|
|
BUG_ON(hwif->handler);
|
2009-05-08 09:53:59 +07:00
|
|
|
rq_in_flight = hwif->rq;
|
|
|
|
hwif->rq = NULL;
|
2009-01-06 23:20:58 +07:00
|
|
|
ide_unlock_port(hwif);
|
|
|
|
plug_device = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-12-30 02:27:29 +07:00
|
|
|
irq_ret = IRQ_HANDLED;
|
|
|
|
out:
|
2009-01-06 23:20:50 +07:00
|
|
|
spin_unlock_irqrestore(&hwif->lock, flags);
|
2009-01-06 23:20:48 +07:00
|
|
|
out_early:
|
2009-01-06 23:20:49 +07:00
|
|
|
if (plug_device) {
|
|
|
|
ide_unlock_host(hwif->host);
|
2009-05-08 09:53:59 +07:00
|
|
|
ide_requeue_and_plug(drive, rq_in_flight);
|
2009-01-06 23:20:49 +07:00
|
|
|
}
|
2009-01-02 22:12:50 +07:00
|
|
|
|
2008-12-30 02:27:29 +07:00
|
|
|
return irq_ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-03-05 22:10:57 +07:00
|
|
|
EXPORT_SYMBOL_GPL(ide_intr);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-29 04:44:41 +07:00
|
|
|
void ide_pad_transfer(ide_drive_t *drive, int write, int len)
|
|
|
|
{
|
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
|
|
|
u8 buf[4] = { 0 };
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
if (write)
|
2008-07-24 00:55:56 +07:00
|
|
|
hwif->tp_ops->output_data(drive, NULL, buf, min(4, len));
|
2008-04-29 04:44:41 +07:00
|
|
|
else
|
2008-07-24 00:55:56 +07:00
|
|
|
hwif->tp_ops->input_data(drive, NULL, buf, min(4, len));
|
2008-04-29 04:44:41 +07:00
|
|
|
len -= 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_pad_transfer);
|