text:
#ifndef __LINUX_LIBATA_H__
#define __LINUX_LIBATA_H__

#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#include <linux/io.h>
#include <linux/ata.h>
#include <linux/workqueue.h>
#include <scsi/scsi_host.h>
#include <linux/acpi.h>
#include <linux/cdrom.h>

/*
 * Define if arch has non-standard setup.  This is a _PCI_ standard
 * not a legacy or ISA standard.
 */
#ifdef CONFIG_ATA_NONSTANDARD
#include <asm/libata-portmap.h>
#else
#include <asm-generic/libata-portmap.h>
#endif

/*
 * compile-time options: to be removed as soon as all the drivers are
 * converted to the new debugging mechanism
 */
#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, __func__, ## args)
#ifdef ATA_VERBOSE_DEBUG
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
#else
#define VPRINTK(fmt, args...)
#endif	/* ATA_VERBOSE_DEBUG */
#else
#define DPRINTK(fmt, args...)
#define VPRINTK(fmt, args...)
#endif	/* ATA_DEBUG */

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

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

/* defines only for the constants which don't work well as enums */
#define ATA_TAG_POISON		0xfafbfcfdU

enum {
	/* various global constants */
	LIBATA_MAX_PRD		= ATA_MAX_PRD / 2,
	LIBATA_DUMB_MAX_PRD	= ATA_MAX_PRD / 4,	/* Worst case */
	ATA_DEF_QUEUE		= 1,
	/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
	ATA_MAX_QUEUE		= 32,
	ATA_TAG_INTERNAL	= ATA_MAX_QUEUE - 1,
	ATA_SHORT_PAUSE		= 16,

	ATAPI_MAX_DRAIN		= 16 << 10,

	ATA_ALL_DEVICES		= (1 << ATA_MAX_DEVICES) - 1,

	ATA_SHT_EMULATED	= 1,
	ATA_SHT_CMD_PER_LUN	= 1,
	ATA_SHT_THIS_ID		= -1,
	ATA_SHT_USE_CLUSTERING	= 1,

	/* struct ata_device stuff */
	ATA_DFLAG_LBA		= (1 << 0), /* device supports LBA */
	ATA_DFLAG_LBA48		= (1 << 1), /* device supports LBA48 */
	ATA_DFLAG_CDB_INTR	= (1 << 2), /* device asserts INTRQ when ready for CDB */
	ATA_DFLAG_NCQ		= (1 << 3), /* device supports NCQ */
	ATA_DFLAG_FLUSH_EXT	= (1 << 4), /* do FLUSH_EXT instead of FLUSH */
	ATA_DFLAG_ACPI_PENDING	= (1 << 5), /* ACPI resume action pending */
	ATA_DFLAG_ACPI_FAILED	= (1 << 6), /* ACPI on devcfg has failed */
	ATA_DFLAG_AN		= (1 << 7), /* AN configured */
	ATA_DFLAG_HIPM		= (1 << 8), /* device supports HIPM */
	ATA_DFLAG_DIPM		= (1 << 9), /* device supports DIPM */
	ATA_DFLAG_DMADIR	= (1 << 10), /* device requires DMADIR */
	ATA_DFLAG_CFG_MASK	= (1 << 12) - 1,

	ATA_DFLAG_PIO		= (1 << 12), /* device limited to PIO mode */
	ATA_DFLAG_NCQ_OFF	= (1 << 13), /* device limited to non-NCQ mode */
	ATA_DFLAG_SLEEPING	= (1 << 15), /* device is sleeping */
	ATA_DFLAG_DUBIOUS_XFER	= (1 << 16), /* data transfer not verified */
	ATA_DFLAG_NO_UNLOAD	= (1 << 17), /* device doesn't support unload */
	ATA_DFLAG_INIT_MASK	= (1 << 24) - 1,

	ATA_DFLAG_DETACH	= (1 << 24),
	ATA_DFLAG_DETACHED	= (1 << 25),

	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_PMP		= 5,	/* SATA port multiplier */
	ATA_DEV_PMP_UNSUP	= 6,	/* SATA port multiplier (unsupported) */
	ATA_DEV_SEMB		= 7,	/* SEMB */
	ATA_DEV_SEMB_UNSUP	= 8,	/* SEMB (unsupported) */
	ATA_DEV_NONE		= 9,	/* no device */

	/* struct ata_link flags */
	ATA_LFLAG_NO_HRST	= (1 << 1), /* avoid hardreset */
	ATA_LFLAG_NO_SRST	= (1 << 2), /* avoid softreset */
	ATA_LFLAG_ASSUME_ATA	= (1 << 3), /* assume ATA class */
	ATA_LFLAG_ASSUME_SEMB	= (1 << 4), /* assume SEMB class */
	ATA_LFLAG_ASSUME_CLASS	= ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
	ATA_LFLAG_NO_RETRY	= (1 << 5), /* don't retry this link */
	ATA_LFLAG_DISABLED	= (1 << 6), /* link is disabled */
	ATA_LFLAG_SW_ACTIVITY	= (1 << 7), /* keep activity stats */

	/* struct ata_port flags */
	ATA_FLAG_SLAVE_POSS	= (1 << 0), /* host supports slave dev */
					    /* (doesn't imply presence) */
	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 */
	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_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
	ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
	ATA_FLAG_DEBUGMSG	= (1 << 13),
	ATA_FLAG_FPDMA_AA		= (1 << 14), /* driver supports Auto-Activate */
	ATA_FLAG_IGN_SIMPLEX	= (1 << 15), /* ignore SIMPLEX */
	ATA_FLAG_NO_IORDY	= (1 << 16), /* controller lacks iordy */
	ATA_FLAG_ACPI_SATA	= (1 << 17), /* need native SATA ACPI layout */
	ATA_FLAG_AN		= (1 << 18), /* controller supports AN */
	ATA_FLAG_PMP		= (1 << 19), /* controller supports PMP */
	ATA_FLAG_IPM		= (1 << 20), /* driver can handle IPM */
	ATA_FLAG_EM		= (1 << 21), /* driver supports enclosure
					      * management */
	ATA_FLAG_SW_ACTIVITY	= (1 << 22), /* driver supports sw activity
					      * led */

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

	/* struct ata_port pflags */
	ATA_PFLAG_EH_PENDING	= (1 << 0), /* EH pending */
	ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
	ATA_PFLAG_FROZEN	= (1 << 2), /* port is frozen */
	ATA_PFLAG_RECOVERED	= (1 << 3), /* recovery action performed */
	ATA_PFLAG_LOADING	= (1 << 4), /* boot/loading probe */
	ATA_PFLAG_SCSI_HOTPLUG	= (1 << 6), /* SCSI hotplug scheduled */
	ATA_PFLAG_INITIALIZING	= (1 << 7), /* being initialized, don't touch */
	ATA_PFLAG_RESETTING	= (1 << 8), /* reset in progress */
	ATA_PFLAG_UNLOADING	= (1 << 9), /* driver is being unloaded */
	ATA_PFLAG_UNLOADED	= (1 << 10), /* driver is unloaded */

	ATA_PFLAG_SUSPENDED	= (1 << 17), /* port is suspended (power) */
	ATA_PFLAG_PM_PENDING	= (1 << 18), /* PM operation pending */
	ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */

	ATA_PFLAG_PIO32		= (1 << 20),  /* 32bit PIO */
	ATA_PFLAG_PIO32CHANGE	= (1 << 21),  /* 32bit PIO can be turned on/off */

	/* struct ata_queued_cmd flags */
	ATA_QCFLAG_ACTIVE	= (1 << 0), /* cmd not yet ack'd to scsi lyer */
	ATA_QCFLAG_DMAMAP	= (1 << 1), /* SG table is DMA mapped */
	ATA_QCFLAG_IO		= (1 << 3), /* standard IO command */
	ATA_QCFLAG_RESULT_TF	= (1 << 4), /* result TF requested */
	ATA_QCFLAG_CLEAR_EXCL	= (1 << 5), /* clear excl_link on completion */
	ATA_QCFLAG_QUIET	= (1 << 6), /* don't report device error */
	ATA_QCFLAG_RETRY	= (1 << 7), /* retry after failure */

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

	/* host set flags */
	ATA_HOST_SIMPLEX	= (1 << 0),	/* Host is simplex, one DMA channel per host only */
	ATA_HOST_STARTED	= (1 << 1),	/* Host started */
	ATA_HOST_PARALLEL_SCAN	= (1 << 2),	/* Ports on this host can be scanned in parallel */

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

	/* various lengths of time */
	ATA_TMOUT_BOOT		= 30000,	/* heuristic */
	ATA_TMOUT_BOOT_QUICK	=  7000,	/* heuristic */
	ATA_TMOUT_INTERNAL_QUICK = 5000,
	ATA_TMOUT_MAX_PARK	= 30000,

	/* FIXME: GoVault needs 2s but we can't afford that without
	 * parallel probing.  800ms is enough for iVDR disk
	 * HHD424020F7SV00.  Increase to 2secs when parallel probing
	 * is in place.
	 */
	ATA_TMOUT_FF_WAIT	=  800,

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

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

	/* 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
	 * unsigned long bitmap
	 */
	ATA_NR_PIO_MODES	= 7,
	ATA_NR_MWDMA_MODES	= 5,
	ATA_NR_UDMA_MODES	= 8,

	ATA_SHIFT_PIO		= 0,
	ATA_SHIFT_MWDMA		= ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
	ATA_SHIFT_UDMA		= ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,

	/* size of buffer to pad xfers ending on unaligned boundaries */
	ATA_DMA_PAD_SZ		= 4,

	/* ering size */
	ATA_ERING_SIZE		= 32,

	/* return values for ->qc_defer */
	ATA_DEFER_LINK		= 1,
	ATA_DEFER_PORT		= 2,

	/* desc_len for ata_eh_info and context */
	ATA_EH_DESC_LEN		= 80,

	/* reset / recovery action types */
	ATA_EH_REVALIDATE	= (1 << 0),
	ATA_EH_SOFTRESET	= (1 << 1), /* meaningful only in ->prereset */
	ATA_EH_HARDRESET	= (1 << 2), /* meaningful only in ->prereset */
	ATA_EH_RESET		= ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
	ATA_EH_ENABLE_LINK	= (1 << 3),
	ATA_EH_LPM		= (1 << 4),  /* link power management action */
	ATA_EH_PARK		= (1 << 5), /* unload heads and stop I/O */

	ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE | ATA_EH_PARK,
	ATA_EH_ALL_ACTIONS	= ATA_EH_REVALIDATE | ATA_EH_RESET |
				  ATA_EH_ENABLE_LINK | ATA_EH_LPM,

	/* ata_eh_info->flags */
	ATA_EHI_HOTPLUGGED	= (1 << 0),  /* could have been hotplugged */
	ATA_EHI_NO_AUTOPSY	= (1 << 2),  /* no autopsy */
	ATA_EHI_QUIET		= (1 << 3),  /* be quiet */

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

	ATA_EHI_DID_RESET	= ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,

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

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

	/* how hard are we gonna try to probe/recover devices */
	ATA_PROBE_MAX_TRIES	= 3,
	ATA_EH_DEV_TRIES	= 3,
	ATA_EH_PMP_TRIES	= 5,
	ATA_EH_PMP_LINK_TRIES	= 3,

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

	/* This should match the actual table size of
	 * ata_eh_cmd_timeout_table in libata-eh.c.
	 */
	ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 5,

	/* 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 */
	ATA_HORKAGE_NODMA	= (1 << 1),	/* DMA problems */
	ATA_HORKAGE_NONCQ	= (1 << 2),	/* Don't use NCQ */
	ATA_HORKAGE_MAX_SEC_128	= (1 << 3),	/* Limit max sects to 128 */
	ATA_HORKAGE_BROKEN_HPA	= (1 << 4),	/* Broken HPA */
	ATA_HORKAGE_DISABLE	= (1 << 5),	/* Disable it */
	ATA_HORKAGE_HPA_SIZE	= (1 << 6),	/* native size off by one */
	ATA_HORKAGE_IPM		= (1 << 7),	/* Link PM problems */
	ATA_HORKAGE_IVB		= (1 << 8),	/* cbl det validity bit bugs */
	ATA_HORKAGE_STUCK_ERR	= (1 << 9),	/* stuck ERR on next PACKET */
	ATA_HORKAGE_BRIDGE_OK	= (1 << 10),	/* no bridge limits */
	ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
						    not multiple of 16 bytes */
	ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),	/* firmware update warning */
	ATA_HORKAGE_1_5_GBPS	= (1 << 13),	/* force 1.5 Gbps */
	ATA_HORKAGE_NOSETXFER	= (1 << 14),	/* skip SETXFER, SATA only */
	ATA_HORKAGE_BROKEN_FPDMA_AA	= (1 << 15),	/* skip AA */

	 /* DMA mask for user DMA control: User visible values; DO NOT
	    renumber */
	ATA_DMA_MASK_ATA	= (1 << 0),	/* DMA on ATA Disk */
	ATA_DMA_MASK_ATAPI	= (1 << 1),	/* DMA on ATAPI */
	ATA_DMA_MASK_CFA	= (1 << 2),	/* DMA on CF Card */

	/* ATAPI command types */
	ATAPI_READ		= 0,		/* READs */
	ATAPI_WRITE		= 1,		/* WRITEs */
	ATAPI_READ_CD		= 2,		/* READ CD [MSF] */
	ATAPI_PASS_THRU		= 3,		/* SAT pass-thru */
	ATAPI_MISC		= 4,		/* the rest */

	/* Timing constants */
	ATA_TIMING_SETUP	= (1 << 0),
	ATA_TIMING_ACT8B	= (1 << 1),
	ATA_TIMING_REC8B	= (1 << 2),
	ATA_TIMING_CYC8B	= (1 << 3),
	ATA_TIMING_8BIT		= ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
				  ATA_TIMING_CYC8B,
	ATA_TIMING_ACTIVE	= (1 << 4),
	ATA_TIMING_RECOVER	= (1 << 5),
	ATA_TIMING_DMACK_HOLD	= (1 << 6),
	ATA_TIMING_CYCLE	= (1 << 7),
	ATA_TIMING_UDMA		= (1 << 8),
	ATA_TIMING_ALL		= ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
				  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
				  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
				  ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
				  ATA_TIMING_UDMA,

	/* ACPI constants */
	ATA_ACPI_FILTER_SETXFER	= 1 << 0,
	ATA_ACPI_FILTER_LOCK	= 1 << 1,
	ATA_ACPI_FILTER_DIPM	= 1 << 2,
	ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3,	/* FPDMA non-zero offset */
	ATA_ACPI_FILTER_FPDMA_AA = 1 << 4,	/* FPDMA auto activate */

	ATA_ACPI_FILTER_DEFAULT	= ATA_ACPI_FILTER_SETXFER |
				  ATA_ACPI_FILTER_LOCK |
				  ATA_ACPI_FILTER_DIPM,
};

enum ata_xfer_mask {
	ATA_MASK_PIO		= ((1LU << ATA_NR_PIO_MODES) - 1)
					<< ATA_SHIFT_PIO,
	ATA_MASK_MWDMA		= ((1LU << ATA_NR_MWDMA_MODES) - 1)
					<< ATA_SHIFT_MWDMA,
	ATA_MASK_UDMA		= ((1LU << ATA_NR_UDMA_MODES) - 1)
					<< ATA_SHIFT_UDMA,
};

enum hsm_task_states {
	HSM_ST_IDLE,		/* no command on going */
	HSM_ST_FIRST,		/* (waiting the device to)
				   write CDB or first data block */
	HSM_ST,			/* (waiting the device to) transfer data */
	HSM_ST_LAST,		/* (waiting the device to) complete command */
	HSM_ST_ERR,		/* error */
};

enum ata_completion_errors {
	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 */
	AC_ERR_NODEV_HINT	= (1 << 9), /* polling device detection hint */
	AC_ERR_NCQ		= (1 << 10), /* marker for offending NCQ qc */
};

/* forward declarations */
struct scsi_device;
struct ata_port_operations;
struct ata_port;
struct ata_link;
struct ata_queued_cmd;

/* typedefs */
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
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,
			      unsigned long deadline);
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);

/*
 * host pm policy: If you alter this, you also need to alter libata-scsi.c
 * (for the ascii descriptions)
 */
enum link_pm {
	NOT_AVAILABLE,
	MIN_POWER,
	MAX_PERFORMANCE,
	MEDIUM_POWER,
};
extern struct device_attribute dev_attr_link_power_management_policy;
extern struct device_attribute dev_attr_unload_heads;
extern struct device_attribute dev_attr_em_message_type;
extern struct device_attribute dev_attr_em_message;
extern struct device_attribute dev_attr_sw_activity;

enum sw_activity {
	OFF,
	BLINK_ON,
	BLINK_OFF,
};

#ifdef CONFIG_ATA_SFF
struct ata_ioports {
	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;
};
#endif /* CONFIG_ATA_SFF */

struct ata_host {
	spinlock_t		lock;
	struct device 		*dev;
	void __iomem * const	*iomap;
	unsigned int		n_ports;
	void			*private_data;
	struct ata_port_operations *ops;
	unsigned long		flags;
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
#endif
	struct ata_port		*simplex_claimed;	/* channel owning the DMA */
	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;
	unsigned int		orig_n_elem;

	int			dma_dir;

	unsigned int		sect_size;

	unsigned int		nbytes;
	unsigned int		extrabytes;
	unsigned int		curbytes;

	struct scatterlist	*cursg;
	unsigned int		cursg_ofs;

	struct scatterlist	sgent;

	struct scatterlist	*sg;

	unsigned int		err_mask;
	struct ata_taskfile	result_tf;
	ata_qc_cb_t		complete_fn;

	void			*private_data;
	void			*lldd_task;
};

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

struct ata_ering_entry {
	unsigned int		eflags;
	unsigned int		err_mask;
	u64			timestamp;
};

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

struct ata_device {
	struct ata_link		*link;
	unsigned int		devno;		/* 0 or 1 */
	unsigned int		horkage;	/* List of broken features */
	unsigned long		flags;		/* ATA_DFLAG_xxx */
	struct scsi_device	*sdev;		/* attached SCSI device */
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
	union acpi_object	*gtf_cache;
	unsigned int		gtf_filter;
#endif
	/* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
	u64			n_sectors;	/* size of device, if ATA */
	u64			n_native_sectors; /* native size, if ATA */
	unsigned int		class;		/* ATA_DEV_xxx */
	unsigned long		unpark_deadline;

	u8			pio_mode;
	u8			dma_mode;
	u8			xfer_mode;
	unsigned int		xfer_shift;	/* ATA_SHIFT_xxx */

	unsigned int		multi_count;	/* sectors count for
						   READ/WRITE MULTIPLE */
	unsigned int		max_sectors;	/* per-device max sectors */
	unsigned int		cdb_len;

	/* per-dev xfer mask */
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;

	/* for CHS addressing */
	u16			cylinders;	/* Number of cylinders */
	u16			heads;		/* Number of heads */
	u16			sectors;	/* Number of sectors per track */

	union {
		u16		id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
		u32		gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
	};

	/* error history */
	int			spdn_cnt;
	/* ering is CLEAR_END, read comment above CLEAR_END */
	struct ata_ering	ering;
};

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

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 */
	unsigned int		dev_action[ATA_MAX_DEVICES]; /* dev EH action */
	unsigned int		flags;		/* ATA_EHI_* flags */

	unsigned int		probe_mask;

	char			desc[ATA_EH_DESC_LEN];
	int			desc_len;
};

struct ata_eh_context {
	struct ata_eh_info	i;
	int			tries[ATA_MAX_DEVICES];
	int			cmd_timeout_idx[ATA_MAX_DEVICES]
					       [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
	unsigned int		classes[ATA_MAX_DEVICES];
	unsigned int		did_probe_mask;
	unsigned int		unloaded_mask;
	unsigned int		saved_ncq_enabled;
	u8			saved_xfer_mode[ATA_MAX_DEVICES];
	/* timestamp for the last reset attempt or success */
	unsigned long		last_reset;
};

struct ata_acpi_drive
{
	u32 pio;
	u32 dma;
} __packed;

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

struct ata_link {
	struct ata_port		*ap;
	int			pmp;		/* port multiplier port # */

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

	unsigned int		flags;		/* ATA_LFLAG_xxx */

	u32			saved_scontrol;	/* SControl on probe */
	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];
};

struct ata_port {
	struct Scsi_Host	*scsi_host; /* our co-allocated scsi host */
	struct ata_port_operations *ops;
	spinlock_t		*lock;
	/* Flags owned by the EH context. Only EH should touch these once the
	   port is active */
	unsigned long		flags;	/* ATA_FLAG_xxx */
	/* Flags that change dynamically, protected by ap->lock */
	unsigned int		pflags; /* ATA_PFLAG_xxx */
	unsigned int		print_id; /* user visible unique port ID */
	unsigned int		port_no; /* 0 based port no. inside the host */

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

#ifdef CONFIG_ATA_SFF
	struct ata_ioports	ioaddr;	/* ATA cmd/ctl/dma register blocks */
#endif /* CONFIG_ATA_SFF */

	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];
	unsigned long		qc_allocated;
	unsigned int		qc_active;
	int			nr_active_links; /* #links with active qcs */

	struct ata_link		link;		/* host default link */
	struct ata_link		*slave_link;	/* see ata_slave_link_init() */

	int			nr_pmp_links;	/* nr of available PMP links */
	struct ata_link		*pmp_link;	/* array of PMP links */
	struct ata_link		*excl_link;	/* for PMP qc exclusion */

	struct ata_port_stats	stats;
	struct ata_host		*host;
	struct device 		*dev;

	void			*port_task_data;
	struct delayed_work	port_task;
	struct delayed_work	hotplug_task;
	struct work_struct	scsi_rescan_task;

	unsigned int		hsm_task_state;

	u32			msg_enable;
	struct list_head	eh_done_q;
	wait_queue_head_t	eh_wait_q;
	int			eh_tries;
	struct completion	park_req_pending;

	pm_message_t		pm_mesg;
	int			*pm_result;
	enum link_pm		pm_policy;

	struct timer_list	fastdrain_timer;
	unsigned long		fastdrain_cnt;

	int			em_message_type;
	void			*private_data;

#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
	struct ata_acpi_gtm	__acpi_init_gtm; /* use ata_acpi_init_gtm() */
#endif
	/* owned by EH */
	u8			sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
};

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

struct ata_port_operations {
	/*
	 * Command execution
	 */
	int  (*qc_defer)(struct ata_queued_cmd *qc);
	int  (*check_atapi_dma)(struct ata_queued_cmd *qc);
	void (*qc_prep)(struct ata_queued_cmd *qc);
	unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
	bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);

	/*
	 * Configuration and exception handling
	 */
	int  (*cable_detect)(struct ata_port *ap);
	unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask);
	void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
	void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
	int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
	unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);

	void (*dev_config)(struct ata_device *dev);

	void (*freeze)(struct ata_port *ap);
	void (*thaw)(struct ata_port *ap);
	ata_prereset_fn_t	prereset;
	ata_reset_fn_t		softreset;
	ata_reset_fn_t		hardreset;
	ata_postreset_fn_t	postreset;
	ata_prereset_fn_t	pmp_prereset;
	ata_reset_fn_t		pmp_softreset;
	ata_reset_fn_t		pmp_hardreset;
	ata_postreset_fn_t	pmp_postreset;
	void (*error_handler)(struct ata_port *ap);
	void (*lost_interrupt)(struct ata_port *ap);
	void (*post_internal_cmd)(struct ata_queued_cmd *qc);

	/*
	 * Optional features
	 */
	int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
	int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
	void (*pmp_attach)(struct ata_port *ap);
	void (*pmp_detach)(struct ata_port *ap);
	int  (*enable_pm)(struct ata_port *ap, enum link_pm policy);
	void (*disable_pm)(struct ata_port *ap);

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

#ifdef CONFIG_ATA_SFF
	/*
	 * SFF / taskfile oriented ops
	 */
	void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
	u8   (*sff_check_status)(struct ata_port *ap);
	u8   (*sff_check_altstatus)(struct ata_port *ap);
	void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
	void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
	void (*sff_exec_command)(struct ata_port *ap,
				 const struct ata_taskfile *tf);
	unsigned int (*sff_data_xfer)(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
	u8   (*sff_irq_on)(struct ata_port *);
	void (*sff_irq_clear)(struct ata_port *);

	void (*bmdma_setup)(struct ata_queued_cmd *qc);
	void (*bmdma_start)(struct ata_queued_cmd *qc);
	void (*bmdma_stop)(struct ata_queued_cmd *qc);
	u8   (*bmdma_status)(struct ata_port *ap);

	void (*drain_fifo)(struct ata_queued_cmd *qc);
#endif /* CONFIG_ATA_SFF */

	ssize_t (*em_show)(struct ata_port *ap, char *buf);
	ssize_t (*em_store)(struct ata_port *ap, const char *message,
			    size_t size);
	ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
	ssize_t (*sw_activity_store)(struct ata_device *dev,
				     enum sw_activity val);
	/*
	 * Obsolete
	 */
	void (*phy_reset)(struct ata_port *ap);
	void (*eng_timeout)(struct ata_port *ap);

	/*
	 * ->inherits must be the last field and all the preceding
	 * fields must be pointers.
	 */
	const struct ata_port_operations	*inherits;
};

struct ata_port_info {
	unsigned long		flags;
	unsigned long		link_flags;
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
	unsigned long		udma_mask;
	struct ata_port_operations *port_ops;
	void 			*private_data;
};

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 dmack_hold;	/* tj */
	unsigned short cycle;		/* t0 */
	unsigned short udma;		/* t2CYCTYP/2 */
};

/*
 * Core layer - drivers/ata/libata-core.c
 */
extern const unsigned long sata_deb_timing_normal[];
extern const unsigned long sata_deb_timing_hotplug[];
extern const unsigned long sata_deb_timing_long[];

extern struct ata_port_operations ata_dummy_port_ops;
extern const struct ata_port_info ata_dummy_port_info;

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

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

extern void ata_port_probe(struct ata_port *);
extern int sata_set_spd(struct ata_link *link);
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
				int (*check_ready)(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);
extern int sata_link_hardreset(struct ata_link *link,
			const unsigned long *timing, unsigned long deadline,
			bool *online, int (*check_ready)(struct ata_link *));
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
			      unsigned long deadline);
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
extern void ata_port_disable(struct ata_port *);

extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
			const struct ata_port_info * const * ppi, int n_ports);
extern int ata_slave_link_init(struct ata_port *ap);
extern int ata_host_start(struct ata_host *host);
extern int ata_host_register(struct ata_host *host,
			     struct scsi_host_template *sht);
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);
extern void ata_host_detach(struct ata_host *host);
extern void ata_host_init(struct ata_host *, struct device *,
			  unsigned long, struct ata_port_operations *);
extern int ata_scsi_detect(struct scsi_host_template *sht);
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 *));
extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
			    int cmd, void __user *arg);
extern void ata_sas_port_destroy(struct ata_port *);
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
					   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);
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 bool ata_link_online(struct ata_link *link);
extern bool ata_link_offline(struct ata_link *link);
#ifdef CONFIG_PM
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
extern void ata_host_resume(struct ata_host *host);
#endif
extern int ata_ratelimit(void);
extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
			     unsigned long interval, unsigned long timeout);
extern int atapi_cmd_type(u8 opcode);
extern void ata_tf_to_fis(const struct ata_taskfile *tf,
			  u8 pmp, int is_cmd, u8 *fis);
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
			unsigned long mwdma_mask, unsigned long udma_mask);
extern void ata_unpack_xfermask(unsigned long xfer_mask,
			unsigned long *pio_mask, unsigned long *mwdma_mask,
			unsigned long *udma_mask);
extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
extern int ata_xfer_mode2shift(unsigned long xfer_mode);
extern const char *ata_mode_string(unsigned long xfer_mask);
extern unsigned long ata_id_xfermask(const u16 *id);
extern int ata_port_start(struct ata_port *ap);
extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
		 unsigned int n_elem);
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
extern void ata_dev_disable(struct ata_device *adev);
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);
extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
					struct ata_taskfile *tf, u16 *id);
extern void ata_qc_complete(struct ata_queued_cmd *qc);
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
			      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);
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
				       int queue_depth);
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);

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_ignore(struct ata_port *ap);
extern int ata_cable_unknown(struct ata_port *ap);

extern void ata_pio_queue_task(struct ata_port *ap, void *data,
			       unsigned long delay);

/* Timing helpers */
extern unsigned int ata_pio_need_iordy(const struct ata_device *);
extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
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);
extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);

/* PCI */
#ifdef CONFIG_PCI
struct pci_dev;

struct pci_bits {
	unsigned int		reg;	/* PCI config register to read */
	unsigned int		width;	/* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
	unsigned long		mask;
	unsigned long		val;
};

extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
extern void ata_pci_remove_one(struct pci_dev *pdev);

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

/*
 * ACPI - drivers/ata/libata-acpi.c
 */
#ifdef CONFIG_ATA_ACPI
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
{
	if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
		return &ap->__acpi_init_gtm;
	return NULL;
}
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
				    const struct ata_acpi_gtm *gtm);
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
#else
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
{
	return NULL;
}

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

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

static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
					const struct ata_acpi_gtm *gtm)
{
	return 0;
}

static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
				      const struct ata_acpi_gtm *gtm)
{
	return 0;
}
#endif

/*
 * EH - drivers/ata/libata-eh.c
 */
extern void ata_port_schedule_eh(struct ata_port *ap);
extern int ata_link_abort(struct ata_link *link);
extern int ata_port_abort(struct ata_port *ap);
extern int ata_port_freeze(struct ata_port *ap);
extern int sata_async_notification(struct ata_port *ap);

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

extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
extern void ata_eh_analyze_ncq_error(struct ata_link *link);

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);
extern void ata_std_error_handler(struct ata_port *ap);

/*
 * Base operations to inherit from and initializers for sht
 *
 * Operations
 *
 * base  : Common to all libata drivers.
 * sata  : SATA controllers w/ native interface.
 * pmp   : SATA controllers w/ PMP support.
 * sff   : SFF ATA controllers w/o BMDMA support.
 * bmdma : SFF ATA controllers w/ BMDMA support.
 *
 * sht initializers
 *
 * BASE  : Common to all libata drivers.  The user must set
 *	   sg_tablesize and dma_boundary.
 * PIO   : SFF ATA controllers w/ only PIO support.
 * BMDMA : SFF ATA controllers w/ BMDMA support.  sg_tablesize and
 *	   dma_boundary are set to BMDMA limits.
 * NCQ   : SATA controllers supporting NCQ.  The user must set
 *	   sg_tablesize, dma_boundary and can_queue.
 */
extern const struct ata_port_operations ata_base_port_ops;
extern const struct ata_port_operations sata_port_ops;
extern struct device_attribute *ata_common_sdev_attrs[];

#define ATA_BASE_SHT(drv_name)					\
	.module			= THIS_MODULE,			\
	.name			= drv_name,			\
	.ioctl			= ata_scsi_ioctl,		\
	.queuecommand		= ata_scsi_queuecmd,		\
	.can_queue		= ATA_DEF_QUEUE,		\
	.this_id		= ATA_SHT_THIS_ID,		\
	.cmd_per_lun		= ATA_SHT_CMD_PER_LUN,		\
	.emulated		= ATA_SHT_EMULATED,		\
	.use_clustering		= ATA_SHT_USE_CLUSTERING,	\
	.proc_name		= drv_name,			\
	.slave_configure	= ata_scsi_slave_config,	\
	.slave_destroy		= ata_scsi_slave_destroy,	\
	.bios_param		= ata_std_bios_param,		\
	.sdev_attrs		= ata_common_sdev_attrs

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

/*
 * PMP helpers
 */
#ifdef CONFIG_SATA_PMP
static inline bool sata_pmp_supported(struct ata_port *ap)
{
	return ap->flags & ATA_FLAG_PMP;
}

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

static inline int ata_is_host_link(const struct ata_link *link)
{
	return link == &link->ap->link || link == link->ap->slave_link;
}
#else /* CONFIG_SATA_PMP */
static inline bool sata_pmp_supported(struct ata_port *ap)
{
	return false;
}

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

static inline int ata_is_host_link(const struct ata_link *link)
{
	return 1;
}
#endif /* CONFIG_SATA_PMP */

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

/*
 * printk helpers
 */
#define ata_port_printk(ap, lv, fmt, args...) \
	printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)

#define ata_link_printk(link, lv, fmt, args...) do { \
	if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)	\
		printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,	\
		       (link)->pmp , ##args); \
	else \
		printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
	} while(0)

#define ata_dev_printk(dev, lv, fmt, args...) \
	printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id,	\
	       (dev)->link->pmp + (dev)->devno , ##args)

/*
 * ata_eh_info helpers
 */
extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
	__attribute__ ((format (printf, 2, 3)));
extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
	__attribute__ ((format (printf, 2, 3)));
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);

static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
{
	ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
	ehi->flags |= ATA_EHI_HOTPLUGGED;
	ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
	ehi->err_mask |= AC_ERR_ATA_BUS;
}

/*
 * port description helpers
 */
extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
	__attribute__ ((format (printf, 2, 3)));
#ifdef CONFIG_PCI
extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
			       const char *name);
#endif

static inline unsigned int ata_tag_valid(unsigned int tag)
{
	return (tag < ATA_MAX_QUEUE) ? 1 : 0;
}

static inline unsigned int ata_tag_internal(unsigned int tag)
{
	return tag == ATA_TAG_INTERNAL;
}

/*
 * device helpers
 */
static inline unsigned int ata_class_enabled(unsigned int class)
{
	return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
		class == ATA_DEV_PMP || class == ATA_DEV_SEMB;
}

static inline unsigned int ata_class_disabled(unsigned int class)
{
	return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
		class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP;
}

static inline unsigned int ata_class_absent(unsigned int class)
{
	return !ata_class_enabled(class) && !ata_class_disabled(class);
}

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

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

/*
 * link helpers
 */
static inline int ata_link_max_devices(const struct ata_link *link)
{
	if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
		return 2;
	return 1;
}

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

/*
 * Iterators
 *
 * ATA_LITER_* constants are used to select link iteration mode and
 * ATA_DITER_* device iteration mode.
 *
 * For a custom iteration directly using ata_{link|dev}_next(), if
 * @link or @dev, respectively, is NULL, the first element is
 * returned.  @dev and @link can be any valid device or link and the
 * next element according to the iteration mode will be returned.
 * After the last element, NULL is returned.
 */
enum ata_link_iter_mode {
	ATA_LITER_EDGE,		/* if present, PMP links only; otherwise,
				 * host link.  no slave link */
	ATA_LITER_HOST_FIRST,	/* host link followed by PMP or slave links */
	ATA_LITER_PMP_FIRST,	/* PMP links followed by host link,
				 * slave link still comes after host link */
};

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

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

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

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

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

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

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 struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
						     unsigned int tag)
{
	struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);

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

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

	return NULL;
}

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

static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
{
	memset(tf, 0, sizeof(*tf));

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

static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
{
	qc->dma_dir = DMA_NONE;
	qc->sg = NULL;
	qc->flags = 0;
	qc->cursg = NULL;
	qc->cursg_ofs = 0;
	qc->nbytes = qc->extrabytes = qc->curbytes = 0;
	qc->n_elem = 0;
	qc->err_mask = 0;
	qc->sect_size = ATA_SECT_SIZE;

	ata_tf_init(qc->dev, &qc->tf);

	/* init result_tf such that it indicates normal completion */
	qc->result_tf.command = ATA_DRDY;
	qc->result_tf.feature = 0;
}

static inline int ata_try_flush_cache(const struct ata_device *dev)
{
	return ata_id_wcache_enabled(dev->id) ||
	       ata_id_has_flush(dev->id) ||
	       ata_id_has_flush_ext(dev->id);
}

static inline unsigned int ac_err_mask(u8 status)
{
	if (status & (ATA_BUSY | ATA_DRQ))
		return AC_ERR_HSM;
	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;
}

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

static inline int ata_check_ready(u8 status)
{
	if (!(status & ATA_BUSY))
		return 1;

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

	return 0;
}

static inline unsigned long ata_deadline(unsigned long from_jiffies,
					 unsigned long timeout_msecs)
{
	return from_jiffies + msecs_to_jiffies(timeout_msecs);
}

/* Don't open code these in drivers as there are traps. Firstly the range may
   change in future hardware and specs, secondly 0xFF means 'no DMA' but is
   > UDMA_0. Dyma ddreigiau */

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

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

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

/**************************************************************************
 * PMP - drivers/ata/libata-pmp.c
 */
#ifdef CONFIG_SATA_PMP

extern const struct ata_port_operations sata_pmp_port_ops;

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

#else /* CONFIG_SATA_PMP */

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

#endif /* CONFIG_SATA_PMP */

/**************************************************************************
 * SFF - drivers/ata/libata-sff.c
 */
#ifdef CONFIG_ATA_SFF

extern const struct ata_port_operations ata_sff_port_ops;
extern const struct ata_port_operations ata_bmdma_port_ops;
extern const struct ata_port_operations ata_bmdma32_port_ops;

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

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

extern void ata_sff_qc_prep(struct ata_queued_cmd *qc);
extern void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc);
extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
extern u8 ata_sff_check_status(struct ata_port *ap);
extern void ata_sff_pause(struct ata_port *ap);
extern void ata_sff_dma_pause(struct ata_port *ap);
extern int ata_sff_busy_sleep(struct ata_port *ap,
			      unsigned long timeout_pat, unsigned long timeout);
extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
extern void ata_sff_exec_command(struct ata_port *ap,
				 const struct ata_taskfile *tf);
extern unsigned int ata_sff_data_xfer(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
extern unsigned int ata_sff_data_xfer32(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
extern unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev,
			unsigned char *buf, unsigned int buflen, int rw);
extern u8 ata_sff_irq_on(struct ata_port *ap);
extern void ata_sff_irq_clear(struct ata_port *ap);
extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
			    u8 status, int in_wq);
extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
extern unsigned int ata_sff_host_intr(struct ata_port *ap,
				      struct ata_queued_cmd *qc);
extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
extern void ata_sff_lost_interrupt(struct ata_port *ap);
extern void ata_sff_freeze(struct ata_port *ap);
extern void ata_sff_thaw(struct ata_port *ap);
extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
					  u8 *r_err);
extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
				    unsigned long deadline);
extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
			     unsigned long deadline);
extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline);
extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
extern void ata_sff_error_handler(struct ata_port *ap);
extern void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc);
extern int ata_sff_port_start(struct ata_port *ap);
extern int ata_sff_port_start32(struct ata_port *ap);
extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
extern unsigned long ata_bmdma_mode_filter(struct ata_device *dev,
					   unsigned long xfer_mask);
extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
extern void ata_bmdma_start(struct ata_queued_cmd *qc);
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
extern u8 ata_bmdma_status(struct ata_port *ap);
extern void ata_bus_reset(struct ata_port *ap);

#ifdef CONFIG_PCI
extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
extern int ata_pci_bmdma_init(struct ata_host *host);
extern int ata_pci_sff_init_host(struct ata_host *host);
extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
				    const struct ata_port_info * const * ppi,
				    struct ata_host **r_host);
extern int ata_pci_sff_activate_host(struct ata_host *host,
				     irq_handler_t irq_handler,
				     struct scsi_host_template *sht);
extern int ata_pci_sff_init_one(struct pci_dev *pdev,
				const struct ata_port_info * const * ppi,
				struct scsi_host_template *sht, void *host_priv);
#endif /* CONFIG_PCI */

/**
 *	ata_sff_busy_wait - Wait for a port status register
 *	@ap: Port to wait for.
 *	@bits: bits that must be clear
 *	@max: number of 10uS waits to perform
 *
 *	Waits up to max*10 microseconds for the selected bits in the port's
 *	status register to be cleared.
 *	Returns final value of status register.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
				   unsigned int max)
{
	u8 status;

	do {
		udelay(10);
		status = ap->ops->sff_check_status(ap);
		max--;
	} while (status != 0xff && (status & bits) && (max > 0));

	return status;
}

/**
 *	ata_wait_idle - Wait for a port to be idle.
 *	@ap: Port to wait for.
 *
 *	Waits up to 10ms for port's BUSY and DRQ signals to clear.
 *	Returns final value of status register.
 *
 *	LOCKING:
 *	Inherited from caller.
 */
static inline u8 ata_wait_idle(struct ata_port *ap)
{
	u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);

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

	return status;
}
#endif /* CONFIG_ATA_SFF */

#endif /* __LINUX_LIBATA_H__ */


The course is flagged and ready to go! We hope you are too!
Arrive early – drive carefully. The Loop is set to begin at 9am. For the sake of those waiting at the starting line, we will have just a few pre-race announcements then the 22nd running of the Leatherman's Loop will commence.
To help us with the race scoring, please make certain that your race number bib is exposed before you enter the finishing chute and do not pin the tear-strip at the bottom of the bib to your shirt. If you wish, at the beginning of the race, you can wear an extra layer over the shirt your number is pinned to which you can discard as you run by the teepee. It will be there for you when you finish.
Please, please, please exercise caution and common sense at both of the stream crossings. Ease into each crossing slowly and do not enter them full stride. Pick your footing slowly and cautiously as you cross and use extra caution when exiting.
Bring a full set of warm dry clothes to change in to after you finish.
Maps and directions are on the website.
Full race finishing results will be posted to the web site www.leathermansloop.org fairly soon after the race.
If you see the Leatherman on the trails, let out a yell!
See you bright and early tomorrow!


text:
Blackbird by AngryOwl
Naruto & RWBY Xover Rated: M, English, Adventure, Naruto U., Yang X.L., Raven B., Words: 33k+, Favs: 715, Follows: 878, Published: 2/16/2017 Updated: 1/17/2022}
255 Chapter 1
"How could you do this, Raven?"
She kept her head held high. She had promised herself a long time ago that she would never bow her head because of her own mistakes. She would accept them with pride and dignity.
"How could you do this to me? To us? To Yang?" The man's final words were punctuated with a loud crash as he sent his fist burrowing into a wall. His breathing was heavy as he yanked his fist out of the structure, sending chunks of plaster and wood spraying across the floor before he turned to the still silent woman. She noted that this was by far the angriest she had ever seen the man as he opened his mouth to speak.
"Are you going to say something? Or, are you just going to sit there? You can't ignore this like you do everything else, Raven!" By the time the blond was finished shouting, he was only inches away from her. Their similarities in heights made them eye to eye with one another. She was offered a clear look at the hurt and conflict in his eyes. His emotions made her hesitate yet did not stop her completely as she sucked in a long, slow breath to steady herself.
"I had a duty. You wouldn't comply so I-" To her credit, she didn't even do so much as flinch when the man's fast came screeching toward her head. The attack missed her by a wide margin, managing to create another hole in the wall next to her head. Taiyang's heavy breathing had turned shaky while his now anger filled eyes were piercing deep into Raven's own.
"Don't give me that crap, Raven." The normally docile man growled out.
"It isn't. You know I value family, Taiyang. The experience meant nothing." The woman coolly responded. If she knew how her words would only make the blond much angrier, she would've worded her statement differently.
"What about our family?" Taiyang shouted out. "Do you know value us? Did you value Yang and I when you went out and fucked someone else?"
"I needed an heir and you wouldn't give me one nor would you let me take Yang." Raven shouted back. She wouldn't sit back and be shouted out. No matter how much she cared for the man, she would not be bullied into submission.
"You want to sacrifice a child to be raised by a tribe of murderers, thieves, and rapists! Did you honestly think I would let any child of mine go through that?"
"I knew you wouldn't. That's why I did what I did." There was no remorse in her voice as she spoke. Her gaze remained steady and unwavering while she met Taiyang's. Where the man was emotional, she was stone cold. While he was on the verge of tears, she looked almost bored with the conversation.
"Get out." And just like that, the passion that had once filled the blond flew out of him. His tired voice was a clear indicator of his emotional exhaustion as his outstretched arm fell to his side.
"Get your crap and get out. Get away from me. Get away from this house. Get away from Yang. Just go." Raven didn't even bother protesting the man's decision. She had expected this exact outcome when she made the decision to go through with her plan. And yet, when the day had finally arrived-more than a little too soon for her liking- she discovered that no amount of preparation could've fully armored her against the grief she saw in the man's tired eyes. Guilt surged up within her, threatening to bring her chin crashing downward. But, she remained strong and forced her head high.
She would not break now.
She passed Taiyang without another word. She didn't look back as she began to march up the stairs nor did she when she got to the top of them. Her gaze remained locked forward as she walked, even when she passed the closed doors to her daughter's room. She pushed forward to the room she shared with Taiyang. She kept her attention locked onto the task at hand as she began to collect her things.
The holster holding the bulk of her swords was the last thing she grabbed. She attached the thing onto the strap running across her back with a small yet audible click before turning to face the doorway. Once more, she was not surprised to see Taiyang standing at the doorway of the room.
Their eyes met and Raven found herself overwhelmed once more. It was obvious that the man had been crying. His red, puffy eyes contrasted with his normally bright and blue ones. The excitement usually contained within them had been sucked away, leaving only exhaustion and misery in their place.
"What will I tell Yang?" Taiyang spoke in a soft voice while leaning against the frame of the door. Whether this was a last ditch effort at trying to guilt her in some way, Raven did not know. She would not question the man, though. She would not grant him the opportunity to make her feel more than she already felt.
Silently, she reached over her shoulder and took hold of the hilt of one of her swords. The weapon came free of the holster with a small click and the hiss of air. Raven pulled the weapon clear of the scabbard and drew it in front of her.
"You tell her the truth." Her voice almost seemed to echo through the dark room. With a practiced ease, she slashed at the air with a vertical strike of the sword. As the tip of the blade passed through the air, a portal manifested after the weapon. She finished the movement by driving the sword into the ground, piercing the carpet and wood that laid beneath her.
Without looking back, Raven jumped into the portal. Taiyang wasn't even offered the chance the chase after her as the construct closed shortly after the woman, leaving him all alone. A loud sigh heaved its way out of the men's mouth, breaking the silence of the room before the man turned his attention to the sole item in the room that still belonged to Raven.
A long, single-edged sword stood in the center of the room. Its hilt doubling as a trigger and its cross guard barely existing. Taiyang noted only one thing about the weapon…
The golden color of its blade.
She had grown as he had grown. Raising a child hadn't been easy without Taiyang or the boy's father, the man had been cut down rather brutally in his sleep by the bearer of his child. What had been an unexpected night of pleasure for the male had been his very last.
She had managed it, though. No one could ever claim she did it right. The boy had grown with scars and wounds no child should ever grow with. Yet, it was the nature of her people. If her son hadn't managed to push past simple wounds, he wouldn't make it under her way of life. The fact that he did only proved his legacy, at least her half of it.
Now, he sat before her, tall and proud. A shallow cut black shirt clung to his upper body while a pair of long black pants covered his legs. He was adorned with an assortment of accessories, some holding meaning that even she wasn't aware of. The beads he wore were standard of her tribe yet she did not know why he deemed it necessary to wear nine pairs. From shoulder to hip he wore an orange sash that added a splash of color to his otherwise bland outfit. His spiky blond hair sat unimpeded on the top of his head except for the portion covered by a currently unused white mask.
"It's time." She said, breaking the silence between them. He nodded and stayed silent, yet she could still sense the excitement boiling beneath his skin. She was surprised he was managing to show enough control to not be jumping in his seat considering how long he had been awaiting this day.
"You'll be given the opportunity to survive outside of the tribe. Understand that this is not some type of dismissal. You are still very much a part of this tribe. Do you understand?" When the boy nearly nodded himself into a case of whiplash, Raven decided she had made him wait long enough. She reached down to her side and touched at her scabbard. Memories of a similar scene nearly 14 years earlier flashed through her mind as she wrapped her fingers around the hilt of one of her sword. She quickly pushed those thoughts away as the sword released with a click and a small hiss. It slid out of its confines with an ease granted by constant maintenance. The weapon swung through the air for a brief moment before she raised it at the blond.
"Take this sword and use it. This is my last gift to you." She watched as she grabbed the sword hilt first. He didn't care if the edge of the sword bit into his skin. His excitement had gotten a hold of him and wouldn't be letting go anytime soon.
She released her hold on the hilt as he stood. The weapon sword was immediately deposited onto his back, it supported by the boy's sash. The boy's stoic face broke as a small grin slipped across his features.
"Goodbye, mother. I'll make you and the tribe proud." Raven responded with a nod and nothing more. She didn't think she could talk anyway. She could only watch the blond turned his back on her and walked out the room. The last thing she spotted from him was the orange blade of his new sword before he disappeared behind the curtains of her hut.
"Burn like the sun, my child. Burn."
AN: So, this became a thing. I'll be honest with the people reading this, I wrote this on a complete whim. I have been having problems with writing the newest chapter of my other Naruto/RWBY crossover so I figured this would be a good way to break the writer's block. Of course, with every single thing I write, if people like this enough, I will eventually make it into a full fic.
I hope you all enjoyed. Review or PM me with any questions. Enjoy the rest of your day!

redpajama_set_name: RedPajamaCommonCrawl


Some tips on choosing, cleansing and caring for your crystals.
Crystals and gemstones are beautiful gifts from Mother Earth, with a myriad of different varieties forming naturally all over the world. Some are very precious and rare, others are more commonly available. Many have taken thousands of years to form into the pieces that we see today. As such, they should be treated with respect, and held in awe for the magical treasures that they truly are. Wearing crystals as jewellery and using them as healing tools and talismans has a long history. The ancient Celts, Egyptian, Native American, Indian and Eastern cultures all revered crystals, embellishing their jewellery and sacred buildings with precious gems.
(For simplicity, I will refer to "crystals" throughout this page, however I include all types of gemstone and mineral).
Many people feel drawn to crystals for different reasons - some are simply attracted by their unique beauty, and keep them as ornaments or as part of a collection. Others are aware of their energy, and use them in healing, meditation and ritual.
When starting to work with crystals energetically, you may not feel a great deal from them. This isn't something to be concerned about - you will still benefit from them. And as you continue to work with them, you may well find that you will sense more and more as time goes on. The important thing to remember is to HANDLE your crystal as much as possible. Crystals have a subtle energy (which you may or may not feel), and by handling them, you will absorb this into your own energy field. Each crystal has its own individual properties, and will relate (through colour and energy) to different parts of the body. As such they can be used as powerful yet gentle healing tools for a myriad of physical and emotional ailments, as well as areas of spiritual development.
You may feel very drawn to crystals, and know that you want to work with them on some level. Sometimes it can feeling daunting to be faced with shelves or lists of crystals to choose from - it can be hard to know quite where to start! The information given on the properties of crystals can often feel overwhelming, and often crystal books and web-sites will give conflicting information.
There are many ways to choose a crystal, but I really feel the key is to follow your heart! If possible, switch off the rational, analytical part of your mind.
Look! When looking at a collection of crystals and gemstones, with thought to finding the "right" one, take a deep breath, stay centred and grounded, and scan the crystals with your eyes. Take time to look at them all, let your eyes gently absorb the whole collection you are choosing from. See which one(s) you are naturally drawn to...and when you settle on a particular type, use the same technique to choose your own individual piece.
Feel! Our connection with crystals is not only based on how they look, but (often more importantly), how they feel. When making your choice, pick up the crystal(s) you are drawn to, one at a time. Hold it in your hand and see how it feels. Can you sense the energy of the crystal? Can you feel a tingling or pulsing sensation? Some people can feel energy from a crystal quite easily, whilst others don't, but this really isn't important. ...but the key question is, does the crystal feel good in your hand? Do you feel connected to it? Do you like it?! If so, then you've found a crystal that you can work with and enjoy having in your life! Some people are adept at sensing energy, and will scan a selection of crystals with their hand to see what they feel. This is a good technique too, and anyone can do this with a little practice.
On its journey to you, your crystal may have travelled far, and been handled by many people, at the very least from the person who mined it, to a crystal importer, to the shop owner who have chosen it and put it on display in their shop...where it will probably have been handled by a few "prospective owners" before it "spoke" to you! Crystals are sensitive to positive and negative energy, and your crystal may well be overloaded by the time it reaches you. So it is important to cleanse your crystal when you get it home, to purify it for your own use and bring it back to its natural, perfect energetic state.
There are many different ways of doing this, from the very simple to the immensely (and I would say unneccessarily) complicated! Here is a short list of suggestions - see what works best for you!
Blowing on your crystal. As you blow, visualise any negative energy leaving your crystal in a grey cloud, to be dissipated and neutralised in the atmosphere.
Washing in water. Running a stream of water from your cold tap over your crystal for a few minutes, whilst again visualising any negativity leaving your crystal can be effective, however if you live in an area where tap water is very hard or your feel it is impure, you may wish to substitute mineral water, and pour this in a slow stream from a jug or other receptacle.
Salt and water bath. Make a solution of (preferably) mineral water and a pinch of sea salt, and allow your crystal(s) to soak in this for around 10 mins.
To charge your crystal after cleansing, simply place on your windowsill for a full day and night (waxing to full moon is the best time as the energy around this time is powerful and very positive.(if in doubt check the Moon Phase Guide at the bottom of our "Home" page). Some people like to place their crystal on a larger quartz or amethyst cluster, as this can help to keep them charged and energised.
You can keep your crystal wherever you feel drawn to...on an altar, on your window ledge (avoid doing this with dyed or colour enhanced stones though as the colour will fade with too much sunshine). You can carry or store them in a pouch or box with a soft lining...however remember that crystals do like light, and keeping them stored in a dark drawer or box for too long will deplete their energy. Regular cleansing and charging is beneficial. You'll get to know intuitively when your crystal needs some attention, but certainly if you've been working with it a lot, then it will benefit energetically from a "freshen up". Also if there's been negativity in your home or wherever you keep your crystals (ie from arguments or traumas), or if has been handled by other people, or used in healing, then a cleanse and charge will clear it of any residue negative energy. Keep your crystals dust-free and cleansed, bright and happy, and they'll work well for you!
You may find your crystal in the most unexpected places..in fact you may not "buy" it at all - but find it on the beach, on a hillside walk, or in your garden! A friend may feel drawn to giving you a crystal as a present. Your chosen crystal may be a polished beach pebble, or a rough piece of quartz found on a walk. If it "speaks" to you and you connect with it, then it is yours for now.
If you are making a crystal purchase, do be sensitive to the energy in the shop you are buying it from. Since crystals pick up energy easily, know wherever possible that your crystal has come from a "good" source, energetically. There are also ethical and environmental considerations - where was the crystal mined? Was child labour involved? Did it come from a place where sources are depleted and scarce? These issues will all effect the energy of your crystal, as well as our precious earth. Buy responsibly and with your heart. Buying crystals on-line is difficult, especially for someone starting out. Wherever possible, it is best to handle and choose your own crystal. However as your interest and knowledge grows you might be happy to shop on-line, and certainly it can be helpful in sourcing some more unusual pieces. Again, find suppliers you can trust - knowledgeable crystal specialists are best.
I hope you find this information helpful - enjoy your crystal journey!
The following books are excellent for further learning.
The Crystal Bible Vol.1 by Judy Hall, publ. Octopus. £12.99 A fantastic reference book, packed with information on how to use crystals, as well as a comprehensive list of crystals and their individual properties, with nice, clear pictures.
The Book of Stones by Robert Simmons & Naisha Ahsian, publ. Heaven and Earth £26.99. A sumptuous and in-depth book featuring information on many rarer crystals as well as more commonly available ones, with beautiful photographs of each crystal.


So many sweet bonding moments for the royal couples.
With their own royal weddings out of the way, the Cambridges and Sussexes could take a back seat at cousin Princess Eugenie's nuptials today. Kate Middleton, Prince William, Meghan Markle, and Prince Harry were all smiles sitting in the second row of St. George's Chapel together.
While William and Harry wore long coats, striped trousers, and ties, Kate and Meghan showed off their contrasting styles with their go-to designers.
The Duchess of Cambridge went bold in a fuchsia Alexander McQueen dress with a Philip Treacy hat, while the Duchess of Sussex went with a navy Givenchy coat dress with a Noel Stewart hat.
After the ceremony, the two couples joined the rest of the royal family with a walk about Windsor, greeting fans gathered on the streets as they exited castle.
For their stroll, William, Kate, Meghan, and Harry were accompanied by Prince Charles, Prince Edward, his wife Sophie, Countess of Wessex, their son James, Viscount Severn.
It's been a while since we last saw the in-laws all in one place, especially since Kate Middleton had been on maternity leave and sat out of most royal obligations over the past six months.
The last time we saw the Sussexes and Cambridges publicly together was at the Royal Air Force centenary in July.
Now that Kate is officially back from maternity leave, after giving birth to Prince Louis in April, we can expect a lot more joint appearances from the Fab Four.


text:
Q: Find a value in NSArray [json] I have an array of json objects like this:
array : (
    {
expiryDate = "2016-04-22T00:00:00Z";
    id = "4dad2aeb-efa3-45ca-8d1a-7382851c56d7";
    name = "demo1";
    value = 200;
},
    {
    expiryDate = "2016-06-20T00:00:00Z";
    id = "28e0df69-3e8f-413d-a6c6-3d4cdad544f9";
    name = "Demo 2";
    value = 200;
},
    {
    expiryDate = "2016-06-19T00:00:00Z";
    id = "2e1f452e-ba53-4d4c-a4fa-e15442057b8b";
    name = "demo3";
    value = 214;
})

and I have a string string = 2e1f452e-ba53-4d4c-a4fa-e15442057b8b
I have to check wether the NsString is present in NSArray or not. I am thinking to convert array into dictionary and do searching. Please help me in this part.

A: Suppose your NSArray is array. Use below lines of code.
 BOOL flag= [array valueForKey:@"id"] containsObject: @"2e1f452e-ba53-4d4c-a4fa-e15442057b8b"];

 if(flag){
 NSInteger index=[array valueForKey:@"id"] indexOfObject: @"2e1f452e-ba53-4d4c-a4fa-e15442057b8b"];
 NSString *str = [array valueForKey:@"id"]objectAtIndex:index];
}

A: The array represented by () is a usual NSArray, and you access its elements like this:
yourArray[index]
Being the index an integer starting with 0. You could also go through the array using for... in... syntax which I'm showing you below.
The {} parenthesis represent a NSDictionary (key-value pairs) and you access them like this:
yourDictionary[@"key"]
Being the @"key" a usual NSString.
For comparing strings, you use the isEqualToString: instance method from the NSString class like this: [stringOne isEqualToString:stringTwo]
So your code would be something like this (considering it's an array of dictionaries):
BOOL stringExists = NO;
for (NSDictionary *elem in array) {
    if ([elem[@"id"] isEqualToString:@"yourStringHere"]) {
        stringExists = YES;
        break;
    }
}
if (stringExists) {
    NSLog(@"the string exists!");
}

Sorry about the formatting, I'm writing from my cellphone. If someone would like to edit it, I thank him/her in advance.

A: NSString *str = @"2e1f452e-ba53-4d4c-a4fa-e15442057b8b";
if([array[@"id"] isEqualToString:str]){
NSLog(@"yes.. string is present");
}

redpajama_set_name: RedPajamaStackExchange


(Hamburg/Cologne, 29.03.2007) – Kids for Kids GmbH, a member of the Splendid Group, has concluded a wide-ranging licensing agreement with the acclaimed American publishing house ENCYCLOPAEDIA BRITANNICA. In cooperation with Britannica, the children's educational programme 'Discovering English with Ben & Bella' developed by Kids for Kids will now be published in Korea by the end of the year. The agreement signed by the two companies also envisages an expansion of their collaboration into other countries.
'Discovering English with Ben & Bella' teaches English to children aged 3 and up in a simple and playful manner. The six DVDs already on sale on the German-speaking market quickly and easily familiarise small children with hundreds of English terms. This innovative education programme, which requires neither previous experience of the English language nor any reading or writing skills, is primarily lots of fun and brings almost instant success.
The collaboration with ENCYCLOPAEDIA BRITANNICA, one of the foremost publishing houses in the world, will enable Kids for Kids to supplement its existing 'Ben & Bella' product portfolio with a clearly structured, 18-episode multilevel language acquisition programme based on the DVDs currently available on the German market. ENCYCLOPAEDIA BRITANNICA will mainly market 'Ben & Bella' through its existing sales channels.
"With Splendid Medien's Kids for Kids division, we have found a partner that understands the needs of the market and how to exceed those needs. We believe that together Britannica – with its expertise in product development and design – and Splendid Medien – with its creative approach to the production of educational videos – can create exciting products that will have lasting value to both companies and to customers everywhere," said Michael Ross, Senior Vice President and Education GM of Encyclopaedia Britannica.
The name "Kids for Kids" has been synonymous with high-quality educational materials for children and families since 1999. The licensed programme 'Rudolph the Red-Nosed Reindeer' is popular with young and old alike. 'Discovering English with Ben & Bella' is an innovative and entertaining language acquisition tool developed by the company specifically for very young children. The company's managing director is Alexander Welzhofer.
Hamburg-based Kids for Kids GmbH is a wholly-owned subsidiary of Splendid Medien AG of Cologne.


Picasso Neapolitan Mastiffs are situated on a spacious 10-hectare farmland property, 30 km's outside Pretoria, South Africa. Our facilities include 19 spacious, well-equipped dog camps. Each camp has a room with bedding and lawn for the dogs.
We have 3 airconditioned maternity rooms where the mothers can whelp in comfort.
We have a spacious 17-cage airconditioned room where we can easily keep up to 20 Neo's in case of extreme heat, cold or other situation.
We have 9 full-time staff members who makes sure that the dogs only get the best care and who keeps our facilities spotless during the day.


"In the game, the player must complete missions by controlling toys (usually in the form of vehicles). These missions take place in rooms of a house. The game is known for its unique tasks themed around the various household areas. For instance, the first mission, which takes place in the kitchen, involves using a toy car to roll eggs over to a pot of boiling water.
The game has five basic types of playable vehicles: race cars, which were primarily used in racing missions (though some missions would have the player navigating mazes in race cars), armed ground vehicles such as tanks or trucks with rocket launchers, airplanes, helicopters, and transport vehicles (which are always unarmed, but would typically be used to transport various smaller toys).
A battle mode is also available in the game for up to four players.
Source: Wikipedia, "Toy_Commander," available under the CC-BY-SA License.


The group, who were accompanied by their lawyer Abun Sui Anyit, is demanding that the IGP direct his officers "to stop".
Following this the native community began mounting blockades from September and late last month they concertedly chased away SEB workers from the site locking down the site and bringing work to a standstill.
On Nov 7 police arrested 10 protestors including two teenagers, aged 13 and 16, who were arrested for taking pictures and videos of the arrest.
The protestors have also since been deprived of food, water and medicine.
"The police must not take sides. They must be nuetral.
"We have done nothing wrong. We are only fighting for our rights and proper compensation.
"They must allow food,water, medicine , health and social workers and reporters to go into the area, " he said reading the demands listed.
Ajang said they also wanted all charges against the 10 Penan protestors who were arrested on Nov 7 to be dropped.
He claimed the police had abused their power by firing at the crowd and threatening to take criminal action under section 143 and 147 of the Penal Code.
After handing over the memorandum, the group moved on to Parliament where they handed their second memorandum this time seeking just compensation.
Save Rivers, a coalition of Sarawak based indigenous groups, in statement today said that their demands "have been and still are the same".
The 1,500 Penans from the seven affected villages would be uprooted from their ancestral land following the inundation of the 944MV Murum Dam.
The natives are seeking in compensation 30,000 ha of land as communal forest for the villagers, RM 500,000 per family, RM3,000 per household per month, 25ha of land per household, and a royalty of 10% of electricity generated from the Murum hydropower dam.
Whilst the state government had promised to meet their demands, thus far they have only received between RM10,000 to RM15,000 each along with 'poor quality' houses in Tegulang resettlement.
Three villages have already been moved to the settlement because their house were indundated following the commencement of the impoundment.
Save Rivers chairman Peter Kallang who accompanied the group in parliament said that he hoped Prime Minister Najib Tun Razak will intervene and respond to recommendations listed in the Suhakam Report on the National Inquiry Lands Rights of Indigenous People 2013.
2.Remedy for loss of customary lands.
6.Recognition of land as central to the identity of Indigenous People.
Najib and IGP to intervene? Maybe, on a sandiwara level or pretentious way. The people of Sarawak must unite and rise against evil and tyranny.
What has happened to Bakun Dam? Why need so many Dams?


There are handfuls of music (and comedy) festivals scattered across the UK and Ireland during the coming week, including Kendal Calling, Global Gathering, Bournemouth's Burnout Festival and more - hurry as many people will start thinking about going to these as time passes.
Some superb gigs are looming - a rare treat for London blues fans as Taj Mahal takes to the stage at the apt Under the Bridge (near the Blues' Stamford Bridge stadium, no less). Wu-Tang Clan will lend some heavyweight 20th anniversary hip-hop bangers on tour, plus there's shows from classical luminary James Rhodes, established rockers Anvil and Uli Jon Roth and master-composer Ennio Morricone.
Your kids will be delighted to learn of Justin Live and Milkshake Live shows taking place in the coming weeks while the grown-ups can see some Shakespeare in his hometown or shake a leg to Midnight Tango.
James Rhodes from 25th July to 3rd August in London. Tickets available from £20 Senser from 26th July to 3rd August in Southampton, Guildford, Bristol, Wolverton, Glasgow and more from £10.00 Uli Jon Roth from 28th July in Worcester from £15.00 to £18.00. Some tickets available for this and autumn tour Lemuria from 22nd July to 3rd August in Camden, Stoke-on-Trent, Leeds, Bristol, Nottingham and more from £6.00 to £16.50.


The PEI Coalition for Women in Government encourages women to put their names forward to run for elected office in the Stratford by-election scheduled for May 1, 2017.
The council seat was previously held by a woman, Diane Griffin, and her appointment to the Senate of Canada opens up an exciting opportunity. Those who wish to run as candidates for Ward 2 – Stewart Cove have until 2:00 p.m, on Friday April 7th, 2017 to submit their paperwork for candidacy.
Municipal government is often assumed to be a more accessible avenue for women entering politics because it doesn't require party affiliation or a nomination process. Yet, the percentages of women in municipal governments across Canada, including PEI, are well below parity. According to the Federation of Canadian Municipalities 31% of municipal councillors in PEI are women. In the Town of Stratford, Gail MacDonald is currently sitting as the only woman councillor.
Municipal government has been described as the level of government closest to the people. The Town of Stratford is a good example of how local government can create inclusive policies and spaces that reflect the needs of the community. Increasing gender and diversity representation at decision-making tables results in more nuanced discussion and better outcomes for all.


LONDON (AP) — Tragicomic royal drama "The Favourite" took best British film and a clutch of other trophies Sunday at the British Academy Film Awards, the U.K. equivalent of the Oscars but where the audience is studded with British royals as well as the A-list stars who are royalty in Hollywood.
Yorgos Lanthimos' period drama had a total of 12 nominations going into the night. Star Olivia Colman has already won a Golden Globe for her performance as Queen Anne in "The Favourite" and was favored to take the best-actress prize in London.
The 18th-century queen's distant relative, Prince William, and his wife, Kate, Duchess of Cambridge — wearing a white, off-the-shoulder Alexander McQueen dress — joined Amy Adams, Bradley Cooper, Cate Blanchett, Viola Davis, Timothee Chalamet and other film stars for the black-tie ceremony at Royal Albert Hall.
"The Favourite" lived up to its title, snapping up the outstanding British film award and prizes for its opulent production design, its larger-than-life hair and makeup and the supporting actress performance of Rachel Weisz.
Weisz, who plays the queen's confidante and rival Sarah Churchill, said she "had the greatest luck in that I played opposite two of the most glorious women" — Colman and Emma Stone.
Production design winners Fiona Crombie and Alice Felton dedicated their award to "every woman and working mother who keeps it together and makes it happen." ″The Favourite" also took the trophy for best original screenplay.
"Thank you for celebrating our female-dominated movie about women in power," said Deborah Davis, who won the award alongside co-writer Tony McNamara.
Other winners included Spike Lee's "BlacKkKlansman" for best adapted screenplay, the Bradley Cooper-directed "A Star is Born" for music and Alfonso Cuaron's lush black-and-white "Roma" for cinematography.
The awards, known as BAFTAs , will be scoured for clues to who might triumph at Hollywood's Academy Awards on Feb. 24, in what's shaping up as an unpredictable awards season.
"I feel like I'm in a fever dream," said McCarthy of recognition for the offbeat film, based on the story of a real literary forger.
Her "Can You Ever Forgive Me?" co-star Richard E. Grant has secured both BAFTA and Oscar nominations for his performance as an affable rogue.
British academy voters have all but ignored superhero blockbuster "Black Panther," which is up for best picture at the Oscars and took top prize at the SAG awards last month. It had a single BAFTA nomination, for visual effects, although one of its stars, Letitia Wright, was named Rising Star, the only category decided through a public vote.
The number of female nominees is up this year, but there has been criticism of the academy's failure to nominate any female filmmakers in the best-director category. Only one woman has ever won the directing prize, Kathryn Bigelow for "The Hurt Locker" in 2010.


A-Level Results Day is Thursday 18th August 2016.
GCSE Results Day is Thursday 25th August 2016.
Don't panic but make sure you're fully prepared for results day 2016.
Bring your mobile phone, a pencil, a copy of The Independent or Daily Telegraph newspaper and a calculator.
Tutor House is offering free advice for all London students on A-Level results day 2016.
This year A-Level results day is on 18th August 2016, GCSE a week later on 25th August. We've come up with an A-Level Results Day guide to help students in London and the UK prepare for receiving their results.
Worrying about your results won't make the slightest bit of difference now, and it certainly won't change your results. That being said it can be hard to switch off as you eagerly (or not so eagerly) wait to hear how you have done.
We have put together some ideas to help you manage any stress that you may feel while you wait for A-Level results day on Thursday August 18th 2016.
Sleep, as most students will already know by now, is key to having a fully functioning brain, and this is just as important to preparing for results day. Make sure you get a solid 8 hours so that you are rested and clear headed for the big day.
We know that on the day you will most likely be a mixture of nerves and excitement, however eating a decent breakfast will help set you up for the day. It is likely to be an emotional day whatever the results are so make sure you have the energy to cope and make the right decisions.
3. Make sure your mobile phone is fully charged.
You are going to want to be able to call the important people and let them know how you got on. You may also need to call University of choice to confirm your place, or call other Universities to find out about getting a place through clearance should you not get into one of your first choices.
4. If you didn't get the results you hoped for don't panic!
Take a deep breath and then find a trusted teacher to talk over your next steps with you. Alternatively we will be available all week to give free advice on what to do if you didn't get your desired grades to get into University.
The most important thing to bear in mind is that you have plenty of time to make your decision, whatever that turns out to be. Even if your first two University choices aren't accepted, you still have the possibility of getting a University place through UCAS clearing. Just remember, there are always alternative options available to you.
5. Take your time making decisions.
It's easy to fly into a panic if you did not get the results you wanted, however a calm mind makes the best decisions. Wait for a few hours, and talk it over with teachers, UCAS advisers, friends and family, before making any important choices about what to do next.
Take a day to think about your options before you make any decisions, but begin thoroughly researching the Universities you're interested in, and even call them to discuss your prospectus course.
6. Check the UCAS website or The Daily Telegraph newspaper for clearing places.
Our top tip for results day 2016? Well, for those that didn't get into their chosen University it has to be grabbing a copy of The Independent and checking the UCAS website for clearing places.
If you are looking to get a place through clearing you will need to act quickly, these places are normally all taken within a couple of days. If you are expecting to go through clearing make sure you do grab your copy of The Independent as it's the only newspaper in the UK to publish a full list of all the clearing places available to students.
7. Don't keep it to yourself.
Whatever your results, good or bad, don't keep it in. Results Day, for better or worse, is an exciting day and a day that changes the lives of thousands of students across the UK. Talk it out with friends, family and teachers about how you are feeling.
Your results – specifically your UMS grades.
A Calculator for adding up module grades.
Mobile Phone (fully charged and topped up) for calling home and/or universities if clearing is required.
UCAS and University acceptance letters for grade references.
Personal statement and references to aid with clearing.
Be prepared to pay for any re-marks that may be required, it's always better to send these off as soon as possible to secure your University place.
You can get your results online, via email, text or in the post. You can also go to your college or school to collect them in person.
Choose the method that feels best for you. Some students like to receive their results in private, whilst others go to collect their results with a group of friends for moral support.
One advantage of going to collect your results in person is that you will have teachers on hand to offer support and guidance about your next steps and options that are available to you.
You can use the UCAS tracking system to track the progress of your application to any Universities, as they will already have received your results. Here is some information on how to track your application via UCAS.
If you got the results you wanted, congratulations! If you didn't get the results you had hoped for now is the time to get some good advice. Sit down calmly and look at your other options, then you can make the necessary arrangements for your next steps.
What happens if you didn't get your required grades?
So you've opened the envelope, checked your results, re-checked them, re-checked them again, and again.
Don't panic. You have plenty of options!
One key thing to remember is that you are in control of your choices, and you have plenty of options available to you no matter what the outcome of results day.
Firstly you should get that pen, paper and calculator and re-calculate your UCAS points just to be sure that a mistake hasn't been made – you know, it happens! If no mistakes have been made, get straight on the phone to your University of choice to ensure that you've definitely not been accepted onto your course.
If you're absolutely sure that you didn't achieve the grades to get into your first choice University, call your second, third and forth choices. Discuss whether anything can be done in order to achieve an acceptance.
If you didn't get the results you wanted check out our advice on what to do if you failed your A-Levels. Remember, academic results are just one consideration for an employer.
Personality, life experience, adaptability and ability to work effectively alongside others are all important qualities that cannot be marked on in exams.
Contact us. We offer free advice and will happily chat through your options with you. You'll find us on info@tutorhouse.co.uk and on 020 7612 8297.
Are you expecting to receive your GCSE grades this summer and need help in choosing the right A-Levels for you? Then why not call Tutor House's free advice line and speak to one of our experienced team members who will be able to offer you free informative advice. Sometimes it can be difficult to know which A-Levels to pick as one is often torn between what they need to do in order to apply for a specific university course and what they would like to do. More often than none, the decision need not be so difficult and a pleasant compromise can be arrived at.
If you're stuck on what to do next or where to go now, call us. If you didn't get the results you wanted, don't worry, call us.
We're here to help, giving free advice for all students and concerned parents.
Students across the country often struggle to get a good night's rest before the big day. Don't panic, take a deep breath and read some of our useful tips that will help you doze off before exams.
You heard us. Don't study the day before your exams. At this point, if you don't know the material, you don't have much hope. All you will do is get anxious if you stumble across something you don't know, which will seriously serve to keep you up at night. If you want to, do some light subject reading before bed, but no timed tests to stress you out.
You may have seen our blog about the best brain foods to eat before your exams? If you haven't, we can surmise that you should be eating a healthy dinner before your exams. Put down the McDonalds and pick up the McBroccoli. You should be eating a balanced meal that's low on sugar and caffeine – so you'll be able to sleep easier. We know the struggle is real, but you have to say "no" to pudding.
Mindfulness is all the rage. (Although 'rage' may not be the right word.) Mindfulness is a mix of breathing exercises and meditation that, when used before exams, can help you stay calm and focused. There are a number of techniques you can learn to centre yourself. With anxieties gone, you should be able to get to sleep quicker and have a restless night.
Shock horror, but it's a well-known fact that smartphone screens stop your brain from producing melatonin (the hormone that helps you sleep). So switch it off, put it in another room and lock the door so that you're not tempted to spend the night before your exams scrolling Instagram rather than getting rested.
If you've tried all of the above and you still are struggling to get a good night's sleep… then don't worry! One night's sleep won't hurt your exam prospects. You've still studied hard and worked towards success and a few lost hours won't limit your chances of success. So just dive right in.
If it's not the night before your exam and you still want to revise, then get a tutor. At Tutor House, we have experienced tutors for every subject and all levels. Call us on 020 3950 0320 or email info@tutorhouse.co.uk to find out more.