IB/qib: checkpatch fixes
authorMike Marciniszyn <mike.marciniszyn@intel.com>
Thu, 19 Jul 2012 13:04:25 +0000 (13:04 +0000)
committerRoland Dreier <roland@purestorage.com>
Thu, 19 Jul 2012 18:20:04 +0000 (11:20 -0700)
Elminate some simple_strto* usage.

checkpatch also noted pr_ conversations, which have been done as
recommended.  The pr_fmt() define is used to shorten line length.

Other multi-line string warnings are also elmininated.

Reviewed-by: Dean Luick <dean.luick@intel.com>
Signed-off-by: Mike Marciniszyn <mike.marciniszyn@intel.com>
Signed-off-by: Roland Dreier <roland@purestorage.com>
16 files changed:
drivers/infiniband/hw/qib/qib_diag.c
drivers/infiniband/hw/qib/qib_driver.c
drivers/infiniband/hw/qib/qib_eeprom.c
drivers/infiniband/hw/qib/qib_file_ops.c
drivers/infiniband/hw/qib/qib_fs.c
drivers/infiniband/hw/qib/qib_iba6120.c
drivers/infiniband/hw/qib/qib_iba7220.c
drivers/infiniband/hw/qib/qib_iba7322.c
drivers/infiniband/hw/qib/qib_init.c
drivers/infiniband/hw/qib/qib_intr.c
drivers/infiniband/hw/qib/qib_pcie.c
drivers/infiniband/hw/qib/qib_sd7220.c
drivers/infiniband/hw/qib/qib_sdma.c
drivers/infiniband/hw/qib/qib_sysfs.c
drivers/infiniband/hw/qib/qib_twsi.c
drivers/infiniband/hw/qib/qib_wc_x86_64.c

index 9892456..1686fd4 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2010 QLogic Corporation. All rights reserved.
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -53,6 +53,9 @@
 #include "qib.h"
 #include "qib_common.h"
 
+#undef pr_fmt
+#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
+
 /*
  * Each client that opens the diag device must read then write
  * offset 0, to prevent lossage from random cat or od. diag_state
@@ -598,8 +601,8 @@ static ssize_t qib_diagpkt_write(struct file *fp,
        }
        tmpbuf = vmalloc(plen);
        if (!tmpbuf) {
-               qib_devinfo(dd->pcidev, "Unable to allocate tmp buffer, "
-                        "failing\n");
+               qib_devinfo(dd->pcidev,
+                       "Unable to allocate tmp buffer, failing\n");
                ret = -ENOMEM;
                goto bail;
        }
@@ -693,7 +696,7 @@ int qib_register_observer(struct qib_devdata *dd,
        ret = -ENOMEM;
        olp = vmalloc(sizeof *olp);
        if (!olp) {
-               printk(KERN_ERR QIB_DRV_NAME ": vmalloc for observer failed\n");
+               pr_err("vmalloc for observer failed\n");
                goto bail;
        }
        if (olp) {
index 8895cfe..e41e7f7 100644 (file)
@@ -764,8 +764,9 @@ int qib_reset_device(int unit)
        qib_devinfo(dd->pcidev, "Reset on unit %u requested\n", unit);
 
        if (!dd->kregbase || !(dd->flags & QIB_PRESENT)) {
-               qib_devinfo(dd->pcidev, "Invalid unit number %u or "
-                           "not initialized or not present\n", unit);
+               qib_devinfo(dd->pcidev,
+                       "Invalid unit number %u or not initialized or not present\n",
+                       unit);
                ret = -ENXIO;
                goto bail;
        }
@@ -802,11 +803,13 @@ int qib_reset_device(int unit)
        else
                ret = -EAGAIN;
        if (ret)
-               qib_dev_err(dd, "Reinitialize unit %u after "
-                           "reset failed with %d\n", unit, ret);
+               qib_dev_err(dd,
+                       "Reinitialize unit %u after reset failed with %d\n",
+                       unit, ret);
        else
-               qib_devinfo(dd->pcidev, "Reinitialized unit %u after "
-                           "resetting\n", unit);
+               qib_devinfo(dd->pcidev,
+                       "Reinitialized unit %u after resetting\n",
+                       unit);
 
 bail:
        return ret;
index 92d9cfe..4d5d71a 100644 (file)
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -160,10 +161,9 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
                if (oguid > bguid[7]) {
                        if (bguid[6] == 0xff) {
                                if (bguid[5] == 0xff) {
-                                       qib_dev_err(dd, "Can't set %s GUID"
-                                                   " from base, wraps to"
-                                                   " OUI!\n",
-                                                   qib_get_unit_name(t));
+                                       qib_dev_err(dd,
+                                               "Can't set %s GUID from base, wraps to OUI!\n",
+                                               qib_get_unit_name(t));
                                        dd->base_guid = 0;
                                        goto bail;
                                }
@@ -182,8 +182,9 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
        len = sizeof(struct qib_flash);
        buf = vmalloc(len);
        if (!buf) {
-               qib_dev_err(dd, "Couldn't allocate memory to read %u "
-                           "bytes from eeprom for GUID\n", len);
+               qib_dev_err(dd,
+                       "Couldn't allocate memory to read %u bytes from eeprom for GUID\n",
+                       len);
                goto bail;
        }
 
@@ -201,23 +202,25 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
 
        csum = flash_csum(ifp, 0);
        if (csum != ifp->if_csum) {
-               qib_devinfo(dd->pcidev, "Bad I2C flash checksum: "
-                        "0x%x, not 0x%x\n", csum, ifp->if_csum);
+               qib_devinfo(dd->pcidev,
+                       "Bad I2C flash checksum: 0x%x, not 0x%x\n",
+                       csum, ifp->if_csum);
                goto done;
        }
        if (*(__be64 *) ifp->if_guid == cpu_to_be64(0) ||
            *(__be64 *) ifp->if_guid == ~cpu_to_be64(0)) {
-               qib_dev_err(dd, "Invalid GUID %llx from flash; ignoring\n",
-                           *(unsigned long long *) ifp->if_guid);
+               qib_dev_err(dd,
+                       "Invalid GUID %llx from flash; ignoring\n",
+                       *(unsigned long long *) ifp->if_guid);
                /* don't allow GUID if all 0 or all 1's */
                goto done;
        }
 
        /* complain, but allow it */
        if (*(u64 *) ifp->if_guid == 0x100007511000000ULL)
-               qib_devinfo(dd->pcidev, "Warning, GUID %llx is "
-                        "default, probably not correct!\n",
-                        *(unsigned long long *) ifp->if_guid);
+               qib_devinfo(dd->pcidev,
+                       "Warning, GUID %llx is default, probably not correct!\n",
+                       *(unsigned long long *) ifp->if_guid);
 
        bguid = ifp->if_guid;
        if (!bguid[0] && !bguid[1] && !bguid[2]) {
@@ -260,8 +263,9 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
                memcpy(dd->serial, ifp->if_serial,
                       sizeof ifp->if_serial);
        if (!strstr(ifp->if_comment, "Tested successfully"))
-               qib_dev_err(dd, "Board SN %s did not pass functional "
-                           "test: %s\n", dd->serial, ifp->if_comment);
+               qib_dev_err(dd,
+                       "Board SN %s did not pass functional test: %s\n",
+                       dd->serial, ifp->if_comment);
 
        memcpy(&dd->eep_st_errs, &ifp->if_errcntp, QIB_EEP_LOG_CNT);
        /*
@@ -323,8 +327,9 @@ int qib_update_eeprom_log(struct qib_devdata *dd)
        buf = vmalloc(len);
        ret = 1;
        if (!buf) {
-               qib_dev_err(dd, "Couldn't allocate memory to read %u "
-                           "bytes from eeprom for logging\n", len);
+               qib_dev_err(dd,
+                       "Couldn't allocate memory to read %u bytes from eeprom for logging\n",
+                       len);
                goto bail;
        }
 
index a740324..faa44cb 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
- * All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -49,6 +49,9 @@
 #include "qib_common.h"
 #include "qib_user_sdma.h"
 
+#undef pr_fmt
+#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
+
 static int qib_open(struct inode *, struct file *);
 static int qib_close(struct inode *, struct file *);
 static ssize_t qib_write(struct file *, const char __user *, size_t, loff_t *);
@@ -315,8 +318,9 @@ static int qib_tid_update(struct qib_ctxtdata *rcd, struct file *fp,
        }
        if (cnt > tidcnt) {
                /* make sure it all fits in tid_pg_list */
-               qib_devinfo(dd->pcidev, "Process tried to allocate %u "
-                        "TIDs, only trying max (%u)\n", cnt, tidcnt);
+               qib_devinfo(dd->pcidev,
+                       "Process tried to allocate %u TIDs, only trying max (%u)\n",
+                       cnt, tidcnt);
                cnt = tidcnt;
        }
        pagep = (struct page **) rcd->tid_pg_list;
@@ -750,9 +754,9 @@ static int qib_mmap_mem(struct vm_area_struct *vma, struct qib_ctxtdata *rcd,
        ret = remap_pfn_range(vma, vma->vm_start, pfn,
                              len, vma->vm_page_prot);
        if (ret)
-               qib_devinfo(dd->pcidev, "%s ctxt%u mmap of %lx, %x "
-                        "bytes failed: %d\n", what, rcd->ctxt,
-                        pfn, len, ret);
+               qib_devinfo(dd->pcidev,
+                       "%s ctxt%u mmap of %lx, %x bytes failed: %d\n",
+                       what, rcd->ctxt, pfn, len, ret);
 bail:
        return ret;
 }
@@ -771,8 +775,9 @@ static int mmap_ureg(struct vm_area_struct *vma, struct qib_devdata *dd,
         */
        sz = dd->flags & QIB_HAS_HDRSUPP ? 2 * PAGE_SIZE : PAGE_SIZE;
        if ((vma->vm_end - vma->vm_start) > sz) {
-               qib_devinfo(dd->pcidev, "FAIL mmap userreg: reqlen "
-                        "%lx > PAGE\n", vma->vm_end - vma->vm_start);
+               qib_devinfo(dd->pcidev,
+                       "FAIL mmap userreg: reqlen %lx > PAGE\n",
+                       vma->vm_end - vma->vm_start);
                ret = -EFAULT;
        } else {
                phys = dd->physaddr + ureg;
@@ -802,8 +807,8 @@ static int mmap_piobufs(struct vm_area_struct *vma,
         * for it.
         */
        if ((vma->vm_end - vma->vm_start) > (piocnt * dd->palign)) {
-               qib_devinfo(dd->pcidev, "FAIL mmap piobufs: "
-                        "reqlen %lx > PAGE\n",
+               qib_devinfo(dd->pcidev,
+                       "FAIL mmap piobufs: reqlen %lx > PAGE\n",
                         vma->vm_end - vma->vm_start);
                ret = -EINVAL;
                goto bail;
@@ -847,8 +852,8 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
        size = rcd->rcvegrbuf_size;
        total_size = rcd->rcvegrbuf_chunks * size;
        if ((vma->vm_end - vma->vm_start) > total_size) {
-               qib_devinfo(dd->pcidev, "FAIL on egr bufs: "
-                        "reqlen %lx > actual %lx\n",
+               qib_devinfo(dd->pcidev,
+                       "FAIL on egr bufs: reqlen %lx > actual %lx\n",
                         vma->vm_end - vma->vm_start,
                         (unsigned long) total_size);
                ret = -EINVAL;
@@ -856,8 +861,9 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
        }
 
        if (vma->vm_flags & VM_WRITE) {
-               qib_devinfo(dd->pcidev, "Can't map eager buffers as "
-                        "writable (flags=%lx)\n", vma->vm_flags);
+               qib_devinfo(dd->pcidev,
+                       "Can't map eager buffers as writable (flags=%lx)\n",
+                       vma->vm_flags);
                ret = -EPERM;
                goto bail;
        }
@@ -1270,8 +1276,8 @@ static int setup_ctxt(struct qib_pportdata *ppd, int ctxt,
                               GFP_KERNEL);
 
        if (!rcd || !ptmp) {
-               qib_dev_err(dd, "Unable to allocate ctxtdata "
-                           "memory, failing open\n");
+               qib_dev_err(dd,
+                       "Unable to allocate ctxtdata memory, failing open\n");
                ret = -ENOMEM;
                goto bailerr;
        }
@@ -1560,10 +1566,10 @@ done_chk_sdma:
                } else if (weight == 1 &&
                        test_bit(cpumask_first(tsk_cpus_allowed(current)),
                                 qib_cpulist))
-                       qib_devinfo(dd->pcidev, "%s PID %u affinity "
-                                   "set to cpu %d; already allocated\n",
-                                   current->comm, current->pid,
-                                   cpumask_first(tsk_cpus_allowed(current)));
+                       qib_devinfo(dd->pcidev,
+                               "%s PID %u affinity set to cpu %d; already allocated\n",
+                               current->comm, current->pid,
+                               cpumask_first(tsk_cpus_allowed(current)));
        }
 
        mutex_unlock(&qib_mutex);
@@ -2185,8 +2191,7 @@ int qib_cdev_init(int minor, const char *name,
 
        cdev = cdev_alloc();
        if (!cdev) {
-               printk(KERN_ERR QIB_DRV_NAME
-                      ": Could not allocate cdev for minor %d, %s\n",
+               pr_err("Could not allocate cdev for minor %d, %s\n",
                       minor, name);
                ret = -ENOMEM;
                goto done;
@@ -2198,8 +2203,7 @@ int qib_cdev_init(int minor, const char *name,
 
        ret = cdev_add(cdev, dev, 1);
        if (ret < 0) {
-               printk(KERN_ERR QIB_DRV_NAME
-                      ": Could not add cdev for minor %d, %s (err %d)\n",
+               pr_err("Could not add cdev for minor %d, %s (err %d)\n",
                       minor, name, -ret);
                goto err_cdev;
        }
@@ -2209,8 +2213,7 @@ int qib_cdev_init(int minor, const char *name,
                goto done;
        ret = PTR_ERR(device);
        device = NULL;
-       printk(KERN_ERR QIB_DRV_NAME ": Could not create "
-              "device for minor %d, %s (err %d)\n",
+       pr_err("Could not create device for minor %d, %s (err %d)\n",
               minor, name, -ret);
 err_cdev:
        cdev_del(cdev);
@@ -2245,16 +2248,14 @@ int __init qib_dev_init(void)
 
        ret = alloc_chrdev_region(&qib_dev, 0, QIB_NMINORS, QIB_DRV_NAME);
        if (ret < 0) {
-               printk(KERN_ERR QIB_DRV_NAME ": Could not allocate "
-                      "chrdev region (err %d)\n", -ret);
+               pr_err("Could not allocate chrdev region (err %d)\n", -ret);
                goto done;
        }
 
        qib_class = class_create(THIS_MODULE, "ipath");
        if (IS_ERR(qib_class)) {
                ret = PTR_ERR(qib_class);
-               printk(KERN_ERR QIB_DRV_NAME ": Could not create "
-                      "device class (err %d)\n", -ret);
+               pr_err("Could not create device class (err %d)\n", -ret);
                unregister_chrdev_region(qib_dev, QIB_NMINORS);
        }
 
index 05e0f17..cff8a6c 100644 (file)
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -382,7 +383,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
        ret = create_file(unit, S_IFDIR|S_IRUGO|S_IXUGO, sb->s_root, &dir,
                          &simple_dir_operations, dd);
        if (ret) {
-               printk(KERN_ERR "create_file(%s) failed: %d\n", unit, ret);
+               pr_err("create_file(%s) failed: %d\n", unit, ret);
                goto bail;
        }
 
@@ -390,21 +391,21 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
        ret = create_file("counters", S_IFREG|S_IRUGO, dir, &tmp,
                          &cntr_ops[0], dd);
        if (ret) {
-               printk(KERN_ERR "create_file(%s/counters) failed: %d\n",
+               pr_err("create_file(%s/counters) failed: %d\n",
                       unit, ret);
                goto bail;
        }
        ret = create_file("counter_names", S_IFREG|S_IRUGO, dir, &tmp,
                          &cntr_ops[1], dd);
        if (ret) {
-               printk(KERN_ERR "create_file(%s/counter_names) failed: %d\n",
+               pr_err("create_file(%s/counter_names) failed: %d\n",
                       unit, ret);
                goto bail;
        }
        ret = create_file("portcounter_names", S_IFREG|S_IRUGO, dir, &tmp,
                          &portcntr_ops[0], dd);
        if (ret) {
-               printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
+               pr_err("create_file(%s/%s) failed: %d\n",
                       unit, "portcounter_names", ret);
                goto bail;
        }
@@ -416,7 +417,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
                ret = create_file(fname, S_IFREG|S_IRUGO, dir, &tmp,
                                  &portcntr_ops[i], dd);
                if (ret) {
-                       printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
+                       pr_err("create_file(%s/%s) failed: %d\n",
                                unit, fname, ret);
                        goto bail;
                }
@@ -426,7 +427,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
                ret = create_file(fname, S_IFREG|S_IRUGO, dir, &tmp,
                                  &qsfp_ops[i - 1], dd);
                if (ret) {
-                       printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
+                       pr_err("create_file(%s/%s) failed: %d\n",
                                unit, fname, ret);
                        goto bail;
                }
@@ -435,7 +436,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
        ret = create_file("flash", S_IFREG|S_IWUSR|S_IRUGO, dir, &tmp,
                          &flash_ops, dd);
        if (ret)
-               printk(KERN_ERR "create_file(%s/flash) failed: %d\n",
+               pr_err("create_file(%s/flash) failed: %d\n",
                        unit, ret);
 bail:
        return ret;
@@ -486,7 +487,7 @@ static int remove_device_files(struct super_block *sb,
 
        if (IS_ERR(dir)) {
                ret = PTR_ERR(dir);
-               printk(KERN_ERR "Lookup of %s failed\n", unit);
+               pr_err("Lookup of %s failed\n", unit);
                goto bail;
        }
 
@@ -532,7 +533,7 @@ static int qibfs_fill_super(struct super_block *sb, void *data, int silent)
 
        ret = simple_fill_super(sb, QIBFS_MAGIC, files);
        if (ret) {
-               printk(KERN_ERR "simple_fill_super failed: %d\n", ret);
+               pr_err("simple_fill_super failed: %d\n", ret);
                goto bail;
        }
 
index 4d352b9..a099ac1 100644 (file)
@@ -753,8 +753,8 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
        if (!hwerrs)
                return;
        if (hwerrs == ~0ULL) {
-               qib_dev_err(dd, "Read of hardware error status failed "
-                           "(all bits set); ignoring\n");
+               qib_dev_err(dd,
+                       "Read of hardware error status failed (all bits set); ignoring\n");
                return;
        }
        qib_stats.sps_hwerrs++;
@@ -779,13 +779,14 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
         * or it's occurred within the last 5 seconds.
         */
        if (hwerrs & ~(TXE_PIO_PARITY | RXEMEMPARITYERR_EAGERTID))
-               qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
-                        "(cleared)\n", (unsigned long long) hwerrs);
+               qib_devinfo(dd->pcidev,
+                       "Hardware error: hwerr=0x%llx (cleared)\n",
+                       (unsigned long long) hwerrs);
 
        if (hwerrs & ~IB_HWE_BITSEXTANT)
-               qib_dev_err(dd, "hwerror interrupt with unknown errors "
-                           "%llx set\n", (unsigned long long)
-                           (hwerrs & ~IB_HWE_BITSEXTANT));
+               qib_dev_err(dd,
+                       "hwerror interrupt with unknown errors %llx set\n",
+                       (unsigned long long)(hwerrs & ~IB_HWE_BITSEXTANT));
 
        ctrl = qib_read_kreg32(dd, kr_control);
        if ((ctrl & QLOGIC_IB_C_FREEZEMODE) && !dd->diag_client) {
@@ -815,8 +816,9 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
 
        if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                isfatal = 1;
-               strlcat(msg, "[Memory BIST test failed, InfiniPath hardware"
-                       " unusable]", msgl);
+               strlcat(msg,
+                       "[Memory BIST test failed, InfiniPath hardware unusable]",
+                       msgl);
                /* ignore from now on, so disable until driver reloaded */
                dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -868,8 +870,9 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
                *msg = 0; /* recovered from all of them */
 
        if (isfatal && !dd->diag_client) {
-               qib_dev_err(dd, "Fatal Hardware Error, no longer"
-                           " usable, SN %.16s\n", dd->serial);
+               qib_dev_err(dd,
+                       "Fatal Hardware Error, no longer usable, SN %.16s\n",
+                       dd->serial);
                /*
                 * for /sys status file and user programs to print; if no
                 * trailing brace is copied, we'll know it was truncated.
@@ -1017,9 +1020,9 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
                                qib_inc_eeprom_err(dd, log_idx, 1);
 
        if (errs & ~IB_E_BITSEXTANT)
-               qib_dev_err(dd, "error interrupt with unknown errors "
-                           "%llx set\n",
-                           (unsigned long long) (errs & ~IB_E_BITSEXTANT));
+               qib_dev_err(dd,
+                       "error interrupt with unknown errors %llx set\n",
+                       (unsigned long long) (errs & ~IB_E_BITSEXTANT));
 
        if (errs & E_SUM_ERRS) {
                qib_disarm_6120_senderrbufs(ppd);
@@ -1089,8 +1092,8 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
        }
 
        if (errs & ERR_MASK(ResetNegated)) {
-               qib_dev_err(dd, "Got reset, requires re-init "
-                             "(unload and reload driver)\n");
+               qib_dev_err(dd,
+                       "Got reset, requires re-init (unload and reload driver)\n");
                dd->flags &= ~QIB_INITTED;  /* needs re-init */
                /* mark as having had error */
                *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1541,8 +1544,9 @@ static noinline void unlikely_6120_intr(struct qib_devdata *dd, u64 istat)
                qib_stats.sps_errints++;
                estat = qib_read_kreg64(dd, kr_errstatus);
                if (!estat)
-                       qib_devinfo(dd->pcidev, "error interrupt (%Lx), "
-                                "but no error bits set!\n", istat);
+                       qib_devinfo(dd->pcidev,
+                               "error interrupt (%Lx), but no error bits set!\n",
+                               istat);
                handle_6120_errors(dd, estat);
        }
 
@@ -1715,16 +1719,16 @@ static void qib_setup_6120_interrupt(struct qib_devdata *dd)
        }
 
        if (!dd->cspec->irq)
-               qib_dev_err(dd, "irq is 0, BIOS error?  Interrupts won't "
-                           "work\n");
+               qib_dev_err(dd,
+                       "irq is 0, BIOS error?  Interrupts won't work\n");
        else {
                int ret;
                ret = request_irq(dd->cspec->irq, qib_6120intr, 0,
                                  QIB_DRV_NAME, dd);
                if (ret)
-                       qib_dev_err(dd, "Couldn't setup interrupt "
-                                   "(irq=%d): %d\n", dd->cspec->irq,
-                                   ret);
+                       qib_dev_err(dd,
+                               "Couldn't setup interrupt (irq=%d): %d\n",
+                               dd->cspec->irq, ret);
        }
 }
 
@@ -1759,8 +1763,9 @@ static void pe_boardname(struct qib_devdata *dd)
                snprintf(dd->boardname, namelen, "%s", n);
 
        if (dd->majrev != 4 || !dd->minrev || dd->minrev > 2)
-               qib_dev_err(dd, "Unsupported InfiniPath hardware revision "
-                           "%u.%u!\n", dd->majrev, dd->minrev);
+               qib_dev_err(dd,
+                       "Unsupported InfiniPath hardware revision %u.%u!\n",
+                       dd->majrev, dd->minrev);
 
        snprintf(dd->boardversion, sizeof(dd->boardversion),
                 "ChipABI %u.%u, %s, InfiniPath%u %u.%u, SW Compat %u\n",
@@ -1833,8 +1838,8 @@ static int qib_6120_setup_reset(struct qib_devdata *dd)
 bail:
        if (ret) {
                if (qib_pcie_params(dd, dd->lbus_width, NULL, NULL))
-                       qib_dev_err(dd, "Reset failed to setup PCIe or "
-                                   "interrupts; continuing anyway\n");
+                       qib_dev_err(dd,
+                               "Reset failed to setup PCIe or interrupts; continuing anyway\n");
                /* clear the reset error, init error/hwerror mask */
                qib_6120_init_hwerrors(dd);
                /* for Rev2 error interrupts; nop for rev 1 */
@@ -1876,8 +1881,9 @@ static void qib_6120_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                }
                pa >>= 11;
                if (pa & ~QLOGIC_IB_RT_ADDR_MASK) {
-                       qib_dev_err(dd, "Physical page address 0x%lx "
-                                   "larger than supported\n", pa);
+                       qib_dev_err(dd,
+                               "Physical page address 0x%lx larger than supported\n",
+                               pa);
                        return;
                }
 
@@ -1941,8 +1947,9 @@ static void qib_6120_put_tid_2(struct qib_devdata *dd, u64 __iomem *tidptr,
                }
                pa >>= 11;
                if (pa & ~QLOGIC_IB_RT_ADDR_MASK) {
-                       qib_dev_err(dd, "Physical page address 0x%lx "
-                                   "larger than supported\n", pa);
+                       qib_dev_err(dd,
+                               "Physical page address 0x%lx larger than supported\n",
+                               pa);
                        return;
                }
 
@@ -2928,8 +2935,9 @@ static int qib_6120_set_loopback(struct qib_pportdata *ppd, const char *what)
                         ppd->dd->unit, ppd->port);
        } else if (!strncmp(what, "off", 3)) {
                ppd->dd->cspec->ibcctrl &= ~SYM_MASK(IBCCtrl, Loopback);
-               qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
-                           "(normal)\n", ppd->dd->unit, ppd->port);
+               qib_devinfo(ppd->dd->pcidev,
+                       "Disabling IB%u:%u IBC loopback (normal)\n",
+                       ppd->dd->unit, ppd->port);
        } else
                ret = -EINVAL;
        if (!ret) {
@@ -3186,11 +3194,10 @@ static int qib_late_6120_initreg(struct qib_devdata *dd)
        qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
        val = qib_read_kreg64(dd, kr_sendpioavailaddr);
        if (val != dd->pioavailregs_phys) {
-               qib_dev_err(dd, "Catastrophic software error, "
-                           "SendPIOAvailAddr written as %lx, "
-                           "read back as %llx\n",
-                           (unsigned long) dd->pioavailregs_phys,
-                           (unsigned long long) val);
+               qib_dev_err(dd,
+                       "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
+                       (unsigned long) dd->pioavailregs_phys,
+                       (unsigned long long) val);
                ret = -EINVAL;
        }
        return ret;
@@ -3218,8 +3225,8 @@ static int init_6120_variables(struct qib_devdata *dd)
        dd->revision = readq(&dd->kregbase[kr_revision]);
 
        if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-               qib_dev_err(dd, "Revision register read failure, "
-                           "giving up initialization\n");
+               qib_dev_err(dd,
+                       "Revision register read failure, giving up initialization\n");
                ret = -ENODEV;
                goto bail;
        }
@@ -3551,8 +3558,8 @@ struct qib_devdata *qib_init_iba6120_funcs(struct pci_dev *pdev,
                goto bail;
 
        if (qib_pcie_params(dd, 8, NULL, NULL))
-               qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
-                           "continuing anyway\n");
+               qib_dev_err(dd,
+                       "Failed to setup PCIe or interrupts; continuing anyway\n");
        dd->cspec->irq = pdev->irq; /* save IRQ */
 
        /* clear diagctrl register, in case diags were running and crashed */
index 86a0ba7..64d0ecb 100644 (file)
@@ -1111,9 +1111,9 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
                sdma_7220_errors(ppd, errs);
 
        if (errs & ~IB_E_BITSEXTANT)
-               qib_dev_err(dd, "error interrupt with unknown errors "
-                           "%llx set\n", (unsigned long long)
-                           (errs & ~IB_E_BITSEXTANT));
+               qib_dev_err(dd,
+                       "error interrupt with unknown errors %llx set\n",
+                       (unsigned long long) (errs & ~IB_E_BITSEXTANT));
 
        if (errs & E_SUM_ERRS) {
                qib_disarm_7220_senderrbufs(ppd);
@@ -1192,8 +1192,8 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
        }
 
        if (errs & ERR_MASK(ResetNegated)) {
-               qib_dev_err(dd, "Got reset, requires re-init "
-                           "(unload and reload driver)\n");
+               qib_dev_err(dd,
+                       "Got reset, requires re-init (unload and reload driver)\n");
                dd->flags &= ~QIB_INITTED;  /* needs re-init */
                /* mark as having had error */
                *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1305,8 +1305,8 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
        if (!hwerrs)
                goto bail;
        if (hwerrs == ~0ULL) {
-               qib_dev_err(dd, "Read of hardware error status failed "
-                           "(all bits set); ignoring\n");
+               qib_dev_err(dd,
+                       "Read of hardware error status failed (all bits set); ignoring\n");
                goto bail;
        }
        qib_stats.sps_hwerrs++;
@@ -1329,13 +1329,14 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
                        qib_inc_eeprom_err(dd, log_idx, 1);
        if (hwerrs & ~(TXEMEMPARITYERR_PIOBUF | TXEMEMPARITYERR_PIOPBC |
                       RXE_PARITY))
-               qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
-                        "(cleared)\n", (unsigned long long) hwerrs);
+               qib_devinfo(dd->pcidev,
+                       "Hardware error: hwerr=0x%llx (cleared)\n",
+                       (unsigned long long) hwerrs);
 
        if (hwerrs & ~IB_HWE_BITSEXTANT)
-               qib_dev_err(dd, "hwerror interrupt with unknown errors "
-                           "%llx set\n", (unsigned long long)
-                           (hwerrs & ~IB_HWE_BITSEXTANT));
+               qib_dev_err(dd,
+                       "hwerror interrupt with unknown errors %llx set\n",
+                       (unsigned long long) (hwerrs & ~IB_HWE_BITSEXTANT));
 
        if (hwerrs & QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR)
                qib_sd7220_clr_ibpar(dd);
@@ -1362,8 +1363,9 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
 
        if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                isfatal = 1;
-               strlcat(msg, "[Memory BIST test failed, "
-                       "InfiniPath hardware unusable]", msgl);
+               strlcat(msg,
+                       "[Memory BIST test failed, InfiniPath hardware unusable]",
+                       msgl);
                /* ignore from now on, so disable until driver reloaded */
                dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -1409,8 +1411,9 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
        qib_dev_err(dd, "%s hardware error\n", msg);
 
        if (isfatal && !dd->diag_client) {
-               qib_dev_err(dd, "Fatal Hardware Error, no longer"
-                           " usable, SN %.16s\n", dd->serial);
+               qib_dev_err(dd,
+                       "Fatal Hardware Error, no longer usable, SN %.16s\n",
+                       dd->serial);
                /*
                 * For /sys status file and user programs to print; if no
                 * trailing brace is copied, we'll know it was truncated.
@@ -1918,8 +1921,9 @@ static noinline void unlikely_7220_intr(struct qib_devdata *dd, u64 istat)
                qib_stats.sps_errints++;
                estat = qib_read_kreg64(dd, kr_errstatus);
                if (!estat)
-                       qib_devinfo(dd->pcidev, "error interrupt (%Lx), "
-                                "but no error bits set!\n", istat);
+                       qib_devinfo(dd->pcidev,
+                               "error interrupt (%Lx), but no error bits set!\n",
+                               istat);
                else
                        handle_7220_errors(dd, estat);
        }
@@ -2023,17 +2027,18 @@ bail:
 static void qib_setup_7220_interrupt(struct qib_devdata *dd)
 {
        if (!dd->cspec->irq)
-               qib_dev_err(dd, "irq is 0, BIOS error?  Interrupts won't "
-                           "work\n");
+               qib_dev_err(dd,
+                       "irq is 0, BIOS error?  Interrupts won't work\n");
        else {
                int ret = request_irq(dd->cspec->irq, qib_7220intr,
                        dd->msi_lo ? 0 : IRQF_SHARED,
                        QIB_DRV_NAME, dd);
 
                if (ret)
-                       qib_dev_err(dd, "Couldn't setup %s interrupt "
-                                   "(irq=%d): %d\n", dd->msi_lo ?
-                                   "MSI" : "INTx", dd->cspec->irq, ret);
+                       qib_dev_err(dd,
+                               "Couldn't setup %s interrupt (irq=%d): %d\n",
+                               dd->msi_lo ?  "MSI" : "INTx",
+                               dd->cspec->irq, ret);
        }
 }
 
@@ -2072,9 +2077,9 @@ static void qib_7220_boardname(struct qib_devdata *dd)
                snprintf(dd->boardname, namelen, "%s", n);
 
        if (dd->majrev != 5 || !dd->minrev || dd->minrev > 2)
-               qib_dev_err(dd, "Unsupported InfiniPath hardware "
-                           "revision %u.%u!\n",
-                           dd->majrev, dd->minrev);
+               qib_dev_err(dd,
+                       "Unsupported InfiniPath hardware revision %u.%u!\n",
+                       dd->majrev, dd->minrev);
 
        snprintf(dd->boardversion, sizeof(dd->boardversion),
                 "ChipABI %u.%u, %s, InfiniPath%u %u.%u, SW Compat %u\n",
@@ -2146,8 +2151,8 @@ static int qib_setup_7220_reset(struct qib_devdata *dd)
 bail:
        if (ret) {
                if (qib_pcie_params(dd, dd->lbus_width, NULL, NULL))
-                       qib_dev_err(dd, "Reset failed to setup PCIe or "
-                                   "interrupts; continuing anyway\n");
+                       qib_dev_err(dd,
+                               "Reset failed to setup PCIe or interrupts; continuing anyway\n");
 
                /* hold IBC in reset, no sends, etc till later */
                qib_write_kreg(dd, kr_control, 0ULL);
@@ -2187,8 +2192,9 @@ static void qib_7220_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                        return;
                }
                if (chippa >= (1UL << IBA7220_TID_SZ_SHIFT)) {
-                       qib_dev_err(dd, "Physical page address 0x%lx "
-                               "larger than supported\n", pa);
+                       qib_dev_err(dd,
+                               "Physical page address 0x%lx larger than supported\n",
+                               pa);
                        return;
                }
 
@@ -2706,8 +2712,9 @@ static int qib_7220_set_loopback(struct qib_pportdata *ppd, const char *what)
                ppd->cpspec->ibcctrl &= ~SYM_MASK(IBCCtrl, Loopback);
                /* enable heart beat again */
                val = IBA7220_IBC_HRTBT_MASK << IBA7220_IBC_HRTBT_SHIFT;
-               qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
-                           "(normal)\n", ppd->dd->unit, ppd->port);
+               qib_devinfo(ppd->dd->pcidev,
+                       "Disabling IB%u:%u IBC loopback (normal)\n",
+                       ppd->dd->unit, ppd->port);
        } else
                ret = -EINVAL;
        if (!ret) {
@@ -3307,8 +3314,8 @@ static int qib_7220_intr_fallback(struct qib_devdata *dd)
        if (!dd->msi_lo)
                return 0;
 
-       qib_devinfo(dd->pcidev, "MSI interrupt not detected,"
-                " trying INTx interrupts\n");
+       qib_devinfo(dd->pcidev,
+               "MSI interrupt not detected, trying INTx interrupts\n");
        qib_7220_free_irq(dd);
        qib_enable_intx(dd->pcidev);
        /*
@@ -3980,11 +3987,10 @@ static int qib_late_7220_initreg(struct qib_devdata *dd)
        qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
        val = qib_read_kreg64(dd, kr_sendpioavailaddr);
        if (val != dd->pioavailregs_phys) {
-               qib_dev_err(dd, "Catastrophic software error, "
-                           "SendPIOAvailAddr written as %lx, "
-                           "read back as %llx\n",
-                           (unsigned long) dd->pioavailregs_phys,
-                           (unsigned long long) val);
+               qib_dev_err(dd,
+                       "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
+                       (unsigned long) dd->pioavailregs_phys,
+                       (unsigned long long) val);
                ret = -EINVAL;
        }
        qib_register_observer(dd, &sendctrl_observer);
@@ -4014,8 +4020,8 @@ static int qib_init_7220_variables(struct qib_devdata *dd)
        dd->revision = readq(&dd->kregbase[kr_revision]);
 
        if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-               qib_dev_err(dd, "Revision register read failure, "
-                           "giving up initialization\n");
+               qib_dev_err(dd,
+                       "Revision register read failure, giving up initialization\n");
                ret = -ENODEV;
                goto bail;
        }
@@ -4613,8 +4619,8 @@ struct qib_devdata *qib_init_iba7220_funcs(struct pci_dev *pdev,
                break;
        }
        if (qib_pcie_params(dd, minwidth, NULL, NULL))
-               qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
-                           "continuing anyway\n");
+               qib_dev_err(dd,
+                       "Failed to setup PCIe or interrupts; continuing anyway\n");
 
        /* save IRQ for possible later use */
        dd->cspec->irq = pdev->irq;
index 78e8550..0d7280a 100644 (file)
@@ -52,6 +52,9 @@
 #include "qib_mad.h"
 #include "qib_verbs.h"
 
+#undef pr_fmt
+#define pr_fmt(fmt) QIB_DRV_NAME " " fmt
+
 static void qib_setup_7322_setextled(struct qib_pportdata *, u32);
 static void qib_7322_handle_hwerrors(struct qib_devdata *, char *, size_t);
 static void sendctrl_7322_mod(struct qib_pportdata *ppd, u32 op);
@@ -1577,8 +1580,8 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
        qib_stats.sps_errints++;
        errs = qib_read_kreg64(dd, kr_errstatus);
        if (!errs) {
-               qib_devinfo(dd->pcidev, "device error interrupt, "
-                        "but no error bits set!\n");
+               qib_devinfo(dd->pcidev,
+                       "device error interrupt, but no error bits set!\n");
                goto done;
        }
 
@@ -1624,8 +1627,8 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
        if (errs & QIB_E_RESET) {
                int pidx;
 
-               qib_dev_err(dd, "Got reset, requires re-init "
-                           "(unload and reload driver)\n");
+               qib_dev_err(dd,
+                       "Got reset, requires re-init (unload and reload driver)\n");
                dd->flags &= ~QIB_INITTED;  /* needs re-init */
                /* mark as having had error */
                *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1762,9 +1765,9 @@ static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
                                            ppd->dd->cspec->r1 ?
                                            QDR_STATIC_ADAPT_DOWN_R1 :
                                            QDR_STATIC_ADAPT_DOWN);
-                       printk(KERN_INFO QIB_DRV_NAME
-                               " IB%u:%u re-enabled QDR adaptation "
-                               "ibclt %x\n", ppd->dd->unit, ppd->port, ibclt);
+                       pr_info(
+                               "IB%u:%u re-enabled QDR adaptation ibclt %x\n",
+                               ppd->dd->unit, ppd->port, ibclt);
                }
        }
 }
@@ -1806,9 +1809,9 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
                if (!*msg)
                        snprintf(msg, sizeof ppd->cpspec->epmsgbuf,
                                 "no others");
-               qib_dev_porterr(dd, ppd->port, "error interrupt with unknown"
-                               " errors 0x%016Lx set (and %s)\n",
-                               (errs & ~QIB_E_P_BITSEXTANT), msg);
+               qib_dev_porterr(dd, ppd->port,
+                       "error interrupt with unknown errors 0x%016Lx set (and %s)\n",
+                       (errs & ~QIB_E_P_BITSEXTANT), msg);
                *msg = '\0';
        }
 
@@ -2026,8 +2029,8 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
        if (!hwerrs)
                goto bail;
        if (hwerrs == ~0ULL) {
-               qib_dev_err(dd, "Read of hardware error status failed "
-                           "(all bits set); ignoring\n");
+               qib_dev_err(dd,
+                       "Read of hardware error status failed (all bits set); ignoring\n");
                goto bail;
        }
        qib_stats.sps_hwerrs++;
@@ -2041,8 +2044,9 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
        /* no EEPROM logging, yet */
 
        if (hwerrs)
-               qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
-                           "(cleared)\n", (unsigned long long) hwerrs);
+               qib_devinfo(dd->pcidev,
+                       "Hardware error: hwerr=0x%llx (cleared)\n",
+                       (unsigned long long) hwerrs);
 
        ctrl = qib_read_kreg32(dd, kr_control);
        if ((ctrl & SYM_MASK(Control, FreezeMode)) && !dd->diag_client) {
@@ -2066,8 +2070,9 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
 
        if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                isfatal = 1;
-               strlcpy(msg, "[Memory BIST test failed, "
-                       "InfiniPath hardware unusable]", msgl);
+               strlcpy(msg,
+                       "[Memory BIST test failed, InfiniPath hardware unusable]",
+                       msgl);
                /* ignore from now on, so disable until driver reloaded */
                dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -2080,8 +2085,9 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
        qib_dev_err(dd, "%s hardware error\n", msg);
 
        if (isfatal && !dd->diag_client) {
-               qib_dev_err(dd, "Fatal Hardware Error, no longer"
-                           " usable, SN %.16s\n", dd->serial);
+               qib_dev_err(dd,
+                       "Fatal Hardware Error, no longer usable, SN %.16s\n",
+                       dd->serial);
                /*
                 * for /sys status file and user programs to print; if no
                 * trailing brace is copied, we'll know it was truncated.
@@ -2669,8 +2675,9 @@ static noinline void unknown_7322_ibits(struct qib_devdata *dd, u64 istat)
        char msg[128];
 
        kills = istat & ~QIB_I_BITSEXTANT;
-       qib_dev_err(dd, "Clearing reserved interrupt(s) 0x%016llx:"
-                   " %s\n", (unsigned long long) kills, msg);
+       qib_dev_err(dd,
+               "Clearing reserved interrupt(s) 0x%016llx: %s\n",
+               (unsigned long long) kills, msg);
        qib_write_kreg(dd, kr_intmask, (dd->cspec->int_enable_mask & ~kills));
 }
 
@@ -3103,16 +3110,16 @@ static void qib_setup_7322_interrupt(struct qib_devdata *dd, int clearpend)
                /* Try to get INTx interrupt */
 try_intx:
                if (!dd->pcidev->irq) {
-                       qib_dev_err(dd, "irq is 0, BIOS error?  "
-                                   "Interrupts won't work\n");
+                       qib_dev_err(dd,
+                               "irq is 0, BIOS error?  Interrupts won't work\n");
                        goto bail;
                }
                ret = request_irq(dd->pcidev->irq, qib_7322intr,
                                  IRQF_SHARED, QIB_DRV_NAME, dd);
                if (ret) {
-                       qib_dev_err(dd, "Couldn't setup INTx "
-                                   "interrupt (irq=%d): %d\n",
-                                   dd->pcidev->irq, ret);
+                       qib_dev_err(dd,
+                               "Couldn't setup INTx interrupt (irq=%d): %d\n",
+                               dd->pcidev->irq, ret);
                        goto bail;
                }
                dd->cspec->irq = dd->pcidev->irq;
@@ -3187,8 +3194,9 @@ try_intx:
                         * Shouldn't happen since the enable said we could
                         * have as many as we are trying to setup here.
                         */
-                       qib_dev_err(dd, "Couldn't setup MSIx "
-                               "interrupt (vec=%d, irq=%d): %d\n", msixnum,
+                       qib_dev_err(dd,
+                               "Couldn't setup MSIx interrupt (vec=%d, irq=%d): %d\n",
+                               msixnum,
                                dd->cspec->msix_entries[msixnum].msix.vector,
                                ret);
                        qib_7322_nomsix(dd);
@@ -3307,8 +3315,9 @@ static unsigned qib_7322_boardname(struct qib_devdata *dd)
                 (unsigned)SYM_FIELD(dd->revision, Revision_R, SW));
 
        if (qib_singleport && (features >> PORT_SPD_CAP_SHIFT) & PORT_SPD_CAP) {
-               qib_devinfo(dd->pcidev, "IB%u: Forced to single port mode"
-                           " by module parameter\n", dd->unit);
+               qib_devinfo(dd->pcidev,
+                       "IB%u: Forced to single port mode by module parameter\n",
+                       dd->unit);
                features &= PORT_SPD_CAP;
        }
 
@@ -3402,8 +3411,8 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
                if (val == dd->revision)
                        break;
                if (i == 5) {
-                       qib_dev_err(dd, "Failed to initialize after reset, "
-                                   "unusable\n");
+                       qib_dev_err(dd,
+                               "Failed to initialize after reset, unusable\n");
                        ret = 0;
                        goto  bail;
                }
@@ -3434,8 +3443,8 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
        if (qib_pcie_params(dd, dd->lbus_width,
                            &dd->cspec->num_msix_entries,
                            dd->cspec->msix_entries))
-               qib_dev_err(dd, "Reset failed to setup PCIe or interrupts; "
-                               "continuing anyway\n");
+               qib_dev_err(dd,
+                       "Reset failed to setup PCIe or interrupts; continuing anyway\n");
 
        qib_setup_7322_interrupt(dd, 1);
 
@@ -3476,8 +3485,9 @@ static void qib_7322_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                        return;
                }
                if (chippa >= (1UL << IBA7322_TID_SZ_SHIFT)) {
-                       qib_dev_err(dd, "Physical page address 0x%lx "
-                               "larger than supported\n", pa);
+                       qib_dev_err(dd,
+                               "Physical page address 0x%lx larger than supported\n",
+                               pa);
                        return;
                }
 
@@ -4031,8 +4041,9 @@ static int qib_7322_set_loopback(struct qib_pportdata *ppd, const char *what)
                                                        Loopback);
                /* enable heart beat again */
                val = IBA7322_IBC_HRTBT_RMASK << IBA7322_IBC_HRTBT_LSB;
-               qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
-                           "(normal)\n", ppd->dd->unit, ppd->port);
+               qib_devinfo(ppd->dd->pcidev,
+                       "Disabling IB%u:%u IBC loopback (normal)\n",
+                       ppd->dd->unit, ppd->port);
        } else
                ret = -EINVAL;
        if (!ret) {
@@ -4716,8 +4727,8 @@ static void init_7322_cntrnames(struct qib_devdata *dd)
                dd->pport[i].cpspec->portcntrs = kmalloc(dd->cspec->nportcntrs
                        * sizeof(u64), GFP_KERNEL);
                if (!dd->pport[i].cpspec->portcntrs)
-                       qib_dev_err(dd, "Failed allocation for"
-                                   " portcounters\n");
+                       qib_dev_err(dd,
+                               "Failed allocation for portcounters\n");
        }
 }
 
@@ -4867,8 +4878,8 @@ static int qib_7322_intr_fallback(struct qib_devdata *dd)
        if (!dd->cspec->num_msix_entries)
                return 0; /* already using INTx */
 
-       qib_devinfo(dd->pcidev, "MSIx interrupt not detected,"
-                " trying INTx interrupts\n");
+       qib_devinfo(dd->pcidev,
+               "MSIx interrupt not detected, trying INTx interrupts\n");
        qib_7322_nomsix(dd);
        qib_enable_intx(dd->pcidev);
        qib_setup_7322_interrupt(dd, 0);
@@ -5842,22 +5853,21 @@ static int setup_txselect(const char *str, struct kernel_param *kp)
 {
        struct qib_devdata *dd;
        unsigned long val;
-       char *n;
+       int ret;
+
        if (strlen(str) >= MAX_ATTEN_LEN) {
-               printk(KERN_INFO QIB_DRV_NAME " txselect_values string "
-                      "too long\n");
+               pr_info("txselect_values string too long\n");
                return -ENOSPC;
        }
-       val = simple_strtoul(str, &n, 0);
-       if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
+       ret = kstrtoul(str, 0, &val);
+       if (ret || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
                                TXDDS_MFG_SZ)) {
-               printk(KERN_INFO QIB_DRV_NAME
-                      "txselect_values must start with a number < %d\n",
+               pr_info("txselect_values must start with a number < %d\n",
                        TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ + TXDDS_MFG_SZ);
-               return -EINVAL;
+               return ret ? ret : -EINVAL;
        }
-       strcpy(txselect_list, str);
 
+       strcpy(txselect_list, str);
        list_for_each_entry(dd, &qib_dev_list, list)
                if (dd->deviceid == PCI_DEVICE_ID_QLOGIC_IB_7322)
                        set_no_qsfp_atten(dd, 1);
@@ -5880,11 +5890,10 @@ static int qib_late_7322_initreg(struct qib_devdata *dd)
        qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
        val = qib_read_kreg64(dd, kr_sendpioavailaddr);
        if (val != dd->pioavailregs_phys) {
-               qib_dev_err(dd, "Catastrophic software error, "
-                           "SendPIOAvailAddr written as %lx, "
-                           "read back as %llx\n",
-                           (unsigned long) dd->pioavailregs_phys,
-                           (unsigned long long) val);
+               qib_dev_err(dd,
+                       "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
+                       (unsigned long) dd->pioavailregs_phys,
+                       (unsigned long long) val);
                ret = -EINVAL;
        }
 
@@ -6096,8 +6105,8 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
        dd->revision = readq(&dd->kregbase[kr_revision]);
 
        if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-               qib_dev_err(dd, "Revision register read failure, "
-                           "giving up initialization\n");
+               qib_dev_err(dd,
+                       "Revision register read failure, giving up initialization\n");
                ret = -ENODEV;
                goto bail;
        }
@@ -6263,9 +6272,9 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                 */
                if (!(dd->flags & QIB_HAS_QSFP)) {
                        if (!IS_QMH(dd) && !IS_QME(dd))
-                               qib_devinfo(dd->pcidev, "IB%u:%u: "
-                                           "Unknown mezzanine card type\n",
-                                           dd->unit, ppd->port);
+                               qib_devinfo(dd->pcidev,
+                                       "IB%u:%u: Unknown mezzanine card type\n",
+                                       dd->unit, ppd->port);
                        cp->h1_val = IS_QMH(dd) ? H1_FORCE_QMH : H1_FORCE_QME;
                        /*
                         * Choose center value as default tx serdes setting
@@ -6920,8 +6929,8 @@ struct qib_devdata *qib_init_iba7322_funcs(struct pci_dev *pdev,
                dd->cspec->msix_entries[i].msix.entry = i;
 
        if (qib_pcie_params(dd, 8, &tabsize, dd->cspec->msix_entries))
-               qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
-                           "continuing anyway\n");
+               qib_dev_err(dd,
+                       "Failed to setup PCIe or interrupts; continuing anyway\n");
        /* may be less than we wanted, if not enough available */
        dd->cspec->num_msix_entries = tabsize;
 
@@ -7274,8 +7283,7 @@ static void find_best_ent(struct qib_pportdata *ppd,
                   ppd->cpspec->no_eep < (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
                                          TXDDS_MFG_SZ)) {
                idx = ppd->cpspec->no_eep - (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ);
-               printk(KERN_INFO QIB_DRV_NAME
-                       " IB%u:%u use idx %u into txdds_mfg\n",
+               pr_info("IB%u:%u use idx %u into txdds_mfg\n",
                        ppd->dd->unit, ppd->port, idx);
                *sdr_dds = &txdds_extra_mfg[idx];
                *ddr_dds = &txdds_extra_mfg[idx];
@@ -7430,11 +7438,11 @@ static void serdes_7322_los_enable(struct qib_pportdata *ppd, int enable)
        u8 state = SYM_FIELD(data, IBSerdesCtrl_0, RXLOSEN);
 
        if (enable && !state) {
-               printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS on\n",
+               pr_info("IB%u:%u Turning LOS on\n",
                        ppd->dd->unit, ppd->port);
                data |= SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
        } else if (!enable && state) {
-               printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS off\n",
+               pr_info("IB%u:%u Turning LOS off\n",
                        ppd->dd->unit, ppd->port);
                data &= ~SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
        }
@@ -7670,8 +7678,7 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
                }
        }
        if (chan_done) {
-               printk(KERN_INFO QIB_DRV_NAME
-                        " Serdes %d calibration not done after .5 sec: 0x%x\n",
+               pr_info("Serdes %d calibration not done after .5 sec: 0x%x\n",
                         IBSD(ppd->hw_pidx), chan_done);
        } else {
                for (chan = 0; chan < SERDES_CHANS; ++chan) {
@@ -7679,9 +7686,8 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
                                            (chan + (chan >> 1)),
                                            25, 0, 0);
                        if ((~rxcaldone & (u32)BMASK(10, 10)) == 0)
-                               printk(KERN_INFO QIB_DRV_NAME
-                                        " Serdes %d chan %d calibration "
-                                        "failed\n", IBSD(ppd->hw_pidx), chan);
+                               pr_info("Serdes %d chan %d calibration failed\n",
+                                       IBSD(ppd->hw_pidx), chan);
                }
        }
 
index 24ad901..4443adf 100644 (file)
 #include <linux/delay.h>
 #include <linux/idr.h>
 #include <linux/module.h>
+#include <linux/printk.h>
 
 #include "qib.h"
 #include "qib_common.h"
 #include "qib_mad.h"
 
+#undef pr_fmt
+#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
+
 /*
  * min buffers we want to have per context, after driver
  */
@@ -124,8 +128,8 @@ int qib_create_ctxts(struct qib_devdata *dd)
         */
        dd->rcd = kzalloc(sizeof(*dd->rcd) * dd->ctxtcnt, GFP_KERNEL);
        if (!dd->rcd) {
-               qib_dev_err(dd, "Unable to allocate ctxtdata array, "
-                           "failing\n");
+               qib_dev_err(dd,
+                       "Unable to allocate ctxtdata array, failing\n");
                ret = -ENOMEM;
                goto done;
        }
@@ -141,8 +145,8 @@ int qib_create_ctxts(struct qib_devdata *dd)
                ppd = dd->pport + (i % dd->num_pports);
                rcd = qib_create_ctxtdata(ppd, i);
                if (!rcd) {
-                       qib_dev_err(dd, "Unable to allocate ctxtdata"
-                                   " for Kernel ctxt, failing\n");
+                       qib_dev_err(dd,
+                               "Unable to allocate ctxtdata for Kernel ctxt, failing\n");
                        ret = -ENOMEM;
                        goto done;
                }
@@ -303,8 +307,8 @@ static int init_pioavailregs(struct qib_devdata *dd)
                &dd->pcidev->dev, PAGE_SIZE, &dd->pioavailregs_phys,
                GFP_KERNEL);
        if (!dd->pioavailregs_dma) {
-               qib_dev_err(dd, "failed to allocate PIOavail reg area "
-                           "in memory\n");
+               qib_dev_err(dd,
+                       "failed to allocate PIOavail reg area in memory\n");
                ret = -ENOMEM;
                goto done;
        }
@@ -359,15 +363,15 @@ static void init_shadow_tids(struct qib_devdata *dd)
 
        pages = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *));
        if (!pages) {
-               qib_dev_err(dd, "failed to allocate shadow page * "
-                           "array, no expected sends!\n");
+               qib_dev_err(dd,
+                       "failed to allocate shadow page * array, no expected sends!\n");
                goto bail;
        }
 
        addrs = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t));
        if (!addrs) {
-               qib_dev_err(dd, "failed to allocate shadow dma handle "
-                           "array, no expected sends!\n");
+               qib_dev_err(dd,
+                       "failed to allocate shadow dma handle array, no expected sends!\n");
                goto bail_free;
        }
 
@@ -391,13 +395,13 @@ static int loadtime_init(struct qib_devdata *dd)
 
        if (((dd->revision >> QLOGIC_IB_R_SOFTWARE_SHIFT) &
             QLOGIC_IB_R_SOFTWARE_MASK) != QIB_CHIP_SWVERSION) {
-               qib_dev_err(dd, "Driver only handles version %d, "
-                           "chip swversion is %d (%llx), failng\n",
-                           QIB_CHIP_SWVERSION,
-                           (int)(dd->revision >>
+               qib_dev_err(dd,
+                       "Driver only handles version %d, chip swversion is %d (%llx), failng\n",
+                       QIB_CHIP_SWVERSION,
+                       (int)(dd->revision >>
                                QLOGIC_IB_R_SOFTWARE_SHIFT) &
-                           QLOGIC_IB_R_SOFTWARE_MASK,
-                           (unsigned long long) dd->revision);
+                               QLOGIC_IB_R_SOFTWARE_MASK,
+                       (unsigned long long) dd->revision);
                ret = -ENOSYS;
                goto done;
        }
@@ -501,8 +505,8 @@ static void verify_interrupt(unsigned long opaque)
         */
        if (dd->int_counter == 0) {
                if (!dd->f_intr_fallback(dd))
-                       dev_err(&dd->pcidev->dev, "No interrupts detected, "
-                               "not usable.\n");
+                       dev_err(&dd->pcidev->dev,
+                               "No interrupts detected, not usable.\n");
                else /* re-arm the timer to see if fallback works */
                        mod_timer(&dd->intrchk_timer, jiffies + HZ/2);
        }
@@ -587,9 +591,8 @@ static int qib_create_workqueues(struct qib_devdata *dd)
        }
        return 0;
 wq_error:
-       pr_err(
-        QIB_DRV_NAME ": create_singlethread_workqueue failed for port %d\n",
-        pidx + 1);
+       pr_err("create_singlethread_workqueue failed for port %d\n",
+               pidx + 1);
        for (pidx = 0; pidx < dd->num_pports; ++pidx) {
                ppd = dd->pport + pidx;
                if (ppd->qib_wq) {
@@ -665,8 +668,8 @@ int qib_init(struct qib_devdata *dd, int reinit)
                if (!lastfail)
                        lastfail = qib_setup_eagerbufs(rcd);
                if (lastfail) {
-                       qib_dev_err(dd, "failed to allocate kernel ctxt's "
-                                   "rcvhdrq and/or egr bufs\n");
+                       qib_dev_err(dd,
+                               "failed to allocate kernel ctxt's rcvhdrq and/or egr bufs\n");
                        continue;
                }
        }
@@ -1016,8 +1019,7 @@ static void qib_verify_pioperf(struct qib_devdata *dd)
        /* 1 GiB/sec, slightly over IB SDR line rate */
        if (lcnt < (emsecs * 1024U))
                qib_dev_err(dd,
-                           "Performance problem: bandwidth to PIO buffers is "
-                           "only %u MiB/sec\n",
+                           "Performance problem: bandwidth to PIO buffers is only %u MiB/sec\n",
                            lcnt / (u32) emsecs);
 
        preempt_enable();
@@ -1090,8 +1092,8 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra)
                if (qib_cpulist)
                        qib_cpulist_count = count;
                else
-                       qib_early_err(&pdev->dev, "Could not alloc cpulist "
-                                     "info, cpu affinity might be wrong\n");
+                       qib_early_err(&pdev->dev,
+                               "Could not alloc cpulist info, cpu affinity might be wrong\n");
        }
 
 bail:
@@ -1180,21 +1182,20 @@ static int __init qlogic_ib_init(void)
         */
        idr_init(&qib_unit_table);
        if (!idr_pre_get(&qib_unit_table, GFP_KERNEL)) {
-               printk(KERN_ERR QIB_DRV_NAME ": idr_pre_get() failed\n");
+               pr_err("idr_pre_get() failed\n");
                ret = -ENOMEM;
                goto bail_cq_wq;
        }
 
        ret = pci_register_driver(&qib_driver);
        if (ret < 0) {
-               printk(KERN_ERR QIB_DRV_NAME
-                      ": Unable to register driver: error %d\n", -ret);
+               pr_err("Unable to register driver: error %d\n", -ret);
                goto bail_unit;
        }
 
        /* not fatal if it doesn't work */
        if (qib_init_qibfs())
-               printk(KERN_ERR QIB_DRV_NAME ": Unable to register ipathfs\n");
+               pr_err("Unable to register ipathfs\n");
        goto bail; /* all OK */
 
 bail_unit:
@@ -1218,9 +1219,9 @@ static void __exit qlogic_ib_cleanup(void)
 
        ret = qib_exit_qibfs();
        if (ret)
-               printk(KERN_ERR QIB_DRV_NAME ": "
-                       "Unable to cleanup counter filesystem: "
-                       "error %d\n", -ret);
+               pr_err(
+                       "Unable to cleanup counter filesystem: error %d\n",
+                       -ret);
 
        pci_unregister_driver(&qib_driver);
 
@@ -1360,9 +1361,9 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
 #ifdef CONFIG_PCI_MSI
                dd = qib_init_iba6120_funcs(pdev, ent);
 #else
-               qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot "
-                     "work if CONFIG_PCI_MSI is not enabled\n",
-                     ent->device);
+               qib_early_err(&pdev->dev,
+                       "QLogic PCIE device 0x%x cannot work if CONFIG_PCI_MSI is not enabled\n",
+                       ent->device);
                dd = ERR_PTR(-ENODEV);
 #endif
                break;
@@ -1376,8 +1377,9 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
                break;
 
        default:
-               qib_early_err(&pdev->dev, "Failing on unknown QLogic "
-                             "deviceid 0x%x\n", ent->device);
+               qib_early_err(&pdev->dev,
+                       "Failing on unknown QLogic deviceid 0x%x\n",
+                       ent->device);
                ret = -ENODEV;
        }
 
@@ -1434,9 +1436,9 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
        if (!qib_wc_pat) {
                ret = qib_enable_wc(dd);
                if (ret) {
-                       qib_dev_err(dd, "Write combining not enabled "
-                                   "(err %d): performance may be poor\n",
-                                   -ret);
+                       qib_dev_err(dd,
+                               "Write combining not enabled (err %d): performance may be poor\n",
+                               -ret);
                        ret = 0;
                }
        }
@@ -1502,9 +1504,9 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
                        gfp_flags | __GFP_COMP);
 
                if (!rcd->rcvhdrq) {
-                       qib_dev_err(dd, "attempt to allocate %d bytes "
-                                   "for ctxt %u rcvhdrq failed\n",
-                                   amt, rcd->ctxt);
+                       qib_dev_err(dd,
+                               "attempt to allocate %d bytes for ctxt %u rcvhdrq failed\n",
+                               amt, rcd->ctxt);
                        goto bail;
                }
 
@@ -1533,8 +1535,9 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
        return 0;
 
 bail_free:
-       qib_dev_err(dd, "attempt to allocate 1 page for ctxt %u "
-                   "rcvhdrqtailaddr failed\n", rcd->ctxt);
+       qib_dev_err(dd,
+               "attempt to allocate 1 page for ctxt %u rcvhdrqtailaddr failed\n",
+               rcd->ctxt);
        vfree(rcd->user_event_mask);
        rcd->user_event_mask = NULL;
 bail_free_hdrq:
index 6ae57d2..f4918f2 100644 (file)
@@ -224,15 +224,15 @@ void qib_bad_intrstatus(struct qib_devdata *dd)
         * We print the message and disable interrupts, in hope of
         * having a better chance of debugging the problem.
         */
-       qib_dev_err(dd, "Read of chip interrupt status failed"
-                   " disabling interrupts\n");
+       qib_dev_err(dd,
+               "Read of chip interrupt status failed disabling interrupts\n");
        if (allbits++) {
                /* disable interrupt delivery, something is very wrong */
                if (allbits == 2)
                        dd->f_set_intr_state(dd, 0);
                if (allbits == 3) {
-                       qib_dev_err(dd, "2nd bad interrupt status, "
-                                   "unregistering interrupts\n");
+                       qib_dev_err(dd,
+                               "2nd bad interrupt status, unregistering interrupts\n");
                        dd->flags |= QIB_BADINTR;
                        dd->flags &= ~QIB_INITTED;
                        dd->f_free_irq(dd);
index 4f9d918..062c301 100644 (file)
@@ -224,8 +224,9 @@ static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
        }
 do_intx:
        if (ret) {
-               qib_dev_err(dd, "pci_enable_msix %d vectors failed: %d, "
-                           "falling back to INTx\n", tabsize, ret);
+               qib_dev_err(dd,
+                       "pci_enable_msix %d vectors failed: %d, falling back to INTx\n",
+                       tabsize, ret);
                tabsize = 0;
        }
        for (i = 0; i < tabsize; i++)
@@ -251,8 +252,9 @@ static int qib_msi_setup(struct qib_devdata *dd, int pos)
 
        ret = pci_enable_msi(pdev);
        if (ret)
-               qib_dev_err(dd, "pci_enable_msi failed: %d, "
-                           "interrupts may not work\n", ret);
+               qib_dev_err(dd,
+                       "pci_enable_msi failed: %d, interrupts may not work\n",
+                       ret);
        /* continue even if it fails, we may still be OK... */
 
        pci_read_config_dword(pdev, pos + PCI_MSI_ADDRESS_LO,
@@ -358,8 +360,8 @@ int qib_reinit_intr(struct qib_devdata *dd)
 
        pos = pci_find_capability(dd->pcidev, PCI_CAP_ID_MSI);
        if (!pos) {
-               qib_dev_err(dd, "Can't find MSI capability, "
-                           "can't restore MSI settings\n");
+               qib_dev_err(dd,
+                       "Can't find MSI capability, can't restore MSI settings\n");
                ret = 0;
                /* nothing special for MSIx, just MSI */
                goto bail;
@@ -471,8 +473,8 @@ void qib_pcie_reenable(struct qib_devdata *dd, u16 cmd, u8 iline, u8 cline)
        pci_write_config_byte(dd->pcidev, PCI_CACHE_LINE_SIZE, cline);
        r = pci_enable_device(dd->pcidev);
        if (r)
-               qib_dev_err(dd, "pci_enable_device failed after "
-                           "reset: %d\n", r);
+               qib_dev_err(dd,
+                       "pci_enable_device failed after reset: %d\n", r);
 }
 
 /* code to adjust PCIe capabilities. */
@@ -717,8 +719,9 @@ qib_pci_mmio_enabled(struct pci_dev *pdev)
                if (words == ~0ULL)
                        ret = PCI_ERS_RESULT_NEED_RESET;
        }
-       qib_devinfo(pdev, "QIB mmio_enabled function called, "
-                "read wordscntr %Lx, returning %d\n", words, ret);
+       qib_devinfo(pdev,
+               "QIB mmio_enabled function called, read wordscntr %Lx, returning %d\n",
+               words, ret);
        return  ret;
 }
 
index ac065dd..a322d51 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
- * All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -342,15 +342,17 @@ static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
                ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                        IB_CTRL2(chn), 0, 0);
                if (ret < 0)
-                       qib_dev_err(dd, "Failed checking TRIMDONE, chn %d"
-                                   " (%s)\n", chn, where);
+                       qib_dev_err(dd,
+                               "Failed checking TRIMDONE, chn %d (%s)\n",
+                               chn, where);
 
                if (!(ret & 0x10)) {
                        int probe;
 
                        baduns |= (1 << chn);
-                       qib_dev_err(dd, "TRIMDONE cleared on chn %d (%02X)."
-                               " (%s)\n", chn, ret, where);
+                       qib_dev_err(dd,
+                               "TRIMDONE cleared on chn %d (%02X). (%s)\n",
+                               chn, ret, where);
                        probe = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                                IB_PGUDP(0), 0, 0);
                        qib_dev_err(dd, "probe is %d (%02X)\n",
@@ -375,8 +377,8 @@ static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
                        ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                                IB_CTRL2(chn), 0x10, 0x10);
                        if (ret < 0)
-                               qib_dev_err(dd, "Failed re-setting "
-                                       "TRIMDONE, chn %d (%s)\n",
+                               qib_dev_err(dd,
+                                       "Failed re-setting TRIMDONE, chn %d (%s)\n",
                                        chn, where);
                }
        }
@@ -1144,10 +1146,10 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                        if (ret < 0) {
                                int sloc = loc >> EPB_ADDR_SHF;
 
-                               qib_dev_err(dd, "pre-read failed: elt %d,"
-                                           " addr 0x%X, chnl %d\n",
-                                           (sloc & 0xF),
-                                           (sloc >> 9) & 0x3f, chnl);
+                               qib_dev_err(dd,
+                                       "pre-read failed: elt %d, addr 0x%X, chnl %d\n",
+                                       (sloc & 0xF),
+                                       (sloc >> 9) & 0x3f, chnl);
                                return ret;
                        }
                        val = (ret & ~mask) | (val & mask);
@@ -1157,9 +1159,9 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                if (ret < 0) {
                        int sloc = loc >> EPB_ADDR_SHF;
 
-                       qib_dev_err(dd, "Global WR failed: elt %d,"
-                                   " addr 0x%X, val %02X\n",
-                                   (sloc & 0xF), (sloc >> 9) & 0x3f, val);
+                       qib_dev_err(dd,
+                               "Global WR failed: elt %d, addr 0x%X, val %02X\n",
+                               (sloc & 0xF), (sloc >> 9) & 0x3f, val);
                }
                return ret;
        }
@@ -1173,11 +1175,10 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                if (ret < 0) {
                        int sloc = loc >> EPB_ADDR_SHF;
 
-                       qib_dev_err(dd, "Write failed: elt %d,"
-                                   " addr 0x%X, chnl %d, val 0x%02X,"
-                                   " mask 0x%02X\n",
-                                   (sloc & 0xF), (sloc >> 9) & 0x3f, chnl,
-                                   val & 0xFF, mask & 0xFF);
+                       qib_dev_err(dd,
+                               "Write failed: elt %d, addr 0x%X, chnl %d, val 0x%02X, mask 0x%02X\n",
+                               (sloc & 0xF), (sloc >> 9) & 0x3f, chnl,
+                               val & 0xFF, mask & 0xFF);
                        break;
                }
        }
index 12a9604..3fc5144 100644 (file)
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2007 - 2012 QLogic Corporation. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -276,8 +277,8 @@ static int alloc_sdma(struct qib_pportdata *ppd)
                GFP_KERNEL);
 
        if (!ppd->sdma_descq) {
-               qib_dev_err(ppd->dd, "failed to allocate SendDMA descriptor "
-                           "FIFO memory\n");
+               qib_dev_err(ppd->dd,
+                       "failed to allocate SendDMA descriptor FIFO memory\n");
                goto bail;
        }
 
@@ -285,8 +286,8 @@ static int alloc_sdma(struct qib_pportdata *ppd)
        ppd->sdma_head_dma = dma_alloc_coherent(&ppd->dd->pcidev->dev,
                PAGE_SIZE, &ppd->sdma_head_phys, GFP_KERNEL);
        if (!ppd->sdma_head_dma) {
-               qib_dev_err(ppd->dd, "failed to allocate SendDMA "
-                           "head memory\n");
+               qib_dev_err(ppd->dd,
+                       "failed to allocate SendDMA head memory\n");
                goto cleanup_descq;
        }
        ppd->sdma_head_dma[0] = 0;
index ae78305..034cc82 100644 (file)
 #include "qib.h"
 #include "qib_mad.h"
 
-/**
- * qib_parse_ushort - parse an unsigned short value in an arbitrary base
- * @str: the string containing the number
- * @valp: where to put the result
- *
- * Returns the number of bytes consumed, or negative value on error.
- */
-static int qib_parse_ushort(const char *str, unsigned short *valp)
-{
-       unsigned long val;
-       char *end;
-       int ret;
-
-       if (!isdigit(str[0])) {
-               ret = -EINVAL;
-               goto bail;
-       }
-
-       val = simple_strtoul(str, &end, 0);
-
-       if (val > 0xffff) {
-               ret = -EINVAL;
-               goto bail;
-       }
-
-       *valp = val;
-
-       ret = end + 1 - str;
-       if (ret == 0)
-               ret = -EINVAL;
-
-bail:
-       return ret;
-}
-
 /* start of per-port functions */
 /*
  * Get/Set heartbeat enable. OR of 1=enabled, 2=auto
@@ -92,7 +57,11 @@ static ssize_t store_hrtbt_enb(struct qib_pportdata *ppd, const char *buf,
        int ret;
        u16 val;
 
-       ret = qib_parse_ushort(buf, &val);
+       ret = kstrtou16(buf, 0, &val);
+       if (ret) {
+               qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
+               return ret;
+       }
 
        /*
         * Set the "intentional" heartbeat enable per either of
@@ -101,10 +70,7 @@ static ssize_t store_hrtbt_enb(struct qib_pportdata *ppd, const char *buf,
         * because entering loopback mode overrides it and automatically
         * disables heartbeat.
         */
-       if (ret >= 0)
-               ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val);
-       if (ret < 0)
-               qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
+       ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val);
        return ret < 0 ? ret : count;
 }
 
@@ -128,12 +94,14 @@ static ssize_t store_led_override(struct qib_pportdata *ppd, const char *buf,
        int ret;
        u16 val;
 
-       ret = qib_parse_ushort(buf, &val);
-       if (ret > 0)
-               qib_set_led_override(ppd, val);
-       else
+       ret = kstrtou16(buf, 0, &val);
+       if (ret) {
                qib_dev_err(dd, "attempt to set invalid LED override\n");
-       return ret < 0 ? ret : count;
+               return ret;
+       }
+
+       qib_set_led_override(ppd, val);
+       return count;
 }
 
 static ssize_t show_status(struct qib_pportdata *ppd, char *buf)
@@ -501,12 +469,12 @@ static ssize_t diagc_attr_store(struct kobject *kobj, struct attribute *attr,
        struct qib_pportdata *ppd =
                container_of(kobj, struct qib_pportdata, diagc_kobj);
        struct qib_ibport *qibp = &ppd->ibport_data;
-       char *endp;
-       long val = simple_strtol(buf, &endp, 0);
-
-       if (val < 0 || endp == buf)
-               return -EINVAL;
+       u32 val;
+       int ret;
 
+       ret = kstrtou32(buf, 0, &val);
+       if (ret)
+               return ret;
        *(u32 *)((char *) qibp + dattr->counter) = val;
        return size;
 }
@@ -739,8 +707,9 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
        int ret;
 
        if (!port_num || port_num > dd->num_pports) {
-               qib_dev_err(dd, "Skipping infiniband class with "
-                           "invalid port %u\n", port_num);
+               qib_dev_err(dd,
+                       "Skipping infiniband class with invalid port %u\n",
+                       port_num);
                ret = -ENODEV;
                goto bail;
        }
@@ -749,8 +718,9 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
        ret = kobject_init_and_add(&ppd->pport_kobj, &qib_port_ktype, kobj,
                                   "linkcontrol");
        if (ret) {
-               qib_dev_err(dd, "Skipping linkcontrol sysfs info, "
-                           "(err %d) port %u\n", ret, port_num);
+               qib_dev_err(dd,
+                       "Skipping linkcontrol sysfs info, (err %d) port %u\n",
+                       ret, port_num);
                goto bail;
        }
        kobject_uevent(&ppd->pport_kobj, KOBJ_ADD);
@@ -758,8 +728,9 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
        ret = kobject_init_and_add(&ppd->sl2vl_kobj, &qib_sl2vl_ktype, kobj,
                                   "sl2vl");
        if (ret) {
-               qib_dev_err(dd, "Skipping sl2vl sysfs info, "
-                           "(err %d) port %u\n", ret, port_num);
+               qib_dev_err(dd,
+                       "Skipping sl2vl sysfs info, (err %d) port %u\n",
+                       ret, port_num);
                goto bail_link;
        }
        kobject_uevent(&ppd->sl2vl_kobj, KOBJ_ADD);
@@ -767,8 +738,9 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
        ret = kobject_init_and_add(&ppd->diagc_kobj, &qib_diagc_ktype, kobj,
                                   "diag_counters");
        if (ret) {
-               qib_dev_err(dd, "Skipping diag_counters sysfs info, "
-                           "(err %d) port %u\n", ret, port_num);
+               qib_dev_err(dd,
+                       "Skipping diag_counters sysfs info, (err %d) port %u\n",
+                       ret, port_num);
                goto bail_sl;
        }
        kobject_uevent(&ppd->diagc_kobj, KOBJ_ADD);
index ddde72e..647f7be 100644 (file)
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -449,8 +450,9 @@ int qib_twsi_blk_wr(struct qib_devdata *dd, int dev, int addr,
                                goto failed_write;
                        ret = qib_twsi_wr(dd, addr, 0);
                        if (ret) {
-                               qib_dev_err(dd, "Failed to write interface"
-                                           " write addr %02X\n", addr);
+                               qib_dev_err(dd,
+                                       "Failed to write interface write addr %02X\n",
+                                       addr);
                                goto failed_write;
                        }
                }
index 561b8bc..1d7281c 100644 (file)
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2012 Intel Corporation. All rights reserved.
+ * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -102,10 +103,10 @@ int qib_enable_wc(struct qib_devdata *dd)
                u64 atmp;
                atmp = pioaddr & ~(piolen - 1);
                if (atmp < addr || (atmp + piolen) > (addr + len)) {
-                       qib_dev_err(dd, "No way to align address/size "
-                                   "(%llx/%llx), no WC mtrr\n",
-                                   (unsigned long long) atmp,
-                                   (unsigned long long) piolen << 1);
+                       qib_dev_err(dd,
+                               "No way to align address/size (%llx/%llx), no WC mtrr\n",
+                               (unsigned long long) atmp,
+                               (unsigned long long) piolen << 1);
                        ret = -ENODEV;
                } else {
                        pioaddr = atmp;
@@ -120,8 +121,7 @@ int qib_enable_wc(struct qib_devdata *dd)
                if (cookie < 0) {
                        {
                                qib_devinfo(dd->pcidev,
-                                        "mtrr_add()  WC for PIO bufs "
-                                        "failed (%d)\n",
+                                        "mtrr_add()  WC for PIO bufs failed (%d)\n",
                                         cookie);
                                ret = -EINVAL;
                        }