2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-08-28 18:18:39 -06:00
|
|
|
* Copyright 2003-2005 Red Hat, Inc. All rights reserved.
|
|
|
|
* Copyright 2003-2005 Jeff Garzik
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; see the file COPYING. If not, write to
|
|
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* libata documentation is available via 'make {ps|pdf}docs',
|
|
|
|
* as Documentation/DocBook/libata.*
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_LIBATA_H__
|
|
|
|
#define __LINUX_LIBATA_H__
|
|
|
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/pci.h>
|
2005-11-10 17:21:38 -07:00
|
|
|
#include <linux/dma-mapping.h>
|
2006-06-23 05:18:31 -06:00
|
|
|
#include <asm/scatterlist.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <linux/ata.h>
|
|
|
|
#include <linux/workqueue.h>
|
2006-04-11 11:12:34 -06:00
|
|
|
#include <scsi/scsi_host.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-09-25 13:33:09 -06:00
|
|
|
/*
|
|
|
|
* Define if arch has non-standard setup. This is a _PCI_ standard
|
|
|
|
* not a legacy or ISA standard.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_ATA_NONSTANDARD
|
2006-08-10 01:59:10 -06:00
|
|
|
#include <asm/libata-portmap.h>
|
2006-09-25 13:33:09 -06:00
|
|
|
#else
|
|
|
|
#include <asm-generic/libata-portmap.h>
|
|
|
|
#endif
|
2006-08-10 01:59:10 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-01-17 17:34:42 -07:00
|
|
|
* compile-time options: to be removed as soon as all the drivers are
|
|
|
|
* converted to the new debugging mechanism
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#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 */
|
2006-08-29 16:12:40 -06:00
|
|
|
#define ATA_ENABLE_PATA /* define to enable PATA support in some
|
2005-04-16 16:20:36 -06:00
|
|
|
* low-level drivers */
|
|
|
|
|
|
|
|
|
|
|
|
/* note: prints function name for you */
|
|
|
|
#ifdef ATA_DEBUG
|
|
|
|
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
|
|
|
|
#ifdef ATA_VERBOSE_DEBUG
|
|
|
|
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
|
|
|
|
#else
|
|
|
|
#define VPRINTK(fmt, args...)
|
|
|
|
#endif /* ATA_VERBOSE_DEBUG */
|
|
|
|
#else
|
|
|
|
#define DPRINTK(fmt, args...)
|
|
|
|
#define VPRINTK(fmt, args...)
|
|
|
|
#endif /* ATA_DEBUG */
|
|
|
|
|
2005-11-14 12:14:16 -07:00
|
|
|
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
|
|
|
|
|
2006-01-17 17:34:42 -07:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* defines only for the constants which don't work well as enums */
|
|
|
|
#define ATA_TAG_POISON 0xfafbfcfdU
|
|
|
|
|
|
|
|
/* move to PCI layer? */
|
2006-09-27 20:20:11 -06:00
|
|
|
#define PCI_VDEVICE(vendor, device) \
|
|
|
|
PCI_VENDOR_ID_##vendor, (device), \
|
|
|
|
PCI_ANY_ID, PCI_ANY_ID, 0, 0
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
return &pdev->dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum {
|
|
|
|
/* various global constants */
|
|
|
|
LIBATA_MAX_PRD = ATA_MAX_PRD / 2,
|
|
|
|
ATA_MAX_PORTS = 8,
|
|
|
|
ATA_DEF_QUEUE = 1,
|
2006-05-15 05:58:02 -06:00
|
|
|
/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
|
2006-05-15 06:03:48 -06:00
|
|
|
ATA_MAX_QUEUE = 32,
|
2006-05-15 05:58:02 -06:00
|
|
|
ATA_TAG_INTERNAL = ATA_MAX_QUEUE - 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
ATA_MAX_BUS = 2,
|
|
|
|
ATA_DEF_BUSY_WAIT = 10000,
|
|
|
|
ATA_SHORT_PAUSE = (HZ >> 6) + 1,
|
|
|
|
|
|
|
|
ATA_SHT_EMULATED = 1,
|
|
|
|
ATA_SHT_CMD_PER_LUN = 1,
|
|
|
|
ATA_SHT_THIS_ID = -1,
|
2005-10-21 22:19:33 -06:00
|
|
|
ATA_SHT_USE_CLUSTERING = 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* struct ata_device stuff */
|
2006-04-02 03:51:52 -06:00
|
|
|
ATA_DFLAG_LBA = (1 << 0), /* device supports LBA */
|
|
|
|
ATA_DFLAG_LBA48 = (1 << 1), /* device supports LBA48 */
|
2006-04-02 08:30:40 -06:00
|
|
|
ATA_DFLAG_CDB_INTR = (1 << 2), /* device asserts INTRQ when ready for CDB */
|
2006-05-15 06:03:38 -06:00
|
|
|
ATA_DFLAG_NCQ = (1 << 3), /* device supports NCQ */
|
2006-11-11 04:10:45 -07:00
|
|
|
ATA_DFLAG_FLUSH_EXT = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
|
2006-04-02 03:51:53 -06:00
|
|
|
ATA_DFLAG_CFG_MASK = (1 << 8) - 1,
|
2006-04-02 03:51:52 -06:00
|
|
|
|
2006-09-30 04:44:39 -06:00
|
|
|
ATA_DFLAG_PIO = (1 << 8), /* device limited to PIO mode */
|
2006-10-18 23:44:53 -06:00
|
|
|
ATA_DFLAG_NCQ_OFF = (1 << 9), /* device limited to non-NCQ mode */
|
2006-09-30 04:44:39 -06:00
|
|
|
ATA_DFLAG_SUSPENDED = (1 << 10), /* device suspended */
|
2006-05-31 03:27:32 -06:00
|
|
|
ATA_DFLAG_INIT_MASK = (1 << 16) - 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-31 03:27:29 -06:00
|
|
|
ATA_DFLAG_DETACH = (1 << 16),
|
|
|
|
ATA_DFLAG_DETACHED = (1 << 17),
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ATA_DEV_UNKNOWN = 0, /* unknown device */
|
|
|
|
ATA_DEV_ATA = 1, /* ATA device */
|
|
|
|
ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */
|
|
|
|
ATA_DEV_ATAPI = 3, /* ATAPI device */
|
|
|
|
ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */
|
|
|
|
ATA_DEV_NONE = 5, /* no device */
|
|
|
|
|
|
|
|
/* struct ata_port flags */
|
2006-04-02 03:51:52 -06:00
|
|
|
ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */
|
2005-04-16 16:20:36 -06:00
|
|
|
/* (doesn't imply presence) */
|
2006-04-02 03:51:52 -06:00
|
|
|
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 */
|
2006-05-31 03:27:25 -06:00
|
|
|
ATA_FLAG_PIO_POLLING = (1 << 9), /* use polling PIO if LLD
|
|
|
|
* doesn't handle PIO interrupts */
|
|
|
|
ATA_FLAG_NCQ = (1 << 10), /* host supports NCQ */
|
2006-05-31 03:27:29 -06:00
|
|
|
ATA_FLAG_HRST_TO_RESUME = (1 << 11), /* hardreset to resume phy */
|
|
|
|
ATA_FLAG_SKIP_D2H_BSY = (1 << 12), /* can't wait for the first D2H
|
|
|
|
* Register FIS clearing BSY */
|
2006-05-31 03:27:25 -06:00
|
|
|
ATA_FLAG_DEBUGMSG = (1 << 13),
|
2006-12-03 05:34:13 -07:00
|
|
|
ATA_FLAG_SETXFER_POLLING= (1 << 14), /* use polling for SETXFER */
|
2007-01-25 03:40:05 -07:00
|
|
|
ATA_FLAG_IGN_SIMPLEX = (1 << 15), /* ignore SIMPLEX */
|
2006-04-02 03:51:52 -06:00
|
|
|
|
2006-06-28 10:29:30 -06:00
|
|
|
/* 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 */
|
2006-05-15 05:57:58 -06:00
|
|
|
|
2006-06-28 10:29:30 -06:00
|
|
|
/* struct ata_port pflags */
|
|
|
|
ATA_PFLAG_EH_PENDING = (1 << 0), /* EH pending */
|
|
|
|
ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
|
|
|
|
ATA_PFLAG_FROZEN = (1 << 2), /* port is frozen */
|
|
|
|
ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */
|
|
|
|
ATA_PFLAG_LOADING = (1 << 4), /* boot/loading probe */
|
|
|
|
ATA_PFLAG_UNLOADING = (1 << 5), /* module is unloading */
|
|
|
|
ATA_PFLAG_SCSI_HOTPLUG = (1 << 6), /* SCSI hotplug scheduled */
|
2006-04-02 03:51:52 -06:00
|
|
|
|
2006-06-28 10:29:30 -06:00
|
|
|
ATA_PFLAG_FLUSH_PORT_TASK = (1 << 16), /* flush port task */
|
|
|
|
ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */
|
2006-07-03 01:07:27 -06:00
|
|
|
ATA_PFLAG_PM_PENDING = (1 << 18), /* PM operation pending */
|
2006-04-02 03:51:52 -06:00
|
|
|
|
|
|
|
/* struct ata_queued_cmd flags */
|
|
|
|
ATA_QCFLAG_ACTIVE = (1 << 0), /* cmd not yet ack'd to scsi lyer */
|
|
|
|
ATA_QCFLAG_SG = (1 << 1), /* have s/g table? */
|
|
|
|
ATA_QCFLAG_SINGLE = (1 << 2), /* no s/g, just a single buffer */
|
2005-04-16 16:20:36 -06:00
|
|
|
ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
|
2006-04-02 03:51:53 -06:00
|
|
|
ATA_QCFLAG_IO = (1 << 3), /* standard IO command */
|
2006-05-15 05:57:40 -06:00
|
|
|
ATA_QCFLAG_RESULT_TF = (1 << 4), /* result TF requested */
|
|
|
|
|
2006-05-15 05:57:58 -06:00
|
|
|
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) */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-27 10:42:40 -07:00
|
|
|
/* host set flags */
|
2006-08-24 01:19:22 -06:00
|
|
|
ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */
|
2006-08-30 22:02:15 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* various lengths of time */
|
2006-01-17 13:50:31 -07:00
|
|
|
ATA_TMOUT_BOOT = 30 * HZ, /* heuristic */
|
|
|
|
ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* heuristic */
|
2005-12-12 22:48:31 -07:00
|
|
|
ATA_TMOUT_INTERNAL = 30 * HZ,
|
|
|
|
ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* 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
|
2006-03-05 12:31:56 -07:00
|
|
|
* unsigned int bitmap
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2006-08-10 11:52:12 -06:00
|
|
|
ATA_BITS_PIO = 7,
|
|
|
|
ATA_BITS_MWDMA = 5,
|
2006-03-05 12:31:56 -07:00
|
|
|
ATA_BITS_UDMA = 8,
|
|
|
|
|
|
|
|
ATA_SHIFT_PIO = 0,
|
|
|
|
ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_BITS_PIO,
|
|
|
|
ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,
|
|
|
|
|
|
|
|
ATA_MASK_PIO = ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
|
|
|
|
ATA_MASK_MWDMA = ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
|
|
|
|
ATA_MASK_UDMA = ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
|
2005-10-05 05:13:30 -06:00
|
|
|
|
|
|
|
/* size of buffer to pad xfers ending on unaligned boundaries */
|
|
|
|
ATA_DMA_PAD_SZ = 4,
|
|
|
|
ATA_DMA_PAD_BUF_SZ = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
|
2006-04-02 03:51:52 -06:00
|
|
|
|
|
|
|
/* masks for port functions */
|
2005-10-04 06:09:19 -06:00
|
|
|
ATA_PORT_PRIMARY = (1 << 0),
|
|
|
|
ATA_PORT_SECONDARY = (1 << 1),
|
2006-04-02 01:54:46 -07:00
|
|
|
|
2006-05-15 05:58:19 -06:00
|
|
|
/* ering size */
|
|
|
|
ATA_ERING_SIZE = 32,
|
|
|
|
|
2006-05-15 05:58:21 -06:00
|
|
|
/* desc_len for ata_eh_info and context */
|
|
|
|
ATA_EH_DESC_LEN = 80,
|
|
|
|
|
2006-05-15 05:58:17 -06:00
|
|
|
/* reset / recovery action types */
|
|
|
|
ATA_EH_REVALIDATE = (1 << 0),
|
|
|
|
ATA_EH_SOFTRESET = (1 << 1),
|
|
|
|
ATA_EH_HARDRESET = (1 << 2),
|
2006-07-03 01:07:26 -06:00
|
|
|
ATA_EH_SUSPEND = (1 << 3),
|
|
|
|
ATA_EH_RESUME = (1 << 4),
|
|
|
|
ATA_EH_PM_FREEZE = (1 << 5),
|
2006-05-15 05:58:17 -06:00
|
|
|
|
|
|
|
ATA_EH_RESET_MASK = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
|
2006-07-03 01:07:26 -06:00
|
|
|
ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_SUSPEND |
|
|
|
|
ATA_EH_RESUME | ATA_EH_PM_FREEZE,
|
2006-05-15 05:58:17 -06:00
|
|
|
|
2006-05-15 05:58:21 -06:00
|
|
|
/* ata_eh_info->flags */
|
2006-05-31 03:27:29 -06:00
|
|
|
ATA_EHI_HOTPLUGGED = (1 << 0), /* could have been hotplugged */
|
2006-07-10 08:18:46 -06:00
|
|
|
ATA_EHI_RESUME_LINK = (1 << 1), /* resume link (reset modifier) */
|
2006-07-03 01:07:26 -06:00
|
|
|
ATA_EHI_NO_AUTOPSY = (1 << 2), /* no autopsy */
|
|
|
|
ATA_EHI_QUIET = (1 << 3), /* be quiet */
|
2006-05-31 03:27:29 -06:00
|
|
|
|
|
|
|
ATA_EHI_DID_RESET = (1 << 16), /* already reset this port */
|
2006-11-01 02:38:52 -07:00
|
|
|
ATA_EHI_PRINTINFO = (1 << 17), /* print configuration info */
|
2006-11-01 02:39:27 -07:00
|
|
|
ATA_EHI_SETMODE = (1 << 18), /* configure transfer mode */
|
|
|
|
ATA_EHI_POST_SETMODE = (1 << 19), /* revaildating after setmode */
|
2006-05-15 05:58:21 -06:00
|
|
|
|
2006-07-10 08:18:46 -06:00
|
|
|
ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
|
|
|
|
|
2006-05-15 05:58:12 -06:00
|
|
|
/* max repeat if error condition is still set after ->error_handler */
|
|
|
|
ATA_EH_MAX_REPEAT = 5,
|
|
|
|
|
2006-04-02 01:54:46 -07:00
|
|
|
/* how hard are we gonna try to probe/recover devices */
|
|
|
|
ATA_PROBE_MAX_TRIES = 3,
|
2006-05-15 05:58:22 -06:00
|
|
|
ATA_EH_RESET_TRIES = 3,
|
|
|
|
ATA_EH_DEV_TRIES = 3,
|
2006-05-31 03:27:48 -06:00
|
|
|
|
|
|
|
/* Drive spinup time (time from power-on to the first D2H FIS)
|
|
|
|
* in msecs - 8s currently. Failing to get ready in this time
|
|
|
|
* isn't critical. It will result in reset failure for
|
|
|
|
* controllers which can't wait for the first D2H FIS. libata
|
|
|
|
* will retry, so it just has to be long enough to spin up
|
|
|
|
* most devices.
|
|
|
|
*/
|
|
|
|
ATA_SPINUP_WAIT = 8000,
|
2006-09-12 09:55:12 -06:00
|
|
|
|
|
|
|
/* 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 */
|
2006-10-27 20:08:46 -06:00
|
|
|
ATA_HORKAGE_NODMA = (1 << 1), /* DMA problems */
|
|
|
|
ATA_HORKAGE_NONCQ = (1 << 2), /* Don't use NCQ */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-09-27 03:36:35 -06:00
|
|
|
enum hsm_task_states {
|
2005-09-30 05:07:39 -06:00
|
|
|
HSM_ST_IDLE, /* no command on going */
|
|
|
|
HSM_ST, /* (waiting the device to) transfer data */
|
|
|
|
HSM_ST_LAST, /* (waiting the device to) complete command */
|
|
|
|
HSM_ST_ERR, /* error */
|
|
|
|
HSM_ST_FIRST, /* (waiting the device to)
|
|
|
|
write CDB or first data block */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-10-30 02:44:42 -07:00
|
|
|
enum ata_completion_errors {
|
2006-01-22 21:09:36 -07:00
|
|
|
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 */
|
2006-11-10 02:08:10 -07:00
|
|
|
AC_ERR_NODEV_HINT = (1 << 9), /* polling device detection hint */
|
2005-10-30 02:44:42 -07:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* forward declarations */
|
|
|
|
struct scsi_device;
|
|
|
|
struct ata_port_operations;
|
|
|
|
struct ata_port;
|
|
|
|
struct ata_queued_cmd;
|
|
|
|
|
|
|
|
/* typedefs */
|
2006-01-22 21:09:36 -07:00
|
|
|
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
|
2006-05-31 03:27:48 -06:00
|
|
|
typedef int (*ata_prereset_fn_t)(struct ata_port *ap);
|
|
|
|
typedef int (*ata_reset_fn_t)(struct ata_port *ap, unsigned int *classes);
|
|
|
|
typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *classes);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct ata_ioports {
|
|
|
|
unsigned long cmd_addr;
|
|
|
|
unsigned long data_addr;
|
|
|
|
unsigned long error_addr;
|
|
|
|
unsigned long feature_addr;
|
|
|
|
unsigned long nsect_addr;
|
|
|
|
unsigned long lbal_addr;
|
|
|
|
unsigned long lbam_addr;
|
|
|
|
unsigned long lbah_addr;
|
|
|
|
unsigned long device_addr;
|
|
|
|
unsigned long status_addr;
|
|
|
|
unsigned long command_addr;
|
|
|
|
unsigned long altstatus_addr;
|
|
|
|
unsigned long ctl_addr;
|
|
|
|
unsigned long bmdma_addr;
|
|
|
|
unsigned long scr_addr;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_probe_ent {
|
|
|
|
struct list_head node;
|
|
|
|
struct device *dev;
|
2005-10-22 12:27:05 -06:00
|
|
|
const struct ata_port_operations *port_ops;
|
2005-11-06 22:59:37 -07:00
|
|
|
struct scsi_host_template *sht;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ata_ioports port[ATA_MAX_PORTS];
|
|
|
|
unsigned int n_ports;
|
2006-08-10 01:59:12 -06:00
|
|
|
unsigned int dummy_port_mask;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int pio_mask;
|
|
|
|
unsigned int mwdma_mask;
|
|
|
|
unsigned int udma_mask;
|
|
|
|
unsigned long irq;
|
2006-08-10 01:59:10 -06:00
|
|
|
unsigned long irq2;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int irq_flags;
|
2006-08-24 01:19:22 -06:00
|
|
|
unsigned long port_flags;
|
|
|
|
unsigned long _host_flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
void __iomem *mmio_base;
|
|
|
|
void *private_data;
|
2006-09-15 12:04:15 -06:00
|
|
|
|
|
|
|
/* port_info for the secondary port. Together with irq2, it's
|
|
|
|
* used to implement non-uniform secondary port. Currently,
|
|
|
|
* the only user is ata_piix combined mode. This workaround
|
|
|
|
* will be removed together with ata_probe_ent when init model
|
|
|
|
* is updated.
|
|
|
|
*/
|
|
|
|
const struct ata_port_info *pinfo2;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
struct ata_host {
|
2005-04-16 16:20:36 -06:00
|
|
|
spinlock_t lock;
|
|
|
|
struct device *dev;
|
|
|
|
unsigned long irq;
|
2006-08-10 01:59:10 -06:00
|
|
|
unsigned long irq2;
|
2005-04-16 16:20:36 -06:00
|
|
|
void __iomem *mmio_base;
|
|
|
|
unsigned int n_ports;
|
|
|
|
void *private_data;
|
2005-10-22 12:27:05 -06:00
|
|
|
const struct ata_port_operations *ops;
|
2006-03-27 10:58:20 -07:00
|
|
|
unsigned long flags;
|
|
|
|
int simplex_claimed; /* Keep seperate in case we
|
|
|
|
ever need to do this locked */
|
2006-06-12 08:05:38 -06:00
|
|
|
struct ata_port *ports[0];
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
2005-10-05 05:13:30 -06:00
|
|
|
unsigned int orig_n_elem;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int dma_dir;
|
|
|
|
|
2005-10-05 05:13:30 -06:00
|
|
|
unsigned int pad_len;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int nsect;
|
|
|
|
unsigned int cursect;
|
|
|
|
|
|
|
|
unsigned int nbytes;
|
|
|
|
unsigned int curbytes;
|
|
|
|
|
|
|
|
unsigned int cursg;
|
|
|
|
unsigned int cursg_ofs;
|
|
|
|
|
|
|
|
struct scatterlist sgent;
|
2005-10-05 05:13:30 -06:00
|
|
|
struct scatterlist pad_sgent;
|
2005-04-16 16:20:36 -06:00
|
|
|
void *buf_virt;
|
|
|
|
|
2005-10-05 05:13:30 -06:00
|
|
|
/* DO NOT iterate over __sg manually, use ata_for_each_sg() */
|
|
|
|
struct scatterlist *__sg;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-05 00:38:02 -07:00
|
|
|
unsigned int err_mask;
|
2006-05-15 05:57:40 -06:00
|
|
|
struct ata_taskfile result_tf;
|
2005-04-16 16:20:36 -06:00
|
|
|
ata_qc_cb_t complete_fn;
|
|
|
|
|
|
|
|
void *private_data;
|
|
|
|
};
|
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
struct ata_port_stats {
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long unhandled_irq;
|
|
|
|
unsigned long idle_irq;
|
|
|
|
unsigned long rw_reqbuf;
|
|
|
|
};
|
|
|
|
|
2006-05-15 05:58:19 -06:00
|
|
|
struct ata_ering_entry {
|
|
|
|
int is_io;
|
|
|
|
unsigned int err_mask;
|
|
|
|
u64 timestamp;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_ering {
|
|
|
|
int cursor;
|
|
|
|
struct ata_ering_entry ring[ATA_ERING_SIZE];
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ata_device {
|
2006-05-15 05:57:51 -06:00
|
|
|
struct ata_port *ap;
|
2006-05-31 03:27:32 -06:00
|
|
|
unsigned int devno; /* 0 or 1 */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags; /* ATA_DFLAG_xxx */
|
2006-05-31 03:27:40 -06:00
|
|
|
struct scsi_device *sdev; /* attached SCSI device */
|
2006-05-31 03:27:32 -06:00
|
|
|
/* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
|
|
|
|
u64 n_sectors; /* size of device, if ATA */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int class; /* ATA_DEV_xxx */
|
2006-05-15 05:57:35 -06:00
|
|
|
u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
|
2005-04-16 16:20:36 -06:00
|
|
|
u8 pio_mode;
|
|
|
|
u8 dma_mode;
|
|
|
|
u8 xfer_mode;
|
|
|
|
unsigned int xfer_shift; /* ATA_SHIFT_xxx */
|
|
|
|
|
2005-10-12 01:06:27 -06:00
|
|
|
unsigned int multi_count; /* sectors count for
|
|
|
|
READ/WRITE MULTIPLE */
|
2006-02-12 07:32:59 -07:00
|
|
|
unsigned int max_sectors; /* per-device max sectors */
|
2006-02-12 07:32:58 -07:00
|
|
|
unsigned int cdb_len;
|
2005-05-12 13:29:42 -06:00
|
|
|
|
2006-03-23 22:07:50 -07:00
|
|
|
/* per-dev xfer mask */
|
|
|
|
unsigned int pio_mask;
|
|
|
|
unsigned int mwdma_mask;
|
|
|
|
unsigned int udma_mask;
|
|
|
|
|
2005-05-12 13:29:42 -06:00
|
|
|
/* for CHS addressing */
|
|
|
|
u16 cylinders; /* Number of cylinders */
|
|
|
|
u16 heads; /* Number of heads */
|
|
|
|
u16 sectors; /* Number of sectors per track */
|
2006-05-15 05:58:19 -06:00
|
|
|
|
|
|
|
/* error history */
|
|
|
|
struct ata_ering ering;
|
2006-09-12 09:55:12 -06:00
|
|
|
unsigned int horkage; /* List of broken features */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-05-31 03:27:32 -06:00
|
|
|
/* Offset into struct ata_device. Fields above it are maintained
|
|
|
|
* acress device init. Fields below are zeroed.
|
|
|
|
*/
|
|
|
|
#define ATA_DEVICE_CLEAR_OFFSET offsetof(struct ata_device, n_sectors)
|
|
|
|
|
2006-05-15 05:58:21 -06:00
|
|
|
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 */
|
2006-06-19 03:27:23 -06:00
|
|
|
unsigned int dev_action[ATA_MAX_DEVICES]; /* dev EH action */
|
2006-05-15 05:58:21 -06:00
|
|
|
unsigned int flags; /* ATA_EHI_* flags */
|
2006-05-31 03:27:29 -06:00
|
|
|
|
|
|
|
unsigned long hotplug_timestamp;
|
|
|
|
unsigned int probe_mask;
|
|
|
|
|
2006-05-15 05:58:21 -06:00
|
|
|
char desc[ATA_EH_DESC_LEN];
|
|
|
|
int desc_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_eh_context {
|
|
|
|
struct ata_eh_info i;
|
|
|
|
int tries[ATA_MAX_DEVICES];
|
2006-05-31 03:27:29 -06:00
|
|
|
unsigned int classes[ATA_MAX_DEVICES];
|
|
|
|
unsigned int did_probe_mask;
|
2006-05-15 05:58:21 -06:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ata_port {
|
2006-08-24 01:19:22 -06:00
|
|
|
struct Scsi_Host *scsi_host; /* our co-allocated scsi host */
|
2005-10-22 12:27:05 -06:00
|
|
|
const struct ata_port_operations *ops;
|
2006-06-22 21:46:10 -06:00
|
|
|
spinlock_t *lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags; /* ATA_FLAG_xxx */
|
2006-06-28 10:29:30 -06:00
|
|
|
unsigned int pflags; /* ATA_PFLAG_xxx */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int id; /* unique id req'd by scsi midlyr */
|
|
|
|
unsigned int port_no; /* unique port #; from zero */
|
|
|
|
|
|
|
|
struct ata_prd *prd; /* our SG list */
|
|
|
|
dma_addr_t prd_dma; /* and its DMA mapping */
|
|
|
|
|
2005-10-05 05:13:30 -06:00
|
|
|
void *pad; /* array of DMA pad buffers */
|
|
|
|
dma_addr_t pad_dma;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */
|
|
|
|
|
|
|
|
u8 ctl; /* cache of ATA control register */
|
|
|
|
u8 last_ctl; /* Cache last written value */
|
|
|
|
unsigned int pio_mask;
|
|
|
|
unsigned int mwdma_mask;
|
|
|
|
unsigned int udma_mask;
|
|
|
|
unsigned int cbl; /* cable type; ATA_CBL_xxx */
|
2006-05-31 03:27:38 -06:00
|
|
|
unsigned int hw_sata_spd_limit;
|
2006-04-02 05:53:28 -06:00
|
|
|
unsigned int sata_spd_limit; /* SATA PHY speed limit */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
/* record runtime error info, protected by host lock */
|
2006-05-15 05:58:21 -06:00
|
|
|
struct ata_eh_info eh_info;
|
|
|
|
/* EH context owned by EH */
|
|
|
|
struct ata_eh_context eh_context;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ata_device device[ATA_MAX_DEVICES];
|
|
|
|
|
|
|
|
struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
|
2006-05-15 06:03:41 -06:00
|
|
|
unsigned long qc_allocated;
|
2006-05-15 06:03:43 -06:00
|
|
|
unsigned int qc_active;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int active_tag;
|
2006-05-15 06:03:43 -06:00
|
|
|
u32 sactive;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
struct ata_port_stats stats;
|
|
|
|
struct ata_host *host;
|
2006-03-23 16:30:15 -07:00
|
|
|
struct device *dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-22 07:55:48 -07:00
|
|
|
void *port_task_data;
|
2006-11-22 07:54:01 -07:00
|
|
|
struct delayed_work port_task;
|
|
|
|
struct delayed_work hotplug_task;
|
2006-06-11 22:22:04 -06:00
|
|
|
struct work_struct scsi_rescan_task;
|
2006-03-04 23:29:09 -07:00
|
|
|
|
2005-09-27 03:36:35 -06:00
|
|
|
unsigned int hsm_task_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-17 17:34:42 -07:00
|
|
|
u32 msg_enable;
|
2006-01-22 21:09:37 -07:00
|
|
|
struct list_head eh_done_q;
|
2006-05-31 03:27:27 -06:00
|
|
|
wait_queue_head_t eh_wait_q;
|
2006-01-17 17:34:42 -07:00
|
|
|
|
2006-07-03 01:07:27 -06:00
|
|
|
pm_message_t pm_mesg;
|
|
|
|
int *pm_result;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void *private_data;
|
2006-05-15 05:57:35 -06:00
|
|
|
|
|
|
|
u8 sector_buf[ATA_SECT_SIZE]; /* owned by EH */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_port_operations {
|
|
|
|
void (*port_disable) (struct ata_port *);
|
|
|
|
|
|
|
|
void (*dev_config) (struct ata_port *, struct ata_device *);
|
|
|
|
|
|
|
|
void (*set_piomode) (struct ata_port *, struct ata_device *);
|
|
|
|
void (*set_dmamode) (struct ata_port *, struct ata_device *);
|
2006-03-27 10:58:20 -07:00
|
|
|
unsigned long (*mode_filter) (const struct ata_port *, struct ata_device *, unsigned long);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-22 12:27:05 -06:00
|
|
|
void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
|
|
|
|
|
2005-10-22 12:27:05 -06:00
|
|
|
void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
|
2005-04-16 16:20:36 -06:00
|
|
|
u8 (*check_status)(struct ata_port *ap);
|
|
|
|
u8 (*check_altstatus)(struct ata_port *ap);
|
|
|
|
void (*dev_select)(struct ata_port *ap, unsigned int device);
|
|
|
|
|
2006-01-24 01:05:22 -07:00
|
|
|
void (*phy_reset) (struct ata_port *ap); /* obsolete */
|
2007-01-24 04:47:07 -07:00
|
|
|
int (*set_mode) (struct ata_port *ap, struct ata_device **r_failed_dev);
|
2006-01-24 01:05:22 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*post_set_mode) (struct ata_port *ap);
|
|
|
|
|
2007-01-24 04:47:07 -07:00
|
|
|
int (*check_atapi_dma) (struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
void (*bmdma_setup) (struct ata_queued_cmd *qc);
|
|
|
|
void (*bmdma_start) (struct ata_queued_cmd *qc);
|
|
|
|
|
2006-05-22 09:59:59 -06:00
|
|
|
void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*qc_prep) (struct ata_queued_cmd *qc);
|
2006-01-22 21:09:36 -07:00
|
|
|
unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-15 05:57:58 -06:00
|
|
|
/* Error handlers. ->error_handler overrides ->eng_timeout and
|
|
|
|
* indicates that new-style EH is in place.
|
|
|
|
*/
|
|
|
|
void (*eng_timeout) (struct ata_port *ap); /* obsolete */
|
|
|
|
|
|
|
|
void (*freeze) (struct ata_port *ap);
|
|
|
|
void (*thaw) (struct ata_port *ap);
|
|
|
|
void (*error_handler) (struct ata_port *ap);
|
|
|
|
void (*post_internal_cmd) (struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
irq_handler_t irq_handler;
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*irq_clear) (struct ata_port *);
|
|
|
|
|
|
|
|
u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
|
|
|
|
void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
|
|
|
|
u32 val);
|
|
|
|
|
2006-07-03 01:07:27 -06:00
|
|
|
int (*port_suspend) (struct ata_port *ap, pm_message_t mesg);
|
|
|
|
int (*port_resume) (struct ata_port *ap);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int (*port_start) (struct ata_port *ap);
|
|
|
|
void (*port_stop) (struct ata_port *ap);
|
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
void (*host_stop) (struct ata_host *host);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-26 09:03:19 -06:00
|
|
|
void (*bmdma_stop) (struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
u8 (*bmdma_status) (struct ata_port *ap);
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_port_info {
|
2005-10-31 10:31:40 -07:00
|
|
|
struct scsi_host_template *sht;
|
2006-08-24 01:19:22 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long pio_mask;
|
|
|
|
unsigned long mwdma_mask;
|
|
|
|
unsigned long udma_mask;
|
2005-10-22 12:27:05 -06:00
|
|
|
const struct ata_port_operations *port_ops;
|
2005-11-08 07:09:44 -07:00
|
|
|
void *private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-10-21 17:01:32 -06:00
|
|
|
struct ata_timing {
|
|
|
|
unsigned short mode; /* ATA mode */
|
|
|
|
unsigned short setup; /* t1 */
|
|
|
|
unsigned short act8b; /* t2 for 8-bit I/O */
|
|
|
|
unsigned short rec8b; /* t2i for 8-bit I/O */
|
|
|
|
unsigned short cyc8b; /* t0 for 8-bit I/O */
|
|
|
|
unsigned short active; /* t2 or tD */
|
|
|
|
unsigned short recover; /* t2i or tK */
|
|
|
|
unsigned short cycle; /* t0 */
|
|
|
|
unsigned short udma; /* t2CYCTYP/2 */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define FIT(v,vmin,vmax) max_t(short,min_t(short,v,vmax),vmin)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
extern const unsigned long sata_deb_timing_normal[];
|
|
|
|
extern const unsigned long sata_deb_timing_hotplug[];
|
|
|
|
extern const unsigned long sata_deb_timing_long[];
|
|
|
|
|
2006-08-10 01:59:12 -06:00
|
|
|
extern const struct ata_port_operations ata_dummy_port_ops;
|
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
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;
|
|
|
|
}
|
2006-05-31 03:27:46 -06:00
|
|
|
|
2006-08-10 01:59:12 -06:00
|
|
|
static inline int ata_port_is_dummy(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return ap->ops == &ata_dummy_port_ops;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_port_probe(struct ata_port *);
|
|
|
|
extern void __sata_phy_reset(struct ata_port *ap);
|
|
|
|
extern void sata_phy_reset(struct ata_port *ap);
|
|
|
|
extern void ata_bus_reset(struct ata_port *ap);
|
2006-05-15 05:57:23 -06:00
|
|
|
extern int sata_set_spd(struct ata_port *ap);
|
2006-05-31 03:27:46 -06:00
|
|
|
extern int sata_phy_debounce(struct ata_port *ap, const unsigned long *param);
|
|
|
|
extern int sata_phy_resume(struct ata_port *ap, const unsigned long *param);
|
2006-05-31 03:27:48 -06:00
|
|
|
extern int ata_std_prereset(struct ata_port *ap);
|
2006-04-11 07:16:45 -06:00
|
|
|
extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes);
|
2006-11-01 01:59:53 -07:00
|
|
|
extern int sata_port_hardreset(struct ata_port *ap,
|
|
|
|
const unsigned long *timing);
|
2006-04-11 07:16:45 -06:00
|
|
|
extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class);
|
2006-01-24 01:05:22 -07:00
|
|
|
extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_port_disable(struct ata_port *);
|
|
|
|
extern void ata_std_ports(struct ata_ioports *ioaddr);
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
|
|
|
|
unsigned int n_ports);
|
|
|
|
extern void ata_pci_remove_one (struct pci_dev *pdev);
|
2006-07-26 01:58:33 -06:00
|
|
|
extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
|
2006-07-03 01:07:27 -06:00
|
|
|
extern void ata_pci_device_do_resume(struct pci_dev *pdev);
|
2006-07-26 01:58:33 -06:00
|
|
|
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
|
2006-01-06 01:28:07 -07:00
|
|
|
extern int ata_pci_device_resume(struct pci_dev *pdev);
|
2006-03-21 19:29:21 -07:00
|
|
|
extern int ata_pci_clear_simplex(struct pci_dev *pdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* CONFIG_PCI */
|
2005-10-22 12:27:05 -06:00
|
|
|
extern int ata_device_add(const struct ata_probe_ent *ent);
|
2006-05-31 03:28:13 -06:00
|
|
|
extern void ata_port_detach(struct ata_port *ap);
|
2006-08-24 01:19:22 -06:00
|
|
|
extern void ata_host_init(struct ata_host *, struct device *,
|
|
|
|
unsigned long, const struct ata_port_operations *);
|
|
|
|
extern void ata_host_remove(struct ata_host *host);
|
2005-11-06 22:59:37 -07:00
|
|
|
extern int ata_scsi_detect(struct scsi_host_template *sht);
|
2005-04-16 16:20:36 -06:00
|
|
|
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_scsi_release(struct Scsi_Host *host);
|
2006-08-07 13:27:31 -06:00
|
|
|
extern void ata_sas_port_destroy(struct ata_port *);
|
2006-08-24 01:19:22 -06:00
|
|
|
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
|
2006-08-07 13:27:31 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
|
2006-05-15 05:57:46 -06:00
|
|
|
extern int sata_scr_valid(struct ata_port *ap);
|
|
|
|
extern int sata_scr_read(struct ata_port *ap, int reg, u32 *val);
|
|
|
|
extern int sata_scr_write(struct ata_port *ap, int reg, u32 val);
|
|
|
|
extern int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val);
|
|
|
|
extern int ata_port_online(struct ata_port *ap);
|
|
|
|
extern int ata_port_offline(struct ata_port *ap);
|
2006-01-06 01:28:07 -07:00
|
|
|
extern int ata_scsi_device_resume(struct scsi_device *);
|
2006-07-26 01:58:33 -06:00
|
|
|
extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t mesg);
|
2006-08-24 01:19:22 -06:00
|
|
|
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
|
|
|
|
extern void ata_host_resume(struct ata_host *host);
|
2005-10-05 00:58:32 -06:00
|
|
|
extern int ata_ratelimit(void);
|
2006-10-09 03:32:15 -06:00
|
|
|
extern int ata_busy_sleep(struct ata_port *ap,
|
|
|
|
unsigned long timeout_pat, unsigned long timeout);
|
2006-11-22 07:55:48 -07:00
|
|
|
extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
|
2006-03-04 23:29:09 -07:00
|
|
|
void *data, unsigned long delay);
|
2006-04-11 07:22:29 -06:00
|
|
|
extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
|
|
|
|
unsigned long interval_msec,
|
|
|
|
unsigned long timeout_msec);
|
2005-10-05 00:58:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Default driver ops implementations
|
|
|
|
*/
|
2005-10-22 12:27:05 -06:00
|
|
|
extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
|
2005-10-22 12:27:05 -06:00
|
|
|
extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
|
|
|
|
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
|
|
|
|
extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
|
|
|
|
extern u8 ata_check_status(struct ata_port *ap);
|
|
|
|
extern u8 ata_altstatus(struct ata_port *ap);
|
2005-10-22 12:27:05 -06:00
|
|
|
extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int ata_port_start (struct ata_port *ap);
|
|
|
|
extern void ata_port_stop (struct ata_port *ap);
|
2006-08-24 01:19:22 -06:00
|
|
|
extern void ata_host_stop (struct ata_host *host);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
extern irqreturn_t ata_interrupt (int irq, void *dev_instance);
|
2006-05-22 09:59:59 -06:00
|
|
|
extern void ata_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
|
|
|
|
unsigned int buflen, int write_data);
|
|
|
|
extern void ata_pio_data_xfer(struct ata_device *adev, unsigned char *buf,
|
|
|
|
unsigned int buflen, int write_data);
|
2006-05-24 07:14:41 -06:00
|
|
|
extern void ata_pio_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
|
|
|
|
unsigned int buflen, int write_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_qc_prep(struct ata_queued_cmd *qc);
|
2006-03-17 16:04:03 -07:00
|
|
|
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
|
2006-01-22 21:09:36 -07:00
|
|
|
extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
|
|
|
|
unsigned int buflen);
|
|
|
|
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
|
|
|
|
unsigned int n_elem);
|
2005-10-22 12:27:05 -06:00
|
|
|
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
|
2006-02-12 18:02:46 -07:00
|
|
|
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);
|
2006-10-27 20:08:46 -06:00
|
|
|
extern unsigned long ata_device_blacklisted(const struct ata_device *dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
|
|
|
|
extern void ata_bmdma_start (struct ata_queued_cmd *qc);
|
2005-08-26 09:03:19 -06:00
|
|
|
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern u8 ata_bmdma_status(struct ata_port *ap);
|
|
|
|
extern void ata_bmdma_irq_clear(struct ata_port *ap);
|
2006-05-15 05:58:24 -06:00
|
|
|
extern void ata_bmdma_freeze(struct ata_port *ap);
|
|
|
|
extern void ata_bmdma_thaw(struct ata_port *ap);
|
2006-05-31 03:27:48 -06:00
|
|
|
extern void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
|
2006-05-15 05:58:24 -06:00
|
|
|
ata_reset_fn_t softreset,
|
|
|
|
ata_reset_fn_t hardreset,
|
|
|
|
ata_postreset_fn_t postreset);
|
|
|
|
extern void ata_bmdma_error_handler(struct ata_port *ap);
|
|
|
|
extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
|
2006-05-31 03:27:52 -06:00
|
|
|
extern int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
|
|
|
|
u8 status, int in_wq);
|
2006-05-15 05:58:05 -06:00
|
|
|
extern void ata_qc_complete(struct ata_queued_cmd *qc);
|
2006-05-15 06:03:43 -06:00
|
|
|
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
|
|
|
|
void (*finish_qc)(struct ata_queued_cmd *));
|
2006-05-15 05:57:53 -06:00
|
|
|
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
2006-05-31 03:28:07 -06:00
|
|
|
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
|
2006-05-15 06:03:48 -06:00
|
|
|
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
|
|
|
|
int queue_depth);
|
2006-05-15 05:57:53 -06:00
|
|
|
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-21 17:01:32 -06:00
|
|
|
/*
|
|
|
|
* Timing helpers
|
|
|
|
*/
|
2006-01-09 10:18:14 -07:00
|
|
|
|
|
|
|
extern unsigned int ata_pio_need_iordy(const struct ata_device *);
|
2005-10-21 17:01:32 -06:00
|
|
|
extern int ata_timing_compute(struct ata_device *, unsigned short,
|
|
|
|
struct ata_timing *, int, int);
|
|
|
|
extern void ata_timing_merge(const struct ata_timing *,
|
|
|
|
const struct ata_timing *, struct ata_timing *,
|
|
|
|
unsigned int);
|
|
|
|
|
|
|
|
enum {
|
|
|
|
ATA_TIMING_SETUP = (1 << 0),
|
|
|
|
ATA_TIMING_ACT8B = (1 << 1),
|
|
|
|
ATA_TIMING_REC8B = (1 << 2),
|
|
|
|
ATA_TIMING_CYC8B = (1 << 3),
|
|
|
|
ATA_TIMING_8BIT = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
|
|
|
|
ATA_TIMING_CYC8B,
|
|
|
|
ATA_TIMING_ACTIVE = (1 << 4),
|
|
|
|
ATA_TIMING_RECOVER = (1 << 5),
|
|
|
|
ATA_TIMING_CYCLE = (1 << 6),
|
|
|
|
ATA_TIMING_UDMA = (1 << 7),
|
|
|
|
ATA_TIMING_ALL = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
|
|
|
|
ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
|
|
|
|
ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
|
|
|
|
ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
struct pci_bits {
|
|
|
|
unsigned int reg; /* PCI config register to read */
|
|
|
|
unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
|
|
|
|
unsigned long mask;
|
|
|
|
unsigned long val;
|
|
|
|
};
|
|
|
|
|
2006-08-24 01:19:22 -06:00
|
|
|
extern void ata_pci_host_stop (struct ata_host *host);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern struct ata_probe_ent *
|
2005-10-04 06:09:19 -06:00
|
|
|
ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask);
|
2005-10-22 12:27:05 -06:00
|
|
|
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
|
2006-03-21 19:29:21 -07:00
|
|
|
extern unsigned long ata_pci_default_filter(const struct ata_port *, struct ata_device *, unsigned long);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2006-04-02 03:51:53 -06:00
|
|
|
/*
|
|
|
|
* EH
|
|
|
|
*/
|
|
|
|
extern void ata_eng_timeout(struct ata_port *ap);
|
2006-05-15 05:58:07 -06:00
|
|
|
|
|
|
|
extern void ata_port_schedule_eh(struct ata_port *ap);
|
|
|
|
extern int ata_port_abort(struct ata_port *ap);
|
2006-05-15 05:58:09 -06:00
|
|
|
extern int ata_port_freeze(struct ata_port *ap);
|
|
|
|
|
|
|
|
extern void ata_eh_freeze_port(struct ata_port *ap);
|
|
|
|
extern void ata_eh_thaw_port(struct ata_port *ap);
|
2006-05-15 05:58:07 -06:00
|
|
|
|
2006-04-02 03:51:53 -06:00
|
|
|
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
|
|
|
|
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
|
|
|
|
|
2006-05-31 03:27:48 -06:00
|
|
|
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);
|
2006-05-15 05:58:22 -06:00
|
|
|
|
2006-05-15 05:57:55 -06:00
|
|
|
/*
|
|
|
|
* printk helpers
|
|
|
|
*/
|
|
|
|
#define ata_port_printk(ap, lv, fmt, args...) \
|
|
|
|
printk(lv"ata%u: "fmt, (ap)->id , ##args)
|
|
|
|
|
|
|
|
#define ata_dev_printk(dev, lv, fmt, args...) \
|
|
|
|
printk(lv"ata%u.%02u: "fmt, (dev)->ap->id, (dev)->devno , ##args)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-15 05:58:21 -06:00
|
|
|
/*
|
|
|
|
* ata_eh_info helpers
|
|
|
|
*/
|
|
|
|
#define ata_ehi_push_desc(ehi, fmt, args...) do { \
|
|
|
|
(ehi)->desc_len += scnprintf((ehi)->desc + (ehi)->desc_len, \
|
|
|
|
ATA_EH_DESC_LEN - (ehi)->desc_len, \
|
|
|
|
fmt , ##args); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define ata_ehi_clear_desc(ehi) do { \
|
|
|
|
(ehi)->desc[0] = '\0'; \
|
|
|
|
(ehi)->desc_len = 0; \
|
|
|
|
} while (0)
|
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
static inline void __ata_ehi_hotplugged(struct ata_eh_info *ehi)
|
2006-05-31 03:28:03 -06:00
|
|
|
{
|
|
|
|
if (ehi->flags & ATA_EHI_HOTPLUGGED)
|
|
|
|
return;
|
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
ehi->flags |= ATA_EHI_HOTPLUGGED | ATA_EHI_RESUME_LINK;
|
2006-05-31 03:28:03 -06:00
|
|
|
ehi->hotplug_timestamp = jiffies;
|
|
|
|
|
|
|
|
ehi->action |= ATA_EH_SOFTRESET;
|
|
|
|
ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
|
|
|
|
}
|
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
|
|
|
|
{
|
|
|
|
__ata_ehi_hotplugged(ehi);
|
|
|
|
ehi->err_mask |= AC_ERR_ATA_BUS;
|
|
|
|
}
|
|
|
|
|
2006-05-15 05:57:55 -06:00
|
|
|
/*
|
|
|
|
* qc helpers
|
|
|
|
*/
|
2005-10-18 20:14:54 -06:00
|
|
|
static inline int
|
|
|
|
ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
if (sg == &qc->pad_sgent)
|
|
|
|
return 1;
|
|
|
|
if (qc->pad_len)
|
|
|
|
return 0;
|
|
|
|
if (((sg - qc->__sg) + 1) == qc->n_elem)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-02-20 07:48:38 -07:00
|
|
|
static inline struct scatterlist *
|
|
|
|
ata_qc_first_sg(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
if (qc->n_elem)
|
|
|
|
return qc->__sg;
|
|
|
|
if (qc->pad_len)
|
|
|
|
return &qc->pad_sgent;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-10-05 05:13:30 -06:00
|
|
|
static inline struct scatterlist *
|
|
|
|
ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
if (sg == &qc->pad_sgent)
|
|
|
|
return NULL;
|
|
|
|
if (++sg - qc->__sg < qc->n_elem)
|
|
|
|
return sg;
|
2006-02-20 07:48:38 -07:00
|
|
|
if (qc->pad_len)
|
|
|
|
return &qc->pad_sgent;
|
|
|
|
return NULL;
|
2005-10-05 05:13:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define ata_for_each_sg(sg, qc) \
|
2006-02-20 07:48:38 -07:00
|
|
|
for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
|
2005-10-05 05:13:30 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline unsigned int ata_tag_valid(unsigned int tag)
|
|
|
|
{
|
|
|
|
return (tag < ATA_MAX_QUEUE) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2006-05-15 05:58:02 -06:00
|
|
|
static inline unsigned int ata_tag_internal(unsigned int tag)
|
|
|
|
{
|
|
|
|
return tag == ATA_MAX_QUEUE - 1;
|
|
|
|
}
|
|
|
|
|
2006-06-24 05:30:19 -06:00
|
|
|
/*
|
|
|
|
* device helpers
|
|
|
|
*/
|
2006-03-31 09:38:18 -07:00
|
|
|
static inline unsigned int ata_class_enabled(unsigned int class)
|
2006-02-28 09:25:38 -07:00
|
|
|
{
|
|
|
|
return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
|
|
|
|
}
|
|
|
|
|
2006-03-31 09:38:18 -07:00
|
|
|
static inline unsigned int ata_class_disabled(unsigned int class)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-03-31 09:38:18 -07:00
|
|
|
return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP;
|
|
|
|
}
|
|
|
|
|
2006-04-02 01:54:46 -07:00
|
|
|
static inline unsigned int ata_class_absent(unsigned int class)
|
|
|
|
{
|
|
|
|
return !ata_class_enabled(class) && !ata_class_disabled(class);
|
|
|
|
}
|
|
|
|
|
2006-03-31 09:38:18 -07:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-04-02 01:54:46 -07:00
|
|
|
static inline unsigned int ata_dev_absent(const struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return ata_class_absent(dev->class);
|
|
|
|
}
|
|
|
|
|
2006-07-03 01:07:26 -06:00
|
|
|
static inline unsigned int ata_dev_ready(const struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return ata_dev_enabled(dev) && !(dev->flags & ATA_DFLAG_SUSPENDED);
|
|
|
|
}
|
|
|
|
|
2006-06-24 05:30:19 -06:00
|
|
|
/*
|
|
|
|
* port helpers
|
|
|
|
*/
|
|
|
|
static inline int ata_port_max_devices(const struct ata_port *ap)
|
|
|
|
{
|
|
|
|
if (ap->flags & ATA_FLAG_SLAVE_POSS)
|
|
|
|
return 2;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline u8 ata_chk_status(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return ap->ops->check_status(ap);
|
|
|
|
}
|
|
|
|
|
2005-06-02 16:17:13 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ata_pause - Flush writes and pause 400 nanoseconds.
|
|
|
|
* @ap: Port to wait for.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline void ata_pause(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
ata_altstatus(ap);
|
|
|
|
ndelay(400);
|
|
|
|
}
|
|
|
|
|
2005-06-02 16:17:13 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ata_busy_wait - Wait for a port status register
|
|
|
|
* @ap: Port to wait for.
|
|
|
|
*
|
|
|
|
* Waits up to max*10 microseconds for the selected bits in the port's
|
|
|
|
* status register to be cleared.
|
|
|
|
* Returns final value of status register.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
|
|
|
|
unsigned int max)
|
|
|
|
{
|
|
|
|
u8 status;
|
|
|
|
|
|
|
|
do {
|
|
|
|
udelay(10);
|
|
|
|
status = ata_chk_status(ap);
|
|
|
|
max--;
|
2006-10-09 03:32:15 -06:00
|
|
|
} while (status != 0xff && (status & bits) && (max > 0));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-06-02 16:17:13 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline u8 ata_wait_idle(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
|
|
|
|
|
2006-10-09 03:32:15 -06:00
|
|
|
if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long l = ap->ioaddr.status_addr;
|
2006-01-17 17:34:42 -07:00
|
|
|
if (ata_msg_warn(ap))
|
|
|
|
printk(KERN_WARNING "ATA: abnormal status 0x%X on port 0x%lX\n",
|
|
|
|
status, l);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
qc->tf.ctl |= ATA_NIEN;
|
|
|
|
}
|
|
|
|
|
2006-05-15 05:58:03 -06:00
|
|
|
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
|
|
|
|
unsigned int tag)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (likely(ata_tag_valid(tag)))
|
|
|
|
return &ap->qcmd[tag];
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-05-15 05:58:03 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-05-15 05:57:53 -06:00
|
|
|
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
memset(tf, 0, sizeof(*tf));
|
|
|
|
|
2006-05-15 05:57:53 -06:00
|
|
|
tf->ctl = dev->ap->ctl;
|
|
|
|
if (dev->devno == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
tf->device = ATA_DEVICE_OBS;
|
|
|
|
else
|
|
|
|
tf->device = ATA_DEVICE_OBS | ATA_DEV1;
|
|
|
|
}
|
|
|
|
|
2005-11-14 12:14:16 -07:00
|
|
|
static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
|
|
|
|
{
|
2007-01-16 19:34:02 -07:00
|
|
|
qc->dma_dir = DMA_NONE;
|
2005-11-14 12:14:16 -07:00
|
|
|
qc->__sg = NULL;
|
|
|
|
qc->flags = 0;
|
|
|
|
qc->cursect = qc->cursg = qc->cursg_ofs = 0;
|
|
|
|
qc->nsect = 0;
|
|
|
|
qc->nbytes = qc->curbytes = 0;
|
2007-01-17 11:32:12 -07:00
|
|
|
qc->n_elem = 0;
|
2005-12-05 00:38:02 -07:00
|
|
|
qc->err_mask = 0;
|
2007-01-17 11:32:28 -07:00
|
|
|
qc->pad_len = 0;
|
2005-11-14 12:14:16 -07:00
|
|
|
|
2006-05-15 05:57:53 -06:00
|
|
|
ata_tf_init(qc->dev, &qc->tf);
|
2006-05-15 05:57:40 -06:00
|
|
|
|
|
|
|
/* init result_tf such that it indicates normal completion */
|
|
|
|
qc->result_tf.command = ATA_DRDY;
|
|
|
|
qc->result_tf.feature = 0;
|
2005-11-14 12:14:16 -07:00
|
|
|
}
|
|
|
|
|
2005-06-02 16:17:13 -06:00
|
|
|
/**
|
|
|
|
* ata_irq_ack - Acknowledge a device interrupt.
|
|
|
|
* @ap: Port on which interrupts are enabled.
|
|
|
|
*
|
|
|
|
* Wait up to 10 ms for legacy IDE device to become idle (BUSY
|
|
|
|
* or BUSY+DRQ clear). Obtain dma status and port status from
|
|
|
|
* device. Clear the interrupt. Return port status.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
|
|
|
|
{
|
|
|
|
unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
|
|
|
|
u8 host_stat, post_stat, status;
|
|
|
|
|
|
|
|
status = ata_busy_wait(ap, bits, 1000);
|
|
|
|
if (status & bits)
|
2006-01-17 17:34:42 -07:00
|
|
|
if (ata_msg_err(ap))
|
|
|
|
printk(KERN_ERR "abnormal status 0x%X\n", status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* get controller status; clear intr, err bits */
|
|
|
|
if (ap->flags & ATA_FLAG_MMIO) {
|
|
|
|
void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
|
|
|
|
host_stat = readb(mmio + ATA_DMA_STATUS);
|
|
|
|
writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
|
|
|
|
mmio + ATA_DMA_STATUS);
|
|
|
|
|
|
|
|
post_stat = readb(mmio + ATA_DMA_STATUS);
|
|
|
|
} else {
|
|
|
|
host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
|
|
|
|
outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
|
|
|
|
ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
|
|
|
|
|
|
|
|
post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
|
|
|
|
}
|
|
|
|
|
2006-01-17 17:34:42 -07:00
|
|
|
if (ata_msg_intr(ap))
|
|
|
|
printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
|
|
|
|
__FUNCTION__,
|
|
|
|
host_stat, post_stat, status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-10-22 12:27:05 -06:00
|
|
|
static inline int ata_try_flush_cache(const struct ata_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return ata_id_wcache_enabled(dev->id) ||
|
|
|
|
ata_id_has_flush(dev->id) ||
|
|
|
|
ata_id_has_flush_ext(dev->id);
|
|
|
|
}
|
|
|
|
|
2005-10-30 02:44:42 -07:00
|
|
|
static inline unsigned int ac_err_mask(u8 status)
|
|
|
|
{
|
2006-05-18 21:43:04 -06:00
|
|
|
if (status & (ATA_BUSY | ATA_DRQ))
|
2006-01-22 21:09:36 -07:00
|
|
|
return AC_ERR_HSM;
|
2005-10-30 02:44:42 -07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-11-04 20:08:00 -07:00
|
|
|
static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
|
|
|
|
{
|
|
|
|
ap->pad_dma = 0;
|
|
|
|
ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
|
|
|
|
&ap->pad_dma, GFP_KERNEL);
|
|
|
|
return (ap->pad == NULL) ? -ENOMEM : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
|
|
|
|
{
|
|
|
|
dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
|
|
|
|
}
|
|
|
|
|
2006-04-11 11:12:34 -06:00
|
|
|
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
|
|
|
|
{
|
|
|
|
return (struct ata_port *) &host->hostdata[0];
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* __LINUX_LIBATA_H__ */
|