libata-core.c source code [Linux/drivers/ata/libata-core.c]

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

Browse the source code of Linux/drivers/ata/libata-core.c