Commit | Line | Data |
---|---|---|
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> |
7fe183c7 BZ |
14 | #include <linux/libata.h> |
15 | ||
16 | #include "libata.h" | |
15964ff7 | 17 | #include "libata-transport.h" |
7fe183c7 | 18 | |
2b384ede BZ |
19 | /* debounce timing parameters in msecs { interval, duration, timeout } */ |
20 | const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 }; | |
21 | EXPORT_SYMBOL_GPL(sata_deb_timing_normal); | |
22 | const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 }; | |
23 | EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug); | |
24 | const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 }; | |
25 | EXPORT_SYMBOL_GPL(sata_deb_timing_long); | |
26 | ||
6eab1bc0 BZ |
27 | /** |
28 | * sata_scr_valid - test whether SCRs are accessible | |
29 | * @link: ATA link to test SCR accessibility for | |
30 | * | |
31 | * Test whether SCRs are accessible for @link. | |
32 | * | |
33 | * LOCKING: | |
34 | * None. | |
35 | * | |
36 | * RETURNS: | |
37 | * 1 if SCRs are accessible, 0 otherwise. | |
38 | */ | |
39 | int sata_scr_valid(struct ata_link *link) | |
40 | { | |
41 | struct ata_port *ap = link->ap; | |
42 | ||
43 | return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read; | |
44 | } | |
45 | EXPORT_SYMBOL_GPL(sata_scr_valid); | |
46 | ||
47 | /** | |
48 | * sata_scr_read - read SCR register of the specified port | |
49 | * @link: ATA link to read SCR for | |
50 | * @reg: SCR to read | |
51 | * @val: Place to store read value | |
52 | * | |
53 | * Read SCR register @reg of @link into *@val. This function is | |
54 | * guaranteed to succeed if @link is ap->link, the cable type of | |
55 | * the port is SATA and the port implements ->scr_read. | |
56 | * | |
57 | * LOCKING: | |
58 | * None if @link is ap->link. Kernel thread context otherwise. | |
59 | * | |
60 | * RETURNS: | |
61 | * 0 on success, negative errno on failure. | |
62 | */ | |
63 | int sata_scr_read(struct ata_link *link, int reg, u32 *val) | |
64 | { | |
65 | if (ata_is_host_link(link)) { | |
66 | if (sata_scr_valid(link)) | |
67 | return link->ap->ops->scr_read(link, reg, val); | |
68 | return -EOPNOTSUPP; | |
69 | } | |
70 | ||
71 | return sata_pmp_scr_read(link, reg, val); | |
72 | } | |
73 | EXPORT_SYMBOL_GPL(sata_scr_read); | |
74 | ||
75 | /** | |
76 | * sata_scr_write - write SCR register of the specified port | |
77 | * @link: ATA link to write SCR for | |
78 | * @reg: SCR to write | |
79 | * @val: value to write | |
80 | * | |
81 | * Write @val to SCR register @reg of @link. This function is | |
82 | * guaranteed to succeed if @link is ap->link, the cable type of | |
83 | * the port is SATA and the port implements ->scr_read. | |
84 | * | |
85 | * LOCKING: | |
86 | * None if @link is ap->link. Kernel thread context otherwise. | |
87 | * | |
88 | * RETURNS: | |
89 | * 0 on success, negative errno on failure. | |
90 | */ | |
91 | int sata_scr_write(struct ata_link *link, int reg, u32 val) | |
92 | { | |
93 | if (ata_is_host_link(link)) { | |
94 | if (sata_scr_valid(link)) | |
95 | return link->ap->ops->scr_write(link, reg, val); | |
96 | return -EOPNOTSUPP; | |
97 | } | |
98 | ||
99 | return sata_pmp_scr_write(link, reg, val); | |
100 | } | |
101 | EXPORT_SYMBOL_GPL(sata_scr_write); | |
102 | ||
103 | /** | |
104 | * sata_scr_write_flush - write SCR register of the specified port and flush | |
105 | * @link: ATA link to write SCR for | |
106 | * @reg: SCR to write | |
107 | * @val: value to write | |
108 | * | |
109 | * This function is identical to sata_scr_write() except that this | |
110 | * function performs flush after writing to the register. | |
111 | * | |
112 | * LOCKING: | |
113 | * None if @link is ap->link. Kernel thread context otherwise. | |
114 | * | |
115 | * RETURNS: | |
116 | * 0 on success, negative errno on failure. | |
117 | */ | |
118 | int sata_scr_write_flush(struct ata_link *link, int reg, u32 val) | |
119 | { | |
120 | if (ata_is_host_link(link)) { | |
121 | int rc; | |
122 | ||
123 | if (sata_scr_valid(link)) { | |
124 | rc = link->ap->ops->scr_write(link, reg, val); | |
125 | if (rc == 0) | |
126 | rc = link->ap->ops->scr_read(link, reg, &val); | |
127 | return rc; | |
128 | } | |
129 | return -EOPNOTSUPP; | |
130 | } | |
131 | ||
132 | return sata_pmp_scr_write(link, reg, val); | |
133 | } | |
134 | EXPORT_SYMBOL_GPL(sata_scr_write_flush); | |
135 | ||
7fe183c7 BZ |
136 | /** |
137 | * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure | |
138 | * @tf: Taskfile to convert | |
139 | * @pmp: Port multiplier port | |
140 | * @is_cmd: This FIS is for command | |
141 | * @fis: Buffer into which data will output | |
142 | * | |
143 | * Converts a standard ATA taskfile to a Serial ATA | |
144 | * FIS structure (Register - Host to Device). | |
145 | * | |
146 | * LOCKING: | |
147 | * Inherited from caller. | |
148 | */ | |
149 | void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis) | |
150 | { | |
151 | fis[0] = 0x27; /* Register - Host to Device FIS */ | |
152 | fis[1] = pmp & 0xf; /* Port multiplier number*/ | |
153 | if (is_cmd) | |
154 | fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */ | |
155 | ||
156 | fis[2] = tf->command; | |
157 | fis[3] = tf->feature; | |
158 | ||
159 | fis[4] = tf->lbal; | |
160 | fis[5] = tf->lbam; | |
161 | fis[6] = tf->lbah; | |
162 | fis[7] = tf->device; | |
163 | ||
164 | fis[8] = tf->hob_lbal; | |
165 | fis[9] = tf->hob_lbam; | |
166 | fis[10] = tf->hob_lbah; | |
167 | fis[11] = tf->hob_feature; | |
168 | ||
169 | fis[12] = tf->nsect; | |
170 | fis[13] = tf->hob_nsect; | |
171 | fis[14] = 0; | |
172 | fis[15] = tf->ctl; | |
173 | ||
174 | fis[16] = tf->auxiliary & 0xff; | |
175 | fis[17] = (tf->auxiliary >> 8) & 0xff; | |
176 | fis[18] = (tf->auxiliary >> 16) & 0xff; | |
177 | fis[19] = (tf->auxiliary >> 24) & 0xff; | |
178 | } | |
179 | EXPORT_SYMBOL_GPL(ata_tf_to_fis); | |
180 | ||
181 | /** | |
182 | * ata_tf_from_fis - Convert SATA FIS to ATA taskfile | |
183 | * @fis: Buffer from which data will be input | |
184 | * @tf: Taskfile to output | |
185 | * | |
186 | * Converts a serial ATA FIS structure to a standard ATA taskfile. | |
187 | * | |
188 | * LOCKING: | |
189 | * Inherited from caller. | |
190 | */ | |
191 | ||
192 | void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf) | |
193 | { | |
194 | tf->command = fis[2]; /* status */ | |
195 | tf->feature = fis[3]; /* error */ | |
196 | ||
197 | tf->lbal = fis[4]; | |
198 | tf->lbam = fis[5]; | |
199 | tf->lbah = fis[6]; | |
200 | tf->device = fis[7]; | |
201 | ||
202 | tf->hob_lbal = fis[8]; | |
203 | tf->hob_lbam = fis[9]; | |
204 | tf->hob_lbah = fis[10]; | |
205 | ||
206 | tf->nsect = fis[12]; | |
207 | tf->hob_nsect = fis[13]; | |
208 | } | |
209 | EXPORT_SYMBOL_GPL(ata_tf_from_fis); | |
210 | ||
9d3158f5 BZ |
211 | /** |
212 | * sata_link_debounce - debounce SATA phy status | |
213 | * @link: ATA link to debounce SATA phy status for | |
214 | * @params: timing parameters { interval, duration, timeout } in msec | |
215 | * @deadline: deadline jiffies for the operation | |
216 | * | |
217 | * Make sure SStatus of @link reaches stable state, determined by | |
218 | * holding the same value where DET is not 1 for @duration polled | |
219 | * every @interval, before @timeout. Timeout constraints the | |
220 | * beginning of the stable state. Because DET gets stuck at 1 on | |
221 | * some controllers after hot unplugging, this functions waits | |
222 | * until timeout then returns 0 if DET is stable at 1. | |
223 | * | |
224 | * @timeout is further limited by @deadline. The sooner of the | |
225 | * two is used. | |
226 | * | |
227 | * LOCKING: | |
228 | * Kernel thread context (may sleep) | |
229 | * | |
230 | * RETURNS: | |
231 | * 0 on success, -errno on failure. | |
232 | */ | |
233 | int sata_link_debounce(struct ata_link *link, const unsigned long *params, | |
234 | unsigned long deadline) | |
235 | { | |
236 | unsigned long interval = params[0]; | |
237 | unsigned long duration = params[1]; | |
238 | unsigned long last_jiffies, t; | |
239 | u32 last, cur; | |
240 | int rc; | |
241 | ||
242 | t = ata_deadline(jiffies, params[2]); | |
243 | if (time_before(t, deadline)) | |
244 | deadline = t; | |
245 | ||
246 | if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) | |
247 | return rc; | |
248 | cur &= 0xf; | |
249 | ||
250 | last = cur; | |
251 | last_jiffies = jiffies; | |
252 | ||
253 | while (1) { | |
254 | ata_msleep(link->ap, interval); | |
255 | if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) | |
256 | return rc; | |
257 | cur &= 0xf; | |
258 | ||
259 | /* DET stable? */ | |
260 | if (cur == last) { | |
261 | if (cur == 1 && time_before(jiffies, deadline)) | |
262 | continue; | |
263 | if (time_after(jiffies, | |
264 | ata_deadline(last_jiffies, duration))) | |
265 | return 0; | |
266 | continue; | |
267 | } | |
268 | ||
269 | /* unstable, start over */ | |
270 | last = cur; | |
271 | last_jiffies = jiffies; | |
272 | ||
273 | /* Check deadline. If debouncing failed, return | |
274 | * -EPIPE to tell upper layer to lower link speed. | |
275 | */ | |
276 | if (time_after(jiffies, deadline)) | |
277 | return -EPIPE; | |
278 | } | |
279 | } | |
280 | EXPORT_SYMBOL_GPL(sata_link_debounce); | |
281 | ||
282 | /** | |
283 | * sata_link_resume - resume SATA link | |
284 | * @link: ATA link to resume SATA | |
285 | * @params: timing parameters { interval, duration, timeout } in msec | |
286 | * @deadline: deadline jiffies for the operation | |
287 | * | |
288 | * Resume SATA phy @link and debounce it. | |
289 | * | |
290 | * LOCKING: | |
291 | * Kernel thread context (may sleep) | |
292 | * | |
293 | * RETURNS: | |
294 | * 0 on success, -errno on failure. | |
295 | */ | |
296 | int sata_link_resume(struct ata_link *link, const unsigned long *params, | |
297 | unsigned long deadline) | |
298 | { | |
299 | int tries = ATA_LINK_RESUME_TRIES; | |
300 | u32 scontrol, serror; | |
301 | int rc; | |
302 | ||
303 | if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) | |
304 | return rc; | |
305 | ||
306 | /* | |
307 | * Writes to SControl sometimes get ignored under certain | |
308 | * controllers (ata_piix SIDPR). Make sure DET actually is | |
309 | * cleared. | |
310 | */ | |
311 | do { | |
312 | scontrol = (scontrol & 0x0f0) | 0x300; | |
313 | if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) | |
314 | return rc; | |
315 | /* | |
316 | * Some PHYs react badly if SStatus is pounded | |
317 | * immediately after resuming. Delay 200ms before | |
318 | * debouncing. | |
319 | */ | |
320 | if (!(link->flags & ATA_LFLAG_NO_DB_DELAY)) | |
321 | ata_msleep(link->ap, 200); | |
322 | ||
323 | /* is SControl restored correctly? */ | |
324 | if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) | |
325 | return rc; | |
326 | } while ((scontrol & 0xf0f) != 0x300 && --tries); | |
327 | ||
328 | if ((scontrol & 0xf0f) != 0x300) { | |
329 | ata_link_warn(link, "failed to resume link (SControl %X)\n", | |
330 | scontrol); | |
331 | return 0; | |
332 | } | |
333 | ||
334 | if (tries < ATA_LINK_RESUME_TRIES) | |
335 | ata_link_warn(link, "link resume succeeded after %d retries\n", | |
336 | ATA_LINK_RESUME_TRIES - tries); | |
337 | ||
338 | if ((rc = sata_link_debounce(link, params, deadline))) | |
339 | return rc; | |
340 | ||
341 | /* clear SError, some PHYs require this even for SRST to work */ | |
342 | if (!(rc = sata_scr_read(link, SCR_ERROR, &serror))) | |
343 | rc = sata_scr_write(link, SCR_ERROR, serror); | |
344 | ||
345 | return rc != -EINVAL ? rc : 0; | |
346 | } | |
347 | EXPORT_SYMBOL_GPL(sata_link_resume); | |
348 | ||
7fe183c7 BZ |
349 | /** |
350 | * sata_link_scr_lpm - manipulate SControl IPM and SPM fields | |
351 | * @link: ATA link to manipulate SControl for | |
352 | * @policy: LPM policy to configure | |
353 | * @spm_wakeup: initiate LPM transition to active state | |
354 | * | |
355 | * Manipulate the IPM field of the SControl register of @link | |
356 | * according to @policy. If @policy is ATA_LPM_MAX_POWER and | |
357 | * @spm_wakeup is %true, the SPM field is manipulated to wake up | |
358 | * the link. This function also clears PHYRDY_CHG before | |
359 | * returning. | |
360 | * | |
361 | * LOCKING: | |
362 | * EH context. | |
363 | * | |
364 | * RETURNS: | |
365 | * 0 on success, -errno otherwise. | |
366 | */ | |
367 | int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy, | |
368 | bool spm_wakeup) | |
369 | { | |
370 | struct ata_eh_context *ehc = &link->eh_context; | |
371 | bool woken_up = false; | |
372 | u32 scontrol; | |
373 | int rc; | |
374 | ||
375 | rc = sata_scr_read(link, SCR_CONTROL, &scontrol); | |
376 | if (rc) | |
377 | return rc; | |
378 | ||
379 | switch (policy) { | |
380 | case ATA_LPM_MAX_POWER: | |
381 | /* disable all LPM transitions */ | |
382 | scontrol |= (0x7 << 8); | |
383 | /* initiate transition to active state */ | |
384 | if (spm_wakeup) { | |
385 | scontrol |= (0x4 << 12); | |
386 | woken_up = true; | |
387 | } | |
388 | break; | |
389 | case ATA_LPM_MED_POWER: | |
390 | /* allow LPM to PARTIAL */ | |
391 | scontrol &= ~(0x1 << 8); | |
392 | scontrol |= (0x6 << 8); | |
393 | break; | |
394 | case ATA_LPM_MED_POWER_WITH_DIPM: | |
395 | case ATA_LPM_MIN_POWER_WITH_PARTIAL: | |
396 | case ATA_LPM_MIN_POWER: | |
397 | if (ata_link_nr_enabled(link) > 0) | |
398 | /* no restrictions on LPM transitions */ | |
399 | scontrol &= ~(0x7 << 8); | |
400 | else { | |
401 | /* empty port, power off */ | |
402 | scontrol &= ~0xf; | |
403 | scontrol |= (0x1 << 2); | |
404 | } | |
405 | break; | |
406 | default: | |
407 | WARN_ON(1); | |
408 | } | |
409 | ||
410 | rc = sata_scr_write(link, SCR_CONTROL, scontrol); | |
411 | if (rc) | |
412 | return rc; | |
413 | ||
414 | /* give the link time to transit out of LPM state */ | |
415 | if (woken_up) | |
416 | msleep(10); | |
417 | ||
418 | /* clear PHYRDY_CHG from SError */ | |
419 | ehc->i.serror &= ~SERR_PHYRDY_CHG; | |
420 | return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG); | |
421 | } | |
422 | EXPORT_SYMBOL_GPL(sata_link_scr_lpm); | |
423 | ||
ab4117cf BZ |
424 | static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol) |
425 | { | |
426 | struct ata_link *host_link = &link->ap->link; | |
427 | u32 limit, target, spd; | |
428 | ||
429 | limit = link->sata_spd_limit; | |
430 | ||
431 | /* Don't configure downstream link faster than upstream link. | |
432 | * It doesn't speed up anything and some PMPs choke on such | |
433 | * configuration. | |
434 | */ | |
435 | if (!ata_is_host_link(link) && host_link->sata_spd) | |
436 | limit &= (1 << host_link->sata_spd) - 1; | |
437 | ||
438 | if (limit == UINT_MAX) | |
439 | target = 0; | |
440 | else | |
441 | target = fls(limit); | |
442 | ||
443 | spd = (*scontrol >> 4) & 0xf; | |
444 | *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4); | |
445 | ||
446 | return spd != target; | |
447 | } | |
448 | ||
449 | /** | |
450 | * sata_set_spd_needed - is SATA spd configuration needed | |
451 | * @link: Link in question | |
452 | * | |
453 | * Test whether the spd limit in SControl matches | |
454 | * @link->sata_spd_limit. This function is used to determine | |
455 | * whether hardreset is necessary to apply SATA spd | |
456 | * configuration. | |
457 | * | |
458 | * LOCKING: | |
459 | * Inherited from caller. | |
460 | * | |
461 | * RETURNS: | |
462 | * 1 if SATA spd configuration is needed, 0 otherwise. | |
463 | */ | |
78c97c80 | 464 | static int sata_set_spd_needed(struct ata_link *link) |
ab4117cf BZ |
465 | { |
466 | u32 scontrol; | |
467 | ||
468 | if (sata_scr_read(link, SCR_CONTROL, &scontrol)) | |
469 | return 1; | |
470 | ||
471 | return __sata_set_spd_needed(link, &scontrol); | |
472 | } | |
473 | ||
474 | /** | |
475 | * sata_set_spd - set SATA spd according to spd limit | |
476 | * @link: Link to set SATA spd for | |
477 | * | |
478 | * Set SATA spd of @link according to sata_spd_limit. | |
479 | * | |
480 | * LOCKING: | |
481 | * Inherited from caller. | |
482 | * | |
483 | * RETURNS: | |
484 | * 0 if spd doesn't need to be changed, 1 if spd has been | |
485 | * changed. Negative errno if SCR registers are inaccessible. | |
486 | */ | |
487 | int sata_set_spd(struct ata_link *link) | |
488 | { | |
489 | u32 scontrol; | |
490 | int rc; | |
491 | ||
492 | if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol))) | |
493 | return rc; | |
494 | ||
495 | if (!__sata_set_spd_needed(link, &scontrol)) | |
496 | return 0; | |
497 | ||
498 | if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol))) | |
499 | return rc; | |
500 | ||
501 | return 1; | |
502 | } | |
503 | EXPORT_SYMBOL_GPL(sata_set_spd); | |
504 | ||
78c97c80 BZ |
505 | /** |
506 | * sata_link_hardreset - reset link via SATA phy reset | |
507 | * @link: link to reset | |
508 | * @timing: timing parameters { interval, duration, timeout } in msec | |
509 | * @deadline: deadline jiffies for the operation | |
510 | * @online: optional out parameter indicating link onlineness | |
511 | * @check_ready: optional callback to check link readiness | |
512 | * | |
513 | * SATA phy-reset @link using DET bits of SControl register. | |
514 | * After hardreset, link readiness is waited upon using | |
515 | * ata_wait_ready() if @check_ready is specified. LLDs are | |
516 | * allowed to not specify @check_ready and wait itself after this | |
517 | * function returns. Device classification is LLD's | |
518 | * responsibility. | |
519 | * | |
520 | * *@online is set to one iff reset succeeded and @link is online | |
521 | * after reset. | |
522 | * | |
523 | * LOCKING: | |
524 | * Kernel thread context (may sleep) | |
525 | * | |
526 | * RETURNS: | |
527 | * 0 on success, -errno otherwise. | |
528 | */ | |
529 | int sata_link_hardreset(struct ata_link *link, const unsigned long *timing, | |
530 | unsigned long deadline, | |
531 | bool *online, int (*check_ready)(struct ata_link *)) | |
532 | { | |
533 | u32 scontrol; | |
534 | int rc; | |
535 | ||
536 | DPRINTK("ENTER\n"); | |
537 | ||
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 | } | |
613 | DPRINTK("EXIT, rc=%d\n", rc); | |
614 | return rc; | |
615 | } | |
616 | EXPORT_SYMBOL_GPL(sata_link_hardreset); | |
617 | ||
61a11986 BZ |
618 | /** |
619 | * ata_qc_complete_multiple - Complete multiple qcs successfully | |
620 | * @ap: port in question | |
621 | * @qc_active: new qc_active mask | |
622 | * | |
623 | * Complete in-flight commands. This functions is meant to be | |
624 | * called from low-level driver's interrupt routine to complete | |
625 | * requests normally. ap->qc_active and @qc_active is compared | |
626 | * and commands are completed accordingly. | |
627 | * | |
628 | * Always use this function when completing multiple NCQ commands | |
629 | * from IRQ handlers instead of calling ata_qc_complete() | |
630 | * multiple times to keep IRQ expect status properly in sync. | |
631 | * | |
632 | * LOCKING: | |
633 | * spin_lock_irqsave(host lock) | |
634 | * | |
635 | * RETURNS: | |
636 | * Number of completed commands on success, -errno otherwise. | |
637 | */ | |
638 | int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active) | |
639 | { | |
640 | u64 done_mask, ap_qc_active = ap->qc_active; | |
641 | int nr_done = 0; | |
642 | ||
643 | /* | |
644 | * If the internal tag is set on ap->qc_active, then we care about | |
645 | * bit0 on the passed in qc_active mask. Move that bit up to match | |
646 | * the internal tag. | |
647 | */ | |
648 | if (ap_qc_active & (1ULL << ATA_TAG_INTERNAL)) { | |
649 | qc_active |= (qc_active & 0x01) << ATA_TAG_INTERNAL; | |
650 | qc_active ^= qc_active & 0x01; | |
651 | } | |
652 | ||
653 | done_mask = ap_qc_active ^ qc_active; | |
654 | ||
655 | if (unlikely(done_mask & qc_active)) { | |
656 | ata_port_err(ap, "illegal qc_active transition (%08llx->%08llx)\n", | |
657 | ap->qc_active, qc_active); | |
658 | return -EINVAL; | |
659 | } | |
660 | ||
661 | while (done_mask) { | |
662 | struct ata_queued_cmd *qc; | |
663 | unsigned int tag = __ffs64(done_mask); | |
664 | ||
665 | qc = ata_qc_from_tag(ap, tag); | |
666 | if (qc) { | |
667 | ata_qc_complete(qc); | |
668 | nr_done++; | |
669 | } | |
670 | done_mask &= ~(1ULL << tag); | |
671 | } | |
672 | ||
673 | return nr_done; | |
674 | } | |
675 | EXPORT_SYMBOL_GPL(ata_qc_complete_multiple); | |
676 | ||
7fe183c7 BZ |
677 | /** |
678 | * ata_slave_link_init - initialize slave link | |
679 | * @ap: port to initialize slave link for | |
680 | * | |
681 | * Create and initialize slave link for @ap. This enables slave | |
682 | * link handling on the port. | |
683 | * | |
684 | * In libata, a port contains links and a link contains devices. | |
685 | * There is single host link but if a PMP is attached to it, | |
686 | * there can be multiple fan-out links. On SATA, there's usually | |
687 | * a single device connected to a link but PATA and SATA | |
688 | * controllers emulating TF based interface can have two - master | |
689 | * and slave. | |
690 | * | |
691 | * However, there are a few controllers which don't fit into this | |
692 | * abstraction too well - SATA controllers which emulate TF | |
693 | * interface with both master and slave devices but also have | |
694 | * separate SCR register sets for each device. These controllers | |
695 | * need separate links for physical link handling | |
696 | * (e.g. onlineness, link speed) but should be treated like a | |
697 | * traditional M/S controller for everything else (e.g. command | |
698 | * issue, softreset). | |
699 | * | |
700 | * slave_link is libata's way of handling this class of | |
701 | * controllers without impacting core layer too much. For | |
702 | * anything other than physical link handling, the default host | |
703 | * link is used for both master and slave. For physical link | |
704 | * handling, separate @ap->slave_link is used. All dirty details | |
705 | * are implemented inside libata core layer. From LLD's POV, the | |
706 | * only difference is that prereset, hardreset and postreset are | |
707 | * called once more for the slave link, so the reset sequence | |
708 | * looks like the following. | |
709 | * | |
710 | * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) -> | |
711 | * softreset(M) -> postreset(M) -> postreset(S) | |
712 | * | |
713 | * Note that softreset is called only for the master. Softreset | |
714 | * resets both M/S by definition, so SRST on master should handle | |
715 | * both (the standard method will work just fine). | |
716 | * | |
717 | * LOCKING: | |
718 | * Should be called before host is registered. | |
719 | * | |
720 | * RETURNS: | |
721 | * 0 on success, -errno on failure. | |
722 | */ | |
723 | int ata_slave_link_init(struct ata_port *ap) | |
724 | { | |
725 | struct ata_link *link; | |
726 | ||
727 | WARN_ON(ap->slave_link); | |
728 | WARN_ON(ap->flags & ATA_FLAG_PMP); | |
729 | ||
730 | link = kzalloc(sizeof(*link), GFP_KERNEL); | |
731 | if (!link) | |
732 | return -ENOMEM; | |
733 | ||
734 | ata_link_init(ap, link, 1); | |
735 | ap->slave_link = link; | |
736 | return 0; | |
737 | } | |
738 | EXPORT_SYMBOL_GPL(ata_slave_link_init); | |
739 | ||
740 | /** | |
741 | * sata_lpm_ignore_phy_events - test if PHY event should be ignored | |
742 | * @link: Link receiving the event | |
743 | * | |
744 | * Test whether the received PHY event has to be ignored or not. | |
745 | * | |
746 | * LOCKING: | |
747 | * None: | |
748 | * | |
749 | * RETURNS: | |
750 | * True if the event has to be ignored. | |
751 | */ | |
752 | bool sata_lpm_ignore_phy_events(struct ata_link *link) | |
753 | { | |
754 | unsigned long lpm_timeout = link->last_lpm_change + | |
755 | msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); | |
756 | ||
757 | /* if LPM is enabled, PHYRDY doesn't mean anything */ | |
758 | if (link->lpm_policy > ATA_LPM_MAX_POWER) | |
759 | return true; | |
760 | ||
761 | /* ignore the first PHY event after the LPM policy changed | |
762 | * as it is might be spurious | |
763 | */ | |
764 | if ((link->flags & ATA_LFLAG_CHANGED) && | |
765 | time_before(jiffies, lpm_timeout)) | |
766 | return true; | |
767 | ||
768 | return false; | |
769 | } | |
770 | EXPORT_SYMBOL_GPL(sata_lpm_ignore_phy_events); | |
ec811a94 BZ |
771 | |
772 | static const char *ata_lpm_policy_names[] = { | |
773 | [ATA_LPM_UNKNOWN] = "max_performance", | |
774 | [ATA_LPM_MAX_POWER] = "max_performance", | |
775 | [ATA_LPM_MED_POWER] = "medium_power", | |
776 | [ATA_LPM_MED_POWER_WITH_DIPM] = "med_power_with_dipm", | |
777 | [ATA_LPM_MIN_POWER_WITH_PARTIAL] = "min_power_with_partial", | |
778 | [ATA_LPM_MIN_POWER] = "min_power", | |
779 | }; | |
780 | ||
781 | static ssize_t ata_scsi_lpm_store(struct device *device, | |
782 | struct device_attribute *attr, | |
783 | const char *buf, size_t count) | |
784 | { | |
785 | struct Scsi_Host *shost = class_to_shost(device); | |
786 | struct ata_port *ap = ata_shost_to_port(shost); | |
787 | struct ata_link *link; | |
788 | struct ata_device *dev; | |
789 | enum ata_lpm_policy policy; | |
790 | unsigned long flags; | |
791 | ||
792 | /* UNKNOWN is internal state, iterate from MAX_POWER */ | |
793 | for (policy = ATA_LPM_MAX_POWER; | |
794 | policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) { | |
795 | const char *name = ata_lpm_policy_names[policy]; | |
796 | ||
797 | if (strncmp(name, buf, strlen(name)) == 0) | |
798 | break; | |
799 | } | |
800 | if (policy == ARRAY_SIZE(ata_lpm_policy_names)) | |
801 | return -EINVAL; | |
802 | ||
803 | spin_lock_irqsave(ap->lock, flags); | |
804 | ||
805 | ata_for_each_link(link, ap, EDGE) { | |
806 | ata_for_each_dev(dev, &ap->link, ENABLED) { | |
807 | if (dev->horkage & ATA_HORKAGE_NOLPM) { | |
808 | count = -EOPNOTSUPP; | |
809 | goto out_unlock; | |
810 | } | |
811 | } | |
812 | } | |
813 | ||
814 | ap->target_lpm_policy = policy; | |
815 | ata_port_schedule_eh(ap); | |
816 | out_unlock: | |
817 | spin_unlock_irqrestore(ap->lock, flags); | |
818 | return count; | |
819 | } | |
820 | ||
821 | static ssize_t ata_scsi_lpm_show(struct device *dev, | |
822 | struct device_attribute *attr, char *buf) | |
823 | { | |
824 | struct Scsi_Host *shost = class_to_shost(dev); | |
825 | struct ata_port *ap = ata_shost_to_port(shost); | |
826 | ||
827 | if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names)) | |
828 | return -EINVAL; | |
829 | ||
830 | return snprintf(buf, PAGE_SIZE, "%s\n", | |
831 | ata_lpm_policy_names[ap->target_lpm_policy]); | |
832 | } | |
833 | DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR, | |
834 | ata_scsi_lpm_show, ata_scsi_lpm_store); | |
835 | EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy); | |
836 | ||
837 | static ssize_t ata_ncq_prio_enable_show(struct device *device, | |
838 | struct device_attribute *attr, | |
839 | char *buf) | |
840 | { | |
841 | struct scsi_device *sdev = to_scsi_device(device); | |
842 | struct ata_port *ap; | |
843 | struct ata_device *dev; | |
844 | bool ncq_prio_enable; | |
845 | int rc = 0; | |
846 | ||
847 | ap = ata_shost_to_port(sdev->host); | |
848 | ||
849 | spin_lock_irq(ap->lock); | |
850 | dev = ata_scsi_find_dev(ap, sdev); | |
851 | if (!dev) { | |
852 | rc = -ENODEV; | |
853 | goto unlock; | |
854 | } | |
855 | ||
856 | ncq_prio_enable = dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLE; | |
857 | ||
858 | unlock: | |
859 | spin_unlock_irq(ap->lock); | |
860 | ||
861 | return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable); | |
862 | } | |
863 | ||
864 | static ssize_t ata_ncq_prio_enable_store(struct device *device, | |
865 | struct device_attribute *attr, | |
866 | const char *buf, size_t len) | |
867 | { | |
868 | struct scsi_device *sdev = to_scsi_device(device); | |
869 | struct ata_port *ap; | |
870 | struct ata_device *dev; | |
871 | long int input; | |
872 | int rc; | |
873 | ||
874 | rc = kstrtol(buf, 10, &input); | |
875 | if (rc) | |
876 | return rc; | |
877 | if ((input < 0) || (input > 1)) | |
878 | return -EINVAL; | |
879 | ||
880 | ap = ata_shost_to_port(sdev->host); | |
881 | dev = ata_scsi_find_dev(ap, sdev); | |
882 | if (unlikely(!dev)) | |
883 | return -ENODEV; | |
884 | ||
885 | spin_lock_irq(ap->lock); | |
886 | if (input) | |
887 | dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLE; | |
888 | else | |
889 | dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE; | |
890 | ||
891 | dev->link->eh_info.action |= ATA_EH_REVALIDATE; | |
892 | dev->link->eh_info.flags |= ATA_EHI_QUIET; | |
893 | ata_port_schedule_eh(ap); | |
894 | spin_unlock_irq(ap->lock); | |
895 | ||
896 | ata_port_wait_eh(ap); | |
897 | ||
898 | if (input) { | |
899 | spin_lock_irq(ap->lock); | |
900 | if (!(dev->flags & ATA_DFLAG_NCQ_PRIO)) { | |
901 | dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE; | |
902 | rc = -EIO; | |
903 | } | |
904 | spin_unlock_irq(ap->lock); | |
905 | } | |
906 | ||
907 | return rc ? rc : len; | |
908 | } | |
909 | ||
910 | DEVICE_ATTR(ncq_prio_enable, S_IRUGO | S_IWUSR, | |
911 | ata_ncq_prio_enable_show, ata_ncq_prio_enable_store); | |
912 | EXPORT_SYMBOL_GPL(dev_attr_ncq_prio_enable); | |
913 | ||
914 | struct device_attribute *ata_ncq_sdev_attrs[] = { | |
915 | &dev_attr_unload_heads, | |
916 | &dev_attr_ncq_prio_enable, | |
917 | NULL | |
918 | }; | |
919 | EXPORT_SYMBOL_GPL(ata_ncq_sdev_attrs); | |
920 | ||
921 | static ssize_t | |
922 | ata_scsi_em_message_store(struct device *dev, struct device_attribute *attr, | |
923 | const char *buf, size_t count) | |
924 | { | |
925 | struct Scsi_Host *shost = class_to_shost(dev); | |
926 | struct ata_port *ap = ata_shost_to_port(shost); | |
927 | if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM)) | |
928 | return ap->ops->em_store(ap, buf, count); | |
929 | return -EINVAL; | |
930 | } | |
931 | ||
932 | static ssize_t | |
933 | ata_scsi_em_message_show(struct device *dev, struct device_attribute *attr, | |
934 | char *buf) | |
935 | { | |
936 | struct Scsi_Host *shost = class_to_shost(dev); | |
937 | struct ata_port *ap = ata_shost_to_port(shost); | |
938 | ||
939 | if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM)) | |
940 | return ap->ops->em_show(ap, buf); | |
941 | return -EINVAL; | |
942 | } | |
943 | DEVICE_ATTR(em_message, S_IRUGO | S_IWUSR, | |
944 | ata_scsi_em_message_show, ata_scsi_em_message_store); | |
945 | EXPORT_SYMBOL_GPL(dev_attr_em_message); | |
946 | ||
947 | static ssize_t | |
948 | ata_scsi_em_message_type_show(struct device *dev, struct device_attribute *attr, | |
949 | char *buf) | |
950 | { | |
951 | struct Scsi_Host *shost = class_to_shost(dev); | |
952 | struct ata_port *ap = ata_shost_to_port(shost); | |
953 | ||
954 | return snprintf(buf, 23, "%d\n", ap->em_message_type); | |
955 | } | |
956 | DEVICE_ATTR(em_message_type, S_IRUGO, | |
957 | ata_scsi_em_message_type_show, NULL); | |
958 | EXPORT_SYMBOL_GPL(dev_attr_em_message_type); | |
959 | ||
960 | static ssize_t | |
961 | ata_scsi_activity_show(struct device *dev, struct device_attribute *attr, | |
962 | char *buf) | |
963 | { | |
964 | struct scsi_device *sdev = to_scsi_device(dev); | |
965 | struct ata_port *ap = ata_shost_to_port(sdev->host); | |
966 | struct ata_device *atadev = ata_scsi_find_dev(ap, sdev); | |
967 | ||
968 | if (atadev && ap->ops->sw_activity_show && | |
969 | (ap->flags & ATA_FLAG_SW_ACTIVITY)) | |
970 | return ap->ops->sw_activity_show(atadev, buf); | |
971 | return -EINVAL; | |
972 | } | |
973 | ||
974 | static ssize_t | |
975 | ata_scsi_activity_store(struct device *dev, struct device_attribute *attr, | |
976 | const char *buf, size_t count) | |
977 | { | |
978 | struct scsi_device *sdev = to_scsi_device(dev); | |
979 | struct ata_port *ap = ata_shost_to_port(sdev->host); | |
980 | struct ata_device *atadev = ata_scsi_find_dev(ap, sdev); | |
981 | enum sw_activity val; | |
982 | int rc; | |
983 | ||
984 | if (atadev && ap->ops->sw_activity_store && | |
985 | (ap->flags & ATA_FLAG_SW_ACTIVITY)) { | |
986 | val = simple_strtoul(buf, NULL, 0); | |
987 | switch (val) { | |
988 | case OFF: case BLINK_ON: case BLINK_OFF: | |
989 | rc = ap->ops->sw_activity_store(atadev, val); | |
990 | if (!rc) | |
991 | return count; | |
992 | else | |
993 | return rc; | |
994 | } | |
995 | } | |
996 | return -EINVAL; | |
997 | } | |
998 | DEVICE_ATTR(sw_activity, S_IWUSR | S_IRUGO, ata_scsi_activity_show, | |
999 | ata_scsi_activity_store); | |
1000 | EXPORT_SYMBOL_GPL(dev_attr_sw_activity); | |
1001 | ||
1002 | /** | |
1003 | * __ata_change_queue_depth - helper for ata_scsi_change_queue_depth | |
1004 | * @ap: ATA port to which the device change the queue depth | |
1005 | * @sdev: SCSI device to configure queue depth for | |
1006 | * @queue_depth: new queue depth | |
1007 | * | |
1008 | * libsas and libata have different approaches for associating a sdev to | |
1009 | * its ata_port. | |
1010 | * | |
1011 | */ | |
1012 | int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev, | |
1013 | int queue_depth) | |
1014 | { | |
1015 | struct ata_device *dev; | |
1016 | unsigned long flags; | |
1017 | ||
1018 | if (queue_depth < 1 || queue_depth == sdev->queue_depth) | |
1019 | return sdev->queue_depth; | |
1020 | ||
1021 | dev = ata_scsi_find_dev(ap, sdev); | |
1022 | if (!dev || !ata_dev_enabled(dev)) | |
1023 | return sdev->queue_depth; | |
1024 | ||
1025 | /* NCQ enabled? */ | |
1026 | spin_lock_irqsave(ap->lock, flags); | |
1027 | dev->flags &= ~ATA_DFLAG_NCQ_OFF; | |
1028 | if (queue_depth == 1 || !ata_ncq_enabled(dev)) { | |
1029 | dev->flags |= ATA_DFLAG_NCQ_OFF; | |
1030 | queue_depth = 1; | |
1031 | } | |
1032 | spin_unlock_irqrestore(ap->lock, flags); | |
1033 | ||
1034 | /* limit and apply queue depth */ | |
1035 | queue_depth = min(queue_depth, sdev->host->can_queue); | |
1036 | queue_depth = min(queue_depth, ata_id_queue_depth(dev->id)); | |
1037 | queue_depth = min(queue_depth, ATA_MAX_QUEUE); | |
1038 | ||
1039 | if (sdev->queue_depth == queue_depth) | |
1040 | return -EINVAL; | |
1041 | ||
1042 | return scsi_change_queue_depth(sdev, queue_depth); | |
1043 | } | |
1044 | EXPORT_SYMBOL_GPL(__ata_change_queue_depth); | |
1045 | ||
1046 | /** | |
1047 | * ata_scsi_change_queue_depth - SCSI callback for queue depth config | |
1048 | * @sdev: SCSI device to configure queue depth for | |
1049 | * @queue_depth: new queue depth | |
1050 | * | |
1051 | * This is libata standard hostt->change_queue_depth callback. | |
1052 | * SCSI will call into this callback when user tries to set queue | |
1053 | * depth via sysfs. | |
1054 | * | |
1055 | * LOCKING: | |
1056 | * SCSI layer (we don't care) | |
1057 | * | |
1058 | * RETURNS: | |
1059 | * Newly configured queue depth. | |
1060 | */ | |
1061 | int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth) | |
1062 | { | |
1063 | struct ata_port *ap = ata_shost_to_port(sdev->host); | |
1064 | ||
1065 | return __ata_change_queue_depth(ap, sdev, queue_depth); | |
1066 | } | |
1067 | EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth); | |
15964ff7 BZ |
1068 | |
1069 | /** | |
842a5e58 | 1070 | * ata_sas_port_alloc - Allocate port for a SAS attached SATA device |
15964ff7 BZ |
1071 | * @host: ATA host container for all SAS ports |
1072 | * @port_info: Information from low-level host driver | |
1073 | * @shost: SCSI host that the scsi device is attached to | |
1074 | * | |
1075 | * LOCKING: | |
1076 | * PCI/etc. bus probe sem. | |
1077 | * | |
1078 | * RETURNS: | |
1079 | * ata_port pointer on success / NULL on failure. | |
1080 | */ | |
1081 | ||
1082 | struct ata_port *ata_sas_port_alloc(struct ata_host *host, | |
1083 | struct ata_port_info *port_info, | |
1084 | struct Scsi_Host *shost) | |
1085 | { | |
1086 | struct ata_port *ap; | |
1087 | ||
1088 | ap = ata_port_alloc(host); | |
1089 | if (!ap) | |
1090 | return NULL; | |
1091 | ||
1092 | ap->port_no = 0; | |
1093 | ap->lock = &host->lock; | |
1094 | ap->pio_mask = port_info->pio_mask; | |
1095 | ap->mwdma_mask = port_info->mwdma_mask; | |
1096 | ap->udma_mask = port_info->udma_mask; | |
1097 | ap->flags |= port_info->flags; | |
1098 | ap->ops = port_info->port_ops; | |
1099 | ap->cbl = ATA_CBL_SATA; | |
1100 | ||
1101 | return ap; | |
1102 | } | |
1103 | EXPORT_SYMBOL_GPL(ata_sas_port_alloc); | |
1104 | ||
1105 | /** | |
1106 | * ata_sas_port_start - Set port up for dma. | |
1107 | * @ap: Port to initialize | |
1108 | * | |
1109 | * Called just after data structures for each port are | |
1110 | * initialized. | |
1111 | * | |
1112 | * May be used as the port_start() entry in ata_port_operations. | |
1113 | * | |
1114 | * LOCKING: | |
1115 | * Inherited from caller. | |
1116 | */ | |
1117 | int ata_sas_port_start(struct ata_port *ap) | |
1118 | { | |
1119 | /* | |
1120 | * the port is marked as frozen at allocation time, but if we don't | |
1121 | * have new eh, we won't thaw it | |
1122 | */ | |
1123 | if (!ap->ops->error_handler) | |
1124 | ap->pflags &= ~ATA_PFLAG_FROZEN; | |
1125 | return 0; | |
1126 | } | |
1127 | EXPORT_SYMBOL_GPL(ata_sas_port_start); | |
1128 | ||
1129 | /** | |
842a5e58 | 1130 | * ata_sas_port_stop - Undo ata_sas_port_start() |
15964ff7 BZ |
1131 | * @ap: Port to shut down |
1132 | * | |
1133 | * May be used as the port_stop() entry in ata_port_operations. | |
1134 | * | |
1135 | * LOCKING: | |
1136 | * Inherited from caller. | |
1137 | */ | |
1138 | ||
1139 | void ata_sas_port_stop(struct ata_port *ap) | |
1140 | { | |
1141 | } | |
1142 | EXPORT_SYMBOL_GPL(ata_sas_port_stop); | |
1143 | ||
1144 | /** | |
1145 | * ata_sas_async_probe - simply schedule probing and return | |
1146 | * @ap: Port to probe | |
1147 | * | |
1148 | * For batch scheduling of probe for sas attached ata devices, assumes | |
1149 | * the port has already been through ata_sas_port_init() | |
1150 | */ | |
1151 | void ata_sas_async_probe(struct ata_port *ap) | |
1152 | { | |
1153 | __ata_port_probe(ap); | |
1154 | } | |
1155 | EXPORT_SYMBOL_GPL(ata_sas_async_probe); | |
1156 | ||
1157 | int ata_sas_sync_probe(struct ata_port *ap) | |
1158 | { | |
1159 | return ata_port_probe(ap); | |
1160 | } | |
1161 | EXPORT_SYMBOL_GPL(ata_sas_sync_probe); | |
1162 | ||
1163 | ||
1164 | /** | |
1165 | * ata_sas_port_init - Initialize a SATA device | |
1166 | * @ap: SATA port to initialize | |
1167 | * | |
1168 | * LOCKING: | |
1169 | * PCI/etc. bus probe sem. | |
1170 | * | |
1171 | * RETURNS: | |
1172 | * Zero on success, non-zero on error. | |
1173 | */ | |
1174 | ||
1175 | int ata_sas_port_init(struct ata_port *ap) | |
1176 | { | |
1177 | int rc = ap->ops->port_start(ap); | |
1178 | ||
1179 | if (rc) | |
1180 | return rc; | |
1181 | ap->print_id = atomic_inc_return(&ata_print_id); | |
1182 | return 0; | |
1183 | } | |
1184 | EXPORT_SYMBOL_GPL(ata_sas_port_init); | |
1185 | ||
1186 | int ata_sas_tport_add(struct device *parent, struct ata_port *ap) | |
1187 | { | |
1188 | return ata_tport_add(parent, ap); | |
1189 | } | |
1190 | EXPORT_SYMBOL_GPL(ata_sas_tport_add); | |
1191 | ||
1192 | void ata_sas_tport_delete(struct ata_port *ap) | |
1193 | { | |
1194 | ata_tport_delete(ap); | |
1195 | } | |
1196 | EXPORT_SYMBOL_GPL(ata_sas_tport_delete); | |
1197 | ||
1198 | /** | |
1199 | * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc | |
1200 | * @ap: SATA port to destroy | |
1201 | * | |
1202 | */ | |
1203 | ||
1204 | void ata_sas_port_destroy(struct ata_port *ap) | |
1205 | { | |
1206 | if (ap->ops->port_stop) | |
1207 | ap->ops->port_stop(ap); | |
1208 | kfree(ap); | |
1209 | } | |
1210 | EXPORT_SYMBOL_GPL(ata_sas_port_destroy); | |
1211 | ||
1212 | /** | |
1213 | * ata_sas_slave_configure - Default slave_config routine for libata devices | |
1214 | * @sdev: SCSI device to configure | |
1215 | * @ap: ATA port to which SCSI device is attached | |
1216 | * | |
1217 | * RETURNS: | |
1218 | * Zero. | |
1219 | */ | |
1220 | ||
1221 | int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap) | |
1222 | { | |
1223 | ata_scsi_sdev_config(sdev); | |
1224 | ata_scsi_dev_config(sdev, ap->link.device); | |
1225 | return 0; | |
1226 | } | |
1227 | EXPORT_SYMBOL_GPL(ata_sas_slave_configure); | |
1228 | ||
1229 | /** | |
1230 | * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device | |
1231 | * @cmd: SCSI command to be sent | |
1232 | * @ap: ATA port to which the command is being sent | |
1233 | * | |
1234 | * RETURNS: | |
1235 | * Return value from __ata_scsi_queuecmd() if @cmd can be queued, | |
1236 | * 0 otherwise. | |
1237 | */ | |
1238 | ||
1239 | int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap) | |
1240 | { | |
1241 | int rc = 0; | |
1242 | ||
1243 | ata_scsi_dump_cdb(ap, cmd); | |
1244 | ||
1245 | if (likely(ata_dev_enabled(ap->link.device))) | |
1246 | rc = __ata_scsi_queuecmd(cmd, ap->link.device); | |
1247 | else { | |
1248 | cmd->result = (DID_BAD_TARGET << 16); | |
1249 | cmd->scsi_done(cmd); | |
1250 | } | |
1251 | return rc; | |
1252 | } | |
1253 | EXPORT_SYMBOL_GPL(ata_sas_queuecmd); | |
1254 | ||
1255 | int ata_sas_allocate_tag(struct ata_port *ap) | |
1256 | { | |
1257 | unsigned int max_queue = ap->host->n_tags; | |
1258 | unsigned int i, tag; | |
1259 | ||
1260 | for (i = 0, tag = ap->sas_last_tag + 1; i < max_queue; i++, tag++) { | |
1261 | tag = tag < max_queue ? tag : 0; | |
1262 | ||
1263 | /* the last tag is reserved for internal command. */ | |
1264 | if (ata_tag_internal(tag)) | |
1265 | continue; | |
1266 | ||
1267 | if (!test_and_set_bit(tag, &ap->sas_tag_allocated)) { | |
1268 | ap->sas_last_tag = tag; | |
1269 | return tag; | |
1270 | } | |
1271 | } | |
1272 | return -1; | |
1273 | } | |
1274 | ||
1275 | void ata_sas_free_tag(unsigned int tag, struct ata_port *ap) | |
1276 | { | |
1277 | clear_bit(tag, &ap->sas_tag_allocated); | |
1278 | } | |
a695de27 BZ |
1279 | |
1280 | /** | |
1281 | * sata_async_notification - SATA async notification handler | |
1282 | * @ap: ATA port where async notification is received | |
1283 | * | |
1284 | * Handler to be called when async notification via SDB FIS is | |
1285 | * received. This function schedules EH if necessary. | |
1286 | * | |
1287 | * LOCKING: | |
1288 | * spin_lock_irqsave(host lock) | |
1289 | * | |
1290 | * RETURNS: | |
1291 | * 1 if EH is scheduled, 0 otherwise. | |
1292 | */ | |
1293 | int sata_async_notification(struct ata_port *ap) | |
1294 | { | |
1295 | u32 sntf; | |
1296 | int rc; | |
1297 | ||
1298 | if (!(ap->flags & ATA_FLAG_AN)) | |
1299 | return 0; | |
1300 | ||
1301 | rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf); | |
1302 | if (rc == 0) | |
1303 | sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf); | |
1304 | ||
1305 | if (!sata_pmp_attached(ap) || rc) { | |
1306 | /* PMP is not attached or SNTF is not available */ | |
1307 | if (!sata_pmp_attached(ap)) { | |
1308 | /* PMP is not attached. Check whether ATAPI | |
1309 | * AN is configured. If so, notify media | |
1310 | * change. | |
1311 | */ | |
1312 | struct ata_device *dev = ap->link.device; | |
1313 | ||
1314 | if ((dev->class == ATA_DEV_ATAPI) && | |
1315 | (dev->flags & ATA_DFLAG_AN)) | |
1316 | ata_scsi_media_change_notify(dev); | |
1317 | return 0; | |
1318 | } else { | |
1319 | /* PMP is attached but SNTF is not available. | |
1320 | * ATAPI async media change notification is | |
1321 | * not used. The PMP must be reporting PHY | |
1322 | * status change, schedule EH. | |
1323 | */ | |
1324 | ata_port_schedule_eh(ap); | |
1325 | return 1; | |
1326 | } | |
1327 | } else { | |
1328 | /* PMP is attached and SNTF is available */ | |
1329 | struct ata_link *link; | |
1330 | ||
1331 | /* check and notify ATAPI AN */ | |
1332 | ata_for_each_link(link, ap, EDGE) { | |
1333 | if (!(sntf & (1 << link->pmp))) | |
1334 | continue; | |
1335 | ||
1336 | if ((link->device->class == ATA_DEV_ATAPI) && | |
1337 | (link->device->flags & ATA_DFLAG_AN)) | |
1338 | ata_scsi_media_change_notify(link->device); | |
1339 | } | |
1340 | ||
1341 | /* If PMP is reporting that PHY status of some | |
1342 | * downstream ports has changed, schedule EH. | |
1343 | */ | |
1344 | if (sntf & (1 << SATA_PMP_CTRL_PORT)) { | |
1345 | ata_port_schedule_eh(ap); | |
1346 | return 1; | |
1347 | } | |
1348 | ||
1349 | return 0; | |
1350 | } | |
1351 | } | |
1352 | EXPORT_SYMBOL_GPL(sata_async_notification); | |
a0ccd251 BZ |
1353 | |
1354 | /** | |
1355 | * ata_eh_read_log_10h - Read log page 10h for NCQ error details | |
1356 | * @dev: Device to read log page 10h from | |
1357 | * @tag: Resulting tag of the failed command | |
1358 | * @tf: Resulting taskfile registers of the failed command | |
1359 | * | |
1360 | * Read log page 10h to obtain NCQ error details and clear error | |
1361 | * condition. | |
1362 | * | |
1363 | * LOCKING: | |
1364 | * Kernel thread context (may sleep). | |
1365 | * | |
1366 | * RETURNS: | |
1367 | * 0 on success, -errno otherwise. | |
1368 | */ | |
1369 | static int ata_eh_read_log_10h(struct ata_device *dev, | |
1370 | int *tag, struct ata_taskfile *tf) | |
1371 | { | |
1372 | u8 *buf = dev->link->ap->sector_buf; | |
1373 | unsigned int err_mask; | |
1374 | u8 csum; | |
1375 | int i; | |
1376 | ||
1377 | err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1); | |
1378 | if (err_mask) | |
1379 | return -EIO; | |
1380 | ||
1381 | csum = 0; | |
1382 | for (i = 0; i < ATA_SECT_SIZE; i++) | |
1383 | csum += buf[i]; | |
1384 | if (csum) | |
1385 | ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n", | |
1386 | csum); | |
1387 | ||
1388 | if (buf[0] & 0x80) | |
1389 | return -ENOENT; | |
1390 | ||
1391 | *tag = buf[0] & 0x1f; | |
1392 | ||
1393 | tf->command = buf[2]; | |
1394 | tf->feature = buf[3]; | |
1395 | tf->lbal = buf[4]; | |
1396 | tf->lbam = buf[5]; | |
1397 | tf->lbah = buf[6]; | |
1398 | tf->device = buf[7]; | |
1399 | tf->hob_lbal = buf[8]; | |
1400 | tf->hob_lbam = buf[9]; | |
1401 | tf->hob_lbah = buf[10]; | |
1402 | tf->nsect = buf[12]; | |
1403 | tf->hob_nsect = buf[13]; | |
1404 | if (dev->class == ATA_DEV_ZAC && ata_id_has_ncq_autosense(dev->id)) | |
1405 | tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16]; | |
1406 | ||
1407 | return 0; | |
1408 | } | |
1409 | ||
1410 | /** | |
1411 | * ata_eh_analyze_ncq_error - analyze NCQ error | |
1412 | * @link: ATA link to analyze NCQ error for | |
1413 | * | |
1414 | * Read log page 10h, determine the offending qc and acquire | |
1415 | * error status TF. For NCQ device errors, all LLDDs have to do | |
1416 | * is setting AC_ERR_DEV in ehi->err_mask. This function takes | |
1417 | * care of the rest. | |
1418 | * | |
1419 | * LOCKING: | |
1420 | * Kernel thread context (may sleep). | |
1421 | */ | |
1422 | void ata_eh_analyze_ncq_error(struct ata_link *link) | |
1423 | { | |
1424 | struct ata_port *ap = link->ap; | |
1425 | struct ata_eh_context *ehc = &link->eh_context; | |
1426 | struct ata_device *dev = link->device; | |
1427 | struct ata_queued_cmd *qc; | |
1428 | struct ata_taskfile tf; | |
1429 | int tag, rc; | |
1430 | ||
1431 | /* if frozen, we can't do much */ | |
1432 | if (ap->pflags & ATA_PFLAG_FROZEN) | |
1433 | return; | |
1434 | ||
1435 | /* is it NCQ device error? */ | |
1436 | if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV)) | |
1437 | return; | |
1438 | ||
1439 | /* has LLDD analyzed already? */ | |
1440 | ata_qc_for_each_raw(ap, qc, tag) { | |
1441 | if (!(qc->flags & ATA_QCFLAG_FAILED)) | |
1442 | continue; | |
1443 | ||
1444 | if (qc->err_mask) | |
1445 | return; | |
1446 | } | |
1447 | ||
1448 | /* okay, this error is ours */ | |
1449 | memset(&tf, 0, sizeof(tf)); | |
1450 | rc = ata_eh_read_log_10h(dev, &tag, &tf); | |
1451 | if (rc) { | |
1452 | ata_link_err(link, "failed to read log page 10h (errno=%d)\n", | |
1453 | rc); | |
1454 | return; | |
1455 | } | |
1456 | ||
1457 | if (!(link->sactive & (1 << tag))) { | |
1458 | ata_link_err(link, "log page 10h reported inactive tag %d\n", | |
1459 | tag); | |
1460 | return; | |
1461 | } | |
1462 | ||
1463 | /* we've got the perpetrator, condemn it */ | |
1464 | qc = __ata_qc_from_tag(ap, tag); | |
1465 | memcpy(&qc->result_tf, &tf, sizeof(tf)); | |
1466 | qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48; | |
1467 | qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ; | |
1468 | if (dev->class == ATA_DEV_ZAC && | |
1469 | ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary)) { | |
1470 | char sense_key, asc, ascq; | |
1471 | ||
1472 | sense_key = (qc->result_tf.auxiliary >> 16) & 0xff; | |
1473 | asc = (qc->result_tf.auxiliary >> 8) & 0xff; | |
1474 | ascq = qc->result_tf.auxiliary & 0xff; | |
1475 | ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc, ascq); | |
1476 | ata_scsi_set_sense_information(dev, qc->scsicmd, | |
1477 | &qc->result_tf); | |
1478 | qc->flags |= ATA_QCFLAG_SENSE_VALID; | |
1479 | } | |
1480 | ||
1481 | ehc->i.err_mask &= ~AC_ERR_DEV; | |
1482 | } | |
1483 | EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error); |