libata.h 26.8 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 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>
L
Linus Torvalds 已提交
33 34 35 36 37
#include <asm/io.h>
#include <linux/ata.h>
#include <linux/workqueue.h>

/*
38 39
 * compile-time options: to be removed as soon as all the drivers are
 * converted to the new debugging mechanism
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
 */
#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 */
#undef ATA_ENABLE_PATA		/* define to enable PATA support in some
				 * low-level drivers */
#undef ATAPI_ENABLE_DMADIR	/* enables ATAPI DMADIR bridge support */


/* 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 */

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

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
/* 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 已提交
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
/* 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,
	ATA_MAX_PORTS		= 8,
	ATA_DEF_QUEUE		= 1,
	ATA_MAX_QUEUE		= 1,
	ATA_MAX_SECTORS		= 200,	/* FIXME */
	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,
120
	ATA_SHT_USE_CLUSTERING	= 1,
L
Linus Torvalds 已提交
121 122 123 124

	/* struct ata_device stuff */
	ATA_DFLAG_LBA48		= (1 << 0), /* device supports LBA48 */
	ATA_DFLAG_PIO		= (1 << 1), /* device currently in PIO mode */
125
	ATA_DFLAG_LBA		= (1 << 2), /* device supports LBA */
L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138 139

	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 */

	/* struct ata_port flags */
	ATA_FLAG_SLAVE_POSS	= (1 << 1), /* host supports slave dev */
					    /* (doesn't imply presence) */
	ATA_FLAG_PORT_DISABLED	= (1 << 2), /* port is disabled, ignore it */
	ATA_FLAG_SATA		= (1 << 3),
	ATA_FLAG_NO_LEGACY	= (1 << 4), /* no legacy mode check */
140
	ATA_FLAG_SRST		= (1 << 5), /* (obsolete) use ATA SRST, not E.D.D. */
L
Linus Torvalds 已提交
141
	ATA_FLAG_MMIO		= (1 << 6), /* use MMIO, not PIO */
142
	ATA_FLAG_SATA_RESET	= (1 << 7), /* (obsolete) use COMRESET */
L
Linus Torvalds 已提交
143
	ATA_FLAG_PIO_DMA	= (1 << 8), /* PIO cmds via DMA */
144 145
	ATA_FLAG_NOINTR		= (1 << 9), /* FIXME: Remove this once
					     * proper HSM is in place. */
J
Jeff Garzik 已提交
146
	ATA_FLAG_DEBUGMSG	= (1 << 10),
147
	ATA_FLAG_NO_ATAPI	= (1 << 11), /* No ATAPI support */
L
Linus Torvalds 已提交
148

J
Jens Axboe 已提交
149 150
	ATA_FLAG_SUSPENDED	= (1 << 12), /* port is suspended */

151 152 153
	ATA_FLAG_PIO_LBA48	= (1 << 13), /* Host DMA engine is LBA28 only */
	ATA_FLAG_IRQ_MASK	= (1 << 14), /* Mask IRQ in PIO xfers */

154
	ATA_FLAG_FLUSH_PORT_TASK = (1 << 15), /* Flush port task */
155
	ATA_FLAG_IN_EH		= (1 << 16), /* EH in progress */
156

L
Linus Torvalds 已提交
157 158 159 160
	ATA_QCFLAG_ACTIVE	= (1 << 1), /* cmd not yet ack'd to scsi lyer */
	ATA_QCFLAG_SG		= (1 << 3), /* have s/g table? */
	ATA_QCFLAG_SINGLE	= (1 << 4), /* no s/g, just a single buffer */
	ATA_QCFLAG_DMAMAP	= ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
161
	ATA_QCFLAG_EH_SCHEDULED = (1 << 5), /* EH scheduled */
L
Linus Torvalds 已提交
162 163

	/* various lengths of time */
164
	ATA_TMOUT_EDD		= 5 * HZ,	/* heuristic */
L
Linus Torvalds 已提交
165
	ATA_TMOUT_PIO		= 30 * HZ,
166 167
	ATA_TMOUT_BOOT		= 30 * HZ,	/* heuristic */
	ATA_TMOUT_BOOT_QUICK	= 7 * HZ,	/* heuristic */
L
Linus Torvalds 已提交
168 169
	ATA_TMOUT_CDB		= 30 * HZ,
	ATA_TMOUT_CDB_QUICK	= 5 * HZ,
170 171
	ATA_TMOUT_INTERNAL	= 30 * HZ,
	ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190

	/* 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
191
	 * unsigned int bitmap
L
Linus Torvalds 已提交
192
	 */
193 194 195 196 197 198 199 200 201 202 203
	ATA_BITS_PIO		= 5,
	ATA_BITS_MWDMA		= 3,
	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,
204 205 206 207

	/* 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,
208 209 210 211
	
	/* Masks for port functions */
	ATA_PORT_PRIMARY	= (1 << 0),
	ATA_PORT_SECONDARY	= (1 << 1),
L
Linus Torvalds 已提交
212 213
};

A
Albert Lee 已提交
214 215 216 217 218 219 220 221 222
enum hsm_task_states {
	HSM_ST_UNKNOWN,
	HSM_ST_IDLE,
	HSM_ST_POLL,
	HSM_ST_TMOUT,
	HSM_ST,
	HSM_ST_LAST,
	HSM_ST_LAST_POLL,
	HSM_ST_ERR,
L
Linus Torvalds 已提交
223 224
};

225
enum ata_completion_errors {
226 227 228 229 230 231 232 233 234
	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 */
235 236
};

L
Linus Torvalds 已提交
237 238 239 240 241 242 243
/* forward declarations */
struct scsi_device;
struct ata_port_operations;
struct ata_port;
struct ata_queued_cmd;

/* typedefs */
244
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
245
typedef void (*ata_probeinit_fn_t)(struct ata_port *);
246 247
typedef int (*ata_reset_fn_t)(struct ata_port *, int, unsigned int *);
typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *);
L
Linus Torvalds 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269

struct ata_ioports {
	unsigned long		cmd_addr;
	unsigned long		data_addr;
	unsigned long		error_addr;
	unsigned long		feature_addr;
	unsigned long		nsect_addr;
	unsigned long		lbal_addr;
	unsigned long		lbam_addr;
	unsigned long		lbah_addr;
	unsigned long		device_addr;
	unsigned long		status_addr;
	unsigned long		command_addr;
	unsigned long		altstatus_addr;
	unsigned long		ctl_addr;
	unsigned long		bmdma_addr;
	unsigned long		scr_addr;
};

struct ata_probe_ent {
	struct list_head	node;
	struct device 		*dev;
J
Jeff Garzik 已提交
270
	const struct ata_port_operations *port_ops;
271
	struct scsi_host_template *sht;
L
Linus Torvalds 已提交
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
	struct ata_ioports	port[ATA_MAX_PORTS];
	unsigned int		n_ports;
	unsigned int		hard_port_no;
	unsigned int		pio_mask;
	unsigned int		mwdma_mask;
	unsigned int		udma_mask;
	unsigned int		legacy_mode;
	unsigned long		irq;
	unsigned int		irq_flags;
	unsigned long		host_flags;
	void __iomem		*mmio_base;
	void			*private_data;
};

struct ata_host_set {
	spinlock_t		lock;
	struct device 		*dev;
	unsigned long		irq;
	void __iomem		*mmio_base;
	unsigned int		n_ports;
	void			*private_data;
J
Jeff Garzik 已提交
293
	const struct ata_port_operations *ops;
L
Linus Torvalds 已提交
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
	struct ata_port *	ports[0];
};

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;
310
	unsigned int		orig_n_elem;
L
Linus Torvalds 已提交
311 312 313

	int			dma_dir;

314 315
	unsigned int		pad_len;

L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323 324 325
	unsigned int		nsect;
	unsigned int		cursect;

	unsigned int		nbytes;
	unsigned int		curbytes;

	unsigned int		cursg;
	unsigned int		cursg_ofs;

	struct scatterlist	sgent;
326
	struct scatterlist	pad_sgent;
L
Linus Torvalds 已提交
327 328
	void			*buf_virt;

329 330
	/* DO NOT iterate over __sg manually, use ata_for_each_sg() */
	struct scatterlist	*__sg;
L
Linus Torvalds 已提交
331

332 333
	unsigned int		err_mask;

L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
	ata_qc_cb_t		complete_fn;

	void			*private_data;
};

struct ata_host_stats {
	unsigned long		unhandled_irq;
	unsigned long		idle_irq;
	unsigned long		rw_reqbuf;
};

struct ata_device {
	u64			n_sectors;	/* size of device, if ATA */
	unsigned long		flags;		/* ATA_DFLAG_xxx */
	unsigned int		class;		/* ATA_DEV_xxx */
	unsigned int		devno;		/* 0 or 1 */
350
	u16			*id;		/* IDENTIFY xxx DEVICE data */
L
Linus Torvalds 已提交
351 352 353 354 355
	u8			pio_mode;
	u8			dma_mode;
	u8			xfer_mode;
	unsigned int		xfer_shift;	/* ATA_SHIFT_xxx */

356 357
	unsigned int		multi_count;	/* sectors count for
						   READ/WRITE MULTIPLE */
358
	unsigned int		max_sectors;	/* per-device max sectors */
359
	unsigned int		cdb_len;
360 361 362 363 364

	/* for CHS addressing */
	u16			cylinders;	/* Number of cylinders */
	u16			heads;		/* Number of heads */
	u16			sectors;	/* Number of sectors per track */
L
Linus Torvalds 已提交
365 366 367 368
};

struct ata_port {
	struct Scsi_Host	*host;	/* our co-allocated scsi host */
J
Jeff Garzik 已提交
369
	const struct ata_port_operations *ops;
L
Linus Torvalds 已提交
370 371 372 373 374 375 376 377
	unsigned long		flags;	/* ATA_FLAG_xxx */
	unsigned int		id;	/* unique id req'd by scsi midlyr */
	unsigned int		port_no; /* unique port #; from zero */
	unsigned int		hard_port_no;	/* hardware port #; from zero */

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

378 379 380
	void			*pad;	/* array of DMA pad buffers */
	dma_addr_t		pad_dma;

L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	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_device	device[ATA_MAX_DEVICES];

	struct ata_queued_cmd	qcmd[ATA_MAX_QUEUE];
	unsigned long		qactive;
	unsigned int		active_tag;

	struct ata_host_stats	stats;
	struct ata_host_set	*host_set;

T
Tejun Heo 已提交
399 400
	struct work_struct	port_task;

A
Albert Lee 已提交
401
	unsigned int		hsm_task_state;
L
Linus Torvalds 已提交
402 403
	unsigned long		pio_task_timeout;

404
	u32			msg_enable;
405
	struct list_head	eh_done_q;
406

L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417
	void			*private_data;
};

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

	void (*dev_config) (struct ata_port *, struct ata_device *);

	void (*set_piomode) (struct ata_port *, struct ata_device *);
	void (*set_dmamode) (struct ata_port *, struct ata_device *);

J
Jeff Garzik 已提交
418
	void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
L
Linus Torvalds 已提交
419 420
	void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);

J
Jeff Garzik 已提交
421
	void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
L
Linus Torvalds 已提交
422 423 424 425
	u8   (*check_status)(struct ata_port *ap);
	u8   (*check_altstatus)(struct ata_port *ap);
	void (*dev_select)(struct ata_port *ap, unsigned int device);

426 427 428
	void (*phy_reset) (struct ata_port *ap); /* obsolete */
	int (*probe_reset) (struct ata_port *ap, unsigned int *classes);

L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436
	void (*post_set_mode) (struct ata_port *ap);

	int (*check_atapi_dma) (struct ata_queued_cmd *qc);

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

	void (*qc_prep) (struct ata_queued_cmd *qc);
437
	unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452

	void (*eng_timeout) (struct ata_port *ap);

	irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
	void (*irq_clear) (struct ata_port *);

	u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
	void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
			   u32 val);

	int (*port_start) (struct ata_port *ap);
	void (*port_stop) (struct ata_port *ap);

	void (*host_stop) (struct ata_host_set *host_set);

453
	void (*bmdma_stop) (struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
454 455 456 457
	u8   (*bmdma_status) (struct ata_port *ap);
};

struct ata_port_info {
458
	struct scsi_host_template	*sht;
L
Linus Torvalds 已提交
459 460 461 462
	unsigned long		host_flags;
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;
J
Jeff Garzik 已提交
463
	const struct ata_port_operations *port_ops;
464
	void 			*private_data;
L
Linus Torvalds 已提交
465 466
};

A
Alan Cox 已提交
467 468 469 470 471 472 473 474 475 476 477 478 479
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)
L
Linus Torvalds 已提交
480 481 482 483 484

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);
485
extern int ata_drive_probe_reset(struct ata_port *ap,
486
			ata_probeinit_fn_t probeinit,
487 488
			ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
			ata_postreset_fn_t postreset, unsigned int *classes);
489
extern void ata_std_probeinit(struct ata_port *ap);
490 491 492 493 494
extern int ata_std_softreset(struct ata_port *ap, int verbose,
			     unsigned int *classes);
extern int sata_std_hardreset(struct ata_port *ap, int verbose,
			      unsigned int *class);
extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
495 496
extern int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
			      int post_reset);
L
Linus Torvalds 已提交
497 498 499 500 501 502
extern void ata_port_disable(struct ata_port *);
extern void ata_std_ports(struct ata_ioports *ioaddr);
#ifdef CONFIG_PCI
extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
			     unsigned int n_ports);
extern void ata_pci_remove_one (struct pci_dev *pdev);
J
Jens Axboe 已提交
503 504
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state);
extern int ata_pci_device_resume(struct pci_dev *pdev);
505
extern int ata_pci_clear_simplex(struct pci_dev *pdev);
L
Linus Torvalds 已提交
506
#endif /* CONFIG_PCI */
J
Jeff Garzik 已提交
507
extern int ata_device_add(const struct ata_probe_ent *ent);
508
extern void ata_host_set_remove(struct ata_host_set *host_set);
509
extern int ata_scsi_detect(struct scsi_host_template *sht);
L
Linus Torvalds 已提交
510 511
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 *));
512
extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
L
Linus Torvalds 已提交
513
extern int ata_scsi_error(struct Scsi_Host *host);
514 515
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
516 517
extern int ata_scsi_release(struct Scsi_Host *host);
extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
J
Jens Axboe 已提交
518 519 520 521
extern int ata_scsi_device_resume(struct scsi_device *);
extern int ata_scsi_device_suspend(struct scsi_device *);
extern int ata_device_resume(struct ata_port *, struct ata_device *);
extern int ata_device_suspend(struct ata_port *, struct ata_device *);
522
extern int ata_ratelimit(void);
523 524 525
extern unsigned int ata_busy_sleep(struct ata_port *ap,
				   unsigned long timeout_pat,
				   unsigned long timeout);
T
Tejun Heo 已提交
526 527
extern void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *),
				void *data, unsigned long delay);
528

L
Linus Torvalds 已提交
529 530 531
/*
 * Default driver ops implementations
 */
J
Jeff Garzik 已提交
532
extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
L
Linus Torvalds 已提交
533
extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
J
Jeff Garzik 已提交
534 535
extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
L
Linus Torvalds 已提交
536 537 538 539
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);
J
Jeff Garzik 已提交
540
extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
541
extern int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes);
L
Linus Torvalds 已提交
542 543
extern int ata_port_start (struct ata_port *ap);
extern void ata_port_stop (struct ata_port *ap);
J
Jeff Garzik 已提交
544
extern void ata_host_stop (struct ata_host_set *host_set);
L
Linus Torvalds 已提交
545 546
extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
extern void ata_qc_prep(struct ata_queued_cmd *qc);
547
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
548
extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
549 550 551 552
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);
J
Jeff Garzik 已提交
553
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
554 555 556 557
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);
L
Linus Torvalds 已提交
558 559
extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
extern void ata_bmdma_start (struct ata_queued_cmd *qc);
560
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
561 562
extern u8   ata_bmdma_status(struct ata_port *ap);
extern void ata_bmdma_irq_clear(struct ata_port *ap);
563
extern void __ata_qc_complete(struct ata_queued_cmd *qc);
L
Linus Torvalds 已提交
564
extern void ata_eng_timeout(struct ata_port *ap);
T
Tejun Heo 已提交
565 566
extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
			      struct scsi_cmnd *cmd,
L
Linus Torvalds 已提交
567 568 569 570 571 572
			      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);

A
Alan Cox 已提交
573 574 575
/*
 * Timing helpers
 */
576 577

extern unsigned int ata_pio_need_iordy(const struct ata_device *);
A
Alan Cox 已提交
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
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,
};

L
Linus Torvalds 已提交
601 602 603 604 605 606 607 608 609

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

610
extern void ata_pci_host_stop (struct ata_host_set *host_set);
L
Linus Torvalds 已提交
611
extern struct ata_probe_ent *
612
ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask);
J
Jeff Garzik 已提交
613
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
614
extern unsigned long ata_pci_default_filter(const struct ata_port *, struct ata_device *, unsigned long);
L
Linus Torvalds 已提交
615 616 617
#endif /* CONFIG_PCI */


618 619 620 621 622 623 624 625 626 627 628 629
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;
}

630 631 632 633 634 635 636 637 638 639
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;
}

640 641 642 643 644 645 646
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;
647 648 649
	if (qc->pad_len)
		return &qc->pad_sgent;
	return NULL;
650 651 652
}

#define ata_for_each_sg(sg, qc) \
653
	for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
654

L
Linus Torvalds 已提交
655 656 657 658 659
static inline unsigned int ata_tag_valid(unsigned int tag)
{
	return (tag < ATA_MAX_QUEUE) ? 1 : 0;
}

660 661 662 663 664
static inline unsigned int ata_class_present(unsigned int class)
{
	return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
}

J
Jeff Garzik 已提交
665
static inline unsigned int ata_dev_present(const struct ata_device *dev)
L
Linus Torvalds 已提交
666
{
667
	return ata_class_present(dev->class);
L
Linus Torvalds 已提交
668 669 670 671 672 673 674
}

static inline u8 ata_chk_status(struct ata_port *ap)
{
	return ap->ops->check_status(ap);
}

E
Edward Falk 已提交
675 676 677 678 679 680 681 682 683

/**
 *	ata_pause - Flush writes and pause 400 nanoseconds.
 *	@ap: Port to wait for.
 *
 *	LOCKING:
 *	Inherited from caller.
 */

L
Linus Torvalds 已提交
684 685 686 687 688 689
static inline void ata_pause(struct ata_port *ap)
{
	ata_altstatus(ap);
	ndelay(400);
}

E
Edward Falk 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702

/**
 *	ata_busy_wait - Wait for a port status register
 *	@ap: Port to wait for.
 *
 *	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.
 */

L
Linus Torvalds 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716
static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
			       unsigned int max)
{
	u8 status;

	do {
		udelay(10);
		status = ata_chk_status(ap);
		max--;
	} while ((status & bits) && (max > 0));

	return status;
}

E
Edward Falk 已提交
717 718 719 720 721 722 723 724 725 726 727 728

/**
 *	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.
 */

L
Linus Torvalds 已提交
729 730 731 732 733 734
static inline u8 ata_wait_idle(struct ata_port *ap)
{
	u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);

	if (status & (ATA_BUSY | ATA_DRQ)) {
		unsigned long l = ap->ioaddr.status_addr;
735 736 737
		if (ata_msg_warn(ap))
			printk(KERN_WARNING "ATA: abnormal status 0x%X on port 0x%lX\n",
				status, l);
L
Linus Torvalds 已提交
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	}

	return status;
}

static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
{
	qc->tf.ctl |= ATA_NIEN;
}

static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
						      unsigned int tag)
{
	if (likely(ata_tag_valid(tag)))
		return &ap->qcmd[tag];
	return NULL;
}

static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
{
	memset(tf, 0, sizeof(*tf));

	tf->ctl = ap->ctl;
	if (device == 0)
		tf->device = ATA_DEVICE_OBS;
	else
		tf->device = ATA_DEVICE_OBS | ATA_DEV1;
}

J
Jeff Garzik 已提交
767 768 769 770 771 772 773
static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
{
	qc->__sg = NULL;
	qc->flags = 0;
	qc->cursect = qc->cursg = qc->cursg_ofs = 0;
	qc->nsect = 0;
	qc->nbytes = qc->curbytes = 0;
774
	qc->err_mask = 0;
J
Jeff Garzik 已提交
775 776 777 778

	ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
}

779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
/**
 *	ata_qc_complete - Complete an active ATA command
 *	@qc: Command to complete
 *	@err_mask: ATA Status register contents
 *
 *	Indicate to the mid and upper layers that an ATA
 *	command has completed, with either an ok or not-ok status.
 *
 *	LOCKING:
 *	spin_lock_irqsave(host_set lock)
 */
static inline void ata_qc_complete(struct ata_queued_cmd *qc)
{
	if (unlikely(qc->flags & ATA_QCFLAG_EH_SCHEDULED))
		return;

	__ata_qc_complete(qc);
}
E
Edward Falk 已提交
797 798 799 800 801 802 803 804 805 806 807 808

/**
 *	ata_irq_on - Enable interrupts on a port.
 *	@ap: Port on which interrupts are enabled.
 *
 *	Enable interrupts on a legacy IDE device using MMIO or PIO,
 *	wait for idle, clear any pending interrupts.
 *
 *	LOCKING:
 *	Inherited from caller.
 */

L
Linus Torvalds 已提交
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
static inline u8 ata_irq_on(struct ata_port *ap)
{
	struct ata_ioports *ioaddr = &ap->ioaddr;
	u8 tmp;

	ap->ctl &= ~ATA_NIEN;
	ap->last_ctl = ap->ctl;

	if (ap->flags & ATA_FLAG_MMIO)
		writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
	else
		outb(ap->ctl, ioaddr->ctl_addr);
	tmp = ata_wait_idle(ap);

	ap->ops->irq_clear(ap);

	return tmp;
}

E
Edward Falk 已提交
828 829 830 831 832 833 834 835 836 837 838 839

/**
 *	ata_irq_ack - Acknowledge a device interrupt.
 *	@ap: Port on which interrupts are enabled.
 *
 *	Wait up to 10 ms for legacy IDE device to become idle (BUSY
 *	or BUSY+DRQ clear).  Obtain dma status and port status from
 *	device.  Clear the interrupt.  Return port status.
 *
 *	LOCKING:
 */

L
Linus Torvalds 已提交
840 841 842 843 844 845 846
static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
{
	unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
	u8 host_stat, post_stat, status;

	status = ata_busy_wait(ap, bits, 1000);
	if (status & bits)
847 848
		if (ata_msg_err(ap))
			printk(KERN_ERR "abnormal status 0x%X\n", status);
L
Linus Torvalds 已提交
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865

	/* get controller status; clear intr, err bits */
	if (ap->flags & ATA_FLAG_MMIO) {
		void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
		host_stat = readb(mmio + ATA_DMA_STATUS);
		writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
		       mmio + ATA_DMA_STATUS);

		post_stat = readb(mmio + ATA_DMA_STATUS);
	} else {
		host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
		outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
		     ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);

		post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
	}

866 867 868 869
	if (ata_msg_intr(ap))
		printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
			__FUNCTION__,
			host_stat, post_stat, status);
L
Linus Torvalds 已提交
870 871 872 873 874 875 876 877 878 879 880 881 882 883

	return status;
}

static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
{
	return ap->ops->scr_read(ap, reg);
}

static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
{
	ap->ops->scr_write(ap, reg, val);
}

J
Jeff Garzik 已提交
884
static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
885 886 887 888 889 890
				   u32 val)
{
	ap->ops->scr_write(ap, reg, val);
	(void) ap->ops->scr_read(ap, reg);
}

L
Linus Torvalds 已提交
891 892 893 894 895
static inline unsigned int sata_dev_present(struct ata_port *ap)
{
	return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
}

J
Jeff Garzik 已提交
896
static inline int ata_try_flush_cache(const struct ata_device *dev)
L
Linus Torvalds 已提交
897 898 899 900 901 902
{
	return ata_id_wcache_enabled(dev->id) ||
	       ata_id_has_flush(dev->id) ||
	       ata_id_has_flush_ext(dev->id);
}

903 904 905
static inline unsigned int ac_err_mask(u8 status)
{
	if (status & ATA_BUSY)
906
		return AC_ERR_HSM;
907 908 909 910 911 912 913 914 915 916 917 918 919
	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;
}

920 921 922 923 924 925 926 927 928 929 930 931 932
static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
{
	ap->pad_dma = 0;
	ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
				     &ap->pad_dma, GFP_KERNEL);
	return (ap->pad == NULL) ? -ENOMEM : 0;
}

static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
{
	dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
}

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