Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev (b312bf35) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/ata/ahci.c

+325 −6

Original line number	Diff line number	Diff line
		@@ -56,6 +56,12 @@ MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)
		static int ahci_enable_alpm(struct ata_port *ap,
		enum link_pm policy);
		static void ahci_disable_alpm(struct ata_port *ap);
		static ssize_t ahci_led_show(struct ata_port ap, char buf);
		static ssize_t ahci_led_store(struct ata_port ap, const char buf,
		size_t size);
		static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
		ssize_t size);
		#define MAX_SLOTS 8

		enum {
		AHCI_PCI_BAR = 5,
		@@ -98,6 +104,8 @@ enum {
		HOST_IRQ_STAT = 0x08, /* interrupt status */
		HOST_PORTS_IMPL = 0x0c, /* bitmap of implemented ports */
		HOST_VERSION = 0x10, /* AHCI spec. version compliancy */
		HOST_EM_LOC = 0x1c, /* Enclosure Management location */
		HOST_EM_CTL = 0x20, /* Enclosure Management Control */

		/* HOST_CTL bits */
		HOST_RESET = (1 << 0), /* reset controller; self-clear */
		@@ -105,6 +113,7 @@ enum {
		HOST_AHCI_EN = (1 << 31), /* AHCI enabled */

		/* HOST_CAP bits */
		HOST_CAP_EMS = (1 << 6), /* Enclosure Management support */
		HOST_CAP_SSC = (1 << 14), /* Slumber capable */
		HOST_CAP_PMP = (1 << 17), /* Port Multiplier support */
		HOST_CAP_CLO = (1 << 24), /* Command List Override support */
		@@ -202,6 +211,11 @@ enum {
		ATA_FLAG_IPM,

		ICH_MAP = 0x90, /* ICH MAP register */

		/* em_ctl bits */
		EM_CTL_RST = (1 << 9), /* Reset */
		EM_CTL_TM = (1 << 8), /* Transmit Message */
		EM_CTL_ALHD = (1 << 26), /* Activity LED */
		};

		struct ahci_cmd_hdr {
		@@ -219,12 +233,21 @@ struct ahci_sg {
		__le32 flags_size;
		};

		struct ahci_em_priv {
		enum sw_activity blink_policy;
		struct timer_list timer;
		unsigned long saved_activity;
		unsigned long activity;
		unsigned long led_state;
		};

		struct ahci_host_priv {
		unsigned int flags; /* AHCI_HFLAG_* */
		u32 cap; /* cap to use */
		u32 port_map; /* port map to use */
		u32 saved_cap; /* saved initial cap */
		u32 saved_port_map; /* saved initial port_map */
		u32 em_loc; /* enclosure management location */
		};

		struct ahci_port_priv {
		@@ -240,6 +263,8 @@ struct ahci_port_priv {
		unsigned int ncq_saw_dmas:1;
		unsigned int ncq_saw_sdb:1;
		u32 intr_mask; /* interrupts to enable */
		struct ahci_em_priv em_priv[MAX_SLOTS];/* enclosure management info
		* per PM slot */
		};

		static int ahci_scr_read(struct ata_port ap, unsigned int sc_reg, u32 val);
		@@ -277,9 +302,20 @@ static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
		static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
		static int ahci_pci_device_resume(struct pci_dev *pdev);
		#endif
		static ssize_t ahci_activity_show(struct ata_device dev, char buf);
		static ssize_t ahci_activity_store(struct ata_device *dev,
		enum sw_activity val);
		static void ahci_init_sw_activity(struct ata_link *link);

		static struct device_attribute *ahci_shost_attrs[] = {
		&dev_attr_link_power_management_policy,
		&dev_attr_em_message_type,
		&dev_attr_em_message,
		NULL
		};

		static struct device_attribute *ahci_sdev_attrs[] = {
		&dev_attr_sw_activity,
		NULL
		};

		@@ -289,6 +325,7 @@ static struct scsi_host_template ahci_sht = {
		.sg_tablesize = AHCI_MAX_SG,
		.dma_boundary = AHCI_DMA_BOUNDARY,
		.shost_attrs = ahci_shost_attrs,
		.sdev_attrs = ahci_sdev_attrs,
		};

		static struct ata_port_operations ahci_ops = {
		@@ -316,6 +353,10 @@ static struct ata_port_operations ahci_ops = {

		.enable_pm = ahci_enable_alpm,
		.disable_pm = ahci_disable_alpm,
		.em_show = ahci_led_show,
		.em_store = ahci_led_store,
		.sw_activity_show = ahci_activity_show,
		.sw_activity_store = ahci_activity_store,
		#ifdef CONFIG_PM
		.port_suspend = ahci_port_suspend,
		.port_resume = ahci_port_resume,
		@@ -561,6 +602,11 @@ static struct pci_driver ahci_pci_driver = {
		#endif
		};

		static int ahci_em_messages = 1;
		module_param(ahci_em_messages, int, 0444);
		/* add other LED protocol types when they become supported */
		MODULE_PARM_DESC(ahci_em_messages,
		"Set AHCI Enclosure Management Message type (0 = disabled, 1 = LED");

		static inline int ahci_nr_ports(u32 cap)
		{
		@@ -1031,11 +1077,28 @@ static void ahci_power_down(struct ata_port *ap)

		static void ahci_start_port(struct ata_port *ap)
		{
		struct ahci_port_priv *pp = ap->private_data;
		struct ata_link *link;
		struct ahci_em_priv *emp;

		/* enable FIS reception */
		ahci_start_fis_rx(ap);

		/* enable DMA */
		ahci_start_engine(ap);

		/* turn on LEDs */
		if (ap->flags & ATA_FLAG_EM) {
		ata_port_for_each_link(link, ap) {
		emp = &pp->em_priv[link->pmp];
		ahci_transmit_led_message(ap, emp->led_state, 4);
		}
		}

		if (ap->flags & ATA_FLAG_SW_ACTIVITY)
		ata_port_for_each_link(link, ap)
		ahci_init_sw_activity(link);

		}

		static int ahci_deinit_port(struct ata_port ap, const char *emsg)
		@@ -1079,12 +1142,15 @@ static int ahci_reset_controller(struct ata_host *host)
		readl(mmio + HOST_CTL); /* flush */
		}

		/* reset must complete within 1 second, or
		/*
		* to perform host reset, OS should set HOST_RESET
		* and poll until this bit is read to be "0".
		* reset must complete within 1 second, or
		* the hardware should be considered fried.
		*/
		ssleep(1);
		tmp = ata_wait_register(mmio + HOST_CTL, HOST_RESET,
		HOST_RESET, 10, 1000);

		tmp = readl(mmio + HOST_CTL);
		if (tmp & HOST_RESET) {
		dev_printk(KERN_ERR, host->dev,
		"controller reset failed (0x%x)\n", tmp);
		@@ -1116,6 +1182,230 @@ static int ahci_reset_controller(struct ata_host *host)
		return 0;
		}

		static void ahci_sw_activity(struct ata_link *link)
		{
		struct ata_port *ap = link->ap;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp = &pp->em_priv[link->pmp];

		if (!(link->flags & ATA_LFLAG_SW_ACTIVITY))
		return;

		emp->activity++;
		if (!timer_pending(&emp->timer))
		mod_timer(&emp->timer, jiffies + msecs_to_jiffies(10));
		}

		static void ahci_sw_activity_blink(unsigned long arg)
		{
		struct ata_link link = (struct ata_link )arg;
		struct ata_port *ap = link->ap;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
		unsigned long led_message = emp->led_state;
		u32 activity_led_state;

		led_message &= 0xffff0000;
		led_message \|= ap->port_no \| (link->pmp << 8);

		/* check to see if we've had activity. If so,
		* toggle state of LED and reset timer. If not,
		* turn LED to desired idle state.
		*/
		if (emp->saved_activity != emp->activity) {
		emp->saved_activity = emp->activity;
		/* get the current LED state */
		activity_led_state = led_message & 0x00010000;

		if (activity_led_state)
		activity_led_state = 0;
		else
		activity_led_state = 1;

		/* clear old state */
		led_message &= 0xfff8ffff;

		/* toggle state */
		led_message \|= (activity_led_state << 16);
		mod_timer(&emp->timer, jiffies + msecs_to_jiffies(100));
		} else {
		/* switch to idle */
		led_message &= 0xfff8ffff;
		if (emp->blink_policy == BLINK_OFF)
		led_message \|= (1 << 16);
		}
		ahci_transmit_led_message(ap, led_message, 4);
		}

		static void ahci_init_sw_activity(struct ata_link *link)
		{
		struct ata_port *ap = link->ap;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp = &pp->em_priv[link->pmp];

		/* init activity stats, setup timer */
		emp->saved_activity = emp->activity = 0;
		setup_timer(&emp->timer, ahci_sw_activity_blink, (unsigned long)link);

		/* check our blink policy and set flag for link if it's enabled */
		if (emp->blink_policy)
		link->flags \|= ATA_LFLAG_SW_ACTIVITY;
		}

		static int ahci_reset_em(struct ata_host *host)
		{
		void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
		u32 em_ctl;

		em_ctl = readl(mmio + HOST_EM_CTL);
		if ((em_ctl & EM_CTL_TM) \|\| (em_ctl & EM_CTL_RST))
		return -EINVAL;

		writel(em_ctl \| EM_CTL_RST, mmio + HOST_EM_CTL);
		return 0;
		}

		static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
		ssize_t size)
		{
		struct ahci_host_priv *hpriv = ap->host->private_data;
		struct ahci_port_priv *pp = ap->private_data;
		void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
		u32 em_ctl;
		u32 message[] = {0, 0};
		unsigned int flags;
		int pmp;
		struct ahci_em_priv *emp;

		/* get the slot number from the message */
		pmp = (state & 0x0000ff00) >> 8;
		if (pmp < MAX_SLOTS)
		emp = &pp->em_priv[pmp];
		else
		return -EINVAL;

		spin_lock_irqsave(ap->lock, flags);

		/*
		* if we are still busy transmitting a previous message,
		* do not allow
		*/
		em_ctl = readl(mmio + HOST_EM_CTL);
		if (em_ctl & EM_CTL_TM) {
		spin_unlock_irqrestore(ap->lock, flags);
		return -EINVAL;
		}

		/*
		* create message header - this is all zero except for
		* the message size, which is 4 bytes.
		*/
		message[0] \|= (4 << 8);

		/* ignore 0:4 of byte zero, fill in port info yourself */
		message[1] = ((state & 0xfffffff0) \| ap->port_no);

		/* write message to EM_LOC */
		writel(message[0], mmio + hpriv->em_loc);
		writel(message[1], mmio + hpriv->em_loc+4);

		/* save off new led state for port/slot */
		emp->led_state = message[1];

		/*
		* tell hardware to transmit the message
		*/
		writel(em_ctl \| EM_CTL_TM, mmio + HOST_EM_CTL);

		spin_unlock_irqrestore(ap->lock, flags);
		return size;
		}

		static ssize_t ahci_led_show(struct ata_port ap, char buf)
		{
		struct ahci_port_priv *pp = ap->private_data;
		struct ata_link *link;
		struct ahci_em_priv *emp;
		int rc = 0;

		ata_port_for_each_link(link, ap) {
		emp = &pp->em_priv[link->pmp];
		rc += sprintf(buf, "%lx\n", emp->led_state);
		}
		return rc;
		}

		static ssize_t ahci_led_store(struct ata_port ap, const char buf,
		size_t size)
		{
		int state;
		int pmp;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp;

		state = simple_strtoul(buf, NULL, 0);

		/* get the slot number from the message */
		pmp = (state & 0x0000ff00) >> 8;
		if (pmp < MAX_SLOTS)
		emp = &pp->em_priv[pmp];
		else
		return -EINVAL;

		/* mask off the activity bits if we are in sw_activity
		* mode, user should turn off sw_activity before setting
		* activity led through em_message
		*/
		if (emp->blink_policy)
		state &= 0xfff8ffff;

		return ahci_transmit_led_message(ap, state, size);
		}

		static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val)
		{
		struct ata_link *link = dev->link;
		struct ata_port *ap = link->ap;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
		u32 port_led_state = emp->led_state;

		/* save the desired Activity LED behavior */
		if (val == OFF) {
		/* clear LFLAG */
		link->flags &= ~(ATA_LFLAG_SW_ACTIVITY);

		/* set the LED to OFF */
		port_led_state &= 0xfff80000;
		port_led_state \|= (ap->port_no \| (link->pmp << 8));
		ahci_transmit_led_message(ap, port_led_state, 4);
		} else {
		link->flags \|= ATA_LFLAG_SW_ACTIVITY;
		if (val == BLINK_OFF) {
		/* set LED to ON for idle */
		port_led_state &= 0xfff80000;
		port_led_state \|= (ap->port_no \| (link->pmp << 8));
		port_led_state \|= 0x00010000; /* check this */
		ahci_transmit_led_message(ap, port_led_state, 4);
		}
		}
		emp->blink_policy = val;
		return 0;
		}

		static ssize_t ahci_activity_show(struct ata_device dev, char buf)
		{
		struct ata_link *link = dev->link;
		struct ata_port *ap = link->ap;
		struct ahci_port_priv *pp = ap->private_data;
		struct ahci_em_priv *emp = &pp->em_priv[link->pmp];

		/* display the saved value of activity behavior for this
		* disk.
		*/
		return sprintf(buf, "%d\n", emp->blink_policy);
		}

		static void ahci_port_init(struct pci_dev pdev, struct ata_port ap,
		int port_no, void __iomem *mmio,
		void __iomem *port_mmio)
		@@ -1846,7 +2136,8 @@ static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
		if (qc->tf.protocol == ATA_PROT_NCQ)
		writel(1 << qc->tag, port_mmio + PORT_SCR_ACT);
		writel(1 << qc->tag, port_mmio + PORT_CMD_ISSUE);
		readl(port_mmio + PORT_CMD_ISSUE); /* flush */

		ahci_sw_activity(qc->dev->link);

		return 0;
		}
		@@ -2154,7 +2445,8 @@ static void ahci_print_info(struct ata_host *host)
		dev_printk(KERN_INFO, &pdev->dev,
		"flags: "
		"%s%s%s%s%s%s%s"
		"%s%s%s%s%s%s%s\n"
		"%s%s%s%s%s%s%s"
		"%s\n"
		,

		cap & (1 << 31) ? "64bit " : "",
		@@ -2171,7 +2463,8 @@ static void ahci_print_info(struct ata_host *host)
		cap & (1 << 17) ? "pmp " : "",
		cap & (1 << 15) ? "pio " : "",
		cap & (1 << 14) ? "slum " : "",
		cap & (1 << 13) ? "part " : ""
		cap & (1 << 13) ? "part " : "",
		cap & (1 << 6) ? "ems ": ""
		);
		}

		@@ -2291,6 +2584,24 @@ static int ahci_init_one(struct pci_dev pdev, const struct pci_device_id ent)
		if (hpriv->cap & HOST_CAP_PMP)
		pi.flags \|= ATA_FLAG_PMP;

		if (ahci_em_messages && (hpriv->cap & HOST_CAP_EMS)) {
		u8 messages;
		void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
		u32 em_loc = readl(mmio + HOST_EM_LOC);
		u32 em_ctl = readl(mmio + HOST_EM_CTL);

		messages = (em_ctl & 0x000f0000) >> 16;

		/* we only support LED message type right now */
		if ((messages & 0x01) && (ahci_em_messages == 1)) {
		/* store em_loc */
		hpriv->em_loc = ((em_loc >> 16) * 4);
		pi.flags \|= ATA_FLAG_EM;
		if (!(em_ctl & EM_CTL_ALHD))
		pi.flags \|= ATA_FLAG_SW_ACTIVITY;
		}
		}

		/* CAP.NP sometimes indicate the index of the last enabled
		* port, at other times, that of the last possible port, so
		* determining the maximum port number requires looking at
		@@ -2304,6 +2615,9 @@ static int ahci_init_one(struct pci_dev pdev, const struct pci_device_id ent)
		host->iomap = pcim_iomap_table(pdev);
		host->private_data = hpriv;

		if (pi.flags & ATA_FLAG_EM)
		ahci_reset_em(host);

		for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

		@@ -2314,6 +2628,11 @@ static int ahci_init_one(struct pci_dev pdev, const struct pci_device_id ent)
		/* set initial link pm policy */
		ap->pm_policy = NOT_AVAILABLE;

		/* set enclosure management message type */
		if (ap->flags & ATA_FLAG_EM)
		ap->em_message_type = ahci_em_messages;


		/* disabled/not-implemented port */
		if (!(hpriv->port_map & (1 << i)))
		ap->ops = &ata_dummy_port_ops;

drivers/ata/libata-core.c

+32 −24

Original line number	Diff line number	Diff line
		@@ -54,7 +54,6 @@
		#include <linux/completion.h>
		#include <linux/suspend.h>
		#include <linux/workqueue.h>
		#include <linux/jiffies.h>
		#include <linux/scatterlist.h>
		#include <linux/io.h>
		#include <scsi/scsi.h>
		@@ -145,7 +144,7 @@ static int libata_dma_mask = ATA_DMA_MASK_ATA\|ATA_DMA_MASK_ATAPI\|ATA_DMA_MASK_CF
		module_param_named(dma, libata_dma_mask, int, 0444);
		MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");

		static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
		static int ata_probe_timeout;
		module_param(ata_probe_timeout, int, 0444);
		MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");

		@@ -1533,7 +1532,7 @@ unsigned long ata_id_xfermask(const u16 *id)
		* @ap: The ata_port to queue port_task for
		* @fn: workqueue function to be scheduled
		* @data: data for @fn to use
		* @delay: delay time for workqueue function
		* @delay: delay time in msecs for workqueue function
		*
		* Schedule @fn(@data) for execution after @delay jiffies using
		* port_task. There is one port_task per port and it's the
		@@ -1552,7 +1551,7 @@ void ata_pio_queue_task(struct ata_port ap, void data, unsigned long delay)
		ap->port_task_data = data;

		/* may fail if ata_port_flush_task() in progress */
		queue_delayed_work(ata_wq, &ap->port_task, delay);
		queue_delayed_work(ata_wq, &ap->port_task, msecs_to_jiffies(delay));
		}

		/**
		@@ -1612,6 +1611,7 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
		struct ata_link *link = dev->link;
		struct ata_port *ap = link->ap;
		u8 command = tf->command;
		int auto_timeout = 0;
		struct ata_queued_cmd *qc;
		unsigned int tag, preempted_tag;
		u32 preempted_sactive, preempted_qc_active;
		@@ -1684,8 +1684,14 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,

		spin_unlock_irqrestore(ap->lock, flags);

		if (!timeout)
		timeout = ata_probe_timeout * 1000 / HZ;
		if (!timeout) {
		if (ata_probe_timeout)
		timeout = ata_probe_timeout * 1000;
		else {
		timeout = ata_internal_cmd_timeout(dev, command);
		auto_timeout = 1;
		}
		}

		rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));

		@@ -1761,6 +1767,9 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,

		spin_unlock_irqrestore(ap->lock, flags);

		if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
		ata_internal_cmd_timed_out(dev, command);

		return err_mask;
		}

		@@ -3319,7 +3328,7 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
		int (check_ready)(struct ata_link link))
		{
		unsigned long start = jiffies;
		unsigned long nodev_deadline = start + ATA_TMOUT_FF_WAIT;
		unsigned long nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
		int warned = 0;

		if (time_after(nodev_deadline, deadline))
		@@ -3387,7 +3396,7 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
		int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
		int (check_ready)(struct ata_link link))
		{
		msleep(ATA_WAIT_AFTER_RESET_MSECS);
		msleep(ATA_WAIT_AFTER_RESET);

		return ata_wait_ready(link, deadline, check_ready);
		}
		@@ -3417,13 +3426,13 @@ int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
		int sata_link_debounce(struct ata_link link, const unsigned long params,
		unsigned long deadline)
		{
		unsigned long interval_msec = params[0];
		unsigned long duration = msecs_to_jiffies(params[1]);
		unsigned long interval = params[0];
		unsigned long duration = params[1];
		unsigned long last_jiffies, t;
		u32 last, cur;
		int rc;

		t = jiffies + msecs_to_jiffies(params[2]);
		t = ata_deadline(jiffies, params[2]);
		if (time_before(t, deadline))
		deadline = t;

		@@ -3435,7 +3444,7 @@ int sata_link_debounce(struct ata_link link, const unsigned long params,
		last_jiffies = jiffies;

		while (1) {
		msleep(interval_msec);
		msleep(interval);
		if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
		return rc;
		cur &= 0xf;
		@@ -3444,7 +3453,8 @@ int sata_link_debounce(struct ata_link link, const unsigned long params,
		if (cur == last) {
		if (cur == 1 && time_before(jiffies, deadline))
		continue;
		if (time_after(jiffies, last_jiffies + duration))
		if (time_after(jiffies,
		ata_deadline(last_jiffies, duration)))
		return 0;
		continue;
		}
		@@ -3636,7 +3646,8 @@ int sata_link_hardreset(struct ata_link link, const unsigned long timing,
		if (check_ready) {
		unsigned long pmp_deadline;

		pmp_deadline = jiffies + ATA_TMOUT_PMP_SRST_WAIT;
		pmp_deadline = ata_deadline(jiffies,
		ATA_TMOUT_PMP_SRST_WAIT);
		if (time_after(pmp_deadline, deadline))
		pmp_deadline = deadline;
		ata_wait_ready(link, pmp_deadline, check_ready);
		@@ -6073,8 +6084,6 @@ static void __init ata_parse_force_param(void)

		static int __init ata_init(void)
		{
		ata_probe_timeout *= HZ;

		ata_parse_force_param();

		ata_wq = create_workqueue("ata");
		@@ -6127,8 +6136,8 @@ int ata_ratelimit(void)
		* @reg: IO-mapped register
		* @mask: Mask to apply to read register value
		* @val: Wait condition
		* @interval_msec: polling interval in milliseconds
		* @timeout_msec: timeout in milliseconds
		* @interval: polling interval in milliseconds
		* @timeout: timeout in milliseconds
		*
		* Waiting for some bits of register to change is a common
		* operation for ATA controllers. This function reads 32bit LE
		@@ -6146,10 +6155,9 @@ int ata_ratelimit(void)
		* The final register value.
		*/
		u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
		unsigned long interval_msec,
		unsigned long timeout_msec)
		unsigned long interval, unsigned long timeout)
		{
		unsigned long timeout;
		unsigned long deadline;
		u32 tmp;

		tmp = ioread32(reg);
		@@ -6158,10 +6166,10 @@ u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
		* preceding writes reach the controller before starting to
		* eat away the timeout.
		*/
		timeout = jiffies + (timeout_msec * HZ) / 1000;
		deadline = ata_deadline(jiffies, timeout);

		while ((tmp & mask) == val && time_before(jiffies, timeout)) {
		msleep(interval_msec);
		while ((tmp & mask) == val && time_before(jiffies, deadline)) {
		msleep(interval);
		tmp = ioread32(reg);
		}

drivers/ata/libata-eh.c

+171 −48

File changed.

Preview size limit exceeded, changes collapsed.

drivers/ata/libata-pmp.c

+2 −11

Original line number	Diff line number	Diff line
		@@ -727,19 +727,12 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
		}

		if (tries) {
		int sleep = ehc->i.flags & ATA_EHI_DID_RESET;

		/* consecutive revalidation failures? speed down */
		if (reval_failed)
		sata_down_spd_limit(link);
		else
		reval_failed = 1;

		ata_dev_printk(dev, KERN_WARNING,
		"retrying reset%s\n",
		sleep ? " in 5 secs" : "");
		if (sleep)
		ssleep(5);
		ehc->i.action \|= ATA_EH_RESET;
		goto retry;
		} else {
		@@ -785,7 +778,8 @@ static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
		* SError.N working.
		*/
		sata_link_hardreset(link, sata_deb_timing_normal,
		jiffies + ATA_TMOUT_INTERNAL_QUICK, NULL, NULL);
		ata_deadline(jiffies, ATA_TMOUT_INTERNAL_QUICK),
		NULL, NULL);

		/* unconditionally clear SError.N */
		rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
		@@ -990,10 +984,7 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
		goto retry;

		if (--pmp_tries) {
		ata_port_printk(ap, KERN_WARNING,
		"failed to recover PMP, retrying in 5 secs\n");
		pmp_ehc->i.action \|= ATA_EH_RESET;
		ssleep(5);
		goto retry;
		}

drivers/ata/libata-scsi.c

+98 −1

Original line number	Diff line number	Diff line
		@@ -190,6 +190,85 @@ static void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
		scsi_build_sense_buffer(0, cmd->sense_buffer, sk, asc, ascq);
		}

		static ssize_t
		ata_scsi_em_message_store(struct device dev, struct device_attribute attr,
		const char *buf, size_t count)
		{
		struct Scsi_Host *shost = class_to_shost(dev);
		struct ata_port *ap = ata_shost_to_port(shost);
		if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM))
		return ap->ops->em_store(ap, buf, count);
		return -EINVAL;
		}

		static ssize_t
		ata_scsi_em_message_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		struct Scsi_Host *shost = class_to_shost(dev);
		struct ata_port *ap = ata_shost_to_port(shost);

		if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM))
		return ap->ops->em_show(ap, buf);
		return -EINVAL;
		}
		DEVICE_ATTR(em_message, S_IRUGO \| S_IWUGO,
		ata_scsi_em_message_show, ata_scsi_em_message_store);
		EXPORT_SYMBOL_GPL(dev_attr_em_message);

		static ssize_t
		ata_scsi_em_message_type_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		struct Scsi_Host *shost = class_to_shost(dev);
		struct ata_port *ap = ata_shost_to_port(shost);

		return snprintf(buf, 23, "%d\n", ap->em_message_type);
		}
		DEVICE_ATTR(em_message_type, S_IRUGO,
		ata_scsi_em_message_type_show, NULL);
		EXPORT_SYMBOL_GPL(dev_attr_em_message_type);

		static ssize_t
		ata_scsi_activity_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		struct scsi_device *sdev = to_scsi_device(dev);
		struct ata_port *ap = ata_shost_to_port(sdev->host);
		struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);

		if (ap->ops->sw_activity_show && (ap->flags & ATA_FLAG_SW_ACTIVITY))
		return ap->ops->sw_activity_show(atadev, buf);
		return -EINVAL;
		}

		static ssize_t
		ata_scsi_activity_store(struct device dev, struct device_attribute attr,
		const char *buf, size_t count)
		{
		struct scsi_device *sdev = to_scsi_device(dev);
		struct ata_port *ap = ata_shost_to_port(sdev->host);
		struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
		enum sw_activity val;
		int rc;

		if (ap->ops->sw_activity_store && (ap->flags & ATA_FLAG_SW_ACTIVITY)) {
		val = simple_strtoul(buf, NULL, 0);
		switch (val) {
		case OFF: case BLINK_ON: case BLINK_OFF:
		rc = ap->ops->sw_activity_store(atadev, val);
		if (!rc)
		return count;
		else
		return rc;
		}
		}
		return -EINVAL;
		}
		DEVICE_ATTR(sw_activity, S_IWUGO \| S_IRUGO, ata_scsi_activity_show,
		ata_scsi_activity_store);
		EXPORT_SYMBOL_GPL(dev_attr_sw_activity);

		static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
		void (done)(struct scsi_cmnd ))
		{
		@@ -1779,7 +1858,9 @@ static unsigned int ata_scsiop_inq_00(struct ata_scsi_args args, u8 rbuf)
		const u8 pages[] = {
		0x00, /* page 0x00, this page */
		0x80, /* page 0x80, unit serial no page */
		0x83 /* page 0x83, device ident page */
		0x83, /* page 0x83, device ident page */
		0x89, /* page 0x89, ata info page */
		0xb1, /* page 0xb1, block device characteristics page */
		};

		rbuf[3] = sizeof(pages); /* number of supported VPD pages */
		@@ -1900,6 +1981,19 @@ static unsigned int ata_scsiop_inq_89(struct ata_scsi_args args, u8 rbuf)
		return 0;
		}

		static unsigned int ata_scsiop_inq_b1(struct ata_scsi_args args, u8 rbuf)
		{
		rbuf[1] = 0xb1;
		rbuf[3] = 0x3c;
		if (ata_id_major_version(args->id) > 7) {
		rbuf[4] = args->id[217] >> 8;
		rbuf[5] = args->id[217];
		rbuf[7] = args->id[168] & 0xf;
		}

		return 0;
		}

		/**
		* ata_scsiop_noop - Command handler that simply returns success.
		* @args: device IDENTIFY data / SCSI command of interest.
		@@ -2921,6 +3015,9 @@ void ata_scsi_simulate(struct ata_device dev, struct scsi_cmnd cmd,
		case 0x89:
		ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
		break;
		case 0xb1:
		ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b1);
		break;
		default:
		ata_scsi_invalid_field(cmd, done);
		break;