blob: 9cd0a2d4181699d94f73f2af82490e59f23373e2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04002 * libata-core.c - helper library for ATA
3 *
Tejun Heo8c3d3d42013-05-14 11:09:50 -07004 * Maintained by: Tejun Heo <tj@kernel.org>
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04005 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
32 *
Alan Cox92c52c52007-11-19 14:30:16 +000033 * Standards documents from:
34 * http://www.t13.org (ATA standards, PCI DMA IDE spec)
35 * http://www.t10.org (SCSI MMC - for ATAPI MMC)
36 * http://www.sata-io.org (SATA)
37 * http://www.compactflash.org (CF)
38 * http://www.qic.org (QIC157 - Tape and DSC)
39 * http://www.ce-ata.org (CE-ATA: not supported)
40 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 */
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/kernel.h>
44#include <linux/module.h>
45#include <linux/pci.h>
46#include <linux/init.h>
47#include <linux/list.h>
48#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/spinlock.h>
50#include <linux/blkdev.h>
51#include <linux/delay.h>
52#include <linux/timer.h>
Anil Veliyankara Madam848c3922016-01-07 21:18:52 -080053#include <linux/time.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <linux/interrupt.h>
55#include <linux/completion.h>
56#include <linux/suspend.h>
57#include <linux/workqueue.h>
David Hardeman378f0582005-09-17 17:55:31 +100058#include <linux/scatterlist.h>
Jeff Garzik2dcb4072007-10-19 06:42:56 -040059#include <linux/io.h>
Arjan van de Ven79318052009-01-04 05:32:28 -080060#include <linux/async.h>
Mark Lorde18086d2009-03-19 13:32:21 -040061#include <linux/log2.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090062#include <linux/slab.h>
George Spelvin428ac5f2014-08-06 16:09:27 -070063#include <linux/glob.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <scsi/scsi.h>
Jeff Garzik193515d2005-11-07 00:59:37 -050065#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <scsi/scsi_host.h>
67#include <linux/libata.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <asm/byteorder.h>
Hannes Reineckefe5af0c2016-04-25 12:45:48 +020069#include <asm/unaligned.h>
Tejun Heo140b5e592007-12-12 12:21:52 +090070#include <linux/cdrom.h>
Akinobu Mita9990b6f2010-04-12 21:11:41 +090071#include <linux/ratelimit.h>
Stephan Linzeb25cb92016-06-10 07:59:56 +020072#include <linux/leds.h>
Lin Ming9ee4f392011-12-05 09:20:28 +080073#include <linux/pm_runtime.h>
Brian Norrisb7db04d2012-11-02 12:29:32 -070074#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Hannes Reinecke255c03d2015-03-27 16:46:38 +010076#define CREATE_TRACE_POINTS
77#include <trace/events/libata.h>
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include "libata.h"
Gwendal Grignoud9027472010-05-25 12:31:38 -070080#include "libata-transport.h"
Jeff Garzikfda0efc2007-01-31 07:43:15 -050081
Tejun Heod7bb4cc2006-05-31 18:27:46 +090082/* debounce timing parameters in msecs { interval, duration, timeout } */
Tejun Heoe9c83912006-07-03 16:07:26 +090083const unsigned long sata_deb_timing_normal[] = { 5, 100, 2000 };
84const unsigned long sata_deb_timing_hotplug[] = { 25, 500, 2000 };
85const unsigned long sata_deb_timing_long[] = { 100, 2000, 5000 };
Tejun Heod7bb4cc2006-05-31 18:27:46 +090086
Tejun Heo029cfd62008-03-25 12:22:49 +090087const struct ata_port_operations ata_base_port_ops = {
Tejun Heo0aa11132008-04-07 22:47:18 +090088 .prereset = ata_std_prereset,
Tejun Heo203c75b2008-04-07 22:47:18 +090089 .postreset = ata_std_postreset,
Tejun Heoa1efdab2008-03-25 12:22:50 +090090 .error_handler = ata_std_error_handler,
Dan Williamse4a9c372012-06-21 23:25:27 -070091 .sched_eh = ata_std_sched_eh,
92 .end_eh = ata_std_end_eh,
Tejun Heo029cfd62008-03-25 12:22:49 +090093};
94
95const struct ata_port_operations sata_port_ops = {
96 .inherits = &ata_base_port_ops,
97
98 .qc_defer = ata_std_qc_defer,
Tejun Heo57c9efd2008-04-07 22:47:19 +090099 .hardreset = sata_std_hardreset,
Tejun Heo029cfd62008-03-25 12:22:49 +0900100};
101
Tejun Heo3373efd2006-05-15 20:57:53 +0900102static unsigned int ata_dev_init_params(struct ata_device *dev,
103 u16 heads, u16 sectors);
104static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
105static void ata_dev_xfermask(struct ata_device *dev);
Tejun Heo75683fe2007-07-05 13:31:27 +0900106static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Tero Roponena78f57a2012-04-22 11:38:00 +0300108atomic_t ata_print_id = ATOMIC_INIT(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Tejun Heo33267322008-02-13 09:15:09 +0900110struct ata_force_param {
111 const char *name;
112 unsigned int cbl;
113 int spd_limit;
114 unsigned long xfer_mask;
115 unsigned int horkage_on;
116 unsigned int horkage_off;
Tejun Heo05944bd2008-08-13 20:19:09 +0900117 unsigned int lflags;
Tejun Heo33267322008-02-13 09:15:09 +0900118};
119
120struct ata_force_ent {
121 int port;
122 int device;
123 struct ata_force_param param;
124};
125
126static struct ata_force_ent *ata_force_tbl;
127static int ata_force_tbl_size;
128
129static char ata_force_param_buf[PAGE_SIZE] __initdata;
Tejun Heo7afb4222008-03-09 20:21:53 +0900130/* param_buf is thrown away after initialization, disallow read */
131module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0);
Mauro Carvalho Chehab8c27ceff32016-10-18 10:12:27 -0200132MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/admin-guide/kernel-parameters.rst for details)");
Tejun Heo33267322008-02-13 09:15:09 +0900133
Tejun Heo2486fa52008-07-31 07:52:40 +0900134static int atapi_enabled = 1;
Jeff Garzik1623c812005-08-30 03:37:42 -0400135module_param(atapi_enabled, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200136MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
Jeff Garzik1623c812005-08-30 03:37:42 -0400137
Adrian Bunkc5c61bd2008-02-25 02:07:25 +0200138static int atapi_dmadir = 0;
Albert Lee95de7192006-04-04 10:57:18 +0800139module_param(atapi_dmadir, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200140MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
Albert Lee95de7192006-04-04 10:57:18 +0800141
Mark Lordbaf4fdf2007-08-08 01:08:45 +0900142int atapi_passthru16 = 1;
143module_param(atapi_passthru16, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200144MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
Mark Lordbaf4fdf2007-08-08 01:08:45 +0900145
Jeff Garzikc3c013a2006-02-27 22:31:19 -0500146int libata_fua = 0;
147module_param_named(fua, libata_fua, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200148MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
Jeff Garzikc3c013a2006-02-27 22:31:19 -0500149
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400150static int ata_ignore_hpa;
Alan Cox1e999732007-04-11 00:23:13 +0100151module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
152MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
153
Alan Coxb3a70602007-10-02 12:38:26 -0400154static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
155module_param_named(dma, libata_dma_mask, int, 0444);
156MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
157
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900158static int ata_probe_timeout;
Andrew Mortona8601e52006-06-25 01:36:52 -0700159module_param(ata_probe_timeout, int, 0444);
160MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
161
Jeff Garzik6ebe9d82007-10-05 16:28:36 -0400162int libata_noacpi = 0;
Jeff Garzikd7d0dad2007-03-28 01:57:37 -0400163module_param_named(noacpi, libata_noacpi, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200164MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
Kristen Carlson Accardi11ef6972006-09-28 11:29:01 -0700165
Alan Coxae8d4ee2007-11-04 22:05:49 -0500166int libata_allow_tpm = 0;
167module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
Evgeni Golovad5d8ea2009-06-22 09:46:20 +0200168MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
Alan Coxae8d4ee2007-11-04 22:05:49 -0500169
Tejun Heoe7ecd432010-05-19 15:38:58 +0200170static int atapi_an;
171module_param(atapi_an, int, 0444);
172MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174MODULE_AUTHOR("Jeff Garzik");
175MODULE_DESCRIPTION("Library module for ATA devices");
176MODULE_LICENSE("GPL");
177MODULE_VERSION(DRV_VERSION);
178
Edward Falk0baab862005-06-02 18:17:13 -0400179
Tejun Heo9913ff82009-01-29 20:31:31 +0900180static bool ata_sstatus_online(u32 sstatus)
181{
182 return (sstatus & 0xf) == 0x3;
183}
184
Tejun Heo1eca4362008-11-03 20:03:17 +0900185/**
186 * ata_link_next - link iteration helper
187 * @link: the previous link, NULL to start
188 * @ap: ATA port containing links to iterate
189 * @mode: iteration mode, one of ATA_LITER_*
Tejun Heoaadffb62008-07-31 17:02:41 +0900190 *
Tejun Heo1eca4362008-11-03 20:03:17 +0900191 * LOCKING:
192 * Host lock or EH context.
193 *
194 * RETURNS:
195 * Pointer to the next link.
Tejun Heoaadffb62008-07-31 17:02:41 +0900196 */
Tejun Heo1eca4362008-11-03 20:03:17 +0900197struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
198 enum ata_link_iter_mode mode)
Tejun Heoaadffb62008-07-31 17:02:41 +0900199{
Tejun Heo1eca4362008-11-03 20:03:17 +0900200 BUG_ON(mode != ATA_LITER_EDGE &&
201 mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);
Tejun Heoaadffb62008-07-31 17:02:41 +0900202
Tejun Heo1eca4362008-11-03 20:03:17 +0900203 /* NULL link indicates start of iteration */
204 if (!link)
205 switch (mode) {
206 case ATA_LITER_EDGE:
207 case ATA_LITER_PMP_FIRST:
208 if (sata_pmp_attached(ap))
209 return ap->pmp_link;
210 /* fall through */
211 case ATA_LITER_HOST_FIRST:
212 return &ap->link;
213 }
214
215 /* we just iterated over the host link, what's next? */
216 if (link == &ap->link)
217 switch (mode) {
218 case ATA_LITER_HOST_FIRST:
219 if (sata_pmp_attached(ap))
220 return ap->pmp_link;
221 /* fall through */
222 case ATA_LITER_PMP_FIRST:
223 if (unlikely(ap->slave_link))
Tejun Heob1c72912008-07-31 17:02:43 +0900224 return ap->slave_link;
Tejun Heo1eca4362008-11-03 20:03:17 +0900225 /* fall through */
226 case ATA_LITER_EDGE:
Tejun Heoaadffb62008-07-31 17:02:41 +0900227 return NULL;
Tejun Heob1c72912008-07-31 17:02:43 +0900228 }
Tejun Heoaadffb62008-07-31 17:02:41 +0900229
Tejun Heob1c72912008-07-31 17:02:43 +0900230 /* slave_link excludes PMP */
231 if (unlikely(link == ap->slave_link))
232 return NULL;
233
Tejun Heo1eca4362008-11-03 20:03:17 +0900234 /* we were over a PMP link */
Tejun Heoaadffb62008-07-31 17:02:41 +0900235 if (++link < ap->pmp_link + ap->nr_pmp_links)
236 return link;
Tejun Heo1eca4362008-11-03 20:03:17 +0900237
238 if (mode == ATA_LITER_PMP_FIRST)
239 return &ap->link;
240
Tejun Heoaadffb62008-07-31 17:02:41 +0900241 return NULL;
242}
243
Edward Falk0baab862005-06-02 18:17:13 -0400244/**
Tejun Heo1eca4362008-11-03 20:03:17 +0900245 * ata_dev_next - device iteration helper
246 * @dev: the previous device, NULL to start
247 * @link: ATA link containing devices to iterate
248 * @mode: iteration mode, one of ATA_DITER_*
249 *
250 * LOCKING:
251 * Host lock or EH context.
252 *
253 * RETURNS:
254 * Pointer to the next device.
255 */
256struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
257 enum ata_dev_iter_mode mode)
258{
259 BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&
260 mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);
261
262 /* NULL dev indicates start of iteration */
263 if (!dev)
264 switch (mode) {
265 case ATA_DITER_ENABLED:
266 case ATA_DITER_ALL:
267 dev = link->device;
268 goto check;
269 case ATA_DITER_ENABLED_REVERSE:
270 case ATA_DITER_ALL_REVERSE:
271 dev = link->device + ata_link_max_devices(link) - 1;
272 goto check;
273 }
274
275 next:
276 /* move to the next one */
277 switch (mode) {
278 case ATA_DITER_ENABLED:
279 case ATA_DITER_ALL:
280 if (++dev < link->device + ata_link_max_devices(link))
281 goto check;
282 return NULL;
283 case ATA_DITER_ENABLED_REVERSE:
284 case ATA_DITER_ALL_REVERSE:
285 if (--dev >= link->device)
286 goto check;
287 return NULL;
288 }
289
290 check:
291 if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&
292 !ata_dev_enabled(dev))
293 goto next;
294 return dev;
295}
296
297/**
Tejun Heob1c72912008-07-31 17:02:43 +0900298 * ata_dev_phys_link - find physical link for a device
299 * @dev: ATA device to look up physical link for
300 *
301 * Look up physical link which @dev is attached to. Note that
302 * this is different from @dev->link only when @dev is on slave
303 * link. For all other cases, it's the same as @dev->link.
304 *
305 * LOCKING:
306 * Don't care.
307 *
308 * RETURNS:
309 * Pointer to the found physical link.
310 */
311struct ata_link *ata_dev_phys_link(struct ata_device *dev)
312{
313 struct ata_port *ap = dev->link->ap;
314
315 if (!ap->slave_link)
316 return dev->link;
317 if (!dev->devno)
318 return &ap->link;
319 return ap->slave_link;
320}
321
322/**
Tejun Heo33267322008-02-13 09:15:09 +0900323 * ata_force_cbl - force cable type according to libata.force
Randy Dunlap4cdfa1b2008-02-22 12:21:37 -0800324 * @ap: ATA port of interest
Tejun Heo33267322008-02-13 09:15:09 +0900325 *
326 * Force cable type according to libata.force and whine about it.
327 * The last entry which has matching port number is used, so it
328 * can be specified as part of device force parameters. For
329 * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the
330 * same effect.
331 *
332 * LOCKING:
333 * EH context.
334 */
335void ata_force_cbl(struct ata_port *ap)
336{
337 int i;
338
339 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
340 const struct ata_force_ent *fe = &ata_force_tbl[i];
341
342 if (fe->port != -1 && fe->port != ap->print_id)
343 continue;
344
345 if (fe->param.cbl == ATA_CBL_NONE)
346 continue;
347
348 ap->cbl = fe->param.cbl;
Joe Perchesa9a79df2011-04-15 15:51:59 -0700349 ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
Tejun Heo33267322008-02-13 09:15:09 +0900350 return;
351 }
352}
353
354/**
Tejun Heo05944bd2008-08-13 20:19:09 +0900355 * ata_force_link_limits - force link limits according to libata.force
Tejun Heo33267322008-02-13 09:15:09 +0900356 * @link: ATA link of interest
357 *
Tejun Heo05944bd2008-08-13 20:19:09 +0900358 * Force link flags and SATA spd limit according to libata.force
359 * and whine about it. When only the port part is specified
360 * (e.g. 1:), the limit applies to all links connected to both
361 * the host link and all fan-out ports connected via PMP. If the
362 * device part is specified as 0 (e.g. 1.00:), it specifies the
363 * first fan-out link not the host link. Device number 15 always
Tejun Heob1c72912008-07-31 17:02:43 +0900364 * points to the host link whether PMP is attached or not. If the
365 * controller has slave link, device number 16 points to it.
Tejun Heo33267322008-02-13 09:15:09 +0900366 *
367 * LOCKING:
368 * EH context.
369 */
Tejun Heo05944bd2008-08-13 20:19:09 +0900370static void ata_force_link_limits(struct ata_link *link)
Tejun Heo33267322008-02-13 09:15:09 +0900371{
Tejun Heo05944bd2008-08-13 20:19:09 +0900372 bool did_spd = false;
Tejun Heob1c72912008-07-31 17:02:43 +0900373 int linkno = link->pmp;
374 int i;
Tejun Heo33267322008-02-13 09:15:09 +0900375
376 if (ata_is_host_link(link))
Tejun Heob1c72912008-07-31 17:02:43 +0900377 linkno += 15;
Tejun Heo33267322008-02-13 09:15:09 +0900378
379 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
380 const struct ata_force_ent *fe = &ata_force_tbl[i];
381
382 if (fe->port != -1 && fe->port != link->ap->print_id)
383 continue;
384
385 if (fe->device != -1 && fe->device != linkno)
386 continue;
387
Tejun Heo05944bd2008-08-13 20:19:09 +0900388 /* only honor the first spd limit */
389 if (!did_spd && fe->param.spd_limit) {
390 link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
Joe Perchesa9a79df2011-04-15 15:51:59 -0700391 ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
Tejun Heo05944bd2008-08-13 20:19:09 +0900392 fe->param.name);
393 did_spd = true;
394 }
Tejun Heo33267322008-02-13 09:15:09 +0900395
Tejun Heo05944bd2008-08-13 20:19:09 +0900396 /* let lflags stack */
397 if (fe->param.lflags) {
398 link->flags |= fe->param.lflags;
Joe Perchesa9a79df2011-04-15 15:51:59 -0700399 ata_link_notice(link,
Tejun Heo05944bd2008-08-13 20:19:09 +0900400 "FORCE: link flag 0x%x forced -> 0x%x\n",
401 fe->param.lflags, link->flags);
402 }
Tejun Heo33267322008-02-13 09:15:09 +0900403 }
404}
405
406/**
407 * ata_force_xfermask - force xfermask according to libata.force
408 * @dev: ATA device of interest
409 *
410 * Force xfer_mask according to libata.force and whine about it.
411 * For consistency with link selection, device number 15 selects
412 * the first device connected to the host link.
413 *
414 * LOCKING:
415 * EH context.
416 */
417static void ata_force_xfermask(struct ata_device *dev)
418{
419 int devno = dev->link->pmp + dev->devno;
420 int alt_devno = devno;
421 int i;
422
Tejun Heob1c72912008-07-31 17:02:43 +0900423 /* allow n.15/16 for devices attached to host port */
424 if (ata_is_host_link(dev->link))
425 alt_devno += 15;
Tejun Heo33267322008-02-13 09:15:09 +0900426
427 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
428 const struct ata_force_ent *fe = &ata_force_tbl[i];
429 unsigned long pio_mask, mwdma_mask, udma_mask;
430
431 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
432 continue;
433
434 if (fe->device != -1 && fe->device != devno &&
435 fe->device != alt_devno)
436 continue;
437
438 if (!fe->param.xfer_mask)
439 continue;
440
441 ata_unpack_xfermask(fe->param.xfer_mask,
442 &pio_mask, &mwdma_mask, &udma_mask);
443 if (udma_mask)
444 dev->udma_mask = udma_mask;
445 else if (mwdma_mask) {
446 dev->udma_mask = 0;
447 dev->mwdma_mask = mwdma_mask;
448 } else {
449 dev->udma_mask = 0;
450 dev->mwdma_mask = 0;
451 dev->pio_mask = pio_mask;
452 }
453
Joe Perchesa9a79df2011-04-15 15:51:59 -0700454 ata_dev_notice(dev, "FORCE: xfer_mask set to %s\n",
455 fe->param.name);
Tejun Heo33267322008-02-13 09:15:09 +0900456 return;
457 }
458}
459
460/**
461 * ata_force_horkage - force horkage according to libata.force
462 * @dev: ATA device of interest
463 *
464 * Force horkage according to libata.force and whine about it.
465 * For consistency with link selection, device number 15 selects
466 * the first device connected to the host link.
467 *
468 * LOCKING:
469 * EH context.
470 */
471static void ata_force_horkage(struct ata_device *dev)
472{
473 int devno = dev->link->pmp + dev->devno;
474 int alt_devno = devno;
475 int i;
476
Tejun Heob1c72912008-07-31 17:02:43 +0900477 /* allow n.15/16 for devices attached to host port */
478 if (ata_is_host_link(dev->link))
479 alt_devno += 15;
Tejun Heo33267322008-02-13 09:15:09 +0900480
481 for (i = 0; i < ata_force_tbl_size; i++) {
482 const struct ata_force_ent *fe = &ata_force_tbl[i];
483
484 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
485 continue;
486
487 if (fe->device != -1 && fe->device != devno &&
488 fe->device != alt_devno)
489 continue;
490
491 if (!(~dev->horkage & fe->param.horkage_on) &&
492 !(dev->horkage & fe->param.horkage_off))
493 continue;
494
495 dev->horkage |= fe->param.horkage_on;
496 dev->horkage &= ~fe->param.horkage_off;
497
Joe Perchesa9a79df2011-04-15 15:51:59 -0700498 ata_dev_notice(dev, "FORCE: horkage modified (%s)\n",
499 fe->param.name);
Tejun Heo33267322008-02-13 09:15:09 +0900500 }
501}
502
503/**
Tejun Heo436d34b2008-04-02 17:28:46 +0900504 * atapi_cmd_type - Determine ATAPI command type from SCSI opcode
505 * @opcode: SCSI opcode
506 *
507 * Determine ATAPI command type from @opcode.
508 *
509 * LOCKING:
510 * None.
511 *
512 * RETURNS:
513 * ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC}
514 */
515int atapi_cmd_type(u8 opcode)
516{
517 switch (opcode) {
518 case GPCMD_READ_10:
519 case GPCMD_READ_12:
520 return ATAPI_READ;
521
522 case GPCMD_WRITE_10:
523 case GPCMD_WRITE_12:
524 case GPCMD_WRITE_AND_VERIFY_10:
525 return ATAPI_WRITE;
526
527 case GPCMD_READ_CD:
528 case GPCMD_READ_CD_MSF:
529 return ATAPI_READ_CD;
530
Tejun Heoe52dcc42008-04-02 17:35:19 +0900531 case ATA_16:
532 case ATA_12:
533 if (atapi_passthru16)
534 return ATAPI_PASS_THRU;
535 /* fall thru */
Tejun Heo436d34b2008-04-02 17:28:46 +0900536 default:
537 return ATAPI_MISC;
538 }
539}
540
541/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
543 * @tf: Taskfile to convert
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 * @pmp: Port multiplier port
Tejun Heo99771262007-07-16 14:29:38 +0900545 * @is_cmd: This FIS is for command
546 * @fis: Buffer into which data will output
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 *
548 * Converts a standard ATA taskfile to a Serial ATA
549 * FIS structure (Register - Host to Device).
550 *
551 * LOCKING:
552 * Inherited from caller.
553 */
Tejun Heo99771262007-07-16 14:29:38 +0900554void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555{
Tejun Heo99771262007-07-16 14:29:38 +0900556 fis[0] = 0x27; /* Register - Host to Device FIS */
557 fis[1] = pmp & 0xf; /* Port multiplier number*/
558 if (is_cmd)
559 fis[1] |= (1 << 7); /* bit 7 indicates Command FIS */
560
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 fis[2] = tf->command;
562 fis[3] = tf->feature;
563
564 fis[4] = tf->lbal;
565 fis[5] = tf->lbam;
566 fis[6] = tf->lbah;
567 fis[7] = tf->device;
568
569 fis[8] = tf->hob_lbal;
570 fis[9] = tf->hob_lbam;
571 fis[10] = tf->hob_lbah;
572 fis[11] = tf->hob_feature;
573
574 fis[12] = tf->nsect;
575 fis[13] = tf->hob_nsect;
576 fis[14] = 0;
577 fis[15] = tf->ctl;
578
Marc Carino86a565e2013-09-01 08:59:01 -0700579 fis[16] = tf->auxiliary & 0xff;
580 fis[17] = (tf->auxiliary >> 8) & 0xff;
581 fis[18] = (tf->auxiliary >> 16) & 0xff;
582 fis[19] = (tf->auxiliary >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583}
584
585/**
586 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
587 * @fis: Buffer from which data will be input
588 * @tf: Taskfile to output
589 *
Mark Lorde12a1be2005-11-12 18:55:45 -0500590 * Converts a serial ATA FIS structure to a standard ATA taskfile.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 *
592 * LOCKING:
593 * Inherited from caller.
594 */
595
Jeff Garzik057ace52005-10-22 14:27:05 -0400596void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 tf->command = fis[2]; /* status */
599 tf->feature = fis[3]; /* error */
600
601 tf->lbal = fis[4];
602 tf->lbam = fis[5];
603 tf->lbah = fis[6];
604 tf->device = fis[7];
605
606 tf->hob_lbal = fis[8];
607 tf->hob_lbam = fis[9];
608 tf->hob_lbah = fis[10];
609
610 tf->nsect = fis[12];
611 tf->hob_nsect = fis[13];
612}
613
Albert Lee8cbd6df2005-10-12 15:06:27 +0800614static const u8 ata_rw_cmds[] = {
615 /* pio multi */
616 ATA_CMD_READ_MULTI,
617 ATA_CMD_WRITE_MULTI,
618 ATA_CMD_READ_MULTI_EXT,
619 ATA_CMD_WRITE_MULTI_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100620 0,
621 0,
622 0,
623 ATA_CMD_WRITE_MULTI_FUA_EXT,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800624 /* pio */
625 ATA_CMD_PIO_READ,
626 ATA_CMD_PIO_WRITE,
627 ATA_CMD_PIO_READ_EXT,
628 ATA_CMD_PIO_WRITE_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100629 0,
630 0,
631 0,
632 0,
Albert Lee8cbd6df2005-10-12 15:06:27 +0800633 /* dma */
634 ATA_CMD_READ,
635 ATA_CMD_WRITE,
636 ATA_CMD_READ_EXT,
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100637 ATA_CMD_WRITE_EXT,
638 0,
639 0,
640 0,
641 ATA_CMD_WRITE_FUA_EXT
Albert Lee8cbd6df2005-10-12 15:06:27 +0800642};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644/**
Albert Lee8cbd6df2005-10-12 15:06:27 +0800645 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
Tejun Heobd056d72006-11-14 22:47:10 +0900646 * @tf: command to examine and configure
647 * @dev: device tf belongs to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 *
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500649 * Examine the device configuration and tf->flags to calculate
Albert Lee8cbd6df2005-10-12 15:06:27 +0800650 * the proper read/write commands and protocol to use.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 *
652 * LOCKING:
653 * caller.
654 */
Tejun Heobd056d72006-11-14 22:47:10 +0900655static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656{
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100657 u8 cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100659 int index, fua, lba48, write;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500660
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100661 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800662 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
663 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Albert Lee8cbd6df2005-10-12 15:06:27 +0800665 if (dev->flags & ATA_DFLAG_PIO) {
666 tf->protocol = ATA_PROT_PIO;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100667 index = dev->multi_count ? 0 : 8;
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900668 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
Alan Cox8d238e02006-01-17 20:50:31 +0000669 /* Unable to use DMA due to host limitation */
670 tf->protocol = ATA_PROT_PIO;
Albert Lee0565c262006-02-13 18:55:25 +0800671 index = dev->multi_count ? 0 : 8;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800672 } else {
673 tf->protocol = ATA_PROT_DMA;
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100674 index = 16;
Albert Lee8cbd6df2005-10-12 15:06:27 +0800675 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Tejun Heo9a3dccc2006-01-06 09:56:18 +0100677 cmd = ata_rw_cmds[index + fua + lba48 + write];
678 if (cmd) {
679 tf->command = cmd;
680 return 0;
681 }
682 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
Tejun Heocb95d562006-03-06 04:31:56 +0900685/**
Tejun Heo35b649f2006-11-14 22:37:35 +0900686 * ata_tf_read_block - Read block address from ATA taskfile
687 * @tf: ATA taskfile of interest
688 * @dev: ATA device @tf belongs to
689 *
690 * LOCKING:
691 * None.
692 *
693 * Read block address from @tf. This function can handle all
694 * three address formats - LBA, LBA48 and CHS. tf->protocol and
695 * flags select the address format to use.
696 *
697 * RETURNS:
698 * Block address read from @tf.
699 */
Hannes Reineckecffd1ee2016-04-04 11:43:57 +0200700u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
Tejun Heo35b649f2006-11-14 22:37:35 +0900701{
702 u64 block = 0;
703
Tejun Heofe16d4f2015-08-03 11:41:33 -0400704 if (tf->flags & ATA_TFLAG_LBA) {
Tejun Heo35b649f2006-11-14 22:37:35 +0900705 if (tf->flags & ATA_TFLAG_LBA48) {
706 block |= (u64)tf->hob_lbah << 40;
707 block |= (u64)tf->hob_lbam << 32;
Roland Dreier44901a92008-11-04 10:34:48 -0800708 block |= (u64)tf->hob_lbal << 24;
Tejun Heo35b649f2006-11-14 22:37:35 +0900709 } else
710 block |= (tf->device & 0xf) << 24;
711
712 block |= tf->lbah << 16;
713 block |= tf->lbam << 8;
714 block |= tf->lbal;
715 } else {
716 u32 cyl, head, sect;
717
718 cyl = tf->lbam | (tf->lbah << 8);
719 head = tf->device & 0xf;
720 sect = tf->lbal;
721
Tejun Heoac8672e2009-08-16 21:21:21 +0900722 if (!sect) {
Joe Perchesa9a79df2011-04-15 15:51:59 -0700723 ata_dev_warn(dev,
724 "device reported invalid CHS sector 0\n");
Hannes Reineckecffd1ee2016-04-04 11:43:57 +0200725 return U64_MAX;
Tejun Heoac8672e2009-08-16 21:21:21 +0900726 }
727
728 block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
Tejun Heo35b649f2006-11-14 22:37:35 +0900729 }
730
731 return block;
732}
733
734/**
Tejun Heobd056d72006-11-14 22:47:10 +0900735 * ata_build_rw_tf - Build ATA taskfile for given read/write request
736 * @tf: Target ATA taskfile
737 * @dev: ATA device @tf belongs to
738 * @block: Block address
739 * @n_block: Number of blocks
740 * @tf_flags: RW/FUA etc...
741 * @tag: tag
Adam Manzanares8e061782016-10-17 11:27:29 -0700742 * @class: IO priority class
Tejun Heobd056d72006-11-14 22:47:10 +0900743 *
744 * LOCKING:
745 * None.
746 *
747 * Build ATA taskfile @tf for read/write request described by
748 * @block, @n_block, @tf_flags and @tag on @dev.
749 *
750 * RETURNS:
751 *
752 * 0 on success, -ERANGE if the request is too large for @dev,
753 * -EINVAL if the request is invalid.
754 */
755int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
756 u64 block, u32 n_block, unsigned int tf_flags,
Adam Manzanares8e061782016-10-17 11:27:29 -0700757 unsigned int tag, int class)
Tejun Heobd056d72006-11-14 22:47:10 +0900758{
759 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
760 tf->flags |= tf_flags;
761
Tejun Heo6d1245b2007-02-20 23:20:27 +0900762 if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
Tejun Heobd056d72006-11-14 22:47:10 +0900763 /* yay, NCQ */
764 if (!lba_48_ok(block, n_block))
765 return -ERANGE;
766
767 tf->protocol = ATA_PROT_NCQ;
768 tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
769
770 if (tf->flags & ATA_TFLAG_WRITE)
771 tf->command = ATA_CMD_FPDMA_WRITE;
772 else
773 tf->command = ATA_CMD_FPDMA_READ;
774
775 tf->nsect = tag << 3;
776 tf->hob_feature = (n_block >> 8) & 0xff;
777 tf->feature = n_block & 0xff;
778
779 tf->hob_lbah = (block >> 40) & 0xff;
780 tf->hob_lbam = (block >> 32) & 0xff;
781 tf->hob_lbal = (block >> 24) & 0xff;
782 tf->lbah = (block >> 16) & 0xff;
783 tf->lbam = (block >> 8) & 0xff;
784 tf->lbal = block & 0xff;
785
Sergei Shtylyov9ca7cfa2012-08-21 22:18:50 +0400786 tf->device = ATA_LBA;
Tejun Heobd056d72006-11-14 22:47:10 +0900787 if (tf->flags & ATA_TFLAG_FUA)
788 tf->device |= 1 << 7;
Adam Manzanares8e061782016-10-17 11:27:29 -0700789
Adam Manzanares9f56eca2016-12-13 12:00:05 -0800790 if (dev->flags & ATA_DFLAG_NCQ_PRIO) {
Adam Manzanares8e061782016-10-17 11:27:29 -0700791 if (class == IOPRIO_CLASS_RT)
792 tf->hob_nsect |= ATA_PRIO_HIGH <<
793 ATA_SHIFT_PRIO;
794 }
Tejun Heobd056d72006-11-14 22:47:10 +0900795 } else if (dev->flags & ATA_DFLAG_LBA) {
796 tf->flags |= ATA_TFLAG_LBA;
797
798 if (lba_28_ok(block, n_block)) {
799 /* use LBA28 */
800 tf->device |= (block >> 24) & 0xf;
801 } else if (lba_48_ok(block, n_block)) {
802 if (!(dev->flags & ATA_DFLAG_LBA48))
803 return -ERANGE;
804
805 /* use LBA48 */
806 tf->flags |= ATA_TFLAG_LBA48;
807
808 tf->hob_nsect = (n_block >> 8) & 0xff;
809
810 tf->hob_lbah = (block >> 40) & 0xff;
811 tf->hob_lbam = (block >> 32) & 0xff;
812 tf->hob_lbal = (block >> 24) & 0xff;
813 } else
814 /* request too large even for LBA48 */
815 return -ERANGE;
816
817 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
818 return -EINVAL;
819
820 tf->nsect = n_block & 0xff;
821
822 tf->lbah = (block >> 16) & 0xff;
823 tf->lbam = (block >> 8) & 0xff;
824 tf->lbal = block & 0xff;
825
826 tf->device |= ATA_LBA;
827 } else {
828 /* CHS */
829 u32 sect, head, cyl, track;
830
831 /* The request -may- be too large for CHS addressing. */
832 if (!lba_28_ok(block, n_block))
833 return -ERANGE;
834
835 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
836 return -EINVAL;
837
838 /* Convert LBA to CHS */
839 track = (u32)block / dev->sectors;
840 cyl = track / dev->heads;
841 head = track % dev->heads;
842 sect = (u32)block % dev->sectors + 1;
843
844 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
845 (u32)block, track, cyl, head, sect);
846
847 /* Check whether the converted CHS can fit.
848 Cylinder: 0-65535
849 Head: 0-15
850 Sector: 1-255*/
851 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
852 return -ERANGE;
853
854 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
855 tf->lbal = sect;
856 tf->lbam = cyl;
857 tf->lbah = cyl >> 8;
858 tf->device |= head;
859 }
860
861 return 0;
862}
863
864/**
Tejun Heocb95d562006-03-06 04:31:56 +0900865 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
866 * @pio_mask: pio_mask
867 * @mwdma_mask: mwdma_mask
868 * @udma_mask: udma_mask
869 *
870 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
871 * unsigned int xfer_mask.
872 *
873 * LOCKING:
874 * None.
875 *
876 * RETURNS:
877 * Packed xfer_mask.
878 */
Tejun Heo7dc951a2007-11-27 19:43:42 +0900879unsigned long ata_pack_xfermask(unsigned long pio_mask,
880 unsigned long mwdma_mask,
881 unsigned long udma_mask)
Tejun Heocb95d562006-03-06 04:31:56 +0900882{
883 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
884 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
885 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
886}
887
Tejun Heoc0489e42006-03-24 14:07:49 +0900888/**
889 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
890 * @xfer_mask: xfer_mask to unpack
891 * @pio_mask: resulting pio_mask
892 * @mwdma_mask: resulting mwdma_mask
893 * @udma_mask: resulting udma_mask
894 *
895 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
Masanari Iidac9b55602016-04-13 23:36:27 +0900896 * Any NULL destination masks will be ignored.
Tejun Heoc0489e42006-03-24 14:07:49 +0900897 */
Tejun Heo7dc951a2007-11-27 19:43:42 +0900898void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask,
899 unsigned long *mwdma_mask, unsigned long *udma_mask)
Tejun Heoc0489e42006-03-24 14:07:49 +0900900{
901 if (pio_mask)
902 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
903 if (mwdma_mask)
904 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
905 if (udma_mask)
906 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
907}
908
Tejun Heocb95d562006-03-06 04:31:56 +0900909static const struct ata_xfer_ent {
Tejun Heobe9a50c2006-03-31 22:48:52 +0900910 int shift, bits;
Tejun Heocb95d562006-03-06 04:31:56 +0900911 u8 base;
912} ata_xfer_tbl[] = {
Tejun Heo70cd0712007-11-27 19:43:40 +0900913 { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 },
914 { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
915 { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 },
Tejun Heocb95d562006-03-06 04:31:56 +0900916 { -1, },
917};
918
919/**
920 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
921 * @xfer_mask: xfer_mask of interest
922 *
923 * Return matching XFER_* value for @xfer_mask. Only the highest
924 * bit of @xfer_mask is considered.
925 *
926 * LOCKING:
927 * None.
928 *
929 * RETURNS:
Tejun Heo70cd0712007-11-27 19:43:40 +0900930 * Matching XFER_* value, 0xff if no match found.
Tejun Heocb95d562006-03-06 04:31:56 +0900931 */
Tejun Heo7dc951a2007-11-27 19:43:42 +0900932u8 ata_xfer_mask2mode(unsigned long xfer_mask)
Tejun Heocb95d562006-03-06 04:31:56 +0900933{
934 int highbit = fls(xfer_mask) - 1;
935 const struct ata_xfer_ent *ent;
936
937 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
938 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
939 return ent->base + highbit - ent->shift;
Tejun Heo70cd0712007-11-27 19:43:40 +0900940 return 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +0900941}
942
943/**
944 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
945 * @xfer_mode: XFER_* of interest
946 *
947 * Return matching xfer_mask for @xfer_mode.
948 *
949 * LOCKING:
950 * None.
951 *
952 * RETURNS:
953 * Matching xfer_mask, 0 if no match found.
954 */
Tejun Heo7dc951a2007-11-27 19:43:42 +0900955unsigned long ata_xfer_mode2mask(u8 xfer_mode)
Tejun Heocb95d562006-03-06 04:31:56 +0900956{
957 const struct ata_xfer_ent *ent;
958
959 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
960 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
Tejun Heo70cd0712007-11-27 19:43:40 +0900961 return ((2 << (ent->shift + xfer_mode - ent->base)) - 1)
962 & ~((1 << ent->shift) - 1);
Tejun Heocb95d562006-03-06 04:31:56 +0900963 return 0;
964}
965
966/**
967 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
968 * @xfer_mode: XFER_* of interest
969 *
970 * Return matching xfer_shift for @xfer_mode.
971 *
972 * LOCKING:
973 * None.
974 *
975 * RETURNS:
976 * Matching xfer_shift, -1 if no match found.
977 */
Tejun Heo7dc951a2007-11-27 19:43:42 +0900978int ata_xfer_mode2shift(unsigned long xfer_mode)
Tejun Heocb95d562006-03-06 04:31:56 +0900979{
980 const struct ata_xfer_ent *ent;
981
982 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
983 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
984 return ent->shift;
985 return -1;
986}
987
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988/**
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900989 * ata_mode_string - convert xfer_mask to string
990 * @xfer_mask: mask of bits supported; only highest bit counts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 *
992 * Determine string which represents the highest speed
Tejun Heo1da7b0d2006-03-06 04:31:56 +0900993 * (highest bit in @modemask).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 *
995 * LOCKING:
996 * None.
997 *
998 * RETURNS:
999 * Constant C string representing highest speed listed in
Tejun Heo1da7b0d2006-03-06 04:31:56 +09001000 * @mode_mask, or the constant C string "<n/a>".
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 */
Tejun Heo7dc951a2007-11-27 19:43:42 +09001002const char *ata_mode_string(unsigned long xfer_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
Tejun Heo75f554b2006-03-06 04:31:57 +09001004 static const char * const xfer_mode_str[] = {
1005 "PIO0",
1006 "PIO1",
1007 "PIO2",
1008 "PIO3",
1009 "PIO4",
Alan Coxb352e572006-08-10 18:52:12 +01001010 "PIO5",
1011 "PIO6",
Tejun Heo75f554b2006-03-06 04:31:57 +09001012 "MWDMA0",
1013 "MWDMA1",
1014 "MWDMA2",
Alan Coxb352e572006-08-10 18:52:12 +01001015 "MWDMA3",
1016 "MWDMA4",
Tejun Heo75f554b2006-03-06 04:31:57 +09001017 "UDMA/16",
1018 "UDMA/25",
1019 "UDMA/33",
1020 "UDMA/44",
1021 "UDMA/66",
1022 "UDMA/100",
1023 "UDMA/133",
1024 "UDMA7",
1025 };
Tejun Heo1da7b0d2006-03-06 04:31:56 +09001026 int highbit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Tejun Heo1da7b0d2006-03-06 04:31:56 +09001028 highbit = fls(xfer_mask) - 1;
1029 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
1030 return xfer_mode_str[highbit];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 return "<n/a>";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032}
1033
Gwendal Grignoud9027472010-05-25 12:31:38 -07001034const char *sata_spd_string(unsigned int spd)
Tejun Heo4c360c82006-04-01 01:38:17 +09001035{
1036 static const char * const spd_str[] = {
1037 "1.5 Gbps",
1038 "3.0 Gbps",
Shane Huang8522ee22008-12-30 11:00:37 +08001039 "6.0 Gbps",
Tejun Heo4c360c82006-04-01 01:38:17 +09001040 };
1041
1042 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
1043 return "<unknown>";
1044 return spd_str[spd - 1];
1045}
1046
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047/**
1048 * ata_dev_classify - determine device type based on ATA-spec signature
1049 * @tf: ATA taskfile register set for device to be identified
1050 *
1051 * Determine from taskfile register contents whether a device is
1052 * ATA or ATAPI, as per "Signature and persistence" section
1053 * of ATA/PI spec (volume 1, sect 5.14).
1054 *
1055 * LOCKING:
1056 * None.
1057 *
1058 * RETURNS:
Hannes Reinecke9162c652014-11-05 13:08:21 +01001059 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP,
1060 * %ATA_DEV_ZAC, or %ATA_DEV_UNKNOWN the event of failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 */
Jeff Garzik057ace52005-10-22 14:27:05 -04001062unsigned int ata_dev_classify(const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063{
1064 /* Apple's open source Darwin code hints that some devices only
1065 * put a proper signature into the LBA mid/high registers,
1066 * So, we only check those. It's sufficient for uniqueness.
Tejun Heo633273a2007-09-23 13:19:54 +09001067 *
1068 * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
1069 * signatures for ATA and ATAPI devices attached on SerialATA,
1070 * 0x3c/0xc3 and 0x69/0x96 respectively. However, SerialATA
1071 * spec has never mentioned about using different signatures
1072 * for ATA/ATAPI devices. Then, Serial ATA II: Port
1073 * Multiplier specification began to use 0x69/0x96 to identify
1074 * port multpliers and 0x3c/0xc3 to identify SEMB device.
1075 * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
1076 * 0x69/0x96 shortly and described them as reserved for
1077 * SerialATA.
1078 *
1079 * We follow the current spec and consider that 0x69/0x96
1080 * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
Tejun Heo79b42ba2009-04-15 06:21:10 +09001081 * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports
1082 * SEMB signature. This is worked around in
1083 * ata_dev_read_id().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 */
Tejun Heo633273a2007-09-23 13:19:54 +09001085 if ((tf->lbam == 0) && (tf->lbah == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 DPRINTK("found ATA device by sig\n");
1087 return ATA_DEV_ATA;
1088 }
1089
Tejun Heo633273a2007-09-23 13:19:54 +09001090 if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 DPRINTK("found ATAPI device by sig\n");
1092 return ATA_DEV_ATAPI;
1093 }
1094
Tejun Heo633273a2007-09-23 13:19:54 +09001095 if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
1096 DPRINTK("found PMP device by sig\n");
1097 return ATA_DEV_PMP;
1098 }
1099
1100 if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
Tejun Heo79b42ba2009-04-15 06:21:10 +09001101 DPRINTK("found SEMB device by sig (could be ATA device)\n");
1102 return ATA_DEV_SEMB;
Tejun Heo633273a2007-09-23 13:19:54 +09001103 }
1104
Hannes Reinecke9162c652014-11-05 13:08:21 +01001105 if ((tf->lbam == 0xcd) && (tf->lbah == 0xab)) {
1106 DPRINTK("found ZAC device by sig\n");
1107 return ATA_DEV_ZAC;
1108 }
1109
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 DPRINTK("unknown device\n");
1111 return ATA_DEV_UNKNOWN;
1112}
1113
1114/**
Tejun Heo6a62a042006-02-13 10:02:46 +09001115 * ata_id_string - Convert IDENTIFY DEVICE page into string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 * @id: IDENTIFY DEVICE results we will examine
1117 * @s: string into which data is output
1118 * @ofs: offset into identify device page
1119 * @len: length of string to return. must be an even number.
1120 *
1121 * The strings in the IDENTIFY DEVICE page are broken up into
1122 * 16-bit chunks. Run through the string, and output each
1123 * 8-bit chunk linearly, regardless of platform.
1124 *
1125 * LOCKING:
1126 * caller.
1127 */
1128
Tejun Heo6a62a042006-02-13 10:02:46 +09001129void ata_id_string(const u16 *id, unsigned char *s,
1130 unsigned int ofs, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131{
1132 unsigned int c;
1133
Alan Cox963e4972008-07-24 17:16:06 +01001134 BUG_ON(len & 1);
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 while (len > 0) {
1137 c = id[ofs] >> 8;
1138 *s = c;
1139 s++;
1140
1141 c = id[ofs] & 0xff;
1142 *s = c;
1143 s++;
1144
1145 ofs++;
1146 len -= 2;
1147 }
1148}
1149
Tejun Heo0e949ff2006-02-12 22:47:04 +09001150/**
Tejun Heo6a62a042006-02-13 10:02:46 +09001151 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
Tejun Heo0e949ff2006-02-12 22:47:04 +09001152 * @id: IDENTIFY DEVICE results we will examine
1153 * @s: string into which data is output
1154 * @ofs: offset into identify device page
1155 * @len: length of string to return. must be an odd number.
1156 *
Tejun Heo6a62a042006-02-13 10:02:46 +09001157 * This function is identical to ata_id_string except that it
Tejun Heo0e949ff2006-02-12 22:47:04 +09001158 * trims trailing spaces and terminates the resulting string with
1159 * null. @len must be actual maximum length (even number) + 1.
1160 *
1161 * LOCKING:
1162 * caller.
1163 */
Tejun Heo6a62a042006-02-13 10:02:46 +09001164void ata_id_c_string(const u16 *id, unsigned char *s,
1165 unsigned int ofs, unsigned int len)
Tejun Heo0e949ff2006-02-12 22:47:04 +09001166{
1167 unsigned char *p;
1168
Tejun Heo6a62a042006-02-13 10:02:46 +09001169 ata_id_string(id, s, ofs, len - 1);
Tejun Heo0e949ff2006-02-12 22:47:04 +09001170
1171 p = s + strnlen(s, len - 1);
1172 while (p > s && p[-1] == ' ')
1173 p--;
1174 *p = '\0';
1175}
Edward Falk0baab862005-06-02 18:17:13 -04001176
Tejun Heodb6f8752007-09-03 12:31:58 +09001177static u64 ata_id_n_sectors(const u16 *id)
1178{
1179 if (ata_id_has_lba(id)) {
1180 if (ata_id_has_lba48(id))
Robert Hancock968e5942009-02-16 20:15:08 -06001181 return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
Tejun Heodb6f8752007-09-03 12:31:58 +09001182 else
Robert Hancock968e5942009-02-16 20:15:08 -06001183 return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
Tejun Heodb6f8752007-09-03 12:31:58 +09001184 } else {
1185 if (ata_id_current_chs_valid(id))
Robert Hancock968e5942009-02-16 20:15:08 -06001186 return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
1187 id[ATA_ID_CUR_SECTORS];
Tejun Heodb6f8752007-09-03 12:31:58 +09001188 else
Robert Hancock968e5942009-02-16 20:15:08 -06001189 return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
1190 id[ATA_ID_SECTORS];
Tejun Heodb6f8752007-09-03 12:31:58 +09001191 }
1192}
1193
Tejun Heoa5987e02008-03-27 19:14:23 +09001194u64 ata_tf_to_lba48(const struct ata_taskfile *tf)
Alan Cox1e999732007-04-11 00:23:13 +01001195{
1196 u64 sectors = 0;
1197
1198 sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
1199 sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
Roland Dreierba14a9c2008-10-28 16:52:20 -07001200 sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
Alan Cox1e999732007-04-11 00:23:13 +01001201 sectors |= (tf->lbah & 0xff) << 16;
1202 sectors |= (tf->lbam & 0xff) << 8;
1203 sectors |= (tf->lbal & 0xff);
1204
Tejun Heoa5987e02008-03-27 19:14:23 +09001205 return sectors;
Alan Cox1e999732007-04-11 00:23:13 +01001206}
1207
Tejun Heoa5987e02008-03-27 19:14:23 +09001208u64 ata_tf_to_lba(const struct ata_taskfile *tf)
Alan Cox1e999732007-04-11 00:23:13 +01001209{
1210 u64 sectors = 0;
1211
1212 sectors |= (tf->device & 0x0f) << 24;
1213 sectors |= (tf->lbah & 0xff) << 16;
1214 sectors |= (tf->lbam & 0xff) << 8;
1215 sectors |= (tf->lbal & 0xff);
1216
Tejun Heoa5987e02008-03-27 19:14:23 +09001217 return sectors;
Alan Cox1e999732007-04-11 00:23:13 +01001218}
1219
1220/**
Tejun Heoc728a912007-09-03 12:32:30 +09001221 * ata_read_native_max_address - Read native max address
1222 * @dev: target device
1223 * @max_sectors: out parameter for the result native max address
Alan Cox1e999732007-04-11 00:23:13 +01001224 *
Tejun Heoc728a912007-09-03 12:32:30 +09001225 * Perform an LBA48 or LBA28 native size query upon the device in
1226 * question.
1227 *
1228 * RETURNS:
1229 * 0 on success, -EACCES if command is aborted by the drive.
1230 * -EIO on other errors.
Alan Cox1e999732007-04-11 00:23:13 +01001231 */
Tejun Heoc728a912007-09-03 12:32:30 +09001232static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
Alan Cox1e999732007-04-11 00:23:13 +01001233{
Tejun Heoc728a912007-09-03 12:32:30 +09001234 unsigned int err_mask;
Alan Cox1e999732007-04-11 00:23:13 +01001235 struct ata_taskfile tf;
Tejun Heoc728a912007-09-03 12:32:30 +09001236 int lba48 = ata_id_has_lba48(dev->id);
Alan Cox1e999732007-04-11 00:23:13 +01001237
1238 ata_tf_init(dev, &tf);
1239
Tejun Heoc728a912007-09-03 12:32:30 +09001240 /* always clear all address registers */
Alan Cox1e999732007-04-11 00:23:13 +01001241 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
Tejun Heoc728a912007-09-03 12:32:30 +09001242
1243 if (lba48) {
1244 tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
1245 tf.flags |= ATA_TFLAG_LBA48;
1246 } else
1247 tf.command = ATA_CMD_READ_NATIVE_MAX;
1248
Hannes Reineckebd18bc02016-07-14 09:05:46 +09001249 tf.protocol = ATA_PROT_NODATA;
Tejun Heoc728a912007-09-03 12:32:30 +09001250 tf.device |= ATA_LBA;
Alan Cox1e999732007-04-11 00:23:13 +01001251
Tejun Heo2b789102007-10-09 15:05:44 +09001252 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
Tejun Heoc728a912007-09-03 12:32:30 +09001253 if (err_mask) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001254 ata_dev_warn(dev,
1255 "failed to read native max address (err_mask=0x%x)\n",
1256 err_mask);
Tejun Heoc728a912007-09-03 12:32:30 +09001257 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
1258 return -EACCES;
1259 return -EIO;
1260 }
Alan Cox1e999732007-04-11 00:23:13 +01001261
Tejun Heoc728a912007-09-03 12:32:30 +09001262 if (lba48)
Tejun Heoa5987e02008-03-27 19:14:23 +09001263 *max_sectors = ata_tf_to_lba48(&tf) + 1;
Tejun Heoc728a912007-09-03 12:32:30 +09001264 else
Tejun Heoa5987e02008-03-27 19:14:23 +09001265 *max_sectors = ata_tf_to_lba(&tf) + 1;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001266 if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
Alan Cox93328e12007-09-29 04:06:48 -04001267 (*max_sectors)--;
Tejun Heoc728a912007-09-03 12:32:30 +09001268 return 0;
Alan Cox1e999732007-04-11 00:23:13 +01001269}
1270
1271/**
Tejun Heoc728a912007-09-03 12:32:30 +09001272 * ata_set_max_sectors - Set max sectors
1273 * @dev: target device
Randy Dunlap6b38d1d2007-05-01 17:35:55 -07001274 * @new_sectors: new max sectors value to set for the device
Alan Cox1e999732007-04-11 00:23:13 +01001275 *
Tejun Heoc728a912007-09-03 12:32:30 +09001276 * Set max sectors of @dev to @new_sectors.
1277 *
1278 * RETURNS:
1279 * 0 on success, -EACCES if command is aborted or denied (due to
1280 * previous non-volatile SET_MAX) by the drive. -EIO on other
1281 * errors.
Alan Cox1e999732007-04-11 00:23:13 +01001282 */
Tejun Heo05027ad2007-09-03 12:32:57 +09001283static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
Alan Cox1e999732007-04-11 00:23:13 +01001284{
Tejun Heoc728a912007-09-03 12:32:30 +09001285 unsigned int err_mask;
Alan Cox1e999732007-04-11 00:23:13 +01001286 struct ata_taskfile tf;
Tejun Heoc728a912007-09-03 12:32:30 +09001287 int lba48 = ata_id_has_lba48(dev->id);
Alan Cox1e999732007-04-11 00:23:13 +01001288
1289 new_sectors--;
1290
1291 ata_tf_init(dev, &tf);
1292
Alan Cox1e999732007-04-11 00:23:13 +01001293 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
Tejun Heoc728a912007-09-03 12:32:30 +09001294
1295 if (lba48) {
1296 tf.command = ATA_CMD_SET_MAX_EXT;
1297 tf.flags |= ATA_TFLAG_LBA48;
1298
1299 tf.hob_lbal = (new_sectors >> 24) & 0xff;
1300 tf.hob_lbam = (new_sectors >> 32) & 0xff;
1301 tf.hob_lbah = (new_sectors >> 40) & 0xff;
Tejun Heo1e582ba2007-09-21 20:07:14 +09001302 } else {
Tejun Heoc728a912007-09-03 12:32:30 +09001303 tf.command = ATA_CMD_SET_MAX;
1304
Tejun Heo1e582ba2007-09-21 20:07:14 +09001305 tf.device |= (new_sectors >> 24) & 0xf;
1306 }
1307
Hannes Reineckebd18bc02016-07-14 09:05:46 +09001308 tf.protocol = ATA_PROT_NODATA;
Tejun Heoc728a912007-09-03 12:32:30 +09001309 tf.device |= ATA_LBA;
Alan Cox1e999732007-04-11 00:23:13 +01001310
1311 tf.lbal = (new_sectors >> 0) & 0xff;
1312 tf.lbam = (new_sectors >> 8) & 0xff;
1313 tf.lbah = (new_sectors >> 16) & 0xff;
Alan Cox1e999732007-04-11 00:23:13 +01001314
Tejun Heo2b789102007-10-09 15:05:44 +09001315 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
Tejun Heoc728a912007-09-03 12:32:30 +09001316 if (err_mask) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001317 ata_dev_warn(dev,
1318 "failed to set max address (err_mask=0x%x)\n",
1319 err_mask);
Tejun Heoc728a912007-09-03 12:32:30 +09001320 if (err_mask == AC_ERR_DEV &&
1321 (tf.feature & (ATA_ABORTED | ATA_IDNF)))
1322 return -EACCES;
1323 return -EIO;
1324 }
Alan Cox1e999732007-04-11 00:23:13 +01001325
Tejun Heoc728a912007-09-03 12:32:30 +09001326 return 0;
Alan Cox1e999732007-04-11 00:23:13 +01001327}
1328
1329/**
1330 * ata_hpa_resize - Resize a device with an HPA set
1331 * @dev: Device to resize
1332 *
1333 * Read the size of an LBA28 or LBA48 disk with HPA features and resize
1334 * it if required to the full size of the media. The caller must check
1335 * the drive has the HPA feature set enabled.
Tejun Heo05027ad2007-09-03 12:32:57 +09001336 *
1337 * RETURNS:
1338 * 0 on success, -errno on failure.
Alan Cox1e999732007-04-11 00:23:13 +01001339 */
Tejun Heo05027ad2007-09-03 12:32:57 +09001340static int ata_hpa_resize(struct ata_device *dev)
Alan Cox1e999732007-04-11 00:23:13 +01001341{
Tejun Heo05027ad2007-09-03 12:32:57 +09001342 struct ata_eh_context *ehc = &dev->link->eh_context;
1343 int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
Tejun Heo445d2112010-04-05 10:33:13 +09001344 bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;
Tejun Heo05027ad2007-09-03 12:32:57 +09001345 u64 sectors = ata_id_n_sectors(dev->id);
1346 u64 native_sectors;
Tejun Heoc728a912007-09-03 12:32:30 +09001347 int rc;
Jeff Garzika617c092007-05-21 20:14:23 -04001348
Tejun Heo05027ad2007-09-03 12:32:57 +09001349 /* do we need to do it? */
Hannes Reinecke9162c652014-11-05 13:08:21 +01001350 if ((dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) ||
Tejun Heo05027ad2007-09-03 12:32:57 +09001351 !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
1352 (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
Tejun Heoc728a912007-09-03 12:32:30 +09001353 return 0;
Alan Cox1e999732007-04-11 00:23:13 +01001354
Tejun Heo05027ad2007-09-03 12:32:57 +09001355 /* read native max address */
1356 rc = ata_read_native_max_address(dev, &native_sectors);
1357 if (rc) {
Tejun Heodda7aba2008-03-23 21:05:15 +09001358 /* If device aborted the command or HPA isn't going to
1359 * be unlocked, skip HPA resizing.
Tejun Heo05027ad2007-09-03 12:32:57 +09001360 */
Tejun Heo445d2112010-04-05 10:33:13 +09001361 if (rc == -EACCES || !unlock_hpa) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001362 ata_dev_warn(dev,
1363 "HPA support seems broken, skipping HPA handling\n");
Tejun Heo05027ad2007-09-03 12:32:57 +09001364 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
Alan Cox1e999732007-04-11 00:23:13 +01001365
Tejun Heo05027ad2007-09-03 12:32:57 +09001366 /* we can continue if device aborted the command */
1367 if (rc == -EACCES)
1368 rc = 0;
Alan Cox1e999732007-04-11 00:23:13 +01001369 }
Tejun Heo37301a52007-06-25 20:45:54 +09001370
Tejun Heo05027ad2007-09-03 12:32:57 +09001371 return rc;
1372 }
Tejun Heo5920dad2009-07-15 17:11:41 +09001373 dev->n_native_sectors = native_sectors;
Tejun Heo05027ad2007-09-03 12:32:57 +09001374
1375 /* nothing to do? */
Tejun Heo445d2112010-04-05 10:33:13 +09001376 if (native_sectors <= sectors || !unlock_hpa) {
Tejun Heo05027ad2007-09-03 12:32:57 +09001377 if (!print_info || native_sectors == sectors)
1378 return 0;
1379
1380 if (native_sectors > sectors)
Joe Perchesa9a79df2011-04-15 15:51:59 -07001381 ata_dev_info(dev,
Tejun Heo05027ad2007-09-03 12:32:57 +09001382 "HPA detected: current %llu, native %llu\n",
1383 (unsigned long long)sectors,
1384 (unsigned long long)native_sectors);
1385 else if (native_sectors < sectors)
Joe Perchesa9a79df2011-04-15 15:51:59 -07001386 ata_dev_warn(dev,
1387 "native sectors (%llu) is smaller than sectors (%llu)\n",
Tejun Heo05027ad2007-09-03 12:32:57 +09001388 (unsigned long long)native_sectors,
1389 (unsigned long long)sectors);
1390 return 0;
1391 }
1392
1393 /* let's unlock HPA */
1394 rc = ata_set_max_sectors(dev, native_sectors);
1395 if (rc == -EACCES) {
1396 /* if device aborted the command, skip HPA resizing */
Joe Perchesa9a79df2011-04-15 15:51:59 -07001397 ata_dev_warn(dev,
1398 "device aborted resize (%llu -> %llu), skipping HPA handling\n",
1399 (unsigned long long)sectors,
1400 (unsigned long long)native_sectors);
Tejun Heo05027ad2007-09-03 12:32:57 +09001401 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1402 return 0;
1403 } else if (rc)
1404 return rc;
1405
1406 /* re-read IDENTIFY data */
1407 rc = ata_dev_reread_id(dev, 0);
1408 if (rc) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001409 ata_dev_err(dev,
1410 "failed to re-read IDENTIFY data after HPA resizing\n");
Tejun Heo05027ad2007-09-03 12:32:57 +09001411 return rc;
1412 }
1413
1414 if (print_info) {
1415 u64 new_sectors = ata_id_n_sectors(dev->id);
Joe Perchesa9a79df2011-04-15 15:51:59 -07001416 ata_dev_info(dev,
Tejun Heo05027ad2007-09-03 12:32:57 +09001417 "HPA unlocked: %llu -> %llu, native %llu\n",
1418 (unsigned long long)sectors,
1419 (unsigned long long)new_sectors,
1420 (unsigned long long)native_sectors);
1421 }
1422
1423 return 0;
Alan Cox1e999732007-04-11 00:23:13 +01001424}
1425
Edward Falk0baab862005-06-02 18:17:13 -04001426/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 * ata_dump_id - IDENTIFY DEVICE info debugging output
Tejun Heo0bd33002006-02-12 22:47:05 +09001428 * @id: IDENTIFY DEVICE page to dump
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 *
Tejun Heo0bd33002006-02-12 22:47:05 +09001430 * Dump selected 16-bit words from the given IDENTIFY DEVICE
1431 * page.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 *
1433 * LOCKING:
1434 * caller.
1435 */
1436
Tejun Heo0bd33002006-02-12 22:47:05 +09001437static inline void ata_dump_id(const u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438{
1439 DPRINTK("49==0x%04x "
1440 "53==0x%04x "
1441 "63==0x%04x "
1442 "64==0x%04x "
1443 "75==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +09001444 id[49],
1445 id[53],
1446 id[63],
1447 id[64],
1448 id[75]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 DPRINTK("80==0x%04x "
1450 "81==0x%04x "
1451 "82==0x%04x "
1452 "83==0x%04x "
1453 "84==0x%04x \n",
Tejun Heo0bd33002006-02-12 22:47:05 +09001454 id[80],
1455 id[81],
1456 id[82],
1457 id[83],
1458 id[84]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 DPRINTK("88==0x%04x "
1460 "93==0x%04x\n",
Tejun Heo0bd33002006-02-12 22:47:05 +09001461 id[88],
1462 id[93]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463}
1464
Tejun Heocb95d562006-03-06 04:31:56 +09001465/**
1466 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
1467 * @id: IDENTIFY data to compute xfer mask from
1468 *
1469 * Compute the xfermask for this device. This is not as trivial
1470 * as it seems if we must consider early devices correctly.
1471 *
1472 * FIXME: pre IDE drive timing (do we care ?).
1473 *
1474 * LOCKING:
1475 * None.
1476 *
1477 * RETURNS:
1478 * Computed xfermask
1479 */
Tejun Heo7dc951a2007-11-27 19:43:42 +09001480unsigned long ata_id_xfermask(const u16 *id)
Tejun Heocb95d562006-03-06 04:31:56 +09001481{
Tejun Heo7dc951a2007-11-27 19:43:42 +09001482 unsigned long pio_mask, mwdma_mask, udma_mask;
Tejun Heocb95d562006-03-06 04:31:56 +09001483
1484 /* Usual case. Word 53 indicates word 64 is valid */
1485 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1486 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1487 pio_mask <<= 3;
1488 pio_mask |= 0x7;
1489 } else {
1490 /* If word 64 isn't valid then Word 51 high byte holds
1491 * the PIO timing number for the maximum. Turn it into
1492 * a mask.
1493 */
Lennert Buytenhek7a0f1c82007-01-29 13:28:47 +01001494 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
Alan Cox46767aeb2006-09-29 18:26:47 +01001495 if (mode < 5) /* Valid PIO range */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001496 pio_mask = (2 << mode) - 1;
Alan Cox46767aeb2006-09-29 18:26:47 +01001497 else
1498 pio_mask = 1;
Tejun Heocb95d562006-03-06 04:31:56 +09001499
1500 /* But wait.. there's more. Design your standards by
1501 * committee and you too can get a free iordy field to
1502 * process. However its the speeds not the modes that
1503 * are supported... Note drivers using the timing API
1504 * will get this right anyway
1505 */
1506 }
1507
1508 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
Tejun Heofb21f0d2006-03-12 12:34:35 +09001509
Alan Coxb352e572006-08-10 18:52:12 +01001510 if (ata_id_is_cfa(id)) {
1511 /*
1512 * Process compact flash extended modes
1513 */
Sergei Shtylyov62afe5d2009-04-13 20:50:00 +04001514 int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
1515 int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;
Alan Coxb352e572006-08-10 18:52:12 +01001516
1517 if (pio)
1518 pio_mask |= (1 << 5);
1519 if (pio > 1)
1520 pio_mask |= (1 << 6);
1521 if (dma)
1522 mwdma_mask |= (1 << 3);
1523 if (dma > 1)
1524 mwdma_mask |= (1 << 4);
1525 }
1526
Tejun Heofb21f0d2006-03-12 12:34:35 +09001527 udma_mask = 0;
1528 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1529 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
Tejun Heocb95d562006-03-06 04:31:56 +09001530
1531 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1532}
1533
Adrian Bunk7102d232007-01-04 00:09:36 +01001534static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
Tejun Heoa2a7a662005-12-13 14:48:31 +09001535{
Tejun Heo77853bf2006-01-23 13:09:36 +09001536 struct completion *waiting = qc->private_data;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001537
Tejun Heoa2a7a662005-12-13 14:48:31 +09001538 complete(waiting);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001539}
1540
1541/**
Tejun Heo24326972006-11-14 22:47:09 +09001542 * ata_exec_internal_sg - execute libata internal command
Tejun Heoa2a7a662005-12-13 14:48:31 +09001543 * @dev: Device to which the command is sent
1544 * @tf: Taskfile registers for the command and the result
Tejun Heod69cf372006-04-02 18:51:53 +09001545 * @cdb: CDB for packet command
Masanari Iidae2278672014-02-18 22:54:36 +09001546 * @dma_dir: Data transfer direction of the command
Randy Dunlap5c1ad8b2007-10-18 14:12:26 -07001547 * @sgl: sg list for the data buffer of the command
Tejun Heo24326972006-11-14 22:47:09 +09001548 * @n_elem: Number of sg entries
Tejun Heo2b789102007-10-09 15:05:44 +09001549 * @timeout: Timeout in msecs (0 for default)
Tejun Heoa2a7a662005-12-13 14:48:31 +09001550 *
1551 * Executes libata internal command with timeout. @tf contains
1552 * command on entry and result on return. Timeout and error
1553 * conditions are reported via return value. No recovery action
1554 * is taken after a command times out. It's caller's duty to
1555 * clean up after timeout.
1556 *
1557 * LOCKING:
1558 * None. Should be called with kernel context, might sleep.
Tejun Heo551e8882006-06-12 14:09:49 +09001559 *
1560 * RETURNS:
1561 * Zero on success, AC_ERR_* mask on failure
Tejun Heoa2a7a662005-12-13 14:48:31 +09001562 */
Tejun Heo24326972006-11-14 22:47:09 +09001563unsigned ata_exec_internal_sg(struct ata_device *dev,
1564 struct ata_taskfile *tf, const u8 *cdb,
Jens Axboe87260212007-10-16 11:14:12 +02001565 int dma_dir, struct scatterlist *sgl,
Tejun Heo2b789102007-10-09 15:05:44 +09001566 unsigned int n_elem, unsigned long timeout)
Tejun Heoa2a7a662005-12-13 14:48:31 +09001567{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001568 struct ata_link *link = dev->link;
1569 struct ata_port *ap = link->ap;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001570 u8 command = tf->command;
Tejun Heo87fbc5a2008-05-20 02:17:54 +09001571 int auto_timeout = 0;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001572 struct ata_queued_cmd *qc;
Tejun Heo2ab7db12006-05-15 20:58:02 +09001573 unsigned int tag, preempted_tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001574 u32 preempted_sactive, preempted_qc_active;
Tejun Heoda917d62007-09-23 13:14:12 +09001575 int preempted_nr_active_links;
Ingo Molnar60be6b92006-07-03 00:25:26 -07001576 DECLARE_COMPLETION_ONSTACK(wait);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001577 unsigned long flags;
Tejun Heo77853bf2006-01-23 13:09:36 +09001578 unsigned int err_mask;
Tejun Heod95a7172006-05-15 20:58:14 +09001579 int rc;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001580
Jeff Garzikba6a1302006-06-22 23:46:10 -04001581 spin_lock_irqsave(ap->lock, flags);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001582
Tejun Heoe3180492006-05-15 20:58:09 +09001583 /* no internal command while frozen */
Tejun Heob51e9e52006-06-29 01:29:30 +09001584 if (ap->pflags & ATA_PFLAG_FROZEN) {
Jeff Garzikba6a1302006-06-22 23:46:10 -04001585 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001586 return AC_ERR_SYSTEM;
1587 }
1588
Tejun Heo2ab7db12006-05-15 20:58:02 +09001589 /* initialize internal qc */
Tejun Heoa2a7a662005-12-13 14:48:31 +09001590
Tejun Heo2ab7db12006-05-15 20:58:02 +09001591 /* XXX: Tag 0 is used for drivers with legacy EH as some
1592 * drivers choke if any other tag is given. This breaks
1593 * ata_tag_internal() test for those drivers. Don't use new
1594 * EH stuff without converting to it.
1595 */
1596 if (ap->ops->error_handler)
1597 tag = ATA_TAG_INTERNAL;
1598 else
1599 tag = 0;
1600
Tejun Heof69499f2006-05-15 20:58:03 +09001601 qc = __ata_qc_from_tag(ap, tag);
Tejun Heo2ab7db12006-05-15 20:58:02 +09001602
1603 qc->tag = tag;
1604 qc->scsicmd = NULL;
1605 qc->ap = ap;
1606 qc->dev = dev;
1607 ata_qc_reinit(qc);
1608
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001609 preempted_tag = link->active_tag;
1610 preempted_sactive = link->sactive;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001611 preempted_qc_active = ap->qc_active;
Tejun Heoda917d62007-09-23 13:14:12 +09001612 preempted_nr_active_links = ap->nr_active_links;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001613 link->active_tag = ATA_TAG_POISON;
1614 link->sactive = 0;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001615 ap->qc_active = 0;
Tejun Heoda917d62007-09-23 13:14:12 +09001616 ap->nr_active_links = 0;
Tejun Heo2ab7db12006-05-15 20:58:02 +09001617
1618 /* prepare & issue qc */
Tejun Heoa2a7a662005-12-13 14:48:31 +09001619 qc->tf = *tf;
Tejun Heod69cf372006-04-02 18:51:53 +09001620 if (cdb)
1621 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
Vincent Pelletiere7714512013-05-18 18:44:04 +02001622
1623 /* some SATA bridges need us to indicate data xfer direction */
1624 if (tf->protocol == ATAPI_PROT_DMA && (dev->flags & ATA_DFLAG_DMADIR) &&
1625 dma_dir == DMA_FROM_DEVICE)
1626 qc->tf.feature |= ATAPI_DMADIR;
1627
Tejun Heoe61e0672006-05-15 20:57:40 +09001628 qc->flags |= ATA_QCFLAG_RESULT_TF;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001629 qc->dma_dir = dma_dir;
1630 if (dma_dir != DMA_NONE) {
Tejun Heo24326972006-11-14 22:47:09 +09001631 unsigned int i, buflen = 0;
Jens Axboe87260212007-10-16 11:14:12 +02001632 struct scatterlist *sg;
Tejun Heo24326972006-11-14 22:47:09 +09001633
Jens Axboe87260212007-10-16 11:14:12 +02001634 for_each_sg(sgl, sg, n_elem, i)
1635 buflen += sg->length;
Tejun Heo24326972006-11-14 22:47:09 +09001636
Jens Axboe87260212007-10-16 11:14:12 +02001637 ata_sg_init(qc, sgl, n_elem);
Brian King49c80422007-01-30 11:32:26 -06001638 qc->nbytes = buflen;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001639 }
1640
Tejun Heo77853bf2006-01-23 13:09:36 +09001641 qc->private_data = &wait;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001642 qc->complete_fn = ata_qc_complete_internal;
1643
Tejun Heo8e0e6942006-03-31 20:41:11 +09001644 ata_qc_issue(qc);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001645
Jeff Garzikba6a1302006-06-22 23:46:10 -04001646 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001647
Tejun Heo87fbc5a2008-05-20 02:17:54 +09001648 if (!timeout) {
1649 if (ata_probe_timeout)
1650 timeout = ata_probe_timeout * 1000;
1651 else {
1652 timeout = ata_internal_cmd_timeout(dev, command);
1653 auto_timeout = 1;
1654 }
1655 }
Tejun Heo2b789102007-10-09 15:05:44 +09001656
Tejun Heoc0c362b2010-09-06 17:57:14 +02001657 if (ap->ops->error_handler)
1658 ata_eh_release(ap);
1659
Tejun Heo2b789102007-10-09 15:05:44 +09001660 rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
Albert Lee41ade502006-03-14 11:19:04 +08001661
Tejun Heoc0c362b2010-09-06 17:57:14 +02001662 if (ap->ops->error_handler)
1663 ata_eh_acquire(ap);
1664
Tejun Heoc4291372010-05-10 21:41:38 +02001665 ata_sff_flush_pio_task(ap);
Tejun Heod95a7172006-05-15 20:58:14 +09001666
1667 if (!rc) {
Jeff Garzikba6a1302006-06-22 23:46:10 -04001668 spin_lock_irqsave(ap->lock, flags);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001669
1670 /* We're racing with irq here. If we lose, the
1671 * following test prevents us from completing the qc
Tejun Heod95a7172006-05-15 20:58:14 +09001672 * twice. If we win, the port is frozen and will be
1673 * cleaned up by ->post_internal_cmd().
Tejun Heoa2a7a662005-12-13 14:48:31 +09001674 */
Tejun Heo77853bf2006-01-23 13:09:36 +09001675 if (qc->flags & ATA_QCFLAG_ACTIVE) {
Tejun Heod95a7172006-05-15 20:58:14 +09001676 qc->err_mask |= AC_ERR_TIMEOUT;
1677
1678 if (ap->ops->error_handler)
1679 ata_port_freeze(ap);
1680 else
1681 ata_qc_complete(qc);
Tejun Heof15a1da2006-05-15 20:57:56 +09001682
Borislav Petkov0dd4b212006-06-23 02:29:08 -04001683 if (ata_msg_warn(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07001684 ata_dev_warn(dev, "qc timeout (cmd 0x%x)\n",
1685 command);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001686 }
1687
Jeff Garzikba6a1302006-06-22 23:46:10 -04001688 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa2a7a662005-12-13 14:48:31 +09001689 }
1690
Tejun Heod95a7172006-05-15 20:58:14 +09001691 /* do post_internal_cmd */
1692 if (ap->ops->post_internal_cmd)
1693 ap->ops->post_internal_cmd(qc);
1694
Tejun Heoa51d6442007-03-20 15:24:11 +09001695 /* perform minimal error analysis */
1696 if (qc->flags & ATA_QCFLAG_FAILED) {
1697 if (qc->result_tf.command & (ATA_ERR | ATA_DF))
1698 qc->err_mask |= AC_ERR_DEV;
1699
1700 if (!qc->err_mask)
1701 qc->err_mask |= AC_ERR_OTHER;
1702
1703 if (qc->err_mask & ~AC_ERR_OTHER)
1704 qc->err_mask &= ~AC_ERR_OTHER;
Tejun Heod95a7172006-05-15 20:58:14 +09001705 }
1706
Tejun Heo15869302006-05-15 20:57:33 +09001707 /* finish up */
Jeff Garzikba6a1302006-06-22 23:46:10 -04001708 spin_lock_irqsave(ap->lock, flags);
Tejun Heo15869302006-05-15 20:57:33 +09001709
Tejun Heoe61e0672006-05-15 20:57:40 +09001710 *tf = qc->result_tf;
Tejun Heo77853bf2006-01-23 13:09:36 +09001711 err_mask = qc->err_mask;
1712
1713 ata_qc_free(qc);
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001714 link->active_tag = preempted_tag;
1715 link->sactive = preempted_sactive;
Tejun Heodedaf2b2006-05-15 21:03:43 +09001716 ap->qc_active = preempted_qc_active;
Tejun Heoda917d62007-09-23 13:14:12 +09001717 ap->nr_active_links = preempted_nr_active_links;
Tejun Heo77853bf2006-01-23 13:09:36 +09001718
Jeff Garzikba6a1302006-06-22 23:46:10 -04001719 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo15869302006-05-15 20:57:33 +09001720
Tejun Heo87fbc5a2008-05-20 02:17:54 +09001721 if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
1722 ata_internal_cmd_timed_out(dev, command);
1723
Tejun Heo77853bf2006-01-23 13:09:36 +09001724 return err_mask;
Tejun Heoa2a7a662005-12-13 14:48:31 +09001725}
1726
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727/**
Tejun Heo33480a02006-12-12 02:15:31 +09001728 * ata_exec_internal - execute libata internal command
Tejun Heo24326972006-11-14 22:47:09 +09001729 * @dev: Device to which the command is sent
1730 * @tf: Taskfile registers for the command and the result
1731 * @cdb: CDB for packet command
Masanari Iidae2278672014-02-18 22:54:36 +09001732 * @dma_dir: Data transfer direction of the command
Tejun Heo24326972006-11-14 22:47:09 +09001733 * @buf: Data buffer of the command
1734 * @buflen: Length of data buffer
Tejun Heo2b789102007-10-09 15:05:44 +09001735 * @timeout: Timeout in msecs (0 for default)
Tejun Heo24326972006-11-14 22:47:09 +09001736 *
1737 * Wrapper around ata_exec_internal_sg() which takes simple
1738 * buffer instead of sg list.
1739 *
1740 * LOCKING:
1741 * None. Should be called with kernel context, might sleep.
1742 *
1743 * RETURNS:
1744 * Zero on success, AC_ERR_* mask on failure
1745 */
1746unsigned ata_exec_internal(struct ata_device *dev,
1747 struct ata_taskfile *tf, const u8 *cdb,
Tejun Heo2b789102007-10-09 15:05:44 +09001748 int dma_dir, void *buf, unsigned int buflen,
1749 unsigned long timeout)
Tejun Heo24326972006-11-14 22:47:09 +09001750{
Tejun Heo33480a02006-12-12 02:15:31 +09001751 struct scatterlist *psg = NULL, sg;
1752 unsigned int n_elem = 0;
Tejun Heo24326972006-11-14 22:47:09 +09001753
Tejun Heo33480a02006-12-12 02:15:31 +09001754 if (dma_dir != DMA_NONE) {
1755 WARN_ON(!buf);
1756 sg_init_one(&sg, buf, buflen);
1757 psg = &sg;
1758 n_elem++;
1759 }
Tejun Heo24326972006-11-14 22:47:09 +09001760
Tejun Heo2b789102007-10-09 15:05:44 +09001761 return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
1762 timeout);
Tejun Heo24326972006-11-14 22:47:09 +09001763}
1764
1765/**
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001766 * ata_pio_need_iordy - check if iordy needed
1767 * @adev: ATA device
1768 *
1769 * Check if the current speed of the device requires IORDY. Used
1770 * by various controllers for chip configuration.
1771 */
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001772unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1773{
Tejun Heo0d9e6652009-06-11 11:04:45 +09001774 /* Don't set IORDY if we're preparing for reset. IORDY may
1775 * lead to controller lock up on certain controllers if the
1776 * port is not occupied. See bko#11703 for details.
1777 */
1778 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1779 return 0;
1780 /* Controller doesn't support IORDY. Probably a pointless
1781 * check as the caller should know this.
1782 */
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001783 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001784 return 0;
David Daney5c18c4d2008-12-10 15:39:12 -08001785 /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6. */
1786 if (ata_id_is_cfa(adev->id)
1787 && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
1788 return 0;
Alan Cox432729f2007-03-08 23:22:59 +00001789 /* PIO3 and higher it is mandatory */
1790 if (adev->pio_mode > XFER_PIO_2)
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001791 return 1;
Alan Cox432729f2007-03-08 23:22:59 +00001792 /* We turn it on when possible */
1793 if (ata_id_has_iordy(adev->id))
1794 return 1;
1795 return 0;
1796}
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001797
Alan Cox432729f2007-03-08 23:22:59 +00001798/**
1799 * ata_pio_mask_no_iordy - Return the non IORDY mask
1800 * @adev: ATA device
1801 *
1802 * Compute the highest mode possible if we are not using iordy. Return
1803 * -1 if no iordy mode is available.
1804 */
Alan Cox432729f2007-03-08 23:22:59 +00001805static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
1806{
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001807 /* If we have no drive specific rule, then PIO 2 is non IORDY */
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001808 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
Alan Cox432729f2007-03-08 23:22:59 +00001809 u16 pio = adev->id[ATA_ID_EIDE_PIO];
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001810 /* Is the speed faster than the drive allows non IORDY ? */
1811 if (pio) {
1812 /* This is cycle times not frequency - watch the logic! */
1813 if (pio > 240) /* PIO2 is 240nS per cycle */
Alan Cox432729f2007-03-08 23:22:59 +00001814 return 3 << ATA_SHIFT_PIO;
1815 return 7 << ATA_SHIFT_PIO;
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001816 }
1817 }
Alan Cox432729f2007-03-08 23:22:59 +00001818 return 3 << ATA_SHIFT_PIO;
Alan Cox1bc4ccf2006-01-09 17:18:14 +00001819}
1820
1821/**
Alan Cox963e4972008-07-24 17:16:06 +01001822 * ata_do_dev_read_id - default ID read method
1823 * @dev: device
1824 * @tf: proposed taskfile
1825 * @id: data buffer
1826 *
1827 * Issue the identify taskfile and hand back the buffer containing
1828 * identify data. For some RAID controllers and for pre ATA devices
1829 * this function is wrapped or replaced by the driver
1830 */
1831unsigned int ata_do_dev_read_id(struct ata_device *dev,
1832 struct ata_taskfile *tf, u16 *id)
1833{
1834 return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE,
1835 id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1836}
1837
1838/**
Tejun Heo49016ac2006-02-21 02:12:11 +09001839 * ata_dev_read_id - Read ID data from the specified device
Tejun Heo49016ac2006-02-21 02:12:11 +09001840 * @dev: target device
1841 * @p_class: pointer to class of the target device (may be changed)
Tejun Heobff04642006-11-10 18:08:10 +09001842 * @flags: ATA_READID_* flags
Tejun Heofe635c72006-05-15 20:57:35 +09001843 * @id: buffer to read IDENTIFY data into
Tejun Heo49016ac2006-02-21 02:12:11 +09001844 *
1845 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1846 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
Tejun Heoaec5c3c2006-03-25 01:33:34 +09001847 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1848 * for pre-ATA4 drives.
Tejun Heo49016ac2006-02-21 02:12:11 +09001849 *
Alan Cox50a99012007-08-08 14:27:00 +01001850 * FIXME: ATA_CMD_ID_ATA is optional for early drives and right
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001851 * now we abort if we hit that case.
Alan Cox50a99012007-08-08 14:27:00 +01001852 *
Tejun Heo49016ac2006-02-21 02:12:11 +09001853 * LOCKING:
1854 * Kernel thread context (may sleep)
1855 *
1856 * RETURNS:
1857 * 0 on success, -errno otherwise.
1858 */
Tejun Heoa9beec92006-05-31 18:27:44 +09001859int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
Tejun Heobff04642006-11-10 18:08:10 +09001860 unsigned int flags, u16 *id)
Tejun Heo49016ac2006-02-21 02:12:11 +09001861{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001862 struct ata_port *ap = dev->link->ap;
Tejun Heo49016ac2006-02-21 02:12:11 +09001863 unsigned int class = *p_class;
Tejun Heo49016ac2006-02-21 02:12:11 +09001864 struct ata_taskfile tf;
1865 unsigned int err_mask = 0;
1866 const char *reason;
Tejun Heo79b42ba2009-04-15 06:21:10 +09001867 bool is_semb = class == ATA_DEV_SEMB;
Tejun Heo54936f82007-05-11 14:35:29 +02001868 int may_fallback = 1, tried_spinup = 0;
Tejun Heo49016ac2006-02-21 02:12:11 +09001869 int rc;
1870
Borislav Petkov0dd4b212006-06-23 02:29:08 -04001871 if (ata_msg_ctl(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07001872 ata_dev_dbg(dev, "%s: ENTER\n", __func__);
Tejun Heo49016ac2006-02-21 02:12:11 +09001873
Alan Cox963e4972008-07-24 17:16:06 +01001874retry:
Tejun Heo3373efd2006-05-15 20:57:53 +09001875 ata_tf_init(dev, &tf);
Tejun Heo49016ac2006-02-21 02:12:11 +09001876
1877 switch (class) {
Tejun Heo79b42ba2009-04-15 06:21:10 +09001878 case ATA_DEV_SEMB:
1879 class = ATA_DEV_ATA; /* some hard drives report SEMB sig */
Tejun Heo49016ac2006-02-21 02:12:11 +09001880 case ATA_DEV_ATA:
Hannes Reinecke9162c652014-11-05 13:08:21 +01001881 case ATA_DEV_ZAC:
Tejun Heo49016ac2006-02-21 02:12:11 +09001882 tf.command = ATA_CMD_ID_ATA;
1883 break;
1884 case ATA_DEV_ATAPI:
1885 tf.command = ATA_CMD_ID_ATAPI;
1886 break;
1887 default:
1888 rc = -ENODEV;
1889 reason = "unsupported class";
1890 goto err_out;
1891 }
1892
1893 tf.protocol = ATA_PROT_PIO;
Tejun Heo81afe892007-02-07 12:37:41 -08001894
1895 /* Some devices choke if TF registers contain garbage. Make
1896 * sure those are properly initialized.
1897 */
1898 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1899
1900 /* Device presence detection is unreliable on some
1901 * controllers. Always poll IDENTIFY if available.
1902 */
1903 tf.flags |= ATA_TFLAG_POLLING;
Tejun Heo49016ac2006-02-21 02:12:11 +09001904
Alan Cox963e4972008-07-24 17:16:06 +01001905 if (ap->ops->read_id)
1906 err_mask = ap->ops->read_id(dev, &tf, id);
1907 else
1908 err_mask = ata_do_dev_read_id(dev, &tf, id);
1909
Tejun Heo49016ac2006-02-21 02:12:11 +09001910 if (err_mask) {
Tejun Heo800b3992006-12-03 21:34:13 +09001911 if (err_mask & AC_ERR_NODEV_HINT) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001912 ata_dev_dbg(dev, "NODEV after polling detection\n");
Tejun Heo55a8e2c2006-11-10 18:08:10 +09001913 return -ENOENT;
1914 }
1915
Tejun Heo79b42ba2009-04-15 06:21:10 +09001916 if (is_semb) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001917 ata_dev_info(dev,
1918 "IDENTIFY failed on device w/ SEMB sig, disabled\n");
Tejun Heo79b42ba2009-04-15 06:21:10 +09001919 /* SEMB is not supported yet */
1920 *p_class = ATA_DEV_SEMB_UNSUP;
1921 return 0;
1922 }
1923
Tejun Heo1ffc1512008-03-23 15:16:53 +09001924 if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
1925 /* Device or controller might have reported
1926 * the wrong device class. Give a shot at the
1927 * other IDENTIFY if the current one is
1928 * aborted by the device.
1929 */
1930 if (may_fallback) {
1931 may_fallback = 0;
Tejun Heo54936f82007-05-11 14:35:29 +02001932
Tejun Heo1ffc1512008-03-23 15:16:53 +09001933 if (class == ATA_DEV_ATA)
1934 class = ATA_DEV_ATAPI;
1935 else
1936 class = ATA_DEV_ATA;
1937 goto retry;
1938 }
1939
1940 /* Control reaches here iff the device aborted
1941 * both flavors of IDENTIFYs which happens
1942 * sometimes with phantom devices.
1943 */
Joe Perchesa9a79df2011-04-15 15:51:59 -07001944 ata_dev_dbg(dev,
1945 "both IDENTIFYs aborted, assuming NODEV\n");
Tejun Heo1ffc1512008-03-23 15:16:53 +09001946 return -ENOENT;
Tejun Heo54936f82007-05-11 14:35:29 +02001947 }
1948
Tejun Heo49016ac2006-02-21 02:12:11 +09001949 rc = -EIO;
1950 reason = "I/O error";
Tejun Heo49016ac2006-02-21 02:12:11 +09001951 goto err_out;
1952 }
1953
Tejun Heo43c9c592010-05-23 12:59:11 +02001954 if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001955 ata_dev_dbg(dev, "dumping IDENTIFY data, "
1956 "class=%d may_fallback=%d tried_spinup=%d\n",
1957 class, may_fallback, tried_spinup);
Tejun Heo43c9c592010-05-23 12:59:11 +02001958 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
1959 16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
1960 }
1961
Tejun Heo54936f82007-05-11 14:35:29 +02001962 /* Falling back doesn't make sense if ID data was read
1963 * successfully at least once.
1964 */
1965 may_fallback = 0;
1966
Tejun Heo49016ac2006-02-21 02:12:11 +09001967 swap_buf_le16(id, ATA_ID_WORDS);
1968
Tejun Heo49016ac2006-02-21 02:12:11 +09001969 /* sanity check */
Tejun Heoa4f57492006-09-12 20:35:49 -07001970 rc = -EINVAL;
Alan Cox60700682007-06-07 16:13:55 +01001971 reason = "device reports invalid type";
Tejun Heoa4f57492006-09-12 20:35:49 -07001972
Hannes Reinecke9162c652014-11-05 13:08:21 +01001973 if (class == ATA_DEV_ATA || class == ATA_DEV_ZAC) {
Tejun Heoa4f57492006-09-12 20:35:49 -07001974 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1975 goto err_out;
Andy Whitcroftdb63a4c2012-05-04 22:15:10 +01001976 if (ap->host->flags & ATA_HOST_IGNORE_ATA &&
1977 ata_id_is_ata(id)) {
1978 ata_dev_dbg(dev,
1979 "host indicates ignore ATA devices, ignored\n");
1980 return -ENOENT;
1981 }
Tejun Heoa4f57492006-09-12 20:35:49 -07001982 } else {
1983 if (ata_id_is_ata(id))
1984 goto err_out;
Tejun Heo49016ac2006-02-21 02:12:11 +09001985 }
1986
Mark Lord169439c2007-04-17 18:26:07 -04001987 if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
1988 tried_spinup = 1;
1989 /*
1990 * Drive powered-up in standby mode, and requires a specific
1991 * SET_FEATURES spin-up subcommand before it will accept
1992 * anything other than the original IDENTIFY command.
1993 */
Jeff Garzik218f3d32007-10-25 00:33:27 -04001994 err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
Ryan Powerfb0582f92007-08-10 13:59:35 -07001995 if (err_mask && id[2] != 0x738c) {
Mark Lord169439c2007-04-17 18:26:07 -04001996 rc = -EIO;
1997 reason = "SPINUP failed";
1998 goto err_out;
1999 }
2000 /*
2001 * If the drive initially returned incomplete IDENTIFY info,
2002 * we now must reissue the IDENTIFY command.
2003 */
2004 if (id[2] == 0x37c8)
2005 goto retry;
2006 }
2007
Hannes Reinecke9162c652014-11-05 13:08:21 +01002008 if ((flags & ATA_READID_POSTRESET) &&
2009 (class == ATA_DEV_ATA || class == ATA_DEV_ZAC)) {
Tejun Heo49016ac2006-02-21 02:12:11 +09002010 /*
2011 * The exact sequence expected by certain pre-ATA4 drives is:
2012 * SRST RESET
Alan Cox50a99012007-08-08 14:27:00 +01002013 * IDENTIFY (optional in early ATA)
2014 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
Tejun Heo49016ac2006-02-21 02:12:11 +09002015 * anything else..
2016 * Some drives were very specific about that exact sequence.
Alan Cox50a99012007-08-08 14:27:00 +01002017 *
2018 * Note that ATA4 says lba is mandatory so the second check
Adam Buchbinderc9404c92009-12-18 15:40:42 -05002019 * should never trigger.
Tejun Heo49016ac2006-02-21 02:12:11 +09002020 */
2021 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
Tejun Heo3373efd2006-05-15 20:57:53 +09002022 err_mask = ata_dev_init_params(dev, id[3], id[6]);
Tejun Heo49016ac2006-02-21 02:12:11 +09002023 if (err_mask) {
2024 rc = -EIO;
2025 reason = "INIT_DEV_PARAMS failed";
2026 goto err_out;
2027 }
2028
2029 /* current CHS translation info (id[53-58]) might be
2030 * changed. reread the identify device info.
2031 */
Tejun Heobff04642006-11-10 18:08:10 +09002032 flags &= ~ATA_READID_POSTRESET;
Tejun Heo49016ac2006-02-21 02:12:11 +09002033 goto retry;
2034 }
2035 }
2036
2037 *p_class = class;
Tejun Heofe635c72006-05-15 20:57:35 +09002038
Tejun Heo49016ac2006-02-21 02:12:11 +09002039 return 0;
2040
2041 err_out:
Tejun Heo88574552006-06-25 20:00:35 +09002042 if (ata_msg_warn(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002043 ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)\n",
2044 reason, err_mask);
Tejun Heo49016ac2006-02-21 02:12:11 +09002045 return rc;
2046}
2047
Tejun Heo90627122009-01-29 20:31:36 +09002048static int ata_do_link_spd_horkage(struct ata_device *dev)
2049{
2050 struct ata_link *plink = ata_dev_phys_link(dev);
2051 u32 target, target_limit;
2052
2053 if (!sata_scr_valid(plink))
2054 return 0;
2055
2056 if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2057 target = 1;
2058 else
2059 return 0;
2060
2061 target_limit = (1 << target) - 1;
2062
2063 /* if already on stricter limit, no need to push further */
2064 if (plink->sata_spd_limit <= target_limit)
2065 return 0;
2066
2067 plink->sata_spd_limit = target_limit;
2068
2069 /* Request another EH round by returning -EAGAIN if link is
2070 * going faster than the target speed. Forward progress is
2071 * guaranteed by setting sata_spd_limit to target_limit above.
2072 */
2073 if (plink->sata_spd > target) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002074 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2075 sata_spd_string(target));
Tejun Heo90627122009-01-29 20:31:36 +09002076 return -EAGAIN;
2077 }
2078 return 0;
2079}
2080
Tejun Heo3373efd2006-05-15 20:57:53 +09002081static inline u8 ata_dev_knobble(struct ata_device *dev)
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09002082{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002083 struct ata_port *ap = dev->link->ap;
Jens Axboe9ce8e302008-08-27 15:23:18 +02002084
2085 if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2086 return 0;
2087
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002088 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09002089}
2090
Hannes Reinecke5a233552016-04-25 12:45:46 +02002091static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2092{
2093 struct ata_port *ap = dev->link->ap;
2094 unsigned int err_mask;
Hannes Reineckefe5af0c2016-04-25 12:45:48 +02002095 int log_index = ATA_LOG_NCQ_SEND_RECV * 2;
2096 u16 log_pages;
Hannes Reinecke5a233552016-04-25 12:45:46 +02002097
Hannes Reineckefe5af0c2016-04-25 12:45:48 +02002098 err_mask = ata_read_log_page(dev, ATA_LOG_DIRECTORY,
2099 0, ap->sector_buf, 1);
2100 if (err_mask) {
2101 ata_dev_dbg(dev,
2102 "failed to get Log Directory Emask 0x%x\n",
2103 err_mask);
2104 return;
2105 }
2106 log_pages = get_unaligned_le16(&ap->sector_buf[log_index]);
2107 if (!log_pages) {
2108 ata_dev_warn(dev,
2109 "NCQ Send/Recv Log not supported\n");
2110 return;
2111 }
Hannes Reinecke5a233552016-04-25 12:45:46 +02002112 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2113 0, ap->sector_buf, 1);
2114 if (err_mask) {
2115 ata_dev_dbg(dev,
2116 "failed to get NCQ Send/Recv Log Emask 0x%x\n",
2117 err_mask);
2118 } else {
2119 u8 *cmds = dev->ncq_send_recv_cmds;
2120
2121 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2122 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2123
2124 if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2125 ata_dev_dbg(dev, "disabling queued TRIM support\n");
2126 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2127 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2128 }
2129 }
2130}
2131
Hannes Reinecke284b3b72016-04-25 12:45:54 +02002132static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2133{
2134 struct ata_port *ap = dev->link->ap;
2135 unsigned int err_mask;
2136 int log_index = ATA_LOG_NCQ_NON_DATA * 2;
2137 u16 log_pages;
2138
2139 err_mask = ata_read_log_page(dev, ATA_LOG_DIRECTORY,
2140 0, ap->sector_buf, 1);
2141 if (err_mask) {
2142 ata_dev_dbg(dev,
2143 "failed to get Log Directory Emask 0x%x\n",
2144 err_mask);
2145 return;
2146 }
2147 log_pages = get_unaligned_le16(&ap->sector_buf[log_index]);
2148 if (!log_pages) {
2149 ata_dev_warn(dev,
2150 "NCQ Send/Recv Log not supported\n");
2151 return;
2152 }
2153 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2154 0, ap->sector_buf, 1);
2155 if (err_mask) {
2156 ata_dev_dbg(dev,
2157 "failed to get NCQ Non-Data Log Emask 0x%x\n",
2158 err_mask);
2159 } else {
2160 u8 *cmds = dev->ncq_non_data_cmds;
2161
2162 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2163 }
2164}
2165
Adam Manzanares8e061782016-10-17 11:27:29 -07002166static void ata_dev_config_ncq_prio(struct ata_device *dev)
2167{
2168 struct ata_port *ap = dev->link->ap;
2169 unsigned int err_mask;
2170
Adam Manzanares9f56eca2016-12-13 12:00:05 -08002171 if (!(dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLE)) {
2172 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
2173 return;
2174 }
2175
Adam Manzanares8e061782016-10-17 11:27:29 -07002176 err_mask = ata_read_log_page(dev,
2177 ATA_LOG_SATA_ID_DEV_DATA,
2178 ATA_LOG_SATA_SETTINGS,
2179 ap->sector_buf,
2180 1);
2181 if (err_mask) {
2182 ata_dev_dbg(dev,
2183 "failed to get Identify Device data, Emask 0x%x\n",
2184 err_mask);
2185 return;
2186 }
2187
Adam Manzanares9f56eca2016-12-13 12:00:05 -08002188 if (ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)) {
Adam Manzanares8e061782016-10-17 11:27:29 -07002189 dev->flags |= ATA_DFLAG_NCQ_PRIO;
Adam Manzanares9f56eca2016-12-13 12:00:05 -08002190 } else {
2191 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
Adam Manzanares8e061782016-10-17 11:27:29 -07002192 ata_dev_dbg(dev, "SATA page does not support priority\n");
Adam Manzanares9f56eca2016-12-13 12:00:05 -08002193 }
Adam Manzanares8e061782016-10-17 11:27:29 -07002194
2195}
2196
Shaohua Li388539f2009-07-27 09:24:35 +08002197static int ata_dev_config_ncq(struct ata_device *dev,
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002198 char *desc, size_t desc_sz)
2199{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002200 struct ata_port *ap = dev->link->ap;
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002201 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
Shaohua Li388539f2009-07-27 09:24:35 +08002202 unsigned int err_mask;
2203 char *aa_desc = "";
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002204
2205 if (!ata_id_has_ncq(dev->id)) {
2206 desc[0] = '\0';
Shaohua Li388539f2009-07-27 09:24:35 +08002207 return 0;
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002208 }
Tejun Heo75683fe2007-07-05 13:31:27 +09002209 if (dev->horkage & ATA_HORKAGE_NONCQ) {
Alan Cox6919a0a2006-10-27 19:08:46 -07002210 snprintf(desc, desc_sz, "NCQ (not used)");
Shaohua Li388539f2009-07-27 09:24:35 +08002211 return 0;
Alan Cox6919a0a2006-10-27 19:08:46 -07002212 }
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002213 if (ap->flags & ATA_FLAG_NCQ) {
Jeff Garzikcca39742006-08-24 03:19:22 -04002214 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002215 dev->flags |= ATA_DFLAG_NCQ;
2216 }
2217
Shaohua Li388539f2009-07-27 09:24:35 +08002218 if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2219 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2220 ata_id_has_fpdma_aa(dev->id)) {
2221 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2222 SATA_FPDMA_AA);
2223 if (err_mask) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002224 ata_dev_err(dev,
2225 "failed to enable AA (error_mask=0x%x)\n",
2226 err_mask);
Shaohua Li388539f2009-07-27 09:24:35 +08002227 if (err_mask != AC_ERR_DEV) {
2228 dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2229 return -EIO;
2230 }
2231 } else
2232 aa_desc = ", AA";
2233 }
2234
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002235 if (hdepth >= ddepth)
Shaohua Li388539f2009-07-27 09:24:35 +08002236 snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002237 else
Shaohua Li388539f2009-07-27 09:24:35 +08002238 snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2239 ddepth, aa_desc);
Marc Carinoed369112013-08-24 23:22:50 -07002240
Hannes Reinecke284b3b72016-04-25 12:45:54 +02002241 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2242 if (ata_id_has_ncq_send_and_recv(dev->id))
2243 ata_dev_config_ncq_send_recv(dev);
2244 if (ata_id_has_ncq_non_data(dev->id))
2245 ata_dev_config_ncq_non_data(dev);
Adam Manzanares8e061782016-10-17 11:27:29 -07002246 if (ata_id_has_ncq_prio(dev->id))
2247 ata_dev_config_ncq_prio(dev);
Marc Carinoed369112013-08-24 23:22:50 -07002248 }
2249
Shaohua Li388539f2009-07-27 09:24:35 +08002250 return 0;
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002251}
2252
Hannes Reineckee87fd282016-04-04 11:43:55 +02002253static void ata_dev_config_sense_reporting(struct ata_device *dev)
2254{
2255 unsigned int err_mask;
2256
2257 if (!ata_id_has_sense_reporting(dev->id))
2258 return;
2259
2260 if (ata_id_sense_reporting_enabled(dev->id))
2261 return;
2262
2263 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2264 if (err_mask) {
2265 ata_dev_dbg(dev,
2266 "failed to enable Sense Data Reporting, Emask 0x%x\n",
2267 err_mask);
2268 }
2269}
2270
Hannes Reinecke6d1003a2016-04-25 12:45:56 +02002271static void ata_dev_config_zac(struct ata_device *dev)
2272{
2273 struct ata_port *ap = dev->link->ap;
2274 unsigned int err_mask;
2275 u8 *identify_buf = ap->sector_buf;
2276 int log_index = ATA_LOG_SATA_ID_DEV_DATA * 2, i, found = 0;
2277 u16 log_pages;
2278
2279 dev->zac_zones_optimal_open = U32_MAX;
2280 dev->zac_zones_optimal_nonseq = U32_MAX;
2281 dev->zac_zones_max_open = U32_MAX;
2282
2283 /*
2284 * Always set the 'ZAC' flag for Host-managed devices.
2285 */
2286 if (dev->class == ATA_DEV_ZAC)
2287 dev->flags |= ATA_DFLAG_ZAC;
2288 else if (ata_id_zoned_cap(dev->id) == 0x01)
2289 /*
2290 * Check for host-aware devices.
2291 */
2292 dev->flags |= ATA_DFLAG_ZAC;
2293
2294 if (!(dev->flags & ATA_DFLAG_ZAC))
2295 return;
2296
2297 /*
2298 * Read Log Directory to figure out if IDENTIFY DEVICE log
2299 * is supported.
2300 */
2301 err_mask = ata_read_log_page(dev, ATA_LOG_DIRECTORY,
2302 0, ap->sector_buf, 1);
2303 if (err_mask) {
2304 ata_dev_info(dev,
2305 "failed to get Log Directory Emask 0x%x\n",
2306 err_mask);
2307 return;
2308 }
2309 log_pages = get_unaligned_le16(&ap->sector_buf[log_index]);
2310 if (log_pages == 0) {
2311 ata_dev_warn(dev,
2312 "ATA Identify Device Log not supported\n");
2313 return;
2314 }
2315 /*
2316 * Read IDENTIFY DEVICE data log, page 0, to figure out
2317 * if page 9 is supported.
2318 */
2319 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_ID_DEV_DATA, 0,
2320 identify_buf, 1);
2321 if (err_mask) {
2322 ata_dev_info(dev,
2323 "failed to get Device Identify Log Emask 0x%x\n",
2324 err_mask);
2325 return;
2326 }
2327 log_pages = identify_buf[8];
2328 for (i = 0; i < log_pages; i++) {
2329 if (identify_buf[9 + i] == ATA_LOG_ZONED_INFORMATION) {
2330 found++;
2331 break;
2332 }
2333 }
2334 if (!found) {
2335 ata_dev_warn(dev,
2336 "ATA Zoned Information Log not supported\n");
2337 return;
2338 }
2339
2340 /*
2341 * Read IDENTIFY DEVICE data log, page 9 (Zoned-device information)
2342 */
2343 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_ID_DEV_DATA,
2344 ATA_LOG_ZONED_INFORMATION,
2345 identify_buf, 1);
2346 if (!err_mask) {
2347 u64 zoned_cap, opt_open, opt_nonseq, max_open;
2348
2349 zoned_cap = get_unaligned_le64(&identify_buf[8]);
2350 if ((zoned_cap >> 63))
2351 dev->zac_zoned_cap = (zoned_cap & 1);
2352 opt_open = get_unaligned_le64(&identify_buf[24]);
2353 if ((opt_open >> 63))
2354 dev->zac_zones_optimal_open = (u32)opt_open;
2355 opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2356 if ((opt_nonseq >> 63))
2357 dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2358 max_open = get_unaligned_le64(&identify_buf[40]);
2359 if ((max_open >> 63))
2360 dev->zac_zones_max_open = (u32)max_open;
2361 }
2362}
2363
Tejun Heo49016ac2006-02-21 02:12:11 +09002364/**
Tejun Heoffeae412006-03-01 16:09:35 +09002365 * ata_dev_configure - Configure the specified ATA/ATAPI device
Tejun Heoffeae412006-03-01 16:09:35 +09002366 * @dev: Target device to configure
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 *
Tejun Heoffeae412006-03-01 16:09:35 +09002368 * Configure @dev according to @dev->id. Generic and low-level
2369 * driver specific fixups are also applied.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 *
2371 * LOCKING:
Tejun Heoffeae412006-03-01 16:09:35 +09002372 * Kernel thread context (may sleep)
2373 *
2374 * RETURNS:
2375 * 0 on success, -errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 */
Tejun Heoefdaedc2006-11-01 18:38:52 +09002377int ata_dev_configure(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002379 struct ata_port *ap = dev->link->ap;
2380 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heo67465442007-05-15 03:28:16 +09002381 int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
Tejun Heo1148c3a2006-03-13 19:48:04 +09002382 const u16 *id = dev->id;
Tejun Heo7dc951a2007-11-27 19:43:42 +09002383 unsigned long xfer_mask;
Shane Huang65fe1f02012-09-07 22:40:01 +08002384 unsigned int err_mask;
Alan Coxb352e572006-08-10 18:52:12 +01002385 char revbuf[7]; /* XYZ-99\0 */
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002386 char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2387 char modelbuf[ATA_ID_PROD_LEN+1];
Brian Kinge6d902a2006-06-28 08:30:31 -05002388 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002390 if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002391 ata_dev_info(dev, "%s: ENTER/EXIT -- nodev\n", __func__);
Tejun Heoffeae412006-03-01 16:09:35 +09002392 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 }
2394
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002395 if (ata_msg_probe(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002396 ata_dev_dbg(dev, "%s: ENTER\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397
Tejun Heo75683fe2007-07-05 13:31:27 +09002398 /* set horkage */
2399 dev->horkage |= ata_dev_blacklisted(dev);
Tejun Heo33267322008-02-13 09:15:09 +09002400 ata_force_horkage(dev);
Tejun Heo75683fe2007-07-05 13:31:27 +09002401
Tejun Heo50af2fa2008-05-19 01:15:14 +09002402 if (dev->horkage & ATA_HORKAGE_DISABLE) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002403 ata_dev_info(dev, "unsupported device, disabling\n");
Tejun Heo50af2fa2008-05-19 01:15:14 +09002404 ata_dev_disable(dev);
2405 return 0;
2406 }
2407
Tejun Heo2486fa52008-07-31 07:52:40 +09002408 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2409 dev->class == ATA_DEV_ATAPI) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002410 ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2411 atapi_enabled ? "not supported with this driver"
2412 : "disabled");
Tejun Heo2486fa52008-07-31 07:52:40 +09002413 ata_dev_disable(dev);
2414 return 0;
2415 }
2416
Tejun Heo90627122009-01-29 20:31:36 +09002417 rc = ata_do_link_spd_horkage(dev);
2418 if (rc)
2419 return rc;
2420
Tejun Heoecd75ad2014-01-16 09:47:17 -05002421 /* some WD SATA-1 drives have issues with LPM, turn on NOLPM for them */
2422 if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2423 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2424 dev->horkage |= ATA_HORKAGE_NOLPM;
2425
2426 if (dev->horkage & ATA_HORKAGE_NOLPM) {
2427 ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2428 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2429 }
2430
Tejun Heo67465442007-05-15 03:28:16 +09002431 /* let ACPI work its magic */
2432 rc = ata_acpi_on_devcfg(dev);
2433 if (rc)
2434 return rc;
Kristen Carlson Accardi08573a82006-11-10 16:14:47 -08002435
Tejun Heo05027ad2007-09-03 12:32:57 +09002436 /* massage HPA, do it early as it might change IDENTIFY data */
2437 rc = ata_hpa_resize(dev);
2438 if (rc)
2439 return rc;
2440
Tejun Heoc39f5eb2006-03-13 19:51:19 +09002441 /* print device capabilities */
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002442 if (ata_msg_probe(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002443 ata_dev_dbg(dev,
2444 "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2445 "85:%04x 86:%04x 87:%04x 88:%04x\n",
2446 __func__,
2447 id[49], id[82], id[83], id[84],
2448 id[85], id[86], id[87], id[88]);
Tejun Heoc39f5eb2006-03-13 19:51:19 +09002449
Tejun Heo208a9932006-03-05 17:55:58 +09002450 /* initialize to-be-configured parameters */
Tejun Heoea1dd4e2006-04-02 18:51:53 +09002451 dev->flags &= ~ATA_DFLAG_CFG_MASK;
Tejun Heo208a9932006-03-05 17:55:58 +09002452 dev->max_sectors = 0;
2453 dev->cdb_len = 0;
2454 dev->n_sectors = 0;
2455 dev->cylinders = 0;
2456 dev->heads = 0;
2457 dev->sectors = 0;
Mark Lorde18086d2009-03-19 13:32:21 -04002458 dev->multi_count = 0;
Tejun Heo208a9932006-03-05 17:55:58 +09002459
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 /*
2461 * common ATA, ATAPI feature tests
2462 */
2463
Tejun Heoff8854b2006-03-06 04:31:56 +09002464 /* find max transfer mode; for printk only */
Tejun Heo1148c3a2006-03-13 19:48:04 +09002465 xfer_mask = ata_id_xfermask(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002467 if (ata_msg_probe(ap))
2468 ata_dump_id(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469
Albert Leeef143d52007-06-05 13:01:33 +08002470 /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
2471 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2472 sizeof(fwrevbuf));
2473
2474 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2475 sizeof(modelbuf));
2476
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 /* ATA-specific feature tests */
Hannes Reinecke9162c652014-11-05 13:08:21 +01002478 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
Alan Coxb352e572006-08-10 18:52:12 +01002479 if (ata_id_is_cfa(id)) {
Sergei Shtylyov62afe5d2009-04-13 20:50:00 +04002480 /* CPRM may make this media unusable */
2481 if (id[ATA_ID_CFA_KEY_MGMT] & 1)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002482 ata_dev_warn(dev,
2483 "supports DRM functions and may not be fully accessible\n");
Alan Coxb352e572006-08-10 18:52:12 +01002484 snprintf(revbuf, 7, "CFA");
Alan Coxae8d4ee2007-11-04 22:05:49 -05002485 } else {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002486 snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
Alan Coxae8d4ee2007-11-04 22:05:49 -05002487 /* Warn the user if the device has TPM extensions */
2488 if (ata_id_has_tpm(id))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002489 ata_dev_warn(dev,
2490 "supports DRM functions and may not be fully accessible\n");
Alan Coxae8d4ee2007-11-04 22:05:49 -05002491 }
Alan Coxb352e572006-08-10 18:52:12 +01002492
Tejun Heo1148c3a2006-03-13 19:48:04 +09002493 dev->n_sectors = ata_id_n_sectors(id);
Tejun Heo29407402006-02-12 22:47:04 +09002494
Mark Lorde18086d2009-03-19 13:32:21 -04002495 /* get current R/W Multiple count setting */
2496 if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2497 unsigned int max = dev->id[47] & 0xff;
2498 unsigned int cnt = dev->id[59] & 0xff;
2499 /* only recognize/allow powers of two here */
2500 if (is_power_of_2(max) && is_power_of_2(cnt))
2501 if (cnt <= max)
2502 dev->multi_count = cnt;
2503 }
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002504
Tejun Heo1148c3a2006-03-13 19:48:04 +09002505 if (ata_id_has_lba(id)) {
Tejun Heo4c2d7212006-03-05 17:55:58 +09002506 const char *lba_desc;
Shaohua Li388539f2009-07-27 09:24:35 +08002507 char ncq_desc[24];
Albert Lee8bf62ece2005-05-12 15:29:42 -04002508
Tejun Heo4c2d7212006-03-05 17:55:58 +09002509 lba_desc = "LBA";
2510 dev->flags |= ATA_DFLAG_LBA;
Tejun Heo1148c3a2006-03-13 19:48:04 +09002511 if (ata_id_has_lba48(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04002512 dev->flags |= ATA_DFLAG_LBA48;
Tejun Heo4c2d7212006-03-05 17:55:58 +09002513 lba_desc = "LBA48";
Tejun Heo6fc49ad2006-11-11 20:10:45 +09002514
2515 if (dev->n_sectors >= (1UL << 28) &&
2516 ata_id_has_flush_ext(id))
2517 dev->flags |= ATA_DFLAG_FLUSH_EXT;
Tejun Heo4c2d7212006-03-05 17:55:58 +09002518 }
Albert Lee8bf62ece2005-05-12 15:29:42 -04002519
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002520 /* config NCQ */
Shaohua Li388539f2009-07-27 09:24:35 +08002521 rc = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2522 if (rc)
2523 return rc;
Tejun Heoa6e6ce82006-05-15 21:03:48 +09002524
Albert Lee8bf62ece2005-05-12 15:29:42 -04002525 /* print device info to dmesg */
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002526 if (ata_msg_drv(ap) && print_info) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002527 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2528 revbuf, modelbuf, fwrevbuf,
2529 ata_mode_string(xfer_mask));
2530 ata_dev_info(dev,
2531 "%llu sectors, multi %u: %s %s\n",
Tejun Heof15a1da2006-05-15 20:57:56 +09002532 (unsigned long long)dev->n_sectors,
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002533 dev->multi_count, lba_desc, ncq_desc);
2534 }
Tejun Heoffeae412006-03-01 16:09:35 +09002535 } else {
Albert Lee8bf62ece2005-05-12 15:29:42 -04002536 /* CHS */
2537
2538 /* Default translation */
Tejun Heo1148c3a2006-03-13 19:48:04 +09002539 dev->cylinders = id[1];
2540 dev->heads = id[3];
2541 dev->sectors = id[6];
Albert Lee8bf62ece2005-05-12 15:29:42 -04002542
Tejun Heo1148c3a2006-03-13 19:48:04 +09002543 if (ata_id_current_chs_valid(id)) {
Albert Lee8bf62ece2005-05-12 15:29:42 -04002544 /* Current CHS translation is valid. */
Tejun Heo1148c3a2006-03-13 19:48:04 +09002545 dev->cylinders = id[54];
2546 dev->heads = id[55];
2547 dev->sectors = id[56];
Albert Lee8bf62ece2005-05-12 15:29:42 -04002548 }
2549
2550 /* print device info to dmesg */
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002551 if (ata_msg_drv(ap) && print_info) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002552 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2553 revbuf, modelbuf, fwrevbuf,
2554 ata_mode_string(xfer_mask));
2555 ata_dev_info(dev,
2556 "%llu sectors, multi %u, CHS %u/%u/%u\n",
2557 (unsigned long long)dev->n_sectors,
2558 dev->multi_count, dev->cylinders,
2559 dev->heads, dev->sectors);
Eric D. Mudama3f64f562007-01-30 23:00:40 -07002560 }
Albert Lee07f6f7d2005-11-01 19:33:20 +08002561 }
2562
Shane Huang803739d2012-12-17 23:18:59 +08002563 /* Check and mark DevSlp capability. Get DevSlp timing variables
2564 * from SATA Settings page of Identify Device Data Log.
Shane Huang65fe1f02012-09-07 22:40:01 +08002565 */
Shane Huang803739d2012-12-17 23:18:59 +08002566 if (ata_id_has_devslp(dev->id)) {
David Woodhouse8e725c72013-03-29 11:54:55 +00002567 u8 *sata_setting = ap->sector_buf;
Shane Huang803739d2012-12-17 23:18:59 +08002568 int i, j;
2569
2570 dev->flags |= ATA_DFLAG_DEVSLP;
Shane Huang65fe1f02012-09-07 22:40:01 +08002571 err_mask = ata_read_log_page(dev,
2572 ATA_LOG_SATA_ID_DEV_DATA,
2573 ATA_LOG_SATA_SETTINGS,
Shane Huang803739d2012-12-17 23:18:59 +08002574 sata_setting,
Shane Huang65fe1f02012-09-07 22:40:01 +08002575 1);
2576 if (err_mask)
2577 ata_dev_dbg(dev,
2578 "failed to get Identify Device Data, Emask 0x%x\n",
2579 err_mask);
Shane Huang803739d2012-12-17 23:18:59 +08002580 else
2581 for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2582 j = ATA_LOG_DEVSLP_OFFSET + i;
2583 dev->devslp_timing[i] = sata_setting[j];
2584 }
Shane Huang65fe1f02012-09-07 22:40:01 +08002585 }
Hannes Reineckee87fd282016-04-04 11:43:55 +02002586 ata_dev_config_sense_reporting(dev);
Hannes Reinecke6d1003a2016-04-25 12:45:56 +02002587 ata_dev_config_zac(dev);
Tejun Heo6e7846e2006-02-12 23:32:58 +09002588 dev->cdb_len = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 }
2590
2591 /* ATAPI-specific feature tests */
Jeff Garzik2c13b7c2005-11-14 14:14:16 -05002592 else if (dev->class == ATA_DEV_ATAPI) {
Tejun Heo854c73a2007-09-23 13:14:11 +09002593 const char *cdb_intr_string = "";
2594 const char *atapi_an_string = "";
Tejun Heo91163002008-02-21 13:25:50 +09002595 const char *dma_dir_string = "";
Tejun Heo7d77b242007-09-23 13:14:13 +09002596 u32 sntf;
Albert Lee08a556d2006-03-31 13:29:04 +08002597
Tejun Heo1148c3a2006-03-13 19:48:04 +09002598 rc = atapi_cdb_len(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002600 if (ata_msg_warn(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002601 ata_dev_warn(dev, "unsupported CDB len\n");
Tejun Heoffeae412006-03-01 16:09:35 +09002602 rc = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 goto err_out_nosup;
2604 }
Tejun Heo6e7846e2006-02-12 23:32:58 +09002605 dev->cdb_len = (unsigned int) rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606
Tejun Heo7d77b242007-09-23 13:14:13 +09002607 /* Enable ATAPI AN if both the host and device have
2608 * the support. If PMP is attached, SNTF is required
2609 * to enable ATAPI AN to discern between PHY status
2610 * changed notifications and ATAPI ANs.
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04002611 */
Tejun Heoe7ecd432010-05-19 15:38:58 +02002612 if (atapi_an &&
2613 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
Tejun Heo071f44b2008-04-07 22:47:22 +09002614 (!sata_pmp_attached(ap) ||
Tejun Heo7d77b242007-09-23 13:14:13 +09002615 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04002616 /* issue SET feature command to turn this on */
Jeff Garzik218f3d32007-10-25 00:33:27 -04002617 err_mask = ata_dev_set_feature(dev,
2618 SETFEATURES_SATA_ENABLE, SATA_AN);
Tejun Heo854c73a2007-09-23 13:14:11 +09002619 if (err_mask)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002620 ata_dev_err(dev,
2621 "failed to enable ATAPI AN (err_mask=0x%x)\n",
2622 err_mask);
Tejun Heo854c73a2007-09-23 13:14:11 +09002623 else {
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04002624 dev->flags |= ATA_DFLAG_AN;
Tejun Heo854c73a2007-09-23 13:14:11 +09002625 atapi_an_string = ", ATAPI AN";
2626 }
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04002627 }
2628
Albert Lee08a556d2006-03-31 13:29:04 +08002629 if (ata_id_cdb_intr(dev->id)) {
Albert Lee312f7da2005-09-27 17:38:03 +08002630 dev->flags |= ATA_DFLAG_CDB_INTR;
Albert Lee08a556d2006-03-31 13:29:04 +08002631 cdb_intr_string = ", CDB intr";
2632 }
Albert Lee312f7da2005-09-27 17:38:03 +08002633
Vincent Pelletier966fbe12013-05-21 22:30:58 +02002634 if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
Tejun Heo91163002008-02-21 13:25:50 +09002635 dev->flags |= ATA_DFLAG_DMADIR;
2636 dma_dir_string = ", DMADIR";
2637 }
2638
Aaron Luafe75952013-01-15 17:20:58 +08002639 if (ata_id_has_da(dev->id)) {
Lin Mingb1354cb2012-06-25 16:13:08 +08002640 dev->flags |= ATA_DFLAG_DA;
Aaron Luafe75952013-01-15 17:20:58 +08002641 zpodd_init(dev);
2642 }
Lin Mingb1354cb2012-06-25 16:13:08 +08002643
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 /* print device info to dmesg */
Borislav Petkov5afc8142006-06-27 14:51:25 +02002645 if (ata_msg_drv(ap) && print_info)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002646 ata_dev_info(dev,
2647 "ATAPI: %s, %s, max %s%s%s%s\n",
2648 modelbuf, fwrevbuf,
2649 ata_mode_string(xfer_mask),
2650 cdb_intr_string, atapi_an_string,
2651 dma_dir_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 }
2653
Tejun Heo914ed352006-11-01 18:39:55 +09002654 /* determine max_sectors */
2655 dev->max_sectors = ATA_MAX_SECTORS;
2656 if (dev->flags & ATA_DFLAG_LBA48)
2657 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2658
Alan Coxc5038fc2007-10-25 14:21:16 +01002659 /* Limit PATA drive on SATA cable bridge transfers to udma5,
2660 200 sectors */
Tejun Heo3373efd2006-05-15 20:57:53 +09002661 if (ata_dev_knobble(dev)) {
Borislav Petkov5afc8142006-06-27 14:51:25 +02002662 if (ata_msg_drv(ap) && print_info)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002663 ata_dev_info(dev, "applying bridge limits\n");
Tejun Heo5a529132006-03-24 14:07:50 +09002664 dev->udma_mask &= ATA_UDMA5;
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09002665 dev->max_sectors = ATA_MAX_SECTORS;
2666 }
2667
Tony Battersbyf8d8e572007-10-30 11:44:35 -04002668 if ((dev->class == ATA_DEV_ATAPI) &&
Albert Leef442cd82007-11-15 10:35:47 +09002669 (atapi_command_packet_set(id) == TYPE_TAPE)) {
Tony Battersbyf8d8e572007-10-30 11:44:35 -04002670 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
Albert Leef442cd82007-11-15 10:35:47 +09002671 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
2672 }
Tony Battersbyf8d8e572007-10-30 11:44:35 -04002673
Tejun Heo75683fe2007-07-05 13:31:27 +09002674 if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
Tejun Heo03ec52d2007-04-12 13:38:11 +09002675 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
2676 dev->max_sectors);
Albert Lee18d6e9d2007-04-02 11:34:15 +08002677
David Milburnaf34d632015-07-13 11:48:23 -05002678 if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
2679 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
2680 dev->max_sectors);
2681
Shan Haia32450e2013-03-18 10:30:44 +08002682 if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
2683 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2684
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09002685 if (ap->ops->dev_config)
Alancd0d3bb2007-03-02 00:56:15 +00002686 ap->ops->dev_config(dev);
Tejun Heo4b2f3ed2006-03-01 16:09:36 +09002687
Alan Coxc5038fc2007-10-25 14:21:16 +01002688 if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
2689 /* Let the user know. We don't want to disallow opens for
2690 rescue purposes, or in case the vendor is just a blithering
2691 idiot. Do this after the dev_config call as some controllers
2692 with buggy firmware may want to avoid reporting false device
2693 bugs */
2694
2695 if (print_info) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002696 ata_dev_warn(dev,
Alan Coxc5038fc2007-10-25 14:21:16 +01002697"Drive reports diagnostics failure. This may indicate a drive\n");
Joe Perchesa9a79df2011-04-15 15:51:59 -07002698 ata_dev_warn(dev,
Alan Coxc5038fc2007-10-25 14:21:16 +01002699"fault or invalid emulation. Contact drive vendor for information.\n");
2700 }
2701 }
2702
Tejun Heoac70a962008-11-27 13:36:48 +09002703 if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002704 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
2705 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n");
Tejun Heoac70a962008-11-27 13:36:48 +09002706 }
2707
Tejun Heoffeae412006-03-01 16:09:35 +09002708 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709
2710err_out_nosup:
Borislav Petkov0dd4b212006-06-23 02:29:08 -04002711 if (ata_msg_probe(ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002712 ata_dev_dbg(dev, "%s: EXIT, err\n", __func__);
Tejun Heoffeae412006-03-01 16:09:35 +09002713 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714}
2715
2716/**
Alan Cox2e41e8e2007-03-08 23:19:19 +00002717 * ata_cable_40wire - return 40 wire cable type
Alan Coxbe0d18d2007-03-06 02:37:56 -08002718 * @ap: port
2719 *
Alan Cox2e41e8e2007-03-08 23:19:19 +00002720 * Helper method for drivers which want to hardwire 40 wire cable
Alan Coxbe0d18d2007-03-06 02:37:56 -08002721 * detection.
2722 */
2723
2724int ata_cable_40wire(struct ata_port *ap)
2725{
2726 return ATA_CBL_PATA40;
2727}
2728
2729/**
Alan Cox2e41e8e2007-03-08 23:19:19 +00002730 * ata_cable_80wire - return 80 wire cable type
Alan Coxbe0d18d2007-03-06 02:37:56 -08002731 * @ap: port
2732 *
Alan Cox2e41e8e2007-03-08 23:19:19 +00002733 * Helper method for drivers which want to hardwire 80 wire cable
Alan Coxbe0d18d2007-03-06 02:37:56 -08002734 * detection.
2735 */
2736
2737int ata_cable_80wire(struct ata_port *ap)
2738{
2739 return ATA_CBL_PATA80;
2740}
2741
2742/**
2743 * ata_cable_unknown - return unknown PATA cable.
2744 * @ap: port
2745 *
2746 * Helper method for drivers which have no PATA cable detection.
2747 */
2748
2749int ata_cable_unknown(struct ata_port *ap)
2750{
2751 return ATA_CBL_PATA_UNK;
2752}
2753
2754/**
Tejun Heoc88f90c2007-11-27 19:43:48 +09002755 * ata_cable_ignore - return ignored PATA cable.
2756 * @ap: port
2757 *
2758 * Helper method for drivers which don't use cable type to limit
2759 * transfer mode.
2760 */
2761int ata_cable_ignore(struct ata_port *ap)
2762{
2763 return ATA_CBL_PATA_IGN;
2764}
2765
2766/**
Alan Coxbe0d18d2007-03-06 02:37:56 -08002767 * ata_cable_sata - return SATA cable type
2768 * @ap: port
2769 *
2770 * Helper method for drivers which have SATA cables
2771 */
2772
2773int ata_cable_sata(struct ata_port *ap)
2774{
2775 return ATA_CBL_SATA;
2776}
2777
2778/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 * ata_bus_probe - Reset and probe ATA bus
2780 * @ap: Bus to probe
2781 *
Jeff Garzik0cba6322005-05-30 19:49:12 -04002782 * Master ATA bus probing function. Initiates a hardware-dependent
2783 * bus reset, then attempts to identify any devices found on
2784 * the bus.
2785 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04002787 * PCI/etc. bus probe sem.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788 *
2789 * RETURNS:
Tejun Heo96072e62006-04-01 01:38:17 +09002790 * Zero on success, negative errno otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 */
2792
Brian King80289162006-08-07 14:27:31 -05002793int ata_bus_probe(struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794{
Tejun Heo28ca5c52006-03-01 16:09:36 +09002795 unsigned int classes[ATA_MAX_DEVICES];
Tejun Heo14d2bac2006-04-02 17:54:46 +09002796 int tries[ATA_MAX_DEVICES];
Tejun Heof58229f2007-08-06 18:36:23 +09002797 int rc;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002798 struct ata_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799
Tejun Heo1eca4362008-11-03 20:03:17 +09002800 ata_for_each_dev(dev, &ap->link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002801 tries[dev->devno] = ATA_PROBE_MAX_TRIES;
Tejun Heo14d2bac2006-04-02 17:54:46 +09002802
2803 retry:
Tejun Heo1eca4362008-11-03 20:03:17 +09002804 ata_for_each_dev(dev, &ap->link, ALL) {
Tejun Heocdeab112007-10-29 16:41:09 +09002805 /* If we issue an SRST then an ATA drive (not ATAPI)
2806 * may change configuration and be in PIO0 timing. If
2807 * we do a hard reset (or are coming from power on)
2808 * this is true for ATA or ATAPI. Until we've set a
2809 * suitable controller mode we should not touch the
2810 * bus as we may be talking too fast.
2811 */
2812 dev->pio_mode = XFER_PIO_0;
Aaron Lu54169122012-12-03 11:35:02 +08002813 dev->dma_mode = 0xff;
Tejun Heocdeab112007-10-29 16:41:09 +09002814
2815 /* If the controller has a pio mode setup function
2816 * then use it to set the chipset to rights. Don't
2817 * touch the DMA setup as that will be dealt with when
2818 * configuring devices.
2819 */
2820 if (ap->ops->set_piomode)
2821 ap->ops->set_piomode(ap, dev);
2822 }
2823
Tejun Heo20444702006-03-13 01:57:01 +09002824 /* reset and determine device classes */
Tejun Heo52783c52006-05-31 18:28:22 +09002825 ap->ops->phy_reset(ap);
Tejun Heo2061a472006-03-12 00:57:39 +09002826
Tejun Heo1eca4362008-11-03 20:03:17 +09002827 ata_for_each_dev(dev, &ap->link, ALL) {
Tejun Heo3e4ec342010-05-10 21:41:30 +02002828 if (dev->class != ATA_DEV_UNKNOWN)
Tejun Heo52783c52006-05-31 18:28:22 +09002829 classes[dev->devno] = dev->class;
2830 else
2831 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo20444702006-03-13 01:57:01 +09002832
Tejun Heo52783c52006-05-31 18:28:22 +09002833 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo28ca5c52006-03-01 16:09:36 +09002834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835
Jeff Garzikf31f0cc2007-03-02 17:47:28 -05002836 /* read IDENTIFY page and configure devices. We have to do the identify
2837 specific sequence bass-ackwards so that PDIAG- is released by
2838 the slave device */
2839
Tejun Heo1eca4362008-11-03 20:03:17 +09002840 ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {
Tejun Heof58229f2007-08-06 18:36:23 +09002841 if (tries[dev->devno])
2842 dev->class = classes[dev->devno];
Tejun Heo14d2bac2006-04-02 17:54:46 +09002843
Tejun Heoe1211e32006-04-01 01:38:18 +09002844 if (!ata_dev_enabled(dev))
Tejun Heoffeae412006-03-01 16:09:35 +09002845 continue;
2846
Tejun Heobff04642006-11-10 18:08:10 +09002847 rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
2848 dev->id);
Tejun Heo14d2bac2006-04-02 17:54:46 +09002849 if (rc)
2850 goto fail;
Jeff Garzikf31f0cc2007-03-02 17:47:28 -05002851 }
2852
Alan Coxbe0d18d2007-03-06 02:37:56 -08002853 /* Now ask for the cable type as PDIAG- should have been released */
2854 if (ap->ops->cable_detect)
2855 ap->cbl = ap->ops->cable_detect(ap);
2856
Tejun Heo1eca4362008-11-03 20:03:17 +09002857 /* We may have SATA bridge glue hiding here irrespective of
2858 * the reported cable types and sensed types. When SATA
2859 * drives indicate we have a bridge, we don't know which end
2860 * of the link the bridge is which is a problem.
2861 */
2862 ata_for_each_dev(dev, &ap->link, ENABLED)
Alan Cox614fe292007-08-22 23:22:45 +01002863 if (ata_id_is_sata(dev->id))
2864 ap->cbl = ATA_CBL_SATA;
Alan Cox614fe292007-08-22 23:22:45 +01002865
Jeff Garzikf31f0cc2007-03-02 17:47:28 -05002866 /* After the identify sequence we can now set up the devices. We do
2867 this in the normal order so that the user doesn't get confused */
2868
Tejun Heo1eca4362008-11-03 20:03:17 +09002869 ata_for_each_dev(dev, &ap->link, ENABLED) {
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002870 ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
Tejun Heoefdaedc2006-11-01 18:38:52 +09002871 rc = ata_dev_configure(dev);
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002872 ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
Tejun Heo14d2bac2006-04-02 17:54:46 +09002873 if (rc)
2874 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 }
2876
Tejun Heoe82cbdb2006-04-01 01:38:18 +09002877 /* configure transfer mode */
Tejun Heo02607312007-08-06 18:36:23 +09002878 rc = ata_set_mode(&ap->link, &dev);
Tejun Heo4ae72a12007-02-02 16:22:30 +09002879 if (rc)
Tejun Heo51713d32006-04-11 22:26:29 +09002880 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
Tejun Heo1eca4362008-11-03 20:03:17 +09002882 ata_for_each_dev(dev, &ap->link, ENABLED)
2883 return 0;
Alan Coxe35a9e02006-03-27 18:46:37 +01002884
Tejun Heo96072e62006-04-01 01:38:17 +09002885 return -ENODEV;
Tejun Heo14d2bac2006-04-02 17:54:46 +09002886
2887 fail:
Tejun Heo4ae72a12007-02-02 16:22:30 +09002888 tries[dev->devno]--;
2889
Tejun Heo14d2bac2006-04-02 17:54:46 +09002890 switch (rc) {
2891 case -EINVAL:
Tejun Heo4ae72a12007-02-02 16:22:30 +09002892 /* eeek, something went very wrong, give up */
Tejun Heo14d2bac2006-04-02 17:54:46 +09002893 tries[dev->devno] = 0;
2894 break;
Tejun Heo4ae72a12007-02-02 16:22:30 +09002895
2896 case -ENODEV:
2897 /* give it just one more chance */
2898 tries[dev->devno] = min(tries[dev->devno], 1);
Tejun Heo14d2bac2006-04-02 17:54:46 +09002899 case -EIO:
Tejun Heo4ae72a12007-02-02 16:22:30 +09002900 if (tries[dev->devno] == 1) {
2901 /* This is the last chance, better to slow
2902 * down than lose it.
2903 */
Tejun Heoa07d4992009-01-29 20:31:33 +09002904 sata_down_spd_limit(&ap->link, 0);
Tejun Heo4ae72a12007-02-02 16:22:30 +09002905 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2906 }
Tejun Heo14d2bac2006-04-02 17:54:46 +09002907 }
2908
Tejun Heo4ae72a12007-02-02 16:22:30 +09002909 if (!tries[dev->devno])
Tejun Heo3373efd2006-05-15 20:57:53 +09002910 ata_dev_disable(dev);
Tejun Heoec573752006-04-11 22:26:29 +09002911
Tejun Heo14d2bac2006-04-02 17:54:46 +09002912 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913}
2914
2915/**
Tejun Heo3be680b2005-12-19 22:35:02 +09002916 * sata_print_link_status - Print SATA link status
Tejun Heo936fd732007-08-06 18:36:23 +09002917 * @link: SATA link to printk link status about
Tejun Heo3be680b2005-12-19 22:35:02 +09002918 *
2919 * This function prints link speed and status of a SATA link.
2920 *
2921 * LOCKING:
2922 * None.
2923 */
Adrian Bunk6bdb4fc2008-04-21 11:51:11 +03002924static void sata_print_link_status(struct ata_link *link)
Tejun Heo3be680b2005-12-19 22:35:02 +09002925{
Tejun Heo6d5f9732006-04-03 00:09:41 +09002926 u32 sstatus, scontrol, tmp;
Tejun Heo3be680b2005-12-19 22:35:02 +09002927
Tejun Heo936fd732007-08-06 18:36:23 +09002928 if (sata_scr_read(link, SCR_STATUS, &sstatus))
Tejun Heo3be680b2005-12-19 22:35:02 +09002929 return;
Tejun Heo936fd732007-08-06 18:36:23 +09002930 sata_scr_read(link, SCR_CONTROL, &scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09002931
Tejun Heob1c72912008-07-31 17:02:43 +09002932 if (ata_phys_link_online(link)) {
Tejun Heo3be680b2005-12-19 22:35:02 +09002933 tmp = (sstatus >> 4) & 0xf;
Joe Perchesa9a79df2011-04-15 15:51:59 -07002934 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
2935 sata_spd_string(tmp), sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09002936 } else {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002937 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
2938 sstatus, scontrol);
Tejun Heo3be680b2005-12-19 22:35:02 +09002939 }
2940}
2941
2942/**
Alan Coxebdfca62006-03-23 15:38:34 +00002943 * ata_dev_pair - return other device on cable
Alan Coxebdfca62006-03-23 15:38:34 +00002944 * @adev: device
2945 *
2946 * Obtain the other device on the same cable, or if none is
2947 * present NULL is returned
2948 */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05002949
Tejun Heo3373efd2006-05-15 20:57:53 +09002950struct ata_device *ata_dev_pair(struct ata_device *adev)
Alan Coxebdfca62006-03-23 15:38:34 +00002951{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002952 struct ata_link *link = adev->link;
2953 struct ata_device *pair = &link->device[1 - adev->devno];
Tejun Heoe1211e32006-04-01 01:38:18 +09002954 if (!ata_dev_enabled(pair))
Alan Coxebdfca62006-03-23 15:38:34 +00002955 return NULL;
2956 return pair;
2957}
2958
2959/**
Tejun Heo3c567b72006-05-15 20:57:23 +09002960 * sata_down_spd_limit - adjust SATA spd limit downward
Tejun Heo936fd732007-08-06 18:36:23 +09002961 * @link: Link to adjust SATA spd limit for
Tejun Heoa07d4992009-01-29 20:31:33 +09002962 * @spd_limit: Additional limit
Tejun Heo1c3fae42006-04-02 20:53:28 +09002963 *
Tejun Heo936fd732007-08-06 18:36:23 +09002964 * Adjust SATA spd limit of @link downward. Note that this
Tejun Heo1c3fae42006-04-02 20:53:28 +09002965 * function only adjusts the limit. The change must be applied
Tejun Heo3c567b72006-05-15 20:57:23 +09002966 * using sata_set_spd().
Tejun Heo1c3fae42006-04-02 20:53:28 +09002967 *
Tejun Heoa07d4992009-01-29 20:31:33 +09002968 * If @spd_limit is non-zero, the speed is limited to equal to or
2969 * lower than @spd_limit if such speed is supported. If
2970 * @spd_limit is slower than any supported speed, only the lowest
2971 * supported speed is allowed.
2972 *
Tejun Heo1c3fae42006-04-02 20:53:28 +09002973 * LOCKING:
2974 * Inherited from caller.
2975 *
2976 * RETURNS:
2977 * 0 on success, negative errno on failure
2978 */
Tejun Heoa07d4992009-01-29 20:31:33 +09002979int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
Tejun Heo1c3fae42006-04-02 20:53:28 +09002980{
Tejun Heo81952c52006-05-15 20:57:47 +09002981 u32 sstatus, spd, mask;
Tejun Heoa07d4992009-01-29 20:31:33 +09002982 int rc, bit;
Tejun Heo1c3fae42006-04-02 20:53:28 +09002983
Tejun Heo936fd732007-08-06 18:36:23 +09002984 if (!sata_scr_valid(link))
Tejun Heo008a7892007-07-16 14:29:40 +09002985 return -EOPNOTSUPP;
2986
2987 /* If SCR can be read, use it to determine the current SPD.
Tejun Heo936fd732007-08-06 18:36:23 +09002988 * If not, use cached value in link->sata_spd.
Tejun Heo008a7892007-07-16 14:29:40 +09002989 */
Tejun Heo936fd732007-08-06 18:36:23 +09002990 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
Tejun Heo9913ff82009-01-29 20:31:31 +09002991 if (rc == 0 && ata_sstatus_online(sstatus))
Tejun Heo008a7892007-07-16 14:29:40 +09002992 spd = (sstatus >> 4) & 0xf;
2993 else
Tejun Heo936fd732007-08-06 18:36:23 +09002994 spd = link->sata_spd;
Tejun Heo1c3fae42006-04-02 20:53:28 +09002995
Tejun Heo936fd732007-08-06 18:36:23 +09002996 mask = link->sata_spd_limit;
Tejun Heo1c3fae42006-04-02 20:53:28 +09002997 if (mask <= 1)
2998 return -EINVAL;
Tejun Heo008a7892007-07-16 14:29:40 +09002999
3000 /* unconditionally mask off the highest bit */
Tejun Heoa07d4992009-01-29 20:31:33 +09003001 bit = fls(mask) - 1;
3002 mask &= ~(1 << bit);
Tejun Heo1c3fae42006-04-02 20:53:28 +09003003
Tejun Heo008a7892007-07-16 14:29:40 +09003004 /* Mask off all speeds higher than or equal to the current
3005 * one. Force 1.5Gbps if current SPD is not available.
3006 */
3007 if (spd > 1)
3008 mask &= (1 << (spd - 1)) - 1;
3009 else
3010 mask &= 1;
3011
3012 /* were we already at the bottom? */
Tejun Heo1c3fae42006-04-02 20:53:28 +09003013 if (!mask)
3014 return -EINVAL;
3015
Tejun Heoa07d4992009-01-29 20:31:33 +09003016 if (spd_limit) {
3017 if (mask & ((1 << spd_limit) - 1))
3018 mask &= (1 << spd_limit) - 1;
3019 else {
3020 bit = ffs(mask) - 1;
3021 mask = 1 << bit;
3022 }
3023 }
3024
Tejun Heo936fd732007-08-06 18:36:23 +09003025 link->sata_spd_limit = mask;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003026
Joe Perchesa9a79df2011-04-15 15:51:59 -07003027 ata_link_warn(link, "limiting SATA link speed to %s\n",
3028 sata_spd_string(fls(mask)));
Tejun Heo1c3fae42006-04-02 20:53:28 +09003029
3030 return 0;
3031}
3032
Tejun Heo936fd732007-08-06 18:36:23 +09003033static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
Tejun Heo1c3fae42006-04-02 20:53:28 +09003034{
Tejun Heo52702222007-10-31 10:17:07 +09003035 struct ata_link *host_link = &link->ap->link;
3036 u32 limit, target, spd;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003037
Tejun Heo52702222007-10-31 10:17:07 +09003038 limit = link->sata_spd_limit;
3039
3040 /* Don't configure downstream link faster than upstream link.
3041 * It doesn't speed up anything and some PMPs choke on such
3042 * configuration.
3043 */
3044 if (!ata_is_host_link(link) && host_link->sata_spd)
3045 limit &= (1 << host_link->sata_spd) - 1;
3046
3047 if (limit == UINT_MAX)
3048 target = 0;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003049 else
Tejun Heo52702222007-10-31 10:17:07 +09003050 target = fls(limit);
Tejun Heo1c3fae42006-04-02 20:53:28 +09003051
3052 spd = (*scontrol >> 4) & 0xf;
Tejun Heo52702222007-10-31 10:17:07 +09003053 *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
Tejun Heo1c3fae42006-04-02 20:53:28 +09003054
Tejun Heo52702222007-10-31 10:17:07 +09003055 return spd != target;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003056}
3057
3058/**
Tejun Heo3c567b72006-05-15 20:57:23 +09003059 * sata_set_spd_needed - is SATA spd configuration needed
Tejun Heo936fd732007-08-06 18:36:23 +09003060 * @link: Link in question
Tejun Heo1c3fae42006-04-02 20:53:28 +09003061 *
3062 * Test whether the spd limit in SControl matches
Tejun Heo936fd732007-08-06 18:36:23 +09003063 * @link->sata_spd_limit. This function is used to determine
Tejun Heo1c3fae42006-04-02 20:53:28 +09003064 * whether hardreset is necessary to apply SATA spd
3065 * configuration.
3066 *
3067 * LOCKING:
3068 * Inherited from caller.
3069 *
3070 * RETURNS:
3071 * 1 if SATA spd configuration is needed, 0 otherwise.
3072 */
Adrian Bunk1dc55e82008-04-21 11:51:17 +03003073static int sata_set_spd_needed(struct ata_link *link)
Tejun Heo1c3fae42006-04-02 20:53:28 +09003074{
3075 u32 scontrol;
3076
Tejun Heo936fd732007-08-06 18:36:23 +09003077 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
Tejun Heodb64bcf2007-10-31 10:17:06 +09003078 return 1;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003079
Tejun Heo936fd732007-08-06 18:36:23 +09003080 return __sata_set_spd_needed(link, &scontrol);
Tejun Heo1c3fae42006-04-02 20:53:28 +09003081}
3082
3083/**
Tejun Heo3c567b72006-05-15 20:57:23 +09003084 * sata_set_spd - set SATA spd according to spd limit
Tejun Heo936fd732007-08-06 18:36:23 +09003085 * @link: Link to set SATA spd for
Tejun Heo1c3fae42006-04-02 20:53:28 +09003086 *
Tejun Heo936fd732007-08-06 18:36:23 +09003087 * Set SATA spd of @link according to sata_spd_limit.
Tejun Heo1c3fae42006-04-02 20:53:28 +09003088 *
3089 * LOCKING:
3090 * Inherited from caller.
3091 *
3092 * RETURNS:
3093 * 0 if spd doesn't need to be changed, 1 if spd has been
Tejun Heo81952c52006-05-15 20:57:47 +09003094 * changed. Negative errno if SCR registers are inaccessible.
Tejun Heo1c3fae42006-04-02 20:53:28 +09003095 */
Tejun Heo936fd732007-08-06 18:36:23 +09003096int sata_set_spd(struct ata_link *link)
Tejun Heo1c3fae42006-04-02 20:53:28 +09003097{
3098 u32 scontrol;
Tejun Heo81952c52006-05-15 20:57:47 +09003099 int rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003100
Tejun Heo936fd732007-08-06 18:36:23 +09003101 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
Tejun Heo81952c52006-05-15 20:57:47 +09003102 return rc;
Tejun Heo1c3fae42006-04-02 20:53:28 +09003103
Tejun Heo936fd732007-08-06 18:36:23 +09003104 if (!__sata_set_spd_needed(link, &scontrol))
Tejun Heo1c3fae42006-04-02 20:53:28 +09003105 return 0;
3106
Tejun Heo936fd732007-08-06 18:36:23 +09003107 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
Tejun Heo81952c52006-05-15 20:57:47 +09003108 return rc;
3109
Tejun Heo1c3fae42006-04-02 20:53:28 +09003110 return 1;
3111}
3112
Alan Cox452503f2005-10-21 19:01:32 -04003113/*
3114 * This mode timing computation functionality is ported over from
3115 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
3116 */
3117/*
Alan Coxb352e572006-08-10 18:52:12 +01003118 * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
Alan Cox452503f2005-10-21 19:01:32 -04003119 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
Alan Coxb352e572006-08-10 18:52:12 +01003120 * for UDMA6, which is currently supported only by Maxtor drives.
3121 *
3122 * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0.
Alan Cox452503f2005-10-21 19:01:32 -04003123 */
3124
3125static const struct ata_timing ata_timing[] = {
David Daney3ada9c12009-01-15 17:45:31 -08003126/* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0, 960, 0 }, */
3127 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 0, 600, 0 },
3128 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 0, 383, 0 },
3129 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 0, 240, 0 },
3130 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 0, 180, 0 },
3131 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 0, 120, 0 },
3132 { XFER_PIO_5, 15, 65, 25, 100, 65, 25, 0, 100, 0 },
3133 { XFER_PIO_6, 10, 55, 20, 80, 55, 20, 0, 80, 0 },
Alan Cox452503f2005-10-21 19:01:32 -04003134
David Daney3ada9c12009-01-15 17:45:31 -08003135 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 50, 960, 0 },
3136 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 30, 480, 0 },
3137 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 20, 240, 0 },
Alan Cox452503f2005-10-21 19:01:32 -04003138
David Daney3ada9c12009-01-15 17:45:31 -08003139 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 20, 480, 0 },
3140 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 5, 150, 0 },
3141 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 5, 120, 0 },
3142 { XFER_MW_DMA_3, 25, 0, 0, 0, 65, 25, 5, 100, 0 },
3143 { XFER_MW_DMA_4, 25, 0, 0, 0, 55, 20, 5, 80, 0 },
Alan Cox452503f2005-10-21 19:01:32 -04003144
David Daney3ada9c12009-01-15 17:45:31 -08003145/* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 0, 150 }, */
3146 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 0, 120 },
3147 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 0, 80 },
3148 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 0, 60 },
3149 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 0, 45 },
3150 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 0, 30 },
3151 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 0, 20 },
3152 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 0, 15 },
Alan Cox452503f2005-10-21 19:01:32 -04003153
3154 { 0xFF }
3155};
3156
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003157#define ENOUGH(v, unit) (((v)-1)/(unit)+1)
3158#define EZ(v, unit) ((v)?ENOUGH(v, unit):0)
Alan Cox452503f2005-10-21 19:01:32 -04003159
3160static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
3161{
David Daney3ada9c12009-01-15 17:45:31 -08003162 q->setup = EZ(t->setup * 1000, T);
3163 q->act8b = EZ(t->act8b * 1000, T);
3164 q->rec8b = EZ(t->rec8b * 1000, T);
3165 q->cyc8b = EZ(t->cyc8b * 1000, T);
3166 q->active = EZ(t->active * 1000, T);
3167 q->recover = EZ(t->recover * 1000, T);
3168 q->dmack_hold = EZ(t->dmack_hold * 1000, T);
3169 q->cycle = EZ(t->cycle * 1000, T);
3170 q->udma = EZ(t->udma * 1000, UT);
Alan Cox452503f2005-10-21 19:01:32 -04003171}
3172
3173void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
3174 struct ata_timing *m, unsigned int what)
3175{
3176 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
3177 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
3178 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
3179 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
3180 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
3181 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
David Daney3ada9c12009-01-15 17:45:31 -08003182 if (what & ATA_TIMING_DMACK_HOLD) m->dmack_hold = max(a->dmack_hold, b->dmack_hold);
Alan Cox452503f2005-10-21 19:01:32 -04003183 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
3184 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
3185}
3186
Tejun Heo63573572007-11-27 19:43:39 +09003187const struct ata_timing *ata_timing_find_mode(u8 xfer_mode)
Alan Cox452503f2005-10-21 19:01:32 -04003188{
Tejun Heo70cd0712007-11-27 19:43:40 +09003189 const struct ata_timing *t = ata_timing;
Alan Cox452503f2005-10-21 19:01:32 -04003190
Tejun Heo70cd0712007-11-27 19:43:40 +09003191 while (xfer_mode > t->mode)
3192 t++;
3193
3194 if (xfer_mode == t->mode)
3195 return t;
Borislav Petkovcd705d52012-10-21 18:57:56 +02003196
3197 WARN_ONCE(true, "%s: unable to find timing for xfer_mode 0x%x\n",
3198 __func__, xfer_mode);
3199
Tejun Heo70cd0712007-11-27 19:43:40 +09003200 return NULL;
Alan Cox452503f2005-10-21 19:01:32 -04003201}
3202
3203int ata_timing_compute(struct ata_device *adev, unsigned short speed,
3204 struct ata_timing *t, int T, int UT)
3205{
Bartlomiej Zolnierkiewicz9e8808a2010-01-18 18:13:57 +01003206 const u16 *id = adev->id;
Alan Cox452503f2005-10-21 19:01:32 -04003207 const struct ata_timing *s;
3208 struct ata_timing p;
3209
3210 /*
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05003211 * Find the mode.
Albert Lee75b1f2f2005-11-16 17:06:18 +08003212 */
Alan Cox452503f2005-10-21 19:01:32 -04003213
3214 if (!(s = ata_timing_find_mode(speed)))
3215 return -EINVAL;
3216
Albert Lee75b1f2f2005-11-16 17:06:18 +08003217 memcpy(t, s, sizeof(*s));
3218
Alan Cox452503f2005-10-21 19:01:32 -04003219 /*
3220 * If the drive is an EIDE drive, it can tell us it needs extended
3221 * PIO/MW_DMA cycle timing.
3222 */
3223
Bartlomiej Zolnierkiewicz9e8808a2010-01-18 18:13:57 +01003224 if (id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
Alan Cox452503f2005-10-21 19:01:32 -04003225 memset(&p, 0, sizeof(p));
Bartlomiej Zolnierkiewicz9e8808a2010-01-18 18:13:57 +01003226
Bartlomiej Zolnierkiewiczbff00252011-10-13 15:17:32 +02003227 if (speed >= XFER_PIO_0 && speed < XFER_SW_DMA_0) {
Bartlomiej Zolnierkiewicz9e8808a2010-01-18 18:13:57 +01003228 if (speed <= XFER_PIO_2)
3229 p.cycle = p.cyc8b = id[ATA_ID_EIDE_PIO];
3230 else if ((speed <= XFER_PIO_4) ||
3231 (speed == XFER_PIO_5 && !ata_id_is_cfa(id)))
3232 p.cycle = p.cyc8b = id[ATA_ID_EIDE_PIO_IORDY];
3233 } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2)
3234 p.cycle = id[ATA_ID_EIDE_DMA_MIN];
3235
Alan Cox452503f2005-10-21 19:01:32 -04003236 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
3237 }
3238
3239 /*
3240 * Convert the timing to bus clock counts.
3241 */
3242
Albert Lee75b1f2f2005-11-16 17:06:18 +08003243 ata_timing_quantize(t, t, T, UT);
Alan Cox452503f2005-10-21 19:01:32 -04003244
3245 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003246 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
3247 * S.M.A.R.T * and some other commands. We have to ensure that the
3248 * DMA cycle timing is slower/equal than the fastest PIO timing.
Alan Cox452503f2005-10-21 19:01:32 -04003249 */
3250
Alanfd3367af2006-12-07 12:41:18 +00003251 if (speed > XFER_PIO_6) {
Alan Cox452503f2005-10-21 19:01:32 -04003252 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
3253 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
3254 }
3255
3256 /*
Randy Dunlapc893a3a2006-01-28 13:15:32 -05003257 * Lengthen active & recovery time so that cycle time is correct.
Alan Cox452503f2005-10-21 19:01:32 -04003258 */
3259
3260 if (t->act8b + t->rec8b < t->cyc8b) {
3261 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
3262 t->rec8b = t->cyc8b - t->act8b;
3263 }
3264
3265 if (t->active + t->recover < t->cycle) {
3266 t->active += (t->cycle - (t->active + t->recover)) / 2;
3267 t->recover = t->cycle - t->active;
3268 }
Jeff Garzika617c092007-05-21 20:14:23 -04003269
Alan Cox4f701d12007-04-23 11:55:36 +01003270 /* In a few cases quantisation may produce enough errors to
3271 leave t->cycle too low for the sum of active and recovery
3272 if so we must correct this */
3273 if (t->active + t->recover > t->cycle)
3274 t->cycle = t->active + t->recover;
Alan Cox452503f2005-10-21 19:01:32 -04003275
3276 return 0;
3277}
3278
Tejun Heocf176e12006-04-02 17:54:46 +09003279/**
Tejun Heoa0f79b92007-12-18 16:33:05 +09003280 * ata_timing_cycle2mode - find xfer mode for the specified cycle duration
3281 * @xfer_shift: ATA_SHIFT_* value for transfer type to examine.
3282 * @cycle: cycle duration in ns
3283 *
3284 * Return matching xfer mode for @cycle. The returned mode is of
3285 * the transfer type specified by @xfer_shift. If @cycle is too
3286 * slow for @xfer_shift, 0xff is returned. If @cycle is faster
3287 * than the fastest known mode, the fasted mode is returned.
3288 *
3289 * LOCKING:
3290 * None.
3291 *
3292 * RETURNS:
3293 * Matching xfer_mode, 0xff if no match found.
3294 */
3295u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3296{
3297 u8 base_mode = 0xff, last_mode = 0xff;
3298 const struct ata_xfer_ent *ent;
3299 const struct ata_timing *t;
3300
3301 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3302 if (ent->shift == xfer_shift)
3303 base_mode = ent->base;
3304
3305 for (t = ata_timing_find_mode(base_mode);
3306 t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3307 unsigned short this_cycle;
3308
3309 switch (xfer_shift) {
3310 case ATA_SHIFT_PIO:
3311 case ATA_SHIFT_MWDMA:
3312 this_cycle = t->cycle;
3313 break;
3314 case ATA_SHIFT_UDMA:
3315 this_cycle = t->udma;
3316 break;
3317 default:
3318 return 0xff;
3319 }
3320
3321 if (cycle > this_cycle)
3322 break;
3323
3324 last_mode = t->mode;
3325 }
3326
3327 return last_mode;
3328}
3329
3330/**
Tejun Heocf176e12006-04-02 17:54:46 +09003331 * ata_down_xfermask_limit - adjust dev xfer masks downward
Tejun Heocf176e12006-04-02 17:54:46 +09003332 * @dev: Device to adjust xfer masks
Tejun Heo458337d2007-02-02 16:22:30 +09003333 * @sel: ATA_DNXFER_* selector
Tejun Heocf176e12006-04-02 17:54:46 +09003334 *
3335 * Adjust xfer masks of @dev downward. Note that this function
3336 * does not apply the change. Invoking ata_set_mode() afterwards
3337 * will apply the limit.
3338 *
3339 * LOCKING:
3340 * Inherited from caller.
3341 *
3342 * RETURNS:
3343 * 0 on success, negative errno on failure
3344 */
Tejun Heo458337d2007-02-02 16:22:30 +09003345int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
Tejun Heocf176e12006-04-02 17:54:46 +09003346{
Tejun Heo458337d2007-02-02 16:22:30 +09003347 char buf[32];
Tejun Heo7dc951a2007-11-27 19:43:42 +09003348 unsigned long orig_mask, xfer_mask;
3349 unsigned long pio_mask, mwdma_mask, udma_mask;
Tejun Heo458337d2007-02-02 16:22:30 +09003350 int quiet, highbit;
Tejun Heocf176e12006-04-02 17:54:46 +09003351
Tejun Heo458337d2007-02-02 16:22:30 +09003352 quiet = !!(sel & ATA_DNXFER_QUIET);
3353 sel &= ~ATA_DNXFER_QUIET;
Tejun Heocf176e12006-04-02 17:54:46 +09003354
Tejun Heo458337d2007-02-02 16:22:30 +09003355 xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3356 dev->mwdma_mask,
3357 dev->udma_mask);
3358 ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
Tejun Heocf176e12006-04-02 17:54:46 +09003359
Tejun Heo458337d2007-02-02 16:22:30 +09003360 switch (sel) {
3361 case ATA_DNXFER_PIO:
3362 highbit = fls(pio_mask) - 1;
3363 pio_mask &= ~(1 << highbit);
3364 break;
3365
3366 case ATA_DNXFER_DMA:
3367 if (udma_mask) {
3368 highbit = fls(udma_mask) - 1;
3369 udma_mask &= ~(1 << highbit);
3370 if (!udma_mask)
3371 return -ENOENT;
3372 } else if (mwdma_mask) {
3373 highbit = fls(mwdma_mask) - 1;
3374 mwdma_mask &= ~(1 << highbit);
3375 if (!mwdma_mask)
3376 return -ENOENT;
3377 }
3378 break;
3379
3380 case ATA_DNXFER_40C:
3381 udma_mask &= ATA_UDMA_MASK_40C;
3382 break;
3383
3384 case ATA_DNXFER_FORCE_PIO0:
3385 pio_mask &= 1;
3386 case ATA_DNXFER_FORCE_PIO:
3387 mwdma_mask = 0;
3388 udma_mask = 0;
3389 break;
3390
Tejun Heo458337d2007-02-02 16:22:30 +09003391 default:
3392 BUG();
3393 }
3394
3395 xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3396
3397 if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3398 return -ENOENT;
3399
3400 if (!quiet) {
3401 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3402 snprintf(buf, sizeof(buf), "%s:%s",
3403 ata_mode_string(xfer_mask),
3404 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3405 else
3406 snprintf(buf, sizeof(buf), "%s",
3407 ata_mode_string(xfer_mask));
3408
Joe Perchesa9a79df2011-04-15 15:51:59 -07003409 ata_dev_warn(dev, "limiting speed to %s\n", buf);
Tejun Heo458337d2007-02-02 16:22:30 +09003410 }
Tejun Heocf176e12006-04-02 17:54:46 +09003411
3412 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3413 &dev->udma_mask);
3414
Tejun Heocf176e12006-04-02 17:54:46 +09003415 return 0;
Tejun Heocf176e12006-04-02 17:54:46 +09003416}
3417
Tejun Heo3373efd2006-05-15 20:57:53 +09003418static int ata_dev_set_mode(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419{
Tejun Heod0cb43b2009-07-09 09:27:50 +09003420 struct ata_port *ap = dev->link->ap;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003421 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heod0cb43b2009-07-09 09:27:50 +09003422 const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
Tejun Heo4055dee2008-02-07 10:34:08 +09003423 const char *dev_err_whine = "";
3424 int ign_dev_err = 0;
Tejun Heod0cb43b2009-07-09 09:27:50 +09003425 unsigned int err_mask = 0;
Tejun Heo83206a22006-03-24 15:25:31 +09003426 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427
Tejun Heoe8384602006-04-02 18:51:53 +09003428 dev->flags &= ~ATA_DFLAG_PIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429 if (dev->xfer_shift == ATA_SHIFT_PIO)
3430 dev->flags |= ATA_DFLAG_PIO;
3431
Tejun Heod0cb43b2009-07-09 09:27:50 +09003432 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3433 dev_err_whine = " (SET_XFERMODE skipped)";
3434 else {
3435 if (nosetxfer)
Joe Perchesa9a79df2011-04-15 15:51:59 -07003436 ata_dev_warn(dev,
3437 "NOSETXFER but PATA detected - can't "
3438 "skip SETXFER, might malfunction\n");
Tejun Heod0cb43b2009-07-09 09:27:50 +09003439 err_mask = ata_dev_set_xfermode(dev);
3440 }
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003441
Tejun Heo4055dee2008-02-07 10:34:08 +09003442 if (err_mask & ~AC_ERR_DEV)
3443 goto fail;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003444
Tejun Heo4055dee2008-02-07 10:34:08 +09003445 /* revalidate */
Tejun Heobaa1e782006-11-01 18:39:27 +09003446 ehc->i.flags |= ATA_EHI_POST_SETMODE;
Tejun Heo422c9da2007-09-23 13:14:12 +09003447 rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
Tejun Heobaa1e782006-11-01 18:39:27 +09003448 ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
Tejun Heo5eb45c02006-04-02 18:51:52 +09003449 if (rc)
Tejun Heo83206a22006-03-24 15:25:31 +09003450 return rc;
Tejun Heo48a8a142006-03-05 17:55:58 +09003451
Alan Coxb93fda12008-04-08 16:36:44 +01003452 if (dev->xfer_shift == ATA_SHIFT_PIO) {
3453 /* Old CFA may refuse this command, which is just fine */
3454 if (ata_id_is_cfa(dev->id))
3455 ign_dev_err = 1;
3456 /* Catch several broken garbage emulations plus some pre
3457 ATA devices */
3458 if (ata_id_major_version(dev->id) == 0 &&
3459 dev->pio_mode <= XFER_PIO_2)
3460 ign_dev_err = 1;
3461 /* Some very old devices and some bad newer ones fail
3462 any kind of SET_XFERMODE request but support PIO0-2
3463 timings and no IORDY */
3464 if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3465 ign_dev_err = 1;
3466 }
Tejun Heo4055dee2008-02-07 10:34:08 +09003467 /* Early MWDMA devices do DMA but don't allow DMA mode setting.
3468 Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
3469 if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3470 dev->dma_mode == XFER_MW_DMA_0 &&
3471 (dev->id[63] >> 8) & 1)
3472 ign_dev_err = 1;
3473
3474 /* if the device is actually configured correctly, ignore dev err */
3475 if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3476 ign_dev_err = 1;
3477
3478 if (err_mask & AC_ERR_DEV) {
3479 if (!ign_dev_err)
3480 goto fail;
3481 else
3482 dev_err_whine = " (device error ignored)";
3483 }
3484
Tejun Heo23e71c32006-03-06 04:31:57 +09003485 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
3486 dev->xfer_shift, (int)dev->xfer_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487
Joe Perchesa9a79df2011-04-15 15:51:59 -07003488 ata_dev_info(dev, "configured for %s%s\n",
3489 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3490 dev_err_whine);
Tejun Heo4055dee2008-02-07 10:34:08 +09003491
Tejun Heo83206a22006-03-24 15:25:31 +09003492 return 0;
Tejun Heo4055dee2008-02-07 10:34:08 +09003493
3494 fail:
Joe Perchesa9a79df2011-04-15 15:51:59 -07003495 ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
Tejun Heo4055dee2008-02-07 10:34:08 +09003496 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497}
3498
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499/**
Alan04351822007-03-06 02:37:52 -08003500 * ata_do_set_mode - Program timings and issue SET FEATURES - XFER
Tejun Heo02607312007-08-06 18:36:23 +09003501 * @link: link on which timings will be programmed
Joe Perches1967b7f2008-02-03 17:08:11 +02003502 * @r_failed_dev: out parameter for failed device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 *
Alan04351822007-03-06 02:37:52 -08003504 * Standard implementation of the function used to tune and set
3505 * ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3506 * ata_dev_set_mode() fails, pointer to the failing device is
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003507 * returned in @r_failed_dev.
Jeff Garzik780a87f2005-05-30 15:41:05 -04003508 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04003510 * PCI/etc. bus probe sem.
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003511 *
3512 * RETURNS:
3513 * 0 on success, negative errno otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 */
Alan04351822007-03-06 02:37:52 -08003515
Tejun Heo02607312007-08-06 18:36:23 +09003516int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003517{
Tejun Heo02607312007-08-06 18:36:23 +09003518 struct ata_port *ap = link->ap;
Tejun Heoe8e06192006-04-01 01:38:18 +09003519 struct ata_device *dev;
Tejun Heof58229f2007-08-06 18:36:23 +09003520 int rc = 0, used_dma = 0, found = 0;
Tejun Heo3adcebb2006-05-15 20:57:37 +09003521
Tejun Heoa6d5a512006-03-06 04:31:57 +09003522 /* step 1: calculate xfer_mask */
Tejun Heo1eca4362008-11-03 20:03:17 +09003523 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo7dc951a2007-11-27 19:43:42 +09003524 unsigned long pio_mask, dma_mask;
Alan Coxb3a70602007-10-02 12:38:26 -04003525 unsigned int mode_mask;
Tejun Heoa6d5a512006-03-06 04:31:57 +09003526
Alan Coxb3a70602007-10-02 12:38:26 -04003527 mode_mask = ATA_DMA_MASK_ATA;
3528 if (dev->class == ATA_DEV_ATAPI)
3529 mode_mask = ATA_DMA_MASK_ATAPI;
3530 else if (ata_id_is_cfa(dev->id))
3531 mode_mask = ATA_DMA_MASK_CFA;
3532
Tejun Heo3373efd2006-05-15 20:57:53 +09003533 ata_dev_xfermask(dev);
Tejun Heo33267322008-02-13 09:15:09 +09003534 ata_force_xfermask(dev);
Tejun Heoa6d5a512006-03-06 04:31:57 +09003535
Tejun Heoacf356b2006-03-24 14:07:50 +09003536 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
Alan Coxb3a70602007-10-02 12:38:26 -04003537
3538 if (libata_dma_mask & mode_mask)
Sergei Shtylyov80a9c432011-12-22 22:41:32 +03003539 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3540 dev->udma_mask);
Alan Coxb3a70602007-10-02 12:38:26 -04003541 else
3542 dma_mask = 0;
3543
Tejun Heoacf356b2006-03-24 14:07:50 +09003544 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3545 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01003546
Tejun Heo4f659772006-04-01 01:38:18 +09003547 found = 1;
Alan Coxb15b3eb2008-08-01 09:18:34 +01003548 if (ata_dma_enabled(dev))
Alan Cox5444a6f2006-03-27 18:58:20 +01003549 used_dma = 1;
Tejun Heoa6d5a512006-03-06 04:31:57 +09003550 }
Tejun Heo4f659772006-04-01 01:38:18 +09003551 if (!found)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003552 goto out;
Tejun Heoa6d5a512006-03-06 04:31:57 +09003553
3554 /* step 2: always set host PIO timings */
Tejun Heo1eca4362008-11-03 20:03:17 +09003555 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo70cd0712007-11-27 19:43:40 +09003556 if (dev->pio_mode == 0xff) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003557 ata_dev_warn(dev, "no PIO support\n");
Tejun Heoe8e06192006-04-01 01:38:18 +09003558 rc = -EINVAL;
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003559 goto out;
Tejun Heoe8e06192006-04-01 01:38:18 +09003560 }
3561
3562 dev->xfer_mode = dev->pio_mode;
3563 dev->xfer_shift = ATA_SHIFT_PIO;
3564 if (ap->ops->set_piomode)
3565 ap->ops->set_piomode(ap, dev);
3566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567
Tejun Heoa6d5a512006-03-06 04:31:57 +09003568 /* step 3: set host DMA timings */
Tejun Heo1eca4362008-11-03 20:03:17 +09003569 ata_for_each_dev(dev, link, ENABLED) {
3570 if (!ata_dma_enabled(dev))
Tejun Heoe8e06192006-04-01 01:38:18 +09003571 continue;
3572
3573 dev->xfer_mode = dev->dma_mode;
3574 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3575 if (ap->ops->set_dmamode)
3576 ap->ops->set_dmamode(ap, dev);
3577 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578
3579 /* step 4: update devices' xfer mode */
Tejun Heo1eca4362008-11-03 20:03:17 +09003580 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo3373efd2006-05-15 20:57:53 +09003581 rc = ata_dev_set_mode(dev);
Tejun Heo5bbc53f2006-04-01 01:38:17 +09003582 if (rc)
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003583 goto out;
Tejun Heo83206a22006-03-24 15:25:31 +09003584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585
Tejun Heoe8e06192006-04-01 01:38:18 +09003586 /* Record simplex status. If we selected DMA then the other
3587 * host channels are not permitted to do so.
Alan Cox5444a6f2006-03-27 18:58:20 +01003588 */
Jeff Garzikcca39742006-08-24 03:19:22 -04003589 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
Alan032af1c2007-03-01 17:36:46 +00003590 ap->host->simplex_claimed = ap;
Alan Cox5444a6f2006-03-27 18:58:20 +01003591
Tejun Heoe82cbdb2006-04-01 01:38:18 +09003592 out:
3593 if (rc)
3594 *r_failed_dev = dev;
3595 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596}
3597
3598/**
Tejun Heoaa2731a2008-04-07 22:47:19 +09003599 * ata_wait_ready - wait for link to become ready
3600 * @link: link to be waited on
3601 * @deadline: deadline jiffies for the operation
3602 * @check_ready: callback to check link readiness
3603 *
3604 * Wait for @link to become ready. @check_ready should return
3605 * positive number if @link is ready, 0 if it isn't, -ENODEV if
3606 * link doesn't seem to be occupied, other errno for other error
3607 * conditions.
3608 *
3609 * Transient -ENODEV conditions are allowed for
3610 * ATA_TMOUT_FF_WAIT.
3611 *
3612 * LOCKING:
3613 * EH context.
3614 *
3615 * RETURNS:
Masanari Iidac9b55602016-04-13 23:36:27 +09003616 * 0 if @link is ready before @deadline; otherwise, -errno.
Tejun Heoaa2731a2008-04-07 22:47:19 +09003617 */
3618int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3619 int (*check_ready)(struct ata_link *link))
3620{
3621 unsigned long start = jiffies;
Tejun Heob48d58f2010-04-09 19:46:38 +09003622 unsigned long nodev_deadline;
Tejun Heoaa2731a2008-04-07 22:47:19 +09003623 int warned = 0;
3624
Tejun Heob48d58f2010-04-09 19:46:38 +09003625 /* choose which 0xff timeout to use, read comment in libata.h */
3626 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3627 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3628 else
3629 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3630
Tejun Heob1c72912008-07-31 17:02:43 +09003631 /* Slave readiness can't be tested separately from master. On
3632 * M/S emulation configuration, this function should be called
3633 * only on the master and it will handle both master and slave.
3634 */
3635 WARN_ON(link == link->ap->slave_link);
3636
Tejun Heoaa2731a2008-04-07 22:47:19 +09003637 if (time_after(nodev_deadline, deadline))
3638 nodev_deadline = deadline;
3639
3640 while (1) {
3641 unsigned long now = jiffies;
3642 int ready, tmp;
3643
3644 ready = tmp = check_ready(link);
3645 if (ready > 0)
3646 return 0;
3647
Tejun Heob48d58f2010-04-09 19:46:38 +09003648 /*
3649 * -ENODEV could be transient. Ignore -ENODEV if link
Tejun Heoaa2731a2008-04-07 22:47:19 +09003650 * is online. Also, some SATA devices take a long
Tejun Heob48d58f2010-04-09 19:46:38 +09003651 * time to clear 0xff after reset. Wait for
3652 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3653 * offline.
Tejun Heoaa2731a2008-04-07 22:47:19 +09003654 *
3655 * Note that some PATA controllers (pata_ali) explode
3656 * if status register is read more than once when
3657 * there's no device attached.
3658 */
3659 if (ready == -ENODEV) {
3660 if (ata_link_online(link))
3661 ready = 0;
3662 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3663 !ata_link_offline(link) &&
3664 time_before(now, nodev_deadline))
3665 ready = 0;
3666 }
3667
3668 if (ready)
3669 return ready;
3670 if (time_after(now, deadline))
3671 return -EBUSY;
3672
3673 if (!warned && time_after(now, start + 5 * HZ) &&
3674 (deadline - now > 3 * HZ)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003675 ata_link_warn(link,
Tejun Heoaa2731a2008-04-07 22:47:19 +09003676 "link is slow to respond, please be patient "
3677 "(ready=%d)\n", tmp);
3678 warned = 1;
3679 }
3680
Tejun Heo97750ce2010-09-06 17:56:29 +02003681 ata_msleep(link->ap, 50);
Tejun Heoaa2731a2008-04-07 22:47:19 +09003682 }
3683}
3684
3685/**
3686 * ata_wait_after_reset - wait for link to become ready after reset
3687 * @link: link to be waited on
3688 * @deadline: deadline jiffies for the operation
3689 * @check_ready: callback to check link readiness
3690 *
3691 * Wait for @link to become ready after reset.
3692 *
3693 * LOCKING:
3694 * EH context.
3695 *
3696 * RETURNS:
Masanari Iidac9b55602016-04-13 23:36:27 +09003697 * 0 if @link is ready before @deadline; otherwise, -errno.
Tejun Heoaa2731a2008-04-07 22:47:19 +09003698 */
Harvey Harrison2b4221b2008-04-24 18:37:34 -07003699int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
Tejun Heoaa2731a2008-04-07 22:47:19 +09003700 int (*check_ready)(struct ata_link *link))
3701{
Tejun Heo97750ce2010-09-06 17:56:29 +02003702 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
Tejun Heoaa2731a2008-04-07 22:47:19 +09003703
3704 return ata_wait_ready(link, deadline, check_ready);
3705}
3706
3707/**
Tejun Heo936fd732007-08-06 18:36:23 +09003708 * sata_link_debounce - debounce SATA phy status
3709 * @link: ATA link to debounce SATA phy status for
Masanari Iidac9b55602016-04-13 23:36:27 +09003710 * @params: timing parameters { interval, duration, timeout } in msec
Tejun Heod4b2bab2007-02-02 16:50:52 +09003711 * @deadline: deadline jiffies for the operation
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003712 *
Tejun Heo1152b262010-09-01 17:50:05 +02003713 * Make sure SStatus of @link reaches stable state, determined by
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003714 * holding the same value where DET is not 1 for @duration polled
3715 * every @interval, before @timeout. Timeout constraints the
Tejun Heod4b2bab2007-02-02 16:50:52 +09003716 * beginning of the stable state. Because DET gets stuck at 1 on
3717 * some controllers after hot unplugging, this functions waits
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003718 * until timeout then returns 0 if DET is stable at 1.
3719 *
Tejun Heod4b2bab2007-02-02 16:50:52 +09003720 * @timeout is further limited by @deadline. The sooner of the
3721 * two is used.
3722 *
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003723 * LOCKING:
3724 * Kernel thread context (may sleep)
3725 *
3726 * RETURNS:
3727 * 0 on success, -errno on failure.
3728 */
Tejun Heo936fd732007-08-06 18:36:23 +09003729int sata_link_debounce(struct ata_link *link, const unsigned long *params,
3730 unsigned long deadline)
Tejun Heo7a7921e2006-02-02 18:20:00 +09003731{
Tejun Heo341c2c92008-05-20 02:17:51 +09003732 unsigned long interval = params[0];
3733 unsigned long duration = params[1];
Tejun Heod4b2bab2007-02-02 16:50:52 +09003734 unsigned long last_jiffies, t;
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003735 u32 last, cur;
3736 int rc;
3737
Tejun Heo341c2c92008-05-20 02:17:51 +09003738 t = ata_deadline(jiffies, params[2]);
Tejun Heod4b2bab2007-02-02 16:50:52 +09003739 if (time_before(t, deadline))
3740 deadline = t;
3741
Tejun Heo936fd732007-08-06 18:36:23 +09003742 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003743 return rc;
3744 cur &= 0xf;
3745
3746 last = cur;
3747 last_jiffies = jiffies;
3748
3749 while (1) {
Tejun Heo97750ce2010-09-06 17:56:29 +02003750 ata_msleep(link->ap, interval);
Tejun Heo936fd732007-08-06 18:36:23 +09003751 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003752 return rc;
3753 cur &= 0xf;
3754
3755 /* DET stable? */
3756 if (cur == last) {
Tejun Heod4b2bab2007-02-02 16:50:52 +09003757 if (cur == 1 && time_before(jiffies, deadline))
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003758 continue;
Tejun Heo341c2c92008-05-20 02:17:51 +09003759 if (time_after(jiffies,
3760 ata_deadline(last_jiffies, duration)))
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003761 return 0;
3762 continue;
3763 }
3764
3765 /* unstable, start over */
3766 last = cur;
3767 last_jiffies = jiffies;
3768
Tejun Heof1545152007-07-16 14:29:40 +09003769 /* Check deadline. If debouncing failed, return
3770 * -EPIPE to tell upper layer to lower link speed.
3771 */
Tejun Heod4b2bab2007-02-02 16:50:52 +09003772 if (time_after(jiffies, deadline))
Tejun Heof1545152007-07-16 14:29:40 +09003773 return -EPIPE;
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003774 }
3775}
3776
3777/**
Tejun Heo936fd732007-08-06 18:36:23 +09003778 * sata_link_resume - resume SATA link
3779 * @link: ATA link to resume SATA
Masanari Iidac9b55602016-04-13 23:36:27 +09003780 * @params: timing parameters { interval, duration, timeout } in msec
Tejun Heod4b2bab2007-02-02 16:50:52 +09003781 * @deadline: deadline jiffies for the operation
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003782 *
Tejun Heo936fd732007-08-06 18:36:23 +09003783 * Resume SATA phy @link and debounce it.
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003784 *
3785 * LOCKING:
3786 * Kernel thread context (may sleep)
3787 *
3788 * RETURNS:
3789 * 0 on success, -errno on failure.
3790 */
Tejun Heo936fd732007-08-06 18:36:23 +09003791int sata_link_resume(struct ata_link *link, const unsigned long *params,
3792 unsigned long deadline)
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003793{
Tejun Heo5040ab62010-01-11 11:14:44 +09003794 int tries = ATA_LINK_RESUME_TRIES;
Tejun Heoac371982008-04-07 22:47:19 +09003795 u32 scontrol, serror;
Tejun Heo81952c52006-05-15 20:57:47 +09003796 int rc;
Tejun Heo7a7921e2006-02-02 18:20:00 +09003797
Tejun Heo936fd732007-08-06 18:36:23 +09003798 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
Tejun Heo81952c52006-05-15 20:57:47 +09003799 return rc;
3800
Tejun Heo5040ab62010-01-11 11:14:44 +09003801 /*
3802 * Writes to SControl sometimes get ignored under certain
3803 * controllers (ata_piix SIDPR). Make sure DET actually is
3804 * cleared.
Tejun Heod7bb4cc2006-05-31 18:27:46 +09003805 */
Tejun Heo5040ab62010-01-11 11:14:44 +09003806 do {
3807 scontrol = (scontrol & 0x0f0) | 0x300;
3808 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3809 return rc;
3810 /*
3811 * Some PHYs react badly if SStatus is pounded
3812 * immediately after resuming. Delay 200ms before
3813 * debouncing.
3814 */
Danesh Petigarae39b2bb2016-01-07 16:03:33 -08003815 if (!(link->flags & ATA_LFLAG_NO_DB_DELAY))
3816 ata_msleep(link->ap, 200);
Tejun Heo5040ab62010-01-11 11:14:44 +09003817
3818 /* is SControl restored correctly? */
3819 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3820 return rc;
3821 } while ((scontrol & 0xf0f) != 0x300 && --tries);
3822
3823 if ((scontrol & 0xf0f) != 0x300) {
Tejun Heo38941c92011-07-01 15:12:09 +02003824 ata_link_warn(link, "failed to resume link (SControl %X)\n",
Joe Perchesa9a79df2011-04-15 15:51:59 -07003825 scontrol);
Tejun Heo5040ab62010-01-11 11:14:44 +09003826 return 0;
3827 }
3828
3829 if (tries < ATA_LINK_RESUME_TRIES)
Joe Perchesa9a79df2011-04-15 15:51:59 -07003830 ata_link_warn(link, "link resume succeeded after %d retries\n",
3831 ATA_LINK_RESUME_TRIES - tries);
Tejun Heo7a7921e2006-02-02 18:20:00 +09003832
Tejun Heoac371982008-04-07 22:47:19 +09003833 if ((rc = sata_link_debounce(link, params, deadline)))
3834 return rc;
3835
Tejun Heof0465192008-05-19 01:15:08 +09003836 /* clear SError, some PHYs require this even for SRST to work */
Tejun Heoac371982008-04-07 22:47:19 +09003837 if (!(rc = sata_scr_read(link, SCR_ERROR, &serror)))
3838 rc = sata_scr_write(link, SCR_ERROR, serror);
Tejun Heoac371982008-04-07 22:47:19 +09003839
Tejun Heof0465192008-05-19 01:15:08 +09003840 return rc != -EINVAL ? rc : 0;
Tejun Heo7a7921e2006-02-02 18:20:00 +09003841}
3842
Tejun Heof5914a42006-05-31 18:27:48 +09003843/**
Tejun Heo1152b262010-09-01 17:50:05 +02003844 * sata_link_scr_lpm - manipulate SControl IPM and SPM fields
3845 * @link: ATA link to manipulate SControl for
3846 * @policy: LPM policy to configure
3847 * @spm_wakeup: initiate LPM transition to active state
3848 *
3849 * Manipulate the IPM field of the SControl register of @link
3850 * according to @policy. If @policy is ATA_LPM_MAX_POWER and
3851 * @spm_wakeup is %true, the SPM field is manipulated to wake up
3852 * the link. This function also clears PHYRDY_CHG before
3853 * returning.
3854 *
3855 * LOCKING:
3856 * EH context.
3857 *
3858 * RETURNS:
Masanari Iida84851872015-05-29 23:11:51 +09003859 * 0 on success, -errno otherwise.
Tejun Heo1152b262010-09-01 17:50:05 +02003860 */
3861int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
3862 bool spm_wakeup)
3863{
3864 struct ata_eh_context *ehc = &link->eh_context;
3865 bool woken_up = false;
3866 u32 scontrol;
3867 int rc;
3868
3869 rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
3870 if (rc)
3871 return rc;
3872
3873 switch (policy) {
3874 case ATA_LPM_MAX_POWER:
3875 /* disable all LPM transitions */
Shane Huang65fe1f02012-09-07 22:40:01 +08003876 scontrol |= (0x7 << 8);
Tejun Heo1152b262010-09-01 17:50:05 +02003877 /* initiate transition to active state */
3878 if (spm_wakeup) {
3879 scontrol |= (0x4 << 12);
3880 woken_up = true;
3881 }
3882 break;
3883 case ATA_LPM_MED_POWER:
3884 /* allow LPM to PARTIAL */
3885 scontrol &= ~(0x1 << 8);
Shane Huang65fe1f02012-09-07 22:40:01 +08003886 scontrol |= (0x6 << 8);
Tejun Heo1152b262010-09-01 17:50:05 +02003887 break;
3888 case ATA_LPM_MIN_POWER:
Kristen Carlson Accardi8a745f12011-03-04 10:24:11 -08003889 if (ata_link_nr_enabled(link) > 0)
3890 /* no restrictions on LPM transitions */
Shane Huang65fe1f02012-09-07 22:40:01 +08003891 scontrol &= ~(0x7 << 8);
Kristen Carlson Accardi8a745f12011-03-04 10:24:11 -08003892 else {
3893 /* empty port, power off */
3894 scontrol &= ~0xf;
3895 scontrol |= (0x1 << 2);
3896 }
Tejun Heo1152b262010-09-01 17:50:05 +02003897 break;
3898 default:
3899 WARN_ON(1);
3900 }
3901
3902 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
3903 if (rc)
3904 return rc;
3905
3906 /* give the link time to transit out of LPM state */
3907 if (woken_up)
3908 msleep(10);
3909
3910 /* clear PHYRDY_CHG from SError */
3911 ehc->i.serror &= ~SERR_PHYRDY_CHG;
3912 return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
3913}
3914
3915/**
Tejun Heo0aa11132008-04-07 22:47:18 +09003916 * ata_std_prereset - prepare for reset
Tejun Heocc0680a2007-08-06 18:36:23 +09003917 * @link: ATA link to be reset
Tejun Heod4b2bab2007-02-02 16:50:52 +09003918 * @deadline: deadline jiffies for the operation
Tejun Heof5914a42006-05-31 18:27:48 +09003919 *
Tejun Heocc0680a2007-08-06 18:36:23 +09003920 * @link is about to be reset. Initialize it. Failure from
Tejun Heob8cffc62007-02-02 16:50:52 +09003921 * prereset makes libata abort whole reset sequence and give up
3922 * that port, so prereset should be best-effort. It does its
3923 * best to prepare for reset sequence but if things go wrong, it
3924 * should just whine, not fail.
Tejun Heof5914a42006-05-31 18:27:48 +09003925 *
3926 * LOCKING:
3927 * Kernel thread context (may sleep)
3928 *
3929 * RETURNS:
3930 * 0 on success, -errno otherwise.
3931 */
Tejun Heo0aa11132008-04-07 22:47:18 +09003932int ata_std_prereset(struct ata_link *link, unsigned long deadline)
Tejun Heof5914a42006-05-31 18:27:48 +09003933{
Tejun Heocc0680a2007-08-06 18:36:23 +09003934 struct ata_port *ap = link->ap;
Tejun Heo936fd732007-08-06 18:36:23 +09003935 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heoe9c83912006-07-03 16:07:26 +09003936 const unsigned long *timing = sata_ehc_deb_timing(ehc);
Tejun Heof5914a42006-05-31 18:27:48 +09003937 int rc;
3938
Tejun Heof5914a42006-05-31 18:27:48 +09003939 /* if we're about to do hardreset, nothing more to do */
3940 if (ehc->i.action & ATA_EH_HARDRESET)
3941 return 0;
3942
Tejun Heo936fd732007-08-06 18:36:23 +09003943 /* if SATA, resume link */
Tejun Heoa16abc02007-05-21 18:33:47 +02003944 if (ap->flags & ATA_FLAG_SATA) {
Tejun Heo936fd732007-08-06 18:36:23 +09003945 rc = sata_link_resume(link, timing, deadline);
Tejun Heob8cffc62007-02-02 16:50:52 +09003946 /* whine about phy resume failure but proceed */
3947 if (rc && rc != -EOPNOTSUPP)
Joe Perchesa9a79df2011-04-15 15:51:59 -07003948 ata_link_warn(link,
3949 "failed to resume link for reset (errno=%d)\n",
3950 rc);
Tejun Heof5914a42006-05-31 18:27:48 +09003951 }
3952
Tejun Heo45db2f62008-04-08 01:46:56 +09003953 /* no point in trying softreset on offline link */
Tejun Heob1c72912008-07-31 17:02:43 +09003954 if (ata_phys_link_offline(link))
Tejun Heo45db2f62008-04-08 01:46:56 +09003955 ehc->i.action &= ~ATA_EH_SOFTRESET;
3956
Tejun Heof5914a42006-05-31 18:27:48 +09003957 return 0;
3958}
3959
Tejun Heoc2bd5802006-01-24 17:05:22 +09003960/**
Tejun Heocc0680a2007-08-06 18:36:23 +09003961 * sata_link_hardreset - reset link via SATA phy reset
3962 * @link: link to reset
Masanari Iidac9b55602016-04-13 23:36:27 +09003963 * @timing: timing parameters { interval, duration, timeout } in msec
Tejun Heod4b2bab2007-02-02 16:50:52 +09003964 * @deadline: deadline jiffies for the operation
Tejun Heo9dadd452008-04-07 22:47:19 +09003965 * @online: optional out parameter indicating link onlineness
3966 * @check_ready: optional callback to check link readiness
Tejun Heoc2bd5802006-01-24 17:05:22 +09003967 *
Tejun Heocc0680a2007-08-06 18:36:23 +09003968 * SATA phy-reset @link using DET bits of SControl register.
Tejun Heo9dadd452008-04-07 22:47:19 +09003969 * After hardreset, link readiness is waited upon using
3970 * ata_wait_ready() if @check_ready is specified. LLDs are
3971 * allowed to not specify @check_ready and wait itself after this
3972 * function returns. Device classification is LLD's
3973 * responsibility.
3974 *
3975 * *@online is set to one iff reset succeeded and @link is online
3976 * after reset.
Tejun Heoc2bd5802006-01-24 17:05:22 +09003977 *
3978 * LOCKING:
3979 * Kernel thread context (may sleep)
3980 *
3981 * RETURNS:
3982 * 0 on success, -errno otherwise.
3983 */
Tejun Heocc0680a2007-08-06 18:36:23 +09003984int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
Tejun Heo9dadd452008-04-07 22:47:19 +09003985 unsigned long deadline,
3986 bool *online, int (*check_ready)(struct ata_link *))
Tejun Heoc2bd5802006-01-24 17:05:22 +09003987{
Tejun Heo852ee162006-04-01 01:38:18 +09003988 u32 scontrol;
Tejun Heo81952c52006-05-15 20:57:47 +09003989 int rc;
Tejun Heo852ee162006-04-01 01:38:18 +09003990
Tejun Heoc2bd5802006-01-24 17:05:22 +09003991 DPRINTK("ENTER\n");
3992
Tejun Heo9dadd452008-04-07 22:47:19 +09003993 if (online)
3994 *online = false;
3995
Tejun Heo936fd732007-08-06 18:36:23 +09003996 if (sata_set_spd_needed(link)) {
Tejun Heo1c3fae42006-04-02 20:53:28 +09003997 /* SATA spec says nothing about how to reconfigure
3998 * spd. To be on the safe side, turn off phy during
3999 * reconfiguration. This works for at least ICH7 AHCI
4000 * and Sil3124.
4001 */
Tejun Heo936fd732007-08-06 18:36:23 +09004002 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
Tejun Heob6103f62006-11-01 17:59:53 +09004003 goto out;
Tejun Heo81952c52006-05-15 20:57:47 +09004004
Martin Hicksa34b6fc2006-07-05 15:06:13 -04004005 scontrol = (scontrol & 0x0f0) | 0x304;
Tejun Heo81952c52006-05-15 20:57:47 +09004006
Tejun Heo936fd732007-08-06 18:36:23 +09004007 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
Tejun Heob6103f62006-11-01 17:59:53 +09004008 goto out;
Tejun Heo1c3fae42006-04-02 20:53:28 +09004009
Tejun Heo936fd732007-08-06 18:36:23 +09004010 sata_set_spd(link);
Tejun Heo1c3fae42006-04-02 20:53:28 +09004011 }
4012
4013 /* issue phy wake/reset */
Tejun Heo936fd732007-08-06 18:36:23 +09004014 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
Tejun Heob6103f62006-11-01 17:59:53 +09004015 goto out;
Tejun Heo81952c52006-05-15 20:57:47 +09004016
Tejun Heo852ee162006-04-01 01:38:18 +09004017 scontrol = (scontrol & 0x0f0) | 0x301;
Tejun Heo81952c52006-05-15 20:57:47 +09004018
Tejun Heo936fd732007-08-06 18:36:23 +09004019 if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
Tejun Heob6103f62006-11-01 17:59:53 +09004020 goto out;
Tejun Heoc2bd5802006-01-24 17:05:22 +09004021
Tejun Heo1c3fae42006-04-02 20:53:28 +09004022 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
Tejun Heoc2bd5802006-01-24 17:05:22 +09004023 * 10.4.2 says at least 1 ms.
4024 */
Tejun Heo97750ce2010-09-06 17:56:29 +02004025 ata_msleep(link->ap, 1);
Tejun Heoc2bd5802006-01-24 17:05:22 +09004026
Tejun Heo936fd732007-08-06 18:36:23 +09004027 /* bring link back */
4028 rc = sata_link_resume(link, timing, deadline);
Tejun Heo9dadd452008-04-07 22:47:19 +09004029 if (rc)
4030 goto out;
4031 /* if link is offline nothing more to do */
Tejun Heob1c72912008-07-31 17:02:43 +09004032 if (ata_phys_link_offline(link))
Tejun Heo9dadd452008-04-07 22:47:19 +09004033 goto out;
4034
4035 /* Link is online. From this point, -ENODEV too is an error. */
4036 if (online)
4037 *online = true;
4038
Tejun Heo071f44b2008-04-07 22:47:22 +09004039 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) {
Tejun Heo9dadd452008-04-07 22:47:19 +09004040 /* If PMP is supported, we have to do follow-up SRST.
4041 * Some PMPs don't send D2H Reg FIS after hardreset if
4042 * the first port is empty. Wait only for
4043 * ATA_TMOUT_PMP_SRST_WAIT.
4044 */
4045 if (check_ready) {
4046 unsigned long pmp_deadline;
4047
Tejun Heo341c2c92008-05-20 02:17:51 +09004048 pmp_deadline = ata_deadline(jiffies,
4049 ATA_TMOUT_PMP_SRST_WAIT);
Tejun Heo9dadd452008-04-07 22:47:19 +09004050 if (time_after(pmp_deadline, deadline))
4051 pmp_deadline = deadline;
4052 ata_wait_ready(link, pmp_deadline, check_ready);
4053 }
4054 rc = -EAGAIN;
4055 goto out;
4056 }
4057
4058 rc = 0;
4059 if (check_ready)
4060 rc = ata_wait_ready(link, deadline, check_ready);
Tejun Heob6103f62006-11-01 17:59:53 +09004061 out:
Tejun Heo0cbf0712008-05-19 01:15:05 +09004062 if (rc && rc != -EAGAIN) {
4063 /* online is set iff link is online && reset succeeded */
4064 if (online)
4065 *online = false;
Joe Perchesa9a79df2011-04-15 15:51:59 -07004066 ata_link_err(link, "COMRESET failed (errno=%d)\n", rc);
Tejun Heo0cbf0712008-05-19 01:15:05 +09004067 }
Tejun Heob6103f62006-11-01 17:59:53 +09004068 DPRINTK("EXIT, rc=%d\n", rc);
4069 return rc;
4070}
4071
4072/**
Tejun Heo57c9efd2008-04-07 22:47:19 +09004073 * sata_std_hardreset - COMRESET w/o waiting or classification
4074 * @link: link to reset
4075 * @class: resulting class of attached device
4076 * @deadline: deadline jiffies for the operation
4077 *
4078 * Standard SATA COMRESET w/o waiting or classification.
4079 *
4080 * LOCKING:
4081 * Kernel thread context (may sleep)
4082 *
4083 * RETURNS:
4084 * 0 if link offline, -EAGAIN if link online, -errno on errors.
4085 */
4086int sata_std_hardreset(struct ata_link *link, unsigned int *class,
4087 unsigned long deadline)
4088{
4089 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
4090 bool online;
4091 int rc;
4092
4093 /* do hardreset */
4094 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
Tejun Heo57c9efd2008-04-07 22:47:19 +09004095 return online ? -EAGAIN : rc;
4096}
4097
4098/**
Tejun Heo203c75b2008-04-07 22:47:18 +09004099 * ata_std_postreset - standard postreset callback
Tejun Heocc0680a2007-08-06 18:36:23 +09004100 * @link: the target ata_link
Tejun Heoc2bd5802006-01-24 17:05:22 +09004101 * @classes: classes of attached devices
4102 *
4103 * This function is invoked after a successful reset. Note that
4104 * the device might have been reset more than once using
4105 * different reset methods before postreset is invoked.
Tejun Heoc2bd5802006-01-24 17:05:22 +09004106 *
Tejun Heoc2bd5802006-01-24 17:05:22 +09004107 * LOCKING:
4108 * Kernel thread context (may sleep)
4109 */
Tejun Heo203c75b2008-04-07 22:47:18 +09004110void ata_std_postreset(struct ata_link *link, unsigned int *classes)
Tejun Heoc2bd5802006-01-24 17:05:22 +09004111{
Tejun Heof0465192008-05-19 01:15:08 +09004112 u32 serror;
4113
Tejun Heoc2bd5802006-01-24 17:05:22 +09004114 DPRINTK("ENTER\n");
4115
Tejun Heof0465192008-05-19 01:15:08 +09004116 /* reset complete, clear SError */
4117 if (!sata_scr_read(link, SCR_ERROR, &serror))
4118 sata_scr_write(link, SCR_ERROR, serror);
4119
Tejun Heoc2bd5802006-01-24 17:05:22 +09004120 /* print link status */
Tejun Heo936fd732007-08-06 18:36:23 +09004121 sata_print_link_status(link);
Tejun Heoc2bd5802006-01-24 17:05:22 +09004122
Tejun Heoc2bd5802006-01-24 17:05:22 +09004123 DPRINTK("EXIT\n");
4124}
4125
Tejun Heoa62c0fc2006-01-24 17:05:22 +09004126/**
Tejun Heo623a3122006-03-05 17:55:58 +09004127 * ata_dev_same_device - Determine whether new ID matches configured device
Tejun Heo623a3122006-03-05 17:55:58 +09004128 * @dev: device to compare against
4129 * @new_class: class of the new device
4130 * @new_id: IDENTIFY page of the new device
4131 *
4132 * Compare @new_class and @new_id against @dev and determine
4133 * whether @dev is the device indicated by @new_class and
4134 * @new_id.
4135 *
4136 * LOCKING:
4137 * None.
4138 *
4139 * RETURNS:
4140 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
4141 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004142static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
4143 const u16 *new_id)
Tejun Heo623a3122006-03-05 17:55:58 +09004144{
4145 const u16 *old_id = dev->id;
Tejun Heoa0cf7332007-01-02 20:18:49 +09004146 unsigned char model[2][ATA_ID_PROD_LEN + 1];
4147 unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
Tejun Heo623a3122006-03-05 17:55:58 +09004148
4149 if (dev->class != new_class) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004150 ata_dev_info(dev, "class mismatch %d != %d\n",
4151 dev->class, new_class);
Tejun Heo623a3122006-03-05 17:55:58 +09004152 return 0;
4153 }
4154
Tejun Heoa0cf7332007-01-02 20:18:49 +09004155 ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
4156 ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
4157 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
4158 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
Tejun Heo623a3122006-03-05 17:55:58 +09004159
4160 if (strcmp(model[0], model[1])) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004161 ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
4162 model[0], model[1]);
Tejun Heo623a3122006-03-05 17:55:58 +09004163 return 0;
4164 }
4165
4166 if (strcmp(serial[0], serial[1])) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004167 ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
4168 serial[0], serial[1]);
Tejun Heo623a3122006-03-05 17:55:58 +09004169 return 0;
4170 }
4171
Tejun Heo623a3122006-03-05 17:55:58 +09004172 return 1;
4173}
4174
4175/**
Tejun Heofe309112007-05-15 03:28:15 +09004176 * ata_dev_reread_id - Re-read IDENTIFY data
Henrik Kretzschmar3fae4502007-06-19 10:10:50 +02004177 * @dev: target ATA device
Tejun Heobff04642006-11-10 18:08:10 +09004178 * @readid_flags: read ID flags
Tejun Heo623a3122006-03-05 17:55:58 +09004179 *
4180 * Re-read IDENTIFY page and make sure @dev is still attached to
4181 * the port.
4182 *
4183 * LOCKING:
4184 * Kernel thread context (may sleep)
4185 *
4186 * RETURNS:
4187 * 0 on success, negative errno otherwise
4188 */
Tejun Heofe309112007-05-15 03:28:15 +09004189int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
Tejun Heo623a3122006-03-05 17:55:58 +09004190{
Tejun Heo5eb45c02006-04-02 18:51:52 +09004191 unsigned int class = dev->class;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09004192 u16 *id = (void *)dev->link->ap->sector_buf;
Tejun Heo623a3122006-03-05 17:55:58 +09004193 int rc;
4194
Tejun Heofe635c72006-05-15 20:57:35 +09004195 /* read ID data */
Tejun Heobff04642006-11-10 18:08:10 +09004196 rc = ata_dev_read_id(dev, &class, readid_flags, id);
Tejun Heo623a3122006-03-05 17:55:58 +09004197 if (rc)
Tejun Heofe309112007-05-15 03:28:15 +09004198 return rc;
Tejun Heo623a3122006-03-05 17:55:58 +09004199
4200 /* is the device still there? */
Tejun Heofe309112007-05-15 03:28:15 +09004201 if (!ata_dev_same_device(dev, class, id))
4202 return -ENODEV;
Tejun Heo623a3122006-03-05 17:55:58 +09004203
Tejun Heofe635c72006-05-15 20:57:35 +09004204 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
Tejun Heofe309112007-05-15 03:28:15 +09004205 return 0;
4206}
4207
4208/**
4209 * ata_dev_revalidate - Revalidate ATA device
4210 * @dev: device to revalidate
Tejun Heo422c9da2007-09-23 13:14:12 +09004211 * @new_class: new class code
Tejun Heofe309112007-05-15 03:28:15 +09004212 * @readid_flags: read ID flags
4213 *
4214 * Re-read IDENTIFY page, make sure @dev is still attached to the
4215 * port and reconfigure it according to the new IDENTIFY page.
4216 *
4217 * LOCKING:
4218 * Kernel thread context (may sleep)
4219 *
4220 * RETURNS:
4221 * 0 on success, negative errno otherwise
4222 */
Tejun Heo422c9da2007-09-23 13:14:12 +09004223int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
4224 unsigned int readid_flags)
Tejun Heofe309112007-05-15 03:28:15 +09004225{
Tejun Heo6ddcd3b2007-05-15 03:28:15 +09004226 u64 n_sectors = dev->n_sectors;
Tejun Heo5920dad2009-07-15 17:11:41 +09004227 u64 n_native_sectors = dev->n_native_sectors;
Tejun Heofe309112007-05-15 03:28:15 +09004228 int rc;
4229
4230 if (!ata_dev_enabled(dev))
4231 return -ENODEV;
4232
Tejun Heo422c9da2007-09-23 13:14:12 +09004233 /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
4234 if (ata_class_enabled(new_class) &&
Borislav Petkovf0d06132009-04-26 16:33:34 +02004235 new_class != ATA_DEV_ATA &&
4236 new_class != ATA_DEV_ATAPI &&
Hannes Reinecke9162c652014-11-05 13:08:21 +01004237 new_class != ATA_DEV_ZAC &&
Borislav Petkovf0d06132009-04-26 16:33:34 +02004238 new_class != ATA_DEV_SEMB) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004239 ata_dev_info(dev, "class mismatch %u != %u\n",
4240 dev->class, new_class);
Tejun Heo422c9da2007-09-23 13:14:12 +09004241 rc = -ENODEV;
4242 goto fail;
4243 }
4244
Tejun Heofe309112007-05-15 03:28:15 +09004245 /* re-read ID */
4246 rc = ata_dev_reread_id(dev, readid_flags);
4247 if (rc)
4248 goto fail;
Tejun Heo623a3122006-03-05 17:55:58 +09004249
4250 /* configure device according to the new ID */
Tejun Heoefdaedc2006-11-01 18:38:52 +09004251 rc = ata_dev_configure(dev);
Tejun Heo6ddcd3b2007-05-15 03:28:15 +09004252 if (rc)
4253 goto fail;
4254
4255 /* verify n_sectors hasn't changed */
Tejun Heo445d2112010-04-05 10:33:13 +09004256 if (dev->class != ATA_DEV_ATA || !n_sectors ||
4257 dev->n_sectors == n_sectors)
4258 return 0;
4259
4260 /* n_sectors has changed */
Joe Perchesa9a79df2011-04-15 15:51:59 -07004261 ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
4262 (unsigned long long)n_sectors,
4263 (unsigned long long)dev->n_sectors);
Tejun Heo445d2112010-04-05 10:33:13 +09004264
4265 /*
4266 * Something could have caused HPA to be unlocked
4267 * involuntarily. If n_native_sectors hasn't changed and the
4268 * new size matches it, keep the device.
4269 */
4270 if (dev->n_native_sectors == n_native_sectors &&
4271 dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004272 ata_dev_warn(dev,
4273 "new n_sectors matches native, probably "
4274 "late HPA unlock, n_sectors updated\n");
Tejun Heo68939ce2010-05-15 20:09:33 +02004275 /* use the larger n_sectors */
Tejun Heo445d2112010-04-05 10:33:13 +09004276 return 0;
Tejun Heo6ddcd3b2007-05-15 03:28:15 +09004277 }
4278
Tejun Heo445d2112010-04-05 10:33:13 +09004279 /*
4280 * Some BIOSes boot w/o HPA but resume w/ HPA locked. Try
4281 * unlocking HPA in those cases.
4282 *
4283 * https://bugzilla.kernel.org/show_bug.cgi?id=15396
4284 */
4285 if (dev->n_native_sectors == n_native_sectors &&
4286 dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
4287 !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004288 ata_dev_warn(dev,
4289 "old n_sectors matches native, probably "
4290 "late HPA lock, will try to unlock HPA\n");
Tejun Heo445d2112010-04-05 10:33:13 +09004291 /* try unlocking HPA */
4292 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
4293 rc = -EIO;
4294 } else
4295 rc = -ENODEV;
Tejun Heo623a3122006-03-05 17:55:58 +09004296
Tejun Heo445d2112010-04-05 10:33:13 +09004297 /* restore original n_[native_]sectors and fail */
4298 dev->n_native_sectors = n_native_sectors;
4299 dev->n_sectors = n_sectors;
Tejun Heo623a3122006-03-05 17:55:58 +09004300 fail:
Joe Perchesa9a79df2011-04-15 15:51:59 -07004301 ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
Tejun Heo623a3122006-03-05 17:55:58 +09004302 return rc;
4303}
4304
Alan Cox6919a0a2006-10-27 19:08:46 -07004305struct ata_blacklist_entry {
4306 const char *model_num;
4307 const char *model_rev;
4308 unsigned long horkage;
4309};
4310
4311static const struct ata_blacklist_entry ata_device_blacklist [] = {
4312 /* Devices with DMA related problems under Linux */
4313 { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA },
4314 { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA },
4315 { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA },
4316 { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA },
4317 { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA },
4318 { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA },
4319 { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA },
4320 { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA },
4321 { "CRD-8400B", NULL, ATA_HORKAGE_NODMA },
Mark Lord7da4c932010-07-01 18:18:12 -04004322 { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA },
Alan Cox6919a0a2006-10-27 19:08:46 -07004323 { "CRD-84", NULL, ATA_HORKAGE_NODMA },
4324 { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA },
4325 { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
4326 { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA },
4327 { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA },
Mark Lord7da4c932010-07-01 18:18:12 -04004328 { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA },
Alan Cox6919a0a2006-10-27 19:08:46 -07004329 { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA },
4330 { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA },
4331 { "CD-532E-A", NULL, ATA_HORKAGE_NODMA },
4332 { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA },
4333 { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA },
4334 { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
4335 { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
4336 { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
Alan Cox6919a0a2006-10-27 19:08:46 -07004337 { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
4338 { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
Jeff Garzik2dcb4072007-10-19 06:42:56 -04004339 { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA },
Dave Jones39f19882007-05-21 14:31:03 -04004340 { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA },
Prarit Bhargavad17d794c2012-08-23 15:11:52 -04004341 { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA },
Shikha Jainb00622f2016-01-11 14:55:45 -08004342 { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
Tejun Heo3af9a772007-09-23 13:19:54 +09004343 /* Odd clown on sil3726/4726 PMPs */
Tejun Heo50af2fa2008-05-19 01:15:14 +09004344 { "Config Disk", NULL, ATA_HORKAGE_DISABLE },
Alan Cox6919a0a2006-10-27 19:08:46 -07004345
Albert Lee18d6e9d2007-04-02 11:34:15 +08004346 /* Weird ATAPI devices */
Tejun Heo40a1d532007-06-27 02:49:38 +09004347 { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },
Tejun Heo6a87e422008-11-03 19:01:09 +09004348 { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA },
Shan Haia32450e2013-03-18 10:30:44 +08004349 { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
Shan Hai0523f032013-10-28 16:08:01 +08004350 { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
Albert Lee18d6e9d2007-04-02 11:34:15 +08004351
David Milburnaf34d632015-07-13 11:48:23 -05004352 /*
4353 * Causes silent data corruption with higher max sects.
4354 * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
4355 */
4356 { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 },
4357
Tejun Heo1488a1e2016-07-18 18:40:00 -04004358 /*
4359 * Device times out with higher max sects.
4360 * https://bugzilla.kernel.org/show_bug.cgi?id=121671
4361 */
4362 { "LITEON CX1-JB256-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 },
4363
Alan Cox6919a0a2006-10-27 19:08:46 -07004364 /* Devices we expect to fail diagnostics */
4365
4366 /* Devices where NCQ should be avoided */
4367 /* NCQ is slow */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04004368 { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
Tejun Heo459ad682007-12-07 12:46:23 +09004369 { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, },
Tejun Heo09125ea2007-02-28 15:21:23 +09004370 /* http://thread.gmane.org/gmane.linux.ide/14907 */
4371 { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
Paul Rolland7acfaf32007-03-26 21:43:44 -08004372 /* NCQ is broken */
Jeff Garzik539cc7c2007-09-20 16:31:47 -04004373 { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ },
Alan Cox0e3dbc02007-09-20 15:22:47 +01004374 { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ },
Paolo Ornatida6f0ec2007-10-04 11:06:56 +09004375 { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ },
Tejun Heoe41bd3e2007-12-09 19:45:39 +09004376 { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ },
Lubomir Bulej5ccfca92008-12-22 11:35:22 +01004377 { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ },
Jeff Garzik539cc7c2007-09-20 16:31:47 -04004378
Tejun Heoac70a962008-11-27 13:36:48 +09004379 /* Seagate NCQ + FLUSH CACHE firmware bug */
Mark Lord4d1f9082010-07-05 18:53:37 -04004380 { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
Tejun Heoac70a962008-11-27 13:36:48 +09004381 ATA_HORKAGE_FIRMWARE_WARN },
Tejun Heod10d4912008-12-11 13:42:42 +09004382
Mark Lord4d1f9082010-07-05 18:53:37 -04004383 { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
Tejun Heod10d4912008-12-11 13:42:42 +09004384 ATA_HORKAGE_FIRMWARE_WARN },
4385
Mark Lord4d1f9082010-07-05 18:53:37 -04004386 { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
Tejun Heod10d4912008-12-11 13:42:42 +09004387 ATA_HORKAGE_FIRMWARE_WARN },
4388
Mark Lord4d1f9082010-07-05 18:53:37 -04004389 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
Tejun Heoac70a962008-11-27 13:36:48 +09004390 ATA_HORKAGE_FIRMWARE_WARN },
4391
Aleksei Mamlin08c85d22015-07-01 13:48:30 +03004392 /* drives which fail FPDMA_AA activation (some may freeze afterwards) */
Michele Baldessari87809942013-11-25 19:00:14 +00004393 { "ST1000LM024 HN-M101MBB", "2AR10001", ATA_HORKAGE_BROKEN_FPDMA_AA },
Michele Baldessarib28a6132014-03-07 16:34:29 +00004394 { "ST1000LM024 HN-M101MBB", "2BA30001", ATA_HORKAGE_BROKEN_FPDMA_AA },
Aleksei Mamlin08c85d22015-07-01 13:48:30 +03004395 { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
Michele Baldessari87809942013-11-25 19:00:14 +00004396
Robert Hancock36e337d2007-04-02 22:05:29 -06004397 /* Blacklist entries taken from Silicon Image 3124/3132
4398 Windows driver .inf file - also several Linux problem reports */
4399 { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, },
4400 { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, },
4401 { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, },
Alan Cox6919a0a2006-10-27 19:08:46 -07004402
Tejun Heo68b0ddb2010-04-05 10:51:26 +09004403 /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */
4404 { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ, },
4405
Tejun Heo16c55b02007-08-29 11:58:33 +09004406 /* devices which puke on READ_NATIVE_MAX */
4407 { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, },
4408 { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
4409 { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
4410 { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA },
Alan Cox6919a0a2006-10-27 19:08:46 -07004411
Tejun Heo78313872009-08-07 01:59:15 +09004412 /* this one allows HPA unlocking but fails IOs on the area */
4413 { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA },
4414
Alan Cox93328e12007-09-29 04:06:48 -04004415 /* Devices which report 1 sector over size HPA */
4416 { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, },
4417 { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, },
Mikko Rapelib152fcd2008-02-19 01:41:25 +01004418 { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE, },
Alan Cox93328e12007-09-29 04:06:48 -04004419
Alan Cox6bbfd532007-11-05 22:58:58 +00004420 /* Devices which get the IVB wrong */
4421 { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
Alan Coxa79067e2008-04-29 14:08:36 +01004422 /* Maybe we should just blacklist TSSTcorp... */
Mark Lord7da4c932010-07-01 18:18:12 -04004423 { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB, },
Alan Cox6bbfd532007-11-05 22:58:58 +00004424
Jens Axboe9ce8e302008-08-27 15:23:18 +02004425 /* Devices that do not need bridging limits applied */
4426 { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK, },
Jeff Garzik04d0f1b82012-08-17 13:36:59 -04004427 { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK, },
Jens Axboe9ce8e302008-08-27 15:23:18 +02004428
Tejun Heo90627122009-01-29 20:31:36 +09004429 /* Devices which aren't very happy with higher link speeds */
4430 { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS, },
Daniel J Bluemanc5310772012-07-23 12:22:37 +08004431 { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS, },
Tejun Heo90627122009-01-29 20:31:36 +09004432
Tejun Heod0cb43b2009-07-09 09:27:50 +09004433 /*
4434 * Devices which choke on SETXFER. Applies only if both the
4435 * device and controller are SATA.
4436 */
Tejun Heocd691872011-06-22 12:13:10 +02004437 { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER },
Vladimir LAVALLADE3a251792012-01-08 13:50:13 +01004438 { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER },
4439 { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER },
Tejun Heocd691872011-06-22 12:13:10 +02004440 { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
4441 { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
Tejun Heod0cb43b2009-07-09 09:27:50 +09004442
Marc Carinof78dea02013-12-16 18:15:53 -08004443 /* devices that don't properly handle queued TRIM commands */
Martin K. Petersen243918b2015-06-18 14:50:18 -04004444 { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
Martin K. Petersene61f7d12015-01-08 10:34:27 -05004445 ATA_HORKAGE_ZERO_AFTER_TRIM, },
Martin K. Petersenff7f53f2015-03-27 15:17:20 -04004446 { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4447 ATA_HORKAGE_ZERO_AFTER_TRIM, },
Martin K. Petersen9051bd32015-07-15 21:03:23 -04004448 { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
Martin K. Petersenff7f53f2015-03-27 15:17:20 -04004449 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4450 { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4451 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4452 { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4453 ATA_HORKAGE_ZERO_AFTER_TRIM, },
Martin K. Petersen9a9324d2015-05-04 12:20:29 -04004454 { "Samsung SSD 8*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
Martin K. Petersen6fc4d972015-03-27 15:17:21 -04004455 ATA_HORKAGE_ZERO_AFTER_TRIM, },
Guillermo A. Amaral7a7184b2015-08-25 23:29:13 -07004456 { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4457 ATA_HORKAGE_ZERO_AFTER_TRIM, },
Martin K. Petersene61f7d12015-01-08 10:34:27 -05004458
Arne Fitzenreitercda57b12015-07-15 13:54:37 +02004459 /* devices that don't properly handle TRIM commands */
4460 { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM, },
4461
Martin K. Petersene61f7d12015-01-08 10:34:27 -05004462 /*
4463 * As defined, the DRAT (Deterministic Read After Trim) and RZAT
4464 * (Return Zero After Trim) flags in the ATA Command Set are
4465 * unreliable in the sense that they only define what happens if
4466 * the device successfully executed the DSM TRIM command. TRIM
4467 * is only advisory, however, and the device is free to silently
4468 * ignore all or parts of the request.
4469 *
4470 * Whitelist drives that are known to reliably return zeroes
4471 * after TRIM.
4472 */
4473
4474 /*
4475 * The intel 510 drive has buggy DRAT/RZAT. Explicitly exclude
4476 * that model before whitelisting all other intel SSDs.
4477 */
4478 { "INTEL*SSDSC2MH*", NULL, 0, },
4479
Martin K. Petersenff7f53f2015-03-27 15:17:20 -04004480 { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4481 { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
Martin K. Petersene61f7d12015-01-08 10:34:27 -05004482 { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4483 { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4484 { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4485 { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4486 { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
Marc Carinof78dea02013-12-16 18:15:53 -08004487
Tejun Heoecd75ad2014-01-16 09:47:17 -05004488 /*
4489 * Some WD SATA-I drives spin up and down erratically when the link
4490 * is put into the slumber mode. We don't have full list of the
4491 * affected devices. Disable LPM if the device matches one of the
4492 * known prefixes and is SATA-1. As a side effect LPM partial is
4493 * lost too.
4494 *
4495 * https://bugzilla.kernel.org/show_bug.cgi?id=57211
4496 */
4497 { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4498 { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4499 { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4500 { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4501 { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4502 { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4503 { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4504
Alan Cox6919a0a2006-10-27 19:08:46 -07004505 /* End Marker */
4506 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004507};
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05004508
Tejun Heo75683fe2007-07-05 13:31:27 +09004509static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004510{
Tejun Heo8bfa79f2007-01-02 20:19:40 +09004511 unsigned char model_num[ATA_ID_PROD_LEN + 1];
4512 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
Alan Cox6919a0a2006-10-27 19:08:46 -07004513 const struct ata_blacklist_entry *ad = ata_device_blacklist;
Albert Lee3a778272006-06-22 13:00:25 +08004514
Tejun Heo8bfa79f2007-01-02 20:19:40 +09004515 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4516 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004517
Alan Cox6919a0a2006-10-27 19:08:46 -07004518 while (ad->model_num) {
George Spelvin1c402792014-10-07 07:26:38 -04004519 if (glob_match(ad->model_num, model_num)) {
Alan Cox6919a0a2006-10-27 19:08:46 -07004520 if (ad->model_rev == NULL)
4521 return ad->horkage;
George Spelvin1c402792014-10-07 07:26:38 -04004522 if (glob_match(ad->model_rev, model_rev))
Alan Cox6919a0a2006-10-27 19:08:46 -07004523 return ad->horkage;
Alan Coxf4b15fe2006-03-22 15:54:04 +00004524 }
Alan Cox6919a0a2006-10-27 19:08:46 -07004525 ad++;
Alan Coxf4b15fe2006-03-22 15:54:04 +00004526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527 return 0;
4528}
4529
Alan Cox6919a0a2006-10-27 19:08:46 -07004530static int ata_dma_blacklisted(const struct ata_device *dev)
4531{
4532 /* We don't support polling DMA.
4533 * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
4534 * if the LLDD handles only interrupts in the HSM_ST_LAST state.
4535 */
Tejun Heo9af5c9c2007-08-06 18:36:22 +09004536 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
Alan Cox6919a0a2006-10-27 19:08:46 -07004537 (dev->flags & ATA_DFLAG_CDB_INTR))
4538 return 1;
Tejun Heo75683fe2007-07-05 13:31:27 +09004539 return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
Alan Cox6919a0a2006-10-27 19:08:46 -07004540}
4541
Tejun Heoa6d5a512006-03-06 04:31:57 +09004542/**
Alan Cox6bbfd532007-11-05 22:58:58 +00004543 * ata_is_40wire - check drive side detection
4544 * @dev: device
4545 *
4546 * Perform drive side detection decoding, allowing for device vendors
4547 * who can't follow the documentation.
4548 */
4549
4550static int ata_is_40wire(struct ata_device *dev)
4551{
4552 if (dev->horkage & ATA_HORKAGE_IVB)
4553 return ata_drive_40wire_relaxed(dev->id);
4554 return ata_drive_40wire(dev->id);
4555}
4556
4557/**
Alan Cox15a55512008-03-28 14:33:46 -07004558 * cable_is_40wire - 40/80/SATA decider
4559 * @ap: port to consider
4560 *
4561 * This function encapsulates the policy for speed management
4562 * in one place. At the moment we don't cache the result but
4563 * there is a good case for setting ap->cbl to the result when
4564 * we are called with unknown cables (and figuring out if it
4565 * impacts hotplug at all).
4566 *
4567 * Return 1 if the cable appears to be 40 wire.
4568 */
4569
4570static int cable_is_40wire(struct ata_port *ap)
4571{
4572 struct ata_link *link;
4573 struct ata_device *dev;
4574
Tejun Heo4a9c7b32008-10-27 19:59:23 +09004575 /* If the controller thinks we are 40 wire, we are. */
Alan Cox15a55512008-03-28 14:33:46 -07004576 if (ap->cbl == ATA_CBL_PATA40)
4577 return 1;
Tejun Heo4a9c7b32008-10-27 19:59:23 +09004578
4579 /* If the controller thinks we are 80 wire, we are. */
Alan Cox15a55512008-03-28 14:33:46 -07004580 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4581 return 0;
Tejun Heo4a9c7b32008-10-27 19:59:23 +09004582
4583 /* If the system is known to be 40 wire short cable (eg
4584 * laptop), then we allow 80 wire modes even if the drive
4585 * isn't sure.
4586 */
Alan Coxf7920682008-04-08 16:37:50 +01004587 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4588 return 0;
Alan Cox15a55512008-03-28 14:33:46 -07004589
Tejun Heo4a9c7b32008-10-27 19:59:23 +09004590 /* If the controller doesn't know, we scan.
4591 *
4592 * Note: We look for all 40 wire detects at this point. Any
4593 * 80 wire detect is taken to be 80 wire cable because
4594 * - in many setups only the one drive (slave if present) will
4595 * give a valid detect
4596 * - if you have a non detect capable drive you don't want it
4597 * to colour the choice
4598 */
Tejun Heo1eca4362008-11-03 20:03:17 +09004599 ata_for_each_link(link, ap, EDGE) {
4600 ata_for_each_dev(dev, link, ENABLED) {
4601 if (!ata_is_40wire(dev))
Alan Cox15a55512008-03-28 14:33:46 -07004602 return 0;
4603 }
4604 }
4605 return 1;
4606}
4607
4608/**
Tejun Heoa6d5a512006-03-06 04:31:57 +09004609 * ata_dev_xfermask - Compute supported xfermask of the given device
Tejun Heoa6d5a512006-03-06 04:31:57 +09004610 * @dev: Device to compute xfermask for
4611 *
Tejun Heoacf356b2006-03-24 14:07:50 +09004612 * Compute supported xfermask of @dev and store it in
4613 * dev->*_mask. This function is responsible for applying all
4614 * known limits including host controller limits, device
4615 * blacklist, etc...
Tejun Heoa6d5a512006-03-06 04:31:57 +09004616 *
4617 * LOCKING:
4618 * None.
Tejun Heoa6d5a512006-03-06 04:31:57 +09004619 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004620static void ata_dev_xfermask(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004621{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09004622 struct ata_link *link = dev->link;
4623 struct ata_port *ap = link->ap;
Jeff Garzikcca39742006-08-24 03:19:22 -04004624 struct ata_host *host = ap->host;
Tejun Heoa6d5a512006-03-06 04:31:57 +09004625 unsigned long xfer_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004626
Tejun Heo37deecb2006-08-10 16:59:07 +09004627 /* controller modes available */
Tejun Heo565083e2006-04-02 17:54:47 +09004628 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4629 ap->mwdma_mask, ap->udma_mask);
4630
Robert Hancock8343f882007-03-06 02:37:51 -08004631 /* drive modes available */
Tejun Heo37deecb2006-08-10 16:59:07 +09004632 xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4633 dev->mwdma_mask, dev->udma_mask);
4634 xfer_mask &= ata_id_xfermask(dev->id);
Tejun Heo565083e2006-04-02 17:54:47 +09004635
Alan Coxb352e572006-08-10 18:52:12 +01004636 /*
4637 * CFA Advanced TrueIDE timings are not allowed on a shared
4638 * cable
4639 */
4640 if (ata_dev_pair(dev)) {
4641 /* No PIO5 or PIO6 */
4642 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4643 /* No MWDMA3 or MWDMA 4 */
4644 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4645 }
4646
Tejun Heo37deecb2006-08-10 16:59:07 +09004647 if (ata_dma_blacklisted(dev)) {
4648 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Joe Perchesa9a79df2011-04-15 15:51:59 -07004649 ata_dev_warn(dev,
4650 "device is on DMA blacklist, disabling DMA\n");
Tejun Heo37deecb2006-08-10 16:59:07 +09004651 }
Tejun Heoa6d5a512006-03-06 04:31:57 +09004652
Petr Vandrovec14d66ab2007-03-08 10:12:12 +01004653 if ((host->flags & ATA_HOST_SIMPLEX) &&
Jeff Garzik2dcb4072007-10-19 06:42:56 -04004654 host->simplex_claimed && host->simplex_claimed != ap) {
Tejun Heo37deecb2006-08-10 16:59:07 +09004655 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Joe Perchesa9a79df2011-04-15 15:51:59 -07004656 ata_dev_warn(dev,
4657 "simplex DMA is claimed by other device, disabling DMA\n");
Alan Cox5444a6f2006-03-27 18:58:20 +01004658 }
Tejun Heo565083e2006-04-02 17:54:47 +09004659
Jeff Garzike4246752007-03-09 09:56:46 -05004660 if (ap->flags & ATA_FLAG_NO_IORDY)
4661 xfer_mask &= ata_pio_mask_no_iordy(dev);
4662
Alan Cox5444a6f2006-03-27 18:58:20 +01004663 if (ap->ops->mode_filter)
Alan Coxa76b62c2007-03-09 09:34:07 -05004664 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
Alan Cox5444a6f2006-03-27 18:58:20 +01004665
Robert Hancock8343f882007-03-06 02:37:51 -08004666 /* Apply cable rule here. Don't apply it early because when
4667 * we handle hot plug the cable type can itself change.
4668 * Check this last so that we know if the transfer rate was
4669 * solely limited by the cable.
4670 * Unknown or 80 wire cables reported host side are checked
4671 * drive side as well. Cases where we know a 40wire cable
4672 * is used safely for 80 are not checked here.
4673 */
4674 if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4675 /* UDMA/44 or higher would be available */
Alan Cox15a55512008-03-28 14:33:46 -07004676 if (cable_is_40wire(ap)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07004677 ata_dev_warn(dev,
4678 "limited to UDMA/33 due to 40-wire cable\n");
Robert Hancock8343f882007-03-06 02:37:51 -08004679 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4680 }
4681
Tejun Heo565083e2006-04-02 17:54:47 +09004682 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4683 &dev->mwdma_mask, &dev->udma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004684}
4685
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004687 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
Linus Torvalds1da177e2005-04-16 15:20:36 -07004688 * @dev: Device to which command will be sent
4689 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04004690 * Issue SET FEATURES - XFER MODE command to device @dev
4691 * on port @ap.
4692 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004693 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004694 * PCI/etc. bus probe sem.
Tejun Heo83206a22006-03-24 15:25:31 +09004695 *
4696 * RETURNS:
4697 * 0 on success, AC_ERR_* mask otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004698 */
4699
Tejun Heo3373efd2006-05-15 20:57:53 +09004700static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004701{
Tejun Heoa0123702005-12-13 14:49:31 +09004702 struct ata_taskfile tf;
Tejun Heo83206a22006-03-24 15:25:31 +09004703 unsigned int err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704
4705 /* set up set-features taskfile */
4706 DPRINTK("set features - xfer mode\n");
4707
Tejun Heo464cf172007-05-27 15:10:40 +02004708 /* Some controllers and ATAPI devices show flaky interrupt
4709 * behavior after setting xfer mode. Use polling instead.
4710 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004711 ata_tf_init(dev, &tf);
Tejun Heoa0123702005-12-13 14:49:31 +09004712 tf.command = ATA_CMD_SET_FEATURES;
4713 tf.feature = SETFEATURES_XFER;
Tejun Heo464cf172007-05-27 15:10:40 +02004714 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
Tejun Heoa0123702005-12-13 14:49:31 +09004715 tf.protocol = ATA_PROT_NODATA;
Alan Coxb9f8ab22007-11-19 14:33:11 +00004716 /* If we are using IORDY we must send the mode setting command */
Jeff Garzik11b7bec2007-11-23 21:12:14 -05004717 if (ata_pio_need_iordy(dev))
4718 tf.nsect = dev->xfer_mode;
Alan Coxb9f8ab22007-11-19 14:33:11 +00004719 /* If the device has IORDY and the controller does not - turn it off */
4720 else if (ata_id_has_iordy(dev->id))
Jeff Garzik11b7bec2007-11-23 21:12:14 -05004721 tf.nsect = 0x01;
Alan Coxb9f8ab22007-11-19 14:33:11 +00004722 else /* In the ancient relic department - skip all of this */
4723 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724
Mikulas Patockad531be22015-07-08 13:06:12 -04004725 /* On some disks, this command causes spin-up, so we need longer timeout */
4726 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004727
Tejun Heo83206a22006-03-24 15:25:31 +09004728 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4729 return err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004730}
Tejun Heo1152b262010-09-01 17:50:05 +02004731
Linus Torvalds1da177e2005-04-16 15:20:36 -07004732/**
Jeff Garzik218f3d32007-10-25 00:33:27 -04004733 * ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004734 * @dev: Device to which command will be sent
4735 * @enable: Whether to enable or disable the feature
Jeff Garzik218f3d32007-10-25 00:33:27 -04004736 * @feature: The sector count represents the feature to set
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004737 *
4738 * Issue SET FEATURES - SATA FEATURES command to device @dev
Jeff Garzik218f3d32007-10-25 00:33:27 -04004739 * on port @ap with sector count
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004740 *
4741 * LOCKING:
4742 * PCI/etc. bus probe sem.
4743 *
4744 * RETURNS:
4745 * 0 on success, AC_ERR_* mask otherwise.
4746 */
Tejun Heo1152b262010-09-01 17:50:05 +02004747unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004748{
4749 struct ata_taskfile tf;
4750 unsigned int err_mask;
Damien Le Moal974e0a42016-04-04 12:17:09 -04004751 unsigned long timeout = 0;
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004752
4753 /* set up set-features taskfile */
4754 DPRINTK("set features - SATA features\n");
4755
4756 ata_tf_init(dev, &tf);
4757 tf.command = ATA_CMD_SET_FEATURES;
4758 tf.feature = enable;
4759 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4760 tf.protocol = ATA_PROT_NODATA;
Jeff Garzik218f3d32007-10-25 00:33:27 -04004761 tf.nsect = feature;
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004762
Damien Le Moal974e0a42016-04-04 12:17:09 -04004763 if (enable == SETFEATURES_SPINUP)
4764 timeout = ata_probe_timeout ?
4765 ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
4766 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004767
4768 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4769 return err_mask;
4770}
Jeff Garzik633de4c2012-09-13 01:12:29 -04004771EXPORT_SYMBOL_GPL(ata_dev_set_feature);
Kristen Carlson Accardi9f45cbd2007-08-15 03:57:11 -04004772
4773/**
Albert Lee8bf62ece2005-05-12 15:29:42 -04004774 * ata_dev_init_params - Issue INIT DEV PARAMS command
Albert Lee8bf62ece2005-05-12 15:29:42 -04004775 * @dev: Device to which command will be sent
Randy Dunlape2a7f772006-05-18 10:50:18 -07004776 * @heads: Number of heads (taskfile parameter)
4777 * @sectors: Number of sectors (taskfile parameter)
Albert Lee8bf62ece2005-05-12 15:29:42 -04004778 *
4779 * LOCKING:
Tejun Heo6aff8f12006-02-15 18:24:09 +09004780 * Kernel thread context (may sleep)
4781 *
4782 * RETURNS:
4783 * 0 on success, AC_ERR_* mask otherwise.
Albert Lee8bf62ece2005-05-12 15:29:42 -04004784 */
Tejun Heo3373efd2006-05-15 20:57:53 +09004785static unsigned int ata_dev_init_params(struct ata_device *dev,
4786 u16 heads, u16 sectors)
Albert Lee8bf62ece2005-05-12 15:29:42 -04004787{
Tejun Heoa0123702005-12-13 14:49:31 +09004788 struct ata_taskfile tf;
Tejun Heo6aff8f12006-02-15 18:24:09 +09004789 unsigned int err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04004790
4791 /* Number of sectors per track 1-255. Number of heads 1-16 */
4792 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
Albert Lee00b6f5e2006-03-27 16:39:18 +08004793 return AC_ERR_INVALID;
Albert Lee8bf62ece2005-05-12 15:29:42 -04004794
4795 /* set up init dev params taskfile */
4796 DPRINTK("init dev params \n");
4797
Tejun Heo3373efd2006-05-15 20:57:53 +09004798 ata_tf_init(dev, &tf);
Tejun Heoa0123702005-12-13 14:49:31 +09004799 tf.command = ATA_CMD_INIT_DEV_PARAMS;
4800 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4801 tf.protocol = ATA_PROT_NODATA;
4802 tf.nsect = sectors;
4803 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
Albert Lee8bf62ece2005-05-12 15:29:42 -04004804
Tejun Heo2b789102007-10-09 15:05:44 +09004805 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
Alan Cox18b24662007-08-08 14:28:49 +01004806 /* A clean abort indicates an original or just out of spec drive
4807 and we should continue as we issue the setup based on the
4808 drive reported working geometry */
4809 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
4810 err_mask = 0;
Albert Lee8bf62ece2005-05-12 15:29:42 -04004811
Tejun Heo6aff8f12006-02-15 18:24:09 +09004812 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4813 return err_mask;
Albert Lee8bf62ece2005-05-12 15:29:42 -04004814}
4815
4816/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004817 * ata_sg_clean - Unmap DMA memory associated with command
4818 * @qc: Command containing DMA memory to be released
4819 *
4820 * Unmap all mapped DMA memory associated with this command.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004821 *
4822 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04004823 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004824 */
Tejun Heo70e6ad02006-11-14 22:47:10 +09004825void ata_sg_clean(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004826{
4827 struct ata_port *ap = qc->ap;
Tejun Heoff2aeb12007-12-05 16:43:11 +09004828 struct scatterlist *sg = qc->sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004829 int dir = qc->dma_dir;
4830
Tejun Heoefcb3cf2009-01-09 19:19:14 +09004831 WARN_ON_ONCE(sg == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004832
James Bottomleydde20202008-02-19 11:36:56 +01004833 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004834
James Bottomleydde20202008-02-19 11:36:56 +01004835 if (qc->n_elem)
FUJITA Tomonori58256272009-02-27 17:35:43 +09004836 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004837
4838 qc->flags &= ~ATA_QCFLAG_DMAMAP;
Tejun Heoff2aeb12007-12-05 16:43:11 +09004839 qc->sg = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004840}
4841
4842/**
Tejun Heo5895ef92008-06-17 12:36:26 +09004843 * atapi_check_dma - Check whether ATAPI DMA can be supported
Linus Torvalds1da177e2005-04-16 15:20:36 -07004844 * @qc: Metadata associated with taskfile to check
4845 *
Jeff Garzik780a87f2005-05-30 15:41:05 -04004846 * Allow low-level driver to filter ATA PACKET commands, returning
4847 * a status indicating whether or not it is OK to use DMA for the
4848 * supplied PACKET command.
4849 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004850 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04004851 * spin_lock_irqsave(host lock)
Jeff Garzik0cba6322005-05-30 19:49:12 -04004852 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004853 * RETURNS: 0 when ATAPI DMA can be used
4854 * nonzero otherwise
4855 */
Tejun Heo5895ef92008-06-17 12:36:26 +09004856int atapi_check_dma(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004857{
4858 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004859
Tejun Heob9a41972007-06-27 02:48:43 +09004860 /* Don't allow DMA if it isn't multiple of 16 bytes. Quite a
4861 * few ATAPI devices choke on such DMA requests.
4862 */
Tejun Heo6a87e422008-11-03 19:01:09 +09004863 if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4864 unlikely(qc->nbytes & 15))
Tejun Heob9a41972007-06-27 02:48:43 +09004865 return 1;
Albert Lee6f23a312007-04-02 11:39:25 +08004866
Linus Torvalds1da177e2005-04-16 15:20:36 -07004867 if (ap->ops->check_atapi_dma)
Tejun Heob9a41972007-06-27 02:48:43 +09004868 return ap->ops->check_atapi_dma(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004869
Tejun Heob9a41972007-06-27 02:48:43 +09004870 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004871}
Tejun Heob9a41972007-06-27 02:48:43 +09004872
Linus Torvalds1da177e2005-04-16 15:20:36 -07004873/**
Tejun Heo31cc23b2007-09-23 13:14:12 +09004874 * ata_std_qc_defer - Check whether a qc needs to be deferred
4875 * @qc: ATA command in question
4876 *
4877 * Non-NCQ commands cannot run with any other command, NCQ or
4878 * not. As upper layer only knows the queue depth, we are
4879 * responsible for maintaining exclusion. This function checks
4880 * whether a new command @qc can be issued.
4881 *
4882 * LOCKING:
4883 * spin_lock_irqsave(host lock)
4884 *
4885 * RETURNS:
4886 * ATA_DEFER_* if deferring is needed, 0 otherwise.
4887 */
4888int ata_std_qc_defer(struct ata_queued_cmd *qc)
4889{
4890 struct ata_link *link = qc->dev->link;
4891
Hannes Reinecke179b3102016-07-14 09:05:43 +09004892 if (ata_is_ncq(qc->tf.protocol)) {
Tejun Heo31cc23b2007-09-23 13:14:12 +09004893 if (!ata_tag_valid(link->active_tag))
4894 return 0;
4895 } else {
4896 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4897 return 0;
4898 }
4899
4900 return ATA_DEFER_LINK;
4901}
4902
Brian Kinge46834c2006-03-17 17:04:03 -06004903void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
4904
Jeff Garzik0cba6322005-05-30 19:49:12 -04004905/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004906 * ata_sg_init - Associate command with scatter-gather table.
4907 * @qc: Command to be associated
4908 * @sg: Scatter-gather table.
4909 * @n_elem: Number of elements in s/g table.
4910 *
4911 * Initialize the data-related elements of queued_cmd @qc
4912 * to point to a scatter-gather table @sg, containing @n_elem
4913 * elements.
4914 *
4915 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04004916 * spin_lock_irqsave(host lock)
Jeff Garzik0cba6322005-05-30 19:49:12 -04004917 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004918void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4919 unsigned int n_elem)
4920{
Tejun Heoff2aeb12007-12-05 16:43:11 +09004921 qc->sg = sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004922 qc->n_elem = n_elem;
Tejun Heoff2aeb12007-12-05 16:43:11 +09004923 qc->cursg = qc->sg;
4924}
4925
Linus Torvalds1da177e2005-04-16 15:20:36 -07004926/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04004927 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
4928 * @qc: Command with scatter-gather table to be mapped.
4929 *
4930 * DMA-map the scatter-gather table associated with queued_cmd @qc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004931 *
4932 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04004933 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004934 *
4935 * RETURNS:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004936 * Zero on success, negative on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004937 *
4938 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004939static int ata_sg_setup(struct ata_queued_cmd *qc)
4940{
4941 struct ata_port *ap = qc->ap;
James Bottomleydde20202008-02-19 11:36:56 +01004942 unsigned int n_elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004943
Tejun Heo44877b42007-02-21 01:06:51 +09004944 VPRINTK("ENTER, ata%u\n", ap->print_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004945
James Bottomleydde20202008-02-19 11:36:56 +01004946 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4947 if (n_elem < 1)
4948 return -1;
Jeff Garzikcedc9a42005-10-05 07:13:30 -04004949
James Bottomleydde20202008-02-19 11:36:56 +01004950 DPRINTK("%d sg elements mapped\n", n_elem);
FUJITA Tomonori58256272009-02-27 17:35:43 +09004951 qc->orig_n_elem = qc->n_elem;
James Bottomleydde20202008-02-19 11:36:56 +01004952 qc->n_elem = n_elem;
Tejun Heof92a2632007-12-05 16:43:10 +09004953 qc->flags |= ATA_QCFLAG_DMAMAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004954
4955 return 0;
4956}
4957
4958/**
Randy Dunlapc893a3a2006-01-28 13:15:32 -05004959 * swap_buf_le16 - swap halves of 16-bit words in place
Edward Falk0baab862005-06-02 18:17:13 -04004960 * @buf: Buffer to swap
4961 * @buf_words: Number of 16-bit words in buffer.
4962 *
4963 * Swap halves of 16-bit words if needed to convert from
4964 * little-endian byte order to native cpu byte order, or
4965 * vice-versa.
4966 *
4967 * LOCKING:
Randy Dunlap6f0ef4f2005-10-25 01:44:30 -04004968 * Inherited from caller.
Edward Falk0baab862005-06-02 18:17:13 -04004969 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004970void swap_buf_le16(u16 *buf, unsigned int buf_words)
4971{
4972#ifdef __BIG_ENDIAN
4973 unsigned int i;
4974
4975 for (i = 0; i < buf_words; i++)
4976 buf[i] = le16_to_cpu(buf[i]);
4977#endif /* __BIG_ENDIAN */
4978}
4979
Albert Lee6ae4cfb2005-08-12 14:15:34 +08004980/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004981 * ata_qc_new_init - Request an available ATA command, and initialize it
Linus Torvalds1da177e2005-04-16 15:20:36 -07004982 * @dev: Device from whom we request an available command structure
Randy Dunlap38755e82015-08-09 18:37:36 -07004983 * @tag: tag
Linus Torvalds1da177e2005-04-16 15:20:36 -07004984 *
4985 * LOCKING:
Jeff Garzik0cba6322005-05-30 19:49:12 -04004986 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004987 */
4988
Shaohua Li98bd4be2015-01-23 19:52:07 -08004989struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev, int tag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004990{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09004991 struct ata_port *ap = dev->link->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004992 struct ata_queued_cmd *qc;
4993
Shaohua Li98bd4be2015-01-23 19:52:07 -08004994 /* no command while frozen */
4995 if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
4996 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004997
Shaohua Li98bd4be2015-01-23 19:52:07 -08004998 /* libsas case */
Shaohua Li5067c042015-03-12 10:32:18 -07004999 if (ap->flags & ATA_FLAG_SAS_HOST) {
Shaohua Li98bd4be2015-01-23 19:52:07 -08005000 tag = ata_sas_allocate_tag(ap);
5001 if (tag < 0)
5002 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005003 }
5004
Shaohua Li98bd4be2015-01-23 19:52:07 -08005005 qc = __ata_qc_from_tag(ap, tag);
5006 qc->tag = tag;
5007 qc->scsicmd = NULL;
5008 qc->ap = ap;
5009 qc->dev = dev;
5010
5011 ata_qc_reinit(qc);
5012
Linus Torvalds1da177e2005-04-16 15:20:36 -07005013 return qc;
5014}
5015
Tejun Heo8a8bc222008-11-10 14:48:21 +09005016/**
5017 * ata_qc_free - free unused ata_queued_cmd
5018 * @qc: Command to complete
5019 *
5020 * Designed to free unused ata_queued_cmd object
5021 * in case something prevents using it.
5022 *
5023 * LOCKING:
5024 * spin_lock_irqsave(host lock)
5025 */
5026void ata_qc_free(struct ata_queued_cmd *qc)
5027{
Julia Lawalla1104012009-10-17 08:41:47 +02005028 struct ata_port *ap;
Tejun Heo8a8bc222008-11-10 14:48:21 +09005029 unsigned int tag;
5030
Tejun Heoefcb3cf2009-01-09 19:19:14 +09005031 WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
Julia Lawalla1104012009-10-17 08:41:47 +02005032 ap = qc->ap;
Tejun Heo8a8bc222008-11-10 14:48:21 +09005033
5034 qc->flags = 0;
5035 tag = qc->tag;
5036 if (likely(ata_tag_valid(tag))) {
5037 qc->tag = ATA_TAG_POISON;
Shaohua Li5067c042015-03-12 10:32:18 -07005038 if (ap->flags & ATA_FLAG_SAS_HOST)
Shaohua Li98bd4be2015-01-23 19:52:07 -08005039 ata_sas_free_tag(tag, ap);
Tejun Heo8a8bc222008-11-10 14:48:21 +09005040 }
5041}
5042
Tejun Heo76014422006-02-11 15:13:49 +09005043void __ata_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005044{
Julia Lawalla1104012009-10-17 08:41:47 +02005045 struct ata_port *ap;
5046 struct ata_link *link;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005047
Tejun Heoefcb3cf2009-01-09 19:19:14 +09005048 WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
5049 WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
Julia Lawalla1104012009-10-17 08:41:47 +02005050 ap = qc->ap;
5051 link = qc->dev->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005052
5053 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
5054 ata_sg_clean(qc);
5055
Tejun Heo7401abf2006-05-15 20:57:32 +09005056 /* command should be marked inactive atomically with qc completion */
Hannes Reinecke179b3102016-07-14 09:05:43 +09005057 if (ata_is_ncq(qc->tf.protocol)) {
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005058 link->sactive &= ~(1 << qc->tag);
Tejun Heoda917d62007-09-23 13:14:12 +09005059 if (!link->sactive)
5060 ap->nr_active_links--;
5061 } else {
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005062 link->active_tag = ATA_TAG_POISON;
Tejun Heoda917d62007-09-23 13:14:12 +09005063 ap->nr_active_links--;
5064 }
5065
5066 /* clear exclusive status */
5067 if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
5068 ap->excl_link == link))
5069 ap->excl_link = NULL;
Tejun Heo7401abf2006-05-15 20:57:32 +09005070
Albert Lee3f3791d2005-08-16 14:25:38 +08005071 /* atapi: mark qc as inactive to prevent the interrupt handler
5072 * from completing the command twice later, before the error handler
5073 * is called. (when rc != 0 and atapi request sense is needed)
5074 */
5075 qc->flags &= ~ATA_QCFLAG_ACTIVE;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005076 ap->qc_active &= ~(1 << qc->tag);
Albert Lee3f3791d2005-08-16 14:25:38 +08005077
Linus Torvalds1da177e2005-04-16 15:20:36 -07005078 /* call completion callback */
Tejun Heo77853bf2006-01-23 13:09:36 +09005079 qc->complete_fn(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005080}
5081
Tejun Heo39599a52006-11-14 22:37:35 +09005082static void fill_result_tf(struct ata_queued_cmd *qc)
5083{
5084 struct ata_port *ap = qc->ap;
5085
Tejun Heo39599a52006-11-14 22:37:35 +09005086 qc->result_tf.flags = qc->tf.flags;
Tejun Heo22183bf2008-04-07 22:47:20 +09005087 ap->ops->qc_fill_rtf(qc);
Tejun Heo39599a52006-11-14 22:37:35 +09005088}
5089
Tejun Heo00115e02007-11-27 19:28:58 +09005090static void ata_verify_xfer(struct ata_queued_cmd *qc)
5091{
5092 struct ata_device *dev = qc->dev;
5093
Christoph Hellwigeb0effd2016-07-16 22:16:41 +09005094 if (!ata_is_data(qc->tf.protocol))
Tejun Heo00115e02007-11-27 19:28:58 +09005095 return;
5096
5097 if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
5098 return;
5099
5100 dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
5101}
5102
Tejun Heof686bcb2006-05-15 20:58:05 +09005103/**
5104 * ata_qc_complete - Complete an active ATA command
5105 * @qc: Command to complete
Tejun Heof686bcb2006-05-15 20:58:05 +09005106 *
Tejun Heo1aadf5c2010-06-25 15:03:34 +02005107 * Indicate to the mid and upper layers that an ATA command has
5108 * completed, with either an ok or not-ok status.
5109 *
5110 * Refrain from calling this function multiple times when
5111 * successfully completing multiple NCQ commands.
5112 * ata_qc_complete_multiple() should be used instead, which will
5113 * properly update IRQ expect state.
Tejun Heof686bcb2006-05-15 20:58:05 +09005114 *
5115 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04005116 * spin_lock_irqsave(host lock)
Tejun Heof686bcb2006-05-15 20:58:05 +09005117 */
5118void ata_qc_complete(struct ata_queued_cmd *qc)
5119{
5120 struct ata_port *ap = qc->ap;
5121
Stephan Linzeb25cb92016-06-10 07:59:56 +02005122 /* Trigger the LED (if available) */
5123 ledtrig_disk_activity();
5124
Tejun Heof686bcb2006-05-15 20:58:05 +09005125 /* XXX: New EH and old EH use different mechanisms to
5126 * synchronize EH with regular execution path.
5127 *
5128 * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
5129 * Normal execution path is responsible for not accessing a
5130 * failed qc. libata core enforces the rule by returning NULL
5131 * from ata_qc_from_tag() for failed qcs.
5132 *
5133 * Old EH depends on ata_qc_complete() nullifying completion
5134 * requests if ATA_QCFLAG_EH_SCHEDULED is set. Old EH does
5135 * not synchronize with interrupt handler. Only PIO task is
5136 * taken care of.
5137 */
5138 if (ap->ops->error_handler) {
Tejun Heo4dbfa392007-10-25 18:22:44 +09005139 struct ata_device *dev = qc->dev;
5140 struct ata_eh_info *ehi = &dev->link->eh_info;
5141
Tejun Heof686bcb2006-05-15 20:58:05 +09005142 if (unlikely(qc->err_mask))
5143 qc->flags |= ATA_QCFLAG_FAILED;
5144
Tejun Heof08dc1a2010-12-09 15:59:32 +01005145 /*
5146 * Finish internal commands without any further processing
5147 * and always with the result TF filled.
5148 */
5149 if (unlikely(ata_tag_internal(qc->tag))) {
Tejun Heof4b31db92009-10-16 13:00:51 +09005150 fill_result_tf(qc);
Hannes Reinecke255c03d2015-03-27 16:46:38 +01005151 trace_ata_qc_complete_internal(qc);
Tejun Heof08dc1a2010-12-09 15:59:32 +01005152 __ata_qc_complete(qc);
5153 return;
5154 }
Tejun Heof4b31db92009-10-16 13:00:51 +09005155
Tejun Heof08dc1a2010-12-09 15:59:32 +01005156 /*
5157 * Non-internal qc has failed. Fill the result TF and
5158 * summon EH.
5159 */
5160 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
5161 fill_result_tf(qc);
Hannes Reinecke255c03d2015-03-27 16:46:38 +01005162 trace_ata_qc_complete_failed(qc);
Tejun Heof08dc1a2010-12-09 15:59:32 +01005163 ata_qc_schedule_eh(qc);
Tejun Heof4b31db92009-10-16 13:00:51 +09005164 return;
Tejun Heof686bcb2006-05-15 20:58:05 +09005165 }
5166
Tejun Heo4dc738e2009-09-17 18:45:27 +09005167 WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN);
5168
Tejun Heof686bcb2006-05-15 20:58:05 +09005169 /* read result TF if requested */
5170 if (qc->flags & ATA_QCFLAG_RESULT_TF)
Tejun Heo39599a52006-11-14 22:37:35 +09005171 fill_result_tf(qc);
Tejun Heof686bcb2006-05-15 20:58:05 +09005172
Hannes Reinecke255c03d2015-03-27 16:46:38 +01005173 trace_ata_qc_complete_done(qc);
Tejun Heo4dbfa392007-10-25 18:22:44 +09005174 /* Some commands need post-processing after successful
5175 * completion.
5176 */
5177 switch (qc->tf.command) {
5178 case ATA_CMD_SET_FEATURES:
5179 if (qc->tf.feature != SETFEATURES_WC_ON &&
Tom Yan0c127352016-07-12 21:37:02 +08005180 qc->tf.feature != SETFEATURES_WC_OFF &&
5181 qc->tf.feature != SETFEATURES_RA_ON &&
5182 qc->tf.feature != SETFEATURES_RA_OFF)
Tejun Heo4dbfa392007-10-25 18:22:44 +09005183 break;
5184 /* fall through */
5185 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
5186 case ATA_CMD_SET_MULTI: /* multi_count changed */
5187 /* revalidate device */
5188 ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
5189 ata_port_schedule_eh(ap);
5190 break;
Tejun Heo054a5fb2007-10-25 18:30:36 +09005191
5192 case ATA_CMD_SLEEP:
5193 dev->flags |= ATA_DFLAG_SLEEPING;
5194 break;
Tejun Heo4dbfa392007-10-25 18:22:44 +09005195 }
5196
Tejun Heo00115e02007-11-27 19:28:58 +09005197 if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER))
5198 ata_verify_xfer(qc);
5199
Tejun Heof686bcb2006-05-15 20:58:05 +09005200 __ata_qc_complete(qc);
5201 } else {
5202 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
5203 return;
5204
5205 /* read result TF if failed or requested */
5206 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
Tejun Heo39599a52006-11-14 22:37:35 +09005207 fill_result_tf(qc);
Tejun Heof686bcb2006-05-15 20:58:05 +09005208
5209 __ata_qc_complete(qc);
5210 }
5211}
5212
Tejun Heodedaf2b2006-05-15 21:03:43 +09005213/**
5214 * ata_qc_complete_multiple - Complete multiple qcs successfully
5215 * @ap: port in question
5216 * @qc_active: new qc_active mask
Tejun Heodedaf2b2006-05-15 21:03:43 +09005217 *
5218 * Complete in-flight commands. This functions is meant to be
5219 * called from low-level driver's interrupt routine to complete
5220 * requests normally. ap->qc_active and @qc_active is compared
5221 * and commands are completed accordingly.
5222 *
Tejun Heo1aadf5c2010-06-25 15:03:34 +02005223 * Always use this function when completing multiple NCQ commands
5224 * from IRQ handlers instead of calling ata_qc_complete()
5225 * multiple times to keep IRQ expect status properly in sync.
5226 *
Tejun Heodedaf2b2006-05-15 21:03:43 +09005227 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04005228 * spin_lock_irqsave(host lock)
Tejun Heodedaf2b2006-05-15 21:03:43 +09005229 *
5230 * RETURNS:
5231 * Number of completed commands on success, -errno otherwise.
5232 */
Tejun Heo79f97da2008-04-07 22:47:20 +09005233int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active)
Tejun Heodedaf2b2006-05-15 21:03:43 +09005234{
5235 int nr_done = 0;
5236 u32 done_mask;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005237
5238 done_mask = ap->qc_active ^ qc_active;
5239
5240 if (unlikely(done_mask & qc_active)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07005241 ata_port_err(ap, "illegal qc_active transition (%08x->%08x)\n",
5242 ap->qc_active, qc_active);
Tejun Heodedaf2b2006-05-15 21:03:43 +09005243 return -EINVAL;
5244 }
5245
Jens Axboe43768182009-05-20 09:44:39 +02005246 while (done_mask) {
Tejun Heodedaf2b2006-05-15 21:03:43 +09005247 struct ata_queued_cmd *qc;
Jens Axboe43768182009-05-20 09:44:39 +02005248 unsigned int tag = __ffs(done_mask);
Tejun Heodedaf2b2006-05-15 21:03:43 +09005249
Jens Axboe43768182009-05-20 09:44:39 +02005250 qc = ata_qc_from_tag(ap, tag);
5251 if (qc) {
Tejun Heodedaf2b2006-05-15 21:03:43 +09005252 ata_qc_complete(qc);
5253 nr_done++;
5254 }
Jens Axboe43768182009-05-20 09:44:39 +02005255 done_mask &= ~(1 << tag);
Tejun Heodedaf2b2006-05-15 21:03:43 +09005256 }
5257
5258 return nr_done;
5259}
5260
Linus Torvalds1da177e2005-04-16 15:20:36 -07005261/**
5262 * ata_qc_issue - issue taskfile to device
5263 * @qc: command to issue to device
5264 *
5265 * Prepare an ATA command to submission to device.
5266 * This includes mapping the data into a DMA-able
5267 * area, filling in the S/G table, and finally
5268 * writing the taskfile to hardware, starting the command.
5269 *
5270 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04005271 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005272 */
Tejun Heo8e0e6942006-03-31 20:41:11 +09005273void ata_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005274{
5275 struct ata_port *ap = qc->ap;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005276 struct ata_link *link = qc->dev->link;
Tejun Heo405e66b2007-11-27 19:28:53 +09005277 u8 prot = qc->tf.protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005278
Tejun Heodedaf2b2006-05-15 21:03:43 +09005279 /* Make sure only one non-NCQ command is outstanding. The
5280 * check is skipped for old EH because it reuses active qc to
5281 * request ATAPI sense.
5282 */
Tejun Heoefcb3cf2009-01-09 19:19:14 +09005283 WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag));
Tejun Heodedaf2b2006-05-15 21:03:43 +09005284
Tejun Heo1973a022007-12-05 10:36:13 +09005285 if (ata_is_ncq(prot)) {
Tejun Heoefcb3cf2009-01-09 19:19:14 +09005286 WARN_ON_ONCE(link->sactive & (1 << qc->tag));
Tejun Heoda917d62007-09-23 13:14:12 +09005287
5288 if (!link->sactive)
5289 ap->nr_active_links++;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005290 link->sactive |= 1 << qc->tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005291 } else {
Tejun Heoefcb3cf2009-01-09 19:19:14 +09005292 WARN_ON_ONCE(link->sactive);
Tejun Heoda917d62007-09-23 13:14:12 +09005293
5294 ap->nr_active_links++;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005295 link->active_tag = qc->tag;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005296 }
5297
Tejun Heoe4a70e72006-03-31 20:36:47 +09005298 qc->flags |= ATA_QCFLAG_ACTIVE;
Tejun Heodedaf2b2006-05-15 21:03:43 +09005299 ap->qc_active |= 1 << qc->tag;
Tejun Heoe4a70e72006-03-31 20:36:47 +09005300
Tejun Heo60f5d6e2010-08-23 11:27:27 +02005301 /*
5302 * We guarantee to LLDs that they will have at least one
Tejun Heof92a2632007-12-05 16:43:10 +09005303 * non-zero sg if the command is a data command.
5304 */
Tejun Heo60f5d6e2010-08-23 11:27:27 +02005305 if (WARN_ON_ONCE(ata_is_data(prot) &&
5306 (!qc->sg || !qc->n_elem || !qc->nbytes)))
5307 goto sys_err;
Tejun Heof92a2632007-12-05 16:43:10 +09005308
Tejun Heo405e66b2007-11-27 19:28:53 +09005309 if (ata_is_dma(prot) || (ata_is_pio(prot) &&
Tejun Heof92a2632007-12-05 16:43:10 +09005310 (ap->flags & ATA_FLAG_PIO_DMA)))
Tejun Heo001102d2007-12-05 16:43:09 +09005311 if (ata_sg_setup(qc))
Tejun Heo60f5d6e2010-08-23 11:27:27 +02005312 goto sys_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005313
Tejun Heocf480622008-01-24 00:05:14 +09005314 /* if device is sleeping, schedule reset and abort the link */
Tejun Heo054a5fb2007-10-25 18:30:36 +09005315 if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
Tejun Heocf480622008-01-24 00:05:14 +09005316 link->eh_info.action |= ATA_EH_RESET;
Tejun Heo054a5fb2007-10-25 18:30:36 +09005317 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5318 ata_link_abort(link);
5319 return;
5320 }
5321
Linus Torvalds1da177e2005-04-16 15:20:36 -07005322 ap->ops->qc_prep(qc);
Hannes Reinecke255c03d2015-03-27 16:46:38 +01005323 trace_ata_qc_issue(qc);
Tejun Heo8e0e6942006-03-31 20:41:11 +09005324 qc->err_mask |= ap->ops->qc_issue(qc);
5325 if (unlikely(qc->err_mask))
5326 goto err;
5327 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005328
Tejun Heo60f5d6e2010-08-23 11:27:27 +02005329sys_err:
Tejun Heo8e0e6942006-03-31 20:41:11 +09005330 qc->err_mask |= AC_ERR_SYSTEM;
5331err:
5332 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005333}
5334
5335/**
Tejun Heo34bf2172006-05-15 20:57:46 +09005336 * sata_scr_valid - test whether SCRs are accessible
Tejun Heo936fd732007-08-06 18:36:23 +09005337 * @link: ATA link to test SCR accessibility for
Tejun Heo34bf2172006-05-15 20:57:46 +09005338 *
Tejun Heo936fd732007-08-06 18:36:23 +09005339 * Test whether SCRs are accessible for @link.
Tejun Heo34bf2172006-05-15 20:57:46 +09005340 *
5341 * LOCKING:
5342 * None.
5343 *
5344 * RETURNS:
5345 * 1 if SCRs are accessible, 0 otherwise.
5346 */
Tejun Heo936fd732007-08-06 18:36:23 +09005347int sata_scr_valid(struct ata_link *link)
Tejun Heo34bf2172006-05-15 20:57:46 +09005348{
Tejun Heo936fd732007-08-06 18:36:23 +09005349 struct ata_port *ap = link->ap;
5350
Tejun Heoa16abc02007-05-21 18:33:47 +02005351 return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
Tejun Heo34bf2172006-05-15 20:57:46 +09005352}
5353
5354/**
5355 * sata_scr_read - read SCR register of the specified port
Tejun Heo936fd732007-08-06 18:36:23 +09005356 * @link: ATA link to read SCR for
Tejun Heo34bf2172006-05-15 20:57:46 +09005357 * @reg: SCR to read
5358 * @val: Place to store read value
5359 *
Tejun Heo936fd732007-08-06 18:36:23 +09005360 * Read SCR register @reg of @link into *@val. This function is
Tejun Heo633273a2007-09-23 13:19:54 +09005361 * guaranteed to succeed if @link is ap->link, the cable type of
5362 * the port is SATA and the port implements ->scr_read.
Tejun Heo34bf2172006-05-15 20:57:46 +09005363 *
5364 * LOCKING:
Tejun Heo633273a2007-09-23 13:19:54 +09005365 * None if @link is ap->link. Kernel thread context otherwise.
Tejun Heo34bf2172006-05-15 20:57:46 +09005366 *
5367 * RETURNS:
5368 * 0 on success, negative errno on failure.
5369 */
Tejun Heo936fd732007-08-06 18:36:23 +09005370int sata_scr_read(struct ata_link *link, int reg, u32 *val)
Tejun Heo34bf2172006-05-15 20:57:46 +09005371{
Tejun Heo633273a2007-09-23 13:19:54 +09005372 if (ata_is_host_link(link)) {
Tejun Heo633273a2007-09-23 13:19:54 +09005373 if (sata_scr_valid(link))
Tejun Heo82ef04f2008-07-31 17:02:40 +09005374 return link->ap->ops->scr_read(link, reg, val);
Tejun Heo633273a2007-09-23 13:19:54 +09005375 return -EOPNOTSUPP;
5376 }
5377
5378 return sata_pmp_scr_read(link, reg, val);
Tejun Heo34bf2172006-05-15 20:57:46 +09005379}
5380
5381/**
5382 * sata_scr_write - write SCR register of the specified port
Tejun Heo936fd732007-08-06 18:36:23 +09005383 * @link: ATA link to write SCR for
Tejun Heo34bf2172006-05-15 20:57:46 +09005384 * @reg: SCR to write
5385 * @val: value to write
5386 *
Tejun Heo936fd732007-08-06 18:36:23 +09005387 * Write @val to SCR register @reg of @link. This function is
Tejun Heo633273a2007-09-23 13:19:54 +09005388 * guaranteed to succeed if @link is ap->link, the cable type of
5389 * the port is SATA and the port implements ->scr_read.
Tejun Heo34bf2172006-05-15 20:57:46 +09005390 *
5391 * LOCKING:
Tejun Heo633273a2007-09-23 13:19:54 +09005392 * None if @link is ap->link. Kernel thread context otherwise.
Tejun Heo34bf2172006-05-15 20:57:46 +09005393 *
5394 * RETURNS:
5395 * 0 on success, negative errno on failure.
5396 */
Tejun Heo936fd732007-08-06 18:36:23 +09005397int sata_scr_write(struct ata_link *link, int reg, u32 val)
Tejun Heo34bf2172006-05-15 20:57:46 +09005398{
Tejun Heo633273a2007-09-23 13:19:54 +09005399 if (ata_is_host_link(link)) {
Tejun Heo633273a2007-09-23 13:19:54 +09005400 if (sata_scr_valid(link))
Tejun Heo82ef04f2008-07-31 17:02:40 +09005401 return link->ap->ops->scr_write(link, reg, val);
Tejun Heo633273a2007-09-23 13:19:54 +09005402 return -EOPNOTSUPP;
5403 }
5404
5405 return sata_pmp_scr_write(link, reg, val);
Tejun Heo34bf2172006-05-15 20:57:46 +09005406}
5407
5408/**
5409 * sata_scr_write_flush - write SCR register of the specified port and flush
Tejun Heo936fd732007-08-06 18:36:23 +09005410 * @link: ATA link to write SCR for
Tejun Heo34bf2172006-05-15 20:57:46 +09005411 * @reg: SCR to write
5412 * @val: value to write
5413 *
5414 * This function is identical to sata_scr_write() except that this
5415 * function performs flush after writing to the register.
5416 *
5417 * LOCKING:
Tejun Heo633273a2007-09-23 13:19:54 +09005418 * None if @link is ap->link. Kernel thread context otherwise.
Tejun Heo34bf2172006-05-15 20:57:46 +09005419 *
5420 * RETURNS:
5421 * 0 on success, negative errno on failure.
5422 */
Tejun Heo936fd732007-08-06 18:36:23 +09005423int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
Tejun Heo34bf2172006-05-15 20:57:46 +09005424{
Tejun Heo633273a2007-09-23 13:19:54 +09005425 if (ata_is_host_link(link)) {
Tejun Heo633273a2007-09-23 13:19:54 +09005426 int rc;
Tejun Heoda3dbb12007-07-16 14:29:40 +09005427
Tejun Heo633273a2007-09-23 13:19:54 +09005428 if (sata_scr_valid(link)) {
Tejun Heo82ef04f2008-07-31 17:02:40 +09005429 rc = link->ap->ops->scr_write(link, reg, val);
Tejun Heo633273a2007-09-23 13:19:54 +09005430 if (rc == 0)
Tejun Heo82ef04f2008-07-31 17:02:40 +09005431 rc = link->ap->ops->scr_read(link, reg, &val);
Tejun Heo633273a2007-09-23 13:19:54 +09005432 return rc;
5433 }
5434 return -EOPNOTSUPP;
Tejun Heo34bf2172006-05-15 20:57:46 +09005435 }
Tejun Heo633273a2007-09-23 13:19:54 +09005436
5437 return sata_pmp_scr_write(link, reg, val);
Tejun Heo34bf2172006-05-15 20:57:46 +09005438}
5439
5440/**
Tejun Heob1c72912008-07-31 17:02:43 +09005441 * ata_phys_link_online - test whether the given link is online
Tejun Heo936fd732007-08-06 18:36:23 +09005442 * @link: ATA link to test
Tejun Heo34bf2172006-05-15 20:57:46 +09005443 *
Tejun Heo936fd732007-08-06 18:36:23 +09005444 * Test whether @link is online. Note that this function returns
5445 * 0 if online status of @link cannot be obtained, so
5446 * ata_link_online(link) != !ata_link_offline(link).
Tejun Heo34bf2172006-05-15 20:57:46 +09005447 *
5448 * LOCKING:
5449 * None.
5450 *
5451 * RETURNS:
Tejun Heob5b3fa32008-07-31 17:02:42 +09005452 * True if the port online status is available and online.
Tejun Heo34bf2172006-05-15 20:57:46 +09005453 */
Tejun Heob1c72912008-07-31 17:02:43 +09005454bool ata_phys_link_online(struct ata_link *link)
Tejun Heo34bf2172006-05-15 20:57:46 +09005455{
5456 u32 sstatus;
5457
Tejun Heo936fd732007-08-06 18:36:23 +09005458 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
Tejun Heo9913ff82009-01-29 20:31:31 +09005459 ata_sstatus_online(sstatus))
Tejun Heob5b3fa32008-07-31 17:02:42 +09005460 return true;
5461 return false;
Tejun Heo34bf2172006-05-15 20:57:46 +09005462}
5463
5464/**
Tejun Heob1c72912008-07-31 17:02:43 +09005465 * ata_phys_link_offline - test whether the given link is offline
Tejun Heo936fd732007-08-06 18:36:23 +09005466 * @link: ATA link to test
Tejun Heo34bf2172006-05-15 20:57:46 +09005467 *
Tejun Heo936fd732007-08-06 18:36:23 +09005468 * Test whether @link is offline. Note that this function
5469 * returns 0 if offline status of @link cannot be obtained, so
5470 * ata_link_online(link) != !ata_link_offline(link).
Tejun Heo34bf2172006-05-15 20:57:46 +09005471 *
5472 * LOCKING:
5473 * None.
5474 *
5475 * RETURNS:
Tejun Heob5b3fa32008-07-31 17:02:42 +09005476 * True if the port offline status is available and offline.
Tejun Heo34bf2172006-05-15 20:57:46 +09005477 */
Tejun Heob1c72912008-07-31 17:02:43 +09005478bool ata_phys_link_offline(struct ata_link *link)
Tejun Heo34bf2172006-05-15 20:57:46 +09005479{
5480 u32 sstatus;
5481
Tejun Heo936fd732007-08-06 18:36:23 +09005482 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
Tejun Heo9913ff82009-01-29 20:31:31 +09005483 !ata_sstatus_online(sstatus))
Tejun Heob5b3fa32008-07-31 17:02:42 +09005484 return true;
5485 return false;
Tejun Heo34bf2172006-05-15 20:57:46 +09005486}
Edward Falk0baab862005-06-02 18:17:13 -04005487
Tejun Heob1c72912008-07-31 17:02:43 +09005488/**
5489 * ata_link_online - test whether the given link is online
5490 * @link: ATA link to test
5491 *
5492 * Test whether @link is online. This is identical to
5493 * ata_phys_link_online() when there's no slave link. When
5494 * there's a slave link, this function should only be called on
5495 * the master link and will return true if any of M/S links is
5496 * online.
5497 *
5498 * LOCKING:
5499 * None.
5500 *
5501 * RETURNS:
5502 * True if the port online status is available and online.
5503 */
5504bool ata_link_online(struct ata_link *link)
5505{
5506 struct ata_link *slave = link->ap->slave_link;
5507
5508 WARN_ON(link == slave); /* shouldn't be called on slave link */
5509
5510 return ata_phys_link_online(link) ||
5511 (slave && ata_phys_link_online(slave));
5512}
5513
5514/**
5515 * ata_link_offline - test whether the given link is offline
5516 * @link: ATA link to test
5517 *
5518 * Test whether @link is offline. This is identical to
5519 * ata_phys_link_offline() when there's no slave link. When
5520 * there's a slave link, this function should only be called on
5521 * the master link and will return true if both M/S links are
5522 * offline.
5523 *
5524 * LOCKING:
5525 * None.
5526 *
5527 * RETURNS:
5528 * True if the port offline status is available and offline.
5529 */
5530bool ata_link_offline(struct ata_link *link)
5531{
5532 struct ata_link *slave = link->ap->slave_link;
5533
5534 WARN_ON(link == slave); /* shouldn't be called on slave link */
5535
5536 return ata_phys_link_offline(link) &&
5537 (!slave || ata_phys_link_offline(slave));
5538}
5539
Tejun Heo6ffa01d2007-03-02 17:32:47 +09005540#ifdef CONFIG_PM
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005541static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
5542 unsigned int action, unsigned int ehi_flags,
5543 bool async)
Tejun Heo500530f2006-07-03 16:07:27 +09005544{
Lin Ming5ef41082011-12-05 09:20:27 +08005545 struct ata_link *link;
Tejun Heo500530f2006-07-03 16:07:27 +09005546 unsigned long flags;
Tejun Heo500530f2006-07-03 16:07:27 +09005547
Lin Ming5ef41082011-12-05 09:20:27 +08005548 /* Previous resume operation might still be in
5549 * progress. Wait for PM_PENDING to clear.
5550 */
5551 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
5552 ata_port_wait_eh(ap);
5553 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
Tejun Heo500530f2006-07-03 16:07:27 +09005554 }
5555
Lin Ming5ef41082011-12-05 09:20:27 +08005556 /* request PM ops to EH */
5557 spin_lock_irqsave(ap->lock, flags);
5558
5559 ap->pm_mesg = mesg;
Lin Ming5ef41082011-12-05 09:20:27 +08005560 ap->pflags |= ATA_PFLAG_PM_PENDING;
5561 ata_for_each_link(link, ap, HOST_FIRST) {
5562 link->eh_info.action |= action;
5563 link->eh_info.flags |= ehi_flags;
5564 }
5565
5566 ata_port_schedule_eh(ap);
5567
5568 spin_unlock_irqrestore(ap->lock, flags);
5569
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005570 if (!async) {
Lin Ming5ef41082011-12-05 09:20:27 +08005571 ata_port_wait_eh(ap);
5572 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5573 }
Tejun Heo500530f2006-07-03 16:07:27 +09005574}
5575
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005576/*
5577 * On some hardware, device fails to respond after spun down for suspend. As
5578 * the device won't be used before being resumed, we don't need to touch the
5579 * device. Ask EH to skip the usual stuff and proceed directly to suspend.
5580 *
5581 * http://thread.gmane.org/gmane.linux.ide/46764
5582 */
5583static const unsigned int ata_port_suspend_ehi = ATA_EHI_QUIET
5584 | ATA_EHI_NO_AUTOPSY
5585 | ATA_EHI_NO_RECOVERY;
5586
5587static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)
Lin Ming5ef41082011-12-05 09:20:27 +08005588{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005589 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);
Lin Ming5ef41082011-12-05 09:20:27 +08005590}
5591
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005592static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)
5593{
5594 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);
5595}
5596
5597static int ata_port_pm_suspend(struct device *dev)
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005598{
5599 struct ata_port *ap = to_ata_port(dev);
5600
Lin Ming5ef41082011-12-05 09:20:27 +08005601 if (pm_runtime_suspended(dev))
5602 return 0;
5603
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005604 ata_port_suspend(ap, PMSG_SUSPEND);
5605 return 0;
Lin Ming33574d62011-12-22 14:50:49 +08005606}
5607
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005608static int ata_port_pm_freeze(struct device *dev)
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005609{
5610 struct ata_port *ap = to_ata_port(dev);
5611
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005612 if (pm_runtime_suspended(dev))
5613 return 0;
5614
5615 ata_port_suspend(ap, PMSG_FREEZE);
5616 return 0;
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005617}
5618
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005619static int ata_port_pm_poweroff(struct device *dev)
Lin Minge90b1e52011-12-22 14:50:48 +08005620{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005621 ata_port_suspend(to_ata_port(dev), PMSG_HIBERNATE);
5622 return 0;
5623}
Lin Minge90b1e52011-12-22 14:50:48 +08005624
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005625static const unsigned int ata_port_resume_ehi = ATA_EHI_NO_AUTOPSY
5626 | ATA_EHI_QUIET;
Lin Minge90b1e52011-12-22 14:50:48 +08005627
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005628static void ata_port_resume(struct ata_port *ap, pm_message_t mesg)
5629{
5630 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, false);
5631}
5632
5633static void ata_port_resume_async(struct ata_port *ap, pm_message_t mesg)
5634{
5635 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, true);
5636}
5637
5638static int ata_port_pm_resume(struct device *dev)
5639{
Todd Brandt200421a2014-03-14 13:52:54 -07005640 ata_port_resume_async(to_ata_port(dev), PMSG_RESUME);
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005641 pm_runtime_disable(dev);
5642 pm_runtime_set_active(dev);
5643 pm_runtime_enable(dev);
5644 return 0;
Lin Minge90b1e52011-12-22 14:50:48 +08005645}
5646
Aaron Lu7e15e9b2013-01-15 17:21:04 +08005647/*
5648 * For ODDs, the upper layer will poll for media change every few seconds,
5649 * which will make it enter and leave suspend state every few seconds. And
5650 * as each suspend will cause a hard/soft reset, the gain of runtime suspend
5651 * is very little and the ODD may malfunction after constantly being reset.
5652 * So the idle callback here will not proceed to suspend if a non-ZPODD capable
5653 * ODD is attached to the port.
5654 */
Lin Ming9ee4f392011-12-05 09:20:28 +08005655static int ata_port_runtime_idle(struct device *dev)
5656{
Aaron Lu7e15e9b2013-01-15 17:21:04 +08005657 struct ata_port *ap = to_ata_port(dev);
5658 struct ata_link *link;
5659 struct ata_device *adev;
5660
5661 ata_for_each_link(link, ap, HOST_FIRST) {
5662 ata_for_each_dev(adev, link, ENABLED)
5663 if (adev->class == ATA_DEV_ATAPI &&
5664 !zpodd_dev_enabled(adev))
5665 return -EBUSY;
5666 }
5667
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02005668 return 0;
Lin Ming9ee4f392011-12-05 09:20:28 +08005669}
5670
Aaron Lua7ff60d2013-01-25 14:29:35 +08005671static int ata_port_runtime_suspend(struct device *dev)
5672{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005673 ata_port_suspend(to_ata_port(dev), PMSG_AUTO_SUSPEND);
5674 return 0;
Aaron Lua7ff60d2013-01-25 14:29:35 +08005675}
5676
5677static int ata_port_runtime_resume(struct device *dev)
5678{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005679 ata_port_resume(to_ata_port(dev), PMSG_AUTO_RESUME);
5680 return 0;
Aaron Lua7ff60d2013-01-25 14:29:35 +08005681}
5682
Lin Ming5ef41082011-12-05 09:20:27 +08005683static const struct dev_pm_ops ata_port_pm_ops = {
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005684 .suspend = ata_port_pm_suspend,
5685 .resume = ata_port_pm_resume,
5686 .freeze = ata_port_pm_freeze,
5687 .thaw = ata_port_pm_resume,
5688 .poweroff = ata_port_pm_poweroff,
5689 .restore = ata_port_pm_resume,
Lin Ming9ee4f392011-12-05 09:20:28 +08005690
Aaron Lua7ff60d2013-01-25 14:29:35 +08005691 .runtime_suspend = ata_port_runtime_suspend,
5692 .runtime_resume = ata_port_runtime_resume,
Lin Ming9ee4f392011-12-05 09:20:28 +08005693 .runtime_idle = ata_port_runtime_idle,
Lin Ming5ef41082011-12-05 09:20:27 +08005694};
5695
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005696/* sas ports don't participate in pm runtime management of ata_ports,
5697 * and need to resume ata devices at the domain level, not the per-port
5698 * level. sas suspend/resume is async to allow parallel port recovery
5699 * since sas has multiple ata_port instances per Scsi_Host.
5700 */
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005701void ata_sas_port_suspend(struct ata_port *ap)
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005702{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005703 ata_port_suspend_async(ap, PMSG_SUSPEND);
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005704}
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005705EXPORT_SYMBOL_GPL(ata_sas_port_suspend);
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005706
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005707void ata_sas_port_resume(struct ata_port *ap)
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005708{
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005709 ata_port_resume_async(ap, PMSG_RESUME);
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005710}
Dan Williamsbc6e7c42014-03-14 13:52:48 -07005711EXPORT_SYMBOL_GPL(ata_sas_port_resume);
Dan Williams2fcbdcb2012-06-21 23:41:46 -07005712
Tejun Heo500530f2006-07-03 16:07:27 +09005713/**
Jeff Garzikcca39742006-08-24 03:19:22 -04005714 * ata_host_suspend - suspend host
5715 * @host: host to suspend
Tejun Heo500530f2006-07-03 16:07:27 +09005716 * @mesg: PM message
5717 *
Lin Ming5ef41082011-12-05 09:20:27 +08005718 * Suspend @host. Actual operation is performed by port suspend.
Tejun Heo500530f2006-07-03 16:07:27 +09005719 */
Jeff Garzikcca39742006-08-24 03:19:22 -04005720int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
Tejun Heo500530f2006-07-03 16:07:27 +09005721{
Lin Ming5ef41082011-12-05 09:20:27 +08005722 host->dev->power.power_state = mesg;
5723 return 0;
Tejun Heo500530f2006-07-03 16:07:27 +09005724}
5725
5726/**
Jeff Garzikcca39742006-08-24 03:19:22 -04005727 * ata_host_resume - resume host
5728 * @host: host to resume
Tejun Heo500530f2006-07-03 16:07:27 +09005729 *
Lin Ming5ef41082011-12-05 09:20:27 +08005730 * Resume @host. Actual operation is performed by port resume.
Tejun Heo500530f2006-07-03 16:07:27 +09005731 */
Jeff Garzikcca39742006-08-24 03:19:22 -04005732void ata_host_resume(struct ata_host *host)
Tejun Heo500530f2006-07-03 16:07:27 +09005733{
Jeff Garzik72ad6ec2008-02-25 17:31:10 -05005734 host->dev->power.power_state = PMSG_ON;
Tejun Heo500530f2006-07-03 16:07:27 +09005735}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09005736#endif
Tejun Heo500530f2006-07-03 16:07:27 +09005737
Lin Ming5ef41082011-12-05 09:20:27 +08005738struct device_type ata_port_type = {
5739 .name = "ata_port",
5740#ifdef CONFIG_PM
5741 .pm = &ata_port_pm_ops,
5742#endif
5743};
5744
Randy Dunlapc893a3a2006-01-28 13:15:32 -05005745/**
Tejun Heo3ef3b432006-05-31 18:27:30 +09005746 * ata_dev_init - Initialize an ata_device structure
5747 * @dev: Device structure to initialize
5748 *
5749 * Initialize @dev in preparation for probing.
5750 *
5751 * LOCKING:
5752 * Inherited from caller.
5753 */
5754void ata_dev_init(struct ata_device *dev)
5755{
Tejun Heob1c72912008-07-31 17:02:43 +09005756 struct ata_link *link = ata_dev_phys_link(dev);
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005757 struct ata_port *ap = link->ap;
Tejun Heo72fa4b72006-05-31 18:27:32 +09005758 unsigned long flags;
Tejun Heo3ef3b432006-05-31 18:27:30 +09005759
Tejun Heob1c72912008-07-31 17:02:43 +09005760 /* SATA spd limit is bound to the attached device, reset together */
Tejun Heo9af5c9c2007-08-06 18:36:22 +09005761 link->sata_spd_limit = link->hw_sata_spd_limit;
5762 link->sata_spd = 0;
Tejun Heo5a04bf42006-05-31 18:27:38 +09005763
Tejun Heo72fa4b72006-05-31 18:27:32 +09005764 /* High bits of dev->flags are used to record warm plug
5765 * requests which occur asynchronously. Synchronize using
Jeff Garzikcca39742006-08-24 03:19:22 -04005766 * host lock.
Tejun Heo72fa4b72006-05-31 18:27:32 +09005767 */
Jeff Garzikba6a1302006-06-22 23:46:10 -04005768 spin_lock_irqsave(ap->lock, flags);
Tejun Heo72fa4b72006-05-31 18:27:32 +09005769 dev->flags &= ~ATA_DFLAG_INIT_MASK;
Tejun Heo3dcc3232007-09-03 12:20:11 +09005770 dev->horkage = 0;
Jeff Garzikba6a1302006-06-22 23:46:10 -04005771 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo72fa4b72006-05-31 18:27:32 +09005772
Tejun Heo99cf6102009-01-29 20:31:32 +09005773 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
5774 ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
Tejun Heo3ef3b432006-05-31 18:27:30 +09005775 dev->pio_mask = UINT_MAX;
5776 dev->mwdma_mask = UINT_MAX;
5777 dev->udma_mask = UINT_MAX;
5778}
5779
5780/**
Tejun Heo4fb37a22007-08-06 18:36:23 +09005781 * ata_link_init - Initialize an ata_link structure
5782 * @ap: ATA port link is attached to
5783 * @link: Link structure to initialize
Tejun Heo89898052007-08-06 18:36:23 +09005784 * @pmp: Port multiplier port number
Tejun Heo4fb37a22007-08-06 18:36:23 +09005785 *
5786 * Initialize @link.
5787 *
5788 * LOCKING:
5789 * Kernel thread context (may sleep)
5790 */
Tejun Heofb7fd612007-09-23 13:14:12 +09005791void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
Tejun Heo4fb37a22007-08-06 18:36:23 +09005792{
5793 int i;
5794
5795 /* clear everything except for devices */
Gwendal Grignoud9027472010-05-25 12:31:38 -07005796 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5797 ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
Tejun Heo4fb37a22007-08-06 18:36:23 +09005798
5799 link->ap = ap;
Tejun Heo89898052007-08-06 18:36:23 +09005800 link->pmp = pmp;
Tejun Heo4fb37a22007-08-06 18:36:23 +09005801 link->active_tag = ATA_TAG_POISON;
5802 link->hw_sata_spd_limit = UINT_MAX;
5803
5804 /* can't use iterator, ap isn't initialized yet */
5805 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5806 struct ata_device *dev = &link->device[i];
5807
5808 dev->link = link;
5809 dev->devno = dev - link->device;
Tejun Heo110f66d2009-09-16 04:17:28 +09005810#ifdef CONFIG_ATA_ACPI
5811 dev->gtf_filter = ata_acpi_gtf_filter;
5812#endif
Tejun Heo4fb37a22007-08-06 18:36:23 +09005813 ata_dev_init(dev);
5814 }
5815}
5816
5817/**
5818 * sata_link_init_spd - Initialize link->sata_spd_limit
5819 * @link: Link to configure sata_spd_limit for
5820 *
5821 * Initialize @link->[hw_]sata_spd_limit to the currently
5822 * configured value.
5823 *
5824 * LOCKING:
5825 * Kernel thread context (may sleep).
5826 *
5827 * RETURNS:
5828 * 0 on success, -errno on failure.
5829 */
Tejun Heofb7fd612007-09-23 13:14:12 +09005830int sata_link_init_spd(struct ata_link *link)
Tejun Heo4fb37a22007-08-06 18:36:23 +09005831{
Tejun Heo33267322008-02-13 09:15:09 +09005832 u8 spd;
Tejun Heo4fb37a22007-08-06 18:36:23 +09005833 int rc;
5834
Tejun Heod127ea72008-07-31 16:09:34 +09005835 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
Tejun Heo4fb37a22007-08-06 18:36:23 +09005836 if (rc)
5837 return rc;
5838
Tejun Heod127ea72008-07-31 16:09:34 +09005839 spd = (link->saved_scontrol >> 4) & 0xf;
Tejun Heo4fb37a22007-08-06 18:36:23 +09005840 if (spd)
5841 link->hw_sata_spd_limit &= (1 << spd) - 1;
5842
Tejun Heo05944bd2008-08-13 20:19:09 +09005843 ata_force_link_limits(link);
Tejun Heo33267322008-02-13 09:15:09 +09005844
Tejun Heo4fb37a22007-08-06 18:36:23 +09005845 link->sata_spd_limit = link->hw_sata_spd_limit;
5846
5847 return 0;
5848}
5849
5850/**
Tejun Heof3187192007-04-17 23:44:07 +09005851 * ata_port_alloc - allocate and initialize basic ATA port resources
5852 * @host: ATA host this allocated port belongs to
Linus Torvalds1da177e2005-04-16 15:20:36 -07005853 *
Tejun Heof3187192007-04-17 23:44:07 +09005854 * Allocate and initialize basic ATA port resources.
5855 *
5856 * RETURNS:
5857 * Allocate ATA port on success, NULL on failure.
Jeff Garzik0cba6322005-05-30 19:49:12 -04005858 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005859 * LOCKING:
Tejun Heof3187192007-04-17 23:44:07 +09005860 * Inherited from calling layer (may sleep).
Linus Torvalds1da177e2005-04-16 15:20:36 -07005861 */
Tejun Heof3187192007-04-17 23:44:07 +09005862struct ata_port *ata_port_alloc(struct ata_host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005863{
Tejun Heof3187192007-04-17 23:44:07 +09005864 struct ata_port *ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005865
Tejun Heof3187192007-04-17 23:44:07 +09005866 DPRINTK("ENTER\n");
5867
5868 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5869 if (!ap)
5870 return NULL;
Jeff Garzik4fca3772011-02-15 01:13:24 -05005871
Maxime Bizon7b3a24c2011-03-16 14:58:32 +01005872 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
Jeff Garzikcca39742006-08-24 03:19:22 -04005873 ap->lock = &host->lock;
Tejun Heof3187192007-04-17 23:44:07 +09005874 ap->print_id = -1;
David Milburne628dc92013-05-14 13:48:40 -05005875 ap->local_port_no = -1;
Jeff Garzikcca39742006-08-24 03:19:22 -04005876 ap->host = host;
Tejun Heof3187192007-04-17 23:44:07 +09005877 ap->dev = host->dev;
Borislav Petkovbd5d8252006-06-11 23:17:01 -04005878
5879#if defined(ATA_VERBOSE_DEBUG)
5880 /* turn on all debugging levels */
5881 ap->msg_enable = 0x00FF;
5882#elif defined(ATA_DEBUG)
5883 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
Tejun Heo88574552006-06-25 20:00:35 +09005884#else
Borislav Petkov0dd4b212006-06-23 02:29:08 -04005885 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
Borislav Petkovbd5d8252006-06-11 23:17:01 -04005886#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07005887
Tejun Heoad72cf92010-07-02 10:03:52 +02005888 mutex_init(&ap->scsi_scan_mutex);
David Howells65f27f32006-11-22 14:55:48 +00005889 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5890 INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
Tejun Heoa72ec4c2006-01-23 13:09:37 +09005891 INIT_LIST_HEAD(&ap->eh_done_q);
Tejun Heoc6cf9e92006-05-31 18:27:27 +09005892 init_waitqueue_head(&ap->eh_wait_q);
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02005893 init_completion(&ap->park_req_pending);
Tejun Heo5ddf24c2007-07-16 14:29:41 +09005894 init_timer_deferrable(&ap->fastdrain_timer);
5895 ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn;
5896 ap->fastdrain_timer.data = (unsigned long)ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005897
Tejun Heo838df622006-05-15 20:57:44 +09005898 ap->cbl = ATA_CBL_NONE;
Tejun Heo838df622006-05-15 20:57:44 +09005899
Tejun Heo89898052007-08-06 18:36:23 +09005900 ata_link_init(ap, &ap->link, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005901
5902#ifdef ATA_IRQ_TRAP
5903 ap->stats.unhandled_irq = 1;
5904 ap->stats.idle_irq = 1;
5905#endif
Tejun Heo270390e2010-05-10 21:41:35 +02005906 ata_sff_port_init(ap);
5907
Linus Torvalds1da177e2005-04-16 15:20:36 -07005908 return ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005909}
5910
Tejun Heof0d36ef2007-01-20 16:00:28 +09005911static void ata_host_release(struct device *gendev, void *res)
5912{
5913 struct ata_host *host = dev_get_drvdata(gendev);
5914 int i;
5915
5916 for (i = 0; i < host->n_ports; i++) {
5917 struct ata_port *ap = host->ports[i];
5918
Tejun Heoecef7252007-04-17 23:44:06 +09005919 if (!ap)
5920 continue;
5921
Tejun Heo49114872007-04-17 23:44:06 +09005922 if (ap->scsi_host)
Tejun Heo1aa506e2007-03-09 19:36:12 +09005923 scsi_host_put(ap->scsi_host);
5924
Tejun Heo633273a2007-09-23 13:19:54 +09005925 kfree(ap->pmp_link);
Tejun Heob1c72912008-07-31 17:02:43 +09005926 kfree(ap->slave_link);
Tejun Heo49114872007-04-17 23:44:06 +09005927 kfree(ap);
Tejun Heo1aa506e2007-03-09 19:36:12 +09005928 host->ports[i] = NULL;
5929 }
5930
Tejun Heo1aa56cc2007-02-27 22:33:21 +09005931 dev_set_drvdata(gendev, NULL);
Tejun Heof0d36ef2007-01-20 16:00:28 +09005932}
5933
Linus Torvalds1da177e2005-04-16 15:20:36 -07005934/**
Tejun Heof3187192007-04-17 23:44:07 +09005935 * ata_host_alloc - allocate and init basic ATA host resources
5936 * @dev: generic device this host is associated with
5937 * @max_ports: maximum number of ATA ports associated with this host
5938 *
5939 * Allocate and initialize basic ATA host resources. LLD calls
5940 * this function to allocate a host, initializes it fully and
5941 * attaches it using ata_host_register().
5942 *
5943 * @max_ports ports are allocated and host->n_ports is
5944 * initialized to @max_ports. The caller is allowed to decrease
5945 * host->n_ports before calling ata_host_register(). The unused
5946 * ports will be automatically freed on registration.
5947 *
5948 * RETURNS:
5949 * Allocate ATA host on success, NULL on failure.
5950 *
5951 * LOCKING:
5952 * Inherited from calling layer (may sleep).
5953 */
5954struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
5955{
5956 struct ata_host *host;
5957 size_t sz;
5958 int i;
5959
5960 DPRINTK("ENTER\n");
5961
5962 if (!devres_open_group(dev, NULL, GFP_KERNEL))
5963 return NULL;
5964
5965 /* alloc a container for our list of ATA ports (buses) */
5966 sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
5967 /* alloc a container for our list of ATA ports (buses) */
5968 host = devres_alloc(ata_host_release, sz, GFP_KERNEL);
5969 if (!host)
5970 goto err_out;
5971
5972 devres_add(dev, host);
5973 dev_set_drvdata(dev, host);
5974
5975 spin_lock_init(&host->lock);
Tejun Heoc0c362b2010-09-06 17:57:14 +02005976 mutex_init(&host->eh_mutex);
Tejun Heof3187192007-04-17 23:44:07 +09005977 host->dev = dev;
5978 host->n_ports = max_ports;
5979
5980 /* allocate ports bound to this host */
5981 for (i = 0; i < max_ports; i++) {
5982 struct ata_port *ap;
5983
5984 ap = ata_port_alloc(host);
5985 if (!ap)
5986 goto err_out;
5987
5988 ap->port_no = i;
5989 host->ports[i] = ap;
5990 }
5991
5992 devres_remove_group(dev, NULL);
5993 return host;
5994
5995 err_out:
5996 devres_release_group(dev, NULL);
5997 return NULL;
5998}
5999
6000/**
Tejun Heof5cda252007-04-17 23:44:07 +09006001 * ata_host_alloc_pinfo - alloc host and init with port_info array
6002 * @dev: generic device this host is associated with
6003 * @ppi: array of ATA port_info to initialize host with
6004 * @n_ports: number of ATA ports attached to this host
6005 *
6006 * Allocate ATA host and initialize with info from @ppi. If NULL
6007 * terminated, @ppi may contain fewer entries than @n_ports. The
6008 * last entry will be used for the remaining ports.
6009 *
6010 * RETURNS:
6011 * Allocate ATA host on success, NULL on failure.
6012 *
6013 * LOCKING:
6014 * Inherited from calling layer (may sleep).
6015 */
6016struct ata_host *ata_host_alloc_pinfo(struct device *dev,
6017 const struct ata_port_info * const * ppi,
6018 int n_ports)
6019{
6020 const struct ata_port_info *pi;
6021 struct ata_host *host;
6022 int i, j;
6023
6024 host = ata_host_alloc(dev, n_ports);
6025 if (!host)
6026 return NULL;
6027
6028 for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) {
6029 struct ata_port *ap = host->ports[i];
6030
6031 if (ppi[j])
6032 pi = ppi[j++];
6033
6034 ap->pio_mask = pi->pio_mask;
6035 ap->mwdma_mask = pi->mwdma_mask;
6036 ap->udma_mask = pi->udma_mask;
6037 ap->flags |= pi->flags;
Tejun Heo0c887582007-08-06 18:36:23 +09006038 ap->link.flags |= pi->link_flags;
Tejun Heof5cda252007-04-17 23:44:07 +09006039 ap->ops = pi->port_ops;
6040
6041 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
6042 host->ops = pi->port_ops;
Tejun Heof5cda252007-04-17 23:44:07 +09006043 }
6044
6045 return host;
6046}
6047
Tejun Heob1c72912008-07-31 17:02:43 +09006048/**
6049 * ata_slave_link_init - initialize slave link
6050 * @ap: port to initialize slave link for
6051 *
6052 * Create and initialize slave link for @ap. This enables slave
6053 * link handling on the port.
6054 *
6055 * In libata, a port contains links and a link contains devices.
6056 * There is single host link but if a PMP is attached to it,
6057 * there can be multiple fan-out links. On SATA, there's usually
6058 * a single device connected to a link but PATA and SATA
6059 * controllers emulating TF based interface can have two - master
6060 * and slave.
6061 *
6062 * However, there are a few controllers which don't fit into this
6063 * abstraction too well - SATA controllers which emulate TF
6064 * interface with both master and slave devices but also have
6065 * separate SCR register sets for each device. These controllers
6066 * need separate links for physical link handling
6067 * (e.g. onlineness, link speed) but should be treated like a
6068 * traditional M/S controller for everything else (e.g. command
6069 * issue, softreset).
6070 *
6071 * slave_link is libata's way of handling this class of
6072 * controllers without impacting core layer too much. For
6073 * anything other than physical link handling, the default host
6074 * link is used for both master and slave. For physical link
6075 * handling, separate @ap->slave_link is used. All dirty details
6076 * are implemented inside libata core layer. From LLD's POV, the
6077 * only difference is that prereset, hardreset and postreset are
6078 * called once more for the slave link, so the reset sequence
6079 * looks like the following.
6080 *
6081 * prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
6082 * softreset(M) -> postreset(M) -> postreset(S)
6083 *
6084 * Note that softreset is called only for the master. Softreset
6085 * resets both M/S by definition, so SRST on master should handle
6086 * both (the standard method will work just fine).
6087 *
6088 * LOCKING:
6089 * Should be called before host is registered.
6090 *
6091 * RETURNS:
6092 * 0 on success, -errno on failure.
6093 */
6094int ata_slave_link_init(struct ata_port *ap)
6095{
6096 struct ata_link *link;
6097
6098 WARN_ON(ap->slave_link);
6099 WARN_ON(ap->flags & ATA_FLAG_PMP);
6100
6101 link = kzalloc(sizeof(*link), GFP_KERNEL);
6102 if (!link)
6103 return -ENOMEM;
6104
6105 ata_link_init(ap, link, 1);
6106 ap->slave_link = link;
6107 return 0;
6108}
6109
Tejun Heo32ebbc02007-11-08 13:09:00 +09006110static void ata_host_stop(struct device *gendev, void *res)
6111{
6112 struct ata_host *host = dev_get_drvdata(gendev);
6113 int i;
6114
6115 WARN_ON(!(host->flags & ATA_HOST_STARTED));
6116
6117 for (i = 0; i < host->n_ports; i++) {
6118 struct ata_port *ap = host->ports[i];
6119
6120 if (ap->ops->port_stop)
6121 ap->ops->port_stop(ap);
6122 }
6123
6124 if (host->ops->host_stop)
6125 host->ops->host_stop(host);
6126}
6127
Tejun Heof5cda252007-04-17 23:44:07 +09006128/**
Tejun Heo029cfd62008-03-25 12:22:49 +09006129 * ata_finalize_port_ops - finalize ata_port_operations
6130 * @ops: ata_port_operations to finalize
6131 *
6132 * An ata_port_operations can inherit from another ops and that
6133 * ops can again inherit from another. This can go on as many
6134 * times as necessary as long as there is no loop in the
6135 * inheritance chain.
6136 *
6137 * Ops tables are finalized when the host is started. NULL or
6138 * unspecified entries are inherited from the closet ancestor
6139 * which has the method and the entry is populated with it.
6140 * After finalization, the ops table directly points to all the
6141 * methods and ->inherits is no longer necessary and cleared.
6142 *
6143 * Using ATA_OP_NULL, inheriting ops can force a method to NULL.
6144 *
6145 * LOCKING:
6146 * None.
6147 */
6148static void ata_finalize_port_ops(struct ata_port_operations *ops)
6149{
Pradeep Singh Rautela2da67652008-05-29 23:28:14 +05306150 static DEFINE_SPINLOCK(lock);
Tejun Heo029cfd62008-03-25 12:22:49 +09006151 const struct ata_port_operations *cur;
6152 void **begin = (void **)ops;
6153 void **end = (void **)&ops->inherits;
6154 void **pp;
6155
6156 if (!ops || !ops->inherits)
6157 return;
6158
6159 spin_lock(&lock);
6160
6161 for (cur = ops->inherits; cur; cur = cur->inherits) {
6162 void **inherit = (void **)cur;
6163
6164 for (pp = begin; pp < end; pp++, inherit++)
6165 if (!*pp)
6166 *pp = *inherit;
6167 }
6168
6169 for (pp = begin; pp < end; pp++)
6170 if (IS_ERR(*pp))
6171 *pp = NULL;
6172
6173 ops->inherits = NULL;
6174
6175 spin_unlock(&lock);
6176}
6177
6178/**
Tejun Heoecef7252007-04-17 23:44:06 +09006179 * ata_host_start - start and freeze ports of an ATA host
6180 * @host: ATA host to start ports for
6181 *
6182 * Start and then freeze ports of @host. Started status is
6183 * recorded in host->flags, so this function can be called
6184 * multiple times. Ports are guaranteed to get started only
Tejun Heof3187192007-04-17 23:44:07 +09006185 * once. If host->ops isn't initialized yet, its set to the
6186 * first non-dummy port ops.
Tejun Heoecef7252007-04-17 23:44:06 +09006187 *
6188 * LOCKING:
6189 * Inherited from calling layer (may sleep).
6190 *
6191 * RETURNS:
6192 * 0 if all ports are started successfully, -errno otherwise.
6193 */
6194int ata_host_start(struct ata_host *host)
6195{
Tejun Heo32ebbc02007-11-08 13:09:00 +09006196 int have_stop = 0;
6197 void *start_dr = NULL;
Tejun Heoecef7252007-04-17 23:44:06 +09006198 int i, rc;
6199
6200 if (host->flags & ATA_HOST_STARTED)
6201 return 0;
6202
Tejun Heo029cfd62008-03-25 12:22:49 +09006203 ata_finalize_port_ops(host->ops);
6204
Tejun Heoecef7252007-04-17 23:44:06 +09006205 for (i = 0; i < host->n_ports; i++) {
6206 struct ata_port *ap = host->ports[i];
6207
Tejun Heo029cfd62008-03-25 12:22:49 +09006208 ata_finalize_port_ops(ap->ops);
6209
Tejun Heof3187192007-04-17 23:44:07 +09006210 if (!host->ops && !ata_port_is_dummy(ap))
6211 host->ops = ap->ops;
6212
Tejun Heo32ebbc02007-11-08 13:09:00 +09006213 if (ap->ops->port_stop)
6214 have_stop = 1;
6215 }
6216
6217 if (host->ops->host_stop)
6218 have_stop = 1;
6219
6220 if (have_stop) {
6221 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
6222 if (!start_dr)
6223 return -ENOMEM;
6224 }
6225
6226 for (i = 0; i < host->n_ports; i++) {
6227 struct ata_port *ap = host->ports[i];
6228
Tejun Heoecef7252007-04-17 23:44:06 +09006229 if (ap->ops->port_start) {
6230 rc = ap->ops->port_start(ap);
6231 if (rc) {
Alan Cox0f9fe9b2007-11-30 15:23:16 +00006232 if (rc != -ENODEV)
Joe Perchesa44fec12011-04-15 15:51:58 -07006233 dev_err(host->dev,
6234 "failed to start port %d (errno=%d)\n",
6235 i, rc);
Tejun Heoecef7252007-04-17 23:44:06 +09006236 goto err_out;
6237 }
6238 }
Tejun Heoecef7252007-04-17 23:44:06 +09006239 ata_eh_freeze_port(ap);
6240 }
6241
Tejun Heo32ebbc02007-11-08 13:09:00 +09006242 if (start_dr)
6243 devres_add(host->dev, start_dr);
Tejun Heoecef7252007-04-17 23:44:06 +09006244 host->flags |= ATA_HOST_STARTED;
6245 return 0;
6246
6247 err_out:
6248 while (--i >= 0) {
6249 struct ata_port *ap = host->ports[i];
6250
6251 if (ap->ops->port_stop)
6252 ap->ops->port_stop(ap);
6253 }
Tejun Heo32ebbc02007-11-08 13:09:00 +09006254 devres_free(start_dr);
Tejun Heoecef7252007-04-17 23:44:06 +09006255 return rc;
6256}
6257
6258/**
Dan Williams8d8e7d12012-07-09 21:06:08 -07006259 * ata_sas_host_init - Initialize a host struct for sas (ipr, libsas)
Jeff Garzikcca39742006-08-24 03:19:22 -04006260 * @host: host to initialize
6261 * @dev: device host is attached to
Jeff Garzikcca39742006-08-24 03:19:22 -04006262 * @ops: port_ops
Brian Kingb03732f2006-08-07 14:27:10 -05006263 *
Brian Kingb03732f2006-08-07 14:27:10 -05006264 */
Jeff Garzikcca39742006-08-24 03:19:22 -04006265void ata_host_init(struct ata_host *host, struct device *dev,
Dan Williams8d8e7d12012-07-09 21:06:08 -07006266 struct ata_port_operations *ops)
Brian Kingb03732f2006-08-07 14:27:10 -05006267{
Jeff Garzikcca39742006-08-24 03:19:22 -04006268 spin_lock_init(&host->lock);
Tejun Heoc0c362b2010-09-06 17:57:14 +02006269 mutex_init(&host->eh_mutex);
Tejun Heo1a112d12014-07-23 09:05:27 -04006270 host->n_tags = ATA_MAX_QUEUE - 1;
Jeff Garzikcca39742006-08-24 03:19:22 -04006271 host->dev = dev;
Jeff Garzikcca39742006-08-24 03:19:22 -04006272 host->ops = ops;
Brian Kingb03732f2006-08-07 14:27:10 -05006273}
6274
Dan Williams9508a662012-01-18 20:47:01 -08006275void __ata_port_probe(struct ata_port *ap)
6276{
6277 struct ata_eh_info *ehi = &ap->link.eh_info;
6278 unsigned long flags;
6279
6280 /* kick EH for boot probing */
6281 spin_lock_irqsave(ap->lock, flags);
6282
6283 ehi->probe_mask |= ATA_ALL_DEVICES;
6284 ehi->action |= ATA_EH_RESET;
6285 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
6286
6287 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
6288 ap->pflags |= ATA_PFLAG_LOADING;
6289 ata_port_schedule_eh(ap);
6290
6291 spin_unlock_irqrestore(ap->lock, flags);
6292}
6293
James Bottomley238c9cf2011-01-23 08:28:33 -06006294int ata_port_probe(struct ata_port *ap)
Arjan van de Ven79318052009-01-04 05:32:28 -08006295{
James Bottomley238c9cf2011-01-23 08:28:33 -06006296 int rc = 0;
Arjan van de Ven886ad092009-01-09 15:54:07 -08006297
Arjan van de Ven79318052009-01-04 05:32:28 -08006298 if (ap->ops->error_handler) {
Dan Williams9508a662012-01-18 20:47:01 -08006299 __ata_port_probe(ap);
Arjan van de Ven79318052009-01-04 05:32:28 -08006300 ata_port_wait_eh(ap);
6301 } else {
6302 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
6303 rc = ata_bus_probe(ap);
6304 DPRINTK("ata%u: bus probe end\n", ap->print_id);
Arjan van de Ven79318052009-01-04 05:32:28 -08006305 }
James Bottomley238c9cf2011-01-23 08:28:33 -06006306 return rc;
6307}
6308
6309
6310static void async_port_probe(void *data, async_cookie_t cookie)
6311{
6312 struct ata_port *ap = data;
Jeff Garzik4fca3772011-02-15 01:13:24 -05006313
James Bottomley238c9cf2011-01-23 08:28:33 -06006314 /*
6315 * If we're not allowed to scan this host in parallel,
6316 * we need to wait until all previous scans have completed
6317 * before going further.
6318 * Jeff Garzik says this is only within a controller, so we
6319 * don't need to wait for port 0, only for later ports.
6320 */
6321 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
6322 async_synchronize_cookie(cookie);
6323
6324 (void)ata_port_probe(ap);
Arjan van de Venf29d3b22009-01-05 15:07:07 -08006325
6326 /* in order to keep device order, we need to synchronize at this point */
6327 async_synchronize_cookie(cookie);
6328
6329 ata_scsi_scan_host(ap, 1);
Arjan van de Ven79318052009-01-04 05:32:28 -08006330}
James Bottomley238c9cf2011-01-23 08:28:33 -06006331
Brian Kingb03732f2006-08-07 14:27:10 -05006332/**
Tejun Heof3187192007-04-17 23:44:07 +09006333 * ata_host_register - register initialized ATA host
6334 * @host: ATA host to register
6335 * @sht: template for SCSI host
Jeff Garzik0cba6322005-05-30 19:49:12 -04006336 *
Tejun Heof3187192007-04-17 23:44:07 +09006337 * Register initialized ATA host. @host is allocated using
6338 * ata_host_alloc() and fully initialized by LLD. This function
6339 * starts ports, registers @host with ATA and SCSI layers and
6340 * probe registered devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006341 *
6342 * LOCKING:
Tejun Heof3187192007-04-17 23:44:07 +09006343 * Inherited from calling layer (may sleep).
Linus Torvalds1da177e2005-04-16 15:20:36 -07006344 *
6345 * RETURNS:
Tejun Heof3187192007-04-17 23:44:07 +09006346 * 0 on success, -errno otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006347 */
Tejun Heof3187192007-04-17 23:44:07 +09006348int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006349{
Tejun Heof3187192007-04-17 23:44:07 +09006350 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006351
Tejun Heo1a112d12014-07-23 09:05:27 -04006352 host->n_tags = clamp(sht->can_queue, 1, ATA_MAX_QUEUE - 1);
Kevin Hao1871ee12014-07-12 12:08:24 +08006353
Tejun Heof3187192007-04-17 23:44:07 +09006354 /* host must have been started */
6355 if (!(host->flags & ATA_HOST_STARTED)) {
Joe Perchesa44fec12011-04-15 15:51:58 -07006356 dev_err(host->dev, "BUG: trying to register unstarted host\n");
Tejun Heof3187192007-04-17 23:44:07 +09006357 WARN_ON(1);
6358 return -EINVAL;
Alan Cox02f076a2006-09-26 17:35:32 +01006359 }
Tejun Heof0d36ef2007-01-20 16:00:28 +09006360
Tejun Heof3187192007-04-17 23:44:07 +09006361 /* Blow away unused ports. This happens when LLD can't
6362 * determine the exact number of ports to allocate at
6363 * allocation time.
6364 */
6365 for (i = host->n_ports; host->ports[i]; i++)
6366 kfree(host->ports[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006367
Tejun Heof3187192007-04-17 23:44:07 +09006368 /* give ports names and add SCSI hosts */
David Milburne628dc92013-05-14 13:48:40 -05006369 for (i = 0; i < host->n_ports; i++) {
Dan Williams85d67252012-03-10 23:28:46 -08006370 host->ports[i]->print_id = atomic_inc_return(&ata_print_id);
David Milburne628dc92013-05-14 13:48:40 -05006371 host->ports[i]->local_port_no = i + 1;
6372 }
Jeff Garzik4fca3772011-02-15 01:13:24 -05006373
Gwendal Grignoud9027472010-05-25 12:31:38 -07006374 /* Create associated sysfs transport objects */
6375 for (i = 0; i < host->n_ports; i++) {
6376 rc = ata_tport_add(host->dev,host->ports[i]);
6377 if (rc) {
6378 goto err_tadd;
6379 }
6380 }
6381
Tejun Heof3187192007-04-17 23:44:07 +09006382 rc = ata_scsi_add_hosts(host, sht);
Tejun Heoecef7252007-04-17 23:44:06 +09006383 if (rc)
Gwendal Grignoud9027472010-05-25 12:31:38 -07006384 goto err_tadd;
Tejun Heoecef7252007-04-17 23:44:06 +09006385
Tejun Heof3187192007-04-17 23:44:07 +09006386 /* set cable, sata_spd_limit and report */
Jeff Garzikcca39742006-08-24 03:19:22 -04006387 for (i = 0; i < host->n_ports; i++) {
6388 struct ata_port *ap = host->ports[i];
Tejun Heof3187192007-04-17 23:44:07 +09006389 unsigned long xfer_mask;
6390
6391 /* set SATA cable type if still unset */
6392 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
6393 ap->cbl = ATA_CBL_SATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006394
Tejun Heo5a04bf42006-05-31 18:27:38 +09006395 /* init sata_spd_limit to the current value */
Tejun Heo4fb37a22007-08-06 18:36:23 +09006396 sata_link_init_spd(&ap->link);
Tejun Heob1c72912008-07-31 17:02:43 +09006397 if (ap->slave_link)
6398 sata_link_init_spd(ap->slave_link);
Tejun Heo5a04bf42006-05-31 18:27:38 +09006399
Tejun Heocbcdd872007-08-18 13:14:55 +09006400 /* print per-port info to dmesg */
Tejun Heof3187192007-04-17 23:44:07 +09006401 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
6402 ap->udma_mask);
6403
Tejun Heoabf6e8e2007-10-09 14:57:25 +09006404 if (!ata_port_is_dummy(ap)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07006405 ata_port_info(ap, "%cATA max %s %s\n",
6406 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
6407 ata_mode_string(xfer_mask),
6408 ap->link.eh_info.desc);
Tejun Heoabf6e8e2007-10-09 14:57:25 +09006409 ata_ehi_clear_desc(&ap->link.eh_info);
6410 } else
Joe Perchesa9a79df2011-04-15 15:51:59 -07006411 ata_port_info(ap, "DUMMY\n");
Tejun Heof3187192007-04-17 23:44:07 +09006412 }
6413
Vegard Nossumf6005352009-04-08 18:19:39 +02006414 /* perform each probe asynchronously */
Tejun Heof3187192007-04-17 23:44:07 +09006415 for (i = 0; i < host->n_ports; i++) {
6416 struct ata_port *ap = host->ports[i];
Arjan van de Ven79318052009-01-04 05:32:28 -08006417 async_schedule(async_port_probe, ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006419
Tejun Heof3187192007-04-17 23:44:07 +09006420 return 0;
Gwendal Grignoud9027472010-05-25 12:31:38 -07006421
6422 err_tadd:
6423 while (--i >= 0) {
6424 ata_tport_delete(host->ports[i]);
6425 }
6426 return rc;
6427
Tejun Heof3187192007-04-17 23:44:07 +09006428}
6429
6430/**
Tejun Heof5cda252007-04-17 23:44:07 +09006431 * ata_host_activate - start host, request IRQ and register it
6432 * @host: target ATA host
6433 * @irq: IRQ to request
6434 * @irq_handler: irq_handler used when requesting IRQ
6435 * @irq_flags: irq_flags used when requesting IRQ
6436 * @sht: scsi_host_template to use when registering the host
6437 *
6438 * After allocating an ATA host and initializing it, most libata
6439 * LLDs perform three steps to activate the host - start host,
Masanari Iidac9b55602016-04-13 23:36:27 +09006440 * request IRQ and register it. This helper takes necessary
Tejun Heof5cda252007-04-17 23:44:07 +09006441 * arguments and performs the three steps in one go.
6442 *
Paul Mundt3d46b2e2007-11-08 11:14:56 +09006443 * An invalid IRQ skips the IRQ registration and expects the host to
6444 * have set polling mode on the port. In this case, @irq_handler
6445 * should be NULL.
6446 *
Tejun Heof5cda252007-04-17 23:44:07 +09006447 * LOCKING:
6448 * Inherited from calling layer (may sleep).
6449 *
6450 * RETURNS:
6451 * 0 on success, -errno otherwise.
6452 */
6453int ata_host_activate(struct ata_host *host, int irq,
6454 irq_handler_t irq_handler, unsigned long irq_flags,
6455 struct scsi_host_template *sht)
6456{
Tejun Heocbcdd872007-08-18 13:14:55 +09006457 int i, rc;
Heiner Kallweit7e22c002015-12-06 21:56:33 +01006458 char *irq_desc;
Tejun Heof5cda252007-04-17 23:44:07 +09006459
6460 rc = ata_host_start(host);
6461 if (rc)
6462 return rc;
6463
Paul Mundt3d46b2e2007-11-08 11:14:56 +09006464 /* Special case for polling mode */
6465 if (!irq) {
6466 WARN_ON(irq_handler);
6467 return ata_host_register(host, sht);
6468 }
6469
Heiner Kallweit7e22c002015-12-06 21:56:33 +01006470 irq_desc = devm_kasprintf(host->dev, GFP_KERNEL, "%s[%s]",
6471 dev_driver_string(host->dev),
6472 dev_name(host->dev));
6473 if (!irq_desc)
6474 return -ENOMEM;
6475
Tejun Heof5cda252007-04-17 23:44:07 +09006476 rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
Heiner Kallweit7e22c002015-12-06 21:56:33 +01006477 irq_desc, host);
Tejun Heof5cda252007-04-17 23:44:07 +09006478 if (rc)
6479 return rc;
6480
Tejun Heocbcdd872007-08-18 13:14:55 +09006481 for (i = 0; i < host->n_ports; i++)
6482 ata_port_desc(host->ports[i], "irq %d", irq);
Tejun Heo40318262007-07-03 01:38:47 +09006483
Tejun Heof5cda252007-04-17 23:44:07 +09006484 rc = ata_host_register(host, sht);
6485 /* if failed, just free the IRQ and leave ports alone */
6486 if (rc)
6487 devm_free_irq(host->dev, irq, host);
6488
6489 return rc;
6490}
6491
6492/**
Masanari Iidac9b55602016-04-13 23:36:27 +09006493 * ata_port_detach - Detach ATA port in preparation of device removal
Tejun Heo720ba122006-05-31 18:28:13 +09006494 * @ap: ATA port to be detached
6495 *
6496 * Detach all ATA devices and the associated SCSI devices of @ap;
6497 * then, remove the associated SCSI host. @ap is guaranteed to
6498 * be quiescent on return from this function.
6499 *
6500 * LOCKING:
6501 * Kernel thread context (may sleep).
6502 */
Adrian Bunk741b7762007-10-24 18:23:06 +02006503static void ata_port_detach(struct ata_port *ap)
Tejun Heo720ba122006-05-31 18:28:13 +09006504{
6505 unsigned long flags;
Levente Kurusaa6f9bf42014-05-06 15:57:48 +02006506 struct ata_link *link;
6507 struct ata_device *dev;
Tejun Heo720ba122006-05-31 18:28:13 +09006508
6509 if (!ap->ops->error_handler)
Tejun Heoc3cf30a2006-08-05 03:59:11 +09006510 goto skip_eh;
Tejun Heo720ba122006-05-31 18:28:13 +09006511
6512 /* tell EH we're leaving & flush EH */
Jeff Garzikba6a1302006-06-22 23:46:10 -04006513 spin_lock_irqsave(ap->lock, flags);
Tejun Heob51e9e52006-06-29 01:29:30 +09006514 ap->pflags |= ATA_PFLAG_UNLOADING;
Tejun Heoece180d2008-11-03 20:04:37 +09006515 ata_port_schedule_eh(ap);
Jeff Garzikba6a1302006-06-22 23:46:10 -04006516 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo720ba122006-05-31 18:28:13 +09006517
Tejun Heoece180d2008-11-03 20:04:37 +09006518 /* wait till EH commits suicide */
Tejun Heo720ba122006-05-31 18:28:13 +09006519 ata_port_wait_eh(ap);
6520
Tejun Heoece180d2008-11-03 20:04:37 +09006521 /* it better be dead now */
6522 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
Tejun Heo720ba122006-05-31 18:28:13 +09006523
Tejun Heoafe2c512010-12-14 16:21:17 +01006524 cancel_delayed_work_sync(&ap->hotplug_task);
Tejun Heo720ba122006-05-31 18:28:13 +09006525
Tejun Heoc3cf30a2006-08-05 03:59:11 +09006526 skip_eh:
Levente Kurusaa6f9bf42014-05-06 15:57:48 +02006527 /* clean up zpodd on port removal */
6528 ata_for_each_link(link, ap, HOST_FIRST) {
6529 ata_for_each_dev(dev, link, ALL) {
6530 if (zpodd_dev_enabled(dev))
6531 zpodd_exit(dev);
6532 }
6533 }
Gwendal Grignoud9027472010-05-25 12:31:38 -07006534 if (ap->pmp_link) {
6535 int i;
6536 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
6537 ata_tlink_delete(&ap->pmp_link[i]);
6538 }
Tejun Heo720ba122006-05-31 18:28:13 +09006539 /* remove the associated SCSI host */
Jeff Garzikcca39742006-08-24 03:19:22 -04006540 scsi_remove_host(ap->scsi_host);
Rafael J. Wysockic5700762013-11-25 13:19:01 +01006541 ata_tport_delete(ap);
Tejun Heo720ba122006-05-31 18:28:13 +09006542}
6543
6544/**
Tejun Heo0529c1592007-01-20 16:00:26 +09006545 * ata_host_detach - Detach all ports of an ATA host
6546 * @host: Host to detach
6547 *
6548 * Detach all ports of @host.
6549 *
6550 * LOCKING:
6551 * Kernel thread context (may sleep).
6552 */
6553void ata_host_detach(struct ata_host *host)
6554{
6555 int i;
6556
6557 for (i = 0; i < host->n_ports; i++)
6558 ata_port_detach(host->ports[i]);
Tejun Heo562f0c22007-12-15 15:05:01 +09006559
6560 /* the host is dead now, dissociate ACPI */
6561 ata_acpi_dissociate(host);
Tejun Heo0529c1592007-01-20 16:00:26 +09006562}
6563
Jeff Garzik374b1872005-08-30 05:42:52 -04006564#ifdef CONFIG_PCI
6565
Edward Falk0baab862005-06-02 18:17:13 -04006566/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07006567 * ata_pci_remove_one - PCI layer callback for device removal
6568 * @pdev: PCI device that was removed
6569 *
Tejun Heob878ca52007-01-20 16:00:28 +09006570 * PCI layer indicates to libata via this hook that hot-unplug or
6571 * module unload event has occurred. Detach all ports. Resource
6572 * release is handled via devres.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006573 *
6574 * LOCKING:
6575 * Inherited from PCI layer (may sleep).
6576 */
Tejun Heof0d36ef2007-01-20 16:00:28 +09006577void ata_pci_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006578{
Brian Norris04a3f5b2012-12-03 10:34:41 -08006579 struct ata_host *host = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006580
Tejun Heob878ca52007-01-20 16:00:28 +09006581 ata_host_detach(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006582}
6583
6584/* move to PCI subsystem */
Jeff Garzik057ace52005-10-22 14:27:05 -04006585int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006586{
6587 unsigned long tmp = 0;
6588
6589 switch (bits->width) {
6590 case 1: {
6591 u8 tmp8 = 0;
6592 pci_read_config_byte(pdev, bits->reg, &tmp8);
6593 tmp = tmp8;
6594 break;
6595 }
6596 case 2: {
6597 u16 tmp16 = 0;
6598 pci_read_config_word(pdev, bits->reg, &tmp16);
6599 tmp = tmp16;
6600 break;
6601 }
6602 case 4: {
6603 u32 tmp32 = 0;
6604 pci_read_config_dword(pdev, bits->reg, &tmp32);
6605 tmp = tmp32;
6606 break;
6607 }
6608
6609 default:
6610 return -EINVAL;
6611 }
6612
6613 tmp &= bits->mask;
6614
6615 return (tmp == bits->val) ? 1 : 0;
6616}
Jens Axboe9b847542006-01-06 09:28:07 +01006617
Tejun Heo6ffa01d2007-03-02 17:32:47 +09006618#ifdef CONFIG_PM
Tejun Heo3c5100c2006-07-26 16:58:33 +09006619void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
Jens Axboe9b847542006-01-06 09:28:07 +01006620{
6621 pci_save_state(pdev);
Tejun Heo4c90d972007-02-20 18:14:48 +09006622 pci_disable_device(pdev);
Tejun Heo500530f2006-07-03 16:07:27 +09006623
Rafael J. Wysocki3a2d5b72008-02-23 19:13:25 +01006624 if (mesg.event & PM_EVENT_SLEEP)
Tejun Heo500530f2006-07-03 16:07:27 +09006625 pci_set_power_state(pdev, PCI_D3hot);
Jens Axboe9b847542006-01-06 09:28:07 +01006626}
6627
Tejun Heo553c4aa2006-12-26 19:39:50 +09006628int ata_pci_device_do_resume(struct pci_dev *pdev)
Jens Axboe9b847542006-01-06 09:28:07 +01006629{
Tejun Heo553c4aa2006-12-26 19:39:50 +09006630 int rc;
6631
Jens Axboe9b847542006-01-06 09:28:07 +01006632 pci_set_power_state(pdev, PCI_D0);
6633 pci_restore_state(pdev);
Tejun Heo553c4aa2006-12-26 19:39:50 +09006634
Tejun Heob878ca52007-01-20 16:00:28 +09006635 rc = pcim_enable_device(pdev);
Tejun Heo553c4aa2006-12-26 19:39:50 +09006636 if (rc) {
Joe Perchesa44fec12011-04-15 15:51:58 -07006637 dev_err(&pdev->dev,
6638 "failed to enable device after resume (%d)\n", rc);
Tejun Heo553c4aa2006-12-26 19:39:50 +09006639 return rc;
6640 }
6641
Jens Axboe9b847542006-01-06 09:28:07 +01006642 pci_set_master(pdev);
Tejun Heo553c4aa2006-12-26 19:39:50 +09006643 return 0;
Tejun Heo500530f2006-07-03 16:07:27 +09006644}
6645
Tejun Heo3c5100c2006-07-26 16:58:33 +09006646int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
Tejun Heo500530f2006-07-03 16:07:27 +09006647{
Brian Norris04a3f5b2012-12-03 10:34:41 -08006648 struct ata_host *host = pci_get_drvdata(pdev);
Tejun Heo500530f2006-07-03 16:07:27 +09006649 int rc = 0;
6650
Jeff Garzikcca39742006-08-24 03:19:22 -04006651 rc = ata_host_suspend(host, mesg);
Tejun Heo500530f2006-07-03 16:07:27 +09006652 if (rc)
6653 return rc;
6654
Tejun Heo3c5100c2006-07-26 16:58:33 +09006655 ata_pci_device_do_suspend(pdev, mesg);
Tejun Heo500530f2006-07-03 16:07:27 +09006656
6657 return 0;
6658}
6659
6660int ata_pci_device_resume(struct pci_dev *pdev)
6661{
Brian Norris04a3f5b2012-12-03 10:34:41 -08006662 struct ata_host *host = pci_get_drvdata(pdev);
Tejun Heo553c4aa2006-12-26 19:39:50 +09006663 int rc;
Tejun Heo500530f2006-07-03 16:07:27 +09006664
Tejun Heo553c4aa2006-12-26 19:39:50 +09006665 rc = ata_pci_device_do_resume(pdev);
6666 if (rc == 0)
6667 ata_host_resume(host);
6668 return rc;
Jens Axboe9b847542006-01-06 09:28:07 +01006669}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09006670#endif /* CONFIG_PM */
6671
Linus Torvalds1da177e2005-04-16 15:20:36 -07006672#endif /* CONFIG_PCI */
6673
Brian Norrisb7db04d2012-11-02 12:29:32 -07006674/**
6675 * ata_platform_remove_one - Platform layer callback for device removal
6676 * @pdev: Platform device that was removed
6677 *
6678 * Platform layer indicates to libata via this hook that hot-unplug or
6679 * module unload event has occurred. Detach all ports. Resource
6680 * release is handled via devres.
6681 *
6682 * LOCKING:
6683 * Inherited from platform layer (may sleep).
6684 */
6685int ata_platform_remove_one(struct platform_device *pdev)
6686{
6687 struct ata_host *host = platform_get_drvdata(pdev);
6688
6689 ata_host_detach(host);
6690
6691 return 0;
6692}
6693
Tejun Heo33267322008-02-13 09:15:09 +09006694static int __init ata_parse_force_one(char **cur,
6695 struct ata_force_ent *force_ent,
6696 const char **reason)
6697{
Rasmus Villemoes0f5f2642015-06-09 15:33:19 +02006698 static const struct ata_force_param force_tbl[] __initconst = {
Tejun Heo33267322008-02-13 09:15:09 +09006699 { "40c", .cbl = ATA_CBL_PATA40 },
6700 { "80c", .cbl = ATA_CBL_PATA80 },
6701 { "short40c", .cbl = ATA_CBL_PATA40_SHORT },
6702 { "unk", .cbl = ATA_CBL_PATA_UNK },
6703 { "ign", .cbl = ATA_CBL_PATA_IGN },
6704 { "sata", .cbl = ATA_CBL_SATA },
6705 { "1.5Gbps", .spd_limit = 1 },
6706 { "3.0Gbps", .spd_limit = 2 },
6707 { "noncq", .horkage_on = ATA_HORKAGE_NONCQ },
6708 { "ncq", .horkage_off = ATA_HORKAGE_NONCQ },
Martin K. Petersend7b16e42015-05-04 21:54:18 -04006709 { "noncqtrim", .horkage_on = ATA_HORKAGE_NO_NCQ_TRIM },
6710 { "ncqtrim", .horkage_off = ATA_HORKAGE_NO_NCQ_TRIM },
Tejun Heo43c9c592010-05-23 12:59:11 +02006711 { "dump_id", .horkage_on = ATA_HORKAGE_DUMP_ID },
Tejun Heo33267322008-02-13 09:15:09 +09006712 { "pio0", .xfer_mask = 1 << (ATA_SHIFT_PIO + 0) },
6713 { "pio1", .xfer_mask = 1 << (ATA_SHIFT_PIO + 1) },
6714 { "pio2", .xfer_mask = 1 << (ATA_SHIFT_PIO + 2) },
6715 { "pio3", .xfer_mask = 1 << (ATA_SHIFT_PIO + 3) },
6716 { "pio4", .xfer_mask = 1 << (ATA_SHIFT_PIO + 4) },
6717 { "pio5", .xfer_mask = 1 << (ATA_SHIFT_PIO + 5) },
6718 { "pio6", .xfer_mask = 1 << (ATA_SHIFT_PIO + 6) },
6719 { "mwdma0", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 0) },
6720 { "mwdma1", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 1) },
6721 { "mwdma2", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 2) },
6722 { "mwdma3", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 3) },
6723 { "mwdma4", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 4) },
6724 { "udma0", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6725 { "udma16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6726 { "udma/16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6727 { "udma1", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6728 { "udma25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6729 { "udma/25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6730 { "udma2", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6731 { "udma33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6732 { "udma/33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6733 { "udma3", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6734 { "udma44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6735 { "udma/44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6736 { "udma4", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6737 { "udma66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6738 { "udma/66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6739 { "udma5", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6740 { "udma100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6741 { "udma/100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6742 { "udma6", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6743 { "udma133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6744 { "udma/133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6745 { "udma7", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 7) },
Tejun Heo05944bd2008-08-13 20:19:09 +09006746 { "nohrst", .lflags = ATA_LFLAG_NO_HRST },
6747 { "nosrst", .lflags = ATA_LFLAG_NO_SRST },
6748 { "norst", .lflags = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST },
Dan Williamsca6d43b2012-06-21 23:41:41 -07006749 { "rstonce", .lflags = ATA_LFLAG_RST_ONCE },
Vincent Pelletier966fbe12013-05-21 22:30:58 +02006750 { "atapi_dmadir", .horkage_on = ATA_HORKAGE_ATAPI_DMADIR },
Robin H. Johnsonb8bd6dc2013-12-16 09:31:19 -08006751 { "disable", .horkage_on = ATA_HORKAGE_DISABLE },
Tejun Heo33267322008-02-13 09:15:09 +09006752 };
6753 char *start = *cur, *p = *cur;
6754 char *id, *val, *endp;
6755 const struct ata_force_param *match_fp = NULL;
6756 int nr_matches = 0, i;
6757
6758 /* find where this param ends and update *cur */
6759 while (*p != '\0' && *p != ',')
6760 p++;
6761
6762 if (*p == '\0')
6763 *cur = p;
6764 else
6765 *cur = p + 1;
6766
6767 *p = '\0';
6768
6769 /* parse */
6770 p = strchr(start, ':');
6771 if (!p) {
6772 val = strstrip(start);
6773 goto parse_val;
6774 }
6775 *p = '\0';
6776
6777 id = strstrip(start);
6778 val = strstrip(p + 1);
6779
6780 /* parse id */
6781 p = strchr(id, '.');
6782 if (p) {
6783 *p++ = '\0';
6784 force_ent->device = simple_strtoul(p, &endp, 10);
6785 if (p == endp || *endp != '\0') {
6786 *reason = "invalid device";
6787 return -EINVAL;
6788 }
6789 }
6790
6791 force_ent->port = simple_strtoul(id, &endp, 10);
6792 if (p == endp || *endp != '\0') {
6793 *reason = "invalid port/link";
6794 return -EINVAL;
6795 }
6796
6797 parse_val:
6798 /* parse val, allow shortcuts so that both 1.5 and 1.5Gbps work */
6799 for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
6800 const struct ata_force_param *fp = &force_tbl[i];
6801
6802 if (strncasecmp(val, fp->name, strlen(val)))
6803 continue;
6804
6805 nr_matches++;
6806 match_fp = fp;
6807
6808 if (strcasecmp(val, fp->name) == 0) {
6809 nr_matches = 1;
6810 break;
6811 }
6812 }
6813
6814 if (!nr_matches) {
6815 *reason = "unknown value";
6816 return -EINVAL;
6817 }
6818 if (nr_matches > 1) {
6819 *reason = "ambigious value";
6820 return -EINVAL;
6821 }
6822
6823 force_ent->param = *match_fp;
6824
6825 return 0;
6826}
6827
6828static void __init ata_parse_force_param(void)
6829{
6830 int idx = 0, size = 1;
6831 int last_port = -1, last_device = -1;
6832 char *p, *cur, *next;
6833
6834 /* calculate maximum number of params and allocate force_tbl */
6835 for (p = ata_force_param_buf; *p; p++)
6836 if (*p == ',')
6837 size++;
6838
6839 ata_force_tbl = kzalloc(sizeof(ata_force_tbl[0]) * size, GFP_KERNEL);
6840 if (!ata_force_tbl) {
6841 printk(KERN_WARNING "ata: failed to extend force table, "
6842 "libata.force ignored\n");
6843 return;
6844 }
6845
6846 /* parse and populate the table */
6847 for (cur = ata_force_param_buf; *cur != '\0'; cur = next) {
6848 const char *reason = "";
6849 struct ata_force_ent te = { .port = -1, .device = -1 };
6850
6851 next = cur;
6852 if (ata_parse_force_one(&next, &te, &reason)) {
6853 printk(KERN_WARNING "ata: failed to parse force "
6854 "parameter \"%s\" (%s)\n",
6855 cur, reason);
6856 continue;
6857 }
6858
6859 if (te.port == -1) {
6860 te.port = last_port;
6861 te.device = last_device;
6862 }
6863
6864 ata_force_tbl[idx++] = te;
6865
6866 last_port = te.port;
6867 last_device = te.device;
6868 }
6869
6870 ata_force_tbl_size = idx;
6871}
Linus Torvalds1da177e2005-04-16 15:20:36 -07006872
Linus Torvalds1da177e2005-04-16 15:20:36 -07006873static int __init ata_init(void)
6874{
Gwendal Grignoud9027472010-05-25 12:31:38 -07006875 int rc;
Tejun Heo270390e2010-05-10 21:41:35 +02006876
Tejun Heo33267322008-02-13 09:15:09 +09006877 ata_parse_force_param();
6878
Tejun Heo270390e2010-05-10 21:41:35 +02006879 rc = ata_sff_init();
Tejun Heoad72cf92010-07-02 10:03:52 +02006880 if (rc) {
6881 kfree(ata_force_tbl);
6882 return rc;
6883 }
Tejun Heo453b07a2006-05-31 18:27:42 +09006884
Gwendal Grignoud9027472010-05-25 12:31:38 -07006885 libata_transport_init();
6886 ata_scsi_transport_template = ata_attach_transport();
6887 if (!ata_scsi_transport_template) {
6888 ata_sff_exit();
6889 rc = -ENOMEM;
6890 goto err_out;
Jeff Garzik4fca3772011-02-15 01:13:24 -05006891 }
Gwendal Grignoud9027472010-05-25 12:31:38 -07006892
Linus Torvalds1da177e2005-04-16 15:20:36 -07006893 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6894 return 0;
Gwendal Grignoud9027472010-05-25 12:31:38 -07006895
6896err_out:
6897 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006898}
6899
6900static void __exit ata_exit(void)
6901{
Gwendal Grignoud9027472010-05-25 12:31:38 -07006902 ata_release_transport(ata_scsi_transport_template);
6903 libata_transport_exit();
Tejun Heo270390e2010-05-10 21:41:35 +02006904 ata_sff_exit();
Tejun Heo33267322008-02-13 09:15:09 +09006905 kfree(ata_force_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006906}
6907
Brian Kinga4625082006-11-13 16:32:36 -06006908subsys_initcall(ata_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006909module_exit(ata_exit);
6910
Akinobu Mita9990b6f2010-04-12 21:11:41 +09006911static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
Jeff Garzik67846b32005-10-05 02:58:32 -04006912
6913int ata_ratelimit(void)
6914{
Akinobu Mita9990b6f2010-04-12 21:11:41 +09006915 return __ratelimit(&ratelimit);
Jeff Garzik67846b32005-10-05 02:58:32 -04006916}
6917
Tejun Heoc0c362b2010-09-06 17:57:14 +02006918/**
6919 * ata_msleep - ATA EH owner aware msleep
6920 * @ap: ATA port to attribute the sleep to
6921 * @msecs: duration to sleep in milliseconds
6922 *
6923 * Sleeps @msecs. If the current task is owner of @ap's EH, the
6924 * ownership is released before going to sleep and reacquired
6925 * after the sleep is complete. IOW, other ports sharing the
6926 * @ap->host will be allowed to own the EH while this task is
6927 * sleeping.
6928 *
6929 * LOCKING:
6930 * Might sleep.
6931 */
Tejun Heo97750ce2010-09-06 17:56:29 +02006932void ata_msleep(struct ata_port *ap, unsigned int msecs)
6933{
Tejun Heoc0c362b2010-09-06 17:57:14 +02006934 bool owns_eh = ap && ap->host->eh_owner == current;
6935
6936 if (owns_eh)
6937 ata_eh_release(ap);
6938
Anil Veliyankara Madam848c3922016-01-07 21:18:52 -08006939 if (msecs < 20) {
6940 unsigned long usecs = msecs * USEC_PER_MSEC;
6941 usleep_range(usecs, usecs + 50);
6942 } else {
6943 msleep(msecs);
6944 }
Tejun Heoc0c362b2010-09-06 17:57:14 +02006945
6946 if (owns_eh)
6947 ata_eh_acquire(ap);
Tejun Heo97750ce2010-09-06 17:56:29 +02006948}
6949
Tejun Heoc22daff2006-04-11 22:22:29 +09006950/**
6951 * ata_wait_register - wait until register value changes
Tejun Heo97750ce2010-09-06 17:56:29 +02006952 * @ap: ATA port to wait register for, can be NULL
Tejun Heoc22daff2006-04-11 22:22:29 +09006953 * @reg: IO-mapped register
6954 * @mask: Mask to apply to read register value
6955 * @val: Wait condition
Tejun Heo341c2c92008-05-20 02:17:51 +09006956 * @interval: polling interval in milliseconds
6957 * @timeout: timeout in milliseconds
Tejun Heoc22daff2006-04-11 22:22:29 +09006958 *
6959 * Waiting for some bits of register to change is a common
6960 * operation for ATA controllers. This function reads 32bit LE
6961 * IO-mapped register @reg and tests for the following condition.
6962 *
6963 * (*@reg & mask) != val
6964 *
6965 * If the condition is met, it returns; otherwise, the process is
6966 * repeated after @interval_msec until timeout.
6967 *
6968 * LOCKING:
6969 * Kernel thread context (may sleep)
6970 *
6971 * RETURNS:
6972 * The final register value.
6973 */
Tejun Heo97750ce2010-09-06 17:56:29 +02006974u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
Tejun Heo341c2c92008-05-20 02:17:51 +09006975 unsigned long interval, unsigned long timeout)
Tejun Heoc22daff2006-04-11 22:22:29 +09006976{
Tejun Heo341c2c92008-05-20 02:17:51 +09006977 unsigned long deadline;
Tejun Heoc22daff2006-04-11 22:22:29 +09006978 u32 tmp;
6979
6980 tmp = ioread32(reg);
6981
6982 /* Calculate timeout _after_ the first read to make sure
6983 * preceding writes reach the controller before starting to
6984 * eat away the timeout.
6985 */
Tejun Heo341c2c92008-05-20 02:17:51 +09006986 deadline = ata_deadline(jiffies, timeout);
Tejun Heoc22daff2006-04-11 22:22:29 +09006987
Tejun Heo341c2c92008-05-20 02:17:51 +09006988 while ((tmp & mask) == val && time_before(jiffies, deadline)) {
Tejun Heo97750ce2010-09-06 17:56:29 +02006989 ata_msleep(ap, interval);
Tejun Heoc22daff2006-04-11 22:22:29 +09006990 tmp = ioread32(reg);
6991 }
6992
6993 return tmp;
6994}
6995
Gabriele Mazzotta8393b812015-04-25 19:52:36 +02006996/**
6997 * sata_lpm_ignore_phy_events - test if PHY event should be ignored
6998 * @link: Link receiving the event
6999 *
7000 * Test whether the received PHY event has to be ignored or not.
7001 *
7002 * LOCKING:
7003 * None:
7004 *
7005 * RETURNS:
7006 * True if the event has to be ignored.
7007 */
7008bool sata_lpm_ignore_phy_events(struct ata_link *link)
7009{
Gabriele Mazzotta09c5b482015-04-25 19:52:37 +02007010 unsigned long lpm_timeout = link->last_lpm_change +
7011 msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY);
7012
Gabriele Mazzotta8393b812015-04-25 19:52:36 +02007013 /* if LPM is enabled, PHYRDY doesn't mean anything */
Gabriele Mazzotta09c5b482015-04-25 19:52:37 +02007014 if (link->lpm_policy > ATA_LPM_MAX_POWER)
7015 return true;
7016
7017 /* ignore the first PHY event after the LPM policy changed
7018 * as it is might be spurious
7019 */
7020 if ((link->flags & ATA_LFLAG_CHANGED) &&
7021 time_before(jiffies, lpm_timeout))
7022 return true;
7023
7024 return false;
Gabriele Mazzotta8393b812015-04-25 19:52:36 +02007025}
7026EXPORT_SYMBOL_GPL(sata_lpm_ignore_phy_events);
7027
Linus Torvalds1da177e2005-04-16 15:20:36 -07007028/*
Tejun Heodd5b06c2006-08-10 16:59:12 +09007029 * Dummy port_ops
7030 */
Tejun Heodd5b06c2006-08-10 16:59:12 +09007031static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
7032{
7033 return AC_ERR_SYSTEM;
7034}
7035
Tejun Heo182d7bb2008-04-07 22:47:21 +09007036static void ata_dummy_error_handler(struct ata_port *ap)
7037{
7038 /* truly dummy */
7039}
7040
Tejun Heo029cfd62008-03-25 12:22:49 +09007041struct ata_port_operations ata_dummy_port_ops = {
Tejun Heodd5b06c2006-08-10 16:59:12 +09007042 .qc_prep = ata_noop_qc_prep,
7043 .qc_issue = ata_dummy_qc_issue,
Tejun Heo182d7bb2008-04-07 22:47:21 +09007044 .error_handler = ata_dummy_error_handler,
Dan Williamse4a9c372012-06-21 23:25:27 -07007045 .sched_eh = ata_std_sched_eh,
7046 .end_eh = ata_std_end_eh,
Tejun Heodd5b06c2006-08-10 16:59:12 +09007047};
7048
Tejun Heo21b0ad42007-04-17 23:44:07 +09007049const struct ata_port_info ata_dummy_port_info = {
7050 .port_ops = &ata_dummy_port_ops,
7051};
7052
Tejun Heodd5b06c2006-08-10 16:59:12 +09007053/*
Joe Perchesa9a79df2011-04-15 15:51:59 -07007054 * Utility print functions
7055 */
Joe Perchesd7bead12014-09-22 09:52:18 -07007056void ata_port_printk(const struct ata_port *ap, const char *level,
7057 const char *fmt, ...)
Joe Perchesa9a79df2011-04-15 15:51:59 -07007058{
7059 struct va_format vaf;
7060 va_list args;
Joe Perchesa9a79df2011-04-15 15:51:59 -07007061
7062 va_start(args, fmt);
7063
7064 vaf.fmt = fmt;
7065 vaf.va = &args;
7066
Joe Perchesd7bead12014-09-22 09:52:18 -07007067 printk("%sata%u: %pV", level, ap->print_id, &vaf);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007068
7069 va_end(args);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007070}
7071EXPORT_SYMBOL(ata_port_printk);
7072
Joe Perchesd7bead12014-09-22 09:52:18 -07007073void ata_link_printk(const struct ata_link *link, const char *level,
7074 const char *fmt, ...)
Joe Perchesa9a79df2011-04-15 15:51:59 -07007075{
7076 struct va_format vaf;
7077 va_list args;
Joe Perchesa9a79df2011-04-15 15:51:59 -07007078
7079 va_start(args, fmt);
7080
7081 vaf.fmt = fmt;
7082 vaf.va = &args;
7083
7084 if (sata_pmp_attached(link->ap) || link->ap->slave_link)
Joe Perchesd7bead12014-09-22 09:52:18 -07007085 printk("%sata%u.%02u: %pV",
7086 level, link->ap->print_id, link->pmp, &vaf);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007087 else
Joe Perchesd7bead12014-09-22 09:52:18 -07007088 printk("%sata%u: %pV",
7089 level, link->ap->print_id, &vaf);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007090
7091 va_end(args);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007092}
7093EXPORT_SYMBOL(ata_link_printk);
7094
Joe Perchesd7bead12014-09-22 09:52:18 -07007095void ata_dev_printk(const struct ata_device *dev, const char *level,
Joe Perchesa9a79df2011-04-15 15:51:59 -07007096 const char *fmt, ...)
7097{
7098 struct va_format vaf;
7099 va_list args;
Joe Perchesa9a79df2011-04-15 15:51:59 -07007100
7101 va_start(args, fmt);
7102
7103 vaf.fmt = fmt;
7104 vaf.va = &args;
7105
Joe Perchesd7bead12014-09-22 09:52:18 -07007106 printk("%sata%u.%02u: %pV",
7107 level, dev->link->ap->print_id, dev->link->pmp + dev->devno,
7108 &vaf);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007109
7110 va_end(args);
Joe Perchesa9a79df2011-04-15 15:51:59 -07007111}
7112EXPORT_SYMBOL(ata_dev_printk);
7113
Joe Perches06296a12011-04-15 15:52:00 -07007114void ata_print_version(const struct device *dev, const char *version)
7115{
7116 dev_printk(KERN_DEBUG, dev, "version %s\n", version);
7117}
7118EXPORT_SYMBOL(ata_print_version);
7119
Joe Perchesa9a79df2011-04-15 15:51:59 -07007120/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07007121 * libata is essentially a library of internal helper functions for
7122 * low-level ATA host controller drivers. As such, the API/ABI is
7123 * likely to change as new drivers are added and updated.
7124 * Do not depend on ABI/API stability.
7125 */
Tejun Heoe9c83912006-07-03 16:07:26 +09007126EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
7127EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
7128EXPORT_SYMBOL_GPL(sata_deb_timing_long);
Tejun Heo029cfd62008-03-25 12:22:49 +09007129EXPORT_SYMBOL_GPL(ata_base_port_ops);
7130EXPORT_SYMBOL_GPL(sata_port_ops);
Tejun Heodd5b06c2006-08-10 16:59:12 +09007131EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
Tejun Heo21b0ad42007-04-17 23:44:07 +09007132EXPORT_SYMBOL_GPL(ata_dummy_port_info);
Tejun Heo1eca4362008-11-03 20:03:17 +09007133EXPORT_SYMBOL_GPL(ata_link_next);
7134EXPORT_SYMBOL_GPL(ata_dev_next);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007135EXPORT_SYMBOL_GPL(ata_std_bios_param);
Tejun Heod8d91292010-05-15 20:09:34 +02007136EXPORT_SYMBOL_GPL(ata_scsi_unlock_native_capacity);
Jeff Garzikcca39742006-08-24 03:19:22 -04007137EXPORT_SYMBOL_GPL(ata_host_init);
Tejun Heof3187192007-04-17 23:44:07 +09007138EXPORT_SYMBOL_GPL(ata_host_alloc);
Tejun Heof5cda252007-04-17 23:44:07 +09007139EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
Tejun Heob1c72912008-07-31 17:02:43 +09007140EXPORT_SYMBOL_GPL(ata_slave_link_init);
Tejun Heoecef7252007-04-17 23:44:06 +09007141EXPORT_SYMBOL_GPL(ata_host_start);
Tejun Heof3187192007-04-17 23:44:07 +09007142EXPORT_SYMBOL_GPL(ata_host_register);
Tejun Heof5cda252007-04-17 23:44:07 +09007143EXPORT_SYMBOL_GPL(ata_host_activate);
Tejun Heo0529c1592007-01-20 16:00:26 +09007144EXPORT_SYMBOL_GPL(ata_host_detach);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007145EXPORT_SYMBOL_GPL(ata_sg_init);
Tejun Heof686bcb2006-05-15 20:58:05 +09007146EXPORT_SYMBOL_GPL(ata_qc_complete);
Tejun Heodedaf2b2006-05-15 21:03:43 +09007147EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
Tejun Heo436d34b2008-04-02 17:28:46 +09007148EXPORT_SYMBOL_GPL(atapi_cmd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007149EXPORT_SYMBOL_GPL(ata_tf_to_fis);
7150EXPORT_SYMBOL_GPL(ata_tf_from_fis);
Tejun Heo63573572007-11-27 19:43:39 +09007151EXPORT_SYMBOL_GPL(ata_pack_xfermask);
7152EXPORT_SYMBOL_GPL(ata_unpack_xfermask);
7153EXPORT_SYMBOL_GPL(ata_xfer_mask2mode);
7154EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);
7155EXPORT_SYMBOL_GPL(ata_xfer_mode2shift);
7156EXPORT_SYMBOL_GPL(ata_mode_string);
7157EXPORT_SYMBOL_GPL(ata_id_xfermask);
Alan04351822007-03-06 02:37:52 -08007158EXPORT_SYMBOL_GPL(ata_do_set_mode);
Tejun Heo31cc23b2007-09-23 13:14:12 +09007159EXPORT_SYMBOL_GPL(ata_std_qc_defer);
Brian Kinge46834c2006-03-17 17:04:03 -06007160EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
Alan10305f02007-02-20 18:01:59 +00007161EXPORT_SYMBOL_GPL(ata_dev_disable);
Tejun Heo3c567b72006-05-15 20:57:23 +09007162EXPORT_SYMBOL_GPL(sata_set_spd);
Tejun Heoaa2731a2008-04-07 22:47:19 +09007163EXPORT_SYMBOL_GPL(ata_wait_after_reset);
Tejun Heo936fd732007-08-06 18:36:23 +09007164EXPORT_SYMBOL_GPL(sata_link_debounce);
7165EXPORT_SYMBOL_GPL(sata_link_resume);
Tejun Heo1152b262010-09-01 17:50:05 +02007166EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
Tejun Heo0aa11132008-04-07 22:47:18 +09007167EXPORT_SYMBOL_GPL(ata_std_prereset);
Tejun Heocc0680a2007-08-06 18:36:23 +09007168EXPORT_SYMBOL_GPL(sata_link_hardreset);
Tejun Heo57c9efd2008-04-07 22:47:19 +09007169EXPORT_SYMBOL_GPL(sata_std_hardreset);
Tejun Heo203c75b2008-04-07 22:47:18 +09007170EXPORT_SYMBOL_GPL(ata_std_postreset);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05007171EXPORT_SYMBOL_GPL(ata_dev_classify);
7172EXPORT_SYMBOL_GPL(ata_dev_pair);
Jeff Garzik67846b32005-10-05 02:58:32 -04007173EXPORT_SYMBOL_GPL(ata_ratelimit);
Tejun Heo97750ce2010-09-06 17:56:29 +02007174EXPORT_SYMBOL_GPL(ata_msleep);
Tejun Heoc22daff2006-04-11 22:22:29 +09007175EXPORT_SYMBOL_GPL(ata_wait_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007176EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007177EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
Tejun Heo83c47bc2006-05-31 18:28:07 +09007178EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
Tejun Heoa6e6ce82006-05-15 21:03:48 +09007179EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
Dan Williamsf6e67032011-09-20 15:10:33 -07007180EXPORT_SYMBOL_GPL(__ata_change_queue_depth);
Tejun Heo34bf2172006-05-15 20:57:46 +09007181EXPORT_SYMBOL_GPL(sata_scr_valid);
7182EXPORT_SYMBOL_GPL(sata_scr_read);
7183EXPORT_SYMBOL_GPL(sata_scr_write);
7184EXPORT_SYMBOL_GPL(sata_scr_write_flush);
Tejun Heo936fd732007-08-06 18:36:23 +09007185EXPORT_SYMBOL_GPL(ata_link_online);
7186EXPORT_SYMBOL_GPL(ata_link_offline);
Tejun Heo6ffa01d2007-03-02 17:32:47 +09007187#ifdef CONFIG_PM
Jeff Garzikcca39742006-08-24 03:19:22 -04007188EXPORT_SYMBOL_GPL(ata_host_suspend);
7189EXPORT_SYMBOL_GPL(ata_host_resume);
Tejun Heo6ffa01d2007-03-02 17:32:47 +09007190#endif /* CONFIG_PM */
Tejun Heo6a62a042006-02-13 10:02:46 +09007191EXPORT_SYMBOL_GPL(ata_id_string);
7192EXPORT_SYMBOL_GPL(ata_id_c_string);
Alan Cox963e4972008-07-24 17:16:06 +01007193EXPORT_SYMBOL_GPL(ata_do_dev_read_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007194EXPORT_SYMBOL_GPL(ata_scsi_simulate);
7195
Alan Cox1bc4ccf2006-01-09 17:18:14 +00007196EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
Tejun Heo63573572007-11-27 19:43:39 +09007197EXPORT_SYMBOL_GPL(ata_timing_find_mode);
Alan Cox452503f2005-10-21 19:01:32 -04007198EXPORT_SYMBOL_GPL(ata_timing_compute);
7199EXPORT_SYMBOL_GPL(ata_timing_merge);
Tejun Heoa0f79b92007-12-18 16:33:05 +09007200EXPORT_SYMBOL_GPL(ata_timing_cycle2mode);
Alan Cox452503f2005-10-21 19:01:32 -04007201
Linus Torvalds1da177e2005-04-16 15:20:36 -07007202#ifdef CONFIG_PCI
7203EXPORT_SYMBOL_GPL(pci_test_config_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007204EXPORT_SYMBOL_GPL(ata_pci_remove_one);
Tejun Heo6ffa01d2007-03-02 17:32:47 +09007205#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +09007206EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
7207EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
Jens Axboe9b847542006-01-06 09:28:07 +01007208EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
7209EXPORT_SYMBOL_GPL(ata_pci_device_resume);
Tejun Heo6ffa01d2007-03-02 17:32:47 +09007210#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007211#endif /* CONFIG_PCI */
Jens Axboe9b847542006-01-06 09:28:07 +01007212
Brian Norrisb7db04d2012-11-02 12:29:32 -07007213EXPORT_SYMBOL_GPL(ata_platform_remove_one);
7214
Tejun Heob64bbc32007-07-16 14:29:39 +09007215EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
7216EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
7217EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
Tejun Heocbcdd872007-08-18 13:14:55 +09007218EXPORT_SYMBOL_GPL(ata_port_desc);
7219#ifdef CONFIG_PCI
7220EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
7221#endif /* CONFIG_PCI */
Tejun Heo7b70fc02006-05-15 20:58:07 +09007222EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
Tejun Heodbd82612007-08-06 18:36:23 +09007223EXPORT_SYMBOL_GPL(ata_link_abort);
Tejun Heo7b70fc02006-05-15 20:58:07 +09007224EXPORT_SYMBOL_GPL(ata_port_abort);
Tejun Heoe3180492006-05-15 20:58:09 +09007225EXPORT_SYMBOL_GPL(ata_port_freeze);
Tejun Heo7d77b242007-09-23 13:14:13 +09007226EXPORT_SYMBOL_GPL(sata_async_notification);
Tejun Heoe3180492006-05-15 20:58:09 +09007227EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
7228EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
Tejun Heoece1d632006-04-02 18:51:53 +09007229EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
7230EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
Mark Lord10acf3b2008-05-02 02:14:53 -04007231EXPORT_SYMBOL_GPL(ata_eh_analyze_ncq_error);
Tejun Heo022bdb02006-05-15 20:58:22 +09007232EXPORT_SYMBOL_GPL(ata_do_eh);
Tejun Heoa1efdab2008-03-25 12:22:50 +09007233EXPORT_SYMBOL_GPL(ata_std_error_handler);
Alan Coxbe0d18d2007-03-06 02:37:56 -08007234
7235EXPORT_SYMBOL_GPL(ata_cable_40wire);
7236EXPORT_SYMBOL_GPL(ata_cable_80wire);
7237EXPORT_SYMBOL_GPL(ata_cable_unknown);
Tejun Heoc88f90c2007-11-27 19:43:48 +09007238EXPORT_SYMBOL_GPL(ata_cable_ignore);
Alan Coxbe0d18d2007-03-06 02:37:56 -08007239EXPORT_SYMBOL_GPL(ata_cable_sata);