projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'printk-for-6.6-fixup' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-block.git] / drivers / ata / libata-sata.c
CommitLineData
7fe183c7
BZ		 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
a695de27 7 * Copyright 2006 Tejun Heo <htejun@gmail.com>
7fe183c7
BZ		 8 */
9
10#include <linux/kernel.h>
11#include <linux/module.h>
15964ff7 12#include <scsi/scsi_cmnd.h>
ec811a94 13#include <scsi/scsi_device.h>
18bd7718 14#include <scsi/scsi_eh.h>
7fe183c7 15#include <linux/libata.h>
18bd7718 16#include <asm/unaligned.h>
7fe183c7
BZ		 17
18#include "libata.h"
15964ff7 19#include "libata-transport.h"
7fe183c7 20
2b384ede 21/* debounce timing parameters in msecs { interval, duration, timeout } */
d14d41cc 22const unsigned int sata_deb_timing_normal[] = { 5, 100, 2000 };
2b384ede 23EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
d14d41cc 24const unsigned int sata_deb_timing_hotplug[] = { 25, 500, 2000 };
2b384ede 25EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
d14d41cc 26const unsigned int sata_deb_timing_long[] = { 100, 2000, 5000 };
2b384ede
BZ		 27EXPORT_SYMBOL_GPL(sata_deb_timing_long);
28
6eab1bc0
BZ		 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
7fe183c7
BZ		 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{
efcef265
SS		 196 tf->status = fis[2];
197 tf->error = fis[3];
7fe183c7
BZ		 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
9d3158f5
BZ		 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 */
d14d41cc 235int sata_link_debounce(struct ata_link *link, const unsigned int *params,
9d3158f5
BZ		 236 unsigned long deadline)
237{
d14d41cc
SS		 238 unsigned int interval = params[0];
239 unsigned int duration = params[1];
9d3158f5
BZ		 240 unsigned long last_jiffies, t;
241 u32 last, cur;
242 int rc;
243
244 t = ata_deadline(jiffies, 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(link->ap, 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 */
d14d41cc 298int sata_link_resume(struct ata_link *link, const unsigned int *params,
9d3158f5
BZ		 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 */
b9ba367c 322 if (!(link->flags & ATA_LFLAG_NO_DEBOUNCE_DELAY))
9d3158f5
BZ		 323 ata_msleep(link->ap, 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
7fe183c7
BZ		 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 /* no restrictions on LPM transitions */
401 scontrol &= ~(0x7 << 8);
402 else {
403 /* empty port, power off */
404 scontrol &= ~0xf;
405 scontrol |= (0x1 << 2);
406 }
407 break;
408 default:
409 WARN_ON(1);
410 }
411
412 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
413 if (rc)
414 return rc;
415
416 /* give the link time to transit out of LPM state */
417 if (woken_up)
418 msleep(10);
419
420 /* clear PHYRDY_CHG from SError */
421 ehc->i.serror &= ~SERR_PHYRDY_CHG;
422 return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
423}
424EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
425
ab4117cf
BZ		 426static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
427{
428 struct ata_link *host_link = &link->ap->link;
429 u32 limit, target, spd;
430
431 limit = link->sata_spd_limit;
432
433 /* Don't configure downstream link faster than upstream link.
434 * It doesn't speed up anything and some PMPs choke on such
435 * configuration.
436 */
437 if (!ata_is_host_link(link) && host_link->sata_spd)
438 limit &= (1 << host_link->sata_spd) - 1;
439
440 if (limit == UINT_MAX)
441 target = 0;
442 else
443 target = fls(limit);
444
445 spd = (*scontrol >> 4) & 0xf;
446 *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
447
448 return spd != target;
449}
450
451/**
452 * sata_set_spd_needed - is SATA spd configuration needed
453 * @link: Link in question
454 *
455 * Test whether the spd limit in SControl matches
456 * @link->sata_spd_limit. This function is used to determine
457 * whether hardreset is necessary to apply SATA spd
458 * configuration.
459 *
460 * LOCKING:
461 * Inherited from caller.
462 *
463 * RETURNS:
464 * 1 if SATA spd configuration is needed, 0 otherwise.
465 */
78c97c80 466static int sata_set_spd_needed(struct ata_link *link)
ab4117cf
BZ		 467{
468 u32 scontrol;
469
470 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
471 return 1;
472
473 return __sata_set_spd_needed(link, &scontrol);
474}
475
476/**
477 * sata_set_spd - set SATA spd according to spd limit
478 * @link: Link to set SATA spd for
479 *
480 * Set SATA spd of @link according to sata_spd_limit.
481 *
482 * LOCKING:
483 * Inherited from caller.
484 *
485 * RETURNS:
486 * 0 if spd doesn't need to be changed, 1 if spd has been
487 * changed. Negative errno if SCR registers are inaccessible.
488 */
489int sata_set_spd(struct ata_link *link)
490{
491 u32 scontrol;
492 int rc;
493
494 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
495 return rc;
496
497 if (!__sata_set_spd_needed(link, &scontrol))
498 return 0;
499
500 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
501 return rc;
502
503 return 1;
504}
505EXPORT_SYMBOL_GPL(sata_set_spd);
506
78c97c80
BZ		 507/**
508 * sata_link_hardreset - reset link via SATA phy reset
509 * @link: link to reset
510 * @timing: timing parameters { interval, duration, timeout } in msec
511 * @deadline: deadline jiffies for the operation
512 * @online: optional out parameter indicating link onlineness
513 * @check_ready: optional callback to check link readiness
514 *
515 * SATA phy-reset @link using DET bits of SControl register.
516 * After hardreset, link readiness is waited upon using
517 * ata_wait_ready() if @check_ready is specified. LLDs are
518 * allowed to not specify @check_ready and wait itself after this
519 * function returns. Device classification is LLD's
520 * responsibility.
521 *
522 * *@online is set to one iff reset succeeded and @link is online
523 * after reset.
524 *
525 * LOCKING:
526 * Kernel thread context (may sleep)
527 *
528 * RETURNS:
529 * 0 on success, -errno otherwise.
530 */
d14d41cc 531int sata_link_hardreset(struct ata_link *link, const unsigned int *timing,
78c97c80
BZ		 532 unsigned long deadline,
533 bool *online, int (*check_ready)(struct ata_link *))
534{
535 u32 scontrol;
536 int rc;
537
78c97c80
BZ		 538 if (online)
539 *online = false;
540
541 if (sata_set_spd_needed(link)) {
542 /* SATA spec says nothing about how to reconfigure
543 * spd. To be on the safe side, turn off phy during
544 * reconfiguration. This works for at least ICH7 AHCI
545 * and Sil3124.
546 */
547 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
548 goto out;
549
550 scontrol = (scontrol & 0x0f0) | 0x304;
551
552 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
553 goto out;
554
555 sata_set_spd(link);
556 }
557
558 /* issue phy wake/reset */
559 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
560 goto out;
561
562 scontrol = (scontrol & 0x0f0) | 0x301;
563
564 if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
565 goto out;
566
567 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
568 * 10.4.2 says at least 1 ms.
569 */
570 ata_msleep(link->ap, 1);
571
572 /* bring link back */
573 rc = sata_link_resume(link, timing, deadline);
574 if (rc)
575 goto out;
576 /* if link is offline nothing more to do */
577 if (ata_phys_link_offline(link))
578 goto out;
579
580 /* Link is online. From this point, -ENODEV too is an error. */
581 if (online)
582 *online = true;
583
584 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) {
585 /* If PMP is supported, we have to do follow-up SRST.
586 * Some PMPs don't send D2H Reg FIS after hardreset if
587 * the first port is empty. Wait only for
588 * ATA_TMOUT_PMP_SRST_WAIT.
589 */
590 if (check_ready) {
591 unsigned long pmp_deadline;
592
593 pmp_deadline = ata_deadline(jiffies,
594 ATA_TMOUT_PMP_SRST_WAIT);
595 if (time_after(pmp_deadline, deadline))
596 pmp_deadline = deadline;
597 ata_wait_ready(link, pmp_deadline, check_ready);
598 }
599 rc = -EAGAIN;
600 goto out;
601 }
602
603 rc = 0;
604 if (check_ready)
605 rc = ata_wait_ready(link, deadline, check_ready);
606 out:
607 if (rc && rc != -EAGAIN) {
608 /* online is set iff link is online && reset succeeded */
609 if (online)
610 *online = false;
611 ata_link_err(link, "COMRESET failed (errno=%d)\n", rc);
612 }
78c97c80
BZ		 613 return rc;
614}
615EXPORT_SYMBOL_GPL(sata_link_hardreset);
616
61a11986
BZ		 617/**
618 * ata_qc_complete_multiple - Complete multiple qcs successfully
619 * @ap: port in question
620 * @qc_active: new qc_active mask
621 *
622 * Complete in-flight commands. This functions is meant to be
623 * called from low-level driver's interrupt routine to complete
624 * requests normally. ap->qc_active and @qc_active is compared
625 * and commands are completed accordingly.
626 *
627 * Always use this function when completing multiple NCQ commands
628 * from IRQ handlers instead of calling ata_qc_complete()
629 * multiple times to keep IRQ expect status properly in sync.
630 *
631 * LOCKING:
632 * spin_lock_irqsave(host lock)
633 *
634 * RETURNS:
635 * Number of completed commands on success, -errno otherwise.
636 */
637int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active)
638{
639 u64 done_mask, ap_qc_active = ap->qc_active;
640 int nr_done = 0;
641
642 /*
643 * If the internal tag is set on ap->qc_active, then we care about
644 * bit0 on the passed in qc_active mask. Move that bit up to match
645 * the internal tag.
646 */
647 if (ap_qc_active & (1ULL << ATA_TAG_INTERNAL)) {
648 qc_active |= (qc_active & 0x01) << ATA_TAG_INTERNAL;
649 qc_active ^= qc_active & 0x01;
650 }
651
652 done_mask = ap_qc_active ^ qc_active;
653
654 if (unlikely(done_mask & qc_active)) {
655 ata_port_err(ap, "illegal qc_active transition (%08llx->%08llx)\n",
656 ap->qc_active, qc_active);
657 return -EINVAL;
658 }
659
93c4aa44
NC		 660 if (ap->ops->qc_ncq_fill_rtf)
661 ap->ops->qc_ncq_fill_rtf(ap, done_mask);
662
61a11986
BZ		 663 while (done_mask) {
664 struct ata_queued_cmd *qc;
665 unsigned int tag = __ffs64(done_mask);
666
667 qc = ata_qc_from_tag(ap, tag);
668 if (qc) {
669 ata_qc_complete(qc);
670 nr_done++;
671 }
672 done_mask &= ~(1ULL << tag);
673 }
674
675 return nr_done;
676}
677EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
678
7fe183c7
BZ		 679/**
680 * ata_slave_link_init - initialize slave link
681 * @ap: port to initialize slave link for
682 *
683 * Create and initialize slave link for @ap. This enables slave
684 * link handling on the port.
685 *
686 * In libata, a port contains links and a link contains devices.
687 * There is single host link but if a PMP is attached to it,
688 * there can be multiple fan-out links. On SATA, there's usually
689 * a single device connected to a link but PATA and SATA
690 * controllers emulating TF based interface can have two - master
691 * and slave.
692 *
693 * However, there are a few controllers which don't fit into this
694 * abstraction too well - SATA controllers which emulate TF
695 * interface with both master and slave devices but also have
696 * separate SCR register sets for each device. These controllers
697 * need separate links for physical link handling
698 * (e.g. onlineness, link speed) but should be treated like a
699 * traditional M/S controller for everything else (e.g. command
700 * issue, softreset).
701 *
702 * slave_link is libata's way of handling this class of
703 * controllers without impacting core layer too much. For
704 * anything other than physical link handling, the default host
705 * link is used for both master and slave. For physical link
706 * handling, separate @ap->slave_link is used. All dirty details
707 * are implemented inside libata core layer. From LLD's POV, the
708 * only difference is that prereset, hardreset and postreset are
709 * called once more for the slave link, so the reset sequence
710 * looks like the following.
711 *
712 * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
713 * softreset(M) -> postreset(M) -> postreset(S)
714 *
715 * Note that softreset is called only for the master. Softreset
716 * resets both M/S by definition, so SRST on master should handle
717 * both (the standard method will work just fine).
718 *
719 * LOCKING:
720 * Should be called before host is registered.
721 *
722 * RETURNS:
723 * 0 on success, -errno on failure.
724 */
725int ata_slave_link_init(struct ata_port *ap)
726{
727 struct ata_link *link;
728
729 WARN_ON(ap->slave_link);
730 WARN_ON(ap->flags & ATA_FLAG_PMP);
731
732 link = kzalloc(sizeof(*link), GFP_KERNEL);
733 if (!link)
734 return -ENOMEM;
735
736 ata_link_init(ap, link, 1);
737 ap->slave_link = link;
738 return 0;
739}
740EXPORT_SYMBOL_GPL(ata_slave_link_init);
741
742/**
743 * sata_lpm_ignore_phy_events - test if PHY event should be ignored
744 * @link: Link receiving the event
745 *
746 * Test whether the received PHY event has to be ignored or not.
747 *
748 * LOCKING:
749 * None:
750 *
751 * RETURNS:
752 * True if the event has to be ignored.
753 */
754bool sata_lpm_ignore_phy_events(struct ata_link *link)
755{
756 unsigned long lpm_timeout = link->last_lpm_change +
757 msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY);
758
759 /* if LPM is enabled, PHYRDY doesn't mean anything */
760 if (link->lpm_policy > ATA_LPM_MAX_POWER)
761 return true;
762
763 /* ignore the first PHY event after the LPM policy changed
764 * as it is might be spurious
765 */
766 if ((link->flags & ATA_LFLAG_CHANGED) &&
767 time_before(jiffies, lpm_timeout))
768 return true;
769
770 return false;
771}
772EXPORT_SYMBOL_GPL(sata_lpm_ignore_phy_events);
ec811a94
BZ		 773
774static const char *ata_lpm_policy_names[] = {
775 [ATA_LPM_UNKNOWN] = "max_performance",
776 [ATA_LPM_MAX_POWER] = "max_performance",
777 [ATA_LPM_MED_POWER] = "medium_power",
778 [ATA_LPM_MED_POWER_WITH_DIPM] = "med_power_with_dipm",
779 [ATA_LPM_MIN_POWER_WITH_PARTIAL] = "min_power_with_partial",
780 [ATA_LPM_MIN_POWER] = "min_power",
781};
782
783static ssize_t ata_scsi_lpm_store(struct device *device,
784 struct device_attribute *attr,
785 const char *buf, size_t count)
786{
787 struct Scsi_Host *shost = class_to_shost(device);
788 struct ata_port *ap = ata_shost_to_port(shost);
789 struct ata_link *link;
790 struct ata_device *dev;
791 enum ata_lpm_policy policy;
792 unsigned long flags;
793
794 /* UNKNOWN is internal state, iterate from MAX_POWER */
795 for (policy = ATA_LPM_MAX_POWER;
796 policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) {
797 const char *name = ata_lpm_policy_names[policy];
798
799 if (strncmp(name, buf, strlen(name)) == 0)
800 break;
801 }
802 if (policy == ARRAY_SIZE(ata_lpm_policy_names))
803 return -EINVAL;
804
805 spin_lock_irqsave(ap->lock, flags);
806
807 ata_for_each_link(link, ap, EDGE) {
808 ata_for_each_dev(dev, &ap->link, ENABLED) {
809 if (dev->horkage & ATA_HORKAGE_NOLPM) {
810 count = -EOPNOTSUPP;
811 goto out_unlock;
812 }
813 }
814 }
815
816 ap->target_lpm_policy = policy;
817 ata_port_schedule_eh(ap);
818out_unlock:
819 spin_unlock_irqrestore(ap->lock, flags);
820 return count;
821}
822
823static ssize_t ata_scsi_lpm_show(struct device *dev,
824 struct device_attribute *attr, char *buf)
825{
826 struct Scsi_Host *shost = class_to_shost(dev);
827 struct ata_port *ap = ata_shost_to_port(shost);
828
829 if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
830 return -EINVAL;
831
06d5d558 832 return sysfs_emit(buf, "%s\n",
ec811a94
BZ		 833 ata_lpm_policy_names[ap->target_lpm_policy]);
834}
835DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
836 ata_scsi_lpm_show, ata_scsi_lpm_store);
837EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
838
5f91b8f5
DLM		 839static ssize_t ata_ncq_prio_supported_show(struct device *device,
840 struct device_attribute *attr,
841 char *buf)
842{
843 struct scsi_device *sdev = to_scsi_device(device);
844 struct ata_port *ap = ata_shost_to_port(sdev->host);
845 struct ata_device *dev;
846 bool ncq_prio_supported;
847 int rc = 0;
848
849 spin_lock_irq(ap->lock);
850 dev = ata_scsi_find_dev(ap, sdev);
851 if (!dev)
852 rc = -ENODEV;
853 else
854 ncq_prio_supported = dev->flags & ATA_DFLAG_NCQ_PRIO;
855 spin_unlock_irq(ap->lock);
856
857 return rc ? rc : sysfs_emit(buf, "%u\n", ncq_prio_supported);
858}
859
860DEVICE_ATTR(ncq_prio_supported, S_IRUGO, ata_ncq_prio_supported_show, NULL);
861EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_supported);
862
ec811a94
BZ		 863static ssize_t ata_ncq_prio_enable_show(struct device *device,
864 struct device_attribute *attr,
865 char *buf)
866{
867 struct scsi_device *sdev = to_scsi_device(device);
2360fa18 868 struct ata_port *ap = ata_shost_to_port(sdev->host);
ec811a94
BZ		 869 struct ata_device *dev;
870 bool ncq_prio_enable;
871 int rc = 0;
872
ec811a94
BZ		 873 spin_lock_irq(ap->lock);
874 dev = ata_scsi_find_dev(ap, sdev);
2360fa18 875 if (!dev)
ec811a94 876 rc = -ENODEV;
2360fa18 877 else
e00923c5 878 ncq_prio_enable = dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED;
ec811a94
BZ		 879 spin_unlock_irq(ap->lock);
880
58c54114 881 return rc ? rc : sysfs_emit(buf, "%u\n", ncq_prio_enable);
ec811a94
BZ		 882}
883
884static ssize_t ata_ncq_prio_enable_store(struct device *device,
885 struct device_attribute *attr,
886 const char *buf, size_t len)
887{
888 struct scsi_device *sdev = to_scsi_device(device);
889 struct ata_port *ap;
890 struct ata_device *dev;
891 long int input;
2360fa18 892 int rc = 0;
ec811a94
BZ		 893
894 rc = kstrtol(buf, 10, &input);
895 if (rc)
896 return rc;
897 if ((input < 0) || (input > 1))
898 return -EINVAL;
899
900 ap = ata_shost_to_port(sdev->host);
901 dev = ata_scsi_find_dev(ap, sdev);
902 if (unlikely(!dev))
903 return -ENODEV;
904
905 spin_lock_irq(ap->lock);
2360fa18
DLM		 906
907 if (!(dev->flags & ATA_DFLAG_NCQ_PRIO)) {
908 rc = -EINVAL;
909 goto unlock;
910 }
911
df60f9c6
DLM		 912 if (input) {
913 if (dev->flags & ATA_DFLAG_CDL_ENABLED) {
914 ata_dev_err(dev,
915 "CDL must be disabled to enable NCQ priority\n");
916 rc = -EINVAL;
917 goto unlock;
918 }
e00923c5 919 dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLED;
df60f9c6 920 } else {
e00923c5 921 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED;
df60f9c6 922 }
ec811a94 923
2360fa18 924unlock:
ec811a94
BZ		 925 spin_unlock_irq(ap->lock);
926
ec811a94
BZ		 927 return rc ? rc : len;
928}
929
930DEVICE_ATTR(ncq_prio_enable, S_IRUGO | S_IWUSR,
931 ata_ncq_prio_enable_show, ata_ncq_prio_enable_store);
932EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_enable);
933
cac7e8b5 934static struct attribute *ata_ncq_sdev_attrs[] = {
c3f69c7f
BVA		 935 &dev_attr_unload_heads.attr,
936 &dev_attr_ncq_prio_enable.attr,
937 &dev_attr_ncq_prio_supported.attr,
ec811a94
BZ		 938 NULL
939};
c3f69c7f
BVA		 940
941static const struct attribute_group ata_ncq_sdev_attr_group = {
942 .attrs = ata_ncq_sdev_attrs
943};
944
945const struct attribute_group *ata_ncq_sdev_groups[] = {
946 &ata_ncq_sdev_attr_group,
947 NULL
948};
949EXPORT_SYMBOL_GPL(ata_ncq_sdev_groups);
ec811a94
BZ		 950
951static ssize_t
952ata_scsi_em_message_store(struct device *dev, struct device_attribute *attr,
953 const char *buf, size_t count)
954{
955 struct Scsi_Host *shost = class_to_shost(dev);
956 struct ata_port *ap = ata_shost_to_port(shost);
957 if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM))
958 return ap->ops->em_store(ap, buf, count);
959 return -EINVAL;
960}
961
962static ssize_t
963ata_scsi_em_message_show(struct device *dev, struct device_attribute *attr,
964 char *buf)
965{
966 struct Scsi_Host *shost = class_to_shost(dev);
967 struct ata_port *ap = ata_shost_to_port(shost);
968
969 if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM))
970 return ap->ops->em_show(ap, buf);
971 return -EINVAL;
972}
973DEVICE_ATTR(em_message, S_IRUGO | S_IWUSR,
974 ata_scsi_em_message_show, ata_scsi_em_message_store);
975EXPORT_SYMBOL_GPL(dev_attr_em_message);
976
977static ssize_t
978ata_scsi_em_message_type_show(struct device *dev, struct device_attribute *attr,
979 char *buf)
980{
981 struct Scsi_Host *shost = class_to_shost(dev);
982 struct ata_port *ap = ata_shost_to_port(shost);
983
58c54114 984 return sysfs_emit(buf, "%d\n", ap->em_message_type);
ec811a94
BZ		 985}
986DEVICE_ATTR(em_message_type, S_IRUGO,
987 ata_scsi_em_message_type_show, NULL);
988EXPORT_SYMBOL_GPL(dev_attr_em_message_type);
989
990static ssize_t
991ata_scsi_activity_show(struct device *dev, struct device_attribute *attr,
992 char *buf)
993{
994 struct scsi_device *sdev = to_scsi_device(dev);
995 struct ata_port *ap = ata_shost_to_port(sdev->host);
996 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
997
998 if (atadev && ap->ops->sw_activity_show &&
999 (ap->flags & ATA_FLAG_SW_ACTIVITY))
1000 return ap->ops->sw_activity_show(atadev, buf);
1001 return -EINVAL;
1002}
1003
1004static ssize_t
1005ata_scsi_activity_store(struct device *dev, struct device_attribute *attr,
1006 const char *buf, size_t count)
1007{
1008 struct scsi_device *sdev = to_scsi_device(dev);
1009 struct ata_port *ap = ata_shost_to_port(sdev->host);
1010 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
1011 enum sw_activity val;
1012 int rc;
1013
1014 if (atadev && ap->ops->sw_activity_store &&
1015 (ap->flags & ATA_FLAG_SW_ACTIVITY)) {
1016 val = simple_strtoul(buf, NULL, 0);
1017 switch (val) {
1018 case OFF: case BLINK_ON: case BLINK_OFF:
1019 rc = ap->ops->sw_activity_store(atadev, val);
1020 if (!rc)
1021 return count;
1022 else
1023 return rc;
1024 }
1025 }
1026 return -EINVAL;
1027}
1028DEVICE_ATTR(sw_activity, S_IWUSR | S_IRUGO, ata_scsi_activity_show,
1029 ata_scsi_activity_store);
1030EXPORT_SYMBOL_GPL(dev_attr_sw_activity);
1031
1032/**
141f3d62
DLM		 1033 * ata_change_queue_depth - Set a device maximum queue depth
1034 * @ap: ATA port of the target device
ec811a94
BZ		 1035 * @sdev: SCSI device to configure queue depth for
1036 * @queue_depth: new queue depth
1037 *
141f3d62
DLM		 1038 * Helper to set a device maximum queue depth, usable with both libsas
1039 * and libata.
ec811a94
BZ		 1040 *
1041 */
371b74c8
DLM		 1042int ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
1043 int queue_depth)
ec811a94 1044{
371b74c8 1045 struct ata_device *dev;
ec811a94 1046 unsigned long flags;
45623d33 1047 int max_queue_depth;
ec811a94 1048
371b74c8 1049 spin_lock_irqsave(ap->lock, flags);
ec811a94 1050
371b74c8
DLM		 1051 dev = ata_scsi_find_dev(ap, sdev);
1052 if (!dev || queue_depth < 1 || queue_depth == sdev->queue_depth) {
1053 spin_unlock_irqrestore(ap->lock, flags);
ec811a94 1054 return sdev->queue_depth;
371b74c8 1055 }
ec811a94 1056
45623d33
DLM		 1057 /*
1058 * Make sure that the queue depth requested does not exceed the device
1059 * capabilities.
1060 */
1061 max_queue_depth = min(ATA_MAX_QUEUE, sdev->host->can_queue);
1062 max_queue_depth = min(max_queue_depth, ata_id_queue_depth(dev->id));
1063 if (queue_depth > max_queue_depth) {
1064 spin_unlock_irqrestore(ap->lock, flags);
1065 return -EINVAL;
1066 }
1067
1068 /*
1069 * If NCQ is not supported by the device or if the target queue depth
1070 * is 1 (to disable drive side command queueing), turn off NCQ.
1071 */
1072 if (queue_depth == 1 || !ata_ncq_supported(dev)) {
ec811a94
BZ		 1073 dev->flags |= ATA_DFLAG_NCQ_OFF;
1074 queue_depth = 1;
45623d33
DLM		 1075 } else {
1076 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
ec811a94 1077 }
371b74c8 1078
ec811a94
BZ		 1079 spin_unlock_irqrestore(ap->lock, flags);
1080
45623d33
DLM		 1081 if (queue_depth == sdev->queue_depth)
1082 return sdev->queue_depth;
ec811a94
BZ		 1083
1084 return scsi_change_queue_depth(sdev, queue_depth);
1085}
141f3d62 1086EXPORT_SYMBOL_GPL(ata_change_queue_depth);
ec811a94
BZ		 1087
1088/**
1089 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
1090 * @sdev: SCSI device to configure queue depth for
1091 * @queue_depth: new queue depth
1092 *
1093 * This is libata standard hostt->change_queue_depth callback.
1094 * SCSI will call into this callback when user tries to set queue
1095 * depth via sysfs.
1096 *
1097 * LOCKING:
1098 * SCSI layer (we don't care)
1099 *
1100 * RETURNS:
1101 * Newly configured queue depth.
1102 */
1103int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
1104{
1105 struct ata_port *ap = ata_shost_to_port(sdev->host);
1106
371b74c8 1107 return ata_change_queue_depth(ap, sdev, queue_depth);
ec811a94
BZ		 1108}
1109EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
15964ff7
BZ		 1110
1111/**
842a5e58 1112 * ata_sas_port_alloc - Allocate port for a SAS attached SATA device
15964ff7
BZ		 1113 * @host: ATA host container for all SAS ports
1114 * @port_info: Information from low-level host driver
1115 * @shost: SCSI host that the scsi device is attached to
1116 *
1117 * LOCKING:
1118 * PCI/etc. bus probe sem.
1119 *
1120 * RETURNS:
1121 * ata_port pointer on success / NULL on failure.
1122 */
1123
1124struct ata_port *ata_sas_port_alloc(struct ata_host *host,
1125 struct ata_port_info *port_info,
1126 struct Scsi_Host *shost)
1127{
1128 struct ata_port *ap;
1129
1130 ap = ata_port_alloc(host);
1131 if (!ap)
1132 return NULL;
1133
1134 ap->port_no = 0;
1135 ap->lock = &host->lock;
1136 ap->pio_mask = port_info->pio_mask;
1137 ap->mwdma_mask = port_info->mwdma_mask;
1138 ap->udma_mask = port_info->udma_mask;
1139 ap->flags |= port_info->flags;
1140 ap->ops = port_info->port_ops;
1141 ap->cbl = ATA_CBL_SATA;
54152817 1142 ap->print_id = atomic_inc_return(&ata_print_id);
15964ff7
BZ		 1143
1144 return ap;
1145}
1146EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
1147
15964ff7
BZ		 1148int ata_sas_tport_add(struct device *parent, struct ata_port *ap)
1149{
1150 return ata_tport_add(parent, ap);
1151}
1152EXPORT_SYMBOL_GPL(ata_sas_tport_add);
1153
1154void ata_sas_tport_delete(struct ata_port *ap)
1155{
1156 ata_tport_delete(ap);
1157}
1158EXPORT_SYMBOL_GPL(ata_sas_tport_delete);
1159
15964ff7
BZ		 1160/**
1161 * ata_sas_slave_configure - Default slave_config routine for libata devices
1162 * @sdev: SCSI device to configure
1163 * @ap: ATA port to which SCSI device is attached
1164 *
1165 * RETURNS:
1166 * Zero.
1167 */
1168
1169int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
1170{
1171 ata_scsi_sdev_config(sdev);
1172 ata_scsi_dev_config(sdev, ap->link.device);
1173 return 0;
1174}
1175EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
1176
1177/**
1178 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
1179 * @cmd: SCSI command to be sent
1180 * @ap: ATA port to which the command is being sent
1181 *
1182 * RETURNS:
1183 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
1184 * 0 otherwise.
1185 */
1186
1187int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap)
1188{
1189 int rc = 0;
1190
15964ff7
BZ		 1191 if (likely(ata_dev_enabled(ap->link.device)))
1192 rc = __ata_scsi_queuecmd(cmd, ap->link.device);
1193 else {
1194 cmd->result = (DID_BAD_TARGET << 16);
58bf201d 1195 scsi_done(cmd);
15964ff7
BZ		 1196 }
1197 return rc;
1198}
1199EXPORT_SYMBOL_GPL(ata_sas_queuecmd);
1200
a695de27
BZ		 1201/**
1202 * sata_async_notification - SATA async notification handler
1203 * @ap: ATA port where async notification is received
1204 *
1205 * Handler to be called when async notification via SDB FIS is
1206 * received. This function schedules EH if necessary.
1207 *
1208 * LOCKING:
1209 * spin_lock_irqsave(host lock)
1210 *
1211 * RETURNS:
1212 * 1 if EH is scheduled, 0 otherwise.
1213 */
1214int sata_async_notification(struct ata_port *ap)
1215{
1216 u32 sntf;
1217 int rc;
1218
1219 if (!(ap->flags & ATA_FLAG_AN))
1220 return 0;
1221
1222 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1223 if (rc == 0)
1224 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1225
1226 if (!sata_pmp_attached(ap) || rc) {
1227 /* PMP is not attached or SNTF is not available */
1228 if (!sata_pmp_attached(ap)) {
1229 /* PMP is not attached. Check whether ATAPI
1230 * AN is configured. If so, notify media
1231 * change.
1232 */
1233 struct ata_device *dev = ap->link.device;
1234
1235 if ((dev->class == ATA_DEV_ATAPI) &&
1236 (dev->flags & ATA_DFLAG_AN))
1237 ata_scsi_media_change_notify(dev);
1238 return 0;
1239 } else {
1240 /* PMP is attached but SNTF is not available.
1241 * ATAPI async media change notification is
1242 * not used. The PMP must be reporting PHY
1243 * status change, schedule EH.
1244 */
1245 ata_port_schedule_eh(ap);
1246 return 1;
1247 }
1248 } else {
1249 /* PMP is attached and SNTF is available */
1250 struct ata_link *link;
1251
1252 /* check and notify ATAPI AN */
1253 ata_for_each_link(link, ap, EDGE) {
1254 if (!(sntf & (1 << link->pmp)))
1255 continue;
1256
1257 if ((link->device->class == ATA_DEV_ATAPI) &&
1258 (link->device->flags & ATA_DFLAG_AN))
1259 ata_scsi_media_change_notify(link->device);
1260 }
1261
1262 /* If PMP is reporting that PHY status of some
1263 * downstream ports has changed, schedule EH.
1264 */
1265 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1266 ata_port_schedule_eh(ap);
1267 return 1;
1268 }
1269
1270 return 0;
1271 }
1272}
1273EXPORT_SYMBOL_GPL(sata_async_notification);
a0ccd251
BZ		 1274
1275/**
1276 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1277 * @dev: Device to read log page 10h from
1278 * @tag: Resulting tag of the failed command
1279 * @tf: Resulting taskfile registers of the failed command
1280 *
1281 * Read log page 10h to obtain NCQ error details and clear error
1282 * condition.
1283 *
1284 * LOCKING:
1285 * Kernel thread context (may sleep).
1286 *
1287 * RETURNS:
1288 * 0 on success, -errno otherwise.
1289 */
1290static int ata_eh_read_log_10h(struct ata_device *dev,
1291 int *tag, struct ata_taskfile *tf)
1292{
1293 u8 *buf = dev->link->ap->sector_buf;
1294 unsigned int err_mask;
1295 u8 csum;
1296 int i;
1297
1298 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1);
1299 if (err_mask)
1300 return -EIO;
1301
1302 csum = 0;
1303 for (i = 0; i < ATA_SECT_SIZE; i++)
1304 csum += buf[i];
1305 if (csum)
1306 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1307 csum);
1308
1309 if (buf[0] & 0x80)
1310 return -ENOENT;
1311
1312 *tag = buf[0] & 0x1f;
1313
efcef265
SS		 1314 tf->status = buf[2];
1315 tf->error = buf[3];
a0ccd251
BZ		 1316 tf->lbal = buf[4];
1317 tf->lbam = buf[5];
1318 tf->lbah = buf[6];
1319 tf->device = buf[7];
1320 tf->hob_lbal = buf[8];
1321 tf->hob_lbam = buf[9];
1322 tf->hob_lbah = buf[10];
1323 tf->nsect = buf[12];
1324 tf->hob_nsect = buf[13];
013115d9 1325 if (ata_id_has_ncq_autosense(dev->id) && (tf->status & ATA_SENSE))
a0ccd251
BZ		 1326 tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
1327
1328 return 0;
1329}
1330
18bd7718
NC		 1331/**
1332 * ata_eh_read_sense_success_ncq_log - Read the sense data for successful
1333 * NCQ commands log
1334 * @link: ATA link to get sense data for
1335 *
1336 * Read the sense data for successful NCQ commands log page to obtain
1337 * sense data for all NCQ commands that completed successfully with
1338 * the sense data available bit set.
1339 *
1340 * LOCKING:
1341 * Kernel thread context (may sleep).
1342 *
1343 * RETURNS:
1344 * 0 on success, -errno otherwise.
1345 */
1346int ata_eh_read_sense_success_ncq_log(struct ata_link *link)
1347{
1348 struct ata_device *dev = link->device;
1349 struct ata_port *ap = dev->link->ap;
1350 u8 *buf = ap->ncq_sense_buf;
1351 struct ata_queued_cmd *qc;
1352 unsigned int err_mask, tag;
1353 u8 *sense, sk = 0, asc = 0, ascq = 0;
1354 u64 sense_valid, val;
1355 int ret = 0;
1356
1357 err_mask = ata_read_log_page(dev, ATA_LOG_SENSE_NCQ, 0, buf, 2);
1358 if (err_mask) {
1359 ata_dev_err(dev,
1360 "Failed to read Sense Data for Successful NCQ Commands log\n");
1361 return -EIO;
1362 }
1363
1364 /* Check the log header */
1365 val = get_unaligned_le64(&buf[0]);
1366 if ((val & 0xffff) != 1 || ((val >> 16) & 0xff) != 0x0f) {
1367 ata_dev_err(dev,
1368 "Invalid Sense Data for Successful NCQ Commands log\n");
1369 return -EIO;
1370 }
1371
1372 sense_valid = (u64)buf[8] | ((u64)buf[9] << 8) |
1373 ((u64)buf[10] << 16) | ((u64)buf[11] << 24);
1374
1375 ata_qc_for_each_raw(ap, qc, tag) {
1376 if (!(qc->flags & ATA_QCFLAG_EH) ||
1377 !(qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) ||
1378 qc->err_mask ||
1379 ata_dev_phys_link(qc->dev) != link)
1380 continue;
1381
1382 /*
1383 * If the command does not have any sense data, clear ATA_SENSE.
1384 * Keep ATA_QCFLAG_EH_SUCCESS_CMD so that command is finished.
1385 */
1386 if (!(sense_valid & (1ULL << tag))) {
1387 qc->result_tf.status &= ~ATA_SENSE;
1388 continue;
1389 }
1390
1391 sense = &buf[32 + 24 * tag];
1392 sk = sense[0];
1393 asc = sense[1];
1394 ascq = sense[2];
1395
1396 if (!ata_scsi_sense_is_valid(sk, asc, ascq)) {
1397 ret = -EIO;
1398 continue;
1399 }
1400
1401 /* Set sense without also setting scsicmd->result */
1402 scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
1403 qc->scsicmd->sense_buffer, sk,
1404 asc, ascq);
1405 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1406
1407 /*
1408 * If we have sense data, call scsi_check_sense() in order to
1409 * set the correct SCSI ML byte (if any). No point in checking
1410 * the return value, since the command has already completed
1411 * successfully.
1412 */
1413 scsi_check_sense(qc->scsicmd);
1414 }
1415
1416 return ret;
1417}
1418EXPORT_SYMBOL_GPL(ata_eh_read_sense_success_ncq_log);
1419
a0ccd251
BZ		 1420/**
1421 * ata_eh_analyze_ncq_error - analyze NCQ error
1422 * @link: ATA link to analyze NCQ error for
1423 *
1424 * Read log page 10h, determine the offending qc and acquire
1425 * error status TF. For NCQ device errors, all LLDDs have to do
1426 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1427 * care of the rest.
1428 *
1429 * LOCKING:
1430 * Kernel thread context (may sleep).
1431 */
1432void ata_eh_analyze_ncq_error(struct ata_link *link)
1433{
1434 struct ata_port *ap = link->ap;
1435 struct ata_eh_context *ehc = &link->eh_context;
1436 struct ata_device *dev = link->device;
1437 struct ata_queued_cmd *qc;
1438 struct ata_taskfile tf;
1439 int tag, rc;
1440
1441 /* if frozen, we can't do much */
4cb7c6f1 1442 if (ata_port_is_frozen(ap))
a0ccd251
BZ		 1443 return;
1444
1445 /* is it NCQ device error? */
1446 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1447 return;
1448
1449 /* has LLDD analyzed already? */
1450 ata_qc_for_each_raw(ap, qc, tag) {
87629312 1451 if (!(qc->flags & ATA_QCFLAG_EH))
a0ccd251
BZ		 1452 continue;
1453
1454 if (qc->err_mask)
1455 return;
1456 }
1457
1458 /* okay, this error is ours */
1459 memset(&tf, 0, sizeof(tf));
1460 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1461 if (rc) {
1462 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1463 rc);
1464 return;
1465 }
1466
1467 if (!(link->sactive & (1 << tag))) {
1468 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1469 tag);
1470 return;
1471 }
1472
1473 /* we've got the perpetrator, condemn it */
1474 qc = __ata_qc_from_tag(ap, tag);
1475 memcpy(&qc->result_tf, &tf, sizeof(tf));
1476 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1477 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
7390896b
NC		 1478
1479 /*
1480 * If the device supports NCQ autosense, ata_eh_read_log_10h() will have
1481 * stored the sense data in qc->result_tf.auxiliary.
1482 */
1483 if (qc->result_tf.auxiliary) {
a0ccd251
BZ		 1484 char sense_key, asc, ascq;
1485
1486 sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
1487 asc = (qc->result_tf.auxiliary >> 8) & 0xff;
1488 ascq = qc->result_tf.auxiliary & 0xff;
4b89ad8e
NC		 1489 if (ata_scsi_sense_is_valid(sense_key, asc, ascq)) {
1490 ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc,
1491 ascq);
1492 ata_scsi_set_sense_information(dev, qc->scsicmd,
1493 &qc->result_tf);
1494 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1495 }
a0ccd251
BZ		 1496 }
1497
3d8a3ae3 1498 ata_qc_for_each_raw(ap, qc, tag) {
87629312 1499 if (!(qc->flags & ATA_QCFLAG_EH) ||
18bd7718 1500 qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD ||
3d8a3ae3
NC		 1501 ata_dev_phys_link(qc->dev) != link)
1502 continue;
1503
1504 /* Skip the single QC which caused the NCQ error. */
1505 if (qc->err_mask)
1506 continue;
1507
1508 /*
1509 * For SATA, the STATUS and ERROR fields are shared for all NCQ
1510 * commands that were completed with the same SDB FIS.
1511 * Therefore, we have to clear the ATA_ERR bit for all QCs
1512 * except the one that caused the NCQ error.
1513 */
1514 qc->result_tf.status &= ~ATA_ERR;
1515 qc->result_tf.error = 0;
1516
1517 /*
1518 * If we get a NCQ error, that means that a single command was
1519 * aborted. All other failed commands for our link should be
1520 * retried and has no business of going though further scrutiny
1521 * by ata_eh_link_autopsy().
1522 */
1523 qc->flags |= ATA_QCFLAG_RETRY;
1524 }
1525
a0ccd251
BZ		 1526 ehc->i.err_mask &= ~AC_ERR_DEV;
1527}
1528EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error);
Linux 6.x block layer and io_uring tree(s)