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