ipmi: Convert printk(KERN_<level> to pr_<level>(

Use the more common logging style.

Miscellanea:

o Convert old style continuation printks without KERN_CONT to pr_cont
o Coalesce formats
o Realign arguments
o Remove unnecessary casts

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Corey Minyard <cminyard@mvista.com>

diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index 97d6856..b413383 100644 (file)
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -215,11 +215,11 @@ static int bt_start_transaction(struct si_sm_data *bt,
                return IPMI_NOT_IN_MY_STATE_ERR;
 
        if (bt_debug & BT_DEBUG_MSG) {
-               printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
-               printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
+               pr_warn("BT: +++++++++++++++++ New command\n");
+               pr_warn("BT: NetFn/LUN CMD [%d data]:", size - 2);
                for (i = 0; i < size; i ++)
-                       printk(" %02x", data[i]);
-               printk("\n");
+                       pr_cont(" %02x", data[i]);
+               pr_cont("\n");
        }
        bt->write_data[0] = size + 1;   /* all data plus seq byte */
        bt->write_data[1] = *data;      /* NetFn/LUN */
@@ -260,10 +260,10 @@ static int bt_get_result(struct si_sm_data *bt,
                memcpy(data + 2, bt->read_data + 4, msg_len - 2);
 
        if (bt_debug & BT_DEBUG_MSG) {
-               printk(KERN_WARNING "BT: result %d bytes:", msg_len);
+               pr_warn("BT: result %d bytes:", msg_len);
                for (i = 0; i < msg_len; i++)
-                       printk(" %02x", data[i]);
-               printk("\n");
+                       pr_cont(" %02x", data[i]);
+               pr_cont("\n");
        }
        return msg_len;
 }
@@ -274,8 +274,7 @@ static int bt_get_result(struct si_sm_data *bt,
 static void reset_flags(struct si_sm_data *bt)
 {
        if (bt_debug)
-               printk(KERN_WARNING "IPMI BT: flag reset %s\n",
-                                       status2txt(BT_STATUS));
+               pr_warn("IPMI BT: flag reset %s\n", status2txt(BT_STATUS));
        if (BT_STATUS & BT_H_BUSY)
                BT_CONTROL(BT_H_BUSY);  /* force clear */
        BT_CONTROL(BT_CLR_WR_PTR);      /* always reset */
@@ -301,14 +300,13 @@ static void drain_BMC2HOST(struct si_sm_data *bt)
        BT_CONTROL(BT_B2H_ATN);         /* some BMCs are stubborn */
        BT_CONTROL(BT_CLR_RD_PTR);      /* always reset */
        if (bt_debug)
-               printk(KERN_WARNING "IPMI BT: stale response %s; ",
-                       status2txt(BT_STATUS));
+               pr_warn("IPMI BT: stale response %s; ", status2txt(BT_STATUS));
        size = BMC2HOST;
        for (i = 0; i < size ; i++)
                BMC2HOST;
        BT_CONTROL(BT_H_BUSY);          /* now clear */
        if (bt_debug)
-               printk("drained %d bytes\n", size + 1);
+               pr_cont("drained %d bytes\n", size + 1);
 }
 
 static inline void write_all_bytes(struct si_sm_data *bt)
@@ -316,11 +314,11 @@ static inline void write_all_bytes(struct si_sm_data *bt)
        int i;
 
        if (bt_debug & BT_DEBUG_MSG) {
-               printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
+               pr_warn("BT: write %d bytes seq=0x%02X",
                        bt->write_count, bt->seq);
                for (i = 0; i < bt->write_count; i++)
-                       printk(" %02x", bt->write_data[i]);
-               printk("\n");
+                       pr_cont(" %02x", bt->write_data[i]);
+               pr_cont("\n");
        }
        for (i = 0; i < bt->write_count; i++)
                HOST2BMC(bt->write_data[i]);
@@ -340,8 +338,7 @@ static inline int read_all_bytes(struct si_sm_data *bt)
 
        if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) {
                if (bt_debug & BT_DEBUG_MSG)
-                       printk(KERN_WARNING "BT: bad raw rsp len=%d\n",
-                               bt->read_count);
+                       pr_warn("BT: bad raw rsp len=%d\n", bt->read_count);
                bt->truncated = 1;
                return 1;       /* let next XACTION START clean it up */
        }
@@ -352,13 +349,12 @@ static inline int read_all_bytes(struct si_sm_data *bt)
        if (bt_debug & BT_DEBUG_MSG) {
                int max = bt->read_count;
 
-               printk(KERN_WARNING "BT: got %d bytes seq=0x%02X",
-                       max, bt->read_data[2]);
+               pr_warn("BT: got %d bytes seq=0x%02X", max, bt->read_data[2]);
                if (max > 16)
                        max = 16;
                for (i = 0; i < max; i++)
-                       printk(KERN_CONT " %02x", bt->read_data[i]);
-               printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
+                       pr_cont(" %02x", bt->read_data[i]);
+               pr_cont("%s\n", bt->read_count == max ? "" : " ...");
        }
 
        /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
@@ -368,10 +364,10 @@ static inline int read_all_bytes(struct si_sm_data *bt)
                        return 1;
 
        if (bt_debug & BT_DEBUG_MSG)
-               printk(KERN_WARNING "IPMI BT: bad packet: "
-               "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
-               bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3],
-               bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
+               pr_warn("IPMI BT: bad packet: want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
+                       bt->write_data[1] | 0x04, bt->write_data[2],
+                       bt->write_data[3],
+                       bt->read_data[1],  bt->read_data[2],  bt->read_data[3]);
        return 0;
 }
 
@@ -394,7 +390,7 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
                break;
        }
 
-       printk(KERN_WARNING "IPMI BT: %s in %s %s ",    /* open-ended line */
+       pr_warn("IPMI BT: %s in %s %s ",        /* open-ended line */
                reason, STATE2TXT, STATUS2TXT);
 
        /*
@@ -403,20 +399,20 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
         */
        (bt->error_retries)++;
        if (bt->error_retries < bt->BT_CAP_retries) {
-               printk("%d retries left\n",
+               pr_cont("%d retries left\n",
                        bt->BT_CAP_retries - bt->error_retries);
                bt->state = BT_STATE_RESTART;
                return SI_SM_CALL_WITHOUT_DELAY;
        }
 
-       printk(KERN_WARNING "failed %d retries, sending error response\n",
-              bt->BT_CAP_retries);
+       pr_warn("failed %d retries, sending error response\n",
+               bt->BT_CAP_retries);
        if (!bt->nonzero_status)
-               printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
+               pr_err("IPMI BT: stuck, try power cycle\n");
 
        /* this is most likely during insmod */
        else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) {
-               printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n");
+               pr_warn("IPMI: BT reset (takes 5 secs)\n");
                bt->state = BT_STATE_RESET1;
                return SI_SM_CALL_WITHOUT_DELAY;
        }
@@ -452,7 +448,7 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
        status = BT_STATUS;
        bt->nonzero_status |= status;
        if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
-               printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
+               pr_warn("BT: %s %s TO=%ld - %ld\n",
                        STATE2TXT,
                        STATUS2TXT,
                        bt->timeout,

diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index 1a486ae..effab11 100644 (file)
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -818,8 +818,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
 
        entry = kmalloc(sizeof(*entry), GFP_KERNEL);
        if (!entry) {
-               printk(KERN_ERR "ipmi_devintf: Unable to create the"
-                      " ipmi class device link\n");
+               pr_err("ipmi_devintf: Unable to create the ipmi class device link\n");
                return;
        }
        entry->dev = dev;
@@ -861,18 +860,18 @@ static int __init init_ipmi_devintf(void)
        if (ipmi_major < 0)
                return -EINVAL;
 
-       printk(KERN_INFO "ipmi device interface\n");
+       pr_info("ipmi device interface\n");
 
        ipmi_class = class_create(THIS_MODULE, "ipmi");
        if (IS_ERR(ipmi_class)) {
-               printk(KERN_ERR "ipmi: can't register device class\n");
+               pr_err("ipmi: can't register device class\n");
                return PTR_ERR(ipmi_class);
        }
 
        rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
        if (rv < 0) {
                class_destroy(ipmi_class);
-               printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
+               pr_err("ipmi: can't get major %d\n", ipmi_major);
                return rv;
        }
 
@@ -884,7 +883,7 @@ static int __init init_ipmi_devintf(void)
        if (rv) {
                unregister_chrdev(ipmi_major, DEVICE_NAME);
                class_destroy(ipmi_class);
-               printk(KERN_WARNING "ipmi: can't register smi watcher\n");
+               pr_warn("ipmi: can't register smi watcher\n");
                return rv;
        }
 

diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index f4ea9f4..2e7cda0 100644 (file)
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -274,8 +274,8 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
        if (kcs_debug & KCS_DEBUG_MSG) {
                printk(KERN_DEBUG "start_kcs_transaction -");
                for (i = 0; i < size; i++)
-                       printk(" %02x", (unsigned char) (data [i]));
-               printk("\n");
+                       pr_cont(" %02x", data[i]);
+               pr_cont("\n");
        }
        kcs->error_retries = 0;
        memcpy(kcs->write_data, data, size);

diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index 466a5aa..b6225bb 100644 (file)
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -132,8 +132,8 @@ static int start_smic_transaction(struct si_sm_data *smic,
        if (smic_debug & SMIC_DEBUG_MSG) {
                printk(KERN_DEBUG "start_smic_transaction -");
                for (i = 0; i < size; i++)
-                       printk(" %02x", (unsigned char) data[i]);
-               printk("\n");
+                       pr_cont(" %02x", data[i]);
+               pr_cont("\n");
        }
        smic->error_retries = 0;
        memcpy(smic->write_data, data, size);
@@ -154,8 +154,8 @@ static int smic_get_result(struct si_sm_data *smic,
        if (smic_debug & SMIC_DEBUG_MSG) {
                printk(KERN_DEBUG "smic_get result -");
                for (i = 0; i < smic->read_pos; i++)
-                       printk(" %02x", smic->read_data[i]);
-               printk("\n");
+                       pr_cont(" %02x", smic->read_data[i]);
+               pr_cont("\n");
        }
        if (length < smic->read_pos) {
                smic->read_pos = length;
@@ -212,8 +212,7 @@ static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
        (smic->error_retries)++;
        if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) {
                if (smic_debug & SMIC_DEBUG_ENABLE)
-                       printk(KERN_WARNING
-                              "ipmi_smic_drv: smic hosed: %s\n", reason);
+                       pr_warn("ipmi_smic_drv: smic hosed: %s\n", reason);
                smic->state = SMIC_HOSED;
        } else {
                smic->write_count = smic->orig_write_count;
@@ -326,8 +325,7 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
        if (smic->state != SMIC_IDLE) {
                if (smic_debug & SMIC_DEBUG_STATES)
                        printk(KERN_DEBUG
-                              "smic_event - smic->smic_timeout = %ld,"
-                              " time = %ld\n",
+                              "smic_event - smic->smic_timeout = %ld, time = %ld\n",
                               smic->smic_timeout, time);
                /*
                 * FIXME: smic_event is sometimes called with time >
@@ -347,9 +345,7 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 
        status = read_smic_status(smic);
        if (smic_debug & SMIC_DEBUG_STATES)
-               printk(KERN_DEBUG
-                      "smic_event - state = %d, flags = 0x%02x,"
-                      " status = 0x%02x\n",
+               printk(KERN_DEBUG "smic_event - state = %d, flags = 0x%02x, status = 0x%02x\n",
                       smic->state, flags, status);
 
        switch (smic->state) {
@@ -440,8 +436,8 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
                data = read_smic_data(smic);
                if (data != 0) {
                        if (smic_debug & SMIC_DEBUG_ENABLE)
-                               printk(KERN_DEBUG
-                                      "SMIC_WRITE_END: data = %02x\n", data);
+                               printk(KERN_DEBUG "SMIC_WRITE_END: data = %02x\n",
+                                      data);
                        start_error_recovery(smic,
                                             "state = SMIC_WRITE_END, "
                                             "data != SUCCESS");
@@ -520,8 +516,8 @@ static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
                /* data register holds an error code */
                if (data != 0) {
                        if (smic_debug & SMIC_DEBUG_ENABLE)
-                               printk(KERN_DEBUG
-                                      "SMIC_READ_END: data = %02x\n", data);
+                               printk(KERN_DEBUG "SMIC_READ_END: data = %02x\n",
+                                      data);
                        start_error_recovery(smic,
                                             "state = SMIC_READ_END, "
                                             "data != SUCCESS");