ata.h 32.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2

/*
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2004 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.*
 *
 *  Hardware documentation available from http://www.t13.org/
 *
Linus Torvalds's avatar
Linus Torvalds committed
27 28 29 30 31
 */

#ifndef __LINUX_ATA_H__
#define __LINUX_ATA_H__

32 33
#include <linux/kernel.h>
#include <linux/string.h>
Linus Torvalds's avatar
Linus Torvalds committed
34
#include <linux/types.h>
35
#include <asm/byteorder.h>
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39 40 41 42 43 44 45

/* defines only for the constants which don't work well as enums */
#define ATA_DMA_BOUNDARY	0xffffUL
#define ATA_DMA_MASK		0xffffffffULL

enum {
	/* various global constants */
	ATA_MAX_DEVICES		= 2,	/* per bus/port */
	ATA_MAX_PRD		= 256,	/* we could make these 256/256 */
	ATA_SECT_SIZE		= 512,
46
	ATA_MAX_SECTORS_128	= 128,
47
	ATA_MAX_SECTORS		= 256,
48
	ATA_MAX_SECTORS_1024    = 1024,
49
	ATA_MAX_SECTORS_LBA48	= 65535,/* avoid count to be 0000h */
50
	ATA_MAX_SECTORS_TAPE	= 65535,
51
	ATA_MAX_TRIM_RNUM	= 64,	/* 512-byte payload / (6-byte LBA + 2-byte range per entry) */
Linus Torvalds's avatar
Linus Torvalds committed
52 53

	ATA_ID_WORDS		= 256,
54 55 56 57
	ATA_ID_CONFIG		= 0,
	ATA_ID_CYLS		= 1,
	ATA_ID_HEADS		= 3,
	ATA_ID_SECTORS		= 6,
58
	ATA_ID_SERNO		= 10,
59
	ATA_ID_BUF_SIZE		= 21,
60 61
	ATA_ID_FW_REV		= 23,
	ATA_ID_PROD		= 27,
62 63 64
	ATA_ID_MAX_MULTSECT	= 47,
	ATA_ID_DWORD_IO		= 48,
	ATA_ID_CAPABILITY	= 49,
65
	ATA_ID_OLD_PIO_MODES	= 51,
66
	ATA_ID_OLD_DMA_MODES	= 52,
67
	ATA_ID_FIELD_VALID	= 53,
68 69 70 71 72 73
	ATA_ID_CUR_CYLS		= 54,
	ATA_ID_CUR_HEADS	= 55,
	ATA_ID_CUR_SECTORS	= 56,
	ATA_ID_MULTSECT		= 59,
	ATA_ID_LBA_CAPACITY	= 60,
	ATA_ID_SWDMA_MODES	= 62,
Linus Torvalds's avatar
Linus Torvalds committed
74
	ATA_ID_MWDMA_MODES	= 63,
75 76
	ATA_ID_PIO_MODES	= 64,
	ATA_ID_EIDE_DMA_MIN	= 65,
77
	ATA_ID_EIDE_DMA_TIME	= 66,
78 79
	ATA_ID_EIDE_PIO		= 67,
	ATA_ID_EIDE_PIO_IORDY	= 68,
80
	ATA_ID_ADDITIONAL_SUPP	= 69,
81
	ATA_ID_QUEUE_DEPTH	= 75,
82 83 84
	ATA_ID_SATA_CAPABILITY	= 76,
	ATA_ID_SATA_CAPABILITY_2	= 77,
	ATA_ID_FEATURE_SUPP	= 78,
85
	ATA_ID_MAJOR_VER	= 80,
86 87 88 89 90 91 92 93 94 95
	ATA_ID_COMMAND_SET_1	= 82,
	ATA_ID_COMMAND_SET_2	= 83,
	ATA_ID_CFSSE		= 84,
	ATA_ID_CFS_ENABLE_1	= 85,
	ATA_ID_CFS_ENABLE_2	= 86,
	ATA_ID_CSF_DEFAULT	= 87,
	ATA_ID_UDMA_MODES	= 88,
	ATA_ID_HW_CONFIG	= 93,
	ATA_ID_SPG		= 98,
	ATA_ID_LBA_CAPACITY_2	= 100,
96
	ATA_ID_SECTOR_SIZE	= 106,
97
	ATA_ID_WWN		= 108,
98
	ATA_ID_LOGICAL_SECTOR_SIZE	= 117,	/* and 118 */
99 100
	ATA_ID_COMMAND_SET_3	= 119,
	ATA_ID_COMMAND_SET_4	= 120,
101 102 103 104
	ATA_ID_LAST_LUN		= 126,
	ATA_ID_DLF		= 128,
	ATA_ID_CSFO		= 129,
	ATA_ID_CFA_POWER	= 160,
105 106
	ATA_ID_CFA_KEY_MGMT	= 162,
	ATA_ID_CFA_MODES	= 163,
107
	ATA_ID_DATA_SET_MGMT	= 169,
108
	ATA_ID_ROT_SPEED	= 217,
Linus Torvalds's avatar
Linus Torvalds committed
109 110
	ATA_ID_PIO4		= (1 << 1),

111 112 113
	ATA_ID_SERNO_LEN	= 20,
	ATA_ID_FW_REV_LEN	= 8,
	ATA_ID_PROD_LEN		= 40,
114
	ATA_ID_WWN_LEN		= 8,
115

Linus Torvalds's avatar
Linus Torvalds committed
116
	ATA_PCI_CTL_OFS		= 2,
117 118 119 120 121 122 123 124 125

	ATA_PIO0		= (1 << 0),
	ATA_PIO1		= ATA_PIO0 | (1 << 1),
	ATA_PIO2		= ATA_PIO1 | (1 << 2),
	ATA_PIO3		= ATA_PIO2 | (1 << 3),
	ATA_PIO4		= ATA_PIO3 | (1 << 4),
	ATA_PIO5		= ATA_PIO4 | (1 << 5),
	ATA_PIO6		= ATA_PIO5 | (1 << 6),

126 127
	ATA_PIO4_ONLY		= (1 << 4),

128 129 130 131 132 133 134 135 136
	ATA_SWDMA0		= (1 << 0),
	ATA_SWDMA1		= ATA_SWDMA0 | (1 << 1),
	ATA_SWDMA2		= ATA_SWDMA1 | (1 << 2),

	ATA_SWDMA2_ONLY		= (1 << 2),

	ATA_MWDMA0		= (1 << 0),
	ATA_MWDMA1		= ATA_MWDMA0 | (1 << 1),
	ATA_MWDMA2		= ATA_MWDMA1 | (1 << 2),
137 138
	ATA_MWDMA3		= ATA_MWDMA2 | (1 << 3),
	ATA_MWDMA4		= ATA_MWDMA3 | (1 << 4),
139 140 141 142

	ATA_MWDMA12_ONLY	= (1 << 1) | (1 << 2),
	ATA_MWDMA2_ONLY		= (1 << 2),

Linus Torvalds's avatar
Linus Torvalds committed
143 144 145 146 147 148 149 150 151 152
	ATA_UDMA0		= (1 << 0),
	ATA_UDMA1		= ATA_UDMA0 | (1 << 1),
	ATA_UDMA2		= ATA_UDMA1 | (1 << 2),
	ATA_UDMA3		= ATA_UDMA2 | (1 << 3),
	ATA_UDMA4		= ATA_UDMA3 | (1 << 4),
	ATA_UDMA5		= ATA_UDMA4 | (1 << 5),
	ATA_UDMA6		= ATA_UDMA5 | (1 << 6),
	ATA_UDMA7		= ATA_UDMA6 | (1 << 7),
	/* ATA_UDMA7 is just for completeness... doesn't exist (yet?).  */

153 154
	ATA_UDMA24_ONLY		= (1 << 2) | (1 << 4),

Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
	ATA_UDMA_MASK_40C	= ATA_UDMA2,	/* udma0-2 */

	/* DMA-related */
	ATA_PRD_SZ		= 8,
	ATA_PRD_TBL_SZ		= (ATA_MAX_PRD * ATA_PRD_SZ),
	ATA_PRD_EOT		= (1 << 31),	/* end-of-table flag */

	ATA_DMA_TABLE_OFS	= 4,
	ATA_DMA_STATUS		= 2,
	ATA_DMA_CMD		= 0,
	ATA_DMA_WR		= (1 << 3),
	ATA_DMA_START		= (1 << 0),
	ATA_DMA_INTR		= (1 << 2),
	ATA_DMA_ERR		= (1 << 1),
	ATA_DMA_ACTIVE		= (1 << 0),

	/* bits in ATA command block registers */
	ATA_HOB			= (1 << 7),	/* LBA48 selector */
	ATA_NIEN		= (1 << 1),	/* disable-irq flag */
	ATA_LBA			= (1 << 6),	/* LBA28 selector */
	ATA_DEV1		= (1 << 4),	/* Select Device 1 (slave) */
	ATA_DEVICE_OBS		= (1 << 7) | (1 << 5), /* obs bits in dev reg */
	ATA_DEVCTL_OBS		= (1 << 3),	/* obsolete bit in devctl reg */
	ATA_BUSY		= (1 << 7),	/* BSY status bit */
	ATA_DRDY		= (1 << 6),	/* device ready */
	ATA_DF			= (1 << 5),	/* device fault */
181
	ATA_DSC			= (1 << 4),	/* drive seek complete */
Linus Torvalds's avatar
Linus Torvalds committed
182
	ATA_DRQ			= (1 << 3),	/* data request i/o */
183
	ATA_CORR		= (1 << 2),	/* corrected data error */
184
	ATA_SENSE		= (1 << 1),	/* sense code available */
Linus Torvalds's avatar
Linus Torvalds committed
185 186
	ATA_ERR			= (1 << 0),	/* have an error */
	ATA_SRST		= (1 << 2),	/* software reset */
187
	ATA_ICRC		= (1 << 7),	/* interface CRC error */
188
	ATA_BBK			= ATA_ICRC,	/* pre-EIDE: block marked bad */
189
	ATA_UNC			= (1 << 6),	/* uncorrectable media error */
190
	ATA_MC			= (1 << 5),	/* media changed */
191
	ATA_IDNF		= (1 << 4),	/* ID not found */
192
	ATA_MCR			= (1 << 3),	/* media change requested */
Linus Torvalds's avatar
Linus Torvalds committed
193
	ATA_ABORTED		= (1 << 2),	/* command aborted */
194 195 196 197 198 199 200
	ATA_TRK0NF		= (1 << 1),	/* track 0 not found */
	ATA_AMNF		= (1 << 0),	/* address mark not found */
	ATAPI_LFS		= 0xF0,		/* last failed sense */
	ATAPI_EOM		= ATA_TRK0NF,	/* end of media */
	ATAPI_ILI		= ATA_AMNF,	/* illegal length indication */
	ATAPI_IO		= (1 << 1),
	ATAPI_COD		= (1 << 0),
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

	/* ATA command block registers */
	ATA_REG_DATA		= 0x00,
	ATA_REG_ERR		= 0x01,
	ATA_REG_NSECT		= 0x02,
	ATA_REG_LBAL		= 0x03,
	ATA_REG_LBAM		= 0x04,
	ATA_REG_LBAH		= 0x05,
	ATA_REG_DEVICE		= 0x06,
	ATA_REG_STATUS		= 0x07,

	ATA_REG_FEATURE		= ATA_REG_ERR, /* and their aliases */
	ATA_REG_CMD		= ATA_REG_STATUS,
	ATA_REG_BYTEL		= ATA_REG_LBAM,
	ATA_REG_BYTEH		= ATA_REG_LBAH,
	ATA_REG_DEVSEL		= ATA_REG_DEVICE,
	ATA_REG_IRQ		= ATA_REG_NSECT,

	/* ATA device commands */
220
	ATA_CMD_DEV_RESET	= 0x08, /* ATAPI device reset */
Linus Torvalds's avatar
Linus Torvalds committed
221
	ATA_CMD_CHK_POWER	= 0xE5, /* check power mode */
222 223
	ATA_CMD_STANDBY		= 0xE2, /* place in standby power mode */
	ATA_CMD_IDLE		= 0xE3, /* place in idle power mode */
Linus Torvalds's avatar
Linus Torvalds committed
224
	ATA_CMD_EDD		= 0x90,	/* execute device diagnostic */
225
	ATA_CMD_DOWNLOAD_MICRO  = 0x92,
226
	ATA_CMD_DOWNLOAD_MICRO_DMA = 0x93,
227
	ATA_CMD_NOP		= 0x00,
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231
	ATA_CMD_FLUSH		= 0xE7,
	ATA_CMD_FLUSH_EXT	= 0xEA,
	ATA_CMD_ID_ATA		= 0xEC,
	ATA_CMD_ID_ATAPI	= 0xA1,
232
	ATA_CMD_SERVICE		= 0xA2,
Linus Torvalds's avatar
Linus Torvalds committed
233 234
	ATA_CMD_READ		= 0xC8,
	ATA_CMD_READ_EXT	= 0x25,
235 236 237
	ATA_CMD_READ_QUEUED	= 0x26,
	ATA_CMD_READ_STREAM_EXT	= 0x2B,
	ATA_CMD_READ_STREAM_DMA_EXT = 0x2A,
Linus Torvalds's avatar
Linus Torvalds committed
238 239
	ATA_CMD_WRITE		= 0xCA,
	ATA_CMD_WRITE_EXT	= 0x35,
240 241 242
	ATA_CMD_WRITE_QUEUED	= 0x36,
	ATA_CMD_WRITE_STREAM_EXT = 0x3B,
	ATA_CMD_WRITE_STREAM_DMA_EXT = 0x3A,
243
	ATA_CMD_WRITE_FUA_EXT	= 0x3D,
244
	ATA_CMD_WRITE_QUEUED_FUA_EXT = 0x3E,
245 246
	ATA_CMD_FPDMA_READ	= 0x60,
	ATA_CMD_FPDMA_WRITE	= 0x61,
247
	ATA_CMD_NCQ_NON_DATA	= 0x63,
248 249
	ATA_CMD_FPDMA_SEND	= 0x64,
	ATA_CMD_FPDMA_RECV	= 0x65,
Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253
	ATA_CMD_PIO_READ	= 0x20,
	ATA_CMD_PIO_READ_EXT	= 0x24,
	ATA_CMD_PIO_WRITE	= 0x30,
	ATA_CMD_PIO_WRITE_EXT	= 0x34,
254 255 256 257
	ATA_CMD_READ_MULTI	= 0xC4,
	ATA_CMD_READ_MULTI_EXT	= 0x29,
	ATA_CMD_WRITE_MULTI	= 0xC5,
	ATA_CMD_WRITE_MULTI_EXT	= 0x39,
258
	ATA_CMD_WRITE_MULTI_FUA_EXT = 0xCE,
Linus Torvalds's avatar
Linus Torvalds committed
259
	ATA_CMD_SET_FEATURES	= 0xEF,
260
	ATA_CMD_SET_MULTI	= 0xC6,
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263
	ATA_CMD_PACKET		= 0xA0,
	ATA_CMD_VERIFY		= 0x40,
	ATA_CMD_VERIFY_EXT	= 0x42,
264
	ATA_CMD_WRITE_UNCORR_EXT = 0x45,
265 266
	ATA_CMD_STANDBYNOW1	= 0xE0,
	ATA_CMD_IDLEIMMEDIATE	= 0xE1,
267
	ATA_CMD_SLEEP		= 0xE6,
268
	ATA_CMD_INIT_DEV_PARAMS	= 0x91,
269 270
	ATA_CMD_READ_NATIVE_MAX	= 0xF8,
	ATA_CMD_READ_NATIVE_MAX_EXT = 0x27,
Alan Cox's avatar
Alan Cox committed
271 272
	ATA_CMD_SET_MAX		= 0xF9,
	ATA_CMD_SET_MAX_EXT	= 0x37,
273 274 275 276
	ATA_CMD_READ_LOG_EXT	= 0x2F,
	ATA_CMD_WRITE_LOG_EXT	= 0x3F,
	ATA_CMD_READ_LOG_DMA_EXT = 0x47,
	ATA_CMD_WRITE_LOG_DMA_EXT = 0x57,
277
	ATA_CMD_TRUSTED_NONDATA	= 0x5B,
278 279 280 281
	ATA_CMD_TRUSTED_RCV	= 0x5C,
	ATA_CMD_TRUSTED_RCV_DMA = 0x5D,
	ATA_CMD_TRUSTED_SND	= 0x5E,
	ATA_CMD_TRUSTED_SND_DMA = 0x5F,
282
	ATA_CMD_PMP_READ	= 0xE4,
283
	ATA_CMD_PMP_READ_DMA	= 0xE9,
284
	ATA_CMD_PMP_WRITE	= 0xE8,
285
	ATA_CMD_PMP_WRITE_DMA	= 0xEB,
286
	ATA_CMD_CONF_OVERLAY	= 0xB1,
287 288 289 290
	ATA_CMD_SEC_SET_PASS	= 0xF1,
	ATA_CMD_SEC_UNLOCK	= 0xF2,
	ATA_CMD_SEC_ERASE_PREP	= 0xF3,
	ATA_CMD_SEC_ERASE_UNIT	= 0xF4,
291
	ATA_CMD_SEC_FREEZE_LOCK	= 0xF5,
292 293
	ATA_CMD_SEC_DISABLE_PASS = 0xF6,
	ATA_CMD_CONFIG_STREAM	= 0x51,
294 295 296
	ATA_CMD_SMART		= 0xB0,
	ATA_CMD_MEDIA_LOCK	= 0xDE,
	ATA_CMD_MEDIA_UNLOCK	= 0xDF,
297
	ATA_CMD_DSM		= 0x06,
298 299 300 301 302 303
	ATA_CMD_CHK_MED_CRD_TYP = 0xD1,
	ATA_CMD_CFA_REQ_EXT_ERR = 0x03,
	ATA_CMD_CFA_WRITE_NE	= 0x38,
	ATA_CMD_CFA_TRANS_SECT	= 0x87,
	ATA_CMD_CFA_ERASE	= 0xC0,
	ATA_CMD_CFA_WRITE_MULT_NE = 0xCD,
304 305
	ATA_CMD_REQ_SENSE_DATA  = 0x0B,
	ATA_CMD_SANITIZE_DEVICE = 0xB4,
306
	ATA_CMD_ZAC_MGMT_IN	= 0x4A,
307
	ATA_CMD_ZAC_MGMT_OUT	= 0x9F,
308

309 310
	/* marked obsolete in the ATA/ATAPI-7 spec */
	ATA_CMD_RESTORE		= 0x10,
311

312 313
	/* Subcmds for ATA_CMD_FPDMA_RECV */
	ATA_SUBCMD_FPDMA_RECV_RD_LOG_DMA_EXT = 0x01,
314
	ATA_SUBCMD_FPDMA_RECV_ZAC_MGMT_IN    = 0x02,
315

316 317 318 319
	/* Subcmds for ATA_CMD_FPDMA_SEND */
	ATA_SUBCMD_FPDMA_SEND_DSM            = 0x00,
	ATA_SUBCMD_FPDMA_SEND_WR_LOG_DMA_EXT = 0x02,

320 321 322 323
	/* Subcmds for ATA_CMD_NCQ_NON_DATA */
	ATA_SUBCMD_NCQ_NON_DATA_ABORT_QUEUE  = 0x00,
	ATA_SUBCMD_NCQ_NON_DATA_SET_FEATURES = 0x05,
	ATA_SUBCMD_NCQ_NON_DATA_ZERO_EXT     = 0x06,
324
	ATA_SUBCMD_NCQ_NON_DATA_ZAC_MGMT_OUT = 0x07,
325

326 327 328
	/* Subcmds for ATA_CMD_ZAC_MGMT_IN */
	ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES = 0x00,

329 330 331 332 333 334
	/* Subcmds for ATA_CMD_ZAC_MGMT_OUT */
	ATA_SUBCMD_ZAC_MGMT_OUT_CLOSE_ZONE = 0x01,
	ATA_SUBCMD_ZAC_MGMT_OUT_FINISH_ZONE = 0x02,
	ATA_SUBCMD_ZAC_MGMT_OUT_OPEN_ZONE = 0x03,
	ATA_SUBCMD_ZAC_MGMT_OUT_RESET_WRITE_POINTER = 0x04,

335
	/* READ_LOG_EXT pages */
336
	ATA_LOG_DIRECTORY	= 0x0,
337
	ATA_LOG_SATA_NCQ	= 0x10,
338
	ATA_LOG_NCQ_NON_DATA	  = 0x12,
339
	ATA_LOG_NCQ_SEND_RECV	  = 0x13,
340 341
	ATA_LOG_SATA_ID_DEV_DATA  = 0x30,
	ATA_LOG_SATA_SETTINGS	  = 0x08,
342
	ATA_LOG_ZONED_INFORMATION = 0x09,
343 344 345
	ATA_LOG_DEVSLP_OFFSET	  = 0x30,
	ATA_LOG_DEVSLP_SIZE	  = 0x08,
	ATA_LOG_DEVSLP_MDAT	  = 0x00,
346
	ATA_LOG_DEVSLP_MDAT_MASK  = 0x1F,
347 348
	ATA_LOG_DEVSLP_DETO	  = 0x01,
	ATA_LOG_DEVSLP_VALID	  = 0x07,
349
	ATA_LOG_DEVSLP_VALID_MASK = 0x80,
Linus Torvalds's avatar
Linus Torvalds committed
350

351 352 353 354 355 356
	/* NCQ send and receive log */
	ATA_LOG_NCQ_SEND_RECV_SUBCMDS_OFFSET	= 0x00,
	ATA_LOG_NCQ_SEND_RECV_SUBCMDS_DSM	= (1 << 0),
	ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET	= 0x04,
	ATA_LOG_NCQ_SEND_RECV_DSM_TRIM		= (1 << 0),
	ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET	= 0x08,
357
	ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED  = (1 << 0),
358
	ATA_LOG_NCQ_SEND_RECV_WR_LOG_OFFSET	= 0x0C,
359
	ATA_LOG_NCQ_SEND_RECV_WR_LOG_SUPPORTED  = (1 << 0),
360 361 362 363
	ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET	= 0x10,
	ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OUT_SUPPORTED = (1 << 0),
	ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED = (1 << 1),
	ATA_LOG_NCQ_SEND_RECV_SIZE		= 0x14,
364

365 366 367 368 369 370 371 372 373 374 375
	/* NCQ Non-Data log */
	ATA_LOG_NCQ_NON_DATA_SUBCMDS_OFFSET	= 0x00,
	ATA_LOG_NCQ_NON_DATA_ABORT_OFFSET	= 0x00,
	ATA_LOG_NCQ_NON_DATA_ABORT_NCQ		= (1 << 0),
	ATA_LOG_NCQ_NON_DATA_ABORT_ALL		= (1 << 1),
	ATA_LOG_NCQ_NON_DATA_ABORT_STREAMING	= (1 << 2),
	ATA_LOG_NCQ_NON_DATA_ABORT_NON_STREAMING = (1 << 3),
	ATA_LOG_NCQ_NON_DATA_ABORT_SELECTED	= (1 << 4),
	ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET	= 0x1C,
	ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT	= (1 << 0),
	ATA_LOG_NCQ_NON_DATA_SIZE		= 0x40,
376

377 378 379 380 381 382
	/* READ/WRITE LONG (obsolete) */
	ATA_CMD_READ_LONG	= 0x22,
	ATA_CMD_READ_LONG_ONCE	= 0x23,
	ATA_CMD_WRITE_LONG	= 0x32,
	ATA_CMD_WRITE_LONG_ONCE	= 0x33,

Linus Torvalds's avatar
Linus Torvalds committed
383 384 385 386 387 388 389 390 391 392
	/* SETFEATURES stuff */
	SETFEATURES_XFER	= 0x03,
	XFER_UDMA_7		= 0x47,
	XFER_UDMA_6		= 0x46,
	XFER_UDMA_5		= 0x45,
	XFER_UDMA_4		= 0x44,
	XFER_UDMA_3		= 0x43,
	XFER_UDMA_2		= 0x42,
	XFER_UDMA_1		= 0x41,
	XFER_UDMA_0		= 0x40,
393 394
	XFER_MW_DMA_4		= 0x24,	/* CFA only */
	XFER_MW_DMA_3		= 0x23,	/* CFA only */
Linus Torvalds's avatar
Linus Torvalds committed
395 396 397
	XFER_MW_DMA_2		= 0x22,
	XFER_MW_DMA_1		= 0x21,
	XFER_MW_DMA_0		= 0x20,
398 399 400
	XFER_SW_DMA_2		= 0x12,
	XFER_SW_DMA_1		= 0x11,
	XFER_SW_DMA_0		= 0x10,
401 402
	XFER_PIO_6		= 0x0E,	/* CFA only */
	XFER_PIO_5		= 0x0D,	/* CFA only */
Linus Torvalds's avatar
Linus Torvalds committed
403 404 405 406 407 408 409
	XFER_PIO_4		= 0x0C,
	XFER_PIO_3		= 0x0B,
	XFER_PIO_2		= 0x0A,
	XFER_PIO_1		= 0x09,
	XFER_PIO_0		= 0x08,
	XFER_PIO_SLOW		= 0x00,

410 411 412
	SETFEATURES_WC_ON	= 0x02, /* Enable write cache */
	SETFEATURES_WC_OFF	= 0x82, /* Disable write cache */

413 414 415
	SETFEATURES_RA_ON	= 0xaa, /* Enable read look-ahead */
	SETFEATURES_RA_OFF	= 0x55, /* Disable read look-ahead */

416 417 418 419
	/* Enable/Disable Automatic Acoustic Management */
	SETFEATURES_AAM_ON	= 0x42,
	SETFEATURES_AAM_OFF	= 0xC2,

420 421
	SETFEATURES_SPINUP		= 0x07, /* Spin-up drive */
	SETFEATURES_SPINUP_TIMEOUT	= 30000, /* 30s timeout for drive spin-up from PUIS */
422

423 424 425 426
	SETFEATURES_SATA_ENABLE = 0x10, /* Enable use of SATA feature */
	SETFEATURES_SATA_DISABLE = 0x90, /* Disable use of SATA feature */

	/* SETFEATURE Sector counts for SATA features */
427
	SATA_FPDMA_OFFSET	= 0x01,	/* FPDMA non-zero buffer offsets */
Tejun Heo's avatar
Tejun Heo committed
428 429
	SATA_FPDMA_AA		= 0x02, /* FPDMA Setup FIS Auto-Activate */
	SATA_DIPM		= 0x03,	/* Device Initiated Power Management */
430
	SATA_FPDMA_IN_ORDER	= 0x04,	/* FPDMA in-order data delivery */
Tejun Heo's avatar
Tejun Heo committed
431
	SATA_AN			= 0x05,	/* Asynchronous Notification */
432
	SATA_SSP		= 0x06,	/* Software Settings Preservation */
433
	SATA_DEVSLP		= 0x09,	/* Device Sleep */
434

435 436
	SETFEATURE_SENSE_DATA	= 0xC3, /* Sense Data Reporting feature */

437 438 439 440 441 442 443 444 445 446 447 448 449
	/* feature values for SET_MAX */
	ATA_SET_MAX_ADDR	= 0x00,
	ATA_SET_MAX_PASSWD	= 0x01,
	ATA_SET_MAX_LOCK	= 0x02,
	ATA_SET_MAX_UNLOCK	= 0x03,
	ATA_SET_MAX_FREEZE_LOCK	= 0x04,

	/* feature values for DEVICE CONFIGURATION OVERLAY */
	ATA_DCO_RESTORE		= 0xC0,
	ATA_DCO_FREEZE_LOCK	= 0xC1,
	ATA_DCO_IDENTIFY	= 0xC2,
	ATA_DCO_SET		= 0xC3,

450 451 452 453 454
	/* feature values for SMART */
	ATA_SMART_ENABLE	= 0xD8,
	ATA_SMART_READ_VALUES	= 0xD0,
	ATA_SMART_READ_THRESHOLDS = 0xD1,

455 456 457
	/* feature values for Data Set Management */
	ATA_DSM_TRIM		= 0x01,

458 459 460 461
	/* password used in LBA Mid / LBA High for executing SMART commands */
	ATA_SMART_LBAM_PASS	= 0x4F,
	ATA_SMART_LBAH_PASS	= 0xC2,

Linus Torvalds's avatar
Linus Torvalds committed
462 463 464 465 466 467
	/* ATAPI stuff */
	ATAPI_PKT_DMA		= (1 << 0),
	ATAPI_DMADIR		= (1 << 2),	/* ATAPI data dir:
						   0=to device, 1=to host */
	ATAPI_CDB_LEN		= 16,

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
	/* PMP stuff */
	SATA_PMP_MAX_PORTS	= 15,
	SATA_PMP_CTRL_PORT	= 15,

	SATA_PMP_GSCR_DWORDS	= 128,
	SATA_PMP_GSCR_PROD_ID	= 0,
	SATA_PMP_GSCR_REV	= 1,
	SATA_PMP_GSCR_PORT_INFO	= 2,
	SATA_PMP_GSCR_ERROR	= 32,
	SATA_PMP_GSCR_ERROR_EN	= 33,
	SATA_PMP_GSCR_FEAT	= 64,
	SATA_PMP_GSCR_FEAT_EN	= 96,

	SATA_PMP_PSCR_STATUS	= 0,
	SATA_PMP_PSCR_ERROR	= 1,
	SATA_PMP_PSCR_CONTROL	= 2,

	SATA_PMP_FEAT_BIST	= (1 << 0),
	SATA_PMP_FEAT_PMREQ	= (1 << 1),
	SATA_PMP_FEAT_DYNSSC	= (1 << 2),
	SATA_PMP_FEAT_NOTIFY	= (1 << 3),

Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493
	/* cable types */
	ATA_CBL_NONE		= 0,
	ATA_CBL_PATA40		= 1,
	ATA_CBL_PATA80		= 2,
Tejun Heo's avatar
Tejun Heo committed
494 495 496 497
	ATA_CBL_PATA40_SHORT	= 3,	/* 40 wire cable to high UDMA spec */
	ATA_CBL_PATA_UNK	= 4,	/* don't know, maybe 80c? */
	ATA_CBL_PATA_IGN	= 5,	/* don't know, ignore cable handling */
	ATA_CBL_SATA		= 6,
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501 502 503 504 505

	/* SATA Status and Control Registers */
	SCR_STATUS		= 0,
	SCR_ERROR		= 1,
	SCR_CONTROL		= 2,
	SCR_ACTIVE		= 3,
	SCR_NOTIFICATION	= 4,

506 507 508 509 510 511 512 513
	/* SError bits */
	SERR_DATA_RECOVERED	= (1 << 0), /* recovered data error */
	SERR_COMM_RECOVERED	= (1 << 1), /* recovered comm failure */
	SERR_DATA		= (1 << 8), /* unrecovered data error */
	SERR_PERSISTENT		= (1 << 9), /* persistent data/comm error */
	SERR_PROTOCOL		= (1 << 10), /* protocol violation */
	SERR_INTERNAL		= (1 << 11), /* host internal error */
	SERR_PHYRDY_CHG		= (1 << 16), /* PHY RDY changed */
514 515 516 517 518 519 520 521 522
	SERR_PHY_INT_ERR	= (1 << 17), /* PHY internal error */
	SERR_COMM_WAKE		= (1 << 18), /* Comm wake */
	SERR_10B_8B_ERR		= (1 << 19), /* 10b to 8b decode error */
	SERR_DISPARITY		= (1 << 20), /* Disparity */
	SERR_CRC		= (1 << 21), /* CRC error */
	SERR_HANDSHAKE		= (1 << 22), /* Handshake error */
	SERR_LINK_SEQ_ERR	= (1 << 23), /* Link sequence error */
	SERR_TRANS_ST_ERROR	= (1 << 24), /* Transport state trans. error */
	SERR_UNRECOG_FIS	= (1 << 25), /* Unrecognized FIS */
523
	SERR_DEV_XCHG		= (1 << 26), /* device exchanged */
Linus Torvalds's avatar
Linus Torvalds committed
524 525
};

526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
enum ata_prot_flags {
	/* protocol flags */
	ATA_PROT_FLAG_PIO	= (1 << 0), /* is PIO */
	ATA_PROT_FLAG_DMA	= (1 << 1), /* is DMA */
	ATA_PROT_FLAG_NCQ	= (1 << 2), /* is NCQ */
	ATA_PROT_FLAG_ATAPI	= (1 << 3), /* is ATAPI */

	/* taskfile protocols */
	ATA_PROT_UNKNOWN	= (u8)-1,
	ATA_PROT_NODATA		= 0,
	ATA_PROT_PIO		= ATA_PROT_FLAG_PIO,
	ATA_PROT_DMA		= ATA_PROT_FLAG_DMA,
	ATA_PROT_NCQ_NODATA	= ATA_PROT_FLAG_NCQ,
	ATA_PROT_NCQ		= ATA_PROT_FLAG_DMA | ATA_PROT_FLAG_NCQ,
	ATAPI_PROT_NODATA	= ATA_PROT_FLAG_ATAPI,
	ATAPI_PROT_PIO		= ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_PIO,
	ATAPI_PROT_DMA		= ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_DMA,
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545
};

enum ata_ioctls {
546 547
	ATA_IOC_GET_IO32	= 0x309, /* HDIO_GET_32BIT */
	ATA_IOC_SET_IO32	= 0x324, /* HDIO_SET_32BIT */
Linus Torvalds's avatar
Linus Torvalds committed
548 549 550 551
};

/* core structures */

552
struct ata_bmdma_prd {
Al Viro's avatar
Al Viro committed
553 554
	__le32			addr;
	__le32			flags_len;
Linus Torvalds's avatar
Linus Torvalds committed
555 556
};

557 558 559
/*
 * id tests
 */
560 561 562
#define ata_id_is_ata(id)	(((id)[ATA_ID_CONFIG] & (1 << 15)) == 0)
#define ata_id_has_lba(id)	((id)[ATA_ID_CAPABILITY] & (1 << 9))
#define ata_id_has_dma(id)	((id)[ATA_ID_CAPABILITY] & (1 << 8))
563
#define ata_id_has_ncq(id)	((id)[ATA_ID_SATA_CAPABILITY] & (1 << 8))
564
#define ata_id_queue_depth(id)	(((id)[ATA_ID_QUEUE_DEPTH] & 0x1f) + 1)
565
#define ata_id_removable(id)	((id)[ATA_ID_CONFIG] & (1 << 7))
Tejun Heo's avatar
Tejun Heo committed
566
#define ata_id_has_atapi_AN(id)	\
567 568 569
	((((id)[ATA_ID_SATA_CAPABILITY] != 0x0000) && \
	  ((id)[ATA_ID_SATA_CAPABILITY] != 0xffff)) && \
	 ((id)[ATA_ID_FEATURE_SUPP] & (1 << 5)))
570
#define ata_id_has_fpdma_aa(id)	\
571 572 573
	((((id)[ATA_ID_SATA_CAPABILITY] != 0x0000) && \
	  ((id)[ATA_ID_SATA_CAPABILITY] != 0xffff)) && \
	 ((id)[ATA_ID_FEATURE_SUPP] & (1 << 2)))
574 575
#define ata_id_iordy_disable(id) ((id)[ATA_ID_CAPABILITY] & (1 << 10))
#define ata_id_has_iordy(id) ((id)[ATA_ID_CAPABILITY] & (1 << 11))
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579 580 581 582 583
#define ata_id_u32(id,n)	\
	(((u32) (id)[(n) + 1] << 16) | ((u32) (id)[(n)]))
#define ata_id_u64(id,n)	\
	( ((u64) (id)[(n) + 3] << 48) |	\
	  ((u64) (id)[(n) + 2] << 32) |	\
	  ((u64) (id)[(n) + 1] << 16) |	\
	  ((u64) (id)[(n) + 0]) )

584
#define ata_id_cdb_intr(id)	(((id)[ATA_ID_CONFIG] & 0x60) == 0x20)
585
#define ata_id_has_da(id)	((id)[ATA_ID_SATA_CAPABILITY_2] & (1 << 4))
586
#define ata_id_has_devslp(id)	((id)[ATA_ID_FEATURE_SUPP] & (1 << 8))
587 588
#define ata_id_has_ncq_autosense(id) \
				((id)[ATA_ID_FEATURE_SUPP] & (1 << 7))
589

590 591
static inline bool ata_id_has_hipm(const u16 *id)
{
592
	u16 val = id[ATA_ID_SATA_CAPABILITY];
593 594 595 596 597 598 599 600 601

	if (val == 0 || val == 0xffff)
		return false;

	return val & (1 << 9);
}

static inline bool ata_id_has_dipm(const u16 *id)
{
602
	u16 val = id[ATA_ID_FEATURE_SUPP];
603 604 605 606 607 608 609

	if (val == 0 || val == 0xffff)
		return false;

	return val & (1 << 3);
}

610

611
static inline bool ata_id_has_fua(const u16 *id)
612
{
613
	if ((id[ATA_ID_CFSSE] & 0xC000) != 0x4000)
614
		return false;
615
	return id[ATA_ID_CFSSE] & (1 << 6);
616 617
}

618
static inline bool ata_id_has_flush(const u16 *id)
619
{
620
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
621
		return false;
622
	return id[ATA_ID_COMMAND_SET_2] & (1 << 12);
623 624
}

625
static inline bool ata_id_flush_enabled(const u16 *id)
626 627
{
	if (ata_id_has_flush(id) == 0)
628
		return false;
629
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
630
		return false;
631 632 633
	return id[ATA_ID_CFS_ENABLE_2] & (1 << 12);
}

634
static inline bool ata_id_has_flush_ext(const u16 *id)
635
{
636
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
637
		return false;
638
	return id[ATA_ID_COMMAND_SET_2] & (1 << 13);
639 640
}

641
static inline bool ata_id_flush_ext_enabled(const u16 *id)
642 643
{
	if (ata_id_has_flush_ext(id) == 0)
644
		return false;
645
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
646
		return false;
647 648 649 650 651 652 653
	/*
	 * some Maxtor disks have bit 13 defined incorrectly
	 * so check bit 10 too
	 */
	return (id[ATA_ID_CFS_ENABLE_2] & 0x2400) == 0x2400;
}

654
static inline u32 ata_id_logical_sector_size(const u16 *id)
655
{
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
	/* T13/1699-D Revision 6a, Sep 6, 2008. Page 128.
	 * IDENTIFY DEVICE data, word 117-118.
	 * 0xd000 ignores bit 13 (logical:physical > 1)
	 */
	if ((id[ATA_ID_SECTOR_SIZE] & 0xd000) == 0x5000)
		return (((id[ATA_ID_LOGICAL_SECTOR_SIZE+1] << 16)
			 + id[ATA_ID_LOGICAL_SECTOR_SIZE]) * sizeof(u16)) ;
	return ATA_SECT_SIZE;
}

static inline u8 ata_id_log2_per_physical_sector(const u16 *id)
{
	/* T13/1699-D Revision 6a, Sep 6, 2008. Page 128.
	 * IDENTIFY DEVICE data, word 106.
	 * 0xe000 ignores bit 12 (logical sector > 512 bytes)
	 */
	if ((id[ATA_ID_SECTOR_SIZE] & 0xe000) == 0x6000)
		return (id[ATA_ID_SECTOR_SIZE] & 0xf);
	return 0;
675 676
}

677 678 679 680 681 682 683 684 685 686 687
/* Offset of logical sectors relative to physical sectors.
 *
 * If device has more than one logical sector per physical sector
 * (aka 512 byte emulation), vendors might offset the "sector 0" address
 * so sector 63 is "naturally aligned" - e.g. FAT partition table.
 * This avoids Read/Mod/Write penalties when using FAT partition table
 * and updating "well aligned" (FS perspective) physical sectors on every
 * transaction.
 */
static inline u16 ata_id_logical_sector_offset(const u16 *id,
	 u8 log2_per_phys)
688
{
689 690 691 692 693 694 695 696
	u16 word_209 = id[209];

	if ((log2_per_phys > 1) && (word_209 & 0xc000) == 0x4000) {
		u16 first = word_209 & 0x3fff;
		if (first > 0)
			return (1 << log2_per_phys) - first;
	}
	return 0;
697 698
}

699
static inline bool ata_id_has_lba48(const u16 *id)
700
{
701
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
702
		return false;
703
	if (!ata_id_u64(id, ATA_ID_LBA_CAPACITY_2))
704
		return false;
705
	return id[ATA_ID_COMMAND_SET_2] & (1 << 10);
706 707
}

708
static inline bool ata_id_lba48_enabled(const u16 *id)
709 710
{
	if (ata_id_has_lba48(id) == 0)
711
		return false;
712
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
713
		return false;
714 715 716
	return id[ATA_ID_CFS_ENABLE_2] & (1 << 10);
}

717
static inline bool ata_id_hpa_enabled(const u16 *id)
718 719
{
	/* Yes children, word 83 valid bits cover word 82 data */
720
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
721
		return false;
722
	/* And 87 covers 85-87 */
723
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
724
		return false;
725
	/* Check command sets enabled as well as supported */
726
	if ((id[ATA_ID_CFS_ENABLE_1] & (1 << 10)) == 0)
727
		return false;
728
	return id[ATA_ID_COMMAND_SET_1] & (1 << 10);
729 730
}

731
static inline bool ata_id_has_wcache(const u16 *id)
732 733
{
	/* Yes children, word 83 valid bits cover word 82 data */
734
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
735
		return false;
736
	return id[ATA_ID_COMMAND_SET_1] & (1 << 5);
737 738
}

739
static inline bool ata_id_has_pm(const u16 *id)
740
{
741
	if ((id[ATA_ID_COMMAND_SET_2] & 0xC000) != 0x4000)
742
		return false;
743
	return id[ATA_ID_COMMAND_SET_1] & (1 << 3);
744 745
}

746
static inline bool ata_id_rahead_enabled(const u16 *id)
747
{
748
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
749
		return false;
750
	return id[ATA_ID_CFS_ENABLE_1] & (1 << 6);
751 752
}

753
static inline bool ata_id_wcache_enabled(const u16 *id)
754
{
755
	if ((id[ATA_ID_CSF_DEFAULT] & 0xC000) != 0x4000)
756
		return false;
757
	return id[ATA_ID_CFS_ENABLE_1] & (1 << 5);
758 759
}

760 761
static inline bool ata_id_has_read_log_dma_ext(const u16 *id)
{
762
	/* Word 86 must have bit 15 set */
763 764
	if (!(id[ATA_ID_CFS_ENABLE_2] & (1 << 15)))
		return false;
765 766 767 768 769 770 771 772 773 774

	/* READ LOG DMA EXT support can be signaled either from word 119
	 * or from word 120. The format is the same for both words: Bit
	 * 15 must be cleared, bit 14 set and bit 3 set.
	 */
	if ((id[ATA_ID_COMMAND_SET_3] & 0xC008) == 0x4008 ||
	    (id[ATA_ID_COMMAND_SET_4] & 0xC008) == 0x4008)
		return true;

	return false;
775 776
}

777 778 779 780 781 782 783 784 785 786 787 788 789 790
static inline bool ata_id_has_sense_reporting(const u16 *id)
{
	if (!(id[ATA_ID_CFS_ENABLE_2] & (1 << 15)))
		return false;
	return id[ATA_ID_COMMAND_SET_3] & (1 << 6);
}

static inline bool ata_id_sense_reporting_enabled(const u16 *id)
{
	if (!(id[ATA_ID_CFS_ENABLE_2] & (1 << 15)))
		return false;
	return id[ATA_ID_COMMAND_SET_4] & (1 << 6);
}

791 792 793 794 795 796 797 798 799 800
/**
 *	ata_id_major_version	-	get ATA level of drive
 *	@id: Identify data
 *
 *	Caveats:
 *		ATA-1 considers identify optional
 *		ATA-2 introduces mandatory identify
 *		ATA-3 introduces word 80 and accurate reporting
 *
 *	The practical impact of this is that ata_id_major_version cannot
801
 *	reliably report on drives below ATA3.
802 803
 */

804 805 806 807
static inline unsigned int ata_id_major_version(const u16 *id)
{
	unsigned int mver;

808 809 810
	if (id[ATA_ID_MAJOR_VER] == 0xFFFF)
		return 0;

811 812 813 814 815 816
	for (mver = 14; mver >= 1; mver--)
		if (id[ATA_ID_MAJOR_VER] & (1 << mver))
			break;
	return mver;
}

817
static inline bool ata_id_is_sata(const u16 *id)
818
{
819 820 821 822 823 824 825
	/*
	 * See if word 93 is 0 AND drive is at least ATA-5 compatible
	 * verifying that word 80 by casting it to a signed type --
	 * this trick allows us to filter out the reserved values of
	 * 0x0000 and 0xffff along with the earlier ATA revisions...
	 */
	if (id[ATA_ID_HW_CONFIG] == 0 && (short)id[ATA_ID_MAJOR_VER] >= 0x0020)
826 827
		return true;
	return false;
828 829
}

830
static inline bool ata_id_has_tpm(const u16 *id)
831 832 833
{
	/* The TPM bits are only valid on ATA8 */
	if (ata_id_major_version(id) < 8)
834
		return false;
835
	if ((id[48] & 0xC000) != 0x4000)
836
		return false;
837 838 839
	return id[48] & (1 << 0);
}

840
static inline bool ata_id_has_dword_io(const u16 *id)
841 842 843
{
	/* ATA 8 reuses this flag for "trusted" computing */
	if (ata_id_major_version(id) > 7)
844 845
		return false;
	return id[ATA_ID_DWORD_IO] & (1 << 0);
846 847
}

848
static inline bool ata_id_has_unload(const u16 *id)
849 850 851 852
{
	if (ata_id_major_version(id) >= 7 &&
	    (id[ATA_ID_CFSSE] & 0xC000) == 0x4000 &&
	    id[ATA_ID_CFSSE] & (1 << 13))
853 854
		return true;
	return false;
855 856
}

857 858 859 860 861
static inline bool ata_id_has_wwn(const u16 *id)
{
	return (id[ATA_ID_CSF_DEFAULT] & 0xC100) == 0x4100;
}

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
static inline int ata_id_form_factor(const u16 *id)
{
	u16 val = id[168];

	if (ata_id_major_version(id) < 7 || val == 0 || val == 0xffff)
		return 0;

	val &= 0xf;

	if (val > 5)
		return 0;

	return val;
}

static inline int ata_id_rotation_rate(const u16 *id)
{
	u16 val = id[217];

	if (ata_id_major_version(id) < 7 || val == 0 || val == 0xffff)
		return 0;

	if (val > 1 && val < 0x401)
		return 0;

	return val;
}

890 891 892 893 894
static inline bool ata_id_has_ncq_send_and_recv(const u16 *id)
{
	return id[ATA_ID_SATA_CAPABILITY_2] & BIT(6);
}

895 896 897 898 899
static inline bool ata_id_has_ncq_non_data(const u16 *id)
{
	return id[ATA_ID_SATA_CAPABILITY_2] & BIT(5);
}

900
static inline bool ata_id_has_trim(const u16 *id)
901 902 903
{
	if (ata_id_major_version(id) >= 7 &&
	    (id[ATA_ID_DATA_SET_MGMT] & 1))
904 905
		return true;
	return false;
906 907
}

908
static inline bool ata_id_has_zero_after_trim(const u16 *id)
909 910 911 912
{
	/* DSM supported, deterministic read, and read zero after trim set */
	if (ata_id_has_trim(id) &&
	    (id[ATA_ID_ADDITIONAL_SUPP] & 0x4020) == 0x4020)
913
		return true;
914

915
	return false;
916 917
}

918
static inline bool ata_id_current_chs_valid(const u16 *id)
919
{
920 921
	/* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
	   has not been issued to the device then the values of
922 923 924 925 926 927
	   id[ATA_ID_CUR_CYLS] to id[ATA_ID_CUR_SECTORS] are vendor specific. */
	return (id[ATA_ID_FIELD_VALID] & 1) && /* Current translation valid */
		id[ATA_ID_CUR_CYLS] &&  /* cylinders in current translation */
		id[ATA_ID_CUR_HEADS] &&  /* heads in current translation */
		id[ATA_ID_CUR_HEADS] <= 16 &&
		id[ATA_ID_CUR_SECTORS];    /* sectors in current translation */
928 929
}

930
static inline bool ata_id_is_cfa(const u16 *id)
931
{
932 933
	if ((id[ATA_ID_CONFIG] == 0x848A) ||	/* Traditional CF */
	    (id[ATA_ID_CONFIG] == 0x844A))	/* Delkin Devices CF */
934
		return true;
935 936 937 938 939 940 941 942
	/*
	 * CF specs don't require specific value in the word 0 anymore and yet
	 * they forbid to report the ATA version in the word 80 and require the
	 * CFA feature set support to be indicated in the word 83 in this case.
	 * Unfortunately, some cards only follow either of this requirements,
	 * and while those that don't indicate CFA feature support need some
	 * sort of quirk list, it seems impractical for the ones that do...
	 */
943
	return (id[ATA_ID_COMMAND_SET_2] & 0xC004) == 0x4004;
944 945
}

946
static inline bool ata_id_is_ssd(const u16 *id)
947 948 949 950
{
	return id[ATA_ID_ROT_SPEED] == 0x01;
}

951 952 953 954 955
static inline u8 ata_id_zoned_cap(const u16 *id)
{
	return (id[ATA_ID_ADDITIONAL_SUPP] & 0x3);
}

956
static inline bool ata_id_pio_need_iordy(const u16 *id, const u8 pio)
957 958 959
{
	/* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */
	if (pio > 4 && ata_id_is_cfa(id))
960
		return false;
961 962
	/* For PIO3 and higher it is mandatory. */
	if (pio > 2)
963
		return true;
964
	/* Turn it on when possible. */
965
	return ata_id_has_iordy(id);
966 967
}

968
static inline bool ata_drive_40wire(const u16 *dev_id)
969
{
970
	if (ata_id_is_sata(dev_id))
971
		return false;	/* SATA */
972
	if ((dev_id[ATA_ID_HW_CONFIG] & 0xE000) == 0x6000)
973 974
		return false;	/* 80 wire */
	return true;
975 976
}

977
static inline bool ata_drive_40wire_relaxed(const u16 *dev_id)
978
{
979
	if ((dev_id[ATA_ID_HW_CONFIG] & 0x2000) == 0x2000)
980 981
		return false;	/* 80 wire */
	return true;
982 983
}

984
static inline int atapi_cdb_len(const u16 *dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
985
{
986
	u16 tmp = dev_id[ATA_ID_CONFIG] & 0x3;
Linus Torvalds's avatar
Linus Torvalds committed
987 988 989 990 991 992 993
	switch (tmp) {
	case 0:		return 12;
	case 1:		return 16;
	default:	return -1;
	}
}

994
static inline int atapi_command_packet_set(const u16 *dev_id)
995
{
996
	return (dev_id[ATA_ID_CONFIG] >> 8) & 0x1f;
997 998
}

999
static inline bool atapi_id_dmadir(const u16 *dev_id)
1000 1001 1002 1003
{
	return ata_id_major_version(dev_id) >= 7 && (dev_id[62] & 0x8000);
}

1004 1005 1006 1007 1008 1009 1010 1011
/*
 * ata_id_is_lba_capacity_ok() performs a sanity check on
 * the claimed LBA capacity value for the device.
 *
 * Returns 1 if LBA capacity looks sensible, 0 otherwise.
 *
 * It is called only once for each device.
 */
1012
static inline bool ata_id_is_lba_capacity_ok(u16 *id)
1013 1014 1015 1016 1017
{
	unsigned long lba_sects, chs_sects, head, tail;

	/* No non-LBA info .. so valid! */
	if (id[ATA_ID_CYLS] == 0)
1018
		return true;
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032

	lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);

	/*
	 * The ATA spec tells large drives to return
	 * C/H/S = 16383/16/63 independent of their size.
	 * Some drives can be jumpered to use 15 heads instead of 16.
	 * Some drives can be jumpered to use 4092 cyls instead of 16383.
	 */
	if ((id[ATA_ID_CYLS] == 16383 ||
	     (id[ATA_ID_CYLS] == 4092 && id[ATA_ID_CUR_CYLS] == 16383)) &&
	    id[ATA_ID_SECTORS] == 63 &&
	    (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
	    (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
1033
		return true;
1034 1035 1036 1037 1038

	chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];

	/* perform a rough sanity check on lba_sects: within 10% is OK */
	if (lba_sects - chs_sects < chs_sects/10)
1039
		return true;
1040 1041 1042 1043 1044 1045 1046 1047

	/* some drives have the word order reversed */
	head = (lba_sects >> 16) & 0xffff;
	tail = lba_sects & 0xffff;
	lba_sects = head | (tail << 16);

	if (lba_sects - chs_sects < chs_sects/10) {
		*(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
1048
		return true;	/* LBA capacity is (now) good */
1049 1050
	}

1051
	return false;	/* LBA capacity value may be bad */
1052 1053
}

1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
static inline void ata_id_to_hd_driveid(u16 *id)
{
#ifdef __BIG_ENDIAN
	/* accessed in struct hd_driveid as 8-bit values */
	id[ATA_ID_MAX_MULTSECT]	 = __cpu_to_le16(id[ATA_ID_MAX_MULTSECT]);
	id[ATA_ID_CAPABILITY]	 = __cpu_to_le16(id[ATA_ID_CAPABILITY]);
	id[ATA_ID_OLD_PIO_MODES] = __cpu_to_le16(id[ATA_ID_OLD_PIO_MODES]);
	id[ATA_ID_OLD_DMA_MODES] = __cpu_to_le16(id[ATA_ID_OLD_DMA_MODES]);
	id[ATA_ID_MULTSECT]	 = __cpu_to_le16(id[ATA_ID_MULTSECT]);

	/* as 32-bit values */
	*(u32 *)&id[ATA_ID_LBA_CAPACITY] = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
	*(u32 *)&id[ATA_ID_SPG]		 = ata_id_u32(id, ATA_ID_SPG);

	/* as 64-bit value */
	*(u64 *)&id[ATA_ID_LBA_CAPACITY_2] =
		ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
#endif
}

1074
/*
1075 1076 1077
 * Write LBA Range Entries to the buffer that will cover the extent from
 * sector to sector + count.  This is used for TRIM and for ADD LBA(S)
 * TO NV CACHE PINNED SET.
1078
 */
1079
static inline unsigned ata_set_lba_range_entries(void *_buffer,
1080
		unsigned num, u64 sector, unsigned long count)
1081 1082
{
	__le64 *buffer = _buffer;
1083
	unsigned i = 0, used_bytes;
1084

1085
	while (i < num) {
1086 1087 1088 1089 1090 1091 1092 1093 1094
		u64 entry = sector |
			((u64)(count > 0xffff ? 0xffff : count) << 48);
		buffer[i++] = __cpu_to_le64(entry);
		if (count <= 0xffff)
			break;
		count -= 0xffff;
		sector += 0xffff;
	}

1095 1096 1097
	used_bytes = ALIGN(i * 8, 512);
	memset(buffer + i, 0, used_bytes - i * 8);
	return used_bytes;
1098 1099
}

1100
static inline bool ata_ok(u8 status)
Linus Torvalds's avatar
Linus Torvalds committed
1101 1102 1103 1104 1105
{
	return ((status & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | ATA_ERR))
			== ATA_DRDY);
}

1106
static inline bool lba_28_ok(u64 block, u32 n_block)
1107
{
1108
	/* check the ending block number: must be LESS THAN 0x0fffffff */
1109
	return ((block + n_block) < ((1 << 28) - 1)) && (n_block <= ATA_MAX_SECTORS);
1110 1111
}

1112
static inline bool lba_48_ok(u64 block, u32 n_block)
1113 1114
{
	/* check the ending block number */
1115
	return ((block + n_block - 1) < ((u64)1 << 48)) && (n_block <= ATA_MAX_SECTORS_LBA48);
1116 1117
}

1118 1119 1120 1121 1122
#define sata_pmp_gscr_vendor(gscr)	((gscr)[SATA_PMP_GSCR_PROD_ID] & 0xffff)
#define sata_pmp_gscr_devid(gscr)	((gscr)[SATA_PMP_GSCR_PROD_ID] >> 16)
#define sata_pmp_gscr_rev(gscr)		(((gscr)[SATA_PMP_GSCR_REV] >> 8) & 0xff)
#define sata_pmp_gscr_ports(gscr)	((gscr)[SATA_PMP_GSCR_PORT_INFO] & 0xf)

Linus Torvalds's avatar
Linus Torvalds committed
1123
#endif /* __LINUX_ATA_H__ */