projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'vfs-6.7.misc' of gitolite.kernel.org:pub/scm/linux/kernel/git/vfs/vfs
[linux-block.git] / drivers / ata / libata-core.c
CommitLineData
c82ee6d3 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 2/*
af36d7f0
JG		 3 * libata-core.c - helper library for ATA
4 *
af36d7f0
JG		 5 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
6 * Copyright 2003-2004 Jeff Garzik
7 *
af36d7f0 8 * libata documentation is available via 'make {ps|pdf}docs',
19285f3c 9 * as Documentation/driver-api/libata.rst
af36d7f0
JG		 10 *
11 * Hardware documentation available from http://www.t13.org/ and
12 * http://www.sata-io.org/
13 *
92c52c52
AC		 14 * Standards documents from:
15 * http://www.t13.org (ATA standards, PCI DMA IDE spec)
16 * http://www.t10.org (SCSI MMC - for ATAPI MMC)
17 * http://www.sata-io.org (SATA)
18 * http://www.compactflash.org (CF)
19 * http://www.qic.org (QIC157 - Tape and DSC)
20 * http://www.ce-ata.org (CE-ATA: not supported)
a52fbcfc
BZ		 21 *
22 * libata is essentially a library of internal helper functions for
23 * low-level ATA host controller drivers. As such, the API/ABI is
24 * likely to change as new drivers are added and updated.
25 * Do not depend on ABI/API stability.
1da177e4
LT		 26 */
27
1da177e4
LT		 28#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/pci.h>
31#include <linux/init.h>
32#include <linux/list.h>
33#include <linux/mm.h>
1da177e4
LT		 34#include <linux/spinlock.h>
35#include <linux/blkdev.h>
36#include <linux/delay.h>
37#include <linux/timer.h>
848c3920 38#include <linux/time.h>
1da177e4
LT		 39#include <linux/interrupt.h>
40#include <linux/completion.h>
41#include <linux/suspend.h>
42#include <linux/workqueue.h>
378f058c 43#include <linux/scatterlist.h>
2dcb407e 44#include <linux/io.h>
e18086d6 45#include <linux/log2.h>
5a0e3ad6 46#include <linux/slab.h>
428ac5fc 47#include <linux/glob.h>
1da177e4 48#include <scsi/scsi.h>
193515d5 49#include <scsi/scsi_cmnd.h>
1da177e4
LT		 50#include <scsi/scsi_host.h>
51#include <linux/libata.h>
1da177e4 52#include <asm/byteorder.h>
fe5af0cc 53#include <asm/unaligned.h>
140b5e59 54#include <linux/cdrom.h>
9990b6f3 55#include <linux/ratelimit.h>
eb25cb99 56#include <linux/leds.h>
9ee4f393 57#include <linux/pm_runtime.h>
b7db04d9 58#include <linux/platform_device.h>
bbf5a097 59#include <asm/setup.h>
1da177e4 60
255c03d1
HR		 61#define CREATE_TRACE_POINTS
62#include <trace/events/libata.h>
63
1da177e4 64#include "libata.h"
d9027470 65#include "libata-transport.h"
fda0efc5 66
029cfd6b 67const struct ata_port_operations ata_base_port_ops = {
0aa1113d 68 .prereset = ata_std_prereset,
203c75b8 69 .postreset = ata_std_postreset,
a1efdaba 70 .error_handler = ata_std_error_handler,
e4a9c373
DW		 71 .sched_eh = ata_std_sched_eh,
72 .end_eh = ata_std_end_eh,
029cfd6b
TH		 73};
74
75const struct ata_port_operations sata_port_ops = {
76 .inherits = &ata_base_port_ops,
77
78 .qc_defer = ata_std_qc_defer,
57c9efdf 79 .hardreset = sata_std_hardreset,
029cfd6b 80};
a52fbcfc 81EXPORT_SYMBOL_GPL(sata_port_ops);
029cfd6b 82
3373efd8
TH		 83static unsigned int ata_dev_init_params(struct ata_device *dev,
84 u16 heads, u16 sectors);
85static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
86static void ata_dev_xfermask(struct ata_device *dev);
75683fe7 87static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
1da177e4 88
a78f57af 89atomic_t ata_print_id = ATOMIC_INIT(0);
1da177e4 90
bf89b0bf 91#ifdef CONFIG_ATA_FORCE
33267325
TH		 92struct ata_force_param {
93 const char *name;
8ba5a45c
BZ		 94 u8 cbl;
95 u8 spd_limit;
f0a6d77b 96 unsigned int xfer_mask;
33267325
TH		 97 unsigned int horkage_on;
98 unsigned int horkage_off;
3af9ca4d
DLM		 99 u16 lflags_on;
100 u16 lflags_off;
33267325
TH		 101};
102
103struct ata_force_ent {
104 int port;
105 int device;
106 struct ata_force_param param;
107};
108
109static struct ata_force_ent *ata_force_tbl;
110static int ata_force_tbl_size;
111
bbf5a097 112static char ata_force_param_buf[COMMAND_LINE_SIZE] __initdata;
7afb4222
TH		 113/* param_buf is thrown away after initialization, disallow read */
114module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0);
8c27ceff 115MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/admin-guide/kernel-parameters.rst for details)");
bf89b0bf 116#endif
33267325 117
2486fa56 118static int atapi_enabled = 1;
1623c81e 119module_param(atapi_enabled, int, 0444);
ad5d8eac 120MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
1623c81e 121
c5c61bda 122static int atapi_dmadir = 0;
95de719a 123module_param(atapi_dmadir, int, 0444);
ad5d8eac 124MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
95de719a 125
baf4fdfa
ML		 126int atapi_passthru16 = 1;
127module_param(atapi_passthru16, int, 0444);
ad5d8eac 128MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
baf4fdfa 129
c3c013a2
JG		 130int libata_fua = 0;
131module_param_named(fua, libata_fua, int, 0444);
ad5d8eac 132MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
c3c013a2 133
2dcb407e 134static int ata_ignore_hpa;
1e999736
AC		 135module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
136MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
137
b3a70601
AC		 138static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
139module_param_named(dma, libata_dma_mask, int, 0444);
140MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
141
87fbc5a0 142static int ata_probe_timeout;
a8601e5f
AM		 143module_param(ata_probe_timeout, int, 0444);
144MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
145
6ebe9d86 146int libata_noacpi = 0;
d7d0dad6 147module_param_named(noacpi, libata_noacpi, int, 0444);
ad5d8eac 148MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
11ef697b 149
ae8d4ee7
AC		 150int libata_allow_tpm = 0;
151module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
ad5d8eac 152MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
ae8d4ee7 153
e7ecd435
TH		 154static int atapi_an;
155module_param(atapi_an, int, 0444);
156MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
157
1da177e4
LT		 158MODULE_AUTHOR("Jeff Garzik");
159MODULE_DESCRIPTION("Library module for ATA devices");
160MODULE_LICENSE("GPL");
161MODULE_VERSION(DRV_VERSION);
162
891fd7c6
DLM		 163static inline bool ata_dev_print_info(struct ata_device *dev)
164{
165 struct ata_eh_context *ehc = &dev->link->eh_context;
166
167 return ehc->i.flags & ATA_EHI_PRINTINFO;
168}
0baab86b 169
9913ff8a
TH		 170static bool ata_sstatus_online(u32 sstatus)
171{
172 return (sstatus & 0xf) == 0x3;
173}
174
1eca4365
TH		 175/**
176 * ata_link_next - link iteration helper
177 * @link: the previous link, NULL to start
178 * @ap: ATA port containing links to iterate
179 * @mode: iteration mode, one of ATA_LITER_*
180 *
181 * LOCKING:
182 * Host lock or EH context.
aadffb68 183 *
1eca4365
TH		 184 * RETURNS:
185 * Pointer to the next link.
aadffb68 186 */
1eca4365
TH		 187struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
188 enum ata_link_iter_mode mode)
aadffb68 189{
1eca4365
TH		 190 BUG_ON(mode != ATA_LITER_EDGE &&
191 mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);
192
aadffb68 193 /* NULL link indicates start of iteration */
1eca4365
TH		 194 if (!link)
195 switch (mode) {
196 case ATA_LITER_EDGE:
197 case ATA_LITER_PMP_FIRST:
198 if (sata_pmp_attached(ap))
199 return ap->pmp_link;
df561f66 200 fallthrough;
1eca4365
TH		 201 case ATA_LITER_HOST_FIRST:
202 return &ap->link;
203 }
aadffb68 204
1eca4365
TH		 205 /* we just iterated over the host link, what's next? */
206 if (link == &ap->link)
207 switch (mode) {
208 case ATA_LITER_HOST_FIRST:
209 if (sata_pmp_attached(ap))
210 return ap->pmp_link;
df561f66 211 fallthrough;
1eca4365
TH		 212 case ATA_LITER_PMP_FIRST:
213 if (unlikely(ap->slave_link))
b1c72916 214 return ap->slave_link;
df561f66 215 fallthrough;
1eca4365 216 case ATA_LITER_EDGE:
aadffb68 217 return NULL;
b1c72916 218 }
aadffb68 219
b1c72916
TH		 220 /* slave_link excludes PMP */
221 if (unlikely(link == ap->slave_link))
222 return NULL;
223
1eca4365 224 /* we were over a PMP link */
aadffb68
TH		 225 if (++link < ap->pmp_link + ap->nr_pmp_links)
226 return link;
1eca4365
TH		 227
228 if (mode == ATA_LITER_PMP_FIRST)
229 return &ap->link;
230
aadffb68
TH		 231 return NULL;
232}
a52fbcfc 233EXPORT_SYMBOL_GPL(ata_link_next);
aadffb68 234
1eca4365
TH		 235/**
236 * ata_dev_next - device iteration helper
237 * @dev: the previous device, NULL to start
238 * @link: ATA link containing devices to iterate
239 * @mode: iteration mode, one of ATA_DITER_*
240 *
241 * LOCKING:
242 * Host lock or EH context.
243 *
244 * RETURNS:
245 * Pointer to the next device.
246 */
247struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
248 enum ata_dev_iter_mode mode)
249{
250 BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&
251 mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);
252
253 /* NULL dev indicates start of iteration */
254 if (!dev)
255 switch (mode) {
256 case ATA_DITER_ENABLED:
257 case ATA_DITER_ALL:
258 dev = link->device;
259 goto check;
260 case ATA_DITER_ENABLED_REVERSE:
261 case ATA_DITER_ALL_REVERSE:
262 dev = link->device + ata_link_max_devices(link) - 1;
263 goto check;
264 }
265
266 next:
267 /* move to the next one */
268 switch (mode) {
269 case ATA_DITER_ENABLED:
270 case ATA_DITER_ALL:
271 if (++dev < link->device + ata_link_max_devices(link))
272 goto check;
273 return NULL;
274 case ATA_DITER_ENABLED_REVERSE:
275 case ATA_DITER_ALL_REVERSE:
276 if (--dev >= link->device)
277 goto check;
278 return NULL;
279 }
280
281 check:
282 if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&
283 !ata_dev_enabled(dev))
284 goto next;
285 return dev;
286}
a52fbcfc 287EXPORT_SYMBOL_GPL(ata_dev_next);
1eca4365 288
b1c72916
TH		 289/**
290 * ata_dev_phys_link - find physical link for a device
291 * @dev: ATA device to look up physical link for
292 *
293 * Look up physical link which @dev is attached to. Note that
294 * this is different from @dev->link only when @dev is on slave
295 * link. For all other cases, it's the same as @dev->link.
296 *
297 * LOCKING:
298 * Don't care.
299 *
300 * RETURNS:
301 * Pointer to the found physical link.
302 */
303struct ata_link *ata_dev_phys_link(struct ata_device *dev)
304{
305 struct ata_port *ap = dev->link->ap;
306
307 if (!ap->slave_link)
308 return dev->link;
309 if (!dev->devno)
310 return &ap->link;
311 return ap->slave_link;
312}
313
bf89b0bf 314#ifdef CONFIG_ATA_FORCE
33267325
TH		 315/**
316 * ata_force_cbl - force cable type according to libata.force
4cdfa1b3 317 * @ap: ATA port of interest
33267325
TH		 318 *
319 * Force cable type according to libata.force and whine about it.
320 * The last entry which has matching port number is used, so it
321 * can be specified as part of device force parameters. For
322 * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the
323 * same effect.
324 *
325 * LOCKING:
326 * EH context.
327 */
328void ata_force_cbl(struct ata_port *ap)
329{
330 int i;
331
332 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
333 const struct ata_force_ent *fe = &ata_force_tbl[i];
334
335 if (fe->port != -1 && fe->port != ap->print_id)
336 continue;
337
338 if (fe->param.cbl == ATA_CBL_NONE)
339 continue;
340
341 ap->cbl = fe->param.cbl;
a9a79dfe 342 ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
33267325
TH		 343 return;
344 }
345}
346
347/**
05944bdf 348 * ata_force_link_limits - force link limits according to libata.force
33267325
TH		 349 * @link: ATA link of interest
350 *
05944bdf
TH		 351 * Force link flags and SATA spd limit according to libata.force
352 * and whine about it. When only the port part is specified
353 * (e.g. 1:), the limit applies to all links connected to both
354 * the host link and all fan-out ports connected via PMP. If the
355 * device part is specified as 0 (e.g. 1.00:), it specifies the
356 * first fan-out link not the host link. Device number 15 always
b1c72916
TH		 357 * points to the host link whether PMP is attached or not. If the
358 * controller has slave link, device number 16 points to it.
33267325
TH		 359 *
360 * LOCKING:
361 * EH context.
362 */
05944bdf 363static void ata_force_link_limits(struct ata_link *link)
33267325 364{
05944bdf 365 bool did_spd = false;
b1c72916
TH		 366 int linkno = link->pmp;
367 int i;
33267325
TH		 368
369 if (ata_is_host_link(link))
b1c72916 370 linkno += 15;
33267325
TH		 371
372 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
373 const struct ata_force_ent *fe = &ata_force_tbl[i];
374
375 if (fe->port != -1 && fe->port != link->ap->print_id)
376 continue;
377
378 if (fe->device != -1 && fe->device != linkno)
379 continue;
380
05944bdf
TH		 381 /* only honor the first spd limit */
382 if (!did_spd && fe->param.spd_limit) {
383 link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
a9a79dfe 384 ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
05944bdf
TH		 385 fe->param.name);
386 did_spd = true;
387 }
33267325 388
05944bdf 389 /* let lflags stack */
3af9ca4d
DLM		 390 if (fe->param.lflags_on) {
391 link->flags |= fe->param.lflags_on;
a9a79dfe 392 ata_link_notice(link,
05944bdf 393 "FORCE: link flag 0x%x forced -> 0x%x\n",
3af9ca4d
DLM		 394 fe->param.lflags_on, link->flags);
395 }
396 if (fe->param.lflags_off) {
397 link->flags &= ~fe->param.lflags_off;
398 ata_link_notice(link,
399 "FORCE: link flag 0x%x cleared -> 0x%x\n",
400 fe->param.lflags_off, link->flags);
05944bdf 401 }
33267325
TH		 402 }
403}
404
405/**
406 * ata_force_xfermask - force xfermask according to libata.force
407 * @dev: ATA device of interest
408 *
409 * Force xfer_mask according to libata.force and whine about it.
410 * For consistency with link selection, device number 15 selects
411 * the first device connected to the host link.
412 *
413 * LOCKING:
414 * EH context.
415 */
416static void ata_force_xfermask(struct ata_device *dev)
417{
418 int devno = dev->link->pmp + dev->devno;
419 int alt_devno = devno;
420 int i;
421
b1c72916
TH		 422 /* allow n.15/16 for devices attached to host port */
423 if (ata_is_host_link(dev->link))
424 alt_devno += 15;
33267325
TH		 425
426 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
427 const struct ata_force_ent *fe = &ata_force_tbl[i];
f0a6d77b 428 unsigned int pio_mask, mwdma_mask, udma_mask;
33267325
TH		 429
430 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
431 continue;
432
433 if (fe->device != -1 && fe->device != devno &&
434 fe->device != alt_devno)
435 continue;
436
437 if (!fe->param.xfer_mask)
438 continue;
439
440 ata_unpack_xfermask(fe->param.xfer_mask,
441 &pio_mask, &mwdma_mask, &udma_mask);
442 if (udma_mask)
443 dev->udma_mask = udma_mask;
444 else if (mwdma_mask) {
445 dev->udma_mask = 0;
446 dev->mwdma_mask = mwdma_mask;
447 } else {
448 dev->udma_mask = 0;
449 dev->mwdma_mask = 0;
450 dev->pio_mask = pio_mask;
451 }
452
a9a79dfe
JP		 453 ata_dev_notice(dev, "FORCE: xfer_mask set to %s\n",
454 fe->param.name);
33267325
TH		 455 return;
456 }
457}
458
459/**
460 * ata_force_horkage - force horkage according to libata.force
461 * @dev: ATA device of interest
462 *
463 * Force horkage according to libata.force and whine about it.
464 * For consistency with link selection, device number 15 selects
465 * the first device connected to the host link.
466 *
467 * LOCKING:
468 * EH context.
469 */
470static void ata_force_horkage(struct ata_device *dev)
471{
472 int devno = dev->link->pmp + dev->devno;
473 int alt_devno = devno;
474 int i;
475
b1c72916
TH		 476 /* allow n.15/16 for devices attached to host port */
477 if (ata_is_host_link(dev->link))
478 alt_devno += 15;
33267325
TH		 479
480 for (i = 0; i < ata_force_tbl_size; i++) {
481 const struct ata_force_ent *fe = &ata_force_tbl[i];
482
483 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
484 continue;
485
486 if (fe->device != -1 && fe->device != devno &&
487 fe->device != alt_devno)
488 continue;
489
490 if (!(~dev->horkage & fe->param.horkage_on) &&
491 !(dev->horkage & fe->param.horkage_off))
492 continue;
493
494 dev->horkage |= fe->param.horkage_on;
495 dev->horkage &= ~fe->param.horkage_off;
496
a9a79dfe
JP		 497 ata_dev_notice(dev, "FORCE: horkage modified (%s)\n",
498 fe->param.name);
33267325
TH		 499 }
500}
bf89b0bf
BZ		 501#else
502static inline void ata_force_link_limits(struct ata_link *link) { }
503static inline void ata_force_xfermask(struct ata_device *dev) { }
504static inline void ata_force_horkage(struct ata_device *dev) { }
505#endif
33267325 506
436d34b3
TH		 507/**
508 * atapi_cmd_type - Determine ATAPI command type from SCSI opcode
509 * @opcode: SCSI opcode
510 *
511 * Determine ATAPI command type from @opcode.
512 *
513 * LOCKING:
514 * None.
515 *
516 * RETURNS:
517 * ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC}
518 */
519int atapi_cmd_type(u8 opcode)
520{
521 switch (opcode) {
522 case GPCMD_READ_10:
523 case GPCMD_READ_12:
524 return ATAPI_READ;
525
526 case GPCMD_WRITE_10:
527 case GPCMD_WRITE_12:
528 case GPCMD_WRITE_AND_VERIFY_10:
529 return ATAPI_WRITE;
530
531 case GPCMD_READ_CD:
532 case GPCMD_READ_CD_MSF:
533 return ATAPI_READ_CD;
534
e52dcc48
TH		 535 case ATA_16:
536 case ATA_12:
537 if (atapi_passthru16)
538 return ATAPI_PASS_THRU;
df561f66 539 fallthrough;
436d34b3
TH		 540 default:
541 return ATAPI_MISC;
542 }
543}
a52fbcfc 544EXPORT_SYMBOL_GPL(atapi_cmd_type);
436d34b3 545
8cbd6df1
AL		 546static const u8 ata_rw_cmds[] = {
547 /* pio multi */
548 ATA_CMD_READ_MULTI,
549 ATA_CMD_WRITE_MULTI,
550 ATA_CMD_READ_MULTI_EXT,
551 ATA_CMD_WRITE_MULTI_EXT,
9a3dccc4
TH		 552 0,
553 0,
554 0,
bc9af490 555 0,
8cbd6df1
AL		 556 /* pio */
557 ATA_CMD_PIO_READ,
558 ATA_CMD_PIO_WRITE,
559 ATA_CMD_PIO_READ_EXT,
560 ATA_CMD_PIO_WRITE_EXT,
9a3dccc4
TH		 561 0,
562 0,
563 0,
564 0,
8cbd6df1
AL		 565 /* dma */
566 ATA_CMD_READ,
567 ATA_CMD_WRITE,
568 ATA_CMD_READ_EXT,
9a3dccc4
TH		 569 ATA_CMD_WRITE_EXT,
570 0,
571 0,
572 0,
573 ATA_CMD_WRITE_FUA_EXT
8cbd6df1 574};
1da177e4
LT		 575
576/**
77839deb
DLM		 577 * ata_set_rwcmd_protocol - set taskfile r/w command and protocol
578 * @dev: target device for the taskfile
579 * @tf: taskfile to examine and configure
1da177e4 580 *
77839deb
DLM		 581 * Examine the device configuration and tf->flags to determine
582 * the proper read/write command and protocol to use for @tf.
1da177e4
LT		 583 *
584 * LOCKING:
585 * caller.
586 */
77839deb
DLM		 587static bool ata_set_rwcmd_protocol(struct ata_device *dev,
588 struct ata_taskfile *tf)
1da177e4 589{
9a3dccc4 590 u8 cmd;
1da177e4 591
9a3dccc4 592 int index, fua, lba48, write;
2e9edbf8 593
9a3dccc4 594 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
8cbd6df1
AL		 595 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
596 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
1da177e4 597
8cbd6df1
AL		 598 if (dev->flags & ATA_DFLAG_PIO) {
599 tf->protocol = ATA_PROT_PIO;
9a3dccc4 600 index = dev->multi_count ? 0 : 8;
9af5c9c9 601 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
8d238e01
AC		 602 /* Unable to use DMA due to host limitation */
603 tf->protocol = ATA_PROT_PIO;
0565c26d 604 index = dev->multi_count ? 0 : 8;
8cbd6df1
AL		 605 } else {
606 tf->protocol = ATA_PROT_DMA;
9a3dccc4 607 index = 16;
8cbd6df1 608 }
1da177e4 609
9a3dccc4 610 cmd = ata_rw_cmds[index + fua + lba48 + write];
77839deb
DLM		 611 if (!cmd)
612 return false;
613
614 tf->command = cmd;
615
616 return true;
1da177e4
LT		 617}
618
35b649fe
TH		 619/**
620 * ata_tf_read_block - Read block address from ATA taskfile
621 * @tf: ATA taskfile of interest
622 * @dev: ATA device @tf belongs to
623 *
624 * LOCKING:
625 * None.
626 *
627 * Read block address from @tf. This function can handle all
628 * three address formats - LBA, LBA48 and CHS. tf->protocol and
629 * flags select the address format to use.
630 *
631 * RETURNS:
632 * Block address read from @tf.
633 */
cffd1ee9 634u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
35b649fe
TH		 635{
636 u64 block = 0;
637
fe16d4f2 638 if (tf->flags & ATA_TFLAG_LBA) {
35b649fe
TH		 639 if (tf->flags & ATA_TFLAG_LBA48) {
640 block |= (u64)tf->hob_lbah << 40;
641 block |= (u64)tf->hob_lbam << 32;
44901a96 642 block |= (u64)tf->hob_lbal << 24;
35b649fe
TH		 643 } else
644 block |= (tf->device & 0xf) << 24;
645
646 block |= tf->lbah << 16;
647 block |= tf->lbam << 8;
648 block |= tf->lbal;
649 } else {
650 u32 cyl, head, sect;
651
652 cyl = tf->lbam | (tf->lbah << 8);
653 head = tf->device & 0xf;
654 sect = tf->lbal;
655
ac8672ea 656 if (!sect) {
a9a79dfe
JP		 657 ata_dev_warn(dev,
658 "device reported invalid CHS sector 0\n");
cffd1ee9 659 return U64_MAX;
ac8672ea
TH		 660 }
661
662 block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
35b649fe
TH		 663 }
664
665 return block;
666}
667
eafe804b
DLM		 668/*
669 * Set a taskfile command duration limit index.
670 */
671static inline void ata_set_tf_cdl(struct ata_queued_cmd *qc, int cdl)
672{
673 struct ata_taskfile *tf = &qc->tf;
674
675 if (tf->protocol == ATA_PROT_NCQ)
676 tf->auxiliary |= cdl;
677 else
678 tf->feature |= cdl;
679
18bd7718
NC		 680 /*
681 * Mark this command as having a CDL and request the result
682 * task file so that we can inspect the sense data available
683 * bit on completion.
684 */
685 qc->flags |= ATA_QCFLAG_HAS_CDL | ATA_QCFLAG_RESULT_TF;
eafe804b
DLM		 686}
687
bd056d7e
TH		 688/**
689 * ata_build_rw_tf - Build ATA taskfile for given read/write request
066de3b9 690 * @qc: Metadata associated with the taskfile to build
bd056d7e
TH		 691 * @block: Block address
692 * @n_block: Number of blocks
693 * @tf_flags: RW/FUA etc...
eafe804b 694 * @cdl: Command duration limit index
8e061784 695 * @class: IO priority class
bd056d7e
TH		 696 *
697 * LOCKING:
698 * None.
699 *
066de3b9
DLM		 700 * Build ATA taskfile for the command @qc for read/write request described
701 * by @block, @n_block, @tf_flags and @class.
bd056d7e
TH		 702 *
703 * RETURNS:
704 *
705 * 0 on success, -ERANGE if the request is too large for @dev,
706 * -EINVAL if the request is invalid.
707 */
066de3b9 708int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block,
eafe804b 709 unsigned int tf_flags, int cdl, int class)
bd056d7e 710{
066de3b9
DLM		 711 struct ata_taskfile *tf = &qc->tf;
712 struct ata_device *dev = qc->dev;
713
bd056d7e
TH		 714 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
715 tf->flags |= tf_flags;
716
066de3b9 717 if (ata_ncq_enabled(dev)) {
bd056d7e
TH		 718 /* yay, NCQ */
719 if (!lba_48_ok(block, n_block))
720 return -ERANGE;
721
722 tf->protocol = ATA_PROT_NCQ;
723 tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
724
725 if (tf->flags & ATA_TFLAG_WRITE)
726 tf->command = ATA_CMD_FPDMA_WRITE;
727 else
728 tf->command = ATA_CMD_FPDMA_READ;
729
066de3b9 730 tf->nsect = qc->hw_tag << 3;
bd056d7e
TH		 731 tf->hob_feature = (n_block >> 8) & 0xff;
732 tf->feature = n_block & 0xff;
733
734 tf->hob_lbah = (block >> 40) & 0xff;
735 tf->hob_lbam = (block >> 32) & 0xff;
736 tf->hob_lbal = (block >> 24) & 0xff;
737 tf->lbah = (block >> 16) & 0xff;
738 tf->lbam = (block >> 8) & 0xff;
739 tf->lbal = block & 0xff;
740
9ca7cfa4 741 tf->device = ATA_LBA;
bd056d7e
TH		 742 if (tf->flags & ATA_TFLAG_FUA)
743 tf->device |= 1 << 7;
8e061784 744
e00923c5 745 if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED &&
2360fa18
DLM		 746 class == IOPRIO_CLASS_RT)
747 tf->hob_nsect |= ATA_PRIO_HIGH << ATA_SHIFT_PRIO;
eafe804b
DLM		 748
749 if ((dev->flags & ATA_DFLAG_CDL_ENABLED) && cdl)
750 ata_set_tf_cdl(qc, cdl);
751
bd056d7e
TH		 752 } else if (dev->flags & ATA_DFLAG_LBA) {
753 tf->flags |= ATA_TFLAG_LBA;
754
eafe804b
DLM		 755 if ((dev->flags & ATA_DFLAG_CDL_ENABLED) && cdl)
756 ata_set_tf_cdl(qc, cdl);
757
758 /* Both FUA writes and a CDL index require 48-bit commands */
759 if (!(tf->flags & ATA_TFLAG_FUA) &&
760 !(qc->flags & ATA_QCFLAG_HAS_CDL) &&
761 lba_28_ok(block, n_block)) {
bd056d7e
TH		 762 /* use LBA28 */
763 tf->device |= (block >> 24) & 0xf;
764 } else if (lba_48_ok(block, n_block)) {
765 if (!(dev->flags & ATA_DFLAG_LBA48))
766 return -ERANGE;
767
768 /* use LBA48 */
769 tf->flags |= ATA_TFLAG_LBA48;
770
771 tf->hob_nsect = (n_block >> 8) & 0xff;
772
773 tf->hob_lbah = (block >> 40) & 0xff;
774 tf->hob_lbam = (block >> 32) & 0xff;
775 tf->hob_lbal = (block >> 24) & 0xff;
bc9af490 776 } else {
bd056d7e
TH		 777 /* request too large even for LBA48 */
778 return -ERANGE;
bc9af490 779 }
bd056d7e 780
77839deb 781 if (unlikely(!ata_set_rwcmd_protocol(dev, tf)))
bd056d7e
TH		 782 return -EINVAL;
783
784 tf->nsect = n_block & 0xff;
785
786 tf->lbah = (block >> 16) & 0xff;
787 tf->lbam = (block >> 8) & 0xff;
788 tf->lbal = block & 0xff;
789
790 tf->device |= ATA_LBA;
791 } else {
792 /* CHS */
793 u32 sect, head, cyl, track;
794
795 /* The request -may- be too large for CHS addressing. */
796 if (!lba_28_ok(block, n_block))
797 return -ERANGE;
798
77839deb 799 if (unlikely(!ata_set_rwcmd_protocol(dev, tf)))
bd056d7e
TH		 800 return -EINVAL;
801
802 /* Convert LBA to CHS */
803 track = (u32)block / dev->sectors;
804 cyl = track / dev->heads;
805 head = track % dev->heads;
806 sect = (u32)block % dev->sectors + 1;
807
bd056d7e
TH		 808 /* Check whether the converted CHS can fit.
809 Cylinder: 0-65535
810 Head: 0-15
811 Sector: 1-255*/
812 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
813 return -ERANGE;
814
815 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
816 tf->lbal = sect;
817 tf->lbam = cyl;
818 tf->lbah = cyl >> 8;
819 tf->device |= head;
820 }
821
822 return 0;
823}
824
cb95d562
TH		 825/**
826 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
827 * @pio_mask: pio_mask
828 * @mwdma_mask: mwdma_mask
829 * @udma_mask: udma_mask
830 *
831 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
832 * unsigned int xfer_mask.
833 *
834 * LOCKING:
835 * None.
836 *
837 * RETURNS:
838 * Packed xfer_mask.
839 */
f0a6d77b
SS		 840unsigned int ata_pack_xfermask(unsigned int pio_mask,
841 unsigned int mwdma_mask,
842 unsigned int udma_mask)
cb95d562 843{
f0a6d77b 844 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
cb95d562
TH		 845 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
846 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
847}
a52fbcfc 848EXPORT_SYMBOL_GPL(ata_pack_xfermask);
cb95d562 849
c0489e4e
TH		 850/**
851 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
852 * @xfer_mask: xfer_mask to unpack
853 * @pio_mask: resulting pio_mask
854 * @mwdma_mask: resulting mwdma_mask
855 * @udma_mask: resulting udma_mask
856 *
857 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
c9b5560a 858 * Any NULL destination masks will be ignored.
c0489e4e 859 */
f0a6d77b
SS		 860void ata_unpack_xfermask(unsigned int xfer_mask, unsigned int *pio_mask,
861 unsigned int *mwdma_mask, unsigned int *udma_mask)
c0489e4e
TH		 862{
863 if (pio_mask)
864 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
865 if (mwdma_mask)
866 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
867 if (udma_mask)
868 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
869}
870
cb95d562 871static const struct ata_xfer_ent {
be9a50c8 872 int shift, bits;
cb95d562
TH		 873 u8 base;
874} ata_xfer_tbl[] = {
70cd071e
TH		 875 { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 },
876 { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
877 { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 },
cb95d562
TH		 878 { -1, },
879};
880
881/**
882 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
883 * @xfer_mask: xfer_mask of interest
884 *
885 * Return matching XFER_* value for @xfer_mask. Only the highest
886 * bit of @xfer_mask is considered.
887 *
888 * LOCKING:
889 * None.
890 *
891 * RETURNS:
70cd071e 892 * Matching XFER_* value, 0xff if no match found.
cb95d562 893 */
f0a6d77b 894u8 ata_xfer_mask2mode(unsigned int xfer_mask)
cb95d562
TH		 895{
896 int highbit = fls(xfer_mask) - 1;
897 const struct ata_xfer_ent *ent;
898
899 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
900 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
901 return ent->base + highbit - ent->shift;
70cd071e 902 return 0xff;
cb95d562 903}
a52fbcfc 904EXPORT_SYMBOL_GPL(ata_xfer_mask2mode);
cb95d562
TH		 905
906/**
907 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
908 * @xfer_mode: XFER_* of interest
909 *
910 * Return matching xfer_mask for @xfer_mode.
911 *
912 * LOCKING:
913 * None.
914 *
915 * RETURNS:
916 * Matching xfer_mask, 0 if no match found.
917 */
f0a6d77b 918unsigned int ata_xfer_mode2mask(u8 xfer_mode)
cb95d562
TH		 919{
920 const struct ata_xfer_ent *ent;
921
922 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
923 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
70cd071e
TH		 924 return ((2 << (ent->shift + xfer_mode - ent->base)) - 1)
925 & ~((1 << ent->shift) - 1);
cb95d562
TH		 926 return 0;
927}
a52fbcfc 928EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);
cb95d562
TH		 929
930/**
931 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
932 * @xfer_mode: XFER_* of interest
933 *
934 * Return matching xfer_shift for @xfer_mode.
935 *
936 * LOCKING:
937 * None.
938 *
939 * RETURNS:
940 * Matching xfer_shift, -1 if no match found.
941 */
a28c1ab3 942int ata_xfer_mode2shift(u8 xfer_mode)
cb95d562
TH		 943{
944 const struct ata_xfer_ent *ent;
945
946 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
947 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
948 return ent->shift;
949 return -1;
950}
a52fbcfc 951EXPORT_SYMBOL_GPL(ata_xfer_mode2shift);
cb95d562 952
1da177e4 953/**
1da7b0d0
TH		 954 * ata_mode_string - convert xfer_mask to string
955 * @xfer_mask: mask of bits supported; only highest bit counts.
1da177e4
LT		 956 *
957 * Determine string which represents the highest speed
1da7b0d0 958 * (highest bit in @modemask).
1da177e4
LT		 959 *
960 * LOCKING:
961 * None.
962 *
963 * RETURNS:
964 * Constant C string representing highest speed listed in
1da7b0d0 965 * @mode_mask, or the constant C string "<n/a>".
1da177e4 966 */
f0a6d77b 967const char *ata_mode_string(unsigned int xfer_mask)
1da177e4 968{
75f554bc
TH		 969 static const char * const xfer_mode_str[] = {
970 "PIO0",
971 "PIO1",
972 "PIO2",
973 "PIO3",
974 "PIO4",
b352e57d
AC		 975 "PIO5",
976 "PIO6",
75f554bc
TH		 977 "MWDMA0",
978 "MWDMA1",
979 "MWDMA2",
b352e57d
AC		 980 "MWDMA3",
981 "MWDMA4",
75f554bc
TH		 982 "UDMA/16",
983 "UDMA/25",
984 "UDMA/33",
985 "UDMA/44",
986 "UDMA/66",
987 "UDMA/100",
988 "UDMA/133",
989 "UDMA7",
990 };
1da7b0d0 991 int highbit;
1da177e4 992
1da7b0d0
TH		 993 highbit = fls(xfer_mask) - 1;
994 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
995 return xfer_mode_str[highbit];
1da177e4 996 return "<n/a>";
1da177e4 997}
a52fbcfc 998EXPORT_SYMBOL_GPL(ata_mode_string);
1da177e4 999
d9027470 1000const char *sata_spd_string(unsigned int spd)
4c360c81
TH		 1001{
1002 static const char * const spd_str[] = {
1003 "1.5 Gbps",
1004 "3.0 Gbps",
8522ee25 1005 "6.0 Gbps",
4c360c81
TH		 1006 };
1007
1008 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
1009 return "<unknown>";
1010 return spd_str[spd - 1];
1011}
1012
1da177e4
LT		 1013/**
1014 * ata_dev_classify - determine device type based on ATA-spec signature
1015 * @tf: ATA taskfile register set for device to be identified
1016 *
1017 * Determine from taskfile register contents whether a device is
1018 * ATA or ATAPI, as per "Signature and persistence" section
1019 * of ATA/PI spec (volume 1, sect 5.14).
1020 *
1021 * LOCKING:
1022 * None.
1023 *
1024 * RETURNS:
9162c657
HR		 1025 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP,
1026 * %ATA_DEV_ZAC, or %ATA_DEV_UNKNOWN the event of failure.
1da177e4 1027 */
057ace5e 1028unsigned int ata_dev_classify(const struct ata_taskfile *tf)
1da177e4
LT		 1029{
1030 /* Apple's open source Darwin code hints that some devices only
1031 * put a proper signature into the LBA mid/high registers,
1032 * So, we only check those. It's sufficient for uniqueness.
633273a3
TH		 1033 *
1034 * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
1035 * signatures for ATA and ATAPI devices attached on SerialATA,
1036 * 0x3c/0xc3 and 0x69/0x96 respectively. However, SerialATA
1037 * spec has never mentioned about using different signatures
1038 * for ATA/ATAPI devices. Then, Serial ATA II: Port
1039 * Multiplier specification began to use 0x69/0x96 to identify
1040 * port multpliers and 0x3c/0xc3 to identify SEMB device.
1041 * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
1042 * 0x69/0x96 shortly and described them as reserved for
1043 * SerialATA.
1044 *
1045 * We follow the current spec and consider that 0x69/0x96
1046 * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
79b42bab
TH		 1047 * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports
1048 * SEMB signature. This is worked around in
1049 * ata_dev_read_id().
1da177e4 1050 */
6c952a0d 1051 if (tf->lbam == 0 && tf->lbah == 0)
1da177e4 1052 return ATA_DEV_ATA;
1da177e4 1053
6c952a0d 1054 if (tf->lbam == 0x14 && tf->lbah == 0xeb)
1da177e4 1055 return ATA_DEV_ATAPI;
1da177e4 1056
6c952a0d 1057 if (tf->lbam == 0x69 && tf->lbah == 0x96)
633273a3 1058 return ATA_DEV_PMP;
633273a3 1059
6c952a0d 1060 if (tf->lbam == 0x3c && tf->lbah == 0xc3)
79b42bab 1061 return ATA_DEV_SEMB;
633273a3 1062
6c952a0d 1063 if (tf->lbam == 0xcd && tf->lbah == 0xab)
9162c657 1064 return ATA_DEV_ZAC;
9162c657 1065
1da177e4
LT		 1066 return ATA_DEV_UNKNOWN;
1067}
a52fbcfc 1068EXPORT_SYMBOL_GPL(ata_dev_classify);
1da177e4 1069
1da177e4 1070/**
6a62a04d 1071 * ata_id_string - Convert IDENTIFY DEVICE page into string
1da177e4
LT		 1072 * @id: IDENTIFY DEVICE results we will examine
1073 * @s: string into which data is output
1074 * @ofs: offset into identify device page
1075 * @len: length of string to return. must be an even number.
1076 *
1077 * The strings in the IDENTIFY DEVICE page are broken up into
1078 * 16-bit chunks. Run through the string, and output each
1079 * 8-bit chunk linearly, regardless of platform.
1080 *
1081 * LOCKING:
1082 * caller.
1083 */
1084
6a62a04d
TH		 1085void ata_id_string(const u16 *id, unsigned char *s,
1086 unsigned int ofs, unsigned int len)
1da177e4
LT		 1087{
1088 unsigned int c;
1089
963e4975
AC		 1090 BUG_ON(len & 1);
1091
1da177e4
LT		 1092 while (len > 0) {
1093 c = id[ofs] >> 8;
1094 *s = c;
1095 s++;
1096
1097 c = id[ofs] & 0xff;
1098 *s = c;
1099 s++;
1100
1101 ofs++;
1102 len -= 2;
1103 }
1104}
a52fbcfc 1105EXPORT_SYMBOL_GPL(ata_id_string);
1da177e4 1106
0e949ff3 1107/**
6a62a04d 1108 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
0e949ff3
TH		 1109 * @id: IDENTIFY DEVICE results we will examine
1110 * @s: string into which data is output
1111 * @ofs: offset into identify device page
1112 * @len: length of string to return. must be an odd number.
1113 *
6a62a04d 1114 * This function is identical to ata_id_string except that it
0e949ff3
TH		 1115 * trims trailing spaces and terminates the resulting string with
1116 * null. @len must be actual maximum length (even number) + 1.
1117 *
1118 * LOCKING:
1119 * caller.
1120 */
6a62a04d
TH		 1121void ata_id_c_string(const u16 *id, unsigned char *s,
1122 unsigned int ofs, unsigned int len)
0e949ff3
TH		 1123{
1124 unsigned char *p;
1125
6a62a04d 1126 ata_id_string(id, s, ofs, len - 1);
0e949ff3
TH		 1127
1128 p = s + strnlen(s, len - 1);
1129 while (p > s && p[-1] == ' ')
1130 p--;
1131 *p = '\0';
1132}
a52fbcfc 1133EXPORT_SYMBOL_GPL(ata_id_c_string);
0baab86b 1134
db6f8759
TH		 1135static u64 ata_id_n_sectors(const u16 *id)
1136{
1137 if (ata_id_has_lba(id)) {
1138 if (ata_id_has_lba48(id))
968e594a 1139 return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
5eb8deb4
SS		 1140
1141 return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
db6f8759 1142 }
5eb8deb4
SS		 1143
1144 if (ata_id_current_chs_valid(id))
1145 return (u32)id[ATA_ID_CUR_CYLS] * (u32)id[ATA_ID_CUR_HEADS] *
1146 (u32)id[ATA_ID_CUR_SECTORS];
1147
1148 return (u32)id[ATA_ID_CYLS] * (u32)id[ATA_ID_HEADS] *
1149 (u32)id[ATA_ID_SECTORS];
db6f8759
TH		 1150}
1151
a5987e0a 1152u64 ata_tf_to_lba48(const struct ata_taskfile *tf)
1e999736
AC		 1153{
1154 u64 sectors = 0;
1155
1156 sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
1157 sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
ba14a9c2 1158 sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
1e999736
AC		 1159 sectors |= (tf->lbah & 0xff) << 16;
1160 sectors |= (tf->lbam & 0xff) << 8;
1161 sectors |= (tf->lbal & 0xff);
1162
a5987e0a 1163 return sectors;
1e999736
AC		 1164}
1165
a5987e0a 1166u64 ata_tf_to_lba(const struct ata_taskfile *tf)
1e999736
AC		 1167{
1168 u64 sectors = 0;
1169
1170 sectors |= (tf->device & 0x0f) << 24;
1171 sectors |= (tf->lbah & 0xff) << 16;
1172 sectors |= (tf->lbam & 0xff) << 8;
1173 sectors |= (tf->lbal & 0xff);
1174
a5987e0a 1175 return sectors;
1e999736
AC		 1176}
1177
1178/**
c728a914
TH		 1179 * ata_read_native_max_address - Read native max address
1180 * @dev: target device
1181 * @max_sectors: out parameter for the result native max address
1e999736 1182 *
c728a914
TH		 1183 * Perform an LBA48 or LBA28 native size query upon the device in
1184 * question.
1e999736 1185 *
c728a914
TH		 1186 * RETURNS:
1187 * 0 on success, -EACCES if command is aborted by the drive.
1188 * -EIO on other errors.
1e999736 1189 */
c728a914 1190static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
1e999736 1191{
c728a914 1192 unsigned int err_mask;
1e999736 1193 struct ata_taskfile tf;
c728a914 1194 int lba48 = ata_id_has_lba48(dev->id);
1e999736
AC		 1195
1196 ata_tf_init(dev, &tf);
1197
c728a914 1198 /* always clear all address registers */
1e999736 1199 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1e999736 1200
c728a914
TH		 1201 if (lba48) {
1202 tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
1203 tf.flags |= ATA_TFLAG_LBA48;
1204 } else
1205 tf.command = ATA_CMD_READ_NATIVE_MAX;
1e999736 1206
bd18bc04 1207 tf.protocol = ATA_PROT_NODATA;
c728a914
TH		 1208 tf.device |= ATA_LBA;
1209
2b789108 1210 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
c728a914 1211 if (err_mask) {
a9a79dfe
JP		 1212 ata_dev_warn(dev,
1213 "failed to read native max address (err_mask=0x%x)\n",
1214 err_mask);
efcef265 1215 if (err_mask == AC_ERR_DEV && (tf.error & ATA_ABORTED))
c728a914
TH		 1216 return -EACCES;
1217 return -EIO;
1218 }
1e999736 1219
c728a914 1220 if (lba48)
a5987e0a 1221 *max_sectors = ata_tf_to_lba48(&tf) + 1;
c728a914 1222 else
a5987e0a 1223 *max_sectors = ata_tf_to_lba(&tf) + 1;
2dcb407e 1224 if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
93328e11 1225 (*max_sectors)--;
c728a914 1226 return 0;
1e999736
AC		 1227}
1228
1229/**
c728a914
TH		 1230 * ata_set_max_sectors - Set max sectors
1231 * @dev: target device
6b38d1d1 1232 * @new_sectors: new max sectors value to set for the device
1e999736 1233 *
c728a914
TH		 1234 * Set max sectors of @dev to @new_sectors.
1235 *
1236 * RETURNS:
1237 * 0 on success, -EACCES if command is aborted or denied (due to
1238 * previous non-volatile SET_MAX) by the drive. -EIO on other
1239 * errors.
1e999736 1240 */
05027adc 1241static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
1e999736 1242{
c728a914 1243 unsigned int err_mask;
1e999736 1244 struct ata_taskfile tf;
c728a914 1245 int lba48 = ata_id_has_lba48(dev->id);
1e999736
AC		 1246
1247 new_sectors--;
1248
1249 ata_tf_init(dev, &tf);
1250
1e999736 1251 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
c728a914
TH		 1252
1253 if (lba48) {
1254 tf.command = ATA_CMD_SET_MAX_EXT;
1255 tf.flags |= ATA_TFLAG_LBA48;
1256
1257 tf.hob_lbal = (new_sectors >> 24) & 0xff;
1258 tf.hob_lbam = (new_sectors >> 32) & 0xff;
1259 tf.hob_lbah = (new_sectors >> 40) & 0xff;
1e582ba4 1260 } else {
c728a914
TH		 1261 tf.command = ATA_CMD_SET_MAX;
1262
1e582ba4
TH		 1263 tf.device |= (new_sectors >> 24) & 0xf;
1264 }
1265
bd18bc04 1266 tf.protocol = ATA_PROT_NODATA;
c728a914 1267 tf.device |= ATA_LBA;
1e999736
AC		 1268
1269 tf.lbal = (new_sectors >> 0) & 0xff;
1270 tf.lbam = (new_sectors >> 8) & 0xff;
1271 tf.lbah = (new_sectors >> 16) & 0xff;
1e999736 1272
2b789108 1273 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
c728a914 1274 if (err_mask) {
a9a79dfe
JP		 1275 ata_dev_warn(dev,
1276 "failed to set max address (err_mask=0x%x)\n",
1277 err_mask);
c728a914 1278 if (err_mask == AC_ERR_DEV &&
efcef265 1279 (tf.error & (ATA_ABORTED | ATA_IDNF)))
c728a914
TH		 1280 return -EACCES;
1281 return -EIO;
1282 }
1283
c728a914 1284 return 0;
1e999736
AC		 1285}
1286
1287/**
1288 * ata_hpa_resize - Resize a device with an HPA set
1289 * @dev: Device to resize
1290 *
1291 * Read the size of an LBA28 or LBA48 disk with HPA features and resize
1292 * it if required to the full size of the media. The caller must check
1293 * the drive has the HPA feature set enabled.
05027adc
TH		 1294 *
1295 * RETURNS:
1296 * 0 on success, -errno on failure.
1e999736 1297 */
05027adc 1298static int ata_hpa_resize(struct ata_device *dev)
1e999736 1299{
891fd7c6 1300 bool print_info = ata_dev_print_info(dev);
445d211b 1301 bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;
05027adc
TH		 1302 u64 sectors = ata_id_n_sectors(dev->id);
1303 u64 native_sectors;
c728a914 1304 int rc;
a617c09f 1305
05027adc 1306 /* do we need to do it? */
9162c657 1307 if ((dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) ||
05027adc
TH		 1308 !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
1309 (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
c728a914 1310 return 0;
1e999736 1311
05027adc
TH		 1312 /* read native max address */
1313 rc = ata_read_native_max_address(dev, &native_sectors);
1314 if (rc) {
dda7aba1
TH		 1315 /* If device aborted the command or HPA isn't going to
1316 * be unlocked, skip HPA resizing.
05027adc 1317 */
445d211b 1318 if (rc == -EACCES || !unlock_hpa) {
a9a79dfe
JP		 1319 ata_dev_warn(dev,
1320 "HPA support seems broken, skipping HPA handling\n");
05027adc
TH		 1321 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1322
1323 /* we can continue if device aborted the command */
1324 if (rc == -EACCES)
1325 rc = 0;
1e999736 1326 }
37301a55 1327
05027adc
TH		 1328 return rc;
1329 }
5920dadf 1330 dev->n_native_sectors = native_sectors;
05027adc
TH		 1331
1332 /* nothing to do? */
445d211b 1333 if (native_sectors <= sectors || !unlock_hpa) {
05027adc
TH		 1334 if (!print_info || native_sectors == sectors)
1335 return 0;
1336
1337 if (native_sectors > sectors)
a9a79dfe 1338 ata_dev_info(dev,
05027adc
TH		 1339 "HPA detected: current %llu, native %llu\n",
1340 (unsigned long long)sectors,
1341 (unsigned long long)native_sectors);
1342 else if (native_sectors < sectors)
a9a79dfe
JP		 1343 ata_dev_warn(dev,
1344 "native sectors (%llu) is smaller than sectors (%llu)\n",
05027adc
TH		 1345 (unsigned long long)native_sectors,
1346 (unsigned long long)sectors);
1347 return 0;
1348 }
1349
1350 /* let's unlock HPA */
1351 rc = ata_set_max_sectors(dev, native_sectors);
1352 if (rc == -EACCES) {
1353 /* if device aborted the command, skip HPA resizing */
a9a79dfe
JP		 1354 ata_dev_warn(dev,
1355 "device aborted resize (%llu -> %llu), skipping HPA handling\n",
1356 (unsigned long long)sectors,
1357 (unsigned long long)native_sectors);
05027adc
TH		 1358 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1359 return 0;
1360 } else if (rc)
1361 return rc;
1362
1363 /* re-read IDENTIFY data */
1364 rc = ata_dev_reread_id(dev, 0);
1365 if (rc) {
a9a79dfe
JP		 1366 ata_dev_err(dev,
1367 "failed to re-read IDENTIFY data after HPA resizing\n");
05027adc
TH		 1368 return rc;
1369 }
1370
1371 if (print_info) {
1372 u64 new_sectors = ata_id_n_sectors(dev->id);
a9a79dfe 1373 ata_dev_info(dev,
05027adc
TH		 1374 "HPA unlocked: %llu -> %llu, native %llu\n",
1375 (unsigned long long)sectors,
1376 (unsigned long long)new_sectors,
1377 (unsigned long long)native_sectors);
1378 }
1379
1380 return 0;
1e999736
AC		 1381}
1382
1da177e4
LT		 1383/**
1384 * ata_dump_id - IDENTIFY DEVICE info debugging output
6044f3c4 1385 * @dev: device from which the information is fetched
0bd3300a 1386 * @id: IDENTIFY DEVICE page to dump
1da177e4 1387 *
0bd3300a
TH		 1388 * Dump selected 16-bit words from the given IDENTIFY DEVICE
1389 * page.
1da177e4
LT		 1390 *
1391 * LOCKING:
1392 * caller.
1393 */
1394
6044f3c4 1395static inline void ata_dump_id(struct ata_device *dev, const u16 *id)
1da177e4 1396{
6044f3c4
HR		 1397 ata_dev_dbg(dev,
1398 "49==0x%04x 53==0x%04x 63==0x%04x 64==0x%04x 75==0x%04x\n"
1399 "80==0x%04x 81==0x%04x 82==0x%04x 83==0x%04x 84==0x%04x\n"
1400 "88==0x%04x 93==0x%04x\n",
1401 id[49], id[53], id[63], id[64], id[75], id[80],
1402 id[81], id[82], id[83], id[84], id[88], id[93]);
1da177e4
LT		 1403}
1404
cb95d562
TH		 1405/**
1406 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
1407 * @id: IDENTIFY data to compute xfer mask from
1408 *
1409 * Compute the xfermask for this device. This is not as trivial
1410 * as it seems if we must consider early devices correctly.
1411 *
1412 * FIXME: pre IDE drive timing (do we care ?).
1413 *
1414 * LOCKING:
1415 * None.
1416 *
1417 * RETURNS:
1418 * Computed xfermask
1419 */
f0a6d77b 1420unsigned int ata_id_xfermask(const u16 *id)
cb95d562 1421{
f0a6d77b 1422 unsigned int pio_mask, mwdma_mask, udma_mask;
cb95d562
TH		 1423
1424 /* Usual case. Word 53 indicates word 64 is valid */
1425 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1426 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1427 pio_mask <<= 3;
1428 pio_mask |= 0x7;
1429 } else {
1430 /* If word 64 isn't valid then Word 51 high byte holds
1431 * the PIO timing number for the maximum. Turn it into
1432 * a mask.
1433 */
7a0f1c8a 1434 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
46767aeb 1435 if (mode < 5) /* Valid PIO range */
2dcb407e 1436 pio_mask = (2 << mode) - 1;
46767aeb
AC		 1437 else
1438 pio_mask = 1;
cb95d562
TH		 1439
1440 /* But wait.. there's more. Design your standards by
1441 * committee and you too can get a free iordy field to
e0af10ac 1442 * process. However it is the speeds not the modes that
cb95d562
TH		 1443 * are supported... Note drivers using the timing API
1444 * will get this right anyway
1445 */
1446 }
1447
1448 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
fb21f0d0 1449
b352e57d
AC		 1450 if (ata_id_is_cfa(id)) {
1451 /*
1452 * Process compact flash extended modes
1453 */
62afe5d7
SS		 1454 int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
1455 int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;
b352e57d
AC		 1456
1457 if (pio)
1458 pio_mask |= (1 << 5);
1459 if (pio > 1)
1460 pio_mask |= (1 << 6);
1461 if (dma)
1462 mwdma_mask |= (1 << 3);
1463 if (dma > 1)
1464 mwdma_mask |= (1 << 4);
1465 }
1466
fb21f0d0
TH		 1467 udma_mask = 0;
1468 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1469 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
cb95d562
TH		 1470
1471 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1472}
a52fbcfc 1473EXPORT_SYMBOL_GPL(ata_id_xfermask);
cb95d562 1474
7102d230 1475static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
a2a7a662 1476{
77853bf2 1477 struct completion *waiting = qc->private_data;
a2a7a662 1478
a2a7a662 1479 complete(waiting);
a2a7a662
TH		 1480}
1481
1482/**
2432697b 1483 * ata_exec_internal_sg - execute libata internal command
a2a7a662
TH		 1484 * @dev: Device to which the command is sent
1485 * @tf: Taskfile registers for the command and the result
d69cf37d 1486 * @cdb: CDB for packet command
e227867f 1487 * @dma_dir: Data transfer direction of the command
5c1ad8b3 1488 * @sgl: sg list for the data buffer of the command
2432697b 1489 * @n_elem: Number of sg entries
2b789108 1490 * @timeout: Timeout in msecs (0 for default)
a2a7a662
TH		 1491 *
1492 * Executes libata internal command with timeout. @tf contains
1493 * command on entry and result on return. Timeout and error
1494 * conditions are reported via return value. No recovery action
1495 * is taken after a command times out. It's caller's duty to
1496 * clean up after timeout.
1497 *
1498 * LOCKING:
1499 * None. Should be called with kernel context, might sleep.
551e8889
TH		 1500 *
1501 * RETURNS:
1502 * Zero on success, AC_ERR_* mask on failure
a2a7a662 1503 */
4d6119f0
SS		 1504static unsigned ata_exec_internal_sg(struct ata_device *dev,
1505 struct ata_taskfile *tf, const u8 *cdb,
1506 int dma_dir, struct scatterlist *sgl,
61176eed 1507 unsigned int n_elem, unsigned int timeout)
a2a7a662 1508{
9af5c9c9
TH		 1509 struct ata_link *link = dev->link;
1510 struct ata_port *ap = link->ap;
a2a7a662 1511 u8 command = tf->command;
87fbc5a0 1512 int auto_timeout = 0;
a2a7a662 1513 struct ata_queued_cmd *qc;
28361c40 1514 unsigned int preempted_tag;
e3ed8939
JA		 1515 u32 preempted_sactive;
1516 u64 preempted_qc_active;
da917d69 1517 int preempted_nr_active_links;
60be6b9a 1518 DECLARE_COMPLETION_ONSTACK(wait);
a2a7a662 1519 unsigned long flags;
77853bf2 1520 unsigned int err_mask;
d95a717f 1521 int rc;
a2a7a662 1522
ba6a1308 1523 spin_lock_irqsave(ap->lock, flags);
a2a7a662 1524
e3180499 1525 /* no internal command while frozen */
4cb7c6f1 1526 if (ata_port_is_frozen(ap)) {
ba6a1308 1527 spin_unlock_irqrestore(ap->lock, flags);
e3180499
TH		 1528 return AC_ERR_SYSTEM;
1529 }
1530
2ab7db1f 1531 /* initialize internal qc */
28361c40 1532 qc = __ata_qc_from_tag(ap, ATA_TAG_INTERNAL);
a2a7a662 1533
28361c40
JA		 1534 qc->tag = ATA_TAG_INTERNAL;
1535 qc->hw_tag = 0;
2ab7db1f
TH		 1536 qc->scsicmd = NULL;
1537 qc->ap = ap;
1538 qc->dev = dev;
1539 ata_qc_reinit(qc);
1540
9af5c9c9
TH		 1541 preempted_tag = link->active_tag;
1542 preempted_sactive = link->sactive;
dedaf2b0 1543 preempted_qc_active = ap->qc_active;
da917d69 1544 preempted_nr_active_links = ap->nr_active_links;
9af5c9c9
TH		 1545 link->active_tag = ATA_TAG_POISON;
1546 link->sactive = 0;
dedaf2b0 1547 ap->qc_active = 0;
da917d69 1548 ap->nr_active_links = 0;
2ab7db1f
TH		 1549
1550 /* prepare & issue qc */
a2a7a662 1551 qc->tf = *tf;
d69cf37d
TH		 1552 if (cdb)
1553 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
e771451c
VP		 1554
1555 /* some SATA bridges need us to indicate data xfer direction */
1556 if (tf->protocol == ATAPI_PROT_DMA && (dev->flags & ATA_DFLAG_DMADIR) &&
1557 dma_dir == DMA_FROM_DEVICE)
1558 qc->tf.feature |= ATAPI_DMADIR;
1559
e61e0672 1560 qc->flags |= ATA_QCFLAG_RESULT_TF;
a2a7a662
TH		 1561 qc->dma_dir = dma_dir;
1562 if (dma_dir != DMA_NONE) {
2432697b 1563 unsigned int i, buflen = 0;
87260216 1564 struct scatterlist *sg;
2432697b 1565
87260216
JA		 1566 for_each_sg(sgl, sg, n_elem, i)
1567 buflen += sg->length;
2432697b 1568
87260216 1569 ata_sg_init(qc, sgl, n_elem);
49c80429 1570 qc->nbytes = buflen;
a2a7a662
TH		 1571 }
1572
77853bf2 1573 qc->private_data = &wait;
a2a7a662
TH		 1574 qc->complete_fn = ata_qc_complete_internal;
1575
8e0e694a 1576 ata_qc_issue(qc);
a2a7a662 1577
ba6a1308 1578 spin_unlock_irqrestore(ap->lock, flags);
a2a7a662 1579
87fbc5a0
TH		 1580 if (!timeout) {
1581 if (ata_probe_timeout)
1582 timeout = ata_probe_timeout * 1000;
1583 else {
1584 timeout = ata_internal_cmd_timeout(dev, command);
1585 auto_timeout = 1;
1586 }
1587 }
2b789108 1588
ff8072d5 1589 ata_eh_release(ap);
c0c362b6 1590
2b789108 1591 rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
d95a717f 1592
ff8072d5 1593 ata_eh_acquire(ap);
c0c362b6 1594
c429137a 1595 ata_sff_flush_pio_task(ap);
41ade50c 1596
d95a717f 1597 if (!rc) {
ba6a1308 1598 spin_lock_irqsave(ap->lock, flags);
a2a7a662
TH		 1599
1600 /* We're racing with irq here. If we lose, the
1601 * following test prevents us from completing the qc
d95a717f
TH		 1602 * twice. If we win, the port is frozen and will be
1603 * cleaned up by ->post_internal_cmd().
a2a7a662 1604 */
77853bf2 1605 if (qc->flags & ATA_QCFLAG_ACTIVE) {
d95a717f
TH		 1606 qc->err_mask |= AC_ERR_TIMEOUT;
1607
ff8072d5 1608 ata_port_freeze(ap);
f15a1daf 1609
16169fb7
TH		 1610 ata_dev_warn(dev, "qc timeout after %u msecs (cmd 0x%x)\n",
1611 timeout, command);
a2a7a662
TH		 1612 }
1613
ba6a1308 1614 spin_unlock_irqrestore(ap->lock, flags);
a2a7a662
TH		 1615 }
1616
d95a717f
TH		 1617 /* do post_internal_cmd */
1618 if (ap->ops->post_internal_cmd)
1619 ap->ops->post_internal_cmd(qc);
1620
a51d644a 1621 /* perform minimal error analysis */
87629312 1622 if (qc->flags & ATA_QCFLAG_EH) {
efcef265 1623 if (qc->result_tf.status & (ATA_ERR | ATA_DF))
a51d644a
TH		 1624 qc->err_mask |= AC_ERR_DEV;
1625
1626 if (!qc->err_mask)
1627 qc->err_mask |= AC_ERR_OTHER;
1628
1629 if (qc->err_mask & ~AC_ERR_OTHER)
1630 qc->err_mask &= ~AC_ERR_OTHER;
2dae9955 1631 } else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) {
efcef265 1632 qc->result_tf.status |= ATA_SENSE;
d95a717f
TH		 1633 }
1634
15869303 1635 /* finish up */
ba6a1308 1636 spin_lock_irqsave(ap->lock, flags);
15869303 1637
e61e0672 1638 *tf = qc->result_tf;
77853bf2
TH		 1639 err_mask = qc->err_mask;
1640
1641 ata_qc_free(qc);
9af5c9c9
TH		 1642 link->active_tag = preempted_tag;
1643 link->sactive = preempted_sactive;
dedaf2b0 1644 ap->qc_active = preempted_qc_active;
da917d69 1645 ap->nr_active_links = preempted_nr_active_links;
77853bf2 1646
ba6a1308 1647 spin_unlock_irqrestore(ap->lock, flags);
15869303 1648
87fbc5a0
TH		 1649 if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
1650 ata_internal_cmd_timed_out(dev, command);
1651
77853bf2 1652 return err_mask;
a2a7a662
TH		 1653}
1654
2432697b 1655/**
33480a0e 1656 * ata_exec_internal - execute libata internal command
2432697b
TH		 1657 * @dev: Device to which the command is sent
1658 * @tf: Taskfile registers for the command and the result
1659 * @cdb: CDB for packet command
e227867f 1660 * @dma_dir: Data transfer direction of the command
2432697b
TH		 1661 * @buf: Data buffer of the command
1662 * @buflen: Length of data buffer
2b789108 1663 * @timeout: Timeout in msecs (0 for default)
2432697b
TH		 1664 *
1665 * Wrapper around ata_exec_internal_sg() which takes simple
1666 * buffer instead of sg list.
1667 *
1668 * LOCKING:
1669 * None. Should be called with kernel context, might sleep.
1670 *
1671 * RETURNS:
1672 * Zero on success, AC_ERR_* mask on failure
1673 */
1674unsigned ata_exec_internal(struct ata_device *dev,
1675 struct ata_taskfile *tf, const u8 *cdb,
2b789108 1676 int dma_dir, void *buf, unsigned int buflen,
61176eed 1677 unsigned int timeout)
2432697b 1678{
33480a0e
TH		 1679 struct scatterlist *psg = NULL, sg;
1680 unsigned int n_elem = 0;
2432697b 1681
33480a0e
TH		 1682 if (dma_dir != DMA_NONE) {
1683 WARN_ON(!buf);
1684 sg_init_one(&sg, buf, buflen);
1685 psg = &sg;
1686 n_elem++;
1687 }
2432697b 1688
2b789108
TH		 1689 return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
1690 timeout);
2432697b
TH		 1691}
1692
1bc4ccff
AC		 1693/**
1694 * ata_pio_need_iordy - check if iordy needed
1695 * @adev: ATA device
1696 *
1697 * Check if the current speed of the device requires IORDY. Used
1698 * by various controllers for chip configuration.
1699 */
1bc4ccff
AC		 1700unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1701{
0d9e6659
TH		 1702 /* Don't set IORDY if we're preparing for reset. IORDY may
1703 * lead to controller lock up on certain controllers if the
1704 * port is not occupied. See bko#11703 for details.
1705 */
1706 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1707 return 0;
1708 /* Controller doesn't support IORDY. Probably a pointless
1709 * check as the caller should know this.
1710 */
9af5c9c9 1711 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1bc4ccff 1712 return 0;
5c18c4d2
DD		 1713 /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6. */
1714 if (ata_id_is_cfa(adev->id)
1715 && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
1716 return 0;
432729f0
AC		 1717 /* PIO3 and higher it is mandatory */
1718 if (adev->pio_mode > XFER_PIO_2)
1719 return 1;
1720 /* We turn it on when possible */
1721 if (ata_id_has_iordy(adev->id))
1bc4ccff 1722 return 1;
432729f0
AC		 1723 return 0;
1724}
a52fbcfc 1725EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
2e9edbf8 1726
432729f0
AC		 1727/**
1728 * ata_pio_mask_no_iordy - Return the non IORDY mask
1729 * @adev: ATA device
1730 *
1731 * Compute the highest mode possible if we are not using iordy. Return
1732 * -1 if no iordy mode is available.
1733 */
432729f0
AC		 1734static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
1735{
1bc4ccff 1736 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1bc4ccff 1737 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
432729f0 1738 u16 pio = adev->id[ATA_ID_EIDE_PIO];
1bc4ccff
AC		 1739 /* Is the speed faster than the drive allows non IORDY ? */
1740 if (pio) {
1741 /* This is cycle times not frequency - watch the logic! */
1742 if (pio > 240) /* PIO2 is 240nS per cycle */
432729f0
AC		 1743 return 3 << ATA_SHIFT_PIO;
1744 return 7 << ATA_SHIFT_PIO;
1bc4ccff
AC		 1745 }
1746 }
432729f0 1747 return 3 << ATA_SHIFT_PIO;
1bc4ccff
AC		 1748}
1749
963e4975
AC		 1750/**
1751 * ata_do_dev_read_id - default ID read method
1752 * @dev: device
1753 * @tf: proposed taskfile
1754 * @id: data buffer
1755 *
1756 * Issue the identify taskfile and hand back the buffer containing
1757 * identify data. For some RAID controllers and for pre ATA devices
1758 * this function is wrapped or replaced by the driver
1759 */
1760unsigned int ata_do_dev_read_id(struct ata_device *dev,
0561e514 1761 struct ata_taskfile *tf, __le16 *id)
963e4975
AC		 1762{
1763 return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE,
1764 id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1765}
a52fbcfc 1766EXPORT_SYMBOL_GPL(ata_do_dev_read_id);
963e4975 1767
1da177e4 1768/**
49016aca 1769 * ata_dev_read_id - Read ID data from the specified device
49016aca
TH		 1770 * @dev: target device
1771 * @p_class: pointer to class of the target device (may be changed)
bff04647 1772 * @flags: ATA_READID_* flags
fe635c7e 1773 * @id: buffer to read IDENTIFY data into
1da177e4 1774 *
49016aca
TH		 1775 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1776 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
aec5c3c1
TH		 1777 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1778 * for pre-ATA4 drives.
1da177e4 1779 *
50a99018 1780 * FIXME: ATA_CMD_ID_ATA is optional for early drives and right
2dcb407e 1781 * now we abort if we hit that case.
50a99018 1782 *
1da177e4 1783 * LOCKING:
49016aca
TH		 1784 * Kernel thread context (may sleep)
1785 *
1786 * RETURNS:
1787 * 0 on success, -errno otherwise.
1da177e4 1788 */
a9beec95 1789int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
bff04647 1790 unsigned int flags, u16 *id)
1da177e4 1791{
9af5c9c9 1792 struct ata_port *ap = dev->link->ap;
49016aca 1793 unsigned int class = *p_class;
a0123703 1794 struct ata_taskfile tf;
49016aca
TH		 1795 unsigned int err_mask = 0;
1796 const char *reason;
79b42bab 1797 bool is_semb = class == ATA_DEV_SEMB;
54936f8b 1798 int may_fallback = 1, tried_spinup = 0;
49016aca 1799 int rc;
1da177e4 1800
963e4975 1801retry:
3373efd8 1802 ata_tf_init(dev, &tf);
a0123703 1803
49016aca 1804 switch (class) {
79b42bab
TH		 1805 case ATA_DEV_SEMB:
1806 class = ATA_DEV_ATA; /* some hard drives report SEMB sig */
df561f66 1807 fallthrough;
49016aca 1808 case ATA_DEV_ATA:
9162c657 1809 case ATA_DEV_ZAC:
a0123703 1810 tf.command = ATA_CMD_ID_ATA;
49016aca
TH		 1811 break;
1812 case ATA_DEV_ATAPI:
a0123703 1813 tf.command = ATA_CMD_ID_ATAPI;
49016aca
TH		 1814 break;
1815 default:
1816 rc = -ENODEV;
1817 reason = "unsupported class";
1818 goto err_out;
1da177e4
LT		 1819 }
1820
a0123703 1821 tf.protocol = ATA_PROT_PIO;
81afe893
TH		 1822
1823 /* Some devices choke if TF registers contain garbage. Make
1824 * sure those are properly initialized.
1825 */
1826 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1827
1828 /* Device presence detection is unreliable on some
1829 * controllers. Always poll IDENTIFY if available.
1830 */
1831 tf.flags |= ATA_TFLAG_POLLING;
1da177e4 1832
963e4975 1833 if (ap->ops->read_id)
0561e514 1834 err_mask = ap->ops->read_id(dev, &tf, (__le16 *)id);
963e4975 1835 else
0561e514 1836 err_mask = ata_do_dev_read_id(dev, &tf, (__le16 *)id);
963e4975 1837
a0123703 1838 if (err_mask) {
800b3996 1839 if (err_mask & AC_ERR_NODEV_HINT) {
a9a79dfe 1840 ata_dev_dbg(dev, "NODEV after polling detection\n");
55a8e2c8
TH		 1841 return -ENOENT;
1842 }
1843
79b42bab 1844 if (is_semb) {
a9a79dfe
JP		 1845 ata_dev_info(dev,
1846 "IDENTIFY failed on device w/ SEMB sig, disabled\n");
79b42bab
TH		 1847 /* SEMB is not supported yet */
1848 *p_class = ATA_DEV_SEMB_UNSUP;
1849 return 0;
1850 }
1851
efcef265 1852 if ((err_mask == AC_ERR_DEV) && (tf.error & ATA_ABORTED)) {
1ffc151f
TH		 1853 /* Device or controller might have reported
1854 * the wrong device class. Give a shot at the
1855 * other IDENTIFY if the current one is
1856 * aborted by the device.
1857 */
1858 if (may_fallback) {
1859 may_fallback = 0;
1860
1861 if (class == ATA_DEV_ATA)
1862 class = ATA_DEV_ATAPI;
1863 else
1864 class = ATA_DEV_ATA;
1865 goto retry;
1866 }
1867
1868 /* Control reaches here iff the device aborted
1869 * both flavors of IDENTIFYs which happens
1870 * sometimes with phantom devices.
1871 */
a9a79dfe
JP		 1872 ata_dev_dbg(dev,
1873 "both IDENTIFYs aborted, assuming NODEV\n");
1ffc151f 1874 return -ENOENT;
54936f8b
TH		 1875 }
1876
49016aca
TH		 1877 rc = -EIO;
1878 reason = "I/O error";
1da177e4
LT		 1879 goto err_out;
1880 }
1881
43c9c591 1882 if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
4baa5745 1883 ata_dev_info(dev, "dumping IDENTIFY data, "
a9a79dfe
JP		 1884 "class=%d may_fallback=%d tried_spinup=%d\n",
1885 class, may_fallback, tried_spinup);
4baa5745 1886 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET,
43c9c591
TH		 1887 16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
1888 }
1889
54936f8b
TH		 1890 /* Falling back doesn't make sense if ID data was read
1891 * successfully at least once.
1892 */
1893 may_fallback = 0;
1894
49016aca 1895 swap_buf_le16(id, ATA_ID_WORDS);
1da177e4 1896
49016aca 1897 /* sanity check */
a4f5749b 1898 rc = -EINVAL;
6070068b 1899 reason = "device reports invalid type";
a4f5749b 1900
9162c657 1901 if (class == ATA_DEV_ATA || class == ATA_DEV_ZAC) {
a4f5749b
TH		 1902 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1903 goto err_out;
db63a4c8
AW		 1904 if (ap->host->flags & ATA_HOST_IGNORE_ATA &&
1905 ata_id_is_ata(id)) {
1906 ata_dev_dbg(dev,
1907 "host indicates ignore ATA devices, ignored\n");
1908 return -ENOENT;
1909 }
a4f5749b
TH		 1910 } else {
1911 if (ata_id_is_ata(id))
1912 goto err_out;
49016aca
TH		 1913 }
1914
169439c2
ML		 1915 if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
1916 tried_spinup = 1;
1917 /*
1918 * Drive powered-up in standby mode, and requires a specific
1919 * SET_FEATURES spin-up subcommand before it will accept
1920 * anything other than the original IDENTIFY command.
1921 */
218f3d30 1922 err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
fb0582f9 1923 if (err_mask && id[2] != 0x738c) {
169439c2
ML		 1924 rc = -EIO;
1925 reason = "SPINUP failed";
1926 goto err_out;
1927 }
1928 /*
1929 * If the drive initially returned incomplete IDENTIFY info,
1930 * we now must reissue the IDENTIFY command.
1931 */
1932 if (id[2] == 0x37c8)
1933 goto retry;
1934 }
1935
9162c657
HR		 1936 if ((flags & ATA_READID_POSTRESET) &&
1937 (class == ATA_DEV_ATA || class == ATA_DEV_ZAC)) {
49016aca
TH		 1938 /*
1939 * The exact sequence expected by certain pre-ATA4 drives is:
1940 * SRST RESET
50a99018
AC		 1941 * IDENTIFY (optional in early ATA)
1942 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
49016aca
TH		 1943 * anything else..
1944 * Some drives were very specific about that exact sequence.
50a99018
AC		 1945 *
1946 * Note that ATA4 says lba is mandatory so the second check
c9404c9c 1947 * should never trigger.
49016aca
TH		 1948 */
1949 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
3373efd8 1950 err_mask = ata_dev_init_params(dev, id[3], id[6]);
49016aca
TH		 1951 if (err_mask) {
1952 rc = -EIO;
1953 reason = "INIT_DEV_PARAMS failed";
1954 goto err_out;
1955 }
1956
1957 /* current CHS translation info (id[53-58]) might be
1958 * changed. reread the identify device info.
1959 */
bff04647 1960 flags &= ~ATA_READID_POSTRESET;
49016aca
TH		 1961 goto retry;
1962 }
1963 }
1964
1965 *p_class = class;
fe635c7e 1966
49016aca
TH		 1967 return 0;
1968
1969 err_out:
16d42467
HR		 1970 ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)\n",
1971 reason, err_mask);
49016aca
TH		 1972 return rc;
1973}
1974
aa3998db
DLM		 1975/**
1976 * ata_dev_power_set_standby - Set a device power mode to standby
1977 * @dev: target device
1978 *
1979 * Issue a STANDBY IMMEDIATE command to set a device power mode to standby.
1980 * For an HDD device, this spins down the disks.
1981 *
1982 * LOCKING:
1983 * Kernel thread context (may sleep).
1984 */
1985void ata_dev_power_set_standby(struct ata_device *dev)
1986{
1987 unsigned long ap_flags = dev->link->ap->flags;
1988 struct ata_taskfile tf;
1989 unsigned int err_mask;
1990
1991 /* Issue STANDBY IMMEDIATE command only if supported by the device */
1992 if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC)
1993 return;
1994
1995 /*
1996 * Some odd clown BIOSes issue spindown on power off (ACPI S4 or S5)
1997 * causing some drives to spin up and down again. For these, do nothing
1998 * if we are being called on shutdown.
1999 */
2000 if ((ap_flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
2001 system_state == SYSTEM_POWER_OFF)
2002 return;
2003
2004 if ((ap_flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
2005 system_entering_hibernation())
2006 return;
2007
2008 ata_tf_init(dev, &tf);
2009 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2010 tf.protocol = ATA_PROT_NODATA;
2011 tf.command = ATA_CMD_STANDBYNOW1;
2012
2013 ata_dev_notice(dev, "Entering standby power mode\n");
2014
2015 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2016 if (err_mask)
2017 ata_dev_err(dev, "STANDBY IMMEDIATE failed (err_mask=0x%x)\n",
2018 err_mask);
2019}
2020
2021/**
2022 * ata_dev_power_set_active - Set a device power mode to active
2023 * @dev: target device
2024 *
2025 * Issue a VERIFY command to enter to ensure that the device is in the
2026 * active power mode. For a spun-down HDD (standby or idle power mode),
2027 * the VERIFY command will complete after the disk spins up.
2028 *
2029 * LOCKING:
2030 * Kernel thread context (may sleep).
2031 */
2032void ata_dev_power_set_active(struct ata_device *dev)
2033{
2034 struct ata_taskfile tf;
2035 unsigned int err_mask;
2036
2037 /*
2038 * Issue READ VERIFY SECTORS command for 1 sector at lba=0 only
2039 * if supported by the device.
2040 */
2041 if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC)
2042 return;
2043
2044 ata_tf_init(dev, &tf);
2045 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2046 tf.protocol = ATA_PROT_NODATA;
2047 tf.command = ATA_CMD_VERIFY;
2048 tf.nsect = 1;
2049 if (dev->flags & ATA_DFLAG_LBA) {
2050 tf.flags |= ATA_TFLAG_LBA;
2051 tf.device |= ATA_LBA;
2052 } else {
2053 /* CHS */
2054 tf.lbal = 0x1; /* sect */
2055 }
2056
2057 ata_dev_notice(dev, "Entering active power mode\n");
2058
2059 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2060 if (err_mask)
2061 ata_dev_err(dev, "VERIFY failed (err_mask=0x%x)\n",
2062 err_mask);
2063}
2064
f01f62c2
CH		 2065/**
2066 * ata_read_log_page - read a specific log page
2067 * @dev: target device
2068 * @log: log to read
2069 * @page: page to read
2070 * @buf: buffer to store read page
2071 * @sectors: number of sectors to read
2072 *
2073 * Read log page using READ_LOG_EXT command.
2074 *
2075 * LOCKING:
2076 * Kernel thread context (may sleep).
2077 *
2078 * RETURNS:
2079 * 0 on success, AC_ERR_* mask otherwise.
2080 */
2081unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
2082 u8 page, void *buf, unsigned int sectors)
2083{
2084 unsigned long ap_flags = dev->link->ap->flags;
2085 struct ata_taskfile tf;
2086 unsigned int err_mask;
2087 bool dma = false;
2088
4633778b 2089 ata_dev_dbg(dev, "read log page - log 0x%x, page 0x%x\n", log, page);
f01f62c2
CH		 2090
2091 /*
2092 * Return error without actually issuing the command on controllers
2093 * which e.g. lockup on a read log page.
2094 */
2095 if (ap_flags & ATA_FLAG_NO_LOG_PAGE)
2096 return AC_ERR_DEV;
2097
2098retry:
2099 ata_tf_init(dev, &tf);
f971a854 2100 if (ata_dma_enabled(dev) && ata_id_has_read_log_dma_ext(dev->id) &&
7cfdfdc8 2101 !(dev->horkage & ATA_HORKAGE_NO_DMA_LOG)) {
f01f62c2
CH		 2102 tf.command = ATA_CMD_READ_LOG_DMA_EXT;
2103 tf.protocol = ATA_PROT_DMA;
2104 dma = true;
2105 } else {
2106 tf.command = ATA_CMD_READ_LOG_EXT;
2107 tf.protocol = ATA_PROT_PIO;
2108 dma = false;
2109 }
2110 tf.lbal = log;
2111 tf.lbam = page;
2112 tf.nsect = sectors;
2113 tf.hob_nsect = sectors >> 8;
2114 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
2115
2116 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
2117 buf, sectors * ATA_SECT_SIZE, 0);
2118
fc5c8aa7
DLM		 2119 if (err_mask) {
2120 if (dma) {
2121 dev->horkage |= ATA_HORKAGE_NO_DMA_LOG;
5122e53e
NC		 2122 if (!ata_port_is_frozen(dev->link->ap))
2123 goto retry;
fc5c8aa7 2124 }
23ef63d5
DLM		 2125 ata_dev_err(dev,
2126 "Read log 0x%02x page 0x%02x failed, Emask 0x%x\n",
2127 (unsigned int)log, (unsigned int)page, err_mask);
f01f62c2
CH		 2128 }
2129
f01f62c2
CH		 2130 return err_mask;
2131}
2132
c745dfc5 2133static int ata_log_supported(struct ata_device *dev, u8 log)
efe205a3
CH		 2134{
2135 struct ata_port *ap = dev->link->ap;
2136
ac9f0c81 2137 if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)
c745dfc5 2138 return 0;
ac9f0c81 2139
efe205a3 2140 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
c745dfc5
TE		 2141 return 0;
2142 return get_unaligned_le16(&ap->sector_buf[log * 2]);
efe205a3
CH		 2143}
2144
a0fd2454
CH		 2145static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
2146{
2147 struct ata_port *ap = dev->link->ap;
2148 unsigned int err, i;
2149
636f6e2a
DLM		 2150 if (dev->horkage & ATA_HORKAGE_NO_ID_DEV_LOG)
2151 return false;
2152
a0fd2454 2153 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
636f6e2a
DLM		 2154 /*
2155 * IDENTIFY DEVICE data log is defined as mandatory starting
2156 * with ACS-3 (ATA version 10). Warn about the missing log
2157 * for drives which implement this ATA level or above.
2158 */
2159 if (ata_id_major_version(dev->id) >= 10)
2160 ata_dev_warn(dev,
2161 "ATA Identify Device Log not supported\n");
2162 dev->horkage |= ATA_HORKAGE_NO_ID_DEV_LOG;
a0fd2454
CH		 2163 return false;
2164 }
2165
2166 /*
2167 * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
2168 * supported.
2169 */
2170 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0, ap->sector_buf,
2171 1);
fc5c8aa7 2172 if (err)
a0fd2454 2173 return false;
a0fd2454
CH		 2174
2175 for (i = 0; i < ap->sector_buf[8]; i++) {
2176 if (ap->sector_buf[9 + i] == page)
2177 return true;
2178 }
2179
2180 return false;
2181}
2182
9062712f
TH		 2183static int ata_do_link_spd_horkage(struct ata_device *dev)
2184{
2185 struct ata_link *plink = ata_dev_phys_link(dev);
2186 u32 target, target_limit;
2187
2188 if (!sata_scr_valid(plink))
2189 return 0;
2190
2191 if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2192 target = 1;
2193 else
2194 return 0;
2195
2196 target_limit = (1 << target) - 1;
2197
2198 /* if already on stricter limit, no need to push further */
2199 if (plink->sata_spd_limit <= target_limit)
2200 return 0;
2201
2202 plink->sata_spd_limit = target_limit;
2203
2204 /* Request another EH round by returning -EAGAIN if link is
2205 * going faster than the target speed. Forward progress is
2206 * guaranteed by setting sata_spd_limit to target_limit above.
2207 */
2208 if (plink->sata_spd > target) {
a9a79dfe
JP		 2209 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2210 sata_spd_string(target));
9062712f
TH		 2211 return -EAGAIN;
2212 }
2213 return 0;
2214}
2215
3373efd8 2216static inline u8 ata_dev_knobble(struct ata_device *dev)
4b2f3ede 2217{
9af5c9c9 2218 struct ata_port *ap = dev->link->ap;
9ce8e307
JA		 2219
2220 if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2221 return 0;
2222
9af5c9c9 2223 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
4b2f3ede
TH		 2224}
2225
5a233551
HR		 2226static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2227{
2228 struct ata_port *ap = dev->link->ap;
2229 unsigned int err_mask;
2230
efe205a3
CH		 2231 if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
2232 ata_dev_warn(dev, "NCQ Send/Recv Log not supported\n");
fe5af0cc
HR		 2233 return;
2234 }
5a233551
HR		 2235 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2236 0, ap->sector_buf, 1);
fc5c8aa7 2237 if (!err_mask) {
5a233551
HR		 2238 u8 *cmds = dev->ncq_send_recv_cmds;
2239
2240 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2241 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2242
2243 if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2244 ata_dev_dbg(dev, "disabling queued TRIM support\n");
2245 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2246 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2247 }
2248 }
2249}
2250
284b3b77
HR		 2251static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2252{
2253 struct ata_port *ap = dev->link->ap;
2254 unsigned int err_mask;
284b3b77 2255
efe205a3 2256 if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
284b3b77
HR		 2257 ata_dev_warn(dev,
2258 "NCQ Send/Recv Log not supported\n");
2259 return;
2260 }
2261 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2262 0, ap->sector_buf, 1);
fc5c8aa7 2263 if (!err_mask) {
284b3b77
HR		 2264 u8 *cmds = dev->ncq_non_data_cmds;
2265
2266 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2267 }
2268}
2269
8e061784
AM		 2270static void ata_dev_config_ncq_prio(struct ata_device *dev)
2271{
2272 struct ata_port *ap = dev->link->ap;
2273 unsigned int err_mask;
2274
06f6c4c6
DLM		 2275 if (!ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
2276 return;
2277
8e061784 2278 err_mask = ata_read_log_page(dev,
1d51d5f3 2279 ATA_LOG_IDENTIFY_DEVICE,
8e061784
AM		 2280 ATA_LOG_SATA_SETTINGS,
2281 ap->sector_buf,
2282 1);
fc5c8aa7 2283 if (err_mask)
2360fa18 2284 goto not_supported;
8e061784 2285
2360fa18
DLM		 2286 if (!(ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)))
2287 goto not_supported;
2288
2289 dev->flags |= ATA_DFLAG_NCQ_PRIO;
2290
2291 return;
8e061784 2292
2360fa18 2293not_supported:
e00923c5 2294 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED;
2360fa18 2295 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
8e061784
AM		 2296}
2297
7a8526a5
KH		 2298static bool ata_dev_check_adapter(struct ata_device *dev,
2299 unsigned short vendor_id)
2300{
2301 struct pci_dev *pcidev = NULL;
2302 struct device *parent_dev = NULL;
2303
2304 for (parent_dev = dev->tdev.parent; parent_dev != NULL;
2305 parent_dev = parent_dev->parent) {
2306 if (dev_is_pci(parent_dev)) {
2307 pcidev = to_pci_dev(parent_dev);
2308 if (pcidev->vendor == vendor_id)
2309 return true;
2310 break;
2311 }
2312 }
2313
2314 return false;
2315}
2316
388539f3 2317static int ata_dev_config_ncq(struct ata_device *dev,
a6e6ce8e
TH		 2318 char *desc, size_t desc_sz)
2319{
9af5c9c9 2320 struct ata_port *ap = dev->link->ap;
a6e6ce8e 2321 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
388539f3
SL		 2322 unsigned int err_mask;
2323 char *aa_desc = "";
a6e6ce8e
TH		 2324
2325 if (!ata_id_has_ncq(dev->id)) {
2326 desc[0] = '\0';
388539f3 2327 return 0;
a6e6ce8e 2328 }
cba97ea1
BZ		 2329 if (!IS_ENABLED(CONFIG_SATA_HOST))
2330 return 0;
75683fe7 2331 if (dev->horkage & ATA_HORKAGE_NONCQ) {
6919a0a6 2332 snprintf(desc, desc_sz, "NCQ (not used)");
388539f3 2333 return 0;
6919a0a6 2334 }
7a8526a5
KH		 2335
2336 if (dev->horkage & ATA_HORKAGE_NO_NCQ_ON_ATI &&
2337 ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
2338 snprintf(desc, desc_sz, "NCQ (not used)");
2339 return 0;
2340 }
2341
a6e6ce8e 2342 if (ap->flags & ATA_FLAG_NCQ) {
69278f79 2343 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
a6e6ce8e
TH		 2344 dev->flags |= ATA_DFLAG_NCQ;
2345 }
2346
388539f3
SL		 2347 if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2348 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2349 ata_id_has_fpdma_aa(dev->id)) {
2350 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2351 SATA_FPDMA_AA);
2352 if (err_mask) {
a9a79dfe
JP		 2353 ata_dev_err(dev,
2354 "failed to enable AA (error_mask=0x%x)\n",
2355 err_mask);
388539f3
SL		 2356 if (err_mask != AC_ERR_DEV) {
2357 dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2358 return -EIO;
2359 }
2360 } else
2361 aa_desc = ", AA";
2362 }
2363
a6e6ce8e 2364 if (hdepth >= ddepth)
388539f3 2365 snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
a6e6ce8e 2366 else
388539f3
SL		 2367 snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2368 ddepth, aa_desc);
ed36911c 2369
284b3b77
HR		 2370 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2371 if (ata_id_has_ncq_send_and_recv(dev->id))
2372 ata_dev_config_ncq_send_recv(dev);
2373 if (ata_id_has_ncq_non_data(dev->id))
2374 ata_dev_config_ncq_non_data(dev);
8e061784
AM		 2375 if (ata_id_has_ncq_prio(dev->id))
2376 ata_dev_config_ncq_prio(dev);
284b3b77 2377 }
f78dea06 2378
388539f3 2379 return 0;
a6e6ce8e 2380}
f78dea06 2381
e87fd28c
HR		 2382static void ata_dev_config_sense_reporting(struct ata_device *dev)
2383{
2384 unsigned int err_mask;
2385
2386 if (!ata_id_has_sense_reporting(dev->id))
2387 return;
2388
2389 if (ata_id_sense_reporting_enabled(dev->id))
2390 return;
2391
2392 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2393 if (err_mask) {
2394 ata_dev_dbg(dev,
2395 "failed to enable Sense Data Reporting, Emask 0x%x\n",
2396 err_mask);
2397 }
2398}
2399
6d1003ae
HR		 2400static void ata_dev_config_zac(struct ata_device *dev)
2401{
2402 struct ata_port *ap = dev->link->ap;
2403 unsigned int err_mask;
2404 u8 *identify_buf = ap->sector_buf;
6d1003ae
HR		 2405
2406 dev->zac_zones_optimal_open = U32_MAX;
2407 dev->zac_zones_optimal_nonseq = U32_MAX;
2408 dev->zac_zones_max_open = U32_MAX;
2409
2410 /*
2411 * Always set the 'ZAC' flag for Host-managed devices.
2412 */
2413 if (dev->class == ATA_DEV_ZAC)
2414 dev->flags |= ATA_DFLAG_ZAC;
2415 else if (ata_id_zoned_cap(dev->id) == 0x01)
2416 /*
2417 * Check for host-aware devices.
2418 */
2419 dev->flags |= ATA_DFLAG_ZAC;
2420
2421 if (!(dev->flags & ATA_DFLAG_ZAC))
2422 return;
2423
a0fd2454 2424 if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
6d1003ae
HR		 2425 ata_dev_warn(dev,
2426 "ATA Zoned Information Log not supported\n");
2427 return;
2428 }
ed36911c 2429
6d1003ae
HR		 2430 /*
2431 * Read IDENTIFY DEVICE data log, page 9 (Zoned-device information)
2432 */
1d51d5f3 2433 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
6d1003ae
HR		 2434 ATA_LOG_ZONED_INFORMATION,
2435 identify_buf, 1);
2436 if (!err_mask) {
2437 u64 zoned_cap, opt_open, opt_nonseq, max_open;
2438
2439 zoned_cap = get_unaligned_le64(&identify_buf[8]);
2440 if ((zoned_cap >> 63))
2441 dev->zac_zoned_cap = (zoned_cap & 1);
2442 opt_open = get_unaligned_le64(&identify_buf[24]);
2443 if ((opt_open >> 63))
2444 dev->zac_zones_optimal_open = (u32)opt_open;
2445 opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2446 if ((opt_nonseq >> 63))
2447 dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2448 max_open = get_unaligned_le64(&identify_buf[40]);
2449 if ((max_open >> 63))
2450 dev->zac_zones_max_open = (u32)max_open;
2451 }
a6e6ce8e
TH		 2452}
2453
818831c8
CH		 2454static void ata_dev_config_trusted(struct ata_device *dev)
2455{
2456 struct ata_port *ap = dev->link->ap;
2457 u64 trusted_cap;
2458 unsigned int err;
2459
e8f11db9
CH		 2460 if (!ata_id_has_trusted(dev->id))
2461 return;
2462
818831c8
CH		 2463 if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
2464 ata_dev_warn(dev,
2465 "Security Log not supported\n");
2466 return;
2467 }
2468
2469 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
2470 ap->sector_buf, 1);
fc5c8aa7 2471 if (err)
818831c8 2472 return;
818831c8
CH		 2473
2474 trusted_cap = get_unaligned_le64(&ap->sector_buf[40]);
2475 if (!(trusted_cap & (1ULL << 63))) {
2476 ata_dev_dbg(dev,
2477 "Trusted Computing capability qword not valid!\n");
2478 return;
2479 }
2480
2481 if (trusted_cap & (1 << 0))
2482 dev->flags |= ATA_DFLAG_TRUSTED;
2483}
2484
62e4a60e
DLM		 2485static void ata_dev_config_cdl(struct ata_device *dev)
2486{
2487 struct ata_port *ap = dev->link->ap;
2488 unsigned int err_mask;
df60f9c6 2489 bool cdl_enabled;
62e4a60e
DLM		 2490 u64 val;
2491
2492 if (ata_id_major_version(dev->id) < 12)
2493 goto not_supported;
2494
2495 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE) ||
df60f9c6
DLM		 2496 !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES) ||
2497 !ata_identify_page_supported(dev, ATA_LOG_CURRENT_SETTINGS))
62e4a60e
DLM		 2498 goto not_supported;
2499
2500 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2501 ATA_LOG_SUPPORTED_CAPABILITIES,
2502 ap->sector_buf, 1);
2503 if (err_mask)
2504 goto not_supported;
2505
2506 /* Check Command Duration Limit Supported bits */
2507 val = get_unaligned_le64(&ap->sector_buf[168]);
2508 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(0)))
2509 goto not_supported;
2510
2511 /* Warn the user if command duration guideline is not supported */
2512 if (!(val & BIT_ULL(1)))
2513 ata_dev_warn(dev,
2514 "Command duration guideline is not supported\n");
2515
18bd7718
NC		 2516 /*
2517 * We must have support for the sense data for successful NCQ commands
2518 * log indicated by the successful NCQ command sense data supported bit.
2519 */
2520 val = get_unaligned_le64(&ap->sector_buf[8]);
2521 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(47))) {
2522 ata_dev_warn(dev,
2523 "CDL supported but Successful NCQ Command Sense Data is not supported\n");
2524 goto not_supported;
2525 }
2526
2527 /* Without NCQ autosense, the successful NCQ commands log is useless. */
2528 if (!ata_id_has_ncq_autosense(dev->id)) {
2529 ata_dev_warn(dev,
2530 "CDL supported but NCQ autosense is not supported\n");
2531 goto not_supported;
2532 }
2533
df60f9c6
DLM		 2534 /*
2535 * If CDL is marked as enabled, make sure the feature is enabled too.
2536 * Conversely, if CDL is disabled, make sure the feature is turned off.
2537 */
2538 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2539 ATA_LOG_CURRENT_SETTINGS,
2540 ap->sector_buf, 1);
2541 if (err_mask)
2542 goto not_supported;
2543
2544 val = get_unaligned_le64(&ap->sector_buf[8]);
2545 cdl_enabled = val & BIT_ULL(63) && val & BIT_ULL(21);
2546 if (dev->flags & ATA_DFLAG_CDL_ENABLED) {
2547 if (!cdl_enabled) {
2548 /* Enable CDL on the device */
2549 err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 1);
2550 if (err_mask) {
2551 ata_dev_err(dev,
2552 "Enable CDL feature failed\n");
2553 goto not_supported;
2554 }
2555 }
2556 } else {
2557 if (cdl_enabled) {
2558 /* Disable CDL on the device */
2559 err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 0);
2560 if (err_mask) {
2561 ata_dev_err(dev,
2562 "Disable CDL feature failed\n");
2563 goto not_supported;
2564 }
2565 }
2566 }
2567
18bd7718
NC		 2568 /*
2569 * While CDL itself has to be enabled using sysfs, CDL requires that
2570 * sense data for successful NCQ commands is enabled to work properly.
2571 * Just like ata_dev_config_sense_reporting(), enable it unconditionally
2572 * if supported.
2573 */
2574 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(18))) {
2575 err_mask = ata_dev_set_feature(dev,
2576 SETFEATURE_SENSE_DATA_SUCC_NCQ, 0x1);
2577 if (err_mask) {
2578 ata_dev_warn(dev,
2579 "failed to enable Sense Data for successful NCQ commands, Emask 0x%x\n",
2580 err_mask);
2581 goto not_supported;
2582 }
2583 }
2584
2585 /*
2586 * Allocate a buffer to handle reading the sense data for successful
2587 * NCQ Commands log page for commands using a CDL with one of the limit
2588 * policy set to 0xD (successful completion with sense data available
2589 * bit set).
2590 */
2591 if (!ap->ncq_sense_buf) {
2592 ap->ncq_sense_buf = kmalloc(ATA_LOG_SENSE_NCQ_SIZE, GFP_KERNEL);
2593 if (!ap->ncq_sense_buf)
2594 goto not_supported;
2595 }
2596
62e4a60e
DLM		 2597 /*
2598 * Command duration limits is supported: cache the CDL log page 18h
2599 * (command duration descriptors).
2600 */
2601 err_mask = ata_read_log_page(dev, ATA_LOG_CDL, 0, ap->sector_buf, 1);
2602 if (err_mask) {
2603 ata_dev_warn(dev, "Read Command Duration Limits log failed\n");
2604 goto not_supported;
2605 }
2606
2607 memcpy(dev->cdl, ap->sector_buf, ATA_LOG_CDL_SIZE);
2608 dev->flags |= ATA_DFLAG_CDL;
2609
2610 return;
2611
2612not_supported:
df60f9c6 2613 dev->flags &= ~(ATA_DFLAG_CDL | ATA_DFLAG_CDL_ENABLED);
18bd7718
NC		 2614 kfree(ap->ncq_sense_buf);
2615 ap->ncq_sense_buf = NULL;
62e4a60e
DLM		 2616}
2617
891fd7c6
DLM		 2618static int ata_dev_config_lba(struct ata_device *dev)
2619{
891fd7c6
DLM		 2620 const u16 *id = dev->id;
2621 const char *lba_desc;
ed518d9b 2622 char ncq_desc[32];
891fd7c6
DLM		 2623 int ret;
2624
2625 dev->flags |= ATA_DFLAG_LBA;
2626
2627 if (ata_id_has_lba48(id)) {
2628 lba_desc = "LBA48";
2629 dev->flags |= ATA_DFLAG_LBA48;
2630 if (dev->n_sectors >= (1UL << 28) &&
2631 ata_id_has_flush_ext(id))
2632 dev->flags |= ATA_DFLAG_FLUSH_EXT;
2633 } else {
2634 lba_desc = "LBA";
2635 }
2636
2637 /* config NCQ */
2638 ret = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2639
2640 /* print device info to dmesg */
1c95a27c 2641 if (ata_dev_print_info(dev))
891fd7c6
DLM		 2642 ata_dev_info(dev,
2643 "%llu sectors, multi %u: %s %s\n",
2644 (unsigned long long)dev->n_sectors,
2645 dev->multi_count, lba_desc, ncq_desc);
2646
2647 return ret;
2648}
2649
2650static void ata_dev_config_chs(struct ata_device *dev)
2651{
891fd7c6
DLM		 2652 const u16 *id = dev->id;
2653
2654 if (ata_id_current_chs_valid(id)) {
2655 /* Current CHS translation is valid. */
2656 dev->cylinders = id[54];
2657 dev->heads = id[55];
2658 dev->sectors = id[56];
2659 } else {
2660 /* Default translation */
2661 dev->cylinders = id[1];
2662 dev->heads = id[3];
2663 dev->sectors = id[6];
2664 }
2665
2666 /* print device info to dmesg */
1c95a27c 2667 if (ata_dev_print_info(dev))
891fd7c6
DLM		 2668 ata_dev_info(dev,
2669 "%llu sectors, multi %u, CHS %u/%u/%u\n",
2670 (unsigned long long)dev->n_sectors,
2671 dev->multi_count, dev->cylinders,
2672 dev->heads, dev->sectors);
2673}
2674
4d2e4980
DLM		 2675static void ata_dev_config_fua(struct ata_device *dev)
2676{
2677 /* Ignore FUA support if its use is disabled globally */
2678 if (!libata_fua)
2679 goto nofua;
2680
2681 /* Ignore devices without support for WRITE DMA FUA EXT */
2682 if (!(dev->flags & ATA_DFLAG_LBA48) || !ata_id_has_fua(dev->id))
2683 goto nofua;
2684
2685 /* Ignore known bad devices and devices that lack NCQ support */
2686 if (!ata_ncq_supported(dev) || (dev->horkage & ATA_HORKAGE_NO_FUA))
2687 goto nofua;
2688
2689 dev->flags |= ATA_DFLAG_FUA;
2690
2691 return;
2692
2693nofua:
2694 dev->flags &= ~ATA_DFLAG_FUA;
2695}
2696
d8d8778c
DLM		 2697static void ata_dev_config_devslp(struct ata_device *dev)
2698{
2699 u8 *sata_setting = dev->link->ap->sector_buf;
2700 unsigned int err_mask;
2701 int i, j;
2702
2703 /*
2704 * Check device sleep capability. Get DevSlp timing variables
2705 * from SATA Settings page of Identify Device Data Log.
2706 */
06f6c4c6
DLM		 2707 if (!ata_id_has_devslp(dev->id) ||
2708 !ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
d8d8778c
DLM		 2709 return;
2710
2711 err_mask = ata_read_log_page(dev,
2712 ATA_LOG_IDENTIFY_DEVICE,
2713 ATA_LOG_SATA_SETTINGS,
2714 sata_setting, 1);
fc5c8aa7 2715 if (err_mask)
d8d8778c 2716 return;
d8d8778c
DLM		 2717
2718 dev->flags |= ATA_DFLAG_DEVSLP;
2719 for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2720 j = ATA_LOG_DEVSLP_OFFSET + i;
2721 dev->devslp_timing[i] = sata_setting[j];
2722 }
2723}
2724
fe22e1c2
DLM		 2725static void ata_dev_config_cpr(struct ata_device *dev)
2726{
2727 unsigned int err_mask;
2728 size_t buf_len;
2729 int i, nr_cpr = 0;
2730 struct ata_cpr_log *cpr_log = NULL;
2731 u8 *desc, *buf = NULL;
2732
c745dfc5
TE		 2733 if (ata_id_major_version(dev->id) < 11)
2734 goto out;
2735
2736 buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
2737 if (buf_len == 0)
fe22e1c2
DLM		 2738 goto out;
2739
2740 /*
fda17afc 2741 * Read the concurrent positioning ranges log (0x47). We can have at
c745dfc5
TE		 2742 * most 255 32B range descriptors plus a 64B header. This log varies in
2743 * size, so use the size reported in the GPL directory. Reading beyond
2744 * the supported length will result in an error.
fe22e1c2 2745 */
c745dfc5 2746 buf_len <<= 9;
fe22e1c2
DLM		 2747 buf = kzalloc(buf_len, GFP_KERNEL);
2748 if (!buf)
2749 goto out;
2750
fda17afc
DLM		 2751 err_mask = ata_read_log_page(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES,
2752 0, buf, buf_len >> 9);
fe22e1c2
DLM		 2753 if (err_mask)
2754 goto out;
2755
2756 nr_cpr = buf[0];
2757 if (!nr_cpr)
2758 goto out;
2759
2760 cpr_log = kzalloc(struct_size(cpr_log, cpr, nr_cpr), GFP_KERNEL);
2761 if (!cpr_log)
2762 goto out;
2763
2764 cpr_log->nr_cpr = nr_cpr;
2765 desc = &buf[64];
2766 for (i = 0; i < nr_cpr; i++, desc += 32) {
2767 cpr_log->cpr[i].num = desc[0];
2768 cpr_log->cpr[i].num_storage_elements = desc[1];
2769 cpr_log->cpr[i].start_lba = get_unaligned_le64(&desc[8]);
2770 cpr_log->cpr[i].num_lbas = get_unaligned_le64(&desc[16]);
2771 }
2772
2773out:
2774 swap(dev->cpr_log, cpr_log);
2775 kfree(cpr_log);
2776 kfree(buf);
2777}
2778
d633b8a7
DLM		 2779static void ata_dev_print_features(struct ata_device *dev)
2780{
2781 if (!(dev->flags & ATA_DFLAG_FEATURES_MASK))
2782 return;
2783
2784 ata_dev_info(dev,
62e4a60e 2785 "Features:%s%s%s%s%s%s%s%s\n",
4d2e4980 2786 dev->flags & ATA_DFLAG_FUA ? " FUA" : "",
d633b8a7
DLM		 2787 dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "",
2788 dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "",
2789 dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "",
2790 dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "",
fe22e1c2 2791 dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "",
62e4a60e 2792 dev->flags & ATA_DFLAG_CDL ? " CDL" : "",
fe22e1c2 2793 dev->cpr_log ? " CPR" : "");
d633b8a7
DLM		 2794}
2795
49016aca 2796/**
ffeae418 2797 * ata_dev_configure - Configure the specified ATA/ATAPI device
ffeae418
TH		 2798 * @dev: Target device to configure
2799 *
2800 * Configure @dev according to @dev->id. Generic and low-level
2801 * driver specific fixups are also applied.
49016aca
TH		 2802 *
2803 * LOCKING:
ffeae418
TH		 2804 * Kernel thread context (may sleep)
2805 *
2806 * RETURNS:
2807 * 0 on success, -errno otherwise
49016aca 2808 */
efdaedc4 2809int ata_dev_configure(struct ata_device *dev)
49016aca 2810{
9af5c9c9 2811 struct ata_port *ap = dev->link->ap;
891fd7c6 2812 bool print_info = ata_dev_print_info(dev);
1148c3a7 2813 const u16 *id = dev->id;
f0a6d77b 2814 unsigned int xfer_mask;
65fe1f0f 2815 unsigned int err_mask;
b352e57d 2816 char revbuf[7]; /* XYZ-99\0 */
3f64f565
EM		 2817 char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2818 char modelbuf[ATA_ID_PROD_LEN+1];
e6d902a3 2819 int rc;
49016aca 2820
96c810f2
HR		 2821 if (!ata_dev_enabled(dev)) {
2822 ata_dev_dbg(dev, "no device\n");
ffeae418 2823 return 0;
49016aca
TH		 2824 }
2825
75683fe7
TH		 2826 /* set horkage */
2827 dev->horkage |= ata_dev_blacklisted(dev);
33267325 2828 ata_force_horkage(dev);
75683fe7 2829
50af2fa1 2830 if (dev->horkage & ATA_HORKAGE_DISABLE) {
a9a79dfe 2831 ata_dev_info(dev, "unsupported device, disabling\n");
50af2fa1
TH		 2832 ata_dev_disable(dev);
2833 return 0;
2834 }
2835
2486fa56
TH		 2836 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2837 dev->class == ATA_DEV_ATAPI) {
a9a79dfe
JP		 2838 ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2839 atapi_enabled ? "not supported with this driver"
2840 : "disabled");
2486fa56
TH		 2841 ata_dev_disable(dev);
2842 return 0;
2843 }
2844
9062712f
TH		 2845 rc = ata_do_link_spd_horkage(dev);
2846 if (rc)
2847 return rc;
2848
ecd75ad5
TH		 2849 /* some WD SATA-1 drives have issues with LPM, turn on NOLPM for them */
2850 if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2851 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2852 dev->horkage |= ATA_HORKAGE_NOLPM;
2853
240630e6
HG		 2854 if (ap->flags & ATA_FLAG_NO_LPM)
2855 dev->horkage |= ATA_HORKAGE_NOLPM;
2856
ecd75ad5
TH		 2857 if (dev->horkage & ATA_HORKAGE_NOLPM) {
2858 ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2859 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2860 }
2861
6746544c
TH		 2862 /* let ACPI work its magic */
2863 rc = ata_acpi_on_devcfg(dev);
2864 if (rc)
2865 return rc;
08573a86 2866
05027adc
TH		 2867 /* massage HPA, do it early as it might change IDENTIFY data */
2868 rc = ata_hpa_resize(dev);
2869 if (rc)
2870 return rc;
2871
c39f5ebe 2872 /* print device capabilities */
17a1e1be
HR		 2873 ata_dev_dbg(dev,
2874 "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2875 "85:%04x 86:%04x 87:%04x 88:%04x\n",
2876 __func__,
2877 id[49], id[82], id[83], id[84],
2878 id[85], id[86], id[87], id[88]);
c39f5ebe 2879
208a9933 2880 /* initialize to-be-configured parameters */
ea1dd4e1 2881 dev->flags &= ~ATA_DFLAG_CFG_MASK;
208a9933
TH		 2882 dev->max_sectors = 0;
2883 dev->cdb_len = 0;
2884 dev->n_sectors = 0;
2885 dev->cylinders = 0;
2886 dev->heads = 0;
2887 dev->sectors = 0;
e18086d6 2888 dev->multi_count = 0;
208a9933 2889
1da177e4
LT		 2890 /*
2891 * common ATA, ATAPI feature tests
2892 */
2893
ff8854b2 2894 /* find max transfer mode; for printk only */
1148c3a7 2895 xfer_mask = ata_id_xfermask(id);
1da177e4 2896
6044f3c4 2897 ata_dump_id(dev, id);
1da177e4 2898
ef143d57
AL		 2899 /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
2900 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2901 sizeof(fwrevbuf));
2902
2903 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2904 sizeof(modelbuf));
2905
1da177e4 2906 /* ATA-specific feature tests */
9162c657 2907 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
b352e57d 2908 if (ata_id_is_cfa(id)) {
62afe5d7
SS		 2909 /* CPRM may make this media unusable */
2910 if (id[ATA_ID_CFA_KEY_MGMT] & 1)
a9a79dfe
JP		 2911 ata_dev_warn(dev,
2912 "supports DRM functions and may not be fully accessible\n");
b352e57d 2913 snprintf(revbuf, 7, "CFA");
ae8d4ee7 2914 } else {
2dcb407e 2915 snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
ae8d4ee7
AC		 2916 /* Warn the user if the device has TPM extensions */
2917 if (ata_id_has_tpm(id))
a9a79dfe
JP		 2918 ata_dev_warn(dev,
2919 "supports DRM functions and may not be fully accessible\n");
ae8d4ee7 2920 }
b352e57d 2921
1148c3a7 2922 dev->n_sectors = ata_id_n_sectors(id);
2940740b 2923
e18086d6
ML		 2924 /* get current R/W Multiple count setting */
2925 if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2926 unsigned int max = dev->id[47] & 0xff;
2927 unsigned int cnt = dev->id[59] & 0xff;
2928 /* only recognize/allow powers of two here */
2929 if (is_power_of_2(max) && is_power_of_2(cnt))
2930 if (cnt <= max)
2931 dev->multi_count = cnt;
2932 }
3f64f565 2933
891fd7c6 2934 /* print device info to dmesg */
1c95a27c 2935 if (print_info)
891fd7c6
DLM		 2936 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2937 revbuf, modelbuf, fwrevbuf,
2938 ata_mode_string(xfer_mask));
8bf62ece 2939
891fd7c6
DLM		 2940 if (ata_id_has_lba(id)) {
2941 rc = ata_dev_config_lba(dev);
388539f3
SL		 2942 if (rc)
2943 return rc;
ffeae418 2944 } else {
891fd7c6 2945 ata_dev_config_chs(dev);
07f6f7d0
AL		 2946 }
2947
4d2e4980 2948 ata_dev_config_fua(dev);
d8d8778c 2949 ata_dev_config_devslp(dev);
e87fd28c 2950 ata_dev_config_sense_reporting(dev);
6d1003ae 2951 ata_dev_config_zac(dev);
818831c8 2952 ata_dev_config_trusted(dev);
fe22e1c2 2953 ata_dev_config_cpr(dev);
62e4a60e 2954 ata_dev_config_cdl(dev);
b1ffbf85 2955 dev->cdb_len = 32;
d633b8a7 2956
1c95a27c 2957 if (print_info)
d633b8a7 2958 ata_dev_print_features(dev);
1da177e4
LT		 2959 }
2960
2961 /* ATAPI-specific feature tests */
2c13b7ce 2962 else if (dev->class == ATA_DEV_ATAPI) {
854c73a2
TH		 2963 const char *cdb_intr_string = "";
2964 const char *atapi_an_string = "";
91163006 2965 const char *dma_dir_string = "";
7d77b247 2966 u32 sntf;
08a556db 2967
1148c3a7 2968 rc = atapi_cdb_len(id);
1da177e4 2969 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
16d42467 2970 ata_dev_warn(dev, "unsupported CDB len %d\n", rc);
ffeae418 2971 rc = -EINVAL;
1da177e4
LT		 2972 goto err_out_nosup;
2973 }
6e7846e9 2974 dev->cdb_len = (unsigned int) rc;
1da177e4 2975
7d77b247
TH		 2976 /* Enable ATAPI AN if both the host and device have
2977 * the support. If PMP is attached, SNTF is required
2978 * to enable ATAPI AN to discern between PHY status
2979 * changed notifications and ATAPI ANs.
9f45cbd3 2980 */
e7ecd435
TH		 2981 if (atapi_an &&
2982 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
071f44b1 2983 (!sata_pmp_attached(ap) ||
7d77b247 2984 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
9f45cbd3 2985 /* issue SET feature command to turn this on */
218f3d30
JG		 2986 err_mask = ata_dev_set_feature(dev,
2987 SETFEATURES_SATA_ENABLE, SATA_AN);
854c73a2 2988 if (err_mask)
a9a79dfe
JP		 2989 ata_dev_err(dev,
2990 "failed to enable ATAPI AN (err_mask=0x%x)\n",
2991 err_mask);
854c73a2 2992 else {
9f45cbd3 2993 dev->flags |= ATA_DFLAG_AN;
854c73a2
TH		 2994 atapi_an_string = ", ATAPI AN";
2995 }
9f45cbd3
KCA		 2996 }
2997
08a556db 2998 if (ata_id_cdb_intr(dev->id)) {
312f7da2 2999 dev->flags |= ATA_DFLAG_CDB_INTR;
08a556db
AL		 3000 cdb_intr_string = ", CDB intr";
3001 }
312f7da2 3002
966fbe19 3003 if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
91163006
TH		 3004 dev->flags |= ATA_DFLAG_DMADIR;
3005 dma_dir_string = ", DMADIR";
3006 }
3007
afe75951 3008 if (ata_id_has_da(dev->id)) {
b1354cbb 3009 dev->flags |= ATA_DFLAG_DA;
afe75951
AL		 3010 zpodd_init(dev);
3011 }
b1354cbb 3012
1da177e4 3013 /* print device info to dmesg */
1c95a27c 3014 if (print_info)
a9a79dfe
JP		 3015 ata_dev_info(dev,
3016 "ATAPI: %s, %s, max %s%s%s%s\n",
3017 modelbuf, fwrevbuf,
3018 ata_mode_string(xfer_mask),
3019 cdb_intr_string, atapi_an_string,
3020 dma_dir_string);
1da177e4
LT		 3021 }
3022
914ed354
TH		 3023 /* determine max_sectors */
3024 dev->max_sectors = ATA_MAX_SECTORS;
3025 if (dev->flags & ATA_DFLAG_LBA48)
3026 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
3027
c5038fc0
AC		 3028 /* Limit PATA drive on SATA cable bridge transfers to udma5,
3029 200 sectors */
3373efd8 3030 if (ata_dev_knobble(dev)) {
1c95a27c 3031 if (print_info)
a9a79dfe 3032 ata_dev_info(dev, "applying bridge limits\n");
5a529139 3033 dev->udma_mask &= ATA_UDMA5;
4b2f3ede
TH		 3034 dev->max_sectors = ATA_MAX_SECTORS;
3035 }
3036
f8d8e579 3037 if ((dev->class == ATA_DEV_ATAPI) &&
f442cd86 3038 (atapi_command_packet_set(id) == TYPE_TAPE)) {
f8d8e579 3039 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
f442cd86
AL		 3040 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
3041 }
f8d8e579 3042
75683fe7 3043 if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
03ec52de
TH		 3044 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
3045 dev->max_sectors);
18d6e9d5 3046
af34d637
DM		 3047 if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
3048 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
3049 dev->max_sectors);
3050
a32450e1
SH		 3051 if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
3052 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
3053
4b2f3ede 3054 if (ap->ops->dev_config)
cd0d3bbc 3055 ap->ops->dev_config(dev);
4b2f3ede 3056
c5038fc0
AC		 3057 if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
3058 /* Let the user know. We don't want to disallow opens for
3059 rescue purposes, or in case the vendor is just a blithering
3060 idiot. Do this after the dev_config call as some controllers
3061 with buggy firmware may want to avoid reporting false device
3062 bugs */
3063
3064 if (print_info) {
a9a79dfe 3065 ata_dev_warn(dev,
c5038fc0 3066"Drive reports diagnostics failure. This may indicate a drive\n");
a9a79dfe 3067 ata_dev_warn(dev,
c5038fc0
AC		 3068"fault or invalid emulation. Contact drive vendor for information.\n");
3069 }
3070 }
3071
ac70a964 3072 if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
a9a79dfe
JP		 3073 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
3074 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n");
ac70a964
TH		 3075 }
3076
ffeae418 3077 return 0;
1da177e4
LT		 3078
3079err_out_nosup:
ffeae418 3080 return rc;
1da177e4
LT		 3081}
3082
be0d18df 3083/**
2e41e8e6 3084 * ata_cable_40wire - return 40 wire cable type
be0d18df
AC		 3085 * @ap: port
3086 *
2e41e8e6 3087 * Helper method for drivers which want to hardwire 40 wire cable
be0d18df
AC		 3088 * detection.
3089 */
3090
3091int ata_cable_40wire(struct ata_port *ap)
3092{
3093 return ATA_CBL_PATA40;
3094}
a52fbcfc 3095EXPORT_SYMBOL_GPL(ata_cable_40wire);
be0d18df
AC		 3096
3097/**
2e41e8e6 3098 * ata_cable_80wire - return 80 wire cable type
be0d18df
AC		 3099 * @ap: port
3100 *
2e41e8e6 3101 * Helper method for drivers which want to hardwire 80 wire cable
be0d18df
AC		 3102 * detection.
3103 */
3104
3105int ata_cable_80wire(struct ata_port *ap)
3106{
3107 return ATA_CBL_PATA80;
3108}
a52fbcfc 3109EXPORT_SYMBOL_GPL(ata_cable_80wire);
be0d18df
AC		 3110
3111/**
3112 * ata_cable_unknown - return unknown PATA cable.
3113 * @ap: port
3114 *
3115 * Helper method for drivers which have no PATA cable detection.
3116 */
3117
3118int ata_cable_unknown(struct ata_port *ap)
3119{
3120 return ATA_CBL_PATA_UNK;
3121}
a52fbcfc 3122EXPORT_SYMBOL_GPL(ata_cable_unknown);
be0d18df 3123
c88f90c3
TH		 3124/**
3125 * ata_cable_ignore - return ignored PATA cable.
3126 * @ap: port
3127 *
3128 * Helper method for drivers which don't use cable type to limit
3129 * transfer mode.
3130 */
3131int ata_cable_ignore(struct ata_port *ap)
3132{
3133 return ATA_CBL_PATA_IGN;
3134}
a52fbcfc 3135EXPORT_SYMBOL_GPL(ata_cable_ignore);
c88f90c3 3136
be0d18df
AC		 3137/**
3138 * ata_cable_sata - return SATA cable type
3139 * @ap: port
3140 *
3141 * Helper method for drivers which have SATA cables
3142 */
3143
3144int ata_cable_sata(struct ata_port *ap)
3145{
3146 return ATA_CBL_SATA;
3147}
a52fbcfc 3148EXPORT_SYMBOL_GPL(ata_cable_sata);
be0d18df 3149
3be680b7
TH		 3150/**
3151 * sata_print_link_status - Print SATA link status
936fd732 3152 * @link: SATA link to printk link status about
3be680b7
TH		 3153 *
3154 * This function prints link speed and status of a SATA link.
3155 *
3156 * LOCKING:
3157 * None.
3158 */
6bdb4fc9 3159static void sata_print_link_status(struct ata_link *link)
3be680b7 3160{
6d5f9732 3161 u32 sstatus, scontrol, tmp;
3be680b7 3162
936fd732 3163 if (sata_scr_read(link, SCR_STATUS, &sstatus))
3be680b7 3164 return;
55d5ba55
LZ		 3165 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
3166 return;
3be680b7 3167
b1c72916 3168 if (ata_phys_link_online(link)) {
3be680b7 3169 tmp = (sstatus >> 4) & 0xf;
a9a79dfe
JP		 3170 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
3171 sata_spd_string(tmp), sstatus, scontrol);
3be680b7 3172 } else {
a9a79dfe
JP		 3173 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
3174 sstatus, scontrol);
3be680b7
TH		 3175 }
3176}
3177
ebdfca6e
AC		 3178/**
3179 * ata_dev_pair - return other device on cable
ebdfca6e
AC		 3180 * @adev: device
3181 *
3182 * Obtain the other device on the same cable, or if none is
3183 * present NULL is returned
3184 */
2e9edbf8 3185
3373efd8 3186struct ata_device *ata_dev_pair(struct ata_device *adev)
ebdfca6e 3187{
9af5c9c9
TH		 3188 struct ata_link *link = adev->link;
3189 struct ata_device *pair = &link->device[1 - adev->devno];
e1211e3f 3190 if (!ata_dev_enabled(pair))
ebdfca6e
AC		 3191 return NULL;
3192 return pair;
3193}
a52fbcfc 3194EXPORT_SYMBOL_GPL(ata_dev_pair);
ebdfca6e 3195
1c3fae4d 3196/**
3c567b7d 3197 * sata_down_spd_limit - adjust SATA spd limit downward
936fd732 3198 * @link: Link to adjust SATA spd limit for
a07d499b 3199 * @spd_limit: Additional limit
1c3fae4d 3200 *
936fd732 3201 * Adjust SATA spd limit of @link downward. Note that this
1c3fae4d 3202 * function only adjusts the limit. The change must be applied
3c567b7d 3203 * using sata_set_spd().
1c3fae4d 3204 *
a07d499b
TH		 3205 * If @spd_limit is non-zero, the speed is limited to equal to or
3206 * lower than @spd_limit if such speed is supported. If
3207 * @spd_limit is slower than any supported speed, only the lowest
3208 * supported speed is allowed.
3209 *
1c3fae4d
TH		 3210 * LOCKING:
3211 * Inherited from caller.
3212 *
3213 * RETURNS:
3214 * 0 on success, negative errno on failure
3215 */
a07d499b 3216int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
1c3fae4d 3217{
81952c54 3218 u32 sstatus, spd, mask;
a07d499b 3219 int rc, bit;
1c3fae4d 3220
936fd732 3221 if (!sata_scr_valid(link))
008a7896
TH		 3222 return -EOPNOTSUPP;
3223
3224 /* If SCR can be read, use it to determine the current SPD.
936fd732 3225 * If not, use cached value in link->sata_spd.
008a7896 3226 */
936fd732 3227 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
9913ff8a 3228 if (rc == 0 && ata_sstatus_online(sstatus))
008a7896
TH		 3229 spd = (sstatus >> 4) & 0xf;
3230 else
936fd732 3231 spd = link->sata_spd;
1c3fae4d 3232
936fd732 3233 mask = link->sata_spd_limit;
1c3fae4d
TH		 3234 if (mask <= 1)
3235 return -EINVAL;
008a7896
TH		 3236
3237 /* unconditionally mask off the highest bit */
a07d499b
TH		 3238 bit = fls(mask) - 1;
3239 mask &= ~(1 << bit);
1c3fae4d 3240
2dc0b46b
DM		 3241 /*
3242 * Mask off all speeds higher than or equal to the current one. At
3243 * this point, if current SPD is not available and we previously
3244 * recorded the link speed from SStatus, the driver has already
3245 * masked off the highest bit so mask should already be 1 or 0.
3246 * Otherwise, we should not force 1.5Gbps on a link where we have
3247 * not previously recorded speed from SStatus. Just return in this
3248 * case.
008a7896
TH		 3249 */
3250 if (spd > 1)
3251 mask &= (1 << (spd - 1)) - 1;
69f2c934 3252 else if (link->sata_spd)
2dc0b46b 3253 return -EINVAL;
008a7896
TH		 3254
3255 /* were we already at the bottom? */
1c3fae4d
TH		 3256 if (!mask)
3257 return -EINVAL;
3258
a07d499b
TH		 3259 if (spd_limit) {
3260 if (mask & ((1 << spd_limit) - 1))
3261 mask &= (1 << spd_limit) - 1;
3262 else {
3263 bit = ffs(mask) - 1;
3264 mask = 1 << bit;
3265 }
3266 }
3267
936fd732 3268 link->sata_spd_limit = mask;
1c3fae4d 3269
a9a79dfe
JP		 3270 ata_link_warn(link, "limiting SATA link speed to %s\n",
3271 sata_spd_string(fls(mask)));
1c3fae4d
TH		 3272
3273 return 0;
3274}
3275
a9b2c120 3276#ifdef CONFIG_ATA_ACPI
a0f79b92
TH		 3277/**
3278 * ata_timing_cycle2mode - find xfer mode for the specified cycle duration
3279 * @xfer_shift: ATA_SHIFT_* value for transfer type to examine.
3280 * @cycle: cycle duration in ns
3281 *
3282 * Return matching xfer mode for @cycle. The returned mode is of
3283 * the transfer type specified by @xfer_shift. If @cycle is too
3284 * slow for @xfer_shift, 0xff is returned. If @cycle is faster
3285 * than the fastest known mode, the fasted mode is returned.
3286 *
3287 * LOCKING:
3288 * None.
3289 *
3290 * RETURNS:
3291 * Matching xfer_mode, 0xff if no match found.
3292 */
3293u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3294{
3295 u8 base_mode = 0xff, last_mode = 0xff;
3296 const struct ata_xfer_ent *ent;
3297 const struct ata_timing *t;
3298
3299 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3300 if (ent->shift == xfer_shift)
3301 base_mode = ent->base;
3302
3303 for (t = ata_timing_find_mode(base_mode);
3304 t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3305 unsigned short this_cycle;
3306
3307 switch (xfer_shift) {
3308 case ATA_SHIFT_PIO:
3309 case ATA_SHIFT_MWDMA:
3310 this_cycle = t->cycle;
3311 break;
3312 case ATA_SHIFT_UDMA:
3313 this_cycle = t->udma;
3314 break;
3315 default:
3316 return 0xff;
3317 }
3318
3319 if (cycle > this_cycle)
3320 break;
3321
3322 last_mode = t->mode;
3323 }
3324
3325 return last_mode;
3326}
a9b2c120 3327#endif
a0f79b92 3328
cf176e1a
TH		 3329/**
3330 * ata_down_xfermask_limit - adjust dev xfer masks downward
cf176e1a 3331 * @dev: Device to adjust xfer masks
458337db 3332 * @sel: ATA_DNXFER_* selector
cf176e1a
TH		 3333 *
3334 * Adjust xfer masks of @dev downward. Note that this function
3335 * does not apply the change. Invoking ata_set_mode() afterwards
3336 * will apply the limit.
3337 *
3338 * LOCKING:
3339 * Inherited from caller.
3340 *
3341 * RETURNS:
3342 * 0 on success, negative errno on failure
3343 */
458337db 3344int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
cf176e1a 3345{
458337db 3346 char buf[32];
f0a6d77b
SS		 3347 unsigned int orig_mask, xfer_mask;
3348 unsigned int pio_mask, mwdma_mask, udma_mask;
458337db 3349 int quiet, highbit;
cf176e1a 3350
458337db
TH		 3351 quiet = !!(sel & ATA_DNXFER_QUIET);
3352 sel &= ~ATA_DNXFER_QUIET;
cf176e1a 3353
458337db
TH		 3354 xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3355 dev->mwdma_mask,
3356 dev->udma_mask);
3357 ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
cf176e1a 3358
458337db
TH		 3359 switch (sel) {
3360 case ATA_DNXFER_PIO:
3361 highbit = fls(pio_mask) - 1;
3362 pio_mask &= ~(1 << highbit);
3363 break;
3364
3365 case ATA_DNXFER_DMA:
3366 if (udma_mask) {
3367 highbit = fls(udma_mask) - 1;
3368 udma_mask &= ~(1 << highbit);
3369 if (!udma_mask)
3370 return -ENOENT;
3371 } else if (mwdma_mask) {
3372 highbit = fls(mwdma_mask) - 1;
3373 mwdma_mask &= ~(1 << highbit);
3374 if (!mwdma_mask)
3375 return -ENOENT;
3376 }
3377 break;
3378
3379 case ATA_DNXFER_40C:
3380 udma_mask &= ATA_UDMA_MASK_40C;
3381 break;
3382
3383 case ATA_DNXFER_FORCE_PIO0:
3384 pio_mask &= 1;
df561f66 3385 fallthrough;
458337db
TH		 3386 case ATA_DNXFER_FORCE_PIO:
3387 mwdma_mask = 0;
3388 udma_mask = 0;
3389 break;
3390
458337db
TH		 3391 default:
3392 BUG();
3393 }
3394
3395 xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3396
3397 if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3398 return -ENOENT;
3399
3400 if (!quiet) {
3401 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3402 snprintf(buf, sizeof(buf), "%s:%s",
3403 ata_mode_string(xfer_mask),
3404 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3405 else
3406 snprintf(buf, sizeof(buf), "%s",
3407 ata_mode_string(xfer_mask));
3408
a9a79dfe 3409 ata_dev_warn(dev, "limiting speed to %s\n", buf);
458337db 3410 }
cf176e1a
TH		 3411
3412 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3413 &dev->udma_mask);
3414
cf176e1a 3415 return 0;
cf176e1a
TH		 3416}
3417
3373efd8 3418static int ata_dev_set_mode(struct ata_device *dev)
1da177e4 3419{
d0cb43b3 3420 struct ata_port *ap = dev->link->ap;
9af5c9c9 3421 struct ata_eh_context *ehc = &dev->link->eh_context;
d0cb43b3 3422 const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
4055dee7
TH		 3423 const char *dev_err_whine = "";
3424 int ign_dev_err = 0;
d0cb43b3 3425 unsigned int err_mask = 0;
83206a29 3426 int rc;
1da177e4 3427
e8384607 3428 dev->flags &= ~ATA_DFLAG_PIO;
1da177e4
LT		 3429 if (dev->xfer_shift == ATA_SHIFT_PIO)
3430 dev->flags |= ATA_DFLAG_PIO;
3431
d0cb43b3
TH		 3432 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3433 dev_err_whine = " (SET_XFERMODE skipped)";
3434 else {
3435 if (nosetxfer)
a9a79dfe
JP		 3436 ata_dev_warn(dev,
3437 "NOSETXFER but PATA detected - can't "
3438 "skip SETXFER, might malfunction\n");
d0cb43b3
TH		 3439 err_mask = ata_dev_set_xfermode(dev);
3440 }
2dcb407e 3441
4055dee7
TH		 3442 if (err_mask & ~AC_ERR_DEV)
3443 goto fail;
3444
3445 /* revalidate */
3446 ehc->i.flags |= ATA_EHI_POST_SETMODE;
3447 rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3448 ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3449 if (rc)
3450 return rc;
3451
b93fda12
AC		 3452 if (dev->xfer_shift == ATA_SHIFT_PIO) {
3453 /* Old CFA may refuse this command, which is just fine */
3454 if (ata_id_is_cfa(dev->id))
3455 ign_dev_err = 1;
3456 /* Catch several broken garbage emulations plus some pre
3457 ATA devices */
3458 if (ata_id_major_version(dev->id) == 0 &&
3459 dev->pio_mode <= XFER_PIO_2)
3460 ign_dev_err = 1;
3461 /* Some very old devices and some bad newer ones fail
3462 any kind of SET_XFERMODE request but support PIO0-2
3463 timings and no IORDY */
3464 if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3465 ign_dev_err = 1;
3466 }
3acaf94b
AC		 3467 /* Early MWDMA devices do DMA but don't allow DMA mode setting.
3468 Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
c5038fc0 3469 if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3acaf94b
AC		 3470 dev->dma_mode == XFER_MW_DMA_0 &&
3471 (dev->id[63] >> 8) & 1)
4055dee7 3472 ign_dev_err = 1;
3acaf94b 3473
4055dee7
TH		 3474 /* if the device is actually configured correctly, ignore dev err */
3475 if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3476 ign_dev_err = 1;
1da177e4 3477
4055dee7
TH		 3478 if (err_mask & AC_ERR_DEV) {
3479 if (!ign_dev_err)
3480 goto fail;
3481 else
3482 dev_err_whine = " (device error ignored)";
3483 }
48a8a14f 3484
4633778b
HR		 3485 ata_dev_dbg(dev, "xfer_shift=%u, xfer_mode=0x%x\n",
3486 dev->xfer_shift, (int)dev->xfer_mode);
1da177e4 3487
07b9b6d6
DLM		 3488 if (!(ehc->i.flags & ATA_EHI_QUIET) ||
3489 ehc->i.flags & ATA_EHI_DID_HARDRESET)
3490 ata_dev_info(dev, "configured for %s%s\n",
3491 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3492 dev_err_whine);
4055dee7 3493
83206a29 3494 return 0;
4055dee7
TH		 3495
3496 fail:
a9a79dfe 3497 ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
4055dee7 3498 return -EIO;
1da177e4
LT		 3499}
3500
1da177e4 3501/**
04351821 3502 * ata_do_set_mode - Program timings and issue SET FEATURES - XFER
0260731f 3503 * @link: link on which timings will be programmed
1967b7ff 3504 * @r_failed_dev: out parameter for failed device
1da177e4 3505 *
04351821
A		 3506 * Standard implementation of the function used to tune and set
3507 * ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3508 * ata_dev_set_mode() fails, pointer to the failing device is
e82cbdb9 3509 * returned in @r_failed_dev.
780a87f7 3510 *
1da177e4 3511 * LOCKING:
0cba632b 3512 * PCI/etc. bus probe sem.
e82cbdb9
TH		 3513 *
3514 * RETURNS:
3515 * 0 on success, negative errno otherwise
1da177e4 3516 */
04351821 3517
0260731f 3518int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
1da177e4 3519{
0260731f 3520 struct ata_port *ap = link->ap;
e8e0619f 3521 struct ata_device *dev;
f58229f8 3522 int rc = 0, used_dma = 0, found = 0;
3adcebb2 3523
a6d5a51c 3524 /* step 1: calculate xfer_mask */
1eca4365 3525 ata_for_each_dev(dev, link, ENABLED) {
f0a6d77b 3526 unsigned int pio_mask, dma_mask;
b3a70601 3527 unsigned int mode_mask;
a6d5a51c 3528
b3a70601
AC		 3529 mode_mask = ATA_DMA_MASK_ATA;
3530 if (dev->class == ATA_DEV_ATAPI)
3531 mode_mask = ATA_DMA_MASK_ATAPI;
3532 else if (ata_id_is_cfa(dev->id))
3533 mode_mask = ATA_DMA_MASK_CFA;
3534
3373efd8 3535 ata_dev_xfermask(dev);
33267325 3536 ata_force_xfermask(dev);
1da177e4 3537
acf356b1 3538 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
b3a70601
AC		 3539
3540 if (libata_dma_mask & mode_mask)
80a9c430
SS		 3541 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3542 dev->udma_mask);
b3a70601
AC		 3543 else
3544 dma_mask = 0;
3545
acf356b1
TH		 3546 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3547 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
5444a6f4 3548
4f65977d 3549 found = 1;
b15b3eba 3550 if (ata_dma_enabled(dev))
5444a6f4 3551 used_dma = 1;
a6d5a51c 3552 }
4f65977d 3553 if (!found)
e82cbdb9 3554 goto out;
a6d5a51c
TH		 3555
3556 /* step 2: always set host PIO timings */
1eca4365 3557 ata_for_each_dev(dev, link, ENABLED) {
70cd071e 3558 if (dev->pio_mode == 0xff) {
a9a79dfe 3559 ata_dev_warn(dev, "no PIO support\n");
e8e0619f 3560 rc = -EINVAL;
e82cbdb9 3561 goto out;
e8e0619f
TH		 3562 }
3563
3564 dev->xfer_mode = dev->pio_mode;
3565 dev->xfer_shift = ATA_SHIFT_PIO;
3566 if (ap->ops->set_piomode)
3567 ap->ops->set_piomode(ap, dev);
3568 }
1da177e4 3569
a6d5a51c 3570 /* step 3: set host DMA timings */
1eca4365
TH		 3571 ata_for_each_dev(dev, link, ENABLED) {
3572 if (!ata_dma_enabled(dev))
e8e0619f
TH		 3573 continue;
3574
3575 dev->xfer_mode = dev->dma_mode;
3576 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3577 if (ap->ops->set_dmamode)
3578 ap->ops->set_dmamode(ap, dev);
3579 }
1da177e4
LT		 3580
3581 /* step 4: update devices' xfer mode */
1eca4365 3582 ata_for_each_dev(dev, link, ENABLED) {
3373efd8 3583 rc = ata_dev_set_mode(dev);
5bbc53f4 3584 if (rc)
e82cbdb9 3585 goto out;
83206a29 3586 }
1da177e4 3587
e8e0619f
TH		 3588 /* Record simplex status. If we selected DMA then the other
3589 * host channels are not permitted to do so.
5444a6f4 3590 */
cca3974e 3591 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
032af1ce 3592 ap->host->simplex_claimed = ap;
5444a6f4 3593
e82cbdb9
TH		 3594 out:
3595 if (rc)
3596 *r_failed_dev = dev;
3597 return rc;
1da177e4 3598}
a52fbcfc 3599EXPORT_SYMBOL_GPL(ata_do_set_mode);
1da177e4 3600
aa2731ad
TH		 3601/**
3602 * ata_wait_ready - wait for link to become ready
3603 * @link: link to be waited on
3604 * @deadline: deadline jiffies for the operation
3605 * @check_ready: callback to check link readiness
3606 *
3607 * Wait for @link to become ready. @check_ready should return
3608 * positive number if @link is ready, 0 if it isn't, -ENODEV if
3609 * link doesn't seem to be occupied, other errno for other error
3610 * conditions.
3611 *
3612 * Transient -ENODEV conditions are allowed for
3613 * ATA_TMOUT_FF_WAIT.
3614 *
3615 * LOCKING:
3616 * EH context.
3617 *
3618 * RETURNS:
c9b5560a 3619 * 0 if @link is ready before @deadline; otherwise, -errno.
aa2731ad
TH		 3620 */
3621int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3622 int (*check_ready)(struct ata_link *link))
3623{
3624 unsigned long start = jiffies;
b48d58f5 3625 unsigned long nodev_deadline;
aa2731ad
TH		 3626 int warned = 0;
3627
b48d58f5
TH		 3628 /* choose which 0xff timeout to use, read comment in libata.h */
3629 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3630 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3631 else
3632 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3633
b1c72916
TH		 3634 /* Slave readiness can't be tested separately from master. On
3635 * M/S emulation configuration, this function should be called
3636 * only on the master and it will handle both master and slave.
3637 */
3638 WARN_ON(link == link->ap->slave_link);
3639
aa2731ad
TH		 3640 if (time_after(nodev_deadline, deadline))
3641 nodev_deadline = deadline;
3642
3643 while (1) {
3644 unsigned long now = jiffies;
3645 int ready, tmp;
3646
3647 ready = tmp = check_ready(link);
3648 if (ready > 0)
3649 return 0;
3650
b48d58f5
TH		 3651 /*
3652 * -ENODEV could be transient. Ignore -ENODEV if link
aa2731ad 3653 * is online. Also, some SATA devices take a long
b48d58f5
TH		 3654 * time to clear 0xff after reset. Wait for
3655 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3656 * offline.
aa2731ad
TH		 3657 *
3658 * Note that some PATA controllers (pata_ali) explode
3659 * if status register is read more than once when
3660 * there's no device attached.
3661 */
3662 if (ready == -ENODEV) {
3663 if (ata_link_online(link))
3664 ready = 0;
3665 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3666 !ata_link_offline(link) &&
3667 time_before(now, nodev_deadline))
3668 ready = 0;
3669 }
3670
3671 if (ready)
3672 return ready;
3673 if (time_after(now, deadline))
3674 return -EBUSY;
3675
3676 if (!warned && time_after(now, start + 5 * HZ) &&
3677 (deadline - now > 3 * HZ)) {
a9a79dfe 3678 ata_link_warn(link,
aa2731ad
TH		 3679 "link is slow to respond, please be patient "
3680 "(ready=%d)\n", tmp);
3681 warned = 1;
3682 }
3683
97750ceb 3684 ata_msleep(link->ap, 50);
aa2731ad
TH		 3685 }
3686}
3687
3688/**
3689 * ata_wait_after_reset - wait for link to become ready after reset
3690 * @link: link to be waited on
3691 * @deadline: deadline jiffies for the operation
3692 * @check_ready: callback to check link readiness
3693 *
3694 * Wait for @link to become ready after reset.
3695 *
3696 * LOCKING:
3697 * EH context.
3698 *
3699 * RETURNS:
c9b5560a 3700 * 0 if @link is ready before @deadline; otherwise, -errno.
aa2731ad 3701 */
2b4221bb 3702int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
aa2731ad
TH		 3703 int (*check_ready)(struct ata_link *link))
3704{
97750ceb 3705 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
aa2731ad
TH		 3706
3707 return ata_wait_ready(link, deadline, check_ready);
3708}
a52fbcfc 3709EXPORT_SYMBOL_GPL(ata_wait_after_reset);
aa2731ad 3710
f5914a46 3711/**
0aa1113d 3712 * ata_std_prereset - prepare for reset
cc0680a5 3713 * @link: ATA link to be reset
d4b2bab4 3714 * @deadline: deadline jiffies for the operation
f5914a46 3715 *
cc0680a5 3716 * @link is about to be reset. Initialize it. Failure from
b8cffc6a
TH		 3717 * prereset makes libata abort whole reset sequence and give up
3718 * that port, so prereset should be best-effort. It does its
3719 * best to prepare for reset sequence but if things go wrong, it
3720 * should just whine, not fail.
f5914a46
TH		 3721 *
3722 * LOCKING:
3723 * Kernel thread context (may sleep)
3724 *
3725 * RETURNS:
ac1eb665 3726 * Always 0.
f5914a46 3727 */
0aa1113d 3728int ata_std_prereset(struct ata_link *link, unsigned long deadline)
f5914a46 3729{
cc0680a5 3730 struct ata_port *ap = link->ap;
936fd732 3731 struct ata_eh_context *ehc = &link->eh_context;
d14d41cc 3732 const unsigned int *timing = sata_ehc_deb_timing(ehc);
f5914a46
TH		 3733 int rc;
3734
f5914a46
TH		 3735 /* if we're about to do hardreset, nothing more to do */
3736 if (ehc->i.action & ATA_EH_HARDRESET)
3737 return 0;
3738
936fd732 3739 /* if SATA, resume link */
a16abc0b 3740 if (ap->flags & ATA_FLAG_SATA) {
936fd732 3741 rc = sata_link_resume(link, timing, deadline);
b8cffc6a
TH		 3742 /* whine about phy resume failure but proceed */
3743 if (rc && rc != -EOPNOTSUPP)
a9a79dfe
JP		 3744 ata_link_warn(link,
3745 "failed to resume link for reset (errno=%d)\n",
3746 rc);
f5914a46
TH		 3747 }
3748
45db2f6c 3749 /* no point in trying softreset on offline link */
b1c72916 3750 if (ata_phys_link_offline(link))
45db2f6c
TH		 3751 ehc->i.action &= ~ATA_EH_SOFTRESET;
3752
f5914a46
TH		 3753 return 0;
3754}
a52fbcfc 3755EXPORT_SYMBOL_GPL(ata_std_prereset);
f5914a46 3756
57c9efdf
TH		 3757/**
3758 * sata_std_hardreset - COMRESET w/o waiting or classification
3759 * @link: link to reset
3760 * @class: resulting class of attached device
3761 * @deadline: deadline jiffies for the operation
3762 *
3763 * Standard SATA COMRESET w/o waiting or classification.
3764 *
3765 * LOCKING:
3766 * Kernel thread context (may sleep)
3767 *
3768 * RETURNS:
3769 * 0 if link offline, -EAGAIN if link online, -errno on errors.
3770 */
3771int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3772 unsigned long deadline)
3773{
d14d41cc 3774 const unsigned int *timing = sata_ehc_deb_timing(&link->eh_context);
57c9efdf
TH		 3775 bool online;
3776 int rc;
3777
3778 /* do hardreset */
3779 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
57c9efdf
TH		 3780 return online ? -EAGAIN : rc;
3781}
a52fbcfc 3782EXPORT_SYMBOL_GPL(sata_std_hardreset);
57c9efdf 3783
c2bd5804 3784/**
203c75b8 3785 * ata_std_postreset - standard postreset callback
cc0680a5 3786 * @link: the target ata_link
c2bd5804
TH		 3787 * @classes: classes of attached devices
3788 *
3789 * This function is invoked after a successful reset. Note that
3790 * the device might have been reset more than once using
3791 * different reset methods before postreset is invoked.
c2bd5804 3792 *
c2bd5804
TH		 3793 * LOCKING:
3794 * Kernel thread context (may sleep)
3795 */
203c75b8 3796void ata_std_postreset(struct ata_link *link, unsigned int *classes)
c2bd5804 3797{
f046519f
TH		 3798 u32 serror;
3799
f046519f
TH		 3800 /* reset complete, clear SError */
3801 if (!sata_scr_read(link, SCR_ERROR, &serror))
3802 sata_scr_write(link, SCR_ERROR, serror);
3803
c2bd5804 3804 /* print link status */
936fd732 3805 sata_print_link_status(link);
c2bd5804 3806}
a52fbcfc 3807EXPORT_SYMBOL_GPL(ata_std_postreset);
c2bd5804 3808
623a3128
TH		 3809/**
3810 * ata_dev_same_device - Determine whether new ID matches configured device
623a3128
TH		 3811 * @dev: device to compare against
3812 * @new_class: class of the new device
3813 * @new_id: IDENTIFY page of the new device
3814 *
3815 * Compare @new_class and @new_id against @dev and determine
3816 * whether @dev is the device indicated by @new_class and
3817 * @new_id.
3818 *
3819 * LOCKING:
3820 * None.
3821 *
3822 * RETURNS:
3823 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
3824 */
3373efd8
TH		 3825static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3826 const u16 *new_id)
623a3128
TH		 3827{
3828 const u16 *old_id = dev->id;
a0cf733b
TH		 3829 unsigned char model[2][ATA_ID_PROD_LEN + 1];
3830 unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
623a3128
TH		 3831
3832 if (dev->class != new_class) {
a9a79dfe
JP		 3833 ata_dev_info(dev, "class mismatch %d != %d\n",
3834 dev->class, new_class);
623a3128
TH		 3835 return 0;
3836 }
3837
a0cf733b
TH		 3838 ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3839 ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3840 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3841 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
623a3128
TH		 3842
3843 if (strcmp(model[0], model[1])) {
a9a79dfe
JP		 3844 ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
3845 model[0], model[1]);
623a3128
TH		 3846 return 0;
3847 }
3848
3849 if (strcmp(serial[0], serial[1])) {
a9a79dfe
JP		 3850 ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
3851 serial[0], serial[1]);
623a3128
TH		 3852 return 0;
3853 }
3854
623a3128
TH		 3855 return 1;
3856}
3857
3858/**
fe30911b 3859 * ata_dev_reread_id - Re-read IDENTIFY data
3fae450c 3860 * @dev: target ATA device
bff04647 3861 * @readid_flags: read ID flags
623a3128
TH		 3862 *
3863 * Re-read IDENTIFY page and make sure @dev is still attached to
3864 * the port.
3865 *
3866 * LOCKING:
3867 * Kernel thread context (may sleep)
3868 *
3869 * RETURNS:
3870 * 0 on success, negative errno otherwise
3871 */
fe30911b 3872int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
623a3128 3873{
5eb45c02 3874 unsigned int class = dev->class;
9af5c9c9 3875 u16 *id = (void *)dev->link->ap->sector_buf;
623a3128
TH		 3876 int rc;
3877
fe635c7e 3878 /* read ID data */
bff04647 3879 rc = ata_dev_read_id(dev, &class, readid_flags, id);
623a3128 3880 if (rc)
fe30911b 3881 return rc;
623a3128
TH		 3882
3883 /* is the device still there? */
fe30911b
TH		 3884 if (!ata_dev_same_device(dev, class, id))
3885 return -ENODEV;
623a3128 3886
fe635c7e 3887 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
fe30911b
TH		 3888 return 0;
3889}
3890
3891/**
3892 * ata_dev_revalidate - Revalidate ATA device
3893 * @dev: device to revalidate
422c9daa 3894 * @new_class: new class code
fe30911b
TH		 3895 * @readid_flags: read ID flags
3896 *
3897 * Re-read IDENTIFY page, make sure @dev is still attached to the
3898 * port and reconfigure it according to the new IDENTIFY page.
3899 *
3900 * LOCKING:
3901 * Kernel thread context (may sleep)
3902 *
3903 * RETURNS:
3904 * 0 on success, negative errno otherwise
3905 */
422c9daa
TH		 3906int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
3907 unsigned int readid_flags)
fe30911b 3908{
6ddcd3b0 3909 u64 n_sectors = dev->n_sectors;
5920dadf 3910 u64 n_native_sectors = dev->n_native_sectors;
fe30911b
TH		 3911 int rc;
3912
3913 if (!ata_dev_enabled(dev))
3914 return -ENODEV;
3915
422c9daa 3916 /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
12e2e17d 3917 if (ata_class_enabled(new_class) && new_class == ATA_DEV_PMP) {
a9a79dfe
JP		 3918 ata_dev_info(dev, "class mismatch %u != %u\n",
3919 dev->class, new_class);
422c9daa
TH		 3920 rc = -ENODEV;
3921 goto fail;
3922 }
3923
fe30911b
TH		 3924 /* re-read ID */
3925 rc = ata_dev_reread_id(dev, readid_flags);
3926 if (rc)
3927 goto fail;
623a3128
TH		 3928
3929 /* configure device according to the new ID */
efdaedc4 3930 rc = ata_dev_configure(dev);
6ddcd3b0
TH		 3931 if (rc)
3932 goto fail;
3933
3934 /* verify n_sectors hasn't changed */
445d211b
TH		 3935 if (dev->class != ATA_DEV_ATA || !n_sectors ||
3936 dev->n_sectors == n_sectors)
3937 return 0;
3938
3939 /* n_sectors has changed */
a9a79dfe
JP		 3940 ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
3941 (unsigned long long)n_sectors,
3942 (unsigned long long)dev->n_sectors);
445d211b
TH		 3943
3944 /*
3945 * Something could have caused HPA to be unlocked
3946 * involuntarily. If n_native_sectors hasn't changed and the
3947 * new size matches it, keep the device.
3948 */
3949 if (dev->n_native_sectors == n_native_sectors &&
3950 dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
a9a79dfe
JP		 3951 ata_dev_warn(dev,
3952 "new n_sectors matches native, probably "
3953 "late HPA unlock, n_sectors updated\n");
68939ce5 3954 /* use the larger n_sectors */
445d211b 3955 return 0;
6ddcd3b0
TH		 3956 }
3957
445d211b
TH		 3958 /*
3959 * Some BIOSes boot w/o HPA but resume w/ HPA locked. Try
3960 * unlocking HPA in those cases.
3961 *
3962 * https://bugzilla.kernel.org/show_bug.cgi?id=15396
3963 */
3964 if (dev->n_native_sectors == n_native_sectors &&
3965 dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
3966 !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
a9a79dfe
JP		 3967 ata_dev_warn(dev,
3968 "old n_sectors matches native, probably "
3969 "late HPA lock, will try to unlock HPA\n");
445d211b
TH		 3970 /* try unlocking HPA */
3971 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
3972 rc = -EIO;
3973 } else
3974 rc = -ENODEV;
623a3128 3975
445d211b
TH		 3976 /* restore original n_[native_]sectors and fail */
3977 dev->n_native_sectors = n_native_sectors;
3978 dev->n_sectors = n_sectors;
623a3128 3979 fail:
a9a79dfe 3980 ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
623a3128
TH		 3981 return rc;
3982}
3983
6919a0a6
AC		 3984struct ata_blacklist_entry {
3985 const char *model_num;
3986 const char *model_rev;
3987 unsigned long horkage;
3988};
3989
3990static const struct ata_blacklist_entry ata_device_blacklist [] = {
3991 /* Devices with DMA related problems under Linux */
3992 { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA },
3993 { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA },
3994 { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA },
3995 { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA },
3996 { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA },
3997 { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA },
3998 { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA },
3999 { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA },
4000 { "CRD-8400B", NULL, ATA_HORKAGE_NODMA },
7da4c935 4001 { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4002 { "CRD-84", NULL, ATA_HORKAGE_NODMA },
4003 { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA },
4004 { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
4005 { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA },
4006 { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA },
7da4c935 4007 { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4008 { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA },
4009 { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA },
4010 { "CD-532E-A", NULL, ATA_HORKAGE_NODMA },
4011 { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA },
4012 { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA },
4013 { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
4014 { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
4015 { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4016 { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
4017 { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
2dcb407e 4018 { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA },
39f19886 4019 { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA },
d17d794c 4020 { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA },
b00622fc 4021 { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3af9a77a 4022 /* Odd clown on sil3726/4726 PMPs */
50af2fa1 4023 { "Config Disk", NULL, ATA_HORKAGE_DISABLE },
a66307d4
HR		 4024 /* Similar story with ASMedia 1092 */
4025 { "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE },
6919a0a6 4026
18d6e9d5 4027 /* Weird ATAPI devices */
40a1d531 4028 { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },
6a87e42e 4029 { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA },
a32450e1 4030 { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
0523f037 4031 { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
18d6e9d5 4032
af34d637
DM		 4033 /*
4034 * Causes silent data corruption with higher max sects.
4035 * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
4036 */
4037 { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 },
1488a1e3
TH		 4038
4039 /*
e0edc8c5 4040 * These devices time out with higher max sects.
1488a1e3
TH		 4041 * https://bugzilla.kernel.org/show_bug.cgi?id=121671
4042 */
e0edc8c5 4043 { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 },
db5ff909 4044 { "LITEON EP1-*", NULL, ATA_HORKAGE_MAX_SEC_1024 },
af34d637 4045
6919a0a6
AC		 4046 /* Devices we expect to fail diagnostics */
4047
4048 /* Devices where NCQ should be avoided */
4049 /* NCQ is slow */
2dcb407e 4050 { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
ef1429c0 4051 { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ },
09125ea6
TH		 4052 /* http://thread.gmane.org/gmane.linux.ide/14907 */
4053 { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
7acfaf30 4054 /* NCQ is broken */
539cc7c7 4055 { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ },
0e3dbc01 4056 { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ },
da6f0ec2 4057 { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ },
e41bd3e8 4058 { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ },
5ccfca97 4059 { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ },
539cc7c7 4060
ac70a964 4061 /* Seagate NCQ + FLUSH CACHE firmware bug */
4d1f9082 4062 { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
ac70a964 4063 ATA_HORKAGE_FIRMWARE_WARN },
d10d491f 4064
4d1f9082 4065 { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
d10d491f
TH		 4066 ATA_HORKAGE_FIRMWARE_WARN },
4067
4d1f9082 4068 { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
d10d491f
TH		 4069 ATA_HORKAGE_FIRMWARE_WARN },
4070
4d1f9082 4071 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
ac70a964
TH		 4072 ATA_HORKAGE_FIRMWARE_WARN },
4073
31f6264e
HG		 4074 /* drives which fail FPDMA_AA activation (some may freeze afterwards)
4075 the ST disks also have LPM issues */
8756a25b 4076 { "ST1000LM024 HN-M101MBB", NULL, ATA_HORKAGE_BROKEN_FPDMA_AA |
ef1429c0 4077 ATA_HORKAGE_NOLPM },
08c85d2a 4078 { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
87809942 4079
36e337d0
RH		 4080 /* Blacklist entries taken from Silicon Image 3124/3132
4081 Windows driver .inf file - also several Linux problem reports */
ef1429c0
DLM		 4082 { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ },
4083 { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ },
4084 { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ },
6919a0a6 4085
68b0ddb2 4086 /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */
ef1429c0 4087 { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ },
68b0ddb2 4088
3b545563 4089 /* Sandisk SD7/8/9s lock up hard on large trims */
ef1429c0 4090 { "SanDisk SD[789]*", NULL, ATA_HORKAGE_MAX_TRIM_128M },
322579dc 4091
16c55b03 4092 /* devices which puke on READ_NATIVE_MAX */
ef1429c0 4093 { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA },
16c55b03
TH		 4094 { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
4095 { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
4096 { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA },
6919a0a6 4097
7831387b
TH		 4098 /* this one allows HPA unlocking but fails IOs on the area */
4099 { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA },
4100
93328e11 4101 /* Devices which report 1 sector over size HPA */
ef1429c0
DLM		 4102 { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE },
4103 { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE },
4104 { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE },
93328e11 4105
6bbfd53d 4106 /* Devices which get the IVB wrong */
ef1429c0 4107 { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB },
a79067e5 4108 /* Maybe we should just blacklist TSSTcorp... */
ef1429c0 4109 { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB },
6bbfd53d 4110
9ce8e307 4111 /* Devices that do not need bridging limits applied */
ef1429c0
DLM		 4112 { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK },
4113 { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK },
9ce8e307 4114
9062712f 4115 /* Devices which aren't very happy with higher link speeds */
ef1429c0
DLM		 4116 { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS },
4117 { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS },
9062712f 4118
d0cb43b3
TH		 4119 /*
4120 * Devices which choke on SETXFER. Applies only if both the
4121 * device and controller are SATA.
4122 */
cd691876 4123 { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER },
3a25179e
VL		 4124 { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER },
4125 { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER },
cd691876
TH		 4126 { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
4127 { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
d0cb43b3 4128
ea08aec7
NC		 4129 /* These specific Pioneer models have LPM issues */
4130 { "PIONEER BD-RW BDR-207M", NULL, ATA_HORKAGE_NOLPM },
4131 { "PIONEER BD-RW BDR-205", NULL, ATA_HORKAGE_NOLPM },
4132
b17e5729 4133 /* Crucial BX100 SSD 500GB has broken LPM support */
3bf7b5d6 4134 { "CT500BX100SSD1", NULL, ATA_HORKAGE_NOLPM },
b17e5729 4135
d418ff56
HG		 4136 /* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */
4137 { "Crucial_CT512MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
9c7be59f 4138 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4139 ATA_HORKAGE_NOLPM },
d418ff56
HG		 4140 /* 512GB MX100 with newer firmware has only LPM issues */
4141 { "Crucial_CT512MX100*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4142 ATA_HORKAGE_NOLPM },
9c7be59f 4143
62ac3f73
HG		 4144 /* 480GB+ M500 SSDs have both queued TRIM and LPM issues */
4145 { "Crucial_CT480M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4146 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4147 ATA_HORKAGE_NOLPM },
62ac3f73
HG		 4148 { "Crucial_CT960M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4149 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4150 ATA_HORKAGE_NOLPM },
62ac3f73 4151
76936e9a 4152 /* These specific Samsung models/firmware-revs do not handle LPM well */
ef1429c0
DLM		 4153 { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM },
4154 { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_HORKAGE_NOLPM },
4155 { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_HORKAGE_NOLPM },
4156 { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM },
b5b4d3a5 4157
f78dea06 4158 /* devices that don't properly handle queued TRIM commands */
136d769e 4159 { "Micron_M500IT_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4160 ATA_HORKAGE_ZERO_AFTER_TRIM },
243918be 4161 { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4162 ATA_HORKAGE_ZERO_AFTER_TRIM },
9051bd39 4163 { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4164 ATA_HORKAGE_ZERO_AFTER_TRIM },
27fd0710
PZ		 4165 { "Micron_1100_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4166 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4167 { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4168 ATA_HORKAGE_ZERO_AFTER_TRIM },
ff7f53fb 4169 { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4170 ATA_HORKAGE_ZERO_AFTER_TRIM },
ff7f53fb 4171 { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4172 ATA_HORKAGE_ZERO_AFTER_TRIM },
53997522
CL		 4173 { "Samsung SSD 840 EVO*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4174 ATA_HORKAGE_NO_DMA_LOG |
ef1429c0 4175 ATA_HORKAGE_ZERO_AFTER_TRIM },
ca6bfcb2 4176 { "Samsung SSD 840*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4177 ATA_HORKAGE_ZERO_AFTER_TRIM },
ca6bfcb2 4178 { "Samsung SSD 850*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4179 ATA_HORKAGE_ZERO_AFTER_TRIM },
8a6430ab 4180 { "Samsung SSD 860*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
7a8526a5 4181 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4182 ATA_HORKAGE_NO_NCQ_ON_ATI },
8a6430ab 4183 { "Samsung SSD 870*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
7a8526a5 4184 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4185 ATA_HORKAGE_NO_NCQ_ON_ATI },
ead08957
PM		 4186 { "SAMSUNG*MZ7LH*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4187 ATA_HORKAGE_ZERO_AFTER_TRIM |
4188 ATA_HORKAGE_NO_NCQ_ON_ATI, },
7a7184b0 4189 { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4190 ATA_HORKAGE_ZERO_AFTER_TRIM },
e61f7d1c 4191
cda57b1b 4192 /* devices that don't properly handle TRIM commands */
ef1429c0
DLM		 4193 { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM },
4194 { "M88V29*", NULL, ATA_HORKAGE_NOTRIM },
cda57b1b 4195
e61f7d1c
MP		 4196 /*
4197 * As defined, the DRAT (Deterministic Read After Trim) and RZAT
4198 * (Return Zero After Trim) flags in the ATA Command Set are
4199 * unreliable in the sense that they only define what happens if
4200 * the device successfully executed the DSM TRIM command. TRIM
4201 * is only advisory, however, and the device is free to silently
4202 * ignore all or parts of the request.
4203 *
4204 * Whitelist drives that are known to reliably return zeroes
4205 * after TRIM.
4206 */
4207
4208 /*
4209 * The intel 510 drive has buggy DRAT/RZAT. Explicitly exclude
4210 * that model before whitelisting all other intel SSDs.
4211 */
ef1429c0
DLM		 4212 { "INTEL*SSDSC2MH*", NULL, 0 },
4213
4214 { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4215 { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4216 { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4217 { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4218 { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4219 { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4220 { "SAMSUNG*MZ7KM*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4221 { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
f78dea06 4222
ecd75ad5
TH		 4223 /*
4224 * Some WD SATA-I drives spin up and down erratically when the link
4225 * is put into the slumber mode. We don't have full list of the
4226 * affected devices. Disable LPM if the device matches one of the
4227 * known prefixes and is SATA-1. As a side effect LPM partial is
4228 * lost too.
4229 *
4230 * https://bugzilla.kernel.org/show_bug.cgi?id=57211
4231 */
4232 { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4233 { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4234 { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4235 { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4236 { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4237 { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4238 { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4239
ac9f0c81
AL		 4240 /*
4241 * This sata dom device goes on a walkabout when the ATA_LOG_DIRECTORY
4242 * log page is accessed. Ensure we never ask for this log page with
4243 * these devices.
4244 */
4245 { "SATADOM-ML 3ME", NULL, ATA_HORKAGE_NO_LOG_DIR },
4246
4d2e4980
DLM		 4247 /* Buggy FUA */
4248 { "Maxtor", "BANC1G10", ATA_HORKAGE_NO_FUA },
38d43122
DLM		 4249 { "WDC*WD2500J*", NULL, ATA_HORKAGE_NO_FUA },
4250 { "OCZ-VERTEX*", NULL, ATA_HORKAGE_NO_FUA },
4251 { "INTEL*SSDSC2CT*", NULL, ATA_HORKAGE_NO_FUA },
4d2e4980 4252
6919a0a6
AC		 4253 /* End Marker */
4254 { }
1da177e4 4255};
2e9edbf8 4256
75683fe7 4257static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
1da177e4 4258{
8bfa79fc
TH		 4259 unsigned char model_num[ATA_ID_PROD_LEN + 1];
4260 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
6919a0a6 4261 const struct ata_blacklist_entry *ad = ata_device_blacklist;
3a778275 4262
8bfa79fc
TH		 4263 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4264 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
1da177e4 4265
6919a0a6 4266 while (ad->model_num) {
1c402799 4267 if (glob_match(ad->model_num, model_num)) {
6919a0a6
AC		 4268 if (ad->model_rev == NULL)
4269 return ad->horkage;
1c402799 4270 if (glob_match(ad->model_rev, model_rev))
6919a0a6 4271 return ad->horkage;
f4b15fef 4272 }
6919a0a6 4273 ad++;
f4b15fef 4274 }
1da177e4
LT		 4275 return 0;
4276}
4277
6919a0a6
AC		 4278static int ata_dma_blacklisted(const struct ata_device *dev)
4279{
4280 /* We don't support polling DMA.
4281 * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
4282 * if the LLDD handles only interrupts in the HSM_ST_LAST state.
4283 */
9af5c9c9 4284 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
6919a0a6
AC		 4285 (dev->flags & ATA_DFLAG_CDB_INTR))
4286 return 1;
75683fe7 4287 return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
6919a0a6
AC		 4288}
4289
6bbfd53d
AC		 4290/**
4291 * ata_is_40wire - check drive side detection
4292 * @dev: device
4293 *
4294 * Perform drive side detection decoding, allowing for device vendors
4295 * who can't follow the documentation.
4296 */
4297
4298static int ata_is_40wire(struct ata_device *dev)
4299{
4300 if (dev->horkage & ATA_HORKAGE_IVB)
4301 return ata_drive_40wire_relaxed(dev->id);
4302 return ata_drive_40wire(dev->id);
4303}
4304
15a5551c
AC		 4305/**
4306 * cable_is_40wire - 40/80/SATA decider
4307 * @ap: port to consider
4308 *
4309 * This function encapsulates the policy for speed management
4310 * in one place. At the moment we don't cache the result but
4311 * there is a good case for setting ap->cbl to the result when
4312 * we are called with unknown cables (and figuring out if it
4313 * impacts hotplug at all).
4314 *
4315 * Return 1 if the cable appears to be 40 wire.
4316 */
4317
4318static int cable_is_40wire(struct ata_port *ap)
4319{
4320 struct ata_link *link;
4321 struct ata_device *dev;
4322
4a9c7b33 4323 /* If the controller thinks we are 40 wire, we are. */
15a5551c
AC		 4324 if (ap->cbl == ATA_CBL_PATA40)
4325 return 1;
4a9c7b33
TH		 4326
4327 /* If the controller thinks we are 80 wire, we are. */
15a5551c
AC		 4328 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4329 return 0;
4a9c7b33
TH		 4330
4331 /* If the system is known to be 40 wire short cable (eg
4332 * laptop), then we allow 80 wire modes even if the drive
4333 * isn't sure.
4334 */
f792068e
AC		 4335 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4336 return 0;
4a9c7b33
TH		 4337
4338 /* If the controller doesn't know, we scan.
4339 *
4340 * Note: We look for all 40 wire detects at this point. Any
4341 * 80 wire detect is taken to be 80 wire cable because
4342 * - in many setups only the one drive (slave if present) will
4343 * give a valid detect
4344 * - if you have a non detect capable drive you don't want it
4345 * to colour the choice
4346 */
1eca4365
TH		 4347 ata_for_each_link(link, ap, EDGE) {
4348 ata_for_each_dev(dev, link, ENABLED) {
4349 if (!ata_is_40wire(dev))
15a5551c
AC		 4350 return 0;
4351 }
4352 }
4353 return 1;
4354}
4355
a6d5a51c
TH		 4356/**
4357 * ata_dev_xfermask - Compute supported xfermask of the given device
a6d5a51c
TH		 4358 * @dev: Device to compute xfermask for
4359 *
acf356b1
TH		 4360 * Compute supported xfermask of @dev and store it in
4361 * dev->*_mask. This function is responsible for applying all
4362 * known limits including host controller limits, device
4363 * blacklist, etc...
a6d5a51c
TH		 4364 *
4365 * LOCKING:
4366 * None.
a6d5a51c 4367 */
3373efd8 4368static void ata_dev_xfermask(struct ata_device *dev)
1da177e4 4369{
9af5c9c9
TH		 4370 struct ata_link *link = dev->link;
4371 struct ata_port *ap = link->ap;
cca3974e 4372 struct ata_host *host = ap->host;
f0a6d77b 4373 unsigned int xfer_mask;
1da177e4 4374
37deecb5 4375 /* controller modes available */
565083e1
TH		 4376 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4377 ap->mwdma_mask, ap->udma_mask);
4378
8343f889 4379 /* drive modes available */
37deecb5
TH		 4380 xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4381 dev->mwdma_mask, dev->udma_mask);
4382 xfer_mask &= ata_id_xfermask(dev->id);
565083e1 4383
b352e57d
AC		 4384 /*
4385 * CFA Advanced TrueIDE timings are not allowed on a shared
4386 * cable
4387 */
4388 if (ata_dev_pair(dev)) {
4389 /* No PIO5 or PIO6 */
4390 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4391 /* No MWDMA3 or MWDMA 4 */
4392 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4393 }
4394
37deecb5
TH		 4395 if (ata_dma_blacklisted(dev)) {
4396 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
a9a79dfe
JP		 4397 ata_dev_warn(dev,
4398 "device is on DMA blacklist, disabling DMA\n");
37deecb5 4399 }
a6d5a51c 4400
14d66ab7 4401 if ((host->flags & ATA_HOST_SIMPLEX) &&
2dcb407e 4402 host->simplex_claimed && host->simplex_claimed != ap) {
37deecb5 4403 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
a9a79dfe
JP		 4404 ata_dev_warn(dev,
4405 "simplex DMA is claimed by other device, disabling DMA\n");
5444a6f4 4406 }
565083e1 4407
e424675f
JG		 4408 if (ap->flags & ATA_FLAG_NO_IORDY)
4409 xfer_mask &= ata_pio_mask_no_iordy(dev);
4410
5444a6f4 4411 if (ap->ops->mode_filter)
a76b62ca 4412 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
5444a6f4 4413
8343f889
RH		 4414 /* Apply cable rule here. Don't apply it early because when
4415 * we handle hot plug the cable type can itself change.
4416 * Check this last so that we know if the transfer rate was
4417 * solely limited by the cable.
4418 * Unknown or 80 wire cables reported host side are checked
4419 * drive side as well. Cases where we know a 40wire cable
4420 * is used safely for 80 are not checked here.
4421 */
4422 if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4423 /* UDMA/44 or higher would be available */
15a5551c 4424 if (cable_is_40wire(ap)) {
a9a79dfe
JP		 4425 ata_dev_warn(dev,
4426 "limited to UDMA/33 due to 40-wire cable\n");
8343f889
RH		 4427 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4428 }
4429
565083e1
TH		 4430 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4431 &dev->mwdma_mask, &dev->udma_mask);
1da177e4
LT		 4432}
4433
1da177e4
LT		 4434/**
4435 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
1da177e4
LT		 4436 * @dev: Device to which command will be sent
4437 *
780a87f7
JG		 4438 * Issue SET FEATURES - XFER MODE command to device @dev
4439 * on port @ap.
4440 *
1da177e4 4441 * LOCKING:
0cba632b 4442 * PCI/etc. bus probe sem.
83206a29
TH		 4443 *
4444 * RETURNS:
4445 * 0 on success, AC_ERR_* mask otherwise.
1da177e4
LT		 4446 */
4447
3373efd8 4448static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
1da177e4 4449{
a0123703 4450 struct ata_taskfile tf;
1da177e4
LT		 4451
4452 /* set up set-features taskfile */
4633778b 4453 ata_dev_dbg(dev, "set features - xfer mode\n");
1da177e4 4454
464cf177
TH		 4455 /* Some controllers and ATAPI devices show flaky interrupt
4456 * behavior after setting xfer mode. Use polling instead.
4457 */
3373efd8 4458 ata_tf_init(dev, &tf);
a0123703
TH		 4459 tf.command = ATA_CMD_SET_FEATURES;
4460 tf.feature = SETFEATURES_XFER;
464cf177 4461 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
a0123703 4462 tf.protocol = ATA_PROT_NODATA;
b9f8ab2d 4463 /* If we are using IORDY we must send the mode setting command */
11b7becc
JG		 4464 if (ata_pio_need_iordy(dev))
4465 tf.nsect = dev->xfer_mode;
b9f8ab2d
AC		 4466 /* If the device has IORDY and the controller does not - turn it off */
4467 else if (ata_id_has_iordy(dev->id))
11b7becc 4468 tf.nsect = 0x01;
b9f8ab2d
AC		 4469 else /* In the ancient relic department - skip all of this */
4470 return 0;
1da177e4 4471
024811a2
DLM		 4472 /*
4473 * On some disks, this command causes spin-up, so we need longer
4474 * timeout.
4475 */
4476 return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
9f45cbd3 4477}
1152b261 4478
9f45cbd3 4479/**
99ad3f9f 4480 * ata_dev_set_feature - Issue SET FEATURES
9f45cbd3 4481 * @dev: Device to which command will be sent
99ad3f9f
NC		 4482 * @subcmd: The SET FEATURES subcommand to be sent
4483 * @action: The sector count represents a subcommand specific action
9f45cbd3 4484 *
99ad3f9f 4485 * Issue SET FEATURES command to device @dev on port @ap with sector count
9f45cbd3
KCA		 4486 *
4487 * LOCKING:
4488 * PCI/etc. bus probe sem.
4489 *
4490 * RETURNS:
4491 * 0 on success, AC_ERR_* mask otherwise.
4492 */
99ad3f9f 4493unsigned int ata_dev_set_feature(struct ata_device *dev, u8 subcmd, u8 action)
9f45cbd3
KCA		 4494{
4495 struct ata_taskfile tf;
61176eed 4496 unsigned int timeout = 0;
9f45cbd3
KCA		 4497
4498 /* set up set-features taskfile */
99ad3f9f 4499 ata_dev_dbg(dev, "set features\n");
9f45cbd3
KCA		 4500
4501 ata_tf_init(dev, &tf);
4502 tf.command = ATA_CMD_SET_FEATURES;
99ad3f9f 4503 tf.feature = subcmd;
9f45cbd3
KCA		 4504 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4505 tf.protocol = ATA_PROT_NODATA;
99ad3f9f 4506 tf.nsect = action;
9f45cbd3 4507
99ad3f9f 4508 if (subcmd == SETFEATURES_SPINUP)
974e0a45
DLM		 4509 timeout = ata_probe_timeout ?
4510 ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
1da177e4 4511
614065ab 4512 return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
1da177e4 4513}
633de4cc 4514EXPORT_SYMBOL_GPL(ata_dev_set_feature);
1da177e4 4515
8bf62ece
AL		 4516/**
4517 * ata_dev_init_params - Issue INIT DEV PARAMS command
8bf62ece 4518 * @dev: Device to which command will be sent
e2a7f77a
RD		 4519 * @heads: Number of heads (taskfile parameter)
4520 * @sectors: Number of sectors (taskfile parameter)
8bf62ece
AL		 4521 *
4522 * LOCKING:
6aff8f1f
TH		 4523 * Kernel thread context (may sleep)
4524 *
4525 * RETURNS:
4526 * 0 on success, AC_ERR_* mask otherwise.
8bf62ece 4527 */
3373efd8
TH		 4528static unsigned int ata_dev_init_params(struct ata_device *dev,
4529 u16 heads, u16 sectors)
8bf62ece 4530{
a0123703 4531 struct ata_taskfile tf;
6aff8f1f 4532 unsigned int err_mask;
8bf62ece
AL		 4533
4534 /* Number of sectors per track 1-255. Number of heads 1-16 */
4535 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
00b6f5e9 4536 return AC_ERR_INVALID;
8bf62ece
AL		 4537
4538 /* set up init dev params taskfile */
4633778b 4539 ata_dev_dbg(dev, "init dev params \n");
8bf62ece 4540
3373efd8 4541 ata_tf_init(dev, &tf);
a0123703
TH		 4542 tf.command = ATA_CMD_INIT_DEV_PARAMS;
4543 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4544 tf.protocol = ATA_PROT_NODATA;
4545 tf.nsect = sectors;
4546 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
8bf62ece 4547
2b789108 4548 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
18b2466c
AC		 4549 /* A clean abort indicates an original or just out of spec drive
4550 and we should continue as we issue the setup based on the
4551 drive reported working geometry */
efcef265 4552 if (err_mask == AC_ERR_DEV && (tf.error & ATA_ABORTED))
18b2466c 4553 err_mask = 0;
8bf62ece 4554
6aff8f1f 4555 return err_mask;
8bf62ece
AL		 4556}
4557
1da177e4 4558/**
5895ef9a 4559 * atapi_check_dma - Check whether ATAPI DMA can be supported
1da177e4
LT		 4560 * @qc: Metadata associated with taskfile to check
4561 *
780a87f7
JG		 4562 * Allow low-level driver to filter ATA PACKET commands, returning
4563 * a status indicating whether or not it is OK to use DMA for the
4564 * supplied PACKET command.
4565 *
1da177e4 4566 * LOCKING:
624d5c51
TH		 4567 * spin_lock_irqsave(host lock)
4568 *
4569 * RETURNS: 0 when ATAPI DMA can be used
4570 * nonzero otherwise
4571 */
5895ef9a 4572int atapi_check_dma(struct ata_queued_cmd *qc)
624d5c51
TH		 4573{
4574 struct ata_port *ap = qc->ap;
71601958 4575
624d5c51
TH		 4576 /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a
4577 * few ATAPI devices choke on such DMA requests.
4578 */
6a87e42e
TH		 4579 if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4580 unlikely(qc->nbytes & 15))
624d5c51 4581 return 1;
e2cec771 4582
624d5c51
TH		 4583 if (ap->ops->check_atapi_dma)
4584 return ap->ops->check_atapi_dma(qc);
e2cec771 4585
624d5c51
TH		 4586 return 0;
4587}
1da177e4 4588
624d5c51
TH		 4589/**
4590 * ata_std_qc_defer - Check whether a qc needs to be deferred
4591 * @qc: ATA command in question
4592 *
4593 * Non-NCQ commands cannot run with any other command, NCQ or
4594 * not. As upper layer only knows the queue depth, we are
4595 * responsible for maintaining exclusion. This function checks
4596 * whether a new command @qc can be issued.
4597 *
4598 * LOCKING:
4599 * spin_lock_irqsave(host lock)
4600 *
4601 * RETURNS:
4602 * ATA_DEFER_* if deferring is needed, 0 otherwise.
4603 */
4604int ata_std_qc_defer(struct ata_queued_cmd *qc)
4605{
4606 struct ata_link *link = qc->dev->link;
e2cec771 4607
179b310a 4608 if (ata_is_ncq(qc->tf.protocol)) {
624d5c51
TH		 4609 if (!ata_tag_valid(link->active_tag))
4610 return 0;
4611 } else {
4612 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4613 return 0;
4614 }
e2cec771 4615
624d5c51
TH		 4616 return ATA_DEFER_LINK;
4617}
a52fbcfc 4618EXPORT_SYMBOL_GPL(ata_std_qc_defer);
6912ccd5 4619
95364f36
JS		 4620enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc)
4621{
4622 return AC_ERR_OK;
4623}
a52fbcfc 4624EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
1da177e4 4625
624d5c51
TH		 4626/**
4627 * ata_sg_init - Associate command with scatter-gather table.
4628 * @qc: Command to be associated
4629 * @sg: Scatter-gather table.
4630 * @n_elem: Number of elements in s/g table.
4631 *
4632 * Initialize the data-related elements of queued_cmd @qc
4633 * to point to a scatter-gather table @sg, containing @n_elem
4634 * elements.
4635 *
4636 * LOCKING:
4637 * spin_lock_irqsave(host lock)
4638 */
4639void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4640 unsigned int n_elem)
4641{
4642 qc->sg = sg;
4643 qc->n_elem = n_elem;
4644 qc->cursg = qc->sg;
4645}
bb5cb290 4646
2874d5ee
GU		 4647#ifdef CONFIG_HAS_DMA
4648
4649/**
4650 * ata_sg_clean - Unmap DMA memory associated with command
4651 * @qc: Command containing DMA memory to be released
4652 *
4653 * Unmap all mapped DMA memory associated with this command.
4654 *
4655 * LOCKING:
4656 * spin_lock_irqsave(host lock)
4657 */
af27e01c 4658static void ata_sg_clean(struct ata_queued_cmd *qc)
2874d5ee
GU		 4659{
4660 struct ata_port *ap = qc->ap;
4661 struct scatterlist *sg = qc->sg;
4662 int dir = qc->dma_dir;
4663
4664 WARN_ON_ONCE(sg == NULL);
4665
2874d5ee
GU		 4666 if (qc->n_elem)
4667 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4668
4669 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4670 qc->sg = NULL;
4671}
4672
624d5c51
TH		 4673/**
4674 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
4675 * @qc: Command with scatter-gather table to be mapped.
4676 *
4677 * DMA-map the scatter-gather table associated with queued_cmd @qc.
4678 *
4679 * LOCKING:
4680 * spin_lock_irqsave(host lock)
4681 *
4682 * RETURNS:
4683 * Zero on success, negative on error.
4684 *
4685 */
4686static int ata_sg_setup(struct ata_queued_cmd *qc)
4687{
4688 struct ata_port *ap = qc->ap;
4689 unsigned int n_elem;
1da177e4 4690
624d5c51
TH		 4691 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4692 if (n_elem < 1)
4693 return -1;
bb5cb290 4694
5825627c 4695 qc->orig_n_elem = qc->n_elem;
624d5c51
TH		 4696 qc->n_elem = n_elem;
4697 qc->flags |= ATA_QCFLAG_DMAMAP;
1da177e4 4698
624d5c51 4699 return 0;
1da177e4
LT		 4700}
4701
2874d5ee
GU		 4702#else /* !CONFIG_HAS_DMA */
4703
4704static inline void ata_sg_clean(struct ata_queued_cmd *qc) {}
4705static inline int ata_sg_setup(struct ata_queued_cmd *qc) { return -1; }
4706
4707#endif /* !CONFIG_HAS_DMA */
4708
624d5c51
TH		 4709/**
4710 * swap_buf_le16 - swap halves of 16-bit words in place
4711 * @buf: Buffer to swap
4712 * @buf_words: Number of 16-bit words in buffer.
4713 *
4714 * Swap halves of 16-bit words if needed to convert from
4715 * little-endian byte order to native cpu byte order, or
4716 * vice-versa.
4717 *
4718 * LOCKING:
4719 * Inherited from caller.
4720 */
4721void swap_buf_le16(u16 *buf, unsigned int buf_words)
8061f5f0 4722{
624d5c51
TH		 4723#ifdef __BIG_ENDIAN
4724 unsigned int i;
8061f5f0 4725
624d5c51
TH		 4726 for (i = 0; i < buf_words; i++)
4727 buf[i] = le16_to_cpu(buf[i]);
4728#endif /* __BIG_ENDIAN */
8061f5f0
TH		 4729}
4730
8a8bc223
TH		 4731/**
4732 * ata_qc_free - free unused ata_queued_cmd
4733 * @qc: Command to complete
4734 *
4735 * Designed to free unused ata_queued_cmd object
4736 * in case something prevents using it.
4737 *
4738 * LOCKING:
4739 * spin_lock_irqsave(host lock)
4740 */
4741void ata_qc_free(struct ata_queued_cmd *qc)
4742{
8a8bc223 4743 qc->flags = 0;
4f1a22ee 4744 if (ata_tag_valid(qc->tag))
8a8bc223 4745 qc->tag = ATA_TAG_POISON;
8a8bc223
TH		 4746}
4747
76014427 4748void __ata_qc_complete(struct ata_queued_cmd *qc)
1da177e4 4749{
a1104016
JL		 4750 struct ata_port *ap;
4751 struct ata_link *link;
dedaf2b0 4752
efcb3cf7
TH		 4753 WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4754 WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
a1104016
JL		 4755 ap = qc->ap;
4756 link = qc->dev->link;
1da177e4
LT		 4757
4758 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4759 ata_sg_clean(qc);
4760
7401abf2 4761 /* command should be marked inactive atomically with qc completion */
179b310a 4762 if (ata_is_ncq(qc->tf.protocol)) {
4e5b6260 4763 link->sactive &= ~(1 << qc->hw_tag);
da917d69
TH		 4764 if (!link->sactive)
4765 ap->nr_active_links--;
4766 } else {
9af5c9c9 4767 link->active_tag = ATA_TAG_POISON;
da917d69
TH		 4768 ap->nr_active_links--;
4769 }
4770
4771 /* clear exclusive status */
4772 if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
4773 ap->excl_link == link))
4774 ap->excl_link = NULL;
7401abf2 4775
3f3791d3
AL		 4776 /* atapi: mark qc as inactive to prevent the interrupt handler
4777 * from completing the command twice later, before the error handler
4778 * is called. (when rc != 0 and atapi request sense is needed)
4779 */
4780 qc->flags &= ~ATA_QCFLAG_ACTIVE;
e3ed8939 4781 ap->qc_active &= ~(1ULL << qc->tag);
3f3791d3 4782
1da177e4 4783 /* call completion callback */
77853bf2 4784 qc->complete_fn(qc);
1da177e4
LT		 4785}
4786
39599a53
TH		 4787static void fill_result_tf(struct ata_queued_cmd *qc)
4788{
4789 struct ata_port *ap = qc->ap;
4790
39599a53 4791 qc->result_tf.flags = qc->tf.flags;
22183bf5 4792 ap->ops->qc_fill_rtf(qc);
39599a53
TH		 4793}
4794
00115e0f
TH		 4795static void ata_verify_xfer(struct ata_queued_cmd *qc)
4796{
4797 struct ata_device *dev = qc->dev;
4798
eb0effdf 4799 if (!ata_is_data(qc->tf.protocol))
00115e0f
TH		 4800 return;
4801
4802 if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
4803 return;
4804
4805 dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
4806}
4807
f686bcb8
TH		 4808/**
4809 * ata_qc_complete - Complete an active ATA command
4810 * @qc: Command to complete
f686bcb8 4811 *
1aadf5c3
TH		 4812 * Indicate to the mid and upper layers that an ATA command has
4813 * completed, with either an ok or not-ok status.
4814 *
4815 * Refrain from calling this function multiple times when
4816 * successfully completing multiple NCQ commands.
4817 * ata_qc_complete_multiple() should be used instead, which will
4818 * properly update IRQ expect state.
f686bcb8
TH		 4819 *
4820 * LOCKING:
cca3974e 4821 * spin_lock_irqsave(host lock)
f686bcb8
TH		 4822 */
4823void ata_qc_complete(struct ata_queued_cmd *qc)
4824{
4825 struct ata_port *ap = qc->ap;
ff8072d5
HR		 4826 struct ata_device *dev = qc->dev;
4827 struct ata_eh_info *ehi = &dev->link->eh_info;
f686bcb8 4828
eb25cb99 4829 /* Trigger the LED (if available) */
d1ed7c55 4830 ledtrig_disk_activity(!!(qc->tf.flags & ATA_TFLAG_WRITE));
eb25cb99 4831
ff8072d5
HR		 4832 /*
4833 * In order to synchronize EH with the regular execution path, a qc that
4834 * is owned by EH is marked with ATA_QCFLAG_EH.
f686bcb8 4835 *
ff8072d5
HR		 4836 * The normal execution path is responsible for not accessing a qc owned
4837 * by EH. libata core enforces the rule by returning NULL from
4838 * ata_qc_from_tag() for qcs owned by EH.
f686bcb8 4839 */
ff8072d5
HR		 4840 if (unlikely(qc->err_mask))
4841 qc->flags |= ATA_QCFLAG_EH;
f686bcb8 4842
ff8072d5
HR		 4843 /*
4844 * Finish internal commands without any further processing and always
4845 * with the result TF filled.
4846 */
4847 if (unlikely(ata_tag_internal(qc->tag))) {
4848 fill_result_tf(qc);
4849 trace_ata_qc_complete_internal(qc);
4850 __ata_qc_complete(qc);
4851 return;
4852 }
f4b31db9 4853
ff8072d5
HR		 4854 /* Non-internal qc has failed. Fill the result TF and summon EH. */
4855 if (unlikely(qc->flags & ATA_QCFLAG_EH)) {
4856 fill_result_tf(qc);
4857 trace_ata_qc_complete_failed(qc);
4858 ata_qc_schedule_eh(qc);
4859 return;
4860 }
f686bcb8 4861
ff8072d5 4862 WARN_ON_ONCE(ata_port_is_frozen(ap));
4dc738ed 4863
ff8072d5
HR		 4864 /* read result TF if requested */
4865 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4866 fill_result_tf(qc);
f686bcb8 4867
ff8072d5 4868 trace_ata_qc_complete_done(qc);
18bd7718 4869
ff8072d5
HR		 4870 /*
4871 * For CDL commands that completed without an error, check if we have
4872 * sense data (ATA_SENSE is set). If we do, then the command may have
4873 * been aborted by the device due to a limit timeout using the policy
4874 * 0xD. For these commands, invoke EH to get the command sense data.
4875 */
5e35a9ac
NC		 4876 if (qc->flags & ATA_QCFLAG_HAS_CDL &&
4877 qc->result_tf.status & ATA_SENSE) {
18bd7718 4878 /*
ff8072d5
HR		 4879 * Tell SCSI EH to not overwrite scmd->result even if this
4880 * command is finished with result SAM_STAT_GOOD.
18bd7718 4881 */
ff8072d5
HR		 4882 qc->scsicmd->flags |= SCMD_FORCE_EH_SUCCESS;
4883 qc->flags |= ATA_QCFLAG_EH_SUCCESS_CMD;
4884 ehi->dev_action[dev->devno] |= ATA_EH_GET_SUCCESS_SENSE;
18bd7718 4885
ff8072d5
HR		 4886 /*
4887 * set pending so that ata_qc_schedule_eh() does not trigger
4888 * fast drain, and freeze the port.
4dbfa39b 4889 */
ff8072d5
HR		 4890 ap->pflags |= ATA_PFLAG_EH_PENDING;
4891 ata_qc_schedule_eh(qc);
4892 return;
4893 }
054a5fba 4894
ff8072d5
HR		 4895 /* Some commands need post-processing after successful completion. */
4896 switch (qc->tf.command) {
4897 case ATA_CMD_SET_FEATURES:
4898 if (qc->tf.feature != SETFEATURES_WC_ON &&
4899 qc->tf.feature != SETFEATURES_WC_OFF &&
4900 qc->tf.feature != SETFEATURES_RA_ON &&
4901 qc->tf.feature != SETFEATURES_RA_OFF)
054a5fba 4902 break;
ff8072d5
HR		 4903 fallthrough;
4904 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
4905 case ATA_CMD_SET_MULTI: /* multi_count changed */
4906 /* revalidate device */
4907 ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
4908 ata_port_schedule_eh(ap);
4909 break;
00115e0f 4910
ff8072d5
HR		 4911 case ATA_CMD_SLEEP:
4912 dev->flags |= ATA_DFLAG_SLEEPING;
4913 break;
4914 }
f686bcb8 4915
ff8072d5
HR		 4916 if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER))
4917 ata_verify_xfer(qc);
f686bcb8 4918
ff8072d5 4919 __ata_qc_complete(qc);
f686bcb8 4920}
a52fbcfc 4921EXPORT_SYMBOL_GPL(ata_qc_complete);
f686bcb8 4922
8385d756
SH		 4923/**
4924 * ata_qc_get_active - get bitmask of active qcs
4925 * @ap: port in question
4926 *
4927 * LOCKING:
4928 * spin_lock_irqsave(host lock)
4929 *
4930 * RETURNS:
4931 * Bitmask of active qcs
4932 */
4933u64 ata_qc_get_active(struct ata_port *ap)
4934{
4935 u64 qc_active = ap->qc_active;
4936
4937 /* ATA_TAG_INTERNAL is sent to hw as tag 0 */
4938 if (qc_active & (1ULL << ATA_TAG_INTERNAL)) {
4939 qc_active |= (1 << 0);
4940 qc_active &= ~(1ULL << ATA_TAG_INTERNAL);
4941 }
4942
4943 return qc_active;
4944}
4945EXPORT_SYMBOL_GPL(ata_qc_get_active);
4946
1da177e4
LT		 4947/**
4948 * ata_qc_issue - issue taskfile to device
4949 * @qc: command to issue to device
4950 *
4951 * Prepare an ATA command to submission to device.
4952 * This includes mapping the data into a DMA-able
4953 * area, filling in the S/G table, and finally
4954 * writing the taskfile to hardware, starting the command.
4955 *
4956 * LOCKING:
cca3974e 4957 * spin_lock_irqsave(host lock)
1da177e4 4958 */
8e0e694a 4959void ata_qc_issue(struct ata_queued_cmd *qc)
1da177e4
LT		 4960{
4961 struct ata_port *ap = qc->ap;
9af5c9c9 4962 struct ata_link *link = qc->dev->link;
405e66b3 4963 u8 prot = qc->tf.protocol;
1da177e4 4964
ff8072d5
HR		 4965 /* Make sure only one non-NCQ command is outstanding. */
4966 WARN_ON_ONCE(ata_tag_valid(link->active_tag));
dedaf2b0 4967
1973a023 4968 if (ata_is_ncq(prot)) {
4e5b6260 4969 WARN_ON_ONCE(link->sactive & (1 << qc->hw_tag));
da917d69
TH		 4970
4971 if (!link->sactive)
4972 ap->nr_active_links++;
4e5b6260 4973 link->sactive |= 1 << qc->hw_tag;
dedaf2b0 4974 } else {
efcb3cf7 4975 WARN_ON_ONCE(link->sactive);
da917d69
TH		 4976
4977 ap->nr_active_links++;
9af5c9c9 4978 link->active_tag = qc->tag;
dedaf2b0
TH		 4979 }
4980
e4a70e76 4981 qc->flags |= ATA_QCFLAG_ACTIVE;
e3ed8939 4982 ap->qc_active |= 1ULL << qc->tag;
e4a70e76 4983
60f5d6ef
TH		 4984 /*
4985 * We guarantee to LLDs that they will have at least one
f92a2636
TH		 4986 * non-zero sg if the command is a data command.
4987 */
9173e5e8 4988 if (ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes))
60f5d6ef 4989 goto sys_err;
f92a2636 4990
405e66b3 4991 if (ata_is_dma(prot) || (ata_is_pio(prot) &&
f92a2636 4992 (ap->flags & ATA_FLAG_PIO_DMA)))
001102d7 4993 if (ata_sg_setup(qc))
60f5d6ef 4994 goto sys_err;
1da177e4 4995
cf480626 4996 /* if device is sleeping, schedule reset and abort the link */
054a5fba 4997 if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
cf480626 4998 link->eh_info.action |= ATA_EH_RESET;
054a5fba
TH		 4999 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5000 ata_link_abort(link);
5001 return;
5002 }
5003
fc914faa 5004 trace_ata_qc_prep(qc);
95364f36
JS		 5005 qc->err_mask |= ap->ops->qc_prep(qc);
5006 if (unlikely(qc->err_mask))
5007 goto err;
255c03d1 5008 trace_ata_qc_issue(qc);
8e0e694a
TH		 5009 qc->err_mask |= ap->ops->qc_issue(qc);
5010 if (unlikely(qc->err_mask))
5011 goto err;
5012 return;
1da177e4 5013
60f5d6ef 5014sys_err:
8e0e694a
TH		 5015 qc->err_mask |= AC_ERR_SYSTEM;
5016err:
5017 ata_qc_complete(qc);
1da177e4
LT		 5018}
5019
34bf2170 5020/**
b1c72916 5021 * ata_phys_link_online - test whether the given link is online
936fd732 5022 * @link: ATA link to test
34bf2170 5023 *
936fd732
TH		 5024 * Test whether @link is online. Note that this function returns
5025 * 0 if online status of @link cannot be obtained, so
5026 * ata_link_online(link) != !ata_link_offline(link).
34bf2170
TH		 5027 *
5028 * LOCKING:
5029 * None.
5030 *
5031 * RETURNS:
b5b3fa38 5032 * True if the port online status is available and online.
34bf2170 5033 */
b1c72916 5034bool ata_phys_link_online(struct ata_link *link)
34bf2170
TH		 5035{
5036 u32 sstatus;
5037
936fd732 5038 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
9913ff8a 5039 ata_sstatus_online(sstatus))
b5b3fa38
TH		 5040 return true;
5041 return false;
34bf2170
TH		 5042}
5043
5044/**
b1c72916 5045 * ata_phys_link_offline - test whether the given link is offline
936fd732 5046 * @link: ATA link to test
34bf2170 5047 *
936fd732
TH		 5048 * Test whether @link is offline. Note that this function
5049 * returns 0 if offline status of @link cannot be obtained, so
5050 * ata_link_online(link) != !ata_link_offline(link).
34bf2170
TH		 5051 *
5052 * LOCKING:
5053 * None.
5054 *
5055 * RETURNS:
b5b3fa38 5056 * True if the port offline status is available and offline.
34bf2170 5057 */
b1c72916 5058bool ata_phys_link_offline(struct ata_link *link)
34bf2170
TH		 5059{
5060 u32 sstatus;
5061
936fd732 5062 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
9913ff8a 5063 !ata_sstatus_online(sstatus))
b5b3fa38
TH		 5064 return true;
5065 return false;
34bf2170 5066}
0baab86b 5067
b1c72916
TH		 5068/**
5069 * ata_link_online - test whether the given link is online
5070 * @link: ATA link to test
5071 *
5072 * Test whether @link is online. This is identical to
5073 * ata_phys_link_online() when there's no slave link. When
5074 * there's a slave link, this function should only be called on
5075 * the master link and will return true if any of M/S links is
5076 * online.
5077 *
5078 * LOCKING:
5079 * None.
5080 *
5081 * RETURNS:
5082 * True if the port online status is available and online.
5083 */
5084bool ata_link_online(struct ata_link *link)
5085{
5086 struct ata_link *slave = link->ap->slave_link;
5087
5088 WARN_ON(link == slave); /* shouldn't be called on slave link */
5089
5090 return ata_phys_link_online(link) ||
5091 (slave && ata_phys_link_online(slave));
5092}
a52fbcfc 5093EXPORT_SYMBOL_GPL(ata_link_online);
b1c72916
TH		 5094
5095/**
5096 * ata_link_offline - test whether the given link is offline
5097 * @link: ATA link to test
5098 *
5099 * Test whether @link is offline. This is identical to
5100 * ata_phys_link_offline() when there's no slave link. When
5101 * there's a slave link, this function should only be called on
5102 * the master link and will return true if both M/S links are
5103 * offline.
5104 *
5105 * LOCKING:
5106 * None.
5107 *
5108 * RETURNS:
5109 * True if the port offline status is available and offline.
5110 */
5111bool ata_link_offline(struct ata_link *link)
5112{
5113 struct ata_link *slave = link->ap->slave_link;
5114
5115 WARN_ON(link == slave); /* shouldn't be called on slave link */
5116
5117 return ata_phys_link_offline(link) &&
5118 (!slave || ata_phys_link_offline(slave));
5119}
a52fbcfc 5120EXPORT_SYMBOL_GPL(ata_link_offline);
b1c72916 5121
6ffa01d8 5122#ifdef CONFIG_PM
bc6e7c4b
DW		 5123static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
5124 unsigned int action, unsigned int ehi_flags,
5125 bool async)
500530f6 5126{
5ef41082 5127 struct ata_link *link;
500530f6 5128 unsigned long flags;
500530f6 5129
3b8e0af4
DLM		 5130 spin_lock_irqsave(ap->lock, flags);
5131
5132 /*
5133 * A previous PM operation might still be in progress. Wait for
5134 * ATA_PFLAG_PM_PENDING to clear.
5ef41082
LM		 5135 */
5136 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
3b8e0af4 5137 spin_unlock_irqrestore(ap->lock, flags);
5ef41082 5138 ata_port_wait_eh(ap);
3b8e0af4 5139 spin_lock_irqsave(ap->lock, flags);
5ef41082 5140 }
500530f6 5141
3b8e0af4 5142 /* Request PM operation to EH */
5ef41082 5143 ap->pm_mesg = mesg;
5ef41082
LM		 5144 ap->pflags |= ATA_PFLAG_PM_PENDING;
5145 ata_for_each_link(link, ap, HOST_FIRST) {
5146 link->eh_info.action |= action;
5147 link->eh_info.flags |= ehi_flags;
5148 }
500530f6 5149
5ef41082 5150 ata_port_schedule_eh(ap);
500530f6 5151
5ef41082 5152 spin_unlock_irqrestore(ap->lock, flags);
500530f6 5153
3b8e0af4 5154 if (!async)
5ef41082 5155 ata_port_wait_eh(ap);
500530f6
TH		 5156}
5157
bc6e7c4b
DW		 5158/*
5159 * On some hardware, device fails to respond after spun down for suspend. As
5160 * the device won't be used before being resumed, we don't need to touch the
5161 * device. Ask EH to skip the usual stuff and proceed directly to suspend.
5162 *
5163 * http://thread.gmane.org/gmane.linux.ide/46764
5164 */
5165static const unsigned int ata_port_suspend_ehi = ATA_EHI_QUIET
5166 | ATA_EHI_NO_AUTOPSY
5167 | ATA_EHI_NO_RECOVERY;
5168
5169static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)
5ef41082 5170{
8b4d9469
DLM		 5171 /*
5172 * We are about to suspend the port, so we do not care about
5173 * scsi_rescan_device() calls scheduled by previous resume operations.
5174 * The next resume will schedule the rescan again. So cancel any rescan
5175 * that is not done yet.
5176 */
5177 cancel_delayed_work_sync(&ap->scsi_rescan_task);
5178
bc6e7c4b 5179 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);
5ef41082
LM		 5180}
5181
bc6e7c4b 5182static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)
2fcbdcb4 5183{
8b4d9469
DLM		 5184 /*
5185 * We are about to suspend the port, so we do not care about
5186 * scsi_rescan_device() calls scheduled by previous resume operations.
5187 * The next resume will schedule the rescan again. So cancel any rescan
5188 * that is not done yet.
5189 */
5190 cancel_delayed_work_sync(&ap->scsi_rescan_task);
5191
bc6e7c4b 5192 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);
2fcbdcb4
DW		 5193}
5194
bc6e7c4b 5195static int ata_port_pm_suspend(struct device *dev)
5ef41082 5196{
bc6e7c4b
DW		 5197 struct ata_port *ap = to_ata_port(dev);
5198
5ef41082
LM		 5199 if (pm_runtime_suspended(dev))
5200 return 0;
5201
bc6e7c4b
DW		 5202 ata_port_suspend(ap, PMSG_SUSPEND);
5203 return 0;
33574d68
LM		 5204}
5205
bc6e7c4b 5206static int ata_port_pm_freeze(struct device *dev)
33574d68 5207{
bc6e7c4b
DW		 5208 struct ata_port *ap = to_ata_port(dev);
5209
33574d68 5210 if (pm_runtime_suspended(dev))
f5e6d0d0 5211 return 0;
33574d68 5212
bc6e7c4b
DW		 5213 ata_port_suspend(ap, PMSG_FREEZE);
5214 return 0;
33574d68
LM		 5215}
5216
bc6e7c4b 5217static int ata_port_pm_poweroff(struct device *dev)
33574d68 5218{
bc6e7c4b
DW		 5219 ata_port_suspend(to_ata_port(dev), PMSG_HIBERNATE);
5220 return 0;
5ef41082
LM		 5221}
5222
bc6e7c4b
DW		 5223static const unsigned int ata_port_resume_ehi = ATA_EHI_NO_AUTOPSY
5224 | ATA_EHI_QUIET;
5ef41082 5225
bc6e7c4b
DW		 5226static void ata_port_resume(struct ata_port *ap, pm_message_t mesg)
5227{
5228 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, false);
5ef41082
LM		 5229}
5230
bc6e7c4b 5231static void ata_port_resume_async(struct ata_port *ap, pm_message_t mesg)
2fcbdcb4 5232{
bc6e7c4b 5233 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, true);
2fcbdcb4
DW		 5234}
5235
bc6e7c4b 5236static int ata_port_pm_resume(struct device *dev)
e90b1e5a 5237{
200421a8 5238 ata_port_resume_async(to_ata_port(dev), PMSG_RESUME);
bc6e7c4b
DW		 5239 pm_runtime_disable(dev);
5240 pm_runtime_set_active(dev);
5241 pm_runtime_enable(dev);
5242 return 0;
e90b1e5a
LM		 5243}
5244
7e15e9be
AL		 5245/*
5246 * For ODDs, the upper layer will poll for media change every few seconds,
5247 * which will make it enter and leave suspend state every few seconds. And
5248 * as each suspend will cause a hard/soft reset, the gain of runtime suspend
5249 * is very little and the ODD may malfunction after constantly being reset.
5250 * So the idle callback here will not proceed to suspend if a non-ZPODD capable
5251 * ODD is attached to the port.
5252 */
9ee4f393
LM		 5253static int ata_port_runtime_idle(struct device *dev)
5254{
7e15e9be
AL		 5255 struct ata_port *ap = to_ata_port(dev);
5256 struct ata_link *link;
5257 struct ata_device *adev;
5258
5259 ata_for_each_link(link, ap, HOST_FIRST) {
5260 ata_for_each_dev(adev, link, ENABLED)
5261 if (adev->class == ATA_DEV_ATAPI &&
5262 !zpodd_dev_enabled(adev))
5263 return -EBUSY;
5264 }
5265
45f0a85c 5266 return 0;
9ee4f393
LM		 5267}
5268
a7ff60db
AL		 5269static int ata_port_runtime_suspend(struct device *dev)
5270{
bc6e7c4b
DW		 5271 ata_port_suspend(to_ata_port(dev), PMSG_AUTO_SUSPEND);
5272 return 0;
a7ff60db
AL		 5273}
5274
5275static int ata_port_runtime_resume(struct device *dev)
5276{
bc6e7c4b
DW		 5277 ata_port_resume(to_ata_port(dev), PMSG_AUTO_RESUME);
5278 return 0;
a7ff60db
AL		 5279}
5280
5ef41082 5281static const struct dev_pm_ops ata_port_pm_ops = {
bc6e7c4b
DW		 5282 .suspend = ata_port_pm_suspend,
5283 .resume = ata_port_pm_resume,
5284 .freeze = ata_port_pm_freeze,
5285 .thaw = ata_port_pm_resume,
5286 .poweroff = ata_port_pm_poweroff,
5287 .restore = ata_port_pm_resume,
9ee4f393 5288
a7ff60db
AL		 5289 .runtime_suspend = ata_port_runtime_suspend,
5290 .runtime_resume = ata_port_runtime_resume,
9ee4f393 5291 .runtime_idle = ata_port_runtime_idle,
5ef41082
LM		 5292};
5293
2fcbdcb4
DW		 5294/* sas ports don't participate in pm runtime management of ata_ports,
5295 * and need to resume ata devices at the domain level, not the per-port
5296 * level. sas suspend/resume is async to allow parallel port recovery
5297 * since sas has multiple ata_port instances per Scsi_Host.
5298 */
bc6e7c4b 5299void ata_sas_port_suspend(struct ata_port *ap)
2fcbdcb4 5300{
bc6e7c4b 5301 ata_port_suspend_async(ap, PMSG_SUSPEND);
2fcbdcb4 5302}
bc6e7c4b 5303EXPORT_SYMBOL_GPL(ata_sas_port_suspend);
2fcbdcb4 5304
bc6e7c4b 5305void ata_sas_port_resume(struct ata_port *ap)
2fcbdcb4 5306{
bc6e7c4b 5307 ata_port_resume_async(ap, PMSG_RESUME);
2fcbdcb4 5308}
bc6e7c4b 5309EXPORT_SYMBOL_GPL(ata_sas_port_resume);
2fcbdcb4 5310
500530f6 5311/**
cca3974e
JG		 5312 * ata_host_suspend - suspend host
5313 * @host: host to suspend
500530f6
TH		 5314 * @mesg: PM message
5315 *
5ef41082 5316 * Suspend @host. Actual operation is performed by port suspend.
500530f6 5317 */
ec87cf37 5318void ata_host_suspend(struct ata_host *host, pm_message_t mesg)
500530f6 5319{
5ef41082 5320 host->dev->power.power_state = mesg;
500530f6 5321}
a52fbcfc 5322EXPORT_SYMBOL_GPL(ata_host_suspend);
500530f6
TH		 5323
5324/**
cca3974e
JG		 5325 * ata_host_resume - resume host
5326 * @host: host to resume
500530f6 5327 *
5ef41082 5328 * Resume @host. Actual operation is performed by port resume.
500530f6 5329 */
cca3974e 5330void ata_host_resume(struct ata_host *host)
500530f6 5331{
72ad6ec4 5332 host->dev->power.power_state = PMSG_ON;
500530f6 5333}
a52fbcfc 5334EXPORT_SYMBOL_GPL(ata_host_resume);
6ffa01d8 5335#endif
500530f6 5336
8df82c13 5337const struct device_type ata_port_type = {
75e2bd5f 5338 .name = ATA_PORT_TYPE_NAME,
5ef41082
LM		 5339#ifdef CONFIG_PM
5340 .pm = &ata_port_pm_ops,
5341#endif
5342};
5343
3ef3b43d
TH		 5344/**
5345 * ata_dev_init - Initialize an ata_device structure
5346 * @dev: Device structure to initialize
5347 *
5348 * Initialize @dev in preparation for probing.
5349 *
5350 * LOCKING:
5351 * Inherited from caller.
5352 */
5353void ata_dev_init(struct ata_device *dev)
5354{
b1c72916 5355 struct ata_link *link = ata_dev_phys_link(dev);
9af5c9c9 5356 struct ata_port *ap = link->ap;
72fa4b74
TH		 5357 unsigned long flags;
5358
b1c72916 5359 /* SATA spd limit is bound to the attached device, reset together */
9af5c9c9
TH		 5360 link->sata_spd_limit = link->hw_sata_spd_limit;
5361 link->sata_spd = 0;
5a04bf4b 5362
72fa4b74
TH		 5363 /* High bits of dev->flags are used to record warm plug
5364 * requests which occur asynchronously. Synchronize using
cca3974e 5365 * host lock.
72fa4b74 5366 */
ba6a1308 5367 spin_lock_irqsave(ap->lock, flags);
72fa4b74 5368 dev->flags &= ~ATA_DFLAG_INIT_MASK;
3dcc323f 5369 dev->horkage = 0;
ba6a1308 5370 spin_unlock_irqrestore(ap->lock, flags);
3ef3b43d 5371
99cf610a
TH		 5372 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
5373 ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
3ef3b43d
TH		 5374 dev->pio_mask = UINT_MAX;
5375 dev->mwdma_mask = UINT_MAX;
5376 dev->udma_mask = UINT_MAX;
5377}
5378
4fb37a25
TH		 5379/**
5380 * ata_link_init - Initialize an ata_link structure
5381 * @ap: ATA port link is attached to
5382 * @link: Link structure to initialize
8989805d 5383 * @pmp: Port multiplier port number
4fb37a25
TH		 5384 *
5385 * Initialize @link.
5386 *
5387 * LOCKING:
5388 * Kernel thread context (may sleep)
5389 */
fb7fd614 5390void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
4fb37a25
TH		 5391{
5392 int i;
5393
5394 /* clear everything except for devices */
d9027470
GG		 5395 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5396 ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
4fb37a25
TH		 5397
5398 link->ap = ap;
8989805d 5399 link->pmp = pmp;
4fb37a25
TH		 5400 link->active_tag = ATA_TAG_POISON;
5401 link->hw_sata_spd_limit = UINT_MAX;
5402
5403 /* can't use iterator, ap isn't initialized yet */
5404 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5405 struct ata_device *dev = &link->device[i];
5406
5407 dev->link = link;
5408 dev->devno = dev - link->device;
110f66d2
TH		 5409#ifdef CONFIG_ATA_ACPI
5410 dev->gtf_filter = ata_acpi_gtf_filter;
5411#endif
4fb37a25
TH		 5412 ata_dev_init(dev);
5413 }
5414}
5415
5416/**
5417 * sata_link_init_spd - Initialize link->sata_spd_limit
5418 * @link: Link to configure sata_spd_limit for
5419 *
a31a6997 5420 * Initialize ``link->[hw_]sata_spd_limit`` to the currently
4fb37a25
TH		 5421 * configured value.
5422 *
5423 * LOCKING:
5424 * Kernel thread context (may sleep).
5425 *
5426 * RETURNS:
5427 * 0 on success, -errno on failure.
5428 */
fb7fd614 5429int sata_link_init_spd(struct ata_link *link)
4fb37a25 5430{
33267325 5431 u8 spd;
4fb37a25
TH		 5432 int rc;
5433
d127ea7b 5434 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
4fb37a25
TH		 5435 if (rc)
5436 return rc;
5437
d127ea7b 5438 spd = (link->saved_scontrol >> 4) & 0xf;
4fb37a25
TH		 5439 if (spd)
5440 link->hw_sata_spd_limit &= (1 << spd) - 1;
5441
05944bdf 5442 ata_force_link_limits(link);
33267325 5443
4fb37a25
TH		 5444 link->sata_spd_limit = link->hw_sata_spd_limit;
5445
5446 return 0;
5447}
5448
1da177e4 5449/**
f3187195
TH		 5450 * ata_port_alloc - allocate and initialize basic ATA port resources
5451 * @host: ATA host this allocated port belongs to
1da177e4 5452 *
f3187195
TH		 5453 * Allocate and initialize basic ATA port resources.
5454 *
5455 * RETURNS:
5456 * Allocate ATA port on success, NULL on failure.
0cba632b 5457 *
1da177e4 5458 * LOCKING:
f3187195 5459 * Inherited from calling layer (may sleep).
1da177e4 5460 */
f3187195 5461struct ata_port *ata_port_alloc(struct ata_host *host)
1da177e4 5462{
f3187195 5463 struct ata_port *ap;
1da177e4 5464
f3187195
TH		 5465 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5466 if (!ap)
5467 return NULL;
4fca377f 5468
7b3a24c5 5469 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
cca3974e 5470 ap->lock = &host->lock;
f3187195 5471 ap->print_id = -1;
e628dc99 5472 ap->local_port_no = -1;
cca3974e 5473 ap->host = host;
f3187195 5474 ap->dev = host->dev;
bd5d825c 5475
ad72cf98 5476 mutex_init(&ap->scsi_scan_mutex);
65f27f38 5477 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
6aa0365a 5478 INIT_DELAYED_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
a72ec4ce 5479 INIT_LIST_HEAD(&ap->eh_done_q);
c6cf9e99 5480 init_waitqueue_head(&ap->eh_wait_q);
45fabbb7 5481 init_completion(&ap->park_req_pending);
b93ab338
KC		 5482 timer_setup(&ap->fastdrain_timer, ata_eh_fastdrain_timerfn,
5483 TIMER_DEFERRABLE);
1da177e4 5484
838df628 5485 ap->cbl = ATA_CBL_NONE;
838df628 5486
8989805d 5487 ata_link_init(ap, &ap->link, 0);
1da177e4
LT		 5488
5489#ifdef ATA_IRQ_TRAP
5490 ap->stats.unhandled_irq = 1;
5491 ap->stats.idle_irq = 1;
5492#endif
270390e1
TH		 5493 ata_sff_port_init(ap);
5494
1da177e4 5495 return ap;
1da177e4
LT		 5496}
5497
2623c7a5 5498static void ata_devres_release(struct device *gendev, void *res)
f0d36efd
TH		 5499{
5500 struct ata_host *host = dev_get_drvdata(gendev);
5501 int i;
5502
1aa506e4
TH		 5503 for (i = 0; i < host->n_ports; i++) {
5504 struct ata_port *ap = host->ports[i];
5505
4911487a
TH		 5506 if (!ap)
5507 continue;
5508
5509 if (ap->scsi_host)
1aa506e4
TH		 5510 scsi_host_put(ap->scsi_host);
5511
2623c7a5
TK		 5512 }
5513
5514 dev_set_drvdata(gendev, NULL);
5515 ata_host_put(host);
5516}
5517
5518static void ata_host_release(struct kref *kref)
5519{
5520 struct ata_host *host = container_of(kref, struct ata_host, kref);
5521 int i;
5522
5523 for (i = 0; i < host->n_ports; i++) {
5524 struct ata_port *ap = host->ports[i];
5525
633273a3 5526 kfree(ap->pmp_link);
b1c72916 5527 kfree(ap->slave_link);
18bd7718 5528 kfree(ap->ncq_sense_buf);
4911487a 5529 kfree(ap);
1aa506e4
TH		 5530 host->ports[i] = NULL;
5531 }
2623c7a5
TK		 5532 kfree(host);
5533}
1aa506e4 5534
2623c7a5
TK		 5535void ata_host_get(struct ata_host *host)
5536{
5537 kref_get(&host->kref);
5538}
5539
5540void ata_host_put(struct ata_host *host)
5541{
5542 kref_put(&host->kref, ata_host_release);
f0d36efd 5543}
a52fbcfc 5544EXPORT_SYMBOL_GPL(ata_host_put);
f0d36efd 5545
f3187195
TH		 5546/**
5547 * ata_host_alloc - allocate and init basic ATA host resources
5548 * @dev: generic device this host is associated with
5549 * @max_ports: maximum number of ATA ports associated with this host
5550 *
5551 * Allocate and initialize basic ATA host resources. LLD calls
5552 * this function to allocate a host, initializes it fully and
5553 * attaches it using ata_host_register().
5554 *
5555 * @max_ports ports are allocated and host->n_ports is
5556 * initialized to @max_ports. The caller is allowed to decrease
5557 * host->n_ports before calling ata_host_register(). The unused
5558 * ports will be automatically freed on registration.
5559 *
5560 * RETURNS:
5561 * Allocate ATA host on success, NULL on failure.
5562 *
5563 * LOCKING:
5564 * Inherited from calling layer (may sleep).
5565 */
5566struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
5567{
5568 struct ata_host *host;
5569 size_t sz;
5570 int i;
2623c7a5 5571 void *dr;
f3187195 5572
f3187195
TH		 5573 /* alloc a container for our list of ATA ports (buses) */
5574 sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
2623c7a5 5575 host = kzalloc(sz, GFP_KERNEL);
f3187195 5576 if (!host)
2623c7a5
TK		 5577 return NULL;
5578
5579 if (!devres_open_group(dev, NULL, GFP_KERNEL))
dafd6c49 5580 goto err_free;
2623c7a5
TK		 5581
5582 dr = devres_alloc(ata_devres_release, 0, GFP_KERNEL);
5583 if (!dr)
f3187195
TH		 5584 goto err_out;
5585
2623c7a5 5586 devres_add(dev, dr);
f3187195
TH		 5587 dev_set_drvdata(dev, host);
5588
5589 spin_lock_init(&host->lock);
c0c362b6 5590 mutex_init(&host->eh_mutex);
f3187195
TH		 5591 host->dev = dev;
5592 host->n_ports = max_ports;
2623c7a5 5593 kref_init(&host->kref);
f3187195
TH		 5594
5595 /* allocate ports bound to this host */
5596 for (i = 0; i < max_ports; i++) {
5597 struct ata_port *ap;
5598
5599 ap = ata_port_alloc(host);
5600 if (!ap)
5601 goto err_out;
5602
5603 ap->port_no = i;
5604 host->ports[i] = ap;
5605 }
5606
5607 devres_remove_group(dev, NULL);
5608 return host;
5609
5610 err_out:
5611 devres_release_group(dev, NULL);
dafd6c49
CIK		 5612 err_free:
5613 kfree(host);
f3187195
TH		 5614 return NULL;
5615}
a52fbcfc 5616EXPORT_SYMBOL_GPL(ata_host_alloc);
f3187195 5617
f5cda257
TH		 5618/**
5619 * ata_host_alloc_pinfo - alloc host and init with port_info array
5620 * @dev: generic device this host is associated with
5621 * @ppi: array of ATA port_info to initialize host with
5622 * @n_ports: number of ATA ports attached to this host
5623 *
5624 * Allocate ATA host and initialize with info from @ppi. If NULL
5625 * terminated, @ppi may contain fewer entries than @n_ports. The
5626 * last entry will be used for the remaining ports.
5627 *
5628 * RETURNS:
5629 * Allocate ATA host on success, NULL on failure.
5630 *
5631 * LOCKING:
5632 * Inherited from calling layer (may sleep).
5633 */
5634struct ata_host *ata_host_alloc_pinfo(struct device *dev,
5635 const struct ata_port_info * const * ppi,
5636 int n_ports)
5637{
bf476fe2 5638 const struct ata_port_info *pi = &ata_dummy_port_info;
f5cda257
TH		 5639 struct ata_host *host;
5640 int i, j;
5641
5642 host = ata_host_alloc(dev, n_ports);
5643 if (!host)
5644 return NULL;
5645
bf476fe2 5646 for (i = 0, j = 0; i < host->n_ports; i++) {
f5cda257
TH		 5647 struct ata_port *ap = host->ports[i];
5648
5649 if (ppi[j])
5650 pi = ppi[j++];
5651
5652 ap->pio_mask = pi->pio_mask;
5653 ap->mwdma_mask = pi->mwdma_mask;
5654 ap->udma_mask = pi->udma_mask;
5655 ap->flags |= pi->flags;
0c88758b 5656 ap->link.flags |= pi->link_flags;
f5cda257
TH		 5657 ap->ops = pi->port_ops;
5658
5659 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
5660 host->ops = pi->port_ops;
f5cda257
TH		 5661 }
5662
5663 return host;
5664}
a52fbcfc 5665EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
f5cda257 5666
32ebbc0c
TH		 5667static void ata_host_stop(struct device *gendev, void *res)
5668{
5669 struct ata_host *host = dev_get_drvdata(gendev);
5670 int i;
5671
5672 WARN_ON(!(host->flags & ATA_HOST_STARTED));
5673
5674 for (i = 0; i < host->n_ports; i++) {
5675 struct ata_port *ap = host->ports[i];
5676
5677 if (ap->ops->port_stop)
5678 ap->ops->port_stop(ap);
5679 }
5680
5681 if (host->ops->host_stop)
5682 host->ops->host_stop(host);
5683}
5684
029cfd6b
TH		 5685/**
5686 * ata_finalize_port_ops - finalize ata_port_operations
5687 * @ops: ata_port_operations to finalize
5688 *
5689 * An ata_port_operations can inherit from another ops and that
5690 * ops can again inherit from another. This can go on as many
5691 * times as necessary as long as there is no loop in the
5692 * inheritance chain.
5693 *
5694 * Ops tables are finalized when the host is started. NULL or
5695 * unspecified entries are inherited from the closet ancestor
5696 * which has the method and the entry is populated with it.
5697 * After finalization, the ops table directly points to all the
5698 * methods and ->inherits is no longer necessary and cleared.
5699 *
5700 * Using ATA_OP_NULL, inheriting ops can force a method to NULL.
5701 *
5702 * LOCKING:
5703 * None.
5704 */
5705static void ata_finalize_port_ops(struct ata_port_operations *ops)
5706{
2da67659 5707 static DEFINE_SPINLOCK(lock);
029cfd6b
TH		 5708 const struct ata_port_operations *cur;
5709 void **begin = (void **)ops;
5710 void **end = (void **)&ops->inherits;
5711 void **pp;
5712
5713 if (!ops || !ops->inherits)
5714 return;
5715
5716 spin_lock(&lock);
5717
5718 for (cur = ops->inherits; cur; cur = cur->inherits) {
5719 void **inherit = (void **)cur;
5720
5721 for (pp = begin; pp < end; pp++, inherit++)
5722 if (!*pp)
5723 *pp = *inherit;
5724 }
5725
5726 for (pp = begin; pp < end; pp++)
5727 if (IS_ERR(*pp))
5728 *pp = NULL;
5729
5730 ops->inherits = NULL;
5731
5732 spin_unlock(&lock);
5733}
5734
ecef7253
TH		 5735/**
5736 * ata_host_start - start and freeze ports of an ATA host
5737 * @host: ATA host to start ports for
5738 *
5739 * Start and then freeze ports of @host. Started status is
5740 * recorded in host->flags, so this function can be called
5741 * multiple times. Ports are guaranteed to get started only
e0af10ac 5742 * once. If host->ops is not initialized yet, it is set to the
f3187195 5743 * first non-dummy port ops.
ecef7253
TH		 5744 *
5745 * LOCKING:
5746 * Inherited from calling layer (may sleep).
5747 *
5748 * RETURNS:
5749 * 0 if all ports are started successfully, -errno otherwise.
5750 */
5751int ata_host_start(struct ata_host *host)
5752{
32ebbc0c
TH		 5753 int have_stop = 0;
5754 void *start_dr = NULL;
ecef7253
TH		 5755 int i, rc;
5756
5757 if (host->flags & ATA_HOST_STARTED)
5758 return 0;
5759
029cfd6b
TH		 5760 ata_finalize_port_ops(host->ops);
5761
ecef7253
TH		 5762 for (i = 0; i < host->n_ports; i++) {
5763 struct ata_port *ap = host->ports[i];
5764
029cfd6b
TH		 5765 ata_finalize_port_ops(ap->ops);
5766
f3187195
TH		 5767 if (!host->ops && !ata_port_is_dummy(ap))
5768 host->ops = ap->ops;
5769
32ebbc0c
TH		 5770 if (ap->ops->port_stop)
5771 have_stop = 1;
5772 }
5773
355a8031 5774 if (host->ops && host->ops->host_stop)
32ebbc0c
TH		 5775 have_stop = 1;
5776
5777 if (have_stop) {
5778 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
5779 if (!start_dr)
5780 return -ENOMEM;
5781 }
5782
5783 for (i = 0; i < host->n_ports; i++) {
5784 struct ata_port *ap = host->ports[i];
5785
ecef7253
TH		 5786 if (ap->ops->port_start) {
5787 rc = ap->ops->port_start(ap);
5788 if (rc) {
0f9fe9b7 5789 if (rc != -ENODEV)
a44fec1f
JP		 5790 dev_err(host->dev,
5791 "failed to start port %d (errno=%d)\n",
5792 i, rc);
ecef7253
TH		 5793 goto err_out;
5794 }
5795 }
ecef7253
TH		 5796 ata_eh_freeze_port(ap);
5797 }
5798
32ebbc0c
TH		 5799 if (start_dr)
5800 devres_add(host->dev, start_dr);
ecef7253
TH		 5801 host->flags |= ATA_HOST_STARTED;
5802 return 0;
5803
5804 err_out:
5805 while (--i >= 0) {
5806 struct ata_port *ap = host->ports[i];
5807
5808 if (ap->ops->port_stop)
5809 ap->ops->port_stop(ap);
5810 }
32ebbc0c 5811 devres_free(start_dr);
ecef7253
TH		 5812 return rc;
5813}
a52fbcfc 5814EXPORT_SYMBOL_GPL(ata_host_start);
ecef7253 5815
b03732f0 5816/**
94bd5719 5817 * ata_host_init - Initialize a host struct for sas (ipr, libsas)
cca3974e
JG		 5818 * @host: host to initialize
5819 * @dev: device host is attached to
cca3974e 5820 * @ops: port_ops
b03732f0 5821 *
b03732f0 5822 */
cca3974e 5823void ata_host_init(struct ata_host *host, struct device *dev,
8d8e7d13 5824 struct ata_port_operations *ops)
b03732f0 5825{
cca3974e 5826 spin_lock_init(&host->lock);
c0c362b6 5827 mutex_init(&host->eh_mutex);
69278f79 5828 host->n_tags = ATA_MAX_QUEUE;
cca3974e 5829 host->dev = dev;
cca3974e 5830 host->ops = ops;
2fa4a326 5831 kref_init(&host->kref);
b03732f0 5832}
a52fbcfc 5833EXPORT_SYMBOL_GPL(ata_host_init);
b03732f0 5834
a76f1b63 5835void ata_port_probe(struct ata_port *ap)
79318057 5836{
9508a66f
DW		 5837 struct ata_eh_info *ehi = &ap->link.eh_info;
5838 unsigned long flags;
886ad09f 5839
9508a66f
DW		 5840 /* kick EH for boot probing */
5841 spin_lock_irqsave(ap->lock, flags);
79318057 5842
9508a66f
DW		 5843 ehi->probe_mask |= ATA_ALL_DEVICES;
5844 ehi->action |= ATA_EH_RESET;
5845 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
79318057 5846
9508a66f
DW		 5847 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
5848 ap->pflags |= ATA_PFLAG_LOADING;
5849 ata_port_schedule_eh(ap);
79318057 5850
9508a66f
DW		 5851 spin_unlock_irqrestore(ap->lock, flags);
5852}
a76f1b63 5853EXPORT_SYMBOL_GPL(ata_port_probe);
79318057 5854
238c9cf9
JB		 5855static void async_port_probe(void *data, async_cookie_t cookie)
5856{
5857 struct ata_port *ap = data;
4fca377f 5858
238c9cf9
JB		 5859 /*
5860 * If we're not allowed to scan this host in parallel,
5861 * we need to wait until all previous scans have completed
5862 * before going further.
5863 * Jeff Garzik says this is only within a controller, so we
5864 * don't need to wait for port 0, only for later ports.
5865 */
5866 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
5867 async_synchronize_cookie(cookie);
5868
a76f1b63 5869 ata_port_probe(ap);
77461a3f 5870 ata_port_wait_eh(ap);
f29d3b23
AV		 5871
5872 /* in order to keep device order, we need to synchronize at this point */
5873 async_synchronize_cookie(cookie);
5874
5875 ata_scsi_scan_host(ap, 1);
79318057 5876}
238c9cf9 5877
f3187195
TH		 5878/**
5879 * ata_host_register - register initialized ATA host
5880 * @host: ATA host to register
5881 * @sht: template for SCSI host
5882 *
5883 * Register initialized ATA host. @host is allocated using
5884 * ata_host_alloc() and fully initialized by LLD. This function
5885 * starts ports, registers @host with ATA and SCSI layers and
5886 * probe registered devices.
5887 *
5888 * LOCKING:
5889 * Inherited from calling layer (may sleep).
5890 *
5891 * RETURNS:
5892 * 0 on success, -errno otherwise.
5893 */
25df73d9 5894int ata_host_register(struct ata_host *host, const struct scsi_host_template *sht)
f3187195
TH		 5895{
5896 int i, rc;
5897
69278f79 5898 host->n_tags = clamp(sht->can_queue, 1, ATA_MAX_QUEUE);
1871ee13 5899
f3187195
TH		 5900 /* host must have been started */
5901 if (!(host->flags & ATA_HOST_STARTED)) {
a44fec1f 5902 dev_err(host->dev, "BUG: trying to register unstarted host\n");
f3187195
TH		 5903 WARN_ON(1);
5904 return -EINVAL;
5905 }
5906
5907 /* Blow away unused ports. This happens when LLD can't
5908 * determine the exact number of ports to allocate at
5909 * allocation time.
5910 */
5911 for (i = host->n_ports; host->ports[i]; i++)
5912 kfree(host->ports[i]);
5913
5914 /* give ports names and add SCSI hosts */
e628dc99 5915 for (i = 0; i < host->n_ports; i++) {
85d6725b 5916 host->ports[i]->print_id = atomic_inc_return(&ata_print_id);
e628dc99
DM		 5917 host->ports[i]->local_port_no = i + 1;
5918 }
4fca377f 5919
d9027470
GG		 5920 /* Create associated sysfs transport objects */
5921 for (i = 0; i < host->n_ports; i++) {
5922 rc = ata_tport_add(host->dev,host->ports[i]);
5923 if (rc) {
5924 goto err_tadd;
5925 }
5926 }
5927
f3187195
TH		 5928 rc = ata_scsi_add_hosts(host, sht);
5929 if (rc)
d9027470 5930 goto err_tadd;
f3187195
TH		 5931
5932 /* set cable, sata_spd_limit and report */
5933 for (i = 0; i < host->n_ports; i++) {
5934 struct ata_port *ap = host->ports[i];
f0a6d77b 5935 unsigned int xfer_mask;
f3187195
TH		 5936
5937 /* set SATA cable type if still unset */
5938 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
5939 ap->cbl = ATA_CBL_SATA;
5940
5941 /* init sata_spd_limit to the current value */
4fb37a25 5942 sata_link_init_spd(&ap->link);
b1c72916
TH		 5943 if (ap->slave_link)
5944 sata_link_init_spd(ap->slave_link);
f3187195 5945
cbcdd875 5946 /* print per-port info to dmesg */
f3187195
TH		 5947 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
5948 ap->udma_mask);
5949
abf6e8ed 5950 if (!ata_port_is_dummy(ap)) {
a9a79dfe
JP		 5951 ata_port_info(ap, "%cATA max %s %s\n",
5952 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
5953 ata_mode_string(xfer_mask),
5954 ap->link.eh_info.desc);
abf6e8ed
TH		 5955 ata_ehi_clear_desc(&ap->link.eh_info);
5956 } else
a9a79dfe 5957 ata_port_info(ap, "DUMMY\n");
f3187195
TH		 5958 }
5959
f6005354 5960 /* perform each probe asynchronously */
f3187195
TH		 5961 for (i = 0; i < host->n_ports; i++) {
5962 struct ata_port *ap = host->ports[i];
b5292111 5963 ap->cookie = async_schedule(async_port_probe, ap);
f3187195 5964 }
f3187195
TH		 5965
5966 return 0;
d9027470
GG		 5967
5968 err_tadd:
5969 while (--i >= 0) {
5970 ata_tport_delete(host->ports[i]);
5971 }
5972 return rc;
5973
f3187195 5974}
a52fbcfc 5975EXPORT_SYMBOL_GPL(ata_host_register);
f3187195 5976
f5cda257
TH		 5977/**
5978 * ata_host_activate - start host, request IRQ and register it
5979 * @host: target ATA host
5980 * @irq: IRQ to request
5981 * @irq_handler: irq_handler used when requesting IRQ
5982 * @irq_flags: irq_flags used when requesting IRQ
5983 * @sht: scsi_host_template to use when registering the host
5984 *
5985 * After allocating an ATA host and initializing it, most libata
5986 * LLDs perform three steps to activate the host - start host,
c9b5560a 5987 * request IRQ and register it. This helper takes necessary
f5cda257
TH		 5988 * arguments and performs the three steps in one go.
5989 *
3d46b2e2
PM		 5990 * An invalid IRQ skips the IRQ registration and expects the host to
5991 * have set polling mode on the port. In this case, @irq_handler
5992 * should be NULL.
5993 *
f5cda257
TH		 5994 * LOCKING:
5995 * Inherited from calling layer (may sleep).
5996 *
5997 * RETURNS:
5998 * 0 on success, -errno otherwise.
5999 */
6000int ata_host_activate(struct ata_host *host, int irq,
6001 irq_handler_t irq_handler, unsigned long irq_flags,
25df73d9 6002 const struct scsi_host_template *sht)
f5cda257 6003{
cbcdd875 6004 int i, rc;
7e22c002 6005 char *irq_desc;
f5cda257
TH		 6006
6007 rc = ata_host_start(host);
6008 if (rc)
6009 return rc;
6010
3d46b2e2
PM		 6011 /* Special case for polling mode */
6012 if (!irq) {
6013 WARN_ON(irq_handler);
6014 return ata_host_register(host, sht);
6015 }
6016
7e22c002
HK		 6017 irq_desc = devm_kasprintf(host->dev, GFP_KERNEL, "%s[%s]",
6018 dev_driver_string(host->dev),
6019 dev_name(host->dev));
6020 if (!irq_desc)
6021 return -ENOMEM;
6022
f5cda257 6023 rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
7e22c002 6024 irq_desc, host);
f5cda257
TH		 6025 if (rc)
6026 return rc;
6027
cbcdd875
TH		 6028 for (i = 0; i < host->n_ports; i++)
6029 ata_port_desc(host->ports[i], "irq %d", irq);
4031826b 6030
f5cda257
TH		 6031 rc = ata_host_register(host, sht);
6032 /* if failed, just free the IRQ and leave ports alone */
6033 if (rc)
6034 devm_free_irq(host->dev, irq, host);
6035
6036 return rc;
6037}
a52fbcfc 6038EXPORT_SYMBOL_GPL(ata_host_activate);
f5cda257 6039
720ba126 6040/**
c9b5560a 6041 * ata_port_detach - Detach ATA port in preparation of device removal
720ba126
TH		 6042 * @ap: ATA port to be detached
6043 *
6044 * Detach all ATA devices and the associated SCSI devices of @ap;
6045 * then, remove the associated SCSI host. @ap is guaranteed to
6046 * be quiescent on return from this function.
6047 *
6048 * LOCKING:
6049 * Kernel thread context (may sleep).
6050 */
741b7763 6051static void ata_port_detach(struct ata_port *ap)
720ba126
TH		 6052{
6053 unsigned long flags;
a6f9bf4d
LK		 6054 struct ata_link *link;
6055 struct ata_device *dev;
720ba126 6056
84d76529
DLM		 6057 /* Wait for any ongoing EH */
6058 ata_port_wait_eh(ap);
6059
6060 mutex_lock(&ap->scsi_scan_mutex);
ba6a1308 6061 spin_lock_irqsave(ap->lock, flags);
84d76529
DLM		 6062
6063 /* Remove scsi devices */
6064 ata_for_each_link(link, ap, HOST_FIRST) {
6065 ata_for_each_dev(dev, link, ALL) {
6066 if (dev->sdev) {
6067 spin_unlock_irqrestore(ap->lock, flags);
6068 scsi_remove_device(dev->sdev);
6069 spin_lock_irqsave(ap->lock, flags);
6070 dev->sdev = NULL;
6071 }
6072 }
6073 }
6074
6075 /* Tell EH to disable all devices */
b51e9e5d 6076 ap->pflags |= ATA_PFLAG_UNLOADING;
ece180d1 6077 ata_port_schedule_eh(ap);
84d76529 6078
ba6a1308 6079 spin_unlock_irqrestore(ap->lock, flags);
84d76529 6080 mutex_unlock(&ap->scsi_scan_mutex);
720ba126 6081
ece180d1 6082 /* wait till EH commits suicide */
720ba126
TH		 6083 ata_port_wait_eh(ap);
6084
ece180d1
TH		 6085 /* it better be dead now */
6086 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
720ba126 6087
afe2c511 6088 cancel_delayed_work_sync(&ap->hotplug_task);
6aa0365a 6089 cancel_delayed_work_sync(&ap->scsi_rescan_task);
720ba126 6090
a6f9bf4d
LK		 6091 /* clean up zpodd on port removal */
6092 ata_for_each_link(link, ap, HOST_FIRST) {
6093 ata_for_each_dev(dev, link, ALL) {
6094 if (zpodd_dev_enabled(dev))
6095 zpodd_exit(dev);
6096 }
6097 }
d9027470
GG		 6098 if (ap->pmp_link) {
6099 int i;
6100 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
6101 ata_tlink_delete(&ap->pmp_link[i]);
6102 }
720ba126 6103 /* remove the associated SCSI host */
cca3974e 6104 scsi_remove_host(ap->scsi_host);
c5700766 6105 ata_tport_delete(ap);
720ba126
TH		 6106}
6107
0529c159
TH		 6108/**
6109 * ata_host_detach - Detach all ports of an ATA host
6110 * @host: Host to detach
6111 *
6112 * Detach all ports of @host.
6113 *
6114 * LOCKING:
6115 * Kernel thread context (may sleep).
6116 */
6117void ata_host_detach(struct ata_host *host)
6118{
6119 int i;
6120
b5292111
KHF		 6121 for (i = 0; i < host->n_ports; i++) {
6122 /* Ensure ata_port probe has completed */
6123 async_synchronize_cookie(host->ports[i]->cookie + 1);
0529c159 6124 ata_port_detach(host->ports[i]);
b5292111 6125 }
562f0c2d
TH		 6126
6127 /* the host is dead now, dissociate ACPI */
6128 ata_acpi_dissociate(host);
0529c159 6129}
a52fbcfc 6130EXPORT_SYMBOL_GPL(ata_host_detach);
0529c159 6131
374b1873
JG		 6132#ifdef CONFIG_PCI
6133
1da177e4
LT		 6134/**
6135 * ata_pci_remove_one - PCI layer callback for device removal
6136 * @pdev: PCI device that was removed
6137 *
b878ca5d
TH		 6138 * PCI layer indicates to libata via this hook that hot-unplug or
6139 * module unload event has occurred. Detach all ports. Resource
6140 * release is handled via devres.
1da177e4
LT		 6141 *
6142 * LOCKING:
6143 * Inherited from PCI layer (may sleep).
6144 */
f0d36efd 6145void ata_pci_remove_one(struct pci_dev *pdev)
1da177e4 6146{
04a3f5b7 6147 struct ata_host *host = pci_get_drvdata(pdev);
1da177e4 6148
b878ca5d 6149 ata_host_detach(host);
1da177e4 6150}
a52fbcfc 6151EXPORT_SYMBOL_GPL(ata_pci_remove_one);
1da177e4 6152
10a663a1
PK		 6153void ata_pci_shutdown_one(struct pci_dev *pdev)
6154{
6155 struct ata_host *host = pci_get_drvdata(pdev);
6156 int i;
6157
6158 for (i = 0; i < host->n_ports; i++) {
6159 struct ata_port *ap = host->ports[i];
6160
6161 ap->pflags |= ATA_PFLAG_FROZEN;
6162
6163 /* Disable port interrupts */
6164 if (ap->ops->freeze)
6165 ap->ops->freeze(ap);
6166
6167 /* Stop the port DMA engines */
6168 if (ap->ops->port_stop)
6169 ap->ops->port_stop(ap);
6170 }
6171}
a52fbcfc 6172EXPORT_SYMBOL_GPL(ata_pci_shutdown_one);
10a663a1 6173
1da177e4 6174/* move to PCI subsystem */
057ace5e 6175int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
1da177e4
LT		 6176{
6177 unsigned long tmp = 0;
6178
6179 switch (bits->width) {
6180 case 1: {
6181 u8 tmp8 = 0;
6182 pci_read_config_byte(pdev, bits->reg, &tmp8);
6183 tmp = tmp8;
6184 break;
6185 }
6186 case 2: {
6187 u16 tmp16 = 0;
6188 pci_read_config_word(pdev, bits->reg, &tmp16);
6189 tmp = tmp16;
6190 break;
6191 }
6192 case 4: {
6193 u32 tmp32 = 0;
6194 pci_read_config_dword(pdev, bits->reg, &tmp32);
6195 tmp = tmp32;
6196 break;
6197 }
6198
6199 default:
6200 return -EINVAL;
6201 }
6202
6203 tmp &= bits->mask;
6204
6205 return (tmp == bits->val) ? 1 : 0;
6206}
a52fbcfc 6207EXPORT_SYMBOL_GPL(pci_test_config_bits);
9b847548 6208
6ffa01d8 6209#ifdef CONFIG_PM
3c5100c1 6210void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
9b847548
JA		 6211{
6212 pci_save_state(pdev);
4c90d971 6213 pci_disable_device(pdev);
500530f6 6214
3a2d5b70 6215 if (mesg.event & PM_EVENT_SLEEP)
500530f6 6216 pci_set_power_state(pdev, PCI_D3hot);
9b847548 6217}
a52fbcfc 6218EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
9b847548 6219
553c4aa6 6220int ata_pci_device_do_resume(struct pci_dev *pdev)
9b847548 6221{
553c4aa6
TH		 6222 int rc;
6223
9b847548
JA		 6224 pci_set_power_state(pdev, PCI_D0);
6225 pci_restore_state(pdev);
553c4aa6 6226
b878ca5d 6227 rc = pcim_enable_device(pdev);
553c4aa6 6228 if (rc) {
a44fec1f
JP		 6229 dev_err(&pdev->dev,
6230 "failed to enable device after resume (%d)\n", rc);
553c4aa6
TH		 6231 return rc;
6232 }
6233
9b847548 6234 pci_set_master(pdev);
553c4aa6 6235 return 0;
500530f6 6236}
a52fbcfc 6237EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
500530f6 6238
3c5100c1 6239int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
500530f6 6240{
04a3f5b7 6241 struct ata_host *host = pci_get_drvdata(pdev);
500530f6 6242
ec87cf37 6243 ata_host_suspend(host, mesg);
500530f6 6244
3c5100c1 6245 ata_pci_device_do_suspend(pdev, mesg);
500530f6
TH		 6246
6247 return 0;
6248}
a52fbcfc 6249EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
500530f6
TH		 6250
6251int ata_pci_device_resume(struct pci_dev *pdev)
6252{
04a3f5b7 6253 struct ata_host *host = pci_get_drvdata(pdev);
553c4aa6 6254 int rc;
500530f6 6255
553c4aa6
TH		 6256 rc = ata_pci_device_do_resume(pdev);
6257 if (rc == 0)
6258 ata_host_resume(host);
6259 return rc;
9b847548 6260}
a52fbcfc 6261EXPORT_SYMBOL_GPL(ata_pci_device_resume);
6ffa01d8 6262#endif /* CONFIG_PM */
1da177e4
LT		 6263#endif /* CONFIG_PCI */
6264
b7db04d9
BN		 6265/**
6266 * ata_platform_remove_one - Platform layer callback for device removal
6267 * @pdev: Platform device that was removed
6268 *
6269 * Platform layer indicates to libata via this hook that hot-unplug or
6270 * module unload event has occurred. Detach all ports. Resource
6271 * release is handled via devres.
6272 *
6273 * LOCKING:
6274 * Inherited from platform layer (may sleep).
6275 */
a7eb54d4 6276void ata_platform_remove_one(struct platform_device *pdev)
b7db04d9
BN		 6277{
6278 struct ata_host *host = platform_get_drvdata(pdev);
6279
6280 ata_host_detach(host);
b7db04d9 6281}
a52fbcfc 6282EXPORT_SYMBOL_GPL(ata_platform_remove_one);
b7db04d9 6283
bf89b0bf 6284#ifdef CONFIG_ATA_FORCE
168af4af
DLM		 6285
6286#define force_cbl(name, flag) \
6287 { #name, .cbl = (flag) }
6288
6289#define force_spd_limit(spd, val) \
6290 { #spd, .spd_limit = (val) }
6291
6292#define force_xfer(mode, shift) \
6293 { #mode, .xfer_mask = (1UL << (shift)) }
6294
3af9ca4d
DLM		 6295#define force_lflag_on(name, flags) \
6296 { #name, .lflags_on = (flags) }
6297
6298#define force_lflag_onoff(name, flags) \
6299 { "no" #name, .lflags_on = (flags) }, \
6300 { #name, .lflags_off = (flags) }
168af4af
DLM		 6301
6302#define force_horkage_on(name, flag) \
6303 { #name, .horkage_on = (flag) }
6304
6305#define force_horkage_onoff(name, flag) \
6306 { "no" #name, .horkage_on = (flag) }, \
6307 { #name, .horkage_off = (flag) }
6308
6309static const struct ata_force_param force_tbl[] __initconst = {
6310 force_cbl(40c, ATA_CBL_PATA40),
6311 force_cbl(80c, ATA_CBL_PATA80),
6312 force_cbl(short40c, ATA_CBL_PATA40_SHORT),
6313 force_cbl(unk, ATA_CBL_PATA_UNK),
6314 force_cbl(ign, ATA_CBL_PATA_IGN),
6315 force_cbl(sata, ATA_CBL_SATA),
6316
6317 force_spd_limit(1.5Gbps, 1),
6318 force_spd_limit(3.0Gbps, 2),
6319
6320 force_xfer(pio0, ATA_SHIFT_PIO + 0),
6321 force_xfer(pio1, ATA_SHIFT_PIO + 1),
6322 force_xfer(pio2, ATA_SHIFT_PIO + 2),
6323 force_xfer(pio3, ATA_SHIFT_PIO + 3),
6324 force_xfer(pio4, ATA_SHIFT_PIO + 4),
6325 force_xfer(pio5, ATA_SHIFT_PIO + 5),
6326 force_xfer(pio6, ATA_SHIFT_PIO + 6),
6327 force_xfer(mwdma0, ATA_SHIFT_MWDMA + 0),
6328 force_xfer(mwdma1, ATA_SHIFT_MWDMA + 1),
6329 force_xfer(mwdma2, ATA_SHIFT_MWDMA + 2),
6330 force_xfer(mwdma3, ATA_SHIFT_MWDMA + 3),
6331 force_xfer(mwdma4, ATA_SHIFT_MWDMA + 4),
6332 force_xfer(udma0, ATA_SHIFT_UDMA + 0),
6333 force_xfer(udma16, ATA_SHIFT_UDMA + 0),
6334 force_xfer(udma/16, ATA_SHIFT_UDMA + 0),
6335 force_xfer(udma1, ATA_SHIFT_UDMA + 1),
6336 force_xfer(udma25, ATA_SHIFT_UDMA + 1),
6337 force_xfer(udma/25, ATA_SHIFT_UDMA + 1),
6338 force_xfer(udma2, ATA_SHIFT_UDMA + 2),
6339 force_xfer(udma33, ATA_SHIFT_UDMA + 2),
6340 force_xfer(udma/33, ATA_SHIFT_UDMA + 2),
6341 force_xfer(udma3, ATA_SHIFT_UDMA + 3),
6342 force_xfer(udma44, ATA_SHIFT_UDMA + 3),
6343 force_xfer(udma/44, ATA_SHIFT_UDMA + 3),
6344 force_xfer(udma4, ATA_SHIFT_UDMA + 4),
6345 force_xfer(udma66, ATA_SHIFT_UDMA + 4),
6346 force_xfer(udma/66, ATA_SHIFT_UDMA + 4),
6347 force_xfer(udma5, ATA_SHIFT_UDMA + 5),
6348 force_xfer(udma100, ATA_SHIFT_UDMA + 5),
6349 force_xfer(udma/100, ATA_SHIFT_UDMA + 5),
6350 force_xfer(udma6, ATA_SHIFT_UDMA + 6),
6351 force_xfer(udma133, ATA_SHIFT_UDMA + 6),
6352 force_xfer(udma/133, ATA_SHIFT_UDMA + 6),
6353 force_xfer(udma7, ATA_SHIFT_UDMA + 7),
6354
3af9ca4d
DLM		 6355 force_lflag_on(nohrst, ATA_LFLAG_NO_HRST),
6356 force_lflag_on(nosrst, ATA_LFLAG_NO_SRST),
6357 force_lflag_on(norst, ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST),
6358 force_lflag_on(rstonce, ATA_LFLAG_RST_ONCE),
6359 force_lflag_onoff(dbdelay, ATA_LFLAG_NO_DEBOUNCE_DELAY),
168af4af
DLM		 6360
6361 force_horkage_onoff(ncq, ATA_HORKAGE_NONCQ),
6362 force_horkage_onoff(ncqtrim, ATA_HORKAGE_NO_NCQ_TRIM),
6363 force_horkage_onoff(ncqati, ATA_HORKAGE_NO_NCQ_ON_ATI),
6364
2c33bbda
DLM		 6365 force_horkage_onoff(trim, ATA_HORKAGE_NOTRIM),
6366 force_horkage_on(trim_zero, ATA_HORKAGE_ZERO_AFTER_TRIM),
6367 force_horkage_on(max_trim_128m, ATA_HORKAGE_MAX_TRIM_128M),
6368
6369 force_horkage_onoff(dma, ATA_HORKAGE_NODMA),
168af4af 6370 force_horkage_on(atapi_dmadir, ATA_HORKAGE_ATAPI_DMADIR),
2c33bbda
DLM		 6371 force_horkage_on(atapi_mod16_dma, ATA_HORKAGE_ATAPI_MOD16_DMA),
6372
6373 force_horkage_onoff(dmalog, ATA_HORKAGE_NO_DMA_LOG),
6374 force_horkage_onoff(iddevlog, ATA_HORKAGE_NO_ID_DEV_LOG),
6375 force_horkage_onoff(logdir, ATA_HORKAGE_NO_LOG_DIR),
6376
6377 force_horkage_on(max_sec_128, ATA_HORKAGE_MAX_SEC_128),
6378 force_horkage_on(max_sec_1024, ATA_HORKAGE_MAX_SEC_1024),
6379 force_horkage_on(max_sec_lba48, ATA_HORKAGE_MAX_SEC_LBA48),
6380
6381 force_horkage_onoff(lpm, ATA_HORKAGE_NOLPM),
6382 force_horkage_onoff(setxfer, ATA_HORKAGE_NOSETXFER),
6383 force_horkage_on(dump_id, ATA_HORKAGE_DUMP_ID),
4d2e4980 6384 force_horkage_onoff(fua, ATA_HORKAGE_NO_FUA),
2c33bbda
DLM		 6385
6386 force_horkage_on(disable, ATA_HORKAGE_DISABLE),
168af4af
DLM		 6387};
6388
33267325
TH		 6389static int __init ata_parse_force_one(char **cur,
6390 struct ata_force_ent *force_ent,
6391 const char **reason)
6392{
33267325
TH		 6393 char *start = *cur, *p = *cur;
6394 char *id, *val, *endp;
6395 const struct ata_force_param *match_fp = NULL;
6396 int nr_matches = 0, i;
6397
6398 /* find where this param ends and update *cur */
6399 while (*p != '\0' && *p != ',')
6400 p++;
6401
6402 if (*p == '\0')
6403 *cur = p;
6404 else
6405 *cur = p + 1;
6406
6407 *p = '\0';
6408
6409 /* parse */
6410 p = strchr(start, ':');
6411 if (!p) {
6412 val = strstrip(start);
6413 goto parse_val;
6414 }
6415 *p = '\0';
6416
6417 id = strstrip(start);
6418 val = strstrip(p + 1);
6419
6420 /* parse id */
6421 p = strchr(id, '.');
6422 if (p) {
6423 *p++ = '\0';
6424 force_ent->device = simple_strtoul(p, &endp, 10);
6425 if (p == endp || *endp != '\0') {
6426 *reason = "invalid device";
6427 return -EINVAL;
6428 }
6429 }
6430
6431 force_ent->port = simple_strtoul(id, &endp, 10);
f7cf69ae 6432 if (id == endp || *endp != '\0') {
33267325
TH		 6433 *reason = "invalid port/link";
6434 return -EINVAL;
6435 }
6436
6437 parse_val:
6438 /* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */
6439 for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
6440 const struct ata_force_param *fp = &force_tbl[i];
6441
6442 if (strncasecmp(val, fp->name, strlen(val)))
6443 continue;
6444
6445 nr_matches++;
6446 match_fp = fp;
6447
6448 if (strcasecmp(val, fp->name) == 0) {
6449 nr_matches = 1;
6450 break;
6451 }
6452 }
6453
6454 if (!nr_matches) {
6455 *reason = "unknown value";
6456 return -EINVAL;
6457 }
6458 if (nr_matches > 1) {
9de55351 6459 *reason = "ambiguous value";
33267325
TH		 6460 return -EINVAL;
6461 }
6462
6463 force_ent->param = *match_fp;
6464
6465 return 0;
6466}
6467
6468static void __init ata_parse_force_param(void)
6469{
6470 int idx = 0, size = 1;
6471 int last_port = -1, last_device = -1;
6472 char *p, *cur, *next;
6473
168af4af 6474 /* Calculate maximum number of params and allocate ata_force_tbl */
33267325
TH		 6475 for (p = ata_force_param_buf; *p; p++)
6476 if (*p == ',')
6477 size++;
6478
6396bb22 6479 ata_force_tbl = kcalloc(size, sizeof(ata_force_tbl[0]), GFP_KERNEL);
33267325
TH		 6480 if (!ata_force_tbl) {
6481 printk(KERN_WARNING "ata: failed to extend force table, "
6482 "libata.force ignored\n");
6483 return;
6484 }
6485
6486 /* parse and populate the table */
6487 for (cur = ata_force_param_buf; *cur != '\0'; cur = next) {
6488 const char *reason = "";
6489 struct ata_force_ent te = { .port = -1, .device = -1 };
6490
6491 next = cur;
6492 if (ata_parse_force_one(&next, &te, &reason)) {
6493 printk(KERN_WARNING "ata: failed to parse force "
6494 "parameter \"%s\" (%s)\n",
6495 cur, reason);
6496 continue;
6497 }
6498
6499 if (te.port == -1) {
6500 te.port = last_port;
6501 te.device = last_device;
6502 }
6503
6504 ata_force_tbl[idx++] = te;
6505
6506 last_port = te.port;
6507 last_device = te.device;
6508 }
6509
6510 ata_force_tbl_size = idx;
6511}
1da177e4 6512
bf89b0bf
BZ		 6513static void ata_free_force_param(void)
6514{
6515 kfree(ata_force_tbl);
6516}
6517#else
6518static inline void ata_parse_force_param(void) { }
6519static inline void ata_free_force_param(void) { }
6520#endif
6521
1da177e4
LT		 6522static int __init ata_init(void)
6523{
d9027470 6524 int rc;
270390e1 6525
33267325
TH		 6526 ata_parse_force_param();
6527
270390e1 6528 rc = ata_sff_init();
ad72cf98 6529 if (rc) {
bf89b0bf 6530 ata_free_force_param();
ad72cf98
TH		 6531 return rc;
6532 }
453b07ac 6533
d9027470
GG		 6534 libata_transport_init();
6535 ata_scsi_transport_template = ata_attach_transport();
6536 if (!ata_scsi_transport_template) {
6537 ata_sff_exit();
6538 rc = -ENOMEM;
6539 goto err_out;
4fca377f 6540 }
d9027470 6541
1da177e4
LT		 6542 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6543 return 0;
d9027470
GG		 6544
6545err_out:
6546 return rc;
1da177e4
LT		 6547}
6548
6549static void __exit ata_exit(void)
6550{
d9027470
GG		 6551 ata_release_transport(ata_scsi_transport_template);
6552 libata_transport_exit();
270390e1 6553 ata_sff_exit();
bf89b0bf 6554 ata_free_force_param();
1da177e4
LT		 6555}
6556
a4625085 6557subsys_initcall(ata_init);
1da177e4
LT		 6558module_exit(ata_exit);
6559
9990b6f3 6560static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
67846b30
JG		 6561
6562int ata_ratelimit(void)
6563{
9990b6f3 6564 return __ratelimit(&ratelimit);
67846b30 6565}
a52fbcfc 6566EXPORT_SYMBOL_GPL(ata_ratelimit);
67846b30 6567
c0c362b6
TH		 6568/**
6569 * ata_msleep - ATA EH owner aware msleep
6570 * @ap: ATA port to attribute the sleep to
6571 * @msecs: duration to sleep in milliseconds
6572 *
6573 * Sleeps @msecs. If the current task is owner of @ap's EH, the
6574 * ownership is released before going to sleep and reacquired
6575 * after the sleep is complete. IOW, other ports sharing the
6576 * @ap->host will be allowed to own the EH while this task is
6577 * sleeping.
6578 *
6579 * LOCKING:
6580 * Might sleep.
6581 */
97750ceb
TH		 6582void ata_msleep(struct ata_port *ap, unsigned int msecs)
6583{
c0c362b6
TH		 6584 bool owns_eh = ap && ap->host->eh_owner == current;
6585
6586 if (owns_eh)
6587 ata_eh_release(ap);
6588
848c3920
AVM		 6589 if (msecs < 20) {
6590 unsigned long usecs = msecs * USEC_PER_MSEC;
6591 usleep_range(usecs, usecs + 50);
6592 } else {
6593 msleep(msecs);
6594 }
c0c362b6
TH		 6595
6596 if (owns_eh)
6597 ata_eh_acquire(ap);
97750ceb 6598}
a52fbcfc 6599EXPORT_SYMBOL_GPL(ata_msleep);
97750ceb 6600
c22daff4
TH		 6601/**
6602 * ata_wait_register - wait until register value changes
97750ceb 6603 * @ap: ATA port to wait register for, can be NULL
c22daff4
TH		 6604 * @reg: IO-mapped register
6605 * @mask: Mask to apply to read register value
6606 * @val: Wait condition
341c2c95
TH		 6607 * @interval: polling interval in milliseconds
6608 * @timeout: timeout in milliseconds
c22daff4
TH		 6609 *
6610 * Waiting for some bits of register to change is a common
6611 * operation for ATA controllers. This function reads 32bit LE
6612 * IO-mapped register @reg and tests for the following condition.
6613 *
6614 * (*@reg & mask) != val
6615 *
6616 * If the condition is met, it returns; otherwise, the process is
6617 * repeated after @interval_msec until timeout.
6618 *
6619 * LOCKING:
6620 * Kernel thread context (may sleep)
6621 *
6622 * RETURNS:
6623 * The final register value.
6624 */
97750ceb 6625u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
84abed36 6626 unsigned int interval, unsigned int timeout)
c22daff4 6627{
341c2c95 6628 unsigned long deadline;
c22daff4
TH		 6629 u32 tmp;
6630
6631 tmp = ioread32(reg);
6632
6633 /* Calculate timeout _after_ the first read to make sure
6634 * preceding writes reach the controller before starting to
6635 * eat away the timeout.
6636 */
341c2c95 6637 deadline = ata_deadline(jiffies, timeout);
c22daff4 6638
341c2c95 6639 while ((tmp & mask) == val && time_before(jiffies, deadline)) {
97750ceb 6640 ata_msleep(ap, interval);
c22daff4
TH		 6641 tmp = ioread32(reg);
6642 }
6643
6644 return tmp;
6645}
a52fbcfc 6646EXPORT_SYMBOL_GPL(ata_wait_register);
c22daff4 6647
dd5b06c4
TH		 6648/*
6649 * Dummy port_ops
6650 */
182d7bba 6651static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
dd5b06c4 6652{
182d7bba 6653 return AC_ERR_SYSTEM;
dd5b06c4
TH		 6654}
6655
182d7bba 6656static void ata_dummy_error_handler(struct ata_port *ap)
dd5b06c4 6657{
182d7bba 6658 /* truly dummy */
dd5b06c4
TH		 6659}
6660
029cfd6b 6661struct ata_port_operations ata_dummy_port_ops = {
dd5b06c4
TH		 6662 .qc_prep = ata_noop_qc_prep,
6663 .qc_issue = ata_dummy_qc_issue,
182d7bba 6664 .error_handler = ata_dummy_error_handler,
e4a9c373
DW		 6665 .sched_eh = ata_std_sched_eh,
6666 .end_eh = ata_std_end_eh,
dd5b06c4 6667};
a52fbcfc 6668EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
dd5b06c4 6669
21b0ad4f
TH		 6670const struct ata_port_info ata_dummy_port_info = {
6671 .port_ops = &ata_dummy_port_ops,
6672};
a52fbcfc 6673EXPORT_SYMBOL_GPL(ata_dummy_port_info);
21b0ad4f 6674
06296a1e
JP		 6675void ata_print_version(const struct device *dev, const char *version)
6676{
6677 dev_printk(KERN_DEBUG, dev, "version %s\n", version);
6678}
6679EXPORT_SYMBOL(ata_print_version);
c206a389
HR		 6680
6681EXPORT_TRACEPOINT_SYMBOL_GPL(ata_tf_load);
6682EXPORT_TRACEPOINT_SYMBOL_GPL(ata_exec_command);
6683EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_setup);
6684EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_start);
6685EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_status);
Linux 6.x block layer and io_uring tree(s)