1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * SATA specific part of ATA helper library
4 *
5 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
6 * Copyright 2003-2004 Jeff Garzik
7 * Copyright 2006 Tejun Heo <htejun@gmail.com>
8 */
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <scsi/scsi_cmnd.h>
13#include <scsi/scsi_device.h>
14#include <scsi/scsi_eh.h>
15#include <linux/libata.h>
16#include <linux/unaligned.h>
17
18#include "libata.h"
19#include "libata-transport.h"
20
21/* debounce timing parameters in msecs { interval, duration, timeout } */
22const unsigned int sata_deb_timing_normal[] = { 5, 100, 2000 };
23EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
24const unsigned int sata_deb_timing_hotplug[] = { 25, 500, 2000 };
25EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
26const unsigned int sata_deb_timing_long[] = { 100, 2000, 5000 };
27EXPORT_SYMBOL_GPL(sata_deb_timing_long);
28
29/**
30 * sata_scr_valid - test whether SCRs are accessible
31 * @link: ATA link to test SCR accessibility for
32 *
33 * Test whether SCRs are accessible for @link.
34 *
35 * LOCKING:
36 * None.
37 *
38 * RETURNS:
39 * 1 if SCRs are accessible, 0 otherwise.
40 */
41int sata_scr_valid(struct ata_link *link)
42{
43 struct ata_port *ap = link->ap;
44
45 return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
46}
47EXPORT_SYMBOL_GPL(sata_scr_valid);
48
49/**
50 * sata_scr_read - read SCR register of the specified port
51 * @link: ATA link to read SCR for
52 * @reg: SCR to read
53 * @val: Place to store read value
54 *
55 * Read SCR register @reg of @link into *@val. This function is
56 * guaranteed to succeed if @link is ap->link, the cable type of
57 * the port is SATA and the port implements ->scr_read.
58 *
59 * LOCKING:
60 * None if @link is ap->link. Kernel thread context otherwise.
61 *
62 * RETURNS:
63 * 0 on success, negative errno on failure.
64 */
65int sata_scr_read(struct ata_link *link, int reg, u32 *val)
66{
67 if (ata_is_host_link(link)) {
68 if (sata_scr_valid(link))
69 return link->ap->ops->scr_read(link, reg, val);
70 return -EOPNOTSUPP;
71 }
72
73 return sata_pmp_scr_read(link, reg, val);
74}
75EXPORT_SYMBOL_GPL(sata_scr_read);
76
77/**
78 * sata_scr_write - write SCR register of the specified port
79 * @link: ATA link to write SCR for
80 * @reg: SCR to write
81 * @val: value to write
82 *
83 * Write @val to SCR register @reg of @link. This function is
84 * guaranteed to succeed if @link is ap->link, the cable type of
85 * the port is SATA and the port implements ->scr_read.
86 *
87 * LOCKING:
88 * None if @link is ap->link. Kernel thread context otherwise.
89 *
90 * RETURNS:
91 * 0 on success, negative errno on failure.
92 */
93int sata_scr_write(struct ata_link *link, int reg, u32 val)
94{
95 if (ata_is_host_link(link)) {
96 if (sata_scr_valid(link))
97 return link->ap->ops->scr_write(link, reg, val);
98 return -EOPNOTSUPP;
99 }
100
101 return sata_pmp_scr_write(link, reg, val);
102}
103EXPORT_SYMBOL_GPL(sata_scr_write);
104
105/**
106 * sata_scr_write_flush - write SCR register of the specified port and flush
107 * @link: ATA link to write SCR for
108 * @reg: SCR to write
109 * @val: value to write
110 *
111 * This function is identical to sata_scr_write() except that this
112 * function performs flush after writing to the register.
113 *
114 * LOCKING:
115 * None if @link is ap->link. Kernel thread context otherwise.
116 *
117 * RETURNS:
118 * 0 on success, negative errno on failure.
119 */
120int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
121{
122 if (ata_is_host_link(link)) {
123 int rc;
124
125 if (sata_scr_valid(link)) {
126 rc = link->ap->ops->scr_write(link, reg, val);
127 if (rc == 0)
128 rc = link->ap->ops->scr_read(link, reg, &val);
129 return rc;
130 }
131 return -EOPNOTSUPP;
132 }
133
134 return sata_pmp_scr_write(link, reg, val);
135}
136EXPORT_SYMBOL_GPL(sata_scr_write_flush);
137
138/**
139 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
140 * @tf: Taskfile to convert
141 * @pmp: Port multiplier port
142 * @is_cmd: This FIS is for command
143 * @fis: Buffer into which data will output
144 *
145 * Converts a standard ATA taskfile to a Serial ATA
146 * FIS structure (Register - Host to Device).
147 *
148 * LOCKING:
149 * Inherited from caller.
150 */
151void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
152{
153 fis[0] = 0x27; /* Register - Host to Device FIS */
154 fis[1] = pmp & 0xf; /* Port multiplier number*/
155 if (is_cmd)
156 fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */
157
158 fis[2] = tf->command;
159 fis[3] = tf->feature;
160
161 fis[4] = tf->lbal;
162 fis[5] = tf->lbam;
163 fis[6] = tf->lbah;
164 fis[7] = tf->device;
165
166 fis[8] = tf->hob_lbal;
167 fis[9] = tf->hob_lbam;
168 fis[10] = tf->hob_lbah;
169 fis[11] = tf->hob_feature;
170
171 fis[12] = tf->nsect;
172 fis[13] = tf->hob_nsect;
173 fis[14] = 0;
174 fis[15] = tf->ctl;
175
176 fis[16] = tf->auxiliary & 0xff;
177 fis[17] = (tf->auxiliary >> 8) & 0xff;
178 fis[18] = (tf->auxiliary >> 16) & 0xff;
179 fis[19] = (tf->auxiliary >> 24) & 0xff;
180}
181EXPORT_SYMBOL_GPL(ata_tf_to_fis);
182
183/**
184 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
185 * @fis: Buffer from which data will be input
186 * @tf: Taskfile to output
187 *
188 * Converts a serial ATA FIS structure to a standard ATA taskfile.
189 *
190 * LOCKING:
191 * Inherited from caller.
192 */
193
194void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
195{
196 tf->status = fis[2];
197 tf->error = fis[3];
198
199 tf->lbal = fis[4];
200 tf->lbam = fis[5];
201 tf->lbah = fis[6];
202 tf->device = fis[7];
203
204 tf->hob_lbal = fis[8];
205 tf->hob_lbam = fis[9];
206 tf->hob_lbah = fis[10];
207
208 tf->nsect = fis[12];
209 tf->hob_nsect = fis[13];
210}
211EXPORT_SYMBOL_GPL(ata_tf_from_fis);
212
213/**
214 * sata_link_debounce - debounce SATA phy status
215 * @link: ATA link to debounce SATA phy status for
216 * @params: timing parameters { interval, duration, timeout } in msec
217 * @deadline: deadline jiffies for the operation
218 *
219 * Make sure SStatus of @link reaches stable state, determined by
220 * holding the same value where DET is not 1 for @duration polled
221 * every @interval, before @timeout. Timeout constraints the
222 * beginning of the stable state. Because DET gets stuck at 1 on
223 * some controllers after hot unplugging, this functions waits
224 * until timeout then returns 0 if DET is stable at 1.
225 *
226 * @timeout is further limited by @deadline. The sooner of the
227 * two is used.
228 *
229 * LOCKING:
230 * Kernel thread context (may sleep)
231 *
232 * RETURNS:
233 * 0 on success, -errno on failure.
234 */
235int sata_link_debounce(struct ata_link *link, const unsigned int *params,
236 unsigned long deadline)
237{
238 unsigned int interval = params[0];
239 unsigned int duration = params[1];
240 unsigned long last_jiffies, t;
241 u32 last, cur;
242 int rc;
243
244 t = ata_deadline(from_jiffies: jiffies, timeout_msecs: params[2]);
245 if (time_before(t, deadline))
246 deadline = t;
247
248 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
249 return rc;
250 cur &= 0xf;
251
252 last = cur;
253 last_jiffies = jiffies;
254
255 while (1) {
256 ata_msleep(ap: link->ap, msecs: interval);
257 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
258 return rc;
259 cur &= 0xf;
260
261 /* DET stable? */
262 if (cur == last) {
263 if (cur == 1 && time_before(jiffies, deadline))
264 continue;
265 if (time_after(jiffies,
266 ata_deadline(last_jiffies, duration)))
267 return 0;
268 continue;
269 }
270
271 /* unstable, start over */
272 last = cur;
273 last_jiffies = jiffies;
274
275 /* Check deadline. If debouncing failed, return
276 * -EPIPE to tell upper layer to lower link speed.
277 */
278 if (time_after(jiffies, deadline))
279 return -EPIPE;
280 }
281}
282EXPORT_SYMBOL_GPL(sata_link_debounce);
283
284/**
285 * sata_link_resume - resume SATA link
286 * @link: ATA link to resume SATA
287 * @params: timing parameters { interval, duration, timeout } in msec
288 * @deadline: deadline jiffies for the operation
289 *
290 * Resume SATA phy @link and debounce it.
291 *
292 * LOCKING:
293 * Kernel thread context (may sleep)
294 *
295 * RETURNS:
296 * 0 on success, -errno on failure.
297 */
298int sata_link_resume(struct ata_link *link, const unsigned int *params,
299 unsigned long deadline)
300{
301 int tries = ATA_LINK_RESUME_TRIES;
302 u32 scontrol, serror;
303 int rc;
304
305 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
306 return rc;
307
308 /*
309 * Writes to SControl sometimes get ignored under certain
310 * controllers (ata_piix SIDPR). Make sure DET actually is
311 * cleared.
312 */
313 do {
314 scontrol = (scontrol & 0x0f0) | 0x300;
315 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
316 return rc;
317 /*
318 * Some PHYs react badly if SStatus is pounded
319 * immediately after resuming. Delay 200ms before
320 * debouncing.
321 */
322 if (!(link->flags & ATA_LFLAG_NO_DEBOUNCE_DELAY))
323 ata_msleep(ap: link->ap, msecs: 200);
324
325 /* is SControl restored correctly? */
326 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
327 return rc;
328 } while ((scontrol & 0xf0f) != 0x300 && --tries);
329
330 if ((scontrol & 0xf0f) != 0x300) {
331 ata_link_warn(link, "failed to resume link (SControl %X)\n",
332 scontrol);
333 return 0;
334 }
335
336 if (tries < ATA_LINK_RESUME_TRIES)
337 ata_link_warn(link, "link resume succeeded after %d retries\n",
338 ATA_LINK_RESUME_TRIES - tries);
339
340 if ((rc = sata_link_debounce(link, params, deadline)))
341 return rc;
342
343 /* clear SError, some PHYs require this even for SRST to work */
344 if (!(rc = sata_scr_read(link, SCR_ERROR, &serror)))
345 rc = sata_scr_write(link, SCR_ERROR, serror);
346
347 return rc != -EINVAL ? rc : 0;
348}
349EXPORT_SYMBOL_GPL(sata_link_resume);
350
351/**
352 * sata_link_scr_lpm - manipulate SControl IPM and SPM fields
353 * @link: ATA link to manipulate SControl for
354 * @policy: LPM policy to configure
355 * @spm_wakeup: initiate LPM transition to active state
356 *
357 * Manipulate the IPM field of the SControl register of @link
358 * according to @policy. If @policy is ATA_LPM_MAX_POWER and
359 * @spm_wakeup is %true, the SPM field is manipulated to wake up
360 * the link. This function also clears PHYRDY_CHG before
361 * returning.
362 *
363 * LOCKING:
364 * EH context.
365 *
366 * RETURNS:
367 * 0 on success, -errno otherwise.
368 */
369int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
370 bool spm_wakeup)
371{
372 struct ata_eh_context *ehc = &link->eh_context;
373 bool woken_up = false;
374 u32 scontrol;
375 int rc;
376
377 rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
378 if (rc)
379 return rc;
380
381 switch (policy) {
382 case ATA_LPM_MAX_POWER:
383 /* disable all LPM transitions */
384 scontrol |= (0x7 << 8);
385 /* initiate transition to active state */
386 if (spm_wakeup) {
387 scontrol |= (0x4 << 12);
388 woken_up = true;
389 }
390 break;
391 case ATA_LPM_MED_POWER:
392 /* allow LPM to PARTIAL */
393 scontrol &= ~(0x1 << 8);
394 scontrol |= (0x6 << 8);
395 break;
396 case ATA_LPM_MED_POWER_WITH_DIPM:
397 case ATA_LPM_MIN_POWER_WITH_PARTIAL:
398 case ATA_LPM_MIN_POWER:
399 if (ata_link_nr_enabled(link) > 0) {
400 /* assume no restrictions on LPM transitions */
401 scontrol &= ~(0x7 << 8);
402
403 /*
404 * If the controller does not support partial, slumber,
405 * or devsleep, then disallow these transitions.
406 */
407 if (link->ap->host->flags & ATA_HOST_NO_PART)
408 scontrol |= (0x1 << 8);
409
410 if (link->ap->host->flags & ATA_HOST_NO_SSC)
411 scontrol |= (0x2 << 8);
412
413 if (link->ap->host->flags & ATA_HOST_NO_DEVSLP)
414 scontrol |= (0x4 << 8);
415 } else {
416 /* empty port, power off */
417 scontrol &= ~0xf;
418 scontrol |= (0x1 << 2);
419 }
420 break;
421 default:
422 WARN_ON(1);
423 }
424
425 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
426 if (rc)
427 return rc;
428
429 /* give the link time to transit out of LPM state */
430 if (woken_up)
431 msleep(msecs: 10);
432
433 /* clear PHYRDY_CHG from SError */
434 ehc->i.serror &= ~SERR_PHYRDY_CHG;
435 return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
436}
437EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
438
439static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
440{
441 struct ata_link *host_link = &link->ap->link;
442 u32 limit, target, spd;
443
444 limit = link->sata_spd_limit;
445
446 /* Don't configure downstream link faster than upstream link.
447 * It doesn't speed up anything and some PMPs choke on such
448 * configuration.
449 */
450 if (!ata_is_host_link(link) && host_link->sata_spd)
451 limit &= (1 << host_link->sata_spd) - 1;
452
453 if (limit == UINT_MAX)
454 target = 0;
455 else
456 target = fls(x: limit);
457
458 spd = (*scontrol >> 4) & 0xf;
459 *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
460
461 return spd != target;
462}
463
464/**
465 * sata_set_spd_needed - is SATA spd configuration needed
466 * @link: Link in question
467 *
468 * Test whether the spd limit in SControl matches
469 * @link->sata_spd_limit. This function is used to determine
470 * whether hardreset is necessary to apply SATA spd
471 * configuration.
472 *
473 * LOCKING:
474 * Inherited from caller.
475 *
476 * RETURNS:
477 * 1 if SATA spd configuration is needed, 0 otherwise.
478 */
479static int sata_set_spd_needed(struct ata_link *link)
480{
481 u32 scontrol;
482
483 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
484 return 1;
485
486 return __sata_set_spd_needed(link, scontrol: &scontrol);
487}
488
489/**
490 * sata_set_spd - set SATA spd according to spd limit
491 * @link: Link to set SATA spd for
492 *
493 * Set SATA spd of @link according to sata_spd_limit.
494 *
495 * LOCKING:
496 * Inherited from caller.
497 *
498 * RETURNS:
499 * 0 if spd doesn't need to be changed, 1 if spd has been
500 * changed. Negative errno if SCR registers are inaccessible.
501 */
502int sata_set_spd(struct ata_link *link)
503{
504 u32 scontrol;
505 int rc;
506
507 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
508 return rc;
509
510 if (!__sata_set_spd_needed(link, scontrol: &scontrol))
511 return 0;
512
513 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
514 return rc;
515
516 return 1;
517}
518EXPORT_SYMBOL_GPL(sata_set_spd);
519
520/**
521 * sata_down_spd_limit - adjust SATA spd limit downward
522 * @link: Link to adjust SATA spd limit for
523 * @spd_limit: Additional limit
524 *
525 * Adjust SATA spd limit of @link downward. Note that this
526 * function only adjusts the limit. The change must be applied
527 * using sata_set_spd().
528 *
529 * If @spd_limit is non-zero, the speed is limited to equal to or
530 * lower than @spd_limit if such speed is supported. If
531 * @spd_limit is slower than any supported speed, only the lowest
532 * supported speed is allowed.
533 *
534 * LOCKING:
535 * Inherited from caller.
536 *
537 * RETURNS:
538 * 0 on success, negative errno on failure
539 */
540int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
541{
542 u32 sstatus, spd, mask;
543 int rc, bit;
544
545 if (!sata_scr_valid(link))
546 return -EOPNOTSUPP;
547
548 /* If SCR can be read, use it to determine the current SPD.
549 * If not, use cached value in link->sata_spd.
550 */
551 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
552 if (rc == 0 && ata_sstatus_online(sstatus))
553 spd = (sstatus >> 4) & 0xf;
554 else
555 spd = link->sata_spd;
556
557 mask = link->sata_spd_limit;
558 if (mask <= 1)
559 return -EINVAL;
560
561 /* unconditionally mask off the highest bit */
562 bit = fls(x: mask) - 1;
563 mask &= ~(1 << bit);
564
565 /*
566 * Mask off all speeds higher than or equal to the current one. At
567 * this point, if current SPD is not available and we previously
568 * recorded the link speed from SStatus, the driver has already
569 * masked off the highest bit so mask should already be 1 or 0.
570 * Otherwise, we should not force 1.5Gbps on a link where we have
571 * not previously recorded speed from SStatus. Just return in this
572 * case.
573 */
574 if (spd > 1)
575 mask &= (1 << (spd - 1)) - 1;
576 else if (link->sata_spd)
577 return -EINVAL;
578
579 /* were we already at the bottom? */
580 if (!mask)
581 return -EINVAL;
582
583 if (spd_limit) {
584 if (mask & ((1 << spd_limit) - 1))
585 mask &= (1 << spd_limit) - 1;
586 else {
587 bit = ffs(mask) - 1;
588 mask = 1 << bit;
589 }
590 }
591
592 link->sata_spd_limit = mask;
593
594 ata_link_warn(link, "limiting SATA link speed to %s\n",
595 sata_spd_string(fls(mask)));
596
597 return 0;
598}
599
600/**
601 * sata_link_hardreset - reset link via SATA phy reset
602 * @link: link to reset
603 * @timing: timing parameters { interval, duration, timeout } in msec
604 * @deadline: deadline jiffies for the operation
605 * @online: optional out parameter indicating link onlineness
606 * @check_ready: optional callback to check link readiness
607 *
608 * SATA phy-reset @link using DET bits of SControl register.
609 * After hardreset, link readiness is waited upon using
610 * ata_wait_ready() if @check_ready is specified. LLDs are
611 * allowed to not specify @check_ready and wait itself after this
612 * function returns. Device classification is LLD's
613 * responsibility.
614 *
615 * *@online is set to one iff reset succeeded and @link is online
616 * after reset.
617 *
618 * LOCKING:
619 * Kernel thread context (may sleep)
620 *
621 * RETURNS:
622 * 0 on success, -errno otherwise.
623 */
624int sata_link_hardreset(struct ata_link *link, const unsigned int *timing,
625 unsigned long deadline,
626 bool *online, int (*check_ready)(struct ata_link *))
627{
628 u32 scontrol;
629 int rc;
630
631 if (online)
632 *online = false;
633
634 if (sata_set_spd_needed(link)) {
635 /* SATA spec says nothing about how to reconfigure
636 * spd. To be on the safe side, turn off phy during
637 * reconfiguration. This works for at least ICH7 AHCI
638 * and Sil3124.
639 */
640 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
641 goto out;
642
643 scontrol = (scontrol & 0x0f0) | 0x304;
644
645 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
646 goto out;
647
648 sata_set_spd(link);
649 }
650
651 /* issue phy wake/reset */
652 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
653 goto out;
654
655 scontrol = (scontrol & 0x0f0) | 0x301;
656
657 if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
658 goto out;
659
660 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
661 * 10.4.2 says at least 1 ms.
662 */
663 ata_msleep(ap: link->ap, msecs: 1);
664
665 /* bring link back */
666 rc = sata_link_resume(link, timing, deadline);
667 if (rc)
668 goto out;
669 /* if link is offline nothing more to do */
670 if (ata_phys_link_offline(link))
671 goto out;
672
673 /* Link is online. From this point, -ENODEV too is an error. */
674 if (online)
675 *online = true;
676
677 if (sata_pmp_supported(ap: link->ap) && ata_is_host_link(link)) {
678 /* If PMP is supported, we have to do follow-up SRST.
679 * Some PMPs don't send D2H Reg FIS after hardreset if
680 * the first port is empty. Wait only for
681 * ATA_TMOUT_PMP_SRST_WAIT.
682 */
683 if (check_ready) {
684 unsigned long pmp_deadline;
685
686 pmp_deadline = ata_deadline(from_jiffies: jiffies,
687 timeout_msecs: ATA_TMOUT_PMP_SRST_WAIT);
688 if (time_after(pmp_deadline, deadline))
689 pmp_deadline = deadline;
690 ata_wait_ready(link, deadline: pmp_deadline, check_ready);
691 }
692 rc = -EAGAIN;
693 goto out;
694 }
695
696 rc = 0;
697 if (check_ready)
698 rc = ata_wait_ready(link, deadline, check_ready);
699 out:
700 if (rc && rc != -EAGAIN) {
701 /* online is set iff link is online && reset succeeded */
702 if (online)
703 *online = false;
704 }
705 return rc;
706}
707EXPORT_SYMBOL_GPL(sata_link_hardreset);
708
709/**
710 * sata_std_hardreset - COMRESET w/o waiting or classification
711 * @link: link to reset
712 * @class: resulting class of attached device
713 * @deadline: deadline jiffies for the operation
714 *
715 * Standard SATA COMRESET w/o waiting or classification.
716 *
717 * LOCKING:
718 * Kernel thread context (may sleep)
719 *
720 * RETURNS:
721 * 0 if link offline, -EAGAIN if link online, -errno on errors.
722 */
723int sata_std_hardreset(struct ata_link *link, unsigned int *class,
724 unsigned long deadline)
725{
726 const unsigned int *timing = sata_ehc_deb_timing(ehc: &link->eh_context);
727 bool online;
728 int rc;
729
730 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
731 if (online)
732 return -EAGAIN;
733 return rc;
734}
735EXPORT_SYMBOL_GPL(sata_std_hardreset);
736
737/**
738 * ata_qc_complete_multiple - Complete multiple qcs successfully
739 * @ap: port in question
740 * @qc_active: new qc_active mask
741 *
742 * Complete in-flight commands. This functions is meant to be
743 * called from low-level driver's interrupt routine to complete
744 * requests normally. ap->qc_active and @qc_active is compared
745 * and commands are completed accordingly.
746 *
747 * Always use this function when completing multiple NCQ commands
748 * from IRQ handlers instead of calling ata_qc_complete()
749 * multiple times to keep IRQ expect status properly in sync.
750 *
751 * LOCKING:
752 * spin_lock_irqsave(host lock)
753 *
754 * RETURNS:
755 * Number of completed commands on success, -errno otherwise.
756 */
757int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active)
758{
759 u64 done_mask, ap_qc_active = ap->qc_active;
760 int nr_done = 0;
761
762 /*
763 * If the internal tag is set on ap->qc_active, then we care about
764 * bit0 on the passed in qc_active mask. Move that bit up to match
765 * the internal tag.
766 */
767 if (ap_qc_active & (1ULL << ATA_TAG_INTERNAL)) {
768 qc_active |= (qc_active & 0x01) << ATA_TAG_INTERNAL;
769 qc_active ^= qc_active & 0x01;
770 }
771
772 done_mask = ap_qc_active ^ qc_active;
773
774 if (unlikely(done_mask & qc_active)) {
775 ata_port_err(ap, "illegal qc_active transition (%08llx->%08llx)\n",
776 ap->qc_active, qc_active);
777 return -EINVAL;
778 }
779
780 if (ap->ops->qc_ncq_fill_rtf)
781 ap->ops->qc_ncq_fill_rtf(ap, done_mask);
782
783 while (done_mask) {
784 struct ata_queued_cmd *qc;
785 unsigned int tag = __ffs64(word: done_mask);
786
787 qc = ata_qc_from_tag(ap, tag);
788 if (qc) {
789 ata_qc_complete(qc);
790 nr_done++;
791 }
792 done_mask &= ~(1ULL << tag);
793 }
794
795 return nr_done;
796}
797EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
798
799/**
800 * ata_slave_link_init - initialize slave link
801 * @ap: port to initialize slave link for
802 *
803 * Create and initialize slave link for @ap. This enables slave
804 * link handling on the port.
805 *
806 * In libata, a port contains links and a link contains devices.
807 * There is single host link but if a PMP is attached to it,
808 * there can be multiple fan-out links. On SATA, there's usually
809 * a single device connected to a link but PATA and SATA
810 * controllers emulating TF based interface can have two - master
811 * and slave.
812 *
813 * However, there are a few controllers which don't fit into this
814 * abstraction too well - SATA controllers which emulate TF
815 * interface with both master and slave devices but also have
816 * separate SCR register sets for each device. These controllers
817 * need separate links for physical link handling
818 * (e.g. onlineness, link speed) but should be treated like a
819 * traditional M/S controller for everything else (e.g. command
820 * issue, softreset).
821 *
822 * slave_link is libata's way of handling this class of
823 * controllers without impacting core layer too much. For
824 * anything other than physical link handling, the default host
825 * link is used for both master and slave. For physical link
826 * handling, separate @ap->slave_link is used. All dirty details
827 * are implemented inside libata core layer. From LLD's POV, the
828 * only difference is that prereset, hardreset and postreset are
829 * called once more for the slave link, so the reset sequence
830 * looks like the following.
831 *
832 * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
833 * softreset(M) -> postreset(M) -> postreset(S)
834 *
835 * Note that softreset is called only for the master. Softreset
836 * resets both M/S by definition, so SRST on master should handle
837 * both (the standard method will work just fine).
838 *
839 * LOCKING:
840 * Should be called before host is registered.
841 *
842 * RETURNS:
843 * 0 on success, -errno on failure.
844 */
845int ata_slave_link_init(struct ata_port *ap)
846{
847 struct ata_link *link;
848
849 WARN_ON(ap->slave_link);
850 WARN_ON(ap->flags & ATA_FLAG_PMP);
851
852 link = kzalloc(sizeof(*link), GFP_KERNEL);
853 if (!link)
854 return -ENOMEM;
855
856 ata_link_init(ap, link, pmp: 1);
857 ap->slave_link = link;
858 return 0;
859}
860EXPORT_SYMBOL_GPL(ata_slave_link_init);
861
862/**
863 * sata_lpm_ignore_phy_events - test if PHY event should be ignored
864 * @link: Link receiving the event
865 *
866 * Test whether the received PHY event has to be ignored or not.
867 *
868 * LOCKING:
869 * None:
870 *
871 * RETURNS:
872 * True if the event has to be ignored.
873 */
874bool sata_lpm_ignore_phy_events(struct ata_link *link)
875{
876 unsigned long lpm_timeout = link->last_lpm_change +
877 msecs_to_jiffies(m: ATA_TMOUT_SPURIOUS_PHY);
878
879 /* if LPM is enabled, PHYRDY doesn't mean anything */
880 if (link->lpm_policy > ATA_LPM_MAX_POWER)
881 return true;
882
883 /* ignore the first PHY event after the LPM policy changed
884 * as it is might be spurious
885 */
886 if ((link->flags & ATA_LFLAG_CHANGED) &&
887 time_before(jiffies, lpm_timeout))
888 return true;
889
890 return false;
891}
892EXPORT_SYMBOL_GPL(sata_lpm_ignore_phy_events);
893
894static const char *ata_lpm_policy_names[] = {
895 [ATA_LPM_UNKNOWN] = "keep_firmware_settings",
896 [ATA_LPM_MAX_POWER] = "max_performance",
897 [ATA_LPM_MED_POWER] = "medium_power",
898 [ATA_LPM_MED_POWER_WITH_DIPM] = "med_power_with_dipm",
899 [ATA_LPM_MIN_POWER_WITH_PARTIAL] = "min_power_with_partial",
900 [ATA_LPM_MIN_POWER] = "min_power",
901};
902
903/*
904 * Check if a port supports link power management.
905 * Must be called with the port locked.
906 */
907static bool ata_scsi_lpm_supported(struct ata_port *ap)
908{
909 struct ata_link *link;
910 struct ata_device *dev;
911
912 if (ap->flags & ATA_FLAG_NO_LPM)
913 return false;
914
915 ata_for_each_link(link, ap, EDGE) {
916 ata_for_each_dev(dev, &ap->link, ENABLED) {
917 if (dev->quirks & ATA_QUIRK_NOLPM)
918 return false;
919 }
920 }
921
922 return true;
923}
924
925static ssize_t ata_scsi_lpm_supported_show(struct device *dev,
926 struct device_attribute *attr, char *buf)
927{
928 struct Scsi_Host *shost = class_to_shost(dev);
929 struct ata_port *ap = ata_shost_to_port(host: shost);
930 unsigned long flags;
931 bool supported;
932
933 spin_lock_irqsave(ap->lock, flags);
934 supported = ata_scsi_lpm_supported(ap);
935 spin_unlock_irqrestore(lock: ap->lock, flags);
936
937 return sysfs_emit(buf, fmt: "%d\n", supported);
938}
939DEVICE_ATTR(link_power_management_supported, S_IRUGO,
940 ata_scsi_lpm_supported_show, NULL);
941EXPORT_SYMBOL_GPL(dev_attr_link_power_management_supported);
942
943static ssize_t ata_scsi_lpm_store(struct device *device,
944 struct device_attribute *attr,
945 const char *buf, size_t count)
946{
947 struct Scsi_Host *shost = class_to_shost(device);
948 struct ata_port *ap = ata_shost_to_port(host: shost);
949 enum ata_lpm_policy policy;
950 unsigned long flags;
951
952 /* UNKNOWN is internal state, iterate from MAX_POWER */
953 for (policy = ATA_LPM_MAX_POWER;
954 policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) {
955 const char *name = ata_lpm_policy_names[policy];
956
957 if (strncmp(name, buf, strlen(name)) == 0)
958 break;
959 }
960 if (policy == ARRAY_SIZE(ata_lpm_policy_names))
961 return -EINVAL;
962
963 spin_lock_irqsave(ap->lock, flags);
964
965 if (!ata_scsi_lpm_supported(ap)) {
966 count = -EOPNOTSUPP;
967 goto out_unlock;
968 }
969
970 ap->target_lpm_policy = policy;
971 ata_port_schedule_eh(ap);
972out_unlock:
973 spin_unlock_irqrestore(lock: ap->lock, flags);
974 return count;
975}
976
977static ssize_t ata_scsi_lpm_show(struct device *dev,
978 struct device_attribute *attr, char *buf)
979{
980 struct Scsi_Host *shost = class_to_shost(dev);
981 struct ata_port *ap = ata_shost_to_port(host: shost);
982
983 if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
984 return -EINVAL;
985
986 return sysfs_emit(buf, fmt: "%s\n",
987 ata_lpm_policy_names[ap->target_lpm_policy]);
988}
989DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
990 ata_scsi_lpm_show, ata_scsi_lpm_store);
991EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
992
993/**
994 * ata_ncq_prio_supported - Check if device supports NCQ Priority
995 * @ap: ATA port of the target device
996 * @sdev: SCSI device
997 * @supported: Address of a boolean to store the result
998 *
999 * Helper to check if device supports NCQ Priority feature.
1000 *
1001 * Context: Any context. Takes and releases @ap->lock.
1002 *
1003 * Return:
1004 * * %0 - OK. Status is stored into @supported
1005 * * %-ENODEV - Failed to find the ATA device
1006 */
1007int ata_ncq_prio_supported(struct ata_port *ap, struct scsi_device *sdev,
1008 bool *supported)
1009{
1010 struct ata_device *dev;
1011 unsigned long flags;
1012 int rc = 0;
1013
1014 spin_lock_irqsave(ap->lock, flags);
1015 dev = ata_scsi_find_dev(ap, scsidev: sdev);
1016 if (!dev)
1017 rc = -ENODEV;
1018 else
1019 *supported = dev->flags & ATA_DFLAG_NCQ_PRIO;
1020 spin_unlock_irqrestore(lock: ap->lock, flags);
1021
1022 return rc;
1023}
1024EXPORT_SYMBOL_GPL(ata_ncq_prio_supported);
1025
1026static ssize_t ata_ncq_prio_supported_show(struct device *device,
1027 struct device_attribute *attr,
1028 char *buf)
1029{
1030 struct scsi_device *sdev = to_scsi_device(device);
1031 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1032 bool supported;
1033 int rc;
1034
1035 rc = ata_ncq_prio_supported(ap, sdev, &supported);
1036 if (rc)
1037 return rc;
1038
1039 return sysfs_emit(buf, fmt: "%d\n", supported);
1040}
1041
1042DEVICE_ATTR(ncq_prio_supported, S_IRUGO, ata_ncq_prio_supported_show, NULL);
1043EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_supported);
1044
1045/**
1046 * ata_ncq_prio_enabled - Check if NCQ Priority is enabled
1047 * @ap: ATA port of the target device
1048 * @sdev: SCSI device
1049 * @enabled: Address of a boolean to store the result
1050 *
1051 * Helper to check if NCQ Priority feature is enabled.
1052 *
1053 * Context: Any context. Takes and releases @ap->lock.
1054 *
1055 * Return:
1056 * * %0 - OK. Status is stored into @enabled
1057 * * %-ENODEV - Failed to find the ATA device
1058 */
1059int ata_ncq_prio_enabled(struct ata_port *ap, struct scsi_device *sdev,
1060 bool *enabled)
1061{
1062 struct ata_device *dev;
1063 unsigned long flags;
1064 int rc = 0;
1065
1066 spin_lock_irqsave(ap->lock, flags);
1067 dev = ata_scsi_find_dev(ap, scsidev: sdev);
1068 if (!dev)
1069 rc = -ENODEV;
1070 else
1071 *enabled = dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED;
1072 spin_unlock_irqrestore(lock: ap->lock, flags);
1073
1074 return rc;
1075}
1076EXPORT_SYMBOL_GPL(ata_ncq_prio_enabled);
1077
1078static ssize_t ata_ncq_prio_enable_show(struct device *device,
1079 struct device_attribute *attr,
1080 char *buf)
1081{
1082 struct scsi_device *sdev = to_scsi_device(device);
1083 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1084 bool enabled;
1085 int rc;
1086
1087 rc = ata_ncq_prio_enabled(ap, sdev, &enabled);
1088 if (rc)
1089 return rc;
1090
1091 return sysfs_emit(buf, fmt: "%d\n", enabled);
1092}
1093
1094/**
1095 * ata_ncq_prio_enable - Enable/disable NCQ Priority
1096 * @ap: ATA port of the target device
1097 * @sdev: SCSI device
1098 * @enable: true - enable NCQ Priority, false - disable NCQ Priority
1099 *
1100 * Helper to enable/disable NCQ Priority feature.
1101 *
1102 * Context: Any context. Takes and releases @ap->lock.
1103 *
1104 * Return:
1105 * * %0 - OK. Status is stored into @enabled
1106 * * %-ENODEV - Failed to find the ATA device
1107 * * %-EINVAL - NCQ Priority is not supported or CDL is enabled
1108 */
1109int ata_ncq_prio_enable(struct ata_port *ap, struct scsi_device *sdev,
1110 bool enable)
1111{
1112 struct ata_device *dev;
1113 unsigned long flags;
1114 int rc = 0;
1115
1116 spin_lock_irqsave(ap->lock, flags);
1117
1118 dev = ata_scsi_find_dev(ap, scsidev: sdev);
1119 if (!dev) {
1120 rc = -ENODEV;
1121 goto unlock;
1122 }
1123
1124 if (!(dev->flags & ATA_DFLAG_NCQ_PRIO)) {
1125 rc = -EINVAL;
1126 goto unlock;
1127 }
1128
1129 if (enable) {
1130 if (dev->flags & ATA_DFLAG_CDL_ENABLED) {
1131 ata_dev_err(dev,
1132 "CDL must be disabled to enable NCQ priority\n");
1133 rc = -EINVAL;
1134 goto unlock;
1135 }
1136 dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLED;
1137 } else {
1138 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED;
1139 }
1140
1141unlock:
1142 spin_unlock_irqrestore(lock: ap->lock, flags);
1143
1144 return rc;
1145}
1146EXPORT_SYMBOL_GPL(ata_ncq_prio_enable);
1147
1148static ssize_t ata_ncq_prio_enable_store(struct device *device,
1149 struct device_attribute *attr,
1150 const char *buf, size_t len)
1151{
1152 struct scsi_device *sdev = to_scsi_device(device);
1153 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1154 bool enable;
1155 int rc;
1156
1157 rc = kstrtobool(s: buf, res: &enable);
1158 if (rc)
1159 return rc;
1160
1161 rc = ata_ncq_prio_enable(ap, sdev, enable);
1162 if (rc)
1163 return rc;
1164
1165 return len;
1166}
1167
1168DEVICE_ATTR(ncq_prio_enable, S_IRUGO | S_IWUSR,
1169 ata_ncq_prio_enable_show, ata_ncq_prio_enable_store);
1170EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_enable);
1171
1172static struct attribute *ata_ncq_sdev_attrs[] = {
1173 &dev_attr_unload_heads.attr,
1174 &dev_attr_ncq_prio_enable.attr,
1175 &dev_attr_ncq_prio_supported.attr,
1176 NULL
1177};
1178
1179static const struct attribute_group ata_ncq_sdev_attr_group = {
1180 .attrs = ata_ncq_sdev_attrs
1181};
1182
1183const struct attribute_group *ata_ncq_sdev_groups[] = {
1184 &ata_ncq_sdev_attr_group,
1185 NULL
1186};
1187EXPORT_SYMBOL_GPL(ata_ncq_sdev_groups);
1188
1189static ssize_t
1190ata_scsi_em_message_store(struct device *dev, struct device_attribute *attr,
1191 const char *buf, size_t count)
1192{
1193 struct Scsi_Host *shost = class_to_shost(dev);
1194 struct ata_port *ap = ata_shost_to_port(host: shost);
1195 if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM))
1196 return ap->ops->em_store(ap, buf, count);
1197 return -EINVAL;
1198}
1199
1200static ssize_t
1201ata_scsi_em_message_show(struct device *dev, struct device_attribute *attr,
1202 char *buf)
1203{
1204 struct Scsi_Host *shost = class_to_shost(dev);
1205 struct ata_port *ap = ata_shost_to_port(host: shost);
1206
1207 if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM))
1208 return ap->ops->em_show(ap, buf);
1209 return -EINVAL;
1210}
1211DEVICE_ATTR(em_message, S_IRUGO | S_IWUSR,
1212 ata_scsi_em_message_show, ata_scsi_em_message_store);
1213EXPORT_SYMBOL_GPL(dev_attr_em_message);
1214
1215static ssize_t
1216ata_scsi_em_message_type_show(struct device *dev, struct device_attribute *attr,
1217 char *buf)
1218{
1219 struct Scsi_Host *shost = class_to_shost(dev);
1220 struct ata_port *ap = ata_shost_to_port(host: shost);
1221
1222 return sysfs_emit(buf, fmt: "%d\n", ap->em_message_type);
1223}
1224DEVICE_ATTR(em_message_type, S_IRUGO,
1225 ata_scsi_em_message_type_show, NULL);
1226EXPORT_SYMBOL_GPL(dev_attr_em_message_type);
1227
1228static ssize_t
1229ata_scsi_activity_show(struct device *dev, struct device_attribute *attr,
1230 char *buf)
1231{
1232 struct scsi_device *sdev = to_scsi_device(dev);
1233 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1234 struct ata_device *atadev = ata_scsi_find_dev(ap, scsidev: sdev);
1235
1236 if (atadev && ap->ops->sw_activity_show &&
1237 (ap->flags & ATA_FLAG_SW_ACTIVITY))
1238 return ap->ops->sw_activity_show(atadev, buf);
1239 return -EINVAL;
1240}
1241
1242static ssize_t
1243ata_scsi_activity_store(struct device *dev, struct device_attribute *attr,
1244 const char *buf, size_t count)
1245{
1246 struct scsi_device *sdev = to_scsi_device(dev);
1247 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1248 struct ata_device *atadev = ata_scsi_find_dev(ap, scsidev: sdev);
1249 enum sw_activity val;
1250 int rc;
1251
1252 if (atadev && ap->ops->sw_activity_store &&
1253 (ap->flags & ATA_FLAG_SW_ACTIVITY)) {
1254 val = simple_strtoul(buf, NULL, 0);
1255 switch (val) {
1256 case OFF: case BLINK_ON: case BLINK_OFF:
1257 rc = ap->ops->sw_activity_store(atadev, val);
1258 if (!rc)
1259 return count;
1260 else
1261 return rc;
1262 }
1263 }
1264 return -EINVAL;
1265}
1266DEVICE_ATTR(sw_activity, S_IWUSR | S_IRUGO, ata_scsi_activity_show,
1267 ata_scsi_activity_store);
1268EXPORT_SYMBOL_GPL(dev_attr_sw_activity);
1269
1270/**
1271 * ata_change_queue_depth - Set a device maximum queue depth
1272 * @ap: ATA port of the target device
1273 * @sdev: SCSI device to configure queue depth for
1274 * @queue_depth: new queue depth
1275 *
1276 * Helper to set a device maximum queue depth, usable with both libsas
1277 * and libata.
1278 *
1279 */
1280int ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
1281 int queue_depth)
1282{
1283 struct ata_device *dev;
1284 unsigned long flags;
1285 int max_queue_depth;
1286
1287 spin_lock_irqsave(ap->lock, flags);
1288
1289 dev = ata_scsi_find_dev(ap, scsidev: sdev);
1290 if (!dev || queue_depth < 1 || queue_depth == sdev->queue_depth) {
1291 spin_unlock_irqrestore(lock: ap->lock, flags);
1292 return sdev->queue_depth;
1293 }
1294
1295 /*
1296 * Make sure that the queue depth requested does not exceed the device
1297 * capabilities.
1298 */
1299 max_queue_depth = min(ATA_MAX_QUEUE, sdev->host->can_queue);
1300 max_queue_depth = min(max_queue_depth, ata_id_queue_depth(dev->id));
1301 if (queue_depth > max_queue_depth) {
1302 spin_unlock_irqrestore(lock: ap->lock, flags);
1303 return -EINVAL;
1304 }
1305
1306 /*
1307 * If NCQ is not supported by the device or if the target queue depth
1308 * is 1 (to disable drive side command queueing), turn off NCQ.
1309 */
1310 if (queue_depth == 1 || !ata_ncq_supported(dev)) {
1311 dev->flags |= ATA_DFLAG_NCQ_OFF;
1312 queue_depth = 1;
1313 } else {
1314 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
1315 }
1316
1317 spin_unlock_irqrestore(lock: ap->lock, flags);
1318
1319 if (queue_depth == sdev->queue_depth)
1320 return sdev->queue_depth;
1321
1322 return scsi_change_queue_depth(sdev, queue_depth);
1323}
1324EXPORT_SYMBOL_GPL(ata_change_queue_depth);
1325
1326/**
1327 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
1328 * @sdev: SCSI device to configure queue depth for
1329 * @queue_depth: new queue depth
1330 *
1331 * This is libata standard hostt->change_queue_depth callback.
1332 * SCSI will call into this callback when user tries to set queue
1333 * depth via sysfs.
1334 *
1335 * LOCKING:
1336 * SCSI layer (we don't care)
1337 *
1338 * RETURNS:
1339 * Newly configured queue depth.
1340 */
1341int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
1342{
1343 struct ata_port *ap = ata_shost_to_port(host: sdev->host);
1344
1345 return ata_change_queue_depth(ap, sdev, queue_depth);
1346}
1347EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
1348
1349/**
1350 * ata_sas_sdev_configure - Default sdev_configure routine for libata
1351 * devices
1352 * @sdev: SCSI device to configure
1353 * @lim: queue limits
1354 * @ap: ATA port to which SCSI device is attached
1355 *
1356 * RETURNS:
1357 * Zero.
1358 */
1359
1360int ata_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim,
1361 struct ata_port *ap)
1362{
1363 ata_scsi_sdev_config(sdev);
1364
1365 return ata_scsi_dev_config(sdev, lim, dev: ap->link.device);
1366}
1367EXPORT_SYMBOL_GPL(ata_sas_sdev_configure);
1368
1369/**
1370 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
1371 * @cmd: SCSI command to be sent
1372 * @ap: ATA port to which the command is being sent
1373 *
1374 * RETURNS:
1375 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
1376 * 0 otherwise.
1377 */
1378
1379int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap)
1380{
1381 int rc = 0;
1382
1383 if (likely(ata_dev_enabled(ap->link.device)))
1384 rc = __ata_scsi_queuecmd(scmd: cmd, dev: ap->link.device);
1385 else {
1386 cmd->result = (DID_BAD_TARGET << 16);
1387 scsi_done(cmd);
1388 }
1389 return rc;
1390}
1391EXPORT_SYMBOL_GPL(ata_sas_queuecmd);
1392
1393/**
1394 * sata_async_notification - SATA async notification handler
1395 * @ap: ATA port where async notification is received
1396 *
1397 * Handler to be called when async notification via SDB FIS is
1398 * received. This function schedules EH if necessary.
1399 *
1400 * LOCKING:
1401 * spin_lock_irqsave(host lock)
1402 *
1403 * RETURNS:
1404 * 1 if EH is scheduled, 0 otherwise.
1405 */
1406int sata_async_notification(struct ata_port *ap)
1407{
1408 u32 sntf;
1409 int rc;
1410
1411 if (!(ap->flags & ATA_FLAG_AN))
1412 return 0;
1413
1414 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1415 if (rc == 0)
1416 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1417
1418 if (!sata_pmp_attached(ap) || rc) {
1419 /* PMP is not attached or SNTF is not available */
1420 if (!sata_pmp_attached(ap)) {
1421 /* PMP is not attached. Check whether ATAPI
1422 * AN is configured. If so, notify media
1423 * change.
1424 */
1425 struct ata_device *dev = ap->link.device;
1426
1427 if ((dev->class == ATA_DEV_ATAPI) &&
1428 (dev->flags & ATA_DFLAG_AN))
1429 ata_scsi_media_change_notify(dev);
1430 return 0;
1431 } else {
1432 /* PMP is attached but SNTF is not available.
1433 * ATAPI async media change notification is
1434 * not used. The PMP must be reporting PHY
1435 * status change, schedule EH.
1436 */
1437 ata_port_schedule_eh(ap);
1438 return 1;
1439 }
1440 } else {
1441 /* PMP is attached and SNTF is available */
1442 struct ata_link *link;
1443
1444 /* check and notify ATAPI AN */
1445 ata_for_each_link(link, ap, EDGE) {
1446 if (!(sntf & (1 << link->pmp)))
1447 continue;
1448
1449 if ((link->device->class == ATA_DEV_ATAPI) &&
1450 (link->device->flags & ATA_DFLAG_AN))
1451 ata_scsi_media_change_notify(dev: link->device);
1452 }
1453
1454 /* If PMP is reporting that PHY status of some
1455 * downstream ports has changed, schedule EH.
1456 */
1457 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1458 ata_port_schedule_eh(ap);
1459 return 1;
1460 }
1461
1462 return 0;
1463 }
1464}
1465EXPORT_SYMBOL_GPL(sata_async_notification);
1466
1467/**
1468 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1469 * @dev: Device to read log page 10h from
1470 * @tag: Resulting tag of the failed command
1471 * @tf: Resulting taskfile registers of the failed command
1472 *
1473 * Read log page 10h to obtain NCQ error details and clear error
1474 * condition.
1475 *
1476 * LOCKING:
1477 * Kernel thread context (may sleep).
1478 *
1479 * RETURNS:
1480 * 0 on success, -errno otherwise.
1481 */
1482static int ata_eh_read_log_10h(struct ata_device *dev,
1483 int *tag, struct ata_taskfile *tf)
1484{
1485 u8 *buf = dev->sector_buf;
1486 unsigned int err_mask;
1487 u8 csum;
1488 int i;
1489
1490 err_mask = ata_read_log_page(dev, log: ATA_LOG_SATA_NCQ, page: 0, buf, sectors: 1);
1491 if (err_mask)
1492 return -EIO;
1493
1494 csum = 0;
1495 for (i = 0; i < ATA_SECT_SIZE; i++)
1496 csum += buf[i];
1497 if (csum)
1498 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1499 csum);
1500
1501 if (buf[0] & 0x80)
1502 return -ENOENT;
1503
1504 *tag = buf[0] & 0x1f;
1505
1506 tf->status = buf[2];
1507 tf->error = buf[3];
1508 tf->lbal = buf[4];
1509 tf->lbam = buf[5];
1510 tf->lbah = buf[6];
1511 tf->device = buf[7];
1512 tf->hob_lbal = buf[8];
1513 tf->hob_lbam = buf[9];
1514 tf->hob_lbah = buf[10];
1515 tf->nsect = buf[12];
1516 tf->hob_nsect = buf[13];
1517 if (ata_id_has_ncq_autosense(dev->id) && (tf->status & ATA_SENSE))
1518 tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
1519
1520 return 0;
1521}
1522
1523/**
1524 * ata_eh_get_ncq_success_sense - Read and process the sense data for
1525 * successful NCQ commands log page
1526 * @link: ATA link to get sense data for
1527 *
1528 * Read the sense data for successful NCQ commands log page to obtain
1529 * sense data for all NCQ commands that completed successfully with
1530 * the sense data available bit set.
1531 *
1532 * LOCKING:
1533 * Kernel thread context (may sleep).
1534 *
1535 * RETURNS:
1536 * 0 on success, -errno otherwise.
1537 */
1538int ata_eh_get_ncq_success_sense(struct ata_link *link)
1539{
1540 struct ata_device *dev = link->device;
1541 struct ata_port *ap = dev->link->ap;
1542 u8 *buf = dev->cdl->ncq_sense_log_buf;
1543 struct ata_queued_cmd *qc;
1544 unsigned int err_mask, tag;
1545 u8 *sense, sk = 0, asc = 0, ascq = 0;
1546 u16 extended_sense;
1547 bool aux_icc_valid;
1548 u32 sense_valid;
1549 u64 val;
1550 int ret = 0;
1551
1552 err_mask = ata_read_log_page(dev, log: ATA_LOG_SENSE_NCQ, page: 0, buf, sectors: 2);
1553 if (err_mask) {
1554 ata_dev_err(dev,
1555 "Failed to read Sense Data for Successful NCQ Commands log\n");
1556 return -EIO;
1557 }
1558
1559 /* Check the log header */
1560 val = get_unaligned_le64(p: &buf[0]);
1561 if ((val & 0xffff) != 1 || ((val >> 16) & 0xff) != 0x0f) {
1562 ata_dev_err(dev,
1563 "Invalid Sense Data for Successful NCQ Commands log\n");
1564 return -EIO;
1565 }
1566
1567 sense_valid = get_unaligned_le32(p: &buf[8]);
1568 extended_sense = get_unaligned_le16(p: &buf[14]);
1569 aux_icc_valid = extended_sense & BIT(15);
1570
1571 ata_qc_for_each_raw(ap, qc, tag) {
1572 if (!(qc->flags & ATA_QCFLAG_EH) ||
1573 !(qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) ||
1574 qc->err_mask ||
1575 ata_dev_phys_link(dev: qc->dev) != link)
1576 continue;
1577
1578 /*
1579 * If the command does not have any sense data, clear ATA_SENSE.
1580 * Keep ATA_QCFLAG_EH_SUCCESS_CMD so that command is finished.
1581 */
1582 if (!(sense_valid & BIT(tag))) {
1583 qc->result_tf.status &= ~ATA_SENSE;
1584 continue;
1585 }
1586
1587 sense = &buf[32 + 24 * tag];
1588 sk = sense[0];
1589 asc = sense[1];
1590 ascq = sense[2];
1591
1592 if (!ata_scsi_sense_is_valid(sk, asc, ascq)) {
1593 ret = -EIO;
1594 continue;
1595 }
1596
1597 qc->result_tf.nsect = sense[6];
1598 qc->result_tf.hob_nsect = sense[7];
1599 qc->result_tf.lbal = sense[8];
1600 qc->result_tf.lbam = sense[9];
1601 qc->result_tf.lbah = sense[10];
1602 qc->result_tf.hob_lbal = sense[11];
1603 qc->result_tf.hob_lbam = sense[12];
1604 qc->result_tf.hob_lbah = sense[13];
1605 if (aux_icc_valid)
1606 qc->result_tf.auxiliary = get_unaligned_le32(p: &sense[16]);
1607
1608 /* Set sense without also setting scsicmd->result */
1609 scsi_build_sense_buffer(desc: dev->flags & ATA_DFLAG_D_SENSE,
1610 buf: qc->scsicmd->sense_buffer, key: sk,
1611 asc, ascq);
1612 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1613
1614 /*
1615 * No point in checking the return value, since the command has
1616 * already completed successfully.
1617 */
1618 ata_eh_decide_disposition(qc);
1619 }
1620
1621 return ret;
1622}
1623
1624/**
1625 * ata_eh_analyze_ncq_error - analyze NCQ error
1626 * @link: ATA link to analyze NCQ error for
1627 *
1628 * Read log page 10h, determine the offending qc and acquire
1629 * error status TF. For NCQ device errors, all LLDDs have to do
1630 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1631 * care of the rest.
1632 *
1633 * LOCKING:
1634 * Kernel thread context (may sleep).
1635 */
1636void ata_eh_analyze_ncq_error(struct ata_link *link)
1637{
1638 struct ata_port *ap = link->ap;
1639 struct ata_eh_context *ehc = &link->eh_context;
1640 struct ata_device *dev = link->device;
1641 struct ata_queued_cmd *qc;
1642 struct ata_taskfile tf;
1643 int tag, rc;
1644
1645 /* if frozen, we can't do much */
1646 if (ata_port_is_frozen(ap))
1647 return;
1648
1649 /* is it NCQ device error? */
1650 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1651 return;
1652
1653 /* has LLDD analyzed already? */
1654 ata_qc_for_each_raw(ap, qc, tag) {
1655 if (!(qc->flags & ATA_QCFLAG_EH))
1656 continue;
1657
1658 if (qc->err_mask)
1659 return;
1660 }
1661
1662 /* okay, this error is ours */
1663 memset(s: &tf, c: 0, n: sizeof(tf));
1664 rc = ata_eh_read_log_10h(dev, tag: &tag, tf: &tf);
1665 if (rc) {
1666 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1667 rc);
1668 return;
1669 }
1670
1671 if (!(link->sactive & BIT(tag))) {
1672 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1673 tag);
1674 return;
1675 }
1676
1677 /* we've got the perpetrator, condemn it */
1678 qc = __ata_qc_from_tag(ap, tag);
1679 memcpy(to: &qc->result_tf, from: &tf, len: sizeof(tf));
1680 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1681 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1682
1683 /*
1684 * If the device supports NCQ autosense, ata_eh_read_log_10h() will have
1685 * stored the sense data in qc->result_tf.auxiliary.
1686 */
1687 if (qc->result_tf.auxiliary) {
1688 char sense_key, asc, ascq;
1689
1690 sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
1691 asc = (qc->result_tf.auxiliary >> 8) & 0xff;
1692 ascq = qc->result_tf.auxiliary & 0xff;
1693 if (ata_scsi_sense_is_valid(sk: sense_key, asc, ascq)) {
1694 ata_scsi_set_sense(dev, cmd: qc->scsicmd, sk: sense_key, asc,
1695 ascq);
1696 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1697 }
1698 }
1699
1700 ata_qc_for_each_raw(ap, qc, tag) {
1701 if (!(qc->flags & ATA_QCFLAG_EH) ||
1702 qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD ||
1703 ata_dev_phys_link(dev: qc->dev) != link)
1704 continue;
1705
1706 /* Skip the single QC which caused the NCQ error. */
1707 if (qc->err_mask)
1708 continue;
1709
1710 /*
1711 * For SATA, the STATUS and ERROR fields are shared for all NCQ
1712 * commands that were completed with the same SDB FIS.
1713 * Therefore, we have to clear the ATA_ERR bit for all QCs
1714 * except the one that caused the NCQ error.
1715 */
1716 qc->result_tf.status &= ~ATA_ERR;
1717 qc->result_tf.error = 0;
1718
1719 /*
1720 * If we get a NCQ error, that means that a single command was
1721 * aborted. All other failed commands for our link should be
1722 * retried and has no business of going though further scrutiny
1723 * by ata_eh_link_autopsy().
1724 */
1725 qc->flags |= ATA_QCFLAG_RETRY;
1726 }
1727
1728 ehc->i.err_mask &= ~AC_ERR_DEV;
1729}
1730EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error);
1731
1732const struct ata_port_operations sata_port_ops = {
1733 .inherits = &ata_base_port_ops,
1734
1735 .qc_defer = ata_std_qc_defer,
1736 .reset.hardreset = sata_std_hardreset,
1737};
1738EXPORT_SYMBOL_GPL(sata_port_ops);
1739