libata: implement new initialization model w/ iomap support, take 2

As all the current LLDs are PCI, ata_pci_host_stop() should be used, which BTW is effectively identical to ata_host_stop(). Convert all LLDs to use ata_pci_host_stop() and kill ata_host_stop().

Signed-off-by Tejun Heo <[email protected]>

Quoted 4 lines · Tejun Heo

As all the current LLDs are PCI, ata_pci_host_stop() should be used, which BTW is effectively identical to ata_host_stop(). Convert all LLDs to use ata_pci_host_stop() and kill ata_host_stop().

Quoted 1 line

Signed-off-by Tejun Heo <[email protected]>

This patch is broken because now several drivers which do not do

mmio_base = pci_iomap()

now unconditionally call pci_iounmap().

As all the current LLDs are PCI, ata_pci_host_stop() should be used, which BTW is effectively identical to ata_host_stop(). Convert all LLDs to use ata_pci_host_stop() and kill ata_host_stop().

Quoted 3 lines · Tejun Heo

As all the current LLDs are PCI, ata_pci_host_stop() should be used, which BTW is effectively identical to ata_host_stop(). Convert all LLDs to use ata_pci_host_stop() and kill ata_host_stop().

NAK, they are not equivalent replacements:

* ata_host_stop checks mmio_base before calling iounmap. Most of the drivers you change do not use ioremap (thus it's really a no-op call for them)

* ata_pci_host_stop not only unmaps unconditionally, it calls pci_iounmap(). Only drivers which have previously used pci_iomap() should use this helper.

This patch may make sense later in the patch series, when ata_pci_host_stop presumably works for all iomap-converted drivers, but not really as the first patch?

Separate out ata_host_alloc(), ata_host_add_ports() and ata_host_attach() from ata_device_add(). These functions will be used by new LLD init model where LLD allocates host directly, then intializes and attaches it instead of going through probe_ent.

ata_host_alloc() can be called with NULL @sht which indicates that Scsi_Host association is handled by the caller. This will be used by SAS.

This patch does not introduce behavior changes.

Signed-off-by Tejun Heo <[email protected]>

---
 drivers/ata/libata-core.c |  451 ++++++++++++++++++++++++++++++---------------
 include/linux/libata.h    |    7 +
 2 files changed, 312 insertions(+), 146 deletions(-)

drivers/ata/libata-core.c +0 -0

index d7bf4a1..eeb9dc6 100644

drivers/ata/libata-core.c +112 -35

  *	Initialize a new ata_port structure.
  *
+ *	@ent and @port_no are to support sas interface.  These will be
+ *	removed once sas is converted to use new alloc/init/attach
+ *	interface.
+ *
  *	LOCKING:
  *	Inherited from caller.
  */

@@ -5261,13 +5265,17 @@ void ata_port_init(struct ata_port *ap, 
 	ap->id = ata_unique_id++;
 	ap->ctl = ATA_DEVCTL_OBS;
 	ap->host = host;
-	ap->dev = ent->dev;
-	ap->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->port_flags;
-	ap->ops = ent->port_ops;
+	ap->dev = host->dev;
+
+	if (ent) {
+		ap->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->port_flags;
+		ap->ops = ent->port_ops;
+	}
+
 	ap->hw_sata_spd_limit = UINT_MAX;
 	ap->active_tag = ATA_TAG_POISON;
 	ap->last_ctl = 0xFF;

@@ -5287,10 +5295,7 @@ #endif
 	INIT_LIST_HEAD(&ap->eh_done_q);
 	init_waitqueue_head(&ap->eh_wait_q);
 
-	/* set cable type */
 	ap->cbl = ATA_CBL_NONE;
-	if (ap->flags & ATA_FLAG_SATA)
-		ap->cbl = ATA_CBL_SATA;
 
 	for (i = 0; i < ATA_MAX_DEVICES; i++) {
 		struct ata_device *dev = &ap->device[i];

@@ -5304,7 +5309,12 @@ #ifdef ATA_IRQ_TRAP
 	ap->stats.idle_irq = 1;
 #endif
 
-	memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
+	if (ent) {
+		if (ap->flags & ATA_FLAG_SATA)
+			ap->cbl = ATA_CBL_SATA;
+		memcpy(&ap->ioaddr, &ent->port[port_no],
+		       sizeof(struct ata_ioports));
+	}
 }
 
 /**

@@ -5329,47 +5339,140 @@ static void ata_port_init_shost(struct a
 }
 
 /**
- *	ata_port_add - Attach low-level ATA driver to system
- *	@ent: Information provided by low-level driver
- *	@host: Collections of ports to which we add
- *	@port_no: Port number associated with this host
+ *	ata_port_alloc - allocate and initialize basic ATA port resources
+ *	@host: ATA host this allocated port belongs to
+ *	@sht: template for SCSI host (can be NULL)
  *
- *	Attach low-level ATA driver to system.
+ *	Allocate and initialize basic ATA port resources.
  *
- *	LOCKING:
- *	PCI/etc. bus probe sem.
+ *	If @sht is NULL, SCSI host is not allocated nor freed later
+ *	with the port.  The caller is responsible for associating SCSI
+ *	host.  This is for SAS.
  *
  *	RETURNS:
- *	New ata_port on success, for NULL on error.
+ *	Allocate ATA port on success, NULL on failure.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
  */
-static struct ata_port * ata_port_add(const struct ata_probe_ent *ent,
-				      struct ata_host *host,
-				      unsigned int port_no)
+static struct ata_port *ata_port_alloc(struct ata_host *host,
+				       struct scsi_host_template *sht)
 {
-	struct Scsi_Host *shost;
 	struct ata_port *ap;
 
 	DPRINTK("ENTER\n");
 
-	if (!ent->port_ops->error_handler &&
-	    !(ent->port_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
-		printk(KERN_ERR "ata%u: no reset mechanism available\n",
-		       port_no);
-		return NULL;
+	if (sht) {
+		struct Scsi_Host *shost;
+
+		shost = scsi_host_alloc(sht, sizeof(struct ata_port));
+		if (!shost)
+			return NULL;
+
+		shost->transportt = &ata_scsi_transport_template;
+
+		ap = ata_shost_to_port(shost);
+		ata_port_init_shost(ap, shost);
+
+		ap->pflags |= ATA_PFLAG_SHOST_OWNER;
+	} else {
+		ap = kzalloc(sizeof(*ap), GFP_KERNEL);
+		if (!ap)
+			return NULL;
 	}
 
-	shost = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
-	if (!shost)
+	ata_port_init(ap, host, NULL, 0);
+
+	return ap;
+}
+
+/**
+ *	ata_host_alloc - allocate and init basic ATA host resources
+ *	@dev: generic device this host is associated with
+ *	@sht: template for SCSI host
+ *	@n_ports: number of ATA ports associated with this host (can be 0)
+ *
+ *	Allocate and initialize basic ATA host resources.  LLD calls
+ *	this function to allocate a host, initializes it fully and
+ *	attaches it using ata_host_attach().
+ *
+ *	RETURNS:
+ *	Allocate ATA host on success, NULL on failure.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+struct ata_host *ata_host_alloc(struct device *dev,
+				struct scsi_host_template *sht, int n_ports)
+{
+	struct ata_host *host;
+	size_t sz;
+
+	DPRINTK("ENTER\n");
+
+	/* alloc a container for our list of ATA ports (buses) */
+	sz = sizeof(struct ata_host) + n_ports * sizeof(void *);
+	if (n_ports == 0)
+		sz += ATA_MAX_PORTS * sizeof(void *);
+
+	host = kzalloc(sz, GFP_KERNEL);
+	if (!host)
 		return NULL;
 
-	shost->transportt = &ata_scsi_transport_template;
+	spin_lock_init(&host->lock);
+	host->dev = dev;
 
-	ap = ata_shost_to_port(shost);
+	if (ata_host_add_ports(host, sht, n_ports))
+		goto err_free;
 
-	ata_port_init(ap, host, ent, port_no);
-	ata_port_init_shost(ap, shost);
+	return host;
 
-	return ap;
+ err_free:
+	ata_host_free(host);
+	return NULL;
+}
+
+/**
+ *	ata_host_add_ports - allocate ports to zero-port host
+ *	@host: target ATA host
+ *	@sht: template for SCSI host
+ *	@n_ports: number of ATA ports associated with this host
+ *
+ *	Allocate @n_ports ports and associate them with @host.
+ *	@n_ports must be less than or equal to ATA_MAX_PORTS and @host
+ *	must have been allocated with zero port.  This function is
+ *	used by LLDs which can't determine number of ports at host
+ *	allocation time.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *

drivers/ata/libata-core.c +174 -108

+	/* allocate ports bound to this host */
+	for (i = 0; i < n_ports; i++) {
+		struct ata_port *ap;
+
+		ap = ata_port_alloc(host, sht);
+		if (!ap)
+			return -ENOMEM;
+
+		ap->port_no = i;
+		host->ports[i] = ap;
+	}
+
+	host->n_ports = n_ports;
+
+	return 0;
 }
 
 /**

@@ -5401,6 +5504,9 @@ void ata_host_init(struct ata_host *host
  *	ap->pflags, so this function can be called multiple times.
  *	Ports are guaranteed to get started only once.
  *
+ *	This function also initializes ap->cbl according to
+ *	ATA_FLAG_SATA if cable type isn't set yet.
+ *
  *	LOCKING:
  *	Inherited from calling layer (may sleep).
  *

@@ -5414,6 +5520,11 @@ int ata_host_start(struct ata_host *host
 	for (i = 0; i < host->n_ports; i++) {
 		struct ata_port *ap = host->ports[i];
 
+		/* set cable type */
+		if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
+			ap->cbl = ATA_CBL_SATA;
+
+		/* start ports */
 		if (ap->pflags & ATA_PFLAG_STARTED)
 			continue;
 

@@ -5430,6 +5541,126 @@ int ata_host_start(struct ata_host *host
 }
 
 /**
+ *	ata_host_attach - attach initialized ATA host
+ *	@host: ATA host to attach
+ *
+ *	Attach initialized ATA host.  @host is allocated using
+ *	ata_host_alloc() and fully initialized by LLD.  This function
+ *	registers @host with ATA and SCSI layers and probe attached
+ *	devices.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+int ata_host_attach(struct ata_host *host)
+{
+	int i, rc;
+
+	/* make sure ports are started */
+	rc = ata_host_start(host);
+	if (rc)
+		return rc;
+
+	/* perform each probe synchronously */
+	DPRINTK("probe begin\n");
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+		int irq_line = host->irq;
+		unsigned long xfer_mode_mask;
+		u32 scontrol;
+		int rc;
+
+		/* report the secondary IRQ for second channel legacy */
+		if (i == 1 && host->irq2)
+			irq_line = host->irq2;
+
+		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 */
+		if (ap->ops != &ata_dummy_port_ops)
+			ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lu "
+					"ctl 0x%lX bmdma 0x%lX irq %d\n",
+					ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
+					ata_mode_string(xfer_mode_mask),
+					ap->ioaddr.cmd_addr,
+					ap->ioaddr.ctl_addr,
+					ap->ioaddr.bmdma_addr, irq_line);
+		else
+			ata_port_printk(ap, KERN_INFO, "DUMMY port\n");
+
+		/* init sata_spd_limit to the current value */
+		if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
+			int spd = (scontrol >> 4) & 0xf;
+			ap->hw_sata_spd_limit &= (1 << spd) - 1;
+		}
+		ap->sata_spd_limit = ap->hw_sata_spd_limit;
+
+		rc = scsi_add_host(ap->scsi_host, host->dev);
+		if (rc) {
+			ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
+			/* FIXME: do something useful here */
+			/* FIXME: handle unconditional calls to
+			 * scsi_scan_host and ata_host_remove, below,
+			 * at the very least
+			 */
+		}
+
+		if (ap->ops->error_handler) {
+			struct ata_eh_info *ehi = &ap->eh_info;
+			unsigned long flags;
+
+			ata_port_probe(ap);
+
+			/* kick EH for boot probing */
+			spin_lock_irqsave(ap->lock, flags);
+
+			ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1;
+			ehi->action |= ATA_EH_SOFTRESET;
+			ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
+
+			ap->pflags |= ATA_PFLAG_LOADING;
+			ata_port_schedule_eh(ap);
+
+			spin_unlock_irqrestore(ap->lock, flags);
+
+			/* wait for EH to finish */
+			ata_port_wait_eh(ap);
+		} else {
+			DPRINTK("ata%u: bus probe begin\n", ap->id);
+			rc = ata_bus_probe(ap);
+			DPRINTK("ata%u: bus probe 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.
+				 */
+			}
+		}
+	}
+
+	/* probes are done, now scan each port's disk(s) */
+	DPRINTK("host probe begin\n");
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+
+		ata_scsi_scan_host(ap);
+	}
+
+	dev_set_drvdata(host->dev, host);
+
+	return 0;
+}
+
+
+/**
  *	ata_device_add - Register hardware device with ATA and SCSI layers
  *	@ent: Probe information describing hardware device to be registered
  *

@@ -5455,61 +5686,48 @@ int ata_device_add(const struct ata_prob
 	int rc;
 
 	DPRINTK("ENTER\n");
-	/* alloc a container for our list of ATA ports (buses) */
-	host = kzalloc(sizeof(struct ata_host) +
-		       (ent->n_ports * sizeof(void *)), GFP_KERNEL);
+
+	if (!ent->port_ops->error_handler &&
+	    !(ent->port_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
+		dev_printk(KERN_ERR, dev, "no reset mechanism available\n");
+		return 0;
+	}
+
+	/* allocate host */
+	host = ata_host_alloc(dev, ent->sht, ent->n_ports);
 	if (!host)
 		return 0;
 
-	ata_host_init(host, dev, ent->_host_flags, ent->port_ops);
-	host->n_ports = ent->n_ports;
 	host->irq = ent->irq;
 	host->irq2 = ent->irq2;
 	host->mmio_base = ent->mmio_base;
 	host->private_data = ent->private_data;
+	host->ops = ent->port_ops;
+	host->flags = ent->_host_flags;
 
-	/* register each port bound to this device */
 	for (i = 0; i < host->n_ports; i++) {
-		struct ata_port *ap;
-		unsigned long xfer_mode_mask;
-		int irq_line = ent->irq;
-
-		ap = ata_port_add(ent, host, i);
-		if (!ap)
-			goto err_out;
-
-		host->ports[i] = ap;
+		struct ata_port *ap = host->ports[i];
 
 		/* dummy? */
 		if (ent->dummy_port_mask & (1 << i)) {
-			ata_port_printk(ap, KERN_INFO, "DUMMY\n");
 			ap->ops = &ata_dummy_port_ops;
 			continue;
 		}
 
-		/* Report the secondary IRQ for second channel legacy */
-		if (i == 1 && ent->irq2)
-			irq_line = ent->irq2;
-
-		xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
-				(ap->mwdma_mask << ATA_SHIFT_MWDMA) |
-				(ap->pio_mask << ATA_SHIFT_PIO);
+		ap->pio_mask = ent->pio_mask;
+		ap->mwdma_mask = ent->mwdma_mask;
+		ap->udma_mask = ent->udma_mask;
+		ap->flags |= ent->port_flags;
+		ap->ops = ent->port_ops;
 
-		/* print per-port info to dmesg */
-		ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lX "
-				"ctl 0x%lX bmdma 0x%lX irq %d\n",
-				ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
-				ata_mode_string(xfer_mode_mask),
-				ap->ioaddr.cmd_addr,
-				ap->ioaddr.ctl_addr,
-				ap->ioaddr.bmdma_addr,
-				irq_line);
+		memcpy(&ap->ioaddr, &ent->port[ap->port_no],
+		       sizeof(struct ata_ioports));
 	}
 
 	/* start ports */
 	rc = ata_host_start(host);
 	if (rc)
-		goto err_out;
+		goto err_free_host;
 
 	/* freeze */
 	for (i = 0; i < host->n_ports; i++) {

@@ -5526,7 +5744,7 @@ int ata_device_add(const struct ata_prob
 	if (rc) {
 		dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
 			   ent->irq, rc);
-		goto err_out;
+		goto err_free_host;
 	}
 
 	/* do we have a second IRQ for the other channel, eg legacy mode */

@@ -5540,86 +5758,22 @@ int ata_device_add(const struct ata_prob
 		if (rc) {
 			dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
 				   ent->irq2, rc);
-			goto err_out_free_irq;
+			goto err_free_irq;
 		}
 	}
 
-	/* perform each probe synchronously */
-	DPRINTK("probe begin\n");
-	for (i = 0; i < host->n_ports; i++) {
-		struct ata_port *ap = host->ports[i];
-		u32 scontrol;
-		int rc;
-
-		/* init sata_spd_limit to the current value */
-		if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
-			int spd = (scontrol >> 4) & 0xf;
-			ap->hw_sata_spd_limit &= (1 << spd) - 1;
-		}
-		ap->sata_spd_limit = ap->hw_sata_spd_limit;
-
-		rc = scsi_add_host(ap->scsi_host, dev);
-		if (rc) {
-			ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
-			/* FIXME: do something useful here */
-			/* FIXME: handle unconditional calls to
-			 * scsi_scan_host and ata_host_remove, below,
-			 * at the very least
-			 */
-		}
-
-		if (ap->ops->error_handler) {
-			struct ata_eh_info *ehi = &ap->eh_info;
-			unsigned long flags;
-
-			ata_port_probe(ap);
-
-			/* kick EH for boot probing */
-			spin_lock_irqsave(ap->lock, flags);
-
-			ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1;
-			ehi->action |= ATA_EH_SOFTRESET;
-			ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
-
-			ap->pflags |= ATA_PFLAG_LOADING;
-			ata_port_schedule_eh(ap);
-
-			spin_unlock_irqrestore(ap->lock, flags);
-
-			/* wait for EH to finish */
-			ata_port_wait_eh(ap);
-		} else {
-			DPRINTK("ata%u: bus probe begin\n", ap->id);
-			rc = ata_bus_probe(ap);
-			DPRINTK("ata%u: bus probe 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.
-				 */
-			}
-		}
-	}
-
-	/* probes are done, now scan each port's disk(s) */
-	DPRINTK("host probe begin\n");
-	for (i = 0; i < host->n_ports; i++) {
-		struct ata_port *ap = host->ports[i];
-
-		ata_scsi_scan_host(ap);
-	}
-
-	dev_set_drvdata(dev, host);
+	rc = ata_host_attach(host);
+	if (rc)
+		goto err_free_irq2;
 
-	VPRINTK("EXIT, returning %u\n", ent->n_ports);
-	return ent->n_ports; /* success */
+	return host->n_ports; /* success */
 
-err_out_free_irq:
+ err_free_irq2:
+	if (ent->irq2)
+		free_irq(ent->irq2, host);
+ err_free_irq:
 	free_irq(ent->irq, host);
-err_out:
+ err_free_host:
 	ata_host_stop(host);
 	ata_host_free(host);
 	VPRINTK("EXIT, returning 0\n");

ACK in general, but minor nits are found in comments below.

Also, to make reviewing and git bisect easier, it would be nice to split ata_host_attach() separation into another patch.

Quoted 5 lines

 drivers/ata/libata-core.c |  451 
++++++++++++++++++++++++++++++---------------
 include/linux/libata.h    |    7 +
 2 files changed, 312 insertions(+), 146 deletions(-)

drivers/ata/libata-core.c void ata_dev_init(struct ata_device *dev · line 5247

Quoted 12 lines

drivers/ata/libata-core.c +2 -2

index d7bf4a1..eeb9dc6 100644
@@ -5243,11 +5243,15 @@ void ata_dev_init(struct ata_device *dev
  *    ata_port_init - Initialize an ata_port structure
  *    @ap: Structure to initialize
  *    @host: Collection of hosts to which @ap belongs
- *    @ent: Probe information provided by low-level driver
- *    @port_no: Port number associated with this ata_port
+ *    @ent: Probe information provided by low-level driver (optional)
+ *    @port_no: Port number associated with this ata_port (optional)

I would perhaps note that port_no is require iff ent != NULL

drivers/ata/libata-core.c static void ata_port_init_shost(struct a · line 5459

Quoted 7 lines

drivers/ata/libata-core.c +7 -0

+int ata_host_add_ports(struct ata_host *host,
+               struct scsi_host_template *sht, int n_ports)
+{
+    int i;
+
+    if (host->n_ports || n_ports > ATA_MAX_PORTS)
+        return -EINVAL;

For what code path would host->n_ports be non-zero?

drivers/ata/libata-core.c void ata_host_free(struct ata_host *host · line 5915

Quoted 9 lines

drivers/ata/libata-core.c +3 -1

@@ -5755,8 +5909,10 @@ void ata_host_free(struct ata_host *host
     /* free */
     for (i = 0; i < host->n_ports; i++) {
         struct ata_port *ap = host->ports[i];
-        if (ap)
+        if (ap->pflags & ATA_PFLAG_SHOST_OWNER)
             scsi_host_put(ap->scsi_host);
+        else
+            kfree(ap);

Do we ever have a reason to care about ap->scsi_host in the SAS case?

It seems like we could kill ATA_PFLAG_SHOST_OWNER, and just test scsi_host for NULL.

drivers/ata/libata-core.c +16 -0

+static void __ata_host_init_pinfo(struct ata_host *host,
+				  const struct ata_port_info **pinfo,
+				  int n_ports, int pi_is_ar)
+{
+	int i;
+
+	if (host->private_data == NULL)
+		host->private_data = pinfo[0]->private_data;
+	host->ops = pinfo[0]->port_ops;
+
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+		const struct ata_port_info *pi;
+
+		if (pi_is_ar)
+			pi = pinfo[i];

drivers/ata/libata-core.c +268 -0

+
+		WARN_ON(pi->private_data &&
+			pi->private_data != host->private_data);
+	}
+}
+
+/**
+ *	ata_host_alloc_pinfo - allocate host and init with port_info
+ *	@dev: generic device this host is associated with
+ *	@pinfo: ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Allocate ATA host and initialize with info from @pi.
+ *
+ *	RETURNS:
+ *	Allocate ATA host on success, NULL on failure.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+struct ata_host *ata_host_alloc_pinfo(struct device *dev,
+				      const struct ata_port_info *pinfo,
+				      int n_ports)
+{
+	struct ata_host *host;
+
+	if (!n_ports)
+		return NULL;
+
+	host = ata_host_alloc(dev, pinfo->sht, n_ports);
+	if (host)
+		__ata_host_init_pinfo(host, &pinfo, n_ports, 0);
+	return host;
+}
+
+/**
+ *	ata_host_alloc_pinfo_ar - alloc host and init with port_info ar
+ *	@dev: generic device this host is associated with
+ *	@pinfo_ar: array of ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Allocate ATA host and initialize with info from @pinfo_ar.
+ *
+ *	RETURNS:
+ *	Allocate ATA host on success, NULL on failure.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+struct ata_host *ata_host_alloc_pinfo_ar(struct device *dev,
+					 const struct ata_port_info **pinfo_ar,
+					 int n_ports)
+{
+	struct ata_host *host;
+
+	if (!n_ports)
+		return NULL;
+
+	host = ata_host_alloc(dev, pinfo_ar[0]->sht, n_ports);
+	if (host)
+		__ata_host_init_pinfo(host, pinfo_ar, n_ports, 1);
+	return host;
+}
+
+/**
+ *	ata_host_add_ports_pinfo - add ports and init with port_info
+ *	@host: target ATA host
+ *	@pinfo: ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Add @n_ports ports to @host and initialize @host with
+ *	info from @pinfo.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+int ata_host_add_ports_pinfo(struct ata_host *host,
+			     const struct ata_port_info *pinfo, int n_ports)
+{
+	int rc;
+
+	rc = ata_host_add_ports(host, pinfo->sht, n_ports);
+	if (rc == 0)
+		__ata_host_init_pinfo(host, &pinfo, n_ports, 0);
+	return rc;
+}
+
+/**
+ *	ata_host_add_ports_pinfo_ar - add ports and init with port_info ar
+ *	@host: target ATA host
+ *	@pinfo_ar: array of ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Add @n_ports ports to @host and initialize @host with
+ *	info from @pinfo_ar.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+int ata_host_add_ports_pinfo_ar(struct ata_host *host,
+				const struct ata_port_info **pinfo_ar,
+				int n_ports)
+{
+	int rc;
+
+	rc = ata_host_add_ports(host, pinfo_ar[0]->sht, n_ports);
+	if (rc == 0)
+		__ata_host_init_pinfo(host, pinfo_ar, n_ports, 1);
+	return rc;
+}
+
 /**
  *	ata_sas_host_init - Initialize a host struct
  *	@host:	host to initialize

@@ -5494,6 +5643,7 @@ void ata_host_init(struct ata_host *host
 	host->dev = dev;
 	host->flags = flags;
 	host->ops = ops;
+	INIT_LIST_HEAD(&host->irq_list);
 }
 
 /**

@@ -5541,6 +5691,108 @@ int ata_host_start(struct ata_host *host
 }
 
 /**
+ *	ata_host_request_irq_marker - request IRQ helper
+ *	@host: ATA host requesting IRQ for
+ *	@irq: IRQ to request
+ *	@handler: IRQ handler
+ *	@irq_flags: IRQ flags
+ *	@dev_id: IRQ dev_id
+ *	@marker: marker
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Freeze all ports and request IRQ with given parameters.
+ *	devname for the IRQ will be the name of the associated LLD.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	Return value of request_irq().
+ */
+int ata_host_request_irq_marker(struct ata_host *host, unsigned int irq,
+			irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			unsigned int irq_flags, void *dev_id, void *marker,
+			const char **p_reason)
+{
+	struct ata_irq *airq = NULL;
+	const char *reason;
+	int i, rc;
+
+	/* make sure ports are started */
+	rc = ata_host_start(host);
+	if (rc) {
+		reason = "failed to start host";
+		goto err;
+	}
+
+	/* freeze before requesting IRQ */
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+
+		if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
+			ata_chk_status(ap);
+			host->ops->irq_clear(ap);
+			ata_eh_freeze_port(ap);
+		}
+	}
+
+	/* request irq */
+	airq = kzalloc(sizeof(*airq), GFP_KERNEL);
+	if (!airq) {
+		reason = "failed to allocate ata_irq";
+		rc = -ENOMEM;
+		goto err;
+	}
+
+	rc = request_irq(irq, handler, irq_flags, DRV_NAME, dev_id);
+	if (rc) {
+		reason = "failed to request IRQ";
+		goto err;
+	}
+
+	airq->irq = irq;
+	airq->dev_id = dev_id;
+	airq->marker = marker;
+	list_add_tail(&airq->node, &host->irq_list);
+
+	return rc;
+
+ err:
+	kfree(airq);
+	if (p_reason)
+		*p_reason = reason;
+	return rc;
+}
+
+/**
+ *	ata_host_request_irq - request IRQ helper
+ *	@host: ATA host requesting IRQ for
+ *	@irq: IRQ to request
+ *	@handler: IRQ handler
+ *	@irq_flags: IRQ flags
+ *	@dev_id: IRQ dev_id
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Freeze all ports and request IRQ with given parameters.
+ *	devname for the IRQ will be the name of the associated LLD.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	Return value of request_irq().
+ */
+int ata_host_request_irq(struct ata_host *host, unsigned int irq,
+			 irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			 unsigned int irq_flags, void *dev_id,
+			 const char **p_reason)
+{
+	return ata_host_request_irq_marker(host, irq, handler, irq_flags,
+					   dev_id, ata_host_request_irq,
+					   p_reason);
+}
+
+/**
  *	ata_host_attach - attach initialized ATA host
  *	@host: ATA host to attach
  *

@@ -5886,6 +6138,48 @@ void ata_host_stop(struct ata_host *host
 	}
 }
 
+static void __ata_host_free_irqs(struct ata_host *host, void **markerp)
+{
+	struct ata_irq *airq, *tmp;
+
+	list_for_each_entry_safe(airq, tmp, &host->irq_list, node) {
+		if (!markerp || airq->marker == *markerp) {
+			list_del(&airq->node);
+			free_irq(airq->irq, airq->dev_id);
+			kfree(airq);
+		}
+	}
+}
+
+/**
+ *	ata_host_free_irqs_marker - free the IRQs with matching marker
+ *	@host: target ATA host
+ *	@marker: marker to match
+ *
+ *	Free IRQs @host is holding and marked with @marker.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+void ata_host_free_irqs_marker(struct ata_host *host, void *marker)
+{
+	__ata_host_free_irqs(host, &marker);
+}
+
+/**
+ *	ata_host_free_irqs - free all IRQs an ATA host is holding
+ *	@host: target ATA host
+ *
+ *	Free all IRQs @host is holding.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+void ata_host_free_irqs(struct ata_host *host)
+{
+	__ata_host_free_irqs(host, NULL);
+}
+
 /**
  *	ata_host_free - Release a host
  *	@host: ATA host set to be freed

@@ -6266,11 +6560,17 @@ EXPORT_SYMBOL_GPL(ata_std_ports);
 EXPORT_SYMBOL_GPL(ata_host_init);
 EXPORT_SYMBOL_GPL(ata_host_alloc);
 EXPORT_SYMBOL_GPL(ata_host_add_ports);
+EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
+EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo_ar);
+EXPORT_SYMBOL_GPL(ata_host_add_ports_pinfo);
+EXPORT_SYMBOL_GPL(ata_host_add_ports_pinfo_ar);
 EXPORT_SYMBOL_GPL(ata_host_start);
+EXPORT_SYMBOL_GPL(ata_host_request_irq);
 EXPORT_SYMBOL_GPL(ata_host_attach);
 EXPORT_SYMBOL_GPL(ata_device_add);
 EXPORT_SYMBOL_GPL(ata_host_detach);
 EXPORT_SYMBOL_GPL(ata_host_stop);
+EXPORT_SYMBOL_GPL(ata_host_free_irqs);
 EXPORT_SYMBOL_GPL(ata_host_free);
 EXPORT_SYMBOL_GPL(ata_host_remove);
 EXPORT_SYMBOL_GPL(ata_sg_init);

drivers/ata/libata.h +5 -1

index a5ecb71..1d24254 100644
@@ -73,7 +73,11 @@ extern void ata_port_init(struct ata_por
 			  const struct ata_probe_ent *ent, unsigned int port_no);
 extern struct ata_probe_ent *ata_probe_ent_alloc(struct device *dev,
 						 const struct ata_port_info *port);
-
+extern int ata_host_request_irq_marker(struct ata_host *host, unsigned int irq,
+			irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			unsigned int irq_flags, void *dev_id, void *marker,
+			const char **p_reason);
+extern void ata_host_free_irqs_marker(struct ata_host *host, void *marker);
 
 /* libata-scsi.c */
 extern struct scsi_transport_template ata_scsi_transport_template;

include/linux/libata.h +16 -3

index 5e8160a..b050517 100644
@@ -378,6 +378,7 @@ struct ata_host {
 	unsigned long		flags;
 	int			simplex_claimed;	/* Keep seperate in case we
 							   ever need to do this locked */
+	struct list_head	irq_list;	/* list of acquired irqs */
 	struct ata_port		*ports[0];
 };
 

@@ -692,15 +693,27 @@ extern int ata_pci_device_resume(struct 
 extern int ata_pci_clear_simplex(struct pci_dev *pdev);
 #endif /* CONFIG_PCI */
 extern struct ata_host *ata_host_alloc(struct device *dev,
-				       struct scsi_host_template *sht,
-				       int n_ports);
+			struct scsi_host_template *sht, int n_ports);
 extern int ata_host_add_ports(struct ata_host *host,
-			      struct scsi_host_template *sht, int n_ports);
+			struct scsi_host_template *sht, int n_ports);
+extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
+			const struct ata_port_info *pinfo, int n_ports);
+extern struct ata_host *ata_host_alloc_pinfo_ar(struct device *dev,
+			const struct ata_port_info **pinfo_ar, int n_ports);
+extern int ata_host_add_ports_pinfo(struct ata_host *host,
+			const struct ata_port_info *pinfo, int n_ports);
+extern int ata_host_add_ports_pinfo_ar(struct ata_host *host,
+			const struct ata_port_info **pinfo_ar, int n_ports);
+extern int ata_host_request_irq(struct ata_host *host, unsigned int irq,
+			irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			unsigned int irq_flags, void *dev_id,
+			const char **p_reason);
 extern int ata_host_start(struct ata_host *host);
 extern int ata_host_attach(struct ata_host *host);
 extern int ata_device_add(const struct ata_probe_ent *ent);
 extern void ata_host_detach(struct ata_host *host);
 extern void ata_host_stop(struct ata_host *host);
+extern void ata_host_free_irqs(struct ata_host *host);
 extern void ata_host_free(struct ata_host *host);
 extern void ata_host_init(struct ata_host *, struct device *,
 			  unsigned long, const struct ata_port_operations *);

Quoted 16 lines · Tejun Heo

drivers/ata/libata-core.c +16 -0

+static void __ata_host_init_pinfo(struct ata_host *host,
+				  const struct ata_port_info **pinfo,
+				  int n_ports, int pi_is_ar)
+{
+	int i;
+
+	if (host->private_data == NULL)
+		host->private_data = pinfo[0]->private_data;
+	host->ops = pinfo[0]->port_ops;
+
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+		const struct ata_port_info *pi;
+
+		if (pi_is_ar)
+			pi = pinfo[i];

drivers/ata/libata-core.c int ata_host_add_ports(struct ata_host * · line 5509

Quoted 10 lines

drivers/ata/libata-core.c +8 -0

+		else
+			pi = pinfo[0];
+
 
 
+		ap->pio_mask = pi->pio_mask;
+		ap->mwdma_mask = pi->mwdma_mask;
+		ap->udma_mask = pi->udma_mask;
+		ap->flags |= pi->flags;
+		ap->ops = pi->port_ops;

Could this bit be moved into ata_port_init and possibly change the parameter list of ata_port_init to something like:

void ata_port_init(struct ata_port *ap, struct ata_host *host,
const struct ata_port_info *pinfo, unsigned int port_no)

Then we could get rid of the struct ata_probe_ent stuff completely.

Hello, Brian.

Quoted 30 lines · Brian King

Quoted 15 lines · Tejun Heo

drivers/ata/libata-core.c +15 -0

+static void __ata_host_init_pinfo(struct ata_host *host,
+				  const struct ata_port_info **pinfo,
+				  int n_ports, int pi_is_ar)
+{
+	int i;
+
+	if (host->private_data == NULL)
+		host->private_data = pinfo[0]->private_data;
+	host->ops = pinfo[0]->port_ops;
+
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+		const struct ata_port_info *pi;
+
+		if (pi_is_ar)

drivers/ata/libata-core.c int ata_host_add_ports(struct ata_host * · line 5509

Quoted 10 lines

drivers/ata/libata-core.c +9 -0

+			pi = pinfo[i];
+		else
+			pi = pinfo[0];
+
 
+		ap->pio_mask = pi->pio_mask;
+		ap->mwdma_mask = pi->mwdma_mask;
+		ap->udma_mask = pi->udma_mask;
+		ap->flags |= pi->flags;
+		ap->ops = pi->port_ops;

Could this bit be moved into ata_port_init and possibly change the parameter list of ata_port_init to something like:

Quoted 4 lines

void ata_port_init(struct ata_port *ap, struct ata_host *host,
const struct ata_port_info *pinfo, unsigned int port_no)

Then we could get rid of the struct ata_probe_ent stuff completely.

Hmmm... ata_port_init() is still exported only to support ata_sas_* helpers. Once the SAS helpers are converted to use new model, this function will be made static or merged into ata_host_alloc(). In the new init model, initialization is done by...

1. allocate the host and associated ports with ata_host_alloc(). If port number cannot be determined at this point. ports can be added later. The returned ata_host has only the basic fields, which assume the same initial values regardless of the user, initialized.

2. initialize ata_host and associated ports appropriately. During this ata_host_add_ports() can be used to add ports if host has no ports yet.

3. attach the initialized ata_host using ata_host_attach().

drivers/ata/libata-core.c +86 -0

+struct ata_host *ata_host_alloc_pinfo(struct device *dev,
+				      const struct ata_port_info *pinfo,
+				      int n_ports)
+{
+	struct ata_host *host;
+
+	if (!n_ports)
+		return NULL;
+
+	host = ata_host_alloc(dev, pinfo->sht, n_ports);
+	if (host)
+		__ata_host_init_pinfo(host, &pinfo, n_ports, 0);
+	return host;
+}
+
+/**
+ *	ata_host_alloc_pinfo_ar - alloc host and init with port_info ar
+ *	@dev: generic device this host is associated with
+ *	@pinfo_ar: array of ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Allocate ATA host and initialize with info from @pinfo_ar.
+ *
+ *	RETURNS:
+ *	Allocate ATA host on success, NULL on failure.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+struct ata_host *ata_host_alloc_pinfo_ar(struct device *dev,
+					 const struct ata_port_info **pinfo_ar,
+					 int n_ports)
+{
+	struct ata_host *host;
+
+	if (!n_ports)
+		return NULL;
+
+	host = ata_host_alloc(dev, pinfo_ar[0]->sht, n_ports);
+	if (host)
+		__ata_host_init_pinfo(host, pinfo_ar, n_ports, 1);
+	return host;
+}
+
+/**
+ *	ata_host_add_ports_pinfo - add ports and init with port_info
+ *	@host: target ATA host
+ *	@pinfo: ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Add @n_ports ports to @host and initialize @host with
+ *	info from @pinfo.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+int ata_host_add_ports_pinfo(struct ata_host *host,
+			     const struct ata_port_info *pinfo, int n_ports)
+{
+	int rc;
+
+	rc = ata_host_add_ports(host, pinfo->sht, n_ports);
+	if (rc == 0)
+		__ata_host_init_pinfo(host, &pinfo, n_ports, 0);
+	return rc;
+}
+
+/**
+ *	ata_host_add_ports_pinfo_ar - add ports and init with port_info ar
+ *	@host: target ATA host
+ *	@pinfo_ar: array of ATA port_info to initialize host with
+ *	@n_ports: number of ATA ports attached to this host
+ *
+ *	Add @n_ports ports to @host and initialize @host with
+ *	info from @pinfo_ar.
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+int ata_host_add_ports_pinfo_ar(struct ata_host *host,

drivers/ata/libata-core.c +105 -0

@@ -5494,6 +5643,7 @@ void ata_host_init(struct ata_host *host
 	host->dev = dev;
 	host->flags = flags;
 	host->ops = ops;
+	INIT_LIST_HEAD(&host->irq_list);
 }
 
 /**

@@ -5541,6 +5691,108 @@ int ata_host_start(struct ata_host *host
 }
 
 /**
+ *	ata_host_request_irq_marker - request IRQ helper
+ *	@host: ATA host requesting IRQ for
+ *	@irq: IRQ to request
+ *	@handler: IRQ handler
+ *	@irq_flags: IRQ flags
+ *	@dev_id: IRQ dev_id
+ *	@marker: marker
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Freeze all ports and request IRQ with given parameters.
+ *	devname for the IRQ will be the name of the associated LLD.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	Return value of request_irq().
+ */
+int ata_host_request_irq_marker(struct ata_host *host, unsigned int irq,
+			irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			unsigned int irq_flags, void *dev_id, void *marker,
+			const char **p_reason)
+{
+	struct ata_irq *airq = NULL;
+	const char *reason;
+	int i, rc;
+
+	/* make sure ports are started */
+	rc = ata_host_start(host);
+	if (rc) {
+		reason = "failed to start host";
+		goto err;
+	}
+
+	/* freeze before requesting IRQ */
+	for (i = 0; i < host->n_ports; i++) {
+		struct ata_port *ap = host->ports[i];
+
+		if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
+			ata_chk_status(ap);
+			host->ops->irq_clear(ap);
+			ata_eh_freeze_port(ap);
+		}
+	}
+
+	/* request irq */
+	airq = kzalloc(sizeof(*airq), GFP_KERNEL);
+	if (!airq) {
+		reason = "failed to allocate ata_irq";
+		rc = -ENOMEM;
+		goto err;
+	}
+
+	rc = request_irq(irq, handler, irq_flags, DRV_NAME, dev_id);
+	if (rc) {
+		reason = "failed to request IRQ";
+		goto err;
+	}
+
+	airq->irq = irq;
+	airq->dev_id = dev_id;
+	airq->marker = marker;
+	list_add_tail(&airq->node, &host->irq_list);
+
+	return rc;
+
+ err:
+	kfree(airq);
+	if (p_reason)
+		*p_reason = reason;
+	return rc;
+}
+
+/**
+ *	ata_host_request_irq - request IRQ helper
+ *	@host: ATA host requesting IRQ for
+ *	@irq: IRQ to request
+ *	@handler: IRQ handler
+ *	@irq_flags: IRQ flags
+ *	@dev_id: IRQ dev_id
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Freeze all ports and request IRQ with given parameters.
+ *	devname for the IRQ will be the name of the associated LLD.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	Return value of request_irq().
+ */
+int ata_host_request_irq(struct ata_host *host, unsigned int irq,
+			 irqreturn_t (*handler)(int, void *, struct pt_regs *),
+			 unsigned int irq_flags, void *dev_id,
+			 const char **p_reason)
+{
+	return ata_host_request_irq_marker(host, irq, handler, irq_flags,
+					   dev_id, ata_host_request_irq,
+					   p_reason);
+}
+
+/**
  *	ata_host_attach - attach initialized ATA host
  *	@host: ATA host to attach
  *

@@ -5886,6 +6138,48 @@ void ata_host_stop(struct ata_host *host
 	}
 }
 
+static void __ata_host_free_irqs(struct ata_host *host, void **markerp)
+{

Quoted 5 lines

drivers/ata/libata-core.c +5 -0

+int ata_host_add_ports_pinfo_ar(struct ata_host *host,
+                const struct ata_port_info **pinfo_ar,
+                int n_ports)
+{
+    int rc;

drivers/ata/libata-core.c int ata_host_add_ports(struct ata_host * · line 5625

Quoted 6 lines

drivers/ata/libata-core.c +6 -0

+
+    rc = ata_host_add_ports(host, pinfo_ar[0]->sht, n_ports);
+    if (rc == 0)
+        __ata_host_init_pinfo(host, pinfo_ar, n_ports, 1);
+    return rc;
+}

Just implement a single version for each case (array and non-array). The LLDD can pass in an indication of whether or not to copy the first element into succeeding elements.

Quoted 6 lines

drivers/ata/libata-core.c +6 -0

+static void __ata_host_free_irqs(struct ata_host *host, void **markerp)
+{
+    struct ata_irq *airq, *tmp;
+
+    list_for_each_entry_safe(airq, tmp, &host->irq_list, node) {
+        if (!markerp || airq->marker == *markerp) {

drivers/ata/libata-core.c void ata_host_stop(struct ata_host *host · line 6152

Quoted 6 lines

drivers/ata/libata-core.c +6 -0

+            list_del(&airq->node);
+            free_irq(airq->irq, airq->dev_id);
+            kfree(airq);
+        }
+    }
+}

Ugh, I just don't like this at all. I would much rather have a hook or entry point where the LLDD is given the capability to call request_irq() itself, in some exotic situations. Then, helpers provided by libata can handle the common cases. That's much more modular than the above.

Implement the following legacy ATA init helpers.

* ata_legacy_acquire_resources() : acquire legacy ATA resources
* ata_legacy_release_resources() : release legacy ATA resources
* ata_legacy_init_ports() : init legacy port addresses
* ata_legacy_request_irqs() : request legacy ATA IRQs
* ata_legacy_free_irqs() : free legacy ATA IRQs

These helpers can be used independently or called implictly from other bus helpers which has support for legacy ATA device for compatibility (e.g. PCI).

Signed-off-by Tejun Heo <[email protected]>

drivers/ata/Kconfig +5 -0

index 2109d75..1a98559 100644
@@ -15,6 +15,11 @@ config ATA
 	  that "speaks" the ATA protocol, also called ATA controller),
 	  because you will be asked for it.
 
+config ATA_LEGACY
+	bool
+	depends on ATA
+	default n
+
 config SATA_AHCI
 	tristate "AHCI SATA support"
 	depends on ATA && PCI

drivers/ata/Makefile +3 -0

index c17ae9c..61d3e76 100644
@@ -19,3 +19,6 @@ obj-$(CONFIG_PDC_ADMA)		+= pdc_adma.o
 
 libata-objs	:= libata-core.o libata-scsi.o libata-bmdma.o libata-eh.o
 
+ifeq ($(CONFIG_ATA_LEGACY),y)
+libata-objs	+= libata-legacy.o
+endif

drivers/ata/libata-legacy.c new file +43 -0

new file mode 100644
index 0000000..00b70b0
@@ -0,0 +1,241 @@
+/*
+ *  libata-legacy.c - helper library for legacy ATA
+ *
+ *  Maintained by:  Jeff Garzik <[email protected]>
+ *    		    Please ALWAYS copy [email protected]
+ *		    on emails.
+ *
+ *  Copyright 2006 Tejun Heo <[email protected]>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License as
+ *  published by the Free Software Foundation; either version 2, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
+ *  USA.
+ *
+ *
+ *  libata documentation is available via 'make {ps|pdf}docs',
+ *  as Documentation/DocBook/libata.*
+ *
+ *  Hardware documentation available from http://www.t13.org/ and
+ *  http://www.sata-io.org/
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/libata.h>
+
+#include "libata.h"
+
+static unsigned long ata_legacy_addr(int port, int sel)
+{
+	if (port == 0) {
+		if (sel == 0)

drivers/ata/libata-legacy.c new file +11 -0

+static int ata_legacy_acquire_port(struct ata_port *ap)
+{
+	struct ata_host *host = ap->host;
+	unsigned long cmd_addr = ata_legacy_addr(ap->port_no, 0);
+
+	if (request_region(cmd_addr, 8, "libata") != NULL)
+		host->legacy_flags |= ATA_LEGACY_RES_PRI << ap->port_no;
+	else {
+		struct resource *conflict, res;
+
+		res.start = cmd_addr;

drivers/ata/libata-legacy.c new file +161 -0

+/**
+ *	ata_legacy_acquire_resources - acquire legacy ATA resources
+ *	@host: target ATA host
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Acquire legacy ATA resources for ports specified by
+ *	ATA_PORT_PRIMARY/SECONDARY mask in host->legacy_flags.  If the
+ *	port is busy, this function makes the port dummy instead of
+ *	failing.  This is to allow legacy ports to be driven by other
+ *	drivers.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ */
+int ata_legacy_acquire_resources(struct ata_host *host, const char **p_reason)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		if (!(host->legacy_flags & (ATA_PORT_PRIMARY << i)))
+			continue;
+		BUG_ON(i >= host->n_ports);
+
+		if (ata_legacy_acquire_port(host->ports[i]))
+			host->ports[i]->ops = &ata_dummy_port_ops;
+	}
+
+	return 0;
+}
+
+/**
+ *	ata_legacy_release_resources - release legacy ATA resources
+ *	@host: target ATA host
+ *
+ *	Free all legacy ATA resources @host is holding.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+void ata_legacy_release_resources(struct ata_host *host)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		if (host->legacy_flags & (ATA_LEGACY_RES_PRI << i)) {
+			release_region(ata_legacy_addr(i, 0), 8);
+			host->legacy_flags &= ~(ATA_LEGACY_RES_PRI << i);
+		}
+	}
+}
+
+/**
+ *	ata_legacy_init_ports - initialize legacy ATA port addresses
+ *	@host: target ATA host
+ *
+ *	Initialize legacy ATA port addresses for non-dummy legacy
+ *	ports in @host.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer.
+ */
+void ata_legacy_init_ports(struct ata_host *host)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		struct ata_port *ap = host->ports[i];
+
+		if (host->legacy_flags & (ATA_PORT_PRIMARY << i) &&
+		    !ata_port_is_dummy(ap)) {
+			struct ata_ioports *ioaddr = &ap->ioaddr;
+			unsigned long cmd_addr = ata_legacy_addr(i, 0);
+			unsigned long ctl_addr = ata_legacy_addr(i, 1);
+
+			ioaddr->cmd_addr = cmd_addr;
+			ioaddr->altstatus_addr = ctl_addr;
+			ioaddr->ctl_addr = ctl_addr;
+			ata_std_ports(ioaddr);
+		}
+	}
+}
+
+/**
+ *	ata_legacy_request_irqs - request legacy ATA IRQs
+ *	@host: target ATA host
+ *	@handler: array of IRQ handlers
+ *	@irq_flags: array of IRQ flags
+ *	@dev_id: array of IRQ dev_ids
+ *	@p_reason: out arg for error message (can be NULL)
+ *
+ *	Request legacy IRQs for non-dummy legacy ports in @host.  All
+ *	IRQ parameters are passed as array to allow ports to have
+ *	separate IRQ handlers.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ *
+ *	RETURNS:
+ *	0 on success, -errno otherwise.
+ */
+int ata_legacy_request_irqs(struct ata_host *host,
+		irqreturn_t (* const * handler)(int, void *, struct pt_regs *),
+		const unsigned int *irq_flags, void * const *dev_id,
+		const char **p_reason)
+{
+	const unsigned int legacy_irq[] = { 14, 15 };
+	const char *reason;
+	int i, rc;
+
+	for (i = 0; i < 2; i++) {
+		struct ata_port *ap = host->ports[i];
+		unsigned int irq = legacy_irq[i];
+
+		if (!(host->legacy_flags & (ATA_PORT_PRIMARY << i)) ||
+		    ata_port_is_dummy(ap))
+			continue;
+
+		if (!handler[i]) {
+			reason = "NULL handler";
+			rc = -EINVAL;
+			goto err;
+		}
+
+		rc = ata_host_request_irq_marker(host, irq,
+					handler[i], irq_flags[i], dev_id[i],
+					ata_legacy_request_irqs, &reason);
+		if (rc)
+			goto err;
+
+		/* only for info printing */
+		if (i == 0)
+			host->irq = irq;
+		else
+			host->irq2 = irq;
+	}
+
+	return 0;
+
+ err:
+	ata_legacy_free_irqs(host);
+	if (p_reason)
+		*p_reason = reason;
+	return rc;
+}
+
+/**
+ *	ata_legacy_free_irqs - free legacy ATA IRQs
+ *	@host: target ATA host
+ *
+ *	Free all legacy ATA IRQs of @host.
+ *
+ *	LOCKING:
+ *	Inherited from calling layer (may sleep).
+ */
+void ata_legacy_free_irqs(struct ata_host *host)
+{
+	ata_host_free_irqs_marker(host, ata_legacy_request_irqs);
+}

drivers/ata/libata.h +11 -0

index 1d24254..0601c4a 100644
@@ -117,6 +117,17 @@ extern void ata_schedule_scsi_eh(struct 
 extern void ata_scsi_dev_rescan(void *data);
 extern int ata_bus_probe(struct ata_port *ap);
 
+/* libata-legacy.c */
+extern int ata_legacy_acquire_resources(struct ata_host *host,
+					const char **p_reason);
+extern void ata_legacy_release_resources(struct ata_host *host);
+extern void ata_legacy_init_ports(struct ata_host *host);
+extern int ata_legacy_request_irqs(struct ata_host *host,
+		irqreturn_t (* const * handler)(int, void *, struct pt_regs *),
+		const unsigned int *irq_flags, void * const *dev_id,
+		const char **p_reason);
+extern void ata_legacy_free_irqs(struct ata_host *host);
+
 /* libata-eh.c */
 extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern void ata_scsi_error(struct Scsi_Host *host);

include/linux/libata.h +0 -0

index b050517..9535f54 100644