libata.h 39.7 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
 *  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.*
 *
Linus Torvalds's avatar
Linus Torvalds committed
24
25
26
27
28
29
30
31
 */

#ifndef __LINUX_LIBATA_H__
#define __LINUX_LIBATA_H__

#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
32
#include <linux/dma-mapping.h>
33
#include <asm/scatterlist.h>
34
#include <linux/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
35
36
#include <linux/ata.h>
#include <linux/workqueue.h>
37
#include <scsi/scsi_host.h>
38
#include <linux/acpi.h>
Linus Torvalds's avatar
Linus Torvalds committed
39

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

Linus Torvalds's avatar
Linus Torvalds committed
50
/*
51
52
 * compile-time options: to be removed as soon as all the drivers are
 * converted to the new debugging mechanism
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 */
#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
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
#ifdef ATA_VERBOSE_DEBUG
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
#else
#define VPRINTK(fmt, args...)
#endif	/* ATA_VERBOSE_DEBUG */
#else
#define DPRINTK(fmt, args...)
#define VPRINTK(fmt, args...)
#endif	/* ATA_DEBUG */

73
74
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)

75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/* 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;
}

Linus Torvalds's avatar
Linus Torvalds committed
107
108
109
110
111
112
113
114
115
116
117
118
/* defines only for the constants which don't work well as enums */
#define ATA_TAG_POISON		0xfafbfcfdU

/* move to PCI layer? */
static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
{
	return &pdev->dev;
}

enum {
	/* various global constants */
	LIBATA_MAX_PRD		= ATA_MAX_PRD / 2,
119
	LIBATA_DUMB_MAX_PRD	= ATA_MAX_PRD / 4,	/* Worst case */
Linus Torvalds's avatar
Linus Torvalds committed
120
121
	ATA_MAX_PORTS		= 8,
	ATA_DEF_QUEUE		= 1,
122
	/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
123
	ATA_MAX_QUEUE		= 32,
124
	ATA_TAG_INTERNAL	= ATA_MAX_QUEUE - 1,
Linus Torvalds's avatar
Linus Torvalds committed
125
126
127
128
129
130
131
	ATA_MAX_BUS		= 2,
	ATA_DEF_BUSY_WAIT	= 10000,
	ATA_SHORT_PAUSE		= (HZ >> 6) + 1,

	ATA_SHT_EMULATED	= 1,
	ATA_SHT_CMD_PER_LUN	= 1,
	ATA_SHT_THIS_ID		= -1,
132
	ATA_SHT_USE_CLUSTERING	= 1,
Linus Torvalds's avatar
Linus Torvalds committed
133
134

	/* struct ata_device stuff */
Tejun Heo's avatar
Tejun Heo committed
135
136
	ATA_DFLAG_LBA		= (1 << 0), /* device supports LBA */
	ATA_DFLAG_LBA48		= (1 << 1), /* device supports LBA48 */
Jeff Garzik's avatar
Jeff Garzik committed
137
	ATA_DFLAG_CDB_INTR	= (1 << 2), /* device asserts INTRQ when ready for CDB */
138
	ATA_DFLAG_NCQ		= (1 << 3), /* device supports NCQ */
139
	ATA_DFLAG_FLUSH_EXT	= (1 << 4), /* do FLUSH_EXT instead of FLUSH */
140
141
	ATA_DFLAG_ACPI_PENDING	= (1 << 5), /* ACPI resume action pending */
	ATA_DFLAG_ACPI_FAILED	= (1 << 6), /* ACPI on devcfg has failed */
142
	ATA_DFLAG_AN		= (1 << 7), /* device supports AN */
143
	ATA_DFLAG_CFG_MASK	= (1 << 8) - 1,
Tejun Heo's avatar
Tejun Heo committed
144

145
	ATA_DFLAG_PIO		= (1 << 8), /* device limited to PIO mode */
Tejun Heo's avatar
Tejun Heo committed
146
	ATA_DFLAG_NCQ_OFF	= (1 << 9), /* device limited to non-NCQ mode */
147
	ATA_DFLAG_SPUNDOWN	= (1 << 10), /* XXX: for spindown_compat */
148
	ATA_DFLAG_INIT_MASK	= (1 << 16) - 1,
Linus Torvalds's avatar
Linus Torvalds committed
149

150
151
152
	ATA_DFLAG_DETACH	= (1 << 16),
	ATA_DFLAG_DETACHED	= (1 << 17),

Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
156
157
158
159
	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) */
	ATA_DEV_NONE		= 5,	/* no device */

160
161
162
163
164
	/* struct ata_link flags */
	ATA_LFLAG_HRST_TO_RESUME = (1 << 0), /* hardreset to resume link */
	ATA_LFLAG_SKIP_D2H_BSY	= (1 << 1), /* can't wait for the first D2H
					     * Register FIS clearing BSY */

Linus Torvalds's avatar
Linus Torvalds committed
165
	/* struct ata_port flags */
Tejun Heo's avatar
Tejun Heo committed
166
	ATA_FLAG_SLAVE_POSS	= (1 << 0), /* host supports slave dev */
Linus Torvalds's avatar
Linus Torvalds committed
167
					    /* (doesn't imply presence) */
Tejun Heo's avatar
Tejun Heo committed
168
169
170
171
172
173
174
175
	ATA_FLAG_SATA		= (1 << 1),
	ATA_FLAG_NO_LEGACY	= (1 << 2), /* no legacy mode check */
	ATA_FLAG_MMIO		= (1 << 3), /* use MMIO, not PIO */
	ATA_FLAG_SRST		= (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */
	ATA_FLAG_SATA_RESET	= (1 << 5), /* (obsolete) use COMRESET */
	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 */
176
177
178
179
	ATA_FLAG_PIO_POLLING	= (1 << 9), /* use polling PIO if LLD
					     * doesn't handle PIO interrupts */
	ATA_FLAG_NCQ		= (1 << 10), /* host supports NCQ */
	ATA_FLAG_DEBUGMSG	= (1 << 13),
180
	ATA_FLAG_IGN_SIMPLEX	= (1 << 15), /* ignore SIMPLEX */
181
	ATA_FLAG_NO_IORDY	= (1 << 16), /* controller lacks iordy */
182
	ATA_FLAG_ACPI_SATA	= (1 << 17), /* need native SATA ACPI layout */
183
	ATA_FLAG_AN		= (1 << 18), /* controller supports AN */
Tejun Heo's avatar
Tejun Heo committed
184

185
186
187
188
189
190
191
	/* The following flag belongs to ap->pflags but is kept in
	 * ap->flags because it's referenced in many LLDs and will be
	 * removed in not-too-distant future.
	 */
	ATA_FLAG_DISABLED	= (1 << 23), /* port is disabled, ignore it */

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

193
194
195
196
197
198
199
200
	/* 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_UNLOADING	= (1 << 5), /* module is unloading */
	ATA_PFLAG_SCSI_HOTPLUG	= (1 << 6), /* SCSI hotplug scheduled */
201
	ATA_PFLAG_INITIALIZING	= (1 << 7), /* being initialized, don't touch */
Tejun Heo's avatar
Tejun Heo committed
202

203
	ATA_PFLAG_SUSPENDED	= (1 << 17), /* port is suspended (power) */
204
	ATA_PFLAG_PM_PENDING	= (1 << 18), /* PM operation pending */
205
	ATA_PFLAG_GTM_VALID	= (1 << 19), /* acpi_gtm data valid */
Tejun Heo's avatar
Tejun Heo committed
206
207
208
209
210

	/* struct ata_queued_cmd flags */
	ATA_QCFLAG_ACTIVE	= (1 << 0), /* cmd not yet ack'd to scsi lyer */
	ATA_QCFLAG_SG		= (1 << 1), /* have s/g table? */
	ATA_QCFLAG_SINGLE	= (1 << 2), /* no s/g, just a single buffer */
Linus Torvalds's avatar
Linus Torvalds committed
211
	ATA_QCFLAG_DMAMAP	= ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
Tejun Heo's avatar
Tejun Heo committed
212
	ATA_QCFLAG_IO		= (1 << 3), /* standard IO command */
213
214
	ATA_QCFLAG_RESULT_TF	= (1 << 4), /* result TF requested */

215
216
217
	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) */
Linus Torvalds's avatar
Linus Torvalds committed
218

219
	/* host set flags */
Jeff Garzik's avatar
Jeff Garzik committed
220
	ATA_HOST_SIMPLEX	= (1 << 0),	/* Host is simplex, one DMA channel per host only */
221
	ATA_HOST_STARTED	= (1 << 1),	/* Host started */
222

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

Linus Torvalds's avatar
Linus Torvalds committed
225
	/* various lengths of time */
226
227
	ATA_TMOUT_BOOT		= 30 * HZ,	/* heuristic */
	ATA_TMOUT_BOOT_QUICK	= 7 * HZ,	/* heuristic */
228
229
	ATA_TMOUT_INTERNAL	= 30 * HZ,
	ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
Linus Torvalds's avatar
Linus Torvalds committed
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

	/* 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
249
	 * unsigned int bitmap
Linus Torvalds's avatar
Linus Torvalds committed
250
	 */
251
252
	ATA_BITS_PIO		= 7,
	ATA_BITS_MWDMA		= 5,
253
254
255
256
257
258
259
260
261
	ATA_BITS_UDMA		= 8,

	ATA_SHIFT_PIO		= 0,
	ATA_SHIFT_MWDMA		= ATA_SHIFT_PIO + ATA_BITS_PIO,
	ATA_SHIFT_UDMA		= ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,

	ATA_MASK_PIO		= ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
	ATA_MASK_MWDMA		= ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
	ATA_MASK_UDMA		= ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
262
263
264
265

	/* size of buffer to pad xfers ending on unaligned boundaries */
	ATA_DMA_PAD_SZ		= 4,
	ATA_DMA_PAD_BUF_SZ	= ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
Tejun Heo's avatar
Tejun Heo committed
266

267
268
269
	/* ering size */
	ATA_ERING_SIZE		= 32,

270
271
272
	/* desc_len for ata_eh_info and context */
	ATA_EH_DESC_LEN		= 80,

273
274
275
276
277
278
	/* reset / recovery action types */
	ATA_EH_REVALIDATE	= (1 << 0),
	ATA_EH_SOFTRESET	= (1 << 1),
	ATA_EH_HARDRESET	= (1 << 2),

	ATA_EH_RESET_MASK	= ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
279
	ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE,
280

281
	/* ata_eh_info->flags */
282
	ATA_EHI_HOTPLUGGED	= (1 << 0),  /* could have been hotplugged */
283
	ATA_EHI_RESUME_LINK	= (1 << 1),  /* resume link (reset modifier) */
284
285
	ATA_EHI_NO_AUTOPSY	= (1 << 2),  /* no autopsy */
	ATA_EHI_QUIET		= (1 << 3),  /* be quiet */
286

287
288
289
290
291
	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 */
	ATA_EHI_POST_SETMODE	= (1 << 20), /* revaildating after setmode */
292

293
	ATA_EHI_DID_RESET	= ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
294
295
	ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,

296
297
298
	/* max repeat if error condition is still set after ->error_handler */
	ATA_EH_MAX_REPEAT	= 5,

299
300
	/* how hard are we gonna try to probe/recover devices */
	ATA_PROBE_MAX_TRIES	= 3,
301
	ATA_EH_DEV_TRIES	= 3,
302

303
304
305
306
	/* Horkage types. May be set by libata or controller on drives
	   (some horkage may be drive/controller pair dependant */

	ATA_HORKAGE_DIAGNOSTIC	= (1 << 0),	/* Failed boot diag */
307
308
	ATA_HORKAGE_NODMA	= (1 << 1),	/* DMA problems */
	ATA_HORKAGE_NONCQ	= (1 << 2),	/* Don't use NCQ */
309
	ATA_HORKAGE_MAX_SEC_128	= (1 << 3),	/* Limit max sects to 128 */
310
	ATA_HORKAGE_BROKEN_HPA	= (1 << 4),	/* Broken HPA */
Linus Torvalds's avatar
Linus Torvalds committed
311
312
};

313
enum hsm_task_states {
314
	HSM_ST_IDLE,		/* no command on going */
315
316
	HSM_ST_FIRST,		/* (waiting the device to)
				   write CDB or first data block */
317
318
319
	HSM_ST,			/* (waiting the device to) transfer data */
	HSM_ST_LAST,		/* (waiting the device to) complete command */
	HSM_ST_ERR,		/* error */
Linus Torvalds's avatar
Linus Torvalds committed
320
321
};

322
enum ata_completion_errors {
323
324
325
326
327
328
329
330
331
	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 */
332
	AC_ERR_NODEV_HINT	= (1 << 9), /* polling device detection hint */
Tejun Heo's avatar
Tejun Heo committed
333
	AC_ERR_NCQ		= (1 << 10), /* marker for offending NCQ qc */
334
335
};

Linus Torvalds's avatar
Linus Torvalds committed
336
337
338
339
/* forward declarations */
struct scsi_device;
struct ata_port_operations;
struct ata_port;
Tejun Heo's avatar
Tejun Heo committed
340
struct ata_link;
Linus Torvalds's avatar
Linus Torvalds committed
341
342
343
struct ata_queued_cmd;

/* typedefs */
344
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
Tejun Heo's avatar
Tejun Heo committed
345
346
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,
347
			      unsigned long deadline);
Tejun Heo's avatar
Tejun Heo committed
348
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
Linus Torvalds's avatar
Linus Torvalds committed
349
350

struct ata_ioports {
Tejun Heo's avatar
Tejun Heo committed
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
	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;
	void __iomem		*bmdma_addr;
	void __iomem		*scr_addr;
Linus Torvalds's avatar
Linus Torvalds committed
366
367
};

Jeff Garzik's avatar
Jeff Garzik committed
368
struct ata_host {
Linus Torvalds's avatar
Linus Torvalds committed
369
370
371
	spinlock_t		lock;
	struct device 		*dev;
	unsigned long		irq;
372
	unsigned long		irq2;
Tejun Heo's avatar
Tejun Heo committed
373
	void __iomem * const	*iomap;
Linus Torvalds's avatar
Linus Torvalds committed
374
375
	unsigned int		n_ports;
	void			*private_data;
376
	const struct ata_port_operations *ops;
377
	unsigned long		flags;
378
379
380
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
#endif
Alan's avatar
Alan committed
381
	struct ata_port		*simplex_claimed;	/* channel owning the DMA */
382
	struct ata_port		*ports[0];
Linus Torvalds's avatar
Linus Torvalds committed
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
};

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;
398
	unsigned int		orig_n_elem;
Linus Torvalds's avatar
Linus Torvalds committed
399
400
401

	int			dma_dir;

402
	unsigned int		pad_len;
403
	unsigned int		sect_size;
404

Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
408
409
410
411
	unsigned int		nbytes;
	unsigned int		curbytes;

	unsigned int		cursg;
	unsigned int		cursg_ofs;

	struct scatterlist	sgent;
412
	struct scatterlist	pad_sgent;
Linus Torvalds's avatar
Linus Torvalds committed
413
414
	void			*buf_virt;

415
416
	/* DO NOT iterate over __sg manually, use ata_for_each_sg() */
	struct scatterlist	*__sg;
Linus Torvalds's avatar
Linus Torvalds committed
417

418
	unsigned int		err_mask;
419
	struct ata_taskfile	result_tf;
Linus Torvalds's avatar
Linus Torvalds committed
420
421
422
	ata_qc_cb_t		complete_fn;

	void			*private_data;
423
	void			*lldd_task;
Linus Torvalds's avatar
Linus Torvalds committed
424
425
};

Jeff Garzik's avatar
Jeff Garzik committed
426
struct ata_port_stats {
Linus Torvalds's avatar
Linus Torvalds committed
427
428
429
430
431
	unsigned long		unhandled_irq;
	unsigned long		idle_irq;
	unsigned long		rw_reqbuf;
};

432
433
434
435
436
437
438
439
440
441
442
struct ata_ering_entry {
	int			is_io;
	unsigned int		err_mask;
	u64			timestamp;
};

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

Linus Torvalds's avatar
Linus Torvalds committed
443
struct ata_device {
Tejun Heo's avatar
Tejun Heo committed
444
	struct ata_link		*link;
445
	unsigned int		devno;		/* 0 or 1 */
Linus Torvalds's avatar
Linus Torvalds committed
446
	unsigned long		flags;		/* ATA_DFLAG_xxx */
Tejun Heo's avatar
Tejun Heo committed
447
	unsigned int		horkage;	/* List of broken features */
448
	struct scsi_device	*sdev;		/* attached SCSI device */
449
450
451
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
#endif
452
453
	/* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
	u64			n_sectors;	/* size of device, if ATA */
Linus Torvalds's avatar
Linus Torvalds committed
454
	unsigned int		class;		/* ATA_DEV_xxx */
455
	u16			id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
Linus Torvalds's avatar
Linus Torvalds committed
456
457
458
459
460
	u8			pio_mode;
	u8			dma_mode;
	u8			xfer_mode;
	unsigned int		xfer_shift;	/* ATA_SHIFT_xxx */

461
462
	unsigned int		multi_count;	/* sectors count for
						   READ/WRITE MULTIPLE */
463
	unsigned int		max_sectors;	/* per-device max sectors */
464
	unsigned int		cdb_len;
465

466
467
468
469
470
	/* per-dev xfer mask */
	unsigned int		pio_mask;
	unsigned int		mwdma_mask;
	unsigned int		udma_mask;

471
472
473
474
	/* for CHS addressing */
	u16			cylinders;	/* Number of cylinders */
	u16			heads;		/* Number of heads */
	u16			sectors;	/* Number of sectors per track */
475
476
477

	/* error history */
	struct ata_ering	ering;
478
	int			spdn_cnt;
Linus Torvalds's avatar
Linus Torvalds committed
479
480
};

481
482
483
484
485
/* Offset into struct ata_device.  Fields above it are maintained
 * acress device init.  Fields below are zeroed.
 */
#define ATA_DEVICE_CLEAR_OFFSET		offsetof(struct ata_device, n_sectors)

486
487
488
489
490
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 */
491
	unsigned int		dev_action[ATA_MAX_DEVICES]; /* dev EH action */
492
	unsigned int		flags;		/* ATA_EHI_* flags */
493
494
495

	unsigned int		probe_mask;

496
497
498
499
500
501
502
	char			desc[ATA_EH_DESC_LEN];
	int			desc_len;
};

struct ata_eh_context {
	struct ata_eh_info	i;
	int			tries[ATA_MAX_DEVICES];
503
504
	unsigned int		classes[ATA_MAX_DEVICES];
	unsigned int		did_probe_mask;
505
506
};

507
508
509
510
511
512
513
514
515
516
517
struct ata_acpi_drive
{
	u32 pio;
	u32 dma;
} __packed;

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

Tejun Heo's avatar
Tejun Heo committed
518
519
struct ata_link {
	struct ata_port		*ap;
Tejun Heo's avatar
Tejun Heo committed
520
	int			pmp;		/* port multiplier port # */
Tejun Heo's avatar
Tejun Heo committed
521
522
523
524

	unsigned int		active_tag;	/* active tag on this link */
	u32			sactive;	/* active NCQ commands */

525
526
	unsigned int		flags;		/* ATA_LFLAG_xxx */

Tejun Heo's avatar
Tejun Heo committed
527
528
529
530
531
532
533
534
535
536
537
538
	unsigned int		hw_sata_spd_limit;
	unsigned int		sata_spd_limit;
	unsigned int		sata_spd;	/* current SATA PHY speed */

	/* 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];
};

Linus Torvalds's avatar
Linus Torvalds committed
539
struct ata_port {
Jeff Garzik's avatar
Jeff Garzik committed
540
	struct Scsi_Host	*scsi_host; /* our co-allocated scsi host */
541
	const struct ata_port_operations *ops;
542
	spinlock_t		*lock;
Linus Torvalds's avatar
Linus Torvalds committed
543
	unsigned long		flags;	/* ATA_FLAG_xxx */
544
	unsigned int		pflags; /* ATA_PFLAG_xxx */
Tejun Heo's avatar
Tejun Heo committed
545
546
	unsigned int		print_id; /* user visible unique port ID */
	unsigned int		port_no; /* 0 based port no. inside the host */
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
550

	struct ata_prd		*prd;	 /* our SG list */
	dma_addr_t		prd_dma; /* and its DMA mapping */

551
552
553
	void			*pad;	/* array of DMA pad buffers */
	dma_addr_t		pad_dma;

Linus Torvalds's avatar
Linus Torvalds committed
554
555
556
557
558
559
560
561
562
563
	struct ata_ioports	ioaddr;	/* ATA cmd/ctl/dma register blocks */

	u8			ctl;	/* cache of ATA control register */
	u8			last_ctl;	/* Cache last written value */
	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];
564
	unsigned long		qc_allocated;
565
566
	unsigned int		qc_active;

Tejun Heo's avatar
Tejun Heo committed
567
	struct ata_link		link;	/* host default link */
Linus Torvalds's avatar
Linus Torvalds committed
568

Tejun Heo's avatar
Tejun Heo committed
569
570
571
	int			nr_pmp_links;	/* nr of available PMP links */
	struct ata_link		*pmp_link;	/* array of PMP links */

Jeff Garzik's avatar
Jeff Garzik committed
572
573
	struct ata_port_stats	stats;
	struct ata_host		*host;
574
	struct device 		*dev;
Linus Torvalds's avatar
Linus Torvalds committed
575

576
	void			*port_task_data;
577
578
	struct delayed_work	port_task;
	struct delayed_work	hotplug_task;
579
	struct work_struct	scsi_rescan_task;
580

581
	unsigned int		hsm_task_state;
Linus Torvalds's avatar
Linus Torvalds committed
582

583
	u32			msg_enable;
584
	struct list_head	eh_done_q;
585
	wait_queue_head_t	eh_wait_q;
586

587
588
589
	pm_message_t		pm_mesg;
	int			*pm_result;

Tejun Heo's avatar
Tejun Heo committed
590
591
592
	struct timer_list	fastdrain_timer;
	unsigned long		fastdrain_cnt;

Linus Torvalds's avatar
Linus Torvalds committed
593
	void			*private_data;
594

595
596
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
597
	struct ata_acpi_gtm	acpi_gtm;
598
#endif
599
	u8			sector_buf[ATA_SECT_SIZE]; /* owned by EH */
Linus Torvalds's avatar
Linus Torvalds committed
600
601
602
603
604
};

struct ata_port_operations {
	void (*port_disable) (struct ata_port *);

605
	void (*dev_config) (struct ata_device *);
Linus Torvalds's avatar
Linus Torvalds committed
606
607
608

	void (*set_piomode) (struct ata_port *, struct ata_device *);
	void (*set_dmamode) (struct ata_port *, struct ata_device *);
609
	unsigned long (*mode_filter) (struct ata_device *, unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
610

611
	void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
Linus Torvalds's avatar
Linus Torvalds committed
612
613
	void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);

614
	void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
Linus Torvalds's avatar
Linus Torvalds committed
615
616
617
618
	u8   (*check_status)(struct ata_port *ap);
	u8   (*check_altstatus)(struct ata_port *ap);
	void (*dev_select)(struct ata_port *ap, unsigned int device);

619
	void (*phy_reset) (struct ata_port *ap); /* obsolete */
620
	int  (*set_mode) (struct ata_link *link, struct ata_device **r_failed_dev);
621

Alan Cox's avatar
Alan Cox committed
622
623
	int (*cable_detect) (struct ata_port *ap);

Alan's avatar
Alan committed
624
	int  (*check_atapi_dma) (struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
625
626
627
628

	void (*bmdma_setup) (struct ata_queued_cmd *qc);
	void (*bmdma_start) (struct ata_queued_cmd *qc);

629
630
	void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);

Linus Torvalds's avatar
Linus Torvalds committed
631
	void (*qc_prep) (struct ata_queued_cmd *qc);
632
	unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
633

634
635
636
637
638
639
640
641
642
	/* Error handlers.  ->error_handler overrides ->eng_timeout and
	 * indicates that new-style EH is in place.
	 */
	void (*eng_timeout) (struct ata_port *ap); /* obsolete */

	void (*freeze) (struct ata_port *ap);
	void (*thaw) (struct ata_port *ap);
	void (*error_handler) (struct ata_port *ap);
	void (*post_internal_cmd) (struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
643

644
	irq_handler_t irq_handler;
Linus Torvalds's avatar
Linus Torvalds committed
645
	void (*irq_clear) (struct ata_port *);
646
647
	u8 (*irq_on) (struct ata_port *);
	u8 (*irq_ack) (struct ata_port *ap, unsigned int chk_drq);
Linus Torvalds's avatar
Linus Torvalds committed
648

649
650
	int (*scr_read) (struct ata_port *ap, unsigned int sc_reg, u32 *val);
	int (*scr_write) (struct ata_port *ap, unsigned int sc_reg, u32 val);
Linus Torvalds's avatar
Linus Torvalds committed
651

652
653
654
	int (*port_suspend) (struct ata_port *ap, pm_message_t mesg);
	int (*port_resume) (struct ata_port *ap);

Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
	int (*port_start) (struct ata_port *ap);
	void (*port_stop) (struct ata_port *ap);

Jeff Garzik's avatar
Jeff Garzik committed
658
	void (*host_stop) (struct ata_host *host);
Linus Torvalds's avatar
Linus Torvalds committed
659

660
	void (*bmdma_stop) (struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
661
662
663
664
	u8   (*bmdma_status) (struct ata_port *ap);
};

struct ata_port_info {
665
	struct scsi_host_template	*sht;
Jeff Garzik's avatar
Jeff Garzik committed
666
	unsigned long		flags;
667
	unsigned long		link_flags;
Linus Torvalds's avatar
Linus Torvalds committed
668
669
670
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;
671
	const struct ata_port_operations *port_ops;
672
	irq_handler_t		irq_handler;
673
	void 			*private_data;
Linus Torvalds's avatar
Linus Torvalds committed
674
675
};

676
677
678
679
680
681
682
683
684
685
686
687
688
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 */
	unsigned short cycle;		/* t0 */
	unsigned short udma;		/* t2CYCTYP/2 */
};

#define FIT(v,vmin,vmax)	max_t(short,min_t(short,v,vmax),vmin)
Linus Torvalds's avatar
Linus Torvalds committed
689

690
691
692
693
extern const unsigned long sata_deb_timing_normal[];
extern const unsigned long sata_deb_timing_hotplug[];
extern const unsigned long sata_deb_timing_long[];

694
extern const struct ata_port_operations ata_dummy_port_ops;
695
extern const struct ata_port_info ata_dummy_port_info;
696

697
698
699
700
701
702
703
704
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;
}
705

706
707
708
709
710
static inline int ata_port_is_dummy(struct ata_port *ap)
{
	return ap->ops == &ata_dummy_port_ops;
}

711
extern void sata_print_link_status(struct ata_link *link);
Linus Torvalds's avatar
Linus Torvalds committed
712
713
714
715
extern void ata_port_probe(struct ata_port *);
extern void __sata_phy_reset(struct ata_port *ap);
extern void sata_phy_reset(struct ata_port *ap);
extern void ata_bus_reset(struct ata_port *ap);
716
717
718
719
720
extern int sata_set_spd(struct ata_link *link);
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);
Tejun Heo's avatar
Tejun Heo committed
721
722
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
extern int ata_std_softreset(struct ata_link *link, unsigned int *classes,
723
			     unsigned long deadline);
Tejun Heo's avatar
Tejun Heo committed
724
725
726
extern int sata_link_hardreset(struct ata_link *link,
			const unsigned long *timing, unsigned long deadline);
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
727
			      unsigned long deadline);
Tejun Heo's avatar
Tejun Heo committed
728
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
Linus Torvalds's avatar
Linus Torvalds committed
729
730
731
extern void ata_port_disable(struct ata_port *);
extern void ata_std_ports(struct ata_ioports *ioaddr);
#ifdef CONFIG_PCI
Tejun Heo's avatar
Tejun Heo committed
732
733
extern int ata_pci_init_one (struct pci_dev *pdev,
			     const struct ata_port_info * const * ppi);
Linus Torvalds's avatar
Linus Torvalds committed
734
extern void ata_pci_remove_one (struct pci_dev *pdev);
735
#ifdef CONFIG_PM
736
extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
737
extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
738
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
739
extern int ata_pci_device_resume(struct pci_dev *pdev);
740
#endif
741
extern int ata_pci_clear_simplex(struct pci_dev *pdev);
Linus Torvalds's avatar
Linus Torvalds committed
742
#endif /* CONFIG_PCI */
743
extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
744
745
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
			const struct ata_port_info * const * ppi, int n_ports);
746
extern int ata_host_start(struct ata_host *host);
747
748
extern int ata_host_register(struct ata_host *host,
			     struct scsi_host_template *sht);
749
750
751
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);
752
extern void ata_host_detach(struct ata_host *host);
Jeff Garzik's avatar
Jeff Garzik committed
753
754
extern void ata_host_init(struct ata_host *, struct device *,
			  unsigned long, const struct ata_port_operations *);
755
extern int ata_scsi_detect(struct scsi_host_template *sht);
Linus Torvalds's avatar
Linus Torvalds committed
756
757
extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
758
extern void ata_scsi_media_change_notify(struct ata_device *atadev);
759
extern void ata_sas_port_destroy(struct ata_port *);
Jeff Garzik's avatar
Jeff Garzik committed
760
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
761
762
763
764
765
766
767
					   struct ata_port_info *, struct Scsi_Host *);
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 *);
extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
			    struct ata_port *ap);
Linus Torvalds's avatar
Linus Torvalds committed
768
extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
769
770
771
772
773
774
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);
extern int ata_link_online(struct ata_link *link);
extern int ata_link_offline(struct ata_link *link);
775
#ifdef CONFIG_PM
Jeff Garzik's avatar
Jeff Garzik committed
776
777
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
extern void ata_host_resume(struct ata_host *host);
778
#endif
779
extern int ata_ratelimit(void);
780
781
extern int ata_busy_sleep(struct ata_port *ap,
			  unsigned long timeout_pat, unsigned long timeout);
782
extern int ata_wait_ready(struct ata_port *ap, unsigned long deadline);
783
extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
784
				void *data, unsigned long delay);
785
786
787
extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
			     unsigned long interval_msec,
			     unsigned long timeout_msec);
Akira Iguchi's avatar
Akira Iguchi committed
788
extern unsigned int ata_dev_try_classify(struct ata_port *, unsigned int, u8 *);
789

Linus Torvalds's avatar
Linus Torvalds committed
790
791
792
/*
 * Default driver ops implementations
 */
793
extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
Linus Torvalds's avatar
Linus Torvalds committed
794
extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
795
796
extern void ata_tf_to_fis(const struct ata_taskfile *tf,
			  u8 pmp, int is_cmd, u8 *fis);
797
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
Linus Torvalds's avatar
Linus Torvalds committed
798
799
800
801
extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
extern u8 ata_check_status(struct ata_port *ap);
extern u8 ata_altstatus(struct ata_port *ap);
802
extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
Linus Torvalds's avatar
Linus Torvalds committed
803
extern int ata_port_start (struct ata_port *ap);
804
extern int ata_sff_port_start (struct ata_port *ap);
805
extern irqreturn_t ata_interrupt (int irq, void *dev_instance);
Tejun Heo's avatar
Tejun Heo committed
806
807
808
809
extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
			  unsigned int buflen, int write_data);
extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
				unsigned int buflen, int write_data);
810
extern void ata_dumb_qc_prep(struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
811
extern void ata_qc_prep(struct ata_queued_cmd *qc);
812
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
813
extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
814
815
816
817
extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
		unsigned int buflen);
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
		 unsigned int n_elem);
818
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
819
extern void ata_dev_disable(struct ata_device *adev);
820
821
822
823
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);
824
extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
Linus Torvalds's avatar
Linus Torvalds committed
825
826
extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
extern void ata_bmdma_start (struct ata_queued_cmd *qc);
827
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
828
829
extern u8   ata_bmdma_status(struct ata_port *ap);
extern void ata_bmdma_irq_clear(struct ata_port *ap);
830
831
extern void ata_bmdma_freeze(struct ata_port *ap);
extern void ata_bmdma_thaw(struct ata_port *ap);
832
extern void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
833
834
835
836
837
			       ata_reset_fn_t softreset,
			       ata_reset_fn_t hardreset,
			       ata_postreset_fn_t postreset);
extern void ata_bmdma_error_handler(struct ata_port *ap);
extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
838
839
extern int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
			u8 status, int in_wq);
840
extern void ata_qc_complete(struct ata_queued_cmd *qc);
841
842
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
				    void (*finish_qc)(struct ata_queued_cmd *));
Tejun Heo's avatar
Tejun Heo committed
843
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
Linus Torvalds's avatar
Linus Torvalds committed
844
845
846
847
848
			      void (*done)(struct scsi_cmnd *));
extern int ata_std_bios_param(struct scsi_device *sdev,
			      struct block_device *bdev,
			      sector_t capacity, int geom[]);
extern int ata_scsi_slave_config(struct scsi_device *sdev);
849
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
850
851
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
				       int queue_depth);
Tejun Heo's avatar
Tejun Heo committed
852
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
853
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
854
855
856
857
extern u8 ata_irq_on(struct ata_port *ap);
extern u8 ata_dummy_irq_on(struct ata_port *ap);
extern u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq);
extern u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq);
Linus Torvalds's avatar
Linus Torvalds committed
858

Alan Cox's avatar
Alan Cox committed
859
860
861
862
863
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);
extern int ata_cable_unknown(struct ata_port *ap);

864
865
866
/*
 * Timing helpers
 */
867
868

extern unsigned int ata_pio_need_iordy(const struct ata_device *);
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
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);

enum {
	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),
	ATA_TIMING_CYCLE	= (1 << 6),
	ATA_TIMING_UDMA		= (1 << 7),
	ATA_TIMING_ALL		= ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
				  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
				  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
				  ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
};

Linus Torvalds's avatar
Linus Torvalds committed
892
893
894
895
896
897
898
899
900

#ifdef CONFIG_PCI
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;
};

901
extern int ata_pci_init_sff_host(struct ata_host *host);
Tejun Heo's avatar
Tejun Heo committed
902
extern int ata_pci_init_bmdma(struct ata_host *host);
903
904
905
extern int ata_pci_prepare_sff_host(struct pci_dev *pdev,
				    const struct ata_port_info * const * ppi,
				    struct ata_host **r_host);
906
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
907
extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
908
909
#endif /* CONFIG_PCI */

910
911
912
913
/*
 * EH
 */
extern void ata_eng_timeout(struct ata_port *ap);
914
915

extern void ata_port_schedule_eh(struct ata_port *ap);
916
extern int ata_link_abort(struct ata_link *link);
917
extern int ata_port_abort(struct ata_port *ap);
918
919
920
921
extern int ata_port_freeze(struct ata_port *ap);

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

923
924
925
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);

926
927
928
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);
929

930
931
932
933
/*
 * printk helpers
 */
#define ata_port_printk(ap, lv, fmt, args...) \
Tejun Heo's avatar
Tejun Heo committed
934
	printk(lv"ata%u: "fmt, (ap)->print_id , ##args)
935

Tejun Heo's avatar
Tejun Heo committed
936
937
938
939
940
941
942
#define ata_link_printk(link, lv, fmt, args...) do { \
	if ((link)->ap->nr_pmp_links) \
		printk(lv"ata%u.%02u: "fmt, (link)->ap->print_id, \
		       (link)->pmp , ##args); \
	else \
		printk(lv"ata%u: "fmt, (link)->ap->print_id , ##args); \
	} while(0)
Tejun Heo's avatar
Tejun Heo committed
943

944
#define ata_dev_printk(dev, lv, fmt, args...) \
Tejun Heo's avatar
Tejun Heo committed
945
946
	printk(lv"ata%u.%02u: "fmt, (dev)->link->ap->print_id, \
	       (dev)->link->pmp + (dev)->devno , ##args)
Linus Torvalds's avatar
Linus Torvalds committed
947

948
949
950
/*
 * ata_eh_info helpers
 */
951
952
953
extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
954

955
static inline void ata_ehi_schedule_probe(struct ata_eh_info *ehi)
956
{
957
	ehi->flags |= ATA_EHI_RESUME_LINK;
958
959
960
961
	ehi->action |= ATA_EH_SOFTRESET;
	ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
}

962
963
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
{
964
965
	ata_ehi_schedule_probe(ehi);
	ehi->flags |= ATA_EHI_HOTPLUGGED;
966
967
968
	ehi->err_mask |= AC_ERR_ATA_BUS;
}

969
970
971
/*
 * qc helpers
 */
972
973
974
975
976
977
978
979
980
981
982
983
static inline int
ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
{
	if (sg == &qc->pad_sgent)
		return 1;
	if (qc->pad_len)
		return 0;
	if (((sg - qc->__sg) + 1) == qc->n_elem)
		return 1;
	return 0;
}

984
985
986
987
988
989
990
991
992
993
static inline struct scatterlist *
ata_qc_first_sg(struct ata_queued_cmd *qc)
{
	if (qc->n_elem)
		return qc->__sg;
	if (qc->pad_len)
		return &qc->pad_sgent;
	return NULL;
}

994
995
996
997
998
999
1000
static inline struct scatterlist *
ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
{
	if (sg == &qc->pad_sgent)
		return NULL;
	if (++sg - qc->__sg < qc->n_elem)
		return sg;
1001
1002
1003
	if (qc->pad_len)
		return &qc->pad_sgent;
	return NULL;
1004
1005
1006
}

#define ata_for_each_sg(sg, qc) \
1007
	for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
1008

Linus Torvalds's avatar
Linus Torvalds committed
1009
1010
1011
1012
1013
static inline unsigned int ata_tag_valid(unsigned int tag)
{
	return (tag < ATA_MAX_QUEUE) ? 1 : 0;
}

1014
1015
1016
1017
1018
static inline unsigned int ata_tag_internal(unsigned int tag)
{
	return tag == ATA_MAX_QUEUE - 1;
}

1019
1020
1021
/*
 * device helpers
 */
1022
static inline unsigned int ata_class_enabled(unsigned int class)
1023
1024
1025
1026
{
	return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
}

1027
static inline unsigned int ata_class_disabled(unsigned int class)
Linus Torvalds's avatar
Linus Torvalds committed
1028
{
1029
1030
1031
	return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP;
}

1032
1033
1034
1035
1036
static inline unsigned int ata_class_absent(unsigned int class)
{
	return !ata_class_enabled(class) && !ata_class_disabled(class);
}

1037
1038
1039
1040
1041
1042
1043
1044
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);
Linus Torvalds's avatar
Linus Torvalds committed
1045
1046
}

1047
1048
1049
1050
1051
static inline unsigned int ata_dev_absent(const struct ata_device *dev)
{
	return ata_class_absent(dev->class);
}

1052
/*
1053
 * link helpers
1054
 */
Tejun Heo's avatar
Tejun Heo committed
1055
1056
1057
1058
1059
static inline int ata_is_host_link(const struct ata_link *link)
{
	return link == &link->ap->link;
}

1060
static inline int ata_link_max_devices(const struct ata_link *link)
1061
{
Tejun Heo's avatar
Tejun Heo committed
1062
	if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
1063
1064
1065
1066
		return 2;
	return 1;
}

Tejun Heo's avatar
Tejun Heo committed
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
static inline struct ata_link *ata_port_first_link(struct ata_port *ap)
{
	if (ap->nr_pmp_links)
		return ap->pmp_link;
	return &ap->link;
}

static inline struct ata_link *ata_port_next_link(struct ata_link *link)
{
	struct ata_port *ap = link->ap;

	if (link == &ap->link) {
		if (!ap->nr_pmp_links)
			return NULL;
		return ap->pmp_link;
	}

	if (++link - ap->pmp_link < ap->nr_pmp_links)
		return link;
	return NULL;
}

#define __ata_port_for_each_link(lk, ap) \
	for ((lk) = &(ap)->link; (lk); (lk) = ata_port_next_link(lk))

#define ata_port_for_each_link(link, ap) \
	for ((link) = ata_port_first_link(ap); (link); \
	     (link) = ata_port_next_link(link))
1095
1096
1097
1098
1099
1100
1101
1102
1103

#define ata_link_for_each_dev(dev, link) \
	for ((dev) = (link)->device; \
	     (dev) < (link)->device + ata_link_max_devices(link) || ((dev) = NULL); \
	     (dev)++)

#define ata_link_for_each_dev_reverse(dev, link) \
	for ((dev) = (link)->device + ata_link_max_devices(link) - 1; \
	     (dev) >= (link)->device || ((dev) = NULL); (dev)--)
1104

Linus Torvalds's avatar
Linus Torvalds committed
1105
1106
1107
1108
1109
static inline u8 ata_chk_status(struct ata_port *ap)
{
	return ap->ops->check_status(ap);
}

1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
/**
 *	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;
}
1125
1126
1127
1128
1129
1130
1131
1132
1133