#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
+#include <linux/completion.h>
#include <linux/suspend.h>
+#include <linux/workqueue.h>
#include <scsi/scsi.h>
#include "scsi.h"
-#include "hosts.h"
+#include "scsi_priv.h"
+#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <asm/io.h>
#include <asm/semaphore.h>
+#include <asm/byteorder.h>
#include "libata.h"
-static void atapi_cdb_send(struct ata_port *ap);
static unsigned int ata_busy_sleep (struct ata_port *ap,
unsigned long tmout_pat,
unsigned long tmout);
-static void __ata_dev_select (struct ata_port *ap, unsigned int device);
-#if 0 /* to be used eventually */
-static void ata_qc_push (struct ata_queued_cmd *qc, unsigned int append);
-#endif
-static void ata_dma_complete(struct ata_port *ap, u8 host_stat,
- unsigned int done_late);
-static void ata_host_set_pio(struct ata_port *ap);
-static void ata_host_set_udma(struct ata_port *ap);
-static void ata_dev_set_pio(struct ata_port *ap, unsigned int device);
-static void ata_dev_set_udma(struct ata_port *ap, unsigned int device);
static void ata_set_mode(struct ata_port *ap);
+static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
+static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
+static int fgb(u32 bitmap);
+static int ata_choose_xfer_mode(struct ata_port *ap,
+ u8 *xfer_mode_out,
+ unsigned int *xfer_shift_out);
+static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
+static void __ata_qc_complete(struct ata_queued_cmd *qc);
static unsigned int ata_unique_id = 1;
+static struct workqueue_struct *ata_wq;
MODULE_AUTHOR("Jeff Garzik");
MODULE_DESCRIPTION("Library module for ATA devices");
MODULE_LICENSE("GPL");
-
-static const char * thr_state_name[] = {
- "THR_UNKNOWN",
- "THR_PORT_RESET",
- "THR_AWAIT_DEATH",
- "THR_PROBE_FAILED",
- "THR_IDLE",
- "THR_PROBE_SUCCESS",
- "THR_PROBE_START",
- "THR_PIO_POLL",
- "THR_PIO_TMOUT",
- "THR_PIO",
- "THR_PIO_LAST",
- "THR_PIO_LAST_POLL",
- "THR_PIO_ERR",
- "THR_PACKET",
-};
-
-/**
- * ata_thr_state_name - convert thread state enum to string
- * @thr_state: thread state to be converted to string
- *
- * Converts the specified thread state id to a constant C string.
- *
- * LOCKING:
- * None.
- *
- * RETURNS:
- * The THR_xxx-prefixed string naming the specified thread
- * state id, or the string "<invalid THR_xxx state>".
- */
-
-static const char *ata_thr_state_name(unsigned int thr_state)
-{
- if (thr_state < ARRAY_SIZE(thr_state_name))
- return thr_state_name[thr_state];
- return "<invalid THR_xxx state>";
-}
-
-/**
- * msleep - sleep for a number of milliseconds
- * @msecs: number of milliseconds to sleep
- *
- * Issues schedule_timeout call for the specified number
- * of milliseconds.
- *
- * LOCKING:
- * None.
- */
-
-static void msleep(unsigned long msecs)
-{
- set_current_state(TASK_UNINTERRUPTIBLE);
- schedule_timeout(msecs_to_jiffies(msecs) + 1);
-}
+MODULE_VERSION(DRV_VERSION);
/**
- * ata_tf_load_pio - send taskfile registers to host controller
- * @ioaddr: set of IO ports to which output is sent
+ * ata_tf_load - send taskfile registers to host controller
+ * @ap: Port to which output is sent
* @tf: ATA taskfile register set
*
- * Outputs ATA taskfile to standard ATA host controller using PIO.
+ * Outputs ATA taskfile to standard ATA host controller.
*
* LOCKING:
* Inherited from caller.
*/
-void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
{
struct ata_ioports *ioaddr = &ap->ioaddr;
unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
/**
* ata_tf_load_mmio - send taskfile registers to host controller
- * @ioaddr: set of IO ports to which output is sent
+ * @ap: Port to which output is sent
* @tf: ATA taskfile register set
*
* Outputs ATA taskfile to standard ATA host controller using MMIO.
* Inherited from caller.
*/
-void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
{
struct ata_ioports *ioaddr = &ap->ioaddr;
unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
if (tf->ctl != ap->last_ctl) {
- writeb(tf->ctl, ap->ioaddr.ctl_addr);
+ writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
ap->last_ctl = tf->ctl;
ata_wait_idle(ap);
}
if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
- writeb(tf->hob_feature, (void *) ioaddr->feature_addr);
- writeb(tf->hob_nsect, (void *) ioaddr->nsect_addr);
- writeb(tf->hob_lbal, (void *) ioaddr->lbal_addr);
- writeb(tf->hob_lbam, (void *) ioaddr->lbam_addr);
- writeb(tf->hob_lbah, (void *) ioaddr->lbah_addr);
+ writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
+ writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
+ writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
+ writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
+ writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
tf->hob_feature,
tf->hob_nsect,
}
if (is_addr) {
- writeb(tf->feature, (void *) ioaddr->feature_addr);
- writeb(tf->nsect, (void *) ioaddr->nsect_addr);
- writeb(tf->lbal, (void *) ioaddr->lbal_addr);
- writeb(tf->lbam, (void *) ioaddr->lbam_addr);
- writeb(tf->lbah, (void *) ioaddr->lbah_addr);
+ writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
+ writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
+ writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
+ writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
+ writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
tf->feature,
tf->nsect,
}
if (tf->flags & ATA_TFLAG_DEVICE) {
- writeb(tf->device, (void *) ioaddr->device_addr);
+ writeb(tf->device, (void __iomem *) ioaddr->device_addr);
VPRINTK("device 0x%X\n", tf->device);
}
ata_wait_idle(ap);
}
+void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
+{
+ if (ap->flags & ATA_FLAG_MMIO)
+ ata_tf_load_mmio(ap, tf);
+ else
+ ata_tf_load_pio(ap, tf);
+}
+
/**
- * ata_exec_command_pio - issue ATA command to host controller
+ * ata_exec_command - issue ATA command to host controller
* @ap: port to which command is being issued
* @tf: ATA taskfile register set
*
- * Issues PIO write to ATA command register, with proper
+ * Issues PIO/MMIO write to ATA command register, with proper
* synchronization with interrupt handler / other threads.
*
* LOCKING:
* spin_lock_irqsave(host_set lock)
*/
-void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
{
DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
* spin_lock_irqsave(host_set lock)
*/
-void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
{
DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
- writeb(tf->command, (void *) ap->ioaddr.command_addr);
+ writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
ata_pause(ap);
}
+void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
+{
+ if (ap->flags & ATA_FLAG_MMIO)
+ ata_exec_command_mmio(ap, tf);
+ else
+ ata_exec_command_pio(ap, tf);
+}
+
/**
* ata_exec - issue ATA command to host controller
* @ap: port to which command is being issued
* @tf: ATA taskfile register set
*
- * Issues PIO write to ATA command register, with proper
+ * Issues PIO/MMIO write to ATA command register, with proper
* synchronization with interrupt handler / other threads.
*
* LOCKING:
* @tf: ATA taskfile register set
*
* Issues ATA taskfile register set to ATA host controller,
- * via PIO, with proper synchronization with interrupt handler and
+ * with proper synchronization with interrupt handler and
* other threads.
*
* LOCKING:
static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
{
- init_MUTEX_LOCKED(&ap->sem);
-
ap->ops->tf_load(ap, tf);
ata_exec(ap, tf);
* @tf: ATA taskfile register set
*
* Issues ATA taskfile register set to ATA host controller,
- * via PIO, with proper synchronization with interrupt handler and
+ * with proper synchronization with interrupt handler and
* other threads.
*
* LOCKING:
void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
{
- init_MUTEX_LOCKED(&ap->sem);
-
ap->ops->tf_load(ap, tf);
ap->ops->exec_command(ap, tf);
}
/**
- * ata_tf_read_pio - input device's ATA taskfile shadow registers
- * @ioaddr: set of IO ports from which input is read
+ * ata_tf_read - input device's ATA taskfile shadow registers
+ * @ap: Port from which input is read
* @tf: ATA taskfile register set for storing input
*
* Reads ATA taskfile registers for currently-selected device
- * into @tf via PIO.
+ * into @tf.
*
* LOCKING:
* Inherited from caller.
*/
-void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
{
struct ata_ioports *ioaddr = &ap->ioaddr;
/**
* ata_tf_read_mmio - input device's ATA taskfile shadow registers
- * @ioaddr: set of IO ports from which input is read
+ * @ap: Port from which input is read
* @tf: ATA taskfile register set for storing input
*
* Reads ATA taskfile registers for currently-selected device
* Inherited from caller.
*/
-void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
{
struct ata_ioports *ioaddr = &ap->ioaddr;
- tf->nsect = readb((void *)ioaddr->nsect_addr);
- tf->lbal = readb((void *)ioaddr->lbal_addr);
- tf->lbam = readb((void *)ioaddr->lbam_addr);
- tf->lbah = readb((void *)ioaddr->lbah_addr);
- tf->device = readb((void *)ioaddr->device_addr);
+ tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
+ tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
+ tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
+ tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
+ tf->device = readb((void __iomem *)ioaddr->device_addr);
if (tf->flags & ATA_TFLAG_LBA48) {
- writeb(tf->ctl | ATA_HOB, ap->ioaddr.ctl_addr);
- tf->hob_feature = readb((void *)ioaddr->error_addr);
- tf->hob_nsect = readb((void *)ioaddr->nsect_addr);
- tf->hob_lbal = readb((void *)ioaddr->lbal_addr);
- tf->hob_lbam = readb((void *)ioaddr->lbam_addr);
- tf->hob_lbah = readb((void *)ioaddr->lbah_addr);
+ writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
+ tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
+ tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
+ tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
+ tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
+ tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
}
}
+void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+ if (ap->flags & ATA_FLAG_MMIO)
+ ata_tf_read_mmio(ap, tf);
+ else
+ ata_tf_read_pio(ap, tf);
+}
+
/**
- * ata_check_status_pio - Read device status reg & clear interrupt
+ * ata_check_status - Read device status reg & clear interrupt
* @ap: port where the device is
*
* Reads ATA taskfile status register for currently-selected device
- * via PIO and return it's value. This also clears pending interrupts
+ * and return it's value. This also clears pending interrupts
* from this device
*
* LOCKING:
* Inherited from caller.
*/
-u8 ata_check_status_pio(struct ata_port *ap)
+static u8 ata_check_status_pio(struct ata_port *ap)
{
return inb(ap->ioaddr.status_addr);
}
* LOCKING:
* Inherited from caller.
*/
-u8 ata_check_status_mmio(struct ata_port *ap)
+static u8 ata_check_status_mmio(struct ata_port *ap)
+{
+ return readb((void __iomem *) ap->ioaddr.status_addr);
+}
+
+u8 ata_check_status(struct ata_port *ap)
+{
+ if (ap->flags & ATA_FLAG_MMIO)
+ return ata_check_status_mmio(ap);
+ return ata_check_status_pio(ap);
+}
+
+/**
+ * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
+ * @tf: Taskfile to convert
+ * @fis: Buffer into which data will output
+ * @pmp: Port multiplier port
+ *
+ * Converts a standard ATA taskfile to a Serial ATA
+ * FIS structure (Register - Host to Device).
+ *
+ * LOCKING:
+ * Inherited from caller.
+ */
+
+void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
+{
+ fis[0] = 0x27; /* Register - Host to Device FIS */
+ fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
+ bit 7 indicates Command FIS */
+ fis[2] = tf->command;
+ fis[3] = tf->feature;
+
+ fis[4] = tf->lbal;
+ fis[5] = tf->lbam;
+ fis[6] = tf->lbah;
+ fis[7] = tf->device;
+
+ fis[8] = tf->hob_lbal;
+ fis[9] = tf->hob_lbam;
+ fis[10] = tf->hob_lbah;
+ fis[11] = tf->hob_feature;
+
+ fis[12] = tf->nsect;
+ fis[13] = tf->hob_nsect;
+ fis[14] = 0;
+ fis[15] = tf->ctl;
+
+ fis[16] = 0;
+ fis[17] = 0;
+ fis[18] = 0;
+ fis[19] = 0;
+}
+
+/**
+ * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
+ * @fis: Buffer from which data will be input
+ * @tf: Taskfile to output
+ *
+ * Converts a standard ATA taskfile to a Serial ATA
+ * FIS structure (Register - Host to Device).
+ *
+ * LOCKING:
+ * Inherited from caller.
+ */
+
+void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
{
- return readb((void *) ap->ioaddr.status_addr);
+ tf->command = fis[2]; /* status */
+ tf->feature = fis[3]; /* error */
+
+ tf->lbal = fis[4];
+ tf->lbam = fis[5];
+ tf->lbah = fis[6];
+ tf->device = fis[7];
+
+ tf->hob_lbal = fis[8];
+ tf->hob_lbam = fis[9];
+ tf->hob_lbah = fis[10];
+
+ tf->nsect = fis[12];
+ tf->hob_nsect = fis[13];
}
/**
dev->write_cmd = (cmd >> 8) & 0xff;
}
-static const char * udma_str[] = {
+static const char * xfer_mode_str[] = {
"UDMA/16",
"UDMA/25",
"UDMA/33",
"UDMA/100",
"UDMA/133",
"UDMA7",
+ "MWDMA0",
+ "MWDMA1",
+ "MWDMA2",
+ "PIO0",
+ "PIO1",
+ "PIO2",
+ "PIO3",
+ "PIO4",
};
/**
* ata_udma_string - convert UDMA bit offset to string
- * @udma_mask: mask of bits supported; only highest bit counts.
+ * @mask: mask of bits supported; only highest bit counts.
*
* Determine string which represents the highest speed
* (highest bit in @udma_mask).
* @udma_mask, or the constant C string "<n/a>".
*/
-static const char *ata_udma_string(unsigned int udma_mask)
+static const char *ata_mode_string(unsigned int mask)
{
int i;
- for (i = 7; i >= 0; i--) {
- if (udma_mask & (1 << i))
- return udma_str[i];
- }
+ for (i = 7; i >= 0; i--)
+ if (mask & (1 << i))
+ goto out;
+ for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
+ if (mask & (1 << i))
+ goto out;
+ for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
+ if (mask & (1 << i))
+ goto out;
return "<n/a>";
+
+out:
+ return xfer_mode_str[i];
}
/**
struct ata_ioports *ioaddr = &ap->ioaddr;
u8 nsect, lbal;
- __ata_dev_select(ap, device);
+ ap->ops->dev_select(ap, device);
outb(0x55, ioaddr->nsect_addr);
outb(0xaa, ioaddr->lbal_addr);
struct ata_ioports *ioaddr = &ap->ioaddr;
u8 nsect, lbal;
- __ata_dev_select(ap, device);
+ ap->ops->dev_select(ap, device);
- writeb(0x55, (void *) ioaddr->nsect_addr);
- writeb(0xaa, (void *) ioaddr->lbal_addr);
+ writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
+ writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
- writeb(0xaa, (void *) ioaddr->nsect_addr);
- writeb(0x55, (void *) ioaddr->lbal_addr);
+ writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
+ writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
- writeb(0x55, (void *) ioaddr->nsect_addr);
- writeb(0xaa, (void *) ioaddr->lbal_addr);
+ writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
+ writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
- nsect = readb((void *) ioaddr->nsect_addr);
- lbal = readb((void *) ioaddr->lbal_addr);
+ nsect = readb((void __iomem *) ioaddr->nsect_addr);
+ lbal = readb((void __iomem *) ioaddr->lbal_addr);
if ((nsect == 0x55) && (lbal == 0xaa))
return 1; /* we found a device */
}
/**
- * ata_dev_devchk - PATA device presence detection
+ * ata_devchk - PATA device presence detection
* @ap: ATA channel to examine
* @device: Device to examine (starting at zero)
*
* caller.
*/
-static unsigned int ata_dev_devchk(struct ata_port *ap,
+static unsigned int ata_devchk(struct ata_port *ap,
unsigned int device)
{
if (ap->flags & ATA_FLAG_MMIO)
* the event of failure.
*/
-static unsigned int ata_dev_classify(struct ata_taskfile *tf)
+unsigned int ata_dev_classify(struct ata_taskfile *tf)
{
/* Apple's open source Darwin code hints that some devices only
* put a proper signature into the LBA mid/high registers,
unsigned int class;
u8 err;
- __ata_dev_select(ap, device);
+ ap->ops->dev_select(ap, device);
memset(&tf, 0, sizeof(tf));
/**
* ata_dev_id_string - Convert IDENTIFY DEVICE page into string
- * @dev: Device whose IDENTIFY DEVICE results we will examine
+ * @id: IDENTIFY DEVICE results we will examine
* @s: string into which data is output
* @ofs: offset into identify device page
- * @len: length of string to return
+ * @len: length of string to return. must be an even number.
*
* The strings in the IDENTIFY DEVICE page are broken up into
* 16-bit chunks. Run through the string, and output each
* caller.
*/
-void ata_dev_id_string(struct ata_device *dev, unsigned char *s,
+void ata_dev_id_string(u16 *id, unsigned char *s,
unsigned int ofs, unsigned int len)
{
unsigned int c;
while (len > 0) {
- c = dev->id[ofs] >> 8;
+ c = id[ofs] >> 8;
*s = c;
s++;
- c = dev->id[ofs] & 0xff;
+ c = id[ofs] & 0xff;
*s = c;
s++;
}
}
-/**
- * ata_dev_parse_strings - Store useful IDENTIFY DEVICE page strings
- * @dev: Device whose IDENTIFY DEVICE page info we use
- *
- * We store 'vendor' and 'product' strings read from the device,
- * for later use in the SCSI simulator's INQUIRY data.
- *
- * Set these strings here, in the case of 'product', using
- * data read from the ATA IDENTIFY DEVICE page.
- *
- * LOCKING:
- * caller.
- */
-
-static void ata_dev_parse_strings(struct ata_device *dev)
+void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
{
- assert (dev->class == ATA_DEV_ATA);
- memcpy(dev->vendor, "ATA ", 8);
-
- ata_dev_id_string(dev, dev->product, ATA_ID_PROD_OFS,
- sizeof(dev->product));
}
/**
- * __ata_dev_select - Select device 0/1 on ATA bus
+ * ata_std_dev_select - Select device 0/1 on ATA bus
* @ap: ATA channel to manipulate
* @device: ATA device (numbered from zero) to select
*
* caller.
*/
-static void __ata_dev_select (struct ata_port *ap, unsigned int device)
+void ata_std_dev_select (struct ata_port *ap, unsigned int device)
{
u8 tmp;
tmp = ATA_DEVICE_OBS | ATA_DEV1;
if (ap->flags & ATA_FLAG_MMIO) {
- writeb(tmp, (void *) ap->ioaddr.device_addr);
+ writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
} else {
outb(tmp, ap->ioaddr.device_addr);
}
* make either device 0, or device 1, active on the
* ATA channel.
*
- * This is a high-level version of __ata_dev_select(),
+ * This is a high-level version of ata_std_dev_select(),
* which additionally provides the services of inserting
* the proper pauses and status polling, where needed.
*
if (wait)
ata_wait_idle(ap);
- __ata_dev_select(ap, device);
+ ap->ops->dev_select(ap, device);
if (wait) {
if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
{
struct ata_device *dev = &ap->device[device];
unsigned int i;
- u16 tmp, udma_modes;
+ u16 tmp;
+ unsigned long xfer_modes;
u8 status;
- struct ata_taskfile tf;
unsigned int using_edd;
+ DECLARE_COMPLETION(wait);
+ struct ata_queued_cmd *qc;
+ unsigned long flags;
+ int rc;
if (!ata_dev_present(dev)) {
DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
-retry:
- ata_tf_init(ap, &tf, device);
- tf.ctl |= ATA_NIEN;
- tf.protocol = ATA_PROT_PIO;
+ qc = ata_qc_new_init(ap, dev);
+ BUG_ON(qc == NULL);
+
+ ata_sg_init_one(qc, dev->id, sizeof(dev->id));
+ qc->dma_dir = DMA_FROM_DEVICE;
+ qc->tf.protocol = ATA_PROT_PIO;
+ qc->nsect = 1;
+retry:
if (dev->class == ATA_DEV_ATA) {
- tf.command = ATA_CMD_ID_ATA;
+ qc->tf.command = ATA_CMD_ID_ATA;
DPRINTK("do ATA identify\n");
} else {
- tf.command = ATA_CMD_ID_ATAPI;
+ qc->tf.command = ATA_CMD_ID_ATAPI;
DPRINTK("do ATAPI identify\n");
}
- ata_tf_to_host(ap, &tf);
+ qc->waiting = &wait;
+ qc->complete_fn = ata_qc_complete_noop;
- /* crazy ATAPI devices... */
- if (dev->class == ATA_DEV_ATAPI)
- msleep(150);
+ spin_lock_irqsave(&ap->host_set->lock, flags);
+ rc = ata_qc_issue(qc);
+ spin_unlock_irqrestore(&ap->host_set->lock, flags);
- if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT))
+ if (rc)
goto err_out;
+ else
+ wait_for_completion(&wait);
status = ata_chk_status(ap);
if (status & ATA_ERR) {
* ATA software reset (SRST, the default) does not appear
* to have this problem.
*/
- if ((using_edd) && (tf.command == ATA_CMD_ID_ATA)) {
+ if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
u8 err = ata_chk_err(ap);
if (err & ATA_ABORTED) {
dev->class = ATA_DEV_ATAPI;
+ qc->cursg = 0;
+ qc->cursg_ofs = 0;
+ qc->cursect = 0;
+ qc->nsect = 1;
goto retry;
}
}
goto err_out;
}
- /* make sure we have BSY=0, DRQ=1 */
- if ((status & ATA_DRQ) == 0) {
- printk(KERN_WARNING "ata%u: dev %u (ATA%s?) not returning id page (0x%x)\n",
- ap->id, device,
- dev->class == ATA_DEV_ATA ? "" : "PI",
- status);
- goto err_out;
- }
-
- /* read IDENTIFY [X] DEVICE page */
- if (ap->flags & ATA_FLAG_MMIO) {
- for (i = 0; i < ATA_ID_WORDS; i++)
- dev->id[i] = readw((void *)ap->ioaddr.data_addr);
- } else
- for (i = 0; i < ATA_ID_WORDS; i++)
- dev->id[i] = inw(ap->ioaddr.data_addr);
-
- /* wait for host_idle */
- status = ata_wait_idle(ap);
- if (status & (ATA_BUSY | ATA_DRQ)) {
- printk(KERN_WARNING "ata%u: dev %u (ATA%s?) error after id page (0x%x)\n",
- ap->id, device,
- dev->class == ATA_DEV_ATA ? "" : "PI",
- status);
- goto err_out;
- }
-
- ata_irq_on(ap); /* re-enable interrupts */
+ swap_buf_le16(dev->id, ATA_ID_WORDS);
/* print device capabilities */
printk(KERN_DEBUG "ata%u: dev %u cfg "
*/
/* we require LBA and DMA support (bits 8 & 9 of word 49) */
- if (!ata_id_has_dma(dev) || !ata_id_has_lba(dev)) {
+ if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
goto err_out_nosup;
}
- /* we require UDMA support */
- udma_modes =
- tmp = dev->id[ATA_ID_UDMA_MODES];
- if ((tmp & 0xff) == 0) {
- printk(KERN_DEBUG "ata%u: no udma\n", ap->id);
- goto err_out_nosup;
+ /* quick-n-dirty find max transfer mode; for printk only */
+ xfer_modes = dev->id[ATA_ID_UDMA_MODES];
+ if (!xfer_modes)
+ xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
+ if (!xfer_modes) {
+ xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
+ xfer_modes |= (0x7 << ATA_SHIFT_PIO);
}
ata_dump_id(dev);
- ata_dev_parse_strings(dev);
-
/* ATA-specific feature tests */
if (dev->class == ATA_DEV_ATA) {
- if (!ata_id_is_ata(dev)) /* sanity check */
+ if (!ata_id_is_ata(dev->id)) /* sanity check */
goto err_out_nosup;
tmp = dev->id[ATA_ID_MAJOR_VER];
goto err_out_nosup;
}
- if (ata_id_has_lba48(dev)) {
+ if (ata_id_has_lba48(dev->id)) {
dev->flags |= ATA_DFLAG_LBA48;
- dev->n_sectors = ata_id_u64(dev, 100);
+ dev->n_sectors = ata_id_u64(dev->id, 100);
} else {
- dev->n_sectors = ata_id_u32(dev, 60);
+ dev->n_sectors = ata_id_u32(dev->id, 60);
}
ap->host->max_cmd_len = 16;
/* print device info to dmesg */
- printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors%s\n",
+ printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
ap->id, device,
- ata_udma_string(udma_modes),
+ ata_mode_string(xfer_modes),
(unsigned long long)dev->n_sectors,
- dev->flags & ATA_DFLAG_LBA48 ? " (lba48)" : "");
+ dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
}
/* ATAPI-specific feature tests */
else {
- if (ata_id_is_ata(dev)) /* sanity check */
+ if (ata_id_is_ata(dev->id)) /* sanity check */
goto err_out_nosup;
- /* see if 16-byte commands supported */
- tmp = dev->id[0] & 0x3;
- if (tmp == 1)
- ap->host->max_cmd_len = 16;
+ rc = atapi_cdb_len(dev->id);
+ if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
+ printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
+ goto err_out_nosup;
+ }
+ ap->cdb_len = (unsigned int) rc;
+ ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
/* print device info to dmesg */
printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
ap->id, device,
- ata_udma_string(udma_modes));
+ ata_mode_string(xfer_modes));
}
DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
}
/**
- * ata_port_reset -
- * @ap:
+ * ata_bus_probe - Reset and probe ATA bus
+ * @ap: Bus to probe
*
* LOCKING:
+ *
+ * RETURNS:
+ * Zero on success, non-zero on error.
*/
-static void ata_port_reset(struct ata_port *ap)
+static int ata_bus_probe(struct ata_port *ap)
{
unsigned int i, found = 0;
if (ap->flags & ATA_FLAG_PORT_DISABLED)
goto err_out_disable;
- ap->thr_state = THR_PROBE_SUCCESS;
-
- return;
+ return 0;
err_out_disable:
ap->ops->port_disable(ap);
err_out:
- ap->thr_state = THR_PROBE_FAILED;
+ return -1;
}
/**
}
/**
- * sata_phy_reset -
+ * __sata_phy_reset -
* @ap:
*
* LOCKING:
*
*/
-void sata_phy_reset(struct ata_port *ap)
+void __sata_phy_reset(struct ata_port *ap)
{
u32 sstatus;
unsigned long timeout = jiffies + (HZ * 5);
return;
}
+ ap->cbl = ATA_CBL_SATA;
+}
+
+/**
+ * __sata_phy_reset -
+ * @ap:
+ *
+ * LOCKING:
+ *
+ */
+void sata_phy_reset(struct ata_port *ap)
+{
+ __sata_phy_reset(ap);
+ if (ap->flags & ATA_FLAG_PORT_DISABLED)
+ return;
ata_bus_reset(ap);
}
ap->flags |= ATA_FLAG_PORT_DISABLED;
}
+static struct {
+ unsigned int shift;
+ u8 base;
+} xfer_mode_classes[] = {
+ { ATA_SHIFT_UDMA, XFER_UDMA_0 },
+ { ATA_SHIFT_MWDMA, XFER_MW_DMA_0 },
+ { ATA_SHIFT_PIO, XFER_PIO_0 },
+};
+
+static inline u8 base_from_shift(unsigned int shift)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
+ if (xfer_mode_classes[i].shift == shift)
+ return xfer_mode_classes[i].base;
+
+ return 0xff;
+}
+
+static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
+{
+ int ofs, idx;
+ u8 base;
+
+ if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
+ return;
+
+ if (dev->xfer_shift == ATA_SHIFT_PIO)
+ dev->flags |= ATA_DFLAG_PIO;
+
+ ata_dev_set_xfermode(ap, dev);
+
+ base = base_from_shift(dev->xfer_shift);
+ ofs = dev->xfer_mode - base;
+ idx = ofs + dev->xfer_shift;
+ WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
+
+ DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
+ idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
+
+ printk(KERN_INFO "ata%u: dev %u configured for %s\n",
+ ap->id, dev->devno, xfer_mode_str[idx]);
+}
+
+static int ata_host_set_pio(struct ata_port *ap)
+{
+ unsigned int mask;
+ int x, i;
+ u8 base, xfer_mode;
+
+ mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
+ x = fgb(mask);
+ if (x < 0) {
+ printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
+ return -1;
+ }
+
+ base = base_from_shift(ATA_SHIFT_PIO);
+ xfer_mode = base + x;
+
+ DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
+ (int)base, (int)xfer_mode, mask, x);
+
+ for (i = 0; i < ATA_MAX_DEVICES; i++) {
+ struct ata_device *dev = &ap->device[i];
+ if (ata_dev_present(dev)) {
+ dev->pio_mode = xfer_mode;
+ dev->xfer_mode = xfer_mode;
+ dev->xfer_shift = ATA_SHIFT_PIO;
+ if (ap->ops->set_piomode)
+ ap->ops->set_piomode(ap, dev);
+ }
+ }
+
+ return 0;
+}
+
+static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
+ unsigned int xfer_shift)
+{
+ int i;
+
+ for (i = 0; i < ATA_MAX_DEVICES; i++) {
+ struct ata_device *dev = &ap->device[i];
+ if (ata_dev_present(dev)) {
+ dev->dma_mode = xfer_mode;
+ dev->xfer_mode = xfer_mode;
+ dev->xfer_shift = xfer_shift;
+ if (ap->ops->set_dmamode)
+ ap->ops->set_dmamode(ap, dev);
+ }
+ }
+}
+
/**
* ata_set_mode - Program timings and issue SET FEATURES - XFER
* @ap: port on which timings will be programmed
*/
static void ata_set_mode(struct ata_port *ap)
{
- unsigned int force_pio, i;
+ unsigned int i, xfer_shift;
+ u8 xfer_mode;
+ int rc;
- ata_host_set_pio(ap);
- if (ap->flags & ATA_FLAG_PORT_DISABLED)
- return;
+ /* step 1: always set host PIO timings */
+ rc = ata_host_set_pio(ap);
+ if (rc)
+ goto err_out;
- ata_host_set_udma(ap);
- if (ap->flags & ATA_FLAG_PORT_DISABLED)
- return;
+ /* step 2: choose the best data xfer mode */
+ xfer_mode = xfer_shift = 0;
+ rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
+ if (rc)
+ goto err_out;
-#ifdef ATA_FORCE_PIO
- force_pio = 1;
-#else
- force_pio = 0;
-#endif
+ /* step 3: if that xfer mode isn't PIO, set host DMA timings */
+ if (xfer_shift != ATA_SHIFT_PIO)
+ ata_host_set_dma(ap, xfer_mode, xfer_shift);
- if (force_pio) {
- ata_dev_set_pio(ap, 0);
- ata_dev_set_pio(ap, 1);
- } else {
- ata_dev_set_udma(ap, 0);
- ata_dev_set_udma(ap, 1);
- }
+ /* step 4: update devices' xfer mode */
+ ata_dev_set_mode(ap, &ap->device[0]);
+ ata_dev_set_mode(ap, &ap->device[1]);
if (ap->flags & ATA_FLAG_PORT_DISABLED)
return;
struct ata_device *dev = &ap->device[i];
ata_dev_set_protocol(dev);
}
+
+ return;
+
+err_out:
+ ata_port_disable(ap);
}
/**
unsigned int dev1 = devmask & (1 << 1);
unsigned long timeout;
- /* if device 0 was found in ata_dev_devchk, wait for its
+ /* if device 0 was found in ata_devchk, wait for its
* BSY bit to clear
*/
if (dev0)
ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
- /* if device 1 was found in ata_dev_devchk, wait for
+ /* if device 1 was found in ata_devchk, wait for
* register access, then wait for BSY to clear
*/
timeout = jiffies + ATA_TMOUT_BOOT;
while (dev1) {
u8 nsect, lbal;
- __ata_dev_select(ap, 1);
+ ap->ops->dev_select(ap, 1);
if (ap->flags & ATA_FLAG_MMIO) {
- nsect = readb((void *) ioaddr->nsect_addr);
- lbal = readb((void *) ioaddr->lbal_addr);
+ nsect = readb((void __iomem *) ioaddr->nsect_addr);
+ lbal = readb((void __iomem *) ioaddr->lbal_addr);
} else {
nsect = inb(ioaddr->nsect_addr);
lbal = inb(ioaddr->lbal_addr);
ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
/* is all this really necessary? */
- __ata_dev_select(ap, 0);
+ ap->ops->dev_select(ap, 0);
if (dev1)
- __ata_dev_select(ap, 1);
+ ap->ops->dev_select(ap, 1);
if (dev0)
- __ata_dev_select(ap, 0);
+ ap->ops->dev_select(ap, 0);
}
/**
/* software reset. causes dev0 to be selected */
if (ap->flags & ATA_FLAG_MMIO) {
- writeb(ap->ctl, ioaddr->ctl_addr);
+ writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
udelay(20); /* FIXME: flush */
- writeb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
+ writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
udelay(20); /* FIXME: flush */
- writeb(ap->ctl, ioaddr->ctl_addr);
+ writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
} else {
outb(ap->ctl, ioaddr->ctl_addr);
udelay(10);
if (ap->flags & ATA_FLAG_SATA_RESET)
dev0 = 1;
else {
- dev0 = ata_dev_devchk(ap, 0);
+ dev0 = ata_devchk(ap, 0);
if (slave_possible)
- dev1 = ata_dev_devchk(ap, 1);
+ dev1 = ata_devchk(ap, 1);
}
if (dev0)
devmask |= (1 << 1);
/* select device 0 again */
- __ata_dev_select(ap, 0);
+ ap->ops->dev_select(ap, 0);
/* issue bus reset */
if (ap->flags & ATA_FLAG_SRST)
else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
/* set up device control */
if (ap->flags & ATA_FLAG_MMIO)
- writeb(ap->ctl, ioaddr->ctl_addr);
+ writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
else
outb(ap->ctl, ioaddr->ctl_addr);
rc = ata_bus_edd(ap);
/* is double-select really necessary? */
if (ap->device[1].class != ATA_DEV_NONE)
- __ata_dev_select(ap, 1);
+ ap->ops->dev_select(ap, 1);
if (ap->device[0].class != ATA_DEV_NONE)
- __ata_dev_select(ap, 0);
+ ap->ops->dev_select(ap, 0);
/* if no devices were detected, disable this port */
if ((ap->device[0].class == ATA_DEV_NONE) &&
if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
/* set up device control for ATA_FLAG_SATA_RESET */
if (ap->flags & ATA_FLAG_MMIO)
- writeb(ap->ctl, ioaddr->ctl_addr);
+ writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
else
outb(ap->ctl, ioaddr->ctl_addr);
}
DPRINTK("EXIT\n");
}
-/**
- * ata_host_set_pio -
- * @ap:
- *
- * LOCKING:
- */
-
-static void ata_host_set_pio(struct ata_port *ap)
+static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
{
struct ata_device *master, *slave;
- unsigned int pio, i;
- u16 mask;
+ unsigned int mask;
master = &ap->device[0];
slave = &ap->device[1];
assert (ata_dev_present(master) || ata_dev_present(slave));
- mask = ap->pio_mask;
- if (ata_dev_present(master))
- mask &= (master->id[ATA_ID_PIO_MODES] & 0x03);
- if (ata_dev_present(slave))
- mask &= (slave->id[ATA_ID_PIO_MODES] & 0x03);
-
- /* require pio mode 3 or 4 support for host and all devices */
- if (mask == 0) {
- printk(KERN_WARNING "ata%u: no PIO3/4 support, ignoring\n",
- ap->id);
- goto err_out;
+ if (shift == ATA_SHIFT_UDMA) {
+ mask = ap->udma_mask;
+ if (ata_dev_present(master))
+ mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
+ if (ata_dev_present(slave))
+ mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
+ }
+ else if (shift == ATA_SHIFT_MWDMA) {
+ mask = ap->mwdma_mask;
+ if (ata_dev_present(master))
+ mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
+ if (ata_dev_present(slave))
+ mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
+ }
+ else if (shift == ATA_SHIFT_PIO) {
+ mask = ap->pio_mask;
+ if (ata_dev_present(master)) {
+ /* spec doesn't return explicit support for
+ * PIO0-2, so we fake it
+ */
+ u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
+ tmp_mode <<= 3;
+ tmp_mode |= 0x7;
+ mask &= tmp_mode;
+ }
+ if (ata_dev_present(slave)) {
+ /* spec doesn't return explicit support for
+ * PIO0-2, so we fake it
+ */
+ u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
+ tmp_mode <<= 3;
+ tmp_mode |= 0x7;
+ mask &= tmp_mode;
+ }
+ }
+ else {
+ mask = 0xffffffff; /* shut up compiler warning */
+ BUG();
}
- pio = (mask & ATA_ID_PIO4) ? 4 : 3;
- for (i = 0; i < ATA_MAX_DEVICES; i++)
- if (ata_dev_present(&ap->device[i])) {
- ap->device[i].pio_mode = (pio == 3) ?
- XFER_PIO_3 : XFER_PIO_4;
- if (ap->ops->set_piomode)
- ap->ops->set_piomode(ap, &ap->device[i], pio);
- }
+ return mask;
+}
- return;
+/* find greatest bit */
+static int fgb(u32 bitmap)
+{
+ unsigned int i;
+ int x = -1;
-err_out:
- ap->ops->port_disable(ap);
+ for (i = 0; i < 32; i++)
+ if (bitmap & (1 << i))
+ x = i;
+
+ return x;
}
/**
- * ata_host_set_udma -
- * @ap:
+ * ata_choose_xfer_mode - attempt to find best transfer mode
+ * @ap: Port for which an xfer mode will be selected
+ * @xfer_mode_out: (output) SET FEATURES - XFER MODE code
+ * @xfer_shift_out: (output) bit shift that selects this mode
*
* LOCKING:
+ *
+ * RETURNS:
+ * Zero on success, negative on error.
*/
-static void ata_host_set_udma(struct ata_port *ap)
+static int ata_choose_xfer_mode(struct ata_port *ap,
+ u8 *xfer_mode_out,
+ unsigned int *xfer_shift_out)
{
- struct ata_device *master, *slave;
- u16 mask;
- unsigned int i, j;
- int udma_mode = -1;
+ unsigned int mask, shift;
+ int x, i;
- master = &ap->device[0];
- slave = &ap->device[1];
+ for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
+ shift = xfer_mode_classes[i].shift;
+ mask = ata_get_mode_mask(ap, shift);
- assert (ata_dev_present(master) || ata_dev_present(slave));
- assert ((ap->flags & ATA_FLAG_PORT_DISABLED) == 0);
-
- DPRINTK("udma masks: host 0x%X, master 0x%X, slave 0x%X\n",
- ap->udma_mask,
- (!ata_dev_present(master)) ? 0xff :
- (master->id[ATA_ID_UDMA_MODES] & 0xff),
- (!ata_dev_present(slave)) ? 0xff :
- (slave->id[ATA_ID_UDMA_MODES] & 0xff));
-
- mask = ap->udma_mask;
- if (ata_dev_present(master))
- mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
- if (ata_dev_present(slave))
- mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
-
- i = XFER_UDMA_7;
- while (i >= XFER_UDMA_0) {
- j = i - XFER_UDMA_0;
- DPRINTK("mask 0x%X i 0x%X j %u\n", mask, i, j);
- if (mask & (1 << j)) {
- udma_mode = i;
- break;
+ x = fgb(mask);
+ if (x >= 0) {
+ *xfer_mode_out = xfer_mode_classes[i].base + x;
+ *xfer_shift_out = shift;
+ return 0;
}
-
- i--;
- }
-
- /* require udma for host and all attached devices */
- if (udma_mode < 0) {
- printk(KERN_WARNING "ata%u: no UltraDMA support, ignoring\n",
- ap->id);
- goto err_out;
}
- for (i = 0; i < ATA_MAX_DEVICES; i++)
- if (ata_dev_present(&ap->device[i])) {
- ap->device[i].udma_mode = udma_mode;
- if (ap->ops->set_udmamode)
- ap->ops->set_udmamode(ap, &ap->device[i],
- udma_mode);
- }
-
- return;
-
-err_out:
- ap->ops->port_disable(ap);
+ return -1;
}
/**
- * ata_dev_set_xfermode -
- * @ap:
- * @dev:
+ * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
+ * @ap: Port associated with device @dev
+ * @dev: Device to which command will be sent
*
* LOCKING:
*/
static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
{
- struct ata_taskfile tf;
+ DECLARE_COMPLETION(wait);
+ struct ata_queued_cmd *qc;
+ int rc;
+ unsigned long flags;
/* set up set-features taskfile */
DPRINTK("set features - xfer mode\n");
- ata_tf_init(ap, &tf, dev->devno);
- tf.ctl |= ATA_NIEN;
- tf.command = ATA_CMD_SET_FEATURES;
- tf.feature = SETFEATURES_XFER;
- tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
- tf.protocol = ATA_PROT_NODATA;
- if (dev->flags & ATA_DFLAG_PIO)
- tf.nsect = dev->pio_mode;
- else
- tf.nsect = dev->udma_mode;
- /* do bus reset */
- ata_tf_to_host(ap, &tf);
+ qc = ata_qc_new_init(ap, dev);
+ BUG_ON(qc == NULL);
- /* crazy ATAPI devices... */
- if (dev->class == ATA_DEV_ATAPI)
- msleep(150);
+ qc->tf.command = ATA_CMD_SET_FEATURES;
+ qc->tf.feature = SETFEATURES_XFER;
+ qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+ qc->tf.protocol = ATA_PROT_NODATA;
+ qc->tf.nsect = dev->xfer_mode;
- ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+ qc->waiting = &wait;
+ qc->complete_fn = ata_qc_complete_noop;
- ata_irq_on(ap); /* re-enable interrupts */
+ spin_lock_irqsave(&ap->host_set->lock, flags);
+ rc = ata_qc_issue(qc);
+ spin_unlock_irqrestore(&ap->host_set->lock, flags);
- ata_wait_idle(ap);
+ if (rc)
+ ata_port_disable(ap);
+ else
+ wait_for_completion(&wait);
DPRINTK("EXIT\n");
}
-/**
- * ata_dev_set_udma -
- * @ap:
- * @device:
- *
- * LOCKING:
- */
-
-static void ata_dev_set_udma(struct ata_port *ap, unsigned int device)
-{
- struct ata_device *dev = &ap->device[device];
-
- if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
- return;
-
- ata_dev_set_xfermode(ap, dev);
-
- assert((dev->udma_mode >= XFER_UDMA_0) &&
- (dev->udma_mode <= XFER_UDMA_7));
- printk(KERN_INFO "ata%u: dev %u configured for %s\n",
- ap->id, device,
- udma_str[dev->udma_mode - XFER_UDMA_0]);
-}
-
-/**
- * ata_dev_set_pio -
- * @ap:
- * @device:
- *
- * LOCKING:
- */
-
-static void ata_dev_set_pio(struct ata_port *ap, unsigned int device)
-{
- struct ata_device *dev = &ap->device[device];
-
- if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
- return;
-
- /* force PIO mode */
- dev->flags |= ATA_DFLAG_PIO;
-
- ata_dev_set_xfermode(ap, dev);
-
- assert((dev->pio_mode >= XFER_PIO_3) &&
- (dev->pio_mode <= XFER_PIO_4));
- printk(KERN_INFO "ata%u: dev %u configured for PIO%c\n",
- ap->id, device,
- dev->pio_mode == 3 ? '3' : '4');
-}
-
/**
* ata_sg_clean -
* @qc:
static void ata_sg_clean(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct scsi_cmnd *cmd = qc->scsicmd;
struct scatterlist *sg = qc->sg;
- int dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+ int dir = qc->dma_dir;
- assert(dir == SCSI_DATA_READ || dir == SCSI_DATA_WRITE);
- assert(qc->flags & ATA_QCFLAG_SG);
+ assert(qc->flags & ATA_QCFLAG_DMAMAP);
assert(sg != NULL);
- if (!cmd->use_sg)
+ if (qc->flags & ATA_QCFLAG_SINGLE)
assert(qc->n_elem == 1);
DPRINTK("unmapping %u sg elements\n", qc->n_elem);
- if (cmd->use_sg)
- pci_unmap_sg(ap->host_set->pdev, sg, qc->n_elem, dir);
+ if (qc->flags & ATA_QCFLAG_SG)
+ dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
else
- pci_unmap_single(ap->host_set->pdev, sg_dma_address(&sg[0]),
+ dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
sg_dma_len(&sg[0]), dir);
- qc->flags &= ~ATA_QCFLAG_SG;
+ qc->flags &= ~ATA_QCFLAG_DMAMAP;
qc->sg = NULL;
}
/**
- * ata_fill_sg -
- * @qc:
+ * ata_fill_sg - Fill PCI IDE PRD table
+ * @qc: Metadata associated with taskfile to be transferred
*
* LOCKING:
*
*/
-void ata_fill_sg(struct ata_queued_cmd *qc)
+static void ata_fill_sg(struct ata_queued_cmd *qc)
{
struct scatterlist *sg = qc->sg;
struct ata_port *ap = qc->ap;
idx = 0;
for (nelem = qc->n_elem; nelem; nelem--,sg++) {
- u32 addr, boundary;
+ u32 addr, offset;
u32 sg_len, len;
/* determine if physical DMA addr spans 64K boundary.
sg_len = sg_dma_len(sg);
while (sg_len) {
- boundary = (addr & ~0xffff) + (0xffff + 1);
+ offset = addr & 0xffff;
len = sg_len;
- if ((addr + sg_len) > boundary)
- len = boundary - addr;
+ if ((offset + sg_len) > 0x10000)
+ len = 0x10000 - offset;
ap->prd[idx].addr = cpu_to_le32(addr);
ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
if (idx)
ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
}
+/**
+ * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
+ * @qc: Metadata associated with taskfile to check
+ *
+ * LOCKING:
+ * RETURNS: 0 when ATAPI DMA can be used
+ * nonzero otherwise
+ */
+int ata_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+ struct ata_port *ap = qc->ap;
+ int rc = 0; /* Assume ATAPI DMA is OK by default */
+
+ if (ap->ops->check_atapi_dma)
+ rc = ap->ops->check_atapi_dma(qc);
+
+ return rc;
+}
+/**
+ * ata_qc_prep - Prepare taskfile for submission
+ * @qc: Metadata associated with taskfile to be prepared
+ *
+ * LOCKING:
+ * spin_lock_irqsave(host_set lock)
+ */
+void ata_qc_prep(struct ata_queued_cmd *qc)
+{
+ if (!(qc->flags & ATA_QCFLAG_DMAMAP))
+ return;
+
+ ata_fill_sg(qc);
+}
+
+void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
+{
+ struct scatterlist *sg;
+
+ qc->flags |= ATA_QCFLAG_SINGLE;
+
+ memset(&qc->sgent, 0, sizeof(qc->sgent));
+ qc->sg = &qc->sgent;
+ qc->n_elem = 1;
+ qc->buf_virt = buf;
+
+ sg = qc->sg;
+ sg->page = virt_to_page(buf);
+ sg->offset = (unsigned long) buf & ~PAGE_MASK;
+ sg_dma_len(sg) = buflen;
+}
+
+void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
+ unsigned int n_elem)
+{
+ qc->flags |= ATA_QCFLAG_SG;
+ qc->sg = sg;
+ qc->n_elem = n_elem;
+}
/**
* ata_sg_setup_one -
static int ata_sg_setup_one(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct scsi_cmnd *cmd = qc->scsicmd;
- int dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+ int dir = qc->dma_dir;
struct scatterlist *sg = qc->sg;
- unsigned int have_sg = (qc->flags & ATA_QCFLAG_SG);
dma_addr_t dma_address;
- assert(sg == &qc->sgent);
- assert(qc->n_elem == 1);
-
- sg->page = virt_to_page(cmd->request_buffer);
- sg->offset = (unsigned long) cmd->request_buffer & ~PAGE_MASK;
- sg_dma_len(sg) = cmd->request_bufflen;
-
- if (!have_sg)
- return 0;
-
- dma_address = pci_map_single(ap->host_set->pdev, cmd->request_buffer,
- cmd->request_bufflen, dir);
- if (pci_dma_mapping_error(dma_address))
+ dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
+ sg_dma_len(sg), dir);
+ if (dma_mapping_error(dma_address))
return -1;
sg_dma_address(sg) = dma_address;
- DPRINTK("mapped buffer of %d bytes for %s\n", cmd->request_bufflen,
+ DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
return 0;
static int ata_sg_setup(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct scsi_cmnd *cmd = qc->scsicmd;
- struct scatterlist *sg;
- int n_elem;
- unsigned int have_sg = (qc->flags & ATA_QCFLAG_SG);
-
- VPRINTK("ENTER, ata%u, use_sg %d\n", ap->id, cmd->use_sg);
- assert(cmd->use_sg > 0);
-
- sg = (struct scatterlist *)cmd->request_buffer;
- if (have_sg) {
- int dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
- n_elem = pci_map_sg(ap->host_set->pdev, sg, cmd->use_sg, dir);
- if (n_elem < 1)
- return -1;
- DPRINTK("%d sg elements mapped\n", n_elem);
- } else {
- n_elem = cmd->use_sg;
- }
+ struct scatterlist *sg = qc->sg;
+ int n_elem, dir;
+
+ VPRINTK("ENTER, ata%u\n", ap->id);
+ assert(qc->flags & ATA_QCFLAG_SG);
+
+ dir = qc->dma_dir;
+ n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
+ if (n_elem < 1)
+ return -1;
+
+ DPRINTK("%d sg elements mapped\n", n_elem);
+
qc->n_elem = n_elem;
return 0;
static unsigned long ata_pio_poll(struct ata_port *ap)
{
u8 status;
- unsigned int poll_state = THR_UNKNOWN;
- unsigned int reg_state = THR_UNKNOWN;
- const unsigned int tmout_state = THR_PIO_TMOUT;
-
- switch (ap->thr_state) {
- case THR_PIO:
- case THR_PIO_POLL:
- poll_state = THR_PIO_POLL;
- reg_state = THR_PIO;
+ unsigned int poll_state = PIO_ST_UNKNOWN;
+ unsigned int reg_state = PIO_ST_UNKNOWN;
+ const unsigned int tmout_state = PIO_ST_TMOUT;
+
+ switch (ap->pio_task_state) {
+ case PIO_ST:
+ case PIO_ST_POLL:
+ poll_state = PIO_ST_POLL;
+ reg_state = PIO_ST;
break;
- case THR_PIO_LAST:
- case THR_PIO_LAST_POLL:
- poll_state = THR_PIO_LAST_POLL;
- reg_state = THR_PIO_LAST;
+ case PIO_ST_LAST:
+ case PIO_ST_LAST_POLL:
+ poll_state = PIO_ST_LAST_POLL;
+ reg_state = PIO_ST_LAST;
break;
default:
BUG();
status = ata_chk_status(ap);
if (status & ATA_BUSY) {
- if (time_after(jiffies, ap->thr_timeout)) {
- ap->thr_state = tmout_state;
+ if (time_after(jiffies, ap->pio_task_timeout)) {
+ ap->pio_task_state = tmout_state;
return 0;
}
- ap->thr_state = poll_state;
+ ap->pio_task_state = poll_state;
return ATA_SHORT_PAUSE;
}
- ap->thr_state = reg_state;
+ ap->pio_task_state = reg_state;
return 0;
}
-/**
- * ata_pio_start -
- * @qc:
- *
- * LOCKING:
- * spin_lock_irqsave(host_set lock)
- */
-
-static void ata_pio_start (struct ata_queued_cmd *qc)
-{
- struct ata_port *ap = qc->ap;
-
- assert(qc->tf.protocol == ATA_PROT_PIO);
-
- qc->flags |= ATA_QCFLAG_POLL;
- qc->tf.ctl |= ATA_NIEN; /* disable interrupts */
- ata_tf_to_host_nolock(ap, &qc->tf);
- ata_thread_wake(ap, THR_PIO);
-}
-
/**
* ata_pio_complete -
* @ap:
static void ata_pio_complete (struct ata_port *ap)
{
struct ata_queued_cmd *qc;
- unsigned long flags;
u8 drv_stat;
/*
* a chk-status or two. If not, the drive is probably seeking
* or something. Snooze for a couple msecs, then
* chk-status again. If still busy, fall back to
- * THR_PIO_POLL state.
+ * PIO_ST_POLL state.
*/
drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
msleep(2);
drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
- ap->thr_state = THR_PIO_LAST_POLL;
- ap->thr_timeout = jiffies + ATA_TMOUT_PIO;
+ ap->pio_task_state = PIO_ST_LAST_POLL;
+ ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
return;
}
}
drv_stat = ata_wait_idle(ap);
- if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
- ap->thr_state = THR_PIO_ERR;
+ if (!ata_ok(drv_stat)) {
+ ap->pio_task_state = PIO_ST_ERR;
return;
}
qc = ata_qc_from_tag(ap, ap->active_tag);
assert(qc != NULL);
- spin_lock_irqsave(&ap->host_set->lock, flags);
- ap->thr_state = THR_IDLE;
- spin_unlock_irqrestore(&ap->host_set->lock, flags);
+ ap->pio_task_state = PIO_ST_IDLE;
ata_irq_on(ap);
- ata_qc_complete(qc, drv_stat, 0);
+ ata_qc_complete(qc, drv_stat);
+}
+
+void swap_buf_le16(u16 *buf, unsigned int buf_words)
+{
+#ifdef __BIG_ENDIAN
+ unsigned int i;
+
+ for (i = 0; i < buf_words; i++)
+ buf[i] = le16_to_cpu(buf[i]);
+#endif /* __BIG_ENDIAN */
+}
+
+static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
+ unsigned int buflen, int write_data)
+{
+ unsigned int i;
+ unsigned int words = buflen >> 1;
+ u16 *buf16 = (u16 *) buf;
+ void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
+
+ if (write_data) {
+ for (i = 0; i < words; i++)
+ writew(le16_to_cpu(buf16[i]), mmio);
+ } else {
+ for (i = 0; i < words; i++)
+ buf16[i] = cpu_to_le16(readw(mmio));
+ }
+}
+
+static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
+ unsigned int buflen, int write_data)
+{
+ unsigned int dwords = buflen >> 1;
+
+ if (write_data)
+ outsw(ap->ioaddr.data_addr, buf, dwords);
+ else
+ insw(ap->ioaddr.data_addr, buf, dwords);
+}
+
+static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
+ unsigned int buflen, int do_write)
+{
+ if (ap->flags & ATA_FLAG_MMIO)
+ ata_mmio_data_xfer(ap, buf, buflen, do_write);
+ else
+ ata_pio_data_xfer(ap, buf, buflen, do_write);
+}
+
+static void ata_pio_sector(struct ata_queued_cmd *qc)
+{
+ int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
+ struct scatterlist *sg = qc->sg;
+ struct ata_port *ap = qc->ap;
+ struct page *page;
+ unsigned int offset;
+ unsigned char *buf;
+
+ if (qc->cursect == (qc->nsect - 1))
+ ap->pio_task_state = PIO_ST_LAST;
+
+ page = sg[qc->cursg].page;
+ offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
+
+ /* get the current page and offset */
+ page = nth_page(page, (offset >> PAGE_SHIFT));
+ offset %= PAGE_SIZE;
+
+ buf = kmap(page) + offset;
+
+ qc->cursect++;
+ qc->cursg_ofs++;
+
+ if ((qc->cursg_ofs * ATA_SECT_SIZE) == sg_dma_len(&sg[qc->cursg])) {
+ qc->cursg++;
+ qc->cursg_ofs = 0;
+ }
+
+ DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+
+ /* do the actual data transfer */
+ do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
+ ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
+
+ kunmap(page);
+}
+
+static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
+{
+ int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
+ struct scatterlist *sg = qc->sg;
+ struct ata_port *ap = qc->ap;
+ struct page *page;
+ unsigned char *buf;
+ unsigned int offset, count;
+
+ if (qc->curbytes == qc->nbytes - bytes)
+ ap->pio_task_state = PIO_ST_LAST;
+
+next_sg:
+ sg = &qc->sg[qc->cursg];
+
+next_page:
+ page = sg->page;
+ offset = sg->offset + qc->cursg_ofs;
+
+ /* get the current page and offset */
+ page = nth_page(page, (offset >> PAGE_SHIFT));
+ offset %= PAGE_SIZE;
+
+ count = min(sg_dma_len(sg) - qc->cursg_ofs, bytes);
+
+ /* don't cross page boundaries */
+ count = min(count, (unsigned int)PAGE_SIZE - offset);
+
+ buf = kmap(page) + offset;
+
+ bytes -= count;
+ qc->curbytes += count;
+ qc->cursg_ofs += count;
+
+ if (qc->cursg_ofs == sg_dma_len(sg)) {
+ qc->cursg++;
+ qc->cursg_ofs = 0;
+ }
+
+ DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+
+ /* do the actual data transfer */
+ ata_data_xfer(ap, buf, count, do_write);
+
+ kunmap(page);
+
+ if (bytes) {
+ if (qc->cursg_ofs < sg_dma_len(sg))
+ goto next_page;
+ goto next_sg;
+ }
+}
+
+static void atapi_pio_bytes(struct ata_queued_cmd *qc)
+{
+ struct ata_port *ap = qc->ap;
+ struct ata_device *dev = qc->dev;
+ unsigned int ireason, bc_lo, bc_hi, bytes;
+ int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
+
+ ap->ops->tf_read(ap, &qc->tf);
+ ireason = qc->tf.nsect;
+ bc_lo = qc->tf.lbam;
+ bc_hi = qc->tf.lbah;
+ bytes = (bc_hi << 8) | bc_lo;
+
+ /* shall be cleared to zero, indicating xfer of data */
+ if (ireason & (1 << 0))
+ goto err_out;
+
+ /* make sure transfer direction matches expected */
+ i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
+ if (do_write != i_write)
+ goto err_out;
+
+ __atapi_pio_bytes(qc, bytes);
+
+ return;
+
+err_out:
+ printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
+ ap->id, dev->devno);
+ ap->pio_task_state = PIO_ST_ERR;
}
/**
* LOCKING:
*/
-static void ata_pio_sector(struct ata_port *ap)
+static void ata_pio_block(struct ata_port *ap)
{
struct ata_queued_cmd *qc;
- struct scatterlist *sg;
- struct scsi_cmnd *cmd;
- unsigned char *buf;
u8 status;
/*
* a chk-status or two. If not, the drive is probably seeking
* or something. Snooze for a couple msecs, then
* chk-status again. If still busy, fall back to
- * THR_PIO_POLL state.
+ * PIO_ST_POLL state.
*/
status = ata_busy_wait(ap, ATA_BUSY, 5);
if (status & ATA_BUSY) {
msleep(2);
status = ata_busy_wait(ap, ATA_BUSY, 10);
if (status & ATA_BUSY) {
- ap->thr_state = THR_PIO_POLL;
- ap->thr_timeout = jiffies + ATA_TMOUT_PIO;
+ ap->pio_task_state = PIO_ST_POLL;
+ ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
return;
}
}
- /* handle BSY=0, DRQ=0 as error */
- if ((status & ATA_DRQ) == 0) {
- ap->thr_state = THR_PIO_ERR;
- return;
+ qc = ata_qc_from_tag(ap, ap->active_tag);
+ assert(qc != NULL);
+
+ if (is_atapi_taskfile(&qc->tf)) {
+ /* no more data to transfer or unsupported ATAPI command */
+ if ((status & ATA_DRQ) == 0) {
+ ap->pio_task_state = PIO_ST_IDLE;
+
+ ata_irq_on(ap);
+
+ ata_qc_complete(qc, status);
+ return;
+ }
+
+ atapi_pio_bytes(qc);
+ } else {
+ /* handle BSY=0, DRQ=0 as error */
+ if ((status & ATA_DRQ) == 0) {
+ ap->pio_task_state = PIO_ST_ERR;
+ return;
+ }
+
+ ata_pio_sector(qc);
}
+}
+
+static void ata_pio_error(struct ata_port *ap)
+{
+ struct ata_queued_cmd *qc;
+ u8 drv_stat;
qc = ata_qc_from_tag(ap, ap->active_tag);
assert(qc != NULL);
- cmd = qc->scsicmd;
- sg = qc->sg;
+ drv_stat = ata_chk_status(ap);
+ printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
+ ap->id, drv_stat);
- if (qc->cursect == (qc->nsect - 1))
- ap->thr_state = THR_PIO_LAST;
+ ap->pio_task_state = PIO_ST_IDLE;
- buf = kmap(sg[qc->cursg].page) +
- sg[qc->cursg].offset + (qc->cursg_ofs * ATA_SECT_SIZE);
+ ata_irq_on(ap);
- qc->cursect++;
- qc->cursg_ofs++;
+ ata_qc_complete(qc, drv_stat | ATA_ERR);
+}
- if (cmd->use_sg)
- if ((qc->cursg_ofs * ATA_SECT_SIZE) == sg_dma_len(&sg[qc->cursg])) {
- qc->cursg++;
- qc->cursg_ofs = 0;
- }
+static void ata_pio_task(void *_data)
+{
+ struct ata_port *ap = _data;
+ unsigned long timeout = 0;
- DPRINTK("data %s, drv_stat 0x%X\n",
- qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read",
- status);
+ switch (ap->pio_task_state) {
+ case PIO_ST_IDLE:
+ return;
- /* do the actual data transfer */
- /* FIXME: mmio-ize */
- if (qc->tf.flags & ATA_TFLAG_WRITE)
- outsl(ap->ioaddr.data_addr, buf, ATA_SECT_DWORDS);
- else
- insl(ap->ioaddr.data_addr, buf, ATA_SECT_DWORDS);
+ case PIO_ST:
+ ata_pio_block(ap);
+ break;
+
+ case PIO_ST_LAST:
+ ata_pio_complete(ap);
+ break;
+
+ case PIO_ST_POLL:
+ case PIO_ST_LAST_POLL:
+ timeout = ata_pio_poll(ap);
+ break;
+
+ case PIO_ST_TMOUT:
+ case PIO_ST_ERR:
+ ata_pio_error(ap);
+ return;
+ }
- kunmap(sg[qc->cursg].page);
+ if (timeout)
+ queue_delayed_work(ata_wq, &ap->pio_task,
+ timeout);
+ else
+ queue_work(ata_wq, &ap->pio_task);
}
-#if 0 /* to be used eventually */
-/**
- * ata_eng_schedule - run an iteration of the pio/dma/whatever engine
- * @ap: port on which activity will occur
- * @eng: instance of engine
- *
- * LOCKING:
- * spin_lock_irqsave(host_set lock)
- */
-static void ata_eng_schedule (struct ata_port *ap, struct ata_engine *eng)
+static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
+ struct scsi_cmnd *cmd)
{
- /* FIXME */
+ DECLARE_COMPLETION(wait);
+ struct ata_queued_cmd *qc;
+ unsigned long flags;
+ int rc;
+
+ DPRINTK("ATAPI request sense\n");
+
+ qc = ata_qc_new_init(ap, dev);
+ BUG_ON(qc == NULL);
+
+ /* FIXME: is this needed? */
+ memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
+
+ ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
+ qc->dma_dir = DMA_FROM_DEVICE;
+
+ memset(&qc->cdb, 0, sizeof(ap->cdb_len));
+ qc->cdb[0] = REQUEST_SENSE;
+ qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
+
+ qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+ qc->tf.command = ATA_CMD_PACKET;
+
+ qc->tf.protocol = ATA_PROT_ATAPI;
+ qc->tf.lbam = (8 * 1024) & 0xff;
+ qc->tf.lbah = (8 * 1024) >> 8;
+ qc->nbytes = SCSI_SENSE_BUFFERSIZE;
+
+ qc->waiting = &wait;
+ qc->complete_fn = ata_qc_complete_noop;
+
+ spin_lock_irqsave(&ap->host_set->lock, flags);
+ rc = ata_qc_issue(qc);
+ spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+ if (rc)
+ ata_port_disable(ap);
+ else
+ wait_for_completion(&wait);
+
+ DPRINTK("EXIT\n");
}
-#endif
/**
- * ata_eng_timeout - Handle timeout of queued command
- * @ap: Port on which timed-out command is active
+ * ata_qc_timeout - Handle timeout of queued command
+ * @qc: Command that timed out
*
* Some part of the kernel (currently, only the SCSI layer)
* has noticed that the active command on port @ap has not
* transaction completed successfully.
*
* LOCKING:
- * Inherited from SCSI layer (none, can sleep)
*/
-void ata_eng_timeout(struct ata_port *ap)
+static void ata_qc_timeout(struct ata_queued_cmd *qc)
{
- u8 host_stat, drv_stat;
- struct ata_queued_cmd *qc;
+ struct ata_port *ap = qc->ap;
+ struct ata_device *dev = qc->dev;
+ u8 host_stat = 0, drv_stat;
DPRINTK("ENTER\n");
- qc = ata_qc_from_tag(ap, ap->active_tag);
- if (!qc) {
- printk(KERN_ERR "ata%u: BUG: timeout without command\n",
- ap->id);
- goto out;
+ /* FIXME: doesn't this conflict with timeout handling? */
+ if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
+ struct scsi_cmnd *cmd = qc->scsicmd;
+
+ if (!scsi_eh_eflags_chk(cmd, SCSI_EH_CANCEL_CMD)) {
+
+ /* finish completing original command */
+ __ata_qc_complete(qc);
+
+ atapi_request_sense(ap, dev, cmd);
+
+ cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
+ scsi_finish_command(cmd);
+
+ goto out;
+ }
}
/* hack alert! We cannot use the supplied completion
qc->scsidone = scsi_finish_command;
switch (qc->tf.protocol) {
+
case ATA_PROT_DMA:
- if (ap->flags & ATA_FLAG_MMIO) {
- void *mmio = (void *) ap->ioaddr.bmdma_addr;
- host_stat = readb(mmio + ATA_DMA_STATUS);
- } else
- host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+ case ATA_PROT_ATAPI_DMA:
+ host_stat = ata_bmdma_status(ap);
- printk(KERN_ERR "ata%u: DMA timeout, stat 0x%x\n",
- ap->id, host_stat);
+ /* before we do anything else, clear DMA-Start bit */
+ ata_bmdma_stop(ap);
- ata_dma_complete(ap, host_stat, 1);
- break;
+ /* fall through */
- case ATA_PROT_NODATA:
- drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
+ default:
+ ata_altstatus(ap);
+ drv_stat = ata_chk_status(ap);
+
+ /* ack bmdma irq events */
+ ata_bmdma_ack_irq(ap);
- printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x\n",
- ap->id, qc->tf.command, drv_stat);
+ printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
+ ap->id, qc->tf.command, drv_stat, host_stat);
- ata_qc_complete(qc, drv_stat, 1);
+ /* complete taskfile transaction */
+ ata_qc_complete(qc, drv_stat);
break;
+ }
+out:
+ DPRINTK("EXIT\n");
+}
- default:
- drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
+/**
+ * ata_eng_timeout - Handle timeout of queued command
+ * @ap: Port on which timed-out command is active
+ *
+ * Some part of the kernel (currently, only the SCSI layer)
+ * has noticed that the active command on port @ap has not
+ * completed after a specified length of time. Handle this
+ * condition by disabling DMA (if necessary) and completing
+ * transactions, with error if necessary.
+ *
+ * This also handles the case of the "lost interrupt", where
+ * for some reason (possibly hardware bug, possibly driver bug)
+ * an interrupt was not delivered to the driver, even though the
+ * transaction completed successfully.
+ *
+ * LOCKING:
+ * Inherited from SCSI layer (none, can sleep)
+ */
- printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n",
- ap->id, qc->tf.command, drv_stat);
+void ata_eng_timeout(struct ata_port *ap)
+{
+ struct ata_queued_cmd *qc;
- ata_qc_complete(qc, drv_stat, 1);
- break;
+ DPRINTK("ENTER\n");
+
+ qc = ata_qc_from_tag(ap, ap->active_tag);
+ if (!qc) {
+ printk(KERN_ERR "ata%u: BUG: timeout without command\n",
+ ap->id);
+ goto out;
}
+ ata_qc_timeout(qc);
+
out:
DPRINTK("EXIT\n");
}
/**
- * ata_qc_new -
- * @ap:
- * @dev:
+ * ata_qc_new - Request an available ATA command, for queueing
+ * @ap: Port associated with device @dev
+ * @dev: Device from whom we request an available command structure
*
* LOCKING:
*/
}
/**
- * ata_qc_new_init -
- * @ap:
- * @dev:
+ * ata_qc_new_init - Request an available ATA command, and initialize it
+ * @ap: Port associated with device @dev
+ * @dev: Device from whom we request an available command structure
*
* LOCKING:
*/
qc->ap = ap;
qc->dev = dev;
qc->cursect = qc->cursg = qc->cursg_ofs = 0;
- INIT_LIST_HEAD(&qc->node);
- init_MUTEX_LOCKED(&qc->sem);
+ qc->nsect = 0;
+ qc->nbytes = qc->curbytes = 0;
ata_tf_init(ap, &qc->tf, dev->devno);
- if (likely((dev->flags & ATA_DFLAG_PIO) == 0))
- qc->flags |= ATA_QCFLAG_DMA;
if (dev->flags & ATA_DFLAG_LBA48)
qc->tf.flags |= ATA_TFLAG_LBA48;
}
return qc;
}
-/**
- * ata_qc_complete -
- * @qc:
- * @drv_stat:
- * @done_late:
- *
- * LOCKING:
- *
- */
+static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
+{
+ return 0;
+}
-void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat, unsigned int done_late)
+static void __ata_qc_complete(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct scsi_cmnd *cmd = qc->scsicmd;
unsigned int tag, do_clear = 0;
- assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
- assert(qc->flags & ATA_QCFLAG_ACTIVE);
-
- if (likely(qc->flags & ATA_QCFLAG_SG))
- ata_sg_clean(qc);
-
- if (cmd) {
- if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
- if (qc->flags & ATA_QCFLAG_ATAPI)
- cmd->result = SAM_STAT_CHECK_CONDITION;
- else
- ata_to_sense_error(qc);
- } else {
- cmd->result = SAM_STAT_GOOD;
- }
-
- qc->scsidone(cmd);
- }
-
- qc->flags &= ~ATA_QCFLAG_ACTIVE;
+ qc->flags = 0;
tag = qc->tag;
if (likely(ata_tag_valid(tag))) {
if (tag == ap->active_tag)
do_clear = 1;
}
- up(&qc->sem);
+ if (qc->waiting) {
+ struct completion *waiting = qc->waiting;
+ qc->waiting = NULL;
+ complete(waiting);
+ }
if (likely(do_clear))
clear_bit(tag, &ap->qactive);
}
-#if 0 /* to be used eventually */
/**
- * ata_qc_push -
- * @qc:
- * @append:
+ * ata_qc_complete - Complete an active ATA command
+ * @qc: Command to complete
+ * @drv_stat: ATA status register contents
*
* LOCKING:
- * spin_lock_irqsave(host_set lock)
+ *
*/
-static void ata_qc_push (struct ata_queued_cmd *qc, unsigned int append)
+
+void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
+{
+ int rc;
+
+ assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
+ assert(qc->flags & ATA_QCFLAG_ACTIVE);
+
+ if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
+ ata_sg_clean(qc);
+
+ /* call completion callback */
+ rc = qc->complete_fn(qc, drv_stat);
+
+ /* if callback indicates not to complete command (non-zero),
+ * return immediately
+ */
+ if (rc != 0)
+ return;
+
+ __ata_qc_complete(qc);
+
+ VPRINTK("EXIT\n");
+}
+
+static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct ata_engine *eng = &ap->eng;
- if (likely(append))
- list_add_tail(&qc->node, &eng->q);
- else
- list_add(&qc->node, &eng->q);
+ switch (qc->tf.protocol) {
+ case ATA_PROT_DMA:
+ case ATA_PROT_ATAPI_DMA:
+ return 1;
+
+ case ATA_PROT_ATAPI:
+ case ATA_PROT_PIO:
+ case ATA_PROT_PIO_MULT:
+ if (ap->flags & ATA_FLAG_PIO_DMA)
+ return 1;
- if (!test_and_set_bit(ATA_EFLG_ACTIVE, &eng->flags))
- ata_eng_schedule(ap, eng);
+ /* fall through */
+
+ default:
+ return 0;
+ }
+
+ /* never reached */
}
-#endif
/**
- * ata_qc_issue -
- * @qc:
+ * ata_qc_issue - issue taskfile to device
+ * @qc: command to issue to device
+ *
+ * Prepare an ATA command to submission to device.
+ * This includes mapping the data into a DMA-able
+ * area, filling in the S/G table, and finally
+ * writing the taskfile to hardware, starting the command.
*
* LOCKING:
+ * spin_lock_irqsave(host_set lock)
*
* RETURNS:
- *
+ * Zero on success, negative on error.
*/
+
int ata_qc_issue(struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
- struct scsi_cmnd *cmd = qc->scsicmd;
- unsigned int dma = qc->flags & ATA_QCFLAG_DMA;
-
- ata_dev_select(ap, qc->dev->devno, 1, 0);
- /* set up SG table */
- if (cmd->use_sg) {
- if (ata_sg_setup(qc))
- goto err_out;
+ if (ata_should_dma_map(qc)) {
+ if (qc->flags & ATA_QCFLAG_SG) {
+ if (ata_sg_setup(qc))
+ goto err_out;
+ } else if (qc->flags & ATA_QCFLAG_SINGLE) {
+ if (ata_sg_setup_one(qc))
+ goto err_out;
+ }
} else {
- if (ata_sg_setup_one(qc))
- goto err_out;
+ qc->flags &= ~ATA_QCFLAG_DMAMAP;
}
- ap->ops->fill_sg(qc);
+ ap->ops->qc_prep(qc);
qc->ap->active_tag = qc->tag;
qc->flags |= ATA_QCFLAG_ACTIVE;
- if (likely(dma)) {
- ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
- ap->ops->bmdma_start(qc); /* initiate bmdma */
- } else
- /* load tf registers, initiate polling pio */
- ata_pio_start(qc);
-
- return 0;
+ return ap->ops->qc_issue(qc);
err_out:
return -1;
}
/**
- * ata_bmdma_start_mmio -
- * @qc:
+ * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
+ * @qc: command to issue to device
+ *
+ * Using various libata functions and hooks, this function
+ * starts an ATA command. ATA commands are grouped into
+ * classes called "protocols", and issuing each type of protocol
+ * is slightly different.
+ *
+ * LOCKING:
+ * spin_lock_irqsave(host_set lock)
+ *
+ * RETURNS:
+ * Zero on success, negative on error.
+ */
+
+int ata_qc_issue_prot(struct ata_queued_cmd *qc)
+{
+ struct ata_port *ap = qc->ap;
+
+ ata_dev_select(ap, qc->dev->devno, 1, 0);
+
+ switch (qc->tf.protocol) {
+ case ATA_PROT_NODATA:
+ ata_tf_to_host_nolock(ap, &qc->tf);
+ break;
+
+ case ATA_PROT_DMA:
+ ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
+ ap->ops->bmdma_setup(qc); /* set up bmdma */
+ ap->ops->bmdma_start(qc); /* initiate bmdma */
+ break;
+
+ case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
+ ata_qc_set_polling(qc);
+ ata_tf_to_host_nolock(ap, &qc->tf);
+ ap->pio_task_state = PIO_ST;
+ queue_work(ata_wq, &ap->pio_task);
+ break;
+
+ case ATA_PROT_ATAPI:
+ ata_qc_set_polling(qc);
+ ata_tf_to_host_nolock(ap, &qc->tf);
+ queue_work(ata_wq, &ap->packet_task);
+ break;
+
+ case ATA_PROT_ATAPI_NODATA:
+ ata_tf_to_host_nolock(ap, &qc->tf);
+ queue_work(ata_wq, &ap->packet_task);
+ break;
+
+ case ATA_PROT_ATAPI_DMA:
+ ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
+ ap->ops->bmdma_setup(qc); /* set up bmdma */
+ queue_work(ata_wq, &ap->packet_task);
+ break;
+
+ default:
+ WARN_ON(1);
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+ * ata_bmdma_setup - Set up PCI IDE BMDMA transaction
+ * @qc: Info associated with this ATA transaction.
*
* LOCKING:
* spin_lock_irqsave(host_set lock)
*/
-void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
+static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
- u8 host_stat, dmactl;
- void *mmio = (void *) ap->ioaddr.bmdma_addr;
+ u8 dmactl;
+ void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
/* load PRD table addr. */
mb(); /* make sure PRD table writes are visible to controller */
dmactl |= ATA_DMA_WR;
writeb(dmactl, mmio + ATA_DMA_CMD);
- /* clear interrupt, error bits */
- host_stat = readb(mmio + ATA_DMA_STATUS);
- writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR, mmio + ATA_DMA_STATUS);
+ /* issue r/w command */
+ ap->ops->exec_command(ap, &qc->tf);
+}
+
+/**
+ * ata_bmdma_start - Start a PCI IDE BMDMA transaction
+ * @qc: Info associated with this ATA transaction.
+ *
+ * LOCKING:
+ * spin_lock_irqsave(host_set lock)
+ */
- /* issue r/w command */
- ap->ops->exec_command(ap, &qc->tf);
+static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
+{
+ struct ata_port *ap = qc->ap;
+ void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
+ u8 dmactl;
/* start host DMA transaction */
+ dmactl = readb(mmio + ATA_DMA_CMD);
writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
/* Strictly, one may wish to issue a readb() here, to
}
/**
- * ata_bmdma_start_pio -
- * @qc:
+ * ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
+ * @qc: Info associated with this ATA transaction.
*
* LOCKING:
* spin_lock_irqsave(host_set lock)
*/
-void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
+static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
{
struct ata_port *ap = qc->ap;
unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
- u8 host_stat, dmactl;
+ u8 dmactl;
/* load PRD table addr. */
outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
dmactl |= ATA_DMA_WR;
outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
- /* clear interrupt, error bits */
- 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);
-
/* issue r/w command */
ap->ops->exec_command(ap, &qc->tf);
-
- /* start host DMA transaction */
- outb(dmactl | ATA_DMA_START,
- ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
}
/**
- * ata_dma_complete -
- * @ap:
- * @host_stat:
- * @done_late:
+ * ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
+ * @qc: Info associated with this ATA transaction.
*
* LOCKING:
+ * spin_lock_irqsave(host_set lock)
*/
-static void ata_dma_complete(struct ata_port *ap, u8 host_stat,
- unsigned int done_late)
+static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
{
- VPRINTK("ENTER\n");
-
- if (ap->flags & ATA_FLAG_MMIO) {
- void *mmio = (void *) ap->ioaddr.bmdma_addr;
-
- /* clear start/stop bit */
- writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
- mmio + ATA_DMA_CMD);
-
- /* ack intr, err bits */
- writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
- mmio + ATA_DMA_STATUS);
- } else {
- /* clear start/stop bit */
- outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
- ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
-
- /* ack intr, err bits */
- outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
- ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
- }
+ struct ata_port *ap = qc->ap;
+ u8 dmactl;
+ /* start host DMA transaction */
+ dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+ outb(dmactl | ATA_DMA_START,
+ ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+}
- /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
- ata_altstatus(ap); /* dummy read */
+void ata_bmdma_start(struct ata_queued_cmd *qc)
+{
+ if (qc->ap->flags & ATA_FLAG_MMIO)
+ ata_bmdma_start_mmio(qc);
+ else
+ ata_bmdma_start_pio(qc);
+}
- DPRINTK("host %u, host_stat==0x%X, drv_stat==0x%X\n",
- ap->id, (u32) host_stat, (u32) ata_chk_status(ap));
+void ata_bmdma_setup(struct ata_queued_cmd *qc)
+{
+ if (qc->ap->flags & ATA_FLAG_MMIO)
+ ata_bmdma_setup_mmio(qc);
+ else
+ ata_bmdma_setup_pio(qc);
+}
- /* get drive status; clear intr; complete txn */
- ata_qc_complete(ata_qc_from_tag(ap, ap->active_tag),
- ata_wait_idle(ap), done_late);
+void ata_bmdma_irq_clear(struct ata_port *ap)
+{
+ ata_bmdma_ack_irq(ap);
}
/**
struct ata_queued_cmd *qc)
{
u8 status, host_stat;
- unsigned int handled = 0;
switch (qc->tf.protocol) {
+
case ATA_PROT_DMA:
- if (ap->flags & ATA_FLAG_MMIO) {
- void *mmio = (void *) ap->ioaddr.bmdma_addr;
- host_stat = readb(mmio + ATA_DMA_STATUS);
- } else
- host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
- VPRINTK("BUS_DMA (host_stat 0x%X)\n", host_stat);
+ case ATA_PROT_ATAPI_DMA:
+ case ATA_PROT_ATAPI:
+ /* check status of DMA engine */
+ host_stat = ata_bmdma_status(ap);
+ VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
- if (!(host_stat & ATA_DMA_INTR)) {
- ap->stats.idle_irq++;
- break;
- }
+ /* if it's not our irq... */
+ if (!(host_stat & ATA_DMA_INTR))
+ goto idle_irq;
- ata_dma_complete(ap, host_stat, 0);
- handled = 1;
- break;
+ /* before we do anything else, clear DMA-Start bit */
+ ata_bmdma_stop(ap);
- case ATA_PROT_NODATA: /* command completion, but no data xfer */
- status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
- DPRINTK("BUS_NODATA (drv_stat 0x%X)\n", status);
- ata_qc_complete(qc, status, 0);
- handled = 1;
+ /* fall through */
+
+ case ATA_PROT_ATAPI_NODATA:
+ case ATA_PROT_NODATA:
+ /* check altstatus */
+ status = ata_altstatus(ap);
+ if (status & ATA_BUSY)
+ goto idle_irq;
+
+ /* check main status, clearing INTRQ */
+ status = ata_chk_status(ap);
+ if (unlikely(status & ATA_BUSY))
+ goto idle_irq;
+ DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
+ ap->id, qc->tf.protocol, status);
+
+ /* ack bmdma irq events */
+ ata_bmdma_ack_irq(ap);
+
+ /* complete taskfile transaction */
+ ata_qc_complete(qc, status);
break;
default:
- ap->stats.idle_irq++;
+ goto idle_irq;
+ }
+
+ return 1; /* irq handled */
+
+idle_irq:
+ ap->stats.idle_irq++;
#ifdef ATA_IRQ_TRAP
- if ((ap->stats.idle_irq % 1000) == 0) {
- handled = 1;
- ata_irq_ack(ap, 0); /* debug trap */
- printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
- }
-#endif
- break;
+ if ((ap->stats.idle_irq % 1000) == 0) {
+ handled = 1;
+ ata_irq_ack(ap, 0); /* debug trap */
+ printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
}
-
- return handled;
+#endif
+ return 0; /* irq not handled */
}
/**
- * ata_interrupt -
- * @irq:
- * @dev_instance:
- * @regs:
+ * ata_interrupt - Default ATA host interrupt handler
+ * @irq: irq line
+ * @dev_instance: pointer to our host information structure
+ * @regs: unused
*
* LOCKING:
*
struct ata_queued_cmd *qc;
qc = ata_qc_from_tag(ap, ap->active_tag);
- if (qc && ((qc->flags & ATA_QCFLAG_POLL) == 0))
- handled += ata_host_intr(ap, qc);
+ if (qc && (!(qc->tf.ctl & ATA_NIEN)))
+ handled |= ata_host_intr(ap, qc);
}
}
}
/**
- * ata_thread_wake -
- * @ap:
- * @thr_state:
- *
- * LOCKING:
- * spin_lock_irqsave(host_set lock)
- */
-
-void ata_thread_wake(struct ata_port *ap, unsigned int thr_state)
-{
- assert(ap->thr_state == THR_IDLE);
- ap->thr_state = thr_state;
- up(&ap->thr_sem);
-}
-
-/**
- * ata_thread_timer -
- * @opaque:
- *
- * LOCKING:
- */
-
-static void ata_thread_timer(unsigned long opaque)
-{
- struct ata_port *ap = (struct ata_port *) opaque;
-
- up(&ap->thr_sem);
-}
-
-/**
- * ata_thread_iter -
- * @ap:
- *
- * LOCKING:
- *
- * RETURNS:
- *
- */
-
-static unsigned long ata_thread_iter(struct ata_port *ap)
-{
- long timeout = 0;
-
- DPRINTK("ata%u: thr_state %s\n",
- ap->id, ata_thr_state_name(ap->thr_state));
-
- switch (ap->thr_state) {
- case THR_UNKNOWN:
- ap->thr_state = THR_PORT_RESET;
- break;
-
- case THR_PROBE_START:
- down(&ap->sem);
- ap->thr_state = THR_PORT_RESET;
- break;
-
- case THR_PORT_RESET:
- ata_port_reset(ap);
- break;
-
- case THR_PROBE_SUCCESS:
- up(&ap->probe_sem);
- ap->thr_state = THR_IDLE;
- break;
-
- case THR_PROBE_FAILED:
- up(&ap->probe_sem);
- ap->thr_state = THR_AWAIT_DEATH;
- break;
-
- case THR_AWAIT_DEATH:
- timeout = -1;
- break;
-
- case THR_IDLE:
- timeout = 30 * HZ;
- break;
-
- case THR_PIO:
- ata_pio_sector(ap);
- break;
-
- case THR_PIO_LAST:
- ata_pio_complete(ap);
- break;
-
- case THR_PIO_POLL:
- case THR_PIO_LAST_POLL:
- timeout = ata_pio_poll(ap);
- break;
-
- case THR_PIO_TMOUT:
- printk(KERN_ERR "ata%d: FIXME: THR_PIO_TMOUT\n", /* FIXME */
- ap->id);
- timeout = 11 * HZ;
- break;
-
- case THR_PIO_ERR:
- printk(KERN_ERR "ata%d: FIXME: THR_PIO_ERR\n", /* FIXME */
- ap->id);
- timeout = 11 * HZ;
- break;
-
- case THR_PACKET:
- atapi_cdb_send(ap);
- break;
-
- default:
- printk(KERN_DEBUG "ata%u: unknown thr state %s\n",
- ap->id, ata_thr_state_name(ap->thr_state));
- break;
- }
-
- DPRINTK("ata%u: new thr_state %s, returning %ld\n",
- ap->id, ata_thr_state_name(ap->thr_state), timeout);
- return timeout;
-}
-
-/**
- * ata_thread -
- * @data:
- *
- * LOCKING:
- *
- * RETURNS:
- *
- */
-
-static int ata_thread (void *data)
-{
- struct ata_port *ap = data;
- long timeout;
-
- daemonize ("katad-%u", ap->id);
- allow_signal(SIGTERM);
-
- while (1) {
- cond_resched();
-
- timeout = ata_thread_iter(ap);
-
- if (signal_pending (current))
- flush_signals(current);
-
- if (current->flags & PF_FREEZE)
- refrigerator(PF_FREEZE);
-
-
- if ((timeout < 0) || (ap->time_to_die))
- break;
-
- /* note sleeping for full timeout not guaranteed (that's ok) */
- if (timeout) {
- mod_timer(&ap->thr_timer, jiffies + timeout);
- down_interruptible(&ap->thr_sem);
-
- if (signal_pending (current))
- flush_signals(current);
-
- if (ap->time_to_die)
- break;
- }
- }
-
- printk(KERN_DEBUG "ata%u: thread exiting\n", ap->id);
- ap->thr_pid = -1;
- del_timer_sync(&ap->thr_timer);
- complete_and_exit (&ap->thr_exited, 0);
-}
-
-/**
- * ata_thread_kill - kill per-port kernel thread
- * @ap: port those thread is to be killed
- *
- * LOCKING:
- *
- */
-
-static int ata_thread_kill(struct ata_port *ap)
-{
- int ret = 0;
-
- if (ap->thr_pid >= 0) {
- ap->time_to_die = 1;
- wmb();
- ret = kill_proc(ap->thr_pid, SIGTERM, 1);
- if (ret)
- printk(KERN_ERR "ata%d: unable to kill kernel thread\n",
- ap->id);
- else
- wait_for_completion(&ap->thr_exited);
- }
-
- return ret;
-}
-
-/**
- * atapi_cdb_send - Write CDB bytes to hardware
- * @ap: Port to which ATAPI device is attached.
+ * atapi_packet_task - Write CDB bytes to hardware
+ * @_data: Port to which ATAPI device is attached.
*
* When device has indicated its readiness to accept
* a CDB, this function is called. Send the CDB.
* Kernel thread context (may sleep)
*/
-static void atapi_cdb_send(struct ata_port *ap)
+static void atapi_packet_task(void *_data)
{
+ struct ata_port *ap = _data;
struct ata_queued_cmd *qc;
u8 status;
/* make sure DRQ is set */
status = ata_chk_status(ap);
- if ((status & ATA_DRQ) == 0)
+ if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
goto err_out;
/* send SCSI cdb */
- /* FIXME: mmio-ize */
DPRINTK("send cdb\n");
- outsl(ap->ioaddr.data_addr,
- qc->scsicmd->cmnd, ap->host->max_cmd_len / 4);
+ assert(ap->cdb_len >= 12);
+ ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
/* if we are DMA'ing, irq handler takes over from here */
- if (qc->tf.feature == ATAPI_PKT_DMA)
- goto out;
-
- /* sleep-wait for BSY to clear */
- DPRINTK("busy wait 2\n");
- if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
- goto err_out;
+ if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
+ ap->ops->bmdma_start(qc); /* initiate bmdma */
- /* wait for BSY,DRQ to clear */
- status = ata_wait_idle(ap);
- if (status & (ATA_BUSY | ATA_DRQ))
- goto err_out;
+ /* non-data commands are also handled via irq */
+ else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
+ /* do nothing */
+ }
- /* transaction completed, indicate such to scsi stack */
- ata_qc_complete(qc, status, 0);
- ata_irq_on(ap);
+ /* PIO commands are handled by polling */
+ else {
+ ap->pio_task_state = PIO_ST;
+ queue_work(ata_wq, &ap->pio_task);
+ }
-out:
- ap->thr_state = THR_IDLE;
return;
err_out:
- ata_qc_complete(qc, ATA_ERR, 0);
- goto out;
+ ata_qc_complete(qc, ATA_ERR);
}
int ata_port_start (struct ata_port *ap)
{
- struct pci_dev *pdev = ap->host_set->pdev;
+ struct device *dev = ap->host_set->dev;
- ap->prd = pci_alloc_consistent(pdev, ATA_PRD_TBL_SZ, &ap->prd_dma);
+ ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
if (!ap->prd)
return -ENOMEM;
-
+
DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
return 0;
void ata_port_stop (struct ata_port *ap)
{
- struct pci_dev *pdev = ap->host_set->pdev;
+ struct device *dev = ap->host_set->dev;
- pci_free_consistent(pdev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
+ dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
}
/**
- * ata_host_remove -
- * @ap:
- * @do_unregister:
+ * ata_host_remove - Unregister SCSI host structure with upper layers
+ * @ap: Port to unregister
+ * @do_unregister: 1 if we fully unregister, 0 to just stop the port
*
* LOCKING:
*/
if (do_unregister)
scsi_remove_host(sh);
- ata_thread_kill(ap); /* FIXME: check return val */
-
ap->ops->port_stop(ap);
}
/**
- * ata_host_init -
- * @host:
- * @ent:
- * @port_no:
+ * ata_host_init - Initialize an ata_port structure
+ * @ap: Structure to initialize
+ * @host: associated SCSI mid-layer structure
+ * @host_set: Collection of hosts to which @ap belongs
+ * @ent: Probe information provided by low-level driver
+ * @port_no: Port number associated with this ata_port
*
* LOCKING:
*
host->max_channel = 1;
host->unique_id = ata_unique_id++;
host->max_cmd_len = 12;
- scsi_set_device(host, &ent->pdev->dev);
+ scsi_set_device(host, ent->dev);
scsi_assign_lock(host, &host_set->lock);
ap->flags = ATA_FLAG_PORT_DISABLED;
ap->ctl = ATA_DEVCTL_OBS;
ap->host_set = host_set;
ap->port_no = port_no;
+ ap->hard_port_no =
+ ent->legacy_mode ? ent->hard_port_no : port_no;
ap->pio_mask = ent->pio_mask;
+ ap->mwdma_mask = ent->mwdma_mask;
ap->udma_mask = ent->udma_mask;
ap->flags |= ent->host_flags;
ap->ops = ent->port_ops;
- ap->thr_state = THR_PROBE_START;
ap->cbl = ATA_CBL_NONE;
- ap->device[0].flags = ATA_DFLAG_MASTER;
ap->active_tag = ATA_TAG_POISON;
ap->last_ctl = 0xFF;
- /* ata_engine init */
- ap->eng.flags = 0;
- INIT_LIST_HEAD(&ap->eng.q);
+ INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
+ INIT_WORK(&ap->pio_task, ata_pio_task, ap);
for (i = 0; i < ATA_MAX_DEVICES; i++)
ap->device[i].devno = i;
- init_completion(&ap->thr_exited);
- init_MUTEX_LOCKED(&ap->probe_sem);
- init_MUTEX_LOCKED(&ap->sem);
- init_MUTEX_LOCKED(&ap->thr_sem);
-
- init_timer(&ap->thr_timer);
- ap->thr_timer.function = ata_thread_timer;
- ap->thr_timer.data = (unsigned long) ap;
-
#ifdef ATA_IRQ_TRAP
ap->stats.unhandled_irq = 1;
ap->stats.idle_irq = 1;
}
/**
- * ata_host_add -
- * @ent:
- * @host_set:
- * @port_no:
+ * ata_host_add - Attach low-level ATA driver to system
+ * @ent: Information provided by low-level driver
+ * @host_set: Collections of ports to which we add
+ * @port_no: Port number associated with this host
*
* LOCKING:
*
if (rc)
goto err_out;
- ap->thr_pid = kernel_thread(ata_thread, ap, CLONE_FS | CLONE_FILES);
- if (ap->thr_pid < 0) {
- printk(KERN_ERR "ata%d: unable to start kernel thread\n",
- ap->id);
- goto err_out_free;
- }
-
return ap;
-err_out_free:
- ap->ops->port_stop(ap);
-
err_out:
scsi_host_put(host);
return NULL;
int ata_device_add(struct ata_probe_ent *ent)
{
unsigned int count = 0, i;
- struct pci_dev *pdev = ent->pdev;
+ struct device *dev = ent->dev;
struct ata_host_set *host_set;
DPRINTK("ENTER\n");
memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
spin_lock_init(&host_set->lock);
- host_set->pdev = pdev;
+ host_set->dev = dev;
host_set->n_ports = ent->n_ports;
host_set->irq = ent->irq;
host_set->mmio_base = ent->mmio_base;
host_set->private_data = ent->private_data;
+ host_set->ops = ent->port_ops;
/* register each port bound to this device */
for (i = 0; i < ent->n_ports; i++) {
struct ata_port *ap;
+ unsigned long xfer_mode_mask;
ap = ata_host_add(ent, host_set, i);
if (!ap)
goto err_out;
host_set->ports[i] = ap;
+ xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
+ (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
+ (ap->pio_mask << ATA_SHIFT_PIO);
/* print per-port info to dmesg */
printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
"bmdma 0x%lX irq %lu\n",
ap->id,
ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
- ata_udma_string(ent->udma_mask),
+ ata_mode_string(xfer_mode_mask),
ap->ioaddr.cmd_addr,
ap->ioaddr.ctl_addr,
ap->ioaddr.bmdma_addr,
ent->irq);
+ ata_chk_status(ap);
+ host_set->ops->irq_clear(ap);
count++;
}
ap = host_set->ports[i];
DPRINTK("ata%u: probe begin\n", ap->id);
- up(&ap->sem); /* start probe */
-
- DPRINTK("ata%u: probe-wait begin\n", ap->id);
- down(&ap->probe_sem); /* wait for end */
+ rc = ata_bus_probe(ap);
+ DPRINTK("ata%u: probe end\n", ap->id);
- DPRINTK("ata%u: probe-wait end\n", ap->id);
+ if (rc) {
+ /* FIXME: do something useful here?
+ * Current libata behavior will
+ * tear down everything when
+ * the module is removed
+ * or the h/w is unplugged.
+ */
+ }
- rc = scsi_add_host(ap->host, &pdev->dev);
+ rc = scsi_add_host(ap->host, dev);
if (rc) {
printk(KERN_ERR "ata%u: scsi_add_host failed\n",
ap->id);
scsi_scan_host(ap->host);
}
- pci_set_drvdata(pdev, host_set);
+ dev_set_drvdata(dev, host_set);
VPRINTK("EXIT, returning %u\n", ent->n_ports);
return ent->n_ports; /* success */
* ata_scsi_release - SCSI layer callback hook for host unload
* @host: libata host to be unloaded
*
- * Performs all duties necessary to shut down a libata port:
+ * Performs all duties necessary to shut down a libata port...
* Kill port kthread, disable port, and release resources.
*
* LOCKING:
/**
* ata_std_ports - initialize ioaddr with standard port offsets.
- * @ioaddr:
+ * @ioaddr: IO address structure to be initialized
*/
void ata_std_ports(struct ata_ioports *ioaddr)
{
ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
}
+static struct ata_probe_ent *
+ata_probe_ent_alloc(int n, struct device *dev, struct ata_port_info **port)
+{
+ struct ata_probe_ent *probe_ent;
+ int i;
+
+ probe_ent = kmalloc(sizeof(*probe_ent) * n, GFP_KERNEL);
+ if (!probe_ent) {
+ printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
+ kobject_name(&(dev->kobj)));
+ return NULL;
+ }
+
+ memset(probe_ent, 0, sizeof(*probe_ent) * n);
+
+ for (i = 0; i < n; i++) {
+ INIT_LIST_HEAD(&probe_ent[i].node);
+ probe_ent[i].dev = dev;
+
+ probe_ent[i].sht = port[i]->sht;
+ probe_ent[i].host_flags = port[i]->host_flags;
+ probe_ent[i].pio_mask = port[i]->pio_mask;
+ probe_ent[i].mwdma_mask = port[i]->mwdma_mask;
+ probe_ent[i].udma_mask = port[i]->udma_mask;
+ probe_ent[i].port_ops = port[i]->port_ops;
+
+ }
+
+ return probe_ent;
+}
+
+#ifdef CONFIG_PCI
+struct ata_probe_ent *
+ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
+{
+ struct ata_probe_ent *probe_ent =
+ ata_probe_ent_alloc(1, pci_dev_to_dev(pdev), port);
+ if (!probe_ent)
+ return NULL;
+
+ probe_ent->n_ports = 2;
+ probe_ent->irq = pdev->irq;
+ probe_ent->irq_flags = SA_SHIRQ;
+
+ probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
+ probe_ent->port[0].altstatus_addr =
+ probe_ent->port[0].ctl_addr =
+ pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
+ probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
+
+ probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
+ probe_ent->port[1].altstatus_addr =
+ probe_ent->port[1].ctl_addr =
+ pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
+ probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
+
+ ata_std_ports(&probe_ent->port[0]);
+ ata_std_ports(&probe_ent->port[1]);
+
+ return probe_ent;
+}
+
+struct ata_probe_ent *
+ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port)
+{
+ struct ata_probe_ent *probe_ent =
+ ata_probe_ent_alloc(2, pci_dev_to_dev(pdev), port);
+ if (!probe_ent)
+ return NULL;
+
+ probe_ent[0].n_ports = 1;
+ probe_ent[0].irq = 14;
+
+ probe_ent[0].hard_port_no = 0;
+ probe_ent[0].legacy_mode = 1;
+
+ probe_ent[1].n_ports = 1;
+ probe_ent[1].irq = 15;
+
+ probe_ent[1].hard_port_no = 1;
+ probe_ent[1].legacy_mode = 1;
+
+ probe_ent[0].port[0].cmd_addr = 0x1f0;
+ probe_ent[0].port[0].altstatus_addr =
+ probe_ent[0].port[0].ctl_addr = 0x3f6;
+ probe_ent[0].port[0].bmdma_addr = pci_resource_start(pdev, 4);
+
+ probe_ent[1].port[0].cmd_addr = 0x170;
+ probe_ent[1].port[0].altstatus_addr =
+ probe_ent[1].port[0].ctl_addr = 0x376;
+ probe_ent[1].port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
+
+ ata_std_ports(&probe_ent[0].port[0]);
+ ata_std_ports(&probe_ent[1].port[0]);
+
+ return probe_ent;
+}
+
/**
- * ata_pci_init_one -
- * @pdev:
- * @port_info:
- * @n_ports:
+ * ata_pci_init_one - Initialize/register PCI IDE host controller
+ * @pdev: Controller to be initialized
+ * @port_info: Information from low-level host driver
+ * @n_ports: Number of ports attached to host controller
*
* LOCKING:
* Inherited from PCI layer (may sleep).
unsigned int n_ports)
{
struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
- struct ata_port_info *port0, *port1;
+ struct ata_port_info *port[2];
u8 tmp8, mask;
unsigned int legacy_mode = 0;
int rc;
DPRINTK("ENTER\n");
- port0 = port_info[0];
+ port[0] = port_info[0];
if (n_ports > 1)
- port1 = port_info[1];
+ port[1] = port_info[1];
else
- port1 = port0;
+ port[1] = port[0];
- if ((port0->host_flags & ATA_FLAG_NO_LEGACY) == 0) {
+ if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0) {
/* TODO: support transitioning to native mode? */
pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
mask = (1 << 2) | (1 << 0);
if (rc)
goto err_out_regions;
- probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
+ if (legacy_mode) {
+ probe_ent = ata_pci_init_legacy_mode(pdev, port);
+ if (probe_ent)
+ probe_ent2 = &probe_ent[1];
+ } else
+ probe_ent = ata_pci_init_native_mode(pdev, port);
if (!probe_ent) {
rc = -ENOMEM;
goto err_out_regions;
}
- memset(probe_ent, 0, sizeof(*probe_ent));
- probe_ent->pdev = pdev;
- INIT_LIST_HEAD(&probe_ent->node);
-
- if (legacy_mode) {
- probe_ent2 = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
- if (!probe_ent2) {
- rc = -ENOMEM;
- goto err_out_free_ent;
- }
-
- memset(probe_ent2, 0, sizeof(*probe_ent));
- probe_ent2->pdev = pdev;
- INIT_LIST_HEAD(&probe_ent2->node);
- }
-
- probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
- probe_ent->sht = port0->sht;
- probe_ent->host_flags = port0->host_flags;
- probe_ent->pio_mask = port0->pio_mask;
- probe_ent->udma_mask = port0->udma_mask;
- probe_ent->port_ops = port0->port_ops;
-
- if (legacy_mode) {
- probe_ent->port[0].cmd_addr = 0x1f0;
- probe_ent->port[0].altstatus_addr =
- probe_ent->port[0].ctl_addr = 0x3f6;
- probe_ent->n_ports = 1;
- probe_ent->irq = 14;
- ata_std_ports(&probe_ent->port[0]);
-
- probe_ent2->port[0].cmd_addr = 0x170;
- probe_ent2->port[0].altstatus_addr =
- probe_ent2->port[0].ctl_addr = 0x376;
- probe_ent2->port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
- probe_ent2->n_ports = 1;
- probe_ent2->irq = 15;
- ata_std_ports(&probe_ent2->port[0]);
-
- probe_ent2->sht = port1->sht;
- probe_ent2->host_flags = port1->host_flags;
- probe_ent2->pio_mask = port1->pio_mask;
- probe_ent2->udma_mask = port1->udma_mask;
- probe_ent2->port_ops = port1->port_ops;
- } else {
- probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
- ata_std_ports(&probe_ent->port[0]);
- probe_ent->port[0].altstatus_addr =
- probe_ent->port[0].ctl_addr =
- pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
-
- probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
- ata_std_ports(&probe_ent->port[1]);
- probe_ent->port[1].altstatus_addr =
- probe_ent->port[1].ctl_addr =
- pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
- probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
-
- probe_ent->n_ports = 2;
- probe_ent->irq = pdev->irq;
- probe_ent->irq_flags = SA_SHIRQ;
- }
-
pci_set_master(pdev);
/* FIXME: check ata_device_add return */
ata_device_add(probe_ent);
if (legacy_mode & (1 << 1))
ata_device_add(probe_ent2);
- kfree(probe_ent2);
} else {
ata_device_add(probe_ent);
- assert(probe_ent2 == NULL);
}
kfree(probe_ent);
return 0;
-err_out_free_ent:
- kfree(probe_ent);
err_out_regions:
if (legacy_mode & (1 << 0))
release_region(0x1f0, 8);
void ata_pci_remove_one (struct pci_dev *pdev)
{
- struct ata_host_set *host_set = pci_get_drvdata(pdev);
+ struct device *dev = pci_dev_to_dev(pdev);
+ struct ata_host_set *host_set = dev_get_drvdata(dev);
struct ata_port *ap;
unsigned int i;
}
free_irq(host_set->irq, host_set);
+ if (host_set->ops->host_stop)
+ host_set->ops->host_stop(host_set);
if (host_set->mmio_base)
iounmap(host_set->mmio_base);
- if (host_set->ports[0]->ops->host_stop)
- host_set->ports[0]->ops->host_stop(host_set);
for (i = 0; i < host_set->n_ports; i++) {
ap = host_set->ports[i];
kfree(host_set);
pci_disable_device(pdev);
- pci_set_drvdata(pdev, NULL);
+ dev_set_drvdata(dev, NULL);
}
/* move to PCI subsystem */
return (tmp == bits->val) ? 1 : 0;
}
+#endif /* CONFIG_PCI */
/**
static int __init ata_init(void)
{
+ ata_wq = create_workqueue("ata");
+ if (!ata_wq)
+ return -ENOMEM;
+
printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
return 0;
}
+static void __exit ata_exit(void)
+{
+ destroy_workqueue(ata_wq);
+}
+
module_init(ata_init);
+module_exit(ata_exit);
/*
* libata is essentially a library of internal helper functions for
* Do not depend on ABI/API stability.
*/
-EXPORT_SYMBOL_GPL(pci_test_config_bits);
EXPORT_SYMBOL_GPL(ata_std_bios_param);
EXPORT_SYMBOL_GPL(ata_std_ports);
EXPORT_SYMBOL_GPL(ata_device_add);
+EXPORT_SYMBOL_GPL(ata_sg_init);
+EXPORT_SYMBOL_GPL(ata_sg_init_one);
EXPORT_SYMBOL_GPL(ata_qc_complete);
+EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
EXPORT_SYMBOL_GPL(ata_eng_timeout);
-EXPORT_SYMBOL_GPL(ata_tf_load_pio);
-EXPORT_SYMBOL_GPL(ata_tf_load_mmio);
-EXPORT_SYMBOL_GPL(ata_tf_read_pio);
-EXPORT_SYMBOL_GPL(ata_tf_read_mmio);
-EXPORT_SYMBOL_GPL(ata_check_status_pio);
-EXPORT_SYMBOL_GPL(ata_check_status_mmio);
-EXPORT_SYMBOL_GPL(ata_exec_command_pio);
-EXPORT_SYMBOL_GPL(ata_exec_command_mmio);
+EXPORT_SYMBOL_GPL(ata_tf_load);
+EXPORT_SYMBOL_GPL(ata_tf_read);
+EXPORT_SYMBOL_GPL(ata_noop_dev_select);
+EXPORT_SYMBOL_GPL(ata_std_dev_select);
+EXPORT_SYMBOL_GPL(ata_tf_to_fis);
+EXPORT_SYMBOL_GPL(ata_tf_from_fis);
+EXPORT_SYMBOL_GPL(ata_check_status);
+EXPORT_SYMBOL_GPL(ata_exec_command);
EXPORT_SYMBOL_GPL(ata_port_start);
EXPORT_SYMBOL_GPL(ata_port_stop);
EXPORT_SYMBOL_GPL(ata_interrupt);
-EXPORT_SYMBOL_GPL(ata_fill_sg);
-EXPORT_SYMBOL_GPL(ata_bmdma_start_pio);
-EXPORT_SYMBOL_GPL(ata_bmdma_start_mmio);
+EXPORT_SYMBOL_GPL(ata_qc_prep);
+EXPORT_SYMBOL_GPL(ata_bmdma_setup);
+EXPORT_SYMBOL_GPL(ata_bmdma_start);
+EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
EXPORT_SYMBOL_GPL(ata_port_probe);
EXPORT_SYMBOL_GPL(sata_phy_reset);
+EXPORT_SYMBOL_GPL(__sata_phy_reset);
EXPORT_SYMBOL_GPL(ata_bus_reset);
EXPORT_SYMBOL_GPL(ata_port_disable);
-EXPORT_SYMBOL_GPL(ata_pci_init_one);
-EXPORT_SYMBOL_GPL(ata_pci_remove_one);
+EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
EXPORT_SYMBOL_GPL(ata_scsi_error);
EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
EXPORT_SYMBOL_GPL(ata_scsi_release);
EXPORT_SYMBOL_GPL(ata_host_intr);
+EXPORT_SYMBOL_GPL(ata_dev_classify);
+EXPORT_SYMBOL_GPL(ata_dev_id_string);
+EXPORT_SYMBOL_GPL(ata_scsi_simulate);
+
+#ifdef CONFIG_PCI
+EXPORT_SYMBOL_GPL(pci_test_config_bits);
+EXPORT_SYMBOL_GPL(ata_pci_init_legacy_mode);
+EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
+EXPORT_SYMBOL_GPL(ata_pci_init_one);
+EXPORT_SYMBOL_GPL(ata_pci_remove_one);
+#endif /* CONFIG_PCI */
git://git.onelab.eu / linux-2.6.git / blobdiff