Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9af5c9c9 authored by Tejun Heo's avatar Tejun Heo Committed by Jeff Garzik
Browse files

libata-link: introduce ata_link 



Introduce ata_link.  It abstracts PHY and sits between ata_port and
ata_device.  This new level of abstraction is necessary to support
SATA Port Multiplier, which basically adds a bunch of links (PHYs) to
a ATA host port.  Fields related to command execution, spd_limit and
EH are per-link and thus moved to ata_link.

This patch only defines the host link.  Multiple link handling will be
added later.  Also, a lot of ap->link derefences are added but many of
them will be removed as each part is converted to deal directly with
ata_link instead of ata_port.

This patch introduces no behavior change.

Signed-off-by: default avatarTejun Heo <htejun@gmail.com>
Cc: James Bottomley <James.Bottomley@SteelEye.com>
Signed-off-by: default avatarJeff Garzik <jeff@garzik.org>
parent 640fdb50

drivers/ata/ahci.c

+9 −9
Original line number Diff line number Diff line
@@ -1064,7 +1064,7 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class, 
		ata_port_printk(ap, KERN_WARNING,

				"failed to reset engine (errno=%d)", rc);



	ata_tf_init(ap->device, &tf);

	ata_tf_init(ap->link.device, &tf);



	/* issue the first D2H Register FIS */

	msecs = 0;
@@ -1132,7 +1132,7 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class, 
	ahci_stop_engine(ap);



	/* clear D2H reception area to properly wait for D2H FIS */

	ata_tf_init(ap->device, &tf);

	ata_tf_init(ap->link.device, &tf);

	tf.command = 0x80;

	ata_tf_to_fis(&tf, 0, 0, d2h_fis);
@@ -1159,7 +1159,7 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class, 


	ahci_stop_engine(ap);



	rc = sata_port_hardreset(ap, sata_ehc_deb_timing(&ap->eh_context),

	rc = sata_port_hardreset(ap, sata_ehc_deb_timing(&ap->link.eh_context),

				 deadline);



	/* vt8251 needs SError cleared for the port to operate */
@@ -1278,7 +1278,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc) 
static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)

{

	struct ahci_port_priv *pp = ap->private_data;

	struct ata_eh_info *ehi = &ap->eh_info;

	struct ata_eh_info *ehi = &ap->link.eh_info;

	unsigned int err_mask = 0, action = 0;

	struct ata_queued_cmd *qc;

	u32 serror;
@@ -1332,7 +1332,7 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat) 
	ehi->serror |= serror;

	ehi->action |= action;



	qc = ata_qc_from_tag(ap, ap->active_tag);

	qc = ata_qc_from_tag(ap, ap->link.active_tag);

	if (qc)

		qc->err_mask |= err_mask;

	else
@@ -1347,7 +1347,7 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat) 
static void ahci_port_intr(struct ata_port *ap)

{

	void __iomem *port_mmio = ap->ioaddr.cmd_addr;

	struct ata_eh_info *ehi = &ap->eh_info;

	struct ata_eh_info *ehi = &ap->link.eh_info;

	struct ahci_port_priv *pp = ap->private_data;

	u32 status, qc_active;

	int rc, known_irq = 0;
@@ -1360,7 +1360,7 @@ static void ahci_port_intr(struct ata_port *ap) 
		return;

	}



	if (ap->sactive)

	if (ap->link.sactive)

		qc_active = readl(port_mmio + PORT_SCR_ACT);

	else

		qc_active = readl(port_mmio + PORT_CMD_ISSUE);
@@ -1380,7 +1380,7 @@ static void ahci_port_intr(struct ata_port *ap) 
	/* if !NCQ, ignore.  No modern ATA device has broken HSM

	 * implementation for non-NCQ commands.

	 */

	if (!ap->sactive)

	if (!ap->link.sactive)

		return;



	if (status & PORT_IRQ_D2H_REG_FIS) {
@@ -1433,7 +1433,7 @@ static void ahci_port_intr(struct ata_port *ap) 
	if (!known_irq)

		ata_port_printk(ap, KERN_INFO, "spurious interrupt "

				"(irq_stat 0x%x active_tag 0x%x sactive 0x%x)\n",

				status, ap->active_tag, ap->sactive);

				status, ap->link.active_tag, ap->link.sactive);

}



static void ahci_irq_clear(struct ata_port *ap)

drivers/ata/ata_generic.c

+1 −1
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ static int generic_set_mode(struct ata_port *ap, struct ata_device **unused) 
		dma_enabled = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);



	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		struct ata_device *dev = &ap->device[i];

		struct ata_device *dev = &ap->link.device[i];

		if (ata_dev_enabled(dev)) {

			/* We don't really care */

			dev->pio_mode = XFER_PIO_0;

drivers/ata/libata-acpi.c

+11 −10
Original line number Diff line number Diff line
@@ -44,7 +44,8 @@ static void ata_acpi_associate_sata_port(struct ata_port *ap) 
{

	acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);



	ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr);

	ap->link.device->acpi_handle =

		acpi_get_child(ap->host->acpi_handle, adr);

}



static void ata_acpi_associate_ide_port(struct ata_port *ap)
@@ -60,7 +61,7 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap) 
		max_devices++;



	for (i = 0; i < max_devices; i++) {

		struct ata_device *dev = &ap->device[i];

		struct ata_device *dev = &ap->link.device[i];



		dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);

	}
@@ -182,10 +183,10 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm) 
	/* Buffers for id may need byteswapping ? */

	in_params[1].type = ACPI_TYPE_BUFFER;

	in_params[1].buffer.length = 512;

	in_params[1].buffer.pointer = (u8 *)ap->device[0].id;

	in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;

	in_params[2].type = ACPI_TYPE_BUFFER;

	in_params[2].buffer.length = 512;

	in_params[2].buffer.pointer = (u8 *)ap->device[1].id;

	in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;



	input.count = 3;

	input.pointer = in_params;
@@ -226,7 +227,7 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm) 
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,

			   void **ptr_to_free)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	acpi_status status;

	struct acpi_buffer output;

	union acpi_object *out_obj;
@@ -320,7 +321,7 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf, 
static int taskfile_load_raw(struct ata_device *dev,

			      const struct ata_acpi_gtf *gtf)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	struct ata_taskfile tf, rtf;

	unsigned int err_mask;
@@ -424,7 +425,7 @@ static int ata_acpi_exec_tfs(struct ata_device *dev) 
 */

static int ata_acpi_push_id(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	int err;

	acpi_status status;

	struct acpi_object_list input;
@@ -519,7 +520,7 @@ void ata_acpi_on_resume(struct ata_port *ap) 


	/* schedule _GTF */

	for (i = 0; i < ATA_MAX_DEVICES; i++)

		ap->device[i].flags |= ATA_DFLAG_ACPI_PENDING;

		ap->link.device[i].flags |= ATA_DFLAG_ACPI_PENDING;

}



/**
@@ -538,8 +539,8 @@ void ata_acpi_on_resume(struct ata_port *ap) 
 */

int ata_acpi_on_devcfg(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_eh_context *ehc = &ap->eh_context;

	struct ata_port *ap = dev->link->ap;

	struct ata_eh_context *ehc = &ap->link.eh_context;

	int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;

	int rc;

drivers/ata/libata-core.c

+83 −74
Original line number Diff line number Diff line
@@ -235,7 +235,7 @@ static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev) 
	if (dev->flags & ATA_DFLAG_PIO) {

		tf->protocol = ATA_PROT_PIO;

		index = dev->multi_count ? 0 : 8;

	} else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) {

	} else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {

		/* Unable to use DMA due to host limitation */

		tf->protocol = ATA_PROT_PIO;

		index = dev->multi_count ? 0 : 8;
@@ -604,7 +604,7 @@ static const char *sata_spd_string(unsigned int spd) 
void ata_dev_disable(struct ata_device *dev)

{

	if (ata_dev_enabled(dev)) {

		if (ata_msg_drv(dev->ap))

		if (ata_msg_drv(dev->link->ap))

			ata_dev_printk(dev, KERN_WARNING, "disabled\n");

		ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |

					     ATA_DNXFER_QUIET);
@@ -735,7 +735,7 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err) 
	/* see if device passed diags: if master then continue and warn later */

	if (err == 0 && device == 0)

		/* diagnostic fail : do nothing _YET_ */

		ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;

		ap->link.device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;

	else if (err == 1)

		/* do nothing */ ;

	else if ((device == 0) && (err == 0x81))
@@ -1150,7 +1150,7 @@ void ata_dev_select(struct ata_port *ap, unsigned int device, 
	ap->ops->dev_select(ap, device);



	if (wait) {

		if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)

		if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)

			msleep(150);

		ata_wait_idle(ap);

	}
@@ -1346,7 +1346,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev, 
			      int dma_dir, struct scatterlist *sg,

			      unsigned int n_elem)

{

	struct ata_port *ap = dev->ap;

	struct ata_link *link = dev->link;

	struct ata_port *ap = link->ap;

	u8 command = tf->command;

	struct ata_queued_cmd *qc;

	unsigned int tag, preempted_tag;
@@ -1386,11 +1387,11 @@ unsigned ata_exec_internal_sg(struct ata_device *dev, 
	qc->dev = dev;

	ata_qc_reinit(qc);



	preempted_tag = ap->active_tag;

	preempted_sactive = ap->sactive;

	preempted_tag = link->active_tag;

	preempted_sactive = link->sactive;

	preempted_qc_active = ap->qc_active;

	ap->active_tag = ATA_TAG_POISON;

	ap->sactive = 0;

	link->active_tag = ATA_TAG_POISON;

	link->sactive = 0;

	ap->qc_active = 0;



	/* prepare & issue qc */
@@ -1467,8 +1468,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev, 
	err_mask = qc->err_mask;



	ata_qc_free(qc);

	ap->active_tag = preempted_tag;

	ap->sactive = preempted_sactive;

	link->active_tag = preempted_tag;

	link->sactive = preempted_sactive;

	ap->qc_active = preempted_qc_active;



	/* XXX - Some LLDDs (sata_mv) disable port on command failure.
@@ -1566,7 +1567,7 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev) 
{

	/* Controller doesn't support  IORDY. Probably a pointless check

	   as the caller should know this */

	if (adev->ap->flags & ATA_FLAG_NO_IORDY)

	if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)

		return 0;

	/* PIO3 and higher it is mandatory */

	if (adev->pio_mode > XFER_PIO_2)
@@ -1622,7 +1623,7 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev) 
int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,

		    unsigned int flags, u16 *id)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	unsigned int class = *p_class;

	struct ata_taskfile tf;

	unsigned int err_mask = 0;
@@ -1774,13 +1775,14 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class, 


static inline u8 ata_dev_knobble(struct ata_device *dev)

{

	return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));

	struct ata_port *ap = dev->link->ap;

	return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));

}



static void ata_dev_config_ncq(struct ata_device *dev,

			       char *desc, size_t desc_sz)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);



	if (!ata_id_has_ncq(dev->id)) {
@@ -1817,8 +1819,8 @@ static void ata_dev_config_ncq(struct ata_device *dev, 
 */

int ata_dev_configure(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_eh_context *ehc = &ap->eh_context;

	struct ata_port *ap = dev->link->ap;

	struct ata_eh_context *ehc = &dev->link->eh_context;

	int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;

	const u16 *id = dev->id;

	unsigned int xfer_mask;
@@ -2116,7 +2118,7 @@ int ata_bus_probe(struct ata_port *ap) 
	ap->ops->phy_reset(ap);



	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];



		if (!(ap->flags & ATA_FLAG_DISABLED) &&

		    dev->class != ATA_DEV_UNKNOWN)
@@ -2133,14 +2135,14 @@ int ata_bus_probe(struct ata_port *ap) 
	   state is undefined. Record the mode */



	for (i = 0; i < ATA_MAX_DEVICES; i++)

		ap->device[i].pio_mode = XFER_PIO_0;

		ap->link.device[i].pio_mode = XFER_PIO_0;



	/* read IDENTIFY page and configure devices. We have to do the identify

	   specific sequence bass-ackwards so that PDIAG- is released by

	   the slave device */



	for (i = ATA_MAX_DEVICES - 1; i >=  0; i--) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];



		if (tries[i])

			dev->class = classes[i];
@@ -2162,13 +2164,13 @@ int ata_bus_probe(struct ata_port *ap) 
	   this in the normal order so that the user doesn't get confused */



	for(i = 0; i < ATA_MAX_DEVICES; i++) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];

		if (!ata_dev_enabled(dev))

			continue;



		ap->eh_context.i.flags |= ATA_EHI_PRINTINFO;

		ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;

		rc = ata_dev_configure(dev);

		ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO;

		ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;

		if (rc)

			goto fail;

	}
@@ -2179,7 +2181,7 @@ int ata_bus_probe(struct ata_port *ap) 
		goto fail;



	for (i = 0; i < ATA_MAX_DEVICES; i++)

		if (ata_dev_enabled(&ap->device[i]))

		if (ata_dev_enabled(&ap->link.device[i]))

			return 0;



	/* no device present, disable port */
@@ -2344,8 +2346,8 @@ void sata_phy_reset(struct ata_port *ap) 


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];

	struct ata_link *link = adev->link;

	struct ata_device *pair = &link->device[1 - adev->devno];

	if (!ata_dev_enabled(pair))

		return NULL;

	return pair;
@@ -2366,8 +2368,8 @@ struct ata_device *ata_dev_pair(struct ata_device *adev) 


void ata_port_disable(struct ata_port *ap)

{

	ap->device[0].class = ATA_DEV_NONE;

	ap->device[1].class = ATA_DEV_NONE;

	ap->link.device[0].class = ATA_DEV_NONE;

	ap->link.device[1].class = ATA_DEV_NONE;

	ap->flags |= ATA_FLAG_DISABLED;

}
@@ -2400,9 +2402,9 @@ int sata_down_spd_limit(struct ata_port *ap) 
	if (rc == 0)

		spd = (sstatus >> 4) & 0xf;

	else

		spd = ap->sata_spd;

		spd = ap->link.sata_spd;



	mask = ap->sata_spd_limit;

	mask = ap->link.sata_spd_limit;

	if (mask <= 1)

		return -EINVAL;
@@ -2422,7 +2424,7 @@ int sata_down_spd_limit(struct ata_port *ap) 
	if (!mask)

		return -EINVAL;



	ap->sata_spd_limit = mask;

	ap->link.sata_spd_limit = mask;



	ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",

			sata_spd_string(fls(mask)));
@@ -2434,10 +2436,10 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol) 
{

	u32 spd, limit;



	if (ap->sata_spd_limit == UINT_MAX)

	if (ap->link.sata_spd_limit == UINT_MAX)

		limit = 0;

	else

		limit = fls(ap->sata_spd_limit);

		limit = fls(ap->link.sata_spd_limit);



	spd = (*scontrol >> 4) & 0xf;

	*scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
@@ -2450,7 +2452,7 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol) 
 *	@ap: Port in question

 *

 *	Test whether the spd limit in SControl matches

 *	@ap->sata_spd_limit.  This function is used to determine

 *	@ap->link.sata_spd_limit.  This function is used to determine

 *	whether hardreset is necessary to apply SATA spd

 *	configuration.

 *
@@ -2749,7 +2751,7 @@ int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel) 


static int ata_dev_set_mode(struct ata_device *dev)

{

	struct ata_eh_context *ehc = &dev->ap->eh_context;

	struct ata_eh_context *ehc = &dev->link->eh_context;

	unsigned int err_mask;

	int rc;
@@ -2809,7 +2811,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev) 
	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		unsigned int pio_mask, dma_mask;



		dev = &ap->device[i];

		dev = &ap->link.device[i];



		if (!ata_dev_enabled(dev))

			continue;
@@ -2830,7 +2832,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev) 


	/* step 2: always set host PIO timings */

	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];

		if (!ata_dev_enabled(dev))

			continue;
@@ -2848,7 +2850,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev) 


	/* step 3: set host DMA timings */

	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];



		if (!ata_dev_enabled(dev) || !dev->dma_mode)

			continue;
@@ -2861,7 +2863,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev) 


	/* step 4: update devices' xfer mode */

	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		dev = &ap->device[i];

		dev = &ap->link.device[i];



		/* don't update suspended devices' xfer mode */

		if (!ata_dev_enabled(dev))
@@ -3142,6 +3144,7 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask, 


void ata_bus_reset(struct ata_port *ap)

{

	struct ata_device *device = ap->link.device;

	struct ata_ioports *ioaddr = &ap->ioaddr;

	unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;

	u8 err;
@@ -3177,19 +3180,19 @@ void ata_bus_reset(struct ata_port *ap) 
	/*

	 * determine by signature whether we have ATA or ATAPI devices

	 */

	ap->device[0].class = ata_dev_try_classify(ap, 0, &err);

	device[0].class = ata_dev_try_classify(ap, 0, &err);

	if ((slave_possible) && (err != 0x81))

		ap->device[1].class = ata_dev_try_classify(ap, 1, &err);

		device[1].class = ata_dev_try_classify(ap, 1, &err);



	/* is double-select really necessary? */

	if (ap->device[1].class != ATA_DEV_NONE)

	if (device[1].class != ATA_DEV_NONE)

		ap->ops->dev_select(ap, 1);

	if (ap->device[0].class != ATA_DEV_NONE)

	if (device[0].class != ATA_DEV_NONE)

		ap->ops->dev_select(ap, 0);



	/* if no devices were detected, disable this port */

	if ((ap->device[0].class == ATA_DEV_NONE) &&

	    (ap->device[1].class == ATA_DEV_NONE))

	if ((device[0].class == ATA_DEV_NONE) &&

	    (device[1].class == ATA_DEV_NONE))

		goto err_out;



	if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
@@ -3331,7 +3334,7 @@ int sata_phy_resume(struct ata_port *ap, const unsigned long *params, 
 */

int ata_std_prereset(struct ata_port *ap, unsigned long deadline)

{

	struct ata_eh_context *ehc = &ap->eh_context;

	struct ata_eh_context *ehc = &ap->link.eh_context;

	const unsigned long *timing = sata_ehc_deb_timing(ehc);

	int rc;
@@ -3503,7 +3506,7 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing, 
int sata_std_hardreset(struct ata_port *ap, unsigned int *class,

		       unsigned long deadline)

{

	const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);

	const unsigned long *timing = sata_ehc_deb_timing(&ap->link.eh_context);

	int rc;



	DPRINTK("ENTER\n");
@@ -3652,7 +3655,7 @@ static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class, 
int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)

{

	unsigned int class = dev->class;

	u16 *id = (void *)dev->ap->sector_buf;

	u16 *id = (void *)dev->link->ap->sector_buf;

	int rc;



	/* read ID data */
@@ -3837,7 +3840,7 @@ static int ata_dma_blacklisted(const struct ata_device *dev) 
	 * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)

	 * if the LLDD handles only interrupts in the HSM_ST_LAST state.

	 */

	if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) &&

	if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&

	    (dev->flags & ATA_DFLAG_CDB_INTR))

		return 1;

	return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
@@ -3857,7 +3860,8 @@ static int ata_dma_blacklisted(const struct ata_device *dev) 
 */

static void ata_dev_xfermask(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_link *link = dev->link;

	struct ata_port *ap = link->ap;

	struct ata_host *host = ap->host;

	unsigned long xfer_mask;
@@ -4482,7 +4486,7 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words) 
void ata_data_xfer(struct ata_device *adev, unsigned char *buf,

		   unsigned int buflen, int write_data)

{

	struct ata_port *ap = adev->ap;

	struct ata_port *ap = adev->link->ap;

	unsigned int words = buflen >> 1;



	/* Transfer multiple of 2 bytes */
@@ -5188,7 +5192,7 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap) 


struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_port *ap = dev->link->ap;

	struct ata_queued_cmd *qc;



	qc = ata_qc_new(ap);
@@ -5231,6 +5235,7 @@ void ata_qc_free(struct ata_queued_cmd *qc) 
void __ata_qc_complete(struct ata_queued_cmd *qc)

{

	struct ata_port *ap = qc->ap;

	struct ata_link *link = qc->dev->link;



	WARN_ON(qc == NULL);	/* ata_qc_from_tag _might_ return NULL */

	WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
@@ -5240,9 +5245,9 @@ void __ata_qc_complete(struct ata_queued_cmd *qc) 


	/* command should be marked inactive atomically with qc completion */

	if (qc->tf.protocol == ATA_PROT_NCQ)

		ap->sactive &= ~(1 << qc->tag);

		link->sactive &= ~(1 << qc->tag);

	else

		ap->active_tag = ATA_TAG_POISON;

		link->active_tag = ATA_TAG_POISON;



	/* atapi: mark qc as inactive to prevent the interrupt handler

	 * from completing the command twice later, before the error handler
@@ -5411,19 +5416,20 @@ static inline int ata_should_dma_map(struct ata_queued_cmd *qc) 
void ata_qc_issue(struct ata_queued_cmd *qc)

{

	struct ata_port *ap = qc->ap;

	struct ata_link *link = qc->dev->link;



	/* Make sure only one non-NCQ command is outstanding.  The

	 * check is skipped for old EH because it reuses active qc to

	 * request ATAPI sense.

	 */

	WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));

	WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));



	if (qc->tf.protocol == ATA_PROT_NCQ) {

		WARN_ON(ap->sactive & (1 << qc->tag));

		ap->sactive |= 1 << qc->tag;

		WARN_ON(link->sactive & (1 << qc->tag));

		link->sactive |= 1 << qc->tag;

	} else {

		WARN_ON(ap->sactive);

		ap->active_tag = qc->tag;

		WARN_ON(link->sactive);

		link->active_tag = qc->tag;

	}



	qc->flags |= ATA_QCFLAG_ACTIVE;
@@ -5606,7 +5612,7 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc) 
inline unsigned int ata_host_intr (struct ata_port *ap,

				   struct ata_queued_cmd *qc)

{

	struct ata_eh_info *ehi = &ap->eh_info;

	struct ata_eh_info *ehi = &ap->link.eh_info;

	u8 status, host_stat = 0;



	VPRINTK("ata%u: protocol %d task_state %d\n",
@@ -5721,7 +5727,7 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance) 
		    !(ap->flags & ATA_FLAG_DISABLED)) {

			struct ata_queued_cmd *qc;



			qc = ata_qc_from_tag(ap, ap->active_tag);

			qc = ata_qc_from_tag(ap, ap->link.active_tag);

			if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&

			    (qc->flags & ATA_QCFLAG_ACTIVE))

				handled |= ata_host_intr(ap, qc);
@@ -5921,8 +5927,8 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg, 
		}



		ap->pflags |= ATA_PFLAG_PM_PENDING;

		ap->eh_info.action |= action;

		ap->eh_info.flags |= ehi_flags;

		ap->link.eh_info.action |= action;

		ap->link.eh_info.flags |= ehi_flags;



		ata_port_schedule_eh(ap);
@@ -6026,12 +6032,13 @@ int ata_port_start(struct ata_port *ap) 
 */

void ata_dev_init(struct ata_device *dev)

{

	struct ata_port *ap = dev->ap;

	struct ata_link *link = dev->link;

	struct ata_port *ap = link->ap;

	unsigned long flags;



	/* SATA spd limit is bound to the first device */

	ap->sata_spd_limit = ap->hw_sata_spd_limit;

	ap->sata_spd = 0;

	link->sata_spd_limit = link->hw_sata_spd_limit;

	link->sata_spd = 0;



	/* High bits of dev->flags are used to record warm plug

	 * requests which occur asynchronously.  Synchronize using
@@ -6080,8 +6087,8 @@ struct ata_port *ata_port_alloc(struct ata_host *host) 
	ap->host = host;

	ap->dev = host->dev;



	ap->hw_sata_spd_limit = UINT_MAX;

	ap->active_tag = ATA_TAG_POISON;

	ap->link.hw_sata_spd_limit = UINT_MAX;

	ap->link.active_tag = ATA_TAG_POISON;

	ap->last_ctl = 0xFF;



#if defined(ATA_VERBOSE_DEBUG)
@@ -6104,9 +6111,11 @@ struct ata_port *ata_port_alloc(struct ata_host *host) 


	ap->cbl = ATA_CBL_NONE;



	ap->link.ap = ap;



	for (i = 0; i < ATA_MAX_DEVICES; i++) {

		struct ata_device *dev = &ap->device[i];

		dev->ap = ap;

		struct ata_device *dev = &ap->link.device[i];

		dev->link = &ap->link;

		dev->devno = i;

		ata_dev_init(dev);

	}
@@ -6402,9 +6411,9 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 
		if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {

			int spd = (scontrol >> 4) & 0xf;

			if (spd)

				ap->hw_sata_spd_limit &= (1 << spd) - 1;

				ap->link.hw_sata_spd_limit &= (1 << spd) - 1;

		}

		ap->sata_spd_limit = ap->hw_sata_spd_limit;

		ap->link.sata_spd_limit = ap->link.hw_sata_spd_limit;



		/* report the secondary IRQ for second channel legacy */

		irq_line = host->irq;
@@ -6436,7 +6445,7 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht) 


		/* probe */

		if (ap->ops->error_handler) {

			struct ata_eh_info *ehi = &ap->eh_info;

			struct ata_eh_info *ehi = &ap->link.eh_info;

			unsigned long flags;



			ata_port_probe(ap);
@@ -6560,7 +6569,7 @@ void ata_port_detach(struct ata_port *ap) 
	spin_lock_irqsave(ap->lock, flags);



	for (i = 0; i < ATA_MAX_DEVICES; i++)

		ata_dev_disable(&ap->device[i]);

		ata_dev_disable(&ap->link.device[i]);



	spin_unlock_irqrestore(ap->lock, flags);

drivers/ata/libata-eh.c

+51 −49

File changed.

Preview size limit exceeded, changes collapsed.