forked from Minki/linux
[PATCH] libata-dev: Cleanup unused enums/functions
Cleanup the following unused functions: - ata_pio_poll() - ata_pio_complete() - ata_pio_first_block() - ata_pio_block() - ata_pio_error() ap->pio_task_timeout and other enums. Signed-off-by: Albert Lee <albertcc@tw.ibm.com> Signed-off-by: Jeff Garzik <jeff@garzik.org>
This commit is contained in:
Albert Lee
Jeff Garzik
parent
a1af37344f
commit
27cdadef6d
|
|
@ -67,7 +67,6 @@ static void ata_set_mode(struct ata_port *ap);
|
|||
static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
|
||||
struct ata_device *dev);
|
||||
static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
|
||||
static void ata_pio_error(struct ata_port *ap);
|
||||
|
||||
static unsigned int ata_unique_id = 1;
|
||||
static struct workqueue_struct *ata_wq;
|
||||
|
|
@ -3131,114 +3130,6 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc)
|
|||
spin_unlock_irqrestore(&ap->host_set->lock, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_pio_poll - poll using PIO, depending on current state
|
||||
* @ap: the target ata_port
|
||||
*
|
||||
* LOCKING:
|
||||
* None. (executing in kernel thread context)
|
||||
*
|
||||
* RETURNS:
|
||||
* timeout value to use
|
||||
*/
|
||||
|
||||
static unsigned long ata_pio_poll(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc;
|
||||
u8 status;
|
||||
unsigned int poll_state = HSM_ST_UNKNOWN;
|
||||
unsigned int reg_state = HSM_ST_UNKNOWN;
|
||||
|
||||
qc = ata_qc_from_tag(ap, ap->active_tag);
|
||||
WARN_ON(qc == NULL);
|
||||
|
||||
switch (ap->hsm_task_state) {
|
||||
case HSM_ST:
|
||||
case HSM_ST_POLL:
|
||||
poll_state = HSM_ST_POLL;
|
||||
reg_state = HSM_ST;
|
||||
break;
|
||||
case HSM_ST_LAST:
|
||||
case HSM_ST_LAST_POLL:
|
||||
poll_state = HSM_ST_LAST_POLL;
|
||||
reg_state = HSM_ST_LAST;
|
||||
break;
|
||||
default:
|
||||
BUG();
|
||||
break;
|
||||
}
|
||||
|
||||
status = ata_chk_status(ap);
|
||||
if (status & ATA_BUSY) {
|
||||
if (time_after(jiffies, ap->pio_task_timeout)) {
|
||||
qc->err_mask |= AC_ERR_TIMEOUT;
|
||||
ap->hsm_task_state = HSM_ST_TMOUT;
|
||||
return 0;
|
||||
}
|
||||
ap->hsm_task_state = poll_state;
|
||||
return ATA_SHORT_PAUSE;
|
||||
}
|
||||
|
||||
ap->hsm_task_state = reg_state;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_pio_complete - check if drive is busy or idle
|
||||
* @ap: the target ata_port
|
||||
*
|
||||
* LOCKING:
|
||||
* None. (executing in kernel thread context)
|
||||
*
|
||||
* RETURNS:
|
||||
* Zero if qc completed.
|
||||
* Non-zero if has next.
|
||||
*/
|
||||
|
||||
static int ata_pio_complete (struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc;
|
||||
u8 drv_stat;
|
||||
|
||||
/*
|
||||
* This is purely heuristic. This is a fast path. Sometimes when
|
||||
* we enter, BSY will be cleared in a chk-status or two. If not,
|
||||
* the drive is probably seeking or something. Snooze for a couple
|
||||
* msecs, then chk-status again. If still busy, fall back to
|
||||
* HSM_ST_LAST_POLL state.
|
||||
*/
|
||||
drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
|
||||
if (drv_stat & ATA_BUSY) {
|
||||
msleep(2);
|
||||
drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
|
||||
if (drv_stat & ATA_BUSY) {
|
||||
ap->hsm_task_state = HSM_ST_LAST_POLL;
|
||||
ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
qc = ata_qc_from_tag(ap, ap->active_tag);
|
||||
WARN_ON(qc == NULL);
|
||||
|
||||
drv_stat = ata_wait_idle(ap);
|
||||
if (!ata_ok(drv_stat)) {
|
||||
qc->err_mask |= __ac_err_mask(drv_stat);
|
||||
ap->hsm_task_state = HSM_ST_ERR;
|
||||
return 1;
|
||||
}
|
||||
|
||||
ap->hsm_task_state = HSM_ST_IDLE;
|
||||
|
||||
WARN_ON(qc->err_mask);
|
||||
ata_poll_qc_complete(qc);
|
||||
|
||||
/* another command may start at this point */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* swap_buf_le16 - swap halves of 16-bit words in place
|
||||
* @buf: Buffer to swap
|
||||
|
|
@ -3496,91 +3387,6 @@ static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_pio_first_block - Write first data block to hardware
|
||||
* @ap: Port to which ATA/ATAPI device is attached.
|
||||
*
|
||||
* When device has indicated its readiness to accept
|
||||
* the data, this function sends out the CDB or
|
||||
* the first data block by PIO.
|
||||
* After this,
|
||||
* - If polling, ata_pio_task() handles the rest.
|
||||
* - Otherwise, interrupt handler takes over.
|
||||
*
|
||||
* LOCKING:
|
||||
* Kernel thread context (may sleep)
|
||||
*
|
||||
* RETURNS:
|
||||
* Zero if irq handler takes over
|
||||
* Non-zero if has next (polling).
|
||||
*/
|
||||
|
||||
static int ata_pio_first_block(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc;
|
||||
u8 status;
|
||||
unsigned long flags;
|
||||
int has_next;
|
||||
|
||||
qc = ata_qc_from_tag(ap, ap->active_tag);
|
||||
WARN_ON(qc == NULL);
|
||||
WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
|
||||
|
||||
/* if polling, we will stay in the work queue after sending the data.
|
||||
* otherwise, interrupt handler takes over after sending the data.
|
||||
*/
|
||||
has_next = (qc->tf.flags & ATA_TFLAG_POLLING);
|
||||
|
||||
/* sleep-wait for BSY to clear */
|
||||
DPRINTK("busy wait\n");
|
||||
if (ata_busy_sleep(ap, ATA_TMOUT_DATAOUT_QUICK, ATA_TMOUT_DATAOUT)) {
|
||||
qc->err_mask |= AC_ERR_TIMEOUT;
|
||||
ap->hsm_task_state = HSM_ST_TMOUT;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
/* make sure DRQ is set */
|
||||
status = ata_chk_status(ap);
|
||||
if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
|
||||
/* device status error */
|
||||
qc->err_mask |= AC_ERR_HSM;
|
||||
ap->hsm_task_state = HSM_ST_ERR;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
/* Send the CDB (atapi) or the first data block (ata pio out).
|
||||
* During the state transition, interrupt handler shouldn't
|
||||
* be invoked before the data transfer is complete and
|
||||
* hsm_task_state is changed. Hence, the following locking.
|
||||
*/
|
||||
spin_lock_irqsave(&ap->host_set->lock, flags);
|
||||
|
||||
if (qc->tf.protocol == ATA_PROT_PIO) {
|
||||
/* PIO data out protocol.
|
||||
* send first data block.
|
||||
*/
|
||||
|
||||
/* ata_pio_sectors() might change the state to HSM_ST_LAST.
|
||||
* so, the state is changed here before ata_pio_sectors().
|
||||
*/
|
||||
ap->hsm_task_state = HSM_ST;
|
||||
ata_pio_sectors(qc);
|
||||
ata_altstatus(ap); /* flush */
|
||||
} else
|
||||
/* send CDB */
|
||||
atapi_send_cdb(ap, qc);
|
||||
|
||||
spin_unlock_irqrestore(&ap->host_set->lock, flags);
|
||||
|
||||
/* if polling, ata_pio_task() handles the rest.
|
||||
* otherwise, interrupt handler takes over from here.
|
||||
*/
|
||||
return has_next;
|
||||
|
||||
err_out:
|
||||
return 1; /* has next */
|
||||
}
|
||||
|
||||
/**
|
||||
* __atapi_pio_bytes - Transfer data from/to the ATAPI device.
|
||||
* @qc: Command on going
|
||||
|
|
@ -3720,91 +3526,6 @@ err_out:
|
|||
ap->hsm_task_state = HSM_ST_ERR;
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_pio_block - start PIO on a block
|
||||
* @ap: the target ata_port
|
||||
*
|
||||
* LOCKING:
|
||||
* None. (executing in kernel thread context)
|
||||
*/
|
||||
|
||||
static void ata_pio_block(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc;
|
||||
u8 status;
|
||||
|
||||
/*
|
||||
* This is purely heuristic. This is a fast path.
|
||||
* Sometimes when we enter, BSY will be cleared in
|
||||
* a chk-status or two. If not, the drive is probably seeking
|
||||
* or something. Snooze for a couple msecs, then
|
||||
* chk-status again. If still busy, fall back to
|
||||
* HSM_ST_POLL state.
|
||||
*/
|
||||
status = ata_busy_wait(ap, ATA_BUSY, 5);
|
||||
if (status & ATA_BUSY) {
|
||||
msleep(2);
|
||||
status = ata_busy_wait(ap, ATA_BUSY, 10);
|
||||
if (status & ATA_BUSY) {
|
||||
ap->hsm_task_state = HSM_ST_POLL;
|
||||
ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
qc = ata_qc_from_tag(ap, ap->active_tag);
|
||||
WARN_ON(qc == NULL);
|
||||
|
||||
/* check error */
|
||||
if (status & (ATA_ERR | ATA_DF)) {
|
||||
qc->err_mask |= AC_ERR_DEV;
|
||||
ap->hsm_task_state = HSM_ST_ERR;
|
||||
return;
|
||||
}
|
||||
|
||||
/* transfer data if any */
|
||||
if (is_atapi_taskfile(&qc->tf)) {
|
||||
/* DRQ=0 means no more data to transfer */
|
||||
if ((status & ATA_DRQ) == 0) {
|
||||
ap->hsm_task_state = HSM_ST_LAST;
|
||||
return;
|
||||
}
|
||||
|
||||
atapi_pio_bytes(qc);
|
||||
} else {
|
||||
/* handle BSY=0, DRQ=0 as error */
|
||||
if ((status & ATA_DRQ) == 0) {
|
||||
qc->err_mask |= AC_ERR_HSM;
|
||||
ap->hsm_task_state = HSM_ST_ERR;
|
||||
return;
|
||||
}
|
||||
|
||||
ata_pio_sectors(qc);
|
||||
}
|
||||
|
||||
ata_altstatus(ap); /* flush */
|
||||
}
|
||||
|
||||
static void ata_pio_error(struct ata_port *ap)
|
||||
{
|
||||
struct ata_queued_cmd *qc;
|
||||
|
||||
qc = ata_qc_from_tag(ap, ap->active_tag);
|
||||
WARN_ON(qc == NULL);
|
||||
|
||||
if (qc->tf.command != ATA_CMD_PACKET)
|
||||
printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
|
||||
|
||||
/* make sure qc->err_mask is available to
|
||||
* know what's wrong and recover
|
||||
*/
|
||||
WARN_ON(qc->err_mask == 0);
|
||||
|
||||
ap->hsm_task_state = HSM_ST_IDLE;
|
||||
|
||||
ata_poll_qc_complete(qc);
|
||||
}
|
||||
|
||||
/**
|
||||
* ata_hsm_move - move the HSM to the next state.
|
||||
* @ap: the target ata_port
|
||||
|
|
|
|||
|
|
@ -162,13 +162,8 @@ enum {
|
|||
ATA_QCFLAG_EH_SCHEDULED = (1 << 5), /* EH scheduled */
|
||||
|
||||
/* various lengths of time */
|
||||
ATA_TMOUT_PIO = 30 * HZ,
|
||||
ATA_TMOUT_BOOT = 30 * HZ, /* heuristic */
|
||||
ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* heuristic */
|
||||
ATA_TMOUT_DATAOUT = 30 * HZ,
|
||||
ATA_TMOUT_DATAOUT_QUICK = 5 * HZ,
|
||||
ATA_TMOUT_CDB = 30 * HZ,
|
||||
ATA_TMOUT_CDB_QUICK = 5 * HZ,
|
||||
ATA_TMOUT_INTERNAL = 30 * HZ,
|
||||
ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
|
||||
|
||||
|
|
@ -216,11 +211,8 @@ enum {
|
|||
enum hsm_task_states {
|
||||
HSM_ST_UNKNOWN, /* state unknown */
|
||||
HSM_ST_IDLE, /* no command on going */
|
||||
HSM_ST_POLL, /* same as HSM_ST, waits longer */
|
||||
HSM_ST_TMOUT, /* timeout */
|
||||
HSM_ST, /* (waiting the device to) transfer data */
|
||||
HSM_ST_LAST, /* (waiting the device to) complete command */
|
||||
HSM_ST_LAST_POLL, /* same as HSM_ST_LAST, waits longer */
|
||||
HSM_ST_ERR, /* error */
|
||||
HSM_ST_FIRST, /* (waiting the device to)
|
||||
write CDB or first data block */
|
||||
|
|
@ -409,7 +401,6 @@ struct ata_port {
|
|||
struct work_struct port_task;
|
||||
|
||||
unsigned int hsm_task_state;
|
||||
unsigned long pio_task_timeout;
|
||||
|
||||
u32 msg_enable;
|
||||
struct list_head eh_done_q;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user