1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Support for SATA devices on Serial Attached SCSI (SAS) controllers
4 *
5 * Copyright (C) 2006 IBM Corporation
6 *
7 * Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation
8 */
9
10 #include <linux/scatterlist.h>
11 #include <linux/slab.h>
12 #include <linux/async.h>
13 #include <linux/export.h>
14
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>
26
sas_to_ata_err(struct task_status_struct * ts)27 static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts)
28 {
29 /* Cheesy attempt to translate SAS errors into ATA. Hah! */
30
31 /* transport error */
32 if (ts->resp == SAS_TASK_UNDELIVERED)
33 return AC_ERR_ATA_BUS;
34
35 /* ts->resp == SAS_TASK_COMPLETE */
36 /* task delivered, what happened afterwards? */
37 switch (ts->stat) {
38 case SAS_DEV_NO_RESPONSE:
39 return AC_ERR_TIMEOUT;
40
41 case SAS_INTERRUPTED:
42 case SAS_PHY_DOWN:
43 case SAS_NAK_R_ERR:
44 return AC_ERR_ATA_BUS;
45
46
47 case SAS_DATA_UNDERRUN:
48 /*
49 * Some programs that use the taskfile interface
50 * (smartctl in particular) can cause underrun
51 * problems. Ignore these errors, perhaps at our
52 * peril.
53 */
54 return 0;
55
56 case SAS_DATA_OVERRUN:
57 case SAS_QUEUE_FULL:
58 case SAS_DEVICE_UNKNOWN:
59 case SAS_SG_ERR:
60 return AC_ERR_INVALID;
61
62 case SAS_OPEN_TO:
63 case SAS_OPEN_REJECT:
64 pr_warn("%s: Saw error %d. What to do?\n",
65 __func__, ts->stat);
66 return AC_ERR_OTHER;
67
68 case SAM_STAT_CHECK_CONDITION:
69 case SAS_ABORTED_TASK:
70 return AC_ERR_DEV;
71
72 case SAS_PROTO_RESPONSE:
73 /* This means the ending_fis has the error
74 * value; return 0 here to collect it */
75 return 0;
76 default:
77 return 0;
78 }
79 }
80
sas_ata_task_done(struct sas_task * task)81 static void sas_ata_task_done(struct sas_task *task)
82 {
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;
89 unsigned long flags;
90 struct ata_link *link;
91 struct ata_port *ap;
92
93 spin_lock_irqsave(&dev->done_lock, flags);
94 if (test_bit(SAS_HA_FROZEN, &sas_ha->state))
95 task = NULL;
96 else if (qc && qc->scsicmd)
97 ASSIGN_SAS_TASK(qc->scsicmd, NULL);
98 spin_unlock_irqrestore(&dev->done_lock, flags);
99
100 /* check if libsas-eh got to the task before us */
101 if (unlikely(!task))
102 return;
103
104 if (!qc)
105 goto qc_already_gone;
106
107 ap = qc->ap;
108 link = &ap->link;
109
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);
114 if (qc->scsicmd)
115 goto qc_already_gone;
116 else {
117 /* if eh is not involved and the port is frozen then the
118 * ata internal abort process has taken responsibility
119 * for this sas_task
120 */
121 return;
122 }
123 }
124
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);
129
130 if (!link->sactive) {
131 qc->err_mask |= ac_err_mask(dev->sata_dev.fis[2]);
132 } else {
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;
136 }
137 } else {
138 ac = sas_to_ata_err(stat);
139 if (ac) {
140 pr_warn("%s: SAS error %x\n", __func__, stat->stat);
141 /* We saw a SAS error. Send a vague error. */
142 if (!link->sactive) {
143 qc->err_mask = ac;
144 } else {
145 link->eh_info.err_mask |= AC_ERR_DEV;
146 qc->flags |= ATA_QCFLAG_FAILED;
147 }
148
149 dev->sata_dev.fis[3] = 0x04; /* status err */
150 dev->sata_dev.fis[2] = ATA_ERR;
151 }
152 }
153
154 qc->lldd_task = NULL;
155 ata_qc_complete(qc);
156 spin_unlock_irqrestore(ap->lock, flags);
157
158 qc_already_gone:
159 sas_free_task(task);
160 }
161
sas_ata_qc_issue(struct ata_queued_cmd * qc)162 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
163 {
164 struct sas_task *task;
165 struct scatterlist *sg;
166 int ret = AC_ERR_SYSTEM;
167 unsigned int si, xfer = 0;
168 struct ata_port *ap = qc->ap;
169 struct domain_device *dev = ap->private_data;
170 struct sas_ha_struct *sas_ha = dev->port->ha;
171 struct Scsi_Host *host = sas_ha->core.shost;
172 struct sas_internal *i = to_sas_internal(host->transportt);
173
174 /* TODO: we should try to remove that unlock */
175 spin_unlock(ap->lock);
176
177 /* If the device fell off, no sense in issuing commands */
178 if (test_bit(SAS_DEV_GONE, &dev->state))
179 goto out;
180
181 task = sas_alloc_task(GFP_ATOMIC);
182 if (!task)
183 goto out;
184 task->dev = dev;
185 task->task_proto = SAS_PROTOCOL_STP;
186 task->task_done = sas_ata_task_done;
187
188 if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
189 qc->tf.command == ATA_CMD_FPDMA_READ ||
190 qc->tf.command == ATA_CMD_FPDMA_RECV ||
191 qc->tf.command == ATA_CMD_FPDMA_SEND ||
192 qc->tf.command == ATA_CMD_NCQ_NON_DATA) {
193 /* Need to zero out the tag libata assigned us */
194 qc->tf.nsect = 0;
195 }
196
197 ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, (u8 *)&task->ata_task.fis);
198 task->uldd_task = qc;
199 if (ata_is_atapi(qc->tf.protocol)) {
200 memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
201 task->total_xfer_len = qc->nbytes;
202 task->num_scatter = qc->n_elem;
203 task->data_dir = qc->dma_dir;
204 } else if (!ata_is_data(qc->tf.protocol)) {
205 task->data_dir = DMA_NONE;
206 } else {
207 for_each_sg(qc->sg, sg, qc->n_elem, si)
208 xfer += sg_dma_len(sg);
209
210 task->total_xfer_len = xfer;
211 task->num_scatter = si;
212 task->data_dir = qc->dma_dir;
213 }
214 task->scatter = qc->sg;
215 task->ata_task.retry_count = 1;
216 task->task_state_flags = SAS_TASK_STATE_PENDING;
217 qc->lldd_task = task;
218
219 task->ata_task.use_ncq = ata_is_ncq(qc->tf.protocol);
220 task->ata_task.dma_xfer = ata_is_dma(qc->tf.protocol);
221
222 if (qc->scsicmd)
223 ASSIGN_SAS_TASK(qc->scsicmd, task);
224
225 ret = i->dft->lldd_execute_task(task, GFP_ATOMIC);
226 if (ret) {
227 pr_debug("lldd_execute_task returned: %d\n", ret);
228
229 if (qc->scsicmd)
230 ASSIGN_SAS_TASK(qc->scsicmd, NULL);
231 sas_free_task(task);
232 qc->lldd_task = NULL;
233 ret = AC_ERR_SYSTEM;
234 }
235
236 out:
237 spin_lock(ap->lock);
238 return ret;
239 }
240
sas_ata_qc_fill_rtf(struct ata_queued_cmd * qc)241 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
242 {
243 struct domain_device *dev = qc->ap->private_data;
244
245 ata_tf_from_fis(dev->sata_dev.fis, &qc->result_tf);
246 return true;
247 }
248
dev_to_sas_internal(struct domain_device * dev)249 static struct sas_internal *dev_to_sas_internal(struct domain_device *dev)
250 {
251 return to_sas_internal(dev->port->ha->core.shost->transportt);
252 }
253
254 static int sas_get_ata_command_set(struct domain_device *dev);
255
sas_get_ata_info(struct domain_device * dev,struct ex_phy * phy)256 int sas_get_ata_info(struct domain_device *dev, struct ex_phy *phy)
257 {
258 if (phy->attached_tproto & SAS_PROTOCOL_STP)
259 dev->tproto = phy->attached_tproto;
260 if (phy->attached_sata_dev)
261 dev->tproto |= SAS_SATA_DEV;
262
263 if (phy->attached_dev_type == SAS_SATA_PENDING)
264 dev->dev_type = SAS_SATA_PENDING;
265 else {
266 int res;
267
268 dev->dev_type = SAS_SATA_DEV;
269 res = sas_get_report_phy_sata(dev->parent, phy->phy_id,
270 &dev->sata_dev.rps_resp);
271 if (res) {
272 pr_debug("report phy sata to %016llx:%02d returned 0x%x\n",
273 SAS_ADDR(dev->parent->sas_addr),
274 phy->phy_id, res);
275 return res;
276 }
277 memcpy(dev->frame_rcvd, &dev->sata_dev.rps_resp.rps.fis,
278 sizeof(struct dev_to_host_fis));
279 dev->sata_dev.class = sas_get_ata_command_set(dev);
280 }
281 return 0;
282 }
283
sas_ata_clear_pending(struct domain_device * dev,struct ex_phy * phy)284 static int sas_ata_clear_pending(struct domain_device *dev, struct ex_phy *phy)
285 {
286 int res;
287
288 /* we weren't pending, so successfully end the reset sequence now */
289 if (dev->dev_type != SAS_SATA_PENDING)
290 return 1;
291
292 /* hmmm, if this succeeds do we need to repost the domain_device to the
293 * lldd so it can pick up new parameters?
294 */
295 res = sas_get_ata_info(dev, phy);
296 if (res)
297 return 0; /* retry */
298 else
299 return 1;
300 }
301
smp_ata_check_ready(struct ata_link * link)302 static int smp_ata_check_ready(struct ata_link *link)
303 {
304 int res;
305 struct ata_port *ap = link->ap;
306 struct domain_device *dev = ap->private_data;
307 struct domain_device *ex_dev = dev->parent;
308 struct sas_phy *phy = sas_get_local_phy(dev);
309 struct ex_phy *ex_phy = &ex_dev->ex_dev.ex_phy[phy->number];
310
311 res = sas_ex_phy_discover(ex_dev, phy->number);
312 sas_put_local_phy(phy);
313
314 /* break the wait early if the expander is unreachable,
315 * otherwise keep polling
316 */
317 if (res == -ECOMM)
318 return res;
319 if (res != SMP_RESP_FUNC_ACC)
320 return 0;
321
322 switch (ex_phy->attached_dev_type) {
323 case SAS_SATA_PENDING:
324 return 0;
325 case SAS_END_DEVICE:
326 if (ex_phy->attached_sata_dev)
327 return sas_ata_clear_pending(dev, ex_phy);
328 /* fall through */
329 default:
330 return -ENODEV;
331 }
332 }
333
local_ata_check_ready(struct ata_link * link)334 static int local_ata_check_ready(struct ata_link *link)
335 {
336 struct ata_port *ap = link->ap;
337 struct domain_device *dev = ap->private_data;
338 struct sas_internal *i = dev_to_sas_internal(dev);
339
340 if (i->dft->lldd_ata_check_ready)
341 return i->dft->lldd_ata_check_ready(dev);
342 else {
343 /* lldd's that don't implement 'ready' checking get the
344 * old default behavior of not coordinating reset
345 * recovery with libata
346 */
347 return 1;
348 }
349 }
350
sas_ata_printk(const char * level,const struct domain_device * ddev,const char * fmt,...)351 static int sas_ata_printk(const char *level, const struct domain_device *ddev,
352 const char *fmt, ...)
353 {
354 struct ata_port *ap = ddev->sata_dev.ap;
355 struct device *dev = &ddev->rphy->dev;
356 struct va_format vaf;
357 va_list args;
358 int r;
359
360 va_start(args, fmt);
361
362 vaf.fmt = fmt;
363 vaf.va = &args;
364
365 r = printk("%s" SAS_FMT "ata%u: %s: %pV",
366 level, ap->print_id, dev_name(dev), &vaf);
367
368 va_end(args);
369
370 return r;
371 }
372
sas_ata_hard_reset(struct ata_link * link,unsigned int * class,unsigned long deadline)373 static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class,
374 unsigned long deadline)
375 {
376 int ret = 0, res;
377 struct sas_phy *phy;
378 struct ata_port *ap = link->ap;
379 int (*check_ready)(struct ata_link *link);
380 struct domain_device *dev = ap->private_data;
381 struct sas_internal *i = dev_to_sas_internal(dev);
382
383 res = i->dft->lldd_I_T_nexus_reset(dev);
384 if (res == -ENODEV)
385 return res;
386
387 if (res != TMF_RESP_FUNC_COMPLETE)
388 sas_ata_printk(KERN_DEBUG, dev, "Unable to reset ata device?\n");
389
390 phy = sas_get_local_phy(dev);
391 if (scsi_is_sas_phy_local(phy))
392 check_ready = local_ata_check_ready;
393 else
394 check_ready = smp_ata_check_ready;
395 sas_put_local_phy(phy);
396
397 ret = ata_wait_after_reset(link, deadline, check_ready);
398 if (ret && ret != -EAGAIN)
399 sas_ata_printk(KERN_ERR, dev, "reset failed (errno=%d)\n", ret);
400
401 *class = dev->sata_dev.class;
402
403 ap->cbl = ATA_CBL_SATA;
404 return ret;
405 }
406
407 /*
408 * notify the lldd to forget the sas_task for this internal ata command
409 * that bypasses scsi-eh
410 */
sas_ata_internal_abort(struct sas_task * task)411 static void sas_ata_internal_abort(struct sas_task *task)
412 {
413 struct sas_internal *si = dev_to_sas_internal(task->dev);
414 unsigned long flags;
415 int res;
416
417 spin_lock_irqsave(&task->task_state_lock, flags);
418 if (task->task_state_flags & SAS_TASK_STATE_ABORTED ||
419 task->task_state_flags & SAS_TASK_STATE_DONE) {
420 spin_unlock_irqrestore(&task->task_state_lock, flags);
421 pr_debug("%s: Task %p already finished.\n", __func__, task);
422 goto out;
423 }
424 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
425 spin_unlock_irqrestore(&task->task_state_lock, flags);
426
427 res = si->dft->lldd_abort_task(task);
428
429 spin_lock_irqsave(&task->task_state_lock, flags);
430 if (task->task_state_flags & SAS_TASK_STATE_DONE ||
431 res == TMF_RESP_FUNC_COMPLETE) {
432 spin_unlock_irqrestore(&task->task_state_lock, flags);
433 goto out;
434 }
435
436 /* XXX we are not prepared to deal with ->lldd_abort_task()
437 * failures. TODO: lldds need to unconditionally forget about
438 * aborted ata tasks, otherwise we (likely) leak the sas task
439 * here
440 */
441 pr_warn("%s: Task %p leaked.\n", __func__, task);
442
443 if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
444 task->task_state_flags &= ~SAS_TASK_STATE_ABORTED;
445 spin_unlock_irqrestore(&task->task_state_lock, flags);
446
447 return;
448 out:
449 sas_free_task(task);
450 }
451
sas_ata_post_internal(struct ata_queued_cmd * qc)452 static void sas_ata_post_internal(struct ata_queued_cmd *qc)
453 {
454 if (qc->flags & ATA_QCFLAG_FAILED)
455 qc->err_mask |= AC_ERR_OTHER;
456
457 if (qc->err_mask) {
458 /*
459 * Find the sas_task and kill it. By this point, libata
460 * has decided to kill the qc and has frozen the port.
461 * In this state sas_ata_task_done() will no longer free
462 * the sas_task, so we need to notify the lldd (via
463 * ->lldd_abort_task) that the task is dead and free it
464 * ourselves.
465 */
466 struct sas_task *task = qc->lldd_task;
467
468 qc->lldd_task = NULL;
469 if (!task)
470 return;
471 task->uldd_task = NULL;
472 sas_ata_internal_abort(task);
473 }
474 }
475
476
sas_ata_set_dmamode(struct ata_port * ap,struct ata_device * ata_dev)477 static void sas_ata_set_dmamode(struct ata_port *ap, struct ata_device *ata_dev)
478 {
479 struct domain_device *dev = ap->private_data;
480 struct sas_internal *i = dev_to_sas_internal(dev);
481
482 if (i->dft->lldd_ata_set_dmamode)
483 i->dft->lldd_ata_set_dmamode(dev);
484 }
485
sas_ata_sched_eh(struct ata_port * ap)486 static void sas_ata_sched_eh(struct ata_port *ap)
487 {
488 struct domain_device *dev = ap->private_data;
489 struct sas_ha_struct *ha = dev->port->ha;
490 unsigned long flags;
491
492 spin_lock_irqsave(&ha->lock, flags);
493 if (!test_and_set_bit(SAS_DEV_EH_PENDING, &dev->state))
494 ha->eh_active++;
495 ata_std_sched_eh(ap);
496 spin_unlock_irqrestore(&ha->lock, flags);
497 }
498
sas_ata_end_eh(struct ata_port * ap)499 void sas_ata_end_eh(struct ata_port *ap)
500 {
501 struct domain_device *dev = ap->private_data;
502 struct sas_ha_struct *ha = dev->port->ha;
503 unsigned long flags;
504
505 spin_lock_irqsave(&ha->lock, flags);
506 if (test_and_clear_bit(SAS_DEV_EH_PENDING, &dev->state))
507 ha->eh_active--;
508 spin_unlock_irqrestore(&ha->lock, flags);
509 }
510
511 static struct ata_port_operations sas_sata_ops = {
512 .prereset = ata_std_prereset,
513 .hardreset = sas_ata_hard_reset,
514 .postreset = ata_std_postreset,
515 .error_handler = ata_std_error_handler,
516 .post_internal_cmd = sas_ata_post_internal,
517 .qc_defer = ata_std_qc_defer,
518 .qc_prep = ata_noop_qc_prep,
519 .qc_issue = sas_ata_qc_issue,
520 .qc_fill_rtf = sas_ata_qc_fill_rtf,
521 .port_start = ata_sas_port_start,
522 .port_stop = ata_sas_port_stop,
523 .set_dmamode = sas_ata_set_dmamode,
524 .sched_eh = sas_ata_sched_eh,
525 .end_eh = sas_ata_end_eh,
526 };
527
528 static struct ata_port_info sata_port_info = {
529 .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ |
530 ATA_FLAG_SAS_HOST | ATA_FLAG_FPDMA_AUX,
531 .pio_mask = ATA_PIO4,
532 .mwdma_mask = ATA_MWDMA2,
533 .udma_mask = ATA_UDMA6,
534 .port_ops = &sas_sata_ops
535 };
536
sas_ata_init(struct domain_device * found_dev)537 int sas_ata_init(struct domain_device *found_dev)
538 {
539 struct sas_ha_struct *ha = found_dev->port->ha;
540 struct Scsi_Host *shost = ha->core.shost;
541 struct ata_host *ata_host;
542 struct ata_port *ap;
543 int rc;
544
545 ata_host = kzalloc(sizeof(*ata_host), GFP_KERNEL);
546 if (!ata_host) {
547 pr_err("ata host alloc failed.\n");
548 return -ENOMEM;
549 }
550
551 ata_host_init(ata_host, ha->dev, &sas_sata_ops);
552
553 ap = ata_sas_port_alloc(ata_host, &sata_port_info, shost);
554 if (!ap) {
555 pr_err("ata_sas_port_alloc failed.\n");
556 rc = -ENODEV;
557 goto free_host;
558 }
559
560 ap->private_data = found_dev;
561 ap->cbl = ATA_CBL_SATA;
562 ap->scsi_host = shost;
563 rc = ata_sas_port_init(ap);
564 if (rc)
565 goto destroy_port;
566
567 rc = ata_sas_tport_add(ata_host->dev, ap);
568 if (rc)
569 goto destroy_port;
570
571 found_dev->sata_dev.ata_host = ata_host;
572 found_dev->sata_dev.ap = ap;
573
574 return 0;
575
576 destroy_port:
577 ata_sas_port_destroy(ap);
578 free_host:
579 ata_host_put(ata_host);
580 return rc;
581 }
582
sas_ata_task_abort(struct sas_task * task)583 void sas_ata_task_abort(struct sas_task *task)
584 {
585 struct ata_queued_cmd *qc = task->uldd_task;
586 struct completion *waiting;
587
588 /* Bounce SCSI-initiated commands to the SCSI EH */
589 if (qc->scsicmd) {
590 blk_abort_request(qc->scsicmd->request);
591 return;
592 }
593
594 /* Internal command, fake a timeout and complete. */
595 qc->flags &= ~ATA_QCFLAG_ACTIVE;
596 qc->flags |= ATA_QCFLAG_FAILED;
597 qc->err_mask |= AC_ERR_TIMEOUT;
598 waiting = qc->private_data;
599 complete(waiting);
600 }
601
sas_get_ata_command_set(struct domain_device * dev)602 static int sas_get_ata_command_set(struct domain_device *dev)
603 {
604 struct dev_to_host_fis *fis =
605 (struct dev_to_host_fis *) dev->frame_rcvd;
606 struct ata_taskfile tf;
607
608 if (dev->dev_type == SAS_SATA_PENDING)
609 return ATA_DEV_UNKNOWN;
610
611 ata_tf_from_fis((const u8 *)fis, &tf);
612
613 return ata_dev_classify(&tf);
614 }
615
sas_probe_sata(struct asd_sas_port * port)616 void sas_probe_sata(struct asd_sas_port *port)
617 {
618 struct domain_device *dev, *n;
619
620 mutex_lock(&port->ha->disco_mutex);
621 list_for_each_entry(dev, &port->disco_list, disco_list_node) {
622 if (!dev_is_sata(dev))
623 continue;
624
625 ata_sas_async_probe(dev->sata_dev.ap);
626 }
627 mutex_unlock(&port->ha->disco_mutex);
628
629 list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
630 if (!dev_is_sata(dev))
631 continue;
632
633 sas_ata_wait_eh(dev);
634
635 /* if libata could not bring the link up, don't surface
636 * the device
637 */
638 if (!ata_dev_enabled(sas_to_ata_dev(dev)))
639 sas_fail_probe(dev, __func__, -ENODEV);
640 }
641
642 }
643
sas_ata_flush_pm_eh(struct asd_sas_port * port,const char * func)644 static void sas_ata_flush_pm_eh(struct asd_sas_port *port, const char *func)
645 {
646 struct domain_device *dev, *n;
647
648 list_for_each_entry_safe(dev, n, &port->dev_list, dev_list_node) {
649 if (!dev_is_sata(dev))
650 continue;
651
652 sas_ata_wait_eh(dev);
653
654 /* if libata failed to power manage the device, tear it down */
655 if (ata_dev_disabled(sas_to_ata_dev(dev)))
656 sas_fail_probe(dev, func, -ENODEV);
657 }
658 }
659
sas_suspend_sata(struct asd_sas_port * port)660 void sas_suspend_sata(struct asd_sas_port *port)
661 {
662 struct domain_device *dev;
663
664 mutex_lock(&port->ha->disco_mutex);
665 list_for_each_entry(dev, &port->dev_list, dev_list_node) {
666 struct sata_device *sata;
667
668 if (!dev_is_sata(dev))
669 continue;
670
671 sata = &dev->sata_dev;
672 if (sata->ap->pm_mesg.event == PM_EVENT_SUSPEND)
673 continue;
674
675 ata_sas_port_suspend(sata->ap);
676 }
677 mutex_unlock(&port->ha->disco_mutex);
678
679 sas_ata_flush_pm_eh(port, __func__);
680 }
681
sas_resume_sata(struct asd_sas_port * port)682 void sas_resume_sata(struct asd_sas_port *port)
683 {
684 struct domain_device *dev;
685
686 mutex_lock(&port->ha->disco_mutex);
687 list_for_each_entry(dev, &port->dev_list, dev_list_node) {
688 struct sata_device *sata;
689
690 if (!dev_is_sata(dev))
691 continue;
692
693 sata = &dev->sata_dev;
694 if (sata->ap->pm_mesg.event == PM_EVENT_ON)
695 continue;
696
697 ata_sas_port_resume(sata->ap);
698 }
699 mutex_unlock(&port->ha->disco_mutex);
700
701 sas_ata_flush_pm_eh(port, __func__);
702 }
703
704 /**
705 * sas_discover_sata - discover an STP/SATA domain device
706 * @dev: pointer to struct domain_device of interest
707 *
708 * Devices directly attached to a HA port, have no parents. All other
709 * devices do, and should have their "parent" pointer set appropriately
710 * before calling this function.
711 */
sas_discover_sata(struct domain_device * dev)712 int sas_discover_sata(struct domain_device *dev)
713 {
714 int res;
715
716 if (dev->dev_type == SAS_SATA_PM)
717 return -ENODEV;
718
719 dev->sata_dev.class = sas_get_ata_command_set(dev);
720 sas_fill_in_rphy(dev, dev->rphy);
721
722 res = sas_notify_lldd_dev_found(dev);
723 if (res)
724 return res;
725
726 return 0;
727 }
728
async_sas_ata_eh(void * data,async_cookie_t cookie)729 static void async_sas_ata_eh(void *data, async_cookie_t cookie)
730 {
731 struct domain_device *dev = data;
732 struct ata_port *ap = dev->sata_dev.ap;
733 struct sas_ha_struct *ha = dev->port->ha;
734
735 sas_ata_printk(KERN_DEBUG, dev, "dev error handler\n");
736 ata_scsi_port_error_handler(ha->core.shost, ap);
737 sas_put_device(dev);
738 }
739
sas_ata_strategy_handler(struct Scsi_Host * shost)740 void sas_ata_strategy_handler(struct Scsi_Host *shost)
741 {
742 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
743 ASYNC_DOMAIN_EXCLUSIVE(async);
744 int i;
745
746 /* it's ok to defer revalidation events during ata eh, these
747 * disks are in one of three states:
748 * 1/ present for initial domain discovery, and these
749 * resets will cause bcn flutters
750 * 2/ hot removed, we'll discover that after eh fails
751 * 3/ hot added after initial discovery, lost the race, and need
752 * to catch the next train.
753 */
754 sas_disable_revalidation(sas_ha);
755
756 spin_lock_irq(&sas_ha->phy_port_lock);
757 for (i = 0; i < sas_ha->num_phys; i++) {
758 struct asd_sas_port *port = sas_ha->sas_port[i];
759 struct domain_device *dev;
760
761 spin_lock(&port->dev_list_lock);
762 list_for_each_entry(dev, &port->dev_list, dev_list_node) {
763 if (!dev_is_sata(dev))
764 continue;
765
766 /* hold a reference over eh since we may be
767 * racing with final remove once all commands
768 * are completed
769 */
770 kref_get(&dev->kref);
771
772 async_schedule_domain(async_sas_ata_eh, dev, &async);
773 }
774 spin_unlock(&port->dev_list_lock);
775 }
776 spin_unlock_irq(&sas_ha->phy_port_lock);
777
778 async_synchronize_full_domain(&async);
779
780 sas_enable_revalidation(sas_ha);
781 }
782
sas_ata_eh(struct Scsi_Host * shost,struct list_head * work_q,struct list_head * done_q)783 void sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
784 struct list_head *done_q)
785 {
786 struct scsi_cmnd *cmd, *n;
787 struct domain_device *eh_dev;
788
789 do {
790 LIST_HEAD(sata_q);
791 eh_dev = NULL;
792
793 list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
794 struct domain_device *ddev = cmd_to_domain_dev(cmd);
795
796 if (!dev_is_sata(ddev) || TO_SAS_TASK(cmd))
797 continue;
798 if (eh_dev && eh_dev != ddev)
799 continue;
800 eh_dev = ddev;
801 list_move(&cmd->eh_entry, &sata_q);
802 }
803
804 if (!list_empty(&sata_q)) {
805 struct ata_port *ap = eh_dev->sata_dev.ap;
806
807 sas_ata_printk(KERN_DEBUG, eh_dev, "cmd error handler\n");
808 ata_scsi_cmd_error_handler(shost, ap, &sata_q);
809 /*
810 * ata's error handler may leave the cmd on the list
811 * so make sure they don't remain on a stack list
812 * about to go out of scope.
813 *
814 * This looks strange, since the commands are
815 * now part of no list, but the next error
816 * action will be ata_port_error_handler()
817 * which takes no list and sweeps them up
818 * anyway from the ata tag array.
819 */
820 while (!list_empty(&sata_q))
821 list_del_init(sata_q.next);
822 }
823 } while (eh_dev);
824 }
825
sas_ata_schedule_reset(struct domain_device * dev)826 void sas_ata_schedule_reset(struct domain_device *dev)
827 {
828 struct ata_eh_info *ehi;
829 struct ata_port *ap;
830 unsigned long flags;
831
832 if (!dev_is_sata(dev))
833 return;
834
835 ap = dev->sata_dev.ap;
836 ehi = &ap->link.eh_info;
837
838 spin_lock_irqsave(ap->lock, flags);
839 ehi->err_mask |= AC_ERR_TIMEOUT;
840 ehi->action |= ATA_EH_RESET;
841 ata_port_schedule_eh(ap);
842 spin_unlock_irqrestore(ap->lock, flags);
843 }
844 EXPORT_SYMBOL_GPL(sas_ata_schedule_reset);
845
sas_ata_wait_eh(struct domain_device * dev)846 void sas_ata_wait_eh(struct domain_device *dev)
847 {
848 struct ata_port *ap;
849
850 if (!dev_is_sata(dev))
851 return;
852
853 ap = dev->sata_dev.ap;
854 ata_port_wait_eh(ap);
855 }
856