libata.h 63.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2005 Jeff Garzik
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
L
Linus Torvalds 已提交
24 25 26 27 28 29
 */

#ifndef __LINUX_LIBATA_H__
#define __LINUX_LIBATA_H__

#include <linux/delay.h>
30
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
31
#include <linux/interrupt.h>
32
#include <linux/dma-mapping.h>
J
Jens Axboe 已提交
33
#include <linux/scatterlist.h>
34
#include <linux/io.h>
L
Linus Torvalds 已提交
35 36
#include <linux/ata.h>
#include <linux/workqueue.h>
37
#include <scsi/scsi_host.h>
38
#include <linux/acpi.h>
39
#include <linux/cdrom.h>
40
#include <linux/sched.h>
L
Linus Torvalds 已提交
41

42 43 44 45 46
/*
 * Define if arch has non-standard setup.  This is a _PCI_ standard
 * not a legacy or ISA standard.
 */
#ifdef CONFIG_ATA_NONSTANDARD
47
#include <asm/libata-portmap.h>
48 49 50
#else
#include <asm-generic/libata-portmap.h>
#endif
51

L
Linus Torvalds 已提交
52
/*
53 54
 * compile-time options: to be removed as soon as all the drivers are
 * converted to the new debugging mechanism
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63
 */
#undef ATA_DEBUG		/* debugging output */
#undef ATA_VERBOSE_DEBUG	/* yet more debugging output */
#undef ATA_IRQ_TRAP		/* define to ack screaming irqs */
#undef ATA_NDEBUG		/* define to disable quick runtime checks */


/* note: prints function name for you */
#ifdef ATA_DEBUG
64
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
L
Linus Torvalds 已提交
65
#ifdef ATA_VERBOSE_DEBUG
66
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
L
Linus Torvalds 已提交
67 68 69 70 71 72 73 74
#else
#define VPRINTK(fmt, args...)
#endif	/* ATA_VERBOSE_DEBUG */
#else
#define DPRINTK(fmt, args...)
#define VPRINTK(fmt, args...)
#endif	/* ATA_DEBUG */

75
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
J
Jeff Garzik 已提交
76

77 78 79 80 81 82 83 84 85 86
#define ata_print_version_once(dev, version)			\
({								\
	static bool __print_once;				\
								\
	if (!__print_once) {					\
		__print_once = true;				\
		ata_print_version(dev, version);		\
	}							\
})

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
/* NEW: debug levels */
#define HAVE_LIBATA_MSG 1

enum {
	ATA_MSG_DRV	= 0x0001,
	ATA_MSG_INFO	= 0x0002,
	ATA_MSG_PROBE	= 0x0004,
	ATA_MSG_WARN	= 0x0008,
	ATA_MSG_MALLOC	= 0x0010,
	ATA_MSG_CTL	= 0x0020,
	ATA_MSG_INTR	= 0x0040,
	ATA_MSG_ERR	= 0x0080,
};

#define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)
#define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)
#define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)
#define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)
#define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
#define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)
#define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)
#define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)

static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
{
	if (dval < 0 || dval >= (sizeof(u32) * 8))
		return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
	if (!dval)
		return 0;
	return (1 << dval) - 1;
}

L
Linus Torvalds 已提交
119 120 121 122 123 124
/* defines only for the constants which don't work well as enums */
#define ATA_TAG_POISON		0xfafbfcfdU

enum {
	/* various global constants */
	LIBATA_MAX_PRD		= ATA_MAX_PRD / 2,
125
	LIBATA_DUMB_MAX_PRD	= ATA_MAX_PRD / 4,	/* Worst case */
L
Linus Torvalds 已提交
126
	ATA_DEF_QUEUE		= 1,
127
	/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
128
	ATA_MAX_QUEUE		= 32,
129
	ATA_TAG_INTERNAL	= ATA_MAX_QUEUE - 1,
130
	ATA_SHORT_PAUSE		= 16,
L
Linus Torvalds 已提交
131

T
Tejun Heo 已提交
132 133
	ATAPI_MAX_DRAIN		= 16 << 10,

134 135
	ATA_ALL_DEVICES		= (1 << ATA_MAX_DEVICES) - 1,

L
Linus Torvalds 已提交
136 137
	ATA_SHT_EMULATED	= 1,
	ATA_SHT_THIS_ID		= -1,
138
	ATA_SHT_USE_CLUSTERING	= 1,
L
Linus Torvalds 已提交
139

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
	/* struct ata_taskfile flags */
	ATA_TFLAG_LBA48		= (1 << 0), /* enable 48-bit LBA and "HOB" */
	ATA_TFLAG_ISADDR	= (1 << 1), /* enable r/w to nsect/lba regs */
	ATA_TFLAG_DEVICE	= (1 << 2), /* enable r/w to device reg */
	ATA_TFLAG_WRITE		= (1 << 3), /* data dir: host->dev==1 (write) */
	ATA_TFLAG_LBA		= (1 << 4), /* enable LBA */
	ATA_TFLAG_FUA		= (1 << 5), /* enable FUA */
	ATA_TFLAG_POLLING	= (1 << 6), /* set nIEN to 1 and use polling */

	/* protocol flags */
	ATA_PROT_FLAG_PIO	= (1 << 0), /* is PIO */
	ATA_PROT_FLAG_DMA	= (1 << 1), /* is DMA */
	ATA_PROT_FLAG_DATA	= ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA,
	ATA_PROT_FLAG_NCQ	= (1 << 2), /* is NCQ */
	ATA_PROT_FLAG_ATAPI	= (1 << 3), /* is ATAPI */

L
Linus Torvalds 已提交
156
	/* struct ata_device stuff */
T
Tejun Heo 已提交
157 158
	ATA_DFLAG_LBA		= (1 << 0), /* device supports LBA */
	ATA_DFLAG_LBA48		= (1 << 1), /* device supports LBA48 */
J
Jeff Garzik 已提交
159
	ATA_DFLAG_CDB_INTR	= (1 << 2), /* device asserts INTRQ when ready for CDB */
160
	ATA_DFLAG_NCQ		= (1 << 3), /* device supports NCQ */
161
	ATA_DFLAG_FLUSH_EXT	= (1 << 4), /* do FLUSH_EXT instead of FLUSH */
T
Tejun Heo 已提交
162 163
	ATA_DFLAG_ACPI_PENDING	= (1 << 5), /* ACPI resume action pending */
	ATA_DFLAG_ACPI_FAILED	= (1 << 6), /* ACPI on devcfg has failed */
164
	ATA_DFLAG_AN		= (1 << 7), /* AN configured */
165
	ATA_DFLAG_DMADIR	= (1 << 10), /* device requires DMADIR */
166
	ATA_DFLAG_CFG_MASK	= (1 << 12) - 1,
T
Tejun Heo 已提交
167

168 169
	ATA_DFLAG_PIO		= (1 << 12), /* device limited to PIO mode */
	ATA_DFLAG_NCQ_OFF	= (1 << 13), /* device limited to non-NCQ mode */
170
	ATA_DFLAG_SLEEPING	= (1 << 15), /* device is sleeping */
171
	ATA_DFLAG_DUBIOUS_XFER	= (1 << 16), /* data transfer not verified */
172
	ATA_DFLAG_NO_UNLOAD	= (1 << 17), /* device doesn't support unload */
T
Tejun Heo 已提交
173
	ATA_DFLAG_UNLOCK_HPA	= (1 << 18), /* unlock HPA */
174
	ATA_DFLAG_NCQ_SEND_RECV = (1 << 19), /* device supports NCQ SEND and RECV */
T
Tejun Heo 已提交
175
	ATA_DFLAG_INIT_MASK	= (1 << 24) - 1,
L
Linus Torvalds 已提交
176

T
Tejun Heo 已提交
177 178
	ATA_DFLAG_DETACH	= (1 << 24),
	ATA_DFLAG_DETACHED	= (1 << 25),
179

180
	ATA_DFLAG_DA		= (1 << 26), /* device supports Device Attention */
181
	ATA_DFLAG_DEVSLP	= (1 << 27), /* device supports Device Sleep */
182
	ATA_DFLAG_ACPI_DISABLED = (1 << 28), /* ACPI for the device is disabled */
183

L
Linus Torvalds 已提交
184 185 186 187 188
	ATA_DEV_UNKNOWN		= 0,	/* unknown device */
	ATA_DEV_ATA		= 1,	/* ATA device */
	ATA_DEV_ATA_UNSUP	= 2,	/* ATA device (unsupported) */
	ATA_DEV_ATAPI		= 3,	/* ATAPI device */
	ATA_DEV_ATAPI_UNSUP	= 4,	/* ATAPI device (unsupported) */
189 190 191 192
	ATA_DEV_PMP		= 5,	/* SATA port multiplier */
	ATA_DEV_PMP_UNSUP	= 6,	/* SATA port multiplier (unsupported) */
	ATA_DEV_SEMB		= 7,	/* SEMB */
	ATA_DEV_SEMB_UNSUP	= 8,	/* SEMB (unsupported) */
H
Hannes Reinecke 已提交
193 194
	ATA_DEV_ZAC		= 9,	/* ZAC device */
	ATA_DEV_NONE		= 10,	/* no device */
L
Linus Torvalds 已提交
195

196
	/* struct ata_link flags */
197
	ATA_LFLAG_NO_HRST	= (1 << 1), /* avoid hardreset */
198 199 200 201
	ATA_LFLAG_NO_SRST	= (1 << 2), /* avoid softreset */
	ATA_LFLAG_ASSUME_ATA	= (1 << 3), /* assume ATA class */
	ATA_LFLAG_ASSUME_SEMB	= (1 << 4), /* assume SEMB class */
	ATA_LFLAG_ASSUME_CLASS	= ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
202
	ATA_LFLAG_NO_RETRY	= (1 << 5), /* don't retry this link */
203
	ATA_LFLAG_DISABLED	= (1 << 6), /* link is disabled */
204
	ATA_LFLAG_SW_ACTIVITY	= (1 << 7), /* keep activity stats */
205
	ATA_LFLAG_NO_LPM	= (1 << 8), /* disable LPM on this link */
D
Dan Williams 已提交
206
	ATA_LFLAG_RST_ONCE	= (1 << 9), /* limit recovery to one reset */
207
	ATA_LFLAG_CHANGED	= (1 << 10), /* LPM state changed on this link */
208
	ATA_LFLAG_NO_DB_DELAY	= (1 << 11), /* no debounce delay on link resume */
209

L
Linus Torvalds 已提交
210
	/* struct ata_port flags */
T
Tejun Heo 已提交
211
	ATA_FLAG_SLAVE_POSS	= (1 << 0), /* host supports slave dev */
L
Linus Torvalds 已提交
212
					    /* (doesn't imply presence) */
T
Tejun Heo 已提交
213
	ATA_FLAG_SATA		= (1 << 1),
214
	ATA_FLAG_NO_LOG_PAGE	= (1 << 5), /* do not issue log page read */
T
Tejun Heo 已提交
215 216 217
	ATA_FLAG_NO_ATAPI	= (1 << 6), /* No ATAPI support */
	ATA_FLAG_PIO_DMA	= (1 << 7), /* PIO cmds via DMA */
	ATA_FLAG_PIO_LBA48	= (1 << 8), /* Host DMA engine is LBA28 only */
218 219 220
	ATA_FLAG_PIO_POLLING	= (1 << 9), /* use polling PIO if LLD
					     * doesn't handle PIO interrupts */
	ATA_FLAG_NCQ		= (1 << 10), /* host supports NCQ */
221 222
	ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
	ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
223
	ATA_FLAG_DEBUGMSG	= (1 << 13),
224
	ATA_FLAG_FPDMA_AA		= (1 << 14), /* driver supports Auto-Activate */
225
	ATA_FLAG_IGN_SIMPLEX	= (1 << 15), /* ignore SIMPLEX */
226
	ATA_FLAG_NO_IORDY	= (1 << 16), /* controller lacks iordy */
227
	ATA_FLAG_ACPI_SATA	= (1 << 17), /* need native SATA ACPI layout */
228
	ATA_FLAG_AN		= (1 << 18), /* controller supports AN */
229
	ATA_FLAG_PMP		= (1 << 19), /* controller supports PMP */
230
	ATA_FLAG_FPDMA_AUX	= (1 << 20), /* controller supports H2DFIS aux field */
231 232 233 234
	ATA_FLAG_EM		= (1 << 21), /* driver supports enclosure
					      * management */
	ATA_FLAG_SW_ACTIVITY	= (1 << 22), /* driver supports sw activity
					      * led */
235
	ATA_FLAG_NO_DIPM	= (1 << 23), /* host not happy with DIPM */
236
	ATA_FLAG_SAS_HOST	= (1 << 24), /* SAS host */
T
Tejun Heo 已提交
237

238
	/* bits 24:31 of ap->flags are reserved for LLD specific flags */
239

240

241 242 243 244 245 246 247
	/* struct ata_port pflags */
	ATA_PFLAG_EH_PENDING	= (1 << 0), /* EH pending */
	ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
	ATA_PFLAG_FROZEN	= (1 << 2), /* port is frozen */
	ATA_PFLAG_RECOVERED	= (1 << 3), /* recovery action performed */
	ATA_PFLAG_LOADING	= (1 << 4), /* boot/loading probe */
	ATA_PFLAG_SCSI_HOTPLUG	= (1 << 6), /* SCSI hotplug scheduled */
248
	ATA_PFLAG_INITIALIZING	= (1 << 7), /* being initialized, don't touch */
T
Tejun Heo 已提交
249
	ATA_PFLAG_RESETTING	= (1 << 8), /* reset in progress */
T
Tejun Heo 已提交
250 251
	ATA_PFLAG_UNLOADING	= (1 << 9), /* driver is being unloaded */
	ATA_PFLAG_UNLOADED	= (1 << 10), /* driver is unloaded */
T
Tejun Heo 已提交
252

253
	ATA_PFLAG_SUSPENDED	= (1 << 17), /* port is suspended (power) */
254
	ATA_PFLAG_PM_PENDING	= (1 << 18), /* PM operation pending */
255
	ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
T
Tejun Heo 已提交
256

257 258
	ATA_PFLAG_PIO32		= (1 << 20),  /* 32bit PIO */
	ATA_PFLAG_PIO32CHANGE	= (1 << 21),  /* 32bit PIO can be turned on/off */
259
	ATA_PFLAG_EXTERNAL	= (1 << 22),  /* eSATA/external port */
260

T
Tejun Heo 已提交
261 262
	/* struct ata_queued_cmd flags */
	ATA_QCFLAG_ACTIVE	= (1 << 0), /* cmd not yet ack'd to scsi lyer */
T
Tejun Heo 已提交
263
	ATA_QCFLAG_DMAMAP	= (1 << 1), /* SG table is DMA mapped */
T
Tejun Heo 已提交
264
	ATA_QCFLAG_IO		= (1 << 3), /* standard IO command */
265
	ATA_QCFLAG_RESULT_TF	= (1 << 4), /* result TF requested */
266
	ATA_QCFLAG_CLEAR_EXCL	= (1 << 5), /* clear excl_link on completion */
267
	ATA_QCFLAG_QUIET	= (1 << 6), /* don't report device error */
T
Tejun Heo 已提交
268
	ATA_QCFLAG_RETRY	= (1 << 7), /* retry after failure */
269

270 271 272
	ATA_QCFLAG_FAILED	= (1 << 16), /* cmd failed and is owned by EH */
	ATA_QCFLAG_SENSE_VALID	= (1 << 17), /* sense data valid */
	ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
L
Linus Torvalds 已提交
273

274
	/* host set flags */
J
Jeff Garzik 已提交
275
	ATA_HOST_SIMPLEX	= (1 << 0),	/* Host is simplex, one DMA channel per host only */
276
	ATA_HOST_STARTED	= (1 << 1),	/* Host started */
277
	ATA_HOST_PARALLEL_SCAN	= (1 << 2),	/* Ports on this host can be scanned in parallel */
278
	ATA_HOST_IGNORE_ATA	= (1 << 3),	/* Ignore ATA devices on this host. */
J
Jeff Garzik 已提交
279

280 281
	/* bits 24:31 of host->flags are reserved for LLD specific flags */

L
Linus Torvalds 已提交
282
	/* various lengths of time */
283 284 285
	ATA_TMOUT_BOOT		= 30000,	/* heuristic */
	ATA_TMOUT_BOOT_QUICK	=  7000,	/* heuristic */
	ATA_TMOUT_INTERNAL_QUICK = 5000,
286
	ATA_TMOUT_MAX_PARK	= 30000,
L
Linus Torvalds 已提交
287

288 289 290 291
	/*
	 * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms.  2s
	 * is too much without parallel probing.  Use 2s if parallel
	 * probing is available, 800ms otherwise.
292
	 */
293 294
	ATA_TMOUT_FF_WAIT_LONG	=  2000,
	ATA_TMOUT_FF_WAIT	=   800,
295

296 297 298 299 300 301 302 303 304 305
	/* Spec mandates to wait for ">= 2ms" before checking status
	 * after reset.  We wait 150ms, because that was the magic
	 * delay used for ATAPI devices in Hale Landis's ATADRVR, for
	 * the period of time between when the ATA command register is
	 * written, and then status is checked.  Because waiting for
	 * "a while" before checking status is fine, post SRST, we
	 * perform this magic delay here as well.
	 *
	 * Old drivers/ide uses the 2mS rule and then waits for ready.
	 */
306
	ATA_WAIT_AFTER_RESET	=  150,
307

308 309 310 311 312
	/* If PMP is supported, we have to do follow-up SRST.  As some
	 * PMPs don't send D2H Reg FIS after hardreset, LLDs are
	 * advised to wait only for the following duration before
	 * doing SRST.
	 */
313
	ATA_TMOUT_PMP_SRST_WAIT	= 5000,
314

315 316 317 318 319 320
	/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
	 * be a spurious PHY event, so ignore the first PHY event that
	 * occurs within 10s after the policy change.
	 */
	ATA_TMOUT_SPURIOUS_PHY	= 10000,

L
Linus Torvalds 已提交
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
	/* ATA bus states */
	BUS_UNKNOWN		= 0,
	BUS_DMA			= 1,
	BUS_IDLE		= 2,
	BUS_NOINTR		= 3,
	BUS_NODATA		= 4,
	BUS_TIMER		= 5,
	BUS_PIO			= 6,
	BUS_EDD			= 7,
	BUS_IDENTIFY		= 8,
	BUS_PACKET		= 9,

	/* SATA port states */
	PORT_UNKNOWN		= 0,
	PORT_ENABLED		= 1,
	PORT_DISABLED		= 2,

	/* encoding various smaller bitmaps into a single
339
	 * unsigned long bitmap
L
Linus Torvalds 已提交
340
	 */
341 342 343
	ATA_NR_PIO_MODES	= 7,
	ATA_NR_MWDMA_MODES	= 5,
	ATA_NR_UDMA_MODES	= 8,
344 345

	ATA_SHIFT_PIO		= 0,
346 347 348
	ATA_SHIFT_MWDMA		= ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
	ATA_SHIFT_UDMA		= ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,

349 350
	/* size of buffer to pad xfers ending on unaligned boundaries */
	ATA_DMA_PAD_SZ		= 4,
T
Tejun Heo 已提交
351

352 353 354
	/* ering size */
	ATA_ERING_SIZE		= 32,

355 356 357 358
	/* return values for ->qc_defer */
	ATA_DEFER_LINK		= 1,
	ATA_DEFER_PORT		= 2,

359 360 361
	/* desc_len for ata_eh_info and context */
	ATA_EH_DESC_LEN		= 80,

362 363
	/* reset / recovery action types */
	ATA_EH_REVALIDATE	= (1 << 0),
T
Tejun Heo 已提交
364 365 366
	ATA_EH_SOFTRESET	= (1 << 1), /* meaningful only in ->prereset */
	ATA_EH_HARDRESET	= (1 << 2), /* meaningful only in ->prereset */
	ATA_EH_RESET		= ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
367
	ATA_EH_ENABLE_LINK	= (1 << 3),
368
	ATA_EH_PARK		= (1 << 5), /* unload heads and stop I/O */
369

370
	ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE | ATA_EH_PARK,
371
	ATA_EH_ALL_ACTIONS	= ATA_EH_REVALIDATE | ATA_EH_RESET |
372
				  ATA_EH_ENABLE_LINK,
373

374
	/* ata_eh_info->flags */
375
	ATA_EHI_HOTPLUGGED	= (1 << 0),  /* could have been hotplugged */
376 377
	ATA_EHI_NO_AUTOPSY	= (1 << 2),  /* no autopsy */
	ATA_EHI_QUIET		= (1 << 3),  /* be quiet */
378
	ATA_EHI_NO_RECOVERY	= (1 << 4),  /* no recovery */
379

380 381 382 383
	ATA_EHI_DID_SOFTRESET	= (1 << 16), /* already soft-reset this port */
	ATA_EHI_DID_HARDRESET	= (1 << 17), /* already soft-reset this port */
	ATA_EHI_PRINTINFO	= (1 << 18), /* print configuration info */
	ATA_EHI_SETMODE		= (1 << 19), /* configure transfer mode */
A
Andrea Gelmini 已提交
384
	ATA_EHI_POST_SETMODE	= (1 << 20), /* revalidating after setmode */
385

386
	ATA_EHI_DID_RESET	= ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
387

388 389 390
	/* mask of flags to transfer *to* the slave link */
	ATA_EHI_TO_SLAVE_MASK	= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,

391 392
	/* max tries if error condition is still set after ->error_handler */
	ATA_EH_MAX_TRIES	= 5,
393

394 395 396
	/* sometimes resuming a link requires several retries */
	ATA_LINK_RESUME_TRIES	= 5,

397 398
	/* how hard are we gonna try to probe/recover devices */
	ATA_PROBE_MAX_TRIES	= 3,
T
Tejun Heo 已提交
399
	ATA_EH_DEV_TRIES	= 3,
400 401 402
	ATA_EH_PMP_TRIES	= 5,
	ATA_EH_PMP_LINK_TRIES	= 3,

403
	SATA_PMP_RW_TIMEOUT	= 3000,		/* PMP read/write timeout */
404

405 406 407
	/* This should match the actual table size of
	 * ata_eh_cmd_timeout_table in libata-eh.c.
	 */
408
	ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 6,
409

410
	/* Horkage types. May be set by libata or controller on drives
L
Lucas De Marchi 已提交
411
	   (some horkage may be drive/controller pair dependent */
412 413

	ATA_HORKAGE_DIAGNOSTIC	= (1 << 0),	/* Failed boot diag */
414 415
	ATA_HORKAGE_NODMA	= (1 << 1),	/* DMA problems */
	ATA_HORKAGE_NONCQ	= (1 << 2),	/* Don't use NCQ */
416
	ATA_HORKAGE_MAX_SEC_128	= (1 << 3),	/* Limit max sects to 128 */
417
	ATA_HORKAGE_BROKEN_HPA	= (1 << 4),	/* Broken HPA */
418
	ATA_HORKAGE_DISABLE	= (1 << 5),	/* Disable it */
419
	ATA_HORKAGE_HPA_SIZE	= (1 << 6),	/* native size off by one */
A
Alan Cox 已提交
420
	ATA_HORKAGE_IVB		= (1 << 8),	/* cbl det validity bit bugs */
421
	ATA_HORKAGE_STUCK_ERR	= (1 << 9),	/* stuck ERR on next PACKET */
422
	ATA_HORKAGE_BRIDGE_OK	= (1 << 10),	/* no bridge limits */
423 424
	ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
						    not multiple of 16 bytes */
425
	ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),	/* firmware update warning */
426
	ATA_HORKAGE_1_5_GBPS	= (1 << 13),	/* force 1.5 Gbps */
427
	ATA_HORKAGE_NOSETXFER	= (1 << 14),	/* skip SETXFER, SATA only */
428
	ATA_HORKAGE_BROKEN_FPDMA_AA	= (1 << 15),	/* skip AA */
429
	ATA_HORKAGE_DUMP_ID	= (1 << 16),	/* dump IDENTIFY data */
430
	ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),	/* Set max sects to 65535 */
431
	ATA_HORKAGE_ATAPI_DMADIR = (1 << 18),	/* device requires dmadir */
432
	ATA_HORKAGE_NO_NCQ_TRIM	= (1 << 19),	/* don't use queued TRIM */
433 434
	ATA_HORKAGE_NOLPM	= (1 << 20),	/* don't use LPM */
	ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),	/* some WDs have broken LPM */
435
	ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
436
	ATA_HORKAGE_NO_NCQ_LOG	= (1 << 23),	/* don't use NCQ for log read */
437
	ATA_HORKAGE_NOTRIM	= (1 << 24),	/* don't use TRIM */
438
	ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),	/* Limit max sects to 1024 */
439

440
	 /* DMA mask for user DMA control: User visible values; DO NOT
441 442 443 444
	    renumber */
	ATA_DMA_MASK_ATA	= (1 << 0),	/* DMA on ATA Disk */
	ATA_DMA_MASK_ATAPI	= (1 << 1),	/* DMA on ATAPI */
	ATA_DMA_MASK_CFA	= (1 << 2),	/* DMA on CF Card */
445 446 447 448 449

	/* ATAPI command types */
	ATAPI_READ		= 0,		/* READs */
	ATAPI_WRITE		= 1,		/* WRITEs */
	ATAPI_READ_CD		= 2,		/* READ CD [MSF] */
450 451
	ATAPI_PASS_THRU		= 3,		/* SAT pass-thru */
	ATAPI_MISC		= 4,		/* the rest */
T
Tejun Heo 已提交
452 453 454 455 456 457 458 459 460 461

	/* Timing constants */
	ATA_TIMING_SETUP	= (1 << 0),
	ATA_TIMING_ACT8B	= (1 << 1),
	ATA_TIMING_REC8B	= (1 << 2),
	ATA_TIMING_CYC8B	= (1 << 3),
	ATA_TIMING_8BIT		= ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
				  ATA_TIMING_CYC8B,
	ATA_TIMING_ACTIVE	= (1 << 4),
	ATA_TIMING_RECOVER	= (1 << 5),
462 463 464
	ATA_TIMING_DMACK_HOLD	= (1 << 6),
	ATA_TIMING_CYCLE	= (1 << 7),
	ATA_TIMING_UDMA		= (1 << 8),
T
Tejun Heo 已提交
465 466 467
	ATA_TIMING_ALL		= ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
				  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
				  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
468 469
				  ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
				  ATA_TIMING_UDMA,
T
Tejun Heo 已提交
470 471 472 473 474

	/* ACPI constants */
	ATA_ACPI_FILTER_SETXFER	= 1 << 0,
	ATA_ACPI_FILTER_LOCK	= 1 << 1,
	ATA_ACPI_FILTER_DIPM	= 1 << 2,
475 476
	ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3,	/* FPDMA non-zero offset */
	ATA_ACPI_FILTER_FPDMA_AA = 1 << 4,	/* FPDMA auto activate */
T
Tejun Heo 已提交
477 478 479 480

	ATA_ACPI_FILTER_DEFAULT	= ATA_ACPI_FILTER_SETXFER |
				  ATA_ACPI_FILTER_LOCK |
				  ATA_ACPI_FILTER_DIPM,
L
Linus Torvalds 已提交
481 482
};

483 484 485 486 487 488 489 490 491
enum ata_xfer_mask {
	ATA_MASK_PIO		= ((1LU << ATA_NR_PIO_MODES) - 1)
					<< ATA_SHIFT_PIO,
	ATA_MASK_MWDMA		= ((1LU << ATA_NR_MWDMA_MODES) - 1)
					<< ATA_SHIFT_MWDMA,
	ATA_MASK_UDMA		= ((1LU << ATA_NR_UDMA_MODES) - 1)
					<< ATA_SHIFT_UDMA,
};

A
Albert Lee 已提交
492
enum hsm_task_states {
493
	HSM_ST_IDLE,		/* no command on going */
494 495
	HSM_ST_FIRST,		/* (waiting the device to)
				   write CDB or first data block */
496 497 498
	HSM_ST,			/* (waiting the device to) transfer data */
	HSM_ST_LAST,		/* (waiting the device to) complete command */
	HSM_ST_ERR,		/* error */
L
Linus Torvalds 已提交
499 500
};

501
enum ata_completion_errors {
502 503 504 505 506 507 508 509 510
	AC_ERR_DEV		= (1 << 0), /* device reported error */
	AC_ERR_HSM		= (1 << 1), /* host state machine violation */
	AC_ERR_TIMEOUT		= (1 << 2), /* timeout */
	AC_ERR_MEDIA		= (1 << 3), /* media error */
	AC_ERR_ATA_BUS		= (1 << 4), /* ATA bus error */
	AC_ERR_HOST_BUS		= (1 << 5), /* host bus error */
	AC_ERR_SYSTEM		= (1 << 6), /* system error */
	AC_ERR_INVALID		= (1 << 7), /* invalid argument */
	AC_ERR_OTHER		= (1 << 8), /* unknown */
511
	AC_ERR_NODEV_HINT	= (1 << 9), /* polling device detection hint */
T
Tejun Heo 已提交
512
	AC_ERR_NCQ		= (1 << 10), /* marker for offending NCQ qc */
513 514
};

515 516 517 518 519 520 521 522 523 524 525
/*
 * Link power management policy: If you alter this, you also need to
 * alter libata-scsi.c (for the ascii descriptions)
 */
enum ata_lpm_policy {
	ATA_LPM_UNKNOWN,
	ATA_LPM_MAX_POWER,
	ATA_LPM_MED_POWER,
	ATA_LPM_MIN_POWER,
};

526 527 528
enum ata_lpm_hints {
	ATA_LPM_EMPTY		= (1 << 0), /* port empty/probing */
	ATA_LPM_HIPM		= (1 << 1), /* may use HIPM */
529
	ATA_LPM_WAKE_ONLY	= (1 << 2), /* only wake up link */
530 531
};

L
Linus Torvalds 已提交
532 533 534 535
/* forward declarations */
struct scsi_device;
struct ata_port_operations;
struct ata_port;
T
Tejun Heo 已提交
536
struct ata_link;
L
Linus Torvalds 已提交
537 538 539
struct ata_queued_cmd;

/* typedefs */
540
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
T
Tejun Heo 已提交
541 542
typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
543
			      unsigned long deadline);
T
Tejun Heo 已提交
544
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
L
Linus Torvalds 已提交
545

546
extern struct device_attribute dev_attr_link_power_management_policy;
547
extern struct device_attribute dev_attr_unload_heads;
548 549 550 551 552 553 554 555 556
extern struct device_attribute dev_attr_em_message_type;
extern struct device_attribute dev_attr_em_message;
extern struct device_attribute dev_attr_sw_activity;

enum sw_activity {
	OFF,
	BLINK_ON,
	BLINK_OFF,
};
557

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
struct ata_taskfile {
	unsigned long		flags;		/* ATA_TFLAG_xxx */
	u8			protocol;	/* ATA_PROT_xxx */

	u8			ctl;		/* control reg */

	u8			hob_feature;	/* additional data */
	u8			hob_nsect;	/* to support LBA48 */
	u8			hob_lbal;
	u8			hob_lbam;
	u8			hob_lbah;

	u8			feature;
	u8			nsect;
	u8			lbal;
	u8			lbam;
	u8			lbah;

	u8			device;

	u8			command;	/* IO operation */
579 580 581 582

	u32			auxiliary;	/* auxiliary field */
						/* from SATA 3.1 and */
						/* ATA-8 ACS-3 */
583 584
};

T
Tejun Heo 已提交
585
#ifdef CONFIG_ATA_SFF
L
Linus Torvalds 已提交
586
struct ata_ioports {
T
Tejun Heo 已提交
587 588 589 590 591 592 593 594 595 596 597 598 599
	void __iomem		*cmd_addr;
	void __iomem		*data_addr;
	void __iomem		*error_addr;
	void __iomem		*feature_addr;
	void __iomem		*nsect_addr;
	void __iomem		*lbal_addr;
	void __iomem		*lbam_addr;
	void __iomem		*lbah_addr;
	void __iomem		*device_addr;
	void __iomem		*status_addr;
	void __iomem		*command_addr;
	void __iomem		*altstatus_addr;
	void __iomem		*ctl_addr;
T
Tejun Heo 已提交
600
#ifdef CONFIG_ATA_BMDMA
T
Tejun Heo 已提交
601
	void __iomem		*bmdma_addr;
T
Tejun Heo 已提交
602
#endif /* CONFIG_ATA_BMDMA */
T
Tejun Heo 已提交
603
	void __iomem		*scr_addr;
L
Linus Torvalds 已提交
604
};
T
Tejun Heo 已提交
605
#endif /* CONFIG_ATA_SFF */
L
Linus Torvalds 已提交
606

J
Jeff Garzik 已提交
607
struct ata_host {
L
Linus Torvalds 已提交
608 609
	spinlock_t		lock;
	struct device 		*dev;
T
Tejun Heo 已提交
610
	void __iomem * const	*iomap;
L
Linus Torvalds 已提交
611
	unsigned int		n_ports;
612
	unsigned int		n_tags;			/* nr of NCQ tags */
L
Linus Torvalds 已提交
613
	void			*private_data;
614
	struct ata_port_operations *ops;
615
	unsigned long		flags;
616 617 618 619

	struct mutex		eh_mutex;
	struct task_struct	*eh_owner;

A
Alan 已提交
620
	struct ata_port		*simplex_claimed;	/* channel owning the DMA */
621
	struct ata_port		*ports[0];
L
Linus Torvalds 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
};

struct ata_queued_cmd {
	struct ata_port		*ap;
	struct ata_device	*dev;

	struct scsi_cmnd	*scsicmd;
	void			(*scsidone)(struct scsi_cmnd *);

	struct ata_taskfile	tf;
	u8			cdb[ATAPI_CDB_LEN];

	unsigned long		flags;		/* ATA_QCFLAG_xxx */
	unsigned int		tag;
	unsigned int		n_elem;
637
	unsigned int		orig_n_elem;
L
Linus Torvalds 已提交
638 639 640

	int			dma_dir;

641
	unsigned int		sect_size;
642

L
Linus Torvalds 已提交
643
	unsigned int		nbytes;
644
	unsigned int		extrabytes;
L
Linus Torvalds 已提交
645 646 647 648
	unsigned int		curbytes;

	struct scatterlist	sgent;

T
Tejun Heo 已提交
649
	struct scatterlist	*sg;
L
Linus Torvalds 已提交
650

651 652 653
	struct scatterlist	*cursg;
	unsigned int		cursg_ofs;

654
	unsigned int		err_mask;
655
	struct ata_taskfile	result_tf;
L
Linus Torvalds 已提交
656 657 658
	ata_qc_cb_t		complete_fn;

	void			*private_data;
659
	void			*lldd_task;
L
Linus Torvalds 已提交
660 661
};

J
Jeff Garzik 已提交
662
struct ata_port_stats {
L
Linus Torvalds 已提交
663 664 665 666 667
	unsigned long		unhandled_irq;
	unsigned long		idle_irq;
	unsigned long		rw_reqbuf;
};

668
struct ata_ering_entry {
669
	unsigned int		eflags;
670 671 672 673 674 675 676 677 678
	unsigned int		err_mask;
	u64			timestamp;
};

struct ata_ering {
	int			cursor;
	struct ata_ering_entry	ring[ATA_ERING_SIZE];
};

L
Linus Torvalds 已提交
679
struct ata_device {
T
Tejun Heo 已提交
680
	struct ata_link		*link;
681
	unsigned int		devno;		/* 0 or 1 */
T
Tejun Heo 已提交
682
	unsigned int		horkage;	/* List of broken features */
683
	unsigned long		flags;		/* ATA_DFLAG_xxx */
684
	struct scsi_device	*sdev;		/* attached SCSI device */
685
	void			*private_data;
686
#ifdef CONFIG_ATA_ACPI
687
	union acpi_object	*gtf_cache;
T
Tejun Heo 已提交
688
	unsigned int		gtf_filter;
689 690 691
#endif
#ifdef CONFIG_SATA_ZPODD
	void			*zpodd;
692
#endif
G
Gwendal Grignou 已提交
693
	struct device		tdev;
694
	/* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
695
	u64			n_sectors;	/* size of device, if ATA */
T
Tejun Heo 已提交
696
	u64			n_native_sectors; /* native size, if ATA */
L
Linus Torvalds 已提交
697
	unsigned int		class;		/* ATA_DEV_xxx */
698
	unsigned long		unpark_deadline;
699

L
Linus Torvalds 已提交
700 701 702 703 704
	u8			pio_mode;
	u8			dma_mode;
	u8			xfer_mode;
	unsigned int		xfer_shift;	/* ATA_SHIFT_xxx */

705 706
	unsigned int		multi_count;	/* sectors count for
						   READ/WRITE MULTIPLE */
707
	unsigned int		max_sectors;	/* per-device max sectors */
708
	unsigned int		cdb_len;
709

710
	/* per-dev xfer mask */
711 712 713
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;
714

715 716 717 718
	/* for CHS addressing */
	u16			cylinders;	/* Number of cylinders */
	u16			heads;		/* Number of heads */
	u16			sectors;	/* Number of sectors per track */
719

720 721 722
	union {
		u16		id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
		u32		gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
723
	} ____cacheline_aligned;
724

725 726
	/* DEVSLP Timing Variables from Identify Device Data Log */
	u8			devslp_timing[ATA_LOG_DEVSLP_SIZE];
727

728 729 730
	/* NCQ send and receive log subcommand support */
	u8			ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_SIZE];

731 732 733 734
	/* error history */
	int			spdn_cnt;
	/* ering is CLEAR_END, read comment above CLEAR_END */
	struct ata_ering	ering;
L
Linus Torvalds 已提交
735 736
};

737 738
/* Fields between ATA_DEVICE_CLEAR_BEGIN and ATA_DEVICE_CLEAR_END are
 * cleared to zero on ata_dev_init().
739
 */
740 741
#define ATA_DEVICE_CLEAR_BEGIN		offsetof(struct ata_device, n_sectors)
#define ATA_DEVICE_CLEAR_END		offsetof(struct ata_device, ering)
742

743 744 745 746 747
struct ata_eh_info {
	struct ata_device	*dev;		/* offending device */
	u32			serror;		/* SError from LLDD */
	unsigned int		err_mask;	/* port-wide err_mask */
	unsigned int		action;		/* ATA_EH_* action mask */
748
	unsigned int		dev_action[ATA_MAX_DEVICES]; /* dev EH action */
749
	unsigned int		flags;		/* ATA_EHI_* flags */
750 751 752

	unsigned int		probe_mask;

753 754 755 756 757 758 759
	char			desc[ATA_EH_DESC_LEN];
	int			desc_len;
};

struct ata_eh_context {
	struct ata_eh_info	i;
	int			tries[ATA_MAX_DEVICES];
760 761
	int			cmd_timeout_idx[ATA_MAX_DEVICES]
					       [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
762 763
	unsigned int		classes[ATA_MAX_DEVICES];
	unsigned int		did_probe_mask;
764
	unsigned int		unloaded_mask;
765 766
	unsigned int		saved_ncq_enabled;
	u8			saved_xfer_mode[ATA_MAX_DEVICES];
767 768
	/* timestamp for the last reset attempt or success */
	unsigned long		last_reset;
769 770
};

771 772 773 774 775 776 777 778 779 780 781
struct ata_acpi_drive
{
	u32 pio;
	u32 dma;
} __packed;

struct ata_acpi_gtm {
	struct ata_acpi_drive drive[2];
	u32 flags;
} __packed;

T
Tejun Heo 已提交
782 783
struct ata_link {
	struct ata_port		*ap;
T
Tejun Heo 已提交
784
	int			pmp;		/* port multiplier port # */
T
Tejun Heo 已提交
785

G
Gwendal Grignou 已提交
786
	struct device		tdev;
T
Tejun Heo 已提交
787 788 789
	unsigned int		active_tag;	/* active tag on this link */
	u32			sactive;	/* active NCQ commands */

790 791
	unsigned int		flags;		/* ATA_LFLAG_xxx */

T
Tejun Heo 已提交
792
	u32			saved_scontrol;	/* SControl on probe */
T
Tejun Heo 已提交
793 794 795
	unsigned int		hw_sata_spd_limit;
	unsigned int		sata_spd_limit;
	unsigned int		sata_spd;	/* current SATA PHY speed */
796
	enum ata_lpm_policy	lpm_policy;
T
Tejun Heo 已提交
797 798 799 800 801 802 803

	/* record runtime error info, protected by host_set lock */
	struct ata_eh_info	eh_info;
	/* EH context */
	struct ata_eh_context	eh_context;

	struct ata_device	device[ATA_MAX_DEVICES];
804 805

	unsigned long		last_lpm_change; /* when last LPM change happened */
T
Tejun Heo 已提交
806
};
G
Gwendal Grignou 已提交
807 808
#define ATA_LINK_CLEAR_BEGIN		offsetof(struct ata_link, active_tag)
#define ATA_LINK_CLEAR_END		offsetof(struct ata_link, device[0])
T
Tejun Heo 已提交
809

L
Linus Torvalds 已提交
810
struct ata_port {
J
Jeff Garzik 已提交
811
	struct Scsi_Host	*scsi_host; /* our co-allocated scsi host */
812
	struct ata_port_operations *ops;
813
	spinlock_t		*lock;
814 815
	/* Flags owned by the EH context. Only EH should touch these once the
	   port is active */
L
Linus Torvalds 已提交
816
	unsigned long		flags;	/* ATA_FLAG_xxx */
817
	/* Flags that change dynamically, protected by ap->lock */
818
	unsigned int		pflags; /* ATA_PFLAG_xxx */
T
Tejun Heo 已提交
819
	unsigned int		print_id; /* user visible unique port ID */
820
	unsigned int            local_port_no; /* host local port num */
T
Tejun Heo 已提交
821
	unsigned int		port_no; /* 0 based port no. inside the host */
L
Linus Torvalds 已提交
822

T
Tejun Heo 已提交
823
#ifdef CONFIG_ATA_SFF
L
Linus Torvalds 已提交
824 825 826
	struct ata_ioports	ioaddr;	/* ATA cmd/ctl/dma register blocks */
	u8			ctl;	/* cache of ATA control register */
	u8			last_ctl;	/* Cache last written value */
827
	struct ata_link*	sff_pio_task_link; /* link currently used */
828
	struct delayed_work	sff_pio_task;
T
Tejun Heo 已提交
829
#ifdef CONFIG_ATA_BMDMA
T
Tejun Heo 已提交
830 831
	struct ata_bmdma_prd	*bmdma_prd;	/* BMDMA SG list */
	dma_addr_t		bmdma_prd_dma;	/* and its DMA mapping */
T
Tejun Heo 已提交
832
#endif /* CONFIG_ATA_BMDMA */
833 834
#endif /* CONFIG_ATA_SFF */

L
Linus Torvalds 已提交
835 836 837 838 839 840
	unsigned int		pio_mask;
	unsigned int		mwdma_mask;
	unsigned int		udma_mask;
	unsigned int		cbl;	/* cable type; ATA_CBL_xxx */

	struct ata_queued_cmd	qcmd[ATA_MAX_QUEUE];
S
Shaohua Li 已提交
841
	unsigned long		sas_tag_allocated; /* for sas tag allocation only */
842
	unsigned int		qc_active;
843
	int			nr_active_links; /* #links with active qcs */
S
Shaohua Li 已提交
844
	unsigned int		sas_last_tag;	/* track next tag hw expects */
845

T
Tejun Heo 已提交
846 847
	struct ata_link		link;		/* host default link */
	struct ata_link		*slave_link;	/* see ata_slave_link_init() */
L
Linus Torvalds 已提交
848

T
Tejun Heo 已提交
849 850
	int			nr_pmp_links;	/* nr of available PMP links */
	struct ata_link		*pmp_link;	/* array of PMP links */
851
	struct ata_link		*excl_link;	/* for PMP qc exclusion */
T
Tejun Heo 已提交
852

J
Jeff Garzik 已提交
853 854
	struct ata_port_stats	stats;
	struct ata_host		*host;
855
	struct device 		*dev;
G
Gwendal Grignou 已提交
856
	struct device		tdev;
L
Linus Torvalds 已提交
857

858
	struct mutex		scsi_scan_mutex;
859
	struct delayed_work	hotplug_task;
860
	struct work_struct	scsi_rescan_task;
T
Tejun Heo 已提交
861

A
Albert Lee 已提交
862
	unsigned int		hsm_task_state;
L
Linus Torvalds 已提交
863

864
	u32			msg_enable;
865
	struct list_head	eh_done_q;
866
	wait_queue_head_t	eh_wait_q;
867
	int			eh_tries;
868
	struct completion	park_req_pending;
869

870
	pm_message_t		pm_mesg;
871
	enum ata_lpm_policy	target_lpm_policy;
872

T
Tejun Heo 已提交
873 874 875
	struct timer_list	fastdrain_timer;
	unsigned long		fastdrain_cnt;

876
	int			em_message_type;
L
Linus Torvalds 已提交
877
	void			*private_data;
878

879
#ifdef CONFIG_ATA_ACPI
880
	struct ata_acpi_gtm	__acpi_init_gtm; /* use ata_acpi_init_gtm() */
881
#endif
T
Tejun Heo 已提交
882 883
	/* owned by EH */
	u8			sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
L
Linus Torvalds 已提交
884 885
};

886 887 888 889 890 891 892
/* The following initializer overrides a method to NULL whether one of
 * its parent has the method defined or not.  This is equivalent to
 * ERR_PTR(-ENOENT).  Unfortunately, ERR_PTR doesn't render a constant
 * expression and thus can't be used as an initializer.
 */
#define ATA_OP_NULL		(void *)(unsigned long)(-ENOENT)

L
Linus Torvalds 已提交
893
struct ata_port_operations {
894 895 896 897 898 899 900
	/*
	 * Command execution
	 */
	int  (*qc_defer)(struct ata_queued_cmd *qc);
	int  (*check_atapi_dma)(struct ata_queued_cmd *qc);
	void (*qc_prep)(struct ata_queued_cmd *qc);
	unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
901
	bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
902

903 904 905 906 907 908 909 910
	/*
	 * Configuration and exception handling
	 */
	int  (*cable_detect)(struct ata_port *ap);
	unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask);
	void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
	void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
	int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
911
	unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
L
Linus Torvalds 已提交
912

913
	void (*dev_config)(struct ata_device *dev);
L
Linus Torvalds 已提交
914

915 916
	void (*freeze)(struct ata_port *ap);
	void (*thaw)(struct ata_port *ap);
917 918 919 920 921 922 923 924
	ata_prereset_fn_t	prereset;
	ata_reset_fn_t		softreset;
	ata_reset_fn_t		hardreset;
	ata_postreset_fn_t	postreset;
	ata_prereset_fn_t	pmp_prereset;
	ata_reset_fn_t		pmp_softreset;
	ata_reset_fn_t		pmp_hardreset;
	ata_postreset_fn_t	pmp_postreset;
925
	void (*error_handler)(struct ata_port *ap);
A
Alan Cox 已提交
926
	void (*lost_interrupt)(struct ata_port *ap);
927
	void (*post_internal_cmd)(struct ata_queued_cmd *qc);
928 929
	void (*sched_eh)(struct ata_port *ap);
	void (*end_eh)(struct ata_port *ap);
930 931 932 933

	/*
	 * Optional features
	 */
T
Tejun Heo 已提交
934 935
	int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
	int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
936 937
	void (*pmp_attach)(struct ata_port *ap);
	void (*pmp_detach)(struct ata_port *ap);
938 939
	int  (*set_lpm)(struct ata_link *link, enum ata_lpm_policy policy,
			unsigned hints);
940 941 942 943 944 945 946 947 948 949

	/*
	 * Start, stop, suspend and resume
	 */
	int  (*port_suspend)(struct ata_port *ap, pm_message_t mesg);
	int  (*port_resume)(struct ata_port *ap);
	int  (*port_start)(struct ata_port *ap);
	void (*port_stop)(struct ata_port *ap);
	void (*host_stop)(struct ata_host *host);

T
Tejun Heo 已提交
950
#ifdef CONFIG_ATA_SFF
951 952 953
	/*
	 * SFF / taskfile oriented ops
	 */
T
Tejun Heo 已提交
954
	void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
955
	void (*sff_set_devctl)(struct ata_port *ap, u8 ctl);
T
Tejun Heo 已提交
956 957 958 959 960 961 962 963
	u8   (*sff_check_status)(struct ata_port *ap);
	u8   (*sff_check_altstatus)(struct ata_port *ap);
	void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
	void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
	void (*sff_exec_command)(struct ata_port *ap,
				 const struct ata_taskfile *tf);
	unsigned int (*sff_data_xfer)(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
964
	void (*sff_irq_on)(struct ata_port *);
965
	bool (*sff_irq_check)(struct ata_port *);
T
Tejun Heo 已提交
966
	void (*sff_irq_clear)(struct ata_port *);
967
	void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
T
Tejun Heo 已提交
968

T
Tejun Heo 已提交
969
#ifdef CONFIG_ATA_BMDMA
970 971 972 973
	void (*bmdma_setup)(struct ata_queued_cmd *qc);
	void (*bmdma_start)(struct ata_queued_cmd *qc);
	void (*bmdma_stop)(struct ata_queued_cmd *qc);
	u8   (*bmdma_status)(struct ata_port *ap);
T
Tejun Heo 已提交
974
#endif /* CONFIG_ATA_BMDMA */
T
Tejun Heo 已提交
975
#endif /* CONFIG_ATA_SFF */
976

977 978 979 980 981 982
	ssize_t (*em_show)(struct ata_port *ap, char *buf);
	ssize_t (*em_store)(struct ata_port *ap, const char *message,
			    size_t size);
	ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
	ssize_t (*sw_activity_store)(struct ata_device *dev,
				     enum sw_activity val);
983 984 985
	ssize_t (*transmit_led_message)(struct ata_port *ap, u32 state,
					ssize_t size);

986 987
	/*
	 * Obsolete
988
	 */
989 990
	void (*phy_reset)(struct ata_port *ap);
	void (*eng_timeout)(struct ata_port *ap);
991 992 993 994 995 996

	/*
	 * ->inherits must be the last field and all the preceding
	 * fields must be pointers.
	 */
	const struct ata_port_operations	*inherits;
L
Linus Torvalds 已提交
997 998 999
};

struct ata_port_info {
J
Jeff Garzik 已提交
1000
	unsigned long		flags;
1001
	unsigned long		link_flags;
L
Linus Torvalds 已提交
1002 1003 1004
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;
1005
	struct ata_port_operations *port_ops;
1006
	void 			*private_data;
L
Linus Torvalds 已提交
1007 1008
};

A
Alan Cox 已提交
1009 1010 1011 1012 1013 1014 1015 1016
struct ata_timing {
	unsigned short mode;		/* ATA mode */
	unsigned short setup;		/* t1 */
	unsigned short act8b;		/* t2 for 8-bit I/O */
	unsigned short rec8b;		/* t2i for 8-bit I/O */
	unsigned short cyc8b;		/* t0 for 8-bit I/O */
	unsigned short active;		/* t2 or tD */
	unsigned short recover;		/* t2i or tK */
1017
	unsigned short dmack_hold;	/* tj */
A
Alan Cox 已提交
1018 1019 1020 1021
	unsigned short cycle;		/* t0 */
	unsigned short udma;		/* t2CYCTYP/2 */
};

T
Tejun Heo 已提交
1022 1023 1024
/*
 * Core layer - drivers/ata/libata-core.c
 */
1025 1026 1027 1028
extern const unsigned long sata_deb_timing_normal[];
extern const unsigned long sata_deb_timing_hotplug[];
extern const unsigned long sata_deb_timing_long[];

1029
extern struct ata_port_operations ata_dummy_port_ops;
1030
extern const struct ata_port_info ata_dummy_port_info;
T
Tejun Heo 已提交
1031

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
/*
 * protocol tests
 */
static inline unsigned int ata_prot_flags(u8 prot)
{
	switch (prot) {
	case ATA_PROT_NODATA:
		return 0;
	case ATA_PROT_PIO:
		return ATA_PROT_FLAG_PIO;
	case ATA_PROT_DMA:
		return ATA_PROT_FLAG_DMA;
	case ATA_PROT_NCQ:
		return ATA_PROT_FLAG_DMA | ATA_PROT_FLAG_NCQ;
	case ATAPI_PROT_NODATA:
		return ATA_PROT_FLAG_ATAPI;
	case ATAPI_PROT_PIO:
		return ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_PIO;
	case ATAPI_PROT_DMA:
		return ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_DMA;
	}
	return 0;
}

static inline int ata_is_atapi(u8 prot)
{
	return ata_prot_flags(prot) & ATA_PROT_FLAG_ATAPI;
}

static inline int ata_is_nodata(u8 prot)
{
	return !(ata_prot_flags(prot) & ATA_PROT_FLAG_DATA);
}

static inline int ata_is_pio(u8 prot)
{
	return ata_prot_flags(prot) & ATA_PROT_FLAG_PIO;
}

static inline int ata_is_dma(u8 prot)
{
	return ata_prot_flags(prot) & ATA_PROT_FLAG_DMA;
}

static inline int ata_is_ncq(u8 prot)
{
	return ata_prot_flags(prot) & ATA_PROT_FLAG_NCQ;
}

static inline int ata_is_data(u8 prot)
{
	return ata_prot_flags(prot) & ATA_PROT_FLAG_DATA;
}

static inline int is_multi_taskfile(struct ata_taskfile *tf)
{
	return (tf->command == ATA_CMD_READ_MULTI) ||
	       (tf->command == ATA_CMD_WRITE_MULTI) ||
	       (tf->command == ATA_CMD_READ_MULTI_EXT) ||
	       (tf->command == ATA_CMD_WRITE_MULTI_EXT) ||
	       (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
}

1095 1096 1097 1098 1099 1100 1101 1102
static inline const unsigned long *
sata_ehc_deb_timing(struct ata_eh_context *ehc)
{
	if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
		return sata_deb_timing_hotplug;
	else
		return sata_deb_timing_normal;
}
1103

T
Tejun Heo 已提交
1104 1105 1106 1107 1108
static inline int ata_port_is_dummy(struct ata_port *ap)
{
	return ap->ops == &ata_dummy_port_ops;
}

1109
extern int sata_set_spd(struct ata_link *link);
1110
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
1111 1112
extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
				int (*check_ready)(struct ata_link *link));
1113 1114 1115 1116
extern int sata_link_debounce(struct ata_link *link,
			const unsigned long *params, unsigned long deadline);
extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
			    unsigned long deadline);
1117 1118
extern int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
			     bool spm_wakeup);
T
Tejun Heo 已提交
1119
extern int sata_link_hardreset(struct ata_link *link,
1120 1121
			const unsigned long *timing, unsigned long deadline,
			bool *online, int (*check_ready)(struct ata_link *));
1122 1123
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
			      unsigned long deadline);
1124
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
1125

1126
extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
1127 1128
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
			const struct ata_port_info * const * ppi, int n_ports);
T
Tejun Heo 已提交
1129
extern int ata_slave_link_init(struct ata_port *ap);
1130
extern int ata_host_start(struct ata_host *host);
1131 1132
extern int ata_host_register(struct ata_host *host,
			     struct scsi_host_template *sht);
1133 1134 1135
extern int ata_host_activate(struct ata_host *host, int irq,
			     irq_handler_t irq_handler, unsigned long irq_flags,
			     struct scsi_host_template *sht);
T
Tejun Heo 已提交
1136
extern void ata_host_detach(struct ata_host *host);
1137
extern void ata_host_init(struct ata_host *, struct device *, struct ata_port_operations *);
1138
extern int ata_scsi_detect(struct scsi_host_template *sht);
L
Linus Torvalds 已提交
1139
extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
J
Jeff Garzik 已提交
1140
extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
1141 1142
extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
			    int cmd, void __user *arg);
1143
extern void ata_sas_port_destroy(struct ata_port *);
J
Jeff Garzik 已提交
1144
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
1145
					   struct ata_port_info *, struct Scsi_Host *);
1146 1147
extern void ata_sas_async_probe(struct ata_port *ap);
extern int ata_sas_sync_probe(struct ata_port *ap);
1148 1149 1150 1151
extern int ata_sas_port_init(struct ata_port *);
extern int ata_sas_port_start(struct ata_port *ap);
extern void ata_sas_port_stop(struct ata_port *ap);
extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
1152
extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap);
1153 1154 1155 1156
extern int sata_scr_valid(struct ata_link *link);
extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
1157 1158
extern bool ata_link_online(struct ata_link *link);
extern bool ata_link_offline(struct ata_link *link);
1159
#ifdef CONFIG_PM
J
Jeff Garzik 已提交
1160 1161
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
extern void ata_host_resume(struct ata_host *host);
1162 1163
extern void ata_sas_port_suspend(struct ata_port *ap);
extern void ata_sas_port_resume(struct ata_port *ap);
1164
#else
1165
static inline void ata_sas_port_suspend(struct ata_port *ap)
1166 1167
{
}
1168 1169 1170
static inline void ata_sas_port_resume(struct ata_port *ap)
{
}
1171
#endif
1172
extern int ata_ratelimit(void);
1173 1174 1175
extern void ata_msleep(struct ata_port *ap, unsigned int msecs);
extern u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask,
			u32 val, unsigned long interval, unsigned long timeout);
T
Tejun Heo 已提交
1176
extern int atapi_cmd_type(u8 opcode);
1177 1178
extern void ata_tf_to_fis(const struct ata_taskfile *tf,
			  u8 pmp, int is_cmd, u8 *fis);
J
Jeff Garzik 已提交
1179
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
			unsigned long mwdma_mask, unsigned long udma_mask);
extern void ata_unpack_xfermask(unsigned long xfer_mask,
			unsigned long *pio_mask, unsigned long *mwdma_mask,
			unsigned long *udma_mask);
extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
extern int ata_xfer_mode2shift(unsigned long xfer_mode);
extern const char *ata_mode_string(unsigned long xfer_mask);
extern unsigned long ata_id_xfermask(const u16 *id);
1190
extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
1191
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
1192 1193
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
		 unsigned int n_elem);
J
Jeff Garzik 已提交
1194
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
1195
extern void ata_dev_disable(struct ata_device *adev);
1196 1197 1198 1199
extern void ata_id_string(const u16 *id, unsigned char *s,
			  unsigned int ofs, unsigned int len);
extern void ata_id_c_string(const u16 *id, unsigned char *s,
			    unsigned int ofs, unsigned int len);
1200 1201
extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
					struct ata_taskfile *tf, u16 *id);
1202
extern void ata_qc_complete(struct ata_queued_cmd *qc);
1203
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
1204
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
L
Linus Torvalds 已提交
1205 1206 1207
extern int ata_std_bios_param(struct scsi_device *sdev,
			      struct block_device *bdev,
			      sector_t capacity, int geom[]);
1208
extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
L
Linus Torvalds 已提交
1209
extern int ata_scsi_slave_config(struct scsi_device *sdev);
1210
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
1211
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
1212
				       int queue_depth);
1213
extern int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
1214
				    int queue_depth);
T
Tejun Heo 已提交
1215
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
1216
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
1217 1218
extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
extern void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
1219
extern bool sata_lpm_ignore_phy_events(struct ata_link *link);
L
Linus Torvalds 已提交
1220

A
Alan Cox 已提交
1221 1222 1223
extern int ata_cable_40wire(struct ata_port *ap);
extern int ata_cable_80wire(struct ata_port *ap);
extern int ata_cable_sata(struct ata_port *ap);
T
Tejun Heo 已提交
1224
extern int ata_cable_ignore(struct ata_port *ap);
A
Alan Cox 已提交
1225 1226
extern int ata_cable_unknown(struct ata_port *ap);

T
Tejun Heo 已提交
1227
/* Timing helpers */
1228
extern unsigned int ata_pio_need_iordy(const struct ata_device *);
1229
extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
A
Alan Cox 已提交
1230 1231 1232 1233 1234
extern int ata_timing_compute(struct ata_device *, unsigned short,
			      struct ata_timing *, int, int);
extern void ata_timing_merge(const struct ata_timing *,
			     const struct ata_timing *, struct ata_timing *,
			     unsigned int);
1235
extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
A
Alan Cox 已提交
1236

T
Tejun Heo 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245
/* PCI */
#ifdef CONFIG_PCI
struct pci_dev;

struct pci_bits {
	unsigned int		reg;	/* PCI config register to read */
	unsigned int		width;	/* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
	unsigned long		mask;
	unsigned long		val;
A
Alan Cox 已提交
1246 1247
};

T
Tejun Heo 已提交
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
extern void ata_pci_remove_one(struct pci_dev *pdev);

#ifdef CONFIG_PM
extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
extern int ata_pci_device_resume(struct pci_dev *pdev);
#endif /* CONFIG_PM */
#endif /* CONFIG_PCI */

1259 1260 1261 1262
struct platform_device;

extern int ata_platform_remove_one(struct platform_device *pdev);

T
Tejun Heo 已提交
1263 1264 1265
/*
 * ACPI - drivers/ata/libata-acpi.c
 */
A
Alan Cox 已提交
1266
#ifdef CONFIG_ATA_ACPI
1267 1268 1269 1270 1271 1272
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
{
	if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
		return &ap->__acpi_init_gtm;
	return NULL;
}
1273 1274
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
1275 1276
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
				    const struct ata_acpi_gtm *gtm);
1277
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
A
Alan Cox 已提交
1278
#else
1279 1280 1281 1282
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
{
	return NULL;
}
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300

static inline int ata_acpi_stm(const struct ata_port *ap,
			       struct ata_acpi_gtm *stm)
{
	return -ENOSYS;
}

static inline int ata_acpi_gtm(const struct ata_port *ap,
			       struct ata_acpi_gtm *stm)
{
	return -ENOSYS;
}

static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
					const struct ata_acpi_gtm *gtm)
{
	return 0;
}
1301 1302 1303 1304 1305 1306

static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
				      const struct ata_acpi_gtm *gtm)
{
	return 0;
}
A
Alan Cox 已提交
1307
#endif
L
Linus Torvalds 已提交
1308

1309
/*
T
Tejun Heo 已提交
1310
 * EH - drivers/ata/libata-eh.c
1311
 */
1312
extern void ata_port_schedule_eh(struct ata_port *ap);
1313
extern void ata_port_wait_eh(struct ata_port *ap);
1314
extern int ata_link_abort(struct ata_link *link);
1315
extern int ata_port_abort(struct ata_port *ap);
1316
extern int ata_port_freeze(struct ata_port *ap);
1317
extern int sata_async_notification(struct ata_port *ap);
1318 1319 1320

extern void ata_eh_freeze_port(struct ata_port *ap);
extern void ata_eh_thaw_port(struct ata_port *ap);
1321

1322 1323
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
1324
extern void ata_eh_analyze_ncq_error(struct ata_link *link);
1325

1326 1327 1328
extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
		      ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
		      ata_postreset_fn_t postreset);
1329
extern void ata_std_error_handler(struct ata_port *ap);
1330 1331
extern void ata_std_sched_eh(struct ata_port *ap);
extern void ata_std_end_eh(struct ata_port *ap);
1332
extern int ata_link_nr_enabled(struct ata_link *link);
T
Tejun Heo 已提交
1333

1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
/*
 * Base operations to inherit from and initializers for sht
 *
 * Operations
 *
 * base  : Common to all libata drivers.
 * sata  : SATA controllers w/ native interface.
 * pmp   : SATA controllers w/ PMP support.
 * sff   : SFF ATA controllers w/o BMDMA support.
 * bmdma : SFF ATA controllers w/ BMDMA support.
 *
 * sht initializers
 *
 * BASE  : Common to all libata drivers.  The user must set
 *	   sg_tablesize and dma_boundary.
 * PIO   : SFF ATA controllers w/ only PIO support.
 * BMDMA : SFF ATA controllers w/ BMDMA support.  sg_tablesize and
 *	   dma_boundary are set to BMDMA limits.
 * NCQ   : SATA controllers supporting NCQ.  The user must set
 *	   sg_tablesize, dma_boundary and can_queue.
 */
extern const struct ata_port_operations ata_base_port_ops;
extern const struct ata_port_operations sata_port_ops;
1357
extern struct device_attribute *ata_common_sdev_attrs[];
1358

1359 1360 1361 1362 1363 1364
/*
 * All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated
 * by the edge drivers.  Because the 'module' field of sht must be the
 * edge driver's module reference, otherwise the driver can be unloaded
 * even if the scsi_device is being accessed.
 */
1365 1366 1367 1368 1369 1370
#define ATA_BASE_SHT(drv_name)					\
	.module			= THIS_MODULE,			\
	.name			= drv_name,			\
	.ioctl			= ata_scsi_ioctl,		\
	.queuecommand		= ata_scsi_queuecmd,		\
	.can_queue		= ATA_DEF_QUEUE,		\
S
Shaohua Li 已提交
1371
	.tag_alloc_policy	= BLK_TAG_ALLOC_RR,		\
1372 1373 1374 1375 1376 1377
	.this_id		= ATA_SHT_THIS_ID,		\
	.emulated		= ATA_SHT_EMULATED,		\
	.use_clustering		= ATA_SHT_USE_CLUSTERING,	\
	.proc_name		= drv_name,			\
	.slave_configure	= ata_scsi_slave_config,	\
	.slave_destroy		= ata_scsi_slave_destroy,	\
1378
	.bios_param		= ata_std_bios_param,		\
1379
	.unlock_native_capacity	= ata_scsi_unlock_native_capacity, \
1380
	.sdev_attrs		= ata_common_sdev_attrs
1381 1382 1383 1384 1385

#define ATA_NCQ_SHT(drv_name)					\
	ATA_BASE_SHT(drv_name),					\
	.change_queue_depth	= ata_scsi_change_queue_depth

T
Tejun Heo 已提交
1386 1387 1388
/*
 * PMP helpers
 */
T
Tejun Heo 已提交
1389
#ifdef CONFIG_SATA_PMP
T
Tejun Heo 已提交
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
static inline bool sata_pmp_supported(struct ata_port *ap)
{
	return ap->flags & ATA_FLAG_PMP;
}

static inline bool sata_pmp_attached(struct ata_port *ap)
{
	return ap->nr_pmp_links != 0;
}

static inline int ata_is_host_link(const struct ata_link *link)
{
T
Tejun Heo 已提交
1402
	return link == &link->ap->link || link == link->ap->slave_link;
T
Tejun Heo 已提交
1403
}
T
Tejun Heo 已提交
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
#else /* CONFIG_SATA_PMP */
static inline bool sata_pmp_supported(struct ata_port *ap)
{
	return false;
}

static inline bool sata_pmp_attached(struct ata_port *ap)
{
	return false;
}

static inline int ata_is_host_link(const struct ata_link *link)
{
	return 1;
}
#endif /* CONFIG_SATA_PMP */
T
Tejun Heo 已提交
1420 1421 1422 1423 1424 1425 1426 1427

static inline int sata_srst_pmp(struct ata_link *link)
{
	if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
		return SATA_PMP_CTRL_PORT;
	return link->pmp;
}

1428 1429 1430
/*
 * printk helpers
 */
1431
__printf(3, 4)
1432 1433
void ata_port_printk(const struct ata_port *ap, const char *level,
		     const char *fmt, ...);
1434
__printf(3, 4)
1435 1436
void ata_link_printk(const struct ata_link *link, const char *level,
		     const char *fmt, ...);
1437
__printf(3, 4)
1438 1439
void ata_dev_printk(const struct ata_device *dev, const char *level,
		    const char *fmt, ...);
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472

#define ata_port_err(ap, fmt, ...)				\
	ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
#define ata_port_warn(ap, fmt, ...)				\
	ata_port_printk(ap, KERN_WARNING, fmt, ##__VA_ARGS__)
#define ata_port_notice(ap, fmt, ...)				\
	ata_port_printk(ap, KERN_NOTICE, fmt, ##__VA_ARGS__)
#define ata_port_info(ap, fmt, ...)				\
	ata_port_printk(ap, KERN_INFO, fmt, ##__VA_ARGS__)
#define ata_port_dbg(ap, fmt, ...)				\
	ata_port_printk(ap, KERN_DEBUG, fmt, ##__VA_ARGS__)

#define ata_link_err(link, fmt, ...)				\
	ata_link_printk(link, KERN_ERR, fmt, ##__VA_ARGS__)
#define ata_link_warn(link, fmt, ...)				\
	ata_link_printk(link, KERN_WARNING, fmt, ##__VA_ARGS__)
#define ata_link_notice(link, fmt, ...)				\
	ata_link_printk(link, KERN_NOTICE, fmt, ##__VA_ARGS__)
#define ata_link_info(link, fmt, ...)				\
	ata_link_printk(link, KERN_INFO, fmt, ##__VA_ARGS__)
#define ata_link_dbg(link, fmt, ...)				\
	ata_link_printk(link, KERN_DEBUG, fmt, ##__VA_ARGS__)

#define ata_dev_err(dev, fmt, ...)				\
	ata_dev_printk(dev, KERN_ERR, fmt, ##__VA_ARGS__)
#define ata_dev_warn(dev, fmt, ...)				\
	ata_dev_printk(dev, KERN_WARNING, fmt, ##__VA_ARGS__)
#define ata_dev_notice(dev, fmt, ...)				\
	ata_dev_printk(dev, KERN_NOTICE, fmt, ##__VA_ARGS__)
#define ata_dev_info(dev, fmt, ...)				\
	ata_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
#define ata_dev_dbg(dev, fmt, ...)				\
	ata_dev_printk(dev, KERN_DEBUG, fmt, ##__VA_ARGS__)
L
Linus Torvalds 已提交
1473

1474 1475
void ata_print_version(const struct device *dev, const char *version);

1476 1477 1478
/*
 * ata_eh_info helpers
 */
1479 1480 1481 1482
extern __printf(2, 3)
void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
extern __printf(2, 3)
void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
T
Tejun Heo 已提交
1483
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
1484

1485 1486
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
{
1487
	ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
1488
	ehi->flags |= ATA_EHI_HOTPLUGGED;
1489
	ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
1490 1491 1492
	ehi->err_mask |= AC_ERR_ATA_BUS;
}

1493 1494 1495
/*
 * port description helpers
 */
1496 1497
extern __printf(2, 3)
void ata_port_desc(struct ata_port *ap, const char *fmt, ...);
1498 1499 1500 1501 1502
#ifdef CONFIG_PCI
extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
			       const char *name);
#endif

L
Linus Torvalds 已提交
1503 1504 1505 1506 1507
static inline unsigned int ata_tag_valid(unsigned int tag)
{
	return (tag < ATA_MAX_QUEUE) ? 1 : 0;
}

1508 1509
static inline unsigned int ata_tag_internal(unsigned int tag)
{
1510
	return tag == ATA_TAG_INTERNAL;
1511 1512
}

1513 1514 1515
/*
 * device helpers
 */
1516
static inline unsigned int ata_class_enabled(unsigned int class)
1517
{
1518
	return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
H
Hannes Reinecke 已提交
1519 1520
		class == ATA_DEV_PMP || class == ATA_DEV_SEMB ||
		class == ATA_DEV_ZAC;
1521 1522
}

1523
static inline unsigned int ata_class_disabled(unsigned int class)
L
Linus Torvalds 已提交
1524
{
1525 1526
	return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
		class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP;
1527 1528
}

1529 1530 1531 1532 1533
static inline unsigned int ata_class_absent(unsigned int class)
{
	return !ata_class_enabled(class) && !ata_class_disabled(class);
}

1534 1535 1536 1537 1538 1539 1540 1541
static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
{
	return ata_class_enabled(dev->class);
}

static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
{
	return ata_class_disabled(dev->class);
L
Linus Torvalds 已提交
1542 1543
}

1544 1545 1546 1547 1548
static inline unsigned int ata_dev_absent(const struct ata_device *dev)
{
	return ata_class_absent(dev->class);
}

1549
/*
1550
 * link helpers
1551
 */
1552
static inline int ata_link_max_devices(const struct ata_link *link)
1553
{
T
Tejun Heo 已提交
1554
	if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
1555 1556 1557 1558
		return 2;
	return 1;
}

1559 1560 1561 1562 1563
static inline int ata_link_active(struct ata_link *link)
{
	return ata_tag_valid(link->active_tag) || link->sactive;
}

T
Tejun Heo 已提交
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
/*
 * Iterators
 *
 * ATA_LITER_* constants are used to select link iteration mode and
 * ATA_DITER_* device iteration mode.
 *
 * For a custom iteration directly using ata_{link|dev}_next(), if
 * @link or @dev, respectively, is NULL, the first element is
 * returned.  @dev and @link can be any valid device or link and the
 * next element according to the iteration mode will be returned.
 * After the last element, NULL is returned.
 */
enum ata_link_iter_mode {
	ATA_LITER_EDGE,		/* if present, PMP links only; otherwise,
				 * host link.  no slave link */
	ATA_LITER_HOST_FIRST,	/* host link followed by PMP or slave links */
	ATA_LITER_PMP_FIRST,	/* PMP links followed by host link,
				 * slave link still comes after host link */
};

enum ata_dev_iter_mode {
	ATA_DITER_ENABLED,
	ATA_DITER_ENABLED_REVERSE,
	ATA_DITER_ALL,
	ATA_DITER_ALL_REVERSE,
};

extern struct ata_link *ata_link_next(struct ata_link *link,
				      struct ata_port *ap,
				      enum ata_link_iter_mode mode);

extern struct ata_device *ata_dev_next(struct ata_device *dev,
				       struct ata_link *link,
				       enum ata_dev_iter_mode mode);

/*
 * Shortcut notation for iterations
 *
 * ata_for_each_link() iterates over each link of @ap according to
 * @mode.  @link points to the current link in the loop.  @link is
 * NULL after loop termination.  ata_for_each_dev() works the same way
 * except that it iterates over each device of @link.
 *
 * Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be
 * specified when using the following shorthand notations.  Only the
 * mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be
 * specified.  This not only increases brevity but also makes it
 * impossible to use ATA_LITER_* for device iteration or vice-versa.
 */
#define ata_for_each_link(link, ap, mode) \
	for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \
	     (link) = ata_link_next((link), (ap), ATA_LITER_##mode))

#define ata_for_each_dev(dev, link, mode) \
	for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \
	     (dev) = ata_dev_next((dev), (link), ATA_DITER_##mode))
1620

1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
/**
 *	ata_ncq_enabled - Test whether NCQ is enabled
 *	@dev: ATA device to test for
 *
 *	LOCKING:
 *	spin_lock_irqsave(host lock)
 *
 *	RETURNS:
 *	1 if NCQ is enabled for @dev, 0 otherwise.
 */
static inline int ata_ncq_enabled(struct ata_device *dev)
{
	return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
			      ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
}
E
Edward Falk 已提交
1636

1637 1638 1639 1640 1641 1642 1643
static inline bool ata_fpdma_dsm_supported(struct ata_device *dev)
{
	return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
		(dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &
		 ATA_LOG_NCQ_SEND_RECV_DSM_TRIM);
}

L
Linus Torvalds 已提交
1644 1645 1646 1647 1648
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
{
	qc->tf.ctl |= ATA_NIEN;
}

1649 1650
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
						       unsigned int tag)
L
Linus Torvalds 已提交
1651 1652 1653 1654 1655 1656
{
	if (likely(ata_tag_valid(tag)))
		return &ap->qcmd[tag];
	return NULL;
}

1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
						     unsigned int tag)
{
	struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);

	if (unlikely(!qc) || !ap->ops->error_handler)
		return qc;

	if ((qc->flags & (ATA_QCFLAG_ACTIVE |
			  ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
		return qc;

	return NULL;
}

1672 1673 1674 1675 1676
static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc)
{
	return qc->nbytes - min(qc->extrabytes, qc->nbytes);
}

T
Tejun Heo 已提交
1677
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
L
Linus Torvalds 已提交
1678 1679 1680
{
	memset(tf, 0, sizeof(*tf));

1681
#ifdef CONFIG_ATA_SFF
T
Tejun Heo 已提交
1682
	tf->ctl = dev->link->ap->ctl;
1683 1684 1685
#else
	tf->ctl = ATA_DEVCTL_OBS;
#endif
T
Tejun Heo 已提交
1686
	if (dev->devno == 0)
L
Linus Torvalds 已提交
1687 1688 1689 1690 1691
		tf->device = ATA_DEVICE_OBS;
	else
		tf->device = ATA_DEVICE_OBS | ATA_DEV1;
}

J
Jeff Garzik 已提交
1692 1693
static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
{
1694
	qc->dma_dir = DMA_NONE;
T
Tejun Heo 已提交
1695
	qc->sg = NULL;
J
Jeff Garzik 已提交
1696
	qc->flags = 0;
J
Jens Axboe 已提交
1697 1698
	qc->cursg = NULL;
	qc->cursg_ofs = 0;
1699
	qc->nbytes = qc->extrabytes = qc->curbytes = 0;
B
Brian King 已提交
1700
	qc->n_elem = 0;
1701
	qc->err_mask = 0;
1702
	qc->sect_size = ATA_SECT_SIZE;
J
Jeff Garzik 已提交
1703

T
Tejun Heo 已提交
1704
	ata_tf_init(qc->dev, &qc->tf);
1705 1706 1707 1708

	/* init result_tf such that it indicates normal completion */
	qc->result_tf.command = ATA_DRDY;
	qc->result_tf.feature = 0;
J
Jeff Garzik 已提交
1709 1710
}

J
Jeff Garzik 已提交
1711
static inline int ata_try_flush_cache(const struct ata_device *dev)
L
Linus Torvalds 已提交
1712 1713 1714 1715 1716 1717
{
	return ata_id_wcache_enabled(dev->id) ||
	       ata_id_has_flush(dev->id) ||
	       ata_id_has_flush_ext(dev->id);
}

1718 1719
static inline unsigned int ac_err_mask(u8 status)
{
1720
	if (status & (ATA_BUSY | ATA_DRQ))
1721
		return AC_ERR_HSM;
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
	if (status & (ATA_ERR | ATA_DF))
		return AC_ERR_DEV;
	return 0;
}

static inline unsigned int __ac_err_mask(u8 status)
{
	unsigned int mask = ac_err_mask(status);
	if (mask == 0)
		return AC_ERR_OTHER;
	return mask;
}

1735 1736
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
{
1737
	return *(struct ata_port **)&host->hostdata[0];
1738 1739
}

1740 1741
static inline int ata_check_ready(u8 status)
{
1742 1743
	if (!(status & ATA_BUSY))
		return 1;
1744 1745 1746 1747 1748

	/* 0xff indicates either no device or device not ready */
	if (status == 0xff)
		return -ENODEV;

1749
	return 0;
1750 1751
}

1752 1753 1754 1755 1756 1757
static inline unsigned long ata_deadline(unsigned long from_jiffies,
					 unsigned long timeout_msecs)
{
	return from_jiffies + msecs_to_jiffies(timeout_msecs);
}

1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
/* Don't open code these in drivers as there are traps. Firstly the range may
   change in future hardware and specs, secondly 0xFF means 'no DMA' but is
   > UDMA_0. Dyma ddreigiau */

static inline int ata_using_mwdma(struct ata_device *adev)
{
	if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
		return 1;
	return 0;
}

static inline int ata_using_udma(struct ata_device *adev)
{
	if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
		return 1;
	return 0;
}

static inline int ata_dma_enabled(struct ata_device *adev)
{
	return (adev->dma_mode == 0xFF ? 0 : 1);
}
1780 1781 1782 1783

/**************************************************************************
 * PMP - drivers/ata/libata-pmp.c
 */
T
Tejun Heo 已提交
1784 1785
#ifdef CONFIG_SATA_PMP

1786 1787 1788 1789 1790
extern const struct ata_port_operations sata_pmp_port_ops;

extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
extern void sata_pmp_error_handler(struct ata_port *ap);

T
Tejun Heo 已提交
1791 1792 1793 1794 1795 1796 1797 1798
#else /* CONFIG_SATA_PMP */

#define sata_pmp_port_ops		sata_port_ops
#define sata_pmp_qc_defer_cmd_switch	ata_std_qc_defer
#define sata_pmp_error_handler		ata_std_error_handler

#endif /* CONFIG_SATA_PMP */

1799

T
Tejun Heo 已提交
1800 1801 1802
/**************************************************************************
 * SFF - drivers/ata/libata-sff.c
 */
T
Tejun Heo 已提交
1803 1804
#ifdef CONFIG_ATA_SFF

T
Tejun Heo 已提交
1805
extern const struct ata_port_operations ata_sff_port_ops;
A
Alan Cox 已提交
1806
extern const struct ata_port_operations ata_bmdma32_port_ops;
T
Tejun Heo 已提交
1807 1808 1809 1810 1811 1812 1813

/* PIO only, sg_tablesize and dma_boundary limits can be removed */
#define ATA_PIO_SHT(drv_name)					\
	ATA_BASE_SHT(drv_name),					\
	.sg_tablesize		= LIBATA_MAX_PRD,		\
	.dma_boundary		= ATA_DMA_BOUNDARY

T
Tejun Heo 已提交
1814 1815
extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
extern u8 ata_sff_check_status(struct ata_port *ap);
1816 1817
extern void ata_sff_pause(struct ata_port *ap);
extern void ata_sff_dma_pause(struct ata_port *ap);
T
Tejun Heo 已提交
1818 1819
extern int ata_sff_busy_sleep(struct ata_port *ap,
			      unsigned long timeout_pat, unsigned long timeout);
1820
extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
T
Tejun Heo 已提交
1821 1822 1823 1824 1825
extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
extern void ata_sff_exec_command(struct ata_port *ap,
				 const struct ata_taskfile *tf);
extern unsigned int ata_sff_data_xfer(struct ata_device *dev,
T
Tejun Heo 已提交
1826
			unsigned char *buf, unsigned int buflen, int rw);
A
Alan Cox 已提交
1827 1828
extern unsigned int ata_sff_data_xfer32(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
T
Tejun Heo 已提交
1829
extern unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev,
T
Tejun Heo 已提交
1830
			unsigned char *buf, unsigned int buflen, int rw);
1831
extern void ata_sff_irq_on(struct ata_port *ap);
T
Tejun Heo 已提交
1832 1833 1834
extern void ata_sff_irq_clear(struct ata_port *ap);
extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
			    u8 status, int in_wq);
1835 1836 1837
extern void ata_sff_queue_work(struct work_struct *work);
extern void ata_sff_queue_delayed_work(struct delayed_work *dwork,
		unsigned long delay);
1838
extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);
T
Tejun Heo 已提交
1839
extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
1840
extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
1841
extern unsigned int ata_sff_port_intr(struct ata_port *ap,
T
Tejun Heo 已提交
1842 1843
				      struct ata_queued_cmd *qc);
extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
A
Alan Cox 已提交
1844
extern void ata_sff_lost_interrupt(struct ata_port *ap);
T
Tejun Heo 已提交
1845 1846 1847 1848 1849
extern void ata_sff_freeze(struct ata_port *ap);
extern void ata_sff_thaw(struct ata_port *ap);
extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
					  u8 *r_err);
1850 1851
extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
				    unsigned long deadline);
T
Tejun Heo 已提交
1852
extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
T
Tejun Heo 已提交
1853
			     unsigned long deadline);
T
Tejun Heo 已提交
1854 1855 1856
extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline);
extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
A
Alan Cox 已提交
1857
extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
T
Tejun Heo 已提交
1858 1859
extern void ata_sff_error_handler(struct ata_port *ap);
extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
T
Tejun Heo 已提交
1860
#ifdef CONFIG_PCI
T
Tejun Heo 已提交
1861 1862
extern int ata_pci_sff_init_host(struct ata_host *host);
extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
T
Tejun Heo 已提交
1863 1864
				    const struct ata_port_info * const * ppi,
				    struct ata_host **r_host);
T
Tejun Heo 已提交
1865
extern int ata_pci_sff_activate_host(struct ata_host *host,
T
Tejun Heo 已提交
1866 1867
				     irq_handler_t irq_handler,
				     struct scsi_host_template *sht);
T
Tejun Heo 已提交
1868
extern int ata_pci_sff_init_one(struct pci_dev *pdev,
1869 1870
		const struct ata_port_info * const * ppi,
		struct scsi_host_template *sht, void *host_priv, int hflags);
T
Tejun Heo 已提交
1871 1872
#endif /* CONFIG_PCI */

T
Tejun Heo 已提交
1873 1874 1875 1876 1877 1878 1879 1880 1881
#ifdef CONFIG_ATA_BMDMA

extern const struct ata_port_operations ata_bmdma_port_ops;

#define ATA_BMDMA_SHT(drv_name)					\
	ATA_BASE_SHT(drv_name),					\
	.sg_tablesize		= LIBATA_MAX_PRD,		\
	.dma_boundary		= ATA_DMA_BOUNDARY

1882
extern void ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
1883
extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
1884
extern void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
1885 1886 1887
extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
				      struct ata_queued_cmd *qc);
extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);
T
Tejun Heo 已提交
1888 1889
extern void ata_bmdma_error_handler(struct ata_port *ap);
extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
1890
extern void ata_bmdma_irq_clear(struct ata_port *ap);
1891 1892 1893 1894
extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
extern void ata_bmdma_start(struct ata_queued_cmd *qc);
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
extern u8 ata_bmdma_status(struct ata_port *ap);
1895 1896
extern int ata_bmdma_port_start(struct ata_port *ap);
extern int ata_bmdma_port_start32(struct ata_port *ap);
1897 1898 1899

#ifdef CONFIG_PCI
extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
1900
extern void ata_pci_bmdma_init(struct ata_host *host);
T
Tejun Heo 已提交
1901 1902 1903 1904 1905 1906 1907
extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
				      const struct ata_port_info * const * ppi,
				      struct ata_host **r_host);
extern int ata_pci_bmdma_init_one(struct pci_dev *pdev,
				  const struct ata_port_info * const * ppi,
				  struct scsi_host_template *sht,
				  void *host_priv, int hflags);
1908
#endif /* CONFIG_PCI */
T
Tejun Heo 已提交
1909
#endif /* CONFIG_ATA_BMDMA */
1910

T
Tejun Heo 已提交
1911
/**
T
Tejun Heo 已提交
1912
 *	ata_sff_busy_wait - Wait for a port status register
T
Tejun Heo 已提交
1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
 *	@ap: Port to wait for.
 *	@bits: bits that must be clear
 *	@max: number of 10uS waits to perform
 *
 *	Waits up to max*10 microseconds for the selected bits in the port's
 *	status register to be cleared.
 *	Returns final value of status register.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
T
Tejun Heo 已提交
1924 1925
static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
				   unsigned int max)
T
Tejun Heo 已提交
1926 1927 1928 1929 1930
{
	u8 status;

	do {
		udelay(10);
T
Tejun Heo 已提交
1931
		status = ap->ops->sff_check_status(ap);
T
Tejun Heo 已提交
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949
		max--;
	} while (status != 0xff && (status & bits) && (max > 0));

	return status;
}

/**
 *	ata_wait_idle - Wait for a port to be idle.
 *	@ap: Port to wait for.
 *
 *	Waits up to 10ms for port's BUSY and DRQ signals to clear.
 *	Returns final value of status register.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
static inline u8 ata_wait_idle(struct ata_port *ap)
{
T
Tejun Heo 已提交
1950
	u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
T
Tejun Heo 已提交
1951 1952 1953 1954 1955 1956 1957 1958 1959

#ifdef ATA_DEBUG
	if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
		ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
				status);
#endif

	return status;
}
T
Tejun Heo 已提交
1960
#endif /* CONFIG_ATA_SFF */
T
Tejun Heo 已提交
1961

L
Linus Torvalds 已提交
1962
#endif /* __LINUX_LIBATA_H__ */