Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/libata-dev (6edad161) · Commits · 戴 / test

Documentation/DocBook/libata.tmpl

+80 −24

Original line number	Diff line number	Diff line
		@@ -169,6 +169,22 @@ void (tf_read) (struct ata_port ap, struct ata_taskfile *tf);

		</sect2>

		<sect2><title>PIO data read/write</title>
		<programlisting>
		void (data_xfer) (struct ata_device , unsigned char *, unsigned int, int);
		</programlisting>

		<para>
		All bmdma-style drivers must implement this hook. This is the low-level
		operation that actually copies the data bytes during a PIO data
		transfer.
		Typically the driver
		will choose one of ata_pio_data_xfer_noirq(), ata_pio_data_xfer(), or
		ata_mmio_data_xfer().
		</para>

		</sect2>

		<sect2><title>ATA command execute</title>
		<programlisting>
		void (exec_command)(struct ata_port ap, struct ata_taskfile *tf);
		@@ -204,11 +220,10 @@ command.
		<programlisting>
		u8 (check_status)(struct ata_port ap);
		u8 (check_altstatus)(struct ata_port ap);
		u8 (check_err)(struct ata_port ap);
		</programlisting>

		<para>
		Reads the Status/AltStatus/Error ATA shadow register from
		Reads the Status/AltStatus ATA shadow register from
		hardware. On some hardware, reading the Status register has
		the side effect of clearing the interrupt condition.
		Most drivers for taskfile-based hardware use
		@@ -269,23 +284,6 @@ void (set_mode) (struct ata_port ap);

		</sect2>

		<sect2><title>Reset ATA bus</title>
		<programlisting>
		void (phy_reset) (struct ata_port ap);
		</programlisting>

		<para>
		The very first step in the probe phase. Actions vary depending
		on the bus type, typically. After waking up the device and probing
		for device presence (PATA and SATA), typically a soft reset
		(SRST) will be performed. Drivers typically use the helper
		functions ata_bus_reset() or sata_phy_reset() for this hook.
		Many SATA drivers use sata_phy_reset() or call it from within
		their own phy_reset() functions.
		</para>

		</sect2>

		<sect2><title>Control PCI IDE BMDMA engine</title>
		<programlisting>
		void (bmdma_setup) (struct ata_queued_cmd qc);
		@@ -354,16 +352,74 @@ int (qc_issue) (struct ata_queued_cmd qc);

		</sect2>

		<sect2><title>Timeout (error) handling</title>
		<sect2><title>Exception and probe handling (EH)</title>
		<programlisting>
		void (eng_timeout) (struct ata_port ap);
		void (phy_reset) (struct ata_port ap);
		</programlisting>

		<para>
		Deprecated. Use ->error_handler() instead.
		</para>

		<programlisting>
		void (freeze) (struct ata_port ap);
		void (thaw) (struct ata_port ap);
		</programlisting>

		<para>
		ata_port_freeze() is called when HSM violations or some other
		condition disrupts normal operation of the port. A frozen port
		is not allowed to perform any operation until the port is
		thawed, which usually follows a successful reset.
		</para>

		<para>
		The optional ->freeze() callback can be used for freezing the port
		hardware-wise (e.g. mask interrupt and stop DMA engine). If a
		port cannot be frozen hardware-wise, the interrupt handler
		must ack and clear interrupts unconditionally while the port
		is frozen.
		</para>
		<para>
		The optional ->thaw() callback is called to perform the opposite of ->freeze():
		prepare the port for normal operation once again. Unmask interrupts,
		start DMA engine, etc.
		</para>

		<programlisting>
		void (error_handler) (struct ata_port ap);
		</programlisting>

		<para>
		->error_handler() is a driver's hook into probe, hotplug, and recovery
		and other exceptional conditions. The primary responsibility of an
		implementation is to call ata_do_eh() or ata_bmdma_drive_eh() with a set
		of EH hooks as arguments:
		</para>

		<para>
		'prereset' hook (may be NULL) is called during an EH reset, before any other actions
		are taken.
		</para>

		<para>
		'postreset' hook (may be NULL) is called after the EH reset is performed. Based on
		existing conditions, severity of the problem, and hardware capabilities,
		</para>

		<para>
		Either 'softreset' (may be NULL) or 'hardreset' (may be NULL) will be
		called to perform the low-level EH reset.
		</para>

		<programlisting>
		void (post_internal_cmd) (struct ata_queued_cmd qc);
		</programlisting>

		<para>
		This is a high level error handling function, called from the
		error handling thread, when a command times out. Most newer
		hardware will implement its own error handling code here. IDE BMDMA
		drivers may use the helper function ata_eng_timeout().
		Perform any hardware-specific actions necessary to finish processing
		after executing a probe-time or EH-time command via ata_exec_internal().
		</para>

		</sect2>

drivers/ide/pci/amd74xx.c

+5 −2

Original line number	Diff line number	Diff line
		@@ -74,6 +74,7 @@ static struct amd_ide_chip {
		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, 0x50, AMD_UDMA_133 },
		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, 0x50, AMD_UDMA_133 },
		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, 0x50, AMD_UDMA_133 },
		{ PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, 0x50, AMD_UDMA_133 },
		{ PCI_DEVICE_ID_AMD_CS5536_IDE, 0x40, AMD_UDMA_100 },
		{ 0 }
		};
		@@ -488,7 +489,8 @@ static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
		/* 14 */ DECLARE_NV_DEV("NFORCE-MCP04"),
		/* 15 */ DECLARE_NV_DEV("NFORCE-MCP51"),
		/* 16 */ DECLARE_NV_DEV("NFORCE-MCP55"),
		/* 17 */ DECLARE_AMD_DEV("AMD5536"),
		/* 17 */ DECLARE_NV_DEV("NFORCE-MCP61"),
		/* 18 */ DECLARE_AMD_DEV("AMD5536"),
		};

		static int __devinit amd74xx_probe(struct pci_dev dev, const struct pci_device_id id)
		@@ -525,7 +527,8 @@ static struct pci_device_id amd74xx_pci_tbl[] = {
		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 },
		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 },
		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 16 },
		{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 17 },
		{ PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 17 },
		{ PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 18 },
		{ 0, },
		};
		MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);

drivers/scsi/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -165,7 +165,7 @@ ncr53c8xx-flags-$(CONFIG_SCSI_ZALON) \
		CFLAGS_ncr53c8xx.o := $(ncr53c8xx-flags-y) $(ncr53c8xx-flags-m)
		zalon7xx-objs := zalon.o ncr53c8xx.o
		NCR_Q720_mod-objs := NCR_Q720.o ncr53c8xx.o
		libata-objs := libata-core.o libata-scsi.o libata-bmdma.o
		libata-objs := libata-core.o libata-scsi.o libata-bmdma.o libata-eh.o
		oktagon_esp_mod-objs := oktagon_esp.o oktagon_io.o

		# Files generated that shall be removed upon make clean

drivers/scsi/ahci.c

+313 −190

File changed.

Preview size limit exceeded, changes collapsed.

drivers/scsi/ata_piix.c

+50 −62

Original line number	Diff line number	Diff line
		@@ -93,7 +93,7 @@
		#include <linux/libata.h>

		#define DRV_NAME "ata_piix"
		#define DRV_VERSION "1.05"
		#define DRV_VERSION "1.10"

		enum {
		PIIX_IOCFG = 0x54, /* IDE I/O configuration register */
		@@ -146,11 +146,10 @@ struct piix_map_db {

		static int piix_init_one (struct pci_dev *pdev,
		const struct pci_device_id *ent);

		static int piix_pata_probe_reset(struct ata_port ap, unsigned int classes);
		static int piix_sata_probe_reset(struct ata_port ap, unsigned int classes);
		static void piix_set_piomode (struct ata_port ap, struct ata_device adev);
		static void piix_set_dmamode (struct ata_port ap, struct ata_device adev);
		static void piix_pata_error_handler(struct ata_port *ap);
		static void piix_sata_error_handler(struct ata_port *ap);

		static unsigned int in_module_init = 1;

		@@ -159,6 +158,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
		{ 0x8086, 0x7111, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix4_pata },
		{ 0x8086, 0x24db, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
		{ 0x8086, 0x25a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
		{ 0x8086, 0x27df, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
		#endif

		/* NOTE: The following PCI ids must be kept in sync with the
		@@ -218,6 +218,7 @@ static struct scsi_host_template piix_sht = {
		.proc_name = DRV_NAME,
		.dma_boundary = ATA_DMA_BOUNDARY,
		.slave_configure = ata_scsi_slave_config,
		.slave_destroy = ata_scsi_slave_destroy,
		.bios_param = ata_std_bios_param,
		.resume = ata_scsi_device_resume,
		.suspend = ata_scsi_device_suspend,
		@@ -227,6 +228,7 @@ static const struct ata_port_operations piix_pata_ops = {
		.port_disable = ata_port_disable,
		.set_piomode = piix_set_piomode,
		.set_dmamode = piix_set_dmamode,
		.mode_filter = ata_pci_default_filter,

		.tf_load = ata_tf_load,
		.tf_read = ata_tf_read,
		@@ -234,16 +236,18 @@ static const struct ata_port_operations piix_pata_ops = {
		.exec_command = ata_exec_command,
		.dev_select = ata_std_dev_select,

		.probe_reset = piix_pata_probe_reset,

		.bmdma_setup = ata_bmdma_setup,
		.bmdma_start = ata_bmdma_start,
		.bmdma_stop = ata_bmdma_stop,
		.bmdma_status = ata_bmdma_status,
		.qc_prep = ata_qc_prep,
		.qc_issue = ata_qc_issue_prot,
		.data_xfer = ata_pio_data_xfer,

		.eng_timeout = ata_eng_timeout,
		.freeze = ata_bmdma_freeze,
		.thaw = ata_bmdma_thaw,
		.error_handler = piix_pata_error_handler,
		.post_internal_cmd = ata_bmdma_post_internal_cmd,

		.irq_handler = ata_interrupt,
		.irq_clear = ata_bmdma_irq_clear,
		@@ -262,16 +266,18 @@ static const struct ata_port_operations piix_sata_ops = {
		.exec_command = ata_exec_command,
		.dev_select = ata_std_dev_select,

		.probe_reset = piix_sata_probe_reset,

		.bmdma_setup = ata_bmdma_setup,
		.bmdma_start = ata_bmdma_start,
		.bmdma_stop = ata_bmdma_stop,
		.bmdma_status = ata_bmdma_status,
		.qc_prep = ata_qc_prep,
		.qc_issue = ata_qc_issue_prot,
		.data_xfer = ata_pio_data_xfer,

		.eng_timeout = ata_eng_timeout,
		.freeze = ata_bmdma_freeze,
		.thaw = ata_bmdma_thaw,
		.error_handler = piix_sata_error_handler,
		.post_internal_cmd = ata_bmdma_post_internal_cmd,

		.irq_handler = ata_interrupt,
		.irq_clear = ata_bmdma_irq_clear,
		@@ -455,59 +461,51 @@ cbl40:
		}

		/**
		* piix_pata_probeinit - probeinit for PATA host controller
		* piix_pata_prereset - prereset for PATA host controller
		* @ap: Target port
		*
		* Probeinit including cable detection.
		* Prereset including cable detection.
		*
		* LOCKING:
		* None (inherited from caller).
		*/
		static void piix_pata_probeinit(struct ata_port *ap)
		{
		piix_pata_cbl_detect(ap);
		ata_std_probeinit(ap);
		}

		/**
		* piix_pata_probe_reset - Perform reset on PATA port and classify
		* @ap: Port to reset
		* @classes: Resulting classes of attached devices
		*
		* Reset PATA phy and classify attached devices.
		*
		* LOCKING:
		* None (inherited from caller).
		*/
		static int piix_pata_probe_reset(struct ata_port ap, unsigned int classes)
		static int piix_pata_prereset(struct ata_port *ap)
		{
		struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);

		if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->hard_port_no])) {
		printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
		ata_port_printk(ap, KERN_INFO, "port disabled. ignoring.\n");
		ap->eh_context.i.action &= ~ATA_EH_RESET_MASK;
		return 0;
		}

		return ata_drive_probe_reset(ap, piix_pata_probeinit,
		ata_std_softreset, NULL,
		ata_std_postreset, classes);
		piix_pata_cbl_detect(ap);

		return ata_std_prereset(ap);
		}

		static void piix_pata_error_handler(struct ata_port *ap)
		{
		ata_bmdma_drive_eh(ap, piix_pata_prereset, ata_std_softreset, NULL,
		ata_std_postreset);
		}

		/**
		* piix_sata_probe - Probe PCI device for present SATA devices
		* @ap: Port associated with the PCI device we wish to probe
		* piix_sata_prereset - prereset for SATA host controller
		* @ap: Target port
		*
		* Reads and configures SATA PCI device's PCI config register
		* Port Configuration and Status (PCS) to determine port and
		* device availability.
		* device availability. Return -ENODEV to skip reset if no
		* device is present.
		*
		* LOCKING:
		* None (inherited from caller).
		*
		* RETURNS:
		* Mask of avaliable devices on the port.
		* 0 if device is present, -ENODEV otherwise.
		*/
		static unsigned int piix_sata_probe (struct ata_port *ap)
		static int piix_sata_prereset(struct ata_port *ap)
		{
		struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
		const unsigned int *map = ap->host_set->private_data;
		@@ -549,29 +547,19 @@ static unsigned int piix_sata_probe (struct ata_port *ap)
		DPRINTK("ata%u: LEAVE, pcs=0x%x present_mask=0x%x\n",
		ap->id, pcs, present_mask);

		return present_mask;
		if (!present_mask) {
		ata_port_printk(ap, KERN_INFO, "SATA port has no device.\n");
		ap->eh_context.i.action &= ~ATA_EH_RESET_MASK;
		return 0;
		}

		/**
		* piix_sata_probe_reset - Perform reset on SATA port and classify
		* @ap: Port to reset
		* @classes: Resulting classes of attached devices
		*
		* Reset SATA phy and classify attached devices.
		*
		* LOCKING:
		* None (inherited from caller).
		*/
		static int piix_sata_probe_reset(struct ata_port ap, unsigned int classes)
		{
		if (!piix_sata_probe(ap)) {
		printk(KERN_INFO "ata%u: SATA port has no device.\n", ap->id);
		return 0;
		return ata_std_prereset(ap);
		}

		return ata_drive_probe_reset(ap, ata_std_probeinit,
		ata_std_softreset, NULL,
		ata_std_postreset, classes);
		static void piix_sata_error_handler(struct ata_port *ap)
		{
		ata_bmdma_drive_eh(ap, piix_sata_prereset, ata_std_softreset, NULL,
		ata_std_postreset);
		}

		/**

Admin message