libata: convert the remaining SATA drivers to new init model

Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.

Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths.  This simplifies code quite a bit.

* init_one()'s now follow more consistent init order

* ahci_setup_port() and ahci_host_init() collapsed into
  ahci_init_one() for init order consistency

* sata_vsc uses port_info instead of setting fields manually

* in sata_svw, k2_board_info converted to port_info (info is now in
  port flags).  port number is honored now.

Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.

Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>

1 files changed, 64 insertions, 86 deletions

diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 1a081c3a8c06..3a4f44559d0a 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -151,24 +151,23 @@ struct pdc_host_priv {
 
 
 static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
-static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance);
 static void pdc_eng_timeout(struct ata_port *ap);
 static void pdc_20621_phy_reset (struct ata_port *ap);
 static int pdc_port_start(struct ata_port *ap);
 static void pdc20621_qc_prep(struct ata_queued_cmd *qc);
 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
-static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe);
-static int pdc20621_detect_dimm(struct ata_probe_ent *pe);
-static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe,
+static unsigned int pdc20621_dimm_init(struct ata_host *host);
+static int pdc20621_detect_dimm(struct ata_host *host);
+static unsigned int pdc20621_i2c_read(struct ata_host *host,
                                       u32 device, u32 subaddr, u32 *pdata);
-static int pdc20621_prog_dimm0(struct ata_probe_ent *pe);
-static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe);
+static int pdc20621_prog_dimm0(struct ata_host *host);
+static unsigned int pdc20621_prog_dimm_global(struct ata_host *host);
 #ifdef ATA_VERBOSE_DEBUG
-static void pdc20621_get_from_dimm(struct ata_probe_ent *pe,
+static void pdc20621_get_from_dimm(struct ata_host *host,
                                    void *psource, u32 offset, u32 size);
 #endif
-static void pdc20621_put_to_dimm(struct ata_probe_ent *pe,
+static void pdc20621_put_to_dimm(struct ata_host *host,
                                  void *psource, u32 offset, u32 size);
 static void pdc20621_irq_clear(struct ata_port *ap);
 static unsigned int pdc20621_qc_issue_prot(struct ata_queued_cmd *qc);
@@ -204,7 +203,6 @@ static const struct ata_port_operations pdc_20621_ops = {
         .qc_issue               = pdc20621_qc_issue_prot,
         .data_xfer              = ata_data_xfer,
         .eng_timeout            = pdc_eng_timeout,
-        .irq_handler            = pdc20621_interrupt,
         .irq_clear              = pdc20621_irq_clear,
         .irq_on                 = ata_irq_on,
         .irq_ack                = ata_irq_ack,
@@ -214,7 +212,6 @@ static const struct ata_port_operations pdc_20621_ops = {
 static const struct ata_port_info pdc_port_info[] = {
         /* board_20621 */
         {
-                .sht            = &pdc_sata_sht,
                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                   ATA_FLAG_SRST | ATA_FLAG_MMIO |
                                   ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING,
@@ -882,15 +879,15 @@ static void pdc_sata_setup_port(struct ata_ioports *port, void __iomem *base)
 
 
 #ifdef ATA_VERBOSE_DEBUG
-static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource,
+static void pdc20621_get_from_dimm(struct ata_host *host, void *psource,
                                    u32 offset, u32 size)
 {
         u32 window_size;
         u16 idx;
         u8 page_mask;
         long dist;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
-        void __iomem *dimm_mmio = pe->iomap[PDC_DIMM_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
+        void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -937,15 +934,15 @@ static void pdc20621_get_from_dimm(struct ata_probe_ent *pe, void *psource,
 #endif
 
 
-static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
+static void pdc20621_put_to_dimm(struct ata_host *host, void *psource,
                                  u32 offset, u32 size)
 {
         u32 window_size;
         u16 idx;
         u8 page_mask;
         long dist;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
-        void __iomem *dimm_mmio = pe->iomap[PDC_DIMM_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
+        void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -987,10 +984,10 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
 }
 
 
-static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device,
+static unsigned int pdc20621_i2c_read(struct ata_host *host, u32 device,
                                       u32 subaddr, u32 *pdata)
 {
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
         u32 i2creg  = 0;
         u32 status;
         u32 count =0;
@@ -1023,17 +1020,17 @@ static unsigned int pdc20621_i2c_read(struct ata_probe_ent *pe, u32 device,
 }
 
 
-static int pdc20621_detect_dimm(struct ata_probe_ent *pe)
+static int pdc20621_detect_dimm(struct ata_host *host)
 {
         u32 data=0 ;
-        if (pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
+        if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
                              PDC_DIMM_SPD_SYSTEM_FREQ, &data)) {
                 if (data == 100)
                         return 100;
         } else
                 return 0;
 
-        if (pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS, 9, &data)) {
+        if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS, 9, &data)) {
                 if(data <= 0x75)
                         return 133;
         } else
@@ -1043,13 +1040,13 @@ static int pdc20621_detect_dimm(struct ata_probe_ent *pe)
 }
 
 
-static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
+static int pdc20621_prog_dimm0(struct ata_host *host)
 {
         u32 spd0[50];
         u32 data = 0;
         int size, i;
         u8 bdimmsize;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
         static const struct {
                 unsigned int reg;
                 unsigned int ofs;
@@ -1072,7 +1069,7 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
         mmio += PDC_CHIP0_OFS;
 
         for(i=0; i<ARRAY_SIZE(pdc_i2c_read_data); i++)
-                pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
+                pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
                                   pdc_i2c_read_data[i].reg,
                                   &spd0[pdc_i2c_read_data[i].ofs]);
 
@@ -1108,11 +1105,11 @@ static int pdc20621_prog_dimm0(struct ata_probe_ent *pe)
 }
 
 
-static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
+static unsigned int pdc20621_prog_dimm_global(struct ata_host *host)
 {
         u32 data, spd0;
         int error, i;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1129,7 +1126,7 @@ static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
         readl(mmio + PDC_SDRAM_CONTROL_OFFSET);
 
         /* Turn on for ECC */
-        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
+        pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
                           PDC_DIMM_SPD_TYPE, &spd0);
         if (spd0 == 0x02) {
                 data |= (0x01 << 16);
@@ -1156,7 +1153,7 @@ static unsigned int pdc20621_prog_dimm_global(struct ata_probe_ent *pe)
 }
 
 
-static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
+static unsigned int pdc20621_dimm_init(struct ata_host *host)
 {
         int speed, size, length;
         u32 addr,spd0,pci_status;
@@ -1166,7 +1163,7 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
         u32 ticks=0;
         u32 clock=0;
         u32 fparam=0;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1225,18 +1222,18 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
            Read SPD of DIMM by I2C interface,
            and program the DIMM Module Controller.
         */
-        if (!(speed = pdc20621_detect_dimm(pe))) {
+        if (!(speed = pdc20621_detect_dimm(host))) {
                 printk(KERN_ERR "Detect Local DIMM Fail\n");
                 return 1;       /* DIMM error */
         }
         VPRINTK("Local DIMM Speed = %d\n", speed);
 
         /* Programming DIMM0 Module Control Register (index_CID0:80h) */
-        size = pdc20621_prog_dimm0(pe);
+        size = pdc20621_prog_dimm0(host);
         VPRINTK("Local DIMM Size = %dMB\n",size);
 
         /* Programming DIMM Module Global Control Register (index_CID0:88h) */
-        if (pdc20621_prog_dimm_global(pe)) {
+        if (pdc20621_prog_dimm_global(host)) {
                 printk(KERN_ERR "Programming DIMM Module Global Control Register Fail\n");
                 return 1;
         }
@@ -1249,20 +1246,20 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
                                 '9','8','0','3','1','6','1','2',0,0};
                 u8 test_parttern2[40] = {0};
 
-                pdc20621_put_to_dimm(pe, (void *) test_parttern2, 0x10040, 40);
-                pdc20621_put_to_dimm(pe, (void *) test_parttern2, 0x40, 40);
+                pdc20621_put_to_dimm(host, (void *) test_parttern2, 0x10040, 40);
+                pdc20621_put_to_dimm(host, (void *) test_parttern2, 0x40, 40);
 
-                pdc20621_put_to_dimm(pe, (void *) test_parttern1, 0x10040, 40);
-                pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x40, 40);
+                pdc20621_put_to_dimm(host, (void *) test_parttern1, 0x10040, 40);
+                pdc20621_get_from_dimm(host, (void *) test_parttern2, 0x40, 40);
                 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
-                pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x10040,
+                pdc20621_get_from_dimm(host, (void *) test_parttern2, 0x10040,
                                        40);
                 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
 
-                pdc20621_put_to_dimm(pe, (void *) test_parttern1, 0x40, 40);
-                pdc20621_get_from_dimm(pe, (void *) test_parttern2, 0x40, 40);
+                pdc20621_put_to_dimm(host, (void *) test_parttern1, 0x40, 40);
+                pdc20621_get_from_dimm(host, (void *) test_parttern2, 0x40, 40);
                 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
                        test_parttern2[1], &(test_parttern2[2]));
         }
@@ -1270,14 +1267,14 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
 
         /* ECC initiliazation. */
 
-        pdc20621_i2c_read(pe, PDC_DIMM0_SPD_DEV_ADDRESS,
+        pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
                           PDC_DIMM_SPD_TYPE, &spd0);
         if (spd0 == 0x02) {
                 VPRINTK("Start ECC initialization\n");
                 addr = 0;
                 length = size * 1024 * 1024;
                 while (addr < length) {
-                        pdc20621_put_to_dimm(pe, (void *) &tmp, addr,
+                        pdc20621_put_to_dimm(host, (void *) &tmp, addr,
                                              sizeof(u32));
                         addr += sizeof(u32);
                 }
@@ -1287,10 +1284,10 @@ static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe)
 }
 
 
-static void pdc_20621_init(struct ata_probe_ent *pe)
+static void pdc_20621_init(struct ata_host *host)
 {
         u32 tmp;
-        void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
+        void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
 
         /* hard-code chip #0 */
         mmio += PDC_CHIP0_OFS;
@@ -1321,15 +1318,25 @@ static void pdc_20621_init(struct ata_probe_ent *pe)
 static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
-        struct ata_probe_ent *probe_ent;
+        const struct ata_port_info *ppi[] =
+                { &pdc_port_info[ent->driver_data], NULL };
+        struct ata_host *host;
         void __iomem *base;
         struct pdc_host_priv *hpriv;
-        unsigned int board_idx = (unsigned int) ent->driver_data;
         int rc;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
 
+        /* allocate host */
+        host = ata_host_alloc_pinfo(&pdev->dev, ppi, 4);
+        hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
+        if (!host || !hpriv)
+                return -ENOMEM;
+
+        host->private_data = hpriv;
+
+        /* acquire resources and fill host */
         rc = pcim_enable_device(pdev);
         if (rc)
                 return rc;
@@ -1340,7 +1347,15 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
                 pcim_pin_device(pdev);
         if (rc)
                 return rc;
+        host->iomap = pcim_iomap_table(pdev);
+
+        base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
+        pdc_sata_setup_port(&host->ports[0]->ioaddr, base + 0x200);
+        pdc_sata_setup_port(&host->ports[1]->ioaddr, base + 0x280);
+        pdc_sata_setup_port(&host->ports[2]->ioaddr, base + 0x300);
+        pdc_sata_setup_port(&host->ports[3]->ioaddr, base + 0x380);
 
+        /* configure and activate */
         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
         if (rc)
                 return rc;
@@ -1348,50 +1363,13 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         if (rc)
                 return rc;
 
-        probe_ent = devm_kzalloc(&pdev->dev, sizeof(*probe_ent), GFP_KERNEL);
-        if (probe_ent == NULL)
+        if (pdc20621_dimm_init(host))
                 return -ENOMEM;
-
-        probe_ent->dev = pci_dev_to_dev(pdev);
-        INIT_LIST_HEAD(&probe_ent->node);
-
-        hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
-        if (!hpriv)
-                return -ENOMEM;
-
-        probe_ent->sht          = pdc_port_info[board_idx].sht;
-        probe_ent->port_flags   = pdc_port_info[board_idx].flags;
-        probe_ent->pio_mask     = pdc_port_info[board_idx].pio_mask;
-        probe_ent->mwdma_mask   = pdc_port_info[board_idx].mwdma_mask;
-        probe_ent->udma_mask    = pdc_port_info[board_idx].udma_mask;
-        probe_ent->port_ops     = pdc_port_info[board_idx].port_ops;
-
-        probe_ent->irq = pdev->irq;
-        probe_ent->irq_flags = IRQF_SHARED;
-        probe_ent->iomap = pcim_iomap_table(pdev);
-
-        probe_ent->private_data = hpriv;
-        base = probe_ent->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
-
-        probe_ent->n_ports = 4;
-        pdc_sata_setup_port(&probe_ent->port[0], base + 0x200);
-        pdc_sata_setup_port(&probe_ent->port[1], base + 0x280);
-        pdc_sata_setup_port(&probe_ent->port[2], base + 0x300);
-        pdc_sata_setup_port(&probe_ent->port[3], base + 0x380);
+        pdc_20621_init(host);
 
         pci_set_master(pdev);
-
-        /* initialize adapter */
-        /* initialize local dimm */
-        if (pdc20621_dimm_init(probe_ent))
-                return -ENOMEM;
-        pdc_20621_init(probe_ent);
-
-        if (!ata_device_add(probe_ent))
-                return -ENODEV;
-
-        devm_kfree(&pdev->dev, probe_ent);
-        return 0;
+        return ata_host_activate(host, pdev->irq, pdc20621_interrupt,
+                                 IRQF_SHARED, &pdc_sata_sht);
 }