1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * SATA specific part of ATA helper library
5 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
6 * Copyright 2003-2004 Jeff Garzik
7 * Copyright 2006 Tejun Heo <htejun@gmail.com>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <scsi/scsi_cmnd.h>
13 #include <scsi/scsi_device.h>
14 #include <linux/libata.h>
17 #include "libata-transport.h"
19 /* debounce timing parameters in msecs { interval, duration, timeout } */
20 const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 };
21 EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
22 const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 };
23 EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
24 const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 };
25 EXPORT_SYMBOL_GPL(sata_deb_timing_long);
28 * sata_scr_valid - test whether SCRs are accessible
29 * @link: ATA link to test SCR accessibility for
31 * Test whether SCRs are accessible for @link.
37 * 1 if SCRs are accessible, 0 otherwise.
39 int sata_scr_valid(struct ata_link *link)
41 struct ata_port *ap = link->ap;
43 return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
45 EXPORT_SYMBOL_GPL(sata_scr_valid);
48 * sata_scr_read - read SCR register of the specified port
49 * @link: ATA link to read SCR for
51 * @val: Place to store read value
53 * Read SCR register @reg of @link into *@val. This function is
54 * guaranteed to succeed if @link is ap->link, the cable type of
55 * the port is SATA and the port implements ->scr_read.
58 * None if @link is ap->link. Kernel thread context otherwise.
61 * 0 on success, negative errno on failure.
63 int sata_scr_read(struct ata_link *link, int reg, u32 *val)
65 if (ata_is_host_link(link)) {
66 if (sata_scr_valid(link))
67 return link->ap->ops->scr_read(link, reg, val);
71 return sata_pmp_scr_read(link, reg, val);
73 EXPORT_SYMBOL_GPL(sata_scr_read);
76 * sata_scr_write - write SCR register of the specified port
77 * @link: ATA link to write SCR for
79 * @val: value to write
81 * Write @val to SCR register @reg of @link. This function is
82 * guaranteed to succeed if @link is ap->link, the cable type of
83 * the port is SATA and the port implements ->scr_read.
86 * None if @link is ap->link. Kernel thread context otherwise.
89 * 0 on success, negative errno on failure.
91 int sata_scr_write(struct ata_link *link, int reg, u32 val)
93 if (ata_is_host_link(link)) {
94 if (sata_scr_valid(link))
95 return link->ap->ops->scr_write(link, reg, val);
99 return sata_pmp_scr_write(link, reg, val);
101 EXPORT_SYMBOL_GPL(sata_scr_write);
104 * sata_scr_write_flush - write SCR register of the specified port and flush
105 * @link: ATA link to write SCR for
107 * @val: value to write
109 * This function is identical to sata_scr_write() except that this
110 * function performs flush after writing to the register.
113 * None if @link is ap->link. Kernel thread context otherwise.
116 * 0 on success, negative errno on failure.
118 int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
120 if (ata_is_host_link(link)) {
123 if (sata_scr_valid(link)) {
124 rc = link->ap->ops->scr_write(link, reg, val);
126 rc = link->ap->ops->scr_read(link, reg, &val);
132 return sata_pmp_scr_write(link, reg, val);
134 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
137 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
138 * @tf: Taskfile to convert
139 * @pmp: Port multiplier port
140 * @is_cmd: This FIS is for command
141 * @fis: Buffer into which data will output
143 * Converts a standard ATA taskfile to a Serial ATA
144 * FIS structure (Register - Host to Device).
147 * Inherited from caller.
149 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
151 fis[0] = 0x27; /* Register - Host to Device FIS */
152 fis[1] = pmp & 0xf; /* Port multiplier number*/
154 fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */
156 fis[2] = tf->command;
157 fis[3] = tf->feature;
164 fis[8] = tf->hob_lbal;
165 fis[9] = tf->hob_lbam;
166 fis[10] = tf->hob_lbah;
167 fis[11] = tf->hob_feature;
170 fis[13] = tf->hob_nsect;
174 fis[16] = tf->auxiliary & 0xff;
175 fis[17] = (tf->auxiliary >> 8) & 0xff;
176 fis[18] = (tf->auxiliary >> 16) & 0xff;
177 fis[19] = (tf->auxiliary >> 24) & 0xff;
179 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
182 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
183 * @fis: Buffer from which data will be input
184 * @tf: Taskfile to output
186 * Converts a serial ATA FIS structure to a standard ATA taskfile.
189 * Inherited from caller.
192 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
194 tf->command = fis[2]; /* status */
195 tf->feature = fis[3]; /* error */
202 tf->hob_lbal = fis[8];
203 tf->hob_lbam = fis[9];
204 tf->hob_lbah = fis[10];
207 tf->hob_nsect = fis[13];
209 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
212 * sata_link_debounce - debounce SATA phy status
213 * @link: ATA link to debounce SATA phy status for
214 * @params: timing parameters { interval, duration, timeout } in msec
215 * @deadline: deadline jiffies for the operation
217 * Make sure SStatus of @link reaches stable state, determined by
218 * holding the same value where DET is not 1 for @duration polled
219 * every @interval, before @timeout. Timeout constraints the
220 * beginning of the stable state. Because DET gets stuck at 1 on
221 * some controllers after hot unplugging, this functions waits
222 * until timeout then returns 0 if DET is stable at 1.
224 * @timeout is further limited by @deadline. The sooner of the
228 * Kernel thread context (may sleep)
231 * 0 on success, -errno on failure.
233 int sata_link_debounce(struct ata_link *link, const unsigned long *params,
234 unsigned long deadline)
236 unsigned long interval = params[0];
237 unsigned long duration = params[1];
238 unsigned long last_jiffies, t;
242 t = ata_deadline(jiffies, params[2]);
243 if (time_before(t, deadline))
246 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
251 last_jiffies = jiffies;
254 ata_msleep(link->ap, interval);
255 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
261 if (cur == 1 && time_before(jiffies, deadline))
263 if (time_after(jiffies,
264 ata_deadline(last_jiffies, duration)))
269 /* unstable, start over */
271 last_jiffies = jiffies;
273 /* Check deadline. If debouncing failed, return
274 * -EPIPE to tell upper layer to lower link speed.
276 if (time_after(jiffies, deadline))
280 EXPORT_SYMBOL_GPL(sata_link_debounce);
283 * sata_link_resume - resume SATA link
284 * @link: ATA link to resume SATA
285 * @params: timing parameters { interval, duration, timeout } in msec
286 * @deadline: deadline jiffies for the operation
288 * Resume SATA phy @link and debounce it.
291 * Kernel thread context (may sleep)
294 * 0 on success, -errno on failure.
296 int sata_link_resume(struct ata_link *link, const unsigned long *params,
297 unsigned long deadline)
299 int tries = ATA_LINK_RESUME_TRIES;
300 u32 scontrol, serror;
303 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
307 * Writes to SControl sometimes get ignored under certain
308 * controllers (ata_piix SIDPR). Make sure DET actually is
312 scontrol = (scontrol & 0x0f0) | 0x300;
313 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
316 * Some PHYs react badly if SStatus is pounded
317 * immediately after resuming. Delay 200ms before
320 if (!(link->flags & ATA_LFLAG_NO_DEBOUNCE_DELAY))
321 ata_msleep(link->ap, 200);
323 /* is SControl restored correctly? */
324 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
326 } while ((scontrol & 0xf0f) != 0x300 && --tries);
328 if ((scontrol & 0xf0f) != 0x300) {
329 ata_link_warn(link, "failed to resume link (SControl %X)\n",
334 if (tries < ATA_LINK_RESUME_TRIES)
335 ata_link_warn(link, "link resume succeeded after %d retries\n",
336 ATA_LINK_RESUME_TRIES - tries);
338 if ((rc = sata_link_debounce(link, params, deadline)))
341 /* clear SError, some PHYs require this even for SRST to work */
342 if (!(rc = sata_scr_read(link, SCR_ERROR, &serror)))
343 rc = sata_scr_write(link, SCR_ERROR, serror);
345 return rc != -EINVAL ? rc : 0;
347 EXPORT_SYMBOL_GPL(sata_link_resume);
350 * sata_link_scr_lpm - manipulate SControl IPM and SPM fields
351 * @link: ATA link to manipulate SControl for
352 * @policy: LPM policy to configure
353 * @spm_wakeup: initiate LPM transition to active state
355 * Manipulate the IPM field of the SControl register of @link
356 * according to @policy. If @policy is ATA_LPM_MAX_POWER and
357 * @spm_wakeup is %true, the SPM field is manipulated to wake up
358 * the link. This function also clears PHYRDY_CHG before
365 * 0 on success, -errno otherwise.
367 int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
370 struct ata_eh_context *ehc = &link->eh_context;
371 bool woken_up = false;
375 rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
380 case ATA_LPM_MAX_POWER:
381 /* disable all LPM transitions */
382 scontrol |= (0x7 << 8);
383 /* initiate transition to active state */
385 scontrol |= (0x4 << 12);
389 case ATA_LPM_MED_POWER:
390 /* allow LPM to PARTIAL */
391 scontrol &= ~(0x1 << 8);
392 scontrol |= (0x6 << 8);
394 case ATA_LPM_MED_POWER_WITH_DIPM:
395 case ATA_LPM_MIN_POWER_WITH_PARTIAL:
396 case ATA_LPM_MIN_POWER:
397 if (ata_link_nr_enabled(link) > 0) {
398 /* assume no restrictions on LPM transitions */
399 scontrol &= ~(0x7 << 8);
402 * If the controller does not support partial, slumber,
403 * or devsleep, then disallow these transitions.
405 if (link->ap->host->flags & ATA_HOST_NO_PART)
406 scontrol |= (0x1 << 8);
408 if (link->ap->host->flags & ATA_HOST_NO_SSC)
409 scontrol |= (0x2 << 8);
411 if (link->ap->host->flags & ATA_HOST_NO_DEVSLP)
412 scontrol |= (0x4 << 8);
414 /* empty port, power off */
416 scontrol |= (0x1 << 2);
423 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
427 /* give the link time to transit out of LPM state */
431 /* clear PHYRDY_CHG from SError */
432 ehc->i.serror &= ~SERR_PHYRDY_CHG;
433 return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
435 EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
437 static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
439 struct ata_link *host_link = &link->ap->link;
440 u32 limit, target, spd;
442 limit = link->sata_spd_limit;
444 /* Don't configure downstream link faster than upstream link.
445 * It doesn't speed up anything and some PMPs choke on such
448 if (!ata_is_host_link(link) && host_link->sata_spd)
449 limit &= (1 << host_link->sata_spd) - 1;
451 if (limit == UINT_MAX)
456 spd = (*scontrol >> 4) & 0xf;
457 *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
459 return spd != target;
463 * sata_set_spd_needed - is SATA spd configuration needed
464 * @link: Link in question
466 * Test whether the spd limit in SControl matches
467 * @link->sata_spd_limit. This function is used to determine
468 * whether hardreset is necessary to apply SATA spd
472 * Inherited from caller.
475 * 1 if SATA spd configuration is needed, 0 otherwise.
477 static int sata_set_spd_needed(struct ata_link *link)
481 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
484 return __sata_set_spd_needed(link, &scontrol);
488 * sata_set_spd - set SATA spd according to spd limit
489 * @link: Link to set SATA spd for
491 * Set SATA spd of @link according to sata_spd_limit.
494 * Inherited from caller.
497 * 0 if spd doesn't need to be changed, 1 if spd has been
498 * changed. Negative errno if SCR registers are inaccessible.
500 int sata_set_spd(struct ata_link *link)
505 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
508 if (!__sata_set_spd_needed(link, &scontrol))
511 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
516 EXPORT_SYMBOL_GPL(sata_set_spd);
519 * sata_link_hardreset - reset link via SATA phy reset
520 * @link: link to reset
521 * @timing: timing parameters { interval, duration, timeout } in msec
522 * @deadline: deadline jiffies for the operation
523 * @online: optional out parameter indicating link onlineness
524 * @check_ready: optional callback to check link readiness
526 * SATA phy-reset @link using DET bits of SControl register.
527 * After hardreset, link readiness is waited upon using
528 * ata_wait_ready() if @check_ready is specified. LLDs are
529 * allowed to not specify @check_ready and wait itself after this
530 * function returns. Device classification is LLD's
533 * *@online is set to one iff reset succeeded and @link is online
537 * Kernel thread context (may sleep)
540 * 0 on success, -errno otherwise.
542 int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
543 unsigned long deadline,
544 bool *online, int (*check_ready)(struct ata_link *))
554 if (sata_set_spd_needed(link)) {
555 /* SATA spec says nothing about how to reconfigure
556 * spd. To be on the safe side, turn off phy during
557 * reconfiguration. This works for at least ICH7 AHCI
560 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
563 scontrol = (scontrol & 0x0f0) | 0x304;
565 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
571 /* issue phy wake/reset */
572 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
575 scontrol = (scontrol & 0x0f0) | 0x301;
577 if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
580 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
581 * 10.4.2 says at least 1 ms.
583 ata_msleep(link->ap, 1);
585 /* bring link back */
586 rc = sata_link_resume(link, timing, deadline);
589 /* if link is offline nothing more to do */
590 if (ata_phys_link_offline(link))
593 /* Link is online. From this point, -ENODEV too is an error. */
597 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) {
598 /* If PMP is supported, we have to do follow-up SRST.
599 * Some PMPs don't send D2H Reg FIS after hardreset if
600 * the first port is empty. Wait only for
601 * ATA_TMOUT_PMP_SRST_WAIT.
604 unsigned long pmp_deadline;
606 pmp_deadline = ata_deadline(jiffies,
607 ATA_TMOUT_PMP_SRST_WAIT);
608 if (time_after(pmp_deadline, deadline))
609 pmp_deadline = deadline;
610 ata_wait_ready(link, pmp_deadline, check_ready);
618 rc = ata_wait_ready(link, deadline, check_ready);
620 if (rc && rc != -EAGAIN) {
621 /* online is set iff link is online && reset succeeded */
624 ata_link_err(link, "COMRESET failed (errno=%d)\n", rc);
626 DPRINTK("EXIT, rc=%d\n", rc);
629 EXPORT_SYMBOL_GPL(sata_link_hardreset);
632 * ata_qc_complete_multiple - Complete multiple qcs successfully
633 * @ap: port in question
634 * @qc_active: new qc_active mask
636 * Complete in-flight commands. This functions is meant to be
637 * called from low-level driver's interrupt routine to complete
638 * requests normally. ap->qc_active and @qc_active is compared
639 * and commands are completed accordingly.
641 * Always use this function when completing multiple NCQ commands
642 * from IRQ handlers instead of calling ata_qc_complete()
643 * multiple times to keep IRQ expect status properly in sync.
646 * spin_lock_irqsave(host lock)
649 * Number of completed commands on success, -errno otherwise.
651 int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active)
653 u64 done_mask, ap_qc_active = ap->qc_active;
657 * If the internal tag is set on ap->qc_active, then we care about
658 * bit0 on the passed in qc_active mask. Move that bit up to match
661 if (ap_qc_active & (1ULL << ATA_TAG_INTERNAL)) {
662 qc_active |= (qc_active & 0x01) << ATA_TAG_INTERNAL;
663 qc_active ^= qc_active & 0x01;
666 done_mask = ap_qc_active ^ qc_active;
668 if (unlikely(done_mask & qc_active)) {
669 ata_port_err(ap, "illegal qc_active transition (%08llx->%08llx)\n",
670 ap->qc_active, qc_active);
675 struct ata_queued_cmd *qc;
676 unsigned int tag = __ffs64(done_mask);
678 qc = ata_qc_from_tag(ap, tag);
683 done_mask &= ~(1ULL << tag);
688 EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
691 * ata_slave_link_init - initialize slave link
692 * @ap: port to initialize slave link for
694 * Create and initialize slave link for @ap. This enables slave
695 * link handling on the port.
697 * In libata, a port contains links and a link contains devices.
698 * There is single host link but if a PMP is attached to it,
699 * there can be multiple fan-out links. On SATA, there's usually
700 * a single device connected to a link but PATA and SATA
701 * controllers emulating TF based interface can have two - master
704 * However, there are a few controllers which don't fit into this
705 * abstraction too well - SATA controllers which emulate TF
706 * interface with both master and slave devices but also have
707 * separate SCR register sets for each device. These controllers
708 * need separate links for physical link handling
709 * (e.g. onlineness, link speed) but should be treated like a
710 * traditional M/S controller for everything else (e.g. command
713 * slave_link is libata's way of handling this class of
714 * controllers without impacting core layer too much. For
715 * anything other than physical link handling, the default host
716 * link is used for both master and slave. For physical link
717 * handling, separate @ap->slave_link is used. All dirty details
718 * are implemented inside libata core layer. From LLD's POV, the
719 * only difference is that prereset, hardreset and postreset are
720 * called once more for the slave link, so the reset sequence
721 * looks like the following.
723 * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
724 * softreset(M) -> postreset(M) -> postreset(S)
726 * Note that softreset is called only for the master. Softreset
727 * resets both M/S by definition, so SRST on master should handle
728 * both (the standard method will work just fine).
731 * Should be called before host is registered.
734 * 0 on success, -errno on failure.
736 int ata_slave_link_init(struct ata_port *ap)
738 struct ata_link *link;
740 WARN_ON(ap->slave_link);
741 WARN_ON(ap->flags & ATA_FLAG_PMP);
743 link = kzalloc(sizeof(*link), GFP_KERNEL);
747 ata_link_init(ap, link, 1);
748 ap->slave_link = link;
751 EXPORT_SYMBOL_GPL(ata_slave_link_init);
754 * sata_lpm_ignore_phy_events - test if PHY event should be ignored
755 * @link: Link receiving the event
757 * Test whether the received PHY event has to be ignored or not.
763 * True if the event has to be ignored.
765 bool sata_lpm_ignore_phy_events(struct ata_link *link)
767 unsigned long lpm_timeout = link->last_lpm_change +
768 msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY);
770 /* if LPM is enabled, PHYRDY doesn't mean anything */
771 if (link->lpm_policy > ATA_LPM_MAX_POWER)
774 /* ignore the first PHY event after the LPM policy changed
775 * as it is might be spurious
777 if ((link->flags & ATA_LFLAG_CHANGED) &&
778 time_before(jiffies, lpm_timeout))
783 EXPORT_SYMBOL_GPL(sata_lpm_ignore_phy_events);
785 static const char *ata_lpm_policy_names[] = {
786 [ATA_LPM_UNKNOWN] = "max_performance",
787 [ATA_LPM_MAX_POWER] = "max_performance",
788 [ATA_LPM_MED_POWER] = "medium_power",
789 [ATA_LPM_MED_POWER_WITH_DIPM] = "med_power_with_dipm",
790 [ATA_LPM_MIN_POWER_WITH_PARTIAL] = "min_power_with_partial",
791 [ATA_LPM_MIN_POWER] = "min_power",
794 static ssize_t ata_scsi_lpm_store(struct device *device,
795 struct device_attribute *attr,
796 const char *buf, size_t count)
798 struct Scsi_Host *shost = class_to_shost(device);
799 struct ata_port *ap = ata_shost_to_port(shost);
800 struct ata_link *link;
801 struct ata_device *dev;
802 enum ata_lpm_policy policy;
805 /* UNKNOWN is internal state, iterate from MAX_POWER */
806 for (policy = ATA_LPM_MAX_POWER;
807 policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) {
808 const char *name = ata_lpm_policy_names[policy];
810 if (strncmp(name, buf, strlen(name)) == 0)
813 if (policy == ARRAY_SIZE(ata_lpm_policy_names))
816 spin_lock_irqsave(ap->lock, flags);
818 ata_for_each_link(link, ap, EDGE) {
819 ata_for_each_dev(dev, &ap->link, ENABLED) {
820 if (dev->horkage & ATA_HORKAGE_NOLPM) {
827 ap->target_lpm_policy = policy;
828 ata_port_schedule_eh(ap);
830 spin_unlock_irqrestore(ap->lock, flags);
834 static ssize_t ata_scsi_lpm_show(struct device *dev,
835 struct device_attribute *attr, char *buf)
837 struct Scsi_Host *shost = class_to_shost(dev);
838 struct ata_port *ap = ata_shost_to_port(shost);
840 if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
843 return snprintf(buf, PAGE_SIZE, "%s\n",
844 ata_lpm_policy_names[ap->target_lpm_policy]);
846 DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
847 ata_scsi_lpm_show, ata_scsi_lpm_store);
848 EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
850 static ssize_t ata_ncq_prio_enable_show(struct device *device,
851 struct device_attribute *attr,
854 struct scsi_device *sdev = to_scsi_device(device);
856 struct ata_device *dev;
857 bool ncq_prio_enable;
860 ap = ata_shost_to_port(sdev->host);
862 spin_lock_irq(ap->lock);
863 dev = ata_scsi_find_dev(ap, sdev);
869 ncq_prio_enable = dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLE;
872 spin_unlock_irq(ap->lock);
874 return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable);
877 static ssize_t ata_ncq_prio_enable_store(struct device *device,
878 struct device_attribute *attr,
879 const char *buf, size_t len)
881 struct scsi_device *sdev = to_scsi_device(device);
883 struct ata_device *dev;
887 rc = kstrtol(buf, 10, &input);
890 if ((input < 0) || (input > 1))
893 ap = ata_shost_to_port(sdev->host);
894 dev = ata_scsi_find_dev(ap, sdev);
898 spin_lock_irq(ap->lock);
900 dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLE;
902 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE;
904 dev->link->eh_info.action |= ATA_EH_REVALIDATE;
905 dev->link->eh_info.flags |= ATA_EHI_QUIET;
906 ata_port_schedule_eh(ap);
907 spin_unlock_irq(ap->lock);
909 ata_port_wait_eh(ap);
912 spin_lock_irq(ap->lock);
913 if (!(dev->flags & ATA_DFLAG_NCQ_PRIO)) {
914 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE;
917 spin_unlock_irq(ap->lock);
920 return rc ? rc : len;
923 DEVICE_ATTR(ncq_prio_enable, S_IRUGO | S_IWUSR,
924 ata_ncq_prio_enable_show, ata_ncq_prio_enable_store);
925 EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_enable);
927 struct device_attribute *ata_ncq_sdev_attrs[] = {
928 &dev_attr_unload_heads,
929 &dev_attr_ncq_prio_enable,
932 EXPORT_SYMBOL_GPL(ata_ncq_sdev_attrs);
935 ata_scsi_em_message_store(struct device *dev, struct device_attribute *attr,
936 const char *buf, size_t count)
938 struct Scsi_Host *shost = class_to_shost(dev);
939 struct ata_port *ap = ata_shost_to_port(shost);
940 if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM))
941 return ap->ops->em_store(ap, buf, count);
946 ata_scsi_em_message_show(struct device *dev, struct device_attribute *attr,
949 struct Scsi_Host *shost = class_to_shost(dev);
950 struct ata_port *ap = ata_shost_to_port(shost);
952 if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM))
953 return ap->ops->em_show(ap, buf);
956 DEVICE_ATTR(em_message, S_IRUGO | S_IWUSR,
957 ata_scsi_em_message_show, ata_scsi_em_message_store);
958 EXPORT_SYMBOL_GPL(dev_attr_em_message);
961 ata_scsi_em_message_type_show(struct device *dev, struct device_attribute *attr,
964 struct Scsi_Host *shost = class_to_shost(dev);
965 struct ata_port *ap = ata_shost_to_port(shost);
967 return snprintf(buf, 23, "%d\n", ap->em_message_type);
969 DEVICE_ATTR(em_message_type, S_IRUGO,
970 ata_scsi_em_message_type_show, NULL);
971 EXPORT_SYMBOL_GPL(dev_attr_em_message_type);
974 ata_scsi_activity_show(struct device *dev, struct device_attribute *attr,
977 struct scsi_device *sdev = to_scsi_device(dev);
978 struct ata_port *ap = ata_shost_to_port(sdev->host);
979 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
981 if (atadev && ap->ops->sw_activity_show &&
982 (ap->flags & ATA_FLAG_SW_ACTIVITY))
983 return ap->ops->sw_activity_show(atadev, buf);
988 ata_scsi_activity_store(struct device *dev, struct device_attribute *attr,
989 const char *buf, size_t count)
991 struct scsi_device *sdev = to_scsi_device(dev);
992 struct ata_port *ap = ata_shost_to_port(sdev->host);
993 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
994 enum sw_activity val;
997 if (atadev && ap->ops->sw_activity_store &&
998 (ap->flags & ATA_FLAG_SW_ACTIVITY)) {
999 val = simple_strtoul(buf, NULL, 0);
1001 case OFF: case BLINK_ON: case BLINK_OFF:
1002 rc = ap->ops->sw_activity_store(atadev, val);
1011 DEVICE_ATTR(sw_activity, S_IWUSR | S_IRUGO, ata_scsi_activity_show,
1012 ata_scsi_activity_store);
1013 EXPORT_SYMBOL_GPL(dev_attr_sw_activity);
1016 * __ata_change_queue_depth - helper for ata_scsi_change_queue_depth
1017 * @ap: ATA port to which the device change the queue depth
1018 * @sdev: SCSI device to configure queue depth for
1019 * @queue_depth: new queue depth
1021 * libsas and libata have different approaches for associating a sdev to
1025 int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
1028 struct ata_device *dev;
1029 unsigned long flags;
1031 if (queue_depth < 1 || queue_depth == sdev->queue_depth)
1032 return sdev->queue_depth;
1034 dev = ata_scsi_find_dev(ap, sdev);
1035 if (!dev || !ata_dev_enabled(dev))
1036 return sdev->queue_depth;
1039 spin_lock_irqsave(ap->lock, flags);
1040 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
1041 if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
1042 dev->flags |= ATA_DFLAG_NCQ_OFF;
1045 spin_unlock_irqrestore(ap->lock, flags);
1047 /* limit and apply queue depth */
1048 queue_depth = min(queue_depth, sdev->host->can_queue);
1049 queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
1050 queue_depth = min(queue_depth, ATA_MAX_QUEUE);
1052 if (sdev->queue_depth == queue_depth)
1055 return scsi_change_queue_depth(sdev, queue_depth);
1057 EXPORT_SYMBOL_GPL(__ata_change_queue_depth);
1060 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
1061 * @sdev: SCSI device to configure queue depth for
1062 * @queue_depth: new queue depth
1064 * This is libata standard hostt->change_queue_depth callback.
1065 * SCSI will call into this callback when user tries to set queue
1069 * SCSI layer (we don't care)
1072 * Newly configured queue depth.
1074 int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
1076 struct ata_port *ap = ata_shost_to_port(sdev->host);
1078 return __ata_change_queue_depth(ap, sdev, queue_depth);
1080 EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
1083 * port_alloc - Allocate port for a SAS attached SATA device
1084 * @host: ATA host container for all SAS ports
1085 * @port_info: Information from low-level host driver
1086 * @shost: SCSI host that the scsi device is attached to
1089 * PCI/etc. bus probe sem.
1092 * ata_port pointer on success / NULL on failure.
1095 struct ata_port *ata_sas_port_alloc(struct ata_host *host,
1096 struct ata_port_info *port_info,
1097 struct Scsi_Host *shost)
1099 struct ata_port *ap;
1101 ap = ata_port_alloc(host);
1106 ap->lock = &host->lock;
1107 ap->pio_mask = port_info->pio_mask;
1108 ap->mwdma_mask = port_info->mwdma_mask;
1109 ap->udma_mask = port_info->udma_mask;
1110 ap->flags |= port_info->flags;
1111 ap->ops = port_info->port_ops;
1112 ap->cbl = ATA_CBL_SATA;
1116 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
1119 * ata_sas_port_start - Set port up for dma.
1120 * @ap: Port to initialize
1122 * Called just after data structures for each port are
1125 * May be used as the port_start() entry in ata_port_operations.
1128 * Inherited from caller.
1130 int ata_sas_port_start(struct ata_port *ap)
1133 * the port is marked as frozen at allocation time, but if we don't
1134 * have new eh, we won't thaw it
1136 if (!ap->ops->error_handler)
1137 ap->pflags &= ~ATA_PFLAG_FROZEN;
1140 EXPORT_SYMBOL_GPL(ata_sas_port_start);
1143 * ata_port_stop - Undo ata_sas_port_start()
1144 * @ap: Port to shut down
1146 * May be used as the port_stop() entry in ata_port_operations.
1149 * Inherited from caller.
1152 void ata_sas_port_stop(struct ata_port *ap)
1155 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
1158 * ata_sas_async_probe - simply schedule probing and return
1159 * @ap: Port to probe
1161 * For batch scheduling of probe for sas attached ata devices, assumes
1162 * the port has already been through ata_sas_port_init()
1164 void ata_sas_async_probe(struct ata_port *ap)
1166 __ata_port_probe(ap);
1168 EXPORT_SYMBOL_GPL(ata_sas_async_probe);
1170 int ata_sas_sync_probe(struct ata_port *ap)
1172 return ata_port_probe(ap);
1174 EXPORT_SYMBOL_GPL(ata_sas_sync_probe);
1178 * ata_sas_port_init - Initialize a SATA device
1179 * @ap: SATA port to initialize
1182 * PCI/etc. bus probe sem.
1185 * Zero on success, non-zero on error.
1188 int ata_sas_port_init(struct ata_port *ap)
1190 int rc = ap->ops->port_start(ap);
1194 ap->print_id = atomic_inc_return(&ata_print_id);
1197 EXPORT_SYMBOL_GPL(ata_sas_port_init);
1199 int ata_sas_tport_add(struct device *parent, struct ata_port *ap)
1201 return ata_tport_add(parent, ap);
1203 EXPORT_SYMBOL_GPL(ata_sas_tport_add);
1205 void ata_sas_tport_delete(struct ata_port *ap)
1207 ata_tport_delete(ap);
1209 EXPORT_SYMBOL_GPL(ata_sas_tport_delete);
1212 * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
1213 * @ap: SATA port to destroy
1217 void ata_sas_port_destroy(struct ata_port *ap)
1219 if (ap->ops->port_stop)
1220 ap->ops->port_stop(ap);
1223 EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
1226 * ata_sas_slave_configure - Default slave_config routine for libata devices
1227 * @sdev: SCSI device to configure
1228 * @ap: ATA port to which SCSI device is attached
1234 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
1236 ata_scsi_sdev_config(sdev);
1237 ata_scsi_dev_config(sdev, ap->link.device);
1240 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
1243 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
1244 * @cmd: SCSI command to be sent
1245 * @ap: ATA port to which the command is being sent
1248 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
1252 int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap)
1256 ata_scsi_dump_cdb(ap, cmd);
1258 if (likely(ata_dev_enabled(ap->link.device)))
1259 rc = __ata_scsi_queuecmd(cmd, ap->link.device);
1261 cmd->result = (DID_BAD_TARGET << 16);
1262 cmd->scsi_done(cmd);
1266 EXPORT_SYMBOL_GPL(ata_sas_queuecmd);
1268 int ata_sas_allocate_tag(struct ata_port *ap)
1270 unsigned int max_queue = ap->host->n_tags;
1271 unsigned int i, tag;
1273 for (i = 0, tag = ap->sas_last_tag + 1; i < max_queue; i++, tag++) {
1274 tag = tag < max_queue ? tag : 0;
1276 /* the last tag is reserved for internal command. */
1277 if (ata_tag_internal(tag))
1280 if (!test_and_set_bit(tag, &ap->sas_tag_allocated)) {
1281 ap->sas_last_tag = tag;
1288 void ata_sas_free_tag(unsigned int tag, struct ata_port *ap)
1290 clear_bit(tag, &ap->sas_tag_allocated);
1294 * sata_async_notification - SATA async notification handler
1295 * @ap: ATA port where async notification is received
1297 * Handler to be called when async notification via SDB FIS is
1298 * received. This function schedules EH if necessary.
1301 * spin_lock_irqsave(host lock)
1304 * 1 if EH is scheduled, 0 otherwise.
1306 int sata_async_notification(struct ata_port *ap)
1311 if (!(ap->flags & ATA_FLAG_AN))
1314 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1316 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1318 if (!sata_pmp_attached(ap) || rc) {
1319 /* PMP is not attached or SNTF is not available */
1320 if (!sata_pmp_attached(ap)) {
1321 /* PMP is not attached. Check whether ATAPI
1322 * AN is configured. If so, notify media
1325 struct ata_device *dev = ap->link.device;
1327 if ((dev->class == ATA_DEV_ATAPI) &&
1328 (dev->flags & ATA_DFLAG_AN))
1329 ata_scsi_media_change_notify(dev);
1332 /* PMP is attached but SNTF is not available.
1333 * ATAPI async media change notification is
1334 * not used. The PMP must be reporting PHY
1335 * status change, schedule EH.
1337 ata_port_schedule_eh(ap);
1341 /* PMP is attached and SNTF is available */
1342 struct ata_link *link;
1344 /* check and notify ATAPI AN */
1345 ata_for_each_link(link, ap, EDGE) {
1346 if (!(sntf & (1 << link->pmp)))
1349 if ((link->device->class == ATA_DEV_ATAPI) &&
1350 (link->device->flags & ATA_DFLAG_AN))
1351 ata_scsi_media_change_notify(link->device);
1354 /* If PMP is reporting that PHY status of some
1355 * downstream ports has changed, schedule EH.
1357 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1358 ata_port_schedule_eh(ap);
1365 EXPORT_SYMBOL_GPL(sata_async_notification);
1368 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1369 * @dev: Device to read log page 10h from
1370 * @tag: Resulting tag of the failed command
1371 * @tf: Resulting taskfile registers of the failed command
1373 * Read log page 10h to obtain NCQ error details and clear error
1377 * Kernel thread context (may sleep).
1380 * 0 on success, -errno otherwise.
1382 static int ata_eh_read_log_10h(struct ata_device *dev,
1383 int *tag, struct ata_taskfile *tf)
1385 u8 *buf = dev->link->ap->sector_buf;
1386 unsigned int err_mask;
1390 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1);
1395 for (i = 0; i < ATA_SECT_SIZE; i++)
1398 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1404 *tag = buf[0] & 0x1f;
1406 tf->command = buf[2];
1407 tf->feature = buf[3];
1411 tf->device = buf[7];
1412 tf->hob_lbal = buf[8];
1413 tf->hob_lbam = buf[9];
1414 tf->hob_lbah = buf[10];
1415 tf->nsect = buf[12];
1416 tf->hob_nsect = buf[13];
1417 if (dev->class == ATA_DEV_ZAC && ata_id_has_ncq_autosense(dev->id))
1418 tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
1424 * ata_eh_analyze_ncq_error - analyze NCQ error
1425 * @link: ATA link to analyze NCQ error for
1427 * Read log page 10h, determine the offending qc and acquire
1428 * error status TF. For NCQ device errors, all LLDDs have to do
1429 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1433 * Kernel thread context (may sleep).
1435 void ata_eh_analyze_ncq_error(struct ata_link *link)
1437 struct ata_port *ap = link->ap;
1438 struct ata_eh_context *ehc = &link->eh_context;
1439 struct ata_device *dev = link->device;
1440 struct ata_queued_cmd *qc;
1441 struct ata_taskfile tf;
1444 /* if frozen, we can't do much */
1445 if (ap->pflags & ATA_PFLAG_FROZEN)
1448 /* is it NCQ device error? */
1449 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1452 /* has LLDD analyzed already? */
1453 ata_qc_for_each_raw(ap, qc, tag) {
1454 if (!(qc->flags & ATA_QCFLAG_FAILED))
1461 /* okay, this error is ours */
1462 memset(&tf, 0, sizeof(tf));
1463 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1465 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1470 if (!(link->sactive & (1 << tag))) {
1471 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1476 /* we've got the perpetrator, condemn it */
1477 qc = __ata_qc_from_tag(ap, tag);
1478 memcpy(&qc->result_tf, &tf, sizeof(tf));
1479 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1480 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1481 if (dev->class == ATA_DEV_ZAC &&
1482 ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary)) {
1483 char sense_key, asc, ascq;
1485 sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
1486 asc = (qc->result_tf.auxiliary >> 8) & 0xff;
1487 ascq = qc->result_tf.auxiliary & 0xff;
1488 ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc, ascq);
1489 ata_scsi_set_sense_information(dev, qc->scsicmd,
1491 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1494 ehc->i.err_mask &= ~AC_ERR_DEV;
1496 EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error);