1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Support for SATA devices on Serial Attached SCSI (SAS) controllers
5 * Copyright (C) 2006 IBM Corporation
7 * Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation
10 #include <linux/scatterlist.h>
11 #include <linux/slab.h>
12 #include <linux/async.h>
13 #include <linux/export.h>
15 #include <scsi/sas_ata.h>
16 #include "sas_internal.h"
17 #include <scsi/scsi_host.h>
18 #include <scsi/scsi_device.h>
19 #include <scsi/scsi_tcq.h>
20 #include <scsi/scsi.h>
21 #include <scsi/scsi_transport.h>
22 #include <scsi/scsi_transport_sas.h>
23 #include "../scsi_sas_internal.h"
24 #include "../scsi_transport_api.h"
25 #include <scsi/scsi_eh.h>
27 static enum ata_completion_errors
sas_to_ata_err(struct task_status_struct
*ts
)
29 /* Cheesy attempt to translate SAS errors into ATA. Hah! */
32 if (ts
->resp
== SAS_TASK_UNDELIVERED
)
33 return AC_ERR_ATA_BUS
;
35 /* ts->resp == SAS_TASK_COMPLETE */
36 /* task delivered, what happened afterwards? */
38 case SAS_DEV_NO_RESPONSE
:
39 return AC_ERR_TIMEOUT
;
44 return AC_ERR_ATA_BUS
;
47 case SAS_DATA_UNDERRUN
:
49 * Some programs that use the taskfile interface
50 * (smartctl in particular) can cause underrun
51 * problems. Ignore these errors, perhaps at our
56 case SAS_DATA_OVERRUN
:
58 case SAS_DEVICE_UNKNOWN
:
60 return AC_ERR_INVALID
;
64 pr_warn("%s: Saw error %d. What to do?\n",
68 case SAM_STAT_CHECK_CONDITION
:
69 case SAS_ABORTED_TASK
:
72 case SAS_PROTO_RESPONSE
:
73 /* This means the ending_fis has the error
74 * value; return 0 here to collect it */
81 static void sas_ata_task_done(struct sas_task
*task
)
83 struct ata_queued_cmd
*qc
= task
->uldd_task
;
84 struct domain_device
*dev
= task
->dev
;
85 struct task_status_struct
*stat
= &task
->task_status
;
86 struct ata_task_resp
*resp
= (struct ata_task_resp
*)stat
->buf
;
87 struct sas_ha_struct
*sas_ha
= dev
->port
->ha
;
88 enum ata_completion_errors ac
;
90 struct ata_link
*link
;
93 spin_lock_irqsave(&dev
->done_lock
, flags
);
94 if (test_bit(SAS_HA_FROZEN
, &sas_ha
->state
))
96 else if (qc
&& qc
->scsicmd
)
97 ASSIGN_SAS_TASK(qc
->scsicmd
, NULL
);
98 spin_unlock_irqrestore(&dev
->done_lock
, flags
);
100 /* check if libsas-eh got to the task before us */
105 goto qc_already_gone
;
110 spin_lock_irqsave(ap
->lock
, flags
);
111 /* check if we lost the race with libata/sas_ata_post_internal() */
112 if (unlikely(ap
->pflags
& ATA_PFLAG_FROZEN
)) {
113 spin_unlock_irqrestore(ap
->lock
, flags
);
115 goto qc_already_gone
;
117 /* if eh is not involved and the port is frozen then the
118 * ata internal abort process has taken responsibility
125 if (stat
->stat
== SAS_PROTO_RESPONSE
|| stat
->stat
== SAM_STAT_GOOD
||
126 ((stat
->stat
== SAM_STAT_CHECK_CONDITION
&&
127 dev
->sata_dev
.class == ATA_DEV_ATAPI
))) {
128 memcpy(dev
->sata_dev
.fis
, resp
->ending_fis
, ATA_RESP_FIS_SIZE
);
130 if (!link
->sactive
) {
131 qc
->err_mask
|= ac_err_mask(dev
->sata_dev
.fis
[2]);
133 link
->eh_info
.err_mask
|= ac_err_mask(dev
->sata_dev
.fis
[2]);
134 if (unlikely(link
->eh_info
.err_mask
))
135 qc
->flags
|= ATA_QCFLAG_FAILED
;
138 ac
= sas_to_ata_err(stat
);
140 pr_warn("%s: SAS error 0x%x\n", __func__
, stat
->stat
);
141 /* We saw a SAS error. Send a vague error. */
142 if (!link
->sactive
) {
145 link
->eh_info
.err_mask
|= AC_ERR_DEV
;
146 qc
->flags
|= ATA_QCFLAG_FAILED
;
149 dev
->sata_dev
.fis
[3] = 0x04; /* status err */
150 dev
->sata_dev
.fis
[2] = ATA_ERR
;
154 qc
->lldd_task
= NULL
;
156 spin_unlock_irqrestore(ap
->lock
, flags
);
162 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd
*qc
)
163 __must_hold(ap
->lock
)
165 struct sas_task
*task
;
166 struct scatterlist
*sg
;
167 int ret
= AC_ERR_SYSTEM
;
168 unsigned int si
, xfer
= 0;
169 struct ata_port
*ap
= qc
->ap
;
170 struct domain_device
*dev
= ap
->private_data
;
171 struct sas_ha_struct
*sas_ha
= dev
->port
->ha
;
172 struct Scsi_Host
*host
= sas_ha
->core
.shost
;
173 struct sas_internal
*i
= to_sas_internal(host
->transportt
);
175 /* TODO: we should try to remove that unlock */
176 spin_unlock(ap
->lock
);
178 /* If the device fell off, no sense in issuing commands */
179 if (test_bit(SAS_DEV_GONE
, &dev
->state
))
182 task
= sas_alloc_task(GFP_ATOMIC
);
186 task
->task_proto
= SAS_PROTOCOL_STP
;
187 task
->task_done
= sas_ata_task_done
;
189 if (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
190 qc
->tf
.command
== ATA_CMD_FPDMA_READ
||
191 qc
->tf
.command
== ATA_CMD_FPDMA_RECV
||
192 qc
->tf
.command
== ATA_CMD_FPDMA_SEND
||
193 qc
->tf
.command
== ATA_CMD_NCQ_NON_DATA
) {
194 /* Need to zero out the tag libata assigned us */
198 ata_tf_to_fis(&qc
->tf
, qc
->dev
->link
->pmp
, 1, (u8
*)&task
->ata_task
.fis
);
199 task
->uldd_task
= qc
;
200 if (ata_is_atapi(qc
->tf
.protocol
)) {
201 memcpy(task
->ata_task
.atapi_packet
, qc
->cdb
, qc
->dev
->cdb_len
);
202 task
->total_xfer_len
= qc
->nbytes
;
203 task
->num_scatter
= qc
->n_elem
;
205 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
)
206 xfer
+= sg_dma_len(sg
);
208 task
->total_xfer_len
= xfer
;
209 task
->num_scatter
= si
;
212 if (qc
->tf
.protocol
== ATA_PROT_NODATA
)
213 task
->data_dir
= DMA_NONE
;
215 task
->data_dir
= qc
->dma_dir
;
216 task
->scatter
= qc
->sg
;
217 task
->ata_task
.retry_count
= 1;
218 task
->task_state_flags
= SAS_TASK_STATE_PENDING
;
219 qc
->lldd_task
= task
;
221 task
->ata_task
.use_ncq
= ata_is_ncq(qc
->tf
.protocol
);
222 task
->ata_task
.dma_xfer
= ata_is_dma(qc
->tf
.protocol
);
225 ASSIGN_SAS_TASK(qc
->scsicmd
, task
);
227 ret
= i
->dft
->lldd_execute_task(task
, GFP_ATOMIC
);
229 pr_debug("lldd_execute_task returned: %d\n", ret
);
232 ASSIGN_SAS_TASK(qc
->scsicmd
, NULL
);
234 qc
->lldd_task
= NULL
;
243 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd
*qc
)
245 struct domain_device
*dev
= qc
->ap
->private_data
;
247 ata_tf_from_fis(dev
->sata_dev
.fis
, &qc
->result_tf
);
251 static struct sas_internal
*dev_to_sas_internal(struct domain_device
*dev
)
253 return to_sas_internal(dev
->port
->ha
->core
.shost
->transportt
);
256 static int sas_get_ata_command_set(struct domain_device
*dev
);
258 int sas_get_ata_info(struct domain_device
*dev
, struct ex_phy
*phy
)
260 if (phy
->attached_tproto
& SAS_PROTOCOL_STP
)
261 dev
->tproto
= phy
->attached_tproto
;
262 if (phy
->attached_sata_dev
)
263 dev
->tproto
|= SAS_SATA_DEV
;
265 if (phy
->attached_dev_type
== SAS_SATA_PENDING
)
266 dev
->dev_type
= SAS_SATA_PENDING
;
270 dev
->dev_type
= SAS_SATA_DEV
;
271 res
= sas_get_report_phy_sata(dev
->parent
, phy
->phy_id
,
272 &dev
->sata_dev
.rps_resp
);
274 pr_debug("report phy sata to %016llx:%02d returned 0x%x\n",
275 SAS_ADDR(dev
->parent
->sas_addr
),
279 memcpy(dev
->frame_rcvd
, &dev
->sata_dev
.rps_resp
.rps
.fis
,
280 sizeof(struct dev_to_host_fis
));
281 dev
->sata_dev
.class = sas_get_ata_command_set(dev
);
286 static int sas_ata_clear_pending(struct domain_device
*dev
, struct ex_phy
*phy
)
290 /* we weren't pending, so successfully end the reset sequence now */
291 if (dev
->dev_type
!= SAS_SATA_PENDING
)
294 /* hmmm, if this succeeds do we need to repost the domain_device to the
295 * lldd so it can pick up new parameters?
297 res
= sas_get_ata_info(dev
, phy
);
299 return 0; /* retry */
304 static int smp_ata_check_ready(struct ata_link
*link
)
307 struct ata_port
*ap
= link
->ap
;
308 struct domain_device
*dev
= ap
->private_data
;
309 struct domain_device
*ex_dev
= dev
->parent
;
310 struct sas_phy
*phy
= sas_get_local_phy(dev
);
311 struct ex_phy
*ex_phy
= &ex_dev
->ex_dev
.ex_phy
[phy
->number
];
313 res
= sas_ex_phy_discover(ex_dev
, phy
->number
);
314 sas_put_local_phy(phy
);
316 /* break the wait early if the expander is unreachable,
317 * otherwise keep polling
321 if (res
!= SMP_RESP_FUNC_ACC
)
324 switch (ex_phy
->attached_dev_type
) {
325 case SAS_SATA_PENDING
:
328 if (ex_phy
->attached_sata_dev
)
329 return sas_ata_clear_pending(dev
, ex_phy
);
336 static int local_ata_check_ready(struct ata_link
*link
)
338 struct ata_port
*ap
= link
->ap
;
339 struct domain_device
*dev
= ap
->private_data
;
340 struct sas_internal
*i
= dev_to_sas_internal(dev
);
342 if (i
->dft
->lldd_ata_check_ready
)
343 return i
->dft
->lldd_ata_check_ready(dev
);
345 /* lldd's that don't implement 'ready' checking get the
346 * old default behavior of not coordinating reset
347 * recovery with libata
353 static int sas_ata_printk(const char *level
, const struct domain_device
*ddev
,
354 const char *fmt
, ...)
356 struct ata_port
*ap
= ddev
->sata_dev
.ap
;
357 struct device
*dev
= &ddev
->rphy
->dev
;
358 struct va_format vaf
;
367 r
= printk("%s" SAS_FMT
"ata%u: %s: %pV",
368 level
, ap
->print_id
, dev_name(dev
), &vaf
);
375 static int sas_ata_hard_reset(struct ata_link
*link
, unsigned int *class,
376 unsigned long deadline
)
380 struct ata_port
*ap
= link
->ap
;
381 int (*check_ready
)(struct ata_link
*link
);
382 struct domain_device
*dev
= ap
->private_data
;
383 struct sas_internal
*i
= dev_to_sas_internal(dev
);
385 res
= i
->dft
->lldd_I_T_nexus_reset(dev
);
389 if (res
!= TMF_RESP_FUNC_COMPLETE
)
390 sas_ata_printk(KERN_DEBUG
, dev
, "Unable to reset ata device?\n");
392 phy
= sas_get_local_phy(dev
);
393 if (scsi_is_sas_phy_local(phy
))
394 check_ready
= local_ata_check_ready
;
396 check_ready
= smp_ata_check_ready
;
397 sas_put_local_phy(phy
);
399 ret
= ata_wait_after_reset(link
, deadline
, check_ready
);
400 if (ret
&& ret
!= -EAGAIN
)
401 sas_ata_printk(KERN_ERR
, dev
, "reset failed (errno=%d)\n", ret
);
403 *class = dev
->sata_dev
.class;
405 ap
->cbl
= ATA_CBL_SATA
;
410 * notify the lldd to forget the sas_task for this internal ata command
411 * that bypasses scsi-eh
413 static void sas_ata_internal_abort(struct sas_task
*task
)
415 struct sas_internal
*si
= dev_to_sas_internal(task
->dev
);
419 spin_lock_irqsave(&task
->task_state_lock
, flags
);
420 if (task
->task_state_flags
& SAS_TASK_STATE_ABORTED
||
421 task
->task_state_flags
& SAS_TASK_STATE_DONE
) {
422 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
423 pr_debug("%s: Task %p already finished.\n", __func__
, task
);
426 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
427 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
429 res
= si
->dft
->lldd_abort_task(task
);
431 spin_lock_irqsave(&task
->task_state_lock
, flags
);
432 if (task
->task_state_flags
& SAS_TASK_STATE_DONE
||
433 res
== TMF_RESP_FUNC_COMPLETE
) {
434 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
438 /* XXX we are not prepared to deal with ->lldd_abort_task()
439 * failures. TODO: lldds need to unconditionally forget about
440 * aborted ata tasks, otherwise we (likely) leak the sas task
443 pr_warn("%s: Task %p leaked.\n", __func__
, task
);
445 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
))
446 task
->task_state_flags
&= ~SAS_TASK_STATE_ABORTED
;
447 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
454 static void sas_ata_post_internal(struct ata_queued_cmd
*qc
)
456 if (qc
->flags
& ATA_QCFLAG_FAILED
)
457 qc
->err_mask
|= AC_ERR_OTHER
;
461 * Find the sas_task and kill it. By this point, libata
462 * has decided to kill the qc and has frozen the port.
463 * In this state sas_ata_task_done() will no longer free
464 * the sas_task, so we need to notify the lldd (via
465 * ->lldd_abort_task) that the task is dead and free it
468 struct sas_task
*task
= qc
->lldd_task
;
470 qc
->lldd_task
= NULL
;
473 task
->uldd_task
= NULL
;
474 sas_ata_internal_abort(task
);
479 static void sas_ata_set_dmamode(struct ata_port
*ap
, struct ata_device
*ata_dev
)
481 struct domain_device
*dev
= ap
->private_data
;
482 struct sas_internal
*i
= dev_to_sas_internal(dev
);
484 if (i
->dft
->lldd_ata_set_dmamode
)
485 i
->dft
->lldd_ata_set_dmamode(dev
);
488 static void sas_ata_sched_eh(struct ata_port
*ap
)
490 struct domain_device
*dev
= ap
->private_data
;
491 struct sas_ha_struct
*ha
= dev
->port
->ha
;
494 spin_lock_irqsave(&ha
->lock
, flags
);
495 if (!test_and_set_bit(SAS_DEV_EH_PENDING
, &dev
->state
))
497 ata_std_sched_eh(ap
);
498 spin_unlock_irqrestore(&ha
->lock
, flags
);
501 void sas_ata_end_eh(struct ata_port
*ap
)
503 struct domain_device
*dev
= ap
->private_data
;
504 struct sas_ha_struct
*ha
= dev
->port
->ha
;
507 spin_lock_irqsave(&ha
->lock
, flags
);
508 if (test_and_clear_bit(SAS_DEV_EH_PENDING
, &dev
->state
))
510 spin_unlock_irqrestore(&ha
->lock
, flags
);
513 static int sas_ata_prereset(struct ata_link
*link
, unsigned long deadline
)
515 struct ata_port
*ap
= link
->ap
;
516 struct domain_device
*dev
= ap
->private_data
;
517 struct sas_phy
*local_phy
= sas_get_local_phy(dev
);
520 if (!local_phy
->enabled
|| test_bit(SAS_DEV_GONE
, &dev
->state
))
522 sas_put_local_phy(local_phy
);
527 static struct ata_port_operations sas_sata_ops
= {
528 .prereset
= sas_ata_prereset
,
529 .hardreset
= sas_ata_hard_reset
,
530 .error_handler
= ata_std_error_handler
,
531 .post_internal_cmd
= sas_ata_post_internal
,
532 .qc_defer
= ata_std_qc_defer
,
533 .qc_prep
= ata_noop_qc_prep
,
534 .qc_issue
= sas_ata_qc_issue
,
535 .qc_fill_rtf
= sas_ata_qc_fill_rtf
,
536 .port_start
= ata_sas_port_start
,
537 .port_stop
= ata_sas_port_stop
,
538 .set_dmamode
= sas_ata_set_dmamode
,
539 .sched_eh
= sas_ata_sched_eh
,
540 .end_eh
= sas_ata_end_eh
,
543 static struct ata_port_info sata_port_info
= {
544 .flags
= ATA_FLAG_SATA
| ATA_FLAG_PIO_DMA
| ATA_FLAG_NCQ
|
545 ATA_FLAG_SAS_HOST
| ATA_FLAG_FPDMA_AUX
,
546 .pio_mask
= ATA_PIO4
,
547 .mwdma_mask
= ATA_MWDMA2
,
548 .udma_mask
= ATA_UDMA6
,
549 .port_ops
= &sas_sata_ops
552 int sas_ata_init(struct domain_device
*found_dev
)
554 struct sas_ha_struct
*ha
= found_dev
->port
->ha
;
555 struct Scsi_Host
*shost
= ha
->core
.shost
;
556 struct ata_host
*ata_host
;
560 ata_host
= kzalloc(sizeof(*ata_host
), GFP_KERNEL
);
562 pr_err("ata host alloc failed.\n");
566 ata_host_init(ata_host
, ha
->dev
, &sas_sata_ops
);
568 ap
= ata_sas_port_alloc(ata_host
, &sata_port_info
, shost
);
570 pr_err("ata_sas_port_alloc failed.\n");
575 ap
->private_data
= found_dev
;
576 ap
->cbl
= ATA_CBL_SATA
;
577 ap
->scsi_host
= shost
;
578 rc
= ata_sas_port_init(ap
);
582 rc
= ata_sas_tport_add(ata_host
->dev
, ap
);
586 found_dev
->sata_dev
.ata_host
= ata_host
;
587 found_dev
->sata_dev
.ap
= ap
;
592 ata_sas_port_destroy(ap
);
594 ata_host_put(ata_host
);
598 void sas_ata_task_abort(struct sas_task
*task
)
600 struct ata_queued_cmd
*qc
= task
->uldd_task
;
601 struct completion
*waiting
;
603 /* Bounce SCSI-initiated commands to the SCSI EH */
605 blk_abort_request(qc
->scsicmd
->request
);
609 /* Internal command, fake a timeout and complete. */
610 qc
->flags
&= ~ATA_QCFLAG_ACTIVE
;
611 qc
->flags
|= ATA_QCFLAG_FAILED
;
612 qc
->err_mask
|= AC_ERR_TIMEOUT
;
613 waiting
= qc
->private_data
;
617 static int sas_get_ata_command_set(struct domain_device
*dev
)
619 struct dev_to_host_fis
*fis
=
620 (struct dev_to_host_fis
*) dev
->frame_rcvd
;
621 struct ata_taskfile tf
;
623 if (dev
->dev_type
== SAS_SATA_PENDING
)
624 return ATA_DEV_UNKNOWN
;
626 ata_tf_from_fis((const u8
*)fis
, &tf
);
628 return ata_dev_classify(&tf
);
631 void sas_probe_sata(struct asd_sas_port
*port
)
633 struct domain_device
*dev
, *n
;
635 mutex_lock(&port
->ha
->disco_mutex
);
636 list_for_each_entry(dev
, &port
->disco_list
, disco_list_node
) {
637 if (!dev_is_sata(dev
))
640 ata_sas_async_probe(dev
->sata_dev
.ap
);
642 mutex_unlock(&port
->ha
->disco_mutex
);
644 list_for_each_entry_safe(dev
, n
, &port
->disco_list
, disco_list_node
) {
645 if (!dev_is_sata(dev
))
648 sas_ata_wait_eh(dev
);
650 /* if libata could not bring the link up, don't surface
653 if (!ata_dev_enabled(sas_to_ata_dev(dev
)))
654 sas_fail_probe(dev
, __func__
, -ENODEV
);
659 static void sas_ata_flush_pm_eh(struct asd_sas_port
*port
, const char *func
)
661 struct domain_device
*dev
, *n
;
663 list_for_each_entry_safe(dev
, n
, &port
->dev_list
, dev_list_node
) {
664 if (!dev_is_sata(dev
))
667 sas_ata_wait_eh(dev
);
669 /* if libata failed to power manage the device, tear it down */
670 if (ata_dev_disabled(sas_to_ata_dev(dev
)))
671 sas_fail_probe(dev
, func
, -ENODEV
);
675 void sas_suspend_sata(struct asd_sas_port
*port
)
677 struct domain_device
*dev
;
679 mutex_lock(&port
->ha
->disco_mutex
);
680 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
681 struct sata_device
*sata
;
683 if (!dev_is_sata(dev
))
686 sata
= &dev
->sata_dev
;
687 if (sata
->ap
->pm_mesg
.event
== PM_EVENT_SUSPEND
)
690 ata_sas_port_suspend(sata
->ap
);
692 mutex_unlock(&port
->ha
->disco_mutex
);
694 sas_ata_flush_pm_eh(port
, __func__
);
697 void sas_resume_sata(struct asd_sas_port
*port
)
699 struct domain_device
*dev
;
701 mutex_lock(&port
->ha
->disco_mutex
);
702 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
703 struct sata_device
*sata
;
705 if (!dev_is_sata(dev
))
708 sata
= &dev
->sata_dev
;
709 if (sata
->ap
->pm_mesg
.event
== PM_EVENT_ON
)
712 ata_sas_port_resume(sata
->ap
);
714 mutex_unlock(&port
->ha
->disco_mutex
);
716 sas_ata_flush_pm_eh(port
, __func__
);
720 * sas_discover_sata - discover an STP/SATA domain device
721 * @dev: pointer to struct domain_device of interest
723 * Devices directly attached to a HA port, have no parents. All other
724 * devices do, and should have their "parent" pointer set appropriately
725 * before calling this function.
727 int sas_discover_sata(struct domain_device
*dev
)
729 if (dev
->dev_type
== SAS_SATA_PM
)
732 dev
->sata_dev
.class = sas_get_ata_command_set(dev
);
733 sas_fill_in_rphy(dev
, dev
->rphy
);
735 return sas_notify_lldd_dev_found(dev
);
738 static void async_sas_ata_eh(void *data
, async_cookie_t cookie
)
740 struct domain_device
*dev
= data
;
741 struct ata_port
*ap
= dev
->sata_dev
.ap
;
742 struct sas_ha_struct
*ha
= dev
->port
->ha
;
744 sas_ata_printk(KERN_DEBUG
, dev
, "dev error handler\n");
745 ata_scsi_port_error_handler(ha
->core
.shost
, ap
);
749 void sas_ata_strategy_handler(struct Scsi_Host
*shost
)
751 struct sas_ha_struct
*sas_ha
= SHOST_TO_SAS_HA(shost
);
752 ASYNC_DOMAIN_EXCLUSIVE(async
);
755 /* it's ok to defer revalidation events during ata eh, these
756 * disks are in one of three states:
757 * 1/ present for initial domain discovery, and these
758 * resets will cause bcn flutters
759 * 2/ hot removed, we'll discover that after eh fails
760 * 3/ hot added after initial discovery, lost the race, and need
761 * to catch the next train.
763 sas_disable_revalidation(sas_ha
);
765 spin_lock_irq(&sas_ha
->phy_port_lock
);
766 for (i
= 0; i
< sas_ha
->num_phys
; i
++) {
767 struct asd_sas_port
*port
= sas_ha
->sas_port
[i
];
768 struct domain_device
*dev
;
770 spin_lock(&port
->dev_list_lock
);
771 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
772 if (!dev_is_sata(dev
))
775 /* hold a reference over eh since we may be
776 * racing with final remove once all commands
779 kref_get(&dev
->kref
);
781 async_schedule_domain(async_sas_ata_eh
, dev
, &async
);
783 spin_unlock(&port
->dev_list_lock
);
785 spin_unlock_irq(&sas_ha
->phy_port_lock
);
787 async_synchronize_full_domain(&async
);
789 sas_enable_revalidation(sas_ha
);
792 void sas_ata_eh(struct Scsi_Host
*shost
, struct list_head
*work_q
,
793 struct list_head
*done_q
)
795 struct scsi_cmnd
*cmd
, *n
;
796 struct domain_device
*eh_dev
;
802 list_for_each_entry_safe(cmd
, n
, work_q
, eh_entry
) {
803 struct domain_device
*ddev
= cmd_to_domain_dev(cmd
);
805 if (!dev_is_sata(ddev
) || TO_SAS_TASK(cmd
))
807 if (eh_dev
&& eh_dev
!= ddev
)
810 list_move(&cmd
->eh_entry
, &sata_q
);
813 if (!list_empty(&sata_q
)) {
814 struct ata_port
*ap
= eh_dev
->sata_dev
.ap
;
816 sas_ata_printk(KERN_DEBUG
, eh_dev
, "cmd error handler\n");
817 ata_scsi_cmd_error_handler(shost
, ap
, &sata_q
);
819 * ata's error handler may leave the cmd on the list
820 * so make sure they don't remain on a stack list
821 * about to go out of scope.
823 * This looks strange, since the commands are
824 * now part of no list, but the next error
825 * action will be ata_port_error_handler()
826 * which takes no list and sweeps them up
827 * anyway from the ata tag array.
829 while (!list_empty(&sata_q
))
830 list_del_init(sata_q
.next
);
835 void sas_ata_schedule_reset(struct domain_device
*dev
)
837 struct ata_eh_info
*ehi
;
841 if (!dev_is_sata(dev
))
844 ap
= dev
->sata_dev
.ap
;
845 ehi
= &ap
->link
.eh_info
;
847 spin_lock_irqsave(ap
->lock
, flags
);
848 ehi
->err_mask
|= AC_ERR_TIMEOUT
;
849 ehi
->action
|= ATA_EH_RESET
;
850 ata_port_schedule_eh(ap
);
851 spin_unlock_irqrestore(ap
->lock
, flags
);
853 EXPORT_SYMBOL_GPL(sas_ata_schedule_reset
);
855 void sas_ata_wait_eh(struct domain_device
*dev
)
859 if (!dev_is_sata(dev
))
862 ap
= dev
->sata_dev
.ap
;
863 ata_port_wait_eh(ap
);