ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>

Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.

ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)

Format string duplication comes from:

 #define ata_link_printk(link, lv, fmt, args...) do { \
       if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)    \
               printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,   \
                      (link)->pmp , ##args); \
       else \
               printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
       } while(0)

Coalesce long formats.

$ size drivers/ata/built-in.*
   text	   data	    bss	    dec	    hex	filename
 544969	  73893	 116584	 735446	  b38d6	drivers/ata/built-in.allyesconfig.ata.o
 558429	  73893	 117864	 750186	  b726a	drivers/ata/built-in.allyesconfig.dev_level.o
 141328	  14689	   4220	 160237	  271ed	drivers/ata/built-in.defconfig.ata.o
 149567	  14689	   4220	 168476	  2921c	drivers/ata/built-in.defconfig.dev_level.o

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>

1 files changed, 59 insertions, 64 deletions

diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
index f06b7ea590d3..3eb2b816eb2a 100644
--- a/drivers/ata/libata-pmp.c
+++ b/drivers/ata/libata-pmp.c
@@ -147,8 +147,8 @@ int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
 
         err_mask = sata_pmp_read(link, reg, r_val);
         if (err_mask) {
-                ata_link_printk(link, KERN_WARNING, "failed to read SCR %d "
-                                "(Emask=0x%x)\n", reg, err_mask);
+                ata_link_warn(link, "failed to read SCR %d (Emask=0x%x)\n",
+                              reg, err_mask);
                 return -EIO;
         }
         return 0;
@@ -178,8 +178,8 @@ int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
 
         err_mask = sata_pmp_write(link, reg, val);
         if (err_mask) {
-                ata_link_printk(link, KERN_WARNING, "failed to write SCR %d "
-                                "(Emask=0x%x)\n", reg, err_mask);
+                ata_link_warn(link, "failed to write SCR %d (Emask=0x%x)\n",
+                              reg, err_mask);
                 return -EIO;
         }
         return 0;
@@ -231,8 +231,8 @@ static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
 
                 err_mask = sata_pmp_read(dev->link, reg, &gscr[reg]);
                 if (err_mask) {
-                        ata_dev_printk(dev, KERN_ERR, "failed to read PMP "
-                                "GSCR[%d] (Emask=0x%x)\n", reg, err_mask);
+                        ata_dev_err(dev, "failed to read PMP GSCR[%d] (Emask=0x%x)\n",
+                                    reg, err_mask);
                         return -EIO;
                 }
         }
@@ -311,26 +311,25 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
         }
 
         if (print_info) {
-                ata_dev_printk(dev, KERN_INFO, "Port Multiplier %s, "
-                               "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
-                               sata_pmp_spec_rev_str(gscr), vendor, devid,
-                               sata_pmp_gscr_rev(gscr),
-                               nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
-                               gscr[SATA_PMP_GSCR_FEAT]);
+                ata_dev_info(dev, "Port Multiplier %s, "
+                             "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
+                             sata_pmp_spec_rev_str(gscr), vendor, devid,
+                             sata_pmp_gscr_rev(gscr),
+                             nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
+                             gscr[SATA_PMP_GSCR_FEAT]);
 
                 if (!(dev->flags & ATA_DFLAG_AN))
-                        ata_dev_printk(dev, KERN_INFO,
+                        ata_dev_info(dev,
                                 "Asynchronous notification not supported, "
-                                "hotplug won't\n         work on fan-out "
-                                "ports. Use warm-plug instead.\n");
+                                "hotplug won't work on fan-out ports. Use warm-plug instead.\n");
         }
 
         return 0;
 
  fail:
-        ata_dev_printk(dev, KERN_ERR,
-                       "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
-                       reason, err_mask);
+        ata_dev_err(dev,
+                    "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
+                    reason, err_mask);
         return rc;
 }
 
@@ -485,20 +484,17 @@ int sata_pmp_attach(struct ata_device *dev)
 
         /* is it hanging off the right place? */
         if (!sata_pmp_supported(ap)) {
-                ata_dev_printk(dev, KERN_ERR,
-                               "host does not support Port Multiplier\n");
+                ata_dev_err(dev, "host does not support Port Multiplier\n");
                 return -EINVAL;
         }
 
         if (!ata_is_host_link(link)) {
-                ata_dev_printk(dev, KERN_ERR,
-                               "Port Multipliers cannot be nested\n");
+                ata_dev_err(dev, "Port Multipliers cannot be nested\n");
                 return -EINVAL;
         }
 
         if (dev->devno) {
-                ata_dev_printk(dev, KERN_ERR,
-                               "Port Multiplier must be the first device\n");
+                ata_dev_err(dev, "Port Multiplier must be the first device\n");
                 return -EINVAL;
         }
 
@@ -517,8 +513,7 @@ int sata_pmp_attach(struct ata_device *dev)
 
         rc = sata_pmp_init_links(ap, sata_pmp_gscr_ports(dev->gscr));
         if (rc) {
-                ata_dev_printk(dev, KERN_INFO,
-                               "failed to initialize PMP links\n");
+                ata_dev_info(dev, "failed to initialize PMP links\n");
                 goto fail;
         }
 
@@ -562,7 +557,7 @@ static void sata_pmp_detach(struct ata_device *dev)
         struct ata_link *tlink;
         unsigned long flags;
 
-        ata_dev_printk(dev, KERN_INFO, "Port Multiplier detaching\n");
+        ata_dev_info(dev, "Port Multiplier detaching\n");
 
         WARN_ON(!ata_is_host_link(link) || dev->devno ||
                 link->pmp != SATA_PMP_CTRL_PORT);
@@ -609,23 +604,23 @@ static int sata_pmp_same_pmp(struct ata_device *dev, const u32 *new_gscr)
         new_nr_ports = sata_pmp_gscr_ports(new_gscr);
 
         if (old_vendor != new_vendor) {
-                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                               "vendor mismatch '0x%x' != '0x%x'\n",
-                               old_vendor, new_vendor);
+                ata_dev_info(dev,
+                             "Port Multiplier vendor mismatch '0x%x' != '0x%x'\n",
+                             old_vendor, new_vendor);
                 return 0;
         }
 
         if (old_devid != new_devid) {
-                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                               "device ID mismatch '0x%x' != '0x%x'\n",
-                               old_devid, new_devid);
+                ata_dev_info(dev,
+                             "Port Multiplier device ID mismatch '0x%x' != '0x%x'\n",
+                             old_devid, new_devid);
                 return 0;
         }
 
         if (old_nr_ports != new_nr_ports) {
-                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                               "nr_ports mismatch '0x%x' != '0x%x'\n",
-                               old_nr_ports, new_nr_ports);
+                ata_dev_info(dev,
+                             "Port Multiplier nr_ports mismatch '0x%x' != '0x%x'\n",
+                             old_nr_ports, new_nr_ports);
                 return 0;
         }
 
@@ -691,8 +686,7 @@ static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
         return 0;
 
  fail:
-        ata_dev_printk(dev, KERN_ERR,
-                       "PMP revalidation failed (errno=%d)\n", rc);
+        ata_dev_err(dev, "PMP revalidation failed (errno=%d)\n", rc);
         DPRINTK("EXIT, rc=%d\n", rc);
         return rc;
 }
@@ -716,13 +710,14 @@ static int sata_pmp_revalidate_quick(struct ata_device *dev)
 
         err_mask = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
         if (err_mask) {
-                ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID "
-                               "(Emask=0x%x)\n", err_mask);
+                ata_dev_err(dev,
+                            "failed to read PMP product ID (Emask=0x%x)\n",
+                            err_mask);
                 return -EIO;
         }
 
         if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
-                ata_dev_printk(dev, KERN_ERR, "PMP product ID mismatch\n");
+                ata_dev_err(dev, "PMP product ID mismatch\n");
                 /* something weird is going on, request full PMP recovery */
                 return -EIO;
         }
@@ -777,8 +772,7 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
                 rc = ata_eh_reset(link, 0, prereset, softreset, hardreset,
                                   postreset);
                 if (rc) {
-                        ata_link_printk(link, KERN_ERR,
-                                        "failed to reset PMP, giving up\n");
+                        ata_link_err(link, "failed to reset PMP, giving up\n");
                         goto fail;
                 }
 
@@ -819,9 +813,9 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
                         ehc->i.action |= ATA_EH_RESET;
                         goto retry;
                 } else {
-                        ata_dev_printk(dev, KERN_ERR, "failed to recover PMP "
-                                       "after %d tries, giving up\n",
-                                       ATA_EH_PMP_TRIES);
+                        ata_dev_err(dev,
+                                    "failed to recover PMP after %d tries, giving up\n",
+                                    ATA_EH_PMP_TRIES);
                         goto fail;
                 }
         }
@@ -867,8 +861,9 @@ static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
                 /* unconditionally clear SError.N */
                 rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
                 if (rc) {
-                        ata_link_printk(link, KERN_ERR, "failed to clear "
-                                        "SError.N (errno=%d)\n", rc);
+                        ata_link_err(link,
+                                     "failed to clear SError.N (errno=%d)\n",
+                                     rc);
                         return rc;
                 }
 
@@ -890,7 +885,7 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
 
         /* disable this link */
         if (!(link->flags & ATA_LFLAG_DISABLED)) {
-                ata_link_printk(link, KERN_WARNING,
+                ata_link_warn(link,
                         "failed to recover link after %d tries, disabling\n",
                         ATA_EH_PMP_LINK_TRIES);
 
@@ -974,7 +969,7 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
                 err_mask = sata_pmp_write(pmp_link, SATA_PMP_GSCR_FEAT_EN,
                                           gscr[SATA_PMP_GSCR_FEAT_EN]);
                 if (err_mask) {
-                        ata_link_printk(pmp_link, KERN_WARNING,
+                        ata_link_warn(pmp_link,
                                 "failed to disable NOTIFY (err_mask=0x%x)\n",
                                 err_mask);
                         goto pmp_fail;
@@ -1018,8 +1013,9 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
                 err_mask = sata_pmp_write(pmp_link, SATA_PMP_GSCR_FEAT_EN,
                                           gscr[SATA_PMP_GSCR_FEAT_EN]);
                 if (err_mask) {
-                        ata_dev_printk(pmp_dev, KERN_ERR, "failed to write "
-                                       "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
+                        ata_dev_err(pmp_dev,
+                                    "failed to write PMP_FEAT_EN (Emask=0x%x)\n",
+                                    err_mask);
                         rc = -EIO;
                         goto pmp_fail;
                 }
@@ -1028,8 +1024,9 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
         /* check GSCR_ERROR */
         err_mask = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
         if (err_mask) {
-                ata_dev_printk(pmp_dev, KERN_ERR, "failed to read "
-                               "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask);
+                ata_dev_err(pmp_dev,
+                            "failed to read PMP_GSCR_ERROR (Emask=0x%x)\n",
+                            err_mask);
                 rc = -EIO;
                 goto pmp_fail;
         }
@@ -1043,17 +1040,16 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
                         ata_ehi_hotplugged(&link->eh_context.i);
                         cnt++;
                 } else {
-                        ata_link_printk(link, KERN_WARNING,
-                                "PHY status changed but maxed out on retries, "
-                                "giving up\n");
-                        ata_link_printk(link, KERN_WARNING,
-                                "Manully issue scan to resume this link\n");
+                        ata_link_warn(link,
+                                "PHY status changed but maxed out on retries, giving up\n");
+                        ata_link_warn(link,
+                                "Manually issue scan to resume this link\n");
                 }
         }
 
         if (cnt) {
-                ata_port_printk(ap, KERN_INFO, "PMP SError.N set for some "
-                                "ports, repeating recovery\n");
+                ata_port_info(ap,
+                        "PMP SError.N set for some ports, repeating recovery\n");
                 goto retry;
         }
 
@@ -1081,9 +1077,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
                 goto retry;
         }
 
-        ata_port_printk(ap, KERN_ERR,
-                        "failed to recover PMP after %d tries, giving up\n",
-                        ATA_EH_PMP_TRIES);
+        ata_port_err(ap, "failed to recover PMP after %d tries, giving up\n",
+                     ATA_EH_PMP_TRIES);
         sata_pmp_detach(pmp_dev);
         ata_dev_disable(pmp_dev);