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
);
248 rc
= sata_link_hardreset(link
, timing
, deadline
);
250 ata_link_printk(link
, KERN_ERR
,
251 "COMRESET failed (errno=%d)\n", rc
);
255 /* clear SError bits including .X which blocks the port when set */
256 rc
= sata_scr_write(link
, SCR_ERROR
, 0xffffffff);
258 ata_link_printk(link
, KERN_ERR
, "failed to clear SError "
259 "during hardreset (errno=%d)\n", rc
);
263 /* if device is present, follow up with srst to wait for !BSY */
264 if (ata_link_online(link
))
267 /* if SCR isn't accessible, we need to reset the PMP */
268 if (rc
&& rc
!= -EAGAIN
&& sata_scr_read(link
, SCR_STATUS
, &tmp
))
271 DPRINTK("EXIT, rc=%d\n", rc
);
276 * ata_std_postreset - standard postreset method for PMP link
277 * @link: the target ata_link
278 * @classes: classes of attached devices
280 * This function is invoked after a successful reset. Note that
281 * the device might have been reset more than once using
282 * different reset methods before postreset is invoked.
285 * Kernel thread context (may sleep)
287 void sata_pmp_std_postreset(struct ata_link
*link
, unsigned int *class)
294 if (sata_scr_read(link
, SCR_ERROR
, &serror
) == 0)
295 sata_scr_write(link
, SCR_ERROR
, serror
);
297 /* print link status */
298 sata_print_link_status(link
);
304 * sata_pmp_read_gscr - read GSCR block of SATA PMP
306 * @gscr: buffer to read GSCR block into
308 * Read selected PMP GSCRs from the PMP at @dev. This will serve
309 * as configuration and identification info for the PMP.
312 * Kernel thread context (may sleep).
315 * 0 on success, -errno on failure.
317 static int sata_pmp_read_gscr(struct ata_device
*dev
, u32
*gscr
)
319 static const int gscr_to_read
[] = { 0, 1, 2, 32, 33, 64, 96 };
322 for (i
= 0; i
< ARRAY_SIZE(gscr_to_read
); i
++) {
323 int reg
= gscr_to_read
[i
];
324 unsigned int err_mask
;
326 err_mask
= sata_pmp_read(dev
->link
, reg
, &gscr
[reg
]);
328 ata_dev_printk(dev
, KERN_ERR
, "failed to read PMP "
329 "GSCR[%d] (Emask=0x%x)\n", reg
, err_mask
);
337 static const char *sata_pmp_spec_rev_str(const u32
*gscr
)
339 u32 rev
= gscr
[SATA_PMP_GSCR_REV
];
348 static int sata_pmp_configure(struct ata_device
*dev
, int print_info
)
350 struct ata_port
*ap
= dev
->link
->ap
;
351 u32
*gscr
= dev
->gscr
;
352 unsigned int err_mask
= 0;
356 nr_ports
= sata_pmp_gscr_ports(gscr
);
358 if (nr_ports
<= 0 || nr_ports
> SATA_PMP_MAX_PORTS
) {
360 reason
= "invalid nr_ports";
364 if ((ap
->flags
& ATA_FLAG_AN
) &&
365 (gscr
[SATA_PMP_GSCR_FEAT
] & SATA_PMP_FEAT_NOTIFY
))
366 dev
->flags
|= ATA_DFLAG_AN
;
368 /* monitor SERR_PHYRDY_CHG on fan-out ports */
369 err_mask
= sata_pmp_write(dev
->link
, SATA_PMP_GSCR_ERROR_EN
,
373 reason
= "failed to write GSCR_ERROR_EN";
377 /* turn off notification till fan-out ports are reset and configured */
378 if (gscr
[SATA_PMP_GSCR_FEAT_EN
] & SATA_PMP_FEAT_NOTIFY
) {
379 gscr
[SATA_PMP_GSCR_FEAT_EN
] &= ~SATA_PMP_FEAT_NOTIFY
;
381 err_mask
= sata_pmp_write(dev
->link
, SATA_PMP_GSCR_FEAT_EN
,
382 gscr
[SATA_PMP_GSCR_FEAT_EN
]);
385 reason
= "failed to write GSCR_FEAT_EN";
391 ata_dev_printk(dev
, KERN_INFO
, "Port Multiplier %s, "
392 "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
393 sata_pmp_spec_rev_str(gscr
),
394 sata_pmp_gscr_vendor(gscr
),
395 sata_pmp_gscr_devid(gscr
),
396 sata_pmp_gscr_rev(gscr
),
397 nr_ports
, gscr
[SATA_PMP_GSCR_FEAT_EN
],
398 gscr
[SATA_PMP_GSCR_FEAT
]);
400 if (!(dev
->flags
& ATA_DFLAG_AN
))
401 ata_dev_printk(dev
, KERN_INFO
,
402 "Asynchronous notification not supported, "
403 "hotplug won't\n work on fan-out "
404 "ports. Use warm-plug instead.\n");
410 ata_dev_printk(dev
, KERN_ERR
,
411 "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
416 static int sata_pmp_init_links(struct ata_port
*ap
, int nr_ports
)
418 struct ata_link
*pmp_link
= ap
->pmp_link
;
422 pmp_link
= kzalloc(sizeof(pmp_link
[0]) * SATA_PMP_MAX_PORTS
,
427 for (i
= 0; i
< SATA_PMP_MAX_PORTS
; i
++)
428 ata_link_init(ap
, &pmp_link
[i
], i
);
430 ap
->pmp_link
= pmp_link
;
433 for (i
= 0; i
< nr_ports
; i
++) {
434 struct ata_link
*link
= &pmp_link
[i
];
435 struct ata_eh_context
*ehc
= &link
->eh_context
;
438 ehc
->i
.probe_mask
|= ATA_ALL_DEVICES
;
439 ehc
->i
.action
|= ATA_EH_RESET
;
445 static void sata_pmp_quirks(struct ata_port
*ap
)
447 u32
*gscr
= ap
->link
.device
->gscr
;
448 u16 vendor
= sata_pmp_gscr_vendor(gscr
);
449 u16 devid
= sata_pmp_gscr_devid(gscr
);
450 struct ata_link
*link
;
452 if (vendor
== 0x1095 && devid
== 0x3726) {
454 ata_port_for_each_link(link
, ap
) {
455 /* class code report is unreliable */
457 link
->flags
|= ATA_LFLAG_ASSUME_ATA
;
459 /* port 5 is for SEMB device and it doesn't like SRST */
461 link
->flags
|= ATA_LFLAG_NO_SRST
|
462 ATA_LFLAG_ASSUME_SEMB
;
464 } else if (vendor
== 0x1095 && devid
== 0x4723) {
466 ata_port_for_each_link(link
, ap
) {
467 /* class code report is unreliable */
469 link
->flags
|= ATA_LFLAG_ASSUME_ATA
;
471 /* the config device at port 2 locks up on SRST */
473 link
->flags
|= ATA_LFLAG_NO_SRST
|
474 ATA_LFLAG_ASSUME_ATA
;
476 } else if (vendor
== 0x1095 && devid
== 0x4726) {
478 ata_port_for_each_link(link
, ap
) {
479 /* Class code report is unreliable and SRST
480 * times out under certain configurations.
481 * Config device can be at port 0 or 5 and
485 link
->flags
|= ATA_LFLAG_NO_SRST
|
486 ATA_LFLAG_ASSUME_ATA
;
488 /* Port 6 is for SEMB device which doesn't
492 link
->flags
|= ATA_LFLAG_NO_SRST
|
493 ATA_LFLAG_ASSUME_SEMB
;
495 } else if (vendor
== 0x1095 && (devid
== 0x5723 || devid
== 0x5733 ||
496 devid
== 0x5734 || devid
== 0x5744)) {
497 /* sil5723/5744 quirks */
499 /* sil5723/5744 has either two or three downstream
500 * ports depending on operation mode. The last port
501 * is empty if any actual IO device is available or
502 * occupied by a pseudo configuration device
503 * otherwise. Don't try hard to recover it.
505 ap
->pmp_link
[ap
->nr_pmp_links
- 1].flags
|= ATA_LFLAG_NO_RETRY
;
510 * sata_pmp_attach - attach a SATA PMP device
511 * @dev: SATA PMP device to attach
513 * Configure and attach SATA PMP device @dev. This function is
514 * also responsible for allocating and initializing PMP links.
517 * Kernel thread context (may sleep).
520 * 0 on success, -errno on failure.
522 int sata_pmp_attach(struct ata_device
*dev
)
524 struct ata_link
*link
= dev
->link
;
525 struct ata_port
*ap
= link
->ap
;
527 struct ata_link
*tlink
;
530 /* is it hanging off the right place? */
531 if (!(ap
->flags
& ATA_FLAG_PMP
)) {
532 ata_dev_printk(dev
, KERN_ERR
,
533 "host does not support Port Multiplier\n");
537 if (!ata_is_host_link(link
)) {
538 ata_dev_printk(dev
, KERN_ERR
,
539 "Port Multipliers cannot be nested\n");
544 ata_dev_printk(dev
, KERN_ERR
,
545 "Port Multiplier must be the first device\n");
549 WARN_ON(link
->pmp
!= 0);
550 link
->pmp
= SATA_PMP_CTRL_PORT
;
552 /* read GSCR block */
553 rc
= sata_pmp_read_gscr(dev
, dev
->gscr
);
558 rc
= sata_pmp_configure(dev
, 1);
562 rc
= sata_pmp_init_links(ap
, sata_pmp_gscr_ports(dev
->gscr
));
564 ata_dev_printk(dev
, KERN_INFO
,
565 "failed to initialize PMP links\n");
570 spin_lock_irqsave(ap
->lock
, flags
);
571 WARN_ON(ap
->nr_pmp_links
);
572 ap
->nr_pmp_links
= sata_pmp_gscr_ports(dev
->gscr
);
573 spin_unlock_irqrestore(ap
->lock
, flags
);
577 if (ap
->ops
->pmp_attach
)
578 ap
->ops
->pmp_attach(ap
);
580 ata_port_for_each_link(tlink
, ap
)
581 sata_link_init_spd(tlink
);
583 ata_acpi_associate_sata_port(ap
);
593 * sata_pmp_detach - detach a SATA PMP device
594 * @dev: SATA PMP device to detach
596 * Detach SATA PMP device @dev. This function is also
597 * responsible for deconfiguring PMP links.
600 * Kernel thread context (may sleep).
602 static void sata_pmp_detach(struct ata_device
*dev
)
604 struct ata_link
*link
= dev
->link
;
605 struct ata_port
*ap
= link
->ap
;
606 struct ata_link
*tlink
;
609 ata_dev_printk(dev
, KERN_INFO
, "Port Multiplier detaching\n");
611 WARN_ON(!ata_is_host_link(link
) || dev
->devno
||
612 link
->pmp
!= SATA_PMP_CTRL_PORT
);
614 if (ap
->ops
->pmp_detach
)
615 ap
->ops
->pmp_detach(ap
);
617 ata_port_for_each_link(tlink
, ap
)
618 ata_eh_detach_dev(tlink
->device
);
620 spin_lock_irqsave(ap
->lock
, flags
);
621 ap
->nr_pmp_links
= 0;
623 spin_unlock_irqrestore(ap
->lock
, flags
);
625 ata_acpi_associate_sata_port(ap
);
629 * sata_pmp_same_pmp - does new GSCR matches the configured PMP?
630 * @dev: PMP device to compare against
631 * @new_gscr: GSCR block of the new device
633 * Compare @new_gscr against @dev and determine whether @dev is
634 * the PMP described by @new_gscr.
640 * 1 if @dev matches @new_gscr, 0 otherwise.
642 static int sata_pmp_same_pmp(struct ata_device
*dev
, const u32
*new_gscr
)
644 const u32
*old_gscr
= dev
->gscr
;
645 u16 old_vendor
, new_vendor
, old_devid
, new_devid
;
646 int old_nr_ports
, new_nr_ports
;
648 old_vendor
= sata_pmp_gscr_vendor(old_gscr
);
649 new_vendor
= sata_pmp_gscr_vendor(new_gscr
);
650 old_devid
= sata_pmp_gscr_devid(old_gscr
);
651 new_devid
= sata_pmp_gscr_devid(new_gscr
);
652 old_nr_ports
= sata_pmp_gscr_ports(old_gscr
);
653 new_nr_ports
= sata_pmp_gscr_ports(new_gscr
);
655 if (old_vendor
!= new_vendor
) {
656 ata_dev_printk(dev
, KERN_INFO
, "Port Multiplier "
657 "vendor mismatch '0x%x' != '0x%x'\n",
658 old_vendor
, new_vendor
);
662 if (old_devid
!= new_devid
) {
663 ata_dev_printk(dev
, KERN_INFO
, "Port Multiplier "
664 "device ID mismatch '0x%x' != '0x%x'\n",
665 old_devid
, new_devid
);
669 if (old_nr_ports
!= new_nr_ports
) {
670 ata_dev_printk(dev
, KERN_INFO
, "Port Multiplier "
671 "nr_ports mismatch '0x%x' != '0x%x'\n",
672 old_nr_ports
, new_nr_ports
);
680 * sata_pmp_revalidate - revalidate SATA PMP
681 * @dev: PMP device to revalidate
682 * @new_class: new class code
684 * Re-read GSCR block and make sure @dev is still attached to the
685 * port and properly configured.
688 * Kernel thread context (may sleep).
691 * 0 on success, -errno otherwise.
693 static int sata_pmp_revalidate(struct ata_device
*dev
, unsigned int new_class
)
695 struct ata_link
*link
= dev
->link
;
696 struct ata_port
*ap
= link
->ap
;
697 u32
*gscr
= (void *)ap
->sector_buf
;
702 ata_eh_about_to_do(link
, NULL
, ATA_EH_REVALIDATE
);
704 if (!ata_dev_enabled(dev
)) {
710 if (ata_class_enabled(new_class
) && new_class
!= ATA_DEV_PMP
) {
716 rc
= sata_pmp_read_gscr(dev
, gscr
);
720 /* is the pmp still there? */
721 if (!sata_pmp_same_pmp(dev
, gscr
)) {
726 memcpy(dev
->gscr
, gscr
, sizeof(gscr
[0]) * SATA_PMP_GSCR_DWORDS
);
728 rc
= sata_pmp_configure(dev
, 0);
732 ata_eh_done(link
, NULL
, ATA_EH_REVALIDATE
);
734 DPRINTK("EXIT, rc=0\n");
738 ata_dev_printk(dev
, KERN_ERR
,
739 "PMP revalidation failed (errno=%d)\n", rc
);
740 DPRINTK("EXIT, rc=%d\n", rc
);
745 * sata_pmp_revalidate_quick - revalidate SATA PMP quickly
746 * @dev: PMP device to revalidate
748 * Make sure the attached PMP is accessible.
751 * Kernel thread context (may sleep).
754 * 0 on success, -errno otherwise.
756 static int sata_pmp_revalidate_quick(struct ata_device
*dev
)
758 unsigned int err_mask
;
761 err_mask
= sata_pmp_read(dev
->link
, SATA_PMP_GSCR_PROD_ID
, &prod_id
);
763 ata_dev_printk(dev
, KERN_ERR
, "failed to read PMP product ID "
764 "(Emask=0x%x)\n", err_mask
);
768 if (prod_id
!= dev
->gscr
[SATA_PMP_GSCR_PROD_ID
]) {
769 ata_dev_printk(dev
, KERN_ERR
, "PMP product ID mismatch\n");
770 /* something weird is going on, request full PMP recovery */
778 * sata_pmp_eh_recover_pmp - recover PMP
779 * @ap: ATA port PMP is attached to
780 * @prereset: prereset method (can be NULL)
781 * @softreset: softreset method
782 * @hardreset: hardreset method
783 * @postreset: postreset method (can be NULL)
785 * Recover PMP attached to @ap. Recovery procedure is somewhat
786 * similar to that of ata_eh_recover() except that reset should
787 * always be performed in hard->soft sequence and recovery
788 * failure results in PMP detachment.
791 * Kernel thread context (may sleep).
794 * 0 on success, -errno on failure.
796 static int sata_pmp_eh_recover_pmp(struct ata_port
*ap
,
797 ata_prereset_fn_t prereset
, ata_reset_fn_t softreset
,
798 ata_reset_fn_t hardreset
, ata_postreset_fn_t postreset
)
800 struct ata_link
*link
= &ap
->link
;
801 struct ata_eh_context
*ehc
= &link
->eh_context
;
802 struct ata_device
*dev
= link
->device
;
803 int tries
= ATA_EH_PMP_TRIES
;
804 int detach
= 0, rc
= 0;
805 int reval_failed
= 0;
809 if (dev
->flags
& ATA_DFLAG_DETACH
) {
815 ehc
->classes
[0] = ATA_DEV_UNKNOWN
;
817 if (ehc
->i
.action
& ATA_EH_RESET
) {
818 struct ata_link
*tlink
;
820 ata_eh_freeze_port(ap
);
823 rc
= ata_eh_reset(link
, 0, prereset
, softreset
, hardreset
,
826 ata_link_printk(link
, KERN_ERR
,
827 "failed to reset PMP, giving up\n");
831 ata_eh_thaw_port(ap
);
833 /* PMP is reset, SErrors cannot be trusted, scan all */
834 ata_port_for_each_link(tlink
, ap
) {
835 struct ata_eh_context
*ehc
= &tlink
->eh_context
;
837 ehc
->i
.probe_mask
|= ATA_ALL_DEVICES
;
838 ehc
->i
.action
|= ATA_EH_RESET
;
842 /* If revalidation is requested, revalidate and reconfigure;
843 * otherwise, do quick revalidation.
845 if (ehc
->i
.action
& ATA_EH_REVALIDATE
)
846 rc
= sata_pmp_revalidate(dev
, ehc
->classes
[0]);
848 rc
= sata_pmp_revalidate_quick(dev
);
854 ehc
->i
.probe_mask
|= ATA_ALL_DEVICES
;
856 /* give it just two more chances */
857 tries
= min(tries
, 2);
861 int sleep
= ehc
->i
.flags
& ATA_EHI_DID_RESET
;
863 /* consecutive revalidation failures? speed down */
865 sata_down_spd_limit(link
);
869 ata_dev_printk(dev
, KERN_WARNING
,
870 "retrying reset%s\n",
871 sleep
? " in 5 secs" : "");
874 ehc
->i
.action
|= ATA_EH_RESET
;
877 ata_dev_printk(dev
, KERN_ERR
, "failed to recover PMP "
878 "after %d tries, giving up\n",
884 /* okay, PMP resurrected */
887 DPRINTK("EXIT, rc=0\n");
891 sata_pmp_detach(dev
);
893 ata_eh_detach_dev(dev
);
895 ata_dev_disable(dev
);
897 DPRINTK("EXIT, rc=%d\n", rc
);
901 static int sata_pmp_eh_handle_disabled_links(struct ata_port
*ap
)
903 struct ata_link
*link
;
907 spin_lock_irqsave(ap
->lock
, flags
);
909 ata_port_for_each_link(link
, ap
) {
910 if (!(link
->flags
& ATA_LFLAG_DISABLED
))
913 spin_unlock_irqrestore(ap
->lock
, flags
);
915 /* Some PMPs require hardreset sequence to get
918 sata_link_hardreset(link
, sata_deb_timing_normal
,
919 jiffies
+ ATA_TMOUT_INTERNAL_QUICK
);
921 /* unconditionally clear SError.N */
922 rc
= sata_scr_write(link
, SCR_ERROR
, SERR_PHYRDY_CHG
);
924 ata_link_printk(link
, KERN_ERR
, "failed to clear "
925 "SError.N (errno=%d)\n", rc
);
929 spin_lock_irqsave(ap
->lock
, flags
);
932 spin_unlock_irqrestore(ap
->lock
, flags
);
937 static int sata_pmp_handle_link_fail(struct ata_link
*link
, int *link_tries
)
939 struct ata_port
*ap
= link
->ap
;
942 if (link_tries
[link
->pmp
] && --link_tries
[link
->pmp
])
945 /* disable this link */
946 if (!(link
->flags
& ATA_LFLAG_DISABLED
)) {
947 ata_link_printk(link
, KERN_WARNING
,
948 "failed to recover link after %d tries, disabling\n",
949 ATA_EH_PMP_LINK_TRIES
);
951 spin_lock_irqsave(ap
->lock
, flags
);
952 link
->flags
|= ATA_LFLAG_DISABLED
;
953 spin_unlock_irqrestore(ap
->lock
, flags
);
956 ata_dev_disable(link
->device
);
957 link
->eh_context
.i
.action
= 0;
963 * sata_pmp_eh_recover - recover PMP-enabled port
964 * @ap: ATA port to recover
965 * @prereset: prereset method (can be NULL)
966 * @softreset: softreset method
967 * @hardreset: hardreset method
968 * @postreset: postreset method (can be NULL)
969 * @pmp_prereset: PMP prereset method (can be NULL)
970 * @pmp_softreset: PMP softreset method (can be NULL)
971 * @pmp_hardreset: PMP hardreset method (can be NULL)
972 * @pmp_postreset: PMP postreset method (can be NULL)
974 * Drive EH recovery operation for PMP enabled port @ap. This
975 * function recovers host and PMP ports with proper retrials and
976 * fallbacks. Actual recovery operations are performed using
977 * ata_eh_recover() and sata_pmp_eh_recover_pmp().
980 * Kernel thread context (may sleep).
983 * 0 on success, -errno on failure.
985 static int sata_pmp_eh_recover(struct ata_port
*ap
,
986 ata_prereset_fn_t prereset
, ata_reset_fn_t softreset
,
987 ata_reset_fn_t hardreset
, ata_postreset_fn_t postreset
,
988 ata_prereset_fn_t pmp_prereset
, ata_reset_fn_t pmp_softreset
,
989 ata_reset_fn_t pmp_hardreset
, ata_postreset_fn_t pmp_postreset
)
991 int pmp_tries
, link_tries
[SATA_PMP_MAX_PORTS
];
992 struct ata_link
*pmp_link
= &ap
->link
;
993 struct ata_device
*pmp_dev
= pmp_link
->device
;
994 struct ata_eh_context
*pmp_ehc
= &pmp_link
->eh_context
;
995 struct ata_link
*link
;
996 struct ata_device
*dev
;
997 unsigned int err_mask
;
998 u32 gscr_error
, sntf
;
1001 pmp_tries
= ATA_EH_PMP_TRIES
;
1002 ata_port_for_each_link(link
, ap
)
1003 link_tries
[link
->pmp
] = ATA_EH_PMP_LINK_TRIES
;
1007 if (!ap
->nr_pmp_links
) {
1008 rc
= ata_eh_recover(ap
, prereset
, softreset
, hardreset
,
1011 ata_link_for_each_dev(dev
, &ap
->link
)
1012 ata_dev_disable(dev
);
1016 if (pmp_dev
->class != ATA_DEV_PMP
)
1019 /* new PMP online */
1020 ata_port_for_each_link(link
, ap
)
1021 link_tries
[link
->pmp
] = ATA_EH_PMP_LINK_TRIES
;
1027 rc
= sata_pmp_eh_recover_pmp(ap
, prereset
, softreset
, hardreset
,
1032 /* handle disabled links */
1033 rc
= sata_pmp_eh_handle_disabled_links(ap
);
1038 rc
= ata_eh_recover(ap
, pmp_prereset
, pmp_softreset
, pmp_hardreset
,
1039 pmp_postreset
, &link
);
1043 /* Connection status might have changed while resetting other
1044 * links, check SATA_PMP_GSCR_ERROR before returning.
1047 /* clear SNotification */
1048 rc
= sata_scr_read(&ap
->link
, SCR_NOTIFICATION
, &sntf
);
1050 sata_scr_write(&ap
->link
, SCR_NOTIFICATION
, sntf
);
1052 /* enable notification */
1053 if (pmp_dev
->flags
& ATA_DFLAG_AN
) {
1054 pmp_dev
->gscr
[SATA_PMP_GSCR_FEAT_EN
] |= SATA_PMP_FEAT_NOTIFY
;
1056 err_mask
= sata_pmp_write(pmp_dev
->link
, SATA_PMP_GSCR_FEAT_EN
,
1057 pmp_dev
->gscr
[SATA_PMP_GSCR_FEAT_EN
]);
1059 ata_dev_printk(pmp_dev
, KERN_ERR
, "failed to write "
1060 "PMP_FEAT_EN (Emask=0x%x)\n", err_mask
);
1066 /* check GSCR_ERROR */
1067 err_mask
= sata_pmp_read(pmp_link
, SATA_PMP_GSCR_ERROR
, &gscr_error
);
1069 ata_dev_printk(pmp_dev
, KERN_ERR
, "failed to read "
1070 "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask
);
1076 ata_port_for_each_link(link
, ap
) {
1077 if (!(gscr_error
& (1 << link
->pmp
)))
1080 if (sata_pmp_handle_link_fail(link
, link_tries
)) {
1081 ata_ehi_hotplugged(&link
->eh_context
.i
);
1084 ata_link_printk(link
, KERN_WARNING
,
1085 "PHY status changed but maxed out on retries, "
1087 ata_link_printk(link
, KERN_WARNING
,
1088 "Manully issue scan to resume this link\n");
1093 ata_port_printk(ap
, KERN_INFO
, "PMP SError.N set for some "
1094 "ports, repeating recovery\n");
1101 if (sata_pmp_handle_link_fail(link
, link_tries
)) {
1102 pmp_ehc
->i
.action
|= ATA_EH_RESET
;
1108 /* Control always ends up here after detaching PMP. Shut up
1109 * and return if we're unloading.
1111 if (ap
->pflags
& ATA_PFLAG_UNLOADING
)
1114 if (!ap
->nr_pmp_links
)
1118 ata_port_printk(ap
, KERN_WARNING
,
1119 "failed to recover PMP, retrying in 5 secs\n");
1120 pmp_ehc
->i
.action
|= ATA_EH_RESET
;
1125 ata_port_printk(ap
, KERN_ERR
,
1126 "failed to recover PMP after %d tries, giving up\n",
1128 sata_pmp_detach(pmp_dev
);
1129 ata_dev_disable(pmp_dev
);
1135 * sata_pmp_do_eh - do standard error handling for PMP-enabled host
1136 * @ap: host port to handle error for
1137 * @prereset: prereset method (can be NULL)
1138 * @softreset: softreset method
1139 * @hardreset: hardreset method
1140 * @postreset: postreset method (can be NULL)
1141 * @pmp_prereset: PMP prereset method (can be NULL)
1142 * @pmp_softreset: PMP softreset method (can be NULL)
1143 * @pmp_hardreset: PMP hardreset method (can be NULL)
1144 * @pmp_postreset: PMP postreset method (can be NULL)
1146 * Perform standard error handling sequence for PMP-enabled host
1150 * Kernel thread context (may sleep).
1152 void sata_pmp_do_eh(struct ata_port
*ap
,
1153 ata_prereset_fn_t prereset
, ata_reset_fn_t softreset
,
1154 ata_reset_fn_t hardreset
, ata_postreset_fn_t postreset
,
1155 ata_prereset_fn_t pmp_prereset
, ata_reset_fn_t pmp_softreset
,
1156 ata_reset_fn_t pmp_hardreset
, ata_postreset_fn_t pmp_postreset
)
1160 sata_pmp_eh_recover(ap
, prereset
, softreset
, hardreset
, postreset
,
1161 pmp_prereset
, pmp_softreset
, pmp_hardreset
,