]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - drivers/ata/libata-core.c
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ata: libata-core: Do not poweroff runtime suspended ports
[thirdparty/kernel/stable.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
8c1f0817
DLM		 1975bool ata_dev_power_init_tf(struct ata_device *dev, struct ata_taskfile *tf,
1976 bool set_active)
1977{
1978 /* Only applies to ATA and ZAC devices */
1979 if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC)
1980 return false;
1981
1982 ata_tf_init(dev, tf);
1983 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1984 tf->protocol = ATA_PROT_NODATA;
1985
1986 if (set_active) {
1987 /* VERIFY for 1 sector at lba=0 */
1988 tf->command = ATA_CMD_VERIFY;
1989 tf->nsect = 1;
1990 if (dev->flags & ATA_DFLAG_LBA) {
1991 tf->flags |= ATA_TFLAG_LBA;
1992 tf->device |= ATA_LBA;
1993 } else {
1994 /* CHS */
1995 tf->lbal = 0x1; /* sect */
1996 }
1997 } else {
1998 tf->command = ATA_CMD_STANDBYNOW1;
1999 }
2000
2001 return true;
2002}
2003
aa3998db
DLM		 2004/**
2005 * ata_dev_power_set_standby - Set a device power mode to standby
2006 * @dev: target device
2007 *
2008 * Issue a STANDBY IMMEDIATE command to set a device power mode to standby.
2009 * For an HDD device, this spins down the disks.
2010 *
2011 * LOCKING:
2012 * Kernel thread context (may sleep).
2013 */
2014void ata_dev_power_set_standby(struct ata_device *dev)
2015{
2016 unsigned long ap_flags = dev->link->ap->flags;
2017 struct ata_taskfile tf;
2018 unsigned int err_mask;
2019
aa3998db
DLM		 2020 /*
2021 * Some odd clown BIOSes issue spindown on power off (ACPI S4 or S5)
2022 * causing some drives to spin up and down again. For these, do nothing
2023 * if we are being called on shutdown.
2024 */
2025 if ((ap_flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
2026 system_state == SYSTEM_POWER_OFF)
2027 return;
2028
2029 if ((ap_flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
2030 system_entering_hibernation())
2031 return;
2032
8c1f0817
DLM		 2033 /* Issue STANDBY IMMEDIATE command only if supported by the device */
2034 if (!ata_dev_power_init_tf(dev, &tf, false))
2035 return;
aa3998db
DLM		 2036
2037 ata_dev_notice(dev, "Entering standby power mode\n");
2038
2039 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2040 if (err_mask)
2041 ata_dev_err(dev, "STANDBY IMMEDIATE failed (err_mask=0x%x)\n",
2042 err_mask);
2043}
2044
2045/**
2046 * ata_dev_power_set_active - Set a device power mode to active
2047 * @dev: target device
2048 *
2049 * Issue a VERIFY command to enter to ensure that the device is in the
2050 * active power mode. For a spun-down HDD (standby or idle power mode),
2051 * the VERIFY command will complete after the disk spins up.
2052 *
2053 * LOCKING:
2054 * Kernel thread context (may sleep).
2055 */
2056void ata_dev_power_set_active(struct ata_device *dev)
2057{
2058 struct ata_taskfile tf;
2059 unsigned int err_mask;
2060
2061 /*
2062 * Issue READ VERIFY SECTORS command for 1 sector at lba=0 only
2063 * if supported by the device.
2064 */
8c1f0817 2065 if (!ata_dev_power_init_tf(dev, &tf, true))
aa3998db
DLM		 2066 return;
2067
aa3998db
DLM		 2068 ata_dev_notice(dev, "Entering active power mode\n");
2069
2070 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2071 if (err_mask)
2072 ata_dev_err(dev, "VERIFY failed (err_mask=0x%x)\n",
2073 err_mask);
2074}
2075
f01f62c2
CH		 2076/**
2077 * ata_read_log_page - read a specific log page
2078 * @dev: target device
2079 * @log: log to read
2080 * @page: page to read
2081 * @buf: buffer to store read page
2082 * @sectors: number of sectors to read
2083 *
2084 * Read log page using READ_LOG_EXT command.
2085 *
2086 * LOCKING:
2087 * Kernel thread context (may sleep).
2088 *
2089 * RETURNS:
2090 * 0 on success, AC_ERR_* mask otherwise.
2091 */
2092unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
2093 u8 page, void *buf, unsigned int sectors)
2094{
2095 unsigned long ap_flags = dev->link->ap->flags;
2096 struct ata_taskfile tf;
2097 unsigned int err_mask;
2098 bool dma = false;
2099
4633778b 2100 ata_dev_dbg(dev, "read log page - log 0x%x, page 0x%x\n", log, page);
f01f62c2
CH		 2101
2102 /*
2103 * Return error without actually issuing the command on controllers
2104 * which e.g. lockup on a read log page.
2105 */
2106 if (ap_flags & ATA_FLAG_NO_LOG_PAGE)
2107 return AC_ERR_DEV;
2108
2109retry:
2110 ata_tf_init(dev, &tf);
f971a854 2111 if (ata_dma_enabled(dev) && ata_id_has_read_log_dma_ext(dev->id) &&
7cfdfdc8 2112 !(dev->horkage & ATA_HORKAGE_NO_DMA_LOG)) {
f01f62c2
CH		 2113 tf.command = ATA_CMD_READ_LOG_DMA_EXT;
2114 tf.protocol = ATA_PROT_DMA;
2115 dma = true;
2116 } else {
2117 tf.command = ATA_CMD_READ_LOG_EXT;
2118 tf.protocol = ATA_PROT_PIO;
2119 dma = false;
2120 }
2121 tf.lbal = log;
2122 tf.lbam = page;
2123 tf.nsect = sectors;
2124 tf.hob_nsect = sectors >> 8;
2125 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
2126
2127 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
2128 buf, sectors * ATA_SECT_SIZE, 0);
2129
fc5c8aa7
DLM		 2130 if (err_mask) {
2131 if (dma) {
2132 dev->horkage |= ATA_HORKAGE_NO_DMA_LOG;
5122e53e
NC		 2133 if (!ata_port_is_frozen(dev->link->ap))
2134 goto retry;
fc5c8aa7 2135 }
23ef63d5
DLM		 2136 ata_dev_err(dev,
2137 "Read log 0x%02x page 0x%02x failed, Emask 0x%x\n",
2138 (unsigned int)log, (unsigned int)page, err_mask);
f01f62c2
CH		 2139 }
2140
f01f62c2
CH		 2141 return err_mask;
2142}
2143
c745dfc5 2144static int ata_log_supported(struct ata_device *dev, u8 log)
efe205a3
CH		 2145{
2146 struct ata_port *ap = dev->link->ap;
2147
ac9f0c81 2148 if (dev->horkage & ATA_HORKAGE_NO_LOG_DIR)
c745dfc5 2149 return 0;
ac9f0c81 2150
efe205a3 2151 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
c745dfc5
TE		 2152 return 0;
2153 return get_unaligned_le16(&ap->sector_buf[log * 2]);
efe205a3
CH		 2154}
2155
a0fd2454
CH		 2156static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
2157{
2158 struct ata_port *ap = dev->link->ap;
2159 unsigned int err, i;
2160
636f6e2a
DLM		 2161 if (dev->horkage & ATA_HORKAGE_NO_ID_DEV_LOG)
2162 return false;
2163
a0fd2454 2164 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
636f6e2a
DLM		 2165 /*
2166 * IDENTIFY DEVICE data log is defined as mandatory starting
2167 * with ACS-3 (ATA version 10). Warn about the missing log
2168 * for drives which implement this ATA level or above.
2169 */
2170 if (ata_id_major_version(dev->id) >= 10)
2171 ata_dev_warn(dev,
2172 "ATA Identify Device Log not supported\n");
2173 dev->horkage |= ATA_HORKAGE_NO_ID_DEV_LOG;
a0fd2454
CH		 2174 return false;
2175 }
2176
2177 /*
2178 * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
2179 * supported.
2180 */
2181 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0, ap->sector_buf,
2182 1);
fc5c8aa7 2183 if (err)
a0fd2454 2184 return false;
a0fd2454
CH		 2185
2186 for (i = 0; i < ap->sector_buf[8]; i++) {
2187 if (ap->sector_buf[9 + i] == page)
2188 return true;
2189 }
2190
2191 return false;
2192}
2193
9062712f
TH		 2194static int ata_do_link_spd_horkage(struct ata_device *dev)
2195{
2196 struct ata_link *plink = ata_dev_phys_link(dev);
2197 u32 target, target_limit;
2198
2199 if (!sata_scr_valid(plink))
2200 return 0;
2201
2202 if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2203 target = 1;
2204 else
2205 return 0;
2206
2207 target_limit = (1 << target) - 1;
2208
2209 /* if already on stricter limit, no need to push further */
2210 if (plink->sata_spd_limit <= target_limit)
2211 return 0;
2212
2213 plink->sata_spd_limit = target_limit;
2214
2215 /* Request another EH round by returning -EAGAIN if link is
2216 * going faster than the target speed. Forward progress is
2217 * guaranteed by setting sata_spd_limit to target_limit above.
2218 */
2219 if (plink->sata_spd > target) {
a9a79dfe
JP		 2220 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2221 sata_spd_string(target));
9062712f
TH		 2222 return -EAGAIN;
2223 }
2224 return 0;
2225}
2226
3373efd8 2227static inline u8 ata_dev_knobble(struct ata_device *dev)
4b2f3ede 2228{
9af5c9c9 2229 struct ata_port *ap = dev->link->ap;
9ce8e307
JA		 2230
2231 if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2232 return 0;
2233
9af5c9c9 2234 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
4b2f3ede
TH		 2235}
2236
5a233551
HR		 2237static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2238{
2239 struct ata_port *ap = dev->link->ap;
2240 unsigned int err_mask;
2241
efe205a3
CH		 2242 if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
2243 ata_dev_warn(dev, "NCQ Send/Recv Log not supported\n");
fe5af0cc
HR		 2244 return;
2245 }
5a233551
HR		 2246 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2247 0, ap->sector_buf, 1);
fc5c8aa7 2248 if (!err_mask) {
5a233551
HR		 2249 u8 *cmds = dev->ncq_send_recv_cmds;
2250
2251 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2252 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2253
2254 if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2255 ata_dev_dbg(dev, "disabling queued TRIM support\n");
2256 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2257 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2258 }
2259 }
2260}
2261
284b3b77
HR		 2262static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2263{
2264 struct ata_port *ap = dev->link->ap;
2265 unsigned int err_mask;
284b3b77 2266
efe205a3 2267 if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
284b3b77
HR		 2268 ata_dev_warn(dev,
2269 "NCQ Send/Recv Log not supported\n");
2270 return;
2271 }
2272 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2273 0, ap->sector_buf, 1);
fc5c8aa7 2274 if (!err_mask) {
284b3b77
HR		 2275 u8 *cmds = dev->ncq_non_data_cmds;
2276
2277 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2278 }
2279}
2280
8e061784
AM		 2281static void ata_dev_config_ncq_prio(struct ata_device *dev)
2282{
2283 struct ata_port *ap = dev->link->ap;
2284 unsigned int err_mask;
2285
06f6c4c6
DLM		 2286 if (!ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
2287 return;
2288
8e061784 2289 err_mask = ata_read_log_page(dev,
1d51d5f3 2290 ATA_LOG_IDENTIFY_DEVICE,
8e061784
AM		 2291 ATA_LOG_SATA_SETTINGS,
2292 ap->sector_buf,
2293 1);
fc5c8aa7 2294 if (err_mask)
2360fa18 2295 goto not_supported;
8e061784 2296
2360fa18
DLM		 2297 if (!(ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)))
2298 goto not_supported;
2299
2300 dev->flags |= ATA_DFLAG_NCQ_PRIO;
2301
2302 return;
8e061784 2303
2360fa18 2304not_supported:
e00923c5 2305 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED;
2360fa18 2306 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
8e061784
AM		 2307}
2308
7a8526a5
KH		 2309static bool ata_dev_check_adapter(struct ata_device *dev,
2310 unsigned short vendor_id)
2311{
2312 struct pci_dev *pcidev = NULL;
2313 struct device *parent_dev = NULL;
2314
2315 for (parent_dev = dev->tdev.parent; parent_dev != NULL;
2316 parent_dev = parent_dev->parent) {
2317 if (dev_is_pci(parent_dev)) {
2318 pcidev = to_pci_dev(parent_dev);
2319 if (pcidev->vendor == vendor_id)
2320 return true;
2321 break;
2322 }
2323 }
2324
2325 return false;
2326}
2327
388539f3 2328static int ata_dev_config_ncq(struct ata_device *dev,
a6e6ce8e
TH		 2329 char *desc, size_t desc_sz)
2330{
9af5c9c9 2331 struct ata_port *ap = dev->link->ap;
a6e6ce8e 2332 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
388539f3
SL		 2333 unsigned int err_mask;
2334 char *aa_desc = "";
a6e6ce8e
TH		 2335
2336 if (!ata_id_has_ncq(dev->id)) {
2337 desc[0] = '\0';
388539f3 2338 return 0;
a6e6ce8e 2339 }
cba97ea1
BZ		 2340 if (!IS_ENABLED(CONFIG_SATA_HOST))
2341 return 0;
75683fe7 2342 if (dev->horkage & ATA_HORKAGE_NONCQ) {
6919a0a6 2343 snprintf(desc, desc_sz, "NCQ (not used)");
388539f3 2344 return 0;
6919a0a6 2345 }
7a8526a5
KH		 2346
2347 if (dev->horkage & ATA_HORKAGE_NO_NCQ_ON_ATI &&
2348 ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
2349 snprintf(desc, desc_sz, "NCQ (not used)");
2350 return 0;
2351 }
2352
a6e6ce8e 2353 if (ap->flags & ATA_FLAG_NCQ) {
69278f79 2354 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
a6e6ce8e
TH		 2355 dev->flags |= ATA_DFLAG_NCQ;
2356 }
2357
388539f3
SL		 2358 if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2359 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2360 ata_id_has_fpdma_aa(dev->id)) {
2361 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2362 SATA_FPDMA_AA);
2363 if (err_mask) {
a9a79dfe
JP		 2364 ata_dev_err(dev,
2365 "failed to enable AA (error_mask=0x%x)\n",
2366 err_mask);
388539f3
SL		 2367 if (err_mask != AC_ERR_DEV) {
2368 dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2369 return -EIO;
2370 }
2371 } else
2372 aa_desc = ", AA";
2373 }
2374
a6e6ce8e 2375 if (hdepth >= ddepth)
388539f3 2376 snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
a6e6ce8e 2377 else
388539f3
SL		 2378 snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2379 ddepth, aa_desc);
ed36911c 2380
284b3b77
HR		 2381 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2382 if (ata_id_has_ncq_send_and_recv(dev->id))
2383 ata_dev_config_ncq_send_recv(dev);
2384 if (ata_id_has_ncq_non_data(dev->id))
2385 ata_dev_config_ncq_non_data(dev);
8e061784
AM		 2386 if (ata_id_has_ncq_prio(dev->id))
2387 ata_dev_config_ncq_prio(dev);
284b3b77 2388 }
f78dea06 2389
388539f3 2390 return 0;
a6e6ce8e 2391}
f78dea06 2392
e87fd28c
HR		 2393static void ata_dev_config_sense_reporting(struct ata_device *dev)
2394{
2395 unsigned int err_mask;
2396
2397 if (!ata_id_has_sense_reporting(dev->id))
2398 return;
2399
2400 if (ata_id_sense_reporting_enabled(dev->id))
2401 return;
2402
2403 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2404 if (err_mask) {
2405 ata_dev_dbg(dev,
2406 "failed to enable Sense Data Reporting, Emask 0x%x\n",
2407 err_mask);
2408 }
2409}
2410
6d1003ae
HR		 2411static void ata_dev_config_zac(struct ata_device *dev)
2412{
2413 struct ata_port *ap = dev->link->ap;
2414 unsigned int err_mask;
2415 u8 *identify_buf = ap->sector_buf;
6d1003ae
HR		 2416
2417 dev->zac_zones_optimal_open = U32_MAX;
2418 dev->zac_zones_optimal_nonseq = U32_MAX;
2419 dev->zac_zones_max_open = U32_MAX;
2420
2421 /*
2422 * Always set the 'ZAC' flag for Host-managed devices.
2423 */
2424 if (dev->class == ATA_DEV_ZAC)
2425 dev->flags |= ATA_DFLAG_ZAC;
2426 else if (ata_id_zoned_cap(dev->id) == 0x01)
2427 /*
2428 * Check for host-aware devices.
2429 */
2430 dev->flags |= ATA_DFLAG_ZAC;
2431
2432 if (!(dev->flags & ATA_DFLAG_ZAC))
2433 return;
2434
a0fd2454 2435 if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
6d1003ae
HR		 2436 ata_dev_warn(dev,
2437 "ATA Zoned Information Log not supported\n");
2438 return;
2439 }
ed36911c 2440
6d1003ae
HR		 2441 /*
2442 * Read IDENTIFY DEVICE data log, page 9 (Zoned-device information)
2443 */
1d51d5f3 2444 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
6d1003ae
HR		 2445 ATA_LOG_ZONED_INFORMATION,
2446 identify_buf, 1);
2447 if (!err_mask) {
2448 u64 zoned_cap, opt_open, opt_nonseq, max_open;
2449
2450 zoned_cap = get_unaligned_le64(&identify_buf[8]);
2451 if ((zoned_cap >> 63))
2452 dev->zac_zoned_cap = (zoned_cap & 1);
2453 opt_open = get_unaligned_le64(&identify_buf[24]);
2454 if ((opt_open >> 63))
2455 dev->zac_zones_optimal_open = (u32)opt_open;
2456 opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2457 if ((opt_nonseq >> 63))
2458 dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2459 max_open = get_unaligned_le64(&identify_buf[40]);
2460 if ((max_open >> 63))
2461 dev->zac_zones_max_open = (u32)max_open;
2462 }
a6e6ce8e
TH		 2463}
2464
818831c8
CH		 2465static void ata_dev_config_trusted(struct ata_device *dev)
2466{
2467 struct ata_port *ap = dev->link->ap;
2468 u64 trusted_cap;
2469 unsigned int err;
2470
e8f11db9
CH		 2471 if (!ata_id_has_trusted(dev->id))
2472 return;
2473
818831c8
CH		 2474 if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
2475 ata_dev_warn(dev,
2476 "Security Log not supported\n");
2477 return;
2478 }
2479
2480 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
2481 ap->sector_buf, 1);
fc5c8aa7 2482 if (err)
818831c8 2483 return;
818831c8
CH		 2484
2485 trusted_cap = get_unaligned_le64(&ap->sector_buf[40]);
2486 if (!(trusted_cap & (1ULL << 63))) {
2487 ata_dev_dbg(dev,
2488 "Trusted Computing capability qword not valid!\n");
2489 return;
2490 }
2491
2492 if (trusted_cap & (1 << 0))
2493 dev->flags |= ATA_DFLAG_TRUSTED;
2494}
2495
62e4a60e
DLM		 2496static void ata_dev_config_cdl(struct ata_device *dev)
2497{
2498 struct ata_port *ap = dev->link->ap;
2499 unsigned int err_mask;
df60f9c6 2500 bool cdl_enabled;
62e4a60e
DLM		 2501 u64 val;
2502
2503 if (ata_id_major_version(dev->id) < 12)
2504 goto not_supported;
2505
2506 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE) ||
df60f9c6
DLM		 2507 !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES) ||
2508 !ata_identify_page_supported(dev, ATA_LOG_CURRENT_SETTINGS))
62e4a60e
DLM		 2509 goto not_supported;
2510
2511 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2512 ATA_LOG_SUPPORTED_CAPABILITIES,
2513 ap->sector_buf, 1);
2514 if (err_mask)
2515 goto not_supported;
2516
2517 /* Check Command Duration Limit Supported bits */
2518 val = get_unaligned_le64(&ap->sector_buf[168]);
2519 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(0)))
2520 goto not_supported;
2521
2522 /* Warn the user if command duration guideline is not supported */
2523 if (!(val & BIT_ULL(1)))
2524 ata_dev_warn(dev,
2525 "Command duration guideline is not supported\n");
2526
18bd7718
NC		 2527 /*
2528 * We must have support for the sense data for successful NCQ commands
2529 * log indicated by the successful NCQ command sense data supported bit.
2530 */
2531 val = get_unaligned_le64(&ap->sector_buf[8]);
2532 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(47))) {
2533 ata_dev_warn(dev,
2534 "CDL supported but Successful NCQ Command Sense Data is not supported\n");
2535 goto not_supported;
2536 }
2537
2538 /* Without NCQ autosense, the successful NCQ commands log is useless. */
2539 if (!ata_id_has_ncq_autosense(dev->id)) {
2540 ata_dev_warn(dev,
2541 "CDL supported but NCQ autosense is not supported\n");
2542 goto not_supported;
2543 }
2544
df60f9c6
DLM		 2545 /*
2546 * If CDL is marked as enabled, make sure the feature is enabled too.
2547 * Conversely, if CDL is disabled, make sure the feature is turned off.
2548 */
2549 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2550 ATA_LOG_CURRENT_SETTINGS,
2551 ap->sector_buf, 1);
2552 if (err_mask)
2553 goto not_supported;
2554
2555 val = get_unaligned_le64(&ap->sector_buf[8]);
2556 cdl_enabled = val & BIT_ULL(63) && val & BIT_ULL(21);
2557 if (dev->flags & ATA_DFLAG_CDL_ENABLED) {
2558 if (!cdl_enabled) {
2559 /* Enable CDL on the device */
2560 err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 1);
2561 if (err_mask) {
2562 ata_dev_err(dev,
2563 "Enable CDL feature failed\n");
2564 goto not_supported;
2565 }
2566 }
2567 } else {
2568 if (cdl_enabled) {
2569 /* Disable CDL on the device */
2570 err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 0);
2571 if (err_mask) {
2572 ata_dev_err(dev,
2573 "Disable CDL feature failed\n");
2574 goto not_supported;
2575 }
2576 }
2577 }
2578
18bd7718
NC		 2579 /*
2580 * While CDL itself has to be enabled using sysfs, CDL requires that
2581 * sense data for successful NCQ commands is enabled to work properly.
2582 * Just like ata_dev_config_sense_reporting(), enable it unconditionally
2583 * if supported.
2584 */
2585 if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(18))) {
2586 err_mask = ata_dev_set_feature(dev,
2587 SETFEATURE_SENSE_DATA_SUCC_NCQ, 0x1);
2588 if (err_mask) {
2589 ata_dev_warn(dev,
2590 "failed to enable Sense Data for successful NCQ commands, Emask 0x%x\n",
2591 err_mask);
2592 goto not_supported;
2593 }
2594 }
2595
2596 /*
2597 * Allocate a buffer to handle reading the sense data for successful
2598 * NCQ Commands log page for commands using a CDL with one of the limit
2599 * policy set to 0xD (successful completion with sense data available
2600 * bit set).
2601 */
2602 if (!ap->ncq_sense_buf) {
2603 ap->ncq_sense_buf = kmalloc(ATA_LOG_SENSE_NCQ_SIZE, GFP_KERNEL);
2604 if (!ap->ncq_sense_buf)
2605 goto not_supported;
2606 }
2607
62e4a60e
DLM		 2608 /*
2609 * Command duration limits is supported: cache the CDL log page 18h
2610 * (command duration descriptors).
2611 */
2612 err_mask = ata_read_log_page(dev, ATA_LOG_CDL, 0, ap->sector_buf, 1);
2613 if (err_mask) {
2614 ata_dev_warn(dev, "Read Command Duration Limits log failed\n");
2615 goto not_supported;
2616 }
2617
2618 memcpy(dev->cdl, ap->sector_buf, ATA_LOG_CDL_SIZE);
2619 dev->flags |= ATA_DFLAG_CDL;
2620
2621 return;
2622
2623not_supported:
df60f9c6 2624 dev->flags &= ~(ATA_DFLAG_CDL | ATA_DFLAG_CDL_ENABLED);
18bd7718
NC		 2625 kfree(ap->ncq_sense_buf);
2626 ap->ncq_sense_buf = NULL;
62e4a60e
DLM		 2627}
2628
891fd7c6
DLM		 2629static int ata_dev_config_lba(struct ata_device *dev)
2630{
891fd7c6
DLM		 2631 const u16 *id = dev->id;
2632 const char *lba_desc;
ed518d9b 2633 char ncq_desc[32];
891fd7c6
DLM		 2634 int ret;
2635
2636 dev->flags |= ATA_DFLAG_LBA;
2637
2638 if (ata_id_has_lba48(id)) {
2639 lba_desc = "LBA48";
2640 dev->flags |= ATA_DFLAG_LBA48;
2641 if (dev->n_sectors >= (1UL << 28) &&
2642 ata_id_has_flush_ext(id))
2643 dev->flags |= ATA_DFLAG_FLUSH_EXT;
2644 } else {
2645 lba_desc = "LBA";
2646 }
2647
2648 /* config NCQ */
2649 ret = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2650
2651 /* print device info to dmesg */
1c95a27c 2652 if (ata_dev_print_info(dev))
891fd7c6
DLM		 2653 ata_dev_info(dev,
2654 "%llu sectors, multi %u: %s %s\n",
2655 (unsigned long long)dev->n_sectors,
2656 dev->multi_count, lba_desc, ncq_desc);
2657
2658 return ret;
2659}
2660
2661static void ata_dev_config_chs(struct ata_device *dev)
2662{
891fd7c6
DLM		 2663 const u16 *id = dev->id;
2664
2665 if (ata_id_current_chs_valid(id)) {
2666 /* Current CHS translation is valid. */
2667 dev->cylinders = id[54];
2668 dev->heads = id[55];
2669 dev->sectors = id[56];
2670 } else {
2671 /* Default translation */
2672 dev->cylinders = id[1];
2673 dev->heads = id[3];
2674 dev->sectors = id[6];
2675 }
2676
2677 /* print device info to dmesg */
1c95a27c 2678 if (ata_dev_print_info(dev))
891fd7c6
DLM		 2679 ata_dev_info(dev,
2680 "%llu sectors, multi %u, CHS %u/%u/%u\n",
2681 (unsigned long long)dev->n_sectors,
2682 dev->multi_count, dev->cylinders,
2683 dev->heads, dev->sectors);
2684}
2685
4d2e4980
DLM		 2686static void ata_dev_config_fua(struct ata_device *dev)
2687{
2688 /* Ignore FUA support if its use is disabled globally */
2689 if (!libata_fua)
2690 goto nofua;
2691
2692 /* Ignore devices without support for WRITE DMA FUA EXT */
2693 if (!(dev->flags & ATA_DFLAG_LBA48) || !ata_id_has_fua(dev->id))
2694 goto nofua;
2695
2696 /* Ignore known bad devices and devices that lack NCQ support */
2697 if (!ata_ncq_supported(dev) || (dev->horkage & ATA_HORKAGE_NO_FUA))
2698 goto nofua;
2699
2700 dev->flags |= ATA_DFLAG_FUA;
2701
2702 return;
2703
2704nofua:
2705 dev->flags &= ~ATA_DFLAG_FUA;
2706}
2707
d8d8778c
DLM		 2708static void ata_dev_config_devslp(struct ata_device *dev)
2709{
2710 u8 *sata_setting = dev->link->ap->sector_buf;
2711 unsigned int err_mask;
2712 int i, j;
2713
2714 /*
2715 * Check device sleep capability. Get DevSlp timing variables
2716 * from SATA Settings page of Identify Device Data Log.
2717 */
06f6c4c6
DLM		 2718 if (!ata_id_has_devslp(dev->id) ||
2719 !ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
d8d8778c
DLM		 2720 return;
2721
2722 err_mask = ata_read_log_page(dev,
2723 ATA_LOG_IDENTIFY_DEVICE,
2724 ATA_LOG_SATA_SETTINGS,
2725 sata_setting, 1);
fc5c8aa7 2726 if (err_mask)
d8d8778c 2727 return;
d8d8778c
DLM		 2728
2729 dev->flags |= ATA_DFLAG_DEVSLP;
2730 for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2731 j = ATA_LOG_DEVSLP_OFFSET + i;
2732 dev->devslp_timing[i] = sata_setting[j];
2733 }
2734}
2735
fe22e1c2
DLM		 2736static void ata_dev_config_cpr(struct ata_device *dev)
2737{
2738 unsigned int err_mask;
2739 size_t buf_len;
2740 int i, nr_cpr = 0;
2741 struct ata_cpr_log *cpr_log = NULL;
2742 u8 *desc, *buf = NULL;
2743
c745dfc5
TE		 2744 if (ata_id_major_version(dev->id) < 11)
2745 goto out;
2746
2747 buf_len = ata_log_supported(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES);
2748 if (buf_len == 0)
fe22e1c2
DLM		 2749 goto out;
2750
2751 /*
fda17afc 2752 * Read the concurrent positioning ranges log (0x47). We can have at
c745dfc5
TE		 2753 * most 255 32B range descriptors plus a 64B header. This log varies in
2754 * size, so use the size reported in the GPL directory. Reading beyond
2755 * the supported length will result in an error.
fe22e1c2 2756 */
c745dfc5 2757 buf_len <<= 9;
fe22e1c2
DLM		 2758 buf = kzalloc(buf_len, GFP_KERNEL);
2759 if (!buf)
2760 goto out;
2761
fda17afc
DLM		 2762 err_mask = ata_read_log_page(dev, ATA_LOG_CONCURRENT_POSITIONING_RANGES,
2763 0, buf, buf_len >> 9);
fe22e1c2
DLM		 2764 if (err_mask)
2765 goto out;
2766
2767 nr_cpr = buf[0];
2768 if (!nr_cpr)
2769 goto out;
2770
2771 cpr_log = kzalloc(struct_size(cpr_log, cpr, nr_cpr), GFP_KERNEL);
2772 if (!cpr_log)
2773 goto out;
2774
2775 cpr_log->nr_cpr = nr_cpr;
2776 desc = &buf[64];
2777 for (i = 0; i < nr_cpr; i++, desc += 32) {
2778 cpr_log->cpr[i].num = desc[0];
2779 cpr_log->cpr[i].num_storage_elements = desc[1];
2780 cpr_log->cpr[i].start_lba = get_unaligned_le64(&desc[8]);
2781 cpr_log->cpr[i].num_lbas = get_unaligned_le64(&desc[16]);
2782 }
2783
2784out:
2785 swap(dev->cpr_log, cpr_log);
2786 kfree(cpr_log);
2787 kfree(buf);
2788}
2789
d633b8a7
DLM		 2790static void ata_dev_print_features(struct ata_device *dev)
2791{
2792 if (!(dev->flags & ATA_DFLAG_FEATURES_MASK))
2793 return;
2794
2795 ata_dev_info(dev,
62e4a60e 2796 "Features:%s%s%s%s%s%s%s%s\n",
4d2e4980 2797 dev->flags & ATA_DFLAG_FUA ? " FUA" : "",
d633b8a7
DLM		 2798 dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "",
2799 dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "",
2800 dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "",
2801 dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "",
fe22e1c2 2802 dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "",
62e4a60e 2803 dev->flags & ATA_DFLAG_CDL ? " CDL" : "",
fe22e1c2 2804 dev->cpr_log ? " CPR" : "");
d633b8a7
DLM		 2805}
2806
49016aca 2807/**
ffeae418 2808 * ata_dev_configure - Configure the specified ATA/ATAPI device
ffeae418
TH		 2809 * @dev: Target device to configure
2810 *
2811 * Configure @dev according to @dev->id. Generic and low-level
2812 * driver specific fixups are also applied.
49016aca
TH		 2813 *
2814 * LOCKING:
ffeae418
TH		 2815 * Kernel thread context (may sleep)
2816 *
2817 * RETURNS:
2818 * 0 on success, -errno otherwise
49016aca 2819 */
efdaedc4 2820int ata_dev_configure(struct ata_device *dev)
49016aca 2821{
9af5c9c9 2822 struct ata_port *ap = dev->link->ap;
891fd7c6 2823 bool print_info = ata_dev_print_info(dev);
1148c3a7 2824 const u16 *id = dev->id;
f0a6d77b 2825 unsigned int xfer_mask;
65fe1f0f 2826 unsigned int err_mask;
b352e57d 2827 char revbuf[7]; /* XYZ-99\0 */
3f64f565
EM		 2828 char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2829 char modelbuf[ATA_ID_PROD_LEN+1];
e6d902a3 2830 int rc;
49016aca 2831
96c810f2
HR		 2832 if (!ata_dev_enabled(dev)) {
2833 ata_dev_dbg(dev, "no device\n");
ffeae418 2834 return 0;
49016aca
TH		 2835 }
2836
75683fe7
TH		 2837 /* set horkage */
2838 dev->horkage |= ata_dev_blacklisted(dev);
33267325 2839 ata_force_horkage(dev);
75683fe7 2840
50af2fa1 2841 if (dev->horkage & ATA_HORKAGE_DISABLE) {
a9a79dfe 2842 ata_dev_info(dev, "unsupported device, disabling\n");
50af2fa1
TH		 2843 ata_dev_disable(dev);
2844 return 0;
2845 }
2846
2486fa56
TH		 2847 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2848 dev->class == ATA_DEV_ATAPI) {
a9a79dfe
JP		 2849 ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2850 atapi_enabled ? "not supported with this driver"
2851 : "disabled");
2486fa56
TH		 2852 ata_dev_disable(dev);
2853 return 0;
2854 }
2855
9062712f
TH		 2856 rc = ata_do_link_spd_horkage(dev);
2857 if (rc)
2858 return rc;
2859
ecd75ad5
TH		 2860 /* some WD SATA-1 drives have issues with LPM, turn on NOLPM for them */
2861 if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2862 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2863 dev->horkage |= ATA_HORKAGE_NOLPM;
2864
240630e6
HG		 2865 if (ap->flags & ATA_FLAG_NO_LPM)
2866 dev->horkage |= ATA_HORKAGE_NOLPM;
2867
ecd75ad5
TH		 2868 if (dev->horkage & ATA_HORKAGE_NOLPM) {
2869 ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2870 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2871 }
2872
6746544c
TH		 2873 /* let ACPI work its magic */
2874 rc = ata_acpi_on_devcfg(dev);
2875 if (rc)
2876 return rc;
08573a86 2877
05027adc
TH		 2878 /* massage HPA, do it early as it might change IDENTIFY data */
2879 rc = ata_hpa_resize(dev);
2880 if (rc)
2881 return rc;
2882
c39f5ebe 2883 /* print device capabilities */
17a1e1be
HR		 2884 ata_dev_dbg(dev,
2885 "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2886 "85:%04x 86:%04x 87:%04x 88:%04x\n",
2887 __func__,
2888 id[49], id[82], id[83], id[84],
2889 id[85], id[86], id[87], id[88]);
c39f5ebe 2890
208a9933 2891 /* initialize to-be-configured parameters */
ea1dd4e1 2892 dev->flags &= ~ATA_DFLAG_CFG_MASK;
208a9933
TH		 2893 dev->max_sectors = 0;
2894 dev->cdb_len = 0;
2895 dev->n_sectors = 0;
2896 dev->cylinders = 0;
2897 dev->heads = 0;
2898 dev->sectors = 0;
e18086d6 2899 dev->multi_count = 0;
208a9933 2900
1da177e4
LT		 2901 /*
2902 * common ATA, ATAPI feature tests
2903 */
2904
ff8854b2 2905 /* find max transfer mode; for printk only */
1148c3a7 2906 xfer_mask = ata_id_xfermask(id);
1da177e4 2907
6044f3c4 2908 ata_dump_id(dev, id);
1da177e4 2909
ef143d57
AL		 2910 /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
2911 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2912 sizeof(fwrevbuf));
2913
2914 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2915 sizeof(modelbuf));
2916
1da177e4 2917 /* ATA-specific feature tests */
9162c657 2918 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
b352e57d 2919 if (ata_id_is_cfa(id)) {
62afe5d7
SS		 2920 /* CPRM may make this media unusable */
2921 if (id[ATA_ID_CFA_KEY_MGMT] & 1)
a9a79dfe
JP		 2922 ata_dev_warn(dev,
2923 "supports DRM functions and may not be fully accessible\n");
b352e57d 2924 snprintf(revbuf, 7, "CFA");
ae8d4ee7 2925 } else {
2dcb407e 2926 snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
ae8d4ee7
AC		 2927 /* Warn the user if the device has TPM extensions */
2928 if (ata_id_has_tpm(id))
a9a79dfe
JP		 2929 ata_dev_warn(dev,
2930 "supports DRM functions and may not be fully accessible\n");
ae8d4ee7 2931 }
b352e57d 2932
1148c3a7 2933 dev->n_sectors = ata_id_n_sectors(id);
2940740b 2934
e18086d6
ML		 2935 /* get current R/W Multiple count setting */
2936 if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2937 unsigned int max = dev->id[47] & 0xff;
2938 unsigned int cnt = dev->id[59] & 0xff;
2939 /* only recognize/allow powers of two here */
2940 if (is_power_of_2(max) && is_power_of_2(cnt))
2941 if (cnt <= max)
2942 dev->multi_count = cnt;
2943 }
3f64f565 2944
891fd7c6 2945 /* print device info to dmesg */
1c95a27c 2946 if (print_info)
891fd7c6
DLM		 2947 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2948 revbuf, modelbuf, fwrevbuf,
2949 ata_mode_string(xfer_mask));
8bf62ece 2950
891fd7c6
DLM		 2951 if (ata_id_has_lba(id)) {
2952 rc = ata_dev_config_lba(dev);
388539f3
SL		 2953 if (rc)
2954 return rc;
ffeae418 2955 } else {
891fd7c6 2956 ata_dev_config_chs(dev);
07f6f7d0
AL		 2957 }
2958
4d2e4980 2959 ata_dev_config_fua(dev);
d8d8778c 2960 ata_dev_config_devslp(dev);
e87fd28c 2961 ata_dev_config_sense_reporting(dev);
6d1003ae 2962 ata_dev_config_zac(dev);
818831c8 2963 ata_dev_config_trusted(dev);
fe22e1c2 2964 ata_dev_config_cpr(dev);
62e4a60e 2965 ata_dev_config_cdl(dev);
b1ffbf85 2966 dev->cdb_len = 32;
d633b8a7 2967
1c95a27c 2968 if (print_info)
d633b8a7 2969 ata_dev_print_features(dev);
1da177e4
LT		 2970 }
2971
2972 /* ATAPI-specific feature tests */
2c13b7ce 2973 else if (dev->class == ATA_DEV_ATAPI) {
854c73a2
TH		 2974 const char *cdb_intr_string = "";
2975 const char *atapi_an_string = "";
91163006 2976 const char *dma_dir_string = "";
7d77b247 2977 u32 sntf;
08a556db 2978
1148c3a7 2979 rc = atapi_cdb_len(id);
1da177e4 2980 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
16d42467 2981 ata_dev_warn(dev, "unsupported CDB len %d\n", rc);
ffeae418 2982 rc = -EINVAL;
1da177e4
LT		 2983 goto err_out_nosup;
2984 }
6e7846e9 2985 dev->cdb_len = (unsigned int) rc;
1da177e4 2986
7d77b247
TH		 2987 /* Enable ATAPI AN if both the host and device have
2988 * the support. If PMP is attached, SNTF is required
2989 * to enable ATAPI AN to discern between PHY status
2990 * changed notifications and ATAPI ANs.
9f45cbd3 2991 */
e7ecd435
TH		 2992 if (atapi_an &&
2993 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
071f44b1 2994 (!sata_pmp_attached(ap) ||
7d77b247 2995 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
9f45cbd3 2996 /* issue SET feature command to turn this on */
218f3d30
JG		 2997 err_mask = ata_dev_set_feature(dev,
2998 SETFEATURES_SATA_ENABLE, SATA_AN);
854c73a2 2999 if (err_mask)
a9a79dfe
JP		 3000 ata_dev_err(dev,
3001 "failed to enable ATAPI AN (err_mask=0x%x)\n",
3002 err_mask);
854c73a2 3003 else {
9f45cbd3 3004 dev->flags |= ATA_DFLAG_AN;
854c73a2
TH		 3005 atapi_an_string = ", ATAPI AN";
3006 }
9f45cbd3
KCA		 3007 }
3008
08a556db 3009 if (ata_id_cdb_intr(dev->id)) {
312f7da2 3010 dev->flags |= ATA_DFLAG_CDB_INTR;
08a556db
AL		 3011 cdb_intr_string = ", CDB intr";
3012 }
312f7da2 3013
966fbe19 3014 if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
91163006
TH		 3015 dev->flags |= ATA_DFLAG_DMADIR;
3016 dma_dir_string = ", DMADIR";
3017 }
3018
afe75951 3019 if (ata_id_has_da(dev->id)) {
b1354cbb 3020 dev->flags |= ATA_DFLAG_DA;
afe75951
AL		 3021 zpodd_init(dev);
3022 }
b1354cbb 3023
1da177e4 3024 /* print device info to dmesg */
1c95a27c 3025 if (print_info)
a9a79dfe
JP		 3026 ata_dev_info(dev,
3027 "ATAPI: %s, %s, max %s%s%s%s\n",
3028 modelbuf, fwrevbuf,
3029 ata_mode_string(xfer_mask),
3030 cdb_intr_string, atapi_an_string,
3031 dma_dir_string);
1da177e4
LT		 3032 }
3033
914ed354
TH		 3034 /* determine max_sectors */
3035 dev->max_sectors = ATA_MAX_SECTORS;
3036 if (dev->flags & ATA_DFLAG_LBA48)
3037 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
3038
c5038fc0
AC		 3039 /* Limit PATA drive on SATA cable bridge transfers to udma5,
3040 200 sectors */
3373efd8 3041 if (ata_dev_knobble(dev)) {
1c95a27c 3042 if (print_info)
a9a79dfe 3043 ata_dev_info(dev, "applying bridge limits\n");
5a529139 3044 dev->udma_mask &= ATA_UDMA5;
4b2f3ede
TH		 3045 dev->max_sectors = ATA_MAX_SECTORS;
3046 }
3047
f8d8e579 3048 if ((dev->class == ATA_DEV_ATAPI) &&
f442cd86 3049 (atapi_command_packet_set(id) == TYPE_TAPE)) {
f8d8e579 3050 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
f442cd86
AL		 3051 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
3052 }
f8d8e579 3053
75683fe7 3054 if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
03ec52de
TH		 3055 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
3056 dev->max_sectors);
18d6e9d5 3057
af34d637
DM		 3058 if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
3059 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
3060 dev->max_sectors);
3061
a32450e1
SH		 3062 if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
3063 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
3064
4b2f3ede 3065 if (ap->ops->dev_config)
cd0d3bbc 3066 ap->ops->dev_config(dev);
4b2f3ede 3067
c5038fc0
AC		 3068 if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
3069 /* Let the user know. We don't want to disallow opens for
3070 rescue purposes, or in case the vendor is just a blithering
3071 idiot. Do this after the dev_config call as some controllers
3072 with buggy firmware may want to avoid reporting false device
3073 bugs */
3074
3075 if (print_info) {
a9a79dfe 3076 ata_dev_warn(dev,
c5038fc0 3077"Drive reports diagnostics failure. This may indicate a drive\n");
a9a79dfe 3078 ata_dev_warn(dev,
c5038fc0
AC		 3079"fault or invalid emulation. Contact drive vendor for information.\n");
3080 }
3081 }
3082
ac70a964 3083 if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
a9a79dfe
JP		 3084 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
3085 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n");
ac70a964
TH		 3086 }
3087
ffeae418 3088 return 0;
1da177e4
LT		 3089
3090err_out_nosup:
ffeae418 3091 return rc;
1da177e4
LT		 3092}
3093
be0d18df 3094/**
2e41e8e6 3095 * ata_cable_40wire - return 40 wire cable type
be0d18df
AC		 3096 * @ap: port
3097 *
2e41e8e6 3098 * Helper method for drivers which want to hardwire 40 wire cable
be0d18df
AC		 3099 * detection.
3100 */
3101
3102int ata_cable_40wire(struct ata_port *ap)
3103{
3104 return ATA_CBL_PATA40;
3105}
a52fbcfc 3106EXPORT_SYMBOL_GPL(ata_cable_40wire);
be0d18df
AC		 3107
3108/**
2e41e8e6 3109 * ata_cable_80wire - return 80 wire cable type
be0d18df
AC		 3110 * @ap: port
3111 *
2e41e8e6 3112 * Helper method for drivers which want to hardwire 80 wire cable
be0d18df
AC		 3113 * detection.
3114 */
3115
3116int ata_cable_80wire(struct ata_port *ap)
3117{
3118 return ATA_CBL_PATA80;
3119}
a52fbcfc 3120EXPORT_SYMBOL_GPL(ata_cable_80wire);
be0d18df
AC		 3121
3122/**
3123 * ata_cable_unknown - return unknown PATA cable.
3124 * @ap: port
3125 *
3126 * Helper method for drivers which have no PATA cable detection.
3127 */
3128
3129int ata_cable_unknown(struct ata_port *ap)
3130{
3131 return ATA_CBL_PATA_UNK;
3132}
a52fbcfc 3133EXPORT_SYMBOL_GPL(ata_cable_unknown);
be0d18df 3134
c88f90c3
TH		 3135/**
3136 * ata_cable_ignore - return ignored PATA cable.
3137 * @ap: port
3138 *
3139 * Helper method for drivers which don't use cable type to limit
3140 * transfer mode.
3141 */
3142int ata_cable_ignore(struct ata_port *ap)
3143{
3144 return ATA_CBL_PATA_IGN;
3145}
a52fbcfc 3146EXPORT_SYMBOL_GPL(ata_cable_ignore);
c88f90c3 3147
be0d18df
AC		 3148/**
3149 * ata_cable_sata - return SATA cable type
3150 * @ap: port
3151 *
3152 * Helper method for drivers which have SATA cables
3153 */
3154
3155int ata_cable_sata(struct ata_port *ap)
3156{
3157 return ATA_CBL_SATA;
3158}
a52fbcfc 3159EXPORT_SYMBOL_GPL(ata_cable_sata);
be0d18df 3160
3be680b7
TH		 3161/**
3162 * sata_print_link_status - Print SATA link status
936fd732 3163 * @link: SATA link to printk link status about
3be680b7
TH		 3164 *
3165 * This function prints link speed and status of a SATA link.
3166 *
3167 * LOCKING:
3168 * None.
3169 */
6bdb4fc9 3170static void sata_print_link_status(struct ata_link *link)
3be680b7 3171{
6d5f9732 3172 u32 sstatus, scontrol, tmp;
3be680b7 3173
936fd732 3174 if (sata_scr_read(link, SCR_STATUS, &sstatus))
3be680b7 3175 return;
55d5ba55
LZ		 3176 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
3177 return;
3be680b7 3178
b1c72916 3179 if (ata_phys_link_online(link)) {
3be680b7 3180 tmp = (sstatus >> 4) & 0xf;
a9a79dfe
JP		 3181 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
3182 sata_spd_string(tmp), sstatus, scontrol);
3be680b7 3183 } else {
a9a79dfe
JP		 3184 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
3185 sstatus, scontrol);
3be680b7
TH		 3186 }
3187}
3188
ebdfca6e
AC		 3189/**
3190 * ata_dev_pair - return other device on cable
ebdfca6e
AC		 3191 * @adev: device
3192 *
3193 * Obtain the other device on the same cable, or if none is
3194 * present NULL is returned
3195 */
2e9edbf8 3196
3373efd8 3197struct ata_device *ata_dev_pair(struct ata_device *adev)
ebdfca6e 3198{
9af5c9c9
TH		 3199 struct ata_link *link = adev->link;
3200 struct ata_device *pair = &link->device[1 - adev->devno];
e1211e3f 3201 if (!ata_dev_enabled(pair))
ebdfca6e
AC		 3202 return NULL;
3203 return pair;
3204}
a52fbcfc 3205EXPORT_SYMBOL_GPL(ata_dev_pair);
ebdfca6e 3206
1c3fae4d 3207/**
3c567b7d 3208 * sata_down_spd_limit - adjust SATA spd limit downward
936fd732 3209 * @link: Link to adjust SATA spd limit for
a07d499b 3210 * @spd_limit: Additional limit
1c3fae4d 3211 *
936fd732 3212 * Adjust SATA spd limit of @link downward. Note that this
1c3fae4d 3213 * function only adjusts the limit. The change must be applied
3c567b7d 3214 * using sata_set_spd().
1c3fae4d 3215 *
a07d499b
TH		 3216 * If @spd_limit is non-zero, the speed is limited to equal to or
3217 * lower than @spd_limit if such speed is supported. If
3218 * @spd_limit is slower than any supported speed, only the lowest
3219 * supported speed is allowed.
3220 *
1c3fae4d
TH		 3221 * LOCKING:
3222 * Inherited from caller.
3223 *
3224 * RETURNS:
3225 * 0 on success, negative errno on failure
3226 */
a07d499b 3227int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
1c3fae4d 3228{
81952c54 3229 u32 sstatus, spd, mask;
a07d499b 3230 int rc, bit;
1c3fae4d 3231
936fd732 3232 if (!sata_scr_valid(link))
008a7896
TH		 3233 return -EOPNOTSUPP;
3234
3235 /* If SCR can be read, use it to determine the current SPD.
936fd732 3236 * If not, use cached value in link->sata_spd.
008a7896 3237 */
936fd732 3238 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
9913ff8a 3239 if (rc == 0 && ata_sstatus_online(sstatus))
008a7896
TH		 3240 spd = (sstatus >> 4) & 0xf;
3241 else
936fd732 3242 spd = link->sata_spd;
1c3fae4d 3243
936fd732 3244 mask = link->sata_spd_limit;
1c3fae4d
TH		 3245 if (mask <= 1)
3246 return -EINVAL;
008a7896
TH		 3247
3248 /* unconditionally mask off the highest bit */
a07d499b
TH		 3249 bit = fls(mask) - 1;
3250 mask &= ~(1 << bit);
1c3fae4d 3251
2dc0b46b
DM		 3252 /*
3253 * Mask off all speeds higher than or equal to the current one. At
3254 * this point, if current SPD is not available and we previously
3255 * recorded the link speed from SStatus, the driver has already
3256 * masked off the highest bit so mask should already be 1 or 0.
3257 * Otherwise, we should not force 1.5Gbps on a link where we have
3258 * not previously recorded speed from SStatus. Just return in this
3259 * case.
008a7896
TH		 3260 */
3261 if (spd > 1)
3262 mask &= (1 << (spd - 1)) - 1;
69f2c934 3263 else if (link->sata_spd)
2dc0b46b 3264 return -EINVAL;
008a7896
TH		 3265
3266 /* were we already at the bottom? */
1c3fae4d
TH		 3267 if (!mask)
3268 return -EINVAL;
3269
a07d499b
TH		 3270 if (spd_limit) {
3271 if (mask & ((1 << spd_limit) - 1))
3272 mask &= (1 << spd_limit) - 1;
3273 else {
3274 bit = ffs(mask) - 1;
3275 mask = 1 << bit;
3276 }
3277 }
3278
936fd732 3279 link->sata_spd_limit = mask;
1c3fae4d 3280
a9a79dfe
JP		 3281 ata_link_warn(link, "limiting SATA link speed to %s\n",
3282 sata_spd_string(fls(mask)));
1c3fae4d
TH		 3283
3284 return 0;
3285}
3286
a9b2c120 3287#ifdef CONFIG_ATA_ACPI
a0f79b92
TH		 3288/**
3289 * ata_timing_cycle2mode - find xfer mode for the specified cycle duration
3290 * @xfer_shift: ATA_SHIFT_* value for transfer type to examine.
3291 * @cycle: cycle duration in ns
3292 *
3293 * Return matching xfer mode for @cycle. The returned mode is of
3294 * the transfer type specified by @xfer_shift. If @cycle is too
3295 * slow for @xfer_shift, 0xff is returned. If @cycle is faster
3296 * than the fastest known mode, the fasted mode is returned.
3297 *
3298 * LOCKING:
3299 * None.
3300 *
3301 * RETURNS:
3302 * Matching xfer_mode, 0xff if no match found.
3303 */
3304u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3305{
3306 u8 base_mode = 0xff, last_mode = 0xff;
3307 const struct ata_xfer_ent *ent;
3308 const struct ata_timing *t;
3309
3310 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3311 if (ent->shift == xfer_shift)
3312 base_mode = ent->base;
3313
3314 for (t = ata_timing_find_mode(base_mode);
3315 t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3316 unsigned short this_cycle;
3317
3318 switch (xfer_shift) {
3319 case ATA_SHIFT_PIO:
3320 case ATA_SHIFT_MWDMA:
3321 this_cycle = t->cycle;
3322 break;
3323 case ATA_SHIFT_UDMA:
3324 this_cycle = t->udma;
3325 break;
3326 default:
3327 return 0xff;
3328 }
3329
3330 if (cycle > this_cycle)
3331 break;
3332
3333 last_mode = t->mode;
3334 }
3335
3336 return last_mode;
3337}
a9b2c120 3338#endif
a0f79b92 3339
cf176e1a
TH		 3340/**
3341 * ata_down_xfermask_limit - adjust dev xfer masks downward
cf176e1a 3342 * @dev: Device to adjust xfer masks
458337db 3343 * @sel: ATA_DNXFER_* selector
cf176e1a
TH		 3344 *
3345 * Adjust xfer masks of @dev downward. Note that this function
3346 * does not apply the change. Invoking ata_set_mode() afterwards
3347 * will apply the limit.
3348 *
3349 * LOCKING:
3350 * Inherited from caller.
3351 *
3352 * RETURNS:
3353 * 0 on success, negative errno on failure
3354 */
458337db 3355int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
cf176e1a 3356{
458337db 3357 char buf[32];
f0a6d77b
SS		 3358 unsigned int orig_mask, xfer_mask;
3359 unsigned int pio_mask, mwdma_mask, udma_mask;
458337db 3360 int quiet, highbit;
cf176e1a 3361
458337db
TH		 3362 quiet = !!(sel & ATA_DNXFER_QUIET);
3363 sel &= ~ATA_DNXFER_QUIET;
cf176e1a 3364
458337db
TH		 3365 xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3366 dev->mwdma_mask,
3367 dev->udma_mask);
3368 ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
cf176e1a 3369
458337db
TH		 3370 switch (sel) {
3371 case ATA_DNXFER_PIO:
3372 highbit = fls(pio_mask) - 1;
3373 pio_mask &= ~(1 << highbit);
3374 break;
3375
3376 case ATA_DNXFER_DMA:
3377 if (udma_mask) {
3378 highbit = fls(udma_mask) - 1;
3379 udma_mask &= ~(1 << highbit);
3380 if (!udma_mask)
3381 return -ENOENT;
3382 } else if (mwdma_mask) {
3383 highbit = fls(mwdma_mask) - 1;
3384 mwdma_mask &= ~(1 << highbit);
3385 if (!mwdma_mask)
3386 return -ENOENT;
3387 }
3388 break;
3389
3390 case ATA_DNXFER_40C:
3391 udma_mask &= ATA_UDMA_MASK_40C;
3392 break;
3393
3394 case ATA_DNXFER_FORCE_PIO0:
3395 pio_mask &= 1;
df561f66 3396 fallthrough;
458337db
TH		 3397 case ATA_DNXFER_FORCE_PIO:
3398 mwdma_mask = 0;
3399 udma_mask = 0;
3400 break;
3401
458337db
TH		 3402 default:
3403 BUG();
3404 }
3405
3406 xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3407
3408 if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3409 return -ENOENT;
3410
3411 if (!quiet) {
3412 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3413 snprintf(buf, sizeof(buf), "%s:%s",
3414 ata_mode_string(xfer_mask),
3415 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3416 else
3417 snprintf(buf, sizeof(buf), "%s",
3418 ata_mode_string(xfer_mask));
3419
a9a79dfe 3420 ata_dev_warn(dev, "limiting speed to %s\n", buf);
458337db 3421 }
cf176e1a
TH		 3422
3423 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3424 &dev->udma_mask);
3425
cf176e1a 3426 return 0;
cf176e1a
TH		 3427}
3428
3373efd8 3429static int ata_dev_set_mode(struct ata_device *dev)
1da177e4 3430{
d0cb43b3 3431 struct ata_port *ap = dev->link->ap;
9af5c9c9 3432 struct ata_eh_context *ehc = &dev->link->eh_context;
d0cb43b3 3433 const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
4055dee7
TH		 3434 const char *dev_err_whine = "";
3435 int ign_dev_err = 0;
d0cb43b3 3436 unsigned int err_mask = 0;
83206a29 3437 int rc;
1da177e4 3438
e8384607 3439 dev->flags &= ~ATA_DFLAG_PIO;
1da177e4
LT		 3440 if (dev->xfer_shift == ATA_SHIFT_PIO)
3441 dev->flags |= ATA_DFLAG_PIO;
3442
d0cb43b3
TH		 3443 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3444 dev_err_whine = " (SET_XFERMODE skipped)";
3445 else {
3446 if (nosetxfer)
a9a79dfe
JP		 3447 ata_dev_warn(dev,
3448 "NOSETXFER but PATA detected - can't "
3449 "skip SETXFER, might malfunction\n");
d0cb43b3
TH		 3450 err_mask = ata_dev_set_xfermode(dev);
3451 }
2dcb407e 3452
4055dee7
TH		 3453 if (err_mask & ~AC_ERR_DEV)
3454 goto fail;
3455
3456 /* revalidate */
3457 ehc->i.flags |= ATA_EHI_POST_SETMODE;
3458 rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3459 ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3460 if (rc)
3461 return rc;
3462
b93fda12
AC		 3463 if (dev->xfer_shift == ATA_SHIFT_PIO) {
3464 /* Old CFA may refuse this command, which is just fine */
3465 if (ata_id_is_cfa(dev->id))
3466 ign_dev_err = 1;
3467 /* Catch several broken garbage emulations plus some pre
3468 ATA devices */
3469 if (ata_id_major_version(dev->id) == 0 &&
3470 dev->pio_mode <= XFER_PIO_2)
3471 ign_dev_err = 1;
3472 /* Some very old devices and some bad newer ones fail
3473 any kind of SET_XFERMODE request but support PIO0-2
3474 timings and no IORDY */
3475 if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3476 ign_dev_err = 1;
3477 }
3acaf94b
AC		 3478 /* Early MWDMA devices do DMA but don't allow DMA mode setting.
3479 Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
c5038fc0 3480 if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3acaf94b
AC		 3481 dev->dma_mode == XFER_MW_DMA_0 &&
3482 (dev->id[63] >> 8) & 1)
4055dee7 3483 ign_dev_err = 1;
3acaf94b 3484
4055dee7
TH		 3485 /* if the device is actually configured correctly, ignore dev err */
3486 if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3487 ign_dev_err = 1;
1da177e4 3488
4055dee7
TH		 3489 if (err_mask & AC_ERR_DEV) {
3490 if (!ign_dev_err)
3491 goto fail;
3492 else
3493 dev_err_whine = " (device error ignored)";
3494 }
48a8a14f 3495
4633778b
HR		 3496 ata_dev_dbg(dev, "xfer_shift=%u, xfer_mode=0x%x\n",
3497 dev->xfer_shift, (int)dev->xfer_mode);
1da177e4 3498
07b9b6d6
DLM		 3499 if (!(ehc->i.flags & ATA_EHI_QUIET) ||
3500 ehc->i.flags & ATA_EHI_DID_HARDRESET)
3501 ata_dev_info(dev, "configured for %s%s\n",
3502 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3503 dev_err_whine);
4055dee7 3504
83206a29 3505 return 0;
4055dee7
TH		 3506
3507 fail:
a9a79dfe 3508 ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
4055dee7 3509 return -EIO;
1da177e4
LT		 3510}
3511
1da177e4 3512/**
04351821 3513 * ata_do_set_mode - Program timings and issue SET FEATURES - XFER
0260731f 3514 * @link: link on which timings will be programmed
1967b7ff 3515 * @r_failed_dev: out parameter for failed device
1da177e4 3516 *
04351821
AC		 3517 * Standard implementation of the function used to tune and set
3518 * ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3519 * ata_dev_set_mode() fails, pointer to the failing device is
e82cbdb9 3520 * returned in @r_failed_dev.
780a87f7 3521 *
1da177e4 3522 * LOCKING:
0cba632b 3523 * PCI/etc. bus probe sem.
e82cbdb9
TH		 3524 *
3525 * RETURNS:
3526 * 0 on success, negative errno otherwise
1da177e4 3527 */
04351821 3528
0260731f 3529int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
1da177e4 3530{
0260731f 3531 struct ata_port *ap = link->ap;
e8e0619f 3532 struct ata_device *dev;
f58229f8 3533 int rc = 0, used_dma = 0, found = 0;
3adcebb2 3534
a6d5a51c 3535 /* step 1: calculate xfer_mask */
1eca4365 3536 ata_for_each_dev(dev, link, ENABLED) {
f0a6d77b 3537 unsigned int pio_mask, dma_mask;
b3a70601 3538 unsigned int mode_mask;
a6d5a51c 3539
b3a70601
AC		 3540 mode_mask = ATA_DMA_MASK_ATA;
3541 if (dev->class == ATA_DEV_ATAPI)
3542 mode_mask = ATA_DMA_MASK_ATAPI;
3543 else if (ata_id_is_cfa(dev->id))
3544 mode_mask = ATA_DMA_MASK_CFA;
3545
3373efd8 3546 ata_dev_xfermask(dev);
33267325 3547 ata_force_xfermask(dev);
1da177e4 3548
acf356b1 3549 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
b3a70601
AC		 3550
3551 if (libata_dma_mask & mode_mask)
80a9c430
SS		 3552 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3553 dev->udma_mask);
b3a70601
AC		 3554 else
3555 dma_mask = 0;
3556
acf356b1
TH		 3557 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3558 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
5444a6f4 3559
4f65977d 3560 found = 1;
b15b3eba 3561 if (ata_dma_enabled(dev))
5444a6f4 3562 used_dma = 1;
a6d5a51c 3563 }
4f65977d 3564 if (!found)
e82cbdb9 3565 goto out;
a6d5a51c
TH		 3566
3567 /* step 2: always set host PIO timings */
1eca4365 3568 ata_for_each_dev(dev, link, ENABLED) {
70cd071e 3569 if (dev->pio_mode == 0xff) {
a9a79dfe 3570 ata_dev_warn(dev, "no PIO support\n");
e8e0619f 3571 rc = -EINVAL;
e82cbdb9 3572 goto out;
e8e0619f
TH		 3573 }
3574
3575 dev->xfer_mode = dev->pio_mode;
3576 dev->xfer_shift = ATA_SHIFT_PIO;
3577 if (ap->ops->set_piomode)
3578 ap->ops->set_piomode(ap, dev);
3579 }
1da177e4 3580
a6d5a51c 3581 /* step 3: set host DMA timings */
1eca4365
TH		 3582 ata_for_each_dev(dev, link, ENABLED) {
3583 if (!ata_dma_enabled(dev))
e8e0619f
TH		 3584 continue;
3585
3586 dev->xfer_mode = dev->dma_mode;
3587 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3588 if (ap->ops->set_dmamode)
3589 ap->ops->set_dmamode(ap, dev);
3590 }
1da177e4
LT		 3591
3592 /* step 4: update devices' xfer mode */
1eca4365 3593 ata_for_each_dev(dev, link, ENABLED) {
3373efd8 3594 rc = ata_dev_set_mode(dev);
5bbc53f4 3595 if (rc)
e82cbdb9 3596 goto out;
83206a29 3597 }
1da177e4 3598
e8e0619f
TH		 3599 /* Record simplex status. If we selected DMA then the other
3600 * host channels are not permitted to do so.
5444a6f4 3601 */
cca3974e 3602 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
032af1ce 3603 ap->host->simplex_claimed = ap;
5444a6f4 3604
e82cbdb9
TH		 3605 out:
3606 if (rc)
3607 *r_failed_dev = dev;
3608 return rc;
1da177e4 3609}
a52fbcfc 3610EXPORT_SYMBOL_GPL(ata_do_set_mode);
1da177e4 3611
aa2731ad
TH		 3612/**
3613 * ata_wait_ready - wait for link to become ready
3614 * @link: link to be waited on
3615 * @deadline: deadline jiffies for the operation
3616 * @check_ready: callback to check link readiness
3617 *
3618 * Wait for @link to become ready. @check_ready should return
3619 * positive number if @link is ready, 0 if it isn't, -ENODEV if
3620 * link doesn't seem to be occupied, other errno for other error
3621 * conditions.
3622 *
3623 * Transient -ENODEV conditions are allowed for
3624 * ATA_TMOUT_FF_WAIT.
3625 *
3626 * LOCKING:
3627 * EH context.
3628 *
3629 * RETURNS:
c9b5560a 3630 * 0 if @link is ready before @deadline; otherwise, -errno.
aa2731ad
TH		 3631 */
3632int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3633 int (*check_ready)(struct ata_link *link))
3634{
3635 unsigned long start = jiffies;
b48d58f5 3636 unsigned long nodev_deadline;
aa2731ad
TH		 3637 int warned = 0;
3638
b48d58f5
TH		 3639 /* choose which 0xff timeout to use, read comment in libata.h */
3640 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3641 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3642 else
3643 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3644
b1c72916
TH		 3645 /* Slave readiness can't be tested separately from master. On
3646 * M/S emulation configuration, this function should be called
3647 * only on the master and it will handle both master and slave.
3648 */
3649 WARN_ON(link == link->ap->slave_link);
3650
aa2731ad
TH		 3651 if (time_after(nodev_deadline, deadline))
3652 nodev_deadline = deadline;
3653
3654 while (1) {
3655 unsigned long now = jiffies;
3656 int ready, tmp;
3657
3658 ready = tmp = check_ready(link);
3659 if (ready > 0)
3660 return 0;
3661
b48d58f5
TH		 3662 /*
3663 * -ENODEV could be transient. Ignore -ENODEV if link
aa2731ad 3664 * is online. Also, some SATA devices take a long
b48d58f5
TH		 3665 * time to clear 0xff after reset. Wait for
3666 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3667 * offline.
aa2731ad
TH		 3668 *
3669 * Note that some PATA controllers (pata_ali) explode
3670 * if status register is read more than once when
3671 * there's no device attached.
3672 */
3673 if (ready == -ENODEV) {
3674 if (ata_link_online(link))
3675 ready = 0;
3676 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3677 !ata_link_offline(link) &&
3678 time_before(now, nodev_deadline))
3679 ready = 0;
3680 }
3681
3682 if (ready)
3683 return ready;
3684 if (time_after(now, deadline))
3685 return -EBUSY;
3686
3687 if (!warned && time_after(now, start + 5 * HZ) &&
3688 (deadline - now > 3 * HZ)) {
a9a79dfe 3689 ata_link_warn(link,
aa2731ad
TH		 3690 "link is slow to respond, please be patient "
3691 "(ready=%d)\n", tmp);
3692 warned = 1;
3693 }
3694
97750ceb 3695 ata_msleep(link->ap, 50);
aa2731ad
TH		 3696 }
3697}
3698
3699/**
3700 * ata_wait_after_reset - wait for link to become ready after reset
3701 * @link: link to be waited on
3702 * @deadline: deadline jiffies for the operation
3703 * @check_ready: callback to check link readiness
3704 *
3705 * Wait for @link to become ready after reset.
3706 *
3707 * LOCKING:
3708 * EH context.
3709 *
3710 * RETURNS:
c9b5560a 3711 * 0 if @link is ready before @deadline; otherwise, -errno.
aa2731ad 3712 */
2b4221bb 3713int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
aa2731ad
TH		 3714 int (*check_ready)(struct ata_link *link))
3715{
97750ceb 3716 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
aa2731ad
TH		 3717
3718 return ata_wait_ready(link, deadline, check_ready);
3719}
a52fbcfc 3720EXPORT_SYMBOL_GPL(ata_wait_after_reset);
aa2731ad 3721
f5914a46 3722/**
0aa1113d 3723 * ata_std_prereset - prepare for reset
cc0680a5 3724 * @link: ATA link to be reset
d4b2bab4 3725 * @deadline: deadline jiffies for the operation
f5914a46 3726 *
cc0680a5 3727 * @link is about to be reset. Initialize it. Failure from
b8cffc6a
TH		 3728 * prereset makes libata abort whole reset sequence and give up
3729 * that port, so prereset should be best-effort. It does its
3730 * best to prepare for reset sequence but if things go wrong, it
3731 * should just whine, not fail.
f5914a46
TH		 3732 *
3733 * LOCKING:
3734 * Kernel thread context (may sleep)
3735 *
3736 * RETURNS:
ac1eb665 3737 * Always 0.
f5914a46 3738 */
0aa1113d 3739int ata_std_prereset(struct ata_link *link, unsigned long deadline)
f5914a46 3740{
cc0680a5 3741 struct ata_port *ap = link->ap;
936fd732 3742 struct ata_eh_context *ehc = &link->eh_context;
d14d41cc 3743 const unsigned int *timing = sata_ehc_deb_timing(ehc);
f5914a46
TH		 3744 int rc;
3745
f5914a46
TH		 3746 /* if we're about to do hardreset, nothing more to do */
3747 if (ehc->i.action & ATA_EH_HARDRESET)
3748 return 0;
3749
936fd732 3750 /* if SATA, resume link */
a16abc0b 3751 if (ap->flags & ATA_FLAG_SATA) {
936fd732 3752 rc = sata_link_resume(link, timing, deadline);
b8cffc6a
TH		 3753 /* whine about phy resume failure but proceed */
3754 if (rc && rc != -EOPNOTSUPP)
a9a79dfe
JP		 3755 ata_link_warn(link,
3756 "failed to resume link for reset (errno=%d)\n",
3757 rc);
f5914a46
TH		 3758 }
3759
45db2f6c 3760 /* no point in trying softreset on offline link */
b1c72916 3761 if (ata_phys_link_offline(link))
45db2f6c
TH		 3762 ehc->i.action &= ~ATA_EH_SOFTRESET;
3763
f5914a46
TH		 3764 return 0;
3765}
a52fbcfc 3766EXPORT_SYMBOL_GPL(ata_std_prereset);
f5914a46 3767
57c9efdf
TH		 3768/**
3769 * sata_std_hardreset - COMRESET w/o waiting or classification
3770 * @link: link to reset
3771 * @class: resulting class of attached device
3772 * @deadline: deadline jiffies for the operation
3773 *
3774 * Standard SATA COMRESET w/o waiting or classification.
3775 *
3776 * LOCKING:
3777 * Kernel thread context (may sleep)
3778 *
3779 * RETURNS:
3780 * 0 if link offline, -EAGAIN if link online, -errno on errors.
3781 */
3782int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3783 unsigned long deadline)
3784{
d14d41cc 3785 const unsigned int *timing = sata_ehc_deb_timing(&link->eh_context);
57c9efdf
TH		 3786 bool online;
3787 int rc;
3788
3789 /* do hardreset */
3790 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
57c9efdf
TH		 3791 return online ? -EAGAIN : rc;
3792}
a52fbcfc 3793EXPORT_SYMBOL_GPL(sata_std_hardreset);
57c9efdf 3794
c2bd5804 3795/**
203c75b8 3796 * ata_std_postreset - standard postreset callback
cc0680a5 3797 * @link: the target ata_link
c2bd5804
TH		 3798 * @classes: classes of attached devices
3799 *
3800 * This function is invoked after a successful reset. Note that
3801 * the device might have been reset more than once using
3802 * different reset methods before postreset is invoked.
c2bd5804 3803 *
c2bd5804
TH		 3804 * LOCKING:
3805 * Kernel thread context (may sleep)
3806 */
203c75b8 3807void ata_std_postreset(struct ata_link *link, unsigned int *classes)
c2bd5804 3808{
f046519f
TH		 3809 u32 serror;
3810
f046519f
TH		 3811 /* reset complete, clear SError */
3812 if (!sata_scr_read(link, SCR_ERROR, &serror))
3813 sata_scr_write(link, SCR_ERROR, serror);
3814
c2bd5804 3815 /* print link status */
936fd732 3816 sata_print_link_status(link);
c2bd5804 3817}
a52fbcfc 3818EXPORT_SYMBOL_GPL(ata_std_postreset);
c2bd5804 3819
623a3128
TH		 3820/**
3821 * ata_dev_same_device - Determine whether new ID matches configured device
623a3128
TH		 3822 * @dev: device to compare against
3823 * @new_class: class of the new device
3824 * @new_id: IDENTIFY page of the new device
3825 *
3826 * Compare @new_class and @new_id against @dev and determine
3827 * whether @dev is the device indicated by @new_class and
3828 * @new_id.
3829 *
3830 * LOCKING:
3831 * None.
3832 *
3833 * RETURNS:
3834 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
3835 */
3373efd8
TH		 3836static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3837 const u16 *new_id)
623a3128
TH		 3838{
3839 const u16 *old_id = dev->id;
a0cf733b
TH		 3840 unsigned char model[2][ATA_ID_PROD_LEN + 1];
3841 unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
623a3128
TH		 3842
3843 if (dev->class != new_class) {
a9a79dfe
JP		 3844 ata_dev_info(dev, "class mismatch %d != %d\n",
3845 dev->class, new_class);
623a3128
TH		 3846 return 0;
3847 }
3848
a0cf733b
TH		 3849 ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3850 ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3851 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3852 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
623a3128
TH		 3853
3854 if (strcmp(model[0], model[1])) {
a9a79dfe
JP		 3855 ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
3856 model[0], model[1]);
623a3128
TH		 3857 return 0;
3858 }
3859
3860 if (strcmp(serial[0], serial[1])) {
a9a79dfe
JP		 3861 ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
3862 serial[0], serial[1]);
623a3128
TH		 3863 return 0;
3864 }
3865
623a3128
TH		 3866 return 1;
3867}
3868
3869/**
fe30911b 3870 * ata_dev_reread_id - Re-read IDENTIFY data
3fae450c 3871 * @dev: target ATA device
bff04647 3872 * @readid_flags: read ID flags
623a3128
TH		 3873 *
3874 * Re-read IDENTIFY page and make sure @dev is still attached to
3875 * the port.
3876 *
3877 * LOCKING:
3878 * Kernel thread context (may sleep)
3879 *
3880 * RETURNS:
3881 * 0 on success, negative errno otherwise
3882 */
fe30911b 3883int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
623a3128 3884{
5eb45c02 3885 unsigned int class = dev->class;
9af5c9c9 3886 u16 *id = (void *)dev->link->ap->sector_buf;
623a3128
TH		 3887 int rc;
3888
fe635c7e 3889 /* read ID data */
bff04647 3890 rc = ata_dev_read_id(dev, &class, readid_flags, id);
623a3128 3891 if (rc)
fe30911b 3892 return rc;
623a3128
TH		 3893
3894 /* is the device still there? */
fe30911b
TH		 3895 if (!ata_dev_same_device(dev, class, id))
3896 return -ENODEV;
623a3128 3897
fe635c7e 3898 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
fe30911b
TH		 3899 return 0;
3900}
3901
3902/**
3903 * ata_dev_revalidate - Revalidate ATA device
3904 * @dev: device to revalidate
422c9daa 3905 * @new_class: new class code
fe30911b
TH		 3906 * @readid_flags: read ID flags
3907 *
3908 * Re-read IDENTIFY page, make sure @dev is still attached to the
3909 * port and reconfigure it according to the new IDENTIFY page.
3910 *
3911 * LOCKING:
3912 * Kernel thread context (may sleep)
3913 *
3914 * RETURNS:
3915 * 0 on success, negative errno otherwise
3916 */
422c9daa
TH		 3917int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
3918 unsigned int readid_flags)
fe30911b 3919{
6ddcd3b0 3920 u64 n_sectors = dev->n_sectors;
5920dadf 3921 u64 n_native_sectors = dev->n_native_sectors;
fe30911b
TH		 3922 int rc;
3923
3924 if (!ata_dev_enabled(dev))
3925 return -ENODEV;
3926
422c9daa 3927 /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
12e2e17d 3928 if (ata_class_enabled(new_class) && new_class == ATA_DEV_PMP) {
a9a79dfe
JP		 3929 ata_dev_info(dev, "class mismatch %u != %u\n",
3930 dev->class, new_class);
422c9daa
TH		 3931 rc = -ENODEV;
3932 goto fail;
3933 }
3934
fe30911b
TH		 3935 /* re-read ID */
3936 rc = ata_dev_reread_id(dev, readid_flags);
3937 if (rc)
3938 goto fail;
623a3128
TH		 3939
3940 /* configure device according to the new ID */
efdaedc4 3941 rc = ata_dev_configure(dev);
6ddcd3b0
TH		 3942 if (rc)
3943 goto fail;
3944
3945 /* verify n_sectors hasn't changed */
445d211b
TH		 3946 if (dev->class != ATA_DEV_ATA || !n_sectors ||
3947 dev->n_sectors == n_sectors)
3948 return 0;
3949
3950 /* n_sectors has changed */
a9a79dfe
JP		 3951 ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
3952 (unsigned long long)n_sectors,
3953 (unsigned long long)dev->n_sectors);
445d211b
TH		 3954
3955 /*
3956 * Something could have caused HPA to be unlocked
3957 * involuntarily. If n_native_sectors hasn't changed and the
3958 * new size matches it, keep the device.
3959 */
3960 if (dev->n_native_sectors == n_native_sectors &&
3961 dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
a9a79dfe
JP		 3962 ata_dev_warn(dev,
3963 "new n_sectors matches native, probably "
3964 "late HPA unlock, n_sectors updated\n");
68939ce5 3965 /* use the larger n_sectors */
445d211b 3966 return 0;
6ddcd3b0
TH		 3967 }
3968
445d211b
TH		 3969 /*
3970 * Some BIOSes boot w/o HPA but resume w/ HPA locked. Try
3971 * unlocking HPA in those cases.
3972 *
3973 * https://bugzilla.kernel.org/show_bug.cgi?id=15396
3974 */
3975 if (dev->n_native_sectors == n_native_sectors &&
3976 dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
3977 !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
a9a79dfe
JP		 3978 ata_dev_warn(dev,
3979 "old n_sectors matches native, probably "
3980 "late HPA lock, will try to unlock HPA\n");
445d211b
TH		 3981 /* try unlocking HPA */
3982 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
3983 rc = -EIO;
3984 } else
3985 rc = -ENODEV;
623a3128 3986
445d211b
TH		 3987 /* restore original n_[native_]sectors and fail */
3988 dev->n_native_sectors = n_native_sectors;
3989 dev->n_sectors = n_sectors;
623a3128 3990 fail:
a9a79dfe 3991 ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
623a3128
TH		 3992 return rc;
3993}
3994
6919a0a6
AC		 3995struct ata_blacklist_entry {
3996 const char *model_num;
3997 const char *model_rev;
3998 unsigned long horkage;
3999};
4000
4001static const struct ata_blacklist_entry ata_device_blacklist [] = {
4002 /* Devices with DMA related problems under Linux */
4003 { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA },
4004 { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA },
4005 { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA },
4006 { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA },
4007 { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA },
4008 { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA },
4009 { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA },
4010 { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA },
4011 { "CRD-8400B", NULL, ATA_HORKAGE_NODMA },
7da4c935 4012 { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4013 { "CRD-84", NULL, ATA_HORKAGE_NODMA },
4014 { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA },
4015 { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
4016 { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA },
4017 { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA },
7da4c935 4018 { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4019 { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA },
4020 { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA },
4021 { "CD-532E-A", NULL, ATA_HORKAGE_NODMA },
4022 { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA },
4023 { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA },
4024 { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
4025 { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
4026 { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
6919a0a6
AC		 4027 { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
4028 { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
2dcb407e 4029 { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA },
39f19886 4030 { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA },
d17d794c 4031 { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA },
b00622fc 4032 { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3af9a77a 4033 /* Odd clown on sil3726/4726 PMPs */
50af2fa1 4034 { "Config Disk", NULL, ATA_HORKAGE_DISABLE },
a66307d4
HR		 4035 /* Similar story with ASMedia 1092 */
4036 { "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE },
6919a0a6 4037
18d6e9d5 4038 /* Weird ATAPI devices */
40a1d531 4039 { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },
6a87e42e 4040 { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA },
a32450e1 4041 { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
0523f037 4042 { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
18d6e9d5 4043
af34d637
DM		 4044 /*
4045 * Causes silent data corruption with higher max sects.
4046 * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
4047 */
4048 { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 },
1488a1e3
TH		 4049
4050 /*
e0edc8c5 4051 * These devices time out with higher max sects.
1488a1e3
TH		 4052 * https://bugzilla.kernel.org/show_bug.cgi?id=121671
4053 */
e0edc8c5 4054 { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 },
db5ff909 4055 { "LITEON EP1-*", NULL, ATA_HORKAGE_MAX_SEC_1024 },
af34d637 4056
6919a0a6
AC		 4057 /* Devices we expect to fail diagnostics */
4058
4059 /* Devices where NCQ should be avoided */
4060 /* NCQ is slow */
2dcb407e 4061 { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
ef1429c0 4062 { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ },
09125ea6
TH		 4063 /* http://thread.gmane.org/gmane.linux.ide/14907 */
4064 { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
7acfaf30 4065 /* NCQ is broken */
539cc7c7 4066 { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ },
0e3dbc01 4067 { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ },
da6f0ec2 4068 { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ },
e41bd3e8 4069 { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ },
5ccfca97 4070 { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ },
539cc7c7 4071
ac70a964 4072 /* Seagate NCQ + FLUSH CACHE firmware bug */
4d1f9082 4073 { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
ac70a964 4074 ATA_HORKAGE_FIRMWARE_WARN },
d10d491f 4075
4d1f9082 4076 { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
d10d491f
TH		 4077 ATA_HORKAGE_FIRMWARE_WARN },
4078
4d1f9082 4079 { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
d10d491f
TH		 4080 ATA_HORKAGE_FIRMWARE_WARN },
4081
4d1f9082 4082 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
ac70a964
TH		 4083 ATA_HORKAGE_FIRMWARE_WARN },
4084
31f6264e
HG		 4085 /* drives which fail FPDMA_AA activation (some may freeze afterwards)
4086 the ST disks also have LPM issues */
8756a25b 4087 { "ST1000LM024 HN-M101MBB", NULL, ATA_HORKAGE_BROKEN_FPDMA_AA |
ef1429c0 4088 ATA_HORKAGE_NOLPM },
08c85d2a 4089 { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
87809942 4090
36e337d0
RH		 4091 /* Blacklist entries taken from Silicon Image 3124/3132
4092 Windows driver .inf file - also several Linux problem reports */
ef1429c0
DLM		 4093 { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ },
4094 { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ },
4095 { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ },
6919a0a6 4096
68b0ddb2 4097 /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */
ef1429c0 4098 { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ },
68b0ddb2 4099
3b545563 4100 /* Sandisk SD7/8/9s lock up hard on large trims */
ef1429c0 4101 { "SanDisk SD[789]*", NULL, ATA_HORKAGE_MAX_TRIM_128M },
322579dc 4102
16c55b03 4103 /* devices which puke on READ_NATIVE_MAX */
ef1429c0 4104 { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA },
16c55b03
TH		 4105 { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
4106 { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
4107 { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA },
6919a0a6 4108
7831387b
TH		 4109 /* this one allows HPA unlocking but fails IOs on the area */
4110 { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA },
4111
93328e11 4112 /* Devices which report 1 sector over size HPA */
ef1429c0
DLM		 4113 { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE },
4114 { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE },
4115 { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE },
93328e11 4116
6bbfd53d 4117 /* Devices which get the IVB wrong */
ef1429c0 4118 { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB },
a79067e5 4119 /* Maybe we should just blacklist TSSTcorp... */
ef1429c0 4120 { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB },
6bbfd53d 4121
9ce8e307 4122 /* Devices that do not need bridging limits applied */
ef1429c0
DLM		 4123 { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK },
4124 { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK },
9ce8e307 4125
9062712f 4126 /* Devices which aren't very happy with higher link speeds */
ef1429c0
DLM		 4127 { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS },
4128 { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS },
9062712f 4129
d0cb43b3
TH		 4130 /*
4131 * Devices which choke on SETXFER. Applies only if both the
4132 * device and controller are SATA.
4133 */
cd691876 4134 { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER },
3a25179e
VL		 4135 { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER },
4136 { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER },
cd691876
TH		 4137 { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
4138 { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
d0cb43b3 4139
ea08aec7
NC		 4140 /* These specific Pioneer models have LPM issues */
4141 { "PIONEER BD-RW BDR-207M", NULL, ATA_HORKAGE_NOLPM },
4142 { "PIONEER BD-RW BDR-205", NULL, ATA_HORKAGE_NOLPM },
4143
b17e5729 4144 /* Crucial BX100 SSD 500GB has broken LPM support */
3bf7b5d6 4145 { "CT500BX100SSD1", NULL, ATA_HORKAGE_NOLPM },
b17e5729 4146
d418ff56
HG		 4147 /* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */
4148 { "Crucial_CT512MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
9c7be59f 4149 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4150 ATA_HORKAGE_NOLPM },
d418ff56
HG		 4151 /* 512GB MX100 with newer firmware has only LPM issues */
4152 { "Crucial_CT512MX100*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4153 ATA_HORKAGE_NOLPM },
9c7be59f 4154
62ac3f73
HG		 4155 /* 480GB+ M500 SSDs have both queued TRIM and LPM issues */
4156 { "Crucial_CT480M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4157 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4158 ATA_HORKAGE_NOLPM },
62ac3f73
HG		 4159 { "Crucial_CT960M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4160 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4161 ATA_HORKAGE_NOLPM },
62ac3f73 4162
76936e9a 4163 /* These specific Samsung models/firmware-revs do not handle LPM well */
ef1429c0
DLM		 4164 { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM },
4165 { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_HORKAGE_NOLPM },
4166 { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_HORKAGE_NOLPM },
4167 { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM },
b5b4d3a5 4168
f78dea06 4169 /* devices that don't properly handle queued TRIM commands */
136d769e 4170 { "Micron_M500IT_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4171 ATA_HORKAGE_ZERO_AFTER_TRIM },
243918be 4172 { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4173 ATA_HORKAGE_ZERO_AFTER_TRIM },
9051bd39 4174 { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4175 ATA_HORKAGE_ZERO_AFTER_TRIM },
27fd0710
PZ		 4176 { "Micron_1100_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4177 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4178 { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4179 ATA_HORKAGE_ZERO_AFTER_TRIM },
ff7f53fb 4180 { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4181 ATA_HORKAGE_ZERO_AFTER_TRIM },
ff7f53fb 4182 { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4183 ATA_HORKAGE_ZERO_AFTER_TRIM },
53997522
CL		 4184 { "Samsung SSD 840 EVO*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4185 ATA_HORKAGE_NO_DMA_LOG |
ef1429c0 4186 ATA_HORKAGE_ZERO_AFTER_TRIM },
ca6bfcb2 4187 { "Samsung SSD 840*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4188 ATA_HORKAGE_ZERO_AFTER_TRIM },
ca6bfcb2 4189 { "Samsung SSD 850*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4190 ATA_HORKAGE_ZERO_AFTER_TRIM },
8a6430ab 4191 { "Samsung SSD 860*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
7a8526a5 4192 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4193 ATA_HORKAGE_NO_NCQ_ON_ATI },
8a6430ab 4194 { "Samsung SSD 870*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
7a8526a5 4195 ATA_HORKAGE_ZERO_AFTER_TRIM |
ef1429c0 4196 ATA_HORKAGE_NO_NCQ_ON_ATI },
ead08957
PM		 4197 { "SAMSUNG*MZ7LH*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4198 ATA_HORKAGE_ZERO_AFTER_TRIM |
4199 ATA_HORKAGE_NO_NCQ_ON_ATI, },
7a7184b0 4200 { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
ef1429c0 4201 ATA_HORKAGE_ZERO_AFTER_TRIM },
e61f7d1c 4202
cda57b1b 4203 /* devices that don't properly handle TRIM commands */
ef1429c0
DLM		 4204 { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM },
4205 { "M88V29*", NULL, ATA_HORKAGE_NOTRIM },
cda57b1b 4206
e61f7d1c
MP		 4207 /*
4208 * As defined, the DRAT (Deterministic Read After Trim) and RZAT
4209 * (Return Zero After Trim) flags in the ATA Command Set are
4210 * unreliable in the sense that they only define what happens if
4211 * the device successfully executed the DSM TRIM command. TRIM
4212 * is only advisory, however, and the device is free to silently
4213 * ignore all or parts of the request.
4214 *
4215 * Whitelist drives that are known to reliably return zeroes
4216 * after TRIM.
4217 */
4218
4219 /*
4220 * The intel 510 drive has buggy DRAT/RZAT. Explicitly exclude
4221 * that model before whitelisting all other intel SSDs.
4222 */
ef1429c0
DLM		 4223 { "INTEL*SSDSC2MH*", NULL, 0 },
4224
4225 { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4226 { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4227 { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4228 { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4229 { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4230 { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4231 { "SAMSUNG*MZ7KM*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
4232 { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM },
f78dea06 4233
ecd75ad5
TH		 4234 /*
4235 * Some WD SATA-I drives spin up and down erratically when the link
4236 * is put into the slumber mode. We don't have full list of the
4237 * affected devices. Disable LPM if the device matches one of the
4238 * known prefixes and is SATA-1. As a side effect LPM partial is
4239 * lost too.
4240 *
4241 * https://bugzilla.kernel.org/show_bug.cgi?id=57211
4242 */
4243 { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4244 { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4245 { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4246 { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4247 { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4248 { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4249 { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4250
ac9f0c81
AL		 4251 /*
4252 * This sata dom device goes on a walkabout when the ATA_LOG_DIRECTORY
4253 * log page is accessed. Ensure we never ask for this log page with
4254 * these devices.
4255 */
4256 { "SATADOM-ML 3ME", NULL, ATA_HORKAGE_NO_LOG_DIR },
4257
4d2e4980
DLM		 4258 /* Buggy FUA */
4259 { "Maxtor", "BANC1G10", ATA_HORKAGE_NO_FUA },
38d43122
DLM		 4260 { "WDC*WD2500J*", NULL, ATA_HORKAGE_NO_FUA },
4261 { "OCZ-VERTEX*", NULL, ATA_HORKAGE_NO_FUA },
4262 { "INTEL*SSDSC2CT*", NULL, ATA_HORKAGE_NO_FUA },
4d2e4980 4263
6919a0a6
AC		 4264 /* End Marker */
4265 { }
1da177e4 4266};
2e9edbf8 4267
75683fe7 4268static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
1da177e4 4269{
8bfa79fc
TH		 4270 unsigned char model_num[ATA_ID_PROD_LEN + 1];
4271 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
6919a0a6 4272 const struct ata_blacklist_entry *ad = ata_device_blacklist;
3a778275 4273
8bfa79fc
TH		 4274 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4275 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
1da177e4 4276
6919a0a6 4277 while (ad->model_num) {
1c402799 4278 if (glob_match(ad->model_num, model_num)) {
6919a0a6
AC		 4279 if (ad->model_rev == NULL)
4280 return ad->horkage;
1c402799 4281 if (glob_match(ad->model_rev, model_rev))
6919a0a6 4282 return ad->horkage;
f4b15fef 4283 }
6919a0a6 4284 ad++;
f4b15fef 4285 }
1da177e4
LT		 4286 return 0;
4287}
4288
6919a0a6
AC		 4289static int ata_dma_blacklisted(const struct ata_device *dev)
4290{
4291 /* We don't support polling DMA.
4292 * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
4293 * if the LLDD handles only interrupts in the HSM_ST_LAST state.
4294 */
9af5c9c9 4295 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
6919a0a6
AC		 4296 (dev->flags & ATA_DFLAG_CDB_INTR))
4297 return 1;
75683fe7 4298 return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
6919a0a6
AC		 4299}
4300
6bbfd53d
AC		 4301/**
4302 * ata_is_40wire - check drive side detection
4303 * @dev: device
4304 *
4305 * Perform drive side detection decoding, allowing for device vendors
4306 * who can't follow the documentation.
4307 */
4308
4309static int ata_is_40wire(struct ata_device *dev)
4310{
4311 if (dev->horkage & ATA_HORKAGE_IVB)
4312 return ata_drive_40wire_relaxed(dev->id);
4313 return ata_drive_40wire(dev->id);
4314}
4315
15a5551c
AC		 4316/**
4317 * cable_is_40wire - 40/80/SATA decider
4318 * @ap: port to consider
4319 *
4320 * This function encapsulates the policy for speed management
4321 * in one place. At the moment we don't cache the result but
4322 * there is a good case for setting ap->cbl to the result when
4323 * we are called with unknown cables (and figuring out if it
4324 * impacts hotplug at all).
4325 *
4326 * Return 1 if the cable appears to be 40 wire.
4327 */
4328
4329static int cable_is_40wire(struct ata_port *ap)
4330{
4331 struct ata_link *link;
4332 struct ata_device *dev;
4333
4a9c7b33 4334 /* If the controller thinks we are 40 wire, we are. */
15a5551c
AC		 4335 if (ap->cbl == ATA_CBL_PATA40)
4336 return 1;
4a9c7b33
TH		 4337
4338 /* If the controller thinks we are 80 wire, we are. */
15a5551c
AC		 4339 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4340 return 0;
4a9c7b33
TH		 4341
4342 /* If the system is known to be 40 wire short cable (eg
4343 * laptop), then we allow 80 wire modes even if the drive
4344 * isn't sure.
4345 */
f792068e
AC		 4346 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4347 return 0;
4a9c7b33
TH		 4348
4349 /* If the controller doesn't know, we scan.
4350 *
4351 * Note: We look for all 40 wire detects at this point. Any
4352 * 80 wire detect is taken to be 80 wire cable because
4353 * - in many setups only the one drive (slave if present) will
4354 * give a valid detect
4355 * - if you have a non detect capable drive you don't want it
4356 * to colour the choice
4357 */
1eca4365
TH		 4358 ata_for_each_link(link, ap, EDGE) {
4359 ata_for_each_dev(dev, link, ENABLED) {
4360 if (!ata_is_40wire(dev))
15a5551c
AC		 4361 return 0;
4362 }
4363 }
4364 return 1;
4365}
4366
a6d5a51c
TH		 4367/**
4368 * ata_dev_xfermask - Compute supported xfermask of the given device
a6d5a51c
TH		 4369 * @dev: Device to compute xfermask for
4370 *
acf356b1
TH		 4371 * Compute supported xfermask of @dev and store it in
4372 * dev->*_mask. This function is responsible for applying all
4373 * known limits including host controller limits, device
4374 * blacklist, etc...
a6d5a51c
TH		 4375 *
4376 * LOCKING:
4377 * None.
a6d5a51c 4378 */
3373efd8 4379static void ata_dev_xfermask(struct ata_device *dev)
1da177e4 4380{
9af5c9c9
TH		 4381 struct ata_link *link = dev->link;
4382 struct ata_port *ap = link->ap;
cca3974e 4383 struct ata_host *host = ap->host;
f0a6d77b 4384 unsigned int xfer_mask;
1da177e4 4385
37deecb5 4386 /* controller modes available */
565083e1
TH		 4387 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4388 ap->mwdma_mask, ap->udma_mask);
4389
8343f889 4390 /* drive modes available */
37deecb5
TH		 4391 xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4392 dev->mwdma_mask, dev->udma_mask);
4393 xfer_mask &= ata_id_xfermask(dev->id);
565083e1 4394
b352e57d
AC		 4395 /*
4396 * CFA Advanced TrueIDE timings are not allowed on a shared
4397 * cable
4398 */
4399 if (ata_dev_pair(dev)) {
4400 /* No PIO5 or PIO6 */
4401 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4402 /* No MWDMA3 or MWDMA 4 */
4403 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4404 }
4405
37deecb5
TH		 4406 if (ata_dma_blacklisted(dev)) {
4407 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
a9a79dfe
JP		 4408 ata_dev_warn(dev,
4409 "device is on DMA blacklist, disabling DMA\n");
37deecb5 4410 }
a6d5a51c 4411
14d66ab7 4412 if ((host->flags & ATA_HOST_SIMPLEX) &&
2dcb407e 4413 host->simplex_claimed && host->simplex_claimed != ap) {
37deecb5 4414 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
a9a79dfe
JP		 4415 ata_dev_warn(dev,
4416 "simplex DMA is claimed by other device, disabling DMA\n");
5444a6f4 4417 }
565083e1 4418
e424675f
JG		 4419 if (ap->flags & ATA_FLAG_NO_IORDY)
4420 xfer_mask &= ata_pio_mask_no_iordy(dev);
4421
5444a6f4 4422 if (ap->ops->mode_filter)
a76b62ca 4423 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
5444a6f4 4424
8343f889
RH		 4425 /* Apply cable rule here. Don't apply it early because when
4426 * we handle hot plug the cable type can itself change.
4427 * Check this last so that we know if the transfer rate was
4428 * solely limited by the cable.
4429 * Unknown or 80 wire cables reported host side are checked
4430 * drive side as well. Cases where we know a 40wire cable
4431 * is used safely for 80 are not checked here.
4432 */
4433 if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4434 /* UDMA/44 or higher would be available */
15a5551c 4435 if (cable_is_40wire(ap)) {
a9a79dfe
JP		 4436 ata_dev_warn(dev,
4437 "limited to UDMA/33 due to 40-wire cable\n");
8343f889
RH		 4438 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4439 }
4440
565083e1
TH		 4441 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4442 &dev->mwdma_mask, &dev->udma_mask);
1da177e4
LT		 4443}
4444
1da177e4
LT		 4445/**
4446 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
1da177e4
LT		 4447 * @dev: Device to which command will be sent
4448 *
780a87f7
JG		 4449 * Issue SET FEATURES - XFER MODE command to device @dev
4450 * on port @ap.
4451 *
1da177e4 4452 * LOCKING:
0cba632b 4453 * PCI/etc. bus probe sem.
83206a29
TH		 4454 *
4455 * RETURNS:
4456 * 0 on success, AC_ERR_* mask otherwise.
1da177e4
LT		 4457 */
4458
3373efd8 4459static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
1da177e4 4460{
a0123703 4461 struct ata_taskfile tf;
1da177e4
LT		 4462
4463 /* set up set-features taskfile */
4633778b 4464 ata_dev_dbg(dev, "set features - xfer mode\n");
1da177e4 4465
464cf177
TH		 4466 /* Some controllers and ATAPI devices show flaky interrupt
4467 * behavior after setting xfer mode. Use polling instead.
4468 */
3373efd8 4469 ata_tf_init(dev, &tf);
a0123703
TH		 4470 tf.command = ATA_CMD_SET_FEATURES;
4471 tf.feature = SETFEATURES_XFER;
464cf177 4472 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
a0123703 4473 tf.protocol = ATA_PROT_NODATA;
b9f8ab2d 4474 /* If we are using IORDY we must send the mode setting command */
11b7becc
JG		 4475 if (ata_pio_need_iordy(dev))
4476 tf.nsect = dev->xfer_mode;
b9f8ab2d
AC		 4477 /* If the device has IORDY and the controller does not - turn it off */
4478 else if (ata_id_has_iordy(dev->id))
11b7becc 4479 tf.nsect = 0x01;
b9f8ab2d
AC		 4480 else /* In the ancient relic department - skip all of this */
4481 return 0;
1da177e4 4482
024811a2
DLM		 4483 /*
4484 * On some disks, this command causes spin-up, so we need longer
4485 * timeout.
4486 */
4487 return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
9f45cbd3 4488}
1152b261 4489
9f45cbd3 4490/**
99ad3f9f 4491 * ata_dev_set_feature - Issue SET FEATURES
9f45cbd3 4492 * @dev: Device to which command will be sent
99ad3f9f
NC		 4493 * @subcmd: The SET FEATURES subcommand to be sent
4494 * @action: The sector count represents a subcommand specific action
9f45cbd3 4495 *
99ad3f9f 4496 * Issue SET FEATURES command to device @dev on port @ap with sector count
9f45cbd3
KCA		 4497 *
4498 * LOCKING:
4499 * PCI/etc. bus probe sem.
4500 *
4501 * RETURNS:
4502 * 0 on success, AC_ERR_* mask otherwise.
4503 */
99ad3f9f 4504unsigned int ata_dev_set_feature(struct ata_device *dev, u8 subcmd, u8 action)
9f45cbd3
KCA		 4505{
4506 struct ata_taskfile tf;
61176eed 4507 unsigned int timeout = 0;
9f45cbd3
KCA		 4508
4509 /* set up set-features taskfile */
99ad3f9f 4510 ata_dev_dbg(dev, "set features\n");
9f45cbd3
KCA		 4511
4512 ata_tf_init(dev, &tf);
4513 tf.command = ATA_CMD_SET_FEATURES;
99ad3f9f 4514 tf.feature = subcmd;
9f45cbd3
KCA		 4515 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4516 tf.protocol = ATA_PROT_NODATA;
99ad3f9f 4517 tf.nsect = action;
9f45cbd3 4518
99ad3f9f 4519 if (subcmd == SETFEATURES_SPINUP)
974e0a45
DLM		 4520 timeout = ata_probe_timeout ?
4521 ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
1da177e4 4522
614065ab 4523 return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
1da177e4 4524}
633de4cc 4525EXPORT_SYMBOL_GPL(ata_dev_set_feature);
1da177e4 4526
8bf62ece
AL		 4527/**
4528 * ata_dev_init_params - Issue INIT DEV PARAMS command
8bf62ece 4529 * @dev: Device to which command will be sent
e2a7f77a
RD		 4530 * @heads: Number of heads (taskfile parameter)
4531 * @sectors: Number of sectors (taskfile parameter)
8bf62ece
AL		 4532 *
4533 * LOCKING:
6aff8f1f
TH		 4534 * Kernel thread context (may sleep)
4535 *
4536 * RETURNS:
4537 * 0 on success, AC_ERR_* mask otherwise.
8bf62ece 4538 */
3373efd8
TH		 4539static unsigned int ata_dev_init_params(struct ata_device *dev,
4540 u16 heads, u16 sectors)
8bf62ece 4541{
a0123703 4542 struct ata_taskfile tf;
6aff8f1f 4543 unsigned int err_mask;
8bf62ece
AL		 4544
4545 /* Number of sectors per track 1-255. Number of heads 1-16 */
4546 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
00b6f5e9 4547 return AC_ERR_INVALID;
8bf62ece
AL		 4548
4549 /* set up init dev params taskfile */
4633778b 4550 ata_dev_dbg(dev, "init dev params \n");
8bf62ece 4551
3373efd8 4552 ata_tf_init(dev, &tf);
a0123703
TH		 4553 tf.command = ATA_CMD_INIT_DEV_PARAMS;
4554 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4555 tf.protocol = ATA_PROT_NODATA;
4556 tf.nsect = sectors;
4557 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
8bf62ece 4558
2b789108 4559 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
18b2466c
AC		 4560 /* A clean abort indicates an original or just out of spec drive
4561 and we should continue as we issue the setup based on the
4562 drive reported working geometry */
efcef265 4563 if (err_mask == AC_ERR_DEV && (tf.error & ATA_ABORTED))
18b2466c 4564 err_mask = 0;
8bf62ece 4565
6aff8f1f 4566 return err_mask;
8bf62ece
AL		 4567}
4568
1da177e4 4569/**
5895ef9a 4570 * atapi_check_dma - Check whether ATAPI DMA can be supported
1da177e4
LT		 4571 * @qc: Metadata associated with taskfile to check
4572 *
780a87f7
JG		 4573 * Allow low-level driver to filter ATA PACKET commands, returning
4574 * a status indicating whether or not it is OK to use DMA for the
4575 * supplied PACKET command.
4576 *
1da177e4 4577 * LOCKING:
624d5c51
TH		 4578 * spin_lock_irqsave(host lock)
4579 *
4580 * RETURNS: 0 when ATAPI DMA can be used
4581 * nonzero otherwise
4582 */
5895ef9a 4583int atapi_check_dma(struct ata_queued_cmd *qc)
624d5c51
TH		 4584{
4585 struct ata_port *ap = qc->ap;
71601958 4586
624d5c51
TH		 4587 /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a
4588 * few ATAPI devices choke on such DMA requests.
4589 */
6a87e42e
TH		 4590 if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4591 unlikely(qc->nbytes & 15))
624d5c51 4592 return 1;
e2cec771 4593
624d5c51
TH		 4594 if (ap->ops->check_atapi_dma)
4595 return ap->ops->check_atapi_dma(qc);
e2cec771 4596
624d5c51
TH		 4597 return 0;
4598}
1da177e4 4599
624d5c51
TH		 4600/**
4601 * ata_std_qc_defer - Check whether a qc needs to be deferred
4602 * @qc: ATA command in question
4603 *
4604 * Non-NCQ commands cannot run with any other command, NCQ or
4605 * not. As upper layer only knows the queue depth, we are
4606 * responsible for maintaining exclusion. This function checks
4607 * whether a new command @qc can be issued.
4608 *
4609 * LOCKING:
4610 * spin_lock_irqsave(host lock)
4611 *
4612 * RETURNS:
4613 * ATA_DEFER_* if deferring is needed, 0 otherwise.
4614 */
4615int ata_std_qc_defer(struct ata_queued_cmd *qc)
4616{
4617 struct ata_link *link = qc->dev->link;
e2cec771 4618
179b310a 4619 if (ata_is_ncq(qc->tf.protocol)) {
624d5c51
TH		 4620 if (!ata_tag_valid(link->active_tag))
4621 return 0;
4622 } else {
4623 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4624 return 0;
4625 }
e2cec771 4626
624d5c51
TH		 4627 return ATA_DEFER_LINK;
4628}
a52fbcfc 4629EXPORT_SYMBOL_GPL(ata_std_qc_defer);
6912ccd5 4630
95364f36
JS		 4631enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc)
4632{
4633 return AC_ERR_OK;
4634}
a52fbcfc 4635EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
1da177e4 4636
624d5c51
TH		 4637/**
4638 * ata_sg_init - Associate command with scatter-gather table.
4639 * @qc: Command to be associated
4640 * @sg: Scatter-gather table.
4641 * @n_elem: Number of elements in s/g table.
4642 *
4643 * Initialize the data-related elements of queued_cmd @qc
4644 * to point to a scatter-gather table @sg, containing @n_elem
4645 * elements.
4646 *
4647 * LOCKING:
4648 * spin_lock_irqsave(host lock)
4649 */
4650void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4651 unsigned int n_elem)
4652{
4653 qc->sg = sg;
4654 qc->n_elem = n_elem;
4655 qc->cursg = qc->sg;
4656}
bb5cb290 4657
2874d5ee
GU		 4658#ifdef CONFIG_HAS_DMA
4659
4660/**
4661 * ata_sg_clean - Unmap DMA memory associated with command
4662 * @qc: Command containing DMA memory to be released
4663 *
4664 * Unmap all mapped DMA memory associated with this command.
4665 *
4666 * LOCKING:
4667 * spin_lock_irqsave(host lock)
4668 */
af27e01c 4669static void ata_sg_clean(struct ata_queued_cmd *qc)
2874d5ee
GU		 4670{
4671 struct ata_port *ap = qc->ap;
4672 struct scatterlist *sg = qc->sg;
4673 int dir = qc->dma_dir;
4674
4675 WARN_ON_ONCE(sg == NULL);
4676
2874d5ee
GU		 4677 if (qc->n_elem)
4678 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4679
4680 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4681 qc->sg = NULL;
4682}
4683
624d5c51
TH		 4684/**
4685 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
4686 * @qc: Command with scatter-gather table to be mapped.
4687 *
4688 * DMA-map the scatter-gather table associated with queued_cmd @qc.
4689 *
4690 * LOCKING:
4691 * spin_lock_irqsave(host lock)
4692 *
4693 * RETURNS:
4694 * Zero on success, negative on error.
4695 *
4696 */
4697static int ata_sg_setup(struct ata_queued_cmd *qc)
4698{
4699 struct ata_port *ap = qc->ap;
4700 unsigned int n_elem;
1da177e4 4701
624d5c51
TH		 4702 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4703 if (n_elem < 1)
4704 return -1;
bb5cb290 4705
5825627c 4706 qc->orig_n_elem = qc->n_elem;
624d5c51
TH		 4707 qc->n_elem = n_elem;
4708 qc->flags |= ATA_QCFLAG_DMAMAP;
1da177e4 4709
624d5c51 4710 return 0;
1da177e4
LT		 4711}
4712
2874d5ee
GU		 4713#else /* !CONFIG_HAS_DMA */
4714
4715static inline void ata_sg_clean(struct ata_queued_cmd *qc) {}
4716static inline int ata_sg_setup(struct ata_queued_cmd *qc) { return -1; }
4717
4718#endif /* !CONFIG_HAS_DMA */
4719
624d5c51
TH		 4720/**
4721 * swap_buf_le16 - swap halves of 16-bit words in place
4722 * @buf: Buffer to swap
4723 * @buf_words: Number of 16-bit words in buffer.
4724 *
4725 * Swap halves of 16-bit words if needed to convert from
4726 * little-endian byte order to native cpu byte order, or
4727 * vice-versa.
4728 *
4729 * LOCKING:
4730 * Inherited from caller.
4731 */
4732void swap_buf_le16(u16 *buf, unsigned int buf_words)
8061f5f0 4733{
624d5c51
TH		 4734#ifdef __BIG_ENDIAN
4735 unsigned int i;
8061f5f0 4736
624d5c51
TH		 4737 for (i = 0; i < buf_words; i++)
4738 buf[i] = le16_to_cpu(buf[i]);
4739#endif /* __BIG_ENDIAN */
8061f5f0
TH		 4740}
4741
8a8bc223
TH		 4742/**
4743 * ata_qc_free - free unused ata_queued_cmd
4744 * @qc: Command to complete
4745 *
4746 * Designed to free unused ata_queued_cmd object
4747 * in case something prevents using it.
4748 *
4749 * LOCKING:
4750 * spin_lock_irqsave(host lock)
4751 */
4752void ata_qc_free(struct ata_queued_cmd *qc)
4753{
8a8bc223 4754 qc->flags = 0;
4f1a22ee 4755 if (ata_tag_valid(qc->tag))
8a8bc223 4756 qc->tag = ATA_TAG_POISON;
8a8bc223
TH		 4757}
4758
76014427 4759void __ata_qc_complete(struct ata_queued_cmd *qc)
1da177e4 4760{
a1104016
JL		 4761 struct ata_port *ap;
4762 struct ata_link *link;
dedaf2b0 4763
efcb3cf7
TH		 4764 WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4765 WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
a1104016
JL		 4766 ap = qc->ap;
4767 link = qc->dev->link;
1da177e4
LT		 4768
4769 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4770 ata_sg_clean(qc);
4771
7401abf2 4772 /* command should be marked inactive atomically with qc completion */
179b310a 4773 if (ata_is_ncq(qc->tf.protocol)) {
4e5b6260 4774 link->sactive &= ~(1 << qc->hw_tag);
da917d69
TH		 4775 if (!link->sactive)
4776 ap->nr_active_links--;
4777 } else {
9af5c9c9 4778 link->active_tag = ATA_TAG_POISON;
da917d69
TH		 4779 ap->nr_active_links--;
4780 }
4781
4782 /* clear exclusive status */
4783 if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
4784 ap->excl_link == link))
4785 ap->excl_link = NULL;
7401abf2 4786
3f3791d3
AL		 4787 /* atapi: mark qc as inactive to prevent the interrupt handler
4788 * from completing the command twice later, before the error handler
4789 * is called. (when rc != 0 and atapi request sense is needed)
4790 */
4791 qc->flags &= ~ATA_QCFLAG_ACTIVE;
e3ed8939 4792 ap->qc_active &= ~(1ULL << qc->tag);
3f3791d3 4793
1da177e4 4794 /* call completion callback */
77853bf2 4795 qc->complete_fn(qc);
1da177e4
LT		 4796}
4797
39599a53
TH		 4798static void fill_result_tf(struct ata_queued_cmd *qc)
4799{
4800 struct ata_port *ap = qc->ap;
4801
39599a53 4802 qc->result_tf.flags = qc->tf.flags;
22183bf5 4803 ap->ops->qc_fill_rtf(qc);
39599a53
TH		 4804}
4805
00115e0f
TH		 4806static void ata_verify_xfer(struct ata_queued_cmd *qc)
4807{
4808 struct ata_device *dev = qc->dev;
4809
eb0effdf 4810 if (!ata_is_data(qc->tf.protocol))
00115e0f
TH		 4811 return;
4812
4813 if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
4814 return;
4815
4816 dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
4817}
4818
f686bcb8
TH		 4819/**
4820 * ata_qc_complete - Complete an active ATA command
4821 * @qc: Command to complete
f686bcb8 4822 *
1aadf5c3
TH		 4823 * Indicate to the mid and upper layers that an ATA command has
4824 * completed, with either an ok or not-ok status.
4825 *
4826 * Refrain from calling this function multiple times when
4827 * successfully completing multiple NCQ commands.
4828 * ata_qc_complete_multiple() should be used instead, which will
4829 * properly update IRQ expect state.
f686bcb8
TH		 4830 *
4831 * LOCKING:
cca3974e 4832 * spin_lock_irqsave(host lock)
f686bcb8
TH		 4833 */
4834void ata_qc_complete(struct ata_queued_cmd *qc)
4835{
4836 struct ata_port *ap = qc->ap;
ff8072d5
HR		 4837 struct ata_device *dev = qc->dev;
4838 struct ata_eh_info *ehi = &dev->link->eh_info;
f686bcb8 4839
eb25cb99 4840 /* Trigger the LED (if available) */
d1ed7c55 4841 ledtrig_disk_activity(!!(qc->tf.flags & ATA_TFLAG_WRITE));
eb25cb99 4842
ff8072d5
HR		 4843 /*
4844 * In order to synchronize EH with the regular execution path, a qc that
4845 * is owned by EH is marked with ATA_QCFLAG_EH.
f686bcb8 4846 *
ff8072d5
HR		 4847 * The normal execution path is responsible for not accessing a qc owned
4848 * by EH. libata core enforces the rule by returning NULL from
4849 * ata_qc_from_tag() for qcs owned by EH.
f686bcb8 4850 */
ff8072d5
HR		 4851 if (unlikely(qc->err_mask))
4852 qc->flags |= ATA_QCFLAG_EH;
f686bcb8 4853
ff8072d5
HR		 4854 /*
4855 * Finish internal commands without any further processing and always
4856 * with the result TF filled.
4857 */
4858 if (unlikely(ata_tag_internal(qc->tag))) {
4859 fill_result_tf(qc);
4860 trace_ata_qc_complete_internal(qc);
4861 __ata_qc_complete(qc);
4862 return;
4863 }
f4b31db9 4864
ff8072d5
HR		 4865 /* Non-internal qc has failed. Fill the result TF and summon EH. */
4866 if (unlikely(qc->flags & ATA_QCFLAG_EH)) {
4867 fill_result_tf(qc);
4868 trace_ata_qc_complete_failed(qc);
4869 ata_qc_schedule_eh(qc);
4870 return;
4871 }
f686bcb8 4872
ff8072d5 4873 WARN_ON_ONCE(ata_port_is_frozen(ap));
4dc738ed 4874
ff8072d5
HR		 4875 /* read result TF if requested */
4876 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4877 fill_result_tf(qc);
f686bcb8 4878
ff8072d5 4879 trace_ata_qc_complete_done(qc);
18bd7718 4880
ff8072d5
HR		 4881 /*
4882 * For CDL commands that completed without an error, check if we have
4883 * sense data (ATA_SENSE is set). If we do, then the command may have
4884 * been aborted by the device due to a limit timeout using the policy
4885 * 0xD. For these commands, invoke EH to get the command sense data.
4886 */
5e35a9ac
NC		 4887 if (qc->flags & ATA_QCFLAG_HAS_CDL &&
4888 qc->result_tf.status & ATA_SENSE) {
18bd7718 4889 /*
ff8072d5
HR		 4890 * Tell SCSI EH to not overwrite scmd->result even if this
4891 * command is finished with result SAM_STAT_GOOD.
18bd7718 4892 */
ff8072d5
HR		 4893 qc->scsicmd->flags |= SCMD_FORCE_EH_SUCCESS;
4894 qc->flags |= ATA_QCFLAG_EH_SUCCESS_CMD;
4895 ehi->dev_action[dev->devno] |= ATA_EH_GET_SUCCESS_SENSE;
18bd7718 4896
ff8072d5
HR		 4897 /*
4898 * set pending so that ata_qc_schedule_eh() does not trigger
4899 * fast drain, and freeze the port.
4dbfa39b 4900 */
ff8072d5
HR		 4901 ap->pflags |= ATA_PFLAG_EH_PENDING;
4902 ata_qc_schedule_eh(qc);
4903 return;
4904 }
054a5fba 4905
ff8072d5
HR		 4906 /* Some commands need post-processing after successful completion. */
4907 switch (qc->tf.command) {
4908 case ATA_CMD_SET_FEATURES:
4909 if (qc->tf.feature != SETFEATURES_WC_ON &&
4910 qc->tf.feature != SETFEATURES_WC_OFF &&
4911 qc->tf.feature != SETFEATURES_RA_ON &&
4912 qc->tf.feature != SETFEATURES_RA_OFF)
054a5fba 4913 break;
ff8072d5
HR		 4914 fallthrough;
4915 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
4916 case ATA_CMD_SET_MULTI: /* multi_count changed */
4917 /* revalidate device */
4918 ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
4919 ata_port_schedule_eh(ap);
4920 break;
00115e0f 4921
ff8072d5
HR		 4922 case ATA_CMD_SLEEP:
4923 dev->flags |= ATA_DFLAG_SLEEPING;
4924 break;
4925 }
f686bcb8 4926
ff8072d5
HR		 4927 if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER))
4928 ata_verify_xfer(qc);
f686bcb8 4929
ff8072d5 4930 __ata_qc_complete(qc);
f686bcb8 4931}
a52fbcfc 4932EXPORT_SYMBOL_GPL(ata_qc_complete);
f686bcb8 4933
8385d756
SH		 4934/**
4935 * ata_qc_get_active - get bitmask of active qcs
4936 * @ap: port in question
4937 *
4938 * LOCKING:
4939 * spin_lock_irqsave(host lock)
4940 *
4941 * RETURNS:
4942 * Bitmask of active qcs
4943 */
4944u64 ata_qc_get_active(struct ata_port *ap)
4945{
4946 u64 qc_active = ap->qc_active;
4947
4948 /* ATA_TAG_INTERNAL is sent to hw as tag 0 */
4949 if (qc_active & (1ULL << ATA_TAG_INTERNAL)) {
4950 qc_active |= (1 << 0);
4951 qc_active &= ~(1ULL << ATA_TAG_INTERNAL);
4952 }
4953
4954 return qc_active;
4955}
4956EXPORT_SYMBOL_GPL(ata_qc_get_active);
4957
1da177e4
LT		 4958/**
4959 * ata_qc_issue - issue taskfile to device
4960 * @qc: command to issue to device
4961 *
4962 * Prepare an ATA command to submission to device.
4963 * This includes mapping the data into a DMA-able
4964 * area, filling in the S/G table, and finally
4965 * writing the taskfile to hardware, starting the command.
4966 *
4967 * LOCKING:
cca3974e 4968 * spin_lock_irqsave(host lock)
1da177e4 4969 */
8e0e694a 4970void ata_qc_issue(struct ata_queued_cmd *qc)
1da177e4
LT		 4971{
4972 struct ata_port *ap = qc->ap;
9af5c9c9 4973 struct ata_link *link = qc->dev->link;
405e66b3 4974 u8 prot = qc->tf.protocol;
1da177e4 4975
ff8072d5
HR		 4976 /* Make sure only one non-NCQ command is outstanding. */
4977 WARN_ON_ONCE(ata_tag_valid(link->active_tag));
dedaf2b0 4978
1973a023 4979 if (ata_is_ncq(prot)) {
4e5b6260 4980 WARN_ON_ONCE(link->sactive & (1 << qc->hw_tag));
da917d69
TH		 4981
4982 if (!link->sactive)
4983 ap->nr_active_links++;
4e5b6260 4984 link->sactive |= 1 << qc->hw_tag;
dedaf2b0 4985 } else {
efcb3cf7 4986 WARN_ON_ONCE(link->sactive);
da917d69
TH		 4987
4988 ap->nr_active_links++;
9af5c9c9 4989 link->active_tag = qc->tag;
dedaf2b0
TH		 4990 }
4991
e4a70e76 4992 qc->flags |= ATA_QCFLAG_ACTIVE;
e3ed8939 4993 ap->qc_active |= 1ULL << qc->tag;
e4a70e76 4994
60f5d6ef
TH		 4995 /*
4996 * We guarantee to LLDs that they will have at least one
f92a2636
TH		 4997 * non-zero sg if the command is a data command.
4998 */
9173e5e8 4999 if (ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes))
60f5d6ef 5000 goto sys_err;
f92a2636 5001
405e66b3 5002 if (ata_is_dma(prot) || (ata_is_pio(prot) &&
f92a2636 5003 (ap->flags & ATA_FLAG_PIO_DMA)))
001102d7 5004 if (ata_sg_setup(qc))
60f5d6ef 5005 goto sys_err;
1da177e4 5006
cf480626 5007 /* if device is sleeping, schedule reset and abort the link */
054a5fba 5008 if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
cf480626 5009 link->eh_info.action |= ATA_EH_RESET;
054a5fba
TH		 5010 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5011 ata_link_abort(link);
5012 return;
5013 }
5014
fc914faa 5015 trace_ata_qc_prep(qc);
95364f36
JS		 5016 qc->err_mask |= ap->ops->qc_prep(qc);
5017 if (unlikely(qc->err_mask))
5018 goto err;
255c03d1 5019 trace_ata_qc_issue(qc);
8e0e694a
TH		 5020 qc->err_mask |= ap->ops->qc_issue(qc);
5021 if (unlikely(qc->err_mask))
5022 goto err;
5023 return;
1da177e4 5024
60f5d6ef 5025sys_err:
8e0e694a
TH		 5026 qc->err_mask |= AC_ERR_SYSTEM;
5027err:
5028 ata_qc_complete(qc);
1da177e4
LT		 5029}
5030
34bf2170 5031/**
b1c72916 5032 * ata_phys_link_online - test whether the given link is online
936fd732 5033 * @link: ATA link to test
34bf2170 5034 *
936fd732
TH		 5035 * Test whether @link is online. Note that this function returns
5036 * 0 if online status of @link cannot be obtained, so
5037 * ata_link_online(link) != !ata_link_offline(link).
34bf2170
TH		 5038 *
5039 * LOCKING:
5040 * None.
5041 *
5042 * RETURNS:
b5b3fa38 5043 * True if the port online status is available and online.
34bf2170 5044 */
b1c72916 5045bool ata_phys_link_online(struct ata_link *link)
34bf2170
TH		 5046{
5047 u32 sstatus;
5048
936fd732 5049 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
9913ff8a 5050 ata_sstatus_online(sstatus))
b5b3fa38
TH		 5051 return true;
5052 return false;
34bf2170
TH		 5053}
5054
5055/**
b1c72916 5056 * ata_phys_link_offline - test whether the given link is offline
936fd732 5057 * @link: ATA link to test
34bf2170 5058 *
936fd732
TH		 5059 * Test whether @link is offline. Note that this function
5060 * returns 0 if offline status of @link cannot be obtained, so
5061 * ata_link_online(link) != !ata_link_offline(link).
34bf2170
TH		 5062 *
5063 * LOCKING:
5064 * None.
5065 *
5066 * RETURNS:
b5b3fa38 5067 * True if the port offline status is available and offline.
34bf2170 5068 */
b1c72916 5069bool ata_phys_link_offline(struct ata_link *link)
34bf2170
TH		 5070{
5071 u32 sstatus;
5072
936fd732 5073 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
9913ff8a 5074 !ata_sstatus_online(sstatus))
b5b3fa38
TH		 5075 return true;
5076 return false;
34bf2170 5077}
0baab86b 5078
b1c72916
TH		 5079/**
5080 * ata_link_online - test whether the given link is online
5081 * @link: ATA link to test
5082 *
5083 * Test whether @link is online. This is identical to
5084 * ata_phys_link_online() when there's no slave link. When
5085 * there's a slave link, this function should only be called on
5086 * the master link and will return true if any of M/S links is
5087 * online.
5088 *
5089 * LOCKING:
5090 * None.
5091 *
5092 * RETURNS:
5093 * True if the port online status is available and online.
5094 */
5095bool ata_link_online(struct ata_link *link)
5096{
5097 struct ata_link *slave = link->ap->slave_link;
5098
5099 WARN_ON(link == slave); /* shouldn't be called on slave link */
5100
5101 return ata_phys_link_online(link) ||
5102 (slave && ata_phys_link_online(slave));
5103}
a52fbcfc 5104EXPORT_SYMBOL_GPL(ata_link_online);
b1c72916
TH		 5105
5106/**
5107 * ata_link_offline - test whether the given link is offline
5108 * @link: ATA link to test
5109 *
5110 * Test whether @link is offline. This is identical to
5111 * ata_phys_link_offline() when there's no slave link. When
5112 * there's a slave link, this function should only be called on
5113 * the master link and will return true if both M/S links are
5114 * offline.
5115 *
5116 * LOCKING:
5117 * None.
5118 *
5119 * RETURNS:
5120 * True if the port offline status is available and offline.
5121 */
5122bool ata_link_offline(struct ata_link *link)
5123{
5124 struct ata_link *slave = link->ap->slave_link;
5125
5126 WARN_ON(link == slave); /* shouldn't be called on slave link */
5127
5128 return ata_phys_link_offline(link) &&
5129 (!slave || ata_phys_link_offline(slave));
5130}
a52fbcfc 5131EXPORT_SYMBOL_GPL(ata_link_offline);
b1c72916 5132
6ffa01d8 5133#ifdef CONFIG_PM
bc6e7c4b
DW		 5134static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
5135 unsigned int action, unsigned int ehi_flags,
5136 bool async)
500530f6 5137{
5ef41082 5138 struct ata_link *link;
500530f6 5139 unsigned long flags;
500530f6 5140
3b8e0af4
DLM		 5141 spin_lock_irqsave(ap->lock, flags);
5142
5143 /*
5144 * A previous PM operation might still be in progress. Wait for
5145 * ATA_PFLAG_PM_PENDING to clear.
5ef41082
LM		 5146 */
5147 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
3b8e0af4 5148 spin_unlock_irqrestore(ap->lock, flags);
5ef41082 5149 ata_port_wait_eh(ap);
3b8e0af4 5150 spin_lock_irqsave(ap->lock, flags);
5ef41082 5151 }
500530f6 5152
3b8e0af4 5153 /* Request PM operation to EH */
5ef41082 5154 ap->pm_mesg = mesg;
5ef41082
LM		 5155 ap->pflags |= ATA_PFLAG_PM_PENDING;
5156 ata_for_each_link(link, ap, HOST_FIRST) {
5157 link->eh_info.action |= action;
5158 link->eh_info.flags |= ehi_flags;
5159 }
500530f6 5160
5ef41082 5161 ata_port_schedule_eh(ap);
500530f6 5162
5ef41082 5163 spin_unlock_irqrestore(ap->lock, flags);
500530f6 5164
3b8e0af4 5165 if (!async)
5ef41082 5166 ata_port_wait_eh(ap);
500530f6
TH		 5167}
5168
6702255d
DLM		 5169static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg,
5170 bool async)
5ef41082 5171{
8b4d9469
DLM		 5172 /*
5173 * We are about to suspend the port, so we do not care about
5174 * scsi_rescan_device() calls scheduled by previous resume operations.
5175 * The next resume will schedule the rescan again. So cancel any rescan
5176 * that is not done yet.
5177 */
5178 cancel_delayed_work_sync(&ap->scsi_rescan_task);
5179
8b4d9469 5180 /*
6702255d
DLM		 5181 * On some hardware, device fails to respond after spun down for
5182 * suspend. As the device will not be used until being resumed, we
5183 * do not need to touch the device. Ask EH to skip the usual stuff
5184 * and proceed directly to suspend.
5185 *
5186 * http://thread.gmane.org/gmane.linux.ide/46764
8b4d9469 5187 */
6702255d
DLM		 5188 ata_port_request_pm(ap, mesg, 0,
5189 ATA_EHI_QUIET | ATA_EHI_NO_AUTOPSY |
5190 ATA_EHI_NO_RECOVERY,
5191 async);
2fcbdcb4
DW		 5192}
5193
bc6e7c4b 5194static int ata_port_pm_suspend(struct device *dev)
5ef41082 5195{
bc6e7c4b
DW		 5196 struct ata_port *ap = to_ata_port(dev);
5197
5ef41082
LM		 5198 if (pm_runtime_suspended(dev))
5199 return 0;
5200
6702255d 5201 ata_port_suspend(ap, PMSG_SUSPEND, false);
bc6e7c4b 5202 return 0;
33574d68
LM		 5203}
5204
bc6e7c4b 5205static int ata_port_pm_freeze(struct device *dev)
33574d68 5206{
bc6e7c4b
DW		 5207 struct ata_port *ap = to_ata_port(dev);
5208
33574d68 5209 if (pm_runtime_suspended(dev))
f5e6d0d0 5210 return 0;
33574d68 5211
6702255d 5212 ata_port_suspend(ap, PMSG_FREEZE, false);
bc6e7c4b 5213 return 0;
33574d68
LM		 5214}
5215
bc6e7c4b 5216static int ata_port_pm_poweroff(struct device *dev)
33574d68 5217{
3a94af24
DLM		 5218 if (!pm_runtime_suspended(dev))
5219 ata_port_suspend(to_ata_port(dev), PMSG_HIBERNATE, false);
bc6e7c4b 5220 return 0;
5ef41082
LM		 5221}
5222
09b055cf
DLM		 5223static void ata_port_resume(struct ata_port *ap, pm_message_t mesg,
5224 bool async)
bc6e7c4b 5225{
09b055cf
DLM		 5226 ata_port_request_pm(ap, mesg, ATA_EH_RESET,
5227 ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
5228 async);
2fcbdcb4
DW		 5229}
5230
bc6e7c4b 5231static int ata_port_pm_resume(struct device *dev)
e90b1e5a 5232{
09b055cf 5233 ata_port_resume(to_ata_port(dev), PMSG_RESUME, true);
bc6e7c4b
DW		 5234 pm_runtime_disable(dev);
5235 pm_runtime_set_active(dev);
5236 pm_runtime_enable(dev);
5237 return 0;
e90b1e5a
LM		 5238}
5239
7e15e9be
AL		 5240/*
5241 * For ODDs, the upper layer will poll for media change every few seconds,
5242 * which will make it enter and leave suspend state every few seconds. And
5243 * as each suspend will cause a hard/soft reset, the gain of runtime suspend
5244 * is very little and the ODD may malfunction after constantly being reset.
5245 * So the idle callback here will not proceed to suspend if a non-ZPODD capable
5246 * ODD is attached to the port.
5247 */
9ee4f393
LM		 5248static int ata_port_runtime_idle(struct device *dev)
5249{
7e15e9be
AL		 5250 struct ata_port *ap = to_ata_port(dev);
5251 struct ata_link *link;
5252 struct ata_device *adev;
5253
5254 ata_for_each_link(link, ap, HOST_FIRST) {
5255 ata_for_each_dev(adev, link, ENABLED)
5256 if (adev->class == ATA_DEV_ATAPI &&
5257 !zpodd_dev_enabled(adev))
5258 return -EBUSY;
5259 }
5260
45f0a85c 5261 return 0;
9ee4f393
LM		 5262}
5263
a7ff60db
AL		 5264static int ata_port_runtime_suspend(struct device *dev)
5265{
6702255d 5266 ata_port_suspend(to_ata_port(dev), PMSG_AUTO_SUSPEND, false);
bc6e7c4b 5267 return 0;
a7ff60db
AL		 5268}
5269
5270static int ata_port_runtime_resume(struct device *dev)
5271{
09b055cf 5272 ata_port_resume(to_ata_port(dev), PMSG_AUTO_RESUME, false);
bc6e7c4b 5273 return 0;
a7ff60db
AL		 5274}
5275
5ef41082 5276static const struct dev_pm_ops ata_port_pm_ops = {
bc6e7c4b
DW		 5277 .suspend = ata_port_pm_suspend,
5278 .resume = ata_port_pm_resume,
5279 .freeze = ata_port_pm_freeze,
5280 .thaw = ata_port_pm_resume,
5281 .poweroff = ata_port_pm_poweroff,
5282 .restore = ata_port_pm_resume,
9ee4f393 5283
a7ff60db
AL		 5284 .runtime_suspend = ata_port_runtime_suspend,
5285 .runtime_resume = ata_port_runtime_resume,
9ee4f393 5286 .runtime_idle = ata_port_runtime_idle,
5ef41082
LM		 5287};
5288
2fcbdcb4
DW		 5289/* sas ports don't participate in pm runtime management of ata_ports,
5290 * and need to resume ata devices at the domain level, not the per-port
5291 * level. sas suspend/resume is async to allow parallel port recovery
5292 * since sas has multiple ata_port instances per Scsi_Host.
5293 */
bc6e7c4b 5294void ata_sas_port_suspend(struct ata_port *ap)
2fcbdcb4 5295{
6702255d 5296 ata_port_suspend(ap, PMSG_SUSPEND, true);
2fcbdcb4 5297}
bc6e7c4b 5298EXPORT_SYMBOL_GPL(ata_sas_port_suspend);
2fcbdcb4 5299
bc6e7c4b 5300void ata_sas_port_resume(struct ata_port *ap)
2fcbdcb4 5301{
09b055cf 5302 ata_port_resume(ap, PMSG_RESUME, true);
2fcbdcb4 5303}
bc6e7c4b 5304EXPORT_SYMBOL_GPL(ata_sas_port_resume);
2fcbdcb4 5305
500530f6 5306/**
cca3974e
JG		 5307 * ata_host_suspend - suspend host
5308 * @host: host to suspend
500530f6
TH		 5309 * @mesg: PM message
5310 *
5ef41082 5311 * Suspend @host. Actual operation is performed by port suspend.
500530f6 5312 */
ec87cf37 5313void ata_host_suspend(struct ata_host *host, pm_message_t mesg)
500530f6 5314{
5ef41082 5315 host->dev->power.power_state = mesg;
500530f6 5316}
a52fbcfc 5317EXPORT_SYMBOL_GPL(ata_host_suspend);
500530f6
TH		 5318
5319/**
cca3974e
JG		 5320 * ata_host_resume - resume host
5321 * @host: host to resume
500530f6 5322 *
5ef41082 5323 * Resume @host. Actual operation is performed by port resume.
500530f6 5324 */
cca3974e 5325void ata_host_resume(struct ata_host *host)
500530f6 5326{
72ad6ec4 5327 host->dev->power.power_state = PMSG_ON;
500530f6 5328}
a52fbcfc 5329EXPORT_SYMBOL_GPL(ata_host_resume);
6ffa01d8 5330#endif
500530f6 5331
8df82c13 5332const struct device_type ata_port_type = {
75e2bd5f 5333 .name = ATA_PORT_TYPE_NAME,
5ef41082
LM		 5334#ifdef CONFIG_PM
5335 .pm = &ata_port_pm_ops,
5336#endif
5337};
5338
3ef3b43d
TH		 5339/**
5340 * ata_dev_init - Initialize an ata_device structure
5341 * @dev: Device structure to initialize
5342 *
5343 * Initialize @dev in preparation for probing.
5344 *
5345 * LOCKING:
5346 * Inherited from caller.
5347 */
5348void ata_dev_init(struct ata_device *dev)
5349{
b1c72916 5350 struct ata_link *link = ata_dev_phys_link(dev);
9af5c9c9 5351 struct ata_port *ap = link->ap;
72fa4b74
TH		 5352 unsigned long flags;
5353
b1c72916 5354 /* SATA spd limit is bound to the attached device, reset together */
9af5c9c9
TH		 5355 link->sata_spd_limit = link->hw_sata_spd_limit;
5356 link->sata_spd = 0;
5a04bf4b 5357
72fa4b74
TH		 5358 /* High bits of dev->flags are used to record warm plug
5359 * requests which occur asynchronously. Synchronize using
cca3974e 5360 * host lock.
72fa4b74 5361 */
ba6a1308 5362 spin_lock_irqsave(ap->lock, flags);
72fa4b74 5363 dev->flags &= ~ATA_DFLAG_INIT_MASK;
3dcc323f 5364 dev->horkage = 0;
ba6a1308 5365 spin_unlock_irqrestore(ap->lock, flags);
3ef3b43d 5366
99cf610a
TH		 5367 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
5368 ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
3ef3b43d
TH		 5369 dev->pio_mask = UINT_MAX;
5370 dev->mwdma_mask = UINT_MAX;
5371 dev->udma_mask = UINT_MAX;
5372}
5373
4fb37a25
TH		 5374/**
5375 * ata_link_init - Initialize an ata_link structure
5376 * @ap: ATA port link is attached to
5377 * @link: Link structure to initialize
8989805d 5378 * @pmp: Port multiplier port number
4fb37a25
TH		 5379 *
5380 * Initialize @link.
5381 *
5382 * LOCKING:
5383 * Kernel thread context (may sleep)
5384 */
fb7fd614 5385void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
4fb37a25
TH		 5386{
5387 int i;
5388
5389 /* clear everything except for devices */
d9027470
GG		 5390 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5391 ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
4fb37a25
TH		 5392
5393 link->ap = ap;
8989805d 5394 link->pmp = pmp;
4fb37a25
TH		 5395 link->active_tag = ATA_TAG_POISON;
5396 link->hw_sata_spd_limit = UINT_MAX;
5397
5398 /* can't use iterator, ap isn't initialized yet */
5399 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5400 struct ata_device *dev = &link->device[i];
5401
5402 dev->link = link;
5403 dev->devno = dev - link->device;
110f66d2
TH		 5404#ifdef CONFIG_ATA_ACPI
5405 dev->gtf_filter = ata_acpi_gtf_filter;
5406#endif
4fb37a25
TH		 5407 ata_dev_init(dev);
5408 }
5409}
5410
5411/**
5412 * sata_link_init_spd - Initialize link->sata_spd_limit
5413 * @link: Link to configure sata_spd_limit for
5414 *
a31a6997 5415 * Initialize ``link->[hw_]sata_spd_limit`` to the currently
4fb37a25
TH		 5416 * configured value.
5417 *
5418 * LOCKING:
5419 * Kernel thread context (may sleep).
5420 *
5421 * RETURNS:
5422 * 0 on success, -errno on failure.
5423 */
fb7fd614 5424int sata_link_init_spd(struct ata_link *link)
4fb37a25 5425{
33267325 5426 u8 spd;
4fb37a25
TH		 5427 int rc;
5428
d127ea7b 5429 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
4fb37a25
TH		 5430 if (rc)
5431 return rc;
5432
d127ea7b 5433 spd = (link->saved_scontrol >> 4) & 0xf;
4fb37a25
TH		 5434 if (spd)
5435 link->hw_sata_spd_limit &= (1 << spd) - 1;
5436
05944bdf 5437 ata_force_link_limits(link);
33267325 5438
4fb37a25
TH		 5439 link->sata_spd_limit = link->hw_sata_spd_limit;
5440
5441 return 0;
5442}
5443
1da177e4 5444/**
f3187195
TH		 5445 * ata_port_alloc - allocate and initialize basic ATA port resources
5446 * @host: ATA host this allocated port belongs to
1da177e4 5447 *
f3187195
TH		 5448 * Allocate and initialize basic ATA port resources.
5449 *
5450 * RETURNS:
5451 * Allocate ATA port on success, NULL on failure.
0cba632b 5452 *
1da177e4 5453 * LOCKING:
f3187195 5454 * Inherited from calling layer (may sleep).
1da177e4 5455 */
f3187195 5456struct ata_port *ata_port_alloc(struct ata_host *host)
1da177e4 5457{
f3187195 5458 struct ata_port *ap;
1da177e4 5459
f3187195
TH		 5460 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5461 if (!ap)
5462 return NULL;
4fca377f 5463
7b3a24c5 5464 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
cca3974e 5465 ap->lock = &host->lock;
f3187195 5466 ap->print_id = -1;
e628dc99 5467 ap->local_port_no = -1;
cca3974e 5468 ap->host = host;
f3187195 5469 ap->dev = host->dev;
bd5d825c 5470
ad72cf98 5471 mutex_init(&ap->scsi_scan_mutex);
65f27f38 5472 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
6aa0365a 5473 INIT_DELAYED_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
a72ec4ce 5474 INIT_LIST_HEAD(&ap->eh_done_q);
c6cf9e99 5475 init_waitqueue_head(&ap->eh_wait_q);
45fabbb7 5476 init_completion(&ap->park_req_pending);
b93ab338
KC		 5477 timer_setup(&ap->fastdrain_timer, ata_eh_fastdrain_timerfn,
5478 TIMER_DEFERRABLE);
1da177e4 5479
838df628 5480 ap->cbl = ATA_CBL_NONE;
838df628 5481
8989805d 5482 ata_link_init(ap, &ap->link, 0);
1da177e4
LT		 5483
5484#ifdef ATA_IRQ_TRAP
5485 ap->stats.unhandled_irq = 1;
5486 ap->stats.idle_irq = 1;
5487#endif
270390e1
TH		 5488 ata_sff_port_init(ap);
5489
1da177e4 5490 return ap;
1da177e4
LT		 5491}
5492
2623c7a5 5493static void ata_devres_release(struct device *gendev, void *res)
f0d36efd
TH		 5494{
5495 struct ata_host *host = dev_get_drvdata(gendev);
5496 int i;
5497
1aa506e4
TH		 5498 for (i = 0; i < host->n_ports; i++) {
5499 struct ata_port *ap = host->ports[i];
5500
4911487a
TH		 5501 if (!ap)
5502 continue;
5503
5504 if (ap->scsi_host)
1aa506e4
TH		 5505 scsi_host_put(ap->scsi_host);
5506
2623c7a5
TK		 5507 }
5508
5509 dev_set_drvdata(gendev, NULL);
5510 ata_host_put(host);
5511}
5512
5513static void ata_host_release(struct kref *kref)
5514{
5515 struct ata_host *host = container_of(kref, struct ata_host, kref);
5516 int i;
5517
5518 for (i = 0; i < host->n_ports; i++) {
5519 struct ata_port *ap = host->ports[i];
5520
633273a3 5521 kfree(ap->pmp_link);
b1c72916 5522 kfree(ap->slave_link);
18bd7718 5523 kfree(ap->ncq_sense_buf);
4911487a 5524 kfree(ap);
1aa506e4
TH		 5525 host->ports[i] = NULL;
5526 }
2623c7a5
TK		 5527 kfree(host);
5528}
1aa506e4 5529
2623c7a5
TK		 5530void ata_host_get(struct ata_host *host)
5531{
5532 kref_get(&host->kref);
5533}
5534
5535void ata_host_put(struct ata_host *host)
5536{
5537 kref_put(&host->kref, ata_host_release);
f0d36efd 5538}
a52fbcfc 5539EXPORT_SYMBOL_GPL(ata_host_put);
f0d36efd 5540
f3187195
TH		 5541/**
5542 * ata_host_alloc - allocate and init basic ATA host resources
5543 * @dev: generic device this host is associated with
5544 * @max_ports: maximum number of ATA ports associated with this host
5545 *
5546 * Allocate and initialize basic ATA host resources. LLD calls
5547 * this function to allocate a host, initializes it fully and
5548 * attaches it using ata_host_register().
5549 *
5550 * @max_ports ports are allocated and host->n_ports is
5551 * initialized to @max_ports. The caller is allowed to decrease
5552 * host->n_ports before calling ata_host_register(). The unused
5553 * ports will be automatically freed on registration.
5554 *
5555 * RETURNS:
5556 * Allocate ATA host on success, NULL on failure.
5557 *
5558 * LOCKING:
5559 * Inherited from calling layer (may sleep).
5560 */
5561struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
5562{
5563 struct ata_host *host;
5564 size_t sz;
5565 int i;
2623c7a5 5566 void *dr;
f3187195 5567
f3187195
TH		 5568 /* alloc a container for our list of ATA ports (buses) */
5569 sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
2623c7a5 5570 host = kzalloc(sz, GFP_KERNEL);
f3187195 5571 if (!host)
2623c7a5
TK		 5572 return NULL;
5573
5574 if (!devres_open_group(dev, NULL, GFP_KERNEL))
dafd6c49 5575 goto err_free;
2623c7a5
TK		 5576
5577 dr = devres_alloc(ata_devres_release, 0, GFP_KERNEL);
5578 if (!dr)
f3187195
TH		 5579 goto err_out;
5580
2623c7a5 5581 devres_add(dev, dr);
f3187195
TH		 5582 dev_set_drvdata(dev, host);
5583
5584 spin_lock_init(&host->lock);
c0c362b6 5585 mutex_init(&host->eh_mutex);
f3187195
TH		 5586 host->dev = dev;
5587 host->n_ports = max_ports;
2623c7a5 5588 kref_init(&host->kref);
f3187195
TH		 5589
5590 /* allocate ports bound to this host */
5591 for (i = 0; i < max_ports; i++) {
5592 struct ata_port *ap;
5593
5594 ap = ata_port_alloc(host);
5595 if (!ap)
5596 goto err_out;
5597
5598 ap->port_no = i;
5599 host->ports[i] = ap;
5600 }
5601
5602 devres_remove_group(dev, NULL);
5603 return host;
5604
5605 err_out:
5606 devres_release_group(dev, NULL);
dafd6c49
CIK		 5607 err_free:
5608 kfree(host);
f3187195
TH		 5609 return NULL;
5610}
a52fbcfc 5611EXPORT_SYMBOL_GPL(ata_host_alloc);
f3187195 5612
f5cda257
TH		 5613/**
5614 * ata_host_alloc_pinfo - alloc host and init with port_info array
5615 * @dev: generic device this host is associated with
5616 * @ppi: array of ATA port_info to initialize host with
5617 * @n_ports: number of ATA ports attached to this host
5618 *
5619 * Allocate ATA host and initialize with info from @ppi. If NULL
5620 * terminated, @ppi may contain fewer entries than @n_ports. The
5621 * last entry will be used for the remaining ports.
5622 *
5623 * RETURNS:
5624 * Allocate ATA host on success, NULL on failure.
5625 *
5626 * LOCKING:
5627 * Inherited from calling layer (may sleep).
5628 */
5629struct ata_host *ata_host_alloc_pinfo(struct device *dev,
5630 const struct ata_port_info * const * ppi,
5631 int n_ports)
5632{
bf476fe2 5633 const struct ata_port_info *pi = &ata_dummy_port_info;
f5cda257
TH		 5634 struct ata_host *host;
5635 int i, j;
5636
5637 host = ata_host_alloc(dev, n_ports);
5638 if (!host)
5639 return NULL;
5640
bf476fe2 5641 for (i = 0, j = 0; i < host->n_ports; i++) {
f5cda257
TH		 5642 struct ata_port *ap = host->ports[i];
5643
5644 if (ppi[j])
5645 pi = ppi[j++];
5646
5647 ap->pio_mask = pi->pio_mask;
5648 ap->mwdma_mask = pi->mwdma_mask;
5649 ap->udma_mask = pi->udma_mask;
5650 ap->flags |= pi->flags;
0c88758b 5651 ap->link.flags |= pi->link_flags;
f5cda257
TH		 5652 ap->ops = pi->port_ops;
5653
5654 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
5655 host->ops = pi->port_ops;
f5cda257
TH		 5656 }
5657
5658 return host;
5659}
a52fbcfc 5660EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
f5cda257 5661
32ebbc0c
TH		 5662static void ata_host_stop(struct device *gendev, void *res)
5663{
5664 struct ata_host *host = dev_get_drvdata(gendev);
5665 int i;
5666
5667 WARN_ON(!(host->flags & ATA_HOST_STARTED));
5668
5669 for (i = 0; i < host->n_ports; i++) {
5670 struct ata_port *ap = host->ports[i];
5671
5672 if (ap->ops->port_stop)
5673 ap->ops->port_stop(ap);
5674 }
5675
5676 if (host->ops->host_stop)
5677 host->ops->host_stop(host);
5678}
5679
029cfd6b
TH		 5680/**
5681 * ata_finalize_port_ops - finalize ata_port_operations
5682 * @ops: ata_port_operations to finalize
5683 *
5684 * An ata_port_operations can inherit from another ops and that
5685 * ops can again inherit from another. This can go on as many
5686 * times as necessary as long as there is no loop in the
5687 * inheritance chain.
5688 *
5689 * Ops tables are finalized when the host is started. NULL or
5690 * unspecified entries are inherited from the closet ancestor
5691 * which has the method and the entry is populated with it.
5692 * After finalization, the ops table directly points to all the
5693 * methods and ->inherits is no longer necessary and cleared.
5694 *
5695 * Using ATA_OP_NULL, inheriting ops can force a method to NULL.
5696 *
5697 * LOCKING:
5698 * None.
5699 */
5700static void ata_finalize_port_ops(struct ata_port_operations *ops)
5701{
2da67659 5702 static DEFINE_SPINLOCK(lock);
029cfd6b
TH		 5703 const struct ata_port_operations *cur;
5704 void **begin = (void **)ops;
5705 void **end = (void **)&ops->inherits;
5706 void **pp;
5707
5708 if (!ops || !ops->inherits)
5709 return;
5710
5711 spin_lock(&lock);
5712
5713 for (cur = ops->inherits; cur; cur = cur->inherits) {
5714 void **inherit = (void **)cur;
5715
5716 for (pp = begin; pp < end; pp++, inherit++)
5717 if (!*pp)
5718 *pp = *inherit;
5719 }
5720
5721 for (pp = begin; pp < end; pp++)
5722 if (IS_ERR(*pp))
5723 *pp = NULL;
5724
5725 ops->inherits = NULL;
5726
5727 spin_unlock(&lock);
5728}
5729
ecef7253
TH		 5730/**
5731 * ata_host_start - start and freeze ports of an ATA host
5732 * @host: ATA host to start ports for
5733 *
5734 * Start and then freeze ports of @host. Started status is
5735 * recorded in host->flags, so this function can be called
5736 * multiple times. Ports are guaranteed to get started only
e0af10ac 5737 * once. If host->ops is not initialized yet, it is set to the
f3187195 5738 * first non-dummy port ops.
ecef7253
TH		 5739 *
5740 * LOCKING:
5741 * Inherited from calling layer (may sleep).
5742 *
5743 * RETURNS:
5744 * 0 if all ports are started successfully, -errno otherwise.
5745 */
5746int ata_host_start(struct ata_host *host)
5747{
32ebbc0c
TH		 5748 int have_stop = 0;
5749 void *start_dr = NULL;
ecef7253
TH		 5750 int i, rc;
5751
5752 if (host->flags & ATA_HOST_STARTED)
5753 return 0;
5754
029cfd6b
TH		 5755 ata_finalize_port_ops(host->ops);
5756
ecef7253
TH		 5757 for (i = 0; i < host->n_ports; i++) {
5758 struct ata_port *ap = host->ports[i];
5759
029cfd6b
TH		 5760 ata_finalize_port_ops(ap->ops);
5761
f3187195
TH		 5762 if (!host->ops && !ata_port_is_dummy(ap))
5763 host->ops = ap->ops;
5764
32ebbc0c
TH		 5765 if (ap->ops->port_stop)
5766 have_stop = 1;
5767 }
5768
355a8031 5769 if (host->ops && host->ops->host_stop)
32ebbc0c
TH		 5770 have_stop = 1;
5771
5772 if (have_stop) {
5773 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
5774 if (!start_dr)
5775 return -ENOMEM;
5776 }
5777
5778 for (i = 0; i < host->n_ports; i++) {
5779 struct ata_port *ap = host->ports[i];
5780
ecef7253
TH		 5781 if (ap->ops->port_start) {
5782 rc = ap->ops->port_start(ap);
5783 if (rc) {
0f9fe9b7 5784 if (rc != -ENODEV)
a44fec1f
JP		 5785 dev_err(host->dev,
5786 "failed to start port %d (errno=%d)\n",
5787 i, rc);
ecef7253
TH		 5788 goto err_out;
5789 }
5790 }
ecef7253
TH		 5791 ata_eh_freeze_port(ap);
5792 }
5793
32ebbc0c
TH		 5794 if (start_dr)
5795 devres_add(host->dev, start_dr);
ecef7253
TH		 5796 host->flags |= ATA_HOST_STARTED;
5797 return 0;
5798
5799 err_out:
5800 while (--i >= 0) {
5801 struct ata_port *ap = host->ports[i];
5802
5803 if (ap->ops->port_stop)
5804 ap->ops->port_stop(ap);
5805 }
32ebbc0c 5806 devres_free(start_dr);
ecef7253
TH		 5807 return rc;
5808}
a52fbcfc 5809EXPORT_SYMBOL_GPL(ata_host_start);
ecef7253 5810
b03732f0 5811/**
94bd5719 5812 * ata_host_init - Initialize a host struct for sas (ipr, libsas)
cca3974e
JG		 5813 * @host: host to initialize
5814 * @dev: device host is attached to
cca3974e 5815 * @ops: port_ops
b03732f0 5816 *
b03732f0 5817 */
cca3974e 5818void ata_host_init(struct ata_host *host, struct device *dev,
8d8e7d13 5819 struct ata_port_operations *ops)
b03732f0 5820{
cca3974e 5821 spin_lock_init(&host->lock);
c0c362b6 5822 mutex_init(&host->eh_mutex);
69278f79 5823 host->n_tags = ATA_MAX_QUEUE;
cca3974e 5824 host->dev = dev;
cca3974e 5825 host->ops = ops;
2fa4a326 5826 kref_init(&host->kref);
b03732f0 5827}
a52fbcfc 5828EXPORT_SYMBOL_GPL(ata_host_init);
b03732f0 5829
a76f1b63 5830void ata_port_probe(struct ata_port *ap)
79318057 5831{
9508a66f
DW		 5832 struct ata_eh_info *ehi = &ap->link.eh_info;
5833 unsigned long flags;
886ad09f 5834
9508a66f
DW		 5835 /* kick EH for boot probing */
5836 spin_lock_irqsave(ap->lock, flags);
79318057 5837
9508a66f
DW		 5838 ehi->probe_mask |= ATA_ALL_DEVICES;
5839 ehi->action |= ATA_EH_RESET;
5840 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
79318057 5841
9508a66f
DW		 5842 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
5843 ap->pflags |= ATA_PFLAG_LOADING;
5844 ata_port_schedule_eh(ap);
79318057 5845
9508a66f
DW		 5846 spin_unlock_irqrestore(ap->lock, flags);
5847}
a76f1b63 5848EXPORT_SYMBOL_GPL(ata_port_probe);
79318057 5849
238c9cf9
JB		 5850static void async_port_probe(void *data, async_cookie_t cookie)
5851{
5852 struct ata_port *ap = data;
4fca377f 5853
238c9cf9
JB		 5854 /*
5855 * If we're not allowed to scan this host in parallel,
5856 * we need to wait until all previous scans have completed
5857 * before going further.
5858 * Jeff Garzik says this is only within a controller, so we
5859 * don't need to wait for port 0, only for later ports.
5860 */
5861 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
5862 async_synchronize_cookie(cookie);
5863
a76f1b63 5864 ata_port_probe(ap);
77461a3f 5865 ata_port_wait_eh(ap);
f29d3b23
AV		 5866
5867 /* in order to keep device order, we need to synchronize at this point */
5868 async_synchronize_cookie(cookie);
5869
5870 ata_scsi_scan_host(ap, 1);
79318057 5871}
238c9cf9 5872
f3187195
TH		 5873/**
5874 * ata_host_register - register initialized ATA host
5875 * @host: ATA host to register
5876 * @sht: template for SCSI host
5877 *
5878 * Register initialized ATA host. @host is allocated using
5879 * ata_host_alloc() and fully initialized by LLD. This function
5880 * starts ports, registers @host with ATA and SCSI layers and
5881 * probe registered devices.
5882 *
5883 * LOCKING:
5884 * Inherited from calling layer (may sleep).
5885 *
5886 * RETURNS:
5887 * 0 on success, -errno otherwise.
5888 */
25df73d9 5889int ata_host_register(struct ata_host *host, const struct scsi_host_template *sht)
f3187195
TH		 5890{
5891 int i, rc;
5892
69278f79 5893 host->n_tags = clamp(sht->can_queue, 1, ATA_MAX_QUEUE);
1871ee13 5894
f3187195
TH		 5895 /* host must have been started */
5896 if (!(host->flags & ATA_HOST_STARTED)) {
a44fec1f 5897 dev_err(host->dev, "BUG: trying to register unstarted host\n");
f3187195
TH		 5898 WARN_ON(1);
5899 return -EINVAL;
5900 }
5901
5902 /* Blow away unused ports. This happens when LLD can't
5903 * determine the exact number of ports to allocate at
5904 * allocation time.
5905 */
5906 for (i = host->n_ports; host->ports[i]; i++)
5907 kfree(host->ports[i]);
5908
5909 /* give ports names and add SCSI hosts */
e628dc99 5910 for (i = 0; i < host->n_ports; i++) {
85d6725b 5911 host->ports[i]->print_id = atomic_inc_return(&ata_print_id);
e628dc99
DM		 5912 host->ports[i]->local_port_no = i + 1;
5913 }
4fca377f 5914
d9027470
GG		 5915 /* Create associated sysfs transport objects */
5916 for (i = 0; i < host->n_ports; i++) {
5917 rc = ata_tport_add(host->dev,host->ports[i]);
5918 if (rc) {
5919 goto err_tadd;
5920 }
5921 }
5922
f3187195
TH		 5923 rc = ata_scsi_add_hosts(host, sht);
5924 if (rc)
d9027470 5925 goto err_tadd;
f3187195
TH		 5926
5927 /* set cable, sata_spd_limit and report */
5928 for (i = 0; i < host->n_ports; i++) {
5929 struct ata_port *ap = host->ports[i];
f0a6d77b 5930 unsigned int xfer_mask;
f3187195
TH		 5931
5932 /* set SATA cable type if still unset */
5933 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
5934 ap->cbl = ATA_CBL_SATA;
5935
5936 /* init sata_spd_limit to the current value */
4fb37a25 5937 sata_link_init_spd(&ap->link);
b1c72916
TH		 5938 if (ap->slave_link)
5939 sata_link_init_spd(ap->slave_link);
f3187195 5940
cbcdd875 5941 /* print per-port info to dmesg */
f3187195
TH		 5942 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
5943 ap->udma_mask);
5944
abf6e8ed 5945 if (!ata_port_is_dummy(ap)) {
a9a79dfe
JP		 5946 ata_port_info(ap, "%cATA max %s %s\n",
5947 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
5948 ata_mode_string(xfer_mask),
5949 ap->link.eh_info.desc);
abf6e8ed
TH		 5950 ata_ehi_clear_desc(&ap->link.eh_info);
5951 } else
a9a79dfe 5952 ata_port_info(ap, "DUMMY\n");
f3187195
TH		 5953 }
5954
f6005354 5955 /* perform each probe asynchronously */
f3187195
TH		 5956 for (i = 0; i < host->n_ports; i++) {
5957 struct ata_port *ap = host->ports[i];
b5292111 5958 ap->cookie = async_schedule(async_port_probe, ap);
f3187195 5959 }
f3187195
TH		 5960
5961 return 0;
d9027470
GG		 5962
5963 err_tadd:
5964 while (--i >= 0) {
5965 ata_tport_delete(host->ports[i]);
5966 }
5967 return rc;
5968
f3187195 5969}
a52fbcfc 5970EXPORT_SYMBOL_GPL(ata_host_register);
f3187195 5971
f5cda257
TH		 5972/**
5973 * ata_host_activate - start host, request IRQ and register it
5974 * @host: target ATA host
5975 * @irq: IRQ to request
5976 * @irq_handler: irq_handler used when requesting IRQ
5977 * @irq_flags: irq_flags used when requesting IRQ
5978 * @sht: scsi_host_template to use when registering the host
5979 *
5980 * After allocating an ATA host and initializing it, most libata
5981 * LLDs perform three steps to activate the host - start host,
c9b5560a 5982 * request IRQ and register it. This helper takes necessary
f5cda257
TH		 5983 * arguments and performs the three steps in one go.
5984 *
3d46b2e2
PM		 5985 * An invalid IRQ skips the IRQ registration and expects the host to
5986 * have set polling mode on the port. In this case, @irq_handler
5987 * should be NULL.
5988 *
f5cda257
TH		 5989 * LOCKING:
5990 * Inherited from calling layer (may sleep).
5991 *
5992 * RETURNS:
5993 * 0 on success, -errno otherwise.
5994 */
5995int ata_host_activate(struct ata_host *host, int irq,
5996 irq_handler_t irq_handler, unsigned long irq_flags,
25df73d9 5997 const struct scsi_host_template *sht)
f5cda257 5998{
cbcdd875 5999 int i, rc;
7e22c002 6000 char *irq_desc;
f5cda257
TH		 6001
6002 rc = ata_host_start(host);
6003 if (rc)
6004 return rc;
6005
3d46b2e2
PM		 6006 /* Special case for polling mode */
6007 if (!irq) {
6008 WARN_ON(irq_handler);
6009 return ata_host_register(host, sht);
6010 }
6011
7e22c002
HK		 6012 irq_desc = devm_kasprintf(host->dev, GFP_KERNEL, "%s[%s]",
6013 dev_driver_string(host->dev),
6014 dev_name(host->dev));
6015 if (!irq_desc)
6016 return -ENOMEM;
6017
f5cda257 6018 rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
7e22c002 6019 irq_desc, host);
f5cda257
TH		 6020 if (rc)
6021 return rc;
6022
cbcdd875 6023 for (i = 0; i < host->n_ports; i++)
affccb16 6024 ata_port_desc_misc(host->ports[i], irq);
4031826b 6025
f5cda257
TH		 6026 rc = ata_host_register(host, sht);
6027 /* if failed, just free the IRQ and leave ports alone */
6028 if (rc)
6029 devm_free_irq(host->dev, irq, host);
6030
6031 return rc;
6032}
a52fbcfc 6033EXPORT_SYMBOL_GPL(ata_host_activate);
f5cda257 6034
720ba126 6035/**
c9b5560a 6036 * ata_port_detach - Detach ATA port in preparation of device removal
720ba126
TH		 6037 * @ap: ATA port to be detached
6038 *
6039 * Detach all ATA devices and the associated SCSI devices of @ap;
6040 * then, remove the associated SCSI host. @ap is guaranteed to
6041 * be quiescent on return from this function.
6042 *
6043 * LOCKING:
6044 * Kernel thread context (may sleep).
6045 */
741b7763 6046static void ata_port_detach(struct ata_port *ap)
720ba126
TH		 6047{
6048 unsigned long flags;
a6f9bf4d
LK		 6049 struct ata_link *link;
6050 struct ata_device *dev;
720ba126 6051
cfead0dd
DLM		 6052 /* Ensure ata_port probe has completed */
6053 async_synchronize_cookie(ap->cookie + 1);
6054
84d76529
DLM		 6055 /* Wait for any ongoing EH */
6056 ata_port_wait_eh(ap);
6057
6058 mutex_lock(&ap->scsi_scan_mutex);
ba6a1308 6059 spin_lock_irqsave(ap->lock, flags);
84d76529
DLM		 6060
6061 /* Remove scsi devices */
6062 ata_for_each_link(link, ap, HOST_FIRST) {
6063 ata_for_each_dev(dev, link, ALL) {
6064 if (dev->sdev) {
6065 spin_unlock_irqrestore(ap->lock, flags);
6066 scsi_remove_device(dev->sdev);
6067 spin_lock_irqsave(ap->lock, flags);
6068 dev->sdev = NULL;
6069 }
6070 }
6071 }
6072
6073 /* Tell EH to disable all devices */
b51e9e5d 6074 ap->pflags |= ATA_PFLAG_UNLOADING;
ece180d1 6075 ata_port_schedule_eh(ap);
84d76529 6076
ba6a1308 6077 spin_unlock_irqrestore(ap->lock, flags);
84d76529 6078 mutex_unlock(&ap->scsi_scan_mutex);
720ba126 6079
ece180d1 6080 /* wait till EH commits suicide */
720ba126
TH		 6081 ata_port_wait_eh(ap);
6082
ece180d1
TH		 6083 /* it better be dead now */
6084 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
720ba126 6085
afe2c511 6086 cancel_delayed_work_sync(&ap->hotplug_task);
6aa0365a 6087 cancel_delayed_work_sync(&ap->scsi_rescan_task);
720ba126 6088
a6f9bf4d
LK		 6089 /* clean up zpodd on port removal */
6090 ata_for_each_link(link, ap, HOST_FIRST) {
6091 ata_for_each_dev(dev, link, ALL) {
6092 if (zpodd_dev_enabled(dev))
6093 zpodd_exit(dev);
6094 }
6095 }
d9027470
GG		 6096 if (ap->pmp_link) {
6097 int i;
6098 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
6099 ata_tlink_delete(&ap->pmp_link[i]);
6100 }
720ba126 6101 /* remove the associated SCSI host */
cca3974e 6102 scsi_remove_host(ap->scsi_host);
c5700766 6103 ata_tport_delete(ap);
720ba126
TH		 6104}
6105
0529c159
TH		 6106/**
6107 * ata_host_detach - Detach all ports of an ATA host
6108 * @host: Host to detach
6109 *
6110 * Detach all ports of @host.
6111 *
6112 * LOCKING:
6113 * Kernel thread context (may sleep).
6114 */
6115void ata_host_detach(struct ata_host *host)
6116{
6117 int i;
6118
cfead0dd 6119 for (i = 0; i < host->n_ports; i++)
0529c159 6120 ata_port_detach(host->ports[i]);
562f0c2d
TH		 6121
6122 /* the host is dead now, dissociate ACPI */
6123 ata_acpi_dissociate(host);
0529c159 6124}
a52fbcfc 6125EXPORT_SYMBOL_GPL(ata_host_detach);
0529c159 6126
374b1873
JG		 6127#ifdef CONFIG_PCI
6128
1da177e4
LT		 6129/**
6130 * ata_pci_remove_one - PCI layer callback for device removal
6131 * @pdev: PCI device that was removed
6132 *
b878ca5d
TH		 6133 * PCI layer indicates to libata via this hook that hot-unplug or
6134 * module unload event has occurred. Detach all ports. Resource
6135 * release is handled via devres.
1da177e4
LT		 6136 *
6137 * LOCKING:
6138 * Inherited from PCI layer (may sleep).
6139 */
f0d36efd 6140void ata_pci_remove_one(struct pci_dev *pdev)
1da177e4 6141{
04a3f5b7 6142 struct ata_host *host = pci_get_drvdata(pdev);
1da177e4 6143
b878ca5d 6144 ata_host_detach(host);
1da177e4 6145}
a52fbcfc 6146EXPORT_SYMBOL_GPL(ata_pci_remove_one);
1da177e4 6147
10a663a1
PK		 6148void ata_pci_shutdown_one(struct pci_dev *pdev)
6149{
6150 struct ata_host *host = pci_get_drvdata(pdev);
5b6fba54
DLM		 6151 struct ata_port *ap;
6152 unsigned long flags;
10a663a1
PK		 6153 int i;
6154
5b6fba54 6155 /* Tell EH to disable all devices */
10a663a1 6156 for (i = 0; i < host->n_ports; i++) {
5b6fba54
DLM		 6157 ap = host->ports[i];
6158 spin_lock_irqsave(ap->lock, flags);
6159 ap->pflags |= ATA_PFLAG_UNLOADING;
6160 ata_port_schedule_eh(ap);
6161 spin_unlock_irqrestore(ap->lock, flags);
6162 }
6163
6164 for (i = 0; i < host->n_ports; i++) {
6165 ap = host->ports[i];
6166
6167 /* Wait for EH to complete before freezing the port */
6168 ata_port_wait_eh(ap);
10a663a1
PK		 6169
6170 ap->pflags |= ATA_PFLAG_FROZEN;
6171
6172 /* Disable port interrupts */
6173 if (ap->ops->freeze)
6174 ap->ops->freeze(ap);
6175
6176 /* Stop the port DMA engines */
6177 if (ap->ops->port_stop)
6178 ap->ops->port_stop(ap);
6179 }
6180}
a52fbcfc 6181EXPORT_SYMBOL_GPL(ata_pci_shutdown_one);
10a663a1 6182
1da177e4 6183/* move to PCI subsystem */
057ace5e 6184int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
1da177e4
LT		 6185{
6186 unsigned long tmp = 0;
6187
6188 switch (bits->width) {
6189 case 1: {
6190 u8 tmp8 = 0;
6191 pci_read_config_byte(pdev, bits->reg, &tmp8);
6192 tmp = tmp8;
6193 break;
6194 }
6195 case 2: {
6196 u16 tmp16 = 0;
6197 pci_read_config_word(pdev, bits->reg, &tmp16);
6198 tmp = tmp16;
6199 break;
6200 }
6201 case 4: {
6202 u32 tmp32 = 0;
6203 pci_read_config_dword(pdev, bits->reg, &tmp32);
6204 tmp = tmp32;
6205 break;
6206 }
6207
6208 default:
6209 return -EINVAL;
6210 }
6211
6212 tmp &= bits->mask;
6213
6214 return (tmp == bits->val) ? 1 : 0;
6215}
a52fbcfc 6216EXPORT_SYMBOL_GPL(pci_test_config_bits);
9b847548 6217
6ffa01d8 6218#ifdef CONFIG_PM
3c5100c1 6219void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
9b847548
JA		 6220{
6221 pci_save_state(pdev);
4c90d971 6222 pci_disable_device(pdev);
500530f6 6223
3a2d5b70 6224 if (mesg.event & PM_EVENT_SLEEP)
500530f6 6225 pci_set_power_state(pdev, PCI_D3hot);
9b847548 6226}
a52fbcfc 6227EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
9b847548 6228
553c4aa6 6229int ata_pci_device_do_resume(struct pci_dev *pdev)
9b847548 6230{
553c4aa6
TH		 6231 int rc;
6232
9b847548
JA		 6233 pci_set_power_state(pdev, PCI_D0);
6234 pci_restore_state(pdev);
553c4aa6 6235
b878ca5d 6236 rc = pcim_enable_device(pdev);
553c4aa6 6237 if (rc) {
a44fec1f
JP		 6238 dev_err(&pdev->dev,
6239 "failed to enable device after resume (%d)\n", rc);
553c4aa6
TH		 6240 return rc;
6241 }
6242
9b847548 6243 pci_set_master(pdev);
553c4aa6 6244 return 0;
500530f6 6245}
a52fbcfc 6246EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
500530f6 6247
3c5100c1 6248int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
500530f6 6249{
04a3f5b7 6250 struct ata_host *host = pci_get_drvdata(pdev);
500530f6 6251
ec87cf37 6252 ata_host_suspend(host, mesg);
500530f6 6253
3c5100c1 6254 ata_pci_device_do_suspend(pdev, mesg);
500530f6
TH		 6255
6256 return 0;
6257}
a52fbcfc 6258EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
500530f6
TH		 6259
6260int ata_pci_device_resume(struct pci_dev *pdev)
6261{
04a3f5b7 6262 struct ata_host *host = pci_get_drvdata(pdev);
553c4aa6 6263 int rc;
500530f6 6264
553c4aa6
TH		 6265 rc = ata_pci_device_do_resume(pdev);
6266 if (rc == 0)
6267 ata_host_resume(host);
6268 return rc;
9b847548 6269}
a52fbcfc 6270EXPORT_SYMBOL_GPL(ata_pci_device_resume);
6ffa01d8 6271#endif /* CONFIG_PM */
1da177e4
LT		 6272#endif /* CONFIG_PCI */
6273
b7db04d9
BN		 6274/**
6275 * ata_platform_remove_one - Platform layer callback for device removal
6276 * @pdev: Platform device that was removed
6277 *
6278 * Platform layer indicates to libata via this hook that hot-unplug or
6279 * module unload event has occurred. Detach all ports. Resource
6280 * release is handled via devres.
6281 *
6282 * LOCKING:
6283 * Inherited from platform layer (may sleep).
6284 */
a7eb54d4 6285void ata_platform_remove_one(struct platform_device *pdev)
b7db04d9
BN		 6286{
6287 struct ata_host *host = platform_get_drvdata(pdev);
6288
6289 ata_host_detach(host);
b7db04d9 6290}
a52fbcfc 6291EXPORT_SYMBOL_GPL(ata_platform_remove_one);
b7db04d9 6292
bf89b0bf 6293#ifdef CONFIG_ATA_FORCE
168af4af
DLM		 6294
6295#define force_cbl(name, flag) \
6296 { #name, .cbl = (flag) }
6297
6298#define force_spd_limit(spd, val) \
6299 { #spd, .spd_limit = (val) }
6300
6301#define force_xfer(mode, shift) \
6302 { #mode, .xfer_mask = (1UL << (shift)) }
6303
3af9ca4d
DLM		 6304#define force_lflag_on(name, flags) \
6305 { #name, .lflags_on = (flags) }
6306
6307#define force_lflag_onoff(name, flags) \
6308 { "no" #name, .lflags_on = (flags) }, \
6309 { #name, .lflags_off = (flags) }
168af4af
DLM		 6310
6311#define force_horkage_on(name, flag) \
6312 { #name, .horkage_on = (flag) }
6313
6314#define force_horkage_onoff(name, flag) \
6315 { "no" #name, .horkage_on = (flag) }, \
6316 { #name, .horkage_off = (flag) }
6317
6318static const struct ata_force_param force_tbl[] __initconst = {
6319 force_cbl(40c, ATA_CBL_PATA40),
6320 force_cbl(80c, ATA_CBL_PATA80),
6321 force_cbl(short40c, ATA_CBL_PATA40_SHORT),
6322 force_cbl(unk, ATA_CBL_PATA_UNK),
6323 force_cbl(ign, ATA_CBL_PATA_IGN),
6324 force_cbl(sata, ATA_CBL_SATA),
6325
6326 force_spd_limit(1.5Gbps, 1),
6327 force_spd_limit(3.0Gbps, 2),
6328
6329 force_xfer(pio0, ATA_SHIFT_PIO + 0),
6330 force_xfer(pio1, ATA_SHIFT_PIO + 1),
6331 force_xfer(pio2, ATA_SHIFT_PIO + 2),
6332 force_xfer(pio3, ATA_SHIFT_PIO + 3),
6333 force_xfer(pio4, ATA_SHIFT_PIO + 4),
6334 force_xfer(pio5, ATA_SHIFT_PIO + 5),
6335 force_xfer(pio6, ATA_SHIFT_PIO + 6),
6336 force_xfer(mwdma0, ATA_SHIFT_MWDMA + 0),
6337 force_xfer(mwdma1, ATA_SHIFT_MWDMA + 1),
6338 force_xfer(mwdma2, ATA_SHIFT_MWDMA + 2),
6339 force_xfer(mwdma3, ATA_SHIFT_MWDMA + 3),
6340 force_xfer(mwdma4, ATA_SHIFT_MWDMA + 4),
6341 force_xfer(udma0, ATA_SHIFT_UDMA + 0),
6342 force_xfer(udma16, ATA_SHIFT_UDMA + 0),
6343 force_xfer(udma/16, ATA_SHIFT_UDMA + 0),
6344 force_xfer(udma1, ATA_SHIFT_UDMA + 1),
6345 force_xfer(udma25, ATA_SHIFT_UDMA + 1),
6346 force_xfer(udma/25, ATA_SHIFT_UDMA + 1),
6347 force_xfer(udma2, ATA_SHIFT_UDMA + 2),
6348 force_xfer(udma33, ATA_SHIFT_UDMA + 2),
6349 force_xfer(udma/33, ATA_SHIFT_UDMA + 2),
6350 force_xfer(udma3, ATA_SHIFT_UDMA + 3),
6351 force_xfer(udma44, ATA_SHIFT_UDMA + 3),
6352 force_xfer(udma/44, ATA_SHIFT_UDMA + 3),
6353 force_xfer(udma4, ATA_SHIFT_UDMA + 4),
6354 force_xfer(udma66, ATA_SHIFT_UDMA + 4),
6355 force_xfer(udma/66, ATA_SHIFT_UDMA + 4),
6356 force_xfer(udma5, ATA_SHIFT_UDMA + 5),
6357 force_xfer(udma100, ATA_SHIFT_UDMA + 5),
6358 force_xfer(udma/100, ATA_SHIFT_UDMA + 5),
6359 force_xfer(udma6, ATA_SHIFT_UDMA + 6),
6360 force_xfer(udma133, ATA_SHIFT_UDMA + 6),
6361 force_xfer(udma/133, ATA_SHIFT_UDMA + 6),
6362 force_xfer(udma7, ATA_SHIFT_UDMA + 7),
6363
3af9ca4d
DLM		 6364 force_lflag_on(nohrst, ATA_LFLAG_NO_HRST),
6365 force_lflag_on(nosrst, ATA_LFLAG_NO_SRST),
6366 force_lflag_on(norst, ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST),
6367 force_lflag_on(rstonce, ATA_LFLAG_RST_ONCE),
6368 force_lflag_onoff(dbdelay, ATA_LFLAG_NO_DEBOUNCE_DELAY),
168af4af
DLM		 6369
6370 force_horkage_onoff(ncq, ATA_HORKAGE_NONCQ),
6371 force_horkage_onoff(ncqtrim, ATA_HORKAGE_NO_NCQ_TRIM),
6372 force_horkage_onoff(ncqati, ATA_HORKAGE_NO_NCQ_ON_ATI),
6373
2c33bbda
DLM		 6374 force_horkage_onoff(trim, ATA_HORKAGE_NOTRIM),
6375 force_horkage_on(trim_zero, ATA_HORKAGE_ZERO_AFTER_TRIM),
6376 force_horkage_on(max_trim_128m, ATA_HORKAGE_MAX_TRIM_128M),
6377
6378 force_horkage_onoff(dma, ATA_HORKAGE_NODMA),
168af4af 6379 force_horkage_on(atapi_dmadir, ATA_HORKAGE_ATAPI_DMADIR),
2c33bbda
DLM		 6380 force_horkage_on(atapi_mod16_dma, ATA_HORKAGE_ATAPI_MOD16_DMA),
6381
6382 force_horkage_onoff(dmalog, ATA_HORKAGE_NO_DMA_LOG),
6383 force_horkage_onoff(iddevlog, ATA_HORKAGE_NO_ID_DEV_LOG),
6384 force_horkage_onoff(logdir, ATA_HORKAGE_NO_LOG_DIR),
6385
6386 force_horkage_on(max_sec_128, ATA_HORKAGE_MAX_SEC_128),
6387 force_horkage_on(max_sec_1024, ATA_HORKAGE_MAX_SEC_1024),
6388 force_horkage_on(max_sec_lba48, ATA_HORKAGE_MAX_SEC_LBA48),
6389
6390 force_horkage_onoff(lpm, ATA_HORKAGE_NOLPM),
6391 force_horkage_onoff(setxfer, ATA_HORKAGE_NOSETXFER),
6392 force_horkage_on(dump_id, ATA_HORKAGE_DUMP_ID),
4d2e4980 6393 force_horkage_onoff(fua, ATA_HORKAGE_NO_FUA),
2c33bbda
DLM		 6394
6395 force_horkage_on(disable, ATA_HORKAGE_DISABLE),
168af4af
DLM		 6396};
6397
33267325
TH		 6398static int __init ata_parse_force_one(char **cur,
6399 struct ata_force_ent *force_ent,
6400 const char **reason)
6401{
33267325
TH		 6402 char *start = *cur, *p = *cur;
6403 char *id, *val, *endp;
6404 const struct ata_force_param *match_fp = NULL;
6405 int nr_matches = 0, i;
6406
6407 /* find where this param ends and update *cur */
6408 while (*p != '\0' && *p != ',')
6409 p++;
6410
6411 if (*p == '\0')
6412 *cur = p;
6413 else
6414 *cur = p + 1;
6415
6416 *p = '\0';
6417
6418 /* parse */
6419 p = strchr(start, ':');
6420 if (!p) {
6421 val = strstrip(start);
6422 goto parse_val;
6423 }
6424 *p = '\0';
6425
6426 id = strstrip(start);
6427 val = strstrip(p + 1);
6428
6429 /* parse id */
6430 p = strchr(id, '.');
6431 if (p) {
6432 *p++ = '\0';
6433 force_ent->device = simple_strtoul(p, &endp, 10);
6434 if (p == endp || *endp != '\0') {
6435 *reason = "invalid device";
6436 return -EINVAL;
6437 }
6438 }
6439
6440 force_ent->port = simple_strtoul(id, &endp, 10);
f7cf69ae 6441 if (id == endp || *endp != '\0') {
33267325
TH		 6442 *reason = "invalid port/link";
6443 return -EINVAL;
6444 }
6445
6446 parse_val:
6447 /* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */
6448 for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
6449 const struct ata_force_param *fp = &force_tbl[i];
6450
6451 if (strncasecmp(val, fp->name, strlen(val)))
6452 continue;
6453
6454 nr_matches++;
6455 match_fp = fp;
6456
6457 if (strcasecmp(val, fp->name) == 0) {
6458 nr_matches = 1;
6459 break;
6460 }
6461 }
6462
6463 if (!nr_matches) {
6464 *reason = "unknown value";
6465 return -EINVAL;
6466 }
6467 if (nr_matches > 1) {
9de55351 6468 *reason = "ambiguous value";
33267325
TH		 6469 return -EINVAL;
6470 }
6471
6472 force_ent->param = *match_fp;
6473
6474 return 0;
6475}
6476
6477static void __init ata_parse_force_param(void)
6478{
6479 int idx = 0, size = 1;
6480 int last_port = -1, last_device = -1;
6481 char *p, *cur, *next;
6482
168af4af 6483 /* Calculate maximum number of params and allocate ata_force_tbl */
33267325
TH		 6484 for (p = ata_force_param_buf; *p; p++)
6485 if (*p == ',')
6486 size++;
6487
6396bb22 6488 ata_force_tbl = kcalloc(size, sizeof(ata_force_tbl[0]), GFP_KERNEL);
33267325
TH		 6489 if (!ata_force_tbl) {
6490 printk(KERN_WARNING "ata: failed to extend force table, "
6491 "libata.force ignored\n");
6492 return;
6493 }
6494
6495 /* parse and populate the table */
6496 for (cur = ata_force_param_buf; *cur != '\0'; cur = next) {
6497 const char *reason = "";
6498 struct ata_force_ent te = { .port = -1, .device = -1 };
6499
6500 next = cur;
6501 if (ata_parse_force_one(&next, &te, &reason)) {
6502 printk(KERN_WARNING "ata: failed to parse force "
6503 "parameter \"%s\" (%s)\n",
6504 cur, reason);
6505 continue;
6506 }
6507
6508 if (te.port == -1) {
6509 te.port = last_port;
6510 te.device = last_device;
6511 }
6512
6513 ata_force_tbl[idx++] = te;
6514
6515 last_port = te.port;
6516 last_device = te.device;
6517 }
6518
6519 ata_force_tbl_size = idx;
6520}
1da177e4 6521
bf89b0bf
BZ		 6522static void ata_free_force_param(void)
6523{
6524 kfree(ata_force_tbl);
6525}
6526#else
6527static inline void ata_parse_force_param(void) { }
6528static inline void ata_free_force_param(void) { }
6529#endif
6530
1da177e4
LT		 6531static int __init ata_init(void)
6532{
d9027470 6533 int rc;
270390e1 6534
33267325
TH		 6535 ata_parse_force_param();
6536
270390e1 6537 rc = ata_sff_init();
ad72cf98 6538 if (rc) {
bf89b0bf 6539 ata_free_force_param();
ad72cf98
TH		 6540 return rc;
6541 }
453b07ac 6542
d9027470
GG		 6543 libata_transport_init();
6544 ata_scsi_transport_template = ata_attach_transport();
6545 if (!ata_scsi_transport_template) {
6546 ata_sff_exit();
6547 rc = -ENOMEM;
6548 goto err_out;
4fca377f 6549 }
d9027470 6550
1da177e4
LT		 6551 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6552 return 0;
d9027470
GG		 6553
6554err_out:
6555 return rc;
1da177e4
LT		 6556}
6557
6558static void __exit ata_exit(void)
6559{
d9027470
GG		 6560 ata_release_transport(ata_scsi_transport_template);
6561 libata_transport_exit();
270390e1 6562 ata_sff_exit();
bf89b0bf 6563 ata_free_force_param();
1da177e4
LT		 6564}
6565
a4625085 6566subsys_initcall(ata_init);
1da177e4
LT		 6567module_exit(ata_exit);
6568
9990b6f3 6569static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
67846b30
JG		 6570
6571int ata_ratelimit(void)
6572{
9990b6f3 6573 return __ratelimit(&ratelimit);
67846b30 6574}
a52fbcfc 6575EXPORT_SYMBOL_GPL(ata_ratelimit);
67846b30 6576
c0c362b6
TH		 6577/**
6578 * ata_msleep - ATA EH owner aware msleep
6579 * @ap: ATA port to attribute the sleep to
6580 * @msecs: duration to sleep in milliseconds
6581 *
6582 * Sleeps @msecs. If the current task is owner of @ap's EH, the
6583 * ownership is released before going to sleep and reacquired
6584 * after the sleep is complete. IOW, other ports sharing the
6585 * @ap->host will be allowed to own the EH while this task is
6586 * sleeping.
6587 *
6588 * LOCKING:
6589 * Might sleep.
6590 */
97750ceb
TH		 6591void ata_msleep(struct ata_port *ap, unsigned int msecs)
6592{
c0c362b6
TH		 6593 bool owns_eh = ap && ap->host->eh_owner == current;
6594
6595 if (owns_eh)
6596 ata_eh_release(ap);
6597
848c3920
AVM		 6598 if (msecs < 20) {
6599 unsigned long usecs = msecs * USEC_PER_MSEC;
6600 usleep_range(usecs, usecs + 50);
6601 } else {
6602 msleep(msecs);
6603 }
c0c362b6
TH		 6604
6605 if (owns_eh)
6606 ata_eh_acquire(ap);
97750ceb 6607}
a52fbcfc 6608EXPORT_SYMBOL_GPL(ata_msleep);
97750ceb 6609
c22daff4
TH		 6610/**
6611 * ata_wait_register - wait until register value changes
97750ceb 6612 * @ap: ATA port to wait register for, can be NULL
c22daff4
TH		 6613 * @reg: IO-mapped register
6614 * @mask: Mask to apply to read register value
6615 * @val: Wait condition
341c2c95
TH		 6616 * @interval: polling interval in milliseconds
6617 * @timeout: timeout in milliseconds
c22daff4
TH		 6618 *
6619 * Waiting for some bits of register to change is a common
6620 * operation for ATA controllers. This function reads 32bit LE
6621 * IO-mapped register @reg and tests for the following condition.
6622 *
6623 * (*@reg & mask) != val
6624 *
6625 * If the condition is met, it returns; otherwise, the process is
6626 * repeated after @interval_msec until timeout.
6627 *
6628 * LOCKING:
6629 * Kernel thread context (may sleep)
6630 *
6631 * RETURNS:
6632 * The final register value.
6633 */
97750ceb 6634u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
84abed36 6635 unsigned int interval, unsigned int timeout)
c22daff4 6636{
341c2c95 6637 unsigned long deadline;
c22daff4
TH		 6638 u32 tmp;
6639
6640 tmp = ioread32(reg);
6641
6642 /* Calculate timeout _after_ the first read to make sure
6643 * preceding writes reach the controller before starting to
6644 * eat away the timeout.
6645 */
341c2c95 6646 deadline = ata_deadline(jiffies, timeout);
c22daff4 6647
341c2c95 6648 while ((tmp & mask) == val && time_before(jiffies, deadline)) {
97750ceb 6649 ata_msleep(ap, interval);
c22daff4
TH		 6650 tmp = ioread32(reg);
6651 }
6652
6653 return tmp;
6654}
a52fbcfc 6655EXPORT_SYMBOL_GPL(ata_wait_register);
c22daff4 6656
dd5b06c4
TH		 6657/*
6658 * Dummy port_ops
6659 */
182d7bba 6660static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
dd5b06c4 6661{
182d7bba 6662 return AC_ERR_SYSTEM;
dd5b06c4
TH		 6663}
6664
182d7bba 6665static void ata_dummy_error_handler(struct ata_port *ap)
dd5b06c4 6666{
182d7bba 6667 /* truly dummy */
dd5b06c4
TH		 6668}
6669
029cfd6b 6670struct ata_port_operations ata_dummy_port_ops = {
dd5b06c4
TH		 6671 .qc_prep = ata_noop_qc_prep,
6672 .qc_issue = ata_dummy_qc_issue,
182d7bba 6673 .error_handler = ata_dummy_error_handler,
e4a9c373
DW		 6674 .sched_eh = ata_std_sched_eh,
6675 .end_eh = ata_std_end_eh,
dd5b06c4 6676};
a52fbcfc 6677EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
dd5b06c4 6678
21b0ad4f
TH		 6679const struct ata_port_info ata_dummy_port_info = {
6680 .port_ops = &ata_dummy_port_ops,
6681};
a52fbcfc 6682EXPORT_SYMBOL_GPL(ata_dummy_port_info);
21b0ad4f 6683
06296a1e
JP		 6684void ata_print_version(const struct device *dev, const char *version)
6685{
6686 dev_printk(KERN_DEBUG, dev, "version %s\n", version);
6687}
6688EXPORT_SYMBOL(ata_print_version);
c206a389
HR		 6689
6690EXPORT_TRACEPOINT_SYMBOL_GPL(ata_tf_load);
6691EXPORT_TRACEPOINT_SYMBOL_GPL(ata_exec_command);
6692EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_setup);
6693EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_start);
6694EXPORT_TRACEPOINT_SYMBOL_GPL(ata_bmdma_status);
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git