brain-hackers_pepepper-mirror
/
linux-brain
mirror of https://github.com/brain-hackers/linux-brain.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[PATCH] libata: use dev->ap 

Use dev->ap where possible and eliminate superflous @ap from functions
and structures.

Signed-off-by: Tejun Heo <htejun@gmail.com>
This commit is contained in:
Tejun Heo 2006-05-15 20:57:53 +09:00
parent 38d87234d6
commit 3373efd89d
5 changed files with 106 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/scsi/ahci.c
View File

@ -597,7 +597,7 @@ static int ahci_softreset(struct ata_port *ap, unsigned int *class)
/* restart engine */
ahci_start_engine(ap);
ata_tf_init(ap, &tf, 0);
ata_tf_init(ap->device, &tf);
fis = pp->cmd_tbl;
/* issue the first D2H Register FIS */

160
drivers/scsi/libata-core.c
View File

@ -61,13 +61,10 @@
#include "libata.h"
static unsigned int ata_dev_init_params(struct ata_port *ap,
struct ata_device *dev,
u16 heads,
u16 sectors);
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 unsigned int ata_dev_init_params(struct ata_device *dev,
u16 heads, u16 sectors);
static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
static void ata_dev_xfermask(struct ata_device *dev);
static unsigned int ata_unique_id = 1;
static struct workqueue_struct *ata_wq;
@ -412,11 +409,11 @@ static const char *sata_spd_string(unsigned int spd)
return spd_str[spd - 1];
}
void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
void ata_dev_disable(struct ata_device *dev)
{
if (ata_dev_enabled(dev)) {
printk(KERN_WARNING "ata%u: dev %u disabled\n",
ap->id, dev->devno);
dev->ap->id, dev->devno);
dev->class++;
}
}
@ -960,7 +957,6 @@ void ata_qc_complete_internal(struct ata_queued_cmd *qc)
/**
* ata_exec_internal - execute libata internal command
* @ap: Port to which the command is sent
* @dev: Device to which the command is sent
* @tf: Taskfile registers for the command and the result
* @cdb: CDB for packet command
@ -978,10 +974,11 @@ void ata_qc_complete_internal(struct ata_queued_cmd *qc)
* None. Should be called with kernel context, might sleep.
*/
unsigned ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
unsigned ata_exec_internal(struct ata_device *dev,
struct ata_taskfile *tf, const u8 *cdb,
int dma_dir, void *buf, unsigned int buflen)
{
struct ata_port *ap = dev->ap;
u8 command = tf->command;
struct ata_queued_cmd *qc;
DECLARE_COMPLETION(wait);
@ -990,7 +987,7 @@ unsigned ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
spin_lock_irqsave(&ap->host_set->lock, flags);
qc = ata_qc_new_init(ap, dev);
qc = ata_qc_new_init(dev);
BUG_ON(qc == NULL);
qc->tf = *tf;
@ -1095,7 +1092,6 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
/**
* ata_dev_read_id - Read ID data from the specified device
* @ap: port on which target device resides
* @dev: target device
* @p_class: pointer to class of the target device (may be changed)
* @post_reset: is this read ID post-reset?
@ -1112,9 +1108,10 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
* RETURNS:
* 0 on success, -errno otherwise.
*/
static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
unsigned int *p_class, int post_reset, u16 *id)
static int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
int post_reset, u16 *id)
{
struct ata_port *ap = dev->ap;
unsigned int class = *p_class;
struct ata_taskfile tf;
unsigned int err_mask = 0;
@ -1126,7 +1123,7 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
retry:
ata_tf_init(ap, &tf, dev->devno);
ata_tf_init(dev, &tf);
switch (class) {
case ATA_DEV_ATA:
@ -1143,7 +1140,7 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
tf.protocol = ATA_PROT_PIO;
err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_FROM_DEVICE,
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
id, sizeof(id[0]) * ATA_ID_WORDS);
if (err_mask) {
rc = -EIO;
@ -1170,7 +1167,7 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
* Some drives were very specific about that exact sequence.
*/
if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
err_mask = ata_dev_init_params(dev, id[3], id[6]);
if (err_mask) {
rc = -EIO;
reason = "INIT_DEV_PARAMS failed";
@ -1195,15 +1192,13 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
return rc;
}
static inline u8 ata_dev_knobble(const struct ata_port *ap,
struct ata_device *dev)
static inline u8 ata_dev_knobble(struct ata_device *dev)
{
return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
}
/**
* ata_dev_configure - Configure the specified ATA/ATAPI device
* @ap: Port on which target device resides
* @dev: Target device to configure
* @print_info: Enable device info printout
*
@ -1216,9 +1211,9 @@ static inline u8 ata_dev_knobble(const struct ata_port *ap,
* RETURNS:
* 0 on success, -errno otherwise
*/
static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
int print_info)
static int ata_dev_configure(struct ata_device *dev, int print_info)
{
struct ata_port *ap = dev->ap;
const u16 *id = dev->id;
unsigned int xfer_mask;
int i, rc;
@ -1331,7 +1326,7 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
ap->device[i].cdb_len);
/* limit bridge transfers to udma5, 200 sectors */
if (ata_dev_knobble(ap, dev)) {
if (ata_dev_knobble(dev)) {
if (print_info)
printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
ap->id, dev->devno);
@ -1416,11 +1411,11 @@ static int ata_bus_probe(struct ata_port *ap)
if (!ata_dev_enabled(dev))
continue;
rc = ata_dev_read_id(ap, dev, &dev->class, 1, dev->id);
rc = ata_dev_read_id(dev, &dev->class, 1, dev->id);
if (rc)
goto fail;
rc = ata_dev_configure(ap, dev, 1);
rc = ata_dev_configure(dev, 1);
if (rc)
goto fail;
}
@ -1453,13 +1448,13 @@ static int ata_bus_probe(struct ata_port *ap)
default:
tries[dev->devno]--;
if (down_xfermask &&
ata_down_xfermask_limit(ap, dev, tries[dev->devno] == 1))
ata_down_xfermask_limit(dev, tries[dev->devno] == 1))
tries[dev->devno] = 0;
}
if (!tries[dev->devno]) {
ata_down_xfermask_limit(ap, dev, 1);
ata_dev_disable(ap, dev);
ata_down_xfermask_limit(dev, 1);
ata_dev_disable(dev);
}
goto retry;
@ -1586,15 +1581,15 @@ void sata_phy_reset(struct ata_port *ap)
/**
* ata_dev_pair - return other device on cable
* @ap: port
* @adev: device
*
* Obtain the other device on the same cable, or if none is
* present NULL is returned
*/
struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
struct ata_device *ata_dev_pair(struct ata_device *adev)
{
struct ata_port *ap = adev->ap;
struct ata_device *pair = &ap->device[1 - adev->devno];
if (!ata_dev_enabled(pair))
return NULL;
@ -1886,7 +1881,6 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
/**
* ata_down_xfermask_limit - adjust dev xfer masks downward
* @ap: Port associated with device @dev
* @dev: Device to adjust xfer masks
* @force_pio0: Force PIO0
*
@ -1900,9 +1894,9 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
* RETURNS:
* 0 on success, negative errno on failure
*/
int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
int force_pio0)
int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0)
{
struct ata_port *ap = dev->ap;
unsigned long xfer_mask;
int highbit;
@ -1934,8 +1928,9 @@ int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
return -EINVAL;
}
static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
static int ata_dev_set_mode(struct ata_device *dev)
{
struct ata_port *ap = dev->ap;
unsigned int err_mask;
int rc;
@ -1943,7 +1938,7 @@ static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
if (dev->xfer_shift == ATA_SHIFT_PIO)
dev->flags |= ATA_DFLAG_PIO;
err_mask = ata_dev_set_xfermode(ap, dev);
err_mask = ata_dev_set_xfermode(dev);
if (err_mask) {
printk(KERN_ERR
"ata%u: failed to set xfermode (err_mask=0x%x)\n",
@ -1951,7 +1946,7 @@ static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
return -EIO;
}
rc = ata_dev_revalidate(ap, dev, 0);
rc = ata_dev_revalidate(dev, 0);
if (rc)
return rc;
@ -2007,7 +2002,7 @@ int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
if (!ata_dev_enabled(dev))
continue;
ata_dev_xfermask(ap, dev);
ata_dev_xfermask(dev);
pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
@ -2060,7 +2055,7 @@ int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
if (!ata_dev_enabled(dev))
continue;
rc = ata_dev_set_mode(ap, dev);
rc = ata_dev_set_mode(dev);
if (rc)
goto out;
}
@ -2712,7 +2707,6 @@ int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
/**
* ata_dev_same_device - Determine whether new ID matches configured device
* @ap: port on which the device to compare against resides
* @dev: device to compare against
* @new_class: class of the new device
* @new_id: IDENTIFY page of the new device
@ -2727,9 +2721,10 @@ int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
* RETURNS:
* 1 if @dev matches @new_class and @new_id, 0 otherwise.
*/
static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
unsigned int new_class, const u16 *new_id)
static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
const u16 *new_id)
{
struct ata_port *ap = dev->ap;
const u16 *old_id = dev->id;
unsigned char model[2][41], serial[2][21];
u64 new_n_sectors;
@ -2774,7 +2769,6 @@ static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
/**
* ata_dev_revalidate - Revalidate ATA device
* @ap: port on which the device to revalidate resides
* @dev: device to revalidate
* @post_reset: is this revalidation after reset?
*
@ -2787,9 +2781,9 @@ static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
* RETURNS:
* 0 on success, negative errno otherwise
*/
int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
int post_reset)
int ata_dev_revalidate(struct ata_device *dev, int post_reset)
{
struct ata_port *ap = dev->ap;
unsigned int class = dev->class;
u16 *id = (void *)ap->sector_buf;
int rc;
@ -2800,12 +2794,12 @@ int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
}
/* read ID data */
rc = ata_dev_read_id(ap, dev, &class, post_reset, id);
rc = ata_dev_read_id(dev, &class, post_reset, id);
if (rc)
goto fail;
/* is the device still there? */
if (!ata_dev_same_device(ap, dev, class, id)) {
if (!ata_dev_same_device(dev, class, id)) {
rc = -ENODEV;
goto fail;
}
@ -2813,7 +2807,7 @@ int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
/* configure device according to the new ID */
rc = ata_dev_configure(ap, dev, 0);
rc = ata_dev_configure(dev, 0);
if (rc == 0)
return 0;
@ -2895,7 +2889,6 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
/**
* ata_dev_xfermask - Compute supported xfermask of the given device
* @ap: Port on which the device to compute xfermask for resides
* @dev: Device to compute xfermask for
*
* Compute supported xfermask of @dev and store it in
@ -2910,8 +2903,9 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
* LOCKING:
* None.
*/
static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
static void ata_dev_xfermask(struct ata_device *dev)
{
struct ata_port *ap = dev->ap;
struct ata_host_set *hs = ap->host_set;
unsigned long xfer_mask;
int i;
@ -2964,7 +2958,6 @@ static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
/**
* ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
* @ap: Port associated with device @dev
* @dev: Device to which command will be sent
*
* Issue SET FEATURES - XFER MODE command to device @dev
@ -2977,8 +2970,7 @@ static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
* 0 on success, AC_ERR_* mask otherwise.
*/
static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
struct ata_device *dev)
static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
{
struct ata_taskfile tf;
unsigned int err_mask;
@ -2986,14 +2978,14 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
/* set up set-features taskfile */
DPRINTK("set features - xfer mode\n");
ata_tf_init(ap, &tf, dev->devno);
ata_tf_init(dev, &tf);
tf.command = ATA_CMD_SET_FEATURES;
tf.feature = SETFEATURES_XFER;
tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
tf.protocol = ATA_PROT_NODATA;
tf.nsect = dev->xfer_mode;
err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
DPRINTK("EXIT, err_mask=%x\n", err_mask);
return err_mask;
@ -3001,8 +2993,9 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
/**
* ata_dev_init_params - Issue INIT DEV PARAMS command
* @ap: Port associated with device @dev
* @dev: Device to which command will be sent
* @heads: Number of heads
* @sectors: Number of sectors
*
* LOCKING:
* Kernel thread context (may sleep)
@ -3010,11 +3003,8 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
* RETURNS:
* 0 on success, AC_ERR_* mask otherwise.
*/
static unsigned int ata_dev_init_params(struct ata_port *ap,
struct ata_device *dev,
u16 heads,
u16 sectors)
static unsigned int ata_dev_init_params(struct ata_device *dev,
u16 heads, u16 sectors)
{
struct ata_taskfile tf;
unsigned int err_mask;
@ -3026,14 +3016,14 @@ static unsigned int ata_dev_init_params(struct ata_port *ap,
/* set up init dev params taskfile */
DPRINTK("init dev params \n");
ata_tf_init(ap, &tf, dev->devno);
ata_tf_init(dev, &tf);
tf.command = ATA_CMD_INIT_DEV_PARAMS;
tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
tf.protocol = ATA_PROT_NODATA;
tf.nsect = sectors;
tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
DPRINTK("EXIT, err_mask=%x\n", err_mask);
return err_mask;
@ -4045,16 +4035,15 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
/**
* ata_qc_new_init - Request an available ATA command, and initialize it
* @ap: Port associated with device @dev
* @dev: Device from whom we request an available command structure
*
* LOCKING:
* None.
*/
struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
struct ata_device *dev)
struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
{
struct ata_port *ap = dev->ap;
struct ata_queued_cmd *qc;
qc = ata_qc_new(ap);
@ -4520,19 +4509,18 @@ int ata_port_offline(struct ata_port *ap)
* Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
* without filling any other registers
*/
static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
u8 cmd)
static int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
{
struct ata_taskfile tf;
int err;
ata_tf_init(ap, &tf, dev->devno);
ata_tf_init(dev, &tf);
tf.command = cmd;
tf.flags |= ATA_TFLAG_DEVICE;
tf.protocol = ATA_PROT_NODATA;
err = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
if (err)
printk(KERN_ERR "%s: ata command failed: %d\n",
__FUNCTION__, err);
@ -4540,7 +4528,7 @@ static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
return err;
}
static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
static int ata_flush_cache(struct ata_device *dev)
{
u8 cmd;
@ -4552,22 +4540,21 @@ static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
else
cmd = ATA_CMD_FLUSH;
return ata_do_simple_cmd(ap, dev, cmd);
return ata_do_simple_cmd(dev, cmd);
}
static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
static int ata_standby_drive(struct ata_device *dev)
{
return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
return ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);
}
static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
static int ata_start_drive(struct ata_device *dev)
{
return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
return ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);
}
/**
* ata_device_resume - wakeup a previously suspended devices
* @ap: port the device is connected to
* @dev: the device to resume
*
* Kick the drive back into action, by sending it an idle immediate
@ -4575,39 +4562,42 @@ static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
* and host.
*
*/
int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
int ata_device_resume(struct ata_device *dev)
{
struct ata_port *ap = dev->ap;
if (ap->flags & ATA_FLAG_SUSPENDED) {
struct ata_device *failed_dev;
ap->flags &= ~ATA_FLAG_SUSPENDED;
while (ata_set_mode(ap, &failed_dev))
ata_dev_disable(ap, failed_dev);
ata_dev_disable(failed_dev);
}
if (!ata_dev_enabled(dev))
return 0;
if (dev->class == ATA_DEV_ATA)
ata_start_drive(ap, dev);
ata_start_drive(dev);
return 0;
}
/**
* ata_device_suspend - prepare a device for suspend
* @ap: port the device is connected to
* @dev: the device to suspend
*
* Flush the cache on the drive, if appropriate, then issue a
* standbynow command.
*/
int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
int ata_device_suspend(struct ata_device *dev, pm_message_t state)
{
struct ata_port *ap = dev->ap;
if (!ata_dev_enabled(dev))
return 0;
if (dev->class == ATA_DEV_ATA)
ata_flush_cache(ap, dev);
ata_flush_cache(dev);
if (state.event != PM_EVENT_FREEZE)
ata_standby_drive(ap, dev);
ata_standby_drive(dev);
ap->flags |= ATA_FLAG_SUSPENDED;
return 0;
}

40
drivers/scsi/libata-scsi.c
View File

@ -302,7 +302,6 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
/**
* ata_scsi_qc_new - acquire new ata_queued_cmd reference
* @ap: ATA port to which the new command is attached
* @dev: ATA device to which the new command is attached
* @cmd: SCSI command that originated this ATA command
* @done: SCSI command completion function
@ -321,14 +320,13 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
* RETURNS:
* Command allocated, or %NULL if none available.
*/
struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
struct ata_device *dev,
struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *))
{
struct ata_queued_cmd *qc;
qc = ata_qc_new_init(ap, dev);
qc = ata_qc_new_init(dev);
if (qc) {
qc->scsicmd = cmd;
qc->scsidone = done;
@ -398,7 +396,7 @@ int ata_scsi_device_resume(struct scsi_device *sdev)
struct ata_port *ap = ata_shost_to_port(sdev->host);
struct ata_device *dev = &ap->device[sdev->id];
return ata_device_resume(ap, dev);
return ata_device_resume(dev);
}
int ata_scsi_device_suspend(struct scsi_device *sdev, pm_message_t state)
@ -406,7 +404,7 @@ int ata_scsi_device_suspend(struct scsi_device *sdev, pm_message_t state)
struct ata_port *ap = ata_shost_to_port(sdev->host);
struct ata_device *dev = &ap->device[sdev->id];
return ata_device_suspend(ap, dev, state);
return ata_device_suspend(dev, state);
}
/**
@ -1224,7 +1222,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
/**
* ata_scsi_translate - Translate then issue SCSI command to ATA device
* @ap: ATA port to which the command is addressed
* @dev: ATA device to which the command is addressed
* @cmd: SCSI command to execute
* @done: SCSI command completion function
@ -1247,17 +1244,16 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
* spin_lock_irqsave(host_set lock)
*/
static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *),
ata_xlat_func_t xlat_func)
static void ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *),
ata_xlat_func_t xlat_func)
{
struct ata_queued_cmd *qc;
u8 *scsicmd = cmd->cmnd;
VPRINTK("ENTER\n");
qc = ata_scsi_qc_new(ap, dev, cmd, done);
qc = ata_scsi_qc_new(dev, cmd, done);
if (!qc)
goto err_mem;
@ -1266,7 +1262,7 @@ static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
cmd->sc_data_direction == DMA_TO_DEVICE) {
if (unlikely(cmd->request_bufflen < 1)) {
printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
ap->id, dev->devno);
dev->ap->id, dev->devno);
goto err_did;
}
@ -2433,19 +2429,20 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
#endif
}
static inline void __ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
struct ata_port *ap, struct ata_device *dev)
static inline void __ata_scsi_queuecmd(struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *),
struct ata_device *dev)
{
if (dev->class == ATA_DEV_ATA) {
ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
cmd->cmnd[0]);
if (xlat_func)
ata_scsi_translate(ap, dev, cmd, done, xlat_func);
ata_scsi_translate(dev, cmd, done, xlat_func);
else
ata_scsi_simulate(ap, dev, cmd, done);
ata_scsi_simulate(dev, cmd, done);
} else
ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
ata_scsi_translate(dev, cmd, done, atapi_xlat);
}
/**
@ -2483,7 +2480,7 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
dev = ata_scsi_find_dev(ap, scsidev);
if (likely(dev))
__ata_scsi_queuecmd(cmd, done, ap, dev);
__ata_scsi_queuecmd(cmd, done, dev);
else {
cmd->result = (DID_BAD_TARGET << 16);
done(cmd);
@ -2496,7 +2493,6 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
/**
* ata_scsi_simulate - simulate SCSI command on ATA device
* @ap: port the device is connected to
* @dev: the target device
* @cmd: SCSI command being sent to device.
* @done: SCSI command completion function.
@ -2508,14 +2504,12 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
* spin_lock_irqsave(host_set lock)
*/
void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
struct scsi_cmnd *cmd,
void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *))
{
struct ata_scsi_args args;
const u8 *scsicmd = cmd->cmnd;
args.ap = ap;
args.dev = dev;
args.id = dev->id;
args.cmd = cmd;

11
drivers/scsi/libata.h
View File

@ -32,7 +32,6 @@
#define DRV_VERSION "1.30" /* must be exactly four chars */
struct ata_scsi_args {
struct ata_port *ap;
struct ata_device *dev;
u16 *id;
struct scsi_cmnd *cmd;
@ -43,18 +42,16 @@ struct ata_scsi_args {
extern int atapi_enabled;
extern int atapi_dmadir;
extern int libata_fua;
extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
struct ata_device *dev);
extern struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev);
extern int ata_rwcmd_protocol(struct ata_queued_cmd *qc);
extern void ata_dev_disable(struct ata_port *ap, struct ata_device *dev);
extern void ata_dev_disable(struct ata_device *dev);
extern void ata_port_flush_task(struct ata_port *ap);
extern unsigned ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
extern unsigned ata_exec_internal(struct ata_device *dev,
struct ata_taskfile *tf, const u8 *cdb,
int dma_dir, void *buf, unsigned int buflen);
extern int sata_down_spd_limit(struct ata_port *ap);
extern int sata_set_spd_needed(struct ata_port *ap);
extern int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
int force_pio0);
extern int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0);
extern int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
extern int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
unsigned int *classes);

21
include/linux/libata.h
View File

@ -518,8 +518,7 @@ extern void ata_std_probeinit(struct ata_port *ap);
extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes);
extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class);
extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
extern int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
int post_reset);
extern int ata_dev_revalidate(struct ata_device *dev, int post_reset);
extern void ata_port_disable(struct ata_port *);
extern void ata_std_ports(struct ata_ioports *ioaddr);
#ifdef CONFIG_PCI
@ -545,8 +544,8 @@ extern int ata_port_online(struct ata_port *ap);
extern int ata_port_offline(struct ata_port *ap);
extern int ata_scsi_device_resume(struct scsi_device *);
extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t state);
extern int ata_device_resume(struct ata_port *, struct ata_device *);
extern int ata_device_suspend(struct ata_port *, struct ata_device *, pm_message_t state);
extern int ata_device_resume(struct ata_device *);
extern int ata_device_suspend(struct ata_device *, pm_message_t state);
extern int ata_ratelimit(void);
extern unsigned int ata_busy_sleep(struct ata_port *ap,
unsigned long timeout_pat,
@ -592,15 +591,13 @@ extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
extern u8 ata_bmdma_status(struct ata_port *ap);
extern void ata_bmdma_irq_clear(struct ata_port *ap);
extern void __ata_qc_complete(struct ata_queued_cmd *qc);
extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
struct scsi_cmnd *cmd,
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *));
extern int ata_std_bios_param(struct scsi_device *sdev,
struct block_device *bdev,
sector_t capacity, int geom[]);
extern int ata_scsi_slave_config(struct scsi_device *sdev);
extern struct ata_device *ata_dev_pair(struct ata_port *ap,
struct ata_device *adev);
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
/*
* Timing helpers
@ -812,12 +809,12 @@ static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
return NULL;
}
static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
{
memset(tf, 0, sizeof(*tf));
tf->ctl = ap->ctl;
if (device == 0)
tf->ctl = dev->ap->ctl;
if (dev->devno == 0)
tf->device = ATA_DEVICE_OBS;
else
tf->device = ATA_DEVICE_OBS | ATA_DEV1;
@ -832,7 +829,7 @@ static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
qc->nbytes = qc->curbytes = 0;
qc->err_mask = 0;
ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
ata_tf_init(qc->dev, &qc->tf);
/* init result_tf such that it indicates normal completion */
qc->result_tf.command = ATA_DRDY;