IB: Replace remaining __FUNCTION__ occurrences with __func__

__FUNCTION__ is gcc-specific, use __func__ instead.

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Roland Dreier <rolandd@cisco.com>

1 files changed, 42 insertions, 42 deletions

diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw/cxgb3/cxio_hal.c
index 03c5ff62889a..66eb7030aea8 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c
@@ -140,7 +140,7 @@ static int cxio_hal_clear_qp_ctx(struct cxio_rdev *rdev_p, u32 qpid)
         struct t3_modify_qp_wr *wqe;
         struct sk_buff *skb = alloc_skb(sizeof(*wqe), GFP_KERNEL);
         if (!skb) {
-                PDBG("%s alloc_skb failed\n", __FUNCTION__);
+                PDBG("%s alloc_skb failed\n", __func__);
                 return -ENOMEM;
         }
         wqe = (struct t3_modify_qp_wr *) skb_put(skb, sizeof(*wqe));
@@ -225,7 +225,7 @@ static u32 get_qpid(struct cxio_rdev *rdev_p, struct cxio_ucontext *uctx)
         }
 out:
         mutex_unlock(&uctx->lock);
-        PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
+        PDBG("%s qpid 0x%x\n", __func__, qpid);
         return qpid;
 }
 
@@ -237,7 +237,7 @@ static void put_qpid(struct cxio_rdev *rdev_p, u32 qpid,
         entry = kmalloc(sizeof *entry, GFP_KERNEL);
         if (!entry)
                 return;
-        PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
+        PDBG("%s qpid 0x%x\n", __func__, qpid);
         entry->qpid = qpid;
         mutex_lock(&uctx->lock);
         list_add_tail(&entry->entry, &uctx->qpids);
@@ -300,7 +300,7 @@ int cxio_create_qp(struct cxio_rdev *rdev_p, u32 kernel_domain,
         if (!kernel_domain)
                 wq->udb = (u64)rdev_p->rnic_info.udbell_physbase +
                                         (wq->qpid << rdev_p->qpshift);
-        PDBG("%s qpid 0x%x doorbell 0x%p udb 0x%llx\n", __FUNCTION__,
+        PDBG("%s qpid 0x%x doorbell 0x%p udb 0x%llx\n", __func__,
              wq->qpid, wq->doorbell, (unsigned long long) wq->udb);
         return 0;
 err4:
@@ -345,7 +345,7 @@ static void insert_recv_cqe(struct t3_wq *wq, struct t3_cq *cq)
 {
         struct t3_cqe cqe;
 
-        PDBG("%s wq %p cq %p sw_rptr 0x%x sw_wptr 0x%x\n", __FUNCTION__,
+        PDBG("%s wq %p cq %p sw_rptr 0x%x sw_wptr 0x%x\n", __func__,
              wq, cq, cq->sw_rptr, cq->sw_wptr);
         memset(&cqe, 0, sizeof(cqe));
         cqe.header = cpu_to_be32(V_CQE_STATUS(TPT_ERR_SWFLUSH) |
@@ -363,10 +363,10 @@ void cxio_flush_rq(struct t3_wq *wq, struct t3_cq *cq, int count)
 {
         u32 ptr;
 
-        PDBG("%s wq %p cq %p\n", __FUNCTION__, wq, cq);
+        PDBG("%s wq %p cq %p\n", __func__, wq, cq);
 
         /* flush RQ */
-        PDBG("%s rq_rptr %u rq_wptr %u skip count %u\n", __FUNCTION__,
+        PDBG("%s rq_rptr %u rq_wptr %u skip count %u\n", __func__,
             wq->rq_rptr, wq->rq_wptr, count);
         ptr = wq->rq_rptr + count;
         while (ptr++ != wq->rq_wptr)
@@ -378,7 +378,7 @@ static void insert_sq_cqe(struct t3_wq *wq, struct t3_cq *cq,
 {
         struct t3_cqe cqe;
 
-        PDBG("%s wq %p cq %p sw_rptr 0x%x sw_wptr 0x%x\n", __FUNCTION__,
+        PDBG("%s wq %p cq %p sw_rptr 0x%x sw_wptr 0x%x\n", __func__,
              wq, cq, cq->sw_rptr, cq->sw_wptr);
         memset(&cqe, 0, sizeof(cqe));
         cqe.header = cpu_to_be32(V_CQE_STATUS(TPT_ERR_SWFLUSH) |
@@ -415,11 +415,11 @@ void cxio_flush_hw_cq(struct t3_cq *cq)
 {
         struct t3_cqe *cqe, *swcqe;
 
-        PDBG("%s cq %p cqid 0x%x\n", __FUNCTION__, cq, cq->cqid);
+        PDBG("%s cq %p cqid 0x%x\n", __func__, cq, cq->cqid);
         cqe = cxio_next_hw_cqe(cq);
         while (cqe) {
                 PDBG("%s flushing hwcq rptr 0x%x to swcq wptr 0x%x\n",
-                     __FUNCTION__, cq->rptr, cq->sw_wptr);
+                     __func__, cq->rptr, cq->sw_wptr);
                 swcqe = cq->sw_queue + Q_PTR2IDX(cq->sw_wptr, cq->size_log2);
                 *swcqe = *cqe;
                 swcqe->header |= cpu_to_be32(V_CQE_SWCQE(1));
@@ -461,7 +461,7 @@ void cxio_count_scqes(struct t3_cq *cq, struct t3_wq *wq, int *count)
                         (*count)++;
                 ptr++;
         }
-        PDBG("%s cq %p count %d\n", __FUNCTION__, cq, *count);
+        PDBG("%s cq %p count %d\n", __func__, cq, *count);
 }
 
 void cxio_count_rcqes(struct t3_cq *cq, struct t3_wq *wq, int *count)
@@ -470,7 +470,7 @@ void cxio_count_rcqes(struct t3_cq *cq, struct t3_wq *wq, int *count)
         u32 ptr;
 
         *count = 0;
-        PDBG("%s count zero %d\n", __FUNCTION__, *count);
+        PDBG("%s count zero %d\n", __func__, *count);
         ptr = cq->sw_rptr;
         while (!Q_EMPTY(ptr, cq->sw_wptr)) {
                 cqe = cq->sw_queue + (Q_PTR2IDX(ptr, cq->size_log2));
@@ -479,7 +479,7 @@ void cxio_count_rcqes(struct t3_cq *cq, struct t3_wq *wq, int *count)
                         (*count)++;
                 ptr++;
         }
-        PDBG("%s cq %p count %d\n", __FUNCTION__, cq, *count);
+        PDBG("%s cq %p count %d\n", __func__, cq, *count);
 }
 
 static int cxio_hal_init_ctrl_cq(struct cxio_rdev *rdev_p)
@@ -506,12 +506,12 @@ static int cxio_hal_init_ctrl_qp(struct cxio_rdev *rdev_p)
 
         skb = alloc_skb(sizeof(*wqe), GFP_KERNEL);
         if (!skb) {
-                PDBG("%s alloc_skb failed\n", __FUNCTION__);
+                PDBG("%s alloc_skb failed\n", __func__);
                 return -ENOMEM;
         }
         err = cxio_hal_init_ctrl_cq(rdev_p);
         if (err) {
-                PDBG("%s err %d initializing ctrl_cq\n", __FUNCTION__, err);
+                PDBG("%s err %d initializing ctrl_cq\n", __func__, err);
                 goto err;
         }
         rdev_p->ctrl_qp.workq = dma_alloc_coherent(
@@ -521,7 +521,7 @@ static int cxio_hal_init_ctrl_qp(struct cxio_rdev *rdev_p)
                                         &(rdev_p->ctrl_qp.dma_addr),
                                         GFP_KERNEL);
         if (!rdev_p->ctrl_qp.workq) {
-                PDBG("%s dma_alloc_coherent failed\n", __FUNCTION__);
+                PDBG("%s dma_alloc_coherent failed\n", __func__);
                 err = -ENOMEM;
                 goto err;
         }
@@ -591,25 +591,25 @@ static int cxio_hal_ctrl_qp_write_mem(struct cxio_rdev *rdev_p, u32 addr,
         addr &= 0x7FFFFFF;
         nr_wqe = len % 96 ? len / 96 + 1 : len / 96;    /* 96B max per WQE */
         PDBG("%s wptr 0x%x rptr 0x%x len %d, nr_wqe %d data %p addr 0x%0x\n",
-             __FUNCTION__, rdev_p->ctrl_qp.wptr, rdev_p->ctrl_qp.rptr, len,
+             __func__, rdev_p->ctrl_qp.wptr, rdev_p->ctrl_qp.rptr, len,
              nr_wqe, data, addr);
         utx_len = 3;            /* in 32B unit */
         for (i = 0; i < nr_wqe; i++) {
                 if (Q_FULL(rdev_p->ctrl_qp.rptr, rdev_p->ctrl_qp.wptr,
                            T3_CTRL_QP_SIZE_LOG2)) {
                         PDBG("%s ctrl_qp full wtpr 0x%0x rptr 0x%0x, "
-                             "wait for more space i %d\n", __FUNCTION__,
+                             "wait for more space i %d\n", __func__,
                              rdev_p->ctrl_qp.wptr, rdev_p->ctrl_qp.rptr, i);
                         if (wait_event_interruptible(rdev_p->ctrl_qp.waitq,
                                              !Q_FULL(rdev_p->ctrl_qp.rptr,
                                                      rdev_p->ctrl_qp.wptr,
                                                      T3_CTRL_QP_SIZE_LOG2))) {
                                 PDBG("%s ctrl_qp workq interrupted\n",
-                                     __FUNCTION__);
+                                     __func__);
                                 return -ERESTARTSYS;
                         }
                         PDBG("%s ctrl_qp wakeup, continue posting work request "
-                             "i %d\n", __FUNCTION__, i);
+                             "i %d\n", __func__, i);
                 }
                 wqe = (__be64 *)(rdev_p->ctrl_qp.workq + (rdev_p->ctrl_qp.wptr %
                                                 (1 << T3_CTRL_QP_SIZE_LOG2)));
@@ -630,7 +630,7 @@ static int cxio_hal_ctrl_qp_write_mem(struct cxio_rdev *rdev_p, u32 addr,
                 if ((i != 0) &&
                     (i % (((1 << T3_CTRL_QP_SIZE_LOG2)) >> 1) == 0)) {
                         flag = T3_COMPLETION_FLAG;
-                        PDBG("%s force completion at i %d\n", __FUNCTION__, i);
+                        PDBG("%s force completion at i %d\n", __func__, i);
                 }
 
                 /* build the utx mem command */
@@ -701,7 +701,7 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
                 *stag = (stag_idx << 8) | ((*stag) & 0xFF);
         }
         PDBG("%s stag_state 0x%0x type 0x%0x pdid 0x%0x, stag_idx 0x%x\n",
-             __FUNCTION__, stag_state, type, pdid, stag_idx);
+             __func__, stag_state, type, pdid, stag_idx);
 
         if (reset_tpt_entry)
                 cxio_hal_pblpool_free(rdev_p, *pbl_addr, *pbl_size << 3);
@@ -718,7 +718,7 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
         if (pbl) {
 
                 PDBG("%s *pdb_addr 0x%x, pbl_base 0x%x, pbl_size %d\n",
-                     __FUNCTION__, *pbl_addr, rdev_p->rnic_info.pbl_base,
+                     __func__, *pbl_addr, rdev_p->rnic_info.pbl_base,
                      *pbl_size);
                 err = cxio_hal_ctrl_qp_write_mem(rdev_p,
                                 (*pbl_addr >> 5),
@@ -814,7 +814,7 @@ int cxio_rdma_init(struct cxio_rdev *rdev_p, struct t3_rdma_init_attr *attr)
         struct sk_buff *skb = alloc_skb(sizeof(*wqe), GFP_ATOMIC);
         if (!skb)
                 return -ENOMEM;
-        PDBG("%s rdev_p %p\n", __FUNCTION__, rdev_p);
+        PDBG("%s rdev_p %p\n", __func__, rdev_p);
         wqe = (struct t3_rdma_init_wr *) __skb_put(skb, sizeof(*wqe));
         wqe->wrh.op_seop_flags = cpu_to_be32(V_FW_RIWR_OP(T3_WR_INIT));
         wqe->wrh.gen_tid_len = cpu_to_be32(V_FW_RIWR_TID(attr->tid) |
@@ -856,7 +856,7 @@ static int cxio_hal_ev_handler(struct t3cdev *t3cdev_p, struct sk_buff *skb)
         struct respQ_msg_t *rsp_msg = (struct respQ_msg_t *) skb->data;
         PDBG("%d: %s cq_id 0x%x cq_ptr 0x%x genbit %0x overflow %0x an %0x"
              " se %0x notify %0x cqbranch %0x creditth %0x\n",
-             cnt, __FUNCTION__, RSPQ_CQID(rsp_msg), RSPQ_CQPTR(rsp_msg),
+             cnt, __func__, RSPQ_CQID(rsp_msg), RSPQ_CQPTR(rsp_msg),
              RSPQ_GENBIT(rsp_msg), RSPQ_OVERFLOW(rsp_msg), RSPQ_AN(rsp_msg),
              RSPQ_SE(rsp_msg), RSPQ_NOTIFY(rsp_msg), RSPQ_CQBRANCH(rsp_msg),
              RSPQ_CREDIT_THRESH(rsp_msg));
@@ -868,7 +868,7 @@ static int cxio_hal_ev_handler(struct t3cdev *t3cdev_p, struct sk_buff *skb)
              CQE_WRID_HI(rsp_msg->cqe), CQE_WRID_LOW(rsp_msg->cqe));
         rdev_p = (struct cxio_rdev *)t3cdev_p->ulp;
         if (!rdev_p) {
-                PDBG("%s called by t3cdev %p with null ulp\n", __FUNCTION__,
+                PDBG("%s called by t3cdev %p with null ulp\n", __func__,
                      t3cdev_p);
                 return 0;
         }
@@ -908,13 +908,13 @@ int cxio_rdev_open(struct cxio_rdev *rdev_p)
                 strncpy(rdev_p->dev_name, rdev_p->t3cdev_p->name,
                         T3_MAX_DEV_NAME_LEN);
         } else {
-                PDBG("%s t3cdev_p or dev_name must be set\n", __FUNCTION__);
+                PDBG("%s t3cdev_p or dev_name must be set\n", __func__);
                 return -EINVAL;
         }
 
         list_add_tail(&rdev_p->entry, &rdev_list);
 
-        PDBG("%s opening rnic dev %s\n", __FUNCTION__, rdev_p->dev_name);
+        PDBG("%s opening rnic dev %s\n", __func__, rdev_p->dev_name);
         memset(&rdev_p->ctrl_qp, 0, sizeof(rdev_p->ctrl_qp));
         if (!rdev_p->t3cdev_p)
                 rdev_p->t3cdev_p = dev2t3cdev(netdev_p);
@@ -923,14 +923,14 @@ int cxio_rdev_open(struct cxio_rdev *rdev_p)
                                          &(rdev_p->rnic_info));
         if (err) {
                 printk(KERN_ERR "%s t3cdev_p(%p)->ctl returned error %d.\n",
-                     __FUNCTION__, rdev_p->t3cdev_p, err);
+                     __func__, rdev_p->t3cdev_p, err);
                 goto err1;
         }
         err = rdev_p->t3cdev_p->ctl(rdev_p->t3cdev_p, GET_PORTS,
                                     &(rdev_p->port_info));
         if (err) {
                 printk(KERN_ERR "%s t3cdev_p(%p)->ctl returned error %d.\n",
-                     __FUNCTION__, rdev_p->t3cdev_p, err);
+                     __func__, rdev_p->t3cdev_p, err);
                 goto err1;
         }
 
@@ -947,7 +947,7 @@ int cxio_rdev_open(struct cxio_rdev *rdev_p)
         rdev_p->qpmask = (65536 >> ilog2(rdev_p->qpnr)) - 1;
         PDBG("%s rnic %s info: tpt_base 0x%0x tpt_top 0x%0x num stags %d "
              "pbl_base 0x%0x pbl_top 0x%0x rqt_base 0x%0x, rqt_top 0x%0x\n",
-             __FUNCTION__, rdev_p->dev_name, rdev_p->rnic_info.tpt_base,
+             __func__, rdev_p->dev_name, rdev_p->rnic_info.tpt_base,
              rdev_p->rnic_info.tpt_top, cxio_num_stags(rdev_p),
              rdev_p->rnic_info.pbl_base,
              rdev_p->rnic_info.pbl_top, rdev_p->rnic_info.rqt_base,
@@ -961,7 +961,7 @@ int cxio_rdev_open(struct cxio_rdev *rdev_p)
         err = cxio_hal_init_ctrl_qp(rdev_p);
         if (err) {
                 printk(KERN_ERR "%s error %d initializing ctrl_qp.\n",
-                       __FUNCTION__, err);
+                       __func__, err);
                 goto err1;
         }
         err = cxio_hal_init_resource(rdev_p, cxio_num_stags(rdev_p), 0,
@@ -969,19 +969,19 @@ int cxio_rdev_open(struct cxio_rdev *rdev_p)
                                      T3_MAX_NUM_PD);
         if (err) {
                 printk(KERN_ERR "%s error %d initializing hal resources.\n",
-                       __FUNCTION__, err);
+                       __func__, err);
                 goto err2;
         }
         err = cxio_hal_pblpool_create(rdev_p);
         if (err) {
                 printk(KERN_ERR "%s error %d initializing pbl mem pool.\n",
-                       __FUNCTION__, err);
+                       __func__, err);
                 goto err3;
         }
         err = cxio_hal_rqtpool_create(rdev_p);
         if (err) {
                 printk(KERN_ERR "%s error %d initializing rqt mem pool.\n",
-                       __FUNCTION__, err);
+                       __func__, err);
                 goto err4;
         }
         return 0;
@@ -1043,7 +1043,7 @@ static void flush_completed_wrs(struct t3_wq *wq, struct t3_cq *cq)
                          * Insert this completed cqe into the swcq.
                          */
                         PDBG("%s moving cqe into swcq sq idx %ld cq idx %ld\n",
-                             __FUNCTION__, Q_PTR2IDX(ptr,  wq->sq_size_log2),
+                             __func__, Q_PTR2IDX(ptr,  wq->sq_size_log2),
                              Q_PTR2IDX(cq->sw_wptr, cq->size_log2));
                         sqp->cqe.header |= htonl(V_CQE_SWCQE(1));
                         *(cq->sw_queue + Q_PTR2IDX(cq->sw_wptr, cq->size_log2))
@@ -1112,7 +1112,7 @@ int cxio_poll_cq(struct t3_wq *wq, struct t3_cq *cq, struct t3_cqe *cqe,
 
         PDBG("%s CQE OOO %d qpid 0x%0x genbit %d type %d status 0x%0x"
              " opcode 0x%0x len 0x%0x wrid_hi_stag 0x%x wrid_low_msn 0x%x\n",
-             __FUNCTION__, CQE_OOO(*hw_cqe), CQE_QPID(*hw_cqe),
+             __func__, CQE_OOO(*hw_cqe), CQE_QPID(*hw_cqe),
              CQE_GENBIT(*hw_cqe), CQE_TYPE(*hw_cqe), CQE_STATUS(*hw_cqe),
              CQE_OPCODE(*hw_cqe), CQE_LEN(*hw_cqe), CQE_WRID_HI(*hw_cqe),
              CQE_WRID_LOW(*hw_cqe));
@@ -1215,7 +1215,7 @@ int cxio_poll_cq(struct t3_wq *wq, struct t3_cq *cq, struct t3_cqe *cqe,
                 struct t3_swsq *sqp;
 
                 PDBG("%s out of order completion going in swsq at idx %ld\n",
-                     __FUNCTION__,
+                     __func__,
                      Q_PTR2IDX(CQE_WRID_SQ_WPTR(*hw_cqe), wq->sq_size_log2));
                 sqp = wq->sq +
                       Q_PTR2IDX(CQE_WRID_SQ_WPTR(*hw_cqe), wq->sq_size_log2);
@@ -1234,13 +1234,13 @@ proc_cqe:
          */
         if (SQ_TYPE(*hw_cqe)) {
                 wq->sq_rptr = CQE_WRID_SQ_WPTR(*hw_cqe);
-                PDBG("%s completing sq idx %ld\n", __FUNCTION__,
+                PDBG("%s completing sq idx %ld\n", __func__,
                      Q_PTR2IDX(wq->sq_rptr, wq->sq_size_log2));
                 *cookie = (wq->sq +
                            Q_PTR2IDX(wq->sq_rptr, wq->sq_size_log2))->wr_id;
                 wq->sq_rptr++;
         } else {
-                PDBG("%s completing rq idx %ld\n", __FUNCTION__,
+                PDBG("%s completing rq idx %ld\n", __func__,
                      Q_PTR2IDX(wq->rq_rptr, wq->rq_size_log2));
                 *cookie = *(wq->rq + Q_PTR2IDX(wq->rq_rptr, wq->rq_size_log2));
                 wq->rq_rptr++;
@@ -1255,11 +1255,11 @@ flush_wq:
 skip_cqe:
         if (SW_CQE(*hw_cqe)) {
                 PDBG("%s cq %p cqid 0x%x skip sw cqe sw_rptr 0x%x\n",
-                     __FUNCTION__, cq, cq->cqid, cq->sw_rptr);
+                     __func__, cq, cq->cqid, cq->sw_rptr);
                 ++cq->sw_rptr;
         } else {
                 PDBG("%s cq %p cqid 0x%x skip hw cqe rptr 0x%x\n",
-                     __FUNCTION__, cq, cq->cqid, cq->rptr);
+                     __func__, cq, cq->cqid, cq->rptr);
                 ++cq->rptr;
 
                 /*