Skip to content

Commit

Permalink
[PATCH] libata-dev: Cleanup unused enums/functions
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
Albert Lee authored and Jeff Garzik committed Mar 29, 2006
1 parent a1af373 commit 27cdade
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 288 deletions.
279 changes: 0 additions & 279 deletions drivers/scsi/libata-core.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -3720,91 +3526,6 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
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
Expand Down
9 changes: 0 additions & 9 deletions include/linux/libata.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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,

Expand Down Expand Up @@ -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 */
Expand Down Expand Up @@ -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;
Expand Down

0 comments on commit 27cdade

Please sign in to comment.