2 * Support for SATA devices on Serial Attached SCSI (SAS) controllers
4 * Copyright (C) 2006 IBM Corporation
6 * Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 #include <linux/scatterlist.h>
25 #include <linux/slab.h>
26 #include <linux/async.h>
27 #include <linux/export.h>
29 #include <scsi/sas_ata.h>
30 #include "sas_internal.h"
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/scsi.h>
35 #include <scsi/scsi_transport.h>
36 #include <scsi/scsi_transport_sas.h>
37 #include "../scsi_sas_internal.h"
38 #include "../scsi_transport_api.h"
39 #include <scsi/scsi_eh.h>
41 static enum ata_completion_errors
sas_to_ata_err(struct task_status_struct
*ts
)
43 /* Cheesy attempt to translate SAS errors into ATA. Hah! */
46 if (ts
->resp
== SAS_TASK_UNDELIVERED
)
47 return AC_ERR_ATA_BUS
;
49 /* ts->resp == SAS_TASK_COMPLETE */
50 /* task delivered, what happened afterwards? */
52 case SAS_DEV_NO_RESPONSE
:
53 return AC_ERR_TIMEOUT
;
58 return AC_ERR_ATA_BUS
;
61 case SAS_DATA_UNDERRUN
:
63 * Some programs that use the taskfile interface
64 * (smartctl in particular) can cause underrun
65 * problems. Ignore these errors, perhaps at our
70 case SAS_DATA_OVERRUN
:
72 case SAS_DEVICE_UNKNOWN
:
74 return AC_ERR_INVALID
;
78 SAS_DPRINTK("%s: Saw error %d. What to do?\n",
82 case SAM_STAT_CHECK_CONDITION
:
83 case SAS_ABORTED_TASK
:
86 case SAS_PROTO_RESPONSE
:
87 /* This means the ending_fis has the error
88 * value; return 0 here to collect it */
95 static void sas_ata_task_done(struct sas_task
*task
)
97 struct ata_queued_cmd
*qc
= task
->uldd_task
;
98 struct domain_device
*dev
= task
->dev
;
99 struct task_status_struct
*stat
= &task
->task_status
;
100 struct ata_task_resp
*resp
= (struct ata_task_resp
*)stat
->buf
;
101 struct sas_ha_struct
*sas_ha
= dev
->port
->ha
;
102 enum ata_completion_errors ac
;
104 struct ata_link
*link
;
107 spin_lock_irqsave(&dev
->done_lock
, flags
);
108 if (test_bit(SAS_HA_FROZEN
, &sas_ha
->state
))
110 else if (qc
&& qc
->scsicmd
)
111 ASSIGN_SAS_TASK(qc
->scsicmd
, NULL
);
112 spin_unlock_irqrestore(&dev
->done_lock
, flags
);
114 /* check if libsas-eh got to the task before us */
119 goto qc_already_gone
;
124 spin_lock_irqsave(ap
->lock
, flags
);
125 /* check if we lost the race with libata/sas_ata_post_internal() */
126 if (unlikely(ap
->pflags
& ATA_PFLAG_FROZEN
)) {
127 spin_unlock_irqrestore(ap
->lock
, flags
);
129 goto qc_already_gone
;
131 /* if eh is not involved and the port is frozen then the
132 * ata internal abort process has taken responsibility
139 if (stat
->stat
== SAS_PROTO_RESPONSE
|| stat
->stat
== SAM_STAT_GOOD
||
140 ((stat
->stat
== SAM_STAT_CHECK_CONDITION
&&
141 dev
->sata_dev
.class == ATA_DEV_ATAPI
))) {
142 memcpy(dev
->sata_dev
.fis
, resp
->ending_fis
, ATA_RESP_FIS_SIZE
);
144 if (!link
->sactive
) {
145 qc
->err_mask
|= ac_err_mask(dev
->sata_dev
.fis
[2]);
147 link
->eh_info
.err_mask
|= ac_err_mask(dev
->sata_dev
.fis
[2]);
148 if (unlikely(link
->eh_info
.err_mask
))
149 qc
->flags
|= ATA_QCFLAG_FAILED
;
152 ac
= sas_to_ata_err(stat
);
154 SAS_DPRINTK("%s: SAS error %x\n", __func__
,
156 /* We saw a SAS error. Send a vague error. */
157 if (!link
->sactive
) {
160 link
->eh_info
.err_mask
|= AC_ERR_DEV
;
161 qc
->flags
|= ATA_QCFLAG_FAILED
;
164 dev
->sata_dev
.fis
[3] = 0x04; /* status err */
165 dev
->sata_dev
.fis
[2] = ATA_ERR
;
169 qc
->lldd_task
= NULL
;
171 spin_unlock_irqrestore(ap
->lock
, flags
);
177 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd
*qc
)
180 struct sas_task
*task
;
181 struct scatterlist
*sg
;
182 int ret
= AC_ERR_SYSTEM
;
183 unsigned int si
, xfer
= 0;
184 struct ata_port
*ap
= qc
->ap
;
185 struct domain_device
*dev
= ap
->private_data
;
186 struct sas_ha_struct
*sas_ha
= dev
->port
->ha
;
187 struct Scsi_Host
*host
= sas_ha
->core
.shost
;
188 struct sas_internal
*i
= to_sas_internal(host
->transportt
);
190 /* TODO: audit callers to ensure they are ready for qc_issue to
191 * unconditionally re-enable interrupts
193 local_irq_save(flags
);
194 spin_unlock(ap
->lock
);
196 /* If the device fell off, no sense in issuing commands */
197 if (test_bit(SAS_DEV_GONE
, &dev
->state
))
200 task
= sas_alloc_task(GFP_ATOMIC
);
204 task
->task_proto
= SAS_PROTOCOL_STP
;
205 task
->task_done
= sas_ata_task_done
;
207 if (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
208 qc
->tf
.command
== ATA_CMD_FPDMA_READ
||
209 qc
->tf
.command
== ATA_CMD_FPDMA_RECV
||
210 qc
->tf
.command
== ATA_CMD_FPDMA_SEND
||
211 qc
->tf
.command
== ATA_CMD_NCQ_NON_DATA
) {
212 /* Need to zero out the tag libata assigned us */
216 ata_tf_to_fis(&qc
->tf
, qc
->dev
->link
->pmp
, 1, (u8
*)&task
->ata_task
.fis
);
217 task
->uldd_task
= qc
;
218 if (ata_is_atapi(qc
->tf
.protocol
)) {
219 memcpy(task
->ata_task
.atapi_packet
, qc
->cdb
, qc
->dev
->cdb_len
);
220 task
->total_xfer_len
= qc
->nbytes
;
221 task
->num_scatter
= qc
->n_elem
;
223 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
)
224 xfer
+= sg_dma_len(sg
);
226 task
->total_xfer_len
= xfer
;
227 task
->num_scatter
= si
;
230 if (qc
->tf
.protocol
== ATA_PROT_NODATA
)
231 task
->data_dir
= DMA_NONE
;
233 task
->data_dir
= qc
->dma_dir
;
234 task
->scatter
= qc
->sg
;
235 task
->ata_task
.retry_count
= 1;
236 task
->task_state_flags
= SAS_TASK_STATE_PENDING
;
237 qc
->lldd_task
= task
;
239 task
->ata_task
.use_ncq
= ata_is_ncq(qc
->tf
.protocol
);
240 task
->ata_task
.dma_xfer
= ata_is_dma(qc
->tf
.protocol
);
243 ASSIGN_SAS_TASK(qc
->scsicmd
, task
);
245 ret
= i
->dft
->lldd_execute_task(task
, GFP_ATOMIC
);
247 SAS_DPRINTK("lldd_execute_task returned: %d\n", ret
);
250 ASSIGN_SAS_TASK(qc
->scsicmd
, NULL
);
252 qc
->lldd_task
= NULL
;
258 local_irq_restore(flags
);
262 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd
*qc
)
264 struct domain_device
*dev
= qc
->ap
->private_data
;
266 ata_tf_from_fis(dev
->sata_dev
.fis
, &qc
->result_tf
);
270 static struct sas_internal
*dev_to_sas_internal(struct domain_device
*dev
)
272 return to_sas_internal(dev
->port
->ha
->core
.shost
->transportt
);
275 static int sas_get_ata_command_set(struct domain_device
*dev
);
277 int sas_get_ata_info(struct domain_device
*dev
, struct ex_phy
*phy
)
279 if (phy
->attached_tproto
& SAS_PROTOCOL_STP
)
280 dev
->tproto
= phy
->attached_tproto
;
281 if (phy
->attached_sata_dev
)
282 dev
->tproto
|= SAS_SATA_DEV
;
284 if (phy
->attached_dev_type
== SAS_SATA_PENDING
)
285 dev
->dev_type
= SAS_SATA_PENDING
;
289 dev
->dev_type
= SAS_SATA_DEV
;
290 res
= sas_get_report_phy_sata(dev
->parent
, phy
->phy_id
,
291 &dev
->sata_dev
.rps_resp
);
293 SAS_DPRINTK("report phy sata to %016llx:0x%x returned "
294 "0x%x\n", SAS_ADDR(dev
->parent
->sas_addr
),
298 memcpy(dev
->frame_rcvd
, &dev
->sata_dev
.rps_resp
.rps
.fis
,
299 sizeof(struct dev_to_host_fis
));
300 dev
->sata_dev
.class = sas_get_ata_command_set(dev
);
305 static int sas_ata_clear_pending(struct domain_device
*dev
, struct ex_phy
*phy
)
309 /* we weren't pending, so successfully end the reset sequence now */
310 if (dev
->dev_type
!= SAS_SATA_PENDING
)
313 /* hmmm, if this succeeds do we need to repost the domain_device to the
314 * lldd so it can pick up new parameters?
316 res
= sas_get_ata_info(dev
, phy
);
318 return 0; /* retry */
323 static int smp_ata_check_ready(struct ata_link
*link
)
326 struct ata_port
*ap
= link
->ap
;
327 struct domain_device
*dev
= ap
->private_data
;
328 struct domain_device
*ex_dev
= dev
->parent
;
329 struct sas_phy
*phy
= sas_get_local_phy(dev
);
330 struct ex_phy
*ex_phy
= &ex_dev
->ex_dev
.ex_phy
[phy
->number
];
332 res
= sas_ex_phy_discover(ex_dev
, phy
->number
);
333 sas_put_local_phy(phy
);
335 /* break the wait early if the expander is unreachable,
336 * otherwise keep polling
340 if (res
!= SMP_RESP_FUNC_ACC
)
343 switch (ex_phy
->attached_dev_type
) {
344 case SAS_SATA_PENDING
:
347 if (ex_phy
->attached_sata_dev
)
348 return sas_ata_clear_pending(dev
, ex_phy
);
355 static int local_ata_check_ready(struct ata_link
*link
)
357 struct ata_port
*ap
= link
->ap
;
358 struct domain_device
*dev
= ap
->private_data
;
359 struct sas_internal
*i
= dev_to_sas_internal(dev
);
361 if (i
->dft
->lldd_ata_check_ready
)
362 return i
->dft
->lldd_ata_check_ready(dev
);
364 /* lldd's that don't implement 'ready' checking get the
365 * old default behavior of not coordinating reset
366 * recovery with libata
372 static int sas_ata_printk(const char *level
, const struct domain_device
*ddev
,
373 const char *fmt
, ...)
375 struct ata_port
*ap
= ddev
->sata_dev
.ap
;
376 struct device
*dev
= &ddev
->rphy
->dev
;
377 struct va_format vaf
;
386 r
= printk("%ssas: ata%u: %s: %pV",
387 level
, ap
->print_id
, dev_name(dev
), &vaf
);
394 static int sas_ata_hard_reset(struct ata_link
*link
, unsigned int *class,
395 unsigned long deadline
)
399 struct ata_port
*ap
= link
->ap
;
400 int (*check_ready
)(struct ata_link
*link
);
401 struct domain_device
*dev
= ap
->private_data
;
402 struct sas_internal
*i
= dev_to_sas_internal(dev
);
404 res
= i
->dft
->lldd_I_T_nexus_reset(dev
);
408 if (res
!= TMF_RESP_FUNC_COMPLETE
)
409 sas_ata_printk(KERN_DEBUG
, dev
, "Unable to reset ata device?\n");
411 phy
= sas_get_local_phy(dev
);
412 if (scsi_is_sas_phy_local(phy
))
413 check_ready
= local_ata_check_ready
;
415 check_ready
= smp_ata_check_ready
;
416 sas_put_local_phy(phy
);
418 ret
= ata_wait_after_reset(link
, deadline
, check_ready
);
419 if (ret
&& ret
!= -EAGAIN
)
420 sas_ata_printk(KERN_ERR
, dev
, "reset failed (errno=%d)\n", ret
);
422 *class = dev
->sata_dev
.class;
424 ap
->cbl
= ATA_CBL_SATA
;
429 * notify the lldd to forget the sas_task for this internal ata command
430 * that bypasses scsi-eh
432 static void sas_ata_internal_abort(struct sas_task
*task
)
434 struct sas_internal
*si
= dev_to_sas_internal(task
->dev
);
438 spin_lock_irqsave(&task
->task_state_lock
, flags
);
439 if (task
->task_state_flags
& SAS_TASK_STATE_ABORTED
||
440 task
->task_state_flags
& SAS_TASK_STATE_DONE
) {
441 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
442 SAS_DPRINTK("%s: Task %p already finished.\n", __func__
,
446 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
447 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
449 res
= si
->dft
->lldd_abort_task(task
);
451 spin_lock_irqsave(&task
->task_state_lock
, flags
);
452 if (task
->task_state_flags
& SAS_TASK_STATE_DONE
||
453 res
== TMF_RESP_FUNC_COMPLETE
) {
454 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
458 /* XXX we are not prepared to deal with ->lldd_abort_task()
459 * failures. TODO: lldds need to unconditionally forget about
460 * aborted ata tasks, otherwise we (likely) leak the sas task
463 SAS_DPRINTK("%s: Task %p leaked.\n", __func__
, task
);
465 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
))
466 task
->task_state_flags
&= ~SAS_TASK_STATE_ABORTED
;
467 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
474 static void sas_ata_post_internal(struct ata_queued_cmd
*qc
)
476 if (qc
->flags
& ATA_QCFLAG_FAILED
)
477 qc
->err_mask
|= AC_ERR_OTHER
;
481 * Find the sas_task and kill it. By this point, libata
482 * has decided to kill the qc and has frozen the port.
483 * In this state sas_ata_task_done() will no longer free
484 * the sas_task, so we need to notify the lldd (via
485 * ->lldd_abort_task) that the task is dead and free it
488 struct sas_task
*task
= qc
->lldd_task
;
490 qc
->lldd_task
= NULL
;
493 task
->uldd_task
= NULL
;
494 sas_ata_internal_abort(task
);
499 static void sas_ata_set_dmamode(struct ata_port
*ap
, struct ata_device
*ata_dev
)
501 struct domain_device
*dev
= ap
->private_data
;
502 struct sas_internal
*i
= dev_to_sas_internal(dev
);
504 if (i
->dft
->lldd_ata_set_dmamode
)
505 i
->dft
->lldd_ata_set_dmamode(dev
);
508 static void sas_ata_sched_eh(struct ata_port
*ap
)
510 struct domain_device
*dev
= ap
->private_data
;
511 struct sas_ha_struct
*ha
= dev
->port
->ha
;
514 spin_lock_irqsave(&ha
->lock
, flags
);
515 if (!test_and_set_bit(SAS_DEV_EH_PENDING
, &dev
->state
))
517 ata_std_sched_eh(ap
);
518 spin_unlock_irqrestore(&ha
->lock
, flags
);
521 void sas_ata_end_eh(struct ata_port
*ap
)
523 struct domain_device
*dev
= ap
->private_data
;
524 struct sas_ha_struct
*ha
= dev
->port
->ha
;
527 spin_lock_irqsave(&ha
->lock
, flags
);
528 if (test_and_clear_bit(SAS_DEV_EH_PENDING
, &dev
->state
))
530 spin_unlock_irqrestore(&ha
->lock
, flags
);
533 static struct ata_port_operations sas_sata_ops
= {
534 .prereset
= ata_std_prereset
,
535 .hardreset
= sas_ata_hard_reset
,
536 .postreset
= ata_std_postreset
,
537 .error_handler
= ata_std_error_handler
,
538 .post_internal_cmd
= sas_ata_post_internal
,
539 .qc_defer
= ata_std_qc_defer
,
540 .qc_prep
= ata_noop_qc_prep
,
541 .qc_issue
= sas_ata_qc_issue
,
542 .qc_fill_rtf
= sas_ata_qc_fill_rtf
,
543 .port_start
= ata_sas_port_start
,
544 .port_stop
= ata_sas_port_stop
,
545 .set_dmamode
= sas_ata_set_dmamode
,
546 .sched_eh
= sas_ata_sched_eh
,
547 .end_eh
= sas_ata_end_eh
,
550 static struct ata_port_info sata_port_info
= {
551 .flags
= ATA_FLAG_SATA
| ATA_FLAG_PIO_DMA
| ATA_FLAG_NCQ
|
552 ATA_FLAG_SAS_HOST
| ATA_FLAG_FPDMA_AUX
,
553 .pio_mask
= ATA_PIO4
,
554 .mwdma_mask
= ATA_MWDMA2
,
555 .udma_mask
= ATA_UDMA6
,
556 .port_ops
= &sas_sata_ops
559 int sas_ata_init(struct domain_device
*found_dev
)
561 struct sas_ha_struct
*ha
= found_dev
->port
->ha
;
562 struct Scsi_Host
*shost
= ha
->core
.shost
;
566 ata_host_init(&found_dev
->sata_dev
.ata_host
, ha
->dev
, &sas_sata_ops
);
567 ap
= ata_sas_port_alloc(&found_dev
->sata_dev
.ata_host
,
571 SAS_DPRINTK("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
);
580 ata_sas_port_destroy(ap
);
583 found_dev
->sata_dev
.ap
= ap
;
588 void sas_ata_task_abort(struct sas_task
*task
)
590 struct ata_queued_cmd
*qc
= task
->uldd_task
;
591 struct completion
*waiting
;
593 /* Bounce SCSI-initiated commands to the SCSI EH */
595 struct request_queue
*q
= qc
->scsicmd
->device
->request_queue
;
598 spin_lock_irqsave(q
->queue_lock
, flags
);
599 blk_abort_request(qc
->scsicmd
->request
);
600 spin_unlock_irqrestore(q
->queue_lock
, flags
);
604 /* Internal command, fake a timeout and complete. */
605 qc
->flags
&= ~ATA_QCFLAG_ACTIVE
;
606 qc
->flags
|= ATA_QCFLAG_FAILED
;
607 qc
->err_mask
|= AC_ERR_TIMEOUT
;
608 waiting
= qc
->private_data
;
612 static int sas_get_ata_command_set(struct domain_device
*dev
)
614 struct dev_to_host_fis
*fis
=
615 (struct dev_to_host_fis
*) dev
->frame_rcvd
;
616 struct ata_taskfile tf
;
618 if (dev
->dev_type
== SAS_SATA_PENDING
)
619 return ATA_DEV_UNKNOWN
;
621 ata_tf_from_fis((const u8
*)fis
, &tf
);
623 return ata_dev_classify(&tf
);
626 void sas_probe_sata(struct asd_sas_port
*port
)
628 struct domain_device
*dev
, *n
;
630 mutex_lock(&port
->ha
->disco_mutex
);
631 list_for_each_entry(dev
, &port
->disco_list
, disco_list_node
) {
632 if (!dev_is_sata(dev
))
635 ata_sas_async_probe(dev
->sata_dev
.ap
);
637 mutex_unlock(&port
->ha
->disco_mutex
);
639 list_for_each_entry_safe(dev
, n
, &port
->disco_list
, disco_list_node
) {
640 if (!dev_is_sata(dev
))
643 sas_ata_wait_eh(dev
);
645 /* if libata could not bring the link up, don't surface
648 if (ata_dev_disabled(sas_to_ata_dev(dev
)))
649 sas_fail_probe(dev
, __func__
, -ENODEV
);
654 static void sas_ata_flush_pm_eh(struct asd_sas_port
*port
, const char *func
)
656 struct domain_device
*dev
, *n
;
658 list_for_each_entry_safe(dev
, n
, &port
->dev_list
, dev_list_node
) {
659 if (!dev_is_sata(dev
))
662 sas_ata_wait_eh(dev
);
664 /* if libata failed to power manage the device, tear it down */
665 if (ata_dev_disabled(sas_to_ata_dev(dev
)))
666 sas_fail_probe(dev
, func
, -ENODEV
);
670 void sas_suspend_sata(struct asd_sas_port
*port
)
672 struct domain_device
*dev
;
674 mutex_lock(&port
->ha
->disco_mutex
);
675 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
676 struct sata_device
*sata
;
678 if (!dev_is_sata(dev
))
681 sata
= &dev
->sata_dev
;
682 if (sata
->ap
->pm_mesg
.event
== PM_EVENT_SUSPEND
)
685 ata_sas_port_suspend(sata
->ap
);
687 mutex_unlock(&port
->ha
->disco_mutex
);
689 sas_ata_flush_pm_eh(port
, __func__
);
692 void sas_resume_sata(struct asd_sas_port
*port
)
694 struct domain_device
*dev
;
696 mutex_lock(&port
->ha
->disco_mutex
);
697 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
698 struct sata_device
*sata
;
700 if (!dev_is_sata(dev
))
703 sata
= &dev
->sata_dev
;
704 if (sata
->ap
->pm_mesg
.event
== PM_EVENT_ON
)
707 ata_sas_port_resume(sata
->ap
);
709 mutex_unlock(&port
->ha
->disco_mutex
);
711 sas_ata_flush_pm_eh(port
, __func__
);
715 * sas_discover_sata -- discover an STP/SATA domain device
716 * @dev: pointer to struct domain_device of interest
718 * Devices directly attached to a HA port, have no parents. All other
719 * devices do, and should have their "parent" pointer set appropriately
720 * before calling this function.
722 int sas_discover_sata(struct domain_device
*dev
)
726 if (dev
->dev_type
== SAS_SATA_PM
)
729 dev
->sata_dev
.class = sas_get_ata_command_set(dev
);
730 sas_fill_in_rphy(dev
, dev
->rphy
);
732 res
= sas_notify_lldd_dev_found(dev
);
736 sas_discover_event(dev
->port
, DISCE_PROBE
);
740 static void async_sas_ata_eh(void *data
, async_cookie_t cookie
)
742 struct domain_device
*dev
= data
;
743 struct ata_port
*ap
= dev
->sata_dev
.ap
;
744 struct sas_ha_struct
*ha
= dev
->port
->ha
;
746 sas_ata_printk(KERN_DEBUG
, dev
, "dev error handler\n");
747 ata_scsi_port_error_handler(ha
->core
.shost
, ap
);
751 void sas_ata_strategy_handler(struct Scsi_Host
*shost
)
753 struct sas_ha_struct
*sas_ha
= SHOST_TO_SAS_HA(shost
);
754 ASYNC_DOMAIN_EXCLUSIVE(async
);
757 /* it's ok to defer revalidation events during ata eh, these
758 * disks are in one of three states:
759 * 1/ present for initial domain discovery, and these
760 * resets will cause bcn flutters
761 * 2/ hot removed, we'll discover that after eh fails
762 * 3/ hot added after initial discovery, lost the race, and need
763 * to catch the next train.
765 sas_disable_revalidation(sas_ha
);
767 spin_lock_irq(&sas_ha
->phy_port_lock
);
768 for (i
= 0; i
< sas_ha
->num_phys
; i
++) {
769 struct asd_sas_port
*port
= sas_ha
->sas_port
[i
];
770 struct domain_device
*dev
;
772 spin_lock(&port
->dev_list_lock
);
773 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
774 if (!dev_is_sata(dev
))
777 /* hold a reference over eh since we may be
778 * racing with final remove once all commands
781 kref_get(&dev
->kref
);
783 async_schedule_domain(async_sas_ata_eh
, dev
, &async
);
785 spin_unlock(&port
->dev_list_lock
);
787 spin_unlock_irq(&sas_ha
->phy_port_lock
);
789 async_synchronize_full_domain(&async
);
791 sas_enable_revalidation(sas_ha
);
794 void sas_ata_eh(struct Scsi_Host
*shost
, struct list_head
*work_q
,
795 struct list_head
*done_q
)
797 struct scsi_cmnd
*cmd
, *n
;
798 struct domain_device
*eh_dev
;
804 list_for_each_entry_safe(cmd
, n
, work_q
, eh_entry
) {
805 struct domain_device
*ddev
= cmd_to_domain_dev(cmd
);
807 if (!dev_is_sata(ddev
) || TO_SAS_TASK(cmd
))
809 if (eh_dev
&& eh_dev
!= ddev
)
812 list_move(&cmd
->eh_entry
, &sata_q
);
815 if (!list_empty(&sata_q
)) {
816 struct ata_port
*ap
= eh_dev
->sata_dev
.ap
;
818 sas_ata_printk(KERN_DEBUG
, eh_dev
, "cmd error handler\n");
819 ata_scsi_cmd_error_handler(shost
, ap
, &sata_q
);
821 * ata's error handler may leave the cmd on the list
822 * so make sure they don't remain on a stack list
823 * about to go out of scope.
825 * This looks strange, since the commands are
826 * now part of no list, but the next error
827 * action will be ata_port_error_handler()
828 * which takes no list and sweeps them up
829 * anyway from the ata tag array.
831 while (!list_empty(&sata_q
))
832 list_del_init(sata_q
.next
);
837 void sas_ata_schedule_reset(struct domain_device
*dev
)
839 struct ata_eh_info
*ehi
;
843 if (!dev_is_sata(dev
))
846 ap
= dev
->sata_dev
.ap
;
847 ehi
= &ap
->link
.eh_info
;
849 spin_lock_irqsave(ap
->lock
, flags
);
850 ehi
->err_mask
|= AC_ERR_TIMEOUT
;
851 ehi
->action
|= ATA_EH_RESET
;
852 ata_port_schedule_eh(ap
);
853 spin_unlock_irqrestore(ap
->lock
, flags
);
855 EXPORT_SYMBOL_GPL(sas_ata_schedule_reset
);
857 void sas_ata_wait_eh(struct domain_device
*dev
)
861 if (!dev_is_sata(dev
))
864 ap
= dev
->sata_dev
.ap
;
865 ata_port_wait_eh(ap
);