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
.command_set
== ATAPI_COMMAND_SET
))) {
142 ata_tf_from_fis(resp
->ending_fis
, &dev
->sata_dev
.tf
);
144 if (!link
->sactive
) {
145 qc
->err_mask
|= ac_err_mask(dev
->sata_dev
.tf
.command
);
147 link
->eh_info
.err_mask
|= ac_err_mask(dev
->sata_dev
.tf
.command
);
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
.tf
.feature
= 0x04; /* status err */
165 dev
->sata_dev
.tf
.command
= ATA_ERR
;
169 qc
->lldd_task
= NULL
;
171 spin_unlock_irqrestore(ap
->lock
, flags
);
174 list_del_init(&task
->list
);
178 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd
*qc
)
181 struct sas_task
*task
;
182 struct scatterlist
*sg
;
183 int ret
= AC_ERR_SYSTEM
;
184 unsigned int si
, xfer
= 0;
185 struct ata_port
*ap
= qc
->ap
;
186 struct domain_device
*dev
= ap
->private_data
;
187 struct sas_ha_struct
*sas_ha
= dev
->port
->ha
;
188 struct Scsi_Host
*host
= sas_ha
->core
.shost
;
189 struct sas_internal
*i
= to_sas_internal(host
->transportt
);
191 /* TODO: audit callers to ensure they are ready for qc_issue to
192 * unconditionally re-enable interrupts
194 local_irq_save(flags
);
195 spin_unlock(ap
->lock
);
197 /* If the device fell off, no sense in issuing commands */
198 if (test_bit(SAS_DEV_GONE
, &dev
->state
))
201 task
= sas_alloc_task(GFP_ATOMIC
);
205 task
->task_proto
= SAS_PROTOCOL_STP
;
206 task
->task_done
= sas_ata_task_done
;
208 if (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
209 qc
->tf
.command
== ATA_CMD_FPDMA_READ
) {
210 /* Need to zero out the tag libata assigned us */
214 ata_tf_to_fis(&qc
->tf
, 1, 0, (u8
*)&task
->ata_task
.fis
);
215 task
->uldd_task
= qc
;
216 if (ata_is_atapi(qc
->tf
.protocol
)) {
217 memcpy(task
->ata_task
.atapi_packet
, qc
->cdb
, qc
->dev
->cdb_len
);
218 task
->total_xfer_len
= qc
->nbytes
;
219 task
->num_scatter
= qc
->n_elem
;
221 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
)
224 task
->total_xfer_len
= xfer
;
225 task
->num_scatter
= si
;
228 task
->data_dir
= qc
->dma_dir
;
229 task
->scatter
= qc
->sg
;
230 task
->ata_task
.retry_count
= 1;
231 task
->task_state_flags
= SAS_TASK_STATE_PENDING
;
232 qc
->lldd_task
= task
;
234 switch (qc
->tf
.protocol
) {
236 task
->ata_task
.use_ncq
= 1;
240 task
->ata_task
.dma_xfer
= 1;
245 ASSIGN_SAS_TASK(qc
->scsicmd
, task
);
247 if (sas_ha
->lldd_max_execute_num
< 2)
248 ret
= i
->dft
->lldd_execute_task(task
, 1, GFP_ATOMIC
);
250 ret
= sas_queue_up(task
);
254 SAS_DPRINTK("lldd_execute_task returned: %d\n", ret
);
257 ASSIGN_SAS_TASK(qc
->scsicmd
, NULL
);
264 local_irq_restore(flags
);
268 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd
*qc
)
270 struct domain_device
*dev
= qc
->ap
->private_data
;
272 memcpy(&qc
->result_tf
, &dev
->sata_dev
.tf
, sizeof(qc
->result_tf
));
276 static struct sas_internal
*dev_to_sas_internal(struct domain_device
*dev
)
278 return to_sas_internal(dev
->port
->ha
->core
.shost
->transportt
);
281 static int smp_ata_check_ready(struct ata_link
*link
)
285 struct ata_port
*ap
= link
->ap
;
286 struct domain_device
*dev
= ap
->private_data
;
287 struct domain_device
*ex_dev
= dev
->parent
;
288 struct sas_phy
*phy
= sas_get_local_phy(dev
);
290 res
= sas_get_phy_attached_sas_addr(ex_dev
, phy
->number
, addr
);
291 sas_put_local_phy(phy
);
292 /* break the wait early if the expander is unreachable,
293 * otherwise keep polling
297 if (res
!= SMP_RESP_FUNC_ACC
|| SAS_ADDR(addr
) == 0)
303 static int local_ata_check_ready(struct ata_link
*link
)
305 struct ata_port
*ap
= link
->ap
;
306 struct domain_device
*dev
= ap
->private_data
;
307 struct sas_internal
*i
= dev_to_sas_internal(dev
);
309 if (i
->dft
->lldd_ata_check_ready
)
310 return i
->dft
->lldd_ata_check_ready(dev
);
312 /* lldd's that don't implement 'ready' checking get the
313 * old default behavior of not coordinating reset
314 * recovery with libata
320 static int sas_ata_hard_reset(struct ata_link
*link
, unsigned int *class,
321 unsigned long deadline
)
325 struct ata_port
*ap
= link
->ap
;
326 int (*check_ready
)(struct ata_link
*link
);
327 struct domain_device
*dev
= ap
->private_data
;
328 struct sas_internal
*i
= dev_to_sas_internal(dev
);
330 if (test_bit(SAS_DEV_GONE
, &dev
->state
))
333 res
= i
->dft
->lldd_I_T_nexus_reset(dev
);
335 if (res
!= TMF_RESP_FUNC_COMPLETE
)
336 SAS_DPRINTK("%s: Unable to reset ata device?\n", __func__
);
338 phy
= sas_get_local_phy(dev
);
339 if (scsi_is_sas_phy_local(phy
))
340 check_ready
= local_ata_check_ready
;
342 check_ready
= smp_ata_check_ready
;
343 sas_put_local_phy(phy
);
345 ret
= ata_wait_after_reset(link
, deadline
, check_ready
);
346 if (ret
&& ret
!= -EAGAIN
)
347 ata_link_err(link
, "COMRESET failed (errno=%d)\n", ret
);
349 /* XXX: if the class changes during the reset the upper layer
350 * should be informed, if the device has gone away we assume
351 * libsas will eventually delete it
353 switch (dev
->sata_dev
.command_set
) {
354 case ATA_COMMAND_SET
:
355 *class = ATA_DEV_ATA
;
357 case ATAPI_COMMAND_SET
:
358 *class = ATA_DEV_ATAPI
;
362 ap
->cbl
= ATA_CBL_SATA
;
366 static int sas_ata_soft_reset(struct ata_link
*link
, unsigned int *class,
367 unsigned long deadline
)
369 struct ata_port
*ap
= link
->ap
;
370 struct domain_device
*dev
= ap
->private_data
;
371 struct sas_internal
*i
= dev_to_sas_internal(dev
);
372 int res
= TMF_RESP_FUNC_FAILED
;
375 if (i
->dft
->lldd_ata_soft_reset
)
376 res
= i
->dft
->lldd_ata_soft_reset(dev
);
378 if (res
!= TMF_RESP_FUNC_COMPLETE
) {
379 SAS_DPRINTK("%s: Unable to soft reset\n", __func__
);
383 switch (dev
->sata_dev
.command_set
) {
384 case ATA_COMMAND_SET
:
385 SAS_DPRINTK("%s: Found ATA device.\n", __func__
);
386 *class = ATA_DEV_ATA
;
388 case ATAPI_COMMAND_SET
:
389 SAS_DPRINTK("%s: Found ATAPI device.\n", __func__
);
390 *class = ATA_DEV_ATAPI
;
393 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
394 __func__
, dev
->sata_dev
.command_set
);
395 *class = ATA_DEV_UNKNOWN
;
399 ap
->cbl
= ATA_CBL_SATA
;
404 * notify the lldd to forget the sas_task for this internal ata command
405 * that bypasses scsi-eh
407 static void sas_ata_internal_abort(struct sas_task
*task
)
409 struct sas_internal
*si
= dev_to_sas_internal(task
->dev
);
413 spin_lock_irqsave(&task
->task_state_lock
, flags
);
414 if (task
->task_state_flags
& SAS_TASK_STATE_ABORTED
||
415 task
->task_state_flags
& SAS_TASK_STATE_DONE
) {
416 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
417 SAS_DPRINTK("%s: Task %p already finished.\n", __func__
,
421 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
422 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
424 res
= si
->dft
->lldd_abort_task(task
);
426 spin_lock_irqsave(&task
->task_state_lock
, flags
);
427 if (task
->task_state_flags
& SAS_TASK_STATE_DONE
||
428 res
== TMF_RESP_FUNC_COMPLETE
) {
429 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
433 /* XXX we are not prepared to deal with ->lldd_abort_task()
434 * failures. TODO: lldds need to unconditionally forget about
435 * aborted ata tasks, otherwise we (likely) leak the sas task
438 SAS_DPRINTK("%s: Task %p leaked.\n", __func__
, task
);
440 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
))
441 task
->task_state_flags
&= ~SAS_TASK_STATE_ABORTED
;
442 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
446 list_del_init(&task
->list
);
450 static void sas_ata_post_internal(struct ata_queued_cmd
*qc
)
452 if (qc
->flags
& ATA_QCFLAG_FAILED
)
453 qc
->err_mask
|= AC_ERR_OTHER
;
457 * Find the sas_task and kill it. By this point, libata
458 * has decided to kill the qc and has frozen the port.
459 * In this state sas_ata_task_done() will no longer free
460 * the sas_task, so we need to notify the lldd (via
461 * ->lldd_abort_task) that the task is dead and free it
464 struct sas_task
*task
= qc
->lldd_task
;
466 qc
->lldd_task
= NULL
;
469 task
->uldd_task
= NULL
;
470 sas_ata_internal_abort(task
);
475 static void sas_ata_set_dmamode(struct ata_port
*ap
, struct ata_device
*ata_dev
)
477 struct domain_device
*dev
= ap
->private_data
;
478 struct sas_internal
*i
= dev_to_sas_internal(dev
);
480 if (i
->dft
->lldd_ata_set_dmamode
)
481 i
->dft
->lldd_ata_set_dmamode(dev
);
484 static struct ata_port_operations sas_sata_ops
= {
485 .prereset
= ata_std_prereset
,
486 .softreset
= sas_ata_soft_reset
,
487 .hardreset
= sas_ata_hard_reset
,
488 .postreset
= ata_std_postreset
,
489 .error_handler
= ata_std_error_handler
,
490 .post_internal_cmd
= sas_ata_post_internal
,
491 .qc_defer
= ata_std_qc_defer
,
492 .qc_prep
= ata_noop_qc_prep
,
493 .qc_issue
= sas_ata_qc_issue
,
494 .qc_fill_rtf
= sas_ata_qc_fill_rtf
,
495 .port_start
= ata_sas_port_start
,
496 .port_stop
= ata_sas_port_stop
,
497 .set_dmamode
= sas_ata_set_dmamode
,
500 static struct ata_port_info sata_port_info
= {
501 .flags
= ATA_FLAG_SATA
| ATA_FLAG_PIO_DMA
| ATA_FLAG_NCQ
,
502 .pio_mask
= ATA_PIO4
,
503 .mwdma_mask
= ATA_MWDMA2
,
504 .udma_mask
= ATA_UDMA6
,
505 .port_ops
= &sas_sata_ops
508 int sas_ata_init_host_and_port(struct domain_device
*found_dev
,
509 struct scsi_target
*starget
)
511 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
512 struct sas_ha_struct
*ha
= SHOST_TO_SAS_HA(shost
);
515 ata_host_init(&found_dev
->sata_dev
.ata_host
,
517 sata_port_info
.flags
,
519 ap
= ata_sas_port_alloc(&found_dev
->sata_dev
.ata_host
,
523 SAS_DPRINTK("ata_sas_port_alloc failed.\n");
527 ap
->private_data
= found_dev
;
528 ap
->cbl
= ATA_CBL_SATA
;
529 ap
->scsi_host
= shost
;
530 found_dev
->sata_dev
.ap
= ap
;
535 void sas_ata_task_abort(struct sas_task
*task
)
537 struct ata_queued_cmd
*qc
= task
->uldd_task
;
538 struct completion
*waiting
;
540 /* Bounce SCSI-initiated commands to the SCSI EH */
542 struct request_queue
*q
= qc
->scsicmd
->device
->request_queue
;
545 spin_lock_irqsave(q
->queue_lock
, flags
);
546 blk_abort_request(qc
->scsicmd
->request
);
547 spin_unlock_irqrestore(q
->queue_lock
, flags
);
548 scsi_schedule_eh(qc
->scsicmd
->device
->host
);
552 /* Internal command, fake a timeout and complete. */
553 qc
->flags
&= ~ATA_QCFLAG_ACTIVE
;
554 qc
->flags
|= ATA_QCFLAG_FAILED
;
555 qc
->err_mask
|= AC_ERR_TIMEOUT
;
556 waiting
= qc
->private_data
;
560 static void sas_get_ata_command_set(struct domain_device
*dev
)
562 struct dev_to_host_fis
*fis
=
563 (struct dev_to_host_fis
*) dev
->frame_rcvd
;
565 if ((fis
->sector_count
== 1 && /* ATA */
571 (fis
->sector_count
== 0 && /* CE-ATA (mATA) */
575 (fis
->device
& ~0x10) == 0))
577 dev
->sata_dev
.command_set
= ATA_COMMAND_SET
;
579 else if ((fis
->interrupt_reason
== 1 && /* ATAPI */
581 fis
->byte_count_low
== 0x14 &&
582 fis
->byte_count_high
== 0xEB &&
583 (fis
->device
& ~0x10) == 0))
585 dev
->sata_dev
.command_set
= ATAPI_COMMAND_SET
;
587 else if ((fis
->sector_count
== 1 && /* SEMB */
593 (fis
->interrupt_reason
== 1 && /* SATA PM */
595 fis
->byte_count_low
== 0x69 &&
596 fis
->byte_count_high
== 0x96 &&
597 (fis
->device
& ~0x10) == 0))
599 /* Treat it as a superset? */
600 dev
->sata_dev
.command_set
= ATAPI_COMMAND_SET
;
603 void sas_probe_sata(struct work_struct
*work
)
605 struct domain_device
*dev
, *n
;
606 struct sas_discovery_event
*ev
=
607 container_of(work
, struct sas_discovery_event
, work
);
608 struct asd_sas_port
*port
= ev
->port
;
610 clear_bit(DISCE_PROBE
, &port
->disc
.pending
);
612 list_for_each_entry_safe(dev
, n
, &port
->disco_list
, disco_list_node
) {
615 spin_lock_irq(&port
->dev_list_lock
);
616 list_add_tail(&dev
->dev_list_node
, &port
->dev_list
);
617 spin_unlock_irq(&port
->dev_list_lock
);
619 err
= sas_rphy_add(dev
->rphy
);
622 SAS_DPRINTK("%s: for %s device %16llx returned %d\n",
623 __func__
, dev
->parent
? "exp-attached" :
625 SAS_ADDR(dev
->sas_addr
), err
);
626 sas_unregister_dev(port
, dev
);
628 list_del_init(&dev
->disco_list_node
);
633 * sas_discover_sata -- discover an STP/SATA domain device
634 * @dev: pointer to struct domain_device of interest
636 * Devices directly attached to a HA port, have no parents. All other
637 * devices do, and should have their "parent" pointer set appropriately
638 * before calling this function.
640 int sas_discover_sata(struct domain_device
*dev
)
644 if (dev
->dev_type
== SATA_PM
)
647 sas_get_ata_command_set(dev
);
648 sas_fill_in_rphy(dev
, dev
->rphy
);
650 res
= sas_notify_lldd_dev_found(dev
);
654 sas_discover_event(dev
->port
, DISCE_PROBE
);
658 static void async_sas_ata_eh(void *data
, async_cookie_t cookie
)
660 struct domain_device
*dev
= data
;
661 struct ata_port
*ap
= dev
->sata_dev
.ap
;
662 struct sas_ha_struct
*ha
= dev
->port
->ha
;
664 /* hold a reference over eh since we may be racing with final
665 * remove once all commands are completed
667 kref_get(&dev
->kref
);
668 ata_port_printk(ap
, KERN_DEBUG
, "sas eh calling libata port error handler");
669 ata_scsi_port_error_handler(ha
->core
.shost
, ap
);
673 void sas_ata_strategy_handler(struct Scsi_Host
*shost
)
675 struct scsi_device
*sdev
;
676 struct sas_ha_struct
*sas_ha
= SHOST_TO_SAS_HA(shost
);
679 /* it's ok to defer revalidation events during ata eh, these
680 * disks are in one of three states:
681 * 1/ present for initial domain discovery, and these
682 * resets will cause bcn flutters
683 * 2/ hot removed, we'll discover that after eh fails
684 * 3/ hot added after initial discovery, lost the race, and need
685 * to catch the next train.
687 sas_disable_revalidation(sas_ha
);
689 shost_for_each_device(sdev
, shost
) {
690 struct domain_device
*ddev
= sdev_to_domain_dev(sdev
);
692 if (!dev_is_sata(ddev
))
695 async_schedule_domain(async_sas_ata_eh
, ddev
, &async
);
697 async_synchronize_full_domain(&async
);
699 sas_enable_revalidation(sas_ha
);
702 int sas_ata_eh(struct Scsi_Host
*shost
, struct list_head
*work_q
,
703 struct list_head
*done_q
)
706 struct scsi_cmnd
*cmd
, *n
;
714 list_for_each_entry_safe(cmd
, n
, work_q
, eh_entry
) {
715 struct domain_device
*ddev
= cmd_to_domain_dev(cmd
);
717 if (!dev_is_sata(ddev
) || TO_SAS_TASK(cmd
))
719 if (ap
&& ap
!= ddev
->sata_dev
.ap
)
721 ap
= ddev
->sata_dev
.ap
;
723 list_move(&cmd
->eh_entry
, &sata_q
);
726 if (!list_empty(&sata_q
)) {
727 ata_port_printk(ap
, KERN_DEBUG
, "sas eh calling libata cmd error handler\n");
728 ata_scsi_cmd_error_handler(shost
, ap
, &sata_q
);
730 * ata's error handler may leave the cmd on the list
731 * so make sure they don't remain on a stack list
732 * about to go out of scope.
734 * This looks strange, since the commands are
735 * now part of no list, but the next error
736 * action will be ata_port_error_handler()
737 * which takes no list and sweeps them up
738 * anyway from the ata tag array.
740 while (!list_empty(&sata_q
))
741 list_del_init(sata_q
.next
);
748 void sas_ata_schedule_reset(struct domain_device
*dev
)
750 struct ata_eh_info
*ehi
;
754 if (!dev_is_sata(dev
))
757 ap
= dev
->sata_dev
.ap
;
758 ehi
= &ap
->link
.eh_info
;
760 spin_lock_irqsave(ap
->lock
, flags
);
761 ehi
->err_mask
|= AC_ERR_TIMEOUT
;
762 ehi
->action
|= ATA_EH_RESET
;
763 ata_port_schedule_eh(ap
);
764 spin_unlock_irqrestore(ap
->lock
, flags
);
766 EXPORT_SYMBOL_GPL(sas_ata_schedule_reset
);
768 void sas_ata_wait_eh(struct domain_device
*dev
)
772 if (!dev_is_sata(dev
))
775 ap
= dev
->sata_dev
.ap
;
776 ata_port_wait_eh(ap
);