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