2 * libata-pmp.c - libata port multiplier support
4 * Copyright (c) 2007 SUSE Linux Products GmbH
5 * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7 * This file is released under the GPLv2.
10 #include <linux/kernel.h>
11 #include <linux/libata.h>
15 * sata_pmp_read - read PMP register
16 * @link: link to read PMP register for
17 * @reg: register to read
18 * @r_val: resulting value
23 * Kernel thread context (may sleep).
26 * 0 on success, AC_ERR_* mask on failure.
28 static unsigned int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
30 struct ata_port *ap = link->ap;
31 struct ata_device *pmp_dev = ap->link.device;
32 struct ata_taskfile tf;
33 unsigned int err_mask;
35 ata_tf_init(pmp_dev, &tf);
36 tf.command = ATA_CMD_PMP_READ;
37 tf.protocol = ATA_PROT_NODATA;
38 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
40 tf.device = link->pmp;
42 err_mask = ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
43 SATA_PMP_SCR_TIMEOUT);
47 *r_val = tf.nsect | tf.lbal << 8 | tf.lbam << 16 | tf.lbah << 24;
52 * sata_pmp_write - write PMP register
53 * @link: link to write PMP register for
54 * @reg: register to write
55 * @r_val: value to write
60 * Kernel thread context (may sleep).
63 * 0 on success, AC_ERR_* mask on failure.
65 static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
67 struct ata_port *ap = link->ap;
68 struct ata_device *pmp_dev = ap->link.device;
69 struct ata_taskfile tf;
71 ata_tf_init(pmp_dev, &tf);
72 tf.command = ATA_CMD_PMP_WRITE;
73 tf.protocol = ATA_PROT_NODATA;
74 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
76 tf.device = link->pmp;
77 tf.nsect = val & 0xff;
78 tf.lbal = (val >> 8) & 0xff;
79 tf.lbam = (val >> 16) & 0xff;
80 tf.lbah = (val >> 24) & 0xff;
82 return ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
83 SATA_PMP_SCR_TIMEOUT);
87 * sata_pmp_qc_defer_cmd_switch - qc_defer for command switching PMP
88 * @qc: ATA command in question
90 * A host which has command switching PMP support cannot issue
91 * commands to multiple links simultaneously.
94 * spin_lock_irqsave(host lock)
97 * ATA_DEFER_* if deferring is needed, 0 otherwise.
99 int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc)
101 struct ata_link *link = qc->dev->link;
102 struct ata_port *ap = link->ap;
104 if (ap->excl_link == NULL || ap->excl_link == link) {
105 if (ap->nr_active_links == 0 || ata_link_active(link)) {
106 qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
107 return ata_std_qc_defer(qc);
110 ap->excl_link = link;
113 return ATA_DEFER_PORT;
117 * sata_pmp_scr_read - read PSCR
118 * @link: ATA link to read PSCR for
120 * @r_val: resulting value
122 * Read PSCR @reg into @r_val for @link, to be called from
126 * Kernel thread context (may sleep).
129 * 0 on success, -errno on failure.
131 int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
133 unsigned int err_mask;
135 if (reg > SATA_PMP_PSCR_CONTROL)
138 err_mask = sata_pmp_read(link, reg, r_val);
140 ata_link_printk(link, KERN_WARNING, "failed to read SCR %d "
141 "(Emask=0x%x)\n", reg, err_mask);
148 * sata_pmp_scr_write - write PSCR
149 * @link: ATA link to write PSCR for
150 * @reg: PSCR to write
151 * @val: value to be written
153 * Write @val to PSCR @reg for @link, to be called from
154 * ata_scr_write() and ata_scr_write_flush().
157 * Kernel thread context (may sleep).
160 * 0 on success, -errno on failure.
162 int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
164 unsigned int err_mask;
166 if (reg > SATA_PMP_PSCR_CONTROL)
169 err_mask = sata_pmp_write(link, reg, val);
171 ata_link_printk(link, KERN_WARNING, "failed to write SCR %d "
172 "(Emask=0x%x)\n", reg, err_mask);
179 * sata_pmp_std_prereset - prepare PMP link for reset
180 * @link: link to be reset
181 * @deadline: deadline jiffies for the operation
183 * @link is about to be reset. Initialize it.
186 * Kernel thread context (may sleep)
189 * 0 on success, -errno otherwise.
191 int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline)
193 struct ata_eh_context *ehc = &link->eh_context;
194 const unsigned long *timing = sata_ehc_deb_timing(ehc);
197 /* if we're about to do hardreset, nothing more to do */
198 if (ehc->i.action & ATA_EH_HARDRESET)
202 rc = sata_link_resume(link, timing, deadline);
204 /* phy resume failed */
205 ata_link_printk(link, KERN_WARNING, "failed to resume link "
206 "for reset (errno=%d)\n", rc);
210 /* clear SError bits including .X which blocks the port when set */
211 rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
213 ata_link_printk(link, KERN_ERR,
214 "failed to clear SError (errno=%d)\n", rc);
222 * sata_pmp_std_hardreset - standard hardreset method for PMP link
223 * @link: link to be reset
224 * @class: resulting class of attached device
225 * @deadline: deadline jiffies for the operation
227 * Hardreset PMP port @link. Note that this function doesn't
228 * wait for BSY clearance. There simply isn't a generic way to
229 * wait the event. Instead, this function return -EAGAIN thus
230 * telling libata-EH to followup with softreset.
233 * Kernel thread context (may sleep)
236 * 0 on success, -errno otherwise.
238 int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
239 unsigned long deadline)
241 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
249 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
251 ata_link_printk(link, KERN_ERR,
252 "COMRESET failed (errno=%d)\n", rc);
256 /* clear SError bits including .X which blocks the port when set */
257 rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
259 ata_link_printk(link, KERN_ERR, "failed to clear SError "
260 "during hardreset (errno=%d)\n", rc);
264 /* if device is present, follow up with srst to wait for !BSY */
268 /* if SCR isn't accessible, we need to reset the PMP */
269 if (rc && rc != -EAGAIN && sata_scr_read(link, SCR_STATUS, &tmp))
272 DPRINTK("EXIT, rc=%d\n", rc);
277 * ata_std_postreset - standard postreset method for PMP link
278 * @link: the target ata_link
279 * @classes: classes of attached devices
281 * This function is invoked after a successful reset. Note that
282 * the device might have been reset more than once using
283 * different reset methods before postreset is invoked.
286 * Kernel thread context (may sleep)
288 void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
295 if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
296 sata_scr_write(link, SCR_ERROR, serror);
298 /* print link status */
299 sata_print_link_status(link);
305 * sata_pmp_read_gscr - read GSCR block of SATA PMP
307 * @gscr: buffer to read GSCR block into
309 * Read selected PMP GSCRs from the PMP at @dev. This will serve
310 * as configuration and identification info for the PMP.
313 * Kernel thread context (may sleep).
316 * 0 on success, -errno on failure.
318 static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
320 static const int gscr_to_read[] = { 0, 1, 2, 32, 33, 64, 96 };
323 for (i = 0; i < ARRAY_SIZE(gscr_to_read); i++) {
324 int reg = gscr_to_read[i];
325 unsigned int err_mask;
327 err_mask = sata_pmp_read(dev->link, reg, &gscr[reg]);
329 ata_dev_printk(dev, KERN_ERR, "failed to read PMP "
330 "GSCR[%d] (Emask=0x%x)\n", reg, err_mask);
338 static const char *sata_pmp_spec_rev_str(const u32 *gscr)
340 u32 rev = gscr[SATA_PMP_GSCR_REV];
349 static int sata_pmp_configure(struct ata_device *dev, int print_info)
351 struct ata_port *ap = dev->link->ap;
352 u32 *gscr = dev->gscr;
353 unsigned int err_mask = 0;
357 nr_ports = sata_pmp_gscr_ports(gscr);
359 if (nr_ports <= 0 || nr_ports > SATA_PMP_MAX_PORTS) {
361 reason = "invalid nr_ports";
365 if ((ap->flags & ATA_FLAG_AN) &&
366 (gscr[SATA_PMP_GSCR_FEAT] & SATA_PMP_FEAT_NOTIFY))
367 dev->flags |= ATA_DFLAG_AN;
369 /* monitor SERR_PHYRDY_CHG on fan-out ports */
370 err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_ERROR_EN,
374 reason = "failed to write GSCR_ERROR_EN";
378 /* turn off notification till fan-out ports are reset and configured */
379 if (gscr[SATA_PMP_GSCR_FEAT_EN] & SATA_PMP_FEAT_NOTIFY) {
380 gscr[SATA_PMP_GSCR_FEAT_EN] &= ~SATA_PMP_FEAT_NOTIFY;
382 err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_FEAT_EN,
383 gscr[SATA_PMP_GSCR_FEAT_EN]);
386 reason = "failed to write GSCR_FEAT_EN";
392 ata_dev_printk(dev, KERN_INFO, "Port Multiplier %s, "
393 "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
394 sata_pmp_spec_rev_str(gscr),
395 sata_pmp_gscr_vendor(gscr),
396 sata_pmp_gscr_devid(gscr),
397 sata_pmp_gscr_rev(gscr),
398 nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
399 gscr[SATA_PMP_GSCR_FEAT]);
401 if (!(dev->flags & ATA_DFLAG_AN))
402 ata_dev_printk(dev, KERN_INFO,
403 "Asynchronous notification not supported, "
404 "hotplug won't\n work on fan-out "
405 "ports. Use warm-plug instead.\n");
411 ata_dev_printk(dev, KERN_ERR,
412 "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
417 static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
419 struct ata_link *pmp_link = ap->pmp_link;
423 pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS,
428 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
429 ata_link_init(ap, &pmp_link[i], i);
431 ap->pmp_link = pmp_link;
434 for (i = 0; i < nr_ports; i++) {
435 struct ata_link *link = &pmp_link[i];
436 struct ata_eh_context *ehc = &link->eh_context;
439 ehc->i.probe_mask |= ATA_ALL_DEVICES;
440 ehc->i.action |= ATA_EH_RESET;
446 static void sata_pmp_quirks(struct ata_port *ap)
448 u32 *gscr = ap->link.device->gscr;
449 u16 vendor = sata_pmp_gscr_vendor(gscr);
450 u16 devid = sata_pmp_gscr_devid(gscr);
451 struct ata_link *link;
453 if (vendor == 0x1095 && devid == 0x3726) {
455 ata_port_for_each_link(link, ap) {
456 /* class code report is unreliable */
458 link->flags |= ATA_LFLAG_ASSUME_ATA;
460 /* port 5 is for SEMB device and it doesn't like SRST */
462 link->flags |= ATA_LFLAG_NO_SRST |
463 ATA_LFLAG_ASSUME_SEMB;
465 } else if (vendor == 0x1095 && devid == 0x4723) {
467 ata_port_for_each_link(link, ap) {
468 /* class code report is unreliable */
470 link->flags |= ATA_LFLAG_ASSUME_ATA;
472 /* the config device at port 2 locks up on SRST */
474 link->flags |= ATA_LFLAG_NO_SRST |
475 ATA_LFLAG_ASSUME_ATA;
477 } else if (vendor == 0x1095 && devid == 0x4726) {
479 ata_port_for_each_link(link, ap) {
480 /* Class code report is unreliable and SRST
481 * times out under certain configurations.
482 * Config device can be at port 0 or 5 and
486 link->flags |= ATA_LFLAG_NO_SRST |
487 ATA_LFLAG_ASSUME_ATA;
489 /* Port 6 is for SEMB device which doesn't
493 link->flags |= ATA_LFLAG_NO_SRST |
494 ATA_LFLAG_ASSUME_SEMB;
496 } else if (vendor == 0x1095 && (devid == 0x5723 || devid == 0x5733 ||
497 devid == 0x5734 || devid == 0x5744)) {
498 /* sil5723/5744 quirks */
500 /* sil5723/5744 has either two or three downstream
501 * ports depending on operation mode. The last port
502 * is empty if any actual IO device is available or
503 * occupied by a pseudo configuration device
504 * otherwise. Don't try hard to recover it.
506 ap->pmp_link[ap->nr_pmp_links - 1].flags |= ATA_LFLAG_NO_RETRY;
511 * sata_pmp_attach - attach a SATA PMP device
512 * @dev: SATA PMP device to attach
514 * Configure and attach SATA PMP device @dev. This function is
515 * also responsible for allocating and initializing PMP links.
518 * Kernel thread context (may sleep).
521 * 0 on success, -errno on failure.
523 int sata_pmp_attach(struct ata_device *dev)
525 struct ata_link *link = dev->link;
526 struct ata_port *ap = link->ap;
528 struct ata_link *tlink;
531 /* is it hanging off the right place? */
532 if (!(ap->flags & ATA_FLAG_PMP)) {
533 ata_dev_printk(dev, KERN_ERR,
534 "host does not support Port Multiplier\n");
538 if (!ata_is_host_link(link)) {
539 ata_dev_printk(dev, KERN_ERR,
540 "Port Multipliers cannot be nested\n");
545 ata_dev_printk(dev, KERN_ERR,
546 "Port Multiplier must be the first device\n");
550 WARN_ON(link->pmp != 0);
551 link->pmp = SATA_PMP_CTRL_PORT;
553 /* read GSCR block */
554 rc = sata_pmp_read_gscr(dev, dev->gscr);
559 rc = sata_pmp_configure(dev, 1);
563 rc = sata_pmp_init_links(ap, sata_pmp_gscr_ports(dev->gscr));
565 ata_dev_printk(dev, KERN_INFO,
566 "failed to initialize PMP links\n");
571 spin_lock_irqsave(ap->lock, flags);
572 WARN_ON(ap->nr_pmp_links);
573 ap->nr_pmp_links = sata_pmp_gscr_ports(dev->gscr);
574 spin_unlock_irqrestore(ap->lock, flags);
578 if (ap->ops->pmp_attach)
579 ap->ops->pmp_attach(ap);
581 ata_port_for_each_link(tlink, ap)
582 sata_link_init_spd(tlink);
584 ata_acpi_associate_sata_port(ap);
594 * sata_pmp_detach - detach a SATA PMP device
595 * @dev: SATA PMP device to detach
597 * Detach SATA PMP device @dev. This function is also
598 * responsible for deconfiguring PMP links.
601 * Kernel thread context (may sleep).
603 static void sata_pmp_detach(struct ata_device *dev)
605 struct ata_link *link = dev->link;
606 struct ata_port *ap = link->ap;
607 struct ata_link *tlink;
610 ata_dev_printk(dev, KERN_INFO, "Port Multiplier detaching\n");
612 WARN_ON(!ata_is_host_link(link) || dev->devno ||
613 link->pmp != SATA_PMP_CTRL_PORT);
615 if (ap->ops->pmp_detach)
616 ap->ops->pmp_detach(ap);
618 ata_port_for_each_link(tlink, ap)
619 ata_eh_detach_dev(tlink->device);
621 spin_lock_irqsave(ap->lock, flags);
622 ap->nr_pmp_links = 0;
624 spin_unlock_irqrestore(ap->lock, flags);
626 ata_acpi_associate_sata_port(ap);
630 * sata_pmp_same_pmp - does new GSCR matches the configured PMP?
631 * @dev: PMP device to compare against
632 * @new_gscr: GSCR block of the new device
634 * Compare @new_gscr against @dev and determine whether @dev is
635 * the PMP described by @new_gscr.
641 * 1 if @dev matches @new_gscr, 0 otherwise.
643 static int sata_pmp_same_pmp(struct ata_device *dev, const u32 *new_gscr)
645 const u32 *old_gscr = dev->gscr;
646 u16 old_vendor, new_vendor, old_devid, new_devid;
647 int old_nr_ports, new_nr_ports;
649 old_vendor = sata_pmp_gscr_vendor(old_gscr);
650 new_vendor = sata_pmp_gscr_vendor(new_gscr);
651 old_devid = sata_pmp_gscr_devid(old_gscr);
652 new_devid = sata_pmp_gscr_devid(new_gscr);
653 old_nr_ports = sata_pmp_gscr_ports(old_gscr);
654 new_nr_ports = sata_pmp_gscr_ports(new_gscr);
656 if (old_vendor != new_vendor) {
657 ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
658 "vendor mismatch '0x%x' != '0x%x'\n",
659 old_vendor, new_vendor);
663 if (old_devid != new_devid) {
664 ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
665 "device ID mismatch '0x%x' != '0x%x'\n",
666 old_devid, new_devid);
670 if (old_nr_ports != new_nr_ports) {
671 ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
672 "nr_ports mismatch '0x%x' != '0x%x'\n",
673 old_nr_ports, new_nr_ports);
681 * sata_pmp_revalidate - revalidate SATA PMP
682 * @dev: PMP device to revalidate
683 * @new_class: new class code
685 * Re-read GSCR block and make sure @dev is still attached to the
686 * port and properly configured.
689 * Kernel thread context (may sleep).
692 * 0 on success, -errno otherwise.
694 static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
696 struct ata_link *link = dev->link;
697 struct ata_port *ap = link->ap;
698 u32 *gscr = (void *)ap->sector_buf;
703 ata_eh_about_to_do(link, NULL, ATA_EH_REVALIDATE);
705 if (!ata_dev_enabled(dev)) {
711 if (ata_class_enabled(new_class) && new_class != ATA_DEV_PMP) {
717 rc = sata_pmp_read_gscr(dev, gscr);
721 /* is the pmp still there? */
722 if (!sata_pmp_same_pmp(dev, gscr)) {
727 memcpy(dev->gscr, gscr, sizeof(gscr[0]) * SATA_PMP_GSCR_DWORDS);
729 rc = sata_pmp_configure(dev, 0);
733 ata_eh_done(link, NULL, ATA_EH_REVALIDATE);
735 DPRINTK("EXIT, rc=0\n");
739 ata_dev_printk(dev, KERN_ERR,
740 "PMP revalidation failed (errno=%d)\n", rc);
741 DPRINTK("EXIT, rc=%d\n", rc);
746 * sata_pmp_revalidate_quick - revalidate SATA PMP quickly
747 * @dev: PMP device to revalidate
749 * Make sure the attached PMP is accessible.
752 * Kernel thread context (may sleep).
755 * 0 on success, -errno otherwise.
757 static int sata_pmp_revalidate_quick(struct ata_device *dev)
759 unsigned int err_mask;
762 err_mask = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
764 ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID "
765 "(Emask=0x%x)\n", err_mask);
769 if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
770 ata_dev_printk(dev, KERN_ERR, "PMP product ID mismatch\n");
771 /* something weird is going on, request full PMP recovery */
779 * sata_pmp_eh_recover_pmp - recover PMP
780 * @ap: ATA port PMP is attached to
781 * @prereset: prereset method (can be NULL)
782 * @softreset: softreset method
783 * @hardreset: hardreset method
784 * @postreset: postreset method (can be NULL)
786 * Recover PMP attached to @ap. Recovery procedure is somewhat
787 * similar to that of ata_eh_recover() except that reset should
788 * always be performed in hard->soft sequence and recovery
789 * failure results in PMP detachment.
792 * Kernel thread context (may sleep).
795 * 0 on success, -errno on failure.
797 static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
798 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
799 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
801 struct ata_link *link = &ap->link;
802 struct ata_eh_context *ehc = &link->eh_context;
803 struct ata_device *dev = link->device;
804 int tries = ATA_EH_PMP_TRIES;
805 int detach = 0, rc = 0;
806 int reval_failed = 0;
810 if (dev->flags & ATA_DFLAG_DETACH) {
816 ehc->classes[0] = ATA_DEV_UNKNOWN;
818 if (ehc->i.action & ATA_EH_RESET) {
819 struct ata_link *tlink;
821 ata_eh_freeze_port(ap);
824 rc = ata_eh_reset(link, 0, prereset, softreset, hardreset,
827 ata_link_printk(link, KERN_ERR,
828 "failed to reset PMP, giving up\n");
832 ata_eh_thaw_port(ap);
834 /* PMP is reset, SErrors cannot be trusted, scan all */
835 ata_port_for_each_link(tlink, ap) {
836 struct ata_eh_context *ehc = &tlink->eh_context;
838 ehc->i.probe_mask |= ATA_ALL_DEVICES;
839 ehc->i.action |= ATA_EH_RESET;
843 /* If revalidation is requested, revalidate and reconfigure;
844 * otherwise, do quick revalidation.
846 if (ehc->i.action & ATA_EH_REVALIDATE)
847 rc = sata_pmp_revalidate(dev, ehc->classes[0]);
849 rc = sata_pmp_revalidate_quick(dev);
855 ehc->i.probe_mask |= ATA_ALL_DEVICES;
857 /* give it just two more chances */
858 tries = min(tries, 2);
862 int sleep = ehc->i.flags & ATA_EHI_DID_RESET;
864 /* consecutive revalidation failures? speed down */
866 sata_down_spd_limit(link);
870 ata_dev_printk(dev, KERN_WARNING,
871 "retrying reset%s\n",
872 sleep ? " in 5 secs" : "");
875 ehc->i.action |= ATA_EH_RESET;
878 ata_dev_printk(dev, KERN_ERR, "failed to recover PMP "
879 "after %d tries, giving up\n",
885 /* okay, PMP resurrected */
888 DPRINTK("EXIT, rc=0\n");
892 sata_pmp_detach(dev);
894 ata_eh_detach_dev(dev);
896 ata_dev_disable(dev);
898 DPRINTK("EXIT, rc=%d\n", rc);
902 static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
904 struct ata_link *link;
908 spin_lock_irqsave(ap->lock, flags);
910 ata_port_for_each_link(link, ap) {
911 if (!(link->flags & ATA_LFLAG_DISABLED))
914 spin_unlock_irqrestore(ap->lock, flags);
916 /* Some PMPs require hardreset sequence to get
919 sata_link_hardreset(link, sata_deb_timing_normal,
920 jiffies + ATA_TMOUT_INTERNAL_QUICK, NULL, NULL);
922 /* unconditionally clear SError.N */
923 rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
925 ata_link_printk(link, KERN_ERR, "failed to clear "
926 "SError.N (errno=%d)\n", rc);
930 spin_lock_irqsave(ap->lock, flags);
933 spin_unlock_irqrestore(ap->lock, flags);
938 static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
940 struct ata_port *ap = link->ap;
943 if (link_tries[link->pmp] && --link_tries[link->pmp])
946 /* disable this link */
947 if (!(link->flags & ATA_LFLAG_DISABLED)) {
948 ata_link_printk(link, KERN_WARNING,
949 "failed to recover link after %d tries, disabling\n",
950 ATA_EH_PMP_LINK_TRIES);
952 spin_lock_irqsave(ap->lock, flags);
953 link->flags |= ATA_LFLAG_DISABLED;
954 spin_unlock_irqrestore(ap->lock, flags);
957 ata_dev_disable(link->device);
958 link->eh_context.i.action = 0;
964 * sata_pmp_eh_recover - recover PMP-enabled port
965 * @ap: ATA port to recover
967 * Drive EH recovery operation for PMP enabled port @ap. This
968 * function recovers host and PMP ports with proper retrials and
969 * fallbacks. Actual recovery operations are performed using
970 * ata_eh_recover() and sata_pmp_eh_recover_pmp().
973 * Kernel thread context (may sleep).
976 * 0 on success, -errno on failure.
978 static int sata_pmp_eh_recover(struct ata_port *ap)
980 struct ata_port_operations *ops = ap->ops;
981 int pmp_tries, link_tries[SATA_PMP_MAX_PORTS];
982 struct ata_link *pmp_link = &ap->link;
983 struct ata_device *pmp_dev = pmp_link->device;
984 struct ata_eh_context *pmp_ehc = &pmp_link->eh_context;
985 struct ata_link *link;
986 struct ata_device *dev;
987 unsigned int err_mask;
988 u32 gscr_error, sntf;
991 pmp_tries = ATA_EH_PMP_TRIES;
992 ata_port_for_each_link(link, ap)
993 link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
997 if (!ap->nr_pmp_links) {
998 rc = ata_eh_recover(ap, ops->prereset, ops->softreset,
999 ops->hardreset, ops->postreset, NULL);
1001 ata_link_for_each_dev(dev, &ap->link)
1002 ata_dev_disable(dev);
1006 if (pmp_dev->class != ATA_DEV_PMP)
1009 /* new PMP online */
1010 ata_port_for_each_link(link, ap)
1011 link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
1017 rc = sata_pmp_eh_recover_pmp(ap, ops->prereset, ops->softreset,
1018 ops->hardreset, ops->postreset);
1022 /* handle disabled links */
1023 rc = sata_pmp_eh_handle_disabled_links(ap);
1028 rc = ata_eh_recover(ap, ops->pmp_prereset, ops->pmp_softreset,
1029 ops->pmp_hardreset, ops->pmp_postreset, &link);
1033 /* Connection status might have changed while resetting other
1034 * links, check SATA_PMP_GSCR_ERROR before returning.
1037 /* clear SNotification */
1038 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1040 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1042 /* enable notification */
1043 if (pmp_dev->flags & ATA_DFLAG_AN) {
1044 pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
1046 err_mask = sata_pmp_write(pmp_dev->link, SATA_PMP_GSCR_FEAT_EN,
1047 pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN]);
1049 ata_dev_printk(pmp_dev, KERN_ERR, "failed to write "
1050 "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
1056 /* check GSCR_ERROR */
1057 err_mask = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
1059 ata_dev_printk(pmp_dev, KERN_ERR, "failed to read "
1060 "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask);
1066 ata_port_for_each_link(link, ap) {
1067 if (!(gscr_error & (1 << link->pmp)))
1070 if (sata_pmp_handle_link_fail(link, link_tries)) {
1071 ata_ehi_hotplugged(&link->eh_context.i);
1074 ata_link_printk(link, KERN_WARNING,
1075 "PHY status changed but maxed out on retries, "
1077 ata_link_printk(link, KERN_WARNING,
1078 "Manully issue scan to resume this link\n");
1083 ata_port_printk(ap, KERN_INFO, "PMP SError.N set for some "
1084 "ports, repeating recovery\n");
1091 if (sata_pmp_handle_link_fail(link, link_tries)) {
1092 pmp_ehc->i.action |= ATA_EH_RESET;
1098 /* Control always ends up here after detaching PMP. Shut up
1099 * and return if we're unloading.
1101 if (ap->pflags & ATA_PFLAG_UNLOADING)
1104 if (!ap->nr_pmp_links)
1108 ata_port_printk(ap, KERN_WARNING,
1109 "failed to recover PMP, retrying in 5 secs\n");
1110 pmp_ehc->i.action |= ATA_EH_RESET;
1115 ata_port_printk(ap, KERN_ERR,
1116 "failed to recover PMP after %d tries, giving up\n",
1118 sata_pmp_detach(pmp_dev);
1119 ata_dev_disable(pmp_dev);
1125 * sata_pmp_error_handler - do standard error handling for PMP-enabled host
1126 * @ap: host port to handle error for
1128 * Perform standard error handling sequence for PMP-enabled host
1132 * Kernel thread context (may sleep).
1134 void sata_pmp_error_handler(struct ata_port *ap)
1138 sata_pmp_eh_recover(ap);